@mdbase-dev/connect 0.1.0-beta.100

package/dist/collection-client.js

@@ -0,0 +1,686 @@
+import { abortableDelay } from "./async.js";
+import { coordinatedQueryPages } from "./query-pagination.js";
+import { coordinatedSavedViewPages } from "./saved-view-pagination.js";
+import { MdbaseConnectError, connectError, connectProblem, operationProblem } from "./errors.js";
+import { COLLECTION_CHANGES_PROBLEM_CODES, COLLECTION_DESCRIPTION_PROBLEM_CODES, COLLECTION_MUTATION_PROBLEM_CODES, COLLECTION_QUERY_PROBLEM_CODES, COLLECTION_READ_PROBLEM_CODES, COLLECTION_TYPE_PROBLEM_CODES, ALL_CONNECT_PROBLEM_CODES, captureConnectOutcome, connectFailure, connectSuccess } from "./outcomes.js";
+import { createRequestBudget, DEFAULT_REQUEST_TIMEOUT_MS, requestAbortReason } from "./request-budget.js";
+import { watchRetryPolicy } from "./watch-policy.js";
+/**
+ * Typed collection operations independent of OAuth, HTTP, or storage.
+ *
+ * Application code can use this surface against Connect, the developer
+ * sandbox, or another provider without changing its record logic.
+ */
+export class MdbaseCollectionClient {
+    transport;
+    requestTimeoutMs;
+    constructor(transport, requestTimeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
+        this.transport = transport;
+        this.requestTimeoutMs = requestTimeoutMs;
+    }
+    operation(operation, input, options) {
+        return captureConnectOutcome(() => this.transport.operation(operation, input, options), ALL_CONNECT_PROBLEM_CODES);
+    }
+    async describe(options) {
+        const outcome = await this.rawOperation("describe", {}, COLLECTION_DESCRIPTION_PROBLEM_CODES, options);
+        return mapOutcome(outcome, wireCollectionDescription);
+    }
+    async changes(input = {}, options) {
+        const outcome = await this.rawOperation("changes", input, COLLECTION_CHANGES_PROBLEM_CODES, options);
+        return mapOutcome(outcome, wireChangesPage);
+    }
+    async read(input, options) {
+        const outcome = await this.envelopeOperation("read", wireReadInput(input), COLLECTION_READ_PROBLEM_CODES, options);
+        return mapOutcome(outcome, wireRecordDocument);
+    }
+    async query(input = {}, options) {
+        const outcome = await this.envelopeOperation("query", wireQueryInput(input), COLLECTION_QUERY_PROBLEM_CODES, options);
+        return mapOutcome(outcome, ({ results, meta }) => ({
+            results: results.map(wireQueryRecord),
+            ...(meta ? {
+                meta: {
+                    ...(typeof meta.total_count === "number" ? { totalCount: meta.total_count } : {}),
+                    ...(meta.total_count_outcome === undefined
+                        ? {}
+                        : { totalCountOutcome: meta.total_count_outcome }),
+                    hasMore: meta.has_more,
+                    ...(meta.cursor ? { cursor: meta.cursor } : {}),
+                    ...(meta.snapshot ? { snapshot: meta.snapshot } : {})
+                }
+            } : {})
+        }));
+    }
+    async *queryPages(input = {}, options = {}) {
+        yield* coordinatedQueryPages((pageInput, pageOptions) => this.query(pageInput, pageOptions), (cursor) => this.releaseQueryCursor(cursor), input, options);
+    }
+    async queryAll(input = {}, options = {}) {
+        const budget = createRequestBudget(options, this.requestTimeoutMs);
+        const results = [];
+        let finalPage;
+        const diagnostics = [];
+        try {
+            for await (const outcome of this.queryPages(input, {
+                firstPageSize: options.firstPageSize,
+                pageSize: options.pageSize,
+                signal: budget.signal,
+                pageTimeoutMs: null,
+                coordination: options.coordination,
+                onProgress: options.onProgress
+            })) {
+                if (!outcome.ok)
+                    return outcome;
+                const page = outcome.value;
+                results.push(...page.results);
+                finalPage = page;
+                diagnostics.push(...outcome.diagnostics);
+            }
+            if (budget.signal.aborted)
+                throw requestAbortReason(budget.signal);
+            return connectSuccess({
+                results,
+                meta: {
+                    totalCount: finalPage?.meta?.totalCount ?? results.length,
+                    hasMore: finalPage ? !finalPage.complete : false,
+                    ...(finalPage?.snapshot ? { snapshot: finalPage.snapshot } : {})
+                }
+            }, diagnostics);
+        }
+        catch (error) {
+            if (error instanceof MdbaseConnectError) {
+                return connectFailure(error.problem);
+            }
+            throw error;
+        }
+        finally {
+            budget.dispose();
+        }
+    }
+    async listViews(options) {
+        const outcome = await this.envelopeOperation("list_views", {}, COLLECTION_READ_PROBLEM_CODES, options);
+        return mapOutcome(outcome, (value) => ({ views: value.views, meta: { totalCount: value.meta.total_count } }));
+    }
+    async executeView(input, options) {
+        const outcome = await this.envelopeOperation("execute_view", input, COLLECTION_READ_PROBLEM_CODES, options);
+        return mapOutcome(outcome, wireSavedViewExecution);
+    }
+    async *executeViewPages(input, options = {}) {
+        yield* coordinatedSavedViewPages((pageInput, pageOptions) => this.executeView(pageInput, pageOptions), (cursor) => this.releaseQueryCursor(cursor), input, options);
+    }
+    readViewSource(input, options) {
+        return this.envelopeOperation("read_view_source", input, COLLECTION_READ_PROBLEM_CODES, options);
+    }
+    createViewSource(input, options) {
+        return this.envelopeOperation("create_view_source", input, COLLECTION_MUTATION_PROBLEM_CODES, options);
+    }
+    updateViewSource(input, options) {
+        return this.envelopeOperation("update_view_source", wireRevisionInput(input), COLLECTION_MUTATION_PROBLEM_CODES, options);
+    }
+    deleteViewSource(input, options) {
+        return this.envelopeOperation("delete_view_source", wireRevisionInput(input), COLLECTION_MUTATION_PROBLEM_CODES, options);
+    }
+    async create(input, options) {
+        const outcome = await this.envelopeOperation("create", wireCreateInput(input), COLLECTION_MUTATION_PROBLEM_CODES, options);
+        return mapOutcome(outcome, wireRecordDocument);
+    }
+    async update(input, options) {
+        const outcome = await this.envelopeOperation("update", wireUpdateInput(input), COLLECTION_MUTATION_PROBLEM_CODES, options);
+        return mapOutcome(outcome, wireRecordDocument);
+    }
+    async delete(input, options) {
+        const outcome = await this.envelopeOperation("delete", wireDeleteInput(input), COLLECTION_MUTATION_PROBLEM_CODES, options);
+        return mapOutcome(outcome, wireDeleteResult);
+    }
+    async preflightDelete(input, options) {
+        const outcome = await this.envelopeOperation("delete", {
+            ...wireDeleteInput(input),
+            check_backlinks: true,
+            dry_run: true
+        }, COLLECTION_MUTATION_PROBLEM_CODES, options);
+        return mapOutcome(outcome, wireDeletePreflightResult);
+    }
+    async rename(input, options) {
+        const outcome = await this.envelopeOperation("rename", wireRenameInput(input), COLLECTION_MUTATION_PROBLEM_CODES, options);
+        return mapOutcome(outcome, wireRenameResult);
+    }
+    async preflightRename(input, options) {
+        const outcome = await this.envelopeOperation("rename", {
+            ...wireRenameInput(input),
+            dry_run: true
+        }, COLLECTION_MUTATION_PROBLEM_CODES, options);
+        return mapOutcome(outcome, wireRenamePreflightResult);
+    }
+    validate(input = {}, options) {
+        return this.envelopeOperation("validate", input, COLLECTION_READ_PROBLEM_CODES, options);
+    }
+    readType(input, options) {
+        return this.envelopeOperation("read_type", input, COLLECTION_TYPE_PROBLEM_CODES, options);
+    }
+    createType(input, options) {
+        return this.envelopeOperation("create_type", input, COLLECTION_TYPE_PROBLEM_CODES, options);
+    }
+    updateType(input, options) {
+        return this.envelopeOperation("update_type", wireRevisionInput(input), COLLECTION_TYPE_PROBLEM_CODES, options);
+    }
+    async assessTypePack(input, options) {
+        const outcome = await this.envelopeOperation("assess_type_pack", wireAssessTypePackInput(input), COLLECTION_TYPE_PROBLEM_CODES, options);
+        return mapOutcome(outcome, wireTypePackAssessment);
+    }
+    async applyTypePack(input, options) {
+        const outcome = await this.envelopeOperation("apply_type_pack", wireApplyTypePackInput(input), COLLECTION_TYPE_PROBLEM_CODES, options);
+        return mapOutcome(outcome, wireTypePackApplyResult);
+    }
+    async assessCollectionSetup(input, options) {
+        const outcome = await this.envelopeOperation("assess_collection_setup", wireAssessCollectionSetupInput(input), COLLECTION_TYPE_PROBLEM_CODES, options);
+        return mapOutcome(outcome, wireCollectionSetupAssessment);
+    }
+    async applyCollectionSetup(input, options) {
+        const outcome = await this.envelopeOperation("apply_collection_setup", wireApplyCollectionSetupInput(input), COLLECTION_TYPE_PROBLEM_CODES, options);
+        return mapOutcome(outcome, (value) => ({
+            assessment: wireCollectionSetupAssessment(value.assessment),
+            receipt: wireCollectionSetupReceipt(value.receipt)
+        }));
+    }
+    async listTimers(namespace, options) {
+        const outcome = await this.rawOperation("list_timers", { namespace }, COLLECTION_READ_PROBLEM_CODES, options);
+        return mapOutcome(outcome, (value) => ({
+            namespace: value.namespace,
+            timers: value.timers.map(wireTimer)
+        }));
+    }
+    async putTimer(input, options) {
+        const outcome = await this.rawOperation("put_timer", {
+            namespace: input.namespace,
+            criterion_id: input.criterionId,
+            timer: wireDesiredTimer(input.timer)
+        }, COLLECTION_MUTATION_PROBLEM_CODES, options);
+        return mapOutcome(outcome, wireTimer);
+    }
+    cancelTimer(input, options) {
+        return this.rawOperation("cancel_timer", input, COLLECTION_MUTATION_PROBLEM_CODES, options);
+    }
+    async reconcileTimers(input, options) {
+        const outcome = await this.rawOperation("reconcile_timers", {
+            namespace: input.namespace,
+            criterion_id: input.criterionId,
+            timers: input.timers.map(wireDesiredTimer)
+        }, COLLECTION_MUTATION_PROBLEM_CODES, options);
+        return mapOutcome(outcome, (value) => ({
+            namespace: value.namespace,
+            timers: value.timers.map(wireTimer),
+            cancelledIds: value.cancelled_ids
+        }));
+    }
+    async *watch(options = {}) {
+        let cursor = options.cursor;
+        const pollInterval = Math.max(100, options.pollIntervalMs ?? 1_000);
+        const retry = watchRetryPolicy(options.retry);
+        let failures = 0;
+        let connected = false;
+        options.onStatus?.({ state: "connecting", ...(cursor === undefined ? {} : { cursor }) });
+        while (!options.signal?.aborted) {
+            const changed = await this.changes(cursor === undefined ? {} : { after: cursor, limit: 200 }, { signal: options.signal, timeoutMs: options.timeoutMs });
+            if (!changed.ok) {
+                const problem = changed.problem;
+                if (options.signal?.aborted)
+                    return;
+                if (!retry || problem.recovery !== "retry") {
+                    yield changed;
+                    return;
+                }
+                connected = false;
+                failures += 1;
+                if (retry.maxAttempts !== undefined && failures > retry.maxAttempts) {
+                    yield changed;
+                    return;
+                }
+                const retryInMs = Math.min(retry.maxDelayMs, Math.round(retry.initialDelayMs * retry.multiplier ** (failures - 1)));
+                options.onStatus?.({
+                    state: "reconnecting",
+                    ...(cursor === undefined ? {} : { cursor }),
+                    attempt: failures,
+                    retryInMs,
+                    problem
+                });
+                try {
+                    await abortableDelay(retryInMs, options.signal);
+                }
+                catch {
+                    if (!options.signal?.aborted)
+                        throw connectError("operation_failed", "Watch retry delay failed unexpectedly.");
+                }
+                continue;
+            }
+            const page = changed.value;
+            if (cursor === undefined) {
+                cursor = page.cursor;
+                continue;
+            }
+            if (page.reset) {
+                const problem = connectProblem("change_cursor_reset", "The collection change cursor expired. Refresh collection state before subscribing again.");
+                options.onStatus?.({ state: "reset_required", cursor, problem });
+                yield connectFailure(problem);
+                return;
+            }
+            const recovered = failures > 0;
+            failures = 0;
+            if (!connected || recovered)
+                options.onStatus?.({ state: "connected", cursor, recovered });
+            connected = true;
+            for (const event of page.events)
+                yield connectSuccess(event);
+            cursor = page.cursor;
+            if (!page.hasMore) {
+                try {
+                    await abortableDelay(pollInterval, options.signal);
+                }
+                catch {
+                    if (!options.signal?.aborted)
+                        throw connectError("operation_failed", "Watch polling delay failed unexpectedly.");
+                }
+            }
+        }
+    }
+    rawOperation(operation, input, allowedCodes, options) {
+        return captureConnectOutcome(() => this.transport.operation(operation, input, options), allowedCodes);
+    }
+    async releaseQueryCursor(cursor) {
+        try {
+            await this.envelopeOperation("query", { release_cursor: cursor }, COLLECTION_QUERY_PROBLEM_CODES, { timeoutMs: 2_000, coordination: { coalesce: false } });
+        }
+        catch {
+            // Lease expiry is bounded by the authority; cleanup never masks query results.
+        }
+    }
+    async envelopeOperation(operation, input, allowedCodes, options) {
+        const transported = await captureConnectOutcome(() => this.transport.operation(operation, input, options), allowedCodes);
+        if (!transported.ok)
+            return transported;
+        const envelope = transported.value;
+        if (!envelope.valid) {
+            return connectFailure(operationProblem(envelope));
+        }
+        return connectSuccess(envelope.result, envelope.diagnostics);
+    }
+}
+function mapOutcome(outcome, map) {
+    return outcome.ok ? connectSuccess(map(outcome.value), outcome.diagnostics) : outcome;
+}
+function wireReadInput(input) {
+    return {
+        path: input.path,
+        ...(input.contract ? { contract: input.contract } : {}),
+        ...(input.includeDocument === undefined ? {} : { include_document: input.includeDocument })
+    };
+}
+function wireQueryInput(input) {
+    return {
+        ...(input.types ? { types: input.types } : {}),
+        ...(input.timezone ? { timezone: input.timezone } : {}),
+        ...(input.context ? { context: input.context } : {}),
+        ...(input.projections ? {
+            projections: Object.fromEntries(Object.entries(input.projections).map(([name, projection]) => [
+                name,
+                { expr: projection.expression, ...(projection.description ? { description: projection.description } : {}) }
+            ]))
+        } : {}),
+        ...(input.where ? { where: input.where } : {}),
+        ...(input.select ? {
+            select: input.select.map((selection) => typeof selection === "string"
+                ? selection
+                : {
+                    name: selection.name,
+                    expr: selection.expression,
+                    ...(selection.label ? { label: selection.label } : {}),
+                    ...(selection.description ? { description: selection.description } : {})
+                })
+        } : {}),
+        ...(input.orderBy ? { order_by: input.orderBy } : {}),
+        ...(input.groupBy ? { group_by: input.groupBy } : {}),
+        ...(input.summaryFunctions ? {
+            summary_functions: Object.fromEntries(Object.entries(input.summaryFunctions).map(([name, projection]) => [
+                name,
+                { expr: projection.expression, ...(projection.description ? { description: projection.description } : {}) }
+            ]))
+        } : {}),
+        ...(input.summaries ? { summaries: input.summaries } : {}),
+        ...(input.limit === undefined ? {} : { limit: input.limit }),
+        ...(input.offset === undefined ? {} : { offset: input.offset }),
+        ...(input.pagination ? { pagination: input.pagination } : {}),
+        ...(input.cursor ? { cursor: input.cursor } : {}),
+        ...(input.snapshot ? { snapshot: input.snapshot } : {}),
+        ...(input.includeBody === undefined ? {} : { include_body: input.includeBody }),
+        ...(input.frontmatterMode ? { frontmatter_mode: input.frontmatterMode } : {}),
+        ...(input.contract ? { contract: input.contract } : {})
+    };
+}
+function wireCreateInput(input) {
+    return {
+        ...(input.path ? { path: input.path } : {}),
+        ...(input.type ? { type: input.type } : {}),
+        ...(input.contract ? { contract: input.contract } : {}),
+        ...(input.frontmatter ? { frontmatter: input.frontmatter } : {}),
+        ...(input.body === undefined ? {} : { body: input.body }),
+        ...(input.ifRevision ? { if_revision: input.ifRevision } : {}),
+        ...(input.includeDocument === undefined ? {} : { include_document: input.includeDocument })
+    };
+}
+function wireUpdateInput(input) {
+    return {
+        path: input.path,
+        ...(input.contract ? { contract: input.contract } : {}),
+        ...(input.ifRevision ? { if_revision: input.ifRevision } : {}),
+        ...(input.includeDocument === undefined ? {} : { include_document: input.includeDocument }),
+        ...(input.document === undefined
+            ? { patch: input.patch, ...(input.body === undefined ? {} : { body: input.body }) }
+            : { document: input.document })
+    };
+}
+function wireDeleteInput(input) {
+    return {
+        path: input.path,
+        ...(input.contract ? { contract: input.contract } : {}),
+        ...(input.checkBacklinks === undefined ? {} : { check_backlinks: input.checkBacklinks }),
+        ...(input.ifRevision ? { if_revision: input.ifRevision } : {})
+    };
+}
+function wireRenameInput(input) {
+    return {
+        from: input.from,
+        to: input.to,
+        ...(input.contract ? { contract: input.contract } : {}),
+        ...(input.updateRefs === undefined ? {} : { update_refs: input.updateRefs }),
+        ...(input.ifRevision ? { if_revision: input.ifRevision } : {}),
+        ...(input.includeDocument === undefined ? {} : { include_document: input.includeDocument })
+    };
+}
+function wireRevisionInput(input) {
+    const { ifRevision, ...rest } = input;
+    return { ...rest, ...(ifRevision ? { if_revision: ifRevision } : {}) };
+}
+function wireAssessTypePackInput(input) {
+    return {
+        provision: input.provision,
+        installed_by: input.installedBy,
+        ...(input.adoptResources ? { adopt_resources: input.adoptResources } : {}),
+        ...(input.preserveSeedTargets ? { preserve_seed_targets: input.preserveSeedTargets } : {}),
+        ...(input.targetOverrides ? { target_overrides: input.targetOverrides } : {}),
+        ...(input.contractSetups ? { contract_setups: input.contractSetups.map(wireContractSetupChoice) } : {})
+    };
+}
+function wireApplyTypePackInput(input) {
+    return {
+        ...wireAssessTypePackInput(input),
+        expected_assessment_digest: input.expectedAssessmentDigest,
+        ...(input.allowDowngrade === undefined ? {} : { allow_downgrade: input.allowDowngrade })
+    };
+}
+function wireAssessCollectionSetupInput(input) {
+    return {
+        application_id: input.applicationId,
+        declaration_digest: input.declarationDigest,
+        requirements: input.requirements,
+        provisions: {
+            configuration: input.provisions.configuration,
+            type_packs: input.provisions.typePacks
+        },
+        ...(input.contractSetups ? { contract_setups: input.contractSetups.map(wireContractSetupChoice) } : {}),
+        ...(input.typePackAdoptions ? { type_pack_adoptions: input.typePackAdoptions } : {})
+    };
+}
+function wireApplyCollectionSetupInput(input) {
+    return {
+        ...wireAssessCollectionSetupInput(input),
+        expected_assessment_digest: input.expectedAssessmentDigest,
+        expected_collection_revision: input.expectedCollectionRevision,
+        expected_provision_digest: input.expectedProvisionDigest,
+        ...(input.allowTypePackDowngrades
+            ? { allow_type_pack_downgrades: input.allowTypePackDowngrades }
+            : {})
+    };
+}
+function wireDeleteResult(value) {
+    return {
+        path: value.path,
+        deleted: value.deleted,
+        ...(value.broken_links ? { brokenLinks: value.broken_links } : {})
+    };
+}
+function wireDeletePreflightResult(value) {
+    return {
+        ...wireDeleteResult(value),
+        deleted: false,
+        dryRun: true,
+        wouldDelete: true
+    };
+}
+function wireRenameResult(value) {
+    const { references_updated, ...record } = value;
+    return {
+        ...wireRecordDocument(record),
+        from: value.from,
+        to: value.to,
+        ...(references_updated ? { referencesUpdated: references_updated } : {})
+    };
+}
+function wireRenamePreflightResult(value) {
+    return {
+        from: value.from,
+        to: value.to,
+        dryRun: true,
+        wouldRename: true,
+        ...(value.references_affected ? { referencesAffected: value.references_affected } : {}),
+        ...(value.warnings ? { warnings: value.warnings } : {})
+    };
+}
+function wireDesiredTimer(timer) {
+    return { id: timer.id, fire_at: timer.fireAt, ...(timer.data === undefined ? {} : { data: timer.data }) };
+}
+function wireTimer(timer) {
+    return {
+        id: timer.id,
+        fireAt: timer.fire_at,
+        ...(timer.data === undefined ? {} : { data: timer.data }),
+        criterionId: timer.criterion_id,
+        generation: timer.generation,
+        status: timer.status,
+        createdAt: timer.created_at,
+        updatedAt: timer.updated_at,
+        firedAt: timer.fired_at
+    };
+}
+function wireContractSetupChoice(choice) {
+    return choice.mode === "starter"
+        ? choice
+        : {
+            contract: choice.contract,
+            mode: "existing",
+            type_name: choice.typeName,
+            type_revision: choice.typeRevision,
+            fields: choice.fields,
+            ...(choice.binding ? { binding: choice.binding } : {})
+        };
+}
+function wireDataContractIdentity(value) {
+    return {
+        id: value.id,
+        version: value.version,
+        digest: value.digest,
+        type: value.type,
+        implementationDigest: value.implementation_digest
+    };
+}
+function wireQueryRecord(value) {
+    const { effective_frontmatter, contract, ...record } = value;
+    return {
+        ...record,
+        ...(effective_frontmatter === undefined ? {} : { effectiveFrontmatter: effective_frontmatter }),
+        ...(contract ? { contract: wireDataContractIdentity(contract) } : {})
+    };
+}
+function wireRecordDocument(value) {
+    const { effective_frontmatter, contract, ...record } = value;
+    return {
+        ...record,
+        effectiveFrontmatter: effective_frontmatter,
+        ...(contract ? { contract: wireDataContractIdentity(contract) } : {})
+    };
+}
+function wireSavedViewExecution(value) {
+    return {
+        results: value.results.map((record) => {
+            const mapped = wireQueryRecord(record);
+            if (!mapped.effectiveFrontmatter) {
+                throw new Error("Saved view result omitted canonical effective frontmatter.");
+            }
+            return { ...mapped, effectiveFrontmatter: mapped.effectiveFrontmatter };
+        }),
+        meta: {
+            totalCount: value.meta.total_count,
+            hasMore: value.meta.has_more,
+            ...(value.meta.cursor ? { cursor: value.meta.cursor } : {}),
+            view: value.meta.view,
+            ...(value.meta.context ? { context: value.meta.context } : {}),
+            ...(value.meta.groups ? { groups: value.meta.groups } : {})
+        }
+    };
+}
+function wireTypePackResource(value) {
+    return {
+        source: value.source,
+        target: value.target,
+        kind: value.kind,
+        mode: value.mode,
+        action: value.action,
+        digest: value.digest,
+        ...(value.current_digest ? { currentDigest: value.current_digest } : {}),
+        ...(value.installed_digest ? { installedDigest: value.installed_digest } : {}),
+        ...(value.adopted_from_digest ? { adoptedFromDigest: value.adopted_from_digest } : {}),
+        ...(value.reason ? { reason: value.reason } : {})
+    };
+}
+function wireTypePackReceipt(value) {
+    return {
+        id: value.id,
+        version: value.version,
+        digest: value.digest,
+        installedBy: value.installed_by,
+        resources: value.resources.map((resource) => ({
+            source: resource.source,
+            target: resource.target,
+            kind: resource.kind,
+            mode: resource.mode,
+            digest: resource.digest,
+            ...(resource.adopted_from_digest ? { adoptedFromDigest: resource.adopted_from_digest } : {})
+        }))
+    };
+}
+function clientContractSetupChoice(choice) {
+    return choice.mode === "starter"
+        ? choice
+        : {
+            contract: choice.contract,
+            mode: "existing",
+            typeName: choice.type_name,
+            typeRevision: choice.type_revision,
+            fields: choice.fields,
+            ...(choice.binding ? { binding: choice.binding } : {})
+        };
+}
+function wireTypePackAssessment(value) {
+    return {
+        status: value.status,
+        applicable: value.applicable,
+        assessmentDigest: value.assessment_digest,
+        ...(value.current ? { current: wireTypePackReceipt(value.current) } : {}),
+        desired: wireTypePackReceipt(value.desired),
+        resources: value.resources.map(wireTypePackResource),
+        lock: value.lock,
+        contractSetups: {
+            choices: value.contract_setups.choices.map(clientContractSetupChoice),
+            resources: value.contract_setups.resources.map(wireTypePackResource)
+        }
+    };
+}
+function wireTypePackApplyResult(value) {
+    return {
+        ...wireTypePackAssessment(value),
+        receipt: wireTypePackReceipt(value.receipt),
+        cleanupDeferred: value.cleanup_deferred
+    };
+}
+function wireCollectionSetupAssessment(value) {
+    return {
+        status: value.status,
+        applicable: value.applicable,
+        applicationId: value.application_id,
+        declarationDigest: value.declaration_digest,
+        provisionDigest: value.provision_digest,
+        collectionRevision: value.collection_revision,
+        finalCollectionRevision: value.final_collection_revision,
+        baselineDiagnosticCount: value.baseline_diagnostic_count,
+        finalDiagnosticCount: value.final_diagnostic_count,
+        resolvedDiagnosticCount: value.resolved_diagnostic_count,
+        introducedDiagnosticCount: value.introduced_diagnostic_count,
+        baselineDiagnosticDigest: value.baseline_diagnostic_digest,
+        configuration: value.configuration,
+        typePacks: value.type_packs.map(wireTypePackAssessment),
+        finalResourceRevisions: value.final_resource_revisions,
+        assessmentDigest: value.assessment_digest
+    };
+}
+function wireCollectionSetupReceipt(value) {
+    return {
+        applicationId: value.application_id,
+        declarationDigest: value.declaration_digest,
+        provisionDigest: value.provision_digest,
+        assessmentDigest: value.assessment_digest,
+        collectionRevision: value.collection_revision,
+        configuration: value.configuration,
+        typePacks: value.type_packs.map(wireTypePackReceipt),
+        cleanupDeferred: value.cleanup_deferred
+    };
+}
+function wireChange(value) {
+    return {
+        cursor: value.cursor,
+        type: value.type,
+        occurredAt: value.occurred_at,
+        payload: value.payload
+    };
+}
+function wireChangesPage(value) {
+    return {
+        events: value.events.map(wireChange),
+        cursor: value.cursor,
+        hasMore: value.has_more,
+        reset: value.reset
+    };
+}
+function wireCollectionDescription(value) {
+    return {
+        protocolVersion: value.protocol_version,
+        collectionId: value.collection_id,
+        displayName: value.display_name,
+        specVersion: value.spec_version,
+        operations: value.operations,
+        changeCursor: value.change_cursor,
+        types: value.types,
+        contracts: value.contracts.map((contract) => ({
+            contractType: contract.contract_type,
+            id: contract.id,
+            version: contract.version,
+            digest: contract.digest,
+            schema: contract.schema,
+            ...(contract.binding_schema ? { bindingSchema: contract.binding_schema } : {}),
+            implementations: contract.implementations.map((implementation) => ({
+                typeName: implementation.type_name,
+                typeVersion: implementation.type_version,
+                ...(implementation.type_path ? { typePath: implementation.type_path } : {}),
+                digest: implementation.digest,
+                fields: implementation.fields,
+                ...(implementation.binding ? { binding: implementation.binding } : {})
+            }))
+        })),
+        ...(value.configuration ? { configuration: value.configuration } : {})
+    };
+}

package/dist/connect-authorization-helpers.d.ts

@@ -0,0 +1,4 @@
+import { MdbaseConnectError } from "./errors.js";
+export declare function assertFreshV2AuthorizationSupport(serverUrl: string, signal?: AbortSignal): Promise<void>;
+export declare function declarationIdFromFamilyIdentity(familyIdentity: string): string;
+export declare function authorizationAbort(signal: AbortSignal, message: string, cause?: unknown): MdbaseConnectError;