@irtio/runtime 1.0.0 → 3.0.0

package/dist/{chunk-YWDRE77H.js → chunk-3BCTP4YS.js}

@@ -1,7 +1,9 @@
 import {
+  HOLD_ACTIONS,
   parseHibernationBlob,
+  sameSchemaHash,
   writeHibernationBlob
-} from "./chunk-LT46QFLW.js";
+} from "./chunk-NPRIYYNM.js";
 
 // src/migrate.ts
 import { PRESENCE_COLLECTION, withBuiltins } from "@irtio/protocol";
@@ -24,8 +26,18 @@ function migrateSnapshot(blob, chain, options) {
   }
   const parsed = parseHibernationBlob(blob);
   let schema = schemaFromCanonical(first.schemaJson);
-  let plain = decodeSnapshot(withBuiltins(schema), parsed.snapshot).state;
-  let state = toMigrationState(withBuiltins(schema), plain);
+  let ext = withBuiltins(schema);
+  if (!sameSchemaHash(parsed.schemaHash8, ext.hash8)) {
+    throw new Error(
+      `migrateSnapshot: room ${options.roomId}: the snapshot was written under schema ${hex(parsed.schemaHash8)}, but the chain starts at v${first.version} whose schema is ${hex(ext.hash8)}. The migration chain does not begin at the deployment these bytes were written under \u2014 most likely the save predates the oldest retained deployment.`
+    );
+  }
+  let plain = decodeSnapshot(ext, parsed.snapshot, {
+    onNonFinite: (path, value) => options.log?.("warn", [
+      `migrateSnapshot: room ${options.roomId}: ${path} held ${value}; reset to its default`
+    ])
+  }).state;
+  let state = toMigrationState(ext, plain);
   delete state[PRESENCE_COLLECTION];
   const applied = [];
   for (let i = 1; i < chain.length; i++) {
@@ -51,7 +63,8 @@ function migrateSnapshot(blob, chain, options) {
     }
     schema = nextSchema;
   }
-  plain = fromMigrationState(withBuiltins(schema), state, last.version);
+  ext = withBuiltins(schema);
+  plain = fromMigrationState(ext, state, last.version);
   const bytes = writeHibernationBlob(
     {
       seed: parsed.seed,
@@ -60,9 +73,23 @@ function migrateSnapshot(blob, chain, options) {
       mode: parsed.mode,
       // Stamped with the *target* schema: these bytes are now that schema's, and a room waking on
       // it must not see them as a mismatch.
-      schemaHash8: withBuiltins(schema).hash8
+      schemaHash8: ext.hash8
     },
-    encodeSnapshot(withBuiltins(schema), plain, { tick: parsed.tick })
+    encodeSnapshot(ext, plain, { tick: parsed.tick }),
+    // The physics section is dropped, and that is the D22 rule rather than an oversight: the world
+    // is rebuilt from post-transform schema state, because pose and velocity ARE schema fields and
+    // a migration is free to move them. Carrying the serialized world across would silently
+    // overwrite whatever the transform wrote — `physics-migrate.test.ts` pins both halves of that.
+    // What follows here is the *third* section, which had no such reason.
+    void 0,
+    // D77 holds were dropped the same way physics is, but by accident: `writeHibernationBlob` takes
+    // four arguments and this call passed two, so a migrating deploy silently emptied the hold map
+    // and nothing logged. A crate under `onLeave: { hold, then }` then woke with no hold, its
+    // deadline never fired, and the record stayed owned by a client id that never comes back —
+    // unwritable by anyone, forever. Unlike a physics world, a hold has no field layout in it, so
+    // it survives a schema change on its own terms; what it needs is re-validating against the
+    // schema it is about to wake under.
+    migrateHolds(parsed.holds, ext, options)
   );
   return {
     bytes,
@@ -72,6 +99,52 @@ function migrateSnapshot(blob, chain, options) {
     ms: performance.now() - startedAt
   };
 }
+function hex(bytes) {
+  if (!bytes) return "(none \u2014 a pre-v3 blob carries no schema hash)";
+  return [...bytes].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function migrateHolds(bytes, target, options) {
+  if (!bytes || bytes.length === 0) return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(new TextDecoder().decode(bytes));
+  } catch (err) {
+    options.log?.("warn", ["migrate: hold deadlines did not decode; they are dropped:", err]);
+    return void 0;
+  }
+  if (!Array.isArray(parsed)) {
+    options.log?.("warn", ["migrate: hold deadlines were not an array; they are dropped"]);
+    return void 0;
+  }
+  const entities = new Map(
+    target.collections.map((c) => [c.name, c.kind])
+  );
+  const kept = [];
+  for (const h of parsed) {
+    if (typeof h?.collection !== "string" || typeof h.id !== "string" || typeof h.holder !== "string" || typeof h.deadlineMs !== "number") {
+      options.log?.("warn", ["migrate: dropping a hold that is not a hold record:", h]);
+      continue;
+    }
+    const kind = entities.get(h.collection);
+    if (kind !== "entity") {
+      options.log?.("warn", [
+        `migrate: dropping the hold on ${h.collection}.${h.id} \u2014`,
+        kind === void 0 ? "the target schema no longer declares that collection" : "that collection is no longer an entity collection"
+      ]);
+      continue;
+    }
+    if (!HOLD_ACTIONS.has(h.then)) {
+      options.log?.("warn", [
+        `migrate: dropping the hold on ${h.collection}.${h.id} \u2014 unknown leave action`,
+        h.then
+      ]);
+      continue;
+    }
+    kept.push(h);
+  }
+  if (kept.length === 0) return void 0;
+  return new TextEncoder().encode(JSON.stringify(kept));
+}
 function toMigrationState(schema, plain) {
   const out = {};
   for (const c of schema.collections) {