@agentshouse/app-bridge 0.1.0-c646d0da70608 → 0.1.0-c66ec79ae3f1a

package/dist/mdruntime/stored.d.ts

@@ -0,0 +1,142 @@
+import type { HeadChange } from './adapter.js';
+import type { Composition } from './collection.js';
+import type { HeldBinary } from './overlay.js';
+import type { SearchedDocument } from './search.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;
+};
+export type ReplicaOpened = {
+    readonly rooms: readonly {
+        readonly locator: string;
+        readonly key: number;
+        readonly record: string;
+    }[];
+    readonly transfers: 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 composition?: Composition;
+    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 prepared: Readonly<Record<string, boolean>>;
+};
+export type CountedRoom = {
+    readonly key: number;
+    readonly roots: readonly string[];
+};
+export type Walked = {
+    readonly entries: readonly HeldEntry[];
+    readonly next: string | null;
+};
+export declare function fingerprint(composition: Composition): 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 record: string | null;
+    readonly key: number | null;
+    readonly composition: Composition;
+    readonly entries: readonly StoredEntry[];
+    readonly folders: readonly string[];
+}): number;
+export declare function refreshing(connection: Connection, request: {
+    readonly key: number;
+    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, kept: boolean): number | 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, limit: number): {
+    readonly done: boolean;
+};
+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 walk(connection: Connection, key: number, view: View, after: string | null, bytes: number): Walked;
+export declare function files(connection: Connection, key: number, view: View, after: string | null, limit: number): {
+    readonly path: string;
+    readonly revision: string;
+}[];
+export declare function typedWithin(connection: Connection, key: number, view: View, roots: readonly string[], within: boolean): boolean;
+export declare function searched(connection: Connection, key: number, locator: string, after: string | null, limit: number, only: readonly string[] | null): {
+    readonly documents: readonly SearchedDocument[];
+    readonly next: string | null;
+};
+export declare function opened(connection: Connection): ReplicaOpened;
+export declare function ended(connection: Connection): void;

package/dist/mdruntime/tables.d.ts

@@ -0,0 +1,319 @@
+import { type QueryAnswer, type QueryRoom } from './compile.js';
+import type { KeptReceipt } from './adapter.js';
+import type { Composition } from './collection.js';
+import type { Plan } from './query.js';
+import type { SearchedDocument } from './search.js';
+import { type Committed, type CountedRoom, type HeldEntry, type ReplicaOpened, type Referrer, type RoomCommit, type StoredEntry, type TypedEntry, type View, type Walked } from './stored.js';
+export type { Committed, CountedRoom, HeldEntry, OverlayEntry, ReplicaOpened, Referrer, RoomCommit, StoredEntry, TypedEntry, View, Walked, } from './stored.js';
+export type { QueryAnswer, QueryRoom } from './compile.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 SqliteDatabase {
+    readonly pointer: number;
+    exec(options: {
+        readonly sql: string;
+        readonly bind: readonly Value[];
+        readonly rowMode?: 'object';
+        readonly returnValue?: 'resultRows';
+    }): Row[];
+}
+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>;
+}
+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[];
+    readonly amendments?: readonly {
+        readonly id: string;
+        readonly amendment: 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.walk': Asked<{
+        readonly key: number;
+        readonly view: View;
+        readonly after: string | null;
+        readonly bytes: number;
+    }, Walked>;
+    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.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.searched': Asked<{
+        readonly key: number;
+        readonly locator: string;
+        readonly after: string | null;
+        readonly limit: number;
+        readonly paths: readonly string[] | null;
+    }, {
+        readonly documents: readonly SearchedDocument[];
+        readonly next: string | null;
+    }>;
+    readonly 'replica.received': Asked<Nothing, readonly KeptReceipt[]>;
+    readonly 'replica.receivedParts': Asked<{
+        readonly key: string;
+        readonly count: number;
+    }, readonly unknown[]>;
+    readonly 'replica.stage': Asked<{
+        readonly locator: string;
+        readonly transfer: string;
+        readonly record: string | null;
+        readonly key: number | null;
+        readonly composition: Composition;
+        readonly entries: readonly StoredEntry[];
+        readonly folders: readonly string[];
+    }, number | null>;
+    readonly 'replica.refresh': Asked<{
+        readonly key: number;
+        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;
+        readonly kept: boolean;
+    }, number | null>;
+    readonly 'replica.release': Asked<{
+        readonly key: number;
+    }, null>;
+    readonly 'replica.rederive': Asked<{
+        readonly key: number;
+        readonly limit: number;
+    }, {
+        readonly done: boolean;
+    }>;
+    readonly 'replica.fact': Asked<{
+        readonly name: string;
+        readonly value: string;
+    }, null>;
+    readonly 'replica.present': Asked<{
+        readonly app: string;
+        readonly value: string;
+    }, null>;
+    readonly 'replica.receive': Asked<{
+        readonly key: string;
+        readonly head: string;
+        readonly part?: {
+            readonly index: number;
+            readonly value: string;
+        };
+    }, null>;
+    readonly 'replica.unreceive': Asked<{
+        readonly keys: readonly 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>;
+}
+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/turn.d.ts

@@ -1,6 +1,8 @@
 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>;
+export declare function after<T, R>(value: Later<T>, next: (value: T) => Later<R>): Later<R>;
+export declare function paced(): (weight: number) => Later<void>;
+export declare function inUnits<T>(items: Iterable<T>, each: (item: T) => number, ended?: () => void, paused?: () => Promise<void>): Later<void>;
+export declare function finished<R>(steps: Generator<number, R, void>): R;
+export declare function stepped<R>(steps: Generator<number, R, void>): Later<R>;

package/dist/mdruntime/wire.d.ts

@@ -34,18 +34,34 @@ 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.link': {
+        readonly reach: 'within';
+        readonly effect: 'read';
+    };
     readonly 'binaryFile.readReference': {
         readonly reach: 'within';
         readonly effect: 'read';
     };
+    readonly 'binaryFile.part': {
+        readonly reach: 'within';
+        readonly effect: 'read';
+    };
     readonly call: {
         readonly reach: 'actions';
         readonly effect: 'action';
@@ -58,6 +74,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 +114,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';
@@ -110,6 +134,10 @@ declare const MEMBERS: {
         readonly reach: 'within';
         readonly effect: 'action';
     };
+    readonly 'conversation.attach': {
+        readonly reach: 'within';
+        readonly effect: 'action';
+    };
     readonly 'conversation.answer': {
         readonly reach: 'within';
         readonly effect: 'action';
@@ -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.js

@@ -99,7 +99,7 @@ export function createHouseBridgeTestHost(options = {}) {
         });
     }
     const bridge = {
-        runtime,
+        runtime: runtime,
         address: () => shown,
         onAddress(listener) {
             return followHeld(addressListeners, listener, () => shown);

package/docs/families.md

@@ -12,7 +12,9 @@
   purpose-bound authenticated pages. The shell navigates only to a same-origin
   absolute path, carries its current address as the return target, and the page
   returns there when it completes. An App names an address House gave it in a
-  reading and composes none.
+  reading and composes one only for `/bind/<app_ref>`, where the User binds
+  its Rooms and connects its account slots, with `?slot=<name>` to open at one
+  slot.
 - **Installation** - `install()` offers the page as a Home-screen app. Where the
   browser has an install prompt ready the shell shows it and the call resolves
   `'accepted'` or `'dismissed'` with the User's choice, spending that prompt;
@@ -67,14 +69,15 @@
   refusal is House's `{ error: { code, retryable } }`, `app_release_not_found` for an
   App with no release; a read House does not answer, or one that outlived
   the browser's signed-in User, is `null`.
-- **External calls** - `callExternal({ url, method, headers, body, slot })`
+- **External calls** - `callExternal({ url, method, headers, body, slot, room_ref })`
   has House's server send an HTTPS request to one of the release's declared
   external origins and resolves with the service's `status`, `headers` and its
   body as `body` text or `body_base64`, or a refusal as House's
   `{ error: { code, retryable } }`, or `null` when House does not answer. House fills in the
-  App and its running release; naming an account slot places the key of the
-  account the User connected to it, which the App never sees, and naming none
-  sends no key. A Site's call names no slot, and the House panel names an
+  App and its running release; naming an account slot and one of the App's
+  bound Rooms places the key of the account that Room connects to the slot,
+  when the User holds one of the account's roles there, which the App never
+  sees, and naming neither sends no key. A Site's call names no slot, and the House panel names an
   `account` instead. `body_base64` replaces `body` for bytes.
 - **App messages** - `messages(listener)` hands the listener each message
   another holder of this App sends to this User's running copies, as `from`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentshouse/app-bridge",
-  "version": "0.1.0-c646d0da70608",
+  "version": "0.1.0-c66ec79ae3f1a",
   "description": "Types of the agents.house App bridge House hands every App: navigation, the tab title and icon, ceremonies, installation, notifications and the icon badge, status, Site image reads, App release code, App and Site screenshot reads, and App messages, with an accessor and an in-page test host.",
   "license": "MIT",
   "type": "module",

package/dist/mdruntime/acquisition.d.ts

@@ -1,13 +0,0 @@
-export type RuntimeDemand = {
-    readonly whole: boolean;
-    readonly rooms: readonly string[];
-    readonly handles: readonly string[];
-    readonly conversations: boolean;
-};
-export declare const WHOLE_DEMAND: RuntimeDemand;
-export declare function demanded(demand: RuntimeDemand, room: {
-    readonly locator: string;
-    readonly handle: string;
-}): boolean;
-export declare function wider(next: RuntimeDemand, current: RuntimeDemand): boolean;
-export declare function narrower(next: RuntimeDemand, current: RuntimeDemand): boolean;

package/dist/mdruntime/rows.d.ts

@@ -1,36 +0,0 @@
-import { type Frontmatter } from '../mdmodel/index.js';
-import type { HeadChange } from './adapter.js';
-import type { BinaryFileRecord } from './binary.js';
-import { type Composition } from './collection.js';
-type Fields = Readonly<Record<string, unknown>>;
-export type DocumentRow = {
-    key: string;
-    kind: 'document';
-    room: string;
-    path: string;
-    type: string | null;
-    fields: Fields;
-    values: Fields;
-    reached: Readonly<Record<string, readonly unknown[]>>;
-    directories: readonly string[];
-    text: string | null;
-    change: HeadChange | null;
-    binary: BinaryFileRecord | null;
-};
-export type ReferenceRow = {
-    key: string;
-    kind: 'reference';
-    room: string;
-    source: string;
-    target: string;
-    field: string;
-    forms: readonly string[];
-    path: string;
-    type: string;
-};
-export type Row = DocumentRow | ReferenceRow;
-export declare function documentKey(room: string, path: string): string;
-export declare function roomOfKey(key: string): string;
-export declare function markdownPath(path: string): boolean;
-export declare function rowsOf(room: string, path: string, document: Frontmatter | null, composition: Composition, change: HeadChange | null, binary: BinaryFileRecord | null): readonly Row[];
-export {};