@qwen-code/channel-base 0.19.8 → 0.19.9-preview.0

package/dist/SessionRouter.js

@@ -1,4 +1,5 @@
-import { existsSync, readFileSync, writeFileSync, unlinkSync } from 'node:fs';
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, unlinkSync, writeFileSync, } from 'node:fs';
+import { dirname, join } from 'node:path';
 import process from 'node:process';
 import { sanitizeLogText } from './sanitize.js';
 export class SessionRouter {
@@ -7,16 +8,22 @@ export class SessionRouter {
     toCwd = new Map(); // session ID → cwd
     creatingSessions = new Map();
     sessionLoadWindows = new Set();
+    liveSessionIds = new Set();
+    routeTokens = new Map();
+    lifecycleGeneration = 0;
     bridge;
     defaultCwd;
     defaultScope;
     channelScopes = new Map();
+    channelApprovalModes = new Map();
     persistPath;
-    constructor(bridge, defaultCwd, scope = 'user', persistPath) {
+    recoveryMode;
+    constructor(bridge, defaultCwd, scope = 'user', persistPath, options = {}) {
         this.bridge = bridge;
         this.defaultCwd = defaultCwd;
         this.defaultScope = scope;
         this.persistPath = persistPath;
+        this.recoveryMode = options.recoveryMode ?? 'eager';
     }
     /** Replace the bridge instance (used after crash recovery restart). */
     setBridge(bridge) {
@@ -26,6 +33,14 @@ export class SessionRouter {
     setChannelScope(channelName, scope) {
         this.channelScopes.set(channelName, scope);
     }
+    setChannelApprovalMode(channelName, approvalMode) {
+        if (approvalMode) {
+            this.channelApprovalModes.set(channelName, approvalMode);
+        }
+        else {
+            this.channelApprovalModes.delete(channelName);
+        }
+    }
     routingKey(channelName, senderId, chatId, threadId) {
         const scope = this.channelScopes.get(channelName) || this.defaultScope;
         switch (scope) {
@@ -38,66 +53,186 @@ export class SessionRouter {
                 return `${channelName}:${senderId}:${chatId}`;
         }
     }
-    async resolve(channelName, senderId, chatId, threadId, cwd, isGroup) {
-        const key = this.routingKey(channelName, senderId, chatId, threadId);
-        let failedCreateWaits = 0;
+    sessionOptions(channelName) {
+        const approvalMode = this.channelApprovalModes.get(channelName);
+        return approvalMode ? { approvalMode } : undefined;
+    }
+    async resolve(channelName, senderId, chatId, threadId, cwd, isGroup, options) {
+        const key = this.routingKey(channelName, senderId, chatId, options?.routingThreadId ?? threadId);
+        const input = {
+            channelName,
+            senderId,
+            chatId,
+            threadId,
+            cwd: cwd || this.defaultCwd,
+            isGroup,
+        };
+        let failedWaits = 0;
         for (;;) {
             const existing = this.toSession.get(key);
-            if (existing) {
+            if (existing && this.isLive(existing)) {
                 this.promoteTargetToGroup(existing, isGroup);
                 return existing;
             }
             const creating = this.creatingSessions.get(key);
             if (creating) {
                 try {
-                    const sessionId = await creating;
+                    const sessionId = await creating.promise;
+                    try {
+                        this.assertOperationResultCurrent(key, sessionId, creating);
+                    }
+                    catch (error) {
+                        this.scheduleDiscardInvalidatedSession(sessionId, creating);
+                        throw error;
+                    }
                     this.promoteTargetToGroup(sessionId, isGroup);
                     return sessionId;
                 }
-                catch (err) {
+                catch (error) {
+                    if (creating.invalidationError) {
+                        throw creating.invalidationError;
+                    }
                     if (this.creatingSessions.get(key) === creating) {
                         this.creatingSessions.delete(key);
                     }
-                    failedCreateWaits++;
-                    if (failedCreateWaits > 3) {
-                        throw err;
-                    }
+                    this.releaseRouteToken(key, creating);
+                    failedWaits++;
+                    if (failedWaits > 3)
+                        throw error;
                     continue;
                 }
             }
-            // Register the in-flight route before starting newSession(), because a
-            // bridge can emit sessionDied synchronously while creating the session.
-            const created = Promise.resolve().then(async () => {
-                const sessionCwd = cwd || this.defaultCwd;
-                const loadWindow = this.beginSessionLoad();
+            const operation = this.createSessionOperation(key, {
+                channelName: input.channelName,
+                senderId: input.senderId,
+                chatId: input.chatId,
+                threadId: input.threadId,
+                isGroup: input.isGroup,
+            }, (currentOperation) => existing
+                ? this.loadOrReplaceSession(key, existing, input, currentOperation)
+                : this.createAndStoreSession(key, input, currentOperation));
+            this.creatingSessions.set(key, operation);
+            try {
+                const sessionId = await operation.promise;
                 try {
-                    const sessionId = await this.createLiveSession(sessionCwd, loadWindow, key);
-                    this.toSession.set(key, sessionId);
-                    this.toTarget.set(sessionId, {
-                        channelName,
-                        senderId,
-                        chatId,
-                        threadId,
-                        isGroup,
-                    });
-                    this.toCwd.set(sessionId, sessionCwd);
-                    this.persist();
-                    return sessionId;
+                    this.assertOperationResultCurrent(key, sessionId, operation);
                 }
-                finally {
-                    this.endSessionLoad(loadWindow);
+                catch (error) {
+                    this.scheduleDiscardInvalidatedSession(sessionId, operation);
+                    throw error;
                 }
-            });
-            this.creatingSessions.set(key, created);
-            try {
-                return await created;
+                this.promoteTargetToGroup(sessionId, isGroup);
+                return sessionId;
             }
             finally {
-                if (this.creatingSessions.get(key) === created) {
+                if (this.creatingSessions.get(key) === operation) {
                     this.creatingSessions.delete(key);
                 }
+                this.releaseRouteToken(key, operation);
+            }
+        }
+    }
+    isLive(sessionId) {
+        return this.recoveryMode === 'eager' || this.liveSessionIds.has(sessionId);
+    }
+    async createAndStoreSession(key, input, operation) {
+        const loadWindow = this.beginSessionLoad();
+        try {
+            const sessionId = await this.createLiveSession(input.cwd, loadWindow, key, this.sessionOptions(input.channelName), operation);
+            try {
+                this.assertOperationCurrent(operation);
+            }
+            catch (error) {
+                this.scheduleDiscardInvalidatedSession(sessionId, operation);
+                throw error;
+            }
+            this.toSession.set(key, sessionId);
+            this.toTarget.set(sessionId, {
+                channelName: input.channelName,
+                senderId: input.senderId,
+                chatId: input.chatId,
+                threadId: input.threadId,
+                isGroup: input.isGroup,
+            });
+            this.toCwd.set(sessionId, input.cwd);
+            this.liveSessionIds.add(sessionId);
+            this.persist();
+            return sessionId;
+        }
+        finally {
+            this.endSessionLoad(loadWindow);
+        }
+    }
+    async loadOrReplaceSession(key, savedSessionId, input, operation) {
+        const savedCwd = this.toCwd.get(savedSessionId) ?? input.cwd;
+        const loadWindow = this.beginSessionLoad();
+        try {
+            try {
+                const loadedSessionId = await this.bridge.loadSession(savedSessionId, savedCwd, this.sessionOptions(input.channelName), operation);
+                try {
+                    this.assertOperationCurrent(operation);
+                    if (this.toSession.get(key) !== savedSessionId) {
+                        this.invalidateOperation(operation);
+                        this.assertOperationCurrent(operation);
+                    }
+                }
+                catch (error) {
+                    this.scheduleDiscardInvalidatedSession(loadedSessionId, operation);
+                    throw error;
+                }
+                if (typeof loadedSessionId !== 'string' ||
+                    loadedSessionId.length === 0 ||
+                    loadWindow.delete(loadedSessionId)) {
+                    throw new Error('Invalid or dead restored session ID');
+                }
+                if (loadedSessionId !== savedSessionId) {
+                    const target = this.toTarget.get(savedSessionId);
+                    this.deleteByKey(key);
+                    this.toSession.set(key, loadedSessionId);
+                    if (target)
+                        this.toTarget.set(loadedSessionId, target);
+                    this.toCwd.set(loadedSessionId, savedCwd);
+                    this.persist();
+                }
+                this.liveSessionIds.add(loadedSessionId);
+                return loadedSessionId;
+            }
+            catch (loadError) {
+                this.assertOperationCurrent(operation);
+                try {
+                    const replacement = await this.createLiveSession(input.cwd, loadWindow, key, this.sessionOptions(input.channelName), operation);
+                    try {
+                        this.assertOperationCurrent(operation);
+                    }
+                    catch (error) {
+                        this.scheduleDiscardInvalidatedSession(replacement, operation);
+                        throw error;
+                    }
+                    this.deleteByKey(key);
+                    this.toSession.set(key, replacement);
+                    this.toTarget.set(replacement, {
+                        channelName: input.channelName,
+                        senderId: input.senderId,
+                        chatId: input.chatId,
+                        threadId: input.threadId,
+                        isGroup: input.isGroup,
+                    });
+                    this.toCwd.set(replacement, input.cwd);
+                    this.liveSessionIds.add(replacement);
+                    this.persist();
+                    process.stderr.write(`[SessionRouter] Replaced unavailable session ${sanitizeLogText(savedSessionId, 128)} for key ${sanitizeLogText(key, 256)} after load failed: ${sanitizeLogText(loadError instanceof Error ? loadError.message : String(loadError), 512)}\n`);
+                    return replacement;
+                }
+                catch (createError) {
+                    this.assertOperationCurrent(operation);
+                    process.stderr.write(`[SessionRouter] Failed to load session ${sanitizeLogText(savedSessionId, 128)} for key ${sanitizeLogText(key, 256)} (${sanitizeLogText(loadError instanceof Error ? loadError.message : String(loadError), 512)}) and failed to create a replacement (${sanitizeLogText(createError instanceof Error ? createError.message : String(createError), 512)})\n`);
+                    throw createError;
+                }
             }
         }
+        finally {
+            this.endSessionLoad(loadWindow);
+        }
     }
     getTarget(sessionId) {
         return this.toTarget.get(sessionId);
@@ -132,6 +267,7 @@ export class SessionRouter {
         const scope = this.channelScopes.get(channelName) || this.defaultScope;
         if (chatId) {
             const key = this.routingKey(channelName, senderId, chatId, threadId);
+            this.invalidateRouteOperation(key);
             const sessionId = this.deleteByKey(key);
             if (sessionId)
                 removedIds.push(sessionId);
@@ -145,11 +281,18 @@ export class SessionRouter {
                 const target = this.toTarget.get(mappedSessionId);
                 if (target?.channelName === channelName &&
                     target.senderId === senderId) {
+                    this.invalidateRouteOperation(k);
                     const sessionId = this.deleteByKey(k);
                     if (sessionId)
                         removedIds.push(sessionId);
                 }
             }
+            for (const [key, operation] of [...this.creatingSessions]) {
+                if (operation.target.channelName === channelName &&
+                    operation.target.senderId === senderId) {
+                    this.invalidateRouteOperation(key);
+                }
+            }
         }
         if (removedIds.length > 0)
             this.persist();
@@ -160,6 +303,7 @@ export class SessionRouter {
         let removed = false;
         for (const [key, mappedSessionId] of [...this.toSession.entries()]) {
             if (mappedSessionId === sessionId) {
+                this.invalidateRouteOperation(key);
                 this.toSession.delete(key);
                 removed = true;
             }
@@ -170,6 +314,7 @@ export class SessionRouter {
         if (this.toCwd.delete(sessionId)) {
             removed = true;
         }
+        this.liveSessionIds.delete(sessionId);
         if (!removed && this.sessionLoadWindows.size > 0) {
             for (const loadWindow of this.sessionLoadWindows) {
                 loadWindow.add(sessionId);
@@ -180,6 +325,17 @@ export class SessionRouter {
         }
         return removed;
     }
+    handleSessionDied(sessionId) {
+        if (this.recoveryMode === 'eager') {
+            return this.removeSessionId(sessionId);
+        }
+        const known = this.toTarget.has(sessionId);
+        this.liveSessionIds.delete(sessionId);
+        for (const loadWindow of this.sessionLoadWindows) {
+            loadWindow.add(sessionId);
+        }
+        return known;
+    }
     deleteByKey(key) {
         const sessionId = this.toSession.get(key);
         if (!sessionId)
@@ -187,6 +343,7 @@ export class SessionRouter {
         this.toSession.delete(key);
         this.toTarget.delete(sessionId);
         this.toCwd.delete(sessionId);
+        this.liveSessionIds.delete(sessionId);
         return sessionId;
     }
     promoteTargetToGroup(sessionId, isGroup) {
@@ -209,46 +366,72 @@ export class SessionRouter {
         }
         return entries;
     }
+    restoreRoutes() {
+        if (this.recoveryMode !== 'lazy') {
+            throw new Error('restoreRoutes requires lazy recovery mode');
+        }
+        const persisted = this.readPersistedEntries();
+        if (!persisted)
+            return { restored: 0, dropped: 0 };
+        this.dispose();
+        let restored = 0;
+        for (const [key, entry] of Object.entries(persisted.entries)) {
+            this.toSession.set(key, entry.sessionId);
+            this.toTarget.set(entry.sessionId, entry.target);
+            this.toCwd.set(entry.sessionId, entry.cwd);
+            restored++;
+        }
+        if (persisted.dropped > 0)
+            this.persist();
+        return { restored, dropped: persisted.dropped };
+    }
     /**
      * Restore session mappings from a previous bridge.
      * Called after bridge restart — attempts loadSession for each saved mapping.
      * Failed loads are dropped (new session on next message).
      */
     async restoreSessions() {
-        const persistPath = this.persistPath;
-        if (!persistPath || !existsSync(persistPath)) {
-            return { restored: 0, failed: 0 };
-        }
-        let entries;
-        try {
-            entries = JSON.parse(readFileSync(persistPath, 'utf-8'));
-        }
-        catch (err) {
-            const reason = err instanceof Error ? err.message : String(err);
-            process.stderr.write(`[SessionRouter] Corrupted persist file at ${sanitizeLogText(persistPath, 1024)}: ${sanitizeLogText(reason, 512)}\n`);
+        const persisted = this.readPersistedEntries();
+        if (!persisted)
             return { restored: 0, failed: 0 };
-        }
+        const entries = persisted.entries;
+        const restoreGeneration = this.lifecycleGeneration;
         let restored = 0;
         let failed = 0;
-        let changed = false;
+        let changed = persisted.dropped > 0;
         const reservations = new Map();
+        for (const key of persisted.droppedKeys) {
+            this.deleteByKey(key);
+        }
         // Reserve every persisted key up front so inbound messages during restart
         // wait for restore instead of returning stale IDs or creating duplicates.
         for (const key of Object.keys(entries)) {
             this.deleteByKey(key);
             const reservation = this.createSessionReservation();
             reservation.promise.catch(() => undefined);
-            this.creatingSessions.set(key, reservation.promise);
-            reservations.set(key, reservation);
+            const operation = this.createSessionOperation(key, entries[key].target, () => reservation.promise);
+            operation.promise.catch(() => undefined);
+            this.creatingSessions.set(key, operation);
+            reservations.set(key, { reservation, operation });
         }
         const loadWindow = this.beginSessionLoad();
         try {
             for (const [key, entry] of Object.entries(entries)) {
-                const reservation = reservations.get(key);
-                if (!reservation)
+                const reserved = reservations.get(key);
+                if (!reserved)
                     continue;
+                const { reservation, operation } = reserved;
                 try {
-                    const sessionId = await this.bridge.loadSession(entry.sessionId, entry.cwd);
+                    this.assertOperationCurrent(operation);
+                    const options = this.sessionOptions(entry.target.channelName);
+                    const sessionId = await this.bridge.loadSession(entry.sessionId, entry.cwd, options, operation);
+                    try {
+                        this.assertOperationCurrent(operation);
+                    }
+                    catch (error) {
+                        this.scheduleDiscardInvalidatedSession(sessionId, operation);
+                        throw error;
+                    }
                     if (typeof sessionId !== 'string' || sessionId.length === 0) {
                         throw new Error('Invalid restored session ID');
                     }
@@ -273,9 +456,10 @@ export class SessionRouter {
                     changed = true;
                 }
                 finally {
-                    if (this.creatingSessions.get(key) === reservation.promise) {
+                    if (this.creatingSessions.get(key) === operation) {
                         this.creatingSessions.delete(key);
                     }
+                    this.releaseRouteToken(key, operation);
                 }
             }
         }
@@ -283,18 +467,27 @@ export class SessionRouter {
             this.endSessionLoad(loadWindow);
         }
         // Update persist file to only include successfully restored sessions
-        if (changed) {
+        if (changed && restoreGeneration === this.lifecycleGeneration) {
             this.persist();
         }
         return { restored, failed };
     }
-    /** Clear in-memory state and delete persist file. Used on clean shutdown. */
-    clearAll() {
+    dispose() {
+        this.lifecycleGeneration++;
+        for (const operation of this.creatingSessions.values()) {
+            this.invalidateOperation(operation);
+        }
         this.toSession.clear();
         this.toTarget.clear();
         this.toCwd.clear();
         this.creatingSessions.clear();
         this.sessionLoadWindows.clear();
+        this.liveSessionIds.clear();
+        this.routeTokens.clear();
+    }
+    /** Clear in-memory state and delete persist file. Used on clean shutdown. */
+    clearAll() {
+        this.dispose();
         if (this.persistPath && existsSync(this.persistPath)) {
             try {
                 unlinkSync(this.persistPath);
@@ -304,32 +497,128 @@ export class SessionRouter {
             }
         }
     }
+    readPersistedEntries() {
+        const persistPath = this.persistPath;
+        if (!persistPath || !existsSync(persistPath))
+            return undefined;
+        let parsed;
+        try {
+            parsed = JSON.parse(readFileSync(persistPath, 'utf-8'));
+        }
+        catch (error) {
+            const quarantinePath = `${persistPath}.corrupt-${Date.now()}`;
+            try {
+                renameSync(persistPath, quarantinePath);
+            }
+            catch {
+                // Keep startup available even if quarantine itself fails.
+            }
+            process.stderr.write(`[SessionRouter] Corrupted persist file at ${sanitizeLogText(persistPath, 1024)}: ${sanitizeLogText(error instanceof Error ? error.message : String(error), 512)}\n`);
+            return undefined;
+        }
+        if (typeof parsed !== 'object' ||
+            parsed === null ||
+            Array.isArray(parsed)) {
+            const quarantinePath = `${persistPath}.corrupt-${Date.now()}`;
+            try {
+                renameSync(persistPath, quarantinePath);
+            }
+            catch {
+                // Keep startup available even if quarantine itself fails.
+            }
+            process.stderr.write(`[SessionRouter] Invalid route store at ${sanitizeLogText(persistPath, 1024)}: expected an object\n`);
+            return undefined;
+        }
+        const entries = {};
+        const droppedKeys = [];
+        for (const [key, value] of Object.entries(parsed)) {
+            if (this.isPersistedEntry(value))
+                entries[key] = value;
+            else
+                droppedKeys.push(key);
+        }
+        return { entries, dropped: droppedKeys.length, droppedKeys };
+    }
+    isPersistedEntry(value) {
+        if (typeof value !== 'object' || value === null)
+            return false;
+        const entry = value;
+        const target = entry['target'];
+        if (typeof target !== 'object' || target === null)
+            return false;
+        const typedTarget = target;
+        return (typeof entry['sessionId'] === 'string' &&
+            entry['sessionId'].length > 0 &&
+            typeof entry['cwd'] === 'string' &&
+            entry['cwd'].length > 0 &&
+            typeof typedTarget['channelName'] === 'string' &&
+            typeof typedTarget['senderId'] === 'string' &&
+            typeof typedTarget['chatId'] === 'string' &&
+            (typedTarget['threadId'] === undefined ||
+                typeof typedTarget['threadId'] === 'string') &&
+            (typedTarget['isGroup'] === undefined ||
+                typeof typedTarget['isGroup'] === 'boolean'));
+    }
     persist() {
         if (!this.persistPath)
             return;
         const data = {};
         for (const [key, sessionId] of this.toSession) {
             const target = this.toTarget.get(sessionId);
-            if (target) {
-                data[key] = {
-                    sessionId,
-                    target,
-                    cwd: this.toCwd.get(sessionId) || this.defaultCwd,
-                };
-            }
+            if (!target)
+                continue;
+            data[key] = {
+                sessionId,
+                target,
+                cwd: this.toCwd.get(sessionId) ?? this.defaultCwd,
+            };
         }
+        const dir = dirname(this.persistPath);
+        const tempPath = join(dir, `${Date.now()}-${process.pid}-${Math.random().toString(16).slice(2)}.tmp`);
         try {
-            writeFileSync(this.persistPath, JSON.stringify(data, null, 2), 'utf-8');
+            mkdirSync(dir, { recursive: true, mode: 0o700 });
+            try {
+                chmodSync(dir, 0o700);
+            }
+            catch {
+                // Windows and some filesystems do not implement POSIX modes.
+            }
+            writeFileSync(tempPath, JSON.stringify(data, null, 2), {
+                encoding: 'utf-8',
+                mode: 0o600,
+            });
+            renameSync(tempPath, this.persistPath);
+            try {
+                chmodSync(this.persistPath, 0o600);
+            }
+            catch {
+                // Windows and some filesystems do not implement POSIX modes.
+            }
         }
-        catch {
-            // best-effort — don't break message flow for persistence failure
+        catch (error) {
+            process.stderr.write(`[SessionRouter] Failed to persist routes at ${sanitizeLogText(this.persistPath, 1024)}: ${sanitizeLogText(error instanceof Error ? error.message : String(error), 512)}\n`);
+        }
+        finally {
+            try {
+                rmSync(tempPath, { force: true });
+            }
+            catch {
+                // best-effort temp cleanup
+            }
         }
     }
-    async createLiveSession(cwd, loadWindow, routingKey) {
+    async createLiveSession(cwd, loadWindow, routingKey, options, operation) {
         const maxAttempts = 2;
         let lastDeadSessionId;
         for (let attempt = 0; attempt < maxAttempts; attempt++) {
-            const sessionId = await this.bridge.newSession(cwd);
+            const sessionId = await this.bridge.newSession(cwd, options, operation);
+            try {
+                this.assertOperationCurrent(operation);
+            }
+            catch (error) {
+                this.scheduleDiscardInvalidatedSession(sessionId, operation);
+                throw error;
+            }
             if (typeof sessionId !== 'string' || sessionId.length === 0) {
                 throw new Error('Invalid session ID from bridge');
             }
@@ -345,6 +634,73 @@ export class SessionRouter {
         this.sessionLoadWindows.add(loadWindow);
         return loadWindow;
     }
+    createSessionOperation(key, target, run) {
+        let routeToken = this.routeTokens.get(key);
+        if (!routeToken) {
+            routeToken = {};
+            this.routeTokens.set(key, routeToken);
+        }
+        const operation = {
+            promise: Promise.resolve(''),
+            target,
+            lifecycleGeneration: this.lifecycleGeneration,
+            routeToken,
+        };
+        operation.promise = Promise.resolve()
+            .then(() => run(operation))
+            .catch((error) => {
+            this.assertOperationCurrent(operation);
+            throw error;
+        });
+        return operation;
+    }
+    invalidateRouteOperation(key) {
+        this.routeTokens.delete(key);
+        const operation = this.creatingSessions.get(key);
+        if (!operation)
+            return;
+        this.invalidateOperation(operation);
+        this.creatingSessions.delete(key);
+    }
+    invalidateOperation(operation) {
+        operation.invalidationError ??= new Error('Session route operation was invalidated');
+    }
+    assertOperationCurrent(operation) {
+        if (operation.lifecycleGeneration !== this.lifecycleGeneration) {
+            this.invalidateOperation(operation);
+        }
+        if (operation.invalidationError) {
+            throw operation.invalidationError;
+        }
+    }
+    assertOperationResultCurrent(key, sessionId, operation) {
+        if (operation.routeToken !== this.routeTokens.get(key)) {
+            this.invalidateOperation(operation);
+        }
+        if (this.toSession.get(key) !== sessionId) {
+            this.invalidateOperation(operation);
+        }
+        this.assertOperationCurrent(operation);
+    }
+    releaseRouteToken(key, operation) {
+        if (this.routeTokens.get(key) === operation.routeToken &&
+            !this.toSession.has(key) &&
+            !this.creatingSessions.has(key)) {
+            this.routeTokens.delete(key);
+        }
+    }
+    scheduleDiscardInvalidatedSession(sessionId, operation) {
+        if ([...this.toSession.values()].includes(sessionId))
+            return;
+        try {
+            void this.bridge
+                .discardSession?.(sessionId, operation)
+                .catch(() => undefined);
+        }
+        catch {
+            // Best-effort cleanup must not replace the terminal invalidation.
+        }
+    }
     createSessionReservation() {
         let resolveReservation;
         let rejectReservation;