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

package/dist/outcomes.d.ts

@@ -13,19 +13,19 @@ export type ConnectFailure<Code extends ConnectProblemCode = ConnectProblemCode>
  * for programming errors and broken SDK invariants.
  */
 export type ConnectOutcome<Value, Code extends ConnectProblemCode = ConnectProblemCode> = ConnectSuccess<Value> | ConnectFailure<Code>;
-export type CommonOperationProblemCode = "access_denied" | "access_paused" | "authorization_expired" | "collection_access_denied" | "connector_identity_changed" | "connector_offline" | "connector_upgrade_required" | "direct_operation_rejected" | "operation_outcome_unknown" | "encryption_required" | "encrypted_relay_rejected" | "hosted_provider_unavailable" | "insufficient_access" | "invalid_encrypted_response" | "invalid_operation_response" | "invalid_request" | "missing_grant_key" | "not_authorized" | "operation_cancelled" | "operation_failed" | "rate_limited" | "relay_authorization_expired" | "relay_unavailable" | "temporarily_unavailable" | "timeout" | "unsupported_operation";
-export declare const COMMON_OPERATION_PROBLEM_CODES: readonly ["access_denied", "access_paused", "authorization_expired", "collection_access_denied", "connector_identity_changed", "connector_offline", "connector_upgrade_required", "direct_operation_rejected", "operation_outcome_unknown", "encryption_required", "encrypted_relay_rejected", "hosted_provider_unavailable", "insufficient_access", "invalid_encrypted_response", "invalid_operation_response", "invalid_request", "missing_grant_key", "not_authorized", "operation_cancelled", "operation_failed", "rate_limited", "relay_authorization_expired", "relay_unavailable", "temporarily_unavailable", "timeout", "unsupported_operation"];
+export type CommonOperationProblemCode = "access_denied" | "access_paused" | "authorization_binding_incompatible" | "authorization_expired" | "capability_contract_incompatible" | "collection_access_denied" | "connector_identity_changed" | "connector_offline" | "connector_upgrade_required" | "direct_operation_rejected" | "durable_mutation_unsupported" | "operation_outcome_unknown" | "encryption_required" | "encrypted_relay_rejected" | "hosted_provider_unavailable" | "insufficient_access" | "invalid_encrypted_response" | "invalid_operation_response" | "invalid_request" | "missing_grant_key" | "mutation_recovery_expired" | "mutation_request_conflict" | "not_authorized" | "operation_cancelled" | "operation_failed" | "rate_limited" | "relay_authorization_expired" | "relay_unavailable" | "temporarily_unavailable" | "timeout" | "transport_protocol_incompatible" | "unsupported_operation";
+export declare const COMMON_OPERATION_PROBLEM_CODES: readonly ["access_denied", "access_paused", "authorization_binding_incompatible", "authorization_expired", "capability_contract_incompatible", "collection_access_denied", "connector_identity_changed", "connector_offline", "connector_upgrade_required", "direct_operation_rejected", "durable_mutation_unsupported", "operation_outcome_unknown", "encryption_required", "encrypted_relay_rejected", "hosted_provider_unavailable", "insufficient_access", "invalid_encrypted_response", "invalid_operation_response", "invalid_request", "missing_grant_key", "mutation_recovery_expired", "mutation_request_conflict", "not_authorized", "operation_cancelled", "operation_failed", "rate_limited", "relay_authorization_expired", "relay_unavailable", "temporarily_unavailable", "timeout", "transport_protocol_incompatible", "unsupported_operation"];
 export declare const ALL_CONNECT_PROBLEM_CODES: ConnectProblemCode[];
-export type RegistrationProblemCode = "discovery_failed" | "invalid_application_manifest" | "invalid_request" | "manifest_load_failed" | "rate_limited" | "temporarily_unavailable" | "timeout";
-export declare const REGISTRATION_PROBLEM_CODES: readonly ["discovery_failed", "invalid_application_manifest", "invalid_request", "manifest_load_failed", "rate_limited", "temporarily_unavailable", "timeout"];
-export type AuthorizationProblemCode = RegistrationProblemCode | "access_denied" | "application_identity_unavailable" | "approval_window_blocked" | "authorization_cancelled" | "authorization_replayed" | "browser_required" | "collection_access_denied" | "collection_configuration_invalid" | "collection_contracts_missing" | "collection_incompatible" | "collection_invalid" | "collection_kind_unsupported" | "collection_mismatch" | "collection_not_found" | "collection_type_registry_invalid" | "collection_version_unsupported" | "connector_identity_changed" | "connector_offline" | "connector_upgrade_required" | "device_authorization_failed" | "encryption_required" | "expired_token" | "invalid_application_authorization" | "invalid_callback" | "invalid_device_authorization_response" | "invalid_token_response" | "scope_denied" | "reconnect_required" | "token_exchange_failed";
-export declare const AUTHORIZATION_PROBLEM_CODES: readonly ["discovery_failed", "invalid_application_manifest", "invalid_request", "manifest_load_failed", "rate_limited", "temporarily_unavailable", "timeout", "access_denied", "application_identity_unavailable", "approval_window_blocked", "authorization_cancelled", "authorization_replayed", "browser_required", "collection_access_denied", "collection_configuration_invalid", "collection_contracts_missing", "collection_incompatible", "collection_invalid", "collection_kind_unsupported", "collection_mismatch", "collection_not_found", "collection_type_registry_invalid", "collection_version_unsupported", "connector_identity_changed", "connector_offline", "connector_upgrade_required", "device_authorization_failed", "encryption_required", "expired_token", "invalid_application_authorization", "invalid_callback", "invalid_device_authorization_response", "invalid_token_response", "scope_denied", "reconnect_required", "token_exchange_failed"];
-export type NotificationProblemCode = RegistrationProblemCode | "authorization_expired" | "invalid_push_subscription" | "managed_fcm_not_declared" | "not_authorized" | "notification_criterion_not_declared" | "notification_reauthorization_required" | "notification_registration_failed" | "notification_unregistration_failed" | "notifications_not_declared" | "notifications_unavailable";
-export declare const NOTIFICATION_PROBLEM_CODES: readonly ["discovery_failed", "invalid_application_manifest", "invalid_request", "manifest_load_failed", "rate_limited", "temporarily_unavailable", "timeout", "authorization_expired", "invalid_push_subscription", "managed_fcm_not_declared", "not_authorized", "notification_criterion_not_declared", "notification_reauthorization_required", "notification_registration_failed", "notification_unregistration_failed", "notifications_not_declared", "notifications_unavailable"];
+export type RegistrationProblemCode = "discovery_failed" | "invalid_operation_response" | "invalid_application_manifest" | "invalid_request" | "manifest_load_failed" | "rate_limited" | "temporarily_unavailable" | "timeout";
+export declare const REGISTRATION_PROBLEM_CODES: readonly ["discovery_failed", "invalid_operation_response", "invalid_application_manifest", "invalid_request", "manifest_load_failed", "rate_limited", "temporarily_unavailable", "timeout"];
+export type AuthorizationProblemCode = RegistrationProblemCode | "access_denied" | "application_identity_unavailable" | "approval_window_blocked" | "authorization_binding_incompatible" | "authorization_cancelled" | "authorization_replayed" | "browser_required" | "capability_contract_incompatible" | "collection_access_denied" | "collection_configuration_invalid" | "collection_contracts_missing" | "collection_incompatible" | "collection_invalid" | "collection_kind_unsupported" | "collection_mismatch" | "collection_not_found" | "collection_type_registry_invalid" | "collection_version_unsupported" | "connector_identity_changed" | "connector_offline" | "connector_upgrade_required" | "device_authorization_failed" | "durable_mutation_unsupported" | "encryption_required" | "expired_token" | "invalid_application_authorization" | "invalid_callback" | "invalid_device_authorization_response" | "invalid_token_response" | "scope_denied" | "reconnect_required" | "token_exchange_failed" | "transport_protocol_incompatible";
+export declare const AUTHORIZATION_PROBLEM_CODES: readonly ["discovery_failed", "invalid_operation_response", "invalid_application_manifest", "invalid_request", "manifest_load_failed", "rate_limited", "temporarily_unavailable", "timeout", "access_denied", "application_identity_unavailable", "approval_window_blocked", "authorization_binding_incompatible", "authorization_cancelled", "authorization_replayed", "browser_required", "capability_contract_incompatible", "collection_access_denied", "collection_configuration_invalid", "collection_contracts_missing", "collection_incompatible", "collection_invalid", "collection_kind_unsupported", "collection_mismatch", "collection_not_found", "collection_type_registry_invalid", "collection_version_unsupported", "connector_identity_changed", "connector_offline", "connector_upgrade_required", "device_authorization_failed", "durable_mutation_unsupported", "encryption_required", "expired_token", "invalid_application_authorization", "invalid_callback", "invalid_device_authorization_response", "invalid_token_response", "scope_denied", "reconnect_required", "token_exchange_failed", "transport_protocol_incompatible"];
+export type NotificationProblemCode = RegistrationProblemCode | "authorization_expired" | "invalid_operation_response" | "invalid_push_subscription" | "managed_fcm_not_declared" | "not_authorized" | "notification_criterion_not_declared" | "notification_reauthorization_required" | "notification_registration_failed" | "notification_unregistration_failed" | "notifications_not_declared" | "notifications_unavailable";
+export declare const NOTIFICATION_PROBLEM_CODES: readonly ["discovery_failed", "invalid_operation_response", "invalid_application_manifest", "invalid_request", "manifest_load_failed", "rate_limited", "temporarily_unavailable", "timeout", "authorization_expired", "invalid_operation_response", "invalid_push_subscription", "managed_fcm_not_declared", "not_authorized", "notification_criterion_not_declared", "notification_reauthorization_required", "notification_registration_failed", "notification_unregistration_failed", "notifications_not_declared", "notifications_unavailable"];
 export type DirectAccessProblemCode = "connector_offline" | "connector_upgrade_required" | "invalid_operation_response" | "not_authorized" | "operation_failed" | "temporarily_unavailable" | "timeout";
 export declare const DIRECT_ACCESS_PROBLEM_CODES: readonly ["connector_offline", "connector_upgrade_required", "invalid_operation_response", "not_authorized", "operation_failed", "temporarily_unavailable", "timeout"];
 export type SessionProblemCode = AuthorizationProblemCode | "collection_not_ready" | "collection_not_selected" | "unknown_collection";
-export declare const SESSION_PROBLEM_CODES: readonly ["discovery_failed", "invalid_application_manifest", "invalid_request", "manifest_load_failed", "rate_limited", "temporarily_unavailable", "timeout", "access_denied", "application_identity_unavailable", "approval_window_blocked", "authorization_cancelled", "authorization_replayed", "browser_required", "collection_access_denied", "collection_configuration_invalid", "collection_contracts_missing", "collection_incompatible", "collection_invalid", "collection_kind_unsupported", "collection_mismatch", "collection_not_found", "collection_type_registry_invalid", "collection_version_unsupported", "connector_identity_changed", "connector_offline", "connector_upgrade_required", "device_authorization_failed", "encryption_required", "expired_token", "invalid_application_authorization", "invalid_callback", "invalid_device_authorization_response", "invalid_token_response", "scope_denied", "reconnect_required", "token_exchange_failed", "collection_not_ready", "collection_not_selected", "unknown_collection"];
+export declare const SESSION_PROBLEM_CODES: readonly ["discovery_failed", "invalid_operation_response", "invalid_application_manifest", "invalid_request", "manifest_load_failed", "rate_limited", "temporarily_unavailable", "timeout", "access_denied", "application_identity_unavailable", "approval_window_blocked", "authorization_binding_incompatible", "authorization_cancelled", "authorization_replayed", "browser_required", "capability_contract_incompatible", "collection_access_denied", "collection_configuration_invalid", "collection_contracts_missing", "collection_incompatible", "collection_invalid", "collection_kind_unsupported", "collection_mismatch", "collection_not_found", "collection_type_registry_invalid", "collection_version_unsupported", "connector_identity_changed", "connector_offline", "connector_upgrade_required", "device_authorization_failed", "durable_mutation_unsupported", "encryption_required", "expired_token", "invalid_application_authorization", "invalid_callback", "invalid_device_authorization_response", "invalid_token_response", "scope_denied", "reconnect_required", "token_exchange_failed", "transport_protocol_incompatible", "collection_not_ready", "collection_not_selected", "unknown_collection"];
 export type CollectionSetupProblemCode = "collection_configuration_invalid" | "collection_invalid" | "collection_type_registry_invalid" | "collection_version_unsupported";
 export type CollectionDescriptionProblemCode = CommonOperationProblemCode | CollectionSetupProblemCode;
 export type CollectionReadProblemCode = CollectionDescriptionProblemCode | "invalid_path" | "operation_invalid";
@@ -34,12 +34,12 @@ export type CollectionMutationProblemCode = CollectionReadProblemCode | "concurr
 export type CollectionChangesProblemCode = CollectionDescriptionProblemCode | "change_cursor_reset";
 export type CollectionTypeProblemCode = CollectionMutationProblemCode | "type_pack_provision_failed";
 export declare const COLLECTION_SETUP_PROBLEM_CODES: readonly ["collection_configuration_invalid", "collection_invalid", "collection_type_registry_invalid", "collection_version_unsupported"];
-export declare const COLLECTION_DESCRIPTION_PROBLEM_CODES: readonly ["access_denied", "access_paused", "authorization_expired", "collection_access_denied", "connector_identity_changed", "connector_offline", "connector_upgrade_required", "direct_operation_rejected", "operation_outcome_unknown", "encryption_required", "encrypted_relay_rejected", "hosted_provider_unavailable", "insufficient_access", "invalid_encrypted_response", "invalid_operation_response", "invalid_request", "missing_grant_key", "not_authorized", "operation_cancelled", "operation_failed", "rate_limited", "relay_authorization_expired", "relay_unavailable", "temporarily_unavailable", "timeout", "unsupported_operation", "collection_configuration_invalid", "collection_invalid", "collection_type_registry_invalid", "collection_version_unsupported"];
-export declare const COLLECTION_READ_PROBLEM_CODES: readonly ["access_denied", "access_paused", "authorization_expired", "collection_access_denied", "connector_identity_changed", "connector_offline", "connector_upgrade_required", "direct_operation_rejected", "operation_outcome_unknown", "encryption_required", "encrypted_relay_rejected", "hosted_provider_unavailable", "insufficient_access", "invalid_encrypted_response", "invalid_operation_response", "invalid_request", "missing_grant_key", "not_authorized", "operation_cancelled", "operation_failed", "rate_limited", "relay_authorization_expired", "relay_unavailable", "temporarily_unavailable", "timeout", "unsupported_operation", "collection_configuration_invalid", "collection_invalid", "collection_type_registry_invalid", "collection_version_unsupported", "invalid_path", "operation_invalid"];
-export declare const COLLECTION_QUERY_PROBLEM_CODES: readonly ["access_denied", "access_paused", "authorization_expired", "collection_access_denied", "connector_identity_changed", "connector_offline", "connector_upgrade_required", "direct_operation_rejected", "operation_outcome_unknown", "encryption_required", "encrypted_relay_rejected", "hosted_provider_unavailable", "insufficient_access", "invalid_encrypted_response", "invalid_operation_response", "invalid_request", "missing_grant_key", "not_authorized", "operation_cancelled", "operation_failed", "rate_limited", "relay_authorization_expired", "relay_unavailable", "temporarily_unavailable", "timeout", "unsupported_operation", "collection_configuration_invalid", "collection_invalid", "collection_type_registry_invalid", "collection_version_unsupported", "invalid_path", "operation_invalid", "query_snapshot_changed", "sandbox_unsupported"];
-export declare const COLLECTION_MUTATION_PROBLEM_CODES: readonly ["access_denied", "access_paused", "authorization_expired", "collection_access_denied", "connector_identity_changed", "connector_offline", "connector_upgrade_required", "direct_operation_rejected", "operation_outcome_unknown", "encryption_required", "encrypted_relay_rejected", "hosted_provider_unavailable", "insufficient_access", "invalid_encrypted_response", "invalid_operation_response", "invalid_request", "missing_grant_key", "not_authorized", "operation_cancelled", "operation_failed", "rate_limited", "relay_authorization_expired", "relay_unavailable", "temporarily_unavailable", "timeout", "unsupported_operation", "collection_configuration_invalid", "collection_invalid", "collection_type_registry_invalid", "collection_version_unsupported", "invalid_path", "operation_invalid", "concurrent_modification", "invalid_preflight", "pending_mutation_unresolved"];
-export declare const COLLECTION_CHANGES_PROBLEM_CODES: readonly ["access_denied", "access_paused", "authorization_expired", "collection_access_denied", "connector_identity_changed", "connector_offline", "connector_upgrade_required", "direct_operation_rejected", "operation_outcome_unknown", "encryption_required", "encrypted_relay_rejected", "hosted_provider_unavailable", "insufficient_access", "invalid_encrypted_response", "invalid_operation_response", "invalid_request", "missing_grant_key", "not_authorized", "operation_cancelled", "operation_failed", "rate_limited", "relay_authorization_expired", "relay_unavailable", "temporarily_unavailable", "timeout", "unsupported_operation", "collection_configuration_invalid", "collection_invalid", "collection_type_registry_invalid", "collection_version_unsupported", "change_cursor_reset"];
-export declare const COLLECTION_TYPE_PROBLEM_CODES: readonly ["access_denied", "access_paused", "authorization_expired", "collection_access_denied", "connector_identity_changed", "connector_offline", "connector_upgrade_required", "direct_operation_rejected", "operation_outcome_unknown", "encryption_required", "encrypted_relay_rejected", "hosted_provider_unavailable", "insufficient_access", "invalid_encrypted_response", "invalid_operation_response", "invalid_request", "missing_grant_key", "not_authorized", "operation_cancelled", "operation_failed", "rate_limited", "relay_authorization_expired", "relay_unavailable", "temporarily_unavailable", "timeout", "unsupported_operation", "collection_configuration_invalid", "collection_invalid", "collection_type_registry_invalid", "collection_version_unsupported", "invalid_path", "operation_invalid", "concurrent_modification", "invalid_preflight", "pending_mutation_unresolved", "type_pack_provision_failed"];
+export declare const COLLECTION_DESCRIPTION_PROBLEM_CODES: readonly ["access_denied", "access_paused", "authorization_binding_incompatible", "authorization_expired", "capability_contract_incompatible", "collection_access_denied", "connector_identity_changed", "connector_offline", "connector_upgrade_required", "direct_operation_rejected", "durable_mutation_unsupported", "operation_outcome_unknown", "encryption_required", "encrypted_relay_rejected", "hosted_provider_unavailable", "insufficient_access", "invalid_encrypted_response", "invalid_operation_response", "invalid_request", "missing_grant_key", "mutation_recovery_expired", "mutation_request_conflict", "not_authorized", "operation_cancelled", "operation_failed", "rate_limited", "relay_authorization_expired", "relay_unavailable", "temporarily_unavailable", "timeout", "transport_protocol_incompatible", "unsupported_operation", "collection_configuration_invalid", "collection_invalid", "collection_type_registry_invalid", "collection_version_unsupported"];
+export declare const COLLECTION_READ_PROBLEM_CODES: readonly ["access_denied", "access_paused", "authorization_binding_incompatible", "authorization_expired", "capability_contract_incompatible", "collection_access_denied", "connector_identity_changed", "connector_offline", "connector_upgrade_required", "direct_operation_rejected", "durable_mutation_unsupported", "operation_outcome_unknown", "encryption_required", "encrypted_relay_rejected", "hosted_provider_unavailable", "insufficient_access", "invalid_encrypted_response", "invalid_operation_response", "invalid_request", "missing_grant_key", "mutation_recovery_expired", "mutation_request_conflict", "not_authorized", "operation_cancelled", "operation_failed", "rate_limited", "relay_authorization_expired", "relay_unavailable", "temporarily_unavailable", "timeout", "transport_protocol_incompatible", "unsupported_operation", "collection_configuration_invalid", "collection_invalid", "collection_type_registry_invalid", "collection_version_unsupported", "invalid_path", "operation_invalid"];
+export declare const COLLECTION_QUERY_PROBLEM_CODES: readonly ["access_denied", "access_paused", "authorization_binding_incompatible", "authorization_expired", "capability_contract_incompatible", "collection_access_denied", "connector_identity_changed", "connector_offline", "connector_upgrade_required", "direct_operation_rejected", "durable_mutation_unsupported", "operation_outcome_unknown", "encryption_required", "encrypted_relay_rejected", "hosted_provider_unavailable", "insufficient_access", "invalid_encrypted_response", "invalid_operation_response", "invalid_request", "missing_grant_key", "mutation_recovery_expired", "mutation_request_conflict", "not_authorized", "operation_cancelled", "operation_failed", "rate_limited", "relay_authorization_expired", "relay_unavailable", "temporarily_unavailable", "timeout", "transport_protocol_incompatible", "unsupported_operation", "collection_configuration_invalid", "collection_invalid", "collection_type_registry_invalid", "collection_version_unsupported", "invalid_path", "operation_invalid", "query_snapshot_changed", "sandbox_unsupported"];
+export declare const COLLECTION_MUTATION_PROBLEM_CODES: readonly ["access_denied", "access_paused", "authorization_binding_incompatible", "authorization_expired", "capability_contract_incompatible", "collection_access_denied", "connector_identity_changed", "connector_offline", "connector_upgrade_required", "direct_operation_rejected", "durable_mutation_unsupported", "operation_outcome_unknown", "encryption_required", "encrypted_relay_rejected", "hosted_provider_unavailable", "insufficient_access", "invalid_encrypted_response", "invalid_operation_response", "invalid_request", "missing_grant_key", "mutation_recovery_expired", "mutation_request_conflict", "not_authorized", "operation_cancelled", "operation_failed", "rate_limited", "relay_authorization_expired", "relay_unavailable", "temporarily_unavailable", "timeout", "transport_protocol_incompatible", "unsupported_operation", "collection_configuration_invalid", "collection_invalid", "collection_type_registry_invalid", "collection_version_unsupported", "invalid_path", "operation_invalid", "concurrent_modification", "invalid_preflight", "pending_mutation_unresolved"];
+export declare const COLLECTION_CHANGES_PROBLEM_CODES: readonly ["access_denied", "access_paused", "authorization_binding_incompatible", "authorization_expired", "capability_contract_incompatible", "collection_access_denied", "connector_identity_changed", "connector_offline", "connector_upgrade_required", "direct_operation_rejected", "durable_mutation_unsupported", "operation_outcome_unknown", "encryption_required", "encrypted_relay_rejected", "hosted_provider_unavailable", "insufficient_access", "invalid_encrypted_response", "invalid_operation_response", "invalid_request", "missing_grant_key", "mutation_recovery_expired", "mutation_request_conflict", "not_authorized", "operation_cancelled", "operation_failed", "rate_limited", "relay_authorization_expired", "relay_unavailable", "temporarily_unavailable", "timeout", "transport_protocol_incompatible", "unsupported_operation", "collection_configuration_invalid", "collection_invalid", "collection_type_registry_invalid", "collection_version_unsupported", "change_cursor_reset"];
+export declare const COLLECTION_TYPE_PROBLEM_CODES: readonly ["access_denied", "access_paused", "authorization_binding_incompatible", "authorization_expired", "capability_contract_incompatible", "collection_access_denied", "connector_identity_changed", "connector_offline", "connector_upgrade_required", "direct_operation_rejected", "durable_mutation_unsupported", "operation_outcome_unknown", "encryption_required", "encrypted_relay_rejected", "hosted_provider_unavailable", "insufficient_access", "invalid_encrypted_response", "invalid_operation_response", "invalid_request", "missing_grant_key", "mutation_recovery_expired", "mutation_request_conflict", "not_authorized", "operation_cancelled", "operation_failed", "rate_limited", "relay_authorization_expired", "relay_unavailable", "temporarily_unavailable", "timeout", "transport_protocol_incompatible", "unsupported_operation", "collection_configuration_invalid", "collection_invalid", "collection_type_registry_invalid", "collection_version_unsupported", "invalid_path", "operation_invalid", "concurrent_modification", "invalid_preflight", "pending_mutation_unresolved", "type_pack_provision_failed"];
 export declare function connectSuccess<Value>(value: Value, diagnostics?: MdbaseDiagnostic[]): ConnectSuccess<Value>;
 export declare function connectFailure<Code extends ConnectProblemCode>(problem: ConnectProblem<Code>): ConnectFailure<Code>;
 export declare function captureConnectOutcome<Value, Code extends ConnectProblemCode>(operation: () => Promise<Value>, allowedCodes: readonly Code[]): Promise<ConnectOutcome<Value, Code>>;

package/dist/outcomes.js

@@ -3,12 +3,15 @@ import { MdbaseConnectError, unknownConnectProblem } from "./errors.js";
 export const COMMON_OPERATION_PROBLEM_CODES = [
     "access_denied",
     "access_paused",
+    "authorization_binding_incompatible",
     "authorization_expired",
+    "capability_contract_incompatible",
     "collection_access_denied",
     "connector_identity_changed",
     "connector_offline",
     "connector_upgrade_required",
     "direct_operation_rejected",
+    "durable_mutation_unsupported",
     "operation_outcome_unknown",
     "encryption_required",
     "encrypted_relay_rejected",
@@ -18,6 +21,8 @@ export const COMMON_OPERATION_PROBLEM_CODES = [
     "invalid_operation_response",
     "invalid_request",
     "missing_grant_key",
+    "mutation_recovery_expired",
+    "mutation_request_conflict",
     "not_authorized",
     "operation_cancelled",
     "operation_failed",
@@ -26,11 +31,13 @@ export const COMMON_OPERATION_PROBLEM_CODES = [
     "relay_unavailable",
     "temporarily_unavailable",
     "timeout",
+    "transport_protocol_incompatible",
     "unsupported_operation"
 ];
 export const ALL_CONNECT_PROBLEM_CODES = Object.keys(CONNECT_PROBLEM_CATALOG);
 export const REGISTRATION_PROBLEM_CODES = [
     "discovery_failed",
+    "invalid_operation_response",
     "invalid_application_manifest",
     "invalid_request",
     "manifest_load_failed",
@@ -43,9 +50,11 @@ export const AUTHORIZATION_PROBLEM_CODES = [
     "access_denied",
     "application_identity_unavailable",
     "approval_window_blocked",
+    "authorization_binding_incompatible",
     "authorization_cancelled",
     "authorization_replayed",
     "browser_required",
+    "capability_contract_incompatible",
     "collection_access_denied",
     "collection_configuration_invalid",
     "collection_contracts_missing",
@@ -60,6 +69,7 @@ export const AUTHORIZATION_PROBLEM_CODES = [
     "connector_offline",
     "connector_upgrade_required",
     "device_authorization_failed",
+    "durable_mutation_unsupported",
     "encryption_required",
     "expired_token",
     "invalid_application_authorization",
@@ -68,11 +78,13 @@ export const AUTHORIZATION_PROBLEM_CODES = [
     "invalid_token_response",
     "scope_denied",
     "reconnect_required",
-    "token_exchange_failed"
+    "token_exchange_failed",
+    "transport_protocol_incompatible"
 ];
 export const NOTIFICATION_PROBLEM_CODES = [
     ...REGISTRATION_PROBLEM_CODES,
     "authorization_expired",
+    "invalid_operation_response",
     "invalid_push_subscription",
     "managed_fcm_not_declared",
     "not_authorized",

package/dist/pending-mutation-store.d.ts

@@ -0,0 +1,13 @@
+import { type MutationOperationIdentifier } from "@mdbase-dev/connect-protocol";
+import type { PendingMutation } from "./internal-types.js";
+export declare class PendingMutationStore {
+    private readonly storage;
+    private readonly baseKey;
+    constructor(storage: Storage, baseKey: string);
+    list(collectionId: string | null): PendingMutation[];
+    find(collectionId: string | null, requestId: string): PendingMutation | null;
+    identifier(pending: PendingMutation): MutationOperationIdentifier;
+    store(pending: PendingMutation): void;
+    take(requestId: string): PendingMutation | null;
+    private key;
+}

package/dist/pending-mutation-store.js

@@ -0,0 +1,64 @@
+import { isCollectionOperation, mutationOperationIdentifier } from "@mdbase-dev/connect-protocol";
+import { parseStored } from "./runtime-utils.js";
+export class PendingMutationStore {
+    storage;
+    baseKey;
+    constructor(storage, baseKey) {
+        this.storage = storage;
+        this.baseKey = baseKey;
+    }
+    list(collectionId) {
+        if (!collectionId)
+            return [];
+        const legacy = parseStored(this.storage.getItem(this.baseKey));
+        if (validPendingMutation(legacy) && legacy.collectionId === collectionId) {
+            const migratedKey = this.key(legacy.requestId);
+            if (!this.storage.getItem(migratedKey)) {
+                this.storage.setItem(migratedKey, JSON.stringify(legacy));
+            }
+            this.storage.removeItem(this.baseKey);
+        }
+        const keys = [];
+        for (let index = 0; index < this.storage.length; index += 1) {
+            const key = this.storage.key(index);
+            if (key?.startsWith(`${this.baseKey}:`))
+                keys.push(key);
+        }
+        return keys
+            .map((key) => parseStored(this.storage.getItem(key)))
+            .filter((pending) => validPendingMutation(pending) && pending.collectionId === collectionId)
+            .sort((left, right) => left.createdAt - right.createdAt
+            || left.requestId.localeCompare(right.requestId));
+    }
+    find(collectionId, requestId) {
+        return this.list(collectionId)
+            .find((pending) => pending.requestId === requestId) ?? null;
+    }
+    identifier(pending) {
+        return pending.mutation ?? mutationOperationIdentifier(pending.operation, pending.request?.input ?? (pending.operation === "sync" ? { action: "mutate" } : {})) ?? (pending.operation === "sync" ? "sync:mutate" : pending.operation);
+    }
+    store(pending) {
+        this.storage.setItem(this.key(pending.requestId), JSON.stringify(pending));
+    }
+    take(requestId) {
+        const key = this.key(requestId);
+        const pending = parseStored(this.storage.getItem(key));
+        this.storage.removeItem(key);
+        return pending;
+    }
+    key(requestId) {
+        return `${this.baseKey}:${encodeURIComponent(requestId)}`;
+    }
+}
+function validPendingMutation(pending) {
+    return Boolean(pending
+        && typeof pending.collectionId === "string"
+        && typeof pending.requestId === "string"
+        && pending.requestId.length > 0
+        && isCollectionOperation(pending.operation)
+        && typeof pending.inputFingerprint === "string"
+        && Number.isFinite(pending.createdAt)
+        && pending.createdAt > 0
+        && (pending.envelope || pending.request)
+        && (pending.operation === "sync" || mutationOperationIdentifier(pending.operation, pending.request?.input ?? {}) !== null));
+}

package/dist/request-budget.d.ts

@@ -0,0 +1,27 @@
+import type { ConnectRequestOptions } from "./operation-types.js";
+import type { MdbaseConnectTimeouts } from "./connect-options.js";
+export declare const DEFAULT_REQUEST_TIMEOUT_MS = 30000;
+export declare const DEFAULT_STARTUP_TIMEOUT_MS = 10000;
+export declare const DEFAULT_UPLOAD_TIMEOUT_MS = 120000;
+export declare const DEFAULT_SYNC_TIMEOUT_MS = 60000;
+export interface ResolvedConnectTimeouts {
+    requestMs: number | null;
+    watchStartMs: number | null;
+    uploadMs: number | null;
+    syncMs: number | null;
+}
+export declare function resolveConnectTimeouts(timeouts?: MdbaseConnectTimeouts): ResolvedConnectTimeouts;
+export interface RequestBudget {
+    readonly signal: AbortSignal;
+    readonly deadline: number | null;
+    remainingMs(): number | null;
+    dispose(): void;
+}
+export declare function createRequestBudget(options?: ConnectRequestOptions, defaultTimeoutMs?: number | null, now?: () => number): RequestBudget;
+export declare function withRequestBudget<Result>(options: ConnectRequestOptions | undefined, defaultTimeoutMs: number | null, operation: (budget: RequestBudget) => Promise<Result>): Promise<Result>;
+/**
+ * Budget an operation whose transport cooperates with AbortSignal and must run
+ * its own bounded cleanup/recovery before the public promise settles.
+ */
+export declare function withCooperativeRequestBudget<Result>(options: ConnectRequestOptions | undefined, defaultTimeoutMs: number | null, operation: (budget: RequestBudget) => Promise<Result>): Promise<Result>;
+export declare function requestAbortReason(signal: AbortSignal): unknown;

package/dist/request-budget.js

@@ -0,0 +1,95 @@
+import { MdbaseConnectError, connectError } from "./errors.js";
+export const DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
+export const DEFAULT_STARTUP_TIMEOUT_MS = 10_000;
+export const DEFAULT_UPLOAD_TIMEOUT_MS = 120_000;
+export const DEFAULT_SYNC_TIMEOUT_MS = 60_000;
+export function resolveConnectTimeouts(timeouts = {}) {
+    return {
+        requestMs: configuredTimeout(timeouts.requestMs, DEFAULT_REQUEST_TIMEOUT_MS, "requestMs"),
+        watchStartMs: configuredTimeout(timeouts.watchStartMs, DEFAULT_STARTUP_TIMEOUT_MS, "watchStartMs"),
+        uploadMs: configuredTimeout(timeouts.uploadMs, DEFAULT_UPLOAD_TIMEOUT_MS, "uploadMs"),
+        syncMs: configuredTimeout(timeouts.syncMs, DEFAULT_SYNC_TIMEOUT_MS, "syncMs")
+    };
+}
+export function createRequestBudget(options = {}, defaultTimeoutMs = DEFAULT_REQUEST_TIMEOUT_MS, now = Date.now) {
+    const configured = options.timeoutMs === undefined ? defaultTimeoutMs : options.timeoutMs;
+    const timeoutMs = configured === null ? null : validTimeout(configured);
+    const controller = new AbortController();
+    const deadline = timeoutMs === null ? null : now() + timeoutMs;
+    const abortFromCaller = () => controller.abort(options.signal?.reason);
+    if (options.signal?.aborted)
+        abortFromCaller();
+    else
+        options.signal?.addEventListener("abort", abortFromCaller, { once: true });
+    const timer = timeoutMs === null
+        ? undefined
+        : setTimeout(() => controller.abort(connectError("timeout", "The operation exceeded its request deadline.", { operationOutcome: "not_sent" })), timeoutMs);
+    let disposed = false;
+    return {
+        signal: controller.signal,
+        deadline,
+        remainingMs: () => deadline === null ? null : Math.max(0, deadline - now()),
+        dispose: () => {
+            if (disposed)
+                return;
+            disposed = true;
+            if (timer !== undefined)
+                clearTimeout(timer);
+            options.signal?.removeEventListener("abort", abortFromCaller);
+        }
+    };
+}
+export async function withRequestBudget(options, defaultTimeoutMs, operation) {
+    const budget = createRequestBudget(options, defaultTimeoutMs);
+    let rejectOnAbort;
+    const aborted = new Promise((_resolve, reject) => {
+        rejectOnAbort = reject;
+    });
+    const abort = () => rejectOnAbort?.(requestAbortReason(budget.signal));
+    budget.signal.addEventListener("abort", abort, { once: true });
+    try {
+        if (budget.signal.aborted)
+            throw requestAbortReason(budget.signal);
+        return await Promise.race([operation(budget), aborted]);
+    }
+    finally {
+        budget.signal.removeEventListener("abort", abort);
+        budget.dispose();
+    }
+}
+/**
+ * Budget an operation whose transport cooperates with AbortSignal and must run
+ * its own bounded cleanup/recovery before the public promise settles.
+ */
+export async function withCooperativeRequestBudget(options, defaultTimeoutMs, operation) {
+    const budget = createRequestBudget(options, defaultTimeoutMs);
+    try {
+        if (budget.signal.aborted)
+            throw requestAbortReason(budget.signal);
+        return await operation(budget);
+    }
+    finally {
+        budget.dispose();
+    }
+}
+export function requestAbortReason(signal) {
+    if (signal.reason instanceof MdbaseConnectError)
+        return signal.reason;
+    return connectError("operation_cancelled", "The operation was cancelled before it changed the collection.", { operationOutcome: "not_sent", cause: signal.reason });
+}
+function validTimeout(value) {
+    if (!Number.isSafeInteger(value) || value <= 0) {
+        throw new TypeError("timeoutMs must be a positive safe integer or null.");
+    }
+    return value;
+}
+function configuredTimeout(value, fallback, name) {
+    if (value === undefined)
+        return fallback;
+    if (value === null)
+        return null;
+    if (!Number.isSafeInteger(value) || value <= 0) {
+        throw new TypeError(`${name} must be a positive safe integer or null.`);
+    }
+    return value;
+}

package/dist/runtime-utils.d.ts

@@ -5,6 +5,8 @@ import type { MdbaseDeviceAuthorization } from "./authorization-types.js";
 type NetworkProblemCode = "notification_registration_failed" | "notification_unregistration_failed" | "notifications_unavailable" | "temporarily_unavailable";
 /** Normalize fetch rejection at the exact I/O boundary. */
 export declare function connectFetch(input: RequestInfo | URL, init: RequestInit | undefined, code: NetworkProblemCode, message: string): Promise<Response>;
+/** Decode JSON without allowing native syntax/body errors across the SDK boundary. */
+export declare function decodeJsonResponse(response: Response, code: string, message: string): Promise<any>;
 export declare function canonicalLoopbackUrl(value: string): string;
 export declare function createPkce(): Promise<{
     verifier: string;

package/dist/runtime-utils.js

@@ -11,6 +11,25 @@ export async function connectFetch(input, init, code, message) {
         throw connectError(code, message, { cause });
     }
 }
+/** Decode JSON without allowing native syntax/body errors across the SDK boundary. */
+export async function decodeJsonResponse(response, code, message) {
+    let text;
+    try {
+        text = await response.text();
+    }
+    catch (cause) {
+        throw serverConnectError(code, message, { status: response.status, cause });
+    }
+    if (text.trim() === "") {
+        throw serverConnectError(code, message, { status: response.status });
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch (cause) {
+        throw serverConnectError(code, message, { status: response.status, cause });
+    }
+}
 export function canonicalLoopbackUrl(value) {
     const url = new URL(value);
     if (url.protocol !== "http:"

package/dist/session.d.ts

@@ -3,9 +3,10 @@ import { MdbaseConnection, type MdbaseAuthorizationOutcome, type MdbaseAuthoriza
 import type { MdbaseAuthorizationCapabilities, MdbaseConnectionInfo } from "./connection-types.js";
 import { type AuthorizationProblemCode, type ConnectOutcome, type SessionProblemCode } from "./outcomes.js";
 import type { MdbaseSelectionHistory, MdbaseApplicationSelection } from "./selection.js";
+import type { ConnectRequestOptions } from "./operation-types.js";
 export interface MdbaseSessionConnect<Frontmatter extends JsonObject> {
     authorize(options?: MdbaseAuthorizeOptions): Promise<ConnectOutcome<MdbaseAuthorizationOutcome<Frontmatter>, AuthorizationProblemCode>>;
-    completeAuthorization(callbackUrl: string): Promise<ConnectOutcome<MdbaseAuthorizationResult<Frontmatter>, AuthorizationProblemCode>>;
+    completeAuthorization(callbackUrl: string, options?: ConnectRequestOptions): Promise<ConnectOutcome<MdbaseAuthorizationResult<Frontmatter>, AuthorizationProblemCode>>;
     connections(): MdbaseConnectionInfo[];
     connection(collectionId: string): MdbaseConnection<Frontmatter> | null;
     unavailableReason(collectionId: string): MdbaseUnavailableReason | null;
@@ -52,7 +53,7 @@ export declare class MdbaseSession<Frontmatter extends JsonObject = JsonObject>
     private transactionDepth;
     private callbackPromise;
     constructor(connect: MdbaseSessionConnect<Frontmatter>, options: MdbaseSessionOptions);
-    start(): Promise<ConnectOutcome<MdbaseSessionSnapshot<Frontmatter>, SessionProblemCode>>;
+    start(options?: ConnectRequestOptions): Promise<ConnectOutcome<MdbaseSessionSnapshot<Frontmatter>, SessionProblemCode>>;
     destroy(): void;
     getSnapshot(): MdbaseSessionSnapshot<Frontmatter>;
     subscribe(listener: () => void): () => void;
@@ -66,11 +67,11 @@ export declare class MdbaseSession<Frontmatter extends JsonObject = JsonObject>
     authorize(target: "choose" | "selected" | {
         collectionId: string;
     }, options?: Omit<MdbaseAuthorizeOptions, "operations" | "returnTo" | "target">): Promise<ConnectOutcome<MdbaseAuthorizationOutcome<Frontmatter>, SessionProblemCode>>;
-    ensureOperations(requiredOperations: CollectionOperation[]): Promise<ConnectOutcome<MdbaseAuthorizationOutcome<Frontmatter> | {
+    ensureOperations(requiredOperations: CollectionOperation[], options?: ConnectRequestOptions): Promise<ConnectOutcome<MdbaseAuthorizationOutcome<Frontmatter> | {
         kind: "unchanged";
         connection: MdbaseConnection<Frontmatter>;
     }, SessionProblemCode>>;
-    handleAuthorizationCallback(callbackUrl: string): Promise<ConnectOutcome<MdbaseConnection<Frontmatter>, AuthorizationProblemCode>>;
+    handleAuthorizationCallback(callbackUrl: string, options?: ConnectRequestOptions): Promise<ConnectOutcome<MdbaseConnection<Frontmatter>, AuthorizationProblemCode>>;
     private autoSelectOnlyConnection;
     private refresh;
     private refreshOnce;

package/dist/session.js

@@ -29,7 +29,7 @@ export class MdbaseSession {
         this.snapshot = { status: "unselected", connections: [] };
         this.refresh();
     }
-    async start() {
+    async start(options) {
         if (!this.started) {
             this.started = true;
             this.stopConnections = this.connect.onConnectionsChange(() => this.refresh());
@@ -40,7 +40,7 @@ export class MdbaseSession {
         }
         const callback = this.selection.authorizationCallback();
         if (callback) {
-            const completed = await this.handleAuthorizationCallback(callback);
+            const completed = await this.handleAuthorizationCallback(callback, options);
             if (!completed.ok)
                 return completed;
         }
@@ -124,7 +124,7 @@ export class MdbaseSession {
             this.refresh();
         }
     }
-    async ensureOperations(requiredOperations) {
+    async ensureOperations(requiredOperations, options) {
         const current = this.snapshot;
         if (current.status !== "ready") {
             return connectFailure(connectProblem("collection_not_ready", "Choose an authorized collection first."));
@@ -137,6 +137,7 @@ export class MdbaseSession {
         this.transactionDepth += 1;
         try {
             const outcome = await this.connect.authorize({
+                ...options,
                 operations: uniqueOperations([...capabilities.grantedOperations, ...capabilities.missingOperations]),
                 target: { kind: "collection", collectionId: current.collectionId },
                 returnTo: this.selection.authorizationReturnTo()
@@ -151,14 +152,14 @@ export class MdbaseSession {
             this.refresh();
         }
     }
-    handleAuthorizationCallback(callbackUrl) {
+    handleAuthorizationCallback(callbackUrl, options) {
         if (!isAuthorizationCallbackUrl(callbackUrl)) {
             return Promise.resolve(connectFailure(connectProblem("invalid_callback", "This URL is not an authorization callback.")));
         }
         if (this.callbackPromise)
             return this.callbackPromise;
         this.transactionDepth += 1;
-        const completion = this.connect.completeAuthorization(callbackUrl)
+        const completion = this.connect.completeAuthorization(callbackUrl, options)
             .then((outcome) => {
             if (!outcome.ok) {
                 const returnTo = authorizationReturnToFromProblem(outcome.problem);

package/dist/stored-token.d.ts

@@ -0,0 +1,10 @@
+import type { StoredToken } from "./internal-types.js";
+interface ReadStoredTokenOptions {
+    stored: string | null;
+    collectionId: string;
+    relayEncryption: "required" | "disabled";
+    invalidate(keyHandle?: string): void;
+    directCapable(token: StoredToken): boolean;
+}
+export declare function readStoredToken({ stored, collectionId, relayEncryption, invalidate, directCapable }: ReadStoredTokenOptions): StoredToken | null;
+export {};

package/dist/stored-token.js

@@ -0,0 +1,60 @@
+import { parseGrantScope, parseStored, validFileCapability, validStoredAuthority, validStoredEncryption } from "./runtime-utils.js";
+export function readStoredToken({ stored, collectionId, relayEncryption, invalidate, directCapable }) {
+    const token = parseStored(stored);
+    const reject = (keyHandle) => {
+        invalidate(typeof keyHandle === "string" ? keyHandle : undefined);
+        return null;
+    };
+    if (!token) {
+        if (stored)
+            reject();
+        return null;
+    }
+    if (token.version !== 1
+        || typeof token.accessToken !== "string"
+        || token.accessToken.length === 0
+        || typeof token.clientId !== "string"
+        || token.clientId.length === 0
+        || token.collectionId !== collectionId
+        || typeof token.collectionName !== "string"
+        || token.collectionName.length === 0
+        || !Array.isArray(token.operations)
+        || token.operations.some((operation) => typeof operation !== "string")
+        || typeof token.expiresAt !== "number"
+        || !Number.isFinite(token.expiresAt)
+        || (token.refreshToken !== undefined
+            && (typeof token.refreshToken !== "string" || token.refreshToken.length === 0))
+        || (token.refreshExpiresAt !== undefined
+            && (typeof token.refreshExpiresAt !== "number" || !Number.isFinite(token.refreshExpiresAt))))
+        return reject(token.keyHandle);
+    if (!parseGrantScope(token.scope))
+        return reject(token.keyHandle);
+    if (token.fileCapability && !validFileCapability(token.fileCapability)) {
+        return reject(token.keyHandle);
+    }
+    if (token.authority && !validStoredAuthority(token.authority, token.collectionId)) {
+        return reject(token.keyHandle);
+    }
+    if (relayEncryption === "required") {
+        if (token.authority) {
+            if (!token.keyHandle || !token.authority.proofPublicKey) {
+                return reject(token.keyHandle);
+            }
+        }
+        else if (!token.grantId
+            || !token.keyHandle
+            || !validStoredEncryption(token.encryption, token.collectionId)) {
+            return reject(token.keyHandle);
+        }
+    }
+    if (token.expiresAt <= Date.now()
+        && (!token.refreshToken || (token.refreshExpiresAt ?? 0) <= Date.now())) {
+        // The cloud bearer and local grant proof have separate lifetimes. Keep an
+        // encrypted local grant usable while the connector still recognizes it.
+        if (directCapable(token))
+            return token;
+        invalidate(token.keyHandle);
+        return null;
+    }
+    return token;
+}

package/dist/token-response.d.ts

@@ -0,0 +1,11 @@
+import type { StoredToken } from "./internal-types.js";
+interface StoredTokenResponseOptions {
+    body: any;
+    clientId: string;
+    keyHandle?: string;
+    previous: StoredToken | null;
+    defaultApplicationOrigin: string;
+    pinConnectorIdentity(connectorId: string, publicKey: string): void;
+}
+export declare function storedTokenFromResponse({ body, clientId, keyHandle, previous, defaultApplicationOrigin, pinConnectorIdentity }: StoredTokenResponseOptions): StoredToken;
+export {};