@agentshouse/mdruntime 0.1.0-alpha.9 → 0.1.0-c037654ea7e04

package/AGENTS.md

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

package/README.md

@@ -0,0 +1,44 @@
+# `@agentshouse/mdruntime`
+
+The headless core of MD App: local Rooms of typed Markdown Documents with
+query, search, observation, Room Drafts, and queued saves that synchronize
+with a Provider through an Adapter.
+
+## Install
+
+```sh
+npm install @agentshouse/mdruntime
+```
+
+## Entries
+
+| Entry                           | For                                                  |
+| ------------------------------- | ---------------------------------------------------- |
+| `@agentshouse/mdruntime/client` | The host's client: `connectMdRuntime(port)`          |
+| `@agentshouse/mdruntime/host`   | The host that serves a Runtime: `serveMdRuntime`     |
+| `@agentshouse/mdruntime`        | Shared types                                         |
+| `@agentshouse/mdruntime/memory` | Tests: `createMemoryAdapter`, an in-memory Adapter   |
+| `@agentshouse/mdruntime/react`  | React hooks over the client: `useObserve`, `useSave` |
+
+## Usage
+
+App code takes the client its host hands it; in House the App bridge hands it:
+
+```ts
+import { connectHouseBridge } from '@agentshouse/app-bridge';
+
+const runtime = await connectHouseBridge().runtime;
+const rooms = await runtime.rooms();
+const notes = await runtime.query({ types: ['note'], select: 'all', limit: 20 });
+```
+
+`observe('storage-loss')` reports `null` or the stable code
+`storage-loss` when unsynchronized Room Drafts and Pending Changes were lost.
+The host supplies the user-facing wording.
+
+The rules an App's agent follows, including Local Query, Local Search, Room
+Draft and Save, are in [`AGENTS.md`](AGENTS.md).
+
+## License
+
+MIT

package/dist/adapter.d.ts

@@ -1,15 +1,12 @@
-import type { ModelIdentity, ModelResult } from './model.js';
+import type { ModelResult } from './model.js';
 import type { ChangeBatch } from './change.js';
 export type Authorization = object;
-export declare const ROOM_CONTRACT_VERSION = 1;
-export declare const VERSION_1_CAPABILITIES: readonly ['stable-file-ids', 'ranked-provider-search', 'room-version-notifications', 'room-history', 'provider-actions'];
 export type MdModelIdentity = {
     identity: string;
     version: string;
 };
 export type TypedSelection = {
     roots: readonly string[];
-    attachedModel: ModelIdentity | null;
 };
 export type OperationScopes = {
     read: readonly string[];
@@ -22,13 +19,12 @@ export type ReplicaAdmission = {
     admission: 'admitted' | 'unavailable';
 };
 export type DiscoveredRoom = {
-    collectionRoot: string;
     name: string;
     locator: string;
+    handle: string;
     roomVersion: string;
     operations: OperationScopes;
     replica: ReplicaAdmission;
-    attachedModel: ModelIdentity | null;
     typedSelection?: TypedSelection;
     providerOwnedPaths: readonly string[];
 };
@@ -36,35 +32,153 @@ export type Capability = {
     name: string;
     limits?: readonly ProviderLimit[];
     actions?: readonly ActionDeclaration[];
-    conversationCards?: ConversationCards;
+    conversationAgents?: ConversationAgents;
 };
-export type ConversationCards = {
+export type ConversationAgents = {
     locator: string;
     type: string;
     identity: string;
+    name: string;
+};
+export type ListedConversation = {
+    conversation: string;
     agent: string;
+    name: string;
+    created: string;
+    finished: string | null;
+    outcome: string | null;
 };
 export type ConversationAction = 'conversation.create' | 'conversation.send' | 'conversation.answer' | 'conversation.interrupt' | 'conversation.kill' | 'conversation.cancel' | 'conversation.delete' | 'conversation.history';
 export type ConversationMessage = {
+    identity: string;
     turn: string;
+    text: string;
     message: unknown;
 };
+export type AcceptedMessage = ConversationMessage & {
+    position: string;
+};
+export type ConversationHistoryRequest = {
+    conversations: readonly {
+        conversation: string;
+        after?: string;
+    }[];
+};
+export type ConversationHistoryPage = {
+    conversation: string;
+    messages: readonly AcceptedMessage[];
+    next?: string;
+};
+export type ConversationHistories = {
+    histories: readonly ConversationHistoryPage[];
+};
+export type TurnContext = {
+    used: number;
+    window: number;
+};
+export type TurnOperation = {
+    op: 'begin';
+    at: string;
+} | {
+    op: 'start';
+    index: number;
+    part: unknown;
+} | {
+    op: 'append';
+    index: number;
+    text: string;
+} | {
+    op: 'status';
+    index: number;
+    status: string;
+    result: unknown;
+} | {
+    op: 'count';
+    index: number;
+    count: number;
+} | {
+    op: 'plan';
+    index: number;
+    entries: readonly unknown[];
+} | ({
+    op: 'context';
+} & TurnContext);
+export type ProcessCommand = {
+    [field: string]: unknown;
+    name: string;
+    description: string;
+    input?: {
+        [field: string]: unknown;
+        hint: string;
+    } | null;
+};
+type SelectValue = {
+    [field: string]: unknown;
+    value: string;
+    name: string;
+    description?: string | null;
+};
+type SelectGroup = {
+    [field: string]: unknown;
+    group: string;
+    name: string;
+    options: readonly SelectValue[];
+};
+type SessionOptionNaming = {
+    [field: string]: unknown;
+    id: string;
+    name: string;
+    description?: string | null;
+    category?: string | null;
+};
+export type SessionOption = (SessionOptionNaming & {
+    type: 'select';
+    currentValue: string;
+    options: readonly SelectValue[] | readonly SelectGroup[];
+}) | (SessionOptionNaming & {
+    type: 'boolean';
+    currentValue: boolean;
+});
 export type ConversationEvent = {
-    kind: 'growing-text';
+    kind: 'turn';
     conversation: string;
     turn: string;
-    text: string;
+    operation: TurnOperation;
+} | {
+    kind: 'questions';
+    conversation: string;
+    questions: readonly unknown[];
+} | {
+    kind: 'process';
+    conversation: string;
+    running: boolean;
+} | {
+    kind: 'commands';
+    conversation: string;
+    commands: readonly ProcessCommand[];
+} | {
+    kind: 'options';
+    conversation: string;
+    options: readonly SessionOption[];
 } | {
     kind: 'accepted-message';
     conversation: string;
-    message: ConversationMessage;
+    message: AcceptedMessage;
+} | {
+    kind: 'gap';
+    conversation: string;
+} | {
+    kind: 'list';
+    entries: readonly ListedConversation[];
 } | {
-    kind: 'session-summary';
+    kind: 'listed';
+    entry: ListedConversation;
+} | {
+    kind: 'unlisted';
     conversation: string;
-    summary: unknown;
 };
-export type ViewedConversations = {
-    view(conversations: readonly string[]): void;
+export type ConversationStream = {
+    replicate(conversations: readonly string[]): void;
     observe(notify: (event: ConversationEvent) => void): () => void;
 };
 export type ActionDeclaration = {
@@ -89,8 +203,6 @@ export type Retention = {
 };
 export type Discovery = {
     kind: 'discovery';
-    supportedVersions: readonly number[];
-    mdModel: MdModelIdentity;
     rooms: readonly DiscoveredRoom[];
     capabilities: readonly Capability[];
     providerLimits: readonly ProviderLimit[];
@@ -121,17 +233,44 @@ export type ContractUnavailable = ProviderRefusal & {
 };
 export type DiscoverResult = Discovery | TransportUncertainty | RevokedAuthorization | ContractUnavailable;
 export type PageToken = string;
+export type ChangeAuthor = {
+    kind: 'user';
+    id: string;
+    name: string;
+} | {
+    kind: 'site';
+    id: string;
+    name: string;
+};
+export type HeadChange = {
+    author: ChangeAuthor | null;
+    time: string;
+};
+export type RoomAttachment = {
+    reference: string;
+    name: string;
+    byteLength: number;
+    mediaType: string | null;
+    entry: unknown;
+};
 export type BootstrapRequest = {
     locator: string;
     selection: string;
     pageToken?: PageToken;
 };
+export type RoomModels = {
+    collection?: ModelResult;
+    selection?: ModelResult;
+};
 export type BootstrapPage = {
     kind: 'bootstrap';
     roomVersion: string;
+    models?: RoomModels;
     documents: Readonly<Record<string, string>>;
     revisions: Readonly<Record<string, string>>;
+    changes: Readonly<Record<string, HeadChange>>;
     binaryTargets: readonly string[];
+    attachments?: readonly RoomAttachment[];
     pageToken?: PageToken;
 };
 export type BootstrapResult = BootstrapPage | AdapterFailure;
@@ -144,31 +283,40 @@ export type RefreshRequest = {
 export type RefreshPage = {
     kind: 'net-advancement';
     roomVersion: string;
+    models?: RoomModels;
     documents: Readonly<Record<string, string>>;
     revisions: Readonly<Record<string, string>>;
+    changes: Readonly<Record<string, HeadChange>>;
     binaryTargets: readonly string[];
     removals: readonly string[];
+    attachments?: readonly RoomAttachment[];
     pageToken?: PageToken;
 };
 export type RefreshResult = {
     kind: 'still-current';
 } | RefreshPage | {
     kind: 'beyond-horizon';
-} | AdapterFailure;
+} | RetryableRefusal | AdapterFailure;
 export type MutationRequest = {
     locator: string;
     changeBatch: ChangeBatch;
+    upload?: unknown;
 };
 export type RetryableRefusal = ProviderRefusal & {
     kind: 'retryable-refusal';
     reset?: string;
 };
+export type ServiceMode = 'open' | 'write-halted';
+export type ServiceModeSignal = {
+    observe(notify: (mode: ServiceMode) => void): () => void;
+};
 export type MutationResult = {
     kind: 'accepted';
     roomVersion: string;
     documents: Readonly<Record<string, string>>;
     revisions: Readonly<Record<string, string>>;
     removals: readonly string[];
+    attachments?: readonly RoomAttachment[];
     author?: string;
     time?: string;
 } | (ProviderRefusal & {
@@ -179,11 +327,21 @@ export type MutationResult = {
     kind: 'rejected';
     affected: Readonly<Record<string, string>>;
 }) | RetryableRefusal | {
+    kind: 'write-halted';
+} | {
     kind: 'expired';
 } | AdapterFailure;
+export type HistoryAuthor = {
+    kind: 'user';
+    id: string;
+} | {
+    kind: 'site';
+    id: string;
+    name: string;
+};
 export type HistoryRevision = {
     revision: string;
-    author: string;
+    author: HistoryAuthor;
     time: string;
 };
 export type HistoryRequest = {
@@ -206,41 +364,54 @@ export type ActionRequest = {
     name: string;
     input: unknown;
 };
+export type RoomVersionAt = {
+    locator: string;
+    roomVersion: string;
+};
 export type ActionResult = {
     kind: 'action';
     result: unknown;
+    at?: RoomVersionAt;
 } | (ProviderRefusal & {
     kind: 'rejected';
 }) | AdapterFailure;
-export type ModelRequest = {
-    locator: string;
-    attached: 'collection';
-    collectionRoot: string;
-    model: ModelIdentity | null;
-} | {
+export type HeldRoom = {
     locator: string;
-    attached: 'typed-selection';
-    roots: readonly string[];
-    model: ModelIdentity | null;
+    roomVersion: string;
+    documents: Readonly<Record<string, string>>;
+    revisions: Readonly<Record<string, string>>;
+    attachments: readonly RoomAttachment[];
 };
-export type RoomVersionNotification = {
+export type RoomStreamEvent = {
+    kind: 'opened';
+} | {
+    kind: 'closed';
+    revoked: boolean;
+} | {
+    kind: 'opening';
+    expired: readonly string[];
+} | {
+    kind: 'room-version';
     locator: string;
     roomVersion: string;
 };
-export type SelectedRooms = {
-    select(locators: readonly string[]): void;
-    observe(notify: (notification: RoomVersionNotification) => void): () => void;
+export type RoomStream = {
+    hold(rooms: readonly HeldRoom[]): void;
+    observe(notify: (event: RoomStreamEvent) => void): () => void;
 };
 export type Adapter = {
-    model(authorization: Authorization, request: ModelRequest): Promise<ModelResult>;
     authorize(): Promise<Authorization>;
     discover(authorization: Authorization): Promise<DiscoverResult>;
     bootstrap(authorization: Authorization, request: BootstrapRequest): Promise<BootstrapResult>;
     refresh(authorization: Authorization, request: RefreshRequest): Promise<RefreshResult>;
-    mutate(authorization: Authorization, request: MutationRequest): Promise<MutationResult>;
+    mutate(authorization: Authorization, request: MutationRequest, keep: (upload: unknown) => Promise<void>): Promise<MutationResult>;
     history(authorization: Authorization, request: HistoryRequest): Promise<HistoryResult>;
     action(authorization: Authorization, request: ActionRequest): Promise<ActionResult>;
-    roomVersions?: SelectedRooms;
-    conversations?: ViewedConversations;
+    reached(locator: string, roomVersion: string, target: string): boolean;
+    follows(locator: string, roomVersion: string, next: string): boolean;
+    roomStream?: RoomStream;
+    conversations?: ConversationStream;
+    serviceMode?: ServiceModeSignal;
 };
+export {};
 //# sourceMappingURL=adapter.d.ts.map