@cortexkit/aft-bridge 0.64.0 → 0.65.0

package/dist/subc-transport.js

@@ -24,6 +24,7 @@ import { isRouteOpenReloadWindowError, isRouteRequestReloadRefusal } from "./err
 import { asCanonicalRootPath, asRootGeneration, LifecycleRegistry, } from "./lifecycle-registry.js";
 import { canonicalizeProjectRoot } from "./project-identity.js";
 import { callPresetFor, HOST_TOOL_NAMES_FIELD, PRESET_FIELD, WORKER_SESSION_FIELD, } from "./transport.js";
+import { deadlineTimer, RESUME_ALLOWANCE_MS, RequestDeadline, WaitClock } from "./wait-clock.js";
 /** The subc pool is closing and cannot carry another request. */
 export class SubcTransportShuttingDownError extends SubcCallError {
     constructor() {
@@ -1081,6 +1082,8 @@ export class SubcTransportPool {
     harness;
     connectionFile;
     handshakeTimeoutMs;
+    clock;
+    waitClock;
     consumerIdentity;
     hostScopes;
     /** Scope identity is host-session-wide, even when the session uses multiple project roots. */
@@ -1144,6 +1147,13 @@ export class SubcTransportPool {
     editSlotSurvives;
     editSlotSurvivesCaptured = false;
     constructor(options) {
+        this.clock = options.clock ?? {
+            now: () => Date.now(),
+            awakeNow: () => performance.now(),
+            setTimeout: (callback, ms) => setTimeout(callback, ms),
+            clearTimeout: (timer) => clearTimeout(timer),
+        };
+        this.waitClock = new WaitClock(() => this.clock.now(), () => this.clock.awakeNow?.() ?? this.clock.now());
         this.connectionFile = options.connectionFile;
         this.harness = options.harness;
         this.handshakeTimeoutMs = options.handshakeTimeoutMs;
@@ -1865,12 +1875,13 @@ export class SubcTransportPool {
     }
     /** Open or reuse a route while guarding every lifecycle boundary. */
     async routeRequest(identity, body, timeoutMs, onProgress, expectedGeneration, abortSignal) {
-        const callStartedAt = performance.now();
+        const callStartedAt = this.waitClock.now();
         const callDeadlineMs = timeoutMs ?? SUBC_DEFAULT_REQUEST_TIMEOUT_MS;
+        const deadline = new RequestDeadline(this.waitClock, callDeadlineMs);
         // Charge shared backoff delays even when an injected sleeper advances no real time.
         let scheduledDelayMs = 0;
-        const spentMs = () => Math.max(performance.now() - callStartedAt, scheduledDelayMs);
-        const remainingMs = () => callDeadlineMs - spentMs();
+        const spentMs = () => Math.max(this.waitClock.now() - callStartedAt, scheduledDelayMs);
+        const remainingMs = () => deadline.remaining() - Math.max(0, scheduledDelayMs - (this.waitClock.now() - callStartedAt));
         const root = asCanonicalRootPath(identity.project_root);
         let generation = expectedGeneration;
         if (this.lifecycleEnabled()) {
@@ -1891,13 +1902,13 @@ export class SubcTransportPool {
                     const remaining = remainingMs();
                     if (remaining <= 0)
                         throw keyChanged ?? callDeadlinePassedError(undefined, callDeadlineMs);
-                    let timer;
+                    let cancelTimer;
                     try {
                         // Each attempt calls SubcClient.connect anew, which re-reads the connection file.
                         const acquired = await Promise.race([
                             this.ensureClient(),
                             new Promise((resolve) => {
-                                timer = setTimeout(() => resolve(CALL_DEADLINE_EXPIRED), remaining);
+                                cancelTimer = deadlineTimer(this.clock, remainingMs, () => resolve(CALL_DEADLINE_EXPIRED));
                             }),
                         ]);
                         if (acquired === CALL_DEADLINE_EXPIRED) {
@@ -1914,24 +1925,24 @@ export class SubcTransportPool {
                             throw error;
                     }
                     finally {
-                        clearTimeout(timer);
+                        cancelTimer?.();
                     }
                     const { delayMs, wait } = this.waitForRouteReopenBackoff();
                     scheduledDelayMs = spentMs() + delayMs;
                     // A shared retry sleeper may outlive this caller's remaining budget.
-                    let retryTimer;
+                    let cancelRetryTimer;
                     try {
                         const waited = await Promise.race([
                             wait,
                             new Promise((resolve) => {
-                                retryTimer = setTimeout(() => resolve(CALL_DEADLINE_EXPIRED), callDeadlineMs - (performance.now() - callStartedAt));
+                                cancelRetryTimer = deadlineTimer(this.clock, remainingMs, () => resolve(CALL_DEADLINE_EXPIRED));
                             }),
                         ]);
                         if (waited === CALL_DEADLINE_EXPIRED)
                             throw keyChanged;
                     }
                     finally {
-                        clearTimeout(retryTimer);
+                        cancelRetryTimer?.();
                     }
                 }
                 this.assertRecordLive(record);
@@ -1996,9 +2007,9 @@ export class SubcTransportPool {
                 const remaining = remainingMs();
                 if (remaining <= 0)
                     throw callDeadlinePassedError(lastRefusal, callDeadlineMs);
-                let timer;
+                let cancelTimer;
                 const expired = new Promise((resolve) => {
-                    timer = setTimeout(() => resolve(CALL_DEADLINE_EXPIRED), remaining);
+                    cancelTimer = deadlineTimer(this.clock, remainingMs, () => resolve(CALL_DEADLINE_EXPIRED));
                 });
                 try {
                     const opened = await Promise.race([openRoute(), expired]);
@@ -2008,7 +2019,7 @@ export class SubcTransportPool {
                     return opened;
                 }
                 finally {
-                    clearTimeout(timer);
+                    cancelTimer?.();
                 }
             };
             const openRouteAfterReloadWindow = async () => {
@@ -2101,8 +2112,13 @@ export class SubcTransportPool {
                     entry.inflight += 1;
                     let request;
                     try {
+                        // The SDK re-arms an expired request once across sleep, retaining
+                        // its correlation while a wake-delayed reply is delivered.
                         request = client.request(route, body, {
                             timeoutMs: Math.ceil(requestTimeoutMs),
+                            // Disable SDK sleep grace if admission already granted the call
+                            // its one resume allowance.
+                            ...(deadline.resumed ? { sleepGraceMs: 0 } : {}),
                             onProgress,
                         });
                     }
@@ -2262,6 +2278,7 @@ export class SubcTransportPool {
         this.connecting = this.connectFn({
             connectionFile: this.connectionFile,
             handshakeTimeoutMs: this.handshakeTimeoutMs,
+            sleepGraceMs: RESUME_ALLOWANCE_MS,
             onControlPush: (push) => {
                 if (owner && this.client === owner)
                     this.onScopeRouteClose(push);