@endge/computation-sandbox 0.1.1

package/dist/computation-sandbox.js

@@ -0,0 +1,123 @@
+var a = Object.defineProperty;
+var h = (o, e, t) => e in o ? a(o, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : o[e] = t;
+var s = (o, e, t) => h(o, typeof e != "symbol" ? e + "" : e, t);
+import { Endge as n, EndgeModule as d } from "@endge/core";
+class c {
+  constructor(e = {}) {
+    s(this, "workers");
+    s(this, "queue", []);
+    s(this, "nextId", 1);
+    s(this, "scheduled", !1);
+    s(this, "disposed", !1);
+    const t = typeof navigator > "u" ? 2 : navigator.hardwareConcurrency || 2, r = e.workerCount ?? Math.min(4, Math.max(1, t - 1)), i = e.watchdogMs ?? 500;
+    this.workers = Array.from({ length: r }, () => new l(i));
+  }
+  execute(e) {
+    return this.disposed ? Promise.reject(new Error("Computation sandbox is disposed.")) : new Promise((t, r) => {
+      this.queue.push({ id: this.nextId++, request: e, resolve: t, reject: r }), this.scheduled || (this.scheduled = !0, queueMicrotask(() => this.flush()));
+    });
+  }
+  dispose() {
+    this.disposed = !0;
+    for (const e of this.queue) e.reject(new Error("Computation sandbox is disposed."));
+    this.queue.splice(0);
+    for (const e of this.workers) e.dispose();
+  }
+  flush() {
+    if (this.scheduled = !1, this.disposed || !this.queue.length)
+      return;
+    const e = Array.from({ length: this.workers.length }, () => []);
+    let t = 0;
+    for (; this.queue.length; ) e[t++ % e.length].push(this.queue.shift());
+    e.forEach((r, i) => {
+      r.length && this.workers[i].execute(r);
+    });
+  }
+}
+class l {
+  constructor(e) {
+    s(this, "worker", this.createWorker());
+    s(this, "queued", []);
+    s(this, "active", null);
+    s(this, "timer", null);
+    s(this, "busy", !1);
+    s(this, "disposed", !1);
+    this.watchdogMs = e;
+  }
+  execute(e) {
+    if (this.disposed) {
+      for (const t of e) t.reject(new Error("Computation Worker was disposed."));
+      return;
+    }
+    this.queued.push(e), this.pump();
+  }
+  dispose() {
+    this.disposed = !0, this.timer && clearTimeout(this.timer), this.timer = null, this.worker.terminate();
+    for (const e of this.active ?? []) e.reject(new Error("Computation Worker was disposed."));
+    for (const e of this.queued) for (const t of e) t.reject(new Error("Computation Worker was disposed."));
+    this.active = null, this.queued.splice(0), this.busy = !1;
+  }
+  pump() {
+    if (this.disposed || this.busy || !this.queued.length)
+      return;
+    this.busy = !0;
+    const e = this.queued.shift();
+    this.active = e, this.timer = setTimeout(() => {
+      this.worker.terminate(), this.worker = this.createWorker();
+      for (const t of e) t.reject(new Error(`Computation Worker exceeded ${this.watchdogMs} ms watchdog.`));
+      this.active = null, this.timer = null, this.busy = !1, this.pump();
+    }, this.watchdogMs), this.worker.onmessage = (t) => {
+      this.timer && clearTimeout(this.timer), this.timer = null;
+      const r = new Map(t.data.results.map((i) => [i.id, i]));
+      for (const i of e) {
+        const u = r.get(i.id);
+        u ? u.ok ? i.resolve(u.value) : i.reject(new Error(u.message)) : i.reject(new Error("Computation Worker returned no result."));
+      }
+      this.active = null, this.busy = !1, this.pump();
+    }, this.worker.onerror = (t) => {
+      this.timer && clearTimeout(this.timer), this.timer = null;
+      for (const r of e) r.reject(new Error(t.message || "Computation Worker failed."));
+      this.worker.terminate(), this.worker = this.createWorker(), this.active = null, this.busy = !1, this.pump();
+    }, this.worker.postMessage({
+      type: "execute-batch",
+      requests: e.map(({ id: t, request: r }) => ({ id: t, request: r }))
+    });
+  }
+  createWorker() {
+    return new Worker(new URL(
+      /* @vite-ignore */
+      "" + new URL("assets/computation-sandbox.worker-DNprzyNC.js", import.meta.url).href,
+      import.meta.url
+    ), { type: "module" });
+  }
+}
+function m(o) {
+  return new c(o);
+}
+class p extends d {
+  constructor() {
+    super(...arguments);
+    s(this, "adapter", null);
+  }
+  setup() {
+    this.adapter = m(), n.runtime.computation.setSandboxAdapter(this.adapter);
+  }
+  reset() {
+    n.runtime.computation.setSandboxAdapter(null), this.adapter = null;
+  }
+}
+const k = {
+  id: "@endge/computation-sandbox",
+  install() {
+    n.defineModule({
+      key: "computationSandbox",
+      module: new p(),
+      before: "runtime"
+    });
+  }
+};
+export {
+  k as EndgeComputationSandboxPlugin,
+  c as QuickJSComputationSandbox,
+  m as createQuickJSComputationSandbox
+};

package/dist/main.d.ts

@@ -0,0 +1,2 @@
+export * from './EndgeComputationSandboxPlugin';
+export * from './QuickJSComputationSandbox';

package/dist/worker/QuickJSComputationVM.d.ts

@@ -0,0 +1,16 @@
+import { ComputationSandboxRequest } from '@endge/core';
+export interface QuickJSComputationVMOptions {
+    executionTimeoutMs?: number;
+    memoryLimitBytes?: number;
+    stackLimitBytes?: number;
+}
+/** One isolated QuickJS VM factory used inside a Worker. */
+export declare class QuickJSComputationVM {
+    private readonly quickJs;
+    private readonly moduleSources;
+    private readonly executionTimeoutMs;
+    private readonly memoryLimitBytes;
+    private readonly stackLimitBytes;
+    constructor(options?: QuickJSComputationVMOptions);
+    execute(request: ComputationSandboxRequest): Promise<unknown>;
+}

package/dist/worker/computation-sandbox.protocol.d.ts

@@ -0,0 +1,20 @@
+import { ComputationSandboxRequest } from '@endge/core';
+export interface SandboxBatchRequest {
+    type: 'execute-batch';
+    requests: Array<{
+        id: number;
+        request: ComputationSandboxRequest;
+    }>;
+}
+export interface SandboxBatchResponse {
+    type: 'execute-batch-result';
+    results: Array<{
+        id: number;
+        ok: true;
+        value: unknown;
+    } | {
+        id: number;
+        ok: false;
+        message: string;
+    }>;
+}

package/dist/worker/computation-sandbox.worker.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@endge/computation-sandbox",
+  "version": "0.1.1",
+  "private": false,
+  "license": "Apache-2.0",
+  "type": "module",
+  "main": "./dist/computation-sandbox.js",
+  "module": "./dist/computation-sandbox.js",
+  "types": "./dist/main.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/main.d.ts",
+      "import": "./dist/computation-sandbox.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@jitl/quickjs-ng-wasmfile-release-sync": "^0.32.0",
+    "quickjs-emscripten-core": "^0.32.0",
+    "typescript": "^5.9.3"
+  },
+  "peerDependencies": {
+    "@endge/core": "^1.2.7"
+  },
+  "devDependencies": {
+    "rimraf": "^6.0.1",
+    "vite": "^6.1.0",
+    "vite-plugin-dts": "^4.5.0",
+    "vitest": "^2.1.9",
+    "@endge/core": "1.2.7"
+  },
+  "scripts": {
+    "build": "vite build",
+    "test": "vitest",
+    "typecheck": "tsc --noEmit"
+  }
+}