ugly-game 0.5.7 → 0.5.8

package/dist/net/roomCore.d.ts

@@ -6,6 +6,9 @@ interface DOStorage {
     get<T>(key: string): Promise<T | undefined>;
     put<T>(key: string, value: T): Promise<void>;
     delete(key: string): Promise<void>;
+    list<T>(options?: {
+        prefix?: string;
+    }): Promise<Map<string, T>>;
 }
 interface DOState {
     storage: DOStorage;
@@ -22,8 +25,11 @@ export declare class RoomCore {
     private seq;
     constructor(state: DOState, opts?: RoomOptions);
     fetch(request: Request): Promise<unknown>;
-    /** The app DO forwards its webSocketMessage here. */
-    webSocketMessage(ws: WS, message: string | ArrayBuffer): void;
+    /** The app DO forwards its webSocketMessage here. Async so relayed edits can be durably accumulated. */
+    webSocketMessage(ws: WS, message: string | ArrayBuffer): Promise<void>;
+    /** LWW-accumulate a relayed keyed edit into DO storage, so a later joiner reconstructs the world. Keeps the
+     *  higher (stamp, by) — the exact rule the free-roam client's LwwStore uses, so server + clients converge. */
+    private accumulateEdit;
     webSocketClose(ws: WS): void;
     webSocketError(ws: WS): void;
     private json;

package/dist/net/roomCore.js

@@ -17,6 +17,13 @@
 //   · `repin`           → lone client re-pins the shared-clock epoch
 // Snapshot bytes are stored chunked (PUT/GET) for join/resync + save. WebSocket
 // HIBERNATION (state.acceptWebSocket) means no duration billed while a room idles.
+//
+// PERSISTENT KEYED WORLD (free-roam / all-mine-sky): a `relay` whose payload carries an `e = {key, val, stamp,
+// by}` is ALSO accumulated server-side, last-write-wins by (stamp, by), under `e:<key>`. GET `edits` returns the
+// accumulated set so a joiner reconstructs the world — even into an empty room. Persisting from the WS handler
+// (not a concurrent HTTP PUT) is REQUIRED: an HTTP storage write to a DO that holds a live hibernatable socket
+// silently no-ops, whereas a write inside webSocketMessage commits. Relays without an `e.key` (e.g. cogsworth's
+// lockstep commands) are untouched — accumulation is opt-in by payload shape, so RoomCore stays game-agnostic.
 // ─────────────────────────────────────────────────────────────────────────────
 const CHUNK = 96 * 1024; // DO value cap is ~128KB; chunk snapshots under it
 const KEYS = { epoch: 'epoch', chunks: 'chunks', bytes: 'bytes', tick: 'tick' };
@@ -45,6 +52,18 @@ export class RoomCore {
             pair[1].send(JSON.stringify({ t: 'hello', peers: this.state.getWebSockets().length, epoch, now: Date.now() }));
             return new Response(null, { status: 101, webSocket: pair[0] });
         }
+        // ── accumulated keyed edits (free-roam join sync): the LWW deltas persisted from the relay stream ──
+        if (path === 'edits') {
+            const m = await this.state.storage.list({ prefix: 'e:' });
+            return new Response(JSON.stringify([...m.values()]), {
+                status: 200,
+                headers: {
+                    'content-type': 'application/json',
+                    'cache-control': 'no-store',
+                    'x-ugly-no-spa-fallback': '1',
+                },
+            });
+        }
         // ── snapshot SAVE (join/resync + persistence): body = opaque bytes, stored chunked ──
         if (request.method === 'PUT' || request.method === 'POST') {
             const body = new Uint8Array(await request.arrayBuffer());
@@ -87,8 +106,8 @@ export class RoomCore {
             },
         });
     }
-    /** The app DO forwards its webSocketMessage here. */
-    webSocketMessage(ws, message) {
+    /** The app DO forwards its webSocketMessage here. Async so relayed edits can be durably accumulated. */
+    async webSocketMessage(ws, message) {
         let m = null;
         try {
             m = JSON.parse(typeof message === 'string' ? message : new TextDecoder().decode(message));
@@ -104,7 +123,7 @@ export class RoomCore {
         }
         if (m.t === 'repin' && typeof m.tick === 'number' && this.state.getWebSockets().length === 1) {
             const epoch = Date.now() - m.tick * (this.opts.tickMs ?? 0);
-            void this.state.storage.put(KEYS.epoch, epoch);
+            await this.state.storage.put(KEYS.epoch, epoch);
             ws.send(JSON.stringify({ t: 'epoch', epoch, now: Date.now() }));
             return;
         }
@@ -120,6 +139,28 @@ export class RoomCore {
         const stamped = JSON.stringify({ ...m, seq: ++this.seq });
         for (const peer of this.state.getWebSockets())
             peer.send(stamped);
+        // free-roam persistence: a relay carrying a keyed edit is accumulated LWW so it outlives the session (fanout
+        // first — this must never delay the relay). Opt-in by payload shape → lockstep relays (no e.key) are untouched.
+        if (m.t === 'relay')
+            await this.accumulateEdit(m.e);
+    }
+    /** LWW-accumulate a relayed keyed edit into DO storage, so a later joiner reconstructs the world. Keeps the
+     *  higher (stamp, by) — the exact rule the free-roam client's LwwStore uses, so server + clients converge. */
+    async accumulateEdit(e) {
+        if (!e || typeof e !== 'object')
+            return;
+        const ed = e;
+        if (typeof ed.key !== 'number' && typeof ed.key !== 'string')
+            return;
+        const k = `e:${ed.key}`;
+        const es = typeof ed.stamp === 'number' ? ed.stamp : 0;
+        const cur = await this.state.storage.get(k);
+        if (cur) {
+            const cs = typeof cur.stamp === 'number' ? cur.stamp : 0;
+            if (cs > es || (cs === es && String(cur.by) >= String(ed.by)))
+                return; // an existing write outranks it
+        }
+        await this.state.storage.put(k, e);
     }
     webSocketClose(ws) {
         try {

package/package.json

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