@ai-ecoverse/slicc-kernel 1.133.4 → 1.134.0

package/dist/kernel-worker.js

@@ -2307,6 +2307,9 @@ var OpfsFs = class {
       }
     }
     await this.meta.remove([found.path]);
+    if (found.handle?.kind === "directory") {
+      await this.meta.update(found.path, (entry) => entry ?? vacatedAt(found.path));
+    }
     this.touch(Date.now(), parentOf3(found.path));
   }
   links() {
@@ -7092,7 +7095,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.133.4" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.134.0" : "0.0.0-dev";
 var OS_RELEASE = "6.0.0-slicc";
 function procVersion() {
   return `Linux version ${OS_RELEASE} (slicc-kernel ${KERNEL_VERSION}) #1 SMP PREEMPT_DYNAMIC
@@ -10785,6 +10788,88 @@ var FifoTable = class {
   }
 };
 
+// src/kernel/held-cwd.ts
+var CWD_SLOTS = 1024;
+var UNTRACKED = CWD_SLOTS - 1;
+var under4 = (path, changed) => changed === "/" || path === changed || path.startsWith(`${changed}/`);
+var CwdTable = class {
+  sab = new SharedArrayBuffer(CWD_SLOTS * 4);
+  view = new Int32Array(this.sab);
+  held = /* @__PURE__ */ new Map();
+  free = [];
+  next = 0;
+  checks = 0;
+  inodeOf;
+  constructor(inodeOf2) {
+    this.inodeOf = inodeOf2;
+  }
+  async hold(path, from) {
+    const shared = from === void 0 ? void 0 : this.held.get(from);
+    if (shared && shared.path === path) return this.share(from);
+    const ino = await this.inodeOf(path).catch(() => void 0);
+    const slot2 = this.free.pop() ?? (this.next < UNTRACKED ? this.next++ : UNTRACKED);
+    if (slot2 === UNTRACKED) return slot2;
+    this.held.set(slot2, {
+      path,
+      ino,
+      refs: 1,
+      dead: false,
+      verified: Atomics.load(this.view, slot2)
+    });
+    return slot2;
+  }
+  share(slot2) {
+    const held = slot2 === void 0 ? void 0 : this.held.get(slot2);
+    if (!held) return UNTRACKED;
+    held.refs++;
+    return slot2;
+  }
+  release(slot2) {
+    const held = slot2 === void 0 ? void 0 : this.held.get(slot2);
+    if (!held || --held.refs > 0) return;
+    this.held.delete(slot2);
+    Atomics.add(this.view, slot2, 1);
+    this.free.push(slot2);
+  }
+  stateOf(slot2) {
+    const held = this.held.get(slot2);
+    return { seen: held?.verified ?? Atomics.load(this.view, slot2), dead: held?.dead === true };
+  }
+  touched(paths, trees = []) {
+    if (this.held.size === 0) return;
+    for (const [slot2, held] of this.held) {
+      if (held.dead) continue;
+      if (paths.some((p) => under4(held.path, p)) || trees.some((t) => under4(held.path, t))) {
+        Atomics.add(this.view, slot2, 1);
+      }
+    }
+  }
+  async check(slot2) {
+    this.checks++;
+    const gen = Atomics.load(this.view, slot2);
+    const held = this.held.get(slot2);
+    if (!held) return { gen, alive: true };
+    if (!held.dead) {
+      const ino = await this.inodeOf(held.path).catch(() => null);
+      held.dead = ino === null || held.ino !== void 0 && ino !== held.ino;
+      held.verified = gen;
+    }
+    return { gen, alive: !held.dead };
+  }
+};
+function heldInit(o) {
+  if (!o.cwds || o.cwdSlot === void 0) return {};
+  const state = o.cwdState ?? { seen: 0, dead: false };
+  return { held: { sab: o.cwds, slot: o.cwdSlot, ...state } };
+}
+function heldHooks(o) {
+  if (!o.cwdCheck || !o.cwdChdir) return {};
+  return { cwdCheck: o.cwdCheck, cwdChdir: o.cwdChdir };
+}
+function inheritedCwd(chdir, parent) {
+  return chdir ? void 0 : parent;
+}
+
 // src/fs/copy.ts
 async function present2(fs, path) {
   return fs.lstat(path).then(
@@ -14073,8 +14158,8 @@ var EventFd = class _EventFd {
   count;
   semaphore;
   changes = new Notifier();
-  constructor(initial, semaphore) {
-    this.count = initial;
+  constructor(initial2, semaphore) {
+    this.count = initial2;
     this.semaphore = semaphore;
   }
   async read(max, signal) {
@@ -17823,7 +17908,7 @@ var UNSAFE = /[\r\n\0]/;
 var POSITIONS = {
   http1: (position) => HEADER.test(position),
   smtp: (position) => position === "auth-plain" || position === "auth-login",
-  pg: (position) => position === "password-cleartext"
+  pg: (position) => position === "password-cleartext" || position === "scram-sha-256"
 };
 function boundHost(servername) {
   const lower = servername.toLowerCase();
@@ -17838,6 +17923,15 @@ function placeholdersOk(list) {
   if (!Array.isArray(list) || list.length === 0 || list.length > SESSION_PLACEHOLDERS) return false;
   return new Set(list).size === list.length && list.every((p) => typeof p === "string" && SESSION_PLACEHOLDER.test(p));
 }
+var SCRAM_TEXT = /^[\x21-\x7e]{1,1024}$/;
+function scramOk(f) {
+  if (f.position !== "scram-sha-256")
+    return f.scram === void 0 && placeholdersOk(f.placeholders);
+  const x = f.scram;
+  if (f.placeholders !== void 0 || typeof x !== "object" || x === null) return false;
+  const texts = [x.clientFirstBare, x.serverFirst, x.clientFinalBare, x.proof];
+  return texts.every((t) => typeof t === "string" && SCRAM_TEXT.test(t));
+}
 function hostOk(host) {
   return typeof host === "string" && HOST.test(host) && boundHost(host) === host;
 }
@@ -17849,7 +17943,7 @@ function sessionAskable(f, now) {
   if (!Number.isInteger(f.port) || f.port < 1 || f.port > 65535) return false;
   const age = now - f.handshakeAt;
   if (!Number.isFinite(age) || age < 0 || age > SESSION_WINDOW_MS) return false;
-  return typeof f.exit === "string" && SESSION_EXIT.test(f.exit) && placeholdersOk(f.placeholders) && headOk(f);
+  return typeof f.exit === "string" && SESSION_EXIT.test(f.exit) && scramOk(f) && headOk(f);
 }
 function sessionRequest(f) {
   return {
@@ -17865,8 +17959,16 @@ function sessionRequest(f) {
     verified: true,
     handshakeAt: f.handshakeAt,
     exit: f.exit,
-    placeholders: [...f.placeholders],
-    ...f.head ? { head: { method: f.head.method, path: f.head.path } } : {}
+    ...f.placeholders ? { placeholders: [...f.placeholders] } : {},
+    ...f.head ? { head: { method: f.head.method, path: f.head.path } } : {},
+    ...f.scram ? {
+      scram: {
+        clientFirstBare: f.scram.clientFirstBare,
+        serverFirst: f.scram.serverFirst,
+        clientFinalBare: f.scram.clientFinalBare,
+        proof: f.scram.proof
+      }
+    } : {}
   };
 }
 function sessionValues(reply, asked) {
@@ -17874,7 +17976,9 @@ function sessionValues(reply, asked) {
   const { error, values } = reply;
   if (error !== void 0 || typeof values !== "object" || values === null) return void 0;
   const out = {};
-  for (const ph of asked) {
+  const keys = Object.keys(values);
+  const wanted = asked ?? (keys.length === 1 && SESSION_PLACEHOLDER.test(keys[0]) ? keys : []);
+  for (const ph of wanted) {
     const value2 = values[ph];
     if (typeof value2 === "string" && value2.length > 0 && !UNSAFE.test(value2)) out[ph] = value2;
   }
@@ -18566,6 +18670,104 @@ async function substituteHead(head, ask) {
 `, values };
 }
 
+// src/kernel/net/sealed-scram.ts
+var encoder8 = new TextEncoder();
+function base64Bytes(text) {
+  try {
+    return Uint8Array.from(atob(text), (c) => c.charCodeAt(0));
+  } catch {
+    return void 0;
+  }
+}
+function base64Of(bytes) {
+  let bin = "";
+  for (const b of bytes) bin += String.fromCharCode(b);
+  return btoa(bin);
+}
+function clientFirstBare(message3) {
+  const m = /^n,,(n=[^,]*,r=[^,]+)$/.exec(message3);
+  return m ? m[1] : void 0;
+}
+var SERVER_FIRST = /^r=([^,]+),s=([^,]+),i=(\d{1,6})$/;
+var CLIENT_FINAL = /^(c=biws,r=([^,]+)),p=([^,]+)$/;
+var SCRAM_MAX = 1024;
+function exchangeOf(clientFirst, serverFirst, clientFinal) {
+  const bare = clientFirstBare(clientFirst);
+  const sf = SERVER_FIRST.exec(serverFirst);
+  const fin = CLIENT_FINAL.exec(clientFinal);
+  if (!bare || !sf || !fin || [bare, serverFirst, clientFinal].some((t) => t.length > SCRAM_MAX))
+    return void 0;
+  const cnonce = bare.slice(bare.indexOf(",r=") + 3);
+  const nonce = sf[1];
+  const salt = base64Bytes(sf[2]);
+  const iterations = Number(sf[3]);
+  const proof = base64Bytes(fin[3]);
+  const ok4 = fin[2] === nonce && nonce.startsWith(cnonce) && iterations >= 1 && iterations <= 1e5 && salt !== void 0 && proof?.length === 32;
+  if (!ok4) return void 0;
+  return {
+    exchange: {
+      clientFirstBare: bare,
+      serverFirst,
+      clientFinalBare: fin[1],
+      salt,
+      iterations
+    },
+    proof
+  };
+}
+async function hmac(key, data) {
+  const k = await crypto.subtle.importKey(
+    "raw",
+    key,
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  return new Uint8Array(await crypto.subtle.sign("HMAC", k, data));
+}
+async function scramKeys(password, x) {
+  const base = await crypto.subtle.importKey("raw", encoder8.encode(password), "PBKDF2", false, [
+    "deriveBits"
+  ]);
+  const salted = new Uint8Array(
+    await crypto.subtle.deriveBits(
+      {
+        name: "PBKDF2",
+        hash: "SHA-256",
+        salt: x.salt,
+        iterations: x.iterations
+      },
+      base,
+      256
+    )
+  );
+  const clientKey = await hmac(salted, encoder8.encode("Client Key"));
+  const stored = new Uint8Array(
+    await crypto.subtle.digest("SHA-256", clientKey)
+  );
+  const auth = encoder8.encode(`${x.clientFirstBare},${x.serverFirst},${x.clientFinalBare}`);
+  const signature = await hmac(stored, auth);
+  const proof = clientKey.map((b, i) => b ^ signature[i]);
+  const serverKey = await hmac(salted, encoder8.encode("Server Key"));
+  const serverSignature = await hmac(serverKey, auth);
+  for (const k of [salted, clientKey, stored, signature, serverKey]) k.fill(0);
+  return { proof, serverSignature };
+}
+var SPACES = /[\u00A0\u1680\u2000-\u200B\u202F\u205F\u3000]/g;
+var NOTHING2 = /\u00AD|\u034F|\u1806|[\u180B-\u180D]|\u200C|\u200D|\u2060|[\uFE00-\uFE0F]|\uFEFF/g;
+var PROHIBITED = /[\u0000-\u001F\u007F-\u009F\uE000-\uF8FF\uFFFE\uFFFF]/;
+function saslprep(password) {
+  if (/^[\x20-\x7e]*$/.test(password)) return password;
+  const mapped = password.replace(SPACES, " ").replace(NOTHING2, "").normalize("NFKC");
+  return PROHIBITED.test(mapped) ? password : mapped;
+}
+function sameBytes(a, b) {
+  if (a.length !== b.length) return false;
+  let d = 0;
+  for (let i = 0; i < a.length; i++) d |= a[i] ^ b[i];
+  return d === 0;
+}
+
 // src/kernel/net/sealed-pg.ts
 var PG_MESSAGE_MAX = 16 * 1024;
 var PROTOCOL_3 = 196608;
@@ -18580,44 +18782,101 @@ function sniffPg(start2) {
   const length2 = int32(bytes, 0);
   return length2 >= 8 && length2 <= PG_MESSAGE_MAX && int32(bytes, 4) === PROTOCOL_3 ? "yes" : "no";
 }
+var PLUS = "SCRAM-SHA-256-PLUS";
+var SASL = 10;
+var SASL_CONTINUE = 11;
+var SASL_FINAL = 12;
+function latin(bytes) {
+  let out = "";
+  for (const b of bytes) out += String.fromCharCode(b);
+  return out;
+}
 var PgServer = class {
   buffer = new Uint8Array(0);
   skip = 0;
-  lost = false;
   cleartext = false;
-  feed(bytes) {
-    if (this.lost) return;
+  sasl = false;
+  serverFirst;
+  expect;
+  failed = false;
+  lost = false;
+  auth(message3) {
+    const code = message3.length >= 9 ? int32(message3, 5) : -1;
+    if (this.expect && code !== SASL_FINAL) this.failed = true;
+    this.cleartext = message3.length === 9 && code === CLEARTEXT;
+    if (code === SASL) return this.mechanisms(message3);
+    else if (code === SASL_CONTINUE) this.serverFirst = latin(message3.subarray(9));
+    else if (code === SASL_FINAL) this.final(message3);
+    return message3;
+  }
+  mechanisms(message3) {
+    this.sasl = true;
+    const names2 = latin(message3.subarray(9)).split("\0").filter((n) => n !== "" && n !== PLUS);
+    return frame3(82, `${latin(message3.subarray(5, 9))}${names2.map((n) => `${n}\0`).join("")}\0`);
+  }
+  final(message3) {
+    const expect = this.expect;
+    if (!expect) return;
+    this.expect = void 0;
+    const data = latin(message3.subarray(9));
+    if (data !== expect.real || expect.fake.length !== expect.real.length) {
+      this.failed = true;
+      return;
+    }
+    for (let i = 0; i < expect.fake.length; i++) message3[9 + i] = expect.fake.charCodeAt(i);
+  }
+  lose() {
+    this.lost = true;
+    this.cleartext = false;
+    this.sasl = false;
+    if (this.expect) this.failed = true;
+    this.expect = void 0;
+  }
+  filter(bytes) {
+    if (this.lost) return bytes;
     const data = new Uint8Array(this.buffer.length + bytes.length);
     data.set(this.buffer);
     data.set(bytes, this.buffer.length);
+    const out = [];
     let at = 0;
     for (; ; ) {
       const left = data.length - at;
       if (this.skip > 0) {
         const n = Math.min(this.skip, left);
+        out.push(data.subarray(at, at + n));
         this.skip -= n;
         at += n;
         if (this.skip > 0) break;
         continue;
       }
       if (left < 5) break;
-      const type = data[at];
       const whole = 1 + int32(data, at + 1);
-      if (whole < 5 || type === 82 && whole > PG_MESSAGE_MAX) {
-        this.lost = true;
-        this.cleartext = false;
-        this.buffer = new Uint8Array(0);
-        return;
+      if (whole < 5 || data[at] === 82 && whole > PG_MESSAGE_MAX) {
+        this.lose();
+        out.push(data.subarray(at));
+        at = data.length;
+        break;
       }
-      if (type !== 82) {
+      if (data[at] !== 82) {
+        if (this.expect) {
+          this.failed = true;
+          break;
+        }
         this.skip = whole;
         continue;
       }
       if (left < whole) break;
-      this.cleartext = whole === 9 && int32(data, at + 5) === CLEARTEXT;
+      out.push(this.auth(data.slice(at, at + whole)));
       at += whole;
     }
     this.buffer = data.slice(at);
+    const joined4 = new Uint8Array(out.reduce((n, b) => n + b.length, 0));
+    let to = 0;
+    for (const b of out) {
+      joined4.set(b, to);
+      to += b.length;
+    }
+    return joined4;
   }
 };
 function frame3(type, body) {
@@ -18634,21 +18893,76 @@ function pgLength(bytes, started) {
   const length2 = int32(bytes, started ? 1 : 0);
   return started ? 1 + length2 : length2;
 }
-async function pgPassword(message3, server, ask) {
-  if (message3[0] !== 112 || !server.cleartext) return { bytes: message3, done: true };
-  server.cleartext = false;
-  let body = "";
-  for (const b of message3.subarray(5)) body += String.fromCharCode(b);
+var MECHANISMS = /* @__PURE__ */ new Set(["SCRAM-SHA-256"]);
+async function cleartext(message3, asks) {
+  const body = latin(message3.subarray(5));
   if (!body.endsWith("\0") || body.indexOf("\0") !== body.length - 1)
     return { bytes: message3, done: true };
   const password = body.slice(0, -1);
   const placeholders = placeholdersIn(password);
   if (placeholders.length === 0 || placeholders.length > SESSION_PLACEHOLDERS)
     return { bytes: message3, done: true };
-  const values = usable(await ask(placeholders));
+  const values = usable(await asks.cleartext(placeholders));
   if (Object.keys(values).length === 0) return { bytes: message3, done: true };
   return { bytes: frame3(112, `${replaced(password, values)}\0`), values, done: true };
 }
+function initial(message3) {
+  const body = latin(message3.subarray(5));
+  const nul = body.indexOf("\0");
+  if (nul < 0 || !MECHANISMS.has(body.slice(0, nul)) || body.length < nul + 5) return void 0;
+  const data = message3.subarray(5 + nul + 5);
+  return int32(message3, 5 + nul + 1) === data.length ? latin(data) : void 0;
+}
+var PgClient = class {
+  clientFirst;
+  server;
+  asks;
+  constructor(server, asks) {
+    this.server = server;
+    this.asks = asks;
+  }
+  async message(message3) {
+    const server = this.server;
+    if (message3[0] !== 112) return { bytes: message3, done: true };
+    if (server.cleartext) {
+      server.cleartext = false;
+      return cleartext(message3, this.asks);
+    }
+    if (server.sasl && this.clientFirst === void 0) {
+      this.clientFirst = initial(message3);
+      return { bytes: message3, done: this.clientFirst === void 0 };
+    }
+    if (this.clientFirst !== void 0 && server.serverFirst !== void 0)
+      return this.final(message3, this.clientFirst, server.serverFirst);
+    return { bytes: message3, done: true };
+  }
+  async final(message3, first, serverFirst) {
+    const got = exchangeOf(first, serverFirst, latin(message3.subarray(5)));
+    if (!got) return { bytes: message3, done: true };
+    const x = got.exchange;
+    const values = usable(
+      await this.asks.scram({
+        clientFirstBare: x.clientFirstBare,
+        serverFirst: x.serverFirst,
+        clientFinalBare: x.clientFinalBare,
+        proof: base64Of(got.proof)
+      })
+    );
+    const [entry, ...more] = Object.entries(values);
+    if (!entry || more.length > 0) return { bytes: message3, done: true };
+    const [placeholder, value2] = entry;
+    const fake = await scramKeys(placeholder, x);
+    if (!sameBytes(fake.proof, got.proof)) return { bytes: message3, done: true };
+    const real = await scramKeys(saslprep(value2), x);
+    this.server.expect = {
+      real: `v=${base64Of(real.serverSignature)}`,
+      fake: `v=${base64Of(fake.serverSignature)}`
+    };
+    const bytes = frame3(112, `${x.clientFinalBare},p=${base64Of(real.proof)}`);
+    for (const k of [real.proof, real.serverSignature, fake.proof, fake.serverSignature]) k.fill(0);
+    return { bytes, values, done: true };
+  }
+};
 
 // src/kernel/net/sealed-smtp.ts
 var SMTP_LINE_MAX = 4096;
@@ -18793,17 +19107,21 @@ var SessionWriter = class {
   session = sessionId();
   smtp;
   pgStarted = false;
+  sawPg = false;
   conn;
   s;
-  pg;
+  pgClient;
   scope;
   constructor(conn, s, pg, scope) {
     this.conn = conn;
     this.s = s;
-    this.pg = pg;
     this.scope = scope;
+    this.pgClient = new PgClient(pg, {
+      cleartext: (placeholders) => this.ask("pg", "password-cleartext", { placeholders }),
+      scram: (scram) => this.ask("pg", "scram-sha-256", { scram })
+    });
     this.smtp = new SmtpClient(
-      (position, placeholders) => this.ask("smtp", position, placeholders)
+      (position, placeholders) => this.ask("smtp", position, { placeholders })
     );
   }
   write(bytes) {
@@ -18814,7 +19132,7 @@ var SessionWriter = class {
     );
     return run2;
   }
-  async ask(protocol, position, placeholders, head) {
+  async ask(protocol, position, extra) {
     const s = this.s;
     const values = await s.broker.sessionMaterialize({
       stamp: await s.stamp(),
@@ -18826,8 +19144,7 @@ var SessionWriter = class {
       verified: s.verified,
       handshakeAt: s.handshakeAt,
       exit: s.exit,
-      placeholders,
-      ...head ? { head } : {}
+      ...extra
     });
     return values;
   }
@@ -18846,6 +19163,7 @@ var SessionWriter = class {
     this.buffer.fill(0);
     this.buffer = joined4;
     if (this.mode === "sniff") this.mode = modeOf(latin12(joined4.subarray(0, 8))) ?? "sniff";
+    if (this.mode === "pg") this.sawPg = true;
     if (this.mode === "pass") await this.release();
     else if (this.mode === "http1") await this.http1();
     else if (this.mode === "smtp") await this.lines();
@@ -18892,11 +19210,7 @@ var SessionWriter = class {
       this.buffer = this.buffer.slice(whole);
       const started = this.pgStarted;
       this.pgStarted = true;
-      const out = started ? await pgPassword(
-        message3,
-        this.pg,
-        (placeholders) => this.ask("pg", "password-cleartext", placeholders)
-      ).catch(() => ({ bytes: message3, done: true })) : { bytes: message3, done: false };
+      const out = started ? await this.pgClient.message(message3).catch(() => ({ bytes: message3, done: true })) : { bytes: message3, done: false };
       if ("values" in out && out.values) this.remember(out.values);
       try {
         await writeAll4(this.conn, out.bytes);
@@ -18928,7 +19242,7 @@ var SessionWriter = class {
     this.buffer = new Uint8Array(0);
     const done5 = await substituteHead(
       latin12(all.subarray(0, end)),
-      (position, placeholders, head2) => this.ask("http1", position, placeholders, head2)
+      (position, placeholders, head2) => this.ask("http1", position, { placeholders, head: head2 })
     ).catch(() => void 0);
     const head = done5 ? bytesOf(done5.head) : all.subarray(0, end);
     if (done5) this.remember(done5.values);
@@ -19026,9 +19340,19 @@ function sealedConn(conn, s) {
   const observed = {
     ...conn,
     read: async () => {
-      const bytes = await conn.read();
-      if (bytes) pg.feed(bytes);
-      return bytes;
+      for (; ; ) {
+        const bytes = await conn.read();
+        if (!bytes) return bytes;
+        const out = writer?.sawPg ? pg.filter(bytes) : bytes;
+        if (pg.failed) {
+          conn.close();
+          throw new KernelError(
+            "EPROTO",
+            "ERR_SSL_PROTOCOL_ERROR: the pg server failed the SCRAM proof"
+          );
+        }
+        if (out.length > 0) return out;
+      }
     }
   };
   const reader = new ScrubReader(writer ? observed : conn, scope);
@@ -21142,6 +21466,8 @@ var SYSCALL_OPS = /* @__PURE__ */ new Set([
   "fd-list",
   "proc-alarm",
   "proc-umask",
+  "cwd-check",
+  "cwd-chdir",
   "proc-cred",
   "proc-setcred",
   "dl-log",
@@ -22467,6 +22793,14 @@ var WasmProcess = class {
         return { ok: true, kind: "void" };
       case "proc-umask":
         return { ok: true, kind: "json", json: this.setUmask(req.mask) };
+      case "cwd-check":
+        return {
+          ok: true,
+          kind: "json",
+          json: await this.options.cwdCheck?.() ?? { gen: 0, alive: true }
+        };
+      case "cwd-chdir":
+        return { ok: true, kind: "json", json: await this.options.cwdChdir?.(req.path) ?? {} };
       case "proc-cred":
         return { ok: true, kind: "json", json: copyCred(this.cred) };
       case "proc-setcred":
@@ -23016,6 +23350,7 @@ function processInit(opts, sab, umask, cred, lane) {
     umask,
     cred,
     ...opts.changes ? { changes: opts.changes } : {},
+    ...heldInit(opts),
     ...opts.owners ? { owners: true } : {},
     ...opts.links !== void 0 ? { links: true } : {},
     ...opts.ppid !== void 0 ? { ppid: opts.ppid } : {}
@@ -23089,6 +23424,7 @@ function processOptions(opts, header3, hooks, created4) {
     ...opts.identity ? { identity: opts.identity } : {},
     ...opts.onSyscall ? { onSyscall: opts.onSyscall } : {},
     ...opts.settling ? { settling: opts.settling } : {},
+    ...heldHooks(opts),
     spawner: opts.spawner,
     forker: opts.forker,
     ...opts.fork?.dl ? { dl: opts.fork.dl } : {},
@@ -23139,6 +23475,7 @@ function threadInit(opts, program, sab, cred, thread, main) {
     owners: opts.owners === true,
     ...opts.links !== void 0 ? { links: true } : {},
     ...opts.changes ? { changes: opts.changes } : {},
+    ...heldInit(opts),
     ...opts.ppid !== void 0 ? { ppid: opts.ppid } : {},
     thread,
     signals: main
@@ -24095,7 +24432,7 @@ var SEALED_OPS = /* @__PURE__ */ new Set([
   "cancel",
   "materialize"
 ]);
-var encoder8 = new TextEncoder();
+var encoder9 = new TextEncoder();
 var decoder3 = new TextDecoder("utf-8", { fatal: true });
 function parseSealed(bytes) {
   try {
@@ -24176,7 +24513,7 @@ var SealedChannel = class {
         await this.broker.tickets.record(req, reply, caller.pid);
       if (this.inflight !== flight) return;
       this.inflight = void 0;
-      if (reply) this.reply = encoder8.encode(serialized(reply));
+      if (reply) this.reply = encoder9.encode(serialized(reply));
     });
     this.inflight = flight;
     return length2;
@@ -25912,9 +26249,9 @@ function importedMemory(bytes) {
   };
   const limits = () => {
     const flags2 = bytes[at++];
-    const initial = u32();
+    const initial2 = u32();
     const maximum = flags2 & 1 ? u32() : void 0;
-    return { initial, maximum, shared: (flags2 & 2) !== 0 };
+    return { initial: initial2, maximum, shared: (flags2 & 2) !== 0 };
   };
   while (at < bytes.length) {
     const id2 = bytes[at++];
@@ -26559,7 +26896,7 @@ var LAYOUT = [
 var IN_TREE = /* @__PURE__ */ new Set([SUDO_PATH, CRONTAB_PATH]);
 var LOAD_SAMPLE_MS = 5e3;
 var LOAD_WINDOWS_MS = [6e4, 3e5, 9e5];
-var encoder9 = new TextEncoder();
+var encoder10 = new TextEncoder();
 var USERS_MODES = ["off", "report", "enforce"];
 function usersMode(mode = "off") {
   if (USERS_MODES.includes(mode)) return mode;
@@ -26770,6 +27107,11 @@ var Launcher = class {
   hostname;
   watchers = new FsWatchers();
   changes = new FileChanges();
+  cwds = new CwdTable(async (path) => {
+    const { dev, ino } = await this.base.stat(path);
+    return `${dev ?? 0}:${ino}`;
+  });
+  cwdSlots = /* @__PURE__ */ new Map();
   pnpmHome;
   pnpmChain;
   pnpmMade;
@@ -26826,7 +27168,10 @@ var Launcher = class {
     this.sealed.tickets.normalise = (path) => physicalPathAsync(this.base, path);
     this.sealed.userOf = async (uid) => (await this.users.lookup(uid))?.name;
     if (this.owners) options.fs.trackOwners?.();
-    this.watchers.tap((paths) => this.changes.publish(...paths));
+    this.watchers.tap((paths) => {
+      this.changes.publish(...paths);
+      this.cwds.touched(paths);
+    });
     this.watchers.onReshape(() => {
       for (const nodes of this.openFiles) nodes.reshaped();
     });
@@ -26896,6 +27241,7 @@ var Launcher = class {
     options.fs.onPeer?.(() => this.flushOpen());
     options.fs.remoteChanges?.((change) => {
       this.changes.flush();
+      this.cwds.touched(change.paths, change.trees);
       this.rewritten(change.paths, change.trees);
     });
     const holders = [this.held, this.openFiles];
@@ -27678,11 +28024,12 @@ var Launcher = class {
     }
     const done5 = this.heldUrl(program);
     try {
+      const cwdSlot = await this.cwds.hold(cwd, req.cwdFrom);
       const handle = await this.admitted(
         program.abi !== "js",
         req.fds,
-        (fds, quietOom) => this.start({ ...req, fds, quietOom, cwd, program, argv0: target.argv0, args, env })
-      );
+        (fds, quietOom) => this.start({ ...req, fds, quietOom, cwd, program, argv0: target.argv0, args, env, cwdSlot })
+      ).finally(() => this.cwds.release(cwdSlot));
       void handle.exited.finally(done5);
       return handle;
     } catch (err) {
@@ -27769,6 +28116,8 @@ var Launcher = class {
       throw new SpawnError("ESRCH");
     }
     const pid = req.pid ?? this.nextPid++;
+    const cwdSlot = this.cwds.share(req.cwdSlot);
+    this.cwdSlots.set(pid, cwdSlot);
     const scrubs = this.treeScrubs(req);
     const stack = this.stackFor(req.tag);
     const terminal = req.fds.stdioTerminal();
@@ -27803,6 +28152,7 @@ var Launcher = class {
       ...this.dac ? { dac: this.dac } : {},
       program: req.program,
       changes: this.changes.sab,
+      ...this.heldFor(pid, cwdSlot),
       argv0: req.argv0,
       args: req.args,
       env: req.env,
@@ -27877,6 +28227,8 @@ var Launcher = class {
       (state) => state === "stopped" ? this.stopped.add(pid) : this.stopped.delete(pid)
     );
     void handle.exited.then(() => {
+      this.cwds.release(this.cwdSlots.get(pid));
+      this.cwdSlots.delete(pid);
       this.freshModules.forget(pid);
       const spent = handle.times?.();
       if (spent) this.spent.set(pid, spent);
@@ -28108,6 +28460,7 @@ var Launcher = class {
       const handle = await this.launch(planned, {
         ...deciding ? { decided: deciding.promise } : {},
         cwd: req.cwd,
+        cwdFrom: inheritedCwd(req.chdir, this.cwdSlots.get(ppid)),
         ...redeemed,
         fds,
         report,
@@ -28169,6 +28522,24 @@ var Launcher = class {
       for (const resolve2 of waiting) resolve2(true);
     }, 0);
   }
+  heldFor(pid, slot2) {
+    return {
+      cwds: this.cwds.sab,
+      cwdSlot: slot2,
+      cwdState: this.cwds.stateOf(slot2),
+      cwdCheck: async () => {
+        const current = this.cwdSlots.get(pid);
+        return { ...await this.cwds.check(current), slot: current };
+      },
+      cwdChdir: (path) => this.chdirHeld(pid, path)
+    };
+  }
+  async chdirHeld(pid, path) {
+    this.cwds.release(this.cwdSlots.get(pid));
+    const slot2 = await this.cwds.hold(path);
+    this.cwdSlots.set(pid, slot2);
+    return { slot: slot2, ...this.cwds.stateOf(slot2) };
+  }
   forker(ppid, parent) {
     const { exec: _exec, pgid: _pgid, group: _group, pid: _pid, scrub: _scrub, ...image } = parent;
     return async (state, given) => {
@@ -28176,6 +28547,7 @@ var Launcher = class {
         ...image,
         quietOom,
         cwd: state.cwd ?? parent.cwd,
+        cwdSlot: this.cwdSlots.get(ppid),
         fds,
         ppid,
         fork: state,
@@ -28799,7 +29171,7 @@ var Launcher = class {
       },
       account
     );
-    const report = (message3) => options.onData(encoder9.encode(`${message3}\r
+    const report = (message3) => options.onData(encoder10.encode(`${message3}\r
 `));
     const handle = await this.launch(planned, {
       env,
@@ -28837,7 +29209,7 @@ var Launcher = class {
     };
     const stdout = collect(out, options.onStdout);
     const stderr = collect(err, options.onStderr);
-    const report = (message3) => stderr(encoder9.encode(`${message3}
+    const report = (message3) => stderr(encoder10.encode(`${message3}
 `));
     if (!planned) {
       const directory = await this.directory(file, this.fs.resolvePath(cwd, file));