@agentshouse/mdruntime 0.1.0-cf04ede9fb796 → 0.1.0-cf0c43fc48aad

package/dist/queue.js

@@ -0,0 +1,450 @@
+import { changeSet, mergeChangeSets } from './change-set.js';
+import { leaving as leavingIn, partnerOf } from './change.js';
+import { composedOf, definitionsAt } from './collection.js';
+import { declared } from './declaration.js';
+import { runtimeError } from './failure.js';
+import { roomDraftRevision } from './identity.js';
+import { landed, movedBy, overlayOf, replaying, slicing, slicingWith, standing, storedRecord, touchedBy, } from './replica.js';
+import { returnedBy, returnedInto } from './room-draft.js';
+import { documentKey } from './rows.js';
+import { stepped } from './turn.js';
+export function withdrawable(states) {
+    return (batch) => {
+        const state = states.get(batch.id);
+        return state !== undefined && state.submission.state !== 'submitted' && !state.lost;
+    };
+}
+export async function sliceAt(store, record, view, queue, extra = [], moved = []) {
+    const local = await store.open();
+    const needed = new Set([...touchedBy(queue), ...extra]);
+    const movedPaths = [...new Set([...movedBy(queue, record.locator), ...moved])];
+    if (movedPaths.length > 0) {
+        for (const { path } of await local.referrers(record.key, view, movedPaths)) {
+            needed.add(path);
+        }
+    }
+    const paths = [...needed];
+    return stepped(slicing(await local.entries(record.key, view, paths), paths));
+}
+async function landedWhole(store, record, batch, confirmedLayer, current) {
+    if (!landed(batch, confirmedLayer, store.composed(record), current))
+        return false;
+    const partner = partnerOf(batch, record.locator);
+    if (partner === null)
+        return true;
+    const other = await store.replica(partner);
+    const half = other?.queue.find((one) => one.id === batch.id);
+    if (other === undefined || half === undefined)
+        return false;
+    return landed(half, await sliceAt(store, other.record, 'confirmed', [half]), store.composed(other.record));
+}
+async function returnedDrafts(store, locator, work, leaving, composition) {
+    const written = new Map();
+    for (const { batch, returned } of leaving) {
+        if (returned === null || batch.between?.destination.room === locator)
+            continue;
+        for (const saved of work.states.get(batch.id)?.drafts ?? []) {
+            const existing = written.get(saved.path) ?? (await store.draft(locator, saved.path));
+            const parts = returnedInto(existing?.parts, saved.parts, composition === undefined ? undefined : definitionsAt(composition, saved.path));
+            written.set(saved.path, parts === null
+                ? { ...existing, returned }
+                : { locator, path: saved.path, revision: roomDraftRevision(), parts, returned });
+        }
+    }
+    return written;
+}
+function unheldComposition({ store, presence }, locator) {
+    const model = presence.unheldModel(locator);
+    const listed = presence.room(locator);
+    if (model === null || listed === undefined)
+        return undefined;
+    return store.composed({ model, declaration: declared(listed) });
+}
+async function carriedBack(runtime, locator, unlanded, written) {
+    const { store } = runtime;
+    const back = new Map();
+    const taken = [];
+    for (const batch of unlanded) {
+        const between = batch.between;
+        if (between === undefined)
+            continue;
+        const source = between.source.room;
+        const destination = between.destination.room;
+        const local = await store.open();
+        const arrived = (await local.pending(destination, batch.id)).state?.drafts ?? [];
+        for (const { path: to } of arrived) {
+            const record = await store.draft(destination, to);
+            const path = between.moves.find((move) => move.to === to)?.path;
+            if (record === undefined || path === undefined)
+                continue;
+            const [into, key] = source === locator ? [written, path] : [back, documentKey(source, path)];
+            const existing = into.get(key) ?? (await store.draft(source, path));
+            const held = await store.record(source);
+            const composition = held === undefined ? unheldComposition(runtime, source) : store.composed(held);
+            const parts = returnedInto(existing?.parts, record.parts, composition === undefined ? undefined : definitionsAt(composition, path));
+            if (parts === null)
+                continue;
+            taken.push({ locator: destination, path: to });
+            into.set(key, {
+                locator: source,
+                path,
+                revision: roomDraftRevision(),
+                parts,
+                returned: existing?.returned ?? null,
+            });
+        }
+    }
+    const records = [...back.values()];
+    const elsewhere = taken.filter((one) => one.locator !== locator);
+    const rooms = new Set([...records, ...elsewhere].map((one) => one.locator));
+    return {
+        taken: taken.filter((one) => one.locator === locator).map(({ path }) => path),
+        writes: [...rooms].map((room) => ({
+            locator: room,
+            roomDrafts: records.filter((record) => record.locator === room),
+            consumedRoomDrafts: elsewhere.filter((one) => one.locator === room).map(({ path }) => path),
+        })),
+        changes: [...rooms].map((room) => changeSet(room, {
+            drafts: [...records, ...elsewhere]
+                .filter((one) => one.locator === room)
+                .map(({ path }) => path),
+        })),
+    };
+}
+function confirmedAgain(store, locator) {
+    store.installs.change(locator, (held) => ({
+        ...held,
+        confirmations: held.confirmations + 1,
+    }));
+}
+function replayed(store, record, confirmedLayer, queue) {
+    return stepped(replaying(confirmedLayer, queue, record.locator, store.composed(record)));
+}
+async function overlayDiff(record, before, visible, touched) {
+    const kept = before !== undefined && before.record.key === record.key ? before.overlaid : new Set();
+    return {
+        overlay: {
+            set: await stepped(overlayOf(visible, touched)),
+            cleared: [...kept].filter((path) => !touched.has(path)),
+        },
+        touched,
+    };
+}
+function unsent(state, batch, locator) {
+    if (state === undefined)
+        return false;
+    return !leavingIn(batch, locator) || withdrawable(new Map([[batch.id, state]]))(batch);
+}
+async function together(runtime, local, settlements) {
+    const settled = new Set(settlements.map(({ locator }) => locator));
+    const all = [...settlements];
+    for (let wave = settlements; wave.length > 0;) {
+        const partnered = new Map();
+        for (const { locator, left } of wave) {
+            for (const batch of left) {
+                const partner = partnerOf(batch, locator);
+                if (partner === null ||
+                    settled.has(partner) ||
+                    !unsent((await local.pending(partner, batch.id)).state, batch, partner)) {
+                    continue;
+                }
+                partnered.set(partner, [...(partnered.get(partner) ?? []), batch]);
+            }
+        }
+        const partners = [];
+        for (const [partner, batches] of partnered) {
+            settled.add(partner);
+            partners.push(await unpairing(runtime, local, partner, batches));
+        }
+        all.push(...partners);
+        wave = partners;
+    }
+    const answer = await local.commit({
+        rooms: all.flatMap(({ commit }) => commit.rooms),
+        writes: all.flatMap(({ commit }) => commit.writes),
+    });
+    return mergeChangeSets(all.map((one) => one.apply(answer)));
+}
+async function settlement(runtime, local, locator, work, record, queue, settling = {}) {
+    const { store, localSaves } = runtime;
+    const before = work.replica;
+    const view = settling.view ?? 'confirmed';
+    const previousQueue = work.queue;
+    const overrides = settling.changes;
+    const read = await sliceAt(store, record, view, queue, [
+        ...(before !== undefined && before.record.key === record.key ? before.overlaid : []),
+        ...(overrides?.set.map(({ path }) => path) ?? []),
+        ...(overrides?.removed ?? []),
+    ]);
+    const confirmedLayer = overrides === undefined
+        ? read
+        : await stepped(slicingWith(read, overrides.set, overrides.removed));
+    const composition = store.composed(record);
+    const shown = queue.filter((batch) => {
+        const held = store.landed.of(locator, batch.id);
+        return (held !== undefined &&
+            Object.entries(held).some(([path, revision]) => confirmedLayer.revisions[path] !== revision));
+    });
+    const unshown = queue.filter((batch) => !shown.includes(batch));
+    const { withdrawn, kept } = await stepped(standing(confirmedLayer, unshown, withdrawable(work.states), localSaves, locator, composition));
+    const founded = kept.filter((batch) => !unshown.includes(batch));
+    const queueChanged = kept.length !== previousQueue.length || founded.length > 0;
+    const unqueued = shown.map((batch) => ({ batch, landed: true }));
+    for (const batch of withdrawn) {
+        unqueued.push({ batch, landed: await landedWhole(store, record, batch, confirmedLayer) });
+    }
+    const returning = [
+        ...[...unqueued].reverse().map(({ batch, landed: held }) => ({
+            batch,
+            returned: localSaves || held ? null : returnedBy(),
+        })),
+        ...(settling.leaving ?? []),
+    ];
+    const written = await returnedDrafts(store, locator, work, returning, composition);
+    const carried = await carriedBack(runtime, locator, [
+        ...[...unqueued].reverse().flatMap(({ batch, landed: held }) => (held ? [] : [batch])),
+        ...(settling.leaving ?? []).flatMap(({ batch, returned }) => returned === null ? [] : [batch]),
+    ], written);
+    const replayedLayer = await replayed(store, record, confirmedLayer, kept);
+    const { overlay } = await overlayDiff(record, before, replayedLayer.visible, replayedLayer.touched);
+    const commit = {
+        rooms: [
+            {
+                locator,
+                key: record.key,
+                record: storedRecord(record),
+                roots: record.declaration.typedSelection?.roots ?? [],
+                composed: composedOf(composition),
+                ...settling.commit,
+                ...(overrides === undefined
+                    ? {}
+                    : { confirmed: { set: overrides.set, removed: overrides.removed } }),
+                overlay,
+            },
+        ],
+        writes: [
+            {
+                locator,
+                queue: kept,
+                stored: previousQueue,
+                founded,
+                roomDrafts: [...written.values()],
+                consumedRoomDrafts: carried.taken,
+            },
+            ...carried.writes,
+        ],
+    };
+    const staying = new Set(kept.map((batch) => batch.id));
+    return {
+        locator,
+        left: previousQueue.filter((batch) => !staying.has(batch.id)),
+        commit,
+        apply: (answer) => {
+            for (const batch of previousQueue) {
+                if (!staying.has(batch.id))
+                    store.landed.drop(locator, batch.id);
+            }
+            const drafts = [...written.keys(), ...carried.taken];
+            const changed = answer.changed[locator];
+            if (settling.commit?.published !== undefined ||
+                settling.commit?.refreshed === true ||
+                overrides !== undefined) {
+                confirmedAgain(store, locator);
+            }
+            return mergeChangeSets([
+                changeSet(locator, {
+                    documents: changed === undefined ? [] : changed,
+                    room: settling.room,
+                    queue: queueChanged,
+                    drafts,
+                    unindexed: answer.indexed[locator] === false,
+                    due: kept.length > 0 && settling.refused !== true,
+                }),
+                ...carried.changes,
+            ]);
+        },
+    };
+}
+async function unpairing(runtime, local, locator, batches) {
+    const { store, localSaves } = runtime;
+    const ids = new Set(batches.map(({ id }) => id));
+    const leaving = batches.map((batch) => ({
+        batch,
+        returned: !localSaves && leavingIn(batch, locator) ? returnedBy() : null,
+    }));
+    const work = await store.work(locator);
+    const current = work.replica;
+    if (current !== undefined) {
+        return settlement(runtime, local, locator, work, current.record, current.queue.filter((one) => !ids.has(one.id)), { leaving });
+    }
+    const queue = work.queue.filter((one) => !ids.has(one.id));
+    const written = await returnedDrafts(store, locator, work, leaving, unheldComposition(runtime, locator));
+    const carried = await carriedBack(runtime, locator, leaving.flatMap(({ batch, returned }) => (returned === null ? [] : [batch])), written);
+    return {
+        locator,
+        left: batches,
+        commit: {
+            rooms: [],
+            writes: [
+                {
+                    locator,
+                    queue,
+                    stored: work.queue,
+                    roomDrafts: [...written.values()],
+                    consumedRoomDrafts: carried.taken,
+                },
+                ...carried.writes,
+            ],
+        },
+        apply() {
+            return mergeChangeSets([
+                changeSet(locator, {
+                    queue: true,
+                    drafts: [...written.keys(), ...carried.taken],
+                    due: queue.length > 0,
+                }),
+                ...carried.changes,
+            ]);
+        },
+    };
+}
+async function orphaned(local) {
+    const { queued, moving } = await local.moving();
+    const halves = new Map();
+    for (const { locator, batch, state } of moving) {
+        const partner = partnerOf(batch, locator);
+        if (partner === null || queued.get(partner)?.includes(batch.id) === true)
+            continue;
+        if (unsent(state, batch, locator))
+            halves.set(locator, [...(halves.get(locator) ?? []), batch]);
+    }
+    return halves;
+}
+async function sweep(runtime, local) {
+    if (!runtime.socket.continuing())
+        return;
+    const halves = await orphaned(local);
+    if (halves.size === 0)
+        return;
+    const settlements = [];
+    for (const [locator, batches] of halves) {
+        settlements.push(await unpairing(runtime, local, locator, batches));
+    }
+    void runtime.store.changed(await together(runtime, local, settlements));
+}
+async function settled(runtime, local, settlements, steps) {
+    const set = await together(runtime, local, settlements);
+    for (const step of steps)
+        step();
+    void runtime.store.changed(set);
+    await sweep(runtime, local);
+}
+export function settle(runtime, locators, decide) {
+    const { store } = runtime;
+    return store.exclusive(async () => {
+        const local = await store.open();
+        const held = new Map();
+        for (const locator of locators)
+            held.set(locator, await store.work(locator));
+        const decided = await decide(held);
+        if (decided.length === 0)
+            return;
+        const settlements = [];
+        for (const { locator, record, accepted, adopted, installed, refused } of decided) {
+            const work = held.get(locator) ?? (await store.work(locator));
+            settlements.push(await settlement(runtime, local, locator, work, record, work.queue.filter((batch) => batch.id !== accepted), {
+                room: true,
+                view: installed?.refreshed === true ? 'refreshed' : 'confirmed',
+                ...(installed === undefined ? {} : { commit: installed }),
+                ...(adopted === undefined ? {} : { changes: adopted }),
+                ...(refused === undefined ? {} : { refused }),
+            }));
+        }
+        await settled(runtime, local, settlements, decided.flatMap(({ after }) => (after === undefined ? [] : [after])));
+    });
+}
+export function answered(runtime, locator, head, answer) {
+    const { store, socket } = runtime;
+    return store.exclusive(async () => {
+        if (!socket.continuing())
+            return;
+        const local = await store.open();
+        const work = await store.work(locator);
+        const current = work.replica;
+        if (current === undefined || !current.queue.some((batch) => batch.id === head.id))
+            return;
+        const confirmedLayer = await sliceAt(store, current.record, 'confirmed', [head]);
+        const held = answer.kind === 'conflicted' &&
+            (await landedWhole(store, current.record, head, confirmedLayer, answer.affected));
+        if (held &&
+            partnerOf(head, locator) === null &&
+            !landed(head, confirmedLayer, store.composed(current.record))) {
+            store.landed.hold(locator, head.id, Object.fromEntries([...touchedBy([head])].map((path) => [path, confirmedLayer.revisions[path]])));
+            return;
+        }
+        const returned = {
+            kind: answer.kind,
+            code: answer.code,
+            fields: answer.fields,
+            retryable: answer.retryable,
+        };
+        await settled(runtime, local, [
+            await settlement(runtime, local, locator, work, current.record, current.queue.filter((batch) => batch.id !== head.id), { leaving: [{ batch: head, returned: held ? null : returned }] }),
+        ], []);
+    });
+}
+export function unpair(runtime) {
+    return runtime.store.durably((local) => sweep(runtime, local));
+}
+export async function append(runtime, appending) {
+    const { plan, files, held, after } = appending;
+    if (plan.kind === 'refused')
+        return { outcome: 'refused', ...plan.refusal };
+    const { store } = runtime;
+    const local = await store.open();
+    const rooms = [];
+    const writes = [];
+    for (const { locator, queue, saved, consumed, carried } of plan.rooms) {
+        const { replica, confirmed } = held.get(locator);
+        const { record } = replica;
+        const replayedLayer = await replayed(store, record, confirmed, queue);
+        const { overlay } = await overlayDiff(record, replica, replayedLayer.visible, replayedLayer.touched);
+        rooms.push({
+            locator,
+            key: record.key,
+            roots: record.declaration.typedSelection?.roots ?? [],
+            composed: composedOf(store.composed(record)),
+            overlay,
+        });
+        writes.push({
+            locator,
+            queue,
+            stored: replica.queue,
+            saved,
+            consumedRoomDrafts: consumed,
+            roomDrafts: carried,
+        });
+    }
+    let answer;
+    try {
+        answer = await local.commit({ rooms, writes, files, whole: true });
+    }
+    catch {
+        return { outcome: 'refused', code: 'durable-write', retryable: true };
+    }
+    const lost = answer.fenced ?? plan.rooms.find(({ locator }) => runtime.presence.lost(locator))?.locator;
+    if (lost !== undefined)
+        throw runtimeError('unknown-room', `Unknown Room ${lost}`);
+    const [saving] = plan.rooms;
+    await Promise.all([
+        store.changed(mergeChangeSets(plan.rooms.map(({ locator, consumed, carried }) => changeSet(locator, {
+            documents: answer.changed[locator] ?? [],
+            queue: true,
+            drafts: [...consumed, ...carried.map(({ path }) => path)],
+            unindexed: answer.indexed[locator] === false,
+            due: locator === saving?.locator,
+        })))),
+        after?.(),
+    ]);
+    return { outcome: 'saved', identifier: plan.identifier };
+}

package/dist/reach.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reach.d.ts","sourceRoot":"","sources":["../src/reach.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"reach.d.ts","sourceRoot":"","sources":["../src/reach.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,KAAK,EAAE,SAAS,EAAe,YAAY,EAAE,MAAM,cAAc,CAAC;AA4BzE,OAAO,KAAK,EAAiB,IAAI,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAS9E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAGhD,MAAM,MAAM,eAAe,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAE/E,MAAM,MAAM,WAAW,GAAG;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,SAAS,EAAE,SAAS,eAAe,EAAE,CAAC;IAC/C,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,WAAW,EAAE,CAAC;IACxC,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,OAAO,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;AAIjD,MAAM,MAAM,IAAI,GAAG,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;AAE5C,MAAM,MAAM,KAAK,GAAG,CAClB,KAAK,EAAE,YAAY,EACnB,KAAK,EAAE,SAAS,OAAO,EAAE,EACzB,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,IAAI,KACP,MAAM,IAAI,CAAC;AAEhB,MAAM,MAAM,WAAW,GAAG;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,KAAK,CAAA;CAAE,CAAC;AAE1D,MAAM,MAAM,YAAY,GAAG,WAAW,GAAG;IACvC,MAAM,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI,GAAG,IAAI,CAAC;CACvC,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG,WAAW,GAAG;IACpC,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,SAAS,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7D,KAAK,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;IACxC,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,GAAG,MAAM,IAAI,CAAC;IAChE,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,SAAS,GAAG,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;IACvE,cAAc,CACZ,IAAI,EAAE,aAAa,EACnB,KAAK,EAAE,SAAS,GAAG,IAAI,EACvB,OAAO,EAAE,CAAC,SAAS,EAAE,SAAS,KAAK,IAAI,GACtC,MAAM,IAAI,CAAC;IACd,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACvC,WAAW,IAAI,OAAO,CAAC,SAAS,MAAM,EAAE,CAAC,CAAC;IAC1C,UAAU,CAAC,MAAM,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC;IAC3C,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAAC;IAC1F,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,GAAG,SAAS,CAAC,CAAC;CACrD,CAAC;AAiDF,wBAAgB,KAAK,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAMpE;AAMD,wBAAgB,OAAO,CACrB,KAAK,EAAE,SAAS,GAAG,IAAI,EACvB,IAAI,EAAE;IAAE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,cAAc,EAAE;QAAE,KAAK,EAAE,SAAS,MAAM,EAAE,CAAA;KAAE,GAAG,IAAI,CAAA;CAAE,GAC/F;IAAE,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;CAAE,CAS/D;AAiCD,wBAAgB,SAAS,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI,CAcnE;AA4GD,wBAAgB,QAAQ,CACtB,OAAO,EAAE,SAAS,EAClB,KAAK,EAAE,SAAS,GAAG,IAAI,EACvB,IAAI,EAAE,aAAa,GAClB,YAAY,CA6Yd"}

package/dist/reach.js

@@ -1,7 +1,9 @@
+import { QueryError } from '@agentshouse/mdmodel';
+import { selected } from './collection.js';
 import { unheldView } from './conversation.js';
 import { modelTypes, NO_MODEL } from './model.js';
 import { changeOf, digestApplied, digestOf, observing, } from './observation.js';
-import { runtimeError } from './failure.js';
+import { runtimeError, uncaught } from './failure.js';
 import { failure, lockedRoom, ROOM_LOCKED, undeclared, UNREADABLE, } from './outcome.js';
 import { beneath } from './paths.js';
 import { moveTarget, readParts, staleWrite, } from './room-draft.js';
@@ -19,10 +21,21 @@ const NO_CONVERSATION = {
     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) {
@@ -45,11 +58,11 @@ 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 ||
@@ -60,6 +73,19 @@ function covers(reach, room, path) {
 function conversing(reach) {
     return reach === null || reach.conversations;
 }
+function roomsAwaited(error, reach) {
+    return error.code === 'unknown-type' && reach !== null && reach.rooms.length === 0;
+}
+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
         ? null
@@ -105,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)) }),
@@ -190,7 +217,7 @@ export function narrowed(runtime, given, port) {
                 shown = shown.then(() => making.then((value) => {
                     if (open)
                         deliver(value);
-                }, () => { }), () => { });
+                }, uncaught), uncaught);
             },
             stop() {
                 open = false;
@@ -249,24 +276,31 @@ export function narrowed(runtime, given, port) {
             return following(() => lockedFirst(room, () => watch(topic, input, (entries) => deliver(queueWithin(reach, room, entries)), fail), () => deliver([])), true);
         }
         if (topic === 'query') {
-            const planning = 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 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 planning;
+                    const plan = await planned;
                     const locked = await runtime.lockedRooms();
                     if (!open)
                         return;
+                    if (plan === null)
+                        return waiting({ pending: [] });
                     const pending = unlocking(plan.rooms, locked);
-                    if (pending !== null) {
-                        const answer = { result: pending, keys: [] };
-                        if (held === null || changeOf(held, answer) !== null)
-                            deliver(answer);
-                        held = digestOf(answer);
-                        return;
-                    }
+                    if (pending !== null)
+                        return waiting(pending);
                     let first = true;
                     const heard = (message) => {
                         if (!first) {
@@ -280,8 +314,7 @@ export function narrowed(runtime, given, port) {
                         if (change !== null)
                             deliver(change);
                     };
-                    const current = { ...plan, reach: planReach(reach), locked };
-                    stop = runtime.watchPlan(current, (message) => {
+                    stop = runtime.watchPlan({ ...plan, locked }, (message) => {
                         if (open)
                             heard(message);
                     }, (error) => {
@@ -339,7 +372,9 @@ export function narrowed(runtime, given, port) {
         ...md,
         rooms: () => md.rooms().then((rooms) => roomsWithin(reach, rooms)),
         query: (async (input) => {
-            const plan = await runtime.plan(input, reach);
+            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 });
         }),
@@ -431,7 +466,6 @@ export function narrowed(runtime, given, port) {
         reached: async (room, roomVersion, path) => (path === undefined ? wholly(reach, room) : covers(reach, room, path)) &&
             !(await runtime.locked(room)) &&
             (await md.reached(room, roomVersion, path)),
-        log: () => (reach === null ? md.log() : ''),
         cleanUp: () => (reach === null ? md.cleanUp() : Promise.reject(deviceUnreached())),
         unsent: () => (reach === null ? md.unsent() : Promise.reject(deviceUnreached())),
         reset: () => (reach === null ? md.reset() : Promise.reject(deviceUnreached())),
@@ -470,14 +504,25 @@ export function narrowed(runtime, given, port) {
             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),
-            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),

package/dist/react.d.ts

@@ -1,4 +1,5 @@
 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 } from './listing.js';
 import type { ConnectionRefusal } from './socket.js';
@@ -8,6 +9,7 @@ import type { ConversationAgent, ConversationEntry, ConversationOptions, Convers
 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 { DocumentResult, GroupResult, PendingResult } from './query.js';
 import type { Readiness } from './readiness.js';
@@ -39,6 +41,9 @@ export declare function useObserve(client: Client, topic: 'conversations'): Obse
 export declare function useObserve(client: Client, topic: 'agents'): Observed<readonly ConversationAgent[]>;
 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;