@agentshouse/mdruntime-adapter 0.1.0-cd028205a5103 → 0.1.0-cd0511bd2d033

package/dist/write.js

@@ -1,4 +1,5 @@
-import { parseOriginals } from './read.js';
+import { departure, partsChanges, ROW_WEIGHT, } from '@agentshouse/mdruntime';
+import { answered, answering, binaryFileOf, headChange, revised } from './read.js';
 import { sha256Hex, textBytes } from './digest.js';
 import { nativePath, roomLocalPath } from './map.js';
 import { classifyDoor, doorRefusal, scopedRefusal } from './refusal.js';
@@ -73,6 +74,25 @@ function operationOf(batch, change, handle) {
         const operation = created(change, path);
         return operation === null ? { rule: 'type-missing' } : { operation };
     }
+    if (change.kind === 'binary') {
+        const written = {
+            op: 'upload',
+            path,
+            local_id: change.localId,
+            bytes: change.byteLength,
+            sha256: change.sha256,
+            media_type: change.mediaType,
+        };
+        const from = departure(batch.changes, batch.changes.indexOf(change));
+        if (from === change.path && priorAbsence(batch, change.path) !== undefined)
+            return { operation: written };
+        const replaced = priorExistence(batch, from);
+        if (replaced === undefined)
+            return { rule: 'precondition-missing' };
+        if (!('base' in replaced))
+            return { rule: 'presence-base-unrepresentable' };
+        return { operation: { ...written, base: replaced.base } };
+    }
     const existence = priorExistence(batch, change.path);
     if (existence === undefined)
         return { rule: 'precondition-missing' };
@@ -100,16 +120,36 @@ export function houseChanges(batch, handle) {
     }
     return { kind: 'changes', changes };
 }
-export function operationHead(batch) {
+export function houseParts(saved, handle) {
+    return houseChanges({ id: '', baseRoomVersion: '', ...partsChanges(saved) }, handle);
+}
+export function houseMove(batch, source, destination) {
+    const changes = [];
+    for (const { path, to } of batch.between?.moves ?? []) {
+        const existence = priorExistence(batch, path);
+        if (existence === undefined)
+            return { kind: 'unmapped', path, rule: 'precondition-missing' };
+        if (!('base' in existence)) {
+            return { kind: 'unmapped', path, rule: 'presence-base-unrepresentable' };
+        }
+        changes.push({
+            op: 'rename',
+            path: nativePath(path, source),
+            to: nativePath(to, destination),
+            base: existence.base,
+        });
+    }
+    return { kind: 'changes', changes };
+}
+export function operationHead(batch, room) {
     const writer = batch.writtenBy;
-    return writer === undefined
-        ? { operation_id: batch.id }
-        : { operation_id: batch.id, app_ref: writer.app, release: writer.release };
+    const head = { operation_id: batch.id, room_ref: room };
+    return writer === undefined ? head : { ...head, app_ref: writer.app, release: writer.release };
 }
 export function batchPaths(changes) {
     return [
         ...new Set(changes.flatMap((change) => change.op === 'rename' ? [String(change.path), String(change.to)] : [String(change.path)])),
-    ].sort();
+    ];
 }
 export function deltaBody(changes) {
     return JSON.stringify({ changes });
@@ -124,20 +164,29 @@ export function uploadable(inline, bytes, bounds) {
 export function deltaDigest(delta) {
     return sha256Hex(delta);
 }
-function material(value, handle) {
+function* material(value, handle, within = () => true) {
     if (!Array.isArray(value))
         return null;
     const held = [];
     for (const entry of value) {
+        yield ROW_WEIGHT;
         if (typeof entry !== 'object' || entry === null)
             return null;
         const file = entry;
         if (typeof file.path !== 'string')
             return null;
+        if (!within(file.path))
+            continue;
         if (file.content !== null && typeof file.content !== 'string')
             return null;
         if (file.revision !== null && file.revision !== undefined && typeof file.revision !== 'string')
             return null;
+        const binary = binaryFileOf(file);
+        if (binary === null)
+            return null;
+        const head = headChange(file);
+        if (head === null)
+            return null;
         let path;
         try {
             path = roomLocalPath(file.path, handle);
@@ -149,29 +198,79 @@ function material(value, handle) {
             path,
             content: file.content,
             revision: typeof file.revision === 'string' ? file.revision : null,
+            ...(binary === undefined ? {} : { binary }),
+            ...(head === undefined ? {} : { head }),
         });
     }
     return held;
 }
-function affectedOf(held) {
+function* affectedOf(held) {
     const affected = {};
     for (const entry of held) {
         if (entry.content !== null)
             affected[entry.path] = entry.content;
+        yield ROW_WEIGHT;
     }
     return affected;
 }
-export function mutationOutcome(status, body, locator, handle) {
+function* acceptedOf(at, contents) {
+    const answer = answering();
+    for (const entry of contents) {
+        yield ROW_WEIGHT + (entry.content?.length ?? 0);
+        if (entry.revision === null) {
+            answer.removals.add(entry.path);
+            continue;
+        }
+        if (entry.content !== null)
+            answer.documents.set(entry.path, entry.content);
+        if (entry.binary !== undefined)
+            answer.binaryFiles.set(entry.path, entry.binary);
+        revised(answer, entry.path, entry.revision);
+        if (entry.head !== undefined)
+            answer.changes.set(entry.path, entry.head);
+    }
+    const unbinaried = answer.binaryFiles.size === 0;
+    const { binaryFiles, facts: _facts, ...room } = yield* answered(answer);
+    return { roomVersion: roomVersion(at), ...room, ...(unbinaried ? {} : { binaryFiles }) };
+}
+function* movedOutcome(held, move) {
+    const authorities = Array.isArray(held.authorities) ? held.authorities : [];
+    const at = (authority) => {
+        const entry = authorities.find((one) => typeof one === 'object' &&
+            one !== null &&
+            one.authority === authority);
+        return entry === undefined ? null : readPosition(entry);
+    };
+    const left = at(move.source.authority);
+    const arrived = at(move.destination.authority);
+    if (left === null || arrived === null)
+        return { kind: 'transport-uncertainty' };
+    const under = (handle) => (path) => path.startsWith(`/rooms/${handle}/`);
+    const leaving = yield* material(held.contents, move.source.handle, under(move.source.handle));
+    const arriving = yield* material(held.contents, move.destination.handle, under(move.destination.handle));
+    if (leaving === null || arriving === null)
+        return { kind: 'transport-uncertainty' };
+    return {
+        kind: 'accepted',
+        ...(yield* acceptedOf(left, leaving)),
+        destination: yield* acceptedOf(arrived, arriving),
+    };
+}
+export function* mutationOutcome(status, body, locator, handle, move) {
     const refusal = doorRefusal(body);
     if (refusal !== null && refusal.code === 'service_mode_write_halted') {
         return { kind: 'write-halted' };
     }
-    if (refusal !== null && refusal.code === 'expired')
-        return { kind: 'expired' };
     if (refusal !== null && refusal.code === 'edit_conflict') {
         const { current, ...fields } = refusal.fields;
-        const held = material(current, handle) ?? [];
-        return { kind: 'conflicted', affected: affectedOf(held), code: refusal.code, fields };
+        const held = (yield* material(current, handle)) ?? [];
+        return {
+            kind: 'conflicted',
+            affected: yield* affectedOf(held),
+            code: refusal.code,
+            fields,
+            retryable: refusal.retryable,
+        };
     }
     if (refusal !== null && status === 404) {
         return scopedRefusal(locator, 'undisclosed', refusal);
@@ -181,47 +280,41 @@ export function mutationOutcome(status, body, locator, handle) {
     if (refusal?.retryable === true &&
         typeof reset === 'string' &&
         classified?.kind === 'transport-uncertainty') {
-        return { kind: 'retryable-refusal', code: refusal.code, fields: refusal.fields, reset };
+        return {
+            kind: 'retryable-refusal',
+            code: refusal.code,
+            fields: refusal.fields,
+            retryable: true,
+            reset,
+        };
     }
     if (classified !== null && classified.kind !== 'scoped-refusal')
         return classified;
-    if (classified !== null && status === 403)
+    if (classified !== null && status === 403 && refusal?.code === 'operation_denied') {
         return classified;
+    }
     if (refusal !== null && status >= 400) {
-        return { kind: 'rejected', affected: {}, code: refusal.code, fields: refusal.fields };
+        return {
+            kind: 'rejected',
+            affected: {},
+            code: refusal.code,
+            fields: refusal.fields,
+            retryable: refusal.retryable,
+        };
     }
     if (status !== 200 || typeof body !== 'object' || body === null) {
         return { kind: 'transport-uncertainty' };
     }
     const held = body;
+    if (move !== undefined)
+        return yield* movedOutcome(held, move);
     const at = readPosition(held);
     if (at === null)
         return { kind: 'transport-uncertainty' };
-    const contents = material(held.contents, handle);
+    const contents = yield* material(held.contents, handle);
     if (contents === null)
         return { kind: 'transport-uncertainty' };
-    const originals = parseOriginals(held.originals);
-    if (originals === null)
-        return { kind: 'transport-uncertainty' };
-    const documents = {};
-    const revisions = {};
-    const removals = [];
-    for (const entry of contents) {
-        if (entry.content === null || entry.revision === null) {
-            removals.push(entry.path);
-            continue;
-        }
-        documents[entry.path] = entry.content;
-        revisions[entry.path] = entry.revision;
-    }
-    return {
-        kind: 'accepted',
-        roomVersion: roomVersion(at),
-        documents,
-        revisions,
-        removals: removals.sort(),
-        originals,
-    };
+    return { kind: 'accepted', ...(yield* acceptedOf(at, contents)) };
 }
 export function rejectedMapping(mapping) {
     return {
@@ -229,6 +322,7 @@ export function rejectedMapping(mapping) {
         affected: {},
         code: mapping.rule,
         fields: { path: mapping.path },
+        retryable: false,
     };
 }
 export function revisionBody(input) {
@@ -240,13 +334,26 @@ export function revisionBody(input) {
 }
 function revisionAuthor(entry) {
     const user = entry.author_user;
+    const userName = entry.author_user_name;
     const site = entry.author_site;
-    const name = entry.author_site_name;
-    if (typeof user === 'string' && site === undefined && name === undefined) {
-        return { kind: 'user', id: user };
+    const siteName = entry.author_site_name;
+    const inbox = entry.author_inbox;
+    const inboxName = entry.author_inbox_name;
+    const app = entry.author_app;
+    const appName = entry.author_app_name;
+    const named = [site, siteName, inbox, inboxName, app, appName].filter((held) => held !== undefined);
+    if (typeof user === 'string' && typeof userName === 'string' && named.length === 0)
+        return { kind: 'user', id: user, name: userName };
+    if (user !== null || userName !== undefined || named.length !== 2)
+        return null;
+    if (typeof site === 'string' && typeof siteName === 'string') {
+        return { kind: 'site', id: site, name: siteName };
+    }
+    if (typeof inbox === 'string' && typeof inboxName === 'string') {
+        return { kind: 'inbox', id: inbox, name: inboxName };
     }
-    if (user === null && typeof site === 'string' && typeof name === 'string') {
-        return { kind: 'site', id: site, name };
+    if (typeof app === 'string' && typeof appName === 'string') {
+        return { kind: 'app', id: app, name: appName };
     }
     return null;
 }
@@ -270,15 +377,8 @@ export function historyOutcome(status, body, locator, request) {
         const named = entries[0];
         if (named === undefined)
             return { kind: 'no-history' };
-        if (named.unavailable === true) {
-            return {
-                kind: 'scoped-refusal',
-                locator,
-                scope: 'content',
-                code: 'retained_history_unavailable',
-                fields: { path: request.path, revision: request.revision },
-            };
-        }
+        if (typeof named.media_type === 'string')
+            return { kind: 'no-history' };
         if (typeof named.content !== 'string')
             return { kind: 'transport-uncertainty' };
         return { kind: 'revision', content: named.content };
@@ -293,7 +393,15 @@ export function historyOutcome(status, body, locator, request) {
             typeof entry.created_at !== 'string') {
             return { kind: 'transport-uncertainty' };
         }
-        revisions.push({ revision: entry.revision, author, time: entry.created_at });
+        const binaryFile = binaryFileOf(entry);
+        if (binaryFile === null)
+            return { kind: 'transport-uncertainty' };
+        revisions.push({
+            revision: entry.revision,
+            author,
+            time: entry.created_at,
+            ...(binaryFile === undefined ? {} : { binaryFile }),
+        });
     }
     const next = held.next_before;
     return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentshouse/mdruntime-adapter",
-  "version": "0.1.0-cd028205a5103",
+  "version": "0.1.0-cd0511bd2d033",
   "description": "Agents House Adapter for the MD Runtime",
   "license": "MIT",
   "type": "module",
@@ -9,23 +9,26 @@
     "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"
     },
     "./package.json": "./package.json"
   },
   "files": [
     "dist",
-    "AGENTS.md",
     "README.md",
     "LICENSE"
   ],
   "dependencies": {
-    "@agentshouse/mdmodel": "0.1.0-c3d58cb8652e6",
-    "@agentshouse/mdruntime": "0.1.0-ca1eff92bbe73"
+    "@agentshouse/mdruntime": "0.1.0-cac707d698ca2"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/agentshouse/core.git",
+    "directory": "mdruntime/packages/mdruntime-adapter"
   }
 }

package/AGENTS.md

@@ -1,244 +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,
-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.
-
-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 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. 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,
-`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. `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/gather.d.ts

@@ -1,3 +0,0 @@
-export declare function gathered<A, R>(send: (asks: readonly A[]) => Promise<readonly R[]>): (ask: A) => Promise<R>;
-export declare function selections<T>(items: readonly T[], weight: (item: T) => number, limit: number): readonly (readonly T[])[];
-//# sourceMappingURL=gather.d.ts.map

package/dist/gather.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"gather.d.ts","sourceRoot":"","sources":["../src/gather.ts"],"names":[],"mappings":"AAMA,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAC3B,IAAI,EAAE,CAAC,IAAI,EAAE,SAAS,CAAC,EAAE,KAAK,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC,GAClD,CAAC,GAAG,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CA0BxB;AAED,wBAAgB,UAAU,CAAC,CAAC,EAC1B,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,EAC3B,KAAK,EAAE,MAAM,GACZ,SAAS,CAAC,SAAS,CAAC,EAAE,CAAC,EAAE,CAgB3B"}

package/dist/gather.js

@@ -1,40 +0,0 @@
-export function gathered(send) {
-    let held = [];
-    function flush() {
-        const taken = held;
-        held = [];
-        send(taken.map((entry) => entry.ask)).then((answers) => {
-            taken.forEach((entry, index) => {
-                entry.resolve(answers[index]);
-            });
-        }, (reason) => {
-            for (const entry of taken)
-                entry.reject(reason);
-        });
-    }
-    return (ask) => new Promise((resolve, reject) => {
-        if (held.length === 0) {
-            // Asks made in one task wait a single event-loop turn so they leave as one batch.
-            setTimeout(flush, 0);
-        }
-        held.push({ ask, resolve, reject });
-    });
-}
-export function selections(items, weight, limit) {
-    const parts = [];
-    let part = [];
-    let carried = 0;
-    for (const item of items) {
-        const weighed = weight(item);
-        if (part.length > 0 && carried + weighed > limit) {
-            parts.push(part);
-            part = [];
-            carried = 0;
-        }
-        part.push(item);
-        carried += weighed;
-    }
-    if (part.length > 0)
-        parts.push(part);
-    return parts;
-}