@tsplc/compiler 0.0.0-stage → 0.2.0

package/src/frontend/elaborate/specialize.ts

@@ -0,0 +1,2280 @@
+import ts from "typescript";
+import { Layouts, type LiteralEnum } from "./layouts.ts";
+import type { CapturedValue } from "./graph.ts";
+import type { Model, ModelNode, Root, Step } from "./model.ts";
+
+type FunctionLike =
+  | ts.FunctionDeclaration
+  | ts.MethodDeclaration
+  | ts.ArrowFunction
+  | ts.FunctionExpression
+  | ts.GetAccessorDeclaration;
+
+/** What an expression is while specializing: known now, or code the PLC runs. */
+export type Value =
+  /** An object setup built: a class instance, record, array, function or service. */
+  | { kind: "static"; node: ModelNode }
+  /** A literal or folded primitive. `undefined` is a value too. */
+  | { kind: "const"; value: number | boolean | string | undefined | bigint }
+  /** An array or record built in scan code from known parts, used before it needs storage. */
+  | { kind: "virtual"; items?: Value[]; fields?: Map<string, Value> }
+  /** A function value: a module function, method of a known instance, or a local arrow. */
+  | { kind: "function"; declaration: FunctionLike; self?: ModelNode; env?: Env }
+  /** Code the PLC runs. `declared` is the storage's declared type, before narrowing. */
+  | {
+      kind: "code";
+      text: string;
+      declared?: ts.Type;
+      place?: boolean;
+      iec?: string;
+      /** A module global another module stores into through its setter; an import is read-only. */
+      setter?: string;
+    };
+
+type Env = Map<ts.Symbol, Value>;
+
+const constant = (value: number | boolean | string | undefined | bigint): Value => ({
+  kind: "const",
+  value,
+});
+
+export class SpecializeError extends Error {
+  constructor(
+    readonly node: ts.Node,
+    message: string,
+  ) {
+    super(message);
+  }
+}
+
+/** Indented lines of one generated routine, with the local names it has used. */
+class Emitter {
+  readonly lines: string[] = [];
+  private depth = 1;
+  private readonly used = new Set<string>();
+  private temporaries = 0;
+
+  line(text: string): void {
+    this.lines.push(`${"  ".repeat(this.depth)}${text}`);
+  }
+  open(text: string): void {
+    this.line(text);
+    this.depth++;
+  }
+  close(text = "}"): void {
+    this.depth--;
+    this.line(text);
+  }
+  local(name: string): string {
+    let candidate = name;
+    for (let index = 2; this.used.has(candidate); index++) candidate = `${name}_${index}`;
+    this.used.add(candidate);
+    return candidate;
+  }
+  temporary(): string {
+    return this.local(`tsplcTemp${++this.temporaries}`);
+  }
+}
+
+interface Frame {
+  emitter: Emitter;
+  env: Env;
+  self?: ModelNode;
+  /** The routine's declared return type, for literal and optional results. */
+  returns?: ts.Type;
+  async: boolean;
+}
+
+/**
+ * Evaluates the program's scan code against the setup graph. Everything setup decided (which
+ * instance `this` is, what a field refers to, array lengths, config never written in scan code)
+ * resolves at compile time; what is left becomes tsPLC dialect code over the stored state.
+ */
+export class Specializer {
+  readonly layouts: Layouts;
+  readonly routines: string[] = [];
+  /** Modules generated code reads through a namespace import, by import name. */
+  readonly namespaces = new Map<string, string>();
+  /** Value imports from kept modules, by file. */
+  readonly imports = new Map<string, Set<string>>();
+  private readonly specialized = new Map<string, string>();
+  private readonly routineNames = new Set<string>();
+  private readonly assigned = new Set<ts.Symbol>();
+  private readonly storedRoots = new Set<Root>();
+
+  constructor(
+    readonly model: Model,
+    readonly checker: ts.TypeChecker,
+    readonly sources: readonly ts.SourceFile[],
+    readonly kept: (file: string) => boolean,
+    readonly rootModule: (root: Root) => string,
+  ) {
+    this.layouts = new Layouts(
+      model,
+      checker,
+      kept,
+      sources.filter((source) => kept(source.fileName)),
+    );
+    for (const source of sources) this.collectAssignments(source);
+  }
+
+  // ---- Which fields scan code writes ----
+
+  /** Fields scan code writes are state; the rest keep what setup gave them. */
+  private collectAssignments(node: ts.Node, inConstructor = false): void {
+    if (ts.isConstructorDeclaration(node)) inConstructor = true;
+    if (!inConstructor) {
+      const write = (target: ts.Expression): void => {
+        while (ts.isParenthesizedExpression(target) || ts.isNonNullExpression(target))
+          target = target.expression;
+        if (ts.isPropertyAccessExpression(target)) this.markAssigned(target.name);
+        else if (ts.isElementAccessExpression(target)) {
+          let base: ts.Expression = target.expression;
+          while (ts.isElementAccessExpression(base)) base = base.expression;
+          if (ts.isPropertyAccessExpression(base)) this.markAssigned(base.name);
+        }
+      };
+      if (ts.isBinaryExpression(node) && isAssignment(node.operatorToken.kind)) write(node.left);
+      if (
+        (ts.isPrefixUnaryExpression(node) || ts.isPostfixUnaryExpression(node)) &&
+        (node.operator === ts.SyntaxKind.PlusPlusToken ||
+          node.operator === ts.SyntaxKind.MinusMinusToken)
+      )
+        write(node.operand);
+    }
+    ts.forEachChild(node, (child) => this.collectAssignments(child, inConstructor));
+  }
+
+  private markAssigned(name: ts.MemberName): void {
+    const symbol = this.checker.getSymbolAtLocation(name);
+    if (!symbol) return;
+    this.assigned.add(symbol);
+    // A property of a union is a synthetic symbol over each member's own property.
+    for (const declaration of symbol.declarations ?? []) {
+      const own = (declaration as { symbol?: ts.Symbol }).symbol;
+      if (own) this.assigned.add(own);
+    }
+  }
+
+  /** The declaration symbol of a captured field, to ask whether scan code writes it. */
+  private fieldSymbol(holder: ModelNode, name: string): ts.Symbol | undefined {
+    if (holder.captured.kind === "instance") {
+      const member = this.model.member(this.model.classOf(holder), name);
+      return member && this.checker.getSymbolAtLocation(member.name);
+    }
+    if (!holder.type) return undefined;
+    const variant = this.model.variant(holder.type, holder.captured);
+    return variant.getProperty(name) ?? this.checker.getPropertyOfType(variant, name);
+  }
+
+  /** Whether a field holds state the PLC stores, rather than a value fixed at setup. */
+  stored(holder: ModelNode, name: string): boolean {
+    if (holder.owner?.root.exported) return true;
+    return this.written(holder, name);
+  }
+
+  /** Whether scan code assigns the field itself. */
+  private written(holder: ModelNode, name: string): boolean {
+    const symbol = this.fieldSymbol(holder, name);
+    if (!symbol) return false;
+    if (this.assigned.has(symbol)) return true;
+    // A union's property is written through any member's declaration of it.
+    return (symbol.declarations ?? []).some((declaration) => {
+      const own = (declaration as { symbol?: ts.Symbol }).symbol;
+      return own !== undefined && this.assigned.has(own);
+    });
+  }
+
+  /** Array elements are stored when the field holding the array is, or its root is exported. */
+  private storedArray(array: ModelNode): boolean {
+    const owner = array.owner;
+    if (!owner) return false;
+    if (owner.root.exported) return true;
+    const last = owner.steps.at(-1);
+    if (!last) return false;
+    const holder = this.at(owner.root, owner.steps.slice(0, -1));
+    return last.kind === "field" && holder !== undefined && this.stored(holder, last.name);
+  }
+
+  /** The node at a path from a root, following captured values. */
+  private at(root: Root, steps: readonly Step[]): ModelNode | undefined {
+    let value: CapturedValue | undefined = this.model.rootValues.get(root);
+    for (const step of steps) {
+      const node = value && this.model.node(value);
+      if (!node) return undefined;
+      const captured = node.captured;
+      value =
+        step.kind === "index"
+          ? captured.kind === "array"
+            ? captured.items[step.index]
+            : undefined
+          : captured.kind === "object" || captured.kind === "instance"
+            ? captured.fields[step.name]
+            : undefined;
+    }
+    return value && this.model.node(value);
+  }
+
+  // ---- Storage ----
+
+  /** Dialect text for a stored node's place. */
+  pathText(node: ModelNode): string {
+    const owner = node.owner;
+    if (!owner) throw new Error("An object with no owner has no storage.");
+    this.storedRoots.add(owner.root);
+    const namespace = this.namespace(owner.root);
+    let text = this.flattened(owner.root) ? namespace : `${namespace}.${owner.root.name}`;
+    owner.steps.forEach((step, index) => {
+      const holder = this.at(owner.root, owner.steps.slice(0, index));
+      if (step.kind === "index") text += `[${step.index}]`;
+      else if (/^\d+$/.test(step.name) && holder?.type)
+        text += `[${this.keyText(holder.type, step.name)}]`;
+      else text += `.${step.name}`;
+    });
+    return text;
+  }
+
+  /** The enum member naming a key of a `Record<Enum, T>`. */
+  private keyText(type: ts.Type, key: string): string {
+    const keyType = type.aliasSymbol?.name === "Record" ? type.aliasTypeArguments?.[0] : undefined;
+    const member = keyType && this.enumMemberName(keyType, Number(key));
+    return member ? `${this.layouts.text(keyType!)}.${member}` : key;
+  }
+
+  /** A record or instance root becomes its own global list, one global per field. */
+  flattened(root: Root): boolean {
+    const node = this.model.node(this.model.rootValues.get(root)!);
+    return node?.captured.kind === "object" || node?.captured.kind === "instance";
+  }
+
+  private namespace(root: Root): string {
+    const name = pascal(root.name);
+    this.namespaces.set(name, this.rootModule(root));
+    return name;
+  }
+
+  /** Stores a root whether or not scan code reads it, as exported data must be. */
+  use(root: Root): void {
+    this.storedRoots.add(root);
+    this.namespace(root);
+  }
+
+  /** Roots generated code reached, which need storage declarations. */
+  get roots(): ReadonlySet<Root> {
+    return this.storedRoots;
+  }
+
+  /** Whether anything inside a node is state the PLC stores. */
+  private hasState(node: ModelNode): boolean {
+    const captured = node.captured;
+    if (node.owner?.root.exported) return true;
+    if (captured.kind === "instance") return this.instanceFields(node).length > 0;
+    if (captured.kind === "array")
+      return (
+        this.storedArray(node) ||
+        captured.items.some((item) => {
+          const inner = this.model.node(item);
+          return inner !== undefined && isChild(inner, node) && this.hasState(inner);
+        })
+      );
+    if (captured.kind === "object")
+      return Object.entries(captured.fields).some(([name, value]) => {
+        if (this.stored(node, name)) return true;
+        const inner = this.model.node(value);
+        return inner !== undefined && isChild(inner, node, name) && this.hasState(inner);
+      });
+    return false;
+  }
+
+  /**
+   * The stored layout of a node, or undefined when nothing in it is stored. Records and arrays
+   * keep their declared type; an instance stores a record of the fields that hold its state.
+   */
+  storageType(node: ModelNode): string | undefined {
+    const captured = node.captured;
+    if (!this.hasState(node)) return undefined;
+    if (captured.kind === "instance") {
+      const fields = this.instanceFields(node);
+      return this.layoutName(
+        `${captured.name}State`,
+        fields.map(([field, text]) => `${field}: ${text};`).join(" "),
+      );
+    }
+    if (captured.kind === "array") {
+      const first = captured.items[0] && this.model.node(captured.items[0]);
+      if (first?.captured.kind === "instance") {
+        const states = captured.items.map((item) => this.storageType(this.model.node(item)!));
+        if (new Set(states).size !== 1)
+          throw new Error("Instances in one array must hold the same kinds of state.");
+        return `FixedArray<${states[0]}, ${captured.items.length}>`;
+      }
+    }
+    if (!node.type) throw new Error("Stored state needs a declared type.");
+    return this.layouts.text(node.type, { kind: "node", id: node.id });
+  }
+
+  /** Records stored as a whole: anything in them is state. */
+  private storedWhole(node: ModelNode): boolean {
+    return node.captured.kind !== "instance" && this.hasState(node);
+  }
+
+  /** An instance's stored fields: what scan code writes, and owned objects holding state. */
+  instanceFields(node: ModelNode): [string, string][] {
+    const captured = node.captured;
+    if (captured.kind !== "instance") return [];
+    const declaration = this.model.classOf(node);
+    return this.fieldNames(declaration).flatMap((name): [string, string][] => {
+      const value = captured.fields[name] ?? { kind: "undefined" };
+      const inner = this.model.node(value);
+      const member = this.model.member(declaration, name);
+      const type = member && this.checker.getTypeAtLocation(member.name);
+      if (inner) {
+        if (inner.captured.kind === "function" || inner.captured.kind === "service") return [];
+        if (!isChild(inner, node, name)) {
+          if (!this.stored(node, name)) return [];
+          // A stored field holds its own copy of the record setup gave it.
+          return type ? [[name, this.layouts.text(type, value)]] : [];
+        }
+        if (inner.captured.kind !== "instance" && this.stored(node, name) && type)
+          return [[name, this.layouts.text(type, value)]];
+        const text = this.storageType(inner);
+        return text ? [[name, text]] : [];
+      }
+      if (!this.stored(node, name)) return [];
+      if (!type) throw new Error(`${captured.name}.${name} has no declared type.`);
+      return [[name, this.layouts.declaredText(member, type, value)]];
+    });
+  }
+
+  /** A class's fields in declaration order: properties and constructor parameter properties. */
+  private fieldNames(declaration: ts.ClassDeclaration): string[] {
+    const names: string[] = [];
+    for (const member of declaration.members) {
+      if (ts.isPropertyDeclaration(member)) names.push(member.name.getText());
+      if (ts.isConstructorDeclaration(member))
+        for (const parameter of member.parameters)
+          if (ts.isParameterPropertyDeclaration(parameter, member))
+            names.push(parameter.name.getText());
+    }
+    return names;
+  }
+
+  private readonly layoutNames = new Map<string, string>();
+  private layoutName(base: string, body: string): string {
+    const known = this.layoutNames.get(body);
+    if (known) return known;
+    let name = base;
+    for (
+      let index = 2;
+      [...this.layoutNames.values()].includes(name) || this.layouts.declarations.has(name);
+      index++
+    )
+      name = `${base}_${index}`;
+    this.layoutNames.set(body, name);
+    this.layouts.declarations.set(name, `export interface ${name} { ${body} }`);
+    return name;
+  }
+
+  private fieldInitializer(
+    holder: ModelNode,
+    name: string,
+    value: CapturedValue,
+    type: string,
+  ): string {
+    const declaredType =
+      holder.captured.kind === "instance"
+        ? (() => {
+            const member = this.model.member(this.model.classOf(holder), name);
+            return member && this.checker.getTypeAtLocation(member.name);
+          })()
+        : holder.type && this.model.fieldType(holder.type, name, holder.captured);
+    if (!declaredType) throw new Error(`${name} has no declared type.`);
+    return this.valueText(value, declaredType, type);
+  }
+
+  /** A captured value as dialect text of its declared type. */
+  valueText(value: CapturedValue, declared: ts.Type, layout?: string): string {
+    const node = this.model.node(value);
+    const literal = this.layouts.literalEnum(declared);
+    if (literal)
+      return this.layouts.member(literal, value.kind === "string" ? value.value : undefined);
+    const optional = this.isOptionalRecord(declared);
+    if (optional) {
+      const inner = this.checker.getNonNullableType(declared);
+      const name = layout ?? this.layouts.text(declared, value);
+      return value.kind === "undefined"
+        ? `defaultValue<${name}>()`
+        : `{ has: true, value: ${this.valueText(value, inner)} }`;
+    }
+    if (this.layouts.enumDeclaration(declared) && value.kind === "number") {
+      const enumName = this.layouts.text(declared);
+      const member = this.enumMemberName(declared, value.value);
+      return member ? `${enumName}.${member}` : String(value.value);
+    }
+    if (!node) return this.literal(value);
+    if (node.captured.kind === "array") {
+      const element = this.model.elementType(declared);
+      const items = node.captured.items;
+      if (!items.length) return `defaultValue<${layout ?? this.layouts.text(declared, value)}>()`;
+      return `[${items.map((item) => (element ? this.valueText(item, element) : this.literal(item))).join(", ")}]`;
+    }
+    if (node.captured.kind === "object") return this.recordInitializer(node, declared);
+    if (node.captured.kind === "instance") {
+      const text = this.storageType(node);
+      return text ? this.instanceInitializer(node) : "{}";
+    }
+    throw new Error("A function has no stored value.");
+  }
+
+  instanceInitializer(node: ModelNode): string {
+    return `{ ${this.instanceFields(node)
+      .map(([name, layout]) => `${name}: ${this.instanceFieldInitializer(node, name, layout)}`)
+      .join(", ")} }`;
+  }
+
+  /** The initial value of one of an instance's stored fields. */
+  instanceFieldInitializer(node: ModelNode, name: string, layout: string): string {
+    const captured = node.captured;
+    if (captured.kind !== "instance") throw new Error("Not an instance.");
+    const value = captured.fields[name] ?? { kind: "undefined" as const };
+    const inner = this.model.node(value);
+    if (inner?.captured.kind === "instance") return this.instanceInitializer(inner);
+    if (
+      inner?.captured.kind === "array" &&
+      inner.captured.items.some((item) => this.model.node(item)?.captured.kind === "instance")
+    )
+      return `[${inner.captured.items.map((item) => this.instanceInitializer(this.model.node(item)!)).join(", ")}]`;
+    return this.fieldInitializer(node, name, value, layout);
+  }
+
+  private recordInitializer(node: ModelNode, declared: ts.Type): string {
+    const captured = node.captured;
+    if (captured.kind !== "object") throw new Error("Not a record.");
+    const tagged = this.layouts.tagged(declared);
+    const variant = this.model.variant(declared, captured);
+    const enumRecord = declared.aliasSymbol?.name === "Record";
+    const properties = tagged
+      ? this.taggedFields(tagged)
+      : this.checker
+          .getPropertiesOfType(enumRecord ? declared : variant)
+          .map((property) => property.name);
+    const parts = properties.map((name) => {
+      const field = captured.fields[name];
+      const fieldType =
+        tagged && name === tagged.tag
+          ? undefined
+          : this.model.fieldType(enumRecord ? declared : variant, name, captured);
+      if (tagged && name === tagged.tag) {
+        const tag = this.layouts.literalEnum(this.tagType(declared, tagged))!;
+        return `${name}: ${this.layouts.member(tag, field?.kind === "string" ? field.value : undefined)}`;
+      }
+      const memberType = fieldType ?? this.taggedFieldType(declared, tagged!, name);
+      if (!field) return `${name}: defaultValue<${this.layouts.text(memberType)}>()`;
+      return `${enumRecord ? `[${name}]` : name}: ${this.valueText(field, memberType)}`;
+    });
+    if (enumRecord) {
+      const [keyType, valueType] = declared.aliasTypeArguments as [ts.Type, ts.Type];
+      const literal = this.layouts.literalEnum(keyType);
+      const entries = properties.map((name, index) => {
+        const key = literal
+          ? this.layouts.member(literal, name)
+          : `${this.layouts.text(keyType)}.${this.enumMemberName(keyType, Number(name))}`;
+        return `[${key}]: ${parts[index]!.slice(parts[index]!.indexOf(": ") + 2)}`;
+      });
+      // An enum that is also optional elsewhere has an Undefined member the table must cover.
+      if (literal?.optional)
+        entries.unshift(
+          `[${this.layouts.member(literal, undefined)}]: ${this.defaultOf(valueType)}`,
+        );
+      return `{ ${entries.join(", ")} }`;
+    }
+    return `{ ${parts.join(", ")} }`;
+  }
+
+  private taggedFields(tagged: { tag: string; variants: ts.Type[] }): string[] {
+    const names = [tagged.tag];
+    for (const variant of tagged.variants)
+      for (const property of variant.getProperties())
+        if (!names.includes(property.name)) names.push(property.name);
+    return names;
+  }
+
+  private taggedFieldType(
+    declared: ts.Type,
+    tagged: { tag: string; variants: ts.Type[] },
+    name: string,
+  ): ts.Type {
+    for (const variant of tagged.variants) {
+      const property = variant.getProperty(name);
+      if (property) return this.checker.getTypeOfSymbol(property);
+    }
+    throw new Error(`${name} is in no variant of ${this.checker.typeToString(declared)}.`);
+  }
+
+  private tagType(declared: ts.Type, tagged: { tag: string; variants: ts.Type[] }): ts.Type {
+    this.layouts.text(declared);
+    const property = this.checker.getPropertyOfType(declared, tagged.tag);
+    return property ? this.checker.getTypeOfSymbol(property) : declared;
+  }
+
+  private enumMemberName(type: ts.Type, value: number): string | undefined {
+    return this.layouts
+      .enumDeclaration(type)
+      ?.members.find((member) => this.checker.getConstantValue(member) === value)
+      ?.name.getText();
+  }
+
+  private literal(value: CapturedValue): string {
+    switch (value.kind) {
+      case "number":
+        return String(value.value);
+      case "boolean":
+        return String(value.value);
+      case "string":
+        return JSON.stringify(value.value);
+      case "bigint":
+        return `${value.value}n`;
+      default:
+        throw new Error(`A captured ${value.kind} has no literal.`);
+    }
+  }
+
+  private isOptionalRecord(type: ts.Type): boolean {
+    if (!type.isUnion() || !type.types.some((part) => part.flags & ts.TypeFlags.Undefined))
+      return false;
+    return !this.layouts.literalEnum(type);
+  }
+
+  // ---- Routines ----
+
+  /** Specializes the entry function, returning its body. */
+  entry(declaration: ts.FunctionDeclaration | ts.ArrowFunction): string[] {
+    const frame: Frame = {
+      emitter: new Emitter(),
+      env: new Map(),
+      returns: undefined,
+      async: false,
+    };
+    this.body(declaration.body!, frame);
+    return frame.emitter.lines;
+  }
+
+  /** The name of `declaration` specialized for `self` and these known arguments. */
+  routine(
+    declaration: FunctionLike,
+    self: ModelNode | undefined,
+    args: Value[],
+    closure?: Env,
+  ): {
+    name: string;
+    args: string[];
+    returns: ts.Type | undefined;
+  } {
+    const signature = this.checker.getSignatureFromDeclaration(declaration);
+    const returnType = signature && this.checker.getReturnTypeOfSignature(signature);
+    const isAsync = Boolean(
+      ts.canHaveModifiers(declaration) &&
+      ts
+        .getModifiers(declaration)
+        ?.some((modifier) => modifier.kind === ts.SyntaxKind.AsyncKeyword),
+    );
+    const frame: Frame = {
+      emitter: new Emitter(),
+      env: new Map(closure),
+      self,
+      returns: returnType && (isAsync ? this.checker.getAwaitedType(returnType) : returnType),
+      async: isAsync,
+    };
+    const parameters: string[] = [];
+    const runtimeArgs: string[] = [];
+    const keys: string[] = [];
+    const parameterList = ts.isGetAccessorDeclaration(declaration) ? [] : declaration.parameters;
+    parameterList.forEach((parameter, index) => {
+      const arg = args[index] ?? constant(undefined);
+      const declared = this.checker.getTypeAtLocation(parameter);
+      this.bindParameter(parameter.name, arg, declared, frame, parameters, runtimeArgs, keys);
+    });
+    // Captured runtime locals become parameters of the specialized routine.
+    for (const [symbol, value] of closure ?? [])
+      if (value.kind === "code") {
+        const name = frame.emitter.local(symbol.name);
+        const type = value.declared ? this.layouts.text(value.declared) : "number";
+        parameters.push(`${name}: ${type}`);
+        runtimeArgs.push(value.text);
+        frame.env.set(symbol, { kind: "code", text: name, declared: value.declared, place: true });
+        keys.push(`${symbol.name}=code`);
+      }
+    const key = `${declarationKey(declaration)}|${self?.id ?? ""}|${keys.join(",")}`;
+    const known = this.specialized.get(key);
+    if (known) return { name: known, args: runtimeArgs, returns: frame.returns };
+    const name = this.routineName(declaration, self);
+    this.specialized.set(key, name);
+    if (ts.isArrowFunction(declaration) && !ts.isBlock(declaration.body)) {
+      const result = this.expression(declaration.body, frame, frame.returns);
+      frame.emitter.line(`return ${this.code(result, frame.returns, frame)};`);
+    } else this.body(declaration.body!, frame);
+    const resultText =
+      frame.returns && !(frame.returns.flags & ts.TypeFlags.Void)
+        ? this.layouts.text(frame.returns)
+        : "void";
+    const head = `${frame.async ? "async " : ""}function ${name}(${parameters.join(", ")}): ${
+      frame.async ? `Promise<${resultText}>` : resultText
+    } {`;
+    const where = self?.owner
+      ? ` /* ${self.owner.root.name}${self.owner.steps.map(stepText).join("")} */`
+      : "";
+    this.routines.push([`${head}${where}`, ...frame.emitter.lines, "}"].join("\n"));
+    return { name, args: runtimeArgs, returns: frame.returns };
+  }
+
+  private routineName(declaration: FunctionLike, self: ModelNode | undefined): string {
+    const own =
+      declaration.name && ts.isIdentifier(declaration.name) ? declaration.name.text : undefined;
+    const variable =
+      !own &&
+      declaration.parent &&
+      ts.isVariableDeclaration(declaration.parent) &&
+      ts.isIdentifier(declaration.parent.name)
+        ? declaration.parent.name.text
+        : undefined;
+    const owner = self?.captured.kind === "instance" ? self.captured.name : undefined;
+    const base = [owner, own ?? variable ?? "callback"].filter(Boolean).join("_");
+    let name = base;
+    for (let index = 2; this.routineNames.has(name); index++) name = `${base}_${index}`;
+    this.routineNames.add(name);
+    return name;
+  }
+
+  private bindParameter(
+    name: ts.BindingName,
+    arg: Value,
+    declared: ts.Type,
+    frame: Frame,
+    parameters: string[],
+    runtimeArgs: string[],
+    keys: string[],
+  ): void {
+    if (ts.isObjectBindingPattern(name)) {
+      for (const element of name.elements) {
+        const field = (element.propertyName ?? element.name).getText();
+        const inner = this.member(arg, field, element, frame);
+        this.bindParameter(
+          element.name,
+          inner,
+          this.checker.getTypeAtLocation(element),
+          frame,
+          parameters,
+          runtimeArgs,
+          keys,
+        );
+      }
+      return;
+    }
+    if (ts.isArrayBindingPattern(name))
+      throw new SpecializeError(name, "Array patterns are not supported in parameters.");
+    const symbol = this.checker.getSymbolAtLocation(name)!;
+    if (arg.kind === "code" || (arg.kind === "virtual" && !this.isKnownShape(arg))) {
+      const local = frame.emitter.local(name.text);
+      const iec = this.layouts.iecName(name.parent);
+      parameters.push(`${local}: ${iec ?? this.layouts.text(declared)}`);
+      runtimeArgs.push(this.assignmentText(arg, declared, frame, iec));
+      frame.env.set(symbol, { kind: "code", text: local, declared, place: true });
+      keys.push(`${name.text}=code`);
+      return;
+    }
+    if (
+      arg.kind === "const" &&
+      !(declared.flags & ts.TypeFlags.Undefined) &&
+      typeof arg.value !== "undefined"
+    ) {
+      // Runtime primitives stay parameters, so one routine serves every value.
+      const local = frame.emitter.local(name.text);
+      parameters.push(`${local}: ${this.layouts.text(declared)}`);
+      runtimeArgs.push(this.code(arg, declared, frame));
+      frame.env.set(symbol, { kind: "code", text: local, declared, place: true });
+      keys.push(`${name.text}=code`);
+      return;
+    }
+    frame.env.set(symbol, arg);
+    keys.push(`${name.text}=${valueKey(arg)}`);
+  }
+
+  private isKnownShape(value: Value): boolean {
+    return (
+      value.kind === "virtual" &&
+      [...(value.fields?.values() ?? []), ...(value.items ?? [])].some(
+        (inner) => inner.kind === "static" || inner.kind === "function",
+      )
+    );
+  }
+
+  // ---- Statements ----
+
+  private body(node: ts.ConciseBody, frame: Frame): void {
+    if (ts.isBlock(node)) for (const statement of node.statements) this.statement(statement, frame);
+    else frame.emitter.line(`${this.code(this.expression(node, frame), undefined, frame)};`);
+  }
+
+  private statement(node: ts.Statement, frame: Frame): void {
+    const { emitter } = frame;
+    if (ts.isBlock(node)) {
+      emitter.open("{");
+      for (const statement of node.statements) this.statement(statement, frame);
+      emitter.close();
+      return;
+    }
+    if (ts.isVariableStatement(node)) {
+      const mutable = !(node.declarationList.flags & ts.NodeFlags.Const);
+      for (const declaration of node.declarationList.declarations)
+        this.declare(declaration, mutable, frame);
+      return;
+    }
+    if (ts.isExpressionStatement(node)) {
+      this.effect(node.expression, frame);
+      return;
+    }
+    if (ts.isIfStatement(node)) {
+      const condition = this.expression(node.expression, frame);
+      if (
+        condition.kind === "const" ||
+        condition.kind === "static" ||
+        condition.kind === "function"
+      ) {
+        const truthy = condition.kind === "const" ? Boolean(condition.value) : true;
+        if (truthy) this.statement(node.thenStatement, frame);
+        else if (node.elseStatement) this.statement(node.elseStatement, frame);
+        return;
+      }
+      emitter.open(`if (${this.condition(condition, node.expression, frame)}) {`);
+      this.inner(node.thenStatement, frame);
+      if (node.elseStatement) {
+        emitter.close("} else {");
+        emitter.open("");
+        emitter.lines.pop();
+        this.inner(node.elseStatement, frame);
+      }
+      emitter.close();
+      return;
+    }
+    if (ts.isReturnStatement(node)) {
+      if (!node.expression) {
+        emitter.line("return;");
+        return;
+      }
+      if (ts.isSatisfiesExpression(node.expression) && this.isNever(node.expression.type)) {
+        emitter.line(`return ${this.defaultOf(frame.returns)};`);
+        return;
+      }
+      const value = this.expression(node.expression, frame, frame.returns);
+      emitter.line(`return ${this.code(value, frame.returns, frame)};`);
+      return;
+    }
+    if (ts.isForOfStatement(node)) {
+      this.forOf(node, frame);
+      return;
+    }
+    if (ts.isSwitchStatement(node)) {
+      this.switch(node, frame);
+      return;
+    }
+    if (ts.isForStatement(node) || ts.isWhileStatement(node)) {
+      throw new SpecializeError(
+        node,
+        "Use for…of over an array; counted and while loops are not lowered yet.",
+      );
+    }
+    if (ts.isTryStatement(node)) {
+      emitter.open("try {");
+      for (const statement of node.tryBlock.statements) this.statement(statement, frame);
+      if (node.catchClause) {
+        emitter.close(
+          `} catch${node.catchClause.variableDeclaration ? ` (${node.catchClause.variableDeclaration.name.getText()})` : ""} {`,
+        );
+        emitter.open("");
+        emitter.lines.pop();
+        for (const statement of node.catchClause.block.statements) this.statement(statement, frame);
+      }
+      emitter.close();
+      return;
+    }
+    if (ts.isBreakStatement(node) || ts.isContinueStatement(node)) {
+      emitter.line(node.getText());
+      return;
+    }
+    if (ts.isEmptyStatement(node)) return;
+    throw new SpecializeError(node, `${ts.SyntaxKind[node.kind]} is not supported in scan code.`);
+  }
+
+  /** A branch body: blocks keep their statements without another brace level. */
+  private inner(node: ts.Statement, frame: Frame): void {
+    if (ts.isBlock(node)) for (const statement of node.statements) this.statement(statement, frame);
+    else this.statement(node, frame);
+  }
+
+  private isNever(type: ts.TypeNode): boolean {
+    return type.kind === ts.SyntaxKind.NeverKeyword;
+  }
+
+  private defaultOf(type: ts.Type | undefined): string {
+    if (!type || type.flags & ts.TypeFlags.Void) return "";
+    if (type.flags & ts.TypeFlags.BooleanLike) return "false";
+    if (type.flags & ts.TypeFlags.NumberLike) return "0";
+    return `defaultValue<${this.layouts.text(type)}>()`;
+  }
+
+  private declare(declaration: ts.VariableDeclaration, mutable: boolean, frame: Frame): void {
+    const initializer = declaration.initializer;
+    if (!initializer)
+      throw new SpecializeError(declaration, "Initialize locals where they are declared.");
+    const value = this.expression(
+      initializer,
+      frame,
+      declaration.type && this.checker.getTypeAtLocation(declaration.type),
+    );
+    this.bind(
+      declaration.name,
+      value,
+      mutable,
+      frame,
+      this.checker.getTypeAtLocation(declaration.name),
+    );
+  }
+
+  /** Binds a local, or each name of a destructuring pattern, to a value. */
+  private bind(
+    name: ts.BindingName,
+    value: Value,
+    mutable: boolean,
+    frame: Frame,
+    declared: ts.Type,
+  ): void {
+    if (!ts.isIdentifier(name) && value.kind === "code" && !value.place)
+      value = this.temporaryOf(value, frame);
+    if (ts.isObjectBindingPattern(name)) {
+      for (const element of name.elements) {
+        const field = (element.propertyName ?? element.name).getText();
+        const inner = this.member(value, field, element, frame);
+        this.bind(
+          element.name,
+          inner,
+          mutable,
+          frame,
+          this.checker.getTypeAtLocation(element.name),
+        );
+      }
+      return;
+    }
+    if (ts.isArrayBindingPattern(name)) {
+      name.elements.forEach((element, index) => {
+        if (ts.isOmittedExpression(element)) return;
+        const inner = this.element(value, constant(index), element, frame);
+        this.bind(
+          element.name,
+          inner,
+          mutable,
+          frame,
+          this.checker.getTypeAtLocation(element.name),
+        );
+      });
+      return;
+    }
+    const symbol = this.checker.getSymbolAtLocation(name)!;
+    if (!mutable && value.kind !== "code") {
+      frame.env.set(symbol, value);
+      return;
+    }
+    if (!mutable && value.kind === "code" && value.place) {
+      // A const naming a place is an alias, as an object binding is in TypeScript.
+      if (this.isAggregate(declared)) {
+        frame.env.set(symbol, value);
+        return;
+      }
+    }
+    const local = frame.emitter.local(name.text);
+    const type = value.kind === "code" && value.iec ? value.iec : this.localType(declared);
+    frame.emitter.line(
+      `${mutable ? "let" : "const"} ${local}: ${type} = ${this.code(value, declared, frame)};`,
+    );
+    frame.env.set(symbol, {
+      kind: "code",
+      text: local,
+      declared,
+      place: true,
+      iec: value.kind === "code" ? value.iec : undefined,
+    });
+  }
+
+  /** A local's dialect type: a literal union keeps its enum; a lone literal widens to its base type. */
+  private localType(declared: ts.Type): string {
+    if (this.layouts.literalEnum(declared)) return this.layouts.text(declared);
+    return this.layouts.text(this.checker.getBaseTypeOfLiteralType(declared));
+  }
+
+  private isAggregate(type: ts.Type): boolean {
+    return Boolean(type.flags & ts.TypeFlags.Object) && !this.layouts.literalEnum(type);
+  }
+
+  private forOf(node: ts.ForOfStatement, frame: Frame): void {
+    const iterable = this.expression(node.expression, frame);
+    const items = this.items(iterable);
+    const declaration = node.initializer;
+    if (!ts.isVariableDeclarationList(declaration) || declaration.declarations.length !== 1)
+      throw new SpecializeError(node.initializer, "Declare one const in for…of.");
+    const name = declaration.declarations[0]!.name;
+    const declared = this.checker.getTypeAtLocation(name);
+    if (items) {
+      for (const item of items) {
+        frame.emitter.open("{");
+        this.bind(name, item, false, frame, declared);
+        this.inner(node.statement, frame);
+        frame.emitter.close();
+      }
+      return;
+    }
+    if (iterable.kind !== "code")
+      throw new SpecializeError(node.expression, "for…of needs an array.");
+    if (!ts.isIdentifier(name))
+      throw new SpecializeError(name, "Destructure a runtime element inside the loop.");
+    const local = frame.emitter.local(name.text);
+    frame.emitter.open(`for (const ${local} of ${iterable.text}) {`);
+    frame.env.set(this.checker.getSymbolAtLocation(name)!, {
+      kind: "code",
+      text: local,
+      declared,
+      place: true,
+    });
+    this.inner(node.statement, frame);
+    frame.emitter.close();
+  }
+
+  /**
+   * The elements of an array setup built or scan code assembled from known parts; undefined for
+   * a runtime array. Known arrays unroll, so each element's identity stays known.
+   */
+  private items(value: Value): Value[] | undefined {
+    if (value.kind === "virtual" && value.items) return value.items;
+    if (value.kind !== "static") return undefined;
+    const array = value.node;
+    const captured = array.captured;
+    if (captured.kind !== "array") return undefined;
+    return captured.items.map((item, index) =>
+      this.fromCaptured(item, array, { kind: "index", index }),
+    );
+  }
+
+  private switch(node: ts.SwitchStatement, frame: Frame): void {
+    const subject = this.expression(node.expression, frame);
+    const declared = subject.kind === "code" ? subject.declared : undefined;
+    if (subject.kind === "const") {
+      let matched = false;
+      for (const clause of node.caseBlock.clauses) {
+        if (!matched) {
+          if (ts.isDefaultClause(clause)) matched = true;
+          else {
+            const label = this.expression(clause.expression, frame);
+            matched = label.kind === "const" && label.value === subject.value;
+          }
+        }
+        if (!matched) continue;
+        for (const statement of clause.statements) {
+          if (ts.isBreakStatement(statement)) return;
+          this.statement(statement, frame);
+        }
+        if (clause.statements.some((statement) => ts.isReturnStatement(statement))) return;
+      }
+      return;
+    }
+    frame.emitter.open(`switch (${this.code(subject, declared, frame)}) {`);
+    for (const clause of node.caseBlock.clauses) {
+      if (ts.isDefaultClause(clause)) {
+        const unreachable = clause.statements.some(
+          (statement) =>
+            ts.isReturnStatement(statement) &&
+            statement.expression &&
+            ts.isSatisfiesExpression(statement.expression) &&
+            this.isNever(statement.expression.type),
+        );
+        frame.emitter.open("default: {");
+        if (unreachable)
+          frame.emitter.line(
+            frame.returns && !(frame.returns.flags & ts.TypeFlags.Void)
+              ? `return ${this.defaultOf(frame.returns)};`
+              : "break;",
+          );
+        else for (const statement of clause.statements) this.statement(statement, frame);
+        frame.emitter.close();
+        continue;
+      }
+      const label = this.expression(clause.expression, frame, declared);
+      frame.emitter.open(`case ${this.code(label, declared, frame)}: {`);
+      for (const statement of clause.statements) this.statement(statement, frame);
+      frame.emitter.close();
+    }
+    frame.emitter.close();
+  }
+
+  /** An expression evaluated for its effect. */
+  private effect(node: ts.Expression, frame: Frame): void {
+    if (ts.isVoidExpression(node)) {
+      const value = this.expression(node.expression, frame);
+      if (value.kind === "code") frame.emitter.line(`void ${value.text};`);
+      return;
+    }
+    if (ts.isBinaryExpression(node) && isAssignment(node.operatorToken.kind)) {
+      this.assign(node, frame);
+      return;
+    }
+    if (
+      (ts.isPrefixUnaryExpression(node) || ts.isPostfixUnaryExpression(node)) &&
+      (node.operator === ts.SyntaxKind.PlusPlusToken ||
+        node.operator === ts.SyntaxKind.MinusMinusToken)
+    ) {
+      const target = this.expression(node.operand, frame);
+      const text = this.placeText(target, node.operand);
+      frame.emitter.line(
+        this.store(
+          target,
+          `${text} ${node.operator === ts.SyntaxKind.PlusPlusToken ? "+" : "-"} 1`,
+        ),
+      );
+      return;
+    }
+    const value = this.expression(node, frame);
+    if (value.kind === "code" && value.text.includes("(")) frame.emitter.line(`${value.text};`);
+  }
+
+  private assign(node: ts.BinaryExpression, frame: Frame): void {
+    const target = this.expression(node.left, frame);
+    const text = this.placeText(target, node.left);
+    const declared = target.kind === "code" ? target.declared : undefined;
+    const operator = node.operatorToken.kind;
+    if (operator === ts.SyntaxKind.QuestionQuestionEqualsToken) {
+      const value = this.expression(
+        node.right,
+        frame,
+        declared && this.checker.getNonNullableType(declared),
+      );
+      frame.emitter.open(`if (${this.isUndefinedText(text, declared)}) {`);
+      frame.emitter.line(
+        this.store(
+          target,
+          this.wrapDefined(
+            this.code(value, declared && this.checker.getNonNullableType(declared), frame),
+            declared,
+          ),
+        ),
+      );
+      frame.emitter.close();
+      return;
+    }
+    const value = this.expression(node.right, frame, declared);
+    if (operator === ts.SyntaxKind.EqualsToken) {
+      frame.emitter.line(
+        this.store(
+          target,
+          this.assignmentText(
+            value,
+            declared,
+            frame,
+            target.kind === "code" ? target.iec : undefined,
+          ),
+        ),
+      );
+      return;
+    }
+    const binary = compoundOperator(operator);
+    if (!binary)
+      throw new SpecializeError(node, `${node.operatorToken.getText()} is not supported.`);
+    frame.emitter.line(
+      this.store(target, `${text} ${binary} ${this.code(value, declared, frame)}`),
+    );
+  }
+
+  /** A statement storing `text` into a place, through its module's setter when it has one. */
+  private store(target: Value, text: string): string {
+    if (target.kind !== "code") throw new Error("Not a place.");
+    return target.setter ? `${target.setter}(${text});` : `${target.text} = ${text};`;
+  }
+
+  /** The text stored into a place of `declared` type, wrapping an optional's value. */
+  private assignmentText(
+    value: Value,
+    declared: ts.Type | undefined,
+    frame: Frame,
+    iec?: string,
+  ): string {
+    const target = iec ?? (declared && declared.flags & ts.TypeFlags.Number ? "DINT" : undefined);
+    if (target && value.kind === "code" && needsConversion(value.iec ?? "DINT", target)) {
+      // A TypeScript number holds any of these; in the PLC a value converts as an IEC assignment does.
+      this.typeImports.add("wrap");
+      return `wrap<${target}>(${this.code(value, undefined, frame)})`;
+    }
+    if (declared && this.isOptionalRecord(declared)) {
+      if (value.kind === "const" && value.value === undefined)
+        return `defaultValue<${this.layouts.text(declared)}>()`;
+      if (value.kind === "code" && value.declared && this.isOptionalRecord(value.declared))
+        return value.text;
+      return this.wrapDefined(
+        this.code(value, this.checker.getNonNullableType(declared), frame),
+        declared,
+      );
+    }
+    return this.code(value, declared, frame);
+  }
+
+  private wrapDefined(text: string, declared: ts.Type | undefined): string {
+    return declared && this.isOptionalRecord(declared) ? `{ has: true, value: ${text} }` : text;
+  }
+
+  private isUndefinedText(text: string, declared: ts.Type | undefined): string {
+    if (declared && this.isOptionalRecord(declared)) return `!${text}.has`;
+    const literal = declared && this.layouts.literalEnum(declared);
+    if (literal) return `${text} === ${this.layouts.member(literal, undefined)}`;
+    throw new Error("Only optional values can be undefined.");
+  }
+
+  private placeText(value: Value, node: ts.Node): string {
+    if (value.kind === "code" && value.place) return value.text;
+    throw new SpecializeError(node, "Assign to stored state: a field scan code owns, or a let.");
+  }
+
+  // ---- Expressions ----
+
+  expression(node: ts.Expression, frame: Frame, expected?: ts.Type): Value {
+    if (
+      ts.isParenthesizedExpression(node) ||
+      ts.isNonNullExpression(node) ||
+      ts.isAsExpression(node) ||
+      ts.isSatisfiesExpression(node)
+    )
+      return this.expression(node.expression, frame, expected);
+    if (ts.isNumericLiteral(node)) return constant(Number(node.text));
+    if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node))
+      return constant(node.text);
+    if (node.kind === ts.SyntaxKind.TrueKeyword) return constant(true);
+    if (node.kind === ts.SyntaxKind.FalseKeyword) return constant(false);
+    if (ts.isBigIntLiteral(node)) return constant(BigInt(node.text.slice(0, -1)));
+    if (node.kind === ts.SyntaxKind.ThisKeyword) {
+      if (!frame.self) throw new SpecializeError(node, "`this` outside a method.");
+      return { kind: "static", node: frame.self };
+    }
+    if (ts.isIdentifier(node)) return this.identifier(node, frame);
+    if (ts.isPropertyAccessExpression(node)) {
+      const object = this.expression(node.expression, frame);
+      if (node.questionDotToken && object.kind === "const" && object.value === undefined)
+        return constant(undefined);
+      return this.narrowed(this.member(object, node.name.text, node, frame), node);
+    }
+    if (ts.isElementAccessExpression(node)) {
+      const object = this.expression(node.expression, frame);
+      const index = this.expression(node.argumentExpression, frame);
+      return this.element(object, index, node, frame);
+    }
+    if (ts.isCallExpression(node)) return this.call(node, frame, expected);
+    if (ts.isAwaitExpression(node)) {
+      const value = this.expression(node.expression, frame);
+      return {
+        kind: "code",
+        text: `await ${this.code(value, undefined, frame)}`,
+        declared: this.checker.getTypeAtLocation(node),
+      };
+    }
+    if (ts.isPrefixUnaryExpression(node)) return this.unary(node, frame);
+    if (ts.isBinaryExpression(node)) return this.binary(node, frame, expected);
+    if (ts.isConditionalExpression(node)) {
+      const condition = this.expression(node.condition, frame);
+      if (condition.kind === "const")
+        return this.expression(condition.value ? node.whenTrue : node.whenFalse, frame, expected);
+      const declared = expected ?? this.checker.getTypeAtLocation(node);
+      const whenTrue = this.expression(node.whenTrue, frame, declared);
+      const whenFalse = this.expression(node.whenFalse, frame, declared);
+      return {
+        kind: "code",
+        text: `(${this.condition(condition, node.condition, frame)} ? ${this.code(whenTrue, declared, frame)} : ${this.code(whenFalse, declared, frame)})`,
+        declared,
+      };
+    }
+    if (ts.isArrowFunction(node) || ts.isFunctionExpression(node))
+      return { kind: "function", declaration: node, self: frame.self, env: frame.env };
+    if (ts.isObjectLiteralExpression(node)) return this.objectLiteral(node, frame);
+    if (ts.isArrayLiteralExpression(node)) {
+      const items: Value[] = [];
+      for (const element of node.elements) {
+        if (ts.isSpreadElement(element)) {
+          const spread = this.items(this.expression(element.expression, frame));
+          if (!spread) throw new SpecializeError(element, "Spread an array setup built.");
+          items.push(...spread);
+        } else items.push(this.expression(element, frame));
+      }
+      return { kind: "virtual", items };
+    }
+    if (ts.isTemplateExpression(node))
+      throw new SpecializeError(node, "Template strings are not supported in scan code.");
+    throw new SpecializeError(node, `${ts.SyntaxKind[node.kind]} is not supported in scan code.`);
+  }
+
+  private identifier(node: ts.Identifier, frame: Frame): Value {
+    if (node.text === "undefined") return constant(undefined);
+    let symbol = this.checker.getSymbolAtLocation(node);
+    if (!symbol) throw new SpecializeError(node, `${node.text} is not declared.`);
+    const local = frame.env.get(symbol);
+    if (local) return this.narrowed(local, node);
+    while (symbol.flags & ts.SymbolFlags.Alias) symbol = this.checker.getAliasedSymbol(symbol);
+    const own = frame.env.get(symbol);
+    if (own) return own;
+    const declaration = symbol.valueDeclaration ?? symbol.declarations?.[0];
+    if (!declaration) throw new SpecializeError(node, `${node.text} has no declaration.`);
+    if (ts.isFunctionDeclaration(declaration)) return { kind: "function", declaration };
+    if (ts.isVariableDeclaration(declaration)) {
+      const initializer = declaration.initializer;
+      if (initializer && (ts.isArrowFunction(initializer) || ts.isFunctionExpression(initializer)))
+        return { kind: "function", declaration: initializer };
+      const root = this.model.roots.find((item) => item.declaration === declaration);
+      if (root) return this.rootValue(root, node);
+      if (
+        ts.isVariableStatement(declaration.parent.parent) &&
+        declaration.parent.parent.parent &&
+        ts.isSourceFile(declaration.parent.parent.parent)
+      ) {
+        if (initializer) return this.expression(initializer, { ...frame, env: new Map() });
+      }
+    }
+    if (ts.isEnumMember(declaration))
+      return constant(this.checker.getConstantValue(declaration) as number);
+    throw new SpecializeError(node, `${node.text} is not available in scan code.`);
+  }
+
+  private rootValue(root: Root, at: ts.Node): Value {
+    const value = this.model.rootValues.get(root)!;
+    const node = this.model.node(value);
+    if (node) {
+      if (this.kept(root.file) && node.captured.kind !== "service") return this.keptRoot(root);
+      return { kind: "static", node };
+    }
+    if (this.kept(root.file) || root.declaration.parent.flags & ts.NodeFlags.Const)
+      return this.capturedConstant(value, at);
+    // A module `let` of a plain module is state in its own global list.
+    const namespace = this.namespace(root);
+    this.storedRoots.add(root);
+    return {
+      kind: "code",
+      text: `${namespace}.${root.name}`,
+      declared: this.checker.getTypeAtLocation(root.declaration.name),
+      place: true,
+      iec: this.layouts.iecName(root.declaration),
+      setter: `${namespace}.${setterName(root.name)}`,
+    };
+  }
+
+  /** A binding in a module the program keeps, read by its own name. */
+  private keptRoot(root: Root): Value {
+    const names = this.imports.get(root.file) ?? new Set<string>();
+    names.add(root.name);
+    this.imports.set(root.file, names);
+    return {
+      kind: "code",
+      text: root.name,
+      declared: this.checker.getTypeAtLocation(root.declaration.name),
+      place: !(root.declaration.parent.flags & ts.NodeFlags.Const),
+    };
+  }
+
+  private capturedConstant(value: CapturedValue, at: ts.Node): Value {
+    if (value.kind === "node") throw new SpecializeError(at, "Not a primitive.");
+    return constant(
+      value.kind === "undefined"
+        ? undefined
+        : value.kind === "bigint"
+          ? BigInt(value.value)
+          : value.value,
+    );
+  }
+
+  /** A known node or primitive read from a captured object at one step. */
+  private fromCaptured(value: CapturedValue, holder: ModelNode, step: Step): Value {
+    const node = this.model.node(value);
+    if (node) {
+      // A field scan code assigns as a whole is a place, holding its own copy of what setup gave it.
+      if (
+        (node.captured.kind === "object" || node.captured.kind === "array") &&
+        step.kind === "field" &&
+        this.written(holder, step.name)
+      )
+        return this.storedField(holder, step);
+      return { kind: "static", node };
+    }
+    const stored =
+      step.kind === "field" ? this.stored(holder, step.name) : this.storedArray(holder);
+    if (stored) return this.storedField(holder, step);
+    return this.capturedConstant(value, holder.type?.symbol?.valueDeclaration ?? this.sources[0]!);
+  }
+
+  /** The IEC width a captured field's declaration names. */
+  private fieldIec(holder: ModelNode, name: string): string | undefined {
+    if (holder.captured.kind === "instance")
+      return this.layouts.iecName(this.model.member(this.model.classOf(holder), name));
+    return this.layouts.iecName(this.fieldSymbol(holder, name)?.valueDeclaration);
+  }
+
+  /** The IEC width of an array's elements, from the declaration holding the array. */
+  private elementIec(array: ModelNode): string | undefined {
+    const owner = array.owner;
+    const last = owner?.steps.at(-1);
+    if (!owner || last?.kind !== "field") return undefined;
+    const holder = this.at(owner.root, owner.steps.slice(0, -1));
+    const declaration =
+      holder &&
+      (holder.captured.kind === "instance"
+        ? this.model.member(this.model.classOf(holder), last.name)
+        : this.fieldSymbol(holder, last.name)?.valueDeclaration);
+    const node = declaration && (declaration as { type?: ts.TypeNode }).type;
+    const element =
+      node && ts.isArrayTypeNode(node)
+        ? node.elementType
+        : node && ts.isTypeReferenceNode(node)
+          ? node.typeArguments?.[0]
+          : undefined;
+    return element ? this.layouts.iecName({ type: element } as unknown as ts.Node) : undefined;
+  }
+
+  private storedField(holder: ModelNode, step: Step): Value {
+    const declared =
+      step.kind === "index"
+        ? holder.type && this.model.elementType(holder.type)
+        : holder.captured.kind === "instance"
+          ? (() => {
+              const member = this.model.member(this.model.classOf(holder), step.name);
+              return member && this.checker.getTypeAtLocation(member.name);
+            })()
+          : holder.type && this.model.fieldType(holder.type, step.name, holder.captured);
+    const global =
+      step.kind === "field" &&
+      holder.owner?.steps.length === 0 &&
+      this.flattened(holder.owner.root);
+    return {
+      kind: "code",
+      text: `${this.pathText(holder)}${step.kind === "index" ? `[${step.index}]` : `.${step.name}`}`,
+      declared,
+      place: true,
+      iec: step.kind === "field" ? this.fieldIec(holder, step.name) : this.elementIec(holder),
+      ...(global && { setter: `${this.pathText(holder)}.${setterName(step.name)}` }),
+    };
+  }
+
+  member(object: Value, name: string, at: ts.Node, frame: Frame): Value {
+    if (object.kind === "static") {
+      const node = object.node;
+      const captured = node.captured;
+      if (captured.kind === "service")
+        return {
+          kind: "static",
+          node: this.serviceNode(captured.path ? `${captured.path}.${name}` : name),
+        };
+      if (captured.kind === "instance") {
+        const declaration = this.model.classOf(node);
+        const accessor = declaration.members.find(
+          (member): member is ts.GetAccessorDeclaration =>
+            ts.isGetAccessorDeclaration(member) && member.name.getText() === name,
+        );
+        if (accessor)
+          return this.invoke(
+            { kind: "function", declaration: accessor, self: node },
+            [],
+            at,
+            frame,
+          );
+        const method = declaration.members.find(
+          (member): member is ts.MethodDeclaration =>
+            ts.isMethodDeclaration(member) && member.name.getText() === name,
+        );
+        if (method) return { kind: "function", declaration: method, self: node };
+      }
+      if (captured.kind === "array" && name === "length") return constant(captured.items.length);
+      if (captured.kind === "object" || captured.kind === "instance") {
+        const field = captured.fields[name];
+        if (!field) {
+          if (captured.kind === "object") return constant(undefined);
+          throw new SpecializeError(at, `${name} is not set during setup.`);
+        }
+        return this.fromCaptured(field, node, { kind: "field", name });
+      }
+      throw new SpecializeError(at, `${name} cannot be read from this value.`);
+    }
+    if (object.kind === "virtual") {
+      if (name === "length" && object.items) return constant(object.items.length);
+      const field = object.fields?.get(name);
+      if (field) return field;
+      throw new SpecializeError(at, `${name} is not set.`);
+    }
+    if (object.kind === "code") {
+      const declared = object.declared && this.fieldDeclared(object.declared, name, at);
+      const property =
+        object.declared &&
+        this.checker.getPropertyOfType(this.checker.getNonNullableType(object.declared), name);
+      return {
+        kind: "code",
+        text: `${object.text}.${name}`,
+        declared,
+        place: object.place,
+        iec: this.layouts.iecName(property?.valueDeclaration),
+      };
+    }
+    if (object.kind === "const" && object.value === undefined)
+      throw new SpecializeError(at, `Reading ${name} of undefined.`);
+    throw new SpecializeError(at, `${name} cannot be read from this value.`);
+  }
+
+  /** An optional's value where TypeScript has narrowed out undefined, as `x` reads after `x !== undefined`. */
+  private narrowed(value: Value, at: ts.Node): Value {
+    if (value.kind !== "code" || !value.declared || !this.isOptionalRecord(value.declared))
+      return value;
+    const type = this.checker.getTypeAtLocation(at);
+    if (type.isUnion() && type.types.some((part) => part.flags & ts.TypeFlags.Undefined))
+      return value;
+    if (type.flags & ts.TypeFlags.Undefined) return value;
+    return {
+      kind: "code",
+      text: `${value.text}.value`,
+      declared: this.checker.getNonNullableType(value.declared),
+      place: value.place,
+    };
+  }
+
+  /** The declared type of a field of a runtime record, through optionals and tagged unions. */
+  private fieldDeclared(type: ts.Type, name: string, at: ts.Node): ts.Type | undefined {
+    const defined = this.checker.getNonNullableType(type);
+    const tagged = this.layouts.tagged(defined);
+    if (tagged)
+      return name === tagged.tag
+        ? this.tagType(defined, tagged)
+        : this.taggedFieldType(defined, tagged, name);
+    const property = this.checker.getPropertyOfType(defined, name);
+    if (!property)
+      throw new SpecializeError(
+        at,
+        `${name} is not a field of ${this.checker.typeToString(type)}.`,
+      );
+    return this.checker.getTypeOfSymbol(property);
+  }
+
+  private readonly services = new Map<string, ModelNode>();
+  private serviceNode(path: string): ModelNode {
+    const known = this.services.get(path);
+    if (known) return known;
+    const node: ModelNode = { id: -1 - this.services.size, captured: { kind: "service", path } };
+    this.services.set(path, node);
+    return node;
+  }
+
+  element(object: Value, index: Value, at: ts.Node, frame: Frame): Value {
+    if (index.kind === "const" && typeof index.value === "number") {
+      if (object.kind === "virtual" && object.items) {
+        const item = object.items[index.value];
+        if (!item) throw new SpecializeError(at, `Index ${index.value} is past the end.`);
+        return item;
+      }
+      if (object.kind === "static" && object.node.captured.kind === "array") {
+        const item = object.node.captured.items[index.value];
+        if (!item) return constant(undefined);
+        return this.fromCaptured(item, object.node, { kind: "index", index: index.value });
+      }
+      if (object.kind === "static" && object.node.captured.kind === "object") {
+        const field = object.node.captured.fields[String(index.value)];
+        if (!field) return constant(undefined);
+        return this.fromCaptured(field, object.node, { kind: "field", name: String(index.value) });
+      }
+    }
+    if (object.kind === "static") {
+      const node = object.node;
+      // A runtime index into stored data, or into a fixed table of plain values.
+      const declared =
+        node.type &&
+        (node.captured.kind === "array"
+          ? this.model.elementType(node.type)
+          : this.recordElement(node.type));
+      const text = this.storedNode(node) ? this.pathText(node) : this.table(node);
+      return {
+        kind: "code",
+        text: `${text}[${this.code(index, undefined, frame)}]`,
+        declared,
+        place: true,
+      };
+    }
+    if (object.kind === "code") {
+      const declared =
+        object.declared &&
+        (this.model.elementType(object.declared) ?? this.recordElement(object.declared));
+      return {
+        kind: "code",
+        text: `${object.text}[${this.code(index, undefined, frame)}]`,
+        declared,
+        place: object.place,
+      };
+    }
+    if (object.kind === "virtual" && object.items) {
+      const text = this.materialize(object, at, frame);
+      return {
+        kind: "code",
+        text: `${text}[${this.code(index, undefined, frame)}]`,
+        declared: this.checker.getTypeAtLocation(at),
+      };
+    }
+    throw new SpecializeError(at, "This value cannot be indexed.");
+  }
+
+  private recordElement(type: ts.Type): ts.Type | undefined {
+    return type.aliasSymbol?.name === "Record" ? type.aliasTypeArguments?.[1] : undefined;
+  }
+
+  private storedNode(node: ModelNode): boolean {
+    return node.captured.kind === "array" ? this.storedArray(node) : this.storedWhole(node);
+  }
+
+  private readonly tables = new Map<number, string>();
+  readonly tableDeclarations: string[] = [];
+  /** A fixed table setup built, emitted once for scan code that indexes it at runtime. */
+  private table(node: ModelNode): string {
+    const known = this.tables.get(node.id);
+    if (known) return known;
+    if (!node.type) throw new Error("A table needs a declared type.");
+    const name = `tsplcTable${this.tables.size + 1}`;
+    this.tables.set(node.id, name);
+    const type = this.layouts.text(node.type, { kind: "node", id: node.id });
+    this.tableDeclarations.push(
+      `const ${name}: ${type} = ${this.valueText({ kind: "node", id: node.id }, node.type, type)};`,
+    );
+    return name;
+  }
+
+  /** Stores a scan-built array in a local, for indexing at runtime. */
+  private materialize(value: Value, at: ts.Node, frame: Frame): string {
+    const type = this.checker.getTypeAtLocation(at);
+    const element = this.model.elementType(type);
+    if (!element || value.kind !== "virtual" || !value.items)
+      throw new SpecializeError(at, "Not an array.");
+    const local = frame.emitter.temporary();
+    frame.emitter.line(
+      `const ${local}: FixedArray<${this.layouts.text(element)}, ${Math.max(value.items.length, 1)}> = [${value.items
+        .map((item) => this.code(item, element, frame))
+        .join(", ")}];`,
+    );
+    return local;
+  }
+
+  private objectLiteral(node: ts.ObjectLiteralExpression, frame: Frame): Value {
+    const fields = new Map<string, Value>();
+    for (const property of node.properties) {
+      if (ts.isPropertyAssignment(property))
+        fields.set(
+          property.name.getText(),
+          this.expression(
+            property.initializer,
+            frame,
+            this.checker.getContextualType(property.initializer),
+          ),
+        );
+      else if (ts.isShorthandPropertyAssignment(property)) {
+        const symbol = this.checker.getShorthandAssignmentValueSymbol(property);
+        const local = symbol && frame.env.get(symbol);
+        fields.set(property.name.text, local ?? this.expression(property.name, frame));
+      } else throw new SpecializeError(property, "Write each field of a record.");
+    }
+    return { kind: "virtual", fields };
+  }
+
+  private unary(node: ts.PrefixUnaryExpression, frame: Frame): Value {
+    const operand = this.expression(node.operand, frame);
+    switch (node.operator) {
+      case ts.SyntaxKind.ExclamationToken:
+        if (operand.kind === "const") return constant(!operand.value);
+        if (operand.kind === "static" || operand.kind === "function") return constant(false);
+        return {
+          kind: "code",
+          text: `!${this.condition(operand, node.operand, frame)}`,
+          declared: this.checker.getBooleanType(),
+        };
+      case ts.SyntaxKind.MinusToken:
+        if (operand.kind === "const" && typeof operand.value === "number")
+          return constant(-operand.value);
+        return {
+          kind: "code",
+          text: `-${this.code(operand, undefined, frame)}`,
+          declared: this.checker.getTypeAtLocation(node),
+        };
+      case ts.SyntaxKind.PlusToken:
+        return operand;
+      default:
+        throw new SpecializeError(node, `${ts.tokenToString(node.operator)} is not supported.`);
+    }
+  }
+
+  private binary(node: ts.BinaryExpression, frame: Frame, expected?: ts.Type): Value {
+    const kind = node.operatorToken.kind;
+    if (kind === ts.SyntaxKind.AmpersandAmpersandToken || kind === ts.SyntaxKind.BarBarToken) {
+      const left = this.expression(node.left, frame);
+      const and = kind === ts.SyntaxKind.AmpersandAmpersandToken;
+      if (left.kind === "const") {
+        if (Boolean(left.value) !== and) return left;
+        return this.expression(node.right, frame, expected);
+      }
+      if (left.kind === "static" || left.kind === "function")
+        return and ? this.expression(node.right, frame, expected) : left;
+      const right = this.expression(node.right, frame, expected);
+      if (right.kind === "const" && typeof right.value === "boolean") {
+        if (right.value === and)
+          return {
+            kind: "code",
+            text: this.condition(left, node.left, frame),
+            declared: this.checker.getBooleanType(),
+          };
+        return constant(!and);
+      }
+      return {
+        kind: "code",
+        text: `(${this.condition(left, node.left, frame)} ${and ? "&&" : "||"} ${this.condition(right, node.right, frame)})`,
+        declared: this.checker.getBooleanType(),
+      };
+    }
+    if (kind === ts.SyntaxKind.QuestionQuestionToken) {
+      const left = this.expression(node.left, frame);
+      if (left.kind === "const")
+        return left.value === undefined ? this.expression(node.right, frame, expected) : left;
+      if (left.kind === "static") return left;
+      const declared = left.kind === "code" ? left.declared : undefined;
+      const right = this.expression(
+        node.right,
+        frame,
+        declared && this.checker.getNonNullableType(declared),
+      );
+      return {
+        kind: "code",
+        text: `(${this.isUndefinedText(this.code(left, declared, frame), declared)} ? ${this.code(right, declared && this.checker.getNonNullableType(declared), frame)} : ${this.code(left, undefined, frame)}${declared && this.isOptionalRecord(declared) ? ".value" : ""})`,
+        declared: declared && this.checker.getNonNullableType(declared),
+      };
+    }
+    if (isAssignment(kind)) throw new SpecializeError(node, "Assign in a statement of its own.");
+    const equality = [
+      ts.SyntaxKind.EqualsEqualsEqualsToken,
+      ts.SyntaxKind.ExclamationEqualsEqualsToken,
+      ts.SyntaxKind.EqualsEqualsToken,
+      ts.SyntaxKind.ExclamationEqualsToken,
+    ].includes(kind);
+    const left = this.expression(node.left, frame);
+    const right = this.expression(
+      node.right,
+      frame,
+      left.kind === "code" ? left.declared : undefined,
+    );
+    const negate =
+      kind === ts.SyntaxKind.ExclamationEqualsEqualsToken ||
+      kind === ts.SyntaxKind.ExclamationEqualsToken;
+    if (equality) {
+      const folded = this.equal(left, right);
+      if (folded !== undefined) return constant(negate ? !folded : folded);
+      const [code, other] = left.kind === "code" ? [left, right] : [right as Value, left];
+      if (code.kind === "code" && other.kind === "const" && other.value === undefined) {
+        const test = this.isUndefinedText(code.text, code.declared);
+        return {
+          kind: "code",
+          text: negate ? `!(${test})` : test,
+          declared: this.checker.getBooleanType(),
+        };
+      }
+      const declared = code.kind === "code" ? code.declared : undefined;
+      const [leftText, rightText] = this.comparable(left, right, declared, frame);
+      const text = `${leftText} ${negate ? "!==" : "==="} ${rightText}`;
+      return { kind: "code", text: `(${text})`, declared: this.checker.getBooleanType() };
+    }
+    if (
+      left.kind === "const" &&
+      right.kind === "const" &&
+      typeof left.value === "number" &&
+      typeof right.value === "number"
+    ) {
+      const folded = foldNumber(kind, left.value, right.value);
+      if (folded !== undefined) return constant(folded);
+    }
+    const operator = binaryToken(kind);
+    if (!operator)
+      throw new SpecializeError(node, `${node.operatorToken.getText()} is not supported.`);
+    const declared = this.checker.getTypeAtLocation(node);
+    const [leftText, rightText] = ["<", "<=", ">", ">="].includes(operator)
+      ? this.comparable(left, right, undefined, frame)
+      : [this.code(left, undefined, frame), this.code(right, undefined, frame)];
+    return { kind: "code", text: `(${leftText} ${operator} ${rightText})`, declared };
+  }
+
+  /**
+   * Both sides of a comparison as text. Integers of different signedness, which TypeScript
+   * compares as numbers, both widen to LINT so the PLC compares them exactly.
+   */
+  private comparable(
+    left: Value,
+    right: Value,
+    declared: ts.Type | undefined,
+    frame: Frame,
+  ): [string, string] {
+    const leftText = this.code(left, declared, frame),
+      rightText = this.code(right, declared, frame);
+    if (left.kind !== "code" || right.kind !== "code") return [leftText, rightText];
+    const from = left.iec ?? "DINT",
+      to = right.iec ?? "DINT";
+    if (!needsConversion(from, to) || !needsConversion(to, from)) return [leftText, rightText];
+    this.typeImports.add("wrap");
+    return [`wrap<LINT>(${leftText})`, `wrap<LINT>(${rightText})`];
+  }
+
+  /** Equality known now: two known objects, or a known object against undefined. */
+  private equal(left: Value, right: Value): boolean | undefined {
+    if (left.kind === "const" && right.kind === "const") return left.value === right.value;
+    if (left.kind === "static" && right.kind === "static") return left.node === right.node;
+    if (
+      (left.kind === "static" && right.kind === "const") ||
+      (left.kind === "const" && right.kind === "static")
+    )
+      return false;
+    return undefined;
+  }
+
+  /** A boolean condition, including JavaScript truthiness of optionals and enums. */
+  private condition(value: Value, at: ts.Node, frame: Frame): string {
+    if (value.kind === "code" && value.declared) {
+      const declared = value.declared;
+      if (this.isOptionalRecord(declared) && !ts.isPrefixUnaryExpression(at)) {
+        const type = this.checker.getTypeAtLocation(at);
+        if (!(type.flags & ts.TypeFlags.BooleanLike)) return `${value.text}.has`;
+      }
+      const literal = this.layouts.literalEnum(declared);
+      if (literal?.optional) return `${value.text} !== ${this.layouts.member(literal, undefined)}`;
+    }
+    return this.code(value, undefined, frame);
+  }
+
+  // ---- Calls ----
+
+  private call(node: ts.CallExpression, frame: Frame, expected?: ts.Type): Value {
+    const callee = node.expression;
+    // Array methods and other calls the language provides.
+    if (ts.isPropertyAccessExpression(callee) || ts.isPropertyAccessChain(callee)) {
+      const name = callee.name.text;
+      if (ts.isIdentifier(callee.expression) && callee.expression.text === "Math")
+        return this.math(name, node, frame);
+      if (
+        ts.isIdentifier(callee.expression) &&
+        callee.expression.text === "Object" &&
+        name === "values"
+      ) {
+        const object = this.expression(node.arguments[0]!, frame);
+        if (object.kind === "static" && object.node.captured.kind === "object")
+          return {
+            kind: "virtual",
+            items: Object.entries(object.node.captured.fields).map(([field, value]) =>
+              this.fromCaptured(value, object.node, { kind: "field", name: field }),
+            ),
+          };
+        throw new SpecializeError(node, "Object.values needs a record setup built.");
+      }
+      const receiver = this.expression(callee.expression, frame);
+      const items = this.items(receiver);
+      if (items && isArrayMethod(name)) return this.arrayMethod(name, items, node, frame);
+      if (receiver.kind === "static" && receiver.node.captured.kind === "service") {
+        const path = receiver.node.captured.path ? `${receiver.node.captured.path}.${name}` : name;
+        return this.serviceCall(path, node, frame);
+      }
+      const method = this.member(receiver, name, callee, frame);
+      if (method.kind === "static" && method.node.captured.kind === "service")
+        return this.serviceCall(method.node.captured.path, node, frame);
+      return this.invoke(
+        method,
+        node.arguments.map((argument, index) => this.argument(argument, method, index, frame)),
+        node,
+        frame,
+        expected,
+      );
+    }
+    const target = this.expression(callee, frame);
+    if (target.kind === "static" && target.node.captured.kind === "service")
+      return this.serviceCall(target.node.captured.path, node, frame);
+    if (target.kind === "static" && target.node.captured.kind === "function") {
+      const fn = this.functionDeclaration(target.node.captured.file, target.node.captured.name);
+      return this.invoke(
+        { kind: "function", declaration: fn },
+        node.arguments.map((argument, index) =>
+          this.argument(argument, { kind: "function", declaration: fn }, index, frame),
+        ),
+        node,
+        frame,
+        expected,
+      );
+    }
+    if (ts.isIdentifier(callee) && this.sdkCall(callee)) return this.sdk(callee.text, node, frame);
+    return this.invoke(
+      target,
+      node.arguments.map((argument, index) => this.argument(argument, target, index, frame)),
+      node,
+      frame,
+      expected,
+    );
+  }
+
+  private argument(node: ts.Expression, callee: Value, index: number, frame: Frame): Value {
+    let expected: ts.Type | undefined;
+    if (callee.kind === "function" && !ts.isGetAccessorDeclaration(callee.declaration)) {
+      const parameter = callee.declaration.parameters[index];
+      expected = parameter && this.checker.getTypeAtLocation(parameter);
+    }
+    return this.expression(node, frame, expected);
+  }
+
+  private functionDeclaration(file: string, name: string): FunctionLike {
+    const source = this.sources.find((item) => item.fileName === file);
+    for (const statement of source?.statements ?? []) {
+      if (ts.isFunctionDeclaration(statement) && statement.name?.text === name) return statement;
+      if (ts.isVariableStatement(statement))
+        for (const declaration of statement.declarationList.declarations)
+          if (
+            ts.isIdentifier(declaration.name) &&
+            declaration.name.text === name &&
+            declaration.initializer &&
+            (ts.isArrowFunction(declaration.initializer) ||
+              ts.isFunctionExpression(declaration.initializer))
+          )
+            return declaration.initializer;
+    }
+    throw new Error(`${file}: no function ${name}.`);
+  }
+
+  /** SDK functions scan code calls, such as the PLC clock. */
+  private sdkCall(callee: ts.Identifier): boolean {
+    let symbol = this.checker.getSymbolAtLocation(callee);
+    while (symbol && symbol.flags & ts.SymbolFlags.Alias)
+      symbol = this.checker.getAliasedSymbol(symbol);
+    const file = symbol?.declarations?.[0]?.getSourceFile().fileName ?? "";
+    return file.includes("/@tsplc/compiler/") || file.includes("/packages/compiler/");
+  }
+
+  private sdk(name: string, node: ts.CallExpression, frame: Frame): Value {
+    const args = node.arguments.map((argument) =>
+      this.code(this.expression(argument, frame), undefined, frame),
+    );
+    this.sdkImports.add(name);
+    return {
+      kind: "code",
+      text: `${name}(${args.join(", ")})`,
+      declared: this.checker.getTypeAtLocation(node),
+    };
+  }
+
+  readonly sdkImports = new Set<string>();
+  /** Conversions generated code imports from `@tsplc/compiler/types`. */
+  readonly typeImports = new Set<string>();
+
+  private math(name: string, node: ts.CallExpression, frame: Frame): Value {
+    const args = node.arguments.map((argument) => this.expression(argument, frame));
+    if (args.every((arg) => arg.kind === "const" && typeof arg.value === "number")) {
+      const values = args.map((arg) => (arg as { value: number }).value);
+      const folded = (Math as unknown as Record<string, (...items: number[]) => number>)[name]?.(
+        ...values,
+      );
+      if (typeof folded === "number") return constant(folded);
+    }
+    const texts = args.map((arg) => this.code(arg, undefined, frame));
+    const declared = this.checker.getTypeAtLocation(node);
+    switch (name) {
+      case "abs": {
+        const local = frame.emitter.temporary();
+        frame.emitter.line(`const ${local}: number = ${texts[0]};`);
+        return { kind: "code", text: `(${local} < 0 ? 0 - ${local} : ${local})`, declared };
+      }
+      case "min":
+      case "max":
+        if (texts.length !== 2) throw new SpecializeError(node, `Math.${name} takes two values.`);
+        return {
+          kind: "code",
+          text: `(${texts[0]} ${name === "min" ? "<" : ">"} ${texts[1]} ? ${texts[0]} : ${texts[1]})`,
+          declared,
+        };
+      default:
+        throw new SpecializeError(node, `Math.${name} is not supported.`);
+    }
+  }
+
+  private serviceCall(path: string, node: ts.CallExpression, frame: Frame): Value {
+    const client = this.model.roots.find((root) => {
+      const value = this.model.node(this.model.rootValues.get(root)!);
+      return value?.captured.kind === "service" && value.captured.path === "";
+    });
+    if (!client)
+      throw new SpecializeError(node, "Create the service client in a module of its own.");
+    const names = this.imports.get(client.file) ?? new Set<string>();
+    names.add(client.name);
+    this.imports.set(client.file, names);
+    const args = node.arguments.map((argument) =>
+      this.code(
+        this.expression(argument, frame, this.checker.getContextualType(argument)),
+        this.checker.getContextualType(argument),
+        frame,
+      ),
+    );
+    return {
+      kind: "code",
+      text: `${client.name}.${path}(${args.join(", ")})`,
+      declared: this.checker.getTypeAtLocation(node),
+    };
+  }
+
+  /** Calls a function value: specializes it, or inlines a one-expression arrow. */
+  private invoke(
+    target: Value,
+    args: Value[],
+    at: ts.Node,
+    frame: Frame,
+    expected?: ts.Type,
+  ): Value {
+    if (target.kind !== "function") throw new SpecializeError(at, "Only functions can be called.");
+    const declaration = target.declaration;
+    if (
+      (ts.isArrowFunction(declaration) || ts.isFunctionExpression(declaration)) &&
+      target.env &&
+      ts.isArrowFunction(declaration) &&
+      !ts.isBlock(declaration.body)
+    ) {
+      // A callback with one expression inlines with its arguments bound.
+      const inline: Frame = { ...frame, env: new Map(target.env), self: target.self ?? frame.self };
+      declaration.parameters.forEach((parameter, index) => {
+        const arg = args[index] ?? constant(undefined);
+        const value = arg.kind === "code" && !arg.place ? this.temporaryOf(arg, frame) : arg;
+        this.bind(parameter.name, value, false, inline, this.checker.getTypeAtLocation(parameter));
+      });
+      return this.expression(declaration.body, inline, expected);
+    }
+    const called = this.routine(declaration, target.self, args, target.env);
+    const text = `${called.name}(${called.args.join(", ")})`;
+    const returns = called.returns;
+    if (!returns || returns.flags & ts.TypeFlags.Void) {
+      if (ts.isExpressionStatement(at.parent)) return { kind: "code", text, declared: returns };
+      frame.emitter.line(`${text};`);
+      return constant(undefined);
+    }
+    return { kind: "code", text, declared: returns };
+  }
+
+  /** A runtime value held in a const, so inlining doesn't evaluate it twice. */
+  private temporaryOf(value: Value & { kind: "code" }, frame: Frame): Value {
+    if (/^[\w.[\]]+$/.test(value.text)) return value;
+    const local = frame.emitter.temporary();
+    const type = value.declared ? this.localType(value.declared) : "number";
+    frame.emitter.line(`const ${local}: ${type} = ${value.text};`);
+    return { kind: "code", text: local, declared: value.declared, place: true };
+  }
+
+  private arrayMethod(name: string, items: Value[], node: ts.CallExpression, frame: Frame): Value {
+    const callback = node.arguments[0] ? this.expression(node.arguments[0], frame) : undefined;
+    const apply = (args: Value[]): Value => {
+      if (!callback) throw new SpecializeError(node, `${name} needs a callback.`);
+      return this.invoke(callback, args, node, frame);
+    };
+    switch (name) {
+      case "entries":
+        return {
+          kind: "virtual",
+          items: items.map((item, index) => ({ kind: "virtual", items: [constant(index), item] })),
+        };
+      case "slice": {
+        const [start, end] = node.arguments.map((argument) => this.expression(argument, frame));
+        if ((start && start.kind !== "const") || (end && end.kind !== "const"))
+          throw new SpecializeError(node, "slice needs constant bounds.");
+        return {
+          kind: "virtual",
+          items: items.slice(start?.value as number | undefined, end?.value as number | undefined),
+        };
+      }
+      case "map":
+        return {
+          kind: "virtual",
+          items: items.map((item, index) => this.settle(apply([item, constant(index)]), frame)),
+        };
+      case "filter": {
+        const kept: Value[] = [];
+        items.forEach((item, index) => {
+          const test = apply([item, constant(index)]);
+          if (test.kind !== "const")
+            throw new SpecializeError(node, "filter must decide from what setup built.");
+          if (test.value) kept.push(item);
+        });
+        return { kind: "virtual", items: kept };
+      }
+      case "forEach":
+        items.forEach((item, index) => {
+          const result = apply([item, constant(index)]);
+          if (result.kind === "code") frame.emitter.line(`${result.text};`);
+        });
+        return constant(undefined);
+      case "some":
+      case "every": {
+        const some = name === "some";
+        const tests = items.map((item, index) => apply([item, constant(index)]));
+        const runtime: string[] = [];
+        for (const test of tests) {
+          if (test.kind === "const") {
+            if (Boolean(test.value) === some) return constant(some);
+            continue;
+          }
+          runtime.push(this.condition(test, node.arguments[0] ?? node, frame));
+        }
+        if (!runtime.length) return constant(!some);
+        return {
+          kind: "code",
+          text: `(${runtime.join(some ? " || " : " && ")})`,
+          declared: this.checker.getBooleanType(),
+        };
+      }
+      case "reduce":
+      case "reduceRight": {
+        const order = name === "reduce" ? items : [...items].reverse();
+        let accumulator = node.arguments[1]
+          ? this.expression(node.arguments[1], frame)
+          : order.shift()!;
+        for (const item of order) accumulator = this.settle(apply([accumulator, item]), frame);
+        return accumulator;
+      }
+      case "find": {
+        for (const [index, item] of items.entries()) {
+          const test = apply([item, constant(index)]);
+          if (test.kind !== "const")
+            throw new SpecializeError(node, "find must decide from what setup built.");
+          if (test.value) return item;
+        }
+        return constant(undefined);
+      }
+      case "includes": {
+        const target = this.expression(node.arguments[0]!, frame);
+        const tests = items.map((item) => this.equal(item, target));
+        if (tests.some((test) => test === true)) return constant(true);
+        if (tests.every((test) => test === false)) return constant(false);
+        throw new SpecializeError(node, "includes must decide from what setup built.");
+      }
+      default:
+        throw new SpecializeError(node, `${name} is not supported.`);
+    }
+  }
+
+  /** Keeps a runtime result in a local, so later code reads it rather than repeating it. */
+  private settle(value: Value, frame: Frame): Value {
+    if (value.kind !== "code" || /^[\w.[\]]+$/.test(value.text)) return value;
+    const local = frame.emitter.temporary();
+    frame.emitter.line(
+      `const ${local}: ${value.declared ? this.localType(value.declared) : "boolean"} = ${value.text};`,
+    );
+    return { kind: "code", text: local, declared: value.declared, place: true };
+  }
+
+  // ---- Values as code ----
+
+  /** Dialect text for a value, in a place of `expected` type when known. */
+  code(value: Value, expected: ts.Type | undefined, frame: Frame): string {
+    switch (value.kind) {
+      case "code":
+        if (
+          expected &&
+          value.declared &&
+          this.isOptionalRecord(value.declared) &&
+          !this.isOptionalRecord(expected)
+        )
+          return `${value.text}.value`;
+        return value.text;
+      case "const": {
+        const literal = expected && this.layouts.literalEnum(expected);
+        if (literal && (typeof value.value === "string" || value.value === undefined))
+          return this.layouts.member(literal, value.value as string | undefined);
+        if (expected && this.isOptionalRecord(expected) && value.value === undefined)
+          return `defaultValue<${this.layouts.text(expected)}>()`;
+        if (expected && this.layouts.enumDeclaration(expected) && typeof value.value === "number") {
+          const member = this.enumMemberName(expected, value.value);
+          if (member) return `${this.layouts.text(expected)}.${member}`;
+        }
+        if (value.value === undefined) throw new Error("undefined has no PLC value here.");
+        if (typeof value.value === "string") return JSON.stringify(value.value);
+        if (typeof value.value === "bigint") return `${value.value}n`;
+        return String(value.value);
+      }
+      case "static": {
+        const node = value.node;
+        if (this.storedNode(node)) return this.pathText(node);
+        if (node.type) return this.valueText({ kind: "node", id: node.id }, expected ?? node.type);
+        throw new Error("This object has no PLC value.");
+      }
+      case "virtual": {
+        if (value.fields) {
+          const type = expected && this.checker.getNonNullableType(expected);
+          if (!type) throw new Error("A record literal needs a declared type.");
+          return this.recordLiteral(value.fields, type, frame);
+        }
+        if (value.items) {
+          const element = expected && this.model.elementType(expected);
+          return `[${value.items.map((item) => this.code(item, element, frame)).join(", ")}]`;
+        }
+        throw new Error("Empty value.");
+      }
+      case "function":
+        throw new Error("A function has no PLC value; call it.");
+    }
+  }
+
+  /** A record literal of `type`, every field written; a tagged union fills the other variants' fields. */
+  private recordLiteral(fields: Map<string, Value>, type: ts.Type, frame: Frame): string {
+    const tagged = this.layouts.tagged(type);
+    const names = tagged
+      ? this.taggedFields(tagged)
+      : this.checker.getPropertiesOfType(type).map((property) => property.name);
+    return `{ ${names
+      .map((name) => {
+        const fieldType = tagged
+          ? name === tagged.tag
+            ? this.tagType(type, tagged)
+            : this.taggedFieldType(type, tagged, name)
+          : this.checker.getTypeOfSymbol(this.checker.getPropertyOfType(type, name)!);
+        const value = fields.get(name);
+        if (!value) return `${name}: ${this.defaultOf(fieldType)}`;
+        const property = this.checker.getPropertyOfType(type, name);
+        return `${name}: ${this.assignmentText(value, fieldType, frame, this.layouts.iecName(property?.valueDeclaration))}`;
+      })
+      .join(", ")} }`;
+  }
+}
+
+/** IEC integer and bit-string widths: [bits, signed, bit string]. */
+const integerWidths: Readonly<Record<string, readonly [number, boolean, boolean]>> = {
+  SINT: [8, true, false],
+  INT: [16, true, false],
+  DINT: [32, true, false],
+  LINT: [64, true, false],
+  USINT: [8, false, false],
+  UINT: [16, false, false],
+  UDINT: [32, false, false],
+  ULINT: [64, false, false],
+  BYTE: [8, false, true],
+  WORD: [16, false, true],
+  DWORD: [32, false, true],
+  LWORD: [64, false, true],
+};
+
+/** Whether IEC needs an explicit conversion from one integer type to another; widening is implicit. */
+const needsConversion = (from: string, to: string): boolean => {
+  const source = integerWidths[from],
+    target = integerWidths[to];
+  if (!source || !target || from === to) return false;
+  if (source[2] || target[2]) return true;
+  if (source[1] === target[1]) return source[0] > target[0];
+  return source[1] || source[0] >= target[0];
+};
+
+const isChild = (node: ModelNode, holder: ModelNode, field?: string): boolean => {
+  const owner = node.owner;
+  const parent = holder.owner;
+  if (!owner || !parent || owner.root !== parent.root) return false;
+  if (owner.steps.length !== parent.steps.length + 1) return false;
+  if (!parent.steps.every((step, index) => stepText(step) === stepText(owner.steps[index]!)))
+    return false;
+  const last = owner.steps.at(-1)!;
+  return field === undefined || (last.kind === "field" && last.name === field);
+};
+
+/** The function a storage module exports to set one of its globals. */
+export const setterName = (name: string): string => `tsplcSet_${name}`;
+
+const stepText = (step: Step): string =>
+  step.kind === "index" ? `[${step.index}]` : `.${step.name}`;
+
+const declarationKey = (declaration: ts.Node): string =>
+  `${declaration.getSourceFile().fileName}:${declaration.pos}`;
+
+const valueKey = (value: Value): string => {
+  switch (value.kind) {
+    case "static":
+      return `#${value.node.id}`;
+    case "const":
+      return `=${String(value.value)}`;
+    case "function":
+      return `fn:${declarationKey(value.declaration)}:${value.self?.id ?? ""}`;
+    case "virtual":
+      return value.items
+        ? `[${value.items.map(valueKey).join(",")}]`
+        : `{${[...(value.fields ?? [])].map(([name, inner]) => `${name}:${valueKey(inner)}`).join(",")}}`;
+    case "code":
+      return "code";
+  }
+};
+
+const isAssignment = (kind: ts.SyntaxKind): boolean =>
+  kind >= ts.SyntaxKind.FirstAssignment && kind <= ts.SyntaxKind.LastAssignment;
+
+const compoundOperator = (kind: ts.SyntaxKind): string | undefined =>
+  ({
+    [ts.SyntaxKind.PlusEqualsToken]: "+",
+    [ts.SyntaxKind.MinusEqualsToken]: "-",
+    [ts.SyntaxKind.AsteriskEqualsToken]: "*",
+    [ts.SyntaxKind.BarEqualsToken]: "|",
+    [ts.SyntaxKind.AmpersandEqualsToken]: "&",
+  })[kind as number];
+
+const binaryToken = (kind: ts.SyntaxKind): string | undefined =>
+  ({
+    [ts.SyntaxKind.PlusToken]: "+",
+    [ts.SyntaxKind.MinusToken]: "-",
+    [ts.SyntaxKind.AsteriskToken]: "*",
+    [ts.SyntaxKind.LessThanToken]: "<",
+    [ts.SyntaxKind.LessThanEqualsToken]: "<=",
+    [ts.SyntaxKind.GreaterThanToken]: ">",
+    [ts.SyntaxKind.GreaterThanEqualsToken]: ">=",
+    [ts.SyntaxKind.AmpersandToken]: "&",
+    [ts.SyntaxKind.BarToken]: "|",
+    [ts.SyntaxKind.CaretToken]: "^",
+    [ts.SyntaxKind.LessThanLessThanToken]: "<<",
+    [ts.SyntaxKind.GreaterThanGreaterThanToken]: ">>",
+  })[kind as number];
+
+const foldNumber = (
+  kind: ts.SyntaxKind,
+  left: number,
+  right: number,
+): number | boolean | undefined => {
+  switch (kind) {
+    case ts.SyntaxKind.PlusToken:
+      return left + right;
+    case ts.SyntaxKind.MinusToken:
+      return left - right;
+    case ts.SyntaxKind.AsteriskToken:
+      return left * right;
+    case ts.SyntaxKind.LessThanToken:
+      return left < right;
+    case ts.SyntaxKind.LessThanEqualsToken:
+      return left <= right;
+    case ts.SyntaxKind.GreaterThanToken:
+      return left > right;
+    case ts.SyntaxKind.GreaterThanEqualsToken:
+      return left >= right;
+    default:
+      return undefined;
+  }
+};
+
+const isArrayMethod = (name: string): boolean =>
+  [
+    "entries",
+    "slice",
+    "map",
+    "filter",
+    "forEach",
+    "some",
+    "every",
+    "reduce",
+    "reduceRight",
+    "find",
+    "includes",
+  ].includes(name);
+
+const pascal = (text: string): string =>
+  text.replace(/(^|[^A-Za-z0-9]+)([A-Za-z0-9])/g, (_, __, letter: string) => letter.toUpperCase());
+
+export type { LiteralEnum };