@yagejs-addons/dialogue 0.1.0 → 0.2.0

package/dist/index.cjs

@@ -0,0 +1,3441 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CompositeInputBinding: () => CompositeInputBinding,
+  DEFAULT_ACTIONS: () => DEFAULT_ACTIONS,
+  DialogueAutoAdvanceEvent: () => DialogueAutoAdvanceEvent,
+  DialogueChoiceMadeEvent: () => DialogueChoiceMadeEvent,
+  DialogueChoiceShownEvent: () => DialogueChoiceShownEvent,
+  DialogueCommandEvent: () => DialogueCommandEvent,
+  DialogueController: () => DialogueController,
+  DialogueEndedEvent: () => DialogueEndedEvent,
+  DialogueExprError: () => DialogueExprError,
+  DialogueLineEvent: () => DialogueLineEvent,
+  DialoguePlayError: () => DialoguePlayError,
+  DialogueRevealCompletedEvent: () => DialogueRevealCompletedEvent,
+  DialogueRevealMarkerEvent: () => DialogueRevealMarkerEvent,
+  DialogueRunner: () => DialogueRunner,
+  DialogueScriptError: () => DialogueScriptError,
+  DialogueSelectionChangedEvent: () => DialogueSelectionChangedEvent,
+  DialogueSession: () => DialogueSession,
+  DialogueSkipUsedEvent: () => DialogueSkipUsedEvent,
+  DialogueStartedEvent: () => DialogueStartedEvent,
+  EMPTY_PARSED: () => EMPTY_PARSED,
+  FULL_ACTIONS: () => FULL_ACTIONS,
+  IdentityI18n: () => IdentityI18n,
+  KeyboardInputBinding: () => KeyboardInputBinding,
+  LineReveal: () => LineReveal,
+  MemoryVariableStorage: () => MemoryVariableStorage,
+  PointerInputBinding: () => PointerInputBinding,
+  cells: () => cells,
+  compose: () => compose,
+  createVoiceChannel: () => createVoiceChannel,
+  defineScript: () => defineScript,
+  evalCondition: () => evalCondition,
+  evaluate: () => evaluate,
+  fullControls: () => fullControls,
+  interpolate: () => interpolate,
+  isExpr: () => isExpr,
+  loadCompact: () => loadCompact,
+  loadScript: () => loadScript,
+  materialize: () => materialize,
+  parseCompact: () => parseCompact,
+  parseExpr: () => parseExpr,
+  parseMarkup: () => parseMarkup,
+  splitGraphemes: () => splitGraphemes,
+  stripMarkup: () => stripMarkup
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core/markup.ts
+var EMPTY_PARSED = Object.freeze({
+  runs: Object.freeze([]),
+  tokens: Object.freeze([]),
+  length: 0
+});
+var NAMED_COLORS = {
+  black: 0,
+  white: 16777215,
+  red: 16734810,
+  green: 9232491,
+  blue: 7316441,
+  yellow: 16769126,
+  gold: 16765530,
+  orange: 16097640,
+  purple: 13214975,
+  pink: 16752331,
+  gray: 10133670,
+  grey: 10133670
+};
+function parseColor(raw) {
+  const v = raw.trim().toLowerCase();
+  if (v.startsWith("#")) {
+    const hex = v.slice(1);
+    if (/^[0-9a-f]{6}$/.test(hex)) return parseInt(hex, 16);
+    if (/^[0-9a-f]{3}$/.test(hex)) {
+      const r = hex[0];
+      const g = hex[1];
+      const b = hex[2];
+      return parseInt(`${r}${r}${g}${g}${b}${b}`, 16);
+    }
+    return void 0;
+  }
+  if (/^0x[0-9a-f]{6}$/.test(v)) return parseInt(v.slice(2), 16);
+  return NAMED_COLORS[v];
+}
+__name(parseColor, "parseColor");
+function effectiveStyle(stack) {
+  let style = {};
+  for (const f of stack) style = mergeStyle(style, f.override);
+  return style;
+}
+__name(effectiveStyle, "effectiveStyle");
+function mergeStyle(parent, child) {
+  const merged = {
+    ...parent,
+    ...stripUndefined(child)
+  };
+  if (child.speed !== void 0) {
+    merged.speed = (parent.speed ?? 1) * child.speed;
+  }
+  return merged;
+}
+__name(mergeStyle, "mergeStyle");
+function stripUndefined(s) {
+  const out = {};
+  for (const k of Object.keys(s)) {
+    if (s[k] !== void 0) out[k] = s[k];
+  }
+  return out;
+}
+__name(stripUndefined, "stripUndefined");
+var TAG_RE = /\[(\/?)([a-zA-Z]+)(?:=([^\s\]/]*))?((?:\s+[A-Za-z_][\w-]*=[^\s\]/]*)*)(\/)?\]/g;
+var GRAPHEME_SEGMENTER = new Intl.Segmenter();
+function splitGraphemes(text) {
+  const out = [];
+  for (const s of GRAPHEME_SEGMENTER.segment(text)) out.push(s.segment);
+  return out;
+}
+__name(splitGraphemes, "splitGraphemes");
+function parseMarkup(input) {
+  const runs = [];
+  const tokens = [];
+  const stack = [];
+  let charCount = 0;
+  let buffer = "";
+  const flush = /* @__PURE__ */ __name(() => {
+    if (buffer.length === 0) return;
+    const graphemeCount = splitGraphemes(buffer).length;
+    runs.push({ text: buffer, style: effectiveStyle(stack), graphemeCount });
+    charCount += graphemeCount;
+    buffer = "";
+  }, "flush");
+  let lastIndex = 0;
+  TAG_RE.lastIndex = 0;
+  let m;
+  while ((m = TAG_RE.exec(input)) !== null) {
+    let backslashes = 0;
+    for (let i = m.index - 1; i >= lastIndex && input[i] === "\\"; i--) backslashes++;
+    if (backslashes % 2 === 1) {
+      buffer += unescape(input.slice(lastIndex, m.index - 1)) + m[0];
+      lastIndex = TAG_RE.lastIndex;
+      continue;
+    }
+    const literal = input.slice(lastIndex, m.index);
+    buffer += unescape(literal);
+    lastIndex = TAG_RE.lastIndex;
+    const closing = m[1] === "/";
+    const name = m[2].toLowerCase();
+    const arg = m[3];
+    const propsStr = m[4];
+    const selfClosing = m[5] === "/";
+    if (propsStr && !selfClosing) {
+      buffer += m[0];
+      continue;
+    }
+    if (closing) {
+      flush();
+      for (let i = stack.length - 1; i >= 0; i--) {
+        if (stack[i].name === name) {
+          stack.splice(i, 1);
+          break;
+        }
+      }
+      continue;
+    }
+    if (selfClosing) {
+      flush();
+      if (name === "pause") {
+        const ms = Number(arg ?? "0");
+        if (Number.isFinite(ms) && ms > 0) {
+          tokens.push({ kind: "pause", atChar: charCount, ms });
+        }
+      } else {
+        tokens.push({
+          kind: "marker",
+          atChar: charCount,
+          name,
+          props: markerProps(name, arg, propsStr)
+        });
+      }
+      continue;
+    }
+    const override = styleForTag(name, arg);
+    if (override) {
+      flush();
+      stack.push({ name, override });
+    }
+  }
+  buffer += unescape(input.slice(lastIndex));
+  flush();
+  return { runs: mergeAdjacent(runs), tokens, length: charCount };
+}
+__name(parseMarkup, "parseMarkup");
+function markerProps(name, arg, propsStr) {
+  const props = {};
+  if (arg !== void 0) props[name] = arg;
+  if (propsStr) {
+    for (const tok of propsStr.trim().split(/\s+/)) {
+      const eq = tok.indexOf("=");
+      if (eq > 0) props[tok.slice(0, eq).toLowerCase()] = tok.slice(eq + 1);
+    }
+  }
+  return props;
+}
+__name(markerProps, "markerProps");
+function styleForTag(name, arg) {
+  switch (name) {
+    case "b":
+    case "bold":
+      return { bold: true };
+    case "i":
+    case "italic":
+      return { italic: true };
+    case "color":
+    case "c": {
+      const color = arg ? parseColor(arg) : void 0;
+      return color !== void 0 ? { color } : null;
+    }
+    case "speed": {
+      const s = Number(arg);
+      return Number.isFinite(s) && s > 0 ? { speed: s } : null;
+    }
+    default:
+      return { effect: name };
+  }
+}
+__name(styleForTag, "styleForTag");
+function unescape(s) {
+  return s.replace(/\\([[\]\\])/g, "$1");
+}
+__name(unescape, "unescape");
+function mergeAdjacent(runs) {
+  const out = [];
+  for (const run of runs) {
+    const prev = out[out.length - 1];
+    if (prev && sameStyle(prev.style, run.style)) {
+      out[out.length - 1] = {
+        text: prev.text + run.text,
+        style: prev.style,
+        graphemeCount: prev.graphemeCount + run.graphemeCount
+      };
+    } else {
+      out.push(run);
+    }
+  }
+  return out;
+}
+__name(mergeAdjacent, "mergeAdjacent");
+function sameStyle(a, b) {
+  return !!a.bold === !!b.bold && !!a.italic === !!b.italic && a.color === b.color && a.effect === b.effect && (a.speed ?? 1) === (b.speed ?? 1);
+}
+__name(sameStyle, "sameStyle");
+function stripMarkup(input) {
+  return parseMarkup(input).runs.map((r) => r.text).join("");
+}
+__name(stripMarkup, "stripMarkup");
+function firstUnknownTag(input) {
+  TAG_RE.lastIndex = 0;
+  let lastIndex = 0;
+  let m;
+  while ((m = TAG_RE.exec(input)) !== null) {
+    let backslashes = 0;
+    for (let i = m.index - 1; i >= lastIndex && input[i] === "\\"; i--) backslashes++;
+    lastIndex = TAG_RE.lastIndex;
+    if (backslashes % 2 === 1) continue;
+    if (m[1] === "/" || m[4] || m[5] === "/") continue;
+    const name = m[2].toLowerCase();
+    if (styleForTag(name, m[3]) === null) return name;
+  }
+  return null;
+}
+__name(firstUnknownTag, "firstUnknownTag");
+
+// src/core/LineReveal.ts
+var LineReveal = class {
+  /** @param charsPerSec base reveal rate (graphemes/second), scaled by the
+   *   hold, per-line, and per-run multipliers. */
+  constructor(charsPerSec) {
+    this.charsPerSec = charsPerSec;
+  }
+  charsPerSec;
+  static {
+    __name(this, "LineReveal");
+  }
+  parsed;
+  /** Reveal cursor, in graphemes (fractional while typing). */
+  cursor = 0;
+  pauseTimer = 0;
+  /** Next un-drained token in `parsed.tokens` (one ordered cursor over pauses +
+   *  markers — source order is drain order). */
+  tokenIdx = 0;
+  /** Graphemes already ticked (so each grapheme ticks exactly once). */
+  tickCount = 0;
+  /** Hold-to-fast-forward rate (1 = normal). */
+  speedMul = 1;
+  /** Per-line `say.speed` multiplier (1 = base). */
+  lineSpeed = 1;
+  done = false;
+  completed = false;
+  /** Fired exactly once when the line finishes revealing. The consuming view
+   *  wires this to the session-owned reveal listener (NOT a public mutable
+   *  field a game could clobber). */
+  onComplete;
+  /** Per-grapheme ticks + inline markers, wired by the consuming view to the
+   *  session-owned beat listener (like {@link onComplete}, never a public field). */
+  onBeat;
+  /**
+   * Register the completion listener — fires once per line, the moment the
+   * cursor reaches the end (or synchronously from {@link begin} for an empty
+   * line, or from {@link complete}). Pass `undefined` to clear.
+   */
+  setCompletionListener(listener) {
+    this.onComplete = listener;
+  }
+  /**
+   * Register the reveal-beat listener — per-grapheme ticks and inline markers,
+   * in char order, the moment the cursor reaches each. Session-owned (set once,
+   * like {@link setCompletionListener}); pass `undefined` to clear.
+   */
+  setBeatListener(listener) {
+    this.onBeat = listener;
+  }
+  /**
+   * Start revealing a new line. Resets the cursor, pauses, and the hold
+   * multiplier (a stale fast-forward must not leak into the next line — an
+   * active binding re-asserts it on its next poll). An **empty** line
+   * (`parsed.length === 0`) is complete immediately and fires the completion
+   * listener synchronously, matching the no-typewriter contract.
+   */
+  begin(parsed, lineSpeed = 1) {
+    this.parsed = parsed;
+    this.lineSpeed = lineSpeed > 0 ? lineSpeed : 1;
+    this.cursor = 0;
+    this.pauseTimer = 0;
+    this.tokenIdx = 0;
+    this.tickCount = 0;
+    this.speedMul = 1;
+    this.done = parsed.length === 0;
+    this.completed = false;
+    this.drainTokens();
+    if (this.done) this.finish();
+  }
+  /** Hold-to-fast-forward multiplier (1 = normal, e.g. 4 while skip is held). */
+  setSpeedMultiplier(m) {
+    this.speedMul = Math.max(1, m);
+  }
+  /** Advance the reveal cursor by `dt` (ms). Honours armed pauses and per-run
+   *  speed; fires completion once the cursor reaches the end. No-op after the
+   *  line is done or before the first {@link begin}. */
+  update(dt) {
+    const parsed = this.parsed;
+    if (!parsed || this.done) return;
+    if (this.pauseTimer > 0) {
+      this.pauseTimer = Math.max(0, this.pauseTimer - dt);
+    } else {
+      this.drainTokens();
+      if (this.pauseTimer === 0) {
+        const rate = this.charsPerSec * this.speedMul * this.lineSpeed * this.runSpeedAt(this.cursor);
+        this.cursor = Math.min(parsed.length, this.cursor + rate * dt / 1e3);
+        this.drainTokens();
+        this.emitTicks();
+      }
+    }
+    if (this.cursor >= parsed.length && this.pauseTimer === 0) this.finish();
+  }
+  /** Reveal everything now (skip-to-end on a click/tap). Drains any not-yet-fired
+   *  markers in order so their consequences still happen (`viaSkip=true` lets a
+   *  host suppress a loud one-shot) and blows straight through pending pauses (a
+   *  skip ignores holds), but DISCARDS pending ticks — replaying dozens of
+   *  typewriter blips at once would machine-gun. Fires completion. */
+  complete() {
+    const parsed = this.parsed;
+    if (!parsed) return;
+    this.cursor = parsed.length;
+    this.pauseTimer = 0;
+    this.drainTokens(true);
+    this.tickCount = parsed.length;
+    this.finish();
+  }
+  /** Revealed grapheme count (fractional while typing). The view floors this to
+   *  map onto its glyph prefix table. */
+  get revealed() {
+    return this.cursor;
+  }
+  /** True once the line is fully revealed (also true for an empty line). */
+  isComplete() {
+    return this.done;
+  }
+  /** True while glyphs are still appearing. */
+  isRevealing() {
+    return !this.done;
+  }
+  finish() {
+    this.done = true;
+    if (this.completed) return;
+    this.completed = true;
+    this.onComplete?.();
+  }
+  /**
+   * Drain tokens whose offset the cursor has reached, IN SOURCE ORDER. A `marker`
+   * emits a beat; a `pause` arms the hold, clamps the cursor to its offset, and
+   * STOPS the drain for this frame (a one-frame advance can overshoot the offset,
+   * so the clamp keeps glyphs past the beat from popping in early, and a later
+   * token waits until the hold resumes). `viaSkip` (from {@link complete}) tags
+   * drained markers and blows straight through pauses without holding. Monotonic
+   * `tokenIdx` → each token is handled exactly once.
+   */
+  drainTokens(viaSkip = false) {
+    const tokens = this.parsed?.tokens;
+    if (!tokens) return;
+    while (this.tokenIdx < tokens.length && this.cursor >= tokens[this.tokenIdx].atChar) {
+      const tok = tokens[this.tokenIdx];
+      this.tokenIdx++;
+      if (tok.kind === "marker") {
+        this.onBeat?.({ kind: "marker", marker: tok, viaSkip });
+      } else if (!viaSkip && tok.ms > 0) {
+        this.pauseTimer = tok.ms;
+        this.cursor = Math.min(this.cursor, tok.atChar);
+        return;
+      }
+    }
+  }
+  /** Emit a `tick` for each grapheme newly revealed since the last call (raw —
+   *  no whitespace test; the host filters). Multiple in order on a large-dt
+   *  frame; `tickCount` is monotonic so none repeat. */
+  emitTicks() {
+    const next = Math.floor(this.cursor);
+    for (let i = this.tickCount; i < next; i++) {
+      this.onBeat?.({ kind: "tick", index: i });
+    }
+    this.tickCount = next;
+  }
+  /** Reveal speed multiplier for whichever run the cursor currently sits in. */
+  runSpeedAt(reveal) {
+    const parsed = this.parsed;
+    if (!parsed) return 1;
+    const at = Math.floor(reveal);
+    let acc = 0;
+    for (const run of parsed.runs) {
+      if (at < acc + run.graphemeCount) return run.style.speed ?? 1;
+      acc += run.graphemeCount;
+    }
+    return 1;
+  }
+};
+
+// src/core/vars.ts
+function materialize(storage) {
+  const out = {};
+  for (const [name, value] of storage.entries()) out[name] = value;
+  return out;
+}
+__name(materialize, "materialize");
+var MemoryVariableStorage = class {
+  static {
+    __name(this, "MemoryVariableStorage");
+  }
+  map = /* @__PURE__ */ new Map();
+  constructor(initial) {
+    if (initial) for (const [name, value] of Object.entries(initial)) this.map.set(name, value);
+  }
+  get(name) {
+    return this.map.get(name);
+  }
+  set(name, value) {
+    this.map.set(name, value);
+  }
+  has(name) {
+    return this.map.has(name);
+  }
+  entries() {
+    return this.map.entries();
+  }
+  /** Drop everything — host-controlled reset (variables persist across plays by default). */
+  clear() {
+    this.map.clear();
+  }
+};
+function cells(defs) {
+  const read = /* @__PURE__ */ __name((name) => {
+    const cell = defs[name];
+    return typeof cell === "function" ? cell() : cell.get();
+  }, "read");
+  return {
+    get(name) {
+      return Object.hasOwn(defs, name) ? read(name) : void 0;
+    },
+    set(name, value) {
+      if (!Object.hasOwn(defs, name)) {
+        throw new Error(`dialogue: cells() has no accessor for "${name}"`);
+      }
+      const cell = defs[name];
+      if (typeof cell === "function" || cell.set === void 0) {
+        throw new Error(
+          `dialogue: "${name}" is read-only (a cells getter without a setter)`
+        );
+      }
+      cell.set(value);
+    },
+    has(name) {
+      return Object.hasOwn(defs, name);
+    },
+    *entries() {
+      for (const name of Object.keys(defs)) yield [name, read(name)];
+    }
+  };
+}
+__name(cells, "cells");
+function compose(...storages) {
+  if (storages.length === 0) {
+    throw new Error("dialogue: compose() needs at least one storage");
+  }
+  const last = storages[storages.length - 1];
+  return {
+    get(name) {
+      for (const s of storages) if (s.has(name)) return s.get(name);
+      return void 0;
+    },
+    set(name, value) {
+      for (const s of storages) {
+        if (s.has(name)) {
+          s.set(name, value);
+          return;
+        }
+      }
+      last.set(name, value);
+    },
+    has(name) {
+      return storages.some((s) => s.has(name));
+    },
+    *entries() {
+      const seen = /* @__PURE__ */ new Set();
+      for (const s of storages) {
+        for (const [name, value] of s.entries()) {
+          if (!seen.has(name)) {
+            seen.add(name);
+            yield [name, value];
+          }
+        }
+      }
+    }
+  };
+}
+__name(compose, "compose");
+
+// src/core/expr.ts
+function createScope(storage, functions) {
+  return {
+    get: /* @__PURE__ */ __name((name) => storage.get(name) ?? null, "get"),
+    call: /* @__PURE__ */ __name((fn, args) => {
+      const f = functions[fn];
+      if (!f) throw new Error(`dialogue: no function "${fn}" is installed`);
+      return f(...args);
+    }, "call"),
+    vars: /* @__PURE__ */ __name(() => materialize(storage), "vars")
+  };
+}
+__name(createScope, "createScope");
+function holds(condition, scope) {
+  return condition === void 0 ? true : evalCondition(condition, scope);
+}
+__name(holds, "holds");
+function evalCondition(condition, scope) {
+  if (typeof condition === "function") return condition(scope.vars());
+  if (typeof condition === "string") return truthy(scope.get(condition));
+  if (isExpr(condition)) return truthy(evaluate(condition, scope));
+  const { var: name, op, value } = condition;
+  if (op === "truthy") return truthy(scope.get(name));
+  if (op === "falsy") return !truthy(scope.get(name));
+  return truthy(
+    evaluate(
+      {
+        kind: "binary",
+        op,
+        left: { kind: "varRef", name },
+        right: { kind: "literal", value }
+      },
+      scope
+    )
+  );
+}
+__name(evalCondition, "evalCondition");
+function evaluate(expr, scope) {
+  switch (expr.kind) {
+    case "literal":
+      return expr.value;
+    case "varRef":
+      return scope.get(expr.name);
+    case "group":
+      return evaluate(expr.expr, scope);
+    case "call":
+      return scope.call(
+        expr.fn,
+        (expr.args ?? []).map((a) => evaluate(a, scope))
+      );
+    case "unary":
+      return applyUnary(expr.op, evaluate(expr.operand, scope));
+    case "binary": {
+      const { op } = expr;
+      if (op === "and" || op === "&&") {
+        return truthy(evaluate(expr.left, scope)) && truthy(evaluate(expr.right, scope));
+      }
+      if (op === "or" || op === "||") {
+        return truthy(evaluate(expr.left, scope)) || truthy(evaluate(expr.right, scope));
+      }
+      return applyBinary(op, evaluate(expr.left, scope), evaluate(expr.right, scope));
+    }
+  }
+}
+__name(evaluate, "evaluate");
+function isExpr(value) {
+  return typeof value === "object" && value !== null && "kind" in value;
+}
+__name(isExpr, "isExpr");
+function truthy(value) {
+  return Boolean(value);
+}
+__name(truthy, "truthy");
+function applyUnary(op, v) {
+  switch (op) {
+    case "not":
+    case "!":
+      return !truthy(v);
+    case "-":
+      return -num(v);
+  }
+}
+__name(applyUnary, "applyUnary");
+function applyBinary(op, l, r) {
+  switch (op) {
+    case "==":
+    case "eq":
+    case "is":
+      return l === r;
+    case "!=":
+    case "neq":
+      return l !== r;
+    case ">":
+    case "gt":
+      return num(l) > num(r);
+    case "<":
+    case "lt":
+      return num(l) < num(r);
+    case ">=":
+    case "gte":
+      return num(l) >= num(r);
+    case "<=":
+    case "lte":
+      return num(l) <= num(r);
+    // `and`/`or` (and `&&`/`||`) are short-circuited in evaluate() and never
+    // reach here; `xor` needs both operands, so it stays.
+    case "xor":
+    case "^":
+      return truthy(l) !== truthy(r);
+    case "+":
+      return typeof l === "string" || typeof r === "string" ? `${str(l)}${str(r)}` : num(l) + num(r);
+    case "-":
+      return num(l) - num(r);
+    case "*":
+      return num(l) * num(r);
+    case "/":
+      return num(l) / num(r);
+    case "%":
+      return num(l) % num(r);
+    default:
+      throw new Error(`dialogue: unknown binary operator "${op}"`);
+  }
+}
+__name(applyBinary, "applyBinary");
+function num(v) {
+  return typeof v === "number" ? v : Number(v);
+}
+__name(num, "num");
+function str(v) {
+  return v === null ? "" : String(v);
+}
+__name(str, "str");
+
+// src/core/i18n.ts
+var IdentityI18n = class {
+  constructor(locale = "en") {
+    this.locale = locale;
+  }
+  locale;
+  static {
+    __name(this, "IdentityI18n");
+  }
+  t(_key, fallback, params) {
+    return params ? interpolate(fallback, params) : fallback;
+  }
+};
+var TOKEN = /\{(\w+)\}/g;
+function interpolate(text, params) {
+  return text.replace(
+    TOKEN,
+    (whole, name) => Object.hasOwn(params, name) ? String(params[name]) : whole
+  );
+}
+__name(interpolate, "interpolate");
+function tokensIn(text) {
+  const names = /* @__PURE__ */ new Set();
+  for (const m of text.matchAll(TOKEN)) names.add(m[1]);
+  return [...names];
+}
+__name(tokensIn, "tokensIn");
+
+// src/core/validate.ts
+var DialogueScriptError = class extends Error {
+  static {
+    __name(this, "DialogueScriptError");
+  }
+};
+var DialoguePlayError = class extends Error {
+  static {
+    __name(this, "DialoguePlayError");
+  }
+};
+var NUMERIC_OPS = /* @__PURE__ */ new Set([">", ">=", "<", "<="]);
+var NUMERIC_EXPR_OPS = /* @__PURE__ */ new Set([
+  ">",
+  "<",
+  ">=",
+  "<=",
+  "gt",
+  "lt",
+  "gte",
+  "lte",
+  "-",
+  "*",
+  "/",
+  "%"
+]);
+var BUILTIN_COMMANDS = /* @__PURE__ */ new Set(["set"]);
+function operandRequirement(op) {
+  if (op === "+") return "numberOrString";
+  return NUMERIC_EXPR_OPS.has(op) ? "number" : null;
+}
+__name(operandRequirement, "operandRequirement");
+var analysisCache = /* @__PURE__ */ new WeakMap();
+function analyzeScript(script) {
+  const cached = analysisCache.get(script);
+  if (cached) return cached;
+  const analysis = computeAnalysis(script);
+  analysisCache.set(script, analysis);
+  return analysis;
+}
+__name(analyzeScript, "analyzeScript");
+function computeAnalysis(script) {
+  const declaredTypes = /* @__PURE__ */ new Map();
+  for (const [name, value] of Object.entries(script.declare ?? {})) {
+    declaredTypes.set(name, valueType(value));
+  }
+  const readVars = /* @__PURE__ */ new Set();
+  const setTargets = /* @__PURE__ */ new Set();
+  const calledFunctions = /* @__PURE__ */ new Set();
+  const commandTypes = /* @__PURE__ */ new Set();
+  const collectExpr = /* @__PURE__ */ __name((expr, where) => {
+    switch (expr.kind) {
+      case "literal":
+        return;
+      case "varRef":
+        readVars.add(expr.name);
+        return;
+      case "call":
+        calledFunctions.add(expr.fn);
+        for (const arg of expr.args ?? []) collectExpr(arg, where);
+        return;
+      case "group":
+        collectExpr(expr.expr, where);
+        return;
+      case "unary":
+        collectExpr(expr.operand, where);
+        return;
+      case "binary":
+        collectExpr(expr.left, where);
+        collectExpr(expr.right, where);
+        checkBinaryOperands(expr, where);
+        return;
+    }
+  }, "collectExpr");
+  const checkBinaryOperands = /* @__PURE__ */ __name((expr, where) => {
+    const req = operandRequirement(expr.op);
+    if (!req) return;
+    const expected = req === "numberOrString" ? "a number or string" : "a number";
+    for (const operand of [expr.left, expr.right]) {
+      if (operand.kind === "literal") {
+        const t = valueType(operand.value);
+        if (t === "number" || req === "numberOrString" && t === "string") continue;
+        throw new DialogueScriptError(
+          `${where}: operator "${expr.op}" expects ${expected}, got ${t}`
+        );
+      }
+      if (operand.kind === "varRef" && req === "number") {
+        const t = declaredTypes.get(operand.name);
+        if (t !== void 0 && t !== "number" && t !== "null") {
+          throw new DialogueScriptError(
+            `${where}: operator "${expr.op}" needs a number; "${operand.name}" is ${t}`
+          );
+        }
+      }
+    }
+  }, "checkBinaryOperands");
+  const checkTokens = /* @__PURE__ */ __name((text) => {
+    if (!text) return;
+    for (const token of tokensIn(text)) readVars.add(token);
+  }, "checkTokens");
+  const checkCondition = /* @__PURE__ */ __name((condition, where) => {
+    if (condition === void 0 || typeof condition === "function") return;
+    if (typeof condition === "string") {
+      readVars.add(condition);
+      return;
+    }
+    if (isExpr(condition)) {
+      collectExpr(condition, where);
+      return;
+    }
+    readVars.add(condition.var);
+    if (NUMERIC_OPS.has(condition.op)) {
+      const t = declaredTypes.get(condition.var);
+      if (t !== void 0 && t !== "number" && t !== "null") {
+        throw new DialogueScriptError(
+          `${where}: operator "${condition.op}" needs a number; "${condition.var}" is ${t}`
+        );
+      }
+      if (typeof condition.value !== "number") {
+        throw new DialogueScriptError(
+          `${where}: operator "${condition.op}" compares against a number, got ${typeof condition.value}`
+        );
+      }
+    }
+  }, "checkCondition");
+  const checkSetLiteralType = /* @__PURE__ */ __name((target, value, where) => {
+    const declared = declaredTypes.get(target);
+    if (declared !== void 0 && declared !== "null" && value !== null && typeof value !== declared) {
+      throw new DialogueScriptError(
+        `${where}: set "${target}" expects ${declared}, got ${typeof value}`
+      );
+    }
+  }, "checkSetLiteralType");
+  const checkCommands = /* @__PURE__ */ __name((commands, where) => {
+    for (const cmd of commands ?? []) {
+      if (cmd.type === "set") {
+        const target = cmd["var"];
+        if (typeof target !== "string") {
+          throw new DialogueScriptError(`${where}: set command has no string "var"`);
+        }
+        setTargets.add(target);
+        const value = cmd["value"];
+        if (value === void 0) {
+          throw new DialogueScriptError(`${where}: set "${target}" has no value`);
+        }
+        if (isExpr(value)) {
+          collectExpr(value, where);
+          if (value.kind === "literal") checkSetLiteralType(target, value.value, where);
+        } else {
+          checkSetLiteralType(target, value, where);
+        }
+        continue;
+      }
+      if (!BUILTIN_COMMANDS.has(cmd.type)) commandTypes.add(cmd.type);
+    }
+  }, "checkCommands");
+  for (const speaker of Object.values(script.speakers ?? {})) {
+    checkTokens(speaker.name);
+  }
+  for (const node of Object.values(script.nodes)) {
+    const where = `node "${node.id}"`;
+    for (const step of node.steps) {
+      switch (step.kind) {
+        case "say": {
+          const s = step;
+          checkTokens(s.text);
+          checkCommands(s.commands, `${where} say`);
+          break;
+        }
+        case "choice": {
+          const c = step;
+          checkTokens(c.text);
+          for (const opt of c.options) {
+            checkTokens(opt.text);
+            checkTokens(opt.disabledReason);
+            checkCondition(opt.condition, `${where} choice option "${opt.text}"`);
+            checkCommands(opt.commands, `${where} choice option "${opt.text}"`);
+          }
+          break;
+        }
+        case "command": {
+          const cs = step;
+          checkCommands(cs.commands, `${where} command`);
+          checkCondition(cs.condition, `${where} command`);
+          break;
+        }
+        default:
+          break;
+      }
+    }
+  }
+  return { declaredTypes, readVars, setTargets, calledFunctions, commandTypes };
+}
+__name(computeAnalysis, "computeAnalysis");
+function validatePlay(analysis, env) {
+  for (const [name, type] of analysis.declaredTypes) {
+    if (type === "null" || !env.storage.has(name)) continue;
+    const current = env.storage.get(name);
+    if (current !== void 0 && current !== null && typeof current !== type) {
+      throw new DialoguePlayError(
+        `declared default for "${name}" is ${type} but storage already holds ${typeof current}`
+      );
+    }
+  }
+  for (const name of analysis.readVars) {
+    if (!analysis.declaredTypes.has(name) && !env.storage.has(name) && !analysis.setTargets.has(name)) {
+      throw new DialoguePlayError(
+        `script reads "${name}" but nothing provides it (no declared default, no storage value, no \`set\`; for an argument read use a function call)`
+      );
+    }
+  }
+  for (const fn of analysis.calledFunctions) {
+    if (!Object.hasOwn(env.functions, fn)) {
+      throw new DialoguePlayError(
+        `script calls function "${fn}" but no such function is installed`
+      );
+    }
+  }
+  for (const target of analysis.setTargets) {
+    if (Object.hasOwn(env.functions, target)) {
+      throw new DialoguePlayError(
+        `set target "${target}" is a function (read-only); functions cannot be assigned`
+      );
+    }
+  }
+  if (env.fallbackCommand === void 0) {
+    const unhandled = [...analysis.commandTypes].filter((t) => !Object.hasOwn(env.commands, t));
+    if (unhandled.length > 0) {
+      throw new DialoguePlayError(
+        `no handler for command type(s): ${unhandled.join(", ")} (add to commands, or set fallbackCommand)`
+      );
+    }
+  }
+}
+__name(validatePlay, "validatePlay");
+function valueType(value) {
+  if (value === null) return "null";
+  if (typeof value === "string") return "string";
+  if (typeof value === "number") return "number";
+  return "boolean";
+}
+__name(valueType, "valueType");
+
+// src/core/expr-parse.ts
+var DialogueExprError = class extends DialogueScriptError {
+  static {
+    __name(this, "DialogueExprError");
+  }
+  line;
+  col;
+  constructor(message, line, col) {
+    super(`${message} (at ${line}:${col})`);
+    this.name = "DialogueExprError";
+    this.line = line;
+    this.col = col;
+  }
+};
+function parseExpr(src) {
+  const tokens = tokenize(src);
+  return new Parser(tokens).parse();
+}
+__name(parseExpr, "parseExpr");
+var KEYWORDS = {
+  and: "&&",
+  or: "||",
+  not: "!",
+  xor: "xor",
+  is: "==",
+  eq: "==",
+  neq: "!=",
+  gt: ">",
+  lt: "<",
+  gte: ">=",
+  lte: "<=",
+  true: "true",
+  false: "false",
+  null: "null"
+};
+var isDigit = /* @__PURE__ */ __name((c) => c >= "0" && c <= "9", "isDigit");
+var isIdentStart = /* @__PURE__ */ __name((c) => c >= "A" && c <= "Z" || c >= "a" && c <= "z" || c === "_" || c === "$", "isIdentStart");
+var isIdentPart = /* @__PURE__ */ __name((c) => isIdentStart(c) || isDigit(c) || c === ".", "isIdentPart");
+function tokenize(src) {
+  const tokens = [];
+  let i = 0;
+  let line = 1;
+  let col = 1;
+  const advance = /* @__PURE__ */ __name((n = 1) => {
+    for (let k = 0; k < n; k++) {
+      if (src[i] === "\n") {
+        line++;
+        col = 1;
+      } else {
+        col++;
+      }
+      i++;
+    }
+  }, "advance");
+  while (i < src.length) {
+    const c = src[i];
+    if (c === " " || c === "	" || c === "\n" || c === "\r") {
+      advance();
+      continue;
+    }
+    const startLine = line;
+    const startCol = col;
+    if (isDigit(c)) {
+      let text = "";
+      while (i < src.length && isDigit(src[i])) {
+        text += src[i];
+        advance();
+      }
+      if (src[i] === "." && isDigit(src[i + 1] ?? "")) {
+        text += ".";
+        advance();
+        while (i < src.length && isDigit(src[i])) {
+          text += src[i];
+          advance();
+        }
+      }
+      tokens.push({ kind: "number", value: Number(text), line: startLine, col: startCol });
+      continue;
+    }
+    if (c === "'" || c === '"') {
+      const quote = c;
+      advance();
+      let text = "";
+      while (i < src.length && src[i] !== quote) {
+        if (src[i] === "\\") {
+          advance();
+          if (i >= src.length) break;
+          text += unescape2(src[i]);
+        } else {
+          text += src[i];
+        }
+        advance();
+      }
+      if (src[i] !== quote) {
+        throw new DialogueExprError("unterminated string literal", startLine, startCol);
+      }
+      advance();
+      tokens.push({ kind: "string", value: text, line: startLine, col: startCol });
+      continue;
+    }
+    if (isIdentStart(c)) {
+      let text = "";
+      while (i < src.length && isIdentPart(src[i])) {
+        text += src[i];
+        advance();
+      }
+      const keyword = KEYWORDS[text];
+      if (keyword === void 0) {
+        tokens.push({ kind: "ident", value: text, line: startLine, col: startCol });
+      } else if (keyword === "true" || keyword === "false" || keyword === "null") {
+        const value = keyword === "true" ? true : keyword === "false" ? false : null;
+        tokens.push({ kind: keyword, value, line: startLine, col: startCol });
+      } else {
+        tokens.push({ kind: keyword, line: startLine, col: startCol });
+      }
+      continue;
+    }
+    const two = src.slice(i, i + 2);
+    if (two === "&&" || two === "||" || two === "==" || two === "!=" || two === ">=" || two === "<=") {
+      tokens.push({ kind: two, line: startLine, col: startCol });
+      advance(2);
+      continue;
+    }
+    if (c === ">" || c === "<" || c === "!" || c === "+" || c === "-" || c === "(" || c === ")" || c === ",") {
+      tokens.push({ kind: c, line: startLine, col: startCol });
+      advance();
+      continue;
+    }
+    throw new DialogueExprError(`unexpected character "${c}"`, startLine, startCol);
+  }
+  tokens.push({ kind: "eof", line, col });
+  return tokens;
+}
+__name(tokenize, "tokenize");
+function unescape2(c) {
+  switch (c) {
+    case "n":
+      return "\n";
+    case "t":
+      return "	";
+    case "r":
+      return "\r";
+    default:
+      return c;
+  }
+}
+__name(unescape2, "unescape");
+var INFIX_BP = {
+  "||": 1,
+  "&&": 2,
+  "==": 3,
+  "!=": 3,
+  ">": 3,
+  "<": 3,
+  ">=": 3,
+  "<=": 3,
+  "+": 4,
+  "-": 4
+};
+var Parser = class {
+  constructor(tokens) {
+    this.tokens = tokens;
+  }
+  tokens;
+  static {
+    __name(this, "Parser");
+  }
+  pos = 0;
+  parse() {
+    const expr = this.parseBinary(0);
+    const t = this.peek();
+    if (t.kind !== "eof") {
+      throw new DialogueExprError(`unexpected trailing token "${describe(t)}"`, t.line, t.col);
+    }
+    return expr;
+  }
+  parseBinary(minBp) {
+    let left = this.parseUnary();
+    for (; ; ) {
+      const t = this.peek();
+      const bp = INFIX_BP[t.kind];
+      if (bp === void 0 || bp < minBp) break;
+      this.next();
+      const right = this.parseBinary(bp + 1);
+      left = { kind: "binary", op: t.kind, left, right };
+    }
+    return left;
+  }
+  parseUnary() {
+    const t = this.peek();
+    if (t.kind === "!" || t.kind === "-") {
+      this.next();
+      const operand = this.parseUnary();
+      return { kind: "unary", op: t.kind === "!" ? "!" : "-", operand };
+    }
+    return this.parsePrimary();
+  }
+  parsePrimary() {
+    const t = this.peek();
+    switch (t.kind) {
+      case "number":
+      case "string":
+        this.next();
+        return { kind: "literal", value: t.value };
+      case "true":
+      case "false":
+      case "null":
+        this.next();
+        return { kind: "literal", value: t.value };
+      case "ident": {
+        this.next();
+        const name = t.value;
+        if (this.peek().kind === "(") {
+          this.next();
+          const args = this.parseArgs();
+          return { kind: "call", fn: name, args };
+        }
+        return { kind: "varRef", name };
+      }
+      case "(": {
+        this.next();
+        const inner = this.parseBinary(0);
+        this.expect(")");
+        return { kind: "group", expr: inner };
+      }
+      default:
+        throw new DialogueExprError(`unexpected ${describe(t)}`, t.line, t.col);
+    }
+  }
+  /** Parse a comma-separated argument list; the opening `(` is already consumed. */
+  parseArgs() {
+    const args = [];
+    if (this.peek().kind === ")") {
+      this.next();
+      return args;
+    }
+    for (; ; ) {
+      args.push(this.parseBinary(0));
+      const t = this.peek();
+      if (t.kind === ",") {
+        this.next();
+        continue;
+      }
+      if (t.kind === ")") {
+        this.next();
+        return args;
+      }
+      throw new DialogueExprError(`expected "," or ")" in argument list, got ${describe(t)}`, t.line, t.col);
+    }
+  }
+  expect(kind) {
+    const t = this.peek();
+    if (t.kind !== kind) {
+      throw new DialogueExprError(`expected "${kind}", got ${describe(t)}`, t.line, t.col);
+    }
+    this.next();
+  }
+  peek() {
+    return this.tokens[this.pos];
+  }
+  next() {
+    return this.tokens[this.pos++];
+  }
+};
+function describe(t) {
+  if (t.kind === "eof") return "end of input";
+  if (t.kind === "ident") return `"${String(t.value)}"`;
+  if (t.kind === "string") return `string "${String(t.value)}"`;
+  if (t.kind === "number") return `number ${String(t.value)}`;
+  return `"${t.kind}"`;
+}
+__name(describe, "describe");
+
+// src/core/formats/canonical.ts
+function loadScript(raw) {
+  if (!raw || typeof raw !== "object") {
+    throw new DialogueScriptError("script must be an object");
+  }
+  if (!raw.id) throw new DialogueScriptError("script.id is required");
+  if (!raw.nodes || typeof raw.nodes !== "object") {
+    throw new DialogueScriptError(`script "${raw.id}" has no nodes`);
+  }
+  const nodeIds = Object.keys(raw.nodes);
+  if (nodeIds.length === 0) {
+    throw new DialogueScriptError(`script "${raw.id}" has no nodes`);
+  }
+  const start = raw.start ?? nodeIds[0];
+  if (!raw.nodes[start]) {
+    throw new DialogueScriptError(`start node "${start}" not found in "${raw.id}"`);
+  }
+  for (const [key, speaker] of Object.entries(raw.speakers ?? {})) {
+    if (speaker.id !== key) {
+      throw new DialogueScriptError(
+        `speaker key "${key}" != speaker.id "${speaker.id}"`
+      );
+    }
+  }
+  for (const [id, node] of Object.entries(raw.nodes)) {
+    validateNode(raw, id, node);
+  }
+  const resolved = resolveExpressions(raw);
+  const script = Object.freeze({ ...resolved, start });
+  analyzeScript(script);
+  return script;
+}
+__name(loadScript, "loadScript");
+function validateNode(script, id, node) {
+  if (node.id !== id) {
+    throw new DialogueScriptError(`node key "${id}" != node.id "${node.id}"`);
+  }
+  if (!Array.isArray(node.steps) || node.steps.length === 0) {
+    throw new DialogueScriptError(`node "${id}" has no steps`);
+  }
+  for (const step of node.steps) validateStep(script, id, step);
+}
+__name(validateNode, "validateNode");
+function validateStep(script, nodeId, step) {
+  const targetExists = /* @__PURE__ */ __name((t) => {
+    if (t !== void 0 && !script.nodes[t]) {
+      throw new DialogueScriptError(
+        `node "${nodeId}": jump target "${t}" does not exist`
+      );
+    }
+  }, "targetExists");
+  const speakerExists = /* @__PURE__ */ __name((s) => {
+    if (s !== void 0 && !script.speakers?.[s]) {
+      throw new DialogueScriptError(
+        `node "${nodeId}": speaker "${s}" is not in script.speakers`
+      );
+    }
+  }, "speakerExists");
+  switch (step.kind) {
+    case "say":
+      if (typeof step.text !== "string") {
+        throw new DialogueScriptError(`node "${nodeId}": say.text must be a string`);
+      }
+      speakerExists(step.speaker);
+      break;
+    case "choice":
+      if (!Array.isArray(step.options) || step.options.length === 0) {
+        throw new DialogueScriptError(`node "${nodeId}": choice has no options`);
+      }
+      speakerExists(step.speaker);
+      for (const opt of step.options) targetExists(opt.target);
+      break;
+    case "command":
+      targetExists(step.target);
+      break;
+    case "goto":
+      if (step.target === void 0) {
+        throw new DialogueScriptError(`node "${nodeId}": goto has no target`);
+      }
+      targetExists(step.target);
+      break;
+    case "end":
+      break;
+    default:
+      throw new DialogueScriptError(
+        `node "${nodeId}": unknown step kind "${step.kind}"`
+      );
+  }
+}
+__name(validateStep, "validateStep");
+function resolveExpressions(script) {
+  let nodesChanged = false;
+  const nodes = {};
+  for (const [id, node] of Object.entries(script.nodes)) {
+    let stepsChanged = false;
+    const steps = node.steps.map((step) => {
+      const next = resolveStep(step);
+      if (next !== step) stepsChanged = true;
+      return next;
+    });
+    if (stepsChanged) {
+      nodes[id] = { ...node, steps };
+      nodesChanged = true;
+    } else {
+      nodes[id] = node;
+    }
+  }
+  return nodesChanged ? { ...script, nodes } : script;
+}
+__name(resolveExpressions, "resolveExpressions");
+function resolveStep(step) {
+  switch (step.kind) {
+    case "say":
+      return resolveSay(step);
+    case "choice":
+      return resolveChoice(step);
+    case "command":
+      return resolveCommandStep(step);
+    case "goto":
+    case "end":
+      return step;
+  }
+}
+__name(resolveStep, "resolveStep");
+function resolveSay(step) {
+  const commands = rewriteCommands(step.commands);
+  return commands ? { ...step, commands } : step;
+}
+__name(resolveSay, "resolveSay");
+function resolveCommandStep(step) {
+  const condition = rewriteCondition(step.condition);
+  const commands = rewriteCommands(step.commands);
+  if (!condition && !commands) return step;
+  return {
+    ...step,
+    ...condition ? { condition } : {},
+    ...commands ? { commands } : {}
+  };
+}
+__name(resolveCommandStep, "resolveCommandStep");
+function resolveChoice(step) {
+  let changed = false;
+  const options = step.options.map((opt) => {
+    const next = rewriteOption(opt);
+    if (next) {
+      changed = true;
+      return next;
+    }
+    return opt;
+  });
+  return changed ? { ...step, options } : step;
+}
+__name(resolveChoice, "resolveChoice");
+function rewriteOption(opt) {
+  const condition = rewriteCondition(opt.condition);
+  const commands = rewriteCommands(opt.commands);
+  if (!condition && !commands) return void 0;
+  return {
+    ...opt,
+    ...condition ? { condition } : {},
+    ...commands ? { commands } : {}
+  };
+}
+__name(rewriteOption, "rewriteOption");
+function rewriteCondition(condition) {
+  return typeof condition === "string" ? parseExpr(condition) : void 0;
+}
+__name(rewriteCondition, "rewriteCondition");
+function rewriteCommands(commands) {
+  if (!commands) return void 0;
+  let changed = false;
+  const out = commands.map((cmd) => {
+    if (cmd.type === "set" && typeof cmd.value === "string") {
+      changed = true;
+      return { ...cmd, value: parseExpr(cmd.value) };
+    }
+    return cmd;
+  });
+  return changed ? out : void 0;
+}
+__name(rewriteCommands, "rewriteCommands");
+
+// src/core/formats/compact.ts
+function parseCompact(text) {
+  const lines = text.split(/\r\n|\r|\n/);
+  const speakers = {};
+  lines.forEach((raw, i) => {
+    const line = raw.trim();
+    if (!line.startsWith("@")) return;
+    const def = parseSpeaker(line, i + 1);
+    if (Object.hasOwn(speakers, def.id)) {
+      fail(i + 1, `duplicate speaker "${def.id}"`);
+    }
+    speakers[def.id] = def;
+  });
+  let id;
+  const nodes = {};
+  const nodeOrder = [];
+  let current = null;
+  let choiceRun = null;
+  const declares = {};
+  const flushChoice = /* @__PURE__ */ __name(() => {
+    if (choiceRun && current) current.steps.push({ kind: "choice", options: choiceRun });
+    choiceRun = null;
+  }, "flushChoice");
+  lines.forEach((raw, i) => {
+    const lineNo = i + 1;
+    const line = raw.trim();
+    if (line === "" || line.startsWith("//")) return;
+    if (line.startsWith("@")) return;
+    if (line.startsWith("#")) {
+      flushChoice();
+      const newId = line.slice(1).trim();
+      if (!newId) fail(lineNo, "'#' script id directive needs an id");
+      if (id !== void 0) fail(lineNo, `duplicate '#' script id directive (already "${id}")`);
+      id = newId;
+      return;
+    }
+    if (line.startsWith("::")) {
+      flushChoice();
+      const nodeId = line.slice(2).trim();
+      if (!nodeId) fail(lineNo, "':: ' node directive needs an id");
+      if (Object.hasOwn(nodes, nodeId)) fail(lineNo, `duplicate node "${nodeId}"`);
+      current = { id: nodeId, steps: [] };
+      nodes[nodeId] = current;
+      nodeOrder.push(nodeId);
+      return;
+    }
+    if (line.startsWith("?")) {
+      if (!current) fail(lineNo, "choice '?' appears before any ':: <node>'");
+      (choiceRun ??= []).push(parseChoice(line.slice(1).trim(), lineNo));
+      return;
+    }
+    flushChoice();
+    const decl = parseDeclare(line);
+    if (decl) {
+      declares[decl.name] = decl.value;
+      return;
+    }
+    const node = current;
+    if (!node) fail(lineNo, `dialogue line appears before any ':: <node>'  ("${line}")`);
+    if (line.startsWith("->")) {
+      node.steps.push(parseGoto(line, lineNo));
+      return;
+    }
+    const set = parseSet(line);
+    if (set) {
+      node.steps.push(set);
+      return;
+    }
+    const cmd = parseDo(line, lineNo);
+    if (cmd) {
+      node.steps.push(cmd);
+      return;
+    }
+    if (line === "end") {
+      node.steps.push({ kind: "end" });
+      return;
+    }
+    node.steps.push(parseSay(line, lineNo, speakers));
+  });
+  flushChoice();
+  if (id === void 0) throw new DialogueScriptError("compact: missing '# <id>' script directive");
+  if (nodeOrder.length === 0) {
+    throw new DialogueScriptError(`compact: script "${id}" has no ':: <node>' nodes`);
+  }
+  return {
+    id,
+    start: nodeOrder[0],
+    nodes,
+    ...Object.keys(speakers).length > 0 ? { speakers } : {},
+    ...Object.keys(declares).length > 0 ? { declare: declares } : {}
+  };
+}
+__name(parseCompact, "parseCompact");
+function loadCompact(text) {
+  return loadScript(parseCompact(text));
+}
+__name(loadCompact, "loadCompact");
+function parseSpeaker(line, lineNo) {
+  const tokens = line.slice(1).trim().split(/\s+/).filter(Boolean);
+  const id = tokens[0];
+  if (!id) fail(lineNo, "'@' speaker directive needs an id");
+  let nameTokens = tokens.slice(1);
+  let color;
+  const last = nameTokens[nameTokens.length - 1];
+  if (last !== void 0 && /^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/.test(last)) {
+    color = hexColor(last);
+    nameTokens = nameTokens.slice(0, -1);
+  }
+  return {
+    id,
+    name: nameTokens.length > 0 ? nameTokens.join(" ") : id,
+    ...color !== void 0 ? { color } : {}
+  };
+}
+__name(parseSpeaker, "parseSpeaker");
+function hexColor(token) {
+  let hex = token.slice(1);
+  if (hex.length === 3) hex = hex.replace(/./g, "$&$&");
+  return parseInt(hex, 16);
+}
+__name(hexColor, "hexColor");
+function parseGoto(line, lineNo) {
+  const m = /^->\s*(\S+)(?:\s+if:\s*(.+))?\s*$/.exec(line);
+  if (!m) fail(lineNo, "'->' goto needs a target node id (optionally `-> node if: cond`)");
+  const target = m[1];
+  if (m[2] !== void 0) {
+    return { kind: "command", commands: [], condition: parseExpr(m[2].trim()), target };
+  }
+  return { kind: "goto", target };
+}
+__name(parseGoto, "parseGoto");
+function parseDeclare(line) {
+  const m = /^declare\s+([A-Za-z_$][A-Za-z0-9_.$]*)\s*=\s*(\S.*)$/.exec(line);
+  if (!m) return null;
+  return { name: m[1], value: scalar(m[2].trim()) };
+}
+__name(parseDeclare, "parseDeclare");
+function parseSet(line) {
+  const m = /^set\s+([A-Za-z_$][A-Za-z0-9_.$]*)\s*=\s*(\S.*)$/.exec(line);
+  if (!m) return null;
+  return {
+    kind: "command",
+    commands: [{ type: "set", var: m[1], value: setValue(m[2].trim()) }]
+  };
+}
+__name(parseSet, "parseSet");
+function setValue(rhs) {
+  const literal = numberBoolNull(rhs);
+  return literal === NOT_LITERAL ? parseExpr(rhs) : literal;
+}
+__name(setValue, "setValue");
+function parseDo(line, lineNo) {
+  if (!/^do(\s|$)/.test(line)) return null;
+  const tokens = splitArgs(line.slice(2).trim());
+  const type = tokens[0];
+  if (type === void 0 || !/^[A-Za-z_][A-Za-z0-9_-]*$/.test(type)) return null;
+  const command = { type };
+  let typeKeyCollision = false;
+  for (const tok of tokens.slice(1)) {
+    if (tok.startsWith("#")) {
+      const flag = tok.slice(1);
+      if (!flag) return null;
+      if (flag === "type") typeKeyCollision = true;
+      else command[flag] = true;
+      continue;
+    }
+    const eq = tok.indexOf("=");
+    if (eq <= 0) return null;
+    const key = tok.slice(0, eq);
+    if (key === "type") typeKeyCollision = true;
+    else command[key] = scalar(tok.slice(eq + 1));
+  }
+  if (typeKeyCollision) {
+    fail(lineNo, `'do' data key "type" collides with the command type (the leading token); rename it`);
+  }
+  return { kind: "command", commands: [command] };
+}
+__name(parseDo, "parseDo");
+function parseSay(line, lineNo, speakers) {
+  let speaker;
+  let expression;
+  let body = line;
+  const colon = line.indexOf(":");
+  if (colon !== -1) {
+    const header = line.slice(0, colon).trim();
+    const tokens = header.length > 0 ? header.split(/\s+/) : [];
+    const first = tokens[0];
+    if (first !== void 0 && Object.hasOwn(speakers, first)) {
+      if (tokens.length > 2) {
+        fail(lineNo, `speaker header "${header}" has too many tokens (use "speaker [face]: text")`);
+      }
+      speaker = first;
+      expression = tokens[1];
+      body = line.slice(colon + 1).trimStart();
+    }
+  }
+  const { text, fields, meta } = peelSayHints(body, lineNo);
+  return {
+    kind: "say",
+    ...speaker !== void 0 ? { speaker } : {},
+    ...expression !== void 0 ? { expression } : {},
+    text,
+    ...fields,
+    ...meta ? { meta } : {}
+  };
+}
+__name(parseSay, "parseSay");
+function peelSayHints(body, lineNo) {
+  let rest = body;
+  const fields = {};
+  const meta = {};
+  let metaCount = 0;
+  for (; ; ) {
+    const hash = /(^|\s)#(\S+)\s*$/.exec(rest);
+    if (hash) {
+      const tag = hash[2];
+      const lk = lineKey(tag);
+      if (lk !== void 0) fields.key = lk;
+      else metaCount += applyHashtag(meta, tag);
+      rest = rest.slice(0, hash.index).replace(/\s+$/, "");
+      continue;
+    }
+    const hint = /(^|\s)(view|voice|speed|auto)=(\S+)\s*$/.exec(rest);
+    if (hint) {
+      applySayField(fields, hint[2], hint[3], lineNo);
+      rest = rest.slice(0, hint.index).replace(/\s+$/, "");
+      continue;
+    }
+    break;
+  }
+  return { text: rest, fields, meta: metaCount > 0 ? meta : void 0 };
+}
+__name(peelSayHints, "peelSayHints");
+function applySayField(fields, key, value, lineNo) {
+  switch (key) {
+    case "view":
+      fields.view = unquote(value);
+      return;
+    case "voice":
+      fields.voice = unquote(value);
+      return;
+    case "speed":
+      fields.speed = numberHint(value, lineNo, "speed");
+      return;
+    case "auto":
+      fields.autoAdvanceMs = numberHint(value, lineNo, "auto");
+      return;
+  }
+}
+__name(applySayField, "applySayField");
+function numberHint(value, lineNo, key) {
+  const n = Number(value);
+  if (!Number.isFinite(n)) fail(lineNo, `'${key}=' expects a number, got "${value}"`);
+  return n;
+}
+__name(numberHint, "numberHint");
+function parseChoice(body, lineNo) {
+  let rest = body;
+  const meta = {};
+  let metaCount = 0;
+  let once = false;
+  let disabled = false;
+  let target;
+  let condition;
+  let key;
+  for (; ; ) {
+    const hash = /(^|\s)#(\S+)\s*$/.exec(rest);
+    if (!hash) break;
+    const tag = hash[2];
+    const lk = lineKey(tag);
+    if (tag === "once") once = true;
+    else if (tag === "disabled") disabled = true;
+    else if (lk !== void 0) key = lk;
+    else metaCount += applyHashtag(meta, tag);
+    rest = rest.slice(0, hash.index).replace(/\s+$/, "");
+  }
+  const arrow = /(^|\s)->\s*(\S+)\s*$/.exec(rest);
+  const named = arrow ? null : /(^|\s)target=(\S+)\s*$/.exec(rest);
+  if (arrow) {
+    target = arrow[2];
+    rest = rest.slice(0, arrow.index).replace(/\s+$/, "");
+  } else if (named) {
+    target = named[2];
+    rest = rest.slice(0, named.index).replace(/\s+$/, "");
+  }
+  const ifm = /(^|\s)if:\s*(.+)$/.exec(rest);
+  if (ifm) {
+    const condStr = ifm[2].trim();
+    if (!condStr) fail(lineNo, "choice 'if:' has no condition");
+    condition = parseExpr(condStr);
+    rest = rest.slice(0, ifm.index).replace(/\s+$/, "");
+  }
+  const text = rest.trim();
+  if (!text) fail(lineNo, "choice has no text");
+  const unknown = firstUnknownTag(text);
+  if (unknown !== null) {
+    fail(
+      lineNo,
+      `unrecognized markup tag "[${unknown}]" in choice text \u2014 '[..]' is for inline markup only; write choice attributes as 'if: \u2026', '-> node', or '#flag'`
+    );
+  }
+  return {
+    text,
+    ...key !== void 0 ? { key } : {},
+    ...condition !== void 0 ? { condition } : {},
+    ...target !== void 0 ? { target } : {},
+    ...once ? { once: true } : {},
+    ...disabled ? { presentation: "disabled" } : {},
+    ...metaCount > 0 ? { meta } : {}
+  };
+}
+__name(parseChoice, "parseChoice");
+function applyHashtag(meta, tag) {
+  const colon = tag.indexOf(":");
+  if (colon === -1) meta[tag] = true;
+  else meta[tag.slice(0, colon)] = scalar(tag.slice(colon + 1));
+  return 1;
+}
+__name(applyHashtag, "applyHashtag");
+function lineKey(tag) {
+  const colon = tag.indexOf(":");
+  return colon > 0 && tag.slice(0, colon) === "line" ? tag.slice(colon + 1) : void 0;
+}
+__name(lineKey, "lineKey");
+var NOT_LITERAL = /* @__PURE__ */ Symbol("not-literal");
+function numberBoolNull(raw) {
+  if (/^-?\d+(?:\.\d+)?$/.test(raw)) return Number(raw);
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  if (raw === "null") return null;
+  return NOT_LITERAL;
+}
+__name(numberBoolNull, "numberBoolNull");
+function scalar(raw) {
+  const lit = numberBoolNull(raw);
+  return lit === NOT_LITERAL ? unquote(raw) : lit;
+}
+__name(scalar, "scalar");
+function unquote(raw) {
+  if (raw.length >= 2 && (raw.startsWith('"') && raw.endsWith('"') || raw.startsWith("'") && raw.endsWith("'"))) {
+    return raw.slice(1, -1);
+  }
+  return raw;
+}
+__name(unquote, "unquote");
+function splitArgs(s) {
+  const out = [];
+  let i = 0;
+  while (i < s.length) {
+    while (i < s.length && /\s/.test(s[i])) i++;
+    if (i >= s.length) break;
+    let tok = "";
+    while (i < s.length && !/\s/.test(s[i])) {
+      const c = s[i];
+      if (c === '"' || c === "'") {
+        tok += c;
+        i++;
+        while (i < s.length && s[i] !== c) tok += s[i++];
+        if (i < s.length) tok += s[i++];
+      } else {
+        tok += c;
+        i++;
+      }
+    }
+    out.push(tok);
+  }
+  return out;
+}
+__name(splitArgs, "splitArgs");
+function fail(lineNo, message) {
+  throw new DialogueScriptError(`compact: line ${lineNo}: ${message}`);
+}
+__name(fail, "fail");
+
+// src/core/defineScript.ts
+function defineScript(script) {
+  return script;
+}
+__name(defineScript, "defineScript");
+
+// src/core/runner.ts
+var DialogueRunner = class {
+  constructor(script, env, handlers) {
+    this.script = script;
+    this.handlers = handlers;
+    this.nodeId = script.start;
+    this.storage = env.storage;
+    this.scope = createScope(env.storage, env.functions);
+    this.onError = env.onError;
+  }
+  script;
+  handlers;
+  static {
+    __name(this, "DialogueRunner");
+  }
+  /** `option.once` keys already picked — per-conversation **cursor** state, NOT
+   *  the variable storage. Fresh per runner, so a new `play()` starts it empty
+   *  (a re-played conversation re-shows its `once` options; {@link getChosenOnce}
+   *  exposes the set so a save cursor could capture/restore it). */
+  chosenOnce = /* @__PURE__ */ new Set();
+  nodeId;
+  stepIndex = 0;
+  state = "idle";
+  /** "play" normally; `skip()` flips it to "skip" to fast-forward the section. */
+  runMode = "play";
+  /** Storage (write through this so a read-only `cells` accessor throws) +
+   *  functions, wrapped once as the condition/`set`-value eval scope. */
+  storage;
+  scope;
+  onError;
+  /** Snapshot of the storage's variables — the `handle.getVars()` /
+   *  future save-cursor view. */
+  getVars() {
+    return materialize(this.storage);
+  }
+  // ── save seam (read-only cursor getters) ──────────────────────────────────
+  // The runner's durable cursor is (nodeId, stepIndex, chosenOnce) + getVars().
+  // These getters exist so a future `SnapshotContributor` can capture/restore a
+  // conversation WITHOUT a breaking API change. Snapshot/restore itself is
+  // deliberately NOT built yet — keep these read-only.
+  /** Current node id (durable cursor; save seam). */
+  getNodeId() {
+    return this.nodeId;
+  }
+  /** Current step index within the node (durable cursor; save seam). */
+  getStepIndex() {
+    return this.stepIndex;
+  }
+  /** One-shot choice keys already picked (`option.once`); save seam. */
+  getChosenOnce() {
+    return this.chosenOnce;
+  }
+  isEnded() {
+    return this.state === "ended";
+  }
+  /** Begin at the start node. Idempotent guard against double-start. The cursor
+   *  (`nodeId`/`stepIndex`) is already at the start from the ctor + field init. */
+  start() {
+    if (this.state !== "idle") return;
+    void this.run();
+  }
+  /** Advance past the current `say` line. No-op unless we're awaiting it. */
+  advance() {
+    if (this.state !== "saying") return;
+    this.stepIndex++;
+    void this.run();
+  }
+  /**
+   * Fast-forward from the current line: run intervening commands in `skip` mode
+   * (so the game can reconstruct world state idempotently) without presenting
+   * any lines, stopping at the next choice or the end. No-op unless on a line.
+   */
+  async skip() {
+    if (this.state !== "saying") return;
+    this.runMode = "skip";
+    this.stepIndex++;
+    await this.run();
+  }
+  /**
+   * Public, **wait-state-free** entry the Session uses to fire a `say` line's
+   * commands at show / after-reveal / advance time. Handles built-in `set`,
+   * surfaces the rest with the current mode (or `mode`, when the Session fires the
+   * displayed line's batches as part of its own skip), and awaits `blocking` ones.
+   * Delegates to {@link executeBatch}; the runner's wait-state is untouched (the
+   * Session gates its own input).
+   */
+  runCommands(commands, mode) {
+    return this.executeBatch(commands, mode);
+  }
+  /** Pick choice `index` (the original option index). */
+  async choose(index) {
+    if (this.state !== "choosing") return;
+    const step = this.currentStep();
+    if (!step || step.kind !== "choice") return;
+    const option = step.options[index];
+    if (!option || !this.choiceEnabled(step, index, option)) return;
+    if (option.once) this.chosenOnce.add(this.onceKey(step, index));
+    this.state = "awaiting-command";
+    await this.fireBatch(option.commands);
+    if (this.isEnded()) return;
+    if (option.target !== void 0) this.jump(option.target);
+    else this.stepIndex++;
+    void this.run();
+  }
+  // ── internal ────────────────────────────────────────────────────────────
+  /** Run non-blocking steps until we hit one that needs input, or the end. */
+  async run() {
+    for (; ; ) {
+      if (this.isEnded()) return;
+      const step = this.currentStep();
+      if (!step) {
+        this.end();
+        return;
+      }
+      if (await this.handleStep(step)) return;
+    }
+  }
+  /** @returns true if the step blocks (waiting for advance/choose/command/end). */
+  async handleStep(step) {
+    switch (step.kind) {
+      case "say": {
+        if (this.runMode === "skip") {
+          await this.fireBatch(step.commands);
+          if (this.isEnded()) return true;
+          this.stepIndex++;
+          return false;
+        }
+        this.state = "saying";
+        this.handlers.onSay(step, this.speaker(step.speaker));
+        return true;
+      }
+      case "choice": {
+        const choices = this.resolveChoices(step);
+        if (!choices.some((c) => !c.disabled)) {
+          this.stepIndex++;
+          return false;
+        }
+        this.runMode = "play";
+        this.state = "choosing";
+        this.handlers.onChoice(step, choices, this.speaker(step.speaker));
+        return true;
+      }
+      case "command": {
+        await this.fireBatch(step.commands);
+        if (this.state === "ended") return true;
+        if (step.target !== void 0 && this.test(step.condition)) {
+          this.jump(step.target);
+          return false;
+        }
+        this.stepIndex++;
+        return false;
+      }
+      case "goto":
+        this.jump(step.target);
+        return false;
+      case "end":
+        this.end();
+        return true;
+    }
+  }
+  jump(target) {
+    this.nodeId = target;
+    this.stepIndex = 0;
+  }
+  end() {
+    if (this.state === "ended") return;
+    this.state = "ended";
+    this.handlers.onEnd();
+  }
+  currentStep() {
+    return this.script.nodes[this.nodeId]?.steps[this.stepIndex];
+  }
+  speaker(id) {
+    return id ? this.script.speakers?.[id] : void 0;
+  }
+  /**
+   * Resolve a choice step to its visible rows. A spent `once` option is always
+   * dropped (presentation governs condition failures only). A passing option is
+   * enabled; a failing one is returned as a `disabled` row when its
+   * `presentation` is `"disabled"`, else dropped (the default `"hidden"`).
+   */
+  resolveChoices(step) {
+    const out = [];
+    step.options.forEach((option, index) => {
+      if (this.isSpent(step, index)) return;
+      if (this.test(option.condition)) out.push({ index, option });
+      else if (option.presentation === "disabled") out.push({ index, option, disabled: true });
+    });
+    return out;
+  }
+  /** Whether option `index` can actually be picked — the gate `choose()` uses.
+   *  A spent `once` option or a failing condition refuses (a `"disabled"` row is
+   *  shown but still unpickable, so this stays the single selection authority). */
+  choiceEnabled(step, index, option) {
+    return !this.isSpent(step, index) && this.test(option.condition);
+  }
+  /** A `once` option already chosen this run — always dropped from the menu
+   *  regardless of `presentation`. Single source of truth for the once-gate,
+   *  shared by `resolveChoices` and `choiceEnabled`. Reads the option from
+   *  `step.options[index]`, so `(step, index)` is the only input. */
+  isSpent(step, index) {
+    const option = step.options[index];
+    return option?.once === true && this.chosenOnce.has(this.onceKey(step, index));
+  }
+  onceKey(step, index) {
+    return `${this.nodeId}#${this.stepIndex}#${index}#${step.options[index]?.text ?? ""}`;
+  }
+  /**
+   * Fire an inline command batch (a `command` step or a chosen option). Manages
+   * wait-state: enters `awaiting-command` up front when the batch contains a
+   * blocking command, so a stray advance/confirm during the await is ignored; the
+   * caller transitions out of the state afterwards. The work itself goes through
+   * the wait-state-free {@link executeBatch}.
+   */
+  async fireBatch(commands) {
+    if (!commands || commands.length === 0) return;
+    if (commands.some((c) => c.blocking)) this.state = "awaiting-command";
+    await this.executeBatch(commands);
+  }
+  /**
+   * The wait-state-free command executor, shared by {@link fireBatch} (inline
+   * firing) and {@link runCommands} (the Session's line-timed firing). Applies
+   * built-in `set`; surfaces the rest to the host with the current mode; awaits
+   * `blocking` handlers and fire-and-forgets the others. Touches no wait-state.
+   */
+  async executeBatch(commands, mode = this.runMode) {
+    if (!commands) return;
+    for (const cmd of commands) {
+      if (cmd.type === "set" && typeof cmd.var === "string") {
+        const value = cmd.value;
+        const next = isExpr(value) ? evaluate(value, this.scope) : value;
+        try {
+          this.storage.set(cmd.var, next);
+        } catch (e) {
+          this.onError?.(
+            `ignored "set ${cmd.var}": ${e instanceof Error ? e.message : String(e)}`,
+            e
+          );
+        }
+        continue;
+      }
+      let result;
+      try {
+        result = this.handlers.onCommand(cmd, this.commandContext(mode));
+      } catch {
+        continue;
+      }
+      if (!isPromise(result)) continue;
+      if (cmd.blocking) {
+        try {
+          await result;
+        } catch {
+        }
+        if (this.isEnded()) return;
+      } else {
+        void Promise.resolve(result).catch(() => {
+        });
+      }
+    }
+  }
+  /** The context handed to a command handler. `setVar` writes through the
+   *  conversation's storage (guarded by the session for staleness), the same
+   *  path as the `set` built-in — so the skill-check seam and `set` share one
+   *  guarded write. */
+  commandContext(mode) {
+    return { mode, setVar: /* @__PURE__ */ __name((name, value) => this.storage.set(name, value), "setVar") };
+  }
+  test(condition) {
+    return holds(condition, this.scope);
+  }
+};
+function isPromise(v) {
+  return typeof v === "object" && v !== null && typeof v.then === "function";
+}
+__name(isPromise, "isPromise");
+
+// src/core/session.ts
+var EMPTY_VARS = Object.freeze({});
+var DialogueSession = class {
+  constructor(channels, opts = {}) {
+    this.channels = channels;
+    this.opts = opts;
+    this.i18n = opts.i18n ?? new IdentityI18n();
+    this.skipMul = opts.skipMultiplier ?? 4;
+    this.defaultStorage = opts.storage ?? new MemoryVariableStorage();
+    this.defaultFunctions = opts.functions ?? {};
+    this.defaultCommands = opts.commands ?? {};
+    this.defaultFallback = opts.fallbackCommand;
+    this.channels.text.setRevealListener(() => this.handleRevealComplete());
+    this.channels.text.setBeatListener((beat) => this.handleRevealBeat(beat));
+    this.channels.choices.onChoiceChosen = (position) => this.confirmAt(position);
+  }
+  channels;
+  opts;
+  static {
+    __name(this, "DialogueSession");
+  }
+  i18n;
+  skipMul;
+  /** Controller-installed environment (persists across plays); per-`play()`
+   *  overrides are layered on top into the resolved fields below. */
+  defaultStorage;
+  defaultFunctions;
+  defaultCommands;
+  defaultFallback;
+  // Resolved per play() (controller install + call-site overrides).
+  storage;
+  functions = {};
+  commands = {};
+  fallbackCommand;
+  // Fields use explicit `| undefined` (not `?`) so reassigning `undefined`
+  // (e.g. `stop()` nulling the cursor) is legal under the repo's
+  // `exactOptionalPropertyTypes`.
+  runner;
+  script;
+  mode = "idle";
+  scriptId = "";
+  saying;
+  autoTimer;
+  /** Default auto-advance delay (ms) applied to lines without their own
+   *  `autoAdvanceMs`. `null` = off (manual advance). Set via {@link setAutoAdvance}. */
+  autoAdvanceDefault = null;
+  resolved = [];
+  selected = 0;
+  /** Count of in-flight blocking line-command batches (show/afterReveal/advance).
+   *  Input is gated while > 0. An ownership counter (not a shared boolean) so an
+   *  overlapping batch resolving — e.g. the afterReveal batch finishing while a
+   *  long blocking `show` command is still awaited — can't drop a gate it
+   *  doesn't own. */
+  blockedCount = 0;
+  /** True between an advance request and the runner stepping off the line —
+   *  guards against a second advance double-firing `advance`-timed commands. */
+  advancing = false;
+  /** True once the current line's `advance`-timed commands have fired, so a
+   *  second advance() while the runner is still stepping (e.g. awaiting a
+   *  blocking command step) can't re-fire them against the stale line. */
+  advanceFired = false;
+  /** True once the current line's `afterReveal`-timed commands have fired
+   *  (normally via handleRevealComplete; skip() fires them early when the line
+   *  hasn't finished revealing). */
+  afterRevealFired = false;
+  /** Latched by the first confirm() until the runner produces its next state
+   *  (handleSay/handleChoice/handleEnd), so mashing confirm while the runner
+   *  awaits the option's blocking commands can't emit duplicate onChoiceMade
+   *  events (`mode` stays "choosing" for that whole window). */
+  confirming = false;
+  /** Bumped by every stop()/play(). A suspended async continuation from a prior
+   *  conversation captures this and bails on resume if it changed, so it can't
+   *  drive (advance / show the caret on) the runner of a *new* conversation. */
+  generation = 0;
+  // ── lifecycle levers — host-level, NOT conversation state ──────────────
+  /** `setHidden` — visual only; gates every channel's `setVisible`. Survives
+   *  `stop()`/`play()` (a host that hides for a cutscene and forgets to unhide
+   *  gets what it asked for) — so it is deliberately NOT reset by `stop()`. */
+  hidden = false;
+  /** `setPaused` — freezes the update loop AND the input-agnostic API. State is
+   *  left fully intact (no generation bump); also host-level, survives replays. */
+  paused = false;
+  /** Whether the chrome / body text are part of the CURRENT choice's layout
+   *  (false when a self-contained bubble panel owns the prompt) — remembered so
+   *  {@link applyVisibility} can recompute after a hide toggle mid-choice. */
+  choiceShowsChrome = false;
+  choiceShowsBody = false;
+  /** Plain (speaker, text) of the line on screen — for the reveal-completed
+   *  event, which fires after `present` has discarded the resolved string. */
+  currentLine;
+  /** The full {@link PresentedLine} on screen — handed to an extra channel's
+   *  `revealComplete` (the session discards the local `line` after present). */
+  currentPresented;
+  /** Host-registered extra channels (Voice / Shop / CameraEffects / History).
+   *  The session fans its cross-cutting stream to these alongside the typed trio
+   *  and folds their `isRevealComplete()` into the auto-advance gate. */
+  extras = [];
+  /**
+   * Begin a conversation. `play(script)` is **content-only** — the storage,
+   * functions, and commands are installed on the session; `overrides` layers
+   * per-conversation specifics on top (a scoped `storage`, extra `functions` /
+   * `commands`). Declared defaults seed into the storage **only if absent**
+   * (game-linked values win); variables persist across plays. Returns a
+   * generation-stamped {@link DialogueHandle} for live `setVar` / `getVars`.
+   */
+  play(rawScript, overrides) {
+    const script = loadScript(rawScript);
+    const analysis = analyzeScript(script);
+    const storage = overrides?.storage ?? this.defaultStorage;
+    const functions = { ...this.defaultFunctions, ...overrides?.functions };
+    const commands = { ...this.defaultCommands, ...overrides?.commands };
+    const fallbackCommand = overrides?.fallbackCommand ?? this.defaultFallback;
+    validatePlay(analysis, { storage, functions, commands, fallbackCommand });
+    for (const [name, value] of Object.entries(script.declare ?? {})) {
+      if (storage.has(name)) continue;
+      try {
+        storage.set(name, value);
+      } catch (cause) {
+        const detail = cause instanceof Error ? cause.message : String(cause);
+        throw new DialoguePlayError(
+          `cannot seed declared default "${name}": ${detail} (a read-only / pure cells() storage has no writable slot \u2014 compose it with a MemoryVariableStorage)`
+        );
+      }
+    }
+    this.stop();
+    this.script = script;
+    this.scriptId = script.id;
+    this.storage = storage;
+    this.functions = functions;
+    this.commands = commands;
+    this.fallbackCommand = fallbackCommand;
+    const gen = this.generation;
+    const live = /* @__PURE__ */ __name(() => gen === this.generation, "live");
+    const guarded = {
+      get: /* @__PURE__ */ __name((name) => storage.get(name), "get"),
+      set: /* @__PURE__ */ __name((name, value) => {
+        if (live()) storage.set(name, value);
+      }, "set"),
+      has: /* @__PURE__ */ __name((name) => storage.has(name), "has"),
+      entries: /* @__PURE__ */ __name(() => storage.entries(), "entries")
+    };
+    const runner = new DialogueRunner(
+      script,
+      { storage: guarded, functions, onError: this.opts.onError },
+      {
+        onSay: /* @__PURE__ */ __name((step, speaker) => {
+          if (live()) this.handleSay(step, speaker);
+        }, "onSay"),
+        onChoice: /* @__PURE__ */ __name((step, choices, speaker) => {
+          if (live()) this.handleChoice(step, choices, speaker);
+        }, "onChoice"),
+        onCommand: /* @__PURE__ */ __name((command, ctx) => live() ? this.handleCommand(command, ctx) : void 0, "onCommand"),
+        onEnd: /* @__PURE__ */ __name(() => {
+          if (live()) this.handleEnd();
+        }, "onEnd")
+      }
+    );
+    this.runner = runner;
+    this.opts.onStarted?.({ scriptId: this.scriptId });
+    runner.start();
+    return {
+      setVar: /* @__PURE__ */ __name((name, value) => guarded.set(name, value), "setVar"),
+      getVars: /* @__PURE__ */ __name(() => gen === this.generation ? materialize(storage) : EMPTY_VARS, "getVars")
+    };
+  }
+  isActive() {
+    return this.mode === "saying" || this.mode === "choosing";
+  }
+  isChoosing() {
+    return this.mode === "choosing";
+  }
+  /**
+   * Register an extra channel (Voice / Shop / CameraEffects / History) — the
+   * open-ended companion to the built-in trio. It receives the cross-cutting
+   * stream (`present` / `command` / `clear` / `setVisible` / `setPaused` /
+   * `completeReveal` / `update`) and can gate auto-advance via
+   * `isRevealComplete()`. Returns a disposer that unregisters **and** disposes
+   * it. On register the channel catches up the current `setVisible` / `setPaused`
+   * lever state ONLY — no content replay (replaying `present` would re-trigger a
+   * voice clip). Safe to call mid-conversation.
+   */
+  addChannel(ch) {
+    this.extras.push(ch);
+    try {
+      ch.setVisible?.(!this.hidden);
+    } catch (error) {
+      this.opts.onError?.("dialogue: channel setVisible() failed", error);
+    }
+    try {
+      ch.setPaused?.(this.paused);
+    } catch (error) {
+      this.opts.onError?.("dialogue: channel setPaused() failed", error);
+    }
+    let disposed = false;
+    return () => {
+      if (disposed) return;
+      disposed = true;
+      const i = this.extras.indexOf(ch);
+      if (i >= 0) this.extras.splice(i, 1);
+      try {
+        ch.dispose?.();
+      } catch (error) {
+        this.opts.onError?.("dialogue: channel dispose() failed", error);
+      }
+    };
+  }
+  // ── lifecycle levers ──────────────────────────────────────────────────
+  /**
+   * Hide or show the whole dialogue UI — purely visual, state-preserving.
+   * Drives every channel's `setVisible`; the conversation keeps running
+   * underneath (reveal, timers, cursor intact). Host-level and **persistent**:
+   * it survives `stop()` and the next `play()`, so a cutscene that hides and
+   * forgets to unhide stays hidden — call `setHidden(false)` to restore.
+   */
+  setHidden(hidden) {
+    this.hidden = hidden;
+    this.applyVisibility();
+  }
+  /** True while the UI is hidden via {@link setHidden}. */
+  isHidden() {
+    return this.hidden;
+  }
+  /**
+   * Freeze or resume the conversation — `update()` no-ops (reveal,
+   * auto-advance clock, caret blink, avatar anim all freeze since they are
+   * dt-driven) and the input-agnostic API (`advance`/`confirm`/`choose`/
+   * `moveSelection`/`selectAt`/`skip`) no-ops. State is left fully intact: no
+   * generation bump, and `lineBlocked`/`advancing`/`autoTimer` survive. It does
+   * NOT block host-driven writes (`handle.setVar` / `ctx.setVar` / storage) —
+   * only player-facing time + input freeze. Host-level and persistent like hide.
+   */
+  setPaused(paused) {
+    this.paused = paused;
+    for (const ch of this.extras) {
+      try {
+        ch.setPaused?.(paused);
+      } catch (error) {
+        this.opts.onError?.("dialogue: channel setPaused() failed", error);
+      }
+    }
+  }
+  /** True while the conversation is frozen via {@link setPaused}. */
+  isPaused() {
+    return this.paused;
+  }
+  /**
+   * Push the current desired visibility to every channel: a channel shows when
+   * it has content for the current mode AND the host hasn't hidden the UI. The
+   * single visibility authority — `setHidden` and every line/choice transition
+   * route through here, so the host-hidden lever composes cleanly with per-line
+   * content and a custom chrome (which may not implement the optional `present`)
+   * is still reliably hidden by the explicit `setVisible(false)`.
+   */
+  applyVisibility() {
+    const shown = !this.hidden;
+    const saying = this.mode === "saying";
+    const choosing = this.mode === "choosing";
+    this.channels.text.setVisible(shown && (saying || choosing && this.choiceShowsBody));
+    this.channels.choices.setVisible(shown && choosing);
+    this.channels.chrome?.setVisible(shown && (saying || choosing && this.choiceShowsChrome));
+    this.channels.avatar?.setVisible?.(shown && (saying || choosing));
+    for (const ch of this.extras) {
+      try {
+        ch.setVisible?.(shown);
+      } catch (error) {
+        this.opts.onError?.("dialogue: channel setVisible() failed", error);
+      }
+    }
+  }
+  /** Clear every presentation channel's content — text, choices, chrome
+   *  (nameplate + caret + line), the avatar, and the registered extras. The
+   *  shared teardown for {@link stop} and the ended state; it touches no session
+   *  bookkeeping or visibility (the caller resets its own state, then
+   *  {@link goIdle} reasserts visibility). */
+  clearAllChannels() {
+    this.channels.text.clear();
+    this.channels.choices.clear();
+    this.channels.chrome?.setContinueVisible(false);
+    this.channels.chrome?.setNameplate(void 0);
+    this.channels.chrome?.present?.(void 0);
+    this.channels.avatar?.setSpeaker(void 0);
+    this.channels.avatar?.setSpeaking(false);
+    this.channels.avatar?.present?.(void 0);
+    for (const ch of this.extras) {
+      try {
+        ch.clear?.();
+      } catch (error) {
+        this.opts.onError?.("dialogue: channel clear() failed", error);
+      }
+    }
+  }
+  /** Drop to a quiescent presentation state (`mode` "idle" or "ended"): reset the
+   *  per-line/choice bookkeeping, clear every channel, and reassert visibility
+   *  (idle/ended → nothing shown, honestly via each channel's `setVisible`,
+   *  preserving the host-hidden lever). The caller owns any further reset —
+   *  {@link stop} also abandons the runner + timing latches. */
+  goIdle(mode) {
+    this.mode = mode;
+    this.saying = void 0;
+    this.resolved = [];
+    this.confirming = false;
+    this.currentLine = void 0;
+    this.currentPresented = void 0;
+    this.choiceShowsChrome = false;
+    this.choiceShowsBody = false;
+    this.clearAllChannels();
+    this.applyVisibility();
+  }
+  /** Abandon the current conversation and reset to idle (clears all visuals).
+   *  Useful for ambient/eavesdrop dialogue that should stop when out of range. */
+  stop() {
+    this.generation++;
+    this.runner = void 0;
+    this.autoTimer = void 0;
+    this.blockedCount = 0;
+    this.advancing = false;
+    this.advanceFired = false;
+    this.afterRevealFired = false;
+    this.goIdle("idle");
+  }
+  update(dt) {
+    if (this.paused) return;
+    this.channels.text.update(dt);
+    this.channels.chrome?.update(dt);
+    this.channels.avatar?.update(dt);
+    for (const ch of this.extras) {
+      try {
+        ch.update?.(dt);
+      } catch (error) {
+        this.opts.onError?.("dialogue: channel update() failed", error);
+      }
+    }
+    if (!this.runner || this.mode !== "saying") return;
+    if (this.autoTimer !== void 0 && this.allRevealsComplete()) {
+      this.autoTimer -= dt;
+      if (this.autoTimer <= 0 && !this.lineBlocked && !this.advancing) {
+        this.autoTimer = void 0;
+        this.opts.onAutoAdvance?.({ scriptId: this.scriptId });
+        this.advance();
+      }
+    }
+  }
+  /** True while any blocking line-command batch is awaited (input is gated). */
+  get lineBlocked() {
+    return this.blockedCount > 0;
+  }
+  /**
+   * The auto-advance gate: the text reveal AND every registered extra channel
+   * that *gates* (implements `isRevealComplete`) report complete. The clock is
+   * armed on the text reveal alone (see `handleRevealComplete`/`setAutoAdvance`)
+   * but only counts down once this is true — so a voice clip outlasting the
+   * typewriter holds the line for `max(clipEnd, revealEnd)` with no duration
+   * plumbing. A channel without the method never gates (a pure observer).
+   */
+  allRevealsComplete() {
+    if (!this.channels.text.isRevealComplete()) return false;
+    for (const ch of this.extras) {
+      if (ch.isRevealComplete && !ch.isRevealComplete()) return false;
+    }
+    return true;
+  }
+  /**
+   * The storage read view for `{token}` interpolation at *this* present-time.
+   * Materialized per evaluation so an earlier command's `set` shows up on a
+   * later line; already-shown lines never re-render.
+   */
+  readView() {
+    return this.storage ? materialize(this.storage) : {};
+  }
+  // ── input-agnostic API ────────────────────────────────────────────────────
+  /** Primary action. Saying → reveal-all if typing, else next line. Choosing → confirm. */
+  advance() {
+    if (this.paused) return;
+    if (this.lineBlocked || this.advancing) return;
+    if (this.mode === "saying") {
+      if (this.channels.text.isRevealing()) {
+        this.channels.text.completeReveal();
+        for (const ch of this.extras) {
+          try {
+            ch.completeReveal?.();
+          } catch (error) {
+            this.opts.onError?.("dialogue: channel completeReveal() failed", error);
+          }
+        }
+      } else void this.advanceLine();
+    } else if (this.mode === "choosing") {
+      this.confirm();
+    }
+  }
+  /** Fire any `advance`-timed line commands, then step the runner off the line.
+   *  `advancing` is held for the whole turn so a second advance can't re-fire
+   *  the (possibly non-blocking) `advance` commands before the runner steps. */
+  async advanceLine() {
+    const gen = this.generation;
+    this.advancing = true;
+    try {
+      if (!this.advanceFired) {
+        this.advanceFired = true;
+        await this.fireLineCommands("advance");
+      }
+      if (gen !== this.generation || this.mode !== "saying") return;
+      this.runner?.advance();
+    } finally {
+      if (gen === this.generation) this.advancing = false;
+    }
+  }
+  /**
+   * Fast-forward the current section: run intervening commands (in skip mode)
+   * without presenting, stopping at the next choice or the end. No-op unless a
+   * line is showing.
+   */
+  skip() {
+    if (this.paused) return;
+    if (this.mode !== "saying" || this.lineBlocked || this.advancing) return;
+    this.opts.onSkipUsed?.({ scriptId: this.scriptId });
+    for (const ch of this.extras) {
+      try {
+        ch.completeReveal?.();
+      } catch (error) {
+        this.opts.onError?.("dialogue: channel completeReveal() failed", error);
+      }
+    }
+    void this.skipLine();
+  }
+  /**
+   * Fire the *displayed* line's not-yet-fired batches in skip mode — the runner
+   * fires every skipped line's commands for world reconstruction, so dropping
+   * the current line's `afterReveal`/`advance` batches would diverge from
+   * normal play — then fast-forward the runner.
+   */
+  async skipLine() {
+    const gen = this.generation;
+    this.advancing = true;
+    try {
+      if (!this.afterRevealFired) {
+        this.afterRevealFired = true;
+        await this.fireLineCommands("afterReveal", "skip");
+        if (gen !== this.generation || this.mode !== "saying") return;
+      }
+      if (!this.advanceFired) {
+        this.advanceFired = true;
+        await this.fireLineCommands("advance", "skip");
+        if (gen !== this.generation || this.mode !== "saying") return;
+      }
+      await this.runner?.skip();
+    } finally {
+      if (gen === this.generation) this.advancing = false;
+    }
+  }
+  /**
+   * Side-effect-free lookahead: the lines a node would show along its linear
+   * path — following `goto` and conditional `command` jumps using the *current*
+   * variable snapshot — stopping at the first choice or the end. Runs no
+   * commands and mutates nothing. For a "skip with a summary" affordance.
+   */
+  preview(nodeId, limit = 64) {
+    const script = this.script;
+    const storage = this.storage;
+    if (!script || !storage) return [];
+    const view = materialize(storage);
+    const scope = createScope(storage, this.functions);
+    const out = [];
+    let node = nodeId;
+    let i = 0;
+    for (let guard = 0; guard < limit; guard++) {
+      const step = script.nodes[node]?.steps[i];
+      if (!step) break;
+      if (step.kind === "say") {
+        const speaker = step.speaker ? script.speakers?.[step.speaker] : void 0;
+        const name = speaker ? this.i18n.t(speaker.nameKey, speaker.name, view) : void 0;
+        out.push({
+          speaker: name,
+          text: stripMarkup(this.i18n.t(step.key, step.text, view))
+        });
+        i++;
+      } else if (step.kind === "command") {
+        if (step.target !== void 0 && holds(step.condition, scope)) {
+          node = step.target;
+          i = 0;
+        } else {
+          i++;
+        }
+      } else if (step.kind === "goto") {
+        node = step.target;
+        i = 0;
+      } else {
+        break;
+      }
+    }
+    return out;
+  }
+  /** Move the choice cursor by `delta`, skipping disabled rows and wrapping.
+   *  No-op outside a choice, and a zero `delta` is a no-op (no cursor move, no
+   *  event). A move that steps over disabled rows fires exactly one
+   *  selection-changed event, for the row it lands on. */
+  moveSelection(delta) {
+    if (this.paused) return;
+    if (this.mode !== "choosing" || this.confirming) return;
+    if (this.resolved.length === 0 || delta === 0) return;
+    const dir = delta < 0 ? -1 : 1;
+    let pos = this.selected;
+    for (let i = 0; i < Math.abs(delta); i++) {
+      pos = this.nextEnabled(pos, dir);
+    }
+    if (pos === this.selected) return;
+    this.selected = pos;
+    this.channels.choices.highlight(this.selected);
+    this.emitSelectionChanged();
+  }
+  /** Highlight a choice by absolute position (e.g. pointer hover). No wrap;
+   *  a disabled row is skipped (the cursor stays put). */
+  selectAt(position) {
+    if (this.paused) return;
+    if (this.mode !== "choosing" || this.confirming) return;
+    const n = this.resolved.length;
+    if (n === 0 || position < 0 || position >= n || position === this.selected)
+      return;
+    if (this.resolved[position]?.disabled) return;
+    this.selected = position;
+    this.channels.choices.highlight(this.selected);
+    this.emitSelectionChanged();
+  }
+  /** The next enabled choice position from `from` in direction `dir` (±1),
+   *  wrapping. Returns `from` when no other enabled row exists (so a single
+   *  enabled option among disabled ones never moves). */
+  nextEnabled(from, dir) {
+    const n = this.resolved.length;
+    let pos = from;
+    for (let i = 0; i < n; i++) {
+      pos = (pos + dir + n) % n;
+      if (pos === from) break;
+      if (!this.resolved[pos]?.disabled) return pos;
+    }
+    return from;
+  }
+  /** Fire onSelectionChanged for the currently-highlighted choice (keyboard nav
+   *  and pointer hover both land here — one canonical selection event). */
+  emitSelectionChanged() {
+    const chosen = this.resolved[this.selected];
+    if (!chosen) return;
+    this.opts.onSelectionChanged?.({
+      index: chosen.index,
+      text: stripMarkup(
+        this.i18n.t(chosen.option.key, chosen.option.text, this.readView())
+      )
+    });
+  }
+  /** Commit the highlighted choice. */
+  confirm() {
+    this.commit(this.selected);
+  }
+  /** Commit by original option index (e.g. a direct pointer hit, or the
+   *  timed-choice recipe firing its default). Refuses an unknown or disabled
+   *  option. */
+  choose(optionIndex) {
+    this.commit(this.resolved.findIndex((c) => c.index === optionIndex));
+  }
+  /** Commit by display position (a pointer hit on a row). The position-keyed
+   *  counterpart to {@link choose}; refuses an out-of-range or disabled row.
+   *  Used by the pointer binding and the presenter pointer-commit seam. */
+  confirmAt(position) {
+    this.commit(position);
+  }
+  /**
+   * The single choice-commit authority: every commit path routes here after
+   * translating its argument to a display position. It guards (paused / not
+   * choosing / already confirming / a missing or disabled row), latches against a
+   * double-commit, fires `onChoiceMade`, and steps the runner. The latch (not the
+   * runner) is what guarantees a single commit: `mode` stays "choosing" while the
+   * runner awaits the option's blocking commands, so without it a second confirm
+   * would emit a duplicate `onChoiceMade`.
+   */
+  commit(position) {
+    if (this.paused) return;
+    if (this.mode !== "choosing" || this.confirming) return;
+    const chosen = this.resolved[position];
+    if (!chosen || chosen.disabled) return;
+    this.selected = position;
+    this.confirming = true;
+    const text = this.i18n.t(chosen.option.key, chosen.option.text, this.readView());
+    this.opts.onChoiceMade?.({ index: chosen.index, text });
+    this.runner?.choose(chosen.index);
+  }
+  /** Toggle hold-to-fast-forward; the text channel scales its reveal rate. */
+  setFastForward(on) {
+    this.channels.text.setSpeedMultiplier(on ? this.skipMul : 1);
+  }
+  /**
+   * Default auto-advance: lines without their own `autoAdvanceMs` advance `ms`
+   * after they finish revealing; `null` turns it off (manual advance). A
+   * per-line `autoAdvanceMs` always overrides this. Toggling it while a line is
+   * already sitting revealed arms/clears its timer immediately.
+   */
+  setAutoAdvance(ms) {
+    this.autoAdvanceDefault = ms;
+    if (this.mode === "saying" && this.saying?.autoAdvanceMs === void 0 && this.channels.text.isRevealComplete()) {
+      this.autoTimer = ms ?? void 0;
+    }
+  }
+  // ── runner handlers ─────────────────────────────────────────────────────
+  handleSay(step, speaker) {
+    this.mode = "saying";
+    this.saying = step;
+    this.autoTimer = void 0;
+    this.advanceFired = false;
+    this.afterRevealFired = false;
+    this.confirming = false;
+    const view = this.readView();
+    const resolved = this.i18n.t(step.key, step.text, view);
+    const line = {
+      speaker: this.speakerView(speaker, view),
+      text: parseMarkup(resolved),
+      speed: step.speed ?? 1,
+      view: step.view,
+      meta: step.meta,
+      voice: step.voice
+    };
+    this.channels.choices.clear();
+    this.channels.chrome?.setContinueVisible(false);
+    this.channels.chrome?.setNameplate(
+      this.speakerName(speaker, view),
+      speaker?.color
+    );
+    this.channels.avatar?.setSpeaker(speaker);
+    this.channels.avatar?.setExpression(step.expression);
+    this.channels.avatar?.setSpeaking(true);
+    this.channels.avatar?.present?.(line);
+    this.channels.chrome?.present?.(line);
+    this.channels.text.present(line);
+    this.currentPresented = line;
+    for (const ch of this.extras) {
+      try {
+        ch.present?.(line);
+      } catch (error) {
+        this.opts.onError?.("dialogue: channel present() failed", error);
+      }
+    }
+    const plain = stripMarkup(resolved);
+    this.currentLine = { speaker: this.speakerName(speaker, view), text: plain };
+    this.opts.onLine?.({ speaker: this.currentLine.speaker, text: plain });
+    this.applyVisibility();
+    void this.fireLineCommands("show");
+  }
+  handleChoice(step, choices, speaker) {
+    this.mode = "choosing";
+    this.resolved = choices;
+    const firstEnabled = choices.findIndex((c) => !c.disabled);
+    if (firstEnabled < 0) {
+      throw new Error("dialogue: choice step presented with no enabled option");
+    }
+    this.selected = firstEnabled;
+    this.confirming = false;
+    const view = this.readView();
+    const line = {
+      speaker: this.speakerView(speaker, view),
+      text: step.text ? parseMarkup(this.i18n.t(step.key, step.text, view)) : EMPTY_PARSED,
+      speed: 1,
+      view: step.view,
+      meta: step.meta
+    };
+    this.channels.avatar?.setSpeaker(speaker);
+    this.channels.avatar?.setExpression(void 0);
+    this.channels.avatar?.setSpeaking(false);
+    this.channels.avatar?.present?.(line);
+    const ctx = {
+      view: step.view,
+      speaker: line.speaker,
+      prompt: line.text,
+      meta: step.meta
+    };
+    const presenterOwnsPrompt = this.channels.choices.ownsPrompt?.(ctx) ?? false;
+    this.choiceShowsChrome = !presenterOwnsPrompt;
+    this.choiceShowsBody = !presenterOwnsPrompt && Boolean(step.text);
+    this.channels.chrome?.setContinueVisible(false);
+    if (presenterOwnsPrompt) {
+      this.channels.chrome?.present?.(void 0);
+      this.channels.text.clear();
+    } else {
+      this.channels.chrome?.setNameplate(
+        this.speakerName(speaker, view),
+        speaker?.color
+      );
+      this.channels.chrome?.present?.(line);
+      if (step.text) this.channels.text.present(line);
+      else this.channels.text.clear();
+    }
+    const labels = choices.map(
+      (c) => stripMarkup(this.i18n.t(c.option.key, c.option.text, view))
+    );
+    const presented = choices.map((c, i) => ({
+      label: labels[i],
+      meta: c.option.meta,
+      disabled: c.disabled,
+      // i18n-resolve the reason (interpolating {tokens}) only for disabled rows
+      // that carry one; there's no separate i18n key for it.
+      disabledReason: c.disabled && c.option.disabledReason !== void 0 ? stripMarkup(this.i18n.t(void 0, c.option.disabledReason, view)) : void 0
+    }));
+    this.channels.choices.present(presented, ctx);
+    this.channels.choices.highlight(this.selected);
+    this.applyVisibility();
+    this.opts.onChoiceShown?.({ options: labels });
+  }
+  handleCommand(command, ctx) {
+    this.opts.onCommand?.(command, ctx);
+    for (const ch of this.extras) {
+      try {
+        ch.command?.(command, ctx);
+      } catch (error) {
+        this.opts.onError?.("dialogue: channel command() failed", error);
+      }
+    }
+    const handler = this.commands[command.type] ?? this.fallbackCommand;
+    return handler?.(command, ctx);
+  }
+  handleEnd() {
+    this.goIdle("ended");
+    this.opts.onEnded?.({ scriptId: this.scriptId });
+  }
+  async handleRevealComplete() {
+    if (this.mode !== "saying") return;
+    const gen = this.generation;
+    this.channels.avatar?.setSpeaking(false);
+    if (!this.afterRevealFired) {
+      this.afterRevealFired = true;
+      await this.fireLineCommands("afterReveal");
+    }
+    if (gen !== this.generation || this.mode !== "saying") return;
+    this.channels.chrome?.setContinueVisible(true);
+    if (this.currentLine) this.opts.onRevealCompleted?.(this.currentLine);
+    const presented = this.currentPresented;
+    if (presented) {
+      for (const ch of this.extras) {
+        try {
+          ch.revealComplete?.(presented);
+        } catch (error) {
+          this.opts.onError?.("dialogue: channel revealComplete() failed", error);
+        }
+      }
+    }
+    const auto = this.saying?.autoAdvanceMs ?? this.autoAdvanceDefault;
+    if (auto !== null) this.autoTimer = auto;
+  }
+  /**
+   * Fan one reveal beat out — the per-line typewriter stream. Extras (Voice /
+   * CameraEffects / a typewriter-SFX channel) see the WHOLE stream via
+   * `revealBeat?`. A `tick` then reaches the host's `onRevealTick` callback; a
+   * `marker` reaches the avatar channel (which interprets `[expression=…/]`
+   * itself — the Session name-matches nothing) and the host's `onRevealMarker`.
+   */
+  handleRevealBeat(beat) {
+    for (const ch of this.extras) {
+      try {
+        ch.revealBeat?.(beat);
+      } catch (error) {
+        this.opts.onError?.("dialogue: channel revealBeat() failed", error);
+      }
+    }
+    if (beat.kind === "tick") {
+      this.opts.onRevealTick?.(beat.index);
+      return;
+    }
+    this.channels.avatar?.marker?.(beat.marker);
+    this.opts.onRevealMarker?.(beat.marker, beat.viaSkip);
+  }
+  /**
+   * Fire the current line's commands matching `at`, via the runner's command
+   * pipeline (so `set`/blocking behave identically). While a blocking one is
+   * awaited, `lineBlocked` gates input so the player can't advance through it.
+   * `mode` overrides the runner's run mode (skip() fires the displayed line's
+   * batches in skip mode).
+   */
+  async fireLineCommands(at, mode) {
+    const all = this.saying?.commands;
+    if (!all || !this.runner) return;
+    const batch = all.filter((c) => (c.at ?? "show") === at);
+    if (batch.length === 0) return;
+    const gen = this.generation;
+    const blocking = batch.some((c) => c.blocking);
+    if (blocking) this.blockedCount++;
+    try {
+      await this.runner.runCommands(batch, mode);
+    } finally {
+      if (blocking && gen === this.generation) this.blockedCount--;
+    }
+  }
+  speakerName(speaker, view) {
+    if (!speaker) return void 0;
+    return this.i18n.t(speaker.nameKey, speaker.name, view);
+  }
+  speakerView(speaker, view) {
+    if (!speaker) return void 0;
+    return {
+      id: speaker.id,
+      name: this.speakerName(speaker, view),
+      color: speaker.color
+    };
+  }
+};
+
+// src/core/channels/voice.ts
+function createVoiceChannel(opts) {
+  const { play, onSkip = "cut", livenessMs, onError } = opts;
+  const pauseClip = opts.pauseWithConversation ?? true;
+  let active;
+  let done = true;
+  let startToken = 0;
+  let elapsed = 0;
+  const stop = /* @__PURE__ */ __name(() => {
+    active?.stop();
+    active = void 0;
+    done = true;
+  }, "stop");
+  return {
+    present(line) {
+      active?.stop();
+      active = void 0;
+      startToken++;
+      elapsed = 0;
+      const id = line.voice;
+      if (id === void 0) {
+        done = true;
+        return;
+      }
+      done = false;
+      const token = startToken;
+      try {
+        active = play(id, () => {
+          if (token !== startToken) return;
+          done = true;
+          active = void 0;
+        });
+      } catch (error) {
+        done = true;
+        throw error;
+      }
+    },
+    completeReveal() {
+      if (onSkip === "ring") return;
+      stop();
+    },
+    setPaused(paused) {
+      if (!pauseClip) return;
+      if (paused) active?.pause?.();
+      else active?.resume?.();
+    },
+    update(dt) {
+      if (done || !livenessMs) return;
+      elapsed += dt;
+      if (elapsed >= livenessMs) {
+        done = true;
+        onError?.(
+          `voice clip exceeded the ${livenessMs}ms liveness budget without reporting its end; releasing the auto-advance gate`,
+          new Error("voice clip liveness cap")
+        );
+      }
+    },
+    clear() {
+      stop();
+    },
+    dispose() {
+      stop();
+    },
+    isRevealComplete() {
+      return done;
+    }
+  };
+}
+__name(createVoiceChannel, "createVoiceChannel");
+
+// src/DialogueController.ts
+var import_core2 = require("@yagejs/core");
+var import_input = require("@yagejs/input");
+
+// src/input/InputBinding.ts
+var DEFAULT_ACTIONS = {
+  advance: ["interact"],
+  speed: ["attack"],
+  up: ["move-up"],
+  down: ["move-down"]
+};
+var FULL_ACTIONS = {
+  ...DEFAULT_ACTIONS,
+  skip: ["skip"]
+};
+var CompositeInputBinding = class {
+  constructor(bindings) {
+    this.bindings = bindings;
+  }
+  bindings;
+  static {
+    __name(this, "CompositeInputBinding");
+  }
+  bind(input, session) {
+    for (const b of this.bindings) b.bind(input, session);
+  }
+  poll() {
+    for (const b of this.bindings) b.poll();
+  }
+  dispose() {
+    for (const b of this.bindings) b.dispose?.();
+  }
+};
+var KeyboardInputBinding = class {
+  /**
+   * @param skipHoldMs Hold the `skip` action this long before it fires (the
+   *   classic "hold to skip" confirm). `0` (default) fires on press.
+   */
+  constructor(actions = DEFAULT_ACTIONS, skipHoldMs = 0) {
+    this.actions = actions;
+    this.skipHoldMs = skipHoldMs;
+  }
+  actions;
+  skipHoldMs;
+  static {
+    __name(this, "KeyboardInputBinding");
+  }
+  input;
+  session;
+  /** Latch so a held skip fires once per hold, not every frame past threshold. */
+  skipFired = false;
+  bind(input, session) {
+    this.input = input;
+    this.session = session;
+  }
+  poll() {
+    const { input, session } = this;
+    if (!input || !session) return;
+    session.setFastForward(held(input, this.actions.speed));
+    this.pollSkip(input, session);
+    if (justPressed(input, this.actions.advance)) session.advance();
+    if (justPressed(input, this.actions.up)) session.moveSelection(-1);
+    else if (justPressed(input, this.actions.down)) session.moveSelection(1);
+  }
+  /** Fire skip once the action has been held `skipHoldMs` (hold-to-confirm),
+   *  re-arming only after it's released. */
+  pollSkip(input, session) {
+    const skip = this.actions.skip;
+    if (!skip) return;
+    const ready = skip.some(
+      (a) => input.isPressed(a) && input.isHeldFor(a, this.skipHoldMs)
+    );
+    if (ready) {
+      if (!this.skipFired) {
+        session.skip();
+        this.skipFired = true;
+      }
+    } else if (!held(input, skip)) {
+      this.skipFired = false;
+    }
+  }
+};
+function justPressed(input, actions) {
+  return actions.some((a) => input.isJustPressed(a));
+}
+__name(justPressed, "justPressed");
+function held(input, actions) {
+  return actions.some((a) => input.isPressed(a));
+}
+__name(held, "held");
+var PointerInputBinding = class {
+  static {
+    __name(this, "PointerInputBinding");
+  }
+  input;
+  session;
+  // Explicit `| undefined` so `dispose()` can null it (exactOptionalPropertyTypes).
+  unsub;
+  /** A primary-button press happened since the last poll (consumed in poll). */
+  clicked = false;
+  // Explicit `| undefined` (not `?:`) so the ctor can assign the possibly-
+  // undefined argument under `exactOptionalPropertyTypes`.
+  choices;
+  /** Pointer position at the last hover hit-test, so an unmoved pointer
+   *  doesn't re-run the hit-test every frame. */
+  lastX = Number.NaN;
+  lastY = Number.NaN;
+  /** Whether the previous poll saw a choice up (a fresh choice set must be
+   *  hit-tested even under a stationary pointer). */
+  wasChoosing = false;
+  constructor(choices) {
+    this.choices = choices;
+  }
+  bind(input, session) {
+    this.unsub?.();
+    this.input = input;
+    this.session = session;
+    this.unsub = input.onPointerDown((info) => {
+      if (info.button === 0) this.clicked = true;
+    });
+  }
+  /** Pointer position in the choice presenter's coordinate space. */
+  pointer(input) {
+    return this.choices?.pointerSpace === "world" ? input.getPointerPosition() : input.getPointerScreenPosition();
+  }
+  poll() {
+    const { input, session } = this;
+    if (!input || !session) return;
+    const choosing = session.isChoosing();
+    if (choosing && this.choices?.choiceAtPoint) {
+      const p = this.pointer(input);
+      if (!this.wasChoosing || p.x !== this.lastX || p.y !== this.lastY) {
+        this.lastX = p.x;
+        this.lastY = p.y;
+        const hovered = this.choices.choiceAtPoint(p.x, p.y);
+        if (hovered !== void 0) session.selectAt(hovered);
+      }
+    }
+    this.wasChoosing = choosing;
+    const clicked = this.clicked;
+    this.clicked = false;
+    if (!clicked) return;
+    if (choosing) {
+      const p = this.pointer(input);
+      const hit = this.choices?.choiceAtPoint?.(p.x, p.y);
+      if (hit !== void 0) session.confirmAt(hit);
+    } else {
+      session.advance();
+    }
+  }
+  dispose() {
+    this.unsub?.();
+    this.unsub = void 0;
+  }
+};
+function fullControls(choices, options = {}) {
+  const { actions = FULL_ACTIONS, skipHoldMs = 0 } = options;
+  return new CompositeInputBinding([
+    new KeyboardInputBinding(actions, skipHoldMs),
+    new PointerInputBinding(choices)
+  ]);
+}
+__name(fullControls, "fullControls");
+
+// src/events.ts
+var import_core = require("@yagejs/core");
+var DialogueStartedEvent = (0, import_core.defineEvent)("dialogue:started");
+var DialogueLineEvent = (0, import_core.defineEvent)("dialogue:line");
+var DialogueChoiceShownEvent = (0, import_core.defineEvent)(
+  "dialogue:choice-shown"
+);
+var DialogueChoiceMadeEvent = (0, import_core.defineEvent)(
+  "dialogue:choice-made"
+);
+var DialogueCommandEvent = (0, import_core.defineEvent)(
+  "dialogue:command"
+);
+var DialogueEndedEvent = (0, import_core.defineEvent)("dialogue:ended");
+var DialogueRevealCompletedEvent = (0, import_core.defineEvent)("dialogue:reveal-completed");
+var DialogueSelectionChangedEvent = (0, import_core.defineEvent)(
+  "dialogue:selection-changed"
+);
+var DialogueSkipUsedEvent = (0, import_core.defineEvent)(
+  "dialogue:skip-used"
+);
+var DialogueAutoAdvanceEvent = (0, import_core.defineEvent)(
+  "dialogue:auto-advance"
+);
+var DialogueRevealMarkerEvent = (0, import_core.defineEvent)("dialogue:reveal-marker");
+
+// src/DialogueController.ts
+var DialogueController = class extends import_core2.Component {
+  constructor(opts) {
+    super();
+    this.opts = opts;
+    this.binding = opts.input ?? new KeyboardInputBinding();
+  }
+  opts;
+  static {
+    __name(this, "DialogueController");
+  }
+  input = this.service(import_input.InputManagerKey);
+  binding;
+  session;
+  /** Captured at onAdd (the scene is gone by the time a stale play() arrives). */
+  logger;
+  /** Set by onDestroy — the presenters are disposed, so play() must refuse. */
+  destroyed = false;
+  /** Input focus. When false, `update()` keeps pumping the session (an
+   *  ambient conversation stays alive) but the binding is NOT polled, so this
+   *  instance doesn't consume device input. NOT `Component.enabled` (which would
+   *  also freeze the session). */
+  inputEnabled = true;
+  /** Pause. Mirrors the session's pause so the binding poll is also gated
+   *  while frozen — a paused conversation neither updates nor consumes input.
+   *  Also the source of truth re-applied to the session in `onAdd` when a host
+   *  set it before the component was added (the session didn't exist yet). */
+  paused = false;
+  /** Hidden. Mirrors the session's hide so a `setHidden` issued before the
+   *  component was added isn't lost — it's re-applied once the session exists. */
+  hidden = false;
+  /** Disposers for every registered extra channel (ctor `channels` + live
+   *  `addChannel`). `onDestroy` runs them all — each idempotent — to unregister
+   *  and dispose (unmounting the Mountable ones). */
+  channelDisposers = /* @__PURE__ */ new Set();
+  onAdd() {
+    this.logger = this.context.tryResolve(import_core2.LoggerKey);
+    const warn = /* @__PURE__ */ __name((message) => this.logger?.warn("dialogue", message), "warn");
+    this.opts.chrome.mount(this.scene);
+    this.opts.choices.mount(this.scene);
+    this.opts.avatar?.mount(this.scene);
+    this.opts.text.mount(this.scene);
+    this.opts.chrome.setDiagnostics?.(warn);
+    this.opts.text.setDiagnostics?.(warn);
+    this.opts.choices.setDiagnostics?.(warn);
+    this.session = new DialogueSession(
+      {
+        text: this.opts.text,
+        choices: this.opts.choices,
+        avatar: this.opts.avatar,
+        chrome: this.opts.chrome
+      },
+      {
+        i18n: this.opts.i18n,
+        skipMultiplier: this.opts.skipMultiplier,
+        // Controller-installed environment — persists across plays.
+        storage: this.opts.storage,
+        functions: this.opts.functions,
+        commands: this.opts.commands,
+        fallbackCommand: this.opts.fallbackCommand,
+        onStarted: /* @__PURE__ */ __name((e) => this.entity.emit(DialogueStartedEvent, e), "onStarted"),
+        onLine: /* @__PURE__ */ __name((e) => this.entity.emit(DialogueLineEvent, e), "onLine"),
+        onChoiceShown: /* @__PURE__ */ __name((e) => this.entity.emit(DialogueChoiceShownEvent, { options: e.options }), "onChoiceShown"),
+        onChoiceMade: /* @__PURE__ */ __name((e) => this.entity.emit(DialogueChoiceMadeEvent, e), "onChoiceMade"),
+        // Observation only — the `commands` map does the work; this mirrors
+        // every non-built-in command onto the scene event bus.
+        onCommand: /* @__PURE__ */ __name((command, ctx) => this.entity.emit(DialogueCommandEvent, { command, mode: ctx.mode }), "onCommand"),
+        // Route non-fatal runtime diagnostics (e.g. a `set` to a read-only cell)
+        // through the engine logger rather than crashing or silently dropping.
+        onError: /* @__PURE__ */ __name((message) => warn(message), "onError"),
+        onEnded: /* @__PURE__ */ __name((e) => {
+          this.entity.emit(DialogueEndedEvent, e);
+          this.opts.onEnded?.();
+        }, "onEnded"),
+        // Observation events — the controller is the one canonical path that
+        // turns the session's callbacks into entity→scene events (no matching
+        // controller callback options).
+        onRevealCompleted: /* @__PURE__ */ __name((e) => this.entity.emit(DialogueRevealCompletedEvent, e), "onRevealCompleted"),
+        onSelectionChanged: /* @__PURE__ */ __name((e) => this.entity.emit(DialogueSelectionChangedEvent, e), "onSelectionChanged"),
+        onSkipUsed: /* @__PURE__ */ __name((e) => this.entity.emit(DialogueSkipUsedEvent, e), "onSkipUsed"),
+        onAutoAdvance: /* @__PURE__ */ __name((e) => this.entity.emit(DialogueAutoAdvanceEvent, e), "onAutoAdvance"),
+        // Inline markers fan to an entity event; per-grapheme ticks stay a direct
+        // callback (forwarded verbatim — undefined when the host wires none).
+        onRevealMarker: /* @__PURE__ */ __name((marker, viaSkip) => this.entity.emit(DialogueRevealMarkerEvent, { marker, viaSkip }), "onRevealMarker"),
+        onRevealTick: this.opts.onRevealTick
+      }
+    );
+    this.binding.bind(this.input, this.session);
+    if (this.paused) this.session.setPaused(true);
+    if (this.hidden) this.session.setHidden(true);
+    for (const ch of this.opts.channels ?? []) this.addChannel(ch);
+  }
+  onDestroy() {
+    this.destroyed = true;
+    this.session?.stop();
+    for (const dispose of [...this.channelDisposers]) dispose();
+    this.binding.dispose?.();
+    this.opts.text.dispose();
+    this.opts.choices.dispose();
+    this.opts.chrome.dispose();
+    this.opts.avatar?.dispose();
+  }
+  /**
+   * Begin a conversation. `play(script)` is **content-only** — storage,
+   * functions, and commands are installed on the controller. `overrides` layers
+   * per-conversation specifics on top (a scoped `storage`, extra
+   * `functions`/`commands`). Returns a {@link DialogueHandle} for live `setVar` /
+   * `getVars`, or `undefined` if the controller was removed.
+   */
+  play(script, overrides) {
+    if (this.destroyed) {
+      this.logger?.warn(
+        "dialogue",
+        "DialogueController.play() ignored: the component has been removed/destroyed.",
+        { scriptId: script.id }
+      );
+      return void 0;
+    }
+    if (!this.session) {
+      throw new Error(
+        "DialogueController.play() called before the component was added to an entity (onAdd has not run yet)."
+      );
+    }
+    return this.session.play(script, overrides);
+  }
+  isActive() {
+    return this.session?.isActive() ?? false;
+  }
+  /** Abandon the current conversation and reset to idle. */
+  stop() {
+    this.session?.stop();
+  }
+  /**
+   * Register an extra channel live — Voice / Shop / CameraEffects / History.
+   * Mounts it if it needs the scene ({@link Mountable}), hands it to the session
+   * (where it joins the cross-cutting stream and can gate auto-advance), and
+   * returns a disposer that unregisters + disposes it. The `channels` ctor option
+   * registers a bundle the same way at mount. Returns a no-op disposer if the
+   * controller was destroyed; **throws** if called before the component is added
+   * to an entity (use the `channels` ctor option to pre-wire a channel) — mirrors
+   * {@link play}.
+   */
+  addChannel(ch) {
+    if (this.destroyed) {
+      this.logger?.warn(
+        "dialogue",
+        "DialogueController.addChannel() ignored: the component has been removed/destroyed."
+      );
+      return () => {
+      };
+    }
+    if (!this.session) {
+      throw new Error(
+        "DialogueController.addChannel() called before the component was added to an entity (onAdd has not run yet). Use the `channels` constructor option to pre-wire a channel."
+      );
+    }
+    if (isMountable(ch)) {
+      try {
+        ch.mount(this.scene);
+      } catch (error) {
+        this.logger?.warn(
+          "dialogue",
+          `extra channel mount() failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    const unregister = this.session.addChannel(ch);
+    const dispose = /* @__PURE__ */ __name(() => {
+      if (!this.channelDisposers.delete(dispose)) return;
+      unregister();
+    }, "dispose");
+    this.channelDisposers.add(dispose);
+    return dispose;
+  }
+  /** Fast-forward the current section to the next choice or the end. */
+  skip() {
+    this.session?.skip();
+  }
+  /**
+   * Auto-advance lines after they finish revealing (`ms`), or `null` to disable
+   * (manual advance). A per-line `autoAdvanceMs` still overrides this. Toggle it
+   * live for a VN-style "auto" control.
+   */
+  setAutoAdvance(ms) {
+    this.session?.setAutoAdvance(ms);
+  }
+  /**
+   * Hide or show the whole dialogue UI without ending the conversation —
+   * for a cutscene takeover (`setHidden(true)` while the camera pans, then
+   * `setHidden(false)` to restore the exact line + caret). Purely visual; the
+   * conversation keeps its state. **Persistent**: it survives `stop()`/`play()`,
+   * so a host that hides and forgets to unhide stays hidden.
+   */
+  setHidden(hidden) {
+    this.hidden = hidden;
+    this.session?.setHidden(hidden);
+  }
+  /**
+   * Freeze or resume the conversation — a pause menu. While paused the
+   * reveal, auto-advance, caret blink, and avatar anim all halt, input is inert,
+   * and no state is lost (an in-flight blocking command keeps running). Also
+   * gates this controller's input binding so a frozen conversation consumes no
+   * device input. Does NOT block host-driven `handle.setVar` / storage writes.
+   */
+  setPaused(paused) {
+    this.paused = paused;
+    this.session?.setPaused(paused);
+  }
+  /**
+   * Set whether this controller consumes device input — the focus seam for
+   * the multi-instance story. `setInputEnabled(false)` keeps the conversation
+   * fully alive (it still updates, reveals, auto-advances) but stops polling its
+   * binding, so an ambient conversation doesn't steal the advance key. Switch
+   * focus between two conversations with `a.setInputEnabled(true);
+   * b.setInputEnabled(false)`. (YAGE input is non-consuming, so two *enabled*
+   * controllers both advance on one press — focus is the game's policy.)
+   */
+  setInputEnabled(enabled) {
+    this.inputEnabled = enabled;
+  }
+  /**
+   * Primary action, host-driven (the input-agnostic seam): while saying,
+   * reveal-all if still typing else advance to the next line; while choosing,
+   * confirm the highlighted option. Lets a host (cutscene script, custom input,
+   * or a test) drive the conversation without synthesising device input — the
+   * same call the default {@link InputBinding} makes.
+   */
+  advance() {
+    this.session?.advance();
+  }
+  /** Move the choice cursor by `delta` (wraps). No-op outside a choice. */
+  moveSelection(delta) {
+    this.session?.moveSelection(delta);
+  }
+  /** Commit a choice by its original option index. No-op outside a choice. */
+  choose(optionIndex) {
+    this.session?.choose(optionIndex);
+  }
+  /** True while a choice is being presented. */
+  isChoosing() {
+    return this.session?.isChoosing() ?? false;
+  }
+  /** Side-effect-free lookahead of the lines a node would show. */
+  preview(nodeId) {
+    return this.session?.preview(nodeId) ?? [];
+  }
+  update(dt) {
+    this.session?.update(dt);
+    if (this.inputEnabled && !this.paused) this.binding.poll();
+  }
+};
+function isMountable(ch) {
+  return typeof ch.mount === "function";
+}
+__name(isMountable, "isMountable");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CompositeInputBinding,
+  DEFAULT_ACTIONS,
+  DialogueAutoAdvanceEvent,
+  DialogueChoiceMadeEvent,
+  DialogueChoiceShownEvent,
+  DialogueCommandEvent,
+  DialogueController,
+  DialogueEndedEvent,
+  DialogueExprError,
+  DialogueLineEvent,
+  DialoguePlayError,
+  DialogueRevealCompletedEvent,
+  DialogueRevealMarkerEvent,
+  DialogueRunner,
+  DialogueScriptError,
+  DialogueSelectionChangedEvent,
+  DialogueSession,
+  DialogueSkipUsedEvent,
+  DialogueStartedEvent,
+  EMPTY_PARSED,
+  FULL_ACTIONS,
+  IdentityI18n,
+  KeyboardInputBinding,
+  LineReveal,
+  MemoryVariableStorage,
+  PointerInputBinding,
+  cells,
+  compose,
+  createVoiceChannel,
+  defineScript,
+  evalCondition,
+  evaluate,
+  fullControls,
+  interpolate,
+  isExpr,
+  loadCompact,
+  loadScript,
+  materialize,
+  parseCompact,
+  parseExpr,
+  parseMarkup,
+  splitGraphemes,
+  stripMarkup
+});
+//# sourceMappingURL=index.cjs.map