@agentshouse/mdruntime 0.1.0-cd3ee807e46ae → 0.1.0-cd50a4607cb7d

package/dist/store.js

@@ -1,10 +1,14 @@
 import { sameBinary, sameChange } from './overlay.js';
+import { differing } from './shared.js';
 const DATABASE = 'mdruntime';
 const AUTHORED = 'mdruntime-authored';
+const FENCES = 'fences';
 const ROOMS = 'rooms';
 const DOCUMENTS = 'documents';
 const BINARY_FILES = 'binaryFiles';
 const TRANSFERS = 'transfers';
+const RECEIVED = 'received';
+const RECEIVED_PARTS = 'receivedParts';
 const PENDING_CHANGES = 'pendingChanges';
 const DECLARATIONS = 'declarations';
 const ROOM_DRAFTS = 'roomDrafts';
@@ -17,16 +21,37 @@ const FACTS = 'facts';
 const CURRENT = 'current';
 const MEMBER = 'member';
 const GENERATION = 'generation';
-export const STORE_SCHEMA = 23;
-export const AUTHORED_SCHEMA = 1;
+const HOLDER = 'holder';
+const BINDING = 'binding';
+export const STORE_SCHEMA = 25;
+const REPLICA_SHAPE = 23;
+export const AUTHORED_SCHEMA = 2;
 const AUTHORED_STORES = [
     [QUEUES, { keyPath: 'locator' }],
     [PENDING_CHANGES, { keyPath: ['locator', 'id'] }],
     [ROOM_DRAFTS, { keyPath: ['locator', 'path'] }],
     [CHAT_DRAFTS, { keyPath: 'conversation' }],
     [FACTS, undefined],
+    [FENCES, { keyPath: 'locator' }],
+];
+const REPLICA_STORES = [
+    [ROOMS, { keyPath: 'locator' }],
+    [DOCUMENTS, { keyPath: ['locator', 'transfer', 'path'] }],
+    [BINARY_FILES, { keyPath: ['locator', 'transfer', 'path'] }],
+    [TRANSFERS, { keyPath: 'locator' }],
+    [RECEIVED, { keyPath: 'key' }],
+    [RECEIVED_PARTS, { keyPath: ['key', 'index'] }],
+    [DECLARATIONS, undefined],
+    [PRESENTATION, { keyPath: 'app' }],
+    [CONVERSATIONS, { keyPath: 'conversation' }],
+    [MESSAGES, { keyPath: ['conversation', 'identity'] }],
 ];
 const READ_BATCH = 256;
+const MESSAGE_INDEXES = [
+    ['conversation', 'conversation'],
+    ['position', ['conversation', 'position']],
+    ['turn', ['conversation', 'turn']],
+];
 function settled(request) {
     return new Promise((resolve, reject) => {
         request.onsuccess = () => resolve(request.result);
@@ -69,6 +94,9 @@ function amendPending(database, locator, id, amendment) {
     };
     return completed(transaction);
 }
+function accepted({ conversation: _held, ...message }) {
+    return message;
+}
 function roomRecord(record) {
     const { documents, binaries, revisions, changes, written, ...room } = record;
     return room;
@@ -141,29 +169,29 @@ function binaryFileRecord(locator, transfer, layer, path) {
 }
 function writeLayer(transaction, locator, transfer, next, base) {
     const documents = transaction.objectStore(DOCUMENTS);
-    for (const path of Object.keys(base?.documents ?? {})) {
-        if (next.documents[path] === undefined)
-            documents.delete([locator, transfer, path]);
-    }
-    for (const [path, content] of Object.entries(next.documents)) {
-        if (base?.documents[path] === content &&
-            base.revisions[path] === next.revisions[path] &&
-            base.written[path] === next.written[path] &&
-            sameChange(base.changes[path], next.changes[path]))
-            continue;
-        documents.put(documentRecord(locator, transfer, next, path));
-    }
     const files = transaction.objectStore(BINARY_FILES);
-    for (const path of Object.keys(base?.binaries ?? {})) {
-        if (next.binaries[path] === undefined)
-            files.delete([locator, transfer, path]);
-    }
-    for (const path of Object.keys(next.binaries)) {
-        if (!sameBinary(base?.binaries[path], next.binaries[path]) ||
-            base?.revisions[path] !== next.revisions[path] ||
-            !sameChange(base?.changes[path], next.changes[path])) {
+    const paths = base === null
+        ? new Set([...Object.keys(next.documents), ...Object.keys(next.binaries)])
+        : new Set([
+            ...differing(base.documents, next.documents),
+            ...differing(base.revisions, next.revisions),
+            ...differing(base.written, next.written),
+            ...differing(base.changes, next.changes, sameChange),
+            ...differing(base.binaries, next.binaries, sameBinary),
+        ]);
+    for (const path of paths) {
+        if (next.documents[path] !== undefined) {
+            documents.put(documentRecord(locator, transfer, next, path));
+        }
+        else if (base?.documents[path] !== undefined) {
+            documents.delete([locator, transfer, path]);
+        }
+        if (next.binaries[path] !== undefined) {
             files.put(binaryFileRecord(locator, transfer, next, path));
         }
+        else if (base?.binaries[path] !== undefined) {
+            files.delete([locator, transfer, path]);
+        }
     }
 }
 function removeRoomEntries(store, locator) {
@@ -182,26 +210,86 @@ function removeDatabase(name) {
         removal.onerror = () => reject(removal.error);
     });
 }
-export async function removeRuntimeStore() {
-    await Promise.all([removeDatabase(DATABASE), removeDatabase(AUTHORED)]);
+export async function authoredHolder() {
+    const authored = await openAuthored();
+    try {
+        const transaction = authored.transaction(FACTS, 'readonly');
+        const held = transaction.objectStore(FACTS).get(HOLDER);
+        await completed(transaction);
+        return typeof held.result === 'string' ? held.result : null;
+    }
+    finally {
+        authored.close();
+    }
+}
+export async function authoredBy(holder) {
+    const authored = await openAuthored();
+    try {
+        const transaction = authored.transaction(FACTS, 'readwrite');
+        const facts = transaction.objectStore(FACTS);
+        const held = facts.get(HOLDER);
+        let owned = true;
+        held.onsuccess = () => {
+            if (held.result === undefined)
+                facts.put(holder, HOLDER);
+            else
+                owned = held.result === holder;
+        };
+        await completed(transaction);
+        return owned;
+    }
+    finally {
+        authored.close();
+    }
+}
+export async function authoredBinding() {
+    const authored = await openAuthored();
+    try {
+        const transaction = authored.transaction(FACTS, 'readonly');
+        const held = transaction.objectStore(FACTS).get(BINDING);
+        await completed(transaction);
+        return typeof held.result === 'string' ? held.result : null;
+    }
+    finally {
+        authored.close();
+    }
+}
+export async function bindAuthored(binding) {
+    const authored = await openAuthored();
+    try {
+        const transaction = authored.transaction(FACTS, 'readwrite');
+        transaction.objectStore(FACTS).put(binding, BINDING);
+        await completed(transaction);
+    }
+    finally {
+        authored.close();
+    }
+}
+export async function removeRuntimeStore(holder) {
+    await removeDatabase(DATABASE);
+    if (holder !== undefined && (await authoredBy(holder)))
+        return true;
+    await removeDatabase(AUTHORED);
+    return false;
 }
 function openReplica() {
     const opening = indexedDB.open(DATABASE, STORE_SCHEMA);
-    opening.onupgradeneeded = () => {
+    opening.onupgradeneeded = (event) => {
         const database = opening.result;
-        for (const name of [...database.objectStoreNames])
-            database.deleteObjectStore(name);
-        database.createObjectStore(ROOMS, { keyPath: 'locator' });
-        database.createObjectStore(DOCUMENTS, { keyPath: ['locator', 'transfer', 'path'] });
-        database.createObjectStore(BINARY_FILES, { keyPath: ['locator', 'transfer', 'path'] });
-        database.createObjectStore(TRANSFERS, { keyPath: 'locator' });
-        database.createObjectStore(DECLARATIONS);
-        database.createObjectStore(PRESENTATION, { keyPath: 'app' });
-        database.createObjectStore(CONVERSATIONS, { keyPath: 'conversation' });
-        const messages = database.createObjectStore(MESSAGES, {
-            keyPath: ['conversation', 'identity'],
-        });
-        messages.createIndex('conversation', 'conversation');
+        if (event.oldVersion < REPLICA_SHAPE) {
+            for (const name of [...database.objectStoreNames])
+                database.deleteObjectStore(name);
+        }
+        for (const [name, parameters] of REPLICA_STORES) {
+            if (database.objectStoreNames.contains(name))
+                continue;
+            database.createObjectStore(name, parameters);
+        }
+        const messages = opening.transaction.objectStore(MESSAGES);
+        for (const [name, keyPath] of MESSAGE_INDEXES) {
+            if (!messages.indexNames.contains(name))
+                messages.createIndex(name, keyPath);
+        }
     };
     return settled(opening);
 }
@@ -216,7 +304,7 @@ function openAuthored() {
     };
     return settled(opening);
 }
-export async function openRuntimeStore() {
+export async function openRuntimeStore(fenced) {
     const authored = await openAuthored();
     const database = await openReplica().catch((error) => {
         authored.close();
@@ -227,12 +315,14 @@ export async function openRuntimeStore() {
             const transaction = database.transaction([ROOMS, DOCUMENTS, BINARY_FILES], 'readonly');
             const rooms = await settled(transaction.objectStore(ROOMS).getAll());
             const records = [];
-            for (const room of rooms) {
+            for (const room of rooms.filter((held) => !fenced(held.locator))) {
                 records.push({ ...room, ...(await readLayer(transaction, room.locator, room.transfer)) });
             }
             return records;
         },
         async keepAuthored({ locator, queue, saved, roomDrafts, consumedRoomDrafts }) {
+            if (fenced(locator))
+                return;
             const transaction = authored.transaction([QUEUES, PENDING_CHANGES, ROOM_DRAFTS], 'readwrite');
             const order = transaction.objectStore(QUEUES);
             const pending = transaction.objectStore(PENDING_CHANGES);
@@ -269,7 +359,7 @@ export async function openRuntimeStore() {
             await completed(transaction);
         },
         async write({ next, previous, stored }) {
-            if (next === previous)
+            if (next === previous || fenced(next.locator))
                 return;
             const transaction = database.transaction([ROOMS, DOCUMENTS, BINARY_FILES, TRANSFERS], 'readwrite');
             transaction.objectStore(ROOMS).put(roomRecord(next));
@@ -289,6 +379,8 @@ export async function openRuntimeStore() {
             const rooms = transaction.objectStore(ROOMS);
             const revoked = { status: 'unavailable', reason: 'revoked' };
             for (const record of records) {
+                if (fenced(record.locator))
+                    continue;
                 rooms.put(roomRecord({ ...record, model: revoked, selectionModel: revoked }));
             }
             await completed(transaction);
@@ -329,7 +421,9 @@ export async function openRuntimeStore() {
                 settled(transaction.objectStore(PENDING_CHANGES).getAll()),
             ]);
             const byId = new Map(pending.map((record) => [`${record.locator}\0${record.id}`, record]));
-            return queues.map((queue) => ({
+            return queues
+                .filter((queue) => !fenced(queue.locator))
+                .map((queue) => ({
                 locator: queue.locator,
                 pending: queue.order.map((id) => {
                     const record = byId.get(`${queue.locator}\0${id}`);
@@ -340,18 +434,22 @@ export async function openRuntimeStore() {
                 }),
             }));
         },
-        submit(locator, id, submission, lost) {
-            return amendPending(authored, locator, id, { submission, lost });
+        async submit(locator, id, submission, lost) {
+            if (!fenced(locator))
+                await amendPending(authored, locator, id, { submission, lost });
         },
-        accept(locator, id, roomVersion) {
-            return amendPending(authored, locator, id, { accepted: roomVersion });
+        async accept(locator, id, roomVersion) {
+            if (!fenced(locator))
+                await amendPending(authored, locator, id, { accepted: roomVersion });
         },
-        keepUpload(locator, id, upload) {
-            return amendPending(authored, locator, id, { upload });
+        async keepUpload(locator, id, upload) {
+            if (!fenced(locator))
+                await amendPending(authored, locator, id, { upload });
         },
         async roomDrafts() {
             const transaction = authored.transaction(ROOM_DRAFTS, 'readonly');
-            return settled(transaction.objectStore(ROOM_DRAFTS).getAll());
+            const held = await settled(transaction.objectStore(ROOM_DRAFTS).getAll());
+            return held.filter((record) => !fenced(record.locator));
         },
         async presentation() {
             const transaction = database.transaction(PRESENTATION, 'readonly');
@@ -364,39 +462,91 @@ export async function openRuntimeStore() {
         },
         async conversations() {
             const transaction = database.transaction([CONVERSATIONS, MESSAGES], 'readonly');
-            const [reads, messages] = await Promise.all([
-                settled(transaction.objectStore(CONVERSATIONS).getAll()),
-                settled(transaction.objectStore(MESSAGES).getAll()),
-            ]);
-            const held = new Map();
-            for (const { conversation, read } of reads) {
-                held.set(conversation, { conversation, read, messages: [] });
-            }
-            for (const { conversation, ...message } of messages) {
-                const entry = held.get(conversation) ?? { conversation, read: undefined, messages: [] };
-                entry.messages.push(message);
-                held.set(conversation, entry);
-            }
+            const records = await settled(transaction.objectStore(CONVERSATIONS).getAll());
+            const held = new Map(records.map(({ conversation, read, partial }) => [
+                conversation,
+                { conversation, read, partial: partial === true },
+            ]));
+            const keys = transaction.objectStore(MESSAGES).index('conversation');
+            await new Promise((resolve, reject) => {
+                const cursor = keys.openKeyCursor(null, 'nextunique');
+                cursor.onerror = () => reject(cursor.error);
+                cursor.onsuccess = () => {
+                    const at = cursor.result;
+                    if (at === null) {
+                        resolve();
+                        return;
+                    }
+                    const conversation = at.key;
+                    if (!held.has(conversation)) {
+                        held.set(conversation, { conversation, read: undefined, partial: true });
+                    }
+                    at.continue();
+                };
+            });
             return [...held.values()];
         },
-        async keepMessages({ conversation, messages, read, sealed }) {
-            if (sealed === true) {
-                const sealing = authored.transaction(CHAT_DRAFTS, 'readwrite');
-                sealing.objectStore(CHAT_DRAFTS).delete(conversation);
-                await completed(sealing);
-            }
+        async keepMessages({ conversation, messages, read }) {
             const transaction = database.transaction([CONVERSATIONS, MESSAGES], 'readwrite');
             const stored = transaction.objectStore(MESSAGES);
             for (const message of messages) {
                 stored.put({ ...message, conversation });
             }
             if (read !== undefined) {
-                transaction
-                    .objectStore(CONVERSATIONS)
-                    .put({ conversation, read });
+                transaction.objectStore(CONVERSATIONS).put({
+                    conversation,
+                    read: read.at,
+                    ...(read.partial ? { partial: true } : {}),
+                });
             }
             await completed(transaction);
         },
+        async messageWindow(conversation, limit) {
+            const transaction = database.transaction(MESSAGES, 'readonly');
+            const index = transaction.objectStore(MESSAGES).index('position');
+            const range = IDBKeyRange.bound([conversation], [conversation, []]);
+            if (limit === undefined) {
+                return (await settled(index.getAll(range))).map(accepted);
+            }
+            const latest = [];
+            if (limit === 0)
+                return latest;
+            await new Promise((resolve, reject) => {
+                const cursor = index.openCursor(range, 'prev');
+                cursor.onerror = () => reject(cursor.error);
+                cursor.onsuccess = () => {
+                    const at = cursor.result;
+                    if (at === null) {
+                        resolve();
+                        return;
+                    }
+                    latest.push(accepted(at.value));
+                    if (latest.length === limit)
+                        resolve();
+                    else
+                        at.continue();
+                };
+            });
+            return latest.reverse();
+        },
+        async messagesAfter(conversation, identity) {
+            const transaction = database.transaction(MESSAGES, 'readonly');
+            const range = identity === null
+                ? IDBKeyRange.bound([conversation], [conversation, []])
+                : IDBKeyRange.bound([conversation, identity], [conversation, []], true);
+            const held = await settled(transaction.objectStore(MESSAGES).getAll(range, READ_BATCH));
+            return held.map(accepted);
+        },
+        async messageIdentities(conversation) {
+            const transaction = database.transaction(MESSAGES, 'readonly');
+            const keys = await settled(transaction.objectStore(MESSAGES).index('conversation').getAllKeys(conversation));
+            return keys.map((key) => key[1]);
+        },
+        async turnArrived(conversation, turn) {
+            const transaction = database.transaction(MESSAGES, 'readonly');
+            const held = await settled(transaction.objectStore(MESSAGES).index('turn').count([conversation, turn]));
+            return held > 0;
+        },
         async dropConversations(conversations) {
             const drafts = authored.transaction(CHAT_DRAFTS, 'readwrite');
             for (const conversation of conversations)
@@ -430,18 +580,28 @@ export async function openRuntimeStore() {
             await completed(transaction);
         },
         async keepRoomDraft(record) {
+            if (fenced(record.locator))
+                return;
             const transaction = authored.transaction(ROOM_DRAFTS, 'readwrite');
             transaction.objectStore(ROOM_DRAFTS).put(record);
             await completed(transaction);
         },
         async discardRoomDraft(locator, path) {
+            if (fenced(locator))
+                return;
             const transaction = authored.transaction(ROOM_DRAFTS, 'readwrite');
             transaction.objectStore(ROOM_DRAFTS).delete([locator, path]);
             await completed(transaction);
         },
-        async dropRooms(locators) {
-            const work = authored.transaction([QUEUES, PENDING_CHANGES, ROOM_DRAFTS], 'readwrite');
+        async fences() {
+            const transaction = authored.transaction(FENCES, 'readonly');
+            const held = await settled(transaction.objectStore(FENCES).getAll());
+            return held.map((fence) => fence.locator);
+        },
+        async erase(locators) {
+            const work = authored.transaction([FENCES, QUEUES, PENDING_CHANGES, ROOM_DRAFTS], 'readwrite');
             for (const locator of locators) {
+                work.objectStore(FENCES).put({ locator });
                 work.objectStore(QUEUES).delete(locator);
                 for (const name of [PENDING_CHANGES, ROOM_DRAFTS]) {
                     removeRoomEntries(work.objectStore(name), locator);
@@ -456,22 +616,37 @@ export async function openRuntimeStore() {
                 transaction.objectStore(BINARY_FILES).delete(underRoom(locator));
             }
             await completed(transaction);
+            const fences = authored.transaction(FENCES, 'readwrite');
+            for (const locator of locators)
+                fences.objectStore(FENCES).delete(locator);
+            await completed(fences);
+        },
+        async discard(locator) {
+            const transaction = authored.transaction([QUEUES, PENDING_CHANGES], 'readwrite');
+            transaction.objectStore(QUEUES).delete(locator);
+            removeRoomEntries(transaction.objectStore(PENDING_CHANGES), locator);
+            await completed(transaction);
         },
         async transfers() {
             const transaction = database.transaction(TRANSFERS, 'readonly');
-            return settled(transaction.objectStore(TRANSFERS).getAll());
+            const held = await settled(transaction.objectStore(TRANSFERS).getAll());
+            return held.filter((record) => !fenced(record.locator));
         },
         staged(record) {
             const transaction = database.transaction([DOCUMENTS, BINARY_FILES], 'readonly');
             return readLayer(transaction, record.locator, record.transfer);
         },
         async stage(record, page) {
+            if (fenced(record.locator))
+                return;
             const transaction = database.transaction([TRANSFERS, DOCUMENTS, BINARY_FILES], 'readwrite');
             writeLayer(transaction, record.locator, record.transfer, page, null);
             transaction.objectStore(TRANSFERS).put(record);
             await completed(transaction);
         },
         async abandon(locator) {
+            if (fenced(locator))
+                return;
             const transaction = database.transaction([TRANSFERS, DOCUMENTS, BINARY_FILES], 'readwrite');
             const transfers = transaction.objectStore(TRANSFERS);
             const held = transfers.get(locator);
@@ -486,6 +661,32 @@ export async function openRuntimeStore() {
             };
             await completed(transaction);
         },
+        async receivedHeads() {
+            const transaction = database.transaction(RECEIVED, 'readonly');
+            return settled(transaction.objectStore(RECEIVED).getAll());
+        },
+        async receivedParts(key, count) {
+            const transaction = database.transaction(RECEIVED_PARTS, 'readonly');
+            const kept = await settled(transaction
+                .objectStore(RECEIVED_PARTS)
+                .getAll(IDBKeyRange.bound([key, 0], [key, count], false, true)));
+            return kept.map((part) => part.value);
+        },
+        async keepReceived(key, head, part) {
+            const transaction = database.transaction([RECEIVED, RECEIVED_PARTS], 'readwrite');
+            transaction.objectStore(RECEIVED).put({ key, head });
+            if (part !== undefined)
+                transaction.objectStore(RECEIVED_PARTS).put({ key, ...part });
+            await completed(transaction);
+        },
+        async dropReceived(keys) {
+            const transaction = database.transaction([RECEIVED, RECEIVED_PARTS], 'readwrite');
+            for (const key of keys) {
+                transaction.objectStore(RECEIVED).delete(key);
+                transaction.objectStore(RECEIVED_PARTS).delete(IDBKeyRange.bound([key], [key, []]));
+            }
+            await completed(transaction);
+        },
         async generation() {
             const transaction = authored.transaction(FACTS, 'readonly');
             const held = await settled(transaction.objectStore(FACTS).get(GENERATION));

package/dist/turn.d.ts

@@ -0,0 +1,7 @@
+export declare function yielded(): Promise<void>;
+export declare const ROW_WEIGHT = 256;
+export type Later<T> = T | Promise<T>;
+export declare function after<T, R>(value: Later<T>, next: (value: T) => R): Later<R>;
+export declare function inUnits<T>(items: Iterable<T>, each: (item: T) => number): Later<void>;
+export declare function inChunks<T>(items: readonly T[], weigh: (item: T) => number, each: (chunk: readonly T[]) => void): Promise<void>;
+//# sourceMappingURL=turn.d.ts.map

package/dist/turn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"turn.d.ts","sourceRoot":"","sources":["../src/turn.ts"],"names":[],"mappings":"AAAA,wBAAgB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CASvC;AAID,eAAO,MAAM,UAAU,MAAM,CAAC;AAE9B,MAAM,MAAM,KAAK,CAAC,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;AAEtC,wBAAgB,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAE5E;AAaD,wBAAgB,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GAAG,KAAK,CAAC,IAAI,CAAC,CAOrF;AAED,wBAAsB,QAAQ,CAAC,CAAC,EAC9B,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,EAC1B,IAAI,EAAE,CAAC,KAAK,EAAE,SAAS,CAAC,EAAE,KAAK,IAAI,GAClC,OAAO,CAAC,IAAI,CAAC,CAUf"}

package/dist/turn.js

@@ -0,0 +1,45 @@
+export function yielded() {
+    return new Promise((resolve) => {
+        const channel = new MessageChannel();
+        channel.port1.onmessage = () => {
+            channel.port1.close();
+            resolve();
+        };
+        channel.port2.postMessage(null);
+    });
+}
+const UNIT = 1 << 20;
+export const ROW_WEIGHT = 256;
+export function after(value, next) {
+    return value instanceof Promise ? value.then(next) : next(value);
+}
+async function resumed(iterator, each) {
+    let spent = UNIT;
+    for (let next = iterator.next(); next.done !== true; next = iterator.next()) {
+        if (spent >= UNIT) {
+            await yielded();
+            spent = 0;
+        }
+        spent += each(next.value);
+    }
+}
+export function inUnits(items, each) {
+    const iterator = items[Symbol.iterator]();
+    let spent = 0;
+    for (let next = iterator.next(); next.done !== true; next = iterator.next()) {
+        spent += each(next.value);
+        if (spent >= UNIT)
+            return resumed(iterator, each);
+    }
+}
+export async function inChunks(items, weigh, each) {
+    for (let at = 0; at < items.length;) {
+        await yielded();
+        const chunk = [];
+        for (let spent = 0; at < items.length && spent < UNIT; at += 1) {
+            chunk.push(items[at]);
+            spent += weigh(items[at]);
+        }
+        each(chunk);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentshouse/mdruntime",
-  "version": "0.1.0-cd3ee807e46ae",
+  "version": "0.1.0-cd50a4607cb7d",
   "description": "The headless core of MD App",
   "license": "MIT",
   "type": "module",
@@ -24,6 +24,10 @@
       "types": "./dist/client.d.ts",
       "default": "./dist/client.js"
     },
+    "./entry": {
+      "types": "./dist/entry.d.ts",
+      "default": "./dist/entry.js"
+    },
     "./memory": {
       "types": "./dist/memory.d.ts",
       "default": "./dist/memory.js"
@@ -45,7 +49,7 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@agentshouse/mdmodel": "0.1.0-c2224db91aaa3",
+    "@agentshouse/mdmodel": "0.1.0-cad192ab63d5f",
     "@assistant-ui/react-markdown": "0.14.20",
     "@tanstack/db": "0.9.2",
     "lucide-react": "1.47.0",