@tsplc/compiler 0.1.0 → 0.2.1

package/dist/cli.js

@@ -71,11 +71,11 @@ var buildServer = async (config, root) => {
 
 // packages/compiler/project/cli.ts
 import { parseArgs } from "util";
-import { resolve as resolve3 } from "path";
+import { resolve as resolve6 } from "path";
 import {
   buildTargetFor,
-  controllerFor,
-  loadTsplcConfig as loadTsplcConfig2,
+  controllerFor as controllerFor2,
+  loadTsplcConfig as loadTsplcConfig3,
   rawBuildConfig,
   simulationConfig
 } from "@tsplc/config";
@@ -84,17 +84,30 @@ import {
   configureDocker,
   configureRuntime,
   inspectController,
-  installLibraries as installLibraries2,
+  installLibraries as installLibraries3,
   loadSources,
   resolveConfig,
   runProject,
   updateController
 } from "@tsplc/build";
-import { checkHostConfig as checkHostConfig2 } from "@tsplc/compiler";
-import { formatDiagnostic, hasErrors as hasErrors2 } from "@tsplc/compiler/ir";
-import { deviceTree as deviceTree2 } from "@tsplc/typegen";
-import { loadHardware as loadHardware2, resolveIo as resolveIo2 } from "@tsplc/typegen/hardware";
+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";
@@ -402,6 +415,17 @@ async function checkProject(file = "tsplc.config.ts", options = {}) {
     ]
   };
 }
+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 {
@@ -421,11 +445,14 @@ async function buildProject(file = "tsplc.config.ts", options = {}) {
     if (hasErrors(bundle.diagnostics)) {
       return { diagnostics: bundle.diagnostics };
     }
-    const controllerConfig = checked.shared?.build ? codesysBuildConfig(checked.plan, bundle, {
+    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), checked.shared.build.outDir),
-      controller: options.controller
+      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-"));
@@ -447,23 +474,15 @@ async function buildProject(file = "tsplc.config.ts", options = {}) {
     }
     let vendor;
     if (!options.emitOnly) {
-      const engineering = checked.shared?.build ? resolve2(dirname3(configFile), checked.shared.build.outDir ?? "build") : join3(previous.root, "engineering");
-      const libraries = checked.shared ? await installLibraries(checked.shared.dependencies, dirname3(configFile), {
-        frozen: options.frozenLockfile
-      }) : undefined;
-      await engineeringDirectory(engineering, configFile);
-      const tree = checked.shared && await deviceTree(checked.shared, await loadHardware(checked.shared, dirname3(configFile)));
+      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: engineering,
-          libraries,
+          outDir,
           controller: options.controller,
-          deviceTree: tree && {
-            ...tree,
-            mappings: bundle.ioMappings.map(({ address, variable }) => ({ address, variable }))
-          }
+          ...engineering
         });
       } catch (cause) {
         return { diagnostics: diagnoseCodesys(cause, bundle) };
@@ -502,12 +521,627 @@ async function buildProject(file = "tsplc.config.ts", options = {}) {
     }
   }
 }
+
+// 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 realpath(resolve2(file)));
+    await cleanArtifacts(await realpath2(resolve5(file)));
     return { diagnostics: [] };
   } catch (cause) {
-    return { diagnostics: [failure("config", "PLC5004", cause)] };
+    return { diagnostics: [failure2("config", "PLC5004", cause)] };
   }
 }
 
@@ -527,14 +1161,32 @@ async function main() {
       plc: { type: "boolean" },
       server: { type: "boolean" },
       simulate: { type: "boolean" },
-      runtime: { 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]");
+    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 (![
@@ -578,51 +1230,51 @@ async function main() {
       result = await cleanProject(file);
     } else {
       if (["check", "build", "run", "download", "online-change"].includes(command)) {
-        const diagnostics = checkHostConfig2(resolve3(file));
-        if (hasErrors2(diagnostics))
+        const diagnostics = checkHostConfig3(resolve6(file));
+        if (hasErrors4(diagnostics))
           throw new DiagnosticFailure({ diagnostics });
       }
-      const loaded = await loadTsplcConfig2(file);
+      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 installLibraries2(config.dependencies, root, {
+          libraries: await installLibraries3(config.dependencies, root, {
             frozen: values["frozen-lockfile"]
           })
         };
       else if (command === "typegen") {
-        const targets = await projectTargets(file, { loaded });
+        const targets = await projectTargets2(file, { loaded });
         if (config.compiler && !values.check) {
-          await generateProject(file, { hardwareOnly: true, loaded, targets });
-          const emitted = await buildProject(file, { emitOnly: true, loaded });
-          if (hasErrors2(emitted.diagnostics))
+          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 generateProject(file, { check: values.check, loaded, targets });
+        result = await generateProject2(file, { check: values.check, loaded, targets });
       } else if (command === "check") {
-        result = config.compiler ? await checkProject(file, { loaded }) : {
+        result = config.compiler ? await checkProject2(file, { loaded }) : {
           objects: (await loadSources(resolveConfig({
             ...rawBuildConfig(config),
-            io: resolveIo2(config, await loadHardware2(config, root))
+            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 buildProject(file, {
+          const built = await buildProject2(file, {
             emitOnly: values["emit-only"],
             frozenLockfile: values["frozen-lockfile"],
             loaded: target,
-            controller: controllerFor(config, command),
+            controller: controllerFor2(config, command),
             buildTarget: buildTargetFor(command)
           });
-          if (hasErrors2(built.diagnostics))
+          if (hasErrors4(built.diagnostics))
             throw new DiagnosticFailure(built);
-          await generateProject(file, {
+          await generateProject2(file, {
             loaded,
-            targets: await projectTargets(file, { loaded })
+            targets: await projectTargets2(file, { loaded })
           });
           result = built;
         } else {
@@ -631,18 +1283,18 @@ async function main() {
           if (!config.build)
             throw new Error("Configure build settings.");
           const build = rawBuildConfig(config);
-          const libraries = await installLibraries2(config.dependencies, root, {
+          const libraries = await installLibraries3(config.dependencies, root, {
             frozen: values["frozen-lockfile"]
           });
-          const hardware = await loadHardware2(target.config, root);
+          const hardware = await loadHardware3(target.config, root);
           result = await buildSt(resolveConfig({
             ...build,
             libraries,
-            io: resolveIo2(target.config, hardware),
-            deviceTree: await deviceTree2(target.config, hardware),
-            controller: controllerFor(config, command)
+            io: resolveIo3(target.config, hardware),
+            deviceTree: await deviceTree3(target.config, hardware),
+            controller: controllerFor2(config, command)
           }, configFile));
-          await generateProject(file, { hardwareOnly: !config.typegen, loaded });
+          await generateProject2(file, { hardwareOnly: !config.typegen, loaded });
         }
         if (command === "build" && !values.plc && !values["emit-only"] && config.server?.runtime) {
           const backend = await buildServer(config, root);
@@ -656,31 +1308,35 @@ async function main() {
       } else if (command === "inspect") {
         if (!config.build)
           throw new Error("Configure build settings and controller connection.");
-        result = await inspectController(resolveConfig({ ...config.build, controller: controllerFor(config, command) }, configFile), values.read);
+        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 buildProject(file, {
+          const emitted = await buildProject2(file, {
             emitOnly: true,
+            forController: true,
+            frozenLockfile: values["frozen-lockfile"],
             loaded: target,
             buildTarget: buildTargetFor(command)
           });
-          if (hasErrors2(emitted.diagnostics))
+          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: resolveIo2(target.config, await loadHardware2(target.config, root))
-          }, configFile);
-        const libraries = await installLibraries2(config.dependencies, root, {
-          frozen: values["frozen-lockfile"]
-        });
-        result = await updateController({ ...settings, libraries, controller: controllerFor(config, command) }, command, {
+          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
         });
@@ -706,7 +1362,7 @@ class DiagnosticFailure extends Error {
 }
 function report(result, format) {
   const diagnostics = result && typeof result === "object" && "diagnostics" in result ? result.diagnostics : [];
-  const ok = !hasErrors2(diagnostics);
+  const ok = !hasErrors4(diagnostics);
   if (format === "json")
     console.log(JSON.stringify({ ok, ...result && typeof result === "object" ? result : { result } }));
   else {
@@ -736,5 +1392,5 @@ try {
   }
 }
 
-//# debugId=0A41ED9B311EA7A064756E2164756E21
+//# debugId=2A9AAF31224302AE64756E2164756E21
 //# sourceMappingURL=cli.js.map