@agentshouse/mdruntime 0.1.0-c069136dcb4e8 → 0.1.0-c09bf842921ff

package/dist/connection.js

@@ -1,8 +1,8 @@
-import { parseFrontmatter, roomTarget, target } from '@agentshouse/mdmodel';
-import { attachedModel, builtInModel, roomTypesOf } from './attached-model.js';
+import { identityOf, parseFrontmatter, plain, queryKey, roomTarget, target, } from '@agentshouse/mdmodel';
+import { attachedModel, builtInModel, roomTypesOf, schemaTypes } from './attached-model.js';
 import { cached, modelTypes, NO_MODEL, sameModel, } from './model.js';
 import { observing, whole } from './observation.js';
-import { filterOf, identityOf, planOf, plain, queryKey, } from './query.js';
+import { planWithin, } from './query.js';
 import { createLiveQueries } from './live.js';
 import { seededResult } from './seed.js';
 import { documentKey, roomOfKey } from './rows.js';
@@ -30,7 +30,7 @@ import { readinessOf, } from './readiness.js';
 import { FencedMap } from './fence.js';
 import { sameBinary } from './overlay.js';
 import { paced, ROW_WEIGHT, stepped, yielded } from './turn.js';
-import { identityTime, roomDraftRevision } from './identity.js';
+import { roomDraftRevision } from './identity.js';
 import { ancestors, beneath, normalize } from './paths.js';
 import { openRuntimeStore, } from './store.js';
 import { validatedNeighbourhood } from './validation.js';
@@ -104,6 +104,7 @@ export function composeRuntime(options) {
     const usableWhenHeld = options.usableWhenHeld ?? [];
     const queuesWithoutReplica = new FencedMap(isFenced);
     const pendings = new Map();
+    const landedAhead = new Map();
     const seeds = new Map();
     const seedWatchers = new Map();
     const roomDrafts = new FencedMap(isFenced);
@@ -115,6 +116,7 @@ export function composeRuntime(options) {
     const counted = new Map();
     const unreadable = new Set();
     const builtIn = builtInModel(roomTypes);
+    const typedPaths = options.adapter.typedPaths ?? [];
     const models = new FencedMap(isFenced);
     const liveModels = new FencedMap(isFenced);
     const invalidModels = new Set();
@@ -141,7 +143,7 @@ export function composeRuntime(options) {
             : modelOf(locator);
     }
     function composed(record) {
-        return compositionOf(record, builtIn);
+        return compositionOf(record, builtIn, typedPaths);
     }
     function compositionFor(record) {
         return composed({ ...record, model: savedModel(record.locator) });
@@ -162,14 +164,14 @@ export function composeRuntime(options) {
     const repairing = new Set();
     const calling = new Set();
     const repairable = new Map();
-    let outcomeRetention = null;
     const answering = new Map();
     let complete = false;
     let recorded = false;
     const stale = new Set();
     let generation = 0;
-    let discovering = null;
     const reloadsDue = new Set();
+    const highest = new Map();
+    const beyondHorizon = new Set();
     const lanes = new Map();
     const roomLanes = new Map();
     let roomWork = 0;
@@ -189,6 +191,8 @@ export function composeRuntime(options) {
     let withdrawConversations;
     let currencyQueued = null;
     let socketOpen = false;
+    let announced = false;
+    let missedChange = false;
     const confirmed = new Set();
     let lockGrace = null;
     const lockListeners = new Set();
@@ -198,6 +202,8 @@ export function composeRuntime(options) {
     const serviceModeListeners = new Set();
     let member = null;
     const memberListeners = new Set();
+    let authorityChanges = 0;
+    const authorityChangeListeners = new Set();
     const unpreparedDemand = new Set();
     const unpreparable = new Set();
     let preparing = false;
@@ -247,6 +253,7 @@ export function composeRuntime(options) {
     const installTurns = { busy: false, ahead: 0, finishing: [], starting: [] };
     const conversations = createConversationStore({
         call: (name, input) => invokeAction(name, input),
+        history: (request) => readConversationHistory(request),
         durably,
         stream: () => options.adapter.conversations,
         publish: publishChangeSet,
@@ -254,7 +261,6 @@ export function composeRuntime(options) {
         full: () => full,
         closed: () => closed,
         unanswered: resendLater,
-        expired: (operation) => pastHorizon(operation),
     });
     const journal = createLog();
     const keptFiles = openedFiles(database, isFenced);
@@ -347,9 +353,9 @@ export function composeRuntime(options) {
         return value === undefined ? null : structuredClone(value);
     }
     async function writtenRoomDraft(room, path, revision, input, next) {
-        const parts = readParts(input);
+        const parts = readParts(input, path);
         if (path === '' || normalize(path) !== path)
-            throw runtimeError('room-draft-malformed');
+            throw runtimeError('room-draft-malformed', `room-draft-malformed at ${path}: a path inside the Room, such as notes/a.md`);
         const local = await openLocal();
         const current = roomDrafts.get(room)?.get(path);
         if ((current?.revision ?? null) !== revision) {
@@ -649,11 +655,7 @@ export function composeRuntime(options) {
         })();
     }
     function roomsOfReach(reach) {
-        return new Set([
-            ...reach.rooms,
-            ...reach.documents.map(roomOfKey),
-            ...reach.areas.flatMap((area) => (area.types.length === 0 ? [] : [area.room])),
-        ]);
+        return new Set([...reach.rooms, ...reach.documents.map(roomOfKey)]);
     }
     function reachedRooms(plan) {
         const reached = plan.reach === null ? null : roomsOfReach(plan.reach);
@@ -792,7 +794,6 @@ export function composeRuntime(options) {
     }
     function readinessFor(port, reach) {
         const required = requiredRooms(reach);
-        const search = port.search === 'required';
         const coverage = required.rooms.map((room) => ({ room, state: roomState(room) }));
         const preparing = coverage
             .filter((room) => room.state === 'preparing' && !unpreparable.has(room.room))
@@ -805,12 +806,11 @@ export function composeRuntime(options) {
                 listed: required.listed,
                 rooms: coverage,
                 conversations: conversationCoverage(reach),
-                search: search ? 'required' : 'unused',
             },
             persistence,
             connection: connectionOf(),
             house: refusal !== null ? 'refused' : writesHeld() ? 'write-halted' : 'open',
-            space: full ? 'full' : port.space,
+            space: full ? 'full' : null,
             installation: installationOf(coverage),
             lost: storageLoss !== null,
             established: targets[port.target]?.established === true ||
@@ -899,8 +899,12 @@ export function composeRuntime(options) {
         unpreparable.clear();
         journal.record('space freed');
         queueReadiness();
-        if (!closed && authorization !== undefined)
-            void sync('unstreamed');
+        if (closed || authorization === undefined)
+            return;
+        if (options.adapter.roomStream === undefined)
+            void sync('unstreamed', null);
+        else
+            void resynchronize();
     }
     function seedRoomHeld(room, version) {
         return indexed(room) && reachedBy(room, version);
@@ -1137,7 +1141,7 @@ export function composeRuntime(options) {
             refusal: scopedRefusals.get(room.locator) ?? null,
         });
     }
-    async function applyDiscovery(found, started, covered) {
+    async function applyDiscovery(found, started, left) {
         const lockedBefore = lockedRooms();
         for (const room of found) {
             const fence = fences.get(room.locator);
@@ -1151,18 +1155,11 @@ export function composeRuntime(options) {
         const listedLocators = new Set(listed.map((room) => room.locator));
         for (const locator of listedLocators)
             scopedRefusals.delete(locator);
-        if (covered === undefined)
+        if (left === undefined)
             discovered.clear();
-        else
-            for (const locator of covered)
-                discovered.delete(locator);
         for (const room of listed)
             discovered.set(room.locator, room);
-        const unlisted = unlistedHeld(new Set(found.map((room) => room.locator))).filter((locator) => covered === undefined || covered.includes(locator));
-        if (options.adapter.exhaustiveDiscovery === true)
-            await loseRooms(unlisted);
-        else
-            unlistedKept(unlisted);
+        await loseRooms(left ?? unlistedHeld(new Set(found.map((room) => room.locator))));
         for (const room of listed) {
             const held = replicas.get(room.locator)?.record;
             if (held !== undefined && held.replica.selection !== room.replica.selection) {
@@ -1193,15 +1190,6 @@ export function composeRuntime(options) {
             ]),
         ].filter((locator) => !listed.has(locator));
     }
-    function unlistedKept(unlisted) {
-        for (const locator of unlisted) {
-            const held = replicas.get(locator)?.record;
-            if (held !== undefined)
-                list(held, false);
-            else
-                rooms.delete(locator);
-        }
-    }
     function fence(locators) {
         const fresh = [...new Set(locators)].filter((locator) => !fences.has(locator));
         const removed = fresh.map((locator) => ({
@@ -1212,9 +1200,13 @@ export function composeRuntime(options) {
             fences.set(locator, { at: discoveries, erased: false });
             lastFenced.set(locator, ++fencings);
             confirmed.delete(locator);
-            for (const batch of replicas.get(locator)?.queue ?? queuesWithoutReplica.get(locator) ?? [])
+            for (const batch of replicas.get(locator)?.queue ?? queuesWithoutReplica.get(locator) ?? []) {
                 pendings.delete(pendingKey(locator, batch.id));
+                landedAhead.delete(pendingKey(locator, batch.id));
+            }
             replicas.delete(locator);
+            highest.delete(locator);
+            beyondHorizon.delete(locator);
             queuesWithoutReplica.delete(locator);
             rooms.delete(locator);
             roomDrafts.delete(locator);
@@ -1281,8 +1273,7 @@ export function composeRuntime(options) {
     function retyped(persisted) {
         if (persisted.status === 'unavailable')
             return persisted;
-        const { state } = attachedModel({ kind: 'model', snapshot: persisted.snapshot }, NO_MODEL, roomTypes);
-        return state.status === 'unavailable' ? state : { ...persisted, types: state.types };
+        return { ...persisted, types: schemaTypes(persisted.snapshot.schema, roomTypes) };
     }
     function restored(key, held) {
         const persisted = retyped(held);
@@ -1328,8 +1319,9 @@ export function composeRuntime(options) {
         presentations.clear();
         for (const record of held.presentation)
             presentations.set(record.app, record.value);
-        conversations.hydrate(heldConversations, chatDrafts, held.conversationList);
+        conversations.hydrate(heldConversations, chatDrafts, held.conversationList, held.conversationCursor);
         pendings.clear();
+        landedAhead.clear();
         for (const queue of queues) {
             for (const { batch, state } of queue.pending) {
                 pendings.set(pendingKey(queue.locator, batch.id), state);
@@ -1478,14 +1470,12 @@ export function composeRuntime(options) {
             return state !== undefined && state.submission.state !== 'submitted' && !state.lost;
         };
     }
-    const REWRITE_LINKS = ['field', 'body'];
-    const CHECKED_LINKS = ['field', 'section'];
     async function sliceAt(record, view, queue, extra = [], moved = []) {
         const local = await openLocal();
         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, REWRITE_LINKS)) {
+            for (const { path } of await local.referrers(record.key, view, movedPaths)) {
                 needed.add(path);
             }
         }
@@ -1622,10 +1612,16 @@ export function composeRuntime(options) {
             ? read
             : await stepped(slicingWith(read, overrides.set, overrides.removed));
         const composition = composed(record);
-        const { withdrawn, kept } = await stepped(standing(confirmedLayer, queue, withdrawable(locator), localSaves, locator, composition));
-        const founded = kept.filter((batch) => !queue.includes(batch));
+        const shown = queue.filter((batch) => {
+            const held = landedAhead.get(pendingKey(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(locator), localSaves, locator, composition));
+        const founded = kept.filter((batch) => !unshown.includes(batch));
         const queueChanged = kept.length !== previousQueue.length || founded.length > 0;
-        const unqueued = [];
+        const unqueued = shown.map((batch) => ({ batch, landed: true }));
         for (const batch of withdrawn) {
             unqueued.push({ batch, landed: await landedWhole(locator, batch, confirmedLayer) });
         }
@@ -1690,8 +1686,10 @@ export function composeRuntime(options) {
             commit,
             apply: (answer) => {
                 for (const batch of previousQueue) {
-                    if (!staying.has(batch.id))
-                        pendings.delete(pendingKey(locator, batch.id));
+                    if (staying.has(batch.id))
+                        continue;
+                    pendings.delete(pendingKey(locator, batch.id));
+                    landedAhead.delete(pendingKey(locator, batch.id));
                 }
                 for (const draft of written.values())
                     rememberRoomDraft(draft);
@@ -1740,11 +1738,7 @@ export function composeRuntime(options) {
         const answer = answers?.collection;
         if (answer === undefined)
             return held;
-        const { state, refused } = attachedModel(answer, held.collection, roomTypes);
-        if (refused !== null) {
-            const where = refused.location === undefined ? '' : ` ${refused.location}`;
-            journal.record(`model invalid ${locator} collection ${refused.identity} ${refused.rule}${where}`);
-        }
+        const state = attachedModel(answer, roomTypes);
         models.set(locator, state);
         return { collection: state };
     }
@@ -1797,6 +1791,8 @@ export function composeRuntime(options) {
                 return true;
             }
             if (landing.kind === 'bootstrapped') {
+                highest.delete(room.locator);
+                beyondHorizon.delete(room.locator);
                 untransferred(room.locator);
                 startedOver.delete(room.locator);
                 catching.delete(room.locator);
@@ -1824,7 +1820,7 @@ export function composeRuntime(options) {
         const replica = replicas.get(locator);
         const room = rooms.get(locator);
         if (replica === undefined || room === undefined) {
-            throw runtimeError('room-not-held', `No Local Replica for ${locator}`);
+            throw runtimeError('unknown-room', `Unknown Room ${locator}`);
         }
         return { local, replica, room };
     }
@@ -1885,7 +1881,7 @@ export function composeRuntime(options) {
         const removed = changes.flatMap((change) => (change.kind === 'remove' ? [change.path] : []));
         const referring = removed.length === 0
             ? []
-            : (await local.referrers(record.key, 'confirmed', removed, CHECKED_LINKS)).map(({ path }) => path);
+            : (await local.referrers(record.key, 'confirmed', removed)).map(({ path }) => path);
         const confirmedLayer = await sliceAt(record, 'confirmed', replica.queue, [...paths, ...paths.flatMap(ancestors), ...referring], moved);
         const { visible } = await replayed(record, confirmedLayer, replica.queue);
         const composition = composed(record);
@@ -1978,7 +1974,7 @@ export function composeRuntime(options) {
     }
     function referrersOf(local, key, view) {
         return async (targets) => [
-            ...new Set((await local.referrers(key, view, targets, CHECKED_LINKS)).map(({ path }) => path)),
+            ...new Set((await local.referrers(key, view, targets)).map(({ path }) => path)),
         ];
     }
     async function sideOf(locator, replica, room, saving) {
@@ -2050,7 +2046,7 @@ export function composeRuntime(options) {
         const target = replicas.get(destination);
         const listedRoom = rooms.get(destination);
         if (target === undefined || listedRoom === undefined) {
-            throw runtimeError('room-not-held', `No Local Replica for ${destination}`);
+            throw runtimeError('unknown-room', `Unknown Room ${destination}`);
         }
         const arriving = await savingIn(target, [], moves.map(({ to }) => to));
         const built = await buildMove({
@@ -2113,10 +2109,10 @@ export function composeRuntime(options) {
             return { outcome: 'refused', code: 'durable-write', retryable: true };
         const { answer, touched } = committedBoth;
         if (answer.fenced !== null) {
-            throw runtimeError('room-not-held', `No Local Replica for ${answer.fenced}`);
+            throw runtimeError('unknown-room', `Unknown Room ${answer.fenced}`);
         }
         if (fences.has(locator) || fences.has(destination)) {
-            throw runtimeError('room-not-held', `No Local Replica for ${locator}`);
+            throw runtimeError('unknown-room', `Unknown Room ${locator}`);
         }
         pendings.set(pendingKey(locator, id), {
             drafts: saved,
@@ -2287,10 +2283,10 @@ export function composeRuntime(options) {
             return { outcome: 'refused', code: 'durable-write', retryable: true };
         const { answer, touched } = done;
         if (answer.fenced !== null) {
-            throw runtimeError('room-not-held', `No Local Replica for ${answer.fenced}`);
+            throw runtimeError('unknown-room', `Unknown Room ${answer.fenced}`);
         }
         if (fences.has(locator))
-            throw runtimeError('room-not-held', `No Local Replica for ${locator}`);
+            throw runtimeError('unknown-room', `Unknown Room ${locator}`);
         for (const origin of withdrawn.keys())
             pendings.delete(pendingKey(locator, origin));
         for (const [id, drafts] of drafted) {
@@ -2339,7 +2335,7 @@ export function composeRuntime(options) {
             throw new Error('connection refused');
         await local.keepUpload(locator, identifier, upload);
         if (fences.has(locator))
-            throw runtimeError('room-not-held', `No Local Replica for ${locator}`);
+            throw runtimeError('unknown-room', `Unknown Room ${locator}`);
         const key = pendingKey(locator, identifier);
         pendings.set(key, { ...pendings.get(key), upload });
         if (!continuing())
@@ -2664,6 +2660,24 @@ export function composeRuntime(options) {
             return UNCERTAIN;
         }
     }
+    async function readConversationHistory(request) {
+        await ready;
+        const stream = options.adapter.conversations;
+        if (closed || refusal !== null || stream?.history === undefined)
+            return UNCERTAIN;
+        journal.record('transfer conversation history');
+        try {
+            const result = await stream.history(request);
+            if (result.kind === 'revoked-authorization')
+                await refuse('revoked-authorization');
+            journal.record(`outcome conversation history ${result.kind}`);
+            return calledResult(result);
+        }
+        catch {
+            journal.record('outcome conversation history transport-uncertainty');
+            return UNCERTAIN;
+        }
+    }
     function unsettled(result) {
         return result.kind !== 'action' && result.retryable;
     }
@@ -2702,10 +2716,6 @@ export function composeRuntime(options) {
                 continue;
             if (closed || signal.aborted)
                 return 'done';
-            if (pastHorizon(held.operation)) {
-                await local.dropCall(held.operation);
-                continue;
-            }
             calling.add(held.operation);
             try {
                 if (unsettled(await invokeAction(held.name, held.input)))
@@ -2725,6 +2735,33 @@ export function composeRuntime(options) {
         const held = replicas.get(locator);
         return (held !== undefined && options.adapter.reached(locator, held.record.roomVersion, roomVersion));
     }
+    function shownAt(locator) {
+        const held = replicas.get(locator)?.record.roomVersion;
+        const raised = highest.get(locator);
+        if (held === undefined || raised === undefined)
+            return held ?? raised;
+        return options.adapter.reached(locator, held, raised) ? held : raised;
+    }
+    function showing(locator, roomVersion) {
+        const at = shownAt(locator);
+        if (at === undefined || !options.adapter.reached(locator, at, roomVersion)) {
+            highest.set(locator, roomVersion);
+        }
+    }
+    function older(locator, roomVersion) {
+        if (beyondHorizon.has(locator))
+            return false;
+        const at = shownAt(locator);
+        return (at !== undefined &&
+            options.adapter.reached(locator, at, roomVersion) &&
+            !options.adapter.reached(locator, roomVersion, at));
+    }
+    function replaced(locators) {
+        for (const locator of locators) {
+            highest.delete(locator);
+            beyondHorizon.add(locator);
+        }
+    }
     async function writtenAfter(locator, roomVersion, path) {
         const held = replicas.get(locator);
         if (held === undefined)
@@ -2735,14 +2772,25 @@ export function composeRuntime(options) {
             options.adapter.reached(locator, written, roomVersion) &&
             !options.adapter.reached(locator, roomVersion, written));
     }
-    function refreshingOf(local, key, composition, liveness, replaying = null) {
-        const write = replaying === null ? exclusive : finishingWrite;
+    async function writtenLater(local, locator, key, paths, roomVersion) {
+        if (paths.length === 0 || !older(locator, roomVersion))
+            return new Set();
+        const entries = await local.entries(key, 'confirmed', paths);
+        return new Set(entries.flatMap(({ path, written }) => written !== null &&
+            options.adapter.reached(locator, written, roomVersion) &&
+            !options.adapter.reached(locator, roomVersion, written)
+            ? [path]
+            : []));
+    }
+    function refreshingOf(local, locator, key, composition, liveness, replaying = false) {
+        const write = replaying ? finishingWrite : exclusive;
         return {
             turn() {
-                if (replaying !== null)
-                    installing(replaying);
+                if (replaying)
+                    installing(locator);
             },
             prior: async (paths) => new Map((await local.entries(key, 'refreshed', paths)).map((entry) => [entry.path, entry])),
+            later: (paths, roomVersion) => writtenLater(local, locator, key, paths, roomVersion),
             async stage(page) {
                 for (let written = 0;;) {
                     const end = batchEnd(page.entries, written);
@@ -2932,7 +2980,7 @@ export function composeRuntime(options) {
                 finally {
                     hold.take();
                 }
-            }, authorized, record, (models, kept) => (liveness() ? remodel(record.locator, models, kept) : kept), liveness, refreshingOf(local, record.key, composed(record), liveness));
+            }, authorized, record, (models, kept) => (liveness() ? remodel(record.locator, models, kept) : kept), liveness, refreshingOf(local, record.locator, record.key, composed(record), liveness));
             if (result.kind !== 'advanced') {
                 journal.record(`transfer refresh ${record.locator} ${result.kind}`);
                 return result;
@@ -3059,7 +3107,7 @@ export function composeRuntime(options) {
             derive: derived,
             async refreshing(locator, key, composition) {
                 await exclusive(() => local.unrefresh(key));
-                return refreshingOf(local, key, composition, liveness, locator);
+                return refreshingOf(local, locator, key, composition, liveness, true);
             },
             abandon: (locator) => exclusive(async () => {
                 if (liveness())
@@ -3093,9 +3141,16 @@ export function composeRuntime(options) {
             liveQueries.recover();
         }
         try {
-            const result = await bootstrapRoom(reads, authorized, room, { collection: modelOf(room.locator) }, builtIn, (models, held) => (liveness() ? remodel(room.locator, models, held) : held), liveness, staging(local, liveness), reusable(room, local));
+            const result = await bootstrapRoom(reads, authorized, room, { collection: modelOf(room.locator) }, builtIn, typedPaths, (models, held) => (liveness() ? remodel(room.locator, models, held) : held), liveness, staging(local, liveness), reusable(room, local));
             const detail = result.kind === 'staged' ? result.record.roomVersion : result.kind;
             journal.record(`transfer bootstrap ${room.locator} ${detail}`);
+            if (result.kind === 'staged' && older(room.locator, result.record.roomVersion)) {
+                caughtUpTo(room.locator);
+                installed(room.locator);
+                await abandoned(local, room.locator);
+                journal.record(`transfer bootstrap ${room.locator} older than shown`);
+                return { kind: 'transport-uncertainty' };
+            }
             if (result.kind !== 'staged') {
                 caughtUpTo(room.locator);
                 installed(room.locator);
@@ -3146,6 +3201,7 @@ export function composeRuntime(options) {
                 return refreshed;
             if (reloadsDue.has(room.locator))
                 return unconfirmed;
+            replaced([room.locator]);
         }
         const from = standingOf(room.locator);
         const bootstrapped = await pullBootstrap(authorized, room, local, live);
@@ -3190,7 +3246,7 @@ export function composeRuntime(options) {
         return refreshed.kind === 'beyond-horizon' ? 'beyond-horizon' : refreshed;
     }
     async function withhold(withheld, room, local, progress) {
-        if (withheld.kind === 'unconfirmed')
+        if (withheld.kind === 'unconfirmed' || isFenced(room.locator))
             return;
         stale.add(room.locator);
         if (withheld.kind === 'transport-uncertainty' || withheld.kind === 'retryable-refusal') {
@@ -3219,8 +3275,6 @@ export function composeRuntime(options) {
         }
     }
     function leaving(batch, result) {
-        if (result.kind === 'expired')
-            return { batch, returned: returnedBy('expired') };
         return {
             batch,
             returned: {
@@ -3253,10 +3307,11 @@ export function composeRuntime(options) {
         logAccepted(room.locator, submitted, accepted);
         let record = current.record;
         let changes;
-        if (!options.adapter.reached(room.locator, held, accepted.roomVersion)) {
+        if (!options.adapter.reached(room.locator, held, accepted.roomVersion) &&
+            !older(room.locator, accepted.roomVersion)) {
             const paths = [...returnedPaths(submitted, accepted)];
             const confirmedLayer = await stepped(slicing(await local.entries(record.key, 'confirmed', paths), paths));
-            const back = await stepped(returning(confirmedLayer, submitted, accepted, accepted.roomVersion));
+            const back = await stepped(returning(confirmedLayer, submitted, accepted, accepted.roomVersion, composed(record)));
             record = {
                 ...record,
                 roomVersion: options.adapter.follows(room.locator, held, accepted.roomVersion)
@@ -3270,6 +3325,7 @@ export function composeRuntime(options) {
             ...settled,
             apply(answer) {
                 const set = settled.apply(answer);
+                showing(room.locator, accepted.roomVersion);
                 pendings.delete(pendingKey(room.locator, submitted.id));
                 unreadable.delete(room.locator);
                 list(room, true);
@@ -3419,15 +3475,10 @@ export function composeRuntime(options) {
             return;
         moveTo({ ...status, ...attention() });
     }
-    async function discardHeld(head, room, local, signal) {
-        const partner = partnerOf(head, room.locator);
-        const other = partner === null ? undefined : discovered.get(partner);
-        await discardPending(other === undefined ? [room] : [room, other], local, signal);
-    }
     async function submitRoom(room, local, authorized, progress, signal) {
         while (continuing() && authorization !== undefined && !signal.aborted) {
             const replica = replicas.get(room.locator);
-            const head = replica?.queue[0];
+            const head = replica?.queue.find((batch) => !landedAhead.has(pendingKey(room.locator, batch.id)));
             if (replica === undefined || head === undefined)
                 return 'done';
             const state = pendings.get(pendingKey(room.locator, head.id));
@@ -3454,10 +3505,6 @@ export function composeRuntime(options) {
                 return 'done';
             }
             const lost = earlier || submission.state === 'submitted';
-            if (lost && pastHorizon(head.id)) {
-                await discardHeld(head, room, local, signal);
-                return 'done';
-            }
             let result;
             journal.record(`submission ${room.locator} ${head.id}`);
             await exclusive(() => mark(local, room.locator, head, { state: 'submitted' }, lost));
@@ -3535,32 +3582,12 @@ export function composeRuntime(options) {
             const other = partner === null ? undefined : discovered.get(partner);
             if (result.kind === 'conflicted' ||
                 result.kind === 'rejected' ||
-                result.kind === 'expired' ||
                 result.kind === 'retryable-refusal') {
-                if (result.kind === 'expired' && lost && result.restored !== true) {
-                    journal.record(`outcome ${room.locator} ${head.id} expired`);
-                    await discardHeld(head, room, local, signal);
-                    return 'done';
-                }
-                if (result.kind === 'expired') {
-                    await exclusive(() => mark(local, room.locator, head, { state: 'waiting' }, partner !== null && lost));
-                    const there = other === undefined ? null : await advanced(other, local, authorized);
-                    if (other !== undefined && there !== null) {
-                        await withhold(there, other, local, progress);
-                        return 'done';
-                    }
-                    const withheld = await advanced(room, local, authorized);
-                    if (withheld !== null) {
-                        await withhold(withheld, room, local, progress);
-                        return 'done';
-                    }
-                }
                 journal.record(`outcome ${room.locator} ${head.id} ${result.kind}` +
                     (result.kind === 'conflicted' && result.roomVersion !== undefined
                         ? ` ${result.roomVersion}`
                         : ''));
-                if (result.kind !== 'expired')
-                    journal.record(`refusal ${result.kind} ${result.code}`);
+                journal.record(`refusal ${result.kind} ${result.code}`);
             }
             if (result.kind === 'retryable-refusal') {
                 const reset = result.reset;
@@ -3568,7 +3595,7 @@ export function composeRuntime(options) {
                 await exclusive(() => mark(local, room.locator, head, reset === undefined ? { state: 'waiting' } : { state: 'reset', reset }, lost));
                 return reset === undefined ? 'again' : { at: Date.parse(reset) };
             }
-            if (result.kind === 'conflicted' || result.kind === 'rejected' || result.kind === 'expired') {
+            if (result.kind === 'conflicted' || result.kind === 'rejected') {
                 const left = leaving(head, result);
                 const refreshed = async () => ({
                     there: other === undefined ? null : await advanced(other, local, authorized),
@@ -3592,16 +3619,19 @@ export function composeRuntime(options) {
                         return;
                     }
                     const confirmedLayer = await sliceAt(current.record, 'confirmed', [head]);
-                    const held = (result.kind === 'expired' &&
-                        (await landedWhole(room.locator, head, confirmedLayer))) ||
-                        (result.kind === 'conflicted' &&
-                            (await landedWhole(room.locator, head, confirmedLayer, result.affected)));
+                    const held = result.kind === 'conflicted' &&
+                        (await landedWhole(room.locator, head, confirmedLayer, result.affected));
+                    if (held &&
+                        result.kind === 'conflicted' &&
+                        partner === null &&
+                        !landed(head, confirmedLayer)) {
+                        landedAhead.set(pendingKey(room.locator, head.id), Object.fromEntries([...touchedBy([head])].map((path) => [path, confirmedLayer.revisions[path]])));
+                        return;
+                    }
                     publishChangeSet(await settle(local, room.locator, current, current.record, current.queue.filter((batch) => batch.id !== head.id), { leaving: [held ? { ...left, returned: null } : left] }));
                     await unpair(local);
                     moveTo({ ...status, ...attention() });
                 });
-                if (result.kind === 'expired')
-                    continue;
                 const { there, here } = judged ?? (await refreshed());
                 if (other !== undefined && there !== null)
                     await withhold(there, other, local, progress);
@@ -3621,67 +3651,6 @@ export function composeRuntime(options) {
         }
         return 'done';
     }
-    function pastHorizon(identity) {
-        return (outcomeRetention !== null && identityTime(identity) + outcomeRetention * 1000 <= Date.now());
-    }
-    async function discardPending(rooms, local, signal) {
-        const discarded = await exclusive(async () => {
-            const held = rooms
-                .filter(({ locator }) => !fences.has(locator))
-                .map((room) => ({
-                room,
-                before: replicas.get(room.locator),
-                queue: queueIn(room.locator),
-            }));
-            if (held.length === 0)
-                return [];
-            const answer = await local.commit({
-                rooms: held.flatMap(({ room, before }) => before === undefined
-                    ? []
-                    : [
-                        {
-                            locator: room.locator,
-                            key: before.record.key,
-                            roots: before.record.typedSelection?.roots ?? [],
-                            composed: composedOf(composed(before.record)),
-                            overlay: { set: [], cleared: [...before.overlaid] },
-                        },
-                    ]),
-                discards: held.map(({ room }) => room.locator),
-            });
-            for (const { room, before, queue } of held) {
-                const { locator } = room;
-                lastFenced.set(locator, ++fencings);
-                for (const batch of queue)
-                    pendings.delete(pendingKey(locator, batch.id));
-                queuesWithoutReplica.delete(locator);
-                if (before !== undefined) {
-                    replicas.set(locator, {
-                        ...before,
-                        queue: [],
-                        overlaid: new Set(),
-                        count: answer.counts[locator] ?? before.count,
-                    });
-                }
-                journal.record(`room discarded ${locator}`);
-            }
-            publishChangeSet(mergeChangeSets(held.map(({ room }) => changeSet(room.locator, {
-                documents: answer.changed[room.locator] ?? [],
-                queue: true,
-            }))));
-            moveTo({ ...status, ...attention() });
-            return held.map(({ room }) => room);
-        });
-        for (const room of discarded) {
-            if (signal.aborted)
-                return;
-            const progress = { complete: true, reachable: true };
-            await roomTask(room.locator, (live) => reload(room, local, progress, live));
-            if (signal.aborted)
-                return;
-            await rest(progress);
-        }
-    }
     function awaitingAnswer(locator) {
         answering.get(locator)?.release();
         let release = () => { };
@@ -3703,6 +3672,30 @@ export function composeRuntime(options) {
                 JSON.stringify(held.replica) === JSON.stringify(room.replica) &&
                 JSON.stringify(held.typedSelection) === JSON.stringify(room.typedSelection ?? null)));
     }
+    async function keepNaming(local, room) {
+        const held = replicas.get(room.locator)?.record;
+        if (held === undefined || (held.name === room.name && held.handle === room.handle))
+            return;
+        await exclusive(async () => {
+            if (!continuing())
+                return;
+            const replica = replicas.get(room.locator);
+            if (replica === undefined)
+                return;
+            const record = { ...replica.record, name: room.name, handle: room.handle };
+            await local.commit({
+                rooms: [
+                    {
+                        locator: room.locator,
+                        key: record.key,
+                        record: storedRecord(record),
+                        composed: composedOf(composed(record)),
+                    },
+                ],
+            });
+            replicas.set(room.locator, { ...replica, record });
+        });
+    }
     async function retainModel(local, room, next) {
         const key = room.locator;
         const previous = modelOf(room.locator);
@@ -3720,6 +3713,8 @@ export function composeRuntime(options) {
             if (held !== undefined) {
                 const record = {
                     ...held.record,
+                    name: room.name,
+                    handle: room.handle,
                     operations: room.operations,
                     replica: room.replica,
                     typedSelection: room.typedSelection ?? null,
@@ -3822,7 +3817,6 @@ export function composeRuntime(options) {
             options.adapter.roomStream?.hold(heldRooms(ready));
             handed = true;
         }
-        discovering?.release();
         for (const room of ready) {
             if (attempt !== 'unstreamed' && replicas.has(room.locator)) {
                 if (attempt === 'authorized')
@@ -3850,6 +3844,8 @@ export function composeRuntime(options) {
         }
         if (prior !== undefined)
             await retainModel(local, room, modelOf(room.locator));
+        if (prior !== undefined)
+            await keepNaming(local, room);
         if (discoveryPaused || authorization === undefined)
             return false;
         return room.replica.admission === 'admitted';
@@ -3903,7 +3899,39 @@ export function composeRuntime(options) {
             caughtUpTo(room.locator);
         }
     }
-    async function discoverRooms(local, progress, attempt, live, scope) {
+    async function asked(authorized) {
+        try {
+            return (await options.adapter.discover?.(authorized)) ?? { kind: 'transport-uncertainty' };
+        }
+        catch {
+            return { kind: 'transport-uncertainty' };
+        }
+    }
+    function malformed(listed) {
+        for (const room of listed) {
+            if (room.operations === undefined ||
+                !['write', 'delete'].every((operation) => Array.isArray(room.operations[operation]) &&
+                    room.operations[operation].every((scope) => typeof scope === 'string')) ||
+                room.replica === undefined ||
+                typeof room.replica.selection !== 'string' ||
+                room.replica.selection.length === 0 ||
+                !['admitted', 'unavailable'].includes(room.replica.admission) ||
+                !['locked', 'open'].includes(room.replica.offline)) {
+                return `invalid model or replica declaration ${room.locator}`;
+            }
+            if (!declaredSelection(room))
+                return `invalid typed selection declaration ${room.locator}`;
+        }
+        return null;
+    }
+    async function signIn(local, signedIn) {
+        if (JSON.stringify(signedIn) === JSON.stringify(member))
+            return;
+        await local.fact('member', signedIn);
+        member = signedIn;
+        emitMember();
+    }
+    async function discoverRooms(local, progress, attempt, live, found) {
         if (closed || authorization === undefined) {
             notifyReady();
             return;
@@ -3911,13 +3939,7 @@ export function composeRuntime(options) {
         moveTo(transferring(status));
         discoveries += 1;
         const started = discoveries;
-        let result;
-        try {
-            result = await options.adapter.discover(authorization, scope);
-        }
-        catch {
-            result = { kind: 'transport-uncertainty' };
-        }
+        const result = found ?? (await asked(authorization));
         if (result.kind === 'discovery')
             roomsNamed = true;
         if (!live()) {
@@ -3927,7 +3949,7 @@ export function composeRuntime(options) {
         }
         journal.record(`connection discover ${result.kind}`);
         if (result.kind === 'transport-uncertainty') {
-            await settleModels([...rooms.values()].map((room) => discovered.get(room.locator) ?? room), 'cached', local);
+            await cachedModels(local);
             progress.reachable = false;
             progress.complete = false;
             notifyReady();
@@ -3948,26 +3970,12 @@ export function composeRuntime(options) {
             notifyReady();
             return;
         }
-        for (const room of result.rooms) {
-            if (room.operations === undefined ||
-                !['write', 'delete'].every((operation) => Array.isArray(room.operations[operation]) &&
-                    room.operations[operation].every((scope) => typeof scope === 'string')) ||
-                room.replica === undefined ||
-                typeof room.replica.selection !== 'string' ||
-                room.replica.selection.length === 0 ||
-                !['admitted', 'unavailable'].includes(room.replica.admission) ||
-                !['locked', 'open'].includes(room.replica.offline)) {
-                journal.record(`invalid model or replica declaration ${room.locator}`);
-                await refuse('missing-required-guarantee');
-                notifyReady();
-                return;
-            }
-            if (!declaredSelection(room)) {
-                journal.record(`invalid typed selection declaration ${room.locator}`);
-                await refuse('missing-required-guarantee');
-                notifyReady();
-                return;
-            }
+        const invalid = malformed(result.rooms);
+        if (invalid !== null) {
+            journal.record(invalid);
+            await refuse('missing-required-guarantee');
+            notifyReady();
+            return;
         }
         if (refusal !== null) {
             refusal = null;
@@ -3975,7 +3983,6 @@ export function composeRuntime(options) {
         }
         const previousCapabilities = capabilities;
         capabilities = result.capabilities;
-        outcomeRetention = result.retention.outcome;
         notifyReady();
         if (JSON.stringify(result.providerLimits) !== JSON.stringify(limits) ||
             JSON.stringify(result.capabilities) !== JSON.stringify(previousCapabilities)) {
@@ -3983,13 +3990,8 @@ export function composeRuntime(options) {
             await local.fact('providerLimits', limits);
             await local.fact('capabilities', capabilities);
         }
-        const signedIn = result.member ?? null;
-        if (JSON.stringify(signedIn) !== JSON.stringify(member)) {
-            await local.fact('member', signedIn);
-            member = signedIn;
-            emitMember();
-        }
-        await synchronize(await applyDiscovery(result.rooms, started, result.covered), local, progress, attempt, live);
+        await signIn(local, result.member ?? null);
+        await synchronize(await applyDiscovery(result.rooms, started), local, progress, attempt, live);
     }
     async function ensureAuthorization() {
         if (authorization !== undefined)
@@ -4058,14 +4060,13 @@ export function composeRuntime(options) {
         void run.finally(() => working.delete(run));
         return run;
     }
-    function sync(attempt) {
+    function sync(attempt, found) {
         return task(OPENING_LANE, async (live) => {
             if (!live()) {
                 readyFromStore();
                 return;
             }
             const progress = { complete: true, reachable: true };
-            const gate = discover();
             underway = attempt === 'opened' ? progress : null;
             if (attempt === 'opened')
                 streamed = progress;
@@ -4079,7 +4080,7 @@ export function composeRuntime(options) {
                 await ensureAuthorization();
                 if (!live())
                     return;
-                await discoverRooms(local, progress, attempt, live);
+                await discoverRooms(local, progress, attempt, live, found);
             }
             catch {
                 progress.complete = false;
@@ -4087,7 +4088,6 @@ export function composeRuntime(options) {
                     progress.reachable = false;
             }
             finally {
-                gate.release();
                 notifyReady();
             }
             if (!live())
@@ -4099,34 +4099,59 @@ export function composeRuntime(options) {
             if (handed || closed || progress.reachable)
                 return;
             underway = null;
-            journal.record('connection reopen');
             await rest(progress, live);
-            options.adapter.roomStream?.reopen();
         });
     }
-    function rediscover(scope) {
+    function resynchronize() {
         return task(OPENING_LANE, async (live) => {
-            if (!live() || !socketOpen)
+            if (!live() || !announced)
                 return;
             const progress = { complete: true, reachable: true };
-            const gate = discover();
             moveTo(transferring(status));
             try {
                 const local = await openLocal();
                 if (!live())
                     return;
-                await ensureAuthorization();
+                await synchronize([...discovered.values()], local, progress, 'unstreamed', live);
+            }
+            catch {
+                progress.complete = false;
+            }
+            if (live())
+                await finishOpening(progress, live);
+        });
+    }
+    function countAuthorityChange() {
+        authorityChanges += 1;
+        for (const listener of authorityChangeListeners)
+            listener(authorityChanges);
+    }
+    function changeAuthority(change) {
+        return task(OPENING_LANE, async (live) => {
+            if (!live() || !announced)
+                return;
+            countAuthorityChange();
+            const progress = { complete: true, reachable: true };
+            moveTo(transferring(status));
+            try {
+                const local = await openLocal();
                 if (!live())
                     return;
-                await discoverRooms(local, progress, 'authorized', live, scope);
+                const invalid = malformed(change.rooms);
+                if (invalid !== null) {
+                    journal.record(invalid);
+                    await refuse('missing-required-guarantee');
+                    return;
+                }
+                if (change.member !== undefined)
+                    await signIn(local, change.member);
+                discoveries += 1;
+                const listed = await applyDiscovery(change.rooms, discoveries, change.left);
+                await synchronize(listed, local, progress, 'authorized', live);
             }
             catch {
                 progress.complete = false;
             }
-            finally {
-                gate.release();
-                notifyReady();
-            }
             if (!live())
                 return;
             if (!progress.complete)
@@ -4134,10 +4159,12 @@ export function composeRuntime(options) {
             await rest(progress, live);
         });
     }
-    function closedSocket(revoked, lost) {
-        notifyDiscovered();
-        const opened = socketOpen;
+    function closedSocket(revoked, lost, authorityChanged) {
+        notifyReady();
+        const opened = announced;
         socketOpen = false;
+        announced = false;
+        missedChange ||= authorityChanged;
         handed = false;
         naming = 0;
         connectionLost();
@@ -4153,14 +4180,29 @@ export function composeRuntime(options) {
         moveTo({
             ...status,
             state: status.state === 'synced' ? 'syncing' : status.state,
-            providerUnreachable: status.providerUnreachable || !opened,
+            providerUnreachable: status.providerUnreachable || (!opened && lost),
         });
+        void closing(opened);
     }
-    function applyOpening(expired) {
+    function closing(opened) {
+        return task(OPENING_LANE, async (live) => {
+            if (!live())
+                return;
+            const local = await openLocal();
+            if (!opened && !socketOpen)
+                await cachedModels(local);
+            await rest(null, live);
+        });
+    }
+    function cachedModels(local) {
+        return settleModels([...rooms.values()].map((room) => discovered.get(room.locator) ?? room), 'cached', local);
+    }
+    function caughtUpRooms(expired) {
         const progress = underway;
         underway = null;
         naming = Math.max(0, naming - 1);
         const cycle = progress ?? { complete: true, reachable: true };
+        replaced(expired);
         const reloading = progress === null ? [] : owedReloads(expired);
         const replacing = reloadNow((room) => expired.includes(room.locator) || reloading.includes(room.locator), cycle);
         return task(OPENING_LANE, async (live) => {
@@ -4394,21 +4436,11 @@ export function composeRuntime(options) {
             ...attention(),
         });
     }
-    function discover() {
-        discovering?.release();
-        let release = () => { };
-        const done = new Promise((resolve) => {
-            release = resolve;
-        });
-        discovering = { done, release };
-        return discovering;
-    }
     function applyRoom(change) {
         const { locator } = change;
         if (stopping)
             return Promise.resolve();
         return inRoom(locator, async (live) => {
-            await discovering?.done;
             await answering.get(locator)?.answered;
             const progress = underway ?? { complete: true, reachable: true };
             try {
@@ -4466,20 +4498,30 @@ export function composeRuntime(options) {
                 return;
             if (event.kind === 'opened') {
                 socketOpen = true;
+                announced = false;
                 handed = false;
                 naming = 0;
                 connectionLive();
                 generation += 1;
                 conversations.reopened();
                 recovery.resume();
-                void sync('opened');
+            }
+            else if (event.kind === 'discovered') {
+                if (!socketOpen)
+                    return;
+                announced = true;
+                if (missedChange) {
+                    missedChange = false;
+                    countAuthorityChange();
+                }
+                void sync('opened', event.discovery);
             }
             else if (event.kind === 'closed')
-                closedSocket(event.revoked, event.lost);
-            else if (event.kind === 'opening')
-                void applyOpening(event.expired);
+                closedSocket(event.revoked, event.lost, event.authorityChanged);
+            else if (event.kind === 'caught-up')
+                void caughtUpRooms(event.expired);
             else if (event.kind === 'authority-changed')
-                void rediscover(event.scope);
+                void changeAuthority(event);
             else
                 void applyRoom(event);
         });
@@ -4572,6 +4614,7 @@ export function composeRuntime(options) {
         statusListeners.clear();
         serviceModeListeners.clear();
         memberListeners.clear();
+        authorityChangeListeners.clear();
         liveQueries.close();
         queueSubscriptions.clear();
         roomDraftListeners.clear();
@@ -4598,15 +4641,15 @@ export function composeRuntime(options) {
         readyFromStore();
     });
     if (options.adapter.roomStream === undefined)
-        void sync('unstreamed');
+        void sync('unstreamed', null);
     function planned(input, reach) {
-        const plan = planOf(input, roomFacts(reach), planReach(reach));
+        const plan = planWithin(input, roomFacts(reach), planReach(reach));
         const named = plan.paths !== null &&
             plan.rooms !== null &&
             plan.paths.length * plan.rooms.length <= MAXIMUM_WINDOW;
         return plan.limit === null && named ? plan : { ...plan, limit: capped(plan.limit) };
     }
-    function watchPlan(plan, deliver) {
+    function watchPlan(plan, deliver, fail) {
         let seeded = false;
         let pending = true;
         const shown = () => {
@@ -4632,7 +4675,7 @@ export function composeRuntime(options) {
             }
             seeded = false;
             deliver(message);
-        });
+        }, fail);
         return () => {
             watchers.delete(shown);
             if (watchers.size === 0)
@@ -4640,61 +4683,59 @@ export function composeRuntime(options) {
             stop();
         };
     }
-    async function searched(input, reach, locked) {
+    async function searched(input, reach) {
         const asked = searchPlanOf(input);
-        const filter = {
-            ...filterOf(asked.documents ?? {}, roomFacts(reach), planReach(reach)),
-            locked,
-        };
-        const unlocking = (filter.rooms ?? [])
-            .filter((room) => locked.includes(room))
-            .map((room) => ({ room, awaits: 'unlock' }));
-        for (;;) {
-            const cover = covered(filter);
-            awaitPreparation(cover);
-            const pending = [...unlocking, ...('pending' in cover ? cover.pending : [])];
-            const complete = pending.length === 0 && !('pending' in cover);
-            const awaited = new Set('pending' in cover ? cover.pending.map(({ room }) => room) : []);
-            const answering = complete
-                ? filter
-                : { ...filter, rooms: reachedRooms(filter).filter((room) => !awaited.has(room)) };
-            const answered = covered(answering);
-            if ('pending' in answered)
-                continue;
-            const listed = conversations.searchable();
-            const named = reach !== null && !reach.conversations
-                ? []
-                : (asked.conversations ?? listed).filter((one) => listed.includes(one) && conversations.acquired(one));
-            const hits = await (await openLocal()).search({
-                text: asked.text,
-                limit: capped(asked.limit),
-                after: asked.after,
-                total: asked.total,
-                documents: {
-                    plan: answering,
-                    rooms: answered.rooms,
-                    beneath: asked.collection
-                        ? answered.rooms.map(({ locator, key }) => ({
-                            key,
-                            roots: replicas.get(locator)?.record.typedSelection?.roots ?? [],
-                        }))
-                        : [],
-                },
-                conversations: named,
-            });
-            if (JSON.stringify(covered(answering)) !== JSON.stringify(answered))
-                continue;
-            const coverage = {
-                rooms: answered.coverage.rooms,
-                conversations: named,
-                overlay: answered.coverage.overlay,
+        await ready;
+        const search = options.adapter.search;
+        if (search === undefined) {
+            return {
+                kind: 'undeclared',
+                code: 'action-undeclared',
+                fields: { name: 'search' },
+                retryable: false,
             };
-            return complete
-                ? { ...hits, coverage }
-                : { pending, documents: hits.documents, messages: hits.messages, coverage };
+        }
+        if (closed || refusal !== null || connectionOf() !== 'connected')
+            return OFFLINE;
+        const reached = reach === null ? null : new Set(reach.rooms);
+        const named = asked.rooms === null
+            ? reached === null
+                ? null
+                : [...reached]
+            : asked.rooms.filter((room) => reached === null || reached.has(room));
+        const rooms = named === null ? null : named.filter((room) => replicas.has(room)).sort();
+        if (rooms !== null && rooms.length === 0)
+            return { kind: 'found', documents: [] };
+        try {
+            await ensureAuthorization();
+        }
+        catch {
+            return UNCERTAIN;
+        }
+        if (closed || authorization === undefined || refusal !== null)
+            return UNCERTAIN;
+        journal.record('transfer search');
+        try {
+            const result = await search(authorization, { text: asked.text, rooms });
+            if (result.kind === 'revoked-authorization')
+                await refuse('revoked-authorization');
+            journal.record(`outcome search ${result.kind}`);
+            if (result.kind === 'rejected')
+                return result;
+            if (result.kind !== 'found')
+                return failure(result);
+            const kept = rooms === null ? null : new Set(rooms);
+            return {
+                kind: 'found',
+                documents: result.documents.filter((hit) => kept === null || kept.has(hit.room)),
+            };
+        }
+        catch {
+            journal.record('outcome search transport-uncertainty');
+            return UNCERTAIN;
         }
     }
-    const watch = (topic, input, deliver) => {
+    const watch = (topic, input, deliver, fail) => {
         if (topic === 'room-drafts') {
             const listener = { notify: deliver, ready: false };
             roomDraftListeners.add(listener);
@@ -4743,7 +4784,7 @@ export function composeRuntime(options) {
             };
         }
         if (topic === 'readiness') {
-            return watchReadiness({ target: '', code: 'stored', space: null, search: 'unused' }, null, deliver);
+            return watchReadiness({ target: '', code: 'stored' }, null, deliver);
         }
         if (topic === 'rooms') {
             unlistedRooms.add(deliver);
@@ -4788,6 +4829,13 @@ export function composeRuntime(options) {
                 memberListeners.delete(deliver);
             };
         }
+        if (topic === 'authority-changes') {
+            authorityChangeListeners.add(deliver);
+            deliver(authorityChanges);
+            return () => {
+                authorityChangeListeners.delete(deliver);
+            };
+        }
         if (topic === 'queue') {
             const queue = { locator: input[0], notify: deliver };
             queueSubscriptions.add(queue);
@@ -4796,7 +4844,7 @@ export function composeRuntime(options) {
                 queueSubscriptions.delete(queue);
             };
         }
-        return watchPlan(planned(input[0], null), deliver);
+        return watchPlan(planned(input[0], null), deliver, fail);
     };
     const md = {
         loaded() {
@@ -4816,7 +4864,7 @@ export function composeRuntime(options) {
             });
         },
         query: ((input) => rowsQuery(planned(input, null))),
-        search: (input) => searched(input, null, []),
+        search: (input) => searched(input, null),
         types(locator) {
             return {
                 collection: modelTypes(modelOf(locator)),
@@ -4919,6 +4967,8 @@ export function composeRuntime(options) {
             return journal.export();
         },
         cleanUp,
+        unsent: () => database.ask({ kind: 'authored.unsent' }),
+        reset: () => options.shell.reset(),
         persistence() {
             return persistence === 'granted';
         },
@@ -4941,7 +4991,7 @@ export function composeRuntime(options) {
             authorization = undefined;
             discoveryPaused = false;
             if (options.adapter.roomStream === undefined)
-                await sync('unstreamed');
+                await sync('unstreamed', null);
             else
                 await task(OPENING_LANE, ensureAuthorization);
         },
@@ -4964,7 +5014,6 @@ export function composeRuntime(options) {
         md,
         seed,
         stop,
-        lose: loseRooms,
         watch,
         persisted(answer) {
             if (answer === persistence)