@agentshouse/mdruntime 0.1.0-alpha.9 → 0.1.0-c30ed2b8e04d5

package/dist/reach.js

@@ -0,0 +1,277 @@
+import { unheldView } from './conversation.js';
+import { modelTypes, NO_MODEL } from './model.js';
+import { applied, observing } from './observation.js';
+import { beneath } from './paths.js';
+import { reconciled } from './read-side.js';
+import { moveTarget, readParts } from './room-draft.js';
+import { documentKey } from './rows.js';
+const UNHELD_TYPES = { collection: modelTypes(NO_MODEL), typedSelection: null };
+const UNDECLARED = { kind: 'undeclared' };
+function undeclared() {
+    return Promise.resolve(UNDECLARED);
+}
+const NO_CONVERSATION = {
+    list: () => Promise.resolve([]),
+    read: (conversation) => Promise.resolve(unheldView(conversation)),
+    create: undeclared,
+    send: undeclared,
+    answer: undeclared,
+    interrupt: undeclared,
+    kill: undeclared,
+    cancel: undeclared,
+    delete: undeclared,
+};
+const NO_CHAT_DRAFT = {
+    write: () => Promise.resolve(),
+    discard: () => Promise.resolve(),
+};
+export function holds(reach, room) {
+    return (reach === null ||
+        reach.rooms.includes(room) ||
+        reach.documents.some((document) => document.room === room));
+}
+function wholly(reach, room) {
+    return reach === null || reach.rooms.includes(room);
+}
+export function governs(reach, room) {
+    if (wholly(reach, room.locator)) {
+        return { collection: true, selection: room.typedSelection !== null };
+    }
+    const selected = (path) => room.typedSelection?.roots.some((root) => beneath(root, path)) ?? false;
+    const paths = reach.documents
+        .filter((document) => document.room === room.locator)
+        .map(({ path }) => path);
+    return { collection: paths.some((path) => !selected(path)), selection: paths.some(selected) };
+}
+function covers(reach, room, path) {
+    return (reach === null ||
+        reach.rooms.includes(room) ||
+        reach.documents.some((document) => document.room === room && document.path === path));
+}
+function conversing(reach) {
+    return reach === null || reach.conversations;
+}
+export function planReach(reach) {
+    return reach === null
+        ? null
+        : {
+            rooms: [...new Set(reach.rooms)].sort(),
+            documents: [
+                ...new Set(reach.documents.map(({ room, path }) => documentKey(room, path))),
+            ].sort(),
+        };
+}
+function roomsWithin(reach, rooms) {
+    if (reach === null)
+        return rooms;
+    return rooms
+        .filter((room) => holds(reach, room.locator))
+        .map((room) => {
+        if (wholly(reach, room.locator))
+            return room;
+        const governed = governs(reach, room);
+        return {
+            ...room,
+            model: governed.collection ? room.model : modelTypes(NO_MODEL),
+            typedSelection: governed.selection ? room.typedSelection : null,
+            roomVersion: null,
+            attachments: [],
+        };
+    });
+}
+function typesWithin(reach, room, types) {
+    if (room === undefined)
+        return structuredClone(UNHELD_TYPES);
+    const governed = governs(reach, room);
+    return {
+        collection: governed.collection ? types.collection : modelTypes(NO_MODEL),
+        typedSelection: governed.selection ? types.typedSelection : null,
+    };
+}
+function moves(reach, room, move) {
+    return move === undefined || covers(reach, room, moveTarget(move));
+}
+function draftWithin(reach, draft) {
+    return covers(reach, draft.room, draft.path) && moves(reach, draft.room, draft.parts.move);
+}
+function draftsWithin(reach, drafts) {
+    return drafts.filter((draft) => draftWithin(reach, draft));
+}
+function shownDraft(reach, draft) {
+    return draft !== null && draftWithin(reach, draft) ? draft : null;
+}
+function writeWithin(reach, write) {
+    return write.outcome === 'written'
+        ? { outcome: 'written', roomDraft: shownDraft(reach, write.roomDraft) }
+        : { outcome: 'stale', current: shownDraft(reach, write.current) };
+}
+function savedWithin(reach, room, result) {
+    if (reach === null || result.outcome === 'saved')
+        return result;
+    const { file, location, referrers, ...refusal } = result;
+    const hidden = file !== undefined && !covers(reach, room, file);
+    return {
+        ...refusal,
+        ...(file === undefined || hidden ? {} : { file }),
+        ...(location === undefined || hidden ? {} : { location }),
+        ...(referrers === undefined
+            ? {}
+            : { referrers: referrers.filter((path) => covers(reach, room, path)) }),
+    };
+}
+function statusWithin(reach, status) {
+    return {
+        ...status,
+        attentionRequired: status.attentionRequired.filter((entry) => covers(reach, entry.room, entry.path)),
+    };
+}
+function queueWithin(reach, room, entries) {
+    return entries.filter(({ batch }) => batch.changes.every((change) => covers(reach, room, change.path) &&
+        (change.kind !== 'move' || covers(reach, room, change.to))));
+}
+function unreached(room) {
+    return new Error(`No Local Replica for ${room}`);
+}
+export function narrowed(runtime, given) {
+    const { md, watch } = runtime;
+    let reach = given;
+    const open = new Set();
+    function following(begin) {
+        let stop = begin();
+        const restart = () => {
+            stop();
+            stop = begin();
+        };
+        open.add(restart);
+        return () => {
+            open.delete(restart);
+            stop();
+        };
+    }
+    const within = (topic, input, deliver) => {
+        if (topic === 'rooms') {
+            return following(() => watch(topic, input, (rooms) => deliver(roomsWithin(reach, rooms))));
+        }
+        if (topic === 'sync-status') {
+            return following(() => watch(topic, input, (status) => deliver(statusWithin(reach, status))));
+        }
+        if (topic === 'room-drafts') {
+            return following(() => watch(topic, input, (drafts) => deliver(draftsWithin(reach, drafts))));
+        }
+        if (topic === 'queue') {
+            const room = input[0];
+            return following(() => {
+                if (!holds(reach, room)) {
+                    deliver([]);
+                    return () => { };
+                }
+                return watch(topic, input, (entries) => deliver(queueWithin(reach, room, entries)));
+            });
+        }
+        if (topic === 'query') {
+            const plan = runtime.plan(input[0], reach);
+            let held = null;
+            return following(() => {
+                let first = true;
+                return runtime.watchPlan({ ...plan, reach: planReach(reach) }, (message) => {
+                    if (!first) {
+                        held = applied(held, message);
+                        deliver(message);
+                        return;
+                    }
+                    first = false;
+                    if (held === null) {
+                        held = message;
+                        deliver(message);
+                        return;
+                    }
+                    const next = reconciled(held, message);
+                    if (next === null)
+                        return;
+                    held = next.keyed;
+                    deliver(next.change);
+                });
+            });
+        }
+        if (topic === 'conversation') {
+            return following(() => {
+                if (conversing(reach))
+                    return watch(topic, input, deliver);
+                deliver(unheldView(input[0]));
+                return () => { };
+            });
+        }
+        return watch(topic, input, deliver);
+    };
+    const conversation = () => (conversing(reach) ? md.conversation : NO_CONVERSATION);
+    const chatDraft = () => (conversing(reach) ? md.chatDraft : NO_CHAT_DRAFT);
+    const view = {
+        ...md,
+        rooms: () => roomsWithin(reach, md.rooms()),
+        query: ((input) => runtime.query(runtime.plan(input, reach))),
+        search: (input) => runtime.search(input, reach),
+        types(room) {
+            if (wholly(reach, room))
+                return md.types(room);
+            if (!holds(reach, room))
+                return structuredClone(UNHELD_TYPES);
+            const listed = md.rooms().find(({ locator }) => locator === room);
+            return typesWithin(reach, listed, md.types(room));
+        },
+        async save(room, roomDrafts, writtenBy) {
+            if (!holds(reach, room))
+                throw unreached(room);
+            const outside = roomDrafts.find(({ path }) => !covers(reach, room, path) ||
+                !moves(reach, room, md.roomDraft.read(room, path)?.parts.move));
+            if (outside !== undefined)
+                return { outcome: 'refused', rule: 'stale', file: outside.path };
+            return savedWithin(reach, room, await md.save(room, roomDrafts, writtenBy));
+        },
+        history: (room, path, query) => covers(reach, room, path)
+            ? md.history(room, path, query)
+            : Promise.resolve({ kind: 'room-not-readable', locator: room }),
+        reached: (room, roomVersion, path) => (path === undefined ? wholly(reach, room) : covers(reach, room, path)) &&
+            md.reached(room, roomVersion, path),
+        log: () => (reach === null ? md.log() : ''),
+        roomDraft: {
+            list: () => md.roomDraft.list().then((drafts) => draftsWithin(reach, drafts)),
+            read: (room, path) => covers(reach, room, path) ? shownDraft(reach, md.roomDraft.read(room, path)) : null,
+            async write(room, path, revision, parts) {
+                if (!covers(reach, room, path) || !moves(reach, room, readParts(parts).move)) {
+                    throw unreached(room);
+                }
+                return writeWithin(reach, await md.roomDraft.write(room, path, revision, parts));
+            },
+            async discard(room, path, revision) {
+                if (!covers(reach, room, path))
+                    return { outcome: 'stale', current: null };
+                return writeWithin(reach, await md.roomDraft.discard(room, path, revision));
+            },
+        },
+        conversation: {
+            list: () => conversation().list(),
+            read: (id, options) => conversation().read(id, options),
+            create: (input) => conversation().create(input),
+            send: (id) => conversation().send(id),
+            answer: (id, answer) => conversation().answer(id, answer),
+            interrupt: (id) => conversation().interrupt(id),
+            kill: (id) => conversation().kill(id),
+            cancel: (id, turn) => conversation().cancel(id, turn),
+            delete: (id) => conversation().delete(id),
+        },
+        chatDraft: {
+            write: (id, draft) => chatDraft().write(id, draft),
+            discard: (id) => chatDraft().discard(id),
+        },
+        observe: observing(within),
+    };
+    return {
+        md: view,
+        watch: within,
+        narrow(next) {
+            reach = next;
+            for (const restart of [...open])
+                restart();
+        },
+    };
+}

package/dist/read-side.d.ts

@@ -0,0 +1,18 @@
+import type { ChangeSet } from './change-set.js';
+import { type KeyedResult, type QueryChange } from './observation.js';
+import type { Plan, QueryResult } from './query.js';
+import type { SearchedDocument } from './search.js';
+export type ReadSide = {
+    apply(set: ChangeSet): void;
+    query(plan: Plan): Promise<QueryResult>;
+    watch(plan: Plan, identity: string, deliver: (message: KeyedResult | QueryChange) => void): () => void;
+    documents(): readonly SearchedDocument[];
+    document(room: string, path: string): SearchedDocument | null;
+    close(): void;
+};
+export declare function reconciled(previous: KeyedResult, next: KeyedResult): {
+    keyed: KeyedResult;
+    change: QueryChange;
+} | null;
+export declare function createReadSide(): ReadSide;
+//# sourceMappingURL=read-side.d.ts.map

package/dist/read-side.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-side.d.ts","sourceRoot":"","sources":["../src/read-side.ts"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,EAAU,KAAK,WAAW,EAAE,KAAK,WAAW,EAAe,MAAM,kBAAkB,CAAC;AAC3F,OAAO,KAAK,EAOV,IAAI,EAIJ,WAAW,EAIZ,MAAM,YAAY,CAAC;AAEpB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAqDpD,MAAM,MAAM,QAAQ,GAAG;IACrB,KAAK,CAAC,GAAG,EAAE,SAAS,GAAG,IAAI,CAAC;IAC5B,KAAK,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;IACxC,KAAK,CACH,IAAI,EAAE,IAAI,EACV,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,CAAC,OAAO,EAAE,WAAW,GAAG,WAAW,KAAK,IAAI,GACpD,MAAM,IAAI,CAAC;IACd,SAAS,IAAI,SAAS,gBAAgB,EAAE,CAAC;IACzC,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CAAC;IAC9D,KAAK,IAAI,IAAI,CAAC;CACf,CAAC;AA8RF,wBAAgB,UAAU,CACxB,QAAQ,EAAE,WAAW,EACrB,IAAI,EAAE,WAAW,GAChB;IAAE,KAAK,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,WAAW,CAAA;CAAE,GAAG,IAAI,CA4BpD;AAED,wBAAgB,cAAc,IAAI,QAAQ,CA4HzC"}

package/dist/read-side.js

@@ -0,0 +1,377 @@
+import { and, BasicIndex, configureIndexDevMode, count, createCollection, createLiveQueryCollection, deepEquals, eq, gt, gte, inArray, isNull, isUndefined, lt, lte, not, or, toArray, } from '@tanstack/db';
+import { rowsOf } from './observation.js';
+import { documentKey } from './rows.js';
+function every(expressions) {
+    const [first, second, ...rest] = expressions;
+    return second === undefined ? first : and(first, second, ...rest);
+}
+function some(expressions) {
+    const [first, second, ...rest] = expressions;
+    return second === undefined ? first : or(first, second, ...rest);
+}
+function equal(field, value) {
+    return or(eq(field, value), inArray(value, field));
+}
+function tested(test, field, size, written) {
+    if (test.op === 'eq')
+        return test.value === null ? isNull(field) : equal(field, test.value);
+    if (test.op === 'ne') {
+        return test.value === null
+            ? not(isNull(field))
+            : or(isUndefined(field), isNull(field), not(equal(field, test.value)));
+    }
+    if (test.op === 'in' || test.op === 'nin') {
+        const matches = test.values.length === 0
+            ? inArray(field, [])
+            : some(test.values.map((value) => (value === null ? isNull(field) : equal(field, value))));
+        if (test.op === 'in')
+            return matches;
+        return some([
+            isUndefined(field),
+            ...(test.values.includes(null) ? [] : [isNull(field)]),
+            not(matches),
+        ]);
+    }
+    if (test.op === 'range') {
+        const compare = { gt, gte, lt, lte };
+        return every(test.bounds.map(([operator, bound]) => compare[operator](field, bound)));
+    }
+    if (test.op === 'all') {
+        return every([not(isUndefined(size)), ...test.values.map((value) => inArray(value, field))]);
+    }
+    if (test.op === 'size')
+        return eq(size, test.size);
+    return test.exists ? not(isUndefined(written)) : isUndefined(written);
+}
+function conditioned(condition, row) {
+    if ('every' in condition)
+        return every(condition.every.map((item) => conditioned(item, row)));
+    if ('some' in condition)
+        return some(condition.some.map((item) => conditioned(item, row)));
+    return tested(condition.test, row.values[condition.field], row.sizes[condition.field], row.fields[condition.field]);
+}
+function reached(reach, room, document) {
+    return reach === null
+        ? []
+        : [or(inArray(room, [...reach.rooms]), inArray(document, [...reach.documents]))];
+}
+function scoped(scope, row, rooms, reach) {
+    return every([
+        eq(row.kind, 'document'),
+        ...(rooms === null ? [] : [inArray(row.room, [...rooms])]),
+        ...reached(reach, row.room, row.key),
+        ...(scope.types === null ? [] : [inArray(row.type, [...scope.types])]),
+        ...(scope.pathPrefix === null ? [] : [inArray(scope.pathPrefix, row.directories)]),
+        ...(scope.where === null ? [] : [conditioned(scope.where, row)]),
+    ]);
+}
+function keyed(key, row) {
+    return key.of === 'field' ? row.values[key.field] : row[key.of];
+}
+function live(query) {
+    return createLiveQueryCollection({
+        query: query,
+        startSync: true,
+    });
+}
+function related(q, rows, scope, field, kept, reach) {
+    const matched = kept === 'source' ? 'target' : 'source';
+    const from = q.from({ r: rows });
+    return from
+        .where(({ r }) => every([eq(r.kind, 'reference'), ...(field === null ? [] : [eq(r.field, field)])]))
+        .innerJoin({ m: rows }, ({ r, m }) => eq(r[matched], m.key))
+        .where(({ m }) => scoped(scope, m, null, reach))
+        .groupBy(({ r }) => r[kept])
+        .select(({ r }) => ({ key: r[kept] }));
+}
+function filtered(q, rows, plan) {
+    const from = q.from({ d: rows });
+    let query = from.where(({ d }) => scoped(plan.root, d, plan.rooms, plan.reach));
+    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));
+    }
+    if (plan.backlinks !== null) {
+        const backlinks = related(q, rows, plan.backlinks, plan.backlinks.field, 'target', plan.reach);
+        query = query.innerJoin({ k: backlinks }, ({ d, k }) => eq(d.key, k.key));
+    }
+    return query;
+}
+function named(prefix, names, source) {
+    return Object.fromEntries(names.map((name, index) => [`${prefix}${index}`, source[name]]));
+}
+function documents(q, rows, plan, shape) {
+    let query = filtered(q, rows, plan);
+    if (shape.sections !== null || shape.preamble || shape.markdown) {
+        query = query.leftJoin({ b: rows }, ({ d, b }) => eq(d.body, b.key));
+    }
+    for (const { key, options } of shape.orderBy) {
+        query = query.orderBy(({ d }) => keyed(key, d), options);
+    }
+    if (shape.orderBy.length === 0 && plan.limit !== null) {
+        query = query.orderBy(({ d }) => d.key, { stringSort: 'lexical' });
+    }
+    if (plan.limit !== null)
+        query = query.limit(plan.limit);
+    return query.select(({ d, b }) => ({
+        room: d.room,
+        path: d.path,
+        type: d.type,
+        ...(shape.fields === 'all' ? { fields: d.fields } : {}),
+        ...(Array.isArray(shape.fields) ? named('field', shape.fields, d.fields) : {}),
+        ...(shape.sections === 'all' ? { sections: b.sections } : {}),
+        ...(Array.isArray(shape.sections) ? named('section', shape.sections, b.sections) : {}),
+        ...(shape.preamble ? { preamble: b.preamble } : {}),
+        ...(shape.markdown ? { markdown: b.markdown } : {}),
+        ...(shape.backlinks ? { backlinks: toArray(backlinked(q, rows, d, plan.reach)) } : {}),
+        ...(shape.change ? { change: d.change } : {}),
+    }));
+}
+function backlinked(q, rows, document, reach) {
+    const from = q.from({ r: rows });
+    return from
+        .where(({ r }) => every([eq(r.target, document.key), ...reached(reach, r.room, r.source)]))
+        .orderBy(({ r }) => r.path, { stringSort: 'lexical' })
+        .orderBy(({ r }) => r.field, { stringSort: 'lexical' })
+        .select(({ r }) => ({ path: r.path, type: r.type, field: r.field }));
+}
+function groups(q, stage, shape, limit) {
+    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),
+    }));
+}
+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 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));
+    return {
+        live: collection,
+        dispose: () => {
+            void collection.cleanup();
+            void stage.cleanup();
+        },
+    };
+}
+function present(entries) {
+    return Object.fromEntries(entries.filter(([, value]) => value !== undefined));
+}
+function part(row, prefix, names, whole) {
+    if (names === 'all')
+        return whole;
+    return present(names.map((name, index) => [name, row[`${prefix}${index}`]]));
+}
+function documentOf(row, shape) {
+    if (row.type === null)
+        return { room: row.room, path: row.path };
+    return {
+        room: row.room,
+        path: row.path,
+        type: row.type,
+        ...(shape.fields === null
+            ? {}
+            : { fields: part(row, 'field', shape.fields, row.fields) }),
+        ...(shape.sections === null
+            ? {}
+            : {
+                sections: part(row, 'section', shape.sections, row.sections),
+            }),
+        ...(shape.preamble ? { preamble: row.preamble } : {}),
+        ...(shape.markdown ? { markdown: row.markdown } : {}),
+        ...(shape.backlinks
+            ? {
+                backlinks: row.backlinks.map(({ path, type, field }) => ({ path, type, field })),
+            }
+            : {}),
+        ...(shape.change ? { change: row.change } : {}),
+    };
+}
+function keyedOf(plan, entries) {
+    const shape = plan.shape;
+    if (shape.kind === 'documents') {
+        return {
+            result: structuredClone({ documents: entries.map(([, row]) => documentOf(row, shape)) }),
+            keys: entries.map(([key]) => key),
+        };
+    }
+    const bounded = shape.orderBy.length === 0 && plan.limit !== null ? entries.slice(0, plan.limit) : entries;
+    return {
+        result: structuredClone({
+            groups: bounded.map(([, row]) => ({
+                key: shape.groupBy.map((_, index) => row[`key${index}`]),
+                count: row.count,
+            })),
+        }),
+        keys: bounded.map(([key]) => key),
+    };
+}
+export function reconciled(previous, next) {
+    const before = rowsOf(previous.result);
+    const held = new Map(previous.keys.map((key, index) => [key, before[index]]));
+    const changed = [];
+    const rows = rowsOf(next.result).map((row, index) => {
+        const key = next.keys[index];
+        const kept = held.get(key);
+        if (kept !== undefined && deepEquals(kept, row))
+            return kept;
+        changed.push([key, row]);
+        return row;
+    });
+    const present = new Set(next.keys);
+    const survivors = previous.keys.filter((key) => present.has(key));
+    const removed = previous.keys.filter((key) => !present.has(key));
+    const moved = survivors.length !== next.keys.length ||
+        survivors.some((key, index) => key !== next.keys[index]);
+    if (changed.length === 0 && removed.length === 0 && !moved)
+        return null;
+    return {
+        keyed: {
+            result: 'groups' in next.result
+                ? { groups: rows }
+                : { documents: rows },
+            keys: next.keys,
+        },
+        change: { changed, removed, order: moved ? next.keys : null },
+    };
+}
+export function createReadSide() {
+    configureIndexDevMode({ enabled: false });
+    let sync;
+    const rows = createCollection({
+        getKey: (row) => row.key,
+        gcTime: 0,
+        startSync: true,
+        autoIndex: 'eager',
+        defaultIndexType: BasicIndex,
+        sync: {
+            rowUpdateMode: 'full',
+            sync: (params) => {
+                sync = params;
+                params.markReady();
+            },
+        },
+    });
+    const shared = new Map();
+    function searched(row) {
+        const body = rows.get(row.body);
+        return {
+            room: row.room,
+            path: row.path,
+            type: row.type,
+            fields: row.fields,
+            preamble: body.preamble,
+            sections: body.sections,
+        };
+    }
+    function publish(entry) {
+        const next = reconciled(entry.result, keyedOf(entry.plan, [...entry.built.live.entries()]));
+        if (next === null)
+            return;
+        entry.result = next.keyed;
+        for (const listener of entry.listeners)
+            listener(next.change);
+    }
+    return {
+        apply(set) {
+            const next = new Map();
+            for (const change of set.documents) {
+                for (const row of change.before)
+                    next.set(row.key, null);
+                for (const row of change.after)
+                    next.set(row.key, row);
+            }
+            if (next.size === 0)
+                return;
+            sync.begin();
+            for (const [key, row] of next) {
+                if (row === null) {
+                    if (rows.has(key))
+                        sync.write({ type: 'delete', key });
+                    continue;
+                }
+                sync.write({ type: rows.has(key) ? 'update' : 'insert', value: row });
+            }
+            sync.commit();
+        },
+        async query(plan) {
+            const { live: collection, dispose } = built(rows, plan);
+            try {
+                await collection.toArrayWhenReady();
+                return keyedOf(plan, [...collection.entries()]).result;
+            }
+            finally {
+                dispose();
+            }
+        },
+        watch(plan, identity, deliver) {
+            let entry = shared.get(identity);
+            if (entry === undefined) {
+                const created = {
+                    plan,
+                    built: built(rows, plan),
+                    result: undefined,
+                    listeners: new Set(),
+                    subscription: null,
+                };
+                created.built.live.on('status:change', ({ status }) => {
+                    if (status === 'cleaned-up' && created.listeners.size === 0)
+                        shared.delete(identity);
+                });
+                shared.set(identity, created);
+                entry = created;
+            }
+            const observed = entry;
+            observed.listeners.add(deliver);
+            observed.built.live.onFirstReady(() => {
+                if (!observed.listeners.has(deliver))
+                    return;
+                if (observed.subscription === null) {
+                    observed.result = keyedOf(observed.plan, [...observed.built.live.entries()]);
+                    observed.subscription = observed.built.live.subscribeChanges(() => {
+                        publish(observed);
+                    }, { includeInitialState: false });
+                }
+                deliver(observed.result);
+            });
+            return () => {
+                if (!observed.listeners.delete(deliver) || observed.listeners.size > 0)
+                    return;
+                observed.subscription?.unsubscribe();
+                observed.subscription = null;
+            };
+        },
+        documents() {
+            return rows.toArray
+                .filter((row) => row.kind === 'document' && row.type !== null)
+                .map(searched);
+        },
+        document(room, path) {
+            const row = rows.get(documentKey(room, path));
+            return row === undefined || row.type === null ? null : searched(row);
+        },
+        close() {
+            for (const entry of shared.values()) {
+                entry.listeners.clear();
+                entry.subscription?.unsubscribe();
+                entry.built.dispose();
+            }
+            shared.clear();
+            void rows.cleanup();
+        },
+    };
+}

package/dist/refresh.d.ts

@@ -1,7 +1,7 @@
-import type { AttachedModelBinding } from './model.js';
-import type { Adapter, AdapterFailure, Authorization } from './adapter.js';
+import type { Adapter, AdapterFailure, Authorization, RetryableRefusal } from './adapter.js';
+import type { Remodel } from './bootstrap.js';
 import { type ConfirmedLayer } from './replica.js';
-import { type Unconfirmed } from './transfer.js';
+import { type Refused, type Unconfirmed } from './transfer.js';
 export type RefreshOutcome = {
     kind: 'still-current';
 } | {
@@ -9,6 +9,6 @@ export type RefreshOutcome = {
     confirmed: ConfirmedLayer;
 } | {
     kind: 'beyond-horizon';
-} | Unconfirmed | AdapterFailure;
-export declare function refreshRoom(adapter: Adapter, authorization: Authorization, confirmed: ConfirmedLayer, binding: AttachedModelBinding | null): Promise<RefreshOutcome>;
+} | RetryableRefusal | Unconfirmed | Refused | AdapterFailure;
+export declare function refreshRoom(adapter: Adapter, authorization: Authorization, confirmed: ConfirmedLayer, remodel: Remodel, continuing: () => boolean): Promise<RefreshOutcome>;
 //# sourceMappingURL=refresh.d.ts.map