@patterkit/runtime 0.18.0 → 0.20.0

package/dist/index.js

@@ -21,6 +21,7 @@ function buildTagIndex(bundle) {
   const visit = (node, inherited) => {
     const acc = dedupe([...inherited, ...node.tags ?? []]);
     index.set(node.id, acc);
+    if (node.type === "group" && node.prompt) index.set(node.prompt.id, dedupe([...acc, ...node.prompt.tags ?? []]));
     if (node.type === "group") {
       for (const child of node.children) visit(child, acc);
     } else {
@@ -80,11 +81,13 @@ var Engine = class _Engine {
   sceneGameIdToId = /* @__PURE__ */ new Map();
   blockGameIdToId = /* @__PURE__ */ new Map();
   /** The options this engine was built with - reused verbatim by `hotSwap` so the replacement
-   *  engine keeps the same world resolver, custom RNG, and diagnostic hooks. */
+   *  engine keeps the same host scopes, custom RNG, and diagnostic hooks. */
   creationOptions;
   /** The run's ordered stream: every flow's events, each naming its flow. Empty and
    *  unwritten unless `options.log` asked for it. */
   engineLog = [];
+  /** The next engine-log `seq`: its own counter, since the log's length restarts after a clear. */
+  engineSeq = 0;
   engineTraceHandlers = /* @__PURE__ */ new Set();
   constructor(bundle, options = {}) {
     this.creationOptions = options;
@@ -130,12 +133,12 @@ var Engine = class _Engine {
       registry.mountOwned("patter", patterBag, { owner: OWNER });
       registered.push("patter");
       const hostBound = /* @__PURE__ */ new Set();
-      if (options.world) {
-        const worldSpec = bundle.scopeRegistry?.scopes.find((s) => s.token === "world");
-        const decls = (worldSpec?.declarations ?? []).map(toForeignDecl);
-        registry.defineForeign("world", options.world, decls, { writable: worldSpec?.writable ?? true, owner: OWNER });
-        registered.push("world");
-        hostBound.add("world");
+      for (const [token, resolver] of Object.entries(boundScopes(options))) {
+        const spec = bundle.scopeRegistry?.scopes.find((s) => s.token === token);
+        const decls = (spec?.declarations ?? []).map(toForeignDecl);
+        registry.defineForeign(token, resolver, decls, { writable: spec?.writable ?? true, owner: OWNER });
+        registered.push(token);
+        hostBound.add(token);
       }
       for (const spec of ownsRegistry ? bundle.scopeRegistry?.scopes ?? [] : []) {
         if (hostBound.has(spec.token) || registry.has(spec.token)) continue;
@@ -155,6 +158,7 @@ var Engine = class _Engine {
     }
     this.host = {
       logEnabled: options.log ?? false,
+      tracing: options.log ?? false,
       emitEngine: (flow, event, scene) => this.emitEngine(flow, event, scene),
       bundle,
       emitIds,
@@ -177,11 +181,13 @@ var Engine = class _Engine {
       patterSharedNames,
       sceneSharedNames,
       sharedVisits: /* @__PURE__ */ new Map(),
+      qualityLadders: /* @__PURE__ */ new Map(),
       sharedSelectors: /* @__PURE__ */ new Map(),
       stageBags: /* @__PURE__ */ new Map(),
       journal: null,
       customRng: options.rng,
       onDryChoice: options.onDryChoice,
+      onError: options.onError ?? ((e) => console.warn(`Patterplay: ${e.kind} on ${e.node} in flow '${e.flow}' failed, played through: ${e.message}`)),
       replayPromptOnChoose: options.replayPromptOnChoose ?? false,
       captionsOn: options.closedCaptions ?? true,
       // captions shown by default (full text)
@@ -202,6 +208,11 @@ var Engine = class _Engine {
   get isSourceDebug() {
     return this.sourceDebug;
   }
+  /** The bundle's build identity (its content hash), the one a debug link handshakes with, or an empty
+   *  string for a bundle compiled without one. */
+  get buildId() {
+    return this.host.bundle.content?.hash ?? "";
+  }
   /**
    * Switch the active locale LIVE - a real game's "language" setting can change mid-session. Subsequent
    * string lookups (new beats, re-resolved character names, `{@ref}` interpolation) render in the new
@@ -322,7 +333,7 @@ var Engine = class _Engine {
       });
     }
     this.flowsById.set(id, flow);
-    flow.start(sceneId, blockId);
+    flow.begin(sceneId, blockId);
     return flow;
   }
   /**
@@ -375,10 +386,10 @@ var Engine = class _Engine {
    */
   resolveOpenAddress(scene, block) {
     if (scene !== void 0) {
-      const sceneId = this.resolveSceneRef(scene);
-      if (!this.host.bundle.scenes[sceneId]) throw new Error(`unknown scene: ${scene}`);
+      const sceneId = resolveScene(this.host, scene);
+      if (sceneId === void 0) throw new Error(`unknown scene: ${scene}`);
       if (block === void 0) return { sceneId };
-      const blockId = this.blockGameIdToId.get(sceneId)?.get(block) ?? (this.host.blockIndex.get(block)?.sceneId === sceneId ? block : void 0);
+      const blockId = resolveBlock(this.host, sceneId, block);
       if (blockId === void 0) throw new Error(`unknown block: ${block}`);
       return { sceneId, blockId };
     }
@@ -389,21 +400,19 @@ var Engine = class _Engine {
     if (Object.keys(this.host.bundle.scenes).length === 0) throw new Error("no scenes in bundle");
     return {};
   }
-  /** Resolve a scene reference (a gameId address OR an internal id) to its internal id. */
+  /** Resolve a scene reference to its internal id by the one address rule (see resolveScene); an
+   *  unknown one passes through, for the caller to find nothing. */
   resolveSceneRef(ref) {
     if (ref == null) return void 0;
-    if (this.host.bundle.scenes[ref]) return ref;
-    return this.sceneGameIdToId.get(ref) ?? ref;
+    return resolveScene(this.host, ref) ?? ref;
   }
-  /** Resolve a block reference (a scene-scoped gameId OR an internal id) to its internal id. */
+  /** Resolve a block reference to its internal id by the one address rule (see resolveBlock): within its
+   *  scene, so a block of another scene resolves to nothing. With no scene, only an internal id resolves,
+   *  since a block's gameId is only unique within its scene. */
   resolveBlockRef(sceneId, ref) {
     if (ref == null) return void 0;
-    if (this.host.blockById.has(ref)) return ref;
-    if (sceneId != null) {
-      const id = this.blockGameIdToId.get(sceneId)?.get(ref);
-      if (id) return id;
-    }
-    return ref;
+    if (sceneId == null) return ref;
+    return resolveBlock(this.host, sceneId, ref);
   }
   /** The host-facing address (gameId) of a scene / block by internal id, or undefined if unknown.
    *  The inverse of the resolve helpers - for a host that wants to display / log the address. */
@@ -688,7 +697,7 @@ var Engine = class _Engine {
     for (const s of this.host.stageBags.keys()) reg.remove(keys.stage(s), { keep });
     this.host.stageBags.clear();
     for (const t of ["patter", ...this.host.hostScopes]) if (reg.has(t)) reg.remove(t, { keep });
-    if (this.creationOptions.world && reg.has("world")) reg.remove("world");
+    for (const t of Object.keys(boundScopes(this.creationOptions))) if (reg.has(t)) reg.remove(t);
   }
   /** Read a shared (`@patter` / foreign) property by ref. `@scene` refs are rejected (flow-level). */
   getProperty(ref) {
@@ -725,12 +734,21 @@ var Engine = class _Engine {
    *  retained. Returns its own unsubscribe. */
   onTrace(handler) {
     this.engineTraceHandlers.add(handler);
-    return () => this.engineTraceHandlers.delete(handler);
+    this.host.tracing = true;
+    return () => {
+      this.engineTraceHandlers.delete(handler);
+      this.host.tracing = this.host.logEnabled || this.engineTraceHandlers.size > 0;
+    };
   }
   emitEngine(flow, event, scene) {
     for (const h of this.engineTraceHandlers) h(flow, event);
     if (!this.host.logEnabled) return;
-    this.engineLog.push({ ...event, flow, seq: this.engineLog.length, ...scene ? { scene } : {} });
+    this.engineLog.push({ ...event, flow, seq: this.engineSeq++, ...scene ? { scene } : {} });
+  }
+  /** How many times each node has been entered across every flow, by node id: the shared count. With a
+   *  flow's own {@link Flow.getVisitCounts}, every visit count the run keeps, read without a save. */
+  getVisitCounts() {
+    return Object.fromEntries(this.host.sharedVisits);
   }
   listProperties() {
     return this.host.patterSharedDecls.map((d) => ({
@@ -796,6 +814,8 @@ var Engine = class _Engine {
     this.refuseInCheckpoint("loadGame");
     const version = save.version;
     if (version !== 2 && version !== SAVE_VERSION) throw new Error(`unsupported save version: ${String(version)}`);
+    const flows = save.flows;
+    if (typeof flows !== "object" || flows === null || Array.isArray(flows)) throw new Error("malformed save: no flows");
     this.assertExternalScopes();
     const reg = this.host.registry;
     for (const [id, flow] of this.flowsById) {
@@ -934,19 +954,21 @@ var Flow = class {
    *  lowercase, as the compiler emits references (the selfBackedResolver lesson). */
   stagesFor(scope, name) {
     const key = name.toLowerCase();
-    const fromDecls = (decls) => decls?.find((d) => d.name.toLowerCase() === key && d.type === "quality")?.stages;
     if (scope === "patter") {
-      return fromDecls(this.host.patterSharedDecls) ?? fromDecls(this.host.patterLocalDecls);
+      return ladders(this.host, "patter", () => [...this.host.patterSharedDecls, ...this.host.patterLocalDecls]).get(key);
     }
     if (scope === "scene") {
-      const scene = this.currentSceneId != null ? this.host.bundle.scenes[this.currentSceneId] : void 0;
-      return fromDecls(scene?.sceneProps);
+      const sceneId = this.currentSceneId;
+      if (sceneId == null) return void 0;
+      return ladders(this.host, `scene/${sceneId}`, () => this.host.bundle.scenes[sceneId]?.sceneProps).get(key);
     }
-    return this.registryQualities?.(scope, name) ?? fromDecls(this.host.bundle.scopeRegistry?.scopes.find((s) => s.token === scope)?.declarations);
+    return this.registryQualities?.(scope, name) ?? ladders(this.host, `host/${scope}`, () => this.host.bundle.scopeRegistry?.scopes.find((s) => s.token === scope)?.declarations).get(key);
   }
   // -- Host API -------------------------------------------------------------
-  /** Begin this flow at a scene (and optionally a specific block within it). */
-  start(sceneId, blockId) {
+  /** Begin this flow at a scene (and optionally a specific block within it). The engine's own entry point:
+   *  openFlow and a goto on an unstarted flow begin a flow here. A game calls {@link reset}.
+   *  @internal */
+  begin(sceneId, blockId) {
     if (this.host.journal && !this.host.journal.opened.has(this)) throw new Error("a flow can't be started or reset while a checkpoint is open");
     this.releaseBags(false);
     this.host.registry.discardParked(keys.flow(this.id));
@@ -958,7 +980,7 @@ var Flow = class {
     this.flowEnded = false;
     this.activeSnippet = null;
     this.beatIndex = 0;
-    this.pendingChoice = null;
+    this.clearPending();
     this.started = true;
     if (blockId) {
       const loc = this.host.blockIndex.get(blockId);
@@ -983,10 +1005,15 @@ var Flow = class {
    * Forget everything in this flow and begin again - its per-flow state (not-shared
    * `@patter` globals + `@scene` props), cursor, callstack, selector cursors, and
    * visit counts. Shared state (shared `@patter` / `@scene`, world visit counts) is
-   * untouched. A clearer-named alias of `start()`.
+   * untouched. The one public way to begin a flow again (openFlow begins a new one).
    */
   reset(sceneId, blockId) {
-    this.start(sceneId, blockId);
+    this.begin(sceneId, blockId);
+  }
+  /** @deprecated Use {@link reset}, the one public name for beginning a flow again on every runtime. `start`
+   *  was the same call under a second name, and goes in a later release. */
+  start(sceneId, blockId) {
+    this.reset(sceneId, blockId);
   }
   /**
    * Send this flow's cursor to an ADDRESS, exactly as an authored `go` jump would: the target scene's
@@ -1010,29 +1037,25 @@ var Flow = class {
     this.touch();
     if (scene === "END") {
       this.started = true;
-      this.pendingChoice = null;
-      this.pendingPrompt = null;
-      this.pendingPromptOwnerId = null;
+      this.clearPending();
       this.activeSnippet = null;
       this.beatIndex = 0;
       this.flowEnded = true;
       this.stack = [];
       return true;
     }
-    const sceneId = this.host.sceneGameIdToId.get(scene) ?? (this.host.bundle.scenes[scene] ? scene : void 0);
+    const sceneId = resolveScene(this.host, scene);
     if (sceneId === void 0) return false;
     let blockId;
     if (block !== void 0) {
-      blockId = this.host.blockGameIdToId.get(sceneId)?.get(block) ?? (this.host.blockIndex.get(block)?.sceneId === sceneId ? block : void 0);
+      blockId = resolveBlock(this.host, sceneId, block);
       if (blockId === void 0) return false;
     }
     if (!this.started) {
-      this.start(sceneId, blockId);
+      this.begin(sceneId, blockId);
       return true;
     }
-    this.pendingChoice = null;
-    this.pendingPrompt = null;
-    this.pendingPromptOwnerId = null;
+    this.clearPending();
     this.activeSnippet = null;
     this.beatIndex = 0;
     this.flowEnded = false;
@@ -1057,6 +1080,15 @@ var Flow = class {
     this.stack = [];
     this.activeSnippet = null;
     this.beatIndex = 0;
+    this.clearPending();
+  }
+  /**
+   * Drop everything waiting to be delivered: an open choice, and a chosen option's prompt still to be
+   * replayed. Every move that abandons the flow's place (start and reset, goto, close) does this, so none
+   * leaves a stale prompt behind. start() cleared only the choice, so a reset between choose() and the
+   * next advance() replayed the abandoned run's prompt as the new run's first beat.
+   */
+  clearPending() {
     this.pendingChoice = null;
     this.pendingPrompt = null;
     this.pendingPromptOwnerId = null;
@@ -1133,7 +1165,7 @@ var Flow = class {
       if (this.flowEnded || this.pendingChoice) return;
       if (this.activeSnippet) {
         if (this.beatIndex < (this.activeSnippet.beats?.length ?? 0)) return;
-        this.runEffects(this.activeSnippet.onExit);
+        this.runEffects(this.activeSnippet.onExit, this.activeSnippet.id);
         const jump = this.activeSnippet.jump;
         this.activeSnippet = null;
         this.beatIndex = 0;
@@ -1153,7 +1185,7 @@ var Flow = class {
       }
       const from = frame.index;
       while (frame.index < children.length && !this.eligible(children[frame.index])) frame.index++;
-      if (this.host.logEnabled && frame.index !== from) {
+      if (this.host.tracing && frame.index !== from) {
         this.emit({
           type: "select",
           group: frame.containerId,
@@ -1189,14 +1221,18 @@ var Flow = class {
   clearLog() {
     this.flowLog.length = 0;
   }
-  /** Record one decision, on this flow's log and the engine's. Cheap to call with logging
-   *  off: the entry is never built. */
+  /** Record one decision, on this flow's log and the engine's, and hand it to any `onTrace`. Each call
+   *  site checks `host.tracing` first, so with nothing logging or tracing the entry is never built. */
   emit(event) {
     const scene = this.currentSceneId ?? void 0;
     this.host.emitEngine(this.id, event, scene);
     if (!this.host.logEnabled) return;
     this.flowLog.push({ ...event, seq: this.flowSeq++, ...scene ? { scene } : {} });
   }
+  /** How many times this flow has entered each node, by node id. */
+  getVisitCounts() {
+    return Object.fromEntries(this.visitCounts);
+  }
   /** The options of a pending choice (empty when not at a choice point). */
   getChoices() {
     return this.pendingChoice?.options ?? [];
@@ -1210,7 +1246,7 @@ var Flow = class {
     if (!option.eligible) throw new Error(`choice option is not eligible: ${id}`);
     this.touch();
     const node = choice.byId.get(id);
-    this.emit({ type: "chose", group: choice.groupId, option: id });
+    if (this.host.tracing) this.emit({ type: "chose", group: choice.groupId, option: id });
     this.pendingChoice = null;
     const authored = this.host.replayPromptOnChoose ? this.authoredPromptOf(node) : void 0;
     this.pendingPrompt = authored && option.prompt ? { beat: authored, shown: { ...option.prompt } } : null;
@@ -1349,7 +1385,7 @@ var Flow = class {
     this.currentSceneId = sceneId;
     this.enter(sceneId);
     this.seedScene(scene);
-    this.runEffects(scene.onEntry);
+    this.runEffects(scene.onEntry, scene.id);
   }
   /**
    * Play one child of the active run. A snippet begins delivering. A group is
@@ -1385,7 +1421,7 @@ var Flow = class {
     return void 0;
   }
   beginSnippet(snippet) {
-    this.runEffects(snippet.onEnter);
+    this.runEffects(snippet.onEnter, snippet.id);
     this.activeSnippet = snippet;
     this.beatIndex = 0;
   }
@@ -1405,8 +1441,8 @@ var Flow = class {
       options.push({ id: child.id, prompt: this.promptFor(child), eligible, gameData: child.gameData });
       byId.set(child.id, child);
     }
-    if (options.length > 0) {
-      this.emit({ type: "choice", group: group.id, options: options.map((o) => ({ id: o.id, eligible: o.eligible })) });
+    if (options.some((o) => o.eligible)) {
+      if (this.host.tracing) this.emit({ type: "choice", group: group.id, options: options.map((o) => ({ id: o.id, eligible: o.eligible })) });
       this.pendingChoice = { groupId: group.id, options, byId };
       return;
     }
@@ -1415,7 +1451,7 @@ var Flow = class {
       this.enterChild(fallback);
       return;
     }
-    this.emit({ type: "dry", group: group.id });
+    if (this.host.tracing) this.emit({ type: "dry", group: group.id });
     this.host.onDryChoice?.(group.id);
   }
   // -- Jumps (jump / call-return) ----------------------------------------
@@ -1430,7 +1466,7 @@ var Flow = class {
    * hard-ends the flow regardless of the callstack.
    */
   enterTarget(to, mode) {
-    this.emit({ type: "jump", to, mode });
+    if (this.host.tracing) this.emit({ type: "jump", to, mode });
     if (to === "END") {
       this.flowEnded = true;
       this.stack = [];
@@ -1463,11 +1499,11 @@ var Flow = class {
   // -- Selectors ------------------------------------------------------------
   selectChild(group) {
     const verdicts = group.children.map((c) => ({ id: c.id, eligible: this.eligible(c) }));
-    const eligible = group.children.filter((c) => this.eligible(c));
+    const eligible = group.children.filter((_, i) => verdicts[i].eligible);
     const order = group.options?.order ?? "sequential";
     const exhaust = group.options?.exhaust ?? "once";
     const trace = (picked) => {
-      this.emit({
+      if (this.host.tracing) this.emit({
         type: "select",
         group: group.id,
         selector: group.selector ?? "default",
@@ -1510,8 +1546,9 @@ var Flow = class {
     const len = eligible.length;
     const stick = exhaust === "stick";
     const fill = () => (stick ? eligible.slice(0, len - 1) : eligible).map((c) => c.id);
+    const eligibleIds = new Set(eligible.map((c) => c.id));
     if (st.bag === void 0) st.bag = fill();
-    if (st.bag.length === 0) {
+    if (!st.bag.some((id2) => eligibleIds.has(id2))) {
       if (exhaust === "once") return null;
       if (stick) {
         const last = eligible[len - 1];
@@ -1519,13 +1556,14 @@ var Flow = class {
         return last;
       }
       st.bag = fill();
+      if (st.bag.length === 0) return null;
     }
-    const pool = st.bag;
+    const pool = st.bag.filter((id2) => eligibleIds.has(id2));
     const p = st.last !== void 0 && pool.length > 1 ? pool.indexOf(st.last) : -1;
     let i = Math.floor(this.rng() * (p >= 0 ? pool.length - 1 : pool.length));
     if (p >= 0 && i >= p) i++;
     const id = pool[i];
-    pool.splice(i, 1);
+    st.bag.splice(st.bag.indexOf(id), 1);
     st.last = id;
     return eligible.find((c) => c.id === id);
   }
@@ -1574,7 +1612,7 @@ var Flow = class {
   /** A child's Best-match score against the current state: 0 when it has no condition (the filler
    *  tier), else the specificity of its (already-passing) condition. */
   specScore(node) {
-    return node.condition ? this.matchedSpec(this.conditionAst(node.condition), true) : 0;
+    return node.condition ? this.matchedSpec(this.conditionAst(node.condition), true, node) : 0;
   }
   /**
    * The **matched-specificity** metric (parity contract): how many atomic constraints are actively
@@ -1584,8 +1622,15 @@ var Flow = class {
    * to hold?" (true at the root). Only `and`/`or`/`not`/`check_flags` are structural; every other
    * node (comparisons, scoped vars, literals, other calls) is an atom, evaluated whole.
    */
-  matchedSpec(node, want) {
-    const evalTruthy = (n) => truthy(evaluate(n, this.context(), patterDialect));
+  matchedSpec(node, want, owner) {
+    const evalTruthy = (n) => {
+      try {
+        return truthy(evaluate(n, this.context(), patterDialect));
+      } catch (err) {
+        this.reportError("best-match", owner.id, owner.condition, err);
+        return false;
+      }
+    };
     return scoreSpecificity(node, evalTruthy, { want });
   }
   /** A selector's cursor state - shared across flows (`group.shared`) or this flow's own. */
@@ -1617,17 +1662,36 @@ var Flow = class {
     return st;
   }
   // -- Effects + expressions ------------------------------------------------
-  runEffects(effects) {
+  /** Run an effect list. `owner` is the snippet or scene it belongs to, for an error report. */
+  runEffects(effects, owner) {
     for (const e of effects ?? []) {
-      const value = this.evalExpr(e.value);
-      const prev = this.host.logEnabled ? this.getProperty(e.target) : void 0;
-      this.writeProperty(e.target, value, false);
-      this.emit({ type: "write", target: e.target, value, ...prev !== void 0 ? { prev } : {} });
+      let value;
+      try {
+        value = this.evalExpr(e.value);
+        const prev = this.host.tracing ? this.getProperty(e.target) : void 0;
+        this.writeProperty(e.target, value, false);
+        if (this.host.tracing) this.emit({ type: "write", target: e.target, value, ...prev !== void 0 ? { prev } : {} });
+      } catch (err) {
+        this.reportError("effect", owner, e.value, err);
+      }
     }
   }
+  /** Whether a node's condition holds. A condition that fails to evaluate counts as false (see PlayError). */
   eligible(node) {
     if (!node.condition) return true;
-    return truthy(this.evalExpr(node.condition));
+    try {
+      return truthy(this.evalExpr(node.condition));
+    } catch (err) {
+      this.reportError("condition", node.id, node.condition, err);
+      return false;
+    }
+  }
+  /** Report a content error the engine is playing through: to the host's onError, and to the log. */
+  reportError(kind, node, expr, err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const source = expr?.src;
+    this.host.onError({ flow: this.id, kind, node, ...source ? { source } : {}, message });
+    if (this.host.tracing) this.emit({ type: "diagnostic", kind, node, ...source ? { source } : {}, message });
   }
   evalExpr(expr) {
     return evaluate(this.conditionAst(expr), this.context(), patterDialect);
@@ -1823,23 +1887,23 @@ var Flow = class {
     if (!this.sceneBags.has(s)) {
       const bag = new PropertyBag(props.filter((d) => !shared.has(d.name.toLowerCase())), { pathPrefix: "@scene." });
       const key = keys.flowScene(this.id, s);
-      this.host.registry.mountOwned(key, bag, { owner: OWNER });
+      const claimed = mountClaims(this.host.registry, key, bag, journal !== null);
       this.registered.add(key);
       this.sceneBags.set(s, bag);
       if (journal) journal.undo.push(() => {
         if (this.sceneBags.get(s) !== bag) return;
-        this.host.registry.remove(key);
+        this.host.registry.remove(key, claimed ? { keep: true } : void 0);
         this.registered.delete(key);
         this.sceneBags.delete(s);
       });
     }
     if (!this.host.stageBags.has(s)) {
       const bag = new PropertyBag(props.filter((d) => shared.has(d.name.toLowerCase())), { pathPrefix: "@scene." });
-      this.host.registry.mountOwned(keys.stage(s), bag, { owner: OWNER });
+      const claimed = mountClaims(this.host.registry, keys.stage(s), bag, journal !== null);
       this.host.stageBags.set(s, bag);
       if (journal) journal.undo.push(() => {
         if (this.host.stageBags.get(s) !== bag) return;
-        this.host.registry.remove(keys.stage(s));
+        this.host.registry.remove(keys.stage(s), claimed ? { keep: true } : void 0);
         this.host.stageBags.delete(s);
       });
     }
@@ -1906,9 +1970,29 @@ function deserialiseSelectors(rec) {
   }
   return map;
 }
+function mountClaims(registry, key, bag, ask) {
+  const before = ask ? JSON.stringify(bag.save()) : "";
+  registry.mountOwned(key, bag, { owner: OWNER });
+  return ask && JSON.stringify(bag.save()) !== before;
+}
 function toDecl(decl) {
   return { name: decl.name, type: decl.type, values: decl.values, stages: decl.stages, default: decl.default };
 }
+function boundScopes(options) {
+  return { ...options.world ? { world: options.world } : {}, ...options.hostScopes };
+}
+function ladders(host, cacheKey, decls) {
+  let found = host.qualityLadders.get(cacheKey);
+  if (!found) {
+    found = /* @__PURE__ */ new Map();
+    for (const d of decls() ?? []) {
+      const k = d.name.toLowerCase();
+      if (d.type === "quality" && d.stages && !found.has(k)) found.set(k, d.stages);
+    }
+    host.qualityLadders.set(cacheKey, found);
+  }
+  return found;
+}
 function toForeignDecl(decl) {
   return { name: decl.name, type: decl.type, values: decl.values, stages: decl.stages, default: decl.default, writable: decl.writable };
 }
@@ -1917,6 +2001,12 @@ function selfBackedDecl(decl, scopeWritable) {
   const writable = decl.writable ?? scopeWritable;
   return writable === void 0 ? d : { ...d, writable };
 }
+function resolveScene(host, ref) {
+  return host.sceneGameIdToId.get(ref) ?? (host.bundle.scenes[ref] ? ref : void 0);
+}
+function resolveBlock(host, sceneId, ref) {
+  return host.blockGameIdToId.get(sceneId)?.get(ref) ?? (host.blockIndex.get(ref)?.sceneId === sceneId ? ref : void 0);
+}
 function splitHostRef(host, ref) {
   if (host.refSplitRevision !== host.registry.revision) {
     host.refSplitCache.clear();