@agentshouse/app-bridge 0.1.0-ca4ec913df08d → 0.1.0-ca559eade7c19

package/dist/mdruntime/save.d.ts

@@ -0,0 +1,63 @@
+import type { 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';
+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;
+    };
+};
+export type BatchResult = {
+    kind: 'batch';
+    batch: ChangeBatch;
+} | {
+    kind: 'refused';
+    refusal: SaveRefusal;
+};
+export declare function providerRewritten(batch: ChangeBatch, visible: VisibleLayer): ChangeBatch;
+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;
+};
+export declare function requeued(queue: readonly ChangeBatch[], changes: readonly Change[], visible: VisibleLayer, changeable: (batch: ChangeBatch) => boolean, state: (queue: readonly ChangeBatch[]) => VisibleLayer): Requeued;
+export declare function joined(queue: readonly ChangeBatch[], owner: ChangeBatch, extra: ChangeBatch): Joining;
+export declare function limitedIn(queue: readonly ChangeBatch[], batch: ChangeBatch, limits: readonly ProviderLimit[], state: (queue: readonly ChangeBatch[]) => VisibleLayer): SaveRefusal | null;
+export declare function buildBatch(input: SaveInput): BatchResult;

package/dist/mdruntime/search.d.ts

@@ -0,0 +1,91 @@
+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;
+};
+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 SearchPending = SearchHits & {
+    pending: readonly (PendingRoom | PendingConversation)[];
+    coverage: SearchCoverage;
+};
+export type SearchUndeclared = ProviderRefusal & {
+    kind: 'undeclared';
+};
+export type SearchResult = (SearchHits & {
+    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): readonly string[];
+    document(room: string, path: string): SearchedDocument | null;
+};
+export type SearchPlan = {
+    text: string;
+    documents: unknown;
+    collection: boolean;
+    conversations: readonly string[] | null;
+    limit: number | null;
+};
+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): SearchHits;
+};
+export declare function searchPlanOf(input: unknown): SearchPlan;
+export declare function createSearchIndex(source: SearchSource): SearchIndex;

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,10 @@
+export type Paths<V> = Readonly<Record<string, V>>;
+type Weigh<V> = (key: string, value: V) => number;
+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 tally<V>(map: Paths<V>, weigh: Weigh<V>): number;
+export declare function sizeOf<V>(map: Paths<V>): number;
+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 {};

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,160 @@
+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 { ChatDraftFile } from './file.js';
+import type { Submission } from './outcome.js';
+import type { RoomDraftRecord, SavedDraft } from './room-draft.js';
+export declare const STORE_SCHEMA = 25;
+export declare const AUTHORED_SCHEMA = 2;
+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 ConversationWrite = {
+    conversation: string;
+    messages: readonly AcceptedMessage[];
+    read?: {
+        at: string | null;
+        partial: boolean;
+    };
+};
+export type ChatSubmission = {
+    readonly operation: string;
+    readonly text: string;
+    readonly files: readonly ChatDraftFile[];
+    readonly turn: string | null;
+};
+export type ChatDraftRecord = {
+    conversation: string;
+    text: string;
+    files: readonly ChatDraftFile[];
+    revision: string;
+    submitted?: readonly ChatSubmission[];
+    moves?: readonly string[];
+};
+export type RecordWrite = {
+    next: ReplicaRecord;
+    previous: ReplicaRecord | null;
+    stored?: StagedLayer;
+};
+export type AuthoredWrite = {
+    locator: string;
+    queue: readonly ChangeBatch[];
+    saved?: ReadonlyMap<string, readonly SavedDraft[]>;
+    roomDrafts?: readonly RoomDraftRecord[];
+    consumedRoomDrafts?: readonly string[];
+};
+export type RuntimeStore = {
+    all(): Promise<readonly ReplicaRecord[]>;
+    keepAuthored(input: AuthoredWrite): Promise<void>;
+    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 | undefined): Promise<AcceptedMessage[]>;
+    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>;
+    keepRoomDraft(record: RoomDraftRecord): 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>;
+    close(): void;
+};
+export declare function authoredHolder(): Promise<string | null>;
+export declare function authoredBy(holder: string): Promise<boolean>;
+export declare function authoredBinding(): Promise<string | null>;
+export declare function bindAuthored(binding: string): Promise<void>;
+export declare function removeRuntimeStore(holder?: string): 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): Promise<RuntimeStore>;

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

package/dist/mdruntime/wire.d.ts

@@ -0,0 +1,206 @@
+import type { ConnectionRefusal } from './connection.js';
+import type { Described } from './failure.js';
+export type RuntimePort = {
+    postMessage(message: unknown): void;
+    addEventListener(type: 'message' | 'close', listener: (event: {
+        data?: unknown;
+    }) => void): void;
+    start(): void;
+};
+export type WireReach = 'within' | 'app' | 'runtime' | 'actions' | 'whole';
+export type WireEffect = 'read' | 'write' | 'action';
+export type WireCall = {
+    readonly reach: WireReach;
+    readonly effect: WireEffect;
+};
+declare const MEMBERS: {
+    readonly rooms: {
+        readonly reach: 'within';
+        readonly effect: 'read';
+    };
+    readonly query: {
+        readonly reach: 'within';
+        readonly effect: 'read';
+    };
+    readonly search: {
+        readonly reach: 'within';
+        readonly effect: 'read';
+    };
+    readonly types: {
+        readonly reach: 'within';
+        readonly effect: 'read';
+    };
+    readonly save: {
+        readonly reach: 'within';
+        readonly effect: 'write';
+    };
+    readonly history: {
+        readonly reach: 'within';
+        readonly effect: 'read';
+    };
+    readonly 'binaryFile.read': {
+        readonly reach: 'within';
+        readonly effect: 'read';
+    };
+    readonly 'binaryFile.readReference': {
+        readonly reach: 'within';
+        readonly effect: 'read';
+    };
+    readonly call: {
+        readonly reach: 'actions';
+        readonly effect: 'action';
+    };
+    readonly reached: {
+        readonly reach: 'within';
+        readonly effect: 'read';
+    };
+    readonly log: {
+        readonly reach: 'whole';
+        readonly effect: 'read';
+    };
+    readonly persistence: {
+        readonly reach: 'runtime';
+        readonly effect: 'read';
+    };
+    readonly retry: {
+        readonly reach: 'runtime';
+        readonly effect: 'write';
+    };
+    readonly reauthorize: {
+        readonly reach: 'runtime';
+        readonly effect: 'write';
+    };
+    readonly 'roomDraft.list': {
+        readonly reach: 'within';
+        readonly effect: 'read';
+    };
+    readonly 'roomDraft.read': {
+        readonly reach: 'within';
+        readonly effect: 'read';
+    };
+    readonly 'roomDraft.write': {
+        readonly reach: 'within';
+        readonly effect: 'write';
+    };
+    readonly 'roomDraft.discard': {
+        readonly reach: 'within';
+        readonly effect: 'write';
+    };
+    readonly 'presentation.read': {
+        readonly reach: 'app';
+        readonly effect: 'read';
+    };
+    readonly 'presentation.write': {
+        readonly reach: 'app';
+        readonly effect: 'write';
+    };
+    readonly 'conversation.list': {
+        readonly reach: 'within';
+        readonly effect: 'read';
+    };
+    readonly 'conversation.read': {
+        readonly reach: 'within';
+        readonly effect: 'read';
+    };
+    readonly 'conversation.create': {
+        readonly reach: 'within';
+        readonly effect: 'action';
+    };
+    readonly 'conversation.send': {
+        readonly reach: 'within';
+        readonly effect: 'action';
+    };
+    readonly 'conversation.answer': {
+        readonly reach: 'within';
+        readonly effect: 'action';
+    };
+    readonly 'conversation.interrupt': {
+        readonly reach: 'within';
+        readonly effect: 'action';
+    };
+    readonly 'conversation.kill': {
+        readonly reach: 'within';
+        readonly effect: 'action';
+    };
+    readonly 'conversation.cancel': {
+        readonly reach: 'within';
+        readonly effect: 'action';
+    };
+    readonly 'conversation.delete': {
+        readonly reach: 'within';
+        readonly effect: 'action';
+    };
+    readonly 'chatDraft.write': {
+        readonly reach: 'within';
+        readonly effect: 'write';
+    };
+    readonly 'chatDraft.discard': {
+        readonly reach: 'within';
+        readonly effect: 'write';
+    };
+};
+declare const TOPICS: {
+    readonly rooms: 'within';
+    readonly readiness: 'within';
+    readonly 'connection-refusal': 'runtime';
+    readonly 'storage-loss': 'runtime';
+    readonly 'deployment-facts': 'runtime';
+    readonly 'sync-status': 'within';
+    readonly 'service-mode': 'runtime';
+    readonly member: 'runtime';
+    readonly query: 'within';
+    readonly queue: 'within';
+    readonly 'room-drafts': 'within';
+    readonly presentation: 'app';
+    readonly conversation: 'within';
+    readonly conversations: 'within';
+    readonly agents: 'within';
+};
+export declare const WIRE: {
+    readonly members: Readonly<Record<string, WireCall>>;
+    readonly topics: Readonly<Record<string, WireReach>>;
+};
+export type WireMember = keyof typeof MEMBERS;
+export type WireTopic = keyof typeof TOPICS;
+export type WireRequest = {
+    kind: 'hello';
+} | {
+    kind: 'call';
+    id: number;
+    member: WireMember;
+    input: readonly unknown[];
+} | {
+    kind: 'observe';
+    id: number;
+    topic: WireTopic;
+    input: readonly unknown[];
+} | {
+    kind: 'stop';
+    id: number;
+};
+export type WireAnswer = {
+    kind: 'result';
+    id: number;
+    value: unknown;
+} | ({
+    kind: 'failure';
+    id: number;
+} & Described) | {
+    kind: 'event';
+    id: number;
+    value: unknown;
+} | {
+    kind: 'refusal';
+    refusal: ConnectionRefusal;
+} | {
+    kind: 'ended';
+};
+export declare function unanswered(call: {
+    readonly id: number;
+    readonly member: WireMember;
+}): WireAnswer | null;
+export declare const AUTHORIZATION_ENDED = "the host authorization ended";
+export declare const PORT_CLOSED = "the port closed";
+export declare function request(message: unknown): WireRequest | null;
+export declare function answer(message: unknown): WireAnswer | null;
+export {};

package/dist/test-host.d.ts

@@ -1,5 +1,5 @@
-import type { MdRuntimeClient } from '@agentshouse/mdruntime/client';
-import type { HouseAnalyticsChoice, HouseAppMessage, HouseExternalAnswer, HouseExternalRequest, HouseImageCopy, HouseNavigationMode, HouseRefusal, HouseSourceDownload, HouseSourceTop, HouseStatus, HouseTab } from './index.js';
+import type { MdRuntimeClient } from './mdruntime/client.js';
+import type { HouseActivation, HouseAnalyticsChoice, HouseAppMessage, HouseExternalAnswer, HouseExternalRequest, HouseNavigationMode, HouseRefusal, HouseSourceDownload, HouseSourceTop, HouseStatus, HouseTab, HouseTask } from './index.js';
 export interface HouseBridgeNavigation {
     readonly mode: HouseNavigationMode;
     readonly address: string;
@@ -15,13 +15,13 @@ export interface HouseBridgeTestHost {
     publish(status: HouseStatus): void;
     message(message: HouseAppMessage): void;
     attachRuntime(runtime: MdRuntimeClient): void;
+    checkpoint(): Promise<HouseTask>;
+    restore(task: HouseTask | null): Promise<boolean>;
+    settle(activation: HouseActivation): void;
 }
 export interface HouseBridgeTestHostOptions {
     readonly address?: string;
     readonly status?: HouseStatus;
-    readonly images?: readonly (HouseImageCopy & {
-        readonly room: string;
-    })[];
     readonly sources?: readonly {
         readonly top: HouseSourceTop;
         readonly download: HouseSourceDownload;