[1.8.0] — 2026-06-01 — Code Audit: Complete Bug-Fix & Refactor Release

Full-source audit pass following v1.7.1. Every bug identified during the review has been fixed in this release. Two partially-finished refactors from the 1.7.x cycle have been completed, and dead code has been removed.

[1.7.1] — 2026-05-18 — Bug Fix Release

This release corrects five bugs identified in a full source-code audit of 1.7.0. Three of them were silent correctness failures that made advertised features behave differently from their documented intent without producing any visible error.

🔴 Critical Fixes

Fixed — LagEngine — Safe Mode FOLLOW_RANGE silently overwritten every tick

• Root cause: After SafeModeOptimizer.applySafeMode() set FOLLOW_RANGE = 4.0, the lambda in applyAiBatched() fell through to an unconditional attr.setBaseValue(attr.getDefaultValue() * multiplier) at the bottom of the loop. In CRITICAL state multiplier = 1.0, so the attribute was reset to its default value on every single tick — completely negating the FOLLOW_RANGE reduction that Safe Mode is supposed to maintain.
• Fix: Added continue immediately after safeModeOptimizer.applySafeMode(mob) to skip the unconditional setBaseValue line, matching the existing pattern used by the pathfinding-distance branch above it.
• Impact: Safe Mode now actually reduces mob target-scanning range during CRITICAL state as documented. Servers using safe-mode: true will see measurably lower entity processing cost during lag spikes.

Fixed — SafeModeOptimizer — NullPointerException crash on certain entity types

• Root cause: disableExpensiveAI() and the previous restoreAI() called mob.getAttribute(FOLLOW_RANGE).setBaseValue(...) without a null-check. getAttribute() returns null for entity types that do not expose FOLLOW_RANGE (e.g. Slime, Bat, some modded mobs), causing an unhandled NullPointerException that bubbled up through the scheduler and printed a stack trace every tick.
• Fix: Extracted the result of getAttribute() into a local variable and guarded both call sites with if (attr != null).

Fixed — SafeModeOptimizer — restoreAI() used a hardcoded FOLLOW_RANGE table

• Root cause: The previous implementation maintained an internal switch table mapping EntityType → double for the restore path. This table was incomplete (missing dozens of types) and ignored any custom attributes set by other plugins or datapacks, silently restoring the wrong range.
• Fix: Replaced the hardcoded table with attr.getDefaultValue(), which reads the actual server-side default and therefore works correctly for all entity types including custom ones.

🟡 Medium Fixes

Fixed — LagEngine — applyDifficultyScaling() had HARD and EASY inverted

• Root cause: case HARD → tps + 1.0 raised the effective TPS, causing optimizations to trigger later on Hard worlds. case EASY → tps - 1.0 lowered it, triggering optimizations earlier on Easy worlds. Both are the opposite of what the logic requires: Hard mobs pathfind more aggressively and consume more CPU; optimizations should therefore activate sooner, not later.
• Fix: Swapped the offsets — EASY → tps + 1.0, HARD → tps - 1.0.
• Impact: Servers running Hard difficulty worlds will now have mob AI throttled earlier under load, meaningfully reducing the lag window that was previously unaddressed.

Fixed — WebDashboard — Rate-limit map memory leak on long-running servers

• Root cause: rateLimitCounters and rateLimitWindows only cleared on stop(). Each unique IP that ever touched the dashboard created a permanent entry. On servers with public web dashboards, scanner/probe traffic could accumulate thousands of entries over days of uptime without any mechanism to reclaim the memory.
• Fix: At the start of each checkRateLimit() call, entries whose 60-second window has already expired are pruned via removeIf, and rateLimitCounters is kept in sync via retainAll. Cost is amortised O(n) across all incoming requests — negligible compared to the HTTP overhead of each call.

🛠️ Code Quality

Documented — LagEngine — AIThrottler field is intentionally unused

• The 1.7.0 refactor extracted AIThrottler as a separate class but did not update the applyAiBatched() call site to delegate to it. The inline throttle logic continued to run using LagEngine's own throttleCounters, leaving AIThrottler as unreachable code with its own duplicate counter map.
• This release adds an explicit NOTE comment on the field explaining why the field exists, why it is not called, and what is required before delegation can be completed safely. No behaviour change — cleanup is deferred to a dedicated refactor release.

[1.7.0] — 2026-05-01 — Major Architecture & Algorithm Improvements

🚀 Major Features

• Safe Mode for Critical State

  • Added safe-mode configuration option under critical TPS tier
  • Implemented SafeModeOptimizer to selectively disable dangerous AI components while preserving essential game mechanics
  • Prevents over-optimization that breaks villager trading, mob escaping water, and other critical behaviors

• LagEngine Refactoring

  • Extracted optimization logic into dedicated classes following Single Responsibility Principle:
    • MobCuller - Entity culling with intelligent importance scoring
    • AIThrottler - AI throttling and tick management
    • SpawnSuppressor - Spawn rate adjustment logic
  • Improved code maintainability and testability

• Event-Driven Architecture

  • Implemented EventBus pattern for decoupled optimization logic:
    • OptimizationEventBus - Central event dispatcher
    • OptimizationEvent - Event data container
    • OptimizationListener - Interface for event handlers
    • Enables plugins/addons to react to optimization state changes

• Mob Importance Scoring System

  • Created MobImportanceScorer with comprehensive importance evaluation:
    • Base scores for all entity types (bosses: 1000, villagers: 100, hostile: 10-20, etc.)
    • Dynamic scoring factors: named mobs (10x), tamed mobs (20x), equipment (1.5x)
    • Integration with MobCuller for intelligent culling decisions

• Mob Behavior Groups

  • Implemented MobBehaviorGroups system for targeted optimization:
    • PASSIVE (low priority): Cows, pigs, sheep, chickens
    • AGGRESSIVE (high priority): Zombies, skeletons, creepers
    • NEUTRAL (medium priority): Endermen, iron golems
    • SPECIAL (preserve): Villagers, bosses, named mobs
    • AQUATIC (water-based): Dolphins, guardians, squids

🧠 Algorithm Improvements

• RegionOptimizer Enhancements

  • Dynamic Region Sizing: Automatically adjusts region size based on player count
    • 0-5 players: 16 chunks (large regions)
    • 6-20 players: 8 chunks (medium regions)
    • 21-50 players: 4 chunks (small regions)
    • 50+ players: 2 chunks (very small regions)
  • Hot Region Decay: Regions gradually cool down when players leave
    • Heat decays at 5% per second when no players present
    • Prevents regions from staying hot indefinitely

• PredictiveScheduler Algorithms

  • EWMA (Exponentially Weighted Moving Average): Better short-term TPS prediction
    • Alpha smoothing factor of 0.3 for optimal responsiveness
    • Linear Regression: Trend analysis for TPS decline detection
    • Combines simple average, EWMA, and trend for robust prediction
    • More accurate lag prevention than simple hourly averages

🛠️ Configuration Management

• Annotation-Based Validation

  • @ConfigValidation annotation for field-level validation rules
  • ConfigValidator class with automatic validation on reload
  • Validates numeric ranges, required fields, and boundary warnings
  • Provides clear error messages and validation reports

• Config Migration System

  • Automatic version checking and stepwise migrations
  • Backup creation before migration with rollback capability
  • Supports migration of config.yml, features.yml, monitors.yml, systems.yml
  • Preserves user settings while updating structure

📚 Documentation

• Comprehensive Config Guide

  • CONFIG-GUIDE.md with detailed explanations for all settings
  • Usage examples, recommended values, and troubleshooting tips
  • Clear organization by functional areas

• Enhanced Config Comments

  • Added detailed explanations to all YAML configuration files
  • Section headers and inline comments for better understanding
  • Security notes and setup instructions where applicable

🔧 Code Quality Improvements

• Single Responsibility Principle

  • Each class has a single, well-defined responsibility
  • Reduced coupling between components
  • Improved testability and maintainability

• Modern Java Practices

  • Updated deprecated Bukkit method usage
  • Proper exception handling and logging
  • Thread-safe data structures where appropriate

🎯 Performance Optimizations

• Intelligent Culling

  • Prioritizes removing low-importance mobs first
  • Preserves named, tamed, and special mobs
  • Reduces impact on gameplay while maintaining server performance

• Targeted Optimization

  • Behavior-based optimization strategies
  • Different approaches for different mob types
  • More efficient than one-size-fits-all approach

🔄 Backward Compatibility

• Seamless Migration
  • Automatic config updates preserve existing functionality
  • Graceful handling of missing or corrupt configuration files
  • No breaking changes to existing setups

🐛 Bug Fixes

• Fixed Memory Leaks

  • Proper cleanup of event listeners and cached data
  • Thread-safe collections with proper synchronization

• Improved Error Handling

  • Better exception messages and logging
  • Graceful degradation when components fail
  • Validation prevents invalid configurations

[1.5.2] — 2026-04-23 — Bug Fix & Safety Patch

Fixed — plugin.yml

• Critical: wrong api-version — api-version was set to 1.5.1 (the plugin version) instead of the required Bukkit API version 1.21. Paper rejects plugins with a non-standard api-version string, causing the plugin to either fail to load or log a persistent warning on every server start. Changed to api-version: 1.21.

Fixed — WebDashboard

• Token not generated when monitors.yml is deleted or web dashboard is disabled. ensureStrongToken() was only called after the if (!webDashboardEnabled) return guard, meaning servers that had the dashboard disabled (or whose monitors.yml was deleted and recreated by saveResource) would still have the default placeholder token the first time the dashboard was enabled — a silent security hole.
  • ensureStrongToken() now runs before the enabled check on every start() call.
  • If monitors.yml does not yet exist, saveResource() is called first to create the file structure before the generated token is written into it.

Fixed — LagEngine — Culling count wrong when protected zones are present

• Protected-zone mobs were counted toward targetRemoveCount but never actually removed, causing the cull pass to under-remove and leaving entity counts above maxEntities indefinitely on servers with active zone protection.
  • cull() now pre-filters protected mobs from the candidate pool before computing targetRemoveCount, so the removal math uses only the actually-cullable mob count.
  • The redundant zone check inside the removal loop is kept as a race-condition safety net.

Fixed — LagEngine — AI update scheduler saturation on very mob-dense worlds

• No upper bound on runTaskLater calls per tick — on worlds with thousands of entities, applyAiBatched() could schedule dozens of batch tasks in a single tick, queuing more work than the scheduler could drain, leading to compounding latency.
  • Added AI_UPDATE_PER_TICK_CAP = 80: at most 80 mob AI updates are scheduled per engine tick. The next monitor tick processes the remaining mobs, spreading load evenly.

Fixed — StressTestManager — Server crash on large spawns at low-chunk-count locations

• No per-chunk mob density check — spawning 2 000+ mobs at or near the world spawn could saturate loaded chunks and crash the server within seconds.
  • Before spawning, the manager now scans a 7×7 chunk area around the target location and compares the current entity count against stress-test.max-mobs-per-chunk (default: 80).
  • If the limit would be exceeded, the spawn count is automatically reduced to the safe maximum and a warning is logged. If the area is already at capacity, the command is rejected with a descriptive error message.
• New config key in systems.yml: stress-test.max-mobs-per-chunk: 80.

Fixed — MultiServerSync — MySQL reconnect attempt logged on every polling cycle

• When the MySQL database was down for an extended period, ensureConnected() logged "MySQL connection lost — reconnecting in Xs…" on every poll interval (default every 10 s), flooding the console with hundreds of lines.
  • Reconnect log messages are now gated behind the same power-of-2 streak filter already used for SQL error warnings (logs on streak 1, 2, 4, 8, 16 …), reducing noise by up to 95% during prolonged outages while still keeping the first occurrence visible.

Config changes

# systems.yml — new in 1.5.2
stress-test:
  max-mobs-per-chunk: 80   # NEW — per-chunk density safety cap for stress tests

[1.5.1] — 2026-04-20 — Code Quality & Performance Patch

Fixed / Improved — ZoneManager

• WorldGuard region cache — getApplicableRegions() was called for every mob on every monitor tick. Queries are now cached per chunk with a 100-tick TTL (ConcurrentHashMap). Cache is invalidated automatically when TTL expires, eliminating excessive WorldGuard API pressure on large servers.
• CuboidZone coords changed from double to int — block-level precision is sufficient; int arithmetic is faster and the record is more memory-efficient.
• Zone initialize() now clears the WG cache on reload.

Fixed / Improved — ProfileManager

• Profile validation before apply — switching to a profile where critical-tps ≥ medium-tps or max-entities < 1 now returns a clear error instead of silently corrupting the engine state.
• Active profile persisted across restarts — the selected profile name is written to plugins/NeuroLag/active-profile.dat on switch and reloaded automatically on startup/reload, so profiles survive server restarts without manual re-selection.
• switchProfile() return type changed from boolean to String (null = success, "NOT_FOUND" or error message = failure) — NeuroLag main command updated accordingly.

Fixed / Improved — PredictiveScheduler

• Hand-rolled JSON parser replaced with Gson (bundled by Paper) — the previous split / replaceAll parser was fragile and could silently produce wrong data on corrupt files. Gson provides safe serialisation and clean error handling; corrupt files now log a warning instead of producing garbage hourly averages.
• Loaded samples are capped to the last 60 per hour on load, not only on record.

Fixed / Improved — CpuMonitor

• Graceful fallback for non-Sun JVMs — if com.sun.management.OperatingSystemMXBean is unavailable (GraalVM, some container JVMs), the monitor now falls back to OperatingSystemMXBean.getSystemLoadAverage() normalised by CPU count. If even that is unavailable, the feature disables itself gracefully instead of throwing at construction time.
• EMA smoothing (α = 0.3) — single-tick CPU spikes no longer toggle the throttle on/off erratically. The exponential moving average keeps the reading stable under transient load.
• Strategy (SUN_PROCESS / SYSTEM_LOAD / DISABLED) is selected once at construction and stored in an enum — no repeated instanceof checks every tick.

Fixed / Improved — RegionOptimizer

• Player chunk position cache — refresh() now tracks each player's last known chunk. The HOT/COLD region map is only rebuilt when at least one player has moved to a different chunk since the previous call. On a stable server this eliminates the full-player-scan every monitor tick.
• isBeyondPathfindingDistance() uses the cached positions instead of calling world.getPlayers() a second time per mob check.

Fixed / Improved — NeuroLagAPI

• Added NeuroLagAPI.getInstance() for cleaner third-party plugin integration.
• JSON payload sent via plugin message channel now uses Gson instead of manual StringBuilder, eliminating potential escape bugs.

Fixed / Improved — LagReporter (Discord)

• Retry with exponential back-off — Discord webhook requests are retried up to 3 times (delays: 1 s → 2 s → 4 s) before giving up. Transient network errors and Discord 429 rate-limit responses no longer silently drop notifications.
• Discord embed payload now built with Gson — no more manual string escaping.

Fixed / Improved — StressTestManager

• Confirmation prompt for spawns > 1 000 mobs — the sender must repeat the command within 30 seconds to confirm. Prevents accidental large spawns.
• Multiple entity types — stress-test.entity-types config list (default: ZOMBIE, SKELETON, CREEPER) is cycled round-robin across spawned mobs, producing a more realistic mixed load. Invalid or non-spawnable type names log a warning and are skipped.

Fixed / Improved — LagEngine

• Added internal processing metrics: lastTickMobCount and lastTickProcessingMs. Visible in /nlag status ("Last Tick: N mobs, X ms").
• ZoneManager.tick() is now called once per engine tick to advance the WG cache TTL counter.

Fixed / Improved — WebDashboard

• Rate limiting now also covers GET / (the HTML dashboard page), not only /api/* endpoints.
• Token auto-generation log output upgraded to SEVERE level and formatted as a clearly visible bordered block so admins cannot miss the new token in the console.

Fixed / Improved — ConfigManager / ConfigValidator

• Added stress-test.entity-types list field.
• ConfigValidator now checks entity-types list is non-empty when stress test is enabled.

Config changes (systems.yml)

stress-test:
  entity-types:        # NEW — 1.5.1
    - ZOMBIE
    - SKELETON
    - CREEPER

[1.5.0] — 2026-04-19 — Security Hardening & Stability Release

Fixed — Security

• [Bug #1] Web dashboard weak default token / no rate limiting / no IP filtering (WebDashboard.java, ConfigManager.java, monitors.yml)
  • Auto-generates a cryptographically strong 24-byte random token on first startup whenever the default placeholder "change-this-token-now" is detected. The new token is immediately persisted to monitors.yml and printed to the console.
  • Added per-IP rate limiting (sliding 60-second window, configurable via web-dashboard.rate-limit.max-requests-per-minute, default 60). Returns HTTP 429 when the limit is exceeded.
  • Added optional IP allow-list (web-dashboard.ip-whitelist, disabled by default). When enabled, only explicitly listed IPs can reach /api/status and /api/cmd.

Fixed — Stability

• [Bug #2] Stress test could spawn unlimited mobs with no cooldown (StressTestManager.java, ConfigManager.java, systems.yml)

  • Hard cap: mob count is clamped to stress-test.max-mob-count (default 2 000) regardless of the value passed to /nlag stresstest. The sender is notified when the cap applies.
  • Cooldown: a configurable stress-test.cooldown-seconds (default 300) must elapse between tests. Attempting to start a test during cooldown shows the remaining time.
  • Both limits are enforced by ConfigValidator.

• [Bug #3] Redis subscriber join(3000) always timed out on slow networks (MultiServerSync.java)

  • stop() now holds a volatile reference to the active JedisPubSub instance and calls pubSub.unsubscribe() before interrupt()+join(). This signals the blocking jedis.subscribe() call to return immediately, so join() completes in milliseconds rather than timing out. Prevents connection-pool leaks during rapid /nlag reload cycles.

• [Bug #4] Smart culling could remove hundreds of entities in one pass → lag spike (LagEngine.java)

  • Added CULL_PER_TICK_CAP = 50 — at most 50 entities are removed per cull invocation. If the entity count remains above max-entities-per-world after one pass, the next monitor tick handles the remainder. Eliminates the single-frame mob-removal lag spike seen on servers with thousands of entities.

• [Bug #5] Predictive scheduler lost all historical data on server restart (PredictiveScheduler.java)

  • Hourly TPS samples are now saved to plugins/NeuroLag/predictive-data.json on stop() (server shutdown or /nlag reload) and reloaded on start(). No external library required — uses a compact hand-rolled JSON serializer/parser. The predictor now accumulates knowledge across restarts and becomes effective much faster on busy servers.

• [Bug #6] Full plugin reload caused noticeable server stutter (NeuroLag.java)

  • reloadPluginState() now takes config snapshots before reloading and selectively restarts only the services whose configuration sections actually changed (web dashboard, multi-server sync, predictive scheduler, CPU monitor, boss-bar dashboard). The main monitor task and engine throttle are always restarted cleanly. On a typical /nlag reload that only changes TPS thresholds, zero external services are bounced, eliminating the stutter caused by restarting Redis/MySQL connections unnecessarily.

Changed

• ConfigValidator now validates the new stress-test limits and rate-limit settings.
• systems.yml — added stress-test.max-mob-count and stress-test.cooldown-seconds.
• monitors.yml — added web-dashboard.rate-limit and web-dashboard.ip-whitelist sections.

[1.4.1] — 2026-04-18 — Bug Fix Release

Fixed — Critical

• Task leak on reload (/nlag reload) — BackupManager.start() was called twice in onEnable() (once directly, once via startRuntimeServices()), causing every scheduled task to be registered a second time on reload. The duplicate direct call has been removed; the initial backup is now triggered asynchronously inside start() when no backups exist. stopRuntimeServices() now also calls engine.cancelAllPendingBatchTasks() before stopping the throttle task, ensuring all in-flight runTaskLater batch tasks are cancelled before any new tasks are registered. (LagEngine, NeuroLag)

• collectTargets() running every tick on the main thread — LagEngine.collectTargets() called world.getLivingEntities() on every monitor tick, causing significant lag spikes on servers with large mob populations. The result is now cached per-world and rebuilt at most once every 4 ticks (~0.2 s). The cache is invalidated on restoreAll() and on world state transitions. (LagEngine)

• FOLLOW_RANGE not fully restored for protected-zone mobs — applyAiBatched() set AI = true for protected mobs but did not always restore FOLLOW_RANGE to its default value, so mobs could permanently retain a reduced follow range after leaving a zone. The fix unconditionally calls attr.setBaseValue(attr.getDefaultValue()) for every protected mob encountered. Additionally, a new restoreWorld(World) helper is called whenever a world transitions back to NORMAL, guaranteeing a full attribute restore even for mobs that were never re-processed by the batch scheduler. (LagEngine)

• Manual override (/nlag toggle) not restoring mobs correctly — in-flight runTaskLater batch tasks scheduled by applyAiBatched() could execute after restoreAll() and re-apply AI restrictions or reduced follow ranges, leaving mobs frozen. handleToggle() now calls engine.cancelAllPendingBatchTasks() before engine.restoreAll() so no pending task survives the toggle. (LagEngine, NeuroLag)

Fixed — High

• WebDashboard query-string token auth — passing ?token=... in the URL is insecure (tokens appear in server access logs, browser history, and HTTP referrer headers). The query-string fallback is now disabled by default. A new config key web-dashboard.auth.allow-query-token (default false) must be explicitly set to true to re-enable it. The existing warning is preserved and now also states the config key needed to disable the fallback permanently. (WebDashboard, ConfigManager, monitors.yml)

• Redis subscriber thread not shutting down gracefully — MultiServerSync.stop() called redisSubThread.interrupt() but returned immediately, so the thread could still be holding a Jedis resource when jedisPool.close() ran, causing pool-exhaustion exceptions in the server log on every reload. The fix adds redisSubThread.join(3000) after interrupt(), giving the thread up to 3 seconds to exit cleanly before the pool is closed. (MultiServerSync)

• MySQL reconnect logic throwing repeatedly when DB is down — ensureConnected() called DriverManager.getConnection() immediately on every sync cycle failure, flooding the log with stack traces. The fix introduces an atomic error-streak counter and an exponential back-off (sleep time = min(streak * 2, 30) seconds before reconnect). Log output now uses a power-of-two gating strategy (log on streak 1, 2, 4, 8, 16, …) to avoid noise during prolonged outages. (MultiServerSync)

• Batched AI task delay not capped — with 5 000+ mobs the delay between batches could reach 100 ticks (5 seconds), making mobs visibly unresponsive. The delay is now capped at 20 ticks (1 second) regardless of entity count. (LagEngine)

• Smart culling could remove protected-zone mobs — the culling loop checked zoneManager.isProtected() only in the main optimization path, not inside cull() itself. Mobs inside protected zones can now never be removed by smart culling. (LagEngine)

• BackupManager not backing up the lang/ directory — the ZIP bundle only included root-level .yml files. Custom language files stored in plugins/NeuroLag/lang/ would be lost on restore. collectConfigFiles() now recursively includes lang/*.yml entries and restoreZip() correctly recreates the lang/ subdirectory on restore. (BackupManager)

[1.4.0] — Stability + lifecycle fix release

Fixed

• Removed the command-level permission wall in plugin.yml so feature-specific permissions can actually work.
• Reworked /nlag toggle so manual override now restores mobs immediately and stops active throttling instead of leaving old optimization state hanging.
• Reworked /nlag reload to stop and restart runtime services cleanly, including CPU monitor, predictive scheduler, web dashboard, backup scheduler, multi-server sync, and monitor tasks.
• Multi-server sync now clears stale peers and restarts cleanly on reload.
• Protected-zone mobs are now excluded from smart culling and have FOLLOW_RANGE restored to defaults when encountered during optimization.
• Ongoing MEDIUM and CRITICAL states now keep reapplying optimization passes on later monitor ticks, so movement into protected zones / hot zones / player zones is handled more consistently.
• Stress-test mobs no longer give themselves a custom name, so they are no longer accidentally excluded by the named-mob whitelist.
• Backup system now stores full zip bundles of NeuroLag YAML files instead of only copying config.yml.
• Added restore-by-name support for /nlag backup restore <file>.
• Memory-pressure config now normalizes legacy percentage values above 1.0, and defaults were corrected to ratio format (0.80).
• Player-scaling ratio is now clamped to avoid negative threshold offsets when online players are below the configured minimum.
• Predictive scheduler now clears parsed peak-hour ranges on restart/reload to avoid duplicate entries.
• Zone manager now fully resets cached zone and WorldGuard state when the feature is disabled or reloaded.
• Web/API JSON generation now escapes keys/values properly and uses stable decimal formatting.
• Web auth query token parsing is stricter and only logs the fallback warning once.
• CPU monitor now resets stale displayed values when stopped or disabled.
• BossBar dashboard now respects dashboard.bossbar.name and dashboard.bossbar.color from monitors.yml.
• Metrics API plugin-message registration now reads the correct split config source.

Docs

• Updated README to reflect the real split-config layout.
• Updated README examples for web-dashboard, multi-server, zone-protection, config-profiles, and backup restore.
• Updated language file version headers to v1.4.0.