@mdbase-dev/connect-protocol 0.1.0-beta.126 → 0.1.0-beta.148

package/dist/application-contract.d.ts

@@ -0,0 +1,23 @@
+import { type ApplicationCapabilityId, type ApplicationCapabilityRequirements, type LegacyApplicationCapabilityRequirements, type LegacyApplicationCapabilityId } from "./capabilities.js";
+import type { ApplicationRequirements, LegacyApplicationRequirements, MdbaseAppManifest, LegacyMdbaseAppManifest } from "./application-declaration.js";
+import type { CollectionOperation } from "./operations.js";
+export declare const DEFAULT_OPERATIONS: CollectionOperation[];
+/** Input compatibility boundary; protocol ApplicationRequirements remains v2-only. */
+export type MdbaseApplicationManifest = MdbaseAppManifest | LegacyMdbaseAppManifest;
+export type MdbaseApplicationRequirements = ApplicationRequirements | LegacyApplicationRequirements;
+export type MdbaseApplicationCapabilityRequirements = ApplicationCapabilityRequirements | LegacyApplicationCapabilityRequirements;
+export type MdbaseApplicationCapabilityId = ApplicationCapabilityId | LegacyApplicationCapabilityId;
+interface MdbaseAuthorizationSelection {
+    operations?: CollectionOperation[];
+    capabilities?: MdbaseApplicationCapabilityId[];
+}
+export declare function semanticContractVersion(requirements: MdbaseApplicationRequirements): 1 | 2;
+export declare function validateAuthorizationSelection(requirements: MdbaseApplicationRequirements, options: MdbaseAuthorizationSelection): void;
+export declare function declaredOperations(requirements: MdbaseApplicationRequirements): CollectionOperation[];
+export declare function authorizationOperations(application: {
+    requirements: MdbaseApplicationRequirements;
+    provisions?: MdbaseApplicationManifest["provisions"];
+}, options: MdbaseAuthorizationSelection): CollectionOperation[];
+export declare function retainedCapabilities(requirements: MdbaseApplicationRequirements, operations: CollectionOperation[]): MdbaseApplicationCapabilityId[];
+export declare function authorizationFiles(requirements: MdbaseApplicationRequirements): import("./files.js").ApplicationFileRequest | undefined;
+export {};

package/dist/application-contract.js

@@ -0,0 +1,76 @@
+import { APPLICATION_SETUP_OPERATIONS, capabilityOperationsForContractVersion } from "./capabilities.js";
+import { applicationFileRequest } from "./files.js";
+import { connectError } from "./authorization-errors.js";
+export const DEFAULT_OPERATIONS = ["describe", "changes", "read", "query"];
+export function semanticContractVersion(requirements) {
+    const version = requirements.capabilities === undefined ? 1 : requirements.capabilities?.contract_version;
+    if (version !== 1 && version !== 2)
+        invalidAuthorizationSelection("Unsupported declared capability contract version.");
+    return version;
+}
+function invalidAuthorizationSelection(message) {
+    throw connectError("invalid_application_manifest", message, {
+        details: { issues: [{ path: "/requirements/capabilities", keyword: "authorizationSelection", message, params: {} }] }
+    });
+}
+export function validateAuthorizationSelection(requirements, options) {
+    if (options.operations !== undefined && options.capabilities !== undefined) {
+        invalidAuthorizationSelection("Specify operations or capabilities, not both.");
+    }
+    if (options.operations !== undefined && semanticContractVersion(requirements) !== 1) {
+        invalidAuthorizationSelection("Exact operations authorization is only supported for legacy v1 declarations.");
+    }
+    if (options.capabilities !== undefined) {
+        const declared = new Set([
+            ...(requirements.capabilities?.required ?? []),
+            ...(requirements.capabilities?.optional ?? [])
+        ]);
+        if (options.capabilities.some((id) => !declared.has(id)
+            || capabilityOperationsForContractVersion(semanticContractVersion(requirements), id) === undefined)) {
+            invalidAuthorizationSelection("Authorization can only include capabilities declared by the application.");
+        }
+    }
+}
+export function declaredOperations(requirements) {
+    const capabilities = requirements.capabilities;
+    if (!capabilities)
+        return [...DEFAULT_OPERATIONS];
+    return [...new Set([...capabilities.required, ...(capabilities.optional ?? [])].flatMap((id) => capabilityOperationsForContractVersion(capabilities.contract_version, id) ?? []))];
+}
+export function authorizationOperations(application, options) {
+    const { requirements } = application;
+    validateAuthorizationSelection(requirements, options);
+    // Legacy callers selected independent exact operations, including subsets of declarations.
+    if (semanticContractVersion(requirements) === 1) {
+        if (options.operations !== undefined)
+            return [...new Set(options.operations)];
+        if (options.capabilities === undefined)
+            return [...DEFAULT_OPERATIONS];
+    }
+    const declared = requirements.capabilities;
+    const selected = [...(declared?.required ?? []), ...(options.capabilities ?? declared?.optional ?? [])];
+    const operations = selected.flatMap((id) => capabilityOperationsForContractVersion(semanticContractVersion(requirements), id) ?? []);
+    const hasSetup = (application.provisions?.type_packs.length ?? 0) > 0
+        || (application.provisions?.configuration?.length ?? 0) > 0;
+    return [...new Set([
+            ...operations,
+            ...(semanticContractVersion(requirements) === 2 && hasSetup ? APPLICATION_SETUP_OPERATIONS : [])
+        ])];
+}
+export function retainedCapabilities(requirements, operations) {
+    return [...(requirements.capabilities?.required ?? []), ...(requirements.capabilities?.optional ?? [])].filter((id) => (capabilityOperationsForContractVersion(semanticContractVersion(requirements), id) ?? []).every((operation) => operations.includes(operation)));
+}
+export function authorizationFiles(requirements) {
+    const files = requirements.files;
+    if (!files)
+        return undefined;
+    if (semanticContractVersion(requirements) === 1) {
+        if (!("actions" in files) || "required" in files || "optional" in files) {
+            invalidAuthorizationSelection("Legacy file declarations must use exact files.actions.");
+        }
+        return { actions: [...files.actions], scope: structuredClone(files.scope) };
+    }
+    if ("actions" in files)
+        invalidAuthorizationSelection("V2 file declarations must use required/optional file actions.");
+    return applicationFileRequest(files);
+}

package/dist/application-declaration.d.ts

@@ -0,0 +1,120 @@
+import type { ApplicationFileRequirement, LegacyApplicationFileRequirement } from "./files.js";
+import type { ApplicationCapabilityRequirements, LegacyApplicationCapabilityRequirements } from "./capabilities.js";
+import type { ContractRequirement, TypePackProvision } from "./type-packs.js";
+import type { ConfigurationProvision, ConfigurationRequirement } from "./collection-setup.js";
+export interface NotificationCriterion {
+    /** Stable, manifest-owned identifier selected by an installation. */
+    id: string;
+    /** Runtime event contract evaluated at the collection authority. */
+    event: ContractRequirement;
+    /** Canonical mdbase CEL. Event content never leaves the authority for evaluation. */
+    if?: {
+        $expr: string;
+    };
+    debounce?: string;
+    minimum_interval?: string;
+    /** Static Web Push copy. Dynamic record content is intentionally unsupported. */
+    presentation: {
+        title: string;
+        body?: string;
+        tag?: string;
+    };
+}
+export type NativeNotificationDelivery = {
+    /**
+     * Connect sends through FCM using revocable, least-privilege authority
+     * granted by the application's Firebase project.
+     */
+    mode: "managed_fcm";
+    firebase_project_id: string;
+} | {
+    /**
+     * Connect sends a signed, content-free signal to infrastructure operated
+     * by the application developer. That infrastructure owns APNs/FCM.
+     */
+    mode: "webhook";
+    url: string;
+};
+export interface ApplicationNotifications {
+    criteria: NotificationCriterion[];
+    /** Optional native delivery route. Web Push registration remains independent. */
+    native_delivery?: NativeNotificationDelivery;
+}
+/**
+ * The declaration bundled with an application build and registered inline.
+ *
+ * `id` is stable presentation metadata rather than proof of a publisher. Each
+ * exact declaration is independently identified and authorized by Connect.
+ */
+export type CanonicalApplicationRequirements = Omit<ApplicationRequirements, "access" | "contracts"> & {
+    access: "full_collection";
+    contracts: [];
+};
+interface MdbaseAppManifestBase {
+    manifest_version: 1;
+    id: string;
+    name: string;
+    /** Exact additional installation origins; part of the digest-bound declaration. */
+    installation_origins?: Partial<Record<"lab" | "staging" | "production", Partial<Record<"app-runtime" | "mobile", string[]>>>>;
+    requirements: CanonicalApplicationRequirements;
+    provisions?: ApplicationProvisions;
+    notifications?: ApplicationNotifications;
+}
+export interface MdbaseWebAppManifest extends MdbaseAppManifestBase {
+    /** Omitted by existing v1 declarations; explicit `web` is equivalent. */
+    distribution?: "web";
+    /** Runtime claim, not publisher identity. Enables literal 127.0.0.1 HTTP. */
+    platform?: "native";
+    homepage: string;
+    icon?: string;
+    redirect_uris: string[];
+}
+export interface MdbasePortableAppManifest extends MdbaseAppManifestBase {
+    /**
+     * A downloaded, publisher-unverified application opened from a local file.
+     * Portable declarations use device authorization and never claim a web origin.
+     */
+    distribution: "portable";
+    /** Optional HTTPS page where the user can inspect the project or source. */
+    project_url?: string;
+    /** Optional HTTPS icon on the project URL's origin. */
+    icon?: string;
+}
+export type MdbaseAppManifest = MdbaseWebAppManifest | MdbasePortableAppManifest;
+export interface ApplicationRequirements {
+    contracts: ContractRequirement[];
+    /** Collection extension values required before the application is ready. */
+    configuration?: ConfigurationRequirement[];
+    /** Versioned semantic intent compiled by Connect into exact operations. */
+    capabilities?: ApplicationCapabilityRequirements;
+    /**
+     * Collection boundary request. New declarations must explicitly use
+     * `full_collection`; omitted and `contract` remain parseable only for legacy
+     * diagnosis and reauthorization.
+     */
+    access?: "contract" | "full_collection";
+    /** Restrict authorization to durable provider-backed collections. */
+    collection_kind?: "hosted";
+    /** Explicit identity consent. Omission discloses no account metadata. */
+    people?: import("./people.js").ApplicationPeopleRequirement;
+    /** First-class non-Markdown file access requested independently of records. */
+    files?: ApplicationFileRequirement;
+}
+export type LegacyApplicationRequirements = Omit<ApplicationRequirements, "capabilities" | "files" | "access" | "people"> & {
+    access: "full_collection";
+    capabilities?: LegacyApplicationCapabilityRequirements;
+    files?: LegacyApplicationFileRequirement;
+};
+export type LegacyMdbaseWebAppManifest = Omit<MdbaseWebAppManifest, "requirements"> & {
+    requirements: LegacyApplicationRequirements;
+};
+export type LegacyMdbasePortableAppManifest = Omit<MdbasePortableAppManifest, "requirements"> & {
+    requirements: LegacyApplicationRequirements;
+};
+export type LegacyMdbaseAppManifest = LegacyMdbaseWebAppManifest | LegacyMdbasePortableAppManifest;
+export interface ApplicationProvisions {
+    type_packs: TypePackProvision[];
+    /** Narrow semantic changes that may satisfy configuration requirements. */
+    configuration?: ConfigurationProvision[];
+}
+export {};

package/dist/application-declaration.js

@@ -0,0 +1 @@
+export {};

package/dist/authorization-errors.d.ts

@@ -0,0 +1,34 @@
+import { type ConnectProblem, type ConnectProblemCode, type ConnectProblemDetailsByCode, type KnownConnectProblem } from "./connect-problems.generated.js";
+interface ProblemOptions {
+    operationOutcome?: ConnectProblem["operation_outcome"];
+    traceId?: string;
+    status?: number;
+    cause?: unknown;
+}
+type ProblemOptionsFor<Code extends ConnectProblemCode> = ConnectProblemDetailsByCode[Code] extends undefined ? ProblemOptions & {
+    details?: never;
+} : {} extends ConnectProblemDetailsByCode[Code] ? ProblemOptions & {
+    details?: ConnectProblemDetailsByCode[Code];
+} : ProblemOptions & {
+    details: ConnectProblemDetailsByCode[Code];
+};
+type ProblemArguments<Code extends ConnectProblemCode> = ConnectProblemDetailsByCode[Code] extends undefined ? [options?: ProblemOptionsFor<Code>] : {} extends ConnectProblemDetailsByCode[Code] ? [options?: ProblemOptionsFor<Code>] : [options: ProblemOptionsFor<Code>];
+export interface ConnectErrorContext {
+    status?: number;
+    cause?: unknown;
+}
+/** Internal carrier used while adapting throwing transports into public outcomes. */
+export declare class MdbaseConnectError extends Error {
+    readonly problem: ConnectProblem;
+    readonly code: ConnectProblem["code"];
+    readonly status?: number;
+    constructor(problem: ConnectProblem, context?: ConnectErrorContext);
+    get retryable(): boolean;
+    get requiresAuthorization(): boolean;
+    get outcomeUnknown(): boolean;
+    get recovery(): "choose_collection" | "contact_support" | "fix_request" | "none" | "reauthorize" | "refresh" | "repair_collection" | "resolve_conflict" | "resolve_outcome" | "resume_connector_access" | "retry" | "upgrade_application" | "upgrade_collection" | "upgrade_connector";
+    get details(): unknown;
+}
+export declare function connectProblem<Code extends ConnectProblemCode>(code: Code, message: string, ...[options]: ProblemArguments<Code>): KnownConnectProblem<Code>;
+export declare function connectError<Code extends ConnectProblemCode>(code: Code, message: string, ...args: ProblemArguments<Code>): MdbaseConnectError;
+export {};

package/dist/authorization-errors.js

@@ -0,0 +1,52 @@
+import { CONNECT_PROBLEM_CATALOG, CONNECT_PROBLEM_VERSION } from "./connect-problems.generated.js";
+/** Internal carrier used while adapting throwing transports into public outcomes. */
+export class MdbaseConnectError extends Error {
+    problem;
+    code;
+    status;
+    constructor(problem, context = {}) {
+        super(problem.message, context.cause === undefined ? undefined : { cause: context.cause });
+        this.problem = problem;
+        this.name = "MdbaseConnectError";
+        this.code = problem.code;
+        this.status = context.status;
+    }
+    get retryable() {
+        return this.problem.recovery === "retry"
+            && this.problem.operation_outcome !== "unknown";
+    }
+    get requiresAuthorization() {
+        return this.problem.category === "authorization";
+    }
+    get outcomeUnknown() {
+        return this.problem.operation_outcome === "unknown";
+    }
+    get recovery() {
+        return this.problem.recovery;
+    }
+    get details() {
+        return this.problem.details;
+    }
+}
+export function connectProblem(code, message, ...[options = {}]) {
+    const definition = CONNECT_PROBLEM_CATALOG[code];
+    return {
+        problem_version: CONNECT_PROBLEM_VERSION,
+        code,
+        category: definition.category,
+        recovery: definition.recovery,
+        message,
+        ...(options.details === undefined ? {} : { details: options.details }),
+        ...(options.operationOutcome === undefined
+            ? {}
+            : { operation_outcome: options.operationOutcome }),
+        ...(options.traceId === undefined ? {} : { trace_id: options.traceId })
+    };
+}
+export function connectError(code, message, ...args) {
+    const options = args[0];
+    return new MdbaseConnectError(connectProblem(code, message, ...args), {
+        status: options?.status,
+        cause: options?.cause
+    });
+}

package/dist/connect-problems.generated.d.ts

@@ -8,6 +8,10 @@ export declare const CONNECT_PROBLEM_CATALOG: {
         readonly category: "availability";
         readonly recovery: "resume_connector_access";
     };
+    readonly application_authorization_issuance_disabled: {
+        readonly category: "authorization";
+        readonly recovery: "reauthorize";
+    };
     readonly application_declaration_mismatch: {
         readonly category: "authorization";
         readonly recovery: "reauthorize";
@@ -16,6 +20,14 @@ export declare const CONNECT_PROBLEM_CATALOG: {
         readonly category: "compatibility";
         readonly recovery: "upgrade_application";
     };
+    readonly application_reauthorization_required: {
+        readonly category: "authorization";
+        readonly recovery: "reauthorize";
+    };
+    readonly application_semantic_version_mismatch: {
+        readonly category: "authorization";
+        readonly recovery: "reauthorize";
+    };
     readonly approval_window_blocked: {
         readonly category: "authorization";
         readonly recovery: "reauthorize";
@@ -60,6 +72,10 @@ export declare const CONNECT_PROBLEM_CATALOG: {
         readonly category: "authorization";
         readonly recovery: "reauthorize";
     };
+    readonly collection_claimed_by_newer_runtime: {
+        readonly category: "compatibility";
+        readonly recovery: "upgrade_connector";
+    };
     readonly collection_configuration_invalid: {
         readonly category: "validation";
         readonly recovery: "repair_collection";
@@ -100,6 +116,10 @@ export declare const CONNECT_PROBLEM_CATALOG: {
         readonly category: "validation";
         readonly recovery: "repair_collection";
     };
+    readonly collection_unavailable: {
+        readonly category: "availability";
+        readonly recovery: "choose_collection";
+    };
     readonly collection_version_unsupported: {
         readonly category: "compatibility";
         readonly recovery: "upgrade_collection";
@@ -260,6 +280,10 @@ export declare const CONNECT_PROBLEM_CATALOG: {
         readonly category: "validation";
         readonly recovery: "fix_request";
     };
+    readonly invalid_replica: {
+        readonly category: "authorization";
+        readonly recovery: "reauthorize";
+    };
     readonly invalid_request: {
         readonly category: "validation";
         readonly recovery: "fix_request";
@@ -312,6 +336,10 @@ export declare const CONNECT_PROBLEM_CATALOG: {
         readonly category: "validation";
         readonly recovery: "fix_request";
     };
+    readonly notification_grant_reauthorization_required: {
+        readonly category: "authorization";
+        readonly recovery: "reauthorize";
+    };
     readonly notification_reauthorization_required: {
         readonly category: "authorization";
         readonly recovery: "reauthorize";
@@ -348,6 +376,10 @@ export declare const CONNECT_PROBLEM_CATALOG: {
         readonly category: "conflict";
         readonly recovery: "resolve_outcome";
     };
+    readonly origin_denied: {
+        readonly category: "authorization";
+        readonly recovery: "reauthorize";
+    };
     readonly path_occupied: {
         readonly category: "conflict";
         readonly recovery: "resolve_conflict";
@@ -404,14 +436,26 @@ export declare const CONNECT_PROBLEM_CATALOG: {
         readonly category: "availability";
         readonly recovery: "retry";
     };
+    readonly replica_scope_denied: {
+        readonly category: "authorization";
+        readonly recovery: "reauthorize";
+    };
     readonly sandbox_unsupported: {
         readonly category: "compatibility";
         readonly recovery: "fix_request";
     };
+    readonly scope_changed: {
+        readonly category: "authorization";
+        readonly recovery: "reauthorize";
+    };
     readonly scope_denied: {
         readonly category: "authorization";
         readonly recovery: "reauthorize";
     };
+    readonly scope_epoch_stale: {
+        readonly category: "authorization";
+        readonly recovery: "reauthorize";
+    };
     readonly session_destroyed: {
         readonly category: "cancellation";
         readonly recovery: "none";
@@ -444,6 +488,10 @@ export declare const CONNECT_PROBLEM_CATALOG: {
         readonly category: "availability";
         readonly recovery: "retry";
     };
+    readonly timer_grant_unavailable: {
+        readonly category: "authorization";
+        readonly recovery: "reauthorize";
+    };
     readonly token_exchange_failed: {
         readonly category: "availability";
         readonly recovery: "retry";
@@ -488,8 +536,11 @@ export interface ConnectProblemDetailsByCode {
         "return_to"?: string;
     };
     "access_paused": undefined;
+    "application_authorization_issuance_disabled": undefined;
     "application_declaration_mismatch": undefined;
     "application_identity_unavailable": undefined;
+    "application_reauthorization_required": undefined;
+    "application_semantic_version_mismatch": undefined;
     "approval_window_blocked": {
         "user_code": string;
         "verification_uri": string;
@@ -519,6 +570,7 @@ export interface ConnectProblemDetailsByCode {
     };
     "change_cursor_reset": undefined;
     "collection_access_denied": undefined;
+    "collection_claimed_by_newer_runtime": undefined;
     "collection_configuration_invalid": {
         "diagnostics": Array<Record<string, unknown>>;
     };
@@ -540,6 +592,9 @@ export interface ConnectProblemDetailsByCode {
     "collection_type_registry_invalid": {
         "diagnostics": Array<Record<string, unknown>>;
     };
+    "collection_unavailable": {
+        "reason": string;
+    };
     "collection_version_unsupported": {
         "current_version": string;
         "required_version": string;
@@ -602,6 +657,7 @@ export interface ConnectProblemDetailsByCode {
     "invalid_push_payload": undefined;
     "invalid_push_subscription": undefined;
     "invalid_read_cursor": undefined;
+    "invalid_replica": undefined;
     "invalid_request": undefined;
     "invalid_token_response": undefined;
     "legacy_scope_reauthorization_required": undefined;
@@ -617,6 +673,7 @@ export interface ConnectProblemDetailsByCode {
     "not_authorized": undefined;
     "not_remote_authority": undefined;
     "notification_criterion_not_declared": undefined;
+    "notification_grant_reauthorization_required": undefined;
     "notification_reauthorization_required": undefined;
     "notification_registration_failed": undefined;
     "notification_unregistration_failed": undefined;
@@ -631,6 +688,7 @@ export interface ConnectProblemDetailsByCode {
     "operation_outcome_unknown": {
         "request_id": string;
     };
+    "origin_denied": undefined;
     "path_occupied": undefined;
     "pending_mutation_unresolved": undefined;
     "query_snapshot_changed": undefined;
@@ -647,8 +705,11 @@ export interface ConnectProblemDetailsByCode {
     "registry_schema_incompatible": undefined;
     "relay_authorization_expired": undefined;
     "relay_unavailable": undefined;
+    "replica_scope_denied": undefined;
     "sandbox_unsupported": undefined;
+    "scope_changed": undefined;
     "scope_denied": undefined;
+    "scope_epoch_stale": undefined;
     "session_destroyed": undefined;
     "session_not_started": undefined;
     "session_starting": undefined;
@@ -657,6 +718,7 @@ export interface ConnectProblemDetailsByCode {
     "sync_failed": undefined;
     "temporarily_unavailable": undefined;
     "timeout": undefined;
+    "timer_grant_unavailable": undefined;
     "token_exchange_failed": undefined;
     "transport_protocol_incompatible": {
         "contract": string;
@@ -684,6 +746,12 @@ export interface ConnectProblemByCode {
         recovery: "resume_connector_access";
         details?: never;
     };
+    "application_authorization_issuance_disabled": ConnectProblemBase & {
+        code: "application_authorization_issuance_disabled";
+        category: "authorization";
+        recovery: "reauthorize";
+        details?: never;
+    };
     "application_declaration_mismatch": ConnectProblemBase & {
         code: "application_declaration_mismatch";
         category: "authorization";
@@ -696,6 +764,18 @@ export interface ConnectProblemByCode {
         recovery: "upgrade_application";
         details?: never;
     };
+    "application_reauthorization_required": ConnectProblemBase & {
+        code: "application_reauthorization_required";
+        category: "authorization";
+        recovery: "reauthorize";
+        details?: never;
+    };
+    "application_semantic_version_mismatch": ConnectProblemBase & {
+        code: "application_semantic_version_mismatch";
+        category: "authorization";
+        recovery: "reauthorize";
+        details?: never;
+    };
     "approval_window_blocked": ConnectProblemBase & {
         code: "approval_window_blocked";
         category: "authorization";
@@ -762,6 +842,12 @@ export interface ConnectProblemByCode {
         recovery: "reauthorize";
         details?: never;
     };
+    "collection_claimed_by_newer_runtime": ConnectProblemBase & {
+        code: "collection_claimed_by_newer_runtime";
+        category: "compatibility";
+        recovery: "upgrade_connector";
+        details?: never;
+    };
     "collection_configuration_invalid": ConnectProblemBase & {
         code: "collection_configuration_invalid";
         category: "validation";
@@ -822,6 +908,12 @@ export interface ConnectProblemByCode {
         recovery: "repair_collection";
         details: ConnectProblemDetailsByCode["collection_type_registry_invalid"];
     };
+    "collection_unavailable": ConnectProblemBase & {
+        code: "collection_unavailable";
+        category: "availability";
+        recovery: "choose_collection";
+        details: ConnectProblemDetailsByCode["collection_unavailable"];
+    };
     "collection_version_unsupported": ConnectProblemBase & {
         code: "collection_version_unsupported";
         category: "compatibility";
@@ -1062,6 +1154,12 @@ export interface ConnectProblemByCode {
         recovery: "fix_request";
         details?: never;
     };
+    "invalid_replica": ConnectProblemBase & {
+        code: "invalid_replica";
+        category: "authorization";
+        recovery: "reauthorize";
+        details?: never;
+    };
     "invalid_request": ConnectProblemBase & {
         code: "invalid_request";
         category: "validation";
@@ -1140,6 +1238,12 @@ export interface ConnectProblemByCode {
         recovery: "fix_request";
         details?: never;
     };
+    "notification_grant_reauthorization_required": ConnectProblemBase & {
+        code: "notification_grant_reauthorization_required";
+        category: "authorization";
+        recovery: "reauthorize";
+        details?: never;
+    };
     "notification_reauthorization_required": ConnectProblemBase & {
         code: "notification_reauthorization_required";
         category: "authorization";
@@ -1194,6 +1298,12 @@ export interface ConnectProblemByCode {
         recovery: "resolve_outcome";
         details: ConnectProblemDetailsByCode["operation_outcome_unknown"];
     };
+    "origin_denied": ConnectProblemBase & {
+        code: "origin_denied";
+        category: "authorization";
+        recovery: "reauthorize";
+        details?: never;
+    };
     "path_occupied": ConnectProblemBase & {
         code: "path_occupied";
         category: "conflict";
@@ -1278,18 +1388,36 @@ export interface ConnectProblemByCode {
         recovery: "retry";
         details?: never;
     };
+    "replica_scope_denied": ConnectProblemBase & {
+        code: "replica_scope_denied";
+        category: "authorization";
+        recovery: "reauthorize";
+        details?: never;
+    };
     "sandbox_unsupported": ConnectProblemBase & {
         code: "sandbox_unsupported";
         category: "compatibility";
         recovery: "fix_request";
         details?: never;
     };
+    "scope_changed": ConnectProblemBase & {
+        code: "scope_changed";
+        category: "authorization";
+        recovery: "reauthorize";
+        details?: never;
+    };
     "scope_denied": ConnectProblemBase & {
         code: "scope_denied";
         category: "authorization";
         recovery: "reauthorize";
         details?: never;
     };
+    "scope_epoch_stale": ConnectProblemBase & {
+        code: "scope_epoch_stale";
+        category: "authorization";
+        recovery: "reauthorize";
+        details?: never;
+    };
     "session_destroyed": ConnectProblemBase & {
         code: "session_destroyed";
         category: "cancellation";
@@ -1338,6 +1466,12 @@ export interface ConnectProblemByCode {
         recovery: "retry";
         details?: never;
     };
+    "timer_grant_unavailable": ConnectProblemBase & {
+        code: "timer_grant_unavailable";
+        category: "authorization";
+        recovery: "reauthorize";
+        details?: never;
+    };
     "token_exchange_failed": ConnectProblemBase & {
         code: "token_exchange_failed";
         category: "availability";