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

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, 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,6 +15,9 @@ 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;

package/dist/test-host.js

@@ -1,5 +1,5 @@
 const HOST_ORIGIN = 'https://house.invalid';
-const ADDRESS_MAX_CHARS = 1000;
+const ADDRESS_MAX_CHARS = 64 * 1024;
 function sameOriginPath(value) {
     if (typeof value !== 'string')
         return null;
@@ -29,6 +29,21 @@ function navigationRefused(address) {
         address,
     });
 }
+function followHeld(listeners, listener, held) {
+    let following = true;
+    queueMicrotask(() => {
+        if (!following)
+            return;
+        listeners.add(listener);
+        const value = held();
+        if (value !== null)
+            listener(value);
+    });
+    return () => {
+        following = false;
+        listeners.delete(listener);
+    };
+}
 export function createHouseBridgeTestHost(options = {}) {
     const navigations = [];
     const ceremonies = [];
@@ -42,6 +57,7 @@ export function createHouseBridgeTestHost(options = {}) {
     let published = options.status ?? null;
     let shown = null;
     let seen = null;
+    let cooperation = null;
     let attached = () => { };
     const runtime = new Promise((resolve) => {
         attached = resolve;
@@ -63,7 +79,17 @@ export function createHouseBridgeTestHost(options = {}) {
         });
     }
     function navigate(mode, asked) {
-        const target = sameOriginPath(asked);
+        let path = asked;
+        if (/^https?:\/\//i.test(asked)) {
+            try {
+                const target = new URL(asked);
+                path = target.origin === HOST_ORIGIN ? target.pathname + target.search + target.hash : '';
+            }
+            catch {
+                path = '';
+            }
+        }
+        const target = sameOriginPath(path);
         if (target === null)
             return Promise.reject(navigationRefused(asked));
         navigations.push({ mode, address: target });
@@ -76,10 +102,7 @@ export function createHouseBridgeTestHost(options = {}) {
         runtime,
         address: () => shown,
         onAddress(listener) {
-            addressListeners.add(listener);
-            return () => {
-                addressListeners.delete(listener);
-            };
+            return followHeld(addressListeners, listener, () => shown);
         },
         push: (asked) => navigate('push', asked),
         replace: (asked) => navigate('replace', asked),
@@ -106,10 +129,7 @@ export function createHouseBridgeTestHost(options = {}) {
         readSiteScreenshot: (site) => Promise.resolve(options.siteScreenshots?.[site] ?? null),
         status: () => seen,
         onStatus(listener) {
-            statusListeners.add(listener);
-            return () => {
-                statusListeners.delete(listener);
-            };
+            return followHeld(statusListeners, listener, () => seen);
         },
         messages(listener) {
             messageListeners.add(listener);
@@ -125,7 +145,19 @@ export function createHouseBridgeTestHost(options = {}) {
             consents.push(choice);
             publish({ ...published, analytics: { measures: true, choice } });
         },
+        cooperate(given) {
+            cooperation = given;
+            return () => {
+                if (cooperation === given)
+                    cooperation = null;
+            };
+        },
     };
+    function cooperating() {
+        if (cooperation === null)
+            throw new Error('the App registered no cooperation');
+        return cooperation;
+    }
     Object.defineProperty(globalThis, 'houseBridge', { value: bridge, configurable: true });
     if (published !== null)
         publish(published);
@@ -150,5 +182,19 @@ export function createHouseBridgeTestHost(options = {}) {
         attachRuntime(client) {
             attached(client);
         },
+        async checkpoint() {
+            const held = cooperating();
+            await held.checkpoint();
+            await held.persist();
+            return JSON.parse(JSON.stringify((await held.capture()) ?? null));
+        },
+        async restore(task) {
+            const held = cooperating();
+            await held.restore(task);
+            return (await held.ready()) === true;
+        },
+        settle(activation) {
+            cooperating().settle(activation);
+        },
     };
 }