@storylet-studio/runtime 0.5.0 → 0.7.0

package/dist/index.d.cts

@@ -72,6 +72,9 @@ interface OutcomeView {
     gameId: string;
     title?: string;
     purpose?: string;
+    /** The outcome's fields, exactly as the bundle carries them: game data
+     *  declared by the box's `outcomeFields`, never read by the engine. */
+    fields?: Record<string, ScalarValue>;
     /** Evaluated against CURRENT state at the moment of the ask. */
     available: boolean;
 }
@@ -130,7 +133,8 @@ type TraceEvent = {
     card: string;
     reason: TraceVerdict | "hand-condition" | "vanished";
 }
-/** Card and outcome gameIds. */
+/** Card and outcome gameIds; `outcome` is "" for a card with no outcomes,
+ *  played with none. */
  | {
     type: "play";
     card: string;
@@ -657,7 +661,16 @@ declare class Flow {
     outcomes(cardId: string, from: string): OutcomeView[];
     /** Apply an outcome (schema 3.7): the card must sit in a hand on the
      *  board (you never play a card from inside the deck). Throws before any
-     *  mutation on a gated-shut outcome or a bad write target. */
+     *  mutation on a gated-shut outcome or a bad write target.
+     *
+     *  A card with NO outcomes is played with none, named as "" (the
+     *  no-outcome-play brief, 2026-09-14): a masthead, a notice, a codex entry,
+     *  whose play means "shown". It is everything a play is except the writes:
+     *  the play log and the history functions count it, the box's turn moves by
+     *  the usual rule, the redraw rests it and it leaves its hand. "" is the one
+     *  spelling in all four runtimes, because a Blueprint pin cannot be absent.
+     *  Only the empty-for-empty case is new: "" on a card that has outcomes is
+     *  refused, and a named outcome on a card with none is refused as before. */
     play(cardId: string, outcomeGameId: string, from: string, opts?: PlayOptions): void;
     /** One owned property's address, owner segment and all (4.4). */
     private address;

package/dist/index.d.ts

@@ -72,6 +72,9 @@ interface OutcomeView {
     gameId: string;
     title?: string;
     purpose?: string;
+    /** The outcome's fields, exactly as the bundle carries them: game data
+     *  declared by the box's `outcomeFields`, never read by the engine. */
+    fields?: Record<string, ScalarValue>;
     /** Evaluated against CURRENT state at the moment of the ask. */
     available: boolean;
 }
@@ -130,7 +133,8 @@ type TraceEvent = {
     card: string;
     reason: TraceVerdict | "hand-condition" | "vanished";
 }
-/** Card and outcome gameIds. */
+/** Card and outcome gameIds; `outcome` is "" for a card with no outcomes,
+ *  played with none. */
  | {
     type: "play";
     card: string;
@@ -657,7 +661,16 @@ declare class Flow {
     outcomes(cardId: string, from: string): OutcomeView[];
     /** Apply an outcome (schema 3.7): the card must sit in a hand on the
      *  board (you never play a card from inside the deck). Throws before any
-     *  mutation on a gated-shut outcome or a bad write target. */
+     *  mutation on a gated-shut outcome or a bad write target.
+     *
+     *  A card with NO outcomes is played with none, named as "" (the
+     *  no-outcome-play brief, 2026-09-14): a masthead, a notice, a codex entry,
+     *  whose play means "shown". It is everything a play is except the writes:
+     *  the play log and the history functions count it, the box's turn moves by
+     *  the usual rule, the redraw rests it and it leaves its hand. "" is the one
+     *  spelling in all four runtimes, because a Blueprint pin cannot be absent.
+     *  Only the empty-for-empty case is new: "" on a card that has outcomes is
+     *  refused, and a named outcome on a card with none is refused as before. */
     play(cardId: string, outcomeGameId: string, from: string, opts?: PlayOptions): void;
     /** One owned property's address, owner segment and all (4.4). */
     private address;

package/dist/index.js

@@ -2054,33 +2054,48 @@ var Flow = class {
       gameId: effectiveGameId(o),
       ...o.title !== void 0 ? { title: o.title } : {},
       ...o.purpose !== void 0 ? { purpose: o.purpose } : {},
+      ...o.fields !== void 0 ? { fields: o.fields } : {},
       available: this.passes(o.condition, ctx)
     }));
   }
   /** Apply an outcome (schema 3.7): the card must sit in a hand on the
    *  board (you never play a card from inside the deck). Throws before any
-   *  mutation on a gated-shut outcome or a bad write target. */
+   *  mutation on a gated-shut outcome or a bad write target.
+   *
+   *  A card with NO outcomes is played with none, named as "" (the
+   *  no-outcome-play brief, 2026-09-14): a masthead, a notice, a codex entry,
+   *  whose play means "shown". It is everything a play is except the writes:
+   *  the play log and the history functions count it, the box's turn moves by
+   *  the usual rule, the redraw rests it and it leaves its hand. "" is the one
+   *  spelling in all four runtimes, because a Blueprint pin cannot be absent.
+   *  Only the empty-for-empty case is new: "" on a card that has outcomes is
+   *  refused, and a named outcome on a card with none is refused as before. */
   play(cardId, outcomeGameId, from, opts = {}) {
     this.assertOpen();
     const { entry, ask } = this.resolveDealt(cardId, from);
-    const outcome = entry.card.outcomes.find((o) => effectiveGameId(o) === outcomeGameId);
-    if (!outcome) throw new Error(`card "${effectiveGameId(entry.card)}" has no outcome "${outcomeGameId}"`);
+    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`);
+    }
+    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 handEnv = this.buildHandEnv(ask);
     const ctx = this.evalCtx(entry.box, entry.deck, handEnv);
-    if (!this.passes(outcome.condition, ctx)) {
+    if (outcome && !this.passes(outcome.condition, ctx)) {
       throw new Error(`outcome "${outcomeGameId}" on "${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);
     const writes = [];
-    for (const [target, expr] of Object.entries(outcome.changes)) {
+    for (const [target, expr] of Object.entries(outcome?.changes ?? {})) {
       writes.push({ target, value: this.eval(expr, ctx) });
     }
     for (const { target, value } of writes) {
       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 record = { card: effectiveGameId(entry.card), outcome: effectiveGameId(outcome), turn: newTurn };
+    const outcomeId = outcome ? effectiveGameId(outcome) : "";
+    const record = { card: effectiveGameId(entry.card), outcome: outcomeId, turn: newTurn };
     this.playLog.push(record);
     this.indexPlay(record);
     if (entry.card.redraw === "never") {
@@ -2095,7 +2110,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: effectiveGameId(outcome), turn: newTurn }, newTurn);
+    if (this.tracing) this.emit({ type: "play", card: effectiveGameId(entry.card), outcome: outcomeId, turn: newTurn }, newTurn);
   }
   /** One owned property's address, owner segment and all (4.4). */
   address(kind, id) {