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

package/dist/conversation.js

@@ -1,401 +1,613 @@
+import { conversationChangeSet } from './change-set.js';
 import { declaredFile } from './file.js';
-const NO_TURNS = new Set();
-function carriedMessage(value) {
-    if (typeof value !== 'object' || value === null) return null;
-    const record = value;
-    if (typeof record.turn !== 'string') return null;
-    return structuredClone(value);
-}
-function historyPage(result) {
-    if (result.kind !== 'action') return null;
-    const answer = result.result;
-    if (typeof answer !== 'object' || answer === null) return null;
-    const record = answer;
-    if (!Array.isArray(record.messages)) return null;
-    const messages = [];
-    for (const entry of record.messages){
-        const carried = carriedMessage(entry);
-        if (carried !== null) messages.push(carried);
-    }
+const QUIET = {
+    turn: null,
+    questions: [],
+    process: null,
+    commands: [],
+    options: [],
+};
+export function unheldView(conversation) {
     return {
-        messages,
-        cursor: typeof record.cursor === 'string' ? record.cursor : null
+        conversation,
+        messages: [],
+        turn: null,
+        questions: [],
+        process: null,
+        commands: [],
+        options: [],
+        chatDraft: null,
     };
 }
-function turnOf(result) {
-    if (result.kind !== 'action') return null;
-    const answer = result.result;
-    if (typeof answer !== 'object' || answer === null) return null;
-    const record = answer;
-    return typeof record.turn === 'string' ? record.turn : null;
+function startedTurn(turn, operation) {
+    if (operation.op === 'context') {
+        return { turn, parts: [], context: { used: operation.used, window: operation.window } };
+    }
+    return operation.op === 'start' && operation.index === 0
+        ? { turn, parts: [structuredClone(operation.part)], context: null }
+        : null;
 }
-function newest(held, page, arrived) {
-    const arriving = new Set(page.messages.map((entry)=>entry.turn));
-    const overlap = held.messages.findIndex((entry)=>arriving.has(entry.turn));
-    const carried = overlap === -1 ? [] : held.messages.slice(0, overlap);
-    const placed = new Set([
-        ...carried,
-        ...page.messages
-    ].map((entry)=>entry.turn));
-    const live = held.messages.filter((entry)=>arrived.has(entry.turn) && !placed.has(entry.turn));
+function changedFields(part, operation) {
+    if (operation.op === 'append') {
+        return { text: `${String(part.text ?? '')}${operation.text}` };
+    }
+    if (operation.op === 'status') {
+        return { status: operation.status, result: structuredClone(operation.result) };
+    }
+    if (operation.op === 'count')
+        return { count: operation.count };
+    return { entries: structuredClone(operation.entries) };
+}
+function appliedTurn(held, operation) {
+    if (operation.op === 'context') {
+        return { ...held, context: { used: operation.used, window: operation.window } };
+    }
+    if (operation.op === 'start') {
+        if (operation.index !== 0 && operation.index !== held.parts.length)
+            return null;
+        return {
+            ...held,
+            parts: [...held.parts.slice(0, operation.index), structuredClone(operation.part)],
+        };
+    }
+    const part = held.parts[operation.index];
+    if (typeof part !== 'object' || part === null)
+        return null;
+    const changed = { ...part, ...changedFields(part, operation) };
     return {
         ...held,
-        messages: [
-            ...carried,
-            ...page.messages,
-            ...live
-        ],
-        cursor: overlap === -1 ? page.cursor : held.cursor
+        parts: held.parts.map((kept, at) => (at === operation.index ? changed : kept)),
     };
 }
-function older(held, page) {
-    const present = new Set(held.messages.map((entry)=>entry.turn));
+function ordered(left, right) {
+    if (left.position !== right.position)
+        return left.position < right.position ? -1 : 1;
+    if (left.identity !== right.identity)
+        return left.identity < right.identity ? -1 : 1;
+    return 0;
+}
+function merged(held, arriving) {
+    const byIdentity = new Map(held.map((message) => [message.identity, message]));
+    for (const message of arriving)
+        byIdentity.set(message.identity, message);
+    return [...byIdentity.values()].sort(ordered);
+}
+function acceptedMessage(value) {
+    if (typeof value !== 'object' || value === null)
+        return null;
+    const record = value;
+    if (typeof record.identity !== 'string' ||
+        typeof record.turn !== 'string' ||
+        typeof record.position !== 'string' ||
+        typeof record.text !== 'string') {
+        return null;
+    }
     return {
-        ...held,
-        messages: [
-            ...page.messages.filter((entry)=>!present.has(entry.turn)),
-            ...held.messages
-        ],
-        cursor: page.cursor
+        identity: record.identity,
+        turn: record.turn,
+        position: record.position,
+        text: record.text,
+        message: structuredClone(record.message),
     };
 }
-function sealed(held, arriving) {
-    const at = held.messages.findIndex((entry)=>entry.turn === arriving.turn);
-    if (at === -1) return {
-        ...held,
-        messages: [
-            ...held.messages,
-            arriving
-        ]
-    };
-    const messages = [
-        ...held.messages
-    ];
-    messages[at] = arriving;
+function historyPage(value) {
+    if (typeof value !== 'object' || value === null)
+        return null;
+    const record = value;
+    if (typeof record.conversation !== 'string' || !Array.isArray(record.messages))
+        return null;
+    if (record.next !== undefined && typeof record.next !== 'string')
+        return null;
+    const messages = [];
+    for (const entry of record.messages) {
+        const message = acceptedMessage(entry);
+        if (message === null)
+            return null;
+        messages.push(message);
+    }
     return {
-        ...held,
-        messages
+        conversation: record.conversation,
+        messages,
+        ...(record.next === undefined ? {} : { next: record.next }),
     };
 }
+function historyPages(result) {
+    if (result.kind !== 'action')
+        return null;
+    const answer = result.result;
+    if (typeof answer !== 'object' || answer === null)
+        return null;
+    const { histories } = answer;
+    if (!Array.isArray(histories))
+        return null;
+    const pages = [];
+    for (const entry of histories) {
+        const page = historyPage(entry);
+        if (page === null)
+            return null;
+        pages.push(page);
+    }
+    return pages;
+}
+function turnOf(result) {
+    if (result.kind !== 'action')
+        return null;
+    const answer = result.result;
+    if (typeof answer !== 'object' || answer === null)
+        return null;
+    const record = answer;
+    return typeof record.turn === 'string' ? record.turn : null;
+}
+function limitOf(options) {
+    const { limit } = options;
+    if (limit === undefined)
+        return undefined;
+    if (!Number.isInteger(limit) || limit < 0) {
+        throw new Error(`conversation limit must be a non-negative integer, got ${String(limit)}`);
+    }
+    return limit;
+}
 export function createConversationStore(deps) {
-    const held = new Map();
-    const composed = new Map();
-    const growing = new Map();
-    const viewers = new Set();
-    const issued = new Map();
-    const live = new Map();
-    let handed;
-    function heldOf(conversation) {
-        return held.get(conversation) ?? {
-            messages: [],
-            cursor: null,
-            summary: null
-        };
+    const messages = new Map();
+    const reads = new Map();
+    const drafts = new Map();
+    const sending = new Map();
+    const behind = new Set();
+    const gaps = new Map();
+    const lives = new Map();
+    const views = new Map();
+    let replicated = new Set();
+    let handedReplicated;
+    function liveOf(conversation) {
+        return lives.get(conversation) ?? QUIET;
     }
-    function instructionOf(conversation) {
-        return composed.get(conversation) ?? {
-            text: '',
-            files: [],
-            turn: null
-        };
+    function shownMessages(conversation, limit) {
+        const held = messages.get(conversation) ?? [];
+        const shown = limit === undefined ? held : held.slice(Math.max(0, held.length - limit));
+        return shown.map(({ identity, turn, text, message }) => ({
+            identity,
+            turn,
+            text,
+            message: structuredClone(message),
+        }));
     }
-    function viewOf(conversation) {
-        const carried = heldOf(conversation);
-        const unsent = composed.get(conversation);
+    function viewOf(conversation, limit, shown = shownMessages(conversation, limit)) {
+        const draft = drafts.get(conversation);
+        const facts = liveOf(conversation);
         return {
             conversation,
-            messages: structuredClone(carried.messages),
-            olderPages: carried.cursor !== null,
-            growingText: growing.get(conversation) ?? null,
-            summary: structuredClone(carried.summary),
-            instruction: unsent === undefined || unsent.turn !== null ? null : {
-                text: unsent.text,
-                files: [
-                    ...unsent.files
-                ]
-            }
+            messages: shown,
+            turn: structuredClone(facts.turn),
+            questions: structuredClone(facts.questions),
+            process: facts.process === null ? null : { ...facts.process },
+            commands: structuredClone(facts.commands),
+            options: structuredClone(facts.options),
+            chatDraft: draft === undefined || draft.turn !== null || sending.get(conversation)?.draft === draft
+                ? null
+                : { text: draft.text, files: [...draft.files] },
         };
     }
-    function emit(conversation) {
-        if (deps.closed()) return;
-        for (const viewer of viewers){
-            if (viewer.conversation === conversation && viewer.ready) viewer.notify(viewOf(conversation));
+    function emit(conversation, messagesChanged = true) {
+        if (deps.closed())
+            return;
+        for (const view of views.values()) {
+            if (view.conversation !== conversation)
+                continue;
+            if (messagesChanged)
+                view.messages = null;
+            const ready = [...view.watchers].filter((watcher) => watcher.ready);
+            if (ready.length === 0)
+                continue;
+            view.messages ??= shownMessages(conversation, view.limit);
+            const value = viewOf(conversation, view.limit, view.messages);
+            for (const watcher of ready)
+                watcher.notify(value);
         }
     }
-    function viewed() {
-        return [
-            ...new Set([
-                ...viewers
-            ].map((viewer)=>viewer.conversation))
-        ].sort();
+    function live(conversation, change) {
+        lives.set(conversation, { ...liveOf(conversation), ...change });
+        emit(conversation, false);
     }
-    function hand() {
-        const path = deps.path();
-        if (path === undefined) return;
-        const open = viewed();
-        const named = JSON.stringify(open);
-        if (named === handed) return;
-        handed = named;
-        path.view(open);
+    function relayed(conversation, turn, operation) {
+        const held = liveOf(conversation).turn;
+        const next = held?.turn === turn ? appliedTurn(held, operation) : startedTurn(turn, operation);
+        if (next !== null)
+            live(conversation, { turn: next });
     }
-    function keptRecord(conversation) {
-        const carried = heldOf(conversation);
-        return {
-            conversation,
-            messages: carried.messages,
-            cursor: carried.cursor,
-            summary: carried.summary
-        };
+    function sealTurns(conversation, turns) {
+        const held = lives.get(conversation);
+        if (held?.turn == null || !turns.has(held.turn.turn))
+            return false;
+        lives.set(conversation, { ...held, turn: null });
+        return true;
+    }
+    function handReplicated() {
+        const stream = deps.stream();
+        if (stream === undefined)
+            return;
+        const held = [...replicated].sort();
+        const named = JSON.stringify(held);
+        if (named === handedReplicated)
+            return;
+        handedReplicated = named;
+        stream.replicate(held);
     }
-    async function settle(local, conversation) {
-        const sent = instructionOf(conversation).turn;
-        if (sent === null) return;
-        if (!heldOf(conversation).messages.some((entry)=>entry.turn === sent)) return;
-        composed.delete(conversation);
-        await local.dropInstruction(conversation);
+    async function documented() {
+        const declaration = deps.cards();
+        if (declaration === undefined)
+            return [];
+        const { documents } = await deps.documents(declaration.locator);
+        return documents.filter((document) => typeof document.type === 'string');
+    }
+    function carded(documents) {
+        const declaration = deps.cards();
+        if (declaration === undefined)
+            return [];
+        const cards = [];
+        for (const card of documents) {
+            if (card.type !== declaration.type)
+                continue;
+            const identity = card.fields[declaration.identity];
+            if (typeof identity === 'string')
+                cards.push({ conversation: identity, card });
+        }
+        return cards;
     }
-    async function keep(conversation, next) {
-        const kept = await deps.durably(async (local)=>{
-            const following = next(heldOf(conversation));
-            if (following === null) return false;
-            held.set(conversation, following);
-            await local.keepConversation(keptRecord(conversation));
-            await settle(local, conversation);
-            return true;
+    async function remove(leaving) {
+        await deps.durably(async (local) => {
+            await local.dropConversations(leaving);
+            const removed = [];
+            const changed = [];
+            for (const conversation of leaving) {
+                for (const message of messages.get(conversation) ?? []) {
+                    removed.push({ conversation, identity: message.identity });
+                }
+                if (messages.has(conversation) || drafts.has(conversation) || lives.has(conversation)) {
+                    changed.push(conversation);
+                }
+                messages.delete(conversation);
+                reads.delete(conversation);
+                drafts.delete(conversation);
+                behind.delete(conversation);
+                lives.delete(conversation);
+            }
+            if (changed.length > 0)
+                deps.publish(conversationChangeSet(removed, changed));
         });
-        if (kept) emit(conversation);
-        return kept;
     }
-    async function keepInstruction(conversation, next) {
-        await deps.durably(async (local)=>{
-            const stored = next(instructionOf(conversation));
-            composed.set(conversation, stored);
-            await local.keepInstruction({
+    function gap(conversation) {
+        gaps.set(conversation, (gaps.get(conversation) ?? 0) + 1);
+        behind.add(conversation);
+    }
+    function keep(conversation, message) {
+        return deps.durably(async (local) => {
+            if (!replicated.has(conversation))
+                return;
+            const read = reads.get(conversation);
+            const advances = read !== undefined &&
+                !behind.has(conversation) &&
+                (read === null || message.position > read);
+            const sealed = drafts.get(conversation)?.turn === message.turn;
+            await local.keepMessages({
                 conversation,
-                ...stored
+                messages: [message],
+                ...(advances ? { read: message.position } : {}),
+                sealed,
             });
-            await settle(local, conversation);
-        });
-        emit(conversation);
-    }
-    async function dropInstruction(conversation) {
-        await deps.durably(async (local)=>{
-            composed.delete(conversation);
-            await local.dropInstruction(conversation);
+            messages.set(conversation, merged(messages.get(conversation) ?? [], [message]));
+            if (advances)
+                reads.set(conversation, message.position);
+            if (sealed)
+                drafts.delete(conversation);
+            sealTurns(conversation, new Set([message.turn]));
+            deps.publish(conversationChangeSet([{ conversation, identity: message.identity }], [conversation]));
         });
-        emit(conversation);
-    }
-    function supersede(conversation) {
-        issued.set(conversation, (issued.get(conversation) ?? 0) + 1);
     }
-    async function fill(conversation, cursor) {
-        const generation = issued.get(conversation);
-        const result = await deps.call('conversation.history', {
+    async function readHistories(conversations) {
+        const generations = new Map(conversations.map((one) => [one, gaps.get(one) ?? 0]));
+        const starts = new Map(conversations.map((one) => [one, reads.get(one)]));
+        const arriving = new Map();
+        const complete = new Set();
+        let asking = conversations.map((conversation) => ({
             conversation,
-            ...cursor === null ? {} : {
-                cursor
+            after: starts.get(conversation) ?? undefined,
+        }));
+        while (asking.length > 0) {
+            const result = await deps.call('conversation.history', {
+                conversations: asking.map(({ conversation, after }) => ({
+                    conversation,
+                    ...(after === undefined ? {} : { after }),
+                })),
+            });
+            const pages = historyPages(result);
+            if (pages === null)
+                return result;
+            const asked = new Set(asking.map(({ conversation }) => conversation));
+            const following = [];
+            for (const page of pages) {
+                if (!asked.has(page.conversation))
+                    continue;
+                arriving.set(page.conversation, [
+                    ...(arriving.get(page.conversation) ?? []),
+                    ...page.messages,
+                ]);
+                if (page.next === undefined)
+                    complete.add(page.conversation);
+                else
+                    following.push({ conversation: page.conversation, after: page.next });
+            }
+            asking = following;
+        }
+        for (const [conversation, held] of arriving) {
+            if (!complete.has(conversation))
+                continue;
+            await keepHistory(conversation, held, starts.get(conversation), generations.get(conversation) ?? 0);
+        }
+        return null;
+    }
+    function keepHistory(conversation, arriving, from, generation) {
+        return deps.durably(async (local) => {
+            if (!replicated.has(conversation))
+                return;
+            const newest = arriving.reduce((top, message) => (top === null || message.position > top ? message.position : top), from ?? null);
+            const turn = drafts.get(conversation)?.turn;
+            const sealed = arriving.some((message) => message.turn === turn);
+            await local.keepMessages({ conversation, messages: arriving, read: newest, sealed });
+            messages.set(conversation, merged(messages.get(conversation) ?? [], arriving));
+            reads.set(conversation, newest);
+            if (sealed)
+                drafts.delete(conversation);
+            sealTurns(conversation, new Set(arriving.map((message) => message.turn)));
+            if ((gaps.get(conversation) ?? 0) === generation)
+                behind.delete(conversation);
+            if (arriving.length > 0 || sealed) {
+                deps.publish(conversationChangeSet(arriving.map((message) => ({ conversation, identity: message.identity })), [conversation]));
             }
         });
-        const page = historyPage(result);
-        if (page === null) return result;
-        const landed = await keep(conversation, (carried)=>{
-            if (issued.get(conversation) !== generation) return null;
-            if (cursor !== null) return carried.cursor === cursor ? older(carried, page) : null;
-            return newest(carried, page, live.get(conversation) ?? NO_TURNS);
+    }
+    function withDraft(conversation, next) {
+        return deps.durably(async (local) => {
+            const following = next(drafts.get(conversation));
+            if (following === undefined)
+                return;
+            if (following === null) {
+                await local.dropChatDraft(conversation);
+                drafts.delete(conversation);
+            }
+            else {
+                await local.keepChatDraft(following);
+                drafts.set(conversation, following);
+            }
+            deps.publish(conversationChangeSet([], [conversation]));
         });
-        if (landed && cursor === null) live.delete(conversation);
-        return result;
     }
     function invoke(name, conversation, extra = {}) {
-        return deps.call(name, {
-            conversation,
-            ...extra
-        });
+        return deps.call(name, { conversation, ...extra });
     }
     const surface = {
-        list () {
+        async list() {
             const declaration = deps.cards();
-            if (declaration === undefined) return Promise.resolve([]);
-            const documents = deps.documents().documents.filter((document)=>document.room === declaration.locator);
-            const entries = [];
-            for (const card of documents){
-                if (card.type !== declaration.type) continue;
-                const identity = card.fields[declaration.identity];
-                if (typeof identity !== 'string') continue;
-                const agent = documents.find((document)=>document.backlinks.some((backlink)=>backlink.path === card.path && backlink.field === declaration.agent));
-                entries.push({
-                    conversation: identity,
-                    card,
-                    agent: agent ?? null
-                });
-            }
-            entries.sort((left, right)=>left.conversation < right.conversation ? -1 : 1);
-            return Promise.resolve(entries);
-        },
-        read (conversation) {
-            return deps.durably(()=>Promise.resolve(viewOf(conversation)));
-        },
-        older (conversation) {
-            const cursor = heldOf(conversation).cursor;
-            if (cursor === null) return Promise.resolve(null);
-            return fill(conversation, cursor);
-        },
-        compose (conversation, supplied) {
-            return keepInstruction(conversation, ()=>({
-                    text: supplied.text,
-                    files: [
-                        ...supplied.files
-                    ],
-                    turn: null
-                }));
+            if (declaration === undefined)
+                return [];
+            const documents = await documented();
+            const entries = carded(documents).map(({ conversation, card }) => ({
+                conversation,
+                card,
+                agent: documents.find((document) => document.backlinks.some((backlink) => backlink.path === card.path && backlink.field === declaration.agent)) ?? null,
+            }));
+            entries.sort((left, right) => (left.conversation < right.conversation ? -1 : 1));
+            return entries;
         },
-        discard (conversation) {
-            return dropInstruction(conversation);
+        async read(conversation, options = {}) {
+            const limit = limitOf(options);
+            return deps.durably(() => Promise.resolve(viewOf(conversation, limit)));
         },
-        create (input) {
+        create(input) {
             return deps.call('conversation.create', input);
         },
-        async send (conversation) {
-            const unsent = instructionOf(conversation);
-            const files = await Promise.all(unsent.files.map(declaredFile));
-            const result = await invoke('conversation.send', conversation, {
-                text: unsent.text,
-                files
-            });
-            const turn = turnOf(result);
-            if (turn === null) return result;
-            await keepInstruction(conversation, (stored)=>({
-                    ...stored,
-                    turn
-                }));
-            return result;
+        async send(conversation) {
+            const draft = drafts.get(conversation);
+            const pending = draft === undefined ? undefined : { draft };
+            if (pending !== undefined) {
+                sending.set(conversation, pending);
+                deps.publish(conversationChangeSet([], [conversation]));
+            }
+            try {
+                const files = await Promise.all((draft?.files ?? []).map(async (file) => ({
+                    ...(await declaredFile(file)),
+                    blob: file.blob,
+                })));
+                const result = await invoke('conversation.send', conversation, {
+                    text: draft?.text ?? '',
+                    files,
+                });
+                const turn = turnOf(result);
+                if (turn === null || draft === undefined)
+                    return result;
+                await withDraft(conversation, (current) => {
+                    if (current !== draft)
+                        return undefined;
+                    const sealed = (messages.get(conversation) ?? []).some((message) => message.turn === turn);
+                    return sealed ? null : { ...draft, turn };
+                });
+                return result;
+            }
+            finally {
+                if (pending !== undefined && sending.get(conversation) === pending) {
+                    sending.delete(conversation);
+                    if (drafts.get(conversation) === draft) {
+                        deps.publish(conversationChangeSet([], [conversation]));
+                    }
+                }
+            }
         },
-        answer (conversation, answer) {
-            return invoke('conversation.answer', conversation, {
-                answer
-            });
+        answer(conversation, answer) {
+            return invoke('conversation.answer', conversation, { answer });
         },
-        interrupt (conversation) {
+        interrupt(conversation) {
             return invoke('conversation.interrupt', conversation);
         },
-        kill (conversation) {
+        kill(conversation) {
             return invoke('conversation.kill', conversation);
         },
-        async cancel (conversation, turn) {
-            const result = await invoke('conversation.cancel', conversation, {
-                turn
-            });
-            if (result.kind !== 'action') return result;
-            if (instructionOf(conversation).turn === turn) {
-                await keepInstruction(conversation, (stored)=>({
-                        ...stored,
-                        turn: null
-                    }));
-            }
+        async cancel(conversation, turn) {
+            const result = await invoke('conversation.cancel', conversation, { turn });
+            if (result.kind !== 'action')
+                return result;
+            await withDraft(conversation, (current) => current === undefined || current.turn !== turn ? undefined : { ...current, turn: null });
             return result;
         },
-        async delete (conversation) {
-            const result = await invoke('conversation.delete', conversation);
-            if (result.kind !== 'action') return result;
-            growing.delete(conversation);
-            live.delete(conversation);
-            supersede(conversation);
-            await deps.durably(async (local)=>{
-                held.delete(conversation);
-                composed.delete(conversation);
-                await local.dropConversation(conversation);
-                await local.dropInstruction(conversation);
-            });
-            emit(conversation);
-            return result;
-        }
+        delete(conversation) {
+            return invoke('conversation.delete', conversation);
+        },
+    };
+    const chatDraft = {
+        write(conversation, draft) {
+            return withDraft(conversation, () => ({
+                conversation,
+                text: draft.text,
+                files: [...draft.files],
+                turn: null,
+            }));
+        },
+        discard(conversation) {
+            return withDraft(conversation, (current) => (current === undefined ? undefined : null));
+        },
     };
     return {
         surface,
-        hydrate (conversations, instructions) {
-            held.clear();
-            for (const stored of conversations){
-                held.set(stored.conversation, {
-                    messages: stored.messages,
-                    cursor: stored.cursor,
-                    summary: stored.summary
-                });
+        chatDraft,
+        hydrate(held, stored) {
+            messages.clear();
+            reads.clear();
+            for (const view of views.values())
+                view.messages = null;
+            for (const entry of held) {
+                messages.set(entry.conversation, [...entry.messages].sort(ordered));
+                if (entry.read !== undefined)
+                    reads.set(entry.conversation, entry.read);
             }
-            composed.clear();
-            for (const stored of instructions){
-                composed.set(stored.conversation, {
-                    text: stored.text,
-                    files: stored.files,
-                    turn: stored.turn
-                });
+            drafts.clear();
+            for (const record of stored)
+                drafts.set(record.conversation, record);
+        },
+        async reconcile() {
+            const named = new Set(carded(await documented()).map((entry) => entry.conversation));
+            const leaving = [
+                ...new Set([...replicated, ...messages.keys(), ...reads.keys(), ...drafts.keys()]),
+            ].filter((conversation) => !named.has(conversation));
+            for (const conversation of named) {
+                if (!replicated.has(conversation))
+                    behind.add(conversation);
             }
+            replicated = named;
+            handReplicated();
+            if (leaving.length > 0)
+                await remove(leaving);
         },
-        observe (conversation, notify) {
-            const first = !viewed().includes(conversation);
-            const viewer = {
+        async catchUp(progress) {
+            const reading = [...behind].filter((conversation) => replicated.has(conversation)).sort();
+            if (reading.length > 0 && !deps.closed()) {
+                const failed = await readHistories(reading);
+                if (failed?.kind === 'transport-uncertainty')
+                    progress.reachable = false;
+            }
+            if (behind.size > 0)
+                progress.complete = false;
+        },
+        current() {
+            return behind.size === 0;
+        },
+        reconnected() {
+            for (const conversation of replicated)
+                gap(conversation);
+        },
+        watch(conversation, options, deliver) {
+            const limit = limitOf(options);
+            const key = JSON.stringify([conversation, limit ?? null]);
+            const view = views.get(key) ?? {
                 conversation,
-                notify,
-                ready: false
+                limit,
+                watchers: new Set(),
+                messages: null,
             };
-            viewers.add(viewer);
-            if (first) {
-                live.set(conversation, new Set());
-                supersede(conversation);
-            }
-            hand();
-            void deps.durably(()=>Promise.resolve()).then(async ()=>{
-                if (deps.closed() || !viewers.has(viewer)) return;
-                viewer.ready = true;
-                viewer.notify(viewOf(conversation));
-                if (first) await fill(conversation, null);
-            }).catch(()=>{});
-            return ()=>{
-                if (!viewers.delete(viewer)) return;
-                if (!viewed().includes(conversation)) {
-                    growing.delete(conversation);
-                    live.delete(conversation);
-                }
-                hand();
+            views.set(key, view);
+            const watcher = { notify: deliver, ready: false };
+            view.watchers.add(watcher);
+            void deps
+                .durably(() => Promise.resolve())
+                .then(() => {
+                if (deps.closed() || !view.watchers.has(watcher))
+                    return;
+                watcher.ready = true;
+                watcher.notify(viewOf(conversation, limit));
+            })
+                .catch(() => { });
+            return () => {
+                if (!view.watchers.delete(watcher))
+                    return;
+                if (view.watchers.size === 0)
+                    views.delete(key);
             };
         },
-        receive (event) {
-            if (deps.closed() || !viewed().includes(event.conversation)) return;
-            if (event.kind === 'growing-text') {
-                growing.set(event.conversation, {
-                    turn: event.turn,
-                    text: event.text
-                });
-                emit(event.conversation);
+        changed(set) {
+            for (const conversation of set.conversations)
+                emit(conversation);
+        },
+        receive(event) {
+            if (deps.closed())
+                return;
+            const { conversation } = event;
+            if (event.kind === 'gap') {
+                if (replicated.has(conversation))
+                    gap(conversation);
+                const held = lives.get(conversation);
+                if (held === undefined)
+                    return;
+                lives.set(conversation, { ...QUIET, turn: held.turn });
+                emit(conversation, false);
+                return;
+            }
+            if (event.kind === 'turn') {
+                relayed(conversation, event.turn, event.operation);
+                return;
+            }
+            if (event.kind === 'questions') {
+                live(conversation, { questions: structuredClone(event.questions) });
+                return;
+            }
+            if (event.kind === 'process') {
+                live(conversation, { process: { running: event.running } });
                 return;
             }
-            if (event.kind === 'session-summary') {
-                const summary = structuredClone(event.summary);
-                void keep(event.conversation, (carried)=>({
-                        ...carried,
-                        summary
-                    })).catch(()=>{});
+            if (event.kind === 'commands') {
+                live(conversation, { commands: structuredClone(event.commands) });
                 return;
             }
-            const arriving = carriedMessage(event.message);
-            if (arriving === null) return;
-            live.get(event.conversation)?.add(arriving.turn);
-            if (growing.get(event.conversation)?.turn === arriving.turn) {
-                growing.delete(event.conversation);
+            if (event.kind === 'options') {
+                live(conversation, { options: structuredClone(event.options) });
+                return;
             }
-            void deps.durably(async (local)=>{
-                held.set(event.conversation, sealed(heldOf(event.conversation), arriving));
-                await local.keepConversation(keptRecord(event.conversation));
-                await settle(local, event.conversation);
-            }).then(()=>{
-                emit(event.conversation);
-            }).catch(()=>{});
+            const arriving = acceptedMessage(event.message);
+            if (arriving === null)
+                return;
+            if (replicated.has(conversation)) {
+                void keep(conversation, arriving).catch(() => { });
+                return;
+            }
+            if (sealTurns(conversation, new Set([arriving.turn])))
+                emit(conversation);
+        },
+        messages() {
+            return [...messages].flatMap(([conversation, held]) => held.map(({ identity, text }) => ({ conversation, identity, text })));
+        },
+        message(conversation, identity) {
+            const held = messages.get(conversation)?.find((message) => message.identity === identity);
+            return held === undefined ? null : { conversation, identity, text: held.text };
+        },
+        close() {
+            views.clear();
+            lives.clear();
         },
-        close () {
-            viewers.clear();
-            growing.clear();
-            live.clear();
-        }
     };
 }
-
-//# sourceMappingURL=conversation.js.map