@agentshouse/mdruntime 0.1.0-alpha.7 → 0.1.0-alpha.9

package/dist/connection.js

@@ -1,18 +1,36 @@
-import { query as evaluate } from '@agentshouse/query';
+import { rawQuery } from './query.js';
+import { cached, modelTypes, NO_MODEL, sameModel } from './model.js';
 import { ROOM_CONTRACT_VERSION, VERSION_1_CAPABILITIES } from './adapter.js';
 import { bootstrapRoom } from './bootstrap.js';
-import { MD_MODEL, PRESENTED } from './collection.js';
+import { createConversationStore } from './conversation.js';
+import { MD_MODEL, PRESENTED, validRoot } from './collection.js';
 import { createLog } from './log.js';
-import { queuedOutcome, refused } from './outcome.js';
+import { queuedOutcome, refusalOf, refused, withheldUntilReset } from './outcome.js';
 import { refreshRoom } from './refresh.js';
 import { buildBatch } from './save.js';
-import { applyReturned, readConfirmed, replicaOf } from './replica.js';
+import { applyReturned, compositionOf, readConfirmed, replicaOf } from './replica.js';
 import { settled, same, saving, STARTING, transferring } from './status.js';
 import { detectStorageLoss, nextGeneration } from './durability.js';
-import { openReplicaStore } from './store.js';
+import { beneath } from './paths.js';
+import { openRuntimeStore } from './store.js';
 import { unconfirmed } from './transfer.js';
 const DEFAULT_DISCOVERY_INTERVAL_MS = 60_000;
 const knownCapabilities = new Set(VERSION_1_CAPABILITIES);
+function within(root, path) {
+    return root === '' || beneath(root, path);
+}
+function declaredIdentity(model) {
+    if (model === undefined) return false;
+    if (model === null) return true;
+    return typeof model.identity === 'string' && model.identity.length > 0 && typeof model.version === 'string' && model.version.length > 0;
+}
+function declaredSelection(room) {
+    const selection = room.typedSelection;
+    if (selection === undefined) return true;
+    if (!Array.isArray(selection.roots) || selection.roots.length === 0) return false;
+    if (!declaredIdentity(selection.attachedModel)) return false;
+    return selection.roots.every((root, index)=>validRoot(root) && root !== '' && !within(room.collectionRoot, root) && selection.roots.every((other, at)=>at === index || !within(other, root)));
+}
 export function createMdRuntime(options) {
     const period = options.discoveryIntervalMs ?? DEFAULT_DISCOVERY_INTERVAL_MS;
     let authorization = options.authorization;
@@ -20,17 +38,47 @@ export function createMdRuntime(options) {
     let store;
     const replicas = new Map();
     const drafts = new Map();
+    const presentations = new Map();
     const outcomes = new Map();
     let limits = [];
     let capabilities = [];
     const rooms = new Map();
     const unreadable = new Set();
+    const models = new Map();
+    const liveModels = new Map();
+    const invalidModels = new Set();
+    const modelEpoch = new Map();
+    const discovered = new Map();
+    const scopedRefusals = new Map();
+    function modelKey(locator, attached) {
+        return `${attached} ${locator}`;
+    }
+    function modelOf(locator, attached = 'collection') {
+        return models.get(modelKey(locator, attached)) ?? NO_MODEL;
+    }
+    function savedModel(locator, attached) {
+        return invalidModels.has(modelKey(locator, attached)) ? {
+            status: 'unavailable',
+            reason: 'revoked'
+        } : modelOf(locator, attached);
+    }
+    function compositionFor(record) {
+        return compositionOf({
+            ...record,
+            model: savedModel(record.locator, 'collection'),
+            selectionModel: savedModel(record.locator, 'typed-selection')
+        });
+    }
+    const mismatchedRoots = new Set();
     let refusal = null;
     let storageLoss = null;
     let status = STARTING;
     let discoveryPaused = false;
     let timer;
     let closed = false;
+    let withdrawNotifications;
+    let handed;
+    const notices = new Map();
     let chain = Promise.resolve();
     let mutations = Promise.resolve();
     let inflight = false;
@@ -42,15 +90,21 @@ export function createMdRuntime(options) {
     const querySubscriptions = new Set();
     const queueSubscriptions = new Set();
     const draftListeners = new Set();
+    const presentationListeners = new Set();
+    let withdrawConversations;
+    const conversations = createConversationStore({
+        cards: declaredCards,
+        documents: ()=>visible({}),
+        call: (name, input)=>invokeAction(name, input),
+        durably,
+        path: ()=>options.adapter.conversations,
+        closed: ()=>closed
+    });
     const journal = createLog();
     let notifyReady = ()=>{};
     const ready = new Promise((resolve)=>{
         notifyReady = resolve;
     });
-    let leader = typeof window === 'undefined';
-    let applyingRemote = false;
-    let releaseLeadership = ()=>{};
-    const channel = typeof window !== 'undefined' ? new BroadcastChannel('mdruntime') : undefined;
     function draftContent(locator, path) {
         return drafts.get(locator)?.get(path);
     }
@@ -84,9 +138,7 @@ export function createMdRuntime(options) {
         return entries;
     }
     async function readDrafts(opened) {
-        await acrossTabs('mdruntime-replica', async ()=>{
-            await hydrate(opened);
-        });
+        await hydrate(opened);
         return snapshotDrafts();
     }
     function publishDrafts(waitingOnly) {
@@ -104,16 +156,23 @@ export function createMdRuntime(options) {
     function releaseWaitingDrafts() {
         publishDrafts(true);
     }
+    function presentationOf(app) {
+        const value = presentations.get(app);
+        return value === undefined ? null : structuredClone(value);
+    }
+    function emitPresentation(app) {
+        if (closed) return;
+        for (const listener of presentationListeners){
+            if (listener.app === app && listener.ready) listener.notify(presentationOf(app));
+        }
+    }
     function commitDraft(work) {
         return exclusive(async ()=>{
             const local = await openLocal();
-            await acrossTabs('mdruntime-replica', async ()=>{
-                await hydrate(local);
-                await work(local);
-            });
+            await hydrate(local);
+            await work(local);
         }).then(()=>{
             emitDrafts();
-            announce();
         });
     }
     function pending() {
@@ -122,12 +181,33 @@ export function createMdRuntime(options) {
         ].some((replica)=>replica.queue.length > 0);
     }
     function attention() {
-        return [
-            ...replicas.values()
-        ].some((replica)=>{
+        const attentionRequired = [];
+        let reset = null;
+        for (const [locator, replica] of replicas){
             const head = replica.queue[0];
-            return head !== undefined && refused(outcomes.get(head.id));
-        });
+            if (head === undefined) continue;
+            const outcome = outcomes.get(head.id);
+            if (outcome?.kind === 'retryable-refusal') {
+                if (outcome.reset !== undefined && (reset === null || outcome.reset < reset)) {
+                    reset = outcome.reset;
+                }
+                continue;
+            }
+            if (!refused(outcome)) continue;
+            attentionRequired.push({
+                locator,
+                batch: head.id,
+                outcome: outcome.kind,
+                refusal: refusalOf(outcome),
+                ...outcome.kind === 'conflicted' && outcome.roomVersion !== undefined ? {
+                    roomVersion: outcome.roomVersion
+                } : {}
+            });
+        }
+        return {
+            attentionRequired,
+            reset
+        };
     }
     function storedOutcomes(batches) {
         const stored = {};
@@ -143,12 +223,11 @@ export function createMdRuntime(options) {
             batches,
             outcomes: storedOutcomes(batches)
         });
-        announce();
     }
     function listed() {
-        return [
+        return structuredClone([
             ...rooms.values()
-        ];
+        ]);
     }
     function queryRooms() {
         return [
@@ -156,7 +235,9 @@ export function createMdRuntime(options) {
         ].map((replica)=>({
                 room: replica.confirmed.record.locator,
                 roomVersion: replica.confirmed.record.roomVersion,
-                documents: replica.visible.collection.documents
+                documents: replica.visible.collection.documents,
+                model: modelTypes(modelOf(replica.confirmed.record.locator)),
+                typedSelection: replica.confirmed.record.typedSelection === null ? null : modelTypes(modelOf(replica.confirmed.record.locator, 'typed-selection'))
             }));
     }
     function emitRooms() {
@@ -169,31 +250,17 @@ export function createMdRuntime(options) {
     function emitStorageLoss() {
         for (const listener of storageLossListeners)listener(storageLoss);
     }
-    function announce(type = 'changed') {
-        if (applyingRemote || channel === undefined) return;
-        if (type === 'hello') {
-            channel.postMessage({
-                type: 'hello'
-            });
-            return;
-        }
-        channel.postMessage({
-            type,
-            status
-        });
-    }
-    function adopt(next) {
+    function moveTo(next) {
         if (closed || same(status, next)) return;
         status = next;
         for (const listener of statusListeners)listener(status);
     }
-    function moveTo(next) {
-        if (closed || same(status, next)) return;
-        adopt(next);
-        announce();
-    }
     function visible(request) {
-        return evaluate(queryRooms(), {
+        if (options.queryBinding === null) {
+            if (Object.keys(request).length > 0) throw new Error('query-binding-unavailable');
+            return rawQuery(queryRooms());
+        }
+        return options.queryBinding(queryRooms(), {
             ...request,
             selector: {
                 $and: [
@@ -233,30 +300,89 @@ export function createMdRuntime(options) {
             void enqueue();
         }, period);
     }
-    function refuse(reason) {
+    function refuse(reason, provider = null) {
+        if (reason === 'revoked-authorization') {
+            const revoked = {
+                status: 'unavailable',
+                reason: 'revoked'
+            };
+            const attachments = [
+                'collection',
+                'typed-selection'
+            ];
+            const keys = new Set(models.keys());
+            for (const locator of rooms.keys()){
+                for (const attached of attachments)keys.add(modelKey(locator, attached));
+            }
+            for (const key of keys){
+                invalidModels.add(key);
+                modelEpoch.set(key, (modelEpoch.get(key) ?? 0) + 1);
+                models.set(key, revoked);
+                liveModels.delete(key);
+            }
+            for (const [locator, room] of rooms)rooms.set(locator, {
+                ...room,
+                model: modelTypes(revoked),
+                typedSelection: room.typedSelection === null ? null : {
+                    ...room.typedSelection,
+                    model: modelTypes(revoked)
+                }
+            });
+            emitRooms();
+            void exclusive(async ()=>{
+                const local = await openLocal();
+                for (const record of (await local.all()))await local.publish({
+                    ...record,
+                    model: revoked,
+                    selectionModel: revoked
+                });
+            }).catch(()=>{
+                journal.record('model invalidation durable-write failure');
+            });
+        }
         stopTimer();
         discoveryPaused = true;
         refusal = {
             reason,
-            reauthorizationOffered: reason === 'revoked-authorization'
+            reauthorizationOffered: reason === 'revoked-authorization',
+            refusal: provider
         };
         journal.record(`connection refused ${reason}`);
         emitRefusal();
     }
     function list(room, synchronizationAvailable) {
+        const selection = room.typedSelection ?? null;
         rooms.set(room.locator, {
             name: room.name,
+            collectionRoot: room.collectionRoot,
             locator: room.locator,
-            writeGrants: room.writeGrants,
+            operations: room.operations,
+            replica: room.replica,
+            attachedModel: room.attachedModel,
+            model: modelTypes(modelOf(room.locator)),
+            typedSelection: selection === null ? null : {
+                roots: selection.roots,
+                attachedModel: selection.attachedModel,
+                model: modelTypes(modelOf(room.locator, 'typed-selection'))
+            },
             providerOwnedPaths: room.providerOwnedPaths,
             roomVersion: replicas.get(room.locator)?.confirmed.record.roomVersion ?? null,
-            synchronizationAvailable
+            synchronizationAvailable,
+            refusal: scopedRefusals.get(room.locator) ?? null
         });
     }
-    function applyDiscovery(discovered) {
-        const listedLocators = new Set(discovered.map((room)=>room.locator));
-        for (const room of discovered){
-            list(room, !unreadable.has(room.locator));
+    function applyDiscovery(listed) {
+        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);
+        for (const room of listed){
+            const held = replicas.get(room.locator)?.confirmed.record;
+            if (held !== undefined && held.replica.selection !== room.replica.selection) {
+                list(held, false);
+                continue;
+            }
+            list(room, room.replica.admission === 'admitted' && !unreadable.has(room.locator));
         }
         for (const [locator, room] of rooms){
             if (listedLocators.has(locator)) continue;
@@ -268,22 +394,41 @@ export function createMdRuntime(options) {
         emitRooms();
         return listedLocators;
     }
+    function restored(key, persisted) {
+        const prior = models.get(key);
+        if (prior !== undefined && prior.status !== 'unavailable' && (persisted.status === 'unavailable' || !sameModel(prior.snapshot, persisted.snapshot))) {
+            modelEpoch.set(key, (modelEpoch.get(key) ?? 0) + 1);
+            invalidModels.add(key);
+        }
+        const model = persisted.status === 'unavailable' || liveModels.get(key) === JSON.stringify(persisted.snapshot) ? persisted : cached(persisted);
+        models.set(key, model);
+        if (model.status === 'unavailable') {
+            liveModels.delete(key);
+            invalidModels.delete(key);
+        }
+        return model;
+    }
     async function hydrate(opened) {
-        const [records, queues, kept, lastCompleted, declared] = await Promise.all([
+        const [records, queues, kept, presented, cached, unsent, lastCompleted, declared] = await Promise.all([
             opened.all(),
             opened.queues(),
             opened.drafts(),
+            opened.presentation(),
+            opened.conversations(),
+            opened.instructions(),
             opened.lastCompleted(),
             opened.providerLimits()
         ]);
         limits = declared;
         drafts.clear();
         for (const draft of kept)rememberDraft(draft.locator, draft.path, draft.content);
+        presentations.clear();
+        for (const record of presented)presentations.set(record.app, record.value);
+        conversations.hydrate(cached, unsent);
         const queuedBatches = new Map(queues.map((queue)=>[
                 queue.locator,
                 queue.batches
             ]));
-        outcomes.clear();
         for (const queue of queues){
             for (const [id, outcome] of Object.entries(queue.outcomes)){
                 outcomes.set(id, outcome);
@@ -291,7 +436,13 @@ export function createMdRuntime(options) {
         }
         replicas.clear();
         for (const record of records){
-            const confirmed = readConfirmed(record);
+            const model = restored(modelKey(record.locator, 'collection'), record.model);
+            const selectionModel = restored(modelKey(record.locator, 'typed-selection'), record.selectionModel);
+            const confirmed = readConfirmed({
+                ...record,
+                model,
+                selectionModel
+            });
             if (confirmed === null) continue;
             replicas.set(record.locator, replicaOf(confirmed, queuedBatches.get(record.locator) ?? []));
             const existing = rooms.get(record.locator);
@@ -299,7 +450,16 @@ export function createMdRuntime(options) {
             else {
                 rooms.set(record.locator, {
                     ...existing,
-                    roomVersion: record.roomVersion
+                    roomVersion: record.roomVersion,
+                    operations: record.operations,
+                    replica: record.replica,
+                    attachedModel: record.attachedModel,
+                    model: modelTypes(model),
+                    typedSelection: record.typedSelection === null ? null : {
+                        roots: record.typedSelection.roots,
+                        attachedModel: record.typedSelection.attachedModel,
+                        model: modelTypes(selectionModel)
+                    }
                 });
             }
         }
@@ -321,52 +481,34 @@ export function createMdRuntime(options) {
         emitDrafts();
         return lastCompleted;
     }
-    async function applyRemote(message) {
-        if (closed) return;
-        if (message.type === 'hello') {
-            if (leader) announce();
-            return;
-        }
-        applyingRemote = true;
-        try {
-            const local = await openLocal();
-            const lastCompleted = await readState(local);
-            if (message.status !== undefined) adopt(message.status);
-            else {
-                adopt({
-                    ...status,
-                    lastCompleted,
-                    attentionRequired: attention(),
-                    state: pending() ? 'pending' : status.state
-                });
-            }
-        } finally{
-            applyingRemote = false;
-        }
-        if (message.type === 'enqueue' && leader) void enqueue();
-    }
     async function open() {
-        const opened = await openReplicaStore();
+        const opened = await openRuntimeStore();
         store = opened;
-        await acrossTabs('mdruntime-generation', async ()=>{
-            const storedGeneration = await opened.generation();
-            const loss = detectStorageLoss(storedGeneration);
-            const generation = nextGeneration(storedGeneration);
-            if (generation !== storedGeneration) await opened.rememberGeneration(generation);
-            if (loss !== null) {
-                storageLoss = loss;
-                emitStorageLoss();
-            }
-        });
+        const kept = options.shell.generation;
+        const storedGeneration = await opened.generation();
+        const loss = detectStorageLoss(storedGeneration, kept);
+        const generation = nextGeneration(storedGeneration, kept);
+        if (generation !== storedGeneration) await opened.rememberGeneration(generation);
+        if (generation !== kept) await options.shell.keepGeneration(generation);
+        if (loss !== null) {
+            storageLoss = loss;
+            emitStorageLoss();
+        }
         const lastCompleted = await readState(opened);
-        adopt({
+        moveTo({
             ...status,
             lastCompleted,
-            attentionRequired: attention()
+            ...attention()
         });
-        if (!leader) announce('hello');
         return opened;
     }
+    function durably(work) {
+        return exclusive(async ()=>{
+            const local = await openLocal();
+            await hydrate(local);
+            return work(local);
+        });
+    }
     function openLocal() {
         opening ??= open().catch((error)=>{
             opening = undefined;
@@ -379,117 +521,117 @@ export function createMdRuntime(options) {
         mutations = next.then(()=>undefined, ()=>undefined);
         return next;
     }
-    function acrossTabs(name, work) {
-        if (typeof window === 'undefined') return work();
-        return window.navigator.locks.request(name, work);
-    }
     function publish(local, room, confirmed) {
         return exclusive(async ()=>{
-            await acrossTabs('mdruntime-replica', async ()=>{
-                await hydrate(local);
-                await local.publish(confirmed.record);
-                unreadable.delete(room.locator);
-                replicas.set(room.locator, replicaOf(confirmed, replicas.get(room.locator)?.queue ?? []));
+            await hydrate(local);
+            const retained = readConfirmed({
+                ...confirmed.record,
+                model: modelOf(room.locator),
+                selectionModel: modelOf(room.locator, 'typed-selection')
             });
+            if (retained !== null) {
+                await local.publish(retained.record);
+                unreadable.delete(room.locator);
+                replicas.set(room.locator, replicaOf(retained, replicas.get(room.locator)?.queue ?? []));
+            }
             list(room, true);
             emitRooms();
             emitVisible();
-            announce();
         });
     }
     async function write(locator, changes, replacing) {
         const local = await openLocal();
-        const result = await acrossTabs('mdruntime-replica', async ()=>{
-            await hydrate(local);
-            const replica = replicas.get(locator);
-            const room = rooms.get(locator);
-            if (replica === undefined || room === undefined) {
-                throw new Error(`No Local Replica for ${locator}`);
-            }
-            const built = buildBatch({
-                baseRoomVersion: replica.confirmed.record.roomVersion,
-                writeGrants: room.writeGrants,
-                providerOwnedPaths: room.providerOwnedPaths,
-                providerLimits: limits,
-                visible: replica.visible,
-                changes
-            });
-            if (built.kind === 'refused') return {
-                outcome: 'refused',
-                ...built.refusal
-            };
-            const head = replica.queue[0];
-            if (replacing !== undefined) {
-                if (head === undefined || head.id !== replacing || !refused(outcomes.get(head.id))) {
-                    return {
-                        outcome: 'refused',
-                        rule: 'no-refused-head'
-                    };
-                }
-            }
-            const batches = replacing === undefined ? [
-                ...replica.queue,
-                built.batch
-            ] : [
-                built.batch,
-                ...replica.queue.slice(1)
-            ];
-            const consumed = [
-                ...new Set(changes.map((change)=>change.path))
-            ];
-            try {
-                await local.append({
-                    locator,
-                    batches,
-                    outcomes: storedOutcomes(batches)
-                }, consumed);
-            } catch  {
+        await hydrate(local);
+        const replica = replicas.get(locator);
+        const room = rooms.get(locator);
+        if (replica === undefined || room === undefined) {
+            throw new Error(`No Local Replica for ${locator}`);
+        }
+        if (mismatchedRoots.has(locator)) return {
+            outcome: 'refused',
+            rule: 'collection-root-mismatch'
+        };
+        const built = buildBatch({
+            baseRoomVersion: replica.confirmed.record.roomVersion,
+            composition: compositionFor(replica.confirmed.record),
+            operations: room.operations,
+            binding: options.modelBinding,
+            providerOwnedPaths: room.providerOwnedPaths,
+            providerLimits: limits,
+            visible: replica.visible,
+            changes
+        });
+        if (built.kind === 'refused') return {
+            outcome: 'refused',
+            ...built.refusal
+        };
+        const head = replica.queue[0];
+        if (replacing !== undefined) {
+            if (head === undefined || head.id !== replacing || !refused(outcomes.get(head.id))) {
                 return {
                     outcome: 'refused',
-                    rule: 'durable-write'
+                    rule: 'no-refused-head'
                 };
             }
-            if (replacing !== undefined) outcomes.delete(replacing);
-            for (const path of consumed)forgetDraft(locator, path);
-            replicas.set(locator, replicaOf(replica.confirmed, batches));
-            emitQueue(locator);
-            emitVisible();
-            emitDrafts();
-            moveTo({
-                ...saving(status),
-                attentionRequired: attention()
-            });
+        }
+        const batches = replacing === undefined ? [
+            ...replica.queue,
+            built.batch
+        ] : [
+            built.batch,
+            ...replica.queue.slice(1)
+        ];
+        const consumed = [
+            ...new Set(changes.map((change)=>change.path))
+        ];
+        try {
+            await local.append({
+                locator,
+                batches,
+                outcomes: storedOutcomes(batches)
+            }, consumed);
+        } catch  {
             return {
-                outcome: 'saved',
-                id: built.batch.id
+                outcome: 'refused',
+                rule: 'durable-write'
             };
+        }
+        if (replacing !== undefined) outcomes.delete(replacing);
+        for (const path of consumed)forgetDraft(locator, path);
+        replicas.set(locator, replicaOf(replica.confirmed, batches));
+        emitQueue(locator);
+        emitVisible();
+        emitDrafts();
+        moveTo({
+            ...saving(status),
+            ...attention()
         });
-        if (result.outcome === 'saved') void enqueue();
-        return result;
+        void enqueue();
+        return {
+            outcome: 'saved',
+            id: built.batch.id
+        };
     }
     async function discardHead(locator, identifier) {
         const local = await openLocal();
-        const changed = await acrossTabs('mdruntime-replica', async ()=>{
-            await hydrate(local);
-            const replica = replicas.get(locator);
-            const head = replica?.queue[0];
-            if (replica === undefined || head === undefined || head.id !== identifier || !refused(outcomes.get(head.id))) {
-                return false;
-            }
-            const batches = replica.queue.slice(1);
-            outcomes.delete(identifier);
-            await persistQueue(local, locator, batches);
-            replicas.set(locator, replicaOf(replica.confirmed, batches));
-            emitQueue(locator);
-            emitVisible();
-            moveTo({
-                ...status,
-                state: pending() ? 'pending' : status.state,
-                attentionRequired: attention()
-            });
-            return true;
+        await hydrate(local);
+        const replica = replicas.get(locator);
+        const head = replica?.queue[0];
+        if (replica === undefined || head === undefined || head.id !== identifier || !refused(outcomes.get(head.id))) {
+            return;
+        }
+        const batches = replica.queue.slice(1);
+        outcomes.delete(identifier);
+        await persistQueue(local, locator, batches);
+        replicas.set(locator, replicaOf(replica.confirmed, batches));
+        emitQueue(locator);
+        emitVisible();
+        moveTo({
+            ...status,
+            state: pending() ? 'pending' : status.state,
+            ...attention()
         });
-        if (changed) void enqueue();
+        void enqueue();
     }
     async function readHistory(locator, path, query = {}) {
         if (closed || refusal !== null) return {
@@ -528,6 +670,10 @@ export function createMdRuntime(options) {
                 }
             });
             journal.record(`outcome history ${result.kind}`);
+            if (result.kind === 'scoped-refusal') {
+                const room = replicas.get(result.locator)?.confirmed.record;
+                if (room !== undefined) await scoped(result, room, await openLocal());
+            }
             if (result.kind === 'revoked-authorization') refuse('revoked-authorization');
             return result;
         } catch  {
@@ -537,6 +683,12 @@ export function createMdRuntime(options) {
             };
         }
     }
+    function declaredCards() {
+        for (const capability of capabilities){
+            if (capability.conversationCards !== undefined) return capability.conversationCards;
+        }
+        return undefined;
+    }
     function declaredAction(name) {
         for (const capability of capabilities){
             for (const action of capability.actions ?? []){
@@ -571,9 +723,13 @@ export function createMdRuntime(options) {
                 name,
                 input
             });
+            if (result.kind === 'scoped-refusal') {
+                const room = replicas.get(result.locator)?.confirmed.record;
+                if (room !== undefined) await scoped(result, room, await openLocal());
+            }
             if (result.kind === 'revoked-authorization') refuse('revoked-authorization');
             journal.record(`outcome action ${result.kind}`);
-            if (result.kind === 'rejected') journal.record(`refusal rejected ${result.text}`);
+            if (result.kind === 'rejected') journal.record(`refusal rejected ${result.code}`);
             return result;
         } catch  {
             journal.record('outcome action transport-uncertainty');
@@ -584,7 +740,7 @@ export function createMdRuntime(options) {
     }
     async function pullRefresh(authorized, confirmed) {
         try {
-            const result = await refreshRoom(options.adapter, authorized, confirmed);
+            const result = await refreshRoom(options.adapter, authorized, confirmed, options.modelBinding);
             const detail = result.kind === 'advanced' ? result.confirmed.record.roomVersion : result.kind;
             journal.record(`transfer refresh ${confirmed.record.locator} ${detail}`);
             return result;
@@ -595,7 +751,10 @@ export function createMdRuntime(options) {
     }
     async function pullBootstrap(authorized, room) {
         try {
-            const result = await bootstrapRoom(options.adapter, authorized, room);
+            const result = await bootstrapRoom(options.adapter, authorized, room, {
+                collection: modelOf(room.locator),
+                selection: modelOf(room.locator, 'typed-selection')
+            }, options.modelBinding);
             const detail = result.kind === 'staged' ? result.confirmed.record.roomVersion : result.kind;
             journal.record(`transfer bootstrap ${room.locator} ${detail}`);
             return result;
@@ -632,54 +791,94 @@ export function createMdRuntime(options) {
         if (result.kind === 'expired') return {
             kind: 'expired'
         };
+        if (result.kind === 'retryable-refusal') {
+            return {
+                kind: 'retryable-refusal',
+                code: result.code,
+                fields: result.fields,
+                ...result.reset === undefined ? {} : {
+                    reset: result.reset
+                }
+            };
+        }
         if (result.kind === 'conflicted') {
             return {
                 kind: 'conflicted',
-                roomVersion: result.roomVersion,
+                ...result.roomVersion === undefined ? {} : {
+                    roomVersion: result.roomVersion
+                },
                 affected: result.affected,
-                text: result.text
+                code: result.code,
+                fields: result.fields
             };
         }
         return {
             kind: 'rejected',
             affected: result.affected,
-            text: result.text
+            code: result.code,
+            fields: result.fields
         };
     }
     async function commitAccept(room, local, submitted, accepted, base, overlay) {
-        return acrossTabs('mdruntime-replica', async ()=>{
-            await hydrate(local);
-            const current = replicas.get(room.locator);
-            if (current === undefined || !current.queue.some((batch)=>batch.id === submitted.id)) {
-                return true;
-            }
-            const remaining = current.queue.filter((batch)=>batch.id !== submitted.id);
-            const applied = overlay ? applyReturned(base, accepted.documents, accepted.revisions, accepted.removals, accepted.roomVersion) : base;
-            if (applied === null) return false;
-            await local.publish(applied.record);
-            await persistQueue(local, room.locator, remaining);
-            outcomes.set(submitted.id, {
-                kind: 'accepted',
-                roomVersion: accepted.roomVersion,
-                author: accepted.author,
-                time: accepted.time
-            });
-            unreadable.delete(room.locator);
-            replicas.set(room.locator, replicaOf(applied, remaining));
-            list(room, true);
-            emitRooms();
-            emitQueue(room.locator);
-            emitVisible();
-            journal.record(`outcome ${room.locator} ${submitted.id} accepted`);
+        await hydrate(local);
+        const current = replicas.get(room.locator);
+        if (current === undefined || !current.queue.some((batch)=>batch.id === submitted.id)) {
             return true;
+        }
+        const remaining = current.queue.filter((batch)=>batch.id !== submitted.id);
+        const retainedBase = readConfirmed({
+            ...base.record,
+            model: modelOf(room.locator),
+            selectionModel: modelOf(room.locator, 'typed-selection')
+        });
+        if (retainedBase === null) return false;
+        const applied = overlay ? applyReturned(retainedBase, accepted.documents, accepted.revisions, accepted.removals, accepted.roomVersion, options.modelBinding) : retainedBase;
+        if (applied === null) return false;
+        await local.publish(applied.record);
+        await persistQueue(local, room.locator, remaining);
+        outcomes.set(submitted.id, {
+            kind: 'accepted',
+            roomVersion: accepted.roomVersion,
+            ...accepted.author === undefined ? {} : {
+                author: accepted.author
+            },
+            ...accepted.time === undefined ? {} : {
+                time: accepted.time
+            }
         });
+        unreadable.delete(room.locator);
+        replicas.set(room.locator, replicaOf(applied, remaining));
+        list(room, true);
+        emitRooms();
+        emitQueue(room.locator);
+        emitVisible();
+        journal.record(`outcome ${room.locator} ${submitted.id} accepted ${accepted.roomVersion}` + (accepted.author === undefined ? '' : ` author ${accepted.author}`) + (accepted.time === undefined ? '' : ` time ${accepted.time}`));
+        return true;
     }
     async function submitRoom(room, local, authorized, progress) {
         while(!closed && authorization !== undefined){
             const replica = replicas.get(room.locator);
             const head = replica?.queue[0];
-            if (replica === undefined || head === undefined || refused(outcomes.get(head.id))) {
-                return null;
+            if (replica === undefined || head === undefined) return null;
+            const held = outcomes.get(head.id);
+            if (refused(held)) return null;
+            if (held?.kind === 'retryable-refusal') {
+                if (withheldUntilReset(held, Date.now())) {
+                    progress.complete = false;
+                    return null;
+                }
+                await exclusive(async ()=>{
+                    await hydrate(local);
+                    const current = replicas.get(room.locator);
+                    if (current === undefined || current.queue[0]?.id !== head.id) return;
+                    outcomes.delete(head.id);
+                    await persistQueue(local, room.locator, current.queue);
+                    emitQueue(room.locator);
+                    moveTo({
+                        ...status,
+                        ...attention()
+                    });
+                });
             }
             let result;
             journal.record(`submission ${room.locator} ${head.id}`);
@@ -710,23 +909,27 @@ export function createMdRuntime(options) {
                 refuse('revoked-authorization');
                 return 'stop';
             }
-            if (result.kind === 'conflicted' || result.kind === 'rejected' || result.kind === 'expired') {
-                journal.record(`outcome ${room.locator} ${head.id} ${result.kind}`);
-                if (result.kind !== 'expired') journal.record(`refusal ${result.kind} ${result.text}`);
+            if (result.kind === 'scoped-refusal') {
+                await scoped(result, room, local);
+                progress.complete = false;
+                return null;
+            }
+            if (result.kind === 'conflicted' || result.kind === 'rejected' || result.kind === 'expired' || result.kind === 'retryable-refusal') {
+                journal.record(`outcome ${room.locator} ${head.id} ${result.kind}` + (result.kind === 'conflicted' && result.roomVersion !== undefined ? ` ${result.roomVersion}` : ''));
+                if (result.kind !== 'expired') journal.record(`refusal ${result.kind} ${result.code}`);
+                if (result.kind === 'retryable-refusal') progress.complete = false;
                 await exclusive(async ()=>{
-                    await acrossTabs('mdruntime-replica', async ()=>{
-                        await hydrate(local);
-                        const current = replicas.get(room.locator);
-                        if (current === undefined || !current.queue.some((batch)=>batch.id === head.id)) {
-                            return;
-                        }
-                        outcomes.set(head.id, recordRefusal(result));
-                        await persistQueue(local, room.locator, current.queue);
-                        emitQueue(room.locator);
-                        moveTo({
-                            ...status,
-                            attentionRequired: true
-                        });
+                    await hydrate(local);
+                    const current = replicas.get(room.locator);
+                    if (current === undefined || !current.queue.some((batch)=>batch.id === head.id)) {
+                        return;
+                    }
+                    outcomes.set(head.id, recordRefusal(result));
+                    await persistQueue(local, room.locator, current.queue);
+                    emitQueue(room.locator);
+                    moveTo({
+                        ...status,
+                        ...attention()
                     });
                 });
                 return null;
@@ -738,6 +941,11 @@ export function createMdRuntime(options) {
                 refuse('revoked-authorization');
                 return 'stop';
             }
+            if (pulled.kind === 'scoped-refusal') {
+                await scoped(pulled, room, local);
+                progress.complete = false;
+                return null;
+            }
             if (pulled.kind === 'still-current') {
                 const committed = await exclusive(()=>commitAccept(room, local, head, result, from, true));
                 if (!committed) {
@@ -761,6 +969,11 @@ export function createMdRuntime(options) {
                     refuse('revoked-authorization');
                     return 'stop';
                 }
+                if (bootstrapped.kind === 'scoped-refusal') {
+                    await scoped(bootstrapped, room, local);
+                    progress.complete = false;
+                    return null;
+                }
                 if (bootstrapped.kind === 'staged') {
                     const overlay = bootstrapped.confirmed.record.roomVersion === result.roomVersion;
                     const committed = await exclusive(()=>commitAccept(room, local, head, result, bootstrapped.confirmed, overlay));
@@ -792,15 +1005,195 @@ export function createMdRuntime(options) {
         }
         return null;
     }
+    async function retainModel(local, room, attached, next) {
+        const key = modelKey(room.locator, attached);
+        if (next.status === 'unavailable') modelEpoch.set(key, (modelEpoch.get(key) ?? 0) + 1);
+        const epoch = modelEpoch.get(key) ?? 0;
+        const previous = modelOf(room.locator, attached);
+        const heldBefore = replicas.get(room.locator)?.confirmed.record;
+        if (JSON.stringify(previous) === JSON.stringify(next) && (heldBefore === undefined || JSON.stringify(heldBefore.operations) === JSON.stringify(room.operations) && JSON.stringify(heldBefore.replica) === JSON.stringify(room.replica) && JSON.stringify(heldBefore.attachedModel) === JSON.stringify(room.attachedModel) && JSON.stringify(heldBefore.typedSelection) === JSON.stringify(room.typedSelection ?? null))) return;
+        const queryChanged = previous.status === 'unavailable' || next.status === 'unavailable' ? previous.status !== next.status : JSON.stringify(previous.types) !== JSON.stringify(next.types);
+        if (next.status === 'unavailable') {
+            invalidModels.add(key);
+            liveModels.delete(key);
+        }
+        await exclusive(async ()=>{
+            await hydrate(local);
+            if (next.status !== 'unavailable' && epoch !== (modelEpoch.get(key) ?? 0)) return;
+            const held = replicas.get(room.locator);
+            if (held !== undefined) {
+                const record = {
+                    ...held.confirmed.record,
+                    operations: room.operations,
+                    replica: room.replica,
+                    attachedModel: room.attachedModel,
+                    typedSelection: room.typedSelection ?? null,
+                    ...attached === 'collection' ? {
+                        model: next
+                    } : {
+                        selectionModel: next
+                    }
+                };
+                await local.publish(record);
+                const confirmed = readConfirmed(record);
+                if (confirmed !== null) replicas.set(room.locator, replicaOf(confirmed, held.queue));
+            }
+            models.set(key, next);
+            if (next.status === 'current') {
+                liveModels.set(key, JSON.stringify(next.snapshot));
+                invalidModels.delete(key);
+            }
+            list(room, room.replica.admission === 'admitted' && !unreadable.has(room.locator));
+            emitRooms();
+            if (queryChanged && held !== undefined) emitVisible();
+        });
+    }
+    async function acquireModel(local, room, authorized, selection) {
+        const attached = selection === null ? 'collection' : 'typed-selection';
+        const key = modelKey(room.locator, attached);
+        const declared = selection === null ? room.attachedModel : selection.attachedModel;
+        let previous = modelOf(room.locator, attached);
+        if (previous.status !== 'unavailable' && (declared === null || !sameModel(previous.snapshot, declared))) {
+            previous = {
+                status: 'unavailable',
+                reason: 'version-changed'
+            };
+            await retainModel(local, room, attached, previous);
+        }
+        const epoch = modelEpoch.get(key) ?? 0;
+        let answer;
+        try {
+            answer = await options.adapter.model(authorized, selection === null ? {
+                locator: room.locator,
+                attached: 'collection',
+                collectionRoot: room.collectionRoot,
+                model: declared
+            } : {
+                locator: room.locator,
+                attached: 'typed-selection',
+                roots: selection.roots,
+                model: declared
+            });
+        } catch  {
+            answer = {
+                kind: 'transport-uncertainty'
+            };
+        }
+        if (epoch !== (modelEpoch.get(key) ?? 0)) return;
+        if (answer.kind === 'revoked-authorization') {
+            await retainModel(local, room, attached, {
+                status: 'unavailable',
+                reason: 'revoked'
+            });
+            refuse('revoked-authorization');
+            return;
+        }
+        if (answer.kind === 'transport-uncertainty') {
+            await retainModel(local, room, attached, cached(previous));
+            return;
+        }
+        if (answer.kind === 'model-unavailable') {
+            await retainModel(local, room, attached, {
+                status: 'unavailable',
+                reason: answer.reason
+            });
+            return;
+        }
+        if (declared === null || !sameModel(answer.snapshot, declared)) {
+            await retainModel(local, room, attached, {
+                status: 'unavailable',
+                reason: 'version-changed'
+            });
+            return;
+        }
+        if (previous.status !== 'unavailable' && sameModel(previous.snapshot, answer.snapshot) && JSON.stringify(Object.entries(previous.snapshot.definitions).sort()) !== JSON.stringify(Object.entries(answer.snapshot.definitions).sort())) {
+            await retainModel(local, room, attached, {
+                status: 'unavailable',
+                reason: 'invalid'
+            });
+            return;
+        }
+        const verified = options.modelBinding?.verify(answer.snapshot);
+        await retainModel(local, room, attached, verified?.kind === 'verified' ? {
+            status: 'current',
+            snapshot: structuredClone(answer.snapshot),
+            verifiedWith: MD_MODEL,
+            types: verified.types
+        } : {
+            status: 'unavailable',
+            reason: verified === undefined ? 'binding-unavailable' : 'invalid'
+        });
+    }
+    async function scoped(result, room, local) {
+        scopedRefusals.set(room.locator, {
+            code: result.code,
+            fields: result.fields
+        });
+        let scopedAway = room;
+        if (result.scope === 'model') await retainModel(local, room, 'collection', {
+            status: 'unavailable',
+            reason: 'not-readable'
+        });
+        else if (result.scope !== 'operation') {
+            unreadable.add(room.locator);
+            scopedAway = {
+                ...room,
+                replica: {
+                    ...room.replica,
+                    admission: 'unavailable'
+                },
+                operations: {
+                    ...room.operations,
+                    ...result.scope === 'content' ? {
+                        read: []
+                    } : {},
+                    ...result.scope === 'sync' ? {
+                        sync: []
+                    } : {}
+                }
+            };
+            await retainModel(local, scopedAway, 'collection', modelOf(room.locator));
+        }
+        list(scopedAway, scopedAway.replica.admission === 'admitted' && !unreadable.has(room.locator));
+        emitRooms();
+        journal.record(`scoped refusal ${room.locator} ${result.scope} ${result.code}`);
+    }
     async function synchronize(discovered, local, progress) {
         for (const room of discovered){
             if (closed || authorization === undefined) {
                 progress.complete = false;
                 return;
             }
+            const prior = replicas.get(room.locator)?.confirmed.record;
+            if (prior !== undefined && prior.replica.selection !== room.replica.selection) {
+                list(prior, false);
+                emitRooms();
+                journal.record(`selection changed ${room.locator}`);
+                progress.complete = false;
+                continue;
+            }
+            await acquireModel(local, room, authorization, null);
+            if (discoveryPaused) return;
+            if (room.typedSelection !== undefined) {
+                await acquireModel(local, room, authorization, room.typedSelection);
+                if (discoveryPaused) return;
+            }
+            if (room.replica.admission !== 'admitted') {
+                progress.complete = false;
+                continue;
+            }
+            const held = replicas.get(room.locator);
+            if (held !== undefined && held.confirmed.record.replica.selection !== room.replica.selection) {
+                progress.complete = false;
+                continue;
+            }
             const withheld = await advance(room, local, authorization);
             if (withheld !== null) {
                 progress.complete = false;
+                if (withheld.kind === 'scoped-refusal') {
+                    await scoped(withheld, room, local);
+                    continue;
+                }
                 if (withheld.kind === 'transport-uncertainty') {
                     progress.reachable = false;
                     continue;
@@ -829,10 +1222,10 @@ export function createMdRuntime(options) {
         let result;
         try {
             result = await options.adapter.discover(authorization);
-        } catch (error) {
-            journal.record('connection discover transport-uncertainty');
-            notifyReady();
-            throw error;
+        } catch  {
+            result = {
+                kind: 'transport-uncertainty'
+            };
         }
         if (closed) {
             notifyReady();
@@ -840,10 +1233,25 @@ export function createMdRuntime(options) {
         }
         journal.record(`connection discover ${result.kind}`);
         if (result.kind === 'transport-uncertainty') {
+            for (const room of rooms.values()){
+                await retainModel(local, room, 'collection', cached(modelOf(room.locator)));
+                if (room.typedSelection !== null) {
+                    await retainModel(local, room, 'typed-selection', cached(modelOf(room.locator, 'typed-selection')));
+                }
+            }
             progress.reachable = false;
             notifyReady();
             return;
         }
+        if (result.kind === 'contract-unavailable') {
+            journal.record(`connection contract unavailable ${result.code}`);
+            refuse('missing-required-guarantee', {
+                code: result.code,
+                fields: result.fields
+            });
+            notifyReady();
+            return;
+        }
         if (result.kind === 'revoked-authorization') {
             refuse('revoked-authorization');
             notifyReady();
@@ -859,6 +1267,40 @@ export function createMdRuntime(options) {
             notifyReady();
             return;
         }
+        mismatchedRoots.clear();
+        for (const room of result.rooms){
+            const held = replicas.get(room.locator)?.confirmed.record;
+            const malformed = !validRoot(room.collectionRoot);
+            if (room.operations === undefined || ![
+                'read',
+                'sync',
+                'write',
+                'delete'
+            ].every((operation)=>Array.isArray(room.operations[operation]) && room.operations[operation].every((scope)=>typeof scope === 'string')) || room.replica === undefined || typeof room.replica.selection !== 'string' || room.replica.selection.length === 0 || ![
+                'admitted',
+                'unavailable'
+            ].includes(room.replica.admission) || !declaredIdentity(room.attachedModel)) {
+                journal.record(`invalid model or replica declaration ${room.locator}`);
+                refuse('missing-required-guarantee');
+                notifyReady();
+                return;
+            }
+            if (!declaredSelection(room)) {
+                journal.record(`invalid typed selection declaration ${room.locator}`);
+                refuse('missing-required-guarantee');
+                notifyReady();
+                return;
+            }
+            if (malformed || held !== undefined && held.collectionRoot !== room.collectionRoot) {
+                mismatchedRoots.add(room.locator);
+                journal.record(`collection root ${malformed ? 'invalid' : 'changed'} ${room.locator}`);
+            }
+        }
+        if (mismatchedRoots.size > 0) {
+            refuse('missing-required-guarantee');
+            notifyReady();
+            return;
+        }
         const declared = new Set(result.capabilities.map((capability)=>capability.name));
         for (const required of options.requiredGuarantees){
             if (!knownCapabilities.has(required) || !declared.has(required)) {
@@ -873,11 +1315,14 @@ export function createMdRuntime(options) {
         }
         capabilities = result.capabilities;
         notifyReady();
+        if (declared.has('room-version-notifications')) observeRoomVersions();
+        if (declared.has('provider-actions')) observeConversations();
         if (JSON.stringify(result.providerLimits) !== JSON.stringify(limits)) {
             limits = result.providerLimits;
             await local.declare(limits);
         }
         const listedLocators = applyDiscovery(result.rooms);
+        handSelected(result.rooms.filter((room)=>room.replica.admission === 'admitted').map((room)=>room.locator).sort());
         progress.complete = [
             ...replicas.keys()
         ].every((locator)=>listedLocators.has(locator));
@@ -935,11 +1380,80 @@ export function createMdRuntime(options) {
             }
         }
     }
-    function enqueue() {
-        if (!leader) {
-            announce('enqueue');
-            return chain;
+    function observeRoomVersions() {
+        const path = options.adapter.roomVersions;
+        if (path === undefined || withdrawNotifications !== undefined) return;
+        withdrawNotifications = path.observe((notification)=>{
+            if (closed || discoveryPaused) return;
+            notices.set(notification.locator, notification.roomVersion);
+            chain = chain.then(runNotified, runNotified);
+        });
+    }
+    function observeConversations() {
+        const path = options.adapter.conversations;
+        if (path === undefined || withdrawConversations !== undefined) return;
+        withdrawConversations = path.observe((event)=>{
+            conversations.receive(event);
+        });
+    }
+    function handSelected(locators) {
+        const path = options.adapter.roomVersions;
+        if (path === undefined || withdrawNotifications === undefined) return;
+        if (handed !== undefined && JSON.stringify(locators) === JSON.stringify(handed)) return;
+        handed = locators;
+        path.select(locators);
+    }
+    async function runNotified() {
+        const announced = [
+            ...notices
+        ];
+        notices.clear();
+        if (announced.length === 0 || closed || discoveryPaused) return;
+        const resting = status;
+        const progress = {
+            complete: false,
+            reachable: !resting.providerUnreachable
+        };
+        moveTo(transferring(resting));
+        try {
+            const local = await openLocal();
+            for (const [locator, roomVersion] of announced){
+                if (closed || discoveryPaused || authorization === undefined) return;
+                if (handed?.includes(locator) !== true) continue;
+                const room = discovered.get(locator);
+                const held = replicas.get(locator);
+                if (room === undefined || held === undefined) continue;
+                if (held.confirmed.record.roomVersion === roomVersion) continue;
+                const withheld = await advance(room, local, authorization);
+                if (withheld === null) continue;
+                if (withheld.kind === 'scoped-refusal') {
+                    await scoped(withheld, room, local);
+                    continue;
+                }
+                if (withheld.kind === 'transport-uncertainty') {
+                    progress.reachable = false;
+                    continue;
+                }
+                if (withheld.kind === 'room-not-readable') {
+                    unreadable.add(locator);
+                    list(room, false);
+                    emitRooms();
+                    continue;
+                }
+                if (withheld.kind === 'revoked-authorization') {
+                    refuse('revoked-authorization');
+                    return;
+                }
+            }
+        } catch  {
+            progress.reachable = false;
+        } finally{
+            if (!closed) {
+                moveTo(settled(resting, progress, resting.lastCompleted, pending(), attention()));
+            }
         }
+    }
+    function enqueue() {
         if (inflight) {
             queued = true;
             return chain;
@@ -948,32 +1462,18 @@ export function createMdRuntime(options) {
         chain = chain.then(run, run);
         return chain;
     }
-    function startProcessing() {
-        if (leader) {
-            void enqueue();
-            return;
-        }
-        void window.navigator.locks.request('mdruntime-sync', {
-            signal: options.signal
-        }, async ()=>{
-            if (closed) return;
-            leader = true;
-            announce();
-            void enqueue();
-            await new Promise((resolve)=>{
-                releaseLeadership = ()=>{
-                    leader = false;
-                    resolve();
-                };
-            });
-        }).catch(()=>{});
-    }
     function close() {
         closed = true;
+        withdrawNotifications?.();
+        withdrawNotifications = undefined;
+        withdrawConversations?.();
+        withdrawConversations = undefined;
+        conversations.close();
         stopTimer();
-        releaseLeadership();
-        channel?.close();
         store?.close();
+        void opening?.then((opened)=>{
+            opened.close();
+        }, ()=>{});
         roomListeners.clear();
         refusalListeners.clear();
         storageLossListeners.clear();
@@ -981,22 +1481,16 @@ export function createMdRuntime(options) {
         querySubscriptions.clear();
         queueSubscriptions.clear();
         draftListeners.clear();
+        presentationListeners.clear();
     }
-    channel?.addEventListener('message', (event)=>{
-        const data = event.data;
-        if (data === null || typeof data !== 'object') return;
-        void exclusive(()=>applyRemote(data));
-    });
     options.signal?.addEventListener('abort', close, {
         once: true
     });
     if (options.signal?.aborted) close();
-    void openLocal().then(()=>{
-        if (!leader) notifyReady();
-    }, ()=>{
+    void openLocal().catch(()=>{
         notifyReady();
     });
-    startProcessing();
+    void enqueue();
     return {
         rooms () {
             return listed();
@@ -1005,7 +1499,10 @@ export function createMdRuntime(options) {
             return visible(request);
         },
         types (locator) {
-            return replicas.get(locator)?.visible.collection.types ?? [];
+            return {
+                collection: modelTypes(modelOf(locator)),
+                typedSelection: rooms.get(locator)?.typedSelection === undefined || rooms.get(locator)?.typedSelection === null ? null : modelTypes(modelOf(locator, 'typed-selection'))
+            };
         },
         syncStatus () {
             return status;
@@ -1042,6 +1539,29 @@ export function createMdRuntime(options) {
                 });
             }
         },
+        conversation: conversations.surface,
+        presentation: {
+            read (app) {
+                return exclusive(async ()=>{
+                    await hydrate(await openLocal());
+                    return presentationOf(app);
+                });
+            },
+            write (app, value) {
+                return exclusive(async ()=>{
+                    const local = await openLocal();
+                    await hydrate(local);
+                    const stored = structuredClone(value);
+                    await local.present({
+                        app,
+                        value: stored
+                    });
+                    presentations.set(app, stored);
+                }).then(()=>{
+                    emitPresentation(app);
+                });
+            }
+        },
         save (locator, changes, replacing) {
             return exclusive(()=>write(locator, changes, replacing));
         },
@@ -1072,6 +1592,9 @@ export function createMdRuntime(options) {
         storageLoss () {
             return storageLoss;
         },
+        persistence () {
+            return options.shell.persistentStorage;
+        },
         observe (topic, second, third) {
             if (topic === 'drafts') {
                 const notify = second;
@@ -1093,6 +1616,27 @@ export function createMdRuntime(options) {
                     draftListeners.delete(listener);
                 };
             }
+            if (topic === 'conversation') {
+                return conversations.observe(second, third);
+            }
+            if (topic === 'presentation') {
+                const listener = {
+                    app: second,
+                    notify: third,
+                    ready: false
+                };
+                presentationListeners.add(listener);
+                void exclusive(async ()=>{
+                    await hydrate(await openLocal());
+                }).then(()=>{
+                    if (closed || !presentationListeners.has(listener)) return;
+                    listener.ready = true;
+                    listener.notify(presentationOf(listener.app));
+                }, ()=>{});
+                return ()=>{
+                    presentationListeners.delete(listener);
+                };
+            }
             if (topic === 'rooms') {
                 const notify = second;
                 roomListeners.add(notify);