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

package/dist/mdruntime/search.d.ts

@@ -0,0 +1,83 @@
+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;
+    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: 'index';
+};
+export type SearchPending = {
+    pending: readonly (PendingRoom | PendingConversation)[];
+};
+export type SearchHits = {
+    documents: readonly DocumentHit[];
+    messages: readonly MessageHit[];
+};
+export type SearchResult = (SearchHits & {
+    coverage: SearchCoverage;
+}) | SearchPending;
+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;
+    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[]): SearchHits;
+};
+export declare function searchPlanOf(input: unknown): SearchPlan;
+export declare function createSearchIndex(source: SearchSource): SearchIndex;

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,159 @@
+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>>;
+    changes: Readonly<Record<string, HeadChange>>;
+    written: Readonly<Record<string, string>>;
+};
+export type StagedLayer = Pick<ReplicaRecord, 'documents' | 'binaries' | 'revisions' | '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;
+    search: 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[];
+};
+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[]>;
+    keepChatDraft(record: 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,104 @@
+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';
+declare const MEMBERS: {
+    readonly rooms: 'within';
+    readonly query: 'within';
+    readonly search: 'within';
+    readonly types: 'within';
+    readonly save: 'within';
+    readonly history: 'within';
+    readonly 'binaryFile.read': 'within';
+    readonly 'binaryFile.readReference': 'within';
+    readonly call: 'actions';
+    readonly reached: 'within';
+    readonly log: 'whole';
+    readonly persistence: 'runtime';
+    readonly retry: 'runtime';
+    readonly reauthorize: 'runtime';
+    readonly 'roomDraft.list': 'within';
+    readonly 'roomDraft.read': 'within';
+    readonly 'roomDraft.write': 'within';
+    readonly 'roomDraft.discard': 'within';
+    readonly 'presentation.read': 'app';
+    readonly 'presentation.write': 'app';
+    readonly 'conversation.list': 'within';
+    readonly 'conversation.read': 'within';
+    readonly 'conversation.create': 'within';
+    readonly 'conversation.send': 'within';
+    readonly 'conversation.answer': 'within';
+    readonly 'conversation.interrupt': 'within';
+    readonly 'conversation.kill': 'within';
+    readonly 'conversation.cancel': 'within';
+    readonly 'conversation.delete': 'within';
+    readonly 'chatDraft.write': 'within';
+    readonly 'chatDraft.discard': 'within';
+};
+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_REACH: {
+    readonly members: Readonly<Record<string, WireReach>>;
+    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 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

@@ -0,0 +1,33 @@
+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;
+}
+export interface HouseBridgeTestHost {
+    readonly navigations: readonly HouseBridgeNavigation[];
+    readonly ceremonies: readonly string[];
+    readonly consents: readonly HouseAnalyticsChoice[];
+    readonly tabs: readonly HouseTab[];
+    readonly externalCalls: readonly HouseExternalRequest[];
+    address(): string;
+    open(address: string): void;
+    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 sources?: readonly {
+        readonly top: HouseSourceTop;
+        readonly download: HouseSourceDownload;
+    }[];
+    readonly screenshots?: Readonly<Record<string, Blob>>;
+    readonly siteScreenshots?: Readonly<Record<string, Blob>>;
+    readonly external?: (request: HouseExternalRequest) => HouseExternalAnswer | HouseRefusal | null | Promise<HouseExternalAnswer | HouseRefusal | null>;
+}
+export declare function createHouseBridgeTestHost(options?: HouseBridgeTestHostOptions): HouseBridgeTestHost;

package/dist/test-host.js

@@ -0,0 +1,200 @@
+const HOST_ORIGIN = 'https://house.invalid';
+const ADDRESS_MAX_CHARS = 64 * 1024;
+function sameOriginPath(value) {
+    if (typeof value !== 'string')
+        return null;
+    if (value.charAt(0) !== '/' || value.slice(0, 2) === '//')
+        return null;
+    if (value.length > ADDRESS_MAX_CHARS)
+        return null;
+    const target = new URL(value, HOST_ORIGIN);
+    return target.origin === HOST_ORIGIN ? `${target.pathname}${target.search}${target.hash}` : null;
+}
+function appAddress(address) {
+    return address.startsWith('/') ? address : `/${address}`;
+}
+function ceremonyRefused(path) {
+    return Object.assign(new Error('house_ceremony_refused'), {
+        name: 'HouseCeremonyRefused',
+        code: 'house_ceremony_refused',
+        retryable: false,
+        path,
+    });
+}
+function navigationRefused(address) {
+    return Object.assign(new Error('house_navigation_refused'), {
+        name: 'HouseNavigationRefused',
+        code: 'house_navigation_refused',
+        retryable: false,
+        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 = [];
+    const consents = [];
+    const tabs = [];
+    const externalCalls = [];
+    const addressListeners = new Set();
+    const statusListeners = new Set();
+    const messageListeners = new Set();
+    let current = appAddress(options.address ?? '/');
+    let published = options.status ?? null;
+    let shown = null;
+    let seen = null;
+    let cooperation = null;
+    let attached = () => { };
+    const runtime = new Promise((resolve) => {
+        attached = resolve;
+    });
+    function arrive(target) {
+        current = target;
+        queueMicrotask(() => {
+            shown = target;
+            for (const listener of addressListeners)
+                listener(target);
+        });
+    }
+    function publish(next) {
+        published = next;
+        queueMicrotask(() => {
+            seen = next;
+            for (const listener of statusListeners)
+                listener(next);
+        });
+    }
+    function navigate(mode, 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 });
+        arrive(target);
+        return new Promise((resolve) => {
+            queueMicrotask(() => resolve(target));
+        });
+    }
+    const bridge = {
+        runtime,
+        address: () => shown,
+        onAddress(listener) {
+            return followHeld(addressListeners, listener, () => shown);
+        },
+        push: (asked) => navigate('push', asked),
+        replace: (asked) => navigate('replace', asked),
+        ceremony(path) {
+            const target = sameOriginPath(path);
+            if (target === null)
+                return Promise.reject(ceremonyRefused(path));
+            ceremonies.push(target);
+            return new Promise(() => { });
+        },
+        install: () => Promise.resolve('manual'),
+        notifications: () => Promise.resolve('unavailable'),
+        setBadge: () => Promise.resolve(),
+        setTab(tab) {
+            tabs.push(tab);
+        },
+        sourceTop: (app) => Promise.resolve(options.sources?.find((entry) => entry.top.app_ref === app)?.top ?? null),
+        sourceDownload: (app) => Promise.resolve(options.sources?.find((entry) => entry.top.app_ref === app)?.download ?? null),
+        callExternal(request) {
+            externalCalls.push(request);
+            return Promise.resolve(options.external?.(request) ?? null);
+        },
+        readScreenshot: (app) => Promise.resolve(options.screenshots?.[app] ?? null),
+        readSiteScreenshot: (site) => Promise.resolve(options.siteScreenshots?.[site] ?? null),
+        status: () => seen,
+        onStatus(listener) {
+            return followHeld(statusListeners, listener, () => seen);
+        },
+        messages(listener) {
+            messageListeners.add(listener);
+            return () => {
+                messageListeners.delete(listener);
+            };
+        },
+        analyticsConsent(choice) {
+            if (published === null || !published.analytics.measures)
+                return;
+            if (choice !== 'accept' && choice !== 'decline')
+                return;
+            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);
+    arrive(current);
+    return {
+        navigations,
+        ceremonies,
+        consents,
+        tabs,
+        externalCalls,
+        address: () => current,
+        open(asked) {
+            arrive(appAddress(asked));
+        },
+        publish,
+        message({ from, body }) {
+            queueMicrotask(() => {
+                for (const listener of messageListeners)
+                    listener({ from, body });
+            });
+        },
+        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);
+        },
+    };
+}