@agentshouse/mdruntime 0.1.0-c0bed82db8d73 → 0.1.0-c0c1e81da9166

package/dist/store.js

@@ -1,5 +1,9 @@
+import { composedOf } from './collection.js';
 import { binaryLocalId } from './identity.js';
 const FILE = '\u0000file';
+function batchFacts(batch) {
+    return { paths: batch.changes.map(({ path }) => path), moving: batch.between !== undefined };
+}
 function batchFiles(batch) {
     return batch.changes.flatMap((change) => (change.kind === 'binary' ? [change.localId] : []));
 }
@@ -9,7 +13,8 @@ function draftFiles(drafts) {
 function roomDraftRow(record) {
     return { path: record.path, record: JSON.stringify(record), files: draftFiles([record]) };
 }
-function authoredRows({ locator, queue, founded, saved, roomDrafts, consumedRoomDrafts, accepted }, held) {
+function authoredRows({ locator, queue, stored, founded, saved, roomDrafts, consumedRoomDrafts, }) {
+    const held = new Set((stored ?? []).map(({ id }) => id));
     return {
         locator,
         ...(queue === undefined
@@ -17,7 +22,7 @@ function authoredRows({ locator, queue, founded, saved, roomDrafts, consumedRoom
             : {
                 order: queue.map(({ id }) => id),
                 added: queue
-                    .filter(({ id }) => held?.has(id) !== true)
+                    .filter(({ id }) => !held.has(id))
                     .map((batch) => {
                     const drafts = saved?.get(batch.id) ?? [];
                     return {
@@ -29,6 +34,7 @@ function authoredRows({ locator, queue, founded, saved, roomDrafts, consumedRoom
                             lost: false,
                         }),
                         files: [...batchFiles(batch), ...draftFiles(drafts)],
+                        ...batchFacts(batch),
                     };
                 }),
             }),
@@ -39,18 +45,11 @@ function authoredRows({ locator, queue, founded, saved, roomDrafts, consumedRoom
                     id: batch.id,
                     batch: JSON.stringify(batch),
                     files: batchFiles(batch),
+                    ...batchFacts(batch),
                 })),
             }),
         ...(roomDrafts === undefined ? {} : { roomDrafts: roomDrafts.map(roomDraftRow) }),
         ...(consumedRoomDrafts === undefined ? {} : { consumedRoomDrafts }),
-        ...(accepted === undefined
-            ? {}
-            : {
-                amendments: accepted.map(({ id, roomVersion }) => ({
-                    id,
-                    amendment: JSON.stringify({ accepted: roomVersion }),
-                })),
-            }),
     };
 }
 function marked(value) {
@@ -85,10 +84,17 @@ async function filed(value, read) {
         restored[name] = await filed(item, read);
     return restored;
 }
+function roomOf(row) {
+    return {
+        record: { ...JSON.parse(row.record), key: row.key },
+        indexed: row.indexed,
+        documents: row.documents,
+    };
+}
 function json(value, fallback) {
     return value === undefined ? fallback : JSON.parse(value);
 }
-export function openRuntimeStore(fenced, authored) {
+export function openRuntimeStore(authored) {
     const keys = new WeakMap();
     const read = async (key, type) => {
         const blob = await authored.ask({ kind: 'authored.file', key, type });
@@ -97,8 +103,6 @@ export function openRuntimeStore(fenced, authored) {
     };
     const restored = async (records) => Promise.all(records.map(async (record) => (await filed(JSON.parse(record), read))));
     const amend = async (locator, id, amendment) => {
-        if (fenced(locator))
-            return;
         await authored.ask({
             kind: 'authored.amend',
             locator,
@@ -107,56 +111,95 @@ export function openRuntimeStore(fenced, authored) {
         });
     };
     const fact = (name) => authored.ask({ kind: 'authored.fact', name });
-    const queued = new Map();
     const changed = new Map();
     const change = (key) => changed.set(key, (changed.get(key) ?? 0) + 1);
-    const rows = (writes) => writes.map((write) => authoredRows(write, queued.get(write.locator)));
-    const noted = (writes) => {
-        for (const { locator, queue } of writes) {
-            if (queue !== undefined)
-                queued.set(locator, new Set(queue.map(({ id }) => id)));
-        }
-    };
     return {
-        async opened() {
-            const held = await authored.ask({ kind: 'replica.open' });
-            const unindexed = new Set(held.keys.flatMap(({ key, rederiving }) => (rederiving === null ? [] : [key])));
-            const overlaid = new Map();
-            for (const { key, path } of held.overlaid) {
-                const paths = overlaid.get(key) ?? new Set();
-                paths.add(path);
-                overlaid.set(key, paths);
-            }
+        opened() {
+            return authored.ask({ kind: 'replica.open' });
+        },
+        async rooms(locators) {
+            const held = await authored.ask({ kind: 'replica.rooms', locators: locators ?? null });
+            return held.map(roomOf);
+        },
+        async room(locator) {
+            const { room, queue } = await authored.ask({ kind: 'replica.room', locator });
             return {
-                rooms: new Map(held.rooms
-                    .filter(({ locator }) => !fenced(locator))
-                    .map(({ locator, key, record }) => [
-                    locator,
-                    { ...JSON.parse(record), key },
-                ])),
-                transfers: new Map(held.transfers
-                    .filter(({ locator }) => !fenced(locator))
-                    .map(({ locator, key, record }) => [
+                room: room === null ? null : { ...roomOf(room), overlaid: new Set(room.overlaid) },
+                queue: queue.map(({ batch, state }) => ({
+                    batch: JSON.parse(batch),
+                    state: JSON.parse(state),
+                })),
+            };
+        },
+        async covering() {
+            const { rooms, queues } = await authored.ask({ kind: 'replica.covering' });
+            return {
+                rooms: new Map(rooms.map(({ locator, ...room }) => [locator, room])),
+                queues: new Map(queues.map(({ locator, ids }) => [locator, ids])),
+            };
+        },
+        offline(locator) {
+            return authored.ask({ kind: 'replica.offline', locator });
+        },
+        async held() {
+            const { held, staged } = await authored.ask({ kind: 'replica.held' });
+            return { held: new Set(held), staged: new Set(staged) };
+        },
+        async status() {
+            const { queued, lastCompleted, changes, resets, returned } = await authored.ask({
+                kind: 'authored.status',
+            });
+            return {
+                queued,
+                lastCompleted: json(lastCompleted ?? undefined, null),
+                unsent: changes.map(({ locator, path }) => ({ room: locator, path })),
+                resets,
+                returned: returned.map((record) => JSON.parse(record)),
+            };
+        },
+        async batch(locator, id) {
+            const held = await authored.ask({ kind: 'authored.batch', locator, id });
+            return held === null ? null : JSON.parse(held);
+        },
+        order(locator) {
+            return authored.ask({ kind: 'authored.order', locator });
+        },
+        queued() {
+            return authored.ask({ kind: 'authored.queued' });
+        },
+        async moving() {
+            const { queues, pending } = await authored.ask({ kind: 'authored.moving' });
+            return {
+                queued: new Map(queues.map(({ locator, ids }) => [locator, ids])),
+                moving: pending.map(({ locator, batch, state }) => ({
                     locator,
-                    { ...JSON.parse(record), key },
-                ])),
-                unindexed,
-                overlaid,
-                erasing: held.erasing.length > 0,
-                orphans: held.orphans,
-                lastCompleted: json(held.facts.lastCompleted, null),
-                providerLimits: json(held.facts.providerLimits, []),
-                capabilities: json(held.facts.capabilities, []),
-                member: json(held.facts.member, null),
-                targets: json(held.facts.targets, {}),
-                presentation: held.presentation.map(({ app, value }) => ({
-                    app,
-                    value: JSON.parse(value),
+                    batch: JSON.parse(batch),
+                    state: JSON.parse(state),
                 })),
             };
         },
-        counts(rooms) {
-            return authored.ask({ kind: 'replica.counts', rooms });
+        async pending(locator, id) {
+            const { state, room } = await authored.ask({ kind: 'authored.pending', locator, id });
+            return { state: state === null ? undefined : JSON.parse(state), room };
+        },
+        async facts() {
+            const held = await authored.ask({ kind: 'replica.facts' });
+            return {
+                lastCompleted: json(held.lastCompleted, null),
+                providerLimits: json(held.providerLimits, []),
+                capabilities: json(held.capabilities, []),
+                member: json(held.member, null),
+                targets: json(held.targets, {}),
+                conversationList: json(held.conversationList, null),
+                conversationCursor: json(held.conversationCursor, null),
+            };
+        },
+        async presentation(app) {
+            const held = await authored.ask({ kind: 'replica.presentation', app });
+            return held === null ? undefined : JSON.parse(held);
+        },
+        async demote() {
+            await authored.ask({ kind: 'replica.demote' });
         },
         query(plan, rooms, budget) {
             return authored.ask({ kind: 'replica.query', plan, rooms, budget });
@@ -170,51 +213,42 @@ export function openRuntimeStore(fenced, authored) {
         typed(key, view, paths) {
             return authored.ask({ kind: 'replica.typed', key, view, paths });
         },
-        referrers(key, view, targets, kinds) {
-            return authored.ask({ kind: 'replica.referrers', key, view, targets, kinds });
+        referrers(key, view, targets) {
+            return authored.ask({ kind: 'replica.referrers', key, view, targets });
         },
-        walk(key, view, after, bytes) {
-            return authored.ask({ kind: 'replica.walk', key, view, after, bytes });
-        },
-        files(key, view, after, limit) {
-            return authored.ask({ kind: 'replica.files', key, view, after, limit });
+        folders(key, view, paths) {
+            return authored.ask({ kind: 'replica.folders', key, view, paths });
         },
         typedWithin(key, view, roots, within) {
             return authored.ask({ kind: 'replica.typedWithin', key, view, roots, within });
         },
-        search(ask) {
-            return authored.ask({ kind: 'replica.search', ...ask });
-        },
-        async stage(record, composition, page, written) {
-            if (fenced(record.locator))
-                return null;
-            const { key, ...kept } = record;
+        stage(record, composition, page) {
             return authored.ask({
                 kind: 'replica.stage',
                 locator: record.locator,
                 transfer: record.transfer,
-                record: JSON.stringify(kept),
-                key,
-                composition,
+                key: record.key,
+                fingerprint: composedOf(composition).fingerprint,
                 entries: page.entries,
                 folders: page.folders,
-                ...(written === undefined ? {} : { written }),
+                part: page.part ?? null,
             });
         },
-        async transferPart(locator, token) {
-            if (fenced(locator))
-                return null;
-            return authored.ask({ kind: 'replica.transferPart', locator, token });
-        },
-        async keepPart(locator, token, part) {
-            if (fenced(locator))
-                return;
-            await authored.ask({ kind: 'replica.keepPart', locator, token, part });
+        resume(record, composition, parts, published) {
+            return authored.ask({
+                kind: 'replica.resume',
+                locator: record.locator,
+                transfer: record.transfer,
+                fingerprint: composedOf(composition).fingerprint,
+                parts,
+                published,
+            });
         },
-        async refresh(key, page) {
+        async refresh(key, composition, page) {
             await authored.ask({
                 kind: 'replica.refresh',
                 key,
+                composed: composedOf(composition),
                 entries: page.entries,
                 removals: page.removals,
                 folders: page.folders,
@@ -224,82 +258,59 @@ export function openRuntimeStore(fenced, authored) {
         async unrefresh(key) {
             await authored.ask({ kind: 'replica.unrefresh', key });
         },
-        async commit({ rooms, writes = [], files = [], whole = false, discards = [] }) {
-            const kept = whole ? writes : writes.filter(({ locator }) => !fenced(locator));
-            const refused = whole ? kept.find(({ locator }) => fenced(locator)) : undefined;
-            if (refused !== undefined) {
-                return { fenced: refused.locator, counts: {}, changed: {}, indexed: {} };
-            }
+        commit({ rooms, writes = [], files = [], whole = false }) {
             for (const room of rooms)
                 change(room.key);
-            const committed = await authored.ask({
+            return authored.ask({
                 kind: 'replica.commit',
-                ...(kept.length === 0 && files.length === 0 && discards.length === 0
+                ...(writes.length === 0 && files.length === 0
                     ? {}
-                    : { authored: { writes: rows(kept), files, whole, discards } }),
-                rooms: rooms.filter(({ locator }) => !fenced(locator)),
+                    : { authored: { writes: writes.map(authoredRows), files, whole } }),
+                rooms,
             });
-            if (committed.fenced === null || !whole)
-                noted(kept);
-            for (const locator of discards)
-                queued.delete(locator);
-            return committed;
         },
         async fence(locators) {
             await authored.ask({ kind: 'replica.fence', locators });
-            for (const locator of locators)
-                queued.delete(locator);
         },
         async erase(locator, limit) {
             return (await authored.ask({ kind: 'replica.erase', locator, limit })).remaining;
         },
-        async abandon(locator, kept = false) {
-            if (fenced(locator))
-                return null;
-            return authored.ask({ kind: 'replica.abandon', locator, kept });
+        async abandon(locator) {
+            await authored.ask({ kind: 'replica.abandon', locator });
+        },
+        async unfence(locators) {
+            return new Set(await authored.ask({ kind: 'replica.unfence', locators }));
         },
         async release(key) {
             await authored.ask({ kind: 'replica.release', key });
         },
-        async rederive(key, limit) {
+        async rederive(key, composition, bytes, ms, floor) {
             change(key);
-            return (await authored.ask({ kind: 'replica.rederive', key, limit })).done;
+            return authored.ask({
+                kind: 'replica.rederive',
+                key,
+                composed: composedOf(composition),
+                bytes,
+                ms,
+                floor,
+            });
         },
         async fact(name, value) {
             await authored.ask({ kind: 'replica.fact', name, value: JSON.stringify(value) });
         },
-        async queues() {
-            const { queues, pending } = await authored.ask({ kind: 'authored.queues' });
-            queued.clear();
-            for (const queue of queues)
-                queued.set(queue.locator, new Set(queue.ids));
-            const byId = new Map(pending.map((record) => [`${record.locator}\0${record.id}`, record]));
-            return queues
-                .filter((queue) => !fenced(queue.locator))
-                .map((queue) => ({
-                locator: queue.locator,
-                pending: queue.ids.map((id) => {
-                    const record = byId.get(`${queue.locator}\0${id}`);
-                    if (record === undefined)
-                        throw new Error(`Missing Pending Change ${queue.locator}/${id}`);
-                    return {
-                        batch: JSON.parse(record.batch),
-                        state: JSON.parse(record.state),
-                    };
-                }),
-            }));
-        },
         submit(locator, id, submission, lost) {
             return amend(locator, id, { submission, lost });
         },
         keepUpload(locator, id, upload) {
             return amend(locator, id, { upload });
         },
-        async roomDrafts() {
-            const held = await authored.ask({ kind: 'authored.roomDrafts' });
-            return held
-                .map((record) => JSON.parse(record))
-                .filter((record) => !fenced(record.locator));
+        async roomDrafts(locator, paths) {
+            const held = await authored.ask({
+                kind: 'authored.roomDrafts',
+                locator: locator ?? null,
+                paths: paths ?? null,
+            });
+            return held.map((record) => JSON.parse(record));
         },
         async present(record) {
             await authored.ask({
@@ -308,21 +319,27 @@ export function openRuntimeStore(fenced, authored) {
                 value: JSON.stringify(record.value ?? null),
             });
         },
-        conversations() {
-            return authored.ask({ kind: 'conversation.held' });
+        conversations(conversations) {
+            return authored.ask({ kind: 'conversation.held', conversations: conversations ?? null });
         },
         async keepMessages(write) {
             await authored.ask({ kind: 'conversation.keep', ...write });
         },
-        messageWindow(conversation, limit, before) {
-            return authored.ask({ kind: 'conversation.window', conversation, limit, before });
+        messageWindow(conversation, limit, before, phrase = null) {
+            return authored.ask({ kind: 'conversation.window', conversation, limit, before, phrase });
         },
-        messageCount(conversation) {
-            return authored.ask({ kind: 'conversation.count', conversation });
+        messageCount(conversation, phrase = null) {
+            return authored.ask({ kind: 'conversation.count', conversation, phrase });
         },
         turnArrived(conversation, turn) {
             return authored.ask({ kind: 'conversation.turn', conversation, turn });
         },
+        conversationRows(conversations) {
+            return authored.ask({ kind: 'conversation.rows', conversations });
+        },
+        jobMarkers(conversation) {
+            return authored.ask({ kind: 'conversation.jobs', conversation });
+        },
         async dropConversations(conversations) {
             await authored.ask({ kind: 'conversation.drop', conversations });
         },
@@ -330,6 +347,10 @@ export function openRuntimeStore(fenced, authored) {
             const records = await authored.ask({ kind: 'authored.chatDrafts' });
             return records.map((record) => JSON.parse(record));
         },
+        async chatDraft(conversation) {
+            const record = await authored.ask({ kind: 'authored.chatDraft.read', conversation });
+            return record === null ? null : JSON.parse(record);
+        },
         async keepChatDrafts(records) {
             await authored.ask({
                 kind: 'authored.chatDraft',
@@ -359,8 +380,6 @@ export function openRuntimeStore(fenced, authored) {
             await authored.ask({ kind: 'authored.call', operation, kept: null, files: [] });
         },
         async keepRoomDraft(record, files) {
-            if (fenced(record.locator))
-                return;
             const { path, ...kept } = roomDraftRow(record);
             await authored.ask({
                 kind: 'authored.roomDraft',
@@ -371,32 +390,11 @@ export function openRuntimeStore(fenced, authored) {
             });
         },
         async discardRoomDraft(locator, path) {
-            if (fenced(locator))
-                return;
             await authored.ask({ kind: 'authored.roomDraft', locator, path, kept: null, files: [] });
         },
         fences() {
             return authored.ask({ kind: 'authored.fences' });
         },
-        receivedHeads() {
-            return authored.ask({ kind: 'replica.received' });
-        },
-        receivedParts(key, count) {
-            return authored.ask({ kind: 'replica.receivedParts', key, count });
-        },
-        async keepReceived(key, head, part) {
-            await authored.ask({
-                kind: 'replica.receive',
-                key,
-                head: JSON.stringify(head),
-                ...(part === undefined
-                    ? {}
-                    : { part: { index: part.index, value: JSON.stringify(part.value) } }),
-            });
-        },
-        async dropReceived(keys) {
-            await authored.ask({ kind: 'replica.unreceive', keys });
-        },
         generation() {
             return fact('generation');
         },