@mdbase-dev/connect 0.1.0-beta.123 → 0.1.0-beta.125

package/dist/query-wire.d.ts

@@ -0,0 +1,61 @@
+import type { CollectionDescription as WireDescription, DataContractViewIdentity as WireIdentity, JsonObject, QueryRecord as WireQueryRecord } from "@mdbase-dev/connect-protocol";
+import type { CollectionDescription, DataContractViewIdentity, QueryInput, QueryMetadataInput, QueryMetadataResult, QueryRecord, QueryResult } from "./operation-types.js";
+export interface WireQueryResult<Frontmatter extends JsonObject> {
+    output?: "metadata";
+    results: Array<WireQueryRecord<Frontmatter> | import("@mdbase-dev/connect-protocol").QueryMetadataRecord>;
+    meta?: {
+        total_count?: number | null;
+        total_count_outcome?: {
+            status: "deferred";
+            budget: "eager_summary_rows";
+            limit: number;
+        };
+        has_more: boolean;
+        cursor?: string;
+        snapshot?: string;
+    };
+}
+export declare function wireQueryInput(input: QueryInput | QueryMetadataInput): {
+    output?: "metadata" | undefined;
+    types?: string[] | undefined;
+    timezone?: string | undefined;
+    context?: {
+        this: {
+            path: string;
+        };
+    } | undefined;
+    projections?: {
+        [k: string]: {
+            expr: string;
+            description?: string | undefined;
+        };
+    } | undefined;
+    where?: string | undefined;
+    select?: (string | {
+        name: string;
+        expr: string;
+        label?: string | undefined;
+        description?: string | undefined;
+    })[] | undefined;
+    order_by?: import("./operation-types.js").QueryOrder[] | undefined;
+    group_by?: import("./operation-types.js").QueryOrder[] | undefined;
+    summary_functions?: {
+        [k: string]: {
+            expr: string;
+            description?: string | undefined;
+        };
+    } | undefined;
+    summaries?: import("./operation-types.js").QuerySummary[] | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+    pagination?: "cursor" | undefined;
+    cursor?: string | undefined;
+    snapshot?: string | undefined;
+    include_body?: boolean | undefined;
+    frontmatter_mode?: "both" | "effective" | "persisted" | undefined;
+    contract?: import("./operation-types.js").DataContractSelector | undefined;
+};
+export declare function wireDataContractIdentity(value: WireIdentity): DataContractViewIdentity;
+export declare function wireQueryRecord<Frontmatter extends JsonObject>(value: WireQueryRecord<Frontmatter>): QueryRecord<Frontmatter>;
+export declare function wireQueryResult<Frontmatter extends JsonObject>(value: WireQueryResult<Frontmatter>, output: "metadata" | undefined): QueryResult<Frontmatter> | QueryMetadataResult;
+export declare function wireCollectionDescription(value: WireDescription): CollectionDescription;

package/dist/query-wire.js

@@ -0,0 +1,110 @@
+import { authorityCapabilities } from "./authority-features.js";
+import { connectError } from "./errors.js";
+export function wireQueryInput(input) {
+    return {
+        ...(input.output ? { output: input.output } : {}),
+        ...(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 } : {})
+    };
+}
+export function wireDataContractIdentity(value) {
+    return {
+        id: value.id, version: value.version, digest: value.digest,
+        type: value.type, implementationDigest: value.implementation_digest
+    };
+}
+export function wireQueryRecord(value) {
+    const { effective_frontmatter, contract, ...record } = value;
+    return {
+        ...record,
+        ...(effective_frontmatter === undefined ? {} : { effectiveFrontmatter: effective_frontmatter }),
+        ...(contract ? { contract: wireDataContractIdentity(contract) } : {})
+    };
+}
+function metadataRecord(value) {
+    if (!value || typeof value.path !== "string" || typeof value.revision !== "string" || !value.revision
+        || !Array.isArray(value.types) || value.types.some(type => typeof type !== "string")
+        || !value.values || typeof value.values !== "object" || Array.isArray(value.values)
+        || Object.keys(value).some(key => !["path", "types", "revision", "values", "contract"].includes(key))
+        || (value.contract !== undefined && (!value.contract
+            || ["id", "version", "digest", "type", "implementation_digest"].some(key => typeof value.contract[key] !== "string")))) {
+        throw connectError("invalid_operation_response", "The authority returned an invalid revision-bearing metadata row.");
+    }
+    return {
+        path: value.path, types: value.types, revision: value.revision, values: value.values,
+        ...(value.contract ? { contract: wireDataContractIdentity(value.contract) } : {})
+    };
+}
+export function wireQueryResult(value, output) {
+    if (!value || !Array.isArray(value.results) || value.output !== output) {
+        throw connectError("invalid_operation_response", "The authority returned an invalid query output mode.");
+    }
+    const meta = value.meta ? {
+        ...(typeof value.meta.total_count === "number" ? { totalCount: value.meta.total_count } : {}),
+        ...(value.meta.total_count_outcome === undefined ? {} : { totalCountOutcome: value.meta.total_count_outcome }),
+        hasMore: value.meta.has_more,
+        ...(value.meta.cursor ? { cursor: value.meta.cursor } : {}),
+        ...(value.meta.snapshot ? { snapshot: value.meta.snapshot } : {})
+    } : undefined;
+    if (output === "metadata")
+        return {
+            output, results: value.results.map(row => metadataRecord(row)),
+            ...(meta ? { meta } : {})
+        };
+    return { results: value.results.map(row => wireQueryRecord(row)), ...(meta ? { meta } : {}) };
+}
+export function wireCollectionDescription(value) {
+    if (!value || value.protocol_version !== 1 || typeof value.collection_id !== "string"
+        || typeof value.display_name !== "string" || typeof value.spec_version !== "string"
+        || !Array.isArray(value.operations) || !Array.isArray(value.types) || !Array.isArray(value.contracts)) {
+        throw connectError("invalid_operation_response", "The authority returned an invalid collection description.");
+    }
+    return {
+        authorityCapabilities: authorityCapabilities(value.authority_capabilities),
+        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/read-many.d.ts

@@ -1,6 +1,7 @@
-import type { JsonObject } from "@mdbase-dev/connect-protocol";
+import { type JsonObject, type ReadManyDocumentsResult } from "@mdbase-dev/connect-protocol";
 import { type CollectionQueryProblemCode, type ConnectOutcome } from "./outcomes.js";
-import type { QueryAllOptions, QueryInput, QueryResult, ReadManyOptions, ReadManyResult } from "./operation-types.js";
+import type { ConnectRequestOptions, QueryAllOptions, QueryInput, QueryResult, ReadManyOptions, ReadManyResult } from "./operation-types.js";
 type QueryAll<Frontmatter extends JsonObject> = (input: QueryInput, options: QueryAllOptions<Frontmatter>) => Promise<ConnectOutcome<QueryResult<Frontmatter>, CollectionQueryProblemCode>>;
-export declare function queryReadMany<Frontmatter extends JsonObject>(queryAll: QueryAll<Frontmatter>, paths: readonly string[], options: ReadManyOptions, defaultTimeoutMs: number | null): Promise<ConnectOutcome<ReadManyResult<Frontmatter>, CollectionQueryProblemCode>>;
+type ReadDocuments<Frontmatter extends JsonObject> = (paths: string[], includeBody: boolean, options: ConnectRequestOptions) => Promise<ConnectOutcome<ReadManyDocumentsResult<Frontmatter>, CollectionQueryProblemCode>>;
+export declare function readMany<Frontmatter extends JsonObject>(queryAll: QueryAll<Frontmatter>, readDocuments: ReadDocuments<Frontmatter>, supports: ((id: string, options: ConnectRequestOptions) => Promise<ConnectOutcome<boolean>>) | undefined, paths: readonly string[], options: ReadManyOptions, defaultTimeoutMs: number | null): Promise<ConnectOutcome<ReadManyResult<Frontmatter>, CollectionQueryProblemCode>>;
 export {};

package/dist/read-many.js

@@ -1,70 +1,175 @@
-import { MdbaseConnectError } from "./errors.js";
-import { connectFailure, connectSuccess } from "./outcomes.js";
-import { createRequestBudget, requestAbortReason } from "./request-budget.js";
-export async function queryReadMany(queryAll, paths, options, defaultTimeoutMs) {
-    const batchSize = boundedInteger(options.batchSize ?? 100, 1_000, "batchSize");
+import { MAX_READ_MANY_PATHS } from "@mdbase-dev/connect-protocol";
+import { MdbaseConnectError, connectError, connectProblem } from "./errors.js";
+import { COLLECTION_QUERY_PROBLEM_CODES, captureConnectOutcome, connectFailure, connectSuccess } from "./outcomes.js";
+import { requestOptionsWithinBudget, withRequestBudget } from "./request-budget.js";
+export async function readMany(queryAll, readDocuments, supports, paths, options, defaultTimeoutMs) {
+    const requestedBatchSize = boundedInteger(options.batchSize ?? 100, 1_000, "batchSize");
     const concurrency = boundedInteger(options.concurrency ?? 4, 4, "concurrency");
-    if (options.coordination?.latestWins) {
+    if (options.coordination?.latestWins)
         throw new TypeError("readMany batches cannot use latestWins coordination.");
-    }
+    if (options.includeBody !== undefined && typeof options.includeBody !== "boolean")
+        throw new TypeError("includeBody must be boolean.");
+    if (options.frontmatterMode !== undefined && !["effective", "persisted", "both"].includes(options.frontmatterMode))
+        throw new TypeError("Invalid frontmatterMode.");
     const inputs = [...paths];
-    const unique = [...new Set(inputs)];
-    const entries = new Map();
-    const errors = [];
-    const budget = createRequestBudget(options, defaultTimeoutMs);
-    let nextBatch = 0;
-    const batchCount = Math.ceil(unique.length / batchSize);
-    const batchDiagnostics = [];
-    const worker = async () => {
-        while (!budget.signal.aborted && nextBatch < batchCount) {
-            const batch = nextBatch++;
-            const selected = unique.slice(batch * batchSize, (batch + 1) * batchSize);
-            const outcome = await queryAll({
-                where: `file.path in ${JSON.stringify(selected)}`,
-                ...(options.types ? { types: options.types } : {}),
-                ...(options.includeBody === undefined ? {} : { includeBody: options.includeBody }),
-                ...(options.frontmatterMode ? { frontmatterMode: options.frontmatterMode } : {})
-            }, {
-                pageSize: selected.length,
-                signal: budget.signal,
-                timeoutMs: null,
-                coordination: options.coordination
-            });
-            if (!outcome.ok) {
-                errors.push({ batch, paths: selected, failure: outcome });
+    try {
+        return await withRequestBudget(options, defaultTimeoutMs, async (budget) => {
+            if (!inputs.length)
+                return connectSuccess({ results: [], errors: [] });
+            const requestOptions = requestOptionsWithinBudget({ ...options, timeoutMs: null, coordination: { ...options.coordination, coalesce: false } }, budget);
+            const unique = [...new Set(inputs)];
+            const entries = new Map();
+            const errors = [];
+            const batchDiagnostics = [];
+            let nextBatch = 0;
+            let nextPath = 0;
+            const failBatch = (batch, selected, failure) => {
+                errors.push({ batch, paths: selected, failure });
                 for (const path of selected)
                     entries.set(path, { status: "error", path, batch });
-                continue;
-            }
-            batchDiagnostics[batch] = outcome.diagnostics;
-            const records = new Map(outcome.value.results.map(record => [record.path, record]));
-            for (const path of selected) {
-                const record = records.get(path);
-                entries.set(path, record ? { status: "found", path, record } : { status: "missing", path });
-            }
-        }
-    };
-    try {
-        await Promise.all(Array.from({ length: Math.min(concurrency, batchCount) }, worker));
-        if (budget.signal.aborted)
-            throw requestAbortReason(budget.signal);
-        return connectSuccess({
-            results: inputs.map(path => entries.get(path)),
-            errors: errors.sort((a, b) => a.batch - b.batch)
-        }, batchDiagnostics.flat());
+            };
+            const worker = async () => {
+                while (!budget.signal.aborted && nextPath < unique.length) {
+                    // Recheck cached lifetime evidence at each admission: queued work must
+                    // not borrow a retired route's support after reconnect/reauthorization.
+                    const support = await supports?.("read-many-documents-v1", requestOptions);
+                    if (support && !support.ok) {
+                        nextPath = unique.length;
+                        throw new MdbaseConnectError(support.problem);
+                    }
+                    if (budget.signal.aborted || nextPath >= unique.length)
+                        return;
+                    let documents = support?.value === true;
+                    // Writer, Reader, TaskNotes, editor and standalone legacy providers
+                    // retain typed path queries until B1's minimum-authority, consumer-pin
+                    // adoption, N-1/rollback and connection-cache windows close. No probing.
+                    const batchSize = documents ? Math.min(requestedBatchSize, MAX_READ_MANY_PATHS) : requestedBatchSize;
+                    const batch = nextBatch++;
+                    const selected = unique.slice(nextPath, nextPath + batchSize);
+                    nextPath += selected.length;
+                    const criteria = { where: `file.path in ${JSON.stringify(selected)}`, ...(options.types ? { types: options.types } : {}) };
+                    try {
+                        let targets = selected;
+                        let diagnostics = [];
+                        if (documents && options.types !== undefined) {
+                            // Only the authority evaluates type membership. This selection
+                            // is discovery, not a snapshot pinned across the subsequent read.
+                            const selection = await queryAll({ ...criteria, select: ["file.path"], includeBody: false }, { ...requestOptions, pageSize: selected.length });
+                            if (!selection.ok) {
+                                failBatch(batch, selected, selection);
+                                continue;
+                            }
+                            const matches = new Set(selection.value.results.map(record => record.path));
+                            targets = selected.filter(path => matches.has(path));
+                            diagnostics = selection.diagnostics;
+                            // Selection can change the route. Reuse the real legacy query
+                            // only on fresh unsupported evidence, never on selection errors.
+                            const current = await supports("read-many-documents-v1", requestOptions);
+                            if (!current.ok)
+                                throw new MdbaseConnectError(current.problem);
+                            documents = current.value;
+                        }
+                        if (!documents) {
+                            const outcome = await queryAll({
+                                ...criteria,
+                                ...(options.includeBody === undefined ? {} : { includeBody: options.includeBody }),
+                                ...(options.frontmatterMode ? { frontmatterMode: options.frontmatterMode } : {})
+                            }, { ...requestOptions, pageSize: selected.length });
+                            if (!outcome.ok) {
+                                failBatch(batch, selected, outcome);
+                                continue;
+                            }
+                            batchDiagnostics[batch] = outcome.diagnostics;
+                            const records = new Map(outcome.value.results.map(record => [record.path, record]));
+                            for (const path of selected) {
+                                const record = records.get(path);
+                                entries.set(path, record ? { status: "found", path, record } : { status: "missing", path });
+                            }
+                            continue;
+                        }
+                        if (budget.signal.aborted)
+                            return;
+                        const outcome = targets.length
+                            ? await readDocuments(targets, options.includeBody ?? false, requestOptions)
+                            : connectSuccess({ items: [] });
+                        if (!outcome.ok) {
+                            failBatch(batch, selected, outcome);
+                            continue;
+                        }
+                        // Parse the entire batch before installing any result: malformed or
+                        // incoherently bound data never becomes successful partial/missing data.
+                        const parsed = documentEntries(outcome.value, targets, batch, options);
+                        for (const path of selected)
+                            entries.set(path, parsed.entries.get(path) ?? { status: "missing", path });
+                        batchDiagnostics[batch] = [...diagnostics, ...outcome.diagnostics];
+                        if (parsed.errors.length)
+                            errors.push({
+                                batch, paths: parsed.errors.map(error => error.path),
+                                failure: connectFailure(connectProblem("operation_invalid", "Some batch records could not be read.", { details: { diagnostics: parsed.errors } }))
+                            });
+                    }
+                    catch (error) {
+                        if (!(error instanceof MdbaseConnectError))
+                            throw error;
+                        const failure = await captureConnectOutcome(async () => { throw error; }, COLLECTION_QUERY_PROBLEM_CODES);
+                        failBatch(batch, selected, failure);
+                    }
+                }
+            };
+            await Promise.all(Array.from({ length: Math.min(concurrency, unique.length) }, worker));
+            return connectSuccess({ results: inputs.map(path => entries.get(path)), errors: errors.sort((a, b) => a.batch - b.batch) }, batchDiagnostics.flat());
+        });
     }
     catch (error) {
         if (error instanceof MdbaseConnectError)
-            return connectFailure(error.problem);
+            return captureConnectOutcome(async () => { throw error; }, COLLECTION_QUERY_PROBLEM_CODES);
         throw error;
     }
-    finally {
-        budget.dispose();
-    }
 }
+function documentEntries(value, paths, batch, options) {
+    if (!value || !Array.isArray(value.items) || value.items.length !== paths.length)
+        invalidResponse();
+    const entries = new Map();
+    const errors = [];
+    value.items.forEach((item, index) => {
+        if (!item || item.path !== paths[index])
+            invalidResponse();
+        switch (item.status) {
+            case "found":
+                entries.set(item.path, { status: "found", path: item.path, record: documentRecord(item.record, item.path, options) });
+                break;
+            case "missing":
+                entries.set(item.path, { status: "missing", path: item.path });
+                break;
+            case "error":
+                if (!item.error || typeof item.error.code !== "string" || typeof item.error.message !== "string")
+                    invalidResponse();
+                entries.set(item.path, { status: "error", path: item.path, batch });
+                errors.push({ severity: "error", code: item.error.code, message: item.error.message, path: item.path });
+                break;
+            default: invalidResponse();
+        }
+    });
+    return { entries, errors };
+}
+function documentRecord(record, path, options) {
+    if (!record || record.path !== path || typeof record.revision !== "string" || !record.revision
+        || !Array.isArray(record.types) || record.types.some(type => typeof type !== "string")
+        || !object(record.frontmatter) || !object(record.effective_frontmatter) || !object(record.file)
+        || ((options.includeBody ?? false) && typeof record.body !== "string") || record.contract !== undefined)
+        invalidResponse();
+    const mode = options.frontmatterMode ?? "effective";
+    return {
+        path: record.path, revision: record.revision, types: record.types, file: record.file,
+        ...(mode !== "effective" ? { frontmatter: record.frontmatter } : {}),
+        ...(mode !== "persisted" ? { effectiveFrontmatter: record.effective_frontmatter } : {}),
+        ...(options.includeBody ? { body: record.body } : {})
+    };
+}
+function object(value) { return !!value && typeof value === "object" && !Array.isArray(value); }
+function invalidResponse() { throw connectError("invalid_operation_response", "The authority returned an invalid or incoherently bound document batch."); }
 function boundedInteger(value, max, name) {
-    if (!Number.isSafeInteger(value) || value < 1 || value > max) {
+    if (!Number.isSafeInteger(value) || value < 1 || value > max)
         throw new TypeError(`${name} must be an integer between 1 and ${max}.`);
-    }
     return value;
 }

package/dist/watch-policy.d.ts

@@ -1,4 +1,5 @@
-import type { WatchOptions } from "./operation-types.js";
+import type { CollectionChange, MdbaseWatchSubscription, WatchInput, WatchOptions, WatchStatus } from "./operation-types.js";
+import type { ConnectOutcome } from "./outcomes.js";
 export interface ResolvedWatchRetryOptions {
     initialDelayMs: number;
     maxDelayMs: number;
@@ -6,3 +7,23 @@ export interface ResolvedWatchRetryOptions {
     maxAttempts?: number;
 }
 export declare function watchRetryPolicy(options: WatchOptions["retry"]): ResolvedWatchRetryOptions | undefined;
+export declare class CollectionWatchSubscription implements MdbaseWatchSubscription {
+    private readonly watch;
+    private readonly input;
+    private readonly watchStartTimeoutMs;
+    private readonly changes;
+    private readonly statuses;
+    private readonly problems;
+    private readonly controller;
+    private removeLifetimeAbort?;
+    private currentStatus;
+    private currentProblem;
+    private pendingChanges;
+    constructor(watch: (options: WatchOptions) => AsyncIterable<ConnectOutcome<CollectionChange>>, cursor: number, input: WatchInput, pendingChanges: CollectionChange[], watchStartTimeoutMs: number | null);
+    get status(): WatchStatus;
+    get problem(): import("@mdbase-dev/connect-protocol").ConnectProblem | null;
+    subscribe(listener: (change: CollectionChange) => void, onStatus?: (status: WatchStatus) => void, onProblem?: (problem: import("@mdbase-dev/connect-protocol").ConnectProblem) => void): () => void;
+    close(): void;
+    private run;
+    private publishStatus;
+}

package/dist/watch-policy.js

@@ -10,3 +10,107 @@ export function watchRetryPolicy(options) {
             : { maxAttempts: Math.max(0, options.maxAttempts) })
     };
 }
+export class CollectionWatchSubscription {
+    watch;
+    input;
+    watchStartTimeoutMs;
+    changes = new Set();
+    statuses = new Set();
+    problems = new Set();
+    controller = new AbortController();
+    removeLifetimeAbort;
+    currentStatus;
+    currentProblem = null;
+    pendingChanges;
+    constructor(watch, cursor, input, pendingChanges, watchStartTimeoutMs) {
+        this.watch = watch;
+        this.input = input;
+        this.watchStartTimeoutMs = watchStartTimeoutMs;
+        this.pendingChanges = [...pendingChanges];
+        this.currentStatus = { state: "connected", cursor, recovered: false };
+        const lifetimeSignal = input.lifetimeSignal;
+        if (lifetimeSignal?.aborted)
+            this.close();
+        else if (lifetimeSignal) {
+            const close = () => this.close();
+            lifetimeSignal.addEventListener("abort", close, { once: true });
+            this.removeLifetimeAbort = () => lifetimeSignal.removeEventListener("abort", close);
+        }
+        if (!this.controller.signal.aborted)
+            void this.run(cursor);
+    }
+    get status() { return this.currentStatus; }
+    get problem() { return this.currentProblem; }
+    subscribe(listener, onStatus, onProblem) {
+        this.changes.add(listener);
+        if (onStatus) {
+            this.statuses.add(onStatus);
+            onStatus(this.currentStatus);
+        }
+        if (onProblem) {
+            this.problems.add(onProblem);
+            if (this.currentProblem)
+                onProblem(this.currentProblem);
+        }
+        for (const change of this.pendingChanges)
+            listener(change);
+        this.pendingChanges = [];
+        return () => {
+            this.changes.delete(listener);
+            if (onStatus)
+                this.statuses.delete(onStatus);
+            if (onProblem)
+                this.problems.delete(onProblem);
+        };
+    }
+    close() {
+        if (this.controller.signal.aborted)
+            return;
+        this.controller.abort();
+        this.removeLifetimeAbort?.();
+        this.removeLifetimeAbort = undefined;
+        const cursor = "cursor" in this.currentStatus ? this.currentStatus.cursor : undefined;
+        this.publishStatus({ state: "closed", ...(cursor === undefined ? {} : { cursor }) });
+    }
+    async run(cursor) {
+        let firstStatus = true;
+        const iterator = this.watch({
+            cursor,
+            pollIntervalMs: this.input.pollIntervalMs,
+            retry: this.input.retry,
+            signal: this.controller.signal,
+            timeoutMs: this.watchStartTimeoutMs,
+            onStatus: (status) => {
+                if (firstStatus && status.state === "connecting") {
+                    firstStatus = false;
+                    return;
+                }
+                firstStatus = false;
+                this.publishStatus(status);
+            }
+        });
+        try {
+            for await (const outcome of iterator) {
+                if (this.controller.signal.aborted)
+                    return;
+                if (!outcome.ok) {
+                    this.currentProblem = outcome.problem;
+                    for (const listener of this.problems)
+                        listener(outcome.problem);
+                    return;
+                }
+                for (const listener of this.changes)
+                    listener(outcome.value);
+            }
+        }
+        finally {
+            if (!this.controller.signal.aborted)
+                this.close();
+        }
+    }
+    publishStatus(status) {
+        this.currentStatus = status;
+        for (const listener of this.statuses)
+            listener(status);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mdbase-dev/connect",
-  "version": "0.1.0-beta.123",
+  "version": "0.1.0-beta.125",
   "private": false,
   "type": "module",
   "license": "MIT",
@@ -33,7 +33,7 @@
     "README.md"
   ],
   "dependencies": {
-    "@mdbase-dev/connect-protocol": "0.1.0-beta.123"
+    "@mdbase-dev/connect-protocol": "0.1.0-beta.125"
   },
   "devDependencies": {
     "esbuild": "^0.28.1",
@@ -42,7 +42,7 @@
   },
   "scripts": {
     "build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.json && node scripts/build-browser.mjs",
-    "test": "vitest run",
+    "test": "node ../../scripts/ci/vitest.mjs",
     "test:browser-storage": "pnpm build && node scripts/browser-storage.test.mjs",
     "test:consumer-spikes": "tsc -p tsconfig.consumer-spikes.json",
     "test:public-api": "pnpm build && pnpm --filter @mdbase-dev/connect-protocol build && pnpm --filter @mdbase-dev/connect-testing build && tsc -p tsconfig.public-api.json && node scripts/check-public-api.mjs && node scripts/test-packed-api.mjs",