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

package/dist/mdruntime/stored.d.ts

@@ -0,0 +1,129 @@
+import type { HeadChange } from './adapter.js';
+import { type Composed, type Composition } from './collection.js';
+import type { HeldBinary } from './overlay.js';
+import type { Connection } from './tables.js';
+export declare const REPLICA_TABLES: readonly string[];
+export type View = 'confirmed' | 'visible' | 'refreshed';
+export type StoredEntry = {
+    readonly path: string;
+    readonly content: string | null;
+    readonly binary: HeldBinary | null;
+    readonly revision: string | null;
+    readonly fileId: string | null;
+    readonly change: HeadChange | null;
+    readonly written: string | null;
+};
+export type OverlayEntry = StoredEntry & {
+    readonly present: boolean;
+};
+export type HeldEntry = StoredEntry & {
+    readonly type: string | null;
+};
+export type TypedEntry = {
+    readonly path: string;
+    readonly type: string | null;
+    readonly binary: boolean;
+};
+export type Referrer = {
+    readonly path: string;
+    readonly target: string;
+    readonly kind: string;
+};
+export type HeldKey = {
+    readonly key: number;
+    readonly locator: string;
+    readonly transfer: string;
+    readonly rederiving: number | null;
+    readonly searching: number | null;
+};
+export type ReplicaOpened = {
+    readonly rooms: readonly {
+        readonly locator: string;
+        readonly key: number;
+        readonly record: string;
+    }[];
+    readonly keys: readonly HeldKey[];
+    readonly facts: Readonly<Record<string, string>>;
+    readonly presentation: readonly {
+        readonly app: string;
+        readonly value: string;
+    }[];
+    readonly overlaid: readonly {
+        readonly key: number;
+        readonly path: string;
+    }[];
+    readonly erasing: readonly {
+        readonly key: number;
+        readonly locator: string;
+    }[];
+    readonly orphans: readonly number[];
+};
+export type RoomCommit = {
+    readonly locator: string;
+    readonly key: number;
+    readonly record?: string;
+    readonly roots?: readonly string[];
+    readonly published?: {
+        readonly from: number | null;
+    };
+    readonly refreshed?: true;
+    readonly composed: Composed;
+    readonly confirmed?: {
+        readonly set: readonly StoredEntry[];
+        readonly removed: readonly string[];
+    };
+    readonly overlay?: {
+        readonly set: readonly OverlayEntry[];
+        readonly cleared: readonly string[];
+    };
+};
+export type Committed = {
+    readonly counts: Readonly<Record<string, number>>;
+    readonly changed: Readonly<Record<string, readonly string[] | null>>;
+    readonly indexed: Readonly<Record<string, boolean>>;
+};
+export type CountedRoom = {
+    readonly key: number;
+    readonly roots: readonly string[];
+};
+export declare function entered(connection: Connection, locator: string, composition: Composition, rows: readonly StoredEntry[]): number;
+export declare function stage(connection: Connection, request: {
+    readonly locator: string;
+    readonly transfer: string;
+    readonly key: number | null;
+    readonly fingerprint: string;
+    readonly entries: readonly StoredEntry[];
+    readonly folders: readonly string[];
+}): number;
+export declare function refreshing(connection: Connection, request: {
+    readonly key: number;
+    readonly composed: Composed;
+    readonly entries: readonly StoredEntry[];
+    readonly removals: readonly string[];
+    readonly folders: readonly string[];
+    readonly folderRemovals: readonly string[];
+}): null;
+export declare function unrefresh(connection: Connection, key: number): null;
+export declare function counts(connection: Connection, rooms: readonly CountedRoom[]): number[];
+export declare function commit(connection: Connection, rooms: readonly RoomCommit[]): Committed;
+export declare function fenceRooms(connection: Connection, locators: readonly string[]): null;
+export declare function abandon(connection: Connection, locator: string): null;
+export declare function release(connection: Connection, key: number): null;
+export declare function erase(connection: Connection, locator: string | null, limit: number): {
+    readonly remaining: boolean;
+};
+export declare function rederive(connection: Connection, key: number, composed: Composed, bytes: number, ms: number, floor: number): {
+    readonly done: boolean;
+    readonly text: number;
+};
+export declare function entries(connection: Connection, key: number, view: View, list: readonly string[]): HeldEntry[];
+export declare function typed(connection: Connection, key: number, view: View, list: readonly string[]): TypedEntry[];
+export declare function referrers(connection: Connection, key: number, view: View, targets: readonly string[], kinds: readonly string[]): Referrer[];
+export declare function files(connection: Connection, key: number, view: View, after: string | null, limit: number): {
+    readonly path: string;
+    readonly revision: string;
+}[];
+export declare function folders(connection: Connection, key: number, view: View, list: readonly string[]): string[];
+export declare function typedWithin(connection: Connection, key: number, view: View, roots: readonly string[], within: boolean): boolean;
+export declare function opened(connection: Connection): ReplicaOpened;
+export declare function ended(connection: Connection): void;

package/dist/mdruntime/tables.d.ts

@@ -0,0 +1,324 @@
+import { type QueryAnswer, type QueryRoom } from './compile.js';
+import type { Composed } from './collection.js';
+import { type SearchAsk } from './fulltext.js';
+import { type ConversationWrite, type HeldConversation, type MessageWindow } from './messages.js';
+import type { Plan } from './query.js';
+import type { SearchWindow } from './search.js';
+import { type Committed, type CountedRoom, type HeldEntry, type ReplicaOpened, type Referrer, type RoomCommit, type StoredEntry, type TypedEntry, type View } from './stored.js';
+export type { Committed, CountedRoom, HeldEntry, OverlayEntry, ReplicaOpened, Referrer, RoomCommit, StoredEntry, TypedEntry, View, } from './stored.js';
+export type { QueryAnswer, QueryRoom } from './compile.js';
+export type { SearchAsk } from './fulltext.js';
+export type { ConversationWrite, HeldConversation, MessageWindow } from './messages.js';
+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[];
+    collate(name: string, compare: (left: string, right: string) => number): void;
+}
+export interface SqliteEngine {
+    readonly capi: {
+        readonly SQLITE_UTF8: number;
+        sqlite3_create_collation_v2(database: number, name: string, encoding: number, argument: number, compare: (argument: number, leftLength: number, left: number, rightLength: number, right: number) => number, destroy: number): number;
+    };
+    readonly wasm: {
+        heap8u(): Uint8Array;
+    };
+}
+export interface SqliteStatement {
+    readonly parameterCount: number;
+    bind(values: readonly Value[]): unknown;
+    step(): boolean;
+    get(values: Value[]): Value[];
+    getColumnNames(names: string[]): string[];
+    resetNoThrow(clearBindings: boolean): number;
+    finalize(): unknown;
+}
+export interface SqliteDatabase {
+    readonly pointer: number;
+    exec(options: {
+        readonly sql: string;
+        readonly bind: readonly Value[];
+        readonly rowMode?: 'object';
+        readonly returnValue?: 'resultRows';
+    }): Row[];
+    prepare(sql: string): SqliteStatement;
+}
+export declare function sqliteConnection(engine: SqliteEngine, database: SqliteDatabase): Connection;
+export declare const FILE_PART_BYTES = 1048576;
+export declare const RUNTIME_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>;
+    probe(bytes: number): 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 type OpenedFile = {
+    readonly key: string;
+    readonly byteLength: number;
+    readonly mediaType: string;
+};
+type Asked<A, R> = {
+    readonly asked: A;
+    readonly answer: R;
+};
+type Nothing = Readonly<Record<never, never>>;
+export type CommittedWrite = Committed & {
+    readonly fenced: string | null;
+};
+export type AuthoredWrite = {
+    readonly writes: readonly AuthoredRows[];
+    readonly files: readonly StoredFile[];
+    readonly whole: boolean;
+    readonly discards?: readonly string[];
+};
+export interface RuntimeRequests {
+    readonly 'authored.queues': Asked<Nothing, HeldQueues>;
+    readonly 'authored.roomDrafts': Asked<Nothing, readonly string[]>;
+    readonly 'authored.chatDrafts': Asked<Nothing, readonly string[]>;
+    readonly 'authored.calls': Asked<Nothing, readonly string[]>;
+    readonly 'authored.fences': Asked<Nothing, readonly string[]>;
+    readonly 'authored.fact': Asked<{
+        readonly name: AuthoredFact;
+    }, string | null>;
+    readonly 'authored.file': Asked<{
+        readonly key: string;
+        readonly type: string;
+    }, Blob>;
+    readonly 'authored.amend': Asked<{
+        readonly locator: string;
+        readonly id: string;
+        readonly amendment: string;
+    }, null>;
+    readonly 'authored.roomDraft': Asked<{
+        readonly locator: string;
+        readonly path: string;
+        readonly kept: KeptRecord | null;
+        readonly files: readonly StoredFile[];
+    }, string | null>;
+    readonly 'authored.chatDraft': Asked<{
+        readonly kept: readonly {
+            readonly conversation: string;
+            readonly record: string;
+        }[];
+        readonly dropped: readonly string[];
+    }, null>;
+    readonly 'authored.call': Asked<{
+        readonly operation: string;
+        readonly kept: KeptRecord | null;
+        readonly files: readonly StoredFile[];
+    }, null>;
+    readonly 'authored.remember': Asked<{
+        readonly name: AuthoredFact;
+        readonly value: string;
+    }, null>;
+    readonly 'authored.claim': Asked<{
+        readonly holder: string;
+    }, boolean>;
+    readonly 'authored.end': Asked<{
+        readonly holder: string | null;
+    }, boolean>;
+    readonly 'replica.open': Asked<Nothing, ReplicaOpened>;
+    readonly 'replica.query': Asked<{
+        readonly plan: Plan;
+        readonly rooms: readonly QueryRoom[];
+        readonly budget: number | null;
+    }, QueryAnswer>;
+    readonly 'replica.entries': Asked<{
+        readonly key: number;
+        readonly view: View;
+        readonly paths: readonly string[];
+    }, readonly HeldEntry[]>;
+    readonly 'replica.typed': Asked<{
+        readonly key: number;
+        readonly view: View;
+        readonly paths: readonly string[];
+    }, readonly TypedEntry[]>;
+    readonly 'replica.referrers': Asked<{
+        readonly key: number;
+        readonly view: View;
+        readonly targets: readonly string[];
+        readonly kinds: readonly string[];
+    }, readonly Referrer[]>;
+    readonly 'replica.files': Asked<{
+        readonly key: number;
+        readonly view: View;
+        readonly after: string | null;
+        readonly limit: number;
+    }, readonly {
+        readonly path: string;
+        readonly revision: string;
+    }[]>;
+    readonly 'replica.folders': Asked<{
+        readonly key: number;
+        readonly view: View;
+        readonly paths: readonly string[];
+    }, readonly string[]>;
+    readonly 'replica.typedWithin': Asked<{
+        readonly key: number;
+        readonly view: View;
+        readonly roots: readonly string[];
+        readonly within: boolean;
+    }, boolean>;
+    readonly 'replica.counts': Asked<{
+        readonly rooms: readonly CountedRoom[];
+    }, readonly number[]>;
+    readonly 'replica.search': Asked<SearchAsk, SearchWindow>;
+    readonly 'replica.stage': Asked<{
+        readonly locator: string;
+        readonly transfer: string;
+        readonly key: number | null;
+        readonly fingerprint: string;
+        readonly entries: readonly StoredEntry[];
+        readonly folders: readonly string[];
+    }, number | null>;
+    readonly 'replica.refresh': Asked<{
+        readonly key: number;
+        readonly composed: Composed;
+        readonly entries: readonly StoredEntry[];
+        readonly removals: readonly string[];
+        readonly folders: readonly string[];
+        readonly folderRemovals: readonly string[];
+    }, null>;
+    readonly 'replica.unrefresh': Asked<{
+        readonly key: number;
+    }, null>;
+    readonly 'replica.commit': Asked<{
+        readonly authored?: AuthoredWrite;
+        readonly rooms: readonly RoomCommit[];
+    }, CommittedWrite>;
+    readonly 'replica.fence': Asked<{
+        readonly locators: readonly string[];
+    }, null>;
+    readonly 'replica.erase': Asked<{
+        readonly locator: string | null;
+        readonly limit: number;
+    }, {
+        readonly remaining: boolean;
+    }>;
+    readonly 'replica.abandon': Asked<{
+        readonly locator: string;
+    }, null>;
+    readonly 'replica.release': Asked<{
+        readonly key: number;
+    }, null>;
+    readonly 'replica.rederive': Asked<{
+        readonly key: number;
+        readonly composed: Composed;
+        readonly bytes: number;
+        readonly ms: number;
+        readonly floor: number;
+    }, {
+        readonly done: boolean;
+        readonly text: number;
+    }>;
+    readonly 'replica.fact': Asked<{
+        readonly name: string;
+        readonly value: string;
+    }, null>;
+    readonly 'replica.present': Asked<{
+        readonly app: string;
+        readonly value: string;
+    }, null>;
+    readonly 'opened.find': Asked<{
+        readonly locator: string;
+        readonly path: string;
+        readonly revision: string;
+    }, OpenedFile | null>;
+    readonly 'opened.begin': Asked<{
+        readonly key: string;
+        readonly locator: string;
+        readonly path: string;
+        readonly revision: string;
+        readonly mediaType: string;
+    }, boolean>;
+    readonly 'opened.part': Asked<{
+        readonly key: string;
+        readonly part: number;
+        readonly bytes: Uint8Array;
+    }, boolean>;
+    readonly 'opened.keep': Asked<{
+        readonly key: string;
+        readonly sha256: string;
+        readonly byteLength: number;
+        readonly parts: number;
+    }, boolean>;
+    readonly 'opened.drop': Asked<{
+        readonly key: string;
+    }, null>;
+    readonly 'opened.clean': Asked<Nothing, number>;
+    readonly 'file.part': Asked<{
+        readonly key: string;
+        readonly part: number;
+    }, Uint8Array | null>;
+    readonly 'conversation.held': Asked<Nothing, readonly HeldConversation[]>;
+    readonly 'conversation.keep': Asked<ConversationWrite, null>;
+    readonly 'conversation.window': Asked<{
+        readonly conversation: string;
+        readonly limit: number;
+        readonly before: readonly [string, string] | null;
+    }, MessageWindow>;
+    readonly 'conversation.count': Asked<{
+        readonly conversation: string;
+    }, number>;
+    readonly 'conversation.turn': Asked<{
+        readonly conversation: string;
+        readonly turn: string;
+    }, boolean>;
+    readonly 'conversation.drop': Asked<{
+        readonly conversations: readonly string[];
+    }, null>;
+    readonly 'space.probe': Asked<Nothing, null>;
+}
+export type RuntimeKind = keyof RuntimeRequests;
+export type RuntimeRequest<K extends RuntimeKind = RuntimeKind> = {
+    readonly [Kind in K]: {
+        readonly kind: Kind;
+    } & RuntimeRequests[Kind]['asked'];
+}[K];
+export type RuntimeAnswer<K extends RuntimeKind> = RuntimeRequests[K]['answer'];
+export interface RuntimeDatabase {
+    ask<K extends RuntimeKind>(request: RuntimeRequest<K>): Promise<RuntimeAnswer<K>>;
+}
+export declare function isRuntime(request: {
+    readonly kind: string;
+}): request is RuntimeRequest;
+export declare function readsRuntime(request: RuntimeRequest): boolean;
+export declare function answerRuntime(connection: Connection, request: RuntimeRequest, spool: FileSpool): unknown;

package/dist/mdruntime/wire.d.ts

@@ -34,15 +34,35 @@ declare const MEMBERS: {
         readonly reach: 'within';
         readonly effect: 'write';
     };
+    readonly saveParts: {
+        readonly reach: 'within';
+        readonly effect: 'write';
+    };
     readonly history: {
         readonly reach: 'within';
         readonly effect: 'read';
     };
+    readonly resolve: {
+        readonly reach: 'within';
+        readonly effect: 'read';
+    };
     readonly 'binaryFile.read': {
         readonly reach: 'within';
         readonly effect: 'read';
     };
-    readonly 'binaryFile.readReference': {
+    readonly 'binaryFile.link': {
+        readonly reach: 'within';
+        readonly effect: 'read';
+    };
+    readonly 'binaryFile.show': {
+        readonly reach: 'within';
+        readonly effect: 'read';
+    };
+    readonly 'binaryFile.attach': {
+        readonly reach: 'within';
+        readonly effect: 'action';
+    };
+    readonly 'binaryFile.part': {
         readonly reach: 'within';
         readonly effect: 'read';
     };
@@ -58,6 +78,10 @@ declare const MEMBERS: {
         readonly reach: 'whole';
         readonly effect: 'read';
     };
+    readonly cleanUp: {
+        readonly reach: 'whole';
+        readonly effect: 'write';
+    };
     readonly persistence: {
         readonly reach: 'runtime';
         readonly effect: 'read';
@@ -94,6 +118,10 @@ declare const MEMBERS: {
         readonly reach: 'app';
         readonly effect: 'write';
     };
+    readonly 'presentation.edit': {
+        readonly reach: 'app';
+        readonly effect: 'write';
+    };
     readonly 'conversation.list': {
         readonly reach: 'within';
         readonly effect: 'read';
@@ -134,6 +162,10 @@ declare const MEMBERS: {
         readonly reach: 'within';
         readonly effect: 'write';
     };
+    readonly 'chatDraft.prepend': {
+        readonly reach: 'within';
+        readonly effect: 'write';
+    };
     readonly 'chatDraft.discard': {
         readonly reach: 'within';
         readonly effect: 'write';

package/dist/test-host.d.ts

@@ -1,11 +1,17 @@
 import type { MdRuntimeClient } from './mdruntime/client.js';
-import type { HouseActivation, HouseAnalyticsChoice, HouseAppMessage, HouseExternalAnswer, HouseExternalRequest, HouseNavigationMode, HouseRefusal, HouseSourceDownload, HouseSourceTop, HouseStatus, HouseTab, HouseTask } from './index.js';
+import type { HouseAnalyticsChoice, HouseAppMessage, HouseChatOptions, HouseExternalAnswer, HouseExternalRequest, HouseNavigationMode, HouseRefusal, HouseSourceDownload, HouseSourceTop, HouseStatus, HouseTab } from './index.js';
 export interface HouseBridgeNavigation {
     readonly mode: HouseNavigationMode;
     readonly address: string;
 }
+export interface HouseBridgeChat {
+    readonly element: object;
+    readonly options: HouseChatOptions;
+    readonly mounted: boolean;
+}
 export interface HouseBridgeTestHost {
     readonly navigations: readonly HouseBridgeNavigation[];
+    readonly chats: readonly HouseBridgeChat[];
     readonly ceremonies: readonly string[];
     readonly consents: readonly HouseAnalyticsChoice[];
     readonly tabs: readonly HouseTab[];
@@ -15,9 +21,6 @@ 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

@@ -50,6 +50,7 @@ export function createHouseBridgeTestHost(options = {}) {
     const consents = [];
     const tabs = [];
     const externalCalls = [];
+    const chats = [];
     const addressListeners = new Set();
     const statusListeners = new Set();
     const messageListeners = new Set();
@@ -57,7 +58,6 @@ 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;
@@ -99,7 +99,21 @@ export function createHouseBridgeTestHost(options = {}) {
         });
     }
     const bridge = {
-        runtime,
+        runtime: runtime,
+        chat: {
+            mount(element, options = {}) {
+                const chat = { element, options, mounted: true };
+                chats.push(chat);
+                return Promise.resolve({
+                    update(next) {
+                        chat.options = next;
+                    },
+                    unmount() {
+                        chat.mounted = false;
+                    },
+                });
+            },
+        },
         address: () => shown,
         onAddress(listener) {
             return followHeld(addressListeners, listener, () => shown);
@@ -145,25 +159,15 @@ export function createHouseBridgeTestHost(options = {}) {
             consents.push(choice);
             publish({ ...published, analytics: { measures: true, choice } });
         },
-        cooperate(given) {
-            cooperation = given;
-            return () => {
-                if (cooperation === given)
-                    cooperation = null;
-            };
-        },
+        cooperate: () => () => { },
     };
-    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,
+        chats,
         ceremonies,
         consents,
         tabs,
@@ -182,19 +186,5 @@ 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);
-        },
     };
 }