@agentshouse/app-bridge 0.1.0-ccf413b4e709d → 0.1.0-cd2d3edbf9805

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

@@ -0,0 +1,238 @@
+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 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.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';
+    };
+    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 cleanUp: {
+        readonly reach: 'whole';
+        readonly effect: 'write';
+    };
+    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 'presentation.edit': {
+        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.prepend': {
+        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 {};