@tsplc/compiler 0.0.0-stage → 0.2.0

package/dist/codesys.js

@@ -0,0 +1,2587 @@
+// packages/compiler/backends/codesys/config.ts
+import {
+  httpOptionsSchema,
+  buildTargetSchema,
+  publicationSchema
+} from "@tsplc/config";
+import { z as z2 } from "zod";
+
+// packages/compiler/backends/codesys/engineering.ts
+import { resolve } from "node:path";
+import { buildProject, configSchema, resolveConfig } from "@tsplc/build";
+import { z } from "zod";
+var engineeringBuildSchema = configSchema.omit({
+  sourceDir: true,
+  entry: true,
+  outDir: true,
+  task: true,
+  tasks: true
+});
+var engineeringSchema = z.strictObject({
+  kind: z.literal("v3.5"),
+  build: engineeringBuildSchema.optional()
+});
+function codesysBuildConfig(plan, bundle, paths) {
+  const settings = plan.options.engineering.build;
+  if (!settings)
+    throw new Error("CODESYS build requires engineering.build settings (codesys installation and template). Configure them or use --emit-only.");
+  const programs = new Map(plan.core.programs.map((program) => {
+    const matches = bundle.objects.filter((object) => object.id === program.id && object.kind === "program");
+    const generated = matches[0];
+    if (matches.length !== 1 || !generated)
+      throw new Error(`Generated bundle must contain one PROGRAM object for ${program.name}.`);
+    return [program.name, generated];
+  }));
+  const tasks = plan.deployment.tasks.map((task) => ({
+    ...task,
+    programs: task.programs.map((name) => {
+      const program = programs.get(name);
+      if (!program)
+        throw new Error(`Task ${task.name} references a missing generated PROGRAM ${name}.`);
+      return program.name;
+    })
+  }));
+  const first = plan.core.programs[0], entry = first && programs.get(first.name);
+  if (!entry)
+    throw new Error("CODESYS build requires a generated PROGRAM entry.");
+  const sourceDir = resolve(paths.sourceDir);
+  return resolveConfig({
+    ...settings,
+    libraryReferences: [
+      ...settings.libraryReferences ?? [],
+      ...Object.values(plan.http).some((endpoint) => endpoint.transport !== "opcua") ? ["Net Base Services, 4.0.0.0 (CODESYS)"] : [],
+      ...Object.values(plan.http).some((endpoint) => endpoint.tls) ? ["CmpX509Cert Implementation, 3.5.22.0 (System)"] : []
+    ],
+    ...paths.libraries ? { libraries: paths.libraries } : {},
+    ...paths.deviceTree ? { deviceTree: paths.deviceTree } : {},
+    ...paths.controller ? { controller: paths.controller } : {},
+    sourceDir,
+    entry: resolve(sourceDir, entry.sourcePath ?? `${entry.name}/declaration.st`),
+    outDir: resolve(paths.outDir),
+    tasks
+  }, paths.configFile);
+}
+async function buildCodesys(...arguments_) {
+  return buildProject(codesysBuildConfig(...arguments_));
+}
+
+// packages/compiler/backends/codesys/names.ts
+var keywords = new Set(`
+ACTION END_ACTION PROGRAM END_PROGRAM FUNCTION END_FUNCTION FUNCTION_BLOCK END_FUNCTION_BLOCK
+INTERFACE END_INTERFACE METHOD END_METHOD PROPERTY END_PROPERTY
+TYPE END_TYPE STRUCT END_STRUCT UNION END_UNION ARRAY POINTER REFERENCE
+VAR END_VAR VAR_INPUT VAR_OUTPUT VAR_IN_OUT VAR_TEMP VAR_GLOBAL VAR_EXTERNAL
+VAR_ACCESS VAR_CONFIG VAR_STAT VAR_INST VAR_GENERIC
+CONSTANT RETAIN NON_RETAIN PERSISTENT AT READ_ONLY READ_WRITE PARAMS
+CONFIGURATION END_CONFIGURATION RESOURCE END_RESOURCE TASK WITH SINGLE INTERVAL PRIORITY
+PRIVATE PUBLIC PROTECTED INTERNAL ABSTRACT FINAL OVERRIDE EXTENDS IMPLEMENTS THIS SUPER
+IF THEN ELSIF ELSE END_IF CASE OF END_CASE FOR TO BY DO END_FOR
+WHILE END_WHILE REPEAT UNTIL END_REPEAT RETURN EXIT CONTINUE JMP
+TRUE FALSE BOOL BYTE WORD DWORD LWORD SINT USINT INT UINT DINT UDINT LINT ULINT
+REAL LREAL TIME LTIME DATE LDATE DATE_AND_TIME LDATE_AND_TIME TIME_OF_DAY LTIME_OF_DAY
+DT LDT TOD LTOD STRING WSTRING CHAR WCHAR
+ANY ANY_BIT ANY_DATE ANY_DERIVED ANY_ELEMENTARY ANY_INT ANY_MAGNITUDE ANY_NUM
+ANY_REAL ANY_STRING ANY_UNSIGNED
+AND AND_THEN OR OR_ELSE XOR NOT MOD ADD SUB MUL DIV MOVE SEL MIN MAX LIMIT
+ABS ACOS ASIN ATAN COS SIN TAN EXP EXPT LN LOG SQRT TRUNC SHL SHR ROL ROR
+ADR SIZEOF CONCAT DELETE FIND INSERT LEFT LEN MID REPLACE RIGHT
+`.trim().split(/\s+/));
+var types = "(?:BOOL|BYTE|WORD|DWORD|LWORD|SINT|USINT|INT|UINT|DINT|UDINT|LINT|ULINT|REAL|LREAL|TIME|LTIME|DATE|LDATE|DATE_AND_TIME|LDATE_AND_TIME|TIME_OF_DAY|LTIME_OF_DAY|DT|LDT|TOD|LTOD|STRING|WSTRING|CHAR|WCHAR)";
+var conversion = new RegExp(`^(?:${types}_TO_${types}|TO_${types}|TRUNC_${types})$`);
+function isIecIdentifier(name) {
+  const upper = name.toUpperCase();
+  return /^[A-Za-z][A-Za-z0-9_]*$/.test(name) && !name.includes("__") && !keywords.has(upper) && !conversion.test(upper);
+}
+var identifierBody = (label) => label.replace(/[^A-Za-z0-9_]/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "") || "name";
+var pascalCase = (label) => label.split(/[^A-Za-z0-9]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+
+class Names {
+  used = new Set;
+  allocateObject(prefix, label) {
+    const source = prefix === "F" ? label.replace(/^PRG_/, "") : label;
+    const kind = prefix === "F" && source.startsWith("FUN_") ? "FUN" : prefix;
+    const body = source.startsWith(`${kind}_`) ? source.slice(kind.length + 1) : source;
+    return this.allocate(`${kind}_${identifierBody(body)}`);
+  }
+  reserve(name) {
+    this.used.add(name.toUpperCase());
+    const prefix = name.split(".")[0];
+    if (prefix)
+      this.used.add(prefix.toUpperCase());
+  }
+  allocate(label, preserve = true) {
+    const base = preserve && isIecIdentifier(label) ? label : `plc_${identifierBody(label)}`;
+    let name = base;
+    for (let suffix = 2;this.used.has(name.toUpperCase()); suffix++)
+      name = `${base}_${suffix}`;
+    this.reserve(name);
+    return name;
+  }
+}
+
+// packages/compiler/backends/codesys/config.ts
+var addressSchema = z2.object({
+  kind: z2.literal("direct"),
+  address: z2.string().regex(/^%(?:[IQ]X[0-9]+\.[0-7]|[IQ][BWD][0-9]+)$/),
+  type: z2.string().optional(),
+  mapped: z2.boolean().optional(),
+  inverted: z2.boolean().optional(),
+  shared: z2.boolean().optional()
+}).strict();
+var iecNames = z2.record(z2.string().min(1), z2.string().refine(isIecIdentifier, "Use a valid, non-reserved IEC identifier.")).optional();
+var optionsSchema = z2.object({
+  engineering: engineeringSchema,
+  http: httpOptionsSchema,
+  io: z2.record(z2.string().min(1), addressSchema),
+  publish: publicationSchema.default({ production: [], development: [] }),
+  buildTarget: buildTargetSchema.default("production"),
+  programNames: iecNames
+}).strict();
+function codesys(options) {
+  return { kind: "codesys", options };
+}
+function direct(address) {
+  return { kind: "direct", address };
+}
+// packages/compiler/backends/codesys/emit.ts
+import { defaultValue, instancedBlock as instancedBlock5, standardBlocks } from "@tsplc/compiler/ir";
+
+// packages/compiler/backends/codesys/numeric.ts
+import {
+  integerRange,
+  floatMaximum,
+  integerType
+} from "@tsplc/compiler/ir";
+function scalarLiteral(value, type) {
+  if (value.kind === "bool")
+    return value.value ? "TRUE" : "FALSE";
+  if (value.kind === "integer")
+    return `${type}#${value.value}`;
+  if (value.kind === "float") {
+    const text = Object.is(value.value, -0) ? "-0.0" : String(value.value).replace(/e/i, "E");
+    return `${type}#${text}`;
+  }
+  throw new Error("Expected verified scalar constant");
+}
+
+class NumericLowering {
+  types;
+  allocate;
+  objects = [];
+  helpers = new Map;
+  constructor(types, allocate) {
+    this.types = types;
+    this.allocate = allocate;
+  }
+  prepare(value) {
+    if (value.kind === "load") {
+      value.path?.forEach((segment) => {
+        if (segment.kind === "index")
+          this.prepare(segment.value);
+      });
+    }
+    if (value.kind === "borrow") {
+      value.place.path.forEach((segment) => {
+        if (segment.kind === "index")
+          this.prepare(segment.value);
+      });
+    }
+    if (value.kind === "binary") {
+      this.prepare(value.left);
+      this.prepare(value.right);
+      if (value.policy)
+        this.arithmetic(value.type, value.operator, value.policy);
+    }
+    if (value.kind === "unary")
+      this.prepare(value.operand);
+    if (value.kind === "convert") {
+      this.prepare(value.operand);
+      if (value.policy === "saturate")
+        this.saturation(value.operand.type, value.type);
+    }
+  }
+  render(value, operands) {
+    if (value.kind === "convert") {
+      return value.policy === "saturate" ? `${this.saturation(value.operand.type, value.type)}(${operands[0]})` : `TO_${value.type}(${operands[0]})`;
+    }
+    if (value.kind === "unary") {
+      if (value.operator === "timeToMilliseconds")
+        return `TIME_TO_UDINT(${operands[0]})`;
+      if (value.operator === "clock")
+        return "TO_DINT(TIME_TO_UDINT(TIME()))";
+      return value.operator === "not" ? `(NOT ${operands[0]})` : `TO_${value.type}(${value.operator === "negate" ? "-" : "NOT "}${operands[0]})`;
+    }
+    if (value.kind !== "binary")
+      throw new Error("Expected numeric operation");
+    if (value.policy) {
+      return `${this.arithmetic(value.type, value.operator, value.policy)}(${operands.join(", ")})`;
+    }
+    if (value.operator === "shiftLeft" || value.operator === "shiftRight") {
+      const shift = value.operator === "shiftLeft" ? "SHL" : "SHR";
+      return `TO_${value.type}(${shift}(${operands.join(", ")}))`;
+    }
+    const tokens = {
+      add: "+",
+      subtract: "-",
+      multiply: "*",
+      divide: "/",
+      remainder: "MOD",
+      equal: "=",
+      notEqual: "<>",
+      less: "<",
+      lessEqual: "<=",
+      greater: ">",
+      greaterEqual: ">=",
+      bitAnd: "AND",
+      bitOr: "OR",
+      bitXor: "XOR"
+    };
+    const token = tokens[value.operator];
+    if (!token)
+      throw new Error("Boolean short-circuit operation was not normalized");
+    const text = value.operator === "remainder" ? `(${operands[0]} - (${operands[0]} / ${operands[1]}) * ${operands[1]})` : `(${operands[0]} ${token} ${operands[1]})`;
+    return value.type === "BOOL" ? text : `TO_${value.type}(${text})`;
+  }
+  helper(key, type, inputs, body, locals = "") {
+    const existing = this.helpers.get(key);
+    if (existing)
+      return existing;
+    const name = this.allocate(`numeric_${key}`);
+    this.helpers.set(key, name);
+    const parameters = inputs.map(([input, inputType]) => `    ${input} : ${inputType};`).join(`
+`);
+    const variables = locals ? `VAR
+${locals}
+END_VAR
+` : "";
+    const declaration = `FUNCTION ${name} : ${type}
+VAR_INPUT
+${parameters}
+END_VAR
+${variables}`;
+    this.objects.push({
+      id: `numeric:${key}`,
+      kind: "function",
+      name,
+      declaration,
+      implementation: body(name)
+    });
+    return name;
+  }
+  add64() {
+    return this.helper("add64", "LWORD", [
+      ["a", "LWORD"],
+      ["b", "LWORD"]
+    ], (name) => `x := a;
+y := b;
+FOR i := 1 TO 64 DO
+    carry := SHL(x AND y, 1);
+    x := x XOR y;
+    y := carry;
+END_FOR;
+${name} := x;
+`, `    x, y, carry : LWORD;
+    i : UINT;`);
+  }
+  wrap64(operator) {
+    const add = this.add64();
+    if (operator === "add")
+      return add;
+    if (operator === "subtract") {
+      return this.helper("subtract64", "LWORD", [
+        ["a", "LWORD"],
+        ["b", "LWORD"]
+      ], (name) => `${name} := ${add}(a, ${add}(NOT b, LWORD#1));
+`);
+    }
+    if (operator !== "multiply")
+      throw new Error("Unsupported verified wrapping operation");
+    return this.helper("multiply64", "LWORD", [
+      ["a", "LWORD"],
+      ["b", "LWORD"]
+    ], (name) => `x := a;
+y := b;
+result := LWORD#0;
+FOR i := 1 TO 64 DO
+    IF (y AND LWORD#1) <> LWORD#0 THEN
+        result := ${add}(result, x);
+    END_IF;
+    x := SHL(x, 1);
+    y := SHR(y, 1);
+END_FOR;
+${name} := result;
+`, `    x, y, result : LWORD;
+    i : UINT;`);
+  }
+  arithmetic(typeId, operator, policy) {
+    const type = this.types.get(typeId);
+    if (type?.kind !== "integer")
+      throw new Error("Expected verified integer arithmetic");
+    const token = operator === "add" ? "+" : operator === "subtract" ? "-" : "*";
+    const key = `${policy}_${operator}_${typeId}`;
+    if (policy === "wrap") {
+      if (type.bits === 64) {
+        const operation = this.wrap64(operator);
+        return this.helper(key, typeId, [
+          ["a", typeId],
+          ["b", typeId]
+        ], (name) => `${name} := LWORD_TO_${typeId}(${operation}(${typeId}_TO_LWORD(a), ${typeId}_TO_LWORD(b)));
+`);
+      }
+      const wide = !type.signed && operator !== "subtract" ? "ULINT" : "LINT";
+      return this.helper(key, typeId, [
+        ["a", typeId],
+        ["b", typeId]
+      ], (name) => `${name} := ${wide}_TO_${typeId}(${typeId}_TO_${wide}(a) ${token} ${typeId}_TO_${wide}(b));
+`);
+    }
+    const [minimum, maximum] = integerRange(type);
+    const min = `${typeId}#${minimum}`, max = `${typeId}#${maximum}`, zero = `${typeId}#0`;
+    return this.helper(key, typeId, [
+      ["a", typeId],
+      ["b", typeId]
+    ], (name) => {
+      const clamp = (condition, endpoint, depth = "") => `${depth}IF ${condition} THEN
+${depth}    ${name} := ${endpoint};
+${depth}    RETURN;
+${depth}END_IF;
+`;
+      let body;
+      if (!type.signed) {
+        if (operator === "add")
+          body = clamp(`a > ${max} - b`, max);
+        else if (operator === "subtract")
+          body = clamp("a < b", zero);
+        else
+          body = `IF b <> ${zero} THEN
+${clamp(`a > ${max} / b`, max, "    ")}END_IF;
+`;
+      } else if (operator === "add") {
+        body = `IF b > ${zero} THEN
+${clamp(`a > ${max} - b`, max, "    ")}ELSIF b < ${zero} THEN
+${clamp(`a < ${min} - b`, min, "    ")}END_IF;
+`;
+      } else if (operator === "subtract") {
+        body = `IF b < ${zero} THEN
+${clamp(`a > ${max} + b`, max, "    ")}ELSIF b > ${zero} THEN
+${clamp(`a < ${min} + b`, min, "    ")}END_IF;
+`;
+      } else {
+        body = clamp(`a = ${zero}`, zero) + clamp(`b = ${zero}`, zero) + `IF a > ${zero} THEN
+    IF b > ${zero} THEN
+${clamp(`a > ${max} / b`, max, "        ")}    ELSE
+${clamp(`b < ${min} / a`, min, "        ")}    END_IF;
+ELSE
+    IF b > ${zero} THEN
+${clamp(`a < ${min} / b`, min, "        ")}    ELSE
+${clamp(`a < ${max} / b`, max, "        ")}    END_IF;
+END_IF;
+`;
+      }
+      return `${body}${name} := a ${token} b;
+`;
+    });
+  }
+  saturation(sourceId, targetId) {
+    const source = this.types.get(sourceId), target = this.types.get(targetId);
+    if (source?.kind === "float" && target?.kind === "float") {
+      if (source.bits <= target.bits)
+        return `TO_${targetId}`;
+      const maximum = floatMaximum(target);
+      const literal = (value, type) => scalarLiteral({ kind: "float", value }, type);
+      return this.helper(`saturate_${sourceId}_${targetId}`, targetId, [["value", sourceId]], (name) => `IF value < ${literal(-maximum, sourceId)} THEN
+    ${name} := ${literal(-maximum, targetId)};
+    RETURN;
+END_IF;
+IF value > ${literal(maximum, sourceId)} THEN
+    ${name} := ${literal(maximum, targetId)};
+    RETURN;
+END_IF;
+${name} := TO_${targetId}(value);
+`);
+    }
+    if (!source || !target || !integerType(source) || !integerType(target)) {
+      throw new Error("Expected verified integer saturation");
+    }
+    const [fromMin, fromMax] = integerRange(source), [toMin, toMax] = integerRange(target);
+    return this.helper(`saturate_${sourceId}_${targetId}`, targetId, [["value", sourceId]], (name) => {
+      let body = "";
+      if (fromMin < toMin)
+        body += `IF value < ${sourceId}#${toMin} THEN
+    ${name} := ${targetId}#${toMin};
+    RETURN;
+END_IF;
+`;
+      if (fromMax > toMax)
+        body += `IF value > ${sourceId}#${toMax} THEN
+    ${name} := ${targetId}#${toMax};
+    RETURN;
+END_IF;
+`;
+      return `${body}${name} := TO_${targetId}(value);
+`;
+    });
+  }
+}
+
+// packages/compiler/backends/codesys/plan.ts
+import {
+  instancedBlock as instancedBlock3,
+  isVerifiedCore
+} from "@tsplc/compiler/ir";
+import { ioLayout as ioLayout2 } from "@tsplc/typegen/hardware";
+
+// packages/compiler/backends/codesys/io-paths.ts
+import { ioLayout } from "@tsplc/typegen/hardware";
+
+// packages/compiler/backends/codesys/storage.ts
+import { basename } from "node:path";
+import { instancedBlock } from "@tsplc/compiler/ir";
+var moduleName = (variable) => basename(variable.span.file).replace(/\.[^.]+$/, "");
+function storageLayout(core) {
+  const types = new Map(core.types.map((type) => [type.id, type]));
+  const blocks = new Map(core.blocks.map((block) => [block.id, block]));
+  const retention = new Map;
+  const blockRetained = (id) => {
+    const cached = retention.get(id);
+    if (cached !== undefined)
+      return cached;
+    const block = blocks.get(id);
+    if (!block)
+      throw new Error("Missing verified block during retention planning.");
+    const retained = block.state.some((field) => {
+      const type = instancedBlock(field.type, types);
+      return field.retain || type !== undefined && blockRetained(type.block);
+    });
+    retention.set(id, retained);
+    return retained;
+  };
+  const retainedBlocks = new Set(core.blocks.filter((block) => blockRetained(block.id)).map((block) => block.id));
+  const retainedVariables = new Set([...core.variables, ...core.blocks.flatMap((block) => block.state)].filter((variable) => {
+    const type = instancedBlock(variable.type, types);
+    return variable.retain || type !== undefined && retainedBlocks.has(type.block);
+  }).map((variable) => variable.id));
+  const groups = new Map;
+  for (const variable of core.variables) {
+    if (variable.storage === "input" || variable.storage === "output")
+      continue;
+    const storage = variable.storage === "constant" ? "constants" : retainedVariables.has(variable.id) ? "retained" : "state";
+    const id = `${variable.span.file}:${storage}`;
+    let group = groups.get(id);
+    if (!group) {
+      group = { id, module: moduleName(variable), storage, variables: [] };
+      groups.set(id, group);
+    }
+    group.variables.push(variable);
+  }
+  return { retainedBlocks, retainedVariables, globalLists: [...groups.values()] };
+}
+
+// packages/compiler/backends/codesys/io-paths.ts
+var pathPattern = /^([\w$-]+)\.([A-Za-z_$][\w$]*)((?:\.[A-Za-z_$][\w$]*|\[-?\d+\])*)$/;
+var isStoragePath = (key) => key.includes(".") || key.includes("[");
+function resolveStoragePath(core, key) {
+  const match = pathPattern.exec(key);
+  if (!match)
+    return { error: `${key}: expected Module.variable followed by .field or [index].` };
+  const [, module, name, rest] = match;
+  const roots = core.variables.filter((item) => item.storage === "module" && item.name === name && moduleName(item) === module);
+  if (roots.length !== 1)
+    return {
+      error: roots.length ? `${key}: ${module}.${name} is declared by more than one module named ${module}.` : `${key}: no mutable module variable ${module}.${name}.`
+    };
+  const root = roots[0];
+  const types = new Map(core.types.map((type) => [type.id, type]));
+  let type = types.get(root.type);
+  const segments = [];
+  for (const [, field, index] of rest.matchAll(/\.([A-Za-z_$][\w$]*)|\[(-?\d+)\]/g)) {
+    if (field !== undefined) {
+      const member = type.kind === "record" ? type.fields.find((f) => f.name === field) : undefined;
+      if (!member)
+        return { error: `${key}: no field ${field}.` };
+      segments.push({ kind: "field", record: type.id, name: field });
+      type = types.get(member.type);
+    } else {
+      const value = Number(index);
+      if (type.kind !== "array")
+        return { error: `${key}: ${index} indexes a non-array value.` };
+      if (value < type.lowerBound || value >= type.lowerBound + type.length)
+        return {
+          error: `${key}: index ${value} is outside ${type.lowerBound}..${type.lowerBound + type.length - 1}.`
+        };
+      segments.push({ kind: "index", value });
+      type = types.get(type.element);
+    }
+  }
+  return { key, root, segments, type };
+}
+function iecSpelling(type, types) {
+  if (type.kind === "bool" || type.kind === "integer" || type.kind === "bits" || type.kind === "float")
+    return type.id;
+  if (type.kind !== "array")
+    return;
+  const element = iecSpelling(types.get(type.element), types);
+  const upper = type.lowerBound + type.length - 1;
+  return element && !element.startsWith("ARRAY") ? `ARRAY[${type.lowerBound}..${upper}] OF ${element}` : undefined;
+}
+function ioTargets(core) {
+  const types = new Map(core.types.map((type) => [type.id, type]));
+  const targets = [];
+  const add = (key, type) => {
+    const layout = ioLayout(iecSpelling(type, types) ?? "");
+    if (layout)
+      targets.push({ key, layout });
+  };
+  const visit = (key, type) => {
+    add(key, type);
+    if (type.kind === "record")
+      for (const field of type.fields)
+        visit(`${key}.${field.name}`, types.get(field.type));
+    if (type.kind === "array")
+      visit(`${key}[` + "${number}" + "]", types.get(type.element));
+  };
+  for (const variable of core.variables) {
+    if (variable.storage === "input" || variable.storage === "output")
+      add(variable.name, types.get(variable.type));
+    else if (variable.storage === "module")
+      visit(`${moduleName(variable)}.${variable.name}`, types.get(variable.type));
+  }
+  return targets;
+}
+
+// packages/compiler/backends/codesys/http.ts
+var opcuaServiceCapacity = 16;
+var resolveHttpEndpoint = (value, input) => {
+  const url = new URL(value);
+  if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.hash || url.hostname.includes(":"))
+    throw new Error("fetch requires an HTTP(S) URL with an IPv4 address or DNS hostname, without credentials or fragment.");
+  if ((url.pathname + url.search).length > 2048 || url.hostname.length > 253 || Number(url.port || (url.protocol === "https:" ? 443 : 80)) === 0)
+    throw new Error("HTTP URL exceeds the native host/path limits or has an invalid port.");
+  let token = "";
+  const origins = new Set;
+  for (const credential of input.credentials) {
+    const configured = process.env[credential.originEnv], secret = process.env[credential.bearerTokenEnv];
+    if (!configured || !secret)
+      throw new Error(`HTTP credentials require ${credential.originEnv} and ${credential.bearerTokenEnv}.`);
+    const origin = new URL(configured);
+    if (!["http:", "https:"].includes(origin.protocol) || origin.username || origin.password || origin.pathname !== "/" || origin.search || origin.hash)
+      throw new Error(`HTTP credential origin ${credential.originEnv} must contain only a scheme, host and port.`);
+    if (origins.has(origin.origin))
+      throw new Error("HTTP credential origins must be unique.");
+    origins.add(origin.origin);
+    if (/[\r\n\0]/.test(secret) || secret.length > 512)
+      throw new Error(`Invalid bearer token in ${credential.bearerTokenEnv}.`);
+    if (origin.origin === url.origin)
+      token = secret;
+  }
+  return {
+    host: url.hostname,
+    port: Number(url.port || (url.protocol === "https:" ? 443 : 80)),
+    authority: url.host,
+    path: url.pathname + url.search,
+    token,
+    timeoutMs: input.timeoutMs,
+    tls: url.protocol === "https:"
+  };
+};
+var quote = (text) => "'" + text.replaceAll("$", "$$").replaceAll("'", "$'").replaceAll("\r", "$R").replaceAll(`
+`, "$N") + "'";
+var httpLayouts = (block, types) => {
+  const request = block.inputs.find((v) => v.name === "request"), response = block.outputs.find((v) => v.name === "result");
+  if (!request || !response)
+    throw new Error("Missing HTTP record ports.");
+  const requestLayout = types.get(request.type), responseLayout = types.get(response.type);
+  if (requestLayout?.kind !== "record" || responseLayout?.kind !== "record" || responseLayout.fields.length === 0 || responseLayout.fields.length > 31)
+    throw new Error("HTTP requires closed request/response records with 1..31 response fields.");
+  const scalarSize = (id) => {
+    const type = types.get(id);
+    if (type?.kind === "string" && type.encoding === "utf8" && type.capacity <= 2048)
+      return type.capacity * 6 + 2;
+    if (type?.kind === "bool")
+      return 5;
+    if (type?.kind === "enum")
+      return Math.max(...type.members.map((member) => member.value.length));
+    if ((type?.kind === "integer" || type?.kind === "bits") && type.bits <= 32) {
+      const signed = type.kind === "integer" && type.signed;
+      return String(signed ? -(2 ** (type.bits - 1)) : 2 ** type.bits - 1).length;
+    }
+    throw new Error("HTTP JSON supports bounded UTF-8 strings, BOOL, enums, and integers up to 32 bits.");
+  };
+  const recordSize = (record, response) => 2 + record.fields.reduce((size, field) => {
+    const type = types.get(field.type);
+    const valueSize = type?.kind === "array" && !response ? 2 + type.length * (scalarSize(type.element) + 1) : scalarSize(field.type);
+    return size + field.name.length + 4 + valueSize;
+  }, 0);
+  if (recordSize(requestLayout, false) > 2048 || recordSize(responseLayout, true) > 2048)
+    throw new Error("The worst-case HTTP JSON payload exceeds the native 2048-byte buffer; reduce record/string/array bounds.");
+  return { request, response, requestLayout, responseLayout };
+};
+var validateHttpLayout = (block, types) => {
+  httpLayouts(block, types);
+};
+var emitHttp = (block, name, fields, types, target, endpoint, network, rpcGlobal) => {
+  const port = (label) => {
+    const variable = [...block.inputs, ...block.outputs].find((v) => v.name === label);
+    if (!variable)
+      throw new Error("Missing HTTP port " + label);
+    return fields.get(variable.id);
+  };
+  const { request, response, requestLayout, responseLayout } = httpLayouts(block, types);
+  const encode = (typeId, value) => {
+    const type = types.get(typeId);
+    if (type.kind === "array")
+      return Array.from({ length: type.length }, (_, i) => `${i ? "Append(',');" : ""}${encode(type.element, `${value}[${i + type.lowerBound}]`)}`).join(`
+`);
+    if (type.kind === "string" && type.encoding === "utf8" && type.capacity <= 2048)
+      return `WriteString(${value});`;
+    if (type.kind === "bool")
+      return `IF ${value} THEN Append('true'); ELSE Append('false'); END_IF;`;
+    if (type.kind === "enum")
+      return `Append(DINT_TO_STRING(TO_DINT(${value})));`;
+    if (type.kind === "bits" && type.bits <= 32)
+      return `Append(UDINT_TO_STRING(TO_UDINT(${value})));`;
+    if (type.kind === "integer" && type.bits <= 32)
+      return `Append(${target.name(typeId)}_TO_STRING(${value}));`;
+    throw new Error("HTTP JSON supports bounded UTF-8 strings, BOOL, enums, integers up to 32 bits and fixed arrays.");
+  };
+  const requestCode = requestLayout.fields.map((field, i) => {
+    const type = types.get(field.type), value = `${port("request")}.${target.field(request.type, field.name)}`;
+    return `Append(${quote((i ? "," : "") + '"' + field.name + '":')});${type.kind === "array" ? "Append('[');" : ""}${encode(field.type, value)}${type.kind === "array" ? "Append(']');" : ""}`;
+  }).join(`
+`);
+  const responseCode = responseLayout.fields.map((field, i) => {
+    const type = types.get(field.type), value = `${port("result")}.${target.field(response.type, field.name)}`;
+    let decode;
+    if (type.kind === "string" && type.encoding === "utf8" && type.capacity <= 2048)
+      decode = `ReadString(); IF ByteLength(token) > ${type.capacity} THEN malformed := TRUE; ELSE ${value} := token; END_IF;`;
+    else if (type.kind === "bool")
+      decode = `IF MatchLiteral('true') THEN ${value}:=TRUE; ELSIF MatchLiteral('false') THEN ${value}:=FALSE; ELSE malformed:=TRUE;END_IF;`;
+    else if ((type.kind === "integer" || type.kind === "bits") && type.bits <= 32 || type.kind === "enum") {
+      const signed = type.kind === "enum" || type.kind === "integer" && type.signed, bits = type.kind === "enum" ? 32 : type.bits;
+      const min = signed ? -(2 ** (bits - 1)) : 0, max = signed ? 2 ** (bits - 1) - 1 : 2 ** bits - 1;
+      decode = `ReadInteger(); IF numberValue < ${min} OR numberValue > ${max} THEN malformed:=TRUE; ELSE `;
+      if (type.kind === "enum")
+        decode += `CASE numberValue OF ${type.members.map((m) => `${m.value}: ${value}:=${target.name(field.type)}.${target.field(field.type, m.name)};`).join(" ")} ELSE malformed:=TRUE; END_CASE;`;
+      else
+        decode += `${value}:=TO_${target.name(field.type)}(numberValue);`;
+      decode += " END_IF;";
+    } else
+      throw new Error("HTTP responses currently require flat scalar records.");
+    return `${i === 0 ? "IF" : "ELSIF"} part = ${quote(field.name)} THEN IF (seen AND SHL(DWORD#1,${i})) <> 0 THEN malformed:=TRUE; END_IF; seen:=seen OR SHL(DWORD#1,${i}); ${decode}`;
+  }).join(`
+`);
+  const inputs = block.inputs.map((v) => `${fields.get(v.id)} : ${target.name(v.type)};`).join(`
+`);
+  const outputs = block.outputs.map((v) => `${fields.get(v.id)} : ${target.name(v.type)};`).join(`
+`);
+  const decodeResponse = `cursor:=1;malformed:=FALSE;seen:=0;
+SkipWhitespace();Expect(123);SkipWhitespace();
+WHILE cursor<=TO_UINT(ByteLength(payload)) AND NOT malformed DO
+ IF payload[cursor-1]=125 THEN cursor:=cursor+1;EXIT;END_IF;
+ ReadString();part:=token;SkipWhitespace();Expect(58);SkipWhitespace();
+ ${responseCode} ELSE malformed:=TRUE;END_IF;
+ SkipWhitespace();
+ IF payload[cursor-1]=44 THEN cursor:=cursor+1;SkipWhitespace();IF payload[cursor-1]=125 THEN malformed:=TRUE;END_IF;
+ ELSIF payload[cursor-1]<>125 THEN malformed:=TRUE;END_IF;
+END_WHILE;
+SkipWhitespace();
+IF malformed OR cursor<>TO_UINT(ByteLength(payload))+1 OR seen<>DWORD#${2 ** responseLayout.fields.length - 1} THEN ${port("error")}:=4;END_IF;`;
+  if (endpoint.transport === "opcua") {
+    if (!rpcGlobal)
+      throw new Error("Missing OPC UA RPC global.");
+    const channel = (field, index = "slotIndex") => `${rpcGlobal}.${field}[${index}]`;
+    return {
+      id: block.id,
+      kind: "functionBlock",
+      name,
+      declaration: `FUNCTION_BLOCK ${name}
+VAR_INPUT ${inputs} END_VAR
+VAR_OUTPUT ${outputs} END_VAR
+VAR
+ timeout:TON;stage:UINT;slotIndex:UINT;candidate:UINT;
+ identity:STRING(64);epoch:STRING(32);prefix:STRING(80);
+ payload:STRING(2048);token:STRING(2048);part:STRING(2048);
+ cursor:UINT;malformed:BOOL;seen:DWORD;numberValue:LINT;tokenUsed:UINT;
+END_VAR`,
+      implementation: `IF NOT ${port("start")} OR ${port("cancel")} THEN
+ IF slotIndex>0 THEN ${channel("requestIds")}:='';${channel("requests")}:='';${channel("inUse")}:=0;END_IF;
+ slotIndex:=0;stage:=0;timeout(IN:=FALSE);${port("busy")}:=FALSE;${port("done")}:=FALSE;${port("error")}:=0;RETURN;
+END_IF;
+IF stage=0 THEN
+ FOR candidate:=1 TO ${opcuaServiceCapacity} DO
+  (* __COMPARE_AND_SWAP can fail spuriously on ARM64; retry while the slot reads free. *)
+  WHILE slotIndex=0 AND ${channel("epochs", "candidate")}<>'' AND ${channel("inUse", "candidate")}=0 DO
+   IF __COMPARE_AND_SWAP(ADR(${channel("inUse", "candidate")}),0,1) THEN slotIndex:=candidate;END_IF;
+  END_WHILE;
+  IF slotIndex>0 THEN EXIT;END_IF;
+ END_FOR;
+ IF slotIndex=0 THEN ${port("error")}:=7;stage:=90;
+ ELSE
+  ${channel("sequence")}:=${channel("sequence")}+1;
+  IF ${channel("sequence")}=0 THEN ${channel("epochs")}:='';${port("error")}:=5;stage:=90;
+  ELSE
+   epoch:=${channel("epochs")};identity:=CONCAT(CONCAT(epoch,':'),UDINT_TO_STRING(${channel("sequence")}));
+   prefix:=CONCAT(identity,'|');payload:='';malformed:=FALSE;
+   Append('{');${requestCode}Append('}');
+   IF malformed THEN ${port("error")}:=3;stage:=90;
+   ELSIF ByteLength(payload)+LEN(prefix)>2048 THEN ${port("error")}:=3;stage:=90;
+   ELSE
+    FOR candidate:=0 TO LEN(prefix)-1 DO ${channel("requests")}[candidate]:=prefix[candidate];END_FOR;
+    FOR candidate:=0 TO ByteLength(payload)-1 DO ${channel("requests")}[candidate+LEN(prefix)]:=payload[candidate];END_FOR;
+    ${channel("requests")}[ByteLength(payload)+LEN(prefix)]:=0;${channel("requestIds")}:=identity;stage:=1;
+   END_IF;
+  END_IF;
+ END_IF;
+END_IF;
+timeout(IN:=stage<90,PT:=T#${endpoint.timeoutMs}ms);
+IF timeout.Q THEN ${port("error")}:=2;stage:=90;END_IF;
+IF stage=1 THEN
+ IF ${channel("epochs")}<>epoch THEN ${port("error")}:=5;stage:=90;
+ ELSIF ${channel("replyIds")}=identity AND_THEN LEFT(${channel("replies")},LEN(prefix))=prefix THEN
+  payload:='';cursor:=LEN(prefix);
+  IF ByteLength(${channel("replies")})<cursor+4 THEN ${port("error")}:=4;
+  ELSIF ${channel("replies")}[cursor]<>48 OR ${channel("replies")}[cursor+1]<>124 THEN ${port("error")}:=5;
+  ELSE
+   FOR candidate:=cursor+2 TO ByteLength(${channel("replies")})-1 DO payload[candidate-cursor-2]:=${channel("replies")}[candidate];END_FOR;
+   payload[ByteLength(${channel("replies")})-cursor-2]:=0;
+   ${decodeResponse}
+  END_IF;
+  stage:=90;
+ END_IF;
+END_IF;
+${port("busy")}:=stage<90;
+IF stage=90 THEN
+ IF slotIndex>0 THEN ${channel("requestIds")}:='';${channel("requests")}:='';${channel("inUse")}:=0;slotIndex:=0;END_IF;
+ timeout(IN:=FALSE);${port("busy")}:=FALSE;${port("done")}:=TRUE;
+END_IF;`
+    };
+  }
+  return {
+    id: block.id,
+    kind: "functionBlock",
+    name,
+    declaration: `FUNCTION_BLOCK ${name}
+VAR_INPUT
+${inputs}
+END_VAR
+VAR_OUTPUT
+${outputs}
+END_VAR
+VAR
+  remoteAddress : NBS.IPv4Address;
+  remoteIP : NBS.IIPAddress := remoteAddress;
+  serverHost : STRING(255) := ${quote(endpoint.host)};
+  resolver : NBS.ResolveHostname := (itfAsyncProperty:=${network});
+  ${endpoint.tls ? `certificateVerifier : ${name}_CertificateVerifier;
+  tlsContext : NBS.TLSContext := (itfCertVerifer:=certificateVerifier,sUseCaseName:='tsPLC HTTPS',ePurpose:=NBS.PURPOSE.CLIENT_SIDE,sTLSVersion:='1.2',sHostname:=${quote(endpoint.host)},udiVerificationMode:=2);` : ""}
+  client : NBS.TCP_Client := (itfAsyncProperty:=${network},itfIPAddress:=remoteAddress,uiPort:=${endpoint.port},udiTimeOut:=${endpoint.timeoutMs * 1000}${endpoint.tls ? ",itfTLSContext:=tlsContext" : ""});
+  writer : NBS.TCP_Write;
+  reader : NBS.TCP_Read;
+  timeout : TON;
+  stage : UINT;
+  wire : STRING(8192);
+  received : STRING(8192);
+  chunk : ARRAY[0..8191] OF BYTE;
+  payload : STRING(2048);
+  token : STRING(2048);
+  part : STRING(2048);
+  used : UINT;
+  headerEnd : UINT;
+  contentLength : DINT;
+  status : UINT;
+  cursor : UINT;
+  malformed : BOOL;
+  seen : DWORD;
+  numberValue : LINT;
+  wireUsed : UINT;
+  tokenUsed : UINT;
+  index : UINT;
+END_VAR
+`,
+    implementation: `IF NOT ${port("start")} OR ${port("cancel")} THEN
+ resolver(xExecute:=FALSE,itfIPAddress:=remoteIP);client(xEnable:=FALSE); writer(xExecute:=FALSE); reader(xEnable:=FALSE); timeout(IN:=FALSE);
+ stage:=0; ${port("busy")}:=FALSE; ${port("done")}:=FALSE; ${port("error")}:=0;
+ RETURN;
+END_IF;
+IF stage=0 THEN
+ payload:=''; malformed:=FALSE; used:=0; received:='';
+ ${block.runtime?.kind === "http" && block.runtime.json ? `Append('{'); ${requestCode} Append('}');` : ""}
+ IF malformed THEN ${port("error")}:=3; stage:=90;
+ ELSE
+ wire:='';wireUsed:=0;
+ AppendWire(${quote((block.runtime?.kind === "http" ? block.runtime.method : "GET") + " " + endpoint.path + ` HTTP/1.1\r
+Host: ` + endpoint.authority + `\r
+` + (endpoint.token ? "Authorization: Bearer " + endpoint.token + `\r
+` : "") + (block.runtime?.kind === "http" && block.runtime.json ? `Content-Type: application/json\r
+` : "") + `Accept: application/json\r
+Connection: close\r
+Content-Length: `)});
+ AppendWire(UINT_TO_STRING(ByteLength(payload)));AppendWire('$R$N$R$N');AppendWire(payload); stage:=10;
+ END_IF;
+END_IF;
+timeout(IN:=stage<90,PT:=T#${endpoint.timeoutMs}ms);
+IF timeout.Q THEN ${port("error")}:=2; stage:=90; END_IF;
+${port("busy")}:=stage<90;
+IF stage=10 THEN
+ resolver(xExecute:=TRUE,sHostname:=serverHost,itfIPAddress:=remoteIP);
+ IF resolver.xError THEN ${port("error")}:=5;stage:=90;ELSIF resolver.xDone THEN stage:=1;END_IF;
+END_IF;
+IF stage=1 THEN
+ client(xEnable:=TRUE);
+ IF client.xError THEN ${port("error")}:=${endpoint.tls ? 6 : 5};stage:=90; ELSIF client.xActive THEN stage:=2;END_IF;
+END_IF;
+IF stage=2 THEN
+ writer(xExecute:=TRUE,itfConnection:=client.itfConnection,pData:=ADR(wire),udiSize:=UINT_TO_UDINT(wireUsed));
+ IF writer.xError THEN ${port("error")}:=5;stage:=90;ELSIF writer.xDone THEN stage:=3;END_IF;
+END_IF;
+IF stage=3 THEN
+ IF used>=8191 THEN ${port("error")}:=3;stage:=90;
+ ELSE
+ reader(xEnable:=TRUE,itfConnection:=client.itfConnection,pData:=ADR(chunk),udiSize:=8191);
+ IF reader.xError THEN ${port("error")}:=5;stage:=90;
+ ELSIF reader.xReady AND reader.udiCount>0 THEN
+ IF TO_UDINT(used)+reader.udiCount>8191 THEN ${port("error")}:=3;stage:=90;
+ ELSE
+ FOR index:=0 TO TO_UINT(reader.udiCount)-1 DO received[used+index]:=chunk[index];END_FOR;
+ used:=used+TO_UINT(reader.udiCount);received[used]:=0;
+ FindHeaders();
+ IF headerEnd=0 AND used>4096 THEN ${port("error")}:=3;stage:=90;END_IF;
+ IF headerEnd>0 THEN
+  IF headerEnd>4096 THEN ${port("error")}:=3;stage:=90;
+  ELSE
+   ReadHeaders();
+   IF malformed OR contentLength<0 OR contentLength>2048 THEN ${port("error")}:=3;stage:=90;
+   ELSIF TO_DINT(used)>=TO_DINT(headerEnd)+3+contentLength THEN
+    IF status<200 OR status>=300 THEN ${port("error")}:=10000+status;stage:=90;
+    ELSE
+     payload:='';IF contentLength>0 THEN FOR index:=0 TO TO_UINT(contentLength)-1 DO payload[index]:=received[headerEnd+3+index]; END_FOR;END_IF;payload[TO_UINT(contentLength)]:=0; ${decodeResponse}
+     stage:=90;
+    END_IF;
+   END_IF;
+  END_IF;
+ END_IF;
+ END_IF;
+ END_IF;
+ END_IF;
+END_IF;
+IF stage=90 THEN
+ resolver(xExecute:=FALSE,itfIPAddress:=remoteIP);client(xEnable:=FALSE);writer(xExecute:=FALSE);reader(xEnable:=FALSE);timeout(IN:=FALSE);
+ ${port("busy")}:=FALSE;${port("done")}:=TRUE;
+END_IF;
+`
+  };
+};
+var httpCertificateVerifier = (owner, name, endpoint) => {
+  if (!endpoint.tls)
+    return [];
+  const id = `${owner}:certificateVerifier`;
+  const ipv4 = /^\d+\.\d+\.\d+\.\d+$/.test(endpoint.host);
+  return [
+    {
+      id,
+      kind: "functionBlock",
+      name: `${name}_CertificateVerifier`,
+      declaration: `FUNCTION_BLOCK ${name}_CertificateVerifier IMPLEMENTS NBS.ICertificateVerifier
+VAR
+  hostname:STRING(255):=${quote(endpoint.host)};
+  ${ipv4 ? `address:ARRAY[0..3] OF BYTE := [${endpoint.host.split(".").join(",")}];` : ""}
+END_VAR`,
+      implementation: ""
+    },
+    {
+      id: `${id}:VerifyCertificate`,
+      parent: id,
+      kind: "method",
+      name: "VerifyCertificate",
+      declaration: `METHOD PUBLIC VerifyCertificate : UDINT
+VAR_INPUT hCert:POINTER TO BYTE;eCurState:UDINT;END_VAR
+VAR matched:BOOL;result:UDINT;END_VAR`,
+      implementation: `VerifyCertificate:=eCurState;
+IF eCurState<>0 THEN RETURN;END_IF;
+matched:=CmpX509Cert_Implementation.${ipv4 ? "X509CertCheckIP(hCert,ADR(address),0,ADR(result))" : "X509CertCheckHost(hCert,ADR(hostname),4,ADR(result))"};
+IF result<>0 THEN VerifyCertificate:=result;ELSIF NOT matched THEN VerifyCertificate:=1;END_IF;`
+    }
+  ];
+};
+var httpMethods = (owner, transport = "http") => {
+  const method = (name, declaration, implementation, result) => ({
+    id: `${owner}:${name}`,
+    parent: owner,
+    kind: "method",
+    name,
+    declaration: `METHOD PRIVATE ${name}${result ? ` : ${result}` : ""}
+${declaration}`,
+    implementation
+  });
+  return [
+    method("ByteLength", `VAR_INPUT value:STRING(8192);END_VAR
+VAR i:UINT;END_VAR`, "ByteLength:=0;FOR i:=0 TO 8191 DO IF value[i]=0 THEN ByteLength:=i;RETURN;END_IF;END_FOR;ByteLength:=8192;", "UINT"),
+    method("Append", `VAR_INPUT value : STRING(2048); END_VAR
+VAR offset:UINT;i:UINT;END_VAR`, `offset:=TO_UINT(ByteLength(payload));IF offset+TO_UINT(ByteLength(value))>2048 THEN malformed:=TRUE; ELSE IF ByteLength(value)>0 THEN FOR i:=0 TO TO_UINT(ByteLength(value))-1 DO payload[offset+i]:=value[i];END_FOR;END_IF;payload[offset+TO_UINT(ByteLength(value))]:=0;END_IF;`),
+    method("AppendWire", `VAR_INPUT value:STRING(8192);END_VAR
+VAR i:UINT;END_VAR`, `IF wireUsed+TO_UINT(ByteLength(value))>8191 THEN malformed:=TRUE;RETURN;END_IF;IF ByteLength(value)>0 THEN FOR i:=0 TO TO_UINT(ByteLength(value))-1 DO wire[wireUsed+i]:=value[i];END_FOR;END_IF;wireUsed:=wireUsed+TO_UINT(ByteLength(value));wire[wireUsed]:=0;`),
+    method("FindHeaders", "VAR i:UINT;END_VAR", `headerEnd:=0;IF used<4 THEN RETURN;END_IF;
+FOR i:=0 TO used-4 DO IF received[i]=13 AND received[i+1]=10 AND received[i+2]=13 AND received[i+3]=10 THEN headerEnd:=i+1;RETURN;END_IF;END_FOR;`),
+    method("MatchLiteral", `VAR_INPUT value:STRING(8);END_VAR
+VAR i:UINT;size:UINT;END_VAR`, `MatchLiteral:=FALSE;size:=TO_UINT(ByteLength(value));IF cursor+size-1>TO_UINT(ByteLength(payload)) THEN RETURN;END_IF;
+FOR i:=0 TO size-1 DO IF payload[cursor-1+i]<>value[i] THEN RETURN;END_IF;END_FOR;cursor:=cursor+size;MatchLiteral:=TRUE;`, "BOOL"),
+    method("ReadHeaders", `VAR lineStart:UINT;lineEnd:UINT;i:UINT;j:UINT;key:STRING(64);octet:BYTE;found:BOOL;digits:UINT;END_VAR`, `malformed:=FALSE;found:=FALSE;contentLength:=-1;
+IF LEFT(received,9)<>'HTTP/1.1 ' AND LEFT(received,9)<>'HTTP/1.0 ' THEN malformed:=TRUE;RETURN;END_IF;
+status:=0;FOR i:=9 TO 11 DO IF received[i]<48 OR received[i]>57 THEN malformed:=TRUE;RETURN;END_IF;status:=status*10+TO_UINT(received[i]-48);END_FOR;
+lineStart:=1;
+WHILE lineStart<headerEnd DO
+ lineEnd:=lineStart;WHILE lineEnd<headerEnd AND received[lineEnd-1]<>13 DO lineEnd:=lineEnd+1;END_WHILE;
+ key:='';j:=0;i:=lineStart;
+ WHILE i<lineEnd AND received[i-1]<>58 AND j<63 DO octet:=received[i-1];IF octet>=65 AND octet<=90 THEN octet:=octet+32;END_IF;key[j]:=octet;j:=j+1;i:=i+1;END_WHILE;key[j]:=0;
+ IF key='transfer-encoding' THEN malformed:=TRUE;RETURN;END_IF;
+ IF key='content-length' THEN
+  IF found THEN malformed:=TRUE;RETURN;END_IF;found:=TRUE;contentLength:=0;digits:=0;i:=i+1;
+  WHILE i<lineEnd AND received[i-1]=32 DO i:=i+1;END_WHILE;
+  WHILE i<lineEnd DO octet:=received[i-1];IF octet<48 OR octet>57 OR digits>=5 THEN malformed:=TRUE;RETURN;END_IF;contentLength:=contentLength*10+TO_DINT(octet-48);digits:=digits+1;i:=i+1;END_WHILE;
+  IF digits=0 THEN malformed:=TRUE;RETURN;END_IF;
+ END_IF;
+ lineStart:=lineEnd+2;
+END_WHILE;`),
+    method("WriteString", `VAR_INPUT value : STRING(2048); END_VAR
+VAR i:UINT; one:STRING(1); hex:STRING(16):='0123456789abcdef'; END_VAR`, `Append('"');IF ByteLength(value)>0 THEN FOR i:=0 TO ByteLength(value)-1 DO
+ one[0]:=value[i];one[1]:=0;
+ IF value[i]=34 OR value[i]=92 THEN Append('\\');Append(one);
+ ELSIF value[i]<32 THEN Append('\\u00');one[0]:=hex[SHR(value[i],4)];Append(one);one[0]:=hex[value[i] AND 15];Append(one);
+ ELSE Append(one);END_IF;
+ END_FOR;END_IF;Append('"');`),
+    method("SkipWhitespace", "", `WHILE cursor<=TO_UINT(ByteLength(payload)) DO IF payload[cursor-1]<>32 AND payload[cursor-1]<>9 AND payload[cursor-1]<>10 AND payload[cursor-1]<>13 THEN EXIT;END_IF;cursor:=cursor+1;END_WHILE;`),
+    method("Expect", "VAR_INPUT value:BYTE; END_VAR", `IF cursor>TO_UINT(ByteLength(payload)) OR_ELSE payload[cursor-1]<>value THEN malformed:=TRUE;ELSE cursor:=cursor+1;END_IF;`),
+    method("TokenByte", "VAR_INPUT value:BYTE;END_VAR", `IF tokenUsed>=2048 OR value=0 THEN malformed:=TRUE;RETURN;END_IF;token[tokenUsed]:=value;tokenUsed:=tokenUsed+1;token[tokenUsed]:=0;`),
+    method("ReadHex", "VAR value:UDINT;i:UINT;octet:BYTE;END_VAR", `numberValue:=0;FOR i:=1 TO 4 DO
+IF cursor>TO_UINT(ByteLength(payload)) THEN malformed:=TRUE;RETURN;END_IF;
+octet:=payload[cursor-1];cursor:=cursor+1;
+IF octet>=48 AND octet<=57 THEN value:=TO_UDINT(octet-48);ELSIF octet>=65 AND octet<=70 THEN value:=TO_UDINT(octet-55);ELSIF octet>=97 AND octet<=102 THEN value:=TO_UDINT(octet-87);ELSE malformed:=TRUE;RETURN;END_IF;
+numberValue:=numberValue*16+TO_LINT(value);END_FOR;`),
+    method("ReadString", `VAR octet:BYTE;point:UDINT;high:UDINT;END_VAR`, `token:='';tokenUsed:=0;Expect(34);
+WHILE cursor<=TO_UINT(ByteLength(payload)) AND NOT malformed DO
+ octet:=payload[cursor-1];cursor:=cursor+1;
+ IF octet=34 THEN ValidateUtf8();RETURN;END_IF;
+ IF octet=92 THEN
+  IF cursor>TO_UINT(ByteLength(payload)) THEN malformed:=TRUE;RETURN;END_IF;
+  octet:=payload[cursor-1];cursor:=cursor+1;
+  CASE octet OF
+  34,47,92: TokenByte(octet);
+  98:TokenByte(8);102:TokenByte(12);110:TokenByte(10);114:TokenByte(13);116:TokenByte(9);
+  117:
+   ReadHex();point:=TO_UDINT(numberValue);
+   IF point>=55296 AND point<=56319 THEN
+    high:=point;Expect(92);Expect(117);ReadHex();
+    IF numberValue<56320 OR numberValue>57343 THEN malformed:=TRUE;RETURN;END_IF;
+    point:=65536+(high-55296)*1024+TO_UDINT(numberValue)-56320;
+   ELSIF point>=56320 AND point<=57343 THEN malformed:=TRUE;RETURN;END_IF;
+   IF point<128 THEN TokenByte(TO_BYTE(point));
+   ELSIF point<2048 THEN TokenByte(TO_BYTE(192+SHR(point,6)));TokenByte(TO_BYTE(128+(point AND 63)));
+   ELSIF point<65536 THEN TokenByte(TO_BYTE(224+SHR(point,12)));TokenByte(TO_BYTE(128+(SHR(point,6) AND 63)));TokenByte(TO_BYTE(128+(point AND 63)));
+   ELSE TokenByte(TO_BYTE(240+SHR(point,18)));TokenByte(TO_BYTE(128+(SHR(point,12) AND 63)));TokenByte(TO_BYTE(128+(SHR(point,6) AND 63)));TokenByte(TO_BYTE(128+(point AND 63)));END_IF;
+  ELSE malformed:=TRUE;RETURN;
+  END_CASE;
+ ELSIF octet<32 THEN malformed:=TRUE;RETURN;ELSE TokenByte(octet);END_IF;
+END_WHILE;malformed:=TRUE;`),
+    method("ValidateUtf8", "VAR i:UINT;j:UINT;count:UINT;first:BYTE;next:BYTE;END_VAR", `i:=0;
+WHILE i<tokenUsed AND NOT malformed DO
+ first:=token[i];
+ IF first<128 THEN i:=i+1;
+ ELSE
+  IF first>=194 AND first<=223 THEN count:=1;ELSIF first>=224 AND first<=239 THEN count:=2;ELSIF first>=240 AND first<=244 THEN count:=3;ELSE malformed:=TRUE;RETURN;END_IF;
+  IF i+count>=tokenUsed THEN malformed:=TRUE;RETURN;END_IF;
+  next:=token[i+1];
+  IF (first=224 AND next<160) OR (first=237 AND next>=160) OR (first=240 AND next<144) OR (first=244 AND next>=144) THEN malformed:=TRUE;RETURN;END_IF;
+  FOR j:=1 TO count DO IF token[i+j]<128 OR token[i+j]>191 THEN malformed:=TRUE;RETURN;END_IF;END_FOR;
+  i:=i+count+1;
+ END_IF;
+END_WHILE;`),
+    method("ReadInteger", "VAR negative:BOOL;digits:UINT;octet:BYTE;END_VAR", `numberValue:=0;negative:=FALSE;digits:=0;
+IF payload[cursor-1]=45 THEN negative:=TRUE;cursor:=cursor+1;END_IF;
+WHILE cursor<=TO_UINT(ByteLength(payload)) DO
+ octet:=payload[cursor-1];IF octet<48 OR octet>57 THEN EXIT;END_IF;
+ IF digits>=10 THEN malformed:=TRUE;RETURN;END_IF;
+ IF digits>0 AND numberValue=0 THEN malformed:=TRUE;RETURN;END_IF;numberValue:=numberValue*10+TO_LINT(octet-48);digits:=digits+1;cursor:=cursor+1;
+END_WHILE;
+IF digits=0 THEN malformed:=TRUE;END_IF;IF negative THEN numberValue:=-numberValue;END_IF;`)
+  ].filter((item) => transport === "http" || !["AppendWire", "FindHeaders", "ReadHeaders"].includes(item.name));
+};
+
+// packages/compiler/backends/codesys/task-access.ts
+import { instancedBlock as instancedBlock2 } from "@tsplc/compiler/ir";
+function accessedStorage(fn, core, scheduledHost) {
+  const scheduledCall = fn.body.find((item) => item.kind === "invoke" && item.instance === scheduledHost);
+  const result = new Set, seen = new Set;
+  const functions = new Map(core.functions.map((item) => [item.id, item]));
+  const blocks = new Map(core.blocks.map((item) => [item.id, item]));
+  const types = new Map(core.types.map((item) => [item.id, item]));
+  const variables = new Map([
+    ...core.variables,
+    ...core.functions.flatMap((item) => [...item.parameters, ...item.locals]),
+    ...core.blocks.flatMap((item) => [
+      ...item.inputs,
+      ...item.outputs,
+      ...item.state,
+      ...item.locals
+    ])
+  ].map((item) => [item.id, item]));
+  const path = (segments = []) => {
+    segments.forEach((segment) => {
+      if (segment.kind === "index")
+        expression(segment.value);
+    });
+  };
+  const expression = (value) => {
+    if (value.kind === "load") {
+      result.add(value.root);
+      path(value.path);
+    }
+    if (value.kind === "borrow") {
+      result.add(value.place.root);
+      path(value.place.path);
+    }
+    if (value.kind === "unary" || value.kind === "convert")
+      expression(value.operand);
+    if (value.kind === "binary") {
+      expression(value.left);
+      expression(value.right);
+    }
+  };
+  const body = (items) => {
+    for (const item of items) {
+      if (item.kind === "assign") {
+        result.add(item.root);
+        path(item.path);
+        expression(item.value);
+      }
+      if (item.kind === "if") {
+        expression(item.condition);
+        body(item.then);
+        body(item.else);
+      }
+      if (item.kind === "switch") {
+        expression(item.value);
+        for (const branch of item.cases)
+          body(branch.body);
+        body(item.fallback);
+      }
+      if (item.kind === "for") {
+        if (item.dynamic) {
+          expression(item.dynamic.start);
+          expression(item.dynamic.limit);
+        }
+        result.add(item.counter);
+        body(item.body);
+      }
+      if (item.kind === "return" && item.value)
+        expression(item.value);
+      if (item.kind === "invoke") {
+        if (item.instance && item !== scheduledCall)
+          result.add(item.instance);
+        if (item.index)
+          expression(item.index);
+        item.arguments.forEach(expression);
+        if (item.destination)
+          result.add(item.destination);
+        const called = functions.get(item.function);
+        if (called && !seen.has(called.id)) {
+          seen.add(called.id);
+          body(called.body);
+        }
+      }
+      if (item.kind === "blockUpdate") {
+        result.add(item.instance);
+        if (item.index)
+          expression(item.index);
+        Object.values(item.inputs).forEach(expression);
+        const variable = variables.get(item.instance);
+        if (!variable)
+          throw new Error("Missing verified instance during task planning.");
+        const type = instancedBlock2(variable.type, types);
+        const block = type && blocks.get(type.block);
+        if (block && !seen.has(block.id)) {
+          seen.add(block.id);
+          body(block.body);
+        }
+      }
+    }
+  };
+  seen.add(fn.id);
+  body(fn.body);
+  return result;
+}
+
+// packages/compiler/backends/codesys/publication.ts
+var globals = (core) => core.variables.filter((variable) => variable.storage === "module" && variable.exported);
+var publicationSelectors = (core) => {
+  const variables = globals(core);
+  return [
+    ...new Set(variables.flatMap((variable) => [
+      moduleName(variable),
+      `${moduleName(variable)}.${variable.name}`
+    ]))
+  ].sort();
+};
+var resolvePublication = (core, policy) => {
+  const variables = globals(core);
+  const errors = [];
+  const select = (selectors) => {
+    const selected = new Set(variables.filter((variable) => variable.exposure).map((variable) => variable.id));
+    const seen = new Set;
+    for (const selector of selectors) {
+      if (seen.has(selector))
+        errors.push(`Duplicate publication selector ${selector}.`);
+      seen.add(selector);
+      const candidates = variables.filter((variable) => selector === moduleName(variable) || selector === `${moduleName(variable)}.${variable.name}`);
+      if (!candidates.length) {
+        errors.push(`Unknown publication selector ${selector}; select an exported mutable global or its module.`);
+        continue;
+      }
+      if (new Set(candidates.map((variable) => variable.span.file)).size !== 1) {
+        errors.push(`Ambiguous publication selector ${selector}.`);
+        continue;
+      }
+      for (const variable of candidates)
+        selected.add(variable.id);
+    }
+    return variables.filter((variable) => selected.has(variable.id)).map((variable) => variable.id);
+  };
+  const publication = {
+    production: select(policy.production),
+    development: select(policy.development)
+  };
+  return { publication, errors };
+};
+
+// packages/compiler/backends/codesys/plan.ts
+var planned = Symbol("CODESYS plan");
+var plans = new WeakSet;
+function diagnostic(message, span) {
+  return { origin: "backend", code: "PLC7001", severity: "error", message, ...span && { span } };
+}
+function isCodesysPlan(plan) {
+  return plans.has(plan);
+}
+function planCodesys(core, deployment, value) {
+  if (!isVerifiedCore(core))
+    return { diagnostics: [diagnostic("CODESYS requires a verified, normalized core module.")] };
+  const parsed = optionsSchema.safeParse(value);
+  if (!parsed.success)
+    return {
+      diagnostics: parsed.error.issues.map((issue) => diagnostic(`${issue.path.join(".")}: ${issue.message}`))
+    };
+  const backgroundTasks = new Map;
+  for (const program of core.programs) {
+    if (!program.background)
+      continue;
+    const { priority, intervalNanoseconds } = program.background;
+    const name = `TsplcBackground_${priority}_${BigInt(intervalNanoseconds) / 1000000n}`;
+    const existing = backgroundTasks.get(name);
+    backgroundTasks.set(name, {
+      name,
+      priority,
+      intervalNanoseconds,
+      programs: [...existing?.programs ?? [], program.name]
+    });
+  }
+  deployment = { tasks: [...deployment.tasks, ...backgroundTasks.values()] };
+  const options = parsed.data;
+  const diagnostics = [];
+  const report = (message, span) => {
+    diagnostics.push(diagnostic(message, span));
+  };
+  const callerTasks = deployment.tasks;
+  for (const continuation of core.programs.filter((program) => program.continuation)) {
+    const scope = continuation.continuation;
+    const root = core.variables.find((variable) => variable.name === scope.instance && variable.span.file === scope.file);
+    if (!root) {
+      report(`Missing continuation owner ${scope.instance}.`);
+      continue;
+    }
+    const owners = callerTasks.filter((task) => task.programs.some((name) => {
+      const program = core.programs.find((program) => program.name === name);
+      if (!program || program.background)
+        return false;
+      const fn = core.functions.find((fn) => fn.id === program.entry);
+      return fn && accessedStorage(fn, core).has(root.id);
+    }));
+    if (owners.length !== 1) {
+      report(`Continuation owner ${scope.instance} must belong to exactly one caller task.`, root.span);
+      continue;
+    }
+    deployment = {
+      tasks: deployment.tasks.map((task) => task.name === owners[0].name ? { ...task, programs: [...task.programs, continuation.name] } : task)
+    };
+  }
+  const http = new Map;
+  for (const block of core.blocks)
+    if (block.runtime?.kind === "http" || block.runtime?.kind === "rpc") {
+      try {
+        validateHttpLayout(block, new Map(core.types.map((type) => [type.id, type])));
+        http.set(block.id, block.runtime.kind === "rpc" ? {
+          transport: "opcua",
+          host: "",
+          port: 0,
+          authority: "",
+          path: block.runtime.path,
+          token: "",
+          timeoutMs: options.http.timeoutMs,
+          tls: false
+        } : resolveHttpEndpoint(block.runtime.url, options.http));
+      } catch (cause) {
+        report(cause instanceof Error ? cause.message : String(cause), block.span);
+      }
+    }
+  const storageBindings = validateIo(core, options, report);
+  validateTasks(core, deployment, report);
+  validateStorage(core, options, report);
+  validateConstants(core, report);
+  const { publication, errors } = resolvePublication(core, options.publish);
+  for (const error of errors)
+    report(error);
+  if (diagnostics.length)
+    return { diagnostics };
+  const plan = Object.freeze({
+    core,
+    deployment: structuredClone(deployment),
+    options: structuredClone(options),
+    storageBindings,
+    publication,
+    http: Object.fromEntries(http),
+    [planned]: true
+  });
+  const freeze = (value) => {
+    if (typeof value !== "object" || value === null || Object.isFrozen(value))
+      return;
+    for (const child of Object.values(value))
+      freeze(child);
+    Object.freeze(value);
+  };
+  freeze(plan.deployment);
+  freeze(plan.options);
+  freeze(plan.storageBindings);
+  freeze(plan.publication);
+  plans.add(plan);
+  return { plan, diagnostics: [] };
+}
+function validateIo(core, options, report) {
+  const types = new Map(core.types.map((type) => [type.id, type]));
+  const targets = [];
+  const names = new Set;
+  for (const item of core.variables.filter((item) => item.storage === "input" || item.storage === "output")) {
+    if (names.has(item.name))
+      report(`Ambiguous I/O name ${item.name}; logical I/O names must be unique.`, item.span);
+    names.add(item.name);
+    const binding = Object.hasOwn(options.io, item.name) ? options.io[item.name] : undefined;
+    if (!binding) {
+      report(`Missing I/O binding for ${item.name}.`, item.span);
+      continue;
+    }
+    targets.push({
+      name: item.name,
+      binding,
+      type: types.get(item.type),
+      region: item.storage === "input" ? "I" : "Q",
+      span: item.span
+    });
+  }
+  const scheduled = new Set;
+  for (const program of core.programs) {
+    const fn = core.functions.find((item) => item.id === program.entry);
+    for (const id of accessedStorage(fn, core))
+      scheduled.add(id);
+  }
+  const storageBindings = [];
+  for (const [name, binding] of Object.entries(options.io)) {
+    if (names.has(name))
+      continue;
+    if (!isStoragePath(name)) {
+      report(`Unknown I/O binding ${name}.`);
+      continue;
+    }
+    const resolved = resolveStoragePath(core, name);
+    if ("error" in resolved) {
+      report(resolved.error);
+      continue;
+    }
+    const overlapping = storageBindings.find((other) => nested(other, resolved));
+    if (overlapping)
+      report(`${name} overlaps the binding ${overlapping.key}.`);
+    if (!scheduled.has(resolved.root.id))
+      report(`${name}: no scheduled program uses ${resolved.root.name}, so it would never be copied.`);
+    storageBindings.push(resolved);
+    targets.push({
+      name,
+      binding,
+      type: resolved.type,
+      region: binding.address[1] === "I" ? "I" : "Q"
+    });
+  }
+  const addresses = [];
+  for (const { name, binding, type, region, span } of targets) {
+    const array = type.kind === "array" ? type : undefined;
+    const element = array ? types.get(array.element) : type;
+    const layout = ioLayout2(iecSpelling(type, types) ?? "");
+    if (binding.type && (!layout || ioLayout2(binding.type) !== layout))
+      report(`I/O type mismatch for ${name}: ${type.id} cannot bind to ${binding.type}.`, span);
+    if (!binding.address.startsWith(`%${region}`))
+      report(`Wrong address region for ${name}: expected %${region}X.`, span);
+    const match = /^%([IQ])([XBWD])([0-9]+)(?:\.([0-7]))?$/.exec(binding.address);
+    if (!match)
+      continue;
+    if (region === "I" && element?.kind === "float")
+      report("Floating logical inputs require an explicit runtime nonfinite policy, which is not supported yet.", span);
+    if (array && element?.kind === "bool")
+      report(`BOOL arrays are not bit-packed in CODESYS I/O; bind each element of ${name} separately.`, span);
+    const size = match[2] === "X" ? 1 : match[2] === "B" ? 8 : match[2] === "W" ? 16 : 32;
+    if (ioBits(element) !== size)
+      report(`Address size does not match ${name}:${type.id}.`, span);
+    const unit = size === 1 ? 8n : BigInt(size);
+    const offset = BigInt(match[3]);
+    const start = offset * unit + BigInt(match[4] ?? 0), end = start + BigInt(size) * BigInt(array?.length ?? 1);
+    if (binding.inverted && (region !== "I" || element?.kind !== "bool" || array))
+      report(`Only a BOOL input can be inverted: ${name}.`, span);
+    if (binding.shared && region !== "I")
+      report(`Only an input can be shared: ${name}.`, span);
+    const collision = addresses.find((address) => address.region === match[1] && address.start < end && start < address.end && !(binding.shared && address.shared && address.start === start && address.end === end));
+    if (collision)
+      report(`Overlapping I/O address ${binding.address} with ${collision.name}.`, span);
+    addresses.push({ region: match[1], start, end, name, shared: binding.shared });
+    if (offset > 0x7fffffffn)
+      report(`I/O offset is too large: ${binding.address}.`, span);
+  }
+  return storageBindings;
+}
+function nested(left, right) {
+  return left.root.id === right.root.id && left.segments.every((a, index) => {
+    const b = right.segments[index];
+    if (!b)
+      return true;
+    return a.kind === "field" ? b.kind === "field" && a.name === b.name : b.kind === "index" && a.value === b.value;
+  });
+}
+function ioBits(type) {
+  if (type?.kind === "bool")
+    return 1;
+  return type && "bits" in type ? type.bits : 0;
+}
+function validateTasks(core, deployment, report) {
+  const programs = new Map(core.programs.map((program) => [program.name, program]));
+  const assignment = new Map;
+  const taskNames = new Set;
+  const stateOwners = new Map;
+  const globals = new Map(core.variables.map((item) => [item.id, item]));
+  const functions = new Map(core.functions.map((item) => [item.id, item]));
+  const blockRuntimes = new Map(core.types.flatMap((type) => type.kind === "block" ? [[type.id, core.blocks.find((block) => block.id === type.block)?.runtime?.kind]] : []));
+  for (const task of deployment.tasks) {
+    if (!isIecIdentifier(task.name))
+      report(`Invalid task name ${task.name}.`);
+    if (taskNames.has(task.name.toUpperCase()))
+      report(`Duplicate task name ${task.name}.`);
+    taskNames.add(task.name.toUpperCase());
+    if (!Number.isInteger(task.priority) || task.priority < 0 || task.priority > 31)
+      report(`Task ${task.name} priority must be 0..31.`);
+    if (!/^[1-9][0-9]*$/.test(task.intervalNanoseconds))
+      report(`Invalid task interval for ${task.name}.`);
+    else {
+      const ns = BigInt(task.intervalNanoseconds);
+      if (ns % 1000000n || ns > 4294967295000000n)
+        report(`Task ${task.name} requires an exact positive TIME interval in milliseconds.`);
+    }
+    if (!task.programs.length)
+      report(`Task ${task.name} has no programs.`);
+    for (const name of task.programs) {
+      const program = programs.get(name);
+      if (!program) {
+        report(`Unknown task program ${name}.`);
+        continue;
+      }
+      if (assignment.has(name))
+        report(`Program ${name} must belong to exactly one task.`);
+      assignment.set(name, task.name);
+      const fn = functions.get(program.entry);
+      if (!fn)
+        throw new Error("Verified core has a missing entry.");
+      const host = program.background && core.variables.find((item) => item.name === program.background?.worker && item.span.file === fn.span.file && blockRuntimes.get(item.type) === "backgroundHost");
+      for (const id of accessedStorage(fn, core, host ? host.id : undefined)) {
+        const item = globals.get(id);
+        if (!item || item.storage === "constant")
+          continue;
+        if (blockRuntimes.get(item.type) === "mailbox")
+          continue;
+        const ownsWorker = program.background?.worker === item.name && item.span.file === fn.span.file;
+        if (program.background && (!ownsWorker || item.id === host?.id))
+          report(`Background task ${program.name} accesses scan-owned storage ${item.name}; pass value snapshots through the mailbox.`, item.span);
+        const owner = stateOwners.get(id);
+        if (owner && owner !== task.name)
+          report(`Storage ${item.name} is shared across cyclic tasks ${owner} and ${task.name}.`, item.span);
+        stateOwners.set(id, task.name);
+      }
+    }
+  }
+  for (const name of programs.keys())
+    if (!assignment.has(name))
+      report(`Program ${name} has no cyclic task.`);
+}
+function validateStorage(core, options, report) {
+  const programs = new Map(core.programs.map((program) => [program.name, program]));
+  if (core.blocks.some((block) => block.standard === "Blinker")) {
+    for (const target of Object.values(options.programNames ?? {})) {
+      if (target.toUpperCase() === "UTIL")
+        report(`IEC object name ${target} shadows the Util library namespace required by Blinker.`);
+    }
+  }
+  const explicitNames = new Set;
+  for (const [name, target] of Object.entries(options.programNames ?? {})) {
+    if (!programs.has(name))
+      report(`Unknown program name override ${name}.`);
+    if (explicitNames.has(target.toUpperCase()))
+      report(`Duplicate IEC program name ${target}.`);
+    explicitNames.add(target.toUpperCase());
+  }
+  const types = new Map(core.types.map((type) => [type.id, type]));
+  const blocks = new Map(core.blocks.map((block) => [block.id, block]));
+  const blockHasInOut = (id) => {
+    const block = blocks.get(id);
+    return block.inputs.some((input) => input.mode === "inOut") || block.state.some((field) => {
+      const type = instancedBlock3(field.type, types);
+      return type !== undefined && blockHasInOut(type.block);
+    });
+  };
+  const layout = storageLayout(core);
+  for (const block of core.blocks)
+    if (layout.retainedBlocks.has(block.id) && blockHasInOut(block.id))
+      report("Retained function blocks cannot contain direct or nested InOut references.", block.span);
+  for (const variable of core.variables) {
+    const type = instancedBlock3(variable.type, types);
+    if (variable.retain && type && blockHasInOut(type.block))
+      report("Retained function blocks cannot contain direct or nested InOut references.", variable.span);
+  }
+}
+function validateConstants(core, report) {
+  const types = new Map(core.types.map((type) => [type.id, type]));
+  const constant = (value, id, span) => {
+    const type = types.get(id);
+    if (type.kind === "string" && value.kind === "string") {
+      if (type.encoding === "utf8" && [...value.value].some((character) => character.charCodeAt(0) === 0 || character.charCodeAt(0) > 127))
+        report("Non-ASCII STRING literals require a verified project-wide UTF8 setting; this profile supports ASCII literals.", span);
+      if (type.encoding === "utf16" && /[\uD800-\uDFFF]/.test(value.value))
+        report("CODESYS WSTRING uses UCS-2 and cannot represent surrogate code units.", span);
+    }
+    if (type.kind === "array" && value.kind === "array")
+      for (const item of value.items)
+        constant(item, type.element, span);
+    if (type.kind === "record" && value.kind === "record")
+      for (const field of type.fields)
+        constant(value.fields[field.name], field.type, span);
+  };
+  const constantsInPath = (path = []) => {
+    for (const segment of path)
+      if (segment.kind === "index")
+        constantsInExpression(segment.value);
+  };
+  const constantsInExpression = (value) => {
+    if (value.kind === "constant")
+      constant(value.value, value.type, value.span);
+    if (value.kind === "load")
+      constantsInPath(value.path);
+    if (value.kind === "borrow")
+      constantsInPath(value.place.path);
+    if (value.kind === "unary" || value.kind === "convert")
+      constantsInExpression(value.operand);
+    if (value.kind === "binary") {
+      constantsInExpression(value.left);
+      constantsInExpression(value.right);
+    }
+  };
+  const constantsInBody = (items) => {
+    for (const item of items) {
+      if (item.kind === "assign") {
+        constantsInExpression(item.value);
+        constantsInPath(item.path);
+      }
+      if (item.kind === "if") {
+        constantsInExpression(item.condition);
+        constantsInBody(item.then);
+        constantsInBody(item.else);
+      }
+      if (item.kind === "switch") {
+        constantsInExpression(item.value);
+        item.cases.forEach((branch) => {
+          for (const value of branch.values)
+            constant(value, item.value.type, item.span);
+          constantsInBody(branch.body);
+        });
+        constantsInBody(item.fallback);
+      }
+      if (item.kind === "for")
+        constantsInBody(item.body);
+      if (item.kind === "invoke") {
+        if (item.index)
+          constantsInExpression(item.index);
+        item.arguments.forEach(constantsInExpression);
+      }
+      if (item.kind === "blockUpdate") {
+        if (item.index)
+          constantsInExpression(item.index);
+        Object.values(item.inputs).forEach(constantsInExpression);
+      }
+      if (item.kind === "return" && item.value)
+        constantsInExpression(item.value);
+    }
+  };
+  core.variables.forEach((variable) => {
+    if (variable.initial)
+      constant(variable.initial, variable.type, variable.span);
+  });
+  for (const fn of core.functions)
+    constantsInBody(fn.body);
+  core.blocks.forEach((block) => {
+    [...block.outputs, ...block.state, ...block.locals].forEach((variable) => {
+      if (variable.initial)
+        constant(variable.initial, variable.type, variable.span);
+    });
+    constantsInBody(block.body);
+  });
+}
+
+// packages/compiler/backends/codesys/types.ts
+import { instancedBlock as instancedBlock4 } from "@tsplc/compiler/ir";
+class CodesysTypes {
+  types;
+  objects = [];
+  names = new Map;
+  fields = new Map;
+  constructor(types, names, blockNames) {
+    this.types = types;
+    for (const type of types.values()) {
+      if (type.kind === "block") {
+        const name = blockNames.get(type.block);
+        if (!name)
+          throw new Error("Missing verified block name");
+        this.names.set(type.id, name);
+      }
+      if (["record", "array", "enum", "string"].includes(type.kind)) {
+        const label = type.id.split(":").at(-1);
+        if (type.kind === "record" || type.kind === "enum") {
+          const prefix = type.kind === "record" ? "ST" : "E";
+          this.names.set(type.id, names.allocateObject(prefix, label));
+        } else
+          this.names.set(type.id, names.allocate(`T_${label}`));
+      }
+      if (type.kind === "record" || type.kind === "enum") {
+        const names = new Names, fields = new Map;
+        for (const member of type.kind === "record" ? type.fields : type.members) {
+          fields.set(member.name, names.allocate(member.name, true));
+        }
+        this.fields.set(type.id, fields);
+      }
+    }
+    for (const type of types.values())
+      if (type.kind === "array" && instancedBlock4(type.id, types))
+        this.names.set(type.id, `ARRAY[${type.lowerBound}..${type.lowerBound + type.length - 1}] OF ${this.name(type.element)}`);
+    const emitted = new Set;
+    const emit = (type) => {
+      if (instancedBlock4(type.id, types) || !this.names.has(type.id) || emitted.has(type.id))
+        return;
+      if (type.kind === "array")
+        emit(this.type(type.element));
+      if (type.kind === "record") {
+        for (const field of type.fields)
+          emit(this.type(field.type));
+      }
+      emitted.add(type.id);
+      const name = this.name(type.id);
+      let declaration;
+      if (type.kind === "record") {
+        const fields = type.fields.map((field) => `    ${this.field(type.id, field.name)} : ${this.name(field.type)};`).join(`
+`);
+        declaration = `TYPE ${name} :
+STRUCT
+${fields}
+END_STRUCT
+END_TYPE
+`;
+      } else if (type.kind === "array") {
+        declaration = `TYPE ${name} : ARRAY[${type.lowerBound}..${type.lowerBound + type.length - 1}] OF ${this.name(type.element)};
+END_TYPE
+`;
+      } else if (type.kind === "string") {
+        declaration = `TYPE ${name} : ${type.encoding === "utf8" ? "STRING" : "WSTRING"}(${type.capacity});
+END_TYPE
+`;
+      } else if (type.kind === "enum") {
+        const members = type.members.map((member) => `    ${this.field(type.id, member.name)} := ${member.value}`).join(`,
+`);
+        declaration = `{attribute 'qualified_only'}
+{attribute 'strict'}
+TYPE ${name} : (
+${members}
+) DINT;
+END_TYPE
+`;
+      } else
+        throw new Error("Unsupported verified data type");
+      this.objects.push({ id: type.id, kind: "dataType", name, declaration });
+    };
+    for (const type of types.values())
+      emit(type);
+  }
+  type(id) {
+    const type = this.types.get(id);
+    if (!type)
+      throw new Error("Missing verified type");
+    return type;
+  }
+  name(id) {
+    return this.names.get(id) ?? id;
+  }
+  field(id, name) {
+    const field = this.fields.get(id)?.get(name);
+    if (!field)
+      throw new Error("Missing verified field");
+    return field;
+  }
+  declarationInitializer(value, id) {
+    const type = this.type(id);
+    if ((type.kind === "record" || type.kind === "array") && this.isZero(value))
+      return "";
+    return ` := ${this.literal(value, id)}`;
+  }
+  isZero(value) {
+    if (value.kind === "bool")
+      return !value.value;
+    if (value.kind === "integer")
+      return value.value === "0";
+    if (value.kind === "float")
+      return Object.is(value.value, 0);
+    if (value.kind === "string")
+      return value.value === "";
+    if (value.kind === "array")
+      return value.items.every((item) => this.isZero(item));
+    if (value.kind === "record")
+      return Object.values(value.fields).every((item) => this.isZero(item));
+    return false;
+  }
+  literal(value, id) {
+    const type = this.type(id);
+    if (type.kind === "enum" && value.kind === "integer") {
+      const member = type.members.find((member) => member.value === value.value);
+      if (!member)
+        throw new Error("Missing verified enum member");
+      return `${this.name(id)}.${this.field(id, member.name)}`;
+    }
+    if (type.kind === "string" && value.kind === "string") {
+      const wide = type.encoding === "utf16", quote = wide ? '"' : "'";
+      let text = "";
+      for (const char of value.value) {
+        const code = char.charCodeAt(0);
+        if (char === "$")
+          text += "$$";
+        else if (char === quote)
+          text += `$${char}`;
+        else if (code < 32 || code === 127)
+          text += `$${code.toString(16).toUpperCase().padStart(wide ? 4 : 2, "0")}`;
+        else
+          text += char;
+      }
+      return `${quote}${text}${quote}`;
+    }
+    if (type.kind === "array" && value.kind === "array") {
+      return `[${value.items.map((item) => this.literal(item, type.element)).join(", ")}]`;
+    }
+    if (type.kind === "record" && value.kind === "record") {
+      const fields = type.fields.map((field) => {
+        const initial = value.fields[field.name];
+        if (!initial)
+          throw new Error("Missing verified record initializer");
+        return `${this.field(id, field.name)} := ${this.literal(initial, field.type)}`;
+      });
+      return `(${fields.join(", ")})`;
+    }
+    if (type.kind === "duration" && value.kind === "duration") {
+      return `T#${BigInt(value.nanoseconds) / 1000000n}ms`;
+    }
+    if (type.kind === "calendar" && value.kind === "calendar") {
+      if (type.domain === "date")
+        return `D#${value.value}`;
+      if (type.domain === "timeOfDay")
+        return `TOD#${value.value}`;
+      return `DT#${value.value.replace("T", "-")}`;
+    }
+    return scalarLiteral(value, id);
+  }
+}
+
+// packages/compiler/backends/codesys/emit.ts
+function required(value) {
+  if (value === undefined)
+    throw new Error("Missing verified CODESYS symbol.");
+  return value;
+}
+function emitCodesys(plan) {
+  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();
+}
+
+class CodesysEmitter {
+  plan;
+  names = new Names;
+  networkName;
+  rpcChannels = [];
+  references = new Map;
+  channels = [];
+  ioMappings = [];
+  objects = [];
+  mappings = [];
+  mailboxLocks = new Map;
+  blockFields = new Map;
+  typeMap;
+  blocks;
+  blockNames;
+  functionNames = new Map;
+  programRoutines = new Set;
+  programResults = new Map;
+  routineScopes = new Map;
+  targetTypes;
+  numeric;
+  layout;
+  constructor(plan) {
+    this.plan = plan;
+    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() {
+    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,
+        declaration: `{attribute 'qualified_only'}
+{attribute 'global_init_slot' := '40000'}
+VAR_GLOBAL
+network:NBS.AsyncProperty := (usiTaskPrio:=15,udiTaskInterval:=1000,tnTaskName:='tsPLC HTTP');
+END_VAR
+`
+      });
+    }
+    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;
+    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) => [...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) + `
+` }, {
+      path: "machines.ts",
+      content: `// Generated explicit read-only machine interfaces. Do not edit.
+export const machines=${JSON.stringify(exposures, null, 2)} as const;
+export const serviceChannels=${JSON.stringify(this.rpcChannels, null, 2)} as const;
+`
+    });
+    return { artifacts, objects, mappings, ioSymbols, ioMappings, publication, diagnostics: [] };
+  }
+  objectPath(object) {
+    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) {
+      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();
+      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}`;
+  }
+  emitGlobals() {
+    const { options } = this.plan;
+    const { layout, names, references, mappings, targetTypes, typeMap, objects } = this;
+    const hasExports = (group) => 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));
+      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 (!instancedBlock5(item.type, typeMap)) {
+          const value = item.initial ?? defaultValue(item.type, typeMap);
+          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(`
+`)}
+`
+      });
+    }
+  }
+  emitIo() {
+    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)};`, "    {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`);
+      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");
+    if (ioLines.length > 4)
+      objects.push({
+        id: "io",
+        kind: "globalList",
+        name: ioName,
+        declaration: `${ioLines.join(`
+`)}
+`
+      });
+  }
+  prepareStatements(items) {
+    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);
+      }
+    }
+  }
+  allocateBlockFields() {
+    const { core } = this.plan;
+    const { objects, functionNames, blockNames, blockFields } = this;
+    for (const block of core.blocks) {
+      const fields = new Names, mapped = new Map;
+      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);
+    }
+  }
+  allocateRoutineScope(fn) {
+    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;
+    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 });
+  }
+  routineHeader(fn, name) {
+    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"}`
+    };
+  }
+  emitRoutine(fn) {
+    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);
+    }
+    const lines = [];
+    const write = (line, depth, source) => {
+      lines.push("    ".repeat(depth) + line);
+      if (source)
+        mappings.push({
+          path: `${mappingName}/implementation.st`,
+          line: lines.length,
+          span: source
+        });
+    };
+    const release = (lock, depth, source) => {
+      write(`WHILE NOT __COMPARE_AND_SWAP(ADR(${lock}), 1, 0) DO`, depth, source);
+      write(";", depth + 1);
+      write("END_WHILE;", depth);
+    };
+    const load = (id) => {
+      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
+    ]));
+    const place = (id, path = []) => {
+      let text = load(id), typeId = required(scopeTypes.get(id));
+      let outputBlock;
+      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") {
+          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) => {
+      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)]);
+    };
+    const assignConstant = (destination, value, id, depth, span) => {
+      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, depth) => {
+      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 = instancedBlock5(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": {
+            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);
+            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) {
+      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, items) => {
+      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 && !instancedBlock5(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(`
+`)}
+`,
+      implementation: `${lines.join(`
+`)}
+`
+    });
+  }
+  emitProgram(program) {
+    const { core, options } = this.plan;
+    const { names, functionNames, objects } = this;
+    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}
+` : `PROGRAM ${name}
+VAR
+    plc_discard : BOOL;
+END_VAR
+`,
+      implementation: `${lines.join(`
+`)}
+`
+    });
+  }
+}
+// packages/compiler/backends/codesys/vendor.ts
+import { CodesysCompilerError } from "@tsplc/build";
+function diagnoseCodesys(cause, bundle) {
+  const notes = [];
+  let current = cause;
+  while (current instanceof Error) {
+    if (current instanceof CodesysCompilerError && current.diagnostics.length) {
+      return current.diagnostics.map((item) => {
+        const location = item.positionText && /^Line ([1-9][0-9]*)(?:, Column ([1-9][0-9]*))? \((Decl|Impl)\)$/.exec(item.positionText);
+        const identity = item.object;
+        let objectPath;
+        if (identity && identity.path.at(-1) === identity.name) {
+          const relative = identity.applicationPath;
+          if (Array.isArray(relative) && relative.length > 0 && relative.every((part) => typeof part === "string") && identity.isApplicationChild === (relative.length === 1) && identity.path.length > relative.length && identity.path.slice(-relative.length).every((part, index) => part === relative[index])) {
+            objectPath = relative.join("/");
+          } else if (relative === undefined && identity.isApplicationChild === true && identity.path.length >= 2) {
+            objectPath = identity.name;
+          }
+        }
+        const objects = objectPath ? bundle.objects.flatMap((object) => {
+          const declaration = object.sourcePath ?? (object.implementation === undefined ? `${object.name}.st` : `${object.name}/declaration.st`);
+          const nativePath = (object.kind === "method" ? declaration.replace(/\/methods\/([^/]+\/declaration\.st)$/, "/$1") : declaration).replace(object.implementation === undefined ? /\.st$/ : /\/declaration\.st$/, "");
+          return object.name === identity?.name && nativePath === objectPath ? [{ object, declaration }] : [];
+        }) : [];
+        const match = objects.length === 1 ? objects[0] : undefined;
+        const section = location?.[3] === "Decl" ? "declaration" : "implementation";
+        const path = section === "declaration" ? match?.declaration : match?.object.implementation !== undefined ? match.declaration.replace(/declaration\.st$/, "implementation.st") : undefined;
+        const mappings = location && path ? bundle.mappings.filter((mapping) => mapping.path === path && mapping.line === Number(location[1])) : [];
+        const mapping = mappings.length === 1 ? mappings[0] : undefined;
+        return {
+          origin: "vendor",
+          code: "PLC8001",
+          severity: "error",
+          message: item.text,
+          ...mapping && { span: mapping.span },
+          notes: [
+            ...notes,
+            ...location && path ? [
+              "Generated ST: " + path + ":" + location[1] + (location[2] ? `:${location[2]}` : "")
+            ] : [],
+            `CODESYS diagnostic: ${JSON.stringify(item)}`
+          ]
+        };
+      });
+    }
+    notes.push(current.message);
+    if (current.cause === undefined)
+      break;
+    current = current.cause;
+    if (!(current instanceof Error))
+      notes.push(String(current));
+  }
+  return [
+    {
+      origin: "vendor",
+      code: "PLC8001",
+      severity: "error",
+      message: cause instanceof Error ? cause.message : String(cause),
+      ...notes.length > 1 && { notes: notes.slice(1) }
+    }
+  ];
+}
+export {
+  buildCodesys,
+  codesys,
+  codesysBuildConfig,
+  diagnoseCodesys,
+  direct,
+  emitCodesys,
+  engineeringBuildSchema,
+  ioTargets,
+  planCodesys,
+  publicationSelectors
+};
+
+//# debugId=0F83E9CDABD60BCF64756E2164756E21
+//# sourceMappingURL=codesys.js.map