@mdbase-dev/connect 0.1.0-beta.93 → 0.1.0-beta.95

package/README.md

@@ -151,6 +151,46 @@ versioned capabilities in their manifest; they never maintain a parallel array
 of protocol operations. Use `getSnapshot()` and `subscribe()` directly or
 through your framework's external-store integration.
 
+### Legacy v1 and capability-group v2 declarations
+
+The same SDK accepts both declaration versions without translating legacy exact
+operations into broader groups. `requirements.capabilities.contract_version`
+selects the semantics; an absent capability declaration means legacy v1.
+`manifest_version` remains the document-format version, not this selector.
+
+- **V1:** `authorize({ operations })`, `connection.requestOperations(operations)`,
+  and `session.ensureOperations(operations)` retain independent exact operations.
+  Incremental requests retain the existing exact grant. Legacy `files.actions`
+  and capability aliases (for example `records.update` and `files.read`) remain
+  supported. Bare registry/connection `authorize()` retains the predecessor's
+  `describe, changes, read, query` default; application sessions derive their
+  exact operation selection from the legacy capability declaration.
+- **V2:** use `capabilities`, `requestCapabilities()`, and `ensureCapabilities()`.
+  Required groups are always included; omitted optional selection requests all
+  declared optional groups. Incremental requests retain already granted declared
+  groups. Files use `required`/`optional` actions.
+
+Mixing `operations` and `capabilities`, or using an operations authorization API
+with a v2 declaration, returns `invalid_application_manifest`, including for
+JavaScript callers and already-sufficient grants. A rejected v2 request is never
+retried as v1. Saved credentials and pending mutations are not translated or
+replayed when selecting a semantic version; signed authorization retains its
+registered declaration digest and exact recovery-transport requirements.
+
+The SDK's `MdbaseAppManifest` and capability input types are explicit v1/v2
+unions. `LegacyMdbaseAppManifest`, `LegacyApplicationRequirements`, and
+`MdbaseApplicationRequirements` are available for explicit annotations. The
+protocol package's canonical `ApplicationRequirements` remains v2-only.
+Application sessions still require an explicit full-collection, versioned
+capability declaration; no-capability legacy declarations can use the registry
+or advanced session APIs.
+
+This bridge is not a v2 readiness or rollout gate: structured v2 file,
+notification, offline-runtime, and authority readiness evidence remains
+incomplete. Legacy readiness aliases are evaluated only for v1. Positive server
+and selected-authority v2 support gating remains separate work; this SDK change
+does not advertise new support or authorize automatic consumer conversion.
+
 Before and during startup the session distinguishes `not_started`, `starting`,
 and `start_failed`; the last state carries the original typed problem and a
 later `start()` retries. `destroyed` is terminal. Once started, the session
@@ -304,22 +344,17 @@ documents both threat models. New or changed declaration criteria never silently
 broaden an existing grant: handle `notification_reauthorization_required` by
 running authorization again before retrying registration.
 
-Before opening a feature, inspect its exact authorization gap instead of
-waiting for an operation to fail:
+Before opening a feature, request its declared capability group instead of
+selecting individual transport operations:
 
 ```ts
-const required = ["read", "query", "update"] as const;
-const capabilities = connection.authorizationCapabilities([...required]);
-if (!capabilities.sufficient) {
-  console.log("Needs", capabilities.missingOperations);
-  await connection.requestOperations([...required]);
-}
+await connection.requestCapabilities(["records.edit"]);
 ```
 
-`requestOperations()` is a no-op when the current grant is sufficient. When a
-replacement grant is needed, it requests the least-privilege union of the
-already granted operations and the missing requirements. An
-An `insufficient_access` problem carries the same `granted_operations`,
+`requestCapabilities()` is a no-op when the current grant already includes the
+complete group. When authorization is needed, required groups remain fixed and
+the requested optional groups are expanded atomically. An
+`insufficient_access` problem carries the internal `granted_operations`,
 `missing_operations`, and `required_operations` metadata with a `reauthorize`
 recovery action.
 
@@ -346,11 +381,11 @@ When the local connector definitively rejects an encrypted grant, the SDK does
 not bypass that decision through the relay. It classifies the error as requiring
 authorization, removes only the matching stale credential, and emits a `null`
 connection through `onConnectionChange()`. A subsequent
-`requestOperations()` call therefore starts authorization instead of trusting
+`requestCapabilities()` call therefore starts authorization instead of trusting
 the stale cached capability list.
 
-Applications with full collection access can also register and maintain type
-definitions. Type source is returned with a revision token so updates cannot
+Applications can register and maintain type definitions when their
+collection-wide grant includes the corresponding operations. Type source is returned with a revision token so updates cannot
 silently overwrite a definition changed by another application:
 
 ```ts
@@ -379,7 +414,8 @@ if (!updatedType.ok) renderProblem(updatedType.problem);
 ```
 
 Request `read_type`, `create_type`, and `update_type` during authorization.
-Contract-scoped applications cannot manage collection-wide type definitions.
+A legacy contract-scoped grant is inactive and must be reauthorized; contracts
+themselves never confer type-management permission.
 
 To install a complete catalog pack without exposing its individual collection
 paths, request `assess_type_pack` and `apply_type_pack`, fetch and verify the
@@ -501,6 +537,7 @@ export const manifest = {
   homepage: "https://worklog.example",
   redirect_uris: ["https://worklog.example/auth/mdbase/callback"],
   requirements: {
+    access: "full_collection",
     contracts: workItemPack.provides
   },
   provisions: {
@@ -513,10 +550,11 @@ Set `collection_kind` to `hosted` when the application needs a durable
 provider-backed collection and the offline sync transport returned by
 `sync()`. Connect then offers and accepts collections with replication capability.
 
-Access defaults to the record types supplied by `requirements.contracts`.
-Set `access` to `full_collection` when the application needs collection-level
-features such as saved views. Required contracts still determine compatibility
-and are provisioned during approval.
+Every SDK manifest must explicitly set `requirements.access` to the N-1 wire
+spelling `full_collection`. An active grant covers the entire selected
+collection; omission and legacy `contract` scope never satisfy application
+access and require reauthorization. Required contracts remain separate
+compatibility, setup, validation, and semantic-adapter evidence.
 
 `listViews()` returns each named view's selected result properties in display
 order. Property descriptors retain source labels for projected and computed
@@ -524,7 +562,7 @@ values. `executeView()` returns their values on each result row.
 
 Provisioning is part of the approval flow. The connector validates and
 installs each missing type pack transactionally, verifies its exact contracts
-and implementations, and creates the scoped grant afterward. The application
+and implementations, and creates the collection grant afterward. The application
 is not granted collection-wide type-management access.
 
 The SDK returns typed outcomes, carries successful mdbase diagnostics alongside

package/dist/application-contract.d.ts

@@ -0,0 +1,22 @@
+import { type ApplicationCapabilityId, type ApplicationCapabilityRequirements, type LegacyApplicationCapabilityRequirements, type LegacyApplicationCapabilityId, type ApplicationRequirements, type LegacyApplicationRequirements, type MdbaseAppManifest, type LegacyMdbaseAppManifest, type CollectionOperation } from "@mdbase-dev/connect-protocol";
+export declare const DEFAULT_OPERATIONS: CollectionOperation[];
+/** SDK 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 invalidAuthorizationSelection(message: string): never;
+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("@mdbase-dev/connect-protocol").ApplicationFileRequest | undefined;
+export {};

package/dist/application-contract.js

@@ -0,0 +1,75 @@
+import { APPLICATION_SETUP_OPERATIONS, applicationFileRequest, capabilityOperationsForContractVersion } from "@mdbase-dev/connect-protocol";
+import { connectError } from "./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;
+}
+export 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-session.d.ts

@@ -1,5 +1,6 @@
-import { type ApplicationCapabilityId, type ConnectProblem, type JsonObject, type MdbaseAppManifest } from "@mdbase-dev/connect-protocol";
-import { type MdbaseEffectiveCapabilities } from "./capabilities.js";
+import { type ConnectProblem, type JsonObject, type CollectionOperation } from "@mdbase-dev/connect-protocol";
+import { type MdbaseApplicationManifest as MdbaseAppManifest, type MdbaseApplicationCapabilityId as ApplicationCapabilityId } from "./application-contract.js";
+import { type ApplicationSessionContext } from "./structured-readiness.js";
 import type { MdbaseAuthorizationOutcome, MdbaseAuthorizeOptions, MdbaseConnection } from "./connection.js";
 import type { MdbaseConnectionInfo } from "./connection-types.js";
 import { type ConnectOutcome, type CollectionTypeProblemCode, type RegistrationProblemCode, type SessionProblemCode } from "./outcomes.js";
@@ -53,12 +54,6 @@ export interface MdbaseCollectionSetupUpdate {
     canApply: boolean;
     reason: string;
 }
-interface ApplicationSessionContext {
-    collectionId: string;
-    info: MdbaseConnectionInfo;
-    capabilities: MdbaseEffectiveCapabilities;
-    connections: MdbaseConnectionInfo[];
-}
 export type MdbaseApplicationSessionSnapshot = {
     status: "not_started";
     connections: MdbaseConnectionInfo[];
@@ -117,6 +112,7 @@ export declare class MdbaseApplicationSession<Frontmatter extends JsonObject = J
     private setupAssessment;
     private setupTypePackAdoptions;
     private verificationGeneration;
+    private readinessController?;
     private lifecycleGeneration;
     private readonly operationControllers;
     private startOperation;
@@ -142,17 +138,22 @@ export declare class MdbaseApplicationSession<Frontmatter extends JsonObject = J
     forget(collectionId: string): ConnectOutcome<void, SessionProblemCode>;
     authorize(target: "choose" | "selected" | {
         collectionId: string;
-    }, options?: Omit<MdbaseAuthorizeOptions, "operations" | "returnTo" | "target">): Promise<ConnectOutcome<MdbaseAuthorizationOutcome<Frontmatter>, SessionProblemCode>>;
+    }, options?: Omit<MdbaseAuthorizeOptions, "returnTo" | "target">): Promise<ConnectOutcome<MdbaseAuthorizationOutcome<Frontmatter>, SessionProblemCode>>;
     handleAuthorizationCallback(callbackUrl: string | URL, options?: ConnectRequestOptions): Promise<ConnectOutcome<MdbaseConnection<Frontmatter>, SessionProblemCode>>;
     completeAuthorization(callbackUrl?: string | URL, options?: ConnectRequestOptions): Promise<ConnectOutcome<MdbaseConnection<Frontmatter>, SessionProblemCode>>;
     ensureCapabilities(capabilities: ApplicationCapabilityId[], options?: ConnectRequestOptions): Promise<ConnectOutcome<MdbaseAuthorizationOutcome<Frontmatter> | {
         kind: "unchanged";
         connection: MdbaseConnection<Frontmatter>;
     }, SessionProblemCode>>;
+    ensureOperations(operations: CollectionOperation[], options?: ConnectRequestOptions): Promise<ConnectOutcome<{
+        kind: "unchanged";
+        connection: MdbaseConnection<Frontmatter>;
+    } | MdbaseAuthorizationOutcome<Frontmatter>, SessionProblemCode>>;
     applyCollectionSetup(options?: ConnectRequestOptions): Promise<ConnectOutcome<MdbaseApplicationSessionSnapshot, CollectionTypeProblemCode | SessionProblemCode>>;
     private applyCollectionSetupStarted;
     private refresh;
     private verifySetup;
+    private publishReady;
     private collectionSetupInput;
     private context;
     private publish;
@@ -164,4 +165,3 @@ export declare class MdbaseApplicationSession<Frontmatter extends JsonObject = J
     private requireManifest;
     private requireApplication;
 }
-export {};

package/dist/application-session.js

@@ -1,10 +1,11 @@
-import { capabilityOperations, operationsForApplicationCapabilities } from "@mdbase-dev/connect-protocol";
-/* The versioned protocol package is the sole capability-to-operation compiler. */
-import { effectiveCapabilities } from "./capabilities.js";
+import { APPLICATION_SETUP_OPERATIONS } from "@mdbase-dev/connect-protocol";
+import { declaredOperations, validateAuthorizationSelection } from "./application-contract.js";
+import { applicationReadinessContext, collectionSetupInput, publishedStructuredReadiness, verifyStructuredReadiness, verificationKey, verificationValue } from "./structured-readiness.js";
 import { MdbaseConnectError, connectProblem } from "./errors.js";
 import { connectFailure, connectSuccess } from "./outcomes.js";
 import { createRequestBudget, resolveConnectTimeouts, withRequestBudget } from "./request-budget.js";
 import { defaultCallbackUrl } from "./runtime-utils.js";
+import { declarationIdFromFamilyIdentity } from "./connect-authorization-helpers.js";
 import { MdbaseSession } from "./session.js";
 export class MdbaseMemoryVerificationStore {
     values = new Map();
@@ -37,6 +38,7 @@ export class MdbaseApplicationSession {
     setupAssessment = null;
     setupTypePackAdoptions = null;
     verificationGeneration = 0;
+    readinessController;
     lifecycleGeneration = 0;
     operationControllers = new Set();
     startOperation = null;
@@ -75,6 +77,7 @@ export class MdbaseApplicationSession {
     }
     abandonStart(operation) {
         operation.controller.abort();
+        this.readinessController?.abort();
         this.startOperation = null;
         this.lifecycleGeneration += 1;
         this.verificationGeneration += 1;
@@ -132,7 +135,19 @@ export class MdbaseApplicationSession {
         const manifest = await this.connect.manifest(options);
         if (!manifest.ok)
             return this.startFailure(manifest.problem, generation);
-        const capabilities = manifest.value.requirements?.capabilities;
+        if (manifest.value.requirements?.access !== "full_collection") {
+            return this.startFailure(connectProblem("invalid_application_manifest", "Application sessions require explicit full_collection access.", {
+                details: {
+                    issues: [{
+                            path: "/requirements/access",
+                            keyword: "const",
+                            message: "must be full_collection",
+                            params: { allowedValue: "full_collection" }
+                        }]
+                }
+            }), generation);
+        }
+        const capabilities = manifest.value.requirements.capabilities;
         if (!capabilities) {
             return this.startFailure(connectProblem("invalid_application_manifest", "Application sessions require a versioned semantic capability contract.", {
                 details: {
@@ -153,7 +168,7 @@ export class MdbaseApplicationSession {
         const base = new MdbaseSession(this.connect, {
             selection: this.options.selection,
             autoSelect: this.options.autoSelect,
-            operations: operationsForSession(capabilities)
+            operations: operationsForSession(capabilities, manifest.value)
         });
         this.base = base;
         try {
@@ -197,6 +212,7 @@ export class MdbaseApplicationSession {
             return;
         this.lifecycleGeneration += 1;
         this.verificationGeneration += 1;
+        this.readinessController?.abort();
         this.startOperation?.controller.abort();
         this.startOperation = null;
         for (const controller of this.operationControllers)
@@ -293,6 +309,7 @@ export class MdbaseApplicationSession {
     }
     ensureCapabilities(capabilities, options) {
         return this.withLifecycleBase(options, (base, requestOptions, generation) => {
+            validateAuthorizationSelection(this.manifest.requirements, { ...options, capabilities });
             const manifestRequirements = this.manifest.requirements?.capabilities;
             const declared = new Set([
                 ...(manifestRequirements?.required ?? []),
@@ -313,7 +330,7 @@ export class MdbaseApplicationSession {
                     }
                 })));
             }
-            return base.ensureOperations(operationsForIds(capabilities), requestOptions).then(async (outcome) => {
+            return base.ensureCapabilities(capabilities, requestOptions).then(async (outcome) => {
                 if (outcome.ok && outcome.value.kind === "connected" && this.lifecycleCurrent(generation)) {
                     await this.refresh(true, requestOptions);
                 }
@@ -321,6 +338,15 @@ export class MdbaseApplicationSession {
             });
         });
     }
+    ensureOperations(operations, options) {
+        return this.withLifecycleBase(options, async (base, requestOptions, generation) => {
+            validateAuthorizationSelection(this.manifest.requirements, { ...options, operations });
+            const outcome = await base.ensureOperations(operations, requestOptions);
+            if (outcome.ok && outcome.value.kind === "connected" && this.lifecycleCurrent(generation))
+                await this.refresh(true, requestOptions);
+            return outcome;
+        });
+    }
     applyCollectionSetup(options) {
         return this.withLifecycleBase(options, (_base, requestOptions, generation) => this.applyCollectionSetupStarted(requestOptions, generation));
     }
@@ -335,6 +361,7 @@ export class MdbaseApplicationSession {
         if (!connection) {
             return connectFailure(connectProblem("collection_not_ready", "The collection is not ready."));
         }
+        const verificationGeneration = this.verificationGeneration;
         const assessment = this.setupAssessment;
         const input = {
             ...this.collectionSetupInput(this.setupTypePackAdoptions ?? undefined),
@@ -352,6 +379,9 @@ export class MdbaseApplicationSession {
             }
             return connectFailure(connectProblem("session_destroyed", lifecycleProblemMessage("session_destroyed")));
         }
+        if (verificationGeneration !== this.verificationGeneration || this.connection() !== connection) {
+            return connectFailure(connectProblem("collection_not_ready", "The selected collection changed during setup."));
+        }
         if (!applied.ok) {
             if (applied.problem.code === "application_declaration_mismatch") {
                 this.setupAssessment = null;
@@ -369,6 +399,7 @@ export class MdbaseApplicationSession {
         if (!this.base || !this.manifest)
             return;
         const current = this.base.getSnapshot();
+        this.readinessController?.abort();
         this.verificationGeneration += 1;
         const generation = this.verificationGeneration;
         this.setupAssessment = null;
@@ -389,18 +420,22 @@ export class MdbaseApplicationSession {
             return;
         }
         if (!context.capabilities.requiredAvailable
+            || context.readiness?.files.state === "requires_authorization"
             || !accessRequirementSatisfied(this.manifest, context.info)) {
             this.publish({ status: "authorization_required", ...context });
             return;
         }
-        const managesSetup = this.manifest.requirements?.capabilities?.required
-            .includes("collection.setup.apply") ?? false;
+        const managesSetup = (this.manifest.provisions?.type_packs.length ?? 0) > 0
+            || (this.manifest.provisions?.configuration?.length ?? 0) > 0;
         if (!managesSetup) {
-            this.publish({ status: "ready", verification: "verified", ...context });
+            const verification = this.publishReady(context, generation, options);
+            if (awaitVerification)
+                await verification;
             return;
         }
         const key = verificationKey(this.manifest, current.collectionId);
-        if (this.verificationStore.read(key) === verificationValue(this.manifest)) {
+        if (context.readiness?.contracts.state !== "checking"
+            && this.verificationStore.read(key) === verificationValue(this.manifest)) {
             this.publish({ status: "ready", verification: "cached", ...context });
         }
         else {
@@ -457,36 +492,51 @@ export class MdbaseApplicationSession {
             return;
         }
         this.verificationStore.write(verificationKey(manifest, context.collectionId), verificationValue(manifest));
-        this.publish({ status: "ready", verification: "verified", ...context });
+        if (context.readiness)
+            context.readiness.setup = { state: "current", evidence: [{ source: "authority", fact: "Collection setup assessment is current." }] };
+        await this.publishReady(context, generation, options);
+    }
+    async publishReady(context, generation, options) {
+        const contracts = this.requireManifest().requirements?.contracts ?? [];
+        if (context.readiness && contracts.length) {
+            const connection = this.connection();
+            if (!connection || connection.collectionId !== context.collectionId)
+                return;
+            this.publish({ status: "checking_setup", ...context });
+            const controller = new AbortController();
+            this.readinessController?.abort();
+            this.readinessController = controller;
+            try {
+                if (!await verifyStructuredReadiness({
+                    ...context, readiness: context.readiness, contracts, connection, controller, options,
+                    requestMs: this.timeouts.requestMs,
+                    isCurrent: () => generation === this.verificationGeneration && this.connection() === connection,
+                    publish: result => this.publish({ ...result, ...context })
+                }))
+                    return;
+            }
+            finally {
+                if (this.readinessController === controller)
+                    this.readinessController = undefined;
+            }
+        }
+        if (generation === this.verificationGeneration)
+            this.publish({ status: "ready", verification: "verified", ...context });
     }
     collectionSetupInput(typePackAdoptions) {
         const manifest = this.requireManifest();
         const application = this.requireApplication();
-        return {
-            applicationId: declarationIdFromFamilyIdentity(application.family_identity),
-            declarationDigest: `sha256:${application.manifest_digest}`,
-            requirements: {
-                configuration: manifest.requirements?.configuration ?? []
-            },
-            provisions: {
-                configuration: manifest.provisions?.configuration ?? [],
-                typePacks: manifest.provisions?.type_packs ?? []
-            },
-            ...(typePackAdoptions ? { typePackAdoptions } : {})
-        };
+        return collectionSetupInput(manifest, declarationIdFromFamilyIdentity(application.family_identity), `sha256:${application.manifest_digest}`, typePackAdoptions);
     }
     context(connection) {
-        const info = connection.info();
-        return {
-            collectionId: connection.collectionId,
-            info,
-            capabilities: effectiveCapabilities(this.requireManifest().requirements.capabilities, this.requireManifest(), info),
-            connections: this.connect.connections()
-        };
+        return applicationReadinessContext(this.requireManifest(), connection.collectionId, connection.info(), this.connect.connections());
     }
     publish(snapshot) {
         if (this.snapshot.status === "destroyed" && snapshot.status !== "destroyed")
             return;
+        if ("readiness" in snapshot && snapshot.readiness) {
+            snapshot = { ...snapshot, readiness: publishedStructuredReadiness(snapshot.readiness, snapshot.status, snapshot.status === "ready" ? snapshot.verification : undefined) };
+        }
         if (JSON.stringify(this.snapshot) === JSON.stringify(snapshot))
             return;
         this.snapshot = snapshot;
@@ -582,12 +632,13 @@ export class MdbaseApplicationSession {
         return this.application;
     }
 }
-function operationsForSession(requirements) {
-    return operationsForApplicationCapabilities(requirements);
-}
-function operationsForIds(capabilities) {
-    const definitions = capabilities.flatMap((id) => capabilityOperations(id));
-    return [...new Set(definitions)];
+function operationsForSession(requirements, manifest) {
+    const hasSetup = (manifest.provisions?.type_packs.length ?? 0) > 0
+        || (manifest.provisions?.configuration?.length ?? 0) > 0;
+    return [
+        ...declaredOperations(manifest.requirements),
+        ...(requirements.contract_version === 2 && hasSetup ? APPLICATION_SETUP_OPERATIONS : [])
+    ];
 }
 function definitionUpdate(provision, assessment) {
     const statusReason = assessment.status === "conflict"
@@ -647,26 +698,10 @@ function reviewableTypePackAdoptions(assessment) {
     }
     return adoptions;
 }
-function verificationKey(manifest, collectionId) {
-    return `mdbase-application-session:v1:${manifest.id}:${collectionId}`;
-}
-function verificationValue(manifest) {
-    return JSON.stringify({
-        capabilities: manifest.requirements?.capabilities,
-        requirements: manifest.requirements?.configuration ?? [],
-        provisions: manifest.provisions ?? {}
-    });
-}
 function accessRequirementSatisfied(manifest, connection) {
-    return manifest.requirements?.access !== "full_collection"
-        || connection.scope.access === "full_collection";
-}
-function declarationIdFromFamilyIdentity(familyIdentity) {
-    const prefix = "bundle:";
-    if (!familyIdentity.startsWith(prefix) || familyIdentity.length === prefix.length) {
-        throw new Error("The registered application has no valid declaration identity.");
-    }
-    return familyIdentity.slice(prefix.length);
+    return manifest.requirements?.access === "full_collection"
+        && connection.scope.access === "full_collection"
+        && connection.scope.contracts.length === 0;
 }
 function lifecycleProblemMessage(code) {
     if (code === "session_destroyed")

package/dist/browser/integrity.json

@@ -1,4 +1,4 @@
 {
   "file": "mdbase-connect.min.js",
-  "integrity": "sha384-G9S7H692RFcmy7JJ8CrePVKzJb4fvERv7ZfJfsbaNMtdu0ffE1SRdTgZAyhrMtJk"
+  "integrity": "sha384-pt5qe5l2IuGgDjsId1oPNVT/zCR+0TLeEJNt6xKdZQSxAACXxaCqoxbZd37EriJh"
 }