@ai-ecoverse/slicc-kernel 1.37.0 → 1.39.0

package/dist/node-process-worker.js

@@ -259,11 +259,11 @@ var init_pages = __esm({
           runs.push({ offset: start, bytes });
           i = j;
         }
-        const written = Math.max(this.stored, ...runs.map((r) => r.offset + r.bytes.length));
+        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 > written ? { extend: this.length } : {}
+          ...this.length > written2 ? { extend: this.length } : {}
         };
       }
       flushed() {
@@ -691,7 +691,7 @@ function createHelpers(Fs, ops) {
     if (s.ranged) call2(() => s.ranged?.flush());
     else {
       const bytes = s.data.slice(0, s.len);
-      call2(() => bridgeOf(node).writeFile(liveNodePath(node), bytes));
+      call2(() => bridgeOf(node).writeFile(liveNodePath(node), bytes, true));
     }
     s.dirty = false;
     s.stat = void 0;
@@ -920,6 +920,12 @@ function createStreamOps(h) {
       }
     }
   };
+  const opened = (node, on) => {
+    try {
+      bridgeOf(node).hold?.(liveNodePath(node), on, true);
+    } catch {
+    }
+  };
   return {
     open(stream) {
       if (!Fs.isFile(stream.node.mode)) return;
@@ -927,6 +933,7 @@ function createStreamOps(h) {
       if (s.openCount === 0 && !s.orphan) {
         const bridge = bridgeOf(stream.node);
         s.ranges = !!(bridge.pread && bridge.pwrite && bridge.truncate && statOf(stream.node).ranged);
+        rangedOf(stream.node);
       }
       if ((stream.flags & 3) !== 0) {
         try {
@@ -939,6 +946,7 @@ function createStreamOps(h) {
         }
       }
       stream.node.live.openCount++;
+      if (stream.node.live.openCount === 1) opened(stream.node, true);
       held(stream, 1);
     },
     dup(stream) {
@@ -964,6 +972,7 @@ function createStreamOps(h) {
         s.len = 0;
         s.loaded = false;
         held(stream, -1);
+        opened(node, false);
       }
     },
     read(stream, buffer, offset, length, position) {
@@ -1053,7 +1062,7 @@ function flushLiveVfs(Fs, plugin) {
         if (s.ranged) s.ranged.flush();
         else {
           const bytes = s.data.slice(0, s.len);
-          node.mount.opts.bridge.writeFile(liveNodePath(node), bytes);
+          node.mount.opts.bridge.writeFile(liveNodePath(node), bytes, true);
         }
         s.dirty = false;
       } catch (err) {
@@ -1490,8 +1499,8 @@ function createSyncFsSabBridge(transport, opts = {}) {
   }
   return {
     readFile: (path) => bytes({ op: "read", path }, path),
-    writeFile: (path, data) => {
-      run({ op: "write", path, body: data }, path);
+    writeFile: (path, data, open) => {
+      run({ op: "write", path, body: data, ...open ? { mode: 1 } : {} }, path);
     },
     stat: (path) => {
       const s = parseSyncFsStat(json({ op: "stat", path }, path));
@@ -1558,8 +1567,8 @@ function createSyncFsSabBridge(transport, opts = {}) {
     lutimes: (path, atimeMs, mtimeMs) => {
       run({ op: "lutimes", path, atimeMs, mtimeMs }, path);
     },
-    hold: (path, held) => {
-      run({ op: "hold", path, mode: held ? 1 : 0 }, path);
+    hold: (path, held, open) => {
+      run({ op: "hold", path, mode: (held ? 1 : 0) | (open ? 2 : 0) }, path);
     },
     statfs: (path = "/") => parseSyncFsUsage(json({ op: "statfs", path }, path)),
     pread: (path, offset, length, version) => bytes({ op: "pread", path, offset, length, ...version ? { version } : {} }, path),
@@ -1790,8 +1799,8 @@ var init_kernel_streams = __esm({
         this.useTerminalNodes();
         const open = this.Fs.open.bind(this.Fs);
         this.Fs.open = (path, flags, mode) => {
-          const device = typeof path === "string" ? this.devicePath(path) : void 0;
-          if (device !== void 0 && TTY_PATH.test(device) && !this.terminalExists(device)) {
+          const device2 = typeof path === "string" ? this.devicePath(path) : void 0;
+          if (device2 !== void 0 && TTY_PATH.test(device2) && !this.terminalExists(device2)) {
             throw new this.Fs.ErrnoError(wasiErrno("ENOENT"));
           }
           const pty = this.openPty(open, path, flags, mode);
@@ -2709,15 +2718,15 @@ function describeInherited(Fs, sys, streams, livePath, actions = []) {
   return out;
 }
 function deviceOfStream(stream) {
-  const device = stream.path === void 0 ? void 0 : DEVICES[stream.path];
-  if (!device || stream.sliccKernelFd !== void 0) return void 0;
+  const device2 = stream.path === void 0 ? void 0 : DEVICES[stream.path];
+  if (!device2 || stream.sliccKernelFd !== void 0) return void 0;
   const access = ACCESS[stream.flags & O_ACCMODE2];
-  return { device, ...access ? { access } : {} };
+  return { device: device2, ...access ? { access } : {} };
 }
 function inheritedSlot(fd, stream) {
   if (stream.sliccKernelFd === void 0) {
-    const device = deviceOfStream(stream);
-    return device ? { fd, ...device } : void 0;
+    const device2 = deviceOfStream(stream);
+    return device2 ? { fd, ...device2 } : void 0;
   }
   const flags = stream.sliccKernelSocket ? { flags: stream.flags } : {};
   return { fd, kernel: stream.sliccKernelFd, ...flags };
@@ -2893,8 +2902,8 @@ function createProcessKernel(deps) {
     if (!stream) return { none: true };
     promote?.(stream);
     if (stream.sliccKernelFd !== void 0) return { fd: stream.sliccKernelFd };
-    const device = deviceOfStream(stream);
-    if (device) return device;
+    const device2 = deviceOfStream(stream);
+    if (device2) return device2;
     return n === 0 ? { input: drain(Fs, stream) } : { capture: true };
   };
   const kernelWait = (pid, nohang, options = 0) => {
@@ -3831,8 +3840,8 @@ function wireKernelStdio(Fs, streams, sys) {
     const stream = Fs.getStream(fd);
     if (!stream) continue;
     const kind = sys?.kind?.(fd);
-    const device = kind === "device" ? sys?.device?.(fd) : void 0;
-    if (device && openDevice(Fs, fd, device)) continue;
+    const device2 = kind === "device" ? sys?.device?.(fd) : void 0;
+    if (device2 && openDevice(Fs, fd, device2)) continue;
     if (kind && PLACED.has(kind)) {
       const { flags } = stream;
       Fs.closeStream(fd);
@@ -3901,8 +3910,8 @@ async function runWasmProcess(init, port2, deps = {}) {
     }
   };
   const sys = kernelSys(transport);
-  const encoder3 = new TextEncoder();
-  const say = (fd) => (text) => sys.write(fd, encoder3.encode(`${text}
+  const encoder4 = new TextEncoder();
+  const say = (fd) => (text) => sys.write(fd, encoder4.encode(`${text}
 `));
   let ready;
   let failed2;
@@ -4301,7 +4310,7 @@ function cachingBridge(bridge, now = () => performance.now()) {
         return false;
       }
     },
-    writeFile: (p, bytes) => mutating(() => bridge.writeFile(p, bytes)),
+    writeFile: (p, bytes, open) => mutating(() => bridge.writeFile(p, bytes, open)),
     mkdir: (p) => mutating(() => bridge.mkdir(p)),
     rm: (p) => mutating(() => bridge.rm(p)),
     rename: (from, to) => mutating(() => bridge.rename(from, to)),
@@ -4311,6 +4320,7 @@ function cachingBridge(bridge, now = () => performance.now()) {
     chmod: (p, mode) => mutating(() => bridge.chmod(p, mode)),
     utimes: (p, a, m) => mutating(() => bridge.utimes(p, a, m)),
     lutimes: (p, a, m) => mutating(() => bridge.lutimes(p, a, m)),
+    ...bridge.hold ? { hold: bridge.hold.bind(bridge) } : {},
     ...bridge.pread && bridge.pwrite && bridge.truncate ? {
       pread: bridge.pread.bind(bridge),
       pwrite: (p, at, bytes, transfer) => mutating(() => bridge.pwrite?.(p, at, bytes, transfer)),
@@ -4455,7 +4465,7 @@ var init_wasi_files = __esm({
         if (this.ranged) this.ranged.flush();
         else if (!this.data) return;
         else if (this.whole || !this.fs.pwrite)
-          this.fs.writeFile(this.path, this.data.slice(0, this.length));
+          this.fs.writeFile(this.path, this.data.slice(0, this.length), true);
         else this.fs.pwrite(this.path, this.from, this.data.slice(this.from, this.to), true);
         this.dirty = false;
         this.whole = false;
@@ -4606,14 +4616,14 @@ var init_wasi_fds = __esm({
         for (const fd of [0, 1, 2]) this.table.set(fd, kernelEntry2());
         const preopens = this.preopens(cwd, root);
         const top = 3 + preopens.length;
-        for (const { fd, kind, flags, device } of inherited) {
+        for (const { fd, kind, flags, device: device2 } of inherited) {
           let at = fd;
           if (fd < top) {
             at = this.kernel.call({ op: "fd-dup", fd, min: top });
             this.kernel.sys.close(fd);
           }
-          if (device) {
-            this.table.set(at, deviceEntry(device));
+          if (device2) {
+            this.table.set(at, deviceEntry(device2));
             continue;
           }
           const nonblock = ((flags ?? 0) & O_NONBLOCK2) !== 0;
@@ -4828,7 +4838,10 @@ var init_wasi_fds = __esm({
           this.table.set(fd, { type: "kernel", kind: "file", nonblock: false, append: e.file.append });
         }
         for (const file of promoted.keys()) {
-          if (--file.buffer.opens <= 0) this.buffers.delete(file.path);
+          if (--file.buffer.opens <= 0) {
+            this.buffers.delete(file.path);
+            this.letGo(file.buffer);
+          }
         }
       }
       snapshot() {
@@ -4896,9 +4909,12 @@ var init_wasi_fds = __esm({
         if (e.type !== "file" || --e.file.refs > 0) return;
         const { buffer } = e.file;
         buffer.flush();
-        if (--buffer.opens === 0 && this.buffers.get(buffer.path) === buffer) {
-          this.buffers.delete(buffer.path);
-        }
+        if (--buffer.opens > 0) return;
+        if (this.buffers.get(buffer.path) === buffer) this.buffers.delete(buffer.path);
+        this.letGo(buffer);
+      }
+      letGo(buffer) {
+        this.fs.hold?.(buffer.path, false, true);
       }
       kind(fd, e) {
         if (!e.kind) {
@@ -4955,8 +4971,8 @@ var init_wasi_fds = __esm({
         return resolveUnder(this.dir(dirfd).path, path);
       }
       open(path, oflags, rights, fdflags) {
-        const device = deviceOf(path);
-        if (device) return this.install({ type: "device", device });
+        const device2 = deviceOf(path);
+        if (device2) return this.install({ type: "device", device: device2 });
         if (path === "/dev/tty" || /^\/dev\/tty\d+$/.test(path)) {
           const fd = this.kernel.sys.openTty?.(path === "/dev/tty" ? void 0 : path);
           if (fd === void 0) throw new WasiError("ENXIO");
@@ -4989,6 +5005,7 @@ var init_wasi_fds = __esm({
           const ranged = st.ranged ? st.size : void 0;
           buffer = new FileBuffer(this.fs, path, empty, st.maxFile, ranged, st.version);
           this.buffers.set(path, buffer);
+          this.fs.hold?.(path, true, true);
         }
         buffer.opens++;
         return new LocalFile(buffer, readable, writable, (fdflags & FDFLAGS.APPEND) !== 0);
@@ -5095,11 +5112,11 @@ var init_wasi_memory = __esm({
         return at;
       }
       putStrings(list, ptrs, buf) {
-        const encoder3 = new TextEncoder();
+        const encoder4 = new TextEncoder();
         const v = this.view();
         let at = buf;
         list.forEach((s, i) => {
-          const b = encoder3.encode(s);
+          const b = encoder4.encode(s);
           v.setUint32(ptrs + i * 4, at, true);
           this.bytes(at, b.length).set(b);
           v.setUint8(at + b.length, 0);
@@ -5107,12 +5124,12 @@ var init_wasi_memory = __esm({
         });
       }
       putSizes(list, countPtr, sizePtr) {
-        const encoder3 = new TextEncoder();
+        const encoder4 = new TextEncoder();
         const v = this.view();
         v.setUint32(countPtr, list.length, true);
         v.setUint32(
           sizePtr,
-          list.reduce((n, s) => n + encoder3.encode(s).length + 1, 0),
+          list.reduce((n, s) => n + encoder4.encode(s).length + 1, 0),
           true
         );
       }
@@ -8254,6 +8271,320 @@ var init_js_kernel = __esm({
   }
 });
 
+// src/process/js/js-io.ts
+function typeOf(info) {
+  if (info.meta && "dir" in info.meta) return "directory";
+  if (info.meta && "device" in info.meta) return "device";
+  if (info.tty || info.kind === "tty") return "tty";
+  if (info.kind === "socket") return "socket";
+  return info.kind === "file" ? "file" : "pipe";
+}
+function device(info) {
+  return info.meta && "device" in info.meta ? info.meta : void 0;
+}
+function readDevice(info, max, random) {
+  if (typeOf(info) === "directory") throw new JsCallError("EISDIR", "read");
+  const dev = device(info);
+  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));
+  if (dev.device === "urandom") random(out);
+  return out;
+}
+function writeDevice(info) {
+  if (typeOf(info) === "directory") throw new JsCallError("EISDIR", "write");
+  const dev = device(info);
+  if (!dev) return false;
+  if (dev.access === "read") throw new JsCallError("EBADF", "write");
+  if (dev.device === "full") throw new JsCallError("ENOSPC", "write");
+  return true;
+}
+function brokenPipe(err, info) {
+  return err instanceof JsCallError && err.code === "EPIPE" && typeOf(info) !== "socket";
+}
+function written(r, fallback) {
+  return r.ok && r.kind === "json" && typeof r.json === "number" ? r.json : fallback;
+}
+function joined(parts, length) {
+  if (parts.length === 1) return parts[0];
+  const out = new Uint8Array(length);
+  let at = 0;
+  for (const part of parts) {
+    out.set(part, at);
+    at += part.length;
+  }
+  return out;
+}
+function fileWrite(fd, append, offset, body) {
+  return append ? { op: "fd-write", fd, body } : { op: "fd-pwrite", fd, offset, body };
+}
+function isExclusive(o) {
+  return o.create === true && o.exclusive === true;
+}
+function absent(err) {
+  if (err instanceof JsCallError && err.code === "ENOENT") return void 0;
+  throw err;
+}
+function checkOpen(abs, o, existing) {
+  if (existing && isExclusive(o)) throw new JsCallError("EEXIST", abs);
+  if (!existing && !o.create) throw new JsCallError("ENOENT", abs);
+  if (existing?.isDirectory) throw new JsCallError("EISDIR", abs);
+}
+function flagsOf(o) {
+  const write = o.write || o.append || o.truncate;
+  const access = write ? o.read ? O_RDWR6 : O_WRONLY6 : 0;
+  return access | (o.append ? O_APPEND3 : 0);
+}
+function openRequest(abs, o) {
+  return {
+    op: "fd-open-vfs",
+    path: abs,
+    flags: flagsOf(o),
+    position: 0,
+    ...isExclusive(o) ? { exclusive: true } : o.create ? { create: true } : { existing: true },
+    ...o.truncate ? { truncate: true } : {}
+  };
+}
+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 init_js_io = __esm({
+  "src/process/js/js-io.ts"() {
+    "use strict";
+    init_js_kernel();
+    CHUNK = 64 * 1024;
+    MAX_IO = 1024 * 1024;
+    O_WRONLY6 = 1;
+    O_RDWR6 = 2;
+    O_APPEND3 = 1024;
+  }
+});
+
+// src/process/js/js-sync.ts
+function laneOf(lane) {
+  if (!lane) return () => ({ ok: false, errno: "ENOSYS", message: "no sync lane" });
+  const transport = createSyncSabTransport(lane.sab, lane.port);
+  return (req) => transport.call(req, Number.POSITIVE_INFINITY, req.op);
+}
+function syncOps(kernel, shared) {
+  const { infos, handles, resolve } = shared;
+  const info = (fd) => {
+    const known = infos.get(fd);
+    if (known) return known;
+    const got = kernel.json({ op: "fd-info", fd });
+    infos.set(fd, got);
+    return got;
+  };
+  const read = (fd, max = CHUNK) => {
+    index(max, "read");
+    const emulated = readDevice(info(fd), max, shared.random);
+    if (emulated) return emulated;
+    const r = kernel.blocking({ op: "fd-read", fd, max: Math.min(max, MAX_IO) });
+    return r.ok && r.kind === "bytes" ? r.bytes : new Uint8Array(0);
+  };
+  const write = (fd, data) => {
+    const bytes = typeof data === "string" ? encoder2.encode(data) : data;
+    const i = info(fd);
+    if (writeDevice(i)) return;
+    let at = 0;
+    while (at < bytes.length) {
+      const body = bytes.subarray(at, at + MAX_IO);
+      try {
+        at += written(kernel.blocking({ op: "fd-write", fd, body }), body.length);
+      } catch (err) {
+        if (brokenPipe(err, i)) kernel.call({ op: "proc-kill", pid: shared.pid, sig: SIG.PIPE });
+        throw err;
+      }
+    }
+  };
+  const statOf = (op, path) => {
+    const abs = resolve(path);
+    kernel.call({ op: "fd-path-flush", path: abs });
+    const s = parseSyncFsStat(kernel.json({ op, path: abs }));
+    if (!s) throw new JsCallError("EIO", op);
+    return s;
+  };
+  const open = (path, options = {}) => {
+    const abs = resolve(path);
+    let existing;
+    try {
+      existing = statOf(isExclusive(options) ? "lstat" : "stat", abs);
+    } catch (err) {
+      existing = absent(err);
+    }
+    checkOpen(abs, options, existing);
+    const fd = kernel.json(openRequest(abs, options));
+    try {
+      kernel.call({ op: "fd-vfs-stat", fd });
+    } catch (err) {
+      kernel.raw({ op: "fd-close", fd });
+      throw err;
+    }
+    infos.set(fd, { kind: "file" });
+    const handle = syncFile(kernel, fd, abs, options.append === true, () => {
+      infos.delete(fd);
+      handles.delete(fd);
+    });
+    handles.set(fd, handle.invalidate);
+    return handle.file;
+  };
+  return {
+    read,
+    write,
+    close(fd) {
+      handles.get(fd)?.();
+      handles.delete(fd);
+      infos.delete(fd);
+      kernel.call({ op: "fd-close", fd });
+    },
+    open,
+    fs: syncPathOps(kernel, resolve, statOf, open)
+  };
+}
+function syncFile(kernel, fd, path, append, forget) {
+  let open = true;
+  const live = () => {
+    if (!open) throw new JsCallError("EBADF", path);
+  };
+  const file = {
+    fd,
+    path,
+    size() {
+      live();
+      return kernel.json({ op: "fd-vfs-stat", fd }).size;
+    },
+    read(position, length) {
+      index(position, "read");
+      index(length, "read");
+      const parts = [];
+      let got = 0;
+      do {
+        live();
+        const max = Math.min(length - got, MAX_IO);
+        if (max <= 0) break;
+        const chunk = kernel.bytes({ op: "fd-pread", fd, offset: position + got, max });
+        if (chunk.length === 0) break;
+        parts.push(chunk);
+        got += chunk.length;
+      } while (got < length);
+      return joined(parts, got);
+    },
+    write(position, data) {
+      index(position, "write");
+      let at = 0;
+      do {
+        live();
+        if (at >= data.length) break;
+        const body = data.subarray(at, at + MAX_IO);
+        const n = kernel.json(fileWrite(fd, append, position + at, body));
+        if (!(n > 0)) throw new JsCallError("EIO", "write");
+        at += n;
+      } while (at < data.length);
+      return at;
+    },
+    truncate(size) {
+      live();
+      index(size, "truncate");
+      kernel.call({ op: "fd-resize", fd, size });
+    },
+    sync() {
+      live();
+      kernel.call({ op: "fd-flush", fd });
+    },
+    close() {
+      live();
+      open = false;
+      forget();
+      kernel.call({ op: "fd-close", fd });
+    }
+  };
+  return {
+    file,
+    invalidate: () => {
+      open = false;
+    }
+  };
+}
+function syncPathOps(kernel, resolve, statOf, open) {
+  return {
+    stat: (path) => statOf("stat", path),
+    lstat: (path) => statOf("lstat", path),
+    exists: (path) => kernel.json({ op: "exists", path: resolve(path) }) === true,
+    readdir: (path) => kernel.json({ op: "readdir", path: resolve(path) }),
+    mkdir: (path) => void kernel.call({ op: "mkdir", path: resolve(path) }),
+    rm: (path) => void kernel.call({ op: "rm", path: resolve(path) }),
+    unlink: (path) => void kernel.call({ op: "unlink", path: resolve(path) }),
+    rename: (from, to) => void kernel.call({ op: "rename", path: resolve(from), arg2: resolve(to) }),
+    symlink: (target, path) => void kernel.call({ op: "symlink", path: resolve(path), arg2: target }),
+    readlink: (path) => String(kernel.json({ op: "readlink", path: resolve(path) })),
+    readFile(path) {
+      const abs = resolve(path);
+      kernel.call({ op: "fd-path-flush", path: abs });
+      return kernel.bytes({ op: "read", path: abs });
+    },
+    writeFile(path, data) {
+      const file = open(path, { write: true, create: true, truncate: true });
+      try {
+        file.write(0, typeof data === "string" ? encoder2.encode(data) : data);
+      } finally {
+        file.close();
+      }
+    }
+  };
+}
+var encoder2, JsSyncKernel;
+var init_js_sync = __esm({
+  "src/process/js/js-sync.ts"() {
+    "use strict";
+    init_signals();
+    init_sync_fs_wire();
+    init_sync_sab_bridge();
+    init_js_io();
+    init_js_kernel();
+    encoder2 = new TextEncoder();
+    JsSyncKernel = class {
+      lane;
+      kernel;
+      unwind;
+      constructor(lane, kernel, unwind = () => {
+      }) {
+        this.lane = lane;
+        this.kernel = kernel;
+        this.unwind = unwind;
+      }
+      raw(req) {
+        this.unwind();
+        const result = this.lane(req);
+        this.kernel.deliver();
+        this.unwind();
+        return result;
+      }
+      call(req) {
+        const result = this.raw(req);
+        if (!result.ok) throw new JsCallError(result.errno, req.op);
+        return result;
+      }
+      json(req) {
+        const result = this.call(req);
+        return result.ok && result.kind === "json" ? result.json : void 0;
+      }
+      bytes(req) {
+        const result = this.call(req);
+        return result.ok && result.kind === "bytes" ? result.bytes : new Uint8Array(0);
+      }
+      blocking(req) {
+        for (; ; ) {
+          const result = this.raw(req);
+          if (result.ok) return result;
+          if (result.errno !== "EINTR") throw new JsCallError(result.errno, req.op);
+        }
+      }
+    };
+  }
+});
+
 // src/process/js/js-context.ts
 function identityOf(answer2, fallback) {
   const id = answer2;
@@ -8280,18 +8611,6 @@ function resolvePath(cwd, path) {
   }
   return `/${parts.join("/")}`;
 }
-function typeOf(info) {
-  if (info.meta && "dir" in info.meta) return "directory";
-  if (info.meta && "device" in info.meta) return "device";
-  if (info.tty || info.kind === "tty") return "tty";
-  if (info.kind === "socket") return "socket";
-  return info.kind === "file" ? "file" : "pipe";
-}
-function flagsOf(o) {
-  const write = o.write || o.append || o.truncate;
-  const access = write ? o.read ? O_RDWR6 : O_WRONLY6 : 0;
-  return access | (o.append ? O_APPEND3 : 0);
-}
 function createContext(o) {
   const { kernel } = o;
   const infos = /* @__PURE__ */ new Map();
@@ -8299,10 +8618,15 @@ function createContext(o) {
   const pending = /* @__PURE__ */ new Set();
   const random = o.random ?? ((bytes) => void crypto.getRandomValues(bytes));
   const resolve = (path) => resolvePath(o.cwd, path);
+  let exiting;
   const exit = (code2 = 0) => {
+    exiting ??= code2;
     o.exit(code2);
     throw new JsExit(code2);
   };
+  const unwind = () => {
+    if (exiting !== void 0) throw new JsExit(exiting);
+  };
   const info = async (fd) => {
     const known = infos.get(fd);
     if (known) return known;
@@ -8310,48 +8634,30 @@ function createContext(o) {
     infos.set(fd, got);
     return got;
   };
-  const device = (i) => i.meta && "device" in i.meta ? i.meta : void 0;
   const read = async (fd, max = CHUNK) => {
     index(max, "read");
-    const i = await info(fd);
-    if (typeOf(i) === "directory") throw new JsCallError("EISDIR", "read");
-    const dev = device(i);
-    if (dev) {
-      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));
-      if (dev.device === "urandom") random(out);
-      return out;
-    }
+    const emulated = readDevice(await info(fd), max, random);
+    if (emulated) return emulated;
     const r = await kernel.blocking({ op: "fd-read", fd, max: Math.min(max, MAX_IO) });
     return r.ok && r.kind === "bytes" ? r.bytes : new Uint8Array(0);
   };
   const writeAll = async (fd, data) => {
     const i = await info(fd);
-    if (typeOf(i) === "directory") throw new JsCallError("EISDIR", "write");
-    const dev = device(i);
-    if (dev) {
-      if (dev.access === "read") throw new JsCallError("EBADF", "write");
-      if (dev.device === "full") throw new JsCallError("ENOSPC", "write");
-      return;
-    }
+    if (writeDevice(i)) return;
     let at = 0;
     while (at < data.length) {
       const body = data.subarray(at, at + MAX_IO);
       try {
         const r = await kernel.blocking({ op: "fd-write", fd, body });
-        at += r.ok && r.kind === "json" && typeof r.json === "number" ? r.json : body.length;
+        at += written(r, body.length);
       } catch (err) {
-        const broken = err instanceof JsCallError && err.code === "EPIPE";
-        if (broken && typeOf(i) !== "socket") {
-          await kernel.call({ op: "proc-kill", pid: o.pid, sig: SIG.PIPE });
-        }
+        if (brokenPipe(err, i)) await kernel.call({ op: "proc-kill", pid: o.pid, sig: SIG.PIPE });
         throw err;
       }
     }
   };
   const write = (fd, data) => {
-    const bytes = typeof data === "string" ? encoder2.encode(data) : data;
+    const bytes = typeof data === "string" ? encoder3.encode(data) : data;
     let settle;
     const settled = new Promise((resolve2) => settle = resolve2);
     pending.add(settled);
@@ -8374,22 +8680,9 @@ function createContext(o) {
   };
   const open = async (path, options = {}) => {
     const abs = resolve(path);
-    const exclusive = options.create === true && options.exclusive === true;
-    const existing = await statOf(exclusive ? "lstat" : "stat", abs).catch((err) => {
-      if (err instanceof JsCallError && err.code === "ENOENT") return void 0;
-      throw err;
-    });
-    if (existing && exclusive) throw new JsCallError("EEXIST", abs);
-    if (!existing && !options.create) throw new JsCallError("ENOENT", abs);
-    if (existing?.isDirectory) throw new JsCallError("EISDIR", abs);
-    const fd = await kernel.json({
-      op: "fd-open-vfs",
-      path: abs,
-      flags: flagsOf(options),
-      position: 0,
-      ...exclusive ? { exclusive: true } : options.create ? { create: true } : { existing: true },
-      ...options.truncate ? { truncate: true } : {}
-    });
+    const existing = await statOf(isExclusive(options) ? "lstat" : "stat", abs).catch(absent);
+    checkOpen(abs, options, existing);
+    const fd = await kernel.json(openRequest(abs, options));
     try {
       await kernel.call({ op: "fd-vfs-stat", fd });
     } catch (err) {
@@ -8405,6 +8698,13 @@ function createContext(o) {
     return handle.file;
   };
   const fs = pathOps(kernel, resolve, statOf, open);
+  const sync = syncOps(new JsSyncKernel(o.lane ?? laneOf(void 0), kernel, unwind), {
+    pid: o.pid,
+    resolve,
+    random,
+    infos,
+    handles
+  });
   const ctx = {
     argv: o.argv,
     env: o.env,
@@ -8446,6 +8746,7 @@ function createContext(o) {
       ignore: async (signal) => kernel.setHandler(signalNumber(signal), "ignore"),
       reset: async (signal) => kernel.setHandler(signalNumber(signal), "default")
     },
+    sync,
     exit
   };
   const drain2 = async () => {
@@ -8484,14 +8785,7 @@ function fileHandle(kernel, fd, path, append, forget) {
         parts.push(chunk);
         got += chunk.length;
       } while (got < length);
-      if (parts.length === 1) return parts[0];
-      const out = new Uint8Array(got);
-      let at = 0;
-      for (const part of parts) {
-        out.set(part, at);
-        at += part.length;
-      }
-      return out;
+      return joined(parts, got);
     },
     async write(position, data) {
       index(position, "write");
@@ -8500,9 +8794,7 @@ function fileHandle(kernel, fd, path, append, forget) {
         live();
         if (at >= data.length) break;
         const body = data.subarray(at, at + MAX_IO);
-        const n = await kernel.json(
-          append ? { op: "fd-write", fd, body } : { op: "fd-pwrite", fd, offset: position + at, body }
-        );
+        const n = await kernel.json(fileWrite(fd, append, position + at, body));
         if (!(n > 0)) throw new JsCallError("EIO", "write");
         at += n;
       } while (at < data.length);
@@ -8531,9 +8823,6 @@ function fileHandle(kernel, fd, path, append, forget) {
     }
   };
 }
-function index(n, what) {
-  if (!Number.isSafeInteger(n) || n < 0) throw new JsCallError("EINVAL", what);
-}
 function pathOps(kernel, resolve, statOf, open) {
   return {
     stat: (path) => statOf("stat", path),
@@ -8554,20 +8843,22 @@ function pathOps(kernel, resolve, statOf, open) {
     async writeFile(path, data) {
       const file = await open(path, { write: true, create: true, truncate: true });
       try {
-        await file.write(0, typeof data === "string" ? encoder2.encode(data) : data);
+        await file.write(0, typeof data === "string" ? encoder3.encode(data) : data);
       } finally {
         await file.close();
       }
     }
   };
 }
-var JsExit, CHUNK, MAX_IO, O_WRONLY6, O_RDWR6, O_APPEND3, encoder2;
+var JsExit, encoder3;
 var init_js_context = __esm({
   "src/process/js/js-context.ts"() {
     "use strict";
     init_signals();
     init_sync_fs_wire();
+    init_js_io();
     init_js_kernel();
+    init_js_sync();
     JsExit = class extends Error {
       status;
       constructor(status2) {
@@ -8576,12 +8867,7 @@ var init_js_context = __esm({
         this.status = status2;
       }
     };
-    CHUNK = 64 * 1024;
-    MAX_IO = 1024 * 1024;
-    O_WRONLY6 = 1;
-    O_RDWR6 = 2;
-    O_APPEND3 = 1024;
-    encoder2 = new TextEncoder();
+    encoder3 = new TextEncoder();
   }
 });
 
@@ -8709,7 +8995,8 @@ async function runJsProcess(init, port2, deps = {}) {
     pid: id.pid,
     ppid: id.ppid,
     cwd: init.cwd,
-    exit: (status3) => exited(statusOf(status3))
+    exit: (status3) => exited(statusOf(status3)),
+    lane: laneOf(init.lane)
   });
   const say = (text) => ctx.write(2, `${init.argv0}: ${text}
 `).catch(() => void 0);
@@ -8747,6 +9034,7 @@ var init_js_runtime = __esm({
     init_async_sab();
     init_js_context();
     init_js_kernel();
+    init_js_sync();
     init_lockdown();
     NOT_RUNNABLE = 126;
   }