@cortexkit/aft-opencode 0.51.3 → 0.52.1

package/dist/index.js

@@ -19,12 +19,14 @@ var __toESM = (mod, isNodeMode, target) => {
   }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: __accessProp.bind(mod, key),
-        enumerable: true
-      });
+  if (mod && typeof mod === "object" || typeof mod === "function") {
+    for (let key of __getOwnPropNames(mod))
+      if (!__hasOwnProp.call(to, key))
+        __defProp(to, key, {
+          get: __accessProp.bind(mod, key),
+          enumerable: true
+        });
+  }
   if (canCache)
     cache.set(mod, to);
   return to;
@@ -46,7 +48,7 @@ var __export = (target, all) => {
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // ../../node_modules/.bun/esprima@4.0.1/node_modules/esprima/dist/esprima.js
-var require_esprima = __commonJS((exports, module) => {
+var require_esprima = __commonJS(function(exports, module) {
   (function webpackUniversalModuleDefinition(root, factory) {
     if (typeof exports === "object" && typeof module === "object")
       module.exports = factory();
@@ -6186,7 +6188,7 @@ var require_esprima = __commonJS((exports, module) => {
 });
 
 // ../../node_modules/.bun/array-timsort@1.0.3/node_modules/array-timsort/src/index.js
-var require_src = __commonJS((exports, module) => {
+var require_src = __commonJS(function(exports, module) {
   var DEFAULT_MIN_MERGE = 32;
   var DEFAULT_MIN_GALLOPING = 7;
   var DEFAULT_TMP_STORAGE_LENGTH = 256;
@@ -6829,7 +6831,7 @@ var require_src = __commonJS((exports, module) => {
 });
 
 // ../../node_modules/.bun/comment-json@4.6.2/node_modules/comment-json/src/common.js
-var require_common = __commonJS((exports, module) => {
+var require_common = __commonJS(function(exports, module) {
   var PREFIX_BEFORE = "before";
   var PREFIX_AFTER_PROP = "after-prop";
   var PREFIX_AFTER_COLON = "after-colon";
@@ -7073,7 +7075,7 @@ var require_common = __commonJS((exports, module) => {
 });
 
 // ../../node_modules/.bun/comment-json@4.6.2/node_modules/comment-json/src/array.js
-var require_array = __commonJS((exports, module) => {
+var require_array = __commonJS(function(exports, module) {
   var { sort } = require_src();
   var {
     PROP_SYMBOL_PREFIXES,
@@ -7231,7 +7233,7 @@ var require_array = __commonJS((exports, module) => {
 });
 
 // ../../node_modules/.bun/comment-json@4.6.2/node_modules/comment-json/src/parse.js
-var require_parse = __commonJS((exports, module) => {
+var require_parse = __commonJS(function(exports, module) {
   var esprima = require_esprima();
   var {
     CommentArray
@@ -7556,7 +7558,7 @@ var require_parse = __commonJS((exports, module) => {
 });
 
 // ../../node_modules/.bun/comment-json@4.6.2/node_modules/comment-json/src/stringify.js
-var require_stringify = __commonJS((exports, module) => {
+var require_stringify = __commonJS(function(exports, module) {
   var {
     PREFIX_BEFORE_ALL,
     PREFIX_BEFORE,
@@ -7768,7 +7770,7 @@ var require_stringify = __commonJS((exports, module) => {
 });
 
 // ../../node_modules/.bun/comment-json@4.6.2/node_modules/comment-json/src/index.js
-var require_src2 = __commonJS((exports, module) => {
+var require_src2 = __commonJS(function(exports, module) {
   var { parse, tokenize } = require_parse();
   var stringify = require_stringify();
   var { CommentArray } = require_array();
@@ -9828,19 +9830,38 @@ async function downloadBinary(version) {
     releaseLock?.();
   }
 }
+var ensureBinaryInFlight = new Map;
+function ensureBinaryKey(version) {
+  if (!version)
+    return "latest";
+  return version.startsWith("v") ? version : `v${version}`;
+}
 async function ensureBinary(version) {
-  if (version) {
-    const tag = version.startsWith("v") ? version : `v${version}`;
-    const versionCached = getCachedBinaryPath(tag);
-    if (versionCached && isExpectedCachedBinary(versionCached, tag)) {
-      log(`Found cached binary for ${tag}: ${versionCached}`);
-      return versionCached;
-    }
-    log(`No cached binary for ${tag}, downloading...`);
-    return downloadBinary(tag);
+  const key = ensureBinaryKey(version);
+  const existing = ensureBinaryInFlight.get(key);
+  if (existing)
+    return existing;
+  const task = (async () => {
+    if (version) {
+      const tag = ensureBinaryKey(version);
+      const versionCached = getCachedBinaryPath(tag);
+      if (versionCached && isExpectedCachedBinary(versionCached, tag)) {
+        log(`Found cached binary for ${tag}: ${versionCached}`);
+        return versionCached;
+      }
+      log(`No cached binary for ${tag}, downloading...`);
+      return downloadBinary(tag);
+    }
+    log("No cached binary found, downloading latest...");
+    return downloadBinary();
+  })();
+  ensureBinaryInFlight.set(key, task);
+  try {
+    return await task;
+  } finally {
+    if (ensureBinaryInFlight.get(key) === task)
+      ensureBinaryInFlight.delete(key);
   }
-  log("No cached binary found, downloading latest...");
-  return downloadBinary();
 }
 function createDownloadLockOwner() {
   return JSON.stringify({
@@ -10094,78 +10115,17 @@ async function renameIfPresent(from, to) {
       throw error2;
   }
 }
-// ../../node_modules/.bun/@cortexkit+subc-client@0.5.0/node_modules/@cortexkit/subc-client/dist/client.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.8.1/node_modules/@cortexkit/subc-client/dist/client.js
 import { promises as fs3 } from "node:fs";
 import { debuglog } from "node:util";
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.5.0/node_modules/@cortexkit/subc-client/dist/auth.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.8.1/node_modules/@cortexkit/subc-client/dist/auth.js
 import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
-var NONCE_LEN = 32;
-var MAX_AUTH_MESSAGE_LEN = 4096;
-var SERVER_PROOF_DOMAIN = "subc-server-v1";
-var CLIENT_AUTH_DOMAIN = "subc-client-v1";
-var DEFAULT_CLIENT_ROLE = "client";
-
-class AuthError extends Error {
-}
-function computeProof(key, domain, clientNonce, serverNonce, daemonId) {
-  const mac = createHmac("sha256", Buffer.from(key));
-  mac.update(Buffer.from(domain, "utf8"));
-  mac.update(Buffer.from(clientNonce));
-  mac.update(Buffer.from(serverNonce));
-  mac.update(Buffer.from(daemonId));
-  return new Uint8Array(mac.digest());
-}
-function constantTimeEq(a, b) {
-  if (a.length !== b.length)
-    return false;
-  return timingSafeEqual(Buffer.from(a), Buffer.from(b));
-}
-async function writeMessage(sock, value, deadlineMs) {
-  const json = Buffer.from(JSON.stringify(value), "utf8");
-  if (json.length > MAX_AUTH_MESSAGE_LEN) {
-    throw new AuthError(`auth message too large: ${json.length} > ${MAX_AUTH_MESSAGE_LEN}`);
-  }
-  const lenPrefix = new Uint8Array(4);
-  new DataView(lenPrefix.buffer).setUint32(0, json.length, true);
-  await sock.write(lenPrefix, deadlineMs);
-  await sock.write(json, deadlineMs);
-}
-async function readMessage(sock, deadlineMs) {
-  const lenBytes = await sock.readExact(4, deadlineMs);
-  const len = new DataView(lenBytes.buffer, lenBytes.byteOffset, 4).getUint32(0, true);
-  if (len > MAX_AUTH_MESSAGE_LEN) {
-    throw new AuthError(`auth message too large: ${len} > ${MAX_AUTH_MESSAGE_LEN}`);
-  }
-  const body = len === 0 ? new Uint8Array(0) : await sock.readExact(len, deadlineMs);
-  try {
-    return JSON.parse(Buffer.from(body).toString("utf8"));
-  } catch (err) {
-    throw new AuthError(`auth message JSON decode failed: ${String(err)}`);
-  }
-}
-async function authenticateClient(sock, conn, deadlineMs) {
-  const clientNonce = new Uint8Array(randomBytes(NONCE_LEN));
-  await writeMessage(sock, { client_nonce: Array.from(clientNonce), role: DEFAULT_CLIENT_ROLE }, deadlineMs);
-  const proof = await readMessage(sock, deadlineMs);
-  const serverNonce = Uint8Array.from(proof.server_nonce);
-  const daemonId = Uint8Array.from(proof.daemon_id);
-  const serverProof = Uint8Array.from(proof.server_proof);
-  const expected = computeProof(conn.key, SERVER_PROOF_DOMAIN, clientNonce, serverNonce, daemonId);
-  if (!constantTimeEq(expected, serverProof)) {
-    throw new AuthError("server proof mismatch — wrong key or impostor daemon");
-  }
-  if (!constantTimeEq(daemonId, conn.daemonId)) {
-    throw new AuthError("daemon id mismatch — connection file points at a different daemon");
-  }
-  const clientAuth = computeProof(conn.key, CLIENT_AUTH_DOMAIN, clientNonce, serverNonce, daemonId);
-  await writeMessage(sock, { client_auth: Array.from(clientAuth) }, deadlineMs);
-}
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.5.0/node_modules/@cortexkit/subc-client/dist/connection-file.js
-import { promises as fs2 } from "node:fs";
+// ../../node_modules/.bun/@cortexkit+subc-client@0.8.1/node_modules/@cortexkit/subc-client/dist/socket.js
+import net from "node:net";
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.5.0/node_modules/@cortexkit/subc-client/dist/envelope.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.8.1/node_modules/@cortexkit/subc-client/dist/envelope.js
 var PROTOCOL_VERSION = 2;
 var HEADER_LEN = 21;
 var FROZEN_PREFIX_LEN = 5;
@@ -10239,6 +10199,39 @@ class DecodeError extends Error {
     this.name = "DecodeError";
   }
 }
+function validateHeaderFields(header) {
+  const len = header.len >>> 0;
+  const ver = header.ver >>> 0 & 255;
+  const typeByte = header.ty >>> 0 & 255;
+  const flags = header.flags >>> 0 & 255;
+  const channel = header.channel >>> 0 & 65535;
+  const epoch = header.epoch >>> 0;
+  BigInt.asUintN(64, header.corr);
+  if (ver !== PROTOCOL_VERSION)
+    throw new DecodeError(`unsupported envelope version ${ver}`, "unsupported_version");
+  if (typeByte > FRAME_TYPE_MAX)
+    throw new DecodeError(`unknown frame type byte ${typeByte}`, "unknown_frame_type");
+  const ty = typeByte;
+  if ((flags & FLAG_RESERVED_MASK) !== 0) {
+    throw new DecodeError(`reserved flag bits set in flags 0b${flags.toString(2).padStart(8, "0")}`, "reserved_flag_bits");
+  }
+  if ((flags & FLAG_PRIORITY_MASK) >> FLAG_PRIORITY_SHIFT === 3) {
+    throw new DecodeError(`reserved priority bits set in flags 0b${flags.toString(2).padStart(8, "0")}`, "reserved_priority_bits");
+  }
+  const admission = (flags & FLAG_ADMISSION_MASK) >> FLAG_ADMISSION_SHIFT;
+  if (admission === 3) {
+    throw new DecodeError(`reserved admission class set in flags 0b${flags.toString(2).padStart(8, "0")}`, "reserved_admission_class");
+  }
+  if (admission === AdmissionClass.Sheddable && ty !== FrameType.Push && ty !== FrameType.StreamData) {
+    throw new DecodeError(`SHEDDABLE admission class is illegal on ${FrameType[ty]} in flags 0b${flags.toString(2).padStart(8, "0")}`, "sheddable_illegal_frame_type");
+  }
+  if (channel === 0 && epoch !== 0) {
+    throw new DecodeError(`control channel carried nonzero epoch ${epoch}`, "nonzero_epoch_on_control_channel");
+  }
+  if (isPureHeader(ty) && len !== 0) {
+    throw new DecodeError(`pure-header frame ${FrameType[ty]} declared non-zero body length ${len}`, "pure_header_frame_with_body");
+  }
+}
 function decodeHeader(bytes) {
   if (bytes.length < FROZEN_PREFIX_LEN) {
     throw new DecodeError(`header shorter than frozen prefix: have ${bytes.length} bytes`, "too_short_for_prefix");
@@ -10287,7 +10280,7 @@ function buildFrameWithVersion(ver, ty, flags, channel, epoch, corr, body) {
     throw new DecodeError(`frame body ${body.length} exceeds max ${MAX_FRAME_BODY_LEN}`, "frame_body_too_large");
   }
   const header = { len: body.length, ver, ty, flags, channel, epoch, corr };
-  decodeHeader(encodeHeader(header));
+  validateHeaderFields(header);
   return { header, body };
 }
 function encodeFrame(frame) {
@@ -10301,7 +10294,315 @@ function encodeFrame(frame) {
   return output;
 }
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.5.0/node_modules/@cortexkit/subc-client/dist/connection-file.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.8.1/node_modules/@cortexkit/subc-client/dist/socket.js
+class SocketClosedError extends Error {
+}
+
+class SocketTimeoutError extends Error {
+}
+
+class SocketWriteNotQueuedError extends Error {
+  cause;
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+  }
+}
+
+class SocketWriteQueuedError extends Error {
+  cause;
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+  }
+}
+function toWriteBuffer(bytes) {
+  return Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+}
+var WRITE_BORROWED = Symbol("subc.socket.writeBorrowed");
+var WRITE_TRACKED_BORROWED = Symbol("subc.socket.writeTrackedBorrowed");
+function writeBorrowed(socket, bytes, deadlineMs) {
+  const borrowed = socket[WRITE_BORROWED];
+  return borrowed ? borrowed.call(socket, bytes, deadlineMs) : socket.write(bytes, deadlineMs);
+}
+function writeTrackedBorrowed(socket, bytes, deadlineMs) {
+  const borrowed = socket[WRITE_TRACKED_BORROWED];
+  return borrowed ? borrowed.call(socket, bytes, deadlineMs) : socket.writeTracked(bytes, deadlineMs);
+}
+
+class SubcSocket {
+  sock;
+  chunks = [];
+  buffered = 0;
+  waiter = null;
+  closedErr = null;
+  bufferedBytes() {
+    return this.buffered;
+  }
+  constructor(sock) {
+    this.sock = sock;
+    sock.on("data", (chunk) => {
+      this.chunks.push(chunk);
+      this.buffered += chunk.length;
+      this.tryServe();
+    });
+    const fail = (err) => {
+      if (!this.closedErr)
+        this.closedErr = err;
+      this.tryServe();
+    };
+    sock.on("error", (err) => fail(err instanceof Error ? err : new Error(String(err))));
+    sock.on("end", () => fail(new SocketClosedError("subc closed the connection")));
+    sock.on("close", () => fail(new SocketClosedError("subc connection closed")));
+  }
+  localPort() {
+    return this.sock.localPort ?? null;
+  }
+  static connect(host, port, deadlineMs) {
+    return new Promise((resolve3, reject) => {
+      const sock = net.connect({ host, port });
+      sock.setNoDelay(true);
+      const timer = setTimeout(() => {
+        sock.destroy();
+        reject(new SocketTimeoutError(`timed out connecting to ${host}:${port}`));
+      }, Math.max(0, deadlineMs - Date.now()));
+      sock.once("connect", () => {
+        clearTimeout(timer);
+        resolve3(new SubcSocket(sock));
+      });
+      sock.once("error", (err) => {
+        clearTimeout(timer);
+        reject(err);
+      });
+    });
+  }
+  async readFrame(headerDeadlineMs, bodyDeadline, onHeader) {
+    const prefix = await this.readExact(FROZEN_PREFIX_LEN, headerDeadlineMs);
+    const version = prefix[4];
+    if (version !== PROTOCOL_VERSION)
+      throw new DecodeError(`unsupported envelope version ${version}`, "unsupported_version");
+    const remainder = await this.readExact(HEADER_LEN - FROZEN_PREFIX_LEN, headerDeadlineMs);
+    const headerBytes = new Uint8Array(HEADER_LEN);
+    headerBytes.set(prefix);
+    headerBytes.set(remainder, FROZEN_PREFIX_LEN);
+    const header = decodeHeader(headerBytes);
+    if (header.len > MAX_FRAME_BODY_LEN) {
+      throw new DecodeError(`frame body ${header.len} exceeds max ${MAX_FRAME_BODY_LEN}`, "frame_body_too_large");
+    }
+    onHeader?.();
+    const bodyDeadlineMs = typeof bodyDeadline === "number" ? bodyDeadline : Date.now() + bodyDeadline.afterHeaderMs;
+    const body = header.len === 0 ? new Uint8Array(0) : await this.readExact(header.len, bodyDeadlineMs);
+    return { header, body };
+  }
+  readExact(n, deadlineMs) {
+    if (this.waiter) {
+      return Promise.reject(new Error("concurrent readExact is not supported"));
+    }
+    if (n === 0)
+      return Promise.resolve(new Uint8Array(0));
+    return new Promise((resolve3, reject) => {
+      let timer = null;
+      if (Number.isFinite(deadlineMs)) {
+        const remaining = deadlineMs - Date.now();
+        if (remaining <= 0) {
+          reject(new SocketTimeoutError(`timed out waiting for ${n} bytes`));
+          return;
+        }
+        timer = setTimeout(() => {
+          this.waiter = null;
+          reject(new SocketTimeoutError(`timed out waiting for ${n} bytes`));
+        }, remaining);
+      }
+      this.waiter = { need: n, resolve: resolve3, reject, timer };
+      this.tryServe();
+    });
+  }
+  async write(bytes, deadlineMs) {
+    await this.writeBuffer(Buffer.from(bytes), deadlineMs);
+  }
+  writeTracked(bytes, deadlineMs) {
+    return this.writeTrackedBuffer(Buffer.from(bytes), deadlineMs);
+  }
+  async[WRITE_BORROWED](bytes, deadlineMs) {
+    await this.writeBuffer(toWriteBuffer(bytes), deadlineMs);
+  }
+  [WRITE_TRACKED_BORROWED](bytes, deadlineMs) {
+    return this.writeTrackedBuffer(toWriteBuffer(bytes), deadlineMs);
+  }
+  async writeBuffer(buffer, deadlineMs) {
+    try {
+      await this.writeTrackedBuffer(buffer, deadlineMs).completed;
+    } catch (err) {
+      if (err instanceof SocketWriteNotQueuedError || err instanceof SocketWriteQueuedError) {
+        throw err.cause ?? err;
+      }
+      throw err;
+    }
+  }
+  writeTrackedBuffer(buffer, deadlineMs) {
+    if (this.closedErr) {
+      return {
+        queued: false,
+        completed: Promise.reject(new SocketWriteNotQueuedError("subc socket was closed before bytes could be queued", this.closedErr))
+      };
+    }
+    let queued = false;
+    let settled = false;
+    let timer = null;
+    const completed = new Promise((resolve3, reject) => {
+      const settle = (run) => {
+        if (settled)
+          return;
+        settled = true;
+        if (timer)
+          clearTimeout(timer);
+        run();
+      };
+      const remaining = deadlineMs - Date.now();
+      if (remaining <= 0) {
+        settle(() => reject(new SocketWriteNotQueuedError("timed out before bytes could be queued to subc", new SocketTimeoutError("timed out writing to subc"))));
+        return;
+      }
+      timer = setTimeout(() => {
+        const timeout = new SocketTimeoutError("timed out writing to subc");
+        settle(() => reject(queued ? new SocketWriteQueuedError("timed out after bytes were handed to the subc socket", timeout) : new SocketWriteNotQueuedError("timed out before bytes could be queued to subc", timeout)));
+      }, remaining);
+      try {
+        this.sock.write(buffer, (err) => {
+          settle(() => {
+            if (err) {
+              reject(new SocketWriteQueuedError("subc socket reported a write error after bytes were handed to the socket", err instanceof Error ? err : new Error(String(err))));
+            } else {
+              resolve3();
+            }
+          });
+        });
+        queued = true;
+      } catch (err) {
+        settle(() => reject(new SocketWriteNotQueuedError("subc socket write threw before bytes could be queued", err instanceof Error ? err : new Error(String(err)))));
+      }
+    });
+    return { queued, completed };
+  }
+  close() {
+    this.sock.destroy();
+  }
+  tryServe() {
+    const w = this.waiter;
+    if (!w)
+      return;
+    if (this.buffered >= w.need) {
+      const out = this.take(w.need);
+      this.waiter = null;
+      if (w.timer)
+        clearTimeout(w.timer);
+      w.resolve(out);
+      return;
+    }
+    if (this.closedErr) {
+      this.waiter = null;
+      if (w.timer)
+        clearTimeout(w.timer);
+      w.reject(this.closedErr);
+    }
+  }
+  take(n) {
+    const out = Buffer.allocUnsafe(n);
+    let off = 0;
+    while (off < n) {
+      const head = this.chunks[0];
+      const want = n - off;
+      if (head.length <= want) {
+        head.copy(out, off);
+        off += head.length;
+        this.chunks.shift();
+      } else {
+        head.copy(out, off, 0, want);
+        this.chunks[0] = head.subarray(want);
+        off += want;
+      }
+    }
+    this.buffered -= n;
+    return out;
+  }
+}
+
+// ../../node_modules/.bun/@cortexkit+subc-client@0.8.1/node_modules/@cortexkit/subc-client/dist/auth.js
+var NONCE_LEN = 32;
+var MAX_AUTH_MESSAGE_LEN = 4096;
+var SERVER_PROOF_DOMAIN = "subc-server-v1";
+var CLIENT_AUTH_DOMAIN = "subc-client-v1";
+var DEFAULT_CLIENT_ROLE = "client";
+
+class AuthError extends Error {
+}
+function computeProof(key, domain, clientNonce, serverNonce, daemonId) {
+  const mac = createHmac("sha256", Buffer.from(key));
+  mac.update(Buffer.from(domain, "utf8"));
+  mac.update(Buffer.from(clientNonce));
+  mac.update(Buffer.from(serverNonce));
+  mac.update(Buffer.from(daemonId));
+  return new Uint8Array(mac.digest());
+}
+function constantTimeEq(a, b) {
+  if (a.length !== b.length)
+    return false;
+  return timingSafeEqual(Buffer.from(a), Buffer.from(b));
+}
+async function writeMessage(sock, value, deadlineMs) {
+  const json = Buffer.from(JSON.stringify(value), "utf8");
+  if (json.length > MAX_AUTH_MESSAGE_LEN) {
+    throw new AuthError(`auth message too large: ${json.length} > ${MAX_AUTH_MESSAGE_LEN}`);
+  }
+  const lenPrefix = new Uint8Array(4);
+  new DataView(lenPrefix.buffer).setUint32(0, json.length, true);
+  await writeBorrowed(sock, lenPrefix, deadlineMs);
+  await writeBorrowed(sock, json, deadlineMs);
+}
+async function readMessage(sock, deadlineMs) {
+  const lenBytes = await sock.readExact(4, deadlineMs);
+  const len = new DataView(lenBytes.buffer, lenBytes.byteOffset, 4).getUint32(0, true);
+  if (len > MAX_AUTH_MESSAGE_LEN) {
+    throw new AuthError(`auth message too large: ${len} > ${MAX_AUTH_MESSAGE_LEN}`);
+  }
+  const body = len === 0 ? new Uint8Array(0) : await sock.readExact(len, deadlineMs);
+  try {
+    return JSON.parse(Buffer.from(body).toString("utf8"));
+  } catch (err) {
+    throw new AuthError(`auth message JSON decode failed: ${String(err)}`);
+  }
+}
+function authBytes(value, field) {
+  if (!Array.isArray(value)) {
+    throw new AuthError(`auth field '${field}' must be a byte array`);
+  }
+  for (const byte of value) {
+    if (typeof byte !== "number" || !Number.isInteger(byte) || byte < 0 || byte > 255) {
+      throw new AuthError(`auth field '${field}' has invalid byte ${String(byte)}`);
+    }
+  }
+  return Uint8Array.from(value);
+}
+async function authenticateClient(sock, conn, deadlineMs) {
+  const clientNonce = new Uint8Array(randomBytes(NONCE_LEN));
+  await writeMessage(sock, { client_nonce: Array.from(clientNonce), role: DEFAULT_CLIENT_ROLE }, deadlineMs);
+  const proof = await readMessage(sock, deadlineMs);
+  const serverNonce = authBytes(proof.server_nonce, "server_nonce");
+  const daemonId = authBytes(proof.daemon_id, "daemon_id");
+  const serverProof = authBytes(proof.server_proof, "server_proof");
+  const expected = computeProof(conn.key, SERVER_PROOF_DOMAIN, clientNonce, serverNonce, daemonId);
+  if (!constantTimeEq(expected, serverProof)) {
+    throw new AuthError("server proof mismatch — wrong key or impostor daemon");
+  }
+  if (!constantTimeEq(daemonId, conn.daemonId)) {
+    throw new AuthError("daemon id mismatch — connection file points at a different daemon");
+  }
+  const clientAuth = computeProof(conn.key, CLIENT_AUTH_DOMAIN, clientNonce, serverNonce, daemonId);
+  await writeMessage(sock, { client_auth: Array.from(clientAuth) }, deadlineMs);
+}
+
+// ../../node_modules/.bun/@cortexkit+subc-client@0.8.1/node_modules/@cortexkit/subc-client/dist/connection-file.js
+import { promises as fs2 } from "node:fs";
 var SCHEMA_VERSION = 1;
 var MIN_KEY_LEN = 32;
 var DAEMON_ID_LEN = 16;
@@ -10309,9 +10610,14 @@ var DAEMON_ID_LEN = 16;
 class ConnectionFileError extends Error {
 }
 function toBytes(value, field) {
-  if (!Array.isArray(value) || value.some((n) => typeof n !== "number")) {
+  if (!Array.isArray(value)) {
     throw new ConnectionFileError(`connection file field '${field}' must be a JSON array of bytes`);
   }
+  for (const byte of value) {
+    if (typeof byte !== "number" || !Number.isInteger(byte) || byte < 0 || byte > 255) {
+      throw new ConnectionFileError(`connection file field '${field}' has invalid byte ${String(byte)}`);
+    }
+  }
   return Uint8Array.from(value);
 }
 function validate(info) {
@@ -10373,7 +10679,7 @@ async function readConnectionFile(path2) {
   return info;
 }
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.5.0/node_modules/@cortexkit/subc-client/dist/route-handle.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.8.1/node_modules/@cortexkit/subc-client/dist/route-handle.js
 var connectionToken = new WeakMap;
 
 class RouteHandle {
@@ -10419,220 +10725,12 @@ function sameRouteHandle(left, right) {
   return left === right;
 }
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.5.0/node_modules/@cortexkit/subc-client/dist/socket.js
-import net from "node:net";
-class SocketClosedError extends Error {
-}
-
-class SocketTimeoutError extends Error {
-}
-
-class SocketWriteNotQueuedError extends Error {
-  cause;
-  constructor(message, cause) {
-    super(message);
-    this.cause = cause;
-  }
-}
-
-class SocketWriteQueuedError extends Error {
-  cause;
-  constructor(message, cause) {
-    super(message);
-    this.cause = cause;
-  }
-}
-
-class SubcSocket {
-  sock;
-  chunks = [];
-  buffered = 0;
-  waiter = null;
-  closedErr = null;
-  bufferedBytes() {
-    return this.buffered;
-  }
-  constructor(sock) {
-    this.sock = sock;
-    sock.on("data", (chunk) => {
-      this.chunks.push(chunk);
-      this.buffered += chunk.length;
-      this.tryServe();
-    });
-    const fail = (err) => {
-      if (!this.closedErr)
-        this.closedErr = err;
-      this.tryServe();
-    };
-    sock.on("error", (err) => fail(err instanceof Error ? err : new Error(String(err))));
-    sock.on("end", () => fail(new SocketClosedError("subc closed the connection")));
-    sock.on("close", () => fail(new SocketClosedError("subc connection closed")));
-  }
-  localPort() {
-    return this.sock.localPort ?? null;
-  }
-  static connect(host, port, deadlineMs) {
-    return new Promise((resolve3, reject) => {
-      const sock = net.connect({ host, port });
-      sock.setNoDelay(true);
-      const timer = setTimeout(() => {
-        sock.destroy();
-        reject(new SocketTimeoutError(`timed out connecting to ${host}:${port}`));
-      }, Math.max(0, deadlineMs - Date.now()));
-      sock.once("connect", () => {
-        clearTimeout(timer);
-        resolve3(new SubcSocket(sock));
-      });
-      sock.once("error", (err) => {
-        clearTimeout(timer);
-        reject(err);
-      });
-    });
-  }
-  async readFrame(headerDeadlineMs, bodyDeadline, onHeader) {
-    const prefix = await this.readExact(FROZEN_PREFIX_LEN, headerDeadlineMs);
-    const version = prefix[4];
-    if (version !== PROTOCOL_VERSION)
-      throw new DecodeError(`unsupported envelope version ${version}`, "unsupported_version");
-    const remainder = await this.readExact(HEADER_LEN - FROZEN_PREFIX_LEN, headerDeadlineMs);
-    const headerBytes = new Uint8Array(HEADER_LEN);
-    headerBytes.set(prefix);
-    headerBytes.set(remainder, FROZEN_PREFIX_LEN);
-    const header = decodeHeader(headerBytes);
-    if (header.len > MAX_FRAME_BODY_LEN) {
-      throw new DecodeError(`frame body ${header.len} exceeds max ${MAX_FRAME_BODY_LEN}`, "frame_body_too_large");
-    }
-    onHeader?.();
-    const bodyDeadlineMs = typeof bodyDeadline === "number" ? bodyDeadline : Date.now() + bodyDeadline.afterHeaderMs;
-    const body = header.len === 0 ? new Uint8Array(0) : await this.readExact(header.len, bodyDeadlineMs);
-    return { header, body };
-  }
-  readExact(n, deadlineMs) {
-    if (this.waiter) {
-      return Promise.reject(new Error("concurrent readExact is not supported"));
-    }
-    if (n === 0)
-      return Promise.resolve(new Uint8Array(0));
-    return new Promise((resolve3, reject) => {
-      let timer = null;
-      if (Number.isFinite(deadlineMs)) {
-        const remaining = deadlineMs - Date.now();
-        if (remaining <= 0) {
-          reject(new SocketTimeoutError(`timed out waiting for ${n} bytes`));
-          return;
-        }
-        timer = setTimeout(() => {
-          this.waiter = null;
-          reject(new SocketTimeoutError(`timed out waiting for ${n} bytes`));
-        }, remaining);
-      }
-      this.waiter = { need: n, resolve: resolve3, reject, timer };
-      this.tryServe();
-    });
-  }
-  async write(bytes, deadlineMs) {
-    try {
-      await this.writeTracked(bytes, deadlineMs).completed;
-    } catch (err) {
-      if (err instanceof SocketWriteNotQueuedError || err instanceof SocketWriteQueuedError) {
-        throw err.cause ?? err;
-      }
-      throw err;
-    }
-  }
-  writeTracked(bytes, deadlineMs) {
-    if (this.closedErr) {
-      return {
-        queued: false,
-        completed: Promise.reject(new SocketWriteNotQueuedError("subc socket was closed before bytes could be queued", this.closedErr))
-      };
-    }
-    let queued = false;
-    let settled = false;
-    let timer = null;
-    const completed = new Promise((resolve3, reject) => {
-      const settle = (run) => {
-        if (settled)
-          return;
-        settled = true;
-        if (timer)
-          clearTimeout(timer);
-        run();
-      };
-      const remaining = deadlineMs - Date.now();
-      if (remaining <= 0) {
-        settle(() => reject(new SocketWriteNotQueuedError("timed out before bytes could be queued to subc", new SocketTimeoutError("timed out writing to subc"))));
-        return;
-      }
-      timer = setTimeout(() => {
-        const timeout = new SocketTimeoutError("timed out writing to subc");
-        settle(() => reject(queued ? new SocketWriteQueuedError("timed out after bytes were handed to the subc socket", timeout) : new SocketWriteNotQueuedError("timed out before bytes could be queued to subc", timeout)));
-      }, remaining);
-      try {
-        this.sock.write(Buffer.from(bytes), (err) => {
-          settle(() => {
-            if (err) {
-              reject(new SocketWriteQueuedError("subc socket reported a write error after bytes were handed to the socket", err instanceof Error ? err : new Error(String(err))));
-            } else {
-              resolve3();
-            }
-          });
-        });
-        queued = true;
-      } catch (err) {
-        settle(() => reject(new SocketWriteNotQueuedError("subc socket write threw before bytes could be queued", err instanceof Error ? err : new Error(String(err)))));
-      }
-    });
-    return { queued, completed };
-  }
-  close() {
-    this.sock.destroy();
-  }
-  tryServe() {
-    const w = this.waiter;
-    if (!w)
-      return;
-    if (this.buffered >= w.need) {
-      const out = this.take(w.need);
-      this.waiter = null;
-      if (w.timer)
-        clearTimeout(w.timer);
-      w.resolve(out);
-      return;
-    }
-    if (this.closedErr) {
-      this.waiter = null;
-      if (w.timer)
-        clearTimeout(w.timer);
-      w.reject(this.closedErr);
-    }
-  }
-  take(n) {
-    const out = Buffer.allocUnsafe(n);
-    let off = 0;
-    while (off < n) {
-      const head = this.chunks[0];
-      const want = n - off;
-      if (head.length <= want) {
-        head.copy(out, off);
-        off += head.length;
-        this.chunks.shift();
-      } else {
-        head.copy(out, off, 0, want);
-        this.chunks[0] = head.subarray(want);
-        off += want;
-      }
-    }
-    this.buffered -= n;
-    return out;
-  }
-}
-
-// ../../node_modules/.bun/@cortexkit+subc-client@0.5.0/node_modules/@cortexkit/subc-client/dist/client.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.8.1/node_modules/@cortexkit/subc-client/dist/client.js
 var debug = debuglog("subc-client");
 var DEFAULT_HANDSHAKE_TIMEOUT_MS = 1e4;
 var DEFAULT_REQUEST_TIMEOUT_MS = 30000;
 var TIMEOUT_ARBITRATION_GRACE_MS = 50;
+var LIVENESS_PROBE_WINDOW_MS = 2000;
 var REQUEST_DEADLINE_MARKER = "request_deadline";
 var DEADLINE_NO_DROP_CODE = "deadline_exceeded_no_drop_observed";
 var ROUTE_OPEN_RETRY_DEADLINE_MS = 30000;
@@ -10763,12 +10861,13 @@ class SubcClient {
       } catch (err) {
         if (!(err instanceof SubcCallError))
           throw this.terminalCallError("managed call failed", err);
-        if (err.code === "unknown_channel" && !retriedUnknownChannel && !this.closeStarted) {
+        const deadBindCode = err.code === "unknown_channel" || err.code === "stale_route_epoch";
+        if (deadBindCode && !retriedUnknownChannel && !this.closeStarted) {
           retriedUnknownChannel = true;
           this.evictRouteHandle(routeHandle);
           continue;
         }
-        if (err.code === "unknown_channel" && retriedUnknownChannel) {
+        if (deadBindCode && retriedUnknownChannel) {
           this.evictRouteHandle(routeHandle);
         }
         if (err.kind === "not_sent") {
@@ -10781,6 +10880,8 @@ class SubcClient {
         }
         if (err.kind === "outcome_unknown" && err.code !== DEADLINE_NO_DROP_CODE) {
           this.scheduleReconnectAfterDrop(err);
+        } else if (err.kind === "outcome_unknown" && err.code === DEADLINE_NO_DROP_CODE) {
+          this.probeLivenessAfterDeadline();
         }
         throw err;
       }
@@ -10793,21 +10894,25 @@ class SubcClient {
     const admission = opts.admissionClass ?? AdmissionClass.Normal;
     const corr = this.allocateCorr();
     const key = pendingKey(handle, corr);
+    let subscriptionPending = null;
+    let resolveClosed = null;
     const closed = new Promise((resolve3, reject) => {
       if (this.closedErr) {
         reject(this.closedErr);
         return;
       }
-      this.pending.set(key, {
+      resolveClosed = resolve3;
+      subscriptionPending = {
         handle,
         resolve: () => resolve3(),
         reject,
         onProgress: onEvent,
         timer: null,
         subscription: true
-      });
+      };
+      this.pending.set(key, subscriptionPending);
       const frame = buildFrame(FrameType.Request, buildFlags(false, priority, false, admission), handle.channel, handle.epoch, corr, bytes);
-      this.sock.write(encodeFrame(frame), Date.now() + DEFAULT_REQUEST_TIMEOUT_MS).catch((err) => {
+      writeBorrowed(this.sock, encodeFrame(frame), Date.now() + DEFAULT_REQUEST_TIMEOUT_MS).catch((err) => {
         const pending = this.pending.get(key);
         if (pending)
           this.rejectPending(key, pending, err instanceof Error ? err : new SubcError(String(err)));
@@ -10818,14 +10923,17 @@ class SubcClient {
       if (cancelled)
         return;
       cancelled = true;
-      this.cancel(handle, corr, priority);
+      if (subscriptionPending && resolveClosed)
+        this.settle(key, subscriptionPending, resolveClosed);
+      if (this.isLiveHandle(handle))
+        this.cancel(handle, corr, priority);
     };
     return { unsubscribe, closed };
   }
   cancel(handle, corr, priority = Priority.Interactive) {
     this.assertLiveHandle(handle);
     const cancel = buildFrame(FrameType.Cancel, buildFlags(false, priority, false), handle.channel, handle.epoch, corr, EMPTY_BODY);
-    this.sock.write(encodeFrame(cancel), Date.now() + DEFAULT_REQUEST_TIMEOUT_MS).catch(() => {
+    writeBorrowed(this.sock, encodeFrame(cancel), Date.now() + DEFAULT_REQUEST_TIMEOUT_MS).catch(() => {
       return;
     });
   }
@@ -10906,7 +11014,7 @@ class SubcClient {
       return;
     }
     const goodbye = buildFrame(FrameType.Goodbye, buildFlags(false, Priority.Interactive, false), handle.channel, handle.epoch, 0n, EMPTY_BODY);
-    const write = this.sock.writeTracked(encodeFrame(goodbye), Date.now() + DEFAULT_REQUEST_TIMEOUT_MS);
+    const write = writeTrackedBorrowed(this.sock, encodeFrame(goodbye), Date.now() + DEFAULT_REQUEST_TIMEOUT_MS);
     if (!write.queued && closeOnQueueFailure)
       this.closeConnectionAfterCleanupFailure();
     write.completed.catch(() => {
@@ -10958,7 +11066,7 @@ class SubcClient {
       };
       pending.timer = setTimeout(() => this.arbitrateTimeout(key, pending, channel, corr, ms), ms);
       this.pending.set(key, pending);
-      this.sock.write(encodeFrame(frame), Date.now() + ms).catch((error2) => {
+      writeBorrowed(this.sock, encodeFrame(frame), Date.now() + ms).catch((error2) => {
         const current = this.pending.get(key);
         if (current)
           this.rejectPending(key, current, error2 instanceof Error ? error2 : new SubcError(String(error2)));
@@ -11035,7 +11143,7 @@ class SubcClient {
       };
       pending.timer = setTimeout(() => this.arbitrateTimeout(key, pending, handle.channel, corr, ms), ms);
       this.pending.set(key, pending);
-      const write = this.sock.writeTracked(encodeFrame(frame), Date.now() + ms);
+      const write = writeTrackedBorrowed(this.sock, encodeFrame(frame), Date.now() + ms);
       handedToSocket = write.queued;
       write.completed.catch((error2) => {
         const current = this.pending.get(key);
@@ -11123,6 +11231,46 @@ class SubcClient {
       }
     }
   }
+  lastInboundAtMs = 0;
+  livenessProbe = null;
+  hasControlPending() {
+    for (const pending of this.pending.values()) {
+      if (pending.handle === null)
+        return true;
+    }
+    return false;
+  }
+  probeLivenessAfterDeadline() {
+    if (this.livenessProbe || this.closeStarted || this.closedErr)
+      return;
+    if (this.hasControlPending())
+      return;
+    const sock = this.sock;
+    const generation = this.generation;
+    let corr;
+    try {
+      corr = this.allocateCorr();
+    } catch {
+      return;
+    }
+    const t0 = Date.now();
+    const ping = buildFrame(FrameType.Ping, buildFlags(false, Priority.Interactive, false, AdmissionClass.Normal), 0, 0, corr, new Uint8Array);
+    const probe = (async () => {
+      await writeBorrowed(sock, encodeFrame(ping), t0 + this.opts.livenessProbeWindowMs).catch(() => {});
+      await this.opts.sleep(this.opts.livenessProbeWindowMs);
+      if (this.sock !== sock || this.generation !== generation || this.closeStarted)
+        return;
+      if (this.lastInboundAtMs >= t0)
+        return;
+      if (this.hasControlPending())
+        return;
+      this.fail(new SocketClosedError(`liveness probe convicted a half-open socket: no inbound frame for ${this.opts.livenessProbeWindowMs}ms after a channel-0 Ping (deadline-no-drop settles preceded this); closing so the next call reconnects`));
+      sock.close();
+    })().finally(() => {
+      this.livenessProbe = null;
+    });
+    this.livenessProbe = probe;
+  }
   async ensureConnectedForManaged() {
     if (this.closeStarted)
       throw new SubcError("client closed");
@@ -11234,6 +11382,24 @@ class SubcClient {
     }
   }
   dispatch(frame) {
+    this.lastInboundAtMs = Date.now();
+    if (frame.header.channel === 0 && frame.header.ty === FrameType.Push) {
+      const observer = this.opts.onControlPush;
+      if (observer) {
+        let parsed = null;
+        try {
+          const body = this.parseJson(frame);
+          if (body && typeof body.op === "string")
+            parsed = { op: body.op, body };
+        } catch {}
+        if (parsed) {
+          try {
+            observer(parsed);
+          } catch {}
+        }
+      }
+      return;
+    }
     let handle = null;
     if (frame.header.channel !== 0) {
       handle = this.liveRoutes.get(frame.header.channel) ?? null;
@@ -11250,7 +11416,9 @@ class SubcClient {
       switch (frame.header.ty) {
         case FrameType.Push:
         case FrameType.StreamData:
-          pending.onProgress?.(frame.body);
+          try {
+            pending.onProgress?.(frame.body);
+          } catch {}
           return;
         case FrameType.Response:
         case FrameType.StreamEnd:
@@ -11270,7 +11438,7 @@ class SubcClient {
       return;
     }
     if (frame.header.ty === FrameType.Goodbye && handle) {
-      this.failHandle(handle, new SubcError("route closed by subc (GOODBYE)"));
+      this.failHandle(handle, new SubcError("route closed by subc (GOODBYE)", "route_closed"));
       if (this.liveRoutes.get(handle.channel) === handle)
         this.liveRoutes.delete(handle.channel);
       this.evictRouteHandle(handle);
@@ -11377,10 +11545,11 @@ class SubcClient {
     this.scheduleReconnectAfterDrop(error2);
   }
   encode(value) {
-    return new Uint8Array(Buffer.from(JSON.stringify(value), "utf8"));
+    return Buffer.from(JSON.stringify(value), "utf8");
   }
   parseJson(frame) {
-    return JSON.parse(Buffer.from(frame.body).toString("utf8"));
+    const b = frame.body;
+    return JSON.parse(Buffer.from(b.buffer, b.byteOffset, b.byteLength).toString("utf8"));
   }
 }
 function isConsumerReconnectTransient(err) {
@@ -11398,7 +11567,7 @@ function isConsumerReconnectTransient(err) {
   return code === "ECONNREFUSED" || code === "ECONNRESET" || code === "EPIPE" || code === "ETIMEDOUT" || code === "ENOENT";
 }
 function isRetryableRouteOpenCode(code) {
-  return code === "unknown_module" || code === "module_reloading" || code === "target_unavailable" || code === "module_timeout";
+  return code === "unknown_module" || code === "module_reloading" || code === "module_warming" || code === "target_unavailable" || code === "module_timeout";
 }
 async function connectionFileExists(path2) {
   try {
@@ -11416,7 +11585,9 @@ function normalizeConnectOptions(opts) {
     targetKind: opts.targetKind ?? DEFAULT_MANAGED_TARGET_KIND,
     reconnectBackoff: opts.reconnectBackoff ?? DEFAULT_RECONNECT_BACKOFF,
     sleep: opts.sleep ?? ((ms) => new Promise((resolve3) => setTimeout(resolve3, ms))),
-    timeoutArbitrationGraceMs: opts.timeoutArbitrationGraceMs ?? TIMEOUT_ARBITRATION_GRACE_MS
+    timeoutArbitrationGraceMs: opts.timeoutArbitrationGraceMs ?? TIMEOUT_ARBITRATION_GRACE_MS,
+    livenessProbeWindowMs: opts.livenessProbeWindowMs ?? LIVENESS_PROBE_WINDOW_MS,
+    onControlPush: opts.onControlPush
   };
 }
 function routeCacheKey(target, identity, consumerIdentity) {
@@ -11448,1071 +11619,221 @@ function causeMessage(cause) {
 function pendingKey(handle, corr) {
   return handle ? `${handle.channel}:${handle.epoch}:${corr}` : `0:0:${corr}`;
 }
-// ../../node_modules/.bun/@cortexkit+subc-client@0.5.0/node_modules/@cortexkit/subc-client/dist/provider.js
-import { Buffer as Buffer2 } from "node:buffer";
-var DEFAULT_HANDSHAKE_TIMEOUT_MS2 = 1e4;
-var BODY_READ_TIMEOUT_MS2 = 30000;
-var WRITE_TIMEOUT_MS = 30000;
-var DEFAULT_RESTORED_DEBOUNCE_MS = 250;
-var DEFAULT_PROVIDER_HANDLER_CAPACITY = 64;
-var HEALTH_CHECK_OP = "health.check";
-var HELLO_CORR = 1n;
+// ../aft-bridge/dist/subc-transport.js
+import { existsSync as existsSync3, statSync as statSync3 } from "node:fs";
 
-class AsyncPermitPool {
-  available;
-  waiters = [];
-  constructor(capacity) {
-    if (!Number.isInteger(capacity) || capacity <= 0) {
-      throw new SubcProviderError("provider handler capacity must be a positive integer", "invalid_handler_capacity");
-    }
-    this.available = capacity;
-  }
-  async acquire() {
-    if (this.available > 0) {
-      this.available -= 1;
-      return this.releaseOnce();
-    }
-    await new Promise((resolve3) => {
-      this.waiters.push(resolve3);
-    });
-    return this.releaseOnce();
-  }
-  releaseOnce() {
-    let released = false;
-    return () => {
-      if (released)
-        return;
-      released = true;
-      const next = this.waiters.shift();
-      if (next) {
-        next();
-      } else {
-        this.available += 1;
-      }
-    };
+// ../aft-bridge/dist/lifecycle-registry.js
+import { lstat } from "node:fs/promises";
+function asCanonicalRootPath(root) {
+  return root;
+}
+function asRootGeneration(generation) {
+  if (!Number.isSafeInteger(generation) || generation < 1) {
+    throw new RangeError("root generations must be positive safe integers");
   }
+  return generation;
 }
-
-class SubcProviderError extends Error {
-  code;
-  constructor(message, code) {
-    super(message);
-    this.code = code;
+function asConcretePoolId(id) {
+  return id;
+}
+var DEFAULT_LIFECYCLE_INTERVAL_MS = 5 * 60 * 1000;
+var DEFAULT_REALM = "default";
+function rootKey(root) {
+  return root;
+}
+function resultMeansPresent(result) {
+  if (typeof result === "boolean")
+    return result;
+  if (typeof result === "object" && result !== null && "exists" in result) {
+    return result.exists !== false;
   }
+  return true;
 }
-class SubcProvider {
-  sock;
-  currentConn;
-  opts;
-  closed;
-  resolveClosed = () => {
-    return;
+function isEnoent(error2) {
+  return typeof error2 === "object" && error2 !== null && "code" in error2 && error2.code === "ENOENT";
+}
+function closeCounts(result) {
+  const teardown = typeof result === "object" && result !== null ? result : undefined;
+  const sessions = teardown?.tornDownSessionCount;
+  const facades = teardown?.tornDownFacadeCount;
+  return {
+    sessions: typeof sessions === "number" && Number.isFinite(sessions) ? Math.max(0, sessions) : 0,
+    facades: typeof facades === "number" && Number.isFinite(facades) ? Math.max(0, facades) : 0
   };
-  closeStarted = false;
-  closedErr = null;
-  inflight = new Map;
-  pending = new Map;
-  liveRoutes = new Map;
-  connectionToken = newConnectionToken();
-  nextCorr = 1n;
-  ingressEpochDropCount = 0;
-  requestGate = new AsyncPermitPool(DEFAULT_PROVIDER_HANDLER_CAPACITY);
-  reconnecting = null;
-  generation = 1;
-  connectionEpoch = 1;
-  stateQueue = [];
-  drainingStateQueue = false;
-  restoredDebounceToken = 0;
-  storage;
-  constructor(sock, currentConn, opts, storage) {
-    this.sock = sock;
-    this.currentConn = currentConn;
-    this.opts = opts;
-    this.storage = storage;
-    this.closed = new Promise((resolve3) => {
-      this.resolveClosed = resolve3;
+}
+function defaultTimer() {
+  return {
+    setInterval(callback, delayMs) {
+      const handle = setInterval(callback, delayMs);
+      const maybeUnref = handle;
+      maybeUnref.unref?.();
+      return handle;
+    },
+    clearInterval(handle) {
+      clearInterval(handle);
+    }
+  };
+}
+
+class LifecycleRegistry {
+  realm;
+  intervalMs;
+  registrations = new Map;
+  registrationByPool = new WeakMap;
+  nextGenerationByRoot = new Map;
+  nextConcretePoolNumber = 1;
+  nextRegistrationSequence = 1;
+  timer;
+  statRoot;
+  demand;
+  onEvent;
+  intervalHandle = null;
+  sweepInFlight = null;
+  constructor(options = {}) {
+    this.realm = options.realm ?? DEFAULT_REALM;
+    this.intervalMs = options.intervalMs ?? DEFAULT_LIFECYCLE_INTERVAL_MS;
+    if (!Number.isFinite(this.intervalMs) || this.intervalMs <= 0) {
+      throw new RangeError("lifecycle interval must be a positive finite number");
+    }
+    const nativeTimer = defaultTimer();
+    this.timer = options.timer ?? (options.setInterval || options.clearInterval ? {
+      setInterval: options.setInterval ?? nativeTimer.setInterval,
+      clearInterval: options.clearInterval ?? nativeTimer.clearInterval
+    } : nativeTimer);
+    this.statRoot = options.stat ?? ((root) => lstat(root));
+    this.demand = options.demandCheck ?? (() => false);
+    this.onEvent = options.onEvent;
+  }
+  registerLifecyclePool(pool, options) {
+    if (!pool || typeof pool.closeProjectRoot !== "function") {
+      throw new TypeError("a lifecycle pool must provide closeProjectRoot");
+    }
+    if (typeof options?.evictOuterFacade !== "function") {
+      throw new TypeError("lifecycle registration requires evictOuterFacade");
+    }
+    if (typeof options.reapingEnabled !== "boolean") {
+      throw new TypeError("reapingEnabled must be a boolean");
+    }
+    const previous = this.registrationByPool.get(pool);
+    if (previous?.active)
+      this.deregisterInternal(previous);
+    const concretePoolId = asConcretePoolId(`pool-${this.nextConcretePoolNumber++}`);
+    const registrationIdentity = Object.freeze({
+      concretePoolId,
+      registrationSequence: this.nextRegistrationSequence++
     });
-    this.readLoop(sock, this.generation);
-    this.enqueueConnectionState({ state: "connected", epoch: this.connectionEpoch });
+    const internal = {
+      pool,
+      concretePoolId,
+      registrationIdentity,
+      reapingEnabled: options.reapingEnabled,
+      evictOuterFacade: options.evictOuterFacade,
+      roots: new Map,
+      handle: undefined,
+      active: true
+    };
+    const handle = {
+      registrationIdentity,
+      identity: registrationIdentity,
+      get concretePoolId() {
+        return concretePoolId;
+      },
+      get reapingEnabled() {
+        return internal.reapingEnabled;
+      },
+      deregister: () => {
+        this.deregisterInternal(internal);
+      }
+    };
+    internal.handle = handle;
+    this.registrations.set(concretePoolId, internal);
+    this.registrationByPool.set(pool, internal);
+    this.refreshTimer();
+    return handle;
   }
-  get droppedIngressFrames() {
-    return this.ingressEpochDropCount;
+  registerPool(pool, options) {
+    return this.registerLifecyclePool(pool, options);
   }
-  get conn() {
-    return this.currentConn;
+  registerRoot(poolId, root) {
+    const registration = this.currentRegistration(poolId);
+    if (!registration)
+      throw new Error(`unknown lifecycle pool ${poolId}`);
+    const key = rootKey(root);
+    const existing = registration.roots.get(key);
+    if (existing?.state === "live")
+      return existing.generation;
+    if (existing && !existing.synchronousPhaseComplete) {
+      throw new Error("root registration raced its synchronous close phase");
+    }
+    const next = (this.nextGenerationByRoot.get(`${poolId}\x00${key}`) ?? 0) + 1;
+    this.nextGenerationByRoot.set(`${poolId}\x00${key}`, next);
+    const entry = {
+      registration,
+      canonicalRoot: root,
+      generation: asRootGeneration(next),
+      state: "live",
+      consecutiveAbsences: 0,
+      tombstoned: false,
+      synchronousPhaseComplete: true,
+      closePromise: null,
+      eventEmitted: false,
+      cause: null
+    };
+    registration.roots.set(key, entry);
+    return entry.generation;
   }
-  currentEpoch() {
-    return this.connectionEpoch;
+  currentGeneration(poolId, root) {
+    return this.currentRoot(poolId, root)?.generation;
   }
-  async request(handle, body, opts = {}) {
-    this.assertLiveHandle(handle);
-    const corr = this.allocateCorr();
-    const key = routeKey(handle, corr);
-    const timeoutMs = opts.timeoutMs ?? WRITE_TIMEOUT_MS;
-    const frame = buildFrame(FrameType.Request, buildFlags(false, opts.priority ?? Priority.Interactive, false, opts.admissionClass ?? AdmissionClass.Normal), handle.channel, handle.epoch, corr, body);
-    return await new Promise((resolve3, reject) => {
-      const timer = setTimeout(() => {
-        if (this.pending.delete(key))
-          reject(new SubcProviderError("reverse request timed out", "request_timeout"));
-      }, timeoutMs);
-      this.pending.set(key, {
-        resolve: (response) => resolve3(response.body),
-        reject,
-        timer
-      });
-      this.sendOn(this.sock, this.generation, frame).catch((error2) => {
-        const pending = this.pending.get(key);
-        if (!pending)
-          return;
-        this.pending.delete(key);
-        clearTimeout(pending.timer);
-        reject(error2 instanceof Error ? error2 : new SubcProviderError(String(error2)));
-      });
-    });
+  isTombstoned(poolId, root, generation) {
+    const entry = this.currentRoot(poolId, root);
+    return entry?.generation === generation && entry.tombstoned;
   }
-  async push(handle, body, opts = {}) {
-    this.assertLiveHandle(handle);
-    await this.sendOn(this.sock, this.generation, buildFrame(FrameType.Push, buildFlags(false, opts.priority ?? Priority.Interactive, false, opts.admissionClass ?? AdmissionClass.Normal), handle.channel, handle.epoch, 0n, body));
+  isCurrentRegistration(identity) {
+    const registration = this.registrations.get(identity.concretePoolId);
+    return registration?.active === true && registration.registrationIdentity === identity;
   }
-  cancel(handle, corr) {
-    this.assertLiveHandle(handle);
-    this.sendOn(this.sock, this.generation, buildFrame(FrameType.Cancel, controlFlags(), handle.channel, handle.epoch, corr, new Uint8Array(0)));
+  isCurrentLiveGeneration(poolId, root, generation) {
+    const entry = this.currentRoot(poolId, root);
+    return entry?.generation === generation && entry.state === "live";
   }
-  closeRoute(handle) {
-    this.assertLiveHandle(handle);
-    this.liveRoutes.delete(handle.channel);
-    this.abortHandle(handle);
-    this.sendOn(this.sock, this.generation, buildFrame(FrameType.Goodbye, controlFlags(), handle.channel, handle.epoch, 0n, new Uint8Array(0)));
+  getRootSnapshot(poolId, root) {
+    const entry = this.currentRoot(poolId, root);
+    return entry ? this.snapshotRoot(entry) : undefined;
   }
-  static async connect(opts) {
-    if (opts.manifest.protocol_ver !== PROTOCOL_VERSION) {
-      throw new SubcProviderError(`manifest protocol_ver ${opts.manifest.protocol_ver} does not match client protocol ${PROTOCOL_VERSION}`, "invalid_manifest");
-    }
-    const normalized = normalizeProviderConnectOptions(opts);
-    const opened = await SubcProvider.openConnection(normalized);
-    return new SubcProvider(opened.sock, opened.conn, normalized, opened.ack.storage);
-  }
-  async close() {
-    if (!this.closeStarted) {
-      this.closeStarted = true;
-      this.cancelRestoredDebounce();
-      const sock = this.sock;
-      try {
-        await sendFrame(sock, buildFrame(FrameType.Goodbye, controlFlags(), 0, 0, 0n, new Uint8Array(0)));
-      } catch {} finally {
-        sock.close();
-        this.finishClosed();
-      }
-    }
-    await this.closed;
+  rootSnapshots(poolId) {
+    const entries = poolId ? [this.currentRegistration(poolId)].filter((registration) => registration != null) : [...this.registrations.values()];
+    return entries.flatMap((registration) => [...registration.roots.values()].map((entry) => this.snapshotRoot(entry)));
   }
-  static async openConnection(opts, onSocket) {
-    const conn = await readConnectionFile(opts.connectionFile);
-    const deadline = Date.now() + (opts.handshakeTimeoutMs ?? DEFAULT_HANDSHAKE_TIMEOUT_MS2);
-    const endpoint = conn.endpoints[0];
-    const sock = await SubcSocket.connect(endpoint.host, endpoint.port, deadline);
-    try {
-      onSocket?.(sock);
-      await authenticateClient(sock, conn, deadline);
-      await sendFrame(sock, buildHelloFrame(opts));
-      const ack = await expectHelloAck(sock, deadline);
-      return { sock, conn, ack };
-    } catch (err) {
-      sock.close();
-      throw err;
-    }
+  snapshot() {
+    return {
+      realm: this.realm,
+      intervalMs: this.intervalMs,
+      timerActive: this.intervalHandle !== null,
+      registrations: [...this.registrations.values()].map((registration) => ({
+        concretePoolId: registration.concretePoolId,
+        reapingEnabled: registration.reapingEnabled,
+        roots: [...registration.roots.values()].map((entry) => this.snapshotRoot(entry))
+      }))
+    };
   }
-  async readLoop(sock, generation) {
+  status() {
+    return this.snapshot();
+  }
+  async ensureRootForDemand(poolId, root) {
+    const registration = this.currentRegistration(poolId);
+    if (!registration)
+      return;
+    const existing = registration.roots.get(rootKey(root));
+    if (existing?.state === "live")
+      return existing.generation;
+    if (existing && !existing.synchronousPhaseComplete)
+      return;
+    let result;
     try {
-      for (;; ) {
-        const frame = await sock.readFrame(Number.POSITIVE_INFINITY, { afterHeaderMs: BODY_READ_TIMEOUT_MS2 });
-        const keepGoing = await this.dispatch(frame, sock, generation);
-        if (!keepGoing) {
-          if (this.sock === sock && this.generation === generation)
-            this.closeStarted = true;
-          break;
-        }
-      }
-    } catch (error2) {
-      if (this.sock === sock && this.generation === generation && !this.closeStarted) {
-        this.handleUnexpectedDrop(sock, generation, error2 instanceof Error ? error2 : new SubcProviderError(String(error2)));
-        return;
-      }
-    } finally {
-      if (this.sock === sock && this.generation === generation) {
-        sock.close();
-        if (this.closeStarted)
-          this.finishClosed();
-      }
-    }
-  }
-  async dispatch(frame, sock, generation) {
-    let handle = null;
-    if (frame.header.channel !== 0) {
-      handle = this.liveRoutes.get(frame.header.channel) ?? null;
-      if (!handle || handle.epoch !== frame.header.epoch) {
-        this.ingressEpochDropCount += 1;
-        return true;
-      }
-    }
-    if (handle) {
-      const pendingKey2 = routeKey(handle, frame.header.corr);
-      const pending = this.pending.get(pendingKey2);
-      if (pending) {
-        if (frame.header.ty === FrameType.Push || frame.header.ty === FrameType.StreamData)
-          return true;
-        if (frame.header.ty === FrameType.Response || frame.header.ty === FrameType.StreamEnd) {
-          this.pending.delete(pendingKey2);
-          clearTimeout(pending.timer);
-          pending.resolve(frame);
-          return true;
-        }
-        if (frame.header.ty === FrameType.Error) {
-          this.pending.delete(pendingKey2);
-          clearTimeout(pending.timer);
-          pending.reject(providerErrorFromFrame(frame));
-          return true;
-        }
-      }
-    }
-    switch (frame.header.ty) {
-      case FrameType.Ping:
-        if (frame.header.channel === 0) {
-          await this.sendOn(sock, generation, buildFrameWithVersion(frame.header.ver, FrameType.Pong, frame.header.flags, 0, 0, frame.header.corr, new Uint8Array(0)));
-        }
-        return true;
-      case FrameType.Goodbye:
-        if (!handle)
-          return false;
-        this.liveRoutes.delete(handle.channel);
-        this.abortHandle(handle);
-        await this.opts.onRouteGone?.(handle);
-        return true;
-      case FrameType.Cancel:
-        if (handle)
-          this.inflight.get(routeKey(handle, frame.header.corr))?.abort();
-        return true;
-      case FrameType.Request:
-        if (frame.header.channel === 0) {
-          await this.handleControlRequest(frame, sock, generation);
-        } else if (handle) {
-          this.handleDataRequest(frame, handle, sock, generation).catch((error2) => {
-            if (!this.closeStarted && this.sock === sock && this.generation === generation) {
-              console.warn("SubcProvider handler failed after its request was dispatched", error2);
-            }
-          });
-        }
-        return true;
-      default:
-        return true;
-    }
-  }
-  abortHandle(handle) {
-    const prefix = `${handle.channel}:${handle.epoch}:`;
-    for (const [key, controller] of this.inflight) {
-      if (key.startsWith(prefix))
-        controller.abort();
-    }
-    for (const [key, pending] of this.pending) {
-      if (!key.startsWith(prefix))
-        continue;
-      this.pending.delete(key);
-      clearTimeout(pending.timer);
-      pending.reject(new StaleRouteHandleError(handle));
-    }
-  }
-  abortGeneration(_generation) {
-    this.abortAllInflight();
-    for (const [key, pending] of this.pending) {
-      this.pending.delete(key);
-      clearTimeout(pending.timer);
-      pending.reject(new SubcProviderError("provider connection dropped", "connection_dropped"));
-    }
-    this.liveRoutes.clear();
-  }
-  abortAllInflight() {
-    for (const controller of this.inflight.values())
-      controller.abort();
-  }
-  async handleControlRequest(frame, sock, generation) {
-    const request = parseJson(frame.body);
-    if (request.op === HEALTH_CHECK_OP) {
-      this.handleHealthRequest(frame, sock, generation).catch((error2) => {
-        if (!this.closeStarted && this.sock === sock && this.generation === generation) {
-          console.warn("SubcProvider health handler failed after its request was dispatched", error2);
-        }
-      });
-      return;
-    }
-    if (request.op !== "route.bind") {
-      throw new SubcProviderError(`unsupported module control request ${request.op ?? "<missing op>"}`);
-    }
-    const boundChannel = numberField(request.route_channel, "route_channel");
-    const boundEpoch = numberField(request.epoch, "epoch");
-    const stale = this.liveRoutes.get(boundChannel);
-    if (stale) {
-      if (boundEpoch <= stale.epoch) {
-        await this.sendError(frame, "route_rejected", `route.bind epoch ${boundEpoch} does not supersede installed epoch ${stale.epoch} on channel ${boundChannel}`, controlFlags(), sock, generation);
-        return;
-      }
-      this.liveRoutes.delete(stale.channel);
-      this.abortHandle(stale);
-      await this.opts.onRouteGone?.(stale);
-    }
-    const tentative = createRouteHandle(boundChannel, boundEpoch, this.connectionToken);
-    const bindRequest = {
-      handle: tentative,
-      target: request.target,
-      identity: request.identity,
-      principal: request.principal,
-      consumer_capabilities: request.consumer_capabilities
-    };
-    let decision;
-    try {
-      decision = await this.opts.onBind?.(bindRequest);
-    } catch (error2) {
-      try {
-        await this.sendError(frame, "route_rejected", error2 instanceof Error ? error2.message : String(error2), controlFlags(), sock, generation);
-      } finally {
-        await this.opts.onRouteGone?.(tentative);
-      }
-      return;
-    }
-    const rejection = bindRejection(decision);
-    if (rejection) {
-      try {
-        await this.sendError(frame, rejection.code, rejection.message, controlFlags(), sock, generation);
-      } finally {
-        await this.opts.onRouteGone?.(tentative);
-      }
-      return;
-    }
-    try {
-      await this.sendOn(sock, generation, buildFrameWithVersion(frame.header.ver, FrameType.Response, controlFlags(), 0, 0, frame.header.corr, encodeJson({ op: "route.bind" })));
-    } catch (error2) {
-      await this.opts.onRouteGone?.(tentative);
-      throw error2;
-    }
-    if (this.sock !== sock || this.generation !== generation || this.closeStarted || this.closedErr) {
-      await this.opts.onRouteGone?.(tentative);
-      return;
-    }
-    this.liveRoutes.set(tentative.channel, tentative);
-    await this.opts.onBound?.(tentative);
-  }
-  async handleDataRequest(frame, handle, sock, generation) {
-    const { corr, ver } = frame.header;
-    const key = routeKey(handle, corr);
-    const controller = new AbortController;
-    this.inflight.set(key, controller);
-    const context = {
-      handle,
-      signal: controller.signal,
-      currentEpoch: () => this.connectionEpoch,
-      emit: async (eventBody, options = {}) => {
-        this.assertLiveHandle(handle);
-        if (controller.signal.aborted)
-          return;
-        await this.sendOn(sock, generation, buildFrameWithVersion(ver, FrameType.StreamData, buildFlags(false, options.priority ?? Priority.Interactive, false, options.admissionClass ?? AdmissionClass.Normal), handle.channel, handle.epoch, corr, eventBody));
-      }
-    };
-    const releasePermit = await (this.requestGate ?? new AsyncPermitPool(DEFAULT_PROVIDER_HANDLER_CAPACITY)).acquire();
-    const dataFlags = buildFlags(false, Priority.Interactive, false);
-    try {
-      const body = await this.opts.handler(handle, frame.body, context);
-      if (controller.signal.aborted)
-        return;
-      this.assertLiveHandle(handle);
-      if (body === undefined) {
-        await this.sendOn(sock, generation, buildFrameWithVersion(ver, FrameType.StreamEnd, dataFlags, handle.channel, handle.epoch, corr, new Uint8Array(0)));
-      } else if (body instanceof Uint8Array) {
-        await this.sendOn(sock, generation, buildFrameWithVersion(ver, FrameType.Response, dataFlags, handle.channel, handle.epoch, corr, body));
-      } else {
-        throw new SubcProviderError("provider handler must return a Uint8Array or void", "invalid_handler_response");
-      }
-    } catch (error2) {
-      if (error2 instanceof StaleRouteHandleError || controller.signal.aborted)
-        return;
-      await this.sendError(frame, error2 instanceof SubcProviderError && error2.code ? error2.code : "handler_error", error2 instanceof Error ? error2.message : String(error2), dataFlags, sock, generation);
-    } finally {
-      releasePermit();
-      if (this.inflight.get(key) === controller)
-        this.inflight.delete(key);
-    }
-  }
-  async handleHealthRequest(frame, sock, generation) {
-    const { corr, ver } = frame.header;
-    const key = `control:${generation}:${corr}`;
-    const controller = new AbortController;
-    this.inflight.set(key, controller);
-    const releasePermit = await (this.requestGate ?? new AsyncPermitPool(DEFAULT_PROVIDER_HANDLER_CAPACITY)).acquire();
-    try {
-      if (controller.signal.aborted)
-        return;
-      const report = await this.opts.health();
-      await this.sendOn(sock, generation, buildFrameWithVersion(ver, FrameType.Response, controlFlags(), 0, 0, corr, encodeJson({
-        op: HEALTH_CHECK_OP,
-        status: report.status,
-        ...report.detail === undefined ? {} : { detail: report.detail },
-        ...report.metrics === undefined ? {} : { metrics: report.metrics }
-      })));
-    } catch (error2) {
-      await this.sendError(frame, error2 instanceof SubcProviderError && error2.code ? error2.code : "health_error", error2 instanceof Error ? error2.message : String(error2), controlFlags(), sock, generation);
-    } finally {
-      releasePermit();
-      if (this.inflight.get(key) === controller)
-        this.inflight.delete(key);
-    }
-  }
-  async sendError(frame, code, message, flags, sock, generation) {
-    await this.sendOn(sock, generation, buildFrameWithVersion(frame.header.ver, FrameType.Error, flags, frame.header.channel, frame.header.epoch, frame.header.corr, encodeJson({ code, message })));
-  }
-  async sendOn(sock, generation, frame) {
-    if (this.sock !== sock || this.generation !== generation || this.closeStarted || this.closedErr)
-      return;
-    await sendFrame(sock, frame);
-  }
-  handleUnexpectedDrop(sock, generation, cause) {
-    if (this.closeStarted || this.sock !== sock || this.generation !== generation)
-      return;
-    this.cancelRestoredDebounce();
-    this.abortGeneration(generation);
-    this.generation += 1;
-    sock.close();
-    this.scheduleReconnectAfterDrop(cause, this.generation, sock);
-  }
-  scheduleReconnectAfterDrop(cause, generation, droppedSocket) {
-    if (this.closeStarted)
-      return;
-    const previous = this.reconnecting;
-    if (previous) {
-      if (!this.shouldSupersedeReconnect(previous, generation, droppedSocket))
-        return;
-      previous.superseded = true;
-      previous.socket?.close();
-    }
-    const cycle = {
-      generation,
-      socket: null,
-      socketDied: false,
-      superseded: false
-    };
-    this.reconnecting = cycle;
-    this.enqueueConnectionState({ state: "down", cause });
-    this.reconnectWithRetry(cycle).catch((err) => {
-      if (this.isCurrentReconnect(cycle) && !this.closeStarted) {
-        this.failFatal(err instanceof Error ? err : new SubcProviderError(String(err)));
-      }
-    }).finally(() => {
-      if (this.isCurrentReconnect(cycle))
-        this.reconnecting = null;
-    });
-  }
-  async reconnectWithRetry(cycle) {
-    let attempt = 0;
-    let delay = this.opts.reconnectBackoff.baseMs;
-    for (;; ) {
-      if (!this.isCurrentReconnect(cycle))
-        return;
-      if (this.closeStarted)
-        throw new SubcProviderError("provider closed");
-      cycle.socket = null;
-      cycle.socketDied = false;
-      attempt += 1;
-      this.enqueueReconnectState(cycle, attempt);
-      try {
-        const opened = await SubcProvider.openConnection(this.opts, (sock) => {
-          if (!this.isCurrentReconnect(cycle)) {
-            sock.close();
-            return;
-          }
-          cycle.socket = sock;
-        });
-        if (!this.isCurrentReconnect(cycle) || this.closeStarted) {
-          opened.sock.close();
-          if (this.closeStarted)
-            throw new SubcProviderError("provider closed");
-          return;
-        }
-        const epoch = this.replaceConnection(opened, cycle.generation);
-        this.reconnecting = null;
-        if (this.reconnecting !== null) {
-          throw new SubcProviderError("reconnect state must clear before restored", "reconnect_state");
-        }
-        this.scheduleRestored(cycle.generation, epoch);
-        return;
-      } catch (err) {
-        if (!this.isCurrentReconnect(cycle))
-          return;
-        if (cycle.socket)
-          cycle.socketDied = true;
-        if (this.closeStarted)
-          throw err;
-        if (!isProviderReconnectTransient(err))
-          throw err;
-        await this.opts.sleep(delay);
-        delay = Math.min(delay * 2, this.opts.reconnectBackoff.capMs);
-      }
-    }
-  }
-  isCurrentReconnect(cycle) {
-    return !cycle.superseded && this.reconnecting === cycle && this.generation === cycle.generation;
-  }
-  shouldSupersedeReconnect(cycle, generation, droppedSocket) {
-    return cycle.generation < generation || cycle.socketDied || cycle.socket === droppedSocket;
-  }
-  enqueueReconnectState(cycle, attempt) {
-    if (!this.isCurrentReconnect(cycle))
-      return;
-    this.enqueueConnectionState({ state: "reconnecting", attempt }, cycle.generation, cycle);
-  }
-  replaceConnection(opened, generation) {
-    this.sock.close();
-    this.sock = opened.sock;
-    this.currentConn = opened.conn;
-    this.storage = opened.ack.storage;
-    this.closedErr = null;
-    this.connectionEpoch += 1;
-    this.connectionToken = newConnectionToken();
-    this.liveRoutes.clear();
-    this.nextCorr = 1n;
-    this.readLoop(opened.sock, generation);
-    return this.connectionEpoch;
-  }
-  scheduleRestored(generation, epoch) {
-    if (!this.opts.onConnectionState)
-      return;
-    const token = ++this.restoredDebounceToken;
-    this.opts.sleep(this.opts.restoredDebounceMs).then(() => {
-      if (token === this.restoredDebounceToken && !this.closeStarted && this.sock && this.generation === generation && this.connectionEpoch === epoch) {
-        this.enqueueConnectionState({ state: "restored", epoch }, generation);
-      }
-    }).catch((err) => {
-      if (token === this.restoredDebounceToken && !this.closeStarted) {
-        console.warn("SubcProvider restored debounce timer failed", err);
-      }
-    });
-  }
-  cancelRestoredDebounce() {
-    this.restoredDebounceToken += 1;
-  }
-  enqueueConnectionState(event, generation, reconnect) {
-    if (!this.opts.onConnectionState)
-      return;
-    this.stateQueue.push({ event, generation, reconnect });
-    if (!this.drainingStateQueue)
-      this.drainConnectionStateQueue();
-  }
-  async drainConnectionStateQueue() {
-    if (this.drainingStateQueue)
-      return;
-    this.drainingStateQueue = true;
-    try {
-      while (this.stateQueue.length > 0) {
-        const queued = this.stateQueue[0];
-        if (this.closeStarted || queued.generation !== undefined && queued.generation !== this.generation || queued.reconnect?.superseded) {
-          this.stateQueue.shift();
-          continue;
-        }
-        const { event } = queued;
-        try {
-          await this.opts.onConnectionState?.(event);
-          this.stateQueue.shift();
-        } catch (err) {
-          if (event.state === "restored") {
-            console.warn("SubcProvider restored callback failed; retrying delivery", err);
-            await pauseBeforeStateRetry();
-            continue;
-          }
-          console.warn("SubcProvider connection-state callback failed", err);
-          this.stateQueue.shift();
-        }
-      }
-    } finally {
-      this.drainingStateQueue = false;
-      if (this.stateQueue.length > 0)
-        this.drainConnectionStateQueue();
-    }
-  }
-  isLiveHandle(handle) {
-    return belongsToConnection(handle, this.connectionToken) && this.liveRoutes.get(handle.channel) === handle;
-  }
-  assertLiveHandle(handle) {
-    if (!this.isLiveHandle(handle))
-      throw new StaleRouteHandleError(handle);
-  }
-  allocateCorr() {
-    const maximum = 0xffffffffffffffffn;
-    if (this.nextCorr > maximum) {
-      const error2 = new SubcProviderError("channel-0 correlation id allocator exhausted", "corr_exhausted");
-      this.handleUnexpectedDrop(this.sock, this.generation, error2);
-      throw error2;
-    }
-    const corr = this.nextCorr;
-    this.nextCorr += 1n;
-    return corr;
-  }
-  failFatal(err) {
-    if (!this.closedErr)
-      this.closedErr = err;
-    this.closeStarted = true;
-    this.cancelRestoredDebounce();
-    this.abortAllInflight();
-    this.sock.close();
-    this.finishClosed();
-  }
-  finishClosed() {
-    this.resolveClosed();
-  }
-}
-function routeKey(handle, corr) {
-  return `${handle.channel}:${handle.epoch}:${corr}`;
-}
-function providerErrorFromFrame(frame) {
-  try {
-    const body = parseJson(frame.body);
-    return new SubcProviderError(body.message ?? "subc error", body.code);
-  } catch {
-    return new SubcProviderError(Buffer2.from(frame.body).toString("utf8") || "subc error");
-  }
-}
-function launchNonce(opts) {
-  const nonce = opts.launchNonce ?? process.env[SUBC_LAUNCH_NONCE_ENV2];
-  return nonce && nonce.length > 0 ? nonce : undefined;
-}
-var SUBC_LAUNCH_NONCE_ENV2 = "SUBC_LAUNCH_NONCE";
-function normalizeProviderConnectOptions(opts) {
-  return {
-    connectionFile: opts.connectionFile,
-    manifest: opts.manifest,
-    handler: opts.handler,
-    health: opts.health ?? (() => ({ status: "ok" })),
-    handshakeTimeoutMs: opts.handshakeTimeoutMs,
-    controlOps: opts.controlOps,
-    onBind: opts.onBind,
-    onBound: opts.onBound,
-    onRouteGone: opts.onRouteGone,
-    reconnectBackoff: opts.reconnectBackoff ?? DEFAULT_RECONNECT_BACKOFF,
-    sleep: opts.sleep ?? ((ms) => new Promise((resolve3) => setTimeout(resolve3, ms))),
-    restoredDebounceMs: opts.restoredDebounceMs ?? DEFAULT_RESTORED_DEBOUNCE_MS,
-    onConnectionState: opts.onConnectionState,
-    launchNonce: opts.launchNonce
-  };
-}
-function normalizedControlOps(controlOps) {
-  if (controlOps === null)
-    return null;
-  const merged = new Set(controlOps ?? []);
-  merged.add(HEALTH_CHECK_OP);
-  return [...merged];
-}
-function buildHelloFrame(opts) {
-  const nonce = launchNonce(opts);
-  return buildFrame(FrameType.Hello, controlFlags(), 0, 0, HELLO_CORR, encodeJson({
-    manifest: normalizeManifest(opts.manifest),
-    protocol_ver: PROTOCOL_VERSION,
-    control_ops: normalizedControlOps(opts.controlOps),
-    ...nonce ? { launch_nonce: nonce } : {}
-  }));
-}
-function isProviderReconnectTransient(err) {
-  if (err instanceof SubcProviderError)
-    return err.code === "duplicate_module_id";
-  if (err instanceof SocketClosedError || err instanceof SocketTimeoutError)
-    return true;
-  if (err instanceof SocketWriteNotQueuedError || err instanceof SocketWriteQueuedError)
-    return true;
-  if (err instanceof AuthError)
-    return true;
-  if (err instanceof ConnectionFileError)
-    return false;
-  const code = errorCode2(err);
-  return code === "ECONNREFUSED" || code === "ECONNRESET" || code === "EPIPE" || code === "ETIMEDOUT" || code === "ENOENT";
-}
-function errorCode2(err) {
-  if (typeof err === "object" && err !== null && "code" in err) {
-    const code = err.code;
-    if (typeof code === "string")
-      return code;
-  }
-  return;
-}
-async function pauseBeforeStateRetry() {
-  await new Promise((resolve3) => setTimeout(resolve3, 0));
-}
-function controlFlags() {
-  return buildFlags(false, Priority.Passive, false);
-}
-async function sendFrame(sock, frame) {
-  await sock.write(encodeFrame(frame), Date.now() + WRITE_TIMEOUT_MS);
-}
-async function expectHelloAck(sock, deadline) {
-  const frame = await sock.readFrame(deadline, deadline);
-  switch (frame.header.ty) {
-    case FrameType.HelloAck: {
-      const ack = parseJson(frame.body);
-      if (ack.negotiated_ver !== PROTOCOL_VERSION) {
-        throw new SubcProviderError(`subc negotiated protocol ${ack.negotiated_ver}; expected exactly ${PROTOCOL_VERSION}`, "unsupported_version");
-      }
-      return ack;
-    }
-    case FrameType.Error: {
-      const error2 = parseJson(frame.body);
-      throw new SubcProviderError(`subc rejected HELLO: ${error2.code ?? "unknown"} — ${error2.message ?? "subc error"}`, error2.code);
-    }
-    default:
-      throw new SubcProviderError(`unexpected frame ${FrameType[frame.header.ty]} awaiting HELLO_ACK`);
-  }
-}
-function encodeJson(value) {
-  return new Uint8Array(Buffer2.from(JSON.stringify(value), "utf8"));
-}
-function parseJson(bytes) {
-  return JSON.parse(Buffer2.from(bytes).toString("utf8"));
-}
-function numberField(value, field) {
-  if (typeof value !== "number" || !Number.isInteger(value)) {
-    throw new SubcProviderError(`route.bind ${field} must be an integer`);
-  }
-  return value;
-}
-function bindRejection(decision) {
-  if (decision === undefined || decision === true)
-    return null;
-  if (decision === false) {
-    return { code: "route_rejected", message: "route.bind rejected by provider" };
-  }
-  if (decision.accept)
-    return null;
-  return {
-    code: decision.code ?? "route_rejected",
-    message: decision.message ?? "route.bind rejected by provider"
-  };
-}
-function normalizeManifest(manifest) {
-  return {
-    module_id: manifest.module_id,
-    module_version: manifest.module_version,
-    protocol_ver: manifest.protocol_ver,
-    trust_tier: manifest.trust_tier,
-    provides: manifest.provides.map(normalizeProviderRole),
-    consumes: manifest.consumes.map(normalizeConsumerRole),
-    scheduled_tasks: manifest.scheduled_tasks.map(normalizeScheduledTask),
-    bindings: {
-      storage: {
-        kind: manifest.bindings.storage.kind,
-        scope: manifest.bindings.storage.scope,
-        owns_schema: manifest.bindings.storage.owns_schema
-      },
-      vault_grants: manifest.bindings.vault_grants.map((grant) => ({
-        secret: grant.secret,
-        reason: grant.reason
-      })),
-      identity: {
-        requires: [...manifest.bindings.identity.requires],
-        optional: [...manifest.bindings.identity.optional]
-      }
-    }
-  };
-}
-function normalizeProviderRole(role) {
-  switch (role.role) {
-    case "tool_provider":
-      return {
-        role: "tool_provider",
-        tools: role.tools.map((tool) => ({
-          name: tool.name,
-          ...tool.description === undefined ? {} : { description: tool.description },
-          execution_mode: tool.execution_mode,
-          schema: tool.schema
-        })),
-        identity_scope: [...role.identity_scope],
-        concurrency: role.concurrency,
-        emits_push: role.emits_push,
-        sub_supervises: role.sub_supervises
-      };
-    case "pipeline_stage":
-      return {
-        role: "pipeline_stage",
-        stage: role.stage,
-        applies_to: {
-          provider: role.applies_to.provider,
-          model: role.applies_to.model
-        },
-        interface: role.interface,
-        declares_frozen_floor: role.declares_frozen_floor,
-        needs_signals: [...role.needs_signals],
-        conformance_class: role.conformance_class
-      };
-    case "management_surface":
-      return {
-        role: "management_surface",
-        operations: role.operations.map((operation) => ({
-          name: operation.name,
-          kind: operation.kind
-        })),
-        config_schema: role.config_schema,
-        observability: role.observability.map((surface) => ({
-          name: surface.name,
-          kind: surface.kind
-        })),
-        identity_scope: [...role.identity_scope]
-      };
-    case "internal_service":
-      return {
-        role: "internal_service",
-        service_id: role.service_id,
-        transport: role.transport,
-        agent_facing: role.agent_facing,
-        operations: [...role.operations]
-      };
-  }
-}
-function normalizeConsumerRole(role) {
-  switch (role.role) {
-    case "tool_client":
-      return { role: "tool_client", of: [...role.of] };
-    case "llm_client":
-      return { role: "llm_client", via: role.via, auth: role.auth };
-    case "service_client":
-      return { role: "service_client", of: [...role.of] };
-  }
-}
-function normalizeScheduledTask(task) {
-  return {
-    task_id: task.task_id,
-    eligibility: {
-      cooldown: task.eligibility.cooldown,
-      window: task.eligibility.window
-    },
-    lease_scope: task.lease_scope,
-    renews_during_calls: task.renews_during_calls,
-    toolset: [...task.toolset],
-    model_policy: {
-      tier: task.model_policy.tier,
-      fallback_chain: [...task.model_policy.fallback_chain]
-    },
-    step_cap: task.step_cap,
-    circuit_breaker: {
-      identical_failures: task.circuit_breaker.identical_failures
-    }
-  };
-}
-// ../aft-bridge/dist/subc-transport.js
-import { existsSync as existsSync3, statSync as statSync3 } from "node:fs";
-
-// ../aft-bridge/dist/lifecycle-registry.js
-import { lstat } from "node:fs/promises";
-function asCanonicalRootPath(root) {
-  return root;
-}
-function asRootGeneration(generation) {
-  if (!Number.isSafeInteger(generation) || generation < 1) {
-    throw new RangeError("root generations must be positive safe integers");
-  }
-  return generation;
-}
-function asConcretePoolId(id) {
-  return id;
-}
-var DEFAULT_LIFECYCLE_INTERVAL_MS = 5 * 60 * 1000;
-var DEFAULT_REALM = "default";
-function rootKey(root) {
-  return root;
-}
-function resultMeansPresent(result) {
-  if (typeof result === "boolean")
-    return result;
-  if (typeof result === "object" && result !== null && "exists" in result) {
-    return result.exists !== false;
-  }
-  return true;
-}
-function isEnoent(error2) {
-  return typeof error2 === "object" && error2 !== null && "code" in error2 && error2.code === "ENOENT";
-}
-function closeCounts(result) {
-  const teardown = typeof result === "object" && result !== null ? result : undefined;
-  const sessions = teardown?.tornDownSessionCount;
-  const facades = teardown?.tornDownFacadeCount;
-  return {
-    sessions: typeof sessions === "number" && Number.isFinite(sessions) ? Math.max(0, sessions) : 0,
-    facades: typeof facades === "number" && Number.isFinite(facades) ? Math.max(0, facades) : 0
-  };
-}
-function defaultTimer() {
-  return {
-    setInterval(callback, delayMs) {
-      const handle = setInterval(callback, delayMs);
-      const maybeUnref = handle;
-      maybeUnref.unref?.();
-      return handle;
-    },
-    clearInterval(handle) {
-      clearInterval(handle);
-    }
-  };
-}
-
-class LifecycleRegistry {
-  realm;
-  intervalMs;
-  registrations = new Map;
-  registrationByPool = new WeakMap;
-  nextGenerationByRoot = new Map;
-  nextConcretePoolNumber = 1;
-  nextRegistrationSequence = 1;
-  timer;
-  statRoot;
-  demand;
-  onEvent;
-  intervalHandle = null;
-  sweepInFlight = null;
-  constructor(options = {}) {
-    this.realm = options.realm ?? DEFAULT_REALM;
-    this.intervalMs = options.intervalMs ?? DEFAULT_LIFECYCLE_INTERVAL_MS;
-    if (!Number.isFinite(this.intervalMs) || this.intervalMs <= 0) {
-      throw new RangeError("lifecycle interval must be a positive finite number");
-    }
-    const nativeTimer = defaultTimer();
-    this.timer = options.timer ?? (options.setInterval || options.clearInterval ? {
-      setInterval: options.setInterval ?? nativeTimer.setInterval,
-      clearInterval: options.clearInterval ?? nativeTimer.clearInterval
-    } : nativeTimer);
-    this.statRoot = options.stat ?? ((root) => lstat(root));
-    this.demand = options.demandCheck ?? (() => false);
-    this.onEvent = options.onEvent;
-  }
-  registerLifecyclePool(pool, options) {
-    if (!pool || typeof pool.closeProjectRoot !== "function") {
-      throw new TypeError("a lifecycle pool must provide closeProjectRoot");
-    }
-    if (typeof options?.evictOuterFacade !== "function") {
-      throw new TypeError("lifecycle registration requires evictOuterFacade");
-    }
-    if (typeof options.reapingEnabled !== "boolean") {
-      throw new TypeError("reapingEnabled must be a boolean");
-    }
-    const previous = this.registrationByPool.get(pool);
-    if (previous?.active)
-      this.deregisterInternal(previous);
-    const concretePoolId = asConcretePoolId(`pool-${this.nextConcretePoolNumber++}`);
-    const registrationIdentity = Object.freeze({
-      concretePoolId,
-      registrationSequence: this.nextRegistrationSequence++
-    });
-    const internal = {
-      pool,
-      concretePoolId,
-      registrationIdentity,
-      reapingEnabled: options.reapingEnabled,
-      evictOuterFacade: options.evictOuterFacade,
-      roots: new Map,
-      handle: undefined,
-      active: true
-    };
-    const handle = {
-      registrationIdentity,
-      identity: registrationIdentity,
-      get concretePoolId() {
-        return concretePoolId;
-      },
-      get reapingEnabled() {
-        return internal.reapingEnabled;
-      },
-      deregister: () => {
-        this.deregisterInternal(internal);
-      }
-    };
-    internal.handle = handle;
-    this.registrations.set(concretePoolId, internal);
-    this.registrationByPool.set(pool, internal);
-    this.refreshTimer();
-    return handle;
-  }
-  registerPool(pool, options) {
-    return this.registerLifecyclePool(pool, options);
-  }
-  registerRoot(poolId, root) {
-    const registration = this.currentRegistration(poolId);
-    if (!registration)
-      throw new Error(`unknown lifecycle pool ${poolId}`);
-    const key = rootKey(root);
-    const existing = registration.roots.get(key);
-    if (existing?.state === "live")
-      return existing.generation;
-    if (existing && !existing.synchronousPhaseComplete) {
-      throw new Error("root registration raced its synchronous close phase");
-    }
-    const next = (this.nextGenerationByRoot.get(`${poolId}\x00${key}`) ?? 0) + 1;
-    this.nextGenerationByRoot.set(`${poolId}\x00${key}`, next);
-    const entry = {
-      registration,
-      canonicalRoot: root,
-      generation: asRootGeneration(next),
-      state: "live",
-      consecutiveAbsences: 0,
-      tombstoned: false,
-      synchronousPhaseComplete: true,
-      closePromise: null,
-      eventEmitted: false,
-      cause: null
-    };
-    registration.roots.set(key, entry);
-    return entry.generation;
-  }
-  currentGeneration(poolId, root) {
-    return this.currentRoot(poolId, root)?.generation;
-  }
-  isTombstoned(poolId, root, generation) {
-    const entry = this.currentRoot(poolId, root);
-    return entry?.generation === generation && entry.tombstoned;
-  }
-  isCurrentRegistration(identity) {
-    const registration = this.registrations.get(identity.concretePoolId);
-    return registration?.active === true && registration.registrationIdentity === identity;
-  }
-  isCurrentLiveGeneration(poolId, root, generation) {
-    const entry = this.currentRoot(poolId, root);
-    return entry?.generation === generation && entry.state === "live";
-  }
-  getRootSnapshot(poolId, root) {
-    const entry = this.currentRoot(poolId, root);
-    return entry ? this.snapshotRoot(entry) : undefined;
-  }
-  rootSnapshots(poolId) {
-    const entries = poolId ? [this.currentRegistration(poolId)].filter((registration) => registration != null) : [...this.registrations.values()];
-    return entries.flatMap((registration) => [...registration.roots.values()].map((entry) => this.snapshotRoot(entry)));
-  }
-  snapshot() {
-    return {
-      realm: this.realm,
-      intervalMs: this.intervalMs,
-      timerActive: this.intervalHandle !== null,
-      registrations: [...this.registrations.values()].map((registration) => ({
-        concretePoolId: registration.concretePoolId,
-        reapingEnabled: registration.reapingEnabled,
-        roots: [...registration.roots.values()].map((entry) => this.snapshotRoot(entry))
-      }))
-    };
-  }
-  status() {
-    return this.snapshot();
-  }
-  async ensureRootForDemand(poolId, root) {
-    const registration = this.currentRegistration(poolId);
-    if (!registration)
-      return;
-    const existing = registration.roots.get(rootKey(root));
-    if (existing?.state === "live")
-      return existing.generation;
-    if (existing && !existing.synchronousPhaseComplete)
-      return;
-    let result;
-    try {
-      result = await this.demand(root, poolId);
-    } catch {
-      return;
+      result = await this.demand(root, poolId);
+    } catch {
+      return;
     }
     if (!resultMeansPresent(result))
       return;
@@ -12764,7 +12085,14 @@ class SubcTransportShuttingDownError extends SubcCallError {
 }
 var AFT_MODULE_ID = "aft";
 var MAX_CONSECUTIVE_TRANSPORT_FAILURES = 3;
+var RECONNECT_RETRY_FLOOR_MS = 100;
+var RECONNECT_RETRY_CAP_MS = 2000;
+var ROUTE_OPEN_RELOAD_WAIT_CAP_MS = 15000;
+var ROUTE_OPEN_RELOAD_WAIT_EXHAUSTED_SUFFIX = " The AFT daemon module did not return within the 15s reload window.";
 var BG_STABLE_MS = 5000;
+function reconnectBackoffMs(attempt) {
+  return Math.min(RECONNECT_RETRY_FLOOR_MS * 2 ** Math.min(attempt, 6), RECONNECT_RETRY_CAP_MS);
+}
 var BG_LIFECYCLE_LOG_INTERVAL_MS = 60000;
 var BG_DISPATCH_PROBE_INTERVAL_MS = 60000;
 var DEFAULT_SESSION_ID = "__default__";
@@ -13028,6 +12356,8 @@ class BgSubscription {
           giveUp("stopped");
           return;
         }
+        if (Date.now() - subscribedAt >= BG_STABLE_MS)
+          backoffAttempt = 0;
         beginReconnect();
       } catch (err) {
         const routeId2 = this.routeId(route);
@@ -13052,8 +12382,7 @@ class BgSubscription {
       giveUp("stopped");
   }
   async backoff(attempt) {
-    const ms = Math.min(100 * 2 ** Math.min(attempt, 6), 2000);
-    await this.sleep(ms);
+    await this.sleep(reconnectBackoffMs(attempt));
   }
 }
 function isRecord(value) {
@@ -13068,6 +12397,15 @@ function isAbsentRootRouteError(err) {
 function absentRootError(root) {
   return new SubcError(`invalid route project root: project root does not exist: ${root}`, "config_divergence");
 }
+function reloadWindowExhaustedError(error2) {
+  if (error2 instanceof Error) {
+    try {
+      error2.message += ROUTE_OPEN_RELOAD_WAIT_EXHAUSTED_SUFFIX;
+      return error2;
+    } catch {}
+  }
+  return new Error(`${String(error2)}${ROUTE_OPEN_RELOAD_WAIT_EXHAUSTED_SUFFIX}`);
+}
 function safeCloseRoute(client, route) {
   try {
     client.closeRouteChannel(route).catch(() => {
@@ -13179,6 +12517,7 @@ class SubcTransportPool {
   onBgEventsNudge;
   onBgEventsNudgeRef;
   bgBackoffSleep;
+  routeRetrySleep;
   bgDispatchProbeIntervalMs;
   lifecycleDemandCheck;
   onLifecycleEvent;
@@ -13189,6 +12528,9 @@ class SubcTransportPool {
   outerFacadeEvictor;
   client = null;
   connecting = null;
+  routeReopenRetryDelayMs = RECONNECT_RETRY_FLOOR_MS;
+  routeReopenRetry = null;
+  routeReopenRetryMs = null;
   sessions = new Map;
   rootIndex = new Map;
   dormantRoots = new Map;
@@ -13209,6 +12551,7 @@ class SubcTransportPool {
     this.onBgEventsNudge = options.onBgEventsNudge;
     this.onBgEventsNudgeRef = options.onBgEventsNudgeRef;
     this.bgBackoffSleep = options.bgBackoffSleep ?? ((ms) => new Promise((resolve4) => setTimeout(resolve4, ms)));
+    this.routeRetrySleep = options.routeRetrySleep ?? ((ms) => new Promise((resolve4) => setTimeout(resolve4, ms)));
     this.bgDispatchProbeIntervalMs = options.bgDispatchProbeIntervalMs ?? BG_DISPATCH_PROBE_INTERVAL_MS;
     const lifecycle = options.lifecycle;
     const demandCheck = options.lifecycleDemandCheck ?? options.demandCheck ?? lifecycle?.demandCheck;
@@ -13661,6 +13004,23 @@ class SubcTransportPool {
           throw error2;
         }
       };
+      const openRouteAfterReloadWindow = async () => {
+        let reloadWaitedMs = 0;
+        while (true) {
+          try {
+            return await openRoute();
+          } catch (error2) {
+            if (!isRouteOpenReloadWindowError(error2))
+              throw error2;
+            const { delayMs, wait } = this.waitForRouteReopenBackoff();
+            if (reloadWaitedMs + delayMs > ROUTE_OPEN_RELOAD_WAIT_CAP_MS) {
+              throw reloadWindowExhaustedError(error2);
+            }
+            reloadWaitedMs += delayMs;
+            await wait;
+          }
+        }
+      };
       const clearRouteEntry = (entry) => {
         if (record.routeEntry !== entry)
           return;
@@ -13697,7 +13057,7 @@ class SubcTransportPool {
         this.ensureBgSubscription(identity, record);
         return reply;
       };
-      let routeAndEntry = await openRoute();
+      let routeAndEntry = await openRouteAfterReloadWindow();
       try {
         return await requestOnRoute(routeAndEntry.route);
       } catch (error2) {
@@ -13705,9 +13065,12 @@ class SubcTransportPool {
           throw this.annotateReapError(error2, record);
         if (isRouteProvenAbsentError(error2) && this.isCurrentSession(key, record) && this.client === client) {
           clearRouteEntry(routeAndEntry.entry);
-          routeAndEntry = await openRoute();
+          await this.waitForRouteReopenBackoff().wait;
+          routeAndEntry = await openRouteAfterReloadWindow();
           try {
-            return await requestOnRoute(routeAndEntry.route);
+            const reply = await requestOnRoute(routeAndEntry.route);
+            this.resetRouteReopenBackoff();
+            return reply;
           } catch (retryError) {
             if (this.isReapInduced(record))
               throw this.annotateReapError(retryError, record);
@@ -13727,6 +13090,27 @@ class SubcTransportPool {
       this.deleteSessionIfEmpty(key, record);
     }
   }
+  waitForRouteReopenBackoff() {
+    const pending = this.routeReopenRetry;
+    const pendingDelay = this.routeReopenRetryMs;
+    if (pending && pendingDelay !== null)
+      return { delayMs: pendingDelay, wait: pending };
+    const delayMs = this.routeReopenRetryDelayMs;
+    this.routeReopenRetryDelayMs = Math.min(delayMs * 2, RECONNECT_RETRY_CAP_MS);
+    let retry;
+    retry = Promise.resolve().then(() => this.routeRetrySleep(delayMs)).finally(() => {
+      if (this.routeReopenRetry === retry) {
+        this.routeReopenRetry = null;
+        this.routeReopenRetryMs = null;
+      }
+    });
+    this.routeReopenRetry = retry;
+    this.routeReopenRetryMs = delayMs;
+    return { delayMs, wait: retry };
+  }
+  resetRouteReopenBackoff() {
+    this.routeReopenRetryDelayMs = RECONNECT_RETRY_FLOOR_MS;
+  }
   async ensureClient() {
     if (this.shuttingDown)
       throw new SubcTransportShuttingDownError;
@@ -14009,6 +13393,12 @@ function isRouteGoodbyeError(error2) {
   }
   return error2.code === "route_closed" && error2.message.includes("route closed by subc");
 }
+function isRouteOpenReloadWindowError(error2) {
+  if (error2 === null || typeof error2 !== "object")
+    return false;
+  const code = error2.code;
+  return code === "module_reloading" || code === "module_warming" || code === "target_unavailable";
+}
 function hasEngineResponse(error2) {
   const response = error2.response;
   if (response !== null && typeof response === "object")
@@ -14333,7 +13723,16 @@ function platformKey(platform = process.platform, arch = process.arch) {
   }
   return key;
 }
+function logBinaryResolution(resolution) {
+  log(`Resolved binary from ${resolution.source}: ${resolution.path}`);
+}
 function findBinarySync(expectedVersion) {
+  const resolution = findBinarySyncInner(expectedVersion);
+  if (resolution)
+    logBinaryResolution(resolution);
+  return resolution?.path ?? null;
+}
+function findBinarySyncInner(expectedVersion) {
   const ext = process.platform === "win32" ? ".exe" : "";
   const env = { ...process.env };
   const pluginVersion = expectedVersion ?? (() => {
@@ -14347,8 +13746,9 @@ function findBinarySync(expectedVersion) {
   if (pluginVersion) {
     const tag = pluginVersion.startsWith("v") ? pluginVersion : `v${pluginVersion}`;
     const versionCached = cachedBinaryPathFromEnv(tag, env, ext);
-    if (versionCached && isExpectedCachedBinary2(versionCached, pluginVersion))
-      return versionCached;
+    if (versionCached && isExpectedCachedBinary2(versionCached, pluginVersion)) {
+      return { path: versionCached, source: "versioned cache" };
+    }
   }
   try {
     const key = platformKey();
@@ -14363,7 +13763,7 @@ function findBinarySync(expectedVersion) {
         warn(`npm platform package binary v${npmVersion} does not match plugin v${pluginVersion}; skipping (continuing to PATH lookup)`);
       } else {
         const copied = copyToVersionedCache(resolved, npmVersion);
-        return copied ?? resolved;
+        return { path: copied ?? resolved, source: "npm platform package" };
       }
     }
   } catch {}
@@ -14381,27 +13781,28 @@ function findBinarySync(expectedVersion) {
       }
       const usable = probeBinaryCandidate(candidate, "PATH", expectedVersion);
       if (usable)
-        return usable;
+        return { path: usable, source: "PATH" };
     }
   } catch {}
   const cargoPath = join7(homeDirFromEnv(env), ".cargo", "bin", `aft${ext}`);
   if (existsSync5(cargoPath)) {
     const usable = probeBinaryCandidate(cargoPath, "cargo", expectedVersion);
     if (usable)
-      return usable;
+      return { path: usable, source: "cargo" };
   }
   return null;
 }
 async function findBinary(expectedVersion) {
   const syncResult = findBinarySync(expectedVersion);
   if (syncResult) {
-    log(`Resolved binary: ${syncResult}`);
     return syncResult;
   }
   log("Binary not found locally, attempting auto-download...");
   const downloaded = await ensureBinaryForResolver(expectedVersion);
-  if (downloaded)
+  if (downloaded) {
+    logBinaryResolution({ path: downloaded, source: "auto-download" });
     return downloaded;
+  }
   throw new Error([
     "Could not find the `aft` binary.",
     "",
@@ -16419,11 +15820,16 @@ function normalizeKey(projectRoot) {
   return canonicalizeProjectRoot(projectRoot);
 }
 // ../aft-bridge/dist/revivable-transport.js
+var REVIVAL_RETRY_FLOOR_MS = 100;
+var REVIVAL_RETRY_CAP_MS = 2000;
+
 class RevivableTransportPool {
   createPool;
   onBinaryReplaced;
   activePool;
   revival = null;
+  revivalRetryDelayMs = REVIVAL_RETRY_FLOOR_MS;
+  revivalRetryNotBefore = 0;
   transports = new Map;
   configureOverrides = new Map;
   editSlotSurvivesCaptured = false;
@@ -16517,12 +15923,30 @@ class RevivableTransportPool {
       return this.activePool;
     if (this.revival)
       return this.revival;
+    const delay = Math.max(0, this.revivalRetryNotBefore - Date.now());
+    if (delay > 0) {
+      let scheduled;
+      scheduled = new Promise((resolve7) => setTimeout(resolve7, delay)).then(() => {
+        if (this.revival === scheduled)
+          this.revival = null;
+        return this.ensureActivePool();
+      });
+      this.revival = scheduled;
+      scheduled.then(() => {
+        return;
+      }, () => {
+        return;
+      });
+      return scheduled;
+    }
     warn("transport was shut down but new demand arrived — reviving (host quit hook fired without process exit?)");
-    const revival = this.createPool().then((pool) => {
+    const revival = Promise.resolve().then(() => this.createPool()).then((pool) => {
       for (const [key, value] of this.configureOverrides) {
         pool.setConfigureOverride(key, value);
       }
       this.activePool = pool;
+      this.revivalRetryDelayMs = REVIVAL_RETRY_FLOOR_MS;
+      this.revivalRetryNotBefore = 0;
       for (const [root, transport] of this.transports) {
         transport.refreshStatusSubscription(pool.getActiveBridgeForRoot(root));
       }
@@ -16533,6 +15957,8 @@ class RevivableTransportPool {
       if (this.revival === revival)
         this.revival = null;
     }, () => {
+      this.revivalRetryNotBefore = Date.now() + this.revivalRetryDelayMs;
+      this.revivalRetryDelayMs = Math.min(this.revivalRetryDelayMs * 2, REVIVAL_RETRY_CAP_MS);
       if (this.revival === revival)
         this.revival = null;
     });
@@ -18019,523 +17445,523 @@ var import_comment_json = __toESM(require_src2(), 1);
 // ../../node_modules/.bun/zod@4.4.3/node_modules/zod/v4/classic/external.js
 var exports_external = {};
 __export(exports_external, {
-  xor: () => xor,
-  xid: () => xid2,
-  void: () => _void2,
-  uuidv7: () => uuidv7,
-  uuidv6: () => uuidv6,
-  uuidv4: () => uuidv4,
-  uuid: () => uuid2,
-  util: () => exports_util,
-  url: () => url,
-  uppercase: () => _uppercase,
-  unknown: () => unknown,
-  union: () => union,
-  undefined: () => _undefined3,
-  ulid: () => ulid2,
-  uint64: () => uint64,
-  uint32: () => uint32,
-  tuple: () => tuple,
-  trim: () => _trim,
-  treeifyError: () => treeifyError,
-  transform: () => transform,
-  toUpperCase: () => _toUpperCase,
-  toLowerCase: () => _toLowerCase,
-  toJSONSchema: () => toJSONSchema,
-  templateLiteral: () => templateLiteral,
-  symbol: () => symbol,
-  superRefine: () => superRefine,
-  success: () => success,
-  stringbool: () => stringbool,
-  stringFormat: () => stringFormat,
-  string: () => string2,
-  strictObject: () => strictObject,
-  startsWith: () => _startsWith,
-  slugify: () => _slugify,
-  size: () => _size,
-  setErrorMap: () => setErrorMap,
-  set: () => set,
-  safeParseAsync: () => safeParseAsync2,
-  safeParse: () => safeParse2,
-  safeEncodeAsync: () => safeEncodeAsync2,
-  safeEncode: () => safeEncode2,
-  safeDecodeAsync: () => safeDecodeAsync2,
-  safeDecode: () => safeDecode2,
-  registry: () => registry,
-  regexes: () => exports_regexes,
-  regex: () => _regex,
-  refine: () => refine,
-  record: () => record,
-  readonly: () => readonly,
-  property: () => _property,
-  promise: () => promise,
-  prettifyError: () => prettifyError,
-  preprocess: () => preprocess,
-  prefault: () => prefault,
-  positive: () => _positive,
-  pipe: () => pipe,
-  partialRecord: () => partialRecord,
-  parseAsync: () => parseAsync2,
-  parse: () => parse3,
-  overwrite: () => _overwrite,
-  optional: () => optional,
-  object: () => object,
-  number: () => number2,
-  nullish: () => nullish2,
-  nullable: () => nullable,
-  null: () => _null3,
-  normalize: () => _normalize,
-  nonpositive: () => _nonpositive,
-  nonoptional: () => nonoptional,
-  nonnegative: () => _nonnegative,
-  never: () => never,
-  negative: () => _negative,
-  nativeEnum: () => nativeEnum,
-  nanoid: () => nanoid2,
-  nan: () => nan,
-  multipleOf: () => _multipleOf,
-  minSize: () => _minSize,
-  minLength: () => _minLength,
-  mime: () => _mime,
-  meta: () => meta2,
-  maxSize: () => _maxSize,
-  maxLength: () => _maxLength,
-  map: () => map,
-  mac: () => mac2,
-  lte: () => _lte,
-  lt: () => _lt,
-  lowercase: () => _lowercase,
-  looseRecord: () => looseRecord,
-  looseObject: () => looseObject,
-  locales: () => exports_locales,
-  literal: () => literal,
-  length: () => _length,
-  lazy: () => lazy,
-  ksuid: () => ksuid2,
-  keyof: () => keyof,
-  jwt: () => jwt,
-  json: () => json,
-  iso: () => exports_iso,
-  ipv6: () => ipv62,
-  ipv4: () => ipv42,
-  invertCodec: () => invertCodec,
-  intersection: () => intersection,
-  int64: () => int64,
-  int32: () => int32,
-  int: () => int,
-  instanceof: () => _instanceof,
-  includes: () => _includes,
-  httpUrl: () => httpUrl,
-  hostname: () => hostname3,
-  hex: () => hex2,
-  hash: () => hash,
-  guid: () => guid2,
-  gte: () => _gte,
-  gt: () => _gt,
-  globalRegistry: () => globalRegistry,
-  getErrorMap: () => getErrorMap,
-  function: () => _function,
-  fromJSONSchema: () => fromJSONSchema,
-  formatError: () => formatError,
-  float64: () => float64,
-  float32: () => float32,
-  flattenError: () => flattenError,
-  file: () => file,
-  exactOptional: () => exactOptional,
-  enum: () => _enum2,
-  endsWith: () => _endsWith,
-  encodeAsync: () => encodeAsync2,
-  encode: () => encode2,
-  emoji: () => emoji2,
-  email: () => email2,
-  e164: () => e1642,
-  discriminatedUnion: () => discriminatedUnion,
-  describe: () => describe2,
-  decodeAsync: () => decodeAsync2,
-  decode: () => decode2,
-  date: () => date3,
-  custom: () => custom,
-  cuid2: () => cuid22,
-  cuid: () => cuid3,
-  core: () => exports_core2,
-  config: () => config,
-  coerce: () => exports_coerce,
-  codec: () => codec,
-  clone: () => clone,
-  cidrv6: () => cidrv62,
-  cidrv4: () => cidrv42,
-  check: () => check,
-  catch: () => _catch2,
-  boolean: () => boolean2,
-  bigint: () => bigint2,
-  base64url: () => base64url2,
-  base64: () => base642,
-  array: () => array,
-  any: () => any,
-  _function: () => _function,
-  _default: () => _default2,
-  _ZodString: () => _ZodString,
-  ZodXor: () => ZodXor,
-  ZodXID: () => ZodXID,
-  ZodVoid: () => ZodVoid,
-  ZodUnknown: () => ZodUnknown,
-  ZodUnion: () => ZodUnion,
-  ZodUndefined: () => ZodUndefined,
-  ZodUUID: () => ZodUUID,
-  ZodURL: () => ZodURL,
-  ZodULID: () => ZodULID,
-  ZodType: () => ZodType,
-  ZodTuple: () => ZodTuple,
-  ZodTransform: () => ZodTransform,
-  ZodTemplateLiteral: () => ZodTemplateLiteral,
-  ZodSymbol: () => ZodSymbol,
-  ZodSuccess: () => ZodSuccess,
-  ZodStringFormat: () => ZodStringFormat,
-  ZodString: () => ZodString,
-  ZodSet: () => ZodSet,
-  ZodRecord: () => ZodRecord,
-  ZodRealError: () => ZodRealError,
-  ZodReadonly: () => ZodReadonly,
-  ZodPromise: () => ZodPromise,
-  ZodPreprocess: () => ZodPreprocess,
-  ZodPrefault: () => ZodPrefault,
-  ZodPipe: () => ZodPipe,
-  ZodOptional: () => ZodOptional,
-  ZodObject: () => ZodObject,
-  ZodNumberFormat: () => ZodNumberFormat,
-  ZodNumber: () => ZodNumber,
-  ZodNullable: () => ZodNullable,
-  ZodNull: () => ZodNull,
-  ZodNonOptional: () => ZodNonOptional,
-  ZodNever: () => ZodNever,
-  ZodNanoID: () => ZodNanoID,
-  ZodNaN: () => ZodNaN,
-  ZodMap: () => ZodMap,
-  ZodMAC: () => ZodMAC,
-  ZodLiteral: () => ZodLiteral,
-  ZodLazy: () => ZodLazy,
-  ZodKSUID: () => ZodKSUID,
-  ZodJWT: () => ZodJWT,
-  ZodIssueCode: () => ZodIssueCode,
-  ZodIntersection: () => ZodIntersection,
-  ZodISOTime: () => ZodISOTime,
-  ZodISODuration: () => ZodISODuration,
-  ZodISODateTime: () => ZodISODateTime,
-  ZodISODate: () => ZodISODate,
-  ZodIPv6: () => ZodIPv6,
-  ZodIPv4: () => ZodIPv4,
-  ZodGUID: () => ZodGUID,
-  ZodFunction: () => ZodFunction,
-  ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind,
-  ZodFile: () => ZodFile,
-  ZodExactOptional: () => ZodExactOptional,
-  ZodError: () => ZodError,
-  ZodEnum: () => ZodEnum,
-  ZodEmoji: () => ZodEmoji,
-  ZodEmail: () => ZodEmail,
-  ZodE164: () => ZodE164,
-  ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
-  ZodDefault: () => ZodDefault,
-  ZodDate: () => ZodDate,
-  ZodCustomStringFormat: () => ZodCustomStringFormat,
-  ZodCustom: () => ZodCustom,
-  ZodCodec: () => ZodCodec,
-  ZodCatch: () => ZodCatch,
-  ZodCUID2: () => ZodCUID2,
-  ZodCUID: () => ZodCUID,
-  ZodCIDRv6: () => ZodCIDRv6,
-  ZodCIDRv4: () => ZodCIDRv4,
-  ZodBoolean: () => ZodBoolean,
-  ZodBigIntFormat: () => ZodBigIntFormat,
-  ZodBigInt: () => ZodBigInt,
-  ZodBase64URL: () => ZodBase64URL,
-  ZodBase64: () => ZodBase64,
-  ZodArray: () => ZodArray,
-  ZodAny: () => ZodAny,
-  TimePrecision: () => TimePrecision,
-  NEVER: () => NEVER,
-  $output: () => $output,
+  $brand: () => $brand,
   $input: () => $input,
-  $brand: () => $brand
+  $output: () => $output,
+  NEVER: () => NEVER,
+  TimePrecision: () => TimePrecision,
+  ZodAny: () => ZodAny,
+  ZodArray: () => ZodArray,
+  ZodBase64: () => ZodBase64,
+  ZodBase64URL: () => ZodBase64URL,
+  ZodBigInt: () => ZodBigInt,
+  ZodBigIntFormat: () => ZodBigIntFormat,
+  ZodBoolean: () => ZodBoolean,
+  ZodCIDRv4: () => ZodCIDRv4,
+  ZodCIDRv6: () => ZodCIDRv6,
+  ZodCUID: () => ZodCUID,
+  ZodCUID2: () => ZodCUID2,
+  ZodCatch: () => ZodCatch,
+  ZodCodec: () => ZodCodec,
+  ZodCustom: () => ZodCustom,
+  ZodCustomStringFormat: () => ZodCustomStringFormat,
+  ZodDate: () => ZodDate,
+  ZodDefault: () => ZodDefault,
+  ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
+  ZodE164: () => ZodE164,
+  ZodEmail: () => ZodEmail,
+  ZodEmoji: () => ZodEmoji,
+  ZodEnum: () => ZodEnum,
+  ZodError: () => ZodError,
+  ZodExactOptional: () => ZodExactOptional,
+  ZodFile: () => ZodFile,
+  ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind,
+  ZodFunction: () => ZodFunction,
+  ZodGUID: () => ZodGUID,
+  ZodIPv4: () => ZodIPv4,
+  ZodIPv6: () => ZodIPv6,
+  ZodISODate: () => ZodISODate,
+  ZodISODateTime: () => ZodISODateTime,
+  ZodISODuration: () => ZodISODuration,
+  ZodISOTime: () => ZodISOTime,
+  ZodIntersection: () => ZodIntersection,
+  ZodIssueCode: () => ZodIssueCode,
+  ZodJWT: () => ZodJWT,
+  ZodKSUID: () => ZodKSUID,
+  ZodLazy: () => ZodLazy,
+  ZodLiteral: () => ZodLiteral,
+  ZodMAC: () => ZodMAC,
+  ZodMap: () => ZodMap,
+  ZodNaN: () => ZodNaN,
+  ZodNanoID: () => ZodNanoID,
+  ZodNever: () => ZodNever,
+  ZodNonOptional: () => ZodNonOptional,
+  ZodNull: () => ZodNull,
+  ZodNullable: () => ZodNullable,
+  ZodNumber: () => ZodNumber,
+  ZodNumberFormat: () => ZodNumberFormat,
+  ZodObject: () => ZodObject,
+  ZodOptional: () => ZodOptional,
+  ZodPipe: () => ZodPipe,
+  ZodPrefault: () => ZodPrefault,
+  ZodPreprocess: () => ZodPreprocess,
+  ZodPromise: () => ZodPromise,
+  ZodReadonly: () => ZodReadonly,
+  ZodRealError: () => ZodRealError,
+  ZodRecord: () => ZodRecord,
+  ZodSet: () => ZodSet,
+  ZodString: () => ZodString,
+  ZodStringFormat: () => ZodStringFormat,
+  ZodSuccess: () => ZodSuccess,
+  ZodSymbol: () => ZodSymbol,
+  ZodTemplateLiteral: () => ZodTemplateLiteral,
+  ZodTransform: () => ZodTransform,
+  ZodTuple: () => ZodTuple,
+  ZodType: () => ZodType,
+  ZodULID: () => ZodULID,
+  ZodURL: () => ZodURL,
+  ZodUUID: () => ZodUUID,
+  ZodUndefined: () => ZodUndefined,
+  ZodUnion: () => ZodUnion,
+  ZodUnknown: () => ZodUnknown,
+  ZodVoid: () => ZodVoid,
+  ZodXID: () => ZodXID,
+  ZodXor: () => ZodXor,
+  _ZodString: () => _ZodString,
+  _default: () => _default2,
+  _function: () => _function,
+  any: () => any,
+  array: () => array,
+  base64: () => base642,
+  base64url: () => base64url2,
+  bigint: () => bigint2,
+  boolean: () => boolean2,
+  catch: () => _catch2,
+  check: () => check,
+  cidrv4: () => cidrv42,
+  cidrv6: () => cidrv62,
+  clone: () => clone,
+  codec: () => codec,
+  coerce: () => exports_coerce,
+  config: () => config,
+  core: () => exports_core2,
+  cuid: () => cuid3,
+  cuid2: () => cuid22,
+  custom: () => custom,
+  date: () => date3,
+  decode: () => decode2,
+  decodeAsync: () => decodeAsync2,
+  describe: () => describe2,
+  discriminatedUnion: () => discriminatedUnion,
+  e164: () => e1642,
+  email: () => email2,
+  emoji: () => emoji2,
+  encode: () => encode2,
+  encodeAsync: () => encodeAsync2,
+  endsWith: () => _endsWith,
+  enum: () => _enum2,
+  exactOptional: () => exactOptional,
+  file: () => file,
+  flattenError: () => flattenError,
+  float32: () => float32,
+  float64: () => float64,
+  formatError: () => formatError,
+  fromJSONSchema: () => fromJSONSchema,
+  function: () => _function,
+  getErrorMap: () => getErrorMap,
+  globalRegistry: () => globalRegistry,
+  gt: () => _gt,
+  gte: () => _gte,
+  guid: () => guid2,
+  hash: () => hash,
+  hex: () => hex2,
+  hostname: () => hostname3,
+  httpUrl: () => httpUrl,
+  includes: () => _includes,
+  instanceof: () => _instanceof,
+  int: () => int,
+  int32: () => int32,
+  int64: () => int64,
+  intersection: () => intersection,
+  invertCodec: () => invertCodec,
+  ipv4: () => ipv42,
+  ipv6: () => ipv62,
+  iso: () => exports_iso,
+  json: () => json,
+  jwt: () => jwt,
+  keyof: () => keyof,
+  ksuid: () => ksuid2,
+  lazy: () => lazy,
+  length: () => _length,
+  literal: () => literal,
+  locales: () => exports_locales,
+  looseObject: () => looseObject,
+  looseRecord: () => looseRecord,
+  lowercase: () => _lowercase,
+  lt: () => _lt,
+  lte: () => _lte,
+  mac: () => mac2,
+  map: () => map,
+  maxLength: () => _maxLength,
+  maxSize: () => _maxSize,
+  meta: () => meta2,
+  mime: () => _mime,
+  minLength: () => _minLength,
+  minSize: () => _minSize,
+  multipleOf: () => _multipleOf,
+  nan: () => nan,
+  nanoid: () => nanoid2,
+  nativeEnum: () => nativeEnum,
+  negative: () => _negative,
+  never: () => never,
+  nonnegative: () => _nonnegative,
+  nonoptional: () => nonoptional,
+  nonpositive: () => _nonpositive,
+  normalize: () => _normalize,
+  null: () => _null3,
+  nullable: () => nullable,
+  nullish: () => nullish2,
+  number: () => number2,
+  object: () => object,
+  optional: () => optional,
+  overwrite: () => _overwrite,
+  parse: () => parse3,
+  parseAsync: () => parseAsync2,
+  partialRecord: () => partialRecord,
+  pipe: () => pipe,
+  positive: () => _positive,
+  prefault: () => prefault,
+  preprocess: () => preprocess,
+  prettifyError: () => prettifyError,
+  promise: () => promise,
+  property: () => _property,
+  readonly: () => readonly,
+  record: () => record,
+  refine: () => refine,
+  regex: () => _regex,
+  regexes: () => exports_regexes,
+  registry: () => registry,
+  safeDecode: () => safeDecode2,
+  safeDecodeAsync: () => safeDecodeAsync2,
+  safeEncode: () => safeEncode2,
+  safeEncodeAsync: () => safeEncodeAsync2,
+  safeParse: () => safeParse2,
+  safeParseAsync: () => safeParseAsync2,
+  set: () => set,
+  setErrorMap: () => setErrorMap,
+  size: () => _size,
+  slugify: () => _slugify,
+  startsWith: () => _startsWith,
+  strictObject: () => strictObject,
+  string: () => string2,
+  stringFormat: () => stringFormat,
+  stringbool: () => stringbool,
+  success: () => success,
+  superRefine: () => superRefine,
+  symbol: () => symbol,
+  templateLiteral: () => templateLiteral,
+  toJSONSchema: () => toJSONSchema,
+  toLowerCase: () => _toLowerCase,
+  toUpperCase: () => _toUpperCase,
+  transform: () => transform,
+  treeifyError: () => treeifyError,
+  trim: () => _trim,
+  tuple: () => tuple,
+  uint32: () => uint32,
+  uint64: () => uint64,
+  ulid: () => ulid2,
+  undefined: () => _undefined3,
+  union: () => union,
+  unknown: () => unknown,
+  uppercase: () => _uppercase,
+  url: () => url,
+  util: () => exports_util,
+  uuid: () => uuid2,
+  uuidv4: () => uuidv4,
+  uuidv6: () => uuidv6,
+  uuidv7: () => uuidv7,
+  void: () => _void2,
+  xid: () => xid2,
+  xor: () => xor
 });
 
 // ../../node_modules/.bun/zod@4.4.3/node_modules/zod/v4/core/index.js
 var exports_core2 = {};
 __export(exports_core2, {
-  version: () => version,
-  util: () => exports_util,
-  treeifyError: () => treeifyError,
-  toJSONSchema: () => toJSONSchema,
-  toDotPath: () => toDotPath,
-  safeParseAsync: () => safeParseAsync,
-  safeParse: () => safeParse,
-  safeEncodeAsync: () => safeEncodeAsync,
-  safeEncode: () => safeEncode,
-  safeDecodeAsync: () => safeDecodeAsync,
-  safeDecode: () => safeDecode,
-  registry: () => registry,
-  regexes: () => exports_regexes,
-  process: () => process2,
-  prettifyError: () => prettifyError,
-  parseAsync: () => parseAsync,
-  parse: () => parse,
-  meta: () => meta,
-  locales: () => exports_locales,
-  isValidJWT: () => isValidJWT,
-  isValidBase64URL: () => isValidBase64URL,
-  isValidBase64: () => isValidBase64,
-  initializeContext: () => initializeContext,
-  globalRegistry: () => globalRegistry,
-  globalConfig: () => globalConfig,
-  formatError: () => formatError,
-  flattenError: () => flattenError,
-  finalize: () => finalize,
-  extractDefs: () => extractDefs,
-  encodeAsync: () => encodeAsync,
-  encode: () => encode,
-  describe: () => describe,
-  decodeAsync: () => decodeAsync,
-  decode: () => decode,
-  createToJSONSchemaMethod: () => createToJSONSchemaMethod,
-  createStandardJSONSchemaMethod: () => createStandardJSONSchemaMethod,
-  config: () => config,
-  clone: () => clone,
-  _xor: () => _xor,
-  _xid: () => _xid,
-  _void: () => _void,
-  _uuidv7: () => _uuidv7,
-  _uuidv6: () => _uuidv6,
-  _uuidv4: () => _uuidv4,
-  _uuid: () => _uuid,
-  _url: () => _url,
-  _uppercase: () => _uppercase,
-  _unknown: () => _unknown,
-  _union: () => _union,
-  _undefined: () => _undefined2,
-  _ulid: () => _ulid,
-  _uint64: () => _uint64,
-  _uint32: () => _uint32,
-  _tuple: () => _tuple,
-  _trim: () => _trim,
-  _transform: () => _transform,
-  _toUpperCase: () => _toUpperCase,
-  _toLowerCase: () => _toLowerCase,
-  _templateLiteral: () => _templateLiteral,
-  _symbol: () => _symbol,
-  _superRefine: () => _superRefine,
-  _success: () => _success,
-  _stringbool: () => _stringbool,
-  _stringFormat: () => _stringFormat,
-  _string: () => _string,
-  _startsWith: () => _startsWith,
-  _slugify: () => _slugify,
-  _size: () => _size,
-  _set: () => _set,
-  _safeParseAsync: () => _safeParseAsync,
-  _safeParse: () => _safeParse,
-  _safeEncodeAsync: () => _safeEncodeAsync,
-  _safeEncode: () => _safeEncode,
-  _safeDecodeAsync: () => _safeDecodeAsync,
-  _safeDecode: () => _safeDecode,
-  _regex: () => _regex,
-  _refine: () => _refine,
-  _record: () => _record,
-  _readonly: () => _readonly,
-  _property: () => _property,
-  _promise: () => _promise,
-  _positive: () => _positive,
-  _pipe: () => _pipe,
-  _parseAsync: () => _parseAsync,
-  _parse: () => _parse,
-  _overwrite: () => _overwrite,
-  _optional: () => _optional,
-  _number: () => _number,
-  _nullable: () => _nullable,
-  _null: () => _null2,
-  _normalize: () => _normalize,
-  _nonpositive: () => _nonpositive,
-  _nonoptional: () => _nonoptional,
-  _nonnegative: () => _nonnegative,
-  _never: () => _never,
-  _negative: () => _negative,
-  _nativeEnum: () => _nativeEnum,
-  _nanoid: () => _nanoid,
-  _nan: () => _nan,
-  _multipleOf: () => _multipleOf,
-  _minSize: () => _minSize,
-  _minLength: () => _minLength,
-  _min: () => _gte,
-  _mime: () => _mime,
-  _maxSize: () => _maxSize,
-  _maxLength: () => _maxLength,
-  _max: () => _lte,
-  _map: () => _map,
-  _mac: () => _mac,
-  _lte: () => _lte,
-  _lt: () => _lt,
-  _lowercase: () => _lowercase,
-  _literal: () => _literal,
-  _length: () => _length,
-  _lazy: () => _lazy,
-  _ksuid: () => _ksuid,
-  _jwt: () => _jwt,
-  _isoTime: () => _isoTime,
-  _isoDuration: () => _isoDuration,
-  _isoDateTime: () => _isoDateTime,
-  _isoDate: () => _isoDate,
-  _ipv6: () => _ipv6,
-  _ipv4: () => _ipv4,
-  _intersection: () => _intersection,
-  _int64: () => _int64,
-  _int32: () => _int32,
-  _int: () => _int,
-  _includes: () => _includes,
-  _guid: () => _guid,
-  _gte: () => _gte,
-  _gt: () => _gt,
-  _float64: () => _float64,
-  _float32: () => _float32,
-  _file: () => _file,
-  _enum: () => _enum,
-  _endsWith: () => _endsWith,
-  _encodeAsync: () => _encodeAsync,
-  _encode: () => _encode,
-  _emoji: () => _emoji2,
-  _email: () => _email,
-  _e164: () => _e164,
-  _discriminatedUnion: () => _discriminatedUnion,
-  _default: () => _default,
-  _decodeAsync: () => _decodeAsync,
-  _decode: () => _decode,
-  _date: () => _date,
-  _custom: () => _custom,
-  _cuid2: () => _cuid2,
-  _cuid: () => _cuid,
-  _coercedString: () => _coercedString,
-  _coercedNumber: () => _coercedNumber,
-  _coercedDate: () => _coercedDate,
-  _coercedBoolean: () => _coercedBoolean,
-  _coercedBigint: () => _coercedBigint,
-  _cidrv6: () => _cidrv6,
-  _cidrv4: () => _cidrv4,
-  _check: () => _check,
-  _catch: () => _catch,
-  _boolean: () => _boolean,
-  _bigint: () => _bigint,
-  _base64url: () => _base64url,
-  _base64: () => _base64,
-  _array: () => _array,
-  _any: () => _any,
-  TimePrecision: () => TimePrecision,
-  NEVER: () => NEVER,
-  JSONSchemaGenerator: () => JSONSchemaGenerator,
-  JSONSchema: () => exports_json_schema,
-  Doc: () => Doc,
-  $output: () => $output,
-  $input: () => $input,
-  $constructor: () => $constructor,
-  $brand: () => $brand,
-  $ZodXor: () => $ZodXor,
-  $ZodXID: () => $ZodXID,
-  $ZodVoid: () => $ZodVoid,
-  $ZodUnknown: () => $ZodUnknown,
-  $ZodUnion: () => $ZodUnion,
-  $ZodUndefined: () => $ZodUndefined,
-  $ZodUUID: () => $ZodUUID,
-  $ZodURL: () => $ZodURL,
-  $ZodULID: () => $ZodULID,
-  $ZodType: () => $ZodType,
-  $ZodTuple: () => $ZodTuple,
-  $ZodTransform: () => $ZodTransform,
-  $ZodTemplateLiteral: () => $ZodTemplateLiteral,
-  $ZodSymbol: () => $ZodSymbol,
-  $ZodSuccess: () => $ZodSuccess,
-  $ZodStringFormat: () => $ZodStringFormat,
-  $ZodString: () => $ZodString,
-  $ZodSet: () => $ZodSet,
-  $ZodRegistry: () => $ZodRegistry,
-  $ZodRecord: () => $ZodRecord,
-  $ZodRealError: () => $ZodRealError,
-  $ZodReadonly: () => $ZodReadonly,
-  $ZodPromise: () => $ZodPromise,
-  $ZodPreprocess: () => $ZodPreprocess,
-  $ZodPrefault: () => $ZodPrefault,
-  $ZodPipe: () => $ZodPipe,
-  $ZodOptional: () => $ZodOptional,
-  $ZodObjectJIT: () => $ZodObjectJIT,
-  $ZodObject: () => $ZodObject,
-  $ZodNumberFormat: () => $ZodNumberFormat,
-  $ZodNumber: () => $ZodNumber,
-  $ZodNullable: () => $ZodNullable,
-  $ZodNull: () => $ZodNull,
-  $ZodNonOptional: () => $ZodNonOptional,
-  $ZodNever: () => $ZodNever,
-  $ZodNanoID: () => $ZodNanoID,
-  $ZodNaN: () => $ZodNaN,
-  $ZodMap: () => $ZodMap,
-  $ZodMAC: () => $ZodMAC,
-  $ZodLiteral: () => $ZodLiteral,
-  $ZodLazy: () => $ZodLazy,
-  $ZodKSUID: () => $ZodKSUID,
-  $ZodJWT: () => $ZodJWT,
-  $ZodIntersection: () => $ZodIntersection,
-  $ZodISOTime: () => $ZodISOTime,
-  $ZodISODuration: () => $ZodISODuration,
-  $ZodISODateTime: () => $ZodISODateTime,
-  $ZodISODate: () => $ZodISODate,
-  $ZodIPv6: () => $ZodIPv6,
-  $ZodIPv4: () => $ZodIPv4,
-  $ZodGUID: () => $ZodGUID,
-  $ZodFunction: () => $ZodFunction,
-  $ZodFile: () => $ZodFile,
-  $ZodExactOptional: () => $ZodExactOptional,
-  $ZodError: () => $ZodError,
-  $ZodEnum: () => $ZodEnum,
-  $ZodEncodeError: () => $ZodEncodeError,
-  $ZodEmoji: () => $ZodEmoji,
-  $ZodEmail: () => $ZodEmail,
-  $ZodE164: () => $ZodE164,
-  $ZodDiscriminatedUnion: () => $ZodDiscriminatedUnion,
-  $ZodDefault: () => $ZodDefault,
-  $ZodDate: () => $ZodDate,
-  $ZodCustomStringFormat: () => $ZodCustomStringFormat,
-  $ZodCustom: () => $ZodCustom,
-  $ZodCodec: () => $ZodCodec,
-  $ZodCheckUpperCase: () => $ZodCheckUpperCase,
-  $ZodCheckStringFormat: () => $ZodCheckStringFormat,
-  $ZodCheckStartsWith: () => $ZodCheckStartsWith,
-  $ZodCheckSizeEquals: () => $ZodCheckSizeEquals,
-  $ZodCheckRegex: () => $ZodCheckRegex,
-  $ZodCheckProperty: () => $ZodCheckProperty,
-  $ZodCheckOverwrite: () => $ZodCheckOverwrite,
-  $ZodCheckNumberFormat: () => $ZodCheckNumberFormat,
-  $ZodCheckMultipleOf: () => $ZodCheckMultipleOf,
-  $ZodCheckMinSize: () => $ZodCheckMinSize,
-  $ZodCheckMinLength: () => $ZodCheckMinLength,
-  $ZodCheckMimeType: () => $ZodCheckMimeType,
-  $ZodCheckMaxSize: () => $ZodCheckMaxSize,
-  $ZodCheckMaxLength: () => $ZodCheckMaxLength,
-  $ZodCheckLowerCase: () => $ZodCheckLowerCase,
-  $ZodCheckLessThan: () => $ZodCheckLessThan,
-  $ZodCheckLengthEquals: () => $ZodCheckLengthEquals,
-  $ZodCheckIncludes: () => $ZodCheckIncludes,
-  $ZodCheckGreaterThan: () => $ZodCheckGreaterThan,
-  $ZodCheckEndsWith: () => $ZodCheckEndsWith,
-  $ZodCheckBigIntFormat: () => $ZodCheckBigIntFormat,
-  $ZodCheck: () => $ZodCheck,
-  $ZodCatch: () => $ZodCatch,
-  $ZodCUID2: () => $ZodCUID2,
-  $ZodCUID: () => $ZodCUID,
-  $ZodCIDRv6: () => $ZodCIDRv6,
-  $ZodCIDRv4: () => $ZodCIDRv4,
-  $ZodBoolean: () => $ZodBoolean,
-  $ZodBigIntFormat: () => $ZodBigIntFormat,
-  $ZodBigInt: () => $ZodBigInt,
-  $ZodBase64URL: () => $ZodBase64URL,
-  $ZodBase64: () => $ZodBase64,
-  $ZodAsyncError: () => $ZodAsyncError,
+  $ZodAny: () => $ZodAny,
   $ZodArray: () => $ZodArray,
-  $ZodAny: () => $ZodAny
+  $ZodAsyncError: () => $ZodAsyncError,
+  $ZodBase64: () => $ZodBase64,
+  $ZodBase64URL: () => $ZodBase64URL,
+  $ZodBigInt: () => $ZodBigInt,
+  $ZodBigIntFormat: () => $ZodBigIntFormat,
+  $ZodBoolean: () => $ZodBoolean,
+  $ZodCIDRv4: () => $ZodCIDRv4,
+  $ZodCIDRv6: () => $ZodCIDRv6,
+  $ZodCUID: () => $ZodCUID,
+  $ZodCUID2: () => $ZodCUID2,
+  $ZodCatch: () => $ZodCatch,
+  $ZodCheck: () => $ZodCheck,
+  $ZodCheckBigIntFormat: () => $ZodCheckBigIntFormat,
+  $ZodCheckEndsWith: () => $ZodCheckEndsWith,
+  $ZodCheckGreaterThan: () => $ZodCheckGreaterThan,
+  $ZodCheckIncludes: () => $ZodCheckIncludes,
+  $ZodCheckLengthEquals: () => $ZodCheckLengthEquals,
+  $ZodCheckLessThan: () => $ZodCheckLessThan,
+  $ZodCheckLowerCase: () => $ZodCheckLowerCase,
+  $ZodCheckMaxLength: () => $ZodCheckMaxLength,
+  $ZodCheckMaxSize: () => $ZodCheckMaxSize,
+  $ZodCheckMimeType: () => $ZodCheckMimeType,
+  $ZodCheckMinLength: () => $ZodCheckMinLength,
+  $ZodCheckMinSize: () => $ZodCheckMinSize,
+  $ZodCheckMultipleOf: () => $ZodCheckMultipleOf,
+  $ZodCheckNumberFormat: () => $ZodCheckNumberFormat,
+  $ZodCheckOverwrite: () => $ZodCheckOverwrite,
+  $ZodCheckProperty: () => $ZodCheckProperty,
+  $ZodCheckRegex: () => $ZodCheckRegex,
+  $ZodCheckSizeEquals: () => $ZodCheckSizeEquals,
+  $ZodCheckStartsWith: () => $ZodCheckStartsWith,
+  $ZodCheckStringFormat: () => $ZodCheckStringFormat,
+  $ZodCheckUpperCase: () => $ZodCheckUpperCase,
+  $ZodCodec: () => $ZodCodec,
+  $ZodCustom: () => $ZodCustom,
+  $ZodCustomStringFormat: () => $ZodCustomStringFormat,
+  $ZodDate: () => $ZodDate,
+  $ZodDefault: () => $ZodDefault,
+  $ZodDiscriminatedUnion: () => $ZodDiscriminatedUnion,
+  $ZodE164: () => $ZodE164,
+  $ZodEmail: () => $ZodEmail,
+  $ZodEmoji: () => $ZodEmoji,
+  $ZodEncodeError: () => $ZodEncodeError,
+  $ZodEnum: () => $ZodEnum,
+  $ZodError: () => $ZodError,
+  $ZodExactOptional: () => $ZodExactOptional,
+  $ZodFile: () => $ZodFile,
+  $ZodFunction: () => $ZodFunction,
+  $ZodGUID: () => $ZodGUID,
+  $ZodIPv4: () => $ZodIPv4,
+  $ZodIPv6: () => $ZodIPv6,
+  $ZodISODate: () => $ZodISODate,
+  $ZodISODateTime: () => $ZodISODateTime,
+  $ZodISODuration: () => $ZodISODuration,
+  $ZodISOTime: () => $ZodISOTime,
+  $ZodIntersection: () => $ZodIntersection,
+  $ZodJWT: () => $ZodJWT,
+  $ZodKSUID: () => $ZodKSUID,
+  $ZodLazy: () => $ZodLazy,
+  $ZodLiteral: () => $ZodLiteral,
+  $ZodMAC: () => $ZodMAC,
+  $ZodMap: () => $ZodMap,
+  $ZodNaN: () => $ZodNaN,
+  $ZodNanoID: () => $ZodNanoID,
+  $ZodNever: () => $ZodNever,
+  $ZodNonOptional: () => $ZodNonOptional,
+  $ZodNull: () => $ZodNull,
+  $ZodNullable: () => $ZodNullable,
+  $ZodNumber: () => $ZodNumber,
+  $ZodNumberFormat: () => $ZodNumberFormat,
+  $ZodObject: () => $ZodObject,
+  $ZodObjectJIT: () => $ZodObjectJIT,
+  $ZodOptional: () => $ZodOptional,
+  $ZodPipe: () => $ZodPipe,
+  $ZodPrefault: () => $ZodPrefault,
+  $ZodPreprocess: () => $ZodPreprocess,
+  $ZodPromise: () => $ZodPromise,
+  $ZodReadonly: () => $ZodReadonly,
+  $ZodRealError: () => $ZodRealError,
+  $ZodRecord: () => $ZodRecord,
+  $ZodRegistry: () => $ZodRegistry,
+  $ZodSet: () => $ZodSet,
+  $ZodString: () => $ZodString,
+  $ZodStringFormat: () => $ZodStringFormat,
+  $ZodSuccess: () => $ZodSuccess,
+  $ZodSymbol: () => $ZodSymbol,
+  $ZodTemplateLiteral: () => $ZodTemplateLiteral,
+  $ZodTransform: () => $ZodTransform,
+  $ZodTuple: () => $ZodTuple,
+  $ZodType: () => $ZodType,
+  $ZodULID: () => $ZodULID,
+  $ZodURL: () => $ZodURL,
+  $ZodUUID: () => $ZodUUID,
+  $ZodUndefined: () => $ZodUndefined,
+  $ZodUnion: () => $ZodUnion,
+  $ZodUnknown: () => $ZodUnknown,
+  $ZodVoid: () => $ZodVoid,
+  $ZodXID: () => $ZodXID,
+  $ZodXor: () => $ZodXor,
+  $brand: () => $brand,
+  $constructor: () => $constructor,
+  $input: () => $input,
+  $output: () => $output,
+  Doc: () => Doc,
+  JSONSchema: () => exports_json_schema,
+  JSONSchemaGenerator: () => JSONSchemaGenerator,
+  NEVER: () => NEVER,
+  TimePrecision: () => TimePrecision,
+  _any: () => _any,
+  _array: () => _array,
+  _base64: () => _base64,
+  _base64url: () => _base64url,
+  _bigint: () => _bigint,
+  _boolean: () => _boolean,
+  _catch: () => _catch,
+  _check: () => _check,
+  _cidrv4: () => _cidrv4,
+  _cidrv6: () => _cidrv6,
+  _coercedBigint: () => _coercedBigint,
+  _coercedBoolean: () => _coercedBoolean,
+  _coercedDate: () => _coercedDate,
+  _coercedNumber: () => _coercedNumber,
+  _coercedString: () => _coercedString,
+  _cuid: () => _cuid,
+  _cuid2: () => _cuid2,
+  _custom: () => _custom,
+  _date: () => _date,
+  _decode: () => _decode,
+  _decodeAsync: () => _decodeAsync,
+  _default: () => _default,
+  _discriminatedUnion: () => _discriminatedUnion,
+  _e164: () => _e164,
+  _email: () => _email,
+  _emoji: () => _emoji2,
+  _encode: () => _encode,
+  _encodeAsync: () => _encodeAsync,
+  _endsWith: () => _endsWith,
+  _enum: () => _enum,
+  _file: () => _file,
+  _float32: () => _float32,
+  _float64: () => _float64,
+  _gt: () => _gt,
+  _gte: () => _gte,
+  _guid: () => _guid,
+  _includes: () => _includes,
+  _int: () => _int,
+  _int32: () => _int32,
+  _int64: () => _int64,
+  _intersection: () => _intersection,
+  _ipv4: () => _ipv4,
+  _ipv6: () => _ipv6,
+  _isoDate: () => _isoDate,
+  _isoDateTime: () => _isoDateTime,
+  _isoDuration: () => _isoDuration,
+  _isoTime: () => _isoTime,
+  _jwt: () => _jwt,
+  _ksuid: () => _ksuid,
+  _lazy: () => _lazy,
+  _length: () => _length,
+  _literal: () => _literal,
+  _lowercase: () => _lowercase,
+  _lt: () => _lt,
+  _lte: () => _lte,
+  _mac: () => _mac,
+  _map: () => _map,
+  _max: () => _lte,
+  _maxLength: () => _maxLength,
+  _maxSize: () => _maxSize,
+  _mime: () => _mime,
+  _min: () => _gte,
+  _minLength: () => _minLength,
+  _minSize: () => _minSize,
+  _multipleOf: () => _multipleOf,
+  _nan: () => _nan,
+  _nanoid: () => _nanoid,
+  _nativeEnum: () => _nativeEnum,
+  _negative: () => _negative,
+  _never: () => _never,
+  _nonnegative: () => _nonnegative,
+  _nonoptional: () => _nonoptional,
+  _nonpositive: () => _nonpositive,
+  _normalize: () => _normalize,
+  _null: () => _null2,
+  _nullable: () => _nullable,
+  _number: () => _number,
+  _optional: () => _optional,
+  _overwrite: () => _overwrite,
+  _parse: () => _parse,
+  _parseAsync: () => _parseAsync,
+  _pipe: () => _pipe,
+  _positive: () => _positive,
+  _promise: () => _promise,
+  _property: () => _property,
+  _readonly: () => _readonly,
+  _record: () => _record,
+  _refine: () => _refine,
+  _regex: () => _regex,
+  _safeDecode: () => _safeDecode,
+  _safeDecodeAsync: () => _safeDecodeAsync,
+  _safeEncode: () => _safeEncode,
+  _safeEncodeAsync: () => _safeEncodeAsync,
+  _safeParse: () => _safeParse,
+  _safeParseAsync: () => _safeParseAsync,
+  _set: () => _set,
+  _size: () => _size,
+  _slugify: () => _slugify,
+  _startsWith: () => _startsWith,
+  _string: () => _string,
+  _stringFormat: () => _stringFormat,
+  _stringbool: () => _stringbool,
+  _success: () => _success,
+  _superRefine: () => _superRefine,
+  _symbol: () => _symbol,
+  _templateLiteral: () => _templateLiteral,
+  _toLowerCase: () => _toLowerCase,
+  _toUpperCase: () => _toUpperCase,
+  _transform: () => _transform,
+  _trim: () => _trim,
+  _tuple: () => _tuple,
+  _uint32: () => _uint32,
+  _uint64: () => _uint64,
+  _ulid: () => _ulid,
+  _undefined: () => _undefined2,
+  _union: () => _union,
+  _unknown: () => _unknown,
+  _uppercase: () => _uppercase,
+  _url: () => _url,
+  _uuid: () => _uuid,
+  _uuidv4: () => _uuidv4,
+  _uuidv6: () => _uuidv6,
+  _uuidv7: () => _uuidv7,
+  _void: () => _void,
+  _xid: () => _xid,
+  _xor: () => _xor,
+  clone: () => clone,
+  config: () => config,
+  createStandardJSONSchemaMethod: () => createStandardJSONSchemaMethod,
+  createToJSONSchemaMethod: () => createToJSONSchemaMethod,
+  decode: () => decode,
+  decodeAsync: () => decodeAsync,
+  describe: () => describe,
+  encode: () => encode,
+  encodeAsync: () => encodeAsync,
+  extractDefs: () => extractDefs,
+  finalize: () => finalize,
+  flattenError: () => flattenError,
+  formatError: () => formatError,
+  globalConfig: () => globalConfig,
+  globalRegistry: () => globalRegistry,
+  initializeContext: () => initializeContext,
+  isValidBase64: () => isValidBase64,
+  isValidBase64URL: () => isValidBase64URL,
+  isValidJWT: () => isValidJWT,
+  locales: () => exports_locales,
+  meta: () => meta,
+  parse: () => parse,
+  parseAsync: () => parseAsync,
+  prettifyError: () => prettifyError,
+  process: () => process2,
+  regexes: () => exports_regexes,
+  registry: () => registry,
+  safeDecode: () => safeDecode,
+  safeDecodeAsync: () => safeDecodeAsync,
+  safeEncode: () => safeEncode,
+  safeEncodeAsync: () => safeEncodeAsync,
+  safeParse: () => safeParse,
+  safeParseAsync: () => safeParseAsync,
+  toDotPath: () => toDotPath,
+  toJSONSchema: () => toJSONSchema,
+  treeifyError: () => treeifyError,
+  util: () => exports_util,
+  version: () => version
 });
 
 // ../../node_modules/.bun/zod@4.4.3/node_modules/zod/v4/core/core.js
@@ -18619,69 +18045,69 @@ function config(newConfig) {
 // ../../node_modules/.bun/zod@4.4.3/node_modules/zod/v4/core/util.js
 var exports_util = {};
 __export(exports_util, {
-  unwrapMessage: () => unwrapMessage,
-  uint8ArrayToHex: () => uint8ArrayToHex,
-  uint8ArrayToBase64url: () => uint8ArrayToBase64url,
-  uint8ArrayToBase64: () => uint8ArrayToBase64,
-  stringifyPrimitive: () => stringifyPrimitive,
-  slugify: () => slugify,
-  shallowClone: () => shallowClone,
-  safeExtend: () => safeExtend,
-  required: () => required,
-  randomString: () => randomString,
-  propertyKeyTypes: () => propertyKeyTypes,
-  promiseAllObject: () => promiseAllObject,
-  primitiveTypes: () => primitiveTypes,
-  prefixIssues: () => prefixIssues,
-  pick: () => pick,
-  partial: () => partial,
-  parsedType: () => parsedType,
-  optionalKeys: () => optionalKeys,
-  omit: () => omit,
-  objectClone: () => objectClone,
-  numKeys: () => numKeys,
-  nullish: () => nullish,
-  normalizeParams: () => normalizeParams,
-  mergeDefs: () => mergeDefs,
-  merge: () => merge,
-  jsonStringifyReplacer: () => jsonStringifyReplacer,
-  joinValues: () => joinValues,
-  issue: () => issue,
-  isPlainObject: () => isPlainObject,
-  isObject: () => isObject,
-  hexToUint8Array: () => hexToUint8Array,
-  getSizableOrigin: () => getSizableOrigin,
-  getParsedType: () => getParsedType,
-  getLengthableOrigin: () => getLengthableOrigin,
-  getEnumValues: () => getEnumValues,
-  getElementAtPath: () => getElementAtPath,
-  floatSafeRemainder: () => floatSafeRemainder,
-  finalizeIssue: () => finalizeIssue,
-  extend: () => extend,
-  explicitlyAborted: () => explicitlyAborted,
-  escapeRegex: () => escapeRegex,
-  esc: () => esc,
-  defineLazy: () => defineLazy,
-  createTransparentProxy: () => createTransparentProxy,
-  cloneDef: () => cloneDef,
-  clone: () => clone,
-  cleanRegex: () => cleanRegex,
-  cleanEnum: () => cleanEnum,
-  captureStackTrace: () => captureStackTrace,
-  cached: () => cached,
-  base64urlToUint8Array: () => base64urlToUint8Array,
-  base64ToUint8Array: () => base64ToUint8Array,
-  assignProp: () => assignProp,
-  assertNotEqual: () => assertNotEqual,
-  assertNever: () => assertNever,
-  assertIs: () => assertIs,
-  assertEqual: () => assertEqual,
-  assert: () => assert,
-  allowsEval: () => allowsEval,
-  aborted: () => aborted,
-  NUMBER_FORMAT_RANGES: () => NUMBER_FORMAT_RANGES,
+  BIGINT_FORMAT_RANGES: () => BIGINT_FORMAT_RANGES,
   Class: () => Class,
-  BIGINT_FORMAT_RANGES: () => BIGINT_FORMAT_RANGES
+  NUMBER_FORMAT_RANGES: () => NUMBER_FORMAT_RANGES,
+  aborted: () => aborted,
+  allowsEval: () => allowsEval,
+  assert: () => assert,
+  assertEqual: () => assertEqual,
+  assertIs: () => assertIs,
+  assertNever: () => assertNever,
+  assertNotEqual: () => assertNotEqual,
+  assignProp: () => assignProp,
+  base64ToUint8Array: () => base64ToUint8Array,
+  base64urlToUint8Array: () => base64urlToUint8Array,
+  cached: () => cached,
+  captureStackTrace: () => captureStackTrace,
+  cleanEnum: () => cleanEnum,
+  cleanRegex: () => cleanRegex,
+  clone: () => clone,
+  cloneDef: () => cloneDef,
+  createTransparentProxy: () => createTransparentProxy,
+  defineLazy: () => defineLazy,
+  esc: () => esc,
+  escapeRegex: () => escapeRegex,
+  explicitlyAborted: () => explicitlyAborted,
+  extend: () => extend,
+  finalizeIssue: () => finalizeIssue,
+  floatSafeRemainder: () => floatSafeRemainder,
+  getElementAtPath: () => getElementAtPath,
+  getEnumValues: () => getEnumValues,
+  getLengthableOrigin: () => getLengthableOrigin,
+  getParsedType: () => getParsedType,
+  getSizableOrigin: () => getSizableOrigin,
+  hexToUint8Array: () => hexToUint8Array,
+  isObject: () => isObject,
+  isPlainObject: () => isPlainObject,
+  issue: () => issue,
+  joinValues: () => joinValues,
+  jsonStringifyReplacer: () => jsonStringifyReplacer,
+  merge: () => merge,
+  mergeDefs: () => mergeDefs,
+  normalizeParams: () => normalizeParams,
+  nullish: () => nullish,
+  numKeys: () => numKeys,
+  objectClone: () => objectClone,
+  omit: () => omit,
+  optionalKeys: () => optionalKeys,
+  parsedType: () => parsedType,
+  partial: () => partial,
+  pick: () => pick,
+  prefixIssues: () => prefixIssues,
+  primitiveTypes: () => primitiveTypes,
+  promiseAllObject: () => promiseAllObject,
+  propertyKeyTypes: () => propertyKeyTypes,
+  randomString: () => randomString,
+  required: () => required,
+  safeExtend: () => safeExtend,
+  shallowClone: () => shallowClone,
+  slugify: () => slugify,
+  stringifyPrimitive: () => stringifyPrimitive,
+  uint8ArrayToBase64: () => uint8ArrayToBase64,
+  uint8ArrayToBase64url: () => uint8ArrayToBase64url,
+  uint8ArrayToHex: () => uint8ArrayToHex,
+  unwrapMessage: () => unwrapMessage
 });
 function assertEqual(val) {
   return val;
@@ -19538,65 +18964,65 @@ var safeDecodeAsync = /* @__PURE__ */ _safeDecodeAsync($ZodRealError);
 // ../../node_modules/.bun/zod@4.4.3/node_modules/zod/v4/core/regexes.js
 var exports_regexes = {};
 __export(exports_regexes, {
-  xid: () => xid,
-  uuid7: () => uuid7,
-  uuid6: () => uuid6,
-  uuid4: () => uuid4,
-  uuid: () => uuid,
-  uppercase: () => uppercase,
-  unicodeEmail: () => unicodeEmail,
-  undefined: () => _undefined,
-  ulid: () => ulid,
-  time: () => time,
-  string: () => string,
-  sha512_hex: () => sha512_hex,
-  sha512_base64url: () => sha512_base64url,
-  sha512_base64: () => sha512_base64,
-  sha384_hex: () => sha384_hex,
-  sha384_base64url: () => sha384_base64url,
-  sha384_base64: () => sha384_base64,
-  sha256_hex: () => sha256_hex,
-  sha256_base64url: () => sha256_base64url,
-  sha256_base64: () => sha256_base64,
-  sha1_hex: () => sha1_hex,
-  sha1_base64url: () => sha1_base64url,
-  sha1_base64: () => sha1_base64,
-  rfc5322Email: () => rfc5322Email,
-  number: () => number,
-  null: () => _null,
-  nanoid: () => nanoid,
-  md5_hex: () => md5_hex,
-  md5_base64url: () => md5_base64url,
-  md5_base64: () => md5_base64,
-  mac: () => mac,
-  lowercase: () => lowercase,
-  ksuid: () => ksuid,
-  ipv6: () => ipv6,
-  ipv4: () => ipv4,
-  integer: () => integer,
-  idnEmail: () => idnEmail,
-  httpProtocol: () => httpProtocol,
-  html5Email: () => html5Email,
-  hostname: () => hostname2,
-  hex: () => hex,
-  guid: () => guid,
-  extendedDuration: () => extendedDuration,
-  emoji: () => emoji,
-  email: () => email,
-  e164: () => e164,
-  duration: () => duration,
-  domain: () => domain,
-  datetime: () => datetime,
-  date: () => date,
-  cuid2: () => cuid2,
-  cuid: () => cuid,
-  cidrv6: () => cidrv6,
-  cidrv4: () => cidrv4,
-  browserEmail: () => browserEmail,
-  boolean: () => boolean,
-  bigint: () => bigint,
+  base64: () => base64,
   base64url: () => base64url,
-  base64: () => base64
+  bigint: () => bigint,
+  boolean: () => boolean,
+  browserEmail: () => browserEmail,
+  cidrv4: () => cidrv4,
+  cidrv6: () => cidrv6,
+  cuid: () => cuid,
+  cuid2: () => cuid2,
+  date: () => date,
+  datetime: () => datetime,
+  domain: () => domain,
+  duration: () => duration,
+  e164: () => e164,
+  email: () => email,
+  emoji: () => emoji,
+  extendedDuration: () => extendedDuration,
+  guid: () => guid,
+  hex: () => hex,
+  hostname: () => hostname2,
+  html5Email: () => html5Email,
+  httpProtocol: () => httpProtocol,
+  idnEmail: () => idnEmail,
+  integer: () => integer,
+  ipv4: () => ipv4,
+  ipv6: () => ipv6,
+  ksuid: () => ksuid,
+  lowercase: () => lowercase,
+  mac: () => mac,
+  md5_base64: () => md5_base64,
+  md5_base64url: () => md5_base64url,
+  md5_hex: () => md5_hex,
+  nanoid: () => nanoid,
+  null: () => _null,
+  number: () => number,
+  rfc5322Email: () => rfc5322Email,
+  sha1_base64: () => sha1_base64,
+  sha1_base64url: () => sha1_base64url,
+  sha1_hex: () => sha1_hex,
+  sha256_base64: () => sha256_base64,
+  sha256_base64url: () => sha256_base64url,
+  sha256_hex: () => sha256_hex,
+  sha384_base64: () => sha384_base64,
+  sha384_base64url: () => sha384_base64url,
+  sha384_hex: () => sha384_hex,
+  sha512_base64: () => sha512_base64,
+  sha512_base64url: () => sha512_base64url,
+  sha512_hex: () => sha512_hex,
+  string: () => string,
+  time: () => time,
+  ulid: () => ulid,
+  undefined: () => _undefined,
+  unicodeEmail: () => unicodeEmail,
+  uppercase: () => uppercase,
+  uuid: () => uuid,
+  uuid4: () => uuid4,
+  uuid6: () => uuid6,
+  uuid7: () => uuid7,
+  xid: () => xid
 });
 var cuid = /^[cC][0-9a-z]{6,}$/;
 var cuid2 = /^[0-9a-z]+$/;
@@ -22373,58 +21799,58 @@ function handleRefineResult(result, payload, input, inst) {
 // ../../node_modules/.bun/zod@4.4.3/node_modules/zod/v4/locales/index.js
 var exports_locales = {};
 __export(exports_locales, {
-  zhTW: () => zh_TW_default,
-  zhCN: () => zh_CN_default,
-  yo: () => yo_default,
-  vi: () => vi_default,
-  uz: () => uz_default,
-  ur: () => ur_default,
-  uk: () => uk_default,
-  ua: () => ua_default,
-  tr: () => tr_default,
-  th: () => th_default,
-  ta: () => ta_default,
-  sv: () => sv_default,
-  sl: () => sl_default,
-  ru: () => ru_default,
-  ro: () => ro_default,
-  pt: () => pt_default,
-  ps: () => ps_default,
-  pl: () => pl_default,
-  ota: () => ota_default,
-  no: () => no_default,
-  nl: () => nl_default,
-  ms: () => ms_default,
-  mk: () => mk_default,
-  lt: () => lt_default,
-  ko: () => ko_default,
-  km: () => km_default,
-  kh: () => kh_default,
-  ka: () => ka_default,
-  ja: () => ja_default,
-  it: () => it_default,
-  is: () => is_default,
-  id: () => id_default,
-  hy: () => hy_default,
-  hu: () => hu_default,
-  hr: () => hr_default,
-  he: () => he_default,
-  frCA: () => fr_CA_default,
-  fr: () => fr_default,
-  fi: () => fi_default,
-  fa: () => fa_default,
-  es: () => es_default,
-  eo: () => eo_default,
-  en: () => en_default,
-  el: () => el_default,
-  de: () => de_default,
-  da: () => da_default,
-  cs: () => cs_default,
-  ca: () => ca_default,
-  bg: () => bg_default,
-  be: () => be_default,
+  ar: () => ar_default,
   az: () => az_default,
-  ar: () => ar_default
+  be: () => be_default,
+  bg: () => bg_default,
+  ca: () => ca_default,
+  cs: () => cs_default,
+  da: () => da_default,
+  de: () => de_default,
+  el: () => el_default,
+  en: () => en_default,
+  eo: () => eo_default,
+  es: () => es_default,
+  fa: () => fa_default,
+  fi: () => fi_default,
+  fr: () => fr_default,
+  frCA: () => fr_CA_default,
+  he: () => he_default,
+  hr: () => hr_default,
+  hu: () => hu_default,
+  hy: () => hy_default,
+  id: () => id_default,
+  is: () => is_default,
+  it: () => it_default,
+  ja: () => ja_default,
+  ka: () => ka_default,
+  kh: () => kh_default,
+  km: () => km_default,
+  ko: () => ko_default,
+  lt: () => lt_default,
+  mk: () => mk_default,
+  ms: () => ms_default,
+  nl: () => nl_default,
+  no: () => no_default,
+  ota: () => ota_default,
+  pl: () => pl_default,
+  ps: () => ps_default,
+  pt: () => pt_default,
+  ro: () => ro_default,
+  ru: () => ru_default,
+  sl: () => sl_default,
+  sv: () => sv_default,
+  ta: () => ta_default,
+  th: () => th_default,
+  tr: () => tr_default,
+  ua: () => ua_default,
+  uk: () => uk_default,
+  ur: () => ur_default,
+  uz: () => uz_default,
+  vi: () => vi_default,
+  yo: () => yo_default,
+  zhCN: () => zh_CN_default,
+  zhTW: () => zh_TW_default
 });
 
 // ../../node_modules/.bun/zod@4.4.3/node_modules/zod/v4/locales/ar.js
@@ -30195,219 +29621,219 @@ var exports_json_schema = {};
 // ../../node_modules/.bun/zod@4.4.3/node_modules/zod/v4/classic/schemas.js
 var exports_schemas2 = {};
 __export(exports_schemas2, {
-  xor: () => xor,
-  xid: () => xid2,
-  void: () => _void2,
-  uuidv7: () => uuidv7,
-  uuidv6: () => uuidv6,
-  uuidv4: () => uuidv4,
-  uuid: () => uuid2,
-  url: () => url,
-  unknown: () => unknown,
-  union: () => union,
-  undefined: () => _undefined3,
-  ulid: () => ulid2,
-  uint64: () => uint64,
-  uint32: () => uint32,
-  tuple: () => tuple,
-  transform: () => transform,
-  templateLiteral: () => templateLiteral,
-  symbol: () => symbol,
-  superRefine: () => superRefine,
-  success: () => success,
-  stringbool: () => stringbool,
-  stringFormat: () => stringFormat,
-  string: () => string2,
-  strictObject: () => strictObject,
-  set: () => set,
-  refine: () => refine,
-  record: () => record,
-  readonly: () => readonly,
-  promise: () => promise,
-  preprocess: () => preprocess,
-  prefault: () => prefault,
-  pipe: () => pipe,
-  partialRecord: () => partialRecord,
-  optional: () => optional,
-  object: () => object,
-  number: () => number2,
-  nullish: () => nullish2,
-  nullable: () => nullable,
-  null: () => _null3,
-  nonoptional: () => nonoptional,
-  never: () => never,
-  nativeEnum: () => nativeEnum,
-  nanoid: () => nanoid2,
-  nan: () => nan,
-  meta: () => meta2,
-  map: () => map,
-  mac: () => mac2,
-  looseRecord: () => looseRecord,
-  looseObject: () => looseObject,
-  literal: () => literal,
-  lazy: () => lazy,
-  ksuid: () => ksuid2,
-  keyof: () => keyof,
-  jwt: () => jwt,
-  json: () => json,
-  ipv6: () => ipv62,
-  ipv4: () => ipv42,
-  invertCodec: () => invertCodec,
-  intersection: () => intersection,
-  int64: () => int64,
-  int32: () => int32,
-  int: () => int,
-  instanceof: () => _instanceof,
-  httpUrl: () => httpUrl,
-  hostname: () => hostname3,
-  hex: () => hex2,
-  hash: () => hash,
-  guid: () => guid2,
-  function: () => _function,
-  float64: () => float64,
-  float32: () => float32,
-  file: () => file,
-  exactOptional: () => exactOptional,
-  enum: () => _enum2,
-  emoji: () => emoji2,
-  email: () => email2,
-  e164: () => e1642,
-  discriminatedUnion: () => discriminatedUnion,
-  describe: () => describe2,
-  date: () => date3,
-  custom: () => custom,
-  cuid2: () => cuid22,
-  cuid: () => cuid3,
-  codec: () => codec,
-  cidrv6: () => cidrv62,
-  cidrv4: () => cidrv42,
-  check: () => check,
-  catch: () => _catch2,
-  boolean: () => boolean2,
-  bigint: () => bigint2,
-  base64url: () => base64url2,
-  base64: () => base642,
-  array: () => array,
-  any: () => any,
-  _function: () => _function,
-  _default: () => _default2,
-  _ZodString: () => _ZodString,
-  ZodXor: () => ZodXor,
-  ZodXID: () => ZodXID,
-  ZodVoid: () => ZodVoid,
-  ZodUnknown: () => ZodUnknown,
-  ZodUnion: () => ZodUnion,
-  ZodUndefined: () => ZodUndefined,
-  ZodUUID: () => ZodUUID,
-  ZodURL: () => ZodURL,
-  ZodULID: () => ZodULID,
-  ZodType: () => ZodType,
-  ZodTuple: () => ZodTuple,
-  ZodTransform: () => ZodTransform,
-  ZodTemplateLiteral: () => ZodTemplateLiteral,
-  ZodSymbol: () => ZodSymbol,
-  ZodSuccess: () => ZodSuccess,
-  ZodStringFormat: () => ZodStringFormat,
-  ZodString: () => ZodString,
-  ZodSet: () => ZodSet,
-  ZodRecord: () => ZodRecord,
-  ZodReadonly: () => ZodReadonly,
-  ZodPromise: () => ZodPromise,
-  ZodPreprocess: () => ZodPreprocess,
-  ZodPrefault: () => ZodPrefault,
-  ZodPipe: () => ZodPipe,
-  ZodOptional: () => ZodOptional,
-  ZodObject: () => ZodObject,
-  ZodNumberFormat: () => ZodNumberFormat,
-  ZodNumber: () => ZodNumber,
-  ZodNullable: () => ZodNullable,
-  ZodNull: () => ZodNull,
-  ZodNonOptional: () => ZodNonOptional,
-  ZodNever: () => ZodNever,
-  ZodNanoID: () => ZodNanoID,
-  ZodNaN: () => ZodNaN,
-  ZodMap: () => ZodMap,
-  ZodMAC: () => ZodMAC,
-  ZodLiteral: () => ZodLiteral,
-  ZodLazy: () => ZodLazy,
-  ZodKSUID: () => ZodKSUID,
-  ZodJWT: () => ZodJWT,
-  ZodIntersection: () => ZodIntersection,
-  ZodIPv6: () => ZodIPv6,
-  ZodIPv4: () => ZodIPv4,
-  ZodGUID: () => ZodGUID,
-  ZodFunction: () => ZodFunction,
-  ZodFile: () => ZodFile,
-  ZodExactOptional: () => ZodExactOptional,
-  ZodEnum: () => ZodEnum,
-  ZodEmoji: () => ZodEmoji,
-  ZodEmail: () => ZodEmail,
-  ZodE164: () => ZodE164,
-  ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
-  ZodDefault: () => ZodDefault,
-  ZodDate: () => ZodDate,
-  ZodCustomStringFormat: () => ZodCustomStringFormat,
-  ZodCustom: () => ZodCustom,
-  ZodCodec: () => ZodCodec,
-  ZodCatch: () => ZodCatch,
-  ZodCUID2: () => ZodCUID2,
-  ZodCUID: () => ZodCUID,
-  ZodCIDRv6: () => ZodCIDRv6,
-  ZodCIDRv4: () => ZodCIDRv4,
-  ZodBoolean: () => ZodBoolean,
-  ZodBigIntFormat: () => ZodBigIntFormat,
-  ZodBigInt: () => ZodBigInt,
-  ZodBase64URL: () => ZodBase64URL,
-  ZodBase64: () => ZodBase64,
+  ZodAny: () => ZodAny,
   ZodArray: () => ZodArray,
-  ZodAny: () => ZodAny
+  ZodBase64: () => ZodBase64,
+  ZodBase64URL: () => ZodBase64URL,
+  ZodBigInt: () => ZodBigInt,
+  ZodBigIntFormat: () => ZodBigIntFormat,
+  ZodBoolean: () => ZodBoolean,
+  ZodCIDRv4: () => ZodCIDRv4,
+  ZodCIDRv6: () => ZodCIDRv6,
+  ZodCUID: () => ZodCUID,
+  ZodCUID2: () => ZodCUID2,
+  ZodCatch: () => ZodCatch,
+  ZodCodec: () => ZodCodec,
+  ZodCustom: () => ZodCustom,
+  ZodCustomStringFormat: () => ZodCustomStringFormat,
+  ZodDate: () => ZodDate,
+  ZodDefault: () => ZodDefault,
+  ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
+  ZodE164: () => ZodE164,
+  ZodEmail: () => ZodEmail,
+  ZodEmoji: () => ZodEmoji,
+  ZodEnum: () => ZodEnum,
+  ZodExactOptional: () => ZodExactOptional,
+  ZodFile: () => ZodFile,
+  ZodFunction: () => ZodFunction,
+  ZodGUID: () => ZodGUID,
+  ZodIPv4: () => ZodIPv4,
+  ZodIPv6: () => ZodIPv6,
+  ZodIntersection: () => ZodIntersection,
+  ZodJWT: () => ZodJWT,
+  ZodKSUID: () => ZodKSUID,
+  ZodLazy: () => ZodLazy,
+  ZodLiteral: () => ZodLiteral,
+  ZodMAC: () => ZodMAC,
+  ZodMap: () => ZodMap,
+  ZodNaN: () => ZodNaN,
+  ZodNanoID: () => ZodNanoID,
+  ZodNever: () => ZodNever,
+  ZodNonOptional: () => ZodNonOptional,
+  ZodNull: () => ZodNull,
+  ZodNullable: () => ZodNullable,
+  ZodNumber: () => ZodNumber,
+  ZodNumberFormat: () => ZodNumberFormat,
+  ZodObject: () => ZodObject,
+  ZodOptional: () => ZodOptional,
+  ZodPipe: () => ZodPipe,
+  ZodPrefault: () => ZodPrefault,
+  ZodPreprocess: () => ZodPreprocess,
+  ZodPromise: () => ZodPromise,
+  ZodReadonly: () => ZodReadonly,
+  ZodRecord: () => ZodRecord,
+  ZodSet: () => ZodSet,
+  ZodString: () => ZodString,
+  ZodStringFormat: () => ZodStringFormat,
+  ZodSuccess: () => ZodSuccess,
+  ZodSymbol: () => ZodSymbol,
+  ZodTemplateLiteral: () => ZodTemplateLiteral,
+  ZodTransform: () => ZodTransform,
+  ZodTuple: () => ZodTuple,
+  ZodType: () => ZodType,
+  ZodULID: () => ZodULID,
+  ZodURL: () => ZodURL,
+  ZodUUID: () => ZodUUID,
+  ZodUndefined: () => ZodUndefined,
+  ZodUnion: () => ZodUnion,
+  ZodUnknown: () => ZodUnknown,
+  ZodVoid: () => ZodVoid,
+  ZodXID: () => ZodXID,
+  ZodXor: () => ZodXor,
+  _ZodString: () => _ZodString,
+  _default: () => _default2,
+  _function: () => _function,
+  any: () => any,
+  array: () => array,
+  base64: () => base642,
+  base64url: () => base64url2,
+  bigint: () => bigint2,
+  boolean: () => boolean2,
+  catch: () => _catch2,
+  check: () => check,
+  cidrv4: () => cidrv42,
+  cidrv6: () => cidrv62,
+  codec: () => codec,
+  cuid: () => cuid3,
+  cuid2: () => cuid22,
+  custom: () => custom,
+  date: () => date3,
+  describe: () => describe2,
+  discriminatedUnion: () => discriminatedUnion,
+  e164: () => e1642,
+  email: () => email2,
+  emoji: () => emoji2,
+  enum: () => _enum2,
+  exactOptional: () => exactOptional,
+  file: () => file,
+  float32: () => float32,
+  float64: () => float64,
+  function: () => _function,
+  guid: () => guid2,
+  hash: () => hash,
+  hex: () => hex2,
+  hostname: () => hostname3,
+  httpUrl: () => httpUrl,
+  instanceof: () => _instanceof,
+  int: () => int,
+  int32: () => int32,
+  int64: () => int64,
+  intersection: () => intersection,
+  invertCodec: () => invertCodec,
+  ipv4: () => ipv42,
+  ipv6: () => ipv62,
+  json: () => json,
+  jwt: () => jwt,
+  keyof: () => keyof,
+  ksuid: () => ksuid2,
+  lazy: () => lazy,
+  literal: () => literal,
+  looseObject: () => looseObject,
+  looseRecord: () => looseRecord,
+  mac: () => mac2,
+  map: () => map,
+  meta: () => meta2,
+  nan: () => nan,
+  nanoid: () => nanoid2,
+  nativeEnum: () => nativeEnum,
+  never: () => never,
+  nonoptional: () => nonoptional,
+  null: () => _null3,
+  nullable: () => nullable,
+  nullish: () => nullish2,
+  number: () => number2,
+  object: () => object,
+  optional: () => optional,
+  partialRecord: () => partialRecord,
+  pipe: () => pipe,
+  prefault: () => prefault,
+  preprocess: () => preprocess,
+  promise: () => promise,
+  readonly: () => readonly,
+  record: () => record,
+  refine: () => refine,
+  set: () => set,
+  strictObject: () => strictObject,
+  string: () => string2,
+  stringFormat: () => stringFormat,
+  stringbool: () => stringbool,
+  success: () => success,
+  superRefine: () => superRefine,
+  symbol: () => symbol,
+  templateLiteral: () => templateLiteral,
+  transform: () => transform,
+  tuple: () => tuple,
+  uint32: () => uint32,
+  uint64: () => uint64,
+  ulid: () => ulid2,
+  undefined: () => _undefined3,
+  union: () => union,
+  unknown: () => unknown,
+  url: () => url,
+  uuid: () => uuid2,
+  uuidv4: () => uuidv4,
+  uuidv6: () => uuidv6,
+  uuidv7: () => uuidv7,
+  void: () => _void2,
+  xid: () => xid2,
+  xor: () => xor
 });
 
 // ../../node_modules/.bun/zod@4.4.3/node_modules/zod/v4/classic/checks.js
 var exports_checks2 = {};
 __export(exports_checks2, {
-  uppercase: () => _uppercase,
-  trim: () => _trim,
-  toUpperCase: () => _toUpperCase,
-  toLowerCase: () => _toLowerCase,
-  startsWith: () => _startsWith,
-  slugify: () => _slugify,
-  size: () => _size,
-  regex: () => _regex,
-  property: () => _property,
-  positive: () => _positive,
-  overwrite: () => _overwrite,
-  normalize: () => _normalize,
-  nonpositive: () => _nonpositive,
-  nonnegative: () => _nonnegative,
-  negative: () => _negative,
-  multipleOf: () => _multipleOf,
-  minSize: () => _minSize,
-  minLength: () => _minLength,
-  mime: () => _mime,
-  maxSize: () => _maxSize,
-  maxLength: () => _maxLength,
-  lte: () => _lte,
-  lt: () => _lt,
-  lowercase: () => _lowercase,
-  length: () => _length,
-  includes: () => _includes,
-  gte: () => _gte,
+  endsWith: () => _endsWith,
   gt: () => _gt,
-  endsWith: () => _endsWith
+  gte: () => _gte,
+  includes: () => _includes,
+  length: () => _length,
+  lowercase: () => _lowercase,
+  lt: () => _lt,
+  lte: () => _lte,
+  maxLength: () => _maxLength,
+  maxSize: () => _maxSize,
+  mime: () => _mime,
+  minLength: () => _minLength,
+  minSize: () => _minSize,
+  multipleOf: () => _multipleOf,
+  negative: () => _negative,
+  nonnegative: () => _nonnegative,
+  nonpositive: () => _nonpositive,
+  normalize: () => _normalize,
+  overwrite: () => _overwrite,
+  positive: () => _positive,
+  property: () => _property,
+  regex: () => _regex,
+  size: () => _size,
+  slugify: () => _slugify,
+  startsWith: () => _startsWith,
+  toLowerCase: () => _toLowerCase,
+  toUpperCase: () => _toUpperCase,
+  trim: () => _trim,
+  uppercase: () => _uppercase
 });
 
 // ../../node_modules/.bun/zod@4.4.3/node_modules/zod/v4/classic/iso.js
 var exports_iso = {};
 __export(exports_iso, {
-  time: () => time2,
-  duration: () => duration2,
-  datetime: () => datetime2,
-  date: () => date2,
-  ZodISOTime: () => ZodISOTime,
-  ZodISODuration: () => ZodISODuration,
+  ZodISODate: () => ZodISODate,
   ZodISODateTime: () => ZodISODateTime,
-  ZodISODate: () => ZodISODate
+  ZodISODuration: () => ZodISODuration,
+  ZodISOTime: () => ZodISOTime,
+  date: () => date2,
+  datetime: () => datetime2,
+  duration: () => duration2,
+  time: () => time2
 });
 var ZodISODateTime = /* @__PURE__ */ $constructor("ZodISODateTime", (inst, def) => {
   $ZodISODateTime.init(inst, def);
@@ -32268,11 +31694,11 @@ function fromJSONSchema(schema, params) {
 // ../../node_modules/.bun/zod@4.4.3/node_modules/zod/v4/classic/coerce.js
 var exports_coerce = {};
 __export(exports_coerce, {
-  string: () => string3,
-  number: () => number3,
-  date: () => date4,
+  bigint: () => bigint3,
   boolean: () => boolean3,
-  bigint: () => bigint3
+  date: () => date4,
+  number: () => number3,
+  string: () => string3
 });
 function string3(params) {
   return _coercedString(ZodString, params);
@@ -32383,6 +31809,9 @@ var SubcConfigSchema = exports_external.object({
   connection_file: exports_external.string().optional(),
   client_reaper: exports_external.boolean().optional()
 });
+var GhShimConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().optional()
+});
 var DEFAULT_INSPECT_DIAGNOSTICS_TIMEOUT_MS = 120000;
 var MIN_INSPECT_DIAGNOSTICS_TIMEOUT_MS = 1e4;
 var MAX_INSPECT_DIAGNOSTICS_TIMEOUT_MS = 600000;
@@ -32437,7 +31866,8 @@ var AftConfigSchema = exports_external.preprocess((value) => stripHarnessSpecifi
   semantic: SemanticConfigSchema.optional(),
   auto_update: exports_external.boolean().optional(),
   bridge: BridgeConfigSchema.optional(),
-  subc: SubcConfigSchema.optional()
+  subc: SubcConfigSchema.optional(),
+  gh_shim: GhShimConfigSchema.optional()
 }).strict());
 function resolveInspectDiagnosticsTimeoutMs(config2) {
   return clampInspectDiagnosticsTimeoutMs(config2.inspect?.diagnostics_timeout_ms ?? DEFAULT_INSPECT_DIAGNOSTICS_TIMEOUT_MS);
@@ -32890,6 +32320,8 @@ function getStrippedTopLevelKeys(override) {
     stripped.push("sandbox.write_allow");
   if (override.subc !== undefined)
     stripped.push("subc");
+  if (override.gh_shim !== undefined)
+    stripped.push("gh_shim");
   if (override.disabled_tools?.includes("aft_safety"))
     stripped.push("disabled_tools.aft_safety");
   return stripped;
@@ -37594,6 +37026,7 @@ function createBashTool(ctx, aftSearchRegisteredOverride) {
     compressed: z5.boolean().optional().describe("When true or omitted, return compressed output with noisy terminal control sequences reduced. Set to false for raw output."),
     ...ptyArgs
   };
+  let hostFallbackActive = false;
   return {
     description: bashToolDescription(false, initialBashCfg.compress, initialBashCfg.background),
     args,
@@ -37690,12 +37123,15 @@ function createBashTool(ctx, aftSearchRegisteredOverride) {
           env: shellEnv?.env
         });
         usedHostFallback = true;
+        hostFallbackActive = true;
       } finally {
         removeAbortListener();
       }
       if (data.success === false) {
         throw new Error(data.message || "bash failed");
       }
+      if (!usedHostFallback && hostFallbackActive)
+        hostFallbackActive = false;
       const uiTitle = description ?? shortenCommand(command);
       if (data.status === "running" && typeof data.task_id === "string") {
         const taskId = data.task_id;
@@ -38593,9 +38029,20 @@ ${backupBehavior}
 - Symbol replace includes decorators, attributes, and doc comments in range
 - Response is a compact server-rendered summary; before/after diff details are attached as UI metadata when available.`;
 }
+var HASHLINE_EDIT_DESCRIPTION = [
+  "Apply a hashline patch. Arguments are exactly `{patch}` where `patch` is a non-empty string. Server-owned preview control is outside this schema.",
+  "",
+  "Quick reference:",
+  "- Header: `[path#TAG]`; TAG is exactly four hexadecimal digits from a current tagged read. Read every addressed row and gap boundary; REM and MV require a whole-file tagged read. Re-read after an edit before chaining: an edit-response tag can retain only changed context.",
+  "- Same canonical path: multiple sections compose in patch order against pre-request coordinates.",
+  "- Addresses: `0` (BOF), `N` (one line), `N.=M` (range; `N..=M`/`N..M` also work), `<N`/`>N` (gap before/after), `N*`/`<N*`/`>N*` (block), and `$`/`$-K` (EOF-relative). A plain `N` PUT replaces; use `<N` or `>N` to insert.",
+  "- PUT text: `PUT <address>:` followed by one or more `+` body rows (`+` alone is blank). A final patch newline is allowed. PUT without `:` copies `@name` (or the anonymous register) and takes no body; names use `@` plus ASCII letters, digits, `_`, or `-`.",
+  "- CUT: `CUT <address> [@name]`. REM: bare `REM` only, removing the whole file. MV: `MV <destination>` (one whitespace-free path, optional matching quotes), once and after any line operations. `*** Begin Patch`/`*** End Patch` is an optional envelope."
+].join(`
+`);
 function createHashlineEditTool(ctx) {
   return {
-    description: "Apply a hashline patch. Arguments are exactly `{patch}` where `patch` is a non-empty string of one or more `[path#TAG]` sections with PUT/CUT/REM/MV operations. Paths and tags come from section headers; obtain tags from tagged reads. Server-owned preview control is outside this schema.",
+    description: HASHLINE_EDIT_DESCRIPTION,
     args: {
       patch: z8.string().min(1).describe("Hashline patch text with one or more [path#TAG] sections and PUT/CUT/REM/MV operations")
     },
@@ -40262,7 +39709,7 @@ var PLUGIN_VERSION = (() => {
     return "0.0.0";
   }
 })();
-var ANNOUNCEMENT_VERSION = "0.51.3";
+var ANNOUNCEMENT_VERSION = "0.52.1";
 var ANNOUNCEMENT_FEATURES = [
   "Callgraph stays consistent under load: edits arriving mid-rebuild can no longer be silently lost from navigation results.",
   "aft_zoom handles real-world .jsonc: files with comment banners above the opening brace now resolve, and not-found errors point at the segment that actually failed (thanks @iceteaSA).",
@@ -40291,7 +39738,16 @@ async function initializePluginForDirectory(input) {
     log2(`AFT disabled by config for ${registrationRoot}`);
     return { tool: {} };
   }
-  const binaryPath = await findBinary(PLUGIN_VERSION);
+  const cachedBinaryPath = findBinarySync(PLUGIN_VERSION);
+  if (!cachedBinaryPath) {
+    ensureBinary(PLUGIN_VERSION).then((path7) => {
+      if (path7)
+        log2(`Background binary warmup ready at ${path7}`);
+    }, (err) => {
+      warn2(`Background binary warmup failed: ${err instanceof Error ? err.message : String(err)}`);
+    });
+  }
+  const binaryPath = cachedBinaryPath ?? await findBinary(PLUGIN_VERSION);
   await ensureStorageMigrated({ harness: "opencode", binaryPath, logger: bridgeLogger });
   const autoUpdateAbort = new AbortController;
   const projectEnabledCache = new Map([[registrationRoot, true]]);