@tsplc/build 0.0.0-stage → 0.1.0

package/dist/cli.js

@@ -0,0 +1,1652 @@
+#!/usr/bin/env bun
+// @bun
+
+// packages/build/src/cli.ts
+import { parseArgs } from "util";
+import { deviceTree } from "@tsplc/typegen";
+import { loadHardware, resolveIo } from "@tsplc/typegen/hardware";
+import { controllerFor, loadTsplcConfig, rawBuildConfig } from "@tsplc/config";
+
+// packages/build/src/artifacts.ts
+import { copyFile, cp, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { z } from "zod";
+
+// packages/build/src/config.ts
+import {
+  configSchema,
+  controllerSchema,
+  cyclicTasksSchema,
+  dockerImage,
+  defineBuildConfig,
+  resolveConfig,
+  loadConfig
+} from "@tsplc/config/build";
+
+// packages/build/src/artifacts.ts
+var buildFiles = {
+  project: "Application.project",
+  output: "runtime/Application.app",
+  checksum: "runtime/Application.crc",
+  receipt: "build.json",
+  devices: "eds",
+  archive: "Application.projectarchive"
+};
+var receiptSchema = z.object({
+  mode: z.literal("build"),
+  application: z.string().regex(/^[A-Za-z_][A-Za-z_0-9]*$/),
+  tasks: cyclicTasksSchema.optional()
+});
+var readBuild = async (directory) => {
+  const receipt = receiptSchema.safeParse(JSON.parse(await readFile(resolve(directory, buildFiles.receipt), "utf8")));
+  if (!receipt.success) {
+    throw new Error("CODESYS did not produce a valid build receipt", {
+      cause: receipt.error
+    });
+  }
+  for (const file of [buildFiles.project, buildFiles.output, buildFiles.checksum]) {
+    const artifact = await stat(resolve(directory, file));
+    if (!artifact.isFile() || artifact.size === 0) {
+      throw new Error(`CODESYS produced an empty artifact: ${file}`);
+    }
+  }
+  return {
+    ...receipt.data,
+    directory,
+    project: resolve(directory, buildFiles.project),
+    output: resolve(directory, buildFiles.output),
+    checksum: resolve(directory, buildFiles.checksum)
+  };
+};
+
+// packages/build/src/docker-build.ts
+import { execFile } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { cp as cp3, mkdir as mkdir3, mkdtemp as mkdtemp2, readFile as readFile3, rm as rm3 } from "node:fs/promises";
+import { tmpdir as tmpdir2 } from "node:os";
+import { resolve as resolve5 } from "node:path";
+import { promisify } from "node:util";
+
+// packages/build/src/docker-context.ts
+import { cp as cp2, mkdir, mkdtemp, rm as rm2, writeFile as writeFile2 } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { tmpdir } from "node:os";
+import { dirname, resolve as resolve3 } from "node:path";
+
+// packages/build/src/package-path.ts
+import { resolve as resolve2 } from "node:path";
+import { fileURLToPath } from "node:url";
+var packageDirectory = resolve2(fileURLToPath(new URL("..", import.meta.url)));
+
+// packages/build/src/docker-context.ts
+async function prepareDockerContext() {
+  const context = await mkdtemp(resolve3(tmpdir(), "tsplc-docker-"));
+  try {
+    for (const directory of ["src", "python", "docker", "runtime"])
+      await cp2(resolve3(packageDirectory, directory), resolve3(context, directory), {
+        recursive: true
+      });
+    const configRoot = resolve3(dirname(createRequire(import.meta.url).resolve("@tsplc/config/build")), "..");
+    await mkdir(resolve3(context, "shared-config"));
+    await cp2(resolve3(configRoot, "src"), resolve3(context, "shared-config/src"), {
+      recursive: true
+    });
+    await cp2(resolve3(configRoot, "templates"), resolve3(context, "shared-config/templates"), {
+      recursive: true
+    });
+    await cp2(resolve3(configRoot, "package.json"), resolve3(context, "shared-config/package.json"));
+    await writeFile2(resolve3(context, "package.json"), JSON.stringify({ type: "module", dependencies: { zod: "4.3.6", jiti: "2.7.0" } }));
+    return context;
+  } catch (cause) {
+    await rm2(context, { recursive: true, force: true });
+    throw cause;
+  }
+}
+
+// packages/build/src/diagnostics.ts
+import { z as z2 } from "zod";
+var compilerDiagnosticSchema = z2.object({
+  category: z2.string(),
+  text: z2.string(),
+  severity: z2.string().nullable(),
+  project: z2.string().nullable(),
+  object: z2.object({
+    name: z2.string(),
+    guid: z2.string(),
+    path: z2.array(z2.string()),
+    isApplicationChild: z2.boolean().nullable()
+  }).passthrough().nullable(),
+  position: z2.string().nullable(),
+  positionText: z2.string().nullable(),
+  positionOffset: z2.int().nullable(),
+  length: z2.int().nullable(),
+  prefix: z2.string().nullable(),
+  number: z2.int().nullable()
+}).passthrough();
+
+class CodesysCompilerError extends Error {
+  diagnostics;
+  constructor(message, diagnostics) {
+    super(message);
+    this.diagnostics = diagnostics;
+    this.name = "CodesysCompilerError";
+  }
+}
+var buildFailureFile = ".codesys/docker/failure.json";
+var buildFailureSchema = z2.strictObject({
+  operationId: z2.uuid(),
+  message: z2.string(),
+  diagnostics: z2.array(compilerDiagnosticSchema)
+});
+
+// packages/build/src/docker-run.ts
+import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile3 } from "node:fs/promises";
+import { basename, posix, relative, resolve as resolve4, sep } from "node:path";
+var runDocker = (args, failure) => new Promise((accept, reject) => {
+  const child = spawn("docker", args, {
+    stdio: ["inherit", process.env["TSPLC_LOG_STDERR"] === "1" ? 2 : "inherit", "inherit"]
+  });
+  const interrupt = () => child.kill("SIGINT");
+  const terminate = () => child.kill("SIGTERM");
+  process.on("SIGINT", interrupt);
+  process.on("SIGTERM", terminate);
+  const cleanup = () => {
+    process.off("SIGINT", interrupt);
+    process.off("SIGTERM", terminate);
+  };
+  child.once("error", (cause) => {
+    cleanup();
+    reject(new Error("Cannot start Docker. Install and start Docker Desktop or Docker Engine", {
+      cause
+    }));
+  });
+  child.once("exit", (code, signal) => {
+    cleanup();
+    if (code === 0) {
+      accept();
+    } else {
+      reject(new Error(failure(signal ?? code)));
+    }
+  });
+});
+var bindMount = (source, target, readonly = false) => `type=bind,"source=${source.replaceAll('"', '""')}",target=${target}${readonly ? ",readonly" : ""}`;
+async function mountLibraries(libraries, directory) {
+  if (!libraries?.length)
+    return;
+  await mkdir2(resolve4(directory, "libraries"), { recursive: true });
+  return Promise.all(libraries.map(async (library) => {
+    const data = await readFile2(library.path);
+    if (createHash("sha256").update(data).digest("hex") !== library.sha256)
+      throw new Error(`Library changed after installation: ${library.title}`);
+    const filename = `${library.sha256}-${basename(library.path)}`;
+    await writeFile3(resolve4(directory, "libraries", filename), data);
+    return { ...library, path: `/input/libraries/${filename}` };
+  }));
+}
+var prepareContainerRun = async (config, requestDirectory, options) => {
+  await writeFile3(resolve4(requestDirectory, "config.json"), JSON.stringify({
+    ...config,
+    libraries: options.sources ? await mountLibraries(config.libraries, requestDirectory) : [],
+    configFile: undefined,
+    docker: undefined,
+    codesys: undefined,
+    sourceDir: "/sources",
+    entry: posix.resolve("/sources", relative(config.sourceDir, config.entry).split(sep).join("/")),
+    template: "/template.project",
+    outDir: "/output",
+    runtime: undefined
+  }));
+  return [
+    "run",
+    "--rm",
+    "--init",
+    ...config.docker?.cpuSet ? ["--cpuset-cpus", config.docker.cpuSet] : [],
+    "--network",
+    options.network,
+    ...process.getuid && process.getgid ? ["--user", `${process.getuid()}:${process.getgid()}`] : [],
+    ...(options.environment ?? []).flatMap((name) => ["--env", name]),
+    "--mount",
+    bindMount(requestDirectory, "/input", true),
+    ...options.sources ? ["--mount", bindMount(config.sourceDir, "/sources", true)] : [],
+    "--mount",
+    bindMount(config.template, "/template.project", true),
+    "--mount",
+    bindMount(config.outDir, "/output")
+  ];
+};
+
+// packages/build/src/docker-build.ts
+var execute = promisify(execFile);
+var runtimeImage = "tsplc-control-linux-sl:4.22.0.0";
+var buildInDocker = async (config, image) => {
+  const requestDirectory = await mkdtemp2(resolve5(tmpdir2(), "codesys-docker-"));
+  try {
+    const operationId = randomUUID();
+    await mkdir3(config.outDir, { recursive: true });
+    const failurePath = resolve5(config.outDir, buildFailureFile);
+    await rm3(failurePath, { force: true });
+    const args = [
+      ...await prepareContainerRun(config, requestDirectory, { network: "none", sources: true }),
+      image,
+      "--request",
+      "/input/config.json",
+      "--operation-id",
+      operationId
+    ];
+    console.log(`Building with Docker (${image})`);
+    try {
+      await runDocker(args, (status) => `Docker build failed (${status}). Run tsplc configure if the image is missing; inspect ${config.outDir}/.codesys/docker for compiler logs`);
+    } catch (cause) {
+      const message = cause instanceof Error ? cause.message : String(cause);
+      const failure = await readFile3(failurePath, "utf8").then((text) => buildFailureSchema.parse(JSON.parse(text))).catch((error) => {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+          return;
+        throw new AggregateError([cause, error], `${message}. Invalid CODESYS failure metadata (${failurePath})`, { cause: error });
+      });
+      if (!failure)
+        throw cause;
+      if (failure.operationId !== operationId)
+        throw new Error(`${message}. CODESYS failure metadata belongs to a different Docker build`, {
+          cause
+        });
+      if (cause instanceof Error) {
+        cause.message = `${message}
+${failure.message}`;
+        if (failure.diagnostics.length)
+          cause.cause = new CodesysCompilerError(failure.message, failure.diagnostics);
+      }
+      throw cause;
+    }
+    return await readBuild(config.outDir);
+  } finally {
+    await rm3(requestDirectory, { recursive: true, force: true });
+  }
+};
+
+// packages/build/src/host/codesys-worker.ts
+import {
+  access,
+  copyFile as copyFile2,
+  mkdir as mkdir4,
+  open,
+  readFile as readFile4,
+  rename as rename2,
+  rm as rm4,
+  unlink,
+  writeFile as writeFile4
+} from "node:fs/promises";
+import { resolve as resolve6 } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { z as z4 } from "zod";
+
+// packages/build/src/host/codesys-command.ts
+import { commandArgumentSchema } from "@tsplc/config/build";
+var codesysCommand = [
+  "@echo off",
+  "setlocal DisableDelayedExpansion",
+  '"%CODESYS_BUILD_EXE%" --profile="%CODESYS_BUILD_PROFILE%" --noUI --runscript="%CODESYS_BUILD_SCRIPT%"',
+  'set "CODESYS_BUILD_STATUS=%errorlevel%"',
+  'if not "%CODESYS_BUILD_STATUS%"=="0" echo CODESYS Windows exit status: %CODESYS_BUILD_STATUS%',
+  "exit /b %CODESYS_BUILD_STATUS%",
+  ""
+].join(`\r
+`);
+
+// packages/build/src/host/codesys-host.ts
+import { execFile as execFile3, spawn as spawn2 } from "node:child_process";
+import { promisify as promisify3 } from "node:util";
+import { z as z3 } from "zod";
+
+// packages/build/src/host/windows-path.ts
+import { execFile as execFile2 } from "node:child_process";
+import { promisify as promisify2 } from "node:util";
+import { codesysTimeouts } from "@tsplc/config/build";
+var execute2 = promisify2(execFile2);
+
+// packages/build/src/host/codesys-host.ts
+var execute3 = promisify3(execFile3);
+var exitSchema = z3.object({
+  pid: z3.int().positive(),
+  code: z3.int().nullable(),
+  signal: z3.string().nullable()
+});
+
+// packages/build/src/host/codesys-worker.ts
+var pythonDirectory = resolve6(packageDirectory, "python");
+var sessionSchema = z4.object({
+  directory: z4.string(),
+  fingerprint: z4.string(),
+  pid: z4.int().positive()
+});
+var hasCode = (error, code) => error instanceof Error && ("code" in error) && error.code === code;
+var isProcessAlive = (pid) => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    if (hasCode(error, "ESRCH")) {
+      return false;
+    }
+    throw error;
+  }
+};
+var withWorkerLock = async (config, run) => {
+  await mkdir4(resolve6(config.outDir, ".codesys"), { recursive: true });
+  const path = resolve6(config.outDir, ".codesys/command.lock");
+  const deadline = Date.now() + config.timeouts.build + config.timeouts.startup;
+  while (true) {
+    const lock = await open(path, "wx").catch((error) => {
+      if (hasCode(error, "EEXIST")) {
+        return;
+      }
+      throw error;
+    });
+    if (lock) {
+      try {
+        await lock.writeFile(String(process.pid));
+        return await run();
+      } finally {
+        await lock.close();
+        await unlink(path);
+      }
+    }
+    const owner = Number(await readFile4(path, "utf8").catch((error) => {
+      if (hasCode(error, "ENOENT")) {
+        return "";
+      }
+      throw error;
+    }));
+    if (owner > 0 && !isProcessAlive(owner)) {
+      throw new Error(`An interrupted command left ${path}. Remove that lock file and retry.`);
+    }
+    if (Date.now() >= deadline) {
+      throw new Error(`Timed out waiting for another CODESYS command (${path})`);
+    }
+    await delay(200);
+  }
+};
+
+// packages/build/src/st/parse.ts
+import { basename as basename2 } from "node:path";
+
+// packages/build/src/st/declarations.ts
+var objectKinds = {
+  PROGRAM: "program",
+  FUNCTION_BLOCK: "function_block",
+  FUNCTIONBLOCK: "function_block",
+  FUNCTION: "function",
+  METHOD: "method",
+  INTERFACE: "interface",
+  PROPERTY: "property"
+};
+var modifiers = new Set([
+  "PUBLIC",
+  "PRIVATE",
+  "PROTECTED",
+  "INTERNAL",
+  "FINAL",
+  "ABSTRACT",
+  "OVERRIDE"
+]);
+var globalSections = new Set(["VAR_GLOBAL", "VAR_CONFIG"]);
+var variableSections = new Set([
+  ...globalSections,
+  "VAR",
+  "VAR_INPUT",
+  "VAR_OUTPUT",
+  "VAR_IN_OUT",
+  "VAR_TEMP",
+  "VAR_STAT",
+  "VAR_INST",
+  "VAR_EXTERNAL",
+  "VAR_ACCESS",
+  "VAR_GENERIC"
+]);
+var closingObjects = new Set(Object.keys(objectKinds).map((kind) => `END_${kind}`));
+var declarationKeywords = new Set([
+  ...Object.keys(objectKinds),
+  ...closingObjects,
+  ...variableSections,
+  "END_VAR",
+  "TYPE",
+  "END_TYPE",
+  "STRUCT",
+  "END_STRUCT",
+  "UNION",
+  "END_UNION",
+  "ACTION",
+  "END_ACTION",
+  "CONFIGURATION",
+  "END_CONFIGURATION"
+]);
+var conditionalDirective = (token) => {
+  if (token?.kind === "pragma") {
+    return /^\{\s*(IF|ELSIF|ELSE|END_IF)\b/i.exec(token.value)?.[1]?.toUpperCase();
+  }
+};
+var isDeclarationPragma = (token) => token?.kind === "pragma" && !conditionalDirective(token);
+var readDeclarationPragmas = (reader) => {
+  while (isDeclarationPragma(reader.peek())) {
+    reader.take();
+  }
+};
+var readDeclarationSemicolon = (reader) => {
+  const token = reader.peek();
+  if (token?.value === ";" && !/[\r\n]/.test(reader.source.slice(reader.end, token.start))) {
+    reader.take();
+  }
+};
+var readIdentifier = (reader) => {
+  const token = reader.take();
+  if (token.kind !== "word" || declarationKeywords.has(token.value)) {
+    reader.fail("Expected an IEC identifier", token);
+  }
+  return reader.source.slice(token.start, token.end);
+};
+var isOverrideModifier = (reader) => {
+  const name = reader.peek(1);
+  return name?.kind === "word" && !declarationKeywords.has(name.value) && !["(", "[", ":=", ".", "^"].includes(reader.peek(2)?.value ?? "") && !/[\r\n]/.test(reader.source.slice(reader.peek()?.end, name.start));
+};
+var readModifiers = (reader) => {
+  while (modifiers.has(reader.peek()?.value ?? "")) {
+    if (reader.peek()?.value === "OVERRIDE" && !isOverrideModifier(reader)) {
+      return;
+    }
+    reader.take();
+  }
+};
+var typeDelimiters = { "(": ")", "[": "]", "<": ">" };
+var readDelimitedType = (reader, open) => {
+  reader.expect(open);
+  const closings = [typeDelimiters[open]];
+  while (closings.length) {
+    const token = reader.take();
+    if (token.kind === "string" || token.kind === "pragma") {
+      continue;
+    }
+    if (token.value === "(" || token.value === "[") {
+      closings.push(typeDelimiters[token.value]);
+    } else if (token.value === ")" || token.value === "]") {
+      if (closings.pop() !== token.value) {
+        reader.fail(`Mismatched delimiter ${token.value}`, token);
+      }
+    } else if (open === "<" && closings.at(-1) === ">") {
+      if (token.value === "<") {
+        closings.push(">");
+      }
+      if (token.value === ">") {
+        closings.pop();
+      }
+    }
+    if (declarationKeywords.has(token.value) || token.value === ";") {
+      reader.fail(`Unclosed ${open}`, token);
+    }
+  }
+};
+var readType = (reader) => {
+  const start = reader.peek()?.start ?? reader.source.length;
+  while (true) {
+    if (["POINTER", "REFERENCE", "REF_TO"].includes(reader.peek()?.value ?? "")) {
+      if (reader.take().value !== "REF_TO") {
+        reader.expect("TO");
+      }
+      continue;
+    }
+    if (reader.consume("ARRAY")) {
+      readDelimitedType(reader, "[");
+      reader.expect("OF");
+      continue;
+    }
+    break;
+  }
+  readIdentifier(reader);
+  while (reader.consume(".")) {
+    readIdentifier(reader);
+  }
+  for (const open of ["(", "[", "<"]) {
+    if (reader.peek()?.value === open) {
+      readDelimitedType(reader, open);
+    }
+  }
+  return reader.source.slice(start, reader.end);
+};
+var readVariableSection = (reader) => {
+  reader.take();
+  const conditionals = [];
+  while (reader.peek()?.value !== "END_VAR") {
+    const token = reader.take();
+    if (variableSections.has(token.value) || closingObjects.has(token.value)) {
+      reader.fail("Missing END_VAR", token);
+    }
+    const directive = conditionalDirective(token);
+    if (!directive) {
+      continue;
+    }
+    if (directive === "IF") {
+      conditionals.push({ hasElse: false });
+      continue;
+    }
+    const current = conditionals.at(-1);
+    if (!current) {
+      return reader.fail("Unmatched conditional pragma", token);
+    }
+    if (directive === "END_IF") {
+      conditionals.pop();
+      continue;
+    }
+    if (current.hasElse) {
+      reader.fail("Conditional branch after ELSE", token);
+    }
+    current.hasElse = directive === "ELSE";
+  }
+  if (conditionals.length) {
+    reader.fail("Conditional pragmas must remain inside one variable section");
+  }
+  reader.take();
+  readDeclarationSemicolon(reader);
+};
+var readDeclarationSections = (reader) => {
+  while (reader.peek()) {
+    let ahead = 0;
+    while (isDeclarationPragma(reader.peek(ahead))) {
+      ahead++;
+    }
+    const next = reader.peek(ahead)?.value ?? "";
+    if (variableSections.has(next)) {
+      readDeclarationPragmas(reader);
+      readVariableSection(reader);
+      continue;
+    }
+    if (next !== "EXTENDS" && next !== "IMPLEMENTS") {
+      return;
+    }
+    readDeclarationPragmas(reader);
+    reader.take();
+    readType(reader);
+    while (reader.consume(",")) {
+      readType(reader);
+    }
+  }
+};
+
+// packages/build/src/st/lexer.ts
+class StSyntaxError extends Error {
+  constructor(source, offset, filename, message) {
+    const lines = source.slice(0, offset).split(/\r\n|\r|\n/);
+    super(`${filename}:${lines.length}:${(lines.at(-1)?.length ?? 0) + 1}: ${message}`);
+    this.name = "StSyntaxError";
+  }
+}
+var tokenize = (source, filename = "<source>") => {
+  const tokens = [];
+  let offset = 0;
+  const fail = (start, message) => {
+    throw new StSyntaxError(source, start, filename, message);
+  };
+  const quoted = () => {
+    const start = offset;
+    const quote = source[offset++];
+    while (offset < source.length) {
+      if (source[offset] === "$") {
+        offset += 2;
+      } else if (source[offset++] === quote) {
+        return;
+      }
+    }
+    fail(start, "Unterminated string");
+  };
+  while (offset < source.length) {
+    const start = offset;
+    const character = source[offset] ?? "";
+    if (/\s|\uFEFF/.test(character)) {
+      offset++;
+      continue;
+    }
+    if (source.startsWith("//", offset)) {
+      while (offset < source.length && !/[\r\n]/.test(source[offset] ?? "")) {
+        offset++;
+      }
+      continue;
+    }
+    if (source.startsWith("(*", offset)) {
+      offset += 2;
+      let depth = 1;
+      while (offset < source.length && depth > 0) {
+        if (source.startsWith("(*", offset)) {
+          depth++;
+          offset += 2;
+        } else if (source.startsWith("*)", offset)) {
+          depth--;
+          offset += 2;
+        } else {
+          offset++;
+        }
+      }
+      if (depth) {
+        fail(start, "Unterminated block comment");
+      }
+      continue;
+    }
+    if (character === "'" || character === '"') {
+      quoted();
+      tokens.push({
+        kind: "string",
+        value: source.slice(start, offset),
+        start,
+        end: offset
+      });
+      continue;
+    }
+    if (character === "{") {
+      offset++;
+      while (offset < source.length && source[offset] !== "}") {
+        if (source[offset] === "'" || source[offset] === '"') {
+          quoted();
+        } else {
+          offset++;
+        }
+      }
+      if (offset === source.length) {
+        fail(start, "Unterminated pragma");
+      }
+      offset++;
+      tokens.push({
+        kind: "pragma",
+        value: source.slice(start, offset),
+        start,
+        end: offset
+      });
+      continue;
+    }
+    if (/[A-Za-z_]/.test(character)) {
+      offset++;
+      while (/[A-Za-z_0-9]/.test(source[offset] ?? "")) {
+        offset++;
+      }
+      tokens.push({
+        kind: "word",
+        value: source.slice(start, offset).toUpperCase(),
+        start,
+        end: offset
+      });
+      continue;
+    }
+    offset++;
+    const pair = source.slice(start, offset + 1);
+    if ([":=", "=>", "..", "<=", ">=", "<>", "**"].includes(pair)) {
+      offset++;
+    }
+    tokens.push({
+      kind: "symbol",
+      value: source.slice(start, offset),
+      start,
+      end: offset
+    });
+  }
+  return tokens;
+};
+
+// packages/build/src/st/reader.ts
+var createTokenReader = (source, filename) => {
+  const tokens = tokenize(source, filename);
+  let index = 0;
+  const peek = (ahead = 0) => tokens[index + ahead];
+  const fail = (message, token = peek()) => {
+    throw new StSyntaxError(source, token?.start ?? source.length, filename, message);
+  };
+  const take = () => {
+    const token = peek();
+    if (!token) {
+      return fail("Unexpected end of declaration");
+    }
+    index++;
+    return token;
+  };
+  const expect = (value) => {
+    if (peek()?.value !== value) {
+      fail(`Expected ${value}`);
+    }
+    return take();
+  };
+  const consume = (value) => {
+    if (peek()?.value === value) {
+      return take();
+    }
+  };
+  return {
+    source,
+    filename,
+    tokens,
+    peek,
+    take,
+    expect,
+    consume,
+    fail,
+    get index() {
+      return index;
+    },
+    get end() {
+      return tokens[index - 1]?.end ?? 0;
+    }
+  };
+};
+
+// packages/build/src/st/parse.ts
+var dutTypes = {
+  STRUCT: "structure",
+  UNION: "union",
+  "(": "enumeration"
+};
+var parseDut = (reader) => {
+  reader.expect("TYPE");
+  readModifiers(reader);
+  const name = readIdentifier(reader);
+  if (reader.consume("EXTENDS")) {
+    readType(reader);
+  }
+  reader.expect(":");
+  readDeclarationPragmas(reader);
+  const dutType = dutTypes[reader.peek()?.value ?? ""] ?? "alias";
+  while (reader.peek()?.value !== "END_TYPE") {
+    if (reader.peek()?.value === "TYPE") {
+      reader.fail("Only one TYPE declaration is allowed per file");
+    }
+    reader.take();
+  }
+  reader.take();
+  reader.consume(";");
+  if (reader.peek()) {
+    reader.fail("Unexpected content after END_TYPE");
+  }
+  return { kind: "dut", name, declaration: reader.source, dutType };
+};
+var parseGlobals = (reader, options) => {
+  const header = reader.peek();
+  let persistent = false;
+  while (reader.peek()) {
+    readDeclarationPragmas(reader);
+    if (!reader.peek()) {
+      break;
+    }
+    if (!globalSections.has(reader.peek()?.value ?? "")) {
+      reader.fail("Expected a global variable section");
+    }
+    const start = reader.index;
+    readVariableSection(reader);
+    for (const token of reader.tokens.slice(start + 1, reader.index)) {
+      if (token.kind !== "word" || !["CONSTANT", "RETAIN", "PERSISTENT", "NON_RETAIN"].includes(token.value)) {
+        break;
+      }
+      persistent ||= token.value === "PERSISTENT";
+    }
+  }
+  const name = options.name ?? basename2(reader.filename, ".st");
+  if (!/^[A-Za-z_][A-Za-z_0-9]*$/.test(name)) {
+    reader.fail("Global list requires an IEC filename or an explicit name", header);
+  }
+  return {
+    kind: "gvl",
+    name,
+    declaration: reader.source,
+    ...persistent && { persistent: true }
+  };
+};
+var validateImplementation = (reader, tokens) => {
+  for (const token of tokens) {
+    if (token.kind !== "word") {
+      continue;
+    }
+    if (variableSections.has(token.value) || token.value === "END_VAR") {
+      reader.fail("Variable declaration outside the declaration section; conditional declaration envelopes are not supported", token);
+    }
+    if (declarationKeywords.has(token.value)) {
+      reader.fail("Nested objects must be separate child files, or the object terminator is mismatched", token);
+    }
+  }
+};
+var splitObject = (reader, header, kind, options) => {
+  const terminator = header.value === "FUNCTIONBLOCK" ? "END_FUNCTION_BLOCK" : `END_${header.value}`;
+  const remaining = reader.tokens.slice(reader.index);
+  const terminatorIndex = remaining.findIndex((token) => token.kind === "word" && token.value === terminator);
+  if (terminatorIndex < 0 && !options.declarationOnly) {
+    reader.fail(`Missing ${terminator}`);
+  }
+  const bodyTokens = terminatorIndex < 0 ? remaining : remaining.slice(0, terminatorIndex);
+  const [endToken, next, afterSemicolon] = terminatorIndex < 0 ? [] : remaining.slice(terminatorIndex);
+  const semicolon = next?.value === ";" ? next : undefined;
+  const unexpected = semicolon ? afterSemicolon : next;
+  if (unexpected) {
+    reader.fail(`Unexpected content after ${terminator}`, unexpected);
+  }
+  validateImplementation(reader, bodyTokens);
+  const declarationOnly = options.declarationOnly || kind === "interface" || kind === "property";
+  if (declarationOnly && bodyTokens.length) {
+    reader.fail("Unexpected implementation in a declaration-only object", bodyTokens[0]);
+  }
+  const declaration = reader.source.slice(0, reader.end);
+  const body = reader.source.slice(reader.end, endToken?.start) + (endToken ? reader.source.slice((semicolon ?? endToken).end) : "");
+  if (declarationOnly) {
+    return { declaration: declaration + body };
+  }
+  return { declaration, implementation: body };
+};
+var parsePou = (reader, options) => {
+  const header = reader.take();
+  if (!(header.value in objectKinds)) {
+    reader.fail(`Unsupported object header ${header.value}`, header);
+  }
+  const kind = objectKinds[header.value];
+  readModifiers(reader);
+  const name = readIdentifier(reader);
+  const returnType = reader.consume(":") ? readType(reader) : undefined;
+  if (returnType === undefined && kind === "property") {
+    reader.fail(`${header.value} requires a return type`);
+  }
+  readDeclarationSemicolon(reader);
+  readDeclarationSections(reader);
+  return {
+    kind,
+    name,
+    ...returnType === undefined ? {} : { returnType },
+    ...splitObject(reader, header, kind, options)
+  };
+};
+var parseSource = (source, options = {}) => {
+  const reader = createTokenReader(source, options.filename ?? "<source>");
+  readDeclarationPragmas(reader);
+  const header = reader.peek();
+  if (header?.value === "TYPE") {
+    return parseDut(reader);
+  }
+  if (header && globalSections.has(header.value)) {
+    return parseGlobals(reader, options);
+  }
+  return parsePou(reader, options);
+};
+
+// packages/build/src/io.ts
+var arrayType = /^ARRAY\s*\[\s*(-?\d+)\s*\.\.\s*(-?\d+)\s*\]\s*OF\s+(\w+)$/;
+var layout = (type) => {
+  const array = arrayType.exec(type);
+  return array ? { element: array[3], length: Number(array[2]) - Number(array[1]) + 1 } : { element: type, length: 1 };
+};
+var widths = {
+  BOOL: "X",
+  BYTE: "B",
+  SINT: "B",
+  USINT: "B",
+  WORD: "W",
+  INT: "W",
+  UINT: "W",
+  DWORD: "D",
+  DINT: "D",
+  UDINT: "D",
+  REAL: "D"
+};
+function bindStructuredTextIo(objects, bindings) {
+  const declarations = [];
+  const visit = (object) => {
+    const tokens = tokenize(object.declaration, object.source);
+    let section = false, start = 0;
+    for (let i = 0;i < tokens.length; i++) {
+      const token = tokens[i];
+      if (variableSections.has(token.value)) {
+        section = true;
+        start = i + 1;
+        continue;
+      }
+      if (token.value === "END_VAR") {
+        section = false;
+        continue;
+      }
+      if (!section || token.value !== ";")
+        continue;
+      const part = tokens.slice(start, i).filter((t) => t.kind !== "pragma");
+      start = i + 1;
+      const colonIndex = part.findIndex((t) => t.value === ":");
+      if (colonIndex < 1)
+        continue;
+      const names = part.slice(0, colonIndex).filter((t) => t.kind === "word" && !["CONSTANT", "RETAIN", "PERSISTENT", "AT"].includes(t.value));
+      const at = part.findIndex((t) => t.value === "AT");
+      const variables = at < 0 ? names : names.filter((t) => t.start < part[at].start);
+      const initializer = part.findIndex((t, index) => index > colonIndex && t.value === ":=");
+      const typeTokens = part.slice(colonIndex + 1, initializer < 0 ? undefined : initializer);
+      const type = typeTokens.length ? object.declaration.slice(typeTokens[0].start, typeTokens.at(-1).end).replace(/\s+/g, " ").toUpperCase() : "";
+      for (const name of variables)
+        declarations.push({
+          object,
+          name: name.value,
+          names: variables,
+          colon: part[colonIndex],
+          type
+        });
+    }
+    object.children.forEach(visit);
+  };
+  objects.forEach(visit);
+  const edits = new Map;
+  for (const [symbol, binding] of Object.entries(bindings)) {
+    const parts = symbol.toUpperCase().split(".");
+    if (parts.length > 2)
+      throw new Error(`${symbol}: direct IO maps a scalar declaration, not a nested field.`);
+    const matches = declarations.filter((d) => d.name === parts.at(-1) && (parts.length === 1 || d.object.name.toUpperCase() === parts[0]));
+    if (matches.length !== 1)
+      throw new Error(`${symbol}: expected one ST variable declaration, found ${matches.length}. Use Object.Variable to disambiguate.`);
+    const declaration = matches[0];
+    if (declaration.names.length !== 1)
+      throw new Error(`${symbol}: declare mapped IO variables separately.`);
+    const declared = layout(declaration.type);
+    if (!widths[declared.element] || declared.length > 1 && declared.element === "BOOL" || binding.address[2] !== widths[declared.element])
+      throw new Error(`${symbol}: ${declaration.type} is incompatible with ${binding.address}.`);
+    const expected = binding.type && layout(binding.type.replace(/\s+/g, " ").toUpperCase());
+    if (expected && (expected.element !== declared.element || expected.length !== declared.length))
+      throw new Error(`${symbol}: expected ${binding.type}, found ${declaration.type}.`);
+    const list = edits.get(declaration.object) ?? [];
+    const start = declaration.names[0].end;
+    if (list.some((e) => e.start === start))
+      throw new Error(`${symbol}: the variable has more than one IO binding.`);
+    list.push({ start, end: declaration.colon.start, text: ` AT ${binding.address} ` });
+    edits.set(declaration.object, list);
+  }
+  for (const [object, list] of edits)
+    for (const edit of list.sort((a, b) => b.start - a.start))
+      object.declaration = object.declaration.slice(0, edit.start) + edit.text + object.declaration.slice(edit.end);
+}
+
+// packages/build/src/build.ts
+var buildProject = async (config) => {
+  if (!config.docker)
+    throw new Error("Builds require a Docker builder image.");
+  return buildInDocker(config, dockerImage);
+};
+
+// packages/build/src/config.ts
+import {
+  configSchema as configSchema2,
+  controllerSchema as controllerSchema2,
+  cyclicTasksSchema as cyclicTasksSchema2,
+  dockerImage as dockerImage2,
+  defineBuildConfig as defineBuildConfig2,
+  resolveConfig as resolveConfig2,
+  loadConfig as loadConfig2
+} from "@tsplc/config/build";
+
+// packages/build/src/controller-online.ts
+import { execFile as execFile4 } from "node:child_process";
+import { createHash as createHash2, randomUUID as randomUUID2 } from "node:crypto";
+import { mkdir as mkdir5, mkdtemp as mkdtemp3, readFile as readFile5, rm as rm5 } from "node:fs/promises";
+import { tmpdir as tmpdir3 } from "node:os";
+import { resolve as resolve7 } from "node:path";
+import { promisify as promisify4 } from "node:util";
+import { z as z5 } from "zod";
+var execute4 = promisify4(execFile4);
+var imageIdSchema = z5.string().regex(/^sha256:[a-f0-9]{64}$/);
+var endpointSchema = z5.strictObject({
+  host: z5.string().nonempty(),
+  port: z5.number().int().min(1).max(65535)
+});
+var controllerResultSchema = z5.strictObject({
+  schemaVersion: z5.literal(1),
+  operationId: z5.uuid(),
+  operation: z5.enum(["download", "online-change", "inspect"]),
+  imageId: imageIdSchema,
+  templateHash: z5.string().regex(/^[a-f0-9]{64}$/),
+  target: z5.strictObject({
+    network: z5.string().nonempty(),
+    gateway: endpointSchema,
+    device: endpointSchema,
+    controller: controllerSchema.optional()
+  }),
+  generation: z5.string().nonempty(),
+  application: z5.string().nonempty(),
+  applicationGuid: z5.string().nonempty(),
+  controllerIds: z5.strictObject({
+    codeId: z5.string().nonempty(),
+    dataId: z5.string().nonempty()
+  }),
+  state: z5.string().nonempty(),
+  values: z5.record(z5.string(), z5.string())
+});
+var controllerOperation = async (config, operation, options) => {
+  if (!config.docker || !config.online) {
+    throw new Error("Docker image and online gateway/device configuration are required for controller operations");
+  }
+  const environmentNames = config.online.credentials ? [config.online.credentials.usernameEnv, config.online.credentials.passwordEnv] : [];
+  for (const name of environmentNames) {
+    if (process.env[name] === undefined) {
+      throw new Error(`Controller credential environment variable ${name} is not set`);
+    }
+  }
+  const { stdout } = await execute4("docker", ["image", "inspect", "--format", "{{.Id}}", dockerImage], { timeout: config.timeouts.hostCommand }).catch((cause) => {
+    throw new Error(`Cannot inspect Docker builder image ${dockerImage}. Install and start Docker, then run tsplc-build configure if the image is missing`, { cause });
+  });
+  const imageId = imageIdSchema.parse(stdout.trim());
+  const templateHash = createHash2("sha256").update(await readFile5(config.template)).digest("hex");
+  const operationId = randomUUID2();
+  const target = {
+    network: config.online.network,
+    gateway: config.online.gateway,
+    device: config.online.device,
+    controller: config.controller
+  };
+  const requestDirectory = await mkdtemp3(resolve7(tmpdir3(), "codesys-controller-"));
+  const diagnostics = resolve7(config.outDir, ".codesys/controller");
+  try {
+    await mkdir5(config.outDir, { recursive: true });
+    await runDocker([
+      ...await prepareContainerRun(config, requestDirectory, {
+        network: target.network,
+        environment: environmentNames,
+        sources: operation !== "inspect"
+      }),
+      imageId,
+      operation,
+      "--request",
+      "/input/config.json",
+      "--operation-id",
+      operationId,
+      "--image-id",
+      imageId,
+      ...options.initializeUser ? ["--initialize-user"] : [],
+      ...options.read ? ["--read", JSON.stringify(options.read)] : []
+    ], (status) => `Docker controller operation failed (${status}). Inspect ${diagnostics} for diagnostics`);
+    const result = await readFile5(resolve7(diagnostics, "result.json"), "utf8").then((content) => controllerResultSchema.parse(JSON.parse(content))).catch((cause) => {
+      throw new Error(`Docker did not produce a valid controller receipt. Inspect ${diagnostics} for diagnostics`, { cause });
+    });
+    if (result.operationId !== operationId || result.operation !== operation || result.imageId !== imageId || result.templateHash !== templateHash || JSON.stringify(result.target) !== JSON.stringify(target)) {
+      throw new Error(`Controller receipt does not match this operation's image, template or target. Inspect ${diagnostics} for diagnostics`);
+    }
+    return result;
+  } finally {
+    await rm5(requestDirectory, { recursive: true, force: true });
+  }
+};
+var updateController = (config, operation, options = {}) => controllerOperation(config, operation, options);
+var inspectController = (config, read) => controllerOperation(config, "inspect", { read });
+
+// packages/build/src/docker-build.ts
+import { execFile as execFile5 } from "node:child_process";
+import { cp as cp4, mkdir as mkdir6, mkdtemp as mkdtemp4, readFile as readFile6, rm as rm6 } from "node:fs/promises";
+import { tmpdir as tmpdir4 } from "node:os";
+import { resolve as resolve8 } from "node:path";
+import { promisify as promisify5 } from "node:util";
+var execute5 = promisify5(execFile5);
+var configureDocker = async () => {
+  const image = dockerImage;
+  const { stdout } = await execute5("docker", ["info", "--format", "{{.OSType}}/{{.Architecture}}"], { timeout: 30000 }).catch((cause) => {
+    throw new Error("Cannot connect to Docker. Install and start Docker Desktop or Docker Engine", {
+      cause
+    });
+  });
+  const architecture = stdout.trim();
+  const arm = architecture === "linux/aarch64" || architecture === "linux/arm64";
+  if (!arm && architecture !== "linux/x86_64" && architecture !== "linux/amd64") {
+    throw new Error("The builder requires a Linux Docker server on ARM64 or AMD64");
+  }
+  const context = await mkdtemp4(resolve8(tmpdir4(), "codesys-installer-"));
+  let buildContext;
+  try {
+    buildContext = await prepareDockerContext();
+    const cache = resolve8(context, "winetricks");
+    await mkdir6(cache);
+    if (process.env["CODESYS_WINETRICKS_CACHE"]) {
+      await cp4(process.env["CODESYS_WINETRICKS_CACHE"], cache, {
+        recursive: true
+      });
+    }
+    console.log(`Preparing Docker builder (${image}). Downloading and installing CODESYS 3.5.22.30 and prerequisites.`);
+    await runDocker([
+      "build",
+      "--platform",
+      "linux/amd64",
+      "--build-arg",
+      `SETUP_BASE=${arm ? "arm-setup" : "base"}`,
+      "--build-arg",
+      `SETUP_PLATFORM=${arm ? "linux/arm64" : "linux/amd64"}`,
+      "--build-arg",
+      "INSTALLER_SOURCE=installer-download",
+      "--progress",
+      "plain",
+      "--build-context",
+      `installer=${context}`,
+      "-f",
+      resolve8(buildContext, "docker/Dockerfile"),
+      "-t",
+      image,
+      buildContext
+    ], (status) => `Docker configuration failed (${status}). Review the image-build output and run tsplc configure again`);
+    return image;
+  } finally {
+    await Promise.all([
+      rm6(context, { recursive: true, force: true }),
+      ...buildContext ? [rm6(buildContext, { recursive: true, force: true })] : []
+    ]);
+  }
+};
+var runtimeImage2 = "tsplc-control-linux-sl:4.22.0.0";
+var configureRuntime = async () => {
+  const context = resolve8(packageDirectory, "docker/control-linux-sl");
+  console.log(`Preparing the local PLC runtime (${runtimeImage2}).`);
+  await runDocker(["build", "--platform", "linux/amd64", "--progress", "plain", "-t", runtimeImage2, context], (status) => `Runtime image build failed (${status}). Review the image-build output`);
+  return runtimeImage2;
+};
+
+// packages/build/src/libraries.ts
+import { createHash as createHash3, randomUUID as randomUUID3 } from "node:crypto";
+import { mkdir as mkdir7, readFile as readFile7, rename as rename3, writeFile as writeFile5 } from "node:fs/promises";
+import { basename as basename3, relative as relative2, resolve as resolve9 } from "node:path";
+var libraryRegistry = "https://store-archive.codesys.com/CODESYSLibs";
+var libraryFile = /\.(?:compiled-library(?:-v\d+)?|library)$/i;
+var hash = (data) => createHash3("sha256").update(data).digest("hex");
+var component = (name) => {
+  if (!name.trim() || /[/\\\0\r\n]/.test(name) || name === "." || name === "..")
+    throw new Error(`Invalid library registry component: ${name}.`);
+  return encodeURIComponent(name);
+};
+async function response(url, fetcher) {
+  const result = await fetcher(url, { signal: AbortSignal.timeout(30000) });
+  if (!result.ok)
+    throw new Error(`Library registry ${result.status}: ${url}`);
+  return result;
+}
+async function libraryIndex(path = ["System"], fetcher = fetch) {
+  const url = `${libraryRegistry}/${path.map(component).join("/")}/index`;
+  const result = await response(url, fetcher);
+  const text = await result.text();
+  if (text.length > 4000000 || /<html/i.test(text))
+    throw new Error(`Invalid library registry index: ${url}`);
+  return text.split(/\r?\n/).map((s) => s.trim()).filter(Boolean);
+}
+async function validateLibrary(title, version, company = "System", fetcher = fetch) {
+  if (!(await libraryIndex([company], fetcher)).includes(title))
+    throw new Error(`Unknown CODESYS library ${company}/${title}. Names are case sensitive.`);
+  const versions = await libraryIndex([company, title], fetcher);
+  if (!versions.includes(version))
+    throw new Error(`Unknown version ${version} for ${title}. Available: ${versions.join(", ")}`);
+  const filenames = (await libraryIndex([company, title, version], fetcher)).filter((name) => libraryFile.test(name));
+  if (filenames.length !== 1)
+    throw new Error(`Expected one library payload for ${title} ${version}, received ${filenames.length}.`);
+  return {
+    filename: filenames[0],
+    url: `${libraryRegistry}/${[company, title, version, filenames[0]].map(component).join("/")}`
+  };
+}
+async function installLibraries(dependencies, root, options = {}) {
+  const file = resolve9(root, "tsplc.lock.json"), store = resolve9(root, ".tsplc/libraries");
+  let previous = { version: 1, dependencies: {} };
+  try {
+    previous = JSON.parse(await readFile7(file, "utf8"));
+  } catch (cause) {
+    if (!(cause && typeof cause === "object" && ("code" in cause) && cause.code === "ENOENT"))
+      throw cause;
+  }
+  if (previous.version !== 1 || !previous.dependencies || typeof previous.dependencies !== "object")
+    throw new Error("Invalid tsplc.lock.json.");
+  const installed = {};
+  const fetcher = options.fetcher ?? fetch;
+  await mkdir7(store, { recursive: true });
+  for (const [title, dependency] of Object.entries(dependencies)) {
+    component(title);
+    const settings = typeof dependency === "string" ? { version: dependency } : dependency;
+    const locked = previous.dependencies[title];
+    const prior = locked ? { ...locked, path: resolve9(root, locked.path) } : undefined;
+    const same = prior !== undefined && prior.namespace === settings.namespace && ("path" in settings ? prior.url === undefined && prior.path === resolve9(root, settings.path) : prior.version === settings.version && prior.company === (settings.company ?? "System"));
+    if (same) {
+      try {
+        if (hash(await readFile7(prior.path)) === prior.sha256) {
+          installed[title] = prior;
+          continue;
+        }
+      } catch {}
+      if (options.frozen)
+        throw new Error(`Locked library ${title} is missing or changed.`);
+    } else if (options.frozen)
+      throw new Error(`Dependency ${title} differs from tsplc.lock.json.`);
+    if ("path" in settings) {
+      const path = resolve9(root, settings.path);
+      if (!libraryFile.test(path))
+        throw new Error(`${title}: expected a .library or .compiled-library file.`);
+      installed[title] = {
+        title,
+        path,
+        sha256: hash(await readFile7(path)),
+        ...settings.namespace ? { namespace: settings.namespace } : {}
+      };
+    } else {
+      const company = settings.company ?? "System";
+      const payload = await validateLibrary(title, settings.version, company, fetcher);
+      const result = await response(payload.url, fetcher);
+      const data = new Uint8Array(await result.arrayBuffer());
+      if (!data.length || data.length > 256 * 1024 * 1024)
+        throw new Error(`${title}: invalid library payload size.`);
+      const sha256 = hash(data);
+      if (same && prior.sha256 !== sha256)
+        throw new Error(`Registry payload changed for locked library ${title} ${settings.version}.`);
+      const path = resolve9(store, `${sha256}-${basename3(payload.filename)}`), temp = `${path}.${randomUUID3()}.tmp`;
+      await writeFile5(temp, data, { flag: "wx" });
+      await rename3(temp, path);
+      installed[title] = {
+        title,
+        company,
+        version: settings.version,
+        path,
+        sha256,
+        url: payload.url,
+        ...settings.namespace ? { namespace: settings.namespace } : {}
+      };
+    }
+  }
+  if (options.frozen && Object.keys(previous.dependencies).some((name) => !Object.hasOwn(dependencies, name)))
+    throw new Error("Removed dependencies differ from tsplc.lock.json.");
+  if (!options.frozen) {
+    const temp = `${file}.${randomUUID3()}.tmp`;
+    const portable = Object.fromEntries(Object.entries(installed).map(([title, library]) => [
+      title,
+      { ...library, path: relative2(root, library.path).replaceAll("\\", "/") }
+    ]));
+    await writeFile5(temp, JSON.stringify({ version: 1, dependencies: portable }, null, 2) + `
+`);
+    await rename3(temp, file);
+  }
+  return Object.values(installed);
+}
+
+// packages/build/src/run.ts
+import { execFile as execFile6 } from "node:child_process";
+import { mkdtemp as mkdtemp5, readFile as readFile8, rm as rm7, writeFile as writeFile6 } from "node:fs/promises";
+import { tmpdir as tmpdir5 } from "node:os";
+import { basename as basename4, dirname as dirname2, join } from "node:path";
+import { setTimeout as delay2 } from "node:timers/promises";
+import { promisify as promisify6 } from "node:util";
+import { z as z6 } from "zod";
+
+// packages/build/src/runtime-status.ts
+var getApplicationStatus = (log, application, startedAt) => {
+  const event = log.split(/\r?\n/).reverse().find((line) => {
+    const timestamp = Date.parse(line.split(",")[0] ?? "");
+    if (!Number.isFinite(timestamp) || timestamp < startedAt) {
+      return false;
+    }
+    return line.includes(`<app>${application}</app>`) && /\b(started|stopped|exception|corrupt|failed|denied)\b/i.test(line) && !line.includes("load started");
+  });
+  if (!event) {
+    return "pending";
+  }
+  return event.includes(`Application [<app>${application}</app>] started`) ? "running" : "failed";
+};
+
+// packages/build/src/run.ts
+var execute6 = promisify6(execFile6);
+var stateSchema = z6.object({
+  Running: z6.boolean(),
+  StartedAt: z6.iso.datetime({ offset: true })
+});
+var service = "plc";
+var runtimeProject = (name) => name.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase().replace(/[^a-z0-9_-]+/g, "-");
+var runtimeDefinition = (name) => ({
+  services: {
+    [service]: {
+      image: runtimeImage,
+      platform: "linux/amd64",
+      hostname: `${runtimeProject(name)}-${service}`,
+      init: true,
+      ports: ["127.0.0.1:4840:4840", "127.0.0.1:11740:11740"],
+      cap_add: ["SYS_NICE", "IPC_LOCK"],
+      volumes: ["control-conf:/conf/codesyscontrol", "control-data:/data/codesyscontrol"],
+      restart: "no"
+    }
+  },
+  volumes: { "control-conf": {}, "control-data": {} }
+});
+var runProject = async (config, name) => withWorkerLock(config, async () => {
+  const build = await readBuild(config.outDir).catch((cause) => {
+    throw new Error(`No complete build in ${config.outDir}. Run tsplc-build build first.`, {
+      cause
+    });
+  });
+  const definitionDirectory = await mkdtemp5(join(tmpdir5(), "tsplc-runtime-"));
+  try {
+    const composeFile = join(definitionDirectory, "compose.yaml");
+    await writeFile6(composeFile, JSON.stringify(runtimeDefinition(name)));
+    const docker = (...args) => execute6("docker", args, {
+      timeout: config.timeouts.runtime,
+      maxBuffer: 8 * 1024 * 1024
+    });
+    const compose = (...args) => docker("compose", "--project-name", runtimeProject(name), "--file", composeFile, ...args);
+    const installer = await readFile8(new URL("../runtime/install.sh", import.meta.url), "utf8");
+    console.log(`Installing ${build.application} in Docker service ${service}`);
+    await compose("stop", service);
+    await compose("run", "--rm", "--no-deps", "-T", "--volume", `${dirname2(build.output)}:/codesys-build:ro`, "--entrypoint", "/bin/sh", service, "-c", installer, "codesys-build-install", build.application, basename4(build.output, ".app"));
+    await compose("up", "--detach", "--no-deps", service);
+    const containers = (await compose("ps", "--all", "--quiet", service)).stdout.trim().split(/\s+/).filter(Boolean);
+    if (containers.length !== 1 || !containers[0]) {
+      throw new Error(`Expected one container for Compose service ${service}`);
+    }
+    const container = containers[0];
+    const deadline = Date.now() + config.timeouts.runtime;
+    while (true) {
+      const state = stateSchema.parse(JSON.parse((await docker("inspect", "--format", "{{json .State}}", container)).stdout));
+      if (!state.Running) {
+        throw new Error(`Docker service ${service} exited before the application started. Check docker logs ${container}.`);
+      }
+      const { stdout: log } = await docker("exec", container, "/bin/sh", "-c", "if [ -f /data/codesyscontrol/codesyscontrol.log ]; then cat /data/codesyscontrol/codesyscontrol.log; fi");
+      const status = getApplicationStatus(log, build.application, Date.parse(state.StartedAt));
+      if (status === "running") {
+        console.log(`${build.application} is running in ${service}`);
+        return { ...build, container };
+      }
+      if (status === "failed" || Date.now() >= deadline) {
+        throw new Error(`CODESYS did not start ${build.application}. Runtime log:
+${log.split(`
+`).slice(-25).join(`
+`)}`);
+      }
+      await delay2(250);
+    }
+  } finally {
+    await rm7(definitionDirectory, { force: true, recursive: true });
+  }
+});
+
+// packages/build/src/sources.ts
+import { readdir, readFile as readFile9 } from "node:fs/promises";
+import { basename as basename5, resolve as resolve10 } from "node:path";
+var prefixes = {
+  FB: "function_block",
+  PRG: "program",
+  FUN: "function",
+  F: "function",
+  I: "interface",
+  ST: "dut",
+  E: "dut",
+  T: "dut",
+  U: "dut",
+  GVL: "gvl"
+};
+var childFolders = {
+  methods: "method",
+  properties: "property",
+  actions: "action"
+};
+var canOwn = (kind) => ["program", "function_block", "interface", "property"].includes(kind);
+var assertUnique = (objects, scope) => {
+  const seen = new Map;
+  for (const object of objects) {
+    const key = object.name.toLowerCase();
+    const previous = seen.get(key);
+    if (previous) {
+      throw new Error(`Duplicate IEC name ${object.name} in ${scope}: ${previous} and ${object.source}`);
+    }
+    seen.set(key, object.source);
+    assertUnique(object.children, `${scope}.${object.name}`);
+  }
+};
+var readUnit = async (name, files, role, interfaceMember = false) => {
+  if (!/^[A-Za-z_][A-Za-z_0-9]*$/.test(name)) {
+    throw new Error(`Invalid IEC object name: ${name}`);
+  }
+  for (const [part, candidates] of Object.entries(files)) {
+    if (candidates.length > 1) {
+      throw new Error(`Ambiguous ${part} for ${name}: ${candidates.join(", ")}`);
+    }
+  }
+  const combined = files.combined[0];
+  const declaration = files.declaration[0];
+  const implementation = files.implementation[0];
+  if (combined && (declaration || implementation)) {
+    throw new Error(`Both combined and split sources exist for ${name}`);
+  }
+  const path = combined ?? declaration ?? implementation;
+  if (!path) {
+    throw new Error(`Missing source for ${name}`);
+  }
+  if (role === "action") {
+    if (!combined) {
+      throw new Error(`Actions use one implementation-only .st file: ${path}`);
+    }
+    return {
+      kind: "action",
+      name,
+      declaration: "",
+      implementation: await readFile9(combined, "utf8"),
+      source: combined
+    };
+  }
+  if (role === "get" || role === "set") {
+    if (!combined) {
+      throw new Error(`Property accessors use one .st file: ${path}`);
+    }
+    const body = await readFile9(combined, "utf8");
+    const header = `METHOD ${name}
+`;
+    const parsed = parseSource(`${header}${body}
+END_METHOD`, {
+      filename: combined
+    });
+    return {
+      ...parsed,
+      kind: role,
+      name,
+      declaration: parsed.declaration.slice(header.length),
+      source: combined
+    };
+  }
+  if (!combined && !declaration) {
+    throw new Error(`Missing declaration for ${path}`);
+  }
+  const sourcePath = combined ?? declaration ?? path;
+  const parsed = parseSource(await readFile9(sourcePath, "utf8"), {
+    filename: sourcePath,
+    name,
+    declarationOnly: !combined || interfaceMember
+  });
+  if (parsed.name.toLowerCase() !== name.toLowerCase()) {
+    throw new Error(`Source name ${name} does not match declaration ${parsed.name}: ${sourcePath}`);
+  }
+  if (role && parsed.kind !== role) {
+    throw new Error(`Expected ${role}, found ${parsed.kind}: ${sourcePath}`);
+  }
+  if (!role && ["method", "property"].includes(parsed.kind)) {
+    throw new Error(`Child object has no enclosing POU: ${sourcePath}`);
+  }
+  const prefix = /^([A-Z]+)_/.exec(name.toUpperCase())?.[1];
+  if (!role && prefix && prefixes[prefix] && prefixes[prefix] !== parsed.kind) {
+    throw new Error(`Prefix ${prefix}_ conflicts with ${parsed.kind}: ${sourcePath}`);
+  }
+  const declarationOnly = ["dut", "gvl", "interface", "property"].includes(parsed.kind) || interfaceMember;
+  if (declarationOnly && implementation) {
+    throw new Error(`This object has no implementation: ${implementation}`);
+  }
+  if (!combined && !declarationOnly && !implementation) {
+    throw new Error(`Missing implementation for ${sourcePath}`);
+  }
+  return {
+    ...parsed,
+    ...implementation ? { implementation: await readFile9(implementation, "utf8") } : {},
+    source: sourcePath
+  };
+};
+var loadSources2 = async (config) => {
+  const objects = [];
+  const visit = async (directory, folder, parent, role) => {
+    const entries = (await readdir(directory, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name, "en"));
+    const groups = new Map;
+    for (const entry of entries) {
+      if (entry.isSymbolicLink()) {
+        throw new Error(`Source symlinks are not supported: ${resolve10(directory, entry.name)}`);
+      }
+      if (!entry.isFile() || !/\.st$/i.test(entry.name)) {
+        continue;
+      }
+      const stem = entry.name.slice(0, -3);
+      const suffix = /^(.*)\.(declaration|implementation)$/.exec(stem);
+      const generic = ["source", "declaration", "implementation"].includes(stem);
+      const name = generic ? basename5(directory) : suffix?.[1] ?? stem;
+      const section = suffix?.[2] ?? stem;
+      const part = section === "declaration" || section === "implementation" ? section : "combined";
+      const key = name.toLowerCase();
+      const group = groups.get(key) ?? {
+        name,
+        files: { combined: [], declaration: [], implementation: [] }
+      };
+      group.files[part].push(resolve10(directory, entry.name));
+      groups.set(key, group);
+    }
+    const units = [];
+    const ownKey = basename5(directory).toLowerCase();
+    const ordered = [...groups].sort(([a], [b]) => Number(b === ownKey) - Number(a === ownKey));
+    for (const [key, { name, files }] of ordered) {
+      const ownProperty = units.find((unit) => unit.kind === "property" && unit.name.toLowerCase() === ownKey);
+      const accessor = ownProperty && (key === "get" || key === "set") ? key : undefined;
+      const unit = {
+        ...await readUnit(accessor ? `${accessor[0]?.toUpperCase()}${accessor.slice(1)}` : name, files, accessor ?? role, parent?.kind === "interface"),
+        folder: parent ? [] : folder,
+        children: []
+      };
+      if (accessor && ownProperty) {
+        if (parent?.kind === "interface") {
+          throw new Error(`Interface properties cannot implement accessors: ${unit.source}`);
+        }
+        ownProperty.children.push(unit);
+      } else {
+        units.push(unit);
+        if (parent) {
+          parent.children.push(unit);
+        } else {
+          objects.push(unit);
+        }
+      }
+    }
+    const own = units.find((unit) => unit.name.toLowerCase() === ownKey && canOwn(unit.kind));
+    if (own && !parent) {
+      own.folder = folder.slice(0, -1);
+    }
+    for (const entry of entries.filter((entry) => entry.isDirectory())) {
+      const childRole = childFolders[entry.name];
+      if (own && childRole) {
+        if (own.kind === "property" || own.kind === "interface" && childRole === "action") {
+          throw new Error(`Unsupported ${entry.name} under ${own.name}`);
+        }
+        await visit(resolve10(directory, entry.name), [], own, childRole);
+      } else if (parent) {
+        await visit(resolve10(directory, entry.name), [], parent, role);
+      } else {
+        await visit(resolve10(directory, entry.name), [...folder, entry.name]);
+      }
+    }
+  };
+  await visit(resolve10(config.sourceDir), []);
+  assertUnique(objects, "Application");
+  if (config.io)
+    bindStructuredTextIo(objects, config.io);
+  const entry = objects.find((object) => object.source === resolve10(config.entry));
+  if (!entry) {
+    throw new Error(`Entry is not a discovered source: ${config.entry}`);
+  }
+  if (entry.kind !== "program") {
+    throw new Error(`Entry must be a PROGRAM: ${config.entry}`);
+  }
+  if (config.tasks) {
+    const programs = new Set(objects.filter((object) => object.kind === "program").map((object) => object.name));
+    for (const task of config.tasks)
+      for (const program of task.programs)
+        if (!programs.has(program))
+          throw new Error(`Task ${task.name} references an undiscovered PROGRAM ${program}`);
+  }
+  return { entry: entry.name, objects };
+};
+
+// packages/build/src/cli.ts
+async function main() {
+  const { values, positionals } = parseArgs({
+    allowPositionals: true,
+    options: {
+      config: { type: "string" },
+      help: { type: "boolean", short: "h" },
+      read: { type: "string", multiple: true },
+      "initialize-user": { type: "boolean" },
+      "frozen-lockfile": { type: "boolean" },
+      runtime: { type: "boolean" }
+    }
+  });
+  const command = positionals[0];
+  const commands = new Set([
+    "configure",
+    "install",
+    "check",
+    "build",
+    "run",
+    "download",
+    "online-change",
+    "inspect"
+  ]);
+  if (positionals.length > 1)
+    throw new Error("Specify one command.");
+  if (!command || values.help) {
+    console.log("tsplc-build configure|install|check|build|run|download|online-change|inspect [--config tsplc.config.ts] [--read symbol] [--runtime]");
+    return;
+  }
+  if (!commands.has(command))
+    throw new Error(`Unknown command ${command}.`);
+  if (values.runtime && command !== "configure")
+    throw new Error("--runtime applies only to configure.");
+  if (command === "configure") {
+    await (values.runtime ? configureRuntime() : configureDocker());
+    return;
+  }
+  const { config, configFile, root } = await loadTsplcConfig(values.config);
+  if (command === "install") {
+    const libraries = await installLibraries(config.dependencies, root, {
+      frozen: values["frozen-lockfile"]
+    });
+    console.log(`Installed ${libraries.length} CODESYS libraries.`);
+    return;
+  }
+  if (!config.build)
+    throw new Error("Configure build options in tsplc.config.ts.");
+  if (command === "inspect") {
+    console.log(JSON.stringify(await inspectController(resolveConfig2({ ...config.build, controller: controllerFor(config, command) }, configFile), values.read), null, 2));
+    return;
+  }
+  if (config.compiler)
+    throw new Error("Use tsplc for TypeScript projects. tsplc-build accepts raw Structured Text.");
+  const build = rawBuildConfig(config);
+  const hardware = await loadHardware(config, root);
+  const io = resolveIo(config, hardware);
+  if (command === "check") {
+    const sources = await loadSources2(resolveConfig2({ ...build, io }, configFile));
+    console.log(`Validated ${sources.objects.length} Structured Text objects.`);
+    return;
+  }
+  const libraries = await installLibraries(config.dependencies, root, {
+    frozen: values["frozen-lockfile"]
+  });
+  const settings = resolveConfig2({
+    ...build,
+    libraries,
+    io,
+    deviceTree: await deviceTree(config, hardware),
+    controller: controllerFor(config, command)
+  }, configFile);
+  if (command === "build")
+    await buildProject(settings);
+  else if (command === "run") {
+    await buildProject(settings);
+    await runProject(settings, config.name);
+  } else if (command === "download" || command === "online-change")
+    await updateController(settings, command, {
+      initializeUser: values["initialize-user"],
+      read: values.read
+    });
+}
+try {
+  await main();
+} catch (cause) {
+  console.error(cause instanceof Error ? cause.message : String(cause));
+  process.exitCode = 1;
+}
+
+//# debugId=B5CDCE065D7E468A64756E2164756E21
+//# sourceMappingURL=cli.js.map