@ai-ecoverse/slicc-kernel 1.54.2 → 1.54.4

package/dist/node-process-worker.js

@@ -1022,7 +1022,7 @@ function openAccess(existing, oflags, rights) {
   return { readable: (rights & RIGHTS.FD_READ) !== 0n || !writable2, writable: writable2 };
 }
 function promoteRequest(fd, f, handed) {
-  const orphan = f.buffer.isOrphan();
+  const orphan = f.buffer.isOrphan() || (f.buffer.handle ?? 0) < 0;
   if (!orphan && f.buffer.isRanged) f.buffer.flush();
   const joins = !orphan && (handed.has(f.buffer) || f.buffer.isRanged);
   return {
@@ -8713,60 +8713,201 @@ var init_wasi_module = __esm({
 function inProc(path) {
   return path === "/proc" || path.startsWith("/proc/");
 }
+function* procWalk(path, follow2) {
+  let done = [];
+  let todo = path.split("/").filter((part) => part !== "");
+  let hops = 0;
+  while (todo.length > 0) {
+    const part = todo.shift();
+    if (part === ".") continue;
+    if (part === "..") {
+      done.pop();
+      continue;
+    }
+    const at = `/${[...done, part].join("/")}`;
+    const whole = normalize(`/${[...done, part, ...todo].join("/")}`);
+    if (inProc(at) && inProc(whole)) return 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 {
+      if (++hops > MAX_HOPS2) return void 0;
+      if (target.startsWith("/")) done = [];
+      todo = [...target.split("/").filter((part2) => part2 !== ""), ...todo];
+    }
+  }
+  return void 0;
+}
+function procPath(fs, path, follow2) {
+  const walk = procWalk(path, follow2);
+  let step = walk.next();
+  while (!step.done) {
+    let target;
+    try {
+      target = fs.lstat(step.value).isSymbolicLink ? fs.readlink(step.value) : void 0;
+    } catch {
+      target = null;
+    }
+    step = walk.next(target);
+  }
+  return step.value;
+}
+function frozen(bytes) {
+  const refuse = () => {
+    throw syncError("EROFS", "/proc");
+  };
+  return {
+    readFile: () => bytes,
+    pread: (_p, at, n) => bytes.subarray(at, at + n),
+    writeFile: refuse,
+    pwrite: refuse,
+    truncate: refuse
+  };
+}
 function procfsBridge(fs, tree) {
+  const toProc = (path, follow2) => procPath(fs, path, follow2);
+  const shadowing = () => {
+    try {
+      return fs.exists("/proc");
+    } catch {
+      return false;
+    }
+  };
+  const via = (p, proc, own, follow2 = true) => {
+    if (inProc(p)) return proc(p);
+    if (shadowing()) {
+      const real = toProc(p, follow2);
+      if (real !== void 0) return proc(real);
+    }
+    try {
+      return own();
+    } catch (err) {
+      const real = toProc(p, follow2);
+      if (real === void 0) throw err;
+      return proc(real);
+    }
+  };
+  const readOnly = (paths, run) => {
+    const physical = shadowing();
+    for (const [p, follow2] of paths) {
+      if (inProc(p) || physical && toProc(p, follow2) !== void 0) throw syncError("EROFS", p);
+    }
+    return run();
+  };
+  const snapshots = /* @__PURE__ */ new Map();
+  let lastSnapshot = 0;
+  const snapshot = (q) => {
+    lastSnapshot--;
+    snapshots.set(lastSnapshot, tree.read(q));
+    return lastSnapshot;
+  };
+  const late = (p) => {
+    const q = toProc(p, true);
+    return q === void 0 ? void 0 : snapshot(q);
+  };
   const over = {
-    readFile: (p) => inProc(p) ? tree.read(p) : fs.readFile(p),
-    stat: (p) => inProc(p) ? tree.stat(p) : fs.stat(p),
-    lstat: (p) => inProc(p) ? tree.stat(p, false) : fs.lstat(p),
-    readdir: (p) => {
-      if (inProc(p)) return tree.readdir(p);
-      const names = fs.readdir(p);
-      return p === "/" && !names.includes("proc") ? [...names, "proc"] : names;
-    },
-    exists: (p) => inProc(p) ? tree.exists(p) : fs.exists(p),
-    readlink: (p) => inProc(p) ? tree.readlink(p) : fs.readlink(p),
-    readdirStat: (p) => {
-      if (!inProc(p)) {
-        const listed = fs.readdirStat(p);
-        if (p !== "/" || listed.some(([name2]) => name2 === "proc")) return listed;
-        return [...listed, ["proc", tree.stat("/proc")]];
+    readFile: (p) => via(
+      p,
+      (q) => tree.read(q),
+      () => fs.readFile(p)
+    ),
+    stat: (p) => via(
+      p,
+      (q) => tree.stat(q),
+      () => fs.stat(p)
+    ),
+    lstat: (p) => via(
+      p,
+      (q) => tree.stat(q, false),
+      () => fs.lstat(p),
+      false
+    ),
+    readdir: (p) => via(
+      p,
+      (q) => tree.readdir(q),
+      () => {
+        const names = fs.readdir(p);
+        return p === "/" && !names.includes("proc") ? [...names, "proc"] : names;
       }
-      return tree.readdir(p).map((name2) => {
+    ),
+    exists: (p) => {
+      if (inProc(p)) return tree.exists(p);
+      const real = shadowing() ? toProc(p, true) : void 0;
+      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);
+    },
+    readlink: (p) => via(
+      p,
+      (q) => tree.readlink(q),
+      () => fs.readlink(p),
+      false
+    ),
+    readdirStat: (p) => via(
+      p,
+      (q) => tree.readdir(q).map((name2) => {
         try {
-          return [name2, tree.stat(`${p}/${name2}`, false)];
+          return [name2, tree.stat(`${q}/${name2}`, false)];
         } catch {
           return [name2, null];
         }
-      });
+      }),
+      () => {
+        const listed = fs.readdirStat(p);
+        if (p !== "/" || listed.some(([name2]) => name2 === "proc")) return listed;
+        return [...listed, ["proc", tree.stat("/proc")]];
+      }
+    ),
+    rename: (from, to) => readOnly(
+      [
+        [from, false],
+        [to, false]
+      ],
+      () => fs.rename(from, to)
+    ),
+    symlink: (target, link) => readOnly([[link, false]], () => fs.symlink(target, link)),
+    hold: (p, held, open, handle) => {
+      if (handle !== void 0 && snapshots.delete(handle)) return void 0;
+      if (!held) return fs.hold?.(p, held, open, handle);
+      return via(p, snapshot, () => fs.hold?.(p, held, open) ?? late(p));
     },
-    rename: (from, to) => {
-      if (inProc(from) || inProc(to)) throw syncError("EROFS", from);
-      fs.rename(from, to);
+    kept: (handle) => snapshots.has(handle) || fs.kept?.(handle) === true,
+    pinned: (handle) => {
+      const bytes = snapshots.get(handle);
+      return bytes ? frozen(bytes) : fs.pinned?.(handle) ?? fs;
     },
-    hold: (p, ...rest2) => inProc(p) ? void 0 : fs.hold?.(p, ...rest2),
     ...fs.pread ? {
-      pread: (p, at, n, version) => inProc(p) ? tree.read(p).subarray(at, at + n) : fs.pread(p, at, n, version)
+      pread: (p, at, n, version) => via(
+        p,
+        (q) => tree.read(q).subarray(at, at + n),
+        () => fs.pread(p, at, n, version)
+      )
     } : {}
   };
-  for (const name2 of READ_ONLY) {
-    const fn = fs[name2];
-    if (!fn) continue;
-    over[name2] = (p, ...rest2) => {
-      if (inProc(p)) throw syncError("EROFS", p);
-      return fn.call(fs, p, ...rest2);
-    };
+  for (const [names, follow2] of [
+    [FOLLOWING, true],
+    [NOT_FOLLOWING, false]
+  ]) {
+    for (const name2 of names) {
+      const fn = fs[name2];
+      if (!fn) continue;
+      over[name2] = (p, ...rest2) => readOnly([[p, follow2]], () => fn.call(fs, p, ...rest2));
+    }
   }
   return new Proxy(fs, {
     get: (target, key, receiver) => key in over ? over[key] : Reflect.get(target, key, receiver)
   });
 }
-var DIR_MODE3, FILE_MODE2, LINK_MODE3, PID_NAMES, SYSTEM_NAMES, ProcTree, READ_ONLY;
+var DIR_MODE3, FILE_MODE2, LINK_MODE3, PID_NAMES, SYSTEM_NAMES, ProcTree, FOLLOWING, NOT_FOLLOWING, MAX_HOPS2;
 var init_wasi_procfs = __esm({
   "src/process/wasi/wasi-procfs.ts"() {
     "use strict";
     init_sync_fs_wire();
     init_process_fds();
     init_procfs();
+    init_wasi_files();
     DIR_MODE3 = 16749;
     FILE_MODE2 = 33060;
     LINK_MODE3 = 41471;
@@ -8877,20 +9018,9 @@ var init_wasi_procfs = __esm({
         }
       }
     };
-    READ_ONLY = [
-      "writeFile",
-      "mkdir",
-      "rm",
-      "unlink",
-      "rmdir",
-      "symlink",
-      "chmod",
-      "utimes",
-      "lutimes",
-      "create",
-      "pwrite",
-      "truncate"
-    ];
+    FOLLOWING = ["writeFile", "chmod", "utimes", "pwrite", "truncate"];
+    NOT_FOLLOWING = ["mkdir", "rm", "unlink", "rmdir", "lutimes", "create"];
+    MAX_HOPS2 = 40;
   }
 });
 
@@ -9770,12 +9900,22 @@ var init_wasix_linker = __esm({
         if (this.mainPath === void 0) return false;
         if (path === this.mainPath) return true;
         const real = this.host.real;
-        return real !== void 0 && real(path) === real(this.mainPath);
+        if (real === void 0) return false;
+        try {
+          return real(path) === real(this.mainPath);
+        } catch {
+          return false;
+        }
       }
       open(name2, cwd, ldPath) {
         const path = this.locate(name2, cwd, ldPath);
         if (this.isMain(path)) return 0;
-        return this.load(path, cwd, ldPath).handle;
+        this.indices?.lock();
+        try {
+          return this.load(path, cwd, ldPath).handle;
+        } finally {
+          this.indices?.unlock();
+        }
       }
       symbol(handle, name2) {
         const found = handle === 0 ? this.find(name2) : this.findIn(this.module(handle), name2, /* @__PURE__ */ new Set());
@@ -9797,15 +9937,17 @@ var init_wasix_linker = __esm({
       allocateClosure() {
         const index2 = this.indices.allocate(this.table.length);
         growTable(this.table, index2 + 1);
+        this.live.add(index2);
         return index2;
       }
       freeClosure(index2) {
         this.indices?.free(index2);
+        this.live.delete(index2);
         this.table.set(index2, null);
       }
+      live = /* @__PURE__ */ new Set();
       prepareClosure(record) {
-        if (record.index >= this.table.length)
-          throw new DlError(`closure ${record.index}: no such slot`);
+        if (!this.live.has(record.index)) throw new DlError(`closure ${record.index}: not allocated`);
         const full = { kind: "closure-prepare", ...record };
         this.install(full);
         this.publisher?.(full);
@@ -9822,15 +9964,23 @@ var init_wasix_linker = __esm({
         this.table.set(record.index, fn);
         this.types.set(fn, sig);
       }
+      reserveLoad(size) {
+        return this.indices?.load(this.table.length, size) ?? {
+          base: this.table.length,
+          handle: this.nextHandle++
+        };
+      }
       reserve(size) {
         return this.indices?.reserve(this.table.length, size) ?? this.table.length;
       }
       replay(record) {
         if (record.kind === "closure") {
           growTable(this.table, record.index + 1);
+          this.live.add(record.index);
           return;
         }
         if (record.kind === "closure-free") {
+          this.live.delete(record.index);
           if (record.index < this.table.length) this.table.set(record.index, null);
           return;
         }
@@ -9840,7 +9990,8 @@ var init_wasix_linker = __esm({
         }
         if (record.kind === "load") {
           if (this.modules.has(record.handle)) return;
-          this.instantiate(record.path, this.moduleAt(record.path), record, false);
+          const linked = this.instantiate(record.path, this.moduleAt(record.path), record, false);
+          linked.needed.push(...record.needed ?? []);
           this.nextHandle = Math.max(this.nextHandle, record.handle + 1);
           return;
         }
@@ -9890,13 +10041,14 @@ var init_wasix_linker = __esm({
           (n) => this.load(this.locate(n, cwd, search), cwd, ldPath).handle
         );
         const memoryBase = this.allocate(info.memorySize, 2 ** info.memoryAlign);
-        const tableBase = this.reserve(info.tableSize);
+        const { base: tableBase, handle } = this.reserveLoad(info.tableSize);
         const record = {
           kind: "load",
-          handle: this.nextHandle++,
+          handle,
           path,
           memoryBase,
-          tableBase
+          tableBase,
+          ...needed.length > 0 ? { needed } : {}
         };
         const linked = this.instantiate(path, module, record, true);
         linked.needed.push(...needed);
@@ -9954,7 +10106,8 @@ var init_wasix_linker = __esm({
         linked.instance = new WebAssembly.Instance(module, imports);
         this.types.register(() => this.host.read(path), linked.instance, this.table, at.tableBase);
         this.modules.set(at.handle, linked);
-        this.byPath.set(path, linked);
+        const first = this.byPath.get(path);
+        if (!first || at.handle < first.handle) this.byPath.set(path, linked);
         for (const resolve of pending) resolve();
         if (init) {
           call(linked.instance, "__wasm_apply_data_relocs");
@@ -10634,6 +10787,7 @@ var init_wasix_host = __esm({
         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);
               mem.view().setUint32(out, MAIN_HANDLE, true);
               return E.SUCCESS;
             }
@@ -10650,7 +10804,7 @@ var init_wasix_host = __esm({
             (l) => l.symbol(handle === MAIN_HANDLE ? 0 : handle, this.str(s, sl)),
             (v) => void mem.view().setUint32(out, v, true)
           ),
-          dl_invalid_handle: (handle) => handle === MAIN_HANDLE || handle !== 0 && this.linker && !this.linker.invalid(handle) ? E.SUCCESS : E.NOEXEC
+          dl_invalid_handle: (handle) => this.linker && (handle === MAIN_HANDLE || handle !== 0 && !this.linker.invalid(handle)) ? E.SUCCESS : E.NOEXEC
         };
       }
       threadImports() {
@@ -10815,6 +10969,7 @@ var init_wasm_names = __esm({
 var wasi_runtime_exports = {};
 __export(wasi_runtime_exports, {
   FALLBACK_MAXIMUM_PAGES: () => FALLBACK_MAXIMUM_PAGES,
+  LinkSync: () => LinkSync,
   captureBacktraces: () => captureBacktraces,
   createImportedMemory: () => createImportedMemory,
   runWasiProcess: () => runWasiProcess,
@@ -10987,7 +11142,7 @@ async function instantiate(host, module, memory, threads, {
       thread
     ),
     (req) => host.o.kernel.call(req),
-    threads?.ids
+    threads
   ) : void 0;
   if (sync) {
     ({ preview1, wasix } = sync.guard(preview1, wasix));
@@ -11299,32 +11454,59 @@ var init_wasi_runtime = __esm({
       linker;
       call;
       ids;
-      constructor(linker, call2, ids) {
+      owner;
+      constructor(linker, call2, threads) {
         this.linker = linker;
         this.call = call2;
-        this.ids = ids;
+        this.ids = threads?.ids;
+        this.owner = threads?.tid ?? 0;
         linker.publisher = (record) => this.publish(record);
         linker.indices = {
           reserve: (floor, size) => this.call({ op: "dl-reserve", floor, size }),
+          load: (floor, size) => this.call({ op: "dl-load-reserve", floor, size }),
+          lock: () => {
+            this.call({ op: "dl-lock", owner: this.owner });
+            try {
+              this.catchUp();
+            } catch (e) {
+              this.call({ op: "dl-unlock", owner: this.owner });
+              throw e;
+            }
+          },
+          unlock: () => this.call({ op: "dl-unlock", owner: this.owner }),
           allocate: (floor) => {
             const index2 = this.call({ op: "dl-closure", floor });
             this.catchUp();
+            this.bump();
             return index2;
           },
-          free: (index2) => void this.call({ op: "dl-closure-free", index: index2 })
+          free: (index2) => {
+            this.call({ op: "dl-closure-free", index: index2 });
+            this.bump();
+          }
         };
       }
+      bump() {
+        if (this.ids) Atomics.add(this.ids, DL_GEN, 1);
+      }
       publish(record) {
         const since = this.call({ op: "dl-log", append: record, from: this.count });
         for (const r of since.slice(0, -1)) this.linker.replay(r);
         this.count += since.length;
-        if (this.ids) this.gen = Atomics.add(this.ids, DL_GEN, 1) + 1;
+        this.bump();
+        this.catchUp();
       }
       catchUp() {
-        const since = this.call({ op: "dl-log", from: this.count });
-        for (const r of since) this.linker.replay(r);
-        this.count += since.length;
-        if (this.ids) this.gen = Atomics.load(this.ids, DL_GEN);
+        for (; ; ) {
+          const gen = this.ids ? Atomics.load(this.ids, DL_GEN) : 0;
+          const since = this.call({ op: "dl-log", from: this.count });
+          for (const r of since) this.linker.replay(r);
+          this.count += since.length;
+          if (!this.ids || Atomics.load(this.ids, DL_GEN) === gen) {
+            this.gen = gen;
+            return;
+          }
+        }
       }
       guard(preview1, wasix) {
         const ids = this.ids;