@tsplc/compiler 0.0.0-stage → 0.1.0

package/dist/ir.js.map

@@ -0,0 +1,22 @@
+{
+  "version": 3,
+  "sources": ["../ir/diagnostics.ts", "../ir/types.ts", "../ir/model.ts", "../ir/core-model.ts", "../ir/scalars.ts", "../ir/domains.ts", "../ir/aggregates.ts", "../ir/normalization-error.ts", "../ir/declarations.ts", "../ir/allocation.ts", "../ir/routine.ts", "../ir/link.ts", "../ir/core.ts"],
+  "sourcesContent": [
+    "export interface SourceSpan {\n  file: string;\n  start: number;\n  end: number;\n  line: number;\n  column: number;\n}\n\nexport interface Diagnostic {\n  origin: \"typescript\" | \"plc\" | \"config\" | \"backend\" | \"vendor\";\n  code: string;\n  severity: \"error\" | \"warning\";\n  message: string;\n  span?: SourceSpan;\n  notes?: readonly string[];\n  related?: readonly { span: SourceSpan; message: string }[];\n}\n\nexport function error(code: string, message: string, span?: SourceSpan): Diagnostic {\n  return { origin: \"plc\", code, severity: \"error\", message, ...(span && { span }) };\n}\n\nexport function hasErrors(diagnostics: readonly Diagnostic[]): boolean {\n  return diagnostics.some((diagnostic) => diagnostic.severity === \"error\");\n}\n\nexport function formatDiagnostic(diagnostic: Diagnostic, source?: string): string {\n  const { span } = diagnostic;\n  const location = span ? `${span.file}:${span.line}:${span.column}: ` : \"\";\n  let result = `${location}${diagnostic.code}: ${diagnostic.message}`;\n  if (source !== undefined && span) {\n    const line = source.split(/\\r?\\n/)[span.line - 1];\n    if (line !== undefined) {\n      const width = Math.max(1, Math.min(span.end - span.start, line.length - span.column + 2));\n      result += `\\n${span.line} | ${line}\\n${\" \".repeat(String(span.line).length + 3 + span.column - 1)}${\"^\".repeat(width)}`;\n    }\n  }\n  for (const related of diagnostic.related ?? []) {\n    result += `\\n  ${related.span.file}:${related.span.line}:${related.span.column}: ${related.message}`;\n  }\n  for (const note of diagnostic.notes ?? []) result += `\\n  ${note}`;\n  return result;\n}\n",
+    "export type TypeId = string;\nexport type SymbolId = string;\n\nexport interface Field {\n  name: string;\n  type: TypeId;\n  readonly: boolean;\n  mode?: \"inOut\";\n}\n\nexport type PlcType =\n  | { id: TypeId; kind: \"bool\" }\n  | { id: TypeId; kind: \"integer\"; bits: 8 | 16 | 32 | 64; signed: boolean }\n  | { id: TypeId; kind: \"bits\"; bits: 8 | 16 | 32 | 64 }\n  | { id: TypeId; kind: \"float\"; bits: 32 | 64 }\n  | { id: TypeId; kind: \"duration\" }\n  | { id: TypeId; kind: \"calendar\"; domain: \"date\" | \"timeOfDay\" | \"dateTime\" }\n  | { id: TypeId; kind: \"string\"; capacity: number; encoding: \"utf8\" | \"utf16\" }\n  | {\n      id: TypeId;\n      kind: \"array\";\n      element: TypeId;\n      length: number;\n      lowerBound: number;\n      /** `Record<Enum, T>`: the enum whose contiguous member values are the bounds and the only indexes. */\n      index?: TypeId;\n    }\n  | { id: TypeId; kind: \"record\"; fields: readonly Field[] }\n  | { id: TypeId; kind: \"enum\"; base: TypeId; members: readonly { name: string; value: string }[] }\n  | { id: TypeId; kind: \"block\"; block: SymbolId; output?: TypeId };\n\n/** The block allocated by a type: a block itself, or a fixed array of one. */\nexport const instancedBlock = (\n  id: TypeId,\n  types: ReadonlyMap<TypeId, PlcType>,\n): Extract<PlcType, { kind: \"block\" }> | undefined => {\n  const type = types.get(id);\n  const element = type?.kind === \"array\" ? types.get(type.element) : type;\n  return element?.kind === \"block\" ? element : undefined;\n};\n\nexport const primitiveTypes: readonly PlcType[] = [\n  { id: \"BOOL\", kind: \"bool\" },\n  ...(\n    [\n      [\"SINT\", \"USINT\", \"BYTE\", 8],\n      [\"INT\", \"UINT\", \"WORD\", 16],\n      [\"DINT\", \"UDINT\", \"DWORD\", 32],\n      [\"LINT\", \"ULINT\", \"LWORD\", 64],\n    ] as const\n  ).flatMap(([signed, unsigned, bitstring, bits]) => [\n    { id: signed, kind: \"integer\" as const, bits, signed: true },\n    { id: unsigned, kind: \"integer\" as const, bits, signed: false },\n    { id: bitstring, kind: \"bits\" as const, bits },\n  ]),\n  { id: \"REAL\", kind: \"float\", bits: 32 },\n  { id: \"LREAL\", kind: \"float\", bits: 64 },\n  { id: \"TIME\", kind: \"duration\" },\n  { id: \"DATE\", kind: \"calendar\", domain: \"date\" },\n  { id: \"TIME_OF_DAY\", kind: \"calendar\", domain: \"timeOfDay\" },\n  { id: \"DATE_AND_TIME\", kind: \"calendar\", domain: \"dateTime\" },\n];\n\nexport function integerRange(\n  type: Extract<PlcType, { kind: \"integer\" | \"bits\" }>,\n): readonly [bigint, bigint] {\n  const signed = type.kind === \"integer\" && type.signed;\n  const limit = 1n << BigInt(type.bits - (signed ? 1 : 0));\n  return signed ? [-limit, limit - 1n] : [0n, limit - 1n];\n}\n",
+    "import type { SourceSpan, Diagnostic } from \"./diagnostics.ts\";\nimport type { PlcType, SymbolId, TypeId } from \"./types.ts\";\n\nexport type Constant =\n  | { kind: \"bool\"; value: boolean }\n  | { kind: \"integer\"; value: string }\n  | { kind: \"float\"; value: number }\n  | { kind: \"duration\"; nanoseconds: string }\n  | { kind: \"calendar\"; value: string }\n  | { kind: \"string\"; value: string }\n  | { kind: \"array\"; items: readonly Constant[] }\n  | { kind: \"record\"; fields: Readonly<Record<string, Constant>> };\n\nexport interface Variable {\n  id: SymbolId;\n  name: string;\n  type: TypeId;\n  storage:\n    | \"module\"\n    | \"local\"\n    | \"parameter\"\n    | \"input\"\n    | \"output\"\n    | \"field\"\n    | \"instance\"\n    | \"constant\"\n    | \"blockOutput\";\n  mutable: boolean;\n  retain: boolean;\n  exported?: true;\n  exposure?: { name: string; version: string };\n  mode?: \"inOut\";\n  initial?: Constant;\n  span: SourceSpan;\n}\n\nexport interface Place {\n  root: SymbolId;\n  path: readonly ({ kind: \"field\"; name: string } | { kind: \"index\"; value: Expression })[];\n}\n\nexport type BinaryOperator =\n  | \"add\"\n  | \"subtract\"\n  | \"multiply\"\n  | \"divide\"\n  | \"remainder\"\n  | \"equal\"\n  | \"notEqual\"\n  | \"less\"\n  | \"lessEqual\"\n  | \"greater\"\n  | \"greaterEqual\"\n  | \"and\"\n  | \"or\"\n  | \"bitAnd\"\n  | \"bitOr\"\n  | \"bitXor\"\n  | \"shiftLeft\"\n  | \"shiftRight\";\n\nexport const comparisonOperators: ReadonlySet<BinaryOperator> = new Set([\n  \"equal\",\n  \"notEqual\",\n  \"less\",\n  \"lessEqual\",\n  \"greater\",\n  \"greaterEqual\",\n]);\n\nexport type Expression = { type: TypeId; span: SourceSpan } & (\n  | { kind: \"constant\"; value: Constant }\n  | { kind: \"load\"; place: Place }\n  | {\n      kind: \"unary\";\n      operator: \"not\" | \"negate\" | \"bitNot\" | \"timeToMilliseconds\" | \"clock\";\n      operand: Expression;\n    }\n  | {\n      kind: \"binary\";\n      operator: BinaryOperator;\n      left: Expression;\n      right: Expression;\n      policy?: \"wrap\" | \"saturate\";\n    }\n  | {\n      kind: \"call\";\n      function: SymbolId;\n      instance?: SymbolId;\n      index?: Expression;\n      arguments: readonly Expression[];\n    }\n  | { kind: \"conditional\"; condition: Expression; then: Expression; else: Expression }\n  | { kind: \"convert\"; operand: Expression; policy: \"exact\" | \"wrap\" | \"saturate\" }\n  | { kind: \"borrow\"; place: Place }\n  | { kind: \"length\"; operand: Expression }\n  | { kind: \"copy\"; operand: Expression }\n  | { kind: \"record\"; fields: Readonly<Record<string, Expression>> }\n  | { kind: \"array\"; items: readonly Expression[] }\n);\n\nexport type Statement = { span: SourceSpan } & (\n  | { kind: \"assign\"; destination: Place; value: Expression }\n  | { kind: \"if\"; condition: Expression; then: readonly Statement[]; else: readonly Statement[] }\n  | {\n      kind: \"switch\";\n      value: Expression;\n      cases: readonly { values: readonly Constant[]; body: readonly Statement[] }[];\n      fallback: readonly Statement[];\n    }\n  | {\n      kind: \"for\";\n      counter: SymbolId;\n      /** Existing storage remains observable after the loop exits. */\n      counterScope?: \"existing\";\n      start: Expression;\n      limit: Expression;\n      step: string;\n      exclusive?: true;\n      maxIterations: number;\n      body: readonly Statement[];\n    }\n  | {\n      kind: \"invoke\";\n      function: SymbolId;\n      instance?: SymbolId;\n      index?: Expression;\n      arguments: readonly Expression[];\n      destination?: Place;\n    }\n  | {\n      kind: \"blockUpdate\";\n      instance: SymbolId;\n      index?: Expression;\n      inputs: Readonly<Record<string, Expression>>;\n    }\n  | { kind: \"return\"; value?: Expression }\n  | { kind: \"break\" | \"continue\" }\n);\n\nexport interface MethodOwner {\n  block: SymbolId;\n  access: \"public\" | \"private\" | \"protected\";\n}\n\nexport interface PlcFunction {\n  owner?: MethodOwner;\n  id: SymbolId;\n  name: string;\n  parameters: readonly Variable[];\n  locals: readonly Variable[];\n  result?: TypeId;\n  /** A `@tsplc/compiler/math` helper, whose result range follows from its arguments' ranges. */\n  bounds?: MathHelper;\n  body: readonly Statement[];\n  span: SourceSpan;\n}\nexport type MathHelper = \"min\" | \"max\" | \"clamp\";\n\n// Native vendor blocks under their TypeScript names. Ports are [name, native name, type];\n// every output starts FALSE or T#0s, matching the vendor library blocks.\nconst timer = (input: string, output: string) =>\n  ({\n    inputs: [\n      [input, \"IN\", \"BOOL\"],\n      [\"duration\", \"PT\", \"TIME\"],\n    ],\n    outputs: [\n      [output, \"Q\", \"BOOL\"],\n      [\"elapsed\", \"ET\", \"TIME\"],\n    ],\n  }) as const;\nexport const standardBlocks = {\n  OnDelayTimer: { native: \"TON\", ...timer(\"enabled\", \"done\") },\n  OffDelayTimer: { native: \"TOF\", ...timer(\"enabled\", \"active\") },\n  PulseTimer: { native: \"TP\", ...timer(\"start\", \"active\") },\n  RisingEdge: {\n    native: \"R_TRIG\",\n    inputs: [[\"signal\", \"CLK\", \"BOOL\"]],\n    outputs: [[\"rose\", \"Q\", \"BOOL\"]],\n  },\n  FallingEdge: {\n    native: \"F_TRIG\",\n    inputs: [[\"signal\", \"CLK\", \"BOOL\"]],\n    outputs: [[\"fell\", \"Q\", \"BOOL\"]],\n  },\n  Blinker: {\n    native: \"Util.BLINK\",\n    inputs: [\n      [\"enabled\", \"ENABLE\", \"BOOL\"],\n      [\"offTime\", \"TIMELOW\", \"TIME\"],\n      [\"onTime\", \"TIMEHIGH\", \"TIME\"],\n    ],\n    outputs: [[\"on\", \"OUT\", \"BOOL\"]],\n  },\n} as const;\nexport type StandardBlock = keyof typeof standardBlocks;\n\nexport interface FunctionBlock {\n  id: SymbolId;\n  name: string;\n  inputs: readonly Variable[];\n  outputs: readonly Variable[];\n  state: readonly Variable[];\n  locals: readonly Variable[];\n  body: readonly Statement[];\n  result?: TypeId;\n  standard?: StandardBlock;\n  runtime?:\n    | { kind: \"mailbox\" }\n    | { kind: \"backgroundHost\" }\n    | { kind: \"rpc\"; path: string }\n    | {\n        kind: \"http\";\n        url: string;\n        method: \"GET\" | \"POST\" | \"PUT\" | \"PATCH\" | \"DELETE\";\n        json: boolean;\n      };\n  span: SourceSpan;\n}\n\nexport interface PlcProgram {\n  id: SymbolId;\n  name: string;\n  entry: SymbolId;\n  continuation?: { instance: string; file: string };\n  background?: { intervalNanoseconds: string; priority: number; mailbox: string; worker: string };\n}\n\nexport interface PlcModule {\n  types: readonly PlcType[];\n  variables: readonly Variable[];\n  functions: readonly PlcFunction[];\n  blocks: readonly FunctionBlock[];\n  programs: readonly PlcProgram[];\n}\n\nexport interface Task {\n  name: string;\n  intervalNanoseconds: string;\n  priority: number;\n  programs: readonly string[];\n}\n\nexport interface Deployment {\n  tasks: readonly Task[];\n}\n\nexport interface Artifact {\n  path: string;\n  content: string;\n}\n\nexport interface GeneratedObject {\n  parent?: SymbolId;\n  sourcePath?: string;\n  id: SymbolId;\n  kind: \"program\" | \"function\" | \"functionBlock\" | \"method\" | \"globalList\" | \"dataType\";\n  name: string;\n  declaration: string;\n  implementation?: string;\n}\n\nexport interface EmitResult {\n  artifacts: readonly Artifact[];\n  objects: readonly GeneratedObject[];\n  diagnostics: readonly Diagnostic[];\n}\n",
+    "import type { SourceSpan } from \"./diagnostics.ts\";\nimport type {\n  Variable,\n  Constant,\n  BinaryOperator,\n  FunctionBlock,\n  PlcProgram,\n  MethodOwner,\n} from \"./model.ts\";\nimport type { PlcType } from \"./types.ts\";\n\n// Core expressions contain no source-level calls. Their effects have already\n// become ordered statements, and every place has passed storage/bounds checks.\nexport type CorePath = readonly (\n  | { readonly kind: \"field\"; readonly name: string }\n  | { readonly kind: \"index\"; readonly value: CoreExpression }\n)[];\nexport interface CheckedPlace {\n  readonly root: string;\n  readonly path: CorePath;\n}\nexport type CoreExpression = { readonly type: string; readonly span: SourceSpan } & (\n  | { readonly kind: \"borrow\"; readonly place: CheckedPlace }\n  | { readonly kind: \"constant\"; readonly value: Constant }\n  | { readonly kind: \"load\"; readonly root: string; readonly path?: CorePath }\n  | {\n      readonly kind: \"unary\";\n      readonly operator: \"not\" | \"negate\" | \"bitNot\" | \"timeToMilliseconds\" | \"clock\";\n      readonly operand: CoreExpression;\n    }\n  | {\n      readonly kind: \"binary\";\n      readonly operator: BinaryOperator;\n      readonly left: CoreExpression;\n      readonly right: CoreExpression;\n      readonly policy?: \"wrap\" | \"saturate\";\n    }\n  | {\n      readonly kind: \"convert\";\n      readonly operand: CoreExpression;\n      readonly policy: \"exact\" | \"wrap\" | \"saturate\";\n    }\n);\nexport type CoreStatement = { readonly span: SourceSpan } & (\n  | {\n      readonly kind: \"assign\";\n      readonly root: string;\n      readonly path?: CorePath;\n      readonly value: CoreExpression;\n    }\n  | {\n      readonly kind: \"if\";\n      readonly condition: CoreExpression;\n      readonly then: readonly CoreStatement[];\n      readonly else: readonly CoreStatement[];\n    }\n  | {\n      readonly kind: \"switch\";\n      readonly value: CoreExpression;\n      readonly cases: readonly { values: readonly Constant[]; body: readonly CoreStatement[] }[];\n      readonly fallback: readonly CoreStatement[];\n    }\n  | {\n      readonly kind: \"for\";\n      readonly counter: string;\n      readonly counterScope?: \"existing\";\n      readonly start: Constant;\n      readonly limit: Constant;\n      readonly step: string;\n      readonly dynamic?: {\n        readonly start: CoreExpression;\n        readonly limit: CoreExpression;\n        readonly exclusive?: true;\n      };\n      readonly maxIterations: number;\n      readonly body: readonly CoreStatement[];\n    }\n  | {\n      readonly kind: \"invoke\";\n      readonly function: string;\n      readonly instance?: string;\n      readonly index?: CoreExpression;\n      readonly arguments: readonly CoreExpression[];\n      readonly destination?: string;\n    }\n  | {\n      readonly kind: \"blockUpdate\";\n      readonly instance: string;\n      readonly index?: CoreExpression;\n      readonly inputs: Readonly<Record<string, CoreExpression>>;\n    }\n  | { readonly kind: \"return\"; readonly value?: CoreExpression }\n  | { readonly kind: \"break\" | \"continue\" }\n);\nexport interface CoreFunction {\n  readonly owner?: MethodOwner;\n  readonly id: string;\n  readonly name: string;\n  readonly parameters: readonly Variable[];\n  readonly result?: string;\n  readonly locals: readonly Variable[];\n  readonly body: readonly CoreStatement[];\n  readonly span: SourceSpan;\n}\nexport interface CoreFunctionBlock extends Readonly<Omit<FunctionBlock, \"body\">> {\n  readonly body: readonly CoreStatement[];\n}\nexport const verified: unique symbol = Symbol(\"verified core\");\nexport interface VerifiedCoreModule {\n  readonly [verified]: true;\n  readonly types: readonly PlcType[];\n  readonly variables: readonly Variable[];\n  readonly functions: readonly CoreFunction[];\n  readonly blocks: readonly CoreFunctionBlock[];\n  readonly programs: readonly PlcProgram[];\n}\n",
+    "import {\n  comparisonOperators,\n  type Constant,\n  type Expression,\n  type MathHelper,\n  type Variable,\n} from \"./model.ts\";\nimport { integerRange, type PlcType } from \"./types.ts\";\n\nexport function integerType(type: PlcType): type is Extract<PlcType, { kind: \"integer\" | \"bits\" }> {\n  return type.kind === \"integer\" || type.kind === \"bits\";\n}\nexport function floatMaximum(type: Extract<PlcType, { kind: \"float\" }>): number {\n  return type.bits === 32 ? Math.fround((2 - 2 ** -23) * 2 ** 127) : Number.MAX_VALUE;\n}\n\nexport function saturateFloat(value: number, type: Extract<PlcType, { kind: \"float\" }>): number {\n  // Clamp before target rounding so a finite source cannot round to infinity.\n  // Comparisons leave signed zero intact; min/max substitution is unnecessary.\n  const maximum = floatMaximum(type);\n  const clipped = value < -maximum ? -maximum : value > maximum ? maximum : value;\n  return type.bits === 32 ? Math.fround(clipped) : clipped;\n}\n\nexport function parseInteger(text: string): bigint {\n  const clean = text.replaceAll(\"_\", \"\").replace(/n$/, \"\");\n  const negative = clean.startsWith(\"-\");\n  const unsigned = negative ? clean.slice(1) : clean;\n  if (/^0[xob]/i.test(unsigned)) return (negative ? -1n : 1n) * BigInt(unsigned);\n  const match = /^(\\d+)(?:\\.(\\d*))?(?:e([+-]?\\d+))?$/i.exec(unsigned);\n  if (!match) throw new Error(\"Expected an exact integer literal.\");\n  const fraction = match[2] ?? \"\";\n  const exponent = Number(match[3] ?? 0) - fraction.length;\n  if (!Number.isSafeInteger(exponent) || Math.abs(exponent) > 400)\n    throw new Error(\"Integer literal exponent is out of range.\");\n  let value = BigInt(match[1]! + fraction);\n  if (exponent >= 0) value *= 10n ** BigInt(exponent);\n  else {\n    const divisor = 10n ** BigInt(-exponent);\n    if (value % divisor) throw new Error(\"Integer literals cannot have a fractional part.\");\n    value /= divisor;\n  }\n  return negative ? -value : value;\n}\nexport function constantFits(value: Constant, type: PlcType): boolean {\n  if (type.kind === \"bool\") return value.kind === \"bool\" && typeof value.value === \"boolean\";\n  if (integerType(type)) {\n    if (value.kind !== \"integer\" || !/^(?:0|-?[1-9][0-9]*)$/.test(value.value)) return false;\n    const [minimum, maximum] = integerRange(type),\n      number = BigInt(value.value);\n    return number >= minimum && number <= maximum;\n  }\n  if (type.kind === \"float\")\n    return (\n      value.kind === \"float\" &&\n      Number.isFinite(value.value) &&\n      (type.bits === 64 || Object.is(Math.fround(value.value), value.value))\n    );\n  return false;\n}\nexport function canAssign(source: PlcType, destination: PlcType, value?: Constant): boolean {\n  if (value) {\n    if (source.kind !== destination.kind || !constantFits(value, destination)) return false;\n    if (\n      source.kind === \"float\" &&\n      destination.kind === \"float\" &&\n      source.bits > destination.bits &&\n      value.kind === \"float\"\n    )\n      return Object.is(Math.fround(value.value), value.value);\n    return true;\n  }\n  if (source.id === destination.id) return true;\n  if (source.kind === \"integer\" && destination.kind === \"integer\") {\n    const [fromMin, fromMax] = integerRange(source),\n      [toMin, toMax] = integerRange(destination);\n    return fromMin >= toMin && fromMax <= toMax;\n  }\n  return source.kind === \"float\" && destination.kind === \"float\" && source.bits <= destination.bits;\n}\nexport function fold(\n  expression: Expression,\n  variables: ReadonlyMap<string, Variable>,\n  types?: ReadonlyMap<string, PlcType>,\n): Constant | undefined {\n  if (expression.kind === \"constant\") return expression.value;\n  if (expression.kind === \"copy\") return fold(expression.operand, variables, types);\n  if (expression.kind === \"length\") {\n    const type = types?.get(expression.operand.type);\n    const receiver =\n      expression.operand.kind === \"load\" ? variables.get(expression.operand.place.root) : undefined;\n    const pure =\n      expression.operand.kind === \"load\" &&\n      expression.operand.place.path.every((segment) => segment.kind === \"field\") &&\n      Boolean(receiver?.initial || receiver?.storage === \"input\" || receiver?.storage === \"output\");\n    if (type?.kind === \"array\" && (pure || fold(expression.operand, variables, types)))\n      return { kind: \"integer\", value: String(type.length) };\n    return undefined;\n  }\n  if (expression.kind === \"record\") {\n    const fields: Record<string, Constant> = Object.create(null);\n    for (const [name, operand] of Object.entries(expression.fields)) {\n      const value = fold(operand, variables, types);\n      if (!value) return undefined;\n      fields[name] = value;\n    }\n    return { kind: \"record\", fields };\n  }\n  if (expression.kind === \"array\") {\n    const items = expression.items.map((item) => fold(item, variables, types));\n    return items.every((item): item is Constant => item !== undefined)\n      ? { kind: \"array\", items }\n      : undefined;\n  }\n  if (expression.kind === \"load\" && !expression.place.path.length) {\n    const variable = variables.get(expression.place.root);\n    return variable?.storage === \"constant\" ? variable.initial : undefined;\n  }\n  if (expression.kind === \"convert\") {\n    const value = fold(expression.operand, variables, types);\n    const target = types?.get(expression.type);\n    if (value?.kind === \"integer\" && target) {\n      if (integerType(target))\n        return {\n          kind: \"integer\",\n          value: String(\n            expression.policy === \"exact\"\n              ? BigInt(value.value)\n              : applyIntegerPolicy(BigInt(value.value), target, expression.policy),\n          ),\n        };\n      if (target.kind === \"float\")\n        return {\n          kind: \"float\",\n          value: target.bits === 32 ? Math.fround(Number(value.value)) : Number(value.value),\n        };\n    }\n    if (value?.kind === \"float\" && target?.kind === \"float\")\n      return {\n        kind: \"float\",\n        value:\n          expression.policy === \"saturate\"\n            ? saturateFloat(value.value, target)\n            : target.bits === 32\n              ? Math.fround(value.value)\n              : value.value,\n      };\n    return undefined;\n  }\n  if (expression.kind === \"unary\") {\n    const value = fold(expression.operand, variables, types);\n    if (value?.kind === \"duration\" && expression.operator === \"timeToMilliseconds\")\n      return { kind: \"integer\", value: String(BigInt(value.nanoseconds) / 1_000_000n) };\n    if (value?.kind === \"bool\" && expression.operator === \"not\")\n      return { kind: \"bool\", value: !value.value };\n    if (value?.kind === \"integer\" && expression.operator === \"bitNot\") {\n      const target = types?.get(expression.type);\n      if (target?.kind === \"bits\")\n        return {\n          kind: \"integer\",\n          value: String(applyIntegerPolicy(~BigInt(value.value), target, \"wrap\")),\n        };\n    }\n    if (value?.kind === \"integer\" && expression.operator === \"negate\")\n      return { kind: \"integer\", value: String(-BigInt(value.value)) };\n    if (value?.kind === \"float\" && expression.operator === \"negate\")\n      return { kind: \"float\", value: -value.value };\n  }\n  if (expression.kind === \"binary\") {\n    const left = fold(expression.left, variables, types),\n      right = fold(expression.right, variables, types);\n    if (!left || !right || left.kind !== right.kind) return undefined;\n    if (left.kind === \"bool\" && right.kind === \"bool\") {\n      if (expression.operator === \"and\") return { kind: \"bool\", value: left.value && right.value };\n      if (expression.operator === \"or\") return { kind: \"bool\", value: left.value || right.value };\n      if (expression.operator === \"equal\")\n        return { kind: \"bool\", value: left.value === right.value };\n      if (expression.operator === \"notEqual\")\n        return { kind: \"bool\", value: left.value !== right.value };\n    }\n    if (\n      (left.kind === \"integer\" && right.kind === \"integer\") ||\n      (left.kind === \"float\" && right.kind === \"float\") ||\n      (left.kind === \"duration\" && right.kind === \"duration\") ||\n      (left.kind === \"calendar\" && right.kind === \"calendar\") ||\n      (left.kind === \"string\" && right.kind === \"string\")\n    ) {\n      const a =\n        left.kind === \"integer\"\n          ? BigInt(left.value)\n          : left.kind === \"duration\"\n            ? BigInt(left.nanoseconds)\n            : left.value;\n      const b =\n        right.kind === \"integer\"\n          ? BigInt(right.value)\n          : right.kind === \"duration\"\n            ? BigInt(right.nanoseconds)\n            : right.value;\n      switch (expression.operator) {\n        case \"equal\":\n          return { kind: \"bool\", value: a === b };\n        case \"notEqual\":\n          return { kind: \"bool\", value: a !== b };\n        case \"less\":\n          return { kind: \"bool\", value: a < b };\n        case \"lessEqual\":\n          return { kind: \"bool\", value: a <= b };\n        case \"greater\":\n          return { kind: \"bool\", value: a > b };\n        case \"greaterEqual\":\n          return { kind: \"bool\", value: a >= b };\n      }\n      if (left.kind !== \"integer\" && left.kind !== \"float\") return undefined;\n      if (typeof a === \"bigint\" && typeof b === \"bigint\") {\n        let value: bigint;\n        switch (expression.operator) {\n          case \"add\":\n            value = a + b;\n            break;\n          case \"subtract\":\n            value = a - b;\n            break;\n          case \"multiply\":\n            value = a * b;\n            break;\n          case \"divide\":\n            if (b === 0n) return undefined;\n            value = a / b;\n            break;\n          case \"remainder\":\n            if (b === 0n) return undefined;\n            value = a % b;\n            break;\n          case \"bitAnd\":\n            value = a & b;\n            break;\n          case \"bitOr\":\n            value = a | b;\n            break;\n          case \"bitXor\":\n            value = a ^ b;\n            break;\n          case \"shiftLeft\":\n            if (b < 0n || b > 63n) return undefined;\n            value = a << b;\n            break;\n          case \"shiftRight\":\n            if (b < 0n || b > 63n) return undefined;\n            value = a >> b;\n            break;\n          default:\n            return undefined;\n        }\n        const target = types?.get(expression.type);\n        if (target && integerType(target) && (expression.policy || target.kind === \"bits\"))\n          value = applyIntegerPolicy(value, target, expression.policy ?? \"wrap\");\n        return { kind: \"integer\", value: String(value) };\n      }\n      if (typeof a === \"number\" && typeof b === \"number\") {\n        let value: number;\n        switch (expression.operator) {\n          case \"add\":\n            value = a + b;\n            break;\n          case \"subtract\":\n            value = a - b;\n            break;\n          case \"multiply\":\n            value = a * b;\n            break;\n          case \"divide\":\n            value = a / b;\n            break;\n          case \"remainder\":\n            value = a % b;\n            break;\n          default:\n            return undefined;\n        }\n        return {\n          kind: \"float\",\n          value:\n            types?.get(expression.type)?.kind === \"float\" && expression.type === \"REAL\"\n              ? Math.fround(value)\n              : value,\n        };\n      }\n    }\n  }\n  return undefined;\n}\nexport type IntegerInterval = readonly [bigint, bigint];\nexport function interval(\n  expression: Expression,\n  types: ReadonlyMap<string, PlcType>,\n  variables: ReadonlyMap<string, Variable>,\n  ranges: ReadonlyMap<string, IntegerInterval> = new Map(),\n): IntegerInterval | undefined {\n  if (expression.kind === \"length\") {\n    const array = types.get(expression.operand.type);\n    if (array?.kind === \"array\") return [BigInt(array.length), BigInt(array.length)];\n  }\n  const value = fold(expression, variables, types);\n  if (value?.kind === \"integer\") return [BigInt(value.value), BigInt(value.value)];\n  const type = types.get(expression.type);\n  if (!type || !integerType(type)) return undefined;\n  if (expression.kind === \"load\") return ranges.get(expression.place.root) ?? integerRange(type);\n  if (expression.kind === \"convert\")\n    return expression.policy === \"exact\"\n      ? interval(expression.operand, types, variables, ranges)\n      : integerRange(type);\n  if (expression.kind === \"unary\" && expression.operator === \"negate\") {\n    const operand = interval(expression.operand, types, variables, ranges);\n    return operand && [-operand[1], -operand[0]];\n  }\n  if (expression.kind === \"binary\" && !expression.policy) {\n    const a = interval(expression.left, types, variables, ranges),\n      b = interval(expression.right, types, variables, ranges);\n    if (!a || !b) return undefined;\n    const [minimum, maximum] = integerRange(type);\n    const unwrapped = (low: bigint, high: bigint): [bigint, bigint] =>\n      low < minimum || high > maximum ? [minimum, maximum] : [low, high];\n    switch (expression.operator) {\n      case \"add\":\n        return unwrapped(a[0] + b[0], a[1] + b[1]);\n      case \"subtract\":\n        return unwrapped(a[0] - b[1], a[1] - b[0]);\n      case \"multiply\": {\n        const values = [a[0] * b[0], a[0] * b[1], a[1] * b[0], a[1] * b[1]];\n        return unwrapped(\n          values.reduce((x, y) => (x < y ? x : y)),\n          values.reduce((x, y) => (x > y ? x : y)),\n        );\n      }\n      case \"divide\": {\n        if (b[0] <= 0n && b[1] >= 0n) return undefined;\n        const values = [a[0] / b[0], a[0] / b[1], a[1] / b[0], a[1] / b[1]];\n        return [values.reduce((x, y) => (x < y ? x : y)), values.reduce((x, y) => (x > y ? x : y))];\n      }\n      case \"remainder\": {\n        if (b[0] <= 0n && b[1] >= 0n) return undefined;\n        const maximum =\n          [b[0], b[1]].map((n) => (n < 0n ? -n : n)).reduce((x, y) => (x > y ? x : y)) - 1n;\n        return [a[0] < 0n ? -maximum : 0n, a[1] > 0n ? maximum : 0n];\n      }\n    }\n  }\n  return integerRange(type);\n}\n// FOR iterations from first to last inclusive; step is nonzero.\nexport function loopIterations(first: bigint, last: bigint, step: bigint): bigint {\n  if (step > 0n) return last >= first ? (last - first) / step + 1n : 0n;\n  return last <= first ? (first - last) / -step + 1n : 0n;\n}\nexport function loopBounds(\n  start: IntegerInterval,\n  limit: IntegerInterval,\n  step: bigint,\n  exclusive = false,\n) {\n  const first = step > 0n ? start[0] : start[1];\n  const last = step > 0n ? limit[1] - (exclusive ? 1n : 0n) : limit[0] + (exclusive ? 1n : 0n);\n  const count = loopIterations(first, last, step);\n  const range: IntegerInterval = first <= last ? [first, last] : [last, first];\n  return { first, last, count, range };\n}\n\n// Only storage no statement can change carries branch refinements: loop counters,\n// by-value parameters and const locals, so the proof survives through the branch.\nexport function narrowRanges(\n  condition: Expression,\n  truth: boolean,\n  types: ReadonlyMap<string, PlcType>,\n  variables: ReadonlyMap<string, Variable>,\n  ranges: ReadonlyMap<string, IntegerInterval>,\n): Map<string, IntegerInterval> {\n  const narrowed = new Map(ranges);\n  if (condition.kind !== \"binary\") return narrowed;\n  if (condition.operator === \"and\")\n    return truth\n      ? narrowRanges(\n          condition.right,\n          truth,\n          types,\n          variables,\n          narrowRanges(condition.left, truth, types, variables, ranges),\n        )\n      : narrowed;\n  if (condition.left.kind !== \"load\" || condition.left.place.path.length) return narrowed;\n  const root = condition.left.place.root,\n    variable = variables.get(root),\n    type = types.get(condition.left.type),\n    fixed =\n      variable &&\n      ((variable.storage === \"parameter\" && !variable.mode) ||\n        (variable.storage === \"local\" && !variable.mutable)),\n    current =\n      ranges.get(root) ?? (fixed && type && integerType(type) ? integerRange(type) : undefined),\n    bound = interval(condition.right, types, variables, ranges);\n  if (!current || !bound || bound[0] !== bound[1]) return narrowed;\n  const value = bound[0];\n  let lower = current[0],\n    upper = current[1];\n  switch (condition.operator) {\n    case \"less\":\n      if (truth) upper = value - 1n < upper ? value - 1n : upper;\n      else lower = value > lower ? value : lower;\n      break;\n    case \"lessEqual\":\n      if (truth) upper = value < upper ? value : upper;\n      else lower = value + 1n > lower ? value + 1n : lower;\n      break;\n    case \"greater\":\n      if (truth) lower = value + 1n > lower ? value + 1n : lower;\n      else upper = value < upper ? value : upper;\n      break;\n    case \"greaterEqual\":\n      if (truth) lower = value > lower ? value : lower;\n      else upper = value - 1n < upper ? value - 1n : upper;\n      break;\n  }\n  if (lower <= upper) narrowed.set(root, [lower, upper]);\n  return narrowed;\n}\n\n/** Plain integer +, - and * are native IEC arithmetic, which wraps on overflow as hand-written ST does. */\nexport function wrapsNatively(expression: {\n  kind: string;\n  operator?: string;\n  policy?: string;\n}): boolean {\n  return (\n    expression.kind === \"binary\" &&\n    !expression.policy &&\n    (expression.operator === \"add\" ||\n      expression.operator === \"subtract\" ||\n      expression.operator === \"multiply\")\n  );\n}\n\nconst lowest = (a: bigint, b: bigint): bigint => (a < b ? a : b);\nconst highest = (a: bigint, b: bigint): bigint => (a > b ? a : b);\n\n/** A value's proved integer range; a math helper's result follows from its arguments. */\nexport function valueRange(\n  expression: Expression,\n  types: ReadonlyMap<string, PlcType>,\n  variables: ReadonlyMap<string, Variable>,\n  ranges: ReadonlyMap<string, IntegerInterval>,\n  functions: ReadonlyMap<string, { bounds?: MathHelper }>,\n): IntegerInterval | undefined {\n  if (expression.kind !== \"call\") return interval(expression, types, variables, ranges);\n  const helper = functions.get(expression.function)?.bounds;\n  return (\n    helper &&\n    mathHelperRange(\n      helper,\n      expression.arguments.map((argument) =>\n        valueRange(argument, types, variables, ranges, functions),\n      ),\n    )\n  );\n}\n\nfunction mathHelperRange(\n  helper: MathHelper,\n  [first, second, third]: readonly (IntegerInterval | undefined)[],\n): IntegerInterval | undefined {\n  if (!first || !second) return undefined;\n  if (helper === \"min\") return [lowest(first[0], second[0]), lowest(first[1], second[1])];\n  if (helper === \"max\") return [highest(first[0], second[0]), highest(first[1], second[1])];\n  // clamp(value, lower, upper) returns one of its three arguments, never outside lower..upper,\n  // and only lower or upper when the bounds are reversed.\n  if (!third) return undefined;\n  return [lowest(second[0], third[0]), highest(second[1], third[1])];\n}\n\nexport function applyIntegerPolicy(\n  value: bigint,\n  type: Extract<PlcType, { kind: \"integer\" | \"bits\" }>,\n  policy: \"wrap\" | \"saturate\",\n): bigint {\n  const [minimum, maximum] = integerRange(type);\n  if (policy === \"saturate\") return value < minimum ? minimum : value > maximum ? maximum : value;\n  return type.kind === \"integer\" && type.signed\n    ? BigInt.asIntN(type.bits, value)\n    : BigInt.asUintN(type.bits, value);\n}\n\nexport function scalarIssue(\n  expression: Expression,\n  types: ReadonlyMap<string, PlcType>,\n  variables: ReadonlyMap<string, Variable>,\n  ranges: ReadonlyMap<string, IntegerInterval> = new Map(),\n): string | undefined {\n  const type = types.get(expression.type);\n  if (!type || ![\"bool\", \"integer\", \"bits\", \"float\"].includes(type.kind))\n    return \"Unknown scalar expression type.\";\n  if (expression.kind === \"constant\")\n    return constantFits(expression.value, type)\n      ? undefined\n      : \"Literal is outside its PLC type or has the wrong domain.\";\n  if (expression.kind === \"load\" || expression.kind === \"call\") return undefined;\n  if (\n    (\"operand\" in expression && !types.has(expression.operand.type)) ||\n    (\"left\" in expression &&\n      (!types.has(expression.left.type) || !types.has(expression.right.type)))\n  )\n    return \"Unknown operand type.\";\n  // Operand types were checked above.\n  const operand = (value: Expression): PlcType => types.get(value.type)!;\n  if (expression.kind === \"convert\") {\n    if (![\"exact\", \"wrap\", \"saturate\"].includes(expression.policy))\n      return \"Unknown numeric conversion policy.\";\n    const source = operand(expression.operand),\n      value = fold(expression.operand, variables, types);\n    if (source.kind === \"bool\" || type.kind === \"bool\")\n      return \"Numeric conversions cannot use BOOL.\";\n    if (expression.policy === \"exact\") {\n      if (\n        canAssign(source, type, value) ||\n        (value && integerType(source) && integerType(type) && constantFits(value, type))\n      )\n        return undefined;\n      if (integerType(source) && type.kind === \"float\") {\n        if (value?.kind === \"integer\") {\n          const converted =\n            type.bits === 32 ? Math.fround(Number(value.value)) : Number(value.value);\n          if (\n            Number.isFinite(converted) &&\n            Number.isInteger(converted) &&\n            BigInt(converted) === BigInt(value.value)\n          )\n            return undefined;\n        }\n        const [minimum, maximum] =\n          interval(expression.operand, types, variables, ranges) ?? integerRange(source);\n        const limit = 1n << BigInt(type.bits === 32 ? 24 : 53);\n        if (minimum >= -limit && maximum <= limit) return undefined;\n      }\n      if (integerType(source) && integerType(type)) {\n        const [fromMin, fromMax] =\n            interval(expression.operand, types, variables, ranges) ?? integerRange(source),\n          [toMin, toMax] = integerRange(type);\n        if (fromMin >= toMin && fromMax <= toMax) return undefined;\n      }\n      return \"Exact conversion cannot be proved lossless.\";\n    }\n    if (expression.policy === \"saturate\" && source.kind === \"float\" && type.kind === \"float\")\n      return undefined;\n    return integerType(source) && integerType(type)\n      ? undefined\n      : expression.policy === \"saturate\"\n        ? \"Saturate conversions require two integer/bit-string operands or two floating operands.\"\n        : \"Wrap conversions require integer or bit-string operands.\";\n  }\n  if (expression.kind === \"unary\") {\n    const source = operand(expression.operand);\n    if (expression.operator === \"clock\")\n      return type.id === \"DINT\" ? undefined : \"now() returns DINT milliseconds.\";\n    if (expression.operator === \"timeToMilliseconds\")\n      return source.id === \"TIME\" && source.kind === \"duration\" && type.id === \"UDINT\"\n        ? undefined\n        : \"timeToMilliseconds requires TIME and returns UDINT.\";\n    if (expression.operator === \"not\")\n      return type.kind === \"bool\" && source.kind === \"bool\"\n        ? undefined\n        : \"Logical negation requires BOOL.\";\n    if (expression.operator === \"bitNot\")\n      return type.kind === \"bits\" && source.id === type.id\n        ? undefined\n        : \"Bitwise complement requires a bit string.\";\n    if (source.id !== type.id || !(type.kind === \"integer\" || type.kind === \"float\"))\n      return \"Numeric negation requires one arithmetic type.\";\n  } else if (expression.kind === \"binary\") {\n    const left = operand(expression.left),\n      right = operand(expression.right);\n    if (expression.operator === \"and\" || expression.operator === \"or\")\n      return type.kind === \"bool\" && left.kind === \"bool\" && right.kind === \"bool\"\n        ? undefined\n        : \"Logical operators require BOOL.\";\n    if (comparisonOperators.has(expression.operator))\n      return type.kind === \"bool\" &&\n        left.id === right.id &&\n        [\"bool\", \"integer\", \"bits\", \"float\"].includes(left.kind) &&\n        (left.kind !== \"bool\" || [\"equal\", \"notEqual\"].includes(expression.operator))\n        ? undefined\n        : \"Comparison operands need the same PLC domain.\";\n    if ([\"bitAnd\", \"bitOr\", \"bitXor\", \"shiftLeft\", \"shiftRight\"].includes(expression.operator)) {\n      if (type.kind !== \"bits\" || left.id !== type.id)\n        return \"Bitwise operators require bit strings.\";\n      if (expression.operator === \"shiftLeft\" || expression.operator === \"shiftRight\") {\n        const count = fold(expression.right, variables, types);\n        return count?.kind === \"integer\" &&\n          BigInt(count.value) >= 0n &&\n          BigInt(count.value) < BigInt(type.bits)\n          ? undefined\n          : \"Shift count must be a compile-time integer within the bit width.\";\n      }\n      return right.id === type.id ? undefined : \"Bit-string widths differ.\";\n    }\n    if (\n      left.id !== type.id ||\n      right.id !== type.id ||\n      (type.kind !== \"integer\" && type.kind !== \"float\")\n    )\n      return \"Arithmetic operands need one integer or floating type.\";\n    if (expression.policy)\n      return type.kind === \"integer\" &&\n        [\"add\", \"subtract\", \"multiply\"].includes(expression.operator)\n        ? undefined\n        : \"Explicit arithmetic policies require integer addition, subtraction or multiplication.\";\n    if (\n      (expression.operator === \"divide\" || expression.operator === \"remainder\") &&\n      type.kind === \"integer\"\n    ) {\n      const divisor = interval(expression.right, types, variables, ranges);\n      if (!divisor || (divisor[0] <= 0n && divisor[1] >= 0n))\n        return \"Division requires a proved nonzero divisor.\";\n      const dividend = interval(expression.left, types, variables, ranges);\n      const [minimum] = integerRange(type);\n      if (\n        type.signed &&\n        dividend &&\n        dividend[0] <= minimum &&\n        divisor[0] <= -1n &&\n        divisor[1] >= -1n\n      )\n        return \"Signed minimum divided by -1 cannot be represented.\";\n    }\n  } else return \"Expression has not been reduced to a scalar operation.\";\n  if (integerType(type)) {\n    const result = interval(expression, types, variables, ranges),\n      [minimum, maximum] = integerRange(type);\n    if (\n      !(wrapsNatively(expression) && !fold(expression, variables, types)) &&\n      (!result || result[0] < minimum || result[1] > maximum)\n    )\n      return \"Arithmetic may overflow; widen the result or use an explicit wrap/saturate operation.\";\n  } else if (type.kind === \"float\") {\n    const result = fold(expression, variables, types);\n    if (result)\n      return constantFits(result, type)\n        ? undefined\n        : \"Floating result is not finite or representable.\";\n    if (expression.kind === \"binary\") {\n      const lhs = fold(expression.left, variables, types);\n      const rhs = fold(expression.right, variables, types);\n      if (\n        [\"add\", \"subtract\"].includes(expression.operator) &&\n        (lhs?.kind === \"float\" || rhs?.kind === \"float\")\n      ) {\n        // Addition/subtraction and nearest rounding are monotone. Checking both\n        // finite endpoints proves every finite input without changing its arithmetic.\n        const maximum = floatMaximum(type);\n        const finite = [-maximum, maximum].every((endpoint) => {\n          const a = lhs?.kind === \"float\" ? lhs.value : endpoint;\n          const b = rhs?.kind === \"float\" ? rhs.value : endpoint;\n          const value = expression.operator === \"add\" ? a + b : a - b;\n          return Number.isFinite(type.bits === 32 ? Math.fround(value) : value);\n        });\n        if (finite) return undefined;\n      }\n      if (\n        rhs?.kind === \"float\" &&\n        rhs.value === 1 &&\n        [\"multiply\", \"divide\"].includes(expression.operator)\n      )\n        return undefined;\n    } else if (expression.kind === \"unary\") return undefined;\n    return \"Floating arithmetic must prove a finite result.\";\n  }\n  return undefined;\n}\n",
+    "import { comparisonOperators, type Constant, type Expression } from \"./model.ts\";\nimport type { PlcType } from \"./types.ts\";\n\nexport function durationLiteral(text: string, scaleNanoseconds: bigint): Constant | undefined {\n  const clean = text.replaceAll(\"_\", \"\").replace(/^(-?)\\./, (_, sign: string) => `${sign}0.`);\n  const match = /^(-?)(\\d+)(?:\\.(\\d*))?(?:e([+-]?\\d+))?$/i.exec(clean);\n  if (!match) return undefined;\n  const fraction = match[3] ?? \"\",\n    exponent = Number(match[4] ?? 0) - fraction.length;\n  if (!Number.isSafeInteger(exponent) || Math.abs(exponent) > 400) return undefined;\n  let value = BigInt(match[2]! + fraction) * scaleNanoseconds;\n  if (exponent >= 0) value *= 10n ** BigInt(exponent);\n  else {\n    const divisor = 10n ** BigInt(-exponent);\n    if (value % divisor) return undefined;\n    value /= divisor;\n  }\n  if (match[1]) value = -value;\n  return validDuration(value) ? { kind: \"duration\", nanoseconds: String(value) } : undefined;\n}\n// TIME stores unsigned 32-bit milliseconds.\nfunction validDuration(nanoseconds: bigint): boolean {\n  return (\n    nanoseconds >= 0n && nanoseconds <= 4_294_967_295_000_000n && nanoseconds % 1_000_000n === 0n\n  );\n}\nfunction validDate(text: string): boolean {\n  const match = /^(\\d{4})-(\\d{2})-(\\d{2})$/.exec(text);\n  if (!match) return false;\n  const year = Number(match[1]),\n    month = Number(match[2]),\n    day = Number(match[3]);\n  const leap = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);\n  const length = [31, leap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][month - 1];\n  return Boolean(\n    length && day >= 1 && day <= length && text >= \"1970-01-01\" && text <= \"2106-02-07\",\n  );\n}\nfunction validClock(text: string, milliseconds: boolean): boolean {\n  const match = (\n    milliseconds ? /^(\\d{2}):(\\d{2}):(\\d{2})\\.(\\d{3})$/ : /^(\\d{2}):(\\d{2}):(\\d{2})$/\n  ).exec(text);\n  return Boolean(match && Number(match[1]) < 24 && Number(match[2]) < 60 && Number(match[3]) < 60);\n}\nexport function calendarLiteral(\n  domain: Extract<PlcType, { kind: \"calendar\" }>[\"domain\"],\n  text: string,\n): Constant | undefined {\n  if (domain === \"date\") return validDate(text) ? { kind: \"calendar\", value: text } : undefined;\n  if (domain === \"timeOfDay\") {\n    const canonical = /^\\d{2}:\\d{2}:\\d{2}$/.test(text) ? `${text}.000` : text;\n    return validClock(canonical, true) ? { kind: \"calendar\", value: canonical } : undefined;\n  }\n  return text.length === 19 &&\n    text[10] === \"T\" &&\n    validDate(text.slice(0, 10)) &&\n    validClock(text.slice(11), false) &&\n    text <= \"2106-02-07T06:28:15\"\n    ? { kind: \"calendar\", value: text }\n    : undefined;\n}\nexport function domainConstantFits(value: Constant, type: PlcType): boolean {\n  if (type.kind === \"duration\")\n    return (\n      value.kind === \"duration\" &&\n      /^(?:0|[1-9][0-9]*)$/.test(value.nanoseconds) &&\n      validDuration(BigInt(value.nanoseconds))\n    );\n  if (type.kind === \"calendar\" && value.kind === \"calendar\") {\n    const parsed = calendarLiteral(type.domain, value.value);\n    return parsed?.kind === \"calendar\" && parsed.value === value.value;\n  }\n  return false;\n}\nexport function domainIssue(\n  value: Expression,\n  types: ReadonlyMap<string, PlcType>,\n): string | undefined {\n  const type = types.get(value.type);\n  if (value.kind === \"constant\")\n    return type && domainConstantFits(value.value, type)\n      ? undefined\n      : \"Invalid TIME/calendar constant.\";\n  if (value.kind === \"load\" || value.kind === \"call\" || value.kind === \"conditional\")\n    return undefined;\n  if (value.kind === \"binary\" && comparisonOperators.has(value.operator)) {\n    const left = types.get(value.left.type);\n    return value.type === \"BOOL\" &&\n      left &&\n      [\"duration\", \"calendar\"].includes(left.kind) &&\n      value.left.type === value.right.type\n      ? undefined\n      : \"Time comparisons require matching domains.\";\n  }\n  return \"TIME and calendar domains permit storage, typed copies and comparisons; implicit numeric arithmetic is unsupported.\";\n}\n",
+    "import {\n  comparisonOperators,\n  type Constant,\n  type Expression,\n  type Variable,\n  type Place,\n} from \"./model.ts\";\nimport { constantFits, interval, scalarIssue, type IntegerInterval } from \"./scalars.ts\";\nimport { domainConstantFits, domainIssue } from \"./domains.ts\";\nimport { primitiveTypes, type PlcType } from \"./types.ts\";\n\nexport function aggregate(type: PlcType | undefined): boolean {\n  return type?.kind === \"record\" || type?.kind === \"array\";\n}\nexport function valueFits(\n  value: Constant,\n  type: PlcType,\n  types: ReadonlyMap<string, PlcType>,\n): boolean {\n  if (type.kind === \"duration\" || type.kind === \"calendar\") return domainConstantFits(value, type);\n  if (type.kind === \"enum\")\n    return value.kind === \"integer\" && type.members.some((member) => member.value === value.value);\n  if (type.kind === \"string\")\n    return (\n      value.kind === \"string\" &&\n      !value.value.includes(\"\\0\") &&\n      (type.encoding === \"utf8\"\n        ? new TextEncoder().encode(value.value).length <= type.capacity\n        : value.value.length <= type.capacity)\n    );\n  if (type.kind === \"array\")\n    return (\n      value.kind === \"array\" &&\n      value.items.length === type.length &&\n      value.items.every((item) => valueFits(item, types.get(type.element)!, types))\n    );\n  if (type.kind === \"record\")\n    return (\n      value.kind === \"record\" &&\n      Object.keys(value.fields).length === type.fields.length &&\n      type.fields.every(\n        (field) =>\n          Object.hasOwn(value.fields, field.name) &&\n          valueFits(value.fields[field.name]!, types.get(field.type)!, types),\n      )\n    );\n  return constantFits(value, type);\n}\nexport function defaultValue(typeId: string, types: ReadonlyMap<string, PlcType>): Constant {\n  const type = types.get(typeId);\n  if (!type) throw new Error(\"Unknown default-value type\");\n  if (type.kind === \"bool\") return { kind: \"bool\", value: false };\n  if (type.kind === \"float\") return { kind: \"float\", value: 0 };\n  if (type.kind === \"string\") return { kind: \"string\", value: \"\" };\n  if (type.kind === \"enum\")\n    return {\n      kind: \"integer\",\n      value: type.members.find((member) => member.value === \"0\")?.value ?? type.members[0]!.value,\n    };\n  if (type.kind === \"array\")\n    return {\n      kind: \"array\",\n      items: Array.from({ length: type.length }, () => defaultValue(type.element, types)),\n    };\n  if (type.kind === \"record\")\n    return {\n      kind: \"record\",\n      fields: Object.fromEntries(\n        type.fields.map((field) => [field.name, defaultValue(field.type, types)]),\n      ),\n    };\n  if (type.kind === \"duration\") return { kind: \"duration\", nanoseconds: \"0\" };\n  if (type.kind === \"calendar\")\n    return {\n      kind: \"calendar\",\n      value:\n        type.domain === \"date\"\n          ? \"1970-01-01\"\n          : type.domain === \"timeOfDay\"\n            ? \"00:00:00.000\"\n            : \"1970-01-01T00:00:00\",\n    };\n  if (type.kind === \"integer\" || type.kind === \"bits\") return { kind: \"integer\", value: \"0\" };\n  throw new Error(\"Unsupported default-value type\");\n}\nexport function placeType(\n  place: Place,\n  types: ReadonlyMap<string, PlcType>,\n  variables: ReadonlyMap<string, Variable>,\n  ranges: ReadonlyMap<string, IntegerInterval> = new Map(),\n  writable = false,\n): { type?: string; issue?: string } {\n  const root = variables.get(place.root);\n  if (!root) return { issue: \"Unknown storage root.\" };\n  if (\n    writable &&\n    (root.storage === \"input\" ||\n      root.storage === \"constant\" ||\n      root.storage === \"blockOutput\" ||\n      (root.storage === \"parameter\" && root.mode !== \"inOut\") ||\n      (!place.path.length && !root.mutable))\n  )\n    return { issue: \"This storage is read-only.\" };\n  let id = root.type;\n  for (const segment of place.path) {\n    const type = types.get(id);\n    if (segment.kind === \"field\") {\n      if (type?.kind === \"block\" && segment.name === \"out\" && type.output) {\n        if (writable) return { issue: \"Function block output views are read-only.\" };\n        id = type.output;\n        continue;\n      }\n      if (type?.kind !== \"record\") return { issue: \"Field access requires a record.\" };\n      const field = type.fields.find((field) => field.name === segment.name);\n      if (!field) return { issue: \"Unknown record field.\" };\n      if (writable && field.readonly) return { issue: \"This field is read-only.\" };\n      id = field.type;\n    } else {\n      if (type?.kind !== \"array\") return { issue: \"Index access requires a fixed array.\" };\n      // Enum values are closed, and the layout check below proves its members are the bounds.\n      // An integer, such as a for…of counter, still needs its bounds proof.\n      if (type.index && segment.value.type === type.index) {\n        id = type.element;\n        continue;\n      }\n      const indexType = types.get(segment.value.type),\n        bounds = interval(segment.value, types, variables, ranges);\n      if (\n        indexType?.kind !== \"integer\" ||\n        !bounds ||\n        bounds[0] < BigInt(type.lowerBound) ||\n        bounds[1] >= BigInt(type.lowerBound + type.length)\n      )\n        return { issue: \"Array index must be proved within the declared bounds.\" };\n      id = type.element;\n    }\n  }\n  return { type: id };\n}\nexport function aggregateIssue(\n  value: Expression,\n  types: ReadonlyMap<string, PlcType>,\n): string | undefined {\n  const type = types.get(value.type);\n  if (!type) return \"Unknown expression type.\";\n  if (value.kind === \"constant\")\n    return valueFits(value.value, type, types)\n      ? undefined\n      : \"Constant does not fit its closed PLC layout.\";\n  if (value.kind === \"record\")\n    return type.kind === \"record\" &&\n      Object.keys(value.fields).length === type.fields.length &&\n      type.fields.every(\n        (field) =>\n          Object.hasOwn(value.fields, field.name) && value.fields[field.name]?.type === field.type,\n      )\n      ? undefined\n      : \"Record expression differs from its layout.\";\n  if (value.kind === \"array\")\n    return type.kind === \"array\" &&\n      value.items.length === type.length &&\n      value.items.every((item) => item.type === type.element)\n      ? undefined\n      : \"Array expression differs from its layout.\";\n  if (value.kind === \"copy\")\n    return aggregate(type) && value.operand.type === value.type\n      ? undefined\n      : \"Copy requires one matching fixed aggregate.\";\n  if (value.kind === \"convert\") {\n    const source = types.get(value.operand.type);\n    return type.kind === \"string\" &&\n      source?.kind === \"string\" &&\n      source.encoding === type.encoding &&\n      source.capacity <= type.capacity &&\n      value.policy === \"exact\"\n      ? undefined\n      : \"Unsupported aggregate/domain conversion.\";\n  }\n  if (value.kind === \"load\" || value.kind === \"call\" || value.kind === \"conditional\")\n    return undefined;\n  if (value.kind === \"binary\" && comparisonOperators.has(value.operator)) {\n    const left = types.get(value.left.type);\n    return value.type === \"BOOL\" &&\n      left &&\n      [\"enum\", \"string\"].includes(left.kind) &&\n      value.left.type === value.right.type &&\n      (left.kind !== \"enum\" || [\"equal\", \"notEqual\"].includes(value.operator))\n      ? undefined\n      : \"Comparison requires compatible scalar domains; object identity is unsupported.\";\n  }\n  return \"Operation is unsupported for this PLC domain.\";\n}\n\n// Route a reduced expression to the checker that owns its PLC domain. A binary\n// operation belongs to its operand domain, e.g. a TIME comparison yields BOOL.\nexport function expressionIssue(\n  value: Expression,\n  types: ReadonlyMap<string, PlcType>,\n  variables: ReadonlyMap<string, Variable>,\n  ranges: ReadonlyMap<string, IntegerInterval>,\n): string | undefined {\n  const kinds = [value.type, ...(value.kind === \"binary\" ? [value.left.type] : [])].map(\n    (id) => types.get(id)?.kind ?? \"\",\n  );\n  if (kinds.some((kind) => [\"duration\", \"calendar\"].includes(kind)))\n    return domainIssue(value, types);\n  if (\n    [\"copy\", \"record\", \"array\"].includes(value.kind) ||\n    kinds.some((kind) => [\"record\", \"array\", \"enum\", \"string\"].includes(kind))\n  )\n    return aggregateIssue(value, types);\n  return scalarIssue(value, types, variables, ranges);\n}\n\n// Validate all layout edges once before constants or places can traverse them.\nexport function layoutIssue(types: ReadonlyMap<string, PlcType>): string | undefined {\n  for (const type of types.values()) {\n    const canonical = primitiveTypes.find((item) => item.id === type.id);\n    if (canonical) {\n      if (\n        type.kind !== canonical.kind ||\n        (\"bits\" in canonical && (!(\"bits\" in type) || type.bits !== canonical.bits)) ||\n        (\"signed\" in canonical && (!(\"signed\" in type) || type.signed !== canonical.signed)) ||\n        (\"domain\" in canonical && (!(\"domain\" in type) || type.domain !== canonical.domain))\n      )\n        return `Conflicting primitive type ${type.id}`;\n      continue;\n    }\n    if (type.kind === \"record\") {\n      if (\n        !type.fields.length ||\n        new Set(type.fields.map((field) => field.name)).size !== type.fields.length ||\n        type.fields.some(\n          (field) =>\n            !field.name ||\n            typeof field.readonly !== \"boolean\" ||\n            (field.mode && field.mode !== \"inOut\") ||\n            !types.has(field.type),\n        )\n      )\n        return `Invalid closed record layout ${type.id}`;\n    } else if (type.kind === \"array\") {\n      if (\n        !types.has(type.element) ||\n        !Number.isSafeInteger(type.length) ||\n        type.length < 1 ||\n        type.length > 1_000_000 ||\n        !Number.isInteger(type.lowerBound) ||\n        type.lowerBound < -2147483648 ||\n        type.lowerBound + type.length - 1 > 2147483647\n      )\n        return `Invalid fixed array layout ${type.id}`;\n      if (type.index !== undefined) {\n        const index = types.get(type.index);\n        if (\n          index?.kind !== \"enum\" ||\n          index.members.length !== type.length ||\n          index.members.some(\n            (member) =>\n              Number(member.value) < type.lowerBound ||\n              Number(member.value) >= type.lowerBound + type.length,\n          )\n        )\n          return `Invalid enum-keyed array layout ${type.id}`;\n      }\n    } else if (type.kind === \"enum\") {\n      if (\n        type.base !== \"DINT\" ||\n        types.get(type.base)?.kind !== \"integer\" ||\n        !type.members.length ||\n        new Set(type.members.map((member) => member.name)).size !== type.members.length ||\n        new Set(type.members.map((member) => member.value)).size !== type.members.length ||\n        type.members.some(\n          (member) =>\n            !member.name ||\n            !constantFits({ kind: \"integer\", value: member.value }, types.get(type.base)!),\n        )\n      )\n        return `Invalid enum layout ${type.id}`;\n    } else if (type.kind === \"string\") {\n      if (\n        !Number.isInteger(type.capacity) ||\n        type.capacity < 1 ||\n        type.capacity > 65535 ||\n        ![\"utf8\", \"utf16\"].includes(type.encoding)\n      )\n        return `Invalid bounded string layout ${type.id}`;\n    } else if (type.kind === \"block\") {\n      if (!type.block || (type.output && types.get(type.output)?.kind !== \"record\"))\n        return `Invalid block type ${type.id}`;\n    } else return `Unsupported core type definition ${type.id}`;\n  }\n  const active = new Set<string>(),\n    layouts = new Map<string, { size: number; height: number }>();\n  const count = (id: string, depth: number): { size: number; height: number } => {\n    if (active.has(id) || depth > 64)\n      throw new Error(`Recursive or excessively nested by-value layout ${id}`);\n    const cached = layouts.get(id);\n    if (cached) {\n      if (depth + cached.height > 64) throw new Error(`Layout nesting exceeds 64 levels ${id}`);\n      return cached;\n    }\n    active.add(id);\n    const type = types.get(id)!;\n    const children =\n      type.kind === \"array\"\n        ? [count(type.element, depth + 1)]\n        : type.kind === \"record\"\n          ? type.fields.map((field) => count(field.type, depth + 1))\n          : [];\n    const size =\n      type.kind === \"array\"\n        ? type.length * children[0]!.size\n        : type.kind === \"record\"\n          ? children.reduce((sum, child) => sum + child.size, 0)\n          : 1;\n    const height = children.length\n      ? 1 + children.reduce((maximum, child) => Math.max(maximum, child.height), 0)\n      : 0;\n    active.delete(id);\n    if (size > 1_000_000) throw new Error(`Layout exceeds one million scalar elements ${id}`);\n    if (depth + height > 64) throw new Error(`Layout nesting exceeds 64 levels ${id}`);\n    const layout = { size, height };\n    layouts.set(id, layout);\n    return layout;\n  };\n  try {\n    for (const id of types.keys()) count(id, 0);\n  } catch (cause) {\n    return cause instanceof Error ? cause.message : \"Invalid layout\";\n  }\n  return undefined;\n}\n",
+    "import { error, type Diagnostic, type SourceSpan } from \"./diagnostics.ts\";\n\nexport class InvalidCore extends Error {\n  constructor(readonly diagnostic: Diagnostic) {\n    super(diagnostic.message);\n  }\n}\nexport function reject(message: string, span?: SourceSpan): never {\n  throw new InvalidCore(error(\"PLC6001\", message, span));\n}\n",
+    "import type { SourceSpan } from \"./diagnostics.ts\";\nimport {\n  standardBlocks,\n  type PlcModule,\n  type Variable,\n  type FunctionBlock,\n  type PlcFunction,\n} from \"./model.ts\";\nimport { instancedBlock, type PlcType } from \"./types.ts\";\nimport { layoutIssue, valueFits } from \"./aggregates.ts\";\nimport { reject } from \"./normalization-error.ts\";\n\n// This index owns the module namespace and storage declarations. Routine\n// lowering may claim temporary identifiers, but cannot weaken admission rules.\nexport class ModuleDeclarations {\n  private readonly ids = new Set<string>();\n  readonly types = new Map<string, PlcType>();\n  readonly globals = new Map<string, Variable>();\n  readonly blocks: Map<string, FunctionBlock>;\n  readonly signatures: Map<string, PlcFunction>;\n\n  constructor(module: PlcModule) {\n    for (const type of module.types) {\n      if (this.types.has(type.id)) reject(`Duplicate type ${type.id}.`);\n      this.types.set(type.id, type);\n    }\n    const invalidLayout = layoutIssue(this.types);\n    if (invalidLayout) reject(invalidLayout);\n    if (this.types.get(\"BOOL\")?.kind !== \"bool\") reject(\"Missing canonical BOOL type.\");\n\n    this.blocks = new Map(module.blocks.map((block) => [block.id, block]));\n    for (const item of module.variables) {\n      this.checkVariable(item, [\"module\", \"instance\", \"input\", \"output\", \"constant\"]);\n      this.globals.set(item.id, item);\n    }\n\n    this.signatures = new Map(module.functions.map((fn) => [fn.id, fn]));\n    for (const fn of module.functions) {\n      this.claimId(fn.id, fn.span);\n      if (\n        fn.owner &&\n        (!this.blocks.has(fn.owner.block) ||\n          this.blocks.get(fn.owner.block)?.standard ||\n          ![\"public\", \"private\", \"protected\"].includes(fn.owner.access))\n      )\n        reject(\"Methods require a user block owner and a valid access modifier.\", fn.span);\n      if (fn.result && !this.isValueType(fn.result))\n        reject(\"Unknown or non-value function result type.\", fn.span);\n      for (const parameter of fn.parameters) {\n        this.checkVariable(parameter, [\"parameter\"], true);\n        if (parameter.mutable && !parameter.mode)\n          reject(\"Value parameters are readonly.\", parameter.span);\n      }\n      for (const local of fn.locals) this.checkVariable(local, [\"local\"]);\n    }\n\n    for (const block of module.blocks) {\n      this.claimId(block.id, block.span);\n      for (const input of block.inputs) {\n        this.checkVariable(input, [\"parameter\"], true);\n        if (!input.mode && input.mutable) reject(\"Value block inputs are readonly.\", input.span);\n      }\n      for (const output of block.outputs) this.checkVariable(output, [\"blockOutput\"]);\n      for (const state of block.state) this.checkVariable(state, [\"field\", \"instance\"]);\n      for (const local of block.locals) this.checkVariable(local, [\"local\"]);\n      for (const ports of [block.inputs, block.outputs]) {\n        if (new Set(ports.map((variable) => variable.name)).size !== ports.length)\n          reject(\n            \"Block input and output names must each be unique within their schema.\",\n            block.span,\n          );\n      }\n      const result = block.result ? this.types.get(block.result) : undefined;\n      if (\n        block.outputs.length\n          ? result?.kind !== \"record\" ||\n            !this.isValueType(result.id) ||\n            result.fields.length !== block.outputs.length ||\n            result.fields.some(\n              (field) =>\n                !block.outputs.some(\n                  (output) => output.name === field.name && output.type === field.type,\n                ),\n            )\n          : Boolean(block.result)\n      )\n        reject(\"Block output schema differs from its result record.\", block.span);\n      if (block.standard) {\n        const expected = Object.hasOwn(standardBlocks, block.standard)\n          ? standardBlocks[block.standard]\n          : undefined;\n        const matches = (\n          variables: readonly Variable[],\n          schema: readonly (readonly [string, string, string])[],\n        ): boolean =>\n          variables.length === schema.length &&\n          schema.every(([name, , type]) =>\n            variables.some(\n              (variable) =>\n                variable.name === name &&\n                variable.type === type &&\n                !variable.mode &&\n                !variable.retain,\n            ),\n          );\n        if (\n          !expected ||\n          block.name !== block.standard ||\n          block.body.length ||\n          block.state.length ||\n          block.locals.length ||\n          !matches(block.inputs, expected.inputs) ||\n          !matches(block.outputs, expected.outputs) ||\n          block.outputs.some((output) =>\n            output.type === \"BOOL\"\n              ? output.initial?.kind !== \"bool\" || output.initial.value !== false\n              : output.initial?.kind !== \"duration\" || output.initial.nanoseconds !== \"0\",\n          )\n        )\n          reject(\"Invalid canonical standard block definition.\", block.span);\n      }\n    }\n\n    for (const type of this.types.values())\n      if (type.kind === \"block\") {\n        const definition = this.blocks.get(type.block);\n        if (!definition || definition.result !== type.output)\n          reject(\"Block type differs from its definition.\");\n      }\n  }\n\n  hasId(id: string): boolean {\n    return this.ids.has(id);\n  }\n\n  public claimId(id: string, span?: SourceSpan): void {\n    if (this.ids.has(id)) reject(`Duplicate symbol ${id}.`, span);\n    this.ids.add(id);\n  }\n\n  public isValueType(id: string, seen = new Set<string>()): boolean {\n    if (seen.has(id)) return true;\n    seen.add(id);\n    const type = this.types.get(id);\n    return Boolean(\n      type &&\n      type.kind !== \"block\" &&\n      (type.kind !== \"record\" ||\n        type.fields.every((field) => !field.mode && this.isValueType(field.type, seen))) &&\n      (type.kind !== \"array\" || this.isValueType(type.element, seen)),\n    );\n  }\n\n  private checkVariable(\n    item: Variable,\n    storage: readonly Variable[\"storage\"][],\n    allowBorrow = false,\n  ): void {\n    this.claimId(item.id, item.span);\n    const type = this.types.get(item.type);\n    if (!type || !storage.includes(item.storage))\n      reject(\"Invalid storage type or class.\", item.span);\n    if (\n      item.mode &&\n      (item.mode !== \"inOut\" || !allowBorrow || !item.mutable || item.storage !== \"parameter\")\n    )\n      reject(\"InOut belongs only on mutable parameters.\", item.span);\n    const mutableState =\n      item.mutable ||\n      type.kind === \"array\" ||\n      (type.kind === \"record\" && type.fields.some((field) => !field.readonly));\n    if (\n      item.retain &&\n      !(item.storage === \"instance\" || ([\"module\", \"field\"].includes(item.storage) && mutableState))\n    )\n      reject(\"Only mutable static state or block instances may retain.\", item.span);\n    if (item.storage === \"instance\") {\n      const instanced = instancedBlock(item.type, this.types);\n      if (!instanced || !this.blocks.has(instanced.block) || item.initial || item.mode)\n        reject(\n          \"Instances require a known static block and cannot have value initializers.\",\n          item.span,\n        );\n    } else if (\n      !this.isValueType(item.type) &&\n      !(allowBorrow && item.mode === \"inOut\" && type.kind === \"block\")\n    )\n      reject(\"Block instances and reference schemas cannot be stored as values.\", item.span);\n    if (item.storage === \"parameter\" && item.initial)\n      reject(\n        \"Inputs are supplied at each invocation and cannot have stored initializers.\",\n        item.span,\n      );\n    if (item.initial && !valueFits(item.initial, type, this.types))\n      reject(\"Initializer has the wrong type or is out of range.\", item.span);\n    if ([\"module\", \"field\", \"constant\", \"blockOutput\"].includes(item.storage) && !item.initial)\n      reject(\"Persistent storage requires initialization.\", item.span);\n    if ([\"input\", \"constant\", \"blockOutput\"].includes(item.storage) && item.mutable)\n      reject(\"Readonly storage marked mutable.\", item.span);\n  }\n}\n",
+    "import type { PlcModule } from \"./model.ts\";\nimport type { ModuleDeclarations } from \"./declarations.ts\";\nimport { reject } from \"./normalization-error.ts\";\nimport { instancedBlock } from \"./types.ts\";\n\nexport function checkStaticAllocation(module: PlcModule, declarations: ModuleDeclarations): void {\n  const { types, blocks } = declarations;\n\n  // Declaration admission closes these registries over every referenced type\n  // and block before allocation starts; a missing entry cannot be authored here.\n  // Static allocation is a separate graph from scan calls: even an unused child\n  // consumes memory, and a recursive child cannot be allocated by value.\n  const payloads = new Map<string, number>();\n  const payload = (id: string): number => {\n    const cached = payloads.get(id);\n    if (cached !== undefined) return cached;\n    const type = types.get(id)!;\n    const size =\n      type.kind === \"array\"\n        ? type.length * payload(type.element)\n        : type.kind === \"record\"\n          ? type.fields.reduce((sum, field) => sum + payload(field.type), 0)\n          : 1;\n    payloads.set(id, size);\n    return size;\n  };\n\n  const instanceSize = (id: string): number => {\n    const type = types.get(id)!;\n    return type.kind === \"array\"\n      ? type.length * instanceSize(type.element)\n      : allocation(type.kind === \"block\" ? type.block : \"\").size;\n  };\n  const allocations = new Map<string, { size: number; height: number }>(),\n    allocating = new Set<string>();\n  const allocation = (id: string): { size: number; height: number } => {\n    if (allocating.size >= 64)\n      reject(\"Static block allocation nesting exceeds 64 levels.\", blocks.get(id)?.span);\n    if (allocating.has(id)) reject(\"Recursive static block allocation.\", blocks.get(id)?.span);\n    const cached = allocations.get(id);\n    if (cached) return cached;\n    allocating.add(id);\n    const block = blocks.get(id)!;\n    const children = block.state\n      .filter((item) => item.storage === \"instance\")\n      .map((item) => ({\n        height: allocation(instancedBlock(item.type, types)!.block).height,\n        size: instanceSize(item.type),\n      }));\n    const own = [\n      ...block.inputs,\n      ...block.outputs,\n      ...block.state.filter((item) => item.storage !== \"instance\"),\n    ].reduce((sum, item) => sum + (item.mode === \"inOut\" ? 1 : payload(item.type)), 1);\n    const size = own + children.reduce((sum, child) => sum + child.size, 0),\n      height = children.length ? 1 + Math.max(...children.map((child) => child.height)) : 1;\n    if (size > 1_000_000 || height > 64)\n      reject(\"Static block allocation exceeds its finite budget.\", block.span);\n    allocating.delete(id);\n    const result = { size, height };\n    allocations.set(id, result);\n    return result;\n  };\n\n  for (const block of module.blocks) allocation(block.id);\n  const staticPayload = module.variables.reduce((sum, variable) => {\n    return (\n      sum +\n      (instancedBlock(variable.type, types) ? instanceSize(variable.type) : payload(variable.type))\n    );\n  }, 0);\n  if (staticPayload > 1_000_000)\n    reject(\"Static module storage exceeds one million scalar elements.\");\n}\n",
+    "import type { SourceSpan } from \"./diagnostics.ts\";\nimport type {\n  Variable,\n  Expression,\n  Statement,\n  Place,\n  PlcFunction,\n  FunctionBlock,\n} from \"./model.ts\";\nimport type {\n  CoreExpression,\n  CoreStatement,\n  CorePath,\n  CoreFunction,\n  CoreFunctionBlock,\n} from \"./core-model.ts\";\nimport {\n  fold,\n  interval,\n  loopBounds,\n  narrowRanges,\n  valueRange,\n  type IntegerInterval,\n} from \"./scalars.ts\";\nimport { instancedBlock, integerRange } from \"./types.ts\";\nimport { aggregate, expressionIssue, placeType, valueFits } from \"./aggregates.ts\";\nimport { reject } from \"./normalization-error.ts\";\nimport type { ModuleDeclarations } from \"./declarations.ts\";\n\ntype Flow = \"fallthrough\" | \"return\" | \"loop\" | \"mixed\";\ninterface BodyResult {\n  body: CoreStatement[];\n  initialized: Set<string>;\n  flow: Flow;\n}\n\n// Only paths that reach the next statement participate in a join. A local is\n// definitely initialized when every such path initialized it; branches that\n// return or leave the loop do not constrain it.\nfunction join(\n  branches: readonly BodyResult[],\n  initialized: Set<string>,\n): { flow: Flow; initialized: Set<string> } {\n  const falling = branches.filter((branch) => branch.flow === \"fallthrough\");\n  if (falling.length)\n    return {\n      flow: \"fallthrough\",\n      initialized: new Set(\n        [...falling[0]!.initialized].filter((id) =>\n          falling.every((branch) => branch.initialized.has(id)),\n        ),\n      ),\n    };\n  const flow = branches[0]!.flow;\n  return { flow: branches.every((branch) => branch.flow === flow) ? flow : \"mixed\", initialized };\n}\n\n// All mutable lowering state belongs to one invocation of one authored routine.\n// sourceScope admits authored places; scope additionally contains captured temps.\nexport class RoutineNormalizer {\n  private readonly fn: PlcFunction;\n\n  private readonly block: FunctionBlock | undefined;\n  private readonly owner: FunctionBlock | undefined;\n\n  private readonly scope: Map<string, Variable>;\n\n  private readonly sourceScope: Map<string, Variable>;\n\n  private readonly locals: Variable[];\n\n  private readonly ranges = new Map<string, IntegerInterval>();\n\n  private readonly counters = new Set<string>();\n\n  private readonly callees = new Set<string>();\n\n  private temporaryCount = 0;\n\n  constructor(\n    routine: PlcFunction | FunctionBlock,\n    private readonly declarations: ModuleDeclarations,\n  ) {\n    this.block = \"inputs\" in routine ? routine : undefined;\n    this.owner =\n      this.block ??\n      (\"owner\" in routine && routine.owner\n        ? declarations.blocks.get(routine.owner.block)\n        : undefined);\n    const parameters = \"parameters\" in routine ? routine.parameters : routine.inputs;\n    this.fn = {\n      id: routine.id,\n      name: routine.name,\n      ...(\"owner\" in routine && routine.owner && { owner: routine.owner }),\n      parameters,\n      locals: routine.locals,\n      body: routine.body,\n      span: routine.span,\n      ...(routine.result && { result: routine.result }),\n    };\n    this.scope = new Map(declarations.globals);\n    for (const item of [\n      ...parameters,\n      ...(this.owner ? [...this.owner.state, ...this.owner.outputs] : []),\n      ...routine.locals,\n    ])\n      this.scope.set(item.id, item);\n    this.sourceScope = new Map(this.scope);\n    this.locals = [...routine.locals];\n  }\n\n  normalize(): { routine: CoreFunction | CoreFunctionBlock; callees: ReadonlySet<string> } {\n    if (this.block?.standard)\n      return { routine: { ...this.block, body: [] }, callees: this.callees };\n    const normalized = this.body(this.fn.body, new Set(this.fn.parameters.map((item) => item.id)));\n    if (this.fn.result && normalized.flow !== \"return\")\n      reject(\"A typed helper must return on every path.\", this.fn.span);\n    const routine = this.block\n      ? { ...this.block, locals: this.locals, body: normalized.body }\n      : { ...this.fn, locals: this.locals, body: normalized.body };\n    return { routine, callees: this.callees };\n  }\n\n  private temporary(type: string, span: SourceSpan): Variable {\n    let id: string;\n    do {\n      id = `${this.fn.id}:temporary:${this.temporaryCount++}`;\n    } while (this.declarations.hasId(id));\n    this.declarations.claimId(id);\n    const item: Variable = {\n      id,\n      name: `temporary_${this.temporaryCount}`,\n      type,\n      storage: \"local\",\n      mutable: true,\n      retain: false,\n      span,\n    };\n    this.scope.set(id, item);\n    this.locals.push(item);\n    return item;\n  }\n\n  private load(variable: Variable, span: SourceSpan): CoreExpression {\n    return { kind: \"load\", root: variable.id, type: variable.type, span };\n  }\n\n  private verifyCall(\n    id: string,\n    arguments_: readonly Expression[],\n    span: SourceSpan,\n    instance?: string,\n  ): PlcFunction {\n    const called = this.declarations.signatures.get(id);\n    if (!called || called.parameters.length !== arguments_.length)\n      reject(\"Unknown helper or wrong argument count.\", span);\n    if (called.owner) {\n      if (instance) {\n        const variable = this.sourceScope.get(instance);\n        const type = variable && instancedBlock(variable.type, this.declarations.types);\n        if (\n          (variable?.storage !== \"instance\" && variable?.mode !== \"inOut\") ||\n          type?.block !== called.owner.block\n        )\n          reject(\"Method calls require a matching static block instance.\", span);\n      } else if (this.owner?.id !== called.owner.block)\n        reject(\"An implicit method call requires its owning block scope.\", span);\n      if (called.owner.access !== \"public\" && this.owner?.id !== called.owner.block)\n        reject(\"Private and protected methods require their owning block scope.\", span);\n    } else if (instance) reject(\"Ordinary functions cannot have an instance receiver.\", span);\n    this.callees.add(id);\n    arguments_.forEach((argument, index) => {\n      if (argument.type !== called.parameters[index]?.type)\n        reject(\"Helper argument has the wrong PLC type.\", argument.span);\n    });\n    return called;\n  }\n\n  private expression(\n    value: Expression,\n    initialized: Set<string>,\n    output: CoreStatement[],\n    allowAggregateLoad = false,\n  ): CoreExpression {\n    const type = this.declarations.types.get(value.type);\n    if (!type || !this.declarations.isValueType(value.type))\n      reject(\"Unknown or non-value expression type.\", value.span);\n    if (value.kind === \"borrow\")\n      reject(\"Borrowed places are only valid in block update arguments.\", value.span);\n    const common = { type: value.type, span: value.span };\n    if (value.kind === \"length\") {\n      const array = this.declarations.types.get(value.operand.type);\n      if (array?.kind !== \"array\" || value.type !== \"DINT\")\n        reject(\"Length requires a fixed array and DINT result.\", value.span);\n      if (value.operand.kind === \"load\") {\n        const source = this.sourceScope.get(value.operand.place.root),\n          checked = placeType(\n            value.operand.place,\n            this.declarations.types,\n            this.sourceScope,\n            this.ranges,\n          );\n        if (\n          !source ||\n          checked.issue ||\n          checked.type !== value.operand.type ||\n          (source.storage === \"local\" && !initialized.has(source.id))\n        )\n          reject(checked.issue ?? \"Invalid array receiver.\", value.span);\n        this.normalizePath(value.operand.place, initialized, output);\n      } else this.expression(value.operand, initialized, output, true);\n      return {\n        ...common,\n        kind: \"constant\",\n        value: { kind: \"integer\", value: String(array.length) },\n      };\n    }\n    if (value.kind === \"conditional\") {\n      if (\n        value.condition.type !== \"BOOL\" ||\n        value.then.type !== value.type ||\n        value.else.type !== value.type\n      )\n        reject(\"Invalid conditional types.\", value.span);\n      const condition = this.expression(value.condition, initialized, output),\n        result = this.temporary(value.type, value.span);\n      const branch = (operand: Expression): CoreStatement[] => {\n        const statements: CoreStatement[] = [];\n        const evaluated = this.expression(operand, new Set(initialized), statements);\n        statements.push({ kind: \"assign\", root: result.id, value: evaluated, span: value.span });\n        return statements;\n      };\n      output.push({\n        kind: \"if\",\n        condition,\n        // biome-ignore lint/suspicious/noThenProperty: PLC branch data is an array, not a thenable callback.\n        then: branch(value.then),\n        else: branch(value.else),\n        span: value.span,\n      });\n      initialized.add(result.id);\n      return this.load(result, value.span);\n    }\n    if (value.kind === \"call\") {\n      const called = this.verifyCall(value.function, value.arguments, value.span, value.instance);\n      if (called.result !== value.type)\n        reject(\"Expression call requires a matching result type.\", value.span);\n      const index =\n        value.instance &&\n        this.instanceIndex(value.instance, value.index, initialized, output, value.span);\n      const arguments_ = this.arguments(called.parameters, value.arguments, initialized, output);\n      const result = this.temporary(value.type, value.span);\n      output.push({\n        kind: \"invoke\",\n        function: value.function,\n        ...(value.instance && { instance: value.instance }),\n        ...(index && { index }),\n        arguments: arguments_,\n        destination: result.id,\n        span: value.span,\n      });\n      initialized.add(result.id);\n      return this.load(result, value.span);\n    }\n    const issue = expressionIssue(value, this.declarations.types, this.scope, this.ranges);\n    if (issue) reject(issue, value.span);\n    switch (value.kind) {\n      case \"copy\":\n        return this.expression(value.operand, initialized, output, true);\n      case \"record\":\n      case \"array\": {\n        const result = this.temporary(value.type, value.span);\n        if (value.kind === \"record\") {\n          for (const [name, operand] of Object.entries(value.fields))\n            output.push({\n              kind: \"assign\",\n              root: result.id,\n              path: [{ kind: \"field\", name }],\n              value: this.expression(operand, initialized, output),\n              span: operand.span,\n            });\n        } else {\n          const array = this.declarations.types.get(value.type)!;\n          if (array.kind !== \"array\") reject(\"Invalid array construction.\", value.span);\n          value.items.forEach((operand, index) => {\n            output.push({\n              kind: \"assign\",\n              root: result.id,\n              path: [\n                {\n                  kind: \"index\",\n                  value: {\n                    kind: \"constant\",\n                    type: \"DINT\",\n                    value: { kind: \"integer\", value: String(array.lowerBound + index) },\n                    span: operand.span,\n                  },\n                },\n              ],\n              value: this.expression(operand, initialized, output),\n              span: operand.span,\n            });\n          });\n        }\n        initialized.add(result.id);\n        return this.load(result, value.span);\n      }\n      case \"constant\": {\n        if (!aggregate(type)) return { ...common, kind: \"constant\", value: value.value };\n        const result = this.temporary(value.type, value.span);\n        output.push({\n          kind: \"assign\",\n          root: result.id,\n          value: { ...common, kind: \"constant\", value: value.value },\n          span: value.span,\n        });\n        initialized.add(result.id);\n        return this.load(result, value.span);\n      }\n      case \"load\": {\n        const source = this.sourceScope.get(value.place.root),\n          checked = placeType(value.place, this.declarations.types, this.sourceScope, this.ranges);\n        if (!source || checked.issue || checked.type !== value.type)\n          reject(checked.issue ?? \"Invalid PLC load.\", value.span);\n        if (aggregate(type) && !allowAggregateLoad)\n          reject(\"Aggregate loads require explicit copy or a readonly value argument.\", value.span);\n        if (source.storage === \"local\" && !initialized.has(source.id))\n          reject(\"Local read before initialization.\", value.span);\n        // The virtual .out view is not a vendor record value. Snapshot its\n        // declared fields, rather than copying the whole FB instance.\n        const first = value.place.path[0];\n        if (\n          source.storage === \"instance\" &&\n          value.place.path.length === 1 &&\n          first?.kind === \"field\" &&\n          first.name === \"out\" &&\n          type.kind === \"record\"\n        ) {\n          const result = this.temporary(value.type, value.span);\n          for (const field of type.fields) {\n            const selected: Expression = {\n              kind: \"load\",\n              type: field.type,\n              place: {\n                root: source.id,\n                path: [...value.place.path, { kind: \"field\", name: field.name }],\n              },\n              span: value.span,\n            };\n            const captured = this.expression(selected, initialized, output, true);\n            output.push({\n              kind: \"assign\",\n              root: result.id,\n              path: [{ kind: \"field\", name: field.name }],\n              value: captured,\n              span: value.span,\n            });\n          }\n          initialized.add(result.id);\n          return this.load(result, value.span);\n        }\n        const path = this.normalizePath(value.place, initialized, output);\n        if (source.storage === \"constant\" && source.initial && !path.length)\n          return { ...common, kind: \"constant\", value: source.initial };\n        // Capture now, before a later operand can invoke an effectful helper.\n        const result = this.temporary(value.type, value.span);\n        output.push({\n          kind: \"assign\",\n          root: result.id,\n          value: { ...common, kind: \"load\", root: source.id, ...(path.length && { path }) },\n          span: value.span,\n        });\n        const bound = interval(value, this.declarations.types, this.scope, this.ranges);\n        if (bound) this.ranges.set(result.id, bound);\n        initialized.add(result.id);\n        return this.load(result, value.span);\n      }\n      case \"unary\": {\n        const operand = this.expression(value.operand, initialized, output),\n          constant = fold(value, this.scope, this.declarations.types);\n        return constant\n          ? { ...common, kind: \"constant\", value: constant }\n          : { ...common, kind: \"unary\", operator: value.operator, operand };\n      }\n      case \"convert\": {\n        const operand = this.expression(value.operand, initialized, output),\n          constant = fold(value, this.scope, this.declarations.types);\n        if (value.type === value.operand.type) return operand;\n        return constant\n          ? { ...common, kind: \"constant\", value: constant }\n          : { ...common, kind: \"convert\", operand, policy: value.policy };\n      }\n      case \"binary\": {\n        const left = this.expression(value.left, initialized, output);\n        if (value.operator === \"and\" || value.operator === \"or\") {\n          const result = this.temporary(\"BOOL\", value.span),\n            branch: CoreStatement[] = [];\n          output.push({ kind: \"assign\", root: result.id, value: left, span: value.span });\n          const right = this.expression(value.right, new Set(initialized), branch);\n          branch.push({ kind: \"assign\", root: result.id, value: right, span: value.span });\n          const condition: CoreExpression =\n            value.operator === \"and\"\n              ? this.load(result, value.span)\n              : {\n                  kind: \"unary\",\n                  operator: \"not\",\n                  operand: this.load(result, value.span),\n                  type: \"BOOL\",\n                  span: value.span,\n                };\n          output.push({\n            kind: \"if\",\n            condition,\n            // biome-ignore lint/suspicious/noThenProperty: PLC branch data is an array, not a thenable callback.\n            then: branch,\n            else: [],\n            span: value.span,\n          });\n          initialized.add(result.id);\n          return this.load(result, value.span);\n        }\n        const right = this.expression(value.right, initialized, output),\n          constant = fold(value, this.scope, this.declarations.types);\n        if (constant) return { ...common, kind: \"constant\", value: constant };\n        return {\n          ...common,\n          kind: \"binary\",\n          operator: value.operator,\n          left,\n          right,\n          ...(value.policy && { policy: value.policy }),\n        };\n      }\n    }\n  }\n\n  private normalizePath(place: Place, initialized: Set<string>, output: CoreStatement[]): CorePath {\n    // An index is evaluated and captured once, before later arguments can change\n    // its source storage. The resulting path denotes that selected cell.\n    return place.path.map((segment) =>\n      segment.kind === \"field\"\n        ? segment\n        : { kind: \"index\", value: this.expression(segment.value, initialized, output) },\n    );\n  }\n\n  private destination(\n    place: Place,\n    type: string,\n    initialized: Set<string>,\n    span: SourceSpan,\n  ): Variable {\n    const target = this.sourceScope.get(place.root),\n      initializing =\n        target?.storage === \"local\" && !initialized.has(place.root) && !place.path.length;\n    const checked = placeType(\n      place,\n      this.declarations.types,\n      this.sourceScope,\n      this.ranges,\n      !initializing,\n    );\n    if (!target || checked.issue || checked.type !== type || this.counters.has(place.root))\n      reject(checked.issue ?? \"Invalid assignment destination.\", span);\n    if (place.path.length && target.storage === \"local\" && !initialized.has(target.id))\n      reject(\"Initialize the whole aggregate before assigning fields.\", span);\n    return target;\n  }\n\n  private instanceIndex(\n    instance: string,\n    index: Expression | undefined,\n    initialized: Set<string>,\n    output: CoreStatement[],\n    span: SourceSpan,\n  ): CoreExpression | undefined {\n    if (!index) return undefined;\n    const checked = placeType(\n      { root: instance, path: [{ kind: \"index\", value: index }] },\n      this.declarations.types,\n      this.sourceScope,\n      this.ranges,\n    );\n    if (checked.issue) reject(checked.issue, span);\n    return this.expression(index, initialized, output);\n  }\n\n  private blockUpdate(\n    item: Extract<Statement, { kind: \"blockUpdate\" }>,\n    initialized: Set<string>,\n    output: CoreStatement[],\n  ): void {\n    const instance = this.sourceScope.get(item.instance),\n      type = instance && instancedBlock(instance.type, this.declarations.types);\n    const called = type && this.declarations.blocks.get(type.block);\n    if ((instance?.storage !== \"instance\" && instance?.mode !== \"inOut\") || !called)\n      reject(\"Updates require a statically allocated block instance.\", item.span);\n    const index = this.instanceIndex(item.instance, item.index, initialized, output, item.span);\n    const keys = Object.keys(item.inputs);\n    if (\n      keys.length !== called.inputs.length ||\n      called.inputs.some((input) => !Object.hasOwn(item.inputs, input.name))\n    )\n      reject(\"Block update must supply every named input exactly once.\", item.span);\n    this.callees.add(called.id);\n    const arguments_ = this.arguments(\n      keys.map((name) => called.inputs.find((input) => input.name === name)!),\n      keys.map((name) => item.inputs[name]!),\n      initialized,\n      output,\n    );\n    const inputs = Object.fromEntries(keys.map((name, index) => [name, arguments_[index]!]));\n    output.push({\n      kind: \"blockUpdate\",\n      instance: instance.id,\n      ...(index && { index }),\n      inputs,\n      span: item.span,\n    });\n  }\n\n  private arguments(\n    parameters: readonly Variable[],\n    values: readonly Expression[],\n    initialized: Set<string>,\n    output: CoreStatement[],\n  ): CoreExpression[] {\n    const arguments_: CoreExpression[] = [];\n    for (const [index, value] of values.entries()) {\n      const input = parameters[index]!;\n      if (value.type !== input.type)\n        reject(\"Block input differs from its concrete PLC type.\", value.span);\n      const block = this.declarations.types.get(value.type)?.kind === \"block\";\n      if (input.mode === \"inOut\" && value.kind !== \"borrow\") {\n        // A value with no writable address reaches the callee through a temporary.\n        if (block) reject(\"Pass a block instance by name.\", value.span);\n        const temporary = this.temporary(value.type, value.span);\n        output.push({\n          kind: \"assign\",\n          root: temporary.id,\n          value: this.expression(value, initialized, output),\n          span: value.span,\n        });\n        initialized.add(temporary.id);\n        arguments_.push({\n          kind: \"borrow\",\n          type: value.type,\n          place: { root: temporary.id, path: [] },\n          span: value.span,\n        });\n      } else if (input.mode === \"inOut\" && value.kind === \"borrow\") {\n        const root = this.sourceScope.get(value.place.root),\n          checked = placeType(\n            value.place,\n            this.declarations.types,\n            this.sourceScope,\n            this.ranges,\n            !block,\n          );\n        if (\n          !root ||\n          checked.issue ||\n          checked.type !== value.type ||\n          (!block && !this.declarations.isValueType(value.type)) ||\n          this.counters.has(root.id) ||\n          (root.storage === \"local\" && !initialized.has(root.id))\n        )\n          reject(\n            checked.issue ?? \"Borrow requires initialized mutable value storage of the exact type.\",\n            value.span,\n          );\n        arguments_.push({\n          kind: \"borrow\",\n          type: value.type,\n          place: {\n            root: value.place.root,\n            path: this.normalizePath(value.place, initialized, output),\n          },\n          span: value.span,\n        });\n      } else {\n        if (value.kind === \"borrow\")\n          reject(\"Readonly value inputs cannot receive borrowed references.\", value.span);\n        arguments_.push(this.expression(value, initialized, output, true));\n      }\n    }\n    return arguments_;\n  }\n\n  private body(\n    statements: readonly Statement[],\n    initialized: Set<string>,\n    inLoop = false,\n  ): BodyResult {\n    const output: CoreStatement[] = [];\n    let flow: Flow = \"fallthrough\";\n    for (const item of statements) {\n      if (flow !== \"fallthrough\") break;\n      switch (item.kind) {\n        case \"assign\": {\n          this.destination(item.destination, item.value.type, initialized, item.span);\n          const path = this.normalizePath(item.destination, initialized, output);\n          // A const is assigned once, so its initializer's range holds wherever it is read.\n          const bound =\n            !path.length &&\n            this.scope.get(item.destination.root)?.mutable === false &&\n            valueRange(\n              item.value,\n              this.declarations.types,\n              this.scope,\n              this.ranges,\n              this.declarations.signatures,\n            );\n          const value = this.expression(item.value, initialized, output);\n          if (bound) this.ranges.set(item.destination.root, bound);\n          if (!path.length) initialized.add(item.destination.root);\n          output.push({\n            kind: \"assign\",\n            root: item.destination.root,\n            ...(path.length && { path }),\n            value,\n            span: item.span,\n          });\n          break;\n        }\n        case \"blockUpdate\": {\n          this.blockUpdate(item, initialized, output);\n          break;\n        }\n        case \"invoke\": {\n          const called = this.verifyCall(item.function, item.arguments, item.span, item.instance);\n          if (item.destination) {\n            if (item.destination.path.length || !called.result)\n              reject(\"Invalid helper destination.\", item.span);\n            this.destination(item.destination, called.result, initialized, item.span);\n          }\n          const index =\n            item.instance &&\n            this.instanceIndex(item.instance, item.index, initialized, output, item.span);\n          // Each argument snapshots its reads before the next argument can invoke\n          // a helper that mutates shared state.\n          const arguments_ = this.arguments(called.parameters, item.arguments, initialized, output);\n          output.push({\n            kind: \"invoke\",\n            function: item.function,\n            ...(item.instance && { instance: item.instance }),\n            ...(index && { index }),\n            arguments: arguments_,\n            span: item.span,\n            ...(item.destination && { destination: item.destination.root }),\n          });\n          if (item.destination) initialized.add(item.destination.root);\n          break;\n        }\n        case \"if\": {\n          if (item.condition.type !== \"BOOL\") reject(\"Conditions require BOOL.\", item.span);\n          const condition = this.expression(item.condition, initialized, output);\n          const originalRanges = new Map(this.ranges);\n          const branch = (statements: readonly Statement[], truth: boolean) => {\n            this.ranges.clear();\n            for (const [root, range] of narrowRanges(\n              item.condition,\n              truth,\n              this.declarations.types,\n              this.sourceScope,\n              originalRanges,\n            ))\n              this.ranges.set(root, range);\n            try {\n              return this.body(statements, new Set(initialized), inLoop);\n            } finally {\n              this.ranges.clear();\n              for (const [root, range] of originalRanges) this.ranges.set(root, range);\n            }\n          };\n          const yes = branch(item.then, true),\n            no = branch(item.else, false);\n          ({ flow, initialized } = join([yes, no], initialized));\n          output.push({\n            kind: \"if\",\n            condition,\n            // biome-ignore lint/suspicious/noThenProperty: PLC branch data is an array, not a thenable callback.\n            then: yes.body,\n            else: no.body,\n            span: item.span,\n          });\n          break;\n        }\n        case \"switch\": {\n          const value = this.expression(item.value, initialized, output),\n            seen = new Set<string>();\n          const branches = item.cases.map((branch) => {\n            for (const constant of branch.values) {\n              if (\n                !valueFits(\n                  constant,\n                  this.declarations.types.get(item.value.type)!,\n                  this.declarations.types,\n                )\n              )\n                reject(\"Invalid case constant.\", item.span);\n              const key = JSON.stringify(constant);\n              if (seen.has(key)) reject(\"Duplicate case constant.\", item.span);\n              seen.add(key);\n            }\n            return {\n              values: branch.values,\n              result: this.body(branch.body, new Set(initialized), inLoop),\n            };\n          });\n          const fallback = this.body(item.fallback, new Set(initialized), inLoop);\n          ({ flow, initialized } = join(\n            [...branches.map((branch) => branch.result), fallback],\n            initialized,\n          ));\n          output.push({\n            kind: \"switch\",\n            value,\n            cases: branches.map((branch) => ({ values: branch.values, body: branch.result.body })),\n            fallback: fallback.body,\n            span: item.span,\n          });\n          break;\n        }\n        case \"for\": {\n          const counter = this.sourceScope.get(item.counter);\n          const counterType = counter && this.declarations.types.get(counter.type);\n          if (\n            !counter ||\n            !(item.counterScope === \"existing\"\n              ? [\"local\", \"module\", \"field\"].includes(counter.storage)\n              : counter.storage === \"local\") ||\n            !counter.mutable ||\n            counterType?.kind !== \"integer\" ||\n            this.counters.has(counter.id) ||\n            item.start.type !== counter.type ||\n            item.limit.type !== counter.type ||\n            !/^(-?[1-9][0-9]*)$/.test(item.step)\n          )\n            reject(\"Invalid bounded loop.\", item.span);\n          const start = fold(item.start, this.scope, this.declarations.types);\n          const limit = fold(item.limit, this.scope, this.declarations.types);\n          const startRange = interval(\n            item.start,\n            this.declarations.types,\n            this.sourceScope,\n            this.ranges,\n          );\n          const limitRange = interval(\n            item.limit,\n            this.declarations.types,\n            this.sourceScope,\n            this.ranges,\n          );\n          if (!startRange || !limitRange)\n            reject(\"Loop bounds require finite integer ranges.\", item.span);\n          const step = BigInt(item.step);\n          const proof = loopBounds(startRange, limitRange, step, item.exclusive);\n          const dynamic = start?.kind !== \"integer\" || limit?.kind !== \"integer\";\n          const first = proof.first,\n            last = proof.last,\n            count = proof.count;\n          if (\n            count > 1_000_000n ||\n            Number(count) !== item.maxIterations ||\n            !Number.isSafeInteger(item.maxIterations)\n          )\n            reject(\"Loop iteration proof differs from its bounds.\", item.span);\n          if (item.counterScope === \"existing\") {\n            const terminal = dynamic\n              ? (step > 0n ? proof.range[1] : proof.range[0]) + step\n              : first + count * step;\n            const [minimum, maximum] = integerRange(counterType);\n            if (count > 0n && (terminal < minimum || terminal > maximum))\n              reject(\"The existing loop counter overflows on termination.\", item.span);\n          }\n          const evaluatedStart = this.expression(item.start, initialized, output);\n          const evaluatedLimit = this.expression(item.limit, initialized, output);\n          initialized.add(counter.id);\n          this.counters.add(counter.id);\n          this.ranges.set(counter.id, proof.range);\n          const nested = this.body(item.body, new Set(initialized), true);\n          this.counters.delete(counter.id);\n          this.ranges.delete(counter.id);\n          if (item.counterScope !== \"existing\") initialized.delete(counter.id);\n          output.push({\n            kind: \"for\",\n            counter: counter.id,\n            ...(item.counterScope && { counterScope: item.counterScope }),\n            start: { kind: \"integer\", value: String(first) },\n            limit: { kind: \"integer\", value: String(last) },\n            ...(dynamic && {\n              dynamic: {\n                start: evaluatedStart,\n                limit: evaluatedLimit,\n                ...(item.exclusive && { exclusive: item.exclusive }),\n              },\n            }),\n            step: item.step,\n            maxIterations: item.maxIterations,\n            body: nested.body,\n            span: item.span,\n          });\n          break;\n        }\n        case \"return\": {\n          if (item.value?.type !== this.fn.result)\n            reject(\"Return differs from the function signature.\", item.span);\n          const value = item.value && this.expression(item.value, initialized, output);\n          output.push({ kind: \"return\", span: item.span, ...(value && { value }) });\n          flow = \"return\";\n          break;\n        }\n        case \"break\":\n        case \"continue\":\n          if (!inLoop) reject(\"Loop control appears outside a bounded loop.\", item.span);\n          output.push({ kind: item.kind, span: item.span });\n          flow = \"loop\";\n          break;\n        default:\n          reject(\"Unknown PLC statement.\");\n      }\n    }\n    return { body: output, initialized, flow };\n  }\n}\n",
+    "import type { PlcModule } from \"./model.ts\";\nimport type { CoreFunction, CoreFunctionBlock, CoreStatement } from \"./core-model.ts\";\nimport type { ModuleDeclarations } from \"./declarations.ts\";\nimport { reject } from \"./normalization-error.ts\";\nimport { instancedBlock } from \"./types.ts\";\n\n// Validate the complete authored call graph before pruning unreachable code.\n// Static instances keep their child layouts even when a child has no scan call.\nexport function linkModule(\n  module: PlcModule,\n  declarations: ModuleDeclarations,\n  functions: CoreFunction[],\n  normalizedBlocks: CoreFunctionBlock[],\n  edges: ReadonlyMap<string, ReadonlySet<string>>,\n) {\n  const { signatures, blocks, types } = declarations;\n  const names = new Set<string>(),\n    entries = new Set<string>();\n  for (const program of module.programs) {\n    declarations.claimId(program.id);\n    const entry = signatures.get(program.entry);\n    if (!entry || entry.owner || entry.parameters.length || entry.result)\n      reject(\"Program entry must be a parameterless void helper.\");\n    if (names.has(program.name)) reject(`Duplicate program ${program.name}.`);\n    names.add(program.name);\n    entries.add(program.entry);\n  }\n  if (!module.programs.length) reject(\"At least one program is required.\");\n\n  // Authored execution cycles are invalid even in unreachable routines. Static\n  // allocation has its own cycle check because it does not depend on scan calls.\n  const visited = new Set<string>(),\n    active = new Set<string>();\n  const visit = (id: string): void => {\n    if (active.has(id)) reject(\"Recursive scan calls are prohibited.\", signatures.get(id)?.span);\n    if (visited.has(id)) return;\n    active.add(id);\n    for (const child of edges.get(id) ?? []) {\n      if (entries.has(child))\n        reject(\"Program entries cannot be called as ordinary helpers.\", signatures.get(id)?.span);\n      visit(child);\n    }\n    active.delete(id);\n    visited.add(id);\n  };\n  for (const fn of [...functions, ...normalizedBlocks]) visit(fn.id);\n\n  // A bounded loop can only reconstruct its counter if called helpers leave\n  // that storage alone. Include transitive calls, not just direct assignments.\n  const routines = new Map([...functions, ...normalizedBlocks].map((fn) => [fn.id, fn]));\n  const variables = new Map(\n    [\n      ...module.variables,\n      ...functions.flatMap((fn) => [...fn.parameters, ...fn.locals]),\n      ...normalizedBlocks.flatMap((block) => [\n        ...block.inputs,\n        ...block.outputs,\n        ...block.state,\n        ...block.locals,\n      ]),\n    ].map((variable) => [variable.id, variable]),\n  );\n  const calledRoutine = (item: CoreStatement): string | undefined => {\n    if (item.kind === \"invoke\") return item.function;\n    if (item.kind !== \"blockUpdate\") return undefined;\n    const variable = variables.get(item.instance);\n    return variable && instancedBlock(variable.type, types)?.block;\n  };\n  const nestedBodies = (item: CoreStatement): readonly (readonly CoreStatement[])[] => {\n    if (item.kind === \"for\") return [item.body];\n    if (item.kind === \"if\") return [item.then, item.else];\n    if (item.kind === \"switch\") return [...item.cases.map((branch) => branch.body), item.fallback];\n    return [];\n  };\n  const writes = new Map<string, Set<string>>();\n  const routineWrites = (id: string): Set<string> => {\n    const cached = writes.get(id);\n    if (cached) return cached;\n    const result = new Set<string>();\n    const inspect = (body: readonly CoreStatement[]) => {\n      for (const item of body) {\n        if (item.kind === \"assign\") result.add(item.root);\n        if (item.kind === \"for\") result.add(item.counter);\n        if (item.kind === \"invoke\") {\n          if (item.destination) result.add(item.destination);\n          for (const argument of item.arguments)\n            if (argument.kind === \"borrow\") result.add(argument.place.root);\n        }\n        if (item.kind === \"blockUpdate\")\n          for (const input of Object.values(item.inputs))\n            if (input.kind === \"borrow\") result.add(input.place.root);\n        for (const nested of nestedBodies(item)) inspect(nested);\n      }\n    };\n    inspect(routines.get(id)!.body);\n    for (const child of edges.get(id) ?? [])\n      for (const root of routineWrites(child)) result.add(root);\n    writes.set(id, result);\n    return result;\n  };\n  const checkCalls = (body: readonly CoreStatement[], counters: ReadonlySet<string>) => {\n    for (const item of body) {\n      const called = calledRoutine(item);\n      if (called && [...counters].some((counter) => routineWrites(called).has(counter)))\n        reject(\"A called routine may mutate an active loop counter.\", item.span);\n      const nestedCounters = item.kind === \"for\" ? new Set([...counters, item.counter]) : counters;\n      for (const nested of nestedBodies(item)) checkCalls(nested, nestedCounters);\n    }\n  };\n  for (const routine of routines.values()) checkCalls(routine.body, new Set());\n\n  // Only after the complete graph is valid may emission discard unused helpers.\n  const reachable = new Set<string>();\n  const link = (id: string): void => {\n    if (reachable.has(id)) return;\n    reachable.add(id);\n    for (const child of edges.get(id) ?? []) link(child);\n    const owner = signatures.get(id)?.owner;\n    if (owner) link(owner.block);\n    for (const method of functions.filter((fn) => fn.owner?.block === id)) link(method.id);\n    for (const instance of blocks\n      .get(id)\n      ?.state.filter((variable) => variable.storage === \"instance\") ?? []) {\n      const type = instancedBlock(instance.type, types);\n      if (type) link(type.block);\n    }\n  };\n  for (const entry of entries) link(entry);\n  for (const variable of module.variables) {\n    const type = instancedBlock(variable.type, types);\n    if (type) link(type.block);\n  }\n  const linkedFunctions = functions.filter((fn) => reachable.has(fn.id)),\n    linkedBlocks = normalizedBlocks.filter((block) => reachable.has(block.id));\n\n  // Admission has already validated every referenced type; these lookups are\n  // closed over the declaration registry, including dependencies kept by DUTs.\n  const usedTypes = new Set<string>();\n  const useType = (id: string): void => {\n    if (usedTypes.has(id)) return;\n    usedTypes.add(id);\n    const type = types.get(id)!;\n    if (type.kind === \"record\") {\n      for (const field of type.fields) useType(field.type);\n    }\n    if (type.kind === \"array\") {\n      useType(type.element);\n      if (type.index) useType(type.index);\n    }\n    if (type.kind === \"enum\") useType(type.base);\n    if (type.kind === \"block\" && type.output) useType(type.output);\n  };\n  // Primitive definitions also support backend-generated numeric helpers.\n  types.forEach((type) => {\n    if ([\"bool\", \"integer\", \"bits\", \"float\", \"duration\", \"calendar\"].includes(type.kind))\n      useType(type.id);\n  });\n  for (const variable of module.variables) useType(variable.type);\n  for (const fn of linkedFunctions) {\n    if (fn.result) useType(fn.result);\n    for (const variable of [...fn.parameters, ...fn.locals]) useType(variable.type);\n  }\n  for (const block of linkedBlocks) {\n    if (block.result) useType(block.result);\n    for (const variable of [...block.inputs, ...block.outputs, ...block.state, ...block.locals]) {\n      useType(variable.type);\n    }\n  }\n  return {\n    types: module.types.filter((type) => usedTypes.has(type.id)),\n    variables: module.variables,\n    functions: linkedFunctions,\n    blocks: linkedBlocks,\n    programs: module.programs,\n  };\n}\n",
+    "import type { Diagnostic } from \"./diagnostics.ts\";\nimport type { PlcModule } from \"./model.ts\";\nimport {\n  verified,\n  type VerifiedCoreModule,\n  type CoreFunction,\n  type CoreFunctionBlock,\n} from \"./core-model.ts\";\nimport { ModuleDeclarations } from \"./declarations.ts\";\nimport { checkStaticAllocation } from \"./allocation.ts\";\nimport { RoutineNormalizer } from \"./routine.ts\";\nimport { linkModule } from \"./link.ts\";\nimport { InvalidCore } from \"./normalization-error.ts\";\n\nexport type {\n  CorePath,\n  CheckedPlace,\n  CoreExpression,\n  CoreStatement,\n  CoreFunction,\n  CoreFunctionBlock,\n  VerifiedCoreModule,\n} from \"./core-model.ts\";\n\nconst verifiedModules = new WeakSet<object>();\nexport function isVerifiedCore(value: unknown): value is VerifiedCoreModule {\n  return typeof value === \"object\" && value !== null && verifiedModules.has(value);\n}\n\nfunction freeze(value: unknown): void {\n  if (typeof value !== \"object\" || value === null || Object.isFrozen(value)) return;\n  for (const child of Object.values(value)) freeze(child);\n  Object.freeze(value);\n}\n// The module crosses the trust boundary only after admission, lowering and linking.\nexport function normalizeModule(module: PlcModule): {\n  core?: VerifiedCoreModule;\n  diagnostics: readonly Diagnostic[];\n} {\n  try {\n    const declarations = new ModuleDeclarations(module);\n    checkStaticAllocation(module, declarations);\n\n    const functions: CoreFunction[] = [],\n      blocks: CoreFunctionBlock[] = [];\n    const edges = new Map<string, ReadonlySet<string>>();\n    for (const source of [...module.functions, ...module.blocks]) {\n      const normalized = new RoutineNormalizer(source, declarations).normalize();\n      edges.set(source.id, normalized.callees);\n      if (\"inputs\" in normalized.routine) blocks.push(normalized.routine);\n      else functions.push(normalized.routine);\n    }\n\n    const linked = linkModule(module, declarations, functions, blocks, edges);\n    const core: VerifiedCoreModule = { ...structuredClone(linked), [verified]: true };\n    freeze(core);\n    verifiedModules.add(core);\n    return { core, diagnostics: [] };\n  } catch (cause) {\n    if (cause instanceof InvalidCore) return { diagnostics: [cause.diagnostic] };\n    throw cause;\n  }\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "56F86269D01021CE64756E2164756E21",
+  "names": []
+}

package/dist/math.js

@@ -0,0 +1,24 @@
+// packages/compiler/stdlib/math.ts
+function min(left, right) {
+  return left < right ? left : right;
+}
+function max(left, right) {
+  return left > right ? left : right;
+}
+function clamp(value, lower, upper) {
+  if (value < lower) {
+    return lower;
+  }
+  if (value > upper) {
+    return upper;
+  }
+  return value;
+}
+export {
+  clamp,
+  max,
+  min
+};
+
+//# debugId=BCABD3CAF678A65664756E2164756E21
+//# sourceMappingURL=math.js.map

package/dist/math.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../stdlib/math.ts"],
+  "sourcesContent": [
+    "// PLC implementation source: the frontend specializes these helpers for each\n// concrete scalar domain. The release includes this source for that analysis.\nexport function min<T extends number | bigint>(left: T, right: T): T {\n  return left < right ? left : right;\n}\n\nexport function max<T extends number | bigint>(left: T, right: T): T {\n  return left > right ? left : right;\n}\n\nexport function clamp<T extends number | bigint>(value: T, lower: T, upper: T): T {\n  if (value < lower) {\n    return lower;\n  }\n  if (value > upper) {\n    return upper;\n  }\n  return value;\n}\n"
+  ],
+  "mappings": ";AAEO,SAAS,GAA8B,CAAC,MAAS,OAAa;AAAA,EACnE,OAAO,OAAO,QAAQ,OAAO;AAAA;AAGxB,SAAS,GAA8B,CAAC,MAAS,OAAa;AAAA,EACnE,OAAO,OAAO,QAAQ,OAAO;AAAA;AAGxB,SAAS,KAAgC,CAAC,OAAU,OAAU,OAAa;AAAA,EAChF,IAAI,QAAQ,OAAO;AAAA,IACjB,OAAO;AAAA,EACT;AAAA,EACA,IAAI,QAAQ,OAAO;AAAA,IACjB,OAAO;AAAA,EACT;AAAA,EACA,OAAO;AAAA;",
+  "debugId": "BCABD3CAF678A65664756E2164756E21",
+  "names": []
+}