@agentshouse/mdruntime 0.1.0-cf6d5f0a5c9c8 → 0.1.0-cf6e25bcd52f6

package/dist/wire.js

@@ -1,35 +1,48 @@
+import { UNCERTAIN } from './outcome.js';
 const MEMBERS = {
-    rooms: 'within',
-    query: 'within',
-    search: 'within',
-    types: 'within',
-    save: 'within',
-    history: 'within',
-    call: 'actions',
-    reached: 'within',
-    log: 'whole',
-    persistence: 'runtime',
-    reauthorize: 'runtime',
-    'roomDraft.list': 'within',
-    'roomDraft.read': 'within',
-    'roomDraft.write': 'within',
-    'roomDraft.discard': 'within',
-    'presentation.read': 'app',
-    'presentation.write': 'app',
-    'conversation.list': 'within',
-    'conversation.read': 'within',
-    'conversation.create': 'within',
-    'conversation.send': 'within',
-    'conversation.answer': 'within',
-    'conversation.interrupt': 'within',
-    'conversation.kill': 'within',
-    'conversation.cancel': 'within',
-    'conversation.delete': 'within',
-    'chatDraft.write': 'within',
-    'chatDraft.discard': 'within',
+    rooms: { reach: 'within', effect: 'read' },
+    query: { reach: 'within', effect: 'read' },
+    search: { reach: 'within', effect: 'read' },
+    types: { reach: 'within', effect: 'read' },
+    save: { reach: 'within', effect: 'write' },
+    saveParts: { reach: 'within', effect: 'write' },
+    history: { reach: 'within', effect: 'read' },
+    resolve: { reach: 'within', effect: 'read' },
+    'binaryFile.read': { reach: 'within', effect: 'read' },
+    'binaryFile.link': { reach: 'within', effect: 'read' },
+    'binaryFile.show': { reach: 'within', effect: 'read' },
+    'binaryFile.attach': { reach: 'within', effect: 'action' },
+    'binaryFile.part': { reach: 'within', effect: 'read' },
+    call: { reach: 'actions', effect: 'action' },
+    reached: { reach: 'within', effect: 'read' },
+    log: { reach: 'whole', effect: 'read' },
+    cleanUp: { reach: 'whole', effect: 'write' },
+    persistence: { reach: 'runtime', effect: 'read' },
+    retry: { reach: 'runtime', effect: 'write' },
+    reauthorize: { reach: 'runtime', effect: 'write' },
+    'roomDraft.list': { reach: 'within', effect: 'read' },
+    'roomDraft.read': { reach: 'within', effect: 'read' },
+    'roomDraft.write': { reach: 'within', effect: 'write' },
+    'roomDraft.discard': { reach: 'within', effect: 'write' },
+    'presentation.read': { reach: 'app', effect: 'read' },
+    'presentation.write': { reach: 'app', effect: 'write' },
+    'presentation.edit': { reach: 'app', effect: 'write' },
+    'conversation.list': { reach: 'within', effect: 'read' },
+    'conversation.read': { reach: 'within', effect: 'read' },
+    'conversation.create': { reach: 'within', effect: 'action' },
+    'conversation.send': { reach: 'within', effect: 'action' },
+    'conversation.answer': { reach: 'within', effect: 'action' },
+    'conversation.interrupt': { reach: 'within', effect: 'action' },
+    'conversation.kill': { reach: 'within', effect: 'action' },
+    'conversation.cancel': { reach: 'within', effect: 'action' },
+    'conversation.delete': { reach: 'within', effect: 'action' },
+    'chatDraft.write': { reach: 'within', effect: 'write' },
+    'chatDraft.prepend': { reach: 'within', effect: 'write' },
+    'chatDraft.discard': { reach: 'within', effect: 'write' },
 };
 const TOPICS = {
     rooms: 'within',
+    readiness: 'within',
     'connection-refusal': 'runtime',
     'storage-loss': 'runtime',
     'deployment-facts': 'runtime',
@@ -42,8 +55,23 @@ const TOPICS = {
     presentation: 'app',
     conversation: 'within',
     conversations: 'within',
+    agents: 'within',
 };
-export const WIRE_REACH = { members: MEMBERS, topics: TOPICS };
+export const WIRE = { members: MEMBERS, topics: TOPICS };
+export function unanswered(call) {
+    const { effect } = MEMBERS[call.member];
+    if (effect === 'read')
+        return null;
+    if (effect === 'action')
+        return { kind: 'result', id: call.id, value: UNCERTAIN };
+    return {
+        kind: 'failure',
+        id: call.id,
+        message: UNCERTAIN.code,
+        code: UNCERTAIN.code,
+        retryable: UNCERTAIN.retryable,
+    };
+}
 export const AUTHORIZATION_ENDED = 'the host authorization ended';
 export const PORT_CLOSED = 'the port closed';
 function body(message) {
@@ -103,8 +131,17 @@ export function answer(message) {
         return { kind: 'result', id: shape.id, value: record.value };
     if (shape.kind === 'event')
         return { kind: 'event', id: shape.id, value: record.value };
-    if (shape.kind === 'failure' && typeof record.message === 'string') {
-        return { kind: 'failure', id: shape.id, message: record.message };
+    if (shape.kind === 'failure' &&
+        typeof record.message === 'string' &&
+        typeof record.code === 'string' &&
+        typeof record.retryable === 'boolean') {
+        return {
+            kind: 'failure',
+            id: shape.id,
+            message: record.message,
+            code: record.code,
+            retryable: record.retryable,
+        };
     }
     return null;
 }

package/dist/words.d.ts

@@ -0,0 +1,19 @@
+export type Clause = {
+    readonly text: string;
+    readonly kind: 'term' | 'stem' | 'prefix' | 'phrase';
+    readonly term: string;
+};
+export type Located = {
+    readonly start: number;
+    readonly end: number;
+};
+export declare function indexed(text: string): string;
+export declare function matchClauses(text: string): Clause[] | null;
+export declare function matchExpression(clauses: readonly Clause[]): string;
+export declare function queryTerms(text: string): string[];
+export declare function snippet(part: string, terms: readonly string[], reach: number): {
+    readonly text: string;
+    readonly at: readonly [number, number];
+} | null;
+export declare function matched(part: string, terms: readonly string[]): string[];
+//# sourceMappingURL=words.d.ts.map

package/dist/words.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"words.d.ts","sourceRoot":"","sources":["../src/words.ts"],"names":[],"mappings":"AA0BA,MAAM,MAAM,MAAM,GAAG;IACnB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,QAAQ,GAAG,QAAQ,CAAC;IACrD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,OAAO,GAAG;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC;AAYvE,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAO5C;AAgBD,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,IAAI,CAiB1D;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAElE;AAMD,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAEjD;AAyDD,wBAAgB,OAAO,CACrB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,KAAK,EAAE,MAAM,GACZ;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,GAAG,IAAI,CAW1E;AAED,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAQxE"}

package/dist/words.js

@@ -0,0 +1,156 @@
+const SPACELESS = /(?:[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Thai}\p{Script=Lao}\p{Script=Khmer}\p{Script=Myanmar}\p{Script=Hangul}]\p{M}*)+/gu;
+const SPACELESS_TERM = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Thai}\p{Script=Lao}\p{Script=Khmer}\p{Script=Myanmar}\p{Script=Hangul}]/u;
+const TOKEN = /(?![\x00-\x7f])\p{S}\p{M}*|[\p{L}\p{N}\p{M}\p{Co}]+/gu;
+const SYMBOL = /(?![\x00-\x7f])\p{S}\p{M}*/gu;
+const MARKED = /([\p{Script=Latin}\p{Script=Greek}\p{Script=Cyrillic}])\p{M}+/gu;
+const INFLECTED = /^[\p{Script=Cyrillic}\p{Script=Greek}]+$/u;
+const FOLD = /\p{M}+/gu;
+const ASCII = /^[\x00-\x7f]$/;
+const PREFIXED_LETTERS = 2;
+const INFLECTED_LETTERS = 4;
+const PHRASE_TERMS = { least: 2, most: 6 };
+const GRAPHEMES = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+function bigrams(run) {
+    const characters = Array.from(run);
+    if (characters.length < 2)
+        return ` ${run} `;
+    const pairs = [];
+    for (let index = 0; index + 1 < characters.length; index += 1) {
+        pairs.push(characters[index] + characters[index + 1]);
+    }
+    return ` ${pairs.join(' ')} `;
+}
+export function indexed(text) {
+    return text
+        .normalize('NFKD')
+        .replace(MARKED, '$1')
+        .normalize('NFKC')
+        .replace(SPACELESS, bigrams)
+        .replace(SYMBOL, (symbol) => ` ${symbol.replace(FOLD, '')} `);
+}
+function tokens(text) {
+    return [...text.matchAll(TOKEN)].map(([token]) => token.toLowerCase());
+}
+function quoted(token) {
+    return `"${token.replaceAll('"', '""')}"`;
+}
+function truncated(term) {
+    const letters = Array.from(term);
+    if (!INFLECTED.test(term) || letters.length < INFLECTED_LETTERS)
+        return null;
+    return letters.slice(0, letters.length - (letters.length >= 6 ? 2 : 1)).join('');
+}
+export function matchClauses(text) {
+    const terms = tokens(indexed(text));
+    if (terms.length === 0)
+        return null;
+    const unique = [...new Set(terms)];
+    const clauses = unique.map((term) => ({ text: quoted(term), kind: 'term', term }));
+    for (const term of unique) {
+        const stem = truncated(term);
+        if (stem !== null)
+            clauses.push({ text: `${quoted(stem)}*`, kind: 'stem', term });
+    }
+    const last = terms[terms.length - 1];
+    if (!/\s$/u.test(text) && Array.from(last).length >= PREFIXED_LETTERS) {
+        clauses.push({ text: `${quoted(last)}*`, kind: 'prefix', term: last });
+    }
+    if (terms.length >= PHRASE_TERMS.least && terms.length <= PHRASE_TERMS.most) {
+        clauses.push({ text: quoted(terms.join(' ')), kind: 'phrase', term: terms.join(' ') });
+    }
+    return clauses;
+}
+export function matchExpression(clauses) {
+    return clauses.map(({ text }) => text).join(' OR ');
+}
+function folded(text) {
+    return text.normalize('NFKD').replace(FOLD, '').toLowerCase();
+}
+export function queryTerms(text) {
+    return [...new Set(tokens(text.normalize('NFKC')).map(folded))];
+}
+function agrees(token, term) {
+    if (SPACELESS_TERM.test(term))
+        return token.includes(term);
+    if (token.startsWith(term))
+        return true;
+    return token.length >= 3 && term.startsWith(token.slice(0, Math.max(3, token.length - 2)));
+}
+function inside(token, offset, term) {
+    const pieces = [...GRAPHEMES.segment(token)];
+    const owner = [];
+    let joined = '';
+    for (const [at, { segment }] of pieces.entries()) {
+        const part = folded(segment);
+        joined += part;
+        for (let index = 0; index < part.length; index += 1)
+            owner.push(at);
+    }
+    const found = joined.indexOf(term);
+    if (found < 0)
+        return null;
+    const first = pieces[owner[found]];
+    const last = pieces[owner[found + term.length - 1]];
+    return { start: offset + first.index, end: offset + last.index + last.segment.length };
+}
+function locate(part, terms) {
+    for (const match of part.matchAll(TOKEN)) {
+        const token = folded(match[0]);
+        for (const term of terms) {
+            if (!agrees(token, term))
+                continue;
+            if (!SPACELESS_TERM.test(term)) {
+                return { start: match.index, end: match.index + match[0].length };
+            }
+            const found = inside(match[0], match.index, term);
+            if (found !== null)
+                return found;
+        }
+    }
+    return null;
+}
+function settled(part, index) {
+    if (index <= 0 || index >= part.length)
+        return true;
+    const before = part[index - 1];
+    const after = part[index];
+    if (before === '\n')
+        return true;
+    return ASCII.test(before) && ASCII.test(after) && !(before === '\r' && after === '\n');
+}
+function edgesAround(part, low, high) {
+    let from = Math.max(0, low);
+    while (!settled(part, from))
+        from -= 1;
+    let to = Math.min(part.length, high);
+    while (!settled(part, to))
+        to += 1;
+    const edges = [...GRAPHEMES.segment(part.slice(from, to))].map(({ index }) => from + index);
+    edges.push(to);
+    return edges;
+}
+export function snippet(part, terms, reach) {
+    const located = locate(part, terms);
+    if (located === null)
+        return null;
+    const edges = edgesAround(part, located.start - 2 * reach, located.end + 2 * reach);
+    const last = (limit) => edges.filter((edge) => edge <= limit).at(-1) ?? edges[0];
+    const first = (limit) => edges.find((edge) => edge >= limit) ?? edges[edges.length - 1];
+    const from = last(located.start);
+    const to = Math.max(first(Math.min(located.end, from + reach)), first(from + 1));
+    const start = first(Math.max(0, from - reach));
+    const end = last(Math.min(part.length, to + reach));
+    return { text: part.slice(start, end), at: [from - start, to - start] };
+}
+export function matched(part, terms) {
+    const found = new Set();
+    for (const match of part.matchAll(TOKEN)) {
+        const token = folded(match[0]);
+        for (const term of terms)
+            if (agrees(token, term))
+                found.add(term);
+        if (found.size === terms.length)
+            break;
+    }
+    return [...found];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentshouse/mdruntime",
-  "version": "0.1.0-cf6d5f0a5c9c8",
+  "version": "0.1.0-cf6e25bcd52f6",
   "description": "The headless core of MD App",
   "license": "MIT",
   "type": "module",
@@ -9,48 +9,59 @@
     "access": "public"
   },
   "engines": {
-    "node": ">=24.21.0"
+    "node": ">=24.22.1"
   },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "default": "./dist/index.js"
     },
     "./host": {
       "types": "./dist/host.d.ts",
-      "import": "./dist/host.js"
+      "default": "./dist/host.js"
     },
     "./client": {
       "types": "./dist/client.d.ts",
-      "import": "./dist/client.js"
+      "default": "./dist/client.js"
+    },
+    "./entry": {
+      "types": "./dist/entry.d.ts",
+      "default": "./dist/entry.js"
     },
     "./memory": {
       "types": "./dist/memory.d.ts",
-      "import": "./dist/memory.js"
+      "default": "./dist/memory.js"
+    },
+    "./tables": {
+      "types": "./dist/tables.d.ts",
+      "default": "./dist/tables.js"
     },
     "./react": {
       "types": "./dist/react.d.ts",
-      "import": "./dist/react.js"
+      "default": "./dist/react.js"
+    },
+    "./digest": {
+      "types": "./dist/digest.d.ts",
+      "default": "./dist/digest.js"
     },
     "./package.json": "./package.json"
   },
   "files": [
     "dist",
-    "AGENTS.md",
+    "!dist/chat.*",
+    "!dist/chat/",
     "README.md",
     "LICENSE"
   ],
   "dependencies": {
-    "@agentshouse/mdmodel": "0.1.0-c64dbada0730d",
-    "@tanstack/db": "0.9.2",
-    "minisearch": "7.2.0"
+    "@agentshouse/mdmodel": "0.1.0-c9952fa046c11"
   },
   "peerDependencies": {
     "react": ">=18"
   },
-  "peerDependenciesMeta": {
-    "react": {
-      "optional": true
-    }
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/agentshouse/core.git",
+    "directory": "mdruntime/packages/mdruntime"
   }
 }

package/AGENTS.md

@@ -1,253 +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, the deployment facts and the signed-in member 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,
-Rooms lists only the Rooms reached whole, a Room reached for single Documents
-shows only those Documents and the Types of the models that govern them, 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 }`.
-History of a Path no current document holds answers the removed document's
-revisions with `deleted: true`, newest first; that revision is what a link to
-the Path opens. 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.
-
-`observe('member')` answers who uses the App: the User the Provider signed in,
-`{ kind: 'user', id, name }` in the shape of a change's `author`, so a Document
-whose `change.author.id` equals its `id` is that User's own. It is `null` until
-the Provider first names one, and where it names none, such as a Site. The
-MD Runtime keeps it with the Local Replicas, so it answers offline once known,
-and every port hears the next member the Provider names; signing out answers
-`null`, then ends the observation with the authorization. It is the only way App code learns who
-uses it.
-
-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.** Every frontmatter value is named by JSON Pointer: `/status`,
-  `/shipping/city`, `~1` for a `/` and `~0` for a `~` in a key. A segment that
-  meets a list applies to every item and a number names one item. `where` names
-  pointers, ANDs them, and nests `$and` and `$or`; a pointer through a list holds
-  when any item satisfies it. 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, and a value under `oneOf` or a conditional, is plain
-  values. There is no text containment or regular
-  expression.
-- **Relations.** `hop: { field, types, where, pathPrefix }` keeps Documents whose
-  reference at pointer `field`, at any depth, 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` is `'all'` or a
-  list of pointers and `sections` `'all'` or a list of names. Selected pointers
-  return the frontmatter holding only them, nested as written. A backlink names
-  the referring Path, MD Type and the pointer it came from as `field`. 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. 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. A sort or group takes only a
-  pointer that holds one value. `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,
-`houseBridge().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 `{ state: 'loading' }` until the topic's
-first value arrives, then `{ state: 'ready', value }`, re-rendering on each
-change; a `null` client observes nothing and stays loading. `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. `saveRoomDrafts(client, room,
-roomDrafts)` is that save outside a component. A react-admin or Refine App
-reads and writes its Rooms through the data providers of
-`@agentshouse/mdruntime-families`.
-
-## 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);
-}