@endge/computation-sandbox 0.1.16 → 0.1.19

package/dist/QuickJSComputationSandbox.d.ts

@@ -5,14 +5,14 @@ export interface QuickJSComputationSandboxOptions {
 }
 /** Batched Worker pool adapter for the core computation runtime. */
 export declare class QuickJSComputationSandbox implements ComputationSandboxAdapter {
-    private readonly workers;
-    private readonly queue;
-    private nextId;
-    private scheduled;
-    private disposed;
+    private readonly _workers;
+    private readonly _queue;
+    private _nextId;
+    private _scheduled;
+    private _disposed;
     constructor(options?: QuickJSComputationSandboxOptions);
     execute(request: ComputationSandboxRequest): Promise<unknown>;
     dispose(): void;
-    private flush;
+    private _flush;
 }
 export declare function createQuickJSComputationSandbox(options?: QuickJSComputationSandboxOptions): QuickJSComputationSandbox;

package/dist/assets/{computation-sandbox.worker-D1PJv1Tp.js → computation-sandbox.worker-BX0goQiF.js}

@@ -161794,20 +161794,20 @@ Additional information: BADCLIENT: Bad error code, ${h} not found in range ${o}.
 var xft = Nft(), Hde = /* @__PURE__ */ Sft(xft);
 class Tft {
   constructor(Bt = {}) {
-    dN(this, "quickJs", vft(nft));
-    dN(this, "moduleSources", /* @__PURE__ */ new Map());
-    dN(this, "executionTimeoutMs");
-    dN(this, "memoryLimitBytes");
-    dN(this, "stackLimitBytes");
-    this.executionTimeoutMs = Bt.executionTimeoutMs ?? 250, this.memoryLimitBytes = Bt.memoryLimitBytes ?? 32 * 1024 * 1024, this.stackLimitBytes = Bt.stackLimitBytes ?? 512 * 1024;
+    dN(this, "_quickJs", vft(nft));
+    dN(this, "_moduleSources", /* @__PURE__ */ new Map());
+    dN(this, "_executionTimeoutMs");
+    dN(this, "_memoryLimitBytes");
+    dN(this, "_stackLimitBytes");
+    this._executionTimeoutMs = Bt.executionTimeoutMs ?? 250, this._memoryLimitBytes = Bt.memoryLimitBytes ?? 32 * 1024 * 1024, this._stackLimitBytes = Bt.stackLimitBytes ?? 512 * 1024;
   }
   async execute(Bt) {
-    Tz(Bt.inputs, "inputs"), this.moduleSources.has(Bt.moduleKey) || this.moduleSources.set(Bt.moduleKey, Rft(Bt.source));
-    const Lr = (await this.quickJs).newRuntime();
-    Lr.setMemoryLimit(this.memoryLimitBytes), Lr.setMaxStackSize(this.stackLimitBytes), Lr.setInterruptHandler(wft(Date.now() + this.executionTimeoutMs));
+    Tz(Bt.inputs, "inputs"), this._moduleSources.has(Bt.moduleKey) || this._moduleSources.set(Bt.moduleKey, Rft(Bt.source));
+    const Lr = (await this._quickJs).newRuntime();
+    Lr.setMemoryLimit(this._memoryLimitBytes), Lr.setMaxStackSize(this._stackLimitBytes), Lr.setInterruptHandler(wft(Date.now() + this._executionTimeoutMs));
     const Qn = Lr.newContext();
     try {
-      const JA = Qn.evalCode(Mft(this.moduleSources.get(Bt.moduleKey), Bt.inputs));
+      const JA = Qn.evalCode(Mft(this._moduleSources.get(Bt.moduleKey), Bt.inputs));
       if (JA.error) {
         const ra = Qn.dump(JA.error);
         throw JA.error.dispose(), new Error(Lft(ra));
@@ -161987,7 +161987,7 @@ function Lft(Ge) {
   return typeof Ge == "object" && Ge && "message" in Ge ? String(Ge.message) : String(Ge);
 }
 const Pft = new Tft();
-self.onmessage = async (Ge) => {
+globalThis.onmessage = async (Ge) => {
   var $e;
   if ((($e = Ge.data) == null ? void 0 : $e.type) !== "execute-batch")
     return;
@@ -161999,7 +161999,7 @@ self.onmessage = async (Ge) => {
     } catch (Qn) {
       Bt.push({ id: Lr.id, ok: !1, message: Qn instanceof Error ? Qn.message : String(Qn) });
     }
-  self.postMessage({ type: "execute-batch-result", results: Bt });
+  globalThis.postMessage({ type: "execute-batch-result", results: Bt });
 };
 var Uft = class {
   constructor(Ge) {

package/dist/computation-sandbox.js

@@ -2,131 +2,131 @@ 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 {
+class _ {
   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;
+    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) {
+    if (this._disposed) {
       for (const t of e)
         t.reject(new Error("Computation Worker was disposed."));
       return;
     }
-    this.queued.push(e), this.pump();
+    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 ?? [])
+    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 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;
+    this._active = null, this._queued.splice(0), this._busy = !1;
   }
-  pump() {
-    if (this.disposed || this.busy || !this.queued.length)
+  _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();
+    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;
+        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;
+      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({
+      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() {
+  _createWorker() {
     return new Worker(new URL(
       /* @vite-ignore */
-      "" + new URL("assets/computation-sandbox.worker-D1PJv1Tp.js", import.meta.url).href,
+      "" + new URL("assets/computation-sandbox.worker-BX0goQiF.js", import.meta.url).href,
       import.meta.url
     ), { type: "module" });
   }
 }
-function m(o) {
+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 _(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);
+    });
+  }
+}
+function l(o) {
   return new c(o);
 }
-class p extends d {
+class m extends d {
   constructor() {
     super(...arguments);
-    s(this, "adapter", null);
+    s(this, "_adapter", null);
   }
   setup() {
-    this.adapter = m(), n.runtime.computation.setSandboxAdapter(this.adapter);
+    this._adapter = l(), n.runtime.computation.setSandboxAdapter(this._adapter);
   }
   reset() {
-    n.runtime.computation.setSandboxAdapter(null), this.adapter = null;
+    n.runtime.computation.setSandboxAdapter(null), this._adapter = null;
   }
 }
-const k = {
+const w = {
   id: "@endge/computation-sandbox",
   install() {
     n.defineModule({
       key: "computationSandbox",
-      module: new p(),
+      module: new m(),
       before: "runtime"
     });
   }
 };
 export {
-  k as EndgeComputationSandboxPlugin,
+  w as EndgeComputationSandboxPlugin,
   c as QuickJSComputationSandbox,
-  m as createQuickJSComputationSandbox
+  l as createQuickJSComputationSandbox
 };

package/dist/worker/QuickJSComputationVM.d.ts

@@ -6,11 +6,11 @@ export interface QuickJSComputationVMOptions {
 }
 /** 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;
+    private readonly _quickJs;
+    private readonly _moduleSources;
+    private readonly _executionTimeoutMs;
+    private readonly _memoryLimitBytes;
+    private readonly _stackLimitBytes;
     constructor(options?: QuickJSComputationVMOptions);
     execute(request: ComputationSandboxRequest): Promise<unknown>;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@endge/computation-sandbox",
   "type": "module",
-  "version": "0.1.16",
+  "version": "0.1.19",
   "private": false,
   "license": "Apache-2.0",
   "exports": {
@@ -25,7 +25,7 @@
     "lint-fix": "eslint . --fix --cache"
   },
   "peerDependencies": {
-    "@endge/core": "^3.0.1 || ^4.0.0"
+    "@endge/core": "^3.0.1 || ^4.0.0 || ^5.0.0"
   },
   "dependencies": {
     "@jitl/quickjs-ng-wasmfile-release-sync": "^0.32.0",
@@ -34,7 +34,7 @@
   },
   "devDependencies": {
     "@antfu/eslint-config": "9.3.0",
-    "@endge/core": "^4.0.0",
+    "@endge/core": "^5.0.0",
     "@endge/raph": "^3.0.11",
     "@endge/utils": "^0.25.0",
     "eslint": "10.9.1",