@irtio/client 0.7.0 → 0.9.0

package/dist/{chunk-XWVXZRBS.js → chunk-5OHONPVG.js}

@@ -11,6 +11,7 @@ function emptyPredictionStats() {
     resimSteps: 0,
     rebases: 0,
     snaps: 0,
+    leadClamped: 0,
     suppressed: 0,
     overCap: 0,
     proxies: 0,
@@ -120,6 +121,13 @@ var ClientStore = class {
   tracked;
   descs = /* @__PURE__ */ new Map();
   frozen = /* @__PURE__ */ new WeakMap();
+  /**
+   * Per-collection add/remove subscribers (`room.onAdd` / `room.onRemove`). Kept here rather than
+   * in the session because this is the only place that sees a frame's ops against the state the
+   * frame is about to change: a removed row's last values exist for exactly as long as it takes
+   * `applyDelta` to run.
+   */
+  entityListeners = /* @__PURE__ */ new Map();
   /** 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. */
@@ -160,11 +168,13 @@ var ClientStore = class {
   }
   // -- snapshot / resync -----------------------------------------------------
   loadSnapshot(bytes) {
+    const before = this.captureRows();
     this.plain = decodeSnapshot(this.ext, bytes).state;
     this.tracked = track(this.ext, this.plain);
     this.pendingWrites.length = 0;
     this.evictedThroughTick = 0;
     this.baselineIntents.clear();
+    this.emitSnapshotDiff(before);
   }
   /**
    * Captures the field values of every pending owned write, keyed by collection then id then
@@ -293,14 +303,144 @@ var ClientStore = class {
   singletonHint(desc) {
     return `${desc.name} is a singleton and never client-owned; change it with an RPC (room.call.\u2026)`;
   }
+  // -- entity add/remove events ---------------------------------------------
+  listenersFor(name) {
+    let set = this.entityListeners.get(name);
+    if (!set) {
+      set = { add: /* @__PURE__ */ new Set(), remove: /* @__PURE__ */ new Set() };
+      this.entityListeners.set(name, set);
+    }
+    return set;
+  }
+  /**
+   * Subscribes to rows appearing in one entity collection. Rows that are **already present** are
+   * announced synchronously as the subscription is made — the join snapshot has usually landed
+   * before user code runs, and a listener that had to reconcile the initial set by hand would
+   * make the event useless for exactly the case (a spawn effect) it exists for.
+   */
+  onEntityAdd(name, cb) {
+    const desc = this.desc(name);
+    if (desc?.kind === "entity") {
+      const coll = entityOf(this.plain, name);
+      for (const id of [...coll.ids()]) cb(id, this.instance(desc, id));
+    }
+    const set = this.listenersFor(name);
+    set.add.add(cb);
+    return () => {
+      set.add.delete(cb);
+    };
+  }
+  /** Subscribes to rows disappearing from one entity collection (never fires for past removals). */
+  onEntityRemove(name, cb) {
+    const set = this.listenersFor(name);
+    set.remove.add(cb);
+    return () => {
+      set.remove.delete(cb);
+    };
+  }
+  emitAdd(name, id) {
+    const set = this.entityListeners.get(name);
+    if (!set || set.add.size === 0) return;
+    const desc = this.desc(name);
+    if (!desc) return;
+    const row = this.instance(desc, id);
+    for (const cb of [...set.add]) cb(id, row);
+  }
+  emitRemove(name, id, value, hint) {
+    const set = this.entityListeners.get(name);
+    if (!set || set.remove.size === 0) return;
+    const row = this.freeze(value, hint);
+    for (const cb of [...set.remove]) cb(id, row);
+  }
+  /**
+   * The adds and removes a delta is about to make, captured against the state as it stands now:
+   * a remove's last values are only readable before `applyDelta` drops the row.
+   */
+  captureOps(delta) {
+    if (this.entityListeners.size === 0) return void 0;
+    const adds = [];
+    const removes = [];
+    for (const dc of delta.collections) {
+      const set = this.entityListeners.get(dc.name);
+      if (!set || set.add.size === 0 && set.remove.size === 0) continue;
+      const desc = this.desc(dc.name);
+      if (!desc || desc.kind !== "entity") continue;
+      const coll = entityOf(this.plain, dc.name);
+      for (const op of dc.ops) {
+        if (op.op === "add") {
+          if (!coll.has(op.id)) adds.push([dc.name, op.id]);
+        } else if (op.op === "remove") {
+          const value = coll.get(op.id);
+          if (value) removes.push([dc.name, op.id, value]);
+        }
+      }
+    }
+    return adds.length === 0 && removes.length === 0 ? void 0 : { adds, removes };
+  }
+  flushOps(captured) {
+    if (!captured) return;
+    for (const [name, id, value] of captured.removes) {
+      const desc = this.desc(name);
+      this.emitRemove(
+        name,
+        id,
+        value,
+        desc ? `${desc.name}[${id}] has been removed; this is its last value` : name
+      );
+    }
+    for (const [name, id] of captured.adds) this.emitAdd(name, id);
+  }
+  /** Fires adds and removes for the difference a wholesale snapshot load made. */
+  emitSnapshotDiff(before) {
+    if (this.entityListeners.size === 0) return;
+    for (const [name, set] of this.entityListeners) {
+      const desc = this.desc(name);
+      if (!desc || desc.kind !== "entity") continue;
+      const prev = before.get(name) ?? /* @__PURE__ */ new Map();
+      const coll = entityOf(this.plain, name);
+      if (set.remove.size > 0) {
+        for (const [id, value] of prev) {
+          if (!coll.has(id)) {
+            this.emitRemove(
+              name,
+              id,
+              value,
+              `${name}[${id}] has been removed; this is its last value`
+            );
+          }
+        }
+      }
+      if (set.add.size > 0) {
+        for (const id of [...coll.ids()]) {
+          if (!prev.has(id)) this.emitAdd(name, id);
+        }
+      }
+    }
+  }
+  /** The rows every subscribed collection holds right now, for the snapshot diff. */
+  captureRows() {
+    const out = /* @__PURE__ */ new Map();
+    if (this.entityListeners.size === 0) return out;
+    for (const name of this.entityListeners.keys()) {
+      const desc = this.desc(name);
+      if (!desc || desc.kind !== "entity") continue;
+      const coll = entityOf(this.plain, name);
+      const rows = /* @__PURE__ */ new Map();
+      for (const [id, value] of coll) rows.set(id, value);
+      out.set(name, rows);
+    }
+    return out;
+  }
   // -- inbound frames -------------------------------------------------------
   /**
    * Applies a server `DELTA`. Update ops for instances this client owns are dropped field-wise
    * (server wins only through `CORRECT`); adds, removes and owner changes always apply.
    */
   applyServerDelta(delta) {
+    const captured = this.captureOps(delta);
     applyDelta(this.ext, this.plain, this.withoutOwnedUpdates(delta));
     this.replayOverAddEchoes(delta);
+    this.flushOps(captured);
   }
   /**
    * The flushed-write half of the §7.2 in-flight own-write fix: an `add` op for an instance this
@@ -453,7 +593,9 @@ var ClientStore = class {
         });
       }
     }
+    const captured = this.captureOps(delta);
     applyDelta(this.ext, this.plain, delta);
+    this.flushOps(captured);
     let replayed = 0;
     if (replay) {
       for (const pw of [...this.pendingWrites, unflushed]) {

package/dist/{chunk-DABQDR3S.js → chunk-VZFJXPVF.js}

@@ -5,7 +5,7 @@ import {
   RESIM_DEPTH,
   SMOOTHING_HALF_LIFE_MS,
   SMOOTHING_SNAP_UNITS
-} from "./chunk-XWVXZRBS.js";
+} from "./chunk-5OHONPVG.js";
 
 // src/predictor.ts
 var MAX_FREE_STEPS_PER_FRAME = 5;
@@ -133,6 +133,7 @@ var Predictor = class _Predictor {
     resimSteps: 0,
     rebases: 0,
     snaps: 0,
+    leadClamped: 0,
     suppressed: 0,
     overCap: 0,
     proxies: 0,
@@ -951,8 +952,8 @@ var Predictor = class _Predictor {
    * written, so plain state holds exactly what the server said), then re-step the world by the
    * client's lead, applying to each re-stepped tick the intent that was in force *at that tick*:
    * the newest buffered unjudged write stamped at or before it, or the baseline (the newest
-   * judged write) before the first of them. Bounded by `MAX_LEAD`: an outrun lead snaps to
-   * authority and counts (`stats.snaps`).
+   * judged write) before the first of them. Bounded by `MAX_LEAD`: an outrun lead re-steps that
+   * many and counts (`stats.leadClamped`, bugs.md #71).
    */
   rebase() {
     if (!this.worldReady) return;
@@ -966,7 +967,9 @@ var Predictor = class _Predictor {
       const k = key(entry.desc.name, entry.id);
       this.predictedTicks.set(k, Math.max(this.authorityTick, this.authorityTicks.get(k) ?? 0));
     }
-    const lead = this.leadTicks();
+    const wanted = this.leadTicks();
+    const lead = Math.min(wanted, MAX_LEAD);
+    if (wanted > MAX_LEAD) this.stats.leadClamped++;
     if (this.lastLead !== void 0 && lead !== this.lastLead && this.gapMeasured) {
       const delta = lead - this.lastLead;
       this.stampGap = Math.min(RESIM_DEPTH, Math.max(0, this.stampGap + delta));
@@ -975,10 +978,6 @@ var Predictor = class _Predictor {
     }
     this.lastLead = lead;
     this.headTick = this.authorityTick;
-    if (lead > MAX_LEAD) {
-      this.stats.snaps++;
-      return;
-    }
     const replays = /* @__PURE__ */ new Map();
     for (const entry of this.bodies.values()) {
       if (!entry.owned) continue;