@agentshouse/mdruntime 0.1.0-cb0eb0d87ff49 → 0.1.0-cb2e390ee7b89

package/dist/read-side.js

@@ -2,6 +2,7 @@ import { and, BasicIndex, configureIndexDevMode, count, createCollection, create
 import { ARRAY_INDEX, parse, pointerSegments } from '@agentshouse/mdmodel';
 import { documentKey } from './rows.js';
 import { after, inUnits, ROW_WEIGHT } from './turn.js';
+import { beyond, cursorOf, MAXIMUM_WINDOW, windowed } from './windows.js';
 function every(expressions) {
     const [first, second, ...rest] = expressions;
     return second === undefined ? first : and(first, second, ...rest);
@@ -59,10 +60,11 @@ function reached(reach, room, document) {
         ? []
         : [or(inArray(room, [...reach.rooms]), inArray(document, [...reach.documents]))];
 }
-function scoped(scope, row, rooms, reach) {
+function scoped(scope, row, rooms, reach, paths = null) {
     return every([
         eq(row.kind, 'document'),
         ...(rooms === null ? [] : [inArray(row.room, [...rooms])]),
+        ...(paths === null ? [] : [inArray(row.path, [...paths])]),
         ...reached(reach, row.room, row.key),
         ...(scope.types === null ? [] : [inArray(row.type, [...scope.types])]),
         ...(scope.pathPrefix === null ? [] : [inArray(scope.pathPrefix, row.directories)]),
@@ -90,7 +92,7 @@ function related(q, rows, scope, field, kept, reach) {
 }
 function filtered(q, rows, plan) {
     const from = q.from({ d: rows });
-    let query = narrowed(from.where(({ d }) => scoped(plan.root, d, plan.rooms, plan.reach)), plan.root.where, 'd');
+    let query = narrowed(from.where(({ d }) => scoped(plan.root, d, plan.rooms, plan.reach, plan.paths)), plan.root.where, 'd');
     if (plan.hop !== null) {
         const hop = related(q, rows, plan.hop, plan.hop.field, 'source', plan.reach);
         query = query.innerJoin({ h: hop }, ({ d, h }) => eq(d.key, h.key));
@@ -104,25 +106,56 @@ function filtered(q, rows, plan) {
 function bodied(shape) {
     return shape.sections !== null || shape.preamble || shape.markdown;
 }
+function orderingOf(options) {
+    const collated = options.stringSort === 'locale';
+    return {
+        direction: options.direction,
+        nulls: options.nulls ?? 'first',
+        stringSort: options.stringSort ?? 'locale',
+        locale: collated ? options.locale : undefined,
+        localeOptions: collated
+            ? options.localeOptions
+            : undefined,
+    };
+}
+function storedValue(key, row) {
+    return key.of === 'field' ? row.values[key.field] : row[key.of];
+}
+function documentOrder(shape) {
+    return shape.orderBy.map(({ options }) => orderingOf(options));
+}
+function documentCursor(shape, row) {
+    return cursorOf([
+        ...shape.orderBy.map((_, index) => row[`order${index}`]),
+        documentKey(row.room, row.path),
+    ]);
+}
 function documents(q, rows, plan, shape) {
     let query = filtered(q, rows, plan);
+    const cursor = plan.after?.values ?? null;
+    if (cursor !== null) {
+        const orderings = documentOrder(shape);
+        query = query.fn.where(({ d }) => beyond([...shape.orderBy.map(({ key }) => storedValue(key, d)), d.key], cursor, orderings));
+    }
     for (const { key, options } of shape.orderBy) {
         query = query.orderBy(({ d }) => keyed(key, d), options);
     }
-    if (shape.orderBy.length === 0 && plan.limit !== null) {
+    if (shape.orderBy.length > 0 || plan.limit !== null || plan.after !== null) {
         query = query.orderBy(({ d }) => d.key, { stringSort: 'lexical' });
     }
     if (plan.limit !== null)
-        query = query.limit(plan.limit);
+        query = query.limit(plan.limit + 1);
     return query.select(({ d }) => ({
         room: d.room,
         path: d.path,
         type: d.type,
         binary: d.binary,
+        ...Object.fromEntries(shape.orderBy.map(({ key }, index) => [`order${index}`, keyed(key, d)])),
         ...(shape.fields === null ? {} : { fields: d.fields }),
         ...(bodied(shape) ? { text: d.text } : {}),
         ...(shape.backlinks ? { backlinks: toArray(backlinked(q, rows, d, plan.reach)) } : {}),
         ...(shape.change ? { change: d.change } : {}),
+        ...(shape.fileId ? { fileId: d.fileId } : {}),
     }));
 }
 function backlinked(q, rows, document, reach) {
@@ -133,15 +166,13 @@ function backlinked(q, rows, document, reach) {
         .orderBy(({ r }) => r.field, { stringSort: 'lexical' })
         .select(({ r }) => ({ path: r.path, type: r.type, field: r.field }));
 }
-function groups(q, stage, shape, limit) {
+function groups(q, stage, shape) {
     const keys = shape.groupBy.map((_, index) => `key${index}`);
     const from = q.from({ m: stage });
     let query = from.groupBy(({ m }) => keys.map((key) => m[key]));
     for (const { by, direction } of shape.orderBy) {
         query = query.orderBy(({ m }) => (by === 'count' ? count(m.key) : m[keys[by]]), direction);
     }
-    if (limit !== null && shape.orderBy.length > 0)
-        query = query.limit(limit);
     return query.select(({ m }) => ({
         ...Object.fromEntries(keys.map((key) => [key, m[key]])),
         count: count(m.key),
@@ -151,15 +182,27 @@ function built(rows, plan) {
     const shape = plan.shape;
     if (shape.kind === 'documents') {
         const collection = live((q) => documents(q, rows, plan, shape));
-        return { live: collection, dispose: () => void collection.cleanup() };
+        const count = plan.total
+            ? live((q) => filtered(q, rows, plan).select(({ d }) => ({ key: d.key })))
+            : null;
+        return {
+            live: collection,
+            count,
+            dispose: () => {
+                void collection.cleanup();
+                if (count !== null)
+                    void count.cleanup();
+            },
+        };
     }
     const stage = live((q) => filtered(q, rows, plan).select(({ d }) => ({
         key: d.key,
         ...Object.fromEntries(shape.groupBy.map((key, index) => [`key${index}`, keyed(key, d)])),
     })));
-    const collection = live((q) => groups(q, stage, shape, plan.limit));
+    const collection = live((q) => groups(q, stage, shape));
     return {
         live: collection,
+        count: null,
         dispose: () => {
             void collection.cleanup();
             void stage.cleanup();
@@ -239,6 +282,7 @@ function documentOf(key, row, shape, bodies) {
             room: row.room,
             path: row.path,
             ...(binary === null ? {} : { binaryFile: binary }),
+            ...(shape.fileId ? { fileId: row.fileId } : {}),
         };
     }
     const body = bodied(shape) ? bodyOf(row, key, bodies) : null;
@@ -260,33 +304,74 @@ function documentOf(key, row, shape, bodies) {
         ...(shape.markdown && body !== null ? { markdown: body.content } : {}),
         ...(shape.backlinks
             ? {
-                backlinks: row.backlinks.map(({ path, type, field }) => ({ path, type, field })),
+                backlinks: row.backlinks
+                    .slice(0, MAXIMUM_WINDOW)
+                    .map(({ path, type, field }) => ({ path, type, field })),
             }
             : {}),
         ...(shape.change ? { change: row.change } : {}),
+        ...(shape.fileId ? { fileId: row.fileId } : {}),
     };
 }
 function weight(row) {
     return ROW_WEIGHT + (typeof row?.text === 'string' ? row.text.length : 0);
 }
-function rowsOfPlan(plan, entries, bodies, each = (row) => row) {
+function groupValues(shape, [key, row]) {
+    return [...shape.orderBy.map(({ by }) => (by === 'count' ? row.count : row[`key${by}`])), key];
+}
+function groupOrder(shape) {
+    return shape.orderBy.map(({ direction }) => ({
+        direction,
+        nulls: 'first',
+        stringSort: 'locale',
+        locale: undefined,
+        localeOptions: undefined,
+    }));
+}
+function windowOf(plan, entries, total) {
+    const shape = plan.shape;
+    if (shape.kind === 'documents') {
+        return {
+            ...windowed(entries, plan.limit, plan.after?.text, ([, row]) => documentCursor(shape, row)),
+            total,
+        };
+    }
+    const cursor = plan.after?.values ?? null;
+    const orderings = groupOrder(shape);
+    const following = cursor === null
+        ? entries
+        : entries.filter((entry) => beyond(groupValues(shape, entry), cursor, orderings));
+    return {
+        ...windowed(following, plan.limit, plan.after?.text, (entry) => cursorOf(groupValues(shape, entry))),
+        total: plan.total ? entries.length : undefined,
+    };
+}
+function framed(rows, { next, total }) {
+    return {
+        ...rows,
+        ...(next === undefined ? {} : { next }),
+        ...(total === undefined ? {} : { total }),
+    };
+}
+function rowsOfPlan(plan, entries, total, bodies, each = (row) => row) {
     const shape = plan.shape;
+    const { kept, ...window } = windowOf(plan, entries, total);
+    const keys = kept.map(([key]) => key);
     if (shape.kind === 'documents') {
         const documents = [];
-        return after(inUnits(entries, ([key, row]) => {
+        return after(inUnits(kept, ([key, row]) => {
             documents.push(each(documentOf(key, row, shape, bodies)));
             return weight(row);
-        }), () => ({ rows: { documents }, keys: entries.map(([key]) => key) }));
+        }), () => ({ rows: framed({ documents }, window), keys, ...window }));
     }
-    const bounded = shape.orderBy.length === 0 && plan.limit !== null ? entries.slice(0, plan.limit) : entries;
     const groups = [];
-    return after(inUnits(bounded, ([, row]) => {
+    return after(inUnits(kept, ([, row]) => {
         groups.push(each({
             key: shape.groupBy.map((_, index) => row[`key${index}`]),
             count: row.count,
         }));
         return ROW_WEIGHT;
-    }), () => ({ rows: { groups }, keys: bounded.map(([key]) => key) }));
+    }), () => ({ rows: framed({ groups }, window), keys, ...window }));
 }
 export function reconciled(previous, next) {
     const before = previous.result;
@@ -311,13 +396,16 @@ export function reconciled(previous, next) {
     const removed = previous.keys.filter((key) => !present.has(key));
     const moved = reordered(previous.keys, next.keys, present);
     const covered = !deepEquals(before.coverage, after.coverage);
-    if (changed.length === 0 && removed.length === 0 && !moved && !covered)
+    const framing = reframed(before, after);
+    if (changed.length === 0 && removed.length === 0 && !moved && !covered && framing === null) {
         return null;
+    }
+    const window = { next: after.next, total: after.total };
     return {
         keyed: {
             result: 'groups' in after
-                ? { groups: rows, coverage: after.coverage }
-                : { documents: rows, coverage: after.coverage },
+                ? framed({ groups: rows, coverage: after.coverage }, window)
+                : framed({ documents: rows, coverage: after.coverage }, window),
             keys: next.keys,
         },
         message: {
@@ -325,9 +413,17 @@ export function reconciled(previous, next) {
             removed,
             order: moved ? next.keys : null,
             ...(covered ? { coverage: after.coverage } : {}),
+            ...framing,
         },
     };
 }
+function reframed(before, after) {
+    const next = before.next === after.next ? {} : { next: after.next ?? null };
+    const total = before.total === after.total || after.total === undefined ? {} : { total: after.total };
+    return Object.keys(next).length === 0 && Object.keys(total).length === 0
+        ? null
+        : { ...next, ...total };
+}
 function reordered(previous, next, present) {
     let at = 0;
     for (const key of previous) {
@@ -376,8 +472,11 @@ export function createReadSide() {
             return;
         entry.rows.set(key, row);
     }
+    function counted(entry) {
+        return entry.built.count === null ? undefined : entry.built.count.size;
+    }
     function rebuilt(entry) {
-        return after(rowsOfPlan(entry.plan, [...entry.built.live.entries()], entry.bodies), ({ rows: found, keys }) => {
+        return after(rowsOfPlan(entry.plan, [...entry.built.live.entries()], counted(entry), entry.bodies), ({ rows: found, keys, next, total }) => {
             const present = new Set(keys);
             for (const key of [...entry.rows.keys()])
                 if (!present.has(key))
@@ -387,32 +486,34 @@ export function createReadSide() {
                     entry.bodies.delete(key);
             }
             keys.forEach((key, index) => kept(entry, key, rowAt(found, index)));
-            return keys;
+            return { keys, next, total };
         });
     }
     function refreshed(entry, dirty) {
         const shape = entry.plan.shape;
-        const keys = [...entry.built.live.keys()];
-        const named = new Set([...dirty, ...keys.filter((key) => !entry.rows.has(key))]);
-        const values = [...named].map((key) => [key, entry.built.live.get(key)]);
+        const { kept: inWindow, next, total, } = windowOf(entry.plan, [...entry.built.live.entries()], counted(entry));
+        const keys = inWindow.map(([key]) => key);
+        const present = new Set(keys);
+        for (const key of [...entry.rows.keys()]) {
+            if (present.has(key))
+                continue;
+            entry.rows.delete(key);
+            entry.bodies.delete(key);
+        }
+        const values = inWindow.filter(([key]) => dirty.has(key) || !entry.rows.has(key));
         const done = inUnits(values, ([key, value]) => {
-            if (value !== undefined)
-                kept(entry, key, documentOf(key, value, shape, entry.bodies));
-            else {
-                entry.rows.delete(key);
-                entry.bodies.delete(key);
-            }
+            kept(entry, key, documentOf(key, value, shape, entry.bodies));
             return weight(value);
         });
-        return after(done, () => keys);
+        return after(done, () => ({ keys, next, total }));
     }
-    function current(entry, keys, coverage) {
-        const found = keys.map((key) => entry.rows.get(key));
+    function current(entry, found, coverage) {
+        const rows = found.keys.map((key) => entry.rows.get(key));
         return {
             result: entry.plan.shape.kind === 'groups'
-                ? { groups: found, coverage }
-                : { documents: found, coverage },
-            keys,
+                ? framed({ groups: rows, coverage }, found)
+                : framed({ documents: rows, coverage }, found),
+            keys: found.keys,
         };
     }
     function delivered(entry, next) {
@@ -448,12 +549,12 @@ export function createReadSide() {
             const dirty = entry.dirty;
             entry.dirty = new Set();
             entry.whole = false;
-            const keys = whole ? rebuilt(entry) : refreshed(entry, dirty);
-            if (keys instanceof Promise) {
-                void keys
-                    .then((found) => {
+            const found = whole ? rebuilt(entry) : refreshed(entry, dirty);
+            if (found instanceof Promise) {
+                void found
+                    .then((window) => {
                     if (entry.listeners.size > 0)
-                        delivered(entry, current(entry, found, cover.coverage));
+                        delivered(entry, current(entry, window, cover.coverage));
                     run(entry);
                 })
                     .catch(() => {
@@ -461,7 +562,7 @@ export function createReadSide() {
                 });
                 return;
             }
-            delivered(entry, current(entry, keys, cover.coverage));
+            delivered(entry, current(entry, found, cover.coverage));
         }
         entry.running = false;
     }
@@ -517,12 +618,14 @@ export function createReadSide() {
         },
         recover,
         async query(plan, at) {
-            const { live: collection, dispose } = built(rows, plan);
+            const { live: collection, count, dispose } = built(rows, plan);
             try {
                 await collection.toArrayWhenReady();
+                if (count !== null)
+                    await count.toArrayWhenReady();
                 const entries = [...collection.entries()];
                 const held = at();
-                const found = await rowsOfPlan(plan, entries, null, structuredClone);
+                const found = await rowsOfPlan(plan, entries, count?.size, null, structuredClone);
                 return { rows: found.rows, at: held };
             }
             finally {
@@ -543,6 +646,7 @@ export function createReadSide() {
                     fresh: new Set(),
                     ready: new Set(),
                     subscription: null,
+                    counting: null,
                     whole: true,
                     dirty: new Set(),
                     stale: false,
@@ -557,7 +661,14 @@ export function createReadSide() {
             }
             const observed = entry;
             observed.listeners.add(deliverTo);
-            observed.built.live.onFirstReady(() => {
+            const ready = (then) => observed.built.live.onFirstReady(() => observed.built.count === null ? then() : observed.built.count.onFirstReady(then));
+            const settled = () => {
+                if (observed.built.count === null)
+                    wake(observed);
+                else
+                    queueMicrotask(() => wake(observed));
+            };
+            ready(() => {
                 if (!observed.listeners.has(deliverTo))
                     return;
                 observed.fresh.add(deliverTo);
@@ -569,8 +680,13 @@ export function createReadSide() {
                         else
                             for (const { key } of changes)
                                 observed.dirty.add(key);
-                        wake(observed);
+                        settled();
                     }, { includeInitialState: false });
+                    observed.counting =
+                        observed.built.count?.subscribeChanges(() => {
+                            observed.stale = true;
+                            settled();
+                        }, { includeInitialState: false }) ?? null;
                 }
                 wake(observed);
             });
@@ -581,6 +697,8 @@ export function createReadSide() {
                     return;
                 observed.subscription?.unsubscribe();
                 observed.subscription = null;
+                observed.counting?.unsubscribe();
+                observed.counting = null;
                 observed.result = undefined;
                 observed.rows.clear();
                 observed.bodies.clear();
@@ -601,6 +719,7 @@ export function createReadSide() {
                 entry.fresh.clear();
                 entry.ready.clear();
                 entry.subscription?.unsubscribe();
+                entry.counting?.unsubscribe();
                 entry.built.dispose();
             }
             shared.clear();
@@ -625,13 +744,16 @@ function changedFrom(previous, next) {
     const removed = previous.keys.filter((key) => !present.has(key));
     const moved = reordered(previous.keys, next.keys, present);
     const covered = !deepEquals(before.coverage, after.coverage);
-    if (changed.length === 0 && removed.length === 0 && !moved && !covered)
+    const framing = reframed(before, after);
+    if (changed.length === 0 && removed.length === 0 && !moved && !covered && framing === null) {
         return null;
+    }
     return {
         changed,
         removed,
         order: moved ? next.keys : null,
         ...(covered ? { coverage: after.coverage } : {}),
+        ...framing,
     };
 }
 function rowAt(rows, index) {

package/dist/readiness.d.ts

@@ -0,0 +1,53 @@
+import type { Open } from './open.js';
+export type CodeAvailability = Open<'stored' | 'absent'>;
+export type RoomPreparation = Open<'complete' | 'acquiring' | 'preparing' | 'indexing' | 'refused' | 'unadmitted'>;
+export type RoomCoverage = {
+    readonly room: string;
+    readonly state: RoomPreparation;
+};
+export type ConversationCoverage = Open<'complete' | 'acquiring' | 'indexing' | 'undeclared'>;
+export type SearchObligation = Open<'required' | 'unused'>;
+export type TargetCoverage = {
+    readonly complete: boolean;
+    readonly listed: boolean;
+    readonly rooms: readonly RoomCoverage[];
+    readonly conversations: ConversationCoverage;
+    readonly search: SearchObligation;
+};
+export type Persistence = Open<'granted' | 'denied' | 'unavailable'>;
+export type Durability = Open<'persistent' | 'best-effort'>;
+export type ConnectionAvailability = Open<'connected' | 'connecting' | 'unreachable'>;
+export type HouseOutcome = Open<'open' | 'write-halted' | 'refused'>;
+export type CapacityCause = {
+    readonly cause: Open<'insufficient-space' | 'quota-exceeded'>;
+    readonly needed: number | null;
+    readonly available: number | null;
+};
+export type RefusedRoom = {
+    readonly room: string;
+    readonly file: string;
+    readonly rule: string;
+    readonly location: string | null;
+};
+export type ReadinessStatus = Open<'preparing' | 'paused' | 'refused' | 'ready' | 'lost'>;
+export type Readiness = {
+    readonly status: ReadinessStatus;
+    readonly ready: boolean;
+    readonly usable: boolean;
+    readonly code: CodeAvailability;
+    readonly coverage: TargetCoverage;
+    readonly durability: Durability;
+    readonly persistence: Persistence;
+    readonly connection: ConnectionAvailability;
+    readonly house: HouseOutcome;
+    readonly capacity: CapacityCause | null;
+    readonly refused: readonly RefusedRoom[];
+    readonly lost: boolean;
+};
+export type ReadinessFacts = Omit<Readiness, 'status' | 'ready' | 'usable' | 'durability' | 'coverage'> & {
+    readonly coverage: Omit<TargetCoverage, 'complete'>;
+    readonly established: boolean;
+};
+export declare const SETTLED_ROOMS: ReadonlySet<string>;
+export declare function readinessOf(facts: ReadinessFacts): Readiness;
+//# sourceMappingURL=readiness.d.ts.map

package/dist/readiness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readiness.d.ts","sourceRoot":"","sources":["../src/readiness.ts"],"names":[],"mappings":"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"}

package/dist/readiness.js

@@ -0,0 +1,33 @@
+const COMPLETE_ROOMS = new Set(['complete', 'unadmitted']);
+export const SETTLED_ROOMS = new Set([...COMPLETE_ROOMS, 'refused']);
+export function readinessOf(facts) {
+    const { established, coverage: held, ...reported } = facts;
+    const settledConversations = held.conversations === 'complete' || held.conversations === 'undeclared';
+    const complete = held.listed &&
+        settledConversations &&
+        held.rooms.every((room) => COMPLETE_ROOMS.has(room.state));
+    const settled = held.listed &&
+        settledConversations &&
+        held.rooms.every((room) => SETTLED_ROOMS.has(room.state));
+    const coverage = { ...held, complete };
+    const stored = facts.code === 'stored';
+    const ready = stored && complete;
+    const usable = stored && (ready || established);
+    const status = ready
+        ? 'ready'
+        : facts.capacity !== null
+            ? 'paused'
+            : facts.lost && !established
+                ? 'lost'
+                : settled && !complete
+                    ? 'refused'
+                    : 'preparing';
+    return {
+        ...reported,
+        coverage,
+        status,
+        ready,
+        usable,
+        durability: facts.persistence === 'granted' ? 'persistent' : 'best-effort',
+    };
+}

package/dist/reads.d.ts

@@ -0,0 +1,11 @@
+import type { Adapter } from './adapter.js';
+import type { Reads } from './bootstrap.js';
+export type DoorReads = Reads & {
+    carried(locator: string): number;
+    finished(locator: string, turn: number): void;
+    opened(): void;
+    applied(): void;
+    lost(): void;
+};
+export declare function doorReads(adapter: Adapter, declaration: (locator: string) => unknown, generation: () => number): DoorReads;
+//# sourceMappingURL=reads.d.ts.map

package/dist/reads.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reads.d.ts","sourceRoot":"","sources":["../src/reads.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EAOR,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAE5C,MAAM,MAAM,SAAS,GAAG,KAAK,GAAG;IAC9B,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC;IACjC,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9C,MAAM,IAAI,IAAI,CAAC;IACf,OAAO,IAAI,IAAI,CAAC;IAChB,IAAI,IAAI,IAAI,CAAC;CACd,CAAC;AAiCF,wBAAgB,SAAS,CACvB,OAAO,EAAE,OAAO,EAChB,WAAW,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,EACzC,UAAU,EAAE,MAAM,MAAM,GACvB,SAAS,CA0FX"}

package/dist/reads.js

@@ -0,0 +1,98 @@
+function declaredAs(declaration) {
+    if (declaration === null || typeof declaration !== 'object')
+        return declaration;
+    const { roomVersion: _version, ...declared } = declaration;
+    return declared;
+}
+function sameHeld(one, other) {
+    return one?.documents === other?.documents && one?.revisions === other?.revisions;
+}
+function failed(answer) {
+    return answer?.kind === 'transport-uncertainty';
+}
+function continues(answer) {
+    const page = answer;
+    return page?.kind === 'net-advancement' && page.pageToken !== undefined;
+}
+export function doorReads(adapter, declaration, generation) {
+    const reading = new Map();
+    const taken = new Map();
+    let carrying = false;
+    function joined(read, authorization, request, ask) {
+        const key = `${read} ${request.locator} ${request.pageToken ?? ''}`;
+        const { held, ...named } = request;
+        const asked = JSON.stringify([declaredAs(declaration(request.locator)), named]);
+        const asking = generation();
+        const current = reading.get(key);
+        if (current !== undefined &&
+            current.authorization === authorization &&
+            current.asked === asked &&
+            sameHeld(current.held, held) &&
+            (!current.settled || current.holder < asking)) {
+            if (current.settled && !current.continued)
+                reading.delete(key);
+            else
+                current.holder = Math.max(current.holder, asking);
+            if (current.from === asking)
+                return current.answer;
+            const again = () => joined(read, authorization, request, ask);
+            return current.answer.then((answer) => {
+                if (failed(answer))
+                    return again();
+                taken.set(request.locator, (taken.get(request.locator) ?? 0) + 1);
+                return answer;
+            }, again);
+        }
+        const answer = ask();
+        const sent = {
+            locator: request.locator,
+            authorization,
+            asked,
+            held,
+            answer,
+            from: asking,
+            holder: asking,
+            settled: false,
+            continued: false,
+        };
+        reading.set(key, sent);
+        const settled = (result, kept) => {
+            sent.settled = true;
+            sent.continued = kept && read === 'refresh' && continues(result);
+            if (reading.get(key) !== sent)
+                return;
+            const live = sent.holder === generation();
+            if (!kept || (live ? !sent.continued : !carrying))
+                reading.delete(key);
+        };
+        answer.then((result) => settled(result, !failed(result)), () => settled(null, false));
+        return answer;
+    }
+    return {
+        bootstrap: (authorization, request) => joined('bootstrap', authorization, request, () => adapter.bootstrap(authorization, request)),
+        refresh: (authorization, request) => joined('refresh', authorization, request, () => adapter.refresh(authorization, request)),
+        reached: (locator, roomVersion, target) => adapter.reached(locator, roomVersion, target),
+        carried: (locator) => taken.get(locator) ?? 0,
+        finished(locator, turn) {
+            for (const [key, held] of reading) {
+                if (held.locator !== locator || !held.settled || held.holder !== turn)
+                    continue;
+                if (turn === generation() || !carrying)
+                    reading.delete(key);
+            }
+        },
+        opened() {
+            carrying = true;
+        },
+        applied() {
+            carrying = false;
+            for (const [key, held] of reading) {
+                if (held.settled && held.holder !== generation())
+                    reading.delete(key);
+            }
+        },
+        lost() {
+            reading.clear();
+        },
+    };
+}

package/dist/refresh.d.ts

@@ -1,5 +1,5 @@
-import type { Adapter, AdapterFailure, Authorization, RetryableRefusal } from './adapter.js';
-import type { Remodel } from './bootstrap.js';
+import type { AdapterFailure, Authorization, RetryableRefusal } from './adapter.js';
+import type { Reads, Remodel } from './bootstrap.js';
 import { type ConfirmedLayer } from './replica.js';
 import type { ReplicaRecord } from './store.js';
 import { type Refused, type Unconfirmed } from './transfer.js';
@@ -19,6 +19,6 @@ export type RefreshOutcome = {
 } | {
     kind: 'beyond-horizon';
 } | RetryableRefusal | Unconfirmed | Refused | AdapterFailure;
-export declare function advancement(adapter: Adapter, authorization: Authorization, held: ReplicaRecord, remodel: Remodel, continuing: () => boolean): Promise<Advancement>;
-export declare function refreshRoom(adapter: Adapter, authorization: Authorization, confirmed: ConfirmedLayer, remodel: Remodel, continuing: () => boolean): Promise<RefreshOutcome>;
+export declare function advancement(adapter: Reads, authorization: Authorization, held: ReplicaRecord, remodel: Remodel, continuing: () => boolean): Promise<Advancement>;
+export declare function refreshRoom(adapter: Reads, authorization: Authorization, confirmed: ConfirmedLayer, remodel: Remodel, continuing: () => boolean): Promise<RefreshOutcome>;
 //# sourceMappingURL=refresh.d.ts.map