@ai-ecoverse/slicc-kernel 1.37.1 → 1.39.1

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() {
@@ -1799,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);
@@ -2718,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 };
@@ -2902,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) => {
@@ -3840,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);
@@ -3910,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;
@@ -4616,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;
@@ -4971,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");
@@ -5112,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);
@@ -5124,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
         );
       }
@@ -8165,6 +8165,7 @@ var init_js_kernel = __esm({
       pid = 0;
       reported = { caught: 0, ignored: 0 };
       watching = false;
+      faulted = false;
       constructor(o) {
         this.header = new Int32Array(o.sab, 0, SAB_HEADER_I32);
         this.transport = o.transport;
@@ -8214,12 +8215,16 @@ var init_js_kernel = __esm({
             continue;
           }
           try {
-            Promise.resolve(handler(sig)).catch(this.onError);
+            Promise.resolve(handler(sig)).catch((err) => this.fault(err));
           } catch (err) {
-            this.onError(err);
+            this.fault(err);
           }
         }
       }
+      fault(err) {
+        this.faulted = true;
+        this.onError(err);
+      }
       async watch() {
         if (this.watching) return;
         this.watching = true;
@@ -8271,6 +8276,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;
@@ -8297,18 +8616,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();
@@ -8316,10 +8623,16 @@ 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);
+    if (kernel.faulted) throw new JsExit(1);
+  };
   const info = async (fd) => {
     const known = infos.get(fd);
     if (known) return known;
@@ -8327,48 +8640,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);
@@ -8391,22 +8686,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) {
@@ -8422,6 +8704,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,
@@ -8463,6 +8752,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 () => {
@@ -8501,14 +8791,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");
@@ -8517,9 +8800,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);
@@ -8548,9 +8829,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),
@@ -8571,20 +8849,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) {
@@ -8593,12 +8873,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();
   }
 });
 
@@ -8726,7 +9001,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);
@@ -8764,6 +9040,7 @@ var init_js_runtime = __esm({
     init_async_sab();
     init_js_context();
     init_js_kernel();
+    init_js_sync();
     init_lockdown();
     NOT_RUNNABLE = 126;
   }