@mdbase-dev/connect 0.1.0-beta.100

package/dist/application-session.js

@@ -0,0 +1,722 @@
+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();
+    read(key) {
+        return this.values.get(key) ?? null;
+    }
+    write(key, value) {
+        this.values.set(key, value);
+    }
+    remove(key) {
+        this.values.delete(key);
+    }
+}
+/**
+ * The application-level lifecycle boundary. It derives authorization from the
+ * bundled manifest, exposes semantic capabilities, and never mutates collection
+ * setup without an explicit `applyCollectionSetup` call.
+ */
+export class MdbaseApplicationSession {
+    connect;
+    options;
+    timeouts;
+    listeners = new Set();
+    verificationStore;
+    snapshot = { status: "not_started", connections: [] };
+    manifest = null;
+    application = null;
+    base = null;
+    stopBase;
+    setupAssessment = null;
+    setupTypePackAdoptions = null;
+    verificationGeneration = 0;
+    readinessController;
+    lifecycleGeneration = 0;
+    operationControllers = new Set();
+    startOperation = null;
+    constructor(connect, options, timeouts = resolveConnectTimeouts()) {
+        this.connect = connect;
+        this.options = options;
+        this.timeouts = timeouts;
+        this.verificationStore = options.verificationStore ?? defaultVerificationStore();
+    }
+    start(options) {
+        if (this.snapshot.status === "destroyed") {
+            return Promise.resolve(connectFailure(connectProblem("session_destroyed", "This application session has been destroyed.")));
+        }
+        if (this.base && !this.startOperation)
+            return Promise.resolve(connectSuccess(this.snapshot));
+        const operation = this.startOperation ?? this.beginStart();
+        return this.waitForStart(operation, options, this.timeouts.watchStartMs);
+    }
+    async waitForStart(operation, options, timeoutMs) {
+        operation.waiters += 1;
+        try {
+            return await withRequestBudget(options, timeoutMs, () => operation.promise);
+        }
+        catch (error) {
+            if (error instanceof MdbaseConnectError) {
+                return connectFailure(error.problem);
+            }
+            throw error;
+        }
+        finally {
+            operation.waiters -= 1;
+            if (operation.waiters === 0 && this.startOperation === operation) {
+                this.abandonStart(operation);
+            }
+        }
+    }
+    abandonStart(operation) {
+        operation.controller.abort();
+        this.readinessController?.abort();
+        this.startOperation = null;
+        this.lifecycleGeneration += 1;
+        this.verificationGeneration += 1;
+        if (this.base)
+            this.cleanupBase(this.base);
+        this.application = null;
+        this.manifest = null;
+        this.setupAssessment = null;
+        this.setupTypePackAdoptions = null;
+        this.publish({ status: "not_started", connections: this.connect.connections() });
+    }
+    beginStart() {
+        this.publish({ status: "starting", connections: this.connect.connections() });
+        const controller = new AbortController();
+        const generation = ++this.lifecycleGeneration;
+        const operation = {
+            promise: this.startWithinBudget({ signal: controller.signal, timeoutMs: null }, generation),
+            controller,
+            waiters: 0,
+            generation
+        };
+        this.startOperation = operation;
+        const settled = () => {
+            if (this.startOperation === operation)
+                this.startOperation = null;
+        };
+        operation.promise.then(settled, settled);
+        return operation;
+    }
+    async startWithinBudget(options, generation) {
+        try {
+            return await this.performStartWithinBudget(options, generation);
+        }
+        catch (error) {
+            if (error instanceof MdbaseConnectError) {
+                return this.startFailure(error.problem, generation);
+            }
+            if (generation === this.lifecycleGeneration) {
+                this.verificationGeneration += 1;
+                if (this.base)
+                    this.cleanupBase(this.base);
+                this.application = null;
+                this.manifest = null;
+                this.setupAssessment = null;
+                this.setupTypePackAdoptions = null;
+                this.publish({ status: "not_started", connections: this.connect.connections() });
+            }
+            throw error;
+        }
+    }
+    async performStartWithinBudget(options, generation) {
+        const registration = await this.connect.register(options);
+        if (!registration.ok)
+            return this.startFailure(registration.problem, generation);
+        const manifest = await this.connect.manifest(options);
+        if (!manifest.ok)
+            return this.startFailure(manifest.problem, generation);
+        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: {
+                    issues: [{
+                            path: "/requirements/capabilities",
+                            keyword: "required",
+                            message: "is required for application sessions",
+                            params: {}
+                        }]
+                }
+            }), generation);
+        }
+        if (generation !== this.lifecycleGeneration || options.signal?.aborted) {
+            return connectFailure(connectProblem("operation_cancelled", "Application session startup was cancelled.", { operationOutcome: "not_sent" }));
+        }
+        this.application = registration.value;
+        this.manifest = manifest.value;
+        const base = new MdbaseSession(this.connect, {
+            selection: this.options.selection,
+            autoSelect: this.options.autoSelect,
+            operations: operationsForSession(capabilities, manifest.value)
+        });
+        this.base = base;
+        try {
+            const started = await base.start(options);
+            if (!started.ok) {
+                this.cleanupBase(base);
+                return this.startFailure(started.problem, generation);
+            }
+            if (generation !== this.lifecycleGeneration || options.signal?.aborted) {
+                this.cleanupBase(base);
+                return connectFailure(connectProblem("operation_cancelled", "Application session startup was cancelled.", { operationOutcome: "not_sent" }));
+            }
+            this.stopBase = base.subscribe(() => {
+                if (this.base === base)
+                    void this.refresh();
+            });
+            await this.refresh(true, options);
+            if (generation !== this.lifecycleGeneration || options.signal?.aborted) {
+                this.cleanupBase(base);
+                return connectFailure(connectProblem("operation_cancelled", "Application session startup was cancelled.", { operationOutcome: "not_sent" }));
+            }
+            return connectSuccess(this.snapshot);
+        }
+        catch (error) {
+            this.cleanupBase(base);
+            throw error;
+        }
+    }
+    startFailure(problem, generation) {
+        if (generation === this.lifecycleGeneration) {
+            this.publish({
+                status: "start_failed",
+                problem,
+                connections: this.connect.connections()
+            });
+        }
+        return connectFailure(problem);
+    }
+    destroy() {
+        if (this.snapshot.status === "destroyed")
+            return;
+        this.lifecycleGeneration += 1;
+        this.verificationGeneration += 1;
+        this.readinessController?.abort();
+        this.startOperation?.controller.abort();
+        this.startOperation = null;
+        for (const controller of this.operationControllers)
+            controller.abort();
+        this.operationControllers.clear();
+        if (this.base)
+            this.cleanupBase(this.base);
+        this.application = null;
+        this.manifest = null;
+        this.setupAssessment = null;
+        this.setupTypePackAdoptions = null;
+        this.publish({ status: "destroyed", connections: [] });
+        this.listeners.clear();
+    }
+    cleanupBase(base) {
+        if (this.base !== base)
+            return;
+        this.stopBase?.();
+        this.stopBase = undefined;
+        base.destroy();
+        this.base = null;
+    }
+    getSnapshot() {
+        return this.snapshot;
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    connection() {
+        const current = this.base?.getSnapshot();
+        return current?.status === "ready" ? current.connection : null;
+    }
+    select(collectionId, options = {}) {
+        const base = this.lifecycleBase();
+        return base.ok ? base.value.select(collectionId, options) : base;
+    }
+    clearSelection(options = {}) {
+        const base = this.lifecycleBase();
+        if (!base.ok)
+            return base;
+        base.value.clearSelection(options);
+        return connectSuccess(undefined);
+    }
+    forget(collectionId) {
+        const base = this.lifecycleBase();
+        if (!base.ok)
+            return base;
+        base.value.forget(collectionId);
+        return connectSuccess(undefined);
+    }
+    authorize(target, options = {}) {
+        return this.withLifecycleBase(options, async (base, requestOptions, generation) => {
+            const outcome = await base.authorize(target, { ...options, ...requestOptions });
+            if (outcome.ok && outcome.value.kind === "connected" && this.lifecycleCurrent(generation)) {
+                await this.refresh(true, requestOptions);
+            }
+            return outcome;
+        });
+    }
+    handleAuthorizationCallback(callbackUrl, options) {
+        const exactUrl = String(callbackUrl);
+        const joinsStartupCallback = this.startOperation !== null
+            && this.options.selection.authorizationCallback() === exactUrl;
+        return this.withLifecycleBase(options, async (base, requestOptions, generation) => {
+            if (joinsStartupCallback) {
+                const current = base.getSnapshot();
+                if (current.status === "ready")
+                    return connectSuccess(current.connection);
+                return connectFailure(connectProblem("collection_not_ready", "Authorization did not produce a ready collection."));
+            }
+            const outcome = await base.handleAuthorizationCallback(exactUrl, requestOptions);
+            if (outcome.ok && this.lifecycleCurrent(generation))
+                await this.refresh(true, requestOptions);
+            return outcome;
+        });
+    }
+    completeAuthorization(callbackUrl, options) {
+        const exactUrl = callbackUrl === undefined ? defaultCallbackUrl() : String(callbackUrl);
+        const joinsStartupCallback = this.startOperation !== null
+            && this.options.selection.authorizationCallback() === exactUrl;
+        return this.withLifecycleBase(options, async (base, requestOptions, generation) => {
+            if (joinsStartupCallback) {
+                const current = base.getSnapshot();
+                if (current.status === "ready")
+                    return connectSuccess(current.connection);
+                return connectFailure(connectProblem("collection_not_ready", "Authorization did not produce a ready collection."));
+            }
+            const outcome = await base.handleAuthorizationCallback(exactUrl, requestOptions);
+            if (outcome.ok && this.lifecycleCurrent(generation))
+                await this.refresh(true, requestOptions);
+            return outcome;
+        });
+    }
+    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 ?? []),
+                ...(manifestRequirements?.optional ?? [])
+            ]);
+            if (capabilities.some((capability) => !declared.has(capability))) {
+                return Promise.resolve(connectFailure(connectProblem("invalid_application_manifest", "Applications may only request capabilities declared in their manifest.", {
+                    details: {
+                        issues: [{
+                                path: "/requirements/capabilities",
+                                keyword: "undeclaredCapability",
+                                message: "must declare every capability requested by the application",
+                                params: {
+                                    requested: capabilities,
+                                    declared: [...declared]
+                                }
+                            }]
+                    }
+                })));
+            }
+            return base.ensureCapabilities(capabilities, requestOptions).then(async (outcome) => {
+                if (outcome.ok && outcome.value.kind === "connected" && this.lifecycleCurrent(generation)) {
+                    await this.refresh(true, requestOptions);
+                }
+                return outcome;
+            });
+        });
+    }
+    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));
+    }
+    async applyCollectionSetupStarted(options, generation) {
+        if (this.snapshot.status !== "setup_review_required" || !this.setupAssessment) {
+            return connectFailure(connectProblem("collection_not_ready", "There is no reviewed collection setup to apply."));
+        }
+        if (!this.setupAssessment.applicable) {
+            return connectFailure(connectProblem("collection_not_ready", "Resolve the collection setup conflicts before applying this update."));
+        }
+        const connection = this.connection();
+        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),
+            expectedAssessmentDigest: assessment.assessmentDigest,
+            expectedCollectionRevision: assessment.collectionRevision,
+            expectedProvisionDigest: assessment.provisionDigest,
+            allowTypePackDowngrades: assessment.typePacks
+                .filter((pack) => pack.status === "downgrade")
+                .map((pack) => pack.desired.id)
+        };
+        const applied = await connection.applyCollectionSetup(input, options);
+        if (!this.lifecycleCurrent(generation)) {
+            if (!applied.ok && applied.problem.code === "operation_outcome_unknown") {
+                return connectFailure(applied.problem);
+            }
+            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;
+                this.setupTypePackAdoptions = null;
+                this.publish({ status: "authorization_required", ...this.context(connection) });
+            }
+            return applied;
+        }
+        this.setupAssessment = null;
+        this.setupTypePackAdoptions = null;
+        await this.verifySetup(this.context(connection), ++this.verificationGeneration, options);
+        return connectSuccess(this.snapshot);
+    }
+    async refresh(awaitVerification = false, options) {
+        if (!this.base || !this.manifest)
+            return;
+        const current = this.base.getSnapshot();
+        this.readinessController?.abort();
+        this.verificationGeneration += 1;
+        const generation = this.verificationGeneration;
+        this.setupAssessment = null;
+        this.setupTypePackAdoptions = null;
+        if (current.status === "unselected") {
+            this.publish({ status: "unselected", connections: current.connections });
+            return;
+        }
+        if (current.status === "unavailable") {
+            this.publish(current);
+            return;
+        }
+        if (current.status !== "ready")
+            return;
+        const context = this.context(current.connection);
+        if (this.connect.connectionApplicationId(current.collectionId) !== this.application?.id) {
+            this.publish({ status: "authorization_required", ...context });
+            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.provisions?.type_packs.length ?? 0) > 0
+            || (this.manifest.provisions?.configuration?.length ?? 0) > 0;
+        if (!managesSetup) {
+            const verification = this.publishReady(context, generation, options);
+            if (awaitVerification)
+                await verification;
+            return;
+        }
+        const key = verificationKey(this.manifest, current.collectionId);
+        if (context.readiness?.contracts.state !== "checking"
+            && this.verificationStore.read(key) === verificationValue(this.manifest)) {
+            this.publish({ status: "ready", verification: "cached", ...context });
+        }
+        else {
+            this.publish({ status: "checking_setup", ...context });
+        }
+        const verification = this.verifySetup(context, generation, options);
+        if (awaitVerification)
+            await verification;
+    }
+    async verifySetup(context, generation, options) {
+        const connection = this.connection();
+        const manifest = this.requireManifest();
+        if (!connection || connection.collectionId !== context.collectionId)
+            return;
+        const initialInput = this.collectionSetupInput();
+        let outcome = options
+            ? await connection.assessCollectionSetup(initialInput, options)
+            : await connection.assessCollectionSetup(initialInput);
+        if (generation !== this.verificationGeneration)
+            return;
+        if (!outcome.ok) {
+            this.publish(outcome.problem.code === "application_declaration_mismatch"
+                ? { status: "authorization_required", ...context }
+                : { status: "blocked", problem: outcome.problem, ...context });
+            return;
+        }
+        if (!outcome.value.applicable) {
+            const adoptions = reviewableTypePackAdoptions(outcome.value);
+            if (Object.keys(adoptions).length > 0) {
+                outcome = options
+                    ? await connection.assessCollectionSetup(this.collectionSetupInput(adoptions), options)
+                    : await connection.assessCollectionSetup(this.collectionSetupInput(adoptions));
+                if (generation !== this.verificationGeneration)
+                    return;
+                if (!outcome.ok) {
+                    this.publish(outcome.problem.code === "application_declaration_mismatch"
+                        ? { status: "authorization_required", ...context }
+                        : { status: "blocked", problem: outcome.problem, ...context });
+                    return;
+                }
+                this.setupTypePackAdoptions = adoptions;
+            }
+        }
+        if (generation !== this.verificationGeneration)
+            return;
+        if (outcome.value.status !== "current") {
+            this.setupAssessment = outcome.value;
+            this.verificationStore.remove(verificationKey(manifest, context.collectionId));
+            this.publish({
+                status: "setup_review_required",
+                update: collectionSetupUpdate(outcome.value, manifest.provisions?.type_packs ?? []),
+                ...context
+            });
+            return;
+        }
+        this.verificationStore.write(verificationKey(manifest, context.collectionId), verificationValue(manifest));
+        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 collectionSetupInput(manifest, declarationIdFromFamilyIdentity(application.family_identity), `sha256:${application.manifest_digest}`, typePackAdoptions);
+    }
+    context(connection) {
+        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;
+        for (const listener of this.listeners)
+            listener();
+    }
+    lifecycleBase() {
+        const status = this.snapshot.status;
+        if (this.startOperation || status === "starting") {
+            return connectFailure(connectProblem("session_starting", "The application session is still starting."));
+        }
+        if (this.snapshot.status === "start_failed")
+            return connectFailure(this.snapshot.problem);
+        if (this.base)
+            return connectSuccess(this.base);
+        const code = status === "destroyed"
+            ? "session_destroyed"
+            : "session_not_started";
+        return connectFailure(connectProblem(code, lifecycleProblemMessage(code)));
+    }
+    async withLifecycleBase(options, operation) {
+        const lifecycle = this.beginLifecycleOperation(options);
+        const budget = createRequestBudget(lifecycle.options, this.timeouts.requestMs);
+        const requestOptions = { signal: budget.signal, timeoutMs: null };
+        try {
+            const starting = this.startOperation;
+            if (starting) {
+                const started = await this.waitForStart(starting, requestOptions, null);
+                if (!started.ok)
+                    return started;
+            }
+            if (!this.lifecycleCurrent(lifecycle.generation)) {
+                return connectFailure(connectProblem("session_destroyed", lifecycleProblemMessage("session_destroyed")));
+            }
+            const base = this.lifecycleBase();
+            if (!base.ok)
+                return base;
+            const outcome = await operation(base.value, requestOptions, lifecycle.generation);
+            if (!this.lifecycleCurrent(lifecycle.generation))
+                return this.destroyedOutcome(outcome);
+            return outcome;
+        }
+        catch (error) {
+            if (error instanceof MdbaseConnectError) {
+                if (!this.lifecycleCurrent(lifecycle.generation)) {
+                    if (error.problem.code === "operation_outcome_unknown") {
+                        return connectFailure(error.problem);
+                    }
+                    return connectFailure(connectProblem("session_destroyed", lifecycleProblemMessage("session_destroyed")));
+                }
+                return connectFailure(error.problem);
+            }
+            throw error;
+        }
+        finally {
+            budget.dispose();
+            lifecycle.dispose();
+        }
+    }
+    beginLifecycleOperation(options = {}) {
+        const controller = new AbortController();
+        const abort = () => controller.abort(options.signal?.reason);
+        if (options.signal?.aborted)
+            abort();
+        else
+            options.signal?.addEventListener("abort", abort, { once: true });
+        this.operationControllers.add(controller);
+        return {
+            generation: this.lifecycleGeneration,
+            options: { ...options, signal: controller.signal },
+            dispose: () => {
+                options.signal?.removeEventListener("abort", abort);
+                this.operationControllers.delete(controller);
+            }
+        };
+    }
+    lifecycleCurrent(generation) {
+        return this.snapshot.status !== "destroyed" && generation === this.lifecycleGeneration;
+    }
+    destroyedOutcome(outcome) {
+        if (!outcome.ok && outcome.problem.code === "operation_outcome_unknown")
+            return outcome;
+        return connectFailure(connectProblem("session_destroyed", lifecycleProblemMessage("session_destroyed")));
+    }
+    requireManifest() {
+        if (!this.manifest)
+            throw new Error("Start the application session before using it.");
+        return this.manifest;
+    }
+    requireApplication() {
+        if (!this.application)
+            throw new Error("Start the application session before using it.");
+        return this.application;
+    }
+}
+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"
+        ? "Existing user-owned resources conflict with this application definition pack."
+        : assessment.status === "install"
+            ? "This collection needs the application definitions installed."
+            : `This collection has a ${assessment.status} definition change to review.`;
+    return {
+        id: assessment.desired.id,
+        name: provision.manifest.name ?? assessment.desired.id,
+        status: assessment.status,
+        applicable: assessment.applicable,
+        assessmentDigest: assessment.assessmentDigest,
+        ...(assessment.current ? { currentVersion: assessment.current.version } : {}),
+        desiredVersion: assessment.desired.version,
+        resources: assessment.resources,
+        contractSetups: assessment.contractSetups,
+        canApply: assessment.applicable,
+        reason: statusReason
+    };
+}
+function collectionSetupUpdate(assessment, provisions) {
+    const typePacks = assessment.typePacks.map((pack) => {
+        const provision = provisions.find((candidate) => candidate.manifest.id === pack.desired.id);
+        if (!provision) {
+            throw new Error(`Collection setup returned undeclared type pack '${pack.desired.id}'.`);
+        }
+        return definitionUpdate(provision, pack);
+    });
+    const configurationChanges = assessment.configuration.filter((entry) => entry.action !== "current").length;
+    const reason = assessment.status === "conflict"
+        ? "Existing collection policy conflicts with this application's required setup."
+        : `This application requires ${configurationChanges} configuration change${configurationChanges === 1 ? "" : "s"} and ${typePacks.length} definition update${typePacks.length === 1 ? "" : "s"}.`;
+    return {
+        status: assessment.status,
+        applicable: assessment.applicable,
+        assessmentDigest: assessment.assessmentDigest,
+        collectionRevision: assessment.collectionRevision,
+        provisionDigest: assessment.provisionDigest,
+        configuration: assessment.configuration,
+        typePacks,
+        canApply: assessment.applicable,
+        reason
+    };
+}
+function reviewableTypePackAdoptions(assessment) {
+    const adoptions = {};
+    for (const pack of assessment.typePacks) {
+        const resources = Object.fromEntries(pack.resources
+            .filter((resource) => resource.action === "conflict"
+            && resource.mode === "managed"
+            && resource.currentDigest !== undefined
+            && resource.installedDigest === undefined)
+            .map((resource) => [resource.target, resource.currentDigest]));
+        if (Object.keys(resources).length > 0)
+            adoptions[pack.desired.id] = resources;
+    }
+    return adoptions;
+}
+function accessRequirementSatisfied(manifest, connection) {
+    return manifest.requirements?.access === "full_collection"
+        && connection.scope.access === "full_collection"
+        && connection.scope.contracts.length === 0;
+}
+function lifecycleProblemMessage(code) {
+    if (code === "session_destroyed")
+        return "This application session has been destroyed.";
+    if (code === "session_starting")
+        return "The application session is still starting.";
+    return "Start the application session before using it.";
+}
+function defaultVerificationStore() {
+    if (typeof localStorage !== "undefined") {
+        return {
+            read: (key) => localStorage.getItem(key),
+            write: (key, value) => localStorage.setItem(key, value),
+            remove: (key) => localStorage.removeItem(key)
+        };
+    }
+    return new MdbaseMemoryVerificationStore();
+}