@agentshouse/mdruntime 0.1.0-cd3486bd400ed → 0.1.0-cd37f80239af0

package/dist/chat/questions.js

@@ -1,111 +0,0 @@
-import { list, record, text } from './read.js';
-const OPTION = 'optionId';
-function choicesOf(schema) {
-    const items = record(schema.items);
-    const listed = [schema.oneOf, schema.enum, items.anyOf, items.enum].find(Array.isArray) ?? [];
-    return listed.flatMap((one) => {
-        if (typeof one === 'string')
-            return [{ value: one, label: one, about: null }];
-        const value = text(record(one), 'const');
-        return value === null
-            ? []
-            : [
-                {
-                    value,
-                    label: text(record(one), 'title') ?? value,
-                    about: text(record(one), 'description'),
-                },
-            ];
-    });
-}
-function fieldOf(name, schema) {
-    const type = text(schema, 'type');
-    const kind = type === 'boolean' || type === 'number' || type === 'integer'
-        ? type
-        : type === 'array'
-            ? 'multi-select'
-            : 'string';
-    return {
-        name,
-        kind,
-        prompt: text(schema, 'title') ?? name,
-        about: text(schema, 'description'),
-        choices: kind === 'boolean' ? [] : choicesOf(schema),
-    };
-}
-export function entered(field) {
-    return field.kind !== 'boolean' && field.choices.length === 0;
-}
-function valueOf(field, raw) {
-    return field.kind === 'number' || field.kind === 'integer' ? Number(raw) : raw;
-}
-function typed(fields, answer) {
-    return Object.fromEntries(Object.entries(answer).map(([name, value]) => {
-        const field = fields.find((one) => one.name === name);
-        return [
-            name,
-            field !== undefined && entered(field) && typeof value === 'string'
-                ? valueOf(field, value)
-                : value,
-        ];
-    }));
-}
-function askedOf(request) {
-    const params = record(request.params);
-    const method = text(request, 'method');
-    if (method === 'session/request_permission') {
-        return {
-            message: '',
-            fields: [
-                {
-                    name: OPTION,
-                    kind: 'string',
-                    prompt: text(record(params.toolCall), 'title') ?? '',
-                    about: null,
-                    choices: list(params, 'options').flatMap((entry) => {
-                        const one = record(entry);
-                        const value = text(one, OPTION);
-                        return value === null
-                            ? []
-                            : [{ value, label: text(one, 'name') ?? value, about: null }];
-                    }),
-                },
-            ],
-            accept: (answer) => ({ outcome: { outcome: 'selected', optionId: answer[OPTION] } }),
-            decline: null,
-        };
-    }
-    if (method !== 'elicitation/create')
-        return null;
-    const fields = Object.entries(record(record(params.requestedSchema).properties)).map(([name, schema]) => fieldOf(name, record(schema)));
-    return {
-        message: text(params, 'message') ?? '',
-        fields,
-        accept: (answer) => ({ action: 'accept', content: typed(fields, answer) }),
-        decline: { action: 'decline' },
-    };
-}
-export function questionsOf(view) {
-    return (view?.questions ?? []).flatMap((entry) => {
-        const one = record(entry);
-        const interaction = text(one, 'interaction_id');
-        const asked = askedOf(record(one.request));
-        return asked === null || interaction === null
-            ? []
-            : [
-                {
-                    interaction,
-                    secret: one.secret === true,
-                    undelivered: one.telegram_undelivered === true,
-                    ...asked,
-                },
-            ];
-    });
-}
-export function loneOf(questions) {
-    const asked = questions.length === 1 && !questions[0]?.secret ? questions[0] : undefined;
-    const only = asked?.fields.length === 1 ? asked.fields[0] : undefined;
-    return asked !== undefined && only !== undefined && entered(only)
-        ? { question: asked, field: only }
-        : null;
-}

package/dist/chat/read.d.ts

@@ -1,5 +0,0 @@
-export type Fields = Readonly<Record<string, unknown>>;
-export declare function record(entry: unknown): Fields;
-export declare function text(fields: Fields, name: string): string | null;
-export declare function list(fields: Fields, name: string): readonly unknown[];
-//# sourceMappingURL=read.d.ts.map

package/dist/chat/read.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"read.d.ts","sourceRoot":"","sources":["../../src/chat/read.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAEvD,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAI7C;AAED,wBAAgB,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAGhE;AAED,wBAAgB,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,OAAO,EAAE,CAGrE"}

package/dist/chat/read.js

@@ -1,13 +0,0 @@
-export function record(entry) {
-    return typeof entry === 'object' && entry !== null && !Array.isArray(entry)
-        ? entry
-        : {};
-}
-export function text(fields, name) {
-    const value = fields[name];
-    return typeof value === 'string' && value !== '' ? value : null;
-}
-export function list(fields, name) {
-    const value = fields[name];
-    return Array.isArray(value) ? value : [];
-}

package/dist/chat.d.ts

@@ -1,7 +0,0 @@
-export { ChatProvider, useChat, type ChatActing, type ChatOpened, type ChatProviderProps, type ChatQueued, type ChatState, } from './chat/provider.js';
-export { chatMessages } from './chat/messages.js';
-export type { ChatOutcome } from './chat/acts.js';
-export type { ChatWork } from './chat/parts.js';
-export type { ChatCommand, ChatOption, ChatOptionValue } from './chat/process.js';
-export type { ChatAnswer, ChatChoice, ChatField, ChatLone, ChatQuestion, } from './chat/questions.js';
-//# sourceMappingURL=chat.d.ts.map

package/dist/chat.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chat.d.ts","sourceRoot":"","sources":["../src/chat.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,OAAO,EACP,KAAK,UAAU,EACf,KAAK,UAAU,EACf,KAAK,iBAAiB,EACtB,KAAK,UAAU,EACf,KAAK,SAAS,GACf,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,YAAY,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAClD,YAAY,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAChD,YAAY,EAAE,WAAW,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAClF,YAAY,EACV,UAAU,EACV,UAAU,EACV,SAAS,EACT,QAAQ,EACR,YAAY,GACb,MAAM,qBAAqB,CAAC"}

package/dist/chat.js

@@ -1,2 +0,0 @@
-export { ChatProvider, useChat, } from './chat/provider.js';
-export { chatMessages } from './chat/messages.js';

package/dist/read-side.d.ts

@@ -1,18 +0,0 @@
-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

@@ -1 +0,0 @@
-{"version":3,"file":"read-side.d.ts","sourceRoot":"","sources":["../src/read-side.ts"],"names":[],"mappings":"AAqBA,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;AAuDpD,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;AA+UF,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

@@ -1,433 +0,0 @@
-import { and, BasicIndex, configureIndexDevMode, count, createCollection, createLiveQueryCollection, deepEquals, eq, inArray, or, toArray, } from '@tanstack/db';
-import { ARRAY_INDEX, pointerSegments } from '@agentshouse/mdmodel';
-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 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, 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)]),
-    ]);
-}
-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 });
-    const joined = from
-        .where(({ r }) => every([eq(r.kind, 'reference'), ...(field === null ? [] : [inArray(field, r.forms)])]))
-        .innerJoin({ m: rows }, ({ r, m }) => eq(r[matched], m.key))
-        .where(({ m }) => scoped(scope, m, null, reach));
-    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.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));
-    }
-    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 === null ? {} : { 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 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(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: shape.fields === 'all'
-                    ? row.fields
-                    : selected(row.fields, shape.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();
-        },
-    };
-}