@mdbase-dev/sdk 0.0.0-stage → 0.1.0-beta.153

package/node_modules/@mdbase-dev/connect-protocol/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/node_modules/@mdbase-dev/connect-protocol/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/node_modules/@mdbase-dev/connect-protocol/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/node_modules/@mdbase-dev/connect-protocol/dist/application-declaration.js

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

package/node_modules/@mdbase-dev/connect-protocol/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/node_modules/@mdbase-dev/connect-protocol/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/node_modules/@mdbase-dev/connect-protocol/dist/capabilities.d.ts

@@ -0,0 +1,73 @@
+import type { CollectionOperation } from "./operations.js";
+export declare const APPLICATION_CAPABILITY_CONTRACT_VERSION: 2;
+export declare const APPLICATION_CAPABILITY_DEFINITIONS: {
+    readonly "collection.read": readonly ["describe", "changes", "read", "query", "list_views", "execute_view", "read_view_source", "validate", "read_type"];
+    readonly "records.create": readonly ["create"];
+    readonly "records.edit": readonly ["update", "rename"];
+    readonly "records.delete": readonly ["delete"];
+    readonly "views.manage": readonly ["create_view_source", "update_view_source", "delete_view_source"];
+    readonly "definitions.manage": readonly ["create_type", "update_type", "assess_type_pack", "apply_type_pack"];
+    readonly "background.schedule": readonly ["list_timers", "put_timer", "cancel_timer", "reconcile_timers"];
+    readonly "offline.replica": readonly ["sync"];
+};
+export declare const APPLICATION_SETUP_OPERATIONS: readonly ["assess_collection_setup", "apply_collection_setup"];
+export type ApplicationCapabilityId = keyof typeof APPLICATION_CAPABILITY_DEFINITIONS;
+export interface ApplicationCapabilityRequirements {
+    contract_version: typeof APPLICATION_CAPABILITY_CONTRACT_VERSION;
+    required: ApplicationCapabilityId[];
+    optional?: ApplicationCapabilityId[];
+}
+export declare function operationsForApplicationCapabilities(requirements: ApplicationCapabilityRequirements, options?: {
+    includeOptional?: boolean;
+}): CollectionOperation[];
+export declare function capabilityOperations(capability: ApplicationCapabilityId): CollectionOperation[];
+export declare function applicationOperationSelectionIsAtomic(requirements: ApplicationCapabilityRequirements, operations: readonly string[]): boolean;
+export declare const APPLICATION_CAPABILITY_V1_CONTRACT_VERSION: 1;
+export declare const APPLICATION_CAPABILITY_V1_DEFINITIONS: Readonly<{
+    readonly "collection.inspect": readonly ["describe"];
+    readonly "records.watch": readonly ["changes"];
+    readonly "records.read": readonly ["read"];
+    readonly "records.query": readonly ["query"];
+    readonly "records.validate": readonly ["validate"];
+    readonly "records.create": readonly ["create"];
+    readonly "records.update": readonly ["update"];
+    readonly "records.delete": readonly ["delete"];
+    readonly "records.rename": readonly ["rename"];
+    readonly "views.list": readonly ["list_views"];
+    readonly "views.execute": readonly ["execute_view"];
+    readonly "views.source.read": readonly ["read_view_source"];
+    readonly "views.source.create": readonly ["create_view_source"];
+    readonly "views.source.update": readonly ["update_view_source"];
+    readonly "views.source.delete": readonly ["delete_view_source"];
+    readonly "definitions.contracts.current": readonly [];
+    readonly "definitions.read": readonly ["read_type"];
+    readonly "definitions.create": readonly ["create_type"];
+    readonly "definitions.update": readonly ["update_type"];
+    readonly "definitions.type-pack.inspect": readonly ["assess_type_pack"];
+    readonly "definitions.type-pack.apply": readonly ["assess_type_pack", "apply_type_pack"];
+    readonly "collection.setup.apply": readonly ["assess_collection_setup", "apply_collection_setup"];
+    readonly "timers.list": readonly ["list_timers"];
+    readonly "timers.put": readonly ["put_timer"];
+    readonly "timers.cancel": readonly ["cancel_timer"];
+    readonly "timers.reconcile": readonly ["reconcile_timers"];
+    readonly "sync.offline-replica": readonly ["sync"];
+    readonly "notifications.background-delivery": readonly [];
+    readonly "files.list": readonly [];
+    readonly "files.read": readonly [];
+    readonly "files.add": readonly [];
+    readonly "files.replace": readonly [];
+    readonly "files.move": readonly [];
+    readonly "files.delete": readonly [];
+}>;
+export type LegacyApplicationCapabilityId = keyof typeof APPLICATION_CAPABILITY_V1_DEFINITIONS;
+export interface LegacyApplicationCapabilityRequirements {
+    contract_version: typeof APPLICATION_CAPABILITY_V1_CONTRACT_VERSION;
+    required: LegacyApplicationCapabilityId[];
+    optional?: LegacyApplicationCapabilityId[];
+}
+export declare function capabilityOperationsForContractVersion(contractVersion: number, capability: string): CollectionOperation[] | undefined;
+/** Fresh issuance only; never use this ceiling to reject retained authority or terminal replay. */
+export declare const FRESH_APPLICATION_AUTHORIZATION_VERSIONS: readonly [1, 2];
+export declare const APPLICATION_AUTHORIZATION_V2_ISSUANCE_CAPABILITY: "application-authorization-v2-issuance";
+export declare const FRESH_APPLICATION_AUTHORIZATION_CAPABILITIES: readonly string[];
+export declare function permitsFreshApplicationAuthorization(version: number): boolean;

package/node_modules/@mdbase-dev/connect-protocol/dist/capabilities.js

@@ -0,0 +1,92 @@
+// Generated by scripts/generate-application-capabilities.mjs. Do not edit directly.
+export const APPLICATION_CAPABILITY_CONTRACT_VERSION = 2;
+export const APPLICATION_CAPABILITY_DEFINITIONS = {
+    "collection.read": ["describe", "changes", "read", "query", "list_views", "execute_view", "read_view_source", "validate", "read_type"],
+    "records.create": ["create"],
+    "records.edit": ["update", "rename"],
+    "records.delete": ["delete"],
+    "views.manage": ["create_view_source", "update_view_source", "delete_view_source"],
+    "definitions.manage": ["create_type", "update_type", "assess_type_pack", "apply_type_pack"],
+    "background.schedule": ["list_timers", "put_timer", "cancel_timer", "reconcile_timers"],
+    "offline.replica": ["sync"]
+};
+export const APPLICATION_SETUP_OPERATIONS = [
+    "assess_collection_setup",
+    "apply_collection_setup"
+];
+export function operationsForApplicationCapabilities(requirements, options = {}) {
+    const capabilities = options.includeOptional === false
+        ? requirements.required
+        : [...requirements.required, ...(requirements.optional ?? [])];
+    return [...new Set(capabilities.flatMap((capability) => APPLICATION_CAPABILITY_DEFINITIONS[capability]))];
+}
+export function capabilityOperations(capability) {
+    return [...APPLICATION_CAPABILITY_DEFINITIONS[capability]];
+}
+export function applicationOperationSelectionIsAtomic(requirements, operations) {
+    const selected = new Set(operations);
+    const declared = [...requirements.required, ...(requirements.optional ?? [])];
+    const allowed = new Set(declared.flatMap((capability) => APPLICATION_CAPABILITY_DEFINITIONS[capability]));
+    if ([...selected].some((operation) => !allowed.has(operation))) {
+        return false;
+    }
+    return declared.every((capability) => {
+        const capabilityOperations = APPLICATION_CAPABILITY_DEFINITIONS[capability];
+        const count = capabilityOperations.filter((operation) => selected.has(operation)).length;
+        return requirements.required.includes(capability)
+            ? count === capabilityOperations.length
+            : count === 0 || count === capabilityOperations.length;
+    });
+}
+// Frozen predecessor catalog. Lookup availability does not imply declaration acceptance.
+export const APPLICATION_CAPABILITY_V1_CONTRACT_VERSION = 1;
+export const APPLICATION_CAPABILITY_V1_DEFINITIONS = Object.freeze({
+    "collection.inspect": Object.freeze(["describe"]),
+    "records.watch": Object.freeze(["changes"]),
+    "records.read": Object.freeze(["read"]),
+    "records.query": Object.freeze(["query"]),
+    "records.validate": Object.freeze(["validate"]),
+    "records.create": Object.freeze(["create"]),
+    "records.update": Object.freeze(["update"]),
+    "records.delete": Object.freeze(["delete"]),
+    "records.rename": Object.freeze(["rename"]),
+    "views.list": Object.freeze(["list_views"]),
+    "views.execute": Object.freeze(["execute_view"]),
+    "views.source.read": Object.freeze(["read_view_source"]),
+    "views.source.create": Object.freeze(["create_view_source"]),
+    "views.source.update": Object.freeze(["update_view_source"]),
+    "views.source.delete": Object.freeze(["delete_view_source"]),
+    "definitions.contracts.current": Object.freeze([]),
+    "definitions.read": Object.freeze(["read_type"]),
+    "definitions.create": Object.freeze(["create_type"]),
+    "definitions.update": Object.freeze(["update_type"]),
+    "definitions.type-pack.inspect": Object.freeze(["assess_type_pack"]),
+    "definitions.type-pack.apply": Object.freeze(["assess_type_pack", "apply_type_pack"]),
+    "collection.setup.apply": Object.freeze(["assess_collection_setup", "apply_collection_setup"]),
+    "timers.list": Object.freeze(["list_timers"]),
+    "timers.put": Object.freeze(["put_timer"]),
+    "timers.cancel": Object.freeze(["cancel_timer"]),
+    "timers.reconcile": Object.freeze(["reconcile_timers"]),
+    "sync.offline-replica": Object.freeze(["sync"]),
+    "notifications.background-delivery": Object.freeze([]),
+    "files.list": Object.freeze([]),
+    "files.read": Object.freeze([]),
+    "files.add": Object.freeze([]),
+    "files.replace": Object.freeze([]),
+    "files.move": Object.freeze([]),
+    "files.delete": Object.freeze([])
+});
+export function capabilityOperationsForContractVersion(contractVersion, capability) {
+    const definitions = contractVersion === 1 ? APPLICATION_CAPABILITY_V1_DEFINITIONS
+        : contractVersion === 2 ? APPLICATION_CAPABILITY_DEFINITIONS : undefined;
+    if (!definitions || !Object.hasOwn(definitions, capability))
+        return undefined;
+    return [...definitions[capability]];
+}
+/** Fresh issuance only; never use this ceiling to reject retained authority or terminal replay. */
+export const FRESH_APPLICATION_AUTHORIZATION_VERSIONS = Object.freeze([1, 2]);
+export const APPLICATION_AUTHORIZATION_V2_ISSUANCE_CAPABILITY = "application-authorization-v2-issuance";
+export const FRESH_APPLICATION_AUTHORIZATION_CAPABILITIES = Object.freeze(["application-authorization-v2-issuance"]);
+export function permitsFreshApplicationAuthorization(version) {
+    return FRESH_APPLICATION_AUTHORIZATION_VERSIONS.some((supported) => supported === version);
+}

package/node_modules/@mdbase-dev/connect-protocol/dist/change-events.generated.d.ts

@@ -0,0 +1,48 @@
+import type { CollectionFileDescriptor } from "./files.js";
+export declare const CHANGE_EVENT_KINDS: {
+    readonly "mdbase.record.created": "record.created";
+    readonly "mdbase.record.modified": "record.updated";
+    readonly "mdbase.record.deleted": "record.deleted";
+    readonly "mdbase.record.renamed": "record.renamed";
+    readonly "mdbase.type.changed": "schema.changed";
+    readonly "mdbase.config.changed": "config.changed";
+    readonly "mdbase.contract.changed": "contract.changed";
+    readonly "mdbase.view.changed": "view.changed";
+    readonly "mdbase.view_source.changed": "view.changed";
+    readonly "mdbase.resource.changed": "file.changed";
+    readonly "mdbase.file.put": "file.put";
+    readonly "mdbase.file.remove": "file.removed";
+    readonly file_put: "file.put";
+    readonly file_remove: "file.removed";
+    readonly "mdbase.collection.invalidated": "gap";
+};
+export type KnownCollectionChangeType = keyof typeof CHANGE_EVENT_KINDS;
+/** Optional metadata: older authorities may omit fields; null means unavailable. */
+export interface RecordChangePayload {
+    path?: string | null;
+    from?: string | null;
+    to?: string | null;
+    previous_revision?: string | null;
+    revision?: string | null;
+    previous_types?: string[] | null;
+    types?: string[] | null;
+    changed_fields?: string[] | null;
+    body_changed?: boolean | null;
+    before?: Record<string, unknown> | null;
+    after?: Record<string, unknown> | null;
+}
+/** Optional metadata: older authorities may omit fields; null means unavailable. */
+export interface ResourceChangePayload {
+    name?: string | null;
+    path?: string | null;
+    previous_revision?: string | null;
+    revision?: string | null;
+    reason?: string | null;
+}
+/** Optional metadata: older authorities may omit fields; null means unavailable. */
+export interface FileChangePayload {
+    file?: CollectionFileDescriptor | null;
+    file_id?: string | null;
+    previous_path?: string | null;
+    revision?: string | null;
+}

package/node_modules/@mdbase-dev/connect-protocol/dist/change-events.generated.js

@@ -0,0 +1,18 @@
+// Generated by scripts/generate-change-events.mjs. Do not edit directly.
+export const CHANGE_EVENT_KINDS = {
+    "mdbase.record.created": "record.created",
+    "mdbase.record.modified": "record.updated",
+    "mdbase.record.deleted": "record.deleted",
+    "mdbase.record.renamed": "record.renamed",
+    "mdbase.type.changed": "schema.changed",
+    "mdbase.config.changed": "config.changed",
+    "mdbase.contract.changed": "contract.changed",
+    "mdbase.view.changed": "view.changed",
+    "mdbase.view_source.changed": "view.changed",
+    "mdbase.resource.changed": "file.changed",
+    "mdbase.file.put": "file.put",
+    "mdbase.file.remove": "file.removed",
+    "file_put": "file.put",
+    "file_remove": "file.removed",
+    "mdbase.collection.invalidated": "gap"
+};

package/node_modules/@mdbase-dev/connect-protocol/dist/collection-setup.d.ts

@@ -0,0 +1,93 @@
+import type { ContractSetupChoice, TypePackAssessment, TypePackProvision, TypePackReceipt } from "./type-packs.js";
+/**
+ * The one core configuration target: an application may add a record format
+ * its data is stored as. Every other target is inside an `x-*` namespace.
+ */
+export declare const RECORD_EXTENSIONS_CONFIGURATION_PATH: "/settings/record_extensions";
+/** The connector's engine reads `.base` files as YAML document records (mdbase spec Chapter 03). */
+export declare const YAML_DOCUMENT_RECORDS_CAPABILITY: "yaml-document-records-v1";
+export type ConfigurationContributionValue = string | number | boolean | null;
+export interface ConfigurationRequirement {
+    id: string;
+    path: string;
+    predicate: "contains";
+    value: ConfigurationContributionValue;
+}
+export interface ConfigurationProvision {
+    requirement: string;
+    operation: "set_add";
+    path: string;
+    value: ConfigurationContributionValue;
+}
+export interface ApplicationCollectionSetupRequirements {
+    configuration: ConfigurationRequirement[];
+}
+export interface ApplicationCollectionSetupProvisions {
+    configuration: ConfigurationProvision[];
+    type_packs: TypePackProvision[];
+}
+export interface AssessCollectionSetupInput {
+    /** Stable application declaration id, not the server's database id. */
+    application_id: string;
+    /** Exact canonical digest of the complete registered application declaration. */
+    declaration_digest: string;
+    requirements: ApplicationCollectionSetupRequirements;
+    provisions: ApplicationCollectionSetupProvisions;
+    /** Collection-owner choices for user-owned contract implementations. */
+    contract_setups?: ContractSetupChoice[];
+    /** Digest-pinned consent to adopt unmanaged managed resources, keyed by pack id and target. */
+    type_pack_adoptions?: Record<string, Record<string, string>>;
+}
+export interface ApplyCollectionSetupInput extends AssessCollectionSetupInput {
+    expected_assessment_digest: string;
+    expected_collection_revision: string;
+    expected_provision_digest: string;
+    allow_type_pack_downgrades?: string[];
+}
+export interface ConfigurationSetupConflict {
+    code: "configuration_path_conflict" | "configuration_type_conflict";
+    path: string;
+    expected: "mapping" | "sequence";
+    observed: "null" | "boolean" | "number" | "string" | "sequence" | "mapping" | "tagged";
+    message: string;
+}
+export interface ConfigurationSetupAssessment {
+    requirement: string;
+    path: string;
+    value: ConfigurationContributionValue;
+    action: "current" | "add" | "conflict";
+    conflict?: ConfigurationSetupConflict;
+}
+export interface CollectionSetupAssessment {
+    status: "current" | "provision" | "conflict";
+    applicable: boolean;
+    application_id: string;
+    declaration_digest: string;
+    provision_digest: string;
+    /** Revision of the setup inputs (configuration, locks, definitions); record edits do not change it. */
+    collection_revision: string;
+    final_collection_revision: string;
+    configuration: ConfigurationSetupAssessment[];
+    type_packs: TypePackAssessment[];
+    final_resource_revisions: Record<string, string>;
+    assessment_digest: string;
+}
+export interface ConfigurationContributionReceipt {
+    requirement: string;
+    path: string;
+    value: ConfigurationContributionValue;
+}
+export interface CollectionSetupReceipt {
+    application_id: string;
+    declaration_digest: string;
+    provision_digest: string;
+    assessment_digest: string;
+    collection_revision: string;
+    configuration: ConfigurationContributionReceipt[];
+    type_packs: TypePackReceipt[];
+    cleanup_deferred: boolean;
+}
+export interface CollectionSetupApplyResult {
+    assessment: CollectionSetupAssessment;
+    receipt: CollectionSetupReceipt;
+}

package/node_modules/@mdbase-dev/connect-protocol/dist/collection-setup.js

@@ -0,0 +1,7 @@
+/**
+ * The one core configuration target: an application may add a record format
+ * its data is stored as. Every other target is inside an `x-*` namespace.
+ */
+export const RECORD_EXTENSIONS_CONFIGURATION_PATH = "/settings/record_extensions";
+/** The connector's engine reads `.base` files as YAML document records (mdbase spec Chapter 03). */
+export const YAML_DOCUMENT_RECORDS_CAPABILITY = "yaml-document-records-v1";