@mdbase-dev/connect 0.1.0-beta.32 → 0.1.0-beta.33

package/dist/collection-client.js

@@ -1,6 +1,8 @@
 import { abortableDelay } from "./async.js";
-import { connectError, connectProblem, operationProblem } from "./errors.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.
  *
@@ -9,23 +11,38 @@ import { COLLECTION_CHANGES_PROBLEM_CODES, COLLECTION_DESCRIPTION_PROBLEM_CODES,
  */
 export class MdbaseCollectionClient {
     transport;
-    constructor(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);
     }
-    describe(options) {
-        return this.rawOperation("describe", {}, COLLECTION_DESCRIPTION_PROBLEM_CODES, options);
-    }
-    changes(input = {}, options) {
-        return this.rawOperation("changes", input, COLLECTION_CHANGES_PROBLEM_CODES, options);
-    }
-    read(input, options) {
-        return this.envelopeOperation("read", input, COLLECTION_READ_PROBLEM_CODES, options);
-    }
-    query(input = {}, options) {
-        return this.envelopeOperation("query", input, COLLECTION_QUERY_PROBLEM_CODES, options);
+    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: {
+                    totalCount: meta.total_count,
+                    hasMore: meta.has_more,
+                    ...(meta.snapshot ? { snapshot: meta.snapshot } : {})
+                }
+            } : {})
+        }));
     }
     async *queryPages(input = {}, options = {}) {
         const { offset: requestedOffset, limit: requestedLimit, snapshot: requestedSnapshot, ...criteria } = input;
@@ -41,7 +58,7 @@ export class MdbaseCollectionClient {
                 offset,
                 limit: pageNumber === 0 ? firstPageSize : pageSize,
                 ...(snapshot ? { snapshot } : {})
-            }, { signal: options.signal, timeoutMs: options.timeoutMs });
+            }, { signal: options.signal, timeoutMs: options.pageTimeoutMs });
             if (!queried.ok) {
                 yield queried;
                 return;
@@ -55,7 +72,7 @@ export class MdbaseCollectionClient {
             if (!snapshot && returnedSnapshot)
                 snapshot = returnedSnapshot;
             loaded += result.results.length;
-            const complete = !result.meta?.has_more || result.results.length === 0;
+            const complete = !result.meta?.hasMore || result.results.length === 0;
             const page = {
                 results: result.results,
                 ...(result.meta ? { meta: result.meta } : {}),
@@ -74,32 +91,54 @@ export class MdbaseCollectionClient {
         }
     }
     async queryAll(input = {}, options = {}) {
+        const budget = createRequestBudget(options, this.requestTimeoutMs);
         const results = [];
         let finalPage;
         const diagnostics = [];
-        for await (const outcome of this.queryPages(input, options)) {
-            if (!outcome.ok)
-                return outcome;
-            const page = outcome.value;
-            results.push(...page.results);
-            finalPage = page;
-            diagnostics.push(...outcome.diagnostics);
+        try {
+            for await (const outcome of this.queryPages(input, {
+                firstPageSize: options.firstPageSize,
+                pageSize: options.pageSize,
+                signal: budget.signal,
+                pageTimeoutMs: null,
+                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: {
+                    ...(finalPage?.meta ?? {}),
+                    totalCount: finalPage?.meta?.totalCount ?? results.length,
+                    hasMore: finalPage ? !finalPage.complete : false,
+                    ...(finalPage?.snapshot ? { snapshot: finalPage.snapshot } : {})
+                }
+            }, diagnostics);
         }
-        return connectSuccess({
-            results,
-            meta: {
-                ...(finalPage?.meta ?? {}),
-                total_count: finalPage?.meta?.total_count ?? results.length,
-                has_more: finalPage ? !finalPage.complete : false,
-                ...(finalPage?.snapshot ? { snapshot: finalPage.snapshot } : {})
+        catch (error) {
+            if (error instanceof MdbaseConnectError) {
+                return connectFailure(error.problem);
             }
-        }, diagnostics);
+            throw error;
+        }
+        finally {
+            budget.dispose();
+        }
     }
-    listViews(options) {
-        return this.envelopeOperation("list_views", {}, COLLECTION_READ_PROBLEM_CODES, options);
+    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 } }));
     }
-    executeView(input, options) {
-        return this.envelopeOperation("execute_view", input, COLLECTION_READ_PROBLEM_CODES, options);
+    async executeView(input, options) {
+        const outcome = await this.envelopeOperation("execute_view", input, COLLECTION_READ_PROBLEM_CODES, options);
+        return mapOutcome(outcome, wireSavedViewExecution);
     }
     readViewSource(input, options) {
         return this.envelopeOperation("read_view_source", input, COLLECTION_READ_PROBLEM_CODES, options);
@@ -108,28 +147,41 @@ export class MdbaseCollectionClient {
         return this.envelopeOperation("create_view_source", input, COLLECTION_MUTATION_PROBLEM_CODES, options);
     }
     updateViewSource(input, options) {
-        return this.envelopeOperation("update_view_source", input, COLLECTION_MUTATION_PROBLEM_CODES, options);
+        return this.envelopeOperation("update_view_source", wireRevisionInput(input), COLLECTION_MUTATION_PROBLEM_CODES, options);
     }
     deleteViewSource(input, options) {
-        return this.envelopeOperation("delete_view_source", input, COLLECTION_MUTATION_PROBLEM_CODES, options);
-    }
-    create(input, options) {
-        return this.envelopeOperation("create", input, COLLECTION_MUTATION_PROBLEM_CODES, options);
-    }
-    update(input, options) {
-        return this.envelopeOperation("update", input, COLLECTION_MUTATION_PROBLEM_CODES, options);
-    }
-    delete(input, options) {
-        return this.envelopeOperation("delete", input, COLLECTION_MUTATION_PROBLEM_CODES, options);
-    }
-    preflightDelete(input, options) {
-        return this.envelopeOperation("delete", { ...input, check_backlinks: true, dry_run: true }, COLLECTION_MUTATION_PROBLEM_CODES, options);
-    }
-    rename(input, options) {
-        return this.envelopeOperation("rename", input, COLLECTION_MUTATION_PROBLEM_CODES, options);
-    }
-    preflightRename(input, options) {
-        return this.envelopeOperation("rename", { ...input, dry_run: true }, COLLECTION_MUTATION_PROBLEM_CODES, 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);
@@ -141,25 +193,56 @@ export class MdbaseCollectionClient {
         return this.envelopeOperation("create_type", input, COLLECTION_TYPE_PROBLEM_CODES, options);
     }
     updateType(input, options) {
-        return this.envelopeOperation("update_type", input, COLLECTION_TYPE_PROBLEM_CODES, options);
-    }
-    assessTypePack(input, options) {
-        return this.envelopeOperation("assess_type_pack", input, COLLECTION_TYPE_PROBLEM_CODES, options);
-    }
-    applyTypePack(input, options) {
-        return this.envelopeOperation("apply_type_pack", input, COLLECTION_TYPE_PROBLEM_CODES, options);
-    }
-    listTimers(namespace, options) {
-        return this.rawOperation("list_timers", { namespace }, COLLECTION_READ_PROBLEM_CODES, options);
-    }
-    putTimer(input, options) {
-        return this.rawOperation("put_timer", input, COLLECTION_MUTATION_PROBLEM_CODES, 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);
     }
-    reconcileTimers(input, options) {
-        return this.rawOperation("reconcile_timers", 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;
@@ -220,7 +303,7 @@ export class MdbaseCollectionClient {
             for (const event of page.events)
                 yield connectSuccess(event);
             cursor = page.cursor;
-            if (!page.has_more) {
+            if (!page.hasMore) {
                 try {
                     await abortableDelay(pollInterval, options.signal);
                 }
@@ -245,14 +328,376 @@ export class MdbaseCollectionClient {
         return connectSuccess(envelope.result, envelope.diagnostics);
     }
 }
-function watchRetryPolicy(options) {
-    if (options === false)
-        return undefined;
+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.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.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) } : {})
+    };
+}
+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,
+            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,
+        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 {
-        initialDelayMs: Math.max(0, options?.initialDelayMs ?? 500),
-        maxDelayMs: Math.max(0, options?.maxDelayMs ?? 15_000),
-        multiplier: Math.max(1, options?.multiplier ?? 2),
-        ...(options?.maxAttempts === undefined ? {} : { maxAttempts: Math.max(0, options.maxAttempts) })
+        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 } : {})
     };
 }
 function nonNegativeInteger(value, fallback) {

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

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