@forgecart/sdk 1.202610241216.0 → 1.202610241437.0

package/dist/client.generated.d.ts

@@ -173,6 +173,11 @@ export declare class BaseGraphQLClient {
      * sink callback, never the operation's lifetime, so a connected stream runs
      * for as long as the server streams it. Both bounds raise the same typed
      * code, so one consumer branch answers for both.
+     *
+     * Disposing the client ends the operation with WS_CLIENT_DISPOSED while it
+     * still waits on a handshake (#2102) or, as a query or a mutation, on its
+     * answer (#1572): graphql-ws would leave the first waiting forever and
+     * COMPLETE the second with no value — see settlePendingOperations.
      */
     private executeWsOperation;
     /**
@@ -212,6 +217,16 @@ export declare class BaseGraphQLClient {
      * is specific to the bound that raised it, such as #2102's endpoint.
      */
     private wsTimeoutError;
+    /**
+     * The ONE error a disposed client raises (#1994, #2102, #1572): for an
+     * operation started after dispose(), for one still waiting on a handshake,
+     * and for a query or a mutation still waiting on its answer. Named, so a
+     * consumer's error path tells an operation its own client cut off from one
+     * the server failed; carrying the endpoint, so a late one stays attributable.
+     * Never routed through the error handler: the disposal is the caller's own
+     * act, not a fault worth a notification.
+     */
+    private clientDisposedError;
     /**
      * Uniform error contract for the sink-level error path. graphql-ws
      * delivers a server ErrorMessage payload as a raw GraphQLError[] —
@@ -252,27 +267,35 @@ export declare class BaseGraphQLClient {
     private settleWsDisposal;
     private describeFailure;
     /**
-     * Ends every operation still waiting on a handshake this socket never
-     * answered, where its owner stands (#2102). graphql-ws speaks to the sinks
-     * of operations its socket CARRIED; an unanswered handshake carried none, so
-     * its disposal says nothing to them and they wait forever on a client that
-     * will never connect again — and the caller awaiting one waits with it
-     * (measured from the far end as backends left idle in transaction on a wait
-     * the client had already abandoned). Erroring from the BOUND is the thing
-     * this must not do: that fires 10 s later, in whatever context is alive
-     * then. dispose() is the owner's own stack, so a rejection lands there.
+     * Ends, where its owner stands, every operation graphql-ws's disposal would
+     * leave without an ending it can use, with WS_CLIENT_DISPOSED. graphql-ws
+     * speaks to the sinks of operations its socket CARRIED. An unanswered
+     * handshake carried none, so its disposal says nothing to them and they wait
+     * forever on a client that will never connect again — and the caller
+     * awaiting one waits with it (#2102; measured from the far end as backends
+     * left idle in transaction on a wait the client had already abandoned). A
+     * query or a mutation it carried unanswered it COMPLETES with no value,
+     * which no consumer can tell from a request never made (#1572). Erroring
+     * from the BOUND is the thing this must not do: that fires 10 s later, in
+     * whatever context is alive then. dispose() is the owner's own stack, so a
+     * rejection lands there. A subscription past its handshake is not here: a
+     * stream its client ended completes truthfully, and an operation whose
+     * answer arrived left the registry with it.
      *
      * The socket's owner ends every operation on it, forks included — the same
      * reason the socket rather than the client carries the disposed flag. A fork
      * owns no socket and ends only what it started, leaving its owner on the
      * wire. Idempotent: an entry settles once and deregisters itself doing so.
      */
-    private settlePendingHandshakes;
+    private settlePendingOperations;
     /**
      * Terminal (#1994). Ends the socket, ends any retry in flight, ends every
-     * operation still waiting on a handshake (#2102), and refuses every later
-     * operation with WS_CLIENT_DISPOSED — a disposed client never mints another
-     * socket. Idempotent and synchronous; never throws.
+     * operation still waiting on a handshake (#2102) and every query or
+     * mutation still waiting on its answer (#1572) with WS_CLIENT_DISPOSED, and
+     * refuses every later operation with the same error — a disposed client
+     * never mints another socket. An answer that already arrived is kept, and a
+     * subscription the socket carried completes. Idempotent and synchronous;
+     * never throws.
      */
     dispose(): void;
     fork(transactionToken: string): BaseGraphQLClient;

package/dist/client.generated.js

@@ -116,8 +116,9 @@ const WS_FIRST_VALUE_BUDGET_MS_BY_OPERATION = {
 // `disposed` is that socket's terminal end, and it lives here rather than
 // on the client because every client still holding the socket — the forks
 // included — is off the wire the moment its owner ends it. `pending` is
-// socket-level for exactly that reason too (#2102): a handshake belongs to
-// the socket, so ending the socket must end everything still waiting on it.
+// socket-level for exactly that reason too (#2102, #1572): an operation
+// waiting on the wire belongs to the socket, so ending the socket must end
+// everything still waiting on it.
 const WS_CONNECTION_STATE = new WeakMap();
 class BaseGraphQLClient {
     baseHeaders;
@@ -170,7 +171,7 @@ class BaseGraphQLClient {
         if (this.disposed) {
             // A fresh socket here would start the retry ladder its owner just ended;
             // the operation fails fast and typed instead, on the caller that asked.
-            throw new ClientError({ errors: [{ message: "WS_CLIENT_DISPOSED", extensions: { endpoint: this.endpoint } }] }, "WS_CLIENT_DISPOSED");
+            throw this.clientDisposedError();
         }
         if (this.wsClient && this.wsClientStale) {
             this.disposeWsClient();
@@ -382,6 +383,11 @@ class BaseGraphQLClient {
      * sink callback, never the operation's lifetime, so a connected stream runs
      * for as long as the server streams it. Both bounds raise the same typed
      * code, so one consumer branch answers for both.
+     *
+     * Disposing the client ends the operation with WS_CLIENT_DISPOSED while it
+     * still waits on a handshake (#2102) or, as a query or a mutation, on its
+     * answer (#1572): graphql-ws would leave the first waiting forever and
+     * COMPLETE the second with no value — see settlePendingOperations.
      */
     executeWsOperation(document, variables, kind) {
         return new QueryObservable((subscriber) => {
@@ -390,6 +396,10 @@ class BaseGraphQLClient {
             // that replaced the boolean this method used to take.
             const singleDelivery = kind === WsOperationKind.MUTATION;
             const firstValueBudgetMs = this.getFirstValueBudgetMs(kind, this.operationNameOf(document));
+            // A query or a mutation is a REQUEST: its completion means something only
+            // once an answer arrived. A subscription is a stream its client may end at
+            // any point, so a disposal that completes it reports the truth (#1572).
+            const awaitsAnswer = kind !== WsOperationKind.SUBSCRIPTION;
             let disposed = false;
             // Delivery latch: once ANY sink callback has fired, the wire has
             // spoken and a socket close can no longer mean "delivery unknown".
@@ -407,8 +417,10 @@ class BaseGraphQLClient {
             // object and a browser a number, and the generated client must typecheck
             // in both without an @types/node-only name.
             let operationDeadline;
-            // This operation's entry in the socket's pending-handshake registry,
-            // present for exactly as long as the bound is armed (#2102).
+            // This operation's entry in the socket's pending registry, present for
+            // exactly as long as dispose() would otherwise leave it without an ending:
+            // while it waits on a handshake (#2102) and, for a request, until the
+            // wire answers it (#1572).
             let pendingEntry;
             const offConnectionEvents = [];
             // Disarms the first-value deadline. Reached on the first sink callback
@@ -419,27 +431,33 @@ class BaseGraphQLClient {
                 clearTimeout(operationDeadline);
                 operationDeadline = undefined;
             };
-            // Disarms the bound AND deregisters the operation, because those are one
-            // fact: a handshake that no longer needs bounding is one dispose() no
-            // longer has to settle. Reached on the ACK, on the delivery latch and on
-            // teardown — every way this operation stops waiting on a handshake.
+            // Disarms the handshake bound. Reached on the ACK, on the delivery latch
+            // and on teardown — every way this operation stops waiting on a handshake.
             const clearConnectionTimeout = () => {
-                if (pendingEntry !== undefined) {
-                    WS_CONNECTION_STATE.get(client)?.pending.delete(pendingEntry);
-                    pendingEntry = undefined;
-                }
                 if (connectionTimer === undefined)
                     return;
                 clearTimeout(connectionTimer);
                 connectionTimer = undefined;
             };
+            // Deregisters the operation: dispose() no longer has to end it. Reached on
+            // the delivery latch and on teardown and, for a subscription, which waits
+            // on nothing past its handshake, on the ACK. A request stays registered
+            // across the ACK — the handshake is over, its answer is still owed.
+            const leavePending = () => {
+                if (pendingEntry === undefined)
+                    return;
+                WS_CONNECTION_STATE.get(client)?.pending.delete(pendingEntry);
+                pendingEntry = undefined;
+            };
             // The wire answering IS proof the handshake completed AND the first value
-            // arrived, so the latch and BOTH bounds fall together — and a timer that
-            // outlived its operation would hold the event loop open (a hung worker).
+            // arrived, so the latch, BOTH bounds and the registration fall together —
+            // and a timer that outlived its operation would hold the event loop open
+            // (a hung worker).
             const settle = () => {
                 settled = true;
                 clearOperationDeadline();
                 clearConnectionTimeout();
+                leavePending();
             };
             // Armed BEFORE the operation is sent, so the budget measures the caller's
             // own wait rather than a window that opens once graphql-ws gets round to
@@ -527,7 +545,11 @@ class BaseGraphQLClient {
             // disposed and shouldRetry is untouched: graphql-ws keeps healing for the
             // next operation; only THIS one gives up (#2102).
             if (!(WS_CONNECTION_STATE.get(client)?.connected ?? false)) {
-                offConnectionEvents.push(client.on("connected", () => { clearConnectionTimeout(); }));
+                offConnectionEvents.push(client.on("connected", () => {
+                    clearConnectionTimeout();
+                    if (!awaitsAnswer)
+                        leavePending();
+                }));
                 connectionTimer = setTimeout(() => {
                     connectionTimer = undefined;
                     // A residual guard, no longer the settlement: dispose() has already
@@ -571,23 +593,29 @@ class BaseGraphQLClient {
                 const timerHandle = connectionTimer;
                 if (typeof timerHandle === "object" && typeof timerHandle.unref === "function")
                     timerHandle.unref();
-                // Reporting nothing when the bound elapses on a dead connection leaves
-                // something else to end this operation when its client ends — and
-                // graphql-ws is not it: its dispose() speaks to the sinks of operations
-                // its socket CARRIED, and a handshake that never completed carried none,
-                // so this one would wait forever and whoever awaited it with it.
-                // Registered for the life of the bound and settled by
-                // settlePendingHandshakes, on the disposing owner's own stack (#2102).
+            }
+            // Reporting nothing when the bound elapses on a dead connection leaves
+            // something else to end this operation when its client ends — and
+            // graphql-ws is not it. Its dispose() speaks to the sinks of operations
+            // its socket CARRIED, and a handshake that never completed carried none,
+            // so that one would wait forever and whoever awaited it with it (#2102).
+            // A request it did carry hears a bare COMPLETE — no value and no error —
+            // so map never runs, catchError never fires, an await reports an
+            // anonymous EmptyError, and the request is indistinguishable from one
+            // never made (#1572: the sidebar of #1571 kept the previous tenant's
+            // entries across a channel switch that way). Registered while either can
+            // still happen, and settled by settlePendingOperations on the disposing
+            // owner's own stack, with the error a later operation already receives.
+            if (awaitsAnswer || connectionTimer !== undefined) {
                 pendingEntry = {
                     owner: this,
                     abandon: () => {
                         if (disposed || settled)
                             return;
                         // The same disarm a wire answer performs: the latch closes and the
-                        // bound is cleared, so nothing speaks twice for this operation.
+                        // bounds are cleared, so nothing speaks twice for this operation.
                         settle();
-                        const message = "WS_CLIENT_DISPOSED";
-                        subscriber.error(new ClientError({ errors: [{ message, extensions: { endpoint: this.endpoint } }] }, message));
+                        subscriber.error(this.clientDisposedError());
                     },
                 };
                 WS_CONNECTION_STATE.get(client)?.pending.add(pendingEntry);
@@ -609,6 +637,7 @@ class BaseGraphQLClient {
                 disposed = true;
                 clearOperationDeadline();
                 clearConnectionTimeout();
+                leavePending();
                 for (const off of offConnectionEvents)
                     off();
                 cleanup();
@@ -691,6 +720,19 @@ class BaseGraphQLClient {
         };
         return new ClientError({ errors: [{ message, extensions }] }, message);
     }
+    /**
+     * The ONE error a disposed client raises (#1994, #2102, #1572): for an
+     * operation started after dispose(), for one still waiting on a handshake,
+     * and for a query or a mutation still waiting on its answer. Named, so a
+     * consumer's error path tells an operation its own client cut off from one
+     * the server failed; carrying the endpoint, so a late one stays attributable.
+     * Never routed through the error handler: the disposal is the caller's own
+     * act, not a fault worth a notification.
+     */
+    clientDisposedError() {
+        const message = "WS_CLIENT_DISPOSED";
+        return new ClientError({ errors: [{ message, extensions: { endpoint: this.endpoint } }] }, message);
+    }
     /**
      * Uniform error contract for the sink-level error path. graphql-ws
      * delivers a server ErrorMessage payload as a raw GraphQLError[] —
@@ -857,22 +899,27 @@ class BaseGraphQLClient {
         return String(value);
     }
     /**
-     * Ends every operation still waiting on a handshake this socket never
-     * answered, where its owner stands (#2102). graphql-ws speaks to the sinks
-     * of operations its socket CARRIED; an unanswered handshake carried none, so
-     * its disposal says nothing to them and they wait forever on a client that
-     * will never connect again — and the caller awaiting one waits with it
-     * (measured from the far end as backends left idle in transaction on a wait
-     * the client had already abandoned). Erroring from the BOUND is the thing
-     * this must not do: that fires 10 s later, in whatever context is alive
-     * then. dispose() is the owner's own stack, so a rejection lands there.
+     * Ends, where its owner stands, every operation graphql-ws's disposal would
+     * leave without an ending it can use, with WS_CLIENT_DISPOSED. graphql-ws
+     * speaks to the sinks of operations its socket CARRIED. An unanswered
+     * handshake carried none, so its disposal says nothing to them and they wait
+     * forever on a client that will never connect again — and the caller
+     * awaiting one waits with it (#2102; measured from the far end as backends
+     * left idle in transaction on a wait the client had already abandoned). A
+     * query or a mutation it carried unanswered it COMPLETES with no value,
+     * which no consumer can tell from a request never made (#1572). Erroring
+     * from the BOUND is the thing this must not do: that fires 10 s later, in
+     * whatever context is alive then. dispose() is the owner's own stack, so a
+     * rejection lands there. A subscription past its handshake is not here: a
+     * stream its client ended completes truthfully, and an operation whose
+     * answer arrived left the registry with it.
      *
      * The socket's owner ends every operation on it, forks included — the same
      * reason the socket rather than the client carries the disposed flag. A fork
      * owns no socket and ends only what it started, leaving its owner on the
      * wire. Idempotent: an entry settles once and deregisters itself doing so.
      */
-    settlePendingHandshakes() {
+    settlePendingOperations() {
         const wsClient = this.wsClient;
         if (!wsClient)
             return;
@@ -888,15 +935,18 @@ class BaseGraphQLClient {
     }
     /**
      * Terminal (#1994). Ends the socket, ends any retry in flight, ends every
-     * operation still waiting on a handshake (#2102), and refuses every later
-     * operation with WS_CLIENT_DISPOSED — a disposed client never mints another
-     * socket. Idempotent and synchronous; never throws.
+     * operation still waiting on a handshake (#2102) and every query or
+     * mutation still waiting on its answer (#1572) with WS_CLIENT_DISPOSED, and
+     * refuses every later operation with the same error — a disposed client
+     * never mints another socket. An answer that already arrived is kept, and a
+     * subscription the socket carried completes. Idempotent and synchronous;
+     * never throws.
      */
     dispose() {
         this.disposed = true;
         // Before the socket goes: erroring a subscriber tears its graphql-ws
-        // subscription down, so the disposal that follows finds nothing pending.
-        this.settlePendingHandshakes();
+        // subscription down, so the disposal that follows finds none of them.
+        this.settlePendingOperations();
         this.disposeWsClient();
     }
     fork(transactionToken) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forgecart/sdk",
-  "version": "1.202610241216.0",
+  "version": "1.202610241437.0",
   "description": "ForgeCart Client SDK",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/src/client.generated.ts

@@ -236,11 +236,14 @@ const WS_FIRST_VALUE_BUDGET_MS_BY_OPERATION: Readonly<Record<string, number>> =
 };
 
 /**
- * One operation still waiting on a handshake its socket has not answered.
- * `owner` is the client that started it: the socket's owner ends every
- * pending operation on that socket, a fork() only the ones it started.
+ * One operation still waiting on the wire, which graphql-ws's own disposal
+ * would leave without an ending it can use: one waiting on a handshake its
+ * socket has not answered (#2102), or a query or a mutation waiting on its
+ * answer (#1572). `owner` is the client that started it: the socket's owner
+ * ends every pending operation on that socket, a fork() only the ones it
+ * started.
  */
-interface PendingHandshake {
+interface PendingOperation {
   owner: BaseGraphQLClient;
   abandon: () => void;
 }
@@ -252,9 +255,10 @@ interface PendingHandshake {
 // `disposed` is that socket's terminal end, and it lives here rather than
 // on the client because every client still holding the socket — the forks
 // included — is off the wire the moment its owner ends it. `pending` is
-// socket-level for exactly that reason too (#2102): a handshake belongs to
-// the socket, so ending the socket must end everything still waiting on it.
-const WS_CONNECTION_STATE = new WeakMap<WsClient, { connected: boolean; disposed: boolean; pending: Set<PendingHandshake> }>();
+// socket-level for exactly that reason too (#2102, #1572): an operation
+// waiting on the wire belongs to the socket, so ending the socket must end
+// everything still waiting on it.
+const WS_CONNECTION_STATE = new WeakMap<WsClient, { connected: boolean; disposed: boolean; pending: Set<PendingOperation> }>();
 
 export class BaseGraphQLClient {
   private readonly logger = new SDKLogger();
@@ -310,10 +314,7 @@ export class BaseGraphQLClient {
     if (this.disposed) {
       // A fresh socket here would start the retry ladder its owner just ended;
       // the operation fails fast and typed instead, on the caller that asked.
-      throw new ClientError(
-        { errors: [{ message: "WS_CLIENT_DISPOSED", extensions: { endpoint: this.endpoint } }] },
-        "WS_CLIENT_DISPOSED",
-      );
+      throw this.clientDisposedError();
     }
     if (this.wsClient && this.wsClientStale) {
       this.disposeWsClient();
@@ -351,7 +352,7 @@ export class BaseGraphQLClient {
         // a dead endpoint for 32-46 s and erroring onto whoever runs then.
         shouldRetry: () => !this.disposed,
       });
-      const connectionState = { connected: false, disposed: false, pending: new Set<PendingHandshake>() };
+      const connectionState = { connected: false, disposed: false, pending: new Set<PendingOperation>() };
       WS_CONNECTION_STATE.set(this.wsClient, connectionState);
       this.wsClient.on("connected", () => {
         connectionState.connected = true;
@@ -538,6 +539,11 @@ export class BaseGraphQLClient {
    * sink callback, never the operation's lifetime, so a connected stream runs
    * for as long as the server streams it. Both bounds raise the same typed
    * code, so one consumer branch answers for both.
+   *
+   * Disposing the client ends the operation with WS_CLIENT_DISPOSED while it
+   * still waits on a handshake (#2102) or, as a query or a mutation, on its
+   * answer (#1572): graphql-ws would leave the first waiting forever and
+   * COMPLETE the second with no value — see settlePendingOperations.
    */
   private executeWsOperation<T>(
     document: string,
@@ -550,6 +556,10 @@ export class BaseGraphQLClient {
       // that replaced the boolean this method used to take.
       const singleDelivery = kind === WsOperationKind.MUTATION;
       const firstValueBudgetMs = this.getFirstValueBudgetMs(kind, this.operationNameOf(document));
+      // A query or a mutation is a REQUEST: its completion means something only
+      // once an answer arrived. A subscription is a stream its client may end at
+      // any point, so a disposal that completes it reports the truth (#1572).
+      const awaitsAnswer = kind !== WsOperationKind.SUBSCRIPTION;
       let disposed = false;
       // Delivery latch: once ANY sink callback has fired, the wire has
       // spoken and a socket close can no longer mean "delivery unknown".
@@ -567,9 +577,11 @@ export class BaseGraphQLClient {
       // object and a browser a number, and the generated client must typecheck
       // in both without an @types/node-only name.
       let operationDeadline: ReturnType<typeof setTimeout> | undefined;
-      // This operation's entry in the socket's pending-handshake registry,
-      // present for exactly as long as the bound is armed (#2102).
-      let pendingEntry: PendingHandshake | undefined;
+      // This operation's entry in the socket's pending registry, present for
+      // exactly as long as dispose() would otherwise leave it without an ending:
+      // while it waits on a handshake (#2102) and, for a request, until the
+      // wire answers it (#1572).
+      let pendingEntry: PendingOperation | undefined;
       const offConnectionEvents: (() => void)[] = [];
 
       // Disarms the first-value deadline. Reached on the first sink callback
@@ -580,27 +592,33 @@ export class BaseGraphQLClient {
         operationDeadline = undefined;
       };
 
-      // Disarms the bound AND deregisters the operation, because those are one
-      // fact: a handshake that no longer needs bounding is one dispose() no
-      // longer has to settle. Reached on the ACK, on the delivery latch and on
-      // teardown — every way this operation stops waiting on a handshake.
+      // Disarms the handshake bound. Reached on the ACK, on the delivery latch
+      // and on teardown — every way this operation stops waiting on a handshake.
       const clearConnectionTimeout = (): void => {
-        if (pendingEntry !== undefined) {
-          WS_CONNECTION_STATE.get(client)?.pending.delete(pendingEntry);
-          pendingEntry = undefined;
-        }
         if (connectionTimer === undefined) return;
         clearTimeout(connectionTimer);
         connectionTimer = undefined;
       };
 
+      // Deregisters the operation: dispose() no longer has to end it. Reached on
+      // the delivery latch and on teardown and, for a subscription, which waits
+      // on nothing past its handshake, on the ACK. A request stays registered
+      // across the ACK — the handshake is over, its answer is still owed.
+      const leavePending = (): void => {
+        if (pendingEntry === undefined) return;
+        WS_CONNECTION_STATE.get(client)?.pending.delete(pendingEntry);
+        pendingEntry = undefined;
+      };
+
       // The wire answering IS proof the handshake completed AND the first value
-      // arrived, so the latch and BOTH bounds fall together — and a timer that
-      // outlived its operation would hold the event loop open (a hung worker).
+      // arrived, so the latch, BOTH bounds and the registration fall together —
+      // and a timer that outlived its operation would hold the event loop open
+      // (a hung worker).
       const settle = (): void => {
         settled = true;
         clearOperationDeadline();
         clearConnectionTimeout();
+        leavePending();
       };
 
       // Armed BEFORE the operation is sent, so the budget measures the caller's
@@ -688,7 +706,10 @@ export class BaseGraphQLClient {
       // disposed and shouldRetry is untouched: graphql-ws keeps healing for the
       // next operation; only THIS one gives up (#2102).
       if (!(WS_CONNECTION_STATE.get(client)?.connected ?? false)) {
-        offConnectionEvents.push(client.on("connected", () => { clearConnectionTimeout(); }));
+        offConnectionEvents.push(client.on("connected", () => {
+          clearConnectionTimeout();
+          if (!awaitsAnswer) leavePending();
+        }));
         connectionTimer = setTimeout(() => {
           connectionTimer = undefined;
           // A residual guard, no longer the settlement: dispose() has already
@@ -730,22 +751,29 @@ export class BaseGraphQLClient {
         // client stays correct in both runtimes with no @types/node-only typing.
         const timerHandle = connectionTimer as unknown as { unref?: () => void } | number;
         if (typeof timerHandle === "object" && typeof timerHandle.unref === "function") timerHandle.unref();
-        // Reporting nothing when the bound elapses on a dead connection leaves
-        // something else to end this operation when its client ends — and
-        // graphql-ws is not it: its dispose() speaks to the sinks of operations
-        // its socket CARRIED, and a handshake that never completed carried none,
-        // so this one would wait forever and whoever awaited it with it.
-        // Registered for the life of the bound and settled by
-        // settlePendingHandshakes, on the disposing owner's own stack (#2102).
+      }
+
+      // Reporting nothing when the bound elapses on a dead connection leaves
+      // something else to end this operation when its client ends — and
+      // graphql-ws is not it. Its dispose() speaks to the sinks of operations
+      // its socket CARRIED, and a handshake that never completed carried none,
+      // so that one would wait forever and whoever awaited it with it (#2102).
+      // A request it did carry hears a bare COMPLETE — no value and no error —
+      // so map never runs, catchError never fires, an await reports an
+      // anonymous EmptyError, and the request is indistinguishable from one
+      // never made (#1572: the sidebar of #1571 kept the previous tenant's
+      // entries across a channel switch that way). Registered while either can
+      // still happen, and settled by settlePendingOperations on the disposing
+      // owner's own stack, with the error a later operation already receives.
+      if (awaitsAnswer || connectionTimer !== undefined) {
         pendingEntry = {
           owner: this,
           abandon: () => {
             if (disposed || settled) return;
             // The same disarm a wire answer performs: the latch closes and the
-            // bound is cleared, so nothing speaks twice for this operation.
+            // bounds are cleared, so nothing speaks twice for this operation.
             settle();
-            const message = "WS_CLIENT_DISPOSED";
-            subscriber.error(new ClientError({ errors: [{ message, extensions: { endpoint: this.endpoint } }] }, message));
+            subscriber.error(this.clientDisposedError());
           },
         };
         WS_CONNECTION_STATE.get(client)?.pending.add(pendingEntry);
@@ -768,6 +796,7 @@ export class BaseGraphQLClient {
         disposed = true;
         clearOperationDeadline();
         clearConnectionTimeout();
+        leavePending();
         for (const off of offConnectionEvents) off();
         cleanup();
       };
@@ -858,6 +887,20 @@ export class BaseGraphQLClient {
     return new ClientError({ errors: [{ message, extensions }] }, message);
   }
 
+  /**
+   * The ONE error a disposed client raises (#1994, #2102, #1572): for an
+   * operation started after dispose(), for one still waiting on a handshake,
+   * and for a query or a mutation still waiting on its answer. Named, so a
+   * consumer's error path tells an operation its own client cut off from one
+   * the server failed; carrying the endpoint, so a late one stays attributable.
+   * Never routed through the error handler: the disposal is the caller's own
+   * act, not a fault worth a notification.
+   */
+  private clientDisposedError(): ClientError {
+    const message = "WS_CLIENT_DISPOSED";
+    return new ClientError({ errors: [{ message, extensions: { endpoint: this.endpoint } }] }, message);
+  }
+
   /**
    * Uniform error contract for the sink-level error path. graphql-ws
    * delivers a server ErrorMessage payload as a raw GraphQLError[] —
@@ -1012,22 +1055,27 @@ export class BaseGraphQLClient {
   }
 
   /**
-   * Ends every operation still waiting on a handshake this socket never
-   * answered, where its owner stands (#2102). graphql-ws speaks to the sinks
-   * of operations its socket CARRIED; an unanswered handshake carried none, so
-   * its disposal says nothing to them and they wait forever on a client that
-   * will never connect again — and the caller awaiting one waits with it
-   * (measured from the far end as backends left idle in transaction on a wait
-   * the client had already abandoned). Erroring from the BOUND is the thing
-   * this must not do: that fires 10 s later, in whatever context is alive
-   * then. dispose() is the owner's own stack, so a rejection lands there.
+   * Ends, where its owner stands, every operation graphql-ws's disposal would
+   * leave without an ending it can use, with WS_CLIENT_DISPOSED. graphql-ws
+   * speaks to the sinks of operations its socket CARRIED. An unanswered
+   * handshake carried none, so its disposal says nothing to them and they wait
+   * forever on a client that will never connect again — and the caller
+   * awaiting one waits with it (#2102; measured from the far end as backends
+   * left idle in transaction on a wait the client had already abandoned). A
+   * query or a mutation it carried unanswered it COMPLETES with no value,
+   * which no consumer can tell from a request never made (#1572). Erroring
+   * from the BOUND is the thing this must not do: that fires 10 s later, in
+   * whatever context is alive then. dispose() is the owner's own stack, so a
+   * rejection lands there. A subscription past its handshake is not here: a
+   * stream its client ended completes truthfully, and an operation whose
+   * answer arrived left the registry with it.
    *
    * The socket's owner ends every operation on it, forks included — the same
    * reason the socket rather than the client carries the disposed flag. A fork
    * owns no socket and ends only what it started, leaving its owner on the
    * wire. Idempotent: an entry settles once and deregisters itself doing so.
    */
-  private settlePendingHandshakes(): void {
+  private settlePendingOperations(): void {
     const wsClient = this.wsClient;
     if (!wsClient) return;
     const pending = WS_CONNECTION_STATE.get(wsClient)?.pending;
@@ -1041,15 +1089,18 @@ export class BaseGraphQLClient {
 
   /**
    * Terminal (#1994). Ends the socket, ends any retry in flight, ends every
-   * operation still waiting on a handshake (#2102), and refuses every later
-   * operation with WS_CLIENT_DISPOSED — a disposed client never mints another
-   * socket. Idempotent and synchronous; never throws.
+   * operation still waiting on a handshake (#2102) and every query or
+   * mutation still waiting on its answer (#1572) with WS_CLIENT_DISPOSED, and
+   * refuses every later operation with the same error — a disposed client
+   * never mints another socket. An answer that already arrived is kept, and a
+   * subscription the socket carried completes. Idempotent and synchronous;
+   * never throws.
    */
   dispose(): void {
     this.disposed = true;
     // Before the socket goes: erroring a subscriber tears its graphql-ws
-    // subscription down, so the disposal that follows finds nothing pending.
-    this.settlePendingHandshakes();
+    // subscription down, so the disposal that follows finds none of them.
+    this.settlePendingOperations();
     this.disposeWsClient();
   }