@tsplc/compiler 0.2.10 → 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.10",
+  "version": "0.2.11",
   "type": "module",
   "exports": {
     ".": {
@@ -90,14 +90,14 @@
     "bun": ">=1.4.3"
   },
   "dependencies": {
-    "@tsplc/agent": "0.2.10",
-    "@tsplc/build": "0.2.10",
-    "@tsplc/config": "0.2.10",
-    "@tsplc/typegen": "0.2.10",
+    "@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.10"
+    "@tsplc/server": "0.2.11"
   },
   "bin": {
     "tsplc": "./dist/cli.js"

package/project/plant.ts

@@ -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({
@@ -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/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 };
+}