@agentshouse/mdruntime 0.1.0-cd26b960b7262 → 0.1.0-cd30853a1b15e

package/dist/install.js

@@ -1,11 +1,12 @@
 import { attachedModel } from './attached-model.js';
 import { bootstrapRoom } from './bootstrap.js';
 import { refusedForSpace } from './durability.js';
-import { name, usable } from './listing.js';
+import { uncaught } from './failure.js';
+import { name } from './listing.js';
 import { NO_MODEL } from './model.js';
+import { settle } from './queue.js';
 import { advancement } from './refresh.js';
-import { recoverReads, statusShown } from './shown.js';
-import { NO_INSTALL, } from './store.js';
+import { recoverReads } from './shown.js';
 import { unconfirmed } from './transfer.js';
 import { ROW_WEIGHT, yielded } from './turn.js';
 // Bytes still arriving are reported at most this often, so readiness is not rebuilt for every chunk the network hands over while a slow link still moves the figure.
@@ -78,28 +79,32 @@ function batchEnd(entries, from, bytes) {
     }
     return end;
 }
-export function installationOf(store, coverage, held) {
-    const bytes = { done: 0, total: 0 };
-    let installing = 0;
-    let downloading = false;
-    for (const { room, state } of coverage) {
-        if (state === 'unadmitted')
-            continue;
-        const install = store.installs.of(room);
-        const underway = state === 'acquiring' || (install.installing && state !== 'complete');
-        if (underway)
-            installing += 1;
-        if (underway && (install.streaming || install.arrived === null))
-            downloading = true;
-        const kept = underway ? NOTHING_HELD.bytes : (held.get(room)?.bytes ?? NOTHING_HELD.bytes);
-        const now = amountOf(install, kept);
-        const earlier = underway ? install.startedOver : null;
-        bytes.done += Math.max(now.done, earlier?.done ?? 0);
-        bytes.total += Math.max(now.total, earlier?.total ?? 0);
-    }
+const UNSHARED = {
+    installing: false,
+    downloading: false,
+    bytes: { done: 0, total: 0 },
+};
+export function installShare(store, { room, state }, held) {
+    if (state === 'unadmitted')
+        return UNSHARED;
+    const install = store.installs.of(room);
+    const underway = state === 'acquiring' || (install.installing && state !== 'complete');
+    const kept = underway ? NOTHING_HELD.bytes : (held.get(room)?.bytes ?? NOTHING_HELD.bytes);
+    const now = amountOf(install, kept);
+    const earlier = underway ? install.startedOver : null;
+    return {
+        installing: underway,
+        downloading: underway && (install.streaming || install.arrived === null),
+        bytes: {
+            done: Math.max(now.done, earlier?.done ?? 0),
+            total: Math.max(now.total, earlier?.total ?? 0),
+        },
+    };
+}
+export function installationOf(installing, downloading, bytes) {
     const step = installing === 0
         ? null
-        : downloading
+        : downloading > 0
             ? 'downloading'
             : bytes.done < bytes.total
                 ? 'writing'
@@ -112,15 +117,15 @@ export function roomInFlight(store, locator) {
 }
 function installing(runtime, locator) {
     runtime.store.installs.change(locator, (held) => ({ ...held, installing: true }));
-    runtime.store.readiness.queue();
+    runtime.store.readiness.queue([locator]);
 }
 function installed(runtime, locator) {
     if (!runtime.store.installs.of(locator).installing)
         return;
     runtime.store.installs.change(locator, (held) => ({ ...held, installing: false }));
-    runtime.store.readiness.queue();
+    runtime.store.readiness.queue([locator]);
 }
-export function sweep({ store, socket, journal }) {
+export function sweep({ store, socket }) {
     if (store.device.now().sweeping || socket.closed())
         return;
     store.device.set({ sweeping: true });
@@ -130,32 +135,23 @@ export function sweep({ store, socket, journal }) {
                 await yielded();
             }
         }
-        catch {
-            journal.record('erasure failed');
+        catch (error) {
+            uncaught(error);
         }
         finally {
             store.device.set({ sweeping: false });
         }
     })();
 }
-export function forgetInstall(store, locator) {
-    store.installs.change(locator, ({ installing }) => ({ ...NO_INSTALL, installing }));
-}
 export function caughtUpTo(runtime, locator) {
     if (!runtime.store.installs.of(locator).catching)
         return;
     runtime.store.installs.change(locator, (held) => ({ ...held, catching: false }));
-    recoverReads(runtime);
+    recoverReads(runtime, [locator]);
 }
 export function catching(store, locator) {
     store.installs.change(locator, (held) => ({ ...held, catching: true }));
 }
-export function confirmedAgain(store, locator) {
-    store.installs.change(locator, (held) => ({
-        ...held,
-        confirmations: held.confirmations + 1,
-    }));
-}
 export function standingAt(store, locator, held) {
     return { key: held?.key ?? null, confirmed: store.installs.of(locator).confirmations };
 }
@@ -270,7 +266,7 @@ function refreshingOf(runtime, local, locator, key, composition, liveness, repla
 export async function pullRefresh(runtime, authorized, record, liveness, hold, refresh) {
     if (!liveness())
         return unconfirmed;
-    const { store, journal } = runtime;
+    const { store } = runtime;
     const from = standingAt(store, record.locator, record);
     const local = await store.open();
     try {
@@ -284,11 +280,8 @@ export async function pullRefresh(runtime, authorized, record, liveness, hold, r
                 hold.take();
             }
         }, authorized, record, (models, kept) => (liveness() ? remodel(runtime, models, kept) : kept), liveness, refreshingOf(runtime, local, record.locator, record.key, store.composed(record), liveness, false, record.roomVersion));
-        if (result.kind !== 'advanced') {
-            journal.record(`transfer refresh ${record.locator} ${result.kind}`);
+        if (result.kind !== 'advanced')
             return result;
-        }
-        journal.record(`transfer refresh ${record.locator} ${result.record.roomVersion}`);
         return {
             kind: 'advanced',
             record: result.record,
@@ -299,14 +292,14 @@ export async function pullRefresh(runtime, authorized, record, liveness, hold, r
     catch (error) {
         if (refusedForSpace(error))
             return unconfirmed;
-        journal.record(`transfer refresh ${record.locator} transport-uncertainty`);
         throw error;
     }
 }
 async function abandoned(runtime, local, locator) {
     await local.abandon(locator);
     runtime.store.installs.change(locator, (held) => transferGone(setBack(held)));
-    recoverReads(runtime);
+    recoverReads(runtime, [locator]);
+    runtime.store.readiness.queue([locator]);
     sweep(runtime);
 }
 function staging(runtime, local, liveness, unheld) {
@@ -320,7 +313,7 @@ function staging(runtime, local, liveness, unheld) {
             if (done === null)
                 return false;
             store.installs.change(locator, (held) => built(held, done.done, done.text));
-            runtime.store.readiness.queue();
+            runtime.store.readiness.queue([locator]);
             if (done.done)
                 return true;
         }
@@ -344,9 +337,9 @@ function staging(runtime, local, liveness, unheld) {
                         arrived: bytes,
                         streaming: true,
                     }));
-                    if (!store.installs.arrivalDue(performance.now(), ARRIVAL_REPORT_MS))
-                        return;
-                    runtime.store.readiness.queue();
+                    const due = store.installs.arrivalsDue(locator, performance.now(), ARRIVAL_REPORT_MS);
+                    if (due.length > 0)
+                        runtime.store.readiness.queue(due);
                 },
                 end() {
                     if (ended)
@@ -355,7 +348,7 @@ function staging(runtime, local, liveness, unheld) {
                     if (!store.installs.of(locator).streaming)
                         return;
                     store.installs.change(locator, (held) => ({ ...held, streaming: false }));
-                    runtime.store.readiness.queue();
+                    runtime.store.readiness.queue([locator]);
                 },
             };
         },
@@ -383,7 +376,7 @@ function staging(runtime, local, liveness, unheld) {
                 underived: owed,
             }));
             installing(runtime, locator);
-            recoverReads(runtime);
+            recoverReads(runtime, [locator]);
             if (owed < store.deriveBytes())
                 return held;
             return (await derived(locator, key, composition)) ? held : null;
@@ -394,7 +387,9 @@ function staging(runtime, local, liveness, unheld) {
             if (!liveness())
                 return null;
             const prior = unheld === undefined ? await store.record(locator) : undefined;
-            const published = prior !== undefined && prior.replica.selection === record.selection ? prior.key : null;
+            const published = prior !== undefined && prior.declaration.replica.selection === record.selection
+                ? prior.key
+                : null;
             const kept = unheld?.staged ?? (await local.held()).staged.has(locator);
             if (published === null && !kept)
                 return { record: null, staged: new Set() };
@@ -416,7 +411,8 @@ function staging(runtime, local, liveness, unheld) {
                 done: { bytes },
             };
             store.installs.change(locator, (room) => ({ ...room, transfer: held }));
-            recoverReads(runtime);
+            recoverReads(runtime, [locator]);
+            store.readiness.queue([locator]);
             return { record: held, staged: parted };
         },
         derive: derived,
@@ -432,7 +428,8 @@ function staging(runtime, local, liveness, unheld) {
             if (!liveness())
                 return;
             store.installs.change(locator, (held) => transferGone(setBack(held)));
-            recoverReads(runtime);
+            recoverReads(runtime, [locator]);
+            store.readiness.queue([locator]);
         },
         release: (key) => store.exclusive(async () => {
             await local.release(key);
@@ -443,23 +440,20 @@ function staging(runtime, local, liveness, unheld) {
 export async function pullBootstrap(runtime, authorized, room, local, liveness, prior, from = runtime.socket.reads, unheld) {
     if (!liveness())
         return unconfirmed;
-    const { store, journal } = runtime;
+    const { store } = runtime;
     if (prior !== undefined) {
         catching(store, room.locator);
-        recoverReads(runtime);
+        recoverReads(runtime, [room.locator]);
     }
     try {
         const result = await bootstrapRoom(from, authorized, room, {
-            collection: prior?.model ?? runtime.socket.rooms.standing(room.locator).unheldModel ?? NO_MODEL,
+            collection: prior?.model ?? runtime.presence.unheldModel(room.locator) ?? NO_MODEL,
         }, runtime.builtIn, runtime.typedPaths, (models, held) => (liveness() ? remodel(runtime, models, held) : held), liveness, staging(runtime, local, liveness, unheld));
-        const detail = result.kind === 'staged' ? result.record.roomVersion : result.kind;
-        journal.record(`transfer bootstrap ${room.locator} ${detail}`);
         if (result.kind === 'staged' &&
             (await older(runtime, room.locator, result.record.roomVersion))) {
             caughtUpTo(runtime, room.locator);
             installed(runtime, room.locator);
             await abandoned(runtime, local, room.locator);
-            journal.record(`transfer bootstrap ${room.locator} older than shown`);
             return { kind: 'transport-uncertainty' };
         }
         if (result.kind !== 'staged') {
@@ -473,27 +467,27 @@ export async function pullBootstrap(runtime, authorized, room, local, liveness,
         installed(runtime, room.locator);
         if (refusedForSpace(error))
             return unconfirmed;
-        journal.record(`transfer bootstrap ${room.locator} transport-uncertainty`);
         throw error;
     }
 }
 export function publish(runtime, local, room, reached, landing, live) {
     const { store } = runtime;
-    const landed = store.exclusive(async () => {
+    let published = true;
+    const landed = settle(runtime, [room.locator], async (held) => {
         if (!live()) {
             caughtUpTo(runtime, room.locator);
-            return true;
+            return [];
         }
-        const work = await store.work(room.locator);
-        const prior = work.replica;
+        const prior = held.get(room.locator)?.replica;
         if (!standsAt(store, room.locator, prior?.record, landing.from)) {
+            published = false;
             if (landing.kind === 'refreshed') {
                 await local.unrefresh(reached.key);
-                return false;
+                return [];
             }
             caughtUpTo(runtime, room.locator);
             await abandoned(runtime, local, room.locator);
-            return false;
+            return [];
         }
         const record = landing.kind === 'refreshed' && prior !== undefined
             ? {
@@ -502,51 +496,40 @@ export function publish(runtime, local, room, reached, landing, live) {
                 ...(landing.remodelled ? { model: reached.model } : {}),
             }
             : reached;
-        let set;
-        try {
-            set = await runtime.settle(local, room.locator, work, record, work.queue, landing.kind === 'refreshed'
-                ? {
-                    room: true,
-                    view: 'refreshed',
-                    commit: { refreshed: true },
-                }
-                : {
-                    room: true,
-                    view: landing.refreshed ? 'refreshed' : 'confirmed',
-                    commit: {
+        return [
+            {
+                locator: room.locator,
+                record,
+                installed: landing.kind === 'refreshed'
+                    ? { refreshed: true }
+                    : {
                         published: { from: prior?.record.key ?? null },
                         ...(landing.refreshed ? { refreshed: true } : {}),
                     },
-                });
-        }
-        catch (error) {
-            if (!refusedForSpace(error))
-                throw error;
-            caughtUpTo(runtime, room.locator);
-            return true;
-        }
-        if (landing.kind === 'bootstrapped') {
-            runtime.socket.rooms.readied(room.locator);
-            store.installs.change(room.locator, (held) => ({
-                ...transferGone(held),
-                highest: null,
-                beyondHorizon: false,
-                startedOver: null,
-                catching: false,
-            }));
-            runtime.socket.rooms.stand(room.locator, { unheldModel: null });
-            if (prior !== undefined && prior.record.key !== record.key)
-                sweep(runtime);
-            void name(runtime, room.locator);
-        }
-        usable(runtime, room);
-        void runtime.store.changed(set);
-        await runtime.unpair(local);
-        void statusShown(runtime);
-        if (landing.kind === 'bootstrapped' && work.queue.length > 0) {
-            runtime.submitLater(room.locator);
-        }
-        return true;
+                after() {
+                    runtime.presence.installed(room.locator, landing.kind === 'bootstrapped');
+                    runtime.retries.succeeded('download', room.locator);
+                    store.prepareAgain(room.locator);
+                    if (landing.kind === 'bootstrapped') {
+                        store.installs.change(room.locator, (held) => ({
+                            ...transferGone(held),
+                            highest: null,
+                            beyondHorizon: false,
+                            startedOver: null,
+                            catching: false,
+                        }));
+                        if (prior !== undefined && prior.record.key !== record.key)
+                            sweep(runtime);
+                        void name(runtime, room.locator);
+                    }
+                },
+            },
+        ];
+    }).then(() => published, (error) => {
+        if (!refusedForSpace(error))
+            throw error;
+        caughtUpTo(runtime, room.locator);
+        return published;
     });
     return landing.kind === 'refreshed'
         ? landed

package/dist/lifecycle.d.ts

@@ -1,7 +1,7 @@
 import type { Runtime } from './runtime.js';
 export declare function scheduleCurrency(runtime: Runtime): void;
 export declare function spaceFreed(runtime: Runtime): void;
-export declare function close({ store, socket, conversations, recovery, liveQueries, figures }: Runtime): void;
+export declare function close({ store, socket, presence, conversations, recovery, liveQueries, figures, }: Runtime): void;
 export declare function stop(runtime: Runtime): Promise<void>;
 export declare function start(runtime: Runtime, signal: AbortSignal | undefined): void;
 //# sourceMappingURL=lifecycle.d.ts.map

package/dist/lifecycle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../src/lifecycle.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AA8M5C,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,QAOhD;AAED,wBAAgB,UAAU,CAAC,OAAO,EAAE,OAAO,QAS1C;AAED,wBAAgB,KAAK,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,QAAQ,EAAE,WAAW,EAAE,OAAO,EAAE,EAAE,OAAO,QAQ9F;AAED,wBAAsB,IAAI,CAAC,OAAO,EAAE,OAAO,iBAS1C;AAED,wBAAgB,KAAK,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,GAAG,SAAS,QAwCtE"}
+{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../src/lifecycle.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAoO5C,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,QAOhD;AAED,wBAAgB,UAAU,CAAC,OAAO,EAAE,OAAO,QAQ1C;AAED,wBAAgB,KAAK,CAAC,EACpB,KAAK,EACL,MAAM,EACN,QAAQ,EACR,aAAa,EACb,QAAQ,EACR,WAAW,EACX,OAAO,GACR,EAAE,OAAO,QAST;AAED,wBAAsB,IAAI,CAAC,OAAO,EAAE,OAAO,iBAS1C;AAED,wBAAgB,KAAK,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,GAAG,SAAS,QA2CtE"}

package/dist/lifecycle.js

@@ -1,13 +1,16 @@
-import { submitAll } from './acceptance.js';
 import { catchUpConversations, receiveConversationEvent, reconcileConversations, } from './conversation.js';
+import { declared } from './declaration.js';
+import { uncaught } from './failure.js';
 import { catching, replaced } from './install.js';
 import { connectionLost } from './locks.js';
 import { fenceLive } from './lost.js';
 import { cachedModels, revoked, settleModels } from './models.js';
 import { refuse } from './refusal.js';
-import { moveTo, recoverReads, rest, SERVICE_MODE_TOPIC, show, transferring } from './shown.js';
+import { roomsListed } from './room-list.js';
+import { moveTo, recoverReads, rest, SERVICE_MODE_TOPIC, show, submissionDue, transferring, } from './shown.js';
 import { applyRoom, changeAuthority, countAuthorityChange, finishOpening, loadRoom, OPENING_LANE, reload, resynchronize, sync, } from './sync.js';
 const CONVERSATION_LANE = 'conversations';
+const RELOADING = 'reloading';
 function closing(runtime, opened) {
     const { store, socket } = runtime;
     return socket.lanes.task(OPENING_LANE, async (live) => {
@@ -20,10 +23,10 @@ function closing(runtime, opened) {
     });
 }
 function closedSocket(runtime, lapsed, lost, opened) {
-    const { socket, conversations } = runtime;
+    const { socket, presence, conversations } = runtime;
     const { session } = socket;
     socket.notifyReady();
-    socket.rooms.unreadied();
+    presence.stopAsking();
     connectionLost(runtime);
     if (lost)
         conversations.lost();
@@ -43,26 +46,26 @@ function closedSocket(runtime, lapsed, lost, opened) {
     void closing(runtime, opened);
 }
 function owedReloads(runtime, expired, held) {
-    const { store, socket } = runtime;
-    const reloading = socket.rooms
-        .discoveredRooms()
+    const { store, presence } = runtime;
+    const reloading = presence
+        .rooms()
         .filter((room) => !expired.includes(room.locator) && revoked(held.get(room.locator)?.record.model))
         .map((room) => room.locator);
     for (const locator of reloading)
         catching(store, locator);
-    recoverReads(runtime);
+    recoverReads(runtime, reloading);
     return reloading;
 }
-async function reloadNow(runtime, replacing, progress, held, installing) {
-    const { store, socket } = runtime;
-    const { rooms, lanes } = socket;
-    const discovered = rooms.discoveredRooms();
+async function reloadNow(runtime, among, replacing, progress, held, installing) {
+    const { store, socket, presence } = runtime;
+    const { lanes } = socket;
+    const discovered = among === null ? presence.rooms() : among.flatMap((locator) => presence.room(locator) ?? []);
     const reloaded = discovered.filter((room) => held.has(room.locator) && !installing.has(room.locator) && replacing(room));
     const acquired = discovered.filter((room) => (!held.has(room.locator) || installing.has(room.locator)) &&
         room.replica.admission === 'admitted' &&
         replacing(room));
     for (const room of reloaded)
-        rooms.stand(room.locator, { reloadDue: true });
+        presence.reload(room.locator, true);
     try {
         const local = await store.open();
         const kept = acquired.length === 0 ? new Set() : (await local.held()).staged;
@@ -77,27 +80,30 @@ async function reloadNow(runtime, replacing, progress, held, installing) {
                 .roomTask(room.locator, (live) => loadRoom(runtime, room, local, progress, live, unheld))
                 .then(() => rest(runtime, progress));
         }
+        runtime.retries.succeeded('download', RELOADING);
     }
-    catch {
+    catch (error) {
+        runtime.retries.failed('download', RELOADING, error);
         for (const room of reloaded)
-            rooms.stand(room.locator, { reloadDue: false });
+            presence.reload(room.locator, false);
         progress.reachable = false;
     }
 }
 function caughtUpRooms(runtime, expired) {
-    const { store, socket } = runtime;
+    const { store, socket, presence } = runtime;
     const { session } = socket;
     const progress = session.now().underway;
     session.set({ underway: null });
     socket.named();
     const cycle = progress ?? { complete: true, reachable: true };
     replaced(store, expired);
-    const installing = store.installs.underway();
-    const held = progress === null ? store.rooms(expired) : store.rooms();
+    const among = progress === null ? expired : null;
+    const installing = store.installs.underway(among);
+    const held = among === null ? store.rooms() : store.rooms(among);
     const reloading = progress === null
         ? Promise.resolve([])
         : held.then((stored) => owedReloads(runtime, expired, stored));
-    const replacing = Promise.all([held, reloading]).then(([stored, owed]) => reloadNow(runtime, (room) => expired.includes(room.locator) || owed.includes(room.locator), cycle, stored, installing));
+    const replacing = Promise.all([held, reloading]).then(([stored, owed]) => reloadNow(runtime, among, (room) => expired.includes(room.locator) || owed.includes(room.locator), cycle, stored, installing));
     return socket.lanes.task(OPENING_LANE, async (live) => {
         if (!live())
             return;
@@ -112,14 +118,17 @@ function caughtUpRooms(runtime, expired) {
             if (progress.reachable) {
                 const stored = await held;
                 const owed = await reloading;
-                await settleModels(runtime, socket.rooms
-                    .discoveredRooms()
+                await settleModels(runtime, new Map(presence
+                    .rooms()
                     .filter((room) => stored.has(room.locator) &&
                     !expired.includes(room.locator) &&
-                    !owed.includes(room.locator)), 'current', local);
+                    !owed.includes(room.locator))
+                    .map((room) => [room.locator, declared(room)])), 'current', local);
             }
+            runtime.retries.succeeded('download', OPENING_LANE);
         }
-        catch {
+        catch (error) {
+            runtime.retries.failed('download', OPENING_LANE, error);
             progress.complete = false;
             progress.reachable = false;
         }
@@ -128,7 +137,7 @@ function caughtUpRooms(runtime, expired) {
     });
 }
 function signalled(runtime, mode) {
-    const { store, socket, journal } = runtime;
+    const { store, socket } = runtime;
     const { session } = socket;
     const { closed, serviceMode, haltedRefusal, openSignals } = session.now();
     if (closed)
@@ -140,12 +149,11 @@ function signalled(runtime, mode) {
         session.set({ haltedRefusal: false });
     if (mode !== serviceMode) {
         session.set({ serviceMode: mode });
-        store.readiness.queue();
-        journal.record(`service mode ${mode}`);
+        store.readiness.queue([]);
         store.tell(SERVICE_MODE_TOPIC, mode);
     }
     if (releasing)
-        submitAll(runtime);
+        void submissionDue(runtime);
 }
 async function runCurrency(runtime, live) {
     const { socket, conversations } = runtime;
@@ -156,7 +164,7 @@ async function runCurrency(runtime, live) {
         return;
     await reconcileConversations(conversations);
     if (conversations.current()) {
-        show(runtime);
+        await rest(runtime, null, live);
         return;
     }
     const progress = {
@@ -166,8 +174,10 @@ async function runCurrency(runtime, live) {
     moveTo(runtime, transferring(runtime));
     try {
         await catchUpConversations(conversations, progress);
+        runtime.retries.succeeded('conversations', CONVERSATION_LANE);
     }
-    catch {
+    catch (error) {
+        runtime.retries.failed('conversations', CONVERSATION_LANE, error);
         progress.reachable = false;
     }
     await rest(runtime, progress, live);
@@ -181,9 +191,8 @@ export function scheduleCurrency(runtime) {
     void socket.lanes.task(CONVERSATION_LANE, (live) => runCurrency(runtime, live));
 }
 export function spaceFreed(runtime) {
-    const { store, socket, journal } = runtime;
-    socket.rooms.standAll({ unpreparable: false });
-    journal.record('space freed');
+    const { store, socket } = runtime;
+    store.prepareAgain();
     store.readiness.queue();
     const { closed, authorization } = socket.session.now();
     if (closed || authorization === undefined)
@@ -193,10 +202,11 @@ export function spaceFreed(runtime) {
     else
         void resynchronize(runtime);
 }
-export function close({ store, socket, conversations, recovery, liveQueries, figures }) {
+export function close({ store, socket, presence, conversations, recovery, liveQueries, figures, }) {
     if (socket.closed())
         return;
     socket.close();
+    presence.close();
     conversations.close();
     void recovery.retire();
     liveQueries.close();
@@ -204,9 +214,9 @@ export function close({ store, socket, conversations, recovery, liveQueries, fig
     store.close();
 }
 export async function stop(runtime) {
-    const { store, socket, recovery } = runtime;
+    const { store, socket, presence, recovery } = runtime;
     socket.session.set({ stopping: true });
-    socket.rooms.unreadied();
+    presence.stopAsking();
     socket.stopReads();
     await recovery.retire();
     await socket.lanes.finished();
@@ -214,12 +224,12 @@ export async function stop(runtime) {
     close(runtime);
 }
 export function start(runtime, signal) {
-    const { store, socket, conversations, lastAnswers, recovery } = runtime;
+    const { store, socket, presence, conversations, lastAnswers, recovery } = runtime;
     const closeRuntime = () => close(runtime);
     socket.observeServiceMode((mode) => signalled(runtime, mode));
     socket.observeConversations((event) => {
         if (event.kind === 'list' || event.kind === 'listed' || event.kind === 'unlisted')
-            store.readiness.queue();
+            store.readiness.queue([]);
         receiveConversationEvent(conversations, event);
         if (event.kind !== 'gap' || conversations.current())
             return;
@@ -231,14 +241,15 @@ export function start(runtime, signal) {
         closeRuntime();
     socket.observe((event) => {
         if (event.kind === 'opened') {
-            socket.rooms.connectionLive();
+            presence.connectionLive();
             conversations.reopened();
             lastAnswers.reopened();
             recovery.resume();
         }
         else if (event.kind === 'discovered') {
+            const listed = roomsListed(runtime, event.discovery.roomList);
             if (event.missed)
-                countAuthorityChange(runtime);
+                countAuthorityChange(runtime, listed);
             void sync(runtime, 'opened', event.discovery);
         }
         else if (event.kind === 'closed') {
@@ -246,6 +257,8 @@ export function start(runtime, signal) {
         }
         else if (event.kind === 'caught-up')
             void caughtUpRooms(runtime, event.expired);
+        else if (event.kind === 'reported')
+            lastAnswers.again();
         else if (event.kind === 'authority-changed') {
             if (socket.isAnnounced() && socket.isOpen())
                 fenceLive(runtime, event.left);
@@ -260,8 +273,9 @@ export function start(runtime, signal) {
         if ((await local.facts()).capabilities.length > 0)
             socket.readyFromStore();
     })
-        .catch(() => {
+        .catch((error) => {
         socket.readyFromStore();
+        uncaught(error);
     });
     if (!socket.streamed)
         void sync(runtime, 'unstreamed', null);