@ai-ecoverse/slicc-kernel 1.54.1 → 1.54.3

package/dist/node.js

@@ -329,6 +329,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) => {
@@ -5866,179 +5892,6 @@ 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;
-  }
-  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, 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;
-    }
-  }
-  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");
-      if (!ctx.locks.lock(ctx.pid, req.path, req.exclusive, req.fd))
-        throw new KernelError("EAGAIN");
-      return done2;
-    case "unlock":
-      ctx.locks?.unlock(ctx.pid, req.path);
-      return done2;
-    case "async-submit":
-      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()));
-    case "async-take":
-      return ctx.ops.take(req.id);
-    case "async-resolve":
-      return json3(ctx.ops.resolve(req.value));
-    case "async-hold":
-      return json3(ctx.ops.hold());
-    case "async-cancel":
-      ctx.ops.cancel(req.id);
-      return done2;
-    case "async-close":
-      ctx.ops.close();
-      return done2;
-  }
-}
-
 // src/kernel/net/loopback-names.ts
 var HOST_LOOPBACK = "host.slicc.internal";
 var HOST_LOOPBACK_ADDRESS = [10, 0, 2, 2];
@@ -6066,66 +5919,815 @@ function ownNames(hostname) {
   return [.../* @__PURE__ */ new Set([hostname.toLowerCase(), ...LIBC_HOSTNAMES])];
 }
 
-// src/kernel/net/proxy-service.ts
-var SEND_BUFFER2 = 1024 * 1024;
-var TLS_HANDSHAKE = 22;
-var TOKEN2 = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
-var NO_WEBSOCKET2 = "WebSocket not supported by this transport (fetchTransport needs { webSocket: true })";
-var REALM_PROXY_PORT = 3128;
-var DEFAULT_LIMITS = {
-  maxConnections: 64,
-  maxHead: 64 * 1024,
-  idleMs: 12e4,
-  bodyBudget: 128 * 1024 * 1024,
-  closeWaitMs: 5e3
-};
-var HOP_BY_HOP = /* @__PURE__ */ new Set([
-  "connection",
-  "keep-alive",
-  "proxy-connection",
-  "proxy-authenticate",
-  "proxy-authorization",
-  "te",
-  "trailer",
-  "transfer-encoding",
-  "upgrade"
-]);
-var REQUEST_OWN = /* @__PURE__ */ new Set(["host", "content-length", "expect"]);
-var Budget = class {
-  free;
-  waiters = [];
-  constructor(free) {
-    this.free = free;
+// 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`
+    );
   }
-  async acquire(n, signal) {
-    while (this.free < n) {
-      signal.throwIfAborted();
-      await new Promise((resolve) => {
-        const done4 = () => {
-          signal.removeEventListener("abort", done4);
-          resolve();
-        };
-        this.waiters.push(done4);
-        signal.addEventListener("abort", done4, { once: true });
-      });
-    }
-    this.free -= n;
+  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
+`;
   }
-  release(n) {
-    this.free += n;
-    const waiters = this.waiters;
-    this.waiters = [];
-    for (const wake of waiters) wake();
+  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)
+    );
   }
-};
-function canonicalHost2(host) {
-  const bare = host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;
-  try {
-    return new URL(`http://${bare}/`).hostname;
-  } catch {
-    return void 0;
+  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}
+`;
   }
-}
+  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;
+  }
+  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);
+  }
+  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;
+  }
+  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, 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;
+    }
+  }
+  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");
+      if (!ctx.locks.lock(ctx.pid, req.path, req.exclusive, req.fd))
+        throw new KernelError("EAGAIN");
+      return done2;
+    case "unlock":
+      ctx.locks?.unlock(ctx.pid, req.path);
+      return done2;
+    case "async-submit":
+      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()));
+    case "async-take":
+      return ctx.ops.take(req.id);
+    case "async-resolve":
+      return json3(ctx.ops.resolve(req.value));
+    case "async-hold":
+      return json3(ctx.ops.hold());
+    case "async-cancel":
+      ctx.ops.cancel(req.id);
+      return done2;
+    case "async-close":
+      ctx.ops.close();
+      return done2;
+  }
+}
+
+// src/kernel/net/proxy-service.ts
+var SEND_BUFFER2 = 1024 * 1024;
+var TLS_HANDSHAKE = 22;
+var TOKEN2 = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
+var NO_WEBSOCKET2 = "WebSocket not supported by this transport (fetchTransport needs { webSocket: true })";
+var REALM_PROXY_PORT = 3128;
+var DEFAULT_LIMITS = {
+  maxConnections: 64,
+  maxHead: 64 * 1024,
+  idleMs: 12e4,
+  bodyBudget: 128 * 1024 * 1024,
+  closeWaitMs: 5e3
+};
+var HOP_BY_HOP = /* @__PURE__ */ new Set([
+  "connection",
+  "keep-alive",
+  "proxy-connection",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade"
+]);
+var REQUEST_OWN = /* @__PURE__ */ new Set(["host", "content-length", "expect"]);
+var Budget = class {
+  free;
+  waiters = [];
+  constructor(free) {
+    this.free = free;
+  }
+  async acquire(n, signal) {
+    while (this.free < n) {
+      signal.throwIfAborted();
+      await new Promise((resolve) => {
+        const done4 = () => {
+          signal.removeEventListener("abort", done4);
+          resolve();
+        };
+        this.waiters.push(done4);
+        signal.addEventListener("abort", done4, { once: true });
+      });
+    }
+    this.free -= n;
+  }
+  release(n) {
+    this.free += n;
+    const waiters = this.waiters;
+    this.waiters = [];
+    for (const wake of waiters) wake();
+  }
+};
+function canonicalHost2(host) {
+  const bare = host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;
+  try {
+    return new URL(`http://${bare}/`).hostname;
+  } catch {
+    return void 0;
+  }
+}
 function localV4(a, b) {
   return a === 127 || a === 0 || a === 169 && b === 254;
 }
@@ -8372,231 +8974,6 @@ async function accept(proc, fd, 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);
-  }
-  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;
-  }
-  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/kernel/vfs-file.ts
 var O_ACCMODE = 3;
 var O_WRONLY = 1;
@@ -9236,6 +9613,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" };
@@ -9446,11 +9824,18 @@ var WasmProcess = class {
     );
   }
   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);
@@ -9472,6 +9857,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,
@@ -10974,8 +11375,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))
   );
@@ -11868,7 +12269,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) {
@@ -11876,7 +12277,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++;
@@ -11967,12 +12368,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;