@agentshouse/mdruntime 0.1.0-c8ca66ac9e99d → 0.1.0-c8f3163f32f93

package/dist/connection.js

@@ -13,13 +13,14 @@ import { validRoot } from './collection.js';
 import { runtimeError } from './failure.js';
 import { createLog } from './log.js';
 import { binaryRecord } from './binary.js';
-import { absentBinary, binaryAnswer, calledResult, historyAnswer, undeclared, UNCERTAIN, } from './outcome.js';
+import { absentBinary, binaryAnswer, calledResult, failure, historyAnswer, undeclared, UNCERTAIN, } from './outcome.js';
 import { refreshRoom } from './refresh.js';
 import { buildBatch, joined, limitedIn, requeued } from './save.js';
 import { applyReturned, compositionOf, confirmedOf, landed, readReclassified, replicaOf, sameMembership, withdrawals, } from './replica.js';
 import { binaryBase, changedParts, changesOf, held, heldFile, joinedDraft, readParts, returnedBy, returnedInto, staleWrite, underneath, withdrawnDrafts, } from './room-draft.js';
 import { same, saving, STARTING, transferring, } from './status.js';
 import { detectStorageLoss, nextGeneration } from './durability.js';
+import { FencedMap } from './fence.js';
 import { roomDraftRevision } from './identity.js';
 import { beneath, normalize } from './paths.js';
 import { openRuntimeStore, } from './store.js';
@@ -38,23 +39,36 @@ function declaredSelection(room) {
         root !== '' &&
         selection.roots.every((other, at) => at === index || !within(other, root)));
 }
+const OPENING_LANE = 'opening';
+const CONVERSATION_LANE = 'conversations';
+const ROOM_READS = 256;
+function roomLane(locator) {
+    return `room ${locator}`;
+}
 export function composeRuntime(options) {
     const localSaves = options.adapter.localSaves === true;
     let authorization = options.authorization;
     let opening;
     let store;
-    const replicas = new Map();
-    const queuesWithoutReplica = new Map();
+    const fences = new Map();
+    const isFenced = (locator) => fences.has(locator);
+    let fencings = 0;
+    const lastFenced = new Map();
+    const fencedSince = (locator, since) => fences.has(locator) || (lastFenced.get(locator) ?? 0) > since;
+    let discoveries = 0;
+    const replicas = new FencedMap(isFenced);
+    const queuesWithoutReplica = new FencedMap(isFenced);
     const pendings = new Map();
-    const roomDrafts = new Map();
+    const roomDrafts = new FencedMap(isFenced);
     const presentations = new Map();
     let limits = [];
     let capabilities = [];
-    const rooms = new Map();
+    const rooms = new FencedMap(isFenced);
     const counted = new Map();
     const unreadable = new Set();
-    const models = new Map();
-    const liveModels = new Map();
+    const isModelFenced = (key) => isFenced(key.slice(key.indexOf(' ') + 1));
+    const models = new FencedMap(isModelFenced);
+    const liveModels = new FencedMap(isModelFenced);
     const invalidModels = new Set();
     const discovered = new Map();
     let roomsListed = false;
@@ -97,7 +111,13 @@ export function composeRuntime(options) {
     let complete = false;
     let recorded = false;
     const stale = new Set();
-    let chain = Promise.resolve();
+    let generation = 0;
+    let discovering = null;
+    let opened = null;
+    const owed = new Set();
+    const lanes = new Map();
+    let roomReads = { generation, free: ROOM_READS, waiting: [] };
+    const working = new Set();
     let mutations = Promise.resolve();
     const roomListeners = new Set();
     const refusalListeners = new Set();
@@ -108,7 +128,7 @@ export function composeRuntime(options) {
     const presentationListeners = new Set();
     const readSide = createReadSide();
     let withdrawConversations;
-    let currencyQueued = false;
+    let currencyQueued = null;
     let socketOpen = false;
     let serviceMode = 'open';
     let haltedRefusal = false;
@@ -118,7 +138,7 @@ export function composeRuntime(options) {
     const memberListeners = new Set();
     const materialized = new Set();
     let everyRoom = false;
-    const transfers = new Map();
+    const transfers = new FencedMap(isFenced);
     const conversations = createConversationStore({
         agents: declaredAgents,
         documents: (locator) => rowsQuery(planOf({ rooms: [locator], select: 'all' }, roomFacts())),
@@ -126,6 +146,7 @@ export function composeRuntime(options) {
         durably,
         stream: () => options.adapter.conversations,
         publish: publishChangeSet,
+        online: () => !status.providerUnreachable && refusal === null,
         closed: () => closed,
     });
     const searchIndex = createSearchIndex({
@@ -476,14 +497,24 @@ export function composeRuntime(options) {
             refusal: scopedRefusals.get(room.locator) ?? sourceRefusals.get(room.locator) ?? null,
         });
     }
-    async function applyDiscovery(listed, local) {
+    async function applyDiscovery(found, started) {
+        for (const room of found) {
+            const fence = fences.get(room.locator);
+            if (fence !== undefined && fence.erased && fence.at < started)
+                fences.delete(room.locator);
+        }
+        const listed = found.filter((room) => !fences.has(room.locator));
         const listedLocators = new Set(listed.map((room) => room.locator));
         for (const locator of listedLocators)
             scopedRefusals.delete(locator);
         discovered.clear();
         for (const room of listed)
             discovered.set(room.locator, room);
-        await dropUnlisted(listedLocators, local);
+        const unlisted = unlistedHeld(new Set(found.map((room) => room.locator)));
+        if (options.adapter.exhaustiveDiscovery === true)
+            await loseRooms(unlisted);
+        else
+            unlistedKept(unlisted);
         for (const room of listed) {
             const held = replicas.get(room.locator)?.confirmed.record;
             if (held !== undefined && held.replica.selection !== room.replica.selection) {
@@ -494,6 +525,7 @@ export function composeRuntime(options) {
         }
         roomsListed = true;
         emitRooms();
+        return listed;
     }
     function unlistedHeld(listed) {
         return [
@@ -505,41 +537,67 @@ export function composeRuntime(options) {
             ]),
         ].filter((locator) => !listed.has(locator));
     }
-    async function dropUnlisted(listed, local) {
-        if (unlistedHeld(listed).length === 0)
-            return;
-        await exclusive(async () => {
-            const unlisted = unlistedHeld(listed);
-            await local.dropRooms(unlisted);
-            const removed = unlisted.map((locator) => changeSet(locator, replicas.get(locator) ?? null, null, {
-                room: true,
-                queue: true,
-                drafts: [...(roomDrafts.get(locator)?.keys() ?? [])],
-            }));
-            for (const locator of unlisted) {
-                for (const batch of replicas.get(locator)?.queue ?? queuesWithoutReplica.get(locator) ?? [])
-                    pendings.delete(batch.id);
-                replicas.delete(locator);
-                queuesWithoutReplica.delete(locator);
+    function unlistedKept(unlisted) {
+        for (const locator of unlisted) {
+            const held = replicas.get(locator)?.confirmed.record;
+            if (held !== undefined)
+                list(held, false);
+            else
                 rooms.delete(locator);
-                roomDrafts.delete(locator);
-                transfers.delete(locator);
-                unreadable.delete(locator);
-                stale.delete(locator);
-                scopedRefusals.delete(locator);
-                sourceRefusals.delete(locator);
-                declarationRefusals.delete(locator);
-                for (const attached of ['collection', 'typed-selection']) {
-                    const key = modelKey(locator, attached);
-                    models.delete(key);
-                    liveModels.delete(key);
-                    invalidModels.delete(key);
-                }
-                journal.record(`room unlisted ${locator}`);
+        }
+    }
+    function fence(locators) {
+        const fresh = [...new Set(locators)].filter((locator) => !fences.has(locator));
+        const removed = fresh.map((locator) => changeSet(locator, replicas.get(locator) ?? null, null, {
+            room: true,
+            queue: true,
+            drafts: [...(roomDrafts.get(locator)?.keys() ?? [])],
+        }));
+        for (const locator of fresh) {
+            fences.set(locator, { at: discoveries, erased: false });
+            lastFenced.set(locator, ++fencings);
+            for (const batch of replicas.get(locator)?.queue ?? queuesWithoutReplica.get(locator) ?? [])
+                pendings.delete(batch.id);
+            replicas.delete(locator);
+            queuesWithoutReplica.delete(locator);
+            rooms.delete(locator);
+            roomDrafts.delete(locator);
+            transfers.delete(locator);
+            discovered.delete(locator);
+            announced.delete(locator);
+            unreadable.delete(locator);
+            stale.delete(locator);
+            scopedRefusals.delete(locator);
+            sourceRefusals.delete(locator);
+            declarationRefusals.delete(locator);
+            for (const attached of ['collection', 'typed-selection']) {
+                const key = modelKey(locator, attached);
+                models.delete(key);
+                liveModels.delete(key);
+                invalidModels.delete(key);
             }
-            publishChangeSet(mergeChangeSets(removed));
-            moveTo({ ...status, ...attention() });
-        });
+            journal.record(`room lost ${locator}`);
+        }
+        if (fresh.length === 0)
+            return fresh;
+        publishChangeSet(mergeChangeSets(removed));
+        for (const locator of fresh)
+            materialized.delete(locator);
+        moveTo({ ...status, ...attention() });
+        return fresh;
+    }
+    async function erased(local, locators) {
+        await local.erase(locators);
+        for (const locator of locators) {
+            const held = fences.get(locator);
+            if (held !== undefined)
+                held.erased = true;
+        }
+    }
+    async function loseRooms(locators) {
+        const fresh = fence(locators);
+        if (fresh.length > 0)
+            await durably((local) => erased(local, fresh));
     }
     function restored(key, persisted) {
         const prior = models.get(key);
@@ -644,8 +702,15 @@ export function composeRuntime(options) {
         return lastCompleted;
     }
     async function open() {
-        const opened = await openRuntimeStore();
+        if (closed)
+            throw new Error('runtime closed');
+        const opened = await openRuntimeStore(isFenced);
         store = opened;
+        const interrupted = await opened.fences();
+        for (const locator of interrupted) {
+            fences.set(locator, { at: discoveries, erased: false });
+            lastFenced.set(locator, ++fencings);
+        }
         const kept = options.shell.generation;
         const storedGeneration = await opened.generation();
         const loss = detectStorageLoss(storedGeneration, kept);
@@ -659,6 +724,8 @@ export function composeRuntime(options) {
             emitStorageLoss();
         }
         const lastCompleted = await readState(opened);
+        if (interrupted.length > 0)
+            await erased(opened, interrupted);
         moveTo({ ...status, lastCompleted, ...attention() });
         return opened;
     }
@@ -783,10 +850,10 @@ export function composeRuntime(options) {
             selection: taken(answers?.selection, held.selection, 'typed-selection'),
         };
     }
-    function publish(local, room, confirmed, landing = {}) {
+    function publish(local, room, confirmed, landing, live) {
         const { base, stored } = landing;
         return exclusive(async () => {
-            if (!continuing())
+            if (!live())
                 return true;
             const prior = replicas.get(room.locator);
             if (base !== undefined &&
@@ -814,6 +881,7 @@ export function composeRuntime(options) {
             list(room, true);
             publishChangeSet(set);
             moveTo({ ...status, ...attention() });
+            options.adapter.roomStream?.published(room.locator, roomVersion);
             return true;
         });
     }
@@ -936,6 +1004,8 @@ export function composeRuntime(options) {
         catch {
             return { outcome: 'refused', code: 'durable-write', retryable: true };
         }
+        if (fences.has(locator))
+            throw runtimeError('room-not-held', `No Local Replica for ${locator}`);
         for (const origin of withdrawn.keys())
             pendings.delete(origin);
         for (const [id, drafts] of drafted) {
@@ -965,6 +1035,8 @@ export function composeRuntime(options) {
             return;
         }
         await local.submit(locator, identifier, submission, lost);
+        if (fences.has(locator))
+            return;
         pendings.set(identifier, { ...state, submission, lost });
         const replica = replicas.get(locator);
         if (replica !== undefined)
@@ -975,6 +1047,8 @@ export function composeRuntime(options) {
         if (!continuing())
             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}`);
         pendings.set(identifier, { ...pendings.get(identifier), upload });
         if (!continuing())
             throw new Error('connection refused');
@@ -990,6 +1064,7 @@ export function composeRuntime(options) {
         }
         if (closed || authorization === undefined || refusal !== null)
             return UNCERTAIN;
+        const since = fencings;
         const transfer = ['transfer', 'history', locator, path];
         if (query.revision !== undefined)
             transfer.push(query.revision);
@@ -1004,6 +1079,8 @@ export function composeRuntime(options) {
                 ...(query.pageToken === undefined ? {} : { pageToken: query.pageToken }),
             });
             journal.record(`outcome history ${result.kind}`);
+            if (fencedSince(locator, since))
+                return failure({ kind: 'room-not-readable', locator });
             if (result.kind === 'scoped-refusal') {
                 const room = replicas.get(result.locator)?.confirmed.record;
                 if (room !== undefined)
@@ -1026,6 +1103,12 @@ export function composeRuntime(options) {
         }
         return null;
     }
+    function binaryRoom(request) {
+        if (request.kind === 'path')
+            return request.locator;
+        const scope = options.adapter.referrerScope(request.referrer);
+        return scope?.kind === 'room' ? scope.locator : null;
+    }
     async function readBinary(request) {
         if (closed || refusal !== null)
             return UNCERTAIN;
@@ -1037,12 +1120,16 @@ export function composeRuntime(options) {
         }
         if (closed || authorization === undefined || refusal !== null)
             return UNCERTAIN;
+        const since = fencings;
         journal.record(request.kind === 'path'
             ? `transfer binary ${request.locator} ${request.path}`
             : `transfer binary ${request.fileRef}`);
         try {
             const result = await options.adapter.binary(authorization, request);
             journal.record(`outcome binary ${result.kind}`);
+            const locator = binaryRoom(request);
+            if (locator !== null && fencedSince(locator, since))
+                return failure({ kind: 'room-not-readable', locator });
             if (result.kind === 'scoped-refusal') {
                 const room = replicas.get(result.locator)?.confirmed.record;
                 if (room !== undefined)
@@ -1166,11 +1253,11 @@ export function composeRuntime(options) {
             options.adapter.reached(locator, written, roomVersion) &&
             !options.adapter.reached(locator, roomVersion, written));
     }
-    async function pullRefresh(authorized, confirmed) {
-        if (!continuing())
+    async function pullRefresh(authorized, confirmed, live) {
+        if (!live())
             return unconfirmed;
         try {
-            const result = await refreshRoom(options.adapter, authorized, confirmed, (models, held) => remodel(confirmed.record.locator, models, held), continuing);
+            const result = await refreshRoom(options.adapter, authorized, confirmed, (models, held) => (live() ? remodel(confirmed.record.locator, models, held) : held), live);
             const detail = result.kind === 'advanced' ? result.confirmed.record.roomVersion : result.kind;
             journal.record(`transfer refresh ${confirmed.record.locator} ${detail}`);
             return result;
@@ -1180,33 +1267,39 @@ export function composeRuntime(options) {
             throw error;
         }
     }
-    function staging(local) {
+    function staging(local, live) {
         return {
             held: (locator) => transfers.get(locator) ?? null,
             staged: (record) => local.staged(record),
             stage: (record, page) => exclusive(async () => {
-                if (!continuing())
+                if (!live())
                     return false;
                 await local.stage(record, page);
                 transfers.set(record.locator, record);
                 return true;
             }),
             abandon: (locator) => exclusive(async () => {
-                if (!continuing())
+                if (!live())
                     return;
                 await local.abandon(locator);
                 transfers.delete(locator);
             }),
         };
     }
-    async function pullBootstrap(authorized, room, local) {
-        if (!continuing())
+    function reusable(room) {
+        const record = replicas.get(room.locator)?.confirmed.record;
+        if (record === undefined || record.replica.selection !== room.replica.selection)
+            return null;
+        return { documents: record.documents, revisions: record.revisions };
+    }
+    async function pullBootstrap(authorized, room, local, live) {
+        if (!live())
             return unconfirmed;
         try {
             const result = await bootstrapRoom(options.adapter, authorized, room, {
                 collection: modelOf(room.locator),
                 selection: modelOf(room.locator, 'typed-selection'),
-            }, (models, held) => remodel(room.locator, models, held), continuing, staging(local));
+            }, (models, held) => (live() ? remodel(room.locator, models, held) : held), live, staging(local, live), reusable(room));
             const detail = result.kind === 'staged' ? result.confirmed.record.roomVersion : result.kind;
             journal.record(`transfer bootstrap ${room.locator} ${detail}`);
             return result;
@@ -1216,11 +1309,11 @@ export function composeRuntime(options) {
             throw error;
         }
     }
-    async function advance(room, local, authorized) {
+    async function advance(room, local, authorized, live) {
         const held = replicas.get(room.locator);
         if (held !== undefined) {
-            const refreshed = await pullRefresh(authorized, held.confirmed);
-            if (!continuing())
+            const refreshed = await pullRefresh(authorized, held.confirmed, live);
+            if (!live())
                 return unconfirmed;
             if (refreshed.kind === 'still-current') {
                 stale.delete(room.locator);
@@ -1234,24 +1327,28 @@ export function composeRuntime(options) {
                 return null;
             }
             if (refreshed.kind === 'advanced') {
-                if (!(await publish(local, room, refreshed.confirmed, { base: held.confirmed }))) {
+                if (!(await publish(local, room, refreshed.confirmed, { base: held.confirmed }, live))) {
                     const now = replicas.get(room.locator)?.confirmed.record.roomVersion;
                     const reached = now !== undefined &&
                         options.adapter.reached(room.locator, now, refreshed.confirmed.record.roomVersion);
-                    return reached ? null : advance(room, local, authorized);
+                    return reached ? null : advance(room, local, authorized, live);
                 }
                 await retainModel(local, room, 'collection', modelOf(room.locator));
                 return null;
             }
             if (refreshed.kind !== 'beyond-horizon')
                 return refreshed;
+            if (opened !== null) {
+                owed.add(room.locator);
+                return unconfirmed;
+            }
         }
-        const bootstrapped = await pullBootstrap(authorized, room, local);
-        if (!continuing())
+        const bootstrapped = await pullBootstrap(authorized, room, local, live);
+        if (!live())
             return unconfirmed;
         if (bootstrapped.kind !== 'staged')
             return bootstrapped;
-        await publish(local, room, bootstrapped.confirmed, { stored: bootstrapped.stored });
+        await publish(local, room, bootstrapped.confirmed, { stored: bootstrapped.stored }, live);
         return null;
     }
     async function withhold(withheld, room, local, progress) {
@@ -1331,7 +1428,7 @@ export function composeRuntime(options) {
         if (applied.kind !== 'staged') {
             const state = pendings.get(submitted.id);
             await local.accept(room.locator, submitted.id, accepted.roomVersion);
-            if (state !== undefined)
+            if (state !== undefined && !fences.has(room.locator))
                 pendings.set(submitted.id, { ...state, accepted: accepted.roomVersion });
             emitQueue(room.locator);
             return applied;
@@ -1380,7 +1477,7 @@ export function composeRuntime(options) {
             let result;
             journal.record(`submission ${room.locator} ${head.id}`);
             await exclusive(() => mark(local, room.locator, head.id, { state: 'submitted' }, lost));
-            if (discoveryPaused)
+            if (discoveryPaused || fences.has(room.locator))
                 return;
             if (writesHeld()) {
                 await exclusive(() => mark(local, room.locator, head.id, submission, earlier));
@@ -1443,7 +1540,7 @@ export function composeRuntime(options) {
                 result.kind === 'expired' ||
                 result.kind === 'retryable-refusal') {
                 if (result.kind === 'expired') {
-                    const withheld = await advance(room, local, authorized);
+                    const withheld = await advance(room, local, authorized, continuing);
                     if (withheld !== null)
                         return withhold(withheld, room, local, progress);
                 }
@@ -1481,7 +1578,7 @@ export function composeRuntime(options) {
                 });
                 if (result.kind === 'expired')
                     continue;
-                const withheld = await advance(room, local, authorized);
+                const withheld = await advance(room, local, authorized, continuing);
                 if (withheld !== null)
                     return withhold(withheld, room, local, progress);
                 continue;
@@ -1498,9 +1595,9 @@ export function composeRuntime(options) {
         const awaited = new Promise((resolve) => {
             release = resolve;
         });
-        answering.set(locator, awaited);
+        answering.set(locator, { generation, answered: awaited });
         return () => {
-            if (answering.get(locator) === awaited)
+            if (answering.get(locator)?.answered === awaited)
                 answering.delete(locator);
             release();
         };
@@ -1616,8 +1713,10 @@ export function composeRuntime(options) {
             ];
         });
     }
-    async function synchronize(listed, local, progress, attempt) {
+    async function synchronize(listed, local, progress, attempt, live) {
         const prepared = await Promise.allSettled(listed.map((room) => prepareRoom(room, local, progress)));
+        if (!live())
+            return;
         const ready = listed.filter((_, index) => {
             const outcome = prepared[index];
             return outcome?.status === 'fulfilled' && outcome.value;
@@ -1626,9 +1725,10 @@ export function composeRuntime(options) {
             options.adapter.roomStream?.hold(heldRooms(ready));
             handed = true;
         }
+        discovering?.release();
         const loaded = await Promise.allSettled(ready
             .filter((room) => attempt === 'unstreamed' || !replicas.has(room.locator))
-            .map((room) => loadRoom(room, local, progress)));
+            .map((room) => roomTask(room.locator, (held) => loadRoom(room, local, progress, held))));
         const failed = [...prepared, ...loaded].find((room) => room.status === 'rejected');
         if (failed !== undefined)
             throw failed.reason;
@@ -1657,14 +1757,14 @@ export function composeRuntime(options) {
         }
         return true;
     }
-    async function caughtUp(room, local, progress) {
+    async function caughtUp(room, local, progress, live) {
         const held = replicas.get(room.locator)?.confirmed.record.roomVersion;
-        if (held === undefined || authorization === undefined)
+        if (held === undefined || authorization === undefined || !live())
             return;
         const behind = [announced.get(room.locator), room.roomVersion].some((later) => later !== undefined && !options.adapter.reached(room.locator, held, later));
         if (!behind)
             return;
-        const withheld = await advance(room, local, authorization);
+        const withheld = await advance(room, local, authorization, live);
         if (withheld !== null)
             await withhold(withheld, room, local, progress);
     }
@@ -1674,39 +1774,41 @@ export function composeRuntime(options) {
             return model.status === 'unavailable' && model.reason === 'revoked';
         });
     }
-    async function loadRoom(room, local, progress) {
-        if (discoveryPaused || authorization === undefined)
+    async function loadRoom(room, local, progress, live) {
+        if (!live() || authorization === undefined)
             return;
         if (replicas.has(room.locator) && revoked(room.locator)) {
-            await reload(room, local, progress);
+            await reload(room, local, progress, live);
             return;
         }
-        const withheld = await advance(room, local, authorization);
+        const withheld = await advance(room, local, authorization, live);
         if (withheld !== null) {
             await withhold(withheld, room, local, progress);
             return;
         }
-        await caughtUp(room, local, progress);
+        await caughtUp(room, local, progress, live);
     }
-    async function reload(room, local, progress) {
-        if (discoveryPaused || authorization === undefined)
+    async function reload(room, local, progress, live) {
+        if (!live() || authorization === undefined)
             return;
-        const bootstrapped = await pullBootstrap(authorization, room, local);
-        if (!continuing())
+        const bootstrapped = await pullBootstrap(authorization, room, local, live);
+        if (!live())
             return;
         if (bootstrapped.kind !== 'staged') {
             await withhold(bootstrapped, room, local, progress);
             return;
         }
-        await publish(local, room, bootstrapped.confirmed, { stored: bootstrapped.stored });
-        await caughtUp(room, local, progress);
+        await publish(local, room, bootstrapped.confirmed, { stored: bootstrapped.stored }, live);
+        await caughtUp(room, local, progress, live);
     }
-    async function discoverRooms(local, progress, attempt) {
+    async function discoverRooms(local, progress, attempt, live) {
         if (closed || authorization === undefined) {
             notifyReady();
             return;
         }
         moveTo(transferring(status));
+        discoveries += 1;
+        const started = discoveries;
         let result;
         try {
             result = await options.adapter.discover(authorization);
@@ -1714,7 +1816,8 @@ export function composeRuntime(options) {
         catch {
             result = { kind: 'transport-uncertainty' };
         }
-        if (closed) {
+        if (!live()) {
+            progress.complete = false;
             notifyReady();
             return;
         }
@@ -1784,8 +1887,7 @@ export function composeRuntime(options) {
             member = signedIn;
             emitMember();
         }
-        await applyDiscovery(result.rooms, local);
-        await synchronize(result.rooms, local, progress, attempt);
+        await synchronize(await applyDiscovery(result.rooms, started), local, progress, attempt, live);
     }
     async function ensureAuthorization() {
         if (authorization !== undefined)
@@ -1799,20 +1901,50 @@ export function composeRuntime(options) {
             throw error;
         }
     }
-    function task(work) {
+    async function admittedRead(work) {
+        if (roomReads.generation !== generation) {
+            roomReads = { generation, free: ROOM_READS, waiting: [] };
+        }
+        const reads = roomReads;
+        while (reads.free === 0)
+            await new Promise((admit) => reads.waiting.push(admit));
+        reads.free -= 1;
+        try {
+            await work();
+        }
+        finally {
+            reads.free += 1;
+            reads.waiting.shift()?.();
+        }
+    }
+    function roomTask(locator, work) {
+        return task(roomLane(locator), (live) => admittedRead(() => work(live)));
+    }
+    function task(lane, work) {
         if (stopping)
-            return chain;
-        chain = chain.then(work, work).catch(() => undefined);
-        return chain;
+            return Promise.resolve();
+        const held = lanes.get(lane);
+        const current = held?.generation === generation ? held : { generation, chain: Promise.resolve() };
+        const turn = current.generation;
+        const live = () => turn === generation && continuing();
+        const run = current.chain.then(() => work(live)).catch(() => undefined);
+        current.chain = run;
+        lanes.set(lane, current);
+        working.add(run);
+        void run.finally(() => working.delete(run));
+        return run;
     }
     function sync(attempt) {
-        return task(async () => {
-            if (closed || stopping || discoveryPaused) {
+        return task(OPENING_LANE, async (live) => {
+            if (!live()) {
                 notifyReady();
                 return;
             }
             const progress = { complete: true, reachable: true };
-            underway = attempt === 'opened' ? progress : null;
+            const gate = discover();
+            if (attempt === 'opened')
+                opened = generation;
+            underway = attempt === 'opened' ? { generation, progress } : null;
             if (attempt === 'opened')
                 streamed = progress;
             complete = false;
@@ -1821,12 +1953,12 @@ export function composeRuntime(options) {
             handed = false;
             try {
                 const local = await openLocal();
-                if (closed)
+                if (!live())
                     return;
                 await ensureAuthorization();
-                if (closed)
+                if (!live())
                     return;
-                await discoverRooms(local, progress, attempt);
+                await discoverRooms(local, progress, attempt, live);
             }
             catch {
                 progress.complete = false;
@@ -1834,17 +1966,21 @@ export function composeRuntime(options) {
                     progress.reachable = false;
             }
             finally {
+                gate.release();
                 notifyReady();
             }
+            if (!live())
+                return;
             if (attempt !== 'opened') {
-                await finishOpening(progress);
+                await finishOpening(progress, live);
                 return;
             }
             if (handed || closed || progress.reachable)
                 return;
             underway = null;
+            opened = null;
             journal.record('connection reopen');
-            await rest(progress);
+            await rest(progress, live);
             options.adapter.roomStream?.reopen();
         });
     }
@@ -1865,24 +2001,38 @@ export function composeRuntime(options) {
         });
     }
     function applyOpening(expired) {
-        return task(async () => {
-            const progress = underway;
+        const progress = underway?.generation === generation ? underway.progress : null;
+        const cycle = progress ?? { complete: true, reachable: true };
+        const replacing = reloadNow((room) => expired.includes(room.locator), cycle);
+        return task(OPENING_LANE, async (live) => {
             underway = null;
-            if (closed || stopping)
+            if (!live())
                 return;
             if (progress === null) {
-                await reloadExpired(expired);
+                await replacing;
+                await rest(cycle, live);
                 return;
             }
+            await roomsCarried(expired);
+            if (!live())
+                return;
+            if (opened === generation)
+                opened = null;
+            const replaced = new Set(owed);
+            owed.clear();
             try {
                 const local = await openLocal();
                 const held = [...discovered.values()].filter((room) => replicas.has(room.locator));
-                const reloading = held.filter((room) => expired.includes(room.locator) || revoked(room.locator));
-                const reloaded = await Promise.allSettled(reloading.map((room) => reload(room, local, progress)));
+                const reloading = held.filter((room) => !expired.includes(room.locator) &&
+                    (replaced.has(room.locator) || revoked(room.locator)));
+                const reloads = Promise.allSettled(reloading.map((room) => roomTask(room.locator, (current) => reload(room, local, progress, current))));
+                const reloaded = [...(await reloads), ...(await replacing)];
                 if (progress.reachable) {
-                    for (const room of held)
-                        if (!reloading.includes(room))
+                    for (const room of held) {
+                        if (!expired.includes(room.locator) && !reloading.includes(room)) {
                             await confirmModels(room, local);
+                        }
+                    }
                 }
                 const failed = reloaded.find((outcome) => outcome.status === 'rejected');
                 if (failed !== undefined)
@@ -1892,21 +2042,21 @@ export function composeRuntime(options) {
                 progress.complete = false;
                 progress.reachable = false;
             }
-            await finishOpening(progress);
+            if (live())
+                await finishOpening(progress, live);
         });
     }
-    async function reloadExpired(expired) {
-        const progress = { complete: true, reachable: true };
+    async function reloadNow(replaced, progress) {
         try {
             const local = await openLocal();
-            await Promise.allSettled([...discovered.values()]
-                .filter((room) => replicas.has(room.locator) && expired.includes(room.locator))
-                .map((room) => reload(room, local, progress)));
+            return await Promise.allSettled([...discovered.values()]
+                .filter((room) => replicas.has(room.locator) && replaced(room))
+                .map((room) => roomTask(room.locator, (live) => reload(room, local, progress, live))));
         }
         catch {
             progress.reachable = false;
+            return [];
         }
-        await rest(progress);
     }
     async function confirmModels(room, local) {
         for (const attached of ['collection', 'typed-selection']) {
@@ -1958,9 +2108,9 @@ export function composeRuntime(options) {
                 submitLater(locator);
         }
     }
-    async function finishOpening(progress) {
+    async function finishOpening(progress, live) {
         try {
-            if (closed || discoveryPaused) {
+            if (!live()) {
                 progress.complete = false;
                 return;
             }
@@ -1970,6 +2120,8 @@ export function composeRuntime(options) {
                 conversations.reconnected();
             const reading = { complete: true, reachable: true };
             await conversations.catchUp(reading);
+            if (progress.reachable && reading.reachable)
+                await conversations.resend(reading);
             if (!reading.reachable)
                 progress.reachable = false;
         }
@@ -1977,12 +2129,14 @@ export function composeRuntime(options) {
             progress.complete = false;
         }
         finally {
-            complete = progress.complete;
-            await rest(progress);
+            if (live()) {
+                complete = progress.complete;
+                await rest(progress, live);
+            }
         }
     }
-    async function rest(progress) {
-        if (closed)
+    async function rest(progress, live = () => !closed) {
+        if (!live())
             return;
         let lastCompleted = status.lastCompleted;
         let synced = complete && stale.size === 0 && !pending();
@@ -1990,6 +2144,8 @@ export function composeRuntime(options) {
             const completedAt = new Date().toISOString();
             try {
                 await (await openLocal()).complete(completedAt);
+                if (!live())
+                    return;
                 recorded = true;
                 lastCompleted = completedAt;
             }
@@ -2004,11 +2160,23 @@ export function composeRuntime(options) {
             ...attention(),
         });
     }
+    function discover() {
+        let release = () => { };
+        const done = new Promise((resolve) => {
+            release = resolve;
+        });
+        discovering = { generation, done, release };
+        return discovering;
+    }
     function applyRoom(locator, roomVersion) {
         announced.set(locator, roomVersion);
-        return task(async () => {
-            await answering.get(locator);
-            if (closed || stopping || discoveryPaused || authorization === undefined)
+        return task(roomLane(locator), async (live) => {
+            if (discovering?.generation === generation)
+                await discovering.done;
+            const saving = answering.get(locator);
+            if (saving?.generation === generation)
+                await saving.answered;
+            if (!live() || authorization === undefined)
                 return;
             const room = discovered.get(locator);
             const held = replicas.get(locator);
@@ -2019,25 +2187,41 @@ export function composeRuntime(options) {
                     options.adapter.reached(locator, held.confirmed.record.roomVersion, roomVersion))) {
                 return;
             }
-            const during = underway;
+            const during = underway?.generation === generation ? underway.progress : null;
             const progress = during ?? { complete: true, reachable: true };
             if (during === null)
                 moveTo(transferring(status));
             try {
                 const local = await openLocal();
-                const withheld = await advance(room, local, authorization);
-                if (withheld !== null)
-                    await withhold(withheld, room, local, progress);
+                await admittedRead(async () => {
+                    if (!live() || authorization === undefined)
+                        return;
+                    const withheld = await advance(room, local, authorization, live);
+                    if (withheld !== null)
+                        await withhold(withheld, room, local, progress);
+                });
             }
             catch {
                 stale.add(locator);
             }
             finally {
                 if (during === null)
-                    await rest(progress);
+                    await rest(progress, live);
             }
         });
     }
+    function roomsCarried(replacing) {
+        const replaced = new Set(replacing.map(roomLane));
+        return Promise.all([...lanes]
+            .filter(([lane, held]) => lane !== OPENING_LANE && !replaced.has(lane) && held.generation === generation)
+            .map(([, held]) => held.chain));
+    }
+    const receipts = {
+        heads: async () => (await openLocal()).receivedHeads(),
+        parts: async (key, count) => (await openLocal()).receivedParts(key, count),
+        keep: async (key, head, part) => (await openLocal()).keepReceived(key, head, part),
+        drop: async (keys) => (await openLocal()).dropReceived(keys),
+    };
     function observeStream() {
         const stream = options.adapter.roomStream;
         if (stream === undefined || withdrawStream !== undefined)
@@ -2047,6 +2231,7 @@ export function composeRuntime(options) {
                 return;
             if (event.kind === 'opened') {
                 socketOpen = true;
+                generation += 1;
                 void sync('opened');
             }
             else if (event.kind === 'closed')
@@ -2055,7 +2240,7 @@ export function composeRuntime(options) {
                 void applyOpening(event.expired);
             else
                 void applyRoom(event.locator, event.roomVersion);
-        });
+        }, receipts);
     }
     function writesHeld() {
         return serviceMode === 'write-halted' || haltedRefusal;
@@ -2093,14 +2278,15 @@ export function composeRuntime(options) {
         });
     }
     function scheduleCurrency() {
-        if (currencyQueued || closed || stopping)
+        if (currencyQueued === generation || closed || stopping)
             return;
-        currencyQueued = true;
-        void task(runCurrency);
+        currencyQueued = generation;
+        void task(CONVERSATION_LANE, runCurrency);
     }
-    async function runCurrency() {
-        currencyQueued = false;
-        if (closed || stopping || discoveryPaused)
+    async function runCurrency(live) {
+        if (currencyQueued === generation)
+            currencyQueued = null;
+        if (!live())
             return;
         await conversations.reconcile();
         if (conversations.current()) {
@@ -2115,7 +2301,7 @@ export function composeRuntime(options) {
         catch {
             progress.reachable = false;
         }
-        await rest(progress);
+        await rest(progress, live);
     }
     function close() {
         if (closed)
@@ -2146,7 +2332,7 @@ export function composeRuntime(options) {
     async function stop() {
         stopping = true;
         stopTimer();
-        await chain.catch(() => undefined);
+        await Promise.all(working);
         await Promise.all([...submitting.values()].map((run) => run.done));
         await mutations;
         close();
@@ -2398,14 +2584,16 @@ export function composeRuntime(options) {
             if (refusal === null || !refusal.reauthorizationOffered)
                 return;
             journal.record('connection reauthorize');
-            await chain.catch(() => undefined);
+            await Promise.all([...lanes.values()]
+                .filter((held) => held.generation === generation)
+                .map((held) => held.chain));
             await mutations;
             authorization = undefined;
             discoveryPaused = false;
             if (options.adapter.roomStream === undefined)
                 await sync('unstreamed');
             else
-                await task(ensureAuthorization);
+                await task(OPENING_LANE, ensureAuthorization);
         },
     };
     const reachable = {
@@ -2417,5 +2605,5 @@ export function composeRuntime(options) {
         watchPlan,
         search: searched,
     };
-    return { md, stop, watch, within: (reach) => narrowed(reachable, reach) };
+    return { md, stop, lose: loseRooms, watch, within: (reach) => narrowed(reachable, reach) };
 }