@mdbase-dev/connect 0.1.0-beta.21 → 0.1.0-beta.23

package/dist/connect.js

@@ -3,21 +3,22 @@ import { abortableDelay } from "./async.js";
 import { randomBase64Url } from "./base64.js";
 import { MdbaseConnection } from "./connection.js";
 import { IndexedDbGrantKeyStore, MemoryGrantKeyStore, validateGrantEncryption } from "./crypto.js";
-import { MdbaseConnectError } from "./errors.js";
+import { connectError, serverConnectError } from "./errors.js";
 import { DEFAULT_OPERATIONS } from "./internal-types.js";
 import { uniqueOperations } from "./operation-helpers.js";
+import { AUTHORIZATION_PROBLEM_CODES, REGISTRATION_PROBLEM_CODES, captureConnectOutcome } from "./outcomes.js";
 import { MdbaseSession } from "./session.js";
-import { MemoryStorage, apiError, canonicalLoopbackUrl, createPkce, defaultCallbackUrl, defaultManifestSource, defaultRedirectUri, defaultStorage, isOpaquePortableManifest, manifestStorageFingerprint, oauthErrorCode, parseDeviceAuthorization, parseGrantScope, parseStored, stripTrailingSlash, validAuthorityTokenResponse } from "./runtime-utils.js";
+import { MemoryStorage, apiError, canonicalLoopbackUrl, connectFetch, createPkce, defaultCallbackUrl, defaultManifestSource, defaultRedirectUri, defaultStorage, isOpaquePortableManifest, manifestStorageFingerprint, oauthErrorCode, parseDeviceAuthorization, parseGrantScope, parseStored, stripTrailingSlash, validFileCapability, validAuthorityTokenResponse } from "./runtime-utils.js";
 export class MdbaseConnect {
     internals;
     constructor(options) {
         this.internals = new MdbaseConnectInternals(options);
     }
     register() {
-        return this.internals.register();
+        return captureConnectOutcome(() => this.internals.register(), REGISTRATION_PROBLEM_CODES);
     }
     authorize(options = {}) {
-        return this.internals.authorize(options);
+        return captureConnectOutcome(() => this.internals.authorize(options), AUTHORIZATION_PROBLEM_CODES);
     }
     createSession(options) {
         return new MdbaseSession(this, options);
@@ -25,8 +26,8 @@ export class MdbaseConnect {
     environment() {
         return this.internals.environment();
     }
-    completeAuthorization(callbackUrl = defaultCallbackUrl()) {
-        return this.internals.completeAuthorization(callbackUrl);
+    completeAuthorization(callbackUrl) {
+        return captureConnectOutcome(() => this.internals.completeAuthorization(callbackUrl ?? defaultCallbackUrl()), AUTHORIZATION_PROBLEM_CODES);
     }
     connections() {
         return this.internals.connections();
@@ -109,11 +110,11 @@ class MdbaseConnectInternals {
     async register() {
         if (this.application)
             return this.application;
-        const response = await fetch(`${this.serverUrl}/v1/apps/register`, {
+        const response = await connectFetch(`${this.serverUrl}/v1/apps/register`, {
             method: "POST",
             headers: { "content-type": "application/json" },
             body: JSON.stringify({ manifest: await this.loadManifest() })
-        });
+        }, "temporarily_unavailable", "Application registration is temporarily unavailable.");
         const body = await response.json();
         if (!response.ok)
             throw apiError(body, "discovery_failed", "Application discovery failed.", response.status);
@@ -131,21 +132,21 @@ class MdbaseConnectInternals {
             });
         }
         catch (cause) {
-            throw new MdbaseConnectError("manifest_load_failed", "The bundled application declaration could not be loaded.", { cause });
+            throw connectError("manifest_load_failed", "The bundled application declaration could not be loaded.", { cause });
         }
         if (!response.ok) {
-            throw new MdbaseConnectError("manifest_load_failed", `The bundled application declaration returned HTTP ${response.status}.`, { status: response.status });
+            throw connectError("manifest_load_failed", `The bundled application declaration returned HTTP ${response.status}.`, { status: response.status });
         }
         try {
             return await response.json();
         }
         catch (cause) {
-            throw new MdbaseConnectError("invalid_application_manifest", "The bundled application declaration is not valid JSON.", { cause });
+            throw connectError("invalid_application_manifest", "The bundled application declaration is not valid JSON.", { cause });
         }
     }
     async authorize(options = {}) {
         if (typeof location === "undefined" && !this.navigate && !options.openVerification) {
-            throw new MdbaseConnectError("browser_required", "Authorization navigation requires a browser environment.");
+            throw connectError("browser_required", "Authorization navigation requires a browser environment.");
         }
         const portableDeclared = typeof this.manifest !== "string"
             && this.manifest.distribution === "portable";
@@ -213,7 +214,7 @@ class MdbaseConnectInternals {
     async authorizePortable(application, options, popup) {
         if (this.relayEncryption !== "required") {
             popup?.close();
-            throw new MdbaseConnectError("encryption_required", "Downloaded applications require encrypted relay authorization.");
+            throw connectError("encryption_required", "Downloaded applications require encrypted relay authorization.");
         }
         const { verifier, challenge } = await createPkce();
         const keyHandle = `grant:${application.id}:${randomBase64Url(24)}`;
@@ -242,7 +243,7 @@ class MdbaseConnectInternals {
         catch (cause) {
             popup?.close();
             await this.keyStore.delete(keyHandle);
-            throw new MdbaseConnectError("device_authorization_failed", "Downloaded application authorization could not be started.", { cause });
+            throw connectError("device_authorization_failed", "Downloaded application authorization could not be started.", { cause });
         }
         if (!response.ok) {
             popup?.close();
@@ -272,14 +273,22 @@ class MdbaseConnectInternals {
         }
         else {
             await this.keyStore.delete(keyHandle);
-            throw new MdbaseConnectError("approval_window_blocked", "The approval window was blocked. Show the provided verification link and code, then try again.", { details: authorization });
+            throw connectError("approval_window_blocked", "The approval window was blocked. Show the provided verification link and code, then try again.", {
+                details: {
+                    user_code: authorization.userCode,
+                    verification_uri: authorization.verificationUri,
+                    verification_uri_complete: authorization.verificationUriComplete,
+                    expires_at: authorization.expiresAt,
+                    interval_seconds: authorization.intervalSeconds
+                }
+            });
         }
         let intervalSeconds = authorization.intervalSeconds;
         try {
             while (Date.now() < authorization.expiresAt) {
                 await abortableDelay(intervalSeconds * 1_000, options.signal);
                 if (options.signal?.aborted) {
-                    throw new MdbaseConnectError("authorization_cancelled", "Downloaded application authorization was cancelled.");
+                    throw connectError("authorization_cancelled", "Downloaded application authorization was cancelled.");
                 }
                 let tokenResponse;
                 try {
@@ -297,7 +306,7 @@ class MdbaseConnectInternals {
                 }
                 catch (cause) {
                     if (options.signal?.aborted) {
-                        throw new MdbaseConnectError("authorization_cancelled", "Downloaded application authorization was cancelled.", { cause });
+                        throw connectError("authorization_cancelled", "Downloaded application authorization was cancelled.", { cause });
                     }
                     continue;
                 }
@@ -319,22 +328,22 @@ class MdbaseConnectInternals {
                     && tokenBody.encryption.application_agreement_public_key
                         === grantKey.agreementPublicKey;
                 if (tokenBody.application_origin !== "null") {
-                    throw new MdbaseConnectError("invalid_token_response", "Authorization did not bind the portable grant to its opaque application origin.");
+                    throw connectError("invalid_token_response", "Authorization did not bind the portable grant to its opaque application origin.");
                 }
                 if (tokenBody.authority
                     && (!authority
                         || tokenBody.encryption != null
                         || tokenBody.authority.proof_public_key !== grantKey.signingPublicKey)) {
-                    throw new MdbaseConnectError("invalid_token_response", "Authorization returned a remote authority capability that is not bound to this portable grant key.");
+                    throw connectError("invalid_token_response", "Authorization returned a remote authority capability that is not bound to this portable grant key.");
                 }
                 if (!tokenBody.authority && !localEncryption) {
-                    throw new MdbaseConnectError("encryption_required", "Authorization did not establish the expected key-bound local portable grant.");
+                    throw connectError("encryption_required", "Authorization did not establish the expected key-bound local portable grant.");
                 }
                 const token = this.storeTokenResponse(tokenBody, application.id, keyHandle);
                 if (options.target?.kind === "collection"
                     && options.target.collectionId !== token.collectionId) {
                     this.removeToken(token.collectionId, token.keyHandle);
-                    throw new MdbaseConnectError("collection_mismatch", "The approved collection does not match the collection requested by this link.");
+                    throw connectError("collection_mismatch", "The approved collection does not match the collection requested by this link.");
                 }
                 popup?.close();
                 return {
@@ -343,7 +352,7 @@ class MdbaseConnectInternals {
                     ...(options.returnTo ? { returnTo: options.returnTo } : {})
                 };
             }
-            throw new MdbaseConnectError("expired_token", "The downloaded application authorization code expired.");
+            throw connectError("expired_token", "The downloaded application authorization code expired.");
         }
         catch (error) {
             popup?.close();
@@ -354,7 +363,7 @@ class MdbaseConnectInternals {
     completeAuthorization(callbackUrl) {
         const state = new URL(callbackUrl).searchParams.get("state");
         if (!state) {
-            return Promise.reject(new MdbaseConnectError("invalid_callback", "Authorization callback is missing its state."));
+            return Promise.reject(connectError("invalid_callback", "Authorization callback is missing its state."));
         }
         const existing = this.completionPromises.get(state);
         if (existing)
@@ -373,18 +382,18 @@ class MdbaseConnectInternals {
         const pendingKey = this.pendingKey(state);
         const pending = parseStored(this.storage.getItem(pendingKey));
         if (!pending || pending.version !== 1 || state !== pending.state) {
-            throw new MdbaseConnectError("invalid_callback", "Authorization callback is missing or does not match this browser session.");
+            throw connectError("invalid_callback", "Authorization callback is missing or does not match this browser session.");
         }
         if (callback.searchParams.has("error")) {
             if (pending.keyHandle)
                 await this.keyStore.delete(pending.keyHandle);
             this.storage.removeItem(pendingKey);
-            throw new MdbaseConnectError(callback.searchParams.get("error") ?? "access_denied", callback.searchParams.get("error_description") ?? "Collection access was not approved.", { details: pending.returnTo ? { returnTo: pending.returnTo } : undefined });
+            throw serverConnectError(callback.searchParams.get("error") ?? "access_denied", callback.searchParams.get("error_description") ?? "Collection access was not approved.", { details: pending.returnTo ? { return_to: pending.returnTo } : undefined });
         }
         if (!code) {
-            throw new MdbaseConnectError("invalid_callback", "Authorization callback is missing its code.");
+            throw connectError("invalid_callback", "Authorization callback is missing its code.");
         }
-        const response = await fetch(`${this.serverUrl}/oauth/token`, {
+        const response = await connectFetch(`${this.serverUrl}/oauth/token`, {
             method: "POST",
             headers: { "content-type": "application/x-www-form-urlencoded" },
             body: new URLSearchParams({
@@ -394,7 +403,7 @@ class MdbaseConnectInternals {
                 redirect_uri: pending.redirectUri,
                 code_verifier: pending.verifier
             })
-        });
+        }, "temporarily_unavailable", "Authorization completion is temporarily unavailable.");
         const body = await response.json();
         if (!response.ok)
             throw apiError(body, "token_exchange_failed", "Authorization could not be completed.", response.status);
@@ -405,7 +414,7 @@ class MdbaseConnectInternals {
             if (pending.keyHandle)
                 await this.keyStore.delete(pending.keyHandle);
             this.storage.removeItem(pendingKey);
-            throw new MdbaseConnectError("encryption_required", "Authorization did not establish the required encrypted relay grant.");
+            throw connectError("encryption_required", "Authorization did not establish the required encrypted relay grant.");
         }
         if (body.authority?.proof_public_key) {
             if (!pending.keyHandle
@@ -414,7 +423,7 @@ class MdbaseConnectInternals {
                 if (pending.keyHandle)
                     await this.keyStore.delete(pending.keyHandle);
                 this.storage.removeItem(pendingKey);
-                throw new MdbaseConnectError("invalid_token_response", "Authorization returned a remote authority capability bound to another application key.");
+                throw connectError("invalid_token_response", "Authorization returned a remote authority capability bound to another application key.");
             }
         }
         else if (body.authority && pending.keyHandle) {
@@ -424,7 +433,7 @@ class MdbaseConnectInternals {
         if (pending.collectionId && pending.collectionId !== token.collectionId) {
             this.removeToken(token.collectionId, token.keyHandle);
             this.storage.removeItem(pendingKey);
-            throw new MdbaseConnectError("collection_mismatch", "The approved collection does not match the collection requested by this link.");
+            throw connectError("collection_mismatch", "The approved collection does not match the collection requested by this link.");
         }
         this.storage.removeItem(pendingKey);
         return {
@@ -462,29 +471,33 @@ class MdbaseConnectInternals {
     storeTokenResponse(body, clientId, keyHandle) {
         const collectionId = body.collection_id;
         if (typeof collectionId !== "string") {
-            throw new MdbaseConnectError("invalid_token_response", "Authorization returned no collection ID.");
+            throw connectError("invalid_token_response", "Authorization returned no collection ID.");
         }
         const scope = parseGrantScope(body.scope);
         if (!scope) {
-            throw new MdbaseConnectError("invalid_token_response", "Authorization returned no valid collection scope.");
+            throw connectError("invalid_token_response", "Authorization returned no valid collection scope.");
         }
         if (body.authority && !validAuthorityTokenResponse(body.authority, collectionId)) {
-            throw new MdbaseConnectError("invalid_token_response", "Authorization returned an invalid remote authority capability.");
+            throw connectError("invalid_token_response", "Authorization returned an invalid remote authority capability.");
         }
         if (body.authority && body.encryption) {
-            throw new MdbaseConnectError("invalid_token_response", "Authorization returned conflicting collection transports.");
+            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 new MdbaseConnectError("invalid_token_response", "Authorization returned an invalid encrypted relay binding.");
+                throw connectError("invalid_token_response", "Authorization returned an invalid encrypted relay binding.");
             }
             if (body.encryption.collection_id !== collectionId
                 || typeof body.grant_id !== "string"
                 || body.grant_id.length === 0) {
-                throw new MdbaseConnectError("invalid_token_response", "Authorization returned an encrypted relay binding for another grant.");
+                throw connectError("invalid_token_response", "Authorization returned an encrypted relay binding for another grant.");
             }
         }
         const previous = parseStored(this.storage.getItem(this.tokenKey(collectionId)));
@@ -498,7 +511,7 @@ class MdbaseConnectInternals {
                     !== body.encryption.connector_agreement_public_key
                 || previous.encryption.application_agreement_public_key
                     !== body.encryption.application_agreement_public_key)) {
-            throw new MdbaseConnectError("connector_identity_changed", "The connector identity changed during authorization renewal. Reauthorize before sending collection data.", { requiresAuthorization: true, recovery: "reauthorize" });
+            throw connectError("connector_identity_changed", "The connector identity changed during authorization renewal. Reauthorize before sending collection data.");
         }
         if (previous?.keyHandle && previous.keyHandle !== keyHandle) {
             void this.keyStore.delete(previous.keyHandle).catch(() => undefined);
@@ -518,12 +531,14 @@ class MdbaseConnectInternals {
                 : 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

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

@@ -0,0 +1,31 @@
+import type { FileTransferSession } from "@mdbase-dev/connect-protocol";
+import type { GrantKeyStore } from "./crypto.js";
+import type { StoredToken } from "./internal-types.js";
+type ProofHeaders = (token: StoredToken, method: "GET" | "POST" | "DELETE", url: string, body: string | undefined, credential: string) => Promise<Record<string, string>>;
+export interface ConnectionFileTransportOptions {
+    keyStore: GrantKeyStore;
+    serverUrl: string;
+    loopbackUrl: string;
+    authorizedToken(): Promise<StoredToken | null>;
+    refreshAuthorization(): Promise<StoredToken>;
+    shouldAttemptDirect(token: StoredToken): Promise<boolean>;
+    onDirectAvailable(): void;
+    onDirectUnavailable(): void;
+    onRelayAvailable(): void;
+    authorityProofHeaders: ProofHeaders;
+}
+/**
+ * Owns every transport concern specific to files. ConnectionTransport only
+ * supplies authorization, routing, and proof-signing policy.
+ */
+export declare class ConnectionFileTransport {
+    private readonly options;
+    private readonly local;
+    constructor(options: ConnectionFileTransportOptions);
+    control<Result>(method: "GET" | "POST" | "DELETE", path?: string, input?: unknown, signal?: AbortSignal): Promise<Result>;
+    uploadChunk(session: FileTransferSession, chunkIndex: number, bytes: Uint8Array, signal?: AbortSignal): Promise<void>;
+    downloadChunk(session: FileTransferSession, chunkIndex: number, signal?: AbortSignal): Promise<Uint8Array>;
+    downloadHostedPart(session: FileTransferSession, partIndex: number, expectedLength: number, signal?: AbortSignal): Promise<ReadableStream<Uint8Array>>;
+    private requireFileToken;
+}
+export {};

package/dist/connection-file-transport.js

@@ -0,0 +1,42 @@
+import { connectError } from "./errors.js";
+import { performHostedFilePartRequest, performHostedFileRequest } from "./hosted-file-request.js";
+import { LocalFileTransport } from "./local-file-transport.js";
+/**
+ * Owns every transport concern specific to files. ConnectionTransport only
+ * supplies authorization, routing, and proof-signing policy.
+ */
+export class ConnectionFileTransport {
+    options;
+    local;
+    constructor(options) {
+        this.options = options;
+        this.local = new LocalFileTransport(options);
+    }
+    async control(method, path = "", input, signal) {
+        const token = await this.requireFileToken();
+        if (!token.authority) {
+            return this.local.control(token, method, path, input, signal);
+        }
+        return performHostedFileRequest(token, method, path, input, signal, this.options.refreshAuthorization, this.options.authorityProofHeaders);
+    }
+    uploadChunk(session, chunkIndex, bytes, signal) {
+        return this.local.uploadChunk(session, chunkIndex, bytes, signal);
+    }
+    downloadChunk(session, chunkIndex, signal) {
+        return this.local.downloadChunk(session, chunkIndex, signal);
+    }
+    async downloadHostedPart(session, partIndex, expectedLength, signal) {
+        const token = await this.requireFileToken();
+        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();
+        if (!token?.fileCapability) {
+            throw connectError("not_authorized", "This connection has no file capability.");
+        }
+        return token;
+    }
+}

package/dist/connection-notifications.js

@@ -1,5 +1,5 @@
-import { MdbaseConnectError } from "./errors.js";
-import { apiError, parseStored } from "./runtime-utils.js";
+import { connectError } from "./errors.js";
+import { apiError, connectFetch, parseStored } from "./runtime-utils.js";
 import { base64UrlBytes, randomBase64Url } from "./base64.js";
 export class ConnectionNotifications {
     context;
@@ -9,19 +9,19 @@ export class ConnectionNotifications {
     async registerNotifications(options) {
         const token = await this.context.authorizedToken();
         if (!token) {
-            throw new MdbaseConnectError("not_authorized", "Connect this application before enabling notifications.");
+            throw connectError("not_authorized", "Connect this application before enabling notifications.");
         }
         const application = await this.context.register();
         const declared = application.notifications?.criteria.map((criterion) => criterion.id) ?? [];
         const criteria = [...new Set(options.criteria ?? declared)];
         const undeclared = criteria.find((criterion) => !declared.includes(criterion));
         if (undeclared) {
-            throw new MdbaseConnectError("notification_criterion_not_declared", `The application manifest does not declare notification criterion ${undeclared}.`);
+            throw connectError("notification_criterion_not_declared", `The application manifest does not declare notification criterion ${undeclared}.`);
         }
         if (criteria.length === 0) {
-            throw new MdbaseConnectError("notifications_not_declared", "This application manifest does not declare any notification criteria.");
+            throw connectError("notifications_not_declared", "This application manifest does not declare any notification criteria.");
         }
-        const keyResponse = await fetch(`${this.context.serverUrl}/v1/notifications/vapid-public-key`);
+        const keyResponse = await connectFetch(`${this.context.serverUrl}/v1/notifications/vapid-public-key`, undefined, "notifications_unavailable", "Push notifications are unavailable.");
         const keyBody = await keyResponse.json();
         if (!keyResponse.ok) {
             throw apiError(keyBody, "notifications_unavailable", "Push notifications are unavailable.", keyResponse.status);
@@ -35,13 +35,13 @@ export class ConnectionNotifications {
         }
         const serialized = pushSubscription.toJSON();
         if (!serialized.endpoint || !serialized.keys?.p256dh || !serialized.keys.auth) {
-            throw new MdbaseConnectError("invalid_push_subscription", "The browser returned an incomplete push subscription.");
+            throw connectError("invalid_push_subscription", "The browser returned an incomplete push subscription.");
         }
         const previous = parseStored(this.context.storage.getItem(this.context.notificationKey()));
         const installationId = options.installationId
             ?? previous?.installationId
             ?? randomBase64Url(24);
-        const channelResponse = await fetch(`${this.context.serverUrl}/v1/notifications/channels`, {
+        const channelResponse = await connectFetch(`${this.context.serverUrl}/v1/notifications/channels`, {
             method: "POST",
             headers: {
                 authorization: `Bearer ${token.accessToken}`,
@@ -56,7 +56,7 @@ export class ConnectionNotifications {
                     keys: serialized.keys
                 }
             })
-        });
+        }, "notification_registration_failed", "Could not register push notifications.");
         const channelBody = await channelResponse.json();
         if (!channelResponse.ok) {
             throw apiError(channelBody, "notification_registration_failed", "Could not register push notifications.", channelResponse.status);
@@ -84,27 +84,27 @@ export class ConnectionNotifications {
     async registerNativeNotifications(options) {
         const token = await this.context.authorizedToken();
         if (!token) {
-            throw new MdbaseConnectError("not_authorized", "Connect this application before enabling notifications.");
+            throw connectError("not_authorized", "Connect this application before enabling notifications.");
         }
         const application = await this.context.register();
         if (application.notifications?.native_delivery?.mode !== "managed_fcm") {
-            throw new MdbaseConnectError("managed_fcm_not_declared", "This application does not declare Connect-managed native notifications.");
+            throw connectError("managed_fcm_not_declared", "This application does not declare Connect-managed native notifications.");
         }
         const declared = application.notifications.criteria.map((criterion) => criterion.id);
         const criteria = [...new Set(options.criteria ?? declared)];
         const undeclared = criteria.find((criterion) => !declared.includes(criterion));
         if (undeclared) {
-            throw new MdbaseConnectError("notification_criterion_not_declared", `The application manifest does not declare notification criterion ${undeclared}.`);
+            throw connectError("notification_criterion_not_declared", `The application manifest does not declare notification criterion ${undeclared}.`);
         }
         if (criteria.length === 0) {
-            throw new MdbaseConnectError("notifications_not_declared", "This application manifest does not declare any notification criteria.");
+            throw connectError("notifications_not_declared", "This application manifest does not declare any notification criteria.");
         }
         const storageKey = this.context.notificationKey("fcm");
         const previous = parseStored(this.context.storage.getItem(storageKey));
         const installationId = options.installationId
             ?? previous?.installationId
             ?? randomBase64Url(24);
-        const response = await fetch(`${this.context.serverUrl}/v1/notifications/channels`, {
+        const response = await connectFetch(`${this.context.serverUrl}/v1/notifications/channels`, {
             method: "POST",
             headers: {
                 authorization: `Bearer ${token.accessToken}`,
@@ -116,7 +116,7 @@ export class ConnectionNotifications {
                 transport: "fcm",
                 token: options.token
             })
-        });
+        }, "notification_registration_failed", "Could not register native notifications.");
         const body = await response.json();
         if (!response.ok) {
             throw apiError(body, "notification_registration_failed", "Could not register native notifications.", response.status);
@@ -139,7 +139,7 @@ export class ConnectionNotifications {
         const registration = parseStored(this.context.storage.getItem(storageKey));
         const token = await this.context.authorizedToken();
         if (registration?.channelId && !token) {
-            throw new MdbaseConnectError("not_authorized", "Reconnect this application before disabling native notifications.");
+            throw connectError("not_authorized", "Reconnect this application before disabling native notifications.");
         }
         if (registration?.channelId && token) {
             await this.deleteNotificationChannel(registration.channelId, token.accessToken);
@@ -150,13 +150,13 @@ export class ConnectionNotifications {
         const registration = parseStored(this.context.storage.getItem(this.context.notificationKey()));
         const token = await this.context.authorizedToken();
         if (registration?.channelId && !token) {
-            throw new MdbaseConnectError("not_authorized", "Reconnect this application before disabling push notifications.");
+            throw connectError("not_authorized", "Reconnect this application before disabling push notifications.");
         }
         if (registration?.channelId && token) {
-            const response = await fetch(`${this.context.serverUrl}/v1/notifications/channels/${registration.channelId}`, {
+            const response = await connectFetch(`${this.context.serverUrl}/v1/notifications/channels/${registration.channelId}`, {
                 method: "DELETE",
                 headers: { authorization: `Bearer ${token.accessToken}` }
-            });
+            }, "notification_unregistration_failed", "Could not unregister push notifications.");
             if (!response.ok && response.status !== 404) {
                 const body = await response.json();
                 throw apiError(body, "notification_unregistration_failed", "Could not unregister push notifications.", response.status);
@@ -167,10 +167,10 @@ export class ConnectionNotifications {
         await subscription?.unsubscribe();
     }
     async deleteNotificationChannel(channelId, accessToken) {
-        const response = await fetch(`${this.context.serverUrl}/v1/notifications/channels/${channelId}`, {
+        const response = await connectFetch(`${this.context.serverUrl}/v1/notifications/channels/${channelId}`, {
             method: "DELETE",
             headers: { authorization: `Bearer ${accessToken}` }
-        });
+        }, "notification_unregistration_failed", "Could not unregister push notifications.");
         if (!response.ok && response.status !== 404) {
             const body = await response.json();
             throw apiError(body, "notification_unregistration_failed", "Could not unregister push notifications.", response.status);

package/dist/connection-transport.d.ts

@@ -3,6 +3,7 @@ import { type GrantKeyStore } from "./crypto.js";
 import type { StoredToken } from "./internal-types.js";
 import type { DirectAccessStatus, MdbaseConnectionRoute } from "./connection-types.js";
 import type { OperationRequestOptions, PendingMutationSummary } from "./operation-types.js";
+import { ConnectionFileTransport } from "./connection-file-transport.js";
 export interface ConnectionTransportInternals {
     readonly relayEncryption: "required" | "disabled";
     removeToken(collectionId: string, keyHandle?: string, reason?: "not_authorized" | "authorization_lost" | "invalid_stored_grant"): void;
@@ -31,6 +32,7 @@ export declare class ConnectionTransport {
     private readonly collectionId;
     private readonly internals;
     private readonly onChange;
+    readonly files: ConnectionFileTransport;
     private refreshPromise;
     private directStatus;
     private currentRoute;