@ai-ecoverse/slicc-kernel 1.124.13 → 1.125.1

package/dist/process-worker.js

@@ -973,7 +973,7 @@ function parseSyncFsStat(json2) {
     ...typeof s.gid === "number" ? { gid: s.gid } : {}
   };
 }
-var SYNC_FS_OPS, HOLD_READ, HOLD_WRITE, HOLD_CREATED, SYNC_FS_REQUEST_TIMEOUT_MS;
+var SYNC_FS_OPS, HOLD_READ, HOLD_WRITE, HOLD_CREATED, SYNC_FS_REQUEST_TIMEOUT_MS, SYNC_FS_READ_ONLY;
 var init_sync_fs_wire = __esm({
   "src/realm/sync-fs-wire.ts"() {
     "use strict";
@@ -1013,6 +1013,19 @@ var init_sync_fs_wire = __esm({
     HOLD_WRITE = 8;
     HOLD_CREATED = 16;
     SYNC_FS_REQUEST_TIMEOUT_MS = 25e3;
+    SYNC_FS_READ_ONLY = /* @__PURE__ */ new Set([
+      "read",
+      "pread",
+      "exists",
+      "stat",
+      "lstat",
+      "readdir",
+      "readdir-stat",
+      "readlink",
+      "statfs",
+      "kept",
+      "access"
+    ]);
   }
 });
 
@@ -1177,7 +1190,7 @@ function createSyncFsSabBridge(transport, opts = {}) {
   let last = null;
   function run(req, path, transfer) {
     last = null;
-    const silence = READ_ONLY.has(req.op) ? timeoutMs2 : Number.POSITIVE_INFINITY;
+    const silence = SYNC_FS_READ_ONLY.has(req.op) ? timeoutMs2 : Number.POSITIVE_INFINITY;
     const result = transport.call(req, silence, `sync-sab bridge, '${path}'`, transfer);
     if (!result.ok) throw errnoError(result.errno, path);
     return result;
@@ -1266,8 +1279,8 @@ function createSyncFsSabBridge(transport, opts = {}) {
     rename: (from, to) => {
       run({ op: "rename", path: from, arg2: to }, from);
     },
-    link: (from, to, follow2) => {
-      run({ op: "link", path: from, arg2: to, ...follow2 ? { mode: 1 } : {} }, from);
+    link: (from, to, follow3) => {
+      run({ op: "link", path: from, arg2: to, ...follow3 ? { mode: 1 } : {} }, from);
     },
     unlink: (path) => {
       run({ op: "unlink", path }, path);
@@ -1310,11 +1323,11 @@ function createSyncFsSabBridge(transport, opts = {}) {
       const flags = { ...mode !== void 0 ? { mode } : {}, ...opening2 ? { opening: opening2 } : {} };
       run({ op: "create", path, ...flags }, path);
     },
-    chown: (path, uid, gid, follow2, handle) => {
+    chown: (path, uid, gid, follow3, handle) => {
       const ids = { ...uid !== void 0 ? { uid } : {}, ...gid !== void 0 ? { gid } : {} };
       changing(
         {
-          op: follow2 ? "chown" : "lchown",
+          op: follow3 ? "chown" : "lchown",
           path,
           ...ids,
           ...handle !== void 0 ? { handle } : {}
@@ -1340,7 +1353,7 @@ function createSyncFsSabBridge(transport, opts = {}) {
     statfs: (path = "/") => parseSyncFsUsage(json2({ op: "statfs", path }, path))
   };
 }
-var PATH_OPS, READ_ONLY, calls, looks, SPIN_MS, SPIN_STRIDE, SPIN_STRIDES, SPIN_CORES, spinning, SPIN_CAP_MS;
+var PATH_OPS, calls, looks, SPIN_MS, SPIN_STRIDE, SPIN_STRIDES, SPIN_CORES, spinning, SPIN_CAP_MS;
 var init_sync_sab_bridge = __esm({
   "src/realm/sync-sab-bridge.ts"() {
     "use strict";
@@ -1349,19 +1362,6 @@ var init_sync_sab_bridge = __esm({
     init_sync_fs_wire();
     init_sync_sab_wire();
     PATH_OPS = new Set(SYNC_FS_OPS);
-    READ_ONLY = /* @__PURE__ */ new Set([
-      "read",
-      "pread",
-      "exists",
-      "stat",
-      "lstat",
-      "readdir",
-      "readdir-stat",
-      "readlink",
-      "statfs",
-      "kept",
-      "access"
-    ]);
     calls = 0;
     looks = 0;
     SPIN_MS = 0.06;
@@ -2345,9 +2345,9 @@ function guardVanished(Fs) {
   const drop = forget;
   const lookupPath = Fs.lookupPath.bind(Fs);
   const ops = Fs;
-  const cached = (path, follow2) => {
+  const cached = (path, follow3) => {
     try {
-      const node = lookupPath(path, { follow: follow2 }).node;
+      const node = lookupPath(path, { follow: follow3 }).node;
       return node.live && node.live.openCount === 0 && !node.live.dirty ? node : void 0;
     } catch {
       return void 0;
@@ -2454,11 +2454,11 @@ function linkable(bridge, path) {
     return false;
   }
 }
-function linkLive(Fs, from, to, follow2) {
+function linkLive(Fs, from, to, follow3) {
   const target = to.replace(/\/+$/, "");
   const slash = target.lastIndexOf("/");
   const name2 = target.slice(slash + 1);
-  const source = Fs.lookupPath(from, { follow: follow2 }).node;
+  const source = Fs.lookupPath(from, { follow: follow3 }).node;
   const parent = Fs.lookupPath(target.slice(0, slash) || "/", { follow: true }).node;
   if (!source.live || !parent.live) return false;
   flushOne(Fs, source);
@@ -2647,7 +2647,7 @@ var KERNEL_VERSION, OS_RELEASE;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    KERNEL_VERSION = true ? "1.124.13" : "0.0.0-dev";
+    KERNEL_VERSION = true ? "1.125.1" : "0.0.0-dev";
     OS_RELEASE = "6.0.0-slicc";
   }
 });
@@ -3482,13 +3482,13 @@ function readonlyRefusal(Fs, memory, call2) {
   try {
     const name2 = cString(memory, call2.path);
     const abs = name2.startsWith("/") ? name2 : `${baseOf2(Fs, call2.dirfd)}/${name2}`;
-    const follow2 = (call2.flags & AT_SYMLINK_NOFOLLOW) === 0;
+    const follow3 = (call2.flags & AT_SYMLINK_NOFOLLOW) === 0;
     const { node } = Fs.lookupPath.call(Fs, abs, {
-      follow: follow2
+      follow: follow3
     });
     const bridge = node.live ? node.mount.opts.bridge : void 0;
     const stats = bridge;
-    const stat = follow2 ? stats?.stat : stats?.lstat;
+    const stat = follow3 ? stats?.stat : stats?.lstat;
     return stat?.call(stats, liveNodePath(node)).readonly ? -wasiErrno("EROFS") : 0;
   } catch {
     return 0;
@@ -3537,8 +3537,8 @@ function kernelLink(imports, fs, memory, glue) {
       try {
         const from = at(olddirfd, oldpath);
         const to = at(newdirfd, newpath);
-        const follow2 = (flags & AT_SYMLINK_FOLLOW) !== 0;
-        if (linkLive(Fs, from, to, follow2)) return 0;
+        const follow3 = (flags & AT_SYMLINK_FOLLOW) !== 0;
+        if (linkLive(Fs, from, to, follow3)) return 0;
       } catch (err) {
         return -errnoOf2(err);
       }
@@ -3761,9 +3761,9 @@ function useKernelFdMetadata(Fs, sys, call2) {
     }
     return void 0;
   };
-  const ofPath = (path, follow2) => {
+  const ofPath = (path, follow3) => {
     if (typeof path !== "string") return find((s) => s.node === path);
-    const fd = follow2 ? fdOfPath(path, Fs.cwd()) : void 0;
+    const fd = follow3 ? fdOfPath(path, Fs.cwd()) : void 0;
     if (fd !== void 0) return kernelFd(Fs.getStream(fd));
     return find((s) => s.path === path);
   };
@@ -6747,7 +6747,7 @@ function cachingBridge(bridge, now = () => performance.now(), shared) {
     mkdir: (p) => mutating(() => bridge.mkdir(p), ...entry(p)),
     rm: (p) => mutating(() => bridge.rm(p)),
     rename: (from, to) => mutating(() => bridge.rename(from, to)),
-    link: (from, to, follow2) => mutating(() => bridge.link(from, to, follow2)),
+    link: (from, to, follow3) => mutating(() => bridge.link(from, to, follow3)),
     unlink: (p) => mutating(() => bridge.unlink(p)),
     rmdir: (p) => mutating(() => bridge.rmdir(p)),
     symlink: (target, link) => mutating(() => bridge.symlink(target, link), ...entry(link)),
@@ -7693,7 +7693,7 @@ function devFdStat(fd) {
 function linkStat(target) {
   return nodeStat(LINK | 511, target.length);
 }
-function* devStat(abs, follow2) {
+function* devStat(abs, follow3) {
   const node = yield* lookup(abs);
   switch (node.kind) {
     case "dir":
@@ -7706,10 +7706,10 @@ function* devStat(abs, follow2) {
     case "terminal":
       return yield* terminalStat(node.name);
     case "link":
-      if (!follow2) return linkStat(node.target);
+      if (!follow3) return linkStat(node.target);
       return node.fd === void 0 ? nodeStat(DIR | 365) : yield* fdStat(node.fd, abs);
     case "fd":
-      return follow2 ? yield* fdStat(node.fd, abs) : linkStat(yield* fdTarget(node.fd, abs));
+      return follow3 ? yield* fdStat(node.fd, abs) : linkStat(yield* fdTarget(node.fd, abs));
   }
 }
 function* devExists(abs) {
@@ -9170,7 +9170,7 @@ function writeEvents(mem, ptr, events) {
     v.setUint16(p + 8, ev.error, true);
     v.setUint8(p + 10, ev.type);
     if (ev.type !== EVENTTYPE.CLOCK) {
-      v.setBigUint64(p + 16, 1n, true);
+      v.setBigUint64(p + 16, BigInt(ev.nbytes ?? 1), true);
       if (ev.hangup) v.setUint16(p + 24, EVENT_FD_READWRITE_HANGUP, true);
     }
   });
@@ -9189,6 +9189,10 @@ function classify(fds, subs) {
   }
   return { events, read: read2, write: write2 };
 }
+function nbytesOf(s, ready) {
+  const n = s.type === EVENTTYPE.FD_READ ? ready.nread?.[s.fd] : void 0;
+  return n === void 0 ? {} : { nbytes: n };
+}
 function readyEvents(subs, ready) {
   return subs.filter(
     (s) => s.type === EVENTTYPE.FD_READ && ready.read.includes(s.fd) || s.type === EVENTTYPE.FD_WRITE && ready.write.includes(s.fd)
@@ -9196,7 +9200,8 @@ function readyEvents(subs, ready) {
     userdata: s.userdata,
     error: E.SUCCESS,
     type: s.type,
-    hangup: ready.hangup?.includes(s.fd) === true
+    hangup: ready.hangup?.includes(s.fd) === true,
+    ...nbytesOf(s, ready)
   }));
 }
 function selectOnce(deps, read2, write2, timeoutMs2) {
@@ -10117,10 +10122,10 @@ var init_wasi_host = __esm({
           return path;
         };
         const modeOf2 = (st) => (st.mode ?? 0) & 4095;
-        const chown = (path, uid, gid, follow2, handle) => {
+        const chown = (path, uid, gid, follow3, handle) => {
           const { chown: own } = this.o.fs;
           if (!own) throw new WasiError("ENOSYS");
-          own.call(this.o.fs, path, idOf3(uid), idOf3(gid), follow2, handle);
+          own.call(this.o.fs, path, idOf3(uid), idOf3(gid), follow3, handle);
         };
         const caller = () => {
           const cred = this.creds.get();
@@ -10160,16 +10165,16 @@ var init_wasi_host = __esm({
             return devSync(dev, devFdStat(fd)).mode ?? DEVICE_MODE;
           return modeOf2(this.o.fs.stat(pathOf(fd)));
         };
-        const pathOwned = (path, follow2) => {
+        const pathOwned = (path, follow3) => {
           const alias = this.fdAlias(path);
-          if (alias && !follow2) return alias.stdio ? ROOT_IDS : void 0;
+          if (alias && !follow3) return alias.stdio ? ROOT_IDS : void 0;
           if (alias) {
             this.openFd(alias.fd);
             return fdOwned(alias.fd);
           }
           if (this.synthetic(path)) return ROOT_IDS;
-          if (kernelDev(path)) return devSync(dev, devStat(path, follow2));
-          return follow2 ? this.o.fs.stat(path) : this.o.fs.lstat(path);
+          if (kernelDev(path)) return devSync(dev, devStat(path, follow3));
+          return follow3 ? this.o.fs.stat(path) : this.o.fs.lstat(path);
         };
         return wrap({
           fd_chown: (fd, uid, gid) => {
@@ -10565,7 +10570,7 @@ var init_wasi_host = __esm({
         const at = (dirfd, p, l) => fds.resolve(dirfd, mem.string(p, l));
         return {
           path_open: (dirfd, lookup2, p, l, oflags, rights, _inheriting, fdflags, out) => {
-            const follow2 = (lookup2 & LOOKUP_SYMLINK_FOLLOW) !== 0;
+            const follow3 = (lookup2 & LOOKUP_SYMLINK_FOLLOW) !== 0;
             try {
               const asked = at(dirfd, p, l);
               const alias = this.fdAlias(asked);
@@ -10579,7 +10584,7 @@ var init_wasi_host = __esm({
               if (err.code !== "ENOENT") throw err;
               const raw = mem.string(p, l);
               const joined2 = raw.startsWith("/") ? raw : `${fds.dir(dirfd).path}/${raw}`;
-              const resolved2 = this.resolveForDev(joined2, follow2);
+              const resolved2 = this.resolveForDev(joined2, follow3);
               if (!resolved2) throw err;
               mem.view().setUint32(out, fds.open(resolved2, oflags, rights, fdflags), true);
             }
@@ -10642,11 +10647,11 @@ var init_wasi_host = __esm({
           path_link: (fd, lookup2, p, l, fd2, p2, l2) => {
             const from = at(fd, p, l);
             const to = at(fd2, p2, l2);
-            const follow2 = (lookup2 & LOOKUP_SYMLINK_FOLLOW) !== 0;
-            const source = follow2 ? physicalPath(o.fs, from) : from;
+            const follow3 = (lookup2 & LOOKUP_SYMLINK_FOLLOW) !== 0;
+            const source = follow3 ? physicalPath(o.fs, from) : from;
             fds.flushPath(from);
             if (source !== from) fds.flushPath(source);
-            o.fs.link(from, to, follow2);
+            o.fs.link(from, to, follow3);
             fds.linked(from, to);
             if (source !== from) fds.linked(source, to);
           }
@@ -10959,18 +10964,18 @@ var init_wasi_host = __esm({
       synthetic(path) {
         return deviceOf(path) !== void 0 || path === SEALED_PATH2 && !!this.o.kernel.sys.openSealed || path === CLIPBOARD_PATH2 && !!this.o.kernel.sys.openClipboard;
       }
-      devChar(path, follow2) {
+      devChar(path, follow3) {
         try {
           const json2 = (req) => this.o.kernel.call(req);
-          const st = devSync({ json: json2 }, devStat(path, follow2));
+          const st = devSync({ json: json2 }, devStat(path, follow3));
           return ((st.mode ?? 0) & 61440) === 8192;
         } catch {
           return false;
         }
       }
-      resolveForDev(path, follow2 = true) {
+      resolveForDev(path, follow3 = true) {
         try {
-          if (!follow2) {
+          if (!follow3) {
             const slash = path.lastIndexOf("/");
             if (slash <= 0) return void 0;
             const parent = physicalPath(this.o.fs, path.slice(0, slash));
@@ -11061,12 +11066,12 @@ var init_wasi_host = __esm({
           });
         }
         this.fds.flushPath(path);
-        const follow2 = (lookup2 & LOOKUP_SYMLINK_FOLLOW) !== 0;
+        const follow3 = (lookup2 & LOOKUP_SYMLINK_FOLLOW) !== 0;
         try {
-          return filestatOf(path, follow2 ? this.o.fs.stat(path) : this.o.fs.lstat(path));
+          return filestatOf(path, follow3 ? this.o.fs.stat(path) : this.o.fs.lstat(path));
         } catch (err) {
           if (err.code !== "ENOENT") throw err;
-          if (kernelDev(path) && this.devChar(path, follow2)) {
+          if (kernelDev(path) && this.devChar(path, follow3)) {
             return this.local({
               filetype: FILETYPE.CHARACTER_DEVICE,
               size: 0n,
@@ -11074,7 +11079,7 @@ var init_wasi_host = __esm({
               mtimeNs: 0n
             });
           }
-          const resolved2 = this.resolveForDev(path, follow2);
+          const resolved2 = this.resolveForDev(path, follow3);
           if (!resolved2) throw err;
           return this.local({
             filetype: FILETYPE.CHARACTER_DEVICE,
@@ -11084,18 +11089,18 @@ var init_wasi_host = __esm({
           });
         }
       }
-      setTimes(path, atim, mtim, flags, follow2 = true) {
+      setTimes(path, atim, mtim, flags, follow3 = true) {
         const asked = FSTFLAGS.ATIM | FSTFLAGS.ATIM_NOW | FSTFLAGS.MTIM | FSTFLAGS.MTIM_NOW;
         if (this.o.fs.owners && (flags & asked) === 0) return;
         const now = Date.now();
         let current;
-        const statOf = follow2 ? this.o.fs.stat.bind(this.o.fs) : this.o.fs.lstat.bind(this.o.fs);
+        const statOf = follow3 ? this.o.fs.stat.bind(this.o.fs) : this.o.fs.lstat.bind(this.o.fs);
         const kept = (field2) => {
           current ??= statOf(path);
           return current[field2] ?? current.mtimeMs ?? now;
         };
         const pick = (set, setNow, value2, field2) => flags & setNow ? now : flags & set ? Number(value2 / NS_PER_MS4) : kept(field2);
-        (follow2 ? this.o.fs.utimes : this.o.fs.lutimes).call(
+        (follow3 ? this.o.fs.utimes : this.o.fs.lutimes).call(
           this.o.fs,
           path,
           pick(FSTFLAGS.ATIM, FSTFLAGS.ATIM_NOW, atim, "atimeMs"),
@@ -11728,7 +11733,7 @@ var init_wasi_module = __esm({
 function inProc(path) {
   return path === "/proc" || path.startsWith("/proc/");
 }
-function* procWalk(path, follow2) {
+function* procWalk(path, follow3) {
   let done = [];
   let todo = path.split("/").filter((part) => part !== "");
   let hops = 0;
@@ -11743,7 +11748,7 @@ function* procWalk(path, follow2) {
     const at = `/${[...done, part].join("/")}`;
     const whole = normalize(`/${[...done, part, ...todo].join("/")}`);
     if (inProc(at) && inProc(whole)) return broken ?? whole;
-    if (!follow2 && todo.length === 0) return void 0;
+    if (!follow3 && todo.length === 0) return void 0;
     const target = yield { at, check: todo.find((next2) => next2 !== ".") === ".." };
     if (typeof target === "string") {
       if (++hops > MAX_HOPS2) return void 0;
@@ -11767,8 +11772,8 @@ function throughLink(target, done, todo) {
   const parts = target.split("/").filter((part) => part !== "");
   return [target.startsWith("/") ? [] : done, [...parts, ...todo]];
 }
-function procPath(fs, path, follow2) {
-  const walk = procWalk(path, follow2);
+function procPath(fs, path, follow3) {
+  const walk = procWalk(path, follow3);
   let step = walk.next();
   while (!step.done) {
     const { at, check } = step.value;
@@ -11826,26 +11831,26 @@ function physicalProc(fs) {
   };
 }
 function procfsBridge(fs, tree) {
-  const toProc = (path, follow2) => procPath(fs, path, follow2);
+  const toProc = (path, follow3) => procPath(fs, path, follow3);
   const shadowing = physicalProc(fs);
-  const via = (p, proc, own, follow2 = true) => {
+  const via = (p, proc, own, follow3 = true) => {
     if (inProc(p)) return proc(p);
     if (shadowing()) {
-      const real = toProc(p, follow2);
+      const real = toProc(p, follow3);
       if (real !== void 0) return proc(real);
     }
     try {
       return own();
     } catch (err) {
-      const real = toProc(p, follow2);
+      const real = toProc(p, follow3);
       if (real === void 0) throw err;
       return proc(real);
     }
   };
   const readOnly2 = (paths, run) => {
     const physical2 = shadowing();
-    for (const [p, follow2] of paths) {
-      if (inProc(p) || physical2 && toProc(p, follow2) !== void 0) throw syncError("EROFS", p);
+    for (const [p, follow3] of paths) {
+      if (inProc(p) || physical2 && toProc(p, follow3) !== void 0) throw syncError("EROFS", p);
     }
     return run();
   };
@@ -11930,12 +11935,12 @@ function procfsBridge(fs, tree) {
       () => fs.rename(from, to)
     ),
     symlink: (target, link) => readOnly2([[link, false]], () => fs.symlink(target, link)),
-    link: (from, to, follow2) => readOnly2(
+    link: (from, to, follow3) => readOnly2(
       [
-        [from, follow2 === true],
+        [from, follow3 === true],
         [to, false]
       ],
-      () => fs.link(from, to, follow2)
+      () => fs.link(from, to, follow3)
     ),
     hold: (p, held2, open, handle, want, seen) => {
       if (handle !== void 0 && snapshots.delete(handle)) return void 0;
@@ -11955,14 +11960,14 @@ function procfsBridge(fs, tree) {
       )
     } : {}
   };
-  for (const [names, follow2] of [
+  for (const [names, follow3] of [
     [FOLLOWING, true],
     [NOT_FOLLOWING, false]
   ]) {
     for (const name2 of names) {
       const fn = fs[name2];
       if (!fn) continue;
-      over[name2] = (p, ...rest2) => readOnly2([[p, follow2]], () => fn.call(fs, p, ...rest2));
+      over[name2] = (p, ...rest2) => readOnly2([[p, follow3]], () => fn.call(fs, p, ...rest2));
     }
   }
   const { chown } = fs;
@@ -12071,18 +12076,18 @@ var init_wasi_procfs = __esm({
           }
         };
       }
-      parts(path, follow2) {
+      parts(path, follow3) {
         const parts = path.split("/").filter((p) => p !== "").slice(1);
-        if (parts[0] === "self" && (follow2 || parts.length > 1)) parts[0] = String(this.pid);
+        if (parts[0] === "self" && (follow3 || parts.length > 1)) parts[0] = String(this.pid);
         return parts;
       }
-      find(path, follow2) {
-        const node = this.node(this.parts(path, follow2));
+      find(path, follow3) {
+        const node = this.node(this.parts(path, follow3));
         if (!node) throw syncError("ENOENT", path);
         return node;
       }
-      stat(path, follow2 = true) {
-        const node = this.find(path, follow2);
+      stat(path, follow3 = true) {
+        const node = this.find(path, follow3);
         const base = {
           isFile: false,
           isDirectory: false,
@@ -15265,8 +15270,8 @@ function fetchOp(kernel) {
     for (let hops = 0; ; hops++) {
       const head = await send(hop, signal);
       const location = head.headers.find(([name2]) => name2.toLowerCase() === "location")?.[1];
-      const follow2 = known.manualRedirects && REDIRECTS.has(head.status) && location !== void 0 && request.redirect !== "manual";
-      if (!follow2) {
+      const follow3 = known.manualRedirects && REDIRECTS.has(head.status) && location !== void 0 && request.redirect !== "manual";
+      if (!follow3) {
         const redirected = hops > 0 || head.redirected === true;
         return respond(head, hop.method, redirected, known.encodedBodies, request);
       }
@@ -15884,10 +15889,22 @@ var init_js_run = __esm({
 });
 
 // src/process/js/js-sync.ts
-function laneOf(lane) {
+function laneOf(lane, silence = SYNC_FS_REQUEST_TIMEOUT_MS, open = createSyncSabTransport) {
   if (!lane) return noLane;
-  const transport = createSyncSabTransport(lane.sab, lane.port);
-  return (req) => transport.call(req, Number.POSITIVE_INFINITY, req.op);
+  const transport = open(lane.sab, lane.port);
+  return (req) => {
+    if (!READ_ONLY.has(req.op)) return transport.call(req, Number.POSITIVE_INFINITY, req.op);
+    try {
+      return transport.call(req, silence, req.op);
+    } catch (err) {
+      const errno2 = err?.code;
+      return {
+        ok: false,
+        errno: typeof errno2 === "string" ? errno2 : "EIO",
+        message: err instanceof Error ? err.message : String(err)
+      };
+    }
+  };
 }
 function syncOps(kernel, shared) {
   const { infos, handles, resolve } = shared;
@@ -16154,7 +16171,7 @@ function syncPathOps(kernel, resolve, statOf, open, tryDev) {
     }
   };
 }
-var encoder3, noLane, JsSyncKernel;
+var encoder3, noLane, READ_ONLY, JsSyncKernel;
 var init_js_sync = __esm({
   "src/process/js/js-sync.ts"() {
     "use strict";
@@ -16168,6 +16185,7 @@ var init_js_sync = __esm({
     init_js_proc();
     encoder3 = new TextEncoder();
     noLane = () => ({ ok: false, errno: "ENOSYS", message: "no sync lane" });
+    READ_ONLY = /* @__PURE__ */ new Set([...SYNC_FS_READ_ONLY, "fd-path-flush"]);
     JsSyncKernel = class {
       lane;
       kernel;
@@ -16298,6 +16316,50 @@ var init_js_tty = __esm({
   }
 });
 
+// src/process/js/js-watch.ts
+function watchRequest(path, options) {
+  return { op: "watch-open", path, ...options?.recursive ? { recursive: true } : {} };
+}
+function watchArgs(options, listener) {
+  const onNote = typeof options === "function" ? options : listener;
+  if (typeof onNote !== "function") throw new TypeError("watch needs a listener");
+  return [typeof options === "object" && options !== null ? options : {}, onNote];
+}
+function follow2(kernel, id, onNote) {
+  const stop = new AbortController();
+  let closed = false;
+  const close = () => {
+    if (closed) return;
+    closed = true;
+    stop.abort();
+    kernel.call({ op: "watch-close", id }).catch(() => void 0);
+  };
+  const pump2 = async () => {
+    while (!closed) {
+      let notes;
+      try {
+        const r = await kernel.blocking({ op: "watch-next", id }, stop.signal);
+        notes = r.ok && r.kind === "json" ? r.json : [];
+      } catch {
+        closed = true;
+        return;
+      }
+      for (const note of notes) {
+        if (closed) return;
+        if ("ended" in note) closed = true;
+        onNote(note);
+      }
+    }
+  };
+  void pump2();
+  return { close };
+}
+var init_js_watch = __esm({
+  "src/process/js/js-watch.ts"() {
+    "use strict";
+  }
+});
+
 // src/process/js/js-websocket.ts
 function failed4(err) {
   return new TypeError("websocket failed", { cause: err });
@@ -16661,6 +16723,15 @@ async function vfsOpen(kernel, abs, options, statOf, io, whole) {
   handles.set(fd, handle.invalidate);
   return handle.file;
 }
+function watchingSyncOps(kernel, syncKernel, shared) {
+  const ops = syncOps(syncKernel, shared);
+  const watch = (path, options, listener) => {
+    const [given, onNote] = watchArgs(options, listener);
+    const id = syncKernel.json(watchRequest(shared.resolve(path), given));
+    return follow2(kernel, id, onNote);
+  };
+  return { ...ops, fs: { ...ops.fs, watch } };
+}
 function createContext(o) {
   const { kernel } = o;
   const infos = /* @__PURE__ */ new Map();
@@ -16736,7 +16807,7 @@ function createContext(o) {
   const terminal = ttyOps(kernel);
   const sync = {
     kernel: KERNEL_INFO,
-    ...syncOps(syncKernel, { pid: o.pid, resolve, random, infos, handles }),
+    ...watchingSyncOps(kernel, syncKernel, { pid: o.pid, resolve, random, infos, handles }),
     run: (options) => runSync(syncKernel, { env: o.env, cwd: o.cwd, resolve, signal: signalNumber }, options),
     spawn: (options) => spawnSync(options),
     exit: (status2 = 0) => {
@@ -16968,6 +17039,11 @@ function pathOps(kernel, resolve, statOf, open, tryDev) {
       await statOf("stat", abs);
       return statFsOf(await kernel.json({ op: "statfs", path: abs }));
     },
+    async watch(path, options, listener) {
+      const [given, onNote] = watchArgs(options, listener);
+      const id = await kernel.json(watchRequest(resolve(path), given));
+      return follow2(kernel, id, onNote);
+    },
     async readFile(path) {
       const abs = resolve(path);
       if (inDev(abs)) return readWhole(await open(abs));
@@ -17015,6 +17091,7 @@ var init_js_context = __esm({
     init_js_run();
     init_js_sync();
     init_js_tty();
+    init_js_watch();
     init_js_websocket();
     KERNEL_INFO = Object.freeze({ version: KERNEL_VERSION });
     JsExit = class extends Error {