ugly-game 0.7.2 → 0.7.4

package/dist/loop/simCore.d.ts

@@ -1,6 +1,6 @@
 import type { DeterministicSim } from '../moat';
 import type { ControlView } from './controlBlock';
-import type { CommandQueue } from './commandQueue';
+import type { CommandQueue, Stamped } from './commandQueue';
 export interface SimClock {
     now(): number;
 }
@@ -21,10 +21,11 @@ export interface CoopStepOpts<S, I> {
     tickOf: (s: S) => number;
     maxCatchUpFrames?: number;
     onLate?: (count: number) => void;
-    /** Called once per tick, with the commands due THIS tick, immediately before `sim.tick`. The seam a game uses
-     *  to drive per-tick co-op diagnostics (a command journal + a checkpoint hash trail) without the primitive
-     *  needing to know their shape. `state` is passed so a checkpoint can hash it (at the top of the tick). */
-    beforeTick?: (due: I[], state: S) => void;
+    /** Called once per tick, with the STAMPED commands due THIS tick (carrying `at`/`seq`/`by`), immediately before
+     *  `sim.tick`. The seam a game drives per-tick co-op diagnostics through — a command journal (whose digest must
+     *  fold in `at`/`seq`, so a relay reorder reads as a relay bug, not a sim bug) + a checkpoint hash trail. `state`
+     *  is passed so a checkpoint can hash it at the top of the tick. */
+    beforeTick?: (due: Stamped<I>[], state: S) => void;
 }
 export interface SoloStepOpts<S, I> {
     sim: SimHostSim<S, I>;
@@ -39,7 +40,7 @@ export interface SoloStepOpts<S, I> {
     fps?: number;
     maxCatchUpFrames?: number;
     onLate?: (count: number) => void;
-    beforeTick?: (due: I[], state: S) => void;
+    beforeTick?: (due: Stamped<I>[], state: S) => void;
 }
 /** Single-player stepping: derive a target tick from elapsed wall time (a free-run 60-UPS accumulator, clamped by
  *  maxCatchUpFrames), publish it to `ctl.targetTick`, then reuse `coopStepBatch` — so solo and co-op run the identical

package/dist/loop/simCore.js

@@ -45,12 +45,12 @@ export function coopStepBatch(opts) {
             if (late && opts.onLate)
                 opts.onLate(late);
         }
-        const inputs = due.map((d) => d.c);
-        // Per-tick diagnostics seam: the game records the applied stream + a checkpoint hash of the top-of-tick state,
-        // BEFORE the tick mutates it. Fires every tick (solo + co-op) so a journal can't silently skip history.
+        // Per-tick diagnostics seam: the game records the applied (stamped) stream + a checkpoint hash of the
+        // top-of-tick state, BEFORE the tick mutates it. Fires every tick (solo + co-op) so a journal can't silently
+        // skip history. The sim itself only needs the bare commands.
         if (opts.beforeTick)
-            opts.beforeTick(inputs, opts.state);
-        opts.sim.tick(opts.state, inputs);
+            opts.beforeTick(due, opts.state);
+        opts.sim.tick(opts.state, due.map((d) => d.c));
         stepped++;
     };
     // STEP_BUDGET burst first (forced, deterministic — independent of the target).

package/dist/loop/simHost.worker.d.ts

@@ -1,6 +1,7 @@
 import type { Layout } from './layout';
 import { type ControlView } from './controlBlock';
 import { type SimHostSim } from './simCore';
+import { type Stamped } from './commandQueue';
 /** A reply a worker posts back to the main thread. Must be structured-cloneable. Echo the originating request's
  *  `rid` so the main thread's `host.request()` Promise resolves on it; any other fields are the game's payload. */
 export interface SimWorkerReply {
@@ -17,7 +18,8 @@ export interface SimWorkerConfig<S, I> {
     layout: Layout<S> | ((init: Record<string, unknown>) => Layout<S>);
     tickOf: (s: S) => number;
     mirror?: (s: S, ctl: ControlView<string>) => void;
-    beforeTick?: (due: I[], state: S) => void;
+    beforeTick?: (due: Stamped<I>[], state: S) => void;
     onMessage?: (m: Record<string, unknown>, ctx: SimWorkerContext<S>) => void;
+    onReinit?: (ctx: SimWorkerContext<S>) => void;
 }
 export declare function runSimWorker<S, I>(cfg: SimWorkerConfig<S, I>): void;

package/dist/loop/simHost.worker.js

@@ -3,6 +3,9 @@ import { soloStepBatch, coopStepBatch, } from './simCore';
 import { CommandQueue } from './commandQueue';
 export function runSimWorker(cfg) {
     const ctx = globalThis;
+    const post = (msg) => {
+        ctx.postMessage(msg);
+    };
     const queue = new CommandQueue();
     let state = null;
     let ctl = null;
@@ -98,6 +101,8 @@ export function runSimWorker(cfg) {
                 queue.clear();
             lastRef.t = clock.now();
             acc = 0;
+            if (ctl)
+                cfg.onReinit?.({ state, ctl, post });
         }
         else if (m.t === 'cmd') {
             queue.push(m.s);
@@ -108,13 +113,7 @@ export function runSimWorker(cfg) {
         }
         else if (state && ctl) {
             // A message this runner doesn't own — hand it to the game (diagnostics requests, etc.).
-            cfg.onMessage?.(m, {
-                state,
-                ctl,
-                post: (msg) => {
-                    ctx.postMessage(msg);
-                },
-            });
+            cfg.onMessage?.(m, { state, ctl, post });
         }
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ugly-game",
-  "version": "0.7.2",
+  "version": "0.7.4",
   "type": "module",
   "exports": {
     ".": {