ugly-game 0.5.4 → 0.5.6

package/dist/moat.d.ts

@@ -1,11 +1,16 @@
-/** The only thing the harness needs from a game: a deterministic sim it can clone, hash, and step. */
-export interface MoatSim<S, I> {
+/** A DETERMINISTIC SIMULATION: pure `step`, clonable state, content-addressable `hash`. Identical (state, input)
+ *  → byte-identical result, verifiable by the hash. That is the ONLY thing the whole harness, the netcode
+ *  Reconciler, and the branchable StateTree need from a game — nothing game-specific. */
+export interface DeterministicSim<S, I> {
     clone(s: S): S;
     hash(s: S): string;
     step(s: S, input: I): void;
 }
+/** @deprecated Renamed to {@link DeterministicSim} — the name now describes the property (determinism), not the
+ *  strategic payoff. Kept as an alias so existing consumers keep compiling. */
+export type MoatSim<S, I> = DeterministicSim<S, I>;
 /** Run a sim over an input stream and record the per-step content hash (index 0 = the initial state). */
-export declare function runTrace<S, I>(sim: MoatSim<S, I>, init: S, inputs: I[]): string[];
+export declare function runTrace<S, I>(sim: DeterministicSim<S, I>, init: S, inputs: I[]): string[];
 export interface Equivalence {
     inSync: boolean;
     firstDivergentStep: number;
@@ -18,7 +23,7 @@ export declare function equivalence(reference: string[], candidate: string[]): E
 export declare function oracleCheck(reference: () => string[], candidate: () => string[]): Equivalence;
 /** Re-run a sim to a given step and return the state there — for localizing WHICH field diverged (the
  *  game supplies a `locate(refState, candState)`, e.g. the factory's "tile (9,7) content A=1 B=0"). */
-export declare function stateAt<S, I>(sim: MoatSim<S, I>, init: S, inputs: I[], step: number): S;
+export declare function stateAt<S, I>(sim: DeterministicSim<S, I>, init: S, inputs: I[], step: number): S;
 export interface SweepResult<P, V extends string> {
     results: {
         perturbation: P;

package/dist/net/reconcile.d.ts

@@ -1,4 +1,4 @@
-import type { MoatSim } from '../moat';
+import type { DeterministicSim } from '../moat';
 export interface Correction {
     rewound: number;
     diverged: boolean;
@@ -10,7 +10,7 @@ export declare class Reconciler<S, I> {
     private st;
     private f;
     private window;
-    constructor(sim: MoatSim<S, I>, base: S, baseFrame?: number, window?: number);
+    constructor(sim: DeterministicSim<S, I>, base: S, baseFrame?: number, window?: number);
     /** Step the head forward by applying `input` for the current head frame → advance to head+1. */
     advance(input: I): void;
     /** An authoritative/corrected input for `frame` arrives. If it's a past frame within the window, rewind and

package/dist/net/reconcile.js

@@ -1,11 +1,11 @@
 // ─────────────────────────────────────────────────────────────────────────────
-// RECONCILER — client-side rollback over any MoatSim (the moat's netcode payoff).
+// RECONCILER — client-side rollback over any DeterministicSim (the moat's netcode payoff).
 //
 // Live play can't wait for the network: you PREDICT missing/remote inputs and step
 // ahead. When an authoritative (or corrected) input for a PAST frame arrives, you
 // rewind to a checkpoint at/just-before that frame, splice the input into the frame-
 // indexed stream, and REPLAY forward to the present. Because the sim is a
-// deterministic MoatSim (clone/hash/step), the replayed head is BYTE-IDENTICAL to
+// deterministic sim (clone/hash/step), the replayed head is BYTE-IDENTICAL to
 // what an in-order application would have produced — that's the whole guarantee, and
 // `reconcile.test.mts` proves it via hash equality. Bounded by a checkpoint window;
 // corrections older than the window return rewound<0 so the app can trigger a resync.

package/dist/net/sharedClock.d.ts

@@ -7,8 +7,10 @@ export declare class SharedClock {
     private pinned;
     constructor(tickMs: number, // ms per tick (e.g. 1000/60)
     now: () => number);
-    /** From the server `hello`. */
-    setEpoch(epoch: number): void;
+    /** From the server `hello`. Pass the server's `now` to seed a PROVISIONAL offset so `targetTick()` is roughly
+     *  right immediately — the window between joining and the first ping/pong returning is exactly when lockstep
+     *  clients stamp their first commands, and an offset of 0 there desyncs them. A real ping sample overrides it. */
+    setEpoch(epoch: number, serverNow?: number): void;
     get hasEpoch(): boolean;
     get epochMs(): number;
     /** Feed a ping round-trip: `sentAt` = local ms we sent, `serverNow` = server ms in the pong. Keeps the sample

package/dist/net/sharedClock.js

@@ -17,10 +17,14 @@ export class SharedClock {
         this.tickMs = tickMs;
         this.now = now;
     }
-    /** From the server `hello`. */
-    setEpoch(epoch) {
+    /** From the server `hello`. Pass the server's `now` to seed a PROVISIONAL offset so `targetTick()` is roughly
+     *  right immediately — the window between joining and the first ping/pong returning is exactly when lockstep
+     *  clients stamp their first commands, and an offset of 0 there desyncs them. A real ping sample overrides it. */
+    setEpoch(epoch, serverNow) {
         this.epoch = epoch;
         this.pinned = true;
+        if (serverNow !== undefined && this.bestRtt === Infinity)
+            this.offset = serverNow - this.now();
     }
     get hasEpoch() {
         return this.pinned;

package/package.json

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