relaxnative 0.1.0-beta.1

package/dist/chunk-HDIVY47T.js

@@ -0,0 +1,287 @@
+// src/worker/workerPool.ts
+import { Worker } from "worker_threads";
+import { existsSync } from "fs";
+var WORKER_ENTRY_TS_URL = new URL(
+  "./workerEntry.vitest.ts",
+  import.meta.url
+);
+var WORKER_ENTRY_JS_URL = new URL("./workerEntry.js", import.meta.url);
+var worker = null;
+var seq = 0;
+var pending = /* @__PURE__ */ new Map();
+function getWorker() {
+  if (!worker) {
+    if (existsSync(WORKER_ENTRY_JS_URL)) {
+      worker = new Worker(WORKER_ENTRY_JS_URL, {
+        env: { ...process.env }
+      });
+    } else {
+      const entryHref = WORKER_ENTRY_TS_URL.href;
+      const bootstrap = `import(${JSON.stringify(entryHref)});`;
+      worker = new Worker(bootstrap, {
+        eval: true,
+        env: { ...process.env }
+      });
+    }
+    worker.on("message", (msg) => {
+      const resolve = pending.get(msg.id);
+      if (resolve) {
+        resolve(msg);
+        pending.delete(msg.id);
+      }
+    });
+  }
+  return worker;
+}
+function runInWorker(req) {
+  const id = ++seq;
+  const w = getWorker();
+  return new Promise((resolve, reject) => {
+    pending.set(id, (res) => {
+      if (res.error) {
+        const err = new Error(res.error + (res.errorCallsite ? `
+--- remote callsite ---
+${res.errorCallsite}` : ""));
+        reject(err);
+      } else resolve(res.result);
+    });
+    w.postMessage({ ...req, id });
+  });
+}
+
+// src/dx/logger.ts
+var enabled = false;
+function isDebugEnabled() {
+  return enabled || process.env.RELAXNATIVE_DEBUG === "1";
+}
+function logDebug(...args) {
+  if (!isDebugEnabled()) return;
+  console.log("[relaxnative]", ...args);
+}
+
+// src/utils/callsite.ts
+function captureCallsite() {
+  const err = new Error();
+  if (!err.stack) return void 0;
+  const parts = err.stack.split("\n");
+  if (parts.length <= 2) return err.stack;
+  return parts.slice(2).join("\n");
+}
+
+// src/worker/workerClient.ts
+function callAsync(libPath, bindings, fn, args) {
+  const callsite = captureCallsite();
+  logDebug("worker dispatch", { fn, callsite: !!callsite });
+  return runInWorker({ libPath, bindings, fn, args, callsite });
+}
+
+// src/worker/processClient.ts
+import { fork } from "child_process";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+var ProcessIsolationError = class extends Error {
+  code;
+  details;
+  constructor(code, message, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+  }
+};
+var child = null;
+var seq2 = 0;
+var pending2 = /* @__PURE__ */ new Map();
+function helperEntryPath() {
+  const here = dirname(fileURLToPath(import.meta.url));
+  const pkgRoot = join(here, "..", "..");
+  const distEntry = join(pkgRoot, "dist", "worker", "processEntry.js");
+  return { distEntry, pkgRoot };
+}
+function startChild() {
+  if (child && child.connected) return child;
+  const { distEntry } = helperEntryPath();
+  const entry = distEntry;
+  const cp = fork(entry, {
+    stdio: ["ignore", "inherit", "inherit", "ipc"],
+    env: {
+      ...process.env,
+      RELAXNATIVE_PROCESS_ISOLATION: "1"
+    }
+  });
+  cp.on("message", (msg) => {
+    if (!msg || typeof msg.id !== "number") return;
+    const p = pending2.get(msg.id);
+    if (!p) return;
+    if (p.cp !== cp) return;
+    pending2.delete(msg.id);
+    const res = msg;
+    if (res.ok) p.resolve(res.result);
+    else {
+      const details = [res.error.message];
+      if (res.error.callsite) details.push("\n--- remote callsite ---\n" + res.error.callsite);
+      const err = new Error(details.join("\n"));
+      err.name = res.error.name;
+      err.stack = res.error.stack;
+      p.reject(err);
+    }
+  });
+  const rejectAll = (reason) => {
+    for (const [id, p] of pending2) {
+      if (p.cp !== cp) continue;
+      pending2.delete(id);
+      p.reject(reason);
+    }
+  };
+  cp.on("exit", (code, signal) => {
+    if (child === cp) child = null;
+    const reason = new ProcessIsolationError(
+      signal ? "ISOLATED_PROCESS_CRASH" : "ISOLATED_PROCESS_EXIT",
+      `Isolated runtime exited (code=${code}, signal=${signal ?? "none"})`,
+      { code, signal }
+    );
+    rejectAll(reason);
+  });
+  cp.on("error", (err) => {
+    const reason = new ProcessIsolationError(
+      "ISOLATED_PROCESS_START_FAILED",
+      `Failed to start isolated runtime: ${String(err)}`,
+      { err }
+    );
+    child = null;
+    rejectAll(reason);
+  });
+  child = cp;
+  return cp;
+}
+async function ping(cp) {
+  const id = ++seq2;
+  const req = { id, type: "ping" };
+  return new Promise((resolve, reject) => {
+    pending2.set(id, { resolve, reject, cp });
+    cp.send(req);
+  });
+}
+async function callIsolated(libPath, bindings, fn, args, safety, callsite) {
+  const cp = startChild();
+  await ping(cp);
+  const id = ++seq2;
+  const req = {
+    id,
+    type: "call",
+    libPath,
+    bindings,
+    safety,
+    fn,
+    args,
+    // forward the captured JS callsite for richer crash diagnostics
+    ...callsite ? { callsite } : {}
+  };
+  const timeoutMs = safety?.limits?.timeoutMs;
+  const baseCall = new Promise((resolve, reject) => {
+    let t = null;
+    let timedOut = false;
+    const wrappedResolve = (v) => {
+      if (timedOut) return;
+      if (t) clearTimeout(t);
+      resolve(v);
+    };
+    const wrappedReject = (e) => {
+      if (timedOut) return;
+      if (t) clearTimeout(t);
+      reject(e);
+    };
+    if (typeof timeoutMs === "number" && timeoutMs > 0) {
+      t = setTimeout(() => {
+        timedOut = true;
+        pending2.delete(id);
+        try {
+          cp.kill();
+        } catch {
+        }
+        wrappedReject(
+          new ProcessIsolationError(
+            "ISOLATED_PROCESS_CRASH",
+            `Isolated runtime exceeded timeout (${timeoutMs}ms)`,
+            { timeoutMs }
+          )
+        );
+      }, timeoutMs);
+    }
+    pending2.set(id, { resolve: wrappedResolve, reject: wrappedReject, cp });
+    cp.send(req);
+  });
+  if (typeof timeoutMs === "number" && timeoutMs > 0) {
+    return Promise.race([
+      baseCall,
+      new Promise((_, reject) => {
+        setTimeout(() => {
+          reject(
+            new ProcessIsolationError(
+              "ISOLATED_PROCESS_CRASH",
+              `Isolated runtime exceeded timeout (${timeoutMs}ms)`,
+              { timeoutMs }
+            )
+          );
+        }, timeoutMs + 25);
+      })
+    ]);
+  }
+  return baseCall;
+}
+
+// src/worker/wrapFunctions.ts
+function wrapFunctions(api, libPath, bindings, opts) {
+  const wrapped = {};
+  const isolation = opts?.isolation ?? "worker";
+  const safety = bindings?.__safety ?? { trust: "local" };
+  const bindingNames = Object.keys(bindings?.functions ?? {});
+  const apiNames = Object.keys(api ?? {});
+  const names = Array.from(/* @__PURE__ */ new Set([...bindingNames, ...apiNames]));
+  for (const name of names) {
+    const fn = api?.[name];
+    const binding = bindings?.functions?.[name];
+    const isAsync = binding?.mode === "async" || binding?.async === true || binding?.thread === "worker" || binding?.cost === "high";
+    wrapped[name] = (...args) => {
+      if (isolation === "process") {
+        return callIsolated(libPath, bindings, name, args, safety);
+      }
+      if (isolation === "worker") {
+        if (typeof fn === "function" && !isAsync) {
+          return fn(...args);
+        }
+        return callAsync(libPath, bindings, name, args);
+      }
+      if (typeof fn !== "function") {
+        throw new Error(`Function not found: ${name}`);
+      }
+      return fn(...args);
+    };
+  }
+  if (isolation === "process") {
+    wrapped.__call = (fn, ...args) => callIsolated(libPath, bindings, fn, args, safety, captureCallsite());
+    return new Proxy(wrapped, {
+      get(target, prop) {
+        if (typeof prop !== "string") return target[prop];
+        if (prop === "then") return void 0;
+        if (prop in target) return target[prop];
+        return (...args) => callIsolated(libPath, bindings, prop, args, safety, captureCallsite());
+      }
+    });
+  }
+  if (isolation === "worker") {
+    return new Proxy(wrapped, {
+      get(target, prop) {
+        if (typeof prop !== "string") return target[prop];
+        if (prop === "then") return void 0;
+        if (prop in target) return target[prop];
+        return (...args) => callAsync(libPath, bindings, prop, args);
+      }
+    });
+  }
+  return wrapped;
+}
+
+export {
+  logDebug,
+  wrapFunctions
+};