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

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 { withCooperativeRequestBudget, 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)
-        });
+        }, internals.timeouts.requestMs);
         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);
@@ -264,150 +267,188 @@ export class MdbaseConnection {
         return this.collectionClient.preflightRename(input, options);
     }
     async renameWithProgress(input, options = {}) {
-        const started = Date.now();
-        const resumed = this.pendingMutation()?.operation === "rename";
-        let estimate;
-        const emit = (state, cancellable, completedUnits = 0) => {
-            options.onProgress?.({
-                operation: "rename",
-                state,
-                elapsedMs: Date.now() - started,
-                cancellable,
-                resumed,
-                completedUnits,
-                ...(estimate ? { estimate } : {})
-            });
-        };
-        try {
-            throwIfCancelled(options.signal);
-            emit("preflighting", true);
-            const previewOutcome = options.preflight
-                ? connectSuccess(options.preflight)
-                : await this.preflightRename(input, { signal: options.signal });
-            if (!previewOutcome.ok)
-                return previewOutcome;
-            const preview = previewOutcome.value;
+        return withCooperativeRequestBudget(options, this.internals.timeouts.requestMs, async (budget) => {
+            const started = Date.now();
+            const resumed = false;
+            let estimate;
+            const emit = (state, cancellable, completedUnits = 0) => {
+                options.onProgress?.({
+                    operation: "rename",
+                    state,
+                    elapsedMs: Date.now() - started,
+                    cancellable,
+                    resumed,
+                    completedUnits,
+                    ...(estimate ? { estimate } : {})
+                });
+            };
             try {
-                assertRenamePreview(input, preview);
+                throwIfCancelled(budget.signal);
+                emit("preflighting", true);
+                const previewOutcome = options.preflight
+                    ? connectSuccess(options.preflight)
+                    : await this.preflightRename(input, { signal: budget.signal, timeoutMs: null });
+                if (!previewOutcome.ok)
+                    return previewOutcome;
+                const preview = previewOutcome.value;
+                try {
+                    assertRenamePreview(input, preview);
+                }
+                catch (error) {
+                    if (error instanceof MdbaseConnectError) {
+                        return connectFailure(error.problem);
+                    }
+                    throw error;
+                }
+                estimate = renameEstimate(input, preview);
+                emit("ready", true);
+                throwIfCancelled(budget.signal);
+                const cancellable = this.transport.hasResumableMutationTransport();
+                emit("applying", cancellable);
+                const result = await this.rename(input, cancellable
+                    ? { signal: budget.signal, timeoutMs: null }
+                    : { timeoutMs: remainingTimeout(budget.remainingMs()) });
+                if (result.ok)
+                    emit("completed", false, estimate.totalUnits);
+                return result;
             }
             catch (error) {
+                if (isCancellation(error, budget.signal))
+                    emit("cancelled", false);
                 if (error instanceof MdbaseConnectError) {
                     return connectFailure(error.problem);
                 }
                 throw error;
             }
-            estimate = renameEstimate(input, preview);
-            emit("ready", true);
-            throwIfCancelled(options.signal);
-            const cancellable = this.transport.hasResumableMutationTransport();
-            emit("applying", cancellable);
-            const result = await this.rename(input, cancellable ? { signal: options.signal } : undefined);
-            if (result.ok)
-                emit("completed", false, estimate.totalUnits);
-            return result;
-        }
-        catch (error) {
-            if (isCancellation(error, options.signal))
-                emit("cancelled", false);
-            if (error instanceof MdbaseConnectError) {
-                return connectFailure(error.problem);
-            }
-            throw error;
-        }
+        });
     }
     async deleteWithProgress(input, options = {}) {
-        const started = Date.now();
-        const resumed = this.pendingMutation()?.operation === "delete";
-        let estimate;
-        const emit = (state, cancellable, completedUnits = 0) => {
-            options.onProgress?.({
-                operation: "delete",
-                state,
-                elapsedMs: Date.now() - started,
-                cancellable,
-                resumed,
-                completedUnits,
-                ...(estimate ? { estimate } : {})
-            });
-        };
-        try {
-            throwIfCancelled(options.signal);
-            emit("preflighting", true);
-            const previewOutcome = options.preflight
-                ? connectSuccess(options.preflight)
-                : await this.preflightDelete(input, { signal: options.signal });
-            if (!previewOutcome.ok)
-                return previewOutcome;
-            const preview = previewOutcome.value;
+        return withCooperativeRequestBudget(options, this.internals.timeouts.requestMs, async (budget) => {
+            const started = Date.now();
+            const resumed = false;
+            let estimate;
+            const emit = (state, cancellable, completedUnits = 0) => {
+                options.onProgress?.({
+                    operation: "delete",
+                    state,
+                    elapsedMs: Date.now() - started,
+                    cancellable,
+                    resumed,
+                    completedUnits,
+                    ...(estimate ? { estimate } : {})
+                });
+            };
             try {
-                assertDeletePreview(input, preview);
+                throwIfCancelled(budget.signal);
+                emit("preflighting", true);
+                const previewOutcome = options.preflight
+                    ? connectSuccess(options.preflight)
+                    : await this.preflightDelete(input, { signal: budget.signal, timeoutMs: null });
+                if (!previewOutcome.ok)
+                    return previewOutcome;
+                const preview = previewOutcome.value;
+                try {
+                    assertDeletePreview(input, preview);
+                }
+                catch (error) {
+                    if (error instanceof MdbaseConnectError) {
+                        return connectFailure(error.problem);
+                    }
+                    throw error;
+                }
+                estimate = deleteEstimate(preview);
+                emit("ready", true);
+                throwIfCancelled(budget.signal);
+                const cancellable = this.transport.hasResumableMutationTransport();
+                emit("applying", cancellable);
+                const result = await this.delete(input, cancellable
+                    ? { signal: budget.signal, timeoutMs: null }
+                    : { timeoutMs: remainingTimeout(budget.remainingMs()) });
+                if (result.ok)
+                    emit("completed", false, estimate.totalUnits);
+                return result;
             }
             catch (error) {
+                if (isCancellation(error, budget.signal))
+                    emit("cancelled", false);
                 if (error instanceof MdbaseConnectError) {
                     return connectFailure(error.problem);
                 }
                 throw error;
             }
-            estimate = deleteEstimate(preview);
-            emit("ready", true);
-            throwIfCancelled(options.signal);
-            const cancellable = this.transport.hasResumableMutationTransport();
-            emit("applying", cancellable);
-            const result = await this.delete(input, cancellable ? { signal: options.signal } : undefined);
-            if (result.ok)
-                emit("completed", false, estimate.totalUnits);
-            return result;
-        }
-        catch (error) {
-            if (isCancellation(error, options.signal))
-                emit("cancelled", false);
-            if (error instanceof MdbaseConnectError) {
-                return connectFailure(error.problem);
-            }
-            throw error;
-        }
+        });
+    }
+    pendingMutations() {
+        return this.transport.pendingMutations().map((summary) => ({
+            ...summary,
+            recover: (options) => captureConnectOutcome(() => this.recoverPendingMutation(summary.requestId, 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)
+        };
     }
-    pendingMutation() {
-        return this.transport.pendingMutation();
+    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;
     }
-    resumePendingMutation(input, options) {
-        return captureConnectOutcome(() => this.transport.resumePendingMutation(input, options), COLLECTION_MUTATION_PROBLEM_CODES);
+    validate(input = {}, options) {
+        return this.collectionClient.validate(input, options);
     }
-    validate(input = {}) {
-        return this.collectionClient.validate(input);
+    readType(input, options) {
+        return this.collectionClient.readType(input, options);
     }
-    readType(input) {
-        return this.collectionClient.readType(input);
+    createType(input, options) {
+        return this.collectionClient.createType(input, options);
     }
-    createType(input) {
-        return this.collectionClient.createType(input);
+    updateType(input, options) {
+        return this.collectionClient.updateType(input, options);
     }
-    updateType(input) {
-        return this.collectionClient.updateType(input);
+    assessTypePack(input, options) {
+        return this.collectionClient.assessTypePack(input, options);
     }
-    assessTypePack(input) {
-        return this.collectionClient.assessTypePack(input);
+    applyTypePack(input, options) {
+        return this.collectionClient.applyTypePack(input, options);
     }
-    applyTypePack(input) {
-        return this.collectionClient.applyTypePack(input);
+    assessCollectionSetup(input, options) {
+        return this.collectionClient.assessCollectionSetup(input, options);
     }
-    listTimers(namespace) {
-        return this.collectionClient.listTimers(namespace);
+    applyCollectionSetup(input, options) {
+        return this.collectionClient.applyCollectionSetup(input, options);
     }
-    putTimer(input) {
-        return this.collectionClient.putTimer(input);
+    listTimers(namespace, options) {
+        return this.collectionClient.listTimers(namespace, options);
     }
-    cancelTimer(input) {
-        return this.collectionClient.cancelTimer(input);
+    putTimer(input, options) {
+        return this.collectionClient.putTimer(input, options);
     }
-    reconcileTimers(input) {
-        return this.collectionClient.reconcileTimers(input);
+    cancelTimer(input, options) {
+        return this.collectionClient.cancelTimer(input, options);
     }
-    watch(options = {}) {
-        return this.collectionClient.watch(options);
+    reconcileTimers(input, options) {
+        return this.collectionClient.reconcileTimers(input, options);
     }
-    operation(operation, input, options) {
-        return this.collectionClient.operation(operation, input, 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);
     }
     emitConnection() {
         const connection = this.info();
@@ -415,3 +456,120 @@ 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
+    };
+}
+function remainingTimeout(remainingMs) {
+    return remainingMs === null ? null : Math.max(1, Math.ceil(remainingMs));
+}

package/dist/crypto-entry.d.ts

@@ -0,0 +1,7 @@
+/** Opt-in cryptographic storage and transport primitives. */
+export { IndexedDbGrantKeyStore, MemoryGrantKeyStore, RelayCryptoError, signAuthorityRequest, authorityProofMessage, encryptRelayRequest, decryptRelayResponse, deriveP256SharedSecret, validateGrantEncryption } from "./crypto.js";
+export type { GrantKeyRecord, GrantKeyStore, RelayBinding, AuthorityProofInput } from "./crypto.js";
+export { FileTransferCryptoError, GrantFileTransferCipher, deriveFileTransferKey } from "./file-crypto.js";
+export type { FileTransferBinding } from "./file-crypto.js";
+export { IndexedDbApplicationIdentityStore, MemoryApplicationIdentityStore, ApplicationIdentityStoreError, applicationInstallationId, signApplicationAuthorization, applicationIdentity } from "./application-identity.js";
+export type { ApplicationIdentity, ApplicationIdentityStore } from "./application-identity.js";

package/dist/crypto-entry.js

@@ -0,0 +1,4 @@
+/** Opt-in cryptographic storage and transport primitives. */
+export { IndexedDbGrantKeyStore, MemoryGrantKeyStore, RelayCryptoError, signAuthorityRequest, authorityProofMessage, encryptRelayRequest, decryptRelayResponse, deriveP256SharedSecret, validateGrantEncryption } from "./crypto.js";
+export { FileTransferCryptoError, GrantFileTransferCipher, deriveFileTransferKey } from "./file-crypto.js";
+export { IndexedDbApplicationIdentityStore, MemoryApplicationIdentityStore, ApplicationIdentityStoreError, applicationInstallationId, signApplicationAuthorization, applicationIdentity } from "./application-identity.js";