@table-games-engine/persistence 0.0.0-stage → 0.1.1

package/dist/index.js

@@ -0,0 +1,1691 @@
+// src/checksum.ts
+var FNV_OFFSET = 2166136261;
+var FNV_PRIME = 16777619;
+function fnv1a32(input) {
+  let h = FNV_OFFSET;
+  for (let i = 0; i < input.length; i++) {
+    h ^= input.charCodeAt(i);
+    h = Math.imul(h, FNV_PRIME);
+  }
+  return h >>> 0;
+}
+function canonicalize(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "null";
+  const t = typeof value;
+  if (t === "number") {
+    if (!Number.isFinite(value)) return "null";
+    return JSON.stringify(value);
+  }
+  if (t === "string" || t === "boolean") return JSON.stringify(value);
+  if (Array.isArray(value)) {
+    return "[" + value.map((v) => canonicalize(v)).join(",") + "]";
+  }
+  if (t === "object") {
+    const obj = value;
+    const keys = Object.keys(obj).sort();
+    const parts = [];
+    for (const k of keys) {
+      const v = obj[k];
+      if (v === void 0) continue;
+      parts.push(JSON.stringify(k) + ":" + canonicalize(v));
+    }
+    return "{" + parts.join(",") + "}";
+  }
+  return "null";
+}
+function checksumState(state) {
+  const canonical = canonicalize(state);
+  const h = fnv1a32(canonical);
+  return h.toString(16).padStart(8, "0");
+}
+
+// src/in-memory.ts
+var InMemoryAdapter = class {
+  matches = /* @__PURE__ */ new Map();
+  now;
+  closed = false;
+  constructor(now = () => Date.now()) {
+    this.now = now;
+  }
+  getOrCreate(matchId) {
+    let data = this.matches.get(matchId);
+    if (!data) {
+      data = {
+        snapshots: [],
+        events: [],
+        lastEventVersion: -1,
+        ownership: null
+      };
+      this.matches.set(matchId, data);
+    }
+    return data;
+  }
+  persistSnapshot(matchId, state, checksum) {
+    const data = this.getOrCreate(matchId);
+    const version = state.version;
+    const existing = data.snapshots.find((s) => s.version === version);
+    if (existing && existing.checksum !== checksum) {
+      return Promise.reject(
+        new Error(
+          `InMemoryAdapter: snapshot integrity violation for match ${String(
+            matchId
+          )} at version ${String(version)}: existing checksum ${existing.checksum} != new checksum ${checksum}`
+        )
+      );
+    }
+    if (!existing) {
+      data.snapshots.push({ version, state, checksum });
+    }
+    return Promise.resolve();
+  }
+  loadSnapshot(matchId, atVersion) {
+    const data = this.matches.get(matchId);
+    if (!data || data.snapshots.length === 0) return Promise.resolve(null);
+    let chosen = null;
+    if (atVersion === void 0) {
+      let bestIdx = -1;
+      let bestVersion = -Infinity;
+      for (let i = 0; i < data.snapshots.length; i++) {
+        const s = data.snapshots[i];
+        const v = s.version;
+        if (v >= bestVersion) {
+          bestVersion = v;
+          bestIdx = i;
+        }
+      }
+      chosen = bestIdx >= 0 ? data.snapshots[bestIdx] : null;
+    } else {
+      const target = atVersion;
+      let bestVersion = -Infinity;
+      for (const s of data.snapshots) {
+        const v = s.version;
+        if (v <= target && v >= bestVersion) {
+          bestVersion = v;
+          chosen = s;
+        }
+      }
+    }
+    if (!chosen) return Promise.resolve(null);
+    const computed = checksumState(chosen.state);
+    if (computed !== chosen.checksum) {
+      return Promise.reject(
+        new Error(
+          `InMemoryAdapter: checksum mismatch on load for match ${String(
+            matchId
+          )} at version ${String(chosen.version)}: stored ${chosen.checksum}, computed ${computed}`
+        )
+      );
+    }
+    return Promise.resolve(chosen.state);
+  }
+  appendEvents(matchId, transitionVersion, events) {
+    const data = this.getOrCreate(matchId);
+    const v = transitionVersion;
+    if (v <= data.lastEventVersion) {
+      return Promise.reject(
+        new Error(
+          `InMemoryAdapter: appendEvents version regression for match ${String(
+            matchId
+          )}: got ${v}, last was ${data.lastEventVersion}`
+        )
+      );
+    }
+    data.events.push({ version: transitionVersion, events });
+    data.lastEventVersion = v;
+    return Promise.resolve();
+  }
+  loadEvents(matchId, fromVersion, toVersion) {
+    const data = this.matches.get(matchId);
+    if (!data) return Promise.resolve([]);
+    const from = fromVersion;
+    const to = toVersion;
+    const out = [];
+    for (const batch of data.events) {
+      const v = batch.version;
+      if (v > from && v <= to) {
+        out.push(...batch.events);
+      }
+    }
+    return Promise.resolve(out);
+  }
+  acquireOwnership(matchId, ownerNode, leaseSeconds) {
+    const data = this.getOrCreate(matchId);
+    const now = this.now();
+    const current = data.ownership;
+    const expired = current === null || current.expiresAt <= now;
+    if (!expired && current.owner !== ownerNode) {
+      return Promise.resolve(false);
+    }
+    data.ownership = {
+      owner: ownerNode,
+      expiresAt: now + leaseSeconds * 1e3
+    };
+    return Promise.resolve(true);
+  }
+  releaseOwnership(matchId, ownerNode) {
+    const data = this.matches.get(matchId);
+    if (!data) return Promise.resolve();
+    if (data.ownership && data.ownership.owner === ownerNode) {
+      data.ownership = null;
+    }
+    return Promise.resolve();
+  }
+  close() {
+    this.closed = true;
+    void this.closed;
+    return Promise.resolve();
+  }
+};
+
+// src/sqlite/adapter.ts
+import Database from "better-sqlite3";
+
+// src/sqlite/migrations.ts
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+var CURRENT_SCHEMA_VERSION = 1;
+var SCHEMA_VERSION_KEY = "schema_version";
+function schemaPath() {
+  const here = dirname(fileURLToPath(import.meta.url));
+  return join(here, "schema.sql");
+}
+function applyMigrations(db) {
+  const ddl = readFileSync(schemaPath(), "utf8");
+  const tx = db.transaction(() => {
+    db.exec(ddl);
+    const existing = getSchemaVersion(db);
+    if (existing < CURRENT_SCHEMA_VERSION) {
+      setSchemaVersion(db, CURRENT_SCHEMA_VERSION);
+    }
+  });
+  tx();
+}
+function getSchemaVersion(db) {
+  const meta = db.prepare(
+    "SELECT name FROM sqlite_master WHERE type='table' AND name='_meta'"
+  ).get();
+  if (!meta) return 0;
+  const row = db.prepare("SELECT value FROM _meta WHERE key = ?").get(SCHEMA_VERSION_KEY);
+  if (!row) return 0;
+  const n = Number.parseInt(row.value, 10);
+  return Number.isFinite(n) ? n : 0;
+}
+function setSchemaVersion(db, n) {
+  db.prepare(
+    "INSERT INTO _meta(key, value) VALUES(?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value"
+  ).run(SCHEMA_VERSION_KEY, String(n));
+}
+
+// src/sqlite/adapter.ts
+var SqliteAdapter = class {
+  db;
+  now;
+  // Prepared statements — created once and reused.
+  stmtInsertSnapshot;
+  stmtSelectSnapshotChecksum;
+  stmtSelectLatestSnapshot;
+  stmtSelectSnapshotAtVersion;
+  stmtMaxEventVersion;
+  stmtInsertEvent;
+  stmtSelectEvents;
+  stmtSelectOwnership;
+  stmtUpsertOwnership;
+  stmtDeleteOwnership;
+  constructor(path, opts = {}) {
+    this.db = new Database(path);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("foreign_keys = ON");
+    applyMigrations(this.db);
+    this.now = opts.now ?? (() => Date.now());
+    this.stmtInsertSnapshot = this.db.prepare(
+      "INSERT OR IGNORE INTO snapshots(match_id, version, state_json, checksum, taken_at) VALUES (?, ?, ?, ?, ?)"
+    );
+    this.stmtSelectSnapshotChecksum = this.db.prepare(
+      "SELECT checksum FROM snapshots WHERE match_id = ? AND version = ?"
+    );
+    this.stmtSelectLatestSnapshot = this.db.prepare(
+      "SELECT state_json, checksum, version FROM snapshots WHERE match_id = ? ORDER BY version DESC LIMIT 1"
+    );
+    this.stmtSelectSnapshotAtVersion = this.db.prepare(
+      "SELECT state_json, checksum, version FROM snapshots WHERE match_id = ? AND version <= ? ORDER BY version DESC LIMIT 1"
+    );
+    this.stmtMaxEventVersion = this.db.prepare(
+      "SELECT MAX(version) AS c FROM events WHERE match_id = ?"
+    );
+    this.stmtInsertEvent = this.db.prepare(
+      "INSERT INTO events(match_id, version, idx, event_json) VALUES (?, ?, ?, ?)"
+    );
+    this.stmtSelectEvents = this.db.prepare(
+      "SELECT event_json FROM events WHERE match_id = ? AND version > ? AND version <= ? ORDER BY version, idx"
+    );
+    this.stmtSelectOwnership = this.db.prepare(
+      "SELECT owner_node, expires_at FROM ownership WHERE match_id = ?"
+    );
+    this.stmtUpsertOwnership = this.db.prepare(
+      "INSERT OR REPLACE INTO ownership(match_id, owner_node, expires_at) VALUES (?, ?, ?)"
+    );
+    this.stmtDeleteOwnership = this.db.prepare(
+      "DELETE FROM ownership WHERE match_id = ? AND owner_node = ?"
+    );
+  }
+  // ---------------------------------------------------------------------------
+  // Snapshots
+  // ---------------------------------------------------------------------------
+  persistSnapshot(matchId, state, checksum) {
+    const version = state.version;
+    const json = JSON.stringify(state);
+    const takenAt = this.now();
+    try {
+      const tx = this.db.transaction(() => {
+        const result = this.stmtInsertSnapshot.run(
+          matchId,
+          version,
+          json,
+          checksum,
+          takenAt
+        );
+        if (result.changes === 0) {
+          const existing = this.stmtSelectSnapshotChecksum.get(
+            matchId,
+            version
+          );
+          if (existing && existing.checksum !== checksum) {
+            throw new Error(
+              `SqliteAdapter: snapshot integrity violation for match ${String(
+                matchId
+              )} at version ${version}: existing checksum ${existing.checksum} != new checksum ${checksum}`
+            );
+          }
+        }
+      });
+      tx.immediate();
+    } catch (err2) {
+      return Promise.reject(err2);
+    }
+    return Promise.resolve();
+  }
+  loadSnapshot(matchId, atVersion) {
+    let row;
+    if (atVersion === void 0) {
+      row = this.stmtSelectLatestSnapshot.get(matchId);
+    } else {
+      row = this.stmtSelectSnapshotAtVersion.get(
+        matchId,
+        atVersion
+      );
+    }
+    if (!row) return Promise.resolve(null);
+    let state;
+    try {
+      state = JSON.parse(row.state_json);
+    } catch (err2) {
+      return Promise.reject(
+        new Error(
+          `SqliteAdapter: failed to parse stored state for match ${String(
+            matchId
+          )} at version ${row.version}: ${err2.message}`
+        )
+      );
+    }
+    const computed = checksumState(state);
+    if (computed !== row.checksum) {
+      return Promise.reject(
+        new Error(
+          `SqliteAdapter: checksum mismatch on load for match ${String(
+            matchId
+          )} at version ${row.version}: stored ${row.checksum}, computed ${computed}`
+        )
+      );
+    }
+    return Promise.resolve(state);
+  }
+  // ---------------------------------------------------------------------------
+  // Events
+  // ---------------------------------------------------------------------------
+  appendEvents(matchId, transitionVersion, events) {
+    if (events.length === 0) return Promise.resolve();
+    const v = transitionVersion;
+    try {
+      const tx = this.db.transaction(() => {
+        const max = this.stmtMaxEventVersion.get(
+          matchId
+        );
+        const existing = max.c ?? -1;
+        if (existing >= 0 && v <= existing) {
+          throw new Error(
+            `SqliteAdapter: appendEvents version regression for match ${String(
+              matchId
+            )}: got ${v}, last was ${existing}`
+          );
+        }
+        for (let i = 0; i < events.length; i++) {
+          const ev = events[i];
+          this.stmtInsertEvent.run(
+            matchId,
+            v,
+            i,
+            JSON.stringify(ev)
+          );
+        }
+      });
+      tx.immediate();
+    } catch (err2) {
+      return Promise.reject(err2);
+    }
+    return Promise.resolve();
+  }
+  loadEvents(matchId, fromVersion, toVersion) {
+    const rows = this.stmtSelectEvents.all(
+      matchId,
+      fromVersion,
+      toVersion
+    );
+    const out = rows.map(
+      (r) => JSON.parse(r.event_json)
+    );
+    return Promise.resolve(out);
+  }
+  // ---------------------------------------------------------------------------
+  // Ownership / leasing
+  // ---------------------------------------------------------------------------
+  acquireOwnership(matchId, ownerNode, leaseSeconds) {
+    const now = this.now();
+    let acquired = false;
+    try {
+      const tx = this.db.transaction(() => {
+        const current = this.stmtSelectOwnership.get(
+          matchId
+        );
+        const expired = !current || current.expires_at <= now;
+        if (!expired && current.owner_node !== ownerNode) {
+          acquired = false;
+          return;
+        }
+        this.stmtUpsertOwnership.run(
+          matchId,
+          ownerNode,
+          now + leaseSeconds * 1e3
+        );
+        acquired = true;
+      });
+      tx.immediate();
+    } catch (err2) {
+      return Promise.reject(err2);
+    }
+    return Promise.resolve(acquired);
+  }
+  releaseOwnership(matchId, ownerNode) {
+    this.stmtDeleteOwnership.run(matchId, ownerNode);
+    return Promise.resolve();
+  }
+  // ---------------------------------------------------------------------------
+  // Lifecycle
+  // ---------------------------------------------------------------------------
+  /**
+   * Close the underlying database. Subsequent calls into adapter methods will
+   * throw with the better-sqlite3 native error ("The database connection is
+   * not open"); we do not wrap that to keep the contract minimal.
+   *
+   * Idempotent: calling `close()` twice is a no-op (better-sqlite3 tolerates
+   * the second close cleanly when the handle is already released).
+   */
+  close() {
+    if (this.db.open) {
+      this.db.close();
+    }
+    return Promise.resolve();
+  }
+};
+
+// src/replay.ts
+function replayMatch(adapter, matchId, toVersion) {
+  return adapter.loadSnapshot(matchId, toVersion);
+}
+function loadEventsBetween(adapter, matchId, fromVersion, toVersion) {
+  return adapter.loadEvents(matchId, fromVersion, toVersion);
+}
+
+// src/snapshots.ts
+function everyNTransitions(n) {
+  if (!Number.isInteger(n) || n < 1) {
+    throw new Error(
+      `everyNTransitions: n must be a positive integer (got ${String(n)})`
+    );
+  }
+  return {
+    shouldSnapshot(_state, sinceLast) {
+      return sinceLast.transitionsSince >= n;
+    }
+  };
+}
+function everyTTicks(t) {
+  if (!Number.isInteger(t) || t < 1) {
+    throw new Error(
+      `everyTTicks: t must be a positive integer (got ${String(t)})`
+    );
+  }
+  return {
+    shouldSnapshot(_state, sinceLast) {
+      return sinceLast.ticksSince >= t;
+    }
+  };
+}
+function always() {
+  return {
+    shouldSnapshot() {
+      return true;
+    }
+  };
+}
+function never() {
+  return {
+    shouldSnapshot() {
+      return false;
+    }
+  };
+}
+function combine(...policies) {
+  if (policies.length === 0) return never();
+  return {
+    shouldSnapshot(state, sinceLast) {
+      for (const p of policies) {
+        if (p.shouldSnapshot(state, sinceLast)) return true;
+      }
+      return false;
+    }
+  };
+}
+
+// ../core/src/types/primitives.ts
+function ok(value) {
+  return { ok: true, value };
+}
+function err(error) {
+  return { ok: false, error };
+}
+
+// ../core/src/engine/rng.ts
+function xorshift32(s) {
+  let x = s | 0;
+  x ^= x << 13;
+  x ^= x >>> 17;
+  x ^= x << 5;
+  return x >>> 0;
+}
+function nextRandom(state) {
+  const s = state[0] ?? 1;
+  const next = xorshift32(s) || 1;
+  return {
+    value: next / 4294967296,
+    // unsigned-32 / 2^32 -> [0, 1)
+    newRngState: [next],
+    consumed: 1
+  };
+}
+function randomInt(state, min, max) {
+  if (min > max) throw new Error(`randomInt: min ${min} > max ${max}`);
+  const r = nextRandom(state);
+  const span = max - min + 1;
+  return {
+    value: min + Math.floor(r.value * span),
+    newRngState: r.newRngState,
+    consumed: 1
+  };
+}
+function randomPick(state, array) {
+  if (array.length === 0) {
+    return { value: void 0, newRngState: state, consumed: 0 };
+  }
+  const r = randomInt(state, 0, array.length - 1);
+  return { value: array[r.value], newRngState: r.newRngState, consumed: 1 };
+}
+function randomShuffle(state, array) {
+  const out = [...array];
+  let s = state;
+  let consumed = 0;
+  for (let i = out.length - 1; i > 0; i--) {
+    const r = randomInt(s, 0, i);
+    [out[i], out[r.value]] = [out[r.value], out[i]];
+    s = r.newRngState;
+    consumed += 1;
+  }
+  return { value: out, newRngState: s, consumed };
+}
+
+// ../core/src/engine/context.ts
+function createContext(manifest, state) {
+  const idCounter = { n: 0 };
+  const ctx = {
+    manifest,
+    state,
+    tick: state.tick,
+    // === Deterministic RNG ===
+    random() {
+      return nextRandom(state.rng.state);
+    },
+    randomInt(min, max) {
+      return randomInt(state.rng.state, min, max);
+    },
+    randomPick(array) {
+      return randomPick(state.rng.state, array);
+    },
+    randomShuffle(array) {
+      return randomShuffle(state.rng.state, array);
+    },
+    // === State Queries ===
+    getPlayer(playerId) {
+      const player = state.players[playerId];
+      if (!player) return err("NOT_FOUND");
+      if (player.status === "eliminated") return err("ELIMINATED");
+      return ok({ player });
+    },
+    getActivePlayers() {
+      return Object.values(state.players).filter((p) => p.status !== "eliminated").map((p) => p.playerId);
+    },
+    getObject(objectId) {
+      const object = state.objects[objectId];
+      if (!object) return err("NOT_FOUND");
+      return ok({ object });
+    },
+    getObjectsInZone(zoneId) {
+      const zone = state.zones[zoneId];
+      if (!zone) return [];
+      const out = [];
+      for (const id of zone.objects) {
+        const obj = state.objects[id];
+        if (obj) out.push(obj);
+      }
+      return out;
+    },
+    findObjects(filter) {
+      const all = Object.values(state.objects);
+      return all.filter((o) => {
+        if (filter.zoneId && o.zoneId !== filter.zoneId) return false;
+        if (filter.controller && o.controller !== filter.controller)
+          return false;
+        if (filter.owner && o.owner !== filter.owner) return false;
+        if (filter.typeId && o.typeId !== filter.typeId) return false;
+        if (filter.tags && !filter.tags.every((t) => o.tags.includes(t)))
+          return false;
+        if (filter.custom && !filter.custom(o)) return false;
+        return true;
+      });
+    },
+    getZone(zoneId) {
+      const zone = state.zones[zoneId];
+      if (!zone) return err("NOT_FOUND");
+      return ok({ zone });
+    },
+    getPlayerZone(playerId, zoneType) {
+      const player = state.players[playerId];
+      if (!player) return err("NOT_FOUND");
+      const zoneId = player.zones[zoneType];
+      if (!zoneId) return err("NOT_FOUND");
+      const zone = state.zones[zoneId];
+      if (!zone) return err("NOT_FOUND");
+      return ok({ zone });
+    },
+    // === Condition Evaluation (manifest-wired in Task 14) ===
+    evaluateCondition(_condition) {
+      return true;
+    },
+    validateTargets(_frameId) {
+      return true;
+    },
+    // === Stack Queries ===
+    getCurrentFrame() {
+      const frames = state.stack.frames;
+      return frames[frames.length - 1];
+    },
+    getStack() {
+      return state.stack.frames;
+    },
+    isStackEmpty() {
+      return state.stack.frames.length === 0;
+    },
+    // === Priority Queries ===
+    getPriorityHolder() {
+      return state.priority.holder;
+    },
+    getActivePlayer() {
+      return state.turn.activePlayer;
+    },
+    getLegalActions(_playerId) {
+      return state.priority.window.legalActionTypes;
+    },
+    // === Effect Execution (manifest-wired in Task 14) ===
+    prepareEffect(_effect, _context) {
+      return { mutations: [], events: [], childEffects: [] };
+    },
+    // === ID Generation ===
+    generateId(prefix) {
+      idCounter.n += 1;
+      return `${prefix}-${state.version}-${idCounter.n}`;
+    }
+  };
+  return ctx;
+}
+
+// ../core/src/engine/frames.ts
+function deriveFrameId(version, clientId) {
+  return `frame-${version}-${clientId}`;
+}
+function rawTargetsToSelections(targets) {
+  const out = {};
+  for (const [name, raw] of Object.entries(targets)) {
+    const r = raw;
+    if (r.type === "player" && typeof r.playerId === "string") {
+      out[name] = { type: "player", playerId: r.playerId };
+    } else if (r.type === "object" && typeof r.objectId === "string") {
+      out[name] = { type: "object", objectId: r.objectId };
+    } else if (r.type === "zone" && typeof r.zoneId === "string") {
+      out[name] = { type: "zone", zoneId: r.zoneId };
+    } else if (r.type === "stack-frame" && typeof r.frameId === "string") {
+      out[name] = { type: "stack-frame", frameId: r.frameId };
+    }
+  }
+  return out;
+}
+function buildActionFrame(args) {
+  const speed = args.def.speed ?? "instant";
+  return {
+    frameId: deriveFrameId(args.version, args.clientId),
+    frameType: "action",
+    actionTypeId: args.def.id,
+    actor: args.actor,
+    speed,
+    createdAt: args.tick,
+    status: "pending",
+    source: { type: "player", playerId: args.actor },
+    targets: {
+      targets: rawTargetsToSelections(args.data.targets),
+      valid: true
+    },
+    payload: args.data.payload,
+    paidCosts: [],
+    children: [],
+    parentFrame: null
+  };
+}
+
+// ../core/src/engine/validate.ts
+function fail(code, message, details) {
+  const error = details ? { code, message, details } : { code, message };
+  return { valid: false, error };
+}
+function validateAction(state, manifest, input) {
+  if (state.priority.holder !== input.playerId) {
+    return fail(
+      "NOT_PRIORITY_HOLDER",
+      `${input.playerId} does not have priority`
+    );
+  }
+  if (input.type === "pass" || input.data.type === "pass") {
+    if (!state.priority.window.canPass) {
+      return fail("ILLEGAL_IN_WINDOW", "cannot pass right now");
+    }
+    return {
+      valid: true,
+      frame: {
+        frameId: "pass-noop",
+        frameType: "action",
+        actionTypeId: "__pass",
+        actor: input.playerId,
+        speed: "instant",
+        createdAt: state.tick,
+        status: "resolved",
+        source: { type: "player", playerId: input.playerId },
+        targets: { targets: {}, valid: true },
+        payload: {},
+        paidCosts: [],
+        children: [],
+        parentFrame: null
+      }
+    };
+  }
+  if (input.type === "concede" || input.data.type === "concede") {
+    return {
+      valid: true,
+      frame: {
+        frameId: "concede-noop",
+        frameType: "action",
+        actionTypeId: "__concede",
+        actor: input.playerId,
+        speed: "instant",
+        createdAt: state.tick,
+        status: "resolved",
+        source: { type: "player", playerId: input.playerId },
+        targets: { targets: {}, valid: true },
+        payload: {},
+        paidCosts: [],
+        children: [],
+        parentFrame: null
+      }
+    };
+  }
+  if (input.type === "timeout" || input.data.type === "timeout") {
+    return {
+      valid: true,
+      frame: {
+        frameId: "timeout-noop",
+        frameType: "action",
+        actionTypeId: "__timeout",
+        actor: input.playerId,
+        speed: "instant",
+        createdAt: state.tick,
+        status: "resolved",
+        source: { type: "player", playerId: input.playerId },
+        targets: { targets: {}, valid: true },
+        payload: {},
+        paidCosts: [],
+        children: [],
+        parentFrame: null
+      }
+    };
+  }
+  if (input.type !== "action" || input.data.type !== "action") {
+    return fail(
+      "ILLEGAL_IN_WINDOW",
+      `input type ${input.type} not supported by validateAction`
+    );
+  }
+  const data = input.data;
+  const actions = manifest.actions?.actions ?? {};
+  const def = actions[data.actionTypeId];
+  if (!def) {
+    return fail("INVALID_ACTION_TYPE", `unknown action ${data.actionTypeId}`);
+  }
+  const window = state.priority.window;
+  if (!window.legalActionTypes.includes(data.actionTypeId)) {
+    return fail(
+      "ILLEGAL_IN_WINDOW",
+      `${data.actionTypeId} not legal in current window`
+    );
+  }
+  const speed = def.speed ?? "instant";
+  if (window.speedRestriction === "instant-only" && speed === "sorcery") {
+    return fail(
+      "ILLEGAL_IN_WINDOW",
+      "sorcery-speed action not allowed; window is instant-only"
+    );
+  }
+  if (window.speedRestriction === "sorcery-only" && speed === "instant") {
+    return fail(
+      "ILLEGAL_IN_WINDOW",
+      "instant-speed action not allowed; window is sorcery-only"
+    );
+  }
+  if (window.speedRestriction === "none") {
+    return fail(
+      "ILLEGAL_IN_WINDOW",
+      "no player actions allowed in current window"
+    );
+  }
+  const frame = buildActionFrame({
+    actor: input.playerId,
+    def,
+    data,
+    tick: state.tick,
+    version: state.version,
+    clientId: input.clientId
+  });
+  return { valid: true, frame };
+}
+
+// ../core/src/engine/reducer.ts
+function applyMutation(state, mutation) {
+  switch (mutation.domain) {
+    case "stack":
+      return applyStack(state, mutation.operation);
+    case "zone":
+      return applyZone(state, mutation.operation);
+    case "object":
+      return applyObject(state, mutation.operation);
+    case "player":
+      return applyPlayer(state, mutation.operation);
+    case "phase":
+      return applyPhase(state, mutation.operation);
+    case "turn":
+      return applyTurn(state, mutation.operation);
+    case "shared":
+      return applyShared(state, mutation.operation);
+    case "rng":
+      return applyRng(state, mutation.operation);
+    default: {
+      const exhaustive = mutation;
+      throw new Error(`Unknown mutation domain: ${JSON.stringify(exhaustive)}`);
+    }
+  }
+}
+function applyStack(state, op) {
+  switch (op.type) {
+    case "push":
+      return {
+        ...state,
+        stack: { ...state.stack, frames: [...state.stack.frames, op.frame] }
+      };
+    case "pop": {
+      const frames = state.stack.frames.slice(0, -1);
+      return { ...state, stack: { ...state.stack, frames } };
+    }
+    case "update-frame": {
+      const frames = state.stack.frames.map(
+        (f) => f.frameId === op.frameId ? { ...f, ...op.updates } : f
+      );
+      return { ...state, stack: { ...state.stack, frames } };
+    }
+    case "clear":
+      return { ...state, stack: { ...state.stack, frames: [] } };
+    default: {
+      const exhaustive = op;
+      throw new Error(`Unknown stack op: ${JSON.stringify(exhaustive)}`);
+    }
+  }
+}
+function applyZone(state, op) {
+  const zones = { ...state.zones };
+  const get = (id) => zones[id];
+  switch (op.type) {
+    case "add-object": {
+      const z = get(op.zoneId);
+      if (!z) throw new Error(`zone not found: ${op.zoneId}`);
+      const objects = op.position == null ? [...z.objects, op.objectId] : [
+        ...z.objects.slice(0, op.position),
+        op.objectId,
+        ...z.objects.slice(op.position)
+      ];
+      zones[op.zoneId] = { ...z, objects };
+      return { ...state, zones };
+    }
+    case "remove-object": {
+      const z = get(op.zoneId);
+      if (!z) throw new Error(`zone not found: ${op.zoneId}`);
+      zones[op.zoneId] = {
+        ...z,
+        objects: z.objects.filter((o) => o !== op.objectId)
+      };
+      return { ...state, zones };
+    }
+    case "move-object": {
+      const from = get(op.fromZone);
+      const to = get(op.toZone);
+      if (!from || !to) throw new Error("zone not found in move");
+      zones[op.fromZone] = {
+        ...from,
+        objects: from.objects.filter((o) => o !== op.objectId)
+      };
+      const toObjects = op.position == null ? [...to.objects, op.objectId] : [
+        ...to.objects.slice(0, op.position),
+        op.objectId,
+        ...to.objects.slice(op.position)
+      ];
+      zones[op.toZone] = { ...to, objects: toObjects };
+      return { ...state, zones };
+    }
+    case "reorder": {
+      const z = get(op.zoneId);
+      if (!z) throw new Error(`zone not found: ${op.zoneId}`);
+      zones[op.zoneId] = { ...z, objects: [...op.newOrder] };
+      return { ...state, zones };
+    }
+    case "shuffle":
+      return state;
+    default: {
+      const exhaustive = op;
+      throw new Error(`Unknown zone op: ${JSON.stringify(exhaustive)}`);
+    }
+  }
+}
+function applyObject(state, op) {
+  const objects = { ...state.objects };
+  switch (op.type) {
+    case "create":
+      objects[op.object.objectId] = op.object;
+      return { ...state, objects };
+    case "destroy": {
+      const next = { ...objects };
+      delete next[op.objectId];
+      return { ...state, objects: next };
+    }
+    case "update": {
+      const o = objects[op.objectId];
+      if (!o) return state;
+      objects[op.objectId] = { ...o, ...op.updates };
+      return { ...state, objects };
+    }
+    case "set-counter": {
+      const o = objects[op.objectId];
+      if (!o) return state;
+      objects[op.objectId] = {
+        ...o,
+        counters: { ...o.counters, [op.counter]: op.value }
+      };
+      return { ...state, objects };
+    }
+    case "add-modification": {
+      const o = objects[op.objectId];
+      if (!o) return state;
+      objects[op.objectId] = {
+        ...o,
+        modifications: [
+          ...o.modifications,
+          op.modification
+        ]
+      };
+      return { ...state, objects };
+    }
+    case "remove-modification": {
+      const o = objects[op.objectId];
+      if (!o) return state;
+      objects[op.objectId] = {
+        ...o,
+        modifications: o.modifications.filter((m) => m.id !== op.modificationId)
+      };
+      return { ...state, objects };
+    }
+    case "tap": {
+      const o = objects[op.objectId];
+      if (!o) return state;
+      const tags = o.tags.includes("tapped") ? o.tags : [...o.tags, "tapped"];
+      objects[op.objectId] = { ...o, tapped: true, tags };
+      return { ...state, objects };
+    }
+    case "untap": {
+      const o = objects[op.objectId];
+      if (!o) return state;
+      objects[op.objectId] = {
+        ...o,
+        tapped: false,
+        tags: o.tags.filter((t) => t !== "tapped")
+      };
+      return { ...state, objects };
+    }
+    case "flip": {
+      const o = objects[op.objectId];
+      if (!o) return state;
+      objects[op.objectId] = { ...o, faceState: op.faceState };
+      return { ...state, objects };
+    }
+    default: {
+      const exhaustive = op;
+      throw new Error(`Unknown object op: ${JSON.stringify(exhaustive)}`);
+    }
+  }
+}
+function applyPlayer(state, op) {
+  const players = { ...state.players };
+  const p = players[op.playerId];
+  if (!p) return state;
+  switch (op.type) {
+    case "set-resource":
+      players[op.playerId] = {
+        ...p,
+        resources: { ...p.resources, [op.resource]: op.value }
+      };
+      return { ...state, players };
+    case "add-resource":
+      players[op.playerId] = {
+        ...p,
+        resources: {
+          ...p.resources,
+          [op.resource]: (p.resources[op.resource] ?? 0) + op.delta
+        }
+      };
+      return { ...state, players };
+    case "set-counter":
+      players[op.playerId] = {
+        ...p,
+        counters: { ...p.counters, [op.counter]: op.value }
+      };
+      return { ...state, players };
+    case "set-flag":
+      players[op.playerId] = {
+        ...p,
+        flags: { ...p.flags, [op.flag]: op.value }
+      };
+      return { ...state, players };
+    case "set-status":
+      players[op.playerId] = {
+        ...p,
+        status: op.status
+      };
+      return { ...state, players };
+    case "update-custom":
+      players[op.playerId] = {
+        ...p,
+        custom: { ...p.custom, [op.path]: op.value }
+      };
+      return { ...state, players };
+    default: {
+      const exhaustive = op;
+      throw new Error(`Unknown player op: ${JSON.stringify(exhaustive)}`);
+    }
+  }
+}
+function applyPhase(state, op) {
+  switch (op.type) {
+    case "enter": {
+      const phaseId = op.phaseId;
+      const visited = state.phase.visitedThisTurn.includes(phaseId) ? state.phase.visitedThisTurn : [...state.phase.visitedThisTurn, phaseId];
+      return {
+        ...state,
+        phase: {
+          ...state.phase,
+          current: phaseId,
+          enteredAt: state.tick,
+          visitedThisTurn: visited
+        }
+      };
+    }
+    case "exit":
+      return state;
+    case "set-visited":
+      return {
+        ...state,
+        phase: {
+          ...state.phase,
+          visitedThisTurn: [...op.phases]
+        }
+      };
+    default: {
+      const exhaustive = op;
+      throw new Error(`Unknown phase op: ${JSON.stringify(exhaustive)}`);
+    }
+  }
+}
+function applyTurn(state, op) {
+  const { turn } = state;
+  switch (op.type) {
+    case "advance": {
+      const idx = turn.turnOrder.indexOf(turn.activePlayer);
+      const len = Math.max(turn.turnOrder.length, 1);
+      const nextIdx = idx === -1 ? turn.activePlayerIndex % len : (idx + 1) % len;
+      const next = turn.turnOrder[nextIdx] ?? turn.activePlayer;
+      return {
+        ...state,
+        turn: {
+          ...turn,
+          turnNumber: turn.turnNumber + 1,
+          activePlayer: next,
+          activePlayerIndex: nextIdx
+        }
+      };
+    }
+    case "set-active-player": {
+      const idx = turn.turnOrder.indexOf(op.playerId);
+      return {
+        ...state,
+        turn: {
+          ...turn,
+          activePlayer: op.playerId,
+          activePlayerIndex: idx === -1 ? turn.activePlayerIndex : idx
+        }
+      };
+    }
+    case "add-extra-turn": {
+      const extra = { player: op.playerId, reason: op.reason };
+      return { ...state, turn: { ...turn, extraTurns: [...turn.extraTurns, extra] } };
+    }
+    case "eliminate-player": {
+      const newOrder = turn.turnOrder.filter((p) => p !== op.playerId);
+      const eliminated = turn.eliminatedPlayers.includes(op.playerId) ? turn.eliminatedPlayers : [...turn.eliminatedPlayers, op.playerId];
+      return {
+        ...state,
+        turn: { ...turn, turnOrder: newOrder, eliminatedPlayers: eliminated }
+      };
+    }
+    case "set-turn-order":
+      return {
+        ...state,
+        turn: { ...turn, turnOrder: [...op.order] }
+      };
+    default: {
+      const exhaustive = op;
+      throw new Error(`Unknown turn op: ${JSON.stringify(exhaustive)}`);
+    }
+  }
+}
+function applyShared(state, op) {
+  switch (op.type) {
+    case "set":
+      return {
+        ...state,
+        shared: {
+          ...state.shared,
+          [op.path]: op.value
+        }
+      };
+    case "merge":
+      return {
+        ...state,
+        shared: {
+          ...state.shared,
+          ...op.updates
+        }
+      };
+    default: {
+      const exhaustive = op;
+      throw new Error(`Unknown shared op: ${JSON.stringify(exhaustive)}`);
+    }
+  }
+}
+function applyRng(state, op) {
+  switch (op.type) {
+    case "advance":
+      return {
+        ...state,
+        rng: { ...state.rng, counter: state.rng.counter + op.count }
+      };
+    case "set-state":
+      return {
+        ...state,
+        rng: { ...state.rng, state: [...op.state] }
+      };
+    default: {
+      const exhaustive = op;
+      throw new Error(`Unknown rng op: ${JSON.stringify(exhaustive)}`);
+    }
+  }
+}
+
+// ../core/src/engine/transition.ts
+function inc(v) {
+  return v + 1;
+}
+function incTick(t) {
+  return t + 1;
+}
+function deriveTransitionId(version) {
+  return `tx-${version}`;
+}
+function applyTransition(state, mutations, events, cause, type = "state-based") {
+  let next = state;
+  for (const m of mutations) next = applyMutation(next, m);
+  const fromVersion = state.version;
+  const toVersion = inc(fromVersion);
+  const newTick = incTick(state.tick);
+  const newState = {
+    ...next,
+    version: toVersion,
+    tick: newTick,
+    recentEvents: [...next.recentEvents, ...events]
+  };
+  const transition = {
+    transitionId: deriveTransitionId(toVersion),
+    type,
+    fromVersion,
+    toVersion,
+    timestamp: newTick,
+    cause,
+    mutations: [...mutations],
+    events: [...events]
+  };
+  return { newState, transition };
+}
+
+// ../core/src/engine/stack.ts
+function peek(stack) {
+  return stack.frames[stack.frames.length - 1];
+}
+
+// ../core/src/engine/resolve.ts
+function resolveTopFrame(state, manifest, handlers) {
+  const top = peek(state.stack);
+  if (!top) return { kind: "stack-empty" };
+  if (!top.targets.valid) {
+    return { kind: "fizzled", frameId: top.frameId, reason: "targets-illegal" };
+  }
+  const key = top.frameType === "action" || top.frameType === "reaction" ? top.actionTypeId : top.frameType === "trigger" ? top.triggerId : top.effectType;
+  const handler = handlers[key];
+  if (!handler) return { kind: "no-handler", actionTypeId: key };
+  const ctx = createContext(manifest, state);
+  const result = handler(ctx, top);
+  return { kind: "resolved", frameId: top.frameId, result };
+}
+
+// ../core/src/engine/lifecycle.ts
+function advanceTurn(state) {
+  return applyMutation(state, { domain: "turn", operation: { type: "advance" } });
+}
+function advancePhase(state, manifest) {
+  const currentPhaseId = state.phase.current;
+  const transitions = manifest.phases?.transitions;
+  if (!transitions || transitions.length === 0) return state;
+  const candidates = transitions.filter((t) => t.from === currentPhaseId).slice().sort((a, b) => b.priority - a.priority);
+  const next = candidates[0]?.to;
+  if (!next) return state;
+  return applyMutation(state, {
+    domain: "phase",
+    operation: { type: "enter", phaseId: next }
+  });
+}
+function checkWin(state) {
+  const allPlayers = Object.values(state.players);
+  const active = allPlayers.filter((p) => p.status !== "eliminated");
+  if (active.length > 1) {
+    return { ended: false };
+  }
+  const winner = active[0];
+  const rankings = [];
+  if (winner) {
+    rankings.push({ playerId: winner.playerId, rank: 1 });
+  }
+  let nextRank = winner ? 2 : 1;
+  for (const p of allPlayers) {
+    if (winner && p.playerId === winner.playerId) continue;
+    rankings.push({ playerId: p.playerId, rank: nextRank });
+    nextRank += 1;
+  }
+  const result = {
+    outcome: winner ? "win" : "draw",
+    winners: winner ? [winner.playerId] : [],
+    rankings,
+    endedAt: state.tick
+  };
+  return { ended: true, result };
+}
+
+// ../core/src/engine/window.ts
+function computeWindow(state, manifest, _holder) {
+  const phaseId = state.phase.current;
+  const phase = manifest.phases.phases[phaseId];
+  const phaseActions = phase?.legalActions ?? [];
+  const top = state.stack.frames[state.stack.frames.length - 1];
+  const respondingTo = top ? top.frameId : null;
+  const type = respondingTo ? "response" : "main";
+  return {
+    type,
+    legalActionTypes: phaseActions,
+    speedRestriction: respondingTo ? "instant-only" : "any",
+    respondingTo,
+    restrictions: [],
+    canPass: true,
+    requiredAction: null
+  };
+}
+
+// ../core/src/engine/triggers.ts
+function resolveController(def, state) {
+  const raw = def.controller;
+  if (raw === "active-player" || raw === "source-controller" || raw === "all" || raw == null) {
+    return state.turn.activePlayer;
+  }
+  return raw;
+}
+function eventMatches(def, event) {
+  const pattern = def.event;
+  if (!pattern || typeof pattern.eventType !== "string") return false;
+  if (pattern.eventType !== event.type) return false;
+  const filters = pattern.filters;
+  if (filters) {
+    for (const key of Object.keys(filters)) {
+      if (event.data[key] !== filters[key]) return false;
+    }
+  }
+  return true;
+}
+function buildTriggerFrame(def, event, state) {
+  const controller = resolveController(def, state);
+  const frameId = `trigger-${state.version}-${def.id}-${event.eventId}`;
+  const optional = def.optional ?? false;
+  return {
+    frameId,
+    frameType: "trigger",
+    triggerId: def.id,
+    controller,
+    triggeringEvent: {
+      eventType: event.type,
+      eventData: event.data,
+      timestamp: event.timestamp
+    },
+    triggerSource: null,
+    optional,
+    createdAt: event.timestamp,
+    status: "pending",
+    source: { type: "trigger", triggerId: def.id, controller },
+    targets: { targets: {}, valid: true },
+    payload: {},
+    paidCosts: [],
+    children: [],
+    parentFrame: null
+  };
+}
+function scanTriggers(state, manifest, recentEvents) {
+  const catalog = manifest.triggers?.triggers ?? {};
+  const defs = Object.values(catalog);
+  const out = [];
+  for (const event of recentEvents) {
+    for (const def of defs) {
+      if (eventMatches(def, event)) {
+        out.push(buildTriggerFrame(def, event, state));
+      }
+    }
+  }
+  return orderApnap(out, state.turn.activePlayer);
+}
+function orderApnap(frames, activePlayer) {
+  const ap = [];
+  const nap = [];
+  for (const f of frames) {
+    if (f.controller === activePlayer) ap.push(f);
+    else nap.push(f);
+  }
+  return [...ap, ...nap];
+}
+
+// ../core/src/engine/operations.ts
+function refreshWindow(state, manifest) {
+  const holder = state.priority.holder ?? state.turn.activePlayer;
+  const window = computeWindow(state, manifest, holder);
+  return {
+    ...state,
+    priority: { ...state.priority, window }
+  };
+}
+function isSentinelFrameId(id) {
+  if (id.startsWith("pass-noop")) return "pass";
+  if (id.startsWith("concede-noop")) return "concede";
+  if (id.startsWith("timeout-noop")) return "timeout";
+  return null;
+}
+function createEngine(manifest, initialState, handlers) {
+  let state = initialState;
+  function setState(next) {
+    state = next;
+  }
+  return {
+    getState: () => state,
+    applyAction(input) {
+      const refreshed = refreshWindow(state, manifest);
+      setState(refreshed);
+      const validation = validateAction(refreshed, manifest, input);
+      if (!validation.valid) return err(validation);
+      const frame = validation.frame;
+      const sentinel = isSentinelFrameId(frame.frameId);
+      if (sentinel === "pass") {
+        const newPriority = {
+          ...refreshed.priority,
+          passed: refreshed.priority.passed.includes(input.playerId) ? refreshed.priority.passed : [...refreshed.priority.passed, input.playerId],
+          consecutivePasses: refreshed.priority.consecutivePasses + 1
+        };
+        const { newState: newState2, transition: transition2 } = applyTransition(
+          { ...refreshed, priority: newPriority },
+          [],
+          [],
+          { type: "player-action", playerId: input.playerId, input },
+          "priority-passed"
+        );
+        setState(newState2);
+        return ok(transition2);
+      }
+      if (sentinel === "concede" || sentinel === "timeout") {
+        const mutations = [
+          {
+            domain: "player",
+            operation: { type: "set-status", playerId: input.playerId, status: "eliminated" }
+          },
+          {
+            domain: "turn",
+            operation: { type: "eliminate-player", playerId: input.playerId }
+          }
+        ];
+        const { newState: newState2, transition: transition2 } = applyTransition(
+          refreshed,
+          mutations,
+          [],
+          { type: "player-action", playerId: input.playerId, input },
+          "player-eliminated"
+        );
+        setState(newState2);
+        return ok(transition2);
+      }
+      const { newState, transition } = applyTransition(
+        refreshed,
+        [{ domain: "stack", operation: { type: "push", frame } }],
+        [],
+        { type: "player-action", playerId: input.playerId, input },
+        "action-pushed"
+      );
+      setState(newState);
+      return ok(transition);
+    },
+    resolveTopFrame() {
+      const outcome = resolveTopFrame(state, manifest, handlers);
+      switch (outcome.kind) {
+        case "stack-empty":
+          return err("rule-violation");
+        case "no-handler":
+          return err("rule-violation");
+        case "fizzled": {
+          const { newState, transition } = applyTransition(
+            state,
+            [{ domain: "stack", operation: { type: "pop" } }],
+            [],
+            { type: "stack-resolution", frameId: outcome.frameId },
+            "action-countered"
+          );
+          setState(newState);
+          return ok(transition);
+        }
+        case "resolved": {
+          const r = outcome.result;
+          const childPushes = r.newFrames.map((f) => ({
+            domain: "stack",
+            operation: { type: "push", frame: f }
+          }));
+          const mutations = [
+            { domain: "stack", operation: { type: "pop" } },
+            ...r.mutations,
+            ...childPushes
+          ];
+          const { newState, transition } = applyTransition(
+            state,
+            mutations,
+            r.events,
+            { type: "stack-resolution", frameId: outcome.frameId },
+            "action-resolved"
+          );
+          setState(newState);
+          return ok(transition);
+        }
+      }
+    },
+    processTriggers() {
+      const triggers = scanTriggers(state, manifest, state.recentEvents);
+      const mutations = triggers.map((f) => ({
+        domain: "stack",
+        operation: { type: "push", frame: f }
+      }));
+      const { newState, transition } = applyTransition(
+        state,
+        mutations,
+        [],
+        { type: "system", reason: "process-triggers" },
+        "trigger-fired"
+      );
+      setState(newState);
+      return ok(transition);
+    },
+    checkStateBasedActions() {
+      const { newState, transition } = applyTransition(
+        state,
+        [],
+        [],
+        { type: "state-based-action" },
+        "state-based"
+      );
+      setState(newState);
+      return ok(transition);
+    },
+    advancePhase() {
+      const next = advancePhase(state, manifest);
+      if (next === state) return err("CANNOT_ADVANCE");
+      const nextPhaseId = next.phase.current;
+      const { newState, transition } = applyTransition(
+        state,
+        [{ domain: "phase", operation: { type: "enter", phaseId: nextPhaseId } }],
+        [],
+        { type: "phase-exit" },
+        "phase-changed"
+      );
+      setState(newState);
+      return ok(transition);
+    },
+    advanceTurn() {
+      const next = advanceTurn(state);
+      if (next === state) return err("CANNOT_ADVANCE");
+      const newActive = next.turn.activePlayer;
+      const { newState, transition } = applyTransition(
+        state,
+        [
+          { domain: "turn", operation: { type: "advance" } },
+          // Reset priority to the new active player so the next applyAction
+          // sees a consistent holder.
+          {
+            domain: "turn",
+            operation: { type: "set-active-player", playerId: newActive }
+          }
+        ],
+        [],
+        { type: "system", reason: "advance-turn" },
+        "turn-changed"
+      );
+      const withPriority = {
+        ...newState,
+        priority: { ...newState.priority, holder: newActive, passed: [], consecutivePasses: 0 }
+      };
+      setState(withPriority);
+      return ok(transition);
+    },
+    checkWinConditions() {
+      return checkWin(state);
+    }
+  };
+}
+
+// src/persisted-engine.ts
+var DEFAULT_LEASE_SECONDS = 60;
+async function createPersistedEngine(args) {
+  const {
+    manifest,
+    initialState,
+    handlers,
+    adapter,
+    matchId,
+    policy = everyNTransitions(50),
+    ownerNode,
+    leaseSeconds = DEFAULT_LEASE_SECONDS
+  } = args;
+  if (ownerNode !== void 0) {
+    const acquired = await adapter.acquireOwnership(
+      matchId,
+      ownerNode,
+      leaseSeconds
+    );
+    if (!acquired) {
+      throw new Error(
+        `createPersistedEngine: ownership lease for match ${String(
+          matchId
+        )} is held by another node; ${String(ownerNode)} could not acquire`
+      );
+    }
+  }
+  await adapter.persistSnapshot(
+    matchId,
+    initialState,
+    checksumState(initialState)
+  );
+  const engine = createEngine(manifest, initialState, handlers);
+  let transitionsSince = 0;
+  let lastSnapshotTick = initialState.tick;
+  let lastVersionPersisted = initialState.version;
+  async function persistTransition(transition) {
+    const tv = transition.toVersion;
+    if (tv <= lastVersionPersisted) {
+      return;
+    }
+    lastVersionPersisted = tv;
+    const events = transition.events;
+    if (events.length > 0) {
+      await adapter.appendEvents(matchId, transition.toVersion, events);
+    }
+    transitionsSince += 1;
+    const state = engine.getState();
+    const ticksSince = state.tick - lastSnapshotTick;
+    if (policy.shouldSnapshot(state, { transitionsSince, ticksSince })) {
+      await snapshotNow(state);
+    }
+  }
+  async function snapshotNow(state) {
+    await adapter.persistSnapshot(matchId, state, checksumState(state));
+    transitionsSince = 0;
+    lastSnapshotTick = state.tick;
+  }
+  let releasedOwnership = false;
+  async function releaseOwnership() {
+    if (ownerNode === void 0) return;
+    if (releasedOwnership) return;
+    releasedOwnership = true;
+    await adapter.releaseOwnership(matchId, ownerNode);
+  }
+  return {
+    getState: () => engine.getState(),
+    getMatchId: () => matchId,
+    async applyAction(input) {
+      const r = engine.applyAction(input);
+      if (r.ok) await persistTransition(r.value);
+      return r;
+    },
+    async resolveTopFrame() {
+      const r = engine.resolveTopFrame();
+      if (r.ok) await persistTransition(r.value);
+      return r;
+    },
+    async processTriggers() {
+      const r = engine.processTriggers();
+      if (r.ok) await persistTransition(r.value);
+      return r;
+    },
+    async checkStateBasedActions() {
+      const r = engine.checkStateBasedActions();
+      if (r.ok) await persistTransition(r.value);
+      return r;
+    },
+    async advancePhase() {
+      const r = engine.advancePhase();
+      if (r.ok) await persistTransition(r.value);
+      return r;
+    },
+    async advanceTurn() {
+      const r = engine.advanceTurn();
+      if (r.ok) await persistTransition(r.value);
+      return r;
+    },
+    checkWinConditions() {
+      return engine.checkWinConditions();
+    },
+    async forceSnapshot() {
+      await snapshotNow(engine.getState());
+    },
+    releaseOwnership,
+    async close() {
+      await releaseOwnership();
+      await adapter.close();
+    }
+  };
+}
+export {
+  InMemoryAdapter,
+  SqliteAdapter,
+  always,
+  checksumState,
+  combine,
+  createPersistedEngine,
+  everyNTransitions,
+  everyTTicks,
+  loadEventsBetween,
+  never,
+  replayMatch
+};