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

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Anton (trof3039)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,70 +1,26 @@
 # @agentshouse/app-bridge
 
-The renderer-side client of the agents.house App bridge. An App served by House
-receives one message port before its own scripts run; this package is that
-port's one listener. It carries six families:
+The types of the agents.house App bridge, an accessor and an in-page test host.
+House builds the bridge object in every App it serves and hands it to the page
+before the App's own scripts run; `houseBridge()` returns that object, so an App
+carries no bridge code of its own. It carries eleven families: navigation,
+ceremonies, installation, notifications, status, Site image reads, App release
+code, external calls, App messages and App and Site screenshot reads.
+[docs/families.md](docs/families.md) describes each and the test host.
 
-- **Navigation** - the part of the shell's URL below the App's path, with its
-  query and fragment. The shell delivers it when the App starts and whenever the
-  User navigates; the App asks the shell to push or replace it. The App also
-  sets its tab's title and icon with `setTab({ title, icon })`, either or both:
-  a title of at most 200 characters and an icon given as a base64 `data:` URL
-  of an SVG, PNG, GIF or WebP image of at most 1,048,576 characters. The shell
-  shows them over the App's display name, or a Site's title, and its tab icon
-  until the next load, and ignores a request outside those bounds.
-- **Ceremony** - the App asks the shell to leave for one of House's own
-  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.
-- **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
-  `display-mode: standalone` media query tells the App it runs installed.
-- **Status** - the App reference the Runtime port is attached under, sync
-  state, credential state, release availability and observed failure, `ga`:
-  whether the page measures and the visitor's stored analytics choice, and
-  `service_mode`: `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
-  the choice never reaches House.
-- **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.
-- **App release code** - `sourceTop(app, release)` answers the top level of
-  the latest successful release of an App the User may use: its folders, its
-  files with their sizes and its root README's text, or `null` for none;
-  `sourceDownload(app, release)` answers every file of that release with its
-  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
-  App with no release; a read House does not answer, or one that outlived
-  the browser's signed-in User, is `null`.
-- **App screenshot read** - given an App reference, `readScreenshot(app)`
-  answers the image this browser captured of that App's screen the first time
-  it ran its current release, as a PNG `Blob` at most 1200 pixels wide, or
-  `null` when this browser holds none. The image stays in the browser; a Site
-  holds none.
+The bridge carries no credential handling and no Runtime family. House builds
+the MD Runtime client into the page beside the bridge, and `bridge.runtime`
+resolves to that client, so the App imports and constructs none.
 
-The package carries no credential handling and no Runtime family. It surfaces
-the dedicated Runtime port the worker transfers over the bridge as a plain
-message port, which the App hands to the MD Runtime client entry.
+House's `find_command` "App" is the guide to building an App or a Site.
 
 ## Use
 
 ```js
-import { connectHouseBridge } from '@agentshouse/app-bridge';
-import { connectMdRuntime } from '@agentshouse/mdruntime/client';
+import { houseBridge } from '@agentshouse/app-bridge';
 
-const bridge = connectHouseBridge();
-const md = connectMdRuntime(await bridge.runtime);
+const bridge = houseBridge();
+const md = await bridge.runtime;
 
 bridge.onAddress((address) => render(address));
 bridge.onStatus((status) => showSync(status.sync));
@@ -79,39 +35,25 @@ async function manageSecurity(securityPath) {
   try {
     await bridge.ceremony(securityPath);
   } catch (refusal) {
-    report(refusal);
+    if (refusal.name === 'HouseCeremonyRefused') report(refusal.path);
   }
 }
 ```
 
-`bridge.runtime` resolves with a structural `HouseMessagePort`. A consumer whose
-Runtime client entry asks for the DOM `MessagePort` type passes it through
-directly at run time and casts at the type level.
+`bridge.runtime` resolves to the `MdRuntimeClient` of `@agentshouse/mdruntime/client`,
+whose README describes its members. Its `call(method, params)` is a remote procedure call
+to a House act, such as `call('member.list', { room_ref })`: `HouseMethods` names each
+with its `params`, `HouseParams<Name>`, and its `result`, `HouseResult<Name>`.
 
 ## Test without a House
 
 ```js
-import { connectHouseBridge } from '@agentshouse/app-bridge';
+import { houseBridge } from '@agentshouse/app-bridge';
 import { createHouseBridgeTestHost } from '@agentshouse/app-bridge/test-host';
 
 const host = createHouseBridgeTestHost({ address: '/rooms/atlas' });
-const bridge = connectHouseBridge(host.port);
+const bridge = houseBridge();
 
 bridge.push('/rooms/atlas/members');
 host.open('/rooms/atlas');
 ```
-
-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 `readScreenshot` from the `screenshots` it was given by App
-reference, answers every `install()` `'manual'`, as a browser with no install
-prompt does, and attaches a Runtime port.