@ai-ecoverse/slicc-kernel 1.39.1 → 1.39.3

package/dist/node.js

@@ -2606,6 +2606,210 @@ var OpfsFs = class {
   }
 };
 
+// src/fs/unlinked.ts
+var UNLINKED_DIR = ".slicc-unlinked";
+function pidOwner(proc) {
+  return {
+    id: `p${proc.pid}`,
+    alive(id) {
+      try {
+        proc.kill(Number(id.slice(1)), 0);
+        return true;
+      } catch (err) {
+        return err.code !== "ESRCH";
+      }
+    }
+  };
+}
+function webLocks() {
+  return globalThis.navigator?.locks;
+}
+var within2 = (path, target) => path === target || target === "/" || path.startsWith(`${target}/`);
+var parentOf3 = (path) => path.slice(0, path.lastIndexOf("/")) || "/";
+var lockName = (instance) => `slicc-unlinked:${instance}`;
+var dirOf = (root) => root === "/" ? `/${UNLINKED_DIR}` : `${root}/${UNLINKED_DIR}`;
+var PathGate = class {
+  tails = /* @__PURE__ */ new Map();
+  async acquire(path) {
+    const prev = this.tails.get(path) ?? Promise.resolve();
+    const { promise, resolve } = Promise.withResolvers();
+    const tail = prev.then(() => promise);
+    this.tails.set(path, tail);
+    await prev;
+    return () => {
+      resolve();
+      if (this.tails.get(path) === tail) this.tails.delete(path);
+    };
+  }
+  async run(path, op) {
+    const release = await this.acquire(path);
+    try {
+      return await op();
+    } finally {
+      release();
+    }
+  }
+};
+var UnlinkedKeeper = class {
+  fs;
+  holders;
+  rootOf;
+  locks;
+  busy;
+  waiting = /* @__PURE__ */ new Set();
+  owner;
+  instance;
+  gate = new PathGate();
+  queue = Promise.resolve();
+  count = 0;
+  constructor(fs, holders, rootOf, options = {}) {
+    const { locks, owner } = options;
+    this.fs = fs;
+    this.holders = holders;
+    this.rootOf = rootOf;
+    this.locks = locks;
+    this.busy = options.busy ?? (() => false);
+    this.owner = owner;
+    this.instance = owner ? `${owner.id}~${crypto.randomUUID()}` : crypto.randomUUID();
+    void locks?.request(lockName(this.instance), () => new Promise(() => void 0));
+  }
+  serial(op) {
+    const next = this.queue.then(op);
+    this.queue = next.catch(() => void 0);
+    return next;
+  }
+  wrap(fs = this.fs) {
+    const keeper = this;
+    const visible = (names) => names.filter((name2) => name2 !== UNLINKED_DIR);
+    return {
+      ...fs,
+      async rm(path, options) {
+        const target = fs.resolvePath("/", path);
+        const pinned = await keeper.pin(target);
+        if (pinned.moved.has(target)) pinned.commit();
+        else await keeper.settle(pinned, () => fs.rm(path, options));
+      },
+      async rename(from, to) {
+        const target = fs.resolvePath("/", to);
+        if (target === fs.resolvePath("/", from)) return fs.rename(from, to);
+        const pinned = await keeper.pin(target);
+        await keeper.settle(pinned, () => fs.rename(from, to));
+      },
+      readdir: async (path) => visible(await fs.readdir(path)),
+      readdirStat: async (path) => (await fs.readdirStat(path)).filter(([name2]) => name2 !== UNLINKED_DIR)
+    };
+  }
+  async settle(pinned, op) {
+    try {
+      await op();
+    } catch (err) {
+      await pinned.rollback();
+      throw err;
+    }
+    pinned.commit();
+  }
+  async pin(target) {
+    const held = /* @__PURE__ */ new Map();
+    for (const holder of this.holders) {
+      if (holder.owns(target)) continue;
+      for (const path of holder.held()) {
+        if (!within2(path, target) || holder.isKept(path)) continue;
+        held.set(path, [...held.get(path) ?? [], holder]);
+      }
+    }
+    const paths = [...held.keys()].sort();
+    const releases = [];
+    for (const path of paths) releases.push(await this.gate.acquire(path));
+    const hidden = /* @__PURE__ */ new Map();
+    for (const path of paths) {
+      const at = await this.hide(path);
+      if (at !== void 0) hidden.set(path, at);
+    }
+    const done4 = () => {
+      for (const release of releases) release();
+    };
+    const files = /* @__PURE__ */ new Map();
+    for (const [path, at] of hidden) {
+      const holders = held.get(path);
+      const file = this.keptFile(at, { refs: holders.length + 1 });
+      files.set(path, file);
+      for (const holder of holders) holder.keep(path, file);
+    }
+    return {
+      moved: new Set(hidden.keys()),
+      commit: () => {
+        for (const file of files.values()) file.release();
+        done4();
+      },
+      rollback: async () => {
+        for (const [path, file] of files) {
+          for (const holder of held.get(path)) holder.unkeep(path, file);
+          await this.serial(async () => {
+            await Promise.allSettled([this.fs.rename(file.hidden, path)]);
+            await this.tidy(parentOf3(file.hidden));
+          });
+        }
+        done4();
+      }
+    };
+  }
+  keptFile(hidden, entry) {
+    return {
+      hidden,
+      release: () => {
+        if (--entry.refs === 0) void this.serial(() => this.drop(hidden));
+      }
+    };
+  }
+  hide(path) {
+    return this.serial(async () => {
+      const dir = dirOf(this.rootOf(path));
+      const hidden = `${dir}/${this.instance}.${++this.count}`;
+      try {
+        await this.fs.mkdir(dir, { recursive: true });
+        await this.fs.rename(path, hidden);
+        return hidden;
+      } catch {
+        await this.tidy(dir);
+        return void 0;
+      }
+    });
+  }
+  closed(path) {
+    if (this.waiting.delete(path)) void this.serial(() => this.drop(path));
+  }
+  async drop(hidden) {
+    if (this.busy(hidden)) {
+      this.waiting.add(hidden);
+      return;
+    }
+    await this.fs.rm(hidden).catch(() => void 0);
+    await this.tidy(parentOf3(hidden));
+  }
+  async tidy(dir) {
+    const left = await this.fs.readdir(dir).catch(() => [UNLINKED_DIR]);
+    if (left.length === 0) await this.fs.rm(dir, { recursive: true }).catch(() => void 0);
+  }
+  sweep(root) {
+    const query = this.locks?.query?.bind(this.locks);
+    const owner = this.owner;
+    if (!query && !owner) return Promise.resolve();
+    return this.serial(async () => {
+      const dir = dirOf(root);
+      const names = await this.fs.readdir(dir).catch(() => void 0);
+      if (!names) return;
+      const held = query && new Set(((await query()).held ?? []).map((lock) => lock.name));
+      for (const name2 of names) {
+        const id = name2.slice(0, name2.lastIndexOf("."));
+        const at = id.indexOf("~");
+        const dead = id !== this.instance && (at < 0 ? held !== void 0 && !held.has(lockName(id)) : owner?.alive(id.slice(0, at)) === false);
+        if (dead) await this.fs.rm(`${dir}/${name2}`, { recursive: true }).catch(() => void 0);
+      }
+      await this.tidy(dir);
+    });
+  }
+};
+
 // src/kernel/net/http1.ts
 var HttpError = class extends Error {
   status;
@@ -3674,186 +3878,6 @@ function withCommandDirs(fs, names) {
   };
 }
 
-// src/fs/unlinked.ts
-var UNLINKED_DIR = ".slicc-unlinked";
-function webLocks() {
-  return globalThis.navigator?.locks;
-}
-var within2 = (path, target) => path === target || target === "/" || path.startsWith(`${target}/`);
-var parentOf3 = (path) => path.slice(0, path.lastIndexOf("/")) || "/";
-var lockName = (instance) => `slicc-unlinked:${instance}`;
-var dirOf = (root) => root === "/" ? `/${UNLINKED_DIR}` : `${root}/${UNLINKED_DIR}`;
-var PathGate = class {
-  tails = /* @__PURE__ */ new Map();
-  async acquire(path) {
-    const prev = this.tails.get(path) ?? Promise.resolve();
-    const { promise, resolve } = Promise.withResolvers();
-    const tail = prev.then(() => promise);
-    this.tails.set(path, tail);
-    await prev;
-    return () => {
-      resolve();
-      if (this.tails.get(path) === tail) this.tails.delete(path);
-    };
-  }
-  async run(path, op) {
-    const release = await this.acquire(path);
-    try {
-      return await op();
-    } finally {
-      release();
-    }
-  }
-};
-var UnlinkedKeeper = class {
-  fs;
-  holders;
-  rootOf;
-  locks;
-  busy;
-  waiting = /* @__PURE__ */ new Set();
-  instance = crypto.randomUUID();
-  gate = new PathGate();
-  queue = Promise.resolve();
-  count = 0;
-  constructor(fs, holders, rootOf, locks, busy = () => false) {
-    this.fs = fs;
-    this.holders = holders;
-    this.rootOf = rootOf;
-    this.locks = locks;
-    this.busy = busy;
-    void locks?.request(lockName(this.instance), () => new Promise(() => void 0));
-  }
-  serial(op) {
-    const next = this.queue.then(op);
-    this.queue = next.catch(() => void 0);
-    return next;
-  }
-  wrap() {
-    const fs = this.fs;
-    const keeper = this;
-    const visible = (names) => names.filter((name2) => name2 !== UNLINKED_DIR);
-    return {
-      ...fs,
-      async rm(path, options) {
-        const target = fs.resolvePath("/", path);
-        const pinned = await keeper.pin(target);
-        if (pinned.moved.has(target)) pinned.commit();
-        else await keeper.settle(pinned, () => fs.rm(path, options));
-      },
-      async rename(from, to) {
-        const pinned = await keeper.pin(fs.resolvePath("/", to));
-        await keeper.settle(pinned, () => fs.rename(from, to));
-      },
-      readdir: async (path) => visible(await fs.readdir(path)),
-      readdirStat: async (path) => (await fs.readdirStat(path)).filter(([name2]) => name2 !== UNLINKED_DIR)
-    };
-  }
-  async settle(pinned, op) {
-    try {
-      await op();
-    } catch (err) {
-      await pinned.rollback();
-      throw err;
-    }
-    pinned.commit();
-  }
-  async pin(target) {
-    const held = /* @__PURE__ */ new Map();
-    for (const holder of this.holders) {
-      if (holder.owns(target)) continue;
-      for (const path of holder.opens.keys()) {
-        if (!within2(path, target) || holder.unlinked.has(path)) continue;
-        held.set(path, [...held.get(path) ?? [], holder]);
-      }
-    }
-    const paths = [...held.keys()].sort();
-    const releases = [];
-    for (const path of paths) releases.push(await this.gate.acquire(path));
-    const hidden = /* @__PURE__ */ new Map();
-    for (const path of paths) {
-      const at = await this.hide(path);
-      if (at !== void 0) hidden.set(path, at);
-    }
-    const done4 = () => {
-      for (const release of releases) release();
-    };
-    return {
-      moved: new Set(hidden.keys()),
-      commit: () => {
-        for (const [path, at] of hidden) {
-          const holders = held.get(path);
-          const file = this.keptFile(at, { refs: holders.length });
-          for (const holder of holders) holder.unlinked.set(path, file);
-        }
-        done4();
-      },
-      rollback: async () => {
-        for (const [path, at] of hidden) {
-          await this.serial(async () => {
-            await Promise.allSettled([this.fs.rename(at, path)]);
-            await this.tidy(parentOf3(at));
-          });
-        }
-        done4();
-      }
-    };
-  }
-  keptFile(hidden, entry) {
-    return {
-      hidden,
-      release: () => {
-        if (--entry.refs === 0) void this.serial(() => this.drop(hidden));
-      }
-    };
-  }
-  hide(path) {
-    return this.serial(async () => {
-      const dir = dirOf(this.rootOf(path));
-      const hidden = `${dir}/${this.instance}.${++this.count}`;
-      try {
-        await this.fs.mkdir(dir, { recursive: true });
-        await this.fs.rename(path, hidden);
-        return hidden;
-      } catch {
-        await this.tidy(dir);
-        return void 0;
-      }
-    });
-  }
-  closed(path) {
-    if (this.waiting.delete(path)) void this.serial(() => this.drop(path));
-  }
-  async drop(hidden) {
-    if (this.busy(hidden)) {
-      this.waiting.add(hidden);
-      return;
-    }
-    await this.fs.rm(hidden).catch(() => void 0);
-    await this.tidy(parentOf3(hidden));
-  }
-  async tidy(dir) {
-    const left = await this.fs.readdir(dir).catch(() => [UNLINKED_DIR]);
-    if (left.length === 0) await this.fs.rm(dir, { recursive: true }).catch(() => void 0);
-  }
-  sweep(root) {
-    const query = this.locks?.query?.bind(this.locks);
-    if (!query) return Promise.resolve();
-    return this.serial(async () => {
-      const dir = dirOf(root);
-      const names = await this.fs.readdir(dir).catch(() => void 0);
-      if (!names) return;
-      const held = new Set(((await query()).held ?? []).map((lock) => lock.name));
-      for (const name2 of names) {
-        const owner = name2.slice(0, name2.lastIndexOf("."));
-        if (owner === this.instance || held.has(lockName(owner))) continue;
-        await this.fs.rm(`${dir}/${name2}`, { recursive: true }).catch(() => void 0);
-      }
-      await this.tidy(dir);
-    });
-  }
-};
-
 // src/fs/watch.ts
 var WATCH_BATCH_LIMIT = 1e3;
 var under2 = (path, dir) => dir === "/" || path.startsWith(`${dir}/`);
@@ -4050,6 +4074,7 @@ var ChildTable = class {
     if ("fd" in slot) return this.parentFds.get(slot.fd).retain();
     if ("input" in slot) return bytesSource(slot.input);
     if ("device" in slot) return deviceFile(slot.device, slot.access);
+    if ("dir" in slot) return heldFile({ dir: slot.dir });
     if ("capture" in slot) {
       const chunks2 = [];
       captured.set(n, chunks2);
@@ -4281,6 +4306,18 @@ var HeldPaths = class extends Map {
   holding(path) {
     return this.opens.has(this.keyOf(path));
   }
+  held() {
+    return this.opens.keys();
+  }
+  isKept(path) {
+    return this.unlinked.has(path);
+  }
+  keep(path, file) {
+    this.unlinked.set(path, file);
+  }
+  unkeep(path) {
+    this.unlinked.delete(path);
+  }
   hold(path, on, open = false, real) {
     if (open) {
       const key = real ?? this.keyOf(path);
@@ -5148,6 +5185,9 @@ async function run(entry, path, req) {
     case "symlink":
       await fs.symlink(req.arg2 ?? "", path);
       return done;
+    case "create":
+      await createExclusive(fs, path);
+      return done;
     case "readlink":
       return json2(await fs.readlink(path));
     case "chmod":
@@ -5167,6 +5207,15 @@ async function run(entry, path, req) {
       return { ok: false, errno: "EINVAL", message: `sync-fs: unknown op '${req.op}'` };
   }
 }
+async function createExclusive(fs, path) {
+  if (fs.createExclusive) return fs.createExclusive(path);
+  if (await fs.lstat(path).then(
+    () => true,
+    () => false
+  ))
+    throw syncError("EEXIST", path);
+  await fs.writeFile(path, new Uint8Array(0));
+}
 async function ranged(fs, path, req) {
   const ops = rangedOps(fs);
   if (!ops) throw syncError("ENOSYS", path);
@@ -8126,6 +8175,8 @@ var VfsNode = class {
 };
 var VfsNodes = class {
   byPath = /* @__PURE__ */ new Map();
+  kept = /* @__PURE__ */ new Map();
+  keepsOnDisk = false;
   fs;
   entries = /* @__PURE__ */ new Map();
   onClosed;
@@ -8208,15 +8259,47 @@ var VfsNodes = class {
       return;
     }
     if (this.byPath.get(node.path) === node) this.byPath.delete(node.path);
+    this.kept.get(node)?.release();
+    this.kept.delete(node);
     this.onClosed?.(node.path);
   }
+  held() {
+    return this.byPath.keys();
+  }
+  owns() {
+    return false;
+  }
+  isKept() {
+    return false;
+  }
+  keep(path, file) {
+    const node = this.byPath.get(path);
+    if (!node) {
+      file.release();
+      return;
+    }
+    this.byPath.delete(path);
+    node.renamedTo(file.hidden);
+    this.byPath.set(file.hidden, node);
+    this.kept.set(node, file);
+  }
+  unkeep(path, file) {
+    const node = this.byPath.get(file.hidden);
+    if (!node) return;
+    this.byPath.delete(file.hidden);
+    node.renamedTo(path);
+    this.byPath.set(path, node);
+    this.kept.delete(node);
+  }
   async flush(path) {
     for (const [p, node] of this.byPath) if (within5(p, path)) await node.serial(() => node.flush());
   }
   async unlinking(path) {
     for (const [held, node] of [...this.byPath]) {
       if (!within5(held, path)) continue;
-      await node.serial(async () => void await Promise.all([node.keep(), node.limit()]));
+      await node.serial(async () => {
+        await Promise.all([this.keepsOnDisk || node.keep(), node.limit()]);
+      });
     }
   }
   revoke(prefix) {
@@ -8346,6 +8429,7 @@ function keepingOpen(fs, nodes) {
       });
     },
     writeFile: (path, content) => nodes.onEntry(fs.resolvePath("/", path), () => fs.writeFile(path, content)),
+    createExclusive: async (path) => nodes.createExclusive(await nodes.entryKey(fs.resolvePath("/", path))),
     symlink: (target, path) => nodes.onEntry(fs.resolvePath("/", path), () => fs.symlink(target, path)),
     mkdir: (path, options) => nodes.onEntry(fs.resolvePath("/", path), () => fs.mkdir(path, options))
   };
@@ -9171,13 +9255,13 @@ var Dying = class {
   timer;
   busy = 0;
   finish;
-  start(code, sig, header3, process, finish) {
+  start(code, sig, header3, process2, finish) {
     if (this.ending) return;
     this.ending = { code, sig };
     this.finish = finish;
     this.arm();
     Atomics.store(header3, SAB_I_KILLED, code);
-    process.die();
+    process2.die();
   }
   async serving(work) {
     this.busy++;
@@ -9213,8 +9297,8 @@ function notifiers(header3) {
     }
   };
 }
-function publishStops(process, header3) {
-  process.onState((state) => {
+function publishStops(process2, header3) {
+  process2.onState((state) => {
     Atomics.store(header3, SAB_I_STOP, state === "stopped" ? 1 : 0);
     Atomics.notify(header3, SAB_I_STOP);
   });
@@ -9284,7 +9368,7 @@ function holdingToken(opts, holds) {
 function spawnWasmProcess(opts) {
   const sab = new SharedArrayBuffer(SAB_HEADER_BYTES + SAB_DEFAULT_WINDOW_BYTES);
   const header3 = new Int32Array(sab, 0, SAB_HEADER_I32);
-  const process = new WasmProcess(opts.pid, opts.fds, {
+  const process2 = new WasmProcess(opts.pid, opts.fds, {
     ...inherited(opts),
     ...opts.identity ? { identity: opts.identity } : {},
     ...opts.onSyscall ? { onSyscall: opts.onSyscall } : {},
@@ -9312,14 +9396,14 @@ function spawnWasmProcess(opts) {
     raise: (sig) => signal(sig),
     ...opts.program.abi === "wasi" || opts.program.abi === "js" ? { pendingBits: () => Atomics.load(header3, SAB_I_SIGNALS) } : {}
   });
-  publishStops(process, header3);
+  publishStops(process2, header3);
   const holds = new HeldPaths();
   opts.held?.add(holds);
   const token = holdingToken(opts, holds);
-  process.keptPath = (path) => holds.keptAt(path)?.hidden;
+  process2.keptPath = (path) => holds.keptAt(path)?.hidden;
   const worker = opts.createWorker();
   const dying = new Dying();
-  const dispatch2 = (req) => dying.serving(() => isWasmSyscall(req) ? process.syscall(req) : dispatchSyncFs(req));
+  const dispatch2 = (req) => dying.serving(() => isWasmSyscall(req) ? process2.syscall(req) : dispatchSyncFs(req));
   const responder = attachSyncSabResponder(worker, sab, token, { dispatch: dispatch2 });
   const lane = opts.program.abi === "js" ? openLane(token, dispatch2) : void 0;
   const { promise: exited, resolve: settle } = Promise.withResolvers();
@@ -9329,7 +9413,7 @@ function spawnWasmProcess(opts) {
     if (done4) return;
     done4 = true;
     dying.clear();
-    endedBy = sig ?? process.execTermsig;
+    endedBy = sig ?? process2.execTermsig;
     worker.removeEventListener("message", onMessage);
     worker.removeEventListener("error", onError);
     for (const tid of [...threads.keys()]) endThread(tid);
@@ -9338,7 +9422,7 @@ function spawnWasmProcess(opts) {
     revokeSyncFsToken(token);
     opts.held?.delete(holds);
     worker.terminate();
-    void process.exit().then(
+    void process2.exit().then(
       () => settle(code),
       () => settle(code)
     );
@@ -9406,14 +9490,14 @@ function spawnWasmProcess(opts) {
     tw.postMessage(tinit);
   };
   worker.postMessage(
-    processInit(opts, sab, process.umask, lane?.lane),
+    processInit(opts, sab, process2.umask, lane?.lane),
     transferOf(opts, lane?.lane)
   );
   const signal = (sig) => {
-    if (process.signal(sig) !== "terminate") return;
+    if (process2.signal(sig) !== "terminate") return;
     const code = sig === SIG.KILL ? 137 : 128 + sig;
     if (opts.program.abi !== "wasi" || done4) finish(code, sig);
-    else dying.start(code, sig, header3, process, () => finish(code, sig));
+    else dying.start(code, sig, header3, process2, () => finish(code, sig));
   };
   const kill = (code = 137) => finish(code, code > 128 && code < 160 ? code - 128 : void 0);
   return {
@@ -9422,10 +9506,10 @@ function spawnWasmProcess(opts) {
     kill,
     signal,
     termsig: () => endedBy,
-    onState: (listener) => process.onState(listener),
+    onState: (listener) => process2.onState(listener),
     memory: () => Atomics.load(header3, SAB_I_MEMORY) * 65536,
-    ignoredSignals: (fork) => process.inheritable(fork),
-    umask: () => process.umask,
+    ignoredSignals: (fork) => process2.inheritable(fork),
+    umask: () => process2.umask,
     writesBack: () => opts.program.abi === "wasi" && !done4
   };
 }
@@ -11013,15 +11097,20 @@ var Launcher = class {
     enableCdp(this.net, this.cdp);
     const fs = withCommandDirs(this.base, async () => new Set((await this.commands()).keys()));
     this.nodes = new VfsNodes(fs, (path) => this.released(path));
+    this.nodes.keepsOnDisk = true;
     this.openFiles.add(this.nodes);
+    const holders = [this.held, [this.nodes]];
     this.unlinked = new UnlinkedKeeper(
       fs,
-      this.held,
+      { [Symbol.iterator]: () => holders.flatMap((set2) => [...set2]).values() },
       (path) => this.mountRoot(path),
-      webLocks(),
-      (path) => [...this.openFiles].some((nodes) => nodes.holds(path))
+      {
+        locks: webLocks(),
+        busy: (path) => [...this.openFiles].some((nodes) => nodes.holds(path)),
+        owner: options.unlinkOwner
+      }
     );
-    this.fs = keepingOpen(this.unlinked.wrap(), this.nodes);
+    this.fs = this.unlinked.wrap(keepingOpen(fs, this.nodes));
     void this.unlinked.sweep("/");
     this.watchers.watch([this.modulesDir, this.pnpmHome], { recursive: true }, () => {
       this.catalog = void 0;
@@ -12718,6 +12807,7 @@ async function createNodeKernel(options = {}) {
   const transport = options.network?.transport;
   const launcher = new Launcher({
     fs,
+    unlinkOwner: pidOwner(process),
     createWorker: () => nodeWorker(file, live, terminated),
     createDriverWorker: () => nodeWorker(
       options.driverWorker ?? new URL("./node-driver-worker.js", import.meta.url),