@agentshouse/mdruntime 0.1.0-cd50a4607cb7d → 0.1.0-cd574a610e9c8

package/dist/tables.js

@@ -0,0 +1,499 @@
+import { sql } from '@agentshouse/mdmodel';
+import { answerQuery } from './compile.js';
+import { amended, authoredLocators, authoredPart, call, callRecords, chatDraft, chatDraftConversations, chatDraftRecord, chatDraftRecords, chatDraftsDropped, claim, fact, fenced, fencedWork, fences, FILE_PART_BYTES, authoredEmptied, heldOrder, kept, moving, pendingBatch, pendingState, queuedLocators, queueOf, queues, remember, roomDraft, roomDraftRecords, spooled, unfenced, unsent, unsentStatus, } from './authored.js';
+import { count, text, texts } from './column.js';
+import { conversationFacts, conversationRows, forgottenConversations, heldConversations, keptFact, keptMessages, messageCount, messageWindow, MESSAGE_TABLES, turnArrived, } from './messages.js';
+import { keptRead, READ_TABLES, readsOfOtherBuildsForgotten, storedRead, } from './reads.js';
+import { conversationTallies, roomTallies, } from './tallies.js';
+import { abandon, release, commit, covering, demoted, ended, entries, erase, facts, fenceRooms, folders, heldLocators, heldRoom, heldRooms, offlineMode, opened, overlaid, presentation, rederive, referrers, refreshing, REPLICA_TABLES, resume, stage, typed, stagedLocators, tablesOf, typedWithin, unrefresh, } from './stored.js';
+export { authoredEmptied, authoredTable, FILE_PART_BYTES, formatted, heldTables, } from './authored.js';
+const STATEMENTS_HELD = 256;
+export function sqliteConnection(engine, database) {
+    const decoder = new TextDecoder();
+    const held = new Map();
+    database.createFunction(sql.HOLDS_PHRASE, sql.holdsPhrase, {
+        arity: 2,
+        deterministic: true,
+    });
+    function prepared(sql) {
+        if (sql.includes(';'))
+            return null;
+        const found = held.get(sql);
+        held.delete(sql);
+        const statement = found ?? database.prepare(sql);
+        held.set(sql, statement);
+        if (held.size > STATEMENTS_HELD) {
+            const [oldest, evicted] = held.entries().next().value;
+            held.delete(oldest);
+            evicted.finalize();
+        }
+        return statement;
+    }
+    function stepped(statement, bind, each) {
+        try {
+            if (bind.length > 0 && statement.parameterCount > 0)
+                statement.bind(bind);
+            while (statement.step())
+                each();
+        }
+        finally {
+            statement.resetNoThrow(true);
+        }
+    }
+    return {
+        run(sql, bind = []) {
+            const statement = prepared(sql);
+            if (statement === null)
+                database.exec({ sql, bind });
+            else
+                stepped(statement, bind, () => { });
+        },
+        rows(sql, bind = []) {
+            const statement = prepared(sql);
+            if (statement === null) {
+                return database.exec({ sql, bind, rowMode: 'object', returnValue: 'resultRows' });
+            }
+            const names = statement.getColumnNames([]);
+            const rows = [];
+            stepped(statement, bind, () => {
+                const values = statement.get([]);
+                const row = Object.create(null);
+                for (const [index, name] of names.entries())
+                    row[name] = values[index] ?? null;
+                rows.push(row);
+            });
+            return rows;
+        },
+        collate(name, compare) {
+            const answered = engine.capi.sqlite3_create_collation_v2(database.pointer, name, engine.capi.SQLITE_UTF8, 0, (_argument, leftLength, left, rightLength, right) => {
+                const heap = engine.wasm.heap8u();
+                return Math.sign(compare(decoder.decode(heap.subarray(left, left + leftLength)), decoder.decode(heap.subarray(right, right + rightLength))));
+            }, 0);
+            if (answered !== 0)
+                throw new Error(`the database refused the collation ${name}`);
+        },
+    };
+}
+const PROBE_BYTES = 4 * FILE_PART_BYTES;
+export const RUNTIME_TABLES = [
+    'CREATE TABLE opened_files (key TEXT PRIMARY KEY, locator TEXT NOT NULL, path TEXT NOT NULL, revision TEXT NOT NULL, media_type TEXT NOT NULL, sha256 TEXT, byte_length INTEGER) WITHOUT ROWID',
+    'CREATE INDEX opened_files_name ON opened_files (locator, path, revision)',
+    'CREATE TABLE opened_parts (key TEXT NOT NULL, part INTEGER NOT NULL, bytes BLOB NOT NULL, PRIMARY KEY (key, part))',
+    ...REPLICA_TABLES,
+    ...MESSAGE_TABLES,
+    ...READ_TABLES,
+];
+const UNOPENED_PARTS = 'DELETE FROM opened_parts WHERE key NOT IN (SELECT key FROM opened_files)';
+const READS = new Set([
+    'authored.status',
+    'authored.moving',
+    'authored.pending',
+    'authored.batch',
+    'authored.order',
+    'authored.queued',
+    'authored.roomDrafts',
+    'authored.chatDraft.read',
+    'authored.chatDrafts',
+    'authored.calls',
+    'authored.fences',
+    'authored.unsent',
+    'authored.fact',
+    'authored.file',
+    'replica.open',
+    'replica.rooms',
+    'replica.room',
+    'replica.covering',
+    'replica.offline',
+    'replica.held',
+    'replica.facts',
+    'replica.presentation',
+    'replica.query',
+    'replica.tallies',
+    'replica.entries',
+    'replica.typed',
+    'replica.referrers',
+    'replica.folders',
+    'replica.typedWithin',
+    'opened.find',
+    'opened.held',
+    'file.part',
+    'conversation.held',
+    'conversation.window',
+    'conversation.count',
+    'conversation.turn',
+    'conversation.rows',
+    'conversation.tallies',
+    'conversation.facts',
+    'conversation.stored',
+    'read.stored',
+]);
+const KINDS = new Set([
+    ...READS,
+    'authored.amend',
+    'authored.roomDraft',
+    'authored.chatDraft',
+    'authored.call',
+    'authored.remember',
+    'authored.claim',
+    'authored.end',
+    'replica.stage',
+    'replica.resume',
+    'replica.refresh',
+    'replica.unrefresh',
+    'replica.commit',
+    'replica.fence',
+    'replica.erase',
+    'replica.abandon',
+    'replica.unfence',
+    'replica.release',
+    'replica.rederive',
+    'replica.demote',
+    'replica.fact',
+    'replica.present',
+    'opened.begin',
+    'opened.part',
+    'opened.keep',
+    'opened.drop',
+    'opened.clean',
+    'conversation.keep',
+    'conversation.fact',
+    'conversation.drop',
+    'space.probe',
+    'read.keep',
+    'read.builds',
+]);
+export function isRuntime(request) {
+    return KINDS.has(request.kind);
+}
+export function readsRuntime(request) {
+    return READS.has(request.kind);
+}
+function heldWork(connection, locator) {
+    const room = heldRoom(connection, locator);
+    return {
+        room: room === null ? null : { ...room, overlaid: overlaid(connection, room.key) },
+        queue: queueOf(connection, locator),
+    };
+}
+function status(connection) {
+    return {
+        ...unsentStatus(connection),
+        lastCompleted: facts(connection, ['lastCompleted']).lastCompleted ?? null,
+    };
+}
+function pendingOf(connection, locator, id) {
+    return {
+        state: pendingState(connection, locator, id),
+        room: connection.rows('SELECT 1 FROM replica_rooms WHERE locator = ?', [locator]).length > 0,
+    };
+}
+function storedConversations(connection, conversations) {
+    const named = conversations === null ? '' : ' WHERE conversation IN (SELECT value FROM json_each(?))';
+    const bound = conversations === null ? [] : [JSON.stringify(conversations)];
+    return [
+        ...new Set([
+            ...tablesOf(MESSAGE_TABLES).flatMap((table) => texts(connection.rows(`SELECT DISTINCT conversation FROM ${table}${named}`, bound), 'conversation')),
+            ...chatDraftConversations(connection, conversations),
+        ]),
+    ];
+}
+function droppedConversations(connection, conversations) {
+    const held = storedConversations(connection, conversations);
+    for (const table of tablesOf(MESSAGE_TABLES)) {
+        connection.run(`DELETE FROM ${table} WHERE conversation IN (SELECT value FROM json_each(?))`, [
+            JSON.stringify(conversations),
+        ]);
+    }
+    chatDraftsDropped(connection, conversations);
+    return held;
+}
+function unopened(connection) {
+    connection.run(UNOPENED_PARTS);
+}
+function fence(connection, locators) {
+    fencedWork(connection, locators);
+    for (const locator of locators) {
+        connection.run('DELETE FROM opened_files WHERE locator = ?', [locator]);
+    }
+    unopened(connection);
+    return fenceRooms(connection, locators);
+}
+function erased(connection, { locator, limit }) {
+    return erase(connection, locator, limit);
+}
+function unfencedRooms(connection, locators) {
+    const erased = locators.filter((locator) => connection.rows('SELECT 1 FROM replica_erasing WHERE locator = ? LIMIT 1', [locator])
+        .length === 0);
+    unfenced(connection, erased);
+    return erased;
+}
+function end(connection, holder) {
+    ended(connection);
+    forgottenConversations(connection);
+    if (holder !== null && claim(connection, holder))
+        return true;
+    authoredEmptied(connection);
+    connection.run('DELETE FROM opened_files');
+    connection.run('DELETE FROM opened_parts');
+    return false;
+}
+function openedFile(connection, { locator, path, revision }) {
+    const [held] = connection.rows('SELECT key, media_type, byte_length FROM opened_files WHERE locator = ? AND path = ? AND revision = ? AND byte_length IS NOT NULL', [locator, path, revision]);
+    return held === undefined
+        ? null
+        : {
+            key: text(held.key),
+            byteLength: count(held.byte_length),
+            mediaType: text(held.media_type),
+        };
+}
+function opening(connection, { key, locator, path, revision, mediaType }) {
+    if (fenced(connection, locator))
+        return false;
+    connection.run('DELETE FROM opened_files WHERE locator = ? AND path = ? AND revision = ? AND byte_length IS NULL', [locator, path, revision]);
+    unopened(connection);
+    connection.run('INSERT INTO opened_files (key, locator, path, revision, media_type) VALUES (?, ?, ?, ?, ?)', [key, locator, path, revision, mediaType]);
+    return true;
+}
+function fetching(connection, key) {
+    const [held] = connection.rows('SELECT locator, path, revision FROM opened_files WHERE key = ? AND byte_length IS NULL', [key]);
+    return held === undefined
+        ? null
+        : { locator: text(held.locator), path: text(held.path), revision: text(held.revision) };
+}
+function openedPart(connection, { key, part, bytes }) {
+    if (fetching(connection, key) === null)
+        return false;
+    connection.run('INSERT INTO opened_parts (key, part, bytes) VALUES (?, ?, ?)', [
+        key,
+        part,
+        bytes,
+    ]);
+    return true;
+}
+function dropped(connection, key) {
+    connection.run('DELETE FROM opened_files WHERE key = ?', [key]);
+    connection.run('DELETE FROM opened_parts WHERE key = ?', [key]);
+    return null;
+}
+function keptOpened(connection, { key, sha256, byteLength, parts }) {
+    const fetched = fetching(connection, key);
+    if (fetched === null)
+        return false;
+    const [held] = connection.rows('SELECT count(*) AS parts, min(part) AS first, max(part) AS last, coalesce(sum(length(bytes)), 0) AS bytes FROM opened_parts WHERE key = ?', [key]);
+    const whole = count(held.parts) === parts &&
+        count(held.bytes) === byteLength &&
+        (parts === 0 || (count(held.first) === 0 && count(held.last) === parts - 1));
+    if (!whole) {
+        dropped(connection, key);
+        return false;
+    }
+    connection.run('UPDATE opened_files SET sha256 = ?, byte_length = ? WHERE key = ?', [
+        sha256,
+        byteLength,
+        key,
+    ]);
+    connection.run('DELETE FROM opened_files WHERE locator = ? AND path = ? AND revision = ? AND key <> ?', [fetched.locator, fetched.path, fetched.revision, key]);
+    unopened(connection);
+    return true;
+}
+function heldPart(connection, key, part) {
+    const [held] = connection.rows('SELECT bytes FROM opened_parts WHERE key = ? AND part = ?', [
+        key,
+        part,
+    ]);
+    return held?.bytes instanceof Uint8Array ? held.bytes : authoredPart(connection, key, part);
+}
+function cleanable(connection) {
+    const [held] = connection.rows('SELECT coalesce(sum(length(bytes)), 0) AS bytes FROM opened_parts');
+    return count(held.bytes);
+}
+function cleaned(connection) {
+    connection.run('DELETE FROM opened_files');
+    const freed = cleanable(connection);
+    unopened(connection);
+    return freed;
+}
+function openedHeld(connection) {
+    return {
+        rooms: connection
+            .rows('SELECT locator, count(*) AS files, sum(byte_length) AS bytes FROM opened_files WHERE byte_length IS NOT NULL GROUP BY locator ORDER BY locator')
+            .map((row) => ({ room: text(row.locator), count: count(row.files), size: count(row.bytes) })),
+        cleanable: cleanable(connection),
+    };
+}
+async function committed(connection, { authored, rooms }) {
+    const refused = authored === undefined ? null : await kept(connection, authored);
+    if (refused !== null && authored?.whole === true) {
+        return { fenced: refused, changed: {}, indexed: {} };
+    }
+    return {
+        fenced: refused,
+        ...commit(connection, rooms.filter(({ locator }) => !fenced(connection, locator))),
+    };
+}
+export function answerRuntime(connection, request, spool) {
+    switch (request.kind) {
+        case 'authored.status':
+            return status(connection);
+        case 'authored.moving':
+            return moving(connection);
+        case 'authored.pending':
+            return pendingOf(connection, request.locator, request.id);
+        case 'authored.batch':
+            return pendingBatch(connection, request.locator, request.id);
+        case 'authored.order':
+            return heldOrder(connection, request.locator);
+        case 'authored.queued':
+            return queuedLocators(connection);
+        case 'authored.roomDrafts':
+            return roomDraftRecords(connection, request.locator, request.paths);
+        case 'authored.chatDraft.read':
+            return chatDraftRecord(connection, request.conversation);
+        case 'authored.chatDrafts':
+            return chatDraftRecords(connection);
+        case 'authored.calls':
+            return callRecords(connection);
+        case 'authored.fences':
+            return fences(connection);
+        case 'authored.unsent':
+            return unsent(connection);
+        case 'authored.fact':
+            return fact(connection, request.name);
+        case 'authored.file':
+            return spooled(connection, spool, request.key, request.type);
+        case 'authored.amend':
+            return amended(connection, request.locator, request.id, request.amendment);
+        case 'authored.roomDraft':
+            return roomDraft(connection, request.locator, request.path, request.kept, request.files);
+        case 'authored.chatDraft':
+            return chatDraft(connection, request.kept, request.dropped);
+        case 'authored.call':
+            return call(connection, request.operation, request.kept, request.files);
+        case 'authored.remember':
+            return remember(connection, request.name, request.value);
+        case 'authored.claim':
+            return claim(connection, request.holder);
+        case 'authored.end':
+            return end(connection, request.holder);
+        case 'replica.open':
+            return opened(connection);
+        case 'replica.rooms':
+            return heldRooms(connection, request.locators);
+        case 'replica.room':
+            return heldWork(connection, request.locator);
+        case 'replica.covering':
+            return { ...covering(connection, request.since), queues: queues(connection) };
+        case 'replica.offline':
+            return offlineMode(connection, request.locator);
+        case 'replica.held':
+            return {
+                held: [...new Set([...heldLocators(connection), ...authoredLocators(connection)])],
+                staged: stagedLocators(connection),
+            };
+        case 'replica.demote':
+            return demoted(connection);
+        case 'replica.facts':
+            return facts(connection, request.names);
+        case 'replica.presentation':
+            return presentation(connection, request.app);
+        case 'replica.query':
+            return answerQuery(connection, request.plan, request.rooms, request.budget);
+        case 'replica.tallies':
+            return roomTallies(connection, request.totals, request.rooms, request.since);
+        case 'replica.entries':
+            return entries(connection, request.key, request.view, request.paths);
+        case 'replica.typed':
+            return typed(connection, request.key, request.view, request.paths);
+        case 'replica.referrers':
+            return referrers(connection, request.key, request.view, request.targets);
+        case 'replica.folders':
+            return folders(connection, request.key, request.paths);
+        case 'replica.typedWithin':
+            return typedWithin(connection, request.key, request.view, request.roots, request.within);
+        case 'replica.stage':
+            return fenced(connection, request.locator) ? null : stage(connection, request);
+        case 'replica.resume':
+            return fenced(connection, request.locator) ? null : resume(connection, request);
+        case 'replica.refresh':
+            return refreshing(connection, request);
+        case 'replica.unrefresh':
+            return unrefresh(connection, request.key);
+        case 'replica.commit':
+            return committed(connection, request);
+        case 'replica.fence':
+            return fence(connection, request.locators);
+        case 'replica.erase':
+            return erased(connection, request);
+        case 'replica.abandon':
+            return abandon(connection, request.locator);
+        case 'replica.unfence':
+            return unfencedRooms(connection, request.locators);
+        case 'replica.release':
+            return release(connection, request.key);
+        case 'replica.rederive':
+            return rederive(connection, request.key, request.composed, request.bytes, request.ms, request.floor);
+        case 'replica.fact':
+            connection.run('INSERT OR REPLACE INTO replica_facts (name, value) VALUES (?, ?)', [
+                request.name,
+                request.value,
+            ]);
+            return null;
+        case 'replica.present':
+            connection.run('INSERT OR REPLACE INTO replica_presentation (app, value) VALUES (?, ?)', [
+                request.app,
+                request.value,
+            ]);
+            return null;
+        case 'opened.find':
+            return openedFile(connection, request);
+        case 'opened.begin':
+            return opening(connection, request);
+        case 'opened.part':
+            return openedPart(connection, request);
+        case 'opened.keep':
+            return keptOpened(connection, request);
+        case 'opened.drop':
+            return dropped(connection, request.key);
+        case 'opened.clean':
+            return cleaned(connection);
+        case 'opened.held':
+            return openedHeld(connection);
+        case 'file.part':
+            return heldPart(connection, request.key, request.part);
+        case 'conversation.held':
+            return heldConversations(connection, request.conversations);
+        case 'conversation.keep': {
+            const { kind: _kind, ...write } = request;
+            return keptMessages(connection, write);
+        }
+        case 'conversation.window':
+            return messageWindow(connection, request.conversation, request.limit, request.before, request.phrase);
+        case 'conversation.count':
+            return messageCount(connection, request.conversation, request.phrase);
+        case 'conversation.turn':
+            return turnArrived(connection, request.conversation, request.turn);
+        case 'conversation.rows':
+            return conversationRows(connection, request.conversations);
+        case 'conversation.tallies':
+            return conversationTallies(connection, request.conversations, request.since);
+        case 'conversation.facts':
+            return conversationFacts(connection);
+        case 'conversation.fact': {
+            const { kind: _kind, ...fact } = request;
+            return keptFact(connection, fact);
+        }
+        case 'conversation.stored':
+            return storedConversations(connection, null);
+        case 'conversation.drop':
+            return droppedConversations(connection, request.conversations);
+        case 'space.probe':
+            return spool.probe(PROBE_BYTES).then(() => null);
+        case 'read.stored':
+            return storedRead(connection, request);
+        case 'read.keep':
+            return keptRead(connection, request, request.answer);
+        case 'read.builds':
+            return readsOfOtherBuildsForgotten(connection, request.build);
+    }
+}

package/dist/tallies.d.ts

@@ -0,0 +1,18 @@
+import { type QueryRoom } from './compile.js';
+import type { GroupTotal, Plan } from './query.js';
+import type { Connection } from './tables.js';
+export type RoomTally = {
+    readonly key: number;
+    readonly documents: GroupTotal;
+    readonly files: GroupTotal;
+    readonly documentTimes: readonly (readonly [string | null, string | null])[];
+    readonly chatTimes: readonly string[];
+    readonly messageTimes: readonly string[];
+};
+export type ConversationTally = {
+    readonly conversation: string;
+    readonly said: readonly string[];
+};
+export declare function roomTallies(connection: Connection, totals: Plan, rooms: readonly QueryRoom[], since: string): RoomTally[];
+export declare function conversationTallies(connection: Connection, conversations: readonly string[] | null, since: string): ConversationTally[];
+//# sourceMappingURL=tallies.d.ts.map

package/dist/tallies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tallies.d.ts","sourceRoot":"","sources":["../src/tallies.ts"],"names":[],"mappings":"AACA,OAAO,EAAgC,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAE5E,OAAO,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AACnD,OAAO,KAAK,EAAE,UAAU,EAAc,MAAM,aAAa,CAAC;AAI1D,MAAM,MAAM,SAAS,GAAG;IACtB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,SAAS,EAAE,UAAU,CAAC;IAC/B,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAC3B,QAAQ,CAAC,aAAa,EAAE,SAAS,CAAC,SAAS,CAAC,MAAM,GAAG,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC;IAC7E,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1C,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAAE,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,CAAC;AAmHpG,wBAAgB,WAAW,CACzB,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE,IAAI,EACZ,KAAK,EAAE,SAAS,SAAS,EAAE,EAC3B,KAAK,EAAE,MAAM,GACZ,SAAS,EAAE,CAwBb;AA0BD,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,UAAU,EACtB,aAAa,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,EACvC,KAAK,EAAE,MAAM,GACZ,iBAAiB,EAAE,CAerB"}

package/dist/tallies.js

@@ -0,0 +1,128 @@
+import { CHAT_MESSAGE_TYPE, CHAT_TYPE, instantKey, sql } from '@agentshouse/mdmodel';
+import { answerQuery, VISIBLE, within } from './compile.js';
+import { HOUSE_DIRECTORY } from './figures.js';
+const NONE = { count: 0, size: 0 };
+const { all, fragment, joined } = sql;
+function instant(value) {
+    return typeof value === 'string' ? value : null;
+}
+function held(alias, keys) {
+    const reserved = within(alias, HOUSE_DIRECTORY);
+    return all([
+        fragment(`${alias}.key IN (SELECT value FROM json_each(?))`, [JSON.stringify(keys)]),
+        fragment(VISIBLE(alias)),
+        fragment(`NOT ${reserved.sql}`, reserved.bind),
+    ]);
+}
+function valued(alias, document, field) {
+    return joined([
+        fragment(`${alias}.doc = ${document}.id AND `),
+        sql.grouped(sql.placed(alias, field, 'exact')),
+        fragment(` AND ${alias}.item = -1`),
+    ], '');
+}
+function inboxed(card) {
+    return joined([
+        fragment('EXISTS (SELECT 1 FROM replica_values i WHERE '),
+        valued('i', card, '/inbox'),
+        fragment(" AND i.kind = 'string')"),
+    ], '');
+}
+function rowsOf(connection, query) {
+    return connection.rows(query.sql, query.bind);
+}
+function documentTimes(connection, keys, since) {
+    return rowsOf(connection, joined([
+        fragment('SELECT d.key AS key, d.created_instant AS created, d.changed_instant AS changed FROM replica_entries d WHERE '),
+        held('d', keys),
+        fragment(" AND d.binary IS NULL AND COALESCE(d.type, '') NOT IN (?, ?) AND (d.created_instant >= ? OR d.changed_instant >= ?)", [CHAT_TYPE, CHAT_MESSAGE_TYPE, since, since]),
+    ], ''));
+}
+function chatTimes(connection, keys, since) {
+    return rowsOf(connection, joined([
+        fragment('SELECT d.key AS key, d.created_instant AS at FROM replica_entries d WHERE '),
+        held('d', keys),
+        fragment(' AND d.type = ? AND d.created_instant >= ? AND ', [CHAT_TYPE, since]),
+        inboxed('d'),
+    ], ''));
+}
+function messageTimes(connection, keys, since) {
+    return rowsOf(connection, joined([
+        fragment('SELECT m.key AS key, s.instant AS at FROM replica_entries m JOIN replica_values s ON '),
+        valued('s', 'm', '/sent_at'),
+        fragment(' AND s.instant >= ? JOIN replica_values r ON ', [since]),
+        valued('r', 'm', '/direction'),
+        fragment(" AND r.kind = 'string' AND r.value = 'in' WHERE "),
+        held('m', keys),
+        fragment(` AND m.type = ? AND EXISTS (SELECT 1 FROM replica_entries c WHERE c.key = m.key AND c.type = ? AND ${VISIBLE('c')} AND c.folder = m.folder AND `, [CHAT_MESSAGE_TYPE, CHAT_TYPE]),
+        inboxed('c'),
+        fragment(')'),
+    ], ''));
+}
+function byKey(rows, read) {
+    const kept = new Map();
+    for (const row of rows) {
+        const key = Number(row.key);
+        const list = kept.get(key) ?? [];
+        list.push(read(row));
+        kept.set(key, list);
+    }
+    return kept;
+}
+export function roomTallies(connection, totals, rooms, since) {
+    const keys = rooms.map(({ key }) => key);
+    const from = instantKey(since);
+    const answered = answerQuery(connection, totals, rooms);
+    const summed = new Map(('groups' in answered ? answered.groups : []).map((group) => [String(group.key[0]), group]));
+    const documents = byKey(documentTimes(connection, keys, from), (row) => [instant(row.created), instant(row.changed)]);
+    const chats = byKey(chatTimes(connection, keys, from), (row) => instant(row.at));
+    const messages = byKey(messageTimes(connection, keys, from), (row) => instant(row.at));
+    return rooms.map(({ locator, key }) => {
+        const total = summed.get(locator);
+        return {
+            key,
+            documents: total?.documents ?? NONE,
+            files: total?.files ?? NONE,
+            documentTimes: documents.get(key) ?? [],
+            chatTimes: chats.get(key) ?? [],
+            messageTimes: messages.get(key) ?? [],
+        };
+    });
+}
+const ACCEPTED = "message ->> '$.accepted_at'";
+const NEWER = 'ORDER BY n.position DESC, n.identity DESC LIMIT 1';
+const SAID = `WITH RECURSIVE
+  named(conversation) AS (SELECT value FROM json_each(?)),
+  walk(conversation, position, identity, at, role) AS (
+    SELECT m.conversation, m.position, m.identity, m.${ACCEPTED}, m.message ->> '$.role'
+    FROM named JOIN conversation_messages m ON m.id = (
+      SELECT n.id FROM conversation_messages n WHERE n.conversation = named.conversation ${NEWER}
+    )
+    UNION ALL
+    SELECT m.conversation, m.position, m.identity, m.${ACCEPTED}, m.message ->> '$.role'
+    FROM walk JOIN conversation_messages m ON m.id = (
+      SELECT n.id FROM conversation_messages n WHERE n.conversation = walk.conversation
+        AND (n.position < walk.position OR (n.position = walk.position AND n.identity < walk.identity))
+      ${NEWER}
+    )
+    WHERE julianday(walk.at) >= julianday(?)
+  )
+  SELECT walk.conversation AS conversation, walk.at AS at
+  FROM walk
+  WHERE walk.role IN ('user', 'assistant') AND julianday(walk.at) >= julianday(?)`;
+export function conversationTallies(connection, conversations, since) {
+    const named = conversations ??
+        connection
+            .rows('SELECT DISTINCT conversation FROM conversation_messages')
+            .map((row) => String(row.conversation));
+    const from = instantKey(since);
+    const said = new Map();
+    for (const row of connection.rows(SAID, [JSON.stringify(named), since, since])) {
+        const at = instantKey(row.at);
+        if (at === null || at < from)
+            continue;
+        const conversation = String(row.conversation);
+        said.set(conversation, [...(said.get(conversation) ?? []), at]);
+    }
+    return named.map((conversation) => ({ conversation, said: said.get(conversation) ?? [] }));
+}

package/dist/transfer.d.ts

@@ -1,10 +1,5 @@
-import type { Refusal } from '@agentshouse/mdmodel';
 export type Unconfirmed = {
     kind: 'unconfirmed';
 };
-export type Refused = {
-    kind: 'refused';
-    refusal: Refusal;
-};
 export declare const unconfirmed: Unconfirmed;
 //# sourceMappingURL=transfer.d.ts.map

package/dist/transfer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transfer.d.ts","sourceRoot":"","sources":["../src/transfer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAEpD,MAAM,MAAM,WAAW,GAAG;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,CAAC;AAElD,MAAM,MAAM,OAAO,GAAG;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CAAC;AAE5D,eAAO,MAAM,WAAW,EAAE,WAAqC,CAAC"}
+{"version":3,"file":"transfer.d.ts","sourceRoot":"","sources":["../src/transfer.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,WAAW,GAAG;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,CAAC;AAElD,eAAO,MAAM,WAAW,EAAE,WAAqC,CAAC"}

package/dist/turn.d.ts

@@ -1,7 +1,9 @@
 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>;
+export declare function after<T, R>(value: Later<T>, next: (value: T) => Later<R>): Later<R>;
+export declare function paced(): (weight: number) => Later<void>;
+export declare function inUnits<T>(items: Iterable<T>, each: (item: T) => number, ended?: () => void, paused?: () => Promise<void>): Later<void>;
+export declare function finished<R>(steps: Generator<number, R, void>): R;
+export declare function stepped<R>(steps: Generator<number, R, void>): Later<R>;
 //# sourceMappingURL=turn.d.ts.map