@lingfan-engine/stories-build 0.0.0-stage → 0.1.2

package/src/compiler/story-compiler/translate/expr/words/call.ts

@@ -0,0 +1,125 @@
+import * as ts from "typescript";
+import type { StoryCommand } from "@lingfan-engine/core";
+import { WORDS, diag, lookupBinding, lookupScope } from "../../shared.ts";
+import type { BodyCtx } from "../../shared.ts";
+import { lowerValue, loweredToScriptValue } from "../expr.ts";
+import { checkFontReferences } from "../../font-check.ts";
+
+export function callWord(
+  ctx: BodyCtx,
+  node: ts.Node,
+  name: string,
+  args: unknown[],
+): StoryCommand | undefined {
+  const word = WORDS[name];
+  if (word === undefined) {
+    // 未知词的第一现场（ambient 直呼也汇到这里），文案单点指路两条调用形态。
+    diag(
+      ctx,
+      node,
+      `词汇层不存在词 \`${name}\`——词函数经 \`script.\` 命名空间或具名导入调用，请核对词名`,
+    );
+    return undefined;
+  }
+  try {
+    const product = word(...args);
+    if (product === null || typeof product !== "object") {
+      diag(ctx, node, `词 \`${name}\` 未返回命令对象`);
+      return undefined;
+    }
+    // 字体引用检查单点：所有词命令都经此处产出（jump/值位置词调用同走），静态可达面全覆盖
+    checkFontReferences(ctx, node, product);
+    return product;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    diag(ctx, node, `词 \`${name}\` 实参形态非法：${message}`);
+    return undefined;
+  }
+}
+
+export function emitJump(
+  ctx: BodyCtx,
+  call: ts.CallExpression,
+): StoryCommand | undefined {
+  if (call.arguments.length !== 1) {
+    diag(ctx, call, "jump 恰好接受一个实参（导入的故事标识符或列名字符串）");
+    return undefined;
+  }
+  const arg = call.arguments[0];
+  if (ts.isStringLiteral(arg) || ts.isNoSubstitutionTemplateLiteral(arg)) {
+    return callWord(ctx, call, "jump", [arg.text]);
+  }
+  if (ts.isIdentifier(arg)) {
+    const binding = lookupBinding(ctx, arg.text);
+    if (binding?.kind === "story") {
+      return callWord(ctx, call, "jump", [binding.name]);
+    }
+    diag(
+      ctx,
+      arg,
+      `jump 实参 \`${arg.text}\` 不是导入的故事（default 导出函数）`,
+    );
+    return undefined;
+  }
+  diag(ctx, arg, "jump 实参必须是导入的故事标识符或字符串字面量");
+  return undefined;
+}
+
+/**
+ * 解析「函数 callee」：具名标识符，绑定面（词表 import）或函数作用域里命中
+ * kind 为 function 的绑定。返回 undefined = 这个 callee 不是子程序调用
+ * （词调用、`obj.method()`、未知名字），由各调用方走自己的分支。
+ *
+ * emitCommand 与语句级 `const x = f(1)` 拦截共用，保证两种位置对「什么算函数」
+ * 的判定逐字节一致。
+ */
+export function resolveFunctionCallee(
+  ctx: BodyCtx,
+  call: ts.CallExpression,
+): { name: string; file: string } | undefined {
+  const callee = call.expression;
+  if (!ts.isIdentifier(callee)) return undefined;
+  const name = callee.text;
+  let binding = lookupBinding(ctx, name);
+  const scopedFn = lookupScope(ctx, name);
+  if (scopedFn?.kind === "function") {
+    binding = {
+      kind: "function",
+      name,
+      file: scopedFn.file ?? ctx.shared.file,
+    };
+  }
+  return binding?.kind === "function"
+    ? { name: binding.name, file: binding.file }
+    : undefined;
+}
+
+export function emitCallCommand(
+  ctx: BodyCtx,
+  call: ts.CallExpression,
+  fn: { name: string; file: string },
+  into?: string,
+): StoryCommand | undefined {
+  const args: Array<string | number | boolean> = [];
+  for (const arg of call.arguments) {
+    const lowered = lowerValue(ctx, arg);
+    if (lowered === undefined) continue;
+    args.push(loweredToScriptValue(lowered));
+  }
+  // refs 的键与 call.target 都用**声明名**：`import { alpha as ah }` 后调用点是 `ah()`，
+  // 但已发射的 func 声明名叫 alpha，函数体登记（funcs.body）也按声明名索引。用调用点
+  // 局部名会得到一个永远解析不到的函数引用——产物里留下悬空的 call。
+  // fn 由 resolveFunctionCallee 给出（携带声明名 + 声明文件），此处不再二次查绑定面：
+  // 别名场景按声明名回查必然落空，会把声明文件错记成当前文件、refs 归位到错误文件。
+  ctx.shared.funcs.refs.set(`${fn.file}#${fn.name}`, {
+    file: fn.file,
+    name: fn.name,
+  });
+  // into = 结果绑定名（语句级 const x = f(1) 的降级形态）：引擎把 ret 带值
+  // 声明成调用方局部变量，无带值 ret / 自然跑完则绑 null
+  return callWord(ctx, call, "call", [
+    fn.name,
+    args,
+    ...(into === undefined ? [] : [into]),
+  ]);
+}

package/src/compiler/story-compiler/translate/expr/words/callee.ts

@@ -0,0 +1,43 @@
+import * as ts from "typescript";
+import { lookupBinding, lookupScope } from "../../shared.ts";
+import type { BodyCtx } from "../../shared.ts";
+
+/**
+ * 取调用表达式的**词名**——具名标识符、`script.` 属性访问与免导入 ambient 直呼
+ * 三种形态在这里归一，免得下面的特判（jump / staticFor / cell）、实参求值与值位置
+ * 通道各写三遍、漏掉一边。
+ *
+ * ambient 直呼（作者不写 `import { script }` 也用 `script.bgm(...)`，类型来自
+ * gen/script.gen.d.ts 的全局声明）只在接收者恰为标识符 `script`、且绑定表与函数
+ * 作用域都没有同名遮蔽时兜底——模块层自有同名声明按 TS 遮蔽语义优先，不在此解析。
+ *
+ * 返回 undefined 表示这个 callee 不是词调用（普通函数、`obj.method()` 等），该走别的分支。
+ */
+export function wordCalleeName(
+  ctx: BodyCtx,
+  call: ts.CallExpression,
+): string | undefined {
+  const callee = call.expression;
+  if (ts.isIdentifier(callee)) {
+    const binding = lookupBinding(ctx, callee.text);
+    // 用 binding.name（声明名）而非 callee.text：`import { say as 说 }` 后调用点是 `说()`，
+    // 但词表里登记的名字仍是 say。
+    return binding?.kind === "word" ? binding.name : undefined;
+  }
+  if (
+    ts.isPropertyAccessExpression(callee) &&
+    ts.isIdentifier(callee.expression)
+  ) {
+    const receiver = callee.expression.text;
+    const target = lookupBinding(ctx, receiver);
+    if (target?.kind === "namespace") return callee.name.text;
+    if (
+      receiver === "script" &&
+      target === undefined &&
+      lookupScope(ctx, receiver) === undefined
+    ) {
+      return callee.name.text;
+    }
+  }
+  return undefined;
+}

package/src/compiler/story-compiler/translate/expr/words/command.ts

@@ -0,0 +1,93 @@
+import * as ts from "typescript";
+import type { StoryCommand } from "@lingfan-engine/core";
+import { diag, lookupBinding } from "../../shared.ts";
+import type { BodyCtx } from "../../shared.ts";
+import {
+  callWord,
+  emitCallCommand,
+  emitJump,
+  resolveFunctionCallee,
+} from "./call.ts";
+import { emitStaticFor } from "./static-for.ts";
+import { evaluateWordArg } from "./arg.ts";
+import { wordCalleeName } from "./callee.ts";
+import type { WordDispatch } from "./dispatch.ts";
+
+/**
+ * 发射一条词命令。三条特判（jump / staticFor / cell）按**词名**判定，与 callee 写成
+ * 具名标识符还是 `script.` 属性访问无关——同一个词换个写法必须落到同一条路径，
+ * 否则 `script.staticFor(...)` 会被当普通命令词去求值实参，报出与 `staticFor(...)`
+ * 完全不同的文案。
+ *
+ * 返回数组而非单条命令：staticFor 会静态展开成多条（`staticFor(3, …)` → 3 条命令），
+ * 是这条通道里唯一的展开点。调用方负责扁平化。
+ */
+function emitWordCommand(
+  ctx: BodyCtx,
+  call: ts.CallExpression,
+  wordName: string,
+): StoryCommand[] {
+  if (wordName === "jump") {
+    const op = emitJump(ctx, call);
+    return op === undefined ? [] : [op];
+  }
+  if (wordName === "staticFor") return emitStaticFor(ctx, call, DISPATCH);
+  if (wordName === "cell") {
+    diag(ctx, call, "cell 是构建期声明词，只能用于模块层 const，不能作为命令");
+    return [];
+  }
+  const args = call.arguments.map((arg) => evaluateWordArg(ctx, arg, DISPATCH));
+  const op = callWord(ctx, call, wordName, args);
+  return op === undefined ? [] : [op];
+}
+
+/** 命令发射总入口：本文件即递归入口，自引用注入给实参求值与 staticFor 展开 */
+const DISPATCH: WordDispatch = {
+  command(ctx, call) {
+    return emitCommand(ctx, call);
+  },
+};
+
+export function emitCommand(
+  ctx: BodyCtx,
+  call: ts.CallExpression,
+): StoryCommand[] {
+  const callee = call.expression;
+  if (ts.isIdentifier(callee)) {
+    const fn = resolveFunctionCallee(ctx, call);
+    if (fn !== undefined) {
+      const op = emitCallCommand(ctx, call, fn);
+      return op === undefined ? [] : [op];
+    }
+    const name = callee.text;
+    const binding = lookupBinding(ctx, name);
+    if (binding === undefined) {
+      diag(ctx, call, `未知调用目标 \`${name}\`（须是词函数或声明的函数）`);
+      return [];
+    }
+    if (binding.kind === "word") {
+      return emitWordCommand(ctx, call, binding.name);
+    }
+    if (binding.kind === "declare" && name === "jump") {
+      const op = emitJump(ctx, call);
+      return op === undefined ? [] : [op];
+    }
+    diag(ctx, call, `\`${name}\` 是 ${binding.kind} 绑定，不是可发射的命令`);
+    return [];
+  }
+  const word = wordCalleeName(ctx, call);
+  if (word !== undefined) {
+    return emitWordCommand(ctx, call, word);
+  }
+  // 属性访问但接收者不是词汇层命名空间（`obj.method()` 之类）：这条文案比末尾的通用文案更能
+  // 指路，故单独保留，避免重构时遗漏。
+  if (
+    ts.isPropertyAccessExpression(callee) &&
+    ts.isIdentifier(callee.expression)
+  ) {
+    diag(ctx, call, "方法调用不支持：词函数通过具名导入或 script 命名空间调用");
+    return [];
+  }
+  diag(ctx, call, "命令只能是词函数/函数调用");
+  return [];
+}

package/src/compiler/story-compiler/translate/expr/words/dispatch.ts

@@ -0,0 +1,16 @@
+import type * as ts from "typescript";
+import type { StoryCommand } from "@lingfan-engine/core";
+import type { BodyCtx } from "../../shared.ts";
+
+/**
+ * 词命令递归入口：命令发射总入口由 `command.ts` 注入给实参求值（`arg.ts`）与
+ * staticFor 展开（`static-for.ts`）。
+ *
+ * 值位置的词调用（`option(...)`）与 staticFor 生成器元素都要回到命令发射总入口，
+ * 而总入口又要靠实参求值 ⇒ 两处若直接 import `command.ts` 即成环（环判据白名单为空）。
+ * 与 `stmt/control-flow.ts` 的 `StatementDispatch` 同法：**只注入、不反向 import**。
+ */
+export interface WordDispatch {
+  /** 调用表达式 → 命令序列（staticFor 的展开点已扁平化） */
+  command(ctx: BodyCtx, call: ts.CallExpression): StoryCommand[];
+}

package/src/compiler/story-compiler/translate/expr/words/index.ts

@@ -0,0 +1,8 @@
+/**
+ * 词命令族出口：命令发射总入口、词表调用（含字体检查单点）与函数 callee 解析。
+ *
+ * `emitCommand` 是族内递归入口，经 `WordDispatch` 注入给 `arg.ts` /
+ * `static-for.ts`（见 `dispatch.ts`）；族外只需这四个名字。
+ */
+export { callWord, emitCallCommand, resolveFunctionCallee } from "./call.ts";
+export { emitCommand } from "./command.ts";

package/src/compiler/story-compiler/translate/expr/words/static-for.ts

@@ -0,0 +1,96 @@
+import * as ts from "typescript";
+import type { StoryCommand } from "@lingfan-engine/core";
+import { foldConst } from "../../../graph.ts";
+import { diag, lookupBinding, lookupScope } from "../../shared.ts";
+import type { BodyCtx, Scope } from "../../shared.ts";
+import type { WordDispatch } from "./dispatch.ts";
+
+const STATIC_FOR_MAX = 100000;
+
+function foldStaticCount(
+  ctx: BodyCtx,
+  expr: ts.Expression,
+): number | undefined {
+  const value = foldConst(
+    expr,
+    ctx.shared.mod.sf,
+    ctx.shared.diags,
+    ctx.shared.file,
+    (name) => {
+      const scoped = lookupScope(ctx, name);
+      if (scoped?.kind === "index" && typeof scoped.value === "number") {
+        return { kind: "const", value: scoped.value };
+      }
+      return lookupBinding(ctx, name);
+    },
+  );
+  if (
+    value === undefined ||
+    typeof value !== "number" ||
+    !Number.isInteger(value)
+  ) {
+    diag(ctx, expr, "staticFor 次数必须是编译期可折叠的整数");
+    return undefined;
+  }
+  return value;
+}
+
+export function emitStaticFor(
+  ctx: BodyCtx,
+  call: ts.CallExpression,
+  dispatch: WordDispatch,
+): StoryCommand[] {
+  if (call.arguments.length !== 2) {
+    diag(ctx, call, "staticFor(count, generator) 恰好接受两个实参");
+    return [];
+  }
+  const count = foldStaticCount(ctx, call.arguments[0]);
+  if (count === undefined) return [];
+  if (count < 0) {
+    diag(ctx, call.arguments[0], "staticFor 次数不能为负");
+    return [];
+  }
+  if (count > STATIC_FOR_MAX) {
+    diag(ctx, call.arguments[0], `staticFor 展开量超限（>${STATIC_FOR_MAX}）`);
+    return [];
+  }
+  const generator = call.arguments[1];
+  if (
+    !ts.isArrowFunction(generator) ||
+    generator.parameters.length !== 1 ||
+    !ts.isIdentifier(generator.parameters[0].name)
+  ) {
+    diag(ctx, generator, "staticFor 生成器必须是单参数箭头函数");
+    return [];
+  }
+  if (!ts.isArrayLiteralExpression(generator.body)) {
+    diag(
+      ctx,
+      generator.body,
+      "staticFor 生成器函数体必须是数组字面量（命令列表）",
+    );
+    return [];
+  }
+  const paramName = generator.parameters[0].name.text;
+  const out: StoryCommand[] = [];
+  for (let i = 0; i < count; i += 1) {
+    const scope: Scope = new Map([[paramName, { kind: "index", value: i }]]);
+    ctx.scopes.push(scope);
+    try {
+      for (const element of generator.body.elements) {
+        if (!ts.isCallExpression(element)) {
+          diag(
+            ctx,
+            element,
+            "staticFor 生成器元素只能是词函数调用或 staticFor 调用",
+          );
+          continue;
+        }
+        out.push(...dispatch.command(ctx, element));
+      }
+    } finally {
+      ctx.scopes.pop();
+    }
+  }
+  return out;
+}

package/src/compiler/story-compiler/translate/font-check.ts

@@ -0,0 +1,94 @@
+/**
+ * 构建期字体名引用检查：词命令产物里的静态字体引用对照字体名注册表，未注册名 fail-closed。
+ *
+ * 覆盖两类静态可达面：
+ * 1. 文本里的 `{font=名}` 行内标签（模板串已整体降糖为静态字符串，标签可见）；
+ * 2. `say` 行参 `font`（角色字体字段的静态源）。
+ *
+ * 动态值不在此档：模板插值与标识符实参在降糖后是 `{…}` 包裹形态（编译期不可见真值），
+ * 编译期放行，由渲染层注册表回退 + 诊断兜底（两档语义）。
+ */
+import * as ts from "typescript";
+import type { BodyCtx } from "./shared.ts";
+import { diag } from "./shared.ts";
+
+/** 降糖形态的插值段：`{…}` 包裹（模板插值与标识符实参都落成这个形态） */
+const INTERP_SEGMENT = /\{[^{}]*\}/;
+const FONT_TAG = /\{font=([^}]*)\}/g;
+
+/**
+ * 检查一个词命令产物里的字体引用；每个未注册的静态名报一条诊断（一次报全部）。
+ * 注册表为空集（工程未声明字体）时同样 fail-closed——引用了就报。
+ */
+export function checkFontReferences(
+  ctx: BodyCtx,
+  node: ts.Node,
+  product: unknown,
+): void {
+  const registry = ctx.shared.fontNames;
+  const bad = new Set<string>();
+  collectFontRefs(product, registry, bad);
+  for (const name of bad) {
+    diag(
+      ctx,
+      node,
+      `未注册的字体名 "${name}"——Resources/Fonts 里没有对应字体文件（字体名 = 文件名去扩展名）`,
+    );
+  }
+}
+
+function collectFontRefs(
+  value: unknown,
+  registry: ReadonlySet<string>,
+  bad: Set<string>,
+): void {
+  if (typeof value === "string") {
+    collectFromString(value, registry, bad);
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      collectFontRefs(item, registry, bad);
+    }
+    return;
+  }
+  if (typeof value === "object" && value !== null) {
+    for (const [key, item] of Object.entries(value)) {
+      // 角色字体字段的静态源（say 行参 font）：裸字符串名直接对照注册表；
+      // 插值降糖形态（{…} 包裹）= 动态值，编译期放行
+      if (
+        key === "font" &&
+        typeof item === "string" &&
+        !INTERP_SEGMENT.test(item)
+      ) {
+        noteName(item, registry, bad);
+      }
+      collectFontRefs(item, registry, bad);
+    }
+  }
+}
+
+function collectFromString(
+  text: string,
+  registry: ReadonlySet<string>,
+  bad: Set<string>,
+): void {
+  for (const match of text.matchAll(FONT_TAG)) {
+    const name = match[1]!.trim();
+    // 空名 / 含插值段的标签 = 动态，运行期档负责
+    if (name === "" || name.includes("{")) {
+      continue;
+    }
+    noteName(name, registry, bad);
+  }
+}
+
+function noteName(
+  name: string,
+  registry: ReadonlySet<string>,
+  bad: Set<string>,
+): void {
+  if (!registry.has(name)) {
+    bad.add(name);
+  }
+}

package/src/compiler/story-compiler/translate/index.ts

@@ -0,0 +1,10 @@
+/**
+ * 翻译族出口：TS 源到引擎命令的翻译。
+ *
+ * 轴 = 三段——表达式与赋值（`expr/`）、语句与控制流（`stmt/`）、共享上下文与词表
+ * （`shared.ts`），外加一处字体引用检查（`font-check.ts`）。
+ */
+export type { FuncRegistry, Scope, ScopeEntry, SharedCtx } from "./shared.ts";
+export { createBodyCtx, createSharedCtx, makeFuncOp } from "./shared.ts";
+export { checkFontReferences } from "./font-check.ts";
+export { translateStatements } from "./stmt/index.ts";

package/src/compiler/story-compiler/translate/shared.ts

@@ -0,0 +1,132 @@
+import * as ts from "typescript";
+import type { StoryCommand } from "@lingfan-engine/core";
+import { script } from "@lingfan-engine/editor";
+import {
+  defaultStoriesBuildTexts,
+  type StoriesBuildTexts,
+} from "../../../shared/index.ts";
+import type { Binding, DiagBag, ModuleRecord } from "../graph.ts";
+
+export const WORDS = script as unknown as Record<
+  string,
+  (...args: unknown[]) => StoryCommand
+>;
+
+export interface ScopeEntry {
+  kind: "let" | "param" | "index" | "function";
+  value?: string | number | boolean;
+  file?: string;
+}
+
+export type Scope = Map<string, ScopeEntry>;
+
+export interface FuncRegistry {
+  refs: Map<string, { file: string; name: string }>;
+  names: Map<string, { file: string; line: number; col: number }>;
+}
+
+export interface SharedCtx {
+  mod: ModuleRecord;
+  file: string;
+  diags: DiagBag;
+  funcs: FuncRegistry;
+  /** 状态根名（发现自 `export declare const <根名>: StoryState`；无声明回退 "state"） */
+  readonly stateRoot: string;
+  /** 字体名注册表（Resources/Fonts 文件名去扩展名；构建期字体引用检查的对照源） */
+  readonly fontNames: ReadonlySet<string>;
+  /** 集中文案表（编译入口注入；已含缺省合并，诊断文案只从这里取） */
+  readonly texts: StoriesBuildTexts;
+}
+
+export interface BodyCtx {
+  shared: SharedCtx;
+  scopes: Scope[];
+  /** 本函数体自身作用域的起始下标；之下的条目继承自外层函数（只读），赋值目标不得落在这里 */
+  readonly ownBase: number;
+  breakables: Array<"loop" | "switch">;
+  inFunction: boolean;
+}
+
+export function diag(ctx: BodyCtx, node: ts.Node, message: string): void {
+  ctx.shared.diags.add(ctx.shared.file, ctx.shared.mod.sf, node, message);
+}
+
+export function lookupBinding(ctx: BodyCtx, name: string): Binding | undefined {
+  return ctx.shared.mod.bindings.get(name);
+}
+
+export function lookupScope(
+  ctx: BodyCtx,
+  name: string,
+): ScopeEntry | undefined {
+  for (let i = ctx.scopes.length - 1; i >= 0; i -= 1) {
+    const hit = ctx.scopes[i].get(name);
+    if (hit !== undefined) return hit;
+  }
+  return undefined;
+}
+
+/** 只查本函数体自身的作用域层（含参数层），不含继承自外层的条目 */
+export function lookupOwnScope(
+  ctx: BodyCtx,
+  name: string,
+): ScopeEntry | undefined {
+  for (let i = ctx.scopes.length - 1; i >= ctx.ownBase; i -= 1) {
+    const hit = ctx.scopes[i].get(name);
+    if (hit !== undefined) return hit;
+  }
+  return undefined;
+}
+
+export function declareLocal(
+  ctx: BodyCtx,
+  name: string,
+  entry: ScopeEntry,
+): void {
+  ctx.scopes[ctx.scopes.length - 1].set(name, entry);
+}
+
+// —— 表达式内联（引擎文法唯一来源 runtime/expr）——
+
+export function isAssignmentOperator(text: string): boolean {
+  return ["=", "+=", "-=", "*=", "/=", "%="].includes(text);
+}
+
+export function createBodyCtx(
+  shared: SharedCtx,
+  options: {
+    inFunction: boolean;
+    params?: string[];
+    parentScopes?: readonly Scope[];
+  },
+): BodyCtx {
+  const parents = options.parentScopes ?? [];
+  const root: Scope = new Map();
+  for (const param of options.params ?? []) root.set(param, { kind: "param" });
+  return {
+    shared,
+    scopes: [...parents, root],
+    ownBase: parents.length,
+    breakables: [],
+    inFunction: options.inFunction,
+  };
+}
+
+export function makeFuncOp(
+  name: string,
+  params: string[],
+  body: StoryCommand[],
+): StoryCommand {
+  return WORDS.func(name, params, body);
+}
+
+export function createSharedCtx(
+  mod: ModuleRecord,
+  diags: DiagBag,
+  funcs: FuncRegistry,
+  stateRoot: string,
+  fontNames: ReadonlySet<string> = new Set(),
+  texts: StoriesBuildTexts = defaultStoriesBuildTexts,
+): SharedCtx {
+  return { mod, file: mod.rel, diags, funcs, stateRoot, fontNames, texts };
+}

package/src/compiler/story-compiler/translate/stmt/control/branch.ts

@@ -0,0 +1,71 @@
+import * as ts from "typescript";
+import type { StoryCommand } from "@lingfan-engine/core";
+import type { BodyCtx } from "../../shared.ts";
+import { lowerCond } from "../../expr/expr.ts";
+import { callWord } from "../../expr/words/index.ts";
+import { translateBlockBody } from "../control-flow.ts";
+import type { StatementDispatch } from "../control-flow.ts";
+
+interface IfChainInput {
+  branches: Array<{ cond: ts.Expression; then: ts.Statement }>;
+  elseStmt: ts.Statement | undefined;
+}
+
+function collectIfChain(stmt: ts.IfStatement): IfChainInput {
+  const branches: Array<{ cond: ts.Expression; then: ts.Statement }> = [
+    { cond: stmt.expression, then: stmt.thenStatement },
+  ];
+  let current = stmt;
+  while (
+    current.elseStatement !== undefined &&
+    ts.isIfStatement(current.elseStatement)
+  ) {
+    current = current.elseStatement;
+    branches.push({ cond: current.expression, then: current.thenStatement });
+  }
+  return { branches, elseStmt: current.elseStatement };
+}
+
+interface Chain {
+  elif(cond: string, body: StoryCommand[]): Chain;
+  else(body: StoryCommand[]): StoryCommand;
+  end(): StoryCommand;
+}
+
+export function translateIf(
+  ctx: BodyCtx,
+  stmt: ts.IfStatement,
+  dispatch: StatementDispatch,
+): StoryCommand[] {
+  const { branches, elseStmt } = collectIfChain(stmt);
+  const rendered: Array<[string, StoryCommand[]]> = [];
+  for (const branch of branches) {
+    const cond = lowerCond(ctx, branch.cond);
+    if (cond === undefined) return [];
+    ctx.scopes.push(new Map());
+    const body = translateBlockBody(ctx, branch.then, dispatch);
+    ctx.scopes.pop();
+    rendered.push([cond, body]);
+  }
+  let elseBody: StoryCommand[] = [];
+  if (elseStmt !== undefined) {
+    ctx.scopes.push(new Map());
+    elseBody = translateBlockBody(ctx, elseStmt, dispatch);
+    ctx.scopes.pop();
+  }
+  const [firstCond, firstThen] = rendered[0];
+  if (branches.length === 1 && elseStmt === undefined) {
+    const op = callWord(ctx, stmt, "when", [firstCond, firstThen]);
+    return op === undefined ? [] : [op];
+  }
+  const chainOp = callWord(ctx, stmt, "whenChain", [firstCond, firstThen]);
+  if (chainOp === undefined) return [];
+  const chain = chainOp as unknown as Chain;
+  let result = chain;
+  for (let i = 1; i < rendered.length; i += 1) {
+    result = result.elif(rendered[i][0], rendered[i][1]) as Chain;
+  }
+  const finished =
+    elseStmt !== undefined ? result.else(elseBody) : result.end();
+  return [finished];
+}