@ai-ecoverse/slicc-kernel 1.54.2 → 1.54.4

package/dist/kernel-worker.js

@@ -1188,6 +1188,32 @@ function bytesSource(data) {
     }
   });
 }
+function memoryFile(data, path, position = 0) {
+  let offset = position;
+  return new OpenFile({
+    read: async (max) => {
+      const out = data.subarray(offset, offset + max);
+      offset += out.length;
+      return out;
+    },
+    pread: async (max, at) => data.subarray(at, at + max),
+    seek: async (by, whence) => {
+      const at = (whence === 1 ? offset : whence === 2 ? data.length : 0) + by;
+      if (at < 0) throw new KernelError("EINVAL");
+      offset = at;
+      return at;
+    },
+    pwrite: async () => {
+      throw new KernelError("EBADF");
+    },
+    resize: async () => {
+      throw new KernelError("EBADF");
+    },
+    stat: async () => ({ path, size: data.length }),
+    close: () => {
+    }
+  });
+}
 function sinkFile(onData) {
   return new OpenFile({
     write: async (bytes) => {
@@ -7459,150 +7485,728 @@ function attachSyncSabResponder(port, sab, token, opts) {
   };
 }
 
-// src/kernel/host-ops.ts
-var HOST_OPS = [
-  "lock",
-  "unlock",
-  "async-submit",
-  "async-wait",
-  "async-take",
-  "async-resolve",
-  "async-hold",
-  "async-cancel",
-  "async-close"
-];
-var json3 = (value) => ({ ok: true, kind: "json", json: value });
-var done2 = { ok: true, kind: "void" };
-var LockTable = class {
-  held = /* @__PURE__ */ new Map();
-  lock(pid, path, exclusive, fd) {
-    const holders = this.held.get(path) ?? /* @__PURE__ */ new Map();
-    for (const [other, h] of holders) if (other !== pid && (exclusive || h.exclusive)) return false;
-    const mine = holders.get(pid) ?? { exclusive, fds: /* @__PURE__ */ new Set() };
-    mine.exclusive = exclusive;
-    mine.fds.add(fd);
-    holders.set(pid, mine);
-    this.held.set(path, holders);
-    return true;
+// src/process/process-fds.ts
+var field2 = (text) => (text || "none").replace(/[\s\\]/g, (c) => `\\${c.charCodeAt(0).toString(8).padStart(3, "0")}`);
+function mountTable(mounts = []) {
+  const root = globalThis.navigator?.storage ? "opfs" : "memory";
+  const lines2 = [`${root} / ${root} rw 0 0`, "devfs /dev devfs rw 0 0", "proc /proc proc rw 0 0"];
+  for (const m of mounts) {
+    const options = Object.entries(m.options).map(([k, v]) => v === "" ? k : `${k}=${v}`);
+    if (m.state !== "ok") options.push(m.state);
+    const access = options.includes("ro") ? [] : ["rw"];
+    lines2.push(
+      `${field2(m.source)} ${field2(m.target)} ${m.type} ${[...access, ...options].join(",")} 0 0`
+    );
   }
-  unlock(pid, path) {
-    const holders = this.held.get(path);
-    holders?.delete(pid);
-    if (holders?.size === 0) this.held.delete(path);
+  return `${lines2.join("\n")}
+`;
+}
+
+// src/process/procfs.ts
+var HZ = 100;
+var KIB = 1024;
+var FALLBACK_MEMORY = 4 * KIB * KIB * KIB;
+var PID_FILES = ["cmdline", "comm", "stat", "statm", "status"];
+var SYSTEM_FILES = ["loadavg", "meminfo", "stat", "uptime"];
+function commOf(info) {
+  const name2 = info.argv[0] ?? "";
+  return name2.slice(name2.lastIndexOf("/") + 1).slice(0, 15);
+}
+function ttyNumber(tty) {
+  const pts = tty && /^\/dev\/pts\/(\d+)$/.exec(tty);
+  if (pts) return 136 << 8 | Number(pts[1]);
+  const vt = tty && /^\/dev\/tty(\d+)$/.exec(tty);
+  return vt ? 4 << 8 | Number(vt[1]) : 0;
+}
+function pages(bytes) {
+  return Math.ceil(bytes / 4096);
+}
+function ticks(ms) {
+  return Math.max(0, Math.floor(ms * HZ / 1e3));
+}
+function pidStat(info, boot) {
+  const fields = [
+    info.pid,
+    `(${commOf(info)})`,
+    info.state,
+    info.ppid,
+    info.pgid,
+    info.sid,
+    ttyNumber(info.tty),
+    info.tty ? info.pgid : -1,
+    4194304,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    20,
+    0,
+    1,
+    0,
+    ticks(info.started - boot),
+    info.memory,
+    pages(info.memory),
+    "18446744073709551615",
+    ...Array(12).fill(0),
+    17,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    ...Array(7).fill(0),
+    0
+  ];
+  return `${fields.join(" ")}
+`;
+}
+var sigMask = (mask = 0) => (mask >>> 1).toString(16).padStart(16, "0");
+function pidStatus(info) {
+  const state = info.state === "Z" ? "Z (zombie)" : "S (sleeping)";
+  const c = info.cred ?? ROOT;
+  const ids = (r, e, s) => `${r}	${e}	${s}	${e}`;
+  return [
+    `Name:	${commOf(info)}`,
+    `Umask:	${(info.umask ?? 18).toString(8).padStart(4, "0")}`,
+    `State:	${state}`,
+    `Tgid:	${info.pid}`,
+    "Ngid:	0",
+    `Pid:	${info.pid}`,
+    `PPid:	${info.ppid}`,
+    "TracerPid:	0",
+    `Uid:	${ids(c.ruid, c.euid, c.suid)}`,
+    `Gid:	${ids(c.rgid, c.egid, c.sgid)}`,
+    "FDSize:	64",
+    `VmSize:	${Math.ceil(info.memory / KIB)} kB`,
+    `VmRSS:	${Math.ceil(info.memory / KIB)} kB`,
+    `Groups:	${c.groups.join(" ")}`,
+    `NSpid:	${info.pid}`,
+    `NSpgid:	${info.pgid}`,
+    `NSsid:	${info.sid}`,
+    "Threads:	1",
+    "SigQ:	0/0",
+    "SigPnd:	0000000000000000",
+    "ShdPnd:	0000000000000000",
+    "SigBlk:	0000000000000000",
+    `SigIgn:	${sigMask(info.sigIgn)}`,
+    `SigCgt:	${sigMask(info.sigCgt)}`,
+    ""
+  ].join("\n");
+}
+function pidFile(name2, info, boot) {
+  if (name2 === "cmdline") return info.state === "Z" ? "" : `${info.argv.join("\0")}\0`;
+  if (name2 === "comm") return `${commOf(info)}
+`;
+  if (name2 === "stat") return pidStat(info, boot);
+  if (name2 === "statm") {
+    const p = pages(info.memory);
+    return `${p} ${p} 0 0 0 ${p} 0
+`;
   }
-  closed(pid, fd) {
-    for (const [path, holders] of [...this.held]) {
-      const mine = holders.get(pid);
-      if (mine?.fds.delete(fd) && mine.fds.size === 0) this.unlock(pid, path);
-    }
+  return pidStatus(info);
+}
+function memoryInfo(source, used = 0) {
+  const total = source.deviceMemory ? source.deviceMemory * KIB * KIB * KIB : FALLBACK_MEMORY;
+  const free = Math.max(0, total - used - (source.usedHeap ?? 0));
+  const kb = (bytes) => `${Math.floor(bytes / KIB)} kB`;
+  return [
+    ["MemTotal", kb(total)],
+    ["MemFree", kb(free)],
+    ["MemAvailable", kb(free)],
+    ["Buffers", kb(0)],
+    ["Cached", kb(0)],
+    ["SwapCached", kb(0)],
+    ["Shmem", kb(0)],
+    ["SReclaimable", kb(0)],
+    ["SwapTotal", kb(0)],
+    ["SwapFree", kb(0)]
+  ].map(([key, value]) => `${`${key}:`.padEnd(16)}${value.padStart(12)}`).concat("").join("\n");
+}
+function systemFile(name2, listing, now, memory) {
+  const up = Math.max(0, now - listing.boot) / 1e3;
+  if (name2 === "uptime") return `${up.toFixed(2)} ${up.toFixed(2)}
+`;
+  if (name2 === "meminfo") {
+    return memoryInfo(
+      memory,
+      listing.processes.reduce((sum, p) => sum + p.memory, 0)
+    );
   }
-  release(pid) {
-    for (const path of [...this.held.keys()]) this.unlock(pid, path);
+  const live = listing.processes.filter((p) => p.state !== "Z");
+  if (name2 === "loadavg") {
+    const last = Math.max(0, ...listing.processes.map((p) => p.pid));
+    return `0.00 0.00 0.00 1/${live.length} ${last}
+`;
   }
-};
-var AsyncOps = class {
-  next = 1;
-  results = /* @__PURE__ */ new Map();
-  ready = [];
-  running = /* @__PURE__ */ new Map();
-  waiters = /* @__PURE__ */ new Set();
-  closed = false;
-  run;
-  onReady;
-  constructor(run2, onReady) {
-    this.run = run2;
-    this.onReady = onReady;
+  const idle = ticks(now - listing.boot);
+  return [
+    `cpu  0 0 0 ${idle} 0 0 0 0 0 0`,
+    `cpu0 0 0 0 ${idle} 0 0 0 0 0 0`,
+    "intr 0",
+    "ctxt 0",
+    `btime ${Math.floor(listing.boot / 1e3)}`,
+    `processes ${listing.processes.length}`,
+    "procs_running 1",
+    "procs_blocked 0",
+    ""
+  ].join("\n");
+}
+function memorySource(scope = globalThis) {
+  const nav = scope.navigator;
+  const perf = scope.performance;
+  const deviceMemory = nav?.deviceMemory;
+  const used = perf?.memory?.usedJSHeapSize;
+  return {
+    ...typeof deviceMemory === "number" && deviceMemory > 0 ? { deviceMemory } : {},
+    ...typeof used === "number" ? { usedHeap: used } : {}
+  };
+}
+
+// src/fs/pages.ts
+var PAGE = 64 * 1024;
+var READAHEAD = 1024 * 1024;
+var CLEAN_LIMIT = 4 * 1024 * 1024;
+var WRITEBACK = 8 * 1024 * 1024;
+var RUN = 1024 * 1024;
+var Pages = class {
+  length;
+  stored;
+  shrink;
+  pages = /* @__PURE__ */ new Map();
+  dirty = /* @__PURE__ */ new Set();
+  free = [];
+  pinned = false;
+  constructor(size) {
+    this.length = size;
+    this.stored = size;
   }
-  submit(req) {
-    const id2 = this.hold();
-    const running = new AbortController();
-    this.running.set(id2, running);
-    this.run(req, running.signal).then(
-      (result) => this.complete(id2, result),
-      (err) => this.complete(id2, { ok: false, errno: "EIO", message: String(err) })
-    );
-    return id2;
+  get dirtyBytes() {
+    return this.dirty.size * PAGE;
   }
-  resolve(value) {
-    const id2 = this.hold();
-    this.complete(id2, json3(value));
-    return id2;
+  get changed() {
+    return this.dirty.size > 0 || this.shrink !== void 0 || this.length !== this.stored;
   }
-  hold() {
-    const id2 = this.next++;
-    this.results.set(id2, void 0);
-    return id2;
+  missing(at, length2) {
+    this.evict();
+    const end = Math.min(this.stored, at + length2, this.length);
+    const runs = [];
+    for (let page = Math.floor(at / PAGE); page * PAGE < end; page++) {
+      if (this.pages.has(page)) continue;
+      const last2 = runs[runs.length - 1];
+      if (last2 && last2[0] + last2[1] === page * PAGE) last2[1] += PAGE;
+      else runs.push([page * PAGE, PAGE]);
+    }
+    const last = runs[runs.length - 1];
+    if (last) last[1] = Math.max(last[1], Math.min(READAHEAD, this.stored - last[0]));
+    return runs.map(([start2, n]) => [start2, Math.min(n, this.stored - start2)]);
   }
-  take(id2) {
-    if (!this.results.has(id2)) throw new KernelError("EINVAL");
-    const result = this.results.get(id2);
-    if (!result) throw new KernelError("EAGAIN");
-    this.forget(id2);
-    return result;
+  partial(at, length2) {
+    if (length2 === 0) return [];
+    this.evict();
+    const edges = /* @__PURE__ */ new Set([Math.floor(at / PAGE), Math.floor((at + length2 - 1) / PAGE)]);
+    const runs = [];
+    for (const page of edges) {
+      const start2 = page * PAGE;
+      const covered = at <= start2 && at + length2 >= start2 + PAGE;
+      if (covered || this.pages.has(page) || start2 >= this.stored) continue;
+      runs.push([start2, Math.min(PAGE, this.stored - start2)]);
+    }
+    return runs;
   }
-  cancel(id2) {
-    this.running.get(id2)?.abort();
-    this.forget(id2);
+  fill(start2, bytes) {
+    for (let at = 0; at < bytes.length; at += PAGE) {
+      const page = (start2 + at) / PAGE;
+      if (this.pages.has(page)) continue;
+      const part = bytes.subarray(at, Math.min(at + PAGE, bytes.length));
+      const fresh = this.take(part.length);
+      fresh.set(part);
+      this.pages.set(page, fresh);
+    }
   }
-  forget(id2) {
-    this.running.delete(id2);
-    this.results.delete(id2);
-    const at = this.ready.indexOf(id2);
-    if (at >= 0) this.ready.splice(at, 1);
+  read(at, length2) {
+    const out = new Uint8Array(Math.max(0, Math.min(this.length, at + length2) - at));
+    this.readInto(at, out);
+    return out;
   }
-  async wait(timeoutMs, signal) {
-    for (; ; ) {
-      if (this.closed) return -1;
-      const id2 = this.ready.shift();
-      if (id2 !== void 0) return id2;
-      if (timeoutMs !== void 0 && timeoutMs <= 0) return 0;
-      const woke = await this.sleep(timeoutMs, signal);
-      if (!woke) return 0;
+  readInto(at, out) {
+    const end = Math.min(this.length, at + out.length);
+    for (let pos = at; pos < end; ) {
+      const page = Math.floor(pos / PAGE);
+      const from = pos - page * PAGE;
+      const n = Math.min(PAGE - from, end - pos);
+      const bytes = this.pages.get(page);
+      if (bytes) out.set(bytes.subarray(from, from + n), pos - at);
+      else out.fill(0, pos - at, pos - at + n);
+      pos += n;
     }
+    return Math.max(0, end - at);
   }
-  close() {
-    this.closed = true;
-    this.wake();
-  }
-  sleep(timeoutMs, signal) {
-    return new Promise((resolve, reject) => {
-      let timer;
-      const cleanup = () => {
-        clearTimeout(timer);
-        this.waiters.delete(wake);
-        signal.removeEventListener("abort", abort);
-      };
-      const wake = () => {
-        cleanup();
-        resolve(true);
-      };
-      const abort = () => {
-        cleanup();
-        reject(new KernelError("EINTR"));
-      };
-      this.waiters.add(wake);
-      signal.addEventListener("abort", abort, { once: true });
-      if (timeoutMs !== void 0) {
-        timer = setTimeout(() => {
-          cleanup();
-          resolve(false);
-        }, timeoutMs);
+  write(at, bytes) {
+    for (let done4 = 0; done4 < bytes.length; ) {
+      const pos = at + done4;
+      const page = Math.floor(pos / PAGE);
+      const from = pos - page * PAGE;
+      const n = Math.min(PAGE - from, bytes.length - done4);
+      let target = this.pages.get(page);
+      if (!target) {
+        target = this.take(0);
+        this.pages.set(page, target);
       }
-    });
-  }
-  complete(id2, result) {
-    this.running.delete(id2);
-    if (!this.results.has(id2)) return;
-    this.results.set(id2, result);
-    this.ready.push(id2);
-    this.wake();
-    this.onReady?.();
+      target.set(bytes.subarray(done4, done4 + n), from);
+      this.dirty.add(page);
+      done4 += n;
+    }
+    this.length = Math.max(this.length, at + bytes.length);
   }
-  wake() {
-    for (const wake of [...this.waiters]) wake();
+  truncate(size) {
+    if (size < this.stored) {
+      this.stored = size;
+      this.shrink = Math.min(this.shrink ?? size, size);
+    }
+    if (size < this.length) {
+      const edge = Math.floor(size / PAGE);
+      for (const page of [...this.pages.keys()]) {
+        if (page > edge || page === edge && size === edge * PAGE) this.drop(page);
+      }
+      this.pages.get(edge)?.fill(0, size - edge * PAGE);
+    }
+    this.length = size;
   }
-};
-async function hostSyscall(req, ctx) {
+  plan() {
+    const runs = [];
+    const sorted = [...this.dirty].sort((a, b) => a - b);
+    for (let i = 0; i < sorted.length; ) {
+      let j = i + 1;
+      const first = sorted[i];
+      while (j < sorted.length && sorted[j] === first + (j - i) && sorted[j] * PAGE % RUN !== 0) {
+        j++;
+      }
+      const start2 = first * PAGE;
+      const end = Math.min(this.length, (first + (j - i)) * PAGE);
+      const bytes = new Uint8Array(end - start2);
+      for (let k = i; k < j; k++) {
+        const page = this.pages.get(sorted[k]);
+        bytes.set(page.subarray(0, Math.min(PAGE, end - (k - i) * PAGE - start2)), (k - i) * PAGE);
+      }
+      runs.push({ offset: start2, bytes });
+      i = j;
+    }
+    const written2 = Math.max(this.stored, ...runs.map((r) => r.offset + r.bytes.length));
+    return {
+      ...this.shrink !== void 0 ? { shrink: this.shrink } : {},
+      runs,
+      ...this.length > written2 ? { extend: this.length } : {}
+    };
+  }
+  flushed() {
+    this.dirty.clear();
+    this.shrink = void 0;
+    this.stored = this.length;
+    this.evict();
+  }
+  pin() {
+    this.pinned = true;
+  }
+  reset(size) {
+    if (this.pinned) return;
+    for (const page of [...this.pages.keys()]) if (!this.dirty.has(page)) this.drop(page);
+    if (this.changed) return;
+    this.length = size;
+    this.stored = size;
+  }
+  evict() {
+    if (this.pinned) return;
+    let clean = (this.pages.size - this.dirty.size) * PAGE;
+    for (const page of this.pages.keys()) {
+      if (clean <= CLEAN_LIMIT) return;
+      if (this.dirty.has(page)) continue;
+      this.drop(page);
+      clean -= PAGE;
+    }
+  }
+  take(used) {
+    const page = this.free.pop();
+    if (!page) return new Uint8Array(PAGE);
+    page.fill(0, used);
+    return page;
+  }
+  drop(page) {
+    const bytes = this.pages.get(page);
+    this.pages.delete(page);
+    this.dirty.delete(page);
+    if (this.free.length < CLEAN_LIMIT / PAGE) this.free.push(bytes);
+  }
+};
+
+// src/fs/ranged.ts
+var AsyncRangedFile = class {
+  pages;
+  io;
+  pinned = false;
+  version;
+  path;
+  constructor(io, path, size, version) {
+    this.io = io;
+    this.path = path;
+    this.version = version;
+    this.pages = new Pages(size);
+  }
+  size() {
+    return this.pages.length;
+  }
+  async fetch(runs) {
+    for (const [start2, n] of runs) {
+      this.pages.fill(start2, await this.io.pread(this.path, start2, n, this.version));
+    }
+  }
+  async read(at, length2) {
+    await this.fetch(this.pages.missing(at, length2));
+    return this.pages.read(at, length2);
+  }
+  async write(at, bytes) {
+    await this.fetch(this.pages.partial(at, bytes.length));
+    this.pages.write(at, bytes);
+    if (!this.pinned && this.pages.dirtyBytes >= WRITEBACK) await this.flush();
+  }
+  truncate(size) {
+    this.pages.truncate(size);
+  }
+  async flush() {
+    if (this.pinned || !this.pages.changed) return;
+    const plan = this.pages.plan();
+    if (plan.shrink !== void 0) await this.io.truncate(this.path, plan.shrink);
+    for (const run2 of plan.runs) await this.io.pwrite(this.path, run2.offset, run2.bytes, true);
+    if (plan.extend !== void 0) await this.io.truncate(this.path, plan.extend);
+    this.version = void 0;
+    this.pages.flushed();
+  }
+  async pin() {
+    this.pinned = true;
+    this.pages.pin();
+    await this.fetch(this.pages.missing(0, this.pages.length));
+  }
+};
+
+// src/process/wasi/wasi-files.ts
+function normalize(path) {
+  const out = [];
+  for (const seg of path.split("/")) {
+    if (seg === "" || seg === ".") continue;
+    if (seg === "..") out.pop();
+    else out.push(seg);
+  }
+  return `/${out.join("/")}`;
+}
+
+// src/process/wasi/wasi-procfs.ts
+var DIR_MODE = 16749;
+var FILE_MODE = 33060;
+var LINK_MODE = 41471;
+var PID_NAMES = PID_FILES;
+var SYSTEM_NAMES = SYSTEM_FILES;
+function inProc(path) {
+  return path === "/proc" || path.startsWith("/proc/");
+}
+var ProcTree = class {
+  source;
+  pid;
+  memory;
+  constructor(source, pid, memory = memorySource()) {
+    this.source = source;
+    this.pid = pid;
+    this.memory = memory;
+  }
+  listing() {
+    return this.source.procList();
+  }
+  alive(pid) {
+    return this.listing().processes.some((p) => p.pid === pid);
+  }
+  node(parts) {
+    const [top, leaf, ...rest2] = parts;
+    if (top === void 0) {
+      return {
+        kind: "dir",
+        names: () => [
+          ...SYSTEM_NAMES,
+          "mounts",
+          "self",
+          ...this.listing().processes.map((p) => String(p.pid))
+        ]
+      };
+    }
+    if (top === "self") {
+      return leaf === void 0 ? { kind: "link", target: String(this.pid) } : void 0;
+    }
+    if (leaf === void 0 && top === "mounts") {
+      return { kind: "file", content: () => mountTable(this.source.mountList()) };
+    }
+    if (leaf === void 0 && SYSTEM_NAMES.includes(top)) {
+      return {
+        kind: "file",
+        content: () => systemFile(top, this.listing(), Date.now(), this.memory)
+      };
+    }
+    if (!/^[1-9]\d*$/.test(top) || rest2.length > 0 || !this.alive(Number(top))) return void 0;
+    if (leaf === void 0) return { kind: "dir", names: () => [...PID_NAMES] };
+    if (!PID_NAMES.includes(leaf)) return void 0;
+    return {
+      kind: "file",
+      content: () => {
+        const listing = this.listing();
+        const info = listing.processes.find((p) => p.pid === Number(top));
+        if (!info) throw syncError("ENOENT", `/proc/${top}/${leaf}`);
+        return pidFile(leaf, info, listing.boot);
+      }
+    };
+  }
+  parts(path, follow2) {
+    const parts = path.split("/").filter((p) => p !== "").slice(1);
+    if (parts[0] === "self" && (follow2 || parts.length > 1)) parts[0] = String(this.pid);
+    return parts;
+  }
+  find(path, follow2) {
+    const node = this.node(this.parts(path, follow2));
+    if (!node) throw syncError("ENOENT", path);
+    return node;
+  }
+  stat(path, follow2 = true) {
+    const node = this.find(path, follow2);
+    const base = {
+      isFile: false,
+      isDirectory: false,
+      size: 0,
+      mtimeMs: Date.now(),
+      readonly: true
+    };
+    if (node.kind === "dir") return { ...base, isDirectory: true, mode: DIR_MODE };
+    if (node.kind === "link") {
+      return { ...base, isSymbolicLink: true, mode: LINK_MODE, size: node.target.length };
+    }
+    return { ...base, isFile: true, mode: FILE_MODE, size: this.bytes(node).length };
+  }
+  bytes(node) {
+    return new TextEncoder().encode(node.kind === "file" ? node.content() : "");
+  }
+  read(path) {
+    const node = this.find(path, true);
+    if (node.kind !== "file") throw syncError("EISDIR", path);
+    return this.bytes(node);
+  }
+  readdir(path) {
+    const node = this.find(path, true);
+    if (node.kind !== "dir") throw syncError("ENOTDIR", path);
+    return node.names();
+  }
+  readlink(path) {
+    const node = this.find(path, false);
+    if (node.kind !== "link") throw syncError("EINVAL", path);
+    return node.target;
+  }
+  exists(path) {
+    try {
+      this.find(path, true);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+var MAX_HOPS2 = 40;
+function* procWalk(path, follow2) {
+  let done4 = [];
+  let todo = path.split("/").filter((part) => part !== "");
+  let hops = 0;
+  while (todo.length > 0) {
+    const part = todo.shift();
+    if (part === ".") continue;
+    if (part === "..") {
+      done4.pop();
+      continue;
+    }
+    const at = `/${[...done4, part].join("/")}`;
+    const whole = normalize(`/${[...done4, 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) done4.push(part);
+    else {
+      if (++hops > MAX_HOPS2) return void 0;
+      if (target.startsWith("/")) done4 = [];
+      todo = [...target.split("/").filter((part2) => part2 !== ""), ...todo];
+    }
+  }
+  return void 0;
+}
+async function procAlias(fs, path, follow2) {
+  const { readlink, lstat } = fs;
+  if (!readlink || !lstat) return void 0;
+  const physical = await lstat.call(fs, "/proc").then(
+    () => true,
+    () => false
+  );
+  if (!physical) return void 0;
+  const walk = procWalk(path, follow2);
+  let step = walk.next();
+  while (!step.done) {
+    const target = await readlink.call(fs, step.value).catch(() => void 0);
+    step = walk.next(target);
+  }
+  return step.value;
+}
+
+// src/kernel/host-ops.ts
+var HOST_OPS = [
+  "lock",
+  "unlock",
+  "async-submit",
+  "async-wait",
+  "async-take",
+  "async-resolve",
+  "async-hold",
+  "async-cancel",
+  "async-close"
+];
+var json3 = (value) => ({ ok: true, kind: "json", json: value });
+var done2 = { ok: true, kind: "void" };
+var LockTable = class {
+  held = /* @__PURE__ */ new Map();
+  lock(pid, path, exclusive, fd) {
+    const holders = this.held.get(path) ?? /* @__PURE__ */ new Map();
+    for (const [other, h] of holders) if (other !== pid && (exclusive || h.exclusive)) return false;
+    const mine = holders.get(pid) ?? { exclusive, fds: /* @__PURE__ */ new Set() };
+    mine.exclusive = exclusive;
+    mine.fds.add(fd);
+    holders.set(pid, mine);
+    this.held.set(path, holders);
+    return true;
+  }
+  unlock(pid, path) {
+    const holders = this.held.get(path);
+    holders?.delete(pid);
+    if (holders?.size === 0) this.held.delete(path);
+  }
+  closed(pid, fd) {
+    for (const [path, holders] of [...this.held]) {
+      const mine = holders.get(pid);
+      if (mine?.fds.delete(fd) && mine.fds.size === 0) this.unlock(pid, path);
+    }
+  }
+  release(pid) {
+    for (const path of [...this.held.keys()]) this.unlock(pid, path);
+  }
+};
+var AsyncOps = class {
+  next = 1;
+  results = /* @__PURE__ */ new Map();
+  ready = [];
+  running = /* @__PURE__ */ new Map();
+  waiters = /* @__PURE__ */ new Set();
+  closed = false;
+  run;
+  onReady;
+  constructor(run2, onReady) {
+    this.run = run2;
+    this.onReady = onReady;
+  }
+  submit(req) {
+    const id2 = this.hold();
+    const running = new AbortController();
+    this.running.set(id2, running);
+    this.run(req, running.signal).then(
+      (result) => this.complete(id2, result),
+      (err) => this.complete(id2, { ok: false, errno: "EIO", message: String(err) })
+    );
+    return id2;
+  }
+  resolve(value) {
+    const id2 = this.hold();
+    this.complete(id2, json3(value));
+    return id2;
+  }
+  hold() {
+    const id2 = this.next++;
+    this.results.set(id2, void 0);
+    return id2;
+  }
+  take(id2) {
+    if (!this.results.has(id2)) throw new KernelError("EINVAL");
+    const result = this.results.get(id2);
+    if (!result) throw new KernelError("EAGAIN");
+    this.forget(id2);
+    return result;
+  }
+  cancel(id2) {
+    this.running.get(id2)?.abort();
+    this.forget(id2);
+  }
+  forget(id2) {
+    this.running.delete(id2);
+    this.results.delete(id2);
+    const at = this.ready.indexOf(id2);
+    if (at >= 0) this.ready.splice(at, 1);
+  }
+  async wait(timeoutMs, blocking) {
+    let signal;
+    for (; ; ) {
+      if (this.closed) return -1;
+      const id2 = this.ready.shift();
+      if (id2 !== void 0) return id2;
+      if (timeoutMs !== void 0 && timeoutMs <= 0) return 0;
+      signal ??= blocking();
+      const woke = await this.sleep(timeoutMs, signal);
+      if (!woke) return 0;
+    }
+  }
+  close() {
+    this.closed = true;
+    this.wake();
+  }
+  sleep(timeoutMs, signal) {
+    return new Promise((resolve, reject) => {
+      let timer;
+      const cleanup = () => {
+        clearTimeout(timer);
+        this.waiters.delete(wake);
+        signal.removeEventListener("abort", abort);
+      };
+      const wake = () => {
+        cleanup();
+        resolve(true);
+      };
+      const abort = () => {
+        cleanup();
+        reject(new KernelError("EINTR"));
+      };
+      this.waiters.add(wake);
+      signal.addEventListener("abort", abort, { once: true });
+      if (timeoutMs !== void 0) {
+        timer = setTimeout(() => {
+          cleanup();
+          resolve(false);
+        }, timeoutMs);
+      }
+    });
+  }
+  complete(id2, result) {
+    this.running.delete(id2);
+    if (!this.results.has(id2)) return;
+    this.results.set(id2, result);
+    this.ready.push(id2);
+    this.wake();
+    this.onReady?.();
+  }
+  wake() {
+    for (const wake of [...this.waiters]) wake();
+  }
+};
+async function hostSyscall(req, ctx) {
   switch (req.op) {
     case "lock":
       if (!ctx.locks) throw new KernelError("ENOSYS");
@@ -7616,7 +8220,7 @@ async function hostSyscall(req, ctx) {
       if (!ctx.valid(req.req)) throw new KernelError("EINVAL");
       return json3(ctx.ops.submit(req.req));
     case "async-wait":
-      return json3(await ctx.ops.wait(req.timeoutMs, ctx.blocking()));
+      return json3(await ctx.ops.wait(req.timeoutMs, ctx.blocking));
     case "async-take":
       return ctx.ops.take(req.id);
     case "async-resolve":
@@ -8504,343 +9108,118 @@ async function selectFds(fds, read, write, timeoutMs, interrupt) {
   try {
     return await waitReady(fds, read, write, deadline, interrupted2.promise);
   } finally {
-    interrupted2.done();
-  }
-}
-async function waitReady(fds, read, write, deadline, interrupted2) {
-  for (; ; ) {
-    const now = ready(fds, read, write);
-    if (now.read.length > 0 || now.write.length > 0 || Date.now() >= deadline) return now;
-    const round = new AbortController();
-    const changes = [.../* @__PURE__ */ new Set([...read, ...write])].flatMap((fd) => {
-      const file = fds.get(fd).file;
-      return file.changed === void 0 ? [] : [file.changed(round.signal).catch(() => void 0)];
-    });
-    let timer;
-    const expiry = deadline === Number.POSITIVE_INFINITY ? [] : [new Promise((resolve) => timer = setTimeout(resolve, deadline - Date.now()))];
-    try {
-      await Promise.race([...changes, ...expiry, interrupted2]);
-    } finally {
-      round.abort();
-      clearTimeout(timer);
-    }
-  }
-}
-
-// src/kernel/socket-syscalls.ts
-var SOCKET_OPS = [
-  "sock-open",
-  "sock-pair",
-  "sock-bind",
-  "sock-listen",
-  "sock-accept",
-  "sock-connect",
-  "sock-shutdown",
-  "sock-name",
-  "sock-getopt",
-  "sock-setopt",
-  "sock-resolve"
-];
-function socketAt(fds, fd) {
-  const file = fds.get(fd).file;
-  if (!(file instanceof KernelSocket)) throw new KernelError("ENOTSOCK");
-  return file;
-}
-var ok = (json5) => json5 === void 0 ? { ok: true, kind: "void" } : { ok: true, kind: "json", json: json5 };
-async function socketSyscall(req, proc) {
-  const { fds, net } = proc;
-  switch (req.op) {
-    case "sock-open":
-      return ok(fds.install(new OpenFile(net.socket(req.domain)), 3));
-    case "sock-pair": {
-      const [a, b] = KernelSocket.pair(net, req.domain, proc.cred?.());
-      const first = fds.install(new OpenFile(a), 3);
-      try {
-        return ok([first, fds.install(new OpenFile(b), 3)]);
-      } catch (e) {
-        await Promise.resolve(fds.close(first));
-        throw e;
-      }
-    }
-    case "sock-bind":
-      socketAt(fds, req.fd).bind(req.addr);
-      return ok();
-    case "sock-listen":
-      socketAt(fds, req.fd).listen(req.backlog, proc.cred?.());
-      return ok();
-    case "sock-accept":
-      return ok(await accept(proc, req.fd, req.nonblock));
-    case "sock-connect": {
-      const dialing = socketAt(fds, req.fd).connect(req.addr, true, proc.cred?.());
-      if (req.nonblock) {
-        dialing?.catch(() => void 0);
-        throw new KernelError("EINPROGRESS");
-      }
-      if (dialing !== void 0) await interruptible(dialing, proc.blocking());
-      return ok();
-    }
-    case "sock-shutdown":
-      socketAt(fds, req.fd).shutdown(req.how);
-      return ok();
-    case "sock-name": {
-      const socket = socketAt(fds, req.fd);
-      const addr = req.peer ? socket.peer : socket.local;
-      if (req.peer && !addr) throw new KernelError("ENOTCONN");
-      return ok(addr ?? unnamed(socket.domain));
-    }
-    case "sock-getopt":
-      return ok(socketAt(fds, req.fd).getOption(req.level, req.name));
-    case "sock-setopt":
-      socketAt(fds, req.fd).setOption(req.level, req.name, req.value);
-      return ok();
-    case "sock-resolve": {
-      const addresses = await proc.resolve(req.name, req.family, () => proc.blocking());
-      if (addresses.length === 0) throw new KernelError("ENOENT");
-      return ok(addresses);
-    }
-  }
-}
-function interruptible(dialing, signal) {
-  return new Promise((resolve, reject) => {
-    const abort = () => reject(new KernelError("EINTR"));
-    signal.addEventListener("abort", abort, { once: true });
-    dialing.then(resolve, reject).finally(() => signal.removeEventListener("abort", abort));
-  });
-}
-function unnamed(domain) {
-  return domain === "inet" ? { family: "inet", host: "0.0.0.0", port: 0 } : { family: "unix", path: "" };
-}
-async function accept(proc, fd, nonblock) {
-  const listener = socketAt(proc.fds, fd);
-  const waits = !nonblock && !pollFile(listener).readable;
-  const socket = await listener.accept(waits ? proc.blocking() : void 0, nonblock);
-  return { fd: proc.fds.install(new OpenFile(socket), 3), peer: socket.peer };
-}
-
-// src/fs/pages.ts
-var PAGE = 64 * 1024;
-var READAHEAD = 1024 * 1024;
-var CLEAN_LIMIT = 4 * 1024 * 1024;
-var WRITEBACK = 8 * 1024 * 1024;
-var RUN = 1024 * 1024;
-var Pages = class {
-  length;
-  stored;
-  shrink;
-  pages = /* @__PURE__ */ new Map();
-  dirty = /* @__PURE__ */ new Set();
-  free = [];
-  pinned = false;
-  constructor(size) {
-    this.length = size;
-    this.stored = size;
-  }
-  get dirtyBytes() {
-    return this.dirty.size * PAGE;
-  }
-  get changed() {
-    return this.dirty.size > 0 || this.shrink !== void 0 || this.length !== this.stored;
-  }
-  missing(at, length2) {
-    this.evict();
-    const end = Math.min(this.stored, at + length2, this.length);
-    const runs = [];
-    for (let page = Math.floor(at / PAGE); page * PAGE < end; page++) {
-      if (this.pages.has(page)) continue;
-      const last2 = runs[runs.length - 1];
-      if (last2 && last2[0] + last2[1] === page * PAGE) last2[1] += PAGE;
-      else runs.push([page * PAGE, PAGE]);
-    }
-    const last = runs[runs.length - 1];
-    if (last) last[1] = Math.max(last[1], Math.min(READAHEAD, this.stored - last[0]));
-    return runs.map(([start2, n]) => [start2, Math.min(n, this.stored - start2)]);
-  }
-  partial(at, length2) {
-    if (length2 === 0) return [];
-    this.evict();
-    const edges = /* @__PURE__ */ new Set([Math.floor(at / PAGE), Math.floor((at + length2 - 1) / PAGE)]);
-    const runs = [];
-    for (const page of edges) {
-      const start2 = page * PAGE;
-      const covered = at <= start2 && at + length2 >= start2 + PAGE;
-      if (covered || this.pages.has(page) || start2 >= this.stored) continue;
-      runs.push([start2, Math.min(PAGE, this.stored - start2)]);
-    }
-    return runs;
-  }
-  fill(start2, bytes) {
-    for (let at = 0; at < bytes.length; at += PAGE) {
-      const page = (start2 + at) / PAGE;
-      if (this.pages.has(page)) continue;
-      const part = bytes.subarray(at, Math.min(at + PAGE, bytes.length));
-      const fresh = this.take(part.length);
-      fresh.set(part);
-      this.pages.set(page, fresh);
-    }
-  }
-  read(at, length2) {
-    const out = new Uint8Array(Math.max(0, Math.min(this.length, at + length2) - at));
-    this.readInto(at, out);
-    return out;
-  }
-  readInto(at, out) {
-    const end = Math.min(this.length, at + out.length);
-    for (let pos = at; pos < end; ) {
-      const page = Math.floor(pos / PAGE);
-      const from = pos - page * PAGE;
-      const n = Math.min(PAGE - from, end - pos);
-      const bytes = this.pages.get(page);
-      if (bytes) out.set(bytes.subarray(from, from + n), pos - at);
-      else out.fill(0, pos - at, pos - at + n);
-      pos += n;
-    }
-    return Math.max(0, end - at);
-  }
-  write(at, bytes) {
-    for (let done4 = 0; done4 < bytes.length; ) {
-      const pos = at + done4;
-      const page = Math.floor(pos / PAGE);
-      const from = pos - page * PAGE;
-      const n = Math.min(PAGE - from, bytes.length - done4);
-      let target = this.pages.get(page);
-      if (!target) {
-        target = this.take(0);
-        this.pages.set(page, target);
-      }
-      target.set(bytes.subarray(done4, done4 + n), from);
-      this.dirty.add(page);
-      done4 += n;
-    }
-    this.length = Math.max(this.length, at + bytes.length);
+    interrupted2.done();
   }
-  truncate(size) {
-    if (size < this.stored) {
-      this.stored = size;
-      this.shrink = Math.min(this.shrink ?? size, size);
-    }
-    if (size < this.length) {
-      const edge = Math.floor(size / PAGE);
-      for (const page of [...this.pages.keys()]) {
-        if (page > edge || page === edge && size === edge * PAGE) this.drop(page);
-      }
-      this.pages.get(edge)?.fill(0, size - edge * PAGE);
+}
+async function waitReady(fds, read, write, deadline, interrupted2) {
+  for (; ; ) {
+    const now = ready(fds, read, write);
+    if (now.read.length > 0 || now.write.length > 0 || Date.now() >= deadline) return now;
+    const round = new AbortController();
+    const changes = [.../* @__PURE__ */ new Set([...read, ...write])].flatMap((fd) => {
+      const file = fds.get(fd).file;
+      return file.changed === void 0 ? [] : [file.changed(round.signal).catch(() => void 0)];
+    });
+    let timer;
+    const expiry = deadline === Number.POSITIVE_INFINITY ? [] : [new Promise((resolve) => timer = setTimeout(resolve, deadline - Date.now()))];
+    try {
+      await Promise.race([...changes, ...expiry, interrupted2]);
+    } finally {
+      round.abort();
+      clearTimeout(timer);
     }
-    this.length = size;
   }
-  plan() {
-    const runs = [];
-    const sorted = [...this.dirty].sort((a, b) => a - b);
-    for (let i = 0; i < sorted.length; ) {
-      let j = i + 1;
-      const first = sorted[i];
-      while (j < sorted.length && sorted[j] === first + (j - i) && sorted[j] * PAGE % RUN !== 0) {
-        j++;
+}
+
+// src/kernel/socket-syscalls.ts
+var SOCKET_OPS = [
+  "sock-open",
+  "sock-pair",
+  "sock-bind",
+  "sock-listen",
+  "sock-accept",
+  "sock-connect",
+  "sock-shutdown",
+  "sock-name",
+  "sock-getopt",
+  "sock-setopt",
+  "sock-resolve"
+];
+function socketAt(fds, fd) {
+  const file = fds.get(fd).file;
+  if (!(file instanceof KernelSocket)) throw new KernelError("ENOTSOCK");
+  return file;
+}
+var ok = (json5) => json5 === void 0 ? { ok: true, kind: "void" } : { ok: true, kind: "json", json: json5 };
+async function socketSyscall(req, proc) {
+  const { fds, net } = proc;
+  switch (req.op) {
+    case "sock-open":
+      return ok(fds.install(new OpenFile(net.socket(req.domain)), 3));
+    case "sock-pair": {
+      const [a, b] = KernelSocket.pair(net, req.domain, proc.cred?.());
+      const first = fds.install(new OpenFile(a), 3);
+      try {
+        return ok([first, fds.install(new OpenFile(b), 3)]);
+      } catch (e) {
+        await Promise.resolve(fds.close(first));
+        throw e;
       }
-      const start2 = first * PAGE;
-      const end = Math.min(this.length, (first + (j - i)) * PAGE);
-      const bytes = new Uint8Array(end - start2);
-      for (let k = i; k < j; k++) {
-        const page = this.pages.get(sorted[k]);
-        bytes.set(page.subarray(0, Math.min(PAGE, end - (k - i) * PAGE - start2)), (k - i) * PAGE);
+    }
+    case "sock-bind":
+      socketAt(fds, req.fd).bind(req.addr);
+      return ok();
+    case "sock-listen":
+      socketAt(fds, req.fd).listen(req.backlog, proc.cred?.());
+      return ok();
+    case "sock-accept":
+      return ok(await accept(proc, req.fd, req.nonblock));
+    case "sock-connect": {
+      const dialing = socketAt(fds, req.fd).connect(req.addr, true, proc.cred?.());
+      if (req.nonblock) {
+        dialing?.catch(() => void 0);
+        throw new KernelError("EINPROGRESS");
       }
-      runs.push({ offset: start2, bytes });
-      i = j;
+      if (dialing !== void 0) await interruptible(dialing, proc.blocking());
+      return ok();
     }
-    const written2 = Math.max(this.stored, ...runs.map((r) => r.offset + r.bytes.length));
-    return {
-      ...this.shrink !== void 0 ? { shrink: this.shrink } : {},
-      runs,
-      ...this.length > written2 ? { extend: this.length } : {}
-    };
-  }
-  flushed() {
-    this.dirty.clear();
-    this.shrink = void 0;
-    this.stored = this.length;
-    this.evict();
-  }
-  pin() {
-    this.pinned = true;
-  }
-  reset(size) {
-    if (this.pinned) return;
-    for (const page of [...this.pages.keys()]) if (!this.dirty.has(page)) this.drop(page);
-    if (this.changed) return;
-    this.length = size;
-    this.stored = size;
-  }
-  evict() {
-    if (this.pinned) return;
-    let clean = (this.pages.size - this.dirty.size) * PAGE;
-    for (const page of this.pages.keys()) {
-      if (clean <= CLEAN_LIMIT) return;
-      if (this.dirty.has(page)) continue;
-      this.drop(page);
-      clean -= PAGE;
+    case "sock-shutdown":
+      socketAt(fds, req.fd).shutdown(req.how);
+      return ok();
+    case "sock-name": {
+      const socket = socketAt(fds, req.fd);
+      const addr = req.peer ? socket.peer : socket.local;
+      if (req.peer && !addr) throw new KernelError("ENOTCONN");
+      return ok(addr ?? unnamed(socket.domain));
     }
-  }
-  take(used) {
-    const page = this.free.pop();
-    if (!page) return new Uint8Array(PAGE);
-    page.fill(0, used);
-    return page;
-  }
-  drop(page) {
-    const bytes = this.pages.get(page);
-    this.pages.delete(page);
-    this.dirty.delete(page);
-    if (this.free.length < CLEAN_LIMIT / PAGE) this.free.push(bytes);
-  }
-};
-
-// src/fs/ranged.ts
-var AsyncRangedFile = class {
-  pages;
-  io;
-  pinned = false;
-  version;
-  path;
-  constructor(io, path, size, version) {
-    this.io = io;
-    this.path = path;
-    this.version = version;
-    this.pages = new Pages(size);
-  }
-  size() {
-    return this.pages.length;
-  }
-  async fetch(runs) {
-    for (const [start2, n] of runs) {
-      this.pages.fill(start2, await this.io.pread(this.path, start2, n, this.version));
+    case "sock-getopt":
+      return ok(socketAt(fds, req.fd).getOption(req.level, req.name));
+    case "sock-setopt":
+      socketAt(fds, req.fd).setOption(req.level, req.name, req.value);
+      return ok();
+    case "sock-resolve": {
+      const addresses = await proc.resolve(req.name, req.family, () => proc.blocking());
+      if (addresses.length === 0) throw new KernelError("ENOENT");
+      return ok(addresses);
     }
   }
-  async read(at, length2) {
-    await this.fetch(this.pages.missing(at, length2));
-    return this.pages.read(at, length2);
-  }
-  async write(at, bytes) {
-    await this.fetch(this.pages.partial(at, bytes.length));
-    this.pages.write(at, bytes);
-    if (!this.pinned && this.pages.dirtyBytes >= WRITEBACK) await this.flush();
-  }
-  truncate(size) {
-    this.pages.truncate(size);
-  }
-  async flush() {
-    if (this.pinned || !this.pages.changed) return;
-    const plan = this.pages.plan();
-    if (plan.shrink !== void 0) await this.io.truncate(this.path, plan.shrink);
-    for (const run2 of plan.runs) await this.io.pwrite(this.path, run2.offset, run2.bytes, true);
-    if (plan.extend !== void 0) await this.io.truncate(this.path, plan.extend);
-    this.version = void 0;
-    this.pages.flushed();
-  }
-  async pin() {
-    this.pinned = true;
-    this.pages.pin();
-    await this.fetch(this.pages.missing(0, this.pages.length));
-  }
-};
+}
+function interruptible(dialing, signal) {
+  return new Promise((resolve, reject) => {
+    const abort = () => reject(new KernelError("EINTR"));
+    signal.addEventListener("abort", abort, { once: true });
+    dialing.then(resolve, reject).finally(() => signal.removeEventListener("abort", abort));
+  });
+}
+function unnamed(domain) {
+  return domain === "inet" ? { family: "inet", host: "0.0.0.0", port: 0 } : { family: "unix", path: "" };
+}
+async function accept(proc, fd, nonblock) {
+  const listener = socketAt(proc.fds, fd);
+  const waits = !nonblock && !pollFile(listener).readable;
+  const socket = await listener.accept(waits ? proc.blocking() : void 0, nonblock);
+  return { fd: proc.fds.install(new OpenFile(socket), 3), peer: socket.peer };
+}
 
 // src/kernel/vfs-file.ts
 var O_ACCMODE = 3;
@@ -9443,6 +9822,9 @@ var SYSCALL_OPS = /* @__PURE__ */ new Set([
   "dl-closure",
   "dl-closure-free",
   "dl-reserve",
+  "dl-load-reserve",
+  "dl-lock",
+  "dl-unlock",
   "fd-renumber",
   "fd-promote",
   "fd-open-tty",
@@ -9481,6 +9863,7 @@ function isWasmSyscall(req) {
   return typeof op === "string" && SYSCALL_OPS.has(op);
 }
 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 DYING = { ok: false, errno: "EINTR", message: "the process is being killed" };
@@ -9501,7 +9884,7 @@ var WasmProcess = class {
   stopped = 0;
   stops = 0;
   owed = false;
-  waits = 0;
+  waiting = /* @__PURE__ */ new Set();
   resumed = Promise.resolve();
   wake;
   stateListeners = [];
@@ -9557,7 +9940,8 @@ var WasmProcess = class {
       return "terminate";
     }
     this.options.onPending?.(sig);
-    if (this.options.jobs?.keyboard && KEYBOARD.has(sig)) this.owed = true;
+    if (this.options.jobs?.keyboard && KEYBOARD.has(sig) && this.waiting.size === 0)
+      this.owed = true;
     const blocked = this.interrupt;
     this.interrupt = new AbortController();
     blocked.abort();
@@ -9602,10 +9986,15 @@ var WasmProcess = class {
       await this.resumed;
       if (this.dying) return DYING;
       const stops = this.stops;
-      const waits = this.waits;
-      const result = await this.dispatch(req, cancelled);
+      const scope = new AbortController();
+      const forward = () => scope.abort();
+      if (cancelled?.aborted) scope.abort();
+      cancelled?.addEventListener("abort", forward, { once: true });
+      const result = await this.dispatch(req, scope.signal).finally(() => {
+        cancelled?.removeEventListener("abort", forward);
+        this.waiting.delete(scope.signal);
+      });
       if (this.dying) return DYING;
-      if (!result.ok && result.errno === "EINTR" && this.waits !== waits) this.owed = false;
       const restart = !result.ok && result.errno === "EINTR" && this.stops !== stops;
       if (restart && !this.options.hasPending?.()) continue;
       await this.resumed;
@@ -9658,12 +10047,31 @@ var WasmProcess = class {
   refuseIfPending(restart) {
     if (restart && this.options.hasPending?.()) throw new KernelError("EINTR");
   }
+  async procWait(req, cancelled) {
+    const flags = {
+      untraced: req.untraced,
+      continued: req.continued,
+      inGroup: this.waitGroup(req.pid)
+    };
+    if (this.owed && !req.nohang) {
+      const now = await this.children.wait(req.pid, true, this.interrupt.signal, flags);
+      if (now[0] !== 0) return now;
+    }
+    const signal = req.nohang ? this.interrupt.signal : this.blockingSignal(cancelled);
+    const waited = await this.children.wait(req.pid, req.nohang, signal, flags);
+    return waited;
+  }
   blockingSignal(cancelled, owing = true) {
-    if (owing) this.waits++;
-    if (this.options.hasPending?.() || cancelled?.aborted || owing && this.owed) {
+    if (owing && this.owed) {
+      this.owed = false;
       throw new KernelError("EINTR");
     }
-    return cancelled ? AbortSignal.any([this.interrupt.signal, cancelled]) : this.interrupt.signal;
+    if (this.options.hasPending?.() || cancelled.aborted) throw new KernelError("EINTR");
+    if (owing) this.waiting.add(cancelled);
+    return this.cancelSignal(cancelled);
+  }
+  cancelSignal(cancelled) {
+    return AbortSignal.any([this.interrupt.signal, cancelled]);
   }
   async read(req, cancelled) {
     const file = this.fds.get(req.fd).file;
@@ -9687,15 +10095,22 @@ var WasmProcess = class {
     if (nonblock) return file.write(body, AbortSignal.abort());
     return file.write(
       body,
-      this.options.hasPending?.() ? AbortSignal.abort() : this.interrupt.signal
+      this.options.hasPending?.() ? AbortSignal.abort() : this.cancelSignal(cancelled)
     );
   }
   async openVfs(req) {
+    if (inProc(req.path)) return this.openProc(req, req.path);
+    const alias = req.orphan ? void 0 : await procAlias(this.options.fs, req.path, !req.exclusive);
+    if (alias !== void 0) return this.openProc(req, alias);
     await refuseReadonly(this.options.fs, req.path, req.flags, req);
     const fd = this.fds.install(heldFile(), 3);
     try {
       const nodes = this.nodes;
       const path = req.orphan ? req.path : req.exclusive ? await nodes.entryKey(req.path) : req.create ? await nodes.targetKey(req.path) : await this.keptOr(await nodes.targetKey(req.path), req.handle);
+      if (inProc(path)) {
+        this.fds.installAt(fd, await this.procFile(req, path));
+        return fd;
+      }
       const open = { ...req, path };
       if (req.exclusive) {
         await nodes.createExclusive(path);
@@ -9717,6 +10132,22 @@ var WasmProcess = class {
     }
     return fd;
   }
+  async openProc(req, path) {
+    return this.fds.install(await this.procFile(req, path), 3);
+  }
+  async procFile(req, path) {
+    if (req.flags & WRITE_ACCESS || req.create || req.truncate || req.exclusive) {
+      throw new KernelError("EROFS");
+    }
+    const tree = new ProcTree(
+      {
+        procList: () => this.options.processes?.() ?? { boot: 0, processes: [] },
+        mountList: () => this.options.mounts?.() ?? []
+      },
+      (await this.options.identity?.())?.pid ?? this.pid
+    );
+    return memoryFile(tree.read(path), path, req.position);
+  }
   openVfsFile(req) {
     return vfsFile(
       this.options.fs,
@@ -9808,6 +10239,11 @@ var WasmProcess = class {
         return { ok: true, kind: "json", json: this.options.jobs?.terminalNames() ?? [] };
       case "fd-select": {
         const { read, write, timeoutMs } = req;
+        if (this.owed && timeoutMs !== 0) {
+          const ready2 = await selectFds(this.fds, read, write, 0, this.interrupt.signal);
+          if (ready2.read.length + ready2.write.length > 0)
+            return { ok: true, kind: "json", json: ready2 };
+        }
         const signal = this.blockingSignal(cancelled, timeoutMs !== 0);
         const selected = await selectFds(this.fds, read, write, timeoutMs, signal);
         return { ok: true, kind: "json", json: selected };
@@ -10005,16 +10441,8 @@ var WasmProcess = class {
       case "proc-spawn":
         this.refuseIfPending(req.restart);
         return { ok: true, kind: "json", json: await this.spawn(req) };
-      case "proc-wait": {
-        const signal = req.nohang ? this.interrupt.signal : this.blockingSignal(cancelled);
-        const flags = {
-          untraced: req.untraced,
-          continued: req.continued,
-          inGroup: this.waitGroup(req.pid)
-        };
-        const waited = await this.children.wait(req.pid, req.nohang, signal, flags);
-        return { ok: true, kind: "json", json: waited };
-      }
+      case "proc-wait":
+        return { ok: true, kind: "json", json: await this.procWait(req, cancelled) };
       case "proc-identity":
         return { ok: true, kind: "json", json: await this.options.identity?.() ?? null };
       case "proc-exec": {
@@ -10046,7 +10474,7 @@ var WasmProcess = class {
         return { ok: true, kind: "json", json: this.options.mounts?.() ?? [] };
       case "mount":
       case "umount":
-        return this.mountSyscall(req);
+        return this.mountSyscall(req, cancelled);
       case "proc-alarm":
         this.setAlarm(req.sig, req.firstMs ?? req.ms, req.repeat ? req.ms : 0, req.timer);
         return { ok: true, kind: "void" };
@@ -10067,6 +10495,18 @@ var WasmProcess = class {
         return { ok: true, kind: "void" };
       case "dl-reserve":
         return { ok: true, kind: "json", json: this.reserveSlots(req.floor, req.size) };
+      case "dl-load-reserve":
+        return {
+          ok: true,
+          kind: "json",
+          json: { base: this.reserveSlots(req.floor, req.size), handle: this.closures.handle++ }
+        };
+      case "dl-lock":
+        await this.lockDl(req.owner);
+        return { ok: true, kind: "void" };
+      case "dl-unlock":
+        this.unlockDl(req.owner);
+        return { ok: true, kind: "void" };
       case "sig-mask":
         this.caught = req.caught;
         this.ignored = req.ignored;
@@ -10081,14 +10521,14 @@ var WasmProcess = class {
         return { ok: true, kind: "bytes", bytes: this.children.captured(req.pid, req.slot) };
     }
   }
-  async mountSyscall(req) {
+  async mountSyscall(req, cancelled) {
     const { mount, umount } = this.options;
     if (!mount || !umount) throw new KernelError("ENOSYS");
     try {
       if (req.op === "umount") await umount(req.target, req.flags);
       else {
         const { source, target, type, flags, data } = req;
-        const signal = this.blockingSignal();
+        const signal = this.blockingSignal(cancelled);
         await Promise.race([mount({ source, target, type, flags, data }, signal), aborted(signal)]);
       }
     } catch (err) {
@@ -10103,7 +10543,12 @@ var WasmProcess = class {
   }
   alarm;
   dlLog = [];
-  closures = { next: 0, free: [], live: /* @__PURE__ */ new Set() };
+  closures = {
+    next: 0,
+    handle: 1,
+    free: [],
+    live: /* @__PURE__ */ new Set()
+  };
   allocateClosure(floor) {
     const index = this.closures.free.pop() ?? Math.max(floor, this.closures.next);
     this.closures.next = Math.max(this.closures.next, index + 1);
@@ -10116,6 +10561,47 @@ var WasmProcess = class {
     this.closures.free.push(index);
     this.dlLog.push({ kind: "closure-free", index });
   }
+  dlLock = {
+    owner: 0,
+    depth: 0,
+    waiters: /* @__PURE__ */ new Set()
+  };
+  async lockDl(owner) {
+    while (this.dlLock.depth > 0 && this.dlLock.owner !== owner) {
+      if (this.dying) throw new KernelError("EINTR");
+      const interrupt = this.interrupt.signal;
+      const gone = await new Promise((resolve) => {
+        const waiter = {
+          owner,
+          wake: (ended) => {
+            this.dlLock.waiters.delete(waiter);
+            interrupt.removeEventListener("abort", recheck);
+            resolve(ended);
+          }
+        };
+        const recheck = () => waiter.wake(false);
+        this.dlLock.waiters.add(waiter);
+        interrupt.addEventListener("abort", recheck, { once: true });
+      });
+      if (gone) throw new KernelError("EINTR");
+    }
+    this.dlLock.owner = owner;
+    this.dlLock.depth++;
+  }
+  threadEnded(tid) {
+    for (const waiter of [...this.dlLock.waiters]) if (waiter.owner === tid) waiter.wake(true);
+    if (this.dlLock.depth === 0 || this.dlLock.owner !== tid) return;
+    this.dlLock.depth = 0;
+    this.wakeDl();
+  }
+  unlockDl(owner) {
+    if (this.dlLock.depth === 0 || this.dlLock.owner !== owner) throw new KernelError("EPERM");
+    this.dlLock.depth--;
+    if (this.dlLock.depth === 0) this.wakeDl();
+  }
+  wakeDl() {
+    for (const waiter of [...this.dlLock.waiters]) waiter.wake(false);
+  }
   reserveSlots(floor, size) {
     const base = Math.max(floor, this.closures.next);
     this.closures.next = base + size;
@@ -10427,6 +10913,7 @@ function spawnWasmProcess(opts) {
   const endThread = (tid) => {
     const end = threads.get(tid);
     threads.delete(tid);
+    process.threadEnded(tid);
     end?.();
   };
   const spawnThread = (thread) => {
@@ -11219,8 +11706,8 @@ function umountCall(target, flags) {
 var FSTAB_PATH = "/etc/fstab";
 var FSTAB_RETRIES = [1e3, 4e3, 16e3];
 var FINAL = /* @__PURE__ */ new Set(["EINVAL", "EBUSY", "EPERM", "EACCES"]);
-function unescape(field2) {
-  return field2.replace(
+function unescape(field3) {
+  return field3.replace(
     /\\([0-7]{3})/g,
     (_, octal) => String.fromCharCode(Number.parseInt(octal, 8))
   );
@@ -12040,7 +12527,7 @@ function importedMemory(bytes) {
     const count = u32();
     for (let i = 0; i < count; i++) {
       const module = name2();
-      const field2 = name2();
+      const field3 = name2();
       const kind = bytes[at++];
       if (kind === 0) u32();
       else if (kind === 1) {
@@ -12048,7 +12535,7 @@ function importedMemory(bytes) {
         limits();
       } else if (kind === 2) {
         const l = limits();
-        return { module, name: field2, ...l };
+        return { module, name: field3, ...l };
       } else if (kind === 3) at += 2;
       else if (kind === 4) {
         at++;
@@ -12139,12 +12626,12 @@ function readImports(r, types) {
   const foreign = {};
   for (let i = r.u32(); i > 0; i--) {
     const module = r.name();
-    const field2 = r.name();
+    const field3 = r.name();
     const kind = r.byte();
     if (kind !== 0) skipImport(r, kind);
     else {
       const type = types[r.u32()] ?? "other";
-      if (!RESERVED_NAMESPACES.has(module)) (foreign[module] ??= {})[field2] = type;
+      if (!RESERVED_NAMESPACES.has(module)) (foreign[module] ??= {})[field3] = type;
     }
   }
   return foreign;