@irtio/runtime 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 irtio contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/chunk-3DQHT4CM.js

@@ -0,0 +1,129 @@
+import {
+  parseHibernationBlob,
+  writeHibernationBlob
+} from "./chunk-X5S364FY.js";
+
+// src/migrate.ts
+import { PRESENCE_COLLECTION, withBuiltins } from "@irtio/protocol";
+import {
+  createState,
+  decodeSnapshot,
+  encodeSnapshot,
+  normalizeRecord,
+  schemaFromCanonical
+} from "@irtio/schema";
+function migrateSnapshot(blob, chain, options) {
+  if (chain.length === 0) throw new Error("migrateSnapshot: empty migration chain");
+  const startedAt = performance.now();
+  const first = chain[0];
+  const last = chain[chain.length - 1];
+  for (let i = 1; i < chain.length; i++) {
+    if (chain[i].version <= chain[i - 1].version) {
+      throw new Error("migrateSnapshot: chain versions must ascend");
+    }
+  }
+  const parsed = parseHibernationBlob(blob);
+  let schema = schemaFromCanonical(first.schemaJson);
+  let plain = decodeSnapshot(withBuiltins(schema), parsed.snapshot).state;
+  let state = toMigrationState(withBuiltins(schema), plain);
+  delete state[PRESENCE_COLLECTION];
+  const applied = [];
+  for (let i = 1; i < chain.length; i++) {
+    const step = chain[i];
+    const nextSchema = schemaFromCanonical(step.schemaJson);
+    if (step.migration) {
+      const helpers = {
+        version: step.version,
+        fromVersion: chain[i - 1].version,
+        roomId: options.roomId,
+        log: (...args) => options.log?.("info", [`migration v${step.version}:`, ...args])
+      };
+      let produced;
+      try {
+        produced = step.migration.up(state, helpers);
+      } catch (err) {
+        throw new Error(
+          `migration to v${step.version} threw: ${err instanceof Error ? err.stack ?? err.message : String(err)}`
+        );
+      }
+      if (produced !== void 0) state = produced;
+      applied.push(step.version);
+    }
+    schema = nextSchema;
+  }
+  plain = fromMigrationState(withBuiltins(schema), state, last.version);
+  const bytes = writeHibernationBlob(
+    { seed: parsed.seed, rngState: parsed.rngState, tick: parsed.tick, mode: parsed.mode },
+    encodeSnapshot(withBuiltins(schema), plain, { tick: parsed.tick })
+  );
+  return {
+    bytes,
+    fromVersion: first.version,
+    toVersion: last.version,
+    applied,
+    ms: performance.now() - startedAt
+  };
+}
+function toMigrationState(schema, plain) {
+  const out = {};
+  for (const c of schema.collections) {
+    const held = plain[c.name];
+    if (c.kind === "entity") {
+      const coll = held;
+      const map = {};
+      for (const [id, rec] of coll.records) {
+        map[id] = { owner: rec.owner, value: { ...rec.value } };
+      }
+      out[c.name] = map;
+    } else {
+      out[c.name] = { ...held };
+    }
+  }
+  return out;
+}
+function fromMigrationState(schema, state, version) {
+  const known = new Set(schema.collections.map((c) => c.name));
+  for (const name of Object.keys(state)) {
+    if (!known.has(name)) {
+      throw new Error(
+        `migration produced a collection ${JSON.stringify(name)} that v${version}'s schema does not declare`
+      );
+    }
+  }
+  const plain = createState(schema);
+  for (const c of schema.collections) {
+    if (c.name === PRESENCE_COLLECTION) continue;
+    const given = state[c.name];
+    if (given === void 0) continue;
+    if (c.kind === "entity") {
+      const coll = plain[c.name];
+      for (const [id, rec] of Object.entries(given)) {
+        if (typeof rec !== "object" || rec === null) {
+          throw new Error(`migration: ${c.name}.${id} must be a { owner, value } record`);
+        }
+        try {
+          coll.add(id, rec.value ?? {}, { owner: typeof rec.owner === "string" ? rec.owner : "" });
+        } catch (err) {
+          throw new Error(
+            `migration: ${c.name}.${id} does not fit v${version}'s schema: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+      }
+    } else {
+      try {
+        plain[c.name] = normalizeRecord(c, given);
+      } catch (err) {
+        throw new Error(
+          `migration: ${c.name} does not fit v${version}'s schema: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+  }
+  return plain;
+}
+
+export {
+  migrateSnapshot,
+  toMigrationState,
+  fromMigrationState
+};