@agentshouse/app-bridge 0.1.0-cf2e2ca943fbc → 0.1.0-cf6672d6a6842

package/dist/{client/src/test-host.d.ts → test-host.d.ts}

@@ -1,14 +1,13 @@
-import type { MdRuntimeClient } from '@agentshouse/mdruntime/client';
-import type { HouseBridgeSource, HouseImageCopy } from './bridge.js';
-import type { HouseAppMessage, HouseExternalAnswer, HouseExternalRequest, HouseGaChoice, HouseNavigationMode, HouseRefusal, HouseSourceDownload, HouseSourceTop, HouseStatus, HouseTab } from './wire.js';
+import type { MdRuntimeClient } from './mdruntime/client.js';
+import type { HouseActivation, HouseAnalyticsChoice, HouseAppMessage, HouseExternalAnswer, HouseExternalRequest, HouseNavigationMode, HouseRefusal, HouseSourceDownload, HouseSourceTop, HouseStatus, HouseTab, HouseTask } from './index.js';
 export interface HouseBridgeNavigation {
     readonly mode: HouseNavigationMode;
     readonly address: string;
 }
-export interface HouseBridgeTestHost extends HouseBridgeSource {
+export interface HouseBridgeTestHost {
     readonly navigations: readonly HouseBridgeNavigation[];
     readonly ceremonies: readonly string[];
-    readonly consents: readonly HouseGaChoice[];
+    readonly consents: readonly HouseAnalyticsChoice[];
     readonly tabs: readonly HouseTab[];
     readonly externalCalls: readonly HouseExternalRequest[];
     address(): string;
@@ -16,13 +15,13 @@ export interface HouseBridgeTestHost extends HouseBridgeSource {
     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 images?: readonly (HouseImageCopy & {
-        readonly room: string;
-    })[];
     readonly sources?: readonly {
         readonly top: HouseSourceTop;
         readonly download: HouseSourceDownload;

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: 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);
+        },
+    };
+}

package/docs/families.md

@@ -12,37 +12,50 @@
   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;
   otherwise, as on every iPhone and iPad, it resolves `'manual'` and the App
   shows its own instructions. A prompt the browser refuses to show, as for a
-  call made without a click, rejects with the browser's own `DOMException`
-  and stays ready. Call it from a click. The standard
+  call made without a click, rejects with an error named and coded by the
+  browser's own error name, with `retryable` false, and stays ready. Call it from a click. The standard
   `display-mode: standalone` media query tells the App it runs installed.
 - **Notifications** - House's own panel alone; an App's or a Site's call
-  rejects with `HouseCeremonyRefused`. `notifications()` answers this browser
+  rejects with an error named `HouseCeremonyRefused`, carrying `code` and `retryable`. `notifications()` answers this browser
   storage's push state: `'on'`, `'off'`, `'blocked'` where the browser refuses
   notifications, or `'unavailable'` where it has no push, as on an iPhone or
   iPad outside a Home-screen app. `notifications(true)` asks the browser's
   permission and subscribes, `notifications(false)` unsubscribes, and each
-  answers the state it leaves; a failure of the browser's push service rejects
-  with the browser's own `DOMException`. Call `notifications(true)` from a
+  answers the state it leaves; a failure of the browser's push service, and
+  of `setBadge`, rejects the same way. Call `notifications(true)` from a
   click. `setBadge(unread)` takes the identifiers of the Human Notifications
   unread in this storage and sets the icon's badge to their number, or clears
   it at none, where the browser shows one.
 - **Status** - the App reference the runtime client is attached under,
-  `preferences`: the `room_ref` and Path of the App's own preferences document,
+  `preferences`: the `roomRef` and Path of the App's own preferences document,
   or `null` until the runtime holds that Room, sync
-  state, credential state and observed failure, `ga`:
+  state, credential state and its `expiresAt`, observed failure, `analytics`:
   whether the page measures and the visitor's stored analytics choice, and
-  `service_mode`: `open`, `write-halted` while House refuses writes, so the
+  `serviceMode`: `open`, `write-halted` while House refuses writes, so the
   App can stop retrying them, or `null` while the runtime holds no House
-  connection.
-  The App reports the visitor's choice with `gaConsent('accept')` or
-  `gaConsent('decline')`; the shell hands it to House's analytics loader, and
+  connection. Every status field is camelCase. `onStatus(listener)` and
+  `onAddress(listener)` hand a listener the status and the address the bridge
+  already holds, then each change.
+  The App reports the visitor's choice with `analyticsConsent('accept')` or
+  `analyticsConsent('decline')`; the shell hands it to House's analytics loader, and
   the choice never reaches House.
+- **Handoff** - when House hands its runtime over to a newer build, the App keeps
+  running, its `runtime` client and observations included: a call it makes
+  meanwhile waits for the newer runtime, however long that takes, and is
+  answered once, by it; each observation goes on with the newer runtime's
+  values; and the status and the address arrive again. A runtime that ended
+  before answering has its reads answered by the next one; since it may have
+  applied any other call, an act on House is answered the outcome
+  `transport-uncertainty`, and every other call, a Save or a draft write among
+  them, fails with the retryable code `transport-uncertainty`.
 - **Site image read** - given a Published Room and an original attachment
   reference, it answers the web copy's path and metadata, or `null` when no
   copy exists. The original bytes never cross this bridge at a Site.
@@ -53,23 +66,24 @@
   path, its size and its `text`, or its bytes as `base64`. The browser keeps
   each answer per App and release: a read naming a release it holds answers
   without asking House, and keeping a newer release drops the earlier one. A
-  refusal is House's `{ error: { code } }`, `app_release_not_found` for an
+  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 } }`, 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
+  `{ error: { code, retryable } }`, or `null` when House does not answer. House fills in the
+  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`,
   the sender's User id, and `body`, the JSON value they sent, until the
   function it returns is called. App code sends one through the Runtime's
-  `call('apps/messages/send', { to, body })` with the recipient's User id and
+  `call('message.send', { to, body })` with the recipient's User id and
   a body of at most 32 KiB of JSON; House fills in the App and relays it only
   to copies running now, storing nothing. The panel sends none.
 - **App screenshot read** - given an App reference, `readScreenshot(app)`
@@ -82,25 +96,54 @@
   after its latest release, as a JPEG `Blob`, or `null` when House holds none
   or does not answer. A Site's own renderer reads none.
 
+- **Cooperation** - `cooperate({ checkpoint, persist, capture, restore,
+ready, settle })` lets House activate a newer release of the App while it
+  runs, keeping the User's task; the function it returns withdraws it.
+  Register it in the entry script, before the first draw, or House treats the
+  page as not cooperating and the newer release waits for the App's next
+  open. When a newer release is stored, House calls `checkpoint()`, which
+  resolves at the App's next safe checkpoint and may never resolve, then
+  `persist()`, which makes authored work durable, then `capture()`, which
+  answers the meaningful task the App owns, such as the selected record,
+  filters, cursor, selection and scroll position, as JSON of at most 65,536
+  characters; House keeps the address itself. In the newer release House
+  calls `restore(task)` once its document has drawn, so the scroll position
+  and focus it sets hold, or `restore(null)` when it opens the release without
+  a task, then `ready()`, the App's own check that its local data and
+  capabilities work, and finally `settle('committed')` once the release is
+  active or `settle('abandoned')` when House returns to the release before
+  it, restoring the same task there. A release House opens already active is
+  settled `'committed'` at once, after `restore(task)` when House hands it a
+  task, and a cooperation registered after House settled is settled at its
+  registration. Until `settle('committed')` House fails the release's outside
+  calls at once, as offline, those of the workers it starts included, and
+  refuses its Saves, write acts and external calls with the retryable code
+  `house_trial_withheld`, so a start-up effect is not repeated; run start-up
+  effects after `settle('committed')`.
+
 ## The test host
 
-The host plays the shell and the worker: it delivers the address the App starts
-at and each address `open` plays as Back or Forward through the shell's own
-slice below the App's path, admitting nothing, so it delivers `//notes` exactly
-as a browser at `/apps/<app>//notes` does. It records every push and replace
-and answers each with the address the shell would then show, records an
-admitted ceremony, refuses a push, replace or ceremony that is not a
-same-origin absolute path, publishes a status, its `service_mode` included,
-records in `consents` each
-`gaConsent` it takes while that status measures and publishes the status the
-choice leaves, records in `tabs` each `setTab` the shell would take and ignores
-any other, answers a release code read from the `sources` it was given, or
-`null`, answers each `callExternal` from the `external` function it was given, or
-`null`, and records the request in `externalCalls`, answers `readScreenshot`
-from the `screenshots` it was given by App
-reference and `readSiteScreenshot` from the `siteScreenshots` it was given by
-Site identifier, answers every `install()` `'manual'`, as a browser with no install
-prompt does, answers every `notifications()` `'unavailable'`, as a browser
-without push does, settles every `setBadge`, delivers each App message
-`message({ from, body })` plays, and hands `bridge.runtime` the MD Runtime
-client `attachRuntime(client)` gives it.
+`createHouseBridgeTestHost(options)` plays House in one page: it installs a
+bridge object that `houseBridge()` returns, until the next host replaces it.
+It delivers the address the App starts at and each address `open` plays as
+Back or Forward, admitting nothing, so it delivers `//notes` exactly as a
+browser at `/apps/<app>//notes` does. It records every push and replace and
+answers each with the address the shell would then show, records an admitted
+ceremony, and refuses a push, replace or ceremony that is not a same-origin
+absolute path of at most 1,000 characters with an error named
+`HouseNavigationRefused` or `HouseCeremonyRefused`. It publishes a status,
+its `serviceMode` included, records in `consents` each `analyticsConsent` it
+takes while that status measures and publishes the status the choice leaves,
+records in `tabs` each `setTab`, answers a release code read from the
+`sources` it was given, or `null`, answers each `callExternal` from the
+`external` function it was given, or `null`, and records the request in
+`externalCalls`, answers `readScreenshot` from the `screenshots` it was given
+by App reference and `readSiteScreenshot` from the `siteScreenshots` it was
+given by Site identifier, answers every `install()` `'manual'`, as a browser
+with no install prompt does, answers every `notifications()` `'unavailable'`,
+as a browser without push does, settles every `setBadge`, delivers each App
+message `message({ from, body })` plays, and hands `bridge.runtime` the MD
+Runtime client `attachRuntime(client)` gives it. `checkpoint()` runs the
+registered cooperation's checkpoint, persist and capture and answers the task,
+`restore(task)` runs its restore and answers its readiness check, and
+`settle(activation)` hands it the outcome.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agentshouse/app-bridge",
-  "version": "0.1.0-cf2e2ca943fbc",
-  "description": "Renderer-side client of the agents.house App bridge: 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 in-page test host.",
+  "version": "0.1.0-cf6672d6a6842",
+  "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",
   "sideEffects": false,
@@ -10,17 +10,14 @@
   },
   "exports": {
     ".": {
-      "types": "./dist/client/src/index.d.ts",
-      "default": "./dist/client/src/index.js"
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
     },
     "./test-host": {
-      "types": "./dist/client/src/test-host.d.ts",
-      "default": "./dist/client/src/test-host.js"
+      "types": "./dist/test-host.d.ts",
+      "default": "./dist/test-host.js"
     }
   },
-  "dependencies": {
-    "@agentshouse/mdruntime": "0.1.0-cacb4c3f6734e"
-  },
   "files": [
     "dist",
     "docs",

package/dist/client/src/bridge.d.ts

@@ -1,38 +0,0 @@
-import type { MdRuntimeClient } from '@agentshouse/mdruntime/client';
-import type { HouseAppMessage, HouseExternalAnswer, HouseExternalRequest, HouseBridgePort, HouseGaChoice, HouseImageCopy, HouseInstallation, HouseNotifications, HouseRefusal, HouseSourceDownload, HouseSourceTop, HouseStatus, HouseTab } from './wire.js';
-export type { HouseImageCopy } from './wire.js';
-export declare class HouseCeremonyRefused extends Error {
-    readonly path: string | null;
-    constructor(path: string | null);
-}
-export declare class HouseNavigationRefused extends Error {
-    readonly address: string | null;
-    constructor(address: string | null);
-}
-export interface HouseBridgeSource {
-    readonly port: Promise<HouseBridgePort>;
-    readonly runtime: Promise<MdRuntimeClient>;
-}
-export interface HouseBridge {
-    readonly runtime: Promise<MdRuntimeClient>;
-    address(): string | null;
-    onAddress(listener: (address: string) => void): () => void;
-    push(address: string): Promise<string>;
-    replace(address: string): Promise<string>;
-    ceremony(path: string): Promise<never>;
-    install(): Promise<HouseInstallation>;
-    notifications(on?: boolean): Promise<HouseNotifications>;
-    setBadge(unread: readonly string[]): Promise<void>;
-    setTab(tab: HouseTab): void;
-    readAttachment(room: string, attachment: string): Promise<HouseImageCopy | null>;
-    sourceTop(app: string, release?: string): Promise<HouseSourceTop | HouseRefusal | null>;
-    sourceDownload(app: string, release?: string): Promise<HouseSourceDownload | HouseRefusal | null>;
-    callExternal(request: HouseExternalRequest): Promise<HouseExternalAnswer | HouseRefusal | null>;
-    readScreenshot(app: string): Promise<Blob | null>;
-    readSiteScreenshot(site: string): Promise<Blob | null>;
-    status(): HouseStatus | null;
-    onStatus(listener: (status: HouseStatus) => void): () => void;
-    messages(listener: (message: HouseAppMessage) => void): () => void;
-    gaConsent(choice: HouseGaChoice): void;
-}
-export declare function connectHouseBridge(source?: HouseBridgeSource): HouseBridge;