@agentshouse/mdruntime 0.1.0-ca7c26c6bc27e → 0.1.0-ca8707258fdde

package/dist/store.js

@@ -1,395 +1,124 @@
-import { sameChange } from './overlay.js';
-const DATABASE = 'mdruntime';
-const ROOMS = 'rooms';
-const DOCUMENTS = 'documents';
-const BINARY_TARGETS = 'binaryTargets';
-const ATTACHMENTS = 'attachments';
-const PENDING_CHANGES = 'pendingChanges';
-const DECLARATIONS = 'declarations';
-const ROOM_DRAFTS = 'roomDrafts';
-const PRESENTATION = 'presentation';
-const CONVERSATIONS = 'conversations';
-const MESSAGES = 'messages';
-const CHAT_DRAFTS = 'chatDrafts';
-const CURRENT = 'current';
-const SCHEMA = 20;
-function settled(request) {
-    return new Promise((resolve, reject) => {
-        request.onsuccess = () => resolve(request.result);
-        request.onerror = () => reject(request.error);
-    });
-}
-function completed(transaction) {
-    return new Promise((resolve, reject) => {
-        transaction.oncomplete = () => resolve();
-        transaction.onerror = () => reject(transaction.error);
-        transaction.onabort = () => reject(transaction.error);
-    });
-}
-const EMPTY_DECLARATIONS = {
-    lastCompleted: null,
-    generation: null,
-    providerLimits: [],
-    capabilities: [],
-};
-function declaration(database) {
-    const transaction = database.transaction(DECLARATIONS, 'readonly');
-    return settled(transaction.objectStore(DECLARATIONS).get(CURRENT)).then((record) => record ?? EMPTY_DECLARATIONS);
-}
-function updateDeclaration(database, update) {
-    const transaction = database.transaction(DECLARATIONS, 'readwrite');
-    const store = transaction.objectStore(DECLARATIONS);
-    const prior = store.get(CURRENT);
-    prior.onsuccess = () => {
-        store.put(update(prior.result ?? EMPTY_DECLARATIONS), CURRENT);
-    };
-    return completed(transaction);
-}
-function amendPending(database, locator, id, amendment) {
-    const transaction = database.transaction(PENDING_CHANGES, 'readwrite');
-    const pending = transaction.objectStore(PENDING_CHANGES);
-    const request = pending.get([locator, id]);
-    request.onsuccess = () => {
-        const record = request.result;
-        if (record !== undefined)
-            pending.put({ ...record, ...amendment });
-    };
-    return completed(transaction);
-}
-function roomRecord(record, queue) {
-    const { documents, binaryTargets, revisions, changes, written, attachments, ...room } = record;
-    return { ...room, order: queue.map((batch) => batch.id) };
-}
-function removeRoomEntries(store, locator) {
-    const keys = store.getAllKeys();
-    keys.onsuccess = () => {
-        for (const key of keys.result) {
-            if (Array.isArray(key) && key[0] === locator)
-                store.delete(key);
-        }
-    };
-}
-export function removeRuntimeStore() {
-    return new Promise((resolve, reject) => {
-        const removal = indexedDB.deleteDatabase(DATABASE);
-        removal.onsuccess = () => resolve();
-        removal.onerror = () => reject(removal.error);
-    });
-}
-export async function openRuntimeStore() {
-    const opening = indexedDB.open(DATABASE, SCHEMA);
-    opening.onupgradeneeded = () => {
-        const database = opening.result;
-        for (const name of [...database.objectStoreNames])
-            database.deleteObjectStore(name);
-        database.createObjectStore(ROOMS, { keyPath: 'locator' });
-        database.createObjectStore(DOCUMENTS, { keyPath: ['locator', 'path'] });
-        database.createObjectStore(BINARY_TARGETS, { keyPath: ['locator', 'path'] });
-        database.createObjectStore(ATTACHMENTS, { keyPath: ['locator', 'reference'] });
-        database.createObjectStore(PENDING_CHANGES, { keyPath: ['locator', 'id'] });
-        database.createObjectStore(DECLARATIONS);
-        database.createObjectStore(ROOM_DRAFTS, { keyPath: ['locator', 'path'] });
-        database.createObjectStore(PRESENTATION, { keyPath: 'app' });
-        database.createObjectStore(CONVERSATIONS, { keyPath: 'conversation' });
-        const messages = database.createObjectStore(MESSAGES, {
-            keyPath: ['conversation', 'identity'],
+import { schemaTypes } from './attached-model.js';
+import { openedFiles } from './opened.js';
+import { compositionOf } from './replica.js';
+import { createFences } from './store/fences.js';
+import { createInstalls } from './store/installs.js';
+import { openRuntimeStore, } from './store/records.js';
+import { createRoomHeld } from './store/room-held.js';
+import { createWatchers } from './store/watchers.js';
+import { createWrites } from './store/writes.js';
+export { NO_INSTALL } from './store/installs.js';
+export function createStore(options) {
+    const writes = createWrites();
+    const watchers = createWatchers(options.unpublished);
+    const fences = createFences();
+    const installs = createInstalls();
+    const seeds = new Map();
+    const landed = createRoomHeld();
+    const attached = createRoomHeld();
+    const typesHeld = new Map();
+    let opening;
+    function open() {
+        opening ??= options.opening(openRuntimeStore(options.database)).catch((error) => {
+            opening = undefined;
+            throw error;
         });
-        messages.createIndex('conversation', 'conversation');
-        database.createObjectStore(CHAT_DRAFTS, { keyPath: 'conversation' });
-    };
-    const database = await settled(opening);
+        return opening;
+    }
+    function typed(locator, persisted) {
+        if (persisted.status === 'unavailable')
+            return persisted;
+        const schema = persisted.snapshot.schema;
+        const held = typesHeld.get(locator);
+        if (held !== undefined && held.schema === schema)
+            return { ...persisted, types: held.types };
+        const types = schemaTypes(schema, options.roomTypes);
+        typesHeld.set(locator, { schema, types });
+        return { ...persisted, types };
+    }
+    function recordOf(stored) {
+        return { ...stored, model: typed(stored.locator, stored.model) };
+    }
+    async function rooms(locators) {
+        const held = await (await open()).rooms(locators);
+        return new Map(held
+            .filter(({ record }) => !fences.has(record.locator))
+            .map(({ record, indexed, documents }) => [
+            record.locator,
+            { record: recordOf(record), indexed, documents },
+        ]));
+    }
+    async function work(locator) {
+        if (fences.has(locator))
+            return { replica: undefined, queue: [], states: new Map() };
+        const { room, queue } = await (await open()).room(locator);
+        const batches = queue.map(({ batch }) => batch);
+        const states = new Map(queue.map(({ batch, state }) => [batch.id, state]));
+        return {
+            replica: room === null
+                ? undefined
+                : { record: recordOf(room.record), queue: batches, states, overlaid: room.overlaid },
+            queue: batches,
+            states,
+        };
+    }
+    async function drafts(locator, paths) {
+        const held = await (await open()).roomDrafts(locator, paths);
+        return held.filter((record) => !fences.has(record.locator));
+    }
     return {
-        async all() {
-            const transaction = database.transaction([ROOMS, DOCUMENTS, BINARY_TARGETS, ATTACHMENTS], 'readonly');
-            const [rooms, documents, targets, attachments] = await Promise.all([
-                settled(transaction.objectStore(ROOMS).getAll()),
-                settled(transaction.objectStore(DOCUMENTS).getAll()),
-                settled(transaction.objectStore(BINARY_TARGETS).getAll()),
-                settled(transaction.objectStore(ATTACHMENTS).getAll()),
-            ]);
-            const byRoom = new Map();
-            for (const { order, ...room } of rooms) {
-                byRoom.set(room.locator, {
-                    ...room,
-                    documents: {},
-                    revisions: {},
-                    changes: {},
-                    written: {},
-                    binaryTargets: [],
-                    attachments: [],
-                });
-            }
-            const head = (room, held) => {
-                if (held.revision !== null) {
-                    room.revisions[held.path] = held.revision;
-                }
-                if (held.change !== null) {
-                    room.changes[held.path] = held.change;
-                }
+        open,
+        durably: (work) => writes.exclusive(async () => {
+            const local = await open();
+            return work(local);
+        }),
+        exclusive: writes.exclusive,
+        gathered: writes.gathered,
+        written: writes.written,
+        startingWrite: writes.startingWrite,
+        finishingWrite: writes.finishingWrite,
+        ahead: writes.ahead,
+        rederive: writes.rederive,
+        refreshPage: writes.refreshPage,
+        stageBytes: writes.stageBytes,
+        deriveBytes: writes.deriveBytes,
+        rooms,
+        record: async (locator) => (await rooms([locator])).get(locator)?.record,
+        work,
+        replica: async (locator) => (await work(locator)).replica,
+        async covering() {
+            const held = await (await open()).covering();
+            return {
+                rooms: new Map([...held.rooms].filter(([locator]) => !fences.has(locator))),
+                queues: new Map([...held.queues].filter(([locator]) => !fences.has(locator))),
             };
-            for (const document of documents) {
-                const room = byRoom.get(document.locator);
-                if (room === undefined)
-                    continue;
-                room.documents[document.path] = document.content;
-                if (document.written !== null) {
-                    room.written[document.path] = document.written;
-                }
-                head(room, document);
-            }
-            for (const target of targets) {
-                const room = byRoom.get(target.locator);
-                if (room === undefined)
-                    continue;
-                room.binaryTargets.push(target.path);
-                head(room, target);
-            }
-            for (const { locator, ...attachment } of attachments) {
-                const room = byRoom.get(locator);
-                if (room === undefined)
-                    continue;
-                room.attachments.push(attachment);
-            }
-            return [...byRoom.values()];
-        },
-        async write({ next, previous, queue, previousQueue, saved, roomDrafts, consumedRoomDrafts }) {
-            const transaction = database.transaction([ROOMS, DOCUMENTS, BINARY_TARGETS, ATTACHMENTS, PENDING_CHANGES, ROOM_DRAFTS], 'readwrite');
-            transaction.objectStore(ROOMS).put(roomRecord(next, queue));
-            const documents = transaction.objectStore(DOCUMENTS);
-            for (const path of Object.keys(previous?.documents ?? {})) {
-                if (next.documents[path] === undefined)
-                    documents.delete([next.locator, path]);
-            }
-            for (const [path, content] of Object.entries(next.documents)) {
-                if (previous?.documents[path] === content &&
-                    previous.revisions[path] === next.revisions[path] &&
-                    previous.written[path] === next.written[path] &&
-                    sameChange(previous.changes[path], next.changes[path]))
-                    continue;
-                documents.put({
-                    locator: next.locator,
-                    path,
-                    content,
-                    revision: next.revisions[path] ?? null,
-                    change: next.changes[path] ?? null,
-                    written: next.written[path] ?? null,
-                });
-            }
-            const targets = transaction.objectStore(BINARY_TARGETS);
-            const beforeTargets = new Set(previous?.binaryTargets ?? []);
-            const afterTargets = new Set(next.binaryTargets);
-            for (const path of beforeTargets) {
-                if (!afterTargets.has(path))
-                    targets.delete([next.locator, path]);
-            }
-            for (const path of afterTargets) {
-                if (!beforeTargets.has(path) ||
-                    previous?.revisions[path] !== next.revisions[path] ||
-                    !sameChange(previous?.changes[path], next.changes[path])) {
-                    targets.put({
-                        locator: next.locator,
-                        path,
-                        revision: next.revisions[path] ?? null,
-                        change: next.changes[path] ?? null,
-                    });
-                }
-            }
-            const attachments = transaction.objectStore(ATTACHMENTS);
-            const held = new Map((previous?.attachments ?? []).map((attachment) => [attachment.reference, attachment]));
-            const declared = new Set(next.attachments.map((attachment) => attachment.reference));
-            for (const reference of held.keys()) {
-                if (!declared.has(reference))
-                    attachments.delete([next.locator, reference]);
-            }
-            for (const attachment of next.attachments) {
-                if (held.get(attachment.reference) === attachment)
-                    continue;
-                attachments.put({ ...attachment, locator: next.locator });
-            }
-            if (previousQueue !== undefined) {
-                const pending = transaction.objectStore(PENDING_CHANGES);
-                const before = new Set(previousQueue.map((batch) => batch.id));
-                const after = new Set(queue.map((batch) => batch.id));
-                for (const id of before) {
-                    if (!after.has(id))
-                        pending.delete([next.locator, id]);
-                }
-                for (const batch of queue) {
-                    if (!before.has(batch.id)) {
-                        pending.put({
-                            locator: next.locator,
-                            id: batch.id,
-                            batch,
-                            drafts: saved ?? [],
-                            submission: { state: 'waiting' },
-                            lost: false,
-                        });
-                    }
-                }
-            }
-            const draftStore = transaction.objectStore(ROOM_DRAFTS);
-            for (const path of consumedRoomDrafts ?? [])
-                draftStore.delete([next.locator, path]);
-            for (const record of roomDrafts ?? [])
-                draftStore.put(record);
-            await completed(transaction);
-        },
-        async revokeModels(records) {
-            const transaction = database.transaction(ROOMS, 'readwrite');
-            const rooms = transaction.objectStore(ROOMS);
-            const revoked = { status: 'unavailable', reason: 'revoked' };
-            for (const { record, queue } of records) {
-                rooms.put(roomRecord({ ...record, model: revoked, selectionModel: revoked }, queue));
-            }
-            await completed(transaction);
-        },
-        async lastCompleted() {
-            return (await declaration(database)).lastCompleted;
-        },
-        complete(at) {
-            return updateDeclaration(database, (record) => ({ ...record, lastCompleted: at }));
-        },
-        async providerLimits() {
-            return (await declaration(database)).providerLimits;
-        },
-        async capabilities() {
-            return (await declaration(database)).capabilities;
-        },
-        declare(limits, capabilities) {
-            return updateDeclaration(database, (record) => ({
-                ...record,
-                providerLimits: limits,
-                capabilities,
-            }));
-        },
-        async queues() {
-            const transaction = database.transaction([ROOMS, PENDING_CHANGES], 'readonly');
-            const [rooms, pending] = await Promise.all([
-                settled(transaction.objectStore(ROOMS).getAll()),
-                settled(transaction.objectStore(PENDING_CHANGES).getAll()),
-            ]);
-            const byId = new Map(pending.map((record) => [`${record.locator}\0${record.id}`, record]));
-            return rooms.map((room) => ({
-                locator: room.locator,
-                pending: room.order.map((id) => {
-                    const record = byId.get(`${room.locator}\0${id}`);
-                    if (record === undefined)
-                        throw new Error(`Missing Pending Change ${room.locator}/${id}`);
-                    const { batch, drafts, submission, lost, upload, accepted } = record;
-                    return { batch, state: { drafts, submission, lost, upload, accepted } };
-                }),
-            }));
-        },
-        submit(locator, id, submission, lost) {
-            return amendPending(database, locator, id, { submission, lost });
-        },
-        accept(locator, id, roomVersion) {
-            return amendPending(database, locator, id, { accepted: roomVersion });
-        },
-        keepUpload(locator, id, upload) {
-            return amendPending(database, locator, id, { upload });
-        },
-        async roomDrafts() {
-            const transaction = database.transaction(ROOM_DRAFTS, 'readonly');
-            return settled(transaction.objectStore(ROOM_DRAFTS).getAll());
-        },
-        async presentation() {
-            const transaction = database.transaction(PRESENTATION, 'readonly');
-            return settled(transaction.objectStore(PRESENTATION).getAll());
-        },
-        async present(record) {
-            const transaction = database.transaction(PRESENTATION, 'readwrite');
-            transaction.objectStore(PRESENTATION).put(record);
-            await completed(transaction);
-        },
-        async conversations() {
-            const transaction = database.transaction([CONVERSATIONS, MESSAGES], 'readonly');
-            const [reads, messages] = await Promise.all([
-                settled(transaction.objectStore(CONVERSATIONS).getAll()),
-                settled(transaction.objectStore(MESSAGES).getAll()),
-            ]);
-            const held = new Map();
-            for (const { conversation, read } of reads) {
-                held.set(conversation, { conversation, read, messages: [] });
-            }
-            for (const { conversation, ...message } of messages) {
-                const entry = held.get(conversation) ?? { conversation, read: undefined, messages: [] };
-                entry.messages.push(message);
-                held.set(conversation, entry);
-            }
-            return [...held.values()];
-        },
-        async keepMessages({ conversation, messages, read, sealed }) {
-            const transaction = database.transaction([CONVERSATIONS, MESSAGES, CHAT_DRAFTS], 'readwrite');
-            const stored = transaction.objectStore(MESSAGES);
-            for (const message of messages) {
-                stored.put({ ...message, conversation });
-            }
-            if (read !== undefined) {
-                transaction
-                    .objectStore(CONVERSATIONS)
-                    .put({ conversation, read });
-            }
-            if (sealed === true)
-                transaction.objectStore(CHAT_DRAFTS).delete(conversation);
-            await completed(transaction);
-        },
-        async dropConversations(conversations) {
-            const transaction = database.transaction([CONVERSATIONS, MESSAGES, CHAT_DRAFTS], 'readwrite');
-            const messages = transaction.objectStore(MESSAGES);
-            for (const conversation of conversations) {
-                transaction.objectStore(CONVERSATIONS).delete(conversation);
-                transaction.objectStore(CHAT_DRAFTS).delete(conversation);
-                const keys = messages.index('conversation').getAllKeys(conversation);
-                keys.onsuccess = () => {
-                    for (const key of keys.result)
-                        messages.delete(key);
-                };
-            }
-            await completed(transaction);
-        },
-        async chatDrafts() {
-            const transaction = database.transaction(CHAT_DRAFTS, 'readonly');
-            return settled(transaction.objectStore(CHAT_DRAFTS).getAll());
-        },
-        async keepChatDraft(record) {
-            const transaction = database.transaction(CHAT_DRAFTS, 'readwrite');
-            transaction.objectStore(CHAT_DRAFTS).put(record);
-            await completed(transaction);
-        },
-        async dropChatDraft(conversation) {
-            const transaction = database.transaction(CHAT_DRAFTS, 'readwrite');
-            transaction.objectStore(CHAT_DRAFTS).delete(conversation);
-            await completed(transaction);
-        },
-        async keepRoomDraft(record) {
-            const transaction = database.transaction(ROOM_DRAFTS, 'readwrite');
-            transaction.objectStore(ROOM_DRAFTS).put(record);
-            await completed(transaction);
-        },
-        async discardRoomDraft(locator, path) {
-            const transaction = database.transaction(ROOM_DRAFTS, 'readwrite');
-            transaction.objectStore(ROOM_DRAFTS).delete([locator, path]);
-            await completed(transaction);
-        },
-        async dropRooms(locators) {
-            const transaction = database.transaction([ROOMS, DOCUMENTS, BINARY_TARGETS, ATTACHMENTS, PENDING_CHANGES, ROOM_DRAFTS], 'readwrite');
-            for (const locator of locators) {
-                transaction.objectStore(ROOMS).delete(locator);
-                for (const name of [DOCUMENTS, BINARY_TARGETS, ATTACHMENTS, PENDING_CHANGES, ROOM_DRAFTS]) {
-                    removeRoomEntries(transaction.objectStore(name), locator);
-                }
-            }
-            await completed(transaction);
-        },
-        async generation() {
-            return (await declaration(database)).generation;
-        },
-        rememberGeneration(value) {
-            return updateDeclaration(database, (record) => ({ ...record, generation: value }));
-        },
-        close() {
-            database.close();
         },
+        drafts,
+        draft: async (locator, path) => (await drafts(locator, [path]))[0],
+        composed: (record) => compositionOf(record, options.builtIn, options.typedPaths),
+        publication: watchers.publication,
+        watch: watchers.watch,
+        watching: watchers.watching,
+        fences,
+        installs,
+        seeds: {
+            of: (key) => seeds.get(key),
+            keep(key, seed) {
+                seeds.set(key, seed);
+            },
+            drop(key) {
+                seeds.delete(key);
+            },
+        },
+        landed,
+        attached,
+        opened: openedFiles(options.database, fences.has),
+        part: (file, part) => options.database.ask({ kind: 'file.part', key: file, part }),
+        forget(locator) {
+            typesHeld.delete(locator);
+            landed.forget(locator);
+            attached.forget(locator);
+        },
+        close: watchers.close,
     };
 }

package/dist/stored.d.ts

@@ -0,0 +1,156 @@
+import type { SavedFacts, HeadChange } from './adapter.js';
+import { type Composed, type Composition } from './collection.js';
+import type { HeldBinary } from './overlay.js';
+import type { Connection } from './tables.js';
+export declare const REPLICA_TABLES: readonly string[];
+export type View = 'confirmed' | 'visible' | 'refreshed';
+export type StoredEntry = {
+    readonly path: string;
+    readonly content: string | null;
+    readonly binary: HeldBinary | null;
+    readonly revision: string | null;
+    readonly fileId: string | null;
+    readonly created: string | null;
+    readonly change: HeadChange | null;
+    readonly written: string | null;
+    readonly facts: SavedFacts | null;
+};
+export type OverlayEntry = StoredEntry & {
+    readonly present: boolean;
+};
+export type HeldEntry = StoredEntry & {
+    readonly type: string | null;
+};
+export type TypedEntry = {
+    readonly path: string;
+    readonly type: string | null;
+    readonly binary: boolean;
+};
+export type Referrer = {
+    readonly path: string;
+    readonly target: string;
+};
+export type HeldRoomRow = {
+    readonly locator: string;
+    readonly key: number;
+    readonly record: string;
+    readonly indexed: boolean;
+    readonly documents: number;
+};
+export type HeldRoomWork = {
+    readonly room: (HeldRoomRow & {
+        readonly overlaid: readonly string[];
+    }) | null;
+    readonly queue: readonly {
+        readonly id: string;
+        readonly batch: string;
+        readonly state: string;
+    }[];
+};
+export type Covering = {
+    readonly rooms: readonly {
+        readonly locator: string;
+        readonly key: number;
+        readonly transfer: string;
+        readonly roomVersion: string;
+        readonly indexed: boolean;
+        readonly documents: number;
+        readonly bytes: number;
+        readonly offline: string;
+    }[];
+    readonly queues: readonly {
+        readonly locator: string;
+        readonly ids: readonly string[];
+    }[];
+};
+export type HeldLocators = {
+    readonly held: readonly string[];
+    readonly staged: readonly string[];
+};
+export type ReplicaOpened = {
+    readonly erasing: boolean;
+    readonly orphans: readonly number[];
+};
+export type RoomCommit = {
+    readonly locator: string;
+    readonly key: number;
+    readonly record?: string;
+    readonly roots?: readonly string[];
+    readonly published?: {
+        readonly from: number | null;
+    };
+    readonly refreshed?: true;
+    readonly composed: Composed;
+    readonly confirmed?: {
+        readonly set: readonly StoredEntry[];
+        readonly removed: readonly string[];
+    };
+    readonly overlay?: {
+        readonly set: readonly OverlayEntry[];
+        readonly cleared: readonly string[];
+    };
+};
+export type Committed = {
+    readonly changed: Readonly<Record<string, readonly string[] | null>>;
+    readonly indexed: Readonly<Record<string, boolean>>;
+};
+export declare function entered(connection: Connection, locator: string, composition: Composition, rows: readonly StoredEntry[]): number;
+export declare function stage(connection: Connection, request: {
+    readonly locator: string;
+    readonly transfer: string;
+    readonly key: number | null;
+    readonly fingerprint: string;
+    readonly entries: readonly StoredEntry[];
+    readonly folders: readonly string[];
+    readonly part: string | null;
+}): number;
+export type Resumed = {
+    readonly key: number | null;
+    readonly transfer: string;
+    readonly staged: readonly string[];
+};
+export declare function resume(connection: Connection, request: {
+    readonly locator: string;
+    readonly transfer: string;
+    readonly fingerprint: string;
+    readonly parts: readonly string[];
+    readonly published: number | null;
+}): Resumed;
+export declare function refreshing(connection: Connection, request: {
+    readonly key: number;
+    readonly composed: Composed;
+    readonly entries: readonly StoredEntry[];
+    readonly removals: readonly string[];
+    readonly folders: readonly string[];
+    readonly folderRemovals: readonly string[];
+}): null;
+export declare function unrefresh(connection: Connection, key: number): null;
+export declare function commit(connection: Connection, rooms: readonly RoomCommit[]): Committed;
+export declare function fenceRooms(connection: Connection, locators: readonly string[]): null;
+export declare function abandon(connection: Connection, locator: string): null;
+export declare function release(connection: Connection, key: number): null;
+export declare function erase(connection: Connection, locator: string | null, limit: number): {
+    readonly remaining: boolean;
+};
+export declare function rederive(connection: Connection, key: number, composed: Composed, bytes: number, ms: number, floor: number): {
+    readonly done: boolean;
+    readonly text: number;
+};
+export declare function entries(connection: Connection, key: number, view: View, list: readonly string[]): HeldEntry[];
+export declare function typed(connection: Connection, key: number, view: View, list: readonly string[]): TypedEntry[];
+export declare function referrers(connection: Connection, key: number, view: View, targets: readonly string[]): Referrer[];
+export declare function folders(connection: Connection, key: number, view: View, list: readonly string[]): string[];
+export declare function typedWithin(connection: Connection, key: number, view: View, roots: readonly string[], within: boolean): boolean;
+export declare function opened(connection: Connection): ReplicaOpened;
+export declare function heldRooms(connection: Connection, locators: readonly string[] | null): readonly HeldRoomRow[];
+export declare function heldRoom(connection: Connection, locator: string): HeldRoomRow | null;
+export declare function overlaid(connection: Connection, key: number): readonly string[];
+export declare function covering(connection: Connection): Covering['rooms'];
+export declare function offlineMode(connection: Connection, locator: string): string | null;
+export declare function stagedLocators(connection: Connection): readonly string[];
+export declare function heldLocators(connection: Connection): readonly string[];
+export declare function demoted(connection: Connection): null;
+export declare function facts(connection: Connection): Readonly<Record<string, string>>;
+export declare function presentation(connection: Connection, app: string): string | null;
+export declare function ended(connection: Connection): void;
+//# sourceMappingURL=stored.d.ts.map