@agentshouse/mdruntime 0.1.0-c1db74d14e5fa → 0.1.0-c1e540acf5f9d

package/dist/reach.js

@@ -1,10 +1,11 @@
+import { QueryError } from '@agentshouse/mdmodel';
+import { selected } from './collection.js';
 import { unheldView } from './conversation.js';
 import { modelTypes, NO_MODEL } from './model.js';
-import { applied, observing } from './observation.js';
-import { runtimeError } from './failure.js';
-import { failure, undeclared, } from './outcome.js';
+import { changeOf, digestApplied, digestOf, observing, } from './observation.js';
+import { runtimeError, uncaught } from './failure.js';
+import { failure, lockedRoom, ROOM_LOCKED, undeclared, UNREADABLE, } from './outcome.js';
 import { beneath } from './paths.js';
-import { reconciled } from './read-side.js';
 import { moveTarget, readParts, staleWrite, } from './room-draft.js';
 import { documentKey } from './rows.js';
 const UNHELD_TYPES = { collection: modelTypes(NO_MODEL), typedSelection: null };
@@ -14,18 +15,37 @@ function unconversed(name) {
 const NO_CONVERSATION = {
     list: () => Promise.resolve([]),
     read: (conversation) => Promise.resolve(unheldView(conversation)),
-    create: unconversed('conversation.create'),
-    send: unconversed('conversation.send'),
-    answer: unconversed('conversation.answer'),
-    interrupt: unconversed('conversation.interrupt'),
-    kill: unconversed('conversation.kill'),
-    cancel: unconversed('conversation.cancel'),
-    delete: unconversed('conversation.delete'),
+    create: unconversed('conversations/create'),
+    send: unconversed('conversations/send'),
+    answer: unconversed('conversations/interaction/answer'),
+    interrupt: unconversed('conversations/interrupt'),
+    kill: unconversed('conversations/kill'),
+    delete: unconversed('conversations/delete'),
+    takeOut: unconversed('conversations/take-out'),
+    decide: unconversed('agent-functions/decide'),
+    rename: unconversed('conversations/rename'),
+    option: unconversed('conversations/option/set'),
+    retry: unconversed('conversations/retry'),
+    pins: () => Promise.resolve([]),
+    pin: () => Promise.resolve(),
+    openedTurns: () => Promise.resolve({}),
+    openTurn: () => Promise.resolve(),
+    dismissSuggestion: () => Promise.resolve(),
 };
 const NO_CHAT_DRAFT = {
     write: () => Promise.resolve(),
+    prepend: () => Promise.resolve(),
+    append: () => Promise.resolve(),
     discard: () => Promise.resolve(),
 };
+function areasOf(reach) {
+    return reach.areas ?? [];
+}
+function fenced(reach, room, path) {
+    return areasOf(reach).some((area) => area.room === room &&
+        beneath(area.path, path) &&
+        !area.open.some((open) => beneath(open, path)));
+}
 export function holds(reach, room) {
     return (reach === null ||
         reach.rooms.includes(room) ||
@@ -38,33 +58,33 @@ export function governs(reach, room) {
     if (wholly(reach, room.locator)) {
         return { collection: true, selection: room.typedSelection !== null };
     }
-    const selected = (path) => room.typedSelection?.roots.some((root) => beneath(root, path)) ?? false;
+    const within = (path) => selected({ selection: room.typedSelection }, path);
     const paths = reach.documents
         .filter((document) => document.room === room.locator)
         .map(({ path }) => path);
-    return { collection: paths.some((path) => !selected(path)), selection: paths.some(selected) };
+    return { collection: paths.some((path) => !within(path)), selection: paths.some(within) };
 }
 function covers(reach, room, path) {
     return (reach === null ||
-        reach.rooms.includes(room) ||
-        reach.documents.some((document) => document.room === room && document.path === path));
+        (!fenced(reach, room, path) &&
+            (reach.rooms.includes(room) ||
+                reach.documents.some((document) => document.room === room && document.path === path))));
 }
 function conversing(reach) {
     return reach === null || reach.conversations;
 }
-function refers(reach, scope) {
-    if (reach === null)
-        return true;
-    if (scope === null)
-        return false;
-    if (scope.kind === 'conversations')
-        return reach.conversations;
-    return scope.path === undefined
-        ? wholly(reach, scope.locator)
-        : covers(reach, scope.locator, scope.path);
+function roomsAwaited(error, reach) {
+    return error.code === 'unknown-type' && reach !== null && reach.rooms.length === 0;
 }
-function unreachedReference(fileRef) {
-    return { kind: 'absent', code: 'binary-file-absent', fields: { fileRef }, retryable: false };
+async function planInReach(runtime, input, reach, answered) {
+    try {
+        return await runtime.plan(input, reach);
+    }
+    catch (error) {
+        if (error instanceof QueryError && (answered || roomsAwaited(error, reach)))
+            return null;
+        throw error;
+    }
 }
 export function planReach(reach) {
     return reach === null
@@ -74,6 +94,9 @@ export function planReach(reach) {
             documents: [
                 ...new Set(reach.documents.map(({ room, path }) => documentKey(room, path))),
             ].sort(),
+            areas: areasOf(reach)
+                .map(({ room, path, open }) => ({ room, path, open: [...new Set(open)].sort() }))
+                .sort((left, right) => documentKey(left.room, left.path) < documentKey(right.room, right.path) ? -1 : 1),
         };
 }
 function roomsWithin(reach, rooms) {
@@ -89,7 +112,7 @@ function typesWithin(reach, room, types) {
     };
 }
 function moves(reach, room, move) {
-    return move === undefined || covers(reach, room, moveTarget(move));
+    return move === undefined || covers(reach, move.room ?? room, moveTarget(move));
 }
 function draftWithin(reach, draft) {
     return covers(reach, draft.room, draft.path) && moves(reach, draft.room, draft.parts.move);
@@ -108,12 +131,13 @@ function writeWithin(reach, write) {
 function savedWithin(reach, room, result) {
     if (reach === null || result.outcome === 'saved')
         return result;
-    const { file, location, referrers, ...refusal } = result;
+    const { file, location, line, referrers, ...refusal } = result;
     const hidden = file !== undefined && !covers(reach, room, file);
     return {
         ...refusal,
         ...(file === undefined || hidden ? {} : { file }),
         ...(location === undefined || hidden ? {} : { location }),
+        ...(line === undefined || hidden ? {} : { line }),
         ...(referrers === undefined
             ? {}
             : { referrers: referrers.filter((path) => covers(reach, room, path)) }),
@@ -122,85 +146,195 @@ function savedWithin(reach, room, result) {
 function statusWithin(reach, status) {
     return {
         ...status,
-        attentionRequired: status.attentionRequired.filter((entry) => 'refusal' in entry ? wholly(reach, entry.room) : covers(reach, entry.room, entry.path)),
+        attentionRequired: status.attentionRequired.filter((entry) => covers(reach, entry.room, entry.path)),
+        unsent: status.unsent.filter((change) => covers(reach, change.room, change.path)),
     };
 }
 function queueWithin(reach, room, entries) {
-    return entries.filter(({ batch }) => batch.changes.every((change) => covers(reach, room, change.path) &&
-        (change.kind !== 'move' || covers(reach, room, change.to))));
+    return entries
+        .filter(({ batch }) => batch.changes.every((change) => covers(reach, room, change.path) &&
+        (change.kind !== 'move' || covers(reach, room, change.to))))
+        .map((entry) => {
+        const { between, ...batch } = entry.batch;
+        if (between === undefined)
+            return entry;
+        return wholly(reach, between.source.room) && wholly(reach, between.destination.room)
+            ? entry
+            : { ...entry, batch };
+    });
 }
 function unreached(room) {
-    return runtimeError('room-not-held', `No Local Replica for ${room}`);
+    return runtimeError('unknown-room', `Unknown Room ${room}`);
+}
+function lockedError(room) {
+    return runtimeError(ROOM_LOCKED, `${room} is locked until House confirms its access`, true);
 }
-export function narrowed(runtime, given, told) {
+function deviceUnreached() {
+    return runtimeError('device-unreached', 'Only the panel reaches this device');
+}
+const ATTACH_REQUIRED = 'attach-required';
+function attachRequired() {
+    return runtimeError(ATTACH_REQUIRED, 'App code takes a file in with binaryFile.attach');
+}
+function carriesFile(parts) {
+    return parts !== null && typeof parts === 'object' && Object.hasOwn(parts, 'file');
+}
+export function narrowed(runtime, given, port) {
     const { md, watch } = runtime;
     let reach = given;
-    let port = told;
     const open = new Set();
-    function following(begin) {
+    function following(begin, locking = false) {
         let stop = begin();
         const restart = () => {
             stop();
             stop = begin();
         };
         open.add(restart);
+        const unwatch = locking ? runtime.watchLocks(restart) : () => { };
         return () => {
             open.delete(restart);
+            unwatch();
             stop();
         };
     }
-    const within = (topic, input, deliver) => {
+    const unlocking = (rooms, locked) => {
+        const held = (rooms ?? []).filter((room) => locked.includes(room));
+        return held.length === 0 ? null : { pending: held.map((room) => ({ room, awaits: 'unlock' })) };
+    };
+    const unlocked = (entries, locked) => entries.filter((entry) => !locked.includes(entry.room));
+    const intoLocked = async (held) => {
+        for (const move of held) {
+            if (move?.room !== undefined && (await runtime.locked(move.room)))
+                return true;
+        }
+        return false;
+    };
+    function ordered(deliver) {
+        let open = true;
+        let shown = Promise.resolve();
+        return {
+            push(making) {
+                shown = shown.then(() => making.then((value) => {
+                    if (open)
+                        deliver(value);
+                }, uncaught), uncaught);
+            },
+            stop() {
+                open = false;
+            },
+        };
+    }
+    function unlockedWatch(topic, input, deliver, fail, within) {
+        const shown = ordered(deliver);
+        const stop = watch(topic, input, (message) => {
+            shown.push(runtime.lockedRooms().then((locked) => within(message, locked)));
+        }, fail);
+        return () => {
+            shown.stop();
+            stop();
+        };
+    }
+    function lockedFirst(room, start, shut) {
+        let open = true;
+        let stop = () => { };
+        void (async () => {
+            const closed = !holds(reach, room) || (await runtime.locked(room));
+            if (!open)
+                return;
+            if (closed)
+                shut();
+            else
+                stop = start();
+        })();
+        return () => {
+            open = false;
+            stop();
+        };
+    }
+    const within = (topic, input, deliver, fail) => {
+        if (topic === 'read' && reach !== null) {
+            fail(deviceUnreached());
+            return () => { };
+        }
         if (topic === 'rooms') {
-            return following(() => watch(topic, input, (rooms) => deliver(roomsWithin(reach, rooms))));
+            return following(() => watch(topic, input, (rooms) => deliver(roomsWithin(reach, rooms)), fail));
         }
         if (topic === 'readiness') {
             return following(() => runtime.watchReadiness(port, reach, deliver));
         }
         if (topic === 'sync-status') {
-            return following(() => watch(topic, input, (status) => deliver(statusWithin(reach, status))));
+            return following(() => unlockedWatch(topic, input, deliver, fail, (status, locked) => {
+                const shown = statusWithin(reach, status);
+                return { ...shown, attentionRequired: unlocked(shown.attentionRequired, locked) };
+            }), true);
         }
         if (topic === 'room-drafts') {
-            return following(() => watch(topic, input, (drafts) => deliver(draftsWithin(reach, drafts))));
+            return following(() => unlockedWatch(topic, input, deliver, fail, (drafts, locked) => unlocked(draftsWithin(reach, drafts), locked)), true);
         }
         if (topic === 'queue') {
             const room = input[0];
-            return following(() => {
-                if (!holds(reach, room)) {
-                    deliver([]);
-                    return () => { };
-                }
-                return watch(topic, input, (entries) => deliver(queueWithin(reach, room, entries)));
-            });
+            return following(() => lockedFirst(room, () => watch(topic, input, (entries) => deliver(queueWithin(reach, room, entries)), fail), () => deliver([])), true);
         }
         if (topic === 'query') {
-            const plan = runtime.plan(input[0], reach);
             let held = null;
+            let planning = null;
+            const waiting = (result) => {
+                const answer = { result, keys: [] };
+                if (held === null || changeOf(held, answer) !== null)
+                    deliver(answer);
+                held = digestOf(answer);
+            };
             return following(() => {
-                let first = true;
-                return runtime.watchPlan({ ...plan, reach: planReach(reach) }, (message) => {
-                    if (!first) {
-                        held = applied(held, message);
-                        deliver(message);
-                        return;
-                    }
-                    first = false;
-                    if (held === null) {
-                        held = message;
-                        deliver(message);
-                        return;
-                    }
-                    const next = reconciled(held, message);
-                    if (next === null)
+                let open = true;
+                let stop = () => { };
+                if (planning?.reach !== reach) {
+                    planning = { reach, plan: planInReach(runtime, input[0], reach, held !== null) };
+                }
+                const planned = planning.plan;
+                void (async () => {
+                    const plan = await planned;
+                    const locked = await runtime.lockedRooms();
+                    if (!open)
                         return;
-                    held = next.keyed;
-                    deliver(next.message);
+                    if (plan === null)
+                        return waiting({ pending: [] });
+                    const pending = unlocking(plan.rooms, locked);
+                    if (pending !== null)
+                        return waiting(pending);
+                    let first = true;
+                    const heard = (message) => {
+                        if (!first) {
+                            held = digestApplied(held, message);
+                            deliver(message);
+                            return;
+                        }
+                        first = false;
+                        const change = held === null ? message : changeOf(held, message);
+                        held = digestOf(message);
+                        if (change !== null)
+                            deliver(change);
+                    };
+                    stop = runtime.watchPlan({ ...plan, locked }, (message) => {
+                        if (open)
+                            heard(message);
+                    }, (error) => {
+                        if (open)
+                            fail(error);
+                    });
+                })().catch((error) => {
+                    if (open)
+                        fail(error);
                 });
-            });
+                return () => {
+                    open = false;
+                    stop();
+                };
+            }, true);
         }
         if (topic === 'conversation') {
             return following(() => {
                 if (conversing(reach))
-                    return watch(topic, input, deliver);
+                    return watch(topic, input, deliver, fail);
                 deliver(unheldView(input[0]));
                 return () => { };
             });
@@ -208,67 +342,160 @@ export function narrowed(runtime, given, told) {
         if (topic === 'conversations' || topic === 'agents') {
             return following(() => {
                 if (conversing(reach))
-                    return watch(topic, input, deliver);
+                    return watch(topic, input, deliver, fail);
                 deliver([]);
                 return () => { };
             });
         }
-        return watch(topic, input, deliver);
+        if (topic === 'figures' || topic === 'holdings' || topic === 'listed-agents') {
+            if (reach === null)
+                return watch(topic, input, deliver, fail);
+            fail(deviceUnreached());
+            return () => { };
+        }
+        return watch(topic, input, deliver, fail);
     };
+    const files = new Map();
+    let handed = 0;
+    async function hand(reading) {
+        const answer = await reading;
+        if (answer.kind !== 'binary')
+            return answer;
+        handed += 1;
+        const file = String(handed);
+        files.set(file, answer.file);
+        return { ...answer, file };
+    }
     const conversation = () => (conversing(reach) ? md.conversation : NO_CONVERSATION);
     const chatDraft = () => (conversing(reach) ? md.chatDraft : NO_CHAT_DRAFT);
     const view = {
         ...md,
-        rooms: () => roomsWithin(reach, md.rooms()),
-        query: ((input) => runtime.query(runtime.plan(input, reach))),
-        search(input) {
-            runtime.searching(port.target);
-            return runtime.search(input, reach);
-        },
-        types(room) {
+        rooms: () => md.rooms().then((rooms) => roomsWithin(reach, rooms)),
+        query: (async (input) => {
+            const plan = await planInReach(runtime, input, reach, false);
+            if (plan === null)
+                return { pending: [] };
+            const locked = await runtime.lockedRooms();
+            return unlocking(plan.rooms, locked) ?? runtime.query({ ...plan, locked });
+        }),
+        search: (input) => runtime.search(input, reach),
+        async types(room) {
+            if (holds(reach, room) && (await runtime.locked(room)))
+                throw lockedError(room);
             if (wholly(reach, room))
                 return md.types(room);
             if (!holds(reach, room))
                 return structuredClone(UNHELD_TYPES);
-            const listed = md.rooms().find(({ locator }) => locator === room);
-            return typesWithin(reach, listed, md.types(room));
+            return typesWithin(reach, await runtime.room(room), await md.types(room));
         },
         async save(room, roomDrafts, writtenBy) {
             if (!holds(reach, room))
                 throw unreached(room);
-            const outside = roomDrafts.find(({ path }) => !covers(reach, room, path) ||
-                !moves(reach, room, md.roomDraft.read(room, path)?.parts.move));
+            if (await runtime.locked(room)) {
+                return { outcome: 'refused', code: ROOM_LOCKED, retryable: true };
+            }
+            const held = (await Promise.all(roomDrafts.map(({ path }) => md.roomDraft.read(room, path)))).map((draft) => draft?.parts.move);
+            const outside = roomDrafts.find(({ path }, at) => !covers(reach, room, path) || !moves(reach, room, held[at]));
             if (outside !== undefined) {
                 return { outcome: 'refused', code: 'stale', retryable: false, file: outside.path };
             }
+            if (await intoLocked(held))
+                return { outcome: 'refused', code: ROOM_LOCKED, retryable: true };
             return savedWithin(reach, room, await md.save(room, roomDrafts, writtenBy));
         },
-        history: (room, path, query) => covers(reach, room, path)
-            ? md.history(room, path, query)
-            : Promise.resolve(failure({ kind: 'room-not-readable', locator: room })),
+        async saveParts(room, parts, writtenBy) {
+            if (!holds(reach, room))
+                throw unreached(room);
+            const filed = reach === null ? undefined : parts.find(({ parts: one }) => carriesFile(one));
+            if (filed !== undefined) {
+                return { outcome: 'refused', code: ATTACH_REQUIRED, retryable: false, file: filed.path };
+            }
+            if (await runtime.locked(room)) {
+                return { outcome: 'refused', code: ROOM_LOCKED, retryable: true };
+            }
+            const held = parts.map(({ path, parts: one }) => readParts(one, path).move);
+            if (parts.some(({ path }, at) => !covers(reach, room, path) || !moves(reach, room, held[at]))) {
+                throw unreached(room);
+            }
+            if (await intoLocked(held))
+                return { outcome: 'refused', code: ROOM_LOCKED, retryable: true };
+            return savedWithin(reach, room, await md.saveParts(room, parts, writtenBy));
+        },
+        async resolve(room, path, destination) {
+            const at = await runtime.located(room, path, destination);
+            return at !== null && !covers(reach, at.room, at.path)
+                ? UNREADABLE
+                : md.resolve(room, path, destination);
+        },
+        history: async (room, path, query) => !covers(reach, room, path)
+            ? failure({ kind: 'room-not-readable', locator: room })
+            : (await runtime.locked(room))
+                ? lockedRoom(room)
+                : md.history(room, path, query),
         binaryFile: {
-            read: (room, path, revision) => covers(reach, room, path)
-                ? md.binaryFile.read(room, path, revision)
-                : Promise.resolve(failure({ kind: 'room-not-readable', locator: room })),
-            readReference: (reference) => refers(reach, runtime.referrerScope(reference.referrer))
-                ? md.binaryFile.readReference(reference)
-                : Promise.resolve(unreachedReference(reference.fileRef)),
+            read: async (room, path, revision) => !covers(reach, room, path)
+                ? failure({ kind: 'room-not-readable', locator: room })
+                : (await runtime.locked(room))
+                    ? lockedRoom(room)
+                    : hand(md.binaryFile.read(room, path, revision)),
+            link: async (room, path, revision) => !covers(reach, room, path)
+                ? failure({ kind: 'room-not-readable', locator: room })
+                : (await runtime.locked(room))
+                    ? lockedRoom(room)
+                    : md.binaryFile.link(room, path, revision),
+            show: async (room, path, revision) => !covers(reach, room, path)
+                ? failure({ kind: 'room-not-readable', locator: room })
+                : (await runtime.locked(room))
+                    ? lockedRoom(room)
+                    : hand(md.binaryFile.show(room, path, revision)),
+            attach: async (room, file) => !wholly(reach, room)
+                ? failure({ kind: 'room-not-readable', locator: room })
+                : (await runtime.locked(room))
+                    ? lockedRoom(room)
+                    : md.binaryFile.attach(room, file),
+            async part(file, part) {
+                const key = files.get(file);
+                if (key === undefined)
+                    return null;
+                const bytes = await md.binaryFile.part(key, part);
+                if (bytes === null)
+                    files.delete(file);
+                return bytes;
+            },
         },
-        reached: (room, roomVersion, path) => (path === undefined ? wholly(reach, room) : covers(reach, room, path)) &&
-            md.reached(room, roomVersion, path),
-        log: () => (reach === null ? md.log() : ''),
+        reached: async (room, roomVersion, path) => (path === undefined ? wholly(reach, room) : covers(reach, room, path)) &&
+            !(await runtime.locked(room)) &&
+            (await md.reached(room, roomVersion, path)),
+        cleanUp: () => (reach === null ? md.cleanUp() : Promise.reject(deviceUnreached())),
+        unsent: () => (reach === null ? md.unsent() : Promise.reject(deviceUnreached())),
+        reset: () => (reach === null ? md.reset() : Promise.reject(deviceUnreached())),
+        readAgain: () => (reach === null ? md.readAgain() : Promise.reject(deviceUnreached())),
         roomDraft: {
-            list: () => md.roomDraft.list().then((drafts) => draftsWithin(reach, drafts)),
-            read: (room, path) => covers(reach, room, path) ? shownDraft(reach, md.roomDraft.read(room, path)) : null,
-            async write(room, path, revision, parts) {
-                if (!covers(reach, room, path) || !moves(reach, room, readParts(parts).move)) {
+            list: async () => unlocked(draftsWithin(reach, await md.roomDraft.list()), await runtime.lockedRooms()),
+            async read(room, path) {
+                if (!covers(reach, room, path))
+                    return null;
+                if (await runtime.locked(room))
+                    throw lockedError(room);
+                return shownDraft(reach, await md.roomDraft.read(room, path));
+            },
+            async write(room, path, revision, parts, next) {
+                if (reach !== null && carriesFile(parts))
+                    throw attachRequired();
+                const move = readParts(parts, path).move;
+                if (!covers(reach, room, path) || !moves(reach, room, move))
                     throw unreached(room);
-                }
-                return writeWithin(reach, await md.roomDraft.write(room, path, revision, parts));
+                if (await runtime.locked(room))
+                    throw lockedError(room);
+                if (await intoLocked([move]))
+                    throw lockedError(move.room);
+                return writeWithin(reach, await md.roomDraft.write(room, path, revision, parts, next));
             },
             async discard(room, path, revision) {
                 if (!covers(reach, room, path))
                     return staleWrite(null);
+                if (await runtime.locked(room))
+                    throw lockedError(room);
                 return writeWithin(reach, await md.roomDraft.discard(room, path, revision));
             },
         },
@@ -277,14 +504,25 @@ export function narrowed(runtime, given, told) {
             read: (id, options) => conversation().read(id, options),
             create: (input) => conversation().create(input),
             send: (id, operation, draft) => conversation().send(id, operation, draft),
-            answer: (id, answer) => conversation().answer(id, answer),
-            interrupt: (id) => conversation().interrupt(id),
-            kill: (id) => conversation().kill(id),
-            cancel: (id, turn) => conversation().cancel(id, turn),
-            delete: (id) => conversation().delete(id),
+            answer: (id, answer, operation) => conversation().answer(id, answer, operation),
+            interrupt: (id, operation) => conversation().interrupt(id, operation),
+            kill: (id, operation) => conversation().kill(id, operation),
+            delete: (id, operation) => conversation().delete(id, operation),
+            takeOut: (id, message, operation) => conversation().takeOut(id, message, operation),
+            decide: (request, decision, operation) => conversation().decide(request, decision, operation),
+            rename: (id, name, operation) => conversation().rename(id, name, operation),
+            option: (id, option, value, operation) => conversation().option(id, option, value, operation),
+            retry: (id, message, operation) => conversation().retry(id, message, operation),
+            pins: () => conversation().pins(),
+            pin: (figures) => conversation().pin(figures),
+            openedTurns: () => conversation().openedTurns(),
+            openTurn: (id, turn) => conversation().openTurn(id, turn),
+            dismissSuggestion: (id, suggestion) => conversation().dismissSuggestion(id, suggestion),
         },
         chatDraft: {
             write: (id, draft, revision) => chatDraft().write(id, draft, revision),
+            prepend: (id, draft) => chatDraft().prepend(id, draft),
+            append: (id, draft) => chatDraft().append(id, draft),
             discard: (id) => chatDraft().discard(id),
         },
         observe: observing(within),
@@ -297,10 +535,5 @@ export function narrowed(runtime, given, told) {
             for (const restart of [...open])
                 restart();
         },
-        facts(next) {
-            port = next;
-            for (const restart of [...open])
-                restart();
-        },
     };
 }

package/dist/react.d.ts

@@ -1,10 +1,17 @@
+import type { DocumentQuery, GroupQuery } from '@agentshouse/mdmodel';
+import type { Acting, Lane, LaneShown } from './act-lanes.js';
 import type { MdRuntimeClient } from './client.js';
-import type { AppRoom, ConnectionRefusal, SaveResult } from './connection.js';
-import type { Member, ServiceMode } from './adapter.js';
+import type { AppRoom } from './listing.js';
+import type { ConnectionRefusal } from './socket.js';
+import type { SavedRoomDraft, SaveResult } from './saves.js';
+import type { ListedAgent, Member, ServiceMode } from './adapter.js';
 import type { ConversationAgent, ConversationEntry, ConversationOptions, ConversationView } from './conversation.js';
 import { type RuntimeError } from './failure.js';
+import type { FiguresResult } from './figures.js';
+import type { Holdings } from './holdings.js';
+import type { Descriptor, Expecting } from './expectation.js';
 import type { QueueEntry } from './outcome.js';
-import type { DocumentQuery, DocumentResult, GroupQuery, GroupResult, PendingResult } from './query.js';
+import type { DocumentResult, GroupResult, PendingResult } from './query.js';
 import type { Readiness } from './readiness.js';
 import type { RoomDraft, RoomDraftParts } from './room-draft.js';
 import type { SyncStatus } from './status.js';
@@ -23,6 +30,7 @@ export declare function useObserve(client: Client, topic: 'storage-loss'): Obser
 export declare function useObserve(client: Client, topic: 'sync-status'): Observed<SyncStatus>;
 export declare function useObserve(client: Client, topic: 'service-mode'): Observed<ServiceMode>;
 export declare function useObserve(client: Client, topic: 'member'): Observed<Member | null>;
+export declare function useObserve(client: Client, topic: 'authority-changes'): Observed<number>;
 export declare function useObserve(client: Client, topic: 'query', query: DocumentQuery): Observed<DocumentResult | PendingResult>;
 export declare function useObserve(client: Client, topic: 'query', query: GroupQuery): Observed<GroupResult | PendingResult>;
 export declare function useObserve(client: Client, topic: 'queue', locator: string): Observed<readonly QueueEntry[]>;
@@ -31,13 +39,19 @@ export declare function useObserve(client: Client, topic: 'presentation'): Obser
 export declare function useObserve(client: Client, topic: 'conversation', conversation: string, options: ConversationOptions): Observed<ConversationView>;
 export declare function useObserve(client: Client, topic: 'conversations'): Observed<readonly ConversationEntry[]>;
 export declare function useObserve(client: Client, topic: 'agents'): Observed<readonly ConversationAgent[]>;
+export declare function useObserve(client: Client, topic: 'listed-agents'): Observed<readonly ListedAgent[]>;
+export declare function useObserve(client: Client, topic: 'figures'): Observed<FiguresResult>;
+export declare function useObserve(client: Client, topic: 'holdings'): Observed<Holdings>;
+export declare function useExpected<A, T>(store: Expecting, descriptor: Descriptor<A, T>, places: readonly A[], held: ReadonlyMap<A, T> | null): (place: A, held: T) => T;
+export type LaneHeld<O> = LaneShown<O> & Pick<Lane<O>, 'run' | 'forget'>;
+export declare function useLane<O>(lanes: Acting<O>): LaneHeld<O>;
 export type Saving = {
     readonly busy: boolean;
     readonly outcome: SaveResult | null;
     readonly failure: RuntimeError | null;
-    save(room: string, roomDrafts: ReadonlyMap<string, RoomDraftParts>): Promise<SaveResult>;
+    save(room: string, parts: ReadonlyMap<string, RoomDraftParts>): Promise<SaveResult>;
+    saveWritten(room: string, roomDrafts: readonly SavedRoomDraft[]): Promise<SaveResult>;
 };
-export declare function saveRoomDrafts(client: MdRuntimeClient, room: string, roomDrafts: ReadonlyMap<string, RoomDraftParts>): Promise<SaveResult>;
 export declare function useSave(client: MdRuntimeClient): Saving;
 export {};
 //# sourceMappingURL=react.d.ts.map