@mdbase-dev/connect 0.1.0-beta.121 → 0.1.0-beta.124

package/dist/browser/mdbase-connect.min.js.sha384

@@ -1 +1 @@
-sha384-Nv0Du948fR/kSC/QXiny8mY1SZ2akUFBT7QmsPb3irgnUGNN0LgsWDubjxozn5cU
+sha384-23aqw9c9S7YPXCd5zLVLjUFjKy3QggldsE+mDLmLzzRkxaOnQxOkLxoQ2j1oujFh

package/dist/change-events.d.ts

@@ -0,0 +1,6 @@
+import { type CollectionChange as WireChange, type CollectionChangesPage as WirePage } from "@mdbase-dev/connect-protocol";
+import type { CollectionChange, CollectionChangesPage } from "./operation-types.js";
+/** Normalize authority events once, without inferring metadata missing on older authorities. */
+export declare function normalizeCollectionChange(raw: WireChange): CollectionChange;
+export declare function normalizeChangesPage(raw: WirePage): CollectionChangesPage;
+export declare function invalidatesDescription(change: CollectionChange): boolean;

package/dist/change-events.js

@@ -0,0 +1,95 @@
+import { CHANGE_EVENT_KINDS } from "@mdbase-dev/connect-protocol";
+import { clientFileDescriptor, validFileDescriptor } from "./file-descriptor.js";
+const RECORD_FIELDS = Object.entries({
+    path: string, from: string, to: string, revision: string, previous_revision: string,
+    types: strings, previous_types: strings, changed_fields: strings, body_changed: boolean,
+    before: object, after: object
+});
+const RESOURCE_FIELDS = Object.entries({ path: string, name: string, revision: string, previous_revision: string, reason: string });
+const REMOVED_FILE_FIELDS = Object.entries({ previous_path: string, revision: string });
+/** Normalize authority events once, without inferring metadata missing on older authorities. */
+export function normalizeCollectionChange(raw) {
+    const base = { cursor: raw.cursor, type: raw.type, occurredAt: raw.occurred_at, payload: raw.payload, raw };
+    const unknown = (reason) => ({ ...base, kind: "unknown", reason });
+    const kind = Object.hasOwn(CHANGE_EVENT_KINDS, raw.type)
+        ? CHANGE_EVENT_KINDS[raw.type]
+        : undefined;
+    if (!kind)
+        return unknown("unrecognized_type");
+    const p = raw.payload;
+    if (!object(p))
+        return unknown("invalid_payload");
+    if (kind.startsWith("record.")) {
+        if (!validFields(p, RECORD_FIELDS))
+            return unknown("invalid_payload");
+        const data = p;
+        const metadata = {
+            ...(data.revision == null ? {} : { revision: data.revision }),
+            ...(data.previous_revision == null ? {} : { previousRevision: data.previous_revision }),
+            ...(data.types == null ? {} : { types: data.types }),
+            ...(data.previous_types == null ? {} : { previousTypes: data.previous_types }),
+            ...(data.changed_fields == null ? {} : { changedFields: data.changed_fields }),
+            ...(data.body_changed == null ? {} : { bodyChanged: data.body_changed }),
+            ...(data.before == null ? {} : { before: data.before }),
+            ...(data.after == null ? {} : { after: data.after })
+        };
+        if (kind === "record.renamed") {
+            return string(p.from) && string(p.to)
+                ? { ...base, ...metadata, kind, from: p.from, to: p.to }
+                : unknown("invalid_payload");
+        }
+        if (kind === "record.created" || kind === "record.updated" || kind === "record.deleted") {
+            return string(p.path) ? { ...base, ...metadata, kind, path: p.path } : unknown("invalid_payload");
+        }
+    }
+    if (kind === "file.put") {
+        return validFileDescriptor(p.file)
+            ? { ...base, kind, file: clientFileDescriptor(p.file) }
+            : unknown("invalid_payload");
+    }
+    if (kind === "file.removed") {
+        if (!string(p.file_id) || !validFields(p, REMOVED_FILE_FIELDS))
+            return unknown("invalid_payload");
+        const data = p;
+        return { ...base, kind, fileId: p.file_id,
+            ...(data.previous_path == null ? {} : { previousPath: data.previous_path }),
+            ...(data.revision == null ? {} : { revision: data.revision }) };
+    }
+    if (!validFields(p, RESOURCE_FIELDS))
+        return unknown("invalid_payload");
+    const data = p;
+    if (kind === "gap")
+        return { ...base, kind, ...(data.reason == null ? {} : { reason: data.reason }) };
+    const metadata = {
+        ...(data.revision == null ? {} : { revision: data.revision }),
+        ...(data.previous_revision == null ? {} : { previousRevision: data.previous_revision })
+    };
+    if (kind === "file.changed")
+        return string(p.path) ? { ...base, ...metadata, kind, path: p.path } : unknown("invalid_payload");
+    if (kind === "schema.changed" || kind === "config.changed" || kind === "contract.changed" || kind === "view.changed") {
+        return { ...base, ...metadata, kind,
+            ...(data.path == null ? {} : { path: data.path }),
+            ...(data.name == null ? {} : { name: data.name }) };
+    }
+    throw new Error(`Unhandled change kind: ${kind}`);
+}
+export function normalizeChangesPage(raw) {
+    return {
+        events: raw.reset ? [{ kind: "reset", type: "reset", cursor: raw.cursor, occurredAt: null, payload: {}, raw }] : raw.events.map(normalizeCollectionChange),
+        cursor: raw.cursor,
+        hasMore: raw.has_more,
+        reset: raw.reset
+    };
+}
+export function invalidatesDescription(change) {
+    return change.kind === "schema.changed" || change.kind === "config.changed"
+        || change.kind === "contract.changed" || change.kind === "view.changed"
+        || change.kind === "gap" || change.kind === "reset" || change.kind === "unknown";
+}
+function string(value) { return typeof value === "string"; }
+function boolean(value) { return typeof value === "boolean"; }
+function strings(value) { return Array.isArray(value) && value.every(string); }
+function object(value) { return value !== null && typeof value === "object" && !Array.isArray(value); }
+function validFields(value, fields) {
+    return fields.every(([key, valid]) => value[key] == null || valid(value[key]));
+}

package/dist/collection-client.d.ts

@@ -1,6 +1,6 @@
 import type { CollectionOperation, CollectionTypeDocument, JsonObject } from "@mdbase-dev/connect-protocol";
 import { type CollectionChangesProblemCode, type CollectionDescriptionProblemCode, type CollectionMutationProblemCode, type CollectionQueryProblemCode, type CollectionReadProblemCode, type CollectionTypeProblemCode, type ConnectOutcome } from "./outcomes.js";
-import type { ChangesInput, CollectionChange, CollectionChangesPage, CollectionDescription, CollectionSetupApplyResult, CollectionSetupAssessment, AssessCollectionSetupInput, AssessTypePackInput, ApplyCollectionSetupInput, ApplyTypePackInput, CreateInput, CreateTypeInput, CreateViewSourceInput, DeleteInput, DeletePreflightResult, DeleteResult, DeleteViewSourceInput, DeleteViewSourceResult, ExecuteViewInput, MdbaseCollectionTransport, MdbaseDesiredTimer, MdbaseTimer, MdbaseTimerList, MdbaseTimerReconciliation, ConnectRequestOptions, QueryAllOptions, QueryInput, QueryPage, QueryPagesOptions, QueryResult, ReadInput, ReadTypeInput, ReadViewSourceInput, RenameInput, RenamePreflightResult, RenameResult, RecordDocument, SavedViewExecution, SavedViewPage, SavedViewPagesOptions, SavedViewList, SavedViewSourceDocument, TypePackApplyResult, TypePackAssessment, UpdateInput, UpdateTypeInput, UpdateViewSourceInput, WatchOptions } from "./operation-types.js";
+import type { ChangesInput, DescribeOptions, CollectionChange, CollectionChangesPage, CollectionDescription, CollectionSetupApplyResult, CollectionSetupAssessment, AssessCollectionSetupInput, AssessTypePackInput, ApplyCollectionSetupInput, ApplyTypePackInput, CreateInput, CreateTypeInput, CreateViewSourceInput, DeleteInput, DeletePreflightResult, DeleteResult, DeleteViewSourceInput, DeleteViewSourceResult, ExecuteViewInput, MdbaseCollectionTransport, MdbaseDesiredTimer, MdbaseTimer, MdbaseTimerList, MdbaseTimerReconciliation, ConnectRequestOptions, QueryAllOptions, QueryInput, QueryMetadataInput, QueryMetadataRecord, QueryMetadataResult, QueryMetadataPage, QueryPage, QueryPagesOptions, QueryResult, ReadInput, ReadManyOptions, ReadManyResult, ReadTypeInput, ReadViewSourceInput, RenameInput, RenamePreflightResult, RenameResult, RecordDocument, SavedViewExecution, SavedViewPage, SavedViewPagesOptions, SavedViewList, SavedViewSourceDocument, TypePackApplyResult, TypePackAssessment, UpdateInput, UpdateTypeInput, UpdateViewSourceInput, WatchOptions } from "./operation-types.js";
 /**
  * Typed collection operations independent of OAuth, HTTP, or storage.
  *
@@ -10,13 +10,23 @@ import type { ChangesInput, CollectionChange, CollectionChangesPage, CollectionD
 export declare class MdbaseCollectionClient<Frontmatter extends JsonObject = JsonObject> {
     private readonly transport;
     private readonly requestTimeoutMs;
-    constructor(transport: MdbaseCollectionTransport, requestTimeoutMs?: number | null);
+    private readonly supportsAuthorityFeature?;
+    private readonly descriptions;
+    private lastSchemaCursor;
+    /** Local cache generation, not an authority revision or cross-connection identity. */
+    get schemaGeneration(): number;
+    constructor(transport: MdbaseCollectionTransport, requestTimeoutMs?: number | null, supportsAuthorityFeature?: ((id: string, options?: ConnectRequestOptions) => Promise<ConnectOutcome<boolean>>) | undefined);
     operation<Result>(operation: CollectionOperation, input: unknown, options?: ConnectRequestOptions): Promise<ConnectOutcome<Result>>;
-    describe(options?: ConnectRequestOptions): Promise<ConnectOutcome<CollectionDescription, CollectionDescriptionProblemCode>>;
+    describe(options?: DescribeOptions): Promise<ConnectOutcome<CollectionDescription, CollectionDescriptionProblemCode>>;
     changes(input?: ChangesInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<CollectionChangesPage, CollectionChangesProblemCode>>;
     read(input: ReadInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<RecordDocument<Frontmatter>, CollectionReadProblemCode>>;
+    readMany(paths: readonly string[], options?: ReadManyOptions): Promise<ConnectOutcome<ReadManyResult<Frontmatter>, CollectionQueryProblemCode>>;
+    query(input: QueryMetadataInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<QueryMetadataResult, CollectionQueryProblemCode>>;
     query(input?: QueryInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<QueryResult<Frontmatter>, CollectionQueryProblemCode>>;
+    query(input: QueryInput | QueryMetadataInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<QueryResult<Frontmatter> | QueryMetadataResult, CollectionQueryProblemCode>>;
+    queryPages(input: QueryMetadataInput, options?: QueryPagesOptions<JsonObject, QueryMetadataRecord>): AsyncGenerator<ConnectOutcome<QueryMetadataPage, CollectionQueryProblemCode>>;
     queryPages(input?: QueryInput, options?: QueryPagesOptions<Frontmatter>): AsyncGenerator<ConnectOutcome<QueryPage<Frontmatter>, CollectionQueryProblemCode>>;
+    queryAll(input: QueryMetadataInput, options?: QueryAllOptions<JsonObject, QueryMetadataRecord>): Promise<ConnectOutcome<QueryMetadataResult, CollectionQueryProblemCode>>;
     queryAll(input?: QueryInput, options?: QueryAllOptions<Frontmatter>): Promise<ConnectOutcome<QueryResult<Frontmatter>, CollectionQueryProblemCode>>;
     listViews(options?: ConnectRequestOptions): Promise<ConnectOutcome<SavedViewList, CollectionReadProblemCode>>;
     executeView(input: ExecuteViewInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<SavedViewExecution<Frontmatter>, CollectionReadProblemCode>>;

package/dist/collection-client.js

@@ -1,9 +1,13 @@
 import { abortableDelay } from "./async.js";
+import { invalidatesDescription, normalizeChangesPage } from "./change-events.js";
+import { CollectionDescriptionCache } from "./description-cache.js";
 import { coordinatedQueryPages } from "./query-pagination.js";
+import { readMany as readManyRecords } from "./read-many.js";
+import { wireDataContractIdentity, wireQueryInput, wireQueryRecord, wireQueryResult } from "./query-wire.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 { COLLECTION_CHANGES_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, requestOptionsWithinBudget, withRequestBudget } from "./request-budget.js";
 import { watchRetryPolicy } from "./watch-policy.js";
 /**
  * Typed collection operations independent of OAuth, HTTP, or storage.
@@ -14,44 +18,69 @@ import { watchRetryPolicy } from "./watch-policy.js";
 export class MdbaseCollectionClient {
     transport;
     requestTimeoutMs;
-    constructor(transport, requestTimeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
+    supportsAuthorityFeature;
+    descriptions;
+    lastSchemaCursor = -1;
+    /** Local cache generation, not an authority revision or cross-connection identity. */
+    get schemaGeneration() { return this.descriptions.schemaGeneration; }
+    constructor(transport, requestTimeoutMs = DEFAULT_REQUEST_TIMEOUT_MS, supportsAuthorityFeature) {
         this.transport = transport;
         this.requestTimeoutMs = requestTimeoutMs;
+        this.supportsAuthorityFeature = supportsAuthorityFeature;
+        this.descriptions = new CollectionDescriptionCache(transport, 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);
+    describe(options) {
+        return this.descriptions.describe(options);
     }
     async changes(input = {}, options) {
         const outcome = await this.rawOperation("changes", input, COLLECTION_CHANGES_PROBLEM_CODES, options);
-        return mapOutcome(outcome, wireChangesPage);
+        const mapped = mapOutcome(outcome, normalizeChangesPage);
+        if (mapped.ok) {
+            const invalidations = mapped.value.events.filter(invalidatesDescription);
+            if (mapped.value.reset || invalidations.some((event) => event.cursor > this.lastSchemaCursor)) {
+                this.descriptions.invalidate();
+                this.lastSchemaCursor = mapped.value.cursor;
+            }
+        }
+        return mapped;
     }
     async read(input, options) {
         const outcome = await this.envelopeOperation("read", wireReadInput(input), COLLECTION_READ_PROBLEM_CODES, options);
         return mapOutcome(outcome, wireRecordDocument);
     }
+    readMany(paths, options = {}) {
+        return readManyRecords((input, requestOptions) => this.queryAll(input, requestOptions), (selected, includeBody, requestOptions) => this.envelopeOperation("read", { paths: selected, include_body: includeBody, include_document: false }, COLLECTION_READ_PROBLEM_CODES, requestOptions), this.supportsAuthorityFeature, paths, options, this.requestTimeoutMs);
+    }
     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 } : {})
-                }
-            } : {})
-        }));
+        if (input.output !== undefined && input.output !== "metadata") {
+            return connectFailure(connectProblem("invalid_request", "Unknown query output mode."));
+        }
+        if (input.output !== "metadata") {
+            const outcome = await this.envelopeOperation("query", wireQueryInput(input), COLLECTION_QUERY_PROBLEM_CODES, options);
+            return mapOutcome(outcome, value => wireQueryResult(value, undefined));
+        }
+        const captured = await captureConnectOutcome(() => withRequestBudget(options, this.requestTimeoutMs, async (budget) => {
+            const requestOptions = requestOptionsWithinBudget({ ...options, timeoutMs: null }, budget);
+            if (input.includeBody)
+                throw connectError("invalid_request", "Metadata queries cannot include a body.");
+            const support = await this.supportsAuthorityFeature?.("query-metadata-v1", requestOptions);
+            if (support && !support.ok)
+                throw new MdbaseConnectError(support.problem);
+            if (!support?.value)
+                throw connectError("unsupported_operation", "This authority does not support metadata queries. Use an ordinary query on legacy authorities.");
+            const outcome = await this.envelopeOperation("query", wireQueryInput(input), COLLECTION_QUERY_PROBLEM_CODES, requestOptions);
+            return mapOutcome(outcome, value => wireQueryResult(value, input.output));
+        }), COLLECTION_QUERY_PROBLEM_CODES);
+        return captured.ok ? captured.value : captured;
     }
     async *queryPages(input = {}, options = {}) {
-        yield* coordinatedQueryPages((pageInput, pageOptions) => this.query(pageInput, pageOptions), (cursor) => this.releaseQueryCursor(cursor), input, options);
+        yield* coordinatedQueryPages((pageInput, pageOptions) => this.query(pageInput, pageOptions), (cursor) => this.releaseQueryCursor(cursor, input.output), input, 
+        // The overload ties callback row types to input.output; the wire parser
+        // rejects mode mismatch before pagination can deliver a page.
+        options);
     }
     async queryAll(input = {}, options = {}) {
         const budget = createRequestBudget(options, this.requestTimeoutMs);
@@ -59,14 +88,18 @@ export class MdbaseCollectionClient {
         let finalPage;
         const diagnostics = [];
         try {
-            for await (const outcome of this.queryPages(input, {
+            const pageOptions = {
                 firstPageSize: options.firstPageSize,
                 pageSize: options.pageSize,
+                maxResults: options.maxResults,
                 signal: budget.signal,
                 pageTimeoutMs: null,
-                coordination: options.coordination,
-                onProgress: options.onProgress
-            })) {
+                coordination: options.coordination
+            };
+            const pages = input.output === "metadata"
+                ? this.queryPages(input, { ...pageOptions, onProgress: options.onProgress })
+                : this.queryPages(input, { ...pageOptions, onProgress: options.onProgress });
+            for await (const outcome of pages) {
                 if (!outcome.ok)
                     return outcome;
                 const page = outcome.value;
@@ -76,14 +109,19 @@ export class MdbaseCollectionClient {
             }
             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);
+            const meta = finalPage ? {
+                ...(finalPage.meta?.totalCount === undefined
+                    ? (!finalPage.meta?.hasMore ? { totalCount: results.length } : {})
+                    : { totalCount: finalPage.meta.totalCount }),
+                ...(finalPage.meta?.hasMore && finalPage.meta.totalCountOutcome ? { totalCountOutcome: finalPage.meta.totalCountOutcome } : {}),
+                hasMore: finalPage.meta?.hasMore ?? false,
+                ...(finalPage.snapshot ? { snapshot: finalPage.snapshot } : {})
+            } : undefined;
+            // Every page is parsed in the requested mode, never converted from full
+            // rows to revision-required metadata (or from partial rows to documents).
+            return input.output === "metadata"
+                ? connectSuccess({ output: "metadata", results: results, ...(meta ? { meta } : {}) }, diagnostics)
+                : connectSuccess({ results: results, ...(meta ? { meta } : {}) }, diagnostics);
         }
         catch (error) {
             if (error instanceof MdbaseConnectError) {
@@ -283,9 +321,19 @@ export class MdbaseCollectionClient {
     rawOperation(operation, input, allowedCodes, options) {
         return captureConnectOutcome(() => this.transport.operation(operation, input, options), allowedCodes);
     }
-    async releaseQueryCursor(cursor) {
+    async releaseQueryCursor(cursor, output) {
         try {
-            await this.envelopeOperation("query", { release_cursor: cursor }, COLLECTION_QUERY_PROBLEM_CODES, { timeoutMs: 2_000, coordination: { coalesce: false } });
+            await withRequestBudget({ timeoutMs: 2_000 }, null, async (budget) => {
+                const options = requestOptionsWithinBudget({ signal: budget.signal, timeoutMs: null, coordination: { coalesce: false } }, budget);
+                if (output) {
+                    // A supplied/stale cursor can reach cleanup even when the page was
+                    // rejected before dispatch. Never send metadata release to an old route.
+                    const support = await this.supportsAuthorityFeature?.("query-metadata-v1", options);
+                    if (!support?.ok || !support.value)
+                        return;
+                }
+                await this.envelopeOperation("query", { release_cursor: cursor, ...(output ? { output } : {}) }, COLLECTION_QUERY_PROBLEM_CODES, options);
+            });
         }
         catch {
             // Lease expiry is bounded by the authority; cleanup never masks query results.
@@ -299,11 +347,23 @@ export class MdbaseCollectionClient {
         if (!envelope.valid) {
             return connectFailure(operationProblem(envelope));
         }
+        if (["create_type", "update_type", "apply_type_pack", "apply_collection_setup", "create_view_source", "update_view_source", "delete_view_source"].includes(operation)) {
+            this.descriptions.invalidate();
+        }
         return connectSuccess(envelope.result, envelope.diagnostics);
     }
 }
 function mapOutcome(outcome, map) {
-    return outcome.ok ? connectSuccess(map(outcome.value), outcome.diagnostics) : outcome;
+    if (!outcome.ok)
+        return outcome;
+    try {
+        return connectSuccess(map(outcome.value), outcome.diagnostics);
+    }
+    catch (error) {
+        if (error instanceof MdbaseConnectError)
+            return connectFailure(error.problem);
+        throw error;
+    }
 }
 function wireReadInput(input) {
     return {
@@ -312,47 +372,6 @@ function wireReadInput(input) {
         ...(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 } : {}),
@@ -500,23 +519,6 @@ function wireContractSetupChoice(choice) {
             ...(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 {
@@ -635,47 +637,3 @@ function wireCollectionSetupReceipt(value) {
         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/connection.d.ts

@@ -1,6 +1,7 @@
 import { MdbasePeopleClient } from "./people-client.js";
 import type { CollectionOperation, CollectionTypeDocument, FileCapability, GrantScope, JsonObject } from "@mdbase-dev/connect-protocol";
 import { type MdbaseApplicationCapabilityId as ApplicationCapabilityId } from "./application-contract.js";
+import { MdbaseCollectionClient } from "./collection-client.js";
 import { type ConnectionTransportInternals } from "./connection-transport.js";
 import type { DirectAccessStatus, MdbaseAuthorizationCapabilities, MdbaseConnectionInfo, MdbaseConnectionRoute, MdbaseSyncConnection } from "./connection-types.js";
 import type { GrantKeyStore } from "./crypto.js";
@@ -8,7 +9,7 @@ import { MdbaseFileClient } from "./files.js";
 import { MdbaseRecords } from "./records.js";
 import { type Application } from "./internal-types.js";
 import type { MdbaseNativeNotificationRegistration, MdbaseNativeNotificationRegistrationOptions, MdbaseNotificationRegistration, MdbaseNotificationRegistrationOptions } from "./notifications.js";
-import type { ChangesInput, CollectionChangesPage, CollectionDescription, CollectionSetupApplyResult, CollectionSetupAssessment, ApplyCollectionSetupInput, ApplyTypePackInput, AssessCollectionSetupInput, AssessTypePackInput, CreateInput, CreateTypeInput, CreateViewSourceInput, DeleteInput, DeletePreflightResult, DeleteProgressOptions, DeleteResult, DeleteViewSourceInput, DeleteViewSourceResult, ExecuteViewInput, MdbaseDesiredTimer, MdbaseTimer, MdbaseTimerList, MdbaseTimerReconciliation, ConnectRequestOptions, PendingMutation, QueryAllOptions, QueryInput, QueryPage, QueryPagesOptions, QueryResult, ReadInput, ReadTypeInput, ReadViewSourceInput, RenameInput, RenamePreflightResult, RenameProgressOptions, RenameResult, RecordDocument, SavedViewExecution, SavedViewPage, SavedViewPagesOptions, SavedViewList, SavedViewSourceDocument, TypePackApplyResult, TypePackAssessment, UpdateInput, UpdateTypeInput, UpdateViewSourceInput, MdbaseWatchSubscription, WatchInput } from "./operation-types.js";
+import type { ChangesInput, CollectionChangesPage, DescribeOptions, CollectionDescription, CollectionSetupApplyResult, CollectionSetupAssessment, ApplyCollectionSetupInput, ApplyTypePackInput, AssessCollectionSetupInput, AssessTypePackInput, CreateInput, CreateTypeInput, CreateViewSourceInput, DeleteInput, DeletePreflightResult, DeleteProgressOptions, DeleteResult, DeleteViewSourceInput, DeleteViewSourceResult, ExecuteViewInput, MdbaseDesiredTimer, MdbaseTimer, MdbaseTimerList, MdbaseTimerReconciliation, ConnectRequestOptions, PendingMutation, QueryAllOptions, QueryInput, QueryMetadataInput, QueryMetadataRecord, QueryMetadataResult, QueryMetadataPage, QueryPage, QueryPagesOptions, QueryResult, ReadInput, ReadTypeInput, ReadViewSourceInput, RenameInput, RenamePreflightResult, RenameProgressOptions, RenameResult, RecordDocument, SavedViewExecution, SavedViewPage, SavedViewPagesOptions, SavedViewList, SavedViewSourceDocument, TypePackApplyResult, TypePackAssessment, UpdateInput, UpdateTypeInput, UpdateViewSourceInput, MdbaseWatchSubscription, WatchInput } from "./operation-types.js";
 import { type AuthorizationProblemCode, type CollectionChangesProblemCode, type CollectionDescriptionProblemCode, type CollectionMutationProblemCode, type CollectionQueryProblemCode, type CollectionReadProblemCode, type CollectionTypeProblemCode, type ConnectOutcome, type DirectAccessProblemCode, type NotificationProblemCode, type RegistrationProblemCode } from "./outcomes.js";
 import type { MdbaseDeviceAuthorization } from "./connection-types.js";
 import { type ResolvedConnectTimeouts } from "./request-budget.js";
@@ -75,10 +76,12 @@ export declare class MdbaseConnection<Frontmatter extends JsonObject = JsonObjec
     private readonly collectionClient;
     private readonly notifications;
     private readonly transport;
+    private readonly authorityFeatures;
     readonly files: MdbaseFileClient;
     /** Editable record sessions shared by every view of this connection. */
     readonly records: MdbaseRecords<Frontmatter>;
     readonly people: MdbasePeopleClient;
+    readonly readMany: MdbaseCollectionClient<Frontmatter>["readMany"];
     private readonly connectionListeners;
     constructor(internals: MdbaseConnectionInternals<Frontmatter>, collectionId: string);
     get displayName(): string;
@@ -87,6 +90,9 @@ export declare class MdbaseConnection<Frontmatter extends JsonObject = JsonObjec
     get fileCapability(): FileCapability | null;
     get directAccess(): DirectAccessStatus;
     get route(): MdbaseConnectionRoute;
+    /** Implementation support for this connection lifetime; not an authorization check. */
+    supportsAuthorityFeature(id: string, options?: ConnectRequestOptions): Promise<ConnectOutcome<boolean>>;
+    get authorityCapabilities(): readonly string[];
     register(options?: ConnectRequestOptions): Promise<ConnectOutcome<Application, RegistrationProblemCode>>;
     info(): MdbaseConnectionInfo | null;
     authorizationCapabilities(requiredOperations?: CollectionOperation[]): MdbaseAuthorizationCapabilities;
@@ -123,11 +129,15 @@ export declare class MdbaseConnection<Frontmatter extends JsonObject = JsonObjec
     unregisterNativeNotifications(options?: ConnectRequestOptions): Promise<ConnectOutcome<void, NotificationProblemCode>>;
     unregisterNotifications(serviceWorker?: ServiceWorkerRegistration, options?: ConnectRequestOptions): Promise<ConnectOutcome<void, NotificationProblemCode>>;
     forget(): void;
-    describe(options?: ConnectRequestOptions): Promise<ConnectOutcome<CollectionDescription, CollectionDescriptionProblemCode>>;
+    get schemaGeneration(): number;
+    describe(options?: DescribeOptions): Promise<ConnectOutcome<CollectionDescription, CollectionDescriptionProblemCode>>;
     changes(input?: ChangesInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<CollectionChangesPage, CollectionChangesProblemCode>>;
     read(input: ReadInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<RecordDocument<Frontmatter>, CollectionReadProblemCode>>;
+    query(input: QueryMetadataInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<QueryMetadataResult, CollectionQueryProblemCode>>;
     query(input?: QueryInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<QueryResult<Frontmatter>, CollectionQueryProblemCode>>;
+    queryPages(input: QueryMetadataInput, options?: QueryPagesOptions<JsonObject, QueryMetadataRecord>): AsyncGenerator<ConnectOutcome<QueryMetadataPage, CollectionQueryProblemCode>>;
     queryPages(input?: QueryInput, options?: QueryPagesOptions<Frontmatter>): AsyncGenerator<ConnectOutcome<QueryPage<Frontmatter>, CollectionQueryProblemCode>>;
+    queryAll(input: QueryMetadataInput, options?: QueryAllOptions<JsonObject, QueryMetadataRecord>): Promise<ConnectOutcome<QueryMetadataResult, CollectionQueryProblemCode>>;
     queryAll(input?: QueryInput, options?: QueryAllOptions<Frontmatter>): Promise<ConnectOutcome<QueryResult<Frontmatter>, CollectionQueryProblemCode>>;
     listViews(options?: ConnectRequestOptions): Promise<ConnectOutcome<SavedViewList, CollectionReadProblemCode>>;
     executeView(input: ExecuteViewInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<SavedViewExecution<Frontmatter>, CollectionReadProblemCode>>;