@agentshouse/mdruntime 0.1.0-cb2e390ee7b89 → 0.1.0-cb3bb3b233fa1

package/dist/store/records.js

@@ -0,0 +1,465 @@
+import { composedOf } from '../collection.js';
+import { binaryLocalId } from '../identity.js';
+import { lockingMode } from '../presence.js';
+import { readsRuntime } from '../tables.js';
+const FILE = '\u0000file';
+const UNSTATED = {
+    lastCompleted: null,
+    providerLimits: [],
+    capabilities: [],
+    member: null,
+    targets: {},
+    conversationList: null,
+    agentList: null,
+    conversationCursor: null,
+    chatPins: [],
+    roomList: null,
+};
+function batchFacts(batch) {
+    return { paths: batch.changes.map(({ path }) => path), moving: batch.between !== undefined };
+}
+function batchFiles(batch) {
+    return batch.changes.flatMap((change) => (change.kind === 'binary' ? [change.localId] : []));
+}
+function draftFiles(drafts) {
+    return drafts.flatMap(({ parts }) => (parts.file === undefined ? [] : [parts.file.localId]));
+}
+function roomDraftRow(record) {
+    return { path: record.path, record: JSON.stringify(record), files: draftFiles([record]) };
+}
+function authoredRows({ locator, queue, stored, founded, saved, roomDrafts, consumedRoomDrafts, }) {
+    const held = new Set((stored ?? []).map(({ id }) => id));
+    return {
+        locator,
+        ...(queue === undefined
+            ? {}
+            : {
+                order: queue.map(({ id }) => id),
+                added: queue
+                    .filter(({ id }) => !held.has(id))
+                    .map((batch) => {
+                    const drafts = saved?.get(batch.id) ?? [];
+                    return {
+                        id: batch.id,
+                        batch: JSON.stringify(batch),
+                        state: JSON.stringify({
+                            drafts,
+                            submission: { state: 'waiting' },
+                            lost: false,
+                        }),
+                        files: [...batchFiles(batch), ...draftFiles(drafts)],
+                        ...batchFacts(batch),
+                    };
+                }),
+            }),
+        ...(founded === undefined
+            ? {}
+            : {
+                founded: founded.map((batch) => ({
+                    id: batch.id,
+                    batch: JSON.stringify(batch),
+                    files: batchFiles(batch),
+                    ...batchFacts(batch),
+                })),
+            }),
+        ...(roomDrafts === undefined ? {} : { roomDrafts: roomDrafts.map(roomDraftRow) }),
+        ...(consumedRoomDrafts === undefined ? {} : { consumedRoomDrafts }),
+    };
+}
+function marked(value) {
+    return typeof value === 'object' && value !== null && FILE in value;
+}
+function keyed(keys, value) {
+    const stored = [];
+    const files = [];
+    const record = JSON.stringify(value, (_name, held) => {
+        if (!(held instanceof Blob))
+            return held;
+        let key = keys.get(held);
+        if (key === undefined) {
+            key = binaryLocalId();
+            keys.set(held, key);
+        }
+        stored.push({ key, blob: held });
+        files.push(key);
+        return { [FILE]: key, type: held.type };
+    });
+    return { record, files, stored };
+}
+async function filed(value, read) {
+    if (Array.isArray(value))
+        return Promise.all(value.map((item) => filed(item, read)));
+    if (marked(value))
+        return read(value[FILE], value.type);
+    if (typeof value !== 'object' || value === null)
+        return value;
+    const restored = {};
+    for (const [name, item] of Object.entries(value))
+        restored[name] = await filed(item, read);
+    return restored;
+}
+function roomOf(row) {
+    return {
+        record: { ...JSON.parse(row.record), key: row.key },
+        indexed: row.indexed,
+        documents: row.documents,
+    };
+}
+function json(value, fallback) {
+    return value === undefined ? fallback : JSON.parse(value);
+}
+function coverOf(kept, answer) {
+    const { log, whole, rooms, removed, queues } = answer;
+    const queued = new Map(queues.map(({ locator, ids }) => [locator, ids]));
+    const fresh = whole || kept === null || kept.log.token !== log.token;
+    if (!fresh && log.at < kept.log.at)
+        return kept;
+    const held = fresh ? { rooms: new Map(), locking: new Set() } : kept;
+    for (const locator of removed) {
+        held.rooms.delete(locator);
+        held.locking.delete(locator);
+    }
+    for (const { locator, ...room } of rooms) {
+        held.rooms.set(locator, room);
+        if (lockingMode(room.offline))
+            held.locking.add(locator);
+        else
+            held.locking.delete(locator);
+    }
+    return { log, rooms: held.rooms, locking: held.locking, queues: queued };
+}
+export function openRuntimeStore(database) {
+    let written = 0;
+    let covered = null;
+    let kept = null;
+    const authored = {
+        ask(request) {
+            if (!readsRuntime(request))
+                written += 1;
+            return database.ask(request);
+        },
+    };
+    const keys = new WeakMap();
+    const read = async (key, type) => {
+        const blob = await authored.ask({ kind: 'authored.file', key, type });
+        keys.set(blob, key);
+        return blob;
+    };
+    const restored = async (records) => Promise.all(records.map(async (record) => (await filed(JSON.parse(record), read))));
+    const amend = async (locator, id, amendment) => {
+        await authored.ask({
+            kind: 'authored.amend',
+            locator,
+            id,
+            amendment: JSON.stringify(amendment),
+        });
+    };
+    const fact = (name) => authored.ask({ kind: 'authored.fact', name });
+    const changed = new Map();
+    const change = (key) => changed.set(key, (changed.get(key) ?? 0) + 1);
+    return {
+        opened() {
+            return authored.ask({ kind: 'replica.open' });
+        },
+        async rooms(locators) {
+            const held = await authored.ask({ kind: 'replica.rooms', locators: locators ?? null });
+            return held.map(roomOf);
+        },
+        async room(locator) {
+            const { room, queue } = await authored.ask({ kind: 'replica.room', locator });
+            return {
+                room: room === null ? null : { ...roomOf(room), overlaid: new Set(room.overlaid) },
+                queue: queue.map(({ batch, state }) => ({
+                    batch: JSON.parse(batch),
+                    state: JSON.parse(state),
+                })),
+            };
+        },
+        covering() {
+            if (covered?.at === written)
+                return covered.cover;
+            const held = {
+                at: written,
+                cover: authored
+                    .ask({ kind: 'replica.covering', since: kept?.log ?? null })
+                    .then((answer) => {
+                    kept = coverOf(kept, answer);
+                    return kept;
+                }),
+            };
+            covered = held;
+            held.cover.catch(() => {
+                if (covered === held)
+                    covered = null;
+            });
+            return held.cover;
+        },
+        offline(locator) {
+            return authored.ask({ kind: 'replica.offline', locator });
+        },
+        async held() {
+            const { held, staged } = await authored.ask({ kind: 'replica.held' });
+            return { held: new Set(held), staged: new Set(staged) };
+        },
+        async status() {
+            const { queued, lastCompleted, changes, resets, returned } = await authored.ask({
+                kind: 'authored.status',
+            });
+            return {
+                queued,
+                lastCompleted: json(lastCompleted ?? undefined, null),
+                unsent: changes.map(({ locator, path }) => ({ room: locator, path })),
+                resets,
+                returned: returned.map((record) => JSON.parse(record)),
+            };
+        },
+        async batch(locator, id) {
+            const held = await authored.ask({ kind: 'authored.batch', locator, id });
+            return held === null ? null : JSON.parse(held);
+        },
+        order(locator) {
+            return authored.ask({ kind: 'authored.order', locator });
+        },
+        queued() {
+            return authored.ask({ kind: 'authored.queued' });
+        },
+        async moving() {
+            const { queues, pending } = await authored.ask({ kind: 'authored.moving' });
+            return {
+                queued: new Map(queues.map(({ locator, ids }) => [locator, ids])),
+                moving: pending.map(({ locator, batch, state }) => ({
+                    locator,
+                    batch: JSON.parse(batch),
+                    state: JSON.parse(state),
+                })),
+            };
+        },
+        async pending(locator, id) {
+            const { state, room } = await authored.ask({ kind: 'authored.pending', locator, id });
+            return { state: state === null ? undefined : JSON.parse(state), room };
+        },
+        facts: (async (names) => {
+            const held = await authored.ask({ kind: 'replica.facts', names: names ?? null });
+            return Object.fromEntries((names ?? Object.keys(UNSTATED)).map((name) => [
+                name,
+                json(held[name], UNSTATED[name]),
+            ]));
+        }),
+        async presentation(app) {
+            const held = await authored.ask({ kind: 'replica.presentation', app });
+            return held === null ? undefined : JSON.parse(held);
+        },
+        async demote() {
+            await authored.ask({ kind: 'replica.demote' });
+        },
+        query(plan, rooms, budget) {
+            return authored.ask({ kind: 'replica.query', plan, rooms, budget });
+        },
+        changes(keys) {
+            return keys.reduce((total, key) => total + (changed.get(key) ?? 0), 0);
+        },
+        entries(key, view, paths) {
+            return authored.ask({ kind: 'replica.entries', key, view, paths });
+        },
+        typed(key, view, paths) {
+            return authored.ask({ kind: 'replica.typed', key, view, paths });
+        },
+        referrers(key, view, targets) {
+            return authored.ask({ kind: 'replica.referrers', key, view, targets });
+        },
+        folders(key, paths) {
+            return authored.ask({ kind: 'replica.folders', key, paths });
+        },
+        typedWithin(key, view, roots, within) {
+            return authored.ask({ kind: 'replica.typedWithin', key, view, roots, within });
+        },
+        stage(record, composition, page) {
+            return authored.ask({
+                kind: 'replica.stage',
+                locator: record.locator,
+                transfer: record.transfer,
+                key: record.key,
+                fingerprint: composedOf(composition).fingerprint,
+                entries: page.entries,
+                folders: page.folders,
+                part: page.part ?? null,
+            });
+        },
+        resume(record, composition, parts, published) {
+            return authored.ask({
+                kind: 'replica.resume',
+                locator: record.locator,
+                transfer: record.transfer,
+                fingerprint: composedOf(composition).fingerprint,
+                parts,
+                published,
+            });
+        },
+        async refresh(key, composition, page) {
+            await authored.ask({
+                kind: 'replica.refresh',
+                key,
+                composed: composedOf(composition),
+                entries: page.entries,
+                removals: page.removals,
+                folders: page.folders,
+                folderRemovals: page.folderRemovals,
+            });
+        },
+        async unrefresh(key) {
+            await authored.ask({ kind: 'replica.unrefresh', key });
+        },
+        commit({ rooms, writes = [], files = [], whole = false }) {
+            for (const room of rooms)
+                change(room.key);
+            return authored.ask({
+                kind: 'replica.commit',
+                ...(writes.length === 0 && files.length === 0
+                    ? {}
+                    : { authored: { writes: writes.map(authoredRows), files, whole } }),
+                rooms,
+            });
+        },
+        async fence(locators) {
+            await authored.ask({ kind: 'replica.fence', locators });
+        },
+        async erase(locator, limit) {
+            return (await authored.ask({ kind: 'replica.erase', locator, limit })).remaining;
+        },
+        async abandon(locator) {
+            await authored.ask({ kind: 'replica.abandon', locator });
+        },
+        async unfence(locators) {
+            return new Set(await authored.ask({ kind: 'replica.unfence', locators }));
+        },
+        async release(key) {
+            await authored.ask({ kind: 'replica.release', key });
+        },
+        async rederive(key, composition, bytes, ms, floor) {
+            change(key);
+            return authored.ask({
+                kind: 'replica.rederive',
+                key,
+                composed: composedOf(composition),
+                bytes,
+                ms,
+                floor,
+            });
+        },
+        async fact(name, value) {
+            await authored.ask({ kind: 'replica.fact', name, value: JSON.stringify(value) });
+        },
+        submit(locator, id, submission, lost) {
+            return amend(locator, id, { submission, lost });
+        },
+        keepUpload(locator, id, upload) {
+            return amend(locator, id, { upload });
+        },
+        async roomDrafts(locator, paths) {
+            const held = await authored.ask({
+                kind: 'authored.roomDrafts',
+                locator: locator ?? null,
+                paths: paths ?? null,
+            });
+            return held.map((record) => JSON.parse(record));
+        },
+        async present(record) {
+            await authored.ask({
+                kind: 'replica.present',
+                app: record.app,
+                value: JSON.stringify(record.value ?? null),
+            });
+        },
+        conversations(conversations) {
+            return authored.ask({ kind: 'conversation.held', conversations: conversations ?? null });
+        },
+        async keepMessages(write) {
+            await authored.ask({ kind: 'conversation.keep', ...write });
+        },
+        messageWindow(conversation, limit, before, phrase = null) {
+            return authored.ask({ kind: 'conversation.window', conversation, limit, before, phrase });
+        },
+        messageCount(conversation, phrase = null) {
+            return authored.ask({ kind: 'conversation.count', conversation, phrase });
+        },
+        turnArrived(conversation, turn) {
+            return authored.ask({ kind: 'conversation.turn', conversation, turn });
+        },
+        conversationRows(conversations) {
+            return authored.ask({ kind: 'conversation.rows', conversations });
+        },
+        conversationFacts() {
+            return authored.ask({ kind: 'conversation.facts' });
+        },
+        async keepConversationFact(fact) {
+            await authored.ask({ kind: 'conversation.fact', ...fact });
+        },
+        storedConversations() {
+            return authored.ask({ kind: 'conversation.stored' });
+        },
+        dropConversations(conversations) {
+            return authored.ask({ kind: 'conversation.drop', conversations });
+        },
+        async chatDrafts() {
+            const records = await authored.ask({ kind: 'authored.chatDrafts' });
+            return records.map((record) => JSON.parse(record));
+        },
+        async chatDraft(conversation) {
+            const record = await authored.ask({ kind: 'authored.chatDraft.read', conversation });
+            return record === null ? null : JSON.parse(record);
+        },
+        async keepChatDrafts(records) {
+            await authored.ask({
+                kind: 'authored.chatDraft',
+                kept: records.map((record) => ({
+                    conversation: record.conversation,
+                    record: JSON.stringify(record),
+                })),
+                dropped: [],
+            });
+        },
+        async dropChatDraft(conversation) {
+            await authored.ask({ kind: 'authored.chatDraft', kept: [], dropped: [conversation] });
+        },
+        async calls() {
+            return restored(await authored.ask({ kind: 'authored.calls' }));
+        },
+        async keepCall(record) {
+            const { stored, ...kept } = keyed(keys, record);
+            await authored.ask({
+                kind: 'authored.call',
+                operation: record.operation,
+                kept,
+                files: stored,
+            });
+        },
+        async dropCall(operation) {
+            await authored.ask({ kind: 'authored.call', operation, kept: null, files: [] });
+        },
+        async keepRoomDraft(record, files) {
+            const { path, ...kept } = roomDraftRow(record);
+            await authored.ask({
+                kind: 'authored.roomDraft',
+                locator: record.locator,
+                path,
+                kept,
+                files,
+            });
+        },
+        async discardRoomDraft(locator, path) {
+            await authored.ask({ kind: 'authored.roomDraft', locator, path, kept: null, files: [] });
+        },
+        fences() {
+            return authored.ask({ kind: 'authored.fences' });
+        },
+        generation() {
+            return fact('generation');
+        },
+        async rememberGeneration(value) {
+            await authored.ask({ kind: 'authored.remember', name: 'generation', value });
+        },
+        file(key, type) {
+            return authored.ask({ kind: 'authored.file', key, type });
+        },
+    };
+}

package/dist/store/room-held.d.ts

@@ -0,0 +1,8 @@
+export type RoomHeld<T> = {
+    of(locator: string, key: string): T | undefined;
+    hold(locator: string, key: string, value: T): void;
+    drop(locator: string, key: string): void;
+    forget(locator: string): void;
+};
+export declare function createRoomHeld<T>(): RoomHeld<T>;
+//# sourceMappingURL=room-held.d.ts.map

package/dist/store/room-held.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"room-held.d.ts","sourceRoot":"","sources":["../../src/store/room-held.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI;IACxB,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS,CAAC;IAChD,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;IACnD,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACzC,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B,CAAC;AAEF,wBAAgB,cAAc,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAgB/C"}

package/dist/store/room-held.js

@@ -0,0 +1,17 @@
+export function createRoomHeld() {
+    const rooms = new Map();
+    return {
+        of: (locator, key) => rooms.get(locator)?.get(key),
+        hold(locator, key, value) {
+            const room = rooms.get(locator) ?? new Map();
+            room.set(key, value);
+            rooms.set(locator, room);
+        },
+        drop(locator, key) {
+            rooms.get(locator)?.delete(key);
+        },
+        forget(locator) {
+            rooms.delete(locator);
+        },
+    };
+}

package/dist/store/rooms-shown.d.ts

@@ -0,0 +1,8 @@
+import type { ListedEntry, Listing } from '../listing.js';
+export type RoomsShown = {
+    now(): Listing | null;
+    show(listing: Listing | null): void;
+    patch(entries: readonly ListedEntry[]): void;
+};
+export declare function createRoomsShown(): RoomsShown;
+//# sourceMappingURL=rooms-shown.d.ts.map

package/dist/store/rooms-shown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rooms-shown.d.ts","sourceRoot":"","sources":["../../src/store/rooms-shown.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAE1D,MAAM,MAAM,UAAU,GAAG;IACvB,GAAG,IAAI,OAAO,GAAG,IAAI,CAAC;IACtB,IAAI,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,GAAG,IAAI,CAAC;IACpC,KAAK,CAAC,OAAO,EAAE,SAAS,WAAW,EAAE,GAAG,IAAI,CAAC;CAC9C,CAAC;AAEF,wBAAgB,gBAAgB,IAAI,UAAU,CAW7C"}

package/dist/store/rooms-shown.js

@@ -0,0 +1,13 @@
+export function createRoomsShown() {
+    let shown = null;
+    return {
+        now: () => shown,
+        show(listing) {
+            shown = listing === null ? null : new Map(listing);
+        },
+        patch(entries) {
+            for (const entry of entries)
+                shown?.set(entry.locator, entry);
+        },
+    };
+}

package/dist/store/space.d.ts

@@ -0,0 +1,11 @@
+import type { RuntimeDatabase } from '../tables.js';
+export type Space = {
+    full(): boolean;
+    fill(): boolean;
+    probing(): boolean;
+    probeEachMinute(): void;
+    probe(): Promise<void>;
+    stop(): void;
+};
+export declare function createSpace(database: RuntimeDatabase, freed: () => void): Space;
+//# sourceMappingURL=space.d.ts.map

package/dist/store/space.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"space.d.ts","sourceRoot":"","sources":["../../src/store/space.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAEpD,MAAM,MAAM,KAAK,GAAG;IAClB,IAAI,IAAI,OAAO,CAAC;IAChB,IAAI,IAAI,OAAO,CAAC;IAChB,OAAO,IAAI,OAAO,CAAC;IACnB,eAAe,IAAI,IAAI,CAAC;IACxB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,IAAI,IAAI,IAAI,CAAC;CACd,CAAC;AAEF,wBAAgB,WAAW,CAAC,QAAQ,EAAE,eAAe,EAAE,KAAK,EAAE,MAAM,IAAI,GAAG,KAAK,CA0C/E"}

package/dist/store/space.js

@@ -0,0 +1,41 @@
+export function createSpace(database, freed) {
+    let full = false;
+    let probing = null;
+    let testing = null;
+    function probe() {
+        testing ??= database.ask({ kind: 'space.probe' }).then(() => {
+            testing = null;
+            if (full) {
+                full = false;
+                if (probing !== null)
+                    clearInterval(probing);
+                probing = null;
+                freed();
+            }
+        }, () => {
+            testing = null;
+        });
+        return testing;
+    }
+    return {
+        full: () => full,
+        fill() {
+            if (full)
+                return false;
+            full = true;
+            return true;
+        },
+        probing: () => probing !== null,
+        probeEachMinute() {
+            // A device whose storage filled after its install tries a write each minute, so space freed elsewhere ends its read-only mode without a Retry.
+            probing = setInterval(() => {
+                void probe();
+            }, 60_000);
+        },
+        probe,
+        stop() {
+            if (probing !== null)
+                clearInterval(probing);
+        },
+    };
+}

package/dist/store/watchers.d.ts

@@ -0,0 +1,17 @@
+export type Watcher = {
+    held(): boolean;
+    stop(): void;
+    answer(value: unknown): void;
+};
+export type Watching = 'all' | 'waiting' | 'ready';
+type Watchers = {
+    publication(work: () => Promise<void>): Promise<void>;
+    owing<T>(topic: string, add: (owed: T | undefined) => T, work: (owed: T) => Promise<void>): Promise<void>;
+    watch(topic: string, notify: (value: unknown) => void): Watcher;
+    watching(topic: string, which?: Watching): readonly Watcher[];
+    tell(topic: string, value: unknown): void;
+    close(): void;
+};
+export declare function createWatchers(unpublished: (error: unknown) => void): Watchers;
+export {};
+//# sourceMappingURL=watchers.d.ts.map

package/dist/store/watchers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"watchers.d.ts","sourceRoot":"","sources":["../../src/store/watchers.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,OAAO,GAAG;IACpB,IAAI,IAAI,OAAO,CAAC;IAChB,IAAI,IAAI,IAAI,CAAC;IACb,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG,KAAK,GAAG,SAAS,GAAG,OAAO,CAAC;AAMnD,KAAK,QAAQ,GAAG;IACd,WAAW,CAAC,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACtD,KAAK,CAAC,CAAC,EACL,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,CAAC,IAAI,EAAE,CAAC,GAAG,SAAS,KAAK,CAAC,EAC/B,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,GAC/B,OAAO,CAAC,IAAI,CAAC,CAAC;IACjB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GAAG,OAAO,CAAC;IAChE,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,QAAQ,GAAG,SAAS,OAAO,EAAE,CAAC;IAC9D,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;IAC1C,KAAK,IAAI,IAAI,CAAC;CACf,CAAC;AAEF,wBAAgB,cAAc,CAAC,WAAW,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GAAG,QAAQ,CA6D9E"}

package/dist/store/watchers.js

@@ -0,0 +1,56 @@
+export function createWatchers(unpublished) {
+    let published = Promise.resolve();
+    const topics = new Map();
+    const owed = new Map();
+    function publication(work) {
+        published = published.then(work).catch(unpublished);
+        return published;
+    }
+    return {
+        publication,
+        owing(topic, add, work) {
+            const held = owed.get(topic);
+            if (held !== undefined) {
+                held.value = add(held.value);
+                return held.shown;
+            }
+            const owing = { value: add(undefined), shown: Promise.resolve() };
+            owed.set(topic, owing);
+            owing.shown = publication(async () => {
+                owed.delete(topic);
+                await work(owing.value);
+            });
+            return owing.shown;
+        },
+        watch(topic, notify) {
+            const held = topics.get(topic) ?? new Set();
+            topics.set(topic, held);
+            const watcher = {
+                ready: false,
+                held: () => topics.get(topic)?.has(watcher) === true,
+                stop() {
+                    const on = topics.get(topic);
+                    on?.delete(watcher);
+                    if (on?.size === 0)
+                        topics.delete(topic);
+                },
+                answer(value) {
+                    watcher.ready = true;
+                    notify(value);
+                },
+            };
+            held.add(watcher);
+            return watcher;
+        },
+        watching(topic, which = 'all') {
+            return [...(topics.get(topic) ?? [])].filter(({ ready }) => which === 'all' || ready === (which === 'ready'));
+        },
+        tell(topic, value) {
+            for (const watcher of topics.get(topic) ?? [])
+                watcher.answer(value);
+        },
+        close() {
+            topics.clear();
+        },
+    };
+}

package/dist/store/writes.d.ts

@@ -0,0 +1,24 @@
+import type { Composition } from '../collection.js';
+import type { RefreshedPage, RuntimeStore } from './records.js';
+export type InstallHold = {
+    take(): void;
+    release(): void;
+};
+type Writes = {
+    exclusive<T>(work: () => Promise<T>): Promise<T>;
+    gathered<I, T>(key: string, input: I, merge: (earlier: I, later: I) => I | null, work: (input: I) => Promise<T>): Promise<T>;
+    written(): Promise<unknown>;
+    startingWrite<T>(work: () => Promise<T>): Promise<T>;
+    finishingWrite<T>(work: () => Promise<T>): Promise<T>;
+    ahead<T>(work: (hold: InstallHold) => Promise<T>): Promise<T>;
+    rederive(local: RuntimeStore, key: number, composition: Composition): Promise<{
+        readonly done: boolean;
+        readonly text: number;
+    }>;
+    refreshPage(local: RuntimeStore, key: number, composition: Composition, page: RefreshedPage): Promise<void>;
+    stageBytes(): number;
+    deriveBytes(): number;
+};
+export declare function createWrites(): Writes;
+export {};
+//# sourceMappingURL=writes.d.ts.map