@tsplc/compiler 0.0.0-stage → 0.2.0

package/dist/cli.js

@@ -0,0 +1,1396 @@
+#!/usr/bin/env bun
+// @bun
+
+// packages/compiler/project/server.ts
+import { existsSync } from "node:fs";
+import { mkdtemp, mkdir, rm, rename } from "node:fs/promises";
+import { dirname, resolve, join } from "node:path";
+import { createRequire } from "node:module";
+import ts from "typescript";
+import { typeCheckOnly } from "@tsplc/compiler";
+var resolveServerModule = (root, name) => name.startsWith(".") || name.startsWith("/") || existsSync(resolve(root, name)) ? resolve(root, name) : createRequire(join(root, "package.json")).resolve(name);
+var kebabCase = (name) => name.replace(/([a-z0-9])([A-Z])|([A-Z])([A-Z][a-z])/g, "$1$3-$2$4").replace(/[^A-Za-z0-9]+/g, "-").replace(/^-|-$/g, "").toLowerCase();
+var buildServer = async (config, root) => {
+  const settings = config.server;
+  if (!settings?.runtime)
+    throw new Error("Configure server.runtime to build an executable.");
+  const runtime = settings.runtime;
+  const entry = resolveServerModule(root, runtime.entry);
+  const windows = runtime.target ? runtime.target.includes("windows") : process.platform === "win32";
+  const outFile = resolve(root, "build/server", `${kebabCase(config.name)}-services${windows ? ".exe" : ""}`);
+  const tsconfig = ts.findConfigFile(dirname(entry), ts.sys.fileExists);
+  if (!tsconfig)
+    throw new Error("Server entry requires a tsconfig.json.");
+  const read = ts.readConfigFile(tsconfig, ts.sys.readFile);
+  if (read.error)
+    throw new Error(ts.flattenDiagnosticMessageText(read.error.messageText, `
+`));
+  const parsed = ts.parseJsonConfigFileContent(read.config, ts.sys, dirname(tsconfig));
+  const program = ts.createProgram({
+    rootNames: [entry, ...parsed.fileNames.filter((file) => /\.d\.[cm]?ts$/.test(file))],
+    options: { ...parsed.options, ...typeCheckOnly },
+    projectReferences: parsed.projectReferences
+  });
+  const diagnostics = [...parsed.errors, ...ts.getPreEmitDiagnostics(program)];
+  if (diagnostics.length)
+    throw new Error(ts.formatDiagnosticsWithColorAndContext(diagnostics, {
+      getCanonicalFileName: (path) => path,
+      getCurrentDirectory: () => root,
+      getNewLine: () => `
+`
+    }));
+  await mkdir(dirname(outFile), { recursive: true });
+  const staging = await mkdtemp(join(dirname(outFile), ".tsplc-server-"));
+  try {
+    const binary = join(staging, "server");
+    const result = await Bun.build({
+      entrypoints: [entry],
+      env: "disable",
+      compile: {
+        outfile: binary,
+        ...runtime.target ? { target: runtime.target } : {},
+        autoloadDotenv: false,
+        autoloadBunfig: false,
+        autoloadTsconfig: false,
+        autoloadPackageJson: false
+      }
+    });
+    if (!result.success)
+      throw new AggregateError(result.logs, "Server executable build failed.");
+    await rename(windows ? `${binary}.exe` : binary, outFile);
+    return {
+      server: {
+        executable: outFile,
+        target: runtime.target ?? `bun-${process.platform}-${process.arch}`
+      }
+    };
+  } finally {
+    await rm(staging, { recursive: true, force: true });
+  }
+};
+
+// packages/compiler/project/cli.ts
+import { parseArgs } from "util";
+import { resolve as resolve6 } from "path";
+import {
+  buildTargetFor,
+  controllerFor as controllerFor2,
+  loadTsplcConfig as loadTsplcConfig3,
+  rawBuildConfig,
+  simulationConfig
+} from "@tsplc/config";
+import {
+  buildProject as buildSt,
+  configureDocker,
+  configureRuntime,
+  inspectController,
+  installLibraries as installLibraries3,
+  loadSources,
+  resolveConfig,
+  runProject,
+  updateController
+} from "@tsplc/build";
+import { checkHostConfig as checkHostConfig3 } from "@tsplc/compiler";
+import { formatDiagnostic, hasErrors as hasErrors4 } from "@tsplc/compiler/ir";
+import { deviceTree as deviceTree3 } from "@tsplc/typegen";
+import { loadHardware as loadHardware3, resolveIo as resolveIo3 } from "@tsplc/typegen/hardware";
+import { generateProject as generateProject2 } from "@tsplc/typegen";
+
+// packages/compiler/project/plant.ts
+import { basename, relative, resolve as resolve4, sep } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { pathToFileURL } from "node:url";
+import {
+  AgentOperationError,
+  createAgentClient
+} from "@tsplc/agent/client";
+import { controllerFor } from "@tsplc/config";
+import { hasErrors as hasErrors2 } from "@tsplc/compiler/ir";
+import { generateProject } from "@tsplc/typegen";
+import { z } from "zod";
+
+// packages/compiler/project/project.ts
+import { copyFile, mkdir as mkdir3, mkdtemp as mkdtemp2, realpath, rm as rm3, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname as dirname3, join as join3, resolve as resolve2 } from "node:path";
+import {
+  buildCodesys,
+  codesysBuildConfig,
+  diagnoseCodesys,
+  emitCodesys,
+  ioTargets,
+  publicationSelectors,
+  planCodesys
+} from "@tsplc/compiler/codesys";
+import { analyze, checkHostConfig } from "@tsplc/compiler";
+import {
+  compilerConfig,
+  loadTsplcConfig
+} from "@tsplc/config";
+import { deviceTree, loadHardware, resolveIo } from "@tsplc/typegen";
+import { installLibraries } from "@tsplc/build";
+import { hasErrors, normalizeModule } from "@tsplc/compiler/ir";
+
+// packages/compiler/project/artifacts.ts
+import { createHash } from "node:crypto";
+import { lstat, mkdir as mkdir2, readdir, readFile, rename as rename2, rm as rm2, writeFile } from "node:fs/promises";
+import { dirname as dirname2, join as join2 } from "node:path";
+var missing = (cause) => cause instanceof Error && ("code" in cause) && cause.code === "ENOENT";
+var digest = (value) => createHash("sha256").update(value).digest("hex");
+function manifest(value, configFile) {
+  if (typeof value !== "object" || value === null || !("kind" in value) || value.kind !== "tsplc-artifacts" || !("version" in value) || value.version !== 1 || !("configFile" in value) || value.configFile !== configFile || !("files" in value) || !Array.isArray(value.files)) {
+    throw new Error("Output directory has no matching tsPLC ownership manifest.");
+  }
+  const files = value.files.map((item) => {
+    if (typeof item !== "object" || item === null || !("path" in item) || typeof item.path !== "string" || !/^[A-Za-z0-9_ .-]+(?:\/[A-Za-z0-9_ .-]+)*$/.test(item.path) || item.path.split("/").some((part) => part === "." || part === "..") || ["manifest.json", "receipt.json"].includes(item.path) || !("sha256" in item) || typeof item.sha256 !== "string" || !/^[0-9a-f]{64}$/.test(item.sha256)) {
+      throw new Error("Invalid generated file ownership entry.");
+    }
+    return { path: item.path, sha256: item.sha256 };
+  });
+  if (new Set(files.map((item) => item.path)).size !== files.length) {
+    throw new Error("Duplicate generated file ownership entry.");
+  }
+  return { kind: "tsplc-artifacts", version: 1, configFile, files };
+}
+async function directory(path) {
+  try {
+    const entry = await lstat(path);
+    if (!entry.isDirectory() || entry.isSymbolicLink()) {
+      throw new Error(`Generated directory must be a real directory: ${path}`);
+    }
+    return true;
+  } catch (cause) {
+    if (missing(cause)) {
+      return false;
+    }
+    throw cause;
+  }
+}
+async function filesIn(path, prefix = "") {
+  const result = [];
+  for (const entry of await readdir(path, { withFileTypes: true })) {
+    const name = prefix + entry.name;
+    if (entry.isDirectory() && !entry.isSymbolicLink()) {
+      result.push(...await filesIn(join2(path, entry.name), `${name}/`));
+    } else {
+      result.push(name);
+    }
+  }
+  return result;
+}
+async function engineeringDirectory(path, configFile) {
+  const marker = join2(path, "ownership.json");
+  const exists = await directory(path);
+  if (!exists || !(await readdir(path)).length) {
+    await mkdir2(path, { recursive: true });
+    await writeFile(marker, `${JSON.stringify({ kind: "tsplc-engineering", version: 1, configFile }, null, 2)}
+`, { flag: "wx" });
+  } else {
+    const entry = await lstat(marker).catch((cause) => {
+      if (missing(cause)) {
+        throw new Error(`Engineering cache has no matching tsPLC ownership marker: ${path}`);
+      }
+      throw cause;
+    });
+    if (!entry.isFile() || entry.isSymbolicLink()) {
+      throw new Error("Engineering ownership marker must be a real file.");
+    }
+    const value = JSON.parse(await readFile(marker, "utf8"));
+    if (value?.kind !== "tsplc-engineering" || value.version !== 1 || value.configFile !== configFile) {
+      throw new Error(`Engineering cache has no matching tsPLC ownership marker: ${path}`);
+    }
+  }
+  const inspect = async (directory) => {
+    for (const entry of await readdir(directory, { withFileTypes: true })) {
+      const child = join2(directory, entry.name);
+      if (entry.isSymbolicLink()) {
+        throw new Error(`Engineering cache must not contain symlinks: ${child}`);
+      }
+      if (entry.isDirectory()) {
+        await inspect(child);
+      }
+    }
+  };
+  await inspect(path);
+}
+async function owned(configFile, withdrawReceipt = false) {
+  const root = join2(dirname2(configFile), ".tsplc");
+  const output = join2(root, "artifacts");
+  if (!await directory(root) || !await directory(output)) {
+    return { root, output, unknown: [] };
+  }
+  const manifestPath = join2(output, "manifest.json");
+  const manifestEntry = await lstat(manifestPath);
+  if (!manifestEntry.isFile() || manifestEntry.isSymbolicLink()) {
+    throw new Error("Ownership manifest must be a real file.");
+  }
+  const ownership = manifest(JSON.parse(await readFile(manifestPath, "utf8")), configFile);
+  const receipt = join2(output, "receipt.json");
+  try {
+    const entry = await lstat(receipt);
+    if (!entry.isFile() || entry.isSymbolicLink()) {
+      throw new Error("Build receipt must be a real file.");
+    }
+    const value = JSON.parse(await readFile(receipt, "utf8"));
+    if (value?.kind !== "tsplc-build" || value.version !== 1 || value.configFile !== configFile || !["emitted", "vendor-compiled"].includes(value.status)) {
+      throw new Error("Build receipt is not owned by this configuration.");
+    }
+    if (withdrawReceipt) {
+      await rm2(receipt);
+    }
+  } catch (cause) {
+    if (!missing(cause)) {
+      throw cause;
+    }
+  }
+  const names = new Set([
+    ...ownership.files.map((file) => file.path),
+    "manifest.json",
+    "receipt.json"
+  ]);
+  for (const file of ownership.files) {
+    let parent = output;
+    for (const part of file.path.split("/").slice(0, -1)) {
+      parent = join2(parent, part);
+      if (!await directory(parent)) {
+        throw new Error(`Missing generated directory: ${parent}`);
+      }
+    }
+    const path = join2(output, file.path);
+    const entry = await lstat(path);
+    if (!entry.isFile() || entry.isSymbolicLink() || digest(await readFile(path)) !== file.sha256) {
+      throw new Error(`Generated file was replaced or edited; preserve it before rebuilding/cleaning: ${path}`);
+    }
+  }
+  return {
+    root,
+    output,
+    ownership,
+    unknown: (await filesIn(output)).filter((name) => !names.has(name))
+  };
+}
+async function publishArtifacts(staging, previous, receipt) {
+  const configFile = receipt.configFile;
+  const generated = (await filesIn(staging)).sort();
+  const ownership = { kind: "tsplc-artifacts", version: 1, configFile, files: [] };
+  for (const path of generated) {
+    ownership.files.push({ path, sha256: digest(await readFile(join2(staging, path))) });
+  }
+  await writeFile(join2(staging, "manifest.json"), `${JSON.stringify(ownership, null, 2)}
+`);
+  await writeFile(join2(staging, "receipt.json"), `${JSON.stringify({ kind: "tsplc-build", version: 1, generatedAt: new Date().toISOString(), ...receipt }, null, 2)}
+`);
+  const current = await owned(configFile);
+  if (JSON.stringify(current.ownership) !== JSON.stringify(previous.ownership)) {
+    throw new Error("Output ownership changed during the build; preserve it before rebuilding.");
+  }
+  if (current.unknown.length) {
+    throw new Error(`Output contains unrelated files: ${current.unknown.join(", ")}`);
+  }
+  const backup = `${staging}-previous`;
+  if (previous.ownership) {
+    await rename2(previous.output, backup);
+  }
+  try {
+    await rename2(staging, previous.output);
+  } catch (cause) {
+    if (previous.ownership) {
+      await rename2(backup, previous.output);
+    }
+    throw cause;
+  }
+  if (previous.ownership) {
+    await rm2(backup, { recursive: true });
+  }
+}
+async function cleanArtifacts(configFile) {
+  const generated = await owned(configFile);
+  if (!generated.ownership) {
+    return;
+  }
+  for (const entry of generated.ownership.files) {
+    await rm2(join2(generated.output, entry.path));
+  }
+  await rm2(join2(generated.output, "receipt.json"), { force: true });
+  await rm2(join2(generated.output, "manifest.json"));
+  const removeEmpty = async (path) => {
+    for (const entry of await readdir(path, { withFileTypes: true })) {
+      if (entry.isDirectory() && !entry.isSymbolicLink()) {
+        await removeEmpty(join2(path, entry.name));
+      }
+    }
+    if (!(await readdir(path)).length) {
+      await rm2(path, { recursive: true });
+    }
+  };
+  await removeEmpty(generated.output);
+}
+
+// packages/compiler/project/project.ts
+var failure = (origin, code, cause) => ({
+  origin,
+  code,
+  severity: "error",
+  message: cause instanceof Error ? cause.message : String(cause)
+});
+async function loadProject(file, loaded, buildTarget) {
+  let configFile = resolve2(file);
+  try {
+    configFile = await realpath(configFile);
+    const diagnostics = checkHostConfig(configFile);
+    if (hasErrors(diagnostics))
+      return { configFile, diagnostics };
+    const shared = (loaded ?? await loadTsplcConfig(configFile)).config;
+    const root = dirname3(configFile);
+    const config = compilerConfig(shared, resolveIo(shared, await loadHardware(shared, root)), buildTarget);
+    return {
+      configFile,
+      shared,
+      config: { ...config, ...sourceInput(config, root) },
+      diagnostics
+    };
+  } catch (cause) {
+    return { configFile, diagnostics: [failure("config", "PLC5003", cause)] };
+  }
+}
+function sourceInput(compiler, root) {
+  return {
+    tsconfig: resolve2(root, compiler.tsconfig),
+    programs: Object.fromEntries(Object.entries(compiler.programs).map(([name, entry]) => [
+      name,
+      { ...entry, module: resolve2(root, entry.module) }
+    ]))
+  };
+}
+async function projectTargets(file = "tsplc.config.ts", options = {}) {
+  const configFile = await realpath(resolve2(file));
+  const { config } = options.loaded ?? await loadTsplcConfig(configFile);
+  if (!config.compiler)
+    return;
+  const source = analyze({
+    ...sourceInput(config.compiler, dirname3(configFile)),
+    services: config.server
+  });
+  const core = source.module && normalizeModule(source.module).core;
+  return core ? { io: ioTargets(core), publication: publicationSelectors(core) } : undefined;
+}
+async function checkProject(file = "tsplc.config.ts", options = {}) {
+  const loaded = await loadProject(file, options.loaded, options.buildTarget);
+  if (!loaded.config) {
+    return loaded;
+  }
+  const config = loaded.config;
+  if (config.target.kind !== "codesys") {
+    return {
+      ...loaded,
+      diagnostics: [failure("backend", "PLC7001", `Unsupported target: ${config.target.kind}`)]
+    };
+  }
+  const source = analyze({
+    tsconfig: config.tsconfig,
+    programs: config.programs,
+    services: loaded.shared?.server
+  });
+  if (!source.module) {
+    return { ...loaded, diagnostics: source.diagnostics };
+  }
+  const normalized = normalizeModule(source.module);
+  if (!normalized.core) {
+    return { ...loaded, diagnostics: normalized.diagnostics };
+  }
+  const tasks = config.tasks.map((task) => ({
+    name: task.name,
+    intervalNanoseconds: task.schedule.interval.nanoseconds,
+    priority: task.priority,
+    programs: task.programs
+  }));
+  const planned = planCodesys(normalized.core, { tasks }, config.target.options);
+  return {
+    ...loaded,
+    ...planned,
+    diagnostics: [
+      ...loaded.diagnostics,
+      ...source.diagnostics,
+      ...normalized.diagnostics,
+      ...planned.diagnostics
+    ]
+  };
+}
+async function engineeringInputs(shared, configFile, bundle, frozen) {
+  const root = dirname3(configFile);
+  const tree = await deviceTree(shared, await loadHardware(shared, root));
+  return {
+    libraries: await installLibraries(shared.dependencies, root, { frozen }),
+    deviceTree: tree && {
+      ...tree,
+      mappings: bundle.ioMappings.map(({ address, variable }) => ({ address, variable }))
+    }
+  };
+}
+async function buildProject(file = "tsplc.config.ts", options = {}) {
+  let staging;
+  try {
+    const configFile = await realpath(resolve2(file));
+    const previous = await owned(configFile, true);
+    if (previous.unknown.length) {
+      throw new Error(`Output contains unrelated files: ${previous.unknown.join(", ")}`);
+    }
+    const checked = await checkProject(configFile, {
+      loaded: options.loaded,
+      buildTarget: options.buildTarget
+    });
+    if (!checked.plan || !checked.config) {
+      return { diagnostics: checked.diagnostics };
+    }
+    const bundle = emitCodesys(checked.plan);
+    if (hasErrors(bundle.diagnostics)) {
+      return { diagnostics: bundle.diagnostics };
+    }
+    const shared = checked.shared;
+    const engineering = shared && (!options.emitOnly || options.forController) ? await engineeringInputs(shared, configFile, bundle, options.frozenLockfile) : undefined;
+    const controllerConfig = shared?.build ? codesysBuildConfig(checked.plan, bundle, {
+      configFile,
+      sourceDir: join3(previous.output, "st"),
+      outDir: resolve2(dirname3(configFile), shared.build.outDir),
+      controller: options.controller,
+      ...engineering
+    }) : undefined;
+    await mkdir3(previous.root, { recursive: true });
+    staging = await mkdtemp2(join3(previous.root, "stage-"));
+    const artifacts = [
+      ...bundle.artifacts,
+      { path: "mappings.json", content: `${JSON.stringify(bundle.mappings, null, 2)}
+` },
+      { path: "io-symbols.json", content: `${JSON.stringify(bundle.ioSymbols, null, 2)}
+` },
+      { path: "publication.json", content: `${JSON.stringify(bundle.publication, null, 2)}
+` },
+      { path: "config.json", content: `${JSON.stringify(checked.config, null, 2)}
+` }
+    ];
+    for (const artifact of artifacts) {
+      const path = join3(staging, "st", artifact.path);
+      await mkdir3(dirname3(path), { recursive: true });
+      await writeFile2(path, artifact.content);
+    }
+    let vendor;
+    if (!options.emitOnly) {
+      const outDir = shared?.build ? resolve2(dirname3(configFile), shared.build.outDir ?? "build") : join3(previous.root, "engineering");
+      await engineeringDirectory(outDir, configFile);
+      try {
+        vendor = await buildCodesys(checked.plan, bundle, {
+          configFile,
+          sourceDir: join3(staging, "st"),
+          outDir,
+          controller: options.controller,
+          ...engineering
+        });
+      } catch (cause) {
+        return { diagnostics: diagnoseCodesys(cause, bundle) };
+      }
+      const vendorArtifacts = [
+        ["Application.project", vendor.project],
+        ["Application.app", vendor.output],
+        ["Application.crc", vendor.checksum]
+      ];
+      for (const [name, path] of vendorArtifacts) {
+        if (!path)
+          continue;
+        const destination = join3(staging, "vendor", name);
+        await mkdir3(dirname3(destination), { recursive: true });
+        await copyFile(path, destination);
+      }
+    }
+    const status = vendor ? "vendor-compiled" : "emitted";
+    await publishArtifacts(staging, previous, {
+      configFile,
+      status,
+      ...vendor && { vendor: { application: vendor.application, tasks: vendor.tasks } }
+    });
+    staging = undefined;
+    return {
+      directory: previous.output,
+      status,
+      ...controllerConfig && { controllerConfig },
+      diagnostics: [...checked.diagnostics, ...bundle.diagnostics]
+    };
+  } catch (cause) {
+    return { diagnostics: [failure("config", "PLC5004", cause)] };
+  } finally {
+    if (staging) {
+      await rm3(staging, { recursive: true, force: true });
+    }
+  }
+}
+
+// packages/compiler/project/server.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { mkdtemp as mkdtemp3, mkdir as mkdir4, rm as rm4, rename as rename3 } from "node:fs/promises";
+import { dirname as dirname4, resolve as resolve3, join as join4 } from "node:path";
+import { createRequire as createRequire2 } from "node:module";
+import ts2 from "typescript";
+import { typeCheckOnly as typeCheckOnly2 } from "@tsplc/compiler";
+var resolveServerModule2 = (root, name) => name.startsWith(".") || name.startsWith("/") || existsSync2(resolve3(root, name)) ? resolve3(root, name) : createRequire2(join4(root, "package.json")).resolve(name);
+var kebabCase2 = (name) => name.replace(/([a-z0-9])([A-Z])|([A-Z])([A-Z][a-z])/g, "$1$3-$2$4").replace(/[^A-Za-z0-9]+/g, "-").replace(/^-|-$/g, "").toLowerCase();
+var buildServer2 = async (config, root) => {
+  const settings = config.server;
+  if (!settings?.runtime)
+    throw new Error("Configure server.runtime to build an executable.");
+  const runtime = settings.runtime;
+  const entry = resolveServerModule2(root, runtime.entry);
+  const windows = runtime.target ? runtime.target.includes("windows") : process.platform === "win32";
+  const outFile = resolve3(root, "build/server", `${kebabCase2(config.name)}-services${windows ? ".exe" : ""}`);
+  const tsconfig = ts2.findConfigFile(dirname4(entry), ts2.sys.fileExists);
+  if (!tsconfig)
+    throw new Error("Server entry requires a tsconfig.json.");
+  const read = ts2.readConfigFile(tsconfig, ts2.sys.readFile);
+  if (read.error)
+    throw new Error(ts2.flattenDiagnosticMessageText(read.error.messageText, `
+`));
+  const parsed = ts2.parseJsonConfigFileContent(read.config, ts2.sys, dirname4(tsconfig));
+  const program = ts2.createProgram({
+    rootNames: [entry, ...parsed.fileNames.filter((file) => /\.d\.[cm]?ts$/.test(file))],
+    options: { ...parsed.options, ...typeCheckOnly2 },
+    projectReferences: parsed.projectReferences
+  });
+  const diagnostics = [...parsed.errors, ...ts2.getPreEmitDiagnostics(program)];
+  if (diagnostics.length)
+    throw new Error(ts2.formatDiagnosticsWithColorAndContext(diagnostics, {
+      getCanonicalFileName: (path) => path,
+      getCurrentDirectory: () => root,
+      getNewLine: () => `
+`
+    }));
+  await mkdir4(dirname4(outFile), { recursive: true });
+  const staging = await mkdtemp3(join4(dirname4(outFile), ".tsplc-server-"));
+  try {
+    const binary = join4(staging, "server");
+    const result = await Bun.build({
+      entrypoints: [entry],
+      env: "disable",
+      compile: {
+        outfile: binary,
+        ...runtime.target ? { target: runtime.target } : {},
+        autoloadDotenv: false,
+        autoloadBunfig: false,
+        autoloadTsconfig: false,
+        autoloadPackageJson: false
+      }
+    });
+    if (!result.success)
+      throw new AggregateError(result.logs, "Server executable build failed.");
+    await rename3(windows ? `${binary}.exe` : binary, outFile);
+    return {
+      server: {
+        executable: outFile,
+        target: runtime.target ?? `bun-${process.platform}-${process.arch}`
+      }
+    };
+  } finally {
+    await rm4(staging, { recursive: true, force: true });
+  }
+};
+
+// packages/compiler/project/plant.ts
+var plantCommands = new Set([
+  "deploy",
+  "target",
+  "status",
+  "login",
+  "logout",
+  "vars",
+  "read",
+  "write",
+  "force",
+  "unforce",
+  "start",
+  "stop",
+  "reset"
+]);
+var ask = async (question) => {
+  const lines = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    return (await lines.question(question)).trim();
+  } finally {
+    lines.close();
+  }
+};
+var askSecret = (question) => new Promise((accept, reject) => {
+  if (!process.stdin.isTTY) {
+    reject(new Error("The controller password needs an interactive terminal."));
+    return;
+  }
+  process.stdin.setRawMode(true);
+  process.stdin.setEncoding("utf8");
+  process.stdin.resume();
+  process.stdout.write(question);
+  let secret = "";
+  const finish = () => {
+    process.stdin.off("data", read);
+    process.stdin.setRawMode(false);
+    process.stdin.pause();
+    process.stdout.write(`
+`);
+  };
+  const read = (text) => {
+    for (const character of text) {
+      if (character === "\r" || character === `
+`) {
+        finish();
+        accept(secret);
+        return;
+      }
+      if (character === "\x03") {
+        finish();
+        reject(new Error("Cancelled."));
+        return;
+      }
+      secret = character === "" ? secret.slice(0, -1) : secret + character;
+    }
+  };
+  process.stdin.on("data", read);
+});
+var choose = async (question, items, label) => {
+  items.forEach((item, index) => console.log(`  ${index + 1}. ${label(item)}`));
+  while (true) {
+    const item = items[Number(await ask(`${question} [1-${items.length}]: `)) - 1];
+    if (item !== undefined)
+      return item;
+  }
+};
+var confirm = async (question, flags) => flags.yes || /^y(es)?$/i.test(await ask(`${question} [y/N]: `));
+var askCredentials = async () => ({
+  username: await ask("Controller username: "),
+  password: await askSecret("Controller password: ")
+});
+var progress = (message) => console.log(`  ${message}`);
+var connect = () => {
+  const environment = z.object({
+    TSPLC_AGENT_URL: z.url({
+      error: "Set TSPLC_AGENT_URL to the plant agent, such as http://line-pc:4850"
+    }),
+    TSPLC_AGENT_TOKEN: z.string({ error: "Set TSPLC_AGENT_TOKEN to the plant agent's token" })
+  }).parse(process.env);
+  return createAgentClient({
+    url: environment.TSPLC_AGENT_URL,
+    token: environment.TSPLC_AGENT_TOKEN
+  });
+};
+var selectTarget = async (agent) => {
+  const interfaces = await agent.interfaces();
+  if (!interfaces.length)
+    throw new Error("The plant PC has no IPv4 network.");
+  const network = interfaces.length === 1 && interfaces[0] ? interfaces[0] : await choose("Which network is the controller on?", interfaces, (item) => `${item.name}  ${item.address}/${item.prefixLength}`);
+  console.log(`Scanning ${network.address}/${network.prefixLength} for CODESYS controllers…`);
+  const found = await agent.discover(network.name);
+  const manual = { address: "", port: 11740, hostname: null };
+  const choice = await choose("Which controller?", [...found, manual], (item) => item === manual ? "Enter an address" : `${item.address}${item.hostname ? `  (${item.hostname})` : ""}`);
+  const host = choice === manual ? await ask("Controller address: ") : choice.address;
+  return agent.setTarget({ host, port: choice.port });
+};
+var contractVariables = async (config, root) => {
+  if (!config.typegen)
+    return [];
+  const contract = z.object({
+    symbols: z.array(z.object({ name: z.string(), gvl: z.string(), type: z.string() })),
+    typeFields: z.record(z.string(), z.array(z.object({ field: z.string(), type: z.string() })))
+  }).parse(await import(pathToFileURL(resolve4(root, config.typegen.dir, "plc.ts")).href));
+  return contract.symbols.flatMap(({ name, gvl, type }) => {
+    const path = `${gvl}.${name}`;
+    const fields = contract.typeFields[type];
+    if (!fields)
+      return [{ path, type }];
+    return fields.map((field) => ({
+      path: field.field === "" ? path : `${path}${field.field.startsWith("[") ? "" : "."}${field.field}`,
+      type: field.type
+    }));
+  });
+};
+var prepareRelease = async (file, loaded, flags) => {
+  const { config, root } = loaded;
+  if (!config.compiler)
+    throw new Error("tsplc deploy deploys tsPLC programs; configure compiler.");
+  const emitted = await buildProject(file, {
+    emitOnly: true,
+    forController: true,
+    frozenLockfile: flags["frozen-lockfile"],
+    loaded,
+    buildTarget: "production",
+    controller: controllerFor(config, "deploy")
+  });
+  if (hasErrors2(emitted.diagnostics))
+    return { diagnostics: emitted.diagnostics };
+  const settings = emitted.controllerConfig;
+  if (!settings)
+    throw new Error("Configure build settings for deployment.");
+  await generateProject(file, { loaded, targets: await projectTargets(file, { loaded }) });
+  const portable = (path) => path.split(sep).join("/");
+  const libraries = (settings.libraries ?? []).map((library) => ({
+    ...library,
+    release: `libraries/${library.sha256}-${basename(library.path)}`
+  }));
+  const files = [
+    { path: "template.project", content: Bun.file(settings.template) },
+    ...libraries.map((library) => ({ path: library.release, content: Bun.file(library.path) }))
+  ];
+  for await (const source of new Bun.Glob("**/*").scan({ cwd: settings.sourceDir, dot: true }))
+    files.push({
+      path: `st/${portable(source)}`,
+      content: Bun.file(resolve4(settings.sourceDir, source))
+    });
+  let server;
+  if (config.server?.runtime) {
+    const { executable } = (await buildServer2(config, root)).server;
+    server = `server/${basename(executable)}`;
+    files.push({ path: server, content: Bun.file(executable) });
+  }
+  const manifest = {
+    config: {
+      io: {},
+      deviceTree: settings.deviceTree,
+      controller: settings.controller,
+      libraryReferences: settings.libraryReferences,
+      libraries: libraries.map(({ release, ...library }) => ({ ...library, path: release })),
+      task: settings.task,
+      tasks: settings.tasks,
+      removeObjects: settings.removeObjects,
+      symbols: settings.symbols,
+      timeouts: settings.timeouts,
+      template: "template.project",
+      sourceDir: "st",
+      entry: `st/${portable(relative(settings.sourceDir, settings.entry))}`
+    },
+    variables: await contractVariables(config, root),
+    server
+  };
+  return { release: { manifest, files } };
+};
+var deploy = async (agent, file, loaded, flags) => {
+  const status = await agent.status();
+  if (status.login)
+    throw new Error("A login is open; log out before deploying: tsplc logout");
+  const target = !status.target || flags.select ? await selectTarget(agent) : status.target;
+  console.log(`Building the release for ${target.host}…`);
+  const { release, diagnostics } = await prepareRelease(file, loaded, flags);
+  if (!release)
+    return { diagnostics };
+  if (flags.download && !await confirm("A full download stops the running application while it loads. Continue?", flags))
+    throw new Error("Cancelled.");
+  const credentials = await askCredentials();
+  const settings = {
+    credentials,
+    download: flags.download ?? false,
+    initializeUser: flags["initialize-user"] ?? false
+  };
+  console.log(release.manifest.server ? "Deploying the server and the program…" : "Deploying the program…");
+  try {
+    return await agent.deploy(release, settings, progress);
+  } catch (error) {
+    if (!(error instanceof AgentOperationError && error.downloadRequired) || !await confirm(`${error.message}. A full download stops the running application while it loads. Download now?`, flags))
+      throw error;
+    return agent.deploy(release, { ...settings, download: true }, progress);
+  }
+};
+var ensureLogin = async (agent) => {
+  if ((await agent.status()).login)
+    return;
+  const credentials = await askCredentials();
+  console.log("Logging in. CODESYS takes a few minutes to start; the login stays open until tsplc logout.");
+  await agent.login(credentials, progress);
+};
+var variableChildren = (variables, prefix) => {
+  const children = new Map;
+  const start = prefix.toLowerCase();
+  for (const { path, type } of variables) {
+    const lower = path.toLowerCase();
+    if (prefix && !(lower === start || lower.startsWith(`${start}.`) || lower.startsWith(`${start}[`)))
+      continue;
+    const rest = path.slice(prefix.length).replace(/^\./, "");
+    if (rest === "")
+      return [{ name: path, type, leaves: 1 }];
+    const name = /^(\[[^\]]*\]|[^.[]+)/.exec(rest)?.[0] ?? rest;
+    const child = children.get(name) ?? { leaves: 0 };
+    children.set(name, { type: rest === name ? type : undefined, leaves: child.leaves + 1 });
+  }
+  const indexes = [...children.keys()].filter((name) => /^\[\d+\]$/.test(name)).map((name) => Number(name.slice(1, -1)));
+  const listed = [...children].filter(([name]) => !/^\[\d+\]$/.test(name));
+  if (indexes.length) {
+    const first = children.get(`[${Math.min(...indexes)}]`);
+    listed.unshift([`[${Math.min(...indexes)}..${Math.max(...indexes)}]`, first ?? { leaves: 0 }]);
+  }
+  return listed.map(([name, child]) => ({ name, ...child }));
+};
+var printLogin = (result) => {
+  if ("values" in result) {
+    for (const [expression, value] of Object.entries(result.values))
+      console.log(`${expression} = ${value}`);
+    return;
+  }
+  console.log(`Application ${result.state}`);
+  if (result.forced.length)
+    console.log(`Forced: ${result.forced.join(", ")}`);
+};
+var runPlantCommand = async (command, args, flags, project) => {
+  const agent = connect();
+  const expect = (count, usage) => {
+    if (args.length !== count)
+      throw new Error(`Usage: tsplc ${command} ${usage}`);
+  };
+  const send = async (loginCommand) => {
+    await ensureLogin(agent);
+    printLogin(await agent.command(loginCommand));
+  };
+  switch (command) {
+    case "deploy": {
+      expect(0, "[--download] [--select] [--initialize-user]");
+      const deployed = await deploy(agent, project.file, await project.load(), flags);
+      if ("diagnostics" in deployed)
+        return deployed;
+      console.log(`Deployed release ${deployed.id} (${deployed.operation}).`);
+      return;
+    }
+    case "target": {
+      expect(0, "");
+      const target = await selectTarget(agent);
+      console.log(`Deployments now go to ${target.host}:${target.port}.`);
+      return;
+    }
+    case "status": {
+      expect(0, "");
+      const status = await agent.status();
+      console.log(`Controller  ${status.target ? `${status.target.host}:${status.target.port}` : "not selected (tsplc target)"}`);
+      console.log(`Release     ${status.release ? `${status.release.id}, ${status.release.operation} at ${status.release.deployedAt}` : "none"}`);
+      console.log(`Server      ${status.server ? `${status.server.running ? "running" : "restarting"} (${status.server.executable})` : "none"}`);
+      console.log(`Login       ${status.login ? `open; application ${status.login.state}${status.login.forced.length ? `; forced: ${status.login.forced.join(", ")}` : ""}` : "closed"}`);
+      return;
+    }
+    case "login":
+      expect(0, "");
+      await ensureLogin(agent);
+      printLogin(await agent.command({ command: "state" }));
+      return;
+    case "logout": {
+      expect(0, "");
+      const forced = (await agent.status()).login?.forced ?? [];
+      if (forced.length && !await confirm(`Forced: ${forced.join(", ")}. Forces stay on the controller after logout. Log out anyway?`, flags))
+        throw new Error("Cancelled.");
+      await agent.logout();
+      console.log("Logged out.");
+      return;
+    }
+    case "vars": {
+      if (args.length > 1)
+        throw new Error("Usage: tsplc vars [path]");
+      const variables = await agent.variables();
+      const children = variableChildren(variables, args[0] ?? "");
+      if (!children.length)
+        throw new Error(`No published variable ${args[0]}.`);
+      for (const child of children)
+        console.log(`${child.name.padEnd(32)} ${child.type ?? `${child.leaves} variables`}`);
+      return;
+    }
+    case "read": {
+      const [first, ...rest] = args;
+      if (!first)
+        throw new Error("Usage: tsplc read <expression>...");
+      return send({ command: "read", expressions: [first, ...rest] });
+    }
+    case "write":
+    case "force": {
+      const [expression, value, ...extra] = args;
+      if (!expression || !value || extra.length)
+        throw new Error(`Usage: tsplc ${command} <expression> <value>`);
+      return send({ command, values: { [expression]: value } });
+    }
+    case "unforce":
+      return send({ command: "unforce", expressions: args, restore: flags.restore ?? false });
+    case "start":
+      expect(0, "");
+      return send({ command: "start" });
+    case "stop":
+      expect(0, "");
+      if (!await confirm("Stop the application on the controller?", flags))
+        throw new Error("Cancelled.");
+      return send({ command: "stop" });
+    case "reset": {
+      expect(1, "warm|cold");
+      const kind = z.enum(["warm", "cold"]).parse(args[0]);
+      if (!await confirm(`Reset the application (${kind})? It stops and reinitializes its variables.`, flags))
+        throw new Error("Cancelled.");
+      return send({ command: "reset", kind: kind === "warm" ? "Warm" : "Cold" });
+    }
+  }
+};
+
+// packages/compiler/project/project.ts
+import { copyFile as copyFile2, mkdir as mkdir5, mkdtemp as mkdtemp4, realpath as realpath2, rm as rm5, writeFile as writeFile3 } from "node:fs/promises";
+import { dirname as dirname5, join as join5, resolve as resolve5 } from "node:path";
+import {
+  buildCodesys as buildCodesys2,
+  codesysBuildConfig as codesysBuildConfig2,
+  diagnoseCodesys as diagnoseCodesys2,
+  emitCodesys as emitCodesys2,
+  ioTargets as ioTargets2,
+  publicationSelectors as publicationSelectors2,
+  planCodesys as planCodesys2
+} from "@tsplc/compiler/codesys";
+import { analyze as analyze2, checkHostConfig as checkHostConfig2 } from "@tsplc/compiler";
+import {
+  compilerConfig as compilerConfig2,
+  loadTsplcConfig as loadTsplcConfig2
+} from "@tsplc/config";
+import { deviceTree as deviceTree2, loadHardware as loadHardware2, resolveIo as resolveIo2 } from "@tsplc/typegen";
+import { installLibraries as installLibraries2 } from "@tsplc/build";
+import { hasErrors as hasErrors3, normalizeModule as normalizeModule2 } from "@tsplc/compiler/ir";
+var failure2 = (origin, code, cause) => ({
+  origin,
+  code,
+  severity: "error",
+  message: cause instanceof Error ? cause.message : String(cause)
+});
+async function loadProject2(file, loaded, buildTarget) {
+  let configFile = resolve5(file);
+  try {
+    configFile = await realpath2(configFile);
+    const diagnostics = checkHostConfig2(configFile);
+    if (hasErrors3(diagnostics))
+      return { configFile, diagnostics };
+    const shared = (loaded ?? await loadTsplcConfig2(configFile)).config;
+    const root = dirname5(configFile);
+    const config = compilerConfig2(shared, resolveIo2(shared, await loadHardware2(shared, root)), buildTarget);
+    return {
+      configFile,
+      shared,
+      config: { ...config, ...sourceInput2(config, root) },
+      diagnostics
+    };
+  } catch (cause) {
+    return { configFile, diagnostics: [failure2("config", "PLC5003", cause)] };
+  }
+}
+function sourceInput2(compiler, root) {
+  return {
+    tsconfig: resolve5(root, compiler.tsconfig),
+    programs: Object.fromEntries(Object.entries(compiler.programs).map(([name, entry]) => [
+      name,
+      { ...entry, module: resolve5(root, entry.module) }
+    ]))
+  };
+}
+async function projectTargets2(file = "tsplc.config.ts", options = {}) {
+  const configFile = await realpath2(resolve5(file));
+  const { config } = options.loaded ?? await loadTsplcConfig2(configFile);
+  if (!config.compiler)
+    return;
+  const source = analyze2({
+    ...sourceInput2(config.compiler, dirname5(configFile)),
+    services: config.server
+  });
+  const core = source.module && normalizeModule2(source.module).core;
+  return core ? { io: ioTargets2(core), publication: publicationSelectors2(core) } : undefined;
+}
+async function checkProject2(file = "tsplc.config.ts", options = {}) {
+  const loaded = await loadProject2(file, options.loaded, options.buildTarget);
+  if (!loaded.config) {
+    return loaded;
+  }
+  const config = loaded.config;
+  if (config.target.kind !== "codesys") {
+    return {
+      ...loaded,
+      diagnostics: [failure2("backend", "PLC7001", `Unsupported target: ${config.target.kind}`)]
+    };
+  }
+  const source = analyze2({
+    tsconfig: config.tsconfig,
+    programs: config.programs,
+    services: loaded.shared?.server
+  });
+  if (!source.module) {
+    return { ...loaded, diagnostics: source.diagnostics };
+  }
+  const normalized = normalizeModule2(source.module);
+  if (!normalized.core) {
+    return { ...loaded, diagnostics: normalized.diagnostics };
+  }
+  const tasks = config.tasks.map((task) => ({
+    name: task.name,
+    intervalNanoseconds: task.schedule.interval.nanoseconds,
+    priority: task.priority,
+    programs: task.programs
+  }));
+  const planned = planCodesys2(normalized.core, { tasks }, config.target.options);
+  return {
+    ...loaded,
+    ...planned,
+    diagnostics: [
+      ...loaded.diagnostics,
+      ...source.diagnostics,
+      ...normalized.diagnostics,
+      ...planned.diagnostics
+    ]
+  };
+}
+async function engineeringInputs2(shared, configFile, bundle, frozen) {
+  const root = dirname5(configFile);
+  const tree = await deviceTree2(shared, await loadHardware2(shared, root));
+  return {
+    libraries: await installLibraries2(shared.dependencies, root, { frozen }),
+    deviceTree: tree && {
+      ...tree,
+      mappings: bundle.ioMappings.map(({ address, variable }) => ({ address, variable }))
+    }
+  };
+}
+async function buildProject2(file = "tsplc.config.ts", options = {}) {
+  let staging;
+  try {
+    const configFile = await realpath2(resolve5(file));
+    const previous = await owned(configFile, true);
+    if (previous.unknown.length) {
+      throw new Error(`Output contains unrelated files: ${previous.unknown.join(", ")}`);
+    }
+    const checked = await checkProject2(configFile, {
+      loaded: options.loaded,
+      buildTarget: options.buildTarget
+    });
+    if (!checked.plan || !checked.config) {
+      return { diagnostics: checked.diagnostics };
+    }
+    const bundle = emitCodesys2(checked.plan);
+    if (hasErrors3(bundle.diagnostics)) {
+      return { diagnostics: bundle.diagnostics };
+    }
+    const shared = checked.shared;
+    const engineering = shared && (!options.emitOnly || options.forController) ? await engineeringInputs2(shared, configFile, bundle, options.frozenLockfile) : undefined;
+    const controllerConfig = shared?.build ? codesysBuildConfig2(checked.plan, bundle, {
+      configFile,
+      sourceDir: join5(previous.output, "st"),
+      outDir: resolve5(dirname5(configFile), shared.build.outDir),
+      controller: options.controller,
+      ...engineering
+    }) : undefined;
+    await mkdir5(previous.root, { recursive: true });
+    staging = await mkdtemp4(join5(previous.root, "stage-"));
+    const artifacts = [
+      ...bundle.artifacts,
+      { path: "mappings.json", content: `${JSON.stringify(bundle.mappings, null, 2)}
+` },
+      { path: "io-symbols.json", content: `${JSON.stringify(bundle.ioSymbols, null, 2)}
+` },
+      { path: "publication.json", content: `${JSON.stringify(bundle.publication, null, 2)}
+` },
+      { path: "config.json", content: `${JSON.stringify(checked.config, null, 2)}
+` }
+    ];
+    for (const artifact of artifacts) {
+      const path = join5(staging, "st", artifact.path);
+      await mkdir5(dirname5(path), { recursive: true });
+      await writeFile3(path, artifact.content);
+    }
+    let vendor;
+    if (!options.emitOnly) {
+      const outDir = shared?.build ? resolve5(dirname5(configFile), shared.build.outDir ?? "build") : join5(previous.root, "engineering");
+      await engineeringDirectory(outDir, configFile);
+      try {
+        vendor = await buildCodesys2(checked.plan, bundle, {
+          configFile,
+          sourceDir: join5(staging, "st"),
+          outDir,
+          controller: options.controller,
+          ...engineering
+        });
+      } catch (cause) {
+        return { diagnostics: diagnoseCodesys2(cause, bundle) };
+      }
+      const vendorArtifacts = [
+        ["Application.project", vendor.project],
+        ["Application.app", vendor.output],
+        ["Application.crc", vendor.checksum]
+      ];
+      for (const [name, path] of vendorArtifacts) {
+        if (!path)
+          continue;
+        const destination = join5(staging, "vendor", name);
+        await mkdir5(dirname5(destination), { recursive: true });
+        await copyFile2(path, destination);
+      }
+    }
+    const status = vendor ? "vendor-compiled" : "emitted";
+    await publishArtifacts(staging, previous, {
+      configFile,
+      status,
+      ...vendor && { vendor: { application: vendor.application, tasks: vendor.tasks } }
+    });
+    staging = undefined;
+    return {
+      directory: previous.output,
+      status,
+      ...controllerConfig && { controllerConfig },
+      diagnostics: [...checked.diagnostics, ...bundle.diagnostics]
+    };
+  } catch (cause) {
+    return { diagnostics: [failure2("config", "PLC5004", cause)] };
+  } finally {
+    if (staging) {
+      await rm5(staging, { recursive: true, force: true });
+    }
+  }
+}
+async function cleanProject(file = "tsplc.config.ts") {
+  try {
+    await cleanArtifacts(await realpath2(resolve5(file)));
+    return { diagnostics: [] };
+  } catch (cause) {
+    return { diagnostics: [failure2("config", "PLC5004", cause)] };
+  }
+}
+
+// packages/compiler/project/cli.ts
+async function main() {
+  const { values, positionals } = parseArgs({
+    allowPositionals: true,
+    options: {
+      config: { type: "string" },
+      help: { type: "boolean", short: "h" },
+      "emit-only": { type: "boolean" },
+      format: { type: "string" },
+      read: { type: "string", multiple: true },
+      "initialize-user": { type: "boolean" },
+      "frozen-lockfile": { type: "boolean" },
+      check: { type: "boolean" },
+      plc: { type: "boolean" },
+      server: { type: "boolean" },
+      simulate: { type: "boolean" },
+      runtime: { type: "boolean" },
+      download: { type: "boolean" },
+      restore: { type: "boolean" },
+      select: { type: "boolean" },
+      yes: { type: "boolean", short: "y" }
+    }
+  });
+  const command = positionals[0], file = values.config ?? "tsplc.config.ts";
+  if (!command || values.help) {
+    console.log(`tsplc install|typegen|check|build|run|download|online-change|inspect|clean|configure [--config tsplc.config.ts] [--plc|--server] [--simulate] [--runtime] [--emit-only] [--format json] [--read symbol]
+
+Plant agent (TSPLC_AGENT_URL, TSPLC_AGENT_TOKEN):
+  tsplc deploy [--download] [--select] [--initialize-user]
+  tsplc target | status | login | logout
+  tsplc vars [path] | read <expression>... | write <expression> <value>
+  tsplc force <expression> <value> | unforce [expression]... [--restore]
+  tsplc start | stop | reset warm|cold   (-y skips confirmations)`);
+    return 0;
+  }
+  if (plantCommands.has(command)) {
+    const failed = await runPlantCommand(command, positionals.slice(1), values, {
+      file,
+      load: () => loadTsplcConfig3(file)
+    });
+    return failed ? report(failed, values.format) : 0;
+  }
+  if (positionals.length > 1)
+    throw new Error("Specify one command.");
+  if (![
+    "install",
+    "typegen",
+    "check",
+    "build",
+    "run",
+    "download",
+    "online-change",
+    "inspect",
+    "clean",
+    "configure"
+  ].includes(command))
+    throw new Error(`Unknown command ${command}.`);
+  if (values.format && !["json", "text"].includes(values.format))
+    throw new Error("--format must be json or text.");
+  if (values["emit-only"] && command !== "build")
+    throw new Error("--emit-only is supported by build only.");
+  if (values.runtime && command !== "configure")
+    throw new Error("--runtime applies only to configure.");
+  if ((values.plc || values.server) && command !== "build")
+    throw new Error("--plc and --server apply only to build.");
+  if (values.simulate && !["run", "download", "online-change"].includes(command))
+    throw new Error("--simulate applies only to run, download and online-change.");
+  if (values.plc && values.server)
+    throw new Error("Choose --plc or --server, or omit both for a full build.");
+  if (values.server && values["emit-only"])
+    throw new Error("--emit-only applies to PLC emission only.");
+  const log = console.log, previousLogTarget = process.env["TSPLC_LOG_STDERR"];
+  if (values.format === "json") {
+    console.log = console.error;
+    process.env["TSPLC_LOG_STDERR"] = "1";
+  }
+  let result;
+  try {
+    if (command === "configure") {
+      await (values.runtime ? configureRuntime() : configureDocker());
+      result = { ok: true };
+    } else if (command === "clean") {
+      result = await cleanProject(file);
+    } else {
+      if (["check", "build", "run", "download", "online-change"].includes(command)) {
+        const diagnostics = checkHostConfig3(resolve6(file));
+        if (hasErrors4(diagnostics))
+          throw new DiagnosticFailure({ diagnostics });
+      }
+      const loaded = await loadTsplcConfig3(file);
+      const { config, configFile, root } = loaded;
+      const target = values.simulate ? { ...loaded, config: simulationConfig(config) } : loaded;
+      if (command === "install")
+        result = {
+          libraries: await installLibraries3(config.dependencies, root, {
+            frozen: values["frozen-lockfile"]
+          })
+        };
+      else if (command === "typegen") {
+        const targets = await projectTargets2(file, { loaded });
+        if (config.compiler && !values.check) {
+          await generateProject2(file, { hardwareOnly: true, loaded, targets });
+          const emitted = await buildProject2(file, { emitOnly: true, loaded });
+          if (hasErrors4(emitted.diagnostics))
+            throw new DiagnosticFailure(emitted);
+        }
+        result = await generateProject2(file, { check: values.check, loaded, targets });
+      } else if (command === "check") {
+        result = config.compiler ? await checkProject2(file, { loaded }) : {
+          objects: (await loadSources(resolveConfig({
+            ...rawBuildConfig(config),
+            io: resolveIo3(config, await loadHardware3(config, root))
+          }, configFile))).objects.length
+        };
+      } else if (command === "build" && values.server) {
+        result = await buildServer(config, root);
+      } else if (command === "build" || command === "run") {
+        if (config.compiler) {
+          const built = await buildProject2(file, {
+            emitOnly: values["emit-only"],
+            frozenLockfile: values["frozen-lockfile"],
+            loaded: target,
+            controller: controllerFor2(config, command),
+            buildTarget: buildTargetFor(command)
+          });
+          if (hasErrors4(built.diagnostics))
+            throw new DiagnosticFailure(built);
+          await generateProject2(file, {
+            loaded,
+            targets: await projectTargets2(file, { loaded })
+          });
+          result = built;
+        } else {
+          if (values["emit-only"])
+            throw new Error("Raw Structured Text is already emitted.");
+          if (!config.build)
+            throw new Error("Configure build settings.");
+          const build = rawBuildConfig(config);
+          const libraries = await installLibraries3(config.dependencies, root, {
+            frozen: values["frozen-lockfile"]
+          });
+          const hardware = await loadHardware3(target.config, root);
+          result = await buildSt(resolveConfig({
+            ...build,
+            libraries,
+            io: resolveIo3(target.config, hardware),
+            deviceTree: await deviceTree3(target.config, hardware),
+            controller: controllerFor2(config, command)
+          }, configFile));
+          await generateProject2(file, { hardwareOnly: !config.typegen, loaded });
+        }
+        if (command === "build" && !values.plc && !values["emit-only"] && config.server?.runtime) {
+          const backend = await buildServer(config, root);
+          result = { ...typeof result === "object" && result !== null ? result : {}, ...backend };
+        }
+        if (command === "run") {
+          if (!config.build)
+            throw new Error("Configure build to run this project.");
+          await runProject(resolveConfig(config.compiler ? config.build : rawBuildConfig(config), configFile), config.name);
+        }
+      } else if (command === "inspect") {
+        if (!config.build)
+          throw new Error("Configure build settings and controller connection.");
+        result = await inspectController(resolveConfig({ ...config.build, controller: controllerFor2(config, command) }, configFile), values.read);
+      } else if (["download", "online-change"].includes(command)) {
+        if (!config.build)
+          throw new Error("Configure build settings and controller connection.");
+        let settings;
+        if (config.compiler) {
+          const emitted = await buildProject2(file, {
+            emitOnly: true,
+            forController: true,
+            frozenLockfile: values["frozen-lockfile"],
+            loaded: target,
+            buildTarget: buildTargetFor(command)
+          });
+          if (hasErrors4(emitted.diagnostics))
+            throw new DiagnosticFailure(emitted);
+          if (!emitted.controllerConfig)
+            throw new Error("Configure build settings for deployment.");
+          settings = { ...emitted.controllerConfig, io: {} };
+        } else
+          settings = {
+            ...resolveConfig({
+              ...rawBuildConfig(config),
+              io: resolveIo3(target.config, await loadHardware3(target.config, root))
+            }, configFile),
+            libraries: await installLibraries3(config.dependencies, root, {
+              frozen: values["frozen-lockfile"]
+            })
+          };
+        result = await updateController({ ...settings, controller: controllerFor2(config, command) }, command, {
+          initializeUser: values["initialize-user"],
+          read: values.read
+        });
+      } else
+        throw new Error(`Unknown command ${command}.`);
+    }
+  } finally {
+    console.log = log;
+    if (previousLogTarget === undefined)
+      delete process.env["TSPLC_LOG_STDERR"];
+    else
+      process.env["TSPLC_LOG_STDERR"] = previousLogTarget;
+  }
+  return report(result, values.format);
+}
+
+class DiagnosticFailure extends Error {
+  result;
+  constructor(result) {
+    super("PLC validation failed.");
+    this.result = result;
+  }
+}
+function report(result, format) {
+  const diagnostics = result && typeof result === "object" && "diagnostics" in result ? result.diagnostics : [];
+  const ok = !hasErrors4(diagnostics);
+  if (format === "json")
+    console.log(JSON.stringify({ ok, ...result && typeof result === "object" ? result : { result } }));
+  else {
+    for (const diagnostic of diagnostics)
+      console.error(formatDiagnostic(diagnostic));
+    if (ok)
+      console.log("tsPLC completed.");
+  }
+  return ok ? 0 : 1;
+}
+try {
+  process.exitCode = await main();
+} catch (cause) {
+  const json = process.argv.includes("json") || process.argv.includes("--format=json");
+  if (cause instanceof DiagnosticFailure) {
+    process.exitCode = report(cause.result, json ? "json" : undefined);
+  } else {
+    const message = cause instanceof Error ? cause.message : String(cause);
+    if (json)
+      console.log(JSON.stringify({
+        ok: false,
+        diagnostics: [{ origin: "config", code: "PLC5003", severity: "error", message }]
+      }));
+    else
+      console.error(message);
+    process.exitCode = 1;
+  }
+}
+
+//# debugId=2A9AAF31224302AE64756E2164756E21
+//# sourceMappingURL=cli.js.map