@agentshouse/mdruntime 0.1.0-c5fe3b2cddda7 → 0.1.0-c6197367d5fad

package/dist/tables.js

@@ -1,11 +1,20 @@
+import { sql } from '@agentshouse/mdmodel';
 import { answerQuery } from './compile.js';
-import { searched, SEARCH_TABLES } from './fulltext.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, opened, rederive, referrers, refreshing, REPLICA_TABLES, stage, typed, typedWithin, unrefresh, } from './stored.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;
@@ -65,59 +74,58 @@ export function sqliteConnection(engine, database) {
         },
     };
 }
-export const FILE_PART_BYTES = 1_048_576;
 const PROBE_BYTES = 4 * FILE_PART_BYTES;
-const TABLES = [
-    ['authored_facts', 'name TEXT PRIMARY KEY, value TEXT NOT NULL'],
-    ['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)',
-    ],
-    [
-        'authored_room_drafts',
-        'locator TEXT NOT NULL, path TEXT NOT NULL, record TEXT NOT NULL, files TEXT NOT NULL, PRIMARY KEY (locator, path)',
-    ],
-    ['authored_chat_drafts', 'conversation TEXT PRIMARY KEY, record TEXT NOT NULL'],
-    ['authored_calls', 'operation TEXT PRIMARY KEY, record TEXT NOT NULL, files TEXT NOT NULL'],
-    ['authored_fences', 'locator TEXT PRIMARY KEY'],
-];
 export const RUNTIME_TABLES = [
-    ...TABLES.map(([name, columns]) => `CREATE TABLE ${name} (${columns}) WITHOUT ROWID`),
-    'CREATE TABLE file_parts (key TEXT NOT NULL, part INTEGER NOT NULL, bytes BLOB NOT NULL, PRIMARY KEY (key, part))',
     '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,
-    ...SEARCH_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 UNOPENED_PARTS = 'DELETE FROM opened_parts WHERE key NOT IN (SELECT key FROM opened_files)';
 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.search',
     '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,
@@ -129,14 +137,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.demote',
     'replica.fact',
     'replica.present',
     'opened.begin',
@@ -145,8 +156,11 @@ const KINDS = new Set([
     '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);
@@ -154,236 +168,75 @@ export function isRuntime(request) {
 export function readsRuntime(request) {
     return READS.has(request.kind);
 }
-function text(value) {
-    return typeof value === 'string' ? value : String(value);
-}
-function texts(rows, column) {
-    return rows.map((row) => text(row[column]));
-}
-function owned(files) {
-    return JSON.stringify([...new Set(files)]);
-}
-function fact(connection, name) {
-    const [held] = connection.rows('SELECT value FROM authored_facts WHERE name = ?', [name]);
-    return held === undefined ? null : text(held.value);
-}
-function remember(connection, name, value) {
-    connection.run('INSERT OR REPLACE INTO authored_facts (name, value) VALUES (?, ?)', [
-        name,
-        value,
-    ]);
-    return null;
-}
-function fenced(connection, locator) {
-    return connection.rows('SELECT 1 FROM authored_fences WHERE locator = ?', [locator]).length > 0;
-}
-function stored(connection, key) {
-    return connection.rows('SELECT 1 FROM file_parts WHERE key = ? LIMIT 1', [key]).length > 0;
-}
-function storedPart(connection, key, part, bytes) {
-    connection.run('INSERT INTO file_parts (key, part, bytes) VALUES (?, ?, ?)', [key, part, bytes]);
-}
-async function storedFiles(connection, files) {
-    for (const { key, blob } of files) {
-        if (stored(connection, key))
-            continue;
-        for (let at = 0, part = 0; at < blob.size; at += FILE_PART_BYTES, part += 1) {
-            const bytes = new Uint8Array(await blob.slice(at, at + FILE_PART_BYTES).arrayBuffer());
-            storedPart(connection, key, part, bytes);
-        }
-    }
-}
-function filePart(connection, key, part) {
-    const [held] = connection.rows('SELECT bytes FROM file_parts WHERE key = ? AND part = ?', [
-        key,
-        part,
-    ]);
-    return held?.bytes instanceof Uint8Array ? held.bytes : null;
-}
-function* fileParts(connection, key) {
-    for (let part = 0;; part += 1) {
-        const bytes = filePart(connection, key, part);
-        if (bytes === null)
-            return;
-        yield bytes;
-    }
-}
-async function spooled(connection, spool, { key, type }) {
-    for (const held of [...spool.held()]) {
-        if (held !== key && !stored(connection, held))
-            await spool.drop(held);
-    }
-    return spool.spool(key, type, fileParts(connection, key));
-}
-function unowned(connection) {
-    connection.run(UNOWNED_PARTS);
-}
-function queued(connection) {
+function heldWork(connection, locator) {
+    const room = heldRoom(connection, locator);
     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: queueOf(connection, locator),
     };
 }
-function heldOrder(connection, locator) {
-    const [held] = connection.rows('SELECT ids FROM authored_queues WHERE locator = ?', [locator]);
-    return held === undefined ? [] : JSON.parse(text(held.ids));
-}
-function keptRows(connection, { locator, order, added, founded, roomDrafts, consumedRoomDrafts }) {
-    for (const path of consumedRoomDrafts ?? []) {
-        connection.run('DELETE FROM authored_room_drafts WHERE locator = ? AND path = ?', [
-            locator,
-            path,
-        ]);
-    }
-    for (const { path, record, files } of roomDrafts ?? []) {
-        connection.run('INSERT OR REPLACE INTO authored_room_drafts (locator, path, record, files) VALUES (?, ?, ?, ?)', [locator, path, record, owned(files)]);
-    }
-    if (order === undefined)
-        return;
-    const before = new Set(heldOrder(connection, locator));
-    const after = new Set(order);
-    if (after.size === 0)
-        connection.run('DELETE FROM authored_queues WHERE locator = ?', [locator]);
-    else {
-        connection.run('INSERT OR REPLACE INTO authored_queues (locator, ids) VALUES (?, ?)', [
-            locator,
-            JSON.stringify([...after]),
-        ]);
-    }
-    for (const id of before) {
-        if (!after.has(id)) {
-            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))
-            continue;
-        connection.run('INSERT OR REPLACE INTO authored_pending (locator, id, batch, state, files) VALUES (?, ?, ?, ?, ?)', [locator, id, batch, state, owned(files)]);
-    }
-    for (const { id, batch, files } 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]);
-    }
-}
-async function kept(connection, { writes, files, whole, discards }) {
-    const refused = writes.find(({ locator }) => fenced(connection, locator));
-    if (refused !== undefined && whole)
-        return refused.locator;
-    await storedFiles(connection, files);
-    for (const write of writes) {
-        if (!fenced(connection, write.locator))
-            keptRows(connection, write);
-    }
-    for (const locator of discards ?? [])
-        roomWork(connection, locator);
-    unowned(connection);
-    return refused?.locator ?? null;
+function status(connection) {
+    return {
+        ...unsentStatus(connection),
+        lastCompleted: facts(connection, ['lastCompleted']).lastCompleted ?? null,
+    };
 }
-function amended(connection, { locator, id, amendment }) {
-    if (fenced(connection, locator))
-        return null;
-    const [held] = connection.rows('SELECT state FROM authored_pending WHERE locator = ? AND id = ?', [locator, id]);
-    if (held === undefined)
-        return null;
-    connection.run('UPDATE authored_pending SET state = ? WHERE locator = ? AND id = ?', [
-        JSON.stringify({
-            ...JSON.parse(text(held.state)),
-            ...JSON.parse(amendment),
-        }),
-        locator,
-        id,
-    ]);
-    return 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,
+    };
 }
-async function roomDraft(connection, { locator, path, kept: draft, files }) {
-    if (fenced(connection, locator))
-        return locator;
-    await storedFiles(connection, files);
-    if (draft === null) {
-        connection.run('DELETE FROM authored_room_drafts WHERE locator = ? AND path = ?', [
-            locator,
-            path,
+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),
         ]);
     }
-    else {
-        connection.run('INSERT OR REPLACE INTO authored_room_drafts (locator, path, record, files) VALUES (?, ?, ?, ?)', [locator, path, draft.record, owned(draft.files)]);
-    }
-    unowned(connection);
-    return null;
+    chatDraftsDropped(connection, conversations);
+    return held;
 }
-function chatDraft(connection, { kept: drafts, dropped }) {
-    for (const conversation of dropped) {
-        connection.run('DELETE FROM authored_chat_drafts WHERE conversation = ?', [conversation]);
-    }
-    for (const { conversation, record } of drafts) {
-        connection.run('INSERT OR REPLACE INTO authored_chat_drafts (conversation, record) VALUES (?, ?)', [conversation, record]);
-    }
-    return null;
-}
-async function call(connection, { operation, kept: held, files }) {
-    await storedFiles(connection, files);
-    if (held === null)
-        connection.run('DELETE FROM authored_calls WHERE operation = ?', [operation]);
-    else {
-        connection.run('INSERT OR REPLACE INTO authored_calls (operation, record, files) VALUES (?, ?, ?)', [operation, held.record, owned(held.files)]);
-    }
-    unowned(connection);
-    return null;
-}
-function roomWork(connection, locator) {
-    connection.run('DELETE FROM authored_queues WHERE locator = ?', [locator]);
-    connection.run('DELETE FROM authored_pending WHERE locator = ?', [locator]);
+function unopened(connection) {
+    connection.run(UNOPENED_PARTS);
 }
 function fence(connection, locators) {
+    fencedWork(connection, locators);
     for (const locator of locators) {
-        connection.run('INSERT OR REPLACE INTO authored_fences (locator) VALUES (?)', [locator]);
-        roomWork(connection, locator);
-        connection.run('DELETE FROM authored_room_drafts WHERE locator = ?', [locator]);
         connection.run('DELETE FROM opened_files WHERE locator = ?', [locator]);
     }
-    unowned(connection);
+    unopened(connection);
     return fenceRooms(connection, locators);
 }
 function erased(connection, { locator, limit }) {
-    const done = erase(connection, locator, limit);
-    if (locator !== null && !done.remaining) {
-        connection.run('DELETE FROM authored_fences WHERE locator = ?', [locator]);
-    }
-    return done;
+    return erase(connection, locator, limit);
 }
-function claim(connection, holder) {
-    const held = fact(connection, 'holder');
-    if (held !== null)
-        return held === holder;
-    remember(connection, 'holder', holder);
-    return true;
+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);
-    forgottenMessages(connection);
+    forgottenConversations(connection);
     if (holder !== null && claim(connection, holder))
         return true;
-    for (const [table] of TABLES)
-        connection.run(`DELETE FROM ${table}`);
+    authoredEmptied(connection);
     connection.run('DELETE FROM opened_files');
-    connection.run('DELETE FROM file_parts');
+    connection.run('DELETE FROM opened_parts');
     return false;
 }
-function count(value) {
-    return typeof value === 'bigint' ? Number(value) : typeof value === 'number' ? value : 0;
-}
 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
@@ -398,7 +251,7 @@ 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]);
-    unowned(connection);
+    unopened(connection);
     connection.run('INSERT INTO opened_files (key, locator, path, revision, media_type) VALUES (?, ?, ?, ?, ?)', [key, locator, path, revision, mediaType]);
     return true;
 }
@@ -411,22 +264,26 @@ function fetching(connection, key) {
 function openedPart(connection, { key, part, bytes }) {
     if (fetching(connection, key) === null)
         return false;
-    storedPart(connection, key, part, bytes);
+    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 file_parts 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 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 [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;
@@ -437,19 +294,38 @@ function keptOpened(connection, { key, sha256, byteLength, parts }) {
         key,
     ]);
     connection.run('DELETE FROM opened_files WHERE locator = ? AND path = ? AND revision = ? AND key <> ?', [fetched.locator, fetched.path, fetched.revision, key]);
-    unowned(connection);
+    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] = connection.rows(`SELECT coalesce(sum(length(bytes)), 0) AS bytes FROM file_parts WHERE key NOT IN (${AUTHORED_KEYS})`);
-    unowned(connection);
-    return count(freed?.bytes);
+    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, counts: {}, changed: {}, indexed: {} };
+        return { fenced: refused, changed: {}, indexed: {} };
     }
     return {
         fenced: refused,
@@ -458,28 +334,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 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 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');
+            return chatDraftRecords(connection);
         case 'authored.calls':
-            return texts(connection.rows('SELECT record FROM authored_calls'), 'record');
+            return callRecords(connection);
         case 'authored.fences':
-            return texts(connection.rows('SELECT locator FROM authored_fences'), 'locator');
+            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);
+            return spooled(connection, spool, request.key, request.type);
         case 'authored.amend':
-            return amended(connection, request);
+            return amended(connection, request.locator, request.id, request.amendment);
         case 'authored.roomDraft':
-            return roomDraft(connection, request);
+            return roomDraft(connection, request.locator, request.path, request.kept, request.files);
         case 'authored.chatDraft':
-            return chatDraft(connection, request);
+            return chatDraft(connection, request.kept, request.dropped);
         case 'authored.call':
-            return call(connection, request);
+            return call(connection, request.operation, request.kept, request.files);
         case 'authored.remember':
             return remember(connection, request.name, request.value);
         case 'authored.claim':
@@ -488,28 +378,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 { ...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, 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.search': {
-            const { kind: _kind, ...ask } = request;
-            return searched(connection, ask);
-        }
         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,6 +427,8 @@ export function answerRuntime(connection, request, spool) {
             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':
@@ -550,29 +457,43 @@ 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);
+            return heldPart(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);
         }
         case 'conversation.window':
-            return messageWindow(connection, request.conversation, request.limit, request.before);
+            return messageWindow(connection, request.conversation, request.limit, request.before, request.phrase);
         case 'conversation.count':
-            return messageCount(connection, request.conversation);
+            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':
-            chatDraft(connection, {
-                kind: 'authored.chatDraft',
-                kept: [],
-                dropped: request.conversations,
-            });
-            droppedMessages(connection, request.conversations);
-            return null;
+            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);
     }
 }