fix(vnext): drain catalog cleanup settlement

Author: Light2Dark

docs/adr/0005-parser-independent-relation-completion.md

@@ -524,11 +524,12 @@ and disables automatic invalidation for the live scope; explicit search
 remains available.
 The returned cleanup closure is itself untrusted: the service captures only a
 function, calls it with `this === undefined` at most once, and isolates
-malformed values and thrown cleanup. A closure avoids a structural TypeScript
-contract that would accept class instances or inherited methods which the
-hostile runtime boundary could not safely validate. Dropping the last owner
-removes the complete scope incarnation before cleanup. A later join creates a
-new unobserved incarnation and may attempt a fresh subscription.
+malformed values, thrown cleanup, and rejected or hostile thenable results.
+Detached cleanup settlement retains no coordinator state. A closure avoids a
+structural TypeScript contract that would accept class instances or inherited
+methods which the hostile runtime boundary could not safely validate. Dropping
+the last owner removes the complete scope incarnation before cleanup. A later
+join creates a new unobserved incarnation and may attempt a fresh subscription.
 
 Malformed, duplicate, stale, or token-conflicting invalidations do not mutate
 state and do not tear down an otherwise valid subscription. Every raw callback

src/vnext/__tests__/relation-catalog-epoch-coordinator.test.ts

@@ -1332,6 +1332,74 @@ describe("hostile subscription lifecycle", () => {
     expect(failedTarget.dispatched).toBe(0);
   });
 
+  it("drains rejected and hostile cleanup results after making state inert", async () => {
+    let asyncCleanupCalls = 0;
+    const rejectingOwner = coordinator(
+      () => async () => {
+        asyncCleanupCalls += 1;
+        throw new Error("async cleanup failed");
+      },
+    );
+    const rejectingMembership = active(rejectingOwner, "scope");
+    rejectingMembership.dispose();
+    rejectingMembership.dispose();
+
+    let applyCalls = 0;
+    let thenReads = 0;
+    const thenProperty = ["th", "en"].join("");
+    const hostileResult = Object.defineProperty({}, thenProperty, {
+      get() {
+        thenReads += 1;
+        throw new Error("hostile then getter");
+      },
+    });
+    const hostileCleanup = new Proxy(() => hostileResult, {
+      apply(target, receiver, argumentsList) {
+        applyCalls += 1;
+        expect(receiver).toBeUndefined();
+        return Reflect.apply(target, receiver, argumentsList);
+      },
+    });
+    const hostileOwner = coordinator(() => hostileCleanup);
+    const hostileMembership = active(hostileOwner, "scope");
+    hostileMembership.dispose();
+    hostileMembership.dispose();
+
+    let thenCalls = 0;
+    let reentrantOwner: SqlCatalogEpochCoordinator;
+    const reentrantResult = Object.defineProperty(
+      {},
+      thenProperty,
+      {
+        value: (resolve: () => void): void => {
+          thenCalls += 1;
+          const replacement = active(
+            reentrantOwner,
+            "replacement",
+          );
+          replacement.dispose();
+          resolve();
+        },
+      },
+    );
+    const reentrantCleanup = () => reentrantResult;
+    let reentrantSubscriptions = 0;
+    reentrantOwner = coordinator(() => {
+      reentrantSubscriptions += 1;
+      return reentrantSubscriptions === 1
+        ? reentrantCleanup
+        : () => {};
+    });
+    active(reentrantOwner, "scope").dispose();
+
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(asyncCleanupCalls).toBe(1);
+    expect(applyCalls).toBe(1);
+    expect(thenReads).toBe(1);
+    expect(thenCalls).toBe(1);
+  });
+
   it("retries a failed subscription only in a new last-owner incarnation", () => {
     const listeners: RawInvalidationListener[] = [];
     let attempts = 0;

src/vnext/relation-catalog-epoch-coordinator.ts

@@ -226,6 +226,7 @@ const ACTIVE_RESULT: SqlCatalogMembershipActivationResult =
 const SUBMITTED_RESULT: SqlCatalogResponseEpochSubmissionResult =
   Object.freeze({ status: "submitted" });
 const NO_PREPARE_CATALOG_CHANGE = (): null => null;
+const IGNORE_CLEANUP_REJECTION = (): void => {};
 
 function unavailableActivation(
   reason: Exclude<
@@ -375,7 +376,8 @@ function cleanupSubscription(subscription: SubscriptionState): void {
   subscription.cleanupCalled = true;
   subscription.cleanup = null;
   try {
-    Reflect.apply(cleanup, undefined, []);
+    const result = Reflect.apply(cleanup, undefined, []);
+    void Promise.resolve(result).catch(IGNORE_CLEANUP_REJECTION);
   } catch {
     // Provider cleanup is isolated after state is inert.
   }

src/vnext/relation-completion-types.ts

@@ -12,7 +12,9 @@ export interface SqlDisposable {
   readonly dispose: (this: void) => void;
 }
 
-export type SqlCatalogSubscriptionCleanup = (this: void) => void;
+export type SqlCatalogSubscriptionCleanup = (
+  this: void,
+) => void | PromiseLike<void>;
 
 export type SqlCatalogContainerRole =
   | "catalog"