@ai-ecoverse/slicc-kernel 1.83.0 → 1.84.1

package/dist/kernel-worker.js

@@ -117,6 +117,9 @@ var MemoryMeta = class {
   async remove(paths) {
     for (const path of paths) this.entries.deleteTree(path);
   }
+  absent(path) {
+    return !this.entries.has(path);
+  }
   async links(dir) {
     return [...this.entries.entries()].map(([, e]) => e).filter((entry) => entry.dir === dir);
   }
@@ -136,6 +139,8 @@ function settle(transaction, value) {
     transaction.onabort = () => reject(transaction.error ?? new Error("metadata transaction aborted"));
   });
 }
+var REMOVE_BATCH = 256;
+var REMOVE_WAIT_MS = 5;
 var IndexedDbMeta = class {
   db;
   cache = new PathMap();
@@ -171,6 +176,7 @@ var IndexedDbMeta = class {
   async get(paths) {
     const missing4 = paths.filter((path) => !this.cache.has(path));
     if (missing4.length > 0) {
+      this.settleRemoves();
       const generation = this.generation;
       const [transaction, store] = this.transaction("readonly");
       const found = /* @__PURE__ */ new Map();
@@ -188,6 +194,7 @@ var IndexedDbMeta = class {
     return paths.map((path) => this.cache.get(path) ?? void 0);
   }
   async update(path, change) {
+    this.settleRemoves();
     const [transaction, store] = this.transaction("readwrite");
     const request2 = store.get(path);
     let next2;
@@ -201,6 +208,7 @@ var IndexedDbMeta = class {
     this.cache.set(path, next2 ?? null);
   }
   async move(from, to, root) {
+    this.settleRemoves();
     const [transaction, store] = this.transaction("readwrite");
     store.delete(to);
     store.delete(descendants(to));
@@ -217,7 +225,28 @@ var IndexedDbMeta = class {
     await settle(transaction, () => void 0);
     this.changed({ trees: [from, to] });
   }
+  absent(path) {
+    return this.cache.has(path) && this.cache.get(path) === null;
+  }
+  removing = /* @__PURE__ */ new Map();
+  removeTimer;
   async remove(paths) {
+    this.settleRemoves();
+    return this.removeNow(paths);
+  }
+  async removeFile(path) {
+    const known = this.cache.get(path);
+    if (!known) return this.remove([path]);
+    this.generation++;
+    this.cache.set(path, null);
+    this.removing.set(path, JSON.stringify(known));
+    if (this.removing.size >= REMOVE_BATCH) return this.flushRemoves();
+    this.removeTimer ??= setTimeout(
+      () => void this.flushRemoves().catch(() => void 0),
+      REMOVE_WAIT_MS
+    );
+  }
+  async removeNow(paths) {
     const [transaction, store] = this.transaction("readwrite");
     for (const path of paths) {
       store.delete(path);
@@ -226,12 +255,33 @@ var IndexedDbMeta = class {
     await settle(transaction, () => void 0);
     this.changed({ trees: paths });
   }
+  settleRemoves() {
+    if (this.removing.size > 0) void this.flushRemoves().catch(() => void 0);
+  }
+  flushRemoves() {
+    clearTimeout(this.removeTimer);
+    this.removeTimer = void 0;
+    const batch = this.removing;
+    if (batch.size === 0) return Promise.resolve();
+    this.removing = /* @__PURE__ */ new Map();
+    const [transaction, store] = this.transaction("readwrite");
+    for (const [path, seen] of batch) {
+      const request2 = store.get(path);
+      request2.onsuccess = () => {
+        if (request2.result && JSON.stringify(request2.result) === seen) store.delete(path);
+      };
+    }
+    const paths = [...batch.keys()];
+    return settle(transaction, () => void this.channel.postMessage({ paths }));
+  }
   async links(dir) {
+    this.settleRemoves();
     const [transaction, store] = this.transaction("readonly");
     const request2 = store.index("dir").getAll(dir);
     return settle(transaction, () => request2.result);
   }
   async under(path) {
+    this.settleRemoves();
     const [transaction, store] = this.transaction("readonly");
     const self = store.get(path);
     const below = store.getAll(descendants(path));
@@ -243,6 +293,7 @@ var IndexedDbMeta = class {
     );
   }
   async all() {
+    this.settleRemoves();
     const [transaction, store] = this.transaction("readonly");
     const request2 = store.getAll();
     return settle(transaction, () => request2.result);
@@ -806,7 +857,14 @@ function sidecar(meta) {
   const guarded2 = (op) => (...args) => meta[op].apply(meta, args).catch((err) => {
     throw translate(err, pathOf(args), "sidecar", false);
   });
-  return Object.fromEntries(META_OPS.map((op) => [op, guarded2(op)]));
+  const ops = Object.fromEntries(META_OPS.map((op) => [op, guarded2(op)]));
+  if (meta.absent) ops.absent = meta.absent.bind(meta);
+  const { removeFile } = meta;
+  if (removeFile)
+    ops.removeFile = (path) => removeFile.call(meta, path).catch((err) => {
+      throw translate(err, path, "sidecar", false);
+    });
+  return ops;
 }
 function missing2(err) {
   const code = err?.code;
@@ -1503,6 +1561,7 @@ var OpfsFs = class {
       throw error;
     }
     this.refuse(found.path, true);
+    if (options.file && found.handle?.kind === "directory") throw fsError("EISDIR", path);
     if (found.handle) {
       const [dir, name2] = await this.parent(found.path);
       try {
@@ -1513,8 +1572,19 @@ var OpfsFs = class {
       } catch (err) {
         throw translate(err, path);
       }
-      this.changed(found.path);
+      const file = found.handle.kind === "file";
+      if (!file || this.remote?.watched()) this.changed(found.path);
+      else this.forget(found.path);
       this.movePending(found.path);
+      if (file && this.meta.absent?.(found.path)) {
+        this.touch(parentOf3(found.path));
+        return;
+      }
+      if (file && this.meta.removeFile) {
+        await this.meta.removeFile(found.path);
+        this.touch(parentOf3(found.path));
+        return;
+      }
     }
     await this.meta.remove([found.path]);
     this.touch(parentOf3(found.path));
@@ -7487,9 +7557,13 @@ function withCommandDirs(fs, names, userDir = async () => void 0, owners = false
 // src/fs/fresh-modules.ts
 var MAGIC = [0, 97, 115, 109];
 var MAX_FRESH = 65536;
+var DEFAULT_UMASK = 18;
 function isModule(bytes) {
   return MAGIC.every((b, i) => bytes[i] === b);
 }
+function within4(path, dir) {
+  return path.startsWith(dir === "/" ? "/" : `${dir}/`);
+}
 var FreshModules = class {
   fresh = /* @__PURE__ */ new Map();
   add(path, umask, pid) {
@@ -7497,17 +7571,40 @@ var FreshModules = class {
     this.fresh.delete(key);
     const oldest = this.fresh.size >= MAX_FRESH ? this.fresh.keys().next().value : void 0;
     if (oldest !== void 0) this.fresh.delete(oldest);
-    this.fresh.set(key, { umask: umask & 511, pid, added: 0 });
+    const mask = umask & 511;
+    this.fresh.set(key, { umask: mask, pid, added: 0, setup: mask !== DEFAULT_UMASK });
   }
   forget(pid) {
     for (const [path, fresh2] of this.fresh) if (fresh2.pid === pid) this.fresh.delete(path);
   }
+  drop(fresh2) {
+    for (const [key, note] of [...this.fresh]) if (note === fresh2) this.fresh.delete(key);
+  }
+  moved(from, to) {
+    const source = normalizePath(from);
+    const target = normalizePath(to);
+    if (source === target) return;
+    for (const key of [...this.fresh.keys()]) {
+      if (key === target || within4(key, target)) this.fresh.delete(key);
+    }
+    for (const [key, fresh2] of [...this.fresh]) {
+      if (key !== source && !within4(key, source)) continue;
+      this.fresh.delete(key);
+      this.fresh.set(target + key.slice(source.length), fresh2);
+    }
+  }
   wrap(fs) {
-    const decide = async (given, bytes) => {
+    const head = async (path) => {
+      if (fs.pread) return fs.pread(path, 0, MAGIC.length);
+      return (await fs.readFileBuffer(path)).subarray(0, MAGIC.length);
+    };
+    const decide = async (given, known) => {
       const path = normalizePath(given);
       const fresh2 = this.fresh.get(path);
-      if (!fresh2 || typeof bytes === "string" || bytes.length < MAGIC.length) return;
+      if (!fresh2) return;
+      const bytes = known && known.length >= MAGIC.length ? known : await head(path);
       const want = isModule(bytes) ? 73 & ~fresh2.umask : 0;
+      fresh2.setup = false;
       if (want === fresh2.added) return;
       const mode = (await fs.stat(path)).mode & 4095;
       await fs.chmod(path, mode & ~fresh2.added | want);
@@ -7516,32 +7613,47 @@ var FreshModules = class {
     const overrides = {
       writeFile: async (path, content, owner) => {
         await fs.writeFile(path, content, owner);
-        await decide(path, content);
+        if (this.fresh.has(normalizePath(path))) {
+          await decide(
+            path,
+            typeof content === "string" ? new TextEncoder().encode(content) : content
+          );
+        }
       },
       chmod: async (path, mode) => {
         const fresh2 = this.fresh.get(normalizePath(path));
-        const creating = fresh2?.added === 0 && (mode & 4095) === (438 & ~fresh2.umask);
-        if (!creating) this.fresh.delete(normalizePath(path));
+        if (fresh2?.setup && (mode & 4095) === (438 & ~fresh2.umask)) fresh2.setup = false;
+        else if (fresh2) this.drop(fresh2);
         await fs.chmod(path, mode);
       },
       rm: async (path, options) => {
-        this.fresh.delete(normalizePath(path));
         await fs.rm(path, options);
+        const at = normalizePath(path);
+        for (const key of [...this.fresh.keys()]) {
+          if (key === at || within4(key, at)) this.fresh.delete(key);
+        }
       },
       rename: async (from, to) => {
         await fs.rename(from, to);
-        const fresh2 = this.fresh.get(normalizePath(from));
-        this.fresh.delete(normalizePath(from));
-        this.fresh.delete(normalizePath(to));
+        this.moved(from, to);
+      },
+      link: async (from, to, follow2) => {
+        await fs.link(from, to, follow2);
+        const source = follow2 && fs.realpath ? await fs.realpath(from, true) : from;
+        const fresh2 = this.fresh.get(normalizePath(source));
         if (fresh2) this.fresh.set(normalizePath(to), fresh2);
       }
     };
     const ranged2 = rangedOps(fs);
     if (ranged2) {
       overrides.pwrite = async (path, at, bytes, transfer) => {
-        const head = at === 0 && this.fresh.has(normalizePath(path)) ? bytes.slice(0, 4) : void 0;
+        const touches2 = at < MAGIC.length && this.fresh.has(normalizePath(path));
         await ranged2.pwrite(path, at, bytes, transfer);
-        if (head) await decide(path, head);
+        if (touches2) await decide(path);
+      };
+      overrides.truncate = async (path, size) => {
+        await ranged2.truncate(path, size);
+        if (size < MAGIC.length && this.fresh.has(normalizePath(path))) await decide(path);
       };
     }
     const bound2 = /* @__PURE__ */ new WeakMap();
@@ -7613,7 +7725,7 @@ var UNLINKED_DIR = ".slicc-unlinked";
 function webLocks() {
   return globalThis.navigator?.locks;
 }
-var within4 = (path, target) => path === target || target === "/" || path.startsWith(`${target}/`);
+var within5 = (path, target) => path === target || target === "/" || path.startsWith(`${target}/`);
 var parentOf5 = (path) => path.slice(0, path.lastIndexOf("/")) || "/";
 var lockName = (instance) => `slicc-unlinked:${instance}`;
 var dirOf = (root) => root === "/" ? `/${UNLINKED_DIR}` : `${root}/${UNLINKED_DIR}`;
@@ -7713,7 +7825,7 @@ var UnlinkedKeeper = class {
     for (const holder of this.holders) {
       if (holder.owns(target)) continue;
       for (const path of holder.held()) {
-        if (!within4(path, target) || holder.isKept(path)) continue;
+        if (!within5(path, target) || holder.isKept(path)) continue;
         held.set(path, [...held.get(path) ?? [], holder]);
       }
     }
@@ -8336,7 +8448,7 @@ function parseSize(text) {
   if (!match) throw errnoError("EINVAL", `not a size: ${text}`);
   return Math.floor(Number(match[1]) * UNITS[match[2].toLowerCase()]);
 }
-var within5 = (path, target) => path === target || target === "/" || path.startsWith(`${target}/`);
+var within6 = (path, target) => path === target || target === "/" || path.startsWith(`${target}/`);
 var HeldSet = class extends Set {
   idle;
   constructor(idle) {
@@ -8355,7 +8467,7 @@ var HeldSet = class extends Set {
   }
 };
 function heldUnder(held, target) {
-  for (const paths of held) for (const path of paths.keys()) if (within5(path, target)) return true;
+  for (const paths of held) for (const path of paths.keys()) if (within6(path, target)) return true;
   return false;
 }
 var HeldPaths = class extends Map {
@@ -8471,24 +8583,24 @@ var HeldPaths = class extends Map {
     return this.owning === path;
   }
   revoke(prefix) {
-    for (const path of this.keys()) if (within5(path, prefix)) this.revoked.add(path);
+    for (const path of this.keys()) if (within6(path, prefix)) this.revoked.add(path);
   }
   renamed(from, to) {
     for (const [path, count2] of [...this]) {
-      if (!within5(path, from)) continue;
+      if (!within6(path, from)) continue;
       const moved2 = to + path.slice(from.length);
       this.delete(path);
       this.set(moved2, (this.get(moved2) ?? 0) + count2);
       if (this.revoked.delete(path)) this.revoked.add(moved2);
     }
     for (const [path, count2] of [...this.opens]) {
-      if (!within5(path, from)) continue;
+      if (!within6(path, from)) continue;
       const moved2 = to + path.slice(from.length);
       this.opens.delete(path);
       this.opens.set(moved2, (this.opens.get(moved2) ?? 0) + count2);
     }
     for (const [id2, key] of this.handles) {
-      if (within5(key, from)) this.handles.set(id2, to + key.slice(from.length));
+      if (within6(key, from)) this.handles.set(id2, to + key.slice(from.length));
     }
   }
   isRevoked(path) {
@@ -8592,10 +8704,14 @@ var MountTable = class {
       ...error ? { error } : {}
     });
   }
+  under(path) {
+    for (const mount of this.mounts.values()) if (within6(mount.target, path)) return true;
+    return false;
+  }
   locate(path) {
     let best;
     for (const mount of this.mounts.values()) {
-      if (within5(path, mount.target) && (!best || mount.target.length > best.target.length))
+      if (within6(path, mount.target) && (!best || mount.target.length > best.target.length))
         best = mount;
     }
     if (!best) return void 0;
@@ -8738,7 +8854,7 @@ var MountTable = class {
   async commitUnder(prefix) {
     const at = normalizePath(prefix);
     await Promise.all(
-      [...this.sessions.keys()].filter((p) => within5(p, at)).map((p) => this.commit(p))
+      [...this.sessions.keys()].filter((p) => within6(p, at)).map((p) => this.commit(p))
     );
   }
   async commitOverlapping(real, offset, length2) {
@@ -8773,10 +8889,10 @@ var MountTable = class {
   }
   forget(mount, path) {
     mount.epoch++;
-    for (const key of [...mount.attrs.keys()]) if (within5(key, path)) mount.attrs.delete(key);
+    for (const key of [...mount.attrs.keys()]) if (within6(key, path)) mount.attrs.delete(key);
     mount.lists.delete(path);
     mount.lists.delete(parentOf7(path));
-    for (const key of [...mount.lists.keys()]) if (within5(key, path)) mount.lists.delete(key);
+    for (const key of [...mount.lists.keys()]) if (within6(key, path)) mount.lists.delete(key);
   }
   async getattr(mount, path, rel2, settled = false) {
     for (let round = 1; ; round++) {
@@ -9161,9 +9277,12 @@ var MountFs = class {
   }
   async rm(path, options = {}) {
     const found = this.at(path);
+    if (!found && options.recursive && this.table.under(normalizePath(path)))
+      return this.rmAround(normalizePath(path), options);
     if (!found) return this.base.rm(path, options);
     const { mount, rel: rel2 } = found;
     const real = normalizePath(path);
+    if (rel2 === "/" && options.recursive) await this.rmEach(real, mount, rel2, options);
     if (rel2 === "/") throw errnoError("EBUSY", `${real} is a mount point`);
     this.writable(mount, real);
     await this.table.commitUnder(real);
@@ -9174,16 +9293,33 @@ var MountFs = class {
       if (options.force && err.code === "ENOENT") return;
       throw err;
     }
+    if (options.file && attr2.kind === "directory") throw errnoError("EISDIR", real);
     this.table.forget(mount, real);
     if (attr2.kind === "directory" && options.recursive) {
-      for (const entry of await this.table.readdir(mount, real, rel2)) {
-        await this.rm(`${real}/${entry.name}`, { recursive: true, force: options.force ?? false });
-      }
+      await this.rmEach(real, mount, rel2, { recursive: true, force: options.force ?? false });
       this.table.forget(mount, real);
     }
     await mount.conn.call({ op: attr2.kind === "directory" ? "rmdir" : "unlink", path: rel2 });
     this.table.forget(mount, real);
   }
+  async rmEach(real, mount, rel2, options) {
+    let first;
+    for (const entry of await this.table.readdir(mount, real, rel2)) {
+      await this.rm(joinName(real, entry.name), options).catch((err) => {
+        first ??= err;
+      });
+    }
+    if (first) throw first;
+  }
+  async rmAround(path, options) {
+    let first;
+    for (const name2 of await this.base.readdir(path)) {
+      await this.rm(joinName(path, name2), options).catch((err) => {
+        first ??= err;
+      });
+    }
+    throw first ?? errnoError("EBUSY", `${path} holds a mount point`);
+  }
   async rename(from, to) {
     const a = this.at(from);
     const b = this.at(to);
@@ -9411,6 +9547,11 @@ function statJson(s) {
 async function readdirStat(fs, dir) {
   return (await fs.readdirStat(dir)).map(([name2, stat]) => [name2, stat && statJson(stat)]);
 }
+async function usageAt(entry, path) {
+  if (!entry.statfs) return void 0;
+  const real = await realTarget(entry.fs, path).catch(() => path);
+  return entry.statfs(real);
+}
 async function storageUsage() {
   const estimate = await globalThis.navigator?.storage?.estimate?.();
   if (typeof estimate?.quota !== "number") return null;
@@ -9482,8 +9623,7 @@ async function run(entry, path, req) {
       await fs.link(path, fs.resolvePath(cwd, req.arg2 ?? ""), req.mode === 1);
       return done;
     case "unlink":
-      if ((await fs.lstat(path)).isDirectory) throw syncError("EISDIR", path);
-      await fs.rm(path);
+      await fs.rm(path, { file: true });
       return done;
     case "rmdir":
       if (!(await fs.lstat(path)).isDirectory) throw syncError("ENOTDIR", path);
@@ -9717,6 +9857,26 @@ async function dispatchSyncFs(req) {
     return toErrno(err);
   }
 }
+var DENIED = /* @__PURE__ */ new Set(["EACCES", "EPERM"]);
+async function rmPermitted(entry, path, req, refused2) {
+  const st = await entry.fs.lstat(path).catch(() => void 0);
+  if (!st?.isDirectory) return refused2;
+  const unlisted = await guarded(entry, path, { ...req, op: "readdir" });
+  if (unlisted) return unlisted;
+  const names = await entry.fs.readdir(path).catch(() => void 0);
+  if (!names) return refused2;
+  let first;
+  for (const name2 of names) {
+    const child = await dispatchOne(entry, {
+      ...req,
+      path: joinName(path, name2)
+    });
+    if (!child.ok) first ??= child;
+  }
+  if (first) return first;
+  const again = await guarded(entry, path, req);
+  return again ?? await run(entry, path, req);
+}
 async function dispatchOne(entry, req) {
   const { fs, cwd } = entry;
   try {
@@ -9726,8 +9886,11 @@ async function dispatchOne(entry, req) {
     if (req.op === "access") return await accessOp(entry, path, req);
     if (req.op === "hold") return await holdOp(entry, path, req);
     const refused2 = await guarded(entry, path, req);
+    if (refused2 && req.op === "rm" && !refused2.ok && DENIED.has(refused2.errno)) {
+      return await rmPermitted(entry, path, req, refused2);
+    }
     if (refused2) return refused2;
-    if (req.op === "statfs") return json2(await entry.statfs?.(path) ?? await storageUsage());
+    if (req.op === "statfs") return json2(await usageAt(entry, path) ?? await storageUsage());
     if (entry.revoked?.(path)) return { ok: false, errno: "EIO", message: `${path} was unmounted` };
     if (req.op === "write" && req.mode === 1 || UNLINKED_OPS.has(req.op)) {
       const serve = async () => run(entry, await keptOr(entry, path, req.handle), req);
@@ -11961,7 +12124,7 @@ function isMissing(err) {
   if (err?.code === "ENOENT") return true;
   return err instanceof Error && err.message.startsWith("ENOENT");
 }
-function within6(path, root) {
+function within7(path, root) {
   return path === root || path.startsWith(root.endsWith("/") ? root : `${root}/`);
 }
 var VfsNode = class {
@@ -12282,12 +12445,12 @@ var VfsNodes = class {
     return node;
   }
   holds(prefix) {
-    for (const path of this.byPath.keys()) if (within6(path, prefix)) return true;
+    for (const path of this.byPath.keys()) if (within7(path, prefix)) return true;
     return false;
   }
   writes(prefix) {
     for (const [path, node] of this.byPath)
-      if (node.writers > 0 && within6(path, prefix)) return true;
+      if (node.writers > 0 && within7(path, prefix)) return true;
     return false;
   }
   closed(node, writable2 = false) {
@@ -12331,11 +12494,11 @@ var VfsNodes = class {
     this.kept.delete(node);
   }
   async flush(path) {
-    for (const [p, node] of this.byPath) if (within6(p, path)) await node.serial(() => node.flush());
+    for (const [p, node] of this.byPath) if (within7(p, path)) await node.serial(() => node.flush());
   }
   async unlinking(path) {
     for (const [held, node] of [...this.byPath]) {
-      if (!within6(held, path)) continue;
+      if (!within7(held, path)) continue;
       await node.serial(async () => {
         await Promise.all([this.keepsOnDisk || node.keep(), node.limit()]);
       });
@@ -12343,14 +12506,14 @@ var VfsNodes = class {
   }
   revoke(prefix) {
     for (const [path, node] of [...this.byPath]) {
-      if (!within6(path, prefix)) continue;
+      if (!within7(path, prefix)) continue;
       node.revoke();
       this.forget(node);
     }
   }
   unlinked(path) {
     for (const [held, node] of [...this.byPath]) {
-      if (!within6(held, path) || this.byPath.get(held) !== node) continue;
+      if (!within7(held, path) || this.byPath.get(held) !== node) continue;
       if (!this.dropName(held, node)) this.orphan(node);
     }
   }
@@ -12358,8 +12521,8 @@ var VfsNodes = class {
     if (from === to) return;
     const moved2 = [];
     for (const [p, node] of [...this.byPath]) {
-      if (within6(p, from)) moved2.push([p, node]);
-      else if (within6(p, to) && this.byPath.get(p) === node && !this.dropName(p, node)) {
+      if (within7(p, from)) moved2.push([p, node]);
+      else if (within7(p, to) && this.byPath.get(p) === node && !this.dropName(p, node)) {
         this.orphan(node);
       }
     }
@@ -12638,7 +12801,7 @@ function isWasmSyscall(req) {
 var MAX_READ = 1024 * 1024;
 var WRITE_ACCESS = 3;
 var KEYBOARD = /* @__PURE__ */ new Set([SIG.INT, SIG.QUIT, SIG.TSTP]);
-var DEFAULT_UMASK = 18;
+var DEFAULT_UMASK2 = 18;
 function words(value) {
   if (!Array.isArray(value) || !value.every((w) => typeof w === "string")) {
     throw new KernelError("EINVAL");
@@ -12666,7 +12829,7 @@ var WasmProcess = class {
   interrupt = new AbortController();
   gone = new AbortController();
   dying = false;
-  umask = DEFAULT_UMASK;
+  umask = DEFAULT_UMASK2;
   cred;
   execChild;
   killed = false;
@@ -12688,7 +12851,7 @@ var WasmProcess = class {
     this.fds = fds;
     this.options = options;
     this.inherited = options.ignored ?? 0;
-    this.umask = options.umask ?? DEFAULT_UMASK;
+    this.umask = options.umask ?? DEFAULT_UMASK2;
     this.cred = copyCred(options.cred ?? ROOT);
     this.children = new ChildTable(fds, options.spawner, options.forker);
     this.nodes = options.nodes ?? new VfsNodes(options.fs);
@@ -18271,7 +18434,7 @@ var Launcher = class {
     }
   }
   umaskOf(pid) {
-    return this.processes.get(pid)?.umask?.() ?? DEFAULT_UMASK;
+    return this.processes.get(pid)?.umask?.() ?? DEFAULT_UMASK2;
   }
   imageOf(pid) {
     const members = this.jobs.list();