@agentshouse/mdruntime 0.1.0-alpha.6 → 0.1.0-alpha.8

package/dist/connection.js

@@ -1,7 +1,8 @@
-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 { MD_MODEL, PRESENTED, validRoot } from './collection.js';
 import { createLog } from './log.js';
 import { queuedOutcome, refused } from './outcome.js';
 import { refreshRoom } from './refresh.js';
@@ -25,6 +26,14 @@ export function createMdRuntime(options) {
     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();
+    function modelOf(locator) {
+        return models.get(locator) ?? NO_MODEL;
+    }
+    const mismatchedRoots = new Set();
     let refusal = null;
     let storageLoss = null;
     let status = STARTING;
@@ -41,6 +50,7 @@ export function createMdRuntime(options) {
     const statusListeners = new Set();
     const querySubscriptions = new Set();
     const queueSubscriptions = new Set();
+    const draftListeners = new Set();
     const journal = createLog();
     let notifyReady = ()=>{};
     const ready = new Promise((resolve)=>{
@@ -50,8 +60,70 @@ export function createMdRuntime(options) {
     let applyingRemote = false;
     let releaseLeadership = ()=>{};
     const channel = typeof window !== 'undefined' ? new BroadcastChannel('mdruntime') : undefined;
-    function at(locator, path) {
-        return `${locator} ${path}`;
+    function draftContent(locator, path) {
+        return drafts.get(locator)?.get(path);
+    }
+    function rememberDraft(locator, path, content) {
+        const room = drafts.get(locator) ?? new Map();
+        room.set(path, content);
+        drafts.set(locator, room);
+    }
+    function forgetDraft(locator, path) {
+        const room = drafts.get(locator);
+        if (room === undefined) return;
+        room.delete(path);
+        if (room.size === 0) drafts.delete(locator);
+    }
+    function snapshotDrafts() {
+        const entries = [];
+        for (const [locator, room] of drafts){
+            for (const [path, content] of room){
+                entries.push({
+                    locator,
+                    path,
+                    content: structuredClone(content)
+                });
+            }
+        }
+        entries.sort((left, right)=>{
+            if (left.locator !== right.locator) return left.locator < right.locator ? -1 : 1;
+            if (left.path !== right.path) return left.path < right.path ? -1 : 1;
+            return 0;
+        });
+        return entries;
+    }
+    async function readDrafts(opened) {
+        await acrossTabs('mdruntime-replica', async ()=>{
+            await hydrate(opened);
+        });
+        return snapshotDrafts();
+    }
+    function publishDrafts(waitingOnly) {
+        if (closed) return;
+        const value = snapshotDrafts();
+        for (const listener of draftListeners){
+            if (waitingOnly && listener.ready) continue;
+            listener.ready = true;
+            listener.notify(value);
+        }
+    }
+    function emitDrafts() {
+        publishDrafts(false);
+    }
+    function releaseWaitingDrafts() {
+        publishDrafts(true);
+    }
+    function commitDraft(work) {
+        return exclusive(async ()=>{
+            const local = await openLocal();
+            await acrossTabs('mdruntime-replica', async ()=>{
+                await hydrate(local);
+                await work(local);
+            });
+        }).then(()=>{
+            emitDrafts();
+            announce();
+        });
     }
     function pending() {
         return [
@@ -83,9 +155,9 @@ export function createMdRuntime(options) {
         announce();
     }
     function listed() {
-        return [
+        return structuredClone([
             ...rooms.values()
-        ];
+        ]);
     }
     function queryRooms() {
         return [
@@ -93,7 +165,8 @@ 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))
             }));
     }
     function emitRooms() {
@@ -130,7 +203,11 @@ export function createMdRuntime(options) {
         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: [
@@ -171,6 +248,38 @@ export function createMdRuntime(options) {
         }, period);
     }
     function refuse(reason) {
+        if (reason === 'revoked-authorization') {
+            const revoked = {
+                status: 'unavailable',
+                reason: 'revoked'
+            };
+            for (const locator of new Set([
+                ...models.keys(),
+                ...rooms.keys()
+            ])){
+                invalidModels.add(locator);
+                modelEpoch.set(locator, (modelEpoch.get(locator) ?? 0) + 1);
+                models.set(locator, revoked);
+                liveModels.delete(locator);
+            }
+            for (const [locator, room] of rooms)rooms.set(locator, {
+                ...room,
+                model: modelTypes(revoked)
+            });
+            emitRooms();
+            void exclusive(async ()=>{
+                const local = await openLocal();
+                await acrossTabs('mdruntime-replica', async ()=>{
+                    for (const record of (await local.all()))await local.publish({
+                        ...record,
+                        model: revoked
+                    });
+                });
+                announce();
+            }).catch(()=>{
+                journal.record('model invalidation durable-write failure');
+            });
+        }
         stopTimer();
         discoveryPaused = true;
         refusal = {
@@ -183,8 +292,12 @@ export function createMdRuntime(options) {
     function list(room, synchronizationAvailable) {
         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)),
             providerOwnedPaths: room.providerOwnedPaths,
             roomVersion: replicas.get(room.locator)?.confirmed.record.roomVersion ?? null,
             synchronizationAvailable
@@ -193,7 +306,12 @@ export function createMdRuntime(options) {
     function applyDiscovery(discovered) {
         const listedLocators = new Set(discovered.map((room)=>room.locator));
         for (const room of discovered){
-            list(room, !unreadable.has(room.locator));
+            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;
@@ -215,7 +333,7 @@ export function createMdRuntime(options) {
         ]);
         limits = declared;
         drafts.clear();
-        for (const draft of kept)drafts.set(at(draft.locator, draft.path), draft.content);
+        for (const draft of kept)rememberDraft(draft.locator, draft.path, draft.content);
         const queuedBatches = new Map(queues.map((queue)=>[
                 queue.locator,
                 queue.batches
@@ -228,7 +346,22 @@ export function createMdRuntime(options) {
         }
         replicas.clear();
         for (const record of records){
-            const confirmed = readConfirmed(record);
+            const persisted = record.model;
+            const priorModel = models.get(record.locator);
+            if (priorModel !== undefined && priorModel.status !== 'unavailable' && (persisted.status === 'unavailable' || !sameModel(priorModel.snapshot, persisted.snapshot))) {
+                modelEpoch.set(record.locator, (modelEpoch.get(record.locator) ?? 0) + 1);
+                invalidModels.add(record.locator);
+            }
+            const model = persisted.status === 'unavailable' || liveModels.get(record.locator) === JSON.stringify(persisted.snapshot) ? persisted : cached(persisted);
+            models.set(record.locator, model);
+            if (model.status === 'unavailable') {
+                liveModels.delete(record.locator);
+                invalidModels.delete(record.locator);
+            }
+            const confirmed = readConfirmed({
+                ...record,
+                model
+            });
             if (confirmed === null) continue;
             replicas.set(record.locator, replicaOf(confirmed, queuedBatches.get(record.locator) ?? []));
             const existing = rooms.get(record.locator);
@@ -236,7 +369,11 @@ 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)
                 });
             }
         }
@@ -255,6 +392,7 @@ export function createMdRuntime(options) {
             emitVisible();
         }
         for (const locator of locators)emitQueue(locator);
+        emitDrafts();
         return lastCompleted;
     }
     async function applyRemote(message) {
@@ -323,9 +461,14 @@ export function createMdRuntime(options) {
         return exclusive(async ()=>{
             await acrossTabs('mdruntime-replica', async ()=>{
                 await hydrate(local);
-                await local.publish(confirmed.record);
+                const retained = readConfirmed({
+                    ...confirmed.record,
+                    model: modelOf(room.locator)
+                });
+                if (retained === null) return;
+                await local.publish(retained.record);
                 unreadable.delete(room.locator);
-                replicas.set(room.locator, replicaOf(confirmed, replicas.get(room.locator)?.queue ?? []));
+                replicas.set(room.locator, replicaOf(retained, replicas.get(room.locator)?.queue ?? []));
             });
             list(room, true);
             emitRooms();
@@ -342,9 +485,19 @@ export function createMdRuntime(options) {
             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,
-                writeGrants: room.writeGrants,
+                collectionRoot: replica.confirmed.record.collectionRoot,
+                operations: room.operations,
+                model: invalidModels.has(locator) ? {
+                    status: 'unavailable',
+                    reason: 'revoked'
+                } : modelOf(locator),
+                binding: options.modelBinding,
                 providerOwnedPaths: room.providerOwnedPaths,
                 providerLimits: limits,
                 visible: replica.visible,
@@ -386,10 +539,11 @@ export function createMdRuntime(options) {
                 };
             }
             if (replacing !== undefined) outcomes.delete(replacing);
-            for (const path of consumed)drafts.delete(at(locator, path));
+            for (const path of consumed)forgetDraft(locator, path);
             replicas.set(locator, replicaOf(replica.confirmed, batches));
             emitQueue(locator);
             emitVisible();
+            emitDrafts();
             moveTo({
                 ...saving(status),
                 attentionRequired: attention()
@@ -463,6 +617,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  {
@@ -506,6 +664,10 @@ 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}`);
@@ -519,7 +681,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;
@@ -530,7 +692,7 @@ 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, modelOf(room.locator), options.modelBinding);
             const detail = result.kind === 'staged' ? result.confirmed.record.roomVersion : result.kind;
             journal.record(`transfer bootstrap ${room.locator} ${detail}`);
             return result;
@@ -589,7 +751,12 @@ export function createMdRuntime(options) {
                 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;
+            const retainedBase = readConfirmed({
+                ...base.record,
+                model: modelOf(room.locator)
+            });
+            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);
@@ -645,6 +812,11 @@ export function createMdRuntime(options) {
                 refuse('revoked-authorization');
                 return 'stop';
             }
+            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') {
                 journal.record(`outcome ${room.locator} ${head.id} ${result.kind}`);
                 if (result.kind !== 'expired') journal.record(`refusal ${result.kind} ${result.text}`);
@@ -673,6 +845,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) {
@@ -696,6 +873,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));
@@ -727,15 +909,172 @@ export function createMdRuntime(options) {
         }
         return null;
     }
+    async function retainModel(local, room, next) {
+        if (next.status === 'unavailable') modelEpoch.set(room.locator, (modelEpoch.get(room.locator) ?? 0) + 1);
+        const epoch = modelEpoch.get(room.locator) ?? 0;
+        const previous = modelOf(room.locator);
+        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))) 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(room.locator);
+            liveModels.delete(room.locator);
+        }
+        await exclusive(async ()=>acrossTabs('mdruntime-replica', async ()=>{
+                await hydrate(local);
+                if (next.status !== 'unavailable' && epoch !== (modelEpoch.get(room.locator) ?? 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,
+                        model: next
+                    };
+                    await local.publish(record);
+                    const confirmed = readConfirmed(record);
+                    if (confirmed !== null) replicas.set(room.locator, replicaOf(confirmed, held.queue));
+                }
+                models.set(room.locator, next);
+                if (next.status === 'current') {
+                    liveModels.set(room.locator, JSON.stringify(next.snapshot));
+                    invalidModels.delete(room.locator);
+                }
+                list(room, room.replica.admission === 'admitted' && !unreadable.has(room.locator));
+                emitRooms();
+                if (queryChanged && held !== undefined) emitVisible();
+                announce();
+            }));
+    }
+    async function acquireModel(local, room, authorized) {
+        let previous = modelOf(room.locator);
+        if (previous.status !== 'unavailable' && (room.attachedModel === null || !sameModel(previous.snapshot, room.attachedModel))) {
+            previous = {
+                status: 'unavailable',
+                reason: 'version-changed'
+            };
+            await retainModel(local, room, previous);
+        }
+        const epoch = modelEpoch.get(room.locator) ?? 0;
+        let answer;
+        try {
+            answer = await options.adapter.model(authorized, {
+                locator: room.locator,
+                collectionRoot: room.collectionRoot,
+                model: room.attachedModel
+            });
+        } catch  {
+            answer = {
+                kind: 'transport-uncertainty'
+            };
+        }
+        if (epoch !== (modelEpoch.get(room.locator) ?? 0)) return;
+        if (answer.kind === 'revoked-authorization') {
+            await retainModel(local, room, {
+                status: 'unavailable',
+                reason: 'revoked'
+            });
+            refuse('revoked-authorization');
+            return;
+        }
+        if (answer.kind === 'transport-uncertainty') {
+            await retainModel(local, room, cached(previous));
+            return;
+        }
+        if (answer.kind === 'model-unavailable') {
+            await retainModel(local, room, {
+                status: 'unavailable',
+                reason: answer.reason
+            });
+            return;
+        }
+        if (room.attachedModel === null || !sameModel(answer.snapshot, room.attachedModel)) {
+            await retainModel(local, room, {
+                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, {
+                status: 'unavailable',
+                reason: 'invalid'
+            });
+            return;
+        }
+        const verified = options.modelBinding?.verify(answer.snapshot);
+        await retainModel(local, room, 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) {
+        if (result.scope === 'model') await retainModel(local, room, {
+            status: 'unavailable',
+            reason: 'not-readable'
+        });
+        else if (result.scope !== 'operation') {
+            unreadable.add(room.locator);
+            const unavailable = {
+                ...room,
+                replica: {
+                    ...room.replica,
+                    admission: 'unavailable'
+                },
+                operations: {
+                    ...room.operations,
+                    ...result.scope === 'content' ? {
+                        read: []
+                    } : {},
+                    ...result.scope === 'sync' ? {
+                        sync: []
+                    } : {}
+                }
+            };
+            await retainModel(local, unavailable, modelOf(room.locator));
+            list(unavailable, false);
+            emitRooms();
+        }
+        journal.record(`scoped refusal ${room.locator} ${result.scope} ${result.text}`);
+    }
     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);
+            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;
@@ -764,10 +1103,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();
@@ -775,10 +1114,17 @@ 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, cached(modelOf(room.locator)));
             progress.reachable = false;
             notifyReady();
             return;
         }
+        if (result.kind === 'contract-unavailable') {
+            journal.record(`connection contract unavailable ${result.text}`);
+            refuse('missing-required-guarantee');
+            notifyReady();
+            return;
+        }
         if (result.kind === 'revoked-authorization') {
             refuse('revoked-authorization');
             notifyReady();
@@ -794,6 +1140,34 @@ 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) || room.attachedModel === undefined || room.attachedModel !== null && (typeof room.attachedModel.identity !== 'string' || !room.attachedModel.identity || typeof room.attachedModel.version !== 'string' || !room.attachedModel.version)) {
+                journal.record(`invalid model or replica 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)) {
@@ -915,6 +1289,7 @@ export function createMdRuntime(options) {
         statusListeners.clear();
         querySubscriptions.clear();
         queueSubscriptions.clear();
+        draftListeners.clear();
     }
     channel?.addEventListener('message', (event)=>{
         const data = event.data;
@@ -939,28 +1314,41 @@ export function createMdRuntime(options) {
             return visible(request);
         },
         types (locator) {
-            return replicas.get(locator)?.visible.collection.types ?? [];
+            return modelTypes(modelOf(locator));
         },
         syncStatus () {
             return status;
         },
         draft: {
+            list () {
+                return exclusive(async ()=>{
+                    const local = await openLocal();
+                    return readDrafts(local);
+                }).then((entries)=>{
+                    releaseWaitingDrafts();
+                    return entries;
+                });
+            },
             read (locator, path) {
-                return drafts.get(at(locator, path)) ?? null;
+                const content = draftContent(locator, path);
+                return content === undefined ? null : structuredClone(content);
             },
-            async replace (locator, path, content) {
-                const local = await openLocal();
-                await local.keep({
-                    locator,
-                    path,
-                    content
+            replace (locator, path, content) {
+                return commitDraft(async (local)=>{
+                    const stored = structuredClone(content);
+                    await local.keep({
+                        locator,
+                        path,
+                        content: stored
+                    });
+                    rememberDraft(locator, path, stored);
                 });
-                drafts.set(at(locator, path), content);
             },
-            async discard (locator, path) {
-                const local = await openLocal();
-                await local.discard(locator, path);
-                drafts.delete(at(locator, path));
+            discard (locator, path) {
+                return commitDraft(async (local)=>{
+                    await local.discard(locator, path);
+                    forgetDraft(locator, path);
+                });
             }
         },
         save (locator, changes, replacing) {
@@ -994,6 +1382,26 @@ export function createMdRuntime(options) {
             return storageLoss;
         },
         observe (topic, second, third) {
+            if (topic === 'drafts') {
+                const notify = second;
+                const listener = {
+                    notify,
+                    ready: false
+                };
+                draftListeners.add(listener);
+                void exclusive(async ()=>{
+                    const local = await openLocal();
+                    await readDrafts(local);
+                    if (closed || !draftListeners.has(listener)) return;
+                    listener.ready = true;
+                }).then(()=>{
+                    if (closed || !listener.ready || !draftListeners.has(listener)) return;
+                    listener.notify(snapshotDrafts());
+                }, ()=>{});
+                return ()=>{
+                    draftListeners.delete(listener);
+                };
+            }
             if (topic === 'rooms') {
                 const notify = second;
                 roomListeners.add(notify);