@agentshouse/mdruntime 0.1.0-c0136de3edfbe → 0.1.0-c014edb0e9d9b

package/dist/surface.js

@@ -1,9 +1,12 @@
 import { called, located, readHistory, resolveReference } from './actions.js';
+import { chatDraftSurface, conversationSurface, watchConversation, watchConversationAgents, watchConversationList, } from './conversation.js';
+import { uncaught } from './failure.js';
+import { CLEANED_TOPIC, watchHoldings } from './holdings.js';
 import { reachedBy, writtenAfter } from './install.js';
 import { declarationOf, listingNow, modelIn, shownRooms } from './listing.js';
 import { stop } from './lifecycle.js';
 import { locked, lockedRooms, watchLocks } from './locks.js';
-import { modelTypes, NO_MODEL } from './model.js';
+import { modelTypes } from './model.js';
 import { observing } from './observation.js';
 import { watchReadiness } from './preparation.js';
 import { planned, rowsQuery, searched, watchPlan, watchPlanned } from './queries.js';
@@ -36,7 +39,7 @@ function watchMember({ store }, deliver) {
         .then(({ member }) => {
         if (watcher.held())
             deliver(member);
-    }, () => { });
+    }, uncaught);
     return watcher.stop;
 }
 function watchQueue(runtime, locator, deliver) {
@@ -58,14 +61,16 @@ function watching(runtime) {
         if (topic === 'room-drafts')
             return watchRoomDrafts(runtime, deliver);
         if (topic === 'conversation') {
-            return conversations.watch(input[0], input[1], deliver);
+            return watchConversation(conversations, input[0], input[1], deliver);
         }
         if (topic === 'conversations')
-            return conversations.watchList(deliver);
+            return watchConversationList(conversations, deliver);
         if (topic === 'agents')
-            return conversations.watchAgents(deliver);
+            return watchConversationAgents(conversations, deliver);
         if (topic === 'figures')
             return figures.watch(deliver, fail);
+        if (topic === 'holdings')
+            return watchHoldings(runtime, deliver, fail);
         if (topic === 'read')
             return lastAnswers.watch(input[0], input[1], deliver);
         if (topic === 'presentation')
@@ -112,10 +117,9 @@ function roomsOnce(runtime) {
 async function typesOf(runtime, locator) {
     const { store, builtIn } = runtime;
     const held = (await store.rooms([locator])).get(locator);
-    const fenced = store.fences.has(locator);
-    const room = fenced ? undefined : declarationOf(runtime, locator, held)?.room;
+    const room = declarationOf(runtime, locator, held)?.room;
     return {
-        collection: modelTypes(fenced ? NO_MODEL : modelIn(runtime, locator, held)),
+        collection: modelTypes(modelIn(runtime, locator, held)),
         typedSelection: (room?.typedSelection ?? null) === null ? null : modelTypes(builtIn),
     };
 }
@@ -142,11 +146,11 @@ function mdRuntime(runtime, watch) {
         search: (input) => searched(runtime, input, null),
         types: (locator) => typesOf(runtime, locator),
         roomDraft: roomDraftSurface(runtime),
-        conversation: conversations.surface,
-        chatDraft: conversations.chatDraft,
+        conversation: conversationSurface(conversations),
+        chatDraft: chatDraftSurface(conversations),
         presentation: presentationSurface(runtime),
-        save: (room, named, writtenBy) => store.exclusive(() => saveRoomDrafts(runtime, room, named, writtenBy)),
-        saveParts: (room, parts, writtenBy) => store.exclusive(() => saveParts(runtime, room, parts, writtenBy)),
+        save: (room, named, writtenBy) => saveRoomDrafts(runtime, room, named, writtenBy),
+        saveParts: (room, parts, writtenBy) => saveParts(runtime, room, parts, writtenBy),
         history: (locator, path, query) => readHistory(runtime, locator, path, query),
         resolve: (room, path, destination) => resolveReference(runtime, room, path, destination),
         binaryFile: binaryFileSurface(runtime),
@@ -159,7 +163,9 @@ function mdRuntime(runtime, watch) {
         log: () => journal.export(),
         async cleanUp() {
             const freed = await store.ask({ kind: 'opened.clean' });
-            return freed + ((await shell.cleanUp?.()) ?? 0);
+            const tidied = (await shell.cleanUp?.()) ?? 0;
+            store.tell(CLEANED_TOPIC, undefined);
+            return freed + tidied;
         },
         unsent: () => store.ask({ kind: 'authored.unsent' }),
         reset: () => shell.reset(),
@@ -169,7 +175,7 @@ function mdRuntime(runtime, watch) {
         persistence: () => store.device.now().persistence === 'granted',
         async retry() {
             journal.record('retry');
-            socket.rooms.standAll({ unpreparable: false });
+            store.prepareAgain();
             store.readiness.queue();
             if (store.space.full())
                 await store.space.probe();

package/dist/sync.d.ts

@@ -8,7 +8,6 @@ export type Attempt = 'opened' | 'unstreamed' | 'authorized';
 export declare const OPENING_LANE = "opening";
 export declare function advanced(runtime: Runtime, room: DiscoveredRoom, local: RuntimeStore, authorized: Authorization): Promise<Withheld | null>;
 export declare function withhold(runtime: Runtime, withheld: Withheld, room: DiscoveredRoom, local: RuntimeStore, progress: CycleProgress): Promise<void>;
-export declare function synchronize(runtime: Runtime, listed: readonly DiscoveredRoom[], local: RuntimeStore, progress: CycleProgress, attempt: Attempt, live: Live): Promise<void>;
 export declare function loadRoom(runtime: Runtime, room: DiscoveredRoom, local: RuntimeStore, progress: CycleProgress, live: Live, unheld?: Unheld): Promise<void>;
 export declare function reload(runtime: Runtime, room: DiscoveredRoom, local: RuntimeStore, progress: CycleProgress, live: Live): Promise<void>;
 export declare function finishOpening(runtime: Runtime, progress: CycleProgress, live: Live): Promise<void>;

package/dist/sync.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sync.d.ts","sourceRoot":"","sources":["../src/sync.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,eAAe,EACf,cAAc,EACd,SAAS,EACT,UAAU,EACX,MAAM,cAAc,CAAC;AAKtB,OAAO,EASL,KAAK,MAAM,EACX,KAAK,QAAQ,EACd,MAAM,cAAc,CAAC;AAOtB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAE5C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,KAAK,EAAe,YAAY,EAAE,MAAM,YAAY,CAAC;AAG5D,MAAM,MAAM,OAAO,GAAG,QAAQ,GAAG,YAAY,GAAG,YAAY,CAAC;AAE7D,eAAO,MAAM,YAAY,YAAY,CAAC;AA4FtC,wBAAgB,QAAQ,CACtB,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,YAAY,EACnB,UAAU,EAAE,aAAa,GACxB,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,CAI1B;AAED,wBAAsB,QAAQ,CAC5B,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,YAAY,EACnB,QAAQ,EAAE,aAAa,GACtB,OAAO,CAAC,IAAI,CAAC,CA8Bf;AAyDD,wBAAsB,WAAW,CAC/B,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,SAAS,cAAc,EAAE,EACjC,KAAK,EAAE,YAAY,EACnB,QAAQ,EAAE,aAAa,EACvB,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,IAAI,iBAkCX;AAiBD,wBAAsB,QAAQ,CAC5B,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,YAAY,EACnB,QAAQ,EAAE,aAAa,EACvB,IAAI,EAAE,IAAI,EACV,MAAM,CAAC,EAAE,MAAM,iBAmBhB;AAED,wBAAsB,MAAM,CAC1B,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,YAAY,EACnB,QAAQ,EAAE,aAAa,EACvB,IAAI,EAAE,IAAI,iBA0BX;AAuDD,wBAAsB,aAAa,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAE,IAAI,EAAE,IAAI,iBAgCxF;AAED,wBAAgB,IAAI,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,SAAS,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAsC/F;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAsB7D;AAED,wBAAgB,oBAAoB,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,EAAE,OAAO,QAK3E;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CA6BxF;AAyDD,wBAAgB,SAAS,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAyD7E"}
+{"version":3,"file":"sync.d.ts","sourceRoot":"","sources":["../src/sync.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,eAAe,EACf,cAAc,EACd,SAAS,EACT,UAAU,EACX,MAAM,cAAc,CAAC;AAUtB,OAAO,EASL,KAAK,MAAM,EACX,KAAK,QAAQ,EACd,MAAM,cAAc,CAAC;AAQtB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAU5C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,KAAK,EAAe,YAAY,EAAE,MAAM,YAAY,CAAC;AAG5D,MAAM,MAAM,OAAO,GAAG,QAAQ,GAAG,YAAY,GAAG,YAAY,CAAC;AAE7D,eAAO,MAAM,YAAY,YAAY,CAAC;AA2FtC,wBAAgB,QAAQ,CACtB,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,YAAY,EACnB,UAAU,EAAE,aAAa,GACxB,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,CAI1B;AAED,wBAAsB,QAAQ,CAC5B,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,YAAY,EACnB,QAAQ,EAAE,aAAa,GACtB,OAAO,CAAC,IAAI,CAAC,CAiCf;AA4GD,wBAAsB,QAAQ,CAC5B,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,YAAY,EACnB,QAAQ,EAAE,aAAa,EACvB,IAAI,EAAE,IAAI,EACV,MAAM,CAAC,EAAE,MAAM,iBAmBhB;AAED,wBAAsB,MAAM,CAC1B,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,YAAY,EACnB,QAAQ,EAAE,aAAa,EACvB,IAAI,EAAE,IAAI,iBA0BX;AAsDD,wBAAsB,aAAa,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAE,IAAI,EAAE,IAAI,iBA8BxF;AAED,wBAAgB,IAAI,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,SAAS,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAwC/F;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAiB7D;AAED,wBAAgB,oBAAoB,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,EAAE,OAAO,QAK3E;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CA+BxF;AAyDD,wBAAgB,SAAS,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CA4D7E"}

package/dist/sync.js

@@ -1,21 +1,25 @@
-import { submitAll, submitLater } from './acceptance.js';
 import { resendCalls, resendLater } from './actions.js';
+import { catchUpConversations, reconcileConversations, resendConversations, } from './conversation.js';
+import { declared, sameDeclaration } from './declaration.js';
 import { applyDiscovery, discoverRooms, malformed, signIn } from './discovery.js';
 import { behind, caughtUpTo, publish, pullBootstrap, pullRefresh, reachedBy, replaced, standingAt, } from './install.js';
-import { heldRooms, listHeld, name, readable } from './listing.js';
-import { declaredAsHeld, keepNaming, retainModel, revoked, scoped } from './models.js';
+import { heldRooms, name } from './listing.js';
+import { retainModel, revoked, scoped } from './models.js';
+import { refusalError } from './failure.js';
 import { refuse } from './refusal.js';
-import { emitRooms, moveTo, rest, roomUnreadable, transferring, AUTHORITY_TOPIC } from './shown.js';
+import { emitRooms, moveTo, rest, roomUnreadable, submissionDue, transferring, AUTHORITY_TOPIC, } from './shown.js';
 import { unconfirmed } from './transfer.js';
 export const OPENING_LANE = 'opening';
+const FINISHING = 'finishing';
 async function advance(runtime, room, local, authorized, running, unheld) {
-    const { store, socket } = runtime;
+    const { store, socket, presence } = runtime;
     const live = () => running() && !store.space.full();
     if (!live())
         return unconfirmed;
     const held = unheld === undefined ? await store.record(room.locator) : undefined;
     if (socket.streamed && (held !== undefined || !store.installs.of(room.locator).beyondHorizon)) {
-        socket.rooms.stand(room.locator, { stale: false });
+        presence.stood(room.locator, false);
+        runtime.retries.succeeded('download', room.locator);
         await name(runtime, room.locator);
         return null;
     }
@@ -26,7 +30,7 @@ async function advance(runtime, room, local, authorized, running, unheld) {
             return advance(runtime, room, local, authorized, live);
         if (refreshed !== 'beyond-horizon')
             return refreshed;
-        if (socket.rooms.standing(room.locator).reloadDue)
+        if (presence.standing(room.locator).reloadDue)
             return unconfirmed;
         replaced(store, [room.locator]);
     }
@@ -44,18 +48,15 @@ async function advance(runtime, room, local, authorized, running, unheld) {
         : advance(runtime, room, local, authorized, live);
 }
 async function refreshedRoom(runtime, room, local, authorized, held, live, hold, refresh) {
-    const { store, socket } = runtime;
-    const { rooms } = socket;
+    const { store, socket, presence } = runtime;
     const refreshed = await pullRefresh(runtime, authorized, held, live, hold, refresh);
     if (!live())
         return unconfirmed;
     if (refreshed.kind === 'still-current') {
-        rooms.stand(room.locator, { stale: false });
-        if (rooms.standing(room.locator).unreadable) {
-            rooms.stand(room.locator, { refusal: null });
-            readable(runtime, room);
+        presence.stood(room.locator, false);
+        runtime.retries.succeeded('download', room.locator);
+        if (presence.readable(room.locator))
             emitRooms(runtime);
-        }
         return null;
     }
     if (refreshed.kind === 'advanced') {
@@ -69,7 +70,7 @@ async function refreshedRoom(runtime, room, local, authorized, held, live, hold,
             const reached = now !== undefined && socket.reads.reached(room.locator, now, refreshed.record.roomVersion);
             return reached ? null : 'behind';
         }
-        await retainModel(runtime, local, room, null);
+        await retainModel(runtime, room.locator, declared(room), null);
         return null;
     }
     return refreshed.kind === 'beyond-horizon' ? 'beyond-horizon' : refreshed;
@@ -78,25 +79,29 @@ export function advanced(runtime, room, local, authorized) {
     return runtime.socket.lanes.inRoom(room.locator, (live) => advance(runtime, room, local, authorized, live));
 }
 export async function withhold(runtime, withheld, room, local, progress) {
-    const { store, socket, journal } = runtime;
-    const { rooms } = socket;
-    if (withheld.kind === 'unconfirmed' || store.fences.has(room.locator))
+    const { presence, journal } = runtime;
+    if (withheld.kind === 'unconfirmed' || presence.lost(room.locator))
         return;
     if (withheld.kind === 'not-ready') {
         progress.complete = false;
         askAgain(runtime, room.locator);
         return;
     }
-    rooms.stand(room.locator, { stale: true });
+    if (withheld.kind === 'transport-uncertainty') {
+        runtime.retries.uncertain('download', room.locator, withheld);
+    }
+    else if (withheld.kind === 'retryable-refusal') {
+        runtime.retries.failed('download', room.locator, refusalError(withheld));
+    }
     if (withheld.kind === 'transport-uncertainty' || withheld.kind === 'retryable-refusal') {
         const reset = withheld.kind === 'retryable-refusal' ? withheld.reset : undefined;
-        rooms.stand(room.locator, { repairable: { reset } });
+        presence.stood(room.locator, true, { reset });
         repairLater(runtime, room.locator, reset === undefined ? { again: true } : { at: Date.parse(reset) });
     }
     else
-        rooms.stand(room.locator, { repairable: null });
+        presence.stood(room.locator, true, null);
     if (withheld.kind === 'scoped-refusal') {
-        await scoped(runtime, withheld, room, local);
+        await scoped(runtime, withheld, room.locator, declared(room));
     }
     else if (withheld.kind === 'transport-uncertainty') {
         progress.reachable = false;
@@ -105,16 +110,16 @@ export async function withhold(runtime, withheld, room, local, progress) {
         journal.record(`refusal ${withheld.kind} ${withheld.code}`);
     }
     else if (withheld.kind === 'room-not-readable') {
-        roomUnreadable(runtime, room);
+        roomUnreadable(runtime, room.locator);
     }
     else if (withheld.kind === 'revoked-authorization') {
         await refuse(runtime, 'revoked-authorization');
     }
 }
 function askAgain(runtime, locator) {
-    const { store, socket } = runtime;
-    socket.rooms.askAgain(locator, () => {
-        const room = socket.rooms.discovered(locator);
+    const { store, socket, presence } = runtime;
+    presence.askAgain(locator, () => {
+        const room = presence.room(locator);
         if (socket.closed() ||
             socket.stopping() ||
             (socket.streamed && !socket.isOpen()) ||
@@ -127,50 +132,47 @@ function askAgain(runtime, locator) {
             .then(() => rest(runtime, progress), () => undefined);
     });
 }
-async function prepareRoom(runtime, room, local, progress, prior) {
+async function prepareRoom(runtime, room, progress, prior) {
     const { socket, journal } = runtime;
     const { session } = socket;
     if (socket.closed() || session.now().authorization === undefined) {
         progress.complete = false;
         return false;
     }
-    if (prior !== undefined && prior.replica.selection !== room.replica.selection) {
-        listHeld(runtime, room.locator);
+    if (prior !== undefined && prior.declaration.replica.selection !== room.replica.selection) {
         emitRooms(runtime);
         journal.record(`selection changed ${room.locator}`);
         progress.complete = false;
         return false;
     }
-    if (prior !== undefined && !declaredAsHeld(prior, room)) {
-        await retainModel(runtime, local, room, null);
-    }
-    if (prior !== undefined && (prior.name !== room.name || prior.handle !== room.handle)) {
-        await keepNaming(runtime, local, room);
+    const declaration = declared(room);
+    if (prior !== undefined && !sameDeclaration(prior.declaration, declaration)) {
+        await retainModel(runtime, room.locator, declaration, null);
     }
     const { paused, authorization } = session.now();
     if (paused || authorization === undefined)
         return false;
     return room.replica.admission === 'admitted';
 }
-export async function synchronize(runtime, listed, local, progress, attempt, live) {
+async function synchronize(runtime, listed, local, progress, attempt, live) {
     const { store, socket } = runtime;
     const heldNow = await store.rooms(listed.map(({ locator }) => locator));
-    const prepared = await Promise.allSettled(listed.map((room) => prepareRoom(runtime, room, local, progress, heldNow.get(room.locator)?.record)));
+    const prepared = await Promise.allSettled(listed.map((room) => prepareRoom(runtime, room, progress, heldNow.get(room.locator)?.record)));
     if (!live())
         return;
     const ready = listed.filter((_, index) => {
         const outcome = prepared[index];
-        return outcome?.status === 'fulfilled' && outcome.value;
+        return outcome.status === 'fulfilled' && outcome.value;
     });
-    const held = await heldRooms(runtime, ready);
-    if (!live())
-        return;
     if (attempt === 'opened') {
+        const held = await heldRooms(runtime, ready);
+        if (!live())
+            return;
         socket.hand(held);
     }
-    const kept = attempt === 'unstreamed'
-        ? new Set()
-        : new Set((await store.rooms(ready.map(({ locator }) => locator))).keys());
+    const kept = attempt === 'authorized'
+        ? new Set((await store.rooms(ready.map(({ locator }) => locator))).keys())
+        : new Set();
     for (const room of ready) {
         if (attempt === 'opened' || kept.has(room.locator)) {
             if (attempt === 'authorized')
@@ -203,7 +205,7 @@ export async function loadRoom(runtime, room, local, progress, live, unheld) {
         return;
     const prior = unheld === undefined ? await store.record(room.locator) : undefined;
     if (prior !== undefined) {
-        if (!(await prepareRoom(runtime, room, local, progress, prior)))
+        if (!(await prepareRoom(runtime, room, progress, prior)))
             return;
         if (revoked(prior.model)) {
             await reload(runtime, room, local, progress, live);
@@ -218,10 +220,10 @@ export async function loadRoom(runtime, room, local, progress, live, unheld) {
     await caughtUp(runtime, room, local, progress, live);
 }
 export async function reload(runtime, room, local, progress, live) {
-    const { store, socket } = runtime;
+    const { store, socket, presence } = runtime;
     try {
         if (live())
-            socket.rooms.stand(room.locator, { reloadDue: false });
+            presence.reload(room.locator, false);
         const { authorization } = socket.session.now();
         if (!live() || authorization === undefined)
             return;
@@ -241,24 +243,23 @@ export async function reload(runtime, room, local, progress, live) {
     }
 }
 function repairLater(runtime, locator, when) {
-    const { socket, recovery } = runtime;
-    if (!socket.isOpen() || socket.rooms.standing(locator).repairing)
+    const { socket, presence, recovery } = runtime;
+    if (!socket.isOpen() || presence.standing(locator).repairing)
         return;
     void recovery.attempt(`repair ${locator}`, (signal) => repairPass(runtime, locator, signal), when);
 }
 async function repairPass(runtime, locator, signal) {
-    const { store, socket } = runtime;
-    const { rooms } = socket;
-    const room = rooms.discovered(locator);
+    const { store, socket, presence } = runtime;
+    const room = presence.room(locator);
     if (!socket.isOpen() ||
         !socket.continuing() ||
         socket.stopping() ||
-        !rooms.standing(locator).stale)
+        !presence.standing(locator).stale)
         return 'done';
     if (room === undefined || room.replica.admission !== 'admitted')
         return 'done';
     const progress = { complete: true, reachable: true };
-    rooms.stand(locator, { repairing: true });
+    presence.repairing(locator, true);
     try {
         const local = await store.open();
         await socket.lanes.roomTask(locator, async (live) => {
@@ -271,41 +272,39 @@ async function repairPass(runtime, locator, signal) {
         });
     }
     catch {
-        rooms.stand(locator, { stale: true });
+        presence.stood(locator, true);
         progress.reachable = false;
     }
     finally {
-        rooms.stand(locator, { repairing: false });
+        presence.repairing(locator, false);
     }
     if (signal.aborted)
         return 'done';
     await rest(runtime, progress);
-    if (!rooms.standing(locator).stale) {
-        if ((await (await store.open()).order(locator)).length > 0)
-            submitLater(runtime, locator);
+    if (!presence.standing(locator).stale) {
+        await submissionDue(runtime, [locator]);
         return 'done';
     }
-    const { repairable } = rooms.standing(locator);
+    const { repairable } = presence.standing(locator);
     if (repairable === null)
         return 'done';
     return repairable.reset === undefined ? 'again' : { at: Date.parse(repairable.reset) };
 }
 export async function finishOpening(runtime, progress, live) {
-    const { socket, conversations, recovery } = runtime;
+    const { socket, presence, conversations, recovery } = runtime;
     try {
         if (!live()) {
             progress.complete = false;
             return;
         }
-        await submitAll(runtime);
-        for (const locator of socket.rooms.standingWhere(({ stale, repairable }) => stale && repairable !== null)) {
+        await submissionDue(runtime);
+        for (const locator of presence.repairsOwed())
             repairLater(runtime, locator, {});
-        }
-        await conversations.reconcile();
+        await reconcileConversations(conversations);
         const reading = { complete: true, reachable: true };
-        await conversations.catchUp(reading);
+        await catchUpConversations(conversations, reading);
         if (progress.reachable && reading.reachable)
-            await conversations.resend(reading);
+            await resendConversations(conversations, reading);
         if (progress.reachable) {
             void recovery.attempt('calls', (signal) => resendCalls(runtime, signal));
         }
@@ -313,8 +312,10 @@ export async function finishOpening(runtime, progress, live) {
             progress.reachable = false;
             resendLater(runtime);
         }
+        runtime.retries.succeeded('conversations', FINISHING);
     }
-    catch {
+    catch (error) {
+        runtime.retries.failed('conversations', FINISHING, error);
         progress.complete = false;
     }
     finally {
@@ -350,8 +351,10 @@ export function sync(runtime, attempt, found) {
             const listed = await discoverRooms(runtime, local, progress, live, found);
             if (listed !== null)
                 await synchronize(runtime, listed, local, progress, attempt, live);
+            runtime.retries.succeeded('connection', OPENING_LANE);
         }
-        catch {
+        catch (error) {
+            runtime.retries.failed('connection', OPENING_LANE, error);
             progress.complete = false;
             if (attempt === 'opened' && !socket.isHanded())
                 progress.reachable = false;
@@ -372,7 +375,7 @@ export function sync(runtime, attempt, found) {
     });
 }
 export function resynchronize(runtime) {
-    const { store, socket } = runtime;
+    const { store, socket, presence } = runtime;
     return socket.lanes.task(OPENING_LANE, async (live) => {
         if (!live() || !socket.isAnnounced())
             return;
@@ -382,9 +385,11 @@ export function resynchronize(runtime) {
             const local = await store.open();
             if (!live())
                 return;
-            await synchronize(runtime, socket.rooms.discoveredRooms(), local, progress, 'unstreamed', live);
+            await synchronize(runtime, presence.rooms(), local, progress, 'unstreamed', live);
+            runtime.retries.succeeded('download', OPENING_LANE);
         }
-        catch {
+        catch (error) {
+            runtime.retries.failed('download', OPENING_LANE, error);
             progress.complete = false;
         }
         if (live())
@@ -422,8 +427,10 @@ export function changeAuthority(runtime, change) {
             session.set({ discoveries });
             const listed = await applyDiscovery(runtime, change.rooms, discoveries, change.left);
             await synchronize(runtime, listed, local, progress, 'authorized', live);
+            runtime.retries.succeeded('connection', OPENING_LANE);
         }
-        catch {
+        catch (error) {
+            runtime.retries.failed('connection', OPENING_LANE, error);
             progress.complete = false;
         }
         if (!live())
@@ -468,8 +475,8 @@ async function installCarried(runtime, room, local, change, live, progress) {
     await publish(runtime, local, room, bootstrapped.record, { kind: 'bootstrapped', refreshed: bootstrapped.refreshed, from }, live);
 }
 export function applyRoom(runtime, change) {
-    const { store, socket } = runtime;
-    const { rooms, session } = socket;
+    const { store, socket, presence } = runtime;
+    const { session } = socket;
     const { locator } = change;
     if (socket.stopping())
         return Promise.resolve();
@@ -482,7 +489,7 @@ export function applyRoom(runtime, change) {
             for (;;) {
                 if (!live())
                     return null;
-                const room = rooms.discovered(locator);
+                const room = presence.room(locator);
                 if (room === undefined || room.replica.admission !== 'admitted')
                     return null;
                 const held = await store.record(locator);
@@ -492,7 +499,7 @@ export function applyRoom(runtime, change) {
                     await installCarried(runtime, room, local, change, live, progress);
                     return progress;
                 }
-                if (held.replica.selection !== room.replica.selection)
+                if (held.declaration.replica.selection !== room.replica.selection)
                     return null;
                 const at = held.roomVersion;
                 if (socket.reads.reached(locator, at, change.roomVersion))
@@ -513,17 +520,19 @@ export function applyRoom(runtime, change) {
                     remodelled: refreshed.remodelled,
                 };
                 if (await publish(runtime, local, room, refreshed.record, landing, writing)) {
-                    rooms.stand(locator, { stale: false });
-                    if (!declaredAsHeld(held, room))
-                        await retainModel(runtime, local, room, null);
+                    presence.stood(locator, false);
+                    const declaration = declared(room);
+                    if (!sameDeclaration(held.declaration, declaration))
+                        await retainModel(runtime, locator, declaration, null);
                     return progress;
                 }
             }
         }
-        catch {
-            if (!rooms.standing(locator).stale)
+        catch (error) {
+            runtime.retries.failed('download', locator, error);
+            if (!presence.standing(locator).stale)
                 void name(runtime, locator);
-            rooms.stand(locator, { stale: true });
+            presence.stood(locator, true);
             return progress;
         }
     })

package/dist/tables.d.ts

@@ -1,9 +1,8 @@
 import { type QueryAnswer, type QueryRoom } from './compile.js';
 import type { Composed } from './collection.js';
 import type { UnsentWork } from './durability.js';
-import type { JobMarker } from './job.js';
 import { type ConversationWrite, type HeldConversation, type HeldRow, type MessageWindow } from './messages.js';
-import type { Plan } from './query.js';
+import type { GroupTotal, Plan } from './query.js';
 import { type ReadAt } from './reads.js';
 import { type ConversationTally, type RoomTally } from './tallies.js';
 import { type Committed, type Covering, type HeldEntry, type HeldLocators, type HeldRoomRow, type HeldRoomWork, type ReplicaOpened, type Referrer, type Resumed, type RoomCommit, type StoredEntry, type TypedEntry, type View } from './stored.js';
@@ -53,7 +52,7 @@ export interface SqliteDatabase {
 export declare function sqliteConnection(engine: SqliteEngine, database: SqliteDatabase): Connection;
 export declare const FILE_PART_BYTES = 1048576;
 export declare const RUNTIME_TABLES: readonly string[];
-export type AuthoredFact = 'holder' | 'binding' | 'generation';
+export type AuthoredFact = 'holder' | 'generation';
 export type StoredFile = {
     readonly key: string;
     readonly blob: Blob;
@@ -116,6 +115,13 @@ export type OpenedFile = {
     readonly byteLength: number;
     readonly mediaType: string;
 };
+export type OpenedRoom = GroupTotal & {
+    readonly room: string;
+};
+export type OpenedHeld = {
+    readonly rooms: readonly OpenedRoom[];
+    readonly cleanable: number;
+};
 type Asked<A, R> = {
     readonly asked: A;
     readonly answer: R;
@@ -242,7 +248,6 @@ export interface RuntimeRequests {
     }, readonly Referrer[]>;
     readonly 'replica.folders': Asked<{
         readonly key: number;
-        readonly view: View;
         readonly paths: readonly string[];
     }, readonly string[]>;
     readonly 'replica.typedWithin': Asked<{
@@ -345,6 +350,7 @@ export interface RuntimeRequests {
         readonly key: string;
     }, null>;
     readonly 'opened.clean': Asked<Nothing, number>;
+    readonly 'opened.held': Asked<Nothing, OpenedHeld>;
     readonly 'file.part': Asked<{
         readonly key: string;
         readonly part: number;
@@ -370,9 +376,6 @@ export interface RuntimeRequests {
     readonly 'conversation.rows': Asked<{
         readonly conversations: readonly string[];
     }, readonly HeldRow[]>;
-    readonly 'conversation.jobs': Asked<{
-        readonly conversation: string;
-    }, readonly JobMarker[]>;
     readonly 'conversation.tallies': Asked<{
         readonly conversations: readonly string[] | null;
         readonly since: string;
@@ -402,6 +405,8 @@ export interface RuntimeDatabase {
 export declare function isRuntime(request: {
     readonly kind: string;
 }): request is RuntimeRequest;
-export declare function readsRuntime(request: RuntimeRequest): boolean;
+export declare function readsRuntime(request: {
+    readonly kind: string;
+}): boolean;
 export declare function answerRuntime(connection: Connection, request: RuntimeRequest, spool: FileSpool): unknown;
 //# sourceMappingURL=tables.d.ts.map