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

package/dist/connection-types.d.ts

@@ -1,4 +1,5 @@
 import type { CollectionOperation, FileCapability, GrantScope, JsonObject, SyncChangesPage, SyncMutation, SyncMutationReceipt, SyncSession, SyncSnapshotPage } from "@mdbase-dev/connect-protocol";
+import type { ConnectRequestOptions } from "./operation-types.js";
 export type MdbaseConnectionRoute = "remote" | "direct" | "relay";
 export type DirectAccessStatus = "disabled" | "permission_required" | "checking" | "available" | "unavailable" | "denied";
 export interface MdbaseConnectionInfo {
@@ -25,10 +26,10 @@ export interface MdbaseAuthorizationCapabilities {
     missingOperations: CollectionOperation[];
 }
 export interface MdbaseSyncTransport<Frontmatter extends JsonObject = JsonObject> {
-    openSession(): Promise<SyncSession>;
-    snapshot(snapshotId: string, page?: string): Promise<SyncSnapshotPage<Frontmatter>>;
-    changes(after: number, limit?: number): Promise<SyncChangesPage<Frontmatter>>;
-    mutate(mutation: SyncMutation): Promise<SyncMutationReceipt<Frontmatter>>;
+    openSession(options?: ConnectRequestOptions): Promise<SyncSession>;
+    snapshot(snapshotId: string, page?: string, options?: ConnectRequestOptions): Promise<SyncSnapshotPage<Frontmatter>>;
+    changes(after: number, limit?: number, options?: ConnectRequestOptions): Promise<SyncChangesPage<Frontmatter>>;
+    mutate(mutation: SyncMutation, options?: ConnectRequestOptions): Promise<SyncMutationReceipt<Frontmatter>>;
 }
 export interface MdbaseSyncConnection<Frontmatter extends JsonObject = JsonObject> {
     collectionId: string;

package/dist/connection.d.ts

@@ -1,20 +1,21 @@
-import type { CollectionChange, CollectionChangesPage, CollectionDescription, CollectionOperation, CollectionTypeDocument, CreateViewSourceInput, DeleteViewSourceInput, DeleteViewSourceResult, ExecuteViewInput, FileCapability, GrantScope, JsonObject, ReadViewSourceInput, RecordDocument, SavedViewExecution, SavedViewList, SavedViewSourceDocument, ApplyTypePackInput, AssessTypePackInput, TypePackApplyResult, TypePackAssessment, UpdateViewSourceInput } from "@mdbase-dev/connect-protocol";
+import type { CollectionChangesPage, CollectionDescription, CollectionOperation, CollectionTypeDocument, CreateViewSourceInput, DeleteViewSourceInput, DeleteViewSourceResult, ExecuteViewInput, FileCapability, GrantScope, JsonObject, ReadViewSourceInput, RecordDocument, SavedViewExecution, SavedViewList, SavedViewSourceDocument, ApplyTypePackInput, AssessTypePackInput, TypePackApplyResult, TypePackAssessment, UpdateViewSourceInput } from "@mdbase-dev/connect-protocol";
 import { type ConnectionTransportInternals } from "./connection-transport.js";
 import type { DirectAccessStatus, MdbaseAuthorizationCapabilities, MdbaseConnectionInfo, MdbaseConnectionRoute, MdbaseSyncConnection } from "./connection-types.js";
 import type { GrantKeyStore } from "./crypto.js";
 import { MdbaseFileClient } from "./files.js";
 import { type Application } from "./internal-types.js";
 import type { MdbaseNativeNotificationRegistration, MdbaseNativeNotificationRegistrationOptions, MdbaseNotificationRegistration, MdbaseNotificationRegistrationOptions } from "./notifications.js";
-import type { ChangesInput, CreateInput, CreateTypeInput, DeleteInput, DeletePreflightResult, DeleteProgressOptions, DeleteResult, MdbaseDesiredTimer, MdbaseTimer, MdbaseTimerList, MdbaseTimerReconciliation, OperationRequestOptions, PendingMutationSummary, QueryInput, QueryPage, QueryPagesOptions, QueryResult, ReadInput, ReadTypeInput, RenameInput, RenamePreflightResult, RenameProgressOptions, RenameResult, UpdateInput, UpdateTypeInput, WatchOptions } from "./operation-types.js";
+import type { ChangesInput, CreateInput, CreateTypeInput, DeleteInput, DeletePreflightResult, DeleteProgressOptions, DeleteResult, MdbaseDesiredTimer, MdbaseTimer, MdbaseTimerList, MdbaseTimerReconciliation, ConnectRequestOptions, PendingMutation, QueryInput, QueryPage, QueryPagesOptions, QueryResult, ReadInput, ReadTypeInput, RenameInput, RenamePreflightResult, RenameProgressOptions, RenameResult, UpdateInput, UpdateTypeInput, MdbaseWatchSubscription, WatchInput } from "./operation-types.js";
 import { type AuthorizationProblemCode, type CollectionChangesProblemCode, type CollectionDescriptionProblemCode, type CollectionMutationProblemCode, type CollectionQueryProblemCode, type CollectionReadProblemCode, type CollectionTypeProblemCode, type ConnectOutcome, type DirectAccessProblemCode, type NotificationProblemCode, type RegistrationProblemCode } from "./outcomes.js";
 import type { MdbaseDeviceAuthorization } from "./authorization-types.js";
+import { type ResolvedConnectTimeouts } from "./request-budget.js";
 export type MdbaseAuthorizationTarget = {
     kind: "choose";
 } | {
     kind: "collection";
     collectionId: string;
 };
-export interface MdbaseAuthorizeOptions {
+export interface MdbaseAuthorizeOptions extends ConnectRequestOptions {
     operations?: CollectionOperation[];
     /** Choose any compatible collection, or require one exact collection. */
     target?: MdbaseAuthorizationTarget;
@@ -24,15 +25,12 @@ export interface MdbaseAuthorizeOptions {
     onDeviceCode?: (authorization: MdbaseDeviceAuthorization) => void;
     /** Replace the default popup for a downloaded application's approval page. */
     openVerification?: (authorization: MdbaseDeviceAuthorization) => void | Promise<void>;
-    /** Stop polling and discard the unapproved, in-memory key. */
-    signal?: AbortSignal;
 }
-export interface MdbaseConnectionAuthorizeOptions {
+export interface MdbaseConnectionAuthorizeOptions extends ConnectRequestOptions {
     operations?: CollectionOperation[];
     returnTo?: string;
     onDeviceCode?: (authorization: MdbaseDeviceAuthorization) => void;
     openVerification?: (authorization: MdbaseDeviceAuthorization) => void | Promise<void>;
-    signal?: AbortSignal;
 }
 export interface MdbaseConnectEnvironment {
     distribution: "web" | "portable";
@@ -54,7 +52,8 @@ export interface MdbaseConnectionInternals<Frontmatter extends JsonObject> exten
     readonly keyStore: GrantKeyStore;
     readonly directAccessMode: "auto" | "disabled";
     readonly loopbackUrl: string;
-    register(): Promise<Application>;
+    readonly timeouts: ResolvedConnectTimeouts;
+    register(options?: ConnectRequestOptions): Promise<Application>;
     authorize(options?: MdbaseAuthorizeOptions): Promise<MdbaseAuthorizationOutcome<Frontmatter>>;
     notificationKey(collectionId: string, transport?: "web_push" | "fcm"): string;
 }
@@ -73,7 +72,7 @@ export declare class MdbaseConnection<Frontmatter extends JsonObject = JsonObjec
     get fileCapability(): FileCapability | null;
     get directAccess(): DirectAccessStatus;
     get route(): MdbaseConnectionRoute;
-    register(): Promise<ConnectOutcome<Application, RegistrationProblemCode>>;
+    register(options?: ConnectRequestOptions): Promise<ConnectOutcome<Application, RegistrationProblemCode>>;
     info(): MdbaseConnectionInfo | null;
     authorizationCapabilities(requiredOperations?: CollectionOperation[]): MdbaseAuthorizationCapabilities;
     hasOperations(requiredOperations: CollectionOperation[]): boolean;
@@ -84,9 +83,9 @@ export declare class MdbaseConnection<Frontmatter extends JsonObject = JsonObjec
     }, AuthorizationProblemCode>>;
     onConnectionChange(listener: (connection: MdbaseConnectionInfo | null) => void): () => void;
     notifyStorageChanged(): void;
-    checkDirectAccess(): Promise<ConnectOutcome<DirectAccessStatus, DirectAccessProblemCode>>;
+    checkDirectAccess(options?: ConnectRequestOptions): Promise<ConnectOutcome<DirectAccessStatus, DirectAccessProblemCode>>;
     /** Call from a user gesture to request browser permission for direct local access. */
-    requestDirectAccess(): Promise<ConnectOutcome<DirectAccessStatus, DirectAccessProblemCode>>;
+    requestDirectAccess(options?: ConnectRequestOptions): Promise<ConnectOutcome<DirectAccessStatus, DirectAccessProblemCode>>;
     disableDirectAccess(): void;
     /**
      * Return one offline-replication transport regardless of whether the
@@ -102,48 +101,49 @@ export declare class MdbaseConnection<Frontmatter extends JsonObject = JsonObjec
      */
     registerNotifications(options: MdbaseNotificationRegistrationOptions): Promise<ConnectOutcome<MdbaseNotificationRegistration, NotificationProblemCode>>;
     registerNativeNotifications(options: MdbaseNativeNotificationRegistrationOptions): Promise<ConnectOutcome<MdbaseNativeNotificationRegistration, NotificationProblemCode>>;
-    unregisterNativeNotifications(): Promise<ConnectOutcome<void, NotificationProblemCode>>;
-    unregisterNotifications(serviceWorker?: ServiceWorkerRegistration): Promise<ConnectOutcome<void, NotificationProblemCode>>;
+    unregisterNativeNotifications(options?: ConnectRequestOptions): Promise<ConnectOutcome<void, NotificationProblemCode>>;
+    unregisterNotifications(serviceWorker?: ServiceWorkerRegistration, options?: ConnectRequestOptions): Promise<ConnectOutcome<void, NotificationProblemCode>>;
     forget(): void;
-    describe(): Promise<ConnectOutcome<CollectionDescription, CollectionDescriptionProblemCode>>;
-    changes(input?: ChangesInput, options?: OperationRequestOptions): Promise<ConnectOutcome<CollectionChangesPage, CollectionChangesProblemCode>>;
-    read(input: ReadInput): Promise<ConnectOutcome<RecordDocument<Frontmatter>, CollectionReadProblemCode>>;
-    query(input?: QueryInput, options?: OperationRequestOptions): Promise<ConnectOutcome<QueryResult<Frontmatter>, CollectionQueryProblemCode>>;
+    describe(options?: ConnectRequestOptions): Promise<ConnectOutcome<CollectionDescription, CollectionDescriptionProblemCode>>;
+    changes(input?: ChangesInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<CollectionChangesPage, CollectionChangesProblemCode>>;
+    read(input: ReadInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<RecordDocument<Frontmatter>, CollectionReadProblemCode>>;
+    query(input?: QueryInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<QueryResult<Frontmatter>, CollectionQueryProblemCode>>;
     queryPages(input?: QueryInput, options?: QueryPagesOptions<Frontmatter>): AsyncGenerator<ConnectOutcome<QueryPage<Frontmatter>, CollectionQueryProblemCode>>;
     queryAll(input?: QueryInput, options?: QueryPagesOptions<Frontmatter>): Promise<ConnectOutcome<QueryResult<Frontmatter>, CollectionQueryProblemCode>>;
-    listViews(): Promise<ConnectOutcome<SavedViewList, CollectionReadProblemCode>>;
-    executeView(input: ExecuteViewInput): Promise<ConnectOutcome<SavedViewExecution<Frontmatter>, CollectionReadProblemCode>>;
-    readViewSource(input: ReadViewSourceInput): Promise<ConnectOutcome<SavedViewSourceDocument, CollectionReadProblemCode>>;
-    createViewSource(input: CreateViewSourceInput): Promise<ConnectOutcome<SavedViewSourceDocument, CollectionMutationProblemCode>>;
-    updateViewSource(input: UpdateViewSourceInput): Promise<ConnectOutcome<SavedViewSourceDocument, CollectionMutationProblemCode>>;
-    deleteViewSource(input: DeleteViewSourceInput): Promise<ConnectOutcome<DeleteViewSourceResult, CollectionMutationProblemCode>>;
-    create(input: CreateInput<Frontmatter>): Promise<ConnectOutcome<RecordDocument<Frontmatter>, CollectionMutationProblemCode>>;
-    update(input: UpdateInput<Frontmatter>): Promise<ConnectOutcome<RecordDocument<Frontmatter>, CollectionMutationProblemCode>>;
-    delete(input: DeleteInput, options?: OperationRequestOptions): Promise<ConnectOutcome<DeleteResult, CollectionMutationProblemCode>>;
-    preflightDelete(input: DeleteInput, options?: OperationRequestOptions): Promise<ConnectOutcome<DeletePreflightResult, CollectionMutationProblemCode>>;
-    rename(input: RenameInput, options?: OperationRequestOptions): Promise<ConnectOutcome<RenameResult, CollectionMutationProblemCode>>;
-    preflightRename(input: RenameInput, options?: OperationRequestOptions): Promise<ConnectOutcome<RenamePreflightResult, CollectionMutationProblemCode>>;
+    listViews(options?: ConnectRequestOptions): Promise<ConnectOutcome<SavedViewList, CollectionReadProblemCode>>;
+    executeView(input: ExecuteViewInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<SavedViewExecution<Frontmatter>, CollectionReadProblemCode>>;
+    readViewSource(input: ReadViewSourceInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<SavedViewSourceDocument, CollectionReadProblemCode>>;
+    createViewSource(input: CreateViewSourceInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<SavedViewSourceDocument, CollectionMutationProblemCode>>;
+    updateViewSource(input: UpdateViewSourceInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<SavedViewSourceDocument, CollectionMutationProblemCode>>;
+    deleteViewSource(input: DeleteViewSourceInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<DeleteViewSourceResult, CollectionMutationProblemCode>>;
+    create(input: CreateInput<Frontmatter>, options?: ConnectRequestOptions): Promise<ConnectOutcome<RecordDocument<Frontmatter>, CollectionMutationProblemCode>>;
+    update(input: UpdateInput<Frontmatter>, options?: ConnectRequestOptions): Promise<ConnectOutcome<RecordDocument<Frontmatter>, CollectionMutationProblemCode>>;
+    delete(input: DeleteInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<DeleteResult, CollectionMutationProblemCode>>;
+    preflightDelete(input: DeleteInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<DeletePreflightResult, CollectionMutationProblemCode>>;
+    rename(input: RenameInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<RenameResult, CollectionMutationProblemCode>>;
+    preflightRename(input: RenameInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<RenamePreflightResult, CollectionMutationProblemCode>>;
     renameWithProgress(input: RenameInput, options?: RenameProgressOptions): Promise<ConnectOutcome<RenameResult, CollectionMutationProblemCode>>;
     deleteWithProgress(input: DeleteInput, options?: DeleteProgressOptions): Promise<ConnectOutcome<DeleteResult, CollectionMutationProblemCode>>;
-    pendingMutation(): PendingMutationSummary | null;
-    resumePendingMutation<Result>(input: unknown, options?: OperationRequestOptions): Promise<ConnectOutcome<Result, CollectionMutationProblemCode>>;
-    validate(input?: JsonObject): Promise<ConnectOutcome<JsonObject, CollectionReadProblemCode>>;
-    readType(input: ReadTypeInput): Promise<ConnectOutcome<CollectionTypeDocument, CollectionTypeProblemCode>>;
-    createType(input: CreateTypeInput): Promise<ConnectOutcome<CollectionTypeDocument, CollectionTypeProblemCode>>;
-    updateType(input: UpdateTypeInput): Promise<ConnectOutcome<CollectionTypeDocument, CollectionTypeProblemCode>>;
-    assessTypePack(input: AssessTypePackInput): Promise<ConnectOutcome<TypePackAssessment, CollectionTypeProblemCode>>;
-    applyTypePack(input: ApplyTypePackInput): Promise<ConnectOutcome<TypePackApplyResult, CollectionTypeProblemCode>>;
-    listTimers(namespace: string): Promise<ConnectOutcome<MdbaseTimerList, CollectionReadProblemCode>>;
+    pendingMutations<Result = unknown>(): readonly PendingMutation<Result>[];
+    pendingMutation<Result = unknown>(requestId: string): PendingMutation<Result> | null;
+    private recoverPendingMutation;
+    validate(input?: JsonObject, options?: ConnectRequestOptions): Promise<ConnectOutcome<JsonObject, CollectionReadProblemCode>>;
+    readType(input: ReadTypeInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<CollectionTypeDocument, CollectionTypeProblemCode>>;
+    createType(input: CreateTypeInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<CollectionTypeDocument, CollectionTypeProblemCode>>;
+    updateType(input: UpdateTypeInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<CollectionTypeDocument, CollectionTypeProblemCode>>;
+    assessTypePack(input: AssessTypePackInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<TypePackAssessment, CollectionTypeProblemCode>>;
+    applyTypePack(input: ApplyTypePackInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<TypePackApplyResult, CollectionTypeProblemCode>>;
+    listTimers(namespace: string, options?: ConnectRequestOptions): Promise<ConnectOutcome<MdbaseTimerList, CollectionReadProblemCode>>;
     putTimer(input: {
         namespace: string;
         criterion_id: string;
         timer: MdbaseDesiredTimer;
-    }): Promise<ConnectOutcome<MdbaseTimer, CollectionMutationProblemCode>>;
+    }, options?: ConnectRequestOptions): Promise<ConnectOutcome<MdbaseTimer, CollectionMutationProblemCode>>;
     cancelTimer(input: {
         namespace: string;
         id: string;
         generation?: number;
-    }): Promise<ConnectOutcome<{
+    }, options?: ConnectRequestOptions): Promise<ConnectOutcome<{
         namespace: string;
         id: string;
         cancelled: boolean;
@@ -152,8 +152,8 @@ export declare class MdbaseConnection<Frontmatter extends JsonObject = JsonObjec
         namespace: string;
         criterion_id: string;
         timers: MdbaseDesiredTimer[];
-    }): Promise<ConnectOutcome<MdbaseTimerReconciliation, CollectionMutationProblemCode>>;
-    watch(options?: WatchOptions): AsyncGenerator<ConnectOutcome<CollectionChange, CollectionChangesProblemCode>>;
-    operation<Result>(operation: CollectionOperation, input: unknown, options?: OperationRequestOptions): Promise<ConnectOutcome<Result>>;
+    }, options?: ConnectRequestOptions): Promise<ConnectOutcome<MdbaseTimerReconciliation, CollectionMutationProblemCode>>;
+    watch(input?: WatchInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<MdbaseWatchSubscription, CollectionChangesProblemCode>>;
+    operation<Result>(operation: CollectionOperation, input: unknown, options?: ConnectRequestOptions): Promise<ConnectOutcome<Result>>;
     private emitConnection;
 }

package/dist/connection.js

@@ -1,11 +1,12 @@
 import { MdbaseCollectionClient } from "./collection-client.js";
 import { ConnectionNotifications } from "./connection-notifications.js";
 import { ConnectionTransport } from "./connection-transport.js";
-import { MdbaseConnectError } from "./errors.js";
+import { MdbaseConnectError, connectProblem, operationProblem } from "./errors.js";
 import { MdbaseFileClient } from "./files.js";
 import { DEFAULT_OPERATIONS } from "./internal-types.js";
 import { assertDeletePreview, assertRenamePreview, deleteEstimate, isCancellation, renameEstimate, throwIfCancelled, uniqueOperations } from "./operation-helpers.js";
-import { AUTHORIZATION_PROBLEM_CODES, COLLECTION_MUTATION_PROBLEM_CODES, DIRECT_ACCESS_PROBLEM_CODES, NOTIFICATION_PROBLEM_CODES, REGISTRATION_PROBLEM_CODES, captureConnectOutcome, connectFailure, connectSuccess } from "./outcomes.js";
+import { AUTHORIZATION_PROBLEM_CODES, COLLECTION_CHANGES_PROBLEM_CODES, COLLECTION_MUTATION_PROBLEM_CODES, DIRECT_ACCESS_PROBLEM_CODES, NOTIFICATION_PROBLEM_CODES, REGISTRATION_PROBLEM_CODES, captureConnectOutcome, connectFailure, connectSuccess } from "./outcomes.js";
+import { withRequestBudget } from "./request-budget.js";
 export class MdbaseConnection {
     internals;
     collectionId;
@@ -25,6 +26,7 @@ export class MdbaseConnection {
             loopbackUrl: internals.loopbackUrl,
             collectionId,
             internals,
+            timeouts: internals.timeouts,
             onChange: () => this.emitConnection()
         });
         this.files = new MdbaseFileClient(() => this.fileCapability, (method, path, input, signal) => this.transport.files.control(method, path, input, signal), {
@@ -32,16 +34,17 @@ export class MdbaseConnection {
             downloadChunk: (session, chunkIndex, signal) => this.transport.files.downloadChunk(session, chunkIndex, signal)
         }, {
             downloadPart: (session, partIndex, expectedLength, signal) => this.transport.files.downloadHostedPart(session, partIndex, expectedLength, signal)
-        });
+        }, internals.timeouts);
         this.collectionClient = new MdbaseCollectionClient({
             operation: (operation, input, requestOptions) => this.transport.performOperation(operation, input, requestOptions)
         });
         this.notifications = new ConnectionNotifications({
             serverUrl: internals.serverUrl,
             storage: internals.storage,
-            authorizedToken: () => this.transport.authorizedToken(),
-            register: () => this.internals.register(),
-            notificationKey: (transport) => internals.notificationKey(collectionId, transport)
+            authorizedToken: (signal) => this.transport.authorizedToken({ signal, timeoutMs: null }),
+            register: (signal) => this.internals.register({ signal, timeoutMs: null }),
+            notificationKey: (transport) => internals.notificationKey(collectionId, transport),
+            requestTimeoutMs: internals.timeouts.requestMs
         });
     }
     get displayName() {
@@ -63,8 +66,8 @@ export class MdbaseConnection {
     get route() {
         return this.transport.route;
     }
-    register() {
-        return captureConnectOutcome(() => this.internals.register(), REGISTRATION_PROBLEM_CODES);
+    register(options) {
+        return captureConnectOutcome(() => this.internals.register(options), REGISTRATION_PROBLEM_CODES);
     }
     info() {
         const token = this.transport.currentToken();
@@ -123,12 +126,12 @@ export class MdbaseConnection {
     notifyStorageChanged() {
         this.transport.notifyStorageChanged();
     }
-    checkDirectAccess() {
-        return captureConnectOutcome(() => this.transport.checkDirectAccess(), DIRECT_ACCESS_PROBLEM_CODES);
+    checkDirectAccess(options) {
+        return captureConnectOutcome(() => this.transport.checkDirectAccess(options), DIRECT_ACCESS_PROBLEM_CODES);
     }
     /** Call from a user gesture to request browser permission for direct local access. */
-    requestDirectAccess() {
-        return captureConnectOutcome(() => this.transport.requestDirectAccess(), DIRECT_ACCESS_PROBLEM_CODES);
+    requestDirectAccess(options) {
+        return captureConnectOutcome(() => this.transport.requestDirectAccess(options), DIRECT_ACCESS_PROBLEM_CODES);
     }
     disableDirectAccess() {
         this.transport.disableDirectAccess();
@@ -151,21 +154,21 @@ export class MdbaseConnection {
                 collectionId,
                 replicaId,
                 transport: {
-                    openSession: () => this.transport.performOperation("sync", { action: "open_session" }),
-                    snapshot: (snapshotId, page) => this.transport.performOperation("sync", {
+                    openSession: (options) => this.transport.performOperation("sync", { action: "open_session" }, syncRequestOptions(options, this.internals.timeouts.syncMs)),
+                    snapshot: (snapshotId, page, options) => this.transport.performOperation("sync", {
                         action: "snapshot",
                         snapshot_id: snapshotId,
                         ...(page ? { page } : {})
-                    }),
-                    changes: (after, limit = 200) => this.transport.performOperation("sync", {
+                    }, syncRequestOptions(options, this.internals.timeouts.syncMs)),
+                    changes: (after, limit = 200, options) => this.transport.performOperation("sync", {
                         action: "changes",
                         after,
                         limit
-                    }),
-                    mutate: (mutation) => this.transport.performOperation("sync", {
+                    }, syncRequestOptions(options, this.internals.timeouts.syncMs)),
+                    mutate: (mutation, options) => this.transport.performOperation("sync", {
                         action: "mutate",
                         mutation
-                    })
+                    }, syncRequestOptions(options, this.internals.timeouts.syncMs))
                 }
             };
         }
@@ -174,15 +177,15 @@ export class MdbaseConnection {
             collectionId,
             replicaId,
             transport: {
-                openSession: () => this.transport.performAuthoritySyncRequest(collectionId, replicaId, "POST", "sessions"),
-                snapshot: (snapshotId, page) => {
+                openSession: (options) => this.transport.performAuthoritySyncRequest(collectionId, replicaId, "POST", "sessions", undefined, options),
+                snapshot: (snapshotId, page, options) => {
                     const query = new URLSearchParams({ snapshot_id: snapshotId });
                     if (page)
                         query.set("page", page);
-                    return this.transport.performAuthoritySyncRequest(collectionId, replicaId, "GET", `snapshot?${query}`);
+                    return this.transport.performAuthoritySyncRequest(collectionId, replicaId, "GET", `snapshot?${query}`, undefined, options);
                 },
-                changes: (after, limit = 200) => this.transport.performAuthoritySyncRequest(collectionId, replicaId, "GET", `changes?${new URLSearchParams({ after: String(after), limit: String(limit) })}`),
-                mutate: (mutation) => this.transport.performAuthoritySyncRequest(collectionId, replicaId, "POST", "mutations", mutation)
+                changes: (after, limit = 200, options) => this.transport.performAuthoritySyncRequest(collectionId, replicaId, "GET", `changes?${new URLSearchParams({ after: String(after), limit: String(limit) })}`, undefined, options),
+                mutate: (mutation, options) => this.transport.performAuthoritySyncRequest(collectionId, replicaId, "POST", "mutations", mutation, options)
             }
         };
     }
@@ -198,25 +201,25 @@ export class MdbaseConnection {
     registerNativeNotifications(options) {
         return captureConnectOutcome(() => this.notifications.registerNativeNotifications(options), NOTIFICATION_PROBLEM_CODES);
     }
-    unregisterNativeNotifications() {
-        return captureConnectOutcome(() => this.notifications.unregisterNativeNotifications(), NOTIFICATION_PROBLEM_CODES);
+    unregisterNativeNotifications(options) {
+        return captureConnectOutcome(() => this.notifications.unregisterNativeNotifications(options), NOTIFICATION_PROBLEM_CODES);
     }
-    unregisterNotifications(serviceWorker) {
-        return captureConnectOutcome(() => this.notifications.unregisterNotifications(serviceWorker), NOTIFICATION_PROBLEM_CODES);
+    unregisterNotifications(serviceWorker, options) {
+        return captureConnectOutcome(() => this.notifications.unregisterNotifications(serviceWorker, options), NOTIFICATION_PROBLEM_CODES);
     }
     forget() {
         const token = this.transport.currentToken();
-        this.internals.removeToken(this.collectionId, token?.keyHandle, "not_authorized");
+        this.internals.removeToken(this.collectionId, token?.keyHandle, "not_authorized", true);
         this.transport.notifyStorageChanged();
     }
-    describe() {
-        return this.collectionClient.describe();
+    describe(options) {
+        return this.collectionClient.describe(options);
     }
     changes(input = {}, options) {
         return this.collectionClient.changes(input, options);
     }
-    read(input) {
-        return this.collectionClient.read(input);
+    read(input, options) {
+        return this.collectionClient.read(input, options);
     }
     query(input = {}, options) {
         return this.collectionClient.query(input, options);
@@ -227,29 +230,29 @@ export class MdbaseConnection {
     queryAll(input = {}, options = {}) {
         return this.collectionClient.queryAll(input, options);
     }
-    listViews() {
-        return this.collectionClient.listViews();
+    listViews(options) {
+        return this.collectionClient.listViews(options);
     }
-    executeView(input) {
-        return this.collectionClient.executeView(input);
+    executeView(input, options) {
+        return this.collectionClient.executeView(input, options);
     }
-    readViewSource(input) {
-        return this.collectionClient.readViewSource(input);
+    readViewSource(input, options) {
+        return this.collectionClient.readViewSource(input, options);
     }
-    createViewSource(input) {
-        return this.collectionClient.createViewSource(input);
+    createViewSource(input, options) {
+        return this.collectionClient.createViewSource(input, options);
     }
-    updateViewSource(input) {
-        return this.collectionClient.updateViewSource(input);
+    updateViewSource(input, options) {
+        return this.collectionClient.updateViewSource(input, options);
     }
-    deleteViewSource(input) {
-        return this.collectionClient.deleteViewSource(input);
+    deleteViewSource(input, options) {
+        return this.collectionClient.deleteViewSource(input, options);
     }
-    create(input) {
-        return this.collectionClient.create(input);
+    create(input, options) {
+        return this.collectionClient.create(input, options);
     }
-    update(input) {
-        return this.collectionClient.update(input);
+    update(input, options) {
+        return this.collectionClient.update(input, options);
     }
     delete(input, options) {
         return this.collectionClient.delete(input, options);
@@ -265,7 +268,7 @@ export class MdbaseConnection {
     }
     async renameWithProgress(input, options = {}) {
         const started = Date.now();
-        const resumed = this.pendingMutation()?.operation === "rename";
+        const resumed = false;
         let estimate;
         const emit = (state, cancellable, completedUnits = 0) => {
             options.onProgress?.({
@@ -317,7 +320,7 @@ export class MdbaseConnection {
     }
     async deleteWithProgress(input, options = {}) {
         const started = Date.now();
-        const resumed = this.pendingMutation()?.operation === "delete";
+        const resumed = false;
         let estimate;
         const emit = (state, cancellable, completedUnits = 0) => {
             options.onProgress?.({
@@ -367,44 +370,71 @@ export class MdbaseConnection {
             throw error;
         }
     }
-    pendingMutation() {
-        return this.transport.pendingMutation();
+    pendingMutations() {
+        return this.transport.pendingMutations().map((summary) => ({
+            ...summary,
+            recover: (options) => captureConnectOutcome(() => this.recoverPendingMutation(summary.requestId, options), COLLECTION_MUTATION_PROBLEM_CODES)
+        }));
     }
-    resumePendingMutation(input, options) {
-        return captureConnectOutcome(() => this.transport.resumePendingMutation(input, options), COLLECTION_MUTATION_PROBLEM_CODES);
+    pendingMutation(requestId) {
+        const summary = this.transport.pendingMutation(requestId);
+        if (!summary)
+            return null;
+        return {
+            ...summary,
+            recover: (options) => captureConnectOutcome(() => this.recoverPendingMutation(requestId, options), COLLECTION_MUTATION_PROBLEM_CODES)
+        };
     }
-    validate(input = {}) {
-        return this.collectionClient.validate(input);
+    async recoverPendingMutation(requestId, options) {
+        const result = await this.transport.recoverPendingMutation(requestId, options);
+        if (result && typeof result === "object" && "valid" in result) {
+            const envelope = result;
+            if (!envelope.valid)
+                throw new MdbaseConnectError(operationProblem(envelope));
+            return envelope.result;
+        }
+        return result;
+    }
+    validate(input = {}, options) {
+        return this.collectionClient.validate(input, options);
     }
-    readType(input) {
-        return this.collectionClient.readType(input);
+    readType(input, options) {
+        return this.collectionClient.readType(input, options);
     }
-    createType(input) {
-        return this.collectionClient.createType(input);
+    createType(input, options) {
+        return this.collectionClient.createType(input, options);
     }
-    updateType(input) {
-        return this.collectionClient.updateType(input);
+    updateType(input, options) {
+        return this.collectionClient.updateType(input, options);
     }
-    assessTypePack(input) {
-        return this.collectionClient.assessTypePack(input);
+    assessTypePack(input, options) {
+        return this.collectionClient.assessTypePack(input, options);
     }
-    applyTypePack(input) {
-        return this.collectionClient.applyTypePack(input);
+    applyTypePack(input, options) {
+        return this.collectionClient.applyTypePack(input, options);
     }
-    listTimers(namespace) {
-        return this.collectionClient.listTimers(namespace);
+    listTimers(namespace, options) {
+        return this.collectionClient.listTimers(namespace, options);
     }
-    putTimer(input) {
-        return this.collectionClient.putTimer(input);
+    putTimer(input, options) {
+        return this.collectionClient.putTimer(input, options);
     }
-    cancelTimer(input) {
-        return this.collectionClient.cancelTimer(input);
+    cancelTimer(input, options) {
+        return this.collectionClient.cancelTimer(input, options);
     }
-    reconcileTimers(input) {
-        return this.collectionClient.reconcileTimers(input);
+    reconcileTimers(input, options) {
+        return this.collectionClient.reconcileTimers(input, options);
     }
-    watch(options = {}) {
-        return this.collectionClient.watch(options);
+    watch(input = {}, options = {}) {
+        return captureConnectOutcome(() => withRequestBudget(options, this.internals.timeouts.watchStartMs, async (budget) => {
+            const initial = await this.collectionClient.changes(input.cursor === undefined ? {} : { after: input.cursor, limit: 200 }, { signal: budget.signal, timeoutMs: null });
+            if (!initial.ok)
+                throw new MdbaseConnectError(initial.problem);
+            if (initial.value.reset) {
+                throw new MdbaseConnectError(connectProblem("change_cursor_reset", "The collection change cursor expired. Refresh collection state before subscribing again."));
+            }
+            return new CollectionWatchSubscription(this.collectionClient, initial.value.cursor, input, input.cursor === undefined ? [] : initial.value.events, this.internals.timeouts.watchStartMs);
+        }), COLLECTION_CHANGES_PROBLEM_CODES);
     }
     operation(operation, input, options) {
         return this.collectionClient.operation(operation, input, options);
@@ -415,3 +445,117 @@ export class MdbaseConnection {
             listener(connection);
     }
 }
+class CollectionWatchSubscription {
+    client;
+    input;
+    watchStartTimeoutMs;
+    changes = new Set();
+    statuses = new Set();
+    problems = new Set();
+    controller = new AbortController();
+    removeLifetimeAbort;
+    currentStatus;
+    currentProblem = null;
+    pendingChanges;
+    constructor(client, cursor, input, pendingChanges, watchStartTimeoutMs) {
+        this.client = client;
+        this.input = input;
+        this.watchStartTimeoutMs = watchStartTimeoutMs;
+        this.pendingChanges = [...pendingChanges];
+        this.currentStatus = { state: "connected", cursor, recovered: false };
+        const lifetimeSignal = input.lifetimeSignal;
+        if (lifetimeSignal?.aborted)
+            this.close();
+        else if (lifetimeSignal) {
+            const close = () => this.close();
+            lifetimeSignal.addEventListener("abort", close, { once: true });
+            this.removeLifetimeAbort = () => lifetimeSignal.removeEventListener("abort", close);
+        }
+        if (!this.controller.signal.aborted)
+            void this.run(cursor);
+    }
+    get status() {
+        return this.currentStatus;
+    }
+    get problem() {
+        return this.currentProblem;
+    }
+    subscribe(listener, onStatus, onProblem) {
+        this.changes.add(listener);
+        if (onStatus) {
+            this.statuses.add(onStatus);
+            onStatus(this.currentStatus);
+        }
+        if (onProblem) {
+            this.problems.add(onProblem);
+            if (this.currentProblem)
+                onProblem(this.currentProblem);
+        }
+        for (const change of this.pendingChanges)
+            listener(change);
+        this.pendingChanges = [];
+        return () => {
+            this.changes.delete(listener);
+            if (onStatus)
+                this.statuses.delete(onStatus);
+            if (onProblem)
+                this.problems.delete(onProblem);
+        };
+    }
+    close() {
+        if (this.controller.signal.aborted)
+            return;
+        this.controller.abort();
+        this.removeLifetimeAbort?.();
+        this.removeLifetimeAbort = undefined;
+        const cursor = "cursor" in this.currentStatus ? this.currentStatus.cursor : undefined;
+        this.publishStatus({ state: "closed", ...(cursor === undefined ? {} : { cursor }) });
+    }
+    async run(cursor) {
+        let firstStatus = true;
+        const iterator = this.client.watch({
+            cursor,
+            pollIntervalMs: this.input.pollIntervalMs,
+            retry: this.input.retry,
+            signal: this.controller.signal,
+            timeoutMs: this.watchStartTimeoutMs,
+            onStatus: (status) => {
+                if (firstStatus && status.state === "connecting") {
+                    firstStatus = false;
+                    return;
+                }
+                firstStatus = false;
+                this.publishStatus(status);
+            }
+        });
+        try {
+            for await (const outcome of iterator) {
+                if (this.controller.signal.aborted)
+                    return;
+                if (!outcome.ok) {
+                    this.currentProblem = outcome.problem;
+                    for (const listener of this.problems)
+                        listener(outcome.problem);
+                    return;
+                }
+                for (const listener of this.changes)
+                    listener(outcome.value);
+            }
+        }
+        finally {
+            if (!this.controller.signal.aborted)
+                this.close();
+        }
+    }
+    publishStatus(status) {
+        this.currentStatus = status;
+        for (const listener of this.statuses)
+            listener(status);
+    }
+}
+function syncRequestOptions(options, defaultTimeoutMs) {
+    return {
+        ...options,
+        timeoutMs: options?.timeoutMs === undefined ? defaultTimeoutMs : options.timeoutMs
+    };
+}

package/dist/crypto-entry.d.ts

@@ -0,0 +1,4 @@
+/** Opt-in cryptographic storage and transport primitives. */
+export * from "./crypto.js";
+export * from "./file-crypto.js";
+export * from "./application-identity.js";

package/dist/crypto-entry.js

@@ -0,0 +1,4 @@
+/** Opt-in cryptographic storage and transport primitives. */
+export * from "./crypto.js";
+export * from "./file-crypto.js";
+export * from "./application-identity.js";