@tsplc/compiler 0.0.0-stage → 0.2.0

package/dist/ir.js

@@ -0,0 +1,1888 @@
+// packages/compiler/ir/diagnostics.ts
+function error(code, message, span) {
+  return { origin: "plc", code, severity: "error", message, ...span && { span } };
+}
+function hasErrors(diagnostics) {
+  return diagnostics.some((diagnostic) => diagnostic.severity === "error");
+}
+function formatDiagnostic(diagnostic, source) {
+  const { span } = diagnostic;
+  const location = span ? `${span.file}:${span.line}:${span.column}: ` : "";
+  let result = `${location}${diagnostic.code}: ${diagnostic.message}`;
+  if (source !== undefined && span) {
+    const line = source.split(/\r?\n/)[span.line - 1];
+    if (line !== undefined) {
+      const width = Math.max(1, Math.min(span.end - span.start, line.length - span.column + 2));
+      result += `
+${span.line} | ${line}
+${" ".repeat(String(span.line).length + 3 + span.column - 1)}${"^".repeat(width)}`;
+    }
+  }
+  for (const related of diagnostic.related ?? []) {
+    result += `
+  ${related.span.file}:${related.span.line}:${related.span.column}: ${related.message}`;
+  }
+  for (const note of diagnostic.notes ?? [])
+    result += `
+  ${note}`;
+  return result;
+}
+// packages/compiler/ir/types.ts
+var instancedBlock = (id, types) => {
+  const type = types.get(id);
+  const element = type?.kind === "array" ? types.get(type.element) : type;
+  return element?.kind === "block" ? element : undefined;
+};
+var primitiveTypes = [
+  { id: "BOOL", kind: "bool" },
+  ...[
+    ["SINT", "USINT", "BYTE", 8],
+    ["INT", "UINT", "WORD", 16],
+    ["DINT", "UDINT", "DWORD", 32],
+    ["LINT", "ULINT", "LWORD", 64]
+  ].flatMap(([signed, unsigned, bitstring, bits]) => [
+    { id: signed, kind: "integer", bits, signed: true },
+    { id: unsigned, kind: "integer", bits, signed: false },
+    { id: bitstring, kind: "bits", bits }
+  ]),
+  { id: "REAL", kind: "float", bits: 32 },
+  { id: "LREAL", kind: "float", bits: 64 },
+  { id: "TIME", kind: "duration" },
+  { id: "DATE", kind: "calendar", domain: "date" },
+  { id: "TIME_OF_DAY", kind: "calendar", domain: "timeOfDay" },
+  { id: "DATE_AND_TIME", kind: "calendar", domain: "dateTime" }
+];
+function integerRange(type) {
+  const signed = type.kind === "integer" && type.signed;
+  const limit = 1n << BigInt(type.bits - (signed ? 1 : 0));
+  return signed ? [-limit, limit - 1n] : [0n, limit - 1n];
+}
+// packages/compiler/ir/model.ts
+var comparisonOperators = new Set([
+  "equal",
+  "notEqual",
+  "less",
+  "lessEqual",
+  "greater",
+  "greaterEqual"
+]);
+var timer = (input, output) => ({
+  inputs: [
+    [input, "IN", "BOOL"],
+    ["duration", "PT", "TIME"]
+  ],
+  outputs: [
+    [output, "Q", "BOOL"],
+    ["elapsed", "ET", "TIME"]
+  ]
+});
+var standardBlocks = {
+  OnDelayTimer: { native: "TON", ...timer("enabled", "done") },
+  OffDelayTimer: { native: "TOF", ...timer("enabled", "active") },
+  PulseTimer: { native: "TP", ...timer("start", "active") },
+  RisingEdge: {
+    native: "R_TRIG",
+    inputs: [["signal", "CLK", "BOOL"]],
+    outputs: [["rose", "Q", "BOOL"]]
+  },
+  FallingEdge: {
+    native: "F_TRIG",
+    inputs: [["signal", "CLK", "BOOL"]],
+    outputs: [["fell", "Q", "BOOL"]]
+  },
+  Blinker: {
+    native: "Util.BLINK",
+    inputs: [
+      ["enabled", "ENABLE", "BOOL"],
+      ["offTime", "TIMELOW", "TIME"],
+      ["onTime", "TIMEHIGH", "TIME"]
+    ],
+    outputs: [["on", "OUT", "BOOL"]]
+  }
+};
+// packages/compiler/ir/core-model.ts
+var verified = Symbol("verified core");
+
+// packages/compiler/ir/scalars.ts
+function integerType(type) {
+  return type.kind === "integer" || type.kind === "bits";
+}
+function floatMaximum(type) {
+  return type.bits === 32 ? Math.fround((2 - 2 ** -23) * 2 ** 127) : Number.MAX_VALUE;
+}
+function saturateFloat(value, type) {
+  const maximum = floatMaximum(type);
+  const clipped = value < -maximum ? -maximum : value > maximum ? maximum : value;
+  return type.bits === 32 ? Math.fround(clipped) : clipped;
+}
+function parseInteger(text) {
+  const clean = text.replaceAll("_", "").replace(/n$/, "");
+  const negative = clean.startsWith("-");
+  const unsigned = negative ? clean.slice(1) : clean;
+  if (/^0[xob]/i.test(unsigned))
+    return (negative ? -1n : 1n) * BigInt(unsigned);
+  const match = /^(\d+)(?:\.(\d*))?(?:e([+-]?\d+))?$/i.exec(unsigned);
+  if (!match)
+    throw new Error("Expected an exact integer literal.");
+  const fraction = match[2] ?? "";
+  const exponent = Number(match[3] ?? 0) - fraction.length;
+  if (!Number.isSafeInteger(exponent) || Math.abs(exponent) > 400)
+    throw new Error("Integer literal exponent is out of range.");
+  let value = BigInt(match[1] + fraction);
+  if (exponent >= 0)
+    value *= 10n ** BigInt(exponent);
+  else {
+    const divisor = 10n ** BigInt(-exponent);
+    if (value % divisor)
+      throw new Error("Integer literals cannot have a fractional part.");
+    value /= divisor;
+  }
+  return negative ? -value : value;
+}
+function constantFits(value, type) {
+  if (type.kind === "bool")
+    return value.kind === "bool" && typeof value.value === "boolean";
+  if (integerType(type)) {
+    if (value.kind !== "integer" || !/^(?:0|-?[1-9][0-9]*)$/.test(value.value))
+      return false;
+    const [minimum, maximum] = integerRange(type), number = BigInt(value.value);
+    return number >= minimum && number <= maximum;
+  }
+  if (type.kind === "float")
+    return value.kind === "float" && Number.isFinite(value.value) && (type.bits === 64 || Object.is(Math.fround(value.value), value.value));
+  return false;
+}
+function canAssign(source, destination, value) {
+  if (value) {
+    if (source.kind !== destination.kind || !constantFits(value, destination))
+      return false;
+    if (source.kind === "float" && destination.kind === "float" && source.bits > destination.bits && value.kind === "float")
+      return Object.is(Math.fround(value.value), value.value);
+    return true;
+  }
+  if (source.id === destination.id)
+    return true;
+  if (source.kind === "integer" && destination.kind === "integer") {
+    const [fromMin, fromMax] = integerRange(source), [toMin, toMax] = integerRange(destination);
+    return fromMin >= toMin && fromMax <= toMax;
+  }
+  return source.kind === "float" && destination.kind === "float" && source.bits <= destination.bits;
+}
+function fold(expression, variables, types) {
+  if (expression.kind === "constant")
+    return expression.value;
+  if (expression.kind === "copy")
+    return fold(expression.operand, variables, types);
+  if (expression.kind === "length") {
+    const type = types?.get(expression.operand.type);
+    const receiver = expression.operand.kind === "load" ? variables.get(expression.operand.place.root) : undefined;
+    const pure = expression.operand.kind === "load" && expression.operand.place.path.every((segment) => segment.kind === "field") && Boolean(receiver?.initial || receiver?.storage === "input" || receiver?.storage === "output");
+    if (type?.kind === "array" && (pure || fold(expression.operand, variables, types)))
+      return { kind: "integer", value: String(type.length) };
+    return;
+  }
+  if (expression.kind === "record") {
+    const fields = Object.create(null);
+    for (const [name, operand] of Object.entries(expression.fields)) {
+      const value = fold(operand, variables, types);
+      if (!value)
+        return;
+      fields[name] = value;
+    }
+    return { kind: "record", fields };
+  }
+  if (expression.kind === "array") {
+    const items = expression.items.map((item) => fold(item, variables, types));
+    return items.every((item) => item !== undefined) ? { kind: "array", items } : undefined;
+  }
+  if (expression.kind === "load" && !expression.place.path.length) {
+    const variable = variables.get(expression.place.root);
+    return variable?.storage === "constant" ? variable.initial : undefined;
+  }
+  if (expression.kind === "convert") {
+    const value = fold(expression.operand, variables, types);
+    const target = types?.get(expression.type);
+    if (value?.kind === "integer" && target) {
+      if (integerType(target))
+        return {
+          kind: "integer",
+          value: String(expression.policy === "exact" ? BigInt(value.value) : applyIntegerPolicy(BigInt(value.value), target, expression.policy))
+        };
+      if (target.kind === "float")
+        return {
+          kind: "float",
+          value: target.bits === 32 ? Math.fround(Number(value.value)) : Number(value.value)
+        };
+    }
+    if (value?.kind === "float" && target?.kind === "float")
+      return {
+        kind: "float",
+        value: expression.policy === "saturate" ? saturateFloat(value.value, target) : target.bits === 32 ? Math.fround(value.value) : value.value
+      };
+    return;
+  }
+  if (expression.kind === "unary") {
+    const value = fold(expression.operand, variables, types);
+    if (value?.kind === "duration" && expression.operator === "timeToMilliseconds")
+      return { kind: "integer", value: String(BigInt(value.nanoseconds) / 1000000n) };
+    if (value?.kind === "bool" && expression.operator === "not")
+      return { kind: "bool", value: !value.value };
+    if (value?.kind === "integer" && expression.operator === "bitNot") {
+      const target = types?.get(expression.type);
+      if (target?.kind === "bits")
+        return {
+          kind: "integer",
+          value: String(applyIntegerPolicy(~BigInt(value.value), target, "wrap"))
+        };
+    }
+    if (value?.kind === "integer" && expression.operator === "negate")
+      return { kind: "integer", value: String(-BigInt(value.value)) };
+    if (value?.kind === "float" && expression.operator === "negate")
+      return { kind: "float", value: -value.value };
+  }
+  if (expression.kind === "binary") {
+    const left = fold(expression.left, variables, types), right = fold(expression.right, variables, types);
+    if (!left || !right || left.kind !== right.kind)
+      return;
+    if (left.kind === "bool" && right.kind === "bool") {
+      if (expression.operator === "and")
+        return { kind: "bool", value: left.value && right.value };
+      if (expression.operator === "or")
+        return { kind: "bool", value: left.value || right.value };
+      if (expression.operator === "equal")
+        return { kind: "bool", value: left.value === right.value };
+      if (expression.operator === "notEqual")
+        return { kind: "bool", value: left.value !== right.value };
+    }
+    if (left.kind === "integer" && right.kind === "integer" || left.kind === "float" && right.kind === "float" || left.kind === "duration" && right.kind === "duration" || left.kind === "calendar" && right.kind === "calendar" || left.kind === "string" && right.kind === "string") {
+      const a = left.kind === "integer" ? BigInt(left.value) : left.kind === "duration" ? BigInt(left.nanoseconds) : left.value;
+      const b = right.kind === "integer" ? BigInt(right.value) : right.kind === "duration" ? BigInt(right.nanoseconds) : right.value;
+      switch (expression.operator) {
+        case "equal":
+          return { kind: "bool", value: a === b };
+        case "notEqual":
+          return { kind: "bool", value: a !== b };
+        case "less":
+          return { kind: "bool", value: a < b };
+        case "lessEqual":
+          return { kind: "bool", value: a <= b };
+        case "greater":
+          return { kind: "bool", value: a > b };
+        case "greaterEqual":
+          return { kind: "bool", value: a >= b };
+      }
+      if (left.kind !== "integer" && left.kind !== "float")
+        return;
+      if (typeof a === "bigint" && typeof b === "bigint") {
+        let value;
+        switch (expression.operator) {
+          case "add":
+            value = a + b;
+            break;
+          case "subtract":
+            value = a - b;
+            break;
+          case "multiply":
+            value = a * b;
+            break;
+          case "divide":
+            if (b === 0n)
+              return;
+            value = a / b;
+            break;
+          case "remainder":
+            if (b === 0n)
+              return;
+            value = a % b;
+            break;
+          case "bitAnd":
+            value = a & b;
+            break;
+          case "bitOr":
+            value = a | b;
+            break;
+          case "bitXor":
+            value = a ^ b;
+            break;
+          case "shiftLeft":
+            if (b < 0n || b > 63n)
+              return;
+            value = a << b;
+            break;
+          case "shiftRight":
+            if (b < 0n || b > 63n)
+              return;
+            value = a >> b;
+            break;
+          default:
+            return;
+        }
+        const target = types?.get(expression.type);
+        if (target && integerType(target) && (expression.policy || target.kind === "bits"))
+          value = applyIntegerPolicy(value, target, expression.policy ?? "wrap");
+        return { kind: "integer", value: String(value) };
+      }
+      if (typeof a === "number" && typeof b === "number") {
+        let value;
+        switch (expression.operator) {
+          case "add":
+            value = a + b;
+            break;
+          case "subtract":
+            value = a - b;
+            break;
+          case "multiply":
+            value = a * b;
+            break;
+          case "divide":
+            value = a / b;
+            break;
+          case "remainder":
+            value = a % b;
+            break;
+          default:
+            return;
+        }
+        return {
+          kind: "float",
+          value: types?.get(expression.type)?.kind === "float" && expression.type === "REAL" ? Math.fround(value) : value
+        };
+      }
+    }
+  }
+  return;
+}
+function interval(expression, types, variables, ranges = new Map) {
+  if (expression.kind === "length") {
+    const array = types.get(expression.operand.type);
+    if (array?.kind === "array")
+      return [BigInt(array.length), BigInt(array.length)];
+  }
+  const value = fold(expression, variables, types);
+  if (value?.kind === "integer")
+    return [BigInt(value.value), BigInt(value.value)];
+  const type = types.get(expression.type);
+  if (!type || !integerType(type))
+    return;
+  if (expression.kind === "load")
+    return ranges.get(expression.place.root) ?? integerRange(type);
+  if (expression.kind === "convert")
+    return expression.policy === "exact" ? interval(expression.operand, types, variables, ranges) : integerRange(type);
+  if (expression.kind === "unary" && expression.operator === "negate") {
+    const operand = interval(expression.operand, types, variables, ranges);
+    return operand && [-operand[1], -operand[0]];
+  }
+  if (expression.kind === "binary" && !expression.policy) {
+    const a = interval(expression.left, types, variables, ranges), b = interval(expression.right, types, variables, ranges);
+    if (!a || !b)
+      return;
+    const [minimum, maximum] = integerRange(type);
+    const unwrapped = (low, high) => low < minimum || high > maximum ? [minimum, maximum] : [low, high];
+    switch (expression.operator) {
+      case "add":
+        return unwrapped(a[0] + b[0], a[1] + b[1]);
+      case "subtract":
+        return unwrapped(a[0] - b[1], a[1] - b[0]);
+      case "multiply": {
+        const values = [a[0] * b[0], a[0] * b[1], a[1] * b[0], a[1] * b[1]];
+        return unwrapped(values.reduce((x, y) => x < y ? x : y), values.reduce((x, y) => x > y ? x : y));
+      }
+      case "divide": {
+        if (b[0] <= 0n && b[1] >= 0n)
+          return;
+        const values = [a[0] / b[0], a[0] / b[1], a[1] / b[0], a[1] / b[1]];
+        return [values.reduce((x, y) => x < y ? x : y), values.reduce((x, y) => x > y ? x : y)];
+      }
+      case "remainder": {
+        if (b[0] <= 0n && b[1] >= 0n)
+          return;
+        const maximum = [b[0], b[1]].map((n) => n < 0n ? -n : n).reduce((x, y) => x > y ? x : y) - 1n;
+        return [a[0] < 0n ? -maximum : 0n, a[1] > 0n ? maximum : 0n];
+      }
+    }
+  }
+  return integerRange(type);
+}
+function loopIterations(first, last, step) {
+  if (step > 0n)
+    return last >= first ? (last - first) / step + 1n : 0n;
+  return last <= first ? (first - last) / -step + 1n : 0n;
+}
+function loopBounds(start, limit, step, exclusive = false) {
+  const first = step > 0n ? start[0] : start[1];
+  const last = step > 0n ? limit[1] - (exclusive ? 1n : 0n) : limit[0] + (exclusive ? 1n : 0n);
+  const count = loopIterations(first, last, step);
+  const range = first <= last ? [first, last] : [last, first];
+  return { first, last, count, range };
+}
+function narrowRanges(condition, truth, types, variables, ranges) {
+  const narrowed = new Map(ranges);
+  if (condition.kind !== "binary")
+    return narrowed;
+  if (condition.operator === "and")
+    return truth ? narrowRanges(condition.right, truth, types, variables, narrowRanges(condition.left, truth, types, variables, ranges)) : narrowed;
+  if (condition.left.kind !== "load" || condition.left.place.path.length)
+    return narrowed;
+  const root = condition.left.place.root, variable = variables.get(root), type = types.get(condition.left.type), fixed = variable && (variable.storage === "parameter" && !variable.mode || variable.storage === "local" && !variable.mutable), current = ranges.get(root) ?? (fixed && type && integerType(type) ? integerRange(type) : undefined), bound = interval(condition.right, types, variables, ranges);
+  if (!current || !bound || bound[0] !== bound[1])
+    return narrowed;
+  const value = bound[0];
+  let lower = current[0], upper = current[1];
+  switch (condition.operator) {
+    case "less":
+      if (truth)
+        upper = value - 1n < upper ? value - 1n : upper;
+      else
+        lower = value > lower ? value : lower;
+      break;
+    case "lessEqual":
+      if (truth)
+        upper = value < upper ? value : upper;
+      else
+        lower = value + 1n > lower ? value + 1n : lower;
+      break;
+    case "greater":
+      if (truth)
+        lower = value + 1n > lower ? value + 1n : lower;
+      else
+        upper = value < upper ? value : upper;
+      break;
+    case "greaterEqual":
+      if (truth)
+        lower = value > lower ? value : lower;
+      else
+        upper = value - 1n < upper ? value - 1n : upper;
+      break;
+  }
+  if (lower <= upper)
+    narrowed.set(root, [lower, upper]);
+  return narrowed;
+}
+function wrapsNatively(expression) {
+  return expression.kind === "binary" && !expression.policy && (expression.operator === "add" || expression.operator === "subtract" || expression.operator === "multiply");
+}
+var lowest = (a, b) => a < b ? a : b;
+var highest = (a, b) => a > b ? a : b;
+function valueRange(expression, types, variables, ranges, functions) {
+  if (expression.kind !== "call")
+    return interval(expression, types, variables, ranges);
+  const helper = functions.get(expression.function)?.bounds;
+  return helper && mathHelperRange(helper, expression.arguments.map((argument) => valueRange(argument, types, variables, ranges, functions)));
+}
+function mathHelperRange(helper, [first, second, third]) {
+  if (!first || !second)
+    return;
+  if (helper === "min")
+    return [lowest(first[0], second[0]), lowest(first[1], second[1])];
+  if (helper === "max")
+    return [highest(first[0], second[0]), highest(first[1], second[1])];
+  if (!third)
+    return;
+  return [lowest(second[0], third[0]), highest(second[1], third[1])];
+}
+function applyIntegerPolicy(value, type, policy) {
+  const [minimum, maximum] = integerRange(type);
+  if (policy === "saturate")
+    return value < minimum ? minimum : value > maximum ? maximum : value;
+  return type.kind === "integer" && type.signed ? BigInt.asIntN(type.bits, value) : BigInt.asUintN(type.bits, value);
+}
+function scalarIssue(expression, types, variables, ranges = new Map) {
+  const type = types.get(expression.type);
+  if (!type || !["bool", "integer", "bits", "float"].includes(type.kind))
+    return "Unknown scalar expression type.";
+  if (expression.kind === "constant")
+    return constantFits(expression.value, type) ? undefined : "Literal is outside its PLC type or has the wrong domain.";
+  if (expression.kind === "load" || expression.kind === "call")
+    return;
+  if ("operand" in expression && !types.has(expression.operand.type) || "left" in expression && (!types.has(expression.left.type) || !types.has(expression.right.type)))
+    return "Unknown operand type.";
+  const operand = (value) => types.get(value.type);
+  if (expression.kind === "convert") {
+    if (!["exact", "wrap", "saturate"].includes(expression.policy))
+      return "Unknown numeric conversion policy.";
+    const source = operand(expression.operand), value = fold(expression.operand, variables, types);
+    if (source.kind === "bool" || type.kind === "bool")
+      return "Numeric conversions cannot use BOOL.";
+    if (expression.policy === "exact") {
+      if (canAssign(source, type, value) || value && integerType(source) && integerType(type) && constantFits(value, type))
+        return;
+      if (integerType(source) && type.kind === "float") {
+        if (value?.kind === "integer") {
+          const converted = type.bits === 32 ? Math.fround(Number(value.value)) : Number(value.value);
+          if (Number.isFinite(converted) && Number.isInteger(converted) && BigInt(converted) === BigInt(value.value))
+            return;
+        }
+        const [minimum, maximum] = interval(expression.operand, types, variables, ranges) ?? integerRange(source);
+        const limit = 1n << BigInt(type.bits === 32 ? 24 : 53);
+        if (minimum >= -limit && maximum <= limit)
+          return;
+      }
+      if (integerType(source) && integerType(type)) {
+        const [fromMin, fromMax] = interval(expression.operand, types, variables, ranges) ?? integerRange(source), [toMin, toMax] = integerRange(type);
+        if (fromMin >= toMin && fromMax <= toMax)
+          return;
+      }
+      return "Exact conversion cannot be proved lossless.";
+    }
+    if (expression.policy === "saturate" && source.kind === "float" && type.kind === "float")
+      return;
+    return integerType(source) && integerType(type) ? undefined : expression.policy === "saturate" ? "Saturate conversions require two integer/bit-string operands or two floating operands." : "Wrap conversions require integer or bit-string operands.";
+  }
+  if (expression.kind === "unary") {
+    const source = operand(expression.operand);
+    if (expression.operator === "clock")
+      return type.id === "DINT" ? undefined : "now() returns DINT milliseconds.";
+    if (expression.operator === "timeToMilliseconds")
+      return source.id === "TIME" && source.kind === "duration" && type.id === "UDINT" ? undefined : "timeToMilliseconds requires TIME and returns UDINT.";
+    if (expression.operator === "not")
+      return type.kind === "bool" && source.kind === "bool" ? undefined : "Logical negation requires BOOL.";
+    if (expression.operator === "bitNot")
+      return type.kind === "bits" && source.id === type.id ? undefined : "Bitwise complement requires a bit string.";
+    if (source.id !== type.id || !(type.kind === "integer" || type.kind === "float"))
+      return "Numeric negation requires one arithmetic type.";
+  } else if (expression.kind === "binary") {
+    const left = operand(expression.left), right = operand(expression.right);
+    if (expression.operator === "and" || expression.operator === "or")
+      return type.kind === "bool" && left.kind === "bool" && right.kind === "bool" ? undefined : "Logical operators require BOOL.";
+    if (comparisonOperators.has(expression.operator))
+      return type.kind === "bool" && left.id === right.id && ["bool", "integer", "bits", "float"].includes(left.kind) && (left.kind !== "bool" || ["equal", "notEqual"].includes(expression.operator)) ? undefined : "Comparison operands need the same PLC domain.";
+    if (["bitAnd", "bitOr", "bitXor", "shiftLeft", "shiftRight"].includes(expression.operator)) {
+      if (type.kind !== "bits" || left.id !== type.id)
+        return "Bitwise operators require bit strings.";
+      if (expression.operator === "shiftLeft" || expression.operator === "shiftRight") {
+        const count = fold(expression.right, variables, types);
+        return count?.kind === "integer" && BigInt(count.value) >= 0n && BigInt(count.value) < BigInt(type.bits) ? undefined : "Shift count must be a compile-time integer within the bit width.";
+      }
+      return right.id === type.id ? undefined : "Bit-string widths differ.";
+    }
+    if (left.id !== type.id || right.id !== type.id || type.kind !== "integer" && type.kind !== "float")
+      return "Arithmetic operands need one integer or floating type.";
+    if (expression.policy)
+      return type.kind === "integer" && ["add", "subtract", "multiply"].includes(expression.operator) ? undefined : "Explicit arithmetic policies require integer addition, subtraction or multiplication.";
+    if ((expression.operator === "divide" || expression.operator === "remainder") && type.kind === "integer") {
+      const divisor = interval(expression.right, types, variables, ranges);
+      if (!divisor || divisor[0] <= 0n && divisor[1] >= 0n)
+        return "Division requires a proved nonzero divisor.";
+      const dividend = interval(expression.left, types, variables, ranges);
+      const [minimum] = integerRange(type);
+      if (type.signed && dividend && dividend[0] <= minimum && divisor[0] <= -1n && divisor[1] >= -1n)
+        return "Signed minimum divided by -1 cannot be represented.";
+    }
+  } else
+    return "Expression has not been reduced to a scalar operation.";
+  if (integerType(type)) {
+    const result = interval(expression, types, variables, ranges), [minimum, maximum] = integerRange(type);
+    if (!(wrapsNatively(expression) && !fold(expression, variables, types)) && (!result || result[0] < minimum || result[1] > maximum))
+      return "Arithmetic may overflow; widen the result or use an explicit wrap/saturate operation.";
+  } else if (type.kind === "float") {
+    const result = fold(expression, variables, types);
+    if (result)
+      return constantFits(result, type) ? undefined : "Floating result is not finite or representable.";
+    if (expression.kind === "binary") {
+      const lhs = fold(expression.left, variables, types);
+      const rhs = fold(expression.right, variables, types);
+      if (["add", "subtract"].includes(expression.operator) && (lhs?.kind === "float" || rhs?.kind === "float")) {
+        const maximum = floatMaximum(type);
+        const finite = [-maximum, maximum].every((endpoint) => {
+          const a = lhs?.kind === "float" ? lhs.value : endpoint;
+          const b = rhs?.kind === "float" ? rhs.value : endpoint;
+          const value = expression.operator === "add" ? a + b : a - b;
+          return Number.isFinite(type.bits === 32 ? Math.fround(value) : value);
+        });
+        if (finite)
+          return;
+      }
+      if (rhs?.kind === "float" && rhs.value === 1 && ["multiply", "divide"].includes(expression.operator))
+        return;
+    } else if (expression.kind === "unary")
+      return;
+    return "Floating arithmetic must prove a finite result.";
+  }
+  return;
+}
+
+// packages/compiler/ir/domains.ts
+function durationLiteral(text, scaleNanoseconds) {
+  const clean = text.replaceAll("_", "").replace(/^(-?)\./, (_, sign) => `${sign}0.`);
+  const match = /^(-?)(\d+)(?:\.(\d*))?(?:e([+-]?\d+))?$/i.exec(clean);
+  if (!match)
+    return;
+  const fraction = match[3] ?? "", exponent = Number(match[4] ?? 0) - fraction.length;
+  if (!Number.isSafeInteger(exponent) || Math.abs(exponent) > 400)
+    return;
+  let value = BigInt(match[2] + fraction) * scaleNanoseconds;
+  if (exponent >= 0)
+    value *= 10n ** BigInt(exponent);
+  else {
+    const divisor = 10n ** BigInt(-exponent);
+    if (value % divisor)
+      return;
+    value /= divisor;
+  }
+  if (match[1])
+    value = -value;
+  return validDuration(value) ? { kind: "duration", nanoseconds: String(value) } : undefined;
+}
+function validDuration(nanoseconds) {
+  return nanoseconds >= 0n && nanoseconds <= 4294967295000000n && nanoseconds % 1000000n === 0n;
+}
+function validDate(text) {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(text);
+  if (!match)
+    return false;
+  const year = Number(match[1]), month = Number(match[2]), day = Number(match[3]);
+  const leap = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+  const length = [31, leap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][month - 1];
+  return Boolean(length && day >= 1 && day <= length && text >= "1970-01-01" && text <= "2106-02-07");
+}
+function validClock(text, milliseconds) {
+  const match = (milliseconds ? /^(\d{2}):(\d{2}):(\d{2})\.(\d{3})$/ : /^(\d{2}):(\d{2}):(\d{2})$/).exec(text);
+  return Boolean(match && Number(match[1]) < 24 && Number(match[2]) < 60 && Number(match[3]) < 60);
+}
+function calendarLiteral(domain, text) {
+  if (domain === "date")
+    return validDate(text) ? { kind: "calendar", value: text } : undefined;
+  if (domain === "timeOfDay") {
+    const canonical = /^\d{2}:\d{2}:\d{2}$/.test(text) ? `${text}.000` : text;
+    return validClock(canonical, true) ? { kind: "calendar", value: canonical } : undefined;
+  }
+  return text.length === 19 && text[10] === "T" && validDate(text.slice(0, 10)) && validClock(text.slice(11), false) && text <= "2106-02-07T06:28:15" ? { kind: "calendar", value: text } : undefined;
+}
+function domainConstantFits(value, type) {
+  if (type.kind === "duration")
+    return value.kind === "duration" && /^(?:0|[1-9][0-9]*)$/.test(value.nanoseconds) && validDuration(BigInt(value.nanoseconds));
+  if (type.kind === "calendar" && value.kind === "calendar") {
+    const parsed = calendarLiteral(type.domain, value.value);
+    return parsed?.kind === "calendar" && parsed.value === value.value;
+  }
+  return false;
+}
+function domainIssue(value, types) {
+  const type = types.get(value.type);
+  if (value.kind === "constant")
+    return type && domainConstantFits(value.value, type) ? undefined : "Invalid TIME/calendar constant.";
+  if (value.kind === "load" || value.kind === "call" || value.kind === "conditional")
+    return;
+  if (value.kind === "binary" && comparisonOperators.has(value.operator)) {
+    const left = types.get(value.left.type);
+    return value.type === "BOOL" && left && ["duration", "calendar"].includes(left.kind) && value.left.type === value.right.type ? undefined : "Time comparisons require matching domains.";
+  }
+  return "TIME and calendar domains permit storage, typed copies and comparisons; implicit numeric arithmetic is unsupported.";
+}
+
+// packages/compiler/ir/aggregates.ts
+function aggregate(type) {
+  return type?.kind === "record" || type?.kind === "array";
+}
+function valueFits(value, type, types) {
+  if (type.kind === "duration" || type.kind === "calendar")
+    return domainConstantFits(value, type);
+  if (type.kind === "enum")
+    return value.kind === "integer" && type.members.some((member) => member.value === value.value);
+  if (type.kind === "string")
+    return value.kind === "string" && !value.value.includes("\x00") && (type.encoding === "utf8" ? new TextEncoder().encode(value.value).length <= type.capacity : value.value.length <= type.capacity);
+  if (type.kind === "array")
+    return value.kind === "array" && value.items.length === type.length && value.items.every((item) => valueFits(item, types.get(type.element), types));
+  if (type.kind === "record")
+    return value.kind === "record" && Object.keys(value.fields).length === type.fields.length && type.fields.every((field) => Object.hasOwn(value.fields, field.name) && valueFits(value.fields[field.name], types.get(field.type), types));
+  return constantFits(value, type);
+}
+function defaultValue(typeId, types) {
+  const type = types.get(typeId);
+  if (!type)
+    throw new Error("Unknown default-value type");
+  if (type.kind === "bool")
+    return { kind: "bool", value: false };
+  if (type.kind === "float")
+    return { kind: "float", value: 0 };
+  if (type.kind === "string")
+    return { kind: "string", value: "" };
+  if (type.kind === "enum")
+    return {
+      kind: "integer",
+      value: type.members.find((member) => member.value === "0")?.value ?? type.members[0].value
+    };
+  if (type.kind === "array")
+    return {
+      kind: "array",
+      items: Array.from({ length: type.length }, () => defaultValue(type.element, types))
+    };
+  if (type.kind === "record")
+    return {
+      kind: "record",
+      fields: Object.fromEntries(type.fields.map((field) => [field.name, defaultValue(field.type, types)]))
+    };
+  if (type.kind === "duration")
+    return { kind: "duration", nanoseconds: "0" };
+  if (type.kind === "calendar")
+    return {
+      kind: "calendar",
+      value: type.domain === "date" ? "1970-01-01" : type.domain === "timeOfDay" ? "00:00:00.000" : "1970-01-01T00:00:00"
+    };
+  if (type.kind === "integer" || type.kind === "bits")
+    return { kind: "integer", value: "0" };
+  throw new Error("Unsupported default-value type");
+}
+function placeType(place, types, variables, ranges = new Map, writable = false) {
+  const root = variables.get(place.root);
+  if (!root)
+    return { issue: "Unknown storage root." };
+  if (writable && (root.storage === "input" || root.storage === "constant" || root.storage === "blockOutput" || root.storage === "parameter" && root.mode !== "inOut" || !place.path.length && !root.mutable))
+    return { issue: "This storage is read-only." };
+  let id = root.type;
+  for (const segment of place.path) {
+    const type = types.get(id);
+    if (segment.kind === "field") {
+      if (type?.kind === "block" && segment.name === "out" && type.output) {
+        if (writable)
+          return { issue: "Function block output views are read-only." };
+        id = type.output;
+        continue;
+      }
+      if (type?.kind !== "record")
+        return { issue: "Field access requires a record." };
+      const field = type.fields.find((field) => field.name === segment.name);
+      if (!field)
+        return { issue: "Unknown record field." };
+      if (writable && field.readonly)
+        return { issue: "This field is read-only." };
+      id = field.type;
+    } else {
+      if (type?.kind !== "array")
+        return { issue: "Index access requires a fixed array." };
+      if (type.index && segment.value.type === type.index) {
+        id = type.element;
+        continue;
+      }
+      const indexType = types.get(segment.value.type), bounds = interval(segment.value, types, variables, ranges);
+      if (indexType?.kind !== "integer" || !bounds || bounds[0] < BigInt(type.lowerBound) || bounds[1] >= BigInt(type.lowerBound + type.length))
+        return { issue: "Array index must be proved within the declared bounds." };
+      id = type.element;
+    }
+  }
+  return { type: id };
+}
+function aggregateIssue(value, types) {
+  const type = types.get(value.type);
+  if (!type)
+    return "Unknown expression type.";
+  if (value.kind === "constant")
+    return valueFits(value.value, type, types) ? undefined : "Constant does not fit its closed PLC layout.";
+  if (value.kind === "record")
+    return type.kind === "record" && Object.keys(value.fields).length === type.fields.length && type.fields.every((field) => Object.hasOwn(value.fields, field.name) && value.fields[field.name]?.type === field.type) ? undefined : "Record expression differs from its layout.";
+  if (value.kind === "array")
+    return type.kind === "array" && value.items.length === type.length && value.items.every((item) => item.type === type.element) ? undefined : "Array expression differs from its layout.";
+  if (value.kind === "copy")
+    return aggregate(type) && value.operand.type === value.type ? undefined : "Copy requires one matching fixed aggregate.";
+  if (value.kind === "convert") {
+    const source = types.get(value.operand.type);
+    return type.kind === "string" && source?.kind === "string" && source.encoding === type.encoding && source.capacity <= type.capacity && value.policy === "exact" ? undefined : "Unsupported aggregate/domain conversion.";
+  }
+  if (value.kind === "load" || value.kind === "call" || value.kind === "conditional")
+    return;
+  if (value.kind === "binary" && comparisonOperators.has(value.operator)) {
+    const left = types.get(value.left.type);
+    return value.type === "BOOL" && left && ["enum", "string"].includes(left.kind) && value.left.type === value.right.type && (left.kind !== "enum" || ["equal", "notEqual"].includes(value.operator)) ? undefined : "Comparison requires compatible scalar domains; object identity is unsupported.";
+  }
+  return "Operation is unsupported for this PLC domain.";
+}
+function expressionIssue(value, types, variables, ranges) {
+  const kinds = [value.type, ...value.kind === "binary" ? [value.left.type] : []].map((id) => types.get(id)?.kind ?? "");
+  if (kinds.some((kind) => ["duration", "calendar"].includes(kind)))
+    return domainIssue(value, types);
+  if (["copy", "record", "array"].includes(value.kind) || kinds.some((kind) => ["record", "array", "enum", "string"].includes(kind)))
+    return aggregateIssue(value, types);
+  return scalarIssue(value, types, variables, ranges);
+}
+function layoutIssue(types) {
+  for (const type of types.values()) {
+    const canonical = primitiveTypes.find((item) => item.id === type.id);
+    if (canonical) {
+      if (type.kind !== canonical.kind || "bits" in canonical && (!("bits" in type) || type.bits !== canonical.bits) || "signed" in canonical && (!("signed" in type) || type.signed !== canonical.signed) || "domain" in canonical && (!("domain" in type) || type.domain !== canonical.domain))
+        return `Conflicting primitive type ${type.id}`;
+      continue;
+    }
+    if (type.kind === "record") {
+      if (!type.fields.length || new Set(type.fields.map((field) => field.name)).size !== type.fields.length || type.fields.some((field) => !field.name || typeof field.readonly !== "boolean" || field.mode && field.mode !== "inOut" || !types.has(field.type)))
+        return `Invalid closed record layout ${type.id}`;
+    } else if (type.kind === "array") {
+      if (!types.has(type.element) || !Number.isSafeInteger(type.length) || type.length < 1 || type.length > 1e6 || !Number.isInteger(type.lowerBound) || type.lowerBound < -2147483648 || type.lowerBound + type.length - 1 > 2147483647)
+        return `Invalid fixed array layout ${type.id}`;
+      if (type.index !== undefined) {
+        const index = types.get(type.index);
+        if (index?.kind !== "enum" || index.members.length !== type.length || index.members.some((member) => Number(member.value) < type.lowerBound || Number(member.value) >= type.lowerBound + type.length))
+          return `Invalid enum-keyed array layout ${type.id}`;
+      }
+    } else if (type.kind === "enum") {
+      if (type.base !== "DINT" || types.get(type.base)?.kind !== "integer" || !type.members.length || new Set(type.members.map((member) => member.name)).size !== type.members.length || new Set(type.members.map((member) => member.value)).size !== type.members.length || type.members.some((member) => !member.name || !constantFits({ kind: "integer", value: member.value }, types.get(type.base))))
+        return `Invalid enum layout ${type.id}`;
+    } else if (type.kind === "string") {
+      if (!Number.isInteger(type.capacity) || type.capacity < 1 || type.capacity > 65535 || !["utf8", "utf16"].includes(type.encoding))
+        return `Invalid bounded string layout ${type.id}`;
+    } else if (type.kind === "block") {
+      if (!type.block || type.output && types.get(type.output)?.kind !== "record")
+        return `Invalid block type ${type.id}`;
+    } else
+      return `Unsupported core type definition ${type.id}`;
+  }
+  const active = new Set, layouts = new Map;
+  const count = (id, depth) => {
+    if (active.has(id) || depth > 64)
+      throw new Error(`Recursive or excessively nested by-value layout ${id}`);
+    const cached = layouts.get(id);
+    if (cached) {
+      if (depth + cached.height > 64)
+        throw new Error(`Layout nesting exceeds 64 levels ${id}`);
+      return cached;
+    }
+    active.add(id);
+    const type = types.get(id);
+    const children = type.kind === "array" ? [count(type.element, depth + 1)] : type.kind === "record" ? type.fields.map((field) => count(field.type, depth + 1)) : [];
+    const size = type.kind === "array" ? type.length * children[0].size : type.kind === "record" ? children.reduce((sum, child) => sum + child.size, 0) : 1;
+    const height = children.length ? 1 + children.reduce((maximum, child) => Math.max(maximum, child.height), 0) : 0;
+    active.delete(id);
+    if (size > 1e6)
+      throw new Error(`Layout exceeds one million scalar elements ${id}`);
+    if (depth + height > 64)
+      throw new Error(`Layout nesting exceeds 64 levels ${id}`);
+    const layout = { size, height };
+    layouts.set(id, layout);
+    return layout;
+  };
+  try {
+    for (const id of types.keys())
+      count(id, 0);
+  } catch (cause) {
+    return cause instanceof Error ? cause.message : "Invalid layout";
+  }
+  return;
+}
+
+// packages/compiler/ir/normalization-error.ts
+class InvalidCore extends Error {
+  diagnostic;
+  constructor(diagnostic) {
+    super(diagnostic.message);
+    this.diagnostic = diagnostic;
+  }
+}
+function reject(message, span) {
+  throw new InvalidCore(error("PLC6001", message, span));
+}
+
+// packages/compiler/ir/declarations.ts
+class ModuleDeclarations {
+  ids = new Set;
+  types = new Map;
+  globals = new Map;
+  blocks;
+  signatures;
+  constructor(module) {
+    for (const type of module.types) {
+      if (this.types.has(type.id))
+        reject(`Duplicate type ${type.id}.`);
+      this.types.set(type.id, type);
+    }
+    const invalidLayout = layoutIssue(this.types);
+    if (invalidLayout)
+      reject(invalidLayout);
+    if (this.types.get("BOOL")?.kind !== "bool")
+      reject("Missing canonical BOOL type.");
+    this.blocks = new Map(module.blocks.map((block) => [block.id, block]));
+    for (const item of module.variables) {
+      this.checkVariable(item, ["module", "instance", "input", "output", "constant"]);
+      this.globals.set(item.id, item);
+    }
+    this.signatures = new Map(module.functions.map((fn) => [fn.id, fn]));
+    for (const fn of module.functions) {
+      this.claimId(fn.id, fn.span);
+      if (fn.owner && (!this.blocks.has(fn.owner.block) || this.blocks.get(fn.owner.block)?.standard || !["public", "private", "protected"].includes(fn.owner.access)))
+        reject("Methods require a user block owner and a valid access modifier.", fn.span);
+      if (fn.result && !this.isValueType(fn.result))
+        reject("Unknown or non-value function result type.", fn.span);
+      for (const parameter of fn.parameters) {
+        this.checkVariable(parameter, ["parameter"], true);
+        if (parameter.mutable && !parameter.mode)
+          reject("Value parameters are readonly.", parameter.span);
+      }
+      for (const local of fn.locals)
+        this.checkVariable(local, ["local"]);
+    }
+    for (const block of module.blocks) {
+      this.claimId(block.id, block.span);
+      for (const input of block.inputs) {
+        this.checkVariable(input, ["parameter"], true);
+        if (!input.mode && input.mutable)
+          reject("Value block inputs are readonly.", input.span);
+      }
+      for (const output of block.outputs)
+        this.checkVariable(output, ["blockOutput"]);
+      for (const state of block.state)
+        this.checkVariable(state, ["field", "instance"]);
+      for (const local of block.locals)
+        this.checkVariable(local, ["local"]);
+      for (const ports of [block.inputs, block.outputs]) {
+        if (new Set(ports.map((variable) => variable.name)).size !== ports.length)
+          reject("Block input and output names must each be unique within their schema.", block.span);
+      }
+      const result = block.result ? this.types.get(block.result) : undefined;
+      if (block.outputs.length ? result?.kind !== "record" || !this.isValueType(result.id) || result.fields.length !== block.outputs.length || result.fields.some((field) => !block.outputs.some((output) => output.name === field.name && output.type === field.type)) : Boolean(block.result))
+        reject("Block output schema differs from its result record.", block.span);
+      if (block.standard) {
+        const expected = Object.hasOwn(standardBlocks, block.standard) ? standardBlocks[block.standard] : undefined;
+        const matches = (variables, schema) => variables.length === schema.length && schema.every(([name, , type]) => variables.some((variable) => variable.name === name && variable.type === type && !variable.mode && !variable.retain));
+        if (!expected || block.name !== block.standard || block.body.length || block.state.length || block.locals.length || !matches(block.inputs, expected.inputs) || !matches(block.outputs, expected.outputs) || block.outputs.some((output) => output.type === "BOOL" ? output.initial?.kind !== "bool" || output.initial.value !== false : output.initial?.kind !== "duration" || output.initial.nanoseconds !== "0"))
+          reject("Invalid canonical standard block definition.", block.span);
+      }
+    }
+    for (const type of this.types.values())
+      if (type.kind === "block") {
+        const definition = this.blocks.get(type.block);
+        if (!definition || definition.result !== type.output)
+          reject("Block type differs from its definition.");
+      }
+  }
+  hasId(id) {
+    return this.ids.has(id);
+  }
+  claimId(id, span) {
+    if (this.ids.has(id))
+      reject(`Duplicate symbol ${id}.`, span);
+    this.ids.add(id);
+  }
+  isValueType(id, seen = new Set) {
+    if (seen.has(id))
+      return true;
+    seen.add(id);
+    const type = this.types.get(id);
+    return Boolean(type && type.kind !== "block" && (type.kind !== "record" || type.fields.every((field) => !field.mode && this.isValueType(field.type, seen))) && (type.kind !== "array" || this.isValueType(type.element, seen)));
+  }
+  checkVariable(item, storage, allowBorrow = false) {
+    this.claimId(item.id, item.span);
+    const type = this.types.get(item.type);
+    if (!type || !storage.includes(item.storage))
+      reject("Invalid storage type or class.", item.span);
+    if (item.mode && (item.mode !== "inOut" || !allowBorrow || !item.mutable || item.storage !== "parameter"))
+      reject("InOut belongs only on mutable parameters.", item.span);
+    const mutableState = item.mutable || type.kind === "array" || type.kind === "record" && type.fields.some((field) => !field.readonly);
+    if (item.retain && !(item.storage === "instance" || ["module", "field"].includes(item.storage) && mutableState))
+      reject("Only mutable static state or block instances may retain.", item.span);
+    if (item.storage === "instance") {
+      const instanced = instancedBlock(item.type, this.types);
+      if (!instanced || !this.blocks.has(instanced.block) || item.initial || item.mode)
+        reject("Instances require a known static block and cannot have value initializers.", item.span);
+    } else if (!this.isValueType(item.type) && !(allowBorrow && item.mode === "inOut" && type.kind === "block"))
+      reject("Block instances and reference schemas cannot be stored as values.", item.span);
+    if (item.storage === "parameter" && item.initial)
+      reject("Inputs are supplied at each invocation and cannot have stored initializers.", item.span);
+    if (item.initial && !valueFits(item.initial, type, this.types))
+      reject("Initializer has the wrong type or is out of range.", item.span);
+    if (["module", "field", "constant", "blockOutput"].includes(item.storage) && !item.initial)
+      reject("Persistent storage requires initialization.", item.span);
+    if (["input", "constant", "blockOutput"].includes(item.storage) && item.mutable)
+      reject("Readonly storage marked mutable.", item.span);
+  }
+}
+
+// packages/compiler/ir/allocation.ts
+function checkStaticAllocation(module, declarations) {
+  const { types, blocks } = declarations;
+  const payloads = new Map;
+  const payload = (id) => {
+    const cached = payloads.get(id);
+    if (cached !== undefined)
+      return cached;
+    const type = types.get(id);
+    const size = type.kind === "array" ? type.length * payload(type.element) : type.kind === "record" ? type.fields.reduce((sum, field) => sum + payload(field.type), 0) : 1;
+    payloads.set(id, size);
+    return size;
+  };
+  const instanceSize = (id) => {
+    const type = types.get(id);
+    return type.kind === "array" ? type.length * instanceSize(type.element) : allocation(type.kind === "block" ? type.block : "").size;
+  };
+  const allocations = new Map, allocating = new Set;
+  const allocation = (id) => {
+    if (allocating.size >= 64)
+      reject("Static block allocation nesting exceeds 64 levels.", blocks.get(id)?.span);
+    if (allocating.has(id))
+      reject("Recursive static block allocation.", blocks.get(id)?.span);
+    const cached = allocations.get(id);
+    if (cached)
+      return cached;
+    allocating.add(id);
+    const block = blocks.get(id);
+    const children = block.state.filter((item) => item.storage === "instance").map((item) => ({
+      height: allocation(instancedBlock(item.type, types).block).height,
+      size: instanceSize(item.type)
+    }));
+    const own = [
+      ...block.inputs,
+      ...block.outputs,
+      ...block.state.filter((item) => item.storage !== "instance")
+    ].reduce((sum, item) => sum + (item.mode === "inOut" ? 1 : payload(item.type)), 1);
+    const size = own + children.reduce((sum, child) => sum + child.size, 0), height = children.length ? 1 + Math.max(...children.map((child) => child.height)) : 1;
+    if (size > 1e6 || height > 64)
+      reject("Static block allocation exceeds its finite budget.", block.span);
+    allocating.delete(id);
+    const result = { size, height };
+    allocations.set(id, result);
+    return result;
+  };
+  for (const block of module.blocks)
+    allocation(block.id);
+  const staticPayload = module.variables.reduce((sum, variable) => {
+    return sum + (instancedBlock(variable.type, types) ? instanceSize(variable.type) : payload(variable.type));
+  }, 0);
+  if (staticPayload > 1e6)
+    reject("Static module storage exceeds one million scalar elements.");
+}
+
+// packages/compiler/ir/routine.ts
+function join(branches, initialized) {
+  const falling = branches.filter((branch) => branch.flow === "fallthrough");
+  if (falling.length)
+    return {
+      flow: "fallthrough",
+      initialized: new Set([...falling[0].initialized].filter((id) => falling.every((branch) => branch.initialized.has(id))))
+    };
+  const flow = branches[0].flow;
+  return { flow: branches.every((branch) => branch.flow === flow) ? flow : "mixed", initialized };
+}
+
+class RoutineNormalizer {
+  declarations;
+  fn;
+  block;
+  owner;
+  scope;
+  sourceScope;
+  locals;
+  ranges = new Map;
+  counters = new Set;
+  callees = new Set;
+  temporaryCount = 0;
+  constructor(routine, declarations) {
+    this.declarations = declarations;
+    this.block = "inputs" in routine ? routine : undefined;
+    this.owner = this.block ?? ("owner" in routine && routine.owner ? declarations.blocks.get(routine.owner.block) : undefined);
+    const parameters = "parameters" in routine ? routine.parameters : routine.inputs;
+    this.fn = {
+      id: routine.id,
+      name: routine.name,
+      ..."owner" in routine && routine.owner && { owner: routine.owner },
+      parameters,
+      locals: routine.locals,
+      body: routine.body,
+      span: routine.span,
+      ...routine.result && { result: routine.result }
+    };
+    this.scope = new Map(declarations.globals);
+    for (const item of [
+      ...parameters,
+      ...this.owner ? [...this.owner.state, ...this.owner.outputs] : [],
+      ...routine.locals
+    ])
+      this.scope.set(item.id, item);
+    this.sourceScope = new Map(this.scope);
+    this.locals = [...routine.locals];
+  }
+  normalize() {
+    if (this.block?.standard)
+      return { routine: { ...this.block, body: [] }, callees: this.callees };
+    const normalized = this.body(this.fn.body, new Set(this.fn.parameters.map((item) => item.id)));
+    if (this.fn.result && normalized.flow !== "return")
+      reject("A typed helper must return on every path.", this.fn.span);
+    const routine = this.block ? { ...this.block, locals: this.locals, body: normalized.body } : { ...this.fn, locals: this.locals, body: normalized.body };
+    return { routine, callees: this.callees };
+  }
+  temporary(type, span) {
+    let id;
+    do {
+      id = `${this.fn.id}:temporary:${this.temporaryCount++}`;
+    } while (this.declarations.hasId(id));
+    this.declarations.claimId(id);
+    const item = {
+      id,
+      name: `temporary_${this.temporaryCount}`,
+      type,
+      storage: "local",
+      mutable: true,
+      retain: false,
+      span
+    };
+    this.scope.set(id, item);
+    this.locals.push(item);
+    return item;
+  }
+  load(variable, span) {
+    return { kind: "load", root: variable.id, type: variable.type, span };
+  }
+  verifyCall(id, arguments_, span, instance) {
+    const called = this.declarations.signatures.get(id);
+    if (!called || called.parameters.length !== arguments_.length)
+      reject("Unknown helper or wrong argument count.", span);
+    if (called.owner) {
+      if (instance) {
+        const variable = this.sourceScope.get(instance);
+        const type = variable && instancedBlock(variable.type, this.declarations.types);
+        if (variable?.storage !== "instance" && variable?.mode !== "inOut" || type?.block !== called.owner.block)
+          reject("Method calls require a matching static block instance.", span);
+      } else if (this.owner?.id !== called.owner.block)
+        reject("An implicit method call requires its owning block scope.", span);
+      if (called.owner.access !== "public" && this.owner?.id !== called.owner.block)
+        reject("Private and protected methods require their owning block scope.", span);
+    } else if (instance)
+      reject("Ordinary functions cannot have an instance receiver.", span);
+    this.callees.add(id);
+    arguments_.forEach((argument, index) => {
+      if (argument.type !== called.parameters[index]?.type)
+        reject("Helper argument has the wrong PLC type.", argument.span);
+    });
+    return called;
+  }
+  expression(value, initialized, output, allowAggregateLoad = false) {
+    const type = this.declarations.types.get(value.type);
+    if (!type || !this.declarations.isValueType(value.type))
+      reject("Unknown or non-value expression type.", value.span);
+    if (value.kind === "borrow")
+      reject("Borrowed places are only valid in block update arguments.", value.span);
+    const common = { type: value.type, span: value.span };
+    if (value.kind === "length") {
+      const array = this.declarations.types.get(value.operand.type);
+      if (array?.kind !== "array" || value.type !== "DINT")
+        reject("Length requires a fixed array and DINT result.", value.span);
+      if (value.operand.kind === "load") {
+        const source = this.sourceScope.get(value.operand.place.root), checked = placeType(value.operand.place, this.declarations.types, this.sourceScope, this.ranges);
+        if (!source || checked.issue || checked.type !== value.operand.type || source.storage === "local" && !initialized.has(source.id))
+          reject(checked.issue ?? "Invalid array receiver.", value.span);
+        this.normalizePath(value.operand.place, initialized, output);
+      } else
+        this.expression(value.operand, initialized, output, true);
+      return {
+        ...common,
+        kind: "constant",
+        value: { kind: "integer", value: String(array.length) }
+      };
+    }
+    if (value.kind === "conditional") {
+      if (value.condition.type !== "BOOL" || value.then.type !== value.type || value.else.type !== value.type)
+        reject("Invalid conditional types.", value.span);
+      const condition = this.expression(value.condition, initialized, output), result = this.temporary(value.type, value.span);
+      const branch = (operand) => {
+        const statements = [];
+        const evaluated = this.expression(operand, new Set(initialized), statements);
+        statements.push({ kind: "assign", root: result.id, value: evaluated, span: value.span });
+        return statements;
+      };
+      output.push({
+        kind: "if",
+        condition,
+        then: branch(value.then),
+        else: branch(value.else),
+        span: value.span
+      });
+      initialized.add(result.id);
+      return this.load(result, value.span);
+    }
+    if (value.kind === "call") {
+      const called = this.verifyCall(value.function, value.arguments, value.span, value.instance);
+      if (called.result !== value.type)
+        reject("Expression call requires a matching result type.", value.span);
+      const index = value.instance && this.instanceIndex(value.instance, value.index, initialized, output, value.span);
+      const arguments_ = this.arguments(called.parameters, value.arguments, initialized, output);
+      const result = this.temporary(value.type, value.span);
+      output.push({
+        kind: "invoke",
+        function: value.function,
+        ...value.instance && { instance: value.instance },
+        ...index && { index },
+        arguments: arguments_,
+        destination: result.id,
+        span: value.span
+      });
+      initialized.add(result.id);
+      return this.load(result, value.span);
+    }
+    const issue = expressionIssue(value, this.declarations.types, this.scope, this.ranges);
+    if (issue)
+      reject(issue, value.span);
+    switch (value.kind) {
+      case "copy":
+        return this.expression(value.operand, initialized, output, true);
+      case "record":
+      case "array": {
+        const result = this.temporary(value.type, value.span);
+        if (value.kind === "record") {
+          for (const [name, operand] of Object.entries(value.fields))
+            output.push({
+              kind: "assign",
+              root: result.id,
+              path: [{ kind: "field", name }],
+              value: this.expression(operand, initialized, output),
+              span: operand.span
+            });
+        } else {
+          const array = this.declarations.types.get(value.type);
+          if (array.kind !== "array")
+            reject("Invalid array construction.", value.span);
+          value.items.forEach((operand, index) => {
+            output.push({
+              kind: "assign",
+              root: result.id,
+              path: [
+                {
+                  kind: "index",
+                  value: {
+                    kind: "constant",
+                    type: "DINT",
+                    value: { kind: "integer", value: String(array.lowerBound + index) },
+                    span: operand.span
+                  }
+                }
+              ],
+              value: this.expression(operand, initialized, output),
+              span: operand.span
+            });
+          });
+        }
+        initialized.add(result.id);
+        return this.load(result, value.span);
+      }
+      case "constant": {
+        if (!aggregate(type))
+          return { ...common, kind: "constant", value: value.value };
+        const result = this.temporary(value.type, value.span);
+        output.push({
+          kind: "assign",
+          root: result.id,
+          value: { ...common, kind: "constant", value: value.value },
+          span: value.span
+        });
+        initialized.add(result.id);
+        return this.load(result, value.span);
+      }
+      case "load": {
+        const source = this.sourceScope.get(value.place.root), checked = placeType(value.place, this.declarations.types, this.sourceScope, this.ranges);
+        if (!source || checked.issue || checked.type !== value.type)
+          reject(checked.issue ?? "Invalid PLC load.", value.span);
+        if (aggregate(type) && !allowAggregateLoad)
+          reject("Aggregate loads require explicit copy or a readonly value argument.", value.span);
+        if (source.storage === "local" && !initialized.has(source.id))
+          reject("Local read before initialization.", value.span);
+        const first = value.place.path[0];
+        if (source.storage === "instance" && value.place.path.length === 1 && first?.kind === "field" && first.name === "out" && type.kind === "record") {
+          const result = this.temporary(value.type, value.span);
+          for (const field of type.fields) {
+            const selected = {
+              kind: "load",
+              type: field.type,
+              place: {
+                root: source.id,
+                path: [...value.place.path, { kind: "field", name: field.name }]
+              },
+              span: value.span
+            };
+            const captured = this.expression(selected, initialized, output, true);
+            output.push({
+              kind: "assign",
+              root: result.id,
+              path: [{ kind: "field", name: field.name }],
+              value: captured,
+              span: value.span
+            });
+          }
+          initialized.add(result.id);
+          return this.load(result, value.span);
+        }
+        const path = this.normalizePath(value.place, initialized, output);
+        if (source.storage === "constant" && source.initial && !path.length)
+          return { ...common, kind: "constant", value: source.initial };
+        const result = this.temporary(value.type, value.span);
+        output.push({
+          kind: "assign",
+          root: result.id,
+          value: { ...common, kind: "load", root: source.id, ...path.length && { path } },
+          span: value.span
+        });
+        const bound = interval(value, this.declarations.types, this.scope, this.ranges);
+        if (bound)
+          this.ranges.set(result.id, bound);
+        initialized.add(result.id);
+        return this.load(result, value.span);
+      }
+      case "unary": {
+        const operand = this.expression(value.operand, initialized, output), constant = fold(value, this.scope, this.declarations.types);
+        return constant ? { ...common, kind: "constant", value: constant } : { ...common, kind: "unary", operator: value.operator, operand };
+      }
+      case "convert": {
+        const operand = this.expression(value.operand, initialized, output), constant = fold(value, this.scope, this.declarations.types);
+        if (value.type === value.operand.type)
+          return operand;
+        return constant ? { ...common, kind: "constant", value: constant } : { ...common, kind: "convert", operand, policy: value.policy };
+      }
+      case "binary": {
+        const left = this.expression(value.left, initialized, output);
+        if (value.operator === "and" || value.operator === "or") {
+          const result = this.temporary("BOOL", value.span), branch = [];
+          output.push({ kind: "assign", root: result.id, value: left, span: value.span });
+          const right = this.expression(value.right, new Set(initialized), branch);
+          branch.push({ kind: "assign", root: result.id, value: right, span: value.span });
+          const condition = value.operator === "and" ? this.load(result, value.span) : {
+            kind: "unary",
+            operator: "not",
+            operand: this.load(result, value.span),
+            type: "BOOL",
+            span: value.span
+          };
+          output.push({
+            kind: "if",
+            condition,
+            then: branch,
+            else: [],
+            span: value.span
+          });
+          initialized.add(result.id);
+          return this.load(result, value.span);
+        }
+        const right = this.expression(value.right, initialized, output), constant = fold(value, this.scope, this.declarations.types);
+        if (constant)
+          return { ...common, kind: "constant", value: constant };
+        return {
+          ...common,
+          kind: "binary",
+          operator: value.operator,
+          left,
+          right,
+          ...value.policy && { policy: value.policy }
+        };
+      }
+    }
+  }
+  normalizePath(place, initialized, output) {
+    return place.path.map((segment) => segment.kind === "field" ? segment : { kind: "index", value: this.expression(segment.value, initialized, output) });
+  }
+  destination(place, type, initialized, span) {
+    const target = this.sourceScope.get(place.root), initializing = target?.storage === "local" && !initialized.has(place.root) && !place.path.length;
+    const checked = placeType(place, this.declarations.types, this.sourceScope, this.ranges, !initializing);
+    if (!target || checked.issue || checked.type !== type || this.counters.has(place.root))
+      reject(checked.issue ?? "Invalid assignment destination.", span);
+    if (place.path.length && target.storage === "local" && !initialized.has(target.id))
+      reject("Initialize the whole aggregate before assigning fields.", span);
+    return target;
+  }
+  instanceIndex(instance, index, initialized, output, span) {
+    if (!index)
+      return;
+    const checked = placeType({ root: instance, path: [{ kind: "index", value: index }] }, this.declarations.types, this.sourceScope, this.ranges);
+    if (checked.issue)
+      reject(checked.issue, span);
+    return this.expression(index, initialized, output);
+  }
+  blockUpdate(item, initialized, output) {
+    const instance = this.sourceScope.get(item.instance), type = instance && instancedBlock(instance.type, this.declarations.types);
+    const called = type && this.declarations.blocks.get(type.block);
+    if (instance?.storage !== "instance" && instance?.mode !== "inOut" || !called)
+      reject("Updates require a statically allocated block instance.", item.span);
+    const index = this.instanceIndex(item.instance, item.index, initialized, output, item.span);
+    const keys = Object.keys(item.inputs);
+    if (keys.length !== called.inputs.length || called.inputs.some((input) => !Object.hasOwn(item.inputs, input.name)))
+      reject("Block update must supply every named input exactly once.", item.span);
+    this.callees.add(called.id);
+    const arguments_ = this.arguments(keys.map((name) => called.inputs.find((input) => input.name === name)), keys.map((name) => item.inputs[name]), initialized, output);
+    const inputs = Object.fromEntries(keys.map((name, index) => [name, arguments_[index]]));
+    output.push({
+      kind: "blockUpdate",
+      instance: instance.id,
+      ...index && { index },
+      inputs,
+      span: item.span
+    });
+  }
+  arguments(parameters, values, initialized, output) {
+    const arguments_ = [];
+    for (const [index, value] of values.entries()) {
+      const input = parameters[index];
+      if (value.type !== input.type)
+        reject("Block input differs from its concrete PLC type.", value.span);
+      const block = this.declarations.types.get(value.type)?.kind === "block";
+      if (input.mode === "inOut" && value.kind !== "borrow") {
+        if (block)
+          reject("Pass a block instance by name.", value.span);
+        const temporary = this.temporary(value.type, value.span);
+        output.push({
+          kind: "assign",
+          root: temporary.id,
+          value: this.expression(value, initialized, output),
+          span: value.span
+        });
+        initialized.add(temporary.id);
+        arguments_.push({
+          kind: "borrow",
+          type: value.type,
+          place: { root: temporary.id, path: [] },
+          span: value.span
+        });
+      } else if (input.mode === "inOut" && value.kind === "borrow") {
+        const root = this.sourceScope.get(value.place.root), checked = placeType(value.place, this.declarations.types, this.sourceScope, this.ranges, !block);
+        if (!root || checked.issue || checked.type !== value.type || !block && !this.declarations.isValueType(value.type) || this.counters.has(root.id) || root.storage === "local" && !initialized.has(root.id))
+          reject(checked.issue ?? "Borrow requires initialized mutable value storage of the exact type.", value.span);
+        arguments_.push({
+          kind: "borrow",
+          type: value.type,
+          place: {
+            root: value.place.root,
+            path: this.normalizePath(value.place, initialized, output)
+          },
+          span: value.span
+        });
+      } else {
+        if (value.kind === "borrow")
+          reject("Readonly value inputs cannot receive borrowed references.", value.span);
+        arguments_.push(this.expression(value, initialized, output, true));
+      }
+    }
+    return arguments_;
+  }
+  body(statements, initialized, inLoop = false) {
+    const output = [];
+    let flow = "fallthrough";
+    for (const item of statements) {
+      if (flow !== "fallthrough")
+        break;
+      switch (item.kind) {
+        case "assign": {
+          this.destination(item.destination, item.value.type, initialized, item.span);
+          const path = this.normalizePath(item.destination, initialized, output);
+          const bound = !path.length && this.scope.get(item.destination.root)?.mutable === false && valueRange(item.value, this.declarations.types, this.scope, this.ranges, this.declarations.signatures);
+          const value = this.expression(item.value, initialized, output);
+          if (bound)
+            this.ranges.set(item.destination.root, bound);
+          if (!path.length)
+            initialized.add(item.destination.root);
+          output.push({
+            kind: "assign",
+            root: item.destination.root,
+            ...path.length && { path },
+            value,
+            span: item.span
+          });
+          break;
+        }
+        case "blockUpdate": {
+          this.blockUpdate(item, initialized, output);
+          break;
+        }
+        case "invoke": {
+          const called = this.verifyCall(item.function, item.arguments, item.span, item.instance);
+          if (item.destination) {
+            if (item.destination.path.length || !called.result)
+              reject("Invalid helper destination.", item.span);
+            this.destination(item.destination, called.result, initialized, item.span);
+          }
+          const index = item.instance && this.instanceIndex(item.instance, item.index, initialized, output, item.span);
+          const arguments_ = this.arguments(called.parameters, item.arguments, initialized, output);
+          output.push({
+            kind: "invoke",
+            function: item.function,
+            ...item.instance && { instance: item.instance },
+            ...index && { index },
+            arguments: arguments_,
+            span: item.span,
+            ...item.destination && { destination: item.destination.root }
+          });
+          if (item.destination)
+            initialized.add(item.destination.root);
+          break;
+        }
+        case "if": {
+          if (item.condition.type !== "BOOL")
+            reject("Conditions require BOOL.", item.span);
+          const condition = this.expression(item.condition, initialized, output);
+          const originalRanges = new Map(this.ranges);
+          const branch = (statements, truth) => {
+            this.ranges.clear();
+            for (const [root, range] of narrowRanges(item.condition, truth, this.declarations.types, this.sourceScope, originalRanges))
+              this.ranges.set(root, range);
+            try {
+              return this.body(statements, new Set(initialized), inLoop);
+            } finally {
+              this.ranges.clear();
+              for (const [root, range] of originalRanges)
+                this.ranges.set(root, range);
+            }
+          };
+          const yes = branch(item.then, true), no = branch(item.else, false);
+          ({ flow, initialized } = join([yes, no], initialized));
+          output.push({
+            kind: "if",
+            condition,
+            then: yes.body,
+            else: no.body,
+            span: item.span
+          });
+          break;
+        }
+        case "switch": {
+          const value = this.expression(item.value, initialized, output), seen = new Set;
+          const branches = item.cases.map((branch) => {
+            for (const constant of branch.values) {
+              if (!valueFits(constant, this.declarations.types.get(item.value.type), this.declarations.types))
+                reject("Invalid case constant.", item.span);
+              const key = JSON.stringify(constant);
+              if (seen.has(key))
+                reject("Duplicate case constant.", item.span);
+              seen.add(key);
+            }
+            return {
+              values: branch.values,
+              result: this.body(branch.body, new Set(initialized), inLoop)
+            };
+          });
+          const fallback = this.body(item.fallback, new Set(initialized), inLoop);
+          ({ flow, initialized } = join([...branches.map((branch) => branch.result), fallback], initialized));
+          output.push({
+            kind: "switch",
+            value,
+            cases: branches.map((branch) => ({ values: branch.values, body: branch.result.body })),
+            fallback: fallback.body,
+            span: item.span
+          });
+          break;
+        }
+        case "for": {
+          const counter = this.sourceScope.get(item.counter);
+          const counterType = counter && this.declarations.types.get(counter.type);
+          if (!counter || !(item.counterScope === "existing" ? ["local", "module", "field"].includes(counter.storage) : counter.storage === "local") || !counter.mutable || counterType?.kind !== "integer" || this.counters.has(counter.id) || item.start.type !== counter.type || item.limit.type !== counter.type || !/^(-?[1-9][0-9]*)$/.test(item.step))
+            reject("Invalid bounded loop.", item.span);
+          const start = fold(item.start, this.scope, this.declarations.types);
+          const limit = fold(item.limit, this.scope, this.declarations.types);
+          const startRange = interval(item.start, this.declarations.types, this.sourceScope, this.ranges);
+          const limitRange = interval(item.limit, this.declarations.types, this.sourceScope, this.ranges);
+          if (!startRange || !limitRange)
+            reject("Loop bounds require finite integer ranges.", item.span);
+          const step = BigInt(item.step);
+          const proof = loopBounds(startRange, limitRange, step, item.exclusive);
+          const dynamic = start?.kind !== "integer" || limit?.kind !== "integer";
+          const { first, last, count } = proof;
+          if (count > 1000000n || Number(count) !== item.maxIterations || !Number.isSafeInteger(item.maxIterations))
+            reject("Loop iteration proof differs from its bounds.", item.span);
+          if (item.counterScope === "existing") {
+            const terminal = dynamic ? (step > 0n ? proof.range[1] : proof.range[0]) + step : first + count * step;
+            const [minimum, maximum] = integerRange(counterType);
+            if (count > 0n && (terminal < minimum || terminal > maximum))
+              reject("The existing loop counter overflows on termination.", item.span);
+          }
+          const evaluatedStart = this.expression(item.start, initialized, output);
+          const evaluatedLimit = this.expression(item.limit, initialized, output);
+          initialized.add(counter.id);
+          this.counters.add(counter.id);
+          this.ranges.set(counter.id, proof.range);
+          const nested = this.body(item.body, new Set(initialized), true);
+          this.counters.delete(counter.id);
+          this.ranges.delete(counter.id);
+          if (item.counterScope !== "existing")
+            initialized.delete(counter.id);
+          output.push({
+            kind: "for",
+            counter: counter.id,
+            ...item.counterScope && { counterScope: item.counterScope },
+            start: { kind: "integer", value: String(first) },
+            limit: { kind: "integer", value: String(last) },
+            ...dynamic && {
+              dynamic: {
+                start: evaluatedStart,
+                limit: evaluatedLimit,
+                ...item.exclusive && { exclusive: item.exclusive }
+              }
+            },
+            step: item.step,
+            maxIterations: item.maxIterations,
+            body: nested.body,
+            span: item.span
+          });
+          break;
+        }
+        case "return": {
+          if (item.value?.type !== this.fn.result)
+            reject("Return differs from the function signature.", item.span);
+          const value = item.value && this.expression(item.value, initialized, output);
+          output.push({ kind: "return", span: item.span, ...value && { value } });
+          flow = "return";
+          break;
+        }
+        case "break":
+        case "continue":
+          if (!inLoop)
+            reject("Loop control appears outside a bounded loop.", item.span);
+          output.push({ kind: item.kind, span: item.span });
+          flow = "loop";
+          break;
+        default:
+          reject("Unknown PLC statement.");
+      }
+    }
+    return { body: output, initialized, flow };
+  }
+}
+
+// packages/compiler/ir/link.ts
+function linkModule(module, declarations, functions, normalizedBlocks, edges) {
+  const { signatures, blocks, types } = declarations;
+  const names = new Set, entries = new Set;
+  for (const program of module.programs) {
+    declarations.claimId(program.id);
+    const entry = signatures.get(program.entry);
+    if (!entry || entry.owner || entry.parameters.length || entry.result)
+      reject("Program entry must be a parameterless void helper.");
+    if (names.has(program.name))
+      reject(`Duplicate program ${program.name}.`);
+    names.add(program.name);
+    entries.add(program.entry);
+  }
+  if (!module.programs.length)
+    reject("At least one program is required.");
+  const visited = new Set, active = new Set;
+  const visit = (id) => {
+    if (active.has(id))
+      reject("Recursive scan calls are prohibited.", signatures.get(id)?.span);
+    if (visited.has(id))
+      return;
+    active.add(id);
+    for (const child of edges.get(id) ?? []) {
+      if (entries.has(child))
+        reject("Program entries cannot be called as ordinary helpers.", signatures.get(id)?.span);
+      visit(child);
+    }
+    active.delete(id);
+    visited.add(id);
+  };
+  for (const fn of [...functions, ...normalizedBlocks])
+    visit(fn.id);
+  const routines = new Map([...functions, ...normalizedBlocks].map((fn) => [fn.id, fn]));
+  const variables = new Map([
+    ...module.variables,
+    ...functions.flatMap((fn) => [...fn.parameters, ...fn.locals]),
+    ...normalizedBlocks.flatMap((block) => [
+      ...block.inputs,
+      ...block.outputs,
+      ...block.state,
+      ...block.locals
+    ])
+  ].map((variable) => [variable.id, variable]));
+  const calledRoutine = (item) => {
+    if (item.kind === "invoke")
+      return item.function;
+    if (item.kind !== "blockUpdate")
+      return;
+    const variable = variables.get(item.instance);
+    return variable && instancedBlock(variable.type, types)?.block;
+  };
+  const nestedBodies = (item) => {
+    if (item.kind === "for")
+      return [item.body];
+    if (item.kind === "if")
+      return [item.then, item.else];
+    if (item.kind === "switch")
+      return [...item.cases.map((branch) => branch.body), item.fallback];
+    return [];
+  };
+  const writes = new Map;
+  const routineWrites = (id) => {
+    const cached = writes.get(id);
+    if (cached)
+      return cached;
+    const result = new Set;
+    const inspect = (body) => {
+      for (const item of body) {
+        if (item.kind === "assign")
+          result.add(item.root);
+        if (item.kind === "for")
+          result.add(item.counter);
+        if (item.kind === "invoke") {
+          if (item.destination)
+            result.add(item.destination);
+          for (const argument of item.arguments)
+            if (argument.kind === "borrow")
+              result.add(argument.place.root);
+        }
+        if (item.kind === "blockUpdate") {
+          for (const input of Object.values(item.inputs))
+            if (input.kind === "borrow")
+              result.add(input.place.root);
+        }
+        for (const nested of nestedBodies(item))
+          inspect(nested);
+      }
+    };
+    inspect(routines.get(id).body);
+    for (const child of edges.get(id) ?? [])
+      for (const root of routineWrites(child))
+        result.add(root);
+    writes.set(id, result);
+    return result;
+  };
+  const checkCalls = (body, counters) => {
+    for (const item of body) {
+      const called = calledRoutine(item);
+      if (called && [...counters].some((counter) => routineWrites(called).has(counter)))
+        reject("A called routine may mutate an active loop counter.", item.span);
+      const nestedCounters = item.kind === "for" ? new Set([...counters, item.counter]) : counters;
+      for (const nested of nestedBodies(item))
+        checkCalls(nested, nestedCounters);
+    }
+  };
+  for (const routine of routines.values())
+    checkCalls(routine.body, new Set);
+  const reachable = new Set;
+  const link = (id) => {
+    if (reachable.has(id))
+      return;
+    reachable.add(id);
+    for (const child of edges.get(id) ?? [])
+      link(child);
+    const owner = signatures.get(id)?.owner;
+    if (owner)
+      link(owner.block);
+    for (const method of functions.filter((fn) => fn.owner?.block === id))
+      link(method.id);
+    for (const instance of blocks.get(id)?.state.filter((variable) => variable.storage === "instance") ?? []) {
+      const type = instancedBlock(instance.type, types);
+      if (type)
+        link(type.block);
+    }
+  };
+  for (const entry of entries)
+    link(entry);
+  for (const variable of module.variables) {
+    const type = instancedBlock(variable.type, types);
+    if (type)
+      link(type.block);
+  }
+  const linkedFunctions = functions.filter((fn) => reachable.has(fn.id)), linkedBlocks = normalizedBlocks.filter((block) => reachable.has(block.id));
+  const usedTypes = new Set;
+  const useType = (id) => {
+    if (usedTypes.has(id))
+      return;
+    usedTypes.add(id);
+    const type = types.get(id);
+    if (type.kind === "record") {
+      for (const field of type.fields)
+        useType(field.type);
+    }
+    if (type.kind === "array") {
+      useType(type.element);
+      if (type.index)
+        useType(type.index);
+    }
+    if (type.kind === "enum")
+      useType(type.base);
+    if (type.kind === "block" && type.output)
+      useType(type.output);
+  };
+  types.forEach((type) => {
+    if (["bool", "integer", "bits", "float", "duration", "calendar"].includes(type.kind))
+      useType(type.id);
+  });
+  for (const variable of module.variables)
+    useType(variable.type);
+  for (const fn of linkedFunctions) {
+    if (fn.result)
+      useType(fn.result);
+    for (const variable of [...fn.parameters, ...fn.locals])
+      useType(variable.type);
+  }
+  for (const block of linkedBlocks) {
+    if (block.result)
+      useType(block.result);
+    for (const variable of [...block.inputs, ...block.outputs, ...block.state, ...block.locals]) {
+      useType(variable.type);
+    }
+  }
+  return {
+    types: module.types.filter((type) => usedTypes.has(type.id)),
+    variables: module.variables,
+    functions: linkedFunctions,
+    blocks: linkedBlocks,
+    programs: module.programs
+  };
+}
+
+// packages/compiler/ir/core.ts
+var verifiedModules = new WeakSet;
+function isVerifiedCore(value) {
+  return typeof value === "object" && value !== null && verifiedModules.has(value);
+}
+function freeze(value) {
+  if (typeof value !== "object" || value === null || Object.isFrozen(value))
+    return;
+  for (const child of Object.values(value))
+    freeze(child);
+  Object.freeze(value);
+}
+function normalizeModule(module) {
+  try {
+    const declarations = new ModuleDeclarations(module);
+    checkStaticAllocation(module, declarations);
+    const functions = [], blocks = [];
+    const edges = new Map;
+    for (const source of [...module.functions, ...module.blocks]) {
+      const normalized = new RoutineNormalizer(source, declarations).normalize();
+      edges.set(source.id, normalized.callees);
+      if ("inputs" in normalized.routine)
+        blocks.push(normalized.routine);
+      else
+        functions.push(normalized.routine);
+    }
+    const linked = linkModule(module, declarations, functions, blocks, edges);
+    const core = { ...structuredClone(linked), [verified]: true };
+    freeze(core);
+    verifiedModules.add(core);
+    return { core, diagnostics: [] };
+  } catch (cause) {
+    if (cause instanceof InvalidCore)
+      return { diagnostics: [cause.diagnostic] };
+    throw cause;
+  }
+}
+export {
+  aggregate,
+  aggregateIssue,
+  applyIntegerPolicy,
+  calendarLiteral,
+  canAssign,
+  comparisonOperators,
+  constantFits,
+  defaultValue,
+  domainConstantFits,
+  domainIssue,
+  durationLiteral,
+  error,
+  expressionIssue,
+  floatMaximum,
+  fold,
+  formatDiagnostic,
+  hasErrors,
+  instancedBlock,
+  integerRange,
+  integerType,
+  interval,
+  isVerifiedCore,
+  layoutIssue,
+  loopBounds,
+  loopIterations,
+  narrowRanges,
+  normalizeModule,
+  parseInteger,
+  placeType,
+  primitiveTypes,
+  saturateFloat,
+  scalarIssue,
+  standardBlocks,
+  valueFits,
+  valueRange,
+  wrapsNatively
+};
+
+//# debugId=56F86269D01021CE64756E2164756E21
+//# sourceMappingURL=ir.js.map