@storylet-studio/play-helpers 0.14.0 → 0.15.0

package/dist/index.d.cts

@@ -1,7 +1,7 @@
 import { Engine, Flow, LogEntry, EngineLogEntry, BundleDescription, PropertySummary, PropertyScopeSummary, TraceEvent, EngineOptions } from '@storylet-studio/runtime';
-import { StateLoggerOptions, StateLogger, StateSnapshot, PropertyBag as PropertyBag$1 } from '@wildwinter/scoperegistry';
+import { StateLoggerOptions, StateLogger, StateSnapshot, PropertyBag } from '@wildwinter/scoperegistry';
 export { StateChange, StateLogger, StateLoggerAdapter, StateLoggerOptions, StateSnapshot, createStateLogger as createKernelStateLogger, diffState } from '@wildwinter/scoperegistry';
-import { LoadReport, PropertyBag, SaveFile, Bundle } from '@storylet-studio/model';
+import { PropertyBag as PropertyBag$1, Bundle, LoadReport, SaveFile } from '@storylet-studio/model';
 import { ScopeResolver } from '@wildwinter/expr';
 
 /** The full flattened snapshot of ONE FLOW's view - the shared partitions
@@ -24,9 +24,48 @@ declare function snapshotState(engine: Engine, flow: Flow): StateSnapshot;
  *  world container's bag through createKernelStateLogger itself. */
 declare function createStateLogger(engine: Engine, flow: Flow, opts?: StateLoggerOptions): StateLogger;
 
+interface WorldContainer {
+    /** Pass as `new Engine(bundle, { hostScopes: { world: container.resolver } })`. */
+    resolver: ScopeResolver;
+    /** The kernel bag itself (subscribe, audit, rows live there) - mount it
+     *  into a state logger or examiner beside the engine's own bags. Writing it
+     *  DIRECTLY is writing the kernel, so a `writable: false` declaration asks
+     *  the kernel's question: pass `{ host: true }` to say the game is speaking
+     *  (`bag.set(name, value, { host: true })`). Through `resolver` or an
+     *  engine's setProperty that is already answered. */
+    bag: PropertyBag;
+    /** The current values, for saving beside the engine's envelope. */
+    values(): PropertyBag$1;
+    /** Restore saved values over fresh defaults: orphaned keys drop, new
+     *  declarations keep their defaults - the same drift rule as loadGame. */
+    load(values: PropertyBag$1): void;
+}
+/** A container seeded from one host scope's declarations in the bundle:
+ *  `@world`'s unless `token` names another (`"player"`).
+ *
+ *  The container is the GAME's state, so it WRITES - even a declaration
+ *  carrying `writable: false`. That flag is the STORY's promise not to write
+ *  the value (Reboot.md 10), and the engine keeps it where the story writes: an
+ *  outcome is refused against the engine's read-only table before it ever
+ *  reaches this resolver. Enforcing it here as well refused the HOST too - the
+ *  clock the game must move, the harness driving the value it is testing
+ *  against - which is the opposite of what the flag says.
+ *
+ *  So the declarations are seeded AS DECLARED, which is what an examiner over
+ *  this container should read, and the writes go through as HOST writes
+ *  (scoperegistry 0.6.0's `{ host: true }`). The resolver's `set` is the
+ *  engine's own doorway and passes the flag too: the engine has already sorted
+ *  story from host by then - a story write was refused earlier, a host write is
+ *  the only kind that arrives - and a resolver takes a name and a value with no
+ *  room to say which. A game wanting a rule of its own binds its own resolver
+ *  rather than this one; the ports' container (Unreal's UStoryletWorld) draws
+ *  the same line, with HostSet never refused and StorySet asking the game's own
+ *  read-only list. */
+declare function createWorldContainer(bundle: Bundle, token?: string): WorldContainer;
+
 /** The current engine state (and the host's @world values, if given) as
  *  pretty-printed .storyletsave JSON. */
-declare function serializeState(engine: Engine, world?: PropertyBag): string;
+declare function serializeState(engine: Engine, world?: PropertyBag$1): string;
 /**
  * Capture the whole engine (and the host's @world values, if it keeps any) as
  * the tagged save-file OBJECT.
@@ -40,7 +79,7 @@ declare function serializeState(engine: Engine, world?: PropertyBag): string;
  * things across the four Storylets runtimes, and neither matched the family.
  * Godot and Unreal already had Patter's shape; these two were brought to it.
  */
-declare function saveState(engine: Engine, world?: PropertyBag): SaveFile;
+declare function saveState(engine: Engine, world?: PropertyBag$1): SaveFile;
 /** What a load may be told to do besides restoring. */
 interface LoadStateOptions {
     /** Handed the engine's LoadReport for this file as the load happens: what
@@ -49,6 +88,13 @@ interface LoadStateOptions {
      *  `engine.previewLoad` return. A callback rather than a return value
      *  because these functions already return the file's @world values. */
     onReport?: (report: LoadReport) => void;
+    /** The host's @world container (`createWorldContainer`, or anything with
+     *  the same `values` and `load`). Given, the file's @world values go into it
+     *  BEFORE the engine loads, so the load's check of each held card reads the
+     *  saved world rather than the one the game had; a refused load puts the
+     *  container back as it was. Without it the values are only returned, and
+     *  the game must apply them before loading for the same check. */
+    world?: Pick<WorldContainer, "values" | "load">;
 }
 /** Restore a {@link saveState} file into an engine. EVERY FLOW IS REBUILT, so
  *  the Flow handles you held before are inert: re-take them with
@@ -57,13 +103,14 @@ interface LoadStateOptions {
  *  the failure lands later, as `play()` refusing a card as "not dealt". (The
  *  engine's `onReplacedFlow` hook reports exactly this.) Throws on a foreign or malformed
  *  file, and the runtime's own project check still applies. Returns the file's
- *  @world values, if any - the HOST applies them to its container; the engine
+ *  @world values, if any. Pass the host's container as `opts.world` and they
+ *  are applied before the load (see LoadStateOptions.world); the engine itself
  *  never touches them. */
-declare function loadState(engine: Engine, file: SaveFile, opts?: LoadStateOptions): PropertyBag | undefined;
+declare function loadState(engine: Engine, file: SaveFile, opts?: LoadStateOptions): PropertyBag$1 | undefined;
 /** Parse + restore a {@link serializeState} string: the TEXT twin of
  *  loadState, as Patterplay pairs them. Throws on malformed JSON, a foreign
  *  file or a project mismatch. Returns the file's @world values for the host. */
-declare function deserializeState(engine: Engine, json: string, opts?: LoadStateOptions): PropertyBag | undefined;
+declare function deserializeState(engine: Engine, json: string, opts?: LoadStateOptions): PropertyBag$1 | undefined;
 
 interface PropertyInspectorOptions {
     /** Mount point; defaults to document.body. */
@@ -103,8 +150,8 @@ interface BundleInspector {
  *  (design/engine-server.md 4.2). Nothing is added for the ordinary
  *  run-scoped property: that is what a property is. */
 declare function formatPropertySummary(p: PropertySummary): string;
-/** The scope label a declaration block files under ("world", "box box",
- *  "tag docks (zone)"). */
+/** The scope label a declaration block files under ("world", "player", "box box",
+ *  "tag docks (zone)"). A host scope is named by its token, as @world is. */
 declare function formatScopeLabel(scope: PropertyScopeSummary): string;
 /** Render a read-only summary of a compiled bundle: what an integrator may
  *  call, with no session and no game running. */
@@ -240,47 +287,9 @@ type LiveBundleResult =
  * the game's registry the old engine hands its keys to the replacement, which a
  * plain save and load into a second engine cannot do (the two would clash).
  *
- * The engine remembers the options it was built with (seed, log, world,
+ * The engine remembers the options it was built with (seed, log, hostScopes,
  * registry), so `opts` is only for overriding one of them for the replacement.
  */
 declare function applyLiveBundle(engine: Engine, bundleJson: string, opts?: EngineOptions): LiveBundleResult;
 
-interface WorldContainer {
-    /** Pass as `new Engine(bundle, { world: container.resolver })`. */
-    resolver: ScopeResolver;
-    /** The kernel bag itself (subscribe, audit, rows live there) - mount it
-     *  into a state logger or examiner beside the engine's own bags. Writing it
-     *  DIRECTLY is writing the kernel, so a `writable: false` declaration asks
-     *  the kernel's question: pass `{ host: true }` to say the game is speaking
-     *  (`bag.set(name, value, { host: true })`). Through `resolver` or an
-     *  engine's setProperty that is already answered. */
-    bag: PropertyBag$1;
-    /** The current values, for saving beside the engine's envelope. */
-    values(): PropertyBag;
-    /** Restore saved values over fresh defaults: orphaned keys drop, new
-     *  declarations keep their defaults - the same drift rule as loadGame. */
-    load(values: PropertyBag): void;
-}
-/** A world container seeded from the bundle's @world declarations.
- *
- *  The container is the GAME's state, so it WRITES - even a declaration
- *  carrying `writable: false`. That flag is the STORY's promise not to write
- *  the value (Reboot.md 10), and the engine keeps it where the story writes: an
- *  outcome is refused against the engine's read-only table before it ever
- *  reaches this resolver. Enforcing it here as well refused the HOST too - the
- *  clock the game must move, the harness driving the value it is testing
- *  against - which is the opposite of what the flag says.
- *
- *  So the declarations are seeded AS DECLARED, which is what an examiner over
- *  this container should read, and the writes go through as HOST writes
- *  (scoperegistry 0.6.0's `{ host: true }`). The resolver's `set` is the
- *  engine's own doorway and passes the flag too: the engine has already sorted
- *  story from host by then - a story write was refused earlier, a host write is
- *  the only kind that arrives - and a resolver takes a name and a value with no
- *  room to say which. A game wanting a rule of its own binds its own resolver
- *  rather than this one; the ports' container (Unreal's UStoryletWorld) draws
- *  the same line, with HostSet never refused and StorySet asking the game's own
- *  read-only list. */
-declare function createWorldContainer(bundle: Bundle): WorldContainer;
-
 export { type BundleInspector, type BundleInspectorOptions, type LiveBundleResult, type LiveFrame, type LiveLink, type LiveLinkOptions, type LiveLinkState, type LiveSocketLike, type LoadStateOptions, type PropertyInspector, type PropertyInspectorOptions, type WorldContainer, applyLiveBundle, boardFrame, createBundleInspector, createLiveLink, createPropertyInspector, createStateLogger, createWorldContainer, deserializeState, ensureInspectorStyle, formatLogEntry, formatPropertySummary, formatScopeLabel, loadState, saveState, serializeState, snapshotState };

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { Engine, Flow, LogEntry, EngineLogEntry, BundleDescription, PropertySummary, PropertyScopeSummary, TraceEvent, EngineOptions } from '@storylet-studio/runtime';
-import { StateLoggerOptions, StateLogger, StateSnapshot, PropertyBag as PropertyBag$1 } from '@wildwinter/scoperegistry';
+import { StateLoggerOptions, StateLogger, StateSnapshot, PropertyBag } from '@wildwinter/scoperegistry';
 export { StateChange, StateLogger, StateLoggerAdapter, StateLoggerOptions, StateSnapshot, createStateLogger as createKernelStateLogger, diffState } from '@wildwinter/scoperegistry';
-import { LoadReport, PropertyBag, SaveFile, Bundle } from '@storylet-studio/model';
+import { PropertyBag as PropertyBag$1, Bundle, LoadReport, SaveFile } from '@storylet-studio/model';
 import { ScopeResolver } from '@wildwinter/expr';
 
 /** The full flattened snapshot of ONE FLOW's view - the shared partitions
@@ -24,9 +24,48 @@ declare function snapshotState(engine: Engine, flow: Flow): StateSnapshot;
  *  world container's bag through createKernelStateLogger itself. */
 declare function createStateLogger(engine: Engine, flow: Flow, opts?: StateLoggerOptions): StateLogger;
 
+interface WorldContainer {
+    /** Pass as `new Engine(bundle, { hostScopes: { world: container.resolver } })`. */
+    resolver: ScopeResolver;
+    /** The kernel bag itself (subscribe, audit, rows live there) - mount it
+     *  into a state logger or examiner beside the engine's own bags. Writing it
+     *  DIRECTLY is writing the kernel, so a `writable: false` declaration asks
+     *  the kernel's question: pass `{ host: true }` to say the game is speaking
+     *  (`bag.set(name, value, { host: true })`). Through `resolver` or an
+     *  engine's setProperty that is already answered. */
+    bag: PropertyBag;
+    /** The current values, for saving beside the engine's envelope. */
+    values(): PropertyBag$1;
+    /** Restore saved values over fresh defaults: orphaned keys drop, new
+     *  declarations keep their defaults - the same drift rule as loadGame. */
+    load(values: PropertyBag$1): void;
+}
+/** A container seeded from one host scope's declarations in the bundle:
+ *  `@world`'s unless `token` names another (`"player"`).
+ *
+ *  The container is the GAME's state, so it WRITES - even a declaration
+ *  carrying `writable: false`. That flag is the STORY's promise not to write
+ *  the value (Reboot.md 10), and the engine keeps it where the story writes: an
+ *  outcome is refused against the engine's read-only table before it ever
+ *  reaches this resolver. Enforcing it here as well refused the HOST too - the
+ *  clock the game must move, the harness driving the value it is testing
+ *  against - which is the opposite of what the flag says.
+ *
+ *  So the declarations are seeded AS DECLARED, which is what an examiner over
+ *  this container should read, and the writes go through as HOST writes
+ *  (scoperegistry 0.6.0's `{ host: true }`). The resolver's `set` is the
+ *  engine's own doorway and passes the flag too: the engine has already sorted
+ *  story from host by then - a story write was refused earlier, a host write is
+ *  the only kind that arrives - and a resolver takes a name and a value with no
+ *  room to say which. A game wanting a rule of its own binds its own resolver
+ *  rather than this one; the ports' container (Unreal's UStoryletWorld) draws
+ *  the same line, with HostSet never refused and StorySet asking the game's own
+ *  read-only list. */
+declare function createWorldContainer(bundle: Bundle, token?: string): WorldContainer;
+
 /** The current engine state (and the host's @world values, if given) as
  *  pretty-printed .storyletsave JSON. */
-declare function serializeState(engine: Engine, world?: PropertyBag): string;
+declare function serializeState(engine: Engine, world?: PropertyBag$1): string;
 /**
  * Capture the whole engine (and the host's @world values, if it keeps any) as
  * the tagged save-file OBJECT.
@@ -40,7 +79,7 @@ declare function serializeState(engine: Engine, world?: PropertyBag): string;
  * things across the four Storylets runtimes, and neither matched the family.
  * Godot and Unreal already had Patter's shape; these two were brought to it.
  */
-declare function saveState(engine: Engine, world?: PropertyBag): SaveFile;
+declare function saveState(engine: Engine, world?: PropertyBag$1): SaveFile;
 /** What a load may be told to do besides restoring. */
 interface LoadStateOptions {
     /** Handed the engine's LoadReport for this file as the load happens: what
@@ -49,6 +88,13 @@ interface LoadStateOptions {
      *  `engine.previewLoad` return. A callback rather than a return value
      *  because these functions already return the file's @world values. */
     onReport?: (report: LoadReport) => void;
+    /** The host's @world container (`createWorldContainer`, or anything with
+     *  the same `values` and `load`). Given, the file's @world values go into it
+     *  BEFORE the engine loads, so the load's check of each held card reads the
+     *  saved world rather than the one the game had; a refused load puts the
+     *  container back as it was. Without it the values are only returned, and
+     *  the game must apply them before loading for the same check. */
+    world?: Pick<WorldContainer, "values" | "load">;
 }
 /** Restore a {@link saveState} file into an engine. EVERY FLOW IS REBUILT, so
  *  the Flow handles you held before are inert: re-take them with
@@ -57,13 +103,14 @@ interface LoadStateOptions {
  *  the failure lands later, as `play()` refusing a card as "not dealt". (The
  *  engine's `onReplacedFlow` hook reports exactly this.) Throws on a foreign or malformed
  *  file, and the runtime's own project check still applies. Returns the file's
- *  @world values, if any - the HOST applies them to its container; the engine
+ *  @world values, if any. Pass the host's container as `opts.world` and they
+ *  are applied before the load (see LoadStateOptions.world); the engine itself
  *  never touches them. */
-declare function loadState(engine: Engine, file: SaveFile, opts?: LoadStateOptions): PropertyBag | undefined;
+declare function loadState(engine: Engine, file: SaveFile, opts?: LoadStateOptions): PropertyBag$1 | undefined;
 /** Parse + restore a {@link serializeState} string: the TEXT twin of
  *  loadState, as Patterplay pairs them. Throws on malformed JSON, a foreign
  *  file or a project mismatch. Returns the file's @world values for the host. */
-declare function deserializeState(engine: Engine, json: string, opts?: LoadStateOptions): PropertyBag | undefined;
+declare function deserializeState(engine: Engine, json: string, opts?: LoadStateOptions): PropertyBag$1 | undefined;
 
 interface PropertyInspectorOptions {
     /** Mount point; defaults to document.body. */
@@ -103,8 +150,8 @@ interface BundleInspector {
  *  (design/engine-server.md 4.2). Nothing is added for the ordinary
  *  run-scoped property: that is what a property is. */
 declare function formatPropertySummary(p: PropertySummary): string;
-/** The scope label a declaration block files under ("world", "box box",
- *  "tag docks (zone)"). */
+/** The scope label a declaration block files under ("world", "player", "box box",
+ *  "tag docks (zone)"). A host scope is named by its token, as @world is. */
 declare function formatScopeLabel(scope: PropertyScopeSummary): string;
 /** Render a read-only summary of a compiled bundle: what an integrator may
  *  call, with no session and no game running. */
@@ -240,47 +287,9 @@ type LiveBundleResult =
  * the game's registry the old engine hands its keys to the replacement, which a
  * plain save and load into a second engine cannot do (the two would clash).
  *
- * The engine remembers the options it was built with (seed, log, world,
+ * The engine remembers the options it was built with (seed, log, hostScopes,
  * registry), so `opts` is only for overriding one of them for the replacement.
  */
 declare function applyLiveBundle(engine: Engine, bundleJson: string, opts?: EngineOptions): LiveBundleResult;
 
-interface WorldContainer {
-    /** Pass as `new Engine(bundle, { world: container.resolver })`. */
-    resolver: ScopeResolver;
-    /** The kernel bag itself (subscribe, audit, rows live there) - mount it
-     *  into a state logger or examiner beside the engine's own bags. Writing it
-     *  DIRECTLY is writing the kernel, so a `writable: false` declaration asks
-     *  the kernel's question: pass `{ host: true }` to say the game is speaking
-     *  (`bag.set(name, value, { host: true })`). Through `resolver` or an
-     *  engine's setProperty that is already answered. */
-    bag: PropertyBag$1;
-    /** The current values, for saving beside the engine's envelope. */
-    values(): PropertyBag;
-    /** Restore saved values over fresh defaults: orphaned keys drop, new
-     *  declarations keep their defaults - the same drift rule as loadGame. */
-    load(values: PropertyBag): void;
-}
-/** A world container seeded from the bundle's @world declarations.
- *
- *  The container is the GAME's state, so it WRITES - even a declaration
- *  carrying `writable: false`. That flag is the STORY's promise not to write
- *  the value (Reboot.md 10), and the engine keeps it where the story writes: an
- *  outcome is refused against the engine's read-only table before it ever
- *  reaches this resolver. Enforcing it here as well refused the HOST too - the
- *  clock the game must move, the harness driving the value it is testing
- *  against - which is the opposite of what the flag says.
- *
- *  So the declarations are seeded AS DECLARED, which is what an examiner over
- *  this container should read, and the writes go through as HOST writes
- *  (scoperegistry 0.6.0's `{ host: true }`). The resolver's `set` is the
- *  engine's own doorway and passes the flag too: the engine has already sorted
- *  story from host by then - a story write was refused earlier, a host write is
- *  the only kind that arrives - and a resolver takes a name and a value with no
- *  room to say which. A game wanting a rule of its own binds its own resolver
- *  rather than this one; the ports' container (Unreal's UStoryletWorld) draws
- *  the same line, with HostSet never refused and StorySet asking the game's own
- *  read-only list. */
-declare function createWorldContainer(bundle: Bundle): WorldContainer;
-
 export { type BundleInspector, type BundleInspectorOptions, type LiveBundleResult, type LiveFrame, type LiveLink, type LiveLinkOptions, type LiveLinkState, type LiveSocketLike, type LoadStateOptions, type PropertyInspector, type PropertyInspectorOptions, type WorldContainer, applyLiveBundle, boardFrame, createBundleInspector, createLiveLink, createPropertyInspector, createStateLogger, createWorldContainer, deserializeState, ensureInspectorStyle, formatLogEntry, formatPropertySummary, formatScopeLabel, loadState, saveState, serializeState, snapshotState };

package/dist/index.js

@@ -37,7 +37,7 @@ function createStateLogger(engine, flow, opts = {}) {
 }
 
 // src/save.ts
-import { SAVEFILE_SCHEMA, SAVE_SCHEMA, SAVE_SCHEMA_V1 } from "@storylet-studio/model";
+import { SAVEFILE_SCHEMA, SAVE_SCHEMA, SAVE_SCHEMA_V1, SAVE_SCHEMA_V2 } from "@storylet-studio/model";
 function serializeState(engine, world) {
   return JSON.stringify(saveState(engine, world), null, 2);
 }
@@ -49,10 +49,19 @@ function saveState(engine, world) {
   };
 }
 function loadState(engine, file, opts = {}) {
-  if (!file || typeof file !== "object" || file.schema !== SAVEFILE_SCHEMA || file.engine?.schema !== SAVE_SCHEMA && file.engine?.schema !== SAVE_SCHEMA_V1) {
+  if (!file || typeof file !== "object" || file.schema !== SAVEFILE_SCHEMA || file.engine?.schema !== SAVE_SCHEMA && file.engine?.schema !== SAVE_SCHEMA_V2 && file.engine?.schema !== SAVE_SCHEMA_V1) {
     throw new Error(`not a storylets save (expected schema "${SAVEFILE_SCHEMA}")`);
   }
-  const report = engine.loadGame(file.engine);
+  const container = opts.world;
+  const before = container !== void 0 ? structuredClone(container.values()) : void 0;
+  if (container !== void 0 && file.world !== void 0) container.load(file.world);
+  let report;
+  try {
+    report = engine.loadGame(file.engine);
+  } catch (e) {
+    if (container !== void 0 && before !== void 0) container.load(before);
+    throw e;
+  }
   opts.onReport?.(report);
   return file.world;
 }
@@ -122,7 +131,7 @@ var LOG_KIND_LABELS = {
   turns: "Turns",
   diagnostic: "Diag"
 };
-var logKindOf = (e) => e.type === "peek" ? "deal" : e.type;
+var logKindOf = (e) => e.type === "peek" ? "deal" : e.type === "discard" ? "play" : e.type;
 var showVal = (v) => v === void 0 ? "<unset>" : JSON.stringify(v);
 function formatLogEntry(e) {
   return formatLogBody(e, "flow" in e && e.flow ? `${e.flow} ` : "");
@@ -148,6 +157,9 @@ function formatLogBody(e, flow) {
       return `${stamp}write ${e.path}: ${showVal(e.prev)} -> ${showVal(e.value)}`;
     case "turns":
       return `${stamp}turns ${e.box} -> ${e.turn}`;
+    // A card the game took out of its hand unplayed: filed with the plays.
+    case "discard":
+      return `${stamp}discard ${e.card} from ${e.hand}`;
     default:
       return `${stamp}diagnostic ${e.where}: ${e.message}`;
   }
@@ -496,6 +508,7 @@ function formatPropertySummary(p) {
 }
 function formatScopeLabel(scope) {
   if (scope.scope === "world" || scope.scope === "story") return scope.scope;
+  if (scope.scope === "host") return scope.owner;
   const group = scope.group !== void 0 ? ` (${scope.group})` : "";
   return `${scope.scope} ${scope.owner}${group}`;
 }
@@ -587,7 +600,7 @@ function createBundleInspector(bundle, opts = {}) {
   line(countsBody, `boxes ${totals.boxes} - decks ${totals.decks} - cards ${totals.cards}`);
   line(countsBody, `hands ${totals.hands} - templates ${totals.templates} - tag groups ${totals.tagGroups}`);
   for (const box of description.boxes) {
-    line(countsBody, `${box.gameId}: decks ${box.counts.decks}, cards ${box.counts.cards}, hands ${box.counts.hands}, templates ${box.counts.templates}, tag groups ${box.counts.tagGroups}, ranking.specificity ${box.ranking.specificity}` + (box.turn !== void 0 ? `, turn = ${box.turn.seconds}s` : "") + (box.durableCards !== void 0 ? `, durable cards ${box.durableCards}` : ""));
+    line(countsBody, `${box.gameId}: decks ${box.counts.decks}, cards ${box.counts.cards}, hands ${box.counts.hands}, templates ${box.counts.templates}, tag groups ${box.counts.tagGroups}, ranking.specificity ${box.ranking.specificity}` + (box.turn === void 0 ? "" : box.turn.seconds !== void 0 ? `, turn = ${box.turn.seconds}s` : ", turn moved by the game") + (box.durableCards !== void 0 ? `, durable cards ${box.durableCards}` : ""));
   }
   (opts.container ?? document.body).append(el);
   return {
@@ -603,7 +616,7 @@ function createBundleInspector(bundle, opts = {}) {
 var OPEN = 1;
 var QUEUE_CAP = 512;
 var DEFAULT_URL = "ws://127.0.0.1:4472";
-var BOARD_EVENTS = /* @__PURE__ */ new Set(["deal", "play", "evict", "turns"]);
+var BOARD_EVENTS = /* @__PURE__ */ new Set(["deal", "play", "discard", "evict", "turns"]);
 function boardFrame(flow) {
   const id = flow.id;
   const hands = {};
@@ -794,8 +807,9 @@ function applyLiveBundle(engine, bundleJson, opts = {}) {
 
 // src/world.ts
 import { PropertyBag as StateBag } from "@wildwinter/scoperegistry";
-function createWorldContainer(bundle) {
-  const bag = new StateBag(bundle.world.properties, { normalise: (n) => n });
+import { hostScopeDecls } from "@storylet-studio/model";
+function createWorldContainer(bundle, token = "world") {
+  const bag = new StateBag(hostScopeDecls(bundle, token), { normalise: (n) => n });
   return {
     resolver: {
       get: (n) => bag.get(n),