ВЕРСИИ (37)

### Added - **NeoForge support on MC 26.3.** The 26 NeoForge matrix stopped at 26.2 under a "no NeoForge exists for 26.3 yet" note. It does exist (now `26.3.0.6-beta`), and the real obstacle was ModDevGradle: on 2.0.141 the NFRT `:createMinecraftArtifacts` recompile dies inside Minecraft's own source -- NeoForge's access transformer widens `HolderSet.Named.contents()` to public and the widening is not propagated to the anonymous subclass `HolderSet.emptyNamed` returns, so javac rejects the recompiled game before a line of mod source is compiled. That failure reads exactly like a broken loader, which is how it got recorded as a gap. MDG 2.0.147 builds the identical cell clean. This closes the last loader gap on the 26.3 line: Fabric and NeoForge both ship. ### Changed - **26.3 cell moved from MC 26.3-snapshot-7 to MC 26.3 (stable, 2026-09-15).** The snapshot-exclusive single-build pin is replaced by the ordinary closed prerelease-inclusive range `>=26.3- <26.4` (Fabric) / `[26.3,26.4)` (NeoForge). Resource `pack_format` `95` -> `97`, read from 26.3's own `resources/version.json`. - fabric-api `0.156.2+26.3` -> `0.161.0+26.3`, fabric-loader `0.19.3` -> `0.19.5`, NeoForge `26.3.0.6-beta`, ModDevGradle `2.0.147`. ### Notes - **No source change required.** The sleeping APIs this mod rides were re-checked: the 4-argument `startSleepInBed` (26.3-snapshot-4) and `startSleeping` going void -> boolean (26.3-snapshot-6) were already handled for the snapshot-7 jar, and nothing in the pre-1 -> release span touches them. The only `CommandSourceStack` contact is `ServerPlayer.createCommandSourceStack()`, whose own signature is unchanged, so the pre-1 constructor argument drop does not reach this mod. - The Bukkit plugin cell was NOT rebuilt and keeps 1.3.1: one plugin jar spans many MC versions through its `api-version`, so it does not follow the per-26.X model the mod jars do.

### Added - **NeoForge support on MC 26.3.** The 26 NeoForge matrix stopped at 26.2 under a "no NeoForge exists for 26.3 yet" note. It does exist (now `26.3.0.6-beta`), and the real obstacle was ModDevGradle: on 2.0.141 the NFRT `:createMinecraftArtifacts` recompile dies inside Minecraft's own source -- NeoForge's access transformer widens `HolderSet.Named.contents()` to public and the widening is not propagated to the anonymous subclass `HolderSet.emptyNamed` returns, so javac rejects the recompiled game before a line of mod source is compiled. That failure reads exactly like a broken loader, which is how it got recorded as a gap. MDG 2.0.147 builds the identical cell clean. This closes the last loader gap on the 26.3 line: Fabric and NeoForge both ship. ### Changed - **26.3 cell moved from MC 26.3-snapshot-7 to MC 26.3 (stable, 2026-09-15).** The snapshot-exclusive single-build pin is replaced by the ordinary closed prerelease-inclusive range `>=26.3- <26.4` (Fabric) / `[26.3,26.4)` (NeoForge). Resource `pack_format` `95` -> `97`, read from 26.3's own `resources/version.json`. - fabric-api `0.156.2+26.3` -> `0.161.0+26.3`, fabric-loader `0.19.3` -> `0.19.5`, NeoForge `26.3.0.6-beta`, ModDevGradle `2.0.147`. ### Notes - **No source change required.** The sleeping APIs this mod rides were re-checked: the 4-argument `startSleepInBed` (26.3-snapshot-4) and `startSleeping` going void -> boolean (26.3-snapshot-6) were already handled for the snapshot-7 jar, and nothing in the pre-1 -> release span touches them. The only `CommandSourceStack` contact is `ServerPlayer.createCommandSourceStack()`, whose own signature is unchanged, so the pre-1 constructor argument drop does not reach this mod. - The Bukkit plugin cell was NOT rebuilt and keeps 1.3.1: one plugin jar spans many MC versions through its `api-version`, so it does not follow the per-26.X model the mod jars do.

Makes the 1.3.0 catch-up observable. No behaviour change to the catch-up itself. ### Added - **`progression start` / `progression end` log lines** (INFO, once per catch-up, mod and plugin), mirroring the `ACCELERATE start` / `ACCELERATE end` pair the engine already logs: `progression start: catching up 9847 ticks over ~10s` / `progression end: applied 9847 ticks over 197 server ticks (9.9s)`. An admin who changes `progression_catchup_seconds` can now see it take effect. ### Why it exists Building the catch-up smoketest gate proved the window has **no external observable**: the random-tick boost is applied and restored INSIDE a single tick body, so a console `gamerule random_tick_speed` query -- which can only run between ticks -- reads the world's own value every time, mid-catch-up included. Sampling it measures nothing, and a permissive parser turns that nothing into numbers. Crop growth is no better: it is stochastic, and a single wheat block needs ~7 successful random ticks, which one night of catch-up does not reliably deliver. So the only honest way to assert "the night was SPREAD, not applied in one tick" is for the mod to say so. The gate now measures the window from these two lines, and the same lines are what an operator reads on a live server.

Makes the 1.3.0 catch-up observable. No behaviour change to the catch-up itself. ### Added - **`progression start` / `progression end` log lines** (INFO, once per catch-up, mod and plugin), mirroring the `ACCELERATE start` / `ACCELERATE end` pair the engine already logs: `progression start: catching up 9847 ticks over ~10s` / `progression end: applied 9847 ticks over 197 server ticks (9.9s)`. An admin who changes `progression_catchup_seconds` can now see it take effect. ### Why it exists Building the catch-up smoketest gate proved the window has **no external observable**: the random-tick boost is applied and restored INSIDE a single tick body, so a console `gamerule random_tick_speed` query -- which can only run between ticks -- reads the world's own value every time, mid-catch-up included. Sampling it measures nothing, and a permissive parser turns that nothing into numbers. Crop growth is no better: it is stochastic, and a single wheat block needs ~7 successful random ticks, which one night of catch-up does not reliably deliver. So the only honest way to assert "the night was SPREAD, not applied in one tick" is for the mod to say so. The gate now measures the window from these two lines, and the same lines are what an operator reads on a live server.

Makes the 1.3.0 catch-up observable. No behaviour change to the catch-up itself. ### Added - **`progression start` / `progression end` log lines** (INFO, once per catch-up, mod and plugin), mirroring the `ACCELERATE start` / `ACCELERATE end` pair the engine already logs: `progression start: catching up 9847 ticks over ~10s` / `progression end: applied 9847 ticks over 197 server ticks (9.9s)`. An admin who changes `progression_catchup_seconds` can now see it take effect. ### Why it exists Building the catch-up smoketest gate proved the window has **no external observable**: the random-tick boost is applied and restored INSIDE a single tick body, so a console `gamerule random_tick_speed` query -- which can only run between ticks -- reads the world's own value every time, mid-catch-up included. Sampling it measures nothing, and a permissive parser turns that nothing into numbers. Crop growth is no better: it is stochastic, and a single wheat block needs ~7 successful random ticks, which one night of catch-up does not reliably deliver. So the only honest way to assert "the night was SPREAD, not applied in one tick" is for the mod to say so. The gate now measures the window from these two lines, and the same lines are what an operator reads on a live server.

Makes the 1.3.0 catch-up observable. No behaviour change to the catch-up itself. ### Added - **`progression start` / `progression end` log lines** (INFO, once per catch-up, mod and plugin), mirroring the `ACCELERATE start` / `ACCELERATE end` pair the engine already logs: `progression start: catching up 9847 ticks over ~10s` / `progression end: applied 9847 ticks over 197 server ticks (9.9s)`. An admin who changes `progression_catchup_seconds` can now see it take effect. ### Why it exists Building the catch-up smoketest gate proved the window has **no external observable**: the random-tick boost is applied and restored INSIDE a single tick body, so a console `gamerule random_tick_speed` query -- which can only run between ticks -- reads the world's own value every time, mid-catch-up included. Sampling it measures nothing, and a permissive parser turns that nothing into numbers. Crop growth is no better: it is stochastic, and a single wheat block needs ~7 successful random ticks, which one night of catch-up does not reliably deliver. So the only honest way to assert "the night was SPREAD, not applied in one tick" is for the mod to say so. The gate now measures the window from these two lines, and the same lines are what an operator reads on a live server.

Makes the 1.3.0 catch-up observable. No behaviour change to the catch-up itself. ### Added - **`progression start` / `progression end` log lines** (INFO, once per catch-up, mod and plugin), mirroring the `ACCELERATE start` / `ACCELERATE end` pair the engine already logs: `progression start: catching up 9847 ticks over ~10s` / `progression end: applied 9847 ticks over 197 server ticks (9.9s)`. An admin who changes `progression_catchup_seconds` can now see it take effect. ### Why it exists Building the catch-up smoketest gate proved the window has **no external observable**: the random-tick boost is applied and restored INSIDE a single tick body, so a console `gamerule random_tick_speed` query -- which can only run between ticks -- reads the world's own value every time, mid-catch-up included. Sampling it measures nothing, and a permissive parser turns that nothing into numbers. Crop growth is no better: it is stochastic, and a single wheat block needs ~7 successful random ticks, which one night of catch-up does not reliably deliver. So the only honest way to assert "the night was SPREAD, not applied in one tick" is for the mod to say so. The gate now measures the window from these two lines, and the same lines are what an operator reads on a live server.

Makes the 1.3.0 catch-up observable. No behaviour change to the catch-up itself. ### Added - **`progression start` / `progression end` log lines** (INFO, once per catch-up, mod and plugin), mirroring the `ACCELERATE start` / `ACCELERATE end` pair the engine already logs: `progression start: catching up 9847 ticks over ~10s` / `progression end: applied 9847 ticks over 197 server ticks (9.9s)`. An admin who changes `progression_catchup_seconds` can now see it take effect. ### Why it exists Building the catch-up smoketest gate proved the window has **no external observable**: the random-tick boost is applied and restored INSIDE a single tick body, so a console `gamerule random_tick_speed` query -- which can only run between ticks -- reads the world's own value every time, mid-catch-up included. Sampling it measures nothing, and a permissive parser turns that nothing into numbers. Crop growth is no better: it is stochastic, and a single wheat block needs ~7 successful random ticks, which one night of catch-up does not reliably deliver. So the only honest way to assert "the night was SPREAD, not applied in one tick" is for the mod to say so. The gate now measures the window from these two lines, and the same lines are what an operator reads on a live server.

Makes the 1.3.0 catch-up observable. No behaviour change to the catch-up itself. ### Added - **`progression start` / `progression end` log lines** (INFO, once per catch-up, mod and plugin), mirroring the `ACCELERATE start` / `ACCELERATE end` pair the engine already logs: `progression start: catching up 9847 ticks over ~10s` / `progression end: applied 9847 ticks over 197 server ticks (9.9s)`. An admin who changes `progression_catchup_seconds` can now see it take effect. ### Why it exists Building the catch-up smoketest gate proved the window has **no external observable**: the random-tick boost is applied and restored INSIDE a single tick body, so a console `gamerule random_tick_speed` query -- which can only run between ticks -- reads the world's own value every time, mid-catch-up included. Sampling it measures nothing, and a permissive parser turns that nothing into numbers. Crop growth is no better: it is stochastic, and a single wheat block needs ~7 successful random ticks, which one night of catch-up does not reliably deliver. So the only honest way to assert "the night was SPREAD, not applied in one tick" is for the mod to say so. The gate now measures the window from these two lines, and the same lines are what an operator reads on a live server.

Makes the 1.3.0 catch-up observable. No behaviour change to the catch-up itself. ### Added - **`progression start` / `progression end` log lines** (INFO, once per catch-up, mod and plugin), mirroring the `ACCELERATE start` / `ACCELERATE end` pair the engine already logs: `progression start: catching up 9847 ticks over ~10s` / `progression end: applied 9847 ticks over 197 server ticks (9.9s)`. An admin who changes `progression_catchup_seconds` can now see it take effect. ### Why it exists Building the catch-up smoketest gate proved the window has **no external observable**: the random-tick boost is applied and restored INSIDE a single tick body, so a console `gamerule random_tick_speed` query -- which can only run between ticks -- reads the world's own value every time, mid-catch-up included. Sampling it measures nothing, and a permissive parser turns that nothing into numbers. Crop growth is no better: it is stochastic, and a single wheat block needs ~7 successful random ticks, which one night of catch-up does not reliably deliver. So the only honest way to assert "the night was SPREAD, not applied in one tick" is for the mod to say so. The gate now measures the window from these two lines, and the same lines are what an operator reads on a live server.

Makes the 1.3.0 catch-up observable. No behaviour change to the catch-up itself. ### Added - **`progression start` / `progression end` log lines** (INFO, once per catch-up, mod and plugin), mirroring the `ACCELERATE start` / `ACCELERATE end` pair the engine already logs: `progression start: catching up 9847 ticks over ~10s` / `progression end: applied 9847 ticks over 197 server ticks (9.9s)`. An admin who changes `progression_catchup_seconds` can now see it take effect. ### Why it exists Building the catch-up smoketest gate proved the window has **no external observable**: the random-tick boost is applied and restored INSIDE a single tick body, so a console `gamerule random_tick_speed` query -- which can only run between ticks -- reads the world's own value every time, mid-catch-up included. Sampling it measures nothing, and a permissive parser turns that nothing into numbers. Crop growth is no better: it is stochastic, and a single wheat block needs ~7 successful random ticks, which one night of catch-up does not reliably deliver. So the only honest way to assert "the night was SPREAD, not applied in one tick" is for the mod to say so. The gate now measures the window from these two lines, and the same lines are what an operator reads on a live server.

Makes the 1.3.0 catch-up observable. No behaviour change to the catch-up itself. ### Added - **`progression start` / `progression end` log lines** (INFO, once per catch-up, mod and plugin), mirroring the `ACCELERATE start` / `ACCELERATE end` pair the engine already logs: `progression start: catching up 9847 ticks over ~10s` / `progression end: applied 9847 ticks over 197 server ticks (9.9s)`. An admin who changes `progression_catchup_seconds` can now see it take effect. ### Why it exists Building the catch-up smoketest gate proved the window has **no external observable**: the random-tick boost is applied and restored INSIDE a single tick body, so a console `gamerule random_tick_speed` query -- which can only run between ticks -- reads the world's own value every time, mid-catch-up included. Sampling it measures nothing, and a permissive parser turns that nothing into numbers. Crop growth is no better: it is stochastic, and a single wheat block needs ~7 successful random ticks, which one night of catch-up does not reliably deliver. So the only honest way to assert "the night was SPREAD, not applied in one tick" is for the mod to say so. The gate now measures the window from these two lines, and the same lines are what an operator reads on a live server.

Makes the 1.3.0 catch-up observable. No behaviour change to the catch-up itself. ### Added - **`progression start` / `progression end` log lines** (INFO, once per catch-up, mod and plugin), mirroring the `ACCELERATE start` / `ACCELERATE end` pair the engine already logs: `progression start: catching up 9847 ticks over ~10s` / `progression end: applied 9847 ticks over 197 server ticks (9.9s)`. An admin who changes `progression_catchup_seconds` can now see it take effect. ### Why it exists Building the catch-up smoketest gate proved the window has **no external observable**: the random-tick boost is applied and restored INSIDE a single tick body, so a console `gamerule random_tick_speed` query -- which can only run between ticks -- reads the world's own value every time, mid-catch-up included. Sampling it measures nothing, and a permissive parser turns that nothing into numbers. Crop growth is no better: it is stochastic, and a single wheat block needs ~7 successful random ticks, which one night of catch-up does not reliably deliver. So the only honest way to assert "the night was SPREAD, not applied in one tick" is for the mod to say so. The gate now measures the window from these two lines, and the same lines are what an operator reads on a live server.

Makes the 1.3.0 catch-up observable. No behaviour change to the catch-up itself. ### Added - **`progression start` / `progression end` log lines** (INFO, once per catch-up, mod and plugin), mirroring the `ACCELERATE start` / `ACCELERATE end` pair the engine already logs: `progression start: catching up 9847 ticks over ~10s` / `progression end: applied 9847 ticks over 197 server ticks (9.9s)`. An admin who changes `progression_catchup_seconds` can now see it take effect. ### Why it exists Building the catch-up smoketest gate proved the window has **no external observable**: the random-tick boost is applied and restored INSIDE a single tick body, so a console `gamerule random_tick_speed` query -- which can only run between ticks -- reads the world's own value every time, mid-catch-up included. Sampling it measures nothing, and a permissive parser turns that nothing into numbers. Crop growth is no better: it is stochastic, and a single wheat block needs ~7 successful random ticks, which one night of catch-up does not reliably deliver. So the only honest way to assert "the night was SPREAD, not applied in one tick" is for the mod to say so. The gate now measures the window from these two lines, and the same lines are what an operator reads on a live server.

Makes the 1.3.0 catch-up observable. No behaviour change to the catch-up itself. ### Added - **`progression start` / `progression end` log lines** (INFO, once per catch-up, mod and plugin), mirroring the `ACCELERATE start` / `ACCELERATE end` pair the engine already logs: `progression start: catching up 9847 ticks over ~10s` / `progression end: applied 9847 ticks over 197 server ticks (9.9s)`. An admin who changes `progression_catchup_seconds` can now see it take effect. ### Why it exists Building the catch-up smoketest gate proved the window has **no external observable**: the random-tick boost is applied and restored INSIDE a single tick body, so a console `gamerule random_tick_speed` query -- which can only run between ticks -- reads the world's own value every time, mid-catch-up included. Sampling it measures nothing, and a permissive parser turns that nothing into numbers. Crop growth is no better: it is stochastic, and a single wheat block needs ~7 successful random ticks, which one night of catch-up does not reliably deliver. So the only honest way to assert "the night was SPREAD, not applied in one tick" is for the mod to say so. The gate now measures the window from these two lines, and the same lines are what an operator reads on a live server.

Makes the 1.3.0 catch-up observable. No behaviour change to the catch-up itself. ### Added - **`progression start` / `progression end` log lines** (INFO, once per catch-up, mod and plugin), mirroring the `ACCELERATE start` / `ACCELERATE end` pair the engine already logs: `progression start: catching up 9847 ticks over ~10s` / `progression end: applied 9847 ticks over 197 server ticks (9.9s)`. An admin who changes `progression_catchup_seconds` can now see it take effect. ### Why it exists Building the catch-up smoketest gate proved the window has **no external observable**: the random-tick boost is applied and restored INSIDE a single tick body, so a console `gamerule random_tick_speed` query -- which can only run between ticks -- reads the world's own value every time, mid-catch-up included. Sampling it measures nothing, and a permissive parser turns that nothing into numbers. Crop growth is no better: it is stochastic, and a single wheat block needs ~7 successful random ticks, which one night of catch-up does not reliably deliver. So the only honest way to assert "the night was SPREAD, not applied in one tick" is for the mod to say so. The gate now measures the window from these two lines, and the same lines are what an operator reads on a live server.

Makes the 1.3.0 catch-up observable. No behaviour change to the catch-up itself. ### Added - **`progression start` / `progression end` log lines** (INFO, once per catch-up, mod and plugin), mirroring the `ACCELERATE start` / `ACCELERATE end` pair the engine already logs: `progression start: catching up 9847 ticks over ~10s` / `progression end: applied 9847 ticks over 197 server ticks (9.9s)`. An admin who changes `progression_catchup_seconds` can now see it take effect. ### Why it exists Building the catch-up smoketest gate proved the window has **no external observable**: the random-tick boost is applied and restored INSIDE a single tick body, so a console `gamerule random_tick_speed` query -- which can only run between ticks -- reads the world's own value every time, mid-catch-up included. Sampling it measures nothing, and a permissive parser turns that nothing into numbers. Crop growth is no better: it is stochastic, and a single wheat block needs ~7 successful random ticks, which one night of catch-up does not reliably deliver. So the only honest way to assert "the night was SPREAD, not applied in one tick" is for the mod to say so. The gate now measures the window from these two lines, and the same lines are what an operator reads on a live server.

Makes the 1.3.0 catch-up observable. No behaviour change to the catch-up itself. ### Added - **`progression start` / `progression end` log lines** (INFO, once per catch-up, mod and plugin), mirroring the `ACCELERATE start` / `ACCELERATE end` pair the engine already logs: `progression start: catching up 9847 ticks over ~10s` / `progression end: applied 9847 ticks over 197 server ticks (9.9s)`. An admin who changes `progression_catchup_seconds` can now see it take effect. ### Why it exists Building the catch-up smoketest gate proved the window has **no external observable**: the random-tick boost is applied and restored INSIDE a single tick body, so a console `gamerule random_tick_speed` query -- which can only run between ticks -- reads the world's own value every time, mid-catch-up included. Sampling it measures nothing, and a permissive parser turns that nothing into numbers. Crop growth is no better: it is stochastic, and a single wheat block needs ~7 successful random ticks, which one night of catch-up does not reliably deliver. So the only honest way to assert "the night was SPREAD, not applied in one tick" is for the mod to say so. The gate now measures the window from these two lines, and the same lines are what an operator reads on a live server.

Makes the 1.3.0 catch-up observable. No behaviour change to the catch-up itself. ### Added - **`progression start` / `progression end` log lines** (INFO, once per catch-up, mod and plugin), mirroring the `ACCELERATE start` / `ACCELERATE end` pair the engine already logs: `progression start: catching up 9847 ticks over ~10s` / `progression end: applied 9847 ticks over 197 server ticks (9.9s)`. An admin who changes `progression_catchup_seconds` can now see it take effect. ### Why it exists Building the catch-up smoketest gate proved the window has **no external observable**: the random-tick boost is applied and restored INSIDE a single tick body, so a console `gamerule random_tick_speed` query -- which can only run between ticks -- reads the world's own value every time, mid-catch-up included. Sampling it measures nothing, and a permissive parser turns that nothing into numbers. Crop growth is no better: it is stochastic, and a single wheat block needs ~7 successful random ticks, which one night of catch-up does not reliably deliver. So the only honest way to assert "the night was SPREAD, not applied in one tick" is for the mod to say so. The gate now measures the window from these two lines, and the same lines are what an operator reads on a live server.

Makes the 1.3.0 catch-up observable. No behaviour change to the catch-up itself. ### Added - **`progression start` / `progression end` log lines** (INFO, once per catch-up, mod and plugin), mirroring the `ACCELERATE start` / `ACCELERATE end` pair the engine already logs: `progression start: catching up 9847 ticks over ~10s` / `progression end: applied 9847 ticks over 197 server ticks (9.9s)`. An admin who changes `progression_catchup_seconds` can now see it take effect. ### Why it exists Building the catch-up smoketest gate proved the window has **no external observable**: the random-tick boost is applied and restored INSIDE a single tick body, so a console `gamerule random_tick_speed` query -- which can only run between ticks -- reads the world's own value every time, mid-catch-up included. Sampling it measures nothing, and a permissive parser turns that nothing into numbers. Crop growth is no better: it is stochastic, and a single wheat block needs ~7 successful random ticks, which one night of catch-up does not reliably deliver. So the only honest way to assert "the night was SPREAD, not applied in one tick" is for the mod to say so. The gate now measures the window from these two lines, and the same lines are what an operator reads on a live server.

Makes the 1.3.0 catch-up observable. No behaviour change to the catch-up itself. ### Added - **`progression start` / `progression end` log lines** (INFO, once per catch-up, mod and plugin), mirroring the `ACCELERATE start` / `ACCELERATE end` pair the engine already logs: `progression start: catching up 9847 ticks over ~10s` / `progression end: applied 9847 ticks over 197 server ticks (9.9s)`. An admin who changes `progression_catchup_seconds` can now see it take effect. ### Why it exists Building the catch-up smoketest gate proved the window has **no external observable**: the random-tick boost is applied and restored INSIDE a single tick body, so a console `gamerule random_tick_speed` query -- which can only run between ticks -- reads the world's own value every time, mid-catch-up included. Sampling it measures nothing, and a permissive parser turns that nothing into numbers. Crop growth is no better: it is stochastic, and a single wheat block needs ~7 successful random ticks, which one night of catch-up does not reliably deliver. So the only honest way to assert "the night was SPREAD, not applied in one tick" is for the mod to say so. The gate now measures the window from these two lines, and the same lines are what an operator reads on a live server.

Makes the 1.3.0 catch-up observable. No behaviour change to the catch-up itself. ### Added - **`progression start` / `progression end` log lines** (INFO, once per catch-up, mod and plugin), mirroring the `ACCELERATE start` / `ACCELERATE end` pair the engine already logs: `progression start: catching up 9847 ticks over ~10s` / `progression end: applied 9847 ticks over 197 server ticks (9.9s)`. An admin who changes `progression_catchup_seconds` can now see it take effect. ### Why it exists Building the catch-up smoketest gate proved the window has **no external observable**: the random-tick boost is applied and restored INSIDE a single tick body, so a console `gamerule random_tick_speed` query -- which can only run between ticks -- reads the world's own value every time, mid-catch-up included. Sampling it measures nothing, and a permissive parser turns that nothing into numbers. Crop growth is no better: it is stochastic, and a single wheat block needs ~7 successful random ticks, which one night of catch-up does not reliably deliver. So the only honest way to assert "the night was SPREAD, not applied in one tick" is for the mod to say so. The gate now measures the window from these two lines, and the same lines are what an operator reads on a live server.

Makes the 1.3.0 catch-up observable. No behaviour change to the catch-up itself. ### Added - **`progression start` / `progression end` log lines** (INFO, once per catch-up, mod and plugin), mirroring the `ACCELERATE start` / `ACCELERATE end` pair the engine already logs: `progression start: catching up 9847 ticks over ~10s` / `progression end: applied 9847 ticks over 197 server ticks (9.9s)`. An admin who changes `progression_catchup_seconds` can now see it take effect. ### Why it exists Building the catch-up smoketest gate proved the window has **no external observable**: the random-tick boost is applied and restored INSIDE a single tick body, so a console `gamerule random_tick_speed` query -- which can only run between ticks -- reads the world's own value every time, mid-catch-up included. Sampling it measures nothing, and a permissive parser turns that nothing into numbers. Crop growth is no better: it is stochastic, and a single wheat block needs ~7 successful random ticks, which one night of catch-up does not reliably deliver. So the only honest way to assert "the night was SPREAD, not applied in one tick" is for the mod to say so. The gate now measures the window from these two lines, and the same lines are what an operator reads on a live server.

Makes the 1.3.0 catch-up observable. No behaviour change to the catch-up itself. ### Added - **`progression start` / `progression end` log lines** (INFO, once per catch-up, mod and plugin), mirroring the `ACCELERATE start` / `ACCELERATE end` pair the engine already logs: `progression start: catching up 9847 ticks over ~10s` / `progression end: applied 9847 ticks over 197 server ticks (9.9s)`. An admin who changes `progression_catchup_seconds` can now see it take effect. ### Why it exists Building the catch-up smoketest gate proved the window has **no external observable**: the random-tick boost is applied and restored INSIDE a single tick body, so a console `gamerule random_tick_speed` query -- which can only run between ticks -- reads the world's own value every time, mid-catch-up included. Sampling it measures nothing, and a permissive parser turns that nothing into numbers. Crop growth is no better: it is stochastic, and a single wheat block needs ~7 successful random ticks, which one night of catch-up does not reliably deliver. So the only honest way to assert "the night was SPREAD, not applied in one tick" is for the mod to say so. The gate now measures the window from these two lines, and the same lines are what an operator reads on a live server.

Makes the 1.3.0 catch-up observable. No behaviour change to the catch-up itself. ### Added - **`progression start` / `progression end` log lines** (INFO, once per catch-up, mod and plugin), mirroring the `ACCELERATE start` / `ACCELERATE end` pair the engine already logs: `progression start: catching up 9847 ticks over ~10s` / `progression end: applied 9847 ticks over 197 server ticks (9.9s)`. An admin who changes `progression_catchup_seconds` can now see it take effect. ### Why it exists Building the catch-up smoketest gate proved the window has **no external observable**: the random-tick boost is applied and restored INSIDE a single tick body, so a console `gamerule random_tick_speed` query -- which can only run between ticks -- reads the world's own value every time, mid-catch-up included. Sampling it measures nothing, and a permissive parser turns that nothing into numbers. Crop growth is no better: it is stochastic, and a single wheat block needs ~7 successful random ticks, which one night of catch-up does not reliably deliver. So the only honest way to assert "the night was SPREAD, not applied in one tick" is for the mod to say so. The gate now measures the window from these two lines, and the same lines are what an operator reads on a live server.

Makes the 1.3.0 catch-up observable. No behaviour change to the catch-up itself. ### Added - **`progression start` / `progression end` log lines** (INFO, once per catch-up, mod and plugin), mirroring the `ACCELERATE start` / `ACCELERATE end` pair the engine already logs: `progression start: catching up 9847 ticks over ~10s` / `progression end: applied 9847 ticks over 197 server ticks (9.9s)`. An admin who changes `progression_catchup_seconds` can now see it take effect. ### Why it exists Building the catch-up smoketest gate proved the window has **no external observable**: the random-tick boost is applied and restored INSIDE a single tick body, so a console `gamerule random_tick_speed` query -- which can only run between ticks -- reads the world's own value every time, mid-catch-up included. Sampling it measures nothing, and a permissive parser turns that nothing into numbers. Crop growth is no better: it is stochastic, and a single wheat block needs ~7 successful random ticks, which one night of catch-up does not reliably deliver. So the only honest way to assert "the night was SPREAD, not applied in one tick" is for the mod to say so. The gate now measures the window from these two lines, and the same lines are what an operator reads on a live server.

Makes the 1.3.0 catch-up observable. No behaviour change to the catch-up itself. ### Added - **`progression start` / `progression end` log lines** (INFO, once per catch-up, mod and plugin), mirroring the `ACCELERATE start` / `ACCELERATE end` pair the engine already logs: `progression start: catching up 9847 ticks over ~10s` / `progression end: applied 9847 ticks over 197 server ticks (9.9s)`. An admin who changes `progression_catchup_seconds` can now see it take effect. ### Why it exists Building the catch-up smoketest gate proved the window has **no external observable**: the random-tick boost is applied and restored INSIDE a single tick body, so a console `gamerule random_tick_speed` query -- which can only run between ticks -- reads the world's own value every time, mid-catch-up included. Sampling it measures nothing, and a permissive parser turns that nothing into numbers. Crop growth is no better: it is stochastic, and a single wheat block needs ~7 successful random ticks, which one night of catch-up does not reliably deliver. So the only honest way to assert "the night was SPREAD, not applied in one tick" is for the mod to say so. The gate now measures the window from these two lines, and the same lines are what an operator reads on a live server.

Makes the 1.3.0 catch-up observable. No behaviour change to the catch-up itself. ### Added - **`progression start` / `progression end` log lines** (INFO, once per catch-up, mod and plugin), mirroring the `ACCELERATE start` / `ACCELERATE end` pair the engine already logs: `progression start: catching up 9847 ticks over ~10s` / `progression end: applied 9847 ticks over 197 server ticks (9.9s)`. An admin who changes `progression_catchup_seconds` can now see it take effect. ### Why it exists Building the catch-up smoketest gate proved the window has **no external observable**: the random-tick boost is applied and restored INSIDE a single tick body, so a console `gamerule random_tick_speed` query -- which can only run between ticks -- reads the world's own value every time, mid-catch-up included. Sampling it measures nothing, and a permissive parser turns that nothing into numbers. Crop growth is no better: it is stochastic, and a single wheat block needs ~7 successful random ticks, which one night of catch-up does not reliably deliver. So the only honest way to assert "the night was SPREAD, not applied in one tick" is for the mod to say so. The gate now measures the window from these two lines, and the same lines are what an operator reads on a live server.

Makes the 1.3.0 catch-up observable. No behaviour change to the catch-up itself. ### Added - **`progression start` / `progression end` log lines** (INFO, once per catch-up, mod and plugin), mirroring the `ACCELERATE start` / `ACCELERATE end` pair the engine already logs: `progression start: catching up 9847 ticks over ~10s` / `progression end: applied 9847 ticks over 197 server ticks (9.9s)`. An admin who changes `progression_catchup_seconds` can now see it take effect. ### Why it exists Building the catch-up smoketest gate proved the window has **no external observable**: the random-tick boost is applied and restored INSIDE a single tick body, so a console `gamerule random_tick_speed` query -- which can only run between ticks -- reads the world's own value every time, mid-catch-up included. Sampling it measures nothing, and a permissive parser turns that nothing into numbers. Crop growth is no better: it is stochastic, and a single wheat block needs ~7 successful random ticks, which one night of catch-up does not reliably deliver. So the only honest way to assert "the night was SPREAD, not applied in one tick" is for the mod to say so. The gate now measures the window from these two lines, and the same lines are what an operator reads on a live server.

Makes the 1.3.0 catch-up observable. No behaviour change to the catch-up itself. ### Added - **`progression start` / `progression end` log lines** (INFO, once per catch-up, mod and plugin), mirroring the `ACCELERATE start` / `ACCELERATE end` pair the engine already logs: `progression start: catching up 9847 ticks over ~10s` / `progression end: applied 9847 ticks over 197 server ticks (9.9s)`. An admin who changes `progression_catchup_seconds` can now see it take effect. ### Why it exists Building the catch-up smoketest gate proved the window has **no external observable**: the random-tick boost is applied and restored INSIDE a single tick body, so a console `gamerule random_tick_speed` query -- which can only run between ticks -- reads the world's own value every time, mid-catch-up included. Sampling it measures nothing, and a permissive parser turns that nothing into numbers. Crop growth is no better: it is stochastic, and a single wheat block needs ~7 successful random ticks, which one night of catch-up does not reliably deliver. So the only honest way to assert "the night was SPREAD, not applied in one tick" is for the mod to say so. The gate now measures the window from these two lines, and the same lines are what an operator reads on a live server.

Makes the 1.3.0 catch-up observable. No behaviour change to the catch-up itself. ### Added - **`progression start` / `progression end` log lines** (INFO, once per catch-up, mod and plugin), mirroring the `ACCELERATE start` / `ACCELERATE end` pair the engine already logs: `progression start: catching up 9847 ticks over ~10s` / `progression end: applied 9847 ticks over 197 server ticks (9.9s)`. An admin who changes `progression_catchup_seconds` can now see it take effect. ### Why it exists Building the catch-up smoketest gate proved the window has **no external observable**: the random-tick boost is applied and restored INSIDE a single tick body, so a console `gamerule random_tick_speed` query -- which can only run between ticks -- reads the world's own value every time, mid-catch-up included. Sampling it measures nothing, and a permissive parser turns that nothing into numbers. Crop growth is no better: it is stochastic, and a single wheat block needs ~7 successful random ticks, which one night of catch-up does not reliably deliver. So the only honest way to assert "the night was SPREAD, not applied in one tick" is for the mod to say so. The gate now measures the window from these two lines, and the same lines are what an operator reads on a live server.

Makes the 1.3.0 catch-up observable. No behaviour change to the catch-up itself. ### Added - **`progression start` / `progression end` log lines** (INFO, once per catch-up, mod and plugin), mirroring the `ACCELERATE start` / `ACCELERATE end` pair the engine already logs: `progression start: catching up 9847 ticks over ~10s` / `progression end: applied 9847 ticks over 197 server ticks (9.9s)`. An admin who changes `progression_catchup_seconds` can now see it take effect. ### Why it exists Building the catch-up smoketest gate proved the window has **no external observable**: the random-tick boost is applied and restored INSIDE a single tick body, so a console `gamerule random_tick_speed` query -- which can only run between ticks -- reads the world's own value every time, mid-catch-up included. Sampling it measures nothing, and a permissive parser turns that nothing into numbers. Crop growth is no better: it is stochastic, and a single wheat block needs ~7 successful random ticks, which one night of catch-up does not reliably deliver. So the only honest way to assert "the night was SPREAD, not applied in one tick" is for the mod to say so. The gate now measures the window from these two lines, and the same lines are what an operator reads on a live server.

Makes the 1.3.0 catch-up observable. No behaviour change to the catch-up itself. ### Added - **`progression start` / `progression end` log lines** (INFO, once per catch-up, mod and plugin), mirroring the `ACCELERATE start` / `ACCELERATE end` pair the engine already logs: `progression start: catching up 9847 ticks over ~10s` / `progression end: applied 9847 ticks over 197 server ticks (9.9s)`. An admin who changes `progression_catchup_seconds` can now see it take effect. ### Why it exists Building the catch-up smoketest gate proved the window has **no external observable**: the random-tick boost is applied and restored INSIDE a single tick body, so a console `gamerule random_tick_speed` query -- which can only run between ticks -- reads the world's own value every time, mid-catch-up included. Sampling it measures nothing, and a permissive parser turns that nothing into numbers. Crop growth is no better: it is stochastic, and a single wheat block needs ~7 successful random ticks, which one night of catch-up does not reliably deliver. So the only honest way to assert "the night was SPREAD, not applied in one tick" is for the mod to say so. The gate now measures the window from these two lines, and the same lines are what an operator reads on a live server.

### Fixed - **`sleep_anytime` let you into the bed and then threw you straight back out** ([mod_support #10](https://github.com/Kishku7/mod_support/issues/10)). Vanilla gates sleeping in TWO places, and only one was ever bypassed: the ENTRY check inside `ServerPlayer.startSleepInBed` (covered by `ServerPlayerSleepMixin` / the loader sleep events), and an ONGOING check inside `Player.tick` that runs every tick while asleep and calls `stopSleepInBed(false, true)` the moment the day-gate says you may not sleep here. Nothing in the mod touched the second one, so with `sleep_anytime` enabled you passed the entry check, entered the bed, and were ejected on the very next tick -- and because you never stayed asleep, `areEnoughSleeping` never flipped, the skip never triggered, and no progression (crops/animals/smelting/despawn) ran either. New `PlayerSleepTickMixin` redirects that `stopSleepInBed` call inside `Player.tick` and skips it while `sleep_anytime` is on. Dawn wake-up is unaffected (that runs through `ServerLevel.wakeUpAllPlayers`, a different call site). **This was never Fabric-only:** NeoForge relies on `CanPlayerSleepEvent`, which likewise fires only at entry, so `sleep_anytime` was broken on NeoForge on EVERY version. Forge was already fine (its `Player.tick` patch fires `SleepingTimeCheckEvent` there) and so was Fabric below 1.21.11 (fabric-api hooks the tick site); the new mixin is inert where the gate is already handled. - **`afk_threshold_seconds = -1` did not actually disable auto-AFK detection.** `AfkManager.tick()` ran the raw value through `Math.max(1, ...)`, flooring any zero/negative value to a 1-second threshold -- the opposite of "off". Auto-AFK detection is now genuinely skipped when the threshold is negative (manual `/usleep afk` still works); if the setting is switched to -1 mid-session, any player already auto-AFK is immediately cleared. ### Added - **Admin GUI: "Auto-AFK Detection" ON/OFF button**, on its own row directly above the `afk_threshold_seconds` field (Auto-sleep & AFK page). OFF sets the threshold to -1; clicking again restores 180s. Landed in both the 26.x (`extractRenderState`) and pre-26 (`render`) `UltimateSleepScreen` copies. ### Notes - Rebuilt across the WHOLE matrix at one version. The AFK fix above had been built for the Fabric 1.21.11 cell only (2026-07-31, never released); it ships everywhere here. - `PlayerSleepTickMixin` needs no era gate: the gate EXPRESSION drifts (`Level.isDay` 1.20-1.21.4, `Level.isBrightOutside` 1.21.5-1.21.8, `BedRule.canSleep` via `environmentAttributes` 1.21.11-26.2, `AbstractBedBlock.getBedRule().canSleep` 26.3+), but the `stopSleepInBed(ZZ)V` call it guards is descriptor-identical with a single call site in `tick` on every version from 1.20.1 to 26.3-snapshot-6. Redirecting the consequence rather than the condition also avoids the equal-priority collision with fabric-api's `ALLOW_SLEEP_TIME` redirect (see the 2026-07-05 smoketest note in `ServerPlayerSleepMixin`). - The Paper/Folia plugin is unchanged and keeps its own 1.2.0 line (no mixins, different sleep path).

### Changed - MC 26.3 Fabric build advanced from 26.3-snapshot-4 to 26.3-snapshot-5 (Fabric API 0.155.3+26.3, pack_format 93, dependency floor 26.3-alpha.5). Loads and drives into a world on the snapshot's reworked GPU/shader pipeline with no source changes; verified in-world on the headless client harness.

### Fixed - Resource pack metadata on Minecraft 1.21.9-1.21.11: Fabric and NeoForge builds no longer ship a `pack.mcmeta` (each loader now synthesises the correct per-type metadata), and Forge builds carry the correct data-pack format range. This stops the client from dropping the mod's resources on those versions. ### Changed - 26.3 build updated to the current snapshot (26.3-snapshot-4). - Internal: consolidated to a single code source of truth across the build matrix (no shipped behaviour change; the produced jars are byte-for-byte identical on unaffected versions).

Ultimate Sleep 1.2.0 -- multi-loader release: Fabric/NeoForge/Forge across MC 1.20-26.x + Paper/Folia plugin line This file: Paper/Folia plugin build (26.x line) -- covers MC 26.1 - 26.3 snapshots.