@agentshouse/mdruntime 0.1.0-c2c52158b7381 → 0.1.0-c2e8a6f99866d

package/dist/read-side.js

@@ -1,1179 +0,0 @@
-import { and, coalesce, configureIndexDevMode, count, createCollection, createLiveQueryCollection, deepEquals, eq, inArray, not, or, } from '@tanstack/db';
-import { ARRAY_INDEX, parse, pointerSegments } from '@agentshouse/mdmodel';
-import { rowsOf, } from './observation.js';
-import { documentKey } from './rows.js';
-import { after, inUnits, ROW_WEIGHT, stepped } from './turn.js';
-import { beyond, cursorOf, FROM_START, MAXIMUM_WINDOW } from './windows.js';
-function every(expressions) {
-    const [first, second, ...rest] = expressions;
-    return second === undefined ? first : and(first, second, ...rest);
-}
-function same(held, value) {
-    return Array.isArray(held) ? held.includes(value) : held === value;
-}
-function ordered(held, [operator, bound]) {
-    if (typeof held !== typeof bound || held === null || typeof held === 'object')
-        return false;
-    const left = held;
-    const right = bound;
-    if (operator === 'gt')
-        return left > right;
-    if (operator === 'gte')
-        return left >= right;
-    if (operator === 'lt')
-        return left < right;
-    return left <= right;
-}
-function satisfied(test, held) {
-    if (test.op === 'eq')
-        return same(held, test.value);
-    if (test.op === 'ne')
-        return !same(held, test.value);
-    if (test.op === 'in')
-        return test.values.some((value) => same(held, value));
-    if (test.op === 'nin')
-        return !test.values.some((value) => same(held, value));
-    if (test.op === 'range')
-        return test.bounds.every((bound) => ordered(held, bound));
-    if (test.op === 'all')
-        return Array.isArray(held) && test.values.every((value) => same(held, value));
-    return Array.isArray(held) && held.length === test.size;
-}
-function tested(test, reached) {
-    if (test.op === 'exists')
-        return test.exists === (reached !== undefined);
-    if (reached === undefined)
-        return test.op === 'ne' || test.op === 'nin';
-    return reached.some((held) => satisfied(test, held));
-}
-function conditioned(condition, row) {
-    if ('every' in condition)
-        return condition.every.every((item) => conditioned(item, row));
-    if ('some' in condition)
-        return condition.some.some((item) => conditioned(item, row));
-    return tested(condition.test, row.reached[condition.field]);
-}
-function narrowed(query, where, alias) {
-    return where === null ? query : query.fn.where((row) => conditioned(where, row[alias]));
-}
-function reached(reach, locked, room, document) {
-    return [
-        ...(reach === null
-            ? []
-            : [or(inArray(room, [...reach.rooms]), inArray(document, [...reach.documents]))]),
-        ...(locked.length === 0 ? [] : [not(inArray(room, [...locked]))]),
-    ];
-}
-function scoped(scope, row, rooms, reach, locked, paths = null, folder = null) {
-    return every([
-        eq(row.kind, 'document'),
-        ...(rooms === null ? [] : [inArray(row.room, [...rooms])]),
-        ...(paths === null ? [] : [inArray(row.path, [...paths])]),
-        ...(folder === null ? [] : [eq(row.folder, folder)]),
-        ...reached(reach, locked, row.room, row.key),
-        ...(scope.types === null ? [] : [inArray(row.type, [...scope.types])]),
-        ...(scope.pathPrefix === null ? [] : [inArray(scope.pathPrefix, row.directories)]),
-    ]);
-}
-function keyed(key, row) {
-    return key.of === 'field' ? row.values[key.field] : row[key.of];
-}
-function readied(live) {
-    return new Promise((resolve) => {
-        live.onFirstReady(resolve);
-    });
-}
-function streamed(value) {
-    return coalesce(value);
-}
-function live(query) {
-    return createLiveQueryCollection({
-        query: query,
-        startSync: true,
-        gcTime: 0,
-    });
-}
-function related(q, rows, scope, field, kept, reach, locked) {
-    const matched = kept === 'source' ? 'target' : 'source';
-    const from = q.from({ r: rows });
-    const joined = from
-        .where(({ r }) => every([eq(r.kind, 'reference'), ...(field === null ? [] : [inArray(field, r.forms)])]))
-        .innerJoin({ m: rows }, ({ r, m }) => eq(streamed(r[matched]), streamed(m.key)))
-        .where(({ m }) => scoped(scope, m, null, reach, locked));
-    return narrowed(joined, scope.where, 'm')
-        .groupBy(({ r }) => r[kept])
-        .select(({ r }) => ({ key: r[kept] }));
-}
-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.locked, plan.paths, plan.folder)), plan.root.where, 'd');
-    if (plan.hop !== null) {
-        const hop = related(q, rows, plan.hop, plan.hop.field, 'source', plan.reach, plan.locked);
-        query = query.innerJoin({ h: hop }, ({ d, h }) => eq(streamed(d.key), streamed(h.key)));
-    }
-    if (plan.backlinks !== null) {
-        const backlinks = related(q, rows, plan.backlinks, plan.backlinks.field, 'target', plan.reach, plan.locked);
-        query = query.innerJoin({ k: backlinks }, ({ d, k }) => eq(streamed(d.key), streamed(k.key)));
-    }
-    return query;
-}
-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 }) => streamed(keyed(key, d)), options);
-    }
-    if (shape.orderBy.length > 0 || plan.limit !== null || plan.after !== null) {
-        query = query.orderBy(({ d }) => streamed(d.key), { stringSort: 'lexical' });
-    }
-    if (plan.limit !== null)
-        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.change ? { change: d.change } : {}),
-        ...(shape.fileId ? { fileId: d.fileId } : {}),
-    }));
-}
-function references(q, rows, reach, locked) {
-    const from = q.from({ r: rows });
-    return from
-        .where(({ r }) => every([eq(r.kind, 'reference'), ...reached(reach, locked, r.room, r.source)]))
-        .select(({ r }) => ({
-        key: r.key,
-        target: r.target,
-        path: r.path,
-        type: r.type,
-        field: r.field,
-    }));
-}
-function lexical(left, right) {
-    return left < right ? -1 : left > right ? 1 : 0;
-}
-function linkOrder([leftKey, left], [rightKey, right]) {
-    return (lexical(left.path, right.path) || lexical(left.field, right.field) || lexical(leftKey, rightKey));
-}
-function linkAt(held, entry) {
-    let low = 0;
-    for (let high = held.length; low < high;) {
-        const middle = (low + high) >>> 1;
-        if (linkOrder(held[middle], entry) < 0)
-            low = middle + 1;
-        else
-            high = middle;
-    }
-    return low;
-}
-function targetOf(change) {
-    return change.value.target;
-}
-function relink(linked, { type, key, value }) {
-    const row = value;
-    const entry = [String(key), { path: row.path, type: row.type, field: row.field }];
-    const held = linked.get(row.target) ?? [];
-    const at = linkAt(held, entry);
-    const present = held[at]?.[0] === entry[0];
-    const shifted = (type === 'delete') === present ? held.length - at : 0;
-    if (type === 'delete') {
-        if (present)
-            held.splice(at, 1);
-    }
-    else if (present)
-        held[at] = entry;
-    else
-        held.splice(at, 0, entry);
-    if (held.length === 0)
-        linked.delete(row.target);
-    else
-        linked.set(row.target, held);
-    return shifted;
-}
-function relinked(linked, changes) {
-    return strides(changes, (change) => ROW_WEIGHT + relink(linked, change) / HELD_PER_WEIGHT);
-}
-function linking(links, received) {
-    return links.subscribeChanges(received, { includeInitialState: true });
-}
-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);
-    }
-    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));
-        const count = plan.total
-            ? live((q) => filtered(q, rows, plan).select(({ d }) => ({ key: d.key })))
-            : null;
-        const links = shape.backlinks
-            ? live((q) => references(q, rows, plan.reach, plan.locked))
-            : null;
-        return {
-            live: collection,
-            count,
-            links,
-            dispose: () => {
-                void collection.cleanup();
-                if (count !== null)
-                    void count.cleanup();
-                if (links !== null)
-                    void links.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));
-    return {
-        live: collection,
-        count: null,
-        links: null,
-        dispose: () => {
-            void collection.cleanup();
-            void stage.cleanup();
-        },
-    };
-}
-function sectionsOf(sections, names) {
-    if (names === 'all')
-        return sections;
-    return Object.fromEntries(names.flatMap((name) => (Object.hasOwn(sections, name) ? [[name, sections[name]]] : [])));
-}
-function bodyOf(row, key, bodies) {
-    const text = row.text;
-    if (text === null)
-        return null;
-    const held = bodies?.get(key);
-    if (held !== undefined && held.text === text)
-        return held.document;
-    const read = parse(text, row.path);
-    const document = read.ok ? read.document : null;
-    bodies?.set(key, { text, document });
-    return document;
-}
-function masked(pointers) {
-    const root = { whole: false, members: new Map() };
-    for (const pointer of pointers) {
-        let mask = root;
-        for (const token of pointerSegments(pointer)) {
-            const next = mask.members.get(token) ?? { whole: false, members: new Map() };
-            mask.members.set(token, next);
-            mask = next;
-        }
-        mask.whole = true;
-    }
-    return root;
-}
-function merged(left, right) {
-    if (left === undefined)
-        return right;
-    const members = new Map(left.members);
-    for (const [token, mask] of right.members)
-        members.set(token, merged(members.get(token), mask));
-    return { whole: left.whole || right.whole, members };
-}
-function cut(value, mask) {
-    if (mask.whole)
-        return value;
-    if (Array.isArray(value)) {
-        const each = {
-            whole: false,
-            members: new Map([...mask.members].filter(([token]) => !ARRAY_INDEX.test(token))),
-        };
-        const kept = [];
-        value.forEach((item, index) => {
-            const part = cut(item, merged(mask.members.get(String(index)), each));
-            if (part !== undefined)
-                kept[index] = part;
-        });
-        return kept.length === 0 ? undefined : kept;
-    }
-    if (typeof value !== 'object' || value === null)
-        return undefined;
-    const kept = Object.entries(value).flatMap(([key, held]) => {
-        const member = mask.members.get(key);
-        const part = member === undefined ? undefined : cut(held, member);
-        return part === undefined ? [] : [[key, part]];
-    });
-    return kept.length === 0 ? undefined : Object.fromEntries(kept);
-}
-function selected(fields, pointers) {
-    return (cut(fields, masked(pointers)) ?? {});
-}
-function documentOf(key, row, shape, bodies, linked) {
-    if (row.type === null) {
-        const binary = row.binary;
-        return {
-            room: row.room,
-            path: row.path,
-            ...(binary === null ? {} : { binaryFile: binary }),
-            ...(shape.fileId ? { fileId: row.fileId } : {}),
-        };
-    }
-    const body = bodied(shape) ? bodyOf(row, key, bodies) : null;
-    return {
-        room: row.room,
-        path: row.path,
-        type: row.type,
-        ...(shape.fields === null
-            ? {}
-            : {
-                fields: shape.fields === 'all'
-                    ? row.fields
-                    : selected(row.fields, shape.fields),
-            }),
-        ...(shape.sections === null || body === null
-            ? {}
-            : { sections: sectionsOf(body.sections, shape.sections) }),
-        ...(shape.preamble && body !== null ? { preamble: body.preamble } : {}),
-        ...(shape.markdown && body !== null ? { markdown: body.content } : {}),
-        ...(shape.backlinks
-            ? {
-                backlinks: (linked.get(documentKey(row.room, row.path)) ?? [])
-                    .slice(0, MAXIMUM_WINDOW)
-                    .map(([, link]) => link),
-            }
-            : {}),
-        ...(shape.change ? { change: row.change } : {}),
-        ...(shape.fileId ? { fileId: row.fileId } : {}),
-    };
-}
-function valueAt(row, path) {
-    let value = row;
-    for (const part of path)
-        value = value?.[part];
-    return value;
-}
-function weight(row) {
-    return ROW_WEIGHT + (typeof row?.text === 'string' ? row.text.length : 0);
-}
-const HELD_PER_WEIGHT = 16;
-const STRIDE = ROW_WEIGHT * 16;
-function* strides(items, each) {
-    let spent = 0;
-    for (const item of items) {
-        spent += each(item);
-        if (spent < STRIDE)
-            continue;
-        yield spent;
-        spent = 0;
-    }
-    if (spent > 0)
-        yield spent;
-}
-function joined(plan) {
-    return (plan.hop !== null ||
-        plan.backlinks !== null ||
-        (plan.shape.kind === 'documents' && plan.shape.backlinks));
-}
-function admission(plan) {
-    if (joined(plan))
-        return () => true;
-    const rooms = plan.rooms === null ? null : new Set(plan.rooms);
-    const paths = plan.paths === null ? null : new Set(plan.paths);
-    return (row) => row.kind === 'document' &&
-        (rooms === null || rooms.has(row.room)) &&
-        (paths === null || paths.has(row.path));
-}
-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, keys, valueOf, total, each) {
-    const shape = plan.shape;
-    const cursor = shape.kind === 'groups' ? (plan.after?.values ?? null) : null;
-    const orderings = shape.kind === 'groups' ? groupOrder(shape) : [];
-    let all = 0;
-    let following = 0;
-    let last;
-    yield* strides(keys, (key) => {
-        all += 1;
-        const admitted = shape.kind === 'documents' ||
-            cursor === null ||
-            beyond(groupValues(shape, [key, valueOf(key)]), cursor, orderings);
-        if (admitted)
-            following += 1;
-        if (!admitted || (plan.limit !== null && following > plan.limit))
-            return ROW_WEIGHT;
-        last = key;
-        return each(key);
-    });
-    const next = plan.limit === null || following <= plan.limit
-        ? undefined
-        : last === undefined
-            ? (plan.after?.text ?? FROM_START)
-            : shape.kind === 'documents'
-                ? documentCursor(shape, valueOf(last))
-                : cursorOf(groupValues(shape, [last, valueOf(last)]));
-    return { next, total: shape.kind === 'documents' ? total : plan.total ? all : undefined };
-}
-function framed(rows, { next, total }) {
-    return {
-        ...rows,
-        ...(next === undefined ? {} : { next }),
-        ...(total === undefined ? {} : { total }),
-    };
-}
-function rowOf(shape, [key, row], bodies, linked) {
-    if (shape.kind === 'documents')
-        return documentOf(key, row, shape, bodies, linked);
-    return { key: shape.groupBy.map((_, index) => row[`key${index}`]), count: row.count };
-}
-function resultOf(grouped, rows, coverage, window) {
-    return grouped
-        ? framed({ groups: rows, coverage }, window)
-        : framed({ documents: rows, coverage }, window);
-}
-function* rowsOfPlan(plan, keys, valueOf, total, linked) {
-    const rows = [];
-    const window = yield* windowOf(plan, keys, valueOf, total, (key) => {
-        const value = valueOf(key);
-        rows.push(structuredClone(rowOf(plan.shape, [key, value], null, linked)));
-        return weight(value);
-    });
-    return plan.shape.kind === 'groups'
-        ? framed({ groups: rows }, window)
-        : framed({ documents: rows }, window);
-}
-function textOf(row) {
-    if (!('path' in row))
-        return 0;
-    let length = (row.markdown?.length ?? 0) + (row.preamble?.length ?? 0);
-    for (const section of Object.values(row.sections ?? {}))
-        length += section.length;
-    return length;
-}
-export function* reconciled(previous, next) {
-    const before = previous.result;
-    const after = next.result;
-    if ('pending' in before || 'pending' in after) {
-        if (deepEquals(before, after))
-            return null;
-        return { keyed: next, message: next };
-    }
-    const earlier = rowsOf(before);
-    const held = new Map();
-    yield* strides(previous.keys.entries(), ([index, key]) => {
-        held.set(key, earlier[index]);
-        return ROW_WEIGHT;
-    });
-    const later = rowsOf(after);
-    const present = new Set();
-    const changed = [];
-    const rows = [];
-    yield* strides(next.keys.entries(), ([index, key]) => {
-        const row = later[index];
-        const kept = held.get(key);
-        present.add(key);
-        if (kept !== undefined && deepEquals(kept, row))
-            rows.push(kept);
-        else {
-            changed.push([key, row]);
-            rows.push(row);
-        }
-        return ROW_WEIGHT + textOf(row);
-    });
-    const keyed = {
-        result: resultOf('groups' in after, rows, after.coverage, {
-            next: after.next,
-            total: after.total,
-        }),
-        keys: next.keys,
-    };
-    const message = yield* changeOf(previous, keyed, changed, (key) => present.has(key));
-    return message === null ? null : { keyed, message };
-}
-function* changeOf(previous, next, changed, present, dropped = () => { }) {
-    const before = previous.result;
-    const after = next.result;
-    const removed = [];
-    let at = 0;
-    let moved = false;
-    yield* strides(previous.keys.entries(), ([index, key]) => {
-        if (present(key, index)) {
-            moved ||= next.keys[at] !== key;
-            at += 1;
-        }
-        else {
-            removed.push(key);
-            dropped(key);
-        }
-        return ROW_WEIGHT;
-    });
-    moved ||= at !== next.keys.length;
-    const covered = !deepEquals(before.coverage, after.coverage);
-    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 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 };
-}
-export function createReadSide() {
-    configureIndexDevMode({ enabled: false });
-    const rows = new Map();
-    const roomPaths = new Map();
-    const views = new Set();
-    const shared = new Map();
-    let writing = false;
-    let publishing = null;
-    let closed = false;
-    function viewOf(plan) {
-        let sync;
-        const view = {
-            plan,
-            rows: createCollection({
-                getKey: (row) => row.key,
-                gcTime: 0,
-                startSync: true,
-                autoIndex: 'off',
-                sync: {
-                    rowUpdateMode: 'full',
-                    sync: (params) => {
-                        sync = params;
-                    },
-                },
-            }),
-            sync,
-            admits: admission(plan),
-            stopped: false,
-            waiting: null,
-        };
-        views.add(view);
-        return view;
-    }
-    function freeze(view) {
-        view.waiting ??= new Map();
-    }
-    function thaw(view) {
-        const waiting = view.waiting;
-        if (waiting === null)
-            return;
-        let unit = new Map();
-        return after(inUnits(waiting, ([key, row]) => {
-            waiting.delete(key);
-            unit.set(key, row);
-            const was = view.rows.get(key);
-            return weight(row ?? undefined) + charged(view, was, row ?? undefined);
-        }, () => {
-            synced(view, unit);
-            unit = new Map();
-        }), () => {
-            if (waiting.size > 0)
-                return thaw(view);
-            view.waiting = null;
-        });
-    }
-    function dropped(view) {
-        view.stopped = true;
-        views.delete(view);
-        void view.rows.cleanup();
-    }
-    function* offered(view) {
-        const { plan } = view;
-        const { rooms, paths } = plan;
-        if (joined(plan) || rooms === null || paths === null) {
-            for (const key of rows.keys()) {
-                if (view.stopped)
-                    return;
-                yield key;
-            }
-            return;
-        }
-        for (const room of rooms) {
-            for (const path of paths) {
-                if (view.stopped)
-                    return;
-                yield documentKey(room, path);
-            }
-        }
-    }
-    function written(view, writes) {
-        if (view.waiting === null)
-            synced(view, writes);
-        else
-            for (const [key, row] of writes)
-                view.waiting.set(key, row);
-    }
-    function synced(view, writes) {
-        if (view.stopped || writes.size === 0)
-            return;
-        view.sync.begin();
-        for (const [key, row] of writes) {
-            if (row !== null) {
-                view.sync.write({ type: view.rows.has(key) ? 'update' : 'insert', value: row });
-            }
-            else if (view.rows.has(key))
-                view.sync.write({ type: 'delete', key });
-        }
-        view.sync.commit();
-    }
-    function filled(view) {
-        let unit = new Map();
-        return after(inUnits(offered(view), (key) => {
-            const row = rows.get(key);
-            if (row === undefined || !view.admits(row) || view.rows.has(key))
-                return ROW_WEIGHT;
-            unit.set(key, row);
-            return weight(row) + charged(view, undefined, row);
-        }, () => {
-            written(view, unit);
-            unit = new Map();
-        }), () => {
-            if (!view.stopped)
-                view.sync.markReady();
-        });
-    }
-    function searched(row) {
-        const read = row.text === null ? null : parse(row.text, row.path);
-        if (read === null || !read.ok)
-            return null;
-        return {
-            room: row.room,
-            path: row.path,
-            type: row.type,
-            fields: row.fields,
-            preamble: read.document.preamble,
-            sections: read.document.sections,
-        };
-    }
-    function counted(entry) {
-        return entry.built.count === null ? undefined : entry.built.count.size;
-    }
-    function* delivery(entry, whole, dirty, touched, relinking, coverage) {
-        const { plan } = entry;
-        const live = entry.built.live;
-        const valueOf = (key) => live.get(key);
-        const previous = entry.result;
-        const answered = previous === undefined || 'pending' in previous.result ? null : previous;
-        const answeredKeys = answered?.keys ?? [];
-        const answeredRows = answered === null ? [] : rowsOf(answered.result);
-        const matched = new Uint8Array(answeredKeys.length);
-        const generation = (entry.generation += 1);
-        const keys = [];
-        const changed = [];
-        const rows = [];
-        let at = 0;
-        const touches = (key) => {
-            const { room, path } = valueOf(key);
-            return touched.has(documentKey(room, path));
-        };
-        const behind = (key) => !live.has(key) || entry.rows.get(key)?.at === generation;
-        yield* relinked(entry.linked, relinking);
-        const window = yield* windowOf(plan, live.keys(), valueOf, counted(entry), (key) => {
-            let skipped = 0;
-            while (skipped < STRIDE &&
-                at < answeredKeys.length &&
-                answeredKeys[at] !== key &&
-                behind(answeredKeys[at])) {
-                at += 1;
-                skipped += ROW_WEIGHT;
-            }
-            let holder;
-            let prior;
-            if (at < answeredKeys.length && answeredKeys[at] === key) {
-                prior = answeredRows[at];
-                matched[at] = 1;
-                at += 1;
-            }
-            else {
-                holder = entry.rows.get(key);
-                prior = holder?.row;
-                if (holder !== undefined)
-                    holder.at = generation;
-            }
-            let row = prior;
-            let spent = ROW_WEIGHT;
-            if (row === undefined || whole || dirty.has(key) || (touched.size > 0 && touches(key))) {
-                const value = valueOf(key);
-                const renewed = rowOf(plan.shape, [key, value], entry.bodies, entry.linked);
-                if (row === undefined || !deepEquals(row, renewed))
-                    row = renewed;
-                spent = weight(value);
-            }
-            if (row !== prior) {
-                holder ??= entry.rows.get(key);
-                if (holder === undefined)
-                    entry.rows.set(key, { row, at: generation });
-                else
-                    holder.row = row;
-                changed.push([key, row]);
-            }
-            keys.push(key);
-            rows.push(row);
-            return skipped + spent;
-        });
-        const result = {
-            result: resultOf(plan.shape.kind === 'groups', rows, coverage, window),
-            keys,
-        };
-        if (previous === undefined)
-            return { result, message: null };
-        if (answered === null)
-            return { result, message: result };
-        const message = yield* changeOf(answered, result, changed, (key, index) => matched[index] === 1 || entry.rows.get(key)?.at === generation, (key) => {
-            entry.rows.delete(key);
-            entry.bodies.delete(key);
-        });
-        return { result, message };
-    }
-    function delivered(entry, { result, message }) {
-        entry.result = result;
-        if (message !== null)
-            for (const listener of entry.ready)
-                listener(message);
-        for (const listener of entry.fresh) {
-            entry.ready.add(listener);
-            listener(result);
-        }
-        entry.fresh.clear();
-    }
-    function run(entry) {
-        while (entry.listeners.size > 0 &&
-            (entry.whole ||
-                entry.dirty.size > 0 ||
-                entry.touched.size > 0 ||
-                entry.stale ||
-                entry.fresh.size > 0)) {
-            entry.stale = false;
-            const cover = entry.cover();
-            if ('pending' in cover) {
-                entry.whole = true;
-                entry.dirty.clear();
-                entry.touched.clear();
-                entry.rows.clear();
-                entry.bodies.clear();
-                const result = { result: cover, keys: [] };
-                const previous = entry.result;
-                const same = previous === undefined || deepEquals(previous.result, cover);
-                delivered(entry, { result, message: same ? null : result });
-                break;
-            }
-            const whole = entry.whole ||
-                entry.plan.shape.kind === 'groups' ||
-                entry.result === undefined ||
-                'pending' in entry.result.result;
-            const dirty = entry.dirty;
-            const touched = entry.touched;
-            const relinking = entry.relinking;
-            entry.dirty = new Set();
-            entry.touched = new Set();
-            entry.relinking = [];
-            entry.whole = false;
-            freeze(entry.view);
-            let made;
-            try {
-                made = stepped(delivery(entry, whole, dirty, touched, relinking, cover.coverage));
-            }
-            catch (error) {
-                void thaw(entry.view);
-                throw error;
-            }
-            if (made instanceof Promise) {
-                void made
-                    .then((delivering) => {
-                    if (entry.listeners.size > 0)
-                        delivered(entry, delivering);
-                })
-                    .finally(() => thaw(entry.view))
-                    .then(() => {
-                    entry.running = false;
-                    wake(entry);
-                }, () => {
-                    entry.running = false;
-                });
-                return;
-            }
-            void thaw(entry.view);
-            delivered(entry, made);
-        }
-        entry.running = false;
-    }
-    function wake(entry) {
-        if (entry.subscription === null || entry.running || writing || publishing !== null)
-            return;
-        entry.running = true;
-        try {
-            run(entry);
-        }
-        catch (error) {
-            entry.running = false;
-            throw error;
-        }
-    }
-    function recover() {
-        for (const entry of shared.values()) {
-            if (entry.result === undefined || entry.subscription === null)
-                continue;
-            const cover = entry.cover();
-            const before = entry.result.result;
-            const held = 'pending' in cover
-                ? deepEquals(before, cover)
-                : 'coverage' in before && deepEquals(before.coverage, cover.coverage);
-            if (held)
-                continue;
-            entry.stale = true;
-            wake(entry);
-        }
-    }
-    function listed(key, row) {
-        const held = rows.get(key) ?? row;
-        if (held?.kind !== 'document')
-            return;
-        const paths = roomPaths.get(held.room) ?? new Set();
-        if (row?.kind === 'document' && row.type !== null)
-            paths.add(key);
-        else
-            paths.delete(key);
-        if (paths.size === 0)
-            roomPaths.delete(held.room);
-        else
-            roomPaths.set(held.room, paths);
-    }
-    function committed(next) {
-        if (closed || next.size === 0)
-            return;
-        for (const [key, row] of next) {
-            listed(key, row);
-            if (row === null)
-                rows.delete(key);
-            else
-                rows.set(key, row);
-        }
-        for (const view of views) {
-            const writes = new Map();
-            for (const [key, row] of next) {
-                if (row !== null && view.admits(row))
-                    writes.set(key, row);
-                else if (view.rows.has(key) || view.waiting?.has(key))
-                    writes.set(key, null);
-            }
-            written(view, writes);
-        }
-    }
-    function moved({ plan }, before, after) {
-        const shape = plan.shape;
-        if (shape.kind === 'documents' && plan.limit === null && shape.orderBy.length > 0) {
-            return true;
-        }
-        const keys = shape.kind === 'documents' ? shape.orderBy.map(({ key }) => key) : shape.groupBy;
-        for (const key of keys) {
-            const path = key.of === 'field' ? ['values', key.field] : [key.of];
-            if (!deepEquals(valueAt(before, path), valueAt(after, path)))
-                return true;
-        }
-        return false;
-    }
-    function charged(view, was, row) {
-        const kept = was !== undefined && view.admits(was);
-        const admitted = row !== undefined && view.admits(row);
-        if (!kept && !admitted)
-            return 0;
-        const shifted = view.rows.size / HELD_PER_WEIGHT;
-        return shifted + (kept && admitted && !moved(view, was, row) ? 0 : shifted);
-    }
-    function charges(was, row) {
-        let spent = 0;
-        for (const view of views)
-            spent += charged(view, was, row);
-        return spent;
-    }
-    function published(set) {
-        let unit = new Map();
-        return inUnits(set.documents, (change) => {
-            if (closed)
-                return 0;
-            const { before, after } = change;
-            const kept = new Set(after.map((row) => row.key));
-            const held = new Map(before.map((row) => [row.key, row]));
-            let spent = 0;
-            for (const row of before) {
-                unit.set(row.key, null);
-                spent += ROW_WEIGHT + (kept.has(row.key) ? 0 : charges(row, undefined));
-            }
-            for (const row of after) {
-                unit.set(row.key, row);
-                spent += weight(row) + charges(held.get(row.key), row);
-            }
-            return spent;
-        }, () => {
-            committed(unit);
-            unit = new Map();
-        });
-    }
-    function released() {
-        recover();
-        for (const entry of shared.values())
-            wake(entry);
-    }
-    function publishedLater(applied) {
-        const fence = applied.then(() => { }, () => { });
-        publishing = fence;
-        void fence.then(() => {
-            if (publishing !== fence)
-                return;
-            publishing = null;
-            released();
-        });
-        return applied;
-    }
-    async function settled() {
-        while (publishing !== null)
-            await publishing;
-    }
-    return {
-        apply(set, next = () => { }) {
-            const pending = publishing;
-            if (pending !== null || set instanceof Promise) {
-                return publishedLater(Promise.all([set, pending]).then(([held]) => after(published(held), () => next(held))));
-            }
-            writing = true;
-            let applied;
-            try {
-                applied = published(set);
-            }
-            finally {
-                writing = false;
-            }
-            if (applied instanceof Promise)
-                return publishedLater(applied.then(() => next(set)));
-            released();
-            next(set);
-        },
-        recover,
-        settled,
-        async query(plan, at) {
-            const view = viewOf(plan);
-            const linked = new Map();
-            let made = null;
-            let following = null;
-            try {
-                const filling = filled(view);
-                made = built(view.rows, plan);
-                const { live: collection, count, links } = made;
-                if (links !== null) {
-                    following = linking(links, (changes) => {
-                        for (const change of changes)
-                            relink(linked, change);
-                    });
-                }
-                await filling;
-                for (const one of [collection, count, links])
-                    if (one !== null)
-                        await readied(one);
-                await settled();
-                freeze(view);
-                following?.unsubscribe();
-                following = null;
-                const held = at();
-                const rows = await stepped(rowsOfPlan(plan, collection.keys(), (key) => collection.get(key), count?.size, linked));
-                return { rows, at: held };
-            }
-            finally {
-                following?.unsubscribe();
-                made?.dispose();
-                dropped(view);
-            }
-        },
-        watch(plan, identity, cover, deliverTo) {
-            let entry = shared.get(identity);
-            if (entry === undefined) {
-                const view = viewOf(plan);
-                void filled(view);
-                const created = {
-                    plan,
-                    view,
-                    built: built(view.rows, plan),
-                    cover,
-                    result: undefined,
-                    rows: new Map(),
-                    generation: 0,
-                    bodies: new Map(),
-                    listeners: new Set(),
-                    fresh: new Set(),
-                    ready: new Set(),
-                    subscription: null,
-                    counting: null,
-                    linking: null,
-                    linked: new Map(),
-                    relinking: [],
-                    touched: new Set(),
-                    whole: true,
-                    dirty: new Set(),
-                    stale: false,
-                    running: false,
-                };
-                if (created.built.links !== null) {
-                    created.linking = linking(created.built.links, (changes) => {
-                        for (const change of changes) {
-                            created.relinking.push(change);
-                            created.touched.add(targetOf(change));
-                        }
-                        if (created.subscription !== null)
-                            queueMicrotask(() => wake(created));
-                    });
-                }
-                created.built.live.on('status:change', ({ status }) => {
-                    if (status !== 'cleaned-up' || created.listeners.size > 0)
-                        return;
-                    if (shared.get(identity) === created)
-                        shared.delete(identity);
-                });
-                shared.set(identity, created);
-                entry = created;
-            }
-            const observed = entry;
-            observed.listeners.add(deliverTo);
-            const ready = (then) => observed.built.live.onFirstReady(() => {
-                const linked = () => observed.built.links === null ? then() : observed.built.links.onFirstReady(then);
-                return observed.built.count === null
-                    ? linked()
-                    : observed.built.count.onFirstReady(linked);
-            });
-            const settled = () => {
-                if (observed.built.count === null)
-                    wake(observed);
-                else
-                    queueMicrotask(() => wake(observed));
-            };
-            ready(() => {
-                if (!observed.listeners.has(deliverTo))
-                    return;
-                observed.fresh.add(deliverTo);
-                if (observed.subscription === null) {
-                    observed.whole = true;
-                    observed.subscription = observed.built.live.subscribeChanges((changes) => {
-                        if (observed.plan.shape.kind === 'groups')
-                            observed.whole = true;
-                        else
-                            for (const { key } of changes)
-                                observed.dirty.add(key);
-                        settled();
-                    }, { includeInitialState: false });
-                    observed.counting =
-                        observed.built.count?.subscribeChanges(() => {
-                            observed.stale = true;
-                            settled();
-                        }, { includeInitialState: false }) ?? null;
-                }
-                wake(observed);
-            });
-            return () => {
-                observed.fresh.delete(deliverTo);
-                observed.ready.delete(deliverTo);
-                if (!observed.listeners.delete(deliverTo) || observed.listeners.size > 0)
-                    return;
-                observed.subscription?.unsubscribe();
-                observed.subscription = null;
-                observed.counting?.unsubscribe();
-                observed.counting = null;
-                observed.linking?.unsubscribe();
-                observed.linking = null;
-                observed.result = undefined;
-                observed.rows.clear();
-                observed.bodies.clear();
-                observed.dirty.clear();
-                observed.touched.clear();
-                observed.whole = true;
-                if (shared.get(identity) === observed)
-                    shared.delete(identity);
-                observed.built.dispose();
-                dropped(observed.view);
-            };
-        },
-        *room(room) {
-            for (const key of roomPaths.get(room) ?? []) {
-                const row = rows.get(key);
-                if (row?.kind === 'document')
-                    yield row.path;
-            }
-        },
-        document(room, path) {
-            const row = rows.get(documentKey(room, path));
-            return row?.kind !== 'document' || row.type === null ? null : searched(row);
-        },
-        close() {
-            closed = true;
-            for (const entry of shared.values()) {
-                entry.listeners.clear();
-                entry.fresh.clear();
-                entry.ready.clear();
-                entry.subscription?.unsubscribe();
-                entry.counting?.unsubscribe();
-                entry.linking?.unsubscribe();
-                entry.built.dispose();
-            }
-            shared.clear();
-            for (const view of [...views])
-                dropped(view);
-            rows.clear();
-            roomPaths.clear();
-        },
-    };
-}