@mdbase-dev/connect-protocol 0.1.0-beta.100

package/dist/mutation-fingerprint.d.ts

@@ -0,0 +1,6 @@
+import { type EncryptedOperation } from "./operations.js";
+export declare const MUTATION_FINGERPRINT_SCHEMA_VERSION: 1;
+export declare const MUTATION_FINGERPRINT_DOMAIN: "mdbase-connect mutation fingerprint v1\0";
+export declare function canonicalMutationInput(input: unknown): string;
+export declare function mutationFingerprintTranscript(operation: EncryptedOperation, input: unknown): Uint8Array<ArrayBuffer>;
+export declare function mutationFingerprint(operation: EncryptedOperation, input: unknown): Promise<string>;

package/dist/mutation-fingerprint.js

@@ -0,0 +1,116 @@
+import { mutationOperationIdentifier, operationInputSchemaVersion } from "./operations.js";
+export const MUTATION_FINGERPRINT_SCHEMA_VERSION = 1;
+export const MUTATION_FINGERPRINT_DOMAIN = "mdbase-connect mutation fingerprint v1\0";
+const encoder = new TextEncoder();
+export function canonicalMutationInput(input) {
+    return canonicalize(input, new Set());
+}
+export function mutationFingerprintTranscript(operation, input) {
+    const identifier = mutationOperationIdentifier(operation, input);
+    if (identifier === null)
+        throw new TypeError("The operation is not a canonical mutation.");
+    const identifierBytes = encoder.encode(identifier);
+    const inputBytes = encoder.encode(canonicalMutationInput(input));
+    const domainBytes = encoder.encode(MUTATION_FINGERPRINT_DOMAIN);
+    const transcript = new Uint8Array(domainBytes.length + 4 + 8 + identifierBytes.length + 4 + 8 + inputBytes.length);
+    const view = new DataView(transcript.buffer);
+    let offset = 0;
+    transcript.set(domainBytes, offset);
+    offset += domainBytes.length;
+    view.setUint32(offset, MUTATION_FINGERPRINT_SCHEMA_VERSION, false);
+    offset += 4;
+    offset = writeField(transcript, view, offset, identifierBytes);
+    view.setUint32(offset, operationInputSchemaVersion(operation, input), false);
+    offset += 4;
+    writeField(transcript, view, offset, inputBytes);
+    return transcript;
+}
+export async function mutationFingerprint(operation, input) {
+    const digest = new Uint8Array(await globalThis.crypto.subtle.digest("SHA-256", mutationFingerprintTranscript(operation, input).buffer));
+    return base64Url(digest);
+}
+function canonicalize(value, ancestors) {
+    if (value === null)
+        return "null";
+    if (value === true)
+        return "true";
+    if (value === false)
+        return "false";
+    if (typeof value === "string") {
+        assertUnicodeScalarString(value);
+        return JSON.stringify(value);
+    }
+    if (typeof value === "number") {
+        if (!Number.isFinite(value))
+            throw new TypeError("Mutation input numbers must be finite.");
+        return JSON.stringify(value);
+    }
+    if (typeof value !== "object") {
+        throw new TypeError(`Mutation input contains unsupported ${typeof value}.`);
+    }
+    if (ancestors.has(value))
+        throw new TypeError("Mutation input must not contain cycles.");
+    ancestors.add(value);
+    try {
+        if (Array.isArray(value)) {
+            if (Object.getOwnPropertySymbols(value).length > 0) {
+                throw new TypeError("Mutation input must not contain symbol properties.");
+            }
+            const children = [];
+            for (let index = 0; index < value.length; index += 1) {
+                if (!Object.hasOwn(value, index))
+                    throw new TypeError("Mutation input arrays must not be sparse.");
+                children.push(canonicalize(value[index], ancestors));
+            }
+            return `[${children.join(",")}]`;
+        }
+        const prototype = Object.getPrototypeOf(value);
+        if (prototype !== Object.prototype && prototype !== null) {
+            throw new TypeError("Mutation input objects must be plain JSON objects.");
+        }
+        if (Object.getOwnPropertySymbols(value).length > 0) {
+            throw new TypeError("Mutation input must not contain symbol properties.");
+        }
+        const entries = Object.entries(value);
+        for (const [key] of entries)
+            assertUnicodeScalarString(key);
+        entries.sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0);
+        return `{${entries.map(([key, child]) => {
+            const descriptor = Object.getOwnPropertyDescriptor(value, key);
+            if (!descriptor || descriptor.get || descriptor.set) {
+                throw new TypeError("Mutation input must not contain accessor properties.");
+            }
+            return `${JSON.stringify(key)}:${canonicalize(child, ancestors)}`;
+        }).join(",")}}`;
+    }
+    finally {
+        ancestors.delete(value);
+    }
+}
+function assertUnicodeScalarString(value) {
+    for (let index = 0; index < value.length; index += 1) {
+        const unit = value.charCodeAt(index);
+        if (unit >= 0xd800 && unit <= 0xdbff) {
+            const next = value.charCodeAt(index + 1);
+            if (!(next >= 0xdc00 && next <= 0xdfff)) {
+                throw new TypeError("Mutation input strings must not contain lone surrogates.");
+            }
+            index += 1;
+        }
+        else if (unit >= 0xdc00 && unit <= 0xdfff) {
+            throw new TypeError("Mutation input strings must not contain lone surrogates.");
+        }
+    }
+}
+function writeField(transcript, view, offset, value) {
+    view.setBigUint64(offset, BigInt(value.length), false);
+    offset += 8;
+    transcript.set(value, offset);
+    return offset + value.length;
+}
+function base64Url(value) {
+    return btoa(String.fromCharCode(...value))
+        .replaceAll("+", "-")
+        .replaceAll("/", "_")
+        .replace(/=+$/u, "");
+}

package/dist/operations.d.ts

@@ -0,0 +1,15 @@
+export declare const OPERATION_CATALOG_VERSION: 1;
+export declare const COLLECTION_OPERATIONS: readonly ["describe", "changes", "read", "query", "list_views", "execute_view", "read_view_source", "create_view_source", "update_view_source", "delete_view_source", "validate", "create", "update", "delete", "rename", "read_type", "create_type", "update_type", "assess_type_pack", "apply_type_pack", "assess_collection_setup", "apply_collection_setup", "list_timers", "put_timer", "cancel_timer", "reconcile_timers", "sync"];
+export type CollectionOperation = typeof COLLECTION_OPERATIONS[number];
+export declare const FILE_CONTROL_MESSAGE_TYPES: readonly ["list_files", "open_file_upload", "open_file_download", "move_file", "delete_file", "get_file_transfer_status", "commit_file_upload", "abort_file_transfer"];
+export type FileControlMessageType = typeof FILE_CONTROL_MESSAGE_TYPES[number];
+export type EncryptedOperation = CollectionOperation | "file_control";
+export declare const MUTATING_OPERATION_IDENTIFIERS: readonly ["create_view_source", "update_view_source", "delete_view_source", "create", "update", "delete", "rename", "create_type", "update_type", "apply_type_pack", "apply_collection_setup", "put_timer", "cancel_timer", "reconcile_timers", "sync:mutate", "file_control:open_file_upload", "file_control:move_file", "file_control:delete_file", "file_control:commit_file_upload", "file_control:abort_file_transfer"];
+export type MutationOperationIdentifier = typeof MUTATING_OPERATION_IDENTIFIERS[number];
+export declare function isCollectionOperation(value: string): value is CollectionOperation;
+export declare function areCollectionOperations(values: readonly string[]): values is readonly CollectionOperation[];
+export declare function operationRequiresTimerCriterion(operation: CollectionOperation): boolean;
+export declare function isFileControlMessageType(value: string): value is FileControlMessageType;
+export declare function operationInputSchemaVersion(operation: EncryptedOperation, input: unknown): number;
+export declare function mutationOperationIdentifier(operation: EncryptedOperation, input: unknown): MutationOperationIdentifier | null;
+export declare function isMutatingOperation(operation: EncryptedOperation, input: unknown): boolean;

package/dist/operations.js

@@ -0,0 +1,194 @@
+// Generated by scripts/generate-operation-catalog.mjs. Do not edit directly.
+export const OPERATION_CATALOG_VERSION = 1;
+export const COLLECTION_OPERATIONS = [
+    "describe",
+    "changes",
+    "read",
+    "query",
+    "list_views",
+    "execute_view",
+    "read_view_source",
+    "create_view_source",
+    "update_view_source",
+    "delete_view_source",
+    "validate",
+    "create",
+    "update",
+    "delete",
+    "rename",
+    "read_type",
+    "create_type",
+    "update_type",
+    "assess_type_pack",
+    "apply_type_pack",
+    "assess_collection_setup",
+    "apply_collection_setup",
+    "list_timers",
+    "put_timer",
+    "cancel_timer",
+    "reconcile_timers",
+    "sync"
+];
+export const FILE_CONTROL_MESSAGE_TYPES = [
+    "list_files",
+    "open_file_upload",
+    "open_file_download",
+    "move_file",
+    "delete_file",
+    "get_file_transfer_status",
+    "commit_file_upload",
+    "abort_file_transfer"
+];
+const COLLECTION_MUTATION_RULES = {
+    "describe": "never",
+    "changes": "never",
+    "read": "never",
+    "query": "never",
+    "list_views": "never",
+    "execute_view": "never",
+    "read_view_source": "never",
+    "create_view_source": "always",
+    "update_view_source": "always",
+    "delete_view_source": "always",
+    "validate": "never",
+    "create": "always",
+    "update": "always",
+    "delete": "always",
+    "rename": "always",
+    "read_type": "never",
+    "create_type": "always",
+    "update_type": "always",
+    "assess_type_pack": "never",
+    "apply_type_pack": "always",
+    "assess_collection_setup": "never",
+    "apply_collection_setup": "always",
+    "list_timers": "never",
+    "put_timer": "always",
+    "cancel_timer": "always",
+    "reconcile_timers": "always",
+    "sync": "sync_action"
+};
+const COLLECTION_INPUT_SCHEMA_VERSIONS = {
+    "describe": 1,
+    "changes": 1,
+    "read": 1,
+    "query": 1,
+    "list_views": 1,
+    "execute_view": 1,
+    "read_view_source": 1,
+    "create_view_source": 1,
+    "update_view_source": 1,
+    "delete_view_source": 1,
+    "validate": 1,
+    "create": 1,
+    "update": 1,
+    "delete": 1,
+    "rename": 1,
+    "read_type": 1,
+    "create_type": 1,
+    "update_type": 1,
+    "assess_type_pack": 1,
+    "apply_type_pack": 1,
+    "assess_collection_setup": 1,
+    "apply_collection_setup": 1,
+    "list_timers": 1,
+    "put_timer": 1,
+    "cancel_timer": 1,
+    "reconcile_timers": 1,
+    "sync": 1
+};
+const FILE_CONTROL_INPUT_SCHEMA_VERSIONS = {
+    "list_files": 1,
+    "open_file_upload": 1,
+    "open_file_download": 1,
+    "move_file": 1,
+    "delete_file": 1,
+    "get_file_transfer_status": 1,
+    "commit_file_upload": 1,
+    "abort_file_transfer": 1
+};
+const MUTATING_FILE_CONTROL_MESSAGE_TYPES = new Set([
+    "open_file_upload",
+    "move_file",
+    "delete_file",
+    "commit_file_upload",
+    "abort_file_transfer"
+]);
+const NONMUTATING_DRY_RUN_OPERATIONS = new Set([
+    "delete",
+    "rename"
+]);
+export const MUTATING_OPERATION_IDENTIFIERS = [
+    "create_view_source",
+    "update_view_source",
+    "delete_view_source",
+    "create",
+    "update",
+    "delete",
+    "rename",
+    "create_type",
+    "update_type",
+    "apply_type_pack",
+    "apply_collection_setup",
+    "put_timer",
+    "cancel_timer",
+    "reconcile_timers",
+    "sync:mutate",
+    "file_control:open_file_upload",
+    "file_control:move_file",
+    "file_control:delete_file",
+    "file_control:commit_file_upload",
+    "file_control:abort_file_transfer"
+];
+const TIMER_CRITERION_OPERATIONS = new Set([
+    "list_timers",
+    "put_timer",
+    "cancel_timer",
+    "reconcile_timers"
+]);
+const COLLECTION_OPERATION_SET = new Set(COLLECTION_OPERATIONS);
+const FILE_CONTROL_MESSAGE_TYPE_SET = new Set(FILE_CONTROL_MESSAGE_TYPES);
+export function isCollectionOperation(value) {
+    return COLLECTION_OPERATION_SET.has(value);
+}
+export function areCollectionOperations(values) {
+    return values.every(isCollectionOperation);
+}
+export function operationRequiresTimerCriterion(operation) {
+    return TIMER_CRITERION_OPERATIONS.has(operation);
+}
+export function isFileControlMessageType(value) {
+    return FILE_CONTROL_MESSAGE_TYPE_SET.has(value);
+}
+export function operationInputSchemaVersion(operation, input) {
+    if (operation === "file_control") {
+        const type = isObject(input) && typeof input.type === "string" ? input.type : "";
+        if (!isFileControlMessageType(type))
+            throw new Error(`Unknown file-control message: ${type}`);
+        return FILE_CONTROL_INPUT_SCHEMA_VERSIONS[type];
+    }
+    return COLLECTION_INPUT_SCHEMA_VERSIONS[operation];
+}
+export function mutationOperationIdentifier(operation, input) {
+    const object = isObject(input) ? input : {};
+    if (object.dry_run === true && NONMUTATING_DRY_RUN_OPERATIONS.has(operation))
+        return null;
+    if (operation === "file_control") {
+        const type = typeof object.type === "string" ? object.type : "";
+        return MUTATING_FILE_CONTROL_MESSAGE_TYPES.has(type)
+            ? `file_control:${type}`
+            : null;
+    }
+    const rule = COLLECTION_MUTATION_RULES[operation];
+    if (rule === "always")
+        return operation;
+    if (rule === "sync_action" && object.action === "mutate")
+        return "sync:mutate";
+    return null;
+}
+export function isMutatingOperation(operation, input) {
+    return mutationOperationIdentifier(operation, input) !== null;
+}
+function isObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}

package/dist/type-packs.d.ts

@@ -0,0 +1,133 @@
+export interface ContractRequirement {
+    id: string;
+    /** Exact semantic version of the collection-local mdbase data contract. */
+    version: string;
+    /** Exact digest of the resolved portable contract identity. */
+    digest: string;
+}
+/** Exact identity of the standard record-created runtime event contract. */
+export declare const MDBASE_RECORD_CREATED_CONTRACT: {
+    readonly id: "mdbase.record.created";
+    readonly version: "1.0.0";
+    readonly digest: "sha256:7f3bed6baa356ee9389e977ae7b77a102e2bee871a7c1d9f2026fc21cacdbfc9";
+};
+/** Exact identity of the standard record-modified runtime event contract. */
+export declare const MDBASE_RECORD_MODIFIED_CONTRACT: {
+    readonly id: "mdbase.record.modified";
+    readonly version: "1.0.0";
+    readonly digest: "sha256:064187148a95701a1f5c749643d306d3c6708470b6b7ab0bf0c698d38dbcabe3";
+};
+/** Exact identity of the standard record-deleted runtime event contract. */
+export declare const MDBASE_RECORD_DELETED_CONTRACT: {
+    readonly id: "mdbase.record.deleted";
+    readonly version: "1.0.0";
+    readonly digest: "sha256:84e5fb0f9d3bfdcd53f76cdc5035f94c7693fdea39a8ead190b10b422dd2ee09";
+};
+/** Exact identity of the standard record-renamed runtime event contract. */
+export declare const MDBASE_RECORD_RENAMED_CONTRACT: {
+    readonly id: "mdbase.record.renamed";
+    readonly version: "1.0.0";
+    readonly digest: "sha256:c825ef8d7db775b784d7af27e6acdf6f2799d2c6440d486f5bfa78afcca71471";
+};
+/** Exact identity of the standard timer-fired runtime event contract. */
+export declare const MDBASE_TIMER_FIRED_CONTRACT: {
+    readonly id: "mdbase.runtime.timer.fired";
+    readonly version: "1.0.0";
+    readonly digest: "sha256:41105be7a7abf33b31ced47e1e1965242236e40ccaea286b959b0a8c591f5642";
+};
+export interface TypePackManifestResource {
+    kind: "contract" | "type" | "schema";
+    mode: "managed" | "seed";
+    source: string;
+    target: string;
+    digest: string;
+}
+export interface TypePackManifest {
+    kind: "mdbase.type-pack";
+    id: string;
+    version: string;
+    name?: string;
+    description?: string;
+    resources: TypePackManifestResource[];
+    [extension: `x-${string}`]: unknown;
+}
+export interface TypePackSourceResource {
+    source: string;
+    document: string;
+}
+export interface TypePackProvision {
+    /** Canonical type-pack manifest shown during approval and verified on install. */
+    manifest: TypePackManifest;
+    /** Exact UTF-8 resource bytes, keyed by each manifest source path. */
+    resources: TypePackSourceResource[];
+    /** Data contracts expected after the complete pack is installed. */
+    provides: ContractRequirement[];
+}
+export interface TypePackResourceDiff {
+    source: string;
+    target: string;
+    kind: "contract" | "type" | "schema";
+    mode: "managed" | "seed";
+    action: "create" | "update" | "delete" | "adopt" | "unchanged" | "preserve" | "conflict";
+    digest: string;
+    current_digest?: string;
+    installed_digest?: string;
+    adopted_from_digest?: string;
+    reason?: string;
+}
+export interface TypePackReceipt {
+    id: string;
+    version: string;
+    digest: string;
+    installed_by: string;
+    resources: Omit<TypePackResourceDiff, "action" | "current_digest" | "installed_digest" | "reason">[];
+}
+export interface TypePackAssessment {
+    status: "current" | "install" | "upgrade" | "downgrade" | "reconfigure" | "conflict";
+    applicable: boolean;
+    assessment_digest: string;
+    current?: TypePackReceipt;
+    desired: TypePackReceipt;
+    resources: TypePackResourceDiff[];
+    lock: {
+        target: "mdbase.lock.yaml";
+        action: "create" | "update" | "unchanged";
+        digest: string;
+    };
+    contract_setups: {
+        choices: ContractSetupChoice[];
+        resources: TypePackResourceDiff[];
+    };
+}
+export interface TypePackApplyResult extends TypePackAssessment {
+    receipt: TypePackReceipt;
+    cleanup_deferred: boolean;
+}
+export interface AssessTypePackInput {
+    provision: TypePackProvision;
+    installed_by: string;
+    /** Explicit digest-pinned consent to claim differing unmanaged managed targets. */
+    adopt_resources?: Record<string, string>;
+    /** Seed resources deliberately omitted because the user selected an existing implementation. */
+    preserve_seed_targets?: string[];
+    /** Resolve canonical manifest targets to collection-specific paths. */
+    target_overrides?: Record<string, string>;
+    /** Reviewed edits to user-owned types, committed atomically with the pack. */
+    contract_setups?: ContractSetupChoice[];
+}
+export interface ApplyTypePackInput extends AssessTypePackInput {
+    expected_assessment_digest: string;
+    allow_downgrade?: boolean;
+}
+export type ContractSetupChoice = {
+    contract: ContractRequirement;
+    mode: "starter";
+} | {
+    contract: ContractRequirement;
+    mode: "existing";
+    type_name: string;
+    /** Exact type source revision shown during approval. */
+    type_revision: string;
+    fields: Record<string, string>;
+    binding?: Record<string, unknown>;
+};

package/dist/type-packs.js

@@ -0,0 +1,30 @@
+/** Exact identity of the standard record-created runtime event contract. */
+export const MDBASE_RECORD_CREATED_CONTRACT = {
+    id: "mdbase.record.created",
+    version: "1.0.0",
+    digest: "sha256:7f3bed6baa356ee9389e977ae7b77a102e2bee871a7c1d9f2026fc21cacdbfc9",
+};
+/** Exact identity of the standard record-modified runtime event contract. */
+export const MDBASE_RECORD_MODIFIED_CONTRACT = {
+    id: "mdbase.record.modified",
+    version: "1.0.0",
+    digest: "sha256:064187148a95701a1f5c749643d306d3c6708470b6b7ab0bf0c698d38dbcabe3",
+};
+/** Exact identity of the standard record-deleted runtime event contract. */
+export const MDBASE_RECORD_DELETED_CONTRACT = {
+    id: "mdbase.record.deleted",
+    version: "1.0.0",
+    digest: "sha256:84e5fb0f9d3bfdcd53f76cdc5035f94c7693fdea39a8ead190b10b422dd2ee09",
+};
+/** Exact identity of the standard record-renamed runtime event contract. */
+export const MDBASE_RECORD_RENAMED_CONTRACT = {
+    id: "mdbase.record.renamed",
+    version: "1.0.0",
+    digest: "sha256:c825ef8d7db775b784d7af27e6acdf6f2799d2c6440d486f5bfa78afcca71471",
+};
+/** Exact identity of the standard timer-fired runtime event contract. */
+export const MDBASE_TIMER_FIRED_CONTRACT = {
+    id: "mdbase.runtime.timer.fired",
+    version: "1.0.0",
+    digest: "sha256:41105be7a7abf33b31ced47e1e1965242236e40ccaea286b959b0a8c591f5642",
+};

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@mdbase-dev/connect-protocol",
+  "version": "0.1.0-beta.100",
+  "private": false,
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mdbase-dev/mdbase-connect.git",
+    "directory": "packages/protocol"
+  },
+  "homepage": "https://mdbase.dev",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./manifest": {
+      "types": "./dist/manifest.d.ts",
+      "import": "./dist/manifest.js"
+    },
+    "./schemas/*": "./schemas/*"
+  },
+  "files": [
+    "dist",
+    "schemas"
+  ],
+  "dependencies": {
+    "ajv": "^8.20.0",
+    "ajv-formats": "^3.0.1"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "typescript": "^7.0.2"
+  },
+  "scripts": {
+    "build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.json",
+    "test": "node --test test/*.test.mjs && node ../../scripts/generate-connect-problems.mjs --check && node ../../scripts/generate-operation-catalog.mjs --check && node ../../scripts/generate-application-capabilities.mjs --check",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  }
+}

package/schemas/application-capability-catalog.v1.json

@@ -0,0 +1,40 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "catalog_version": 1,
+  "capabilities": [
+    { "id": "collection.inspect", "operations": ["describe"] },
+    { "id": "records.watch", "operations": ["changes"] },
+    { "id": "records.read", "operations": ["read"] },
+    { "id": "records.query", "operations": ["query"] },
+    { "id": "records.validate", "operations": ["validate"] },
+    { "id": "records.create", "operations": ["create"] },
+    { "id": "records.update", "operations": ["update"] },
+    { "id": "records.delete", "operations": ["delete"] },
+    { "id": "records.rename", "operations": ["rename"] },
+    { "id": "views.list", "operations": ["list_views"] },
+    { "id": "views.execute", "operations": ["execute_view"] },
+    { "id": "views.source.read", "operations": ["read_view_source"] },
+    { "id": "views.source.create", "operations": ["create_view_source"] },
+    { "id": "views.source.update", "operations": ["update_view_source"] },
+    { "id": "views.source.delete", "operations": ["delete_view_source"] },
+    { "id": "definitions.contracts.current", "operations": [] },
+    { "id": "definitions.read", "operations": ["read_type"] },
+    { "id": "definitions.create", "operations": ["create_type"] },
+    { "id": "definitions.update", "operations": ["update_type"] },
+    { "id": "definitions.type-pack.inspect", "operations": ["assess_type_pack"] },
+    { "id": "definitions.type-pack.apply", "operations": ["assess_type_pack", "apply_type_pack"] },
+    { "id": "collection.setup.apply", "operations": ["assess_collection_setup", "apply_collection_setup"] },
+    { "id": "timers.list", "operations": ["list_timers"] },
+    { "id": "timers.put", "operations": ["put_timer"] },
+    { "id": "timers.cancel", "operations": ["cancel_timer"] },
+    { "id": "timers.reconcile", "operations": ["reconcile_timers"] },
+    { "id": "sync.offline-replica", "operations": ["sync"] },
+    { "id": "notifications.background-delivery", "operations": [] },
+    { "id": "files.list", "operations": [] },
+    { "id": "files.read", "operations": [] },
+    { "id": "files.add", "operations": [] },
+    { "id": "files.replace", "operations": [] },
+    { "id": "files.move", "operations": [] },
+    { "id": "files.delete", "operations": [] }
+  ]
+}

package/schemas/application-capability-catalog.v2.json

@@ -0,0 +1,68 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "catalog_version": 2,
+  "capabilities": [
+    {
+      "id": "collection.read",
+      "operations": [
+        "describe",
+        "changes",
+        "read",
+        "query",
+        "list_views",
+        "execute_view",
+        "read_view_source",
+        "validate",
+        "read_type"
+      ]
+    },
+    {
+      "id": "records.create",
+      "operations": ["create"]
+    },
+    {
+      "id": "records.edit",
+      "operations": ["update", "rename"]
+    },
+    {
+      "id": "records.delete",
+      "operations": ["delete"]
+    },
+    {
+      "id": "views.manage",
+      "operations": [
+        "create_view_source",
+        "update_view_source",
+        "delete_view_source"
+      ]
+    },
+    {
+      "id": "definitions.manage",
+      "operations": [
+        "create_type",
+        "update_type",
+        "assess_type_pack",
+        "apply_type_pack"
+      ]
+    },
+    {
+      "id": "background.schedule",
+      "operations": [
+        "list_timers",
+        "put_timer",
+        "cancel_timer",
+        "reconcile_timers"
+      ]
+    },
+    {
+      "id": "offline.replica",
+      "operations": ["sync"]
+    }
+  ],
+  "structured_authorities": {
+    "application_setup": [
+      "assess_collection_setup",
+      "apply_collection_setup"
+    ]
+  }
+}

package/schemas/catalog.json

@@ -0,0 +1,17 @@
+{
+  "manifest_version": 1,
+  "schemas": {
+    "app_manifest": "./mdbase-app.schema.json",
+    "data_contract": "./data-contract.schema.json",
+    "event_action_interop": "./interop/v0.1/profile.schema.json",
+    "connect_protocol": "./connect-protocol.v1.schema.json",
+    "connect_problem": "./connect-problem.v1.schema.json",
+    "connect_problem_catalog": "./connect-problems.v1.catalog.json",
+    "mdbase_query_v0_3": "./mdbase-query.v0.3.schema.json",
+    "encrypted_relay": "./encrypted-relay.v3.schema.json",
+    "encrypted_relay_legacy_v2": "./encrypted-relay.v2.schema.json",
+    "files": "./files.v1.schema.json",
+    "notification_webhook": "./notification-webhook.v1.schema.json",
+    "sync": "./sync.v1.schema.json"
+  }
+}