@agentshouse/mdruntime 0.1.0-alpha.42 → 0.1.0-alpha.44

package/dist/connection.js

@@ -57,6 +57,7 @@ export function composeRuntime(options) {
     const presentations = new Map();
     const outcomes = new Map();
     const outcomeRooms = new Map();
+    const wanted = new Map();
     let limits = [];
     let slots = [];
     let capabilities = [];
@@ -449,6 +450,7 @@ export function composeRuntime(options) {
         for (const locator of listedLocators)scopedRefusals.delete(locator);
         discovered.clear();
         for (const room of listed)discovered.set(room.locator, room);
+        for (const locator of wanted.keys())if (!listedLocators.has(locator)) wanted.delete(locator);
         await dropUnlisted(listedLocators, local);
         for (const room of listed){
             const held = replicas.get(room.locator)?.confirmed.record;
@@ -751,11 +753,19 @@ export function composeRuntime(options) {
             }, prior?.confirmed);
             if (retained.kind !== 'staged') throw new Error(`Cannot retype staged Room ${room.locator}`);
             const queue = prior?.queue ?? [];
-            const accepted = queue.filter((batch)=>outcomes.get(batch.id)?.kind === 'accepted');
+            const roomVersion = retained.confirmed.record.roomVersion;
+            const accepted = queue.filter((batch)=>{
+                const outcome = outcomes.get(batch.id);
+                return outcome?.kind === 'accepted' && options.adapter.reached(room.locator, roomVersion, outcome.roomVersion);
+            });
             const set = await settle(local, room.locator, prior, retained.confirmed, queue.filter((batch)=>!accepted.includes(batch)), {
                 room: true
             });
             for (const batch of accepted)pendings.delete(batch.id);
+            const target = wanted.get(room.locator);
+            if (target !== undefined && options.adapter.reached(room.locator, roomVersion, target)) {
+                wanted.delete(room.locator);
+            }
             unreadable.delete(room.locator);
             sourceRefusals.delete(room.locator);
             declarationRefusals.delete(room.locator);
@@ -978,6 +988,7 @@ export function composeRuntime(options) {
                 name,
                 input
             });
+            if (result.kind === 'action' && result.at !== undefined) want(result.at);
             if (result.kind === 'scoped-refusal') {
                 const room = replicas.get(result.locator)?.confirmed.record;
                 if (room !== undefined) await scoped(result, room, await openLocal());
@@ -996,10 +1007,36 @@ export function composeRuntime(options) {
     function continuing() {
         return !closed && !discoveryPaused;
     }
-    async function pullRefresh(authorized, confirmed) {
+    function reachedBy(locator, roomVersion) {
+        const held = replicas.get(locator);
+        return held !== undefined && options.adapter.reached(locator, held.confirmed.record.roomVersion, roomVersion);
+    }
+    function want({ locator, roomVersion }) {
+        if (reachedBy(locator, roomVersion)) return;
+        const held = wanted.get(locator);
+        if (held === undefined || options.adapter.reached(locator, roomVersion, held)) {
+            wanted.set(locator, roomVersion);
+        }
+    }
+    function reachOf(locator) {
+        let target = wanted.get(locator);
+        const versions = (replicas.get(locator)?.queue ?? []).flatMap((batch)=>{
+            const outcome = outcomes.get(batch.id);
+            return outcome?.kind === 'accepted' ? [
+                outcome.roomVersion
+            ] : [];
+        });
+        for (const version of versions){
+            if (target === undefined || options.adapter.reached(locator, version, target)) {
+                target = version;
+            }
+        }
+        return target === undefined || reachedBy(locator, target) ? undefined : target;
+    }
+    async function pullRefresh(authorized, confirmed, reach) {
         if (!continuing()) return unconfirmed;
         try {
-            const result = await refreshRoom(options.adapter, authorized, confirmed, continuing);
+            const result = await refreshRoom(options.adapter, authorized, confirmed, continuing, reach);
             const detail = result.kind === 'advanced' ? result.confirmed.record.roomVersion : result.kind;
             journal.record(`transfer refresh ${confirmed.record.locator} ${detail}`);
             return result;
@@ -1026,7 +1063,7 @@ export function composeRuntime(options) {
     async function advance(room, local, authorized) {
         const held = replicas.get(room.locator);
         if (held !== undefined) {
-            const refreshed = await pullRefresh(authorized, held.confirmed);
+            const refreshed = await pullRefresh(authorized, held.confirmed, reachOf(room.locator));
             if (!continuing()) return unconfirmed;
             if (refreshed.kind === 'still-current') {
                 if (sourceRefusals.has(room.locator)) return unconfirmed;
@@ -1054,6 +1091,8 @@ export function composeRuntime(options) {
             await scoped(withheld, room, local);
         } else if (withheld.kind === 'transport-uncertainty') {
             progress.reachable = false;
+        } else if (withheld.kind === 'retryable-refusal') {
+            journal.record(`refusal ${withheld.kind} ${withheld.code}`);
         } else if (withheld.kind === 'room-not-readable') {
             unreadable.add(room.locator);
             list(room, false);
@@ -1145,7 +1184,7 @@ export function composeRuntime(options) {
     function logAccepted(locator, submitted, accepted) {
         journal.record(`outcome ${locator} ${submitted.id} accepted ${accepted.roomVersion}` + (accepted.author === undefined ? '' : ` author ${accepted.author}`) + (accepted.time === undefined ? '' : ` time ${accepted.time}`));
     }
-    async function holdAccepted(room, local, submitted, accepted, refused) {
+    async function recordAccepted(room, local, submitted, accepted) {
         await exclusive(async ()=>{
             if (!continuing()) return;
             const current = replicas.get(room.locator);
@@ -1169,7 +1208,6 @@ export function composeRuntime(options) {
             outcomeRooms.set(submitted.id, room.locator);
             logAccepted(room.locator, submitted, accepted);
         });
-        if (refused !== null && continuing()) refusedSource(room, refused);
     }
     async function commitAccept(room, local, submitted, accepted, base, overlay) {
         if (!continuing()) return unconfirmed;
@@ -1201,13 +1239,20 @@ export function composeRuntime(options) {
             ...status,
             ...attention()
         });
-        logAccepted(room.locator, submitted, accepted);
         return null;
     }
+    async function accepting(room, local, submitted, accepted, pulled, fresh) {
+        const roomVersion = pulled.record.roomVersion;
+        if (options.adapter.reached(room.locator, roomVersion, accepted.roomVersion)) {
+            return committed(room, local, submitted, accepted, pulled, roomVersion === accepted.roomVersion);
+        }
+        if (fresh && continuing()) await publish(local, room, pulled);
+        return false;
+    }
     async function committed(room, local, submitted, accepted, base, overlay) {
         const failed = await exclusive(()=>commitAccept(room, local, submitted, accepted, base, overlay));
         if (failed === null) return true;
-        await holdAccepted(room, local, submitted, accepted, failed.kind === 'refused' ? failed : null);
+        if (failed.kind === 'refused' && continuing()) refusedSource(room, failed);
         return false;
     }
     async function submitRoom(room, local, authorized, progress) {
@@ -1338,9 +1383,10 @@ export function composeRuntime(options) {
                 if (withheld !== null) return withhold(withheld, room, local, progress);
                 continue;
             }
+            await recordAccepted(room, local, head, result);
             const from = replicas.get(room.locator)?.confirmed;
             if (from === undefined) return;
-            const pulled = await pullRefresh(authorized, from);
+            const pulled = await pullRefresh(authorized, from, reachOf(room.locator));
             if (!continuing()) return;
             if (pulled.kind === 'revoked-authorization') {
                 await refuse('revoked-authorization');
@@ -1351,16 +1397,9 @@ export function composeRuntime(options) {
                 progress.complete = false;
                 return;
             }
-            if (pulled.kind === 'still-current') {
-                if (!await committed(room, local, head, result, from, true)) {
-                    progress.complete = false;
-                    return;
-                }
-                continue;
-            }
-            if (pulled.kind === 'advanced') {
-                const overlay = pulled.confirmed.record.roomVersion === result.roomVersion;
-                if (!await committed(room, local, head, result, pulled.confirmed, overlay)) {
+            if (pulled.kind === 'still-current' || pulled.kind === 'advanced') {
+                const fresh = pulled.kind === 'advanced';
+                if (!await accepting(room, local, head, result, fresh ? pulled.confirmed : from, fresh)) {
                     progress.complete = false;
                     return;
                 }
@@ -1379,8 +1418,7 @@ export function composeRuntime(options) {
                     return;
                 }
                 if (bootstrapped.kind === 'staged') {
-                    const overlay = bootstrapped.confirmed.record.roomVersion === result.roomVersion;
-                    if (!await committed(room, local, head, result, bootstrapped.confirmed, overlay)) {
+                    if (!await accepting(room, local, head, result, bootstrapped.confirmed, true)) {
                         progress.complete = false;
                         return;
                     }
@@ -1394,7 +1432,7 @@ export function composeRuntime(options) {
                     list(room, false);
                     emitRooms();
                 } else if (bootstrapped.kind === 'refused') {
-                    await holdAccepted(room, local, head, result, bootstrapped);
+                    refusedSource(room, bootstrapped);
                 }
                 return;
             }
@@ -1405,8 +1443,10 @@ export function composeRuntime(options) {
                 unreadable.add(room.locator);
                 list(room, false);
                 emitRooms();
+            } else if (pulled.kind === 'retryable-refusal') {
+                journal.record(`refusal ${pulled.kind} ${pulled.code}`);
             } else if (pulled.kind === 'refused') {
-                await holdAccepted(room, local, head, result, pulled);
+                refusedSource(room, pulled);
             }
             return;
         }
@@ -1589,14 +1629,22 @@ export function composeRuntime(options) {
         journal.record(`scoped refusal ${room.locator} ${result.scope} ${result.code}`);
     }
     async function synchronize(discovered, local, progress) {
-        const rooms = await Promise.allSettled(discovered.map((room)=>synchronizeRoom(room, local, progress)));
-        const failed = rooms.find((room)=>room.status === 'rejected');
+        const prepared = await Promise.allSettled(discovered.map((room)=>prepareRoom(room, local, progress)));
+        const ready = discovered.filter((_, index)=>{
+            const outcome = prepared[index];
+            return outcome?.status === 'fulfilled' && outcome.value;
+        });
+        const rooms = await Promise.allSettled(ready.map((room)=>synchronizeRoom(room, local, progress)));
+        const failed = [
+            ...prepared,
+            ...rooms
+        ].find((room)=>room.status === 'rejected');
         if (failed !== undefined) throw failed.reason;
     }
-    async function synchronizeRoom(room, local, progress) {
+    async function prepareRoom(room, local, progress) {
         if (closed || authorization === undefined) {
             progress.complete = false;
-            return;
+            return false;
         }
         const prior = replicas.get(room.locator)?.confirmed.record;
         if (prior !== undefined && prior.replica.selection !== room.replica.selection) {
@@ -1604,7 +1652,7 @@ export function composeRuntime(options) {
             emitRooms();
             journal.record(`selection changed ${room.locator}`);
             progress.complete = false;
-            return;
+            return false;
         }
         const selection = room.typedSelection;
         await Promise.all([
@@ -1613,16 +1661,20 @@ export function composeRuntime(options) {
                 acquireModel(local, room, authorization, selection)
             ]
         ]);
-        if (discoveryPaused || authorization === undefined) return;
+        if (discoveryPaused || authorization === undefined) return false;
         if (room.replica.admission !== 'admitted') {
             progress.complete = false;
-            return;
+            return false;
         }
         const held = replicas.get(room.locator);
         if (held !== undefined && held.confirmed.record.replica.selection !== room.replica.selection) {
             progress.complete = false;
-            return;
+            return false;
         }
+        return true;
+    }
+    async function synchronizeRoom(room, local, progress) {
+        if (discoveryPaused || authorization === undefined) return;
         const withheld = await advance(room, local, authorization);
         if (withheld !== null) {
             await withhold(withheld, room, local, progress);
@@ -2212,6 +2264,9 @@ export function composeRuntime(options) {
         call (name, input) {
             return invokeAction(name, input);
         },
+        reached (locator, roomVersion) {
+            return reachedBy(locator, roomVersion);
+        },
         log () {
             return journal.export();
         },