@tasker-systems/tasker 0.1.0-alpha.1

package/dist/ffi/index.js

@@ -0,0 +1,1945 @@
+import { existsSync } from 'fs';
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames2 = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames2(fn)[0]])(fn = 0)), res;
+};
+var __commonJS2 = (cb, mod3) => function __require2() {
+  return mod3 || (0, cb[__getOwnPropNames2(cb)[0]])((mod3 = { exports: {} }).exports, mod3), mod3.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 __getOwnPropNames2(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 = (mod3, isNodeMode, target) => (target = mod3 != null ? __create(__getProtoOf(mod3)) : {}, __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.
+  __defProp(target, "default", { value: mod3, enumerable: true }) ,
+  mod3
+));
+
+// src/ffi/runtime-interface.ts
+var BaseTaskerRuntime;
+var init_runtime_interface = __esm({
+  "src/ffi/runtime-interface.ts"() {
+    BaseTaskerRuntime = class {
+      /**
+       * Helper to parse JSON string from FFI
+       */
+      parseJson(jsonStr) {
+        if (jsonStr === null || jsonStr === "") {
+          return null;
+        }
+        try {
+          return JSON.parse(jsonStr);
+        } catch {
+          return null;
+        }
+      }
+      /**
+       * Helper to stringify JSON for FFI
+       */
+      toJson(value) {
+        return JSON.stringify(value);
+      }
+    };
+  }
+});
+
+// node_modules/koffi/build/koffi/darwin_arm64/koffi.node
+var koffi_default;
+var init_koffi = __esm({
+  "node_modules/koffi/build/koffi/darwin_arm64/koffi.node"() {
+    koffi_default = "../koffi-X7JMBSZH.node";
+  }
+});
+
+// node-file:/Users/petetaylor/projects/tasker-systems/tasker-core/workers/typescript/node_modules/koffi/build/koffi/darwin_arm64/koffi.node
+var require_koffi = __commonJS2({
+  "node-file:/Users/petetaylor/projects/tasker-systems/tasker-core/workers/typescript/node_modules/koffi/build/koffi/darwin_arm64/koffi.node"(exports2, module2) {
+    init_koffi();
+    try {
+      module2.exports = __require(koffi_default);
+    } catch {
+    }
+  }
+});
+
+// node_modules/koffi/build/koffi/darwin_x64/koffi.node
+var koffi_default2;
+var init_koffi2 = __esm({
+  "node_modules/koffi/build/koffi/darwin_x64/koffi.node"() {
+    koffi_default2 = "../koffi-OMHWL3D6.node";
+  }
+});
+
+// node-file:/Users/petetaylor/projects/tasker-systems/tasker-core/workers/typescript/node_modules/koffi/build/koffi/darwin_x64/koffi.node
+var require_koffi2 = __commonJS2({
+  "node-file:/Users/petetaylor/projects/tasker-systems/tasker-core/workers/typescript/node_modules/koffi/build/koffi/darwin_x64/koffi.node"(exports2, module2) {
+    init_koffi2();
+    try {
+      module2.exports = __require(koffi_default2);
+    } catch {
+    }
+  }
+});
+
+// node_modules/koffi/build/koffi/freebsd_arm64/koffi.node
+var koffi_default3;
+var init_koffi3 = __esm({
+  "node_modules/koffi/build/koffi/freebsd_arm64/koffi.node"() {
+    koffi_default3 = "../koffi-AVDVVSXH.node";
+  }
+});
+
+// node-file:/Users/petetaylor/projects/tasker-systems/tasker-core/workers/typescript/node_modules/koffi/build/koffi/freebsd_arm64/koffi.node
+var require_koffi3 = __commonJS2({
+  "node-file:/Users/petetaylor/projects/tasker-systems/tasker-core/workers/typescript/node_modules/koffi/build/koffi/freebsd_arm64/koffi.node"(exports2, module2) {
+    init_koffi3();
+    try {
+      module2.exports = __require(koffi_default3);
+    } catch {
+    }
+  }
+});
+
+// node_modules/koffi/build/koffi/freebsd_ia32/koffi.node
+var koffi_default4;
+var init_koffi4 = __esm({
+  "node_modules/koffi/build/koffi/freebsd_ia32/koffi.node"() {
+    koffi_default4 = "../koffi-GG4SDSYA.node";
+  }
+});
+
+// node-file:/Users/petetaylor/projects/tasker-systems/tasker-core/workers/typescript/node_modules/koffi/build/koffi/freebsd_ia32/koffi.node
+var require_koffi4 = __commonJS2({
+  "node-file:/Users/petetaylor/projects/tasker-systems/tasker-core/workers/typescript/node_modules/koffi/build/koffi/freebsd_ia32/koffi.node"(exports2, module2) {
+    init_koffi4();
+    try {
+      module2.exports = __require(koffi_default4);
+    } catch {
+    }
+  }
+});
+
+// node_modules/koffi/build/koffi/freebsd_x64/koffi.node
+var koffi_default5;
+var init_koffi5 = __esm({
+  "node_modules/koffi/build/koffi/freebsd_x64/koffi.node"() {
+    koffi_default5 = "../koffi-AHHUCM3C.node";
+  }
+});
+
+// node-file:/Users/petetaylor/projects/tasker-systems/tasker-core/workers/typescript/node_modules/koffi/build/koffi/freebsd_x64/koffi.node
+var require_koffi5 = __commonJS2({
+  "node-file:/Users/petetaylor/projects/tasker-systems/tasker-core/workers/typescript/node_modules/koffi/build/koffi/freebsd_x64/koffi.node"(exports2, module2) {
+    init_koffi5();
+    try {
+      module2.exports = __require(koffi_default5);
+    } catch {
+    }
+  }
+});
+
+// node_modules/koffi/build/koffi/linux_armhf/koffi.node
+var koffi_default6;
+var init_koffi6 = __esm({
+  "node_modules/koffi/build/koffi/linux_armhf/koffi.node"() {
+    koffi_default6 = "../koffi-YNQDUF3Q.node";
+  }
+});
+
+// node-file:/Users/petetaylor/projects/tasker-systems/tasker-core/workers/typescript/node_modules/koffi/build/koffi/linux_armhf/koffi.node
+var require_koffi6 = __commonJS2({
+  "node-file:/Users/petetaylor/projects/tasker-systems/tasker-core/workers/typescript/node_modules/koffi/build/koffi/linux_armhf/koffi.node"(exports2, module2) {
+    init_koffi6();
+    try {
+      module2.exports = __require(koffi_default6);
+    } catch {
+    }
+  }
+});
+
+// node_modules/koffi/build/koffi/linux_arm64/koffi.node
+var koffi_default7;
+var init_koffi7 = __esm({
+  "node_modules/koffi/build/koffi/linux_arm64/koffi.node"() {
+    koffi_default7 = "../koffi-SE4ZI36U.node";
+  }
+});
+
+// node-file:/Users/petetaylor/projects/tasker-systems/tasker-core/workers/typescript/node_modules/koffi/build/koffi/linux_arm64/koffi.node
+var require_koffi7 = __commonJS2({
+  "node-file:/Users/petetaylor/projects/tasker-systems/tasker-core/workers/typescript/node_modules/koffi/build/koffi/linux_arm64/koffi.node"(exports2, module2) {
+    init_koffi7();
+    try {
+      module2.exports = __require(koffi_default7);
+    } catch {
+    }
+  }
+});
+
+// node_modules/koffi/build/koffi/linux_ia32/koffi.node
+var koffi_default8;
+var init_koffi8 = __esm({
+  "node_modules/koffi/build/koffi/linux_ia32/koffi.node"() {
+    koffi_default8 = "../koffi-LOH6WKRQ.node";
+  }
+});
+
+// node-file:/Users/petetaylor/projects/tasker-systems/tasker-core/workers/typescript/node_modules/koffi/build/koffi/linux_ia32/koffi.node
+var require_koffi8 = __commonJS2({
+  "node-file:/Users/petetaylor/projects/tasker-systems/tasker-core/workers/typescript/node_modules/koffi/build/koffi/linux_ia32/koffi.node"(exports2, module2) {
+    init_koffi8();
+    try {
+      module2.exports = __require(koffi_default8);
+    } catch {
+    }
+  }
+});
+
+// node_modules/koffi/build/koffi/linux_loong64/koffi.node
+var koffi_default9;
+var init_koffi9 = __esm({
+  "node_modules/koffi/build/koffi/linux_loong64/koffi.node"() {
+    koffi_default9 = "../koffi-QKY2KSXW.node";
+  }
+});
+
+// node-file:/Users/petetaylor/projects/tasker-systems/tasker-core/workers/typescript/node_modules/koffi/build/koffi/linux_loong64/koffi.node
+var require_koffi9 = __commonJS2({
+  "node-file:/Users/petetaylor/projects/tasker-systems/tasker-core/workers/typescript/node_modules/koffi/build/koffi/linux_loong64/koffi.node"(exports2, module2) {
+    init_koffi9();
+    try {
+      module2.exports = __require(koffi_default9);
+    } catch {
+    }
+  }
+});
+
+// node_modules/koffi/build/koffi/linux_riscv64d/koffi.node
+var koffi_default10;
+var init_koffi10 = __esm({
+  "node_modules/koffi/build/koffi/linux_riscv64d/koffi.node"() {
+    koffi_default10 = "../koffi-X3YT67KE.node";
+  }
+});
+
+// node-file:/Users/petetaylor/projects/tasker-systems/tasker-core/workers/typescript/node_modules/koffi/build/koffi/linux_riscv64d/koffi.node
+var require_koffi10 = __commonJS2({
+  "node-file:/Users/petetaylor/projects/tasker-systems/tasker-core/workers/typescript/node_modules/koffi/build/koffi/linux_riscv64d/koffi.node"(exports2, module2) {
+    init_koffi10();
+    try {
+      module2.exports = __require(koffi_default10);
+    } catch {
+    }
+  }
+});
+
+// node_modules/koffi/build/koffi/linux_x64/koffi.node
+var koffi_default11;
+var init_koffi11 = __esm({
+  "node_modules/koffi/build/koffi/linux_x64/koffi.node"() {
+    koffi_default11 = "../koffi-G4D35B2D.node";
+  }
+});
+
+// node-file:/Users/petetaylor/projects/tasker-systems/tasker-core/workers/typescript/node_modules/koffi/build/koffi/linux_x64/koffi.node
+var require_koffi11 = __commonJS2({
+  "node-file:/Users/petetaylor/projects/tasker-systems/tasker-core/workers/typescript/node_modules/koffi/build/koffi/linux_x64/koffi.node"(exports2, module2) {
+    init_koffi11();
+    try {
+      module2.exports = __require(koffi_default11);
+    } catch {
+    }
+  }
+});
+
+// node_modules/koffi/build/koffi/openbsd_ia32/koffi.node
+var koffi_default12;
+var init_koffi12 = __esm({
+  "node_modules/koffi/build/koffi/openbsd_ia32/koffi.node"() {
+    koffi_default12 = "../koffi-LUY2JHJP.node";
+  }
+});
+
+// node-file:/Users/petetaylor/projects/tasker-systems/tasker-core/workers/typescript/node_modules/koffi/build/koffi/openbsd_ia32/koffi.node
+var require_koffi12 = __commonJS2({
+  "node-file:/Users/petetaylor/projects/tasker-systems/tasker-core/workers/typescript/node_modules/koffi/build/koffi/openbsd_ia32/koffi.node"(exports2, module2) {
+    init_koffi12();
+    try {
+      module2.exports = __require(koffi_default12);
+    } catch {
+    }
+  }
+});
+
+// node_modules/koffi/build/koffi/openbsd_x64/koffi.node
+var koffi_default13;
+var init_koffi13 = __esm({
+  "node_modules/koffi/build/koffi/openbsd_x64/koffi.node"() {
+    koffi_default13 = "../koffi-ROB3FRHA.node";
+  }
+});
+
+// node-file:/Users/petetaylor/projects/tasker-systems/tasker-core/workers/typescript/node_modules/koffi/build/koffi/openbsd_x64/koffi.node
+var require_koffi13 = __commonJS2({
+  "node-file:/Users/petetaylor/projects/tasker-systems/tasker-core/workers/typescript/node_modules/koffi/build/koffi/openbsd_x64/koffi.node"(exports2, module2) {
+    init_koffi13();
+    try {
+      module2.exports = __require(koffi_default13);
+    } catch {
+    }
+  }
+});
+
+// node_modules/koffi/build/koffi/win32_arm64/koffi.node
+var koffi_default14;
+var init_koffi14 = __esm({
+  "node_modules/koffi/build/koffi/win32_arm64/koffi.node"() {
+    koffi_default14 = "../koffi-GOENU54R.node";
+  }
+});
+
+// node-file:/Users/petetaylor/projects/tasker-systems/tasker-core/workers/typescript/node_modules/koffi/build/koffi/win32_arm64/koffi.node
+var require_koffi14 = __commonJS2({
+  "node-file:/Users/petetaylor/projects/tasker-systems/tasker-core/workers/typescript/node_modules/koffi/build/koffi/win32_arm64/koffi.node"(exports2, module2) {
+    init_koffi14();
+    try {
+      module2.exports = __require(koffi_default14);
+    } catch {
+    }
+  }
+});
+
+// node_modules/koffi/build/koffi/win32_ia32/koffi.node
+var koffi_default15;
+var init_koffi15 = __esm({
+  "node_modules/koffi/build/koffi/win32_ia32/koffi.node"() {
+    koffi_default15 = "../koffi-KFZAXWPQ.node";
+  }
+});
+
+// node-file:/Users/petetaylor/projects/tasker-systems/tasker-core/workers/typescript/node_modules/koffi/build/koffi/win32_ia32/koffi.node
+var require_koffi15 = __commonJS2({
+  "node-file:/Users/petetaylor/projects/tasker-systems/tasker-core/workers/typescript/node_modules/koffi/build/koffi/win32_ia32/koffi.node"(exports2, module2) {
+    init_koffi15();
+    try {
+      module2.exports = __require(koffi_default15);
+    } catch {
+    }
+  }
+});
+
+// node_modules/koffi/build/koffi/win32_x64/koffi.node
+var koffi_default16;
+var init_koffi16 = __esm({
+  "node_modules/koffi/build/koffi/win32_x64/koffi.node"() {
+    koffi_default16 = "../koffi-IDX6JEDH.node";
+  }
+});
+
+// node-file:/Users/petetaylor/projects/tasker-systems/tasker-core/workers/typescript/node_modules/koffi/build/koffi/win32_x64/koffi.node
+var require_koffi16 = __commonJS2({
+  "node-file:/Users/petetaylor/projects/tasker-systems/tasker-core/workers/typescript/node_modules/koffi/build/koffi/win32_x64/koffi.node"(exports2, module2) {
+    init_koffi16();
+    try {
+      module2.exports = __require(koffi_default16);
+    } catch {
+    }
+  }
+});
+
+// node_modules/koffi/build/koffi/musl_arm64/koffi.node
+var koffi_default17;
+var init_koffi17 = __esm({
+  "node_modules/koffi/build/koffi/musl_arm64/koffi.node"() {
+    koffi_default17 = "../koffi-3HFAASOB.node";
+  }
+});
+
+// node-file:/Users/petetaylor/projects/tasker-systems/tasker-core/workers/typescript/node_modules/koffi/build/koffi/musl_arm64/koffi.node
+var require_koffi17 = __commonJS2({
+  "node-file:/Users/petetaylor/projects/tasker-systems/tasker-core/workers/typescript/node_modules/koffi/build/koffi/musl_arm64/koffi.node"(exports2, module2) {
+    init_koffi17();
+    try {
+      module2.exports = __require(koffi_default17);
+    } catch {
+    }
+  }
+});
+
+// node_modules/koffi/build/koffi/musl_x64/koffi.node
+var koffi_default18;
+var init_koffi18 = __esm({
+  "node_modules/koffi/build/koffi/musl_x64/koffi.node"() {
+    koffi_default18 = "../koffi-BMO5K7B3.node";
+  }
+});
+
+// node-file:/Users/petetaylor/projects/tasker-systems/tasker-core/workers/typescript/node_modules/koffi/build/koffi/musl_x64/koffi.node
+var require_koffi18 = __commonJS2({
+  "node-file:/Users/petetaylor/projects/tasker-systems/tasker-core/workers/typescript/node_modules/koffi/build/koffi/musl_x64/koffi.node"(exports2, module2) {
+    init_koffi18();
+    try {
+      module2.exports = __require(koffi_default18);
+    } catch {
+    }
+  }
+});
+
+// node_modules/koffi/index.js
+var require_koffi19 = __commonJS2({
+  "node_modules/koffi/index.js"(exports$1, module) {
+    var __getOwnPropNames = Object.getOwnPropertyNames;
+    var __commonJS = (cb, mod3) => function __require2() {
+      return mod3 || (0, cb[__getOwnPropNames(cb)[0]])((mod3 = { exports: {} }).exports, mod3), mod3.exports;
+    };
+    var require_tools = __commonJS({
+      "bin/Koffi/package/src/cnoke/src/tools.js"(exports2, module2) {
+        var crypto = __require("crypto");
+        var fs2 = __require("fs");
+        var http = __require("https");
+        var path2 = __require("path");
+        var zlib = __require("zlib");
+        async function download_http(url, dest) {
+          console.log(">> Downloading " + url);
+          let [tmp_name, file] = open_temporary_stream(dest);
+          try {
+            await new Promise((resolve, reject) => {
+              let request = http.get(url, (response) => {
+                if (response.statusCode != 200) {
+                  let err = new Error(`Download failed: ${response.statusMessage} [${response.statusCode}]`);
+                  err.code = response.statusCode;
+                  reject(err);
+                  return;
+                }
+                response.pipe(file);
+                file.on("finish", () => file.close(() => {
+                  try {
+                    fs2.renameSync(file.path, dest);
+                  } catch (err) {
+                    if (!fs2.existsSync(dest))
+                      reject(err);
+                  }
+                  resolve();
+                }));
+              });
+              request.on("error", reject);
+              file.on("error", reject);
+            });
+          } catch (err) {
+            file.close();
+            try {
+              fs2.unlinkSync(tmp_name);
+            } catch (err2) {
+              if (err2.code != "ENOENT")
+                throw err2;
+            }
+            throw err;
+          }
+        }
+        function open_temporary_stream(prefix) {
+          let buf = Buffer.allocUnsafe(4);
+          for (; ; ) {
+            try {
+              crypto.randomFillSync(buf);
+              let suffix = buf.toString("hex").padStart(8, "0");
+              let filename2 = `${prefix}.${suffix}`;
+              let file = fs2.createWriteStream(filename2, { flags: "wx", mode: 420 });
+              return [filename2, file];
+            } catch (err) {
+              if (err.code != "EEXIST")
+                throw err;
+            }
+          }
+        }
+        function extract_targz(filename2, dest_dir, strip = 0) {
+          let reader = fs2.createReadStream(filename2).pipe(zlib.createGunzip());
+          return new Promise((resolve, reject) => {
+            let header = null;
+            let extended = {};
+            reader.on("readable", () => {
+              try {
+                for (; ; ) {
+                  if (header == null) {
+                    let buf = reader.read(512);
+                    if (buf == null)
+                      break;
+                    if (!buf[0])
+                      continue;
+                    header = {
+                      filename: buf.toString("utf-8", 0, 100).replace(/\0/g, ""),
+                      mode: parseInt(buf.toString("ascii", 100, 109), 8),
+                      size: parseInt(buf.toString("ascii", 124, 137), 8),
+                      type: String.fromCharCode(buf[156])
+                    };
+                    Object.assign(header, extended);
+                    extended = {};
+                    header.filename = header.filename.replace(/\\/g, "/");
+                    if (!header.filename.length)
+                      throw new Error(`Insecure empty filename inside TAR archive`);
+                    if (path_is_absolute(header.filename[0]))
+                      throw new Error(`Insecure filename starting with / inside TAR archive`);
+                    if (path_has_dotdot(header.filename))
+                      throw new Error(`Insecure filename containing '..' inside TAR archive`);
+                    for (let i = 0; i < strip; i++)
+                      header.filename = header.filename.substr(header.filename.indexOf("/") + 1);
+                  }
+                  let aligned = Math.floor((header.size + 511) / 512) * 512;
+                  let data = header.size ? reader.read(aligned) : null;
+                  if (data == null) {
+                    if (header.size)
+                      break;
+                    data = Buffer.alloc(0);
+                  }
+                  data = data.subarray(0, header.size);
+                  if (header.type == "0" || header.type == "7") {
+                    let filename3 = dest_dir + "/" + header.filename;
+                    let dirname = path2.dirname(filename3);
+                    fs2.mkdirSync(dirname, { recursive: true, mode: 493 });
+                    fs2.writeFileSync(filename3, data, { mode: header.mode });
+                  } else if (header.type == "5") {
+                    let filename3 = dest_dir + "/" + header.filename;
+                    fs2.mkdirSync(filename3, { recursive: true, mode: header.mode });
+                  } else if (header.type == "L") {
+                    extended.filename = data.toString("utf-8").replace(/\0/g, "");
+                  } else if (header.type == "x") {
+                    let str = data.toString("utf-8");
+                    try {
+                      while (str.length) {
+                        let matches = str.match(/^([0-9]+) ([a-zA-Z0-9\._]+)=(.*)\n/);
+                        let skip = parseInt(matches[1], 10);
+                        let key = matches[2];
+                        let value = matches[3];
+                        switch (key) {
+                          case "path":
+                            {
+                              extended.filename = value;
+                            }
+                            break;
+                          case "size":
+                            {
+                              extended.size = parseInt(value, 10);
+                            }
+                            break;
+                        }
+                        str = str.substr(skip).trimStart();
+                      }
+                    } catch (err) {
+                      throw new Error("Malformed PAX entry");
+                    }
+                  }
+                  header = null;
+                }
+              } catch (err) {
+                reject(err);
+              }
+            });
+            reader.on("error", reject);
+            reader.on("end", resolve);
+          });
+        }
+        function path_is_absolute(path3) {
+          if (process.platform == "win32" && path3.match(/^[a-zA-Z]:/))
+            path3 = path3.substr(2);
+          return is_path_separator(path3[0]);
+        }
+        function path_has_dotdot(path3) {
+          let start = 0;
+          for (; ; ) {
+            let offset = path3.indexOf("..", start);
+            if (offset < 0)
+              break;
+            start = offset + 2;
+            if (offset && !is_path_separator(path3[offset - 1]))
+              continue;
+            if (offset + 2 < path3.length && !is_path_separator(path3[offset + 2]))
+              continue;
+            return true;
+          }
+          return false;
+        }
+        function is_path_separator(c) {
+          if (c == "/")
+            return true;
+          if (process.platform == "win32" && c == "\\")
+            return true;
+          return false;
+        }
+        function sync_files(src_dir, dest_dir) {
+          let keep = /* @__PURE__ */ new Set();
+          {
+            let entries = fs2.readdirSync(src_dir, { withFileTypes: true });
+            for (let entry of entries) {
+              if (!entry.isFile())
+                continue;
+              keep.add(entry.name);
+              fs2.copyFileSync(src_dir + `/${entry.name}`, dest_dir + `/${entry.name}`);
+            }
+          }
+          {
+            let entries = fs2.readdirSync(dest_dir, { withFileTypes: true });
+            for (let entry of entries) {
+              if (!entry.isFile())
+                continue;
+              if (keep.has(entry.name))
+                continue;
+              fs2.unlinkSync(dest_dir + `/${entry.name}`);
+            }
+          }
+        }
+        function determine_arch2() {
+          let arch = process.arch;
+          if (arch == "riscv32" || arch == "riscv64") {
+            let buf = read_file_header(process.execPath, 512);
+            let header = decode_elf_header(buf);
+            let float_abi = header.e_flags & 6;
+            switch (float_abi) {
+              case 0:
+                break;
+              case 2:
+                {
+                  arch += "f";
+                }
+                break;
+              case 4:
+                {
+                  arch += "d";
+                }
+                break;
+              case 6:
+                {
+                  arch += "q";
+                }
+                break;
+            }
+          } else if (arch == "arm") {
+            let buf = read_file_header(process.execPath, 512);
+            let header = decode_elf_header(buf);
+            if (header.e_flags & 1024) {
+              arch += "hf";
+            } else if (header.e_flags & 512) {
+              arch += "sf";
+            } else {
+              throw new Error("Unknown ARM floating-point ABI");
+            }
+          }
+          return arch;
+        }
+        function read_file_header(filename2, read) {
+          try {
+            let fd2 = fs2.openSync(filename2);
+            let buf = Buffer.allocUnsafe(read);
+            let len = fs2.readSync(fd2, buf);
+            return buf.subarray(0, len);
+          } finally {
+          }
+        }
+        function decode_elf_header(buf) {
+          let header = {};
+          if (buf.length < 16)
+            throw new Error("Truncated header");
+          if (buf[0] != 127 || buf[1] != 69 || buf[2] != 76 || buf[3] != 70)
+            throw new Error("Invalid magic number");
+          if (buf[6] != 1)
+            throw new Error("Invalid ELF version");
+          if (buf[5] != 1)
+            throw new Error("Big-endian architectures are not supported");
+          let machine = buf.readUInt16LE(18);
+          switch (machine) {
+            case 3:
+              {
+                header.e_machine = "ia32";
+              }
+              break;
+            case 40:
+              {
+                header.e_machine = "arm";
+              }
+              break;
+            case 62:
+              {
+                header.e_machine = "amd64";
+              }
+              break;
+            case 183:
+              {
+                header.e_machine = "arm64";
+              }
+              break;
+            case 243:
+              {
+                switch (buf[4]) {
+                  case 1:
+                    {
+                      header.e_machine = "riscv32";
+                    }
+                    break;
+                  case 2:
+                    {
+                      header.e_machine = "riscv64";
+                    }
+                    break;
+                }
+              }
+              break;
+            case 248:
+              {
+                switch (buf[4]) {
+                  case 1:
+                    {
+                      header.e_machine = "loong32";
+                    }
+                    break;
+                  case 2:
+                    {
+                      header.e_machine = "loong64";
+                    }
+                    break;
+                }
+              }
+              break;
+            default:
+              throw new Error("Unknown ELF machine type");
+          }
+          switch (buf[4]) {
+            case 1:
+              {
+                buf = buf.subarray(0, 68);
+                if (buf.length < 68)
+                  throw new Error("Truncated ELF header");
+                header.ei_class = 32;
+                header.e_flags = buf.readUInt32LE(36);
+              }
+              break;
+            case 2:
+              {
+                buf = buf.subarray(0, 120);
+                if (buf.length < 120)
+                  throw new Error("Truncated ELF header");
+                header.ei_class = 64;
+                header.e_flags = buf.readUInt32LE(48);
+              }
+              break;
+            default:
+              throw new Error("Invalid ELF class");
+          }
+          return header;
+        }
+        function unlink_recursive(path3) {
+          try {
+            if (fs2.rmSync != null) {
+              fs2.rmSync(path3, { recursive: true, maxRetries: process.platform == "win32" ? 3 : 0 });
+            } else {
+              fs2.rmdirSync(path3, { recursive: true, maxRetries: process.platform == "win32" ? 3 : 0 });
+            }
+          } catch (err) {
+            if (err.code !== "ENOENT")
+              throw err;
+          }
+        }
+        function get_napi_version2(napi, major) {
+          if (napi > 8)
+            return null;
+          const support = {
+            6: ["6.14.2", "6.14.2", "6.14.2"],
+            8: ["8.6.0", "8.10.0", "8.11.2"],
+            9: ["9.0.0", "9.3.0", "9.11.0"],
+            10: ["10.0.0", "10.0.0", "10.0.0", "10.16.0", "10.17.0", "10.20.0", "10.23.0"],
+            11: ["11.0.0", "11.0.0", "11.0.0", "11.8.0"],
+            12: ["12.0.0", "12.0.0", "12.0.0", "12.0.0", "12.11.0", "12.17.0", "12.19.0", "12.22.0"],
+            13: ["13.0.0", "13.0.0", "13.0.0", "13.0.0", "13.0.0"],
+            14: ["14.0.0", "14.0.0", "14.0.0", "14.0.0", "14.0.0", "14.0.0", "14.12.0", "14.17.0"],
+            15: ["15.0.0", "15.0.0", "15.0.0", "15.0.0", "15.0.0", "15.0.0", "15.0.0", "15.12.0"]
+          };
+          const max = Math.max(...Object.keys(support).map((k) => parseInt(k, 10)));
+          if (major > max)
+            return major + ".0.0";
+          if (support[major] == null)
+            return null;
+          let required = support[major][napi - 1] || null;
+          return required;
+        }
+        function cmp_version(ver1, ver2) {
+          ver1 = String(ver1).replace(/-.*$/, "").split(".").reduce((acc, v, idx) => acc + parseInt(v, 10) * Math.pow(10, 2 * (5 - idx)), 0);
+          ver2 = String(ver2).replace(/-.*$/, "").split(".").reduce((acc, v, idx) => acc + parseInt(v, 10) * Math.pow(10, 2 * (5 - idx)), 0);
+          let cmp = Math.min(Math.max(ver1 - ver2, -1), 1);
+          return cmp;
+        }
+        module2.exports = {
+          download_http,
+          extract_targz,
+          path_is_absolute,
+          path_has_dotdot,
+          sync_files,
+          determine_arch: determine_arch2,
+          unlink_recursive,
+          get_napi_version: get_napi_version2,
+          cmp_version
+        };
+      }
+    });
+    var require_package = __commonJS({
+      "bin/Koffi/package/src/koffi/package.json"(exports2, module2) {
+        module2.exports = {
+          name: "koffi",
+          version: "2.15.0",
+          description: "Fast and simple C FFI (foreign function interface) for Node.js",
+          keywords: [
+            "foreign",
+            "function",
+            "interface",
+            "ffi",
+            "binding",
+            "c",
+            "napi"
+          ],
+          repository: {
+            type: "git",
+            url: "https://github.com/Koromix/koffi"
+          },
+          homepage: "https://koffi.dev/",
+          author: {
+            name: "Niels Martign\xE8ne",
+            email: "niels.martignene@protonmail.com",
+            url: "https://koromix.dev/"
+          },
+          main: "./index.js",
+          types: "./index.d.ts",
+          scripts: {
+            test: "node tools/koffi.js test",
+            prepack: `echo 'Use "npm run package" instead' && false`,
+            prepublishOnly: `echo 'Use "npm run package" instead' && false`,
+            package: "node tools/koffi.js build"
+          },
+          license: "MIT",
+          cnoke: {
+            api: "../../vendor/node-api-headers",
+            output: "../../bin/Koffi/{{ platform }}_{{ arch }}",
+            node: 16,
+            napi: 8,
+            require: "./index.js"
+          },
+          funding: "https://buymeacoffee.com/koromix"
+        };
+      }
+    });
+    var require_init = __commonJS({
+      "bin/Koffi/package/src/koffi/src/init.js"(exports$1, module) {
+        var fs = __require("fs");
+        var path = __require("path");
+        var util = __require("util");
+        var { get_napi_version, determine_arch } = require_tools();
+        var pkg = require_package();
+        function detect() {
+          if (process.versions.napi == null || process.versions.napi < pkg.cnoke.napi) {
+            let major = parseInt(process.versions.node, 10);
+            let required = get_napi_version(pkg.cnoke.napi, major);
+            if (required != null) {
+              throw new Error(`This engine is based on Node ${process.versions.node}, but ${pkg.name} requires Node >= ${required} in the Node ${major}.x branch (N-API >= ${pkg.cnoke.napi})`);
+            } else {
+              throw new Error(`This engine is based on Node ${process.versions.node}, but ${pkg.name} does not support the Node ${major}.x branch (N-API < ${pkg.cnoke.napi})`);
+            }
+          }
+          let arch = determine_arch();
+          let triplet3 = `${process.platform}_${arch}`;
+          return triplet3;
+        }
+        function init(triplet, native) {
+          if (native == null) {
+            let roots = [path.join(__dirname, "..")];
+            let triplets = [triplet];
+            if (process.resourcesPath != null)
+              roots.push(process.resourcesPath);
+            if (triplet.startsWith("linux_")) {
+              let musl = triplet.replace(/^linux_/, "musl_");
+              triplets.push(musl);
+            }
+            let filenames = roots.flatMap((root) => triplets.flatMap((triplet3) => [
+              `${root}/build/koffi/${triplet3}/koffi.node`,
+              `${root}/koffi/${triplet3}/koffi.node`,
+              `${root}/node_modules/koffi/build/koffi/${triplet3}/koffi.node`,
+              `${root}/../../bin/Koffi/${triplet3}/koffi.node`
+            ]));
+            let first_err = null;
+            for (let filename of filenames) {
+              if (!fs.existsSync(filename))
+                continue;
+              try {
+                native = eval("require")(filename);
+              } catch (err) {
+                if (first_err == null)
+                  first_err = err;
+                continue;
+              }
+              break;
+            }
+            if (first_err != null)
+              throw first_err;
+          }
+          if (native == null)
+            throw new Error("Cannot find the native Koffi module; did you bundle it correctly?");
+          if (native.version != pkg.version)
+            throw new Error("Mismatched native Koffi modules");
+          let mod = wrap(native);
+          return mod;
+        }
+        function wrap(native3) {
+          let obj = {
+            ...native3,
+            // Deprecated functions
+            handle: util.deprecate(native3.opaque, "The koffi.handle() function was deprecated in Koffi 2.1, use koffi.opaque() instead", "KOFFI001"),
+            callback: util.deprecate(native3.proto, "The koffi.callback() function was deprecated in Koffi 2.4, use koffi.proto() instead", "KOFFI002")
+          };
+          obj.load = (...args) => {
+            let lib = native3.load(...args);
+            lib.cdecl = util.deprecate((...args2) => lib.func("__cdecl", ...args2), "The koffi.cdecl() function was deprecated in Koffi 2.7, use koffi.func(...) instead", "KOFFI003");
+            lib.stdcall = util.deprecate((...args2) => lib.func("__stdcall", ...args2), 'The koffi.stdcall() function was deprecated in Koffi 2.7, use koffi.func("__stdcall", ...) instead', "KOFFI004");
+            lib.fastcall = util.deprecate((...args2) => lib.func("__fastcall", ...args2), 'The koffi.fastcall() function was deprecated in Koffi 2.7, use koffi.func("__fastcall", ...) instead', "KOFFI005");
+            lib.thiscall = util.deprecate((...args2) => lib.func("__thiscall", ...args2), 'The koffi.thiscall() function was deprecated in Koffi 2.7, use koffi.func("__thiscall", ...) instead', "KOFFI006");
+            return lib;
+          };
+          return obj;
+        }
+        module.exports = {
+          detect,
+          init
+        };
+      }
+    });
+    var { detect: detect2, init: init2 } = require_init();
+    var triplet2 = detect2();
+    var native2 = null;
+    try {
+      switch (triplet2) {
+        case "darwin_arm64":
+          {
+            native2 = require_koffi();
+          }
+          break;
+        case "darwin_x64":
+          {
+            native2 = require_koffi2();
+          }
+          break;
+        case "freebsd_arm64":
+          {
+            native2 = require_koffi3();
+          }
+          break;
+        case "freebsd_ia32":
+          {
+            native2 = require_koffi4();
+          }
+          break;
+        case "freebsd_x64":
+          {
+            native2 = require_koffi5();
+          }
+          break;
+        case "linux_armhf":
+          {
+            native2 = require_koffi6();
+          }
+          break;
+        case "linux_arm64":
+          {
+            native2 = require_koffi7();
+          }
+          break;
+        case "linux_ia32":
+          {
+            native2 = require_koffi8();
+          }
+          break;
+        case "linux_loong64":
+          {
+            native2 = require_koffi9();
+          }
+          break;
+        case "linux_riscv64d":
+          {
+            native2 = require_koffi10();
+          }
+          break;
+        case "linux_x64":
+          {
+            native2 = require_koffi11();
+          }
+          break;
+        case "openbsd_ia32":
+          {
+            native2 = require_koffi12();
+          }
+          break;
+        case "openbsd_x64":
+          {
+            native2 = require_koffi13();
+          }
+          break;
+        case "win32_arm64":
+          {
+            native2 = require_koffi14();
+          }
+          break;
+        case "win32_ia32":
+          {
+            native2 = require_koffi15();
+          }
+          break;
+        case "win32_x64":
+          {
+            native2 = require_koffi16();
+          }
+          break;
+      }
+    } catch {
+      try {
+        switch (triplet2) {
+          case "linux_arm64":
+            {
+              native2 = require_koffi17();
+            }
+            break;
+          case "linux_x64":
+            {
+              native2 = require_koffi18();
+            }
+            break;
+        }
+      } catch {
+      }
+    }
+    var mod2 = init2(triplet2, native2);
+    module.exports = mod2;
+  }
+});
+
+// src/ffi/node-runtime.ts
+var node_runtime_exports = {};
+__export(node_runtime_exports, {
+  NodeRuntime: () => NodeRuntime
+});
+var NodeRuntime;
+var init_node_runtime = __esm({
+  "src/ffi/node-runtime.ts"() {
+    init_runtime_interface();
+    NodeRuntime = class extends BaseTaskerRuntime {
+      name = "node";
+      lib = null;
+      // biome-ignore lint/suspicious/noExplicitAny: koffi module type
+      koffi = null;
+      get isLoaded() {
+        return this.lib !== null;
+      }
+      async load(libraryPath) {
+        if (this.lib !== null) {
+          return;
+        }
+        const koffiModule = await Promise.resolve().then(() => __toESM(require_koffi19()));
+        this.koffi = koffiModule.default ?? koffiModule;
+        const lib = this.koffi.load(libraryPath);
+        this.lib = {
+          get_version: lib.func("void* get_version()"),
+          get_rust_version: lib.func("void* get_rust_version()"),
+          health_check: lib.func("int health_check()"),
+          is_worker_running: lib.func("int is_worker_running()"),
+          bootstrap_worker: lib.func("void* bootstrap_worker(str)"),
+          get_worker_status: lib.func("void* get_worker_status()"),
+          stop_worker: lib.func("void* stop_worker()"),
+          transition_to_graceful_shutdown: lib.func("void* transition_to_graceful_shutdown()"),
+          poll_step_events: lib.func("void* poll_step_events()"),
+          poll_in_process_events: lib.func("void* poll_in_process_events()"),
+          complete_step_event: lib.func("int complete_step_event(str, str)"),
+          checkpoint_yield_step_event: lib.func("int checkpoint_yield_step_event(str, str)"),
+          get_ffi_dispatch_metrics: lib.func("void* get_ffi_dispatch_metrics()"),
+          check_starvation_warnings: lib.func("void check_starvation_warnings()"),
+          cleanup_timeouts: lib.func("void cleanup_timeouts()"),
+          log_error: lib.func("void log_error(str, str)"),
+          log_warn: lib.func("void log_warn(str, str)"),
+          log_info: lib.func("void log_info(str, str)"),
+          log_debug: lib.func("void log_debug(str, str)"),
+          log_trace: lib.func("void log_trace(str, str)"),
+          free_rust_string: lib.func("void free_rust_string(void*)"),
+          // Client API functions (TAS-231)
+          client_create_task: lib.func("void* client_create_task(str)"),
+          client_get_task: lib.func("void* client_get_task(str)"),
+          client_list_tasks: lib.func("void* client_list_tasks(str)"),
+          client_cancel_task: lib.func("void* client_cancel_task(str)"),
+          client_list_task_steps: lib.func("void* client_list_task_steps(str)"),
+          client_get_step: lib.func("void* client_get_step(str, str)"),
+          client_get_step_audit_history: lib.func("void* client_get_step_audit_history(str, str)"),
+          client_health_check: lib.func("void* client_health_check()")
+        };
+      }
+      unload() {
+        this.lib = null;
+        this.koffi = null;
+      }
+      ensureLoaded() {
+        if (!this.lib) {
+          throw new Error("Native library not loaded. Call load() first.");
+        }
+        return this.lib;
+      }
+      /**
+       * Read a C string from a pointer and free the Rust-allocated memory.
+       *
+       * Uses koffi.decode with 'char' type and -1 length for null-terminated strings.
+       */
+      readAndFreeRustString(ptr) {
+        if (!ptr) return null;
+        const lib = this.ensureLoaded();
+        const str = this.koffi.decode(ptr, "char", -1);
+        lib.free_rust_string(ptr);
+        return str;
+      }
+      getVersion() {
+        const lib = this.ensureLoaded();
+        const ptr = lib.get_version();
+        return this.readAndFreeRustString(ptr) ?? "unknown";
+      }
+      getRustVersion() {
+        const lib = this.ensureLoaded();
+        const ptr = lib.get_rust_version();
+        return this.readAndFreeRustString(ptr) ?? "unknown";
+      }
+      healthCheck() {
+        const lib = this.ensureLoaded();
+        return lib.health_check() === 1;
+      }
+      bootstrapWorker(config) {
+        const lib = this.ensureLoaded();
+        const configJson = config ? this.toJson(config) : null;
+        const ptr = lib.bootstrap_worker(configJson);
+        const jsonStr = this.readAndFreeRustString(ptr);
+        const parsed = this.parseJson(jsonStr);
+        return parsed ?? {
+          success: false,
+          status: "error",
+          message: "Failed to parse bootstrap result",
+          error: "Invalid JSON response"
+        };
+      }
+      isWorkerRunning() {
+        const lib = this.ensureLoaded();
+        return lib.is_worker_running() === 1;
+      }
+      getWorkerStatus() {
+        const lib = this.ensureLoaded();
+        const ptr = lib.get_worker_status();
+        const jsonStr = this.readAndFreeRustString(ptr);
+        const parsed = this.parseJson(jsonStr);
+        return parsed ?? { success: false, running: false };
+      }
+      stopWorker() {
+        const lib = this.ensureLoaded();
+        const ptr = lib.stop_worker();
+        const jsonStr = this.readAndFreeRustString(ptr);
+        const parsed = this.parseJson(jsonStr);
+        return parsed ?? {
+          success: false,
+          status: "error",
+          message: "Failed to parse stop result",
+          error: "Invalid JSON response"
+        };
+      }
+      transitionToGracefulShutdown() {
+        const lib = this.ensureLoaded();
+        const ptr = lib.transition_to_graceful_shutdown();
+        const jsonStr = this.readAndFreeRustString(ptr);
+        const parsed = this.parseJson(jsonStr);
+        return parsed ?? {
+          success: false,
+          status: "error",
+          message: "Failed to parse shutdown result",
+          error: "Invalid JSON response"
+        };
+      }
+      pollStepEvents() {
+        const lib = this.ensureLoaded();
+        const ptr = lib.poll_step_events();
+        if (!ptr) return null;
+        const jsonStr = this.readAndFreeRustString(ptr);
+        return this.parseJson(jsonStr);
+      }
+      pollInProcessEvents() {
+        const lib = this.ensureLoaded();
+        const ptr = lib.poll_in_process_events();
+        if (!ptr) return null;
+        const jsonStr = this.readAndFreeRustString(ptr);
+        return this.parseJson(jsonStr);
+      }
+      completeStepEvent(eventId, result) {
+        const lib = this.ensureLoaded();
+        return lib.complete_step_event(eventId, this.toJson(result)) === 1;
+      }
+      checkpointYieldStepEvent(eventId, checkpointData) {
+        const lib = this.ensureLoaded();
+        return lib.checkpoint_yield_step_event(eventId, this.toJson(checkpointData)) === 1;
+      }
+      getFfiDispatchMetrics() {
+        const lib = this.ensureLoaded();
+        const ptr = lib.get_ffi_dispatch_metrics();
+        const jsonStr = this.readAndFreeRustString(ptr);
+        const parsed = this.parseJson(jsonStr);
+        if (parsed && typeof parsed.pending_count === "number") {
+          return parsed;
+        }
+        return {
+          pending_count: 0,
+          starvation_detected: false,
+          starving_event_count: 0,
+          oldest_pending_age_ms: null,
+          newest_pending_age_ms: null,
+          oldest_event_id: null
+        };
+      }
+      checkStarvationWarnings() {
+        const lib = this.ensureLoaded();
+        lib.check_starvation_warnings();
+      }
+      cleanupTimeouts() {
+        const lib = this.ensureLoaded();
+        lib.cleanup_timeouts();
+      }
+      logError(message, fields) {
+        const lib = this.ensureLoaded();
+        lib.log_error(message, fields ? this.toJson(fields) : null);
+      }
+      logWarn(message, fields) {
+        const lib = this.ensureLoaded();
+        lib.log_warn(message, fields ? this.toJson(fields) : null);
+      }
+      logInfo(message, fields) {
+        const lib = this.ensureLoaded();
+        lib.log_info(message, fields ? this.toJson(fields) : null);
+      }
+      logDebug(message, fields) {
+        const lib = this.ensureLoaded();
+        lib.log_debug(message, fields ? this.toJson(fields) : null);
+      }
+      logTrace(message, fields) {
+        const lib = this.ensureLoaded();
+        lib.log_trace(message, fields ? this.toJson(fields) : null);
+      }
+      // ==========================================================================
+      // Client API Operations (TAS-231)
+      // ==========================================================================
+      parseClientResult(ptr) {
+        const jsonStr = this.readAndFreeRustString(ptr);
+        const parsed = this.parseJson(jsonStr);
+        return parsed ?? {
+          success: false,
+          data: null,
+          error: "Failed to parse client result",
+          recoverable: null
+        };
+      }
+      clientCreateTask(requestJson) {
+        const lib = this.ensureLoaded();
+        const ptr = lib.client_create_task(requestJson);
+        return this.parseClientResult(ptr);
+      }
+      clientGetTask(taskUuid) {
+        const lib = this.ensureLoaded();
+        const ptr = lib.client_get_task(taskUuid);
+        return this.parseClientResult(ptr);
+      }
+      clientListTasks(paramsJson) {
+        const lib = this.ensureLoaded();
+        const ptr = lib.client_list_tasks(paramsJson);
+        return this.parseClientResult(ptr);
+      }
+      clientCancelTask(taskUuid) {
+        const lib = this.ensureLoaded();
+        const ptr = lib.client_cancel_task(taskUuid);
+        return this.parseClientResult(ptr);
+      }
+      clientListTaskSteps(taskUuid) {
+        const lib = this.ensureLoaded();
+        const ptr = lib.client_list_task_steps(taskUuid);
+        return this.parseClientResult(ptr);
+      }
+      clientGetStep(taskUuid, stepUuid) {
+        const lib = this.ensureLoaded();
+        const ptr = lib.client_get_step(taskUuid, stepUuid);
+        return this.parseClientResult(ptr);
+      }
+      clientGetStepAuditHistory(taskUuid, stepUuid) {
+        const lib = this.ensureLoaded();
+        const ptr = lib.client_get_step_audit_history(taskUuid, stepUuid);
+        return this.parseClientResult(ptr);
+      }
+      clientHealthCheck() {
+        const lib = this.ensureLoaded();
+        const ptr = lib.client_health_check();
+        return this.parseClientResult(ptr);
+      }
+    };
+  }
+});
+
+// src/ffi/deno-runtime.ts
+var deno_runtime_exports = {};
+__export(deno_runtime_exports, {
+  DenoRuntime: () => DenoRuntime
+});
+var DenoRuntime;
+var init_deno_runtime = __esm({
+  "src/ffi/deno-runtime.ts"() {
+    init_runtime_interface();
+    DenoRuntime = class extends BaseTaskerRuntime {
+      name = "deno";
+      lib = null;
+      encoder = new TextEncoder();
+      get isLoaded() {
+        return this.lib !== null;
+      }
+      async load(libraryPath) {
+        if (this.lib !== null) {
+          return;
+        }
+        if (typeof Deno === "undefined") {
+          throw new Error("Deno runtime not detected");
+        }
+        this.lib = Deno.dlopen(libraryPath, {
+          get_version: {
+            parameters: [],
+            result: "pointer"
+          },
+          get_rust_version: {
+            parameters: [],
+            result: "pointer"
+          },
+          health_check: {
+            parameters: [],
+            result: "i32"
+          },
+          is_worker_running: {
+            parameters: [],
+            result: "i32"
+          },
+          bootstrap_worker: {
+            parameters: ["buffer"],
+            result: "pointer"
+          },
+          get_worker_status: {
+            parameters: [],
+            result: "pointer"
+          },
+          stop_worker: {
+            parameters: [],
+            result: "pointer"
+          },
+          transition_to_graceful_shutdown: {
+            parameters: [],
+            result: "pointer"
+          },
+          poll_step_events: {
+            parameters: [],
+            result: "pointer"
+          },
+          poll_in_process_events: {
+            parameters: [],
+            result: "pointer"
+          },
+          complete_step_event: {
+            parameters: ["buffer", "buffer"],
+            result: "i32"
+          },
+          checkpoint_yield_step_event: {
+            parameters: ["buffer", "buffer"],
+            result: "i32"
+          },
+          get_ffi_dispatch_metrics: {
+            parameters: [],
+            result: "pointer"
+          },
+          check_starvation_warnings: {
+            parameters: [],
+            result: "void"
+          },
+          cleanup_timeouts: {
+            parameters: [],
+            result: "void"
+          },
+          log_error: {
+            parameters: ["buffer", "buffer"],
+            result: "void"
+          },
+          log_warn: {
+            parameters: ["buffer", "buffer"],
+            result: "void"
+          },
+          log_info: {
+            parameters: ["buffer", "buffer"],
+            result: "void"
+          },
+          log_debug: {
+            parameters: ["buffer", "buffer"],
+            result: "void"
+          },
+          log_trace: {
+            parameters: ["buffer", "buffer"],
+            result: "void"
+          },
+          free_rust_string: {
+            parameters: ["pointer"],
+            result: "void"
+          },
+          // Client API functions (TAS-231)
+          client_create_task: {
+            parameters: ["buffer"],
+            result: "pointer"
+          },
+          client_get_task: {
+            parameters: ["buffer"],
+            result: "pointer"
+          },
+          client_list_tasks: {
+            parameters: ["buffer"],
+            result: "pointer"
+          },
+          client_cancel_task: {
+            parameters: ["buffer"],
+            result: "pointer"
+          },
+          client_list_task_steps: {
+            parameters: ["buffer"],
+            result: "pointer"
+          },
+          client_get_step: {
+            parameters: ["buffer", "buffer"],
+            result: "pointer"
+          },
+          client_get_step_audit_history: {
+            parameters: ["buffer", "buffer"],
+            result: "pointer"
+          },
+          client_health_check: {
+            parameters: [],
+            result: "pointer"
+          }
+        });
+      }
+      unload() {
+        if (this.lib) {
+          this.lib.close();
+          this.lib = null;
+        }
+      }
+      ensureLoaded() {
+        if (!this.lib) {
+          throw new Error("Native library not loaded. Call load() first.");
+        }
+        return this.lib.symbols;
+      }
+      /**
+       * Creates a null-terminated C string buffer.
+       * With 'buffer' FFI type, we return Uint8Array directly.
+       */
+      toCString(str) {
+        return this.encoder.encode(`${str}\0`);
+      }
+      // biome-ignore lint/suspicious/noExplicitAny: Deno PointerValue type
+      fromCString(ptr) {
+        if (ptr === null || Deno.UnsafePointer.equals(ptr, null)) {
+          return null;
+        }
+        const view = new Deno.UnsafePointerView(ptr);
+        return view.getCString();
+      }
+      getVersion() {
+        const symbols = this.ensureLoaded();
+        const result = symbols.get_version();
+        const version = this.fromCString(result) ?? "unknown";
+        if (result !== null) symbols.free_rust_string(result);
+        return version;
+      }
+      getRustVersion() {
+        const symbols = this.ensureLoaded();
+        const result = symbols.get_rust_version();
+        const version = this.fromCString(result) ?? "unknown";
+        if (result !== null) symbols.free_rust_string(result);
+        return version;
+      }
+      healthCheck() {
+        const symbols = this.ensureLoaded();
+        return symbols.health_check() === 1;
+      }
+      bootstrapWorker(config) {
+        const symbols = this.ensureLoaded();
+        const configBuf = config ? this.toCString(this.toJson(config)) : null;
+        const result = symbols.bootstrap_worker(configBuf);
+        const jsonStr = this.fromCString(result);
+        if (result !== null) symbols.free_rust_string(result);
+        const parsed = this.parseJson(jsonStr);
+        return parsed ?? {
+          success: false,
+          status: "error",
+          message: "Failed to parse bootstrap result",
+          error: "Invalid JSON response"
+        };
+      }
+      isWorkerRunning() {
+        const symbols = this.ensureLoaded();
+        return symbols.is_worker_running() === 1;
+      }
+      getWorkerStatus() {
+        const symbols = this.ensureLoaded();
+        const result = symbols.get_worker_status();
+        const jsonStr = this.fromCString(result);
+        if (result !== null) symbols.free_rust_string(result);
+        const parsed = this.parseJson(jsonStr);
+        return parsed ?? { success: false, running: false };
+      }
+      stopWorker() {
+        const symbols = this.ensureLoaded();
+        const result = symbols.stop_worker();
+        const jsonStr = this.fromCString(result);
+        if (result !== null) symbols.free_rust_string(result);
+        const parsed = this.parseJson(jsonStr);
+        return parsed ?? {
+          success: false,
+          status: "error",
+          message: "Failed to parse stop result",
+          error: "Invalid JSON response"
+        };
+      }
+      transitionToGracefulShutdown() {
+        const symbols = this.ensureLoaded();
+        const result = symbols.transition_to_graceful_shutdown();
+        const jsonStr = this.fromCString(result);
+        if (result !== null) symbols.free_rust_string(result);
+        const parsed = this.parseJson(jsonStr);
+        return parsed ?? {
+          success: false,
+          status: "error",
+          message: "Failed to parse shutdown result",
+          error: "Invalid JSON response"
+        };
+      }
+      pollStepEvents() {
+        const symbols = this.ensureLoaded();
+        const result = symbols.poll_step_events();
+        if (result === null || Deno.UnsafePointer.equals(result, null)) {
+          return null;
+        }
+        const jsonStr = this.fromCString(result);
+        symbols.free_rust_string(result);
+        return this.parseJson(jsonStr);
+      }
+      pollInProcessEvents() {
+        const symbols = this.ensureLoaded();
+        const result = symbols.poll_in_process_events();
+        if (result === null || Deno.UnsafePointer.equals(result, null)) {
+          return null;
+        }
+        const jsonStr = this.fromCString(result);
+        symbols.free_rust_string(result);
+        return this.parseJson(jsonStr);
+      }
+      completeStepEvent(eventId, result) {
+        const symbols = this.ensureLoaded();
+        const eventIdBuf = this.toCString(eventId);
+        const resultJsonBuf = this.toCString(this.toJson(result));
+        return symbols.complete_step_event(eventIdBuf, resultJsonBuf) === 1;
+      }
+      checkpointYieldStepEvent(eventId, checkpointData) {
+        const symbols = this.ensureLoaded();
+        const eventIdBuf = this.toCString(eventId);
+        const checkpointJsonBuf = this.toCString(this.toJson(checkpointData));
+        return symbols.checkpoint_yield_step_event(eventIdBuf, checkpointJsonBuf) === 1;
+      }
+      getFfiDispatchMetrics() {
+        const symbols = this.ensureLoaded();
+        const result = symbols.get_ffi_dispatch_metrics();
+        const jsonStr = this.fromCString(result);
+        if (result !== null) symbols.free_rust_string(result);
+        const parsed = this.parseJson(jsonStr);
+        if (parsed && typeof parsed.pending_count === "number") {
+          return parsed;
+        }
+        return {
+          pending_count: 0,
+          starvation_detected: false,
+          starving_event_count: 0,
+          oldest_pending_age_ms: null,
+          newest_pending_age_ms: null,
+          oldest_event_id: null
+        };
+      }
+      checkStarvationWarnings() {
+        const symbols = this.ensureLoaded();
+        symbols.check_starvation_warnings();
+      }
+      cleanupTimeouts() {
+        const symbols = this.ensureLoaded();
+        symbols.cleanup_timeouts();
+      }
+      logError(message, fields) {
+        const symbols = this.ensureLoaded();
+        const msgBuf = this.toCString(message);
+        const fieldsBuf = fields ? this.toCString(this.toJson(fields)) : null;
+        symbols.log_error(msgBuf, fieldsBuf);
+      }
+      logWarn(message, fields) {
+        const symbols = this.ensureLoaded();
+        const msgBuf = this.toCString(message);
+        const fieldsBuf = fields ? this.toCString(this.toJson(fields)) : null;
+        symbols.log_warn(msgBuf, fieldsBuf);
+      }
+      logInfo(message, fields) {
+        const symbols = this.ensureLoaded();
+        const msgBuf = this.toCString(message);
+        const fieldsBuf = fields ? this.toCString(this.toJson(fields)) : null;
+        symbols.log_info(msgBuf, fieldsBuf);
+      }
+      logDebug(message, fields) {
+        const symbols = this.ensureLoaded();
+        const msgBuf = this.toCString(message);
+        const fieldsBuf = fields ? this.toCString(this.toJson(fields)) : null;
+        symbols.log_debug(msgBuf, fieldsBuf);
+      }
+      logTrace(message, fields) {
+        const symbols = this.ensureLoaded();
+        const msgBuf = this.toCString(message);
+        const fieldsBuf = fields ? this.toCString(this.toJson(fields)) : null;
+        symbols.log_trace(msgBuf, fieldsBuf);
+      }
+      // ==========================================================================
+      // Client API Operations (TAS-231)
+      // ==========================================================================
+      parseClientResult(result) {
+        const jsonStr = this.fromCString(result);
+        if (result !== null) this.ensureLoaded().free_rust_string(result);
+        const parsed = this.parseJson(jsonStr);
+        return parsed ?? {
+          success: false,
+          data: null,
+          error: "Failed to parse client result",
+          recoverable: null
+        };
+      }
+      clientCreateTask(requestJson) {
+        const symbols = this.ensureLoaded();
+        const buf = this.toCString(requestJson);
+        const result = symbols.client_create_task(buf);
+        return this.parseClientResult(result);
+      }
+      clientGetTask(taskUuid) {
+        const symbols = this.ensureLoaded();
+        const buf = this.toCString(taskUuid);
+        const result = symbols.client_get_task(buf);
+        return this.parseClientResult(result);
+      }
+      clientListTasks(paramsJson) {
+        const symbols = this.ensureLoaded();
+        const buf = this.toCString(paramsJson);
+        const result = symbols.client_list_tasks(buf);
+        return this.parseClientResult(result);
+      }
+      clientCancelTask(taskUuid) {
+        const symbols = this.ensureLoaded();
+        const buf = this.toCString(taskUuid);
+        const result = symbols.client_cancel_task(buf);
+        return this.parseClientResult(result);
+      }
+      clientListTaskSteps(taskUuid) {
+        const symbols = this.ensureLoaded();
+        const buf = this.toCString(taskUuid);
+        const result = symbols.client_list_task_steps(buf);
+        return this.parseClientResult(result);
+      }
+      clientGetStep(taskUuid, stepUuid) {
+        const symbols = this.ensureLoaded();
+        const tBuf = this.toCString(taskUuid);
+        const sBuf = this.toCString(stepUuid);
+        const result = symbols.client_get_step(tBuf, sBuf);
+        return this.parseClientResult(result);
+      }
+      clientGetStepAuditHistory(taskUuid, stepUuid) {
+        const symbols = this.ensureLoaded();
+        const tBuf = this.toCString(taskUuid);
+        const sBuf = this.toCString(stepUuid);
+        const result = symbols.client_get_step_audit_history(tBuf, sBuf);
+        return this.parseClientResult(result);
+      }
+      clientHealthCheck() {
+        const symbols = this.ensureLoaded();
+        const result = symbols.client_health_check();
+        return this.parseClientResult(result);
+      }
+    };
+  }
+});
+
+// src/ffi/bun-runtime.ts
+init_node_runtime();
+var BunRuntime = class extends NodeRuntime {
+  name = "bun";
+};
+
+// src/ffi/index.ts
+init_deno_runtime();
+
+// src/ffi/runtime.ts
+var cachedRuntimeType = null;
+function detectRuntime() {
+  if (cachedRuntimeType !== null) {
+    return cachedRuntimeType;
+  }
+  if (typeof globalThis !== "undefined" && "Bun" in globalThis) {
+    cachedRuntimeType = "bun";
+    return "bun";
+  }
+  if (typeof globalThis !== "undefined" && "Deno" in globalThis) {
+    cachedRuntimeType = "deno";
+    return "deno";
+  }
+  if (typeof process !== "undefined" && process.versions && process.versions.node) {
+    cachedRuntimeType = "node";
+    return "node";
+  }
+  cachedRuntimeType = "unknown";
+  return "unknown";
+}
+function isBun() {
+  return detectRuntime() === "bun";
+}
+function isNode() {
+  return detectRuntime() === "node";
+}
+function isDeno() {
+  return detectRuntime() === "deno";
+}
+function getRuntimeInfo() {
+  const type = detectRuntime();
+  switch (type) {
+    case "bun": {
+      const Bun = globalThis.Bun;
+      return {
+        type: "bun",
+        version: Bun?.version ?? "unknown",
+        platform: process?.platform ?? "unknown",
+        arch: process?.arch ?? "unknown"
+      };
+    }
+    case "deno": {
+      const Deno2 = globalThis.Deno;
+      return {
+        type: "deno",
+        version: Deno2?.version?.deno ?? "unknown",
+        platform: Deno2?.build?.os ?? "unknown",
+        arch: Deno2?.build?.arch ?? "unknown"
+      };
+    }
+    case "node":
+      return {
+        type: "node",
+        version: process.versions.node,
+        platform: process.platform,
+        arch: process.arch
+      };
+    default:
+      return {
+        type: "unknown",
+        version: "unknown",
+        platform: "unknown",
+        arch: "unknown"
+      };
+  }
+}
+function getLibraryFilename() {
+  const platform = process?.platform ?? "unknown";
+  switch (platform) {
+    case "darwin":
+      return "libtasker_ts.dylib";
+    case "linux":
+      return "libtasker_ts.so";
+    case "win32":
+      return "tasker_ts.dll";
+    default:
+      throw new Error(`Unsupported platform: ${platform}`);
+  }
+}
+function getLibraryPath(basePath) {
+  const envPath = process.env.TASKER_FFI_LIBRARY_PATH;
+  if (envPath) {
+    return envPath;
+  }
+  if (basePath) {
+    return `${basePath}/${getLibraryFilename()}`;
+  }
+  throw new Error(
+    "FFI library path not configured. Set TASKER_FFI_LIBRARY_PATH environment variable.\nExample: export TASKER_FFI_LIBRARY_PATH=/path/to/target/debug/libtasker_ts.dylib"
+  );
+}
+
+// src/ffi/ffi-layer.ts
+var FfiLayer = class _FfiLayer {
+  runtime = null;
+  libraryPath = null;
+  runtimeType;
+  configuredLibraryPath;
+  /**
+   * Create a new FfiLayer.
+   *
+   * @param config - Optional configuration for runtime type and library path
+   */
+  constructor(config = {}) {
+    this.runtimeType = config.runtimeType ?? detectRuntime();
+    this.configuredLibraryPath = config.libraryPath;
+  }
+  /**
+   * Load the FFI library.
+   *
+   * Discovers and loads the native library for the current runtime.
+   *
+   * @param customPath - Optional override for library path (takes precedence over config)
+   * @throws Error if library not found or failed to load
+   */
+  async load(customPath) {
+    if (this.runtime?.isLoaded) {
+      return;
+    }
+    const path2 = customPath ?? this.configuredLibraryPath ?? this.discoverLibraryPath();
+    if (!path2) {
+      throw new Error(
+        "FFI library not found. TASKER_FFI_LIBRARY_PATH environment variable must be set to the path of the compiled library.\nExample: export TASKER_FFI_LIBRARY_PATH=/path/to/target/debug/libtasker_ts.dylib\nBuild the library with: cargo build -p tasker-ts"
+      );
+    }
+    this.runtime = await this.createRuntime();
+    await this.runtime.load(path2);
+    this.libraryPath = path2;
+  }
+  /**
+   * Unload the FFI library and release resources.
+   *
+   * Safe to call even if not loaded.
+   */
+  async unload() {
+    if (this.runtime?.isLoaded) {
+      this.runtime.unload();
+    }
+    this.runtime = null;
+    this.libraryPath = null;
+  }
+  /**
+   * Check if the FFI library is loaded.
+   */
+  isLoaded() {
+    return this.runtime?.isLoaded ?? false;
+  }
+  /**
+   * Get the loaded runtime.
+   *
+   * @throws Error if runtime is not loaded
+   */
+  getRuntime() {
+    if (!this.runtime?.isLoaded) {
+      throw new Error("FFI not loaded. Call load() first.");
+    }
+    return this.runtime;
+  }
+  /**
+   * Get the path to the loaded library.
+   */
+  getLibraryPath() {
+    return this.libraryPath;
+  }
+  /**
+   * Get the detected runtime type.
+   */
+  getRuntimeType() {
+    return this.runtimeType;
+  }
+  /**
+   * Find the FFI library path.
+   *
+   * Static method for finding the library path without creating an instance.
+   * Useful for test utilities and pre-flight checks.
+   *
+   * REQUIRES: TASKER_FFI_LIBRARY_PATH environment variable to be set.
+   * This explicit requirement prevents confusion from automatic debug/release
+   * library discovery and ensures intentional configuration at build/runtime.
+   *
+   * @param _callerDir Deprecated parameter, kept for API compatibility
+   * @returns Path to the library if found and exists, null otherwise
+   */
+  static findLibraryPath(_callerDir) {
+    const envPath = process.env.TASKER_FFI_LIBRARY_PATH;
+    if (!envPath) {
+      return null;
+    }
+    if (!existsSync(envPath)) {
+      console.warn(`TASKER_FFI_LIBRARY_PATH is set to "${envPath}" but the file does not exist`);
+      return null;
+    }
+    return envPath;
+  }
+  /**
+   * Discover the FFI library path.
+   *
+   * Instance method that delegates to the static findLibraryPath.
+   */
+  discoverLibraryPath() {
+    return _FfiLayer.findLibraryPath();
+  }
+  /**
+   * Create a runtime adapter for the configured runtime type.
+   *
+   * NOTE: We use koffi (NodeRuntime) for both Node.js and Bun because:
+   * - bun:ffi is experimental with known bugs (per Bun docs)
+   * - koffi is stable and works with both Node.js and Bun via Node-API
+   * - See: https://bun.sh/docs/runtime/node-api
+   */
+  async createRuntime() {
+    switch (this.runtimeType) {
+      case "bun":
+      case "node": {
+        const { NodeRuntime: NodeRuntime2 } = await Promise.resolve().then(() => (init_node_runtime(), node_runtime_exports));
+        return new NodeRuntime2();
+      }
+      case "deno": {
+        const { DenoRuntime: DenoRuntime2 } = await Promise.resolve().then(() => (init_deno_runtime(), deno_runtime_exports));
+        return new DenoRuntime2();
+      }
+      default:
+        throw new Error(
+          `Unsupported runtime: ${this.runtimeType}. Tasker TypeScript worker requires Bun, Node.js, or Deno.`
+        );
+    }
+  }
+};
+
+// src/ffi/index.ts
+init_node_runtime();
+init_runtime_interface();
+
+export { BaseTaskerRuntime, BunRuntime, DenoRuntime, FfiLayer, NodeRuntime, detectRuntime, getLibraryPath, getRuntimeInfo, isBun, isDeno, isNode };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map