@tsplc/compiler 0.2.9 → 0.2.11

package/ir/declarations.ts

@@ -111,11 +111,18 @@ export class ModuleDeclarations {
           block.locals.length ||
           !matches(block.inputs, expected.inputs) ||
           !matches(block.outputs, expected.outputs) ||
-          block.outputs.some((output) =>
-            output.type === "BOOL"
-              ? output.initial?.kind !== "bool" || output.initial.value !== false
-              : output.initial?.kind !== "duration" || output.initial.nanoseconds !== "0",
-          )
+          block.outputs.some(({ initial }) => {
+            switch (initial?.kind) {
+              case "bool":
+                return initial.value !== false;
+              case "duration":
+                return initial.nanoseconds !== "0";
+              case "integer":
+                return initial.value !== "0";
+              default:
+                return true;
+            }
+          })
         )
           reject("Invalid canonical standard block definition.", block.span);
       }

package/ir/model.ts

@@ -158,7 +158,7 @@ export interface PlcFunction {
 export type MathHelper = "min" | "max" | "clamp";
 
 // Native vendor blocks under their TypeScript names. Ports are [name, native name, type];
-// every output starts FALSE or T#0s, matching the vendor library blocks.
+// every output starts at its type's default, matching the vendor library blocks.
 const timer = (input: string, output: string) =>
   ({
     inputs: [
@@ -184,6 +184,45 @@ export const standardBlocks = {
     inputs: [["signal", "CLK", "BOOL"]],
     outputs: [["fell", "Q", "BOOL"]],
   },
+  UpCounter: {
+    native: "CTU",
+    inputs: [
+      ["countUp", "CU", "BOOL"],
+      ["reset", "RESET", "BOOL"],
+      ["preset", "PV", "WORD"],
+    ],
+    outputs: [
+      ["reachedPreset", "Q", "BOOL"],
+      ["value", "CV", "WORD"],
+    ],
+  },
+  DownCounter: {
+    native: "CTD",
+    inputs: [
+      ["countDown", "CD", "BOOL"],
+      ["load", "LOAD", "BOOL"],
+      ["preset", "PV", "WORD"],
+    ],
+    outputs: [
+      ["atZero", "Q", "BOOL"],
+      ["value", "CV", "WORD"],
+    ],
+  },
+  UpDownCounter: {
+    native: "CTUD",
+    inputs: [
+      ["countUp", "CU", "BOOL"],
+      ["countDown", "CD", "BOOL"],
+      ["reset", "RESET", "BOOL"],
+      ["load", "LOAD", "BOOL"],
+      ["preset", "PV", "WORD"],
+    ],
+    outputs: [
+      ["reachedPreset", "QU", "BOOL"],
+      ["atZero", "QD", "BOOL"],
+      ["value", "CV", "WORD"],
+    ],
+  },
   Blinker: {
     native: "Util.BLINK",
     inputs: [

package/package.json

@@ -17,7 +17,7 @@
     "url": "git+https://github.com/livingforjesus/tsplc.git",
     "directory": "packages/compiler"
   },
-  "version": "0.2.9",
+  "version": "0.2.11",
   "type": "module",
   "exports": {
     ".": {
@@ -90,14 +90,14 @@
     "bun": ">=1.4.3"
   },
   "dependencies": {
-    "@tsplc/agent": "0.2.9",
-    "@tsplc/build": "0.2.9",
-    "@tsplc/config": "0.2.9",
-    "@tsplc/typegen": "0.2.9",
+    "@tsplc/agent": "0.2.11",
+    "@tsplc/build": "0.2.11",
+    "@tsplc/config": "0.2.11",
+    "@tsplc/typegen": "0.2.11",
     "typescript": "6.0.3",
     "zod": "4.3.6",
     "@types/bun": "1.4.2",
-    "@tsplc/server": "0.2.9"
+    "@tsplc/server": "0.2.11"
   },
   "bin": {
     "tsplc": "./dist/cli.js"

package/project/plant.ts

@@ -14,7 +14,7 @@ import { hasErrors } from "@tsplc/compiler/ir";
 import { generateProject } from "@tsplc/typegen";
 import { z } from "zod";
 import { buildProject, projectTargets } from "./project.ts";
-import { buildServer } from "./server.ts";
+import { bundleServer } from "./server.ts";
 
 export const plantCommands = new Set([
   "deploy",
@@ -107,6 +107,15 @@ const askCredentials = async (): Promise<Credentials> => ({
 
 const progress = (message: string) => console.log(`  ${message}`);
 
+/** Prints progress with the minutes and seconds since it was made, so the slow steps show. */
+const timedProgress = () => {
+  const start = Date.now();
+  return (message: string) => {
+    const seconds = Math.round((Date.now() - start) / 1000);
+    progress(`${Math.floor(seconds / 60)}:${String(seconds % 60).padStart(2, "0")} ${message}`);
+  };
+};
+
 const connect = () => {
   const environment = z
     .object({
@@ -168,7 +177,7 @@ const contractVariables = async (config: LoadedConfig["config"], root: string) =
   });
 };
 
-/** Compiles the production program and its server into the files `tsplc deploy` uploads. */
+/** Compiles the production program and bundles its server into the files `tsplc deploy` uploads. */
 const prepareRelease = async (file: string, loaded: LoadedConfig, flags: PlantFlags) => {
   const { config, root } = loaded;
   if (!config.compiler) throw new Error("tsplc deploy deploys tsPLC programs; configure compiler.");
@@ -194,17 +203,17 @@ const prepareRelease = async (file: string, loaded: LoadedConfig, flags: PlantFl
     { path: "template.project", content: Bun.file(settings.template) },
     ...libraries.map((library) => ({ path: library.release, content: Bun.file(library.path) })),
   ];
-  // Plain TypeScript programs emit their generated modules under `.tsplc/`.
-  for await (const source of new Bun.Glob("**/*").scan({ cwd: settings.sourceDir, dot: true }))
+  // The agent compiles only the ST. Plain TypeScript programs emit their generated modules under `.tsplc/`.
+  for await (const source of new Bun.Glob("**/*.st").scan({ cwd: settings.sourceDir, dot: true }))
     files.push({
       path: `st/${portable(source)}`,
       content: Bun.file(resolve(settings.sourceDir, source)),
     });
   let server: string | undefined;
   if (config.server?.runtime) {
-    const { executable } = (await buildServer(config, root)).server;
-    server = `server/${basename(executable)}`;
-    files.push({ path: server, content: Bun.file(executable) });
+    const script = await bundleServer(config, root);
+    server = `server/${basename(script)}`;
+    files.push({ path: server, content: Bun.file(script) });
   }
   const manifest: ReleaseManifest = {
     // Paths are relative to the release; the agent supplies the output and controller settings.
@@ -239,8 +248,10 @@ const deploy = async (
   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 building = timedProgress();
   const { release, diagnostics } = await prepareRelease(file, loaded, flags);
   if (!release) return { diagnostics };
+  building("Built");
   if (
     flags.download &&
     !(await confirm(
@@ -258,8 +269,10 @@ const deploy = async (
   console.log(
     release.manifest.server ? "Deploying the server and the program…" : "Deploying the program…",
   );
+  const deploying = timedProgress();
+  deploying("Uploading");
   try {
-    return await agent.deploy(release, settings, progress);
+    return await agent.deploy(release, settings, deploying);
   } catch (error) {
     if (
       !(error instanceof AgentOperationError && error.downloadRequired) ||
@@ -269,7 +282,7 @@ const deploy = async (
       ))
     )
       throw error;
-    return agent.deploy(release, { ...settings, download: true }, progress);
+    return agent.deploy(release, { ...settings, download: true }, timedProgress());
   }
 };
 

package/project/server.ts

@@ -18,20 +18,11 @@ const kebabCase = (name: string) =>
     .replace(/^-|-$/g, "")
     .toLowerCase();
 
-/** Compiles the host entry, which starts its own listener, into `build/server/<name>-services`. */
-export const buildServer = async (config: ResolvedTsplcConfig, root: string) => {
-  const settings = config.server;
-  if (!settings?.runtime) throw new Error("Configure server.runtime to build an executable.");
-  const runtime = settings.runtime;
+/** The host entry, type-checked as it will be built. */
+const checkedServerEntry = (config: ResolvedTsplcConfig, root: string) => {
+  const runtime = config.server?.runtime;
+  if (!runtime) throw new Error("Configure server.runtime to build the server.");
   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);
@@ -51,6 +42,45 @@ export const buildServer = async (config: ResolvedTsplcConfig, root: string) =>
         getNewLine: () => "\n",
       }),
     );
+  return { entry, runtime };
+};
+
+/**
+ * Bundles the host entry, which starts its own listener, into one minified script,
+ * `build/server/<name>-services.js`, which the plant agent runs on its own Bun. It is a few MB
+ * where an executable, which embeds Bun, is over 100, and deployments upload it.
+ */
+export const bundleServer = async (config: ResolvedTsplcConfig, root: string) => {
+  const { entry } = checkedServerEntry(config, root);
+  const outFile = resolve(root, "build/server", `${kebabCase(config.name)}-services.js`);
+  const result = await Bun.build({
+    entrypoints: [entry],
+    target: "bun",
+    minify: true,
+    env: "disable",
+  });
+  if (!result.success) throw new AggregateError(result.logs, "Server bundle build failed.");
+  const [script, ...assets] = result.outputs;
+  if (!script || assets.length)
+    throw new Error(
+      `The server bundle needs files beside its script (${assets.map(({ path }) => path).join(", ")}), which deployments don't carry.`,
+    );
+  await mkdir(dirname(outFile), { recursive: true });
+  await Bun.write(outFile, script);
+  return outFile;
+};
+
+/** Compiles the host entry, which starts its own listener, into `build/server/<name>-services`. */
+export const buildServer = async (config: ResolvedTsplcConfig, root: string) => {
+  const { entry, runtime } = checkedServerEntry(config, root);
+  const windows = runtime.target
+    ? runtime.target.includes("windows")
+    : process.platform === "win32";
+  const outFile = resolve(
+    root,
+    "build/server",
+    `${kebabCase(config.name)}-services${windows ? ".exe" : ""}`,
+  );
   await mkdir(dirname(outFile), { recursive: true });
   // Compile beside the output so dependency resolution starts from the owning project.
   const staging = await mkdtemp(join(dirname(outFile), ".tsplc-server-"));

package/src/frontend/async.ts

@@ -932,17 +932,22 @@ protected execute(input:{}):void {}
         const milliseconds =
           Number(interval.arguments[0]!.text) *
           (official(interval.expression, "seconds") ? 1000 : 1);
+        const taskPriority = Number(priority.text);
         if (
           !Number.isSafeInteger(milliseconds) ||
           milliseconds <= 0 ||
           milliseconds > 4294967295 ||
-          Number(priority.text) < 1 ||
-          Number(priority.text) > 31
+          !Number.isInteger(taskPriority) ||
+          taskPriority < 1 ||
+          taskPriority > 31
         )
-          fail(init, "Background interval must be positive and priority must be 1..31.");
+          fail(
+            init,
+            "Background interval must be positive and priority must be an integer in 1..31.",
+          );
         const schedule = {
           intervalNanoseconds: String(BigInt(milliseconds) * 1000000n),
-          priority: Number(priority.text),
+          priority: taskPriority,
           mailbox: dec.name.text,
           worker,
         };

package/src/frontend/typescript.ts

@@ -1,7 +1,7 @@
 import { runtimeSources } from "./module-graph.ts";
 import ts from "typescript";
 import { createRequire } from "node:module";
-import { mkdirSync, writeFileSync } from "node:fs";
+import { mkdirSync, realpathSync, writeFileSync } from "node:fs";
 import { dirname, join, relative, resolve } from "node:path";
 import {
   instancedBlock,
@@ -202,6 +202,24 @@ export const typeCheckOnly: ts.CompilerOptions = {
   tsBuildInfoFile: undefined,
 };
 
+const sdkFor = (project: string, options: ts.CompilerOptions): string => {
+  const name = "@tsplc/compiler/globals";
+  const resolveSdk = (from: string) => createRequire(from).resolve(name).replaceAll("\\", "/");
+  try {
+    const installed = resolveSdk(project);
+    const resolved = ts.resolveModuleName(name, project, options, ts.sys).resolvedModule;
+    // TypeScript may preserve a workspace symlink. A path alias may only stand in
+    // for the SDK if it resolves to the same installed declaration.
+    if (resolved && realpathSync(resolved.resolvedFileName) === realpathSync(installed))
+      return resolved.resolvedFileName;
+    return installed;
+  } catch (cause) {
+    if (!(cause instanceof Error) || !("code" in cause) || cause.code !== "MODULE_NOT_FOUND")
+      throw cause;
+    return resolveSdk(import.meta.url);
+  }
+};
+
 export function analyze(options: FrontendOptions): FrontendResult {
   const filename = resolve(options.tsconfig);
   const config = ts.readConfigFile(filename, ts.sys.readFile);
@@ -214,11 +232,6 @@ export function analyze(options: FrontendOptions): FrontendResult {
     filename,
   );
   if (parsed.errors.length) return { diagnostics: parsed.errors.map(tsDiagnostic) };
-  // TypeScript stores SourceFile paths with forward slashes on every host.
-  // Normalize require.resolve once so canonical SDK identity also works on Windows.
-  const sdk = createRequire(import.meta.url)
-    .resolve("@tsplc/compiler/globals")
-    .replaceAll("\\", "/");
   const programFiles = Object.values(options.programs).map((entry) =>
     resolve(dirname(filename), entry.module),
   );
@@ -229,7 +242,6 @@ export function analyze(options: FrontendOptions): FrontendResult {
     (file) => /\.d\.[cm]?ts$/.test(file) && file.startsWith(`${dirname(filename)}/`),
   );
   const projectFiles = scope === "project" ? parsed.fileNames : ambient;
-  const rootNames = [...new Set([...projectFiles, ...programFiles, sdk])];
   const compilerOptions: ts.CompilerOptions = {
     ...parsed.options,
     ...typeCheckOnly,
@@ -251,6 +263,8 @@ export function analyze(options: FrontendOptions): FrontendResult {
   // Nothing is emitted, and a service client's router type imports modules outside these (TS6059).
   delete compilerOptions.rootDir;
   delete compilerOptions.outDir;
+  const sdk = sdkFor(filename, compilerOptions);
+  const rootNames = [...new Set([...projectFiles, ...programFiles, sdk])];
   let program = ts.createProgram(rootNames, compilerOptions);
   const plcFiles = (program: ts.Program) => {
     const files = new Set(runtimeSources(program));

package/types/globals.d.ts

@@ -24,6 +24,12 @@ declare global {
   const RisingEdge: typeof import("./index").RisingEdge;
   type FallingEdge = import("./index").FallingEdge;
   const FallingEdge: typeof import("./index").FallingEdge;
+  type UpCounter = import("./index").UpCounter;
+  const UpCounter: typeof import("./index").UpCounter;
+  type DownCounter = import("./index").DownCounter;
+  const DownCounter: typeof import("./index").DownCounter;
+  type UpDownCounter = import("./index").UpDownCounter;
+  const UpDownCounter: typeof import("./index").UpDownCounter;
   const ref: typeof import("./index").ref;
   const retain: typeof import("./index").retain;
   const ms: typeof import("./index").ms;

package/types/index.d.ts

@@ -68,7 +68,7 @@ export declare abstract class FunctionBlock<I, O = Record<never, never>> {
   protected abstract execute(input: I): keyof O extends never ? void : O;
 }
 
-/** Alternates `on` while enabled: off for `offTime`, then on for `onTime`. Keeps its last `on` when disabled. CODESYS Util.BLINK. */
+/** Starts on, then alternates `onTime` and `offTime`. Keeps its last `on` when disabled. CODESYS Util.BLINK. */
 export declare class Blinker extends FunctionBlock<
   { enabled: BOOL; offTime: TIME; onTime: TIME },
   { on: BOOL }
@@ -109,3 +109,39 @@ export declare class RisingEdge extends FunctionBlock<{ signal: BOOL }, { rose:
 export declare class FallingEdge extends FunctionBlock<{ signal: BOOL }, { fell: BOOL }> {
   protected execute(input: { signal: BOOL }): { fell: BOOL };
 }
+
+/** Counts rising `countUp` edges. `reset` clears `value`. `reachedPreset` indicates `value >= preset`. CODESYS CTU. */
+export declare class UpCounter extends FunctionBlock<
+  { countUp: BOOL; reset: BOOL; preset: WORD },
+  { reachedPreset: BOOL; value: WORD }
+> {
+  protected execute(input: { countUp: BOOL; reset: BOOL; preset: WORD }): {
+    reachedPreset: BOOL;
+    value: WORD;
+  };
+}
+
+/** Counts down on rising `countDown` edges. `load` sets `value` to `preset`. `atZero` indicates `value = 0`. CODESYS CTD. */
+export declare class DownCounter extends FunctionBlock<
+  { countDown: BOOL; load: BOOL; preset: WORD },
+  { atZero: BOOL; value: WORD }
+> {
+  protected execute(input: { countDown: BOOL; load: BOOL; preset: WORD }): {
+    atZero: BOOL;
+    value: WORD;
+  };
+}
+
+/** Counts rising edges in either direction. `reset` clears `value`, and `load` sets `value` to `preset`. CODESYS CTUD. */
+export declare class UpDownCounter extends FunctionBlock<
+  { countUp: BOOL; countDown: BOOL; reset: BOOL; load: BOOL; preset: WORD },
+  { reachedPreset: BOOL; atZero: BOOL; value: WORD }
+> {
+  protected execute(input: {
+    countUp: BOOL;
+    countDown: BOOL;
+    reset: BOOL;
+    load: BOOL;
+    preset: WORD;
+  }): { reachedPreset: BOOL; atZero: BOOL; value: WORD };
+}