@cortexkit/aft-pi 0.57.0 → 0.57.2

package/dist/index.js

@@ -10642,17 +10642,17 @@ ${reflowText}`;
   }
   return " Auto-formatted.";
 }
-// ../../node_modules/.bun/@cortexkit+subc-client@0.8.1/node_modules/@cortexkit/subc-client/dist/client.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.13.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.8.1/node_modules/@cortexkit/subc-client/dist/auth.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.13.1/node_modules/@cortexkit/subc-client/dist/auth.js
 import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.8.1/node_modules/@cortexkit/subc-client/dist/socket.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.13.1/node_modules/@cortexkit/subc-client/dist/socket.js
 import net from "node:net";
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.8.1/node_modules/@cortexkit/subc-client/dist/envelope.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.13.1/node_modules/@cortexkit/subc-client/dist/envelope.js
 var PROTOCOL_VERSION = 2;
 var HEADER_LEN = 21;
 var FROZEN_PREFIX_LEN = 5;
@@ -10694,7 +10694,7 @@ var FLAG_PRIORITY_SHIFT = 1;
 var FLAG_LAST = 8;
 var FLAG_ADMISSION_MASK = 48;
 var FLAG_ADMISSION_SHIFT = 4;
-var FLAG_RESERVED_MASK = 192;
+var FLAG_RESERVED_MASK = 0;
 function buildFlags(binary, priority, last, admissionClass = AdmissionClass.Normal) {
   let flags = 0;
   if (binary)
@@ -10705,6 +10705,9 @@ function buildFlags(binary, priority, last, admissionClass = AdmissionClass.Norm
   flags |= admissionClass << FLAG_ADMISSION_SHIFT;
   return flags;
 }
+function hasBinary(flags) {
+  return (flags & FLAG_BINARY) !== 0;
+}
 function encodeHeader(header) {
   const buffer = new Uint8Array(HEADER_LEN);
   const view = new DataView(buffer.buffer);
@@ -10821,7 +10824,7 @@ function encodeFrame(frame) {
   return output;
 }
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.8.1/node_modules/@cortexkit/subc-client/dist/socket.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.13.1/node_modules/@cortexkit/subc-client/dist/socket.js
 class SocketClosedError extends Error {
 }
 
@@ -11054,7 +11057,7 @@ class SubcSocket {
   }
 }
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.8.1/node_modules/@cortexkit/subc-client/dist/auth.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.13.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";
@@ -11128,7 +11131,7 @@ async function authenticateClient(sock, conn, deadlineMs) {
   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
+// ../../node_modules/.bun/@cortexkit+subc-client@0.13.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;
@@ -11206,13 +11209,49 @@ async function readConnectionFile(path) {
   return info;
 }
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.8.1/node_modules/@cortexkit/subc-client/dist/route-handle.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.13.1/node_modules/@cortexkit/subc-client/dist/route-handle.js
 var connectionToken = new WeakMap;
+var reverseRequests = new WeakMap;
+
+class ReverseRequestRegistrationError extends Error {
+  methodFamily;
+  code = "reverse_request_capability_not_declared";
+  constructor(methodFamily) {
+    super(`reverse-request capability ${JSON.stringify(methodFamily)} was not registered before route.open`);
+    this.methodFamily = methodFamily;
+    this.name = "ReverseRequestRegistrationError";
+  }
+}
+
+class ReverseRequestRegistry {
+  handlers = new Map;
+  declaredFamilies = null;
+  onRequest(methodFamily, handler) {
+    if (!isMethodFamily(methodFamily)) {
+      throw new TypeError(`reverse-request method family must be a capability identifier, got ${JSON.stringify(methodFamily)}`);
+    }
+    if (typeof handler !== "function")
+      throw new TypeError("reverse-request handler must be a function");
+    if (this.declaredFamilies && !this.declaredFamilies.has(methodFamily)) {
+      throw new ReverseRequestRegistrationError(methodFamily);
+    }
+    this.handlers.set(methodFamily, handler);
+  }
+  capabilities() {
+    return [...this.handlers.keys()].sort();
+  }
+  handler(methodFamily) {
+    return this.handlers.get(methodFamily);
+  }
+  seal() {
+    this.declaredFamilies ??= new Set(this.handlers.keys());
+  }
+}
 
 class RouteHandle {
   channel;
   epoch;
-  constructor(channel, epoch, token) {
+  constructor(channel, epoch, token, registry) {
     if (!Number.isInteger(channel) || channel <= 0 || channel > 65535) {
       throw new RangeError(`route channel must be an integer in 1..65535, got ${channel}`);
     }
@@ -11221,16 +11260,27 @@ class RouteHandle {
     }
     this.channel = channel;
     this.epoch = epoch;
+    registry.seal();
     connectionToken.set(this, token);
+    reverseRequests.set(this, registry);
     Object.freeze(this);
   }
-  static create(channel, epoch, token) {
-    return new RouteHandle(channel, epoch, token);
+  onRequest(methodFamily, handler) {
+    reverseRequests.get(this).onRequest(methodFamily, handler);
+  }
+  static create(channel, epoch, token, registry) {
+    return new RouteHandle(channel, epoch, token, registry);
   }
 }
-function createRouteHandle(channel, epoch, token) {
+function createRouteHandle(channel, epoch, token, registry = new ReverseRequestRegistry) {
   const factory = RouteHandle;
-  return factory.create(channel, epoch, token);
+  return factory.create(channel, epoch, token, registry);
+}
+function reverseRequestHandler(handle, methodFamily) {
+  return reverseRequests.get(handle)?.handler(methodFamily);
+}
+function isMethodFamily(value) {
+  return /^[a-z][a-z0-9]*(?:[._-][a-z0-9]+)*$/.test(value);
 }
 
 class StaleRouteHandleError extends Error {
@@ -11252,7 +11302,7 @@ function sameRouteHandle(left, right) {
   return left === right;
 }
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.8.1/node_modules/@cortexkit/subc-client/dist/client.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.13.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;
@@ -11283,16 +11333,26 @@ class SubcCallError extends Error {
     this.cause = cause;
     this.name = "SubcCallError";
   }
+  get detail() {
+    return this.cause instanceof SubcError ? this.cause.detail : undefined;
+  }
 }
 
 class SubcError extends Error {
   code;
-  constructor(message, code) {
+  detail;
+  constructor(message, code, detail) {
     super(message);
     this.code = code;
+    this.detail = detail;
   }
 }
-
+function requireBinaryBody(body) {
+  if (body instanceof Uint8Array)
+    return body;
+  const type = body === null ? "null" : Array.isArray(body) ? "array" : typeof body;
+  throw new SubcError(`binary request body must be a Uint8Array; got ${type}`, "binary_body_required");
+}
 class SubcClient {
   sock;
   currentConn;
@@ -11329,15 +11389,34 @@ class SubcClient {
     const parsed = this.parseJson(reply);
     return parsed.modules ?? [];
   }
+  async resolveProvider(capability) {
+    const claimants = await this.resolveProviders(capability);
+    if (claimants.length === 0) {
+      throw new SubcError(`no catalog claimant for capability ${capability}`, "capability_unprovided");
+    }
+    if (claimants.length > 1) {
+      throw new SubcError(`multiple catalog claimants for capability ${capability}: ${claimants.join(", ")}`, "capability_ambiguous");
+    }
+    return claimants[0];
+  }
+  async resolveProviders(capability) {
+    if (!isValidCapabilityIdentifier(capability)) {
+      throw new SubcError(`malformed capability identifier ${JSON.stringify(capability)}`, "invalid_capability_identifier");
+    }
+    const modules = await this.catalogList();
+    return modules.filter((module) => module.capabilities?.provides.includes(capability) ?? false).map((module) => module.module_id).sort();
+  }
   async routeOpen(target, identity, opts = {}) {
     const consumerIdentity = routeOpenConsumerIdentity(opts);
-    const consumerCapabilities = opts.consumerCapabilities;
+    const reverseRequests = opts.reverseRequests ?? new ReverseRequestRegistry;
+    reverseRequests.seal();
+    const consumerCapabilities = reverseRequests.capabilities();
     const body = this.encode({
       op: "route.open",
       target,
       identity,
       ...consumerIdentity ? { consumer_identity: consumerIdentity } : {},
-      ...consumerCapabilities !== undefined ? { consumer_capabilities: consumerCapabilities } : {}
+      ...consumerCapabilities.length > 0 ? { consumer_capabilities: consumerCapabilities } : {}
     });
     let installed = null;
     const install = (frame) => {
@@ -11347,7 +11426,7 @@ class SubcClient {
       if (typeof parsed.route_channel !== "number" || typeof parsed.route_epoch !== "number") {
         throw new SubcError(`route.open returned no route handle: ${JSON.stringify(parsed)}`);
       }
-      installed = this.installRoute(parsed.route_channel, parsed.route_epoch);
+      installed = this.installRoute(parsed.route_channel, parsed.route_epoch, reverseRequests);
       return true;
     };
     const closeLateRoute = (frame) => {
@@ -11372,14 +11451,25 @@ class SubcClient {
   }
   async request(handle, body, opts = {}) {
     this.assertLiveHandle(handle);
-    const bytes = body instanceof Uint8Array ? body : this.encode(body);
+    const binary = opts.binary ?? false;
+    const bytes = binary ? requireBinaryBody(body) : body instanceof Uint8Array ? body : this.encode(body);
     const priority = opts.priority ?? Priority.Interactive;
     const admission = opts.admissionClass ?? AdmissionClass.Normal;
-    const reply = await this.send(handle, bytes, priority, admission, opts.timeoutMs, opts.onProgress);
-    return this.parseJson(reply);
+    const reply = await this.send(handle, bytes, priority, admission, opts.timeoutMs, opts.onProgress, undefined, undefined, binary, opts.signal);
+    return this.decodeReply(reply);
   }
   async call(moduleId, method, params, opts = {}) {
+    if (opts.binary) {
+      throw new SubcError("call() builds a JSON body and cannot send a binary request; use callBinary(moduleId, body, opts) with a Uint8Array", "binary_call_requires_call_binary");
+    }
     const body = params === undefined ? { method } : { method, params };
+    return await this.managedCall(moduleId, body, opts);
+  }
+  async callBinary(moduleId, body, opts = {}) {
+    const bytes = requireBinaryBody(body);
+    return this.managedCall(moduleId, bytes, { ...opts, binary: true });
+  }
+  async managedCall(moduleId, body, opts) {
     let retriedUnknownChannel = false;
     for (;; ) {
       const routeHandle = await this.cachedRouteHandle(moduleId, opts);
@@ -11457,6 +11547,22 @@ class SubcClient {
     };
     return { unsubscribe, closed };
   }
+  attachCancelSignal(signal, key, handle, corr, priority) {
+    if (!handle)
+      return;
+    const emit = () => {
+      if (!this.pending.has(key))
+        return;
+      try {
+        this.cancel(handle, corr, priority);
+      } catch {}
+    };
+    if (signal.aborted) {
+      emit();
+      return;
+    }
+    signal.addEventListener("abort", emit, { once: true });
+  }
   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);
@@ -11497,7 +11603,7 @@ class SubcClient {
     this.sendRouteGoodbye(handle);
   }
   async closeManagedRoute(target, identity, opts = {}) {
-    const key = routeCacheKey(target, identity, routeOpenConsumerIdentity(opts));
+    const key = routeCacheKey(target, identity, routeOpenConsumerIdentity(opts), (opts.reverseRequests ?? new ReverseRequestRegistry).capabilities());
     const cached = this.routes.get(key);
     if (!cached)
       return;
@@ -11565,7 +11671,7 @@ class SubcClient {
   async controlRpc(body, acceptFrame, onLateResponse) {
     return this.send(null, body, Priority.Interactive, AdmissionClass.Normal, undefined, undefined, acceptFrame, onLateResponse);
   }
-  send(handle, body, priority, admission, timeoutMs, onProgress, acceptFrame, onLateResponse) {
+  send(handle, body, priority, admission, timeoutMs, onProgress, acceptFrame, onLateResponse, binary = false, signal) {
     if (handle)
       this.assertLiveHandle(handle);
     if (this.closedErr)
@@ -11579,7 +11685,7 @@ class SubcClient {
     const key = pendingKey(handle, corr);
     const channel = handle?.channel ?? 0;
     const epoch = handle?.epoch ?? 0;
-    const frame = buildFrame(FrameType.Request, buildFlags(false, priority, false, admission), channel, epoch, corr, body);
+    const frame = buildFrame(FrameType.Request, buildFlags(binary, priority, false, admission), channel, epoch, corr, body);
     return new Promise((resolve, reject) => {
       const ms = timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
       const pending = {
@@ -11593,6 +11699,8 @@ class SubcClient {
       };
       pending.timer = setTimeout(() => this.arbitrateTimeout(key, pending, channel, corr, ms), ms);
       this.pending.set(key, pending);
+      if (signal)
+        this.attachCancelSignal(signal, key, handle, corr, priority);
       writeBorrowed(this.sock, encodeFrame(frame), Date.now() + ms).catch((error) => {
         const current = this.pending.get(key);
         if (current)
@@ -11620,19 +11728,20 @@ class SubcClient {
     setImmediate(arbitrate);
   }
   async managedRequest(handle, body, opts) {
-    const bytes = body instanceof Uint8Array ? body : this.encode(body);
+    const binary = opts.binary ?? false;
+    const bytes = binary ? requireBinaryBody(body) : body instanceof Uint8Array ? body : this.encode(body);
     const priority = opts.priority ?? Priority.Interactive;
     const admission = opts.admissionClass ?? AdmissionClass.Normal;
     try {
-      const reply = await this.sendManaged(handle, bytes, priority, admission, opts.timeoutMs, opts.onProgress);
-      return this.parseJson(reply);
+      const reply = await this.sendManaged(handle, bytes, priority, admission, opts.timeoutMs, opts.onProgress, binary, opts.signal);
+      return this.decodeReply(reply);
     } catch (error) {
       if (error instanceof SubcCallError)
         throw error;
       throw this.terminalCallError("managed call failed", error);
     }
   }
-  sendManaged(handle, body, priority, admission, timeoutMs, onProgress) {
+  sendManaged(handle, body, priority, admission, timeoutMs, onProgress, binary = false, signal) {
     try {
       this.assertLiveHandle(handle);
     } catch (error) {
@@ -11648,7 +11757,7 @@ class SubcClient {
       return Promise.reject(this.notSentCallError("request correlation allocator was exhausted", error));
     }
     const key = pendingKey(handle, corr);
-    const frame = buildFrame(FrameType.Request, buildFlags(false, priority, false, admission), handle.channel, handle.epoch, corr, body);
+    const frame = buildFrame(FrameType.Request, buildFlags(binary, priority, false, admission), handle.channel, handle.epoch, corr, body);
     let handedToSocket = false;
     const classifyFailure = (error) => {
       if (!handedToSocket)
@@ -11670,6 +11779,8 @@ class SubcClient {
       };
       pending.timer = setTimeout(() => this.arbitrateTimeout(key, pending, handle.channel, corr, ms), ms);
       this.pending.set(key, pending);
+      if (signal)
+        this.attachCancelSignal(signal, key, handle, corr, priority);
       const write = writeTrackedBorrowed(this.sock, encodeFrame(frame), Date.now() + ms);
       handedToSocket = write.queued;
       write.completed.catch((error) => {
@@ -11686,7 +11797,9 @@ class SubcClient {
     }
     const target = { kind: opts.targetKind ?? this.opts.targetKind, module_id: moduleId };
     const consumerIdentity = routeOpenConsumerIdentity(opts);
-    const key = routeCacheKey(target, identity, consumerIdentity);
+    const reverseRequests = opts.reverseRequests ?? new ReverseRequestRegistry;
+    reverseRequests.seal();
+    const key = routeCacheKey(target, identity, consumerIdentity, reverseRequests.capabilities());
     let cached = this.routes.get(key);
     if (!cached) {
       cached = {
@@ -11695,6 +11808,7 @@ class SubcClient {
         target,
         identity,
         consumerIdentity,
+        reverseRequests,
         handle: null,
         opening: null
       };
@@ -11710,7 +11824,7 @@ class SubcClient {
     return cached.opening;
   }
   async openCachedRoute(cached) {
-    const routeRetryDeadline = Date.now() + ROUTE_OPEN_RETRY_DEADLINE_MS;
+    const routeRetryDeadline = Date.now() + this.opts.routeOpenRetryDeadlineMs;
     let routeRetryDelay = this.opts.reconnectBackoff.baseMs;
     let routeRetryAttempt = 0;
     for (;; ) {
@@ -11725,7 +11839,8 @@ class SubcClient {
         return cached.handle;
       try {
         const handle = await this.routeOpen(cached.target, cached.identity, {
-          consumerIdentity: cached.consumerIdentity ?? null
+          consumerIdentity: cached.consumerIdentity ?? null,
+          reverseRequests: cached.reverseRequests
         });
         if (cached.closed) {
           this.liveRoutes.delete(handle.channel);
@@ -11747,12 +11862,12 @@ class SubcClient {
         }
         if (!this.closeStarted && error instanceof SubcError && isRetryableRouteOpenCode(error.code)) {
           routeRetryAttempt += 1;
-          if (routeRetryAttempt < this.opts.reconnectBackoff.maxAttempts && Date.now() < routeRetryDeadline) {
+          if (Date.now() < routeRetryDeadline) {
             await this.opts.sleep(routeRetryDelay);
             routeRetryDelay = Math.min(routeRetryDelay * 2, this.opts.reconnectBackoff.capMs);
             continue;
           }
-          throw this.notSentCallError(`route.open failed for module ${cached.moduleId}: ${error.code} (retry budget exhausted)`, error);
+          throw this.notSentCallError(`route.open failed for module ${cached.moduleId}: ${error.code} (retry deadline exhausted after ${routeRetryAttempt} attempts)`, error);
         }
         throw this.terminalCallError(`route.open failed for module ${cached.moduleId}`, error);
       }
@@ -11864,20 +11979,34 @@ class SubcClient {
     this.readLoop(opened.sock, this.generation);
   }
   async reopenCachedRoutes() {
-    for (const cached of this.routes.values())
-      cached.handle = null;
-    for (const cached of this.routes.values()) {
-      if (cached.closed)
-        continue;
-      const handle = await this.routeOpen(cached.target, cached.identity, {
-        consumerIdentity: cached.consumerIdentity ?? null
-      });
-      if (cached.closed) {
-        this.liveRoutes.delete(handle.channel);
-        this.sendRouteGoodbye(handle);
+    const routeKeys = [...this.routes.keys()];
+    for (const key of routeKeys) {
+      const cached = this.routes.get(key);
+      if (cached)
+        cached.handle = null;
+    }
+    for (const key of routeKeys) {
+      const cached = this.routes.get(key);
+      if (!cached || cached.closed)
         continue;
+      try {
+        const handle = await this.routeOpen(cached.target, cached.identity, {
+          consumerIdentity: cached.consumerIdentity ?? null,
+          reverseRequests: cached.reverseRequests
+        });
+        if (cached.closed) {
+          this.liveRoutes.delete(handle.channel);
+          this.sendRouteGoodbye(handle);
+          continue;
+        }
+        cached.handle = handle;
+      } catch (error) {
+        if (isRouteOpenRefusal(error)) {
+          this.routes.delete(key);
+          continue;
+        }
+        throw error;
       }
-      cached.handle = handle;
     }
   }
   timeoutMessage(channel, corr, ms) {
@@ -11935,6 +12064,10 @@ class SubcClient {
         return;
       }
     }
+    if (frame.header.ty === FrameType.Request && handle) {
+      this.dispatchReverseRequest(frame, handle);
+      return;
+    }
     const key = pendingKey(handle, frame.header.corr);
     const pending = this.pending.get(key);
     if (pending) {
@@ -11988,10 +12121,49 @@ class SubcClient {
   rejectPending(key, pending, err) {
     this.settle(key, pending, () => pending.reject(pending.classifyFailure?.(err) ?? err));
   }
+  dispatchReverseRequest(frame, handle) {
+    const method = reverseRequestMethod(frame.body);
+    const methodFamily = method?.split("/", 1)[0];
+    const handler = methodFamily ? reverseRequestHandler(handle, methodFamily) : undefined;
+    const sock = this.sock;
+    const generation = this.generation;
+    const reply = async () => {
+      if (!handler || !method) {
+        await this.sendReverseError(frame, handle, "reverse_request_unhandled", methodFamily ? `no reverse-request handler is registered for ${methodFamily}` : "reverse request has no valid method", sock, generation);
+        return;
+      }
+      let body;
+      try {
+        body = await handler(frame.body, { corr: frame.header.corr, method });
+        if (!(body instanceof Uint8Array)) {
+          throw new TypeError("reverse-request handler must return a Uint8Array");
+        }
+      } catch (error) {
+        await this.sendReverseError(frame, handle, "reverse_request_unhandled", error instanceof Error ? error.message : String(error), sock, generation);
+        return;
+      }
+      await this.sendReverseReply(frame, handle, FrameType.Response, body, sock, generation);
+    };
+    reply().catch((error) => {
+      if (this.sock === sock && this.generation === generation && !this.closeStarted) {
+        debug("failed to answer reverse request: %s", causeMessage(error));
+      }
+    });
+  }
+  async sendReverseError(request, handle, code, message, sock, generation) {
+    await this.sendReverseReply(request, handle, FrameType.Error, this.encode({ code, message }), sock, generation);
+  }
+  async sendReverseReply(request, handle, type, body, sock, generation) {
+    if (this.sock !== sock || this.generation !== generation || !this.isLiveHandle(handle) || this.closeStarted || this.closedErr) {
+      return;
+    }
+    const frame = buildFrame(type, buildFlags(false, Priority.Interactive, false), handle.channel, handle.epoch, request.header.corr, body);
+    await writeBorrowed(sock, encodeFrame(frame), Date.now() + DEFAULT_REQUEST_TIMEOUT_MS);
+  }
   errorFromFrame(frame) {
     try {
       const parsed = JSON.parse(Buffer.from(frame.body).toString("utf8"));
-      return new SubcError(parsed.message ?? "subc error", parsed.code);
+      return new SubcError(parsed.message ?? "subc error", parsed.code, parsed.detail);
     } catch {
       return new SubcError(Buffer.from(frame.body).toString("utf8") || "subc error");
     }
@@ -12036,8 +12208,8 @@ class SubcClient {
   get droppedIngressFrames() {
     return this.ingressEpochDropCount;
   }
-  installRoute(channel, epoch) {
-    const handle = createRouteHandle(channel, epoch, this.connectionToken);
+  installRoute(channel, epoch, reverseRequests = new ReverseRequestRegistry) {
+    const handle = createRouteHandle(channel, epoch, this.connectionToken, reverseRequests);
     this.liveRoutes.set(channel, handle);
     return handle;
   }
@@ -12074,6 +12246,9 @@ class SubcClient {
   encode(value) {
     return Buffer.from(JSON.stringify(value), "utf8");
   }
+  decodeReply(frame) {
+    return hasBinary(frame.header.flags) ? frame.body : this.parseJson(frame);
+  }
   parseJson(frame) {
     const b = frame.body;
     return JSON.parse(Buffer.from(b.buffer, b.byteOffset, b.byteLength).toString("utf8"));
@@ -12093,7 +12268,12 @@ function isConsumerReconnectTransient(err) {
   const code = errorCode(err);
   return code === "ECONNREFUSED" || code === "ECONNRESET" || code === "EPIPE" || code === "ETIMEDOUT" || code === "ENOENT";
 }
+function isRouteOpenRefusal(err) {
+  return err instanceof SubcError && typeof err.code === "string";
+}
 function isRetryableRouteOpenCode(code) {
+  if (code === "capability_forbidden")
+    return false;
   return code === "unknown_module" || code === "module_reloading" || code === "module_warming" || code === "target_unavailable" || code === "module_timeout";
 }
 async function connectionFileExists(path) {
@@ -12112,14 +12292,35 @@ function normalizeConnectOptions(opts) {
     targetKind: opts.targetKind ?? DEFAULT_MANAGED_TARGET_KIND,
     reconnectBackoff: opts.reconnectBackoff ?? DEFAULT_RECONNECT_BACKOFF,
     sleep: opts.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms))),
+    routeOpenRetryDeadlineMs: opts.routeOpenRetryDeadlineMs ?? ROUTE_OPEN_RETRY_DEADLINE_MS,
     timeoutArbitrationGraceMs: opts.timeoutArbitrationGraceMs ?? TIMEOUT_ARBITRATION_GRACE_MS,
     livenessProbeWindowMs: opts.livenessProbeWindowMs ?? LIVENESS_PROBE_WINDOW_MS,
     onControlPush: opts.onControlPush
   };
 }
-function routeCacheKey(target, identity, consumerIdentity) {
+function isValidCapabilityIdentifier(identifier) {
+  if (/\s/u.test(identifier))
+    return false;
+  const separator = identifier.indexOf("/v");
+  if (separator <= 0 || identifier.indexOf("/v", separator + 1) !== -1)
+    return false;
+  const name = identifier.slice(0, separator);
+  const version = identifier.slice(separator + 2);
+  if (new TextEncoder().encode(name).byteLength > 64 || version.length === 0)
+    return false;
+  if (!/^[a-z][a-z0-9-]*[a-z0-9]$/u.test(name) && !/^[a-z]$/u.test(name))
+    return false;
+  if (name.includes("--"))
+    return false;
+  if (!/^\d+$/u.test(version) || version.length > 1 && version.startsWith("0"))
+    return false;
+  const numericVersion = Number(version);
+  return Number.isSafeInteger(numericVersion) && numericVersion >= 1 && numericVersion <= 4294967295;
+}
+function routeCacheKey(target, identity, consumerIdentity, consumerCapabilities) {
   const consumerPart = consumerIdentity ? `${consumerIdentity.module_id}\x00${consumerIdentity.launch_nonce}` : "";
-  return `${target.kind}\x00${target.module_id}\x00${identity.project_root}\x00${identity.harness}\x00${identity.session}\x00${consumerPart}`;
+  const capabilitiesPart = [...consumerCapabilities].sort().join("\x00");
+  return `${target.kind}\x00${target.module_id}\x00${identity.project_root}\x00${identity.harness}\x00${identity.session}\x00${consumerPart}\x00${capabilitiesPart}`;
 }
 function routeOpenConsumerIdentity(opts = {}) {
   if (opts.consumerIdentity !== undefined)
@@ -12146,6 +12347,14 @@ function causeMessage(cause) {
 function pendingKey(handle, corr) {
   return handle ? `${handle.channel}:${handle.epoch}:${corr}` : `0:0:${corr}`;
 }
+function reverseRequestMethod(body) {
+  try {
+    const parsed = JSON.parse(Buffer.from(body).toString("utf8"));
+    return typeof parsed.method === "string" && parsed.method.length > 0 ? parsed.method : undefined;
+  } catch {
+    return;
+  }
+}
 // ../aft-bridge/dist/subc-transport.js
 import { existsSync as existsSync4, statSync as statSync3 } from "node:fs";
 
@@ -12629,8 +12838,16 @@ 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 SUBC_DEFAULT_REQUEST_TIMEOUT_MS = 30000;
+var ROUTE_OPEN_RELOAD_WAIT_CEILING_MS = 45000;
+function reloadWaitExhaustedSuffix(callDeadlineMs) {
+  if (callDeadlineMs > ROUTE_OPEN_RELOAD_WAIT_CEILING_MS) {
+    const ceilingSeconds = ROUTE_OPEN_RELOAD_WAIT_CEILING_MS / 1000;
+    return ` The AFT daemon module did not return within the ${ceilingSeconds}s reload-wait ceiling.`;
+  }
+  const seconds = Math.round(callDeadlineMs / 100) / 10;
+  return ` The AFT daemon module did not return within this call's ${seconds}s deadline.`;
+}
 var BG_STABLE_MS = 5000;
 function reconnectBackoffMs(attempt) {
   return Math.min(RECONNECT_RETRY_FLOOR_MS * 2 ** Math.min(attempt, 6), RECONNECT_RETRY_CAP_MS);
@@ -12939,14 +13156,15 @@ function isAbsentRootRouteError(err) {
 function absentRootError(root) {
   return new SubcError(`invalid route project root: project root does not exist: ${root}`, "config_divergence");
 }
-function reloadWindowExhaustedError(error) {
+function reloadWindowExhaustedError(error, callDeadlineMs) {
+  const suffix = reloadWaitExhaustedSuffix(callDeadlineMs);
   if (error instanceof Error) {
     try {
-      error.message += ROUTE_OPEN_RELOAD_WAIT_EXHAUSTED_SUFFIX;
+      error.message += suffix;
       return error;
     } catch {}
   }
-  return new Error(`${String(error)}${ROUTE_OPEN_RELOAD_WAIT_EXHAUSTED_SUFFIX}`);
+  return new Error(`${String(error)}${suffix}`);
 }
 function safeCloseRoute(client, route) {
   try {
@@ -13551,18 +13769,20 @@ class SubcTransportPool {
           throw error;
         }
       };
+      const callDeadlineMs = timeoutMs ?? SUBC_DEFAULT_REQUEST_TIMEOUT_MS;
+      const reloadWaitBudgetMs = Math.min(callDeadlineMs, ROUTE_OPEN_RELOAD_WAIT_CEILING_MS);
+      let reloadWaitedMs = 0;
       const openRouteAfterReloadWindow = async () => {
-        let reloadWaitedMs = 0;
         while (true) {
           try {
             return await openRoute();
           } catch (error) {
             if (!isRouteOpenReloadWindowError(error))
               throw error;
-            const { delayMs, wait } = this.waitForRouteReopenBackoff();
-            if (reloadWaitedMs + delayMs > ROUTE_OPEN_RELOAD_WAIT_CAP_MS) {
-              throw reloadWindowExhaustedError(error);
+            if (reloadWaitedMs + this.nextRouteReopenDelayMs() >= reloadWaitBudgetMs) {
+              throw reloadWindowExhaustedError(error, callDeadlineMs);
             }
+            const { delayMs, wait } = this.waitForRouteReopenBackoff();
             reloadWaitedMs += delayMs;
             await wait;
           }
@@ -13608,7 +13828,8 @@ class SubcTransportPool {
         };
         abortSignal?.addEventListener("abort", onAbort, { once: true });
         try {
-          const request = client.request(route, body, { timeoutMs, onProgress });
+          const requestTimeoutMs = reloadWaitedMs > 0 ? callDeadlineMs - reloadWaitedMs : timeoutMs;
+          const request = client.request(route, body, { timeoutMs: requestTimeoutMs, onProgress });
           const reply = abortSignal ? await Promise.race([request, aborted]) : await request;
           if (!this.isCurrentSession(key, record)) {
             if (this.isReapInduced(record))
@@ -13625,28 +13846,41 @@ class SubcTransportPool {
         }
       };
       let routeAndEntry = await openRouteAfterReloadWindow();
-      try {
-        return await requestOnRoute(routeAndEntry.route, routeAndEntry.entry);
-      } catch (error) {
-        if (this.isReapInduced(record))
-          throw this.annotateReapError(error, record);
-        if (isRouteProvenAbsentError(error) && this.isCurrentSession(key, record) && this.client === client) {
-          clearRouteEntry(routeAndEntry.entry);
-          await this.waitForRouteReopenBackoff().wait;
-          routeAndEntry = await openRouteAfterReloadWindow();
-          try {
-            const reply = await requestOnRoute(routeAndEntry.route, routeAndEntry.entry);
+      let reopened = false;
+      let retriedAbsentRoute = false;
+      while (true) {
+        try {
+          const reply = await requestOnRoute(routeAndEntry.route, routeAndEntry.entry);
+          if (reopened)
             this.resetRouteReopenBackoff();
-            return reply;
-          } catch (retryError) {
-            if (this.isReapInduced(record))
-              throw this.annotateReapError(retryError, record);
-            handleRequestFailure(retryError, routeAndEntry.entry);
-            throw retryError;
+          return reply;
+        } catch (error) {
+          if (this.isReapInduced(record))
+            throw this.annotateReapError(error, record);
+          const ownsRoute = this.isCurrentSession(key, record) && this.client === client;
+          if (ownsRoute && isRouteRequestReloadRefusal(error)) {
+            clearRouteEntry(routeAndEntry.entry);
+            if (reloadWaitedMs + this.nextRouteReopenDelayMs() >= reloadWaitBudgetMs) {
+              throw reloadWindowExhaustedError(error, callDeadlineMs);
+            }
+            const { delayMs, wait } = this.waitForRouteReopenBackoff();
+            reloadWaitedMs += delayMs;
+            await wait;
+            routeAndEntry = await openRouteAfterReloadWindow();
+            reopened = true;
+            continue;
           }
+          if (ownsRoute && !retriedAbsentRoute && isRouteProvenAbsentError(error)) {
+            retriedAbsentRoute = true;
+            clearRouteEntry(routeAndEntry.entry);
+            await this.waitForRouteReopenBackoff().wait;
+            routeAndEntry = await openRouteAfterReloadWindow();
+            reopened = true;
+            continue;
+          }
+          handleRequestFailure(error, routeAndEntry.entry);
+          throw error;
         }
-        handleRequestFailure(error, routeAndEntry.entry);
-        throw error;
       }
     } catch (error) {
       if (this.isReapInduced(record))
@@ -13675,6 +13909,11 @@ class SubcTransportPool {
     this.routeReopenRetryMs = delayMs;
     return { delayMs, wait: retry };
   }
+  nextRouteReopenDelayMs() {
+    if (this.routeReopenRetry && this.routeReopenRetryMs !== null)
+      return this.routeReopenRetryMs;
+    return this.routeReopenRetryDelayMs;
+  }
   resetRouteReopenBackoff() {
     this.routeReopenRetryDelayMs = RECONNECT_RETRY_FLOOR_MS;
   }
@@ -13966,6 +14205,12 @@ function isRouteOpenReloadWindowError(error) {
   const code = error.code;
   return code === "module_reloading" || code === "module_warming" || code === "target_unavailable";
 }
+function isRouteRequestReloadRefusal(error) {
+  if (error instanceof SubcCallError) {
+    return error.kind === "not_sent" && error.code === "module_reloading";
+  }
+  return error instanceof SubcError && error.code === "module_reloading";
+}
 function hasEngineResponse(error) {
   const response = error.response;
   if (response !== null && typeof response === "object")
@@ -18154,7 +18399,7 @@ import {
 // package.json
 var package_default = {
   name: "@cortexkit/aft-pi",
-  version: "0.57.0",
+  version: "0.57.2",
   type: "module",
   description: "Pi coding agent extension for Agent File Tools (AFT) — tree-sitter and LSP-powered code analysis",
   main: "dist/index.js",
@@ -18177,19 +18422,19 @@ var package_default = {
     "test:unit": "bun test src/__tests__ --path-ignore-patterns 'src/__tests__/e2e/**'"
   },
   dependencies: {
-    "@cortexkit/aft-bridge": "0.57.0",
+    "@cortexkit/aft-bridge": "0.57.2",
     "comment-json": "^5.0.0",
     diff: "^8.0.4",
     typebox: "1.1.38",
     zod: "^4.4.3"
   },
   optionalDependencies: {
-    "@cortexkit/aft-darwin-arm64": "0.57.0",
-    "@cortexkit/aft-darwin-x64": "0.57.0",
-    "@cortexkit/aft-linux-arm64": "0.57.0",
-    "@cortexkit/aft-linux-x64": "0.57.0",
-    "@cortexkit/aft-win32-arm64": "0.57.0",
-    "@cortexkit/aft-win32-x64": "0.57.0"
+    "@cortexkit/aft-darwin-arm64": "0.57.2",
+    "@cortexkit/aft-darwin-x64": "0.57.2",
+    "@cortexkit/aft-linux-arm64": "0.57.2",
+    "@cortexkit/aft-linux-x64": "0.57.2",
+    "@cortexkit/aft-win32-arm64": "0.57.2",
+    "@cortexkit/aft-win32-x64": "0.57.2"
   },
   devDependencies: {
     "@earendil-works/pi-coding-agent": "^0.80.2",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cortexkit/aft-pi",
-  "version": "0.57.0",
+  "version": "0.57.2",
   "type": "module",
   "description": "Pi coding agent extension for Agent File Tools (AFT) — tree-sitter and LSP-powered code analysis",
   "main": "dist/index.js",
@@ -23,19 +23,19 @@
     "test:unit": "bun test src/__tests__ --path-ignore-patterns 'src/__tests__/e2e/**'"
   },
   "dependencies": {
-    "@cortexkit/aft-bridge": "0.57.0",
+    "@cortexkit/aft-bridge": "0.57.2",
     "comment-json": "^5.0.0",
     "diff": "^8.0.4",
     "typebox": "1.1.38",
     "zod": "^4.4.3"
   },
   "optionalDependencies": {
-    "@cortexkit/aft-darwin-arm64": "0.57.0",
-    "@cortexkit/aft-darwin-x64": "0.57.0",
-    "@cortexkit/aft-linux-arm64": "0.57.0",
-    "@cortexkit/aft-linux-x64": "0.57.0",
-    "@cortexkit/aft-win32-arm64": "0.57.0",
-    "@cortexkit/aft-win32-x64": "0.57.0"
+    "@cortexkit/aft-darwin-arm64": "0.57.2",
+    "@cortexkit/aft-darwin-x64": "0.57.2",
+    "@cortexkit/aft-linux-arm64": "0.57.2",
+    "@cortexkit/aft-linux-x64": "0.57.2",
+    "@cortexkit/aft-win32-arm64": "0.57.2",
+    "@cortexkit/aft-win32-x64": "0.57.2"
   },
   "devDependencies": {
     "@earendil-works/pi-coding-agent": "^0.80.2",