@agentshouse/app-bridge 0.1.0-ccf413b4e709d → 0.1.0-cd2d3edbf9805

package/dist/mdruntime/replica.d.ts

@@ -0,0 +1,67 @@
+import type { BootstrapInventory, MutationResult, OperationScopes, ReplicaAdmission, TypedSelection } from './adapter.js';
+import { type ChangeBatch, type Precondition } from './change.js';
+import { type Collection, type Composition } from './collection.js';
+import { type ModelState } from './model.js';
+import { type Layer } from './overlay.js';
+import type { HeldEntry, OverlayEntry, StoredEntry } from './tables.js';
+export type ReplicaRecord = {
+    readonly locator: string;
+    readonly name: string;
+    readonly handle: string;
+    readonly operations: OperationScopes;
+    readonly replica: ReplicaAdmission;
+    readonly model: ModelState;
+    readonly typedSelection: TypedSelection | null;
+    readonly providerOwnedPaths: readonly string[];
+    readonly roomVersion: string;
+    readonly transfer: string;
+    readonly inventory: BootstrapInventory;
+    readonly key: number;
+};
+export type HeldReplica = {
+    readonly record: ReplicaRecord;
+    readonly queue: readonly ChangeBatch[];
+    readonly overlaid: ReadonlySet<string>;
+    readonly count: number;
+    readonly confirmed: number;
+    readonly indexed: boolean;
+};
+export type VisibleLayer = Layer & {
+    readonly collection: Collection;
+};
+export type Slice = Layer & {
+    readonly written: Readonly<Record<string, string>>;
+    readonly held: ReadonlySet<string>;
+};
+export declare function compositionOf(record: Pick<ReplicaRecord, 'model' | 'typedSelection'>, builtIn: ModelState): Composition;
+export declare function storedRecord(record: ReplicaRecord): string;
+export declare function slicing(entries: readonly HeldEntry[], paths: Iterable<string>): Generator<number, Slice, void>;
+export declare function entryAt(layer: Layer & {
+    readonly written?: Readonly<Record<string, string>>;
+}, path: string): StoredEntry | null;
+export declare function slicingWith(slice: Slice, set: readonly StoredEntry[], removed: readonly string[]): Generator<number, Slice, void>;
+export declare function touchedBy(queue: readonly ChangeBatch[]): Set<string>;
+export declare function movedBy(queue: readonly ChangeBatch[], locator: string): Set<string>;
+export type Replayed = {
+    readonly visible: VisibleLayer;
+    readonly touched: ReadonlySet<string>;
+};
+export declare function replaying(confirmed: Slice, queue: readonly ChangeBatch[], locator: string, composition: Composition): Generator<number, Replayed, void>;
+export declare function overlayOf(visible: Layer, touched: Iterable<string>): Generator<number, OverlayEntry[], void>;
+export declare function holds(layer: Layer, preconditions: readonly Precondition[]): boolean;
+export declare function landed(batch: ChangeBatch, confirmed: Layer, current?: Readonly<Record<string, string>>): boolean;
+export type Standing = {
+    readonly withdrawn: readonly ChangeBatch[];
+    readonly kept: readonly ChangeBatch[];
+};
+export declare function standing(confirmed: Slice, queue: readonly ChangeBatch[], withdrawable: (batch: ChangeBatch) => boolean, local: boolean, locator: string, composition: Composition): Generator<number, Standing, void>;
+type Accepted = Extract<MutationResult, {
+    kind: 'accepted';
+}>;
+export type Returned = {
+    readonly set: readonly StoredEntry[];
+    readonly removed: readonly string[];
+};
+export declare function returnedPaths(submitted: ChangeBatch, accepted: Accepted): Set<string>;
+export declare function returning(confirmed: Slice, submitted: ChangeBatch, accepted: Accepted, writtenAt: string): Generator<number, Returned, void>;
+export {};

package/dist/mdruntime/room-draft.d.ts

@@ -0,0 +1,173 @@
+import type { ProviderRefusal } from './adapter.js';
+import type { Open } from './open.js';
+import type { Change, Precondition } from './change.js';
+import type { VisibleLayer } from './replica.js';
+export type FieldValue = {
+    readonly value: unknown;
+} | null;
+export type RoomDraftCreation = {
+    readonly type: string;
+    readonly fields: Readonly<Record<string, unknown>>;
+    readonly sections: Readonly<Record<string, string>>;
+} | {
+    readonly markdown: string;
+};
+export type RoomDraftParts = {
+    readonly fields?: Readonly<Record<string, {
+        readonly value: unknown;
+        readonly base?: FieldValue;
+    }>>;
+    readonly sections?: Readonly<Record<string, {
+        readonly value: string;
+        readonly base?: string;
+    }>>;
+    readonly preamble?: {
+        readonly value: string;
+        readonly base?: string;
+    };
+    readonly markdown?: {
+        readonly value: string;
+        readonly base?: string;
+    };
+    readonly creation?: RoomDraftCreation;
+    readonly move?: {
+        readonly to: string;
+        readonly room?: string;
+        readonly base?: string | null;
+    };
+    readonly removal?: {
+        readonly base?: string | null;
+    };
+    readonly file?: {
+        readonly blob: Blob;
+        readonly base?: string | null;
+    };
+};
+export type HeldFile = {
+    readonly localId: string;
+    readonly name?: string;
+    readonly byteLength: number;
+    readonly mediaType: string;
+    readonly sha256: string;
+    readonly base: string | null;
+};
+type HeldParts = {
+    readonly fields?: Readonly<Record<string, {
+        readonly value: unknown;
+        readonly base: FieldValue;
+    }>>;
+    readonly sections?: Readonly<Record<string, {
+        readonly value: string;
+        readonly base: string;
+    }>>;
+    readonly preamble?: {
+        readonly value: string;
+        readonly base: string;
+    };
+    readonly markdown?: {
+        readonly value: string;
+        readonly base: string;
+    };
+    readonly creation?: RoomDraftCreation;
+    readonly move?: {
+        readonly to: string;
+        readonly room?: string;
+        readonly base: string | null;
+    };
+    readonly removal?: {
+        readonly base: string | null;
+    };
+    readonly file?: HeldFile;
+};
+type ChangedUnderneath = {
+    readonly fields?: Readonly<Record<string, FieldValue>>;
+    readonly sections?: Readonly<Record<string, string | null>>;
+    readonly preamble?: string | null;
+    readonly markdown?: string | null;
+    readonly creation?: string;
+    readonly move?: string | null;
+    readonly removal?: string | null;
+    readonly file?: string | null;
+};
+export type ReturnReason = ProviderRefusal & {
+    readonly kind: Open<'conflicted' | 'rejected' | 'expired' | 'withdrawn'>;
+};
+export declare function returnedBy(kind: 'expired' | 'withdrawn'): ReturnReason;
+export type RoomDraft = {
+    readonly room: string;
+    readonly path: string;
+    readonly revision: string;
+    readonly parts: HeldParts;
+    readonly changedUnderneath: ChangedUnderneath;
+    readonly returned: ReturnReason | null;
+};
+export type RoomDraftWrite = {
+    readonly outcome: 'written';
+    readonly roomDraft: RoomDraft | null;
+} | {
+    readonly outcome: 'stale';
+    readonly code: string;
+    readonly retryable: boolean;
+    readonly current: RoomDraft | null;
+};
+export declare function staleWrite(current: RoomDraft | null): RoomDraftWrite;
+export type ChangedPart = {
+    readonly path: string;
+    readonly part: Open<'field' | 'section' | 'preamble' | 'markdown' | 'move' | 'removal' | 'file'>;
+    readonly name?: string;
+};
+export type RoomDraftRecord = {
+    readonly locator: string;
+    readonly path: string;
+    readonly revision: string;
+    readonly parts: HeldParts;
+    readonly returned: ReturnReason | null;
+};
+export type SavedDraft = {
+    readonly path: string;
+    readonly parts: HeldParts;
+};
+export declare function readParts(value: unknown): RoomDraftParts;
+export declare function gatheredParts(earlier: unknown, later: unknown): unknown;
+export declare function held(current: HeldParts | undefined, parts: RoomDraftParts, file?: HeldFile): HeldParts;
+export declare function underneath(parts: HeldParts, path: string, visible: VisibleLayer | undefined): ChangedUnderneath;
+export declare function heldFile(blob: Blob, base: string | null): Promise<HeldFile>;
+export declare function binaryBase(visible: VisibleLayer | undefined, path: string): string | null;
+export declare function changedParts(path: string, parts: HeldParts, visible: VisibleLayer | undefined): readonly ChangedPart[];
+export type TextParts = {
+    readonly fields?: Readonly<Record<string, {
+        readonly value: unknown;
+    }>>;
+    readonly sections?: Readonly<Record<string, {
+        readonly value: string;
+    }>>;
+    readonly preamble?: {
+        readonly value: string;
+    };
+};
+export declare function partsAfter(markdown: string, parts: TextParts): string;
+export declare function returnedInto(existing: HeldParts | undefined, returned: HeldParts): HeldParts;
+export declare function moveTarget(move: {
+    readonly to: string;
+}): string;
+export declare function readSavedParts(named: readonly {
+    readonly path: string;
+    readonly parts: unknown;
+}[]): readonly {
+    readonly path: string;
+    readonly parts: RoomDraftParts;
+}[];
+export declare function partsChanges(named: readonly {
+    readonly path: string;
+    readonly parts: unknown;
+}[]): {
+    readonly changes: readonly Change[];
+    readonly preconditions: readonly Precondition[];
+};
+export declare function changesOf(path: string, parts: HeldParts): {
+    changes: readonly Change[];
+    bases: readonly Precondition[];
+};
+export declare function joinedDraft(carried: SavedDraft, saved: readonly SavedDraft[]): SavedDraft;
+export declare function withdrawnDrafts(drafts: readonly SavedDraft[], changes: readonly Change[]): readonly SavedDraft[];
+export {};

package/dist/mdruntime/save.d.ts

@@ -0,0 +1,102 @@
+import { type Validation } from '../mdmodel/index.js';
+import type { OperationScopes, ProviderLimit } from './adapter.js';
+import { type Change, type ChangeBatch, type Precondition, type WrittenBy } from './change.js';
+import { type Composition } from './collection.js';
+import { type Layer } from './overlay.js';
+import type { VisibleLayer } from './replica.js';
+import type { ChangedPart } from './room-draft.js';
+export type SaveRefusal = {
+    code: string;
+    retryable: boolean;
+    file?: string;
+    location?: string;
+    referrers?: readonly string[];
+    parts?: readonly ChangedPart[];
+};
+export type SaveInput = {
+    local: boolean;
+    composition: Composition;
+    baseRoomVersion: string;
+    operations: import('./adapter.js').OperationScopes;
+    providerOwnedPaths: readonly string[];
+    providerLimits: readonly ProviderLimit[];
+    visible: VisibleLayer;
+    folders: ReadonlySet<string>;
+    handle: string;
+    changes: readonly Change[];
+    bases: readonly Precondition[];
+    queued?: ReadonlySet<string>;
+    writtenBy?: WrittenBy;
+    unmodeled: boolean;
+    validate: Validator;
+};
+export type Validator = (resulting: Layer, touched: readonly string[]) => Promise<Validation>;
+type Refusing = {
+    kind: 'refused';
+    refusal: SaveRefusal;
+};
+export type BatchResult = {
+    kind: 'batch';
+    batch: ChangeBatch;
+} | Refusing;
+export declare function providerRewritten(batch: ChangeBatch, visible: VisibleLayer): Generator<number, ChangeBatch, void>;
+export declare function leavingRewritten(batch: ChangeBatch, visible: VisibleLayer): Generator<number, ChangeBatch, void>;
+export declare function rewriting(batch: ChangeBatch, locator: string): boolean;
+export declare function effectiveIn(batch: ChangeBatch, locator: string, visible: VisibleLayer): Generator<number, ChangeBatch, void>;
+export declare function queuedDocuments(queue: readonly ChangeBatch[]): ReadonlySet<string>;
+export type Requeued = {
+    kind: 'requeued';
+    queue: readonly ChangeBatch[];
+    changes: readonly Change[];
+    queued: ReadonlySet<string>;
+    withdrawn: ReadonlyMap<string, ChangeBatch | null>;
+    owners: ReadonlySet<string>;
+} | {
+    kind: 'refused';
+    refusal: SaveRefusal;
+};
+export type Joining = {
+    kind: 'joined';
+    batch: ChangeBatch;
+    queue: readonly ChangeBatch[];
+} | {
+    kind: 'refused';
+    refusal: SaveRefusal;
+};
+type VisibleOver = (queue: readonly ChangeBatch[]) => Generator<number, VisibleLayer, void>;
+export declare function requeuing(queue: readonly ChangeBatch[], changes: readonly Change[], visible: VisibleLayer, changeable: (batch: ChangeBatch) => boolean, state: VisibleOver): Generator<number, Requeued, void>;
+export declare function joined(queue: readonly ChangeBatch[], owner: ChangeBatch, extra: ChangeBatch): Joining;
+export declare function limiting(queue: readonly ChangeBatch[], batch: ChangeBatch, limits: readonly ProviderLimit[], state: VisibleOver): Generator<number, SaveRefusal | null, void>;
+export declare const MOVE_DOCUMENTS = "move-documents";
+export type MoveSide = {
+    room: string;
+    handle: string;
+    baseRoomVersion: string;
+    composition: Composition;
+    operations: OperationScopes;
+    providerOwnedPaths: readonly string[];
+    visible: VisibleLayer;
+    folders: ReadonlySet<string>;
+    queued: ReadonlySet<string>;
+    unmodeled: boolean;
+    validate: Validator;
+};
+export type MoveInput = {
+    source: MoveSide;
+    destination: MoveSide;
+    moves: readonly {
+        readonly path: string;
+        readonly to: string;
+    }[];
+    providerLimits: readonly ProviderLimit[];
+    local: boolean;
+    writtenBy?: WrittenBy;
+};
+export type MoveResult = {
+    kind: 'moved';
+    leaving: ChangeBatch;
+    arriving: ChangeBatch;
+} | Refusing;
+export declare function buildMove(input: MoveInput): Promise<MoveResult>;
+export declare function buildBatch(input: SaveInput): Promise<BatchResult>;
+export {};

package/dist/mdruntime/search.d.ts

@@ -0,0 +1,72 @@
+import type { ProviderRefusal } from './adapter.js';
+import { type CoveredRoom, type Filter, type PendingRoom } from './query.js';
+import type { Open } from './open.js';
+export type DocumentPart = Open<'fields' | 'sections' | 'preamble' | 'path'>;
+export type SearchRequest = {
+    text: string;
+    documents?: Filter;
+    collection?: true;
+    conversations?: readonly string[];
+    limit?: number;
+    after?: string;
+    total?: true;
+};
+export type MessagePart = Open<'text'>;
+export type Snippet<Part extends string> = {
+    part: Part;
+    text: string;
+    at: readonly [number, number];
+};
+export type DocumentHit = {
+    room: string;
+    path: string;
+    type: string;
+    score: number;
+    matches: Readonly<Record<string, readonly DocumentPart[]>>;
+    snippet?: Snippet<DocumentPart>;
+};
+export type MessageHit = {
+    conversation: string;
+    identity: string;
+    score: number;
+    matches: Readonly<Record<string, readonly MessagePart[]>>;
+    snippet?: Snippet<MessagePart>;
+};
+export type SearchCoverage = {
+    rooms: readonly CoveredRoom[];
+    conversations: readonly string[];
+    overlay: readonly string[];
+};
+export type SearchHits = {
+    documents: readonly DocumentHit[];
+    messages: readonly MessageHit[];
+};
+export type SearchWindow = SearchHits & {
+    next?: string;
+    total?: {
+        documents: number;
+        messages: number;
+    };
+};
+export type SearchPending = SearchHits & {
+    pending: readonly PendingRoom[];
+    coverage: SearchCoverage;
+};
+export type SearchUndeclared = ProviderRefusal & {
+    kind: 'undeclared';
+};
+export type SearchResult = (SearchWindow & {
+    coverage: SearchCoverage;
+}) | SearchPending | SearchUndeclared;
+export declare function undeclaredSearch(): SearchUndeclared;
+export type HitCursor = readonly [number, string, string] | readonly [] | null;
+export type SearchPlan = {
+    text: string;
+    documents: unknown;
+    collection: boolean;
+    conversations: readonly string[] | null;
+    limit: number | null;
+    after: readonly [HitCursor, HitCursor] | null;
+    total: boolean;
+};
+export declare function searchPlanOf(input: unknown): SearchPlan;

package/dist/mdruntime/seed.d.ts

@@ -0,0 +1,15 @@
+import type { KeyedResult } from './observation.js';
+import type { QueryRows } from './query.js';
+export type EntrySeed = {
+    readonly at: Readonly<Record<string, string>>;
+    readonly queries: readonly {
+        readonly query: unknown;
+        readonly rows: QueryRows;
+    }[];
+};
+export type Seeded = {
+    readonly rows: QueryRows;
+    readonly at: Readonly<Record<string, string>>;
+};
+export declare function entrySeedOf(value: unknown): EntrySeed | null;
+export declare function seededResult(seed: Seeded): KeyedResult;

package/dist/mdruntime/status.d.ts

@@ -0,0 +1,27 @@
+import type { Open } from './open.js';
+import type { ReturnReason } from './room-draft.js';
+export type AttentionEntry = {
+    room: string;
+    path: string;
+    returned: ReturnReason;
+};
+export type UnsentChange = {
+    room: string;
+    path: string;
+};
+export type SyncStatus = {
+    state: Open<'pending' | 'syncing' | 'synced'>;
+    lastCompleted: string | null;
+    providerUnreachable: boolean;
+    attentionRequired: readonly AttentionEntry[];
+    unsent: readonly UnsentChange[];
+    reset: string | null;
+};
+export type CycleProgress = {
+    complete: boolean;
+    reachable: boolean;
+};
+export declare const STARTING: SyncStatus;
+export declare function transferring(status: SyncStatus): SyncStatus;
+export declare function saving(status: SyncStatus): SyncStatus;
+export declare function same(one: SyncStatus, other: SyncStatus): boolean;

package/dist/mdruntime/store.d.ts

@@ -0,0 +1,153 @@
+import type { BootstrapInventory, Capability, ListedConversation, Member, ProviderLimit } from './adapter.js';
+import type { ChangeBatch } from './change.js';
+import { type Composition } from './collection.js';
+import type { Plan } from './query.js';
+import type { ReplicaRecord } from './replica.js';
+import type { Submission } from './outcome.js';
+import type { RoomDraftRecord, SavedDraft } from './room-draft.js';
+import type { ModelState, StoredModel } from './model.js';
+import type { SearchWindow } from './search.js';
+import type { CommittedWrite, ConversationWrite, CountedRoom, HeldConversation, HeldEntry, MessageWindow, QueryAnswer, QueryRoom, Referrer, RoomCommit, RuntimeDatabase, SearchAsk, StoredEntry, StoredFile, TypedEntry, View } from './tables.js';
+export type { ConversationWrite, HeldConversation, MessageWindow } from './tables.js';
+export type TransferRecord = {
+    readonly locator: string;
+    readonly transfer: string;
+    readonly selection: string;
+    readonly from: string;
+    readonly last: string;
+    readonly done: BootstrapInventory;
+    readonly models: {
+        readonly collection: ModelState;
+    };
+    readonly key: number | null;
+};
+export type StoredReplica = Omit<ReplicaRecord, 'model'> & {
+    readonly model: StoredModel;
+};
+export type PendingState = {
+    readonly drafts: readonly SavedDraft[];
+    readonly submission: Submission;
+    readonly lost: boolean;
+    readonly upload?: unknown;
+};
+export type TargetRecord = {
+    established: boolean;
+};
+export type QueueRecord = {
+    locator: string;
+    pending: readonly {
+        batch: ChangeBatch;
+        state: PendingState;
+    }[];
+};
+export type PresentationRecord = {
+    app: string;
+    value: unknown;
+};
+export type ChatSubmission = {
+    readonly operation: string;
+    readonly text: string;
+    readonly turn: string | null;
+};
+export type ChatDraftRecord = {
+    conversation: string;
+    text: string;
+    revision: string;
+    submitted?: readonly ChatSubmission[];
+    moves?: readonly string[];
+};
+export type CallRecord = {
+    readonly operation: string;
+    readonly name: string;
+    readonly input: unknown;
+};
+export type AuthoredWrite = {
+    locator: string;
+    queue?: readonly ChangeBatch[];
+    founded?: readonly ChangeBatch[];
+    saved?: ReadonlyMap<string, readonly SavedDraft[]>;
+    roomDrafts?: readonly RoomDraftRecord[];
+    consumedRoomDrafts?: readonly string[];
+};
+export type StagedPage = {
+    readonly entries: readonly StoredEntry[];
+    readonly folders: readonly string[];
+};
+export type RefreshedPage = StagedPage & {
+    readonly removals: readonly string[];
+    readonly folderRemovals: readonly string[];
+};
+export type Opened = {
+    readonly rooms: ReadonlyMap<string, StoredReplica>;
+    readonly unindexed: ReadonlySet<number>;
+    readonly overlaid: ReadonlyMap<number, ReadonlySet<string>>;
+    readonly erasing: boolean;
+    readonly orphans: readonly number[];
+    readonly lastCompleted: string | null;
+    readonly providerLimits: readonly ProviderLimit[];
+    readonly capabilities: readonly Capability[];
+    readonly member: Member | null;
+    readonly targets: Readonly<Record<string, TargetRecord>>;
+    readonly presentation: readonly PresentationRecord[];
+    readonly conversationList: readonly ListedConversation[] | null;
+};
+export type Commit = {
+    readonly rooms: readonly RoomCommit[];
+    readonly writes?: readonly AuthoredWrite[];
+    readonly files?: readonly StoredFile[];
+    readonly whole?: boolean;
+    readonly discards?: readonly string[];
+};
+export type RuntimeStore = {
+    opened(): Promise<Opened>;
+    counts(rooms: readonly CountedRoom[]): Promise<readonly number[]>;
+    query(plan: Plan, rooms: readonly QueryRoom[], budget: number | null): Promise<QueryAnswer>;
+    changes(keys: readonly number[]): number;
+    entries(key: number, view: View, paths: readonly string[]): Promise<readonly HeldEntry[]>;
+    typed(key: number, view: View, paths: readonly string[]): Promise<readonly TypedEntry[]>;
+    referrers(key: number, view: View, targets: readonly string[], kinds: readonly string[]): Promise<readonly Referrer[]>;
+    files(key: number, view: View, after: string | null, limit: number): Promise<readonly {
+        readonly path: string;
+        readonly revision: string;
+    }[]>;
+    folders(key: number, view: View, paths: readonly string[]): Promise<readonly string[]>;
+    typedWithin(key: number, view: View, roots: readonly string[], within: boolean): Promise<boolean>;
+    search(ask: SearchAsk): Promise<SearchWindow>;
+    stage(record: TransferRecord, composition: Composition, page: StagedPage): Promise<number | null>;
+    refresh(key: number, composition: Composition, page: RefreshedPage): Promise<void>;
+    unrefresh(key: number): Promise<void>;
+    commit(commit: Commit): Promise<CommittedWrite>;
+    fence(locators: readonly string[]): Promise<void>;
+    erase(locator: string | null, limit: number): Promise<boolean>;
+    abandon(locator: string): Promise<void>;
+    release(key: number): Promise<void>;
+    rederive(key: number, composition: Composition, bytes: number, ms: number, floor: number): Promise<{
+        readonly done: boolean;
+        readonly text: number;
+    }>;
+    fact(name: string, value: unknown): Promise<void>;
+    queues(): Promise<readonly QueueRecord[]>;
+    submit(locator: string, id: string, submission: Submission, lost: boolean): Promise<void>;
+    keepUpload(locator: string, id: string, upload: unknown): Promise<void>;
+    roomDrafts(): Promise<readonly RoomDraftRecord[]>;
+    present(record: PresentationRecord): Promise<void>;
+    conversations(): Promise<readonly HeldConversation[]>;
+    keepMessages(write: ConversationWrite): Promise<void>;
+    messageWindow(conversation: string, limit: number, before: readonly [string, string] | null): Promise<MessageWindow>;
+    messageCount(conversation: string): Promise<number>;
+    turnArrived(conversation: string, turn: string): Promise<boolean>;
+    dropConversations(conversations: readonly string[]): Promise<void>;
+    chatDrafts(): Promise<readonly ChatDraftRecord[]>;
+    keepChatDrafts(records: readonly ChatDraftRecord[]): Promise<void>;
+    dropChatDraft(conversation: string): Promise<void>;
+    calls(): Promise<readonly CallRecord[]>;
+    keepCall(record: CallRecord): Promise<void>;
+    dropCall(operation: string): Promise<void>;
+    keepRoomDraft(record: RoomDraftRecord, files: readonly StoredFile[]): Promise<void>;
+    discardRoomDraft(locator: string, path: string): Promise<void>;
+    fences(): Promise<readonly string[]>;
+    generation(): Promise<string | null>;
+    rememberGeneration(value: string): Promise<void>;
+    file(key: string, type: string): Promise<Blob>;
+};
+export declare function openRuntimeStore(fenced: (locator: string) => boolean, authored: RuntimeDatabase): RuntimeStore;