@storylet-studio/runtime 0.8.1 → 0.9.0

package/dist/index.cjs

@@ -23,944 +23,24 @@ __export(index_exports, {
   Engine: () => Engine,
   Flow: () => Flow,
   describeBundle: () => describeBundle,
-  makePrng: () => makePrng,
-  shuffleInPlace: () => shuffleInPlace
+  makePrng: () => import_expr.makePrng,
+  shuffleInPlace: () => import_expr.shuffleInPlace
 });
 module.exports = __toCommonJS(index_exports);
 
-// ../../../expr/packages/expr/src/ast.ts
-function deserialiseAst(node) {
-  switch (node[0]) {
-    case "b":
-      return { kind: "bool", value: node[1] };
-    case "n":
-      return { kind: "number", value: node[1] };
-    case "s":
-      return { kind: "string", value: node[1] };
-    case "sv":
-      return { kind: "scopedvar", scope: node[1], name: node[2] };
-    case "u":
-      return { kind: "unary", op: node[1], operand: deserialiseAst(node[2]) };
-    case "bin":
-      return { kind: "binary", op: node[1], left: deserialiseAst(node[2]), right: deserialiseAst(node[3]) };
-    case "call": {
-      const args = node.slice(2).map(deserialiseAst);
-      return { kind: "call", name: node[1], args };
-    }
-    case "fd":
-      return { kind: "flagdelta", sign: node[1], name: node[2] };
-  }
-}
-
-// ../../../expr/packages/expr/src/evaluate.ts
-var EvalError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "EvalError";
-  }
-};
-function evaluate(node, ctx, dialect) {
-  const missingPolicy = new Map(
-    dialect.scopes.map((s) => [s.token, s.missing ?? "false"])
-  );
-  const rec = (n) => {
-    switch (n.kind) {
-      case "bool":
-        return n.value;
-      case "number":
-        return n.value;
-      case "string":
-        return n.value;
-      case "scopedvar": {
-        const scope = ctx.scopes[n.scope];
-        if (scope === void 0) {
-          return false;
-        }
-        const val = typeof scope.get === "function" ? scope.get(n.name) : scope[n.name];
-        if (val === void 0) {
-          if (missingPolicy.get(n.scope) === "throw") {
-            throw new EvalError(`@${n.scope}.${n.name} is not declared on the current ${n.scope}.`);
-          }
-          return false;
-        }
-        return val;
-      }
-      case "call": {
-        if (n.name === "advance" && !dialect.functions[n.name]) {
-          const arg = n.args[0];
-          if (n.args.length !== 1 || arg === void 0) {
-            throw new EvalError(`advance() takes exactly 1 argument, got ${n.args.length}`);
-          }
-          const ladder = ladderOf(arg, ctx);
-          if (ladder === void 0) {
-            throw new EvalError("advance() needs a quality reference (@scope.name of a quality property)");
-          }
-          const current = stageIndex(rec(arg), ladder, "advance");
-          return ladder[Math.min(current + 1, ladder.length - 1)];
-        }
-        const def = dialect.functions[n.name];
-        if (!def) throw new EvalError(`unknown function '${n.name}'`);
-        return def.eval(n.args, { evaluate: rec, ctx });
-      }
-      case "flagdelta":
-        throw new EvalError("flagdelta node is only valid as an argument to a flag-delta function");
-      case "unary": {
-        if (n.op === "not") {
-          const val2 = rec(n.operand);
-          if (typeof val2 !== "boolean") throw new EvalError(`'not' requires a boolean operand, got ${typeof val2}`);
-          return !val2;
-        }
-        const val = rec(n.operand);
-        if (typeof val !== "number") throw new EvalError(`unary '-' requires a numeric operand, got ${typeof val}`);
-        return -val;
-      }
-      case "binary": {
-        if (n.op === "and") {
-          const l = rec(n.left);
-          if (typeof l !== "boolean") throw new EvalError(`'and' requires boolean operands, left is ${typeof l}`);
-          if (!l) return false;
-          const r = rec(n.right);
-          if (typeof r !== "boolean") throw new EvalError(`'and' requires boolean operands, right is ${typeof r}`);
-          return r;
-        }
-        if (n.op === "or") {
-          const l = rec(n.left);
-          if (typeof l !== "boolean") throw new EvalError(`'or' requires boolean operands, left is ${typeof l}`);
-          if (l) return true;
-          const r = rec(n.right);
-          if (typeof r !== "boolean") throw new EvalError(`'or' requires boolean operands, right is ${typeof r}`);
-          return r;
-        }
-        const left = rec(n.left);
-        const right = rec(n.right);
-        const lLadder = ladderOf(n.left, ctx);
-        const rLadder = ladderOf(n.right, ctx);
-        const ladder = lLadder ?? rLadder;
-        if (ladder !== void 0) {
-          if (lLadder && rLadder && !sameLadder(lLadder, rLadder)) {
-            if (n.op === ">" || n.op === ">=" || n.op === "<" || n.op === "<=") {
-              throw new EvalError(`'${n.op}' compares two different qualities, whose stage orders are unrelated`);
-            }
-          }
-          switch (n.op) {
-            case ">":
-              return stageIndex(left, ladder, ">") > stageIndex(right, ladder, ">");
-            case ">=":
-              return stageIndex(left, ladder, ">=") >= stageIndex(right, ladder, ">=");
-            case "<":
-              return stageIndex(left, ladder, "<") < stageIndex(right, ladder, "<");
-            case "<=":
-              return stageIndex(left, ladder, "<=") <= stageIndex(right, ladder, "<=");
-            case "+":
-            case "-":
-            case "*":
-            case "/":
-              throw new EvalError(`'${n.op}' cannot be applied to a quality - a stage is a position, not a number; use advance() to move it`);
-            default:
-              break;
-          }
-        }
-        switch (n.op) {
-          case "==":
-            return valueEquals(left, right);
-          case "!=":
-            return !valueEquals(left, right);
-          case ">":
-            assertNumbers(left, right, ">");
-            return left > right;
-          case ">=":
-            assertNumbers(left, right, ">=");
-            return left >= right;
-          case "<":
-            assertNumbers(left, right, "<");
-            return left < right;
-          case "<=":
-            assertNumbers(left, right, "<=");
-            return left <= right;
-          case "+":
-            if (typeof left === "number" && typeof right === "number") return left + right;
-            if (typeof left === "string" && typeof right === "string") return left + right;
-            throw new EvalError(`'+' requires two numbers or two strings, got ${typeof left} and ${typeof right}`);
-          case "-":
-            assertNumbers(left, right, "-");
-            return left - right;
-          case "*":
-            assertNumbers(left, right, "*");
-            return left * right;
-          case "/":
-            assertNumbers(left, right, "/");
-            if (right === 0) throw new EvalError("division by zero");
-            return left / right;
-        }
-      }
-    }
-  };
-  return rec(node);
-}
-function valueEquals(a, b) {
-  if (Array.isArray(a) || Array.isArray(b)) {
-    if (!Array.isArray(a) || !Array.isArray(b)) return false;
-    if (a.length !== b.length) return false;
-    const x = [...a].sort();
-    const y = [...b].sort();
-    for (let i = 0; i < x.length; i++) if (x[i] !== y[i]) return false;
-    return true;
-  }
-  return a === b;
-}
-function assertNumbers(l, r, op) {
-  if (typeof l !== "number" || typeof r !== "number") {
-    throw new EvalError(`'${op}' requires numeric operands, got ${typeof l} and ${typeof r}`);
-  }
-}
-function ladderOf(node, ctx) {
-  if (node.kind !== "scopedvar" || ctx.qualities === void 0) return void 0;
-  return ctx.qualities(node.scope, node.name);
-}
-function stageIndex(value, ladder, op) {
-  if (typeof value !== "string") {
-    throw new EvalError(`'${op}' on a quality compares stages, got ${typeof value}`);
-  }
-  const i = ladder.indexOf(value);
-  if (i < 0) throw new EvalError(`"${value}" is not a stage of this quality (stages: ${ladder.join(", ")})`);
-  return i;
-}
-var sameLadder = (a, b) => a.length === b.length && a.every((x, i) => x === b[i]);
-
-// ../../../expr/packages/expr/src/prng.ts
-function toUint32(seed) {
-  if (Number.isNaN(seed) || !Number.isFinite(seed)) return 0;
-  const modded = Math.trunc(seed) % 4294967296;
-  return modded < 0 ? modded + 4294967296 : modded;
-}
-function makePrng(seed) {
-  let s = toUint32(seed);
-  return {
-    next() {
-      s = s + 1831565813 >>> 0;
-      let t = Math.imul(s ^ s >>> 15, 1 | s);
-      t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
-      return ((t ^ t >>> 14) >>> 0) / 4294967296;
-    },
-    state() {
-      return s;
-    }
-  };
-}
-function shuffleInPlace(arr, prng) {
-  for (let i = arr.length - 1; i > 0; i--) {
-    const j = Math.floor(prng.next() * (i + 1));
-    [arr[i], arr[j]] = [arr[j], arr[i]];
-  }
-}
-
-// ../../../expr/packages/expr-specificity/src/index.ts
-var CHECK_FLAGS_COUNTING_CALL = {
-  name: "check_flags",
-  count: (node) => Math.max(1, node.args.length - 1)
-};
-var DEFAULT_COUNTING_CALLS = [CHECK_FLAGS_COUNTING_CALL];
-function matchedSpecificity(node, evalTruthy, opts) {
-  const countingCalls = opts?.countingCalls ?? DEFAULT_COUNTING_CALLS;
-  return walk(node, opts?.want ?? true, evalTruthy, countingCalls);
-}
-function walk(node, want, evalTruthy, countingCalls) {
-  if (node.kind === "binary" && (node.op === "and" || node.op === "or")) {
-    const l = walk(node.left, want, evalTruthy, countingCalls);
-    const r = walk(node.right, want, evalTruthy, countingCalls);
-    const behaveAsAnd = node.op === "and" === want;
-    if (behaveAsAnd) return l > 0 && r > 0 ? l + r : 0;
-    return Math.max(l, r);
-  }
-  if (node.kind === "unary" && node.op === "not") {
-    return walk(node.operand, !want, evalTruthy, countingCalls);
-  }
-  if (node.kind === "call") {
-    const rule = countingCalls.find((c) => c.name === node.name);
-    if (rule) {
-      const operands = rule.count(node);
-      const holds = evalTruthy(node);
-      if (want) return holds ? operands : 0;
-      return holds ? 0 : 1;
-    }
-  }
-  return evalTruthy(node) === want ? 1 : 0;
-}
-
-// ../dialect/src/engine-scopes.ts
-var ENGINE_SCOPES = [
-  { token: "patter", engine: "Patterplay", means: "Patter's shared globals" },
-  { token: "story", engine: "Storylet Engine", means: "the Storylet Engine's shared @story properties" }
-];
-
-// ../dialect/src/index.ts
-var NEVER_PLAYED = 9999;
-var host = (h) => h.ctx.host ?? {};
-var stringArg = (fn, args, h, i) => {
-  const v = h.evaluate(args[i]);
-  if (typeof v !== "string" || v === "") {
-    throw new EvalError(`${fn}() argument ${i + 1} must be a non-empty string`);
-  }
-  return v;
-};
-var flagsArg = (fn, args, h) => {
-  if (args.length === 0) {
-    throw new EvalError(`${fn}() requires at least one argument (the flags property)`);
-  }
-  const v = h.evaluate(args[0]);
-  if (Array.isArray(v)) return v;
-  if (v === false) return [];
-  throw new EvalError(`${fn}() first argument must be a flags property`);
-};
-var OWN_SCOPES = ["story", "world", "box", "deck", "hand"];
-var EXTERNAL_SCOPES = ENGINE_SCOPES.map((s) => s.token).filter((t) => !OWN_SCOPES.includes(t));
-var storyletsDialect = {
-  // A missing property in a PRESENT scope is always an error: every property
-  // is declared with a default, so absence means a publish bug, a drifted
-  // save, or a foreign scope the host never fed (schema 6.2). The same holds
-  // for another engine's scope: `@patter.glod` is a typo, and it says so the
-  // first time the card is evaluated rather than quietly reading false.
-  scopes: [
-    ...OWN_SCOPES.map((token) => ({ token, missing: "throw" })),
-    ...EXTERNAL_SCOPES.map((token) => ({ token, missing: "throw" }))
-  ],
-  defaultScope: "story",
-  functions: {
-    random: {
-      minArgs: 2,
-      maxArgs: 2,
-      returnType: "number",
-      eval(args, h) {
-        if (args.length !== 2) throw new EvalError("random(a, b) requires exactly 2 arguments");
-        const nextRandom = host(h).nextRandom;
-        if (!nextRandom) throw new EvalError("random() called without a PRNG in context");
-        const a = h.evaluate(args[0]);
-        const b = h.evaluate(args[1]);
-        if (typeof a !== "number" || typeof b !== "number") {
-          throw new EvalError("random(a, b) arguments must be numbers");
-        }
-        if (!Number.isInteger(a) || !Number.isInteger(b)) {
-          throw new EvalError("random(a, b) arguments must be integers");
-        }
-        const lo = Math.min(a, b);
-        const hi = Math.max(a, b);
-        return Math.floor(nextRandom() * (hi - lo + 1)) + lo;
-      }
-    },
-    check_flags: {
-      minArgs: 1,
-      returnType: "boolean",
-      flagDeltaArgs: true,
-      eval(args, h) {
-        const flags = flagsArg("check_flags", args, h);
-        for (let i = 1; i < args.length; i++) {
-          const arg = args[i];
-          if (arg.kind !== "flagdelta") {
-            throw new EvalError("check_flags() flag args must be +flagName or -flagName");
-          }
-          if (arg.sign === "+" ? !flags.includes(arg.name) : flags.includes(arg.name)) {
-            return false;
-          }
-        }
-        return true;
-      }
-    },
-    set_flags: {
-      minArgs: 1,
-      returnType: "flags",
-      flagDeltaArgs: true,
-      eval(args, h) {
-        const result = [...flagsArg("set_flags", args, h)];
-        for (let i = 1; i < args.length; i++) {
-          const arg = args[i];
-          if (arg.kind !== "flagdelta") {
-            throw new EvalError("set_flags() flag args must be +flagName or -flagName");
-          }
-          if (arg.sign === "+") {
-            if (!result.includes(arg.name)) result.push(arg.name);
-          } else {
-            const idx = result.indexOf(arg.name);
-            if (idx >= 0) result.splice(idx, 1);
-          }
-        }
-        return result.sort();
-      }
-    },
-    count_played: {
-      minArgs: 1,
-      maxArgs: 1,
-      returnType: "number",
-      eval(args, h) {
-        const card = stringArg("count_played", args, h, 0);
-        const fn = host(h).countPlayed;
-        if (!fn) throw new EvalError("count_played() called without a play log in context");
-        return fn(card);
-      }
-    },
-    turns_since_played: {
-      minArgs: 1,
-      maxArgs: 1,
-      returnType: "number",
-      eval(args, h) {
-        const card = stringArg("turns_since_played", args, h, 0);
-        const fn = host(h).turnsSincePlayed;
-        if (!fn) throw new EvalError("turns_since_played() called without a play log in context");
-        return fn(card);
-      }
-    },
-    count_played_in: {
-      minArgs: 2,
-      maxArgs: 2,
-      returnType: "number",
-      eval(args, h) {
-        const dimension = stringArg("count_played_in", args, h, 0);
-        const value = stringArg("count_played_in", args, h, 1);
-        const fn = host(h).countPlayedIn;
-        if (!fn) throw new EvalError("count_played_in() called without a play log in context");
-        return fn(dimension, value);
-      }
-    },
-    turns_since_played_in: {
-      minArgs: 2,
-      maxArgs: 2,
-      returnType: "number",
-      eval(args, h) {
-        const dimension = stringArg("turns_since_played_in", args, h, 0);
-        const value = stringArg("turns_since_played_in", args, h, 1);
-        const fn = host(h).turnsSincePlayedIn;
-        if (!fn) throw new EvalError("turns_since_played_in() called without a play log in context");
-        return fn(dimension, value);
-      }
-    }
-  }
-};
-
-// ../model/src/index.ts
-function gameIdify(text) {
-  return text.toLowerCase().replace(/['’]/g, "").replace(/[^a-z0-9-]+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
-}
-function effectiveGameId(entity) {
-  const pinned = entity.gameId?.trim();
-  if (pinned) return pinned;
-  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] };
-};
-var SAVE_SCHEMA = "storylets/save@2";
-var SAVE_SCHEMA_V1 = "storylets/save@1";
+// src/engine.ts
+var import_expr2 = require("@wildwinter/expr");
+var import_expr_specificity = require("@wildwinter/expr-specificity");
+var import_dialect = require("@storylet-studio/dialect");
+var import_model = require("@storylet-studio/model");
+var import_model2 = require("@storylet-studio/model");
+var import_scoperegistry = require("@wildwinter/scoperegistry");
 
-// ../../../expr/packages/scoperegistry/src/index.ts
-var PropertyBag = class _PropertyBag {
-  /** The live values record (stable identity across reseed, so an
-   *  EvalContext built over it stays valid). Read-path for evaluation;
-   *  writes go through `set` so the firing rule applies. */
-  values = {};
-  decls = /* @__PURE__ */ new Map();
-  subscribers = /* @__PURE__ */ new Set();
-  auditors = /* @__PURE__ */ new Set();
-  /** Name normalisation policy: lowercase by default (the registry's
-   *  long-standing contract); a product whose names are case-significant
-   *  passes identity. */
-  norm;
-  /** The address prefix this bag's rows carry, separator included (`@`,
-   *  `@scene.`, `world.`, `deck.<id>.`). Empty means a row's path is its name. */
-  pathPrefix;
-  constructor(declarations = [], opts) {
-    this.norm = opts?.normalise ?? ((n) => n.toLowerCase());
-    this.pathPrefix = opts?.pathPrefix ?? "";
-    this.seed(declarations);
-  }
-  seed(declarations) {
-    for (const d of declarations) {
-      const name = this.norm(d.name);
-      this.decls.set(name, d);
-      this.values[name] = structuredClone(d.default ?? defaultFor(d));
-    }
-  }
-  get(name) {
-    return this.values[this.norm(name)];
-  }
-  /** A name as this bag keys it: its normalisation policy applied. The registry
-   *  uses it to key quality ladders and the validation schema the bag's own way,
-   *  so a case-significant (identity) bag is not quietly folded to lower case
-   *  one layer up. */
-  normalise(name) {
-    return this.norm(name);
-  }
-  /** 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 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 (!opts?.host && this.decls.get(n)?.writable === false) throw new Error(`'${name}' is read-only`);
-    const change = {
-      name: n,
-      prev: this.values[n],
-      next: value,
-      silent: opts?.silent ?? false,
-      reason: opts?.reason
-    };
-    this.values[n] = value;
-    for (const audit of this.auditors) audit(change);
-    if (!change.silent) for (const fn of this.subscribers) fn(change);
-    return change;
-  }
-  /** Notified of engine (non-silent) writes. Returns the unsubscribe. */
-  subscribe(fn) {
-    this.subscribers.add(fn);
-    return () => this.subscribers.delete(fn);
-  }
-  /** Notified of EVERY write, silent or not. Returns the unsubscribe. */
-  onAudit(fn) {
-    this.auditors.add(fn);
-    return () => this.auditors.delete(fn);
-  }
-  /** Examiner rows: the declared surface only (stray values are storage,
-   *  not surface). */
-  rows() {
-    return [...this.decls.entries()].map(([name, d]) => rowFor(d, this.get(name), void 0, name, this.pathPrefix));
-  }
-  declarations() {
-    return [...this.decls.values()];
-  }
-  /** The one sanctioned copy door: values deep-copied, declarations
-   *  duplicated, the normalisation policy carried, subscriptions NOT
-   *  carried. */
-  clone() {
-    const c = new _PropertyBag([], { normalise: this.norm, pathPrefix: this.pathPrefix });
-    c.decls = new Map(this.decls);
-    Object.assign(c.values, structuredClone(this.values));
-    return c;
-  }
-  /** Clear and re-seed from new declarations, in place (the values record
-   *  keeps its identity, so contexts built over it stay valid). */
-  reseed(declarations) {
-    for (const k of Object.keys(this.values)) delete this.values[k];
-    this.decls.clear();
-    this.seed(declarations);
-  }
-  /** Bare values, ready to embed in a product's save. */
-  save() {
-    return structuredClone(this.values);
-  }
-  /** Lay saved values over the current ones (call after a fresh seed:
-   *  orphans land as strays, new declarations keep their defaults; the
-   *  product decides whether to prune). Does not fire events. */
-  load(values) {
-    for (const [k, v] of Object.entries(values)) this.values[this.norm(k)] = v;
-  }
-};
-function rowFor(d, value, writable, name, pathPrefix = "") {
-  const rowName = name ?? d.name.toLowerCase();
-  return {
-    name: rowName,
-    path: pathPrefix + rowName,
-    type: d.type,
-    value,
-    default: d.default ?? defaultFor(d),
-    ...d.values !== void 0 ? { values: d.values } : {},
-    // `stages` was added to the row so an examiner could offer a quality's ladder
-    // instead of a free-text box, and then never populated here: every quality row
-    // this function built came out without one. Fixed 2026-09-02.
-    ...d.stages !== void 0 ? { stages: d.stages } : {},
-    writable: writable ?? d.writable ?? true
-  };
-}
-var lowerCase = (name) => name.toLowerCase();
-var SAVE_FRAGMENT_VERSION = 1;
-var ScopeRegistry = class {
-  scopes = /* @__PURE__ */ new Map();
-  /** Values loaded for keys nobody has registered yet, waiting to be claimed. */
-  parked = /* @__PURE__ */ new Map();
-  rev = 0;
-  /**
-   * A counter that moves whenever a scope is registered or removed, and at no
-   * other time: it starts at 0 and each registration or removal adds 1. Values
-   * changing does not move it. A caller that caches a context built by
-   * `toEvalContext()` rebuilds it when this moves, because the context's set of
-   * scopes is fixed when it is built while the values it reads stay live.
-   */
-  get revision() {
-    return this.rev;
-  }
-  /**
-   * Register a scope this registry **owns and stores**. Its bag is seeded from
-   * each declaration's `default` (or a type default). Owned scopes are
-   * type-checked (declarations) and serialized by `save`/`load`.
-   *
-   * The third argument may be the path prefix alone (the pre-0.7 form) or an
-   * options object.
-   */
-  defineOwned(token, declarations, opts) {
-    const o = typeof opts === "string" ? { pathPrefix: opts } : opts ?? {};
-    const bag = new PropertyBag(declarations, {
-      pathPrefix: o.pathPrefix ?? `${token}.`,
-      ...o.normalise ? { normalise: o.normalise } : {}
-    });
-    return this.mountOwned(token, bag, o.owner !== void 0 ? { owner: o.owner } : void 0);
-  }
-  /**
-   * Attach an EXISTING bag as an owned scope: an engine (or a host) holds the
-   * bag and this registry reads, writes, lists and saves it like its own.
-   *
-   * If values were loaded for this key before anyone registered it, the bag
-   * claims them now: laid over its seeded defaults by the bag's own `load` rule.
-   */
-  mountOwned(token, bag, opts) {
-    this.assertFree(token, opts?.owner);
-    this.scopes.set(token, { kind: "owned", bag, ...opts?.owner !== void 0 ? { owner: opts.owner } : {} });
-    this.rev++;
-    const waiting = this.parked.get(token);
-    if (waiting) {
-      bag.load(waiting);
-      this.parked.delete(token);
-    }
-    return this;
-  }
-  /**
-   * Unregister a scope. With `{ keep: true }` an owned scope's values are parked
-   * and handed back when the same key is next registered, which is how a live
-   * reload hands an engine's state to its replacement. Throws on an unknown key.
-   */
-  remove(token, opts) {
-    const e = this.scopes.get(token);
-    if (!e) throw new Error(`unknown scope '@${token}'`);
-    if (opts?.keep && e.kind === "owned") this.parked.set(token, e.bag.save());
-    this.scopes.delete(token);
-    this.rev++;
-    return this;
-  }
-  /**
-   * Drop parked values nobody claimed. Parked values are kept in the next save by
-   * default, so nothing loaded is lost to a flow or deck that simply has not
-   * reopened yet; a game that knows they are dead drops them here.
-   *
-   * With a `prefix`, only keys starting with it are dropped: an engine resetting
-   * itself drops its own instance keys (`my-engine/`) and leaves every other
-   * engine's alone.
-   */
-  discardParked(prefix) {
-    if (prefix === void 0) this.parked.clear();
-    else for (const key of [...this.parked.keys()]) if (key.startsWith(prefix)) this.parked.delete(key);
-    return this;
-  }
-  /** An owned scope's bag (subscribe, audit, rows live there). */
-  ownedBag(token) {
-    const e = this.scopes.get(token);
-    if (!e || e.kind !== "owned") throw new Error(`'@${token}' is not an owned scope`);
-    return e.bag;
-  }
-  /**
-   * Re-initialise an existing **owned** scope's bag from new declarations,
-   * clearing its current values. For scope-local state that resets on a context
-   * change (e.g. entering a new scene / site / deck) without disturbing other
-   * scopes. Mutates the bag in place, so an `EvalContext` already built from this
-   * registry stays valid.
-   */
-  reseedOwned(token, declarations) {
-    this.ownedBag(token).reseed(declarations);
-    return this;
-  }
-  /**
-   * Register a **foreign** scope backed by a host `{ get, set? }` resolver. The
-   * values live in the host/other engine and are never stored or saved here.
-   * `declarations` (optional, e.g. imported from a `scopeRegistrySpec`) are used
-   * only for validation; omit them for an opaque scope.
-   */
-  defineForeign(token, resolver, declarations = [], opts = true) {
-    const o = typeof opts === "boolean" ? { writable: opts } : opts;
-    this.assertFree(token, o.owner);
-    const norm = o.normalise ?? lowerCase;
-    const decls = /* @__PURE__ */ new Map();
-    for (const d of declarations) decls.set(norm(d.name), d);
-    this.scopes.set(token, {
-      kind: "foreign",
-      resolver,
-      decls,
-      scopeWritable: o.writable ?? true,
-      norm,
-      ...o.owner !== void 0 ? { owner: o.owner } : {}
-    });
-    this.rev++;
-    return this;
-  }
-  has(token) {
-    return this.scopes.has(token);
-  }
-  /** Read a property; undefined if the scope or property is not present. */
-  get(scope, name) {
-    const e = this.scopes.get(scope);
-    if (!e) return void 0;
-    return e.kind === "owned" ? e.bag.get(name) : e.resolver.get(e.norm(name));
-  }
-  /** Write a property (an ENGINE write: the bag's subscribers fire; use
-   *  the bag directly for silent host writes). Throws on an unknown scope.
-   *
-   *  `writable: false` is the STORY's promise, so a story write is refused and
-   *  a HOST write is not: pass `{ host: true }` from a host's own surface (its
-   *  `setProperty`, its tooling, a coverage driver) and never from the path an
-   *  outcome or effect takes. A foreign scope whose resolver has no `set` is
-   *  refused for everyone, host included - that is not a rule to bypass, it is
-   *  a game that gave no way to write. */
-  set(scope, name, value, opts) {
-    const e = this.scopes.get(scope);
-    if (!e) throw new Error(`unknown scope '@${scope}'`);
-    if (e.kind === "owned") {
-      try {
-        e.bag.set(name, value, opts?.host ? { host: true } : void 0);
-      } catch {
-        throw new Error(`'@${scope}.${name}' is read-only`);
-      }
-      return;
-    }
-    const n = e.norm(name);
-    if (!e.resolver.set) throw new Error(`'@${scope}.${name}' is read-only`);
-    if (!opts?.host && !this.foreignWritable(e, n)) throw new Error(`'@${scope}.${name}' is read-only`);
-    e.resolver.set(n, value);
-  }
-  foreignWritable(e, name) {
-    if (!e.resolver.set) return false;
-    return e.decls.get(name)?.writable ?? e.scopeWritable;
-  }
-  /** Examiner rows across every scope with a declared surface: owned bags
-   *  first, then declared foreign scopes (values read through, writability
-   *  reflecting the resolver). Opaque foreign scopes are not listed. */
-  listProperties() {
-    const out = [];
-    for (const [token, e] of this.scopes) {
-      const owner = e.owner !== void 0 ? { owner: e.owner } : {};
-      if (e.kind === "owned") {
-        for (const row of e.bag.rows()) out.push({ scope: token, ...owner, ...row });
-      } else {
-        for (const [n, d] of e.decls) {
-          out.push({
-            scope: token,
-            ...owner,
-            ...rowFor(d, e.resolver.get(n), this.foreignWritable(e, n), n, `${token}.`)
-          });
-        }
-      }
-    }
-    return out;
-  }
-  /**
-   * Build the `EvalContext` expr's `evaluate` consumes: owned scopes as static
-   * bags, foreign scopes as their resolvers. `host` carries dialect-function
-   * callbacks (PRNG, tag lookups) and is passed through untouched.
-   */
-  toEvalContext(host2, opts) {
-    const view = this.view(opts?.aliases);
-    const scopes = {};
-    for (const [token, e] of view) scopes[token] = e.kind === "owned" ? e.bag.values : e.resolver;
-    const qualities = this.qualityLadders(view);
-    return qualities.size === 0 ? { scopes, host: host2 } : {
-      scopes,
-      host: host2,
-      qualities: (scope, name) => {
-        const e = view.get(scope);
-        return e ? qualities.get(scope)?.get(normOf(e)(name)) : void 0;
-      }
-    };
-  }
-  /**
-   * The scopes an expression sees: every registered key under its own token,
-   * then each alias token pointing at its key's entry (an alias shadows a key of
-   * the same name). Keys an engine uses for instance bags (`engine/flow-2/...`)
-   * are not valid expression tokens, so they are present but unreachable.
-   */
-  view(aliases) {
-    const out = new Map(this.scopes);
-    for (const [token, key] of Object.entries(aliases ?? {})) {
-      const e = this.scopes.get(key);
-      if (!e) throw new Error(`alias '@${token}' names '${key}', which is not registered`);
-      out.set(token, e);
-    }
-    return out;
-  }
-  /** Every quality declaration's ladder, keyed scope token then name (the
-   *  scope's own normalisation). */
-  qualityLadders(view) {
-    const out = /* @__PURE__ */ new Map();
-    for (const [token, e] of view) {
-      for (const [n, d] of declsOf(e)) {
-        if (d.type !== "quality" || d.stages === void 0) continue;
-        let m = out.get(token);
-        if (!m) {
-          m = /* @__PURE__ */ new Map();
-          out.set(token, m);
-        }
-        m.set(n, d.stages);
-      }
-    }
-    return out;
-  }
-  /**
-   * Build the `ExpressionSchema` expr's validator consumes. Scopes with no
-   * declarations are **omitted** (opaque - references into them are not flagged);
-   * declared scopes contribute their property types for validation. Aliases
-   * apply as they do to `toEvalContext`, so a condition written against `@scene`
-   * validates against the instance bag the engine names.
-   */
-  toSchema(opts) {
-    const properties = /* @__PURE__ */ new Map();
-    for (const [token, e] of this.view(opts?.aliases)) {
-      const decls = declsOf(e);
-      if (decls.length === 0) continue;
-      const m = /* @__PURE__ */ new Map();
-      for (const [n, d] of decls) m.set(n, {
-        type: d.type,
-        enumValues: d.values,
-        ...d.stages !== void 0 ? { stages: d.stages } : {}
-      });
-      properties.set(token, m);
-    }
-    return { properties };
-  }
-  /** Serialize **owned** scopes (foreign scopes are the game's, and the game
-   *  saves them), as bare bags keyed by token, plus any values still parked, so
-   *  a save taken before every engine has re-registered loses nothing. The
-   *  registry knows nothing about game saves: a game embeds this in its own. */
-  save() {
-    const out = {};
-    for (const [token, e] of this.scopes) if (e.kind === "owned") out[token] = e.bag.save();
-    for (const [token, vals] of this.parked) out[token] = structuredClone(vals);
-    return out;
-  }
-  /**
-   * Restore from a `save` blob. An owned scope lays its section over its current
-   * values (the bag's `load` rule). A section for a key nobody has registered
-   * yet is PARKED and handed over when that key registers, so a game can load
-   * its registry before its engines have reopened their flows or decks. A
-   * section for a foreign scope is ignored: those values are the game's.
-   *
-   * A load replaces whatever was parked before it: it is a whole restore, and
-   * residue from an earlier load must not leak into this one.
-   *
-   * Changed in 0.7.0: sections for unregistered keys used to be dropped.
-   */
-  load(blob, opts) {
-    if (!opts?.keepParked) this.parked.clear();
-    for (const [token, vals] of Object.entries(blob)) {
-      const e = this.scopes.get(token);
-      if (e?.kind === "owned") e.bag.load(vals);
-      else if (!e) this.parked.set(token, structuredClone(vals));
-    }
-  }
-  /**
-   * `save()` wrapped with a version stamp.
-   *
-   * @deprecated Versioning belongs to the save that embeds the values; no
-   * engine ever called this. Embed `save()` in your own versioned save.
-   * Removed at the next breaking release.
-   */
-  saveFragment() {
-    return { version: SAVE_FRAGMENT_VERSION, scopes: this.save() };
-  }
-  /**
-   * Restore from a versioned fragment; an unsupported version throws.
-   *
-   * @deprecated See `saveFragment`. Removed at the next breaking release.
-   */
-  loadFragment(fragment) {
-    if (fragment.version !== SAVE_FRAGMENT_VERSION) {
-      throw new Error(`unsupported owned-state fragment version ${fragment.version} (supported: ${SAVE_FRAGMENT_VERSION})`);
-    }
-    this.load(fragment.scopes);
-  }
-  /**
-   * A token is taken once. There is no reserved-token list: a clash surfaces
-   * here, the moment a game combines its engines, which is the only moment
-   * anyone knows which engines are present. With owners recorded the error says
-   * whose token it already is.
-   */
-  assertFree(token, owner) {
-    const e = this.scopes.get(token);
-    if (!e) return;
-    const by = e.owner !== void 0 ? ` by ${e.owner}` : "";
-    const wants = owner !== void 0 ? ` (wanted by ${owner})` : "";
-    throw new Error(`scope '@${token}' is already registered${by}${wants}`);
-  }
-};
-function declsOf(e) {
-  if (e.kind === "foreign") return [...e.decls.entries()];
-  return e.bag.declarations().map((d) => [e.bag.normalise(d.name), d]);
-}
-function normOf(e) {
-  return e.kind === "foreign" ? e.norm : (n) => e.bag.normalise(n);
-}
-function defaultFor(d) {
-  if (d.default !== void 0) return d.default;
-  switch (d.type) {
-    case "boolean":
-      return false;
-    case "number":
-      return 0;
-    case "string":
-      return "";
-    case "enum":
-      return d.values?.[0] ?? "";
-    case "flags":
-      return [];
-    // A quality starts at the first rung of its ladder.
-    case "quality":
-      return d.stages?.[0] ?? "";
-    // Unreachable for a well-typed declaration, and deliberately present anyway: a bundle
-    // is DATA, and a hand-edited or newer-than-this-build one can carry a type string the
-    // union does not have. Falling off the switch would seed `undefined`, which is not a
-    // ScalarValue and travels a long way before it fails. Patterplay's copy of this had the
-    // guard and this one did not, which is the drift you only find by removing a duplicate.
-    default:
-      return false;
-  }
-}
+// src/prng.ts
+var import_expr = require("@wildwinter/expr");
 
 // src/engine.ts
-var tagKey = (groupId, tagId) => `${groupId}${tagId}`;
+var tagKey = (boxId, groupId, tagId) => `${boxId}${groupId}${tagId}`;
 var cardIsShared = (card, deckShared) => card.shared ?? deckShared;
 var sharedCap = (card) => card.sharedCopies ?? card.copies ?? 1;
 var OWNER = "Storylet Engine";
@@ -1005,7 +85,7 @@ function sectionsOf(p, keyOf, out) {
     for (const [id, values] of Object.entries(p[kind])) if (Object.keys(values).length > 0) out[keyOf(kind, id)] = values;
   }
 }
-var bagFromDecls = (decls, pathPrefix) => new PropertyBag(decls, { normalise: (n) => n, pathPrefix });
+var bagFromDecls = (decls, pathPrefix) => new import_scoperegistry.PropertyBag(decls, { normalise: (n) => n, pathPrefix });
 function conditionPasses(v) {
   if (typeof v === "boolean") return v;
   if (typeof v === "number") return v !== 0;
@@ -1017,22 +97,24 @@ 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 emptyOwnerIndex = () => ({ gameId: /* @__PURE__ */ new Map(), id: /* @__PURE__ */ new Map(), repeated: /* @__PURE__ */ new Map(), zoneQualified: /* @__PURE__ */ new Map() });
 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() }
+  box: emptyOwnerIndex(),
+  deck: emptyOwnerIndex(),
+  hand: emptyOwnerIndex(),
+  value: emptyOwnerIndex()
 });
 var indexOwner = (index, entity) => {
-  const gameId = effectiveGameId(entity);
+  const gameId = (0, import_model.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);
+  const addresses = (0, import_model.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);
+  for (const [segment, zone] of addresses.zoneQualified) index.zoneQualified.set(segment, zone);
 };
 var handDeclsOf = (internals, hand) => {
   if (hand.template !== void 0) {
@@ -1044,6 +126,8 @@ var addressOf = (internals, kind, id) => `${kind}.${internals.owners[kind].gameI
 var resolveOwner = (internals, kind, segment) => {
   const candidates = internals.owners[kind].repeated.get(segment);
   if (candidates !== void 0) return { ambiguous: candidates };
+  const zone = internals.owners[kind].zoneQualified.get(segment);
+  if (zone !== void 0) return { zone };
   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 };
@@ -1052,7 +136,8 @@ var resolveOwner = (internals, kind, segment) => {
 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));
+  if ("ambiguous" in owner) throw new Error((0, import_model.ambiguousValueAddressMessage)(segment, name, owner.ambiguous));
+  if ("zone" in owner) throw new Error((0, import_model.zoneQualifiedValueAddressMessage)(segment, owner.zone, name));
   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.`;
@@ -1070,9 +155,12 @@ var buildPartition = (internals, half) => {
     hand: new Map(b.boxes.flatMap((box) => box.hands.map(
       (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(
+    // Every box's tags, then the project map's zones ONCE (design/project-
+    // map-contract.md 3.3): a zone is one bag per partition, whichever boxes'
+    // hands are dealt to it.
+    value: new Map((0, import_model.allTagGroups)(b).flatMap((group) => group.tags.map(
       (tag) => [tag.id, bagFromDecls(half("value", tag.properties ?? []), at("value", tag.id))]
-    ))))
+    )))
   };
 };
 var partitionValues = (p) => ({
@@ -1189,6 +277,68 @@ function finishReport(bundle, saved, flows, draft) {
     retypedProperties
   };
 }
+var refuseUnreadableBundle = (bundle) => {
+  const schema = bundle.schema;
+  if (typeof schema !== "string" || !import_model.BUNDLE_SCHEMAS.includes(schema)) {
+    throw new Error(`unsupported bundle schema: ${String(schema)} (this runtime reads ${import_model.BUNDLE_SCHEMAS.join(" and ")})`);
+  }
+  const problems = [];
+  const map = bundle.map?.group;
+  const mapName = map !== void 0 ? (0, import_model.effectiveGameId)(map) : void 0;
+  if (map !== void 0 && mapName === import_model.PLACE_GROUP) {
+    problems.push(`the project map's tag group is called "${import_model.PLACE_GROUP}", which is reserved for a box's own hands`);
+  }
+  const boxTags = /* @__PURE__ */ new Map();
+  for (const box of bundle.boxes) {
+    for (const group of box.tagGroups) {
+      for (const tag of group.tags) {
+        const gameId = (0, import_model.effectiveGameId)(tag);
+        if (!boxTags.has(gameId)) boxTags.set(gameId, { box: (0, import_model.effectiveGameId)(box), group: (0, import_model.effectiveGameId)(group) });
+      }
+    }
+  }
+  for (const tag of map?.tags ?? []) {
+    const zone = (0, import_model.effectiveGameId)(tag);
+    const clash = boxTags.get(zone);
+    if (clash !== void 0) {
+      problems.push(`the project map's zone "${zone}" has the name of tag "${zone}" in box "${clash.box}", group "${clash.group}", so "value.${zone}.<name>" would name two things`);
+    }
+  }
+  for (const box of bundle.boxes) {
+    const boxName = (0, import_model.effectiveGameId)(box);
+    if (box.usesMap === true) {
+      if (map === void 0) {
+        problems.push(`box "${boxName}" uses the project map, but the bundle has no map`);
+        continue;
+      }
+      const twin = box.tagGroups.find((g) => (0, import_model.effectiveGameId)(g) === mapName);
+      if (twin !== void 0) {
+        problems.push(`box "${boxName}" uses the project map and declares its own tag group "${mapName}", the map's name`);
+      }
+      continue;
+    }
+    if (map === void 0) continue;
+    const names = (where) => {
+      problems.push(`box "${boxName}" is not on the project map, but ${where} names the map's tag group "${mapName}"`);
+    };
+    for (const deck of box.decks) {
+      for (const card of deck.cards) {
+        if (card.tags?.[map.id] !== void 0) names(`card "${(0, import_model.effectiveGameId)(card)}"`);
+      }
+    }
+    for (const template of box.handTemplates) {
+      if (template.bindings?.[map.id] !== void 0 || template.chooses?.includes(map.id) === true) {
+        names(`hand template "${(0, import_model.effectiveGameId)(template)}"`);
+      }
+    }
+    for (const hand of box.hands) {
+      if (hand.chosen?.[map.id] !== void 0 || hand.rule?.bindings?.[map.id] !== void 0) {
+        names(`hand "${(0, import_model.effectiveGameId)(hand)}"`);
+      }
+    }
+  }
+  if (problems.length > 0) throw new Error(`bundle refused: ${problems.join("; ")}`);
+};
 var Engine = class _Engine {
   internals;
   seed;
@@ -1205,6 +355,7 @@ var Engine = class _Engine {
    *  hotSwap puts this engine back exactly as it was. */
   sharedMounts = [];
   constructor(bundle, opts = {}) {
+    refuseUnreadableBundle(bundle);
     this.creationOptions = opts;
     this.seed = opts.seed ?? 0;
     this.onReplacedFlow = opts.onReplacedFlow;
@@ -1229,7 +380,7 @@ var Engine = class _Engine {
       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,
-      registry: opts.registry ?? new ScopeRegistry(),
+      registry: opts.registry ?? new import_scoperegistry.ScopeRegistry(),
       ownsRegistry: opts.registry === void 0,
       selfWorld: false,
       registryView: () => view(),
@@ -1263,7 +414,7 @@ var Engine = class _Engine {
     indexValueOwners(internals.owners.value, bundle);
     for (const box of bundle.boxes) {
       internals.boxesById.set(box.id, box);
-      internals.boxesByGameId.set(effectiveGameId(box), box);
+      internals.boxesByGameId.set((0, import_model.effectiveGameId)(box), box);
       indexOwner(internals.owners.box, box);
       for (const group of box.tagGroups) {
         internals.groupsById.set(group.id, { group, box });
@@ -1275,7 +426,7 @@ var Engine = class _Engine {
         for (const card of deck.cards) {
           const entry = { card, deck, box };
           internals.cardsById.set(card.id, entry);
-          internals.cardsByGameId.set(effectiveGameId(card), entry);
+          internals.cardsByGameId.set((0, import_model.effectiveGameId)(card), entry);
           if (card.shared === true) internals.hasShared = true;
         }
       }
@@ -1284,10 +435,14 @@ var Engine = class _Engine {
       }
       for (const hand of box.hands) {
         internals.handsById.set(hand.id, { hand, box });
-        internals.handsByGameId.set(effectiveGameId(hand), { hand, box });
+        internals.handsByGameId.set((0, import_model.effectiveGameId)(hand), { hand, box });
         indexOwner(internals.owners.hand, hand);
       }
     }
+    if (bundle.map !== void 0) {
+      internals.groupsById.set(bundle.map.group.id, { group: bundle.map.group });
+      if (bundle.map.group.required === true) internals.requiredGroups.add(bundle.map.group.id);
+    }
     this.initLadders();
     const declSet = (half) => ({
       story: half("story", bundle.story.properties),
@@ -1298,9 +453,9 @@ var Engine = class _Engine {
       hand: new Map(bundle.boxes.flatMap((box) => box.hands.map(
         (hand) => [hand.id, half("hand", handDeclsOf(internals, hand))]
       ))),
-      value: new Map(bundle.boxes.flatMap((box) => box.tagGroups.flatMap((group) => group.tags.map(
+      value: new Map((0, import_model.allTagGroups)(bundle).flatMap((group) => group.tags.map(
         (tag) => [tag.id, half("value", tag.properties ?? [])]
-      ))))
+      )))
     });
     internals.flowDecls = declSet(flowHalf);
     internals.sharedDecls = declSet(sharedHalf);
@@ -1362,8 +517,8 @@ var Engine = class _Engine {
         reg.set("world", n, v, { host: true });
       } : void 0;
     } else {
-      internals.worldSet = (n, v, host2) => {
-        reg.set("world", n, v, host2 === true ? { host: true } : void 0);
+      internals.worldSet = (n, v, host) => {
+        reg.set("world", n, v, host === true ? { host: true } : void 0);
       };
     }
   }
@@ -1401,6 +556,7 @@ var Engine = class _Engine {
       }
       for (const hand of box.hands) internals.ladders.hand.set(hand.id, grab(handDeclsOf(internals, hand)));
     }
+    for (const tag of b.map?.group.tags ?? []) internals.ladders.value.set(tag.id, grab(tag.properties));
     const any = (m) => [...m.values()].some((x) => x.size > 0);
     internals.hasQualities = internals.ladders.world.size > 0 || internals.ladders.story.size > 0 || any(internals.ladders.box) || any(internals.ladders.deck) || any(internals.ladders.value) || any(internals.ladders.hand);
   }
@@ -1722,13 +878,37 @@ var Engine = class _Engine {
    *  saves it once itself, beside each engine's envelope. */
   saveGame() {
     return structuredClone({
-      schema: SAVE_SCHEMA,
+      schema: import_model2.SAVE_SCHEMA,
       content: this.internals.bundle.content,
-      ...this.internals.ownsRegistry ? { registry: this.internals.registry.save() } : {},
+      ...this.internals.ownsRegistry ? { registry: this.registrySection() } : {},
       shared: { spent: [...this.spent].sort() },
       flows: Object.fromEntries([...this.flowsById].map(([id, flow]) => [id, flow.snapshot(false)]))
     });
   }
+  /** The registry's values in CANONICAL order, the order a load rebuilds them
+   *  in: the engine-wide keys as the constructor registered them, then each
+   *  flow's keys in `flows()` order (each flow's own registration order), then
+   *  anything else the registry holds (values still waiting for a key), as the
+   *  registry lists it. The registry itself lists keys in registration order,
+   *  and a flow replaced in place (`open()` above keeps its slot in
+   *  `flowsById`) re-registers its keys at the END, so `openFlow("a");
+   *  openFlow("b"); openFlow("a")` saved b's keys before a's while a load
+   *  rebuilt a's first: the same run, different `.storyletsave` bytes, and a
+   *  save loaded and saved again no longer equal to itself. It is the
+   *  2026-08-29 rule carried into the section save@2 moved the per-flow values
+   *  to (2026-10-01). Order does not matter on READ (`partitionsFromSections`
+   *  sorts by key shape), so a save written in the old order loads as before. */
+  registrySection() {
+    const all = this.internals.registry.save();
+    const out = {};
+    const take = (key) => {
+      if (Object.prototype.hasOwnProperty.call(all, key) && !Object.prototype.hasOwnProperty.call(out, key)) out[key] = all[key];
+    };
+    for (const { key } of this.sharedMounts) take(key);
+    for (const flow of this.flowsById.values()) for (const key of flow.registeredKeys()) take(key);
+    for (const key of Object.keys(all)) take(key);
+    return out;
+  }
   /** 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
@@ -1798,11 +978,11 @@ var Engine = class _Engine {
    *  previewLoad and loadGame share it. */
   planLoad(envelope) {
     const schema = envelope.schema;
-    if (schema !== SAVE_SCHEMA && schema !== SAVE_SCHEMA_V1) throw new Error(`unsupported save schema: ${String(schema)}`);
+    if (schema !== import_model2.SAVE_SCHEMA && schema !== import_model2.SAVE_SCHEMA_V1) throw new Error(`unsupported save schema: ${String(schema)}`);
     const draft = emptyDraft();
     const flowIds = new Set(Object.keys(envelope.flows ?? {}));
     let moved;
-    if (envelope.schema === SAVE_SCHEMA_V1) {
+    if (envelope.schema === import_model2.SAVE_SCHEMA_V1) {
       moved = {
         shared: envelope.shared?.props ?? emptyPartitionValues(),
         flows: new Map(Object.entries(envelope.flows ?? {}).map(([id, f]) => [id, f.props ?? emptyPartitionValues()])),
@@ -1852,7 +1032,7 @@ var Engine = class _Engine {
     }
     const cardName = (cardId) => {
       const entry = internals.cardsById.get(cardId);
-      return entry ? effectiveGameId(entry.card) : cardId;
+      return entry ? (0, import_model.effectiveGameId)(entry.card) : cardId;
     };
     const board = {};
     const restored = /* @__PURE__ */ new Map();
@@ -1864,7 +1044,7 @@ var Engine = class _Engine {
         }
         continue;
       }
-      const hand = effectiveGameId(known.hand);
+      const hand = (0, import_model.effectiveGameId)(known.hand);
       const kept = [];
       for (const cardId of ids) {
         const entry = internals.cardsById.get(cardId);
@@ -1875,7 +1055,7 @@ var Engine = class _Engine {
         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" });
+            draft.evicted.push({ flow: id, hand, card: (0, import_model.effectiveGameId)(entry.card), reason: "claimed-elsewhere" });
             continue;
           }
           restored.set(cardId, (restored.get(cardId) ?? 0) + 1);
@@ -1949,7 +1129,7 @@ var Flow = class {
     this.engine = engine;
     this.internals = internals;
     this.id = id;
-    this.prng = makePrng(seed);
+    this.prng = (0, import_expr.makePrng)(seed);
     this.stores = buildPartition(internals, flowHalf);
     const put = (key, bag) => {
       if (bag.declarations().length === 0) return;
@@ -2050,7 +1230,7 @@ var Flow = class {
   node(expr) {
     let node = this.internals.nodeCache.get(expr);
     if (!node) {
-      node = deserialiseAst(expr.ast);
+      node = (0, import_expr2.deserialiseAst)(expr.ast);
       this.internals.nodeCache.set(expr, node);
     }
     return node;
@@ -2058,9 +1238,16 @@ var Flow = class {
   /** Tag group names are box-scoped: two boxes may name a group the same way
    *  (schema 1 - boxes namespace their groups), so a name is only ever
    *  resolved inside the box being asked, never bundle-wide. Ids are
-   *  project-unique and accepted here too, still confined to the box. */
+   *  project-unique and accepted here too, still confined to the box.
+   *
+   *  A box on the project map sees ONE namespace: its own groups, then the
+   *  map's group (design/project-map-contract.md 3.1). A box that has not
+   *  opted in does not see the map's name at all, so a peek naming it there
+   *  is the ordinary unknown-group refusal. Own groups first is stated for
+   *  determinism only: a bundle that loads never has the two share a name. */
   groupInBox(box, ref) {
-    return box.tagGroups.find((g) => effectiveGameId(g) === ref) ?? box.tagGroups.find((g) => g.id === ref);
+    const groups = (0, import_model.groupsOfBox)(this.internals.bundle, box);
+    return groups.find((g) => (0, import_model.effectiveGameId)(g) === ref) ?? groups.find((g) => g.id === ref);
   }
   /** Fold one play into the indexes. O(the card's tags), not O(the log). */
   indexPlay(record) {
@@ -2070,7 +1257,7 @@ var Flow = class {
     if (!entry) return;
     for (const [groupId, tagIds] of Object.entries(entry.card.tags ?? {})) {
       for (const tagId of tagIds) {
-        const key = tagKey(groupId, tagId);
+        const key = tagKey(entry.box.id, groupId, tagId);
         this.tagPlayCount.set(key, (this.tagPlayCount.get(key) ?? 0) + 1);
         this.lastPlayInTag.set(key, record);
       }
@@ -2086,8 +1273,10 @@ var Flow = class {
     for (const record of this.playLog) this.indexPlay(record);
   }
   /** `box` is the box whose ask is being evaluated: the play-history
-   *  functions take a bare group name, so it resolves there (a card's tags
-   *  reference its own box's group, which keeps the counts box-local).
+   *  functions take a bare group name, so it resolves there, and they count
+   *  only that box's own plays (the box is in the index key). That was
+   *  automatic while every group was a box's; a project-map zone is shared,
+   *  and its history is still not (design/project-map-contract.md 3.7, D7).
    *  History is THIS flow's: countPlayed answers "have I done this". */
   /** One host per box, built once.
    *
@@ -2112,11 +1301,11 @@ var Flow = class {
     const keyOf = (group, tag) => {
       const found = this.groupInBox(box, group);
       const t = found?.tags.find((v) => v.gameId === tag);
-      return found && t ? tagKey(found.id, t.id) : void 0;
+      return found && t ? tagKey(box.id, found.id, t.id) : void 0;
     };
     const since = (record) => {
       const entry = this.internals.cardsByGameId.get(record.card);
-      if (!entry) return NEVER_PLAYED;
+      if (!entry) return import_dialect.NEVER_PLAYED;
       return (this.turnCounts.get(entry.box.id) ?? 0) - record.turn;
     };
     return {
@@ -2124,7 +1313,7 @@ var Flow = class {
       countPlayed: (card) => this.playCount.get(card) ?? 0,
       turnsSincePlayed: (card) => {
         const last = this.lastPlayOf.get(card);
-        return last ? since(last) : NEVER_PLAYED;
+        return last ? since(last) : import_dialect.NEVER_PLAYED;
       },
       countPlayedIn: (group, tag) => {
         const key = keyOf(group, tag);
@@ -2133,7 +1322,7 @@ var Flow = class {
       turnsSincePlayedIn: (group, tag) => {
         const key = keyOf(group, tag);
         const last = key === void 0 ? void 0 : this.lastPlayInTag.get(key);
-        return last ? since(last) : NEVER_PLAYED;
+        return last ? since(last) : import_dialect.NEVER_PLAYED;
       }
     };
   }
@@ -2172,7 +1361,7 @@ var Flow = class {
     return source.kind === "value" ? this.internals.ladders.value.get(source.id)?.get(name) : source.kind === "hand" ? this.internals.ladders.hand.get(source.id)?.get(name) : void 0;
   }
   eval(expr, ctx) {
-    return evaluate(this.node(expr), ctx, storyletsDialect);
+    return (0, import_expr2.evaluate)(this.node(expr), ctx, import_dialect.storyletsDialect);
   }
   passes(expr, ctx, where) {
     if (!expr) return true;
@@ -2197,35 +1386,35 @@ var Flow = class {
     let condition;
     if (hand.template !== void 0) {
       const template = this.internals.templatesById.get(hand.template);
-      if (!template) throw new Error(`hand "${effectiveGameId(hand)}": unknown template "${hand.template}"`);
+      if (!template) throw new Error(`hand "${(0, import_model.effectiveGameId)(hand)}": unknown template "${hand.template}"`);
       for (const [groupId, tagId] of Object.entries(template.bindings ?? {})) {
         boundTags.set(groupId, tagId);
       }
       for (const [groupId, tagId] of Object.entries(hand.chosen ?? {})) {
-        if (isHoleRef(tagId)) {
+        if ((0, import_model.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);
-        if (found && tag) askNames[effectiveGameId(found.group)] = effectiveGameId(tag);
+        if (found && tag) askNames[(0, import_model.effectiveGameId)(found.group)] = (0, import_model.effectiveGameId)(tag);
       }
       condition = template.condition;
     } else {
       for (const [groupId, tagId] of Object.entries(hand.rule?.bindings ?? {})) {
-        if (isHoleRef(tagId)) {
+        if ((0, import_model.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);
-        if (found && tag) askNames[effectiveGameId(found.group)] = effectiveGameId(tag);
+        if (found && tag) askNames[(0, import_model.effectiveGameId)(found.group)] = (0, import_model.effectiveGameId)(tag);
       }
       condition = hand.rule?.condition;
     }
-    boundTags.set(PLACE_GROUP, hand.id);
+    boundTags.set(import_model.PLACE_GROUP, hand.id);
     this.bindStateGroups(box, boundTags, askNames);
     return { box, hand, ...condition !== void 0 ? { condition } : {}, boundTags, askNames };
   }
@@ -2235,20 +1424,20 @@ var Flow = class {
     const boundTags = /* @__PURE__ */ new Map();
     const askNames = {};
     for (const [groupRef, tagRef] of Object.entries(criteria)) {
-      if (groupRef === PLACE_GROUP) {
+      if (groupRef === import_model.PLACE_GROUP) {
         const hand = this.internals.handsByGameId.get(tagRef) ?? this.internals.handsById.get(tagRef);
         if (!hand) throw new Error(`peek: unknown hand "${tagRef}" in home criteria`);
-        boundTags.set(PLACE_GROUP, hand.hand.id);
+        boundTags.set(import_model.PLACE_GROUP, hand.hand.id);
         continue;
       }
       const found = this.groupInBox(box, groupRef);
       if (!found) {
-        throw new Error(`peek: unknown tag group "${groupRef}" in box "${effectiveGameId(box)}"`);
+        throw new Error(`peek: unknown tag group "${groupRef}" in box "${(0, import_model.effectiveGameId)(box)}"`);
       }
       const tag = this.tagByGameId(found, tagRef) ?? found.tags.find((t) => t.id === tagRef);
-      if (!tag) throw new Error(`peek: unknown tag "${tagRef}" in group "${effectiveGameId(found)}"`);
+      if (!tag) throw new Error(`peek: unknown tag "${tagRef}" in group "${(0, import_model.effectiveGameId)(found)}"`);
       boundTags.set(found.id, tag.id);
-      askNames[effectiveGameId(found)] = effectiveGameId(tag);
+      askNames[(0, import_model.effectiveGameId)(found)] = (0, import_model.effectiveGameId)(tag);
     }
     this.bindStateGroups(box, boundTags, askNames);
     return { box, boundTags, askNames };
@@ -2271,9 +1460,9 @@ var Flow = class {
    */
   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);
+    const groupName = found ? (0, import_model.effectiveGameId)(found.group) : groupId;
+    const where = `hand ${(0, import_model.effectiveGameId)(hand)}, tag group ${groupName}`;
+    const parsed = (0, import_model.parseHoleRef)(ref);
     if (!parsed) {
       this.emit({ type: "diagnostic", where, message: `"${ref}" is not a @hand, @world or @story property reference` });
       return;
@@ -2297,13 +1486,13 @@ var Flow = class {
       return;
     }
     const wanted = typeof value === "string" ? value : String(value);
-    const tag = found.group.tags.find((t) => effectiveGameId(t) === wanted);
+    const tag = found.group.tags.find((t) => (0, import_model.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);
+    askNames[groupName] = (0, import_model.effectiveGameId)(tag);
   }
   /**
    * Bind every `boundBy` group in the box from the property it names.
@@ -2319,28 +1508,28 @@ var Flow = class {
    * is what says otherwise.
    */
   bindStateGroups(box, boundTags, askNames) {
-    for (const group of box.tagGroups) {
+    for (const group of (0, import_model.groupsOfBox)(this.internals.bundle, box)) {
       if (group.boundBy === void 0 || boundTags.has(group.id)) continue;
       const ref = /^@(world|story)\.([a-z][a-z0-9_-]*)$/.exec(group.boundBy);
       if (!ref) {
-        this.emit({ type: "diagnostic", where: `tag group ${effectiveGameId(group)}`, message: `boundBy "${group.boundBy}" is not a @world or @story property reference` });
+        this.emit({ type: "diagnostic", where: `tag group ${(0, import_model.effectiveGameId)(group)}`, message: `boundBy "${group.boundBy}" is not a @world or @story property reference` });
         continue;
       }
       let value;
       try {
         value = this.getProperty(`${ref[1]}.${ref[2]}`);
       } catch {
-        this.emit({ type: "diagnostic", where: `tag group ${effectiveGameId(group)}`, message: `boundBy "${group.boundBy}" names a property that is not declared` });
+        this.emit({ type: "diagnostic", where: `tag group ${(0, import_model.effectiveGameId)(group)}`, message: `boundBy "${group.boundBy}" names a property that is not declared` });
         continue;
       }
       const wanted = typeof value === "string" ? value : String(value);
-      const tag = group.tags.find((t) => effectiveGameId(t) === wanted);
+      const tag = group.tags.find((t) => (0, import_model.effectiveGameId)(t) === wanted);
       if (!tag) {
-        this.emit({ type: "diagnostic", where: `tag group ${effectiveGameId(group)}`, message: `${group.boundBy} is "${wanted}", which is not one of its tags` });
+        this.emit({ type: "diagnostic", where: `tag group ${(0, import_model.effectiveGameId)(group)}`, message: `${group.boundBy} is "${wanted}", which is not one of its tags` });
         continue;
       }
       boundTags.set(group.id, tag.id);
-      askNames[effectiveGameId(group)] = effectiveGameId(tag);
+      askNames[(0, import_model.effectiveGameId)(group)] = (0, import_model.effectiveGameId)(tag);
     }
   }
   // --- @hand composition (schema 3.6) -------------------------------------------
@@ -2357,7 +1546,7 @@ var Flow = class {
     const bag = {};
     const sources = /* @__PURE__ */ new Map();
     for (const [groupId, tagId] of ask.boundTags) {
-      if (groupId === PLACE_GROUP) continue;
+      if (groupId === import_model.PLACE_GROUP) continue;
       for (const [name, value] of Object.entries(this.valuesOf("value", tagId))) {
         bag[name] = value;
         sources.set(name, { kind: "value", id: tagId });
@@ -2412,13 +1601,13 @@ var Flow = class {
    *  the bound tag or omits the group (wildcard); the home group inverts -
    *  a homed card requires a matching home binding (schema 2.4). */
   tagsMatch(card, boundTags) {
-    const home = card.tags?.[PLACE_GROUP];
+    const home = card.tags?.[import_model.PLACE_GROUP];
     if (home !== void 0 && home.length > 0) {
-      const bound = boundTags.get(PLACE_GROUP);
+      const bound = boundTags.get(import_model.PLACE_GROUP);
       if (bound === void 0 || !home.includes(bound)) return false;
     }
     for (const [groupId, tagId] of boundTags) {
-      if (groupId === PLACE_GROUP) continue;
+      if (groupId === import_model.PLACE_GROUP) continue;
       const tags = card.tags?.[groupId];
       if (tags === void 0) {
         if (this.internals.requiredGroups.has(groupId)) return false;
@@ -2436,9 +1625,9 @@ var Flow = class {
     const { box } = ask;
     const handEnv = this.buildHandEnv(ask);
     const verdict = (card, v) => {
-      trace?.push({ id: effectiveGameId(card), verdict: v });
+      trace?.push({ id: (0, import_model.effectiveGameId)(card), verdict: v });
     };
-    if (!this.passes(ask.condition, this.evalCtx(box, void 0, handEnv), `hand ${ask.hand ? effectiveGameId(ask.hand) : ""} condition`)) {
+    if (!this.passes(ask.condition, this.evalCtx(box, void 0, handEnv), `hand ${ask.hand ? (0, import_model.effectiveGameId)(ask.hand) : ""} condition`)) {
       return { ordered: [], handEnv };
     }
     const gateOk = /* @__PURE__ */ new Map();
@@ -2503,9 +1692,9 @@ var Flow = class {
         let spec = 0;
         if (box.ranking.specificity && card.condition) {
           const node = this.node(card.condition);
-          spec = matchedSpecificity(node, (n) => {
+          spec = (0, import_expr_specificity.matchedSpecificity)(node, (n) => {
             try {
-              return conditionPasses(evaluate(n, deckCtx, storyletsDialect));
+              return conditionPasses((0, import_expr2.evaluate)(n, deckCtx, import_dialect.storyletsDialect));
             } catch {
               return false;
             }
@@ -2521,13 +1710,13 @@ var Flow = class {
       while (j < scored.length && scored[j].priority === scored[i].priority && scored[j].spec === scored[i].spec) j++;
       if (j - i > 1) {
         const run = scored.slice(i, j);
-        shuffleInPlace(run, this.prng);
+        (0, import_expr.shuffleInPlace)(run, this.prng);
         for (let k = 0; k < run.length; k++) scored[i + k] = run[k];
       }
       i = j;
     }
     for (const s of scored) {
-      trace?.push({ id: effectiveGameId(s.entry.card), verdict: "dealt", priority: s.priority, specificity: s.spec });
+      trace?.push({ id: (0, import_model.effectiveGameId)(s.entry.card), verdict: "dealt", priority: s.priority, specificity: s.spec });
     }
     return { ordered: scored.map((s) => s.entry), handEnv };
   }
@@ -2543,7 +1732,7 @@ var Flow = class {
     const { card } = entry;
     return {
       id: card.id,
-      gameId: effectiveGameId(card),
+      gameId: (0, import_model.effectiveGameId)(card),
       ...card.title !== void 0 ? { title: card.title } : {},
       ...card.purpose !== void 0 ? { purpose: card.purpose } : {},
       ...card.fields !== void 0 ? { fields: card.fields } : {}
@@ -2574,16 +1763,16 @@ 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) => effectiveGameId(e.card))));
-      this.emit({ type: "peek", box: effectiveGameId(box), criteria, cards: trace }, this.turnCounts.get(box.id) ?? 0);
+      this.capTrace(trace, new Set(listed.map((e) => (0, import_model.effectiveGameId)(e.card))));
+      this.emit({ type: "peek", box: (0, import_model.effectiveGameId)(box), criteria, cards: trace }, this.turnCounts.get(box.id) ?? 0);
     }
-    return { box: effectiveGameId(box), cards: listed.map((e) => this.view(e)) };
+    return { box: (0, import_model.effectiveGameId)(box), cards: listed.map((e) => this.view(e)) };
   }
   /** Refresh one hand (schema 3.5); returns its new shape. */
   deal(handRef) {
     this.assertOpen();
     const { hand } = this.resolveHand(handRef);
-    return this.dealMany([handRef])[effectiveGameId(hand)] ?? [];
+    return this.dealMany([handRef])[(0, import_model.effectiveGameId)(hand)] ?? [];
   }
   /** Re-deal several / all hands (schema 3.5): seeded hand-order shuffle
    *  (fairness), evict, seed the ledger from survivors, fill in order.
@@ -2592,7 +1781,7 @@ var Flow = class {
   dealMany(handRefs) {
     this.assertOpen();
     const dealt = (handRefs ?? [...this.internals.handsById.keys()].sort()).map((ref) => this.resolveHand(ref));
-    shuffleInPlace(dealt, this.prng);
+    (0, import_expr.shuffleInPlace)(dealt, this.prng);
     for (const { hand, box } of dealt) {
       const ask = this.askForHand(hand, box);
       const handEnv = this.buildHandEnv(ask);
@@ -2605,7 +1794,7 @@ var Flow = class {
       const evicted = [];
       const evict = (cardId, reason) => {
         const known = this.internals.cardsById.get(cardId);
-        evicted.push({ card: known ? effectiveGameId(known.card) : cardId, reason });
+        evicted.push({ card: known ? (0, import_model.effectiveGameId)(known.card) : cardId, reason });
         return false;
       };
       const survivors = (this.boardContents.get(hand.id) ?? []).filter((cardId) => {
@@ -2622,7 +1811,7 @@ var Flow = class {
       });
       this.boardContents.set(hand.id, survivors);
       if (this.tracing) {
-        for (const e of evicted) this.emit({ type: "evict", hand: effectiveGameId(hand), card: e.card, reason: e.reason }, turn);
+        for (const e of evicted) this.emit({ type: "evict", hand: (0, import_model.effectiveGameId)(hand), card: e.card, reason: e.reason }, turn);
       }
     }
     const claimCounts = this.claims();
@@ -2647,12 +1836,12 @@ var Flow = class {
         worldClaims.set(id, (worldClaims.get(id) ?? 0) + 1);
       }
       if (trace) {
-        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);
+        this.capTrace(trace, new Set(taking.map((e) => (0, import_model.effectiveGameId)(e.card))));
+        this.emit({ type: "deal", hand: (0, import_model.effectiveGameId)(hand), cards: trace }, this.turnCounts.get(box.id) ?? 0);
       }
     }
     return Object.fromEntries(dealt.map(({ hand }) => [
-      effectiveGameId(hand),
+      (0, import_model.effectiveGameId)(hand),
       (this.boardContents.get(hand.id) ?? []).map((id) => this.view(this.internals.cardsById.get(id)))
     ]));
   }
@@ -2674,7 +1863,7 @@ var Flow = class {
       keep = box.id;
     }
     return Object.fromEntries([...this.boardContents.entries()].filter(([handId]) => keep === void 0 || this.internals.handsById.get(handId).box.id === keep).map(([handId, ids]) => [
-      effectiveGameId(this.internals.handsById.get(handId).hand),
+      (0, import_model.effectiveGameId)(this.internals.handsById.get(handId).hand),
       ids.map((id) => this.view(this.internals.cardsById.get(id)))
     ]));
   }
@@ -2684,7 +1873,7 @@ var Flow = class {
     if (!entry) throw new Error(`unknown card "${cardId}"`);
     const { hand, box } = this.resolveHand(handRef);
     if (!(this.boardContents.get(hand.id) ?? []).includes(entry.card.id)) {
-      throw new Error(`card "${effectiveGameId(entry.card)}" is not dealt to hand "${effectiveGameId(hand)}"`);
+      throw new Error(`card "${(0, import_model.effectiveGameId)(entry.card)}" is not dealt to hand "${(0, import_model.effectiveGameId)(hand)}"`);
     }
     return { entry, ask: this.askForHand(hand, box) };
   }
@@ -2696,7 +1885,7 @@ var Flow = class {
     const ctx = this.evalCtx(entry.box, entry.deck, this.buildHandEnv(ask));
     return entry.card.outcomes.map((o) => ({
       id: o.id,
-      gameId: effectiveGameId(o),
+      gameId: (0, import_model.effectiveGameId)(o),
       ...o.title !== void 0 ? { title: o.title } : {},
       ...o.purpose !== void 0 ? { purpose: o.purpose } : {},
       ...o.fields !== void 0 ? { fields: o.fields } : {},
@@ -2720,14 +1909,14 @@ var Flow = class {
     const { entry, ask } = this.resolveDealt(cardId, from);
     const bare = outcomeGameId === "";
     if (bare && entry.card.outcomes.length > 0) {
-      throw new Error(`card "${effectiveGameId(entry.card)}" has outcomes (${entry.card.outcomes.map((o) => effectiveGameId(o)).join(", ")}); name the one played`);
+      throw new Error(`card "${(0, import_model.effectiveGameId)(entry.card)}" has outcomes (${entry.card.outcomes.map((o) => (0, import_model.effectiveGameId)(o)).join(", ")}); name the one played`);
     }
-    const outcome = bare ? void 0 : entry.card.outcomes.find((o) => effectiveGameId(o) === outcomeGameId);
-    if (!bare && !outcome) throw new Error(`card "${effectiveGameId(entry.card)}" has no outcome "${outcomeGameId}"`);
+    const outcome = bare ? void 0 : entry.card.outcomes.find((o) => (0, import_model.effectiveGameId)(o) === outcomeGameId);
+    if (!bare && !outcome) throw new Error(`card "${(0, import_model.effectiveGameId)(entry.card)}" has no outcome "${outcomeGameId}"`);
     const handEnv = this.buildHandEnv(ask);
     const ctx = this.evalCtx(entry.box, entry.deck, handEnv);
     if (outcome && !this.passes(outcome.condition, ctx)) {
-      throw new Error(`outcome "${outcomeGameId}" on "${effectiveGameId(entry.card)}" is gated shut`);
+      throw new Error(`outcome "${outcomeGameId}" on "${(0, import_model.effectiveGameId)(entry.card)}" is gated shut`);
     }
     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);
@@ -2739,8 +1928,8 @@ var Flow = class {
       const { path, prev } = this.applyWrite(target, value, entry, handEnv);
       if (this.tracing) this.emit({ type: "write", target, path, value, ...prev !== void 0 ? { prev } : {} }, newTurn);
     }
-    const outcomeId = outcome ? effectiveGameId(outcome) : "";
-    const record = { card: effectiveGameId(entry.card), outcome: outcomeId, turn: newTurn };
+    const outcomeId = outcome ? (0, import_model.effectiveGameId)(outcome) : "";
+    const record = { card: (0, import_model.effectiveGameId)(entry.card), outcome: outcomeId, turn: newTurn };
     this.playLog.push(record);
     this.indexPlay(record);
     if (entry.card.redraw === "never") {
@@ -2755,7 +1944,7 @@ 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: effectiveGameId(entry.card), outcome: outcomeId, turn: newTurn }, newTurn);
+    if (this.tracing) this.emit({ type: "play", card: (0, import_model.effectiveGameId)(entry.card), outcome: outcomeId, turn: newTurn }, newTurn);
   }
   /** One owned property's address, owner segment and all (4.4). */
   address(kind, id) {
@@ -2820,7 +2009,7 @@ var Flow = class {
     if (!box) throw new Error(`unknown box "${boxRef}"`);
     const next = (this.turnCounts.get(box.id) ?? 0) + n;
     this.turnCounts.set(box.id, next);
-    if (this.tracing) this.emit({ type: "turns", box: effectiveGameId(box), turn: next }, next);
+    if (this.tracing) this.emit({ type: "turns", box: (0, import_model.effectiveGameId)(box), turn: next }, next);
   }
   // --- state access (host surface + test tooling) ---------------------------------
   /** Every box, bundle order: identity + this flow's clock (the enumeration
@@ -2829,7 +2018,7 @@ var Flow = class {
     this.assertOpen();
     return this.internals.bundle.boxes.map((b) => ({
       id: b.id,
-      gameId: effectiveGameId(b),
+      gameId: (0, import_model.effectiveGameId)(b),
       ...b.title !== void 0 ? { title: b.title } : {},
       turn: this.turnCounts.get(b.id) ?? 0
     }));
@@ -2966,7 +2155,7 @@ var Flow = class {
     for (const [boxId, turn] of Object.entries(saved.turns ?? {})) {
       if (this.turnCounts.has(boxId)) this.turnCounts.set(boxId, turn);
     }
-    this.prng = makePrng(saved.prng);
+    this.prng = (0, import_expr.makePrng)(saved.prng);
     this.cooldowns = saved.cooldowns ?? {};
     this.playLog = saved.playLog ?? [];
     this.rebuildPlayIndex();
@@ -2978,6 +2167,7 @@ var Flow = class {
 };
 
 // src/describe.ts
+var import_model3 = require("@storylet-studio/model");
 var summarise = (decls) => decls.map((d) => ({
   name: d.name,
   type: d.type,
@@ -2993,14 +2183,14 @@ var handDecls = (hand, box) => {
   }
   return hand.properties ?? [];
 };
-var movableHoles = (hand, box) => {
+var movableHoles = (bundle, 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 (!(0, import_model3.isHoleRef)(value)) continue;
+    const group = (0, import_model3.groupsOfBox)(bundle, box).find((g) => g.id === groupId);
     if (group === void 0) continue;
-    out.push({ group: effectiveGameId(group), from: value });
+    out.push({ group: (0, import_model3.effectiveGameId)(group), from: value });
   }
   return out;
 };
@@ -3018,17 +2208,18 @@ function describeBundle(bundle) {
   ];
   const totals = { boxes: 0, decks: 0, cards: 0, hands: 0, templates: 0, tagGroups: 0 };
   for (const box of bundle.boxes) {
-    const boxGameId = effectiveGameId(box);
+    const boxGameId = (0, import_model3.effectiveGameId)(box);
     const cards = box.decks.reduce((n, deck) => n + deck.cards.length, 0);
     boxes.push({
       gameId: boxGameId,
       ...box.title !== void 0 ? { title: box.title } : {},
+      ...box.usesMap === true ? { usesMap: true } : {},
       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))
+        gameId: (0, import_model3.effectiveGameId)(group),
+        tags: group.tags.map((tag) => (0, import_model3.effectiveGameId)(tag))
       })),
       counts: {
         decks: box.decks.length,
@@ -3046,13 +2237,13 @@ 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);
+      const movable = movableHoles(bundle, hand, box);
       hands.push({
-        gameId: effectiveGameId(hand),
+        gameId: (0, import_model3.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: (0, import_model3.effectiveGameId)(template) } : {},
         ...movable.length > 0 ? { movable } : {}
       });
     }
@@ -3067,14 +2258,23 @@ function describeBundle(bundle) {
       });
     };
     push("box", boxGameId, box.properties);
-    for (const deck of box.decks) push("deck", effectiveGameId(deck), deck.properties);
-    for (const hand of box.hands) push("hand", effectiveGameId(hand), handDecls(hand, box));
+    for (const deck of box.decks) push("deck", (0, import_model3.effectiveGameId)(deck), deck.properties);
+    for (const hand of box.hands) push("hand", (0, import_model3.effectiveGameId)(hand), handDecls(hand, box));
     for (const group of box.tagGroups) {
       for (const tag of group.tags) {
-        push("tag", effectiveGameId(tag), tag.properties ?? [], effectiveGameId(group));
+        push("tag", (0, import_model3.effectiveGameId)(tag), tag.properties ?? [], (0, import_model3.effectiveGameId)(group));
       }
     }
   }
+  const map = bundle.map;
+  if (map !== void 0) {
+    const group = (0, import_model3.effectiveGameId)(map.group);
+    for (const tag of map.group.tags) {
+      const decls = tag.properties ?? [];
+      if (decls.length > 0) properties.push({ scope: "tag", owner: (0, import_model3.effectiveGameId)(tag), group, properties: summarise(decls) });
+    }
+    totals.tagGroups += 1;
+  }
   return {
     identity: {
       schema: bundle.schema,
@@ -3087,13 +2287,16 @@ function describeBundle(bundle) {
     boxes,
     hands,
     properties,
-    maps: (bundle.maps ?? []).map((map) => ({
-      box: map.box,
-      group: map.group,
-      zones: map.zones.length,
-      backgrounds: map.backgrounds?.length ?? 0,
-      sites: map.sites?.length ?? 0
-    }))
+    ...map !== void 0 ? {
+      map: {
+        group: (0, import_model3.effectiveGameId)(map.group),
+        tags: map.group.tags.map((tag) => (0, import_model3.effectiveGameId)(tag)),
+        boxes: bundle.boxes.filter((box) => box.usesMap === true).map((box) => (0, import_model3.effectiveGameId)(box)),
+        zones: map.geometry?.zones.length ?? 0,
+        backgrounds: map.geometry?.backgrounds?.length ?? 0,
+        sites: Object.fromEntries(Object.entries(map.geometry?.sites ?? {}).map(([box, sites]) => [box, sites.length]))
+      }
+    } : {}
   };
 }
 // Annotate the CommonJS export names for ESM import in node: