@ai-ecoverse/slicc-kernel 1.54.7 → 1.54.8

package/dist/node-process-worker.js

@@ -4015,13 +4015,13 @@ function netOps(kernel, io) {
         const r = await kernel.raw({ op: "sock-connect", fd, addr, nonblock: true });
         if (!r.ok && r.errno !== "EINPROGRESS") throw new JsCallError(r.errno, "connect");
         await kernel.blocking({ op: "fd-select", read: [], write: [fd], timeoutMs: -1 }, signal);
-        const failed4 = await kernel.json({
+        const failed5 = await kernel.json({
           op: "sock-getopt",
           fd,
           level: SOL_SOCKET,
           name: SO_ERROR
         });
-        if (failed4 !== 0) throw new JsCallError(errnoName(failed4), "connect");
+        if (failed5 !== 0) throw new JsCallError(errnoName(failed5), "connect");
         return connection(fd);
       });
     }
@@ -8356,12 +8356,12 @@ async function runWasmProcess(init, port3, deps = {}) {
   const say = (fd) => (text) => sys.write(fd, encoder4.encode(`${text}
 `));
   let ready;
-  let failed4;
+  let failed5;
   let memory;
   let exports;
   const initialized = new Promise((resolve, reject) => {
     ready = resolve;
-    failed4 = reject;
+    failed5 = reject;
   });
   const id = identify(transport, init);
   const module = {
@@ -8414,7 +8414,7 @@ async function runWasmProcess(init, port3, deps = {}) {
         exports = instance.exports;
         publishMemory(init.sab, memory?.buffer.byteLength ?? 0);
         done(instance, init.program.module);
-      }, failed4);
+      }, failed5);
       return {};
     },
     preRun: [
@@ -8715,6 +8715,7 @@ function* procWalk(path, follow2) {
   let done = [];
   let todo = path.split("/").filter((part) => part !== "");
   let hops = 0;
+  let broken;
   while (todo.length > 0) {
     const part = todo.shift();
     if (part === ".") continue;
@@ -8724,32 +8725,48 @@ function* procWalk(path, follow2) {
     }
     const at = `/${[...done, part].join("/")}`;
     const whole = normalize(`/${[...done, part, ...todo].join("/")}`);
-    if (inProc(at) && inProc(whole)) return whole;
+    if (inProc(at) && inProc(whole)) return broken ?? whole;
     if (!follow2 && todo.length === 0) return void 0;
-    const target = yield at;
-    if (target === null) return void 0;
-    if (target === void 0) done.push(part);
-    else {
+    const target = yield { at, check: todo.find((next2) => next2 !== ".") === ".." };
+    if (typeof target === "string") {
       if (++hops > MAX_HOPS2) return void 0;
-      if (target.startsWith("/")) done = [];
-      todo = [...target.split("/").filter((part2) => part2 !== ""), ...todo];
+      [done, todo] = throughLink(target, done, todo);
+    } else {
+      broken ??= refusalOf(target);
+      done.push(part);
     }
   }
   return void 0;
 }
+function failed4(err) {
+  const code2 = err?.code;
+  return { refused: typeof code2 === "string" ? code2 : "ENOENT" };
+}
+function refusalOf(found) {
+  if (found === true) return void 0;
+  return found === false ? { refused: "ENOTDIR" } : found;
+}
+function throughLink(target, done, todo) {
+  const parts = target.split("/").filter((part) => part !== "");
+  return [target.startsWith("/") ? [] : done, [...parts, ...todo]];
+}
 function procPath(fs, path, follow2) {
   const walk = procWalk(path, follow2);
   let step = walk.next();
   while (!step.done) {
+    const { at, check } = step.value;
     let target;
     try {
-      target = fs.lstat(step.value).isSymbolicLink ? fs.readlink(step.value) : void 0;
-    } catch {
-      target = null;
+      const st = fs.lstat(at);
+      target = st.isSymbolicLink ? fs.readlink(at) : !check || st.isDirectory;
+    } catch (err) {
+      target = failed4(err);
     }
     step = walk.next(target);
   }
-  return step.value;
+  const result = step.value;
+  if (typeof result === "object") throw syncError(result.refused, path);
+  return result;
 }
 function frozen(bytes) {
   const refuse = () => {
@@ -8831,11 +8848,19 @@ function procfsBridge(fs, tree) {
     ),
     exists: (p) => {
       if (inProc(p)) return tree.exists(p);
-      const real = shadowing() ? toProc(p, true) : void 0;
+      const probe = () => {
+        try {
+          return toProc(p, true);
+        } catch {
+          return null;
+        }
+      };
+      const real = shadowing() ? probe() : void 0;
+      if (real === null) return false;
       if (real !== void 0) return tree.exists(real);
       if (fs.exists(p)) return true;
-      const late2 = toProc(p, true);
-      return late2 !== void 0 && tree.exists(late2);
+      const late2 = probe();
+      return typeof late2 === "string" && tree.exists(late2);
     },
     readlink: (p) => via(
       p,
@@ -10769,7 +10794,7 @@ var init_wasix_host = __esm({
       }
       dlImports() {
         const { mem, host } = this;
-        const failed4 = (message2, buf, len) => {
+        const failed5 = (message2, buf, len) => {
           if (len > 0) {
             const bytes = new TextEncoder().encode(message2).subarray(0, len - 1);
             mem.bytes(buf, bytes.length).set(bytes);
@@ -10778,19 +10803,19 @@ var init_wasix_host = __esm({
           return E.NOEXEC;
         };
         const linked = (buf, len, op, out) => {
-          if (!this.linker) return failed4("not a dynamically-linked program", buf, len);
+          if (!this.linker) return failed5("not a dynamically-linked program", buf, len);
           try {
             out(op(this.linker));
             return E.SUCCESS;
           } catch (e) {
-            if (e instanceof DlError) return failed4(e.message, buf, len);
+            if (e instanceof DlError) return failed5(e.message, buf, len);
             throw e;
           }
         };
         return {
           dlopen: (p, pl, _flags, buf, len, lp, ll, out) => {
             if (p === 0) {
-              if (!this.linker) return failed4("not a dynamically-linked program", buf, len);
+              if (!this.linker) return failed5("not a dynamically-linked program", buf, len);
               mem.view().setUint32(out, MAIN_HANDLE, true);
               return E.SUCCESS;
             }
@@ -11605,20 +11630,20 @@ function started(init, port3, run, wasi, js) {
   return run(wasmInit, port3);
 }
 function processEntry(port3, run = runWasmProcess, wasi = loadWasi, js = loadJs) {
-  const failed4 = (err) => port3.postMessage({
+  const failed5 = (err) => port3.postMessage({
     type: WASM_PROCESS_ERROR,
     message: err instanceof Error ? err.stack ?? err.message : String(err)
   });
   return (data) => {
     const type = data?.type;
     if (type === WASM_THREAD_INIT) {
-      wasi().then((m) => m.runWasiThread(data, port3)).catch(failed4);
+      wasi().then((m) => m.runWasiThread(data, port3)).catch(failed5);
       return;
     }
     if (type !== WASM_PROCESS_INIT) return;
     started(data, port3, run, wasi, js).then(
       (code2) => port3.postMessage({ type: WASM_PROCESS_EXIT, code: code2 }),
-      failed4
+      failed5
     );
   };
 }