@agentshouse/mdruntime 0.1.0-cf28918c2bf91 → 0.1.0-cf53a3b60b194

package/dist/tables.js

@@ -0,0 +1,627 @@
+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, keepParts, stage, transferPart, typed, typedWithin, unrefresh, walk, } from './stored.js';
+const STATEMENTS_HELD = 256;
+export function sqliteConnection(engine, database) {
+    const decoder = new TextDecoder();
+    const held = new Map();
+    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}`);
+        },
+    };
+}
+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)',
+    ...REPLICA_TABLES,
+    ...MESSAGE_TABLES,
+    ...SEARCH_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 READS = new Set([
+    'authored.queues',
+    'authored.roomDrafts',
+    'authored.chatDrafts',
+    'authored.calls',
+    'authored.fences',
+    'authored.fact',
+    'authored.file',
+    'replica.open',
+    'replica.query',
+    'replica.entries',
+    'replica.typed',
+    'replica.referrers',
+    'replica.walk',
+    'replica.files',
+    'replica.folders',
+    'replica.typedWithin',
+    'replica.counts',
+    'replica.search',
+    'replica.received',
+    'replica.receivedParts',
+    'replica.transferPart',
+    'opened.find',
+    'file.part',
+    'conversation.held',
+    'conversation.window',
+    'conversation.count',
+    'conversation.turn',
+]);
+const KINDS = new Set([
+    ...READS,
+    'authored.amend',
+    'authored.roomDraft',
+    'authored.chatDraft',
+    'authored.call',
+    'authored.remember',
+    'authored.claim',
+    'authored.end',
+    'replica.stage',
+    'replica.keepParts',
+    'replica.refresh',
+    'replica.unrefresh',
+    'replica.commit',
+    'replica.fence',
+    'replica.erase',
+    'replica.abandon',
+    'replica.release',
+    'replica.rederive',
+    'replica.fact',
+    'replica.present',
+    'replica.receive',
+    'replica.unreceive',
+    'opened.begin',
+    'opened.part',
+    'opened.keep',
+    'opened.drop',
+    'opened.clean',
+    'conversation.keep',
+    'conversation.drop',
+    'space.probe',
+]);
+export function isRuntime(request) {
+    return KINDS.has(request.kind);
+}
+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) {
+    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),
+        })),
+    };
+}
+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, amendments }) {
+    for (const { id, amendment } of amendments ?? []) {
+        amended(connection, { kind: 'authored.amend', locator, id, amendment });
+    }
+    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 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;
+}
+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,
+        ]);
+    }
+    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;
+}
+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 fence(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);
+    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;
+}
+function claim(connection, holder) {
+    const held = fact(connection, 'holder');
+    if (held !== null)
+        return held === holder;
+    remember(connection, 'holder', holder);
+    return true;
+}
+function end(connection, holder) {
+    ended(connection);
+    forgottenMessages(connection);
+    if (holder !== null && claim(connection, holder))
+        return true;
+    for (const [table] of TABLES)
+        connection.run(`DELETE FROM ${table}`);
+    connection.run('DELETE FROM opened_files');
+    connection.run('DELETE FROM file_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
+        ? 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]);
+    unowned(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;
+    storedPart(connection, 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]);
+    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));
+    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]);
+    unowned(connection);
+    return true;
+}
+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);
+}
+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,
+        ...commit(connection, rooms.filter(({ locator }) => !fenced(connection, locator))),
+    };
+}
+function receivedParts(connection, key, count) {
+    return connection
+        .rows('SELECT value FROM replica_received_parts WHERE key = ? AND part < ? ORDER BY part', [
+        key,
+        count,
+    ])
+        .map((row) => JSON.parse(text(row.value)));
+}
+function receive(connection, { key, head, part }) {
+    connection.run('INSERT OR REPLACE INTO replica_received (key, head) VALUES (?, ?)', [key, head]);
+    if (part !== undefined) {
+        connection.run('INSERT OR REPLACE INTO replica_received_parts (key, part, value) VALUES (?, ?, ?)', [key, part.index, part.value]);
+    }
+    return null;
+}
+function unreceive(connection, keys) {
+    for (const key of keys) {
+        connection.run('DELETE FROM replica_received WHERE key = ?', [key]);
+        connection.run('DELETE FROM replica_received_parts WHERE key = ?', [key]);
+    }
+    return null;
+}
+export function answerRuntime(connection, request, spool) {
+    switch (request.kind) {
+        case 'authored.queues':
+            return queued(connection);
+        case 'authored.roomDrafts':
+            return texts(connection.rows('SELECT record FROM authored_room_drafts'), 'record');
+        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.fact':
+            return fact(connection, request.name);
+        case 'authored.file':
+            return spooled(connection, spool, request);
+        case 'authored.amend':
+            return amended(connection, request);
+        case 'authored.roomDraft':
+            return roomDraft(connection, request);
+        case 'authored.chatDraft':
+            return chatDraft(connection, request);
+        case 'authored.call':
+            return call(connection, request);
+        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.query':
+            return answerQuery(connection, request.plan, request.rooms, request.budget);
+        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.walk':
+            return walk(connection, request.key, request.view, request.after, request.bytes);
+        case 'replica.files':
+            return files(connection, request.key, request.view, request.after, request.limit);
+        case 'replica.folders':
+            return folders(connection, request.key, request.view, 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.received':
+            return connection.rows('SELECT key, head FROM replica_received').map((row) => ({
+                key: text(row.key),
+                head: JSON.parse(text(row.head)),
+            }));
+        case 'replica.receivedParts':
+            return receivedParts(connection, request.key, request.count);
+        case 'replica.stage':
+            return fenced(connection, request.locator) ? null : stage(connection, request);
+        case 'replica.transferPart':
+            return transferPart(connection, request.locator, request.token);
+        case 'replica.keepParts':
+            return keepParts(connection, request.parts.filter(({ locator }) => !fenced(connection, locator)));
+        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, request.kept);
+        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 'replica.receive':
+            return receive(connection, request);
+        case 'replica.unreceive':
+            return unreceive(connection, request.keys);
+        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 'file.part':
+            return filePart(connection, request.key, request.part);
+        case 'conversation.held':
+            return heldConversations(connection);
+        case 'conversation.keep': {
+            const { kind: _kind, ...write } = request;
+            return keptMessages(connection, write);
+        }
+        case 'conversation.window':
+            return messageWindow(connection, request.conversation, request.limit, request.before);
+        case 'conversation.count':
+            return messageCount(connection, request.conversation);
+        case 'conversation.turn':
+            return turnArrived(connection, request.conversation, request.turn);
+        case 'conversation.drop':
+            chatDraft(connection, {
+                kind: 'authored.chatDraft',
+                kept: [],
+                dropped: request.conversations,
+            });
+            droppedMessages(connection, request.conversations);
+            return null;
+        case 'space.probe':
+            return spool.probe(PROBE_BYTES).then(() => null);
+    }
+}

package/dist/turn.d.ts

@@ -0,0 +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) => 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

package/dist/turn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"turn.d.ts","sourceRoot":"","sources":["../src/turn.ts"],"names":[],"mappings":"AAAA,wBAAgB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CASvC;AAOD,eAAO,MAAM,UAAU,MAAM,CAAC;AAE9B,MAAM,MAAM,KAAK,CAAC,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;AAEtC,wBAAgB,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAEnF;AAmBD,wBAAgB,KAAK,IAAI,CAAC,MAAM,EAAE,MAAM,KAAK,KAAK,CAAC,IAAI,CAAC,CAGvD;AAsBD,wBAAgB,OAAO,CAAC,CAAC,EACvB,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,EAClB,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,EACzB,KAAK,GAAE,MAAM,IAAe,EAC5B,MAAM,GAAE,MAAM,OAAO,CAAC,IAAI,CAAW,GACpC,KAAK,CAAC,IAAI,CAAC,CAUb;AAED,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,MAAM,EAAE,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAIhE;AAED,wBAAgB,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,MAAM,EAAE,CAAC,EAAE,IAAI,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAStE"}