@mdbase-dev/connect 0.1.0-beta.31 → 0.1.0-beta.33

package/dist/connect-authorization-helpers.d.ts

@@ -0,0 +1,3 @@
+import { MdbaseConnectError } from "./errors.js";
+export declare function declarationIdFromFamilyIdentity(familyIdentity: string): string;
+export declare function authorizationAbort(signal: AbortSignal, message: string, cause?: unknown): MdbaseConnectError;

package/dist/connect-authorization-helpers.js

@@ -0,0 +1,13 @@
+import { MdbaseConnectError, connectError } from "./errors.js";
+export function declarationIdFromFamilyIdentity(familyIdentity) {
+    const prefix = "bundle:";
+    if (!familyIdentity.startsWith(prefix) || familyIdentity.length === prefix.length) {
+        throw new Error("The registered application has no valid declaration identity.");
+    }
+    return familyIdentity.slice(prefix.length);
+}
+export function authorizationAbort(signal, message, cause) {
+    if (signal.reason instanceof MdbaseConnectError)
+        return signal.reason;
+    return connectError("authorization_cancelled", message, { cause });
+}

package/dist/connect-options.d.ts

@@ -1,14 +1,20 @@
 import type { JsonObject, MdbaseAppManifest } from "@mdbase-dev/connect-protocol";
 import type { GrantKeyStore } from "./crypto.js";
 import type { ApplicationIdentityStore } from "./application-identity.js";
+export interface MdbaseConnectTimeouts {
+    requestMs?: number | null;
+    watchStartMs?: number | null;
+    uploadMs?: number | null;
+    syncMs?: number | null;
+}
 export interface MdbaseConnectOptions {
-    serverUrl: string;
+    serverUrl: string | URL;
     /**
      * A bundled v1 application manifest or its app-local URL. String values
      * are loaded by this SDK and posted inline; Connect never fetches them.
      */
-    manifest?: MdbaseAppManifest | string;
-    redirectUri?: string;
+    manifest?: MdbaseAppManifest | string | URL;
+    redirectUri?: string | URL;
     storage?: Storage;
     /** Encrypted relay is required by default for newly authorized grants. */
     relayEncryption?: "required" | "disabled";
@@ -18,8 +24,10 @@ export interface MdbaseConnectOptions {
     /** Prefer same-computer connector access when the browser permits it. */
     directAccess?: "auto" | "disabled";
     /** Loopback origin override for development and automated testing. */
-    loopbackUrl?: string;
+    loopbackUrl?: string | URL;
     /** Override browser navigation, for example to use a native system browser. */
     navigate?: (url: string) => void | Promise<void>;
+    /** Workload-specific defaults. Per-call timeoutMs always wins. */
+    timeouts?: MdbaseConnectTimeouts;
 }
 export type MdbaseFrontmatter = JsonObject;

package/dist/connect.d.ts

@@ -5,6 +5,8 @@ import type { MdbaseConnectOptions } from "./connect-options.js";
 import type { MdbaseConnectionInfo } from "./connection-types.js";
 import { type GrantKeyStore } from "./crypto.js";
 import { type Application, type StoredToken } from "./internal-types.js";
+import type { ConnectRequestOptions } from "./operation-types.js";
+import { type ResolvedConnectTimeouts } from "./request-budget.js";
 import type { MdbaseUnavailableReason } from "./session.js";
 export declare class MdbaseConnectInternals<Frontmatter extends JsonObject> {
     readonly serverUrl: string;
@@ -18,6 +20,7 @@ export declare class MdbaseConnectInternals<Frontmatter extends JsonObject> {
     readonly directAccessMode: "auto" | "disabled";
     readonly loopbackUrl: string;
     readonly navigate?: (url: string) => void | Promise<void>;
+    readonly timeouts: ResolvedConnectTimeouts;
     readonly credentialStorage: MdbaseConnectEnvironment["credentialStorage"];
     private application;
     private manifestPromise;
@@ -27,13 +30,16 @@ export declare class MdbaseConnectInternals<Frontmatter extends JsonObject> {
     private readonly invalidatedConnections;
     constructor(options: MdbaseConnectOptions);
     environment(): MdbaseConnectEnvironment;
-    register(): Promise<Application>;
-    manifestDeclaration(): Promise<MdbaseAppManifest>;
+    register(options?: ConnectRequestOptions): Promise<Application>;
+    private registerWithinBudget;
+    manifestDeclaration(options?: ConnectRequestOptions): Promise<MdbaseAppManifest>;
     private loadManifest;
     authorize(options?: MdbaseAuthorizeOptions): Promise<MdbaseAuthorizationOutcome<Frontmatter>>;
+    private authorizeWithinBudget;
     private authorizeWeb;
     private authorizePortable;
-    completeAuthorization(callbackUrl: string): Promise<MdbaseAuthorizationResult<Frontmatter>>;
+    completeAuthorization(callbackUrl: string, options?: ConnectRequestOptions): Promise<MdbaseAuthorizationResult<Frontmatter>>;
+    private completeAuthorizationWithinBudget;
     private performAuthorizationCompletion;
     connections(): MdbaseConnectionInfo[];
     connection(collectionId: string): MdbaseConnection<Frontmatter> | null;
@@ -44,9 +50,11 @@ export declare class MdbaseConnectInternals<Frontmatter extends JsonObject> {
     private pinConnectorIdentity;
     private connectorPinKey;
     private loadApplicationIdentity;
-    removeToken(collectionId: string, keyHandle?: string, reason?: MdbaseUnavailableReason): void;
+    removeToken(collectionId: string, keyHandle?: string, reason?: MdbaseUnavailableReason, discardPending?: boolean): void;
     tokenKey(collectionId: string): string;
     pendingMutationKey(collectionId: string): string;
+    private removePendingMutations;
+    private pendingMutationsUseKey;
     notificationKey(collectionId: string, transport?: "web_push" | "fcm"): string;
     directPreferenceKey(): string;
     defaultApplicationOrigin(): string;

package/dist/connect.js

@@ -1,13 +1,16 @@
-import { APPLICATION_AUTHORIZATION_PROTOCOL_VERSION, DEFAULT_LOOPBACK_PORT, ENCRYPTED_RELAY_PROTOCOL_VERSION, RELAY_ENCRYPTION_SUITE } from "@mdbase-dev/connect-protocol";
+import { APPLICATION_AUTHORIZATION_PROTOCOL_VERSION, authorizationContractRequirements, DEFAULT_LOOPBACK_PORT, GRANT_ENCRYPTION_PROTOCOL_VERSION, RELAY_ENCRYPTION_SUITE } from "@mdbase-dev/connect-protocol";
 import { abortableDelay } from "./async.js";
 import { randomBase64Url } from "./base64.js";
 import { ApplicationIdentityStoreError, IndexedDbApplicationIdentityStore, MemoryApplicationIdentityStore, applicationIdentity, applicationInstallationId, signApplicationAuthorization } from "./application-identity.js";
 import { MdbaseConnection } from "./connection.js";
-import { IndexedDbGrantKeyStore, MemoryGrantKeyStore, validateGrantEncryption } from "./crypto.js";
+import { authorizationAbort, declarationIdFromFamilyIdentity } from "./connect-authorization-helpers.js";
+import { IndexedDbGrantKeyStore, MemoryGrantKeyStore } from "./crypto.js";
 import { connectError, serverConnectError } from "./errors.js";
 import { DEFAULT_OPERATIONS } from "./internal-types.js";
 import { uniqueOperations } from "./operation-helpers.js";
-import { MemoryStorage, apiError, applicationStorageOrigin, canonicalLoopbackUrl, collectionIdFromTokenKey, connectFetch, createPkce, defaultManifestSource, defaultRedirectUri, defaultStorage, isOpaquePortableManifest, manifestStorageFingerprint, oauthErrorCode, parseDeviceAuthorization, parseGrantScope, parseStored, stripTrailingSlash, validFileCapability, validAuthorityTokenResponse } from "./runtime-utils.js";
+import { resolveConnectTimeouts, withRequestBudget } from "./request-budget.js";
+import { MemoryStorage, apiError, applicationStorageOrigin, canonicalLoopbackUrl, collectionIdFromTokenKey, connectFetch, createPkce, defaultManifestSource, defaultRedirectUri, defaultStorage, decodeJsonResponse, isOpaquePortableManifest, manifestStorageFingerprint, oauthErrorCode, parseDeviceAuthorization, parseStored, stripTrailingSlash, validAuthorityTokenResponse } from "./runtime-utils.js";
+import { storedTokenFromResponse } from "./token-response.js";
 export class MdbaseConnectInternals {
     serverUrl;
     manifest;
@@ -20,6 +23,7 @@ export class MdbaseConnectInternals {
     directAccessMode;
     loopbackUrl;
     navigate;
+    timeouts;
     credentialStorage;
     application = null;
     manifestPromise = null;
@@ -28,17 +32,19 @@ export class MdbaseConnectInternals {
     listeners = new Set();
     invalidatedConnections = new Map();
     constructor(options) {
-        this.serverUrl = stripTrailingSlash(options.serverUrl);
-        this.manifest = options.manifest ?? defaultManifestSource();
+        this.serverUrl = stripTrailingSlash(String(options.serverUrl));
+        this.manifest = options.manifest instanceof URL
+            ? options.manifest.href
+            : options.manifest ?? defaultManifestSource();
         this.manifestSource = typeof this.manifest === "string"
             ? this.manifest
             : this.manifest.distribution === "portable"
                 ? `bundle:${this.manifest.id}:${manifestStorageFingerprint(this.manifest)}`
                 : `bundle:${this.manifest.id}`;
         const opaquePortable = isOpaquePortableManifest(this.manifest);
-        this.redirectUri = options.redirectUri ?? (typeof this.manifest !== "string" && this.manifest.distribution === "portable"
+        this.redirectUri = options.redirectUri === undefined ? (typeof this.manifest !== "string" && this.manifest.distribution === "portable"
             ? ""
-            : defaultRedirectUri());
+            : defaultRedirectUri()) : String(options.redirectUri);
         this.storage = options.storage ?? defaultStorage(opaquePortable);
         this.relayEncryption = options.relayEncryption ?? "required";
         this.keyStore = options.keyStore ?? (opaquePortable ? new MemoryGrantKeyStore() : new IndexedDbGrantKeyStore());
@@ -49,8 +55,9 @@ export class MdbaseConnectInternals {
             ? "custom"
             : this.storage instanceof MemoryStorage ? "memory" : "persistent";
         this.directAccessMode = options.directAccess ?? "auto";
-        this.loopbackUrl = canonicalLoopbackUrl(options.loopbackUrl ?? `http://127.0.0.1:${DEFAULT_LOOPBACK_PORT}`);
+        this.loopbackUrl = canonicalLoopbackUrl(String(options.loopbackUrl ?? `http://127.0.0.1:${DEFAULT_LOOPBACK_PORT}`));
         this.navigate = options.navigate;
+        this.timeouts = resolveConnectTimeouts(options.timeouts);
         if (typeof window !== "undefined" && this.storage === window.localStorage) {
             window.addEventListener("storage", (event) => {
                 if (event.storageArea !== this.storage || !event.key?.startsWith(this.storagePrefix()))
@@ -73,34 +80,45 @@ export class MdbaseConnectInternals {
             credentialStorage: this.credentialStorage
         };
     }
-    async register() {
+    register(options = {}) {
+        return withRequestBudget(options, this.timeouts.requestMs, (budget) => this.registerWithinBudget(budget.signal));
+    }
+    async registerWithinBudget(signal) {
         if (this.application)
             return this.application;
         const response = await connectFetch(`${this.serverUrl}/v1/apps/register`, {
             method: "POST",
             headers: { "content-type": "application/json" },
-            body: JSON.stringify({ manifest: await this.manifestDeclaration() })
+            body: JSON.stringify({ manifest: await this.manifestDeclaration({ signal, timeoutMs: null }) }),
+            signal
         }, "temporarily_unavailable", "Application registration is temporarily unavailable.");
-        const body = await response.json();
+        const body = await decodeJsonResponse(response, "invalid_operation_response", "Connect returned an invalid application registration response.");
         if (!response.ok)
             throw apiError(body, "discovery_failed", "Application discovery failed.", response.status);
         this.application = body.application;
         return this.application;
     }
-    manifestDeclaration() {
+    manifestDeclaration(options = {}) {
         if (this.manifestPromise)
             return this.manifestPromise;
-        this.manifestPromise = this.loadManifest();
+        const loading = withRequestBudget(options, this.timeouts.requestMs, (budget) => this.loadManifest(budget.signal));
+        const shared = loading.catch((error) => {
+            if (this.manifestPromise === shared)
+                this.manifestPromise = null;
+            throw error;
+        });
+        this.manifestPromise = shared;
         return this.manifestPromise;
     }
-    async loadManifest() {
+    async loadManifest(signal) {
         if (typeof this.manifest !== "string")
             return this.manifest;
         const source = this.manifest;
         let response;
         try {
             response = await fetch(source, {
-                headers: { accept: "application/json" }
+                headers: { accept: "application/json" },
+                signal
             });
         }
         catch (cause) {
@@ -110,7 +128,7 @@ export class MdbaseConnectInternals {
             throw connectError("manifest_load_failed", `The bundled application declaration returned HTTP ${response.status}.`, { status: response.status });
         }
         try {
-            return await response.json();
+            return await decodeJsonResponse(response, "invalid_application_manifest", "The bundled application declaration is not valid JSON.");
         }
         catch (cause) {
             throw connectError("invalid_application_manifest", "The bundled application declaration is not valid JSON.", {
@@ -127,6 +145,9 @@ export class MdbaseConnectInternals {
         }
     }
     async authorize(options = {}) {
+        return withRequestBudget(options, this.timeouts.requestMs, (budget) => this.authorizeWithinBudget({ ...options, signal: budget.signal, timeoutMs: null }));
+    }
+    async authorizeWithinBudget(options) {
         if (typeof location === "undefined" && !this.navigate && !options.openVerification) {
             throw connectError("browser_required", "Authorization navigation requires a browser environment.");
         }
@@ -140,7 +161,7 @@ export class MdbaseConnectInternals {
             : null;
         let application;
         try {
-            application = await this.register();
+            application = await this.registerWithinBudget(options.signal);
         }
         catch (error) {
             popup?.close();
@@ -177,6 +198,7 @@ export class MdbaseConnectInternals {
             protocol_version: APPLICATION_AUTHORIZATION_PROTOCOL_VERSION,
             authorization_id: authorizationId,
             application_id: application.id,
+            application_declaration_id: declarationIdFromFamilyIdentity(application.family_identity),
             application_manifest_digest: application.manifest_digest,
             application_installation_id: await applicationInstallationId(installation),
             installation_signing_public_key: installation.signingPublicKey,
@@ -189,6 +211,7 @@ export class MdbaseConnectInternals {
             redirect_uri: this.redirectUri,
             state,
             code_challenge: challenge,
+            contracts: authorizationContractRequirements(operations, application.requirements?.files),
             requested_operations: operations,
             ...(application.requirements?.files
                 ? { requested_files: application.requirements.files }
@@ -226,7 +249,7 @@ export class MdbaseConnectInternals {
                 }),
                 signal: options.signal
             });
-            const body = await response.json();
+            const body = await decodeJsonResponse(response, "invalid_device_authorization_response", "The authorization service returned an invalid authorization response.");
             if (!response.ok) {
                 throw apiError(body, "device_authorization_failed", "Application authorization could not be started.", response.status);
             }
@@ -249,7 +272,7 @@ export class MdbaseConnectInternals {
             this.storage.removeItem(this.pendingKey(state));
             await this.keyStore.delete(keyHandle);
             if (options.signal?.aborted) {
-                throw connectError("authorization_cancelled", "Application authorization was cancelled.", { cause: error });
+                throw authorizationAbort(options.signal, "Application authorization was cancelled.", error);
             }
             throw error;
         }
@@ -278,6 +301,7 @@ export class MdbaseConnectInternals {
             protocol_version: APPLICATION_AUTHORIZATION_PROTOCOL_VERSION,
             authorization_id: authorizationId,
             application_id: application.id,
+            application_declaration_id: declarationIdFromFamilyIdentity(application.family_identity),
             application_manifest_digest: application.manifest_digest,
             application_installation_id: await applicationInstallationId(installation),
             installation_signing_public_key: installation.signingPublicKey,
@@ -288,6 +312,7 @@ export class MdbaseConnectInternals {
             issued_at: issuedAt.toISOString(),
             expires_at: new Date(issuedAt.getTime() + 10 * 60 * 1_000).toISOString(),
             code_challenge: challenge,
+            contracts: authorizationContractRequirements(operations, application.requirements?.files),
             requested_operations: operations,
             ...(application.requirements?.files
                 ? { requested_files: application.requirements.files }
@@ -311,9 +336,10 @@ export class MdbaseConnectInternals {
                     code_challenge: challenge,
                     code_challenge_method: "S256",
                     application_authorization: JSON.stringify(proof)
-                })
+                }),
+                signal: options.signal
             });
-            body = await response.json();
+            body = await decodeJsonResponse(response, "invalid_device_authorization_response", "The authorization service returned an invalid device authorization response.");
         }
         catch (cause) {
             popup?.close();
@@ -333,7 +359,7 @@ export class MdbaseConnectInternals {
             popup?.close();
             await this.keyStore.delete(keyHandle);
             if (options.signal?.aborted) {
-                throw connectError("authorization_cancelled", "Downloaded application authorization was cancelled.", { cause: error });
+                throw authorizationAbort(options.signal, "Downloaded application authorization was cancelled.", error);
             }
             throw error;
         }
@@ -366,7 +392,7 @@ export class MdbaseConnectInternals {
             while (Date.now() < authorization.expiresAt) {
                 await abortableDelay(intervalSeconds * 1_000, options.signal);
                 if (options.signal?.aborted) {
-                    throw connectError("authorization_cancelled", "Downloaded application authorization was cancelled.");
+                    throw authorizationAbort(options.signal, "Downloaded application authorization was cancelled.");
                 }
                 let tokenResponse;
                 try {
@@ -384,11 +410,11 @@ export class MdbaseConnectInternals {
                 }
                 catch (cause) {
                     if (options.signal?.aborted) {
-                        throw connectError("authorization_cancelled", "Downloaded application authorization was cancelled.", { cause });
+                        throw authorizationAbort(options.signal, "Downloaded application authorization was cancelled.", cause);
                     }
                     continue;
                 }
-                const tokenBody = await tokenResponse.json();
+                const tokenBody = await decodeJsonResponse(tokenResponse, "invalid_token_response", "The authorization service returned an invalid token response.");
                 if (!tokenResponse.ok) {
                     const code = oauthErrorCode(tokenBody);
                     if (code === "authorization_pending") {
@@ -402,7 +428,7 @@ export class MdbaseConnectInternals {
                 }
                 const authority = validAuthorityTokenResponse(tokenBody.authority, tokenBody.collection_id);
                 const localEncryption = tokenBody.encryption
-                    && tokenBody.encryption.protocol_version === ENCRYPTED_RELAY_PROTOCOL_VERSION
+                    && tokenBody.encryption.protocol_version === GRANT_ENCRYPTION_PROTOCOL_VERSION
                     && tokenBody.encryption.suite === RELAY_ENCRYPTION_SUITE
                     && tokenBody.encryption.application_agreement_public_key
                         === grantKey.agreementPublicKey;
@@ -437,12 +463,15 @@ export class MdbaseConnectInternals {
             popup?.close();
             await this.keyStore.delete(keyHandle);
             if (options.signal?.aborted) {
-                throw connectError("authorization_cancelled", "Downloaded application authorization was cancelled.", { cause: error });
+                throw authorizationAbort(options.signal, "Downloaded application authorization was cancelled.", error);
             }
             throw error;
         }
     }
-    completeAuthorization(callbackUrl) {
+    completeAuthorization(callbackUrl, options = {}) {
+        return withRequestBudget(options, this.timeouts.requestMs, (budget) => this.completeAuthorizationWithinBudget(callbackUrl, budget.signal));
+    }
+    completeAuthorizationWithinBudget(callbackUrl, signal) {
         const state = new URL(callbackUrl).searchParams.get("state");
         if (!state) {
             return Promise.reject(connectError("invalid_callback", "Authorization callback is missing its state."));
@@ -450,7 +479,7 @@ export class MdbaseConnectInternals {
         const existing = this.completionPromises.get(state);
         if (existing)
             return existing;
-        const completion = this.performAuthorizationCompletion(callbackUrl, state);
+        const completion = this.performAuthorizationCompletion(callbackUrl, state, signal);
         const shared = completion.finally(() => {
             if (this.completionPromises.get(state) === shared)
                 this.completionPromises.delete(state);
@@ -458,7 +487,7 @@ export class MdbaseConnectInternals {
         this.completionPromises.set(state, shared);
         return shared;
     }
-    async performAuthorizationCompletion(callbackUrl, state) {
+    async performAuthorizationCompletion(callbackUrl, state, signal) {
         const callback = new URL(callbackUrl);
         const code = callback.searchParams.get("code");
         const pendingKey = this.pendingKey(state);
@@ -484,9 +513,10 @@ export class MdbaseConnectInternals {
                 client_id: pending.clientId,
                 redirect_uri: pending.redirectUri,
                 code_verifier: pending.verifier
-            })
+            }),
+            signal
         }, "temporarily_unavailable", "Authorization completion is temporarily unavailable.");
-        const body = await response.json();
+        const body = await decodeJsonResponse(response, "invalid_token_response", "The authorization service returned an invalid token response.");
         if (!response.ok)
             throw apiError(body, "token_exchange_failed", "Authorization could not be completed.", response.status);
         if (pending.relayEncryption === "required" && !body.authority && (!body.encryption
@@ -555,78 +585,18 @@ export class MdbaseConnectInternals {
         if (typeof collectionId !== "string") {
             throw connectError("invalid_token_response", "Authorization returned no collection ID.");
         }
-        const scope = parseGrantScope(body.scope);
-        if (!scope) {
-            throw connectError("invalid_token_response", "Authorization returned no valid collection scope.");
-        }
-        if (body.authority && !validAuthorityTokenResponse(body.authority, collectionId)) {
-            throw connectError("invalid_token_response", "Authorization returned an invalid remote authority capability.");
-        }
-        if (body.authority && body.encryption) {
-            throw connectError("invalid_token_response", "Authorization returned conflicting collection transports.");
-        }
-        if (body.file_capability !== null && body.file_capability !== undefined
-            && !validFileCapability(body.file_capability)) {
-            throw connectError("invalid_token_response", "Authorization returned an invalid file capability.");
-        }
-        if (body.encryption) {
-            try {
-                validateGrantEncryption(body.encryption);
-            }
-            catch {
-                throw connectError("invalid_token_response", "Authorization returned an invalid encrypted relay binding.");
-            }
-            this.pinConnectorIdentity(body.encryption.connector_id, body.encryption.connector_agreement_public_key);
-            if (body.encryption.collection_id !== collectionId
-                || typeof body.grant_id !== "string"
-                || body.grant_id.length === 0) {
-                throw connectError("invalid_token_response", "Authorization returned an encrypted relay binding for another grant.");
-            }
-        }
         const previous = parseStored(this.storage.getItem(this.tokenKey(collectionId)));
-        if (previous?.encryption
-            && body.encryption
-            && previous.keyHandle
-            && previous.keyHandle === keyHandle
-            && (previous.grantId !== body.grant_id
-                || previous.encryption.connector_id !== body.encryption.connector_id
-                || previous.encryption.connector_agreement_public_key
-                    !== body.encryption.connector_agreement_public_key
-                || previous.encryption.application_agreement_public_key
-                    !== body.encryption.application_agreement_public_key)) {
-            throw connectError("connector_identity_changed", "The connector identity changed during authorization renewal. Reauthorize before sending collection data.");
-        }
+        const token = storedTokenFromResponse({
+            body,
+            clientId,
+            keyHandle,
+            previous,
+            defaultApplicationOrigin: this.defaultApplicationOrigin(),
+            pinConnectorIdentity: (connectorId, publicKey) => this.pinConnectorIdentity(connectorId, publicKey)
+        });
         if (previous?.keyHandle && previous.keyHandle !== keyHandle) {
             void this.keyStore.delete(previous.keyHandle).catch(() => undefined);
         }
-        const token = {
-            version: 1,
-            accessToken: body.access_token,
-            refreshToken: body.refresh_token,
-            clientId,
-            collectionId,
-            collectionName: body.collection_name ?? `Collection ${collectionId.slice(0, 8)}`,
-            operations: body.operations,
-            scope,
-            expiresAt: Date.now() + body.expires_in * 1_000,
-            refreshExpiresAt: body.refresh_expires_in
-                ? Date.now() + body.refresh_expires_in * 1_000
-                : undefined,
-            grantId: body.grant_id,
-            encryption: body.encryption ?? undefined,
-            fileCapability: body.file_capability ?? undefined,
-            applicationOrigin: body.application_origin ?? this.defaultApplicationOrigin(),
-            keyHandle,
-            savedAt: Date.now(),
-            authority: body.authority ? {
-                operationsUrl: body.authority.operations_url,
-                syncUrl: body.authority.sync_url,
-                filesUrl: body.authority.files_url,
-                replicaId: body.authority.replica_id,
-                accessToken: body.authority.access_token,
-                proofPublicKey: body.authority.proof_public_key
-            } : undefined
-        };
         this.storage.setItem(this.tokenKey(collectionId), JSON.stringify(token));
         this.addConnectionId(collectionId);
         this.invalidatedConnections.delete(collectionId);
@@ -659,12 +629,14 @@ export class MdbaseConnectInternals {
                 : "The application installation identity is unavailable.", { cause });
         }
     }
-    removeToken(collectionId, keyHandle, reason = "authorization_lost") {
+    removeToken(collectionId, keyHandle, reason = "authorization_lost", discardPending = false) {
         this.invalidatedConnections.set(collectionId, reason);
-        if (keyHandle)
+        if (keyHandle && (discardPending || !this.pendingMutationsUseKey(collectionId, keyHandle))) {
             void this.keyStore.delete(keyHandle).catch(() => undefined);
+        }
         this.storage.removeItem(this.tokenKey(collectionId));
-        this.storage.removeItem(this.pendingMutationKey(collectionId));
+        if (discardPending)
+            this.removePendingMutations(collectionId);
         for (const transport of ["web_push", "fcm"]) {
             this.storage.removeItem(this.notificationKey(collectionId, transport));
         }
@@ -681,6 +653,33 @@ export class MdbaseConnectInternals {
     pendingMutationKey(collectionId) {
         return `${this.storagePrefix()}:pending-mutation:${collectionId}`;
     }
+    removePendingMutations(collectionId) {
+        const baseKey = this.pendingMutationKey(collectionId);
+        const keys = [baseKey];
+        for (let index = 0; index < this.storage.length; index += 1) {
+            const key = this.storage.key(index);
+            if (key?.startsWith(`${baseKey}:`))
+                keys.push(key);
+        }
+        for (const key of keys) {
+            const pending = parseStored(this.storage.getItem(key));
+            if (pending?.keyHandle)
+                void this.keyStore.delete(pending.keyHandle).catch(() => undefined);
+            this.storage.removeItem(key);
+        }
+    }
+    pendingMutationsUseKey(collectionId, keyHandle) {
+        const baseKey = this.pendingMutationKey(collectionId);
+        for (let index = 0; index < this.storage.length; index += 1) {
+            const key = this.storage.key(index);
+            if (key !== baseKey && !key?.startsWith(`${baseKey}:`))
+                continue;
+            const pending = parseStored(this.storage.getItem(key));
+            if (pending?.keyHandle === keyHandle)
+                return true;
+        }
+        return false;
+    }
     notificationKey(collectionId, transport = "web_push") {
         return `${this.storagePrefix()}:notifications:${collectionId}:${transport}`;
     }

package/dist/connection-file-transport.d.ts

@@ -6,8 +6,8 @@ export interface ConnectionFileTransportOptions {
     keyStore: GrantKeyStore;
     serverUrl: string;
     loopbackUrl: string;
-    authorizedToken(): Promise<StoredToken | null>;
-    refreshAuthorization(): Promise<StoredToken>;
+    authorizedToken(signal?: AbortSignal): Promise<StoredToken | null>;
+    refreshAuthorization(signal?: AbortSignal): Promise<StoredToken>;
     shouldAttemptDirect(token: StoredToken): Promise<boolean>;
     onDirectAvailable(): void;
     onDirectUnavailable(): void;

package/dist/connection-file-transport.js

@@ -13,7 +13,7 @@ export class ConnectionFileTransport {
         this.local = new LocalFileTransport(options);
     }
     async control(method, path = "", input, signal) {
-        const token = await this.requireFileToken();
+        const token = await this.requireFileToken(signal);
         if (!token.authority) {
             return this.local.control(token, method, path, input, signal);
         }
@@ -26,14 +26,14 @@ export class ConnectionFileTransport {
         return this.local.downloadChunk(session, chunkIndex, signal);
     }
     async downloadHostedPart(session, partIndex, expectedLength, signal) {
-        const token = await this.requireFileToken();
+        const token = await this.requireFileToken(signal);
         if (!token.authority) {
             throw connectError("not_remote_authority", "Hosted file delivery requires a remote authority endpoint.");
         }
         return performHostedFilePartRequest(token, `downloads/${encodeURIComponent(session.transfer_id)}/parts/${partIndex}`, expectedLength, signal, this.options.refreshAuthorization, this.options.authorityProofHeaders);
     }
-    async requireFileToken() {
-        const token = await this.options.authorizedToken();
+    async requireFileToken(signal) {
+        const token = await this.options.authorizedToken(signal);
         if (!token?.fileCapability) {
             throw connectError("not_authorized", "This connection has no file capability.");
         }

package/dist/connection-notifications.d.ts

@@ -1,17 +1,20 @@
 import type { Application } from "./internal-types.js";
 import type { StoredToken } from "./internal-types.js";
+import type { ConnectRequestOptions } from "./operation-types.js";
 import type { MdbaseNativeNotificationRegistration, MdbaseNativeNotificationRegistrationOptions, MdbaseNotificationRegistration, MdbaseNotificationRegistrationOptions } from "./notifications.js";
 export interface ConnectionNotificationContext {
     serverUrl: string;
     storage: Storage;
-    authorizedToken(): Promise<StoredToken | null>;
-    register(): Promise<Application>;
+    authorizedToken(signal?: AbortSignal): Promise<StoredToken | null>;
+    register(signal?: AbortSignal): Promise<Application>;
     notificationKey(transport?: "web_push" | "fcm"): string;
+    requestTimeoutMs: number | null;
 }
 export declare class ConnectionNotifications {
     private readonly context;
     constructor(context: ConnectionNotificationContext);
     registerNotifications(options: MdbaseNotificationRegistrationOptions): Promise<MdbaseNotificationRegistration>;
+    private registerNotificationsWithinBudget;
     /**
      * Register an iOS or Android installation for Connect-managed FCM.
      *
@@ -19,7 +22,10 @@ export declare class ConnectionNotifications {
      * same installation whenever Firebase refreshes its token.
      */
     registerNativeNotifications(options: MdbaseNativeNotificationRegistrationOptions): Promise<MdbaseNativeNotificationRegistration>;
-    unregisterNativeNotifications(): Promise<void>;
-    unregisterNotifications(serviceWorker?: ServiceWorkerRegistration): Promise<void>;
+    private registerNativeNotificationsWithinBudget;
+    unregisterNativeNotifications(options?: ConnectRequestOptions): Promise<void>;
+    private unregisterNativeNotificationsWithinBudget;
+    unregisterNotifications(serviceWorker?: ServiceWorkerRegistration, options?: ConnectRequestOptions): Promise<void>;
+    private unregisterNotificationsWithinBudget;
     private deleteNotificationChannel;
 }