@yagejs-addons/dialogue 0.1.0 → 0.2.0

package/dist/index.js

@@ -0,0 +1,2048 @@
+import {
+  EMPTY_PARSED,
+  LineReveal,
+  firstUnknownTag,
+  parseMarkup,
+  splitGraphemes,
+  stripMarkup
+} from "./chunk-CU47RPEB.js";
+import {
+  DialogueExprError,
+  DialoguePlayError,
+  DialogueScriptError,
+  IdentityI18n,
+  MemoryVariableStorage,
+  analyzeScript,
+  cells,
+  compose,
+  createScope,
+  evalCondition,
+  evaluate,
+  holds,
+  interpolate,
+  isExpr,
+  loadScript,
+  materialize,
+  parseExpr,
+  validatePlay
+} from "./chunk-GJQKZCOL.js";
+import {
+  __name
+} from "./chunk-7QVYU63E.js";
+
+// 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
+import { Component, LoggerKey } from "@yagejs/core";
+import { InputManagerKey } from "@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
+import { defineEvent } from "@yagejs/core";
+var DialogueStartedEvent = defineEvent("dialogue:started");
+var DialogueLineEvent = defineEvent("dialogue:line");
+var DialogueChoiceShownEvent = defineEvent(
+  "dialogue:choice-shown"
+);
+var DialogueChoiceMadeEvent = defineEvent(
+  "dialogue:choice-made"
+);
+var DialogueCommandEvent = defineEvent(
+  "dialogue:command"
+);
+var DialogueEndedEvent = defineEvent("dialogue:ended");
+var DialogueRevealCompletedEvent = defineEvent("dialogue:reveal-completed");
+var DialogueSelectionChangedEvent = defineEvent(
+  "dialogue:selection-changed"
+);
+var DialogueSkipUsedEvent = defineEvent(
+  "dialogue:skip-used"
+);
+var DialogueAutoAdvanceEvent = defineEvent(
+  "dialogue:auto-advance"
+);
+var DialogueRevealMarkerEvent = defineEvent("dialogue:reveal-marker");
+
+// src/DialogueController.ts
+var DialogueController = class extends Component {
+  constructor(opts) {
+    super();
+    this.opts = opts;
+    this.binding = opts.input ?? new KeyboardInputBinding();
+  }
+  opts;
+  static {
+    __name(this, "DialogueController");
+  }
+  input = this.service(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(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");
+export {
+  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.js.map