@agentshouse/mdruntime 0.1.0-c2e8a6f99866d → 0.1.0-c2ef9303a058d

package/AGENTS.md

@@ -1,312 +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, Resolve, the binary file reads, Call,
-Reached, Log, the reported persistence answer, reauthorization, conversation, the chat
-draft, and Presentation State. Sync Status, readiness, 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 them and their
-models' Types, and without conversations the conversation members, chat draft and
-observation hold none. A changed reach reaches every open observation as its new value.
-
-Every `observe` resolves, once its first value arrived, to a handle: `current()` is the
-latest complete value, `subscribe(listener)` hears each later value whole and returns its
-unsubscribe, and `close()` ends it. Closing the port ends every handle and rejects every
-pending call and observation; a reconnected client observes again.
-
-`observe('agents')` answers every Agent a new conversation can go to, each `{ identity,
-name }`, with a conversation yet or not. Each conversation the Provider lists 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,
-live `state` (`asking` while a question waits, `working` while a turn runs, else `idle`)
-and `started`, when the running turn began, or `null`. `observe('conversation', id, {
-limit, total: true })` holds its latest `limit` messages, at most 1,000, oldest first,
-`total` their count, and `next` while older ones exist, which `after` takes, there or in
-`conversation.read(id, { limit, after })`, for the window before; its chat draft; and,
-only in memory, what the Provider streams whether or not anything views it: the running
-`turn` with its parts and its context in use and window, which the message accepted under
-the turn's id replaces, the open questions, the process state, and the CLI's commands and
-options, none stored or searchable. `chatDraft.write` and `chatDraft.discard` keep what
-the App Creator composes, and `chatDraft.prepend(conversation, draft)` puts a returned
-message ahead of it as it stands. Sending it is a Provider Action that needs the Provider
-reachable and is never queued. A new conversation's chat draft is keyed `new:<Agent
-identity>`: no conversation list removes it, a retired Agent's goes, and the first answer
-to `conversation.create({ agent_id, operation_id })` moves it to the created conversation,
-where `conversation.send(conversation)` sends it; a replay of that create moves nothing.
-
-Presentation State is one value per App, kept in the browser and shared by its tabs:
-`presentation.read()` answers it, `null` before anything is kept,
-`observe('presentation')` hears it whole, `presentation.write(value)` replaces it whole,
-and `presentation.edit(members)` sets each member named, or removes one named `null`, in
-the state as it stands, so tabs changing different members never lose each other's change:
-never write back a value read before. Each rejects when the browser does not keep the
-change, and no tab sees it then.
-
-A binary file at a Path is a binary Path entry. Query lists it by `path`, and History each
-of its revisions, with its `binaryFile` record and never its bytes: `{ state: 'accepted',
-revision, path, fileRef, byteLength, mediaType, sha256 }`, or, from a Save until the
-Provider accepts it, `{ state: 'pending', localId, path, byteLength, mediaType, sha256 }`.
-Write one with a Room Draft whose only part is `file: { blob }`, the `Blob`'s `type` its
-media type: Save keeps the bytes in its Pending Change, offline too, and acceptance gives
-the record the Provider's revision. Move or remove one as a Document, a pending one too,
-its bytes following; once its Pending Change has gone to the Provider, Save refuses that
-as `unknown-revision` until it is accepted. `binaryFile.read(room, path, revision?)`
-answers a pending record's saved bytes, or an accepted one's or a History revision's, a
-removed file's last included: the first read asks the Provider and the browser keeps the
-bytes, and every later read of that revision, offline too, answers them from the browser.
-Text, a Record attachment or a conversation message may name a file by its `fileRef`; read
-it with `binaryFile.readReference({ fileRef, referrer })`, the `referrer` the Provider gave
-beside it, or `{ room, path }` of the document whose text names it, kept the same way. Both
-answer `{ kind: 'binary', stream, byteLength, mediaType }`, the bytes a `ReadableStream`
-of parts of at most a mebibyte, or a refusal or failure; read the stream to its end, or
-take it whole with `new Response(stream).blob()` where a screen needs one `Blob`.
-
-Rooms, Query, Search, Observe, Types, Room Draft, Save, and Reached never touch the
-network; History, a binary file read the browser does not keep yet and Call go to the
-Provider through the Adapter.
-Call takes the Action names the Adapter declares, any other answering `undeclared`. 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, refreshing the Room until it has, and `reached(room, roomVersion, path)`
-whether the held copy of that document was written later. A History revision names its
-author, `{ kind: 'user', id }` or `{ kind: 'site' | 'inbox', id, name }`; History of a Path no
-document holds answers the removed document's revisions, newest first, with `deleted:
-true`, which a link to the Path opens. Every member is asynchronous and every result a
-detached snapshot; nothing returns the authorization, performs a request the App's code
-composes, or exposes the browser store. A Room `rooms` names `locked` shows only online.
-
-Every refusal and failure carries `code` and `retryable`: each Call and History answer
-other than its result, a refused Save or Room Draft write, a returned Room Draft's reason,
-a Room's refusal, the Connection Refusal and every error a member rejects with, beside its
-message, a Provider refusal with the Provider's own `retryable`. Every code and value is
-open: handle one you do not know by its `code` and `retryable`. Only a tag telling which
-fields a value carries, such as `kind`, is closed: keep a branch for one you do not know.
-A model with no usable types answers `types: null`.
-
-Read the deployment facts with `observe('deployment-facts')`, an opaque value the host's
-contract interprets. `observe('member')` answers who uses the App, the only way App code
-learns it: the User the Provider signed in, `{ kind: 'user', id, name }` like a change's
-`author`, so a Document whose `change.author.id` is its `id` is that User's own; `null`
-until the Provider first names one, and where it names none, such as a Site. It is kept
-with the Local Replicas, answers offline once known, and every port hears the next member
-named; signing out answers `null`, then ends the observation with the authorization.
-
-## 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. `{ documents, coverage }` or `{ groups,
-coverage }` is complete for the Rooms its `coverage` names, and `{ pending }` names each
-Room not yet acquired, prepared or unlocked, `[{ room, awaits }]`: never read it as empty,
-draw it as loading and observe the query to hear the complete answer. 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`; `folder` keeps only what lies directly in it.
-  `paths` keeps only the Paths it names: read named Documents so, never from a list.
-- **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 if 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 if 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.** Within one Room, `hop: { field, types, where, pathPrefix }` keeps Documents
-  whose reference at pointer `field`, at any depth, points to a matching Document, and
-  `backlinks` with the same keys those a matching Document references, each once. A body
-  link, or a reference declaring `cross_room`, may name another Room's
-  `/rooms/<handle>/<path>`: `resolve(room, path, destination)` answers its `document`, the
-  `deleted` one's last `revision`, or `unreadable` where the App does not bind it or it is
-  locked.
-- **Parts.** A Document query must `select`: `'all'`, or `fields`, `sections`,
-  `preamble`, `markdown`, `backlinks`, `change` and `fileId`, 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, and at most its first 1,000
-  backlinks: a query on the referring field reads the rest. A non-Markdown Document
-  returns only Room, Path and a selected `fileId`, and a binary Path entry its
-  `binaryFile` record too; a YAML file under `settings/` also returns its text as a
-  selected `markdown`, kept out of Search. An unselected part is absent. Select only what a screen shows:
-  a list that selects the Markdown hears every edit of it.
-- **Change and file ID.** `change` is `{ author, time }` of the Document's head revision
-  as the Provider last delivered it: `author` is `{ kind: 'user' | 'site' | 'inbox', id, name }`, or
-  `null` for a write the Provider made itself, and `time` its ISO 8601 change time, or the
-  whole change `null` where it delivered no time, as at a Site. `fileId` is the Provider's
-  Stable File ID of the file at the Path, or `null`. An unsent edit keeps both, an unsent
-  move keeps the change and carries the file ID to the new Path, so a file ID that leaves
-  one Path for another is the same file moved, and an unsent creation has neither until it
-  is Accepted. A Room's last change is its Document with the latest `time`.
-- **Order and groups.** `orderBy` sorts by `room`, `path`, `type`, `folder` or `{ field }`: missing
-  and null first, last with `nulls: 'last'`, then numbers and booleans, then text by `locale` or
-  code point with `stringSort: 'lexical'`, then lists item by item; ties end with Room, then Path.
-  `groupBy` by `room`, `type`, `folder` or `{ field }` answers `{ groups: [{ key, count }] }`,
-  counted over every match and ordered by `count` or a key. A sort or group takes only a
-  single-value pointer. `limit`, at most 1,000 whatever a query names, bounds the Documents or the
-  groups, and a result it cuts short names `next`: the same query with it as `after` reads the next
-  window, in the same order, ties included. `total: true` adds `total`, every match's count. An
-  observed window hears rows entering, leaving or changing, and `next`, `total`.
-- **Results and errors.** A result carries no Room Version: read freshness from Rooms and
-  Sync Status. `coverage` names each Room read as `{ room, generation, current }`,
-  `current` false while a newer copy of that Room is being fetched, and the queued changes
-  it includes as `overlay`, which a Save in the Room changes. An invalid query fails with
-  `invalid-query`, `unknown-type`, `unknown-field` or `wrong-kind`, never an empty answer.
-
-## Local Search rules
-
-`search({ text, documents, collection, conversations, limit, after, total })` answers
-once, by words, from local state, with MiniSearch's defaults. There is no observed search.
-
-- **Declaration.** Only an App whose release declares Local Search searches, its first
-  readiness waiting for its index; any other App's `search` answers the never retryable
-  `undeclared` refusal `search-undeclared`, its `fields` naming `local_search`.
-- **What is found.** A Document by its field values, its sections' headings and text, its
-  preamble and its Path, and a message by its text, never a frontmatter key, a Room Draft,
-  a chat draft or a running turn's parts, with no phrases, word forms, typo tolerance or
-  prefix matching.
-- **Narrowing.** `documents` is a Local Query filter, and `collection: true` leaves out
-  what each Room's `typedSelection` roots hold; `conversations` names conversations. All
-  apply before `limit`, which bounds each list, at most 1,000 whatever a search names. A
-  complete answer it cuts short names `next`, which `after` takes for the next window of
-  both lists. `total: true` adds `total`, each list's count.
-- **Results.** `{ documents, messages, coverage }`, or the same with `pending` naming each
-  Room or conversation the search still waits for: show its hits, ask again, and never
-  read pending as no hits. `coverage` names the Rooms and conversations searched. Each
-  list is ranked by `score`, comparable only within it; ties come by `room`, then `path`,
-  or by `conversation`, then `identity`. A Document hit names its `room`, `path` and
-  `type`, a message hit its `conversation` and `identity`; `matches` maps each matched
-  word to the parts it matched in: `fields`, `sections`, `preamble`, `path` or `text`. A
-  hit carries no position: mark the words you show. A bad filter fails as a query does.
-
-## Room Draft, Save, and outcome rules
-
-The MD Runtime owns one durable Room Draft per Room and Path, shared by every App and tab
-across reloads; a Room the Provider reports lost takes its Room Drafts and queue with it.
-Write one with `roomDraft.write(room, path, revision, parts)`, naming the revision you read
-or `null`, and every part it now changes: fields, sections and the preamble, or the whole
-Markdown, a creation, a move, into another Room when it names `room`, or a removal. A new
-part names its base, the value you showed when it was opened, a field's as `{ value }` or
-`null` for no such field, and keeps its first base; a binary Path entry's move or removal
-takes `null`. A write or discard from an older revision is refused as `stale` with the
-current Room Draft.
-
-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. Refused as `stale`, `changed-underneath` naming each part whose base no longer
-matches the visible state, or a local validation rule, it creates nothing and leaves every
-Room Draft. A directory move or removal is that part on each Document and binary Path entry
-beneath it, saved together; moves into another Room, saved alone, are one Change Batch in
-both Rooms' queues. `saveParts(room, [{ path, parts }])` saves parts, each Path once and
-each new part with its base, the same way but writes no Room Draft: one held at a saved Path
-stays, one at a moved Path moves with it to a destination that holds none. Never save by
-writing back a Room Draft read before.
-
-Outcomes follow the Provider's answer. An Accepted Change Batch stays in the queue, drawn
-over the confirmed layer, until that layer reaches the Room Version it was accepted at.
-Conflicted and Rejected, an expired operation, and a change that no longer applies each
-leave the queue and return as Room Drafts on their Documents, 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 or discarded. `observe('queue', room)`
-shows each Pending Change Batch, which keeps no outcome once it leaves. Transport failure,
-Provider unavailability and a refusal marked retryable, until the reset it names, keep
-work Pending; the MD Runtime retries the same Change Batch identity and payload, never
-infers an outcome from transport uncertainty, and never combines, reorders, or rebases.
-
-On a Site, every Save stays in the visitor's browser: write grants and revisions do not
-refuse it, and its Pending Change shows in every query and across reloads until the
-browser's storage is cleared. It is never sent: `observe('queue', room)` shows it `local`,
-Sync Status never waits on it, and once the Room no longer lets it apply it leaves the
-queue and returns no Room Draft.
-
-`observe('service-mode')` answers the Provider's Service Mode, `open` or `write-halted`.
-While writes are halted, Save succeeds, its Change Batch waits unsent and the queue is
-submitted in order once writes reopen; an Action is never held, and one the halt refuses
-returns that refusal: show the Provider as read-only instead of retrying.
-`observe('readiness')` tells whether the App's code and bound Rooms are held locally
-(`ready`), each Room's state, each refused Room's file and rule, the persistence answer
-and a paused preparation's `capacity` cause; `retry()` resumes a paused preparation.
-
-## Content safety and launch promises
-
-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. 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. An agent must
-never read the authorization, load code from a Room, call the Provider directly, or rebase
-a refused Change Batch.
-
-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, defaulting to the
-browser's preference and respecting an App's override. What an agent adds carries none of
-these promises by itself. Data lives only in the App Creator's browser and the Provider.
-
-## App code takes the client its host hands it and never constructs a Runtime
-
-No module outside an Adapter package imports, names, or special-cases a Provider, and
-every App and MD UI reach data only through the client entry. In House,
-`houseBridge().runtime` from `@agentshouse/app-bridge` resolves to the client House built
-into the page. App code imports only types from `@agentshouse/mdruntime/client`, never
-calls `connectMdRuntime` or `serveMdRuntime`, and never imports the package main, the host
-entry or the Adapter package; the in-memory Adapter at `@agentshouse/mdruntime/memory` is
-for tests and ships in no bundle. A Site's page fills its Entry Data Contract's
-`{"$param": name}` arguments with `boundQuery` from `@agentshouse/mdruntime/entry`, as
-House did for its HTML. While the Site prepares, a query a route's `interaction` names
-answers from the entry's result when the page observes that descriptor, and every other
-stays pending. House replaces its HTML with the page once its document changed after those
-answers, or readiness is `ready`, and then held still for two animation frames, unless the
-visitor uses the HTML: draw the route at once, never behind a placeholder. Before
-readiness is `ready`, `push` loads a new page.
-
-A React App may observe and save through `@agentshouse/mdruntime/react`, with 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 stays loading.
-`useSave(client)` returns `busy`, the last `outcome` or `failure`, and `save(room,
-parts)`, which saves through `saveParts` and rejects with a recorded failure.
-`saveWritten(room, roomDrafts)` saves Room Drafts the App wrote, each named with the
-revision its last write returned: one another tab wrote since is refused as `stale`, and
-nothing is saved. React-admin and Refine Apps use `@agentshouse/mdruntime-families`.
-
-## The Chat
-
-`@agentshouse/mdruntime/chat` holds the Chat, one data layer for every App; add React as a
-dependency in any App, with React DOM and `@assistant-ui/react`. Place the ready chat with
-`<Chat client={runtime} conversation={id} agent={agent} width="1/3" showChats />`:
-`conversation` opens one, `null` for a new chat, `agent` is the Agent a new chat goes to,
-`onOpen` hears each one it opens, and `width` is `full` (the place you give it), or `3/4`,
-`1/2` or `1/3` of the window docked at its right edge, whole on a narrow window.
-`showChats` adds its conversation list; or draw your own inside a `ChatProvider` around a
-`<Chat />` with no `client`. Theme its own styles with CSS custom properties on it or an
-ancestor: `--chat-background`, `--chat-surface`, `--chat-text`, `--chat-text-muted`,
-`--chat-accent`, `--chat-line`, `--chat-attention`, `--chat-danger`, `--chat-font`,
-`--chat-font-mono`, `--chat-font-size`, `--chat-radius` and `--chat-density` (a factor for
-spacing); an unset one keeps House's light or dark look. `mountChat(element, { client })`
-places it outside React, with `update(props)` and `unmount()`.
-
-Mix `ChatMessageList` (`components` takes your `UserMessage` and `AssistantMessage`),
-`ChatInput` and `ChatQuestionCard` with your own design inside a `ChatProvider`, or
-compose assistant-ui's primitives there; `useChat()` gives `send`, the conversations, the
-Agents, questions to `answer`, `options` to `choose`, `commands`, the queue to `edit` or
-`unqueue`, `stop`, `kill`, `renew`, which starts a new chat with the same Agent in place of
-a conversation whose session could not resume, and outcomes; never replace its messages,
-sending or store. It
-shows a conversation's latest 50 messages, and assistant-ui's `loadEarlier()` the 50
-before, which `ChatMessageList` calls as the reader scrolls back. A secret question is
-never answered here; typed answers live in the Presentation State members named `typed:…`:
-leave them. `Markdown` draws Markdown safely.

package/dist/chat/acts.d.ts

@@ -1,33 +0,0 @@
-import { type Answered } from '../attempt.js';
-import { type CallResult, type Offline } from '../outcome.js';
-import type { Expected } from './overlay.js';
-export type ChatResult = CallResult | Offline;
-export type ChatOutcome = {
-    readonly state: 'sending';
-} | {
-    readonly state: 'offline';
-} | {
-    readonly state: 'failed';
-    readonly result: CallResult;
-};
-export declare function accepted(result: ChatResult): result is Extract<CallResult, {
-    readonly kind: 'action';
-}>;
-export declare function unanswered(result: ChatResult): boolean;
-export declare function outcomeOf(result: ChatResult): ChatOutcome | null;
-export declare function answeredOf(result: ChatResult): Answered;
-export type Sender = {
-    carried(name: string, about: unknown, sending: (operation: string) => Promise<CallResult>): Promise<ChatResult>;
-    numbered(name: string, about: unknown, sending: (operation: string) => Promise<ChatResult>): Promise<ChatResult>;
-    expect(expected: Expected): void;
-    draw(expected: Expected): void;
-};
-type Senders = {
-    readonly online: boolean;
-    identity(intent: string): string;
-    expect(expected: Expected): void;
-    draw(expected: Expected): void;
-};
-export declare function sender({ online, identity, expect, draw }: Senders): Sender;
-export {};
-//# sourceMappingURL=acts.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"acts.d.ts","sourceRoot":"","sources":["../../src/chat/acts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,QAAQ,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,EAAa,KAAK,UAAU,EAAE,KAAK,OAAO,EAAE,MAAM,eAAe,CAAC;AACzE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAE7C,MAAM,MAAM,UAAU,GAAG,UAAU,GAAG,OAAO,CAAC;AAE9C,MAAM,MAAM,WAAW,GACnB;IAAE,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAA;CAAE,GAC7B;IAAE,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAA;CAAE,GAC7B;IAAE,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAA;CAAE,CAAC;AAE9D,wBAAgB,QAAQ,CACtB,MAAM,EAAE,UAAU,GACjB,MAAM,IAAI,OAAO,CAAC,UAAU,EAAE;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC,CAE5D;AAED,wBAAgB,UAAU,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAEtD;AAED,wBAAgB,SAAS,CAAC,MAAM,EAAE,UAAU,GAAG,WAAW,GAAG,IAAI,CAGhE;AAED,wBAAgB,UAAU,CAAC,MAAM,EAAE,UAAU,GAAG,QAAQ,CAIvD;AAED,MAAM,MAAM,MAAM,GAAG;IACnB,OAAO,CACL,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,OAAO,EACd,OAAO,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,UAAU,CAAC,GAClD,OAAO,CAAC,UAAU,CAAC,CAAC;IACvB,QAAQ,CACN,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,OAAO,EACd,OAAO,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,UAAU,CAAC,GAClD,OAAO,CAAC,UAAU,CAAC,CAAC;IACvB,MAAM,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAAC;IACjC,IAAI,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAAC;CAChC,CAAC;AAEF,KAAK,OAAO,GAAG;IACb,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;IACjC,MAAM,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAAC;IACjC,IAAI,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAAC;CAChC,CAAC;AAEF,wBAAgB,MAAM,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE,OAAO,GAAG,MAAM,CAe1E"}

package/dist/chat/acts.js

@@ -1,36 +0,0 @@
-import { intentOf } from '../attempt.js';
-import { UNCERTAIN } from '../outcome.js';
-export function accepted(result) {
-    return result.kind === 'action';
-}
-export function unanswered(result) {
-    return result.kind === 'transport-uncertainty';
-}
-export function outcomeOf(result) {
-    if (accepted(result))
-        return null;
-    return result.kind === 'offline' ? { state: 'offline' } : { state: 'failed', result };
-}
-export function answeredOf(result) {
-    if (accepted(result))
-        return 'accepted';
-    if (result.kind === 'offline')
-        return 'offline';
-    return unanswered(result) ? 'unanswered' : 'refused';
-}
-export function sender({ online, identity, expect, draw }) {
-    const numbered = async (name, about, sending) => {
-        try {
-            return await sending(identity(intentOf(name, about)));
-        }
-        catch {
-            return UNCERTAIN;
-        }
-    };
-    return {
-        carried: (name, about, sending) => online ? numbered(name, about, sending) : Promise.resolve({ kind: 'offline' }),
-        numbered,
-        expect,
-        draw,
-    };
-}

package/dist/chat/context.d.ts

@@ -1,3 +0,0 @@
-import type { TurnContext } from '../adapter.js';
-export declare function contextText(context: TurnContext): string;
-//# sourceMappingURL=context.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/chat/context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAQjD,wBAAgB,WAAW,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,CAExD"}

package/dist/chat/earlier.d.ts

@@ -1,10 +0,0 @@
-import type { MdRuntimeClient } from '../client.js';
-import type { ConversationView } from '../conversation.js';
-export declare const CHAT_WINDOW = 50;
-export type Paged = {
-    readonly view: ConversationView | null;
-    readonly hasEarlier: boolean;
-    loadEarlier(): Promise<void>;
-};
-export declare function useEarlier(client: MdRuntimeClient, thread: string | null, held: ConversationView | null): Paged;
-//# sourceMappingURL=earlier.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"earlier.d.ts","sourceRoot":"","sources":["../../src/chat/earlier.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE3D,eAAO,MAAM,WAAW,KAAK,CAAC;AAU9B,MAAM,MAAM,KAAK,GAAG;IAClB,QAAQ,CAAC,IAAI,EAAE,gBAAgB,GAAG,IAAI,CAAC;IACvC,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9B,CAAC;AAuBF,wBAAgB,UAAU,CACxB,MAAM,EAAE,eAAe,EACvB,MAAM,EAAE,MAAM,GAAG,IAAI,EACrB,IAAI,EAAE,gBAAgB,GAAG,IAAI,GAC5B,KAAK,CA8BP"}

package/dist/chat/earlier.js

@@ -1,54 +0,0 @@
-import { useCallback, useMemo, useState } from 'react';
-export const CHAT_WINDOW = 50;
-function slidOut(before, after) {
-    if (before === null || before.conversation !== after.conversation)
-        return [];
-    const kept = new Set(after.messages.map((one) => one.identity));
-    const left = [];
-    for (const message of before.messages) {
-        if (kept.has(message.identity))
-            break;
-        left.push(message);
-    }
-    return left;
-}
-function joined(held, earlier) {
-    const { next: _live, ...view } = held;
-    const live = new Set(held.messages.map((one) => one.identity));
-    return {
-        ...view,
-        messages: [...earlier.messages.filter((one) => !live.has(one.identity)), ...held.messages],
-        ...(earlier.next === undefined ? {} : { next: earlier.next }),
-    };
-}
-export function useEarlier(client, thread, held) {
-    const [earlier, setEarlier] = useState(null);
-    const [seen, setSeen] = useState(held);
-    const whole = held !== null && held.next === undefined;
-    let current = earlier !== null && earlier.thread === thread && !whole ? earlier : null;
-    if (current !== earlier)
-        setEarlier(current);
-    if (seen !== held) {
-        setSeen(held);
-        const carried = held === null ? [] : slidOut(seen, held);
-        if (thread !== null && carried.length > 0) {
-            const base = current ?? { thread, messages: [], next: seen?.next };
-            current = { ...base, messages: [...base.messages, ...carried] };
-            setEarlier(current);
-        }
-    }
-    const view = useMemo(() => (held === null || current === null ? held : joined(held, current)), [held, current]);
-    const next = current === null ? held?.next : current.next;
-    const loadEarlier = useCallback(async () => {
-        if (thread === null || next === undefined)
-            return;
-        const older = await client.conversation.read(thread, { limit: CHAT_WINDOW, after: next });
-        setEarlier((now) => {
-            const base = now !== null && now.thread === thread ? now : { thread, messages: [], next };
-            if (base.next !== next)
-                return now;
-            return { thread, messages: [...older.messages, ...base.messages], next: older.next };
-        });
-    }, [client, thread, next]);
-    return { view, hasEarlier: next !== undefined, loadEarlier };
-}

package/dist/chat/house.d.ts

@@ -1,25 +0,0 @@
-export type HouseSource = {
-    readonly kind: 'request';
-    readonly request: string;
-    readonly routine: string;
-    readonly version: number;
-    readonly requester: {
-        readonly name: string;
-        readonly room: boolean;
-    };
-    readonly room: {
-        readonly ref: string;
-        readonly name: string;
-    };
-    readonly approved: string | null;
-} | {
-    readonly kind: 'mail';
-    readonly agent: string;
-    readonly owner: string;
-};
-export type ChatRequest = {
-    readonly request: string;
-    readonly room: string;
-};
-export declare function sourceOf(value: unknown): HouseSource | null;
-//# sourceMappingURL=house.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"house.d.ts","sourceRoot":"","sources":["../../src/chat/house.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,WAAW,GACnB;IACE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;KAAE,CAAC;IACtE,QAAQ,CAAC,IAAI,EAAE;QAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IAC/D,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CAClC,GACD;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAE9E,MAAM,MAAM,WAAW,GAAG;IAAE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAgC9E,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,WAAW,GAAG,IAAI,CAO3D"}

package/dist/chat/house.js

@@ -1,38 +0,0 @@
-import { record, text } from './read.js';
-function requestOf(source) {
-    const request = text(source, 'request');
-    const routine = record(source.routine);
-    const name = text(routine, 'name');
-    const version = routine.version;
-    const requester = record(source.requester);
-    const by = text(requester, 'name');
-    const room = record(source.room);
-    const ref = text(room, 'ref');
-    const called = text(room, 'name');
-    if (request === null ||
-        name === null ||
-        typeof version !== 'number' ||
-        by === null ||
-        ref === null ||
-        called === null)
-        return null;
-    return {
-        kind: 'request',
-        request,
-        routine: name,
-        version,
-        requester: { name: by, room: text(requester, 'room') !== null },
-        room: { ref, name: called },
-        approved: text(source, 'approved_at'),
-    };
-}
-export function sourceOf(value) {
-    const source = record(value);
-    if (source.kind === 'request')
-        return requestOf(source);
-    if (source.kind !== 'mail')
-        return null;
-    const agent = text(record(source.agent), 'name');
-    const owner = text(record(source.owner), 'name');
-    return agent === null || owner === null ? null : { kind: 'mail', agent, owner };
-}

package/dist/chat/input.d.ts

@@ -1,11 +0,0 @@
-import { type ReactElement, type ReactNode } from 'react';
-import type { ChatRequest } from './house.js';
-import { type ChatNoteProps } from './kit.js';
-export type ChatInputProps = {
-    readonly messageLength?: number;
-    readonly note?: (note: ChatNoteProps) => ReactNode;
-    readonly autoFocus?: boolean;
-    readonly decision?: (request: ChatRequest) => ReactNode;
-};
-export declare function ChatInput({ messageLength, note, autoFocus, decision, }: ChatInputProps): ReactElement;
-//# sourceMappingURL=input.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"input.d.ts","sourceRoot":"","sources":["../../src/chat/input.tsx"],"names":[],"mappings":"AAAA,OAAO,EAA0C,KAAK,YAAY,EAAE,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAmBlG,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,EAAsD,KAAK,aAAa,EAAE,MAAM,UAAU,CAAC;AAMlG,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,SAAS,CAAC;IACnD,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC,OAAO,EAAE,WAAW,KAAK,SAAS,CAAC;CACzD,CAAC;AAgFF,wBAAgB,SAAS,CAAC,EACxB,aAAa,EACb,IAAY,EACZ,SAAiB,EACjB,QAAQ,GACT,EAAE,cAAc,GAAG,YAAY,CA4K/B"}