@mdbase-dev/connect 0.1.0-beta.84 → 0.1.0-beta.85

package/dist/retired-grant-keys.js

@@ -0,0 +1,56 @@
+import { pendingMutationKeyHandles, pendingMutationsUseKey } from "./pending-recovery-transports.js";
+import { parseStored } from "./runtime-utils.js";
+export function storedTokenKeyHandles(token, additional) {
+    const handles = new Set();
+    if (additional)
+        handles.add(additional);
+    if (token?.keyHandle)
+        handles.add(token.keyHandle);
+    if (Array.isArray(token?.retiredKeyHandles)) {
+        for (const handle of token.retiredKeyHandles) {
+            if (typeof handle === "string" && handle.length > 0)
+                handles.add(handle);
+        }
+    }
+    return handles;
+}
+export function planRetiredGrantKeys(storage, pendingMutationKey, previous, current, leased = [], retainAll = false) {
+    const retained = [];
+    const disposable = [];
+    const candidates = storedTokenKeyHandles(previous);
+    for (const handle of pendingMutationKeyHandles(storage, pendingMutationKey)) {
+        candidates.add(handle);
+    }
+    const leasedHandles = new Set(leased);
+    for (const handle of leasedHandles)
+        candidates.add(handle);
+    for (const handle of candidates) {
+        if (handle === current)
+            continue;
+        (retainAll || leasedHandles.has(handle) || pendingMutationsUseKey(storage, pendingMutationKey, handle)
+            ? retained
+            : disposable).push(handle);
+    }
+    return { retained, disposable };
+}
+export function removeRetiredGrantKeyMetadata(storage, tokenKey, handle) {
+    const token = parseStored(storage.getItem(tokenKey));
+    if (!token || !Array.isArray(token.retiredKeyHandles))
+        return;
+    const retiredKeyHandles = token.retiredKeyHandles.filter((candidate) => candidate !== handle);
+    if (retiredKeyHandles.length === token.retiredKeyHandles.length)
+        return;
+    if (retiredKeyHandles.length > 0)
+        token.retiredKeyHandles = retiredKeyHandles;
+    else
+        delete token.retiredKeyHandles;
+    storage.setItem(tokenKey, JSON.stringify(token));
+}
+export async function deleteUnusedGrantKey(storage, keyStore, pendingMutationKey, tokenKey, handle) {
+    const current = parseStored(storage.getItem(tokenKey));
+    if (current?.keyHandle === handle
+        || pendingMutationsUseKey(storage, pendingMutationKey, handle))
+        return;
+    await keyStore.delete(handle);
+    removeRetiredGrantKeyMetadata(storage, tokenKey, handle);
+}

package/dist/session.d.ts

@@ -1,4 +1,4 @@
-import type { CollectionOperation, JsonObject } from "@mdbase-dev/connect-protocol";
+import type { CollectionOperation, ConnectProblem, JsonObject } from "@mdbase-dev/connect-protocol";
 import { MdbaseConnection, type MdbaseAuthorizationOutcome, type MdbaseAuthorizationResult, type MdbaseAuthorizeOptions } from "./connection.js";
 import type { MdbaseAuthorizationCapabilities, MdbaseConnectionInfo } from "./connection-types.js";
 import { type AuthorizationProblemCode, type ConnectOutcome, type SessionProblemCode } from "./outcomes.js";
@@ -19,6 +19,19 @@ export interface MdbaseSessionOptions {
 }
 export type MdbaseUnavailableReason = "not_authorized" | "authorization_lost" | "invalid_stored_grant";
 export type MdbaseSessionSnapshot<Frontmatter extends JsonObject = JsonObject> = {
+    status: "not_started";
+    connections: MdbaseConnectionInfo[];
+} | {
+    status: "starting";
+    connections: MdbaseConnectionInfo[];
+} | {
+    status: "start_failed";
+    problem: ConnectProblem<SessionProblemCode>;
+    connections: MdbaseConnectionInfo[];
+} | {
+    status: "destroyed";
+    connections: MdbaseConnectionInfo[];
+} | {
     status: "unselected";
     connections: MdbaseConnectionInfo[];
 } | {
@@ -48,22 +61,30 @@ export declare class MdbaseSession<Frontmatter extends JsonObject = JsonObject>
     private activeCollectionId;
     private unavailableReason;
     private started;
+    private destroyed;
     private refreshing;
     private refreshQueued;
     private transactionDepth;
-    private callbackPromise;
+    private lifecycleGeneration;
+    private readonly operationControllers;
+    private startOperation;
+    private readonly callbackCompletions;
     constructor(connect: MdbaseSessionConnect<Frontmatter>, options: MdbaseSessionOptions);
     start(options?: ConnectRequestOptions): Promise<ConnectOutcome<MdbaseSessionSnapshot<Frontmatter>, SessionProblemCode>>;
+    private beginStart;
+    private waitForStart;
+    private performStart;
     destroy(): void;
+    private stopLifecycleSubscriptions;
     getSnapshot(): MdbaseSessionSnapshot<Frontmatter>;
     subscribe(listener: () => void): () => void;
     select(collectionId: string, options?: {
         history?: MdbaseSelectionHistory;
-    }): ConnectOutcome<MdbaseConnection<Frontmatter>, "unknown_collection">;
+    }): ConnectOutcome<MdbaseConnection<Frontmatter>, SessionProblemCode>;
     clearSelection(options?: {
         history?: MdbaseSelectionHistory;
-    }): void;
-    forget(collectionId: string): void;
+    }): ConnectOutcome<void, SessionProblemCode>;
+    forget(collectionId: string): ConnectOutcome<void, SessionProblemCode>;
     authorize(target: "choose" | "selected" | {
         collectionId: string;
     }, options?: Omit<MdbaseAuthorizeOptions, "operations" | "returnTo" | "target">): Promise<ConnectOutcome<MdbaseAuthorizationOutcome<Frontmatter>, SessionProblemCode>>;
@@ -71,8 +92,16 @@ export declare class MdbaseSession<Frontmatter extends JsonObject = JsonObject>
         kind: "unchanged";
         connection: MdbaseConnection<Frontmatter>;
     }, SessionProblemCode>>;
-    handleAuthorizationCallback(callbackUrl: string, options?: ConnectRequestOptions): Promise<ConnectOutcome<MdbaseConnection<Frontmatter>, AuthorizationProblemCode>>;
+    handleAuthorizationCallback(callbackUrl: string, options?: ConnectRequestOptions): Promise<ConnectOutcome<MdbaseConnection<Frontmatter>, SessionProblemCode>>;
+    private completeAuthorizationCallback;
+    private beginCallbackCompletion;
+    private waitForCallbackCompletion;
+    private lifecycleProblem;
+    private beginLifecycleOperation;
+    private lifecycleCurrent;
+    private destroyedOutcome;
     private autoSelectOnlyConnection;
     private refresh;
-    private refreshOnce;
+    private publishCurrent;
+    private publish;
 }

package/dist/session.js

@@ -1,8 +1,9 @@
-import { authorizationReturnToFromProblem, isAuthorizationCallbackUrl } from "./authorization-url.js";
-import { connectProblem } from "./errors.js";
+import { authorizationCallbackState, authorizationReturnToFromProblem, isAuthorizationCallbackUrl } from "./authorization-url.js";
+import { MdbaseConnectError, connectProblem } from "./errors.js";
 import { DEFAULT_OPERATIONS } from "./internal-types.js";
 import { uniqueOperations } from "./operation-helpers.js";
 import { connectFailure, connectSuccess } from "./outcomes.js";
+import { DEFAULT_REQUEST_TIMEOUT_MS, DEFAULT_STARTUP_TIMEOUT_MS, requestAbortReason, withRequestBudget } from "./request-budget.js";
 export class MdbaseSession {
     connect;
     operations;
@@ -17,39 +18,139 @@ export class MdbaseSession {
     activeCollectionId = null;
     unavailableReason = "not_authorized";
     started = false;
+    destroyed = false;
     refreshing = false;
     refreshQueued = false;
     transactionDepth = 0;
-    callbackPromise = null;
+    lifecycleGeneration = 0;
+    operationControllers = new Set();
+    startOperation = null;
+    callbackCompletions = new Map();
     constructor(connect, options) {
         this.connect = connect;
         this.operations = uniqueOperations(options.operations ?? DEFAULT_OPERATIONS);
         this.selection = options.selection;
         this.autoSelect = options.autoSelect ?? "only";
-        this.snapshot = { status: "unselected", connections: [] };
-        this.refresh();
+        this.snapshot = { status: "not_started", connections: [] };
     }
-    async start(options) {
-        if (!this.started) {
+    start(options) {
+        if (this.destroyed) {
+            return Promise.resolve(connectFailure(connectProblem("session_destroyed", "This session has been destroyed.")));
+        }
+        if (this.started && !this.startOperation) {
+            return Promise.resolve(connectSuccess(this.snapshot));
+        }
+        const operation = this.startOperation ?? this.beginStart();
+        return this.waitForStart(operation, options);
+    }
+    beginStart() {
+        const controller = new AbortController();
+        const generation = ++this.lifecycleGeneration;
+        this.publish({ status: "starting", connections: this.connect.connections() });
+        const operation = {
+            promise: this.performStart({ signal: controller.signal, timeoutMs: null }, generation),
+            controller,
+            waiters: 0,
+            generation
+        };
+        this.startOperation = operation;
+        const settled = () => {
+            if (this.startOperation === operation)
+                this.startOperation = null;
+        };
+        operation.promise.then(settled, settled);
+        return operation;
+    }
+    async waitForStart(operation, options) {
+        operation.waiters += 1;
+        try {
+            return await withRequestBudget(options, DEFAULT_STARTUP_TIMEOUT_MS, () => operation.promise);
+        }
+        catch (error) {
+            if (error instanceof MdbaseConnectError) {
+                return connectFailure(error.problem);
+            }
+            throw error;
+        }
+        finally {
+            operation.waiters -= 1;
+            if (operation.waiters === 0 && this.startOperation === operation) {
+                operation.controller.abort();
+                this.startOperation = null;
+                this.lifecycleGeneration += 1;
+                this.stopLifecycleSubscriptions();
+                this.started = false;
+                this.publish({ status: "not_started", connections: this.connect.connections() });
+            }
+        }
+    }
+    async performStart(options, generation) {
+        try {
             this.started = true;
             this.stopConnections = this.connect.onConnectionsChange(() => this.refresh());
             this.stopSelection = this.selection.subscribe(() => {
                 this.unavailableReason = "not_authorized";
                 this.refresh();
             });
+            const callback = this.selection.authorizationCallback();
+            if (callback) {
+                const completed = await this.completeAuthorizationCallback(callback, options);
+                if (!completed.ok) {
+                    if (generation === this.lifecycleGeneration && !this.destroyed) {
+                        this.stopLifecycleSubscriptions();
+                        this.started = false;
+                        this.publish({
+                            status: "start_failed",
+                            problem: completed.problem,
+                            connections: this.connect.connections()
+                        });
+                    }
+                    return completed;
+                }
+            }
+            else
+                this.autoSelectOnlyConnection();
+            if (generation !== this.lifecycleGeneration || this.destroyed) {
+                return connectFailure(connectProblem("session_destroyed", "This session has been destroyed."));
+            }
+            this.publishCurrent();
+            return connectSuccess(this.snapshot);
         }
-        const callback = this.selection.authorizationCallback();
-        if (callback) {
-            const completed = await this.handleAuthorizationCallback(callback, options);
-            if (!completed.ok)
-                return completed;
+        catch (error) {
+            if (error instanceof MdbaseConnectError) {
+                const problem = error.problem;
+                if (generation === this.lifecycleGeneration && !this.destroyed) {
+                    this.stopLifecycleSubscriptions();
+                    this.started = false;
+                    this.publish({ status: "start_failed", problem, connections: this.connect.connections() });
+                }
+                return connectFailure(problem);
+            }
+            if (generation === this.lifecycleGeneration && !this.destroyed) {
+                this.stopLifecycleSubscriptions();
+                this.started = false;
+                this.publish({ status: "not_started", connections: this.connect.connections() });
+            }
+            throw error;
         }
-        else
-            this.autoSelectOnlyConnection();
-        this.refresh();
-        return connectSuccess(this.snapshot);
     }
     destroy() {
+        if (this.destroyed)
+            return;
+        this.lifecycleGeneration += 1;
+        this.startOperation?.controller.abort();
+        this.startOperation = null;
+        for (const controller of this.operationControllers)
+            controller.abort();
+        this.operationControllers.clear();
+        this.stopLifecycleSubscriptions();
+        this.started = false;
+        this.destroyed = true;
+        this.callbackCompletions.clear();
+        this.publish({ status: "destroyed", connections: [] });
+        this.listeners.clear();
+    }
+    stopLifecycleSubscriptions() {
         this.stopConnections?.();
         this.stopSelection?.();
         this.stopActiveConnection?.();
@@ -57,7 +158,6 @@ export class MdbaseSession {
         this.stopSelection = undefined;
         this.stopActiveConnection = undefined;
         this.activeCollectionId = null;
-        this.started = false;
     }
     getSnapshot() {
         return this.snapshot;
@@ -67,6 +167,9 @@ export class MdbaseSession {
         return () => this.listeners.delete(listener);
     }
     select(collectionId, options = {}) {
+        const lifecycle = this.lifecycleProblem();
+        if (lifecycle)
+            return connectFailure(lifecycle);
         const connection = this.connect.connection(collectionId);
         if (!connection) {
             return connectFailure(connectProblem("unknown_collection", "This collection is not authorized for this application."));
@@ -77,11 +180,18 @@ export class MdbaseSession {
         return connectSuccess(connection);
     }
     clearSelection(options = {}) {
+        const lifecycle = this.lifecycleProblem();
+        if (lifecycle)
+            return connectFailure(lifecycle);
         this.unavailableReason = "not_authorized";
         this.selection.select(null, options);
         this.refresh();
+        return connectSuccess(undefined);
     }
     forget(collectionId) {
+        const lifecycle = this.lifecycleProblem();
+        if (lifecycle)
+            return connectFailure(lifecycle);
         this.transactionDepth += 1;
         try {
             const selected = this.selection.selectedCollectionId() === collectionId;
@@ -93,8 +203,12 @@ export class MdbaseSession {
             this.transactionDepth -= 1;
             this.refresh();
         }
+        return connectSuccess(undefined);
     }
     async authorize(target, options = {}) {
+        const lifecycle = this.lifecycleProblem();
+        if (lifecycle)
+            return connectFailure(lifecycle);
         const selectedCollectionId = this.selection.selectedCollectionId();
         if (target === "selected" && !selectedCollectionId) {
             return connectFailure(connectProblem("collection_not_selected", "Choose a collection before updating its access."));
@@ -104,27 +218,34 @@ export class MdbaseSession {
             : target === "selected"
                 ? selectedCollectionId
                 : null;
+        const operation = this.beginLifecycleOperation(options);
         this.transactionDepth += 1;
         try {
             const outcome = await this.connect.authorize({
-                ...options,
+                ...operation.options,
                 operations: this.operations,
                 target: targetCollectionId === null
                     ? { kind: "choose" }
                     : { kind: "collection", collectionId: targetCollectionId },
                 returnTo: this.selection.authorizationReturnTo()
             });
+            if (!this.lifecycleCurrent(operation.generation))
+                return this.destroyedOutcome(outcome);
             if (outcome.ok && outcome.value.kind === "connected") {
                 this.selection.finishAuthorization(outcome.value.returnTo, outcome.value.connection.collectionId);
             }
             return outcome;
         }
         finally {
+            operation.dispose();
             this.transactionDepth -= 1;
             this.refresh();
         }
     }
     async ensureOperations(requiredOperations, options) {
+        const lifecycle = this.lifecycleProblem();
+        if (lifecycle)
+            return connectFailure(lifecycle);
         const current = this.snapshot;
         if (current.status !== "ready") {
             return connectFailure(connectProblem("collection_not_ready", "Choose an authorized collection first."));
@@ -134,36 +255,82 @@ export class MdbaseSession {
         if (capabilities.sufficient) {
             return connectSuccess({ kind: "unchanged", connection: current.connection });
         }
+        const operation = this.beginLifecycleOperation(options);
         this.transactionDepth += 1;
         try {
             const outcome = await this.connect.authorize({
-                ...options,
+                ...operation.options,
                 operations: uniqueOperations([...capabilities.grantedOperations, ...capabilities.missingOperations]),
                 target: { kind: "collection", collectionId: current.collectionId },
                 returnTo: this.selection.authorizationReturnTo()
             });
+            if (!this.lifecycleCurrent(operation.generation))
+                return this.destroyedOutcome(outcome);
             if (outcome.ok && outcome.value.kind === "connected") {
                 this.selection.finishAuthorization(outcome.value.returnTo, outcome.value.connection.collectionId);
             }
             return outcome;
         }
         finally {
+            operation.dispose();
             this.transactionDepth -= 1;
             this.refresh();
         }
     }
     handleAuthorizationCallback(callbackUrl, options) {
+        const lifecycle = this.lifecycleProblem();
+        if (lifecycle)
+            return Promise.resolve(connectFailure(lifecycle));
         if (!isAuthorizationCallbackUrl(callbackUrl)) {
             return Promise.resolve(connectFailure(connectProblem("invalid_callback", "This URL is not an authorization callback.")));
         }
-        if (this.callbackPromise)
-            return this.callbackPromise;
+        return this.completeAuthorizationCallback(callbackUrl, options);
+    }
+    completeAuthorizationCallback(callbackUrl, options) {
+        if (options?.signal?.aborted) {
+            const error = requestAbortReason(options.signal);
+            return Promise.resolve(connectFailure(error.problem));
+        }
+        const state = authorizationCallbackState(callbackUrl);
+        if (!state) {
+            return Promise.resolve(connectFailure(connectProblem("invalid_callback", "Authorization callback is missing its state.")));
+        }
+        const operation = this.callbackCompletions.get(state)
+            ?? this.beginCallbackCompletion(callbackUrl, state);
+        return this.waitForCallbackCompletion(operation, options);
+    }
+    beginCallbackCompletion(callbackUrl, state) {
+        const controller = new AbortController();
+        const generation = this.lifecycleGeneration;
         this.transactionDepth += 1;
-        const completion = this.connect.completeAuthorization(callbackUrl, options)
+        this.operationControllers.add(controller);
+        const operation = {
+            state,
+            controller,
+            waiters: 0,
+            settled: false,
+            abandoned: false,
+            promise: undefined
+        };
+        const completion = this.connect.completeAuthorization(callbackUrl, {
+            signal: controller.signal,
+            timeoutMs: null
+        }).catch((error) => {
+            if (error instanceof MdbaseConnectError) {
+                return connectFailure(error.problem);
+            }
+            throw error;
+        });
+        operation.promise = completion
             .then((outcome) => {
+            if (generation !== this.lifecycleGeneration || this.destroyed) {
+                return this.destroyedOutcome(outcome);
+            }
             if (!outcome.ok) {
-                const returnTo = authorizationReturnToFromProblem(outcome.problem);
-                this.selection.clearAuthorizationCallback(returnTo);
+                if (!operation.abandoned && outcome.problem.recovery !== "retry") {
+                    const returnTo = authorizationReturnToFromProblem(outcome.problem);
+                    this.selection.clearAuthorizationCallback(returnTo);
+                }
                 this.refresh();
                 return outcome;
             }
@@ -174,18 +341,87 @@ export class MdbaseSession {
             return connectSuccess(result.connection, outcome.diagnostics);
         })
             .catch((error) => {
-            this.selection.clearAuthorizationCallback();
-            this.refresh();
+            if (generation !== this.lifecycleGeneration || this.destroyed) {
+                return connectFailure(connectProblem("session_destroyed", "This session was destroyed before authorization completion finished."));
+            }
+            if (!operation.abandoned) {
+                this.selection.clearAuthorizationCallback();
+                this.refresh();
+            }
             throw error;
         })
             .finally(() => {
+            operation.settled = true;
+            this.operationControllers.delete(controller);
             this.transactionDepth -= 1;
             this.refresh();
-            if (this.callbackPromise === completion)
-                this.callbackPromise = null;
+            if (this.callbackCompletions.get(state) === operation) {
+                this.callbackCompletions.delete(state);
+            }
         });
-        this.callbackPromise = completion;
-        return completion;
+        this.callbackCompletions.set(state, operation);
+        return operation;
+    }
+    async waitForCallbackCompletion(operation, options) {
+        operation.waiters += 1;
+        try {
+            return await withRequestBudget(options, DEFAULT_REQUEST_TIMEOUT_MS, () => operation.promise);
+        }
+        catch (error) {
+            if (error instanceof MdbaseConnectError) {
+                return connectFailure(error.problem);
+            }
+            throw error;
+        }
+        finally {
+            operation.waiters -= 1;
+            if (operation.waiters === 0
+                && !operation.settled
+                && this.callbackCompletions.get(operation.state) === operation) {
+                operation.abandoned = true;
+                this.callbackCompletions.delete(operation.state);
+                operation.controller.abort();
+            }
+        }
+    }
+    lifecycleProblem() {
+        if (this.destroyed) {
+            return connectProblem("session_destroyed", "This session has been destroyed.");
+        }
+        if (this.snapshot.status === "starting") {
+            return connectProblem("session_starting", "The session is still starting.");
+        }
+        if (this.snapshot.status === "start_failed")
+            return this.snapshot.problem;
+        if (!this.started) {
+            return connectProblem("session_not_started", "Start the session before using it.");
+        }
+        return null;
+    }
+    beginLifecycleOperation(options = {}) {
+        const controller = new AbortController();
+        const abort = () => controller.abort(options.signal?.reason);
+        if (options.signal?.aborted)
+            abort();
+        else
+            options.signal?.addEventListener("abort", abort, { once: true });
+        this.operationControllers.add(controller);
+        return {
+            generation: this.lifecycleGeneration,
+            options: { ...options, signal: controller.signal },
+            dispose: () => {
+                options.signal?.removeEventListener("abort", abort);
+                this.operationControllers.delete(controller);
+            }
+        };
+    }
+    lifecycleCurrent(generation) {
+        return !this.destroyed && generation === this.lifecycleGeneration;
+    }
+    destroyedOutcome(outcome) {
+        if (!outcome.ok && outcome.problem.code === "operation_outcome_unknown")
+            return outcome;
+        return connectFailure(connectProblem("session_destroyed", "This session was destroyed before the operation finished."));
     }
     autoSelectOnlyConnection() {
         if (this.autoSelect !== "only" || this.selection.selectedCollectionId())
@@ -196,6 +432,11 @@ export class MdbaseSession {
         }
     }
     refresh() {
+        if (!this.started
+            || this.destroyed
+            || this.snapshot.status === "starting"
+            || this.snapshot.status === "start_failed")
+            return;
         if (this.transactionDepth > 0) {
             this.refreshQueued = true;
             return;
@@ -208,14 +449,14 @@ export class MdbaseSession {
         try {
             do {
                 this.refreshQueued = false;
-                this.refreshOnce();
+                this.publishCurrent();
             } while (this.refreshQueued);
         }
         finally {
             this.refreshing = false;
         }
     }
-    refreshOnce() {
+    publishCurrent() {
         const collectionId = this.selection.selectedCollectionId();
         const connections = this.connect.connections();
         const connection = collectionId ? this.connect.connection(collectionId) : null;
@@ -252,16 +493,28 @@ export class MdbaseSession {
                 connections
             };
         }
-        const key = sessionSnapshotKey(next);
+        this.publish(next);
+    }
+    publish(snapshot) {
+        if (this.snapshot.status === "destroyed" && snapshot.status !== "destroyed")
+            return;
+        const key = sessionSnapshotKey(snapshot);
         if (key === this.snapshotKey)
             return;
-        this.snapshot = next;
+        this.snapshot = snapshot;
         this.snapshotKey = key;
         for (const listener of this.listeners)
             listener();
     }
 }
 function sessionSnapshotKey(snapshot) {
+    if (snapshot.status === "not_started"
+        || snapshot.status === "starting"
+        || snapshot.status === "destroyed")
+        return JSON.stringify(snapshot);
+    if (snapshot.status === "start_failed") {
+        return JSON.stringify({ status: snapshot.status, problem: snapshot.problem, connections: snapshot.connections });
+    }
     if (snapshot.status === "unselected") {
         return JSON.stringify({ status: snapshot.status, connections: snapshot.connections });
     }

package/dist/shared-operation.d.ts

@@ -0,0 +1,7 @@
+import type { ConnectRequestOptions } from "./operation-types.js";
+export declare class SharedOperationMap<Result> {
+    private readonly operations;
+    run(key: string, options: ConnectRequestOptions | undefined, defaultTimeoutMs: number | null, start: (signal: AbortSignal) => Promise<Result>): Promise<Result>;
+    private begin;
+    private wait;
+}

package/dist/shared-operation.js

@@ -0,0 +1,41 @@
+import { requestAbortReason, withRequestBudget } from "./request-budget.js";
+export class SharedOperationMap {
+    operations = new Map();
+    run(key, options, defaultTimeoutMs, start) {
+        if (options?.signal?.aborted)
+            return Promise.reject(requestAbortReason(options.signal));
+        const operation = this.operations.get(key) ?? this.begin(key, start);
+        return this.wait(key, operation, options, defaultTimeoutMs);
+    }
+    begin(key, start) {
+        const controller = new AbortController();
+        const operation = {
+            controller,
+            waiters: 0,
+            settled: false,
+            promise: undefined
+        };
+        operation.promise = Promise.resolve()
+            .then(() => start(controller.signal))
+            .finally(() => {
+            operation.settled = true;
+            if (this.operations.get(key) === operation)
+                this.operations.delete(key);
+        });
+        this.operations.set(key, operation);
+        return operation;
+    }
+    async wait(key, operation, options, defaultTimeoutMs) {
+        operation.waiters += 1;
+        try {
+            return await withRequestBudget(options, defaultTimeoutMs, () => operation.promise);
+        }
+        finally {
+            operation.waiters -= 1;
+            if (operation.waiters === 0 && !operation.settled && this.operations.get(key) === operation) {
+                this.operations.delete(key);
+                operation.controller.abort();
+            }
+        }
+    }
+}