covenant-bridge 0.1.5 → 0.2.0

package/dist/backend.js

@@ -1,16 +1,4507 @@
-/**
- * Covenant Bridge Backend
- *
- * Main entry point for the LinuxCNC-Eden bridge.
- * Initializes and exposes all AppBus services.
- */
-import { initLinuxCNCService } from "./services/linuxcnc";
-import { initGCodeService } from "./services/gcode";
-import { initHalService } from "./services/hal";
-import { initPositionLoggerService } from "./services/position-logger";
-const appId = process.env.EDEN_APP_ID;
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../node_modules/.pnpm/@linuxcnc-node+core@2.1.3/node_modules/@linuxcnc-node/core/dist/constants.js
+var require_constants = __commonJS({
+  "../node_modules/.pnpm/@linuxcnc-node+core@2.1.3/node_modules/@linuxcnc-node/core/dist/constants.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.addon = void 0;
+    function loadAddon() {
+      const paths = [
+        "../build/Release/nml_addon.node",
+        "../../build/Release/nml_addon.node"
+        // Fallback for debug builds
+      ];
+      for (const path of paths) {
+        try {
+          return require(path);
+        } catch {
+        }
+      }
+      throw new Error("Failed to load linuxcnc-node nml native addon. Please ensure it's built correctly and that LinuxCNC is in your PATH.");
+    }
+    exports2.addon = loadAddon();
+  }
+});
+
+// ../node_modules/.pnpm/dlv@1.1.3/node_modules/dlv/dist/dlv.es.js
+var dlv_es_exports = {};
+__export(dlv_es_exports, {
+  default: () => dlv_es_default
+});
+function dlv_es_default(t, e, l, n, r) {
+  for (e = e.split ? e.split(".") : e, n = 0; n < e.length; n++) t = t ? t[e[n]] : r;
+  return t === r ? l : t;
+}
+var init_dlv_es = __esm({
+  "../node_modules/.pnpm/dlv@1.1.3/node_modules/dlv/dist/dlv.es.js"() {
+    "use strict";
+  }
+});
+
+// ../node_modules/.pnpm/dset@3.1.4/node_modules/dset/dist/index.js
+var require_dist = __commonJS({
+  "../node_modules/.pnpm/dset@3.1.4/node_modules/dset/dist/index.js"(exports2) {
+    "use strict";
+    function dset(obj, keys, val) {
+      keys.split && (keys = keys.split("."));
+      var i = 0, l = keys.length, t = obj, x, k;
+      while (i < l) {
+        k = "" + keys[i++];
+        if (k === "__proto__" || k === "constructor" || k === "prototype") break;
+        t = t[k] = i === l ? val : typeof (x = t[k]) === typeof keys ? x : keys[i] * 0 !== 0 || !!~("" + keys[i]).indexOf(".") ? {} : [];
+      }
+    }
+    exports2.dset = dset;
+  }
+});
+
+// ../node_modules/.pnpm/@linuxcnc-node+core@2.1.3/node_modules/@linuxcnc-node/core/dist/statChannel.js
+var require_statChannel = __commonJS({
+  "../node_modules/.pnpm/@linuxcnc-node+core@2.1.3/node_modules/@linuxcnc-node/core/dist/statChannel.js"(exports2) {
+    "use strict";
+    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.StatChannel = exports2.DEFAULT_STAT_POLL_INTERVAL = void 0;
+    var node_events_1 = require("events");
+    var constants_1 = require_constants();
+    var dlv_1 = __importDefault((init_dlv_es(), __toCommonJS(dlv_es_exports)));
+    var dset_1 = require_dist();
+    exports2.DEFAULT_STAT_POLL_INTERVAL = 50;
+    var StatChannel2 = class extends node_events_1.EventEmitter {
+      constructor(options) {
+        super();
+        this.poller = null;
+        this.isPolling = false;
+        this.cursor = 0;
+        this.currentStat = null;
+        this.watchedProperties = /* @__PURE__ */ new Map();
+        this.nativeInstance = new constants_1.addon.NativeStatChannel();
+        this.pollInterval = options?.pollInterval ?? exports2.DEFAULT_STAT_POLL_INTERVAL;
+        this.currentStat = {};
+        const initialResult = this.nativeInstance.poll(true);
+        for (const change of initialResult.changes) {
+          (0, dset_1.dset)(this.currentStat, change.path, change.value);
+        }
+        this.cursor = initialResult.cursor;
+        this.startPolling();
+      }
+      startPolling() {
+        if (this.poller || !this.nativeInstance)
+          return;
+        this.poller = setInterval(() => this.performPoll(), this.pollInterval);
+      }
+      stopPolling() {
+        if (this.poller) {
+          clearInterval(this.poller);
+          this.poller = null;
+        }
+      }
+      performPoll() {
+        if (this.isPolling)
+          return;
+        this.isPolling = true;
+        try {
+          const result = this.nativeInstance.poll();
+          this.cursor = result.cursor;
+          if (result.changes.length > 0 && this.currentStat) {
+            for (const change of result.changes) {
+              (0, dset_1.dset)(this.currentStat, change.path, change.value);
+            }
+            this.emit("delta", result.changes);
+            for (const change of result.changes) {
+              const path = change.path;
+              const watched = this.watchedProperties.get(path);
+              if (watched) {
+                const oldValue = watched.lastValue;
+                const newValue = change.value;
+                watched.lastValue = typeof newValue === "object" && newValue !== null ? JSON.parse(JSON.stringify(newValue)) : newValue;
+                const listeners = this.rawListeners(path);
+                for (const listener of listeners) {
+                  try {
+                    listener(newValue, oldValue, path);
+                  } catch (e) {
+                    console.error(`Error in StatChannel watch callback for ${path}:`, e);
+                  }
+                }
+              }
+            }
+          }
+        } catch (e) {
+          console.error("Error during StatChannel poll:", e);
+        } finally {
+          this.isPolling = false;
+        }
+      }
+      /**
+       * Ensures that a property path is being tracked for changes.
+       * This initializes the lastValue for comparing changes.
+       */
+      ensureWatched(propertyPath) {
+        if (!this.watchedProperties.has(propertyPath)) {
+          const initialValue = this.currentStat ? (0, dlv_1.default)(this.currentStat, propertyPath) : null;
+          this.watchedProperties.set(propertyPath, {
+            lastValue: typeof initialValue === "object" && initialValue !== null ? JSON.parse(JSON.stringify(initialValue)) : initialValue
+          });
+        }
+      }
+      on(event, listener) {
+        if (event === "delta") {
+          return super.on(event, listener);
+        }
+        this.ensureWatched(event);
+        return super.on(event, listener);
+      }
+      /**
+       * Registers a one-time listener for changes to a specific property path.
+       * The listener will be removed after it fires once.
+       * @param propertyPath A dot-separated path to the property.
+       * @param listener The function to call when the property's value changes.
+       * @returns this (for chaining)
+       */
+      once(propertyPath, listener) {
+        this.ensureWatched(propertyPath);
+        return super.once(propertyPath, listener);
+      }
+      off(event, listener) {
+        if (event === "delta") {
+          return super.off(event, listener);
+        }
+        const result = super.off(event, listener);
+        if (this.listenerCount(event) === 0) {
+          this.watchedProperties.delete(event);
+        }
+        return result;
+      }
+      /**
+       * Removes a listener for a specific property path.
+       * Alias for off().
+       * @param propertyPath The property path.
+       * @param listener The listener function to remove.
+       * @returns this (for chaining)
+       */
+      removeListener(propertyPath, listener) {
+        return this.off(propertyPath, listener);
+      }
+      /**
+       * Sets the polling interval for status updates.
+       * @param interval The new interval in milliseconds.
+       */
+      setPollInterval(interval) {
+        this.pollInterval = Math.max(10, interval);
+        this.stopPolling();
+        this.startPolling();
+      }
+      /**
+       * Gets the current polling interval.
+       * @returns The interval in milliseconds.
+       */
+      getPollInterval() {
+        return this.pollInterval;
+      }
+      /**
+       * Retrieves the most recent full status object.
+       * @returns The current LinuxCNCStat object, or null if not yet available.
+       */
+      get() {
+        return this.currentStat;
+      }
+      /**
+       * Forces a full resync of the stat object from native.
+       * Use this if cursor gaps are detected or for initial sync scenarios.
+       */
+      sync() {
+        this.currentStat = {};
+        const result = this.nativeInstance.poll(true);
+        for (const change of result.changes) {
+          (0, dset_1.dset)(this.currentStat, change.path, change.value);
+        }
+        this.cursor = result.cursor;
+        this.watchedProperties.forEach((watched, path) => {
+          watched.lastValue = this.currentStat ? (0, dlv_1.default)(this.currentStat, path) : null;
+        });
+      }
+      /**
+       * Gets the current cursor value for sync verification.
+       * The cursor increments each time the native layer detects changes.
+       * @returns The current cursor value.
+       */
+      getCursor() {
+        return this.cursor;
+      }
+      /**
+       * Cleans up resources, stopping the polling timer.
+       */
+      destroy() {
+        this.stopPolling();
+        this.watchedProperties.clear();
+        this.removeAllListeners();
+        if (this.nativeInstance) {
+          this.nativeInstance.disconnect();
+        }
+      }
+      // --- Convenience Getters for common properties ---
+      // These access the locally cached `this.currentStat`
+      get task() {
+        return this.currentStat?.task;
+      }
+      get motion() {
+        return this.currentStat?.motion;
+      }
+      get io() {
+        return this.currentStat?.io;
+      }
+      get toolTable() {
+        return this.currentStat?.toolTable;
+      }
+    };
+    exports2.StatChannel = StatChannel2;
+  }
+});
+
+// ../node_modules/.pnpm/@linuxcnc-node+types@2.1.1/node_modules/@linuxcnc-node/types/dist/constants.js
+var require_constants2 = __commonJS({
+  "../node_modules/.pnpm/@linuxcnc-node+types@2.1.1/node_modules/@linuxcnc-node/types/dist/constants.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.EmcDebug = exports2.OrientState = exports2.JointType = exports2.NmlMessageType = exports2.ProgramUnits = exports2.RcsStatus = exports2.KinematicsType = exports2.MotionType = exports2.TrajMode = exports2.InterpState = exports2.ExecState = exports2.TaskState = exports2.TaskMode = void 0;
+    var TaskMode;
+    (function(TaskMode2) {
+      TaskMode2[TaskMode2["MANUAL"] = 1] = "MANUAL";
+      TaskMode2[TaskMode2["AUTO"] = 2] = "AUTO";
+      TaskMode2[TaskMode2["MDI"] = 3] = "MDI";
+    })(TaskMode || (exports2.TaskMode = TaskMode = {}));
+    var TaskState;
+    (function(TaskState2) {
+      TaskState2[TaskState2["ESTOP"] = 1] = "ESTOP";
+      TaskState2[TaskState2["ESTOP_RESET"] = 2] = "ESTOP_RESET";
+      TaskState2[TaskState2["OFF"] = 3] = "OFF";
+      TaskState2[TaskState2["ON"] = 4] = "ON";
+    })(TaskState || (exports2.TaskState = TaskState = {}));
+    var ExecState;
+    (function(ExecState2) {
+      ExecState2[ExecState2["ERROR"] = 1] = "ERROR";
+      ExecState2[ExecState2["DONE"] = 2] = "DONE";
+      ExecState2[ExecState2["WAITING_FOR_MOTION"] = 3] = "WAITING_FOR_MOTION";
+      ExecState2[ExecState2["WAITING_FOR_MOTION_QUEUE"] = 4] = "WAITING_FOR_MOTION_QUEUE";
+      ExecState2[ExecState2["WAITING_FOR_IO"] = 5] = "WAITING_FOR_IO";
+      ExecState2[ExecState2["WAITING_FOR_MOTION_AND_IO"] = 7] = "WAITING_FOR_MOTION_AND_IO";
+      ExecState2[ExecState2["WAITING_FOR_DELAY"] = 8] = "WAITING_FOR_DELAY";
+      ExecState2[ExecState2["WAITING_FOR_SYSTEM_CMD"] = 9] = "WAITING_FOR_SYSTEM_CMD";
+      ExecState2[ExecState2["WAITING_FOR_SPINDLE_ORIENTED"] = 10] = "WAITING_FOR_SPINDLE_ORIENTED";
+    })(ExecState || (exports2.ExecState = ExecState = {}));
+    var InterpState;
+    (function(InterpState2) {
+      InterpState2[InterpState2["IDLE"] = 1] = "IDLE";
+      InterpState2[InterpState2["READING"] = 2] = "READING";
+      InterpState2[InterpState2["PAUSED"] = 3] = "PAUSED";
+      InterpState2[InterpState2["WAITING"] = 4] = "WAITING";
+    })(InterpState || (exports2.InterpState = InterpState = {}));
+    var TrajMode;
+    (function(TrajMode2) {
+      TrajMode2[TrajMode2["FREE"] = 1] = "FREE";
+      TrajMode2[TrajMode2["COORD"] = 2] = "COORD";
+      TrajMode2[TrajMode2["TELEOP"] = 3] = "TELEOP";
+    })(TrajMode || (exports2.TrajMode = TrajMode = {}));
+    var MotionType;
+    (function(MotionType2) {
+      MotionType2[MotionType2["NONE"] = 0] = "NONE";
+      MotionType2[MotionType2["TRAVERSE"] = 1] = "TRAVERSE";
+      MotionType2[MotionType2["FEED"] = 2] = "FEED";
+      MotionType2[MotionType2["ARC"] = 3] = "ARC";
+      MotionType2[MotionType2["TOOLCHANGE"] = 4] = "TOOLCHANGE";
+      MotionType2[MotionType2["PROBING"] = 5] = "PROBING";
+      MotionType2[MotionType2["INDEXROTARY"] = 6] = "INDEXROTARY";
+    })(MotionType || (exports2.MotionType = MotionType = {}));
+    var KinematicsType;
+    (function(KinematicsType2) {
+      KinematicsType2[KinematicsType2["IDENTITY"] = 1] = "IDENTITY";
+      KinematicsType2[KinematicsType2["FORWARD_ONLY"] = 2] = "FORWARD_ONLY";
+      KinematicsType2[KinematicsType2["INVERSE_ONLY"] = 3] = "INVERSE_ONLY";
+      KinematicsType2[KinematicsType2["BOTH"] = 4] = "BOTH";
+    })(KinematicsType || (exports2.KinematicsType = KinematicsType = {}));
+    var RcsStatus;
+    (function(RcsStatus2) {
+      RcsStatus2[RcsStatus2["UNINITIALIZED"] = -1] = "UNINITIALIZED";
+      RcsStatus2[RcsStatus2["DONE"] = 1] = "DONE";
+      RcsStatus2[RcsStatus2["EXEC"] = 2] = "EXEC";
+      RcsStatus2[RcsStatus2["ERROR"] = 3] = "ERROR";
+    })(RcsStatus || (exports2.RcsStatus = RcsStatus = {}));
+    var ProgramUnits;
+    (function(ProgramUnits2) {
+      ProgramUnits2[ProgramUnits2["INCH"] = 1] = "INCH";
+      ProgramUnits2[ProgramUnits2["MM"] = 2] = "MM";
+      ProgramUnits2[ProgramUnits2["CM"] = 3] = "CM";
+    })(ProgramUnits || (exports2.ProgramUnits = ProgramUnits = {}));
+    var NmlMessageType;
+    (function(NmlMessageType2) {
+      NmlMessageType2[NmlMessageType2["EMC_OPERATOR_ERROR"] = 11] = "EMC_OPERATOR_ERROR";
+      NmlMessageType2[NmlMessageType2["EMC_OPERATOR_TEXT"] = 12] = "EMC_OPERATOR_TEXT";
+      NmlMessageType2[NmlMessageType2["EMC_OPERATOR_DISPLAY"] = 13] = "EMC_OPERATOR_DISPLAY";
+      NmlMessageType2[NmlMessageType2["NML_ERROR"] = 1] = "NML_ERROR";
+      NmlMessageType2[NmlMessageType2["NML_TEXT"] = 2] = "NML_TEXT";
+      NmlMessageType2[NmlMessageType2["NML_DISPLAY"] = 3] = "NML_DISPLAY";
+    })(NmlMessageType || (exports2.NmlMessageType = NmlMessageType = {}));
+    var JointType;
+    (function(JointType2) {
+      JointType2[JointType2["LINEAR"] = 1] = "LINEAR";
+      JointType2[JointType2["ANGULAR"] = 2] = "ANGULAR";
+    })(JointType || (exports2.JointType = JointType = {}));
+    var OrientState;
+    (function(OrientState2) {
+      OrientState2[OrientState2["NONE"] = 0] = "NONE";
+      OrientState2[OrientState2["COMPLETE"] = 1] = "COMPLETE";
+      OrientState2[OrientState2["IN_PROGRESS"] = 2] = "IN_PROGRESS";
+      OrientState2[OrientState2["FAULTED"] = 3] = "FAULTED";
+    })(OrientState || (exports2.OrientState = OrientState = {}));
+    var EmcDebug;
+    (function(EmcDebug2) {
+      EmcDebug2[EmcDebug2["CONFIG"] = 2] = "CONFIG";
+      EmcDebug2[EmcDebug2["VERSIONS"] = 8] = "VERSIONS";
+      EmcDebug2[EmcDebug2["TASK_ISSUE"] = 16] = "TASK_ISSUE";
+      EmcDebug2[EmcDebug2["NML"] = 64] = "NML";
+      EmcDebug2[EmcDebug2["MOTION_TIME"] = 128] = "MOTION_TIME";
+      EmcDebug2[EmcDebug2["INTERP"] = 256] = "INTERP";
+      EmcDebug2[EmcDebug2["RCS"] = 512] = "RCS";
+      EmcDebug2[EmcDebug2["INTERP_LIST"] = 2048] = "INTERP_LIST";
+      EmcDebug2[EmcDebug2["IOCONTROL"] = 4096] = "IOCONTROL";
+      EmcDebug2[EmcDebug2["OWORD"] = 8192] = "OWORD";
+      EmcDebug2[EmcDebug2["REMAP"] = 16384] = "REMAP";
+      EmcDebug2[EmcDebug2["PYTHON"] = 32768] = "PYTHON";
+      EmcDebug2[EmcDebug2["NAMEDPARAM"] = 65536] = "NAMEDPARAM";
+      EmcDebug2[EmcDebug2["GDBONSIGNAL"] = 131072] = "GDBONSIGNAL";
+      EmcDebug2[EmcDebug2["STATE_TAGS"] = 524288] = "STATE_TAGS";
+    })(EmcDebug || (exports2.EmcDebug = EmcDebug = {}));
+  }
+});
+
+// ../node_modules/.pnpm/@linuxcnc-node+types@2.1.1/node_modules/@linuxcnc-node/types/dist/core.js
+var require_core = __commonJS({
+  "../node_modules/.pnpm/@linuxcnc-node+types@2.1.1/node_modules/@linuxcnc-node/types/dist/core.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.PositionIndex = exports2.PositionLoggerIndex = exports2.POSITION_STRIDE = void 0;
+    exports2.POSITION_STRIDE = 10;
+    var PositionLoggerIndex;
+    (function(PositionLoggerIndex2) {
+      PositionLoggerIndex2[PositionLoggerIndex2["X"] = 0] = "X";
+      PositionLoggerIndex2[PositionLoggerIndex2["Y"] = 1] = "Y";
+      PositionLoggerIndex2[PositionLoggerIndex2["Z"] = 2] = "Z";
+      PositionLoggerIndex2[PositionLoggerIndex2["A"] = 3] = "A";
+      PositionLoggerIndex2[PositionLoggerIndex2["B"] = 4] = "B";
+      PositionLoggerIndex2[PositionLoggerIndex2["C"] = 5] = "C";
+      PositionLoggerIndex2[PositionLoggerIndex2["U"] = 6] = "U";
+      PositionLoggerIndex2[PositionLoggerIndex2["V"] = 7] = "V";
+      PositionLoggerIndex2[PositionLoggerIndex2["W"] = 8] = "W";
+      PositionLoggerIndex2[PositionLoggerIndex2["MotionType"] = 9] = "MotionType";
+    })(PositionLoggerIndex || (exports2.PositionLoggerIndex = PositionLoggerIndex = {}));
+    var PositionIndex;
+    (function(PositionIndex2) {
+      PositionIndex2[PositionIndex2["X"] = 0] = "X";
+      PositionIndex2[PositionIndex2["Y"] = 1] = "Y";
+      PositionIndex2[PositionIndex2["Z"] = 2] = "Z";
+      PositionIndex2[PositionIndex2["A"] = 3] = "A";
+      PositionIndex2[PositionIndex2["B"] = 4] = "B";
+      PositionIndex2[PositionIndex2["C"] = 5] = "C";
+      PositionIndex2[PositionIndex2["U"] = 6] = "U";
+      PositionIndex2[PositionIndex2["V"] = 7] = "V";
+      PositionIndex2[PositionIndex2["W"] = 8] = "W";
+    })(PositionIndex || (exports2.PositionIndex = PositionIndex = {}));
+  }
+});
+
+// ../node_modules/.pnpm/@linuxcnc-node+types@2.1.1/node_modules/@linuxcnc-node/types/dist/hal.js
+var require_hal = __commonJS({
+  "../node_modules/.pnpm/@linuxcnc-node+types@2.1.1/node_modules/@linuxcnc-node/types/dist/hal.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+  }
+});
+
+// ../node_modules/.pnpm/@linuxcnc-node+types@2.1.1/node_modules/@linuxcnc-node/types/dist/gcode.js
+var require_gcode = __commonJS({
+  "../node_modules/.pnpm/@linuxcnc-node+types@2.1.1/node_modules/@linuxcnc-node/types/dist/gcode.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.Plane = exports2.OperationType = void 0;
+    var OperationType;
+    (function(OperationType2) {
+      OperationType2[OperationType2["TRAVERSE"] = 1] = "TRAVERSE";
+      OperationType2[OperationType2["FEED"] = 2] = "FEED";
+      OperationType2[OperationType2["ARC"] = 3] = "ARC";
+      OperationType2[OperationType2["PROBE"] = 4] = "PROBE";
+      OperationType2[OperationType2["RIGID_TAP"] = 5] = "RIGID_TAP";
+      OperationType2[OperationType2["DWELL"] = 6] = "DWELL";
+      OperationType2[OperationType2["NURBS_G5"] = 7] = "NURBS_G5";
+      OperationType2[OperationType2["NURBS_G6"] = 8] = "NURBS_G6";
+      OperationType2[OperationType2["UNITS_CHANGE"] = 10] = "UNITS_CHANGE";
+      OperationType2[OperationType2["PLANE_CHANGE"] = 11] = "PLANE_CHANGE";
+      OperationType2[OperationType2["G5X_OFFSET"] = 12] = "G5X_OFFSET";
+      OperationType2[OperationType2["G92_OFFSET"] = 13] = "G92_OFFSET";
+      OperationType2[OperationType2["XY_ROTATION"] = 14] = "XY_ROTATION";
+      OperationType2[OperationType2["TOOL_OFFSET"] = 15] = "TOOL_OFFSET";
+      OperationType2[OperationType2["TOOL_CHANGE"] = 16] = "TOOL_CHANGE";
+      OperationType2[OperationType2["FEED_RATE_CHANGE"] = 17] = "FEED_RATE_CHANGE";
+    })(OperationType || (exports2.OperationType = OperationType = {}));
+    var Plane;
+    (function(Plane2) {
+      Plane2[Plane2["XY"] = 1] = "XY";
+      Plane2[Plane2["YZ"] = 2] = "YZ";
+      Plane2[Plane2["XZ"] = 3] = "XZ";
+      Plane2[Plane2["UV"] = 4] = "UV";
+      Plane2[Plane2["VW"] = 5] = "VW";
+      Plane2[Plane2["UW"] = 6] = "UW";
+    })(Plane || (exports2.Plane = Plane = {}));
+  }
+});
+
+// ../node_modules/.pnpm/@linuxcnc-node+types@2.1.1/node_modules/@linuxcnc-node/types/dist/index.js
+var require_dist2 = __commonJS({
+  "../node_modules/.pnpm/@linuxcnc-node+types@2.1.1/node_modules/@linuxcnc-node/types/dist/index.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    __exportStar(require_constants2(), exports2);
+    __exportStar(require_core(), exports2);
+    __exportStar(require_hal(), exports2);
+    __exportStar(require_gcode(), exports2);
+  }
+});
+
+// ../node_modules/.pnpm/@linuxcnc-node+core@2.1.3/node_modules/@linuxcnc-node/core/dist/commandChannel.js
+var require_commandChannel = __commonJS({
+  "../node_modules/.pnpm/@linuxcnc-node+core@2.1.3/node_modules/@linuxcnc-node/core/dist/commandChannel.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.CommandChannel = void 0;
+    var constants_1 = require_constants();
+    var types_1 = require_dist2();
+    var CommandChannel2 = class {
+      constructor() {
+        this.nativeInstance = new constants_1.addon.NativeCommandChannel();
+      }
+      async exec(cmdFunc, ...args) {
+        try {
+          const status = await cmdFunc.apply(this.nativeInstance, args);
+          if (status !== types_1.RcsStatus.DONE && status !== types_1.RcsStatus.EXEC) {
+            throw new Error(`Command failed with RCS status: ${types_1.RcsStatus[status] || status}`);
+          }
+          return status;
+        } catch (e) {
+          throw new Error(`Command native execution failed: ${e.message || e}`);
+        }
+      }
+      // --- Task Commands ---
+      /**
+       * Sets the task execution mode for LinuxCNC
+       *
+       * @param mode - The task mode to set (MDI, MANUAL, or AUTO)
+       * @returns Promise resolving to RcsStatus indicating command completion
+       *
+       * @example
+       * ```typescript
+       * // Switch to MDI mode for manual data input
+       * await commandChannel.setTaskMode(TaskMode.MDI);
+       *
+       * // Switch to manual mode for jogging
+       * await commandChannel.setTaskMode(TaskMode.MANUAL);
+       *
+       * // Switch to auto mode for program execution
+       * await commandChannel.setTaskMode(TaskMode.AUTO);
+       * ```
+       */
+      async setTaskMode(mode) {
+        return this.exec(this.nativeInstance.setTaskMode, mode);
+      }
+      /**
+       * Sets the task state for LinuxCNC
+       *
+       * @param state - The task state to set (ESTOP, ESTOP_RESET, OFF, or ON)
+       * @returns Promise resolving to RcsStatus indicating command completion
+       *
+       * @example
+       * ```typescript
+       * // Enable E-stop
+       * await commandChannel.setState(TaskState.ESTOP);
+       *
+       * // Reset E-stop
+       * await commandChannel.setState(TaskState.ESTOP_RESET);
+       *
+       * // Turn machine on
+       * await commandChannel.setState(TaskState.ON);
+       * ```
+       */
+      async setState(state) {
+        return this.exec(this.nativeInstance.setState, state);
+      }
+      /**
+       * On completion of this call, the VAR file on disk is updated with live values from the interpreter.
+       *
+       * @returns Promise resolving to RcsStatus indicating command completion
+       */
+      async taskPlanSynch() {
+        return this.exec(this.nativeInstance.taskPlanSynch);
+      }
+      /**
+       * Resets the G-code interpreter
+       *
+       * @returns Promise resolving to RcsStatus indicating command completion
+       */
+      async resetInterpreter() {
+        return this.exec(this.nativeInstance.resetInterpreter);
+      }
+      /**
+       * Opens a G-code program file for execution
+       *
+       * @param filePath - Absolute path to the G-code file to open
+       * @returns Promise resolving to RcsStatus indicating command completion
+       *
+       * @example
+       * ```typescript
+       * // Open a G-code program
+       * await commandChannel.programOpen('/home/user/programs/part.ngc');
+       * ```
+       */
+      async programOpen(filePath) {
+        return this.exec(this.nativeInstance.programOpen, filePath);
+      }
+      /**
+       * Runs the currently loaded G-code program
+       *
+       * @param startLine - Line number to start execution from (default: 0 for beginning)
+       * @returns Promise resolving to RcsStatus indicating command completion
+       *
+       * @example
+       * ```typescript
+       * // Run program from the beginning
+       * await commandChannel.runProgram();
+       *
+       * // Run program starting from line 100
+       * await commandChannel.runProgram(100);
+       * ```
+       */
+      async runProgram(startLine = 0) {
+        return this.exec(this.nativeInstance.runProgram, startLine);
+      }
+      /**
+       * Pauses the currently running G-code program
+       * Program can be resumed with resumeProgram()
+       *
+       * @returns Promise resolving to RcsStatus indicating command completion
+       *
+       * @example
+       * ```typescript
+       * // Pause the running program
+       * await commandChannel.pauseProgram();
+       * ```
+       */
+      async pauseProgram() {
+        return this.exec(this.nativeInstance.pauseProgram);
+      }
+      /**
+       * Resumes a paused G-code program
+       *
+       * @returns Promise resolving to RcsStatus indicating command completion
+       *
+       * @example
+       * ```typescript
+       * // Resume the paused program
+       * await commandChannel.resumeProgram();
+       * ```
+       */
+      async resumeProgram() {
+        return this.exec(this.nativeInstance.resumeProgram);
+      }
+      /**
+       * Executes a single step of the G-code program
+       * Advances program execution by one line/block
+       *
+       * @returns Promise resolving to RcsStatus indicating command completion
+       *
+       * @example
+       * ```typescript
+       * // Step through program one line at a time
+       * await commandChannel.stepProgram();
+       * ```
+       */
+      async stepProgram() {
+        return this.exec(this.nativeInstance.stepProgram);
+      }
+      /**
+       * Reverses program execution direction
+       * Used for backing up through a program
+       *
+       * @returns Promise resolving to RcsStatus indicating command completion
+       */
+      async reverseProgram() {
+        return this.exec(this.nativeInstance.reverseProgram);
+      }
+      /**
+       * Sets program execution direction to forward
+       * Used after reversing to resume normal forward execution
+       *
+       * @returns Promise resolving to RcsStatus indicating command completion
+       */
+      async forwardProgram() {
+        return this.exec(this.nativeInstance.forwardProgram);
+      }
+      /**
+       * Aborts the currently running task/program
+       * Immediately stops all motion and task execution
+       *
+       * @returns Promise resolving to RcsStatus indicating command completion
+       *
+       * @example
+       * ```typescript
+       * // Emergency stop of current program
+       * await commandChannel.abortTask();
+       * ```
+       */
+      async abortTask() {
+        return this.exec(this.nativeInstance.abortTask);
+      }
+      /**
+       * Enables or disables optional stop (M1) functionality
+       * When enabled, M1 codes in programs will pause execution
+       *
+       * @param enable - true to enable optional stops, false to disable
+       * @returns Promise resolving to RcsStatus indicating command completion
+       *
+       * @example
+       * ```typescript
+       * // Enable optional stops
+       * await commandChannel.setOptionalStop(true);
+       *
+       * // Disable optional stops
+       * await commandChannel.setOptionalStop(false);
+       * ```
+       */
+      async setOptionalStop(enable) {
+        return this.exec(this.nativeInstance.setOptionalStop, enable);
+      }
+      /**
+       * Enables or disables block delete functionality
+       * When enabled, lines beginning with "/" are skipped during execution
+       *
+       * @param enable - true to enable block delete, false to disable
+       * @returns Promise resolving to RcsStatus indicating command completion
+       *
+       * @example
+       * ```typescript
+       * // Enable block delete - skip lines starting with "/"
+       * await commandChannel.setBlockDelete(true);
+       *
+       * // Disable block delete - execute all lines
+       * await commandChannel.setBlockDelete(false);
+       * ```
+       */
+      async setBlockDelete(enable) {
+        return this.exec(this.nativeInstance.setBlockDelete, enable);
+      }
+      /**
+       * Executes a Manual Data Input (MDI) command
+       * Allows direct execution of G-code commands without a program file
+       *
+       * @param command - G-code command string to execute
+       * @returns Promise resolving to RcsStatus indicating command completion
+       *
+       * @example
+       * ```typescript
+       * // Move to position
+       * await commandChannel.mdi('G0 X10 Y20 Z5');
+       *
+       * // Set spindle speed
+       * await commandChannel.mdi('S1000 M3');
+       * ```
+       */
+      async mdi(command) {
+        return this.exec(this.nativeInstance.mdi, command);
+      }
+      // --- Trajectory Commands ---
+      /**
+       * Sets the trajectory mode for coordinated motion
+       *
+       * @param mode - The trajectory mode (FREE, COORD, or TELEOP)
+       * @returns Promise resolving to RcsStatus indicating command completion
+       *
+       * @example
+       * ```typescript
+       * // Set to coordinated mode for normal G-code execution
+       * await commandChannel.setTrajMode(TrajMode.COORD);
+       *
+       * // Set to free mode for individual joint control
+       * await commandChannel.setTrajMode(TrajMode.FREE);
+       * ```
+       */
+      async setTrajMode(mode) {
+        return this.exec(this.nativeInstance.setTrajMode, mode);
+      }
+      /**
+       * Sets the maximum velocity for trajectory planning
+       *
+       * @param velocity - Maximum velocity in machine units per second
+       * @returns Promise resolving to RcsStatus indicating command completion
+       *
+       * @example
+       * ```typescript
+       * // Set maximum velocity to 200 units/second
+       * await commandChannel.setMaxVelocity(200);
+       * ```
+       */
+      async setMaxVelocity(velocity) {
+        return this.exec(this.nativeInstance.setMaxVelocity, velocity);
+      }
+      /**
+       * Sets the feedrate override scale factor
+       *
+       * @param scale - Feedrate scale factor (1.0 = 100%, 0.5 = 50%, 2.0 = 200%)
+       * @returns Promise resolving to RcsStatus indicating command completion
+       *
+       * @example
+       * ```typescript
+       * // Set feedrate to 50% of programmed values
+       * await commandChannel.setFeedRate(0.5);
+       *
+       * // Set feedrate to 120% of programmed values
+       * await commandChannel.setFeedRate(1.2);
+       * ```
+       */
+      async setFeedRate(scale) {
+        return this.exec(this.nativeInstance.setFeedRate, scale);
+      }
+      /**
+       * Sets the rapid traverse override scale factor
+       *
+       * @param scale - Rapid rate scale factor (1.0 = 100%, 0.25 = 25%)
+       * @returns Promise resolving to RcsStatus indicating command completion
+       *
+       * @example
+       * ```typescript
+       * // Set rapid rate to 50%
+       * await commandChannel.setRapidRate(0.5);
+       * ```
+       */
+      async setRapidRate(scale) {
+        return this.exec(this.nativeInstance.setRapidRate, scale);
+      }
+      /**
+       * Sets the spindle speed override scale factor
+       *
+       * @param scale - Spindle override scale factor (1.0 = 100%)
+       * @param spindleIndex - Index of the spindle to control (default: 0)
+       * @returns Promise resolving to RcsStatus indicating command completion
+       *
+       * @example
+       * ```typescript
+       * // Set spindle speed to 80% of programmed values
+       * await commandChannel.setSpindleOverride(0.8);
+       *
+       * // Set spindle 1 speed to 110%
+       * await commandChannel.setSpindleOverride(1.1, 1);
+       * ```
+       */
+      async setSpindleOverride(scale, spindleIndex = 0) {
+        return this.exec(this.nativeInstance.setSpindleOverride, scale, spindleIndex);
+      }
+      /**
+       * Overrides axis limits to allow motion beyond normal soft limits
+       *
+       * @returns Promise resolving to RcsStatus indicating command completion
+       *
+       * @example
+       * ```typescript
+       * // Override limits for recovery from limit switch activation
+       * await commandChannel.overrideLimits();
+       * ```
+       */
+      async overrideLimits() {
+        return this.exec(this.nativeInstance.overrideLimits);
+      }
+      /**
+       * Enables or disables teleop mode
+       *
+       * @param enable - true to enable teleop mode, false for joint mode
+       * @returns Promise resolving to RcsStatus indicating command completion
+       *
+       * @example
+       * ```typescript
+       * // Enable teleop mode for Cartesian jogging
+       * await commandChannel.teleopEnable(true);
+       *
+       * // Disable teleop mode for joint jogging
+       * await commandChannel.teleopEnable(false);
+       * ```
+       */
+      async teleopEnable(enable) {
+        return this.exec(this.nativeInstance.teleopEnable, enable);
+      }
+      /**
+       * Enables or disables feedrate override functionality
+       *
+       * @param enable - true to enable feedrate override, false to disable
+       * @returns Promise resolving to RcsStatus indicating command completion
+       *
+       * @example
+       * ```typescript
+       * // Enable feedrate override control
+       * await commandChannel.setFeedOverrideEnable(true);
+       * ```
+       */
+      async setFeedOverrideEnable(enable) {
+        return this.exec(this.nativeInstance.setFeedOverrideEnable, enable);
+      }
+      /**
+       * Enables or disables spindle speed override functionality
+       *
+       * @param enable - true to enable spindle override, false to disable
+       * @param spindleIndex - Index of the spindle to control (default: 0)
+       * @returns Promise resolving to RcsStatus indicating command completion
+       *
+       * @example
+       * ```typescript
+       * // Enable spindle override control
+       * await commandChannel.setSpindleOverrideEnable(true);
+       * ```
+       */
+      async setSpindleOverrideEnable(enable, spindleIndex = 0) {
+        return this.exec(this.nativeInstance.setSpindleOverrideEnable, enable, spindleIndex);
+      }
+      /**
+       * Enables or disables feed hold functionality
+       * When enabled, allows pausing motion without stopping the program
+       *
+       * @param enable - true to enable feed hold, false to disable
+       * @returns Promise resolving to RcsStatus indicating command completion
+       *
+       * @example
+       * ```typescript
+       * // Enable feed hold capability
+       * await commandChannel.setFeedHoldEnable(true);
+       * ```
+       */
+      async setFeedHoldEnable(enable) {
+        return this.exec(this.nativeInstance.setFeedHoldEnable, enable);
+      }
+      /**
+       * Enables or disables adaptive feed functionality
+       * Allows external signals to modulate feedrate in real-time
+       *
+       * @param enable - true to enable adaptive feed, false to disable
+       * @returns Promise resolving to RcsStatus indicating command completion
+       *
+       * @example
+       * ```typescript
+       * // Enable adaptive feed for force-sensitive machining
+       * await commandChannel.setAdaptiveFeedEnable(true);
+       * ```
+       */
+      async setAdaptiveFeedEnable(enable) {
+        return this.exec(this.nativeInstance.setAdaptiveFeedEnable, enable);
+      }
+      // --- Joint Commands ---
+      /**
+       * Homes a specific joint by moving it to its home position
+       *
+       * @param jointIndex - Zero-based index of the joint to home, -1 to home all joints
+       * @returns Promise resolving to RcsStatus indicating command completion
+       *
+       * @example
+       * ```typescript
+       * // Home joint 0 (typically X-axis)
+       * await commandChannel.homeJoint(0);
+       *
+       * // Home joint 2 (typically Z-axis)
+       * await commandChannel.homeJoint(2);
+       *
+       * // Home all joints
+       * await commandChannel.homeJoint(-1);
+       * ```
+       */
+      async homeJoint(jointIndex) {
+        return this.exec(this.nativeInstance.homeJoint, jointIndex);
+      }
+      /**
+       * Unhomes a specific joint, clearing its homed status
+       *
+       * @param jointIndex - Zero-based index of the joint to unhome, -1 to unhome all joints
+       * @returns Promise resolving to RcsStatus indicating command completion
+       *
+       * @example
+       * ```typescript
+       * // Unhome joint 1 (typically Y-axis)
+       * await commandChannel.unhomeJoint(1);
+       *
+       * // Unhome all joints
+       * await commandChannel.unhomeJoint(-1);
+       * ```
+       */
+      async unhomeJoint(jointIndex) {
+        return this.exec(this.nativeInstance.unhomeJoint, jointIndex);
+      }
+      /**
+       * Stops jogging motion for a specific axis or joint
+       *
+       * @param axisOrJointIndex - Index of the axis (0=X,1=Y,2=Z...) or joint to stop
+       * @param isJointJog - true for joint jogging, false for axis jogging
+       * @returns Promise resolving to RcsStatus indicating command completion
+       *
+       * @example
+       * ```typescript
+       * // Stop axis X jogging
+       * await commandChannel.jogStop(0, false);
+       *
+       * // Stop joint 1 jogging
+       * await commandChannel.jogStop(1, true);
+       * ```
+       */
+      async jogStop(axisOrJointIndex, isJointJog) {
+        return this.exec(this.nativeInstance.jogStop, axisOrJointIndex, isJointJog);
+      }
+      /**
+       * Starts continuous jogging motion for a specific axis or joint
+       *
+       * @param axisOrJointIndex - Index of the axis (0=X,1=Y,2=Z...) or joint to jog
+       * @param isJointJog - true for joint jogging, false for axis jogging
+       * @param speed - Jogging speed in machine units per second
+       * @returns Promise resolving to RcsStatus indicating command completion
+       *
+       * @example
+       * ```typescript
+       * // Jog X axis continuously at 10 units/sec
+       * await commandChannel.jogContinuous(0, false, 10);
+       *
+       * // Jog joint 2 continuously at -5 units/sec (negative direction)
+       * await commandChannel.jogContinuous(2, true, -5);
+       * ```
+       */
+      async jogContinuous(axisOrJointIndex, isJointJog, speed) {
+        return this.exec(this.nativeInstance.jogContinuous, axisOrJointIndex, isJointJog, speed);
+      }
+      /**
+       * Jogs a specific distance at a given speed for an axis or joint
+       *
+       * @param axisOrJointIndex - Index of the axis (0=X,1=Y,2=Z...) or joint to jog
+       * @param isJointJog - true for joint jogging, false for axis jogging
+       * @param speed - Jogging speed in machine units per second
+       * @param increment - Distance to jog in machine units
+       * @returns Promise resolving to RcsStatus indicating command completion
+       *
+       * @example
+       * ```typescript
+       * // Jog Y axis 1.0 unit at 5 units/sec
+       * await commandChannel.jogIncrement(1, false, 5, 1.0);
+       *
+       * // Jog joint 0 back 0.1 units at 2 units/sec
+       * await commandChannel.jogIncrement(0, true, 2, -0.1);
+       * ```
+       */
+      async jogIncrement(axisOrJointIndex, isJointJog, speed, increment) {
+        return this.exec(this.nativeInstance.jogIncrement, axisOrJointIndex, isJointJog, speed, increment);
+      }
+      /**
+       * Sets the minimum position limit for a joint
+       *
+       * @param jointIndex - Zero-based index of the joint
+       * @param limit - Minimum position limit in machine units
+       * @returns Promise resolving to RcsStatus indicating command completion
+       *
+       * @example
+       * ```typescript
+       * // Set minimum limit for joint 0 to -100 units
+       * await commandChannel.setMinPositionLimit(0, -100);
+       * ```
+       */
+      async setMinPositionLimit(jointIndex, limit) {
+        return this.exec(this.nativeInstance.setMinPositionLimit, jointIndex, limit);
+      }
+      /**
+       * Sets the maximum position limit for a joint
+       *
+       * @param jointIndex - Zero-based index of the joint
+       * @param limit - Maximum position limit in machine units
+       * @returns Promise resolving to RcsStatus indicating command completion
+       *
+       * @example
+       * ```typescript
+       * // Set maximum limit for joint 0 to 200 units
+       * await commandChannel.setMaxPositionLimit(0, 200);
+       * ```
+       */
+      async setMaxPositionLimit(jointIndex, limit) {
+        return this.exec(this.nativeInstance.setMaxPositionLimit, jointIndex, limit);
+      }
+      // --- Spindle Commands ---
+      /**
+       * Turns on the spindle at a specified speed
+       *
+       * @param speed - Spindle speed in RPM (positive = clockwise, negative = counterclockwise)
+       * @param spindleIndex - Index of the spindle to control (default: 0)
+       * @param waitForSpeed - Whether to wait for spindle to reach speed before continuing (default: true)
+       * @returns Promise resolving to RcsStatus indicating command completion
+       *
+       * @example
+       * ```typescript
+       * // Turn on spindle at 1000 RPM clockwise
+       * await commandChannel.spindleOn(1000);
+       *
+       * // Turn on spindle 1 at 500 RPM counterclockwise
+       * await commandChannel.spindleOn(-500, 1);
+       *
+       * // Start spindle without waiting for speed
+       * await commandChannel.spindleOn(800, 0, false);
+       * ```
+       */
+      async spindleOn(speed, spindleIndex = 0, waitForSpeed = true) {
+        return this.exec(this.nativeInstance.spindleOn, speed, spindleIndex, waitForSpeed);
+      }
+      /**
+       * Increases spindle speed by a predefined increment
+       * Spindle must already be running
+       *
+       * @param spindleIndex - Index of the spindle to control (default: 0)
+       * @returns Promise resolving to RcsStatus indicating command completion
+       *
+       * @example
+       * ```typescript
+       * // Increase speed of main spindle
+       * await commandChannel.spindleIncrease();
+       *
+       * // Increase speed of spindle 1
+       * await commandChannel.spindleIncrease(1);
+       * ```
+       */
+      async spindleIncrease(spindleIndex = 0) {
+        return this.exec(this.nativeInstance.spindleIncrease, spindleIndex);
+      }
+      /**
+       * Decreases spindle speed by a predefined increment
+       * Spindle must already be running
+       *
+       * @param spindleIndex - Index of the spindle to control (default: 0)
+       * @returns Promise resolving to RcsStatus indicating command completion
+       *
+       * @example
+       * ```typescript
+       * // Decrease speed of main spindle
+       * await commandChannel.spindleDecrease();
+       *
+       * // Decrease speed of spindle 1
+       * await commandChannel.spindleDecrease(1);
+       * ```
+       */
+      async spindleDecrease(spindleIndex = 0) {
+        return this.exec(this.nativeInstance.spindleDecrease, spindleIndex);
+      }
+      /**
+       * Turns off the spindle
+       *
+       * @param spindleIndex - Index of the spindle to control (default: 0)
+       * @returns Promise resolving to RcsStatus indicating command completion
+       *
+       * @example
+       * ```typescript
+       * // Turn off main spindle
+       * await commandChannel.spindleOff();
+       *
+       * // Turn off spindle 1
+       * await commandChannel.spindleOff(1);
+       * ```
+       */
+      async spindleOff(spindleIndex = 0) {
+        return this.exec(this.nativeInstance.spindleOff, spindleIndex);
+      }
+      /**
+       * Engages or releases the spindle brake
+       *
+       * @param engage - true to engage brake, false to release brake
+       * @param spindleIndex - Index of the spindle to control (default: 0)
+       * @returns Promise resolving to RcsStatus indicating command completion
+       *
+       * @example
+       * ```typescript
+       * // Engage spindle brake
+       * await commandChannel.spindleBrake(true);
+       *
+       * // Release brake on spindle 1
+       * await commandChannel.spindleBrake(false, 1);
+       * ```
+       */
+      async spindleBrake(engage, spindleIndex = 0) {
+        return this.exec(this.nativeInstance.spindleBrake, engage, spindleIndex);
+      }
+      // --- Coolant Commands ---
+      /**
+       * Turns mist coolant on or off
+       *
+       * @param on - true to turn mist on, false to turn off
+       * @returns Promise resolving to RcsStatus indicating command completion
+       *
+       * @example
+       * ```typescript
+       * // Turn on mist coolant
+       * await commandChannel.setMist(true);
+       *
+       * // Turn off mist coolant
+       * await commandChannel.setMist(false);
+       * ```
+       */
+      async setMist(on) {
+        return this.exec(this.nativeInstance.setMist, on);
+      }
+      /**
+       * Turns flood coolant on or off
+       *
+       * @param on - true to turn flood on, false to turn off
+       * @returns Promise resolving to RcsStatus indicating command completion
+       *
+       * @example
+       * ```typescript
+       * // Turn on flood coolant
+       * await commandChannel.setFlood(true);
+       *
+       * // Turn off flood coolant
+       * await commandChannel.setFlood(false);
+       * ```
+       */
+      async setFlood(on) {
+        return this.exec(this.nativeInstance.setFlood, on);
+      }
+      // --- Tool Commands ---
+      /**
+       * Reloads the tool table from disk
+       * Updates the in-memory tool table with changes made to the tool table file
+       *
+       * @returns Promise resolving to RcsStatus indicating command completion
+       *
+       * @example
+       * ```typescript
+       * // Reload tool table after editing the .tbl file
+       * await commandChannel.loadToolTable();
+       * ```
+       */
+      async loadToolTable() {
+        return this.exec(this.nativeInstance.loadToolTable);
+      }
+      /**
+       * Sets tool data for a specific tool number
+       * Updates tool geometry and parameters in the tool table
+       *
+       * @param toolEntry - Tool entry containing tool number and optional geometry data
+       * @returns Promise resolving to RcsStatus indicating command completion
+       *
+       * @example
+       * ```typescript
+       * // Set basic tool data
+       * await commandChannel.setTool({
+       *   toolNo: 3,
+       *   pocketNo: 3
+       * });
+       *
+       * // Set tool with geometry data
+       * await commandChannel.setTool({
+       *   toolNo: 1,
+       *   pocketNo: 1,
+       *   diameter: 6.35,
+       *   offset: {
+       *     x: 0,
+       *     y: 0,
+       *     z: 25.4
+       *   }
+       * });
+       * ```
+       */
+      async setTool(toolEntry) {
+        return this.exec(this.nativeInstance.setTool, toolEntry);
+      }
+      // --- IO Commands ---
+      /**
+       * Sets the state of a digital output pin
+       *
+       * @param index - Index of the digital output pin
+       * @param value - true to set high, false to set low
+       * @returns Promise resolving to RcsStatus indicating command completion
+       *
+       * @example
+       * ```typescript
+       * // Set digital output 0 high
+       * await commandChannel.setDigitalOutput(0, true);
+       *
+       * // Set digital output 3 low
+       * await commandChannel.setDigitalOutput(3, false);
+       * ```
+       */
+      async setDigitalOutput(index, value) {
+        return this.exec(this.nativeInstance.setDigitalOutput, index, value);
+      }
+      /**
+       * Sets the value of an analog output pin
+       *
+       * @param index - Index of the analog output pin
+       * @param value - Analog value to set
+       * @returns Promise resolving to RcsStatus indicating command completion
+       *
+       * @example
+       * ```typescript
+       * // Set analog output 0 to 13.3
+       * await commandChannel.setAnalogOutput(0, 13.3);
+       * ```
+       */
+      async setAnalogOutput(index, value) {
+        return this.exec(this.nativeInstance.setAnalogOutput, index, value);
+      }
+      // --- Debug & Message Commands ---
+      /**
+       * Sets debug flags for LinuxCNC components using OR-ed EmcDebug flags
+       * Multiple debug categories can be enabled simultaneously by combining flags
+       *
+       * @param level - Debug flags from EmcDebug enum, can be OR-ed together
+       * @returns Promise resolving to RcsStatus indicating command completion
+       *
+       * @example
+       * ```typescript
+       * // Disable all debugging
+       * await commandChannel.setDebugLevel(0);
+       *
+       * // Enable interpreter debugging only
+       * await commandChannel.setDebugLevel(EmcDebug.INTERP);
+       *
+       * // Enable multiple debug categories
+       * await commandChannel.setDebugLevel(EmcDebug.INTERP | EmcDebug.MOTION_TIME);
+       *
+       * // Enable task and NML debugging
+       * await commandChannel.setDebugLevel(EmcDebug.TASK_ISSUE | EmcDebug.NML);
+       *
+       * // Enable Python and remap debugging for custom components
+       * await commandChannel.setDebugLevel(EmcDebug.PYTHON | EmcDebug.REMAP);
+       * ```
+       */
+      async setDebugLevel(level) {
+        return this.exec(this.nativeInstance.setDebugLevel, level);
+      }
+      /**
+       * Sends an error message to the operator display
+       *
+       * @param message - Error message to display (max 254 characters)
+       * @returns Promise resolving to RcsStatus indicating command completion
+       *
+       * @example
+       * ```typescript
+       * // Send error message
+       * await commandChannel.sendOperatorError('Tool change required');
+       * ```
+       */
+      async sendOperatorError(message) {
+        return this.exec(this.nativeInstance.sendOperatorError, message);
+      }
+      /**
+       * Sends a text message to the operator display
+       *
+       * @param message - Text message to display (max 254 characters)
+       * @returns Promise resolving to RcsStatus indicating command completion
+       *
+       * @example
+       * ```typescript
+       * // Send informational message
+       * await commandChannel.sendOperatorText('Setup complete');
+       * ```
+       */
+      async sendOperatorText(message) {
+        return this.exec(this.nativeInstance.sendOperatorText, message);
+      }
+      /**
+       * Sends a display message to the operator
+       *
+       * @param message - Display message (max 254 characters)
+       * @returns Promise resolving to RcsStatus indicating command completion
+       *
+       * @example
+       * ```typescript
+       * // Send display message
+       * await commandChannel.sendOperatorDisplay('Insert tool T1 M6');
+       * ```
+       */
+      async sendOperatorDisplay(message) {
+        return this.exec(this.nativeInstance.sendOperatorDisplay, message);
+      }
+      // --- Misc ---
+      /**
+       * Synchronously waits for the last command to complete
+       * This does the same as await but provides a synchronous way to wait for command completion
+       *
+       * @param timeout - Maximum time to wait in seconds (default: 5 seconds)
+       * @returns RcsStatus indicating completion status (RCS_DONE, RCS_ERROR, or -1 for timeout)
+       *
+       * @example
+       * ```typescript
+       * // These two approaches are equivalent:
+       *
+       * // Approach 1: Using await (asynchronous)
+       * await commandChannel.runProgram();
+       * console.log('Program completed');
+       *
+       * // Approach 2: Using waitComplete (synchronous)
+       * commandChannel.runProgram(); // Fire and forget - don't await
+       * const status = commandChannel.waitComplete(); // Synchronously wait for completion
+       * if (status === RcsStatus.DONE) {
+       *   console.log('Program completed');
+       * }
+       * ```
+       */
+      waitComplete(timeout) {
+        if (!this.nativeInstance)
+          throw new Error("CommandChannel native instance not available.");
+        return this.nativeInstance.waitComplete(timeout);
+      }
+      /**
+       * Gets the serial number of the current command
+       * Each command sent has a unique serial number for tracking
+       *
+       * @returns The current command serial number
+       *
+       * @example
+       * ```typescript
+       * // Get current command serial number
+       * const serial = commandChannel.getSerial();
+       * console.log(`Current command serial: ${serial}`);
+       * ```
+       */
+      getSerial() {
+        if (!this.nativeInstance)
+          throw new Error("CommandChannel native instance not available.");
+        return this.nativeInstance.serial;
+      }
+      /**
+       * Destroys the command channel and cleans up resources
+       * Call this when done using the command channel
+       */
+      destroy() {
+        if (this.nativeInstance) {
+          this.nativeInstance.disconnect();
+        }
+      }
+    };
+    exports2.CommandChannel = CommandChannel2;
+  }
+});
+
+// ../node_modules/.pnpm/@linuxcnc-node+core@2.1.3/node_modules/@linuxcnc-node/core/dist/errorChannel.js
+var require_errorChannel = __commonJS({
+  "../node_modules/.pnpm/@linuxcnc-node+core@2.1.3/node_modules/@linuxcnc-node/core/dist/errorChannel.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.ErrorChannel = exports2.DEFAULT_ERROR_POLL_INTERVAL = void 0;
+    var events_1 = require("events");
+    var constants_1 = require_constants();
+    var types_1 = require_dist2();
+    exports2.DEFAULT_ERROR_POLL_INTERVAL = 100;
+    var ErrorChannel2 = class extends events_1.EventEmitter {
+      constructor(options) {
+        super();
+        this.poller = null;
+        this.isPolling = false;
+        this.nativeInstance = new constants_1.addon.NativeErrorChannel();
+        const pollInterval = options?.pollInterval ?? exports2.DEFAULT_ERROR_POLL_INTERVAL;
+        this.poller = setInterval(() => this.poll(), pollInterval);
+      }
+      poll() {
+        if (this.isPolling)
+          return;
+        this.isPolling = true;
+        try {
+          const error = this.nativeInstance.poll();
+          if (error) {
+            this.emit("message", error);
+            switch (error.type) {
+              case types_1.NmlMessageType.EMC_OPERATOR_ERROR:
+                this.emit("operatorError", error);
+                break;
+              case types_1.NmlMessageType.EMC_OPERATOR_TEXT:
+                this.emit("operatorText", error);
+                break;
+              case types_1.NmlMessageType.EMC_OPERATOR_DISPLAY:
+                this.emit("operatorDisplay", error);
+                break;
+              case types_1.NmlMessageType.NML_ERROR:
+                this.emit("nmlError", error);
+                break;
+              case types_1.NmlMessageType.NML_TEXT:
+                this.emit("nmlText", error);
+                break;
+              case types_1.NmlMessageType.NML_DISPLAY:
+                this.emit("nmlDisplay", error);
+                break;
+            }
+          }
+        } catch (e) {
+          console.error("Error during ErrorChannel poll:", e);
+        } finally {
+          this.isPolling = false;
+        }
+      }
+      destroy() {
+        if (this.poller) {
+          clearInterval(this.poller);
+          this.poller = null;
+        }
+        this.removeAllListeners();
+        this.nativeInstance.disconnect();
+      }
+    };
+    exports2.ErrorChannel = ErrorChannel2;
+  }
+});
+
+// ../node_modules/.pnpm/@linuxcnc-node+core@2.1.3/node_modules/@linuxcnc-node/core/dist/positionLogger.js
+var require_positionLogger = __commonJS({
+  "../node_modules/.pnpm/@linuxcnc-node+core@2.1.3/node_modules/@linuxcnc-node/core/dist/positionLogger.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.PositionLogger = void 0;
+    var constants_1 = require_constants();
+    var PositionLogger2 = class {
+      constructor() {
+        this.nativeLogger = new constants_1.addon.NativePositionLogger();
+      }
+      /**
+       * Start position logging
+       * @param options Logging options
+       */
+      start(options = {}) {
+        const interval = options.interval || 0.01;
+        const maxHistorySize = options.maxHistorySize || 1e4;
+        this.nativeLogger.start(interval, maxHistorySize);
+      }
+      /**
+       * Stop position logging
+       */
+      stop() {
+        this.nativeLogger.stop();
+      }
+      /**
+       * Clear the position history (invalidates all previous cursors)
+       */
+      clear() {
+        this.nativeLogger.clear();
+      }
+      /**
+       * Get the current position as a Float64Array
+       * Layout: [x, y, z, a, b, c, u, v, w, motionType]
+       * @returns Float64Array with 10 values, or null if no position available
+       */
+      getCurrentPosition() {
+        return this.nativeLogger.getCurrentPosition();
+      }
+      /**
+       * Get the motion history as a Float64Array
+       * Layout: [x, y, z, a, b, c, u, v, w, motionType] repeated for each point
+       * Use POSITION_STRIDE (10) to iterate through points
+       * @param startIndex Starting index (default: 0)
+       * @param count Number of points to retrieve (default: all)
+       * @returns Float64Array with 10 values per point
+       */
+      getMotionHistory(startIndex, count) {
+        if (startIndex !== void 0 && count !== void 0) {
+          return this.nativeLogger.getMotionHistory(startIndex, count);
+        } else if (startIndex !== void 0) {
+          return this.nativeLogger.getMotionHistory(startIndex);
+        } else {
+          return this.nativeLogger.getMotionHistory();
+        }
+      }
+      /**
+       * Get the number of points in the motion history
+       * @returns Number of logged points
+       */
+      getHistoryCount() {
+        return this.nativeLogger.getHistoryCount();
+      }
+      /**
+       * Get the most recent points from the history
+       * @param count Number of recent points to get (default: 10)
+       * @returns Float64Array with 10 values per point
+       */
+      getRecentHistory(count = 10) {
+        const totalCount = this.getHistoryCount();
+        if (totalCount === 0)
+          return new Float64Array(0);
+        const startIndex = Math.max(0, totalCount - count);
+        const actualCount = Math.min(count, totalCount);
+        return this.getMotionHistory(startIndex, actualCount);
+      }
+      /**
+       * Get the current cursor position (monotonic counter of points ever added)
+       * @returns Current cursor value
+       */
+      getCurrentCursor() {
+        return this.nativeLogger.getCurrentCursor();
+      }
+      /**
+       * Get delta points since a given cursor position
+       * Use this for efficient incremental updates instead of fetching full history.
+       * @param cursor Last known cursor (0 for full history)
+       * @returns Delta result with points, count, new cursor, and wasReset flag
+       */
+      getDeltaSince(cursor2) {
+        return this.nativeLogger.getDeltaSince(cursor2);
+      }
+    };
+    exports2.PositionLogger = PositionLogger2;
+  }
+});
+
+// ../node_modules/.pnpm/@linuxcnc-node+core@2.1.3/node_modules/@linuxcnc-node/core/dist/index.js
+var require_dist3 = __commonJS({
+  "../node_modules/.pnpm/@linuxcnc-node+core@2.1.3/node_modules/@linuxcnc-node/core/dist/index.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.PositionLogger = exports2.ErrorChannel = exports2.CommandChannel = exports2.StatChannel = void 0;
+    exports2.setNmlFilePath = setNmlFilePath;
+    exports2.getNmlFilePath = getNmlFilePath;
+    var statChannel_1 = require_statChannel();
+    Object.defineProperty(exports2, "StatChannel", { enumerable: true, get: function() {
+      return statChannel_1.StatChannel;
+    } });
+    var commandChannel_1 = require_commandChannel();
+    Object.defineProperty(exports2, "CommandChannel", { enumerable: true, get: function() {
+      return commandChannel_1.CommandChannel;
+    } });
+    var errorChannel_1 = require_errorChannel();
+    Object.defineProperty(exports2, "ErrorChannel", { enumerable: true, get: function() {
+      return errorChannel_1.ErrorChannel;
+    } });
+    var positionLogger_1 = require_positionLogger();
+    Object.defineProperty(exports2, "PositionLogger", { enumerable: true, get: function() {
+      return positionLogger_1.PositionLogger;
+    } });
+    var constants_1 = require_constants();
+    var nmlFilePath = constants_1.addon.NMLFILE_DEFAULT;
+    function setNmlFilePath(filePath) {
+      constants_1.addon.setNmlFilePath(filePath);
+      nmlFilePath = filePath;
+    }
+    function getNmlFilePath() {
+      return constants_1.addon.getNmlFilePath();
+    }
+  }
+});
+
+// ../node_modules/.pnpm/@linuxcnc-node+gcode@2.1.3/node_modules/@linuxcnc-node/gcode/dist/parser.js
+var require_parser = __commonJS({
+  "../node_modules/.pnpm/@linuxcnc-node+gcode@2.1.3/node_modules/@linuxcnc-node/gcode/dist/parser.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.parseGCode = parseGCode2;
+    function loadAddon() {
+      const paths = [
+        "../build/Release/gcode_addon.node",
+        // Installed in node_modules (path relative to dist/)
+        "../../build/Release/gcode_addon.node"
+        // Local development (path relative to src/ts/)
+      ];
+      for (const path of paths) {
+        try {
+          return require(path);
+        } catch {
+        }
+      }
+      throw new Error(`Failed to load gcode_addon.node. Tried paths:
+` + paths.map((p) => `  - ${p}`).join("\n"));
+    }
+    var addon = loadAddon();
+    async function parseGCode2(filepath, options) {
+      if (!options.iniPath) {
+        throw new Error("iniPath is required in ParseOptions");
+      }
+      return new Promise((resolve, reject) => {
+        const progressCallback = options.onProgress || ((_progress) => {
+        });
+        const progressUpdates = options.progressUpdates ?? 40;
+        addon.parseGCode(filepath, options.iniPath, progressUpdates, progressCallback, (error, result) => {
+          if (error) {
+            reject(error);
+          } else {
+            resolve(result);
+          }
+        });
+      });
+    }
+  }
+});
+
+// ../node_modules/.pnpm/@linuxcnc-node+gcode@2.1.3/node_modules/@linuxcnc-node/gcode/dist/index.js
+var require_dist4 = __commonJS({
+  "../node_modules/.pnpm/@linuxcnc-node+gcode@2.1.3/node_modules/@linuxcnc-node/gcode/dist/index.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.parseGCode = void 0;
+    var parser_1 = require_parser();
+    Object.defineProperty(exports2, "parseGCode", { enumerable: true, get: function() {
+      return parser_1.parseGCode;
+    } });
+  }
+});
+
+// ../node_modules/.pnpm/@linuxcnc-node+hal@2.1.3/node_modules/@linuxcnc-node/hal/dist/constants.js
+var require_constants3 = __commonJS({
+  "../node_modules/.pnpm/@linuxcnc-node+hal@2.1.3/node_modules/@linuxcnc-node/hal/dist/constants.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.RtapiMsgLevelFromValue = exports2.HalParamDirFromValue = exports2.HalPinDirFromValue = exports2.HalTypeFromValue = exports2.RtapiMsgLevelValue = exports2.HalParamDirValue = exports2.HalPinDirValue = exports2.HalTypeValue = exports2.halNative = void 0;
+    function loadAddon() {
+      const paths = [
+        "../build/Release/hal_addon.node",
+        "../../build/Release/hal_addon.node"
+      ];
+      for (const path of paths) {
+        try {
+          return require(path);
+        } catch {
+        }
+      }
+      throw new Error("Failed to load linuxcnc-node hal native addon. Please ensure it's built correctly and that LinuxCNC is in your PATH.");
+    }
+    exports2.halNative = loadAddon();
+    exports2.HalTypeValue = {
+      bit: 1,
+      float: 2,
+      s32: 3,
+      u32: 4,
+      s64: 6,
+      u64: 7
+    };
+    exports2.HalPinDirValue = {
+      in: 16,
+      out: 32,
+      io: 48
+    };
+    exports2.HalParamDirValue = {
+      ro: 64,
+      rw: 192
+    };
+    exports2.RtapiMsgLevelValue = {
+      none: 0,
+      err: 1,
+      warn: 2,
+      info: 3,
+      dbg: 4,
+      all: 5
+    };
+    function createReverseMap(map) {
+      const reverse = {};
+      for (const [key, value] of Object.entries(map)) {
+        reverse[value] = key;
+      }
+      return reverse;
+    }
+    exports2.HalTypeFromValue = createReverseMap(exports2.HalTypeValue);
+    exports2.HalPinDirFromValue = createReverseMap(exports2.HalPinDirValue);
+    exports2.HalParamDirFromValue = createReverseMap(exports2.HalParamDirValue);
+    exports2.RtapiMsgLevelFromValue = createReverseMap(exports2.RtapiMsgLevelValue);
+  }
+});
+
+// ../node_modules/.pnpm/@linuxcnc-node+hal@2.1.3/node_modules/@linuxcnc-node/hal/dist/item.js
+var require_item = __commonJS({
+  "../node_modules/.pnpm/@linuxcnc-node+hal@2.1.3/node_modules/@linuxcnc-node/hal/dist/item.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.Param = exports2.Pin = exports2.HalItem = void 0;
+    var events_1 = require("events");
+    var HalItem = class extends events_1.EventEmitter {
+      constructor(component, nameSuffix, type, direction) {
+        super();
+        this.component = component;
+        this.name = nameSuffix;
+        this.type = type;
+        this.direction = direction;
+      }
+      /**
+       * Retrieves the current value of this item.
+       *
+       * @returns The item's value (number or boolean depending on type).
+       */
+      getValue() {
+        return this.component.getValue(this.name);
+      }
+      /**
+       * Sets the value of this item.
+       *
+       * For pins, only applicable to `HAL_OUT` or `HAL_IO` pins.
+       * For parameters, only applicable to `HAL_RW` parameters.
+       *
+       * @param value - The new value for the item.
+       * @returns The value that was set.
+       * @throws Error if trying to set an `HAL_IN` pin or `HAL_RO` parameter.
+       */
+      setValue(value) {
+        return this.component.setValue(this.name, value);
+      }
+    };
+    exports2.HalItem = HalItem;
+    var Pin2 = class extends HalItem {
+    };
+    exports2.Pin = Pin2;
+    var Param2 = class extends HalItem {
+    };
+    exports2.Param = Param2;
+  }
+});
+
+// ../node_modules/.pnpm/@linuxcnc-node+hal@2.1.3/node_modules/@linuxcnc-node/hal/dist/component.js
+var require_component = __commonJS({
+  "../node_modules/.pnpm/@linuxcnc-node+hal@2.1.3/node_modules/@linuxcnc-node/hal/dist/component.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.HalComponent = exports2.DEFAULT_POLL_INTERVAL = void 0;
+    var events_1 = require("events");
+    var constants_1 = require_constants3();
+    var item_1 = require_item();
+    exports2.DEFAULT_POLL_INTERVAL = 10;
+    var HalComponent2 = class extends events_1.EventEmitter {
+      /**
+       * Creates a new HAL component.
+       *
+       * @param name - The name of the component (e.g., "my-component").
+       *               This will be registered with LinuxCNC HAL.
+       * @param prefix - Optional prefix for pins and parameters created by this component.
+       *                 If not provided, defaults to `name`.
+       */
+      constructor(name, prefix) {
+        super();
+        this.pins = {};
+        this.params = {};
+        this.watchedItems = /* @__PURE__ */ new Map();
+        this.monitoringTimer = null;
+        this.monitoringOptions = {
+          pollInterval: exports2.DEFAULT_POLL_INTERVAL
+        };
+        this.cursor = 0;
+        this.nativeInstance = new constants_1.halNative.HalComponent(name, prefix);
+        this.name = name;
+        this.prefix = prefix || name;
+      }
+      /**
+       * Checks if a HAL component with the given name exists in the system.
+       *
+       * @param name - The component name (e.g., "halui", "my-custom-comp").
+       * @returns `true` if the component exists, `false` otherwise.
+       */
+      static exists(name) {
+        return constants_1.halNative.component_exists(name);
+      }
+      /**
+       * Checks if the HAL component with the given name has been marked as ready.
+       *
+       * @param name - The component name.
+       * @returns `true` if the component exists and is ready, `false` otherwise.
+       */
+      static isReady(name) {
+        return constants_1.halNative.component_is_ready(name);
+      }
+      /**
+       * Gets the value of a pin or parameter by name.
+       *
+       * @param name - The nameSuffix of the pin or parameter.
+       * @returns The current value.
+       */
+      getValue(name) {
+        return this.nativeInstance.getProperty(name);
+      }
+      /**
+       * Sets the value of a pin or parameter by name.
+       *
+       * @param name - The nameSuffix of the pin or parameter.
+       * @param value - The value to set.
+       * @returns The value that was set.
+       */
+      setValue(name, value) {
+        if (typeof value !== "number" && typeof value !== "boolean") {
+          throw new TypeError("Value must be a number or boolean");
+        }
+        return this.nativeInstance.setProperty(name, value);
+      }
+      /**
+       * Creates a new HAL pin associated with this component.
+       *
+       * This method can only be called before `ready()` or after `unready()`.
+       *
+       * @param nameSuffix - The suffix for the pin name (e.g., "in1", "motor.0.pos").
+       *                     The full HAL name will be `this.prefix + "." + nameSuffix`.
+       * @param type - The data type of the pin (e.g., `"float"`, `"bit"`).
+       *               See {@link HalType} for available types.
+       * @param direction - The direction of the pin (e.g., `"in"`, `"out"`, `"io"`).
+       *                    See {@link HalPinDir} for available directions.
+       * @returns A new `Pin` object instance.
+       * @throws Error if component is ready or if pin creation fails.
+       */
+      newPin(nameSuffix, type, direction) {
+        const success = this.nativeInstance.newPin(nameSuffix, constants_1.HalTypeValue[type], constants_1.HalPinDirValue[direction]);
+        if (!success) {
+          console.error(`Failed to create pin '${nameSuffix}'`);
+        }
+        const pin = new item_1.Pin(this, nameSuffix, type, direction);
+        this.pins[nameSuffix] = pin;
+        this.setupItemListeners(pin, nameSuffix);
+        return pin;
+      }
+      /**
+       * Creates a new HAL parameter associated with this component.
+       *
+       * This method can only be called before `ready()` or after `unready()`.
+       *
+       * @param nameSuffix - The suffix for the parameter name.
+       *                     The full HAL name will be `this.prefix + "." + nameSuffix`.
+       * @param type - The data type of the parameter. See {@link HalType} for available types.
+       * @param direction - The writability of the parameter (`"ro"` for read-only,
+       *                    `"rw"` for read-write). See {@link HalParamDir}.
+       * @returns A new `Param` object instance.
+       * @throws Error if component is ready or if parameter creation fails.
+       */
+      newParam(nameSuffix, type, direction) {
+        const success = this.nativeInstance.newParam(nameSuffix, constants_1.HalTypeValue[type], constants_1.HalParamDirValue[direction]);
+        if (!success) {
+          console.error(`Failed to create param '${nameSuffix}'`);
+        }
+        const param = new item_1.Param(this, nameSuffix, type, direction);
+        this.params[nameSuffix] = param;
+        this.setupItemListeners(param, nameSuffix);
+        return param;
+      }
+      /**
+       * Sets up auto-watch listeners for a pin or param.
+       * @private
+       */
+      setupItemListeners(item, name) {
+        item.on("newListener", (event) => {
+          if (event === "change" && !this.watchedItems.has(name)) {
+            this.watchedItems.set(name, {
+              item,
+              lastValue: this.getValue(name)
+            });
+            this.ensureMonitoring();
+          }
+        });
+        item.on("removeListener", (event) => {
+          if (event === "change" && item.listenerCount("change") === 0) {
+            this.watchedItems.delete(name);
+            this.checkStopMonitoring();
+          }
+        });
+      }
+      /**
+       * Marks this component as ready and available to the HAL system.
+       *
+       * Once ready, pins can be linked, and parameters can be accessed by other
+       * HAL components or tools. Pins and parameters cannot be added after `ready()`
+       * is called, unless `unready()` is called first.
+       */
+      ready() {
+        this.nativeInstance.ready();
+      }
+      /**
+       * Marks this component as not ready, allowing addition of more pins or parameters.
+       *
+       * `ready()` must be called again to make the component (and any new items)
+       * available to HAL.
+       */
+      unready() {
+        this.nativeInstance.unready();
+      }
+      /**
+       * Retrieves a map of all `Pin` objects created for this component.
+       *
+       * @returns An object where keys are the `nameSuffix` of the pins and values
+       *          are the corresponding `Pin` instances.
+       */
+      getPins() {
+        return this.pins;
+      }
+      /**
+       * Retrieves a map of all `Param` objects created for this component.
+       *
+       * @returns An object where keys are the `nameSuffix` of the parameters and
+       *          values are the corresponding `Param` instances.
+       */
+      getParams() {
+        return this.params;
+      }
+      /**
+       * Gets a pin by name.
+       *
+       * @param name - The nameSuffix of the pin.
+       * @returns The Pin instance, or undefined if not found.
+       */
+      getPin(name) {
+        return this.pins[name];
+      }
+      /**
+       * Gets a param by name.
+       *
+       * @param name - The nameSuffix of the param.
+       * @returns The Param instance, or undefined if not found.
+       */
+      getParam(name) {
+        return this.params[name];
+      }
+      /**
+       * Gets the current cursor value for sync operations.
+       *
+       * The cursor is monotonically increasing and increments with each delta emit.
+       *
+       * @returns The current cursor value.
+       */
+      getCursor() {
+        return this.cursor;
+      }
+      /**
+       * Gets a snapshot of all current item values.
+       *
+       * Useful for initial sync or resync after cursor mismatch.
+       *
+       * @returns Object with items map, current cursor, and timestamp.
+       */
+      getSnapshot() {
+        const items = {};
+        for (const [name] of this.watchedItems.entries()) {
+          items[name] = this.getValue(name);
+        }
+        return {
+          items,
+          cursor: this.cursor,
+          timestamp: Date.now()
+        };
+      }
+      /**
+       * Configures the monitoring system settings.
+       *
+       * The monitoring system will check for value changes at the specified interval.
+       *
+       * @param options - Configuration object with `pollInterval` property (in milliseconds).
+       *                  Default polling interval is 10ms.
+       */
+      setMonitoringOptions(options) {
+        this.monitoringOptions = { ...this.monitoringOptions, ...options };
+        if (this.monitoringTimer && this.watchedItems.size > 0) {
+          this.stopMonitoring();
+          this.startMonitoring();
+        }
+      }
+      /**
+       * Retrieves the current monitoring configuration.
+       *
+       * @returns A copy of the current monitoring options.
+       */
+      getMonitoringOptions() {
+        return { ...this.monitoringOptions };
+      }
+      /**
+       * Starts the monitoring timer if not already running.
+       * @private
+       */
+      ensureMonitoring() {
+        if (!this.monitoringTimer && this.watchedItems.size > 0) {
+          this.startMonitoring();
+        }
+      }
+      /**
+       * Stops monitoring if no items are being watched.
+       * @private
+       */
+      checkStopMonitoring() {
+        if (this.watchedItems.size === 0) {
+          this.stopMonitoring();
+        }
+      }
+      /**
+       * Starts the monitoring timer.
+       * @private
+       */
+      startMonitoring() {
+        if (this.monitoringTimer) {
+          return;
+        }
+        this.monitoringTimer = setInterval(() => {
+          this.checkForChanges();
+        }, this.monitoringOptions.pollInterval || exports2.DEFAULT_POLL_INTERVAL);
+      }
+      /**
+       * Stops the monitoring timer.
+       * @private
+       */
+      stopMonitoring() {
+        if (this.monitoringTimer) {
+          clearInterval(this.monitoringTimer);
+          this.monitoringTimer = null;
+        }
+      }
+      /**
+       * Checks all watched items for value changes and emits events.
+       *
+       * Emits individual 'change' events on each HalItem, plus a batch 'delta'
+       * event on the component with all changes aggregated.
+       * @private
+       */
+      checkForChanges() {
+        const changes = [];
+        for (const [name, watched] of this.watchedItems.entries()) {
+          try {
+            const currentValue = this.getValue(name);
+            if (currentValue !== watched.lastValue) {
+              const oldValue = watched.lastValue;
+              watched.lastValue = currentValue;
+              watched.item.emit("change", currentValue, oldValue);
+              changes.push({ name, value: currentValue });
+            }
+          } catch (error) {
+            console.error(`Error checking value for ${name}:`, error);
+          }
+        }
+        if (changes.length > 0) {
+          this.cursor++;
+          const delta = {
+            changes,
+            cursor: this.cursor,
+            timestamp: Date.now()
+          };
+          this.emit("delta", delta);
+        }
+      }
+      /**
+       * Cleans up the component, stops monitoring and removes all listeners.
+       *
+       * Should be called when the component is no longer needed to prevent memory leaks.
+       */
+      dispose() {
+        this.stopMonitoring();
+        this.watchedItems.clear();
+        for (const pin of Object.values(this.pins)) {
+          pin.removeAllListeners();
+        }
+        for (const param of Object.values(this.params)) {
+          param.removeAllListeners();
+        }
+      }
+    };
+    exports2.HalComponent = HalComponent2;
+  }
+});
+
+// ../node_modules/.pnpm/@linuxcnc-node+hal@2.1.3/node_modules/@linuxcnc-node/hal/dist/functions.js
+var require_functions = __commonJS({
+  "../node_modules/.pnpm/@linuxcnc-node+hal@2.1.3/node_modules/@linuxcnc-node/hal/dist/functions.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.setSignalValue = exports2.setPinParamValue = exports2.pinHasWriter = exports2.newSignal = exports2.getInfoParams = exports2.getInfoSignals = exports2.getInfoPins = exports2.getValue = exports2.disconnect = exports2.connect = exports2.setMsgLevel = exports2.getMsgLevel = void 0;
+    var constants_1 = require_constants3();
+    var getMsgLevel2 = () => {
+      const nativeValue = constants_1.halNative.get_msg_level();
+      return constants_1.RtapiMsgLevelFromValue[nativeValue] ?? "none";
+    };
+    exports2.getMsgLevel = getMsgLevel2;
+    var setMsgLevel2 = (level) => {
+      constants_1.halNative.set_msg_level(constants_1.RtapiMsgLevelValue[level]);
+    };
+    exports2.setMsgLevel = setMsgLevel2;
+    var connect = (pinName, signalName) => {
+      return constants_1.halNative.connect(pinName, signalName);
+    };
+    exports2.connect = connect;
+    var disconnect = (pinName) => {
+      return constants_1.halNative.disconnect(pinName);
+    };
+    exports2.disconnect = disconnect;
+    var getValue2 = (name) => {
+      return constants_1.halNative.get_value(name);
+    };
+    exports2.getValue = getValue2;
+    var getInfoPins2 = () => {
+      const nativePins = constants_1.halNative.get_info_pins();
+      return nativePins.map((pin) => ({
+        ...pin,
+        type: constants_1.HalTypeFromValue[pin.type] ?? "bit",
+        direction: constants_1.HalPinDirFromValue[pin.direction] ?? "in"
+      }));
+    };
+    exports2.getInfoPins = getInfoPins2;
+    var getInfoSignals2 = () => {
+      const nativeSignals = constants_1.halNative.get_info_signals();
+      return nativeSignals.map((signal) => ({
+        ...signal,
+        type: constants_1.HalTypeFromValue[signal.type] ?? "bit"
+      }));
+    };
+    exports2.getInfoSignals = getInfoSignals2;
+    var getInfoParams2 = () => {
+      const nativeParams = constants_1.halNative.get_info_params();
+      return nativeParams.map((param) => ({
+        ...param,
+        type: constants_1.HalTypeFromValue[param.type] ?? "bit",
+        direction: constants_1.HalParamDirFromValue[param.direction] ?? "ro"
+      }));
+    };
+    exports2.getInfoParams = getInfoParams2;
+    var newSignal2 = (signalName, type) => {
+      return constants_1.halNative.new_sig(signalName, constants_1.HalTypeValue[type]);
+    };
+    exports2.newSignal = newSignal2;
+    var pinHasWriter2 = (pinName) => {
+      return constants_1.halNative.pin_has_writer(pinName);
+    };
+    exports2.pinHasWriter = pinHasWriter2;
+    var setPinParamValue = (name, value) => {
+      return constants_1.halNative.set_p(name, String(value));
+    };
+    exports2.setPinParamValue = setPinParamValue;
+    var setSignalValue2 = (name, value) => {
+      return constants_1.halNative.set_s(name, String(value));
+    };
+    exports2.setSignalValue = setSignalValue2;
+  }
+});
+
+// ../node_modules/.pnpm/@linuxcnc-node+hal@2.1.3/node_modules/@linuxcnc-node/hal/dist/index.js
+var require_dist5 = __commonJS({
+  "../node_modules/.pnpm/@linuxcnc-node+hal@2.1.3/node_modules/@linuxcnc-node/hal/dist/index.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.setSignalValue = exports2.setPinParamValue = exports2.pinHasWriter = exports2.newSignal = exports2.getInfoParams = exports2.getInfoSignals = exports2.getInfoPins = exports2.getValue = exports2.disconnect = exports2.connect = exports2.setMsgLevel = exports2.getMsgLevel = exports2.Param = exports2.Pin = exports2.HalItem = exports2.HalComponent = void 0;
+    var component_1 = require_component();
+    Object.defineProperty(exports2, "HalComponent", { enumerable: true, get: function() {
+      return component_1.HalComponent;
+    } });
+    var item_1 = require_item();
+    Object.defineProperty(exports2, "HalItem", { enumerable: true, get: function() {
+      return item_1.HalItem;
+    } });
+    Object.defineProperty(exports2, "Pin", { enumerable: true, get: function() {
+      return item_1.Pin;
+    } });
+    Object.defineProperty(exports2, "Param", { enumerable: true, get: function() {
+      return item_1.Param;
+    } });
+    var functions_1 = require_functions();
+    Object.defineProperty(exports2, "getMsgLevel", { enumerable: true, get: function() {
+      return functions_1.getMsgLevel;
+    } });
+    Object.defineProperty(exports2, "setMsgLevel", { enumerable: true, get: function() {
+      return functions_1.setMsgLevel;
+    } });
+    Object.defineProperty(exports2, "connect", { enumerable: true, get: function() {
+      return functions_1.connect;
+    } });
+    Object.defineProperty(exports2, "disconnect", { enumerable: true, get: function() {
+      return functions_1.disconnect;
+    } });
+    Object.defineProperty(exports2, "getValue", { enumerable: true, get: function() {
+      return functions_1.getValue;
+    } });
+    Object.defineProperty(exports2, "getInfoPins", { enumerable: true, get: function() {
+      return functions_1.getInfoPins;
+    } });
+    Object.defineProperty(exports2, "getInfoSignals", { enumerable: true, get: function() {
+      return functions_1.getInfoSignals;
+    } });
+    Object.defineProperty(exports2, "getInfoParams", { enumerable: true, get: function() {
+      return functions_1.getInfoParams;
+    } });
+    Object.defineProperty(exports2, "newSignal", { enumerable: true, get: function() {
+      return functions_1.newSignal;
+    } });
+    Object.defineProperty(exports2, "pinHasWriter", { enumerable: true, get: function() {
+      return functions_1.pinHasWriter;
+    } });
+    Object.defineProperty(exports2, "setPinParamValue", { enumerable: true, get: function() {
+      return functions_1.setPinParamValue;
+    } });
+    Object.defineProperty(exports2, "setSignalValue", { enumerable: true, get: function() {
+      return functions_1.setSignalValue;
+    } });
+  }
+});
+
+// ../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/constants.js
+var require_constants4 = __commonJS({
+  "../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/constants.js"(exports2, module2) {
+    "use strict";
+    var WIN_SLASH = "\\\\/";
+    var WIN_NO_SLASH = `[^${WIN_SLASH}]`;
+    var DOT_LITERAL = "\\.";
+    var PLUS_LITERAL = "\\+";
+    var QMARK_LITERAL = "\\?";
+    var SLASH_LITERAL = "\\/";
+    var ONE_CHAR = "(?=.)";
+    var QMARK = "[^/]";
+    var END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;
+    var START_ANCHOR = `(?:^|${SLASH_LITERAL})`;
+    var DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
+    var NO_DOT = `(?!${DOT_LITERAL})`;
+    var NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`;
+    var NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`;
+    var NO_DOTS_SLASH = `(?!${DOTS_SLASH})`;
+    var QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`;
+    var STAR = `${QMARK}*?`;
+    var SEP = "/";
+    var POSIX_CHARS = {
+      DOT_LITERAL,
+      PLUS_LITERAL,
+      QMARK_LITERAL,
+      SLASH_LITERAL,
+      ONE_CHAR,
+      QMARK,
+      END_ANCHOR,
+      DOTS_SLASH,
+      NO_DOT,
+      NO_DOTS,
+      NO_DOT_SLASH,
+      NO_DOTS_SLASH,
+      QMARK_NO_DOT,
+      STAR,
+      START_ANCHOR,
+      SEP
+    };
+    var WINDOWS_CHARS = {
+      ...POSIX_CHARS,
+      SLASH_LITERAL: `[${WIN_SLASH}]`,
+      QMARK: WIN_NO_SLASH,
+      STAR: `${WIN_NO_SLASH}*?`,
+      DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`,
+      NO_DOT: `(?!${DOT_LITERAL})`,
+      NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+      NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`,
+      NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+      QMARK_NO_DOT: `[^.${WIN_SLASH}]`,
+      START_ANCHOR: `(?:^|[${WIN_SLASH}])`,
+      END_ANCHOR: `(?:[${WIN_SLASH}]|$)`,
+      SEP: "\\"
+    };
+    var POSIX_REGEX_SOURCE = {
+      alnum: "a-zA-Z0-9",
+      alpha: "a-zA-Z",
+      ascii: "\\x00-\\x7F",
+      blank: " \\t",
+      cntrl: "\\x00-\\x1F\\x7F",
+      digit: "0-9",
+      graph: "\\x21-\\x7E",
+      lower: "a-z",
+      print: "\\x20-\\x7E ",
+      punct: "\\-!\"#$%&'()\\*+,./:;<=>?@[\\]^_`{|}~",
+      space: " \\t\\r\\n\\v\\f",
+      upper: "A-Z",
+      word: "A-Za-z0-9_",
+      xdigit: "A-Fa-f0-9"
+    };
+    module2.exports = {
+      MAX_LENGTH: 1024 * 64,
+      POSIX_REGEX_SOURCE,
+      // regular expressions
+      REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
+      REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
+      REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
+      REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
+      REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
+      REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
+      // Replace globs with equivalent patterns to reduce parsing time.
+      REPLACEMENTS: {
+        __proto__: null,
+        "***": "*",
+        "**/**": "**",
+        "**/**/**": "**"
+      },
+      // Digits
+      CHAR_0: 48,
+      /* 0 */
+      CHAR_9: 57,
+      /* 9 */
+      // Alphabet chars.
+      CHAR_UPPERCASE_A: 65,
+      /* A */
+      CHAR_LOWERCASE_A: 97,
+      /* a */
+      CHAR_UPPERCASE_Z: 90,
+      /* Z */
+      CHAR_LOWERCASE_Z: 122,
+      /* z */
+      CHAR_LEFT_PARENTHESES: 40,
+      /* ( */
+      CHAR_RIGHT_PARENTHESES: 41,
+      /* ) */
+      CHAR_ASTERISK: 42,
+      /* * */
+      // Non-alphabetic chars.
+      CHAR_AMPERSAND: 38,
+      /* & */
+      CHAR_AT: 64,
+      /* @ */
+      CHAR_BACKWARD_SLASH: 92,
+      /* \ */
+      CHAR_CARRIAGE_RETURN: 13,
+      /* \r */
+      CHAR_CIRCUMFLEX_ACCENT: 94,
+      /* ^ */
+      CHAR_COLON: 58,
+      /* : */
+      CHAR_COMMA: 44,
+      /* , */
+      CHAR_DOT: 46,
+      /* . */
+      CHAR_DOUBLE_QUOTE: 34,
+      /* " */
+      CHAR_EQUAL: 61,
+      /* = */
+      CHAR_EXCLAMATION_MARK: 33,
+      /* ! */
+      CHAR_FORM_FEED: 12,
+      /* \f */
+      CHAR_FORWARD_SLASH: 47,
+      /* / */
+      CHAR_GRAVE_ACCENT: 96,
+      /* ` */
+      CHAR_HASH: 35,
+      /* # */
+      CHAR_HYPHEN_MINUS: 45,
+      /* - */
+      CHAR_LEFT_ANGLE_BRACKET: 60,
+      /* < */
+      CHAR_LEFT_CURLY_BRACE: 123,
+      /* { */
+      CHAR_LEFT_SQUARE_BRACKET: 91,
+      /* [ */
+      CHAR_LINE_FEED: 10,
+      /* \n */
+      CHAR_NO_BREAK_SPACE: 160,
+      /* \u00A0 */
+      CHAR_PERCENT: 37,
+      /* % */
+      CHAR_PLUS: 43,
+      /* + */
+      CHAR_QUESTION_MARK: 63,
+      /* ? */
+      CHAR_RIGHT_ANGLE_BRACKET: 62,
+      /* > */
+      CHAR_RIGHT_CURLY_BRACE: 125,
+      /* } */
+      CHAR_RIGHT_SQUARE_BRACKET: 93,
+      /* ] */
+      CHAR_SEMICOLON: 59,
+      /* ; */
+      CHAR_SINGLE_QUOTE: 39,
+      /* ' */
+      CHAR_SPACE: 32,
+      /*   */
+      CHAR_TAB: 9,
+      /* \t */
+      CHAR_UNDERSCORE: 95,
+      /* _ */
+      CHAR_VERTICAL_LINE: 124,
+      /* | */
+      CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,
+      /* \uFEFF */
+      /**
+       * Create EXTGLOB_CHARS
+       */
+      extglobChars(chars) {
+        return {
+          "!": { type: "negate", open: "(?:(?!(?:", close: `))${chars.STAR})` },
+          "?": { type: "qmark", open: "(?:", close: ")?" },
+          "+": { type: "plus", open: "(?:", close: ")+" },
+          "*": { type: "star", open: "(?:", close: ")*" },
+          "@": { type: "at", open: "(?:", close: ")" }
+        };
+      },
+      /**
+       * Create GLOB_CHARS
+       */
+      globChars(win32) {
+        return win32 === true ? WINDOWS_CHARS : POSIX_CHARS;
+      }
+    };
+  }
+});
+
+// ../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/utils.js
+var require_utils = __commonJS({
+  "../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/utils.js"(exports2) {
+    "use strict";
+    var {
+      REGEX_BACKSLASH,
+      REGEX_REMOVE_BACKSLASH,
+      REGEX_SPECIAL_CHARS,
+      REGEX_SPECIAL_CHARS_GLOBAL
+    } = require_constants4();
+    exports2.isObject = (val) => val !== null && typeof val === "object" && !Array.isArray(val);
+    exports2.hasRegexChars = (str) => REGEX_SPECIAL_CHARS.test(str);
+    exports2.isRegexChar = (str) => str.length === 1 && exports2.hasRegexChars(str);
+    exports2.escapeRegex = (str) => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, "\\$1");
+    exports2.toPosixSlashes = (str) => str.replace(REGEX_BACKSLASH, "/");
+    exports2.isWindows = () => {
+      if (typeof navigator !== "undefined" && navigator.platform) {
+        const platform = navigator.platform.toLowerCase();
+        return platform === "win32" || platform === "windows";
+      }
+      if (typeof process !== "undefined" && process.platform) {
+        return process.platform === "win32";
+      }
+      return false;
+    };
+    exports2.removeBackslashes = (str) => {
+      return str.replace(REGEX_REMOVE_BACKSLASH, (match) => {
+        return match === "\\" ? "" : match;
+      });
+    };
+    exports2.escapeLast = (input, char, lastIdx) => {
+      const idx = input.lastIndexOf(char, lastIdx);
+      if (idx === -1) return input;
+      if (input[idx - 1] === "\\") return exports2.escapeLast(input, char, idx - 1);
+      return `${input.slice(0, idx)}\\${input.slice(idx)}`;
+    };
+    exports2.removePrefix = (input, state = {}) => {
+      let output = input;
+      if (output.startsWith("./")) {
+        output = output.slice(2);
+        state.prefix = "./";
+      }
+      return output;
+    };
+    exports2.wrapOutput = (input, state = {}, options = {}) => {
+      const prepend = options.contains ? "" : "^";
+      const append = options.contains ? "" : "$";
+      let output = `${prepend}(?:${input})${append}`;
+      if (state.negated === true) {
+        output = `(?:^(?!${output}).*$)`;
+      }
+      return output;
+    };
+    exports2.basename = (path, { windows } = {}) => {
+      const segs = path.split(windows ? /[\\/]/ : "/");
+      const last = segs[segs.length - 1];
+      if (last === "") {
+        return segs[segs.length - 2];
+      }
+      return last;
+    };
+  }
+});
+
+// ../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/scan.js
+var require_scan = __commonJS({
+  "../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/scan.js"(exports2, module2) {
+    "use strict";
+    var utils = require_utils();
+    var {
+      CHAR_ASTERISK,
+      /* * */
+      CHAR_AT,
+      /* @ */
+      CHAR_BACKWARD_SLASH,
+      /* \ */
+      CHAR_COMMA,
+      /* , */
+      CHAR_DOT,
+      /* . */
+      CHAR_EXCLAMATION_MARK,
+      /* ! */
+      CHAR_FORWARD_SLASH,
+      /* / */
+      CHAR_LEFT_CURLY_BRACE,
+      /* { */
+      CHAR_LEFT_PARENTHESES,
+      /* ( */
+      CHAR_LEFT_SQUARE_BRACKET,
+      /* [ */
+      CHAR_PLUS,
+      /* + */
+      CHAR_QUESTION_MARK,
+      /* ? */
+      CHAR_RIGHT_CURLY_BRACE,
+      /* } */
+      CHAR_RIGHT_PARENTHESES,
+      /* ) */
+      CHAR_RIGHT_SQUARE_BRACKET
+      /* ] */
+    } = require_constants4();
+    var isPathSeparator = (code) => {
+      return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
+    };
+    var depth = (token) => {
+      if (token.isPrefix !== true) {
+        token.depth = token.isGlobstar ? Infinity : 1;
+      }
+    };
+    var scan = (input, options) => {
+      const opts = options || {};
+      const length = input.length - 1;
+      const scanToEnd = opts.parts === true || opts.scanToEnd === true;
+      const slashes = [];
+      const tokens = [];
+      const parts = [];
+      let str = input;
+      let index = -1;
+      let start = 0;
+      let lastIndex = 0;
+      let isBrace = false;
+      let isBracket = false;
+      let isGlob = false;
+      let isExtglob = false;
+      let isGlobstar = false;
+      let braceEscaped = false;
+      let backslashes = false;
+      let negated = false;
+      let negatedExtglob = false;
+      let finished = false;
+      let braces = 0;
+      let prev;
+      let code;
+      let token = { value: "", depth: 0, isGlob: false };
+      const eos = () => index >= length;
+      const peek = () => str.charCodeAt(index + 1);
+      const advance = () => {
+        prev = code;
+        return str.charCodeAt(++index);
+      };
+      while (index < length) {
+        code = advance();
+        let next;
+        if (code === CHAR_BACKWARD_SLASH) {
+          backslashes = token.backslashes = true;
+          code = advance();
+          if (code === CHAR_LEFT_CURLY_BRACE) {
+            braceEscaped = true;
+          }
+          continue;
+        }
+        if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE) {
+          braces++;
+          while (eos() !== true && (code = advance())) {
+            if (code === CHAR_BACKWARD_SLASH) {
+              backslashes = token.backslashes = true;
+              advance();
+              continue;
+            }
+            if (code === CHAR_LEFT_CURLY_BRACE) {
+              braces++;
+              continue;
+            }
+            if (braceEscaped !== true && code === CHAR_DOT && (code = advance()) === CHAR_DOT) {
+              isBrace = token.isBrace = true;
+              isGlob = token.isGlob = true;
+              finished = true;
+              if (scanToEnd === true) {
+                continue;
+              }
+              break;
+            }
+            if (braceEscaped !== true && code === CHAR_COMMA) {
+              isBrace = token.isBrace = true;
+              isGlob = token.isGlob = true;
+              finished = true;
+              if (scanToEnd === true) {
+                continue;
+              }
+              break;
+            }
+            if (code === CHAR_RIGHT_CURLY_BRACE) {
+              braces--;
+              if (braces === 0) {
+                braceEscaped = false;
+                isBrace = token.isBrace = true;
+                finished = true;
+                break;
+              }
+            }
+          }
+          if (scanToEnd === true) {
+            continue;
+          }
+          break;
+        }
+        if (code === CHAR_FORWARD_SLASH) {
+          slashes.push(index);
+          tokens.push(token);
+          token = { value: "", depth: 0, isGlob: false };
+          if (finished === true) continue;
+          if (prev === CHAR_DOT && index === start + 1) {
+            start += 2;
+            continue;
+          }
+          lastIndex = index + 1;
+          continue;
+        }
+        if (opts.noext !== true) {
+          const isExtglobChar = code === CHAR_PLUS || code === CHAR_AT || code === CHAR_ASTERISK || code === CHAR_QUESTION_MARK || code === CHAR_EXCLAMATION_MARK;
+          if (isExtglobChar === true && peek() === CHAR_LEFT_PARENTHESES) {
+            isGlob = token.isGlob = true;
+            isExtglob = token.isExtglob = true;
+            finished = true;
+            if (code === CHAR_EXCLAMATION_MARK && index === start) {
+              negatedExtglob = true;
+            }
+            if (scanToEnd === true) {
+              while (eos() !== true && (code = advance())) {
+                if (code === CHAR_BACKWARD_SLASH) {
+                  backslashes = token.backslashes = true;
+                  code = advance();
+                  continue;
+                }
+                if (code === CHAR_RIGHT_PARENTHESES) {
+                  isGlob = token.isGlob = true;
+                  finished = true;
+                  break;
+                }
+              }
+              continue;
+            }
+            break;
+          }
+        }
+        if (code === CHAR_ASTERISK) {
+          if (prev === CHAR_ASTERISK) isGlobstar = token.isGlobstar = true;
+          isGlob = token.isGlob = true;
+          finished = true;
+          if (scanToEnd === true) {
+            continue;
+          }
+          break;
+        }
+        if (code === CHAR_QUESTION_MARK) {
+          isGlob = token.isGlob = true;
+          finished = true;
+          if (scanToEnd === true) {
+            continue;
+          }
+          break;
+        }
+        if (code === CHAR_LEFT_SQUARE_BRACKET) {
+          while (eos() !== true && (next = advance())) {
+            if (next === CHAR_BACKWARD_SLASH) {
+              backslashes = token.backslashes = true;
+              advance();
+              continue;
+            }
+            if (next === CHAR_RIGHT_SQUARE_BRACKET) {
+              isBracket = token.isBracket = true;
+              isGlob = token.isGlob = true;
+              finished = true;
+              break;
+            }
+          }
+          if (scanToEnd === true) {
+            continue;
+          }
+          break;
+        }
+        if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) {
+          negated = token.negated = true;
+          start++;
+          continue;
+        }
+        if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES) {
+          isGlob = token.isGlob = true;
+          if (scanToEnd === true) {
+            while (eos() !== true && (code = advance())) {
+              if (code === CHAR_LEFT_PARENTHESES) {
+                backslashes = token.backslashes = true;
+                code = advance();
+                continue;
+              }
+              if (code === CHAR_RIGHT_PARENTHESES) {
+                finished = true;
+                break;
+              }
+            }
+            continue;
+          }
+          break;
+        }
+        if (isGlob === true) {
+          finished = true;
+          if (scanToEnd === true) {
+            continue;
+          }
+          break;
+        }
+      }
+      if (opts.noext === true) {
+        isExtglob = false;
+        isGlob = false;
+      }
+      let base = str;
+      let prefix = "";
+      let glob = "";
+      if (start > 0) {
+        prefix = str.slice(0, start);
+        str = str.slice(start);
+        lastIndex -= start;
+      }
+      if (base && isGlob === true && lastIndex > 0) {
+        base = str.slice(0, lastIndex);
+        glob = str.slice(lastIndex);
+      } else if (isGlob === true) {
+        base = "";
+        glob = str;
+      } else {
+        base = str;
+      }
+      if (base && base !== "" && base !== "/" && base !== str) {
+        if (isPathSeparator(base.charCodeAt(base.length - 1))) {
+          base = base.slice(0, -1);
+        }
+      }
+      if (opts.unescape === true) {
+        if (glob) glob = utils.removeBackslashes(glob);
+        if (base && backslashes === true) {
+          base = utils.removeBackslashes(base);
+        }
+      }
+      const state = {
+        prefix,
+        input,
+        start,
+        base,
+        glob,
+        isBrace,
+        isBracket,
+        isGlob,
+        isExtglob,
+        isGlobstar,
+        negated,
+        negatedExtglob
+      };
+      if (opts.tokens === true) {
+        state.maxDepth = 0;
+        if (!isPathSeparator(code)) {
+          tokens.push(token);
+        }
+        state.tokens = tokens;
+      }
+      if (opts.parts === true || opts.tokens === true) {
+        let prevIndex;
+        for (let idx = 0; idx < slashes.length; idx++) {
+          const n = prevIndex ? prevIndex + 1 : start;
+          const i = slashes[idx];
+          const value = input.slice(n, i);
+          if (opts.tokens) {
+            if (idx === 0 && start !== 0) {
+              tokens[idx].isPrefix = true;
+              tokens[idx].value = prefix;
+            } else {
+              tokens[idx].value = value;
+            }
+            depth(tokens[idx]);
+            state.maxDepth += tokens[idx].depth;
+          }
+          if (idx !== 0 || value !== "") {
+            parts.push(value);
+          }
+          prevIndex = i;
+        }
+        if (prevIndex && prevIndex + 1 < input.length) {
+          const value = input.slice(prevIndex + 1);
+          parts.push(value);
+          if (opts.tokens) {
+            tokens[tokens.length - 1].value = value;
+            depth(tokens[tokens.length - 1]);
+            state.maxDepth += tokens[tokens.length - 1].depth;
+          }
+        }
+        state.slashes = slashes;
+        state.parts = parts;
+      }
+      return state;
+    };
+    module2.exports = scan;
+  }
+});
+
+// ../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/parse.js
+var require_parse = __commonJS({
+  "../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/parse.js"(exports2, module2) {
+    "use strict";
+    var constants = require_constants4();
+    var utils = require_utils();
+    var {
+      MAX_LENGTH,
+      POSIX_REGEX_SOURCE,
+      REGEX_NON_SPECIAL_CHARS,
+      REGEX_SPECIAL_CHARS_BACKREF,
+      REPLACEMENTS
+    } = constants;
+    var expandRange = (args, options) => {
+      if (typeof options.expandRange === "function") {
+        return options.expandRange(...args, options);
+      }
+      args.sort();
+      const value = `[${args.join("-")}]`;
+      try {
+        new RegExp(value);
+      } catch (ex) {
+        return args.map((v) => utils.escapeRegex(v)).join("..");
+      }
+      return value;
+    };
+    var syntaxError = (type, char) => {
+      return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
+    };
+    var parse = (input, options) => {
+      if (typeof input !== "string") {
+        throw new TypeError("Expected a string");
+      }
+      input = REPLACEMENTS[input] || input;
+      const opts = { ...options };
+      const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+      let len = input.length;
+      if (len > max) {
+        throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+      }
+      const bos = { type: "bos", value: "", output: opts.prepend || "" };
+      const tokens = [bos];
+      const capture = opts.capture ? "" : "?:";
+      const PLATFORM_CHARS = constants.globChars(opts.windows);
+      const EXTGLOB_CHARS = constants.extglobChars(PLATFORM_CHARS);
+      const {
+        DOT_LITERAL,
+        PLUS_LITERAL,
+        SLASH_LITERAL,
+        ONE_CHAR,
+        DOTS_SLASH,
+        NO_DOT,
+        NO_DOT_SLASH,
+        NO_DOTS_SLASH,
+        QMARK,
+        QMARK_NO_DOT,
+        STAR,
+        START_ANCHOR
+      } = PLATFORM_CHARS;
+      const globstar = (opts2) => {
+        return `(${capture}(?:(?!${START_ANCHOR}${opts2.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+      };
+      const nodot = opts.dot ? "" : NO_DOT;
+      const qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT;
+      let star = opts.bash === true ? globstar(opts) : STAR;
+      if (opts.capture) {
+        star = `(${star})`;
+      }
+      if (typeof opts.noext === "boolean") {
+        opts.noextglob = opts.noext;
+      }
+      const state = {
+        input,
+        index: -1,
+        start: 0,
+        dot: opts.dot === true,
+        consumed: "",
+        output: "",
+        prefix: "",
+        backtrack: false,
+        negated: false,
+        brackets: 0,
+        braces: 0,
+        parens: 0,
+        quotes: 0,
+        globstar: false,
+        tokens
+      };
+      input = utils.removePrefix(input, state);
+      len = input.length;
+      const extglobs = [];
+      const braces = [];
+      const stack = [];
+      let prev = bos;
+      let value;
+      const eos = () => state.index === len - 1;
+      const peek = state.peek = (n = 1) => input[state.index + n];
+      const advance = state.advance = () => input[++state.index] || "";
+      const remaining = () => input.slice(state.index + 1);
+      const consume = (value2 = "", num = 0) => {
+        state.consumed += value2;
+        state.index += num;
+      };
+      const append = (token) => {
+        state.output += token.output != null ? token.output : token.value;
+        consume(token.value);
+      };
+      const negate = () => {
+        let count = 1;
+        while (peek() === "!" && (peek(2) !== "(" || peek(3) === "?")) {
+          advance();
+          state.start++;
+          count++;
+        }
+        if (count % 2 === 0) {
+          return false;
+        }
+        state.negated = true;
+        state.start++;
+        return true;
+      };
+      const increment = (type) => {
+        state[type]++;
+        stack.push(type);
+      };
+      const decrement = (type) => {
+        state[type]--;
+        stack.pop();
+      };
+      const push = (tok) => {
+        if (prev.type === "globstar") {
+          const isBrace = state.braces > 0 && (tok.type === "comma" || tok.type === "brace");
+          const isExtglob = tok.extglob === true || extglobs.length && (tok.type === "pipe" || tok.type === "paren");
+          if (tok.type !== "slash" && tok.type !== "paren" && !isBrace && !isExtglob) {
+            state.output = state.output.slice(0, -prev.output.length);
+            prev.type = "star";
+            prev.value = "*";
+            prev.output = star;
+            state.output += prev.output;
+          }
+        }
+        if (extglobs.length && tok.type !== "paren") {
+          extglobs[extglobs.length - 1].inner += tok.value;
+        }
+        if (tok.value || tok.output) append(tok);
+        if (prev && prev.type === "text" && tok.type === "text") {
+          prev.output = (prev.output || prev.value) + tok.value;
+          prev.value += tok.value;
+          return;
+        }
+        tok.prev = prev;
+        tokens.push(tok);
+        prev = tok;
+      };
+      const extglobOpen = (type, value2) => {
+        const token = { ...EXTGLOB_CHARS[value2], conditions: 1, inner: "" };
+        token.prev = prev;
+        token.parens = state.parens;
+        token.output = state.output;
+        const output = (opts.capture ? "(" : "") + token.open;
+        increment("parens");
+        push({ type, value: value2, output: state.output ? "" : ONE_CHAR });
+        push({ type: "paren", extglob: true, value: advance(), output });
+        extglobs.push(token);
+      };
+      const extglobClose = (token) => {
+        let output = token.close + (opts.capture ? ")" : "");
+        let rest;
+        if (token.type === "negate") {
+          let extglobStar = star;
+          if (token.inner && token.inner.length > 1 && token.inner.includes("/")) {
+            extglobStar = globstar(opts);
+          }
+          if (extglobStar !== star || eos() || /^\)+$/.test(remaining())) {
+            output = token.close = `)$))${extglobStar}`;
+          }
+          if (token.inner.includes("*") && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
+            const expression = parse(rest, { ...options, fastpaths: false }).output;
+            output = token.close = `)${expression})${extglobStar})`;
+          }
+          if (token.prev.type === "bos") {
+            state.negatedExtglob = true;
+          }
+        }
+        push({ type: "paren", extglob: true, value, output });
+        decrement("parens");
+      };
+      if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) {
+        let backslashes = false;
+        let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => {
+          if (first === "\\") {
+            backslashes = true;
+            return m;
+          }
+          if (first === "?") {
+            if (esc) {
+              return esc + first + (rest ? QMARK.repeat(rest.length) : "");
+            }
+            if (index === 0) {
+              return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : "");
+            }
+            return QMARK.repeat(chars.length);
+          }
+          if (first === ".") {
+            return DOT_LITERAL.repeat(chars.length);
+          }
+          if (first === "*") {
+            if (esc) {
+              return esc + first + (rest ? star : "");
+            }
+            return star;
+          }
+          return esc ? m : `\\${m}`;
+        });
+        if (backslashes === true) {
+          if (opts.unescape === true) {
+            output = output.replace(/\\/g, "");
+          } else {
+            output = output.replace(/\\+/g, (m) => {
+              return m.length % 2 === 0 ? "\\\\" : m ? "\\" : "";
+            });
+          }
+        }
+        if (output === input && opts.contains === true) {
+          state.output = input;
+          return state;
+        }
+        state.output = utils.wrapOutput(output, state, options);
+        return state;
+      }
+      while (!eos()) {
+        value = advance();
+        if (value === "\0") {
+          continue;
+        }
+        if (value === "\\") {
+          const next = peek();
+          if (next === "/" && opts.bash !== true) {
+            continue;
+          }
+          if (next === "." || next === ";") {
+            continue;
+          }
+          if (!next) {
+            value += "\\";
+            push({ type: "text", value });
+            continue;
+          }
+          const match = /^\\+/.exec(remaining());
+          let slashes = 0;
+          if (match && match[0].length > 2) {
+            slashes = match[0].length;
+            state.index += slashes;
+            if (slashes % 2 !== 0) {
+              value += "\\";
+            }
+          }
+          if (opts.unescape === true) {
+            value = advance();
+          } else {
+            value += advance();
+          }
+          if (state.brackets === 0) {
+            push({ type: "text", value });
+            continue;
+          }
+        }
+        if (state.brackets > 0 && (value !== "]" || prev.value === "[" || prev.value === "[^")) {
+          if (opts.posix !== false && value === ":") {
+            const inner = prev.value.slice(1);
+            if (inner.includes("[")) {
+              prev.posix = true;
+              if (inner.includes(":")) {
+                const idx = prev.value.lastIndexOf("[");
+                const pre = prev.value.slice(0, idx);
+                const rest2 = prev.value.slice(idx + 2);
+                const posix = POSIX_REGEX_SOURCE[rest2];
+                if (posix) {
+                  prev.value = pre + posix;
+                  state.backtrack = true;
+                  advance();
+                  if (!bos.output && tokens.indexOf(prev) === 1) {
+                    bos.output = ONE_CHAR;
+                  }
+                  continue;
+                }
+              }
+            }
+          }
+          if (value === "[" && peek() !== ":" || value === "-" && peek() === "]") {
+            value = `\\${value}`;
+          }
+          if (value === "]" && (prev.value === "[" || prev.value === "[^")) {
+            value = `\\${value}`;
+          }
+          if (opts.posix === true && value === "!" && prev.value === "[") {
+            value = "^";
+          }
+          prev.value += value;
+          append({ value });
+          continue;
+        }
+        if (state.quotes === 1 && value !== '"') {
+          value = utils.escapeRegex(value);
+          prev.value += value;
+          append({ value });
+          continue;
+        }
+        if (value === '"') {
+          state.quotes = state.quotes === 1 ? 0 : 1;
+          if (opts.keepQuotes === true) {
+            push({ type: "text", value });
+          }
+          continue;
+        }
+        if (value === "(") {
+          increment("parens");
+          push({ type: "paren", value });
+          continue;
+        }
+        if (value === ")") {
+          if (state.parens === 0 && opts.strictBrackets === true) {
+            throw new SyntaxError(syntaxError("opening", "("));
+          }
+          const extglob = extglobs[extglobs.length - 1];
+          if (extglob && state.parens === extglob.parens + 1) {
+            extglobClose(extglobs.pop());
+            continue;
+          }
+          push({ type: "paren", value, output: state.parens ? ")" : "\\)" });
+          decrement("parens");
+          continue;
+        }
+        if (value === "[") {
+          if (opts.nobracket === true || !remaining().includes("]")) {
+            if (opts.nobracket !== true && opts.strictBrackets === true) {
+              throw new SyntaxError(syntaxError("closing", "]"));
+            }
+            value = `\\${value}`;
+          } else {
+            increment("brackets");
+          }
+          push({ type: "bracket", value });
+          continue;
+        }
+        if (value === "]") {
+          if (opts.nobracket === true || prev && prev.type === "bracket" && prev.value.length === 1) {
+            push({ type: "text", value, output: `\\${value}` });
+            continue;
+          }
+          if (state.brackets === 0) {
+            if (opts.strictBrackets === true) {
+              throw new SyntaxError(syntaxError("opening", "["));
+            }
+            push({ type: "text", value, output: `\\${value}` });
+            continue;
+          }
+          decrement("brackets");
+          const prevValue = prev.value.slice(1);
+          if (prev.posix !== true && prevValue[0] === "^" && !prevValue.includes("/")) {
+            value = `/${value}`;
+          }
+          prev.value += value;
+          append({ value });
+          if (opts.literalBrackets === false || utils.hasRegexChars(prevValue)) {
+            continue;
+          }
+          const escaped = utils.escapeRegex(prev.value);
+          state.output = state.output.slice(0, -prev.value.length);
+          if (opts.literalBrackets === true) {
+            state.output += escaped;
+            prev.value = escaped;
+            continue;
+          }
+          prev.value = `(${capture}${escaped}|${prev.value})`;
+          state.output += prev.value;
+          continue;
+        }
+        if (value === "{" && opts.nobrace !== true) {
+          increment("braces");
+          const open = {
+            type: "brace",
+            value,
+            output: "(",
+            outputIndex: state.output.length,
+            tokensIndex: state.tokens.length
+          };
+          braces.push(open);
+          push(open);
+          continue;
+        }
+        if (value === "}") {
+          const brace = braces[braces.length - 1];
+          if (opts.nobrace === true || !brace) {
+            push({ type: "text", value, output: value });
+            continue;
+          }
+          let output = ")";
+          if (brace.dots === true) {
+            const arr = tokens.slice();
+            const range = [];
+            for (let i = arr.length - 1; i >= 0; i--) {
+              tokens.pop();
+              if (arr[i].type === "brace") {
+                break;
+              }
+              if (arr[i].type !== "dots") {
+                range.unshift(arr[i].value);
+              }
+            }
+            output = expandRange(range, opts);
+            state.backtrack = true;
+          }
+          if (brace.comma !== true && brace.dots !== true) {
+            const out = state.output.slice(0, brace.outputIndex);
+            const toks = state.tokens.slice(brace.tokensIndex);
+            brace.value = brace.output = "\\{";
+            value = output = "\\}";
+            state.output = out;
+            for (const t of toks) {
+              state.output += t.output || t.value;
+            }
+          }
+          push({ type: "brace", value, output });
+          decrement("braces");
+          braces.pop();
+          continue;
+        }
+        if (value === "|") {
+          if (extglobs.length > 0) {
+            extglobs[extglobs.length - 1].conditions++;
+          }
+          push({ type: "text", value });
+          continue;
+        }
+        if (value === ",") {
+          let output = value;
+          const brace = braces[braces.length - 1];
+          if (brace && stack[stack.length - 1] === "braces") {
+            brace.comma = true;
+            output = "|";
+          }
+          push({ type: "comma", value, output });
+          continue;
+        }
+        if (value === "/") {
+          if (prev.type === "dot" && state.index === state.start + 1) {
+            state.start = state.index + 1;
+            state.consumed = "";
+            state.output = "";
+            tokens.pop();
+            prev = bos;
+            continue;
+          }
+          push({ type: "slash", value, output: SLASH_LITERAL });
+          continue;
+        }
+        if (value === ".") {
+          if (state.braces > 0 && prev.type === "dot") {
+            if (prev.value === ".") prev.output = DOT_LITERAL;
+            const brace = braces[braces.length - 1];
+            prev.type = "dots";
+            prev.output += value;
+            prev.value += value;
+            brace.dots = true;
+            continue;
+          }
+          if (state.braces + state.parens === 0 && prev.type !== "bos" && prev.type !== "slash") {
+            push({ type: "text", value, output: DOT_LITERAL });
+            continue;
+          }
+          push({ type: "dot", value, output: DOT_LITERAL });
+          continue;
+        }
+        if (value === "?") {
+          const isGroup = prev && prev.value === "(";
+          if (!isGroup && opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+            extglobOpen("qmark", value);
+            continue;
+          }
+          if (prev && prev.type === "paren") {
+            const next = peek();
+            let output = value;
+            if (prev.value === "(" && !/[!=<:]/.test(next) || next === "<" && !/<([!=]|\w+>)/.test(remaining())) {
+              output = `\\${value}`;
+            }
+            push({ type: "text", value, output });
+            continue;
+          }
+          if (opts.dot !== true && (prev.type === "slash" || prev.type === "bos")) {
+            push({ type: "qmark", value, output: QMARK_NO_DOT });
+            continue;
+          }
+          push({ type: "qmark", value, output: QMARK });
+          continue;
+        }
+        if (value === "!") {
+          if (opts.noextglob !== true && peek() === "(") {
+            if (peek(2) !== "?" || !/[!=<:]/.test(peek(3))) {
+              extglobOpen("negate", value);
+              continue;
+            }
+          }
+          if (opts.nonegate !== true && state.index === 0) {
+            negate();
+            continue;
+          }
+        }
+        if (value === "+") {
+          if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+            extglobOpen("plus", value);
+            continue;
+          }
+          if (prev && prev.value === "(" || opts.regex === false) {
+            push({ type: "plus", value, output: PLUS_LITERAL });
+            continue;
+          }
+          if (prev && (prev.type === "bracket" || prev.type === "paren" || prev.type === "brace") || state.parens > 0) {
+            push({ type: "plus", value });
+            continue;
+          }
+          push({ type: "plus", value: PLUS_LITERAL });
+          continue;
+        }
+        if (value === "@") {
+          if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+            push({ type: "at", extglob: true, value, output: "" });
+            continue;
+          }
+          push({ type: "text", value });
+          continue;
+        }
+        if (value !== "*") {
+          if (value === "$" || value === "^") {
+            value = `\\${value}`;
+          }
+          const match = REGEX_NON_SPECIAL_CHARS.exec(remaining());
+          if (match) {
+            value += match[0];
+            state.index += match[0].length;
+          }
+          push({ type: "text", value });
+          continue;
+        }
+        if (prev && (prev.type === "globstar" || prev.star === true)) {
+          prev.type = "star";
+          prev.star = true;
+          prev.value += value;
+          prev.output = star;
+          state.backtrack = true;
+          state.globstar = true;
+          consume(value);
+          continue;
+        }
+        let rest = remaining();
+        if (opts.noextglob !== true && /^\([^?]/.test(rest)) {
+          extglobOpen("star", value);
+          continue;
+        }
+        if (prev.type === "star") {
+          if (opts.noglobstar === true) {
+            consume(value);
+            continue;
+          }
+          const prior = prev.prev;
+          const before = prior.prev;
+          const isStart = prior.type === "slash" || prior.type === "bos";
+          const afterStar = before && (before.type === "star" || before.type === "globstar");
+          if (opts.bash === true && (!isStart || rest[0] && rest[0] !== "/")) {
+            push({ type: "star", value, output: "" });
+            continue;
+          }
+          const isBrace = state.braces > 0 && (prior.type === "comma" || prior.type === "brace");
+          const isExtglob = extglobs.length && (prior.type === "pipe" || prior.type === "paren");
+          if (!isStart && prior.type !== "paren" && !isBrace && !isExtglob) {
+            push({ type: "star", value, output: "" });
+            continue;
+          }
+          while (rest.slice(0, 3) === "/**") {
+            const after = input[state.index + 4];
+            if (after && after !== "/") {
+              break;
+            }
+            rest = rest.slice(3);
+            consume("/**", 3);
+          }
+          if (prior.type === "bos" && eos()) {
+            prev.type = "globstar";
+            prev.value += value;
+            prev.output = globstar(opts);
+            state.output = prev.output;
+            state.globstar = true;
+            consume(value);
+            continue;
+          }
+          if (prior.type === "slash" && prior.prev.type !== "bos" && !afterStar && eos()) {
+            state.output = state.output.slice(0, -(prior.output + prev.output).length);
+            prior.output = `(?:${prior.output}`;
+            prev.type = "globstar";
+            prev.output = globstar(opts) + (opts.strictSlashes ? ")" : "|$)");
+            prev.value += value;
+            state.globstar = true;
+            state.output += prior.output + prev.output;
+            consume(value);
+            continue;
+          }
+          if (prior.type === "slash" && prior.prev.type !== "bos" && rest[0] === "/") {
+            const end = rest[1] !== void 0 ? "|$" : "";
+            state.output = state.output.slice(0, -(prior.output + prev.output).length);
+            prior.output = `(?:${prior.output}`;
+            prev.type = "globstar";
+            prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`;
+            prev.value += value;
+            state.output += prior.output + prev.output;
+            state.globstar = true;
+            consume(value + advance());
+            push({ type: "slash", value: "/", output: "" });
+            continue;
+          }
+          if (prior.type === "bos" && rest[0] === "/") {
+            prev.type = "globstar";
+            prev.value += value;
+            prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`;
+            state.output = prev.output;
+            state.globstar = true;
+            consume(value + advance());
+            push({ type: "slash", value: "/", output: "" });
+            continue;
+          }
+          state.output = state.output.slice(0, -prev.output.length);
+          prev.type = "globstar";
+          prev.output = globstar(opts);
+          prev.value += value;
+          state.output += prev.output;
+          state.globstar = true;
+          consume(value);
+          continue;
+        }
+        const token = { type: "star", value, output: star };
+        if (opts.bash === true) {
+          token.output = ".*?";
+          if (prev.type === "bos" || prev.type === "slash") {
+            token.output = nodot + token.output;
+          }
+          push(token);
+          continue;
+        }
+        if (prev && (prev.type === "bracket" || prev.type === "paren") && opts.regex === true) {
+          token.output = value;
+          push(token);
+          continue;
+        }
+        if (state.index === state.start || prev.type === "slash" || prev.type === "dot") {
+          if (prev.type === "dot") {
+            state.output += NO_DOT_SLASH;
+            prev.output += NO_DOT_SLASH;
+          } else if (opts.dot === true) {
+            state.output += NO_DOTS_SLASH;
+            prev.output += NO_DOTS_SLASH;
+          } else {
+            state.output += nodot;
+            prev.output += nodot;
+          }
+          if (peek() !== "*") {
+            state.output += ONE_CHAR;
+            prev.output += ONE_CHAR;
+          }
+        }
+        push(token);
+      }
+      while (state.brackets > 0) {
+        if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "]"));
+        state.output = utils.escapeLast(state.output, "[");
+        decrement("brackets");
+      }
+      while (state.parens > 0) {
+        if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", ")"));
+        state.output = utils.escapeLast(state.output, "(");
+        decrement("parens");
+      }
+      while (state.braces > 0) {
+        if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "}"));
+        state.output = utils.escapeLast(state.output, "{");
+        decrement("braces");
+      }
+      if (opts.strictSlashes !== true && (prev.type === "star" || prev.type === "bracket")) {
+        push({ type: "maybe_slash", value: "", output: `${SLASH_LITERAL}?` });
+      }
+      if (state.backtrack === true) {
+        state.output = "";
+        for (const token of state.tokens) {
+          state.output += token.output != null ? token.output : token.value;
+          if (token.suffix) {
+            state.output += token.suffix;
+          }
+        }
+      }
+      return state;
+    };
+    parse.fastpaths = (input, options) => {
+      const opts = { ...options };
+      const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+      const len = input.length;
+      if (len > max) {
+        throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+      }
+      input = REPLACEMENTS[input] || input;
+      const {
+        DOT_LITERAL,
+        SLASH_LITERAL,
+        ONE_CHAR,
+        DOTS_SLASH,
+        NO_DOT,
+        NO_DOTS,
+        NO_DOTS_SLASH,
+        STAR,
+        START_ANCHOR
+      } = constants.globChars(opts.windows);
+      const nodot = opts.dot ? NO_DOTS : NO_DOT;
+      const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
+      const capture = opts.capture ? "" : "?:";
+      const state = { negated: false, prefix: "" };
+      let star = opts.bash === true ? ".*?" : STAR;
+      if (opts.capture) {
+        star = `(${star})`;
+      }
+      const globstar = (opts2) => {
+        if (opts2.noglobstar === true) return star;
+        return `(${capture}(?:(?!${START_ANCHOR}${opts2.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+      };
+      const create = (str) => {
+        switch (str) {
+          case "*":
+            return `${nodot}${ONE_CHAR}${star}`;
+          case ".*":
+            return `${DOT_LITERAL}${ONE_CHAR}${star}`;
+          case "*.*":
+            return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+          case "*/*":
+            return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`;
+          case "**":
+            return nodot + globstar(opts);
+          case "**/*":
+            return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;
+          case "**/*.*":
+            return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+          case "**/.*":
+            return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;
+          default: {
+            const match = /^(.*?)\.(\w+)$/.exec(str);
+            if (!match) return;
+            const source2 = create(match[1]);
+            if (!source2) return;
+            return source2 + DOT_LITERAL + match[2];
+          }
+        }
+      };
+      const output = utils.removePrefix(input, state);
+      let source = create(output);
+      if (source && opts.strictSlashes !== true) {
+        source += `${SLASH_LITERAL}?`;
+      }
+      return source;
+    };
+    module2.exports = parse;
+  }
+});
+
+// ../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/picomatch.js
+var require_picomatch = __commonJS({
+  "../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/picomatch.js"(exports2, module2) {
+    "use strict";
+    var scan = require_scan();
+    var parse = require_parse();
+    var utils = require_utils();
+    var constants = require_constants4();
+    var isObject = (val) => val && typeof val === "object" && !Array.isArray(val);
+    var picomatch2 = (glob, options, returnState = false) => {
+      if (Array.isArray(glob)) {
+        const fns = glob.map((input) => picomatch2(input, options, returnState));
+        const arrayMatcher = (str) => {
+          for (const isMatch of fns) {
+            const state2 = isMatch(str);
+            if (state2) return state2;
+          }
+          return false;
+        };
+        return arrayMatcher;
+      }
+      const isState = isObject(glob) && glob.tokens && glob.input;
+      if (glob === "" || typeof glob !== "string" && !isState) {
+        throw new TypeError("Expected pattern to be a non-empty string");
+      }
+      const opts = options || {};
+      const posix = opts.windows;
+      const regex = isState ? picomatch2.compileRe(glob, options) : picomatch2.makeRe(glob, options, false, true);
+      const state = regex.state;
+      delete regex.state;
+      let isIgnored = () => false;
+      if (opts.ignore) {
+        const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };
+        isIgnored = picomatch2(opts.ignore, ignoreOpts, returnState);
+      }
+      const matcher = (input, returnObject = false) => {
+        const { isMatch, match, output } = picomatch2.test(input, regex, options, { glob, posix });
+        const result = { glob, state, regex, posix, input, output, match, isMatch };
+        if (typeof opts.onResult === "function") {
+          opts.onResult(result);
+        }
+        if (isMatch === false) {
+          result.isMatch = false;
+          return returnObject ? result : false;
+        }
+        if (isIgnored(input)) {
+          if (typeof opts.onIgnore === "function") {
+            opts.onIgnore(result);
+          }
+          result.isMatch = false;
+          return returnObject ? result : false;
+        }
+        if (typeof opts.onMatch === "function") {
+          opts.onMatch(result);
+        }
+        return returnObject ? result : true;
+      };
+      if (returnState) {
+        matcher.state = state;
+      }
+      return matcher;
+    };
+    picomatch2.test = (input, regex, options, { glob, posix } = {}) => {
+      if (typeof input !== "string") {
+        throw new TypeError("Expected input to be a string");
+      }
+      if (input === "") {
+        return { isMatch: false, output: "" };
+      }
+      const opts = options || {};
+      const format = opts.format || (posix ? utils.toPosixSlashes : null);
+      let match = input === glob;
+      let output = match && format ? format(input) : input;
+      if (match === false) {
+        output = format ? format(input) : input;
+        match = output === glob;
+      }
+      if (match === false || opts.capture === true) {
+        if (opts.matchBase === true || opts.basename === true) {
+          match = picomatch2.matchBase(input, regex, options, posix);
+        } else {
+          match = regex.exec(output);
+        }
+      }
+      return { isMatch: Boolean(match), match, output };
+    };
+    picomatch2.matchBase = (input, glob, options) => {
+      const regex = glob instanceof RegExp ? glob : picomatch2.makeRe(glob, options);
+      return regex.test(utils.basename(input));
+    };
+    picomatch2.isMatch = (str, patterns, options) => picomatch2(patterns, options)(str);
+    picomatch2.parse = (pattern, options) => {
+      if (Array.isArray(pattern)) return pattern.map((p) => picomatch2.parse(p, options));
+      return parse(pattern, { ...options, fastpaths: false });
+    };
+    picomatch2.scan = (input, options) => scan(input, options);
+    picomatch2.compileRe = (state, options, returnOutput = false, returnState = false) => {
+      if (returnOutput === true) {
+        return state.output;
+      }
+      const opts = options || {};
+      const prepend = opts.contains ? "" : "^";
+      const append = opts.contains ? "" : "$";
+      let source = `${prepend}(?:${state.output})${append}`;
+      if (state && state.negated === true) {
+        source = `^(?!${source}).*$`;
+      }
+      const regex = picomatch2.toRegex(source, options);
+      if (returnState === true) {
+        regex.state = state;
+      }
+      return regex;
+    };
+    picomatch2.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
+      if (!input || typeof input !== "string") {
+        throw new TypeError("Expected a non-empty string");
+      }
+      let parsed = { negated: false, fastpaths: true };
+      if (options.fastpaths !== false && (input[0] === "." || input[0] === "*")) {
+        parsed.output = parse.fastpaths(input, options);
+      }
+      if (!parsed.output) {
+        parsed = parse(input, options);
+      }
+      return picomatch2.compileRe(parsed, options, returnOutput, returnState);
+    };
+    picomatch2.toRegex = (source, options) => {
+      try {
+        const opts = options || {};
+        return new RegExp(source, opts.flags || (opts.nocase ? "i" : ""));
+      } catch (err) {
+        if (options && options.debug === true) throw err;
+        return /$^/;
+      }
+    };
+    picomatch2.constants = constants;
+    module2.exports = picomatch2;
+  }
+});
+
+// ../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/index.js
+var require_picomatch2 = __commonJS({
+  "../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/index.js"(exports2, module2) {
+    "use strict";
+    var pico = require_picomatch();
+    var utils = require_utils();
+    function picomatch2(glob, options, returnState = false) {
+      if (options && (options.windows === null || options.windows === void 0)) {
+        options = { ...options, windows: utils.isWindows() };
+      }
+      return pico(glob, options, returnState);
+    }
+    Object.assign(picomatch2, pico);
+    module2.exports = picomatch2;
+  }
+});
+
+// src/services/linuxcnc.ts
+var import_core = __toESM(require_dist3());
+init_dlv_es();
+var SERVICE_NAME = "linuxcnc";
+var statChannel = null;
+var commandChannel = null;
+var errorChannel = null;
+var connections = /* @__PURE__ */ new Map();
+function broadcastDelta(changes) {
+  if (changes.length === 0 || !statChannel) return;
+  const message = {
+    changes,
+    cursor: statChannel.getCursor(),
+    timestamp: Date.now()
+  };
+  for (const conn of connections.values()) {
+    try {
+      conn.send("stat-delta", message);
+    } catch (err) {
+      console.error("[LinuxCNC] Error sending delta:", err);
+    }
+  }
+}
+function initLinuxCNCService() {
+  statChannel = new import_core.StatChannel({ pollInterval: 50 });
+  commandChannel = new import_core.CommandChannel();
+  errorChannel = new import_core.ErrorChannel({ pollInterval: 100 });
+  statChannel.on("delta", broadcastDelta);
+  errorChannel.on("message", (error) => {
+    for (const conn of connections.values()) {
+      try {
+        conn.send("error-channel-event", error);
+      } catch (err) {
+        console.error("[LinuxCNC] Error forwarding error event:", err);
+      }
+    }
+  });
+  worker.appBus.exposeService(
+    SERVICE_NAME,
+    (connection, { appId: clientAppId }) => {
+      console.log(`[LinuxCNC] Client connected: ${clientAppId}`);
+      const typedConn = connection;
+      connections.set(clientAppId, typedConn);
+      connection.onClose(() => {
+        console.log(`[LinuxCNC] Client disconnected: ${clientAppId}`);
+        connections.delete(clientAppId);
+      });
+      typedConn.handle("stat/sync", () => {
+        const stat = statChannel.get();
+        if (!stat) {
+          throw new Error("StatChannel not ready");
+        }
+        return {
+          stat,
+          cursor: statChannel.getCursor()
+        };
+      });
+      typedConn.handle("stat/get-value", ({ path }) => {
+        const stat = statChannel.get();
+        if (!stat) {
+          throw new Error("StatChannel not ready");
+        }
+        return { value: dlv_es_default(stat, path) };
+      });
+      typedConn.handle("cmd/set-task-mode", async ({ mode }) => {
+        return commandChannel.setTaskMode(mode);
+      });
+      typedConn.handle("cmd/set-state", async ({ state }) => {
+        return commandChannel.setState(state);
+      });
+      typedConn.handle("cmd/mdi", async ({ command }) => {
+        return commandChannel.mdi(command);
+      });
+      typedConn.handle("cmd/abort", async () => {
+        return commandChannel.abortTask();
+      });
+      typedConn.handle("cmd/task-plan-synch", async () => {
+        return commandChannel.taskPlanSynch();
+      });
+      typedConn.handle("cmd/reset-interpreter", async () => {
+        return commandChannel.resetInterpreter();
+      });
+      typedConn.handle("cmd/program-open", async ({ filePath }) => {
+        return commandChannel.programOpen(filePath);
+      });
+      typedConn.handle("cmd/program-run", async ({ startLine }) => {
+        return commandChannel.runProgram(startLine ?? 0);
+      });
+      typedConn.handle("cmd/program-pause", async () => {
+        return commandChannel.pauseProgram();
+      });
+      typedConn.handle("cmd/program-resume", async () => {
+        return commandChannel.resumeProgram();
+      });
+      typedConn.handle("cmd/program-step", async () => {
+        return commandChannel.stepProgram();
+      });
+      typedConn.handle("cmd/program-reverse", async () => {
+        return commandChannel.reverseProgram();
+      });
+      typedConn.handle("cmd/program-forward", async () => {
+        return commandChannel.forwardProgram();
+      });
+      typedConn.handle("cmd/set-feed-rate", async ({ scale }) => {
+        return commandChannel.setFeedRate(scale);
+      });
+      typedConn.handle("cmd/set-rapid-rate", async ({ scale }) => {
+        return commandChannel.setRapidRate(scale);
+      });
+      typedConn.handle("cmd/set-max-velocity", async ({ velocity }) => {
+        return commandChannel.setMaxVelocity(velocity);
+      });
+      typedConn.handle("cmd/set-traj-mode", async ({ mode }) => {
+        return commandChannel.setTrajMode(mode);
+      });
+      typedConn.handle("cmd/teleop-enable", async ({ enable }) => {
+        return commandChannel.teleopEnable(enable);
+      });
+      typedConn.handle("cmd/set-feed-override-enable", async ({ enable }) => {
+        return commandChannel.setFeedOverrideEnable(enable);
+      });
+      typedConn.handle("cmd/set-feed-hold-enable", async ({ enable }) => {
+        return commandChannel.setFeedHoldEnable(enable);
+      });
+      typedConn.handle("cmd/set-adaptive-feed-enable", async ({ enable }) => {
+        return commandChannel.setAdaptiveFeedEnable(enable);
+      });
+      typedConn.handle(
+        "cmd/jog-continuous",
+        async ({ axis, speed, isJoint }) => {
+          return commandChannel.jogContinuous(axis, isJoint ?? false, speed);
+        }
+      );
+      typedConn.handle(
+        "cmd/jog-increment",
+        async ({ axis, speed, increment, isJoint }) => {
+          return commandChannel.jogIncrement(
+            axis,
+            isJoint ?? false,
+            speed,
+            increment
+          );
+        }
+      );
+      typedConn.handle("cmd/jog-stop", async ({ axis, isJoint }) => {
+        return commandChannel.jogStop(axis, isJoint ?? false);
+      });
+      typedConn.handle("cmd/home", async ({ joint }) => {
+        return commandChannel.homeJoint(joint);
+      });
+      typedConn.handle("cmd/unhome", async ({ joint }) => {
+        return commandChannel.unhomeJoint(joint);
+      });
+      typedConn.handle(
+        "cmd/set-min-position-limit",
+        async ({ joint, limit }) => {
+          return commandChannel.setMinPositionLimit(joint, limit);
+        }
+      );
+      typedConn.handle(
+        "cmd/set-max-position-limit",
+        async ({ joint, limit }) => {
+          return commandChannel.setMaxPositionLimit(joint, limit);
+        }
+      );
+      typedConn.handle("cmd/spindle-on", async ({ speed, spindle, wait }) => {
+        return commandChannel.spindleOn(speed, spindle ?? 0, wait ?? false);
+      });
+      typedConn.handle("cmd/spindle-off", async ({ spindle }) => {
+        return commandChannel.spindleOff(spindle ?? 0);
+      });
+      typedConn.handle("cmd/spindle-override", async ({ scale, spindle }) => {
+        return commandChannel.setSpindleOverride(scale, spindle ?? 0);
+      });
+      typedConn.handle("cmd/spindle-brake", async ({ engage, spindle }) => {
+        return commandChannel.spindleBrake(engage, spindle ?? 0);
+      });
+      typedConn.handle("cmd/spindle-increase", async ({ spindle }) => {
+        return commandChannel.spindleIncrease(spindle ?? 0);
+      });
+      typedConn.handle("cmd/spindle-decrease", async ({ spindle }) => {
+        return commandChannel.spindleDecrease(spindle ?? 0);
+      });
+      typedConn.handle(
+        "cmd/set-spindle-override-enable",
+        async ({ enable, spindle }) => {
+          return commandChannel.setSpindleOverrideEnable(enable, spindle ?? 0);
+        }
+      );
+      typedConn.handle("cmd/set-mist", async ({ on }) => {
+        return commandChannel.setMist(on);
+      });
+      typedConn.handle("cmd/set-flood", async ({ on }) => {
+        return commandChannel.setFlood(on);
+      });
+      typedConn.handle("cmd/load-tool-table", async () => {
+        return commandChannel.loadToolTable();
+      });
+      typedConn.handle("cmd/set-tool", async ({ tool }) => {
+        return commandChannel.setTool(tool);
+      });
+      typedConn.handle("cmd/set-digital-output", async ({ index, value }) => {
+        return commandChannel.setDigitalOutput(index, value);
+      });
+      typedConn.handle("cmd/set-analog-output", async ({ index, value }) => {
+        return commandChannel.setAnalogOutput(index, value);
+      });
+      typedConn.handle("cmd/override-limits", async () => {
+        return commandChannel.overrideLimits();
+      });
+      typedConn.handle("cmd/set-optional-stop", async ({ enable }) => {
+        return commandChannel.setOptionalStop(enable);
+      });
+      typedConn.handle("cmd/set-block-delete", async ({ enable }) => {
+        return commandChannel.setBlockDelete(enable);
+      });
+      typedConn.handle("cmd/set-debug-level", async ({ level }) => {
+        return commandChannel.setDebugLevel(level);
+      });
+      typedConn.handle("cmd/send-operator-error", async ({ message }) => {
+        return commandChannel.sendOperatorError(message);
+      });
+      typedConn.handle("cmd/send-operator-text", async ({ message }) => {
+        return commandChannel.sendOperatorText(message);
+      });
+      typedConn.handle("cmd/send-operator-display", async ({ message }) => {
+        return commandChannel.sendOperatorDisplay(message);
+      });
+      typedConn.handle("ping", () => {
+        return { timestamp: Date.now() };
+      });
+    },
+    { description: "LinuxCNC status monitoring and command execution" }
+  );
+  console.log(`[LinuxCNC] Service exposed as '${SERVICE_NAME}'`);
+}
+
+// src/services/gcode.ts
+var import_gcode = __toESM(require_dist4());
+var SERVICE_NAME2 = "gcode";
+function initGCodeService() {
+  worker.appBus.exposeService(
+    SERVICE_NAME2,
+    (connection, { appId: clientAppId }) => {
+      console.log(`[GCode] Client connected: ${clientAppId}`);
+      const typedConn = connection;
+      connection.onClose(() => {
+        console.log(`[GCode] Client disconnected: ${clientAppId}`);
+      });
+      typedConn.handle(
+        "parse",
+        async ({ filepath, iniPath, progressUpdates }) => {
+          try {
+            const result = await (0, import_gcode.parseGCode)(filepath, {
+              iniPath,
+              progressUpdates: progressUpdates ?? 40,
+              onProgress: (progress) => {
+                try {
+                  typedConn.send("parse-progress", progress);
+                } catch (err) {
+                  console.error("[GCode] Error sending progress:", err);
+                }
+              }
+            });
+            return result;
+          } catch (err) {
+            typedConn.send("error", {
+              code: "PARSE_ERROR",
+              message: err instanceof Error ? err.message : String(err)
+            });
+            throw err;
+          }
+        }
+      );
+      typedConn.handle("ping", () => {
+        return { timestamp: Date.now() };
+      });
+    },
+    { description: "G-code file parsing using LinuxCNC interpreter" }
+  );
+  console.log(`[GCode] Service exposed as '${SERVICE_NAME2}'`);
+}
+
+// src/services/hal.ts
+var import_hal = __toESM(require_dist5());
+var import_picomatch = __toESM(require_picomatch2());
+var SERVICE_NAME3 = "hal";
+function initHalService() {
+  worker.appBus.exposeService(
+    SERVICE_NAME3,
+    (connection, { appId: clientAppId }) => {
+      console.log(`[HAL] Client connected: ${clientAppId}`);
+      const typedConn = connection;
+      const state = {
+        component: null,
+        pins: /* @__PURE__ */ new Map(),
+        params: /* @__PURE__ */ new Map(),
+        lastValues: /* @__PURE__ */ new Map(),
+        cursor: 0,
+        pollInterval: null
+      };
+      connection.onClose(() => {
+        console.log(`[HAL] Client disconnected: ${clientAppId}`);
+        if (state.pollInterval) {
+          clearInterval(state.pollInterval);
+        }
+        if (state.component) {
+          state.component.dispose();
+        }
+      });
+      function startPolling() {
+        if (state.pollInterval) return;
+        state.pollInterval = setInterval(() => {
+          if (!state.component) return;
+          const changes = [];
+          for (const [name, pin] of state.pins) {
+            const value = pin.getValue();
+            const lastValue = state.lastValues.get(name);
+            if (value !== lastValue) {
+              changes.push({ name, value });
+              state.lastValues.set(name, value);
+            }
+          }
+          for (const [name, param] of state.params) {
+            const value = param.getValue();
+            const lastValue = state.lastValues.get(name);
+            if (value !== lastValue) {
+              changes.push({ name, value });
+              state.lastValues.set(name, value);
+            }
+          }
+          if (changes.length > 0) {
+            state.cursor++;
+            const delta = {
+              changes,
+              cursor: state.cursor,
+              timestamp: Date.now()
+            };
+            try {
+              typedConn.send("items-delta", delta);
+            } catch (err) {
+              console.error("[HAL] Error sending delta:", err);
+            }
+          }
+        }, 10);
+      }
+      typedConn.handle("component/init", ({ name, prefix }) => {
+        if (state.component) {
+          return {
+            success: false,
+            componentName: "",
+            error: "Component already initialized for this connection"
+          };
+        }
+        try {
+          state.component = new import_hal.HalComponent(name, prefix);
+          return {
+            success: true,
+            componentName: state.component.name
+          };
+        } catch (err) {
+          return {
+            success: false,
+            componentName: "",
+            error: err instanceof Error ? err.message : String(err)
+          };
+        }
+      });
+      typedConn.handle("component/ready", () => {
+        if (!state.component) {
+          return { success: false, error: "Component not initialized" };
+        }
+        try {
+          state.component.ready();
+          startPolling();
+          typedConn.send("hal-ready", {
+            componentName: state.component.name,
+            prefix: state.component.prefix
+          });
+          return { success: true };
+        } catch (err) {
+          return {
+            success: false,
+            error: err instanceof Error ? err.message : String(err)
+          };
+        }
+      });
+      typedConn.handle("component/unready", () => {
+        if (!state.component) {
+          return { success: false, error: "Component not initialized" };
+        }
+        try {
+          state.component.unready();
+          return { success: true };
+        } catch (err) {
+          return {
+            success: false,
+            error: err instanceof Error ? err.message : String(err)
+          };
+        }
+      });
+      typedConn.handle("pin/create", ({ name, type, direction }) => {
+        if (!state.component) {
+          return {
+            success: false,
+            fullName: "",
+            error: "Component not initialized"
+          };
+        }
+        try {
+          const pin = state.component.newPin(name, type, direction);
+          state.pins.set(name, pin);
+          state.lastValues.set(name, pin.getValue());
+          return {
+            success: true,
+            fullName: `${state.component.prefix}.${pin.name}`
+          };
+        } catch (err) {
+          return {
+            success: false,
+            fullName: "",
+            error: err instanceof Error ? err.message : String(err)
+          };
+        }
+      });
+      typedConn.handle("param/create", ({ name, type, direction }) => {
+        if (!state.component) {
+          return {
+            success: false,
+            fullName: "",
+            error: "Component not initialized"
+          };
+        }
+        try {
+          const param = state.component.newParam(name, type, direction);
+          state.params.set(name, param);
+          state.lastValues.set(name, param.getValue());
+          return {
+            success: true,
+            fullName: `${state.component.prefix}.${param.name}`
+          };
+        } catch (err) {
+          return {
+            success: false,
+            fullName: "",
+            error: err instanceof Error ? err.message : String(err)
+          };
+        }
+      });
+      typedConn.handle("item/get-value", ({ name }) => {
+        if (!state.component) {
+          throw new Error("Component not initialized");
+        }
+        const value = state.component.getValue(name);
+        return { value };
+      });
+      typedConn.handle("item/set-value", ({ name, value }) => {
+        if (!state.component) {
+          return { success: false, error: "Component not initialized" };
+        }
+        try {
+          state.component.setValue(name, value);
+          state.lastValues.set(name, value);
+          return { success: true };
+        } catch (err) {
+          return {
+            success: false,
+            error: err instanceof Error ? err.message : String(err)
+          };
+        }
+      });
+      typedConn.handle("items/sync", () => {
+        if (!state.component) {
+          throw new Error("Component not initialized");
+        }
+        const items = {};
+        for (const [name, pin] of state.pins) {
+          items[name] = pin.getValue();
+        }
+        for (const [name, param] of state.params) {
+          items[name] = param.getValue();
+        }
+        return {
+          items,
+          cursor: state.cursor
+        };
+      });
+      typedConn.handle("global/component-exists", ({ componentName }) => {
+        return { exists: import_hal.HalComponent.exists(componentName) };
+      });
+      typedConn.handle("global/component-is-ready", ({ componentName }) => {
+        return { ready: import_hal.HalComponent.isReady(componentName) };
+      });
+      typedConn.handle("global/signal-create", ({ name, type }) => {
+        try {
+          (0, import_hal.newSignal)(name, type);
+          return { success: true };
+        } catch (err) {
+          return {
+            success: false,
+            error: err instanceof Error ? err.message : String(err)
+          };
+        }
+      });
+      typedConn.handle("global/signal-get-value", ({ signalName }) => {
+        const value = (0, import_hal.getValue)(signalName);
+        return { value };
+      });
+      typedConn.handle("global/signal-set-value", ({ signalName, value }) => {
+        try {
+          (0, import_hal.setSignalValue)(signalName, value);
+          return { success: true };
+        } catch (err) {
+          return {
+            success: false,
+            error: err instanceof Error ? err.message : String(err)
+          };
+        }
+      });
+      typedConn.handle("global/signal-connect", ({ pinName, signalName }) => {
+        return { success: false, error: "Not implemented - use halcmd net" };
+      });
+      typedConn.handle("global/signal-disconnect", ({ pinName }) => {
+        return {
+          success: false,
+          error: "Not implemented - use halcmd unlinkp"
+        };
+      });
+      typedConn.handle("global/pin-has-writer", ({ pinName }) => {
+        return { hasWriter: (0, import_hal.pinHasWriter)(pinName) };
+      });
+      typedConn.handle("global/get-value", ({ name }) => {
+        const value = (0, import_hal.getValue)(name);
+        return { value, type: "pin" };
+      });
+      typedConn.handle("global/list-pins", ({ filter }) => {
+        let pins = (0, import_hal.getInfoPins)();
+        if (filter) {
+          const isMatch = (0, import_picomatch.default)(filter);
+          pins = pins.filter((p) => isMatch(p.name));
+        }
+        return { pins };
+      });
+      typedConn.handle("global/list-params", ({ filter }) => {
+        let params = (0, import_hal.getInfoParams)();
+        if (filter) {
+          const isMatch = (0, import_picomatch.default)(filter);
+          params = params.filter((p) => isMatch(p.name));
+        }
+        return { params };
+      });
+      typedConn.handle("global/list-signals", ({ filter }) => {
+        let signals = (0, import_hal.getInfoSignals)();
+        if (filter) {
+          const isMatch = (0, import_picomatch.default)(filter);
+          signals = signals.filter((s) => isMatch(s.name));
+        }
+        return { signals };
+      });
+      typedConn.handle("global/list-all", () => {
+        return {
+          pins: (0, import_hal.getInfoPins)(),
+          params: (0, import_hal.getInfoParams)(),
+          signals: (0, import_hal.getInfoSignals)()
+        };
+      });
+      typedConn.handle("global/msg-level-get", () => {
+        return { level: (0, import_hal.getMsgLevel)() };
+      });
+      typedConn.handle("global/msg-level-set", ({ level }) => {
+        const previousLevel = (0, import_hal.getMsgLevel)();
+        (0, import_hal.setMsgLevel)(level);
+        return { success: true, previousLevel };
+      });
+      typedConn.handle("ping", () => {
+        return { timestamp: Date.now() };
+      });
+      typedConn.handle("get-status", () => {
+        return {
+          connected: true,
+          componentName: state.component?.name ?? "",
+          componentReady: state.component ? import_hal.HalComponent.isReady(state.component.name) : false,
+          pinCount: state.pins.size,
+          paramCount: state.params.size,
+          uptime: process.uptime()
+        };
+      });
+    },
+    { description: "HAL component management and I/O access" }
+  );
+  console.log(`[HAL] Service exposed as '${SERVICE_NAME3}'`);
+}
+
+// src/services/position-logger.ts
+var import_core2 = __toESM(require_dist3());
+var import_types = __toESM(require_dist2());
+var SERVICE_NAME4 = "position-logger";
+var UPDATE_INTERVAL_MS = 50;
+var logger = null;
+var cursor = 0;
+var lastHistoryCount = 0;
+var connections2 = /* @__PURE__ */ new Map();
+var updateInterval = null;
+function startUpdateLoop() {
+  if (updateInterval) return;
+  updateInterval = setInterval(() => {
+    if (!logger || connections2.size === 0) return;
+    const currentCount = logger.getHistoryCount();
+    if (currentCount <= lastHistoryCount) return;
+    const newPointCount = currentCount - lastHistoryCount;
+    const newPoints = logger.getMotionHistory(lastHistoryCount, newPointCount);
+    cursor++;
+    lastHistoryCount = currentCount;
+    const message = {
+      points: newPoints,
+      count: newPointCount,
+      cursor
+    };
+    for (const conn of connections2.values()) {
+      try {
+        conn.send("position-update", message);
+      } catch (err) {
+        console.error("[PositionLogger] Error sending update:", err);
+      }
+    }
+  }, UPDATE_INTERVAL_MS);
+}
+function stopUpdateLoop() {
+  if (updateInterval) {
+    clearInterval(updateInterval);
+    updateInterval = null;
+  }
+}
+function initPositionLoggerService() {
+  logger = new import_core2.PositionLogger();
+  worker.appBus.exposeService(
+    SERVICE_NAME4,
+    (connection, { appId: clientAppId }) => {
+      console.log(`[PositionLogger] Client connected: ${clientAppId}`);
+      const typedConn = connection;
+      connections2.set(clientAppId, typedConn);
+      connection.onClose(() => {
+        console.log(`[PositionLogger] Client disconnected: ${clientAppId}`);
+        connections2.delete(clientAppId);
+        if (connections2.size === 0) {
+          stopUpdateLoop();
+        }
+      });
+      typedConn.handle("start", ({ interval, maxHistory }) => {
+        if (!logger) {
+          return { success: false, cursor: 0 };
+        }
+        logger.start({
+          interval: interval ?? 0.01,
+          maxHistorySize: maxHistory ?? 1e4
+        });
+        lastHistoryCount = 0;
+        cursor++;
+        startUpdateLoop();
+        return { success: true, cursor };
+      });
+      typedConn.handle("stop", () => {
+        if (!logger) {
+          return { success: false };
+        }
+        logger.stop();
+        return { success: true };
+      });
+      typedConn.handle("clear", () => {
+        if (!logger) {
+          return { success: false };
+        }
+        logger.clear();
+        lastHistoryCount = 0;
+        cursor++;
+        return { success: true };
+      });
+      typedConn.handle("sync", () => {
+        if (!logger) {
+          return {
+            history: new Float64Array(0),
+            count: 0,
+            cursor: 0
+          };
+        }
+        const currentCount = logger.getHistoryCount();
+        const history = logger.getMotionHistory(0, currentCount);
+        return {
+          history,
+          count: history.length / import_types.POSITION_STRIDE,
+          cursor
+        };
+      });
+      typedConn.handle("get-current", () => {
+        if (!logger) {
+          return { position: null };
+        }
+        const position = logger.getCurrentPosition();
+        return { position };
+      });
+      typedConn.handle("get-cursor", () => {
+        return { cursor };
+      });
+      typedConn.handle("ping", () => {
+        return { timestamp: Date.now() };
+      });
+    },
+    { description: "Machine position logging and history streaming" }
+  );
+  console.log(`[PositionLogger] Service exposed as '${SERVICE_NAME4}'`);
+}
+
+// src/backend.ts
+var appId = process.env.EDEN_APP_ID;
 console.log(`[Covenant Bridge] Starting for ${appId}`);
-// Initialize all services
 initLinuxCNCService();
 initGCodeService();
 initHalService();