@agentshouse/app-bridge 0.1.0-alpha.9 → 0.1.0-c0079debc581d

package/dist/mdruntime/save.d.ts

@@ -0,0 +1,101 @@
+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 { VisibleLayer } from './replica.js';
+import type { ChangedPart } from './room-draft.js';
+import { type Later } from './turn.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;
+    handle: string;
+    changes: readonly Change[];
+    bases: readonly Precondition[];
+    queued?: ReadonlySet<string>;
+    writtenBy?: WrittenBy;
+    clean?: {
+        text: Readonly<Record<string, string>>;
+        binaries: Readonly<Record<string, unknown>>;
+        composition: Composition;
+    };
+};
+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>;
+type Clean = NonNullable<SaveInput['clean']>;
+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;
+    queued: ReadonlySet<string>;
+    clean: Clean;
+};
+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): Later<MoveResult>;
+export declare function buildBatch(input: SaveInput): Later<BatchResult>;
+export {};

package/dist/mdruntime/search.d.ts

@@ -0,0 +1,104 @@
+import type { ProviderRefusal } from './adapter.js';
+import type { ChangeSet } from './change-set.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 DocumentHit = {
+    room: string;
+    path: string;
+    type: string;
+    score: number;
+    matches: Readonly<Record<string, readonly DocumentPart[]>>;
+};
+export type MessageHit = {
+    conversation: string;
+    identity: string;
+    score: number;
+    matches: Readonly<Record<string, readonly Open<'text'>[]>>;
+};
+export type SearchCoverage = {
+    rooms: readonly CoveredRoom[];
+    conversations: readonly string[];
+    index: string;
+    overlay: readonly string[];
+};
+export type PendingConversation = {
+    conversation: string;
+    awaits: Open<'index'>;
+};
+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 | PendingConversation)[];
+    coverage: SearchCoverage;
+};
+export type SearchUndeclared = ProviderRefusal & {
+    kind: 'undeclared';
+};
+export type SearchResult = (SearchWindow & {
+    coverage: SearchCoverage;
+}) | SearchPending | SearchUndeclared;
+export declare function undeclaredSearch(): SearchUndeclared;
+export type SearchedDocument = {
+    room: string;
+    path: string;
+    type: string;
+    fields: Readonly<Record<string, unknown>>;
+    preamble: string;
+    sections: Readonly<Record<string, string>>;
+};
+export type SearchedMessage = {
+    conversation: string;
+    identity: string;
+    text: string;
+};
+export type SearchSource = {
+    room(room: string): Iterable<string>;
+    document(room: string, path: string): SearchedDocument | null;
+};
+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 type SearchIndex = {
+    generation(): string;
+    rooms(): ReadonlySet<string>;
+    conversations(): ReadonlySet<string>;
+    indexRoom(room: string): Promise<void>;
+    indexMessages(conversation: string, messages: readonly SearchedMessage[], whole: boolean): void;
+    forget(rooms: readonly string[]): void;
+    changed(set: ChangeSet): void;
+    changes(): number;
+    caughtUp(): Promise<void>;
+    search(plan: SearchPlan, documents: readonly {
+        room: string;
+        path: string;
+    }[] | null, conversations: readonly string[], rooms: ReadonlySet<string> | null, selections: ReadonlyMap<string, readonly string[]> | null): SearchWindow;
+};
+export declare function searchPlanOf(input: unknown): SearchPlan;
+export declare function createSearchIndex(source: SearchSource): SearchIndex;
+export {};

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/shared.d.ts

@@ -0,0 +1,18 @@
+export type Paths<V> = Readonly<Record<string, V>>;
+type Weigh<V> = (key: string, value: V) => number;
+export declare function entriesIn<V>(map: Paths<V>): Generator<readonly [string, V]>;
+export declare function keysIn(...maps: readonly Paths<unknown>[]): Generator<number, Set<string>, void>;
+export declare function sortedKeys(map: Paths<unknown>): Generator<number, readonly string[], void>;
+export declare function sorting(keys: Iterable<string>): Generator<number, readonly string[], void>;
+export declare function sharing<V>(map: Paths<V>): Generator<number, Paths<V>, void>;
+export declare function shared<V>(map: Paths<V>): Paths<V>;
+export declare function patched<V>(base: Paths<V>, set: Iterable<readonly [string, V]>, removed?: Iterable<string>): Paths<V>;
+export declare function patching<V>(base: Paths<V>, set: Iterable<readonly [string, V]>, removed?: Iterable<string>): Generator<number, Paths<V>, void>;
+export declare function tallying<V>(map: Paths<V>, weigh: Weigh<V>): Generator<number, number, void>;
+export declare function sizeOf<V>(map: Paths<V>): number;
+export declare function differences<V>(left: Paths<V>, right: Paths<V>, same?: (left: V, right: V) => boolean): Generator<number, ReadonlySet<string>, void>;
+export declare function differing<V>(left: Paths<V>, right: Paths<V>, same?: (left: V, right: V) => boolean): ReadonlySet<string>;
+export declare function drafted<V>(base: Paths<V>): Record<string, V>;
+export declare function settled<V>(draft: Record<string, V>): Paths<V>;
+export declare function settling<V>(draft: Record<string, V>): Generator<number, Paths<V>, void>;
+export {};

package/dist/mdruntime/status.d.ts

@@ -0,0 +1,26 @@
+import type { Open } from './open.js';
+import type { ProviderRefusal } from './adapter.js';
+import type { ReturnReason } from './room-draft.js';
+export type AttentionEntry = {
+    room: string;
+    path: string;
+    returned: ReturnReason;
+} | {
+    room: string;
+    refusal: ProviderRefusal;
+};
+export type SyncStatus = {
+    state: Open<'pending' | 'syncing' | 'synced'>;
+    lastCompleted: string | null;
+    providerUnreachable: boolean;
+    attentionRequired: readonly AttentionEntry[];
+    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,171 @@
+import type { ModelState } from './model.js';
+import type { Capability, HeadChange, Member, OperationScopes, ProviderLimit, ReplicaAdmission, TypedSelection } from './adapter.js';
+import type { AcceptedMessage, KeptReceipt } from './adapter.js';
+import type { ChangeBatch } from './change.js';
+import { type HeldBinary } from './overlay.js';
+import { type Later } from './turn.js';
+import type { Submission } from './outcome.js';
+import type { RoomDraftRecord, SavedDraft } from './room-draft.js';
+import type { RuntimeDatabase, StoredFile } from './tables.js';
+export declare const STORE_SCHEMA = 25;
+export type ReplicaRecord = {
+    locator: string;
+    name: string;
+    handle: string;
+    operations: OperationScopes;
+    replica: ReplicaAdmission;
+    model: ModelState;
+    typedSelection: TypedSelection | null;
+    selectionModel: ModelState;
+    providerOwnedPaths: readonly string[];
+    roomVersion: string;
+    transfer: string;
+    documents: Readonly<Record<string, string>>;
+    binaries: Readonly<Record<string, HeldBinary>>;
+    revisions: Readonly<Record<string, string>>;
+    fileIds: Readonly<Record<string, string>>;
+    changes: Readonly<Record<string, HeadChange>>;
+    written: Readonly<Record<string, string>>;
+};
+export type StagedLayer = Pick<ReplicaRecord, 'documents' | 'binaries' | 'revisions' | 'fileIds' | 'changes' | 'written'>;
+export type TransferRecord = {
+    locator: string;
+    transfer: string;
+    selection: string;
+    from: string;
+    last: string;
+    pageToken: string | null;
+    models: {
+        collection: ModelState;
+        selection: ModelState;
+    };
+};
+export type PendingState = {
+    readonly drafts: readonly SavedDraft[];
+    readonly submission: Submission;
+    readonly lost: boolean;
+    readonly upload?: unknown;
+    readonly accepted?: string;
+};
+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 HeldConversation = {
+    conversation: string;
+    read: string | null | undefined;
+    partial: boolean;
+};
+export type MessageWindow = {
+    messages: AcceptedMessage[];
+    more: boolean;
+};
+export type ConversationWrite = {
+    conversation: string;
+    messages: readonly AcceptedMessage[];
+    read?: {
+        at: string | null;
+        partial: boolean;
+    };
+};
+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 RecordWrite = {
+    next: ReplicaRecord;
+    previous: ReplicaRecord | null;
+    stored?: StagedLayer;
+};
+export type AuthoredWrite = {
+    locator: string;
+    queue?: readonly ChangeBatch[];
+    founded?: readonly ChangeBatch[];
+    saved?: ReadonlyMap<string, readonly SavedDraft[]>;
+    roomDrafts?: readonly RoomDraftRecord[];
+    consumedRoomDrafts?: readonly string[];
+};
+export type RuntimeStore = {
+    all(): Promise<readonly ReplicaRecord[]>;
+    keepAuthored(...writes: readonly AuthoredWrite[]): Promise<void>;
+    saveAuthored(files: readonly StoredFile[], ...writes: readonly AuthoredWrite[]): Promise<string | null>;
+    write(input: RecordWrite): Promise<void>;
+    revokeModels(records: readonly ReplicaRecord[]): Promise<void>;
+    lastCompleted(): Promise<string | null>;
+    complete(at: string): Promise<void>;
+    providerLimits(): Promise<readonly ProviderLimit[]>;
+    capabilities(): Promise<readonly Capability[]>;
+    declare(limits: readonly ProviderLimit[], capabilities: readonly Capability[]): Promise<void>;
+    member(): Promise<Member | null>;
+    keepMember(member: Member | null): Promise<void>;
+    targets(): Promise<Readonly<Record<string, TargetRecord>>>;
+    keepTargets(targets: Readonly<Record<string, TargetRecord>>): Promise<void>;
+    queues(): Promise<readonly QueueRecord[]>;
+    submit(locator: string, id: string, submission: Submission, lost: boolean): Promise<void>;
+    accept(locator: string, id: string, roomVersion: string): Promise<void>;
+    keepUpload(locator: string, id: string, upload: unknown): Promise<void>;
+    roomDrafts(): Promise<readonly RoomDraftRecord[]>;
+    presentation(): Promise<readonly PresentationRecord[]>;
+    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>;
+    messagesAfter(conversation: string, identity: string | null): Promise<AcceptedMessage[]>;
+    messageIdentities(conversation: string): Promise<readonly string[]>;
+    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[]>;
+    erase(locators: readonly string[]): Promise<void>;
+    discard(locator: string): Promise<void>;
+    transfers(): Promise<readonly TransferRecord[]>;
+    staged(record: TransferRecord): Promise<StagedLayer>;
+    stage(record: TransferRecord, page: StagedLayer): Promise<void>;
+    abandon(locator: string): Promise<void>;
+    receivedHeads(): Promise<readonly KeptReceipt[]>;
+    receivedParts(key: string, count: number): Promise<readonly unknown[]>;
+    keepReceived(key: string, head: unknown, part?: {
+        index: number;
+        value: unknown;
+    }): Promise<void>;
+    dropReceived(keys: readonly string[]): Promise<void>;
+    generation(): Promise<string | null>;
+    rememberGeneration(value: string): Promise<void>;
+    file(key: string, type: string): Promise<Blob>;
+    close(): void;
+};
+export declare function transacted<T>(database: IDBDatabase, stores: string | readonly string[], mode: IDBTransactionMode, work: (transaction: IDBTransaction) => Later<T>): Promise<T>;
+export declare function endRuntimeStore(database: RuntimeDatabase, holder: string | undefined): Promise<boolean>;
+export declare function openDatabase(name: string, version: number, upgrade: (opening: IDBOpenDBRequest, oldVersion: number) => void): Promise<IDBDatabase>;
+export declare function openRuntimeStore(fenced: (locator: string) => boolean, authored: RuntimeDatabase): Promise<RuntimeStore>;

package/dist/mdruntime/tables.d.ts

@@ -0,0 +1,180 @@
+export type Value = string | number | bigint | Uint8Array | null;
+export type Row = Readonly<Record<string, Value>>;
+export interface Connection {
+    run(sql: string, bind?: readonly Value[]): void;
+    rows(sql: string, bind?: readonly Value[]): readonly Row[];
+}
+export declare const FILE_PART_BYTES = 1048576;
+export declare const AUTHORED_TABLES: readonly string[];
+export type AuthoredFact = 'holder' | 'binding' | 'generation';
+export type StoredFile = {
+    readonly key: string;
+    readonly blob: Blob;
+};
+export interface FileSpool {
+    held(): Iterable<string>;
+    spool(key: string, type: string, parts: Iterable<Uint8Array>): Promise<Blob>;
+    drop(key: string): Promise<void>;
+}
+export type KeptPending = {
+    readonly id: string;
+    readonly batch: string;
+    readonly state: string;
+    readonly files: readonly string[];
+};
+export type KeptRecord = {
+    readonly record: string;
+    readonly files: readonly string[];
+};
+export type AuthoredRows = {
+    readonly locator: string;
+    readonly order?: readonly string[];
+    readonly added?: readonly KeptPending[];
+    readonly founded?: readonly Omit<KeptPending, 'state'>[];
+    readonly roomDrafts?: readonly (KeptRecord & {
+        readonly path: string;
+    })[];
+    readonly consumedRoomDrafts?: readonly string[];
+};
+export type HeldQueues = {
+    readonly queues: readonly {
+        readonly locator: string;
+        readonly ids: readonly string[];
+    }[];
+    readonly pending: readonly {
+        readonly locator: string;
+        readonly id: string;
+        readonly batch: string;
+        readonly state: string;
+    }[];
+};
+export interface AuthoredRequests {
+    readonly 'authored.queues': {
+        readonly asked: Readonly<Record<never, never>>;
+        readonly answer: HeldQueues;
+    };
+    readonly 'authored.roomDrafts': {
+        readonly asked: Readonly<Record<never, never>>;
+        readonly answer: readonly string[];
+    };
+    readonly 'authored.chatDrafts': {
+        readonly asked: Readonly<Record<never, never>>;
+        readonly answer: readonly string[];
+    };
+    readonly 'authored.calls': {
+        readonly asked: Readonly<Record<never, never>>;
+        readonly answer: readonly string[];
+    };
+    readonly 'authored.fences': {
+        readonly asked: Readonly<Record<never, never>>;
+        readonly answer: readonly string[];
+    };
+    readonly 'authored.fact': {
+        readonly asked: {
+            readonly name: AuthoredFact;
+        };
+        readonly answer: string | null;
+    };
+    readonly 'authored.file': {
+        readonly asked: {
+            readonly key: string;
+            readonly type: string;
+        };
+        readonly answer: Blob;
+    };
+    readonly 'authored.keep': {
+        readonly asked: {
+            readonly writes: readonly AuthoredRows[];
+            readonly files: readonly StoredFile[];
+            readonly whole: boolean;
+        };
+        readonly answer: string | null;
+    };
+    readonly 'authored.amend': {
+        readonly asked: {
+            readonly locator: string;
+            readonly id: string;
+            readonly amendment: string;
+        };
+        readonly answer: null;
+    };
+    readonly 'authored.roomDraft': {
+        readonly asked: {
+            readonly locator: string;
+            readonly path: string;
+            readonly kept: KeptRecord | null;
+            readonly files: readonly StoredFile[];
+        };
+        readonly answer: string | null;
+    };
+    readonly 'authored.chatDraft': {
+        readonly asked: {
+            readonly kept: readonly {
+                readonly conversation: string;
+                readonly record: string;
+            }[];
+            readonly dropped: readonly string[];
+        };
+        readonly answer: null;
+    };
+    readonly 'authored.call': {
+        readonly asked: {
+            readonly operation: string;
+            readonly kept: KeptRecord | null;
+            readonly files: readonly StoredFile[];
+        };
+        readonly answer: null;
+    };
+    readonly 'authored.fence': {
+        readonly asked: {
+            readonly locators: readonly string[];
+        };
+        readonly answer: null;
+    };
+    readonly 'authored.unfence': {
+        readonly asked: {
+            readonly locators: readonly string[];
+        };
+        readonly answer: null;
+    };
+    readonly 'authored.discard': {
+        readonly asked: {
+            readonly locator: string;
+        };
+        readonly answer: null;
+    };
+    readonly 'authored.remember': {
+        readonly asked: {
+            readonly name: AuthoredFact;
+            readonly value: string;
+        };
+        readonly answer: null;
+    };
+    readonly 'authored.claim': {
+        readonly asked: {
+            readonly holder: string;
+        };
+        readonly answer: boolean;
+    };
+    readonly 'authored.end': {
+        readonly asked: {
+            readonly holder: string | null;
+        };
+        readonly answer: boolean;
+    };
+}
+export type AuthoredKind = keyof AuthoredRequests;
+export type AuthoredRequest<K extends AuthoredKind = AuthoredKind> = {
+    readonly [Kind in K]: {
+        readonly kind: Kind;
+    } & AuthoredRequests[Kind]['asked'];
+}[K];
+export type AuthoredAnswer<K extends AuthoredKind> = AuthoredRequests[K]['answer'];
+export interface RuntimeDatabase {
+    ask<K extends AuthoredKind>(request: AuthoredRequest<K>): Promise<AuthoredAnswer<K>>;
+}
+export declare function isAuthored(request: {
+    readonly kind: string;
+}): request is AuthoredRequest;
+export declare function readsAuthored(request: AuthoredRequest): boolean;
+export declare function answerAuthored(connection: Connection, request: AuthoredRequest, spool: FileSpool): unknown;

package/dist/mdruntime/transfer.d.ts

@@ -0,0 +1,9 @@
+import type { Refusal } from '../mdmodel/index.js';
+export type Unconfirmed = {
+    kind: 'unconfirmed';
+};
+export type Refused = {
+    kind: 'refused';
+    refusal: Refusal;
+};
+export declare const unconfirmed: Unconfirmed;

package/dist/mdruntime/turn.d.ts

@@ -0,0 +1,8 @@
+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 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>;
+export declare function inChunks<T>(items: Iterable<T>, weigh: (item: T) => number, each: (chunk: readonly T[]) => Later<void>): Promise<void>;