@irtio/client 0.5.2 → 0.6.0

package/dist/{chunk-7UTJ7RSF.js → chunk-6J6PKFUS.js}

@@ -14,7 +14,10 @@ function emptyPredictionStats() {
     overCap: 0,
     lastResimMicros: 0,
     smoothing: 0,
-    stampGap: 0
+    stampGap: 0,
+    stampGapRaw: 0,
+    lastStampTick: 0,
+    lastAppliedTick: 0
   };
 }
 
@@ -58,6 +61,10 @@ var ClientCollectionImpl = class {
   }
   store;
   desc;
+  /** D50: point this facade at the same collection in a rebuilt schema. */
+  retarget(desc) {
+    this.desc = desc;
+  }
   get plain() {
     return entityOf(this.store.plain, this.desc.name);
   }
@@ -101,7 +108,8 @@ var ClientStore = class {
     for (const c of ext.collections) this.descs.set(c.name, c);
     this.plain = createState(ext);
     this.tracked = track(ext, this.plain);
-    this.view = this.buildView();
+    this.view = {};
+    this.buildViewInto(this.view);
   }
   ext;
   meOf;
@@ -109,6 +117,8 @@ var ClientStore = class {
   tracked;
   descs = /* @__PURE__ */ new Map();
   frozen = /* @__PURE__ */ new WeakMap();
+  /** Live collection facades by name, so a D50 swap can retarget rather than replace them. */
+  facades = /* @__PURE__ */ new Map();
   /** The object handed out as `room.state`; identity survives a resync. */
   view;
   /** Flushed-but-unjudged writes, oldest first, at most `RESIM_DEPTH` entries (D19). */
@@ -122,6 +132,29 @@ var ClientStore = class {
    * walks the window tick by tick starts from here, not from the newest local value.
    */
   baselineIntents = /* @__PURE__ */ new Map();
+  /**
+   * D50: rebuild every schema-derived handle in this store against `newExt`, keeping the objects
+   * user code holds. `view` keeps its identity (contractual, and pinned by test), and so does each
+   * collection facade behind it, because a game may well have hoisted `room.state.players` into a
+   * local.
+   *
+   * State itself is *not* carried across: `plain` is re-created empty under the new schema. That
+   * is not a loss, because a swap only ever happens immediately before the resync WELCOME that
+   * `rejoinAll` sends, and `loadSnapshot` re-seeds everything from it. Carrying the old records
+   * forward would be actively wrong — `normalizeRecord` rejects field names the old schema did
+   * not have, and a record built under the old descriptor is missing the new fields entirely.
+   */
+  swapSchema(newExt) {
+    this.ext = newExt;
+    this.descs.clear();
+    for (const c of newExt.collections) this.descs.set(c.name, c);
+    this.plain = createState(newExt);
+    this.tracked = track(newExt, this.plain);
+    this.pendingWrites.length = 0;
+    this.evictedThroughTick = 0;
+    this.baselineIntents.clear();
+    this.buildViewInto(this.view);
+  }
   // -- snapshot / resync -----------------------------------------------------
   loadSnapshot(bytes) {
     this.plain = decodeSnapshot(this.ext, bytes).state;
@@ -182,20 +215,48 @@ var ClientStore = class {
     }
     this.remarkOwned();
   }
-  buildView() {
-    const view = {};
+  /**
+   * Defines one accessor per collection on `view`. Called once at construction and again on every
+   * schema swap, always against the SAME object, so `room.state`'s identity never changes.
+   *
+   * A collection that survives the swap keeps its facade and is retargeted at the new descriptor;
+   * a collection the new schema adds gets a fresh one; a collection that disappears has its
+   * accessor deleted. Only the first two can happen on an additive swap, but a `delete` is one
+   * line and a stale accessor reading a collection that no longer exists would throw from inside
+   * a getter, which is a miserable thing to debug.
+   */
+  buildViewInto(view) {
+    const names = /* @__PURE__ */ new Set();
     for (const c of this.ext.collections) {
+      names.add(c.name);
       if (c.kind === "entity") {
-        const facade = withIndexSugar(new ClientCollectionImpl(this, c));
-        Object.defineProperty(view, c.name, { get: () => facade, enumerable: true });
+        const existing = this.facades.get(c.name);
+        if (existing) {
+          existing.retarget(c);
+          continue;
+        }
+        const impl = new ClientCollectionImpl(this, c);
+        this.facades.set(c.name, impl);
+        const facade = withIndexSugar(impl);
+        Object.defineProperty(view, c.name, {
+          get: () => facade,
+          enumerable: true,
+          configurable: true
+        });
       } else {
         Object.defineProperty(view, c.name, {
           get: () => this.freeze(this.plain[c.name], this.singletonHint(c)),
-          enumerable: true
+          enumerable: true,
+          configurable: true
         });
       }
     }
-    return view;
+    for (const name of Object.keys(view)) {
+      if (!names.has(name)) {
+        delete view[name];
+        this.facades.delete(name);
+      }
+    }
   }
   // -- instances ------------------------------------------------------------
   /** The writable tracked proxy when this client owns `id`, otherwise a frozen one. */