@agentshouse/mdruntime 0.1.0-cef5833f6c689 → 0.1.0-cef76ea952695

package/dist/tables.js

@@ -1,7 +1,9 @@
 import { sql } from '@agentshouse/mdmodel';
 import { answerQuery } from './compile.js';
-import { droppedMessages, forgottenMessages, heldConversations, keptMessages, messageCount, messageWindow, MESSAGE_TABLES, turnArrived, } from './messages.js';
-import { abandon, release, commit, counts, ended, entries, erase, fenceRooms, files, folders, holdTexts, opened, rederive, referrers, refreshing, remembered, REPLICA_TABLES, stage, typed, typedWithin, unholdTexts, unrefresh, wanted, } from './stored.js';
+import { conversationRows, droppedMessages, forgottenMessages, heldConversations, 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, typedWithin, unrefresh, } from './stored.js';
 const STATEMENTS_HELD = 256;
 export function sqliteConnection(engine, database) {
     const decoder = new TextDecoder();
@@ -76,7 +78,7 @@ const TABLES = [
     ['authored_queues', 'locator TEXT PRIMARY KEY, ids TEXT NOT NULL'],
     [
         'authored_pending',
-        'locator TEXT NOT NULL, id TEXT NOT NULL, batch TEXT NOT NULL, state TEXT NOT NULL, files TEXT NOT NULL, PRIMARY KEY (locator, id)',
+        'locator TEXT NOT NULL, id TEXT NOT NULL, batch TEXT NOT NULL, state TEXT NOT NULL, files TEXT NOT NULL, paths TEXT NOT NULL, moving INTEGER NOT NULL, PRIMARY KEY (locator, id)',
     ],
     [
         'authored_room_drafts',
@@ -93,34 +95,52 @@ export const RUNTIME_TABLES = [
     'CREATE INDEX opened_files_name ON opened_files (locator, path, revision)',
     ...REPLICA_TABLES,
     ...MESSAGE_TABLES,
+    ...READ_TABLES,
 ];
 const OWNERS = ['authored_pending', 'authored_room_drafts', 'authored_calls'];
 const AUTHORED_KEYS = OWNERS.map((table) => `SELECT value FROM ${table}, json_each(${table}.files)`).join(' UNION ');
 const UNOWNED_PARTS = `DELETE FROM file_parts WHERE key NOT IN (${AUTHORED_KEYS} UNION SELECT key FROM opened_files)`;
+const CLEANABLE_BYTES = `SELECT coalesce(sum(length(bytes)), 0) AS bytes FROM file_parts WHERE key NOT IN (${AUTHORED_KEYS})`;
 const READS = new Set([
-    'authored.queues',
+    '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.files',
     'replica.folders',
     'replica.typedWithin',
-    'replica.counts',
-    'replica.wanted',
     'opened.find',
+    'opened.held',
     'file.part',
     'conversation.held',
     'conversation.window',
     'conversation.count',
     'conversation.turn',
+    'conversation.rows',
+    'conversation.tallies',
+    'read.stored',
 ]);
 const KINDS = new Set([
     ...READS,
@@ -132,17 +152,17 @@ const KINDS = new Set([
     '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.hold',
-    'replica.remember',
-    'replica.unhold',
+    'replica.demote',
     'replica.fact',
     'replica.present',
     'opened.begin',
@@ -153,6 +173,8 @@ const KINDS = new Set([
     'conversation.keep',
     'conversation.drop',
     'space.probe',
+    'read.keep',
+    'read.builds',
 ]);
 export function isRuntime(request) {
     return KINDS.has(request.kind);
@@ -225,21 +247,66 @@ function unowned(connection) {
     connection.run(UNOWNED_PARTS);
 }
 function queued(connection) {
+    return connection.rows('SELECT locator, ids FROM authored_queues').map((row) => ({
+        locator: text(row.locator),
+        ids: JSON.parse(text(row.ids)),
+    }));
+}
+function heldWork(connection, locator) {
+    const room = heldRoom(connection, locator);
+    const pending = new Map(connection
+        .rows('SELECT id, batch, state FROM authored_pending WHERE locator = ?', [locator])
+        .map((row) => [
+        text(row.id),
+        { id: text(row.id), batch: text(row.batch), state: text(row.state) },
+    ]));
     return {
-        queues: connection.rows('SELECT locator, ids FROM authored_queues').map((row) => ({
-            locator: text(row.locator),
-            ids: JSON.parse(text(row.ids)),
-        })),
-        pending: connection
-            .rows('SELECT locator, id, batch, state FROM authored_pending')
-            .map((row) => ({
-            locator: text(row.locator),
-            id: text(row.id),
-            batch: text(row.batch),
-            state: text(row.state),
-        })),
+        room: room === null ? null : { ...room, overlaid: overlaid(connection, room.key) },
+        queue: heldOrder(connection, locator).map((id) => {
+            const held = pending.get(id);
+            if (held === undefined)
+                throw new Error(`Missing Pending Change ${locator}/${id}`);
+            return held;
+        }),
+    };
+}
+function status(connection) {
+    const [completed] = connection.rows("SELECT value FROM replica_facts WHERE name = 'lastCompleted'");
+    return {
+        queued: texts(connection.rows('SELECT locator FROM authored_queues'), 'locator'),
+        lastCompleted: completed === undefined ? null : text(completed.value),
+        changes: connection
+            .rows('SELECT p.locator, c.value AS path FROM authored_pending p, json_each(p.paths) c')
+            .map((row) => ({ locator: text(row.locator), path: text(row.path) })),
+        resets: connection
+            .rows(`SELECT locator, json_extract(state, '$.submission.reset') AS reset FROM authored_pending
+         WHERE json_extract(state, '$.submission.state') = 'reset'`)
+            .map((row) => ({ locator: text(row.locator), reset: text(row.reset) })),
+        returned: texts(connection.rows(`SELECT record FROM authored_room_drafts WHERE json_type(record, '$.returned') = 'object'`), 'record'),
+    };
+}
+function pendingOf(connection, locator, id) {
+    const [held] = connection.rows('SELECT state FROM authored_pending WHERE locator = ? AND id = ?', [locator, id]);
+    return {
+        state: held === undefined ? null : text(held.state),
+        room: connection.rows('SELECT 1 FROM replica_rooms WHERE locator = ?', [locator]).length > 0,
     };
 }
+function roomDraftRecords(connection, locator, paths) {
+    if (locator === null) {
+        return texts(connection.rows('SELECT record FROM authored_room_drafts'), 'record');
+    }
+    if (paths === null) {
+        return texts(connection.rows('SELECT record FROM authored_room_drafts WHERE locator = ?', [locator]), 'record');
+    }
+    return texts(connection.rows('SELECT record FROM authored_room_drafts WHERE locator = ? AND path IN (SELECT value FROM json_each(?))', [locator, JSON.stringify(paths)]), 'record');
+}
+function chatDraftRecord(connection, conversation) {
+    const [held] = connection.rows('SELECT record FROM authored_chat_drafts WHERE conversation = ?', [
+        conversation,
+    ]);
+    return held === undefined ? null : text(held.record);
+}
 function heldOrder(connection, locator) {
     const [held] = connection.rows('SELECT ids FROM authored_queues WHERE locator = ?', [locator]);
     return held === undefined ? [] : JSON.parse(text(held.ids));
@@ -271,16 +338,23 @@ function keptRows(connection, { locator, order, added, founded, roomDrafts, cons
             connection.run('DELETE FROM authored_pending WHERE locator = ? AND id = ?', [locator, id]);
         }
     }
-    for (const { id, batch, state, files } of added ?? []) {
-        if (before.has(id) || !after.has(id))
+    for (const { id, batch, state, files, paths, moving } of added ?? []) {
+        if (before.has(id))
             continue;
-        connection.run('INSERT OR REPLACE INTO authored_pending (locator, id, batch, state, files) VALUES (?, ?, ?, ?, ?)', [locator, id, batch, state, owned(files)]);
+        connection.run('INSERT OR REPLACE INTO authored_pending (locator, id, batch, state, files, paths, moving) VALUES (?, ?, ?, ?, ?, ?, ?)', [locator, id, batch, state, owned(files), JSON.stringify(paths), moving ? 1 : 0]);
     }
-    for (const { id, batch, files } of founded ?? []) {
+    for (const { id, batch, files, paths, moving } of founded ?? []) {
         const [held] = connection.rows('SELECT files FROM authored_pending WHERE locator = ? AND id = ?', [locator, id]);
         if (held === undefined || !before.has(id))
             continue;
-        connection.run('UPDATE authored_pending SET batch = ?, files = ? WHERE locator = ? AND id = ?', [batch, owned([...JSON.parse(text(held.files)), ...files]), locator, id]);
+        connection.run('UPDATE authored_pending SET batch = ?, files = ?, paths = ?, moving = ? WHERE locator = ? AND id = ?', [
+            batch,
+            owned([...JSON.parse(text(held.files)), ...files]),
+            JSON.stringify(paths),
+            moving ? 1 : 0,
+            locator,
+            id,
+        ]);
     }
 }
 async function kept(connection, { writes, files, whole }) {
@@ -361,11 +435,15 @@ function fence(connection, locators) {
     return fenceRooms(connection, locators);
 }
 function erased(connection, { locator, limit }) {
-    const done = erase(connection, locator, limit);
-    if (locator !== null && !done.remaining) {
+    return erase(connection, locator, limit);
+}
+function unfenced(connection, locators) {
+    const erased = locators.filter((locator) => connection.rows('SELECT 1 FROM replica_erasing WHERE locator = ? LIMIT 1', [locator])
+        .length === 0);
+    for (const locator of erased) {
         connection.run('DELETE FROM authored_fences WHERE locator = ?', [locator]);
     }
-    return done;
+    return erased;
 }
 function claim(connection, holder) {
     const held = fact(connection, 'holder');
@@ -428,9 +506,9 @@ function keptOpened(connection, { key, sha256, byteLength, parts }) {
     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 file_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));
+    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;
@@ -444,16 +522,38 @@ function keptOpened(connection, { key, sha256, byteLength, parts }) {
     unowned(connection);
     return true;
 }
+const UNSENT = [
+    ['pending-change', 'authored_pending'],
+    ['call', 'authored_calls'],
+    ['room-draft', 'authored_room_drafts'],
+    ['chat-draft', 'authored_chat_drafts'],
+];
+function unsent(connection) {
+    const [held] = connection.rows(`SELECT ${UNSENT.map(([kind, table]) => `(SELECT count(*) FROM ${table}) AS "${kind}"`).join(', ')}`);
+    return UNSENT.map(([kind]) => ({ kind, count: count(held[kind]) })).filter((work) => work.count > 0);
+}
+function cleanable(connection) {
+    const [held] = connection.rows(CLEANABLE_BYTES);
+    return count(held.bytes);
+}
 function cleaned(connection) {
     connection.run('DELETE FROM opened_files');
-    const [freed] = connection.rows(`SELECT coalesce(sum(length(bytes)), 0) AS bytes FROM file_parts WHERE key NOT IN (${AUTHORED_KEYS})`);
+    const freed = cleanable(connection);
     unowned(connection);
-    return count(freed?.bytes);
+    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, counts: {}, changed: {}, indexed: {} };
+        return { fenced: refused, changed: {}, indexed: {} };
     }
     return {
         fenced: refused,
@@ -462,16 +562,42 @@ async function committed(connection, { authored, rooms }) {
 }
 export function answerRuntime(connection, request, spool) {
     switch (request.kind) {
-        case 'authored.queues':
-            return queued(connection);
+        case 'authored.status':
+            return status(connection);
+        case 'authored.moving':
+            return {
+                queues: queued(connection),
+                pending: connection
+                    .rows('SELECT locator, id, batch, state FROM authored_pending WHERE moving = 1 ORDER BY locator')
+                    .map((row) => ({
+                    locator: text(row.locator),
+                    id: text(row.id),
+                    batch: text(row.batch),
+                    state: text(row.state),
+                })),
+            };
+        case 'authored.pending':
+            return pendingOf(connection, request.locator, request.id);
+        case 'authored.batch': {
+            const [held] = connection.rows('SELECT batch FROM authored_pending WHERE locator = ? AND id = ?', [request.locator, request.id]);
+            return held === undefined ? null : text(held.batch);
+        }
+        case 'authored.order':
+            return heldOrder(connection, request.locator);
+        case 'authored.queued':
+            return texts(connection.rows('SELECT locator FROM authored_queues'), 'locator');
         case 'authored.roomDrafts':
-            return texts(connection.rows('SELECT record FROM authored_room_drafts'), 'record');
+            return roomDraftRecords(connection, request.locator, request.paths);
+        case 'authored.chatDraft.read':
+            return chatDraftRecord(connection, request.conversation);
         case 'authored.chatDrafts':
             return texts(connection.rows('SELECT record FROM authored_chat_drafts'), 'record');
         case 'authored.calls':
             return texts(connection.rows('SELECT record FROM authored_calls'), 'record');
         case 'authored.fences':
             return texts(connection.rows('SELECT locator FROM authored_fences'), 'locator');
+        case 'authored.unsent':
+            return unsent(connection);
         case 'authored.fact':
             return fact(connection, request.name);
         case 'authored.file':
@@ -492,24 +618,43 @@ export function answerRuntime(connection, request, spool) {
             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 {
+                rooms: covering(connection),
+                queues: queued(connection),
+            };
+        case 'replica.offline':
+            return offlineMode(connection, request.locator);
+        case 'replica.held':
+            return { held: heldLocators(connection), staged: stagedLocators(connection) };
+        case 'replica.demote':
+            return demoted(connection);
+        case 'replica.facts':
+            return facts(connection);
+        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, request.kinds);
-        case 'replica.files':
-            return files(connection, request.key, request.view, request.after, request.limit);
+            return referrers(connection, request.key, request.view, request.targets);
         case 'replica.folders':
-            return folders(connection, request.key, request.view, request.paths);
+            return folders(connection, request.key, request.paths);
         case 'replica.typedWithin':
             return typedWithin(connection, request.key, request.view, request.roots, request.within);
-        case 'replica.counts':
-            return counts(connection, request.rooms);
         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':
@@ -522,18 +667,12 @@ export function answerRuntime(connection, request, spool) {
             return erased(connection, request);
         case 'replica.abandon':
             return abandon(connection, request.locator);
+        case 'replica.unfence':
+            return unfenced(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.hold':
-            return holdTexts(connection, request);
-        case 'replica.unhold':
-            return unholdTexts(connection, request);
-        case 'replica.wanted':
-            return wanted(connection, request);
-        case 'replica.remember':
-            return remembered(connection, request);
         case 'replica.fact':
             connection.run('INSERT OR REPLACE INTO replica_facts (name, value) VALUES (?, ?)', [
                 request.name,
@@ -558,10 +697,12 @@ export function answerRuntime(connection, request, spool) {
             return dropped(connection, request.key);
         case 'opened.clean':
             return cleaned(connection);
+        case 'opened.held':
+            return openedHeld(connection);
         case 'file.part':
             return filePart(connection, request.key, request.part);
         case 'conversation.held':
-            return heldConversations(connection);
+            return heldConversations(connection, request.conversations);
         case 'conversation.keep': {
             const { kind: _kind, ...write } = request;
             return keptMessages(connection, write);
@@ -572,6 +713,10 @@ export function answerRuntime(connection, request, spool) {
             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.drop':
             chatDraft(connection, {
                 kind: 'authored.chatDraft',
@@ -582,5 +727,11 @@ export function answerRuntime(connection, request, spool) {
             return null;
         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":"AAEA,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,129 @@
+import { instantKey, sql } from '@agentshouse/mdmodel';
+import { CHAT_MESSAGE_TYPE, CHAT_TYPE } from './chat-types.js';
+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/validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,UAAU,EAGhB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAY,KAAK,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAM7D,KAAK,QAAQ,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC;AAE3E,MAAM,MAAM,KAAK,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;CAAE,CAAC;AAEpF,MAAM,MAAM,IAAI,GAAG,CACjB,KAAK,EAAE,MAAM,GAAG,IAAI,KACjB,OAAO,CAAC;IAAE,QAAQ,CAAC,OAAO,EAAE,SAAS,QAAQ,EAAE,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC,CAAC;AAEtF,MAAM,MAAM,MAAM,GAAG,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,KAAK,OAAO,CAAC,WAAW,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC;AAyBvF,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,WAAW,GACvB,OAAO,CAAC,UAAU,CAAC,CA4CrB;AAED,MAAM,MAAM,OAAO,GAAG;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IACxC,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;CACzC,CAAC;AAEF,KAAK,aAAa,GAAG;IACnB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,KAAK,OAAO,CAAC,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC;IAC1F,QAAQ,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,KAAK,OAAO,CAAC,SAAS,MAAM,EAAE,CAAC,CAAC;CAChF,CAAC;AAkBF,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,SAAS,OAAO,EAAE,EAC3B,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,aAAa,GACpB,OAAO,CAAC,UAAU,CAAC,CAgCrB"}
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.ts"],"names":[],"mappings":"AAAA,OAAO,EAOL,KAAK,UAAU,EAGhB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAY,KAAK,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAM7D,KAAK,QAAQ,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC;AAE3E,MAAM,MAAM,KAAK,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;CAAE,CAAC;AAEpF,MAAM,MAAM,IAAI,GAAG,CACjB,KAAK,EAAE,MAAM,GAAG,IAAI,KACjB,OAAO,CAAC;IAAE,QAAQ,CAAC,OAAO,EAAE,SAAS,QAAQ,EAAE,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC,CAAC;AAEtF,MAAM,MAAM,MAAM,GAAG,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,KAAK,OAAO,CAAC,WAAW,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC;AAwBvF,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,WAAW,GACvB,OAAO,CAAC,UAAU,CAAC,CA6CrB;AAED,MAAM,MAAM,OAAO,GAAG;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IACxC,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;CACzC,CAAC;AAEF,KAAK,aAAa,GAAG;IACnB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,KAAK,OAAO,CAAC,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC;IAC1F,QAAQ,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,KAAK,OAAO,CAAC,SAAS,MAAM,EAAE,CAAC,CAAC;CAChF,CAAC;AAkBF,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,SAAS,OAAO,EAAE,EAC3B,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,aAAa,GACpB,OAAO,CAAC,UAAU,CAAC,CAgCrB"}

package/dist/validation.js

@@ -5,8 +5,7 @@ const NO_TYPES = { types: {} };
 function modelOf(model) {
     return model.status === 'unavailable' ? NO_TYPES : { types: model.types };
 }
-function typedText(content) {
-    const read = parse(content);
+function typedText(read) {
     return read.ok && read.document.type !== undefined && read.document.type !== 'any';
 }
 function partVerdict(part) {
@@ -28,10 +27,11 @@ export async function validatedCollection(walk, lookup, composition) {
             if (content === null)
                 continue;
             const part = partOf(path);
-            if (part.model.status === 'unavailable' && part.unmodeled === null && typedText(content)) {
+            const parsed = parse(content, path);
+            if (part.model.status === 'unavailable' && part.unmodeled === null && typedText(parsed)) {
                 part.unmodeled = path;
             }
-            const assessment = assess(path, content, false, modelOf(part.model), {
+            const assessment = assess(path, parsed, false, modelOf(part.model), {
                 anyRoom: true,
                 typedPaths: composition.typedPaths,
             });

package/dist/wire.d.ts

@@ -1,4 +1,4 @@
-import type { ConnectionRefusal } from './connection.js';
+import type { ConnectionRefusal } from './socket.js';
 import type { Described } from './failure.js';
 export type RuntimePort = {
     postMessage(message: unknown): void;
@@ -82,6 +82,18 @@ declare const MEMBERS: {
         readonly reach: 'whole';
         readonly effect: 'write';
     };
+    readonly unsent: {
+        readonly reach: 'whole';
+        readonly effect: 'read';
+    };
+    readonly reset: {
+        readonly reach: 'whole';
+        readonly effect: 'write';
+    };
+    readonly readAgain: {
+        readonly reach: 'whole';
+        readonly effect: 'read';
+    };
     readonly persistence: {
         readonly reach: 'runtime';
         readonly effect: 'read';
@@ -184,6 +196,9 @@ declare const TOPICS: {
     readonly conversation: 'within';
     readonly conversations: 'within';
     readonly agents: 'within';
+    readonly figures: 'whole';
+    readonly holdings: 'whole';
+    readonly read: 'whole';
 };
 export declare const WIRE: {
     readonly members: Readonly<Record<string, WireCall>>;