@storylet-studio/runtime 0.4.1 → 0.5.0

package/dist/index.cjs

@@ -438,7 +438,48 @@ function effectiveGameId(entity) {
   const fromTitle = entity.title ? gameIdify(entity.title) : "";
   return fromTitle || entity.id;
 }
+function valueAddresses(bundle) {
+  const tags = [];
+  for (const box of bundle.boxes) {
+    const boxGameId = effectiveGameId(box);
+    for (const group of box.tagGroups) {
+      for (const tag of group.tags) {
+        const gameId = effectiveGameId(tag);
+        tags.push({ id: tag.id, gameId, qualified: `${boxGameId}/${gameId}` });
+      }
+    }
+  }
+  const forms = /* @__PURE__ */ new Map();
+  for (const tag of tags) {
+    const list = forms.get(tag.gameId) ?? [];
+    if (!list.includes(tag.qualified)) list.push(tag.qualified);
+    forms.set(tag.gameId, list);
+  }
+  const print = /* @__PURE__ */ new Map();
+  const accept = /* @__PURE__ */ new Map();
+  const repeated = /* @__PURE__ */ new Map();
+  for (const tag of tags) {
+    const candidates = forms.get(tag.gameId) ?? [tag.qualified];
+    const ambiguous = candidates.length > 1;
+    print.set(tag.id, ambiguous ? tag.qualified : tag.gameId);
+    if (!accept.has(tag.qualified)) accept.set(tag.qualified, tag.id);
+    if (!ambiguous && !accept.has(tag.gameId)) accept.set(tag.gameId, tag.id);
+    if (ambiguous) repeated.set(tag.gameId, candidates);
+  }
+  return { print, accept, repeated };
+}
+function ambiguousValueAddressMessage(segment, name, candidates) {
+  const forms = candidates.map((q) => `"value.${q}.${name}"`);
+  const list = forms.length <= 1 ? forms[0] ?? "" : `${forms.slice(0, -1).join(", ")} or ${forms[forms.length - 1]}`;
+  return `"value.${segment}.${name}" names a tag in ${candidates.length} boxes; write ${list}`;
+}
 var PLACE_GROUP = "place";
+var HOLE_REF = /^@(hand|world|story)\.([a-z][a-z0-9_-]*)$/;
+var isHoleRef = (value) => value.startsWith("@");
+var parseHoleRef = (value) => {
+  const m = HOLE_REF.exec(value);
+  return m === null ? void 0 : { scope: m[1], name: m[2] };
+};
 
 // ../../../expr/packages/scoperegistry/src/index.ts
 var PropertyBag = class _PropertyBag {
@@ -473,10 +514,14 @@ var PropertyBag = class _PropertyBag {
   }
   /** Write a property. Engine writes (the default) notify subscribers;
    *  pass `silent: true` for a host write, which reaches only the audit
-   *  hook. Throws on a read-only property. Returns the change. */
+   *  hook. Throws on a read-only property unless the caller says it is the
+   *  HOST (`host: true`), for whom `writable: false` was never a rule - it is
+   *  the story's promise, not the game's. `silent` and `host` are separate on
+   *  purpose: one is about who hears the write, the other about who may make
+   *  it. Returns the change. */
   set(name, value, opts) {
     const n = this.norm(name);
-    if (this.decls.get(n)?.writable === false) throw new Error(`'${name}' is read-only`);
+    if (!opts?.host && this.decls.get(n)?.writable === false) throw new Error(`'${name}' is read-only`);
     const change = {
       name: n,
       prev: this.values[n],
@@ -591,27 +636,62 @@ var SCOPE_DEFAULT_SHARED = { story: true, box: false, deck: false, hand: false,
 var isShared = (scope, d) => d.shared ?? SCOPE_DEFAULT_SHARED[scope];
 var sharedHalf = (scope, decls) => decls.filter((d) => isShared(scope, d));
 var flowHalf = (scope, decls) => decls.filter((d) => !isShared(scope, d));
+var OWNED_SCOPES = ["box", "deck", "hand", "value"];
+var emptyOwnerIndexes = () => ({
+  box: { gameId: /* @__PURE__ */ new Map(), id: /* @__PURE__ */ new Map(), repeated: /* @__PURE__ */ new Map() },
+  deck: { gameId: /* @__PURE__ */ new Map(), id: /* @__PURE__ */ new Map(), repeated: /* @__PURE__ */ new Map() },
+  hand: { gameId: /* @__PURE__ */ new Map(), id: /* @__PURE__ */ new Map(), repeated: /* @__PURE__ */ new Map() },
+  value: { gameId: /* @__PURE__ */ new Map(), id: /* @__PURE__ */ new Map(), repeated: /* @__PURE__ */ new Map() }
+});
+var indexOwner = (index, entity) => {
+  const gameId = effectiveGameId(entity);
+  index.gameId.set(entity.id, gameId);
+  if (!index.id.has(gameId)) index.id.set(gameId, entity.id);
+};
+var indexValueOwners = (index, bundle) => {
+  const addresses = valueAddresses(bundle);
+  for (const [id, segment] of addresses.print) index.gameId.set(id, segment);
+  for (const [segment, id] of addresses.accept) index.id.set(segment, id);
+  for (const [gameId, candidates] of addresses.repeated) index.repeated.set(gameId, candidates);
+};
 var handDeclsOf = (internals, hand) => {
   if (hand.template !== void 0) {
     return internals.templatesById.get(hand.template)?.properties ?? internals.bundle.boxes.flatMap((b) => b.handTemplates).find((t) => t.id === hand.template)?.properties ?? [];
   }
   return hand.properties ?? [];
 };
+var addressOf = (internals, kind, id) => `${kind}.${internals.owners[kind].gameId.get(id) ?? id}`;
+var resolveOwner = (internals, kind, segment) => {
+  const candidates = internals.owners[kind].repeated.get(segment);
+  if (candidates !== void 0) return { ambiguous: candidates };
+  const byGameId = internals.owners[kind].id.get(segment);
+  if (byGameId !== void 0) return { id: byGameId, legacy: false };
+  if (internals.owners[kind].gameId.has(segment)) return { id: segment, legacy: true };
+  return void 0;
+};
+var ownerOrThrow = (internals, kind, segment, name) => {
+  const owner = resolveOwner(internals, kind, segment);
+  if (owner === void 0) throw new Error(`no ${kind} store "${segment}"`);
+  if ("ambiguous" in owner) throw new Error(ambiguousValueAddressMessage(segment, name, owner.ambiguous));
+  return owner;
+};
+var legacyAddressMessage = (internals, kind, segment, name) => `"${kind}.${segment}.${name}" names the ${kind} by its internal id; write "${addressOf(internals, kind, segment)}.${name}". The internal-id form is refused after the next release.`;
 var buildPartition = (internals, half) => {
   const b = internals.bundle;
+  const at = (kind, id) => `${addressOf(internals, kind, id)}.`;
   return {
     story: bagFromDecls(half("story", b.story.properties), "story."),
-    box: new Map(b.boxes.map((box) => [box.id, bagFromDecls(half("box", box.properties), `box.${box.id}.`)])),
+    box: new Map(b.boxes.map((box) => [box.id, bagFromDecls(half("box", box.properties), at("box", box.id))])),
     deck: new Map(b.boxes.flatMap((box) => box.decks.map(
-      (deck) => [deck.id, bagFromDecls(half("deck", deck.properties), `deck.${deck.id}.`)]
+      (deck) => [deck.id, bagFromDecls(half("deck", deck.properties), at("deck", deck.id))]
     ))),
     // A template instance inherits the template's property declarations;
     // a standalone hand declares its own (schema 2.6).
     hand: new Map(b.boxes.flatMap((box) => box.hands.map(
-      (hand) => [hand.id, bagFromDecls(half("hand", handDeclsOf(internals, hand)), `hand.${hand.id}.`)]
+      (hand) => [hand.id, bagFromDecls(half("hand", handDeclsOf(internals, hand)), at("hand", hand.id))]
     ))),
     value: new Map(b.boxes.flatMap((box) => box.tagGroups.flatMap((group) => group.tags.map(
-      (tag) => [tag.id, bagFromDecls(half("value", tag.properties ?? []), `value.${tag.id}.`)]
+      (tag) => [tag.id, bagFromDecls(half("value", tag.properties ?? []), at("value", tag.id))]
     ))))
   };
 };
@@ -630,6 +710,105 @@ var loadPartition = (p, values) => {
     }
   }
 };
+var emptyDraft = () => ({
+  evicted: [],
+  droppedCooldowns: [],
+  droppedSpent: [],
+  droppedProperties: [],
+  defaultedProperties: [],
+  retypedProperties: []
+});
+var SORT_SEP = "";
+var byKey = (items, key) => [...items].map((item) => ({ item, k: key(item) })).sort((a, b) => a.k < b.k ? -1 : a.k > b.k ? 1 : 0).map((e) => e.item);
+var propKey = (p) => `${p.flow ?? ""}${SORT_SEP}${p.path}`;
+function valueFits(decl, value) {
+  switch (decl.type) {
+    case "boolean":
+      return typeof value === "boolean";
+    case "number":
+      return typeof value === "number";
+    case "string":
+      return typeof value === "string";
+    case "enum":
+      return typeof value === "string" && (decl.values === void 0 || decl.values.includes(value));
+    case "quality":
+      return typeof value === "string" && (decl.stages === void 0 || decl.stages.includes(value));
+    case "flags":
+      return Array.isArray(value) && (decl.values === void 0 || value.every((f) => decl.values.includes(f)));
+    default:
+      return true;
+  }
+}
+function walkScope(decls, saved, path, flow, draft) {
+  const at = (name) => ({ ...flow !== void 0 ? { flow } : {}, path: path(name) });
+  const byName = new Map((decls ?? []).map((d) => [d.name, d]));
+  const values = saved ?? {};
+  const clean = {};
+  for (const [name, value] of Object.entries(values)) {
+    const decl = byName.get(name);
+    if (decl === void 0) {
+      draft.droppedProperties.push(at(name));
+      continue;
+    }
+    if (!valueFits(decl, value)) {
+      draft.retypedProperties.push(at(name));
+      continue;
+    }
+    clean[name] = value;
+  }
+  for (const decl of decls ?? []) {
+    if (!(decl.name in values)) draft.defaultedProperties.push(at(decl.name));
+  }
+  return clean;
+}
+function walkPartition(internals, decls, values, flow, draft) {
+  const out = {
+    story: walkScope(decls.story, values?.story, (n) => `story.${n}`, flow, draft),
+    box: {},
+    deck: {},
+    hand: {},
+    value: {}
+  };
+  for (const kind of ["box", "deck", "hand", "value"]) {
+    const savedKind = values?.[kind] ?? {};
+    const ids = [.../* @__PURE__ */ new Set([...decls[kind].keys(), ...Object.keys(savedKind)])].sort();
+    for (const id of ids) {
+      const owner = addressOf(internals, kind, id);
+      out[kind][id] = walkScope(
+        decls[kind].get(id),
+        savedKind[id],
+        (n) => `${owner}.${n}`,
+        flow,
+        draft
+      );
+    }
+  }
+  return out;
+}
+function finishReport(bundle, saved, flows, draft) {
+  const drift = saved.version !== bundle.version || saved.hash !== bundle.hash;
+  const evicted = byKey(draft.evicted, (e) => [e.flow, e.hand, e.card, e.reason].join(SORT_SEP));
+  const droppedCooldowns = byKey(draft.droppedCooldowns, (c) => `${c.flow}${SORT_SEP}${c.card}`);
+  const droppedSpent = [...draft.droppedSpent].sort();
+  const droppedProperties = byKey(draft.droppedProperties, propKey);
+  const defaultedProperties = byKey(draft.defaultedProperties, propKey);
+  const retypedProperties = byKey(draft.retypedProperties, propKey);
+  return {
+    // `flows` is what the load restores, not something it had to change, so
+    // it never makes a report inexact.
+    exact: !drift && evicted.length === 0 && droppedCooldowns.length === 0 && droppedSpent.length === 0 && droppedProperties.length === 0 && defaultedProperties.length === 0 && retypedProperties.length === 0,
+    project: bundle.project,
+    version: { saved: saved.version, bundle: bundle.version },
+    hash: { saved: saved.hash, bundle: bundle.hash },
+    flows,
+    evicted,
+    droppedCooldowns,
+    droppedSpent,
+    droppedProperties,
+    defaultedProperties,
+    retypedProperties
+  };
+}
 var Engine = class {
   internals;
   seed;
@@ -653,6 +832,7 @@ var Engine = class {
       boxesById: /* @__PURE__ */ new Map(),
       handsById: /* @__PURE__ */ new Map(),
       handsByGameId: /* @__PURE__ */ new Map(),
+      owners: emptyOwnerIndexes(),
       templatesById: /* @__PURE__ */ new Map(),
       groupsById: /* @__PURE__ */ new Map(),
       requiredGroups: /* @__PURE__ */ new Set(),
@@ -661,6 +841,7 @@ var Engine = class {
       hasQualities: false,
       hasShared: false,
       flowDecls: { story: [], box: /* @__PURE__ */ new Map(), deck: /* @__PURE__ */ new Map(), hand: /* @__PURE__ */ new Map(), value: /* @__PURE__ */ new Map() },
+      sharedDecls: { story: [], box: /* @__PURE__ */ new Map(), deck: /* @__PURE__ */ new Map(), hand: /* @__PURE__ */ new Map(), value: /* @__PURE__ */ new Map() },
       shared: void 0,
       worldResolver: void 0,
       worldReadOnly: /* @__PURE__ */ new Set(),
@@ -676,14 +857,17 @@ var Engine = class {
       engineTracing: () => this.engineTraceHandlers.size > 0
     };
     this.internals = internals;
+    indexValueOwners(internals.owners.value, bundle);
     for (const box of bundle.boxes) {
       internals.boxesById.set(box.id, box);
       internals.boxesByGameId.set(effectiveGameId(box), box);
+      indexOwner(internals.owners.box, box);
       for (const group of box.tagGroups) {
         internals.groupsById.set(group.id, { group, box });
         if (group.required === true) internals.requiredGroups.add(group.id);
       }
       for (const deck of box.decks) {
+        indexOwner(internals.owners.deck, deck);
         if (deck.shared === true) internals.hasShared = true;
         for (const card of deck.cards) {
           const entry = { card, deck, box };
@@ -698,22 +882,25 @@ var Engine = class {
       for (const hand of box.hands) {
         internals.handsById.set(hand.id, { hand, box });
         internals.handsByGameId.set(effectiveGameId(hand), { hand, box });
+        indexOwner(internals.owners.hand, hand);
       }
     }
     this.initLadders();
-    internals.flowDecls = {
-      story: flowHalf("story", bundle.story.properties),
-      box: new Map(bundle.boxes.map((box) => [box.id, flowHalf("box", box.properties)])),
+    const declSet = (half) => ({
+      story: half("story", bundle.story.properties),
+      box: new Map(bundle.boxes.map((box) => [box.id, half("box", box.properties)])),
       deck: new Map(bundle.boxes.flatMap((box) => box.decks.map(
-        (deck) => [deck.id, flowHalf("deck", deck.properties)]
+        (deck) => [deck.id, half("deck", deck.properties)]
       ))),
       hand: new Map(bundle.boxes.flatMap((box) => box.hands.map(
-        (hand) => [hand.id, flowHalf("hand", handDeclsOf(internals, hand))]
+        (hand) => [hand.id, half("hand", handDeclsOf(internals, hand))]
       ))),
       value: new Map(bundle.boxes.flatMap((box) => box.tagGroups.flatMap((group) => group.tags.map(
-        (tag) => [tag.id, flowHalf("value", tag.properties ?? [])]
+        (tag) => [tag.id, half("value", tag.properties ?? [])]
       ))))
-    };
+    });
+    internals.flowDecls = declSet(flowHalf);
+    internals.sharedDecls = declSet(sharedHalf);
     this.initShared(this.hostWorld);
   }
   /** Build the shared stores and the @world seam. `hostWorld` sticks for the
@@ -724,14 +911,24 @@ var Engine = class {
     internals.worldReadOnly = new Set(internals.bundle.world.properties.filter((d) => d.writable === false).map((d) => d.name));
     if (hostWorld !== void 0) {
       internals.worldResolver = hostWorld;
+      const set = hostWorld.set;
+      internals.worldSet = set !== void 0 ? (n, v) => {
+        set(n, v);
+      } : void 0;
     } else {
       const bag = bagFromDecls(internals.bundle.world.properties, "world.");
       internals.worldResolver = {
+        // The engine writes through worldSet below, not through this; the `set`
+        // is the resolver's SHAPE, so @world still reads as writable to anything
+        // inspecting the seam, and it is the story's door: no host flag on it.
         get: (n) => bag.get(n),
         set: (n, v) => {
           bag.set(n, v);
         }
       };
+      internals.worldSet = (n, v, host2) => {
+        bag.set(n, v, host2 === true ? { host: true } : void 0);
+      };
     }
   }
   /** Quality ladders by scope for the eval channel (design/quality.md):
@@ -765,6 +962,7 @@ var Engine = class {
    *  state; shared state is untouched. There is no default flow: "main" is
    *  a caller convention, not an engine rule. */
   openFlow(id, opts = {}) {
+    const otherClaims = opts.restore !== void 0 ? this.sharedClaimsExcept(id) : void 0;
     const existing = this.flowsById.get(id);
     if (existing) {
       const dealt = existing.heldCardIds().length;
@@ -773,6 +971,13 @@ var Engine = class {
     }
     const flow = new Flow(this, this.internals, id, opts.seed ?? this.seed);
     this.flowsById.set(id, flow);
+    if (opts.restore !== void 0) {
+      const draft = emptyDraft();
+      const clean = this.planFlowRestore(id, structuredClone(opts.restore), otherClaims, draft);
+      flow.restore(clean);
+      const content = this.internals.bundle.content;
+      opts.onRestoreReport?.(finishReport(content, content, [id], draft));
+    }
     return flow;
   }
   getFlow(id) {
@@ -846,10 +1051,21 @@ var Engine = class {
     }
     return counts;
   }
+  /** The same ledger with one name left out: what the REST of the world
+   *  holds, which is the question a resume under that name has to ask. */
+  sharedClaimsExcept(id) {
+    const counts = /* @__PURE__ */ new Map();
+    for (const [flowId, flow] of this.flowsById) {
+      if (flowId === id) continue;
+      for (const cardId of flow.heldCardIds()) counts.set(cardId, (counts.get(cardId) ?? 0) + 1);
+    }
+    return counts;
+  }
   // --- engine-level state access ----------------------------------------------
   /**
    * Read shared state by path: "world.x", "story.gold" (when shared),
-   * "box.b_x.heat" (when shared). A ref that resolves PER-FLOW throws,
+   * "box.village.heat" (when shared) - the owner segment is its GAMEID
+   * (design/engine-server.md 4.4). A ref that resolves PER-FLOW throws,
    * naming the fix - silently answering with some flow's copy (or a junk
    * default) was the bug Patter's engine.getProperty guard exists to stop.
    */
@@ -862,13 +1078,13 @@ var Engine = class {
   setProperty(path, value) {
     const found = this.resolveShared(path);
     if (found.kind === "world") {
-      if (!this.internals.worldResolver.set) {
+      if (!this.internals.worldSet) {
         throw new Error(`@world is read-only here: the host bound no write`);
       }
-      this.internals.worldResolver.set(found.name, value);
+      this.internals.worldSet(found.name, value, true);
       return;
     }
-    found.bag.set(found.name, value, { silent: true, reason: "host setProperty" });
+    found.bag.set(found.name, value, { silent: true, reason: "host setProperty", host: true });
   }
   resolveShared(path) {
     const parts = path.split(".");
@@ -884,15 +1100,25 @@ var Engine = class {
     }
     if (parts.length === 3 && (parts[0] === "box" || parts[0] === "deck" || parts[0] === "hand" || parts[0] === "value")) {
       const kind = parts[0];
-      const [, id, name] = parts;
+      const [, segment, name] = parts;
+      const owner = ownerOrThrow(this.internals, kind, segment, name);
+      if (owner.legacy) this.diagnose(legacyAddressMessage(this.internals, kind, segment, name));
+      const id = owner.id;
       const bag = this.internals.shared[kind].get(id);
       if (bag !== void 0 && bag.get(name) !== void 0) return { kind: "bag", bag, name };
       if (this.internals.flowDecls[kind].get(id)?.some((d) => d.name === name)) perFlow();
-      if (bag === void 0 && !this.internals.flowDecls[kind].has(id)) throw new Error(`no ${kind} store "${id}"`);
+      if (bag === void 0 && !this.internals.flowDecls[kind].has(id)) throw new Error(`no ${kind} store "${segment}"`);
       throw new Error(`no property at "${path}"`);
     }
     throw new Error(`bad property path "${path}"`);
   }
+  /** The engine's own surface has no flow, so an engine-level diagnostic
+   *  carries the empty flow id - the same way a LoadReport's shared half
+   *  carries no flow. It reaches the run log and the engine tap; there is
+   *  nowhere else for it to go, and it fires only on a legacy address. */
+  diagnose(message) {
+    this.internals.emitEngine("", { type: "diagnostic", where: "property address", message });
+  }
   /** The shared surface as examiner rows: @world (read through the
    *  resolver) then the shared partitions. Per-flow rows live on each Flow. */
   listProperties() {
@@ -908,20 +1134,24 @@ var Engine = class {
         ...d.values !== void 0 ? { values: d.values } : {},
         ...d.stages !== void 0 ? { stages: d.stages } : {},
         // @world is FOREIGN - a host resolver backs it - so writability is whether that
-        // resolver can be written at all, which is the shared registry's own rule for a
-        // foreign scope. The `as PropertyView` cast this replaced was hiding the field's
-        // absence: the row type has always required it, and these rows shipped without one.
-        writable: this.internals.worldResolver.set !== void 0
+        // resolver can be written at all AND what the declaration says, which is the
+        // shared registry's own rule for a foreign scope (its foreignWritable). The
+        // `as PropertyView` cast this replaced was hiding the field's absence: the row
+        // type has always required it, and these rows shipped without one.
+        //
+        // A row is where `writable: false` is meant to SHOW (Reboot.md 10): it tells a
+        // state panel this is the game's value, not the story's. It does not stop the
+        // panel editing it - the host's setProperty passes `{ host: true }`.
+        writable: this.internals.worldSet !== void 0 && !this.internals.worldReadOnly.has(d.name)
       });
     }
     const add = (_prefix, bag) => {
       for (const row of bag.rows()) out.push(row);
     };
     add("story", this.internals.shared.story);
-    for (const [id, bag] of this.internals.shared.box) add(`box.${id}`, bag);
-    for (const [id, bag] of this.internals.shared.deck) add(`deck.${id}`, bag);
-    for (const [id, bag] of this.internals.shared.hand) add(`hand.${id}`, bag);
-    for (const [id, bag] of this.internals.shared.value) add(`value.${id}`, bag);
+    for (const kind of OWNED_SCOPES) {
+      for (const [id, bag] of this.internals.shared[kind]) add(addressOf(this.internals, kind, id), bag);
+    }
     return out;
   }
   /** The SHARED kernel bags with their store path prefixes (the state
@@ -930,7 +1160,7 @@ var Engine = class {
   listBags() {
     const mounts = [{ prefix: "story", bag: this.internals.shared.story }];
     for (const kind of ["box", "deck", "hand", "value"]) {
-      for (const [id, bag] of this.internals.shared[kind]) mounts.push({ prefix: `${kind}.${id}`, bag });
+      for (const [id, bag] of this.internals.shared[kind]) mounts.push({ prefix: addressOf(this.internals, kind, id), bag });
     }
     return mounts;
   }
@@ -951,20 +1181,137 @@ var Engine = class {
       flows: Object.fromEntries([...this.flowsById].map(([id, flow]) => [id, flow.snapshot()]))
     });
   }
+  /** ONE flow's blob, to park a visit that is walking away: the same shape
+   *  the envelope carries per flow, and the same shape `openFlow`'s `restore`
+   *  option takes back (design/engine-server.md 4.1). Saving the whole
+   *  envelope to park one of four hundred players is wrong in cost and in
+   *  meaning. Throws for a name that is not open - a closed flow has nothing
+   *  left to save. */
+  saveFlow(id) {
+    const flow = this.flowsById.get(id);
+    if (!flow) throw new Error(`unknown flow "${id}"`);
+    return structuredClone(flow.snapshot());
+  }
+  /** What `loadGame(envelope)` would do that is not a plain restore, without
+   *  doing any of it (design/engine-server.md 4.9). Pure: nothing on this
+   *  engine moves. A project mismatch is refused here exactly as `loadGame`
+   *  refuses it - it is the one thing neither call will tolerate. */
+  previewLoad(envelope) {
+    this.assertSameProject(envelope);
+    return this.planLoad(envelope).report;
+  }
+  /** What `openFlow(id, { restore: saved })` would do to a flow of that name,
+   *  without doing it: the same report shape, since a visit parked under one
+   *  build and resumed under the next raises the same questions. Pure. */
+  previewFlowRestore(id, saved) {
+    const draft = emptyDraft();
+    this.planFlowRestore(id, saved, this.sharedClaimsExcept(id), draft);
+    const content = this.internals.bundle.content;
+    return finishReport(content, content, [id], draft);
+  }
   /** Restore: shared state once, then every flow REBUILT from its blob.
    *  Handles held from before the load are closed and inert (Patter's
-   *  rule); take fresh ones from getFlow()/flows(). */
+   *  rule); take fresh ones from getFlow()/flows().
+   *
+   *  Returns the report `previewLoad` would have given for this envelope: the
+   *  drift tolerance that makes a load forgiving is what hides its cost, so
+   *  the cost comes back with the load whether or not anybody looked first. */
   loadGame(envelope) {
+    this.assertSameProject(envelope);
+    const plan = this.planLoad(structuredClone(envelope));
+    this.reset();
+    loadPartition(this.internals.shared, plan.shared);
+    for (const id of plan.spent) this.spent.add(id);
+    for (const [id, clean] of plan.flows) this.openFlow(id).restore(clean);
+    return plan.report;
+  }
+  assertSameProject(envelope) {
     if (envelope.content.project !== this.internals.bundle.content.project) {
       throw new Error(`save is for project "${envelope.content.project}", bundle is "${this.internals.bundle.content.project}"`);
     }
-    const env = structuredClone(envelope);
-    this.reset();
-    loadPartition(this.internals.shared, env.shared.props);
-    for (const id of env.shared.spent ?? []) this.spent.add(id);
-    for (const [id, saved] of Object.entries(env.flows ?? {})) {
-      this.openFlow(id).restore(saved);
+  }
+  /** The whole-envelope walk: the report, and the cleaned state the apply
+   *  half writes. Nothing here touches the engine, which is what lets
+   *  previewLoad and loadGame share it. */
+  planLoad(envelope) {
+    const draft = emptyDraft();
+    const shared = walkPartition(
+      this.internals,
+      this.internals.sharedDecls,
+      envelope.shared?.props,
+      void 0,
+      draft
+    );
+    const spent = [];
+    for (const cardId of envelope.shared?.spent ?? []) {
+      if (this.internals.cardsById.has(cardId)) spent.push(cardId);
+      else draft.droppedSpent.push(cardId);
+    }
+    const flows = [];
+    for (const [id, saved] of Object.entries(envelope.flows ?? {})) {
+      flows.push([id, this.planFlowRestore(id, saved, void 0, draft)]);
+    }
+    return {
+      report: finishReport(this.internals.bundle.content, envelope.content, flows.map(([id]) => id), draft),
+      shared,
+      spent,
+      flows
+    };
+  }
+  /** One flow's walk. `otherClaims` is the rest of the world's shared ledger
+   *  and is present only for a SINGLE-flow restore into a live engine: a
+   *  whole-envelope load rebuilds every flow from one consistent moment, so
+   *  there is nobody else to compete with. */
+  planFlowRestore(id, saved, otherClaims, draft) {
+    const internals = this.internals;
+    const props = walkPartition(internals, internals.flowDecls, saved.props, id, draft);
+    const cooldowns = {};
+    for (const [cardId, turn] of Object.entries(saved.cooldowns ?? {})) {
+      if (internals.cardsById.has(cardId)) cooldowns[cardId] = turn;
+      else draft.droppedCooldowns.push({ flow: id, card: cardId });
+    }
+    const cardName = (cardId) => {
+      const entry = internals.cardsById.get(cardId);
+      return entry ? effectiveGameId(entry.card) : cardId;
+    };
+    const board = {};
+    const restored = /* @__PURE__ */ new Map();
+    for (const [handId, ids] of Object.entries(saved.board ?? {})) {
+      const known = internals.handsById.get(handId);
+      if (known === void 0) {
+        for (const cardId of ids) {
+          draft.evicted.push({ flow: id, hand: handId, card: cardName(cardId), reason: "hand-vanished" });
+        }
+        continue;
+      }
+      const hand = effectiveGameId(known.hand);
+      const kept = [];
+      for (const cardId of ids) {
+        const entry = internals.cardsById.get(cardId);
+        if (entry === void 0) {
+          draft.evicted.push({ flow: id, hand, card: cardId, reason: "vanished" });
+          continue;
+        }
+        if (otherClaims !== void 0 && cardIsShared(entry.card, entry.deck.shared ?? false)) {
+          const held = (otherClaims.get(cardId) ?? 0) + (restored.get(cardId) ?? 0);
+          if (held >= sharedCap(entry.card)) {
+            draft.evicted.push({ flow: id, hand, card: effectiveGameId(entry.card), reason: "claimed-elsewhere" });
+            continue;
+          }
+          restored.set(cardId, (restored.get(cardId) ?? 0) + 1);
+        }
+        kept.push(cardId);
+      }
+      board[handId] = kept;
     }
+    return {
+      props,
+      turns: saved.turns ?? {},
+      prng: saved.prng,
+      cooldowns,
+      board,
+      playLog: saved.playLog ?? []
+    };
   }
 };
 var Flow = class {
@@ -1240,6 +1587,10 @@ var Flow = class {
         boundTags.set(groupId, tagId);
       }
       for (const [groupId, tagId] of Object.entries(hand.chosen ?? {})) {
+        if (isHoleRef(tagId)) {
+          this.fillHoleFromProperty(hand, groupId, tagId, boundTags, askNames);
+          continue;
+        }
         boundTags.set(groupId, tagId);
         const found = this.internals.groupsById.get(groupId);
         const tag = found?.group.tags.find((t) => t.id === tagId);
@@ -1248,6 +1599,10 @@ var Flow = class {
       condition = template.condition;
     } else {
       for (const [groupId, tagId] of Object.entries(hand.rule?.bindings ?? {})) {
+        if (isHoleRef(tagId)) {
+          this.fillHoleFromProperty(hand, groupId, tagId, boundTags, askNames);
+          continue;
+        }
         boundTags.set(groupId, tagId);
         const found = this.internals.groupsById.get(groupId);
         const tag = found?.group.tags.find((t) => t.id === tagId);
@@ -1283,6 +1638,58 @@ var Flow = class {
     this.bindStateGroups(box, boundTags, askNames);
     return { box, boundTags, askNames };
   }
+  /**
+   * Fill one hole from the property its value names: the hand that moves
+   * (design/engine-server.md 4.6).
+   *
+   * The semantics are `bindStateGroups`' below, word for word, applied per
+   * HOLE instead of per group: resolved at ask time, and a value naming no tag
+   * leaves the hole UNBOUND (a wildcard) with a diagnostic rather than dealing
+   * a silently empty hand. What is added is the `@hand` scope - the asking
+   * hand's OWN declared state, read here from the flow's merged view (the
+   * shared half under the flow's own, so a `shared: true` declaration moves
+   * the hole for every flow and a per-flow one moves it for this flow alone).
+   *
+   * Read BEFORE tag composition, which is the whole reason it is safe: the
+   * @hand bag a card sees is built from the bound tags, so resolving a hole
+   * from it would be circular. A hand's own declarations are not, so they are.
+   */
+  fillHoleFromProperty(hand, groupId, ref, boundTags, askNames) {
+    const found = this.internals.groupsById.get(groupId);
+    const groupName = found ? effectiveGameId(found.group) : groupId;
+    const where = `hand ${effectiveGameId(hand)}, tag group ${groupName}`;
+    const parsed = parseHoleRef(ref);
+    if (!parsed) {
+      this.emit({ type: "diagnostic", where, message: `"${ref}" is not a @hand, @world or @story property reference` });
+      return;
+    }
+    if (!found) {
+      this.emit({ type: "diagnostic", where, message: `"${ref}" fills a tag group that is not in this box` });
+      return;
+    }
+    let value;
+    if (parsed.scope === "hand") {
+      value = this.valuesOf("hand", hand.id)[parsed.name];
+    } else {
+      try {
+        value = this.getProperty(`${parsed.scope}.${parsed.name}`);
+      } catch {
+        value = void 0;
+      }
+    }
+    if (value === void 0) {
+      this.emit({ type: "diagnostic", where, message: `"${ref}" names a property that is not declared` });
+      return;
+    }
+    const wanted = typeof value === "string" ? value : String(value);
+    const tag = found.group.tags.find((t) => effectiveGameId(t) === wanted);
+    if (!tag) {
+      this.emit({ type: "diagnostic", where, message: `${ref} is "${wanted}", which is not one of the tags of "${groupName}"` });
+      return;
+    }
+    boundTags.set(groupId, tag.id);
+    askNames[groupName] = effectiveGameId(tag);
+  }
   /**
    * Bind every `boundBy` group in the box from the property it names.
    *
@@ -1413,8 +1820,8 @@ var Flow = class {
   runAsk(ask, claimed, trace) {
     const { box } = ask;
     const handEnv = this.buildHandEnv(ask);
-    const verdict = (id, v) => {
-      trace?.push({ id, verdict: v });
+    const verdict = (card, v) => {
+      trace?.push({ id: effectiveGameId(card), verdict: v });
     };
     if (!this.passes(ask.condition, this.evalCtx(box, void 0, handEnv), `hand ${ask.hand ? effectiveGameId(ask.hand) : ""} condition`)) {
       return { ordered: [], handEnv };
@@ -1431,19 +1838,19 @@ var Flow = class {
       for (const card of deck.cards) {
         const shared = cardIsShared(card, deckShared);
         if (!gateOk.get(deck.id)) {
-          verdict(card.id, "deck-gate");
+          verdict(card, "deck-gate");
           continue;
         }
         if (shared && this.engine.isTaken(card.id)) {
-          verdict(card.id, "taken");
+          verdict(card, "taken");
           continue;
         }
         if ((this.cooldowns[card.id] ?? 0) > turn) {
-          verdict(card.id, "cooldown");
+          verdict(card, "cooldown");
           continue;
         }
         if (!this.tagsMatch(card, handEnv.boundTags)) {
-          verdict(card.id, "tags");
+          verdict(card, "tags");
           continue;
         }
         if (card.condition && !this.passes(
@@ -1451,12 +1858,12 @@ var Flow = class {
           deckCtx,
           this.tracing ? `card ${card.gameId} condition` : void 0
         )) {
-          verdict(card.id, "condition");
+          verdict(card, "condition");
           continue;
         }
         const refused = claimed(card, shared);
         if (refused) {
-          verdict(card.id, refused);
+          verdict(card, refused);
           continue;
         }
         let priority;
@@ -1466,7 +1873,7 @@ var Flow = class {
           try {
             const v = this.eval(card.priority, deckCtx);
             if (typeof v !== "number") {
-              verdict(card.id, "priority");
+              verdict(card, "priority");
               continue;
             }
             priority = v;
@@ -1474,7 +1881,7 @@ var Flow = class {
             if (this.tracing) {
               this.emit({ type: "diagnostic", where: `card ${card.gameId} priority`, message: e instanceof Error ? e.message : String(e) });
             }
-            verdict(card.id, "priority");
+            verdict(card, "priority");
             continue;
           }
         }
@@ -1505,11 +1912,13 @@ var Flow = class {
       i = j;
     }
     for (const s of scored) {
-      trace?.push({ id: s.entry.card.id, verdict: "dealt", priority: s.priority, specificity: s.spec });
+      trace?.push({ id: effectiveGameId(s.entry.card), verdict: "dealt", priority: s.priority, specificity: s.spec });
     }
     return { ordered: scored.map((s) => s.entry), handEnv };
   }
-  /** Flip eligible-but-not-taken trace entries to "capped". */
+  /** Flip eligible-but-not-taken trace entries to "capped". `taken` is keyed
+   *  by GAMEID, as the trace rows are (4.4): the two must move together or
+   *  every dealt card silently reads as capped. */
   capTrace(trace, taken) {
     for (const entry of trace) {
       if (entry.verdict === "dealt" && !taken.has(entry.id)) entry.verdict = "capped";
@@ -1550,7 +1959,7 @@ var Flow = class {
     const { ordered } = this.runAsk(ask, (card, shared) => this.claimVerdict(card, shared, claimCounts, worldClaims), trace);
     const listed = n === void 0 ? ordered : ordered.slice(0, Math.max(n, 0));
     if (trace) {
-      this.capTrace(trace, new Set(listed.map((e) => e.card.id)));
+      this.capTrace(trace, new Set(listed.map((e) => effectiveGameId(e.card))));
       this.emit({ type: "peek", box: effectiveGameId(box), criteria, cards: trace }, this.turnCounts.get(box.id) ?? 0);
     }
     return { box: effectiveGameId(box), cards: listed.map((e) => this.view(e)) };
@@ -1580,7 +1989,8 @@ var Flow = class {
       const turn = this.turnCounts.get(box.id) ?? 0;
       const evicted = [];
       const evict = (cardId, reason) => {
-        evicted.push({ card: cardId, reason });
+        const known = this.internals.cardsById.get(cardId);
+        evicted.push({ card: known ? effectiveGameId(known.card) : cardId, reason });
         return false;
       };
       const survivors = (this.boardContents.get(hand.id) ?? []).filter((cardId) => {
@@ -1597,7 +2007,7 @@ var Flow = class {
       });
       this.boardContents.set(hand.id, survivors);
       if (this.tracing) {
-        for (const e of evicted) this.emit({ type: "evict", hand: hand.id, card: e.card, reason: e.reason }, turn);
+        for (const e of evicted) this.emit({ type: "evict", hand: effectiveGameId(hand), card: e.card, reason: e.reason }, turn);
       }
     }
     const claimCounts = this.claims();
@@ -1614,14 +2024,15 @@ var Flow = class {
         (card, shared) => own.has(card.id) ? "claimed" : this.claimVerdict(card, shared, claimCounts, worldClaims),
         trace
       );
-      const added = ordered.slice(0, free).map((e) => e.card.id);
+      const taking = ordered.slice(0, free);
+      const added = taking.map((e) => e.card.id);
       this.boardContents.set(hand.id, [...contents, ...added]);
       for (const id of added) {
         claimCounts.set(id, (claimCounts.get(id) ?? 0) + 1);
         worldClaims.set(id, (worldClaims.get(id) ?? 0) + 1);
       }
       if (trace) {
-        this.capTrace(trace, new Set(added));
+        this.capTrace(trace, new Set(taking.map((e) => effectiveGameId(e.card))));
         this.emit({ type: "deal", hand: effectiveGameId(hand), cards: trace }, this.turnCounts.get(box.id) ?? 0);
       }
     }
@@ -1689,7 +2100,8 @@ var Flow = class {
     if (!this.passes(outcome.condition, ctx)) {
       throw new Error(`outcome "${outcomeGameId}" on "${effectiveGameId(entry.card)}" is gated shut`);
     }
-    const newTurn = (this.turnCounts.get(entry.box.id) ?? 0) + (opts.advanceTurns ?? this.internals.bundle.settings.playAdvancesTurns);
+    const perPlay = entry.box.turn !== void 0 ? 0 : this.internals.bundle.settings.playAdvancesTurns;
+    const newTurn = (this.turnCounts.get(entry.box.id) ?? 0) + (opts.advanceTurns ?? perPlay);
     const writes = [];
     for (const [target, expr] of Object.entries(outcome.changes)) {
       writes.push({ target, value: this.eval(expr, ctx) });
@@ -1713,7 +2125,11 @@ var Flow = class {
       (this.boardContents.get(handId) ?? []).filter((id) => id !== entry.card.id)
     );
     this.turnCounts.set(entry.box.id, newTurn);
-    if (this.tracing) this.emit({ type: "play", card: entry.card.id, outcome: effectiveGameId(outcome), turn: newTurn }, newTurn);
+    if (this.tracing) this.emit({ type: "play", card: effectiveGameId(entry.card), outcome: effectiveGameId(outcome), turn: newTurn }, newTurn);
+  }
+  /** One owned property's address, owner segment and all (4.4). */
+  address(kind, id) {
+    return addressOf(this.internals, kind, id);
   }
   /** Land one change in whichever partition declares the name: the flow's
    *  bag when the property is per-flow, the shared bag when it is shared -
@@ -1734,24 +2150,24 @@ var Flow = class {
     const [, scope, name] = match;
     switch (scope) {
       case "world": {
-        const resolver = this.internals.worldResolver;
-        if (!resolver.set) throw new Error(`@world.${name} cannot be written: the host bound @world read-only`);
+        const worldSet = this.internals.worldSet;
+        if (!worldSet) throw new Error(`@world.${name} cannot be written: the host bound @world read-only`);
         if (this.internals.worldReadOnly.has(name)) throw new Error(`'@world.${name}' is read-only (writable: false)`);
-        const prev = resolver.get(name);
-        resolver.set(name, value);
+        const prev = this.internals.worldResolver.get(name);
+        worldSet(name, value);
         return { path: `world.${name}`, ...prev !== void 0 ? { prev } : {} };
       }
       case "story":
         return this.landIn("story", void 0, name, value, `story.${name}`);
       case "box":
-        return this.landIn("box", entry.box.id, name, value, `box.${entry.box.id}.${name}`);
+        return this.landIn("box", entry.box.id, name, value, `${this.address("box", entry.box.id)}.${name}`);
       case "deck":
-        return this.landIn("deck", entry.deck.id, name, value, `deck.${entry.deck.id}.${name}`);
+        return this.landIn("deck", entry.deck.id, name, value, `${this.address("deck", entry.deck.id)}.${name}`);
       case "hand": {
         const source = handEnv.sources.get(name);
         if (!source) throw new Error(`@hand.${name} is not composed in this ask`);
         if (source.kind === "criteria") throw new Error(`@hand.${name} is a chosen tag / criteria name and cannot be written`);
-        return this.landIn(source.kind, source.id, name, value, `${source.kind}.${source.id}.${name}`);
+        return this.landIn(source.kind, source.id, name, value, `${this.address(source.kind, source.id)}.${name}`);
       }
       default:
         throw new Error(`bad change target scope "@${scope}"`);
@@ -1787,7 +2203,7 @@ var Flow = class {
     this.assertOpen();
     const mounts = [{ prefix: "story", bag: this.stores.story }];
     for (const kind of ["box", "deck", "hand", "value"]) {
-      for (const [id, bag] of this.stores[kind]) mounts.push({ prefix: `${kind}.${id}`, bag });
+      for (const [id, bag] of this.stores[kind]) mounts.push({ prefix: addressOf(this.internals, kind, id), bag });
     }
     return mounts;
   }
@@ -1810,10 +2226,15 @@ var Flow = class {
         ...d.values !== void 0 ? { values: d.values } : {},
         ...d.stages !== void 0 ? { stages: d.stages } : {},
         // @world is FOREIGN - a host resolver backs it - so writability is whether that
-        // resolver can be written at all, which is the shared registry's own rule for a
-        // foreign scope. The `as PropertyView` cast this replaced was hiding the field's
-        // absence: the row type has always required it, and these rows shipped without one.
-        writable: this.internals.worldResolver.set !== void 0
+        // resolver can be written at all AND what the declaration says, which is the
+        // shared registry's own rule for a foreign scope (its foreignWritable). The
+        // `as PropertyView` cast this replaced was hiding the field's absence: the row
+        // type has always required it, and these rows shipped without one.
+        //
+        // A row is where `writable: false` is meant to SHOW (Reboot.md 10): it tells a
+        // state panel this is the game's value, not the story's. It does not stop the
+        // panel editing it - the host's setProperty passes `{ host: true }`.
+        writable: this.internals.worldSet !== void 0 && !this.internals.worldReadOnly.has(d.name)
       });
     }
     const add = (_prefix, shared, own) => {
@@ -1823,15 +2244,22 @@ var Flow = class {
       }
     };
     add("story", this.internals.shared.story, this.stores.story);
-    for (const kind of ["box", "deck", "hand", "value"]) {
+    for (const kind of OWNED_SCOPES) {
       const ids = /* @__PURE__ */ new Set([...this.internals.shared[kind].keys(), ...this.stores[kind].keys()]);
-      for (const id of ids) add(`${kind}.${id}`, this.internals.shared[kind].get(id), this.stores[kind].get(id));
+      for (const id of ids) {
+        add(addressOf(this.internals, kind, id), this.internals.shared[kind].get(id), this.stores[kind].get(id));
+      }
     }
     return out;
   }
-  /** Read by path: "world.x", "story.gold", "value.v_docks.danger",
-   *  "box.b_x.heat", "deck.k_main.n", "hand.h_board.owner" - the flow's
-   *  merged view, routed by the declaration's sharing. */
+  /** Read by path: "world.x", "story.gold", "value.docks.danger",
+   *  "box.village.heat", "deck.wares.n", "hand.the-elder.zone" - the flow's
+   *  merged view, routed by the declaration's sharing.
+   *
+   *  The owner segment is the entity's GAMEID, the name it is called by
+   *  everywhere else (4.4). Its internal id is accepted for this release and
+   *  earns a `diagnostic` naming the address to move to; the next lockstep
+   *  release refuses it. */
   getProperty(path) {
     this.assertOpen();
     const found = this.resolvePath(path);
@@ -1843,13 +2271,13 @@ var Flow = class {
     this.assertOpen();
     const found = this.resolvePath(path);
     if (found.kind === "world") {
-      if (!this.internals.worldResolver.set) throw new Error(`@world is read-only here: the host bound no write`);
-      this.internals.worldResolver.set(found.name, value);
+      if (!this.internals.worldSet) throw new Error(`@world is read-only here: the host bound no write`);
+      this.internals.worldSet(found.name, value, true);
       return;
     }
     const bag = found.own !== void 0 && found.own.get(found.name) !== void 0 ? found.own : found.shared !== void 0 && found.shared.get(found.name) !== void 0 ? found.shared : void 0;
     if (bag === void 0) throw new Error(`no property at "${path}"`);
-    bag.set(found.name, value, { silent: true, reason: "host setProperty" });
+    bag.set(found.name, value, { silent: true, reason: "host setProperty", host: true });
   }
   resolvePath(path) {
     const parts = path.split(".");
@@ -1859,10 +2287,15 @@ var Flow = class {
     }
     if (parts.length === 3 && (parts[0] === "box" || parts[0] === "deck" || parts[0] === "hand" || parts[0] === "value")) {
       const kind = parts[0];
-      const own = this.stores[kind].get(parts[1]);
-      const shared = this.internals.shared[kind].get(parts[1]);
-      if (own === void 0 && shared === void 0) throw new Error(`no ${parts[0]} store "${parts[1]}"`);
-      return { kind: "bag", ...own !== void 0 ? { own } : {}, ...shared !== void 0 ? { shared } : {}, name: parts[2] };
+      const [, segment, name] = parts;
+      const owner = ownerOrThrow(this.internals, kind, segment, name);
+      if (owner.legacy && this.tracing) {
+        this.emit({ type: "diagnostic", where: "property address", message: legacyAddressMessage(this.internals, kind, segment, name) });
+      }
+      const own = this.stores[kind].get(owner.id);
+      const shared = this.internals.shared[kind].get(owner.id);
+      if (own === void 0 && shared === void 0) throw new Error(`no ${kind} store "${segment}"`);
+      return { kind: "bag", ...own !== void 0 ? { own } : {}, ...shared !== void 0 ? { shared } : {}, name };
     }
     throw new Error(`bad property path "${path}"`);
   }
@@ -1903,14 +2336,27 @@ var summarise = (decls) => decls.map((d) => ({
   type: d.type,
   default: d.default,
   ...d.values !== void 0 ? { values: d.values } : {},
+  ...d.durable === true ? { durable: true } : {},
   ...d.purpose !== void 0 ? { purpose: d.purpose } : {}
 }));
+var durableCardCount = (box) => box.decks.reduce((n, deck) => n + deck.cards.filter((card) => (card.durable ?? deck.durable) === true).length, 0);
 var handDecls = (hand, box) => {
   if (hand.template !== void 0) {
     return box.handTemplates.find((t) => t.id === hand.template)?.properties ?? [];
   }
   return hand.properties ?? [];
 };
+var movableHoles = (hand, box) => {
+  const filled = hand.template !== void 0 ? hand.chosen : hand.rule?.bindings;
+  const out = [];
+  for (const [groupId, value] of Object.entries(filled ?? {})) {
+    if (!isHoleRef(value)) continue;
+    const group = box.tagGroups.find((g) => g.id === groupId);
+    if (group === void 0) continue;
+    out.push({ group: effectiveGameId(group), from: value });
+  }
+  return out;
+};
 var handSlots = (hand, box) => {
   if (hand.slots !== void 0) return hand.slots;
   const declared = hand.template !== void 0 ? box.handTemplates.find((t) => t.id === hand.template)?.slots : hand.rule?.slots;
@@ -1931,6 +2377,8 @@ function describeBundle(bundle) {
       gameId: boxGameId,
       ...box.title !== void 0 ? { title: box.title } : {},
       ranking: { specificity: box.ranking.specificity },
+      ...box.turn !== void 0 ? { turn: { seconds: box.turn.seconds } } : {},
+      ...durableCardCount(box) > 0 ? { durableCards: durableCardCount(box) } : {},
       tagGroups: box.tagGroups.map((group) => ({
         gameId: effectiveGameId(group),
         tags: group.tags.map((tag) => effectiveGameId(tag))
@@ -1951,12 +2399,14 @@ function describeBundle(bundle) {
     totals.tagGroups += box.tagGroups.length;
     for (const hand of box.hands) {
       const template = hand.template !== void 0 ? box.handTemplates.find((t) => t.id === hand.template) : void 0;
+      const movable = movableHoles(hand, box);
       hands.push({
         gameId: effectiveGameId(hand),
         ...hand.title !== void 0 ? { title: hand.title } : {},
         box: boxGameId,
         slots: handSlots(hand, box),
-        ...template !== void 0 ? { template: effectiveGameId(template) } : {}
+        ...template !== void 0 ? { template: effectiveGameId(template) } : {},
+        ...movable.length > 0 ? { movable } : {}
       });
     }
     const push = (scope, owner, decls, group) => {
@@ -1994,7 +2444,8 @@ function describeBundle(bundle) {
       box: map.box,
       group: map.group,
       zones: map.zones.length,
-      backgrounds: map.backgrounds?.length ?? 0
+      backgrounds: map.backgrounds?.length ?? 0,
+      sites: map.sites?.length ?? 0
     }))
   };
 }