@agentshouse/mdruntime 0.1.0-alpha.7 → 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;
@@ -146,9 +155,9 @@ export function createMdRuntime(options) {
         announce();
     }
     function listed() {
-        return [
+        return structuredClone([
             ...rooms.values()
-        ];
+        ]);
     }
     function queryRooms() {
         return [
@@ -156,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() {
@@ -193,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: [
@@ -234,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 = {
@@ -246,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
@@ -256,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;
@@ -291,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);
@@ -299,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)
                 });
             }
         }
@@ -387,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();
@@ -406,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,
@@ -528,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  {
@@ -571,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}`);
@@ -584,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;
@@ -595,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;
@@ -654,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);
@@ -710,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}`);
@@ -738,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) {
@@ -761,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));
@@ -792,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;
@@ -829,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();
@@ -840,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();
@@ -859,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)) {
@@ -1005,7 +1314,7 @@ export function createMdRuntime(options) {
             return visible(request);
         },
         types (locator) {
-            return replicas.get(locator)?.visible.collection.types ?? [];
+            return modelTypes(modelOf(locator));
         },
         syncStatus () {
             return status;