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

package/dist/connection-transport.js

@@ -1,7 +1,9 @@
+import { isConnectProblem } from "@mdbase-dev/connect-protocol";
 import { decryptRelayResponse, encryptRelayRequest, RelayCryptoError, signAuthorityRequest } from "./crypto.js";
-import { MdbaseConnectError } from "./errors.js";
-import { directFallbackStatus, isMutation, localNetworkPermission, loopbackRequest, operationFingerprint, operationTransportError, sameAuthorization, throwIfCancelled, uncertainDirectMutation } from "./operation-helpers.js";
-import { apiError, parseGrantScope, parseStored, validStoredAuthority, validStoredEncryption } from "./runtime-utils.js";
+import { MdbaseConnectError, connectError, serverConnectError } from "./errors.js";
+import { ConnectionFileTransport } from "./connection-file-transport.js";
+import { directFallbackStatus, isMutation, localNetworkPermission, loopbackRequest, operationFingerprint, operationTransportError, sameAuthorization, throwIfCancelled, unknownMutationOutcome } from "./operation-helpers.js";
+import { apiError, oauthErrorCode, parseGrantScope, parseStored, validStoredAuthority, validStoredEncryption, validFileCapability } from "./runtime-utils.js";
 export class ConnectionTransport {
     serverUrl;
     storage;
@@ -11,6 +13,7 @@ export class ConnectionTransport {
     collectionId;
     internals;
     onChange;
+    files;
     refreshPromise = null;
     directStatus;
     currentRoute = "relay";
@@ -25,6 +28,21 @@ export class ConnectionTransport {
         this.collectionId = options.collectionId;
         this.internals = options.internals;
         this.onChange = options.onChange;
+        this.files = new ConnectionFileTransport({
+            keyStore: this.keyStore,
+            serverUrl: this.serverUrl,
+            loopbackUrl: this.loopbackUrl,
+            authorizedToken: () => this.authorizedToken(),
+            refreshAuthorization: () => this.refreshAuthorization(),
+            shouldAttemptDirect: (token) => this.shouldAttemptDirect(token),
+            onDirectAvailable: () => {
+                this.markDirectAvailable();
+                this.setRoute("direct");
+            },
+            onDirectUnavailable: () => this.markDirectUnavailable(),
+            onRelayAvailable: () => this.setRoute("relay"),
+            authorityProofHeaders: (token, method, url, body, credential) => this.authorityProofHeaders(token, method, url, body, credential)
+        });
         this.directStatus = this.directAccessMode === "disabled"
             ? "disabled"
             : "unavailable";
@@ -83,7 +101,7 @@ export class ConnectionTransport {
     async resumePendingMutation(input, options) {
         const pending = this.pendingMutation();
         if (!pending) {
-            throw new MdbaseConnectError("no_pending_mutation", "There is no interrupted mutation to resume.", { recovery: "none" });
+            throw connectError("no_pending_mutation", "There is no interrupted mutation to resume.");
         }
         return this.performOperation(pending.operation, input, options);
     }
@@ -91,15 +109,13 @@ export class ConnectionTransport {
         throwIfCancelled(options.signal);
         let token = this.currentToken();
         if (!token)
-            throw new MdbaseConnectError("not_authorized", "Connect this application before accessing a collection.");
+            throw connectError("not_authorized", "Connect this application before accessing a collection.");
         if (!token.operations.includes(operation)) {
-            throw new MdbaseConnectError("insufficient_access", `This connection does not allow ${operation}.`, {
-                requiresAuthorization: true,
-                recovery: "reauthorize",
+            throw connectError("insufficient_access", `This connection does not allow ${operation}.`, {
                 details: {
-                    requiredOperations: [operation],
-                    grantedOperations: [...token.operations],
-                    missingOperations: [operation]
+                    required_operations: [operation],
+                    granted_operations: [...token.operations],
+                    missing_operations: [operation]
                 }
             });
         }
@@ -107,14 +123,14 @@ export class ConnectionTransport {
         if (!tryDirect) {
             token = await this.authorizedToken();
             if (!token)
-                throw new MdbaseConnectError("not_authorized", "Reconnect this application to continue.");
+                throw connectError("not_authorized", "Reconnect this application to continue.");
         }
         let attempt;
         try {
             attempt = await this.sendOperation(token, operation, input, tryDirect, options);
         }
         catch (error) {
-            throw operationTransportError(error, options.signal, isMutation(operation, input) && this.pendingMutation() !== null);
+            throw operationTransportError(error, options.signal, isMutation(operation, input) && this.pendingMutation() !== null, token.authority ? "hosted_provider_unavailable" : "relay_unavailable");
         }
         let response = attempt.response;
         const staleBinding = response.status === 409
@@ -123,7 +139,7 @@ export class ConnectionTransport {
             if (attempt.pendingMutation
                 && (attempt.directDeliveryUncertain
                     || (attempt.encryptedRequest && attempt.resumingMutation))) {
-                throw new MdbaseConnectError("direct_outcome_unknown", "The direct operation may have completed, but its encrypted grant changed before the response could be recovered. Refresh before making another change.");
+                throw connectError("operation_outcome_unknown", "The direct operation may have completed, but its encrypted grant changed before the response could be recovered. Refresh before making another change.", { operationOutcome: "unknown" });
             }
             if (attempt.pendingMutation)
                 this.clearPendingMutation();
@@ -133,17 +149,25 @@ export class ConnectionTransport {
                 attempt = await this.sendOperation(token, operation, input, tryDirect, options);
             }
             catch (error) {
-                throw operationTransportError(error, options.signal, isMutation(operation, input) && this.pendingMutation() !== null);
+                throw operationTransportError(error, options.signal, isMutation(operation, input) && this.pendingMutation() !== null, token.authority ? "hosted_provider_unavailable" : "relay_unavailable");
             }
             response = attempt.response;
         }
-        const body = await response.json();
+        let body;
+        try {
+            body = await response.json();
+        }
+        catch (cause) {
+            if (attempt.pendingMutation)
+                throw unknownMutationOutcome(cause);
+            throw connectError("invalid_operation_response", "The collection authority returned a response that is not valid JSON.", { cause });
+        }
         if (!response.ok) {
             const error = apiError(body, "operation_failed", "Collection operation failed.", response.status);
             if (attempt.pendingMutation
                 && (attempt.directDeliveryUncertain
                     || (attempt.encryptedRequest && attempt.resumingMutation))) {
-                throw uncertainDirectMutation(error);
+                throw unknownMutationOutcome(error);
             }
             if (attempt.pendingMutation && !attempt.directDeliveryUncertain) {
                 this.clearPendingMutation();
@@ -156,26 +180,54 @@ export class ConnectionTransport {
         if (attempt.encryptedRequest) {
             const encryptedResponse = body?.envelope;
             if (!encryptedResponse || !token.encryption || !token.grantId || !token.keyHandle) {
-                throw new MdbaseConnectError("invalid_encrypted_response", "The relay did not return an encrypted connector response.");
+                if (attempt.pendingMutation)
+                    throw unknownMutationOutcome(new Error("Encrypted operation response was missing its envelope."));
+                throw connectError("invalid_encrypted_response", "The relay did not return an encrypted connector response.");
             }
             try {
                 const decrypted = await decryptRelayResponse(this.keyStore, token.keyHandle, { grantId: token.grantId, applicationId: token.clientId, encryption: token.encryption }, attempt.encryptedRequest, encryptedResponse);
                 if (attempt.pendingMutation)
                     this.clearPendingMutation();
                 if (!decrypted.ok)
-                    throw new MdbaseConnectError(decrypted.error.code, decrypted.error.message);
+                    throw serverConnectError(decrypted.problem.code === "unknown"
+                        ? decrypted.problem.server_code
+                        : decrypted.problem.code, decrypted.problem.message, {
+                        details: decrypted.problem.details,
+                        operationOutcome: decrypted.problem.operation_outcome ?? "rejected",
+                        traceId: decrypted.problem.trace_id
+                    });
                 return decrypted.result;
             }
             catch (error) {
                 if (error instanceof MdbaseConnectError)
                     throw error;
-                if (error instanceof RelayCryptoError)
-                    throw new MdbaseConnectError(error.code, error.message);
+                if (error instanceof RelayCryptoError) {
+                    if (attempt.pendingMutation)
+                        throw unknownMutationOutcome(error);
+                    throw serverConnectError(error.code, error.message);
+                }
                 throw error;
             }
         }
         if (body?.protocol_version !== 1 || body?.request_id !== attempt.requestId) {
-            throw new MdbaseConnectError("invalid_operation_response", "The collection authority returned a response for a different protocol request.");
+            if (attempt.pendingMutation)
+                throw unknownMutationOutcome(new Error("Operation response protocol or request ID did not match."));
+            throw connectError("invalid_operation_response", "The collection authority returned a response for a different protocol request.");
+        }
+        if (body.ok === false) {
+            if (!isConnectProblem(body.problem)) {
+                if (attempt.pendingMutation)
+                    throw unknownMutationOutcome(new Error("Operation rejection did not contain a canonical problem."));
+                throw connectError("invalid_operation_response", "The collection authority returned an invalid operation problem.");
+            }
+            if (attempt.pendingMutation)
+                this.clearPendingMutation();
+            throw new MdbaseConnectError(body.problem);
+        }
+        if (body.ok !== true || !("result" in body)) {
+            if (attempt.pendingMutation)
+                throw unknownMutationOutcome(new Error("Successful operation response did not contain a result."));
+            throw connectError("invalid_operation_response", "The collection authority returned an incomplete operation response.");
         }
         if (attempt.pendingMutation)
             this.clearPendingMutation();
@@ -186,7 +238,7 @@ export class ConnectionTransport {
         if (!token?.authority
             || token.collectionId !== collectionId
             || token.authority.replicaId !== replicaId) {
-            throw new MdbaseConnectError("authority_authorization_changed", "Reconnect this collection authority before synchronizing.");
+            throw connectError("authority_authorization_changed", "Reconnect this collection authority before synchronizing.");
         }
         let response = await this.sendAuthoritySyncRequest(token, method, path, input);
         if (response.status === 401 && token.refreshToken) {
@@ -194,7 +246,7 @@ export class ConnectionTransport {
             if (!token.authority
                 || token.collectionId !== collectionId
                 || token.authority.replicaId !== replicaId) {
-                throw new MdbaseConnectError("authority_authorization_changed", "Reconnect this collection authority before synchronizing.");
+                throw connectError("authority_authorization_changed", "Reconnect this collection authority before synchronizing.");
             }
             response = await this.sendAuthoritySyncRequest(token, method, path, input);
         }
@@ -205,7 +257,7 @@ export class ConnectionTransport {
     }
     async sendAuthoritySyncRequest(token, method, path, input) {
         if (!token.authority) {
-            throw new MdbaseConnectError("not_remote_authority", "This authorization has no remote authority endpoint.");
+            throw connectError("not_remote_authority", "This authorization has no remote authority endpoint.");
         }
         const url = `${token.authority.syncUrl}/${path}`;
         const body = input === undefined ? undefined : JSON.stringify(input);
@@ -237,7 +289,7 @@ export class ConnectionTransport {
                     || pending.keyId !== token.encryption?.key_id
                     || pending.operation !== operation
                     || pending.inputFingerprint !== inputFingerprint) {
-                    throw new MdbaseConnectError("pending_mutation_unresolved", "A previous write still has an unknown outcome. Retry that exact write before making another change.");
+                    throw connectError("pending_mutation_unresolved", "A previous write still has an unknown outcome. Retry that exact write before making another change.");
                 }
                 requestId = pending.requestId;
                 resumingMutation = true;
@@ -246,13 +298,13 @@ export class ConnectionTransport {
         }
         if (token.encryption && !token.authority) {
             if (!token.grantId || !token.keyHandle) {
-                throw new MdbaseConnectError("missing_grant_key", "Reconnect this application to restore encrypted access.");
+                throw connectError("missing_grant_key", "Reconnect this application to restore encrypted access.");
             }
             try {
                 if (pendingMutation) {
                     if (pending) {
                         if (!pending.envelope) {
-                            throw new MdbaseConnectError("pending_mutation_unresolved", "The pending write belongs to a different transport. Reconnect before retrying it.");
+                            throw connectError("pending_mutation_unresolved", "The pending write belongs to a different transport. Reconnect before retrying it.");
                         }
                         encryptedRequest = pending.envelope;
                     }
@@ -276,7 +328,7 @@ export class ConnectionTransport {
             }
             catch (error) {
                 if (error instanceof RelayCryptoError)
-                    throw new MdbaseConnectError(error.code, error.message);
+                    throw serverConnectError(error.code, error.message);
                 throw error;
             }
             body = encryptedRequest;
@@ -341,7 +393,7 @@ export class ConnectionTransport {
             }
             catch (error) {
                 if (pendingMutation && (directDeliveryUncertain || resumingMutation))
-                    throw uncertainDirectMutation(error);
+                    throw unknownMutationOutcome(error);
                 throw error;
             }
             let response;
@@ -358,7 +410,7 @@ export class ConnectionTransport {
             }
             catch (error) {
                 if (pendingMutation && (directDeliveryUncertain || resumingMutation))
-                    throw uncertainDirectMutation(error);
+                    throw unknownMutationOutcome(error);
                 throw error;
             }
             if (response.ok)
@@ -526,6 +578,9 @@ export class ConnectionTransport {
         if (!parseGrantScope(token.scope)) {
             return invalidate(token.keyHandle);
         }
+        if (token.fileCapability && !validFileCapability(token.fileCapability)) {
+            return invalidate(token.keyHandle);
+        }
         if (token.authority
             && !validStoredAuthority(token.authority, token.collectionId)) {
             return invalidate(token.keyHandle);
@@ -564,7 +619,7 @@ export class ConnectionTransport {
             return token;
         if (!token.refreshToken || (token.refreshExpiresAt ?? 0) <= Date.now()) {
             if (this.directCapable(token)) {
-                throw new MdbaseConnectError("relay_authorization_expired", "Direct access is still available on this computer, but using the relay requires reconnecting this application.");
+                throw connectError("relay_authorization_expired", "Direct access is still available on this computer, but using the relay requires reconnecting this application.");
             }
             this.internals.removeToken(this.collectionId, token.keyHandle);
             return null;
@@ -582,10 +637,10 @@ export class ConnectionTransport {
     async performRefresh() {
         const current = this.currentToken();
         if (!current?.refreshToken) {
-            throw new MdbaseConnectError("not_authorized", "Reconnect this application to continue.");
+            throw connectError("not_authorized", "Reconnect this application to continue.");
         }
         if ((current.refreshExpiresAt ?? 0) <= Date.now()) {
-            throw new MdbaseConnectError("relay_authorization_expired", "Direct access is still available on this computer, but using the relay requires reconnecting this application.");
+            throw connectError("relay_authorization_expired", "Direct access is still available on this computer, but using the relay requires reconnecting this application.");
         }
         const attemptedRefreshToken = current.refreshToken;
         const refreshUrl = `${this.serverUrl}/oauth/token`;
@@ -614,6 +669,9 @@ export class ConnectionTransport {
             if (!this.directCapable(current)) {
                 this.internals.removeToken(this.collectionId, current.keyHandle);
             }
+            if ((oauthErrorCode(body) ?? body?.error?.code) === "invalid_grant") {
+                throw connectError("authorization_expired", body?.error_description ?? body?.error?.message ?? "Reconnect this application to continue.", { status: response.status });
+            }
             throw apiError(body, "authorization_expired", "Reconnect this application to continue.", response.status);
         }
         return this.storeTokenResponse(body, current.clientId, current.keyHandle);
@@ -622,7 +680,7 @@ export class ConnectionTransport {
         if (!token.authority?.proofPublicKey)
             return {};
         if (!token.keyHandle) {
-            throw new MdbaseConnectError("missing_grant_key", "Reconnect this application to restore remote authority request signing.");
+            throw connectError("missing_grant_key", "Reconnect this application to restore remote authority request signing.");
         }
         try {
             const target = new URL(url);
@@ -635,14 +693,14 @@ export class ConnectionTransport {
         }
         catch (error) {
             if (error instanceof RelayCryptoError) {
-                throw new MdbaseConnectError(error.code, error.message);
+                throw serverConnectError(error.code, error.message);
             }
             throw error;
         }
     }
     storeTokenResponse(body, clientId, keyHandle) {
         if (body.collection_id !== this.collectionId) {
-            throw new MdbaseConnectError("collection_mismatch", "The refreshed authorization belongs to a different collection.");
+            throw connectError("collection_mismatch", "The refreshed authorization belongs to a different collection.");
         }
         const token = this.internals.storeTokenResponse(body, clientId, keyHandle);
         this.currentRoute = token.authority ? "remote" : "relay";

package/dist/connection-types.d.ts

@@ -1,4 +1,4 @@
-import type { CollectionOperation, GrantScope, JsonObject, SyncChangesPage, SyncMutation, SyncMutationReceipt, SyncSession, SyncSnapshotPage } from "@mdbase-dev/connect-protocol";
+import type { CollectionOperation, FileCapability, GrantScope, JsonObject, SyncChangesPage, SyncMutation, SyncMutationReceipt, SyncSession, SyncSnapshotPage } from "@mdbase-dev/connect-protocol";
 export type MdbaseConnectionRoute = "remote" | "direct" | "relay";
 export type DirectAccessStatus = "disabled" | "permission_required" | "checking" | "available" | "unavailable" | "denied";
 export interface MdbaseConnectionInfo {
@@ -6,6 +6,7 @@ export interface MdbaseConnectionInfo {
     displayName: string;
     operations: CollectionOperation[];
     scope: GrantScope;
+    fileCapability?: FileCapability;
     route: MdbaseConnectionRoute;
     directAccess: DirectAccessStatus;
 }

package/dist/connection.d.ts

@@ -1,10 +1,12 @@
-import type { CollectionChange, CollectionChangesPage, CollectionDescription, CollectionOperation, CollectionTypeDocument, CreateViewSourceInput, DeleteViewSourceInput, DeleteViewSourceResult, ExecuteViewInput, GrantScope, JsonObject, MdbaseOperationEnvelope, ReadViewSourceInput, RecordDocument, SavedViewExecution, SavedViewList, SavedViewSourceDocument, TypePackInstallResult, TypePackProvision, UpdateViewSourceInput } from "@mdbase-dev/connect-protocol";
+import type { CollectionChange, CollectionChangesPage, CollectionDescription, CollectionOperation, CollectionTypeDocument, CreateViewSourceInput, DeleteViewSourceInput, DeleteViewSourceResult, ExecuteViewInput, FileCapability, GrantScope, JsonObject, ReadViewSourceInput, RecordDocument, SavedViewExecution, SavedViewList, SavedViewSourceDocument, TypePackInstallResult, TypePackProvision, 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 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";
 export type MdbaseAuthorizationTarget = {
     kind: "choose";
@@ -62,27 +64,29 @@ export declare class MdbaseConnection<Frontmatter extends JsonObject = JsonObjec
     private readonly collectionClient;
     private readonly notifications;
     private readonly transport;
+    readonly files: MdbaseFileClient;
     private readonly connectionListeners;
     constructor(internals: MdbaseConnectionInternals<Frontmatter>, collectionId: string);
     get displayName(): string;
     get operations(): CollectionOperation[];
-    get scope(): GrantScope;
+    get scope(): GrantScope | null;
+    get fileCapability(): FileCapability | null;
     get directAccess(): DirectAccessStatus;
     get route(): MdbaseConnectionRoute;
-    register(): Promise<Application>;
+    register(): Promise<ConnectOutcome<Application, RegistrationProblemCode>>;
     info(): MdbaseConnectionInfo | null;
     authorizationCapabilities(requiredOperations?: CollectionOperation[]): MdbaseAuthorizationCapabilities;
     hasOperations(requiredOperations: CollectionOperation[]): boolean;
-    authorize(options?: MdbaseConnectionAuthorizeOptions): Promise<MdbaseAuthorizationOutcome<Frontmatter>>;
-    requestOperations(requiredOperations: CollectionOperation[], options?: Pick<MdbaseConnectionAuthorizeOptions, "returnTo">): Promise<MdbaseAuthorizationOutcome<Frontmatter> | {
+    authorize(options?: MdbaseConnectionAuthorizeOptions): Promise<ConnectOutcome<MdbaseAuthorizationOutcome<Frontmatter>, AuthorizationProblemCode>>;
+    requestOperations(requiredOperations: CollectionOperation[], options?: Pick<MdbaseConnectionAuthorizeOptions, "returnTo">): Promise<ConnectOutcome<MdbaseAuthorizationOutcome<Frontmatter> | {
         kind: "unchanged";
         connection: MdbaseConnection<Frontmatter>;
-    }>;
+    }, AuthorizationProblemCode>>;
     onConnectionChange(listener: (connection: MdbaseConnectionInfo | null) => void): () => void;
     notifyStorageChanged(): void;
-    checkDirectAccess(): Promise<DirectAccessStatus>;
+    checkDirectAccess(): Promise<ConnectOutcome<DirectAccessStatus, DirectAccessProblemCode>>;
     /** Call from a user gesture to request browser permission for direct local access. */
-    requestDirectAccess(): Promise<DirectAccessStatus>;
+    requestDirectAccess(): Promise<ConnectOutcome<DirectAccessStatus, DirectAccessProblemCode>>;
     disableDirectAccess(): void;
     /**
      * Return one offline-replication transport regardless of whether the
@@ -96,59 +100,59 @@ export declare class MdbaseConnection<Frontmatter extends JsonObject = JsonObjec
      * Criteria are evaluated by the collection authority. Push payloads contain
      * only an opaque cursor and static presentation copy.
      */
-    registerNotifications(options: MdbaseNotificationRegistrationOptions): Promise<MdbaseNotificationRegistration>;
-    registerNativeNotifications(options: MdbaseNativeNotificationRegistrationOptions): Promise<MdbaseNativeNotificationRegistration>;
-    unregisterNativeNotifications(): Promise<void>;
-    unregisterNotifications(serviceWorker?: ServiceWorkerRegistration): Promise<void>;
+    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>>;
     forget(): void;
-    describe(): Promise<CollectionDescription>;
-    changes(input?: ChangesInput, options?: OperationRequestOptions): Promise<CollectionChangesPage>;
-    read(input: ReadInput): Promise<MdbaseOperationEnvelope<RecordDocument<Frontmatter>>>;
-    query(input?: QueryInput, options?: OperationRequestOptions): Promise<MdbaseOperationEnvelope<QueryResult<Frontmatter>>>;
-    queryPages(input?: QueryInput, options?: QueryPagesOptions<Frontmatter>): AsyncGenerator<QueryPage<Frontmatter>>;
-    queryAll(input?: QueryInput, options?: QueryPagesOptions<Frontmatter>): Promise<QueryResult<Frontmatter>>;
-    listViews(): Promise<MdbaseOperationEnvelope<SavedViewList>>;
-    executeView(input: ExecuteViewInput): Promise<MdbaseOperationEnvelope<SavedViewExecution<Frontmatter>>>;
-    readViewSource(input: ReadViewSourceInput): Promise<MdbaseOperationEnvelope<SavedViewSourceDocument>>;
-    createViewSource(input: CreateViewSourceInput): Promise<MdbaseOperationEnvelope<SavedViewSourceDocument>>;
-    updateViewSource(input: UpdateViewSourceInput): Promise<MdbaseOperationEnvelope<SavedViewSourceDocument>>;
-    deleteViewSource(input: DeleteViewSourceInput): Promise<MdbaseOperationEnvelope<DeleteViewSourceResult>>;
-    create(input: CreateInput<Frontmatter>): Promise<MdbaseOperationEnvelope<RecordDocument<Frontmatter>>>;
-    update(input: UpdateInput<Frontmatter>): Promise<MdbaseOperationEnvelope<RecordDocument<Frontmatter>>>;
-    delete(input: DeleteInput, options?: OperationRequestOptions): Promise<MdbaseOperationEnvelope<DeleteResult>>;
-    preflightDelete(input: DeleteInput, options?: OperationRequestOptions): Promise<MdbaseOperationEnvelope<DeletePreflightResult>>;
-    rename(input: RenameInput, options?: OperationRequestOptions): Promise<MdbaseOperationEnvelope<RenameResult>>;
-    preflightRename(input: RenameInput, options?: OperationRequestOptions): Promise<MdbaseOperationEnvelope<RenamePreflightResult>>;
-    renameWithProgress(input: RenameInput, options?: RenameProgressOptions): Promise<MdbaseOperationEnvelope<RenameResult>>;
-    deleteWithProgress(input: DeleteInput, options?: DeleteProgressOptions): Promise<MdbaseOperationEnvelope<DeleteResult>>;
+    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>>;
+    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>>;
+    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<Result>;
-    validate(input?: JsonObject): Promise<MdbaseOperationEnvelope>;
-    readType(input: ReadTypeInput): Promise<MdbaseOperationEnvelope<CollectionTypeDocument>>;
-    createType(input: CreateTypeInput): Promise<MdbaseOperationEnvelope<CollectionTypeDocument>>;
-    updateType(input: UpdateTypeInput): Promise<MdbaseOperationEnvelope<CollectionTypeDocument>>;
-    installTypePack(input: TypePackProvision): Promise<MdbaseOperationEnvelope<TypePackInstallResult>>;
-    listTimers(namespace: string): Promise<MdbaseTimerList>;
+    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>>;
+    installTypePack(input: TypePackProvision): Promise<ConnectOutcome<TypePackInstallResult, CollectionTypeProblemCode>>;
+    listTimers(namespace: string): Promise<ConnectOutcome<MdbaseTimerList, CollectionReadProblemCode>>;
     putTimer(input: {
         namespace: string;
         criterion_id: string;
         timer: MdbaseDesiredTimer;
-    }): Promise<MdbaseTimer>;
+    }): Promise<ConnectOutcome<MdbaseTimer, CollectionMutationProblemCode>>;
     cancelTimer(input: {
         namespace: string;
         id: string;
         generation?: number;
-    }): Promise<{
+    }): Promise<ConnectOutcome<{
         namespace: string;
         id: string;
         cancelled: boolean;
-    }>;
+    }, CollectionMutationProblemCode>>;
     reconcileTimers(input: {
         namespace: string;
         criterion_id: string;
         timers: MdbaseDesiredTimer[];
-    }): Promise<MdbaseTimerReconciliation>;
-    watch(options?: WatchOptions): AsyncGenerator<CollectionChange>;
-    operation<Result>(operation: CollectionOperation, input: unknown, options?: OperationRequestOptions): Promise<Result>;
+    }): Promise<ConnectOutcome<MdbaseTimerReconciliation, CollectionMutationProblemCode>>;
+    watch(options?: WatchOptions): AsyncGenerator<ConnectOutcome<CollectionChange, CollectionChangesProblemCode>>;
+    operation<Result>(operation: CollectionOperation, input: unknown, options?: OperationRequestOptions): Promise<ConnectOutcome<Result>>;
     private emitConnection;
 }