@agentshouse/mdruntime 0.1.0-cff8ba8fa2542 → 0.1.0-cffcba9cd9c2f

package/AGENTS.md

@@ -1,231 +0,0 @@
-# Instructions for the App Creator's agent
-
-These instructions address an agent in an environment with Git. Obtain the
-App Repository, change it, build, and push. They are documentation, not
-enforcement.
-
-## The MD Runtime API
-
-App code reaches the MD Runtime through the remote client. The surfaces are
-Rooms, Query, Search, Observe, Types, Room Draft, Save, History, Call, Reached, Log,
-the reported persistence answer, reauthorization, conversation, the chat draft,
-and Presentation State. Sync Status, the Service Mode, the storage-loss
-statement and the deployment facts are observations only.
-
-The host attaches each port with its reach, and every member and observation
-answers within it: a Room outside it answers as one the replica does not hold, a
-Room reached for single Documents shows only those Documents, the Types of the
-models that govern them and no attachments, and without conversations the
-conversation members, the chat draft and the conversation observation hold none.
-A change of the reach reaches every open observation as its new value, a query
-keeping every unchanged Document the same object.
-
-Every `observe` resolves, once its first value has arrived, to a handle:
-`current()` is the latest complete value, `subscribe(listener)` hears each later
-value whole and returns its unsubscribe, and `close()` ends the observation.
-Closing the port ends every handle and rejects every pending call and
-observation; a client that reconnects observes again.
-
-Each conversation the Provider's conversation list names is held complete in the
-browser. `conversation.list()` and `observe('conversations')` answer each with its
-Agent's identity and name, its name, created and finished times, last outcome and live
-`state`: `asking` while a question waits, `working` while a turn runs, else `idle`,
-and `started`, when the running turn began, or `null`.
-Observe one with `observe('conversation', id, { limit })`: the view
-holds its latest `limit` messages, or all of them, oldest first, its chat
-draft, and what the Provider streams for it whether or not anything views it:
-the running `turn` with its message parts and its context in use and window, the
-open questions, the process state, and the CLI's commands and options. These live
-only in memory: the message accepted under the turn's id replaces the running turn,
-and none of them is stored or searchable.
-`chatDraft.write` and `chatDraft.discard` keep what the App Creator composes;
-sending it is a Provider Action that needs the Provider reachable and is never
-queued.
-
-Each Room in Rooms lists its `attachments`, the files the Provider holds for it
-that its Documents link by the Provider's reference, ordered by `reference`,
-each with `name`, `byteLength`, `mediaType` and the Provider's own entry as
-`entry`. They are as the Provider last declared them and hold no bytes;
-open one through the Provider Action that serves it.
-
-Rooms, Query, Search, Observe, Types, Room Draft, Save, and Reached never
-touch the network.
-History and Call go to the Provider through the Adapter. A Call result whose
-effect the Provider places in a Room carries `at`, that Room and Room Version;
-`reached(room, roomVersion)` answers whether the Room's confirmed state has
-reached it, and the MD Runtime keeps refreshing that Room until it has;
-`reached(room, roomVersion, path)` answers whether the held confirmed copy of
-that document was written at a later Room Version. Each History revision
-names its author, `{ kind: 'user', id }` or `{ kind: 'site', id, name }`. Every
-member of the
-client is asynchronous. Results are detached snapshots. Nothing in this
-surface returns the authorization, performs a request the App's code
-composes, or exposes the browser store.
-
-Read the deployment facts with `observe('deployment-facts')`. Interpret the
-opaque value using the host's contract.
-
-The in-memory Adapter at `@agentshouse/mdruntime/memory` is for tests and
-ships in no bundle.
-
-## Local Query rules
-
-`query(q)` answers once from local state; `observe('query', q)` holds the whole
-result and hears it again only when it changes, keeping every unchanged Document
-the same object, so a component can tell what changed by identity. A query is
-data:
-
-- **Filter.** `rooms` names Room locators and defaults to every Room. `types`
-  names MD Types, and `any` names untyped Markdown Documents. `pathPrefix` is a
-  directory: `notes` keeps `notes/a.md` and not `notes2/a.md`.
-- **Fields.** `where` names frontmatter fields, ANDs them, and nests `$and` and
-  `$or`. A bare value is equality; the operators are `$eq`, `$ne`, `$in`, `$nin`,
-  `$gt`, `$gte`, `$lt`, `$lte`, `$all`, `$size` and `$exists`. Equality on a list
-  asks whether it contains the value. Missing, null and empty differ:
-  `$exists: false` keeps a missing field, `null` an explicit null, `''` empty
-  text and `$size: 0` an empty list. A date compares in calendar order and never
-  with a date-time. A reference compares by the Room Path it resolves to.
-  Untyped frontmatter is plain values. There is no text containment or regular
-  expression.
-- **Relations.** `hop: { field, types, where, pathPrefix }` keeps Documents whose
-  reference `field` points to a matching Document of the same Room.
-  `backlinks: { field, types, where, pathPrefix }` keeps Documents that a
-  matching Document of the same Room references. Each keeps a Document once.
-- **Parts.** A Document query must `select`: `'all'`, or `fields`, `sections`,
-  `preamble`, `markdown`, `backlinks` and `change`, where `fields` and `sections`
-  are `'all'` or a list of names. Room and Path always return; a Markdown
-  Document also returns its MD Type. A non-Markdown Document or binary link
-  target returns only Room and Path. An unselected part is absent. Select only
-  what a screen shows: a list that selects the Markdown hears every edit of it.
-- **Change.** `change` is `{ author, time }` of the Document's head revision as
-  the Provider last delivered it: `author` is `{ kind: 'user' | 'site', id, name }`
-  or `null` for a write the Provider made itself, and `time` is the Provider's
-  ISO 8601 change time. It is `null` where the Provider delivered no time, as at
-  a Site. An unsent edit or move keeps it, an unsent creation has none, and a
-  saved write takes the Provider's own once it is Accepted and refreshed. A
-  Room's last change is its Document with the latest `time`.
-- **Order and groups.** `orderBy` sorts by `room`, `path`, `type` or `{ field }`
-  with TanStack DB's own options, and ties end with Room, then Path. `groupBy` by
-  `room`, `type` or `{ field }` answers `{ groups: [{ key, count }] }`, counted
-  over every match and ordered by `count` or a key. `limit` bounds the Documents
-  or the groups.
-- **Results and errors.** A result carries no Room Version: read freshness from
-  Rooms and Sync Status. An invalid query fails with `invalid-query`,
-  `unknown-type`, `unknown-field` or `wrong-kind`, naming where, and never
-  answers an empty result in its place.
-
-## Local Search rules
-
-`search({ text, documents, conversations, limit })` answers once, by words, from
-local state, with MiniSearch at its default configuration. There is no observed
-search.
-
-- **What is found.** A Document by its field values, its sections' headings and
-  text, its preamble and its Path; a message by its text. Frontmatter keys, Room
-  Drafts, chat drafts and a running turn's parts are never found. There are no phrases,
-  word forms, typo tolerance or prefix matching.
-- **Narrowing.** `documents` is a Local Query filter: `rooms`, `types`, `where`,
-  `pathPrefix`, `hop` and `backlinks`. `conversations` names conversations. Both
-  apply before `limit`, which bounds each list; without it every hit returns.
-- **Results.** `{ documents, messages }`, each ranked by `score`, which compares
-  hits of one list of one search. A Document hit names its `room`, `path` and
-  `type`, a message hit its `conversation` and `identity`, and `matches` maps each
-  matched word to the parts it matched in: `fields`, `sections`, `preamble` or
-  `path`, or `text`. A hit carries no position; mark the words in the text you
-  show. An invalid filter fails with its Local Query error.
-
-## Room Draft, Save, and outcome rules
-
-The MD Runtime owns one Room Draft per Room and Path, shared by every App and
-tab. It is durable: it survives reload and navigation. A Room that Discovery
-stops listing takes its Room Drafts and its queue with it.
-Write a Room Draft with `roomDraft.write(room, path, revision, parts)`, naming
-the revision you read, or `null` when there was none, and every part it should
-now change: fields, sections and the preamble, or the whole Markdown, a
-creation, a move, or a removal. A part new to the Room Draft names its base,
-the value you showed when it was opened; the MD Runtime keeps a part's first
-base. A binary link target has a Room Draft too, for a move or a removal, with
-`null` as its base. A write or a discard from an older revision is refused as `stale` with
-the current Room Draft; read it and write again.
-
-Save takes one Room and the Room Drafts of it to save, each with its revision,
-validates locally, and on success appends one Change Batch to that Room's
-queue and removes those Room Drafts. It is refused as `stale`, as
-`changed-underneath` naming each part whose base no longer matches the visible
-state, or by a local validation rule, and then creates nothing and leaves every
-Room Draft in place. A directory move or removal is a move or removal part on
-each Document and binary link target beneath it, saved together.
-
-Outcomes follow the Provider's answer. An Accepted Change Batch stays in the
-queue, drawn over the confirmed layer, until the confirmed layer reaches the
-Room Version it was accepted at, and then leaves it. Conflicted and Rejected, an expired operation, and a change that no
-longer applies over the Room each leave the queue and return as Room Drafts on
-the Documents they changed, marked with why: the Provider's structured refusal
-code and fields as returned, not known to have applied, or withdrawn locally.
-The rest of the queue keeps synchronizing, and Sync Status requires attention
-until each returned Room Draft is saved again or discarded. A Change Batch
-keeps no outcome once it leaves the queue; `observe('queue', room)` shows each
-Pending one, and a returned Room Draft says why it returned. Transport
-failure and Provider unavailability keep work Pending and do not infer a
-rejection. A refusal the Provider marks retryable stays Pending until the reset
-it names; the MD Runtime retries the same Change Batch identity and payload and
-never infers an outcome from transport uncertainty. The MD Runtime never
-combines, reorders, or rebases.
-
-`observe('service-mode')` answers the Provider's Service
-Mode, `open` or `write-halted`. While writes are halted, Save still succeeds,
-its Change Batch waits unsent, and the queue is submitted in order once the
-Provider reopens writes. An Action is never held: a write the Provider refuses
-for the halt returns that refusal to its caller. Show the Provider as read-only
-instead of retrying.
-
-## The neutrality rule
-
-No module outside an Adapter package imports, names, or special-cases a
-Provider. MD UI and every App reach data only through the client entry.
-
-## Content-safety rules
-
-The Provider authorization belongs to the Runtime host and is never readable
-by the App's code. The App's code reaches the network only at the external
-origins its manifest declares, empty by default, and the Provider enforces
-that set. Every request to the Provider itself goes through the MD Runtime.
-Rendered Markdown never executes scripts, renders raw HTML only for the
-details and summary elements, and loads images and other resources only from
-origins the Provider's policy allows.
-
-## Launch promises MD UI keeps
-
-MD UI uses semantic HTML, is fully operable from a keyboard with visible
-focus and labelled controls, and lays out from a 360 pixel wide viewport to
-a desktop. Its strings are English only, dates and numbers follow the
-browser locale, and content is never translated. Light and dark themes come
-from CSS custom properties with the browser's preference as the default and
-an App's override respected. What an App Creator's agent adds carries none
-of these promises by itself. Reading, querying and searching never wait for
-the network. Data lives only in the App Creator's browser and with the Provider.
-
-## App code takes the client its host hands it and never constructs a Runtime
-
-App code takes the client its host hands it: in House,
-`connectHouseBridge().runtime` from `@agentshouse/app-bridge` resolves to the
-client House built into the page. It never constructs a Runtime or a client.
-It imports only types from `@agentshouse/mdruntime/client`, does not call
-`connectMdRuntime` or `serveMdRuntime`, and does not import the package main,
-the host entry, or the Adapter package. Hosts and tests use those entries; the
-served App does not.
-
-A React App may observe and save through `@agentshouse/mdruntime/react`, which
-names React as a peer dependency. `useObserve(client, topic, ...input)` takes
-the arguments of `observe` and returns the topic's current value, `undefined`
-until it arrives, re-rendering on each change; a `null` client observes
-nothing. `useSave(client)` returns `busy`, the last `outcome` or `failure`, and
-`save(room, roomDrafts)`, which writes each Path's parts onto the Room Draft
-already there, keeping the bases its parts have, or onto a new one, and saves
-them together. A refused Save leaves the Room Drafts for the App to save again
-or discard; a failure is recorded and rejects.
-
-## What an agent must never do
-
-An agent must never read the authorization, load code from a Room, call the
-Provider directly, or rebase a refused Change Batch.

package/dist/attachment.d.ts

@@ -1,3 +0,0 @@
-import type { RoomAttachment } from './adapter.js';
-export declare function declaredAttachments(pages: readonly (readonly RoomAttachment[])[]): readonly RoomAttachment[];
-//# sourceMappingURL=attachment.d.ts.map

package/dist/attachment.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"attachment.d.ts","sourceRoot":"","sources":["../src/attachment.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAEnD,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,SAAS,CAAC,SAAS,cAAc,EAAE,CAAC,EAAE,GAC5C,SAAS,cAAc,EAAE,CAQ3B"}

package/dist/attachment.js

@@ -1,8 +0,0 @@
-export function declaredAttachments(pages) {
-    const byReference = new Map();
-    for (const page of pages) {
-        for (const attachment of page)
-            byReference.set(attachment.reference, attachment);
-    }
-    return [...byReference.values()].sort((left, right) => left.reference < right.reference ? -1 : left.reference > right.reference ? 1 : 0);
-}

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":"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

@@ -1,377 +0,0 @@
-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();
-        },
-    };
-}