@ai-ecoverse/slicc-kernel 1.129.0 → 1.130.1

package/dist/node-process-worker.js

@@ -103,6 +103,28 @@ var init_lockdown = __esm({
   }
 });
 
+// src/kernel/protocol.ts
+var WASM_PROCESS_INIT, WASM_PROCESS_EXIT, WASM_PROCESS_ERROR, WASM_PROCESS_READY, WASM_THREAD_SPAWN, WASM_THREAD_INIT, WASM_THREAD_EXIT, WASM_MAX_THREADS, WASM_DEFAULT_THREADS, JS_THREAD_SPAWN, JS_THREAD_INIT, JS_THREAD_EXIT, JS_THREAD_NO_MEMORY, JS_THREAD_CRASHED;
+var init_protocol = __esm({
+  "src/kernel/protocol.ts"() {
+    "use strict";
+    WASM_PROCESS_INIT = "wasm-process-init";
+    WASM_PROCESS_EXIT = "wasm-process-exit";
+    WASM_PROCESS_ERROR = "wasm-process-error";
+    WASM_PROCESS_READY = "wasm-process-ready";
+    WASM_THREAD_SPAWN = "wasm-thread-spawn";
+    WASM_THREAD_INIT = "wasm-thread-init";
+    WASM_THREAD_EXIT = "wasm-thread-exit";
+    WASM_MAX_THREADS = 256;
+    WASM_DEFAULT_THREADS = 64;
+    JS_THREAD_SPAWN = "js-thread-spawn";
+    JS_THREAD_INIT = "js-thread-init";
+    JS_THREAD_EXIT = "js-thread-exit";
+    JS_THREAD_NO_MEMORY = 256;
+    JS_THREAD_CRASHED = 257;
+  }
+});
+
 // src/process/wasi/wasi-abi.ts
 function wasiErrnoOf(code2) {
   if (!code2) return E.IO;
@@ -766,35 +788,64 @@ function copying(bridge, mutating, entry) {
     copy: (from, to, mode, exclusive) => mutating(() => copy2.call(bridge, from, to, mode, exclusive), ...entry(to))
   };
 }
+function listed({ cache, seen, filled }, p, list, gen, asked) {
+  const base = p === "/" ? "" : p;
+  for (const [name2, st] of list) {
+    if (!st) continue;
+    filled.set(st, asked);
+    const at = `${base}/${name2}`;
+    cache.put(cache.lstats, at, st);
+    if (gen !== void 0) seen.saw(cache.lstats, at, gen);
+    if (st.isSymbolicLink) continue;
+    cache.put(cache.stats, at, st);
+    if (gen !== void 0) seen.saw(cache.stats, at, gen);
+  }
+}
+function fetched({
+  view,
+  now,
+  seen,
+  filled,
+  cache
+}, map, path, get) {
+  const gen = view?.now();
+  const asked = now();
+  let hit;
+  try {
+    hit = get();
+    if (gen !== void 0) seen.saw(map, path, gen);
+  } catch (e) {
+    hit = { error: e, until: asked + MISS_TTL_MS, ...gen !== void 0 ? { gen } : {} };
+  }
+  filled.set(hit, asked);
+  cache.put(map, path, hit);
+  return hit;
+}
 function cachingBridge(bridge, now = () => performance.now(), shared) {
   const blind = shared !== void 0 && shared.length * 4 < SHARED_IDS_BYTES;
   const cache = new StatCache(blind ? void 0 : shared);
   const { stats, lstats } = cache;
   const view = bridge.changes;
-  const live = (miss, path) => miss.until > now() && (view === void 0 || miss.gen === void 0 || !view.changedSince(miss.gen, path).changed);
+  const filled = new Fills(view, now);
+  const young = (entry2) => filled.young(entry2);
+  const live = (miss, path) => miss.until > now() && young(miss) && (view === void 0 || miss.gen === void 0 || !view.changedSince(miss.gen, path).changed);
   const seen = new SeenAt(view, lstats);
-  const kept = remember(cache, seen, blind);
+  const kept = remember(cache, seen, blind, (entry2) => filled.set(entry2));
   const gone = (path) => goneAbove([lstats, stats], live, path);
+  const usable = (map, path) => {
+    const hit = map.get(path);
+    if (hit === void 0) return void 0;
+    if ("until" in hit) return live(hit, path) ? hit : void 0;
+    return young(hit) && !seen.changed(map, path) ? hit : void 0;
+  };
   const cached = (map, path, get) => {
-    if (blind || view?.foreign()) return get();
+    if (blind) return get();
     cache.fresh();
-    let hit = map.get(path);
-    if (hit !== void 0 && !("until" in hit) && seen.changed(map, path)) hit = void 0;
-    if (hit === void 0 || "until" in hit && !live(hit, path)) {
+    let hit = usable(map, path);
+    if (hit === void 0) {
       const missing2 = gone(path);
       if (missing2) throw missing2.error;
-      const gen = view?.now();
-      try {
-        hit = get();
-        if (gen !== void 0) seen.saw(map, path, gen);
-      } catch (e) {
-        hit = {
-          error: e,
-          until: now() + MISS_TTL_MS,
-          ...gen !== void 0 ? { gen } : {}
-        };
-      }
-      cache.put(map, path, hit);
+      hit = fetched({ view, now, seen, filled, cache }, map, path, get);
     }
     if ("until" in hit) throw hit.error;
     return hit;
@@ -851,24 +902,16 @@ function cachingBridge(bridge, now = () => performance.now(), shared) {
     readdir: (p) => bridge.readdir(p),
     readdirStat: (p) => {
       const gen = view?.now();
+      const asked = now();
       const list = bridge.readdirStat(p);
-      const base = p === "/" ? "" : p;
-      for (const [name2, st] of list) {
-        if (!st || blind) continue;
-        const at = `${base}/${name2}`;
-        cache.put(lstats, at, st);
-        if (gen !== void 0) seen.saw(lstats, at, gen);
-        if (st.isSymbolicLink) continue;
-        cache.put(stats, at, st);
-        if (gen !== void 0) seen.saw(stats, at, gen);
-      }
+      if (!blind) listed({ cache, seen, filled }, p, list, gen, asked);
       return list;
     },
     readlink: (p) => {
       const known = blind ? void 0 : (cache.fresh(), lstats.get(p));
       const gen = seen.lstat(p);
       const current = view !== void 0 && gen !== void 0 && !view.changedSince(gen, p).changed;
-      if (known && current && !("until" in known) && !known.isSymbolicLink) {
+      if (known && current && !("until" in known) && young(known) && !known.isSymbolicLink) {
         throw syncError("EINVAL", `'${p}' is not a symbolic link`);
       }
       return bridge.readlink(p);
@@ -941,7 +984,7 @@ function pinnedIo(bridge, handle, rewriting) {
     } : {}
   };
 }
-var WasiError, FileBuffer, LocalFile, MAX_LINKS, MISS_TTL_MS, CACHE_CAP, FS_GEN, CRED_GEN, UMASK, RING, RING_SIZE, SLOT, FD_RING, FD_RING_SIZE, SHARED_IDS_BYTES, StatCache, SEEN_CAP, SeenAt, remember;
+var WasiError, FileBuffer, LocalFile, MAX_LINKS, MISS_TTL_MS, SHARED_TTL_MS, CACHE_CAP, FS_GEN, CRED_GEN, UMASK, RING, RING_SIZE, SLOT, FD_RING, FD_RING_SIZE, SHARED_IDS_BYTES, StatCache, SEEN_CAP, SeenAt, remember, Fills;
 var init_wasi_files = __esm({
   "src/process/wasi/wasi-files.ts"() {
     "use strict";
@@ -1168,6 +1211,7 @@ var init_wasi_files = __esm({
     };
     MAX_LINKS = 40;
     MISS_TTL_MS = 20;
+    SHARED_TTL_MS = 100;
     CACHE_CAP = 8192;
     FS_GEN = 4;
     CRED_GEN = 5;
@@ -1332,30 +1376,30 @@ var init_wasi_files = __esm({
         return since.changed;
       }
     };
-    remember = (cache, seen, blind) => (path, made) => {
+    remember = (cache, seen, blind, fill) => (path, made) => {
       if (!made || blind) return made;
       const { seen: at, ...st } = made;
+      fill(st);
       cache.put(cache.stats, path, st);
       if (at !== void 0) seen.saw(cache.stats, path, at);
       return made;
     };
-  }
-});
-
-// src/kernel/protocol.ts
-var WASM_PROCESS_INIT, WASM_PROCESS_EXIT, WASM_PROCESS_ERROR, WASM_PROCESS_READY, WASM_THREAD_SPAWN, WASM_THREAD_INIT, WASM_THREAD_EXIT, WASM_MAX_THREADS, WASM_DEFAULT_THREADS;
-var init_protocol = __esm({
-  "src/kernel/protocol.ts"() {
-    "use strict";
-    WASM_PROCESS_INIT = "wasm-process-init";
-    WASM_PROCESS_EXIT = "wasm-process-exit";
-    WASM_PROCESS_ERROR = "wasm-process-error";
-    WASM_PROCESS_READY = "wasm-process-ready";
-    WASM_THREAD_SPAWN = "wasm-thread-spawn";
-    WASM_THREAD_INIT = "wasm-thread-init";
-    WASM_THREAD_EXIT = "wasm-thread-exit";
-    WASM_MAX_THREADS = 256;
-    WASM_DEFAULT_THREADS = 64;
+    Fills = class {
+      at = /* @__PURE__ */ new WeakMap();
+      view;
+      now;
+      constructor(view, now) {
+        this.view = view;
+        this.now = now;
+      }
+      set(entry, at = this.now()) {
+        this.at.set(entry, at);
+      }
+      young(entry) {
+        if (!this.view?.foreign()) return true;
+        return this.now() - (this.at.get(entry) ?? Number.NEGATIVE_INFINITY) < SHARED_TTL_MS;
+      }
+    };
   }
 });
 
@@ -5920,8 +5964,8 @@ var init_wasi_host = __esm({
       }
       list(path) {
         const { fs } = this.o;
-        const listed = fs.readdirStat(path);
-        return { names: [".", "..", ...listed.map(([name2]) => name2)], stats: new Map(listed) };
+        const listed2 = fs.readdirStat(path);
+        return { names: [".", "..", ...listed2.map(([name2]) => name2)], stats: new Map(listed2) };
       }
       lstatOrNull(path) {
         try {
@@ -6435,7 +6479,7 @@ var KERNEL_VERSION, OS_RELEASE;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    KERNEL_VERSION = true ? "1.129.0" : "0.0.0-dev";
+    KERNEL_VERSION = true ? "1.130.1" : "0.0.0-dev";
     OS_RELEASE = "6.0.0-slicc";
   }
 });
@@ -8343,9 +8387,9 @@ function createNodeOps(h) {
       node.live.stat = void 0;
     },
     lookup(parent, name2) {
-      const listed = parent.live.listed?.get(name2);
+      const listed2 = parent.live.listed?.get(name2);
       parent.live.listed?.delete(name2);
-      const st = listed ?? call2(() => bridgeOf(parent).lstat(childPath(parent, name2)));
+      const st = listed2 ?? call2(() => bridgeOf(parent).lstat(childPath(parent, name2)));
       return makeNode(parent, name2, st);
     },
     mknod(parent, name2, mode) {
@@ -8419,10 +8463,10 @@ function createNodeOps(h) {
       call2(() => bridgeOf(parent).rmdir(childPath(parent, name2)));
     },
     readdir(node) {
-      const listed = call2(() => bridgeOf(node).readdirStat(liveNodePath(node)));
+      const listed2 = call2(() => bridgeOf(node).readdirStat(liveNodePath(node)));
       node.live.listed = /* @__PURE__ */ new Map();
-      for (const [name2, st] of listed) if (st) node.live.listed.set(name2, st);
-      return [".", "..", ...listed.map(([name2]) => name2)];
+      for (const [name2, st] of listed2) if (st) node.live.listed.set(name2, st);
+      return [".", "..", ...listed2.map(([name2]) => name2)];
     },
     symlink(parent, newName, target) {
       parent.live.listed = void 0;
@@ -10456,7 +10500,7 @@ function useProcfs(Fs, sys, pid, memory = memorySource()) {
     return dir;
   };
   const scans = /* @__PURE__ */ new Map();
-  const listed = (target) => {
+  const listed2 = (target) => {
     let found = false;
     for (const [stream, pids] of scans) {
       if (Fs.streams && Fs.streams[stream.fd ?? -1] !== stream) scans.delete(stream);
@@ -10477,7 +10521,7 @@ function useProcfs(Fs, sys, pid, memory = memorySource()) {
     ...procOps2,
     lookup: (parent, name2) => {
       if (/^[1-9]\d*$/.test(name2)) {
-        if (!infoOf(Number(name2)) && !listed(Number(name2))) throw error();
+        if (!infoOf(Number(name2)) && !listed2(Number(name2))) throw error();
         return pidDir(name2, Number(name2));
       }
       if (name2 === "mounts") return file(parent, name2, () => mountTable(sys.mountList?.() ?? []));
@@ -10793,9 +10837,9 @@ function procfsBridge(fs, tree) {
         }
       }),
       () => {
-        const listed = fs.readdirStat(p);
-        if (p !== "/" || listed.some(([name2]) => name2 === "proc")) return listed;
-        return [...listed, ["proc", tree.stat("/proc")]];
+        const listed2 = fs.readdirStat(p);
+        if (p !== "/" || listed2.some(([name2]) => name2 === "proc")) return listed2;
+        return [...listed2, ["proc", tree.stat("/proc")]];
       }
     ),
     rename: (from, to) => readOnly2(
@@ -12255,9 +12299,7 @@ function createContext(o) {
     argv: o.argv,
     env: o.env,
     pid: o.pid,
-    async ppid() {
-      return identityOf(await kernel.json({ op: "proc-identity" }), o).ppid;
-    },
+    ppid: async () => identityOf(await kernel.json({ op: "proc-identity" }), o).ppid,
     cwd: o.cwd,
     stdin: readable2(read2),
     stdout: writable2(1),
@@ -12302,6 +12344,7 @@ function createContext(o) {
     websocket: websocketOp(kernel),
     tty: terminal.tty,
     exit,
+    thread: o.thread,
     onUncaught: (listener) => listen(strays.exception, listener),
     onUnhandledRejection: (listener) => listen(strays.rejection, listener)
   };
@@ -12533,11 +12576,100 @@ var init_js_context = __esm({
   }
 });
 
+// src/process/js/js-thread.ts
+function outOfMemory(err) {
+  return err instanceof RangeError && OOM.test(err.message);
+}
+function optionsOf(options) {
+  if (options === void 0) return {};
+  if (typeof options !== "object" || options === null || Array.isArray(options)) {
+    throw new JsCallError("EINVAL", "thread.spawn");
+  }
+  const { transfer } = options;
+  if (transfer !== void 0 && !Array.isArray(transfer)) {
+    throw new JsCallError("EINVAL", "thread.spawn");
+  }
+  return options;
+}
+function started(port3, control) {
+  const exited = Promise.withResolvers();
+  return new Promise((resolve, reject) => {
+    const thread = (tid) => Object.freeze({
+      tid,
+      port: port3,
+      exited: exited.promise,
+      async terminate() {
+        control.postMessage({ terminate: true });
+        await exited.promise;
+      }
+    });
+    control.onmessage = (event) => {
+      const said = event.data;
+      if ("tid" in said) resolve(thread(said.tid));
+      else if ("errno" in said) {
+        control.close();
+        port3.close();
+        reject(new JsCallError(said.errno, "thread.spawn", said.message));
+      } else if ("exited" in said) {
+        control.close();
+        exited.resolve(said.exited);
+      }
+    };
+  });
+}
+function threadContext(post2, start2) {
+  const spawn = (options) => {
+    let asked;
+    try {
+      asked = optionsOf(options);
+    } catch (err) {
+      return Promise.reject(err);
+    }
+    const channel = new NativeChannel();
+    const control = new NativeChannel();
+    const transfer = [...asked.transfer ?? []];
+    const msg = {
+      type: JS_THREAD_SPAWN,
+      data: asked.data,
+      port: channel.port2,
+      control: control.port2,
+      transfer
+    };
+    try {
+      post2.postMessage(msg, [channel.port2, control.port2, ...transfer]);
+    } catch (err) {
+      channel.port1.close();
+      control.port1.close();
+      return Promise.reject(err);
+    }
+    return started(channel.port1, control.port1);
+  };
+  return Object.freeze({
+    tid: start2?.tid ?? 0,
+    port: start2?.port,
+    data: start2?.data,
+    NO_MEMORY: JS_THREAD_NO_MEMORY,
+    CRASHED: JS_THREAD_CRASHED,
+    spawn
+  });
+}
+var NativeChannel, OOM;
+var init_js_thread = __esm({
+  "src/process/js/js-thread.ts"() {
+    "use strict";
+    init_protocol();
+    init_js_kernel();
+    NativeChannel = globalThis.MessageChannel;
+    OOM = /out of memory|Array buffer allocation failed|Cannot allocate Wasm memory/i;
+  }
+});
+
 // src/process/js/js-runtime.ts
 var js_runtime_exports = {};
 __export(js_runtime_exports, {
   mainOf: () => mainOf,
   runJsProcess: () => runJsProcess,
+  runJsThread: () => runJsThread,
   trapStrays: () => trapStrays
 });
 function trapStrays(scope2, stray) {
@@ -12568,7 +12700,15 @@ function mainOf(module) {
   const main = typeof module.default === "function" ? module.default : module.main;
   return typeof main === "function" ? main : void 0;
 }
-async function runJsProcess(init, port3, deps = {}) {
+function runJsProcess(init, port3, deps = {}) {
+  return runJs(init, port3, deps, void 0);
+}
+function runJsThread(init, port3, deps = {}) {
+  const { thread, ...rest2 } = init;
+  return runJs(rest2, port3, deps, thread);
+}
+async function runJs(init, port3, deps, thread) {
+  const failed5 = (err) => thread && outOfMemory(err) ? JS_THREAD_NO_MEMORY : 1;
   const transport = createAsyncSabTransport(init.sab, port3, deps.waitAsync);
   let resolveExit;
   const exit = new Promise((resolve) => resolveExit = resolve);
@@ -12580,7 +12720,7 @@ async function runJsProcess(init, port3, deps = {}) {
   let failing;
   const fail = (err) => {
     if (err instanceof JsExit) return;
-    failing ??= say(message(err)).then(() => exited(1));
+    failing ??= (thread ? Promise.resolve() : say(message(err))).then(() => exited(failed5(err)));
   };
   const kernel = new JsKernel({
     sab: init.sab,
@@ -12601,7 +12741,8 @@ async function runJsProcess(init, port3, deps = {}) {
     cwd: init.cwd,
     exit: (status3) => exited(statusOf(status3)),
     lane: laneOf(init.lane),
-    strays
+    strays,
+    thread: threadContext(port3, thread)
   });
   const say = (text) => ctx.write(2, `${init.argv0}: ${text}
 `).catch(() => void 0);
@@ -12632,8 +12773,8 @@ async function runJsProcess(init, port3, deps = {}) {
   const program = main;
   const ran = Promise.resolve().then(() => program(ctx)).then(statusOf, async (err) => {
     if (err instanceof JsExit) return err.status;
-    await say(message(err));
-    return 1;
+    if (!thread) await say(message(err));
+    return failed5(err);
   });
   const status2 = await Promise.race([ran, exit]);
   await drain2();
@@ -12646,11 +12787,13 @@ var NOT_RUNNABLE;
 var init_js_runtime = __esm({
   "src/process/js/js-runtime.ts"() {
     "use strict";
+    init_protocol();
     init_wasi_imports();
     init_async_sab();
     init_js_context();
     init_js_kernel();
     init_js_sync();
+    init_js_thread();
     init_lockdown();
     NOT_RUNNABLE = 126;
   }
@@ -15150,17 +15293,17 @@ function ptsBridge(fs, call2) {
     },
     readdir: (p) => {
       if (p === PTS) return names();
-      const listed = fs.readdir(p);
-      return p === "/dev" && !listed.includes("pts") ? [...listed, "pts"] : listed;
+      const listed2 = fs.readdir(p);
+      return p === "/dev" && !listed2.includes("pts") ? [...listed2, "pts"] : listed2;
     },
     readdirStat: (p) => {
       if (p === PTS) {
         const known = open();
         return names(known).map((name2) => listedEntry(name2, known));
       }
-      const listed = fs.readdirStat(p);
-      if (p !== "/dev" || listed.some(([name2]) => name2 === "pts")) return listed;
-      return [...listed, ["pts", dir()]];
+      const listed2 = fs.readdirStat(p);
+      if (p !== "/dev" || listed2.some(([name2]) => name2 === "pts")) return listed2;
+      return [...listed2, ["pts", dir()]];
     }
   };
   return new Proxy(fs, {
@@ -17746,7 +17889,7 @@ init_process_runtime();
 var loadWasi = () => Promise.resolve().then(() => (init_wasi_runtime(), wasi_runtime_exports));
 var loadJs = () => Promise.resolve().then(() => (init_js_runtime(), js_runtime_exports));
 var NOT_RUNNABLE2 = 126;
-function started(init, port3, run, wasi, js) {
+function started2(init, port3, run, wasi, js) {
   if (init.program?.abi === "js") {
     const jsInit = init;
     return js().then((m) => m.runJsProcess(jsInit, port3));
@@ -17776,8 +17919,19 @@ function processEntry(port3, run = runWasmProcess, wasi = loadWasi, js = loadJs,
   };
   return (data) => {
     const type = data?.type;
-    if (type !== WASM_THREAD_INIT && type !== WASM_PROCESS_INIT) return;
+    if (type !== WASM_THREAD_INIT && type !== WASM_PROCESS_INIT && type !== JS_THREAD_INIT) return;
     const refusal2 = sealOnce();
+    if (type === JS_THREAD_INIT) {
+      if (refusal2) return failed5(refusal2.error);
+      js().then((m) => {
+        if (!m.runJsThread) throw new Error("this process worker runs no JS threads");
+        return m.runJsThread(data, port3);
+      }).then(
+        (code2) => port3.postMessage({ type: JS_THREAD_EXIT, code: code2 }),
+        failed5
+      );
+      return;
+    }
     const init = data;
     if (type === WASM_THREAD_INIT || init?.program?.abi !== "js") useLocalClock(init?.sab);
     if (type === WASM_THREAD_INIT) {
@@ -17786,7 +17940,7 @@ function processEntry(port3, run = runWasmProcess, wasi = loadWasi, js = loadJs,
       return;
     }
     if (refusal2) return failed5(refusal2.error, NOT_RUNNABLE2);
-    started(data, port3, run, wasi, js).then(
+    started2(data, port3, run, wasi, js).then(
       (code2) => port3.postMessage({ type: WASM_PROCESS_EXIT, code: code2 }),
       failed5
     );
@@ -17800,14 +17954,17 @@ scope.require ??= createRequire(import.meta.url);
 scope.__filename ??= new URL(import.meta.url).pathname;
 scope.__dirname ??= new URL(".", import.meta.url).pathname;
 var port2 = parentPort;
-var post = { postMessage: (message2) => port2.postMessage(message2) };
+var post = {
+  postMessage: (message2, transfer) => port2.postMessage(message2, transfer)
+};
 var strayScope = nodeProcess ? { process: nodeProcess } : {};
 var onMessage = processEntry(
   post,
   void 0,
   async () => wasi_runtime_exports,
   async () => ({
-    runJsProcess: (init, at) => runJsProcess(init, at, { lockdown: () => nodeLockdown(), scope: strayScope })
+    runJsProcess: (init, at) => runJsProcess(init, at, { lockdown: () => nodeLockdown(), scope: strayScope }),
+    runJsThread: (init, at) => runJsThread(init, at, { lockdown: () => nodeLockdown(), scope: strayScope })
   }),
   () => nodeLockdown()
 );