@cortexkit/subc-client 0.2.0 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cortexkit/subc-client",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "TypeScript client for the subc daemon. Wire-compatible (byte-for-byte) with the Rust subc-transport handshake and subc-protocol envelope.",
   "type": "module",
   "exports": {

package/src/client.ts

@@ -521,7 +521,7 @@ export class SubcClient {
         timer: null,
       };
       pending.timer = setTimeout(() => {
-        this.rejectPending(key, pending, new SubcError(`request on channel ${channel} timed out after ${ms}ms`));
+        this.rejectPending(key, pending, new SubcError(this.timeoutMessage(channel, corr, ms)));
       }, ms);
       this.pending.set(key, pending);
       this.sock.write(encodeFrame(frame), Date.now() + ms).catch((err) => {
@@ -586,7 +586,7 @@ export class SubcClient {
         classifyFailure,
       };
       pending.timer = setTimeout(() => {
-        this.rejectPending(key, pending, new SubcError(`request on channel ${channel} timed out after ${ms}ms`));
+        this.rejectPending(key, pending, new SubcError(this.timeoutMessage(channel, corr, ms)));
       }, ms);
       this.pending.set(key, pending);
 
@@ -752,7 +752,14 @@ export class SubcClient {
     }
     for (const cached of this.routes.values()) {
       if (cached.closed) continue; // closed concurrently with reconnect — don't reopen.
-      const channel = await this.routeOpen(cached.target, cached.identity);
+      // Thread the route's consumer identity through the reopen, exactly as the
+      // lazy per-call path (openCachedRoute) does. Dropping it here would make a
+      // route reopened after a reconnect send route.open with no consumer_identity,
+      // so the daemon would re-stamp it with a different (weaker) principal than the
+      // one it was originally bound under — a silent post-reconnect trust downgrade.
+      const channel = await this.routeOpen(cached.target, cached.identity, {
+        consumerIdentity: cached.consumerIdentity ?? null,
+      });
       // A closeRoute may have raced this reopen (flipping the tombstone during the
       // route.open await). If so, GOODBYE the channel instead of installing it, so the
       // closed route isn't silently re-established on the new connection.
@@ -765,6 +772,16 @@ export class SubcClient {
     }
   }
 
+  // A request timeout carries the local socket port and (channel, corr) so a
+  // packet capture can pinpoint the exact on-wire exchange — the decisive evidence
+  // for whether a "timed out" reply was actually delivered to this socket (a
+  // client-local demux problem) or never sent (a daemon/module problem).
+  private timeoutMessage(channel: number, corr: bigint, ms: number): string {
+    const port = this.sock.localPort();
+    const where = port === null ? "channel" : `local_port=${port} channel`;
+    return `request on ${where} ${channel} corr ${corr} timed out after ${ms}ms`;
+  }
+
   private routeClosedDuringOpen(): SubcCallError {
     return new SubcCallError("not_sent", "route was closed before route.open completed", "route_closed");
   }

package/src/socket.ts

@@ -64,6 +64,15 @@ export class SubcSocket {
     sock.on("close", () => fail(new SocketClosedError("subc connection closed")));
   }
 
+  /**
+   * The OS-assigned local TCP port of this connection, or null if not yet
+   * connected/closed. Used to correlate a client-side timeout with a specific
+   * socket in a packet capture when diagnosing reply-delivery issues.
+   */
+  localPort(): number | null {
+    return this.sock.localPort ?? null;
+  }
+
   static connect(host: string, port: number, deadlineMs: number): Promise<SubcSocket> {
     return new Promise((resolve, reject) => {
       const sock = net.connect({ host, port });