@tsplc/compiler 0.0.0-stage → 0.2.0

package/backends/codesys/emit.ts

@@ -0,0 +1,1063 @@
+import type {
+  Constant,
+  CoreExpression,
+  CoreFunction,
+  CoreFunctionBlock,
+  CorePath,
+  CoreStatement,
+  EmitResult,
+  GeneratedObject,
+  SourceSpan,
+  Variable,
+} from "@tsplc/compiler/ir";
+import { defaultValue, instancedBlock, standardBlocks } from "@tsplc/compiler/ir";
+import { Names, pascalCase } from "./names.ts";
+import { NumericLowering } from "./numeric.ts";
+import { type CodesysPlan, diagnostic, isCodesysPlan } from "./plan.ts";
+import { storageLayout } from "./storage.ts";
+import { accessedStorage } from "./task-access.ts";
+import { emitHttp, httpMethods, httpCertificateVerifier, opcuaServiceCapacity } from "./http.ts";
+import { CodesysTypes } from "./types.ts";
+import type { Publication } from "@tsplc/config";
+
+export interface SourceMapping {
+  path: string;
+  line: number;
+  span: SourceSpan;
+}
+
+// All symbol relationships were checked by normalization and planning. Failure
+// here is an emitter invariant violation, rather than a recoverable source error.
+function required<T>(value: T | undefined): T {
+  if (value === undefined) throw new Error("Missing verified CODESYS symbol.");
+  return value;
+}
+
+type CodesysBundle = EmitResult & {
+  /** Variables a generated device tree maps to their bit or byte channels. */
+  ioMappings: readonly { key: string; address: string; variable: string }[];
+  mappings: readonly SourceMapping[];
+  ioSymbols: Readonly<Record<string, string>>;
+  publication: Publication;
+};
+
+export function emitCodesys(plan: CodesysPlan): CodesysBundle {
+  if (!isCodesysPlan(plan)) {
+    return {
+      artifacts: [],
+      objects: [],
+      mappings: [],
+      ioSymbols: {},
+      publication: { production: [], development: [] },
+      ioMappings: [],
+      diagnostics: [diagnostic("Emission requires a validated CODESYS plan.")],
+    };
+  }
+  return new CodesysEmitter(plan).emit();
+}
+
+// A bundle owns target names and source mappings. Per-routine declarations and
+// implementation lines stay local to emitRoutine, so they cannot leak between POUs.
+class CodesysEmitter {
+  private readonly names = new Names();
+  private networkName: string | undefined;
+  private readonly rpcChannels: {
+    path: string;
+    request: string;
+    requestId: string;
+    reply: string;
+    replyId: string;
+    epoch: string;
+  }[] = [];
+  private readonly references = new Map<string, string>();
+  /** Each `io` binding: an AT wire copied to or from its logical target around the scan. */
+  private readonly channels: {
+    key: string;
+    root: string;
+    input: boolean;
+    target: string;
+    wire: string;
+    inverted?: boolean;
+  }[] = [];
+  private readonly ioMappings: { key: string; address: string; variable: string }[] = [];
+  private readonly objects: GeneratedObject[] = [];
+  private readonly mappings: SourceMapping[] = [];
+  private readonly mailboxLocks = new Map<string, string>();
+  private readonly blockFields = new Map<string, Map<string, string>>();
+  private readonly typeMap;
+  private readonly blocks;
+  private readonly blockNames;
+  private readonly functionNames = new Map<string, string>();
+  private readonly programRoutines = new Set<string>();
+  private readonly programResults = new Map<string, string>();
+  private readonly routineScopes = new Map<
+    string,
+    { names: Names; references: Map<string, string> }
+  >();
+  private readonly targetTypes: CodesysTypes;
+  private readonly numeric: NumericLowering;
+  private readonly layout;
+
+  constructor(private readonly plan: CodesysPlan) {
+    const { core, options } = plan;
+    const persistent = new Set(
+      core.variables.filter((item) => item.storage !== "constant").map((item) => item.id),
+    );
+    for (const fn of core.functions) {
+      if (!fn.owner && [...accessedStorage(fn, core)].some((id) => persistent.has(id)))
+        this.programRoutines.add(fn.id);
+    }
+    for (const name of Object.values(options.programNames ?? {})) this.names.reserve(name);
+
+    this.typeMap = new Map(core.types.map((type) => [type.id, type]));
+    this.blocks = new Map(core.blocks.map((block) => [block.id, block]));
+    this.blockNames = new Map(
+      core.blocks.map((block) => [
+        block.id,
+        block.standard
+          ? standardBlocks[block.standard].native
+          : this.names.allocateObject("FB", block.name),
+      ]),
+    );
+    for (const name of this.blockNames.values()) this.names.reserve(name);
+    this.targetTypes = new CodesysTypes(this.typeMap, this.names, this.blockNames);
+    this.numeric = new NumericLowering(this.typeMap, (label) => this.names.allocate(label));
+    this.layout = storageLayout(core);
+    this.objects.push(...this.targetTypes.objects);
+  }
+
+  emit(): CodesysBundle {
+    this.emitGlobals();
+    this.emitIo();
+    if (Object.values(this.plan.http).some((endpoint) => endpoint.transport !== "opcua")) {
+      this.networkName = this.names.allocateObject("GVL", "TsplcNetwork");
+      this.objects.push({
+        id: "runtime:httpNetwork",
+        kind: "globalList",
+        name: this.networkName,
+        // Blocks in other global lists take this in their initializers, so it must initialize first.
+        declaration: `{attribute 'qualified_only'}
+{attribute 'global_init_slot' := '40000'}
+VAR_GLOBAL
+network:NBS.AsyncProperty := (usiTaskPrio:=15,udiTaskInterval:=1000,tnTaskName:='tsPLC HTTP');
+END_VAR
+`,
+      });
+    }
+
+    // Helpers must be discovered before allocating local names: an ST local must
+    // never shadow a helper, function, FB, or DUT that the implementation calls.
+    const { core } = this.plan;
+    const entries = new Set(core.programs.map((program) => program.entry));
+    for (const fn of core.functions.filter((fn) => !fn.owner)) {
+      const program = this.programRoutines.has(fn.id);
+      const label = program && entries.has(fn.id) ? `${fn.name}_body` : fn.name;
+      this.functionNames.set(fn.id, this.names.allocateObject(program ? "PRG" : "F", label));
+    }
+    for (const fn of core.functions) this.prepareStatements(fn.body);
+    for (const block of core.blocks) this.prepareStatements(block.body);
+    this.objects.push(...this.numeric.objects);
+    this.allocateBlockFields();
+
+    const routines = [...core.functions, ...core.blocks.filter((block) => !block.standard)];
+    for (const fn of routines) this.allocateRoutineScope(fn);
+    for (const fn of routines) this.emitRoutine(fn);
+    for (const program of core.programs) this.emitProgram(program);
+
+    const { objects, mappings } = this;
+    const paths = new Map<string, string>();
+    for (const object of objects) {
+      const path = this.objectPath(object);
+      paths.set(object.id, path);
+      object.sourcePath =
+        object.implementation === undefined ? `${path}.st` : `${path}/declaration.st`;
+    }
+    const artifacts = objects.flatMap((object) => {
+      const path = paths.get(object.id)!;
+      return object.implementation === undefined
+        ? [{ path: `${path}.st`, content: object.declaration }]
+        : [
+            { path: `${path}/declaration.st`, content: object.declaration },
+            { path: `${path}/implementation.st`, content: object.implementation },
+          ];
+    });
+    for (const mapping of mappings) {
+      const object = objects.find((object) => {
+        const key = object.kind === "method" ? object.id : object.name;
+        return mapping.path === `${key}.st` || mapping.path.startsWith(`${key}/`);
+      });
+      if (object) {
+        const key = object.kind === "method" ? object.id : object.name;
+        mapping.path = paths.get(object.id)! + mapping.path.slice(key.length);
+      }
+    }
+    const ioSymbols = Object.fromEntries([
+      ...this.channels.map((channel) => [channel.key, channel.target]),
+      ...this.ioMappings.map((mapping) => [mapping.key, mapping.variable]),
+    ]);
+    const { ioMappings } = this;
+    const logicalIo = this.plan.core.variables
+      .filter((variable) => variable.storage === "input" || variable.storage === "output")
+      .map((variable) => variable.id);
+    const rpcSymbols = [
+      ...new Set(
+        this.rpcChannels.flatMap((channel) =>
+          [channel.request, channel.requestId, channel.reply, channel.replyId, channel.epoch].map(
+            (path) => path.replace(/\[\d+\]$/, ""),
+          ),
+        ),
+      ),
+    ];
+    const published = (ids: readonly string[]) =>
+      [...ids, ...logicalIo].map((id) => required(this.references.get(id))).concat(rpcSymbols);
+    const publication = {
+      production: published(this.plan.publication.production),
+      development: published(this.plan.publication.development),
+    };
+    const exposures = Object.fromEntries(
+      core.variables
+        .filter((variable) => variable.exposure)
+        .map((variable) => {
+          const record = this.typeMap.get(variable.type);
+          if (record?.kind !== "record") throw new Error("Invalid exposure record.");
+          const root = required(this.references.get(variable.id));
+          const fields = Object.fromEntries(
+            record.fields
+              .filter((field) => field.name !== "contractVersion")
+              .map((field) => {
+                const type = this.typeMap.get(field.type);
+                const kind =
+                  type?.kind === "bool" ? "boolean" : type?.kind === "string" ? "string" : "number";
+                return [
+                  field.name,
+                  { path: `${root}.${this.targetTypes.field(record.id, field.name)}`, kind },
+                ];
+              }),
+          );
+          return [
+            variable.exposure!.name,
+            {
+              version: variable.exposure!.version,
+              versionPath: `${root}.${this.targetTypes.field(record.id, "contractVersion")}`,
+              telemetry: fields,
+            },
+          ];
+        }),
+    );
+    artifacts.push(
+      { path: "exposures.json", content: JSON.stringify(exposures, null, 2) + "\n" },
+      {
+        path: "machines.ts",
+        content: `// Generated explicit read-only machine interfaces. Do not edit.\nexport const machines=${JSON.stringify(exposures, null, 2)} as const;\nexport const serviceChannels=${JSON.stringify(this.rpcChannels, null, 2)} as const;\n`,
+      },
+    );
+    return { artifacts, objects, mappings, ioSymbols, ioMappings, publication, diagnostics: [] };
+  }
+
+  private objectPath(object: GeneratedObject): string {
+    const { core } = this.plan;
+    if (object.kind === "method" && object.parent) {
+      const parent = required(this.objects.find((candidate) => candidate.id === object.parent));
+      return `${this.objectPath(parent)}/methods/${object.name}`;
+    }
+    if (object.kind === "method") {
+      const method = required(core.functions.find((fn) => fn.id === object.id));
+      const owner = required(this.objects.find((item) => item.id === method.owner?.block));
+      return `${this.objectPath(owner)}/methods/${object.name}`;
+    }
+    let source = object.id.split(":")[0] ?? "";
+    const program = core.programs.find((item) => item.id === object.id);
+    if (program) source = program.entry.split(":")[0] ?? "";
+    const group = this.layout.globalLists.find((item) => item.id === object.id);
+    if (group) {
+      // Variable IDs are relative to tsconfig, unlike their diagnostic spans.
+      source = group.variables[0]?.id.split(":")[0] ?? "";
+    }
+    if (
+      /^[\w./ -]+\.tsx?$/.test(source) &&
+      !source.split(/[\\/]/).includes("..") &&
+      !source.startsWith("/")
+    ) {
+      const segments = source.replaceAll("\\", "/").split("/").slice(0, -1);
+      if (segments[0] === "src") segments.shift();
+      // A DUT directory can also contain sibling input/output layouts. Keep
+      // that directory for every DUT, or its primary type would block the folder.
+      if (object.kind !== "dataType" && segments.at(-1) === object.name) segments.pop();
+      return [...segments, object.name].join("/");
+    }
+    return `${object.kind === "dataType" ? "Types" : object.id === "io" ? "IO" : "_Generated"}/${object.name}`;
+  }
+
+  private emitGlobals(): void {
+    const { options } = this.plan;
+    const { layout, names, references, mappings, targetTypes, typeMap, objects } = this;
+    const hasExports = (group: (typeof layout.globalLists)[number]) =>
+      group.variables.some((variable) => variable.exported && !variable.exposure);
+    for (const group of layout.globalLists) {
+      const splitByStorage = layout.globalLists.some(
+        (other) =>
+          other.module === group.module && other.storage !== group.storage && hasExports(other),
+      );
+      // Exported lists are the program's public interface; private storage stays generated.
+      const name = hasExports(group)
+        ? names.allocate(
+            pascalCase(splitByStorage ? `${group.module}-${group.storage}` : group.module),
+          )
+        : names.allocateObject("GVL", `${group.module}_${group.storage}`);
+      const published = new Set(this.plan.publication[options.buildTarget]);
+      const publish = group.variables.some((variable) => published.has(variable.id));
+      const fields = new Names();
+      for (const name of this.blockNames.values()) fields.reserve(name);
+      const lines = [
+        ...(publish ? ["{attribute 'linkalways'}"] : []),
+        "{attribute 'qualified_only'}",
+        group.storage === "constants"
+          ? "VAR_GLOBAL CONSTANT"
+          : group.storage === "retained"
+            ? "VAR_GLOBAL RETAIN"
+            : "VAR_GLOBAL",
+      ];
+      for (const item of group.variables) {
+        const field = fields.allocate(item.name);
+        references.set(item.id, `${name}.${field}`);
+        if (published.has(item.id))
+          lines.push(`    {attribute 'symbol' := '${item.exposure ? "read" : "readwrite"}'}`);
+        mappings.push({ path: `${name}.st`, line: lines.length + 1, span: item.span });
+        let initial = "";
+        if (!instancedBlock(item.type, typeMap)) {
+          const value = item.initial ?? defaultValue(item.type, typeMap);
+          // CONSTANT declarations always keep their initializer. Mutable zero
+          // aggregates use the same implicit initialization as the original ST.
+          initial =
+            group.storage === "constants"
+              ? ` := ${targetTypes.literal(value, item.type)}`
+              : targetTypes.declarationInitializer(value, item.type);
+        }
+        lines.push(`    ${field} : ${targetTypes.name(item.type)}${initial};`);
+      }
+      lines.push("END_VAR");
+      objects.push({
+        id: group.id,
+        kind: "globalList",
+        name,
+        declaration: `${lines.join("\n")}\n`,
+      });
+    }
+  }
+
+  private emitIo(): void {
+    const { core, options } = this.plan;
+    const { names, references, channels, ioMappings, mappings, targetTypes, typeMap, objects } =
+      this;
+    const ioName = names.allocate("GVL_IO");
+    const ioFields = new Names();
+    for (const name of this.blockNames.values()) ioFields.reserve(name);
+    const ioLines = ["{attribute 'linkalways'}", "{attribute 'qualified_only'}", "VAR_GLOBAL"];
+    for (const item of core.variables.filter(
+      (item) => item.storage === "input" || item.storage === "output",
+    )) {
+      const field = ioFields.allocate(item.name);
+      const initial = item.initial ?? defaultValue(item.type, typeMap);
+      const binding = required(options.io[item.name]);
+      references.set(item.id, `${ioName}.${field}`);
+      if (binding.mapped) {
+        ioMappings.push({
+          key: item.name,
+          address: binding.address,
+          variable: `${ioName}.${field}`,
+        });
+        mappings.push({ path: `${ioName}.st`, line: ioLines.length + 2, span: item.span });
+        ioLines.push(
+          "    {attribute 'symbol' := 'read'}",
+          `    ${field} : ${targetTypes.name(item.type)} := ${targetTypes.literal(initial, item.type)};`,
+        );
+        continue;
+      }
+      const wire = ioFields.allocate(`${item.name}_physical`);
+      channels.push({
+        key: item.name,
+        root: item.id,
+        input: item.storage === "input",
+        target: `${ioName}.${field}`,
+        wire: `${ioName}.${wire}`,
+        inverted: binding.inverted,
+      });
+      mappings.push(
+        { path: `${ioName}.st`, line: ioLines.length + 1, span: item.span },
+        { path: `${ioName}.st`, line: ioLines.length + 3, span: item.span },
+      );
+      ioLines.push(
+        `    ${wire} AT ${binding.address} : ${targetTypes.name(item.type)};`,
+        // Publish the scan's logical value for monitoring. Physical wires stay
+        // private; external writes cannot alter the controller's IO snapshot.
+        "    {attribute 'symbol' := 'read'}",
+        `    ${field} : ${targetTypes.name(item.type)} := ${targetTypes.literal(initial, item.type)};`,
+      );
+    }
+    for (const { key, root, segments, type } of this.plan.storageBindings) {
+      const { address, mapped, inverted } = required(options.io[key]);
+      const target = segments.reduce(
+        (path, segment) =>
+          segment.kind === "field"
+            ? `${path}.${targetTypes.field(segment.record, segment.name)}`
+            : `${path}[${segment.value}]`,
+        required(references.get(root.id)),
+      );
+      if (mapped) {
+        ioMappings.push({ key, address, variable: target });
+        continue;
+      }
+      const wire = ioFields.allocate(`${key.replace(/\W+/g, "_").replace(/_+$/, "")}_physical`);
+      // The wire takes the target's own type, so equal-width EDS types need no conversion.
+      ioLines.push(`    ${wire} AT ${address} : ${targetTypes.name(type.id)};`);
+      channels.push({
+        key,
+        root: root.id,
+        input: address[1] === "I",
+        target,
+        wire: `${ioName}.${wire}`,
+        inverted,
+      });
+    }
+    ioLines.push("END_VAR");
+    // Mapped storage bindings need no IO list; mapped logical IO is declared here.
+    if (ioLines.length > 4)
+      objects.push({
+        id: "io",
+        kind: "globalList",
+        name: ioName,
+        declaration: `${ioLines.join("\n")}\n`,
+      });
+  }
+
+  private prepareStatements(items: readonly CoreStatement[]): void {
+    const { numeric } = this;
+    for (const item of items) {
+      if (item.kind === "assign") {
+        numeric.prepare(item.value);
+        item.path?.forEach((segment) => {
+          if (segment.kind === "index") numeric.prepare(segment.value);
+        });
+      }
+      if (item.kind === "if") {
+        numeric.prepare(item.condition);
+        this.prepareStatements(item.then);
+        this.prepareStatements(item.else);
+      }
+      if (item.kind === "switch") {
+        numeric.prepare(item.value);
+        for (const branch of item.cases) this.prepareStatements(branch.body);
+        this.prepareStatements(item.fallback);
+      }
+      if (item.kind === "for") {
+        if (item.dynamic) {
+          numeric.prepare(item.dynamic.start);
+          numeric.prepare(item.dynamic.limit);
+        }
+        this.prepareStatements(item.body);
+      }
+      if (item.kind === "return" && item.value) numeric.prepare(item.value);
+      if (item.kind === "invoke") {
+        if (item.index) numeric.prepare(item.index);
+        for (const value of item.arguments) numeric.prepare(value);
+      }
+      if (item.kind === "blockUpdate") {
+        if (item.index) numeric.prepare(item.index);
+        for (const value of Object.values(item.inputs)) numeric.prepare(value);
+      }
+    }
+  }
+
+  private allocateBlockFields(): void {
+    const { core } = this.plan;
+    const { objects, functionNames, blockNames, blockFields } = this;
+    for (const block of core.blocks) {
+      const fields = new Names(),
+        mapped = new Map<string, string>();
+      for (const object of objects) fields.reserve(object.name);
+      for (const objectName of [
+        ...core.functions.filter((fn) => !fn.owner).map((fn) => required(functionNames.get(fn.id))),
+        ...blockNames.values(),
+      ])
+        fields.reserve(objectName);
+      for (const method of core.functions.filter((fn) => fn.owner?.block === block.id))
+        functionNames.set(method.id, fields.allocate(method.name));
+      const native = block.standard && standardBlocks[block.standard];
+      for (const item of [...block.inputs, ...block.outputs, ...block.state])
+        mapped.set(
+          item.id,
+          native
+            ? required(
+                [...native.inputs, ...native.outputs].find(([name]) => name === item.name),
+              )[1]
+            : fields.allocate(item.name, true),
+        );
+      if (block.runtime?.kind === "mailbox")
+        this.mailboxLocks.set(block.id, fields.allocate("plc_mailbox_lock"));
+      blockFields.set(block.id, mapped);
+    }
+  }
+
+  private allocateRoutineScope(fn: CoreFunction | CoreFunctionBlock): void {
+    const block = "inputs" in fn ? fn : undefined;
+    const owner =
+      block ?? ("owner" in fn && fn.owner ? this.blocks.get(fn.owner.block) : undefined);
+    const names = new Names(),
+      references = new Map<string, string>();
+    for (const object of this.objects) names.reserve(object.name);
+    for (const name of [...this.functionNames.values(), ...this.blockNames.values()])
+      names.reserve(name);
+    if (this.programRoutines.has(fn.id) && "parameters" in fn && fn.result)
+      this.programResults.set(fn.id, names.allocate("plc_result"));
+    if (owner) {
+      for (const item of [...owner.outputs, ...owner.state]) {
+        const name = required(required(this.blockFields.get(owner.id)).get(item.id));
+        names.reserve(name);
+        references.set(item.id, name);
+      }
+    }
+    for (const item of "parameters" in fn ? fn.parameters : fn.inputs) {
+      const name = block
+        ? required(required(this.blockFields.get(block.id)).get(item.id))
+        : names.allocate(item.name);
+      names.reserve(name);
+      references.set(item.id, name);
+    }
+    for (const item of fn.locals) references.set(item.id, names.allocate(item.name));
+    this.routineScopes.set(fn.id, { names, references });
+  }
+
+  private routineHeader(
+    fn: CoreFunction | CoreFunctionBlock,
+    name: string,
+  ): { kind: GeneratedObject["kind"]; declaration: string } {
+    if ("inputs" in fn) return { kind: "functionBlock", declaration: `FUNCTION_BLOCK ${name}` };
+    if (fn.owner)
+      return {
+        kind: "method",
+        declaration: `METHOD ${fn.owner.access.toUpperCase()} ${name}${fn.result ? ` : ${this.targetTypes.name(fn.result)}` : ""}`,
+      };
+    if (this.programRoutines.has(fn.id)) return { kind: "program", declaration: `PROGRAM ${name}` };
+    return {
+      kind: "function",
+      declaration: `FUNCTION ${name} : ${fn.result ? this.targetTypes.name(fn.result) : "BOOL"}`,
+    };
+  }
+
+  private emitRoutine(fn: CoreFunction | CoreFunctionBlock): void {
+    const { core } = this.plan;
+    if ("inputs" in fn && (fn.runtime?.kind === "http" || fn.runtime?.kind === "rpc")) {
+      const endpoint = required(this.plan.http[fn.id]);
+      const rpcGlobal =
+        endpoint.transport === "opcua"
+          ? this.names.allocateObject("GVL", "TsplcRpc_" + required(this.blockNames.get(fn.id)))
+          : undefined;
+      if (rpcGlobal) {
+        this.objects.push({
+          id: fn.id + ":rpc",
+          kind: "globalList",
+          name: rpcGlobal,
+          declaration: `{attribute 'qualified_only'}
+VAR_GLOBAL
+ {attribute 'symbol' := 'read'} requests:ARRAY[1..${opcuaServiceCapacity}] OF STRING(2048);
+ {attribute 'symbol' := 'read'} requestIds:ARRAY[1..${opcuaServiceCapacity}] OF STRING(64);
+ {attribute 'symbol' := 'readwrite'} replyIds:ARRAY[1..${opcuaServiceCapacity}] OF STRING(64);
+ {attribute 'symbol' := 'readwrite'} replies:ARRAY[1..${opcuaServiceCapacity}] OF STRING(2048);
+ {attribute 'symbol' := 'readwrite'} epochs:ARRAY[1..${opcuaServiceCapacity}] OF STRING(32);
+ inUse:ARRAY[1..${opcuaServiceCapacity}] OF __XWORD;
+ sequence:ARRAY[1..${opcuaServiceCapacity}] OF UDINT;
+END_VAR`,
+        });
+        for (let slot = 1; slot <= opcuaServiceCapacity; slot++)
+          this.rpcChannels.push({
+            path: endpoint.path,
+            request: `${rpcGlobal}.requests[${slot}]`,
+            reply: `${rpcGlobal}.replies[${slot}]`,
+            requestId: `${rpcGlobal}.requestIds[${slot}]`,
+            replyId: `${rpcGlobal}.replyIds[${slot}]`,
+            epoch: `${rpcGlobal}.epochs[${slot}]`,
+          });
+      }
+      const generated = emitHttp(
+        fn,
+        required(this.blockNames.get(fn.id)),
+        required(this.blockFields.get(fn.id)),
+        this.typeMap,
+        this.targetTypes,
+        endpoint,
+        this.networkName ? `${this.networkName}.network` : "",
+        rpcGlobal,
+      );
+      this.objects.push(
+        generated,
+        ...httpMethods(generated.id, endpoint.transport),
+        ...httpCertificateVerifier(generated.id, generated.name, required(this.plan.http[fn.id])),
+      );
+      return;
+    }
+    const {
+      blockNames,
+      functionNames,
+      references,
+      objects,
+      mappings,
+      targetTypes,
+      typeMap,
+      blocks,
+      blockFields,
+      numeric,
+      layout,
+    } = this;
+    const block = "inputs" in fn ? fn : undefined;
+    const method = "owner" in fn ? fn.owner : undefined;
+    const program = this.programRoutines.has(fn.id);
+    const owner = method ? required(blocks.get(method.block)) : block;
+    const name = block ? required(blockNames.get(block.id)) : required(functionNames.get(fn.id));
+    const inputs = "parameters" in fn ? fn.parameters : fn.inputs;
+    const state = owner ? [...owner.outputs, ...owner.state] : [];
+    const mappingName = method ? fn.id : name;
+    const routineScope = required(this.routineScopes.get(fn.id));
+    const scope = new Map([...references, ...routineScope.references]),
+      locals = routineScope.names;
+    const declarations = fn.locals.map(
+      (item) => `    ${required(scope.get(item.id))} : ${targetTypes.name(item.type)};`,
+    );
+    const declarationSpans = fn.locals.map((item) => item.span);
+    const mutex =
+      method && owner?.runtime?.kind === "mailbox"
+        ? required(this.mailboxLocks.get(owner.id))
+        : undefined;
+    const acquired = mutex ? locals.allocate("plc_acquired") : undefined;
+    const unavailable = mutex && fn.result ? locals.allocate("plc_unavailable") : undefined;
+    if (acquired) {
+      declarations.push(`    ${acquired} : BOOL;`);
+      declarationSpans.push(fn.span);
+    }
+    if (unavailable && fn.result) {
+      declarations.push(
+        `    ${unavailable} : ${targetTypes.name(fn.result)} := ${targetTypes.literal(defaultValue(fn.result, typeMap), fn.result)};`,
+      );
+      declarationSpans.push(fn.span);
+    }
+    // Count target lines as they are appended; diagnostics use these exact offsets.
+    const lines: string[] = [];
+    const write = (line: string, depth: number, source?: SourceSpan): void => {
+      lines.push("    ".repeat(depth) + line);
+      if (source)
+        mappings.push({
+          path: `${mappingName}/implementation.st`,
+          line: lines.length,
+          span: source,
+        });
+    };
+
+    // Only the holder releases, so a failed swap is spurious (see the acquire above); retry it.
+    const release = (lock: string, depth: number, source?: SourceSpan) => {
+      write(`WHILE NOT __COMPARE_AND_SWAP(ADR(${lock}), 1, 0) DO`, depth, source);
+      write(";", depth + 1);
+      write("END_WHILE;", depth);
+    };
+
+    const load = (id: string): string => {
+      const value = scope.get(id);
+      if (!value) throw new Error(`Missing verified storage ${id}.`);
+      return value;
+    };
+    const scopeTypes = new Map(
+      [...core.variables, ...inputs, ...state, ...fn.locals].map((variable) => [
+        variable.id,
+        variable.type,
+      ]),
+    );
+
+    // Block output records are a source abstraction; target FB fields are direct.
+    const place = (id: string, path: CorePath = []): string => {
+      let text = load(id),
+        typeId = required(scopeTypes.get(id));
+      let outputBlock: string | undefined;
+      for (const segment of path) {
+        const type = required(typeMap.get(typeId));
+        if (segment.kind === "field" && type.kind === "block" && segment.name === "out") {
+          outputBlock = type.block;
+          typeId = required(type.output);
+          continue;
+        }
+        if (segment.kind === "field" && outputBlock) {
+          const output = required(
+            required(blocks.get(outputBlock)).outputs.find((field) => field.name === segment.name),
+          );
+          text += `.${required(required(blockFields.get(outputBlock)).get(output.id))}`;
+          typeId = output.type;
+          outputBlock = undefined;
+        } else if (segment.kind === "field" && type.kind === "record") {
+          text += `.${targetTypes.field(typeId, segment.name)}`;
+          typeId = required(type.fields.find((field) => field.name === segment.name)).type;
+        } else if (segment.kind === "index" && type.kind === "array") {
+          // A strict enum converts explicitly to its DINT base, as HTTP JSON encoding does.
+          text +=
+            typeMap.get(segment.value.type)?.kind === "enum"
+              ? `[TO_DINT(${expression(segment.value)})]`
+              : `[${expression(segment.value)}]`;
+          typeId = type.element;
+        } else throw new Error("Invalid verified place");
+      }
+      return text;
+    };
+
+    const expression = (value: CoreExpression): string => {
+      if (value.kind === "constant") return targetTypes.literal(value.value, value.type);
+      if (value.kind === "load") return place(value.root, value.path);
+      if (value.kind === "borrow") return place(value.place.root, value.place.path);
+      if (value.kind === "convert" && typeMap.get(value.type)?.kind === "string")
+        return expression(value.operand);
+      if (value.kind === "unary" || value.kind === "convert")
+        return numeric.render(value, [expression(value.operand)]);
+      return numeric.render(value, [expression(value.left), expression(value.right)]);
+    };
+
+    // Aggregate constants are expanded into legal leaf assignments for ST.
+    const assignConstant = (
+      destination: string,
+      value: Constant,
+      id: string,
+      depth: number,
+      span: SourceSpan,
+    ): void => {
+      const type = required(typeMap.get(id));
+      if (type.kind === "record" && value.kind === "record")
+        type.fields.forEach((field) => {
+          assignConstant(
+            `${destination}.${targetTypes.field(id, field.name)}`,
+            required(value.fields[field.name]),
+            field.type,
+            depth,
+            span,
+          );
+        });
+      else if (type.kind === "array" && value.kind === "array")
+        value.items.forEach((item, index) => {
+          assignConstant(
+            `${destination}[${type.lowerBound + index}]`,
+            item,
+            type.element,
+            depth,
+            span,
+          );
+        });
+      else write(`${destination} := ${targetTypes.literal(value, id)};`, depth, span);
+    };
+
+    const body = (items: readonly CoreStatement[], depth: number): void => {
+      for (const item of items) {
+        switch (item.kind) {
+          case "assign":
+            if (item.value.kind === "constant")
+              assignConstant(
+                place(item.root, item.path),
+                item.value.value,
+                item.value.type,
+                depth,
+                item.span,
+              );
+            else
+              write(
+                `${place(item.root, item.path)} := ${expression(item.value)};`,
+                depth,
+                item.span,
+              );
+            break;
+          case "blockUpdate": {
+            const instance = instancedBlock(required(scopeTypes.get(item.instance)), typeMap);
+            if (!instance) throw new Error("Invalid verified block receiver");
+            const target = required(blocks.get(instance.block));
+            const arguments_ = Object.entries(item.inputs).map(([input, value]) => {
+              const formal = required(target.inputs.find((field) => field.name === input));
+              return `${required(required(blockFields.get(target.id)).get(formal.id))} := ${expression(value)}`;
+            });
+            const receiver = item.index
+              ? `${load(item.instance)}[${expression(item.index)}]`
+              : load(item.instance);
+            write(`${receiver}(${arguments_.join(", ")});`, depth, item.span);
+            break;
+          }
+          case "invoke": {
+            const receiver = item.instance
+              ? `${load(item.instance)}${item.index ? `[${expression(item.index)}]` : ""}.`
+              : "";
+            const called = required(core.functions.find((fn) => fn.id === item.function));
+            const programCall = this.programRoutines.has(called.id);
+            const arguments_ = item.arguments.map((value, index) => {
+              if (
+                !called.owner &&
+                !programCall &&
+                !called.parameters.some((parameter) => parameter.mode === "inOut")
+              )
+                return expression(value);
+              const parameter = required(called.parameters[index]);
+              const formal = required(
+                required(this.routineScopes.get(called.id)).references.get(parameter.id),
+              );
+              return `${formal} := ${expression(value)}`;
+            });
+            const call = `${receiver}${required(functionNames.get(item.function))}(${arguments_.join(", ")})`;
+            if (programCall) {
+              write(`${call};`, depth, item.span);
+              if (item.destination)
+                write(
+                  `${load(item.destination)} := ${required(functionNames.get(called.id))}.${required(this.programResults.get(called.id))};`,
+                  depth,
+                  item.span,
+                );
+              break;
+            }
+            write(
+              item.destination ? `${load(item.destination)} := ${call};` : `${call};`,
+              depth,
+              item.span,
+            );
+            break;
+          }
+          case "if":
+            write(`IF ${expression(item.condition)} THEN`, depth, item.span);
+            body(item.then, depth + 1);
+            if (item.else.length) {
+              write("ELSE", depth, item.span);
+              body(item.else, depth + 1);
+            }
+            write("END_IF;", depth, item.span);
+            break;
+          case "switch": {
+            for (const [index, branch] of item.cases.entries()) {
+              const conditions = branch.values.map(
+                (value) =>
+                  `(${expression(item.value)} = ${targetTypes.literal(value, item.value.type)})`,
+              );
+              write(`${index ? "ELSIF" : "IF"} ${conditions.join(" OR ")} THEN`, depth, item.span);
+              body(branch.body, depth + 1);
+            }
+            if (item.cases.length) {
+              if (item.fallback.length) write("ELSE", depth, item.span);
+              body(item.fallback, depth + 1);
+              write("END_IF;", depth, item.span);
+            } else body(item.fallback, depth);
+            break;
+          }
+          case "for": {
+            // Iterate with a DINT ordinal rather than overflowing the authored
+            // counter at a width boundary. Reconstruct its typed value each scan.
+            const counterType = scopeTypes.get(item.counter);
+            if (!counterType || item.start.kind !== "integer")
+              throw new Error("Invalid verified loop");
+            if (!item.maxIterations) {
+              if (item.counterScope === "existing")
+                write(
+                  `${load(item.counter)} := ${item.dynamic ? expression(item.dynamic.start) : targetTypes.literal(item.start, counterType)};`,
+                  depth,
+                  item.span,
+                );
+              break;
+            }
+            const ordinal = locals.allocate("iteration");
+            declarations.push(`    ${ordinal} : DINT;`);
+            declarationSpans.push(item.span);
+            const wide = counterType === "ULINT" ? "ULINT" : "LINT";
+            const ascending = BigInt(item.step) > 0n;
+            const step = BigInt(item.step) < 0n ? -BigInt(item.step) : BigInt(item.step);
+            let iterations = `DINT#${item.maxIterations}`;
+            let first = `${wide}#${item.start.value}`;
+            if (item.dynamic) {
+              first = `TO_${wide}(${expression(item.dynamic.start)})`;
+              const last = `TO_${wide}(${expression(item.dynamic.limit)})`;
+              const count = locals.allocate("iterationCount");
+              declarations.push(`    ${count} : DINT;`);
+              declarationSpans.push(item.span);
+              const comparison = ascending ? "<" : ">";
+              const inclusive = item.dynamic.exclusive ? "" : "=";
+              const distance = ascending ? `${last} - ${first}` : `${first} - ${last}`;
+              const exclusive = item.dynamic.exclusive ? ` - ${wide}#1` : "";
+              write(`${count} := DINT#0;`, depth, item.span);
+              write(`IF ${first} ${comparison}${inclusive} ${last} THEN`, depth, item.span);
+              write(
+                `${count} := ${wide}_TO_DINT(((${distance}${exclusive}) / ${wide}#${step}) + ${wide}#1);`,
+                depth + 1,
+                item.span,
+              );
+              write("END_IF;", depth, item.span);
+              iterations = count;
+            }
+            write(
+              `FOR ${ordinal} := DINT#0 TO ${item.dynamic ? `${iterations} - DINT#1` : `DINT#${item.maxIterations - 1}`} DO`,
+              depth,
+              item.span,
+            );
+            const counterValue = `${load(item.counter)} := TO_${counterType}(${first} ${ascending ? "+" : "-"} (${wide}#${step} * DINT_TO_${wide}(${ordinal})));`;
+            write(counterValue, depth + 1, item.span);
+            body(item.body, depth + 1);
+            write("END_FOR;", depth, item.span);
+            // CODESYS keeps the ordinal at EXIT and advances it on normal
+            // completion/CONTINUE. Reconstructing here preserves that distinction.
+            if (item.counterScope === "existing") write(counterValue, depth, item.span);
+            break;
+          }
+          case "return":
+            if (block) {
+              if (item.value) {
+                const returned = expression(item.value);
+                for (const output of block.outputs)
+                  write(
+                    `${load(output.id)} := ${returned}.${targetTypes.field(required(block.result), output.name)};`,
+                    depth,
+                    item.span,
+                  );
+              }
+            } else if (program) {
+              if (item.value)
+                write(
+                  `${required(this.programResults.get(fn.id))} := ${expression(item.value)};`,
+                  depth,
+                  item.span,
+                );
+            } else if (!method || fn.result)
+              write(
+                `${name} := ${item.value ? expression(item.value) : "TRUE"};`,
+                depth,
+                item.span,
+              );
+            if (mutex) release(mutex, depth, item.span);
+            write("RETURN;", depth, item.span);
+            break;
+          case "break":
+            write("EXIT;", depth, item.span);
+            break;
+          case "continue":
+            write("CONTINUE;", depth, item.span);
+            break;
+        }
+      }
+    };
+
+    if (mutex && acquired) {
+      // ARM64 implements __COMPARE_AND_SWAP with load-linked/store-conditional, which can fail
+      // even when the word holds the expected value. Retry while the lock reads free.
+      write(`${acquired} := FALSE;`, 0);
+      write(`WHILE NOT ${acquired} AND ${mutex} = 0 DO`, 0);
+      write(`${acquired} := __COMPARE_AND_SWAP(ADR(${mutex}), 0, 1);`, 1);
+      write("END_WHILE;", 0);
+      write(`IF NOT ${acquired} THEN`, 0);
+      if (unavailable) write(`${name} := ${unavailable};`, 1);
+      write("RETURN;", 1);
+      write("END_IF;", 0);
+    }
+    body(fn.body, 0);
+    if (mutex) release(mutex, 0);
+    if (!block && !method && !program && !fn.result) write(`${name} := TRUE;`, 0);
+
+    const header = this.routineHeader(fn, name);
+    const declaration = [header.declaration];
+    mappings.push({ path: `${mappingName}/declaration.st`, line: 1, span: fn.span });
+    const section = (keyword: string, items: readonly Variable[]): void => {
+      if (!items.length) return;
+      declaration.push(keyword);
+      for (const item of items) {
+        mappings.push({
+          path: `${mappingName}/declaration.st`,
+          line: declaration.length + 1,
+          span: item.span,
+        });
+        const initial =
+          item.initial && !instancedBlock(item.type, typeMap)
+            ? targetTypes.declarationInitializer(item.initial, item.type)
+            : "";
+        declaration.push(`    ${load(item.id)} : ${targetTypes.name(item.type)}${initial};`);
+      }
+      declaration.push("END_VAR");
+    };
+
+    section(
+      "VAR_INPUT",
+      inputs.filter((item) => item.mode !== "inOut"),
+    );
+    section(
+      "VAR_IN_OUT",
+      inputs.filter((item) => item.mode === "inOut"),
+    );
+    if (program && "parameters" in fn && fn.result) {
+      declaration.push(
+        "VAR_OUTPUT",
+        `    ${required(this.programResults.get(fn.id))} : ${targetTypes.name(fn.result)};`,
+        "END_VAR",
+      );
+    }
+    if (block) {
+      if (block.runtime?.kind === "mailbox")
+        declaration.push(
+          "VAR",
+          `    ${required(this.mailboxLocks.get(block.id))} : __XWORD;`,
+          "END_VAR",
+        );
+      section("VAR_OUTPUT", block.outputs);
+      section(
+        "VAR",
+        block.state.filter((item) => !layout.retainedVariables.has(item.id)),
+      );
+      section(
+        "VAR RETAIN",
+        block.state.filter((item) => layout.retainedVariables.has(item.id)),
+      );
+    }
+    if (declarations.length) {
+      declaration.push(block || program ? "VAR_TEMP" : "VAR");
+      declarationSpans.forEach((span, index) => {
+        mappings.push({
+          path: `${mappingName}/declaration.st`,
+          line: declaration.length + index + 1,
+          span,
+        });
+      });
+      declaration.push(...declarations, "END_VAR");
+    }
+
+    objects.push({
+      id: fn.id,
+      kind: header.kind,
+      name,
+      declaration: `${declaration.join("\n")}\n`,
+      implementation: `${lines.join("\n")}\n`,
+    });
+  }
+
+  private emitProgram(program: CodesysPlan["core"]["programs"][number]): void {
+    const { core, options } = this.plan;
+    const { names, functionNames, objects } = this;
+    // Each wrapper snapshots physical inputs before the authored scan and commits
+    // outputs afterwards. RETURN in an authored routine cannot skip that epilogue.
+    const explicit =
+      options.programNames && Object.hasOwn(options.programNames, program.name)
+        ? options.programNames[program.name]
+        : undefined;
+    const name = explicit ?? names.allocateObject("PRG", program.name);
+    const fn = required(core.functions.find((item) => item.id === program.entry));
+    const used = accessedStorage(fn, core);
+    const channels = this.channels.filter((channel) => used.has(channel.root));
+    const stateful = this.programRoutines.has(program.entry);
+    const call = `${functionNames.get(program.entry)}();`;
+    const lines = [
+      ...channels
+        .filter((channel) => channel.input)
+        .map(({ target, wire, inverted }) => `${target} := ${inverted ? "NOT " : ""}${wire};`),
+      stateful ? call : `plc_discard := ${call}`,
+      ...channels
+        .filter((channel) => !channel.input)
+        .map(({ target, wire }) => `${wire} := ${target};`),
+    ];
+    objects.push({
+      id: program.id,
+      kind: "program",
+      name,
+      declaration: stateful
+        ? `PROGRAM ${name}\n`
+        : `PROGRAM ${name}\nVAR\n    plc_discard : BOOL;\nEND_VAR\n`,
+      implementation: `${lines.join("\n")}\n`,
+    });
+  }
+}