@ai-ecoverse/slicc-kernel 1.45.0 → 1.46.0

package/dist/node-process-worker.js

@@ -2903,6 +2903,31 @@ function number(r) {
   if (!r.ok) return -wasiErrno(r.errno);
   return r.kind === "json" && typeof r.json === "number" ? r.json : -wasiErrno("EIO");
 }
+function restarted(issue) {
+  for (; ; ) {
+    const r = issue();
+    if (r.ok || r.errno !== "EINTR") return r;
+  }
+}
+function forkRestarted(deps, state, snapshotAt) {
+  let memory = state.memory;
+  let seen = snapshotAt;
+  return restarted(() => {
+    const streams = deps.describeFork();
+    const now = deps.deliveries?.();
+    if (now !== seen) {
+      seen = now;
+      const live = deps.memory?.();
+      if (live) memory = new Uint8Array(live.buffer).slice();
+    }
+    const forked = { ...state, memory, streams, cwd: deps.Fs.cwd() };
+    return deps.transport.call(
+      { op: "proc-fork", state: forked, restart: true },
+      Infinity,
+      "proc-fork"
+    );
+  });
+}
 function flushed(beforeSpawn) {
   try {
     beforeSpawn();
@@ -3029,20 +3054,18 @@ function createProcessKernel(deps) {
     const promote = deps.stdioPromoter?.();
     const stdio = [0, 1, 2].map((n) => slot(fds[n] ?? -1, n, promote));
     const inherit = deps.inherit?.(actions) ?? [];
-    const r = transport.call(
-      {
-        op: "proc-spawn",
-        file,
-        argv,
-        env: env ?? deps.env,
-        cwd: cwd ?? Fs.cwd(),
-        stdio,
-        ...inherit.length > 0 ? { inherit } : {},
-        ...exec ? { exec } : {}
-      },
-      Infinity,
-      `proc-spawn ${file}`
-    );
+    const req = {
+      op: "proc-spawn",
+      file,
+      argv,
+      env: env ?? deps.env,
+      cwd: cwd ?? Fs.cwd(),
+      stdio,
+      ...inherit.length > 0 ? { inherit } : {},
+      ...exec ? { exec } : {},
+      restart: true
+    };
+    const r = restarted(() => transport.call(req, Infinity, `proc-spawn ${file}`));
     if (!r.ok) return -wasiErrno(r.errno);
     const pid = r.kind === "json" ? r.json : 0;
     const captures = [1, 2].filter((n) => "capture" in stdio[n]);
@@ -3064,14 +3087,10 @@ function createProcessKernel(deps) {
       return spawnChild(file, argv, env, cwd, fds, actions, false);
     },
     fork(state) {
+      const snapshotAt = deps.deliveries?.();
       const unflushed = flushed(deps.beforeSpawn);
       if (unflushed < 0) return unflushed;
-      const streams = deps.describeFork();
-      const r = transport.call(
-        { op: "proc-fork", state: { ...state, streams, cwd: Fs.cwd() } },
-        Infinity,
-        "proc-fork"
-      );
+      const r = forkRestarted(deps, state, snapshotAt);
       if (!r.ok) return -wasiErrno(r.errno);
       return r.kind === "json" ? r.json : -wasiErrno("EIO");
     },
@@ -3203,6 +3222,7 @@ var init_process_signals = __esm({
       reporting = false;
       unwinding = false;
       quieted = 0;
+      delivered = 0;
       raw;
       header;
       hooks;
@@ -3226,6 +3246,9 @@ var init_process_signals = __esm({
           }
         };
       }
+      deliveries() {
+        return this.delivered;
+      }
       restartable() {
         return this.lastDelivered !== 0 && (this.lastDelivered & ~this.restart) === 0;
       }
@@ -3267,6 +3290,7 @@ var init_process_signals = __esm({
         const timers = Atomics.exchange(this.header, SAB_I_TIMERS, 0);
         const pending = Atomics.exchange(this.header, SAB_I_SIGNALS, 0);
         if (this.depth <= 1) this.lastDelivered = pending | (timers & 1 ? sigbit(SIG.ALRM) : 0);
+        if (pending !== 0 || timers !== 0) this.delivered++;
         for (let which = 0; which < 3; which++) {
           if (timers & 1 << which) this.hooks.timer?.(which);
         }
@@ -4033,12 +4057,12 @@ async function runWasmProcess(init, port3, deps = {}) {
   const say = (fd) => (text) => sys.write(fd, encoder4.encode(`${text}
 `));
   let ready;
-  let failed3;
+  let failed4;
   let memory;
   let exports;
   const initialized = new Promise((resolve, reject) => {
     ready = resolve;
-    failed3 = reject;
+    failed4 = reject;
   });
   const id = identify(transport, init);
   const module = {
@@ -4091,7 +4115,7 @@ async function runWasmProcess(init, port3, deps = {}) {
         exports = instance.exports;
         publishMemory(init.sab, memory?.buffer.byteLength ?? 0);
         done(instance, init.program.module);
-      }, failed3);
+      }, failed4);
       return {};
     },
     preRun: [
@@ -4152,6 +4176,8 @@ async function runWasmProcess(init, port3, deps = {}) {
     pid: init.pid,
     raise: (sig) => running.sliccRaise?.(sig),
     restartable,
+    memory: () => memory,
+    deliveries: () => signals.deliveries(),
     describeFork: () => describeForFork(running.FS, sys, streams, livePath),
     inherit: (actions) => describeInherited(running.FS, sys, streams, livePath, actions),
     stdioPromoter: () => vfsPromoter(running.FS, sys, streams, livePath)
@@ -6063,108 +6089,435 @@ var init_wasi_host = __esm({
   }
 });
 
-// src/process/wasi/wasi-imports.ts
-function base64(text) {
-  const bytes = new TextEncoder().encode(text);
-  let binary = "";
-  for (let at = 0; at < bytes.length; at += 32768) {
-    binary += String.fromCharCode(...bytes.subarray(at, at + 32768));
-  }
-  return btoa(binary);
+// src/process/wasi/wasi-threads.ts
+function threadCap(env) {
+  const asked = Number.parseInt(env.SLICC_WASM_THREADS ?? "", 10);
+  return asked >= 1 ? Math.min(asked, WASM_MAX_THREADS) : WASM_DEFAULT_THREADS;
 }
-function importSource(source) {
-  return import(`data:text/javascript;base64,${base64(source)}`);
+var LAST_TID, RUNNING, MAIN_TID, ThreadExit, WasiThreads;
+var init_wasi_threads = __esm({
+  "src/process/wasi/wasi-threads.ts"() {
+    "use strict";
+    init_protocol();
+    LAST_TID = 0;
+    RUNNING = 1;
+    MAIN_TID = 1;
+    ThreadExit = class extends Error {
+      constructor() {
+        super("thread exit");
+      }
+    };
+    WasiThreads = class {
+      ids;
+      beforeSpawn;
+      modules;
+      received;
+      port;
+      memory;
+      cap;
+      tid;
+      constructor(port3, memory, cap, tid, ids) {
+        this.port = port3;
+        this.memory = memory;
+        this.cap = cap;
+        this.tid = tid;
+        this.ids = new Int32Array(ids ?? new SharedArrayBuffer(16));
+        if (!ids) Atomics.store(this.ids, LAST_TID, MAIN_TID);
+      }
+      spawn(arg) {
+        if (Atomics.add(this.ids, RUNNING, 1) + 1 >= this.cap) {
+          Atomics.sub(this.ids, RUNNING, 1);
+          return -1;
+        }
+        this.beforeSpawn?.();
+        const tid = Atomics.add(this.ids, LAST_TID, 1) + 1;
+        const modules = this.modules?.();
+        this.port.postMessage({
+          type: WASM_THREAD_SPAWN,
+          thread: {
+            tid,
+            arg,
+            memory: this.memory,
+            ids: this.ids.buffer,
+            ...modules ? { modules } : {}
+          }
+        });
+        return tid;
+      }
+      exited() {
+        Atomics.sub(this.ids, RUNNING, 1);
+        this.port.postMessage({ type: WASM_THREAD_EXIT });
+      }
+      known(tid) {
+        return tid >= MAIN_TID && tid <= Atomics.load(this.ids, LAST_TID);
+      }
+      parallelism() {
+        const cores = globalThis.navigator?.hardwareConcurrency;
+        return Math.max(1, Math.min(this.cap, cores ?? this.cap));
+      }
+    };
+  }
+});
+
+// src/fs/physical-path.ts
+function start(path) {
+  return { done: [], todo: path.split("/").filter((p) => p !== ""), hops: 0 };
 }
-async function loadImports(source) {
-  const loaded = await importSource(source);
-  if (typeof loaded.createImports !== "function") {
-    throw new Error("the imports module exports no createImports function");
+function next(walk) {
+  while (walk.todo.length > 0) {
+    const part = walk.todo.shift();
+    if (part === ".") continue;
+    if (part === "..") {
+      walk.done.pop();
+      continue;
+    }
+    return part;
   }
-  return loaded.createImports;
+  return void 0;
 }
-function value(result) {
-  if (!result.ok) throw new WasiError(result.errno);
-  if (result.kind === "json") return result.json;
-  return result.kind === "bytes" ? result.bytes : void 0;
+function lexical(path) {
+  const walk = start(path);
+  for (let part = next(walk); part !== void 0; part = next(walk)) walk.done.push(part);
+  return `/${walk.done.join("/")}`;
 }
-function code(err) {
-  const c = err?.code;
-  return typeof c === "string" ? c : void 0;
+function rest(walk, part) {
+  return lexical(`/${[...walk.done, part, ...walk.todo].join("/")}`);
 }
-function importsContext({
-  host,
-  raw,
-  tid,
-  memory,
-  instance
-}) {
-  const { fs } = host.o;
-  const call2 = (req) => value(raw(req));
-  const pathOf = (fd) => {
-    const e = host.fds.get(fd);
-    if (e.type === "file") return e.file.path;
-    if (e.type === "dir") return e.path;
-    if (e.type === "kernel" && host.fds.kind(fd, e) === "file") {
-      return call2({ op: "fd-vfs-stat", fd }).path;
+function follow(walk, target) {
+  if (++walk.hops > MAX_HOPS) return false;
+  if (target.startsWith("/")) walk.done.length = 0;
+  walk.todo = [...target.split("/").filter((p) => p !== ""), ...walk.todo];
+  return true;
+}
+function physicalPath(fs, path) {
+  const walk = start(path);
+  for (let part = next(walk); part !== void 0; part = next(walk)) {
+    const at = `/${[...walk.done, part].join("/")}`;
+    let target;
+    try {
+      target = fs.lstat(at).isSymbolicLink ? fs.readlink(at) : void 0;
+    } catch {
+      return rest(walk, part);
     }
-    return void 0;
-  };
-  const requirePath = (fd) => {
-    const path = pathOf(fd);
-    if (path === void 0) throw new WasiError("EBADF");
-    return path;
-  };
-  const fds = {
-    open(path, o = {}) {
-      const abs = host.fds.resolve(3, path);
-      if (o.nofollow && fs.exists(abs) && fs.lstat(abs).isSymbolicLink)
-        throw new WasiError("ELOOP");
-      const existed = fs.exists(abs);
-      const oflags = (o.create ? OFLAGS.CREAT : 0) | (o.exclusive ? OFLAGS.EXCL : 0) | (o.truncate ? OFLAGS.TRUNC : 0) | (o.directory ? OFLAGS.DIRECTORY : 0);
-      const rights = (o.write ? RIGHTS.FD_WRITE : 0n) | (o.read || !o.write ? RIGHTS.FD_READ : 0n);
-      const fd = host.fds.open(abs, oflags, rights, o.append ? FDFLAGS.APPEND : 0);
-      if (o.mode !== void 0 && !existed) fs.chmod(abs, o.mode);
-      return fd;
-    },
-    close(fd) {
-      host.fds.close(fd);
-    },
-    fstat(fd) {
-      const e = host.fds.get(fd);
-      const path = pathOf(fd);
-      if (path === void 0) {
-        const kind = e.type === "device" ? "device" : "stream";
-        return { kind, mode: kind === "device" ? 8630 : 4480, uid: UID2, gid: UID2, size: 0 };
+    if (target === void 0) walk.done.push(part);
+    else if (!follow(walk, target)) {
+      throw Object.assign(new Error("too many levels of symbolic links"), { code: "ELOOP" });
+    }
+  }
+  return `/${walk.done.join("/")}`;
+}
+var MAX_HOPS;
+var init_physical_path = __esm({
+  "src/fs/physical-path.ts"() {
+    "use strict";
+    MAX_HOPS = 40;
+  }
+});
+
+// src/process/wasi/wasix-process.ts
+function restarted2(issue) {
+  for (; ; ) {
+    try {
+      return issue();
+    } catch (e) {
+      if (e?.code !== "EINTR") throw e;
+    }
+  }
+}
+function resolveFrom(cwd, path) {
+  return normalize(path.startsWith("/") ? path : `${cwd}/${path}`);
+}
+var O_WRONLY5, O_RDWR5, O_APPEND2, OFLAG_CREAT, OFLAG_TRUNC, WasixProcess;
+var init_wasix_process = __esm({
+  "src/process/wasi/wasix-process.ts"() {
+    "use strict";
+    init_physical_path();
+    init_wasi_files();
+    init_wasi_host();
+    O_WRONLY5 = 1;
+    O_RDWR5 = 2;
+    O_APPEND2 = 1024;
+    OFLAG_CREAT = 1;
+    OFLAG_TRUNC = 8;
+    WasixProcess = class {
+      host;
+      driver;
+      inThread;
+      constructor(host, driver, inThread = () => false) {
+        this.host = host;
+        this.driver = driver;
+        this.inThread = inThread;
       }
-      host.fds.flushPath(path);
-      const s = fs.stat(path);
-      return {
-        kind: s.isDirectory ? "dir" : "file",
-        path,
-        mode: s.mode ?? (s.isDirectory ? 16877 : 33188),
-        uid: UID2,
-        gid: UID2,
-        size: s.size,
-        ...s.ino !== void 0 ? { ino: s.ino } : {},
-        ...s.mtimeMs !== void 0 ? { mtimeMs: s.mtimeMs } : {}
-      };
-    },
-    fchmod(fd, mode) {
-      fs.chmod(requirePath(fd), mode);
-    },
-    tryLock(fd, exclusive) {
-      const path = requirePath(fd);
-      try {
-        call2({ op: "lock", path, exclusive, fd });
-      } catch (err) {
-        if (code(err) === "EAGAIN") return E.AGAIN;
-        throw err;
+      restart() {
+        return this.inThread() ? {} : { restart: true };
       }
-      return E.SUCCESS;
-    },
-    unlock(fd) {
-      call2({ op: "unlock", path: requirePath(fd) });
-    }
+      call(req) {
+        return this.host.o.kernel.call(req);
+      }
+      environment() {
+        return { ...this.host.o.env, PWD: this.host.cwd };
+      }
+      locate(name, search, path) {
+        if (name.includes("/"))
+          return name.startsWith("/") ? name : normalize(`${this.host.cwd}/${name}`);
+        if (!search) return name;
+        for (const dir of path.split(":")) {
+          if (!dir) continue;
+          const candidate = normalize(
+            `${dir.startsWith("/") ? "" : `${this.host.cwd}/`}${dir}/${name}`
+          );
+          if (this.host.o.fs.exists(candidate)) return candidate;
+        }
+        return name;
+      }
+      childFds(ops) {
+        const { fds } = this.host;
+        fds.promoteFiles();
+        const map = fds.inheritable();
+        const nulls = /* @__PURE__ */ new Set();
+        const opened = [];
+        let cwd = this.host.cwd;
+        try {
+          for (const op of ops) cwd = this.applyFdOp(op, { map, nulls, opened }, cwd);
+        } catch (e) {
+          for (const kfd of opened) this.host.o.kernel.sys.close(kfd);
+          throw e;
+        }
+        const stdio = [0, 1, 2].map((fd) => {
+          const k = map.get(fd);
+          return k === void 0 ? { none: true } : { fd: k };
+        });
+        const inherit = [
+          ...[...map].filter(([fd]) => fd > 2).map(([fd, kernel]) => ({ fd, kernel })),
+          ...[...nulls].filter((fd) => fd > 2).map((fd) => ({ fd, device: "null" }))
+        ];
+        return { stdio, inherit, cwd, opened };
+      }
+      applyFdOp(op, slots2, cwd) {
+        const { map, nulls, opened } = slots2;
+        const { fds } = this.host;
+        const point = (fd, kfd) => {
+          if (kfd === void 0) {
+            map.delete(fd);
+            nulls.add(fd);
+          } else {
+            map.set(fd, kfd);
+            nulls.delete(fd);
+          }
+        };
+        if (op.cmd === "close") {
+          map.delete(op.fd);
+          nulls.delete(op.fd);
+        } else if (op.cmd === "dup2" && nulls.has(op.srcFd)) point(op.fd, void 0);
+        else if (op.cmd === "dup2") {
+          const src = map.get(op.srcFd) ?? (fds.find(op.srcFd)?.type === "kernel" ? op.srcFd : void 0);
+          if (src === void 0) throw Object.assign(new Error("EBADF"), { code: "EBADF" });
+          point(op.fd, src);
+        } else if (op.cmd === "open" && resolveFrom(cwd, op.path) === "/dev/null") {
+          point(op.fd, void 0);
+        } else if (op.cmd === "open") {
+          const kfd = this.openFor(op, cwd);
+          opened.push(kfd);
+          point(op.fd, kfd);
+        } else if (op.cmd === "chdir") return this.physicalFrom(cwd, op.path);
+        else return physicalPath(this.host.o.fs, fds.dir(op.fd).path);
+        return cwd;
+      }
+      physicalFrom(cwd, path) {
+        return physicalPath(this.host.o.fs, path.startsWith("/") ? path : `${cwd}/${path}`);
+      }
+      openFor(op, cwd) {
+        const path = resolveFrom(cwd, op.path);
+        const create = (op.oflags & OFLAG_CREAT) !== 0;
+        if (!create && !this.host.o.fs.exists(path)) {
+          throw Object.assign(new Error("ENOENT"), { code: "ENOENT" });
+        }
+        const flags = (op.rightsWrite ? O_RDWR5 : 0) | (op.append ? O_APPEND2 : 0);
+        return this.host.o.kernel.sys.openVfs(path, op.rightsWrite ? flags || O_WRONLY5 : 0, 0, {
+          ...create ? { create } : {},
+          ...op.oflags & OFLAG_TRUNC ? { truncate: true } : {}
+        });
+      }
+      spawn(req, exec = false) {
+        const { stdio, inherit, cwd, opened } = this.childFds(req.ops ?? []);
+        try {
+          const spawn = {
+            op: "proc-spawn",
+            file: this.locate(req.name, req.search, req.path),
+            argv: req.argv.length > 0 ? req.argv : [req.name],
+            env: req.env ?? this.environment(),
+            cwd,
+            stdio,
+            inherit,
+            ...exec ? { exec } : {},
+            ...this.restart()
+          };
+          return restarted2(() => this.call(spawn));
+        } finally {
+          for (const kfd of opened) this.host.o.kernel.sys.close(kfd);
+          this.host.o.fs.invalidate?.();
+        }
+      }
+      exec(req) {
+        const pid = this.spawn(req, true);
+        const [, status2] = this.call({ op: "proc-exec", pid });
+        const sig = status2 & 127;
+        throw new WasiExit(sig ? 128 + sig : status2 >> 8 & 255);
+      }
+      join(pidPtr, flags, statusPtr) {
+        const v = this.host.mem.view();
+        const pid = v.getUint8(pidPtr) === 1 ? v.getUint32(pidPtr + 4, true) : -1;
+        this.host.mem.bytes(statusPtr, 6).fill(0);
+        const [child, status2] = this.call({ op: "proc-wait", pid, nohang: (flags & 1) !== 0 });
+        if (child === 0) return;
+        this.host.o.fs.invalidate?.();
+        v.setUint8(pidPtr, 1);
+        v.setUint32(pidPtr + 4, child, true);
+        const sig = status2 & 127;
+        if (sig) {
+          v.setUint8(statusPtr, 2);
+          v.setUint8(statusPtr + 4, sig);
+        } else {
+          v.setUint8(statusPtr, 1);
+          v.setUint16(statusPtr + 2, status2 >> 8 & 255, true);
+        }
+      }
+      fork(pidPtr) {
+        const back = this.driver.rewound();
+        if (back !== void 0) {
+          this.host.mem.view().setUint32(pidPtr, back, true);
+          return void 0;
+        }
+        return this.driver.fork(
+          (asyncifyData, globals, forkSp) => restarted2(() => this.forkCall(asyncifyData, globals, forkSp))
+        );
+      }
+      forkCall(asyncifyData, globals, forkSp) {
+        const { fds } = this.host;
+        fds.promoteFiles();
+        const memory = this.host.mem.bytes(0, this.host.mem.size()).slice();
+        const wasi = {
+          asyncifyData,
+          globals,
+          fds: fds.snapshot(),
+          cloexec: [...fds.cloexec],
+          cwd: this.host.cwd,
+          ...fds.isShared ? { shared: true } : {},
+          setjmps: this.driver.setjmps(),
+          ...this.host.signals ? { signals: this.host.signals.snapshot() } : {}
+        };
+        return this.call({
+          op: "proc-fork",
+          state: { memory, currData: 0, forkSp, callStackNames: [], ppid: this.host.o.pid, wasi },
+          ...this.restart()
+        });
+      }
+    };
+  }
+});
+
+// src/process/wasi/wasi-imports.ts
+function base64(text) {
+  const bytes = new TextEncoder().encode(text);
+  let binary = "";
+  for (let at = 0; at < bytes.length; at += 32768) {
+    binary += String.fromCharCode(...bytes.subarray(at, at + 32768));
+  }
+  return btoa(binary);
+}
+function importSource(source) {
+  return import(`data:text/javascript;base64,${base64(source)}`);
+}
+async function loadImports(source) {
+  const loaded = await importSource(source);
+  if (typeof loaded.createImports !== "function") {
+    throw new Error("the imports module exports no createImports function");
+  }
+  return loaded.createImports;
+}
+function value(result) {
+  if (!result.ok) throw new WasiError(result.errno);
+  if (result.kind === "json") return result.json;
+  return result.kind === "bytes" ? result.bytes : void 0;
+}
+function code(err) {
+  const c = err?.code;
+  return typeof c === "string" ? c : void 0;
+}
+function importsContext({
+  host,
+  raw,
+  tid,
+  memory,
+  instance
+}) {
+  const { fs } = host.o;
+  const call2 = (req) => value(raw(req));
+  const pathOf = (fd) => {
+    const e = host.fds.get(fd);
+    if (e.type === "file") return e.file.path;
+    if (e.type === "dir") return e.path;
+    if (e.type === "kernel" && host.fds.kind(fd, e) === "file") {
+      return call2({ op: "fd-vfs-stat", fd }).path;
+    }
+    return void 0;
+  };
+  const requirePath = (fd) => {
+    const path = pathOf(fd);
+    if (path === void 0) throw new WasiError("EBADF");
+    return path;
+  };
+  const fds = {
+    open(path, o = {}) {
+      const abs = host.fds.resolve(3, path);
+      if (o.nofollow && fs.exists(abs) && fs.lstat(abs).isSymbolicLink)
+        throw new WasiError("ELOOP");
+      const existed = fs.exists(abs);
+      const oflags = (o.create ? OFLAGS.CREAT : 0) | (o.exclusive ? OFLAGS.EXCL : 0) | (o.truncate ? OFLAGS.TRUNC : 0) | (o.directory ? OFLAGS.DIRECTORY : 0);
+      const rights = (o.write ? RIGHTS.FD_WRITE : 0n) | (o.read || !o.write ? RIGHTS.FD_READ : 0n);
+      const fd = host.fds.open(abs, oflags, rights, o.append ? FDFLAGS.APPEND : 0);
+      if (o.mode !== void 0 && !existed) fs.chmod(abs, o.mode);
+      return fd;
+    },
+    close(fd) {
+      host.fds.close(fd);
+    },
+    fstat(fd) {
+      const e = host.fds.get(fd);
+      const path = pathOf(fd);
+      if (path === void 0) {
+        const kind = e.type === "device" ? "device" : "stream";
+        return { kind, mode: kind === "device" ? 8630 : 4480, uid: UID2, gid: UID2, size: 0 };
+      }
+      host.fds.flushPath(path);
+      const s = fs.stat(path);
+      return {
+        kind: s.isDirectory ? "dir" : "file",
+        path,
+        mode: s.mode ?? (s.isDirectory ? 16877 : 33188),
+        uid: UID2,
+        gid: UID2,
+        size: s.size,
+        ...s.ino !== void 0 ? { ino: s.ino } : {},
+        ...s.mtimeMs !== void 0 ? { mtimeMs: s.mtimeMs } : {}
+      };
+    },
+    fchmod(fd, mode) {
+      fs.chmod(requirePath(fd), mode);
+    },
+    tryLock(fd, exclusive) {
+      const path = requirePath(fd);
+      try {
+        call2({ op: "lock", path, exclusive, fd });
+      } catch (err) {
+        if (code(err) === "EAGAIN") return E.AGAIN;
+        throw err;
+      }
+      return E.SUCCESS;
+    },
+    unlock(fd) {
+      call2({ op: "unlock", path: requirePath(fd) });
+    }
   };
   return {
     memory,
@@ -6176,7 +6529,7 @@ function importsContext({
     fs,
     fds,
     syscall: call2,
-    ...processes(host, call2),
+    ...processes(host, call2, tid !== MAIN_TID),
     async: {
       submit: (req) => call2({ op: "async-submit", req }),
       wait(timeoutMs) {
@@ -6206,7 +6559,7 @@ function importsContext({
     errno: (err) => wasiErrnoOf(code(err))
   };
 }
-function processes(host, call2) {
+function processes(host, call2, inThread) {
   const close = (fd) => void call2({ op: "fd-close", fd });
   const slot = (n, how, mine, theirs) => {
     if (how === "inherit") return { fd: n };
@@ -6223,14 +6576,16 @@ function processes(host, call2) {
       host.fds.promoteFiles();
       try {
         const stdio = STDIO.map((name, n) => slot(n, o[name] ?? "inherit", mine, theirs));
-        const pid = call2({
+        const req = {
           op: "proc-spawn",
           file: o.argv[0],
           argv: o.argv,
           env: o.env ?? { ...host.o.env },
           cwd: o.cwd ?? host.cwd,
-          stdio
-        });
+          stdio,
+          ...inThread ? {} : { restart: true }
+        };
+        const pid = restarted2(() => call2(req));
         const out = { pid };
         STDIO.forEach((name, n) => {
           if (mine[n] !== void 0) out[name] = mine[n];
@@ -6267,6 +6622,8 @@ var init_wasi_imports = __esm({
     "use strict";
     init_wasi_abi();
     init_wasi_files();
+    init_wasi_threads();
+    init_wasix_process();
     UID2 = 1e3;
     STDIO = ["stdin", "stdout", "stderr"];
   }
@@ -6467,76 +6824,6 @@ var init_wasi_stats = __esm({
   }
 });
 
-// src/process/wasi/wasi-threads.ts
-function threadCap(env) {
-  const asked = Number.parseInt(env.SLICC_WASM_THREADS ?? "", 10);
-  return asked >= 1 ? Math.min(asked, WASM_MAX_THREADS) : WASM_DEFAULT_THREADS;
-}
-var LAST_TID, RUNNING, MAIN_TID, ThreadExit, WasiThreads;
-var init_wasi_threads = __esm({
-  "src/process/wasi/wasi-threads.ts"() {
-    "use strict";
-    init_protocol();
-    LAST_TID = 0;
-    RUNNING = 1;
-    MAIN_TID = 1;
-    ThreadExit = class extends Error {
-      constructor() {
-        super("thread exit");
-      }
-    };
-    WasiThreads = class {
-      ids;
-      beforeSpawn;
-      modules;
-      received;
-      port;
-      memory;
-      cap;
-      tid;
-      constructor(port3, memory, cap, tid, ids) {
-        this.port = port3;
-        this.memory = memory;
-        this.cap = cap;
-        this.tid = tid;
-        this.ids = new Int32Array(ids ?? new SharedArrayBuffer(16));
-        if (!ids) Atomics.store(this.ids, LAST_TID, MAIN_TID);
-      }
-      spawn(arg) {
-        if (Atomics.add(this.ids, RUNNING, 1) + 1 >= this.cap) {
-          Atomics.sub(this.ids, RUNNING, 1);
-          return -1;
-        }
-        this.beforeSpawn?.();
-        const tid = Atomics.add(this.ids, LAST_TID, 1) + 1;
-        const modules = this.modules?.();
-        this.port.postMessage({
-          type: WASM_THREAD_SPAWN,
-          thread: {
-            tid,
-            arg,
-            memory: this.memory,
-            ids: this.ids.buffer,
-            ...modules ? { modules } : {}
-          }
-        });
-        return tid;
-      }
-      exited() {
-        Atomics.sub(this.ids, RUNNING, 1);
-        this.port.postMessage({ type: WASM_THREAD_EXIT });
-      }
-      known(tid) {
-        return tid >= MAIN_TID && tid <= Atomics.load(this.ids, LAST_TID);
-      }
-      parallelism() {
-        const cores = globalThis.navigator?.hardwareConcurrency;
-        return Math.max(1, Math.min(this.cap, cores ?? this.cap));
-      }
-    };
-  }
-});
-
 // src/process/wasi/wasix-fork.ts
 function mutableGlobals(exports) {
   const out = [];
@@ -6898,325 +7185,88 @@ var init_wasix_linker = __esm({
             pending.push(() => {
               g.value = this.slotOrNull(imp.name);
             });
-          }
-        }
-        const imports = {
-          ...this.host.hostImports(module),
-          env,
-          "GOT.mem": gotMem,
-          "GOT.func": gotFunc
-        };
-        linked.instance = new WebAssembly.Instance(module, imports);
-        this.modules.set(at.handle, linked);
-        this.byPath.set(path, linked);
-        for (const resolve of pending) resolve();
-        if (init) {
-          call(linked.instance, "__wasm_apply_data_relocs");
-          call(linked.instance, "__wasm_call_ctors");
-        } else {
-          call(linked.instance, "__wasix_init_tls");
-        }
-        return linked;
-      }
-      functionImport(name) {
-        const now = this.find(name);
-        if (now && typeof now[1] === "function") return now[1];
-        let resolved2;
-        return (...args) => {
-          if (!resolved2) {
-            const later = this.find(name);
-            if (!later || typeof later[1] !== "function")
-              throw new WebAssembly.RuntimeError(`unresolved symbol ${name}`);
-            resolved2 = later[1];
-          }
-          return resolved2(...args);
-        };
-      }
-      addressOrNull(name) {
-        const found = this.find(name);
-        if (!found || !(found[1] instanceof WebAssembly.Global)) return 0;
-        return this.baseOf(found[0]) + found[1].value;
-      }
-      slotOrNull(name) {
-        const found = this.find(name);
-        if (!found || typeof found[1] !== "function") return 0;
-        return this.slot(found[1], found[0], name);
-      }
-      find(name) {
-        const inMain = this.main?.exports[name];
-        if (inMain !== void 0) return [0, inMain];
-        for (const m of this.modules.values()) {
-          const v = m.instance?.exports[name];
-          if (v !== void 0) return [m.handle, v];
-        }
-        return void 0;
-      }
-      findIn(m, name, seen) {
-        if (seen.has(m.handle)) return void 0;
-        seen.add(m.handle);
-        const v = m.instance.exports[name];
-        if (v !== void 0) return [m.handle, v];
-        for (const h of m.needed) {
-          const found = this.findIn(this.module(h), name, seen);
-          if (found) return found;
-        }
-        return void 0;
-      }
-      baseOf(handle) {
-        return handle === 0 ? this.memoryBase : this.module(handle).memoryBase;
-      }
-      slot(fn, handle, name) {
-        const known = this.slots.get(fn);
-        if (known !== void 0) return known;
-        const index2 = this.table.length;
-        this.table.grow(1);
-        this.table.set(index2, fn);
-        this.slots.set(fn, index2);
-        this.publisher?.({ kind: "slot", index: index2, handle, name });
-        return index2;
-      }
-      allocate(size, alignment) {
-        if (size === 0) return 0;
-        const base = align(this.memory.buffer.byteLength, Math.max(alignment, 16));
-        growTo(this.memory, base + size);
-        return base;
-      }
-    };
-  }
-});
-
-// src/fs/physical-path.ts
-function start(path) {
-  return { done: [], todo: path.split("/").filter((p) => p !== ""), hops: 0 };
-}
-function next(walk) {
-  while (walk.todo.length > 0) {
-    const part = walk.todo.shift();
-    if (part === ".") continue;
-    if (part === "..") {
-      walk.done.pop();
-      continue;
-    }
-    return part;
-  }
-  return void 0;
-}
-function lexical(path) {
-  const walk = start(path);
-  for (let part = next(walk); part !== void 0; part = next(walk)) walk.done.push(part);
-  return `/${walk.done.join("/")}`;
-}
-function rest(walk, part) {
-  return lexical(`/${[...walk.done, part, ...walk.todo].join("/")}`);
-}
-function follow(walk, target) {
-  if (++walk.hops > MAX_HOPS) return false;
-  if (target.startsWith("/")) walk.done.length = 0;
-  walk.todo = [...target.split("/").filter((p) => p !== ""), ...walk.todo];
-  return true;
-}
-function physicalPath(fs, path) {
-  const walk = start(path);
-  for (let part = next(walk); part !== void 0; part = next(walk)) {
-    const at = `/${[...walk.done, part].join("/")}`;
-    let target;
-    try {
-      target = fs.lstat(at).isSymbolicLink ? fs.readlink(at) : void 0;
-    } catch {
-      return rest(walk, part);
-    }
-    if (target === void 0) walk.done.push(part);
-    else if (!follow(walk, target)) {
-      throw Object.assign(new Error("too many levels of symbolic links"), { code: "ELOOP" });
-    }
-  }
-  return `/${walk.done.join("/")}`;
-}
-var MAX_HOPS;
-var init_physical_path = __esm({
-  "src/fs/physical-path.ts"() {
-    "use strict";
-    MAX_HOPS = 40;
-  }
-});
-
-// src/process/wasi/wasix-process.ts
-function resolveFrom(cwd, path) {
-  return normalize(path.startsWith("/") ? path : `${cwd}/${path}`);
-}
-var O_WRONLY5, O_RDWR5, O_APPEND2, OFLAG_CREAT, OFLAG_TRUNC, WasixProcess;
-var init_wasix_process = __esm({
-  "src/process/wasi/wasix-process.ts"() {
-    "use strict";
-    init_physical_path();
-    init_wasi_files();
-    init_wasi_host();
-    O_WRONLY5 = 1;
-    O_RDWR5 = 2;
-    O_APPEND2 = 1024;
-    OFLAG_CREAT = 1;
-    OFLAG_TRUNC = 8;
-    WasixProcess = class {
-      host;
-      driver;
-      constructor(host, driver) {
-        this.host = host;
-        this.driver = driver;
-      }
-      call(req) {
-        return this.host.o.kernel.call(req);
-      }
-      environment() {
-        return { ...this.host.o.env, PWD: this.host.cwd };
-      }
-      locate(name, search, path) {
-        if (name.includes("/"))
-          return name.startsWith("/") ? name : normalize(`${this.host.cwd}/${name}`);
-        if (!search) return name;
-        for (const dir of path.split(":")) {
-          if (!dir) continue;
-          const candidate = normalize(
-            `${dir.startsWith("/") ? "" : `${this.host.cwd}/`}${dir}/${name}`
-          );
-          if (this.host.o.fs.exists(candidate)) return candidate;
+          }
         }
-        return name;
-      }
-      childFds(ops) {
-        const { fds } = this.host;
-        fds.promoteFiles();
-        const map = fds.inheritable();
-        const nulls = /* @__PURE__ */ new Set();
-        const opened = [];
-        let cwd = this.host.cwd;
-        try {
-          for (const op of ops) cwd = this.applyFdOp(op, { map, nulls, opened }, cwd);
-        } catch (e) {
-          for (const kfd of opened) this.host.o.kernel.sys.close(kfd);
-          throw e;
+        const imports = {
+          ...this.host.hostImports(module),
+          env,
+          "GOT.mem": gotMem,
+          "GOT.func": gotFunc
+        };
+        linked.instance = new WebAssembly.Instance(module, imports);
+        this.modules.set(at.handle, linked);
+        this.byPath.set(path, linked);
+        for (const resolve of pending) resolve();
+        if (init) {
+          call(linked.instance, "__wasm_apply_data_relocs");
+          call(linked.instance, "__wasm_call_ctors");
+        } else {
+          call(linked.instance, "__wasix_init_tls");
         }
-        const stdio = [0, 1, 2].map((fd) => {
-          const k = map.get(fd);
-          return k === void 0 ? { none: true } : { fd: k };
-        });
-        const inherit = [
-          ...[...map].filter(([fd]) => fd > 2).map(([fd, kernel]) => ({ fd, kernel })),
-          ...[...nulls].filter((fd) => fd > 2).map((fd) => ({ fd, device: "null" }))
-        ];
-        return { stdio, inherit, cwd, opened };
+        return linked;
       }
-      applyFdOp(op, slots2, cwd) {
-        const { map, nulls, opened } = slots2;
-        const { fds } = this.host;
-        const point = (fd, kfd) => {
-          if (kfd === void 0) {
-            map.delete(fd);
-            nulls.add(fd);
-          } else {
-            map.set(fd, kfd);
-            nulls.delete(fd);
+      functionImport(name) {
+        const now = this.find(name);
+        if (now && typeof now[1] === "function") return now[1];
+        let resolved2;
+        return (...args) => {
+          if (!resolved2) {
+            const later = this.find(name);
+            if (!later || typeof later[1] !== "function")
+              throw new WebAssembly.RuntimeError(`unresolved symbol ${name}`);
+            resolved2 = later[1];
           }
+          return resolved2(...args);
         };
-        if (op.cmd === "close") {
-          map.delete(op.fd);
-          nulls.delete(op.fd);
-        } else if (op.cmd === "dup2" && nulls.has(op.srcFd)) point(op.fd, void 0);
-        else if (op.cmd === "dup2") {
-          const src = map.get(op.srcFd) ?? (fds.find(op.srcFd)?.type === "kernel" ? op.srcFd : void 0);
-          if (src === void 0) throw Object.assign(new Error("EBADF"), { code: "EBADF" });
-          point(op.fd, src);
-        } else if (op.cmd === "open" && resolveFrom(cwd, op.path) === "/dev/null") {
-          point(op.fd, void 0);
-        } else if (op.cmd === "open") {
-          const kfd = this.openFor(op, cwd);
-          opened.push(kfd);
-          point(op.fd, kfd);
-        } else if (op.cmd === "chdir") return this.physicalFrom(cwd, op.path);
-        else return physicalPath(this.host.o.fs, fds.dir(op.fd).path);
-        return cwd;
       }
-      physicalFrom(cwd, path) {
-        return physicalPath(this.host.o.fs, path.startsWith("/") ? path : `${cwd}/${path}`);
+      addressOrNull(name) {
+        const found = this.find(name);
+        if (!found || !(found[1] instanceof WebAssembly.Global)) return 0;
+        return this.baseOf(found[0]) + found[1].value;
       }
-      openFor(op, cwd) {
-        const path = resolveFrom(cwd, op.path);
-        const create = (op.oflags & OFLAG_CREAT) !== 0;
-        if (!create && !this.host.o.fs.exists(path)) {
-          throw Object.assign(new Error("ENOENT"), { code: "ENOENT" });
+      slotOrNull(name) {
+        const found = this.find(name);
+        if (!found || typeof found[1] !== "function") return 0;
+        return this.slot(found[1], found[0], name);
+      }
+      find(name) {
+        const inMain = this.main?.exports[name];
+        if (inMain !== void 0) return [0, inMain];
+        for (const m of this.modules.values()) {
+          const v = m.instance?.exports[name];
+          if (v !== void 0) return [m.handle, v];
         }
-        const flags = (op.rightsWrite ? O_RDWR5 : 0) | (op.append ? O_APPEND2 : 0);
-        return this.host.o.kernel.sys.openVfs(path, op.rightsWrite ? flags || O_WRONLY5 : 0, 0, {
-          ...create ? { create } : {},
-          ...op.oflags & OFLAG_TRUNC ? { truncate: true } : {}
-        });
+        return void 0;
       }
-      spawn(req, exec = false) {
-        const { stdio, inherit, cwd, opened } = this.childFds(req.ops ?? []);
-        try {
-          return this.call({
-            op: "proc-spawn",
-            file: this.locate(req.name, req.search, req.path),
-            argv: req.argv.length > 0 ? req.argv : [req.name],
-            env: req.env ?? this.environment(),
-            cwd,
-            stdio,
-            inherit,
-            ...exec ? { exec } : {}
-          });
-        } finally {
-          for (const kfd of opened) this.host.o.kernel.sys.close(kfd);
-          this.host.o.fs.invalidate?.();
+      findIn(m, name, seen) {
+        if (seen.has(m.handle)) return void 0;
+        seen.add(m.handle);
+        const v = m.instance.exports[name];
+        if (v !== void 0) return [m.handle, v];
+        for (const h of m.needed) {
+          const found = this.findIn(this.module(h), name, seen);
+          if (found) return found;
         }
+        return void 0;
       }
-      exec(req) {
-        const pid = this.spawn(req, true);
-        const [, status2] = this.call({ op: "proc-exec", pid });
-        const sig = status2 & 127;
-        throw new WasiExit(sig ? 128 + sig : status2 >> 8 & 255);
+      baseOf(handle) {
+        return handle === 0 ? this.memoryBase : this.module(handle).memoryBase;
       }
-      join(pidPtr, flags, statusPtr) {
-        const v = this.host.mem.view();
-        const pid = v.getUint8(pidPtr) === 1 ? v.getUint32(pidPtr + 4, true) : -1;
-        this.host.mem.bytes(statusPtr, 6).fill(0);
-        const [child, status2] = this.call({ op: "proc-wait", pid, nohang: (flags & 1) !== 0 });
-        if (child === 0) return;
-        this.host.o.fs.invalidate?.();
-        v.setUint8(pidPtr, 1);
-        v.setUint32(pidPtr + 4, child, true);
-        const sig = status2 & 127;
-        if (sig) {
-          v.setUint8(statusPtr, 2);
-          v.setUint8(statusPtr + 4, sig);
-        } else {
-          v.setUint8(statusPtr, 1);
-          v.setUint16(statusPtr + 2, status2 >> 8 & 255, true);
-        }
+      slot(fn, handle, name) {
+        const known = this.slots.get(fn);
+        if (known !== void 0) return known;
+        const index2 = this.table.length;
+        this.table.grow(1);
+        this.table.set(index2, fn);
+        this.slots.set(fn, index2);
+        this.publisher?.({ kind: "slot", index: index2, handle, name });
+        return index2;
       }
-      fork(pidPtr) {
-        const back = this.driver.rewound();
-        if (back !== void 0) {
-          this.host.mem.view().setUint32(pidPtr, back, true);
-          return void 0;
-        }
-        return this.driver.fork((asyncifyData, globals, forkSp) => {
-          const { fds } = this.host;
-          fds.promoteFiles();
-          const memory = this.host.mem.bytes(0, this.host.mem.size()).slice();
-          const wasi = {
-            asyncifyData,
-            globals,
-            fds: fds.snapshot(),
-            cloexec: [...fds.cloexec],
-            cwd: this.host.cwd,
-            ...fds.isShared ? { shared: true } : {},
-            setjmps: this.driver.setjmps(),
-            ...this.host.signals ? { signals: this.host.signals.snapshot() } : {}
-          };
-          return this.call({
-            op: "proc-fork",
-            state: { memory, currData: 0, forkSp, callStackNames: [], ppid: this.host.o.pid, wasi }
-          });
-        });
+      allocate(size, alignment) {
+        if (size === 0) return 0;
+        const base = align(this.memory.buffer.byteLength, Math.max(alignment, 16));
+        growTo(this.memory, base + size);
+        return base;
       }
     };
   }
@@ -7530,7 +7580,11 @@ var init_wasix_host = __esm({
       constructor(host, driver, module) {
         this.host = host;
         this.driver = driver;
-        this.process = new WasixProcess(host, driver);
+        this.process = new WasixProcess(
+          host,
+          driver,
+          () => (this.threads?.tid ?? MAIN_TID) !== MAIN_TID
+        );
         if (module && !WebAssembly.Module.imports(module).some((i) => i.name === "fd_fdflags_set")) {
           host.fds.implicitCloexec = true;
           host.interruptWakes = true;
@@ -7748,7 +7802,7 @@ var init_wasix_host = __esm({
       }
       dlImports() {
         const { mem, host } = this;
-        const failed3 = (message2, buf, len) => {
+        const failed4 = (message2, buf, len) => {
           if (len > 0) {
             const bytes = new TextEncoder().encode(message2).subarray(0, len - 1);
             mem.bytes(buf, bytes.length).set(bytes);
@@ -7757,12 +7811,12 @@ var init_wasix_host = __esm({
           return E.NOEXEC;
         };
         const linked = (buf, len, op, out) => {
-          if (!this.linker) return failed3("not a dynamically-linked program", buf, len);
+          if (!this.linker) return failed4("not a dynamically-linked program", buf, len);
           try {
             out(op(this.linker));
             return E.SUCCESS;
           } catch (e) {
-            if (e instanceof DlError) return failed3(e.message, buf, len);
+            if (e instanceof DlError) return failed4(e.message, buf, len);
             throw e;
           }
         };
@@ -8761,6 +8815,239 @@ var init_js_children = __esm({
   }
 });
 
+// src/process/js/js-fetch.ts
+function withoutFragment(url) {
+  url.hash = "";
+  return url.href;
+}
+function failed2(err) {
+  return new TypeError("fetch failed", { cause: err });
+}
+function plain(status2, text) {
+  return new Response(text, {
+    status: status2,
+    headers: { "content-type": "text/plain; charset=utf-8" }
+  });
+}
+function rewrite(hop, status2, location) {
+  const next2 = new URL(location, hop.url);
+  if (next2.protocol !== "http:" && next2.protocol !== "https:") {
+    throw failed2(new JsCallError("EPROTONOSUPPORT", next2.protocol));
+  }
+  const toGet = (status2 === 301 || status2 === 302) && hop.method === "POST" || status2 === 303 && hop.method !== "GET" && hop.method !== "HEAD";
+  const crossOrigin = next2.origin !== new URL(hop.url).origin;
+  const headers = hop.headers.filter(
+    ([name]) => !(toGet && BODY_HEADERS.has(name.toLowerCase())) && !(crossOrigin && CREDENTIALS.has(name.toLowerCase()))
+  );
+  return {
+    url: withoutFragment(next2),
+    method: toGet ? "GET" : hop.method,
+    headers,
+    body: toGet ? void 0 : hop.body
+  };
+}
+function withMeta(response, url, redirected) {
+  const clone = response.clone.bind(response);
+  Object.defineProperty(response, "url", { value: url });
+  Object.defineProperty(response, "redirected", { value: redirected });
+  Object.defineProperty(response, "clone", { value: () => withMeta(clone(), url, redirected) });
+  return response;
+}
+function bytesOf(chunk) {
+  if (typeof chunk === "string") return new TextEncoder().encode(chunk);
+  if (chunk instanceof ArrayBuffer) return new Uint8Array(chunk);
+  if (ArrayBuffer.isView(chunk)) {
+    return new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+  }
+  throw failed2(new TypeError("a request body chunk must be bytes or a string"));
+}
+async function bodyOf(request, cap, signal) {
+  signal.throwIfAborted();
+  if (!request.body || request.method === "GET" || request.method === "HEAD") return void 0;
+  const reader = request.body.getReader();
+  const stop = () => void reader.cancel(signal.reason).catch(() => void 0);
+  signal.addEventListener("abort", stop, { once: true });
+  const parts = [];
+  let length = 0;
+  try {
+    for (; ; ) {
+      const next2 = await reader.read().catch((err) => {
+        throw signal.aborted ? signal.reason : failed2(err);
+      });
+      signal.throwIfAborted();
+      if (next2.done) break;
+      const chunk = bytesOf(next2.value);
+      length += chunk.length;
+      if (length > cap) {
+        reader.cancel().catch(() => void 0);
+        return OVER;
+      }
+      parts.push(chunk);
+    }
+  } finally {
+    signal.removeEventListener("abort", stop);
+  }
+  if (length === 0) return void 0;
+  const out = new Uint8Array(length);
+  let at = 0;
+  for (const part of parts) {
+    out.set(part, at);
+    at += part.length;
+  }
+  return out;
+}
+function fetchOp(kernel) {
+  let traits;
+  const traitsOf = () => {
+    traits ??= kernel.json({ op: "net-traits" });
+    traits.catch(() => {
+      traits = void 0;
+    });
+    return traits;
+  };
+  const close = (handle) => kernel.raw({ op: "net-close", handle });
+  const send = async (hop, signal) => {
+    signal.throwIfAborted();
+    const handle = await kernel.json({
+      op: "net-open",
+      url: hop.url,
+      method: hop.method,
+      headers: hop.headers,
+      ...hop.body ? { body: hop.body } : {}
+    });
+    try {
+      const r = await kernel.blocking({ op: "net-head", handle }, signal);
+      signal.throwIfAborted();
+      return r.ok && r.kind === "json" ? r.json : void 0;
+    } catch (err) {
+      await close(handle);
+      throw signal.aborted ? signal.reason : failed2(err);
+    }
+  };
+  const body = (handle, signal) => {
+    let aborted;
+    const settle = () => {
+      if (aborted) signal.removeEventListener("abort", aborted);
+    };
+    return new ReadableStream(
+      {
+        start(controller) {
+          aborted = () => {
+            controller.error(signal.reason);
+            void close(handle);
+          };
+          signal.addEventListener("abort", aborted, { once: true });
+        },
+        async pull(controller) {
+          let r;
+          try {
+            signal.throwIfAborted();
+            r = await kernel.blocking({ op: "net-read", handle, max: CHUNK }, signal);
+          } catch (err) {
+            settle();
+            await close(handle);
+            throw signal.aborted ? signal.reason : failed2(err);
+          }
+          const bytes = r.ok && r.kind === "bytes" ? r.bytes : new Uint8Array(0);
+          if (bytes.length > 0) {
+            controller.enqueue(bytes);
+            return;
+          }
+          settle();
+          controller.close();
+          await close(handle);
+        },
+        cancel: async () => {
+          settle();
+          await close(handle);
+        }
+      },
+      { highWaterMark: 0 }
+    );
+  };
+  const respond = (head, method, redirected, encoded, signal) => {
+    if (head.status < 200 || head.status > 599) {
+      void close(head.handle);
+      throw failed2(new JsCallError("EPROTO", `status ${head.status}`));
+    }
+    const empty = method === "HEAD" || NULL_BODY.has(head.status);
+    if (empty) void close(head.handle);
+    const headers = new Headers(head.headers);
+    let stream = empty ? null : body(head.handle, signal);
+    const coding = headers.get("content-encoding")?.trim().toLowerCase();
+    if (stream && encoded && coding && DECODED.has(coding)) {
+      const format = coding === "deflate" ? "deflate" : "gzip";
+      stream = stream.pipeThrough(
+        new DecompressionStream(format)
+      );
+      headers.delete("content-encoding");
+      headers.delete("content-length");
+    }
+    const response = new Response(stream, {
+      status: head.status,
+      statusText: head.statusText,
+      headers
+    });
+    return withMeta(response, head.url, redirected);
+  };
+  return async (input, init) => {
+    const request = new Request(input, init);
+    const { signal } = request;
+    signal.throwIfAborted();
+    const known = await traitsOf().catch((err) => {
+      throw failed2(err);
+    });
+    if (!known.manualRedirects && request.redirect !== "follow") {
+      throw failed2(new JsCallError("ENOTSUP", `redirect: ${request.redirect}`));
+    }
+    const url = withoutFragment(new URL(request.url));
+    const bytes = await bodyOf(request, known.maxRequestBody, signal);
+    if (bytes === OVER) {
+      return withMeta(plain(413, `request body over ${known.maxRequestBody} bytes`), url, false);
+    }
+    let hop = {
+      url,
+      method: request.method,
+      headers: [...request.headers],
+      body: bytes
+    };
+    for (let hops = 0; ; hops++) {
+      const head = await send(hop, signal);
+      const location = head.headers.find(([name]) => name.toLowerCase() === "location")?.[1];
+      const follow2 = known.manualRedirects && REDIRECTS.has(head.status) && location !== void 0 && request.redirect !== "manual";
+      if (!follow2) {
+        const redirected = hops > 0 || head.redirected === true;
+        return respond(head, hop.method, redirected, known.encodedBodies, signal);
+      }
+      await close(head.handle);
+      if (request.redirect === "error") throw failed2(new JsCallError("EREDIRECT", hop.url));
+      if (hops >= MAX_REDIRECTS) throw failed2(new JsCallError("ELOOP", hop.url));
+      hop = rewrite(hop, head.status, location);
+    }
+  };
+}
+var CHUNK, MAX_REDIRECTS, NULL_BODY, REDIRECTS, BODY_HEADERS, DECODED, CREDENTIALS, OVER;
+var init_js_fetch = __esm({
+  "src/process/js/js-fetch.ts"() {
+    "use strict";
+    init_js_kernel();
+    CHUNK = 64 * 1024;
+    MAX_REDIRECTS = 20;
+    NULL_BODY = /* @__PURE__ */ new Set([101, 103, 204, 205, 304]);
+    REDIRECTS = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
+    BODY_HEADERS = /* @__PURE__ */ new Set([
+      "content-encoding",
+      "content-language",
+      "content-location",
+      "content-type",
+      "content-length"
+    ]);
+    DECODED = /* @__PURE__ */ new Set(["gzip", "x-gzip", "deflate"]);
+    CREDENTIALS = /* @__PURE__ */ new Set(["authorization", "proxy-authorization", "cookie", "cookie2"]);
+    OVER = /* @__PURE__ */ Symbol("over");
+  }
+});
+
 // src/process/js/js-io.ts
 function typeOf(info) {
   if (info.meta && "dir" in info.meta) return "directory";
@@ -8778,7 +9065,7 @@ function readDevice(info, max, random) {
   if (!dev) return void 0;
   if (dev.access === "write") throw new JsCallError("EBADF", "read");
   if (dev.device === "null") return new Uint8Array(0);
-  const out = new Uint8Array(Math.min(max, CHUNK));
+  const out = new Uint8Array(Math.min(max, CHUNK2));
   if (dev.device === "urandom") random(out);
   return out;
 }
@@ -8839,12 +9126,12 @@ function openRequest(abs, o) {
 function index(n, what) {
   if (!Number.isSafeInteger(n) || n < 0) throw new JsCallError("EINVAL", what);
 }
-var CHUNK, MAX_IO, O_WRONLY6, O_RDWR6, O_APPEND3;
+var CHUNK2, MAX_IO, O_WRONLY6, O_RDWR6, O_APPEND3;
 var init_js_io = __esm({
   "src/process/js/js-io.ts"() {
     "use strict";
     init_js_kernel();
-    CHUNK = 64 * 1024;
+    CHUNK2 = 64 * 1024;
     MAX_IO = 1024 * 1024;
     O_WRONLY6 = 1;
     O_RDWR6 = 2;
@@ -8966,13 +9253,13 @@ function netOps(kernel, io) {
         const r = await kernel.raw({ op: "sock-connect", fd, addr, nonblock: true });
         if (!r.ok && r.errno !== "EINPROGRESS") throw new JsCallError(r.errno, "connect");
         await kernel.blocking({ op: "fd-select", read: [], write: [fd], timeoutMs: -1 }, signal);
-        const failed3 = await kernel.json({
+        const failed4 = await kernel.json({
           op: "sock-getopt",
           fd,
           level: SOL_SOCKET,
           name: SO_ERROR
         });
-        if (failed3 !== 0) throw new JsCallError(errnoName(failed3), "connect");
+        if (failed4 !== 0) throw new JsCallError(errnoName(failed4), "connect");
         return connection(fd);
       });
     }
@@ -9008,7 +9295,7 @@ function syncOps(kernel, shared) {
     infos.set(fd, got);
     return got;
   };
-  const read = (fd, max = CHUNK) => {
+  const read = (fd, max = CHUNK2) => {
     index(max, "read");
     const emulated = readDevice(info(fd), max, shared.random);
     if (emulated) return emulated;
@@ -9217,7 +9504,7 @@ var init_js_sync = __esm({
 });
 
 // src/process/js/js-websocket.ts
-function failed2(err) {
+function failed3(err) {
   return new TypeError("websocket failed", { cause: err });
 }
 function socketUrl(input) {
@@ -9261,7 +9548,7 @@ function websocketOp(kernel) {
       protocol = (r.ok && r.kind === "json" ? r.json : {}).protocol;
     } catch (err) {
       await free();
-      throw signal.aborted ? signal.reason : failed2(err);
+      throw signal.aborted ? signal.reason : failed3(err);
     }
     let settle;
     let lose;
@@ -9311,7 +9598,7 @@ function websocketOp(kernel) {
           try {
             r = await kernel.blocking({ op: "net-ws-recv", handle }, stop.signal);
           } catch (err) {
-            hardStop(stop.signal.aborted ? stop.signal.reason : failed2(err));
+            hardStop(stop.signal.aborted ? stop.signal.reason : failed3(err));
             throw stop.signal.reason;
           }
           stop.signal.throwIfAborted();
@@ -9416,7 +9703,7 @@ function createContext(o) {
     infos.set(fd, got);
     return got;
   };
-  const read = async (fd, max = CHUNK, signal) => {
+  const read = async (fd, max = CHUNK2, signal) => {
     index(max, "read");
     const emulated = readDevice(await info(fd), max, random);
     if (emulated) return emulated;
@@ -9529,6 +9816,7 @@ function createContext(o) {
       reset: async (signal) => kernel.setHandler(signalNumber(signal), "default")
     },
     sync,
+    fetch: fetchOp(kernel),
     ...children,
     net: netOps(kernel, io),
     websocket: websocketOp(kernel),
@@ -9665,6 +9953,7 @@ var init_js_context = __esm({
     init_signals();
     init_sync_fs_wire();
     init_js_children();
+    init_js_fetch();
     init_js_io();
     init_js_kernel();
     init_js_net();
@@ -9870,20 +10159,20 @@ function started(init, port3, run, wasi, js) {
   return run(wasmInit, port3);
 }
 function processEntry(port3, run = runWasmProcess, wasi = loadWasi, js = loadJs) {
-  const failed3 = (err) => port3.postMessage({
+  const failed4 = (err) => port3.postMessage({
     type: WASM_PROCESS_ERROR,
     message: err instanceof Error ? err.stack ?? err.message : String(err)
   });
   return (data) => {
     const type = data?.type;
     if (type === WASM_THREAD_INIT) {
-      wasi().then((m) => m.runWasiThread(data, port3)).catch(failed3);
+      wasi().then((m) => m.runWasiThread(data, port3)).catch(failed4);
       return;
     }
     if (type !== WASM_PROCESS_INIT) return;
     started(data, port3, run, wasi, js).then(
       (code2) => port3.postMessage({ type: WASM_PROCESS_EXIT, code: code2 }),
-      failed3
+      failed4
     );
   };
 }