@nervur-org/dock 0.5.0 → 0.6.0

package/dist/harbor/edge/edge.js

@@ -1,24 +1,19 @@
 import { isSilence } from 'nervur';
-import { User, Desk, Avatar, Clock } from '../../beings/index.js';
+import { BEINGS } from '../../beings/index.js';
 import { setup } from '../../beings/setup.js';
 import { Harbor, Socket as Held } from 'nervur/harbor';
 import { quoRoute } from '../quo.js';
 import { webRoute } from '../../human/web.js';
-import { DOCK, TIMER, Console, facultyOf, settled, stand } from '../../dock/index.js';
 import { Alarm, alarmsIn } from './alarm.js';
-import { Grants, GRANTS } from '../../dock/grants.js';
+import { BOX_SEED, GRANTS, Grants, Http, TIMER, WIRE, harborageOver, keyed, lent, settled, standHarbor } from '../../box/index.js';
 import { find, letIn } from '../../beings/join.js';
 import { apiRoute } from '../../api/route.js';
 import { mcpRoute } from '../../mcp/route.js';
 import { McpHttp } from '../../mcp/http.js';
 import { Exchange } from '../../mcp/allow.js';
 import { DurableStorage, danceInStorage, folderInStorage, settingsInStorage, wearInStorage } from './storage.js';
-import { LENT } from './given.js';
+import {} from './given.js';
 import { sealKey } from '../seal.js';
-// The beings a deployed worker carries. The Clock is among them because this
-// terrain lends a timer: a box that lends one and holds no class that can ask
-// for a wake lends a name nobody there could use.
-export const BUILT_IN = { User, Desk, Avatar, Clock };
 const json = (status, v, headers = {}) => new Response(JSON.stringify(v), { status, headers: { 'content-type': 'application/json', ...headers } });
 export class EdgeHarbor extends Harbor {
     sockets = new Set();
@@ -32,9 +27,6 @@ export class EdgeHarbor extends Harbor {
     // The model side's dance, one key in the same object: clients, pending
     // requests and codes, all of them living minutes.
     dance;
-    // The object's storage, unprefixed and unsealed: the alarm is the object's
-    // own and is no row.
-    #storage;
     #booted;
     // The MCP endpoint, one per instance: a session is a client's connection
     // and belongs to the harbor, not to the request that opened it.
@@ -47,18 +39,32 @@ export class EdgeHarbor extends Harbor {
         if (!env.NERVUR_SEED_KEY)
             throw new Error('no NERVUR_SEED_KEY: a seed is never kept plain on the edge');
         const harbor = new EdgeHarbor(new DurableStorage(state.storage, await sealKey(env.NERVUR_SEED_KEY)), env.NERVUR_ROOT, deployed);
-        harbor.lent = LENT;
+        // What a worker brings to its own ward, and it is the whole of it. A
+        // bearer to an identity in a world is a record in the grants' cells and
+        // nothing else, so the grants are the same code here as on a disk. The
+        // timer is the same class too, with the one method that knows a terrain
+        // replaced: `Alarm` arms the object's own storage alarm.
+        //
+        // Nothing else is brought, each for its own reason. A worker is at no
+        // place and before no screen, so no location and no notifications. Push
+        // rings under this world's own web origin, which a worker learns from
+        // the request and not at boot. And no process stands behind a worker, so
+        // no way in over a socket, no dialers and no agents.
+        // Only the object may set its own alarm, so the two calls are handed to
+        // the timer in the class body this object brings.
+        const alarms = alarmsIn(state.storage);
+        class ObjectAlarm extends Alarm {
+            constructor(stance, box) {
+                super(stance, box, alarms);
+            }
+        }
+        harbor.faculties = { box: { Grants, Http }, harbor: { edge: { Alarm: ObjectAlarm } } };
         return harbor;
     }
     constructor(store, root, deployed = {}) {
-        // The faculty classes this terrain can stand, beside the beings: the box
-        // ward's own front desk and the grants its routes honour. They are named
-        // here and not left to the deploy, because `lent` names classes and a
-        // name the loader cannot find is a ward that would not boot.
-        super(store, async () => ({ ...BUILT_IN, Console, Grants, Alarm, ...deployed.classes }));
+        super(store, async () => keyed({ ...BEINGS, classes: deployed.classes ?? {} }));
         this.root = root;
         this.deployed = deployed;
-        this.#storage = store.storage;
         // The rows live beside the wards in the same object, under the same
         // prefix, so an exercise standing two harbors in one object gives each
         // its own settings and its own design.
@@ -72,11 +78,14 @@ export class EdgeHarbor extends Harbor {
     async given() {
         return { ...this.deployed, settings: await this.settings.load(), folder: this.folder };
     }
-    // What this box lends, by name. Set before the first request and read at
-    // the boot; a harbor that says nothing stands no ward of its own and lends
-    // nothing. `given.ts` holds the list a deployed worker uses and why it is
-    // that list.
-    lent;
+    // The classes this terrain brings to its own ward, as a tree. Set before
+    // the first request and read at the boot; a harbor that brings none stands
+    // no ward of its own and lends nothing. The deploy's own classes join them,
+    // so an estate's faculty stands beside the terrain's.
+    faculties;
+    // What this harbor is to its faculties: the box ward's save, which on this
+    // terrain is the one place the box keeps its state, and up once booted.
+    box = harborageOver(() => this.wards.get(BOX_SEED)?.save() ?? Promise.resolve());
     // Once per instance, on the first request: the platform may have woken a
     // fresh instance, and every ward boots from storage before anything is
     // answered.
@@ -89,22 +98,13 @@ export class EdgeHarbor extends Harbor {
     // keeps, then the beings who took what the box lends: a box is up when
     // they have landed.
     async boot() {
-        if (this.lent) {
-            this.lend = await stand(this, this.lent);
-            // A token issued is a cell written, and the cells are the dock ward's
-            // partition like every faculty's: there is no second place on this
-            // terrain for the box to keep its state.
-            const grants = facultyOf(this, GRANTS);
-            if (grants)
-                grants.persist = () => this.wards.get(DOCK)?.save() ?? Promise.resolve();
-            // The clock here is the object's alarm, and only the object may set its
-            // own, so the timer is handed the two calls the same way.
-            const timer = facultyOf(this, TIMER);
-            if (timer)
-                timer.alarms = alarmsIn(this.#storage);
+        if (this.faculties) {
+            const tree = { ...this.faculties, classes: this.deployed.classes ?? {} };
+            await standHarbor(this, tree, this.box);
         }
         await super.boot();
-        await settled();
+        await settled(this);
+        await this.box.raise();
     }
     // The alarm went off: no request, no route and nobody asking, which is the
     // whole point of it. The box ward is up by now, so the round runs and the
@@ -115,7 +115,7 @@ export class EdgeHarbor extends Harbor {
     // saw it. A box whose alarm fired and whose partition was not written would
     // fire the same minute again on its next wake.
     async rang() {
-        const timer = facultyOf(this, TIMER);
+        const timer = await lent(this, TIMER);
         if (!timer)
             return;
         try {
@@ -130,8 +130,8 @@ export class EdgeHarbor extends Harbor {
     // The box's grants, for the routes that honour a bearer. Undefined is a
     // harbor that stands no box ward, which is the exercise and nothing a
     // deploy does.
-    get grants() {
-        return facultyOf(this, GRANTS);
+    grants() {
+        return lent(this, GRANTS);
     }
     // The web side, built per request because its whole configuration is rows
     // a root writes while the worker runs. It is the same `webRoute` the daemon
@@ -171,7 +171,7 @@ export class EdgeHarbor extends Harbor {
     // as a folder with several wards and no mark does. The box's own ward is
     // furniture and never a candidate.
     here() {
-        const worlds = [...this.wards.keys()].filter((n) => n !== DOCK);
+        const worlds = [...this.wards.keys()].filter((n) => n !== BOX_SEED);
         return worlds.length === 1 ? worlds[0] : '';
     }
     // What a route asks of a ward here: her avatar as she stands, and her way
@@ -190,17 +190,16 @@ export class EdgeHarbor extends Harbor {
     };
     // The worlds a client may be let into: every ward here but the box's own.
     #worlds = () => [...this.wards]
-        .filter(([ward]) => ward !== DOCK)
+        .filter(([ward]) => ward !== BOX_SEED)
         .map(([ward, h]) => ({ ward, pk: h.pk, user: h.record.user }));
     // The program side. The same `apiRoute` the daemon mounts, on the grants of
     // this box's own ward: a request with no bearer is the stranger every route
     // knows, and one with a bearer this box granted is an occupant.
-    async api(request, path, base) {
-        const grants = this.grants;
+    async api(request, path) {
+        const grants = await this.grants();
         if (!grants)
             return json(503, { error: 'this box stands no ward of its own, so it grants nothing' });
-        const at = await this.routes(base);
-        const route = apiRoute({ wards: this.wards, here: () => this.here() }, { grants, resolve: this.#resolve, join: this.#join, web: at.web });
+        const route = apiRoute({ wards: this.wards, here: () => this.here() }, { grants, resolve: this.#resolve, join: this.#join });
         return (await route(request, path.slice('/api'.length))) ?? json(404, { error: 'no such route' });
     }
     // The model side: the OAuth dance, kept in this object's own storage, and
@@ -210,7 +209,7 @@ export class EdgeHarbor extends Harbor {
     // while one is held and a client that comes back to a woken instance
     // reconnects, which is what a reconnect is for.
     async mcp(request, path, base) {
-        const grants = this.grants;
+        const grants = await this.grants();
         if (!grants)
             return json(503, { error: 'this box stands no ward of its own, so it grants nothing' });
         const endpoint = (this.#mcp ??= new McpHttp(this.#resolve, async () => {
@@ -225,7 +224,7 @@ export class EdgeHarbor extends Harbor {
     // The dance's discovery under this prefix, for a caller that reaches the
     // harbor at a path rather than at an origin of its own.
     async wellKnown(request, path, base) {
-        const grants = this.grants;
+        const grants = await this.grants();
         if (!grants)
             return json(404, { error: 'no such route' });
         const route = await mcpRoute(this.dance, await this.routes(base), null, grants);
@@ -234,7 +233,7 @@ export class EdgeHarbor extends Harbor {
     // The exchange, for the allow page on the web side: the dance it finishes
     // is the same one the model side keeps.
     async exchange(base) {
-        const grants = this.grants;
+        const grants = await this.grants();
         if (!grants)
             return undefined;
         const route = await mcpRoute(this.dance, await this.routes(base), null, grants);
@@ -252,7 +251,7 @@ export class EdgeHarbor extends Harbor {
     async fetch(request, path, base) {
         await this.ready();
         const out = await this.#route(request, path, base);
-        await facultyOf(this, TIMER)?.setting;
+        await (await lent(this, TIMER))?.setting;
         return out;
     }
     async #route(request, path, base) {
@@ -263,7 +262,7 @@ export class EdgeHarbor extends Harbor {
         if (path === '/web' || path.startsWith('/web/'))
             return this.web(request, path, base);
         if (path === '/api' || path.startsWith('/api/'))
-            return this.api(request, path, base);
+            return this.api(request, path);
         if (path === '/mcp' || path.startsWith('/mcp/'))
             return this.mcp(request, path, base);
         if (path.startsWith('/.well-known/'))
@@ -275,7 +274,13 @@ export class EdgeHarbor extends Harbor {
                 return this.upgrade();
             return (await quoRoute(this)(request, path.slice('/quo'.length))) ?? json(404, { error: 'no such route' });
         }
-        return json(404, { error: 'no such route' });
+        // Every other path is the box's wire: a faculty that claims it answers,
+        // as the object's path and never the platform's prefix.
+        const wire = await lent(this, WIRE);
+        if (!wire)
+            return json(404, { error: 'no such route' });
+        const url = new URL(request.url);
+        return wire.handle(new Request(new URL(`${path}${url.search}`, url.origin), request));
     }
     health() {
         return {
@@ -328,7 +333,7 @@ export class EdgeHarbor extends Harbor {
                 if (this.wards.has(name))
                     return json(409, { error: `ward ${name} already exists here` });
                 const hosted = await this.create(name, user);
-                await setup(hosted, user);
+                await setup(hosted, user, typeof body.init.class === 'string' ? { home: body.init.class } : {});
                 return json(200, { name, pk: hosted.pk, user });
             }
             // The settings, merged over what is kept and answered whole, so a root

package/dist/harbor/edge/exercise.js

@@ -180,14 +180,14 @@ export async function exercise(request, base, path, state, env) {
     // the same refusal. That the number a deployment runs under is the
     // platform's own is the line below it, which asks the store directly.
     test('[edge] a row past the object s ceiling is refused, the arrival that wrote it fails at the door, and she stands at what is kept', {}, async () => {
-        const key = await sealKey(env.NERVUR_SEED_KEY ?? '');
+        const sealed = await sealKey(env.NERVUR_SEED_KEY ?? '');
         const small = 8_000;
-        const h = new EdgeHarbor(new DurableStorage(state.storage, key, `c:${Date.now()}:`, small), undefined, DEPLOYED);
+        const h = new EdgeHarbor(new DurableStorage(state.storage, sealed, `c:${Date.now()}:`, small), undefined, DEPLOYED);
         await h.ready();
         const w = await h.create(`ceiling-${Date.now()}`);
         for (const [k, c] of [
-            ['P', 'Printer'],
-            ['A', 'Customer'],
+            ['P', 'classes/Printer'],
+            ['A', 'classes/Customer'],
         ])
             assert.deepEqual(await w.ask('boot', { key: k, class: c }), { booted: k });
         const printer = w.being('P');

package/dist/harbor/edge/given.d.ts

@@ -1,7 +1,6 @@
 import type { BeingClass } from 'nervur';
 import type { Apps, Folder } from '../../human/web.ts';
 import type { Routes } from '../../mcp/route.ts';
-export declare const LENT: Record<string, string>;
 export declare const ROW_CEILING = 2000000;
 export type Code = {
     tab: string;

package/dist/harbor/edge/given.js

@@ -1,32 +1,3 @@
-import { GRANTS } from '../../dock/grants.js';
-import { TIMER } from '../../dock/index.js';
-// What a worker lends the beings of the wards it holds, by name to the class
-// that stands for it. The box's state has one home on every terrain, the box
-// ward's partition, so the edge stands that ward like every other terrain;
-// what differs is this list, and a faculty the platform has no answer for is
-// not lent at all rather than lent and hollow.
-//
-// `grants` and `timer` are lent, and they are the whole of it. A bearer to an
-// identity in a world is a record in her cells and nothing else, so the
-// grants are the same code here as on a disk and the routes that honour a
-// bearer, `api.` and `mcp.`, work the moment she stands. The timer is the
-// same class too, with the one method that knows a terrain replaced: she arms
-// the object's own storage alarm, which is the clock here, so a home on this
-// terrain wakes for its schedules with nobody asking. `Alarm` in
-// `edge/alarm.ts` is that subclass.
-//
-// The three others every box ships are not lent here, each for its own
-// reason. `location` and `notifications` are a place and a screen, and a
-// worker is at neither: it runs wherever the platform put it and no human is
-// looking at it. `push` rings under this world's own web origin, and a worker
-// learns its origin from the request it is answering and not at boot, so a
-// ring signed at the moment the faculty stood would be signed for nowhere.
-//
-// There is no process on the other side of a worker either, so `local`,
-// `dialers` and `agents`, which the daemon adds, name nothing here: no
-// socket a process was seen on, no line this box holds open, and no command
-// to run an agent in.
-export const LENT = { [GRANTS]: 'Grants', [TIMER]: 'Alarm' };
 // The ceiling on one row in this object's storage, key and value together,
 // in bytes. The platform publishes it for a SQLite-backed Durable Object,
 // which is what `wrangler.toml` declares this class to be, and past it the

package/dist/harbor/edge/storage.d.ts

@@ -4,8 +4,6 @@ import type { Folder } from '../../human/web.ts';
 import { type SettingsStore } from './given.ts';
 import type { Rows, Storage } from './platform.d.ts';
 export declare function settingsInStorage(storage: Rows, prefix?: string): SettingsStore;
-export declare const DESIGN_ROW = "design:";
-export declare const BEINGS_ROW = "beings";
 export declare function folderInStorage(storage: Rows, prefix?: string): Folder;
 export declare function wearInStorage(storage: Rows, prefix?: string): {
     put: (file: string, text: string | null) => Promise<void>;

package/dist/harbor/edge/storage.js

@@ -35,8 +35,8 @@ export function settingsInStorage(storage, prefix = '') {
 // storage instead. A row is text, because a stylesheet is text and so is a
 // bundle; a file the root has not put there answers nothing and the route
 // declines the path.
-export const DESIGN_ROW = 'design:';
-export const BEINGS_ROW = 'beings';
+const DESIGN_ROW = 'design:';
+const BEINGS_ROW = 'beings';
 export function folderInStorage(storage, prefix = '') {
     const design = (file) => `${prefix}${DESIGN_ROW}${file}`;
     const held = (file) => storage.get(design(file)).then((v) => v ?? null);

package/dist/harbor/http.js

@@ -87,7 +87,9 @@ export async function listenHttp(harbor, host, port, quo) {
                     faults: Object.fromEntries([...harbor.faults]),
                 }, { headers: { 'access-control-allow-origin': '*' } });
             }
-            for (const [prefix, handler] of mounts) {
+            // the longest prefix first, so a route mounted later under a longer
+            // path is still tried before the wire mounted at the root
+            for (const [prefix, handler] of [...mounts].sort(([a], [b]) => b.length - a.length)) {
                 if (url.pathname === prefix || url.pathname.startsWith(prefix + '/')) {
                     const out = await handler(asRequest(req, url), url.pathname.slice(prefix.length));
                     if (out)
@@ -161,7 +163,7 @@ function asRequest(req, url) {
 async function writeResponse(out, res) {
     const headers = {};
     out.headers.forEach((v, k) => {
-        headers[k] = k === 'set-cookie' ? [...(Array.isArray(headers[k]) ? headers[k] : []), v] : v;
+        headers[k] = k === 'set-cookie' ? [...(Array.isArray(headers[k]) ? (headers[k]) : []), v] : v;
     });
     res.writeHead(out.status, headers);
     if (!out.body)

package/dist/harbor/sealed.d.ts

@@ -28,8 +28,3 @@ export declare class Sealed implements Store {
     hints(): Promise<Record<string, string>>;
     hint(pk: string, url: string): Promise<void>;
 }
-export declare function inMemory(): {
-    files: Files;
-    secrets: Secrets;
-    disk: Map<string, string>;
-};

package/dist/harbor/sealed.js

@@ -121,42 +121,3 @@ export class Sealed {
         await this.#files.write(`quo/${this.harbor}/reach.json`, JSON.stringify(all) + '\n');
     }
 }
-// Files and secrets in memory, for a suite and for a box that keeps
-// nothing: the custody rule is proven here once and holds on every
-// platform that hands the two.
-export function inMemory() {
-    const disk = new Map();
-    const dirs = new Set();
-    const vault = new Map();
-    const under = (dir) => [...disk.keys()].filter((k) => k.startsWith(`${dir}/`));
-    const files = {
-        exists: async (p) => disk.has(p) || dirs.has(p),
-        read: async (p) => {
-            const v = disk.get(p);
-            if (v === undefined)
-                throw new Error(`no such file: ${p}`);
-            return v;
-        },
-        write: async (p, text) => void disk.set(p, text),
-        remove: async (p) => void disk.delete(p),
-        mkdir: async (p) => {
-            const parts = p.split('/');
-            for (let i = 1; i <= parts.length; i += 1)
-                dirs.add(parts.slice(0, i).join('/'));
-        },
-        rmdir: async (p) => {
-            for (const k of under(p))
-                disk.delete(k);
-            for (const d of [...dirs])
-                if (d === p || d.startsWith(`${p}/`))
-                    dirs.delete(d);
-        },
-        list: async (p) => under(p).map((k) => k.slice(p.length + 1)).filter((k) => !k.includes('/')),
-    };
-    const secrets = {
-        get: async (i) => vault.get(i),
-        set: async (i, v) => void vault.set(i, v),
-        remove: async (i) => void vault.delete(i),
-    };
-    return { files, secrets, disk };
-}

package/dist/harbor/tauri.d.ts

@@ -1,5 +1,5 @@
 import type { BeingClass, JsonObject } from 'nervur';
-import { Notifications } from '../dock/index.ts';
+import { Notifications } from '../box/index.ts';
 import { BrowserHarbor } from './browser.ts';
 import { type Files, type Secrets } from './sealed.ts';
 export type Core = {
@@ -8,9 +8,9 @@ export type Core = {
 export declare class DeskNotifications extends Notifications {
     #private;
     constructor(stance: ConstructorParameters<typeof Notifications>[0], core: Core);
+    static stands(): boolean;
     notify(args: JsonObject): Promise<JsonObject>;
 }
-export declare const deskLent: Record<string, string>;
 export declare function deskFiles(core: Core): Files;
 export declare function deskSecrets(core: Core): Secrets;
 export declare function deskHarbor(core: Core, name?: string, classes?: Record<string, BeingClass>): Promise<BrowserHarbor>;

package/dist/harbor/tauri.js

@@ -1,4 +1,4 @@
-import { NOTIFICATIONS, Notifications } from '../dock/index.js';
+import { Notifications } from '../box/index.js';
 import { BrowserHarbor } from './browser.js';
 import { Sealed } from './sealed.js';
 export class DeskNotifications extends Notifications {
@@ -7,6 +7,11 @@ export class DeskNotifications extends Notifications {
         super(stance);
         this.#core = core;
     }
+    // A desk's notification center is its core's, and a class handed a core
+    // stands wherever it was handed one.
+    static stands() {
+        return true;
+    }
     async notify(args) {
         const title = typeof args.title === 'string' ? args.title : '';
         const body = typeof args.body === 'string' ? args.body : '';
@@ -14,13 +19,6 @@ export class DeskNotifications extends Notifications {
         return { shown: true };
     }
 }
-// What a desk lends: its notification center, under the name every box
-// lends it under. Location is what the platform gives, which on a desk is
-// nothing, so it is not lent rather than lent and dumb. No timer either: a
-// desk holds presences and no home, so no Clock lives on it and a Timer
-// there would arm for nobody. A Timer stands only on a box that hosts a
-// home.
-export const deskLent = { [NOTIFICATIONS]: 'Notifications' };
 // The two seams over the core's commands. Paths are relative to the app's
 // data folder, and the core refuses one that climbs out of it.
 export function deskFiles(core) {
@@ -52,8 +50,13 @@ export async function deskHarbor(core, name = 'nervur', classes = {}) {
         }
     }
     const store = await Sealed.open(name, deskFiles(core), deskSecrets(core));
-    const h = new BrowserHarbor(store, { Notifications: Center, ...classes });
-    await h.stand(deskLent);
+    // A desk brings its notification center and nothing else. Location is what
+    // the platform gives, which on a desk is nothing, so no class for it is
+    // brought rather than one brought and dumb. No timer either: a desk holds
+    // presences and no home, so no Clock lives on it and a Timer there would
+    // arm for nobody.
+    const h = new BrowserHarbor(store, classes);
+    await h.stand({ harbor: { DeskNotifications: Center } });
     await h.boot();
     return h;
 }

package/dist/human/app.d.ts

@@ -2,7 +2,7 @@ import type { Harbor } from 'nervur/harbor';
 import type { Invitation, JsonObject } from 'nervur';
 import { type Joined, type World } from './worlds.ts';
 import { type Bell } from './wake.ts';
-import type { Token } from '../dock/index.ts';
+import type { Token } from '../box/index.ts';
 import type { Config } from './tab.ts';
 export type Learn = (at: string) => Promise<Config>;
 export declare const learn: Learn;

package/dist/human/app.js

@@ -3,7 +3,7 @@ import { domSurface } from './dom.js';
 import { guest } from './guest.js';
 import { door, held as heldPage } from './door.js';
 import { USER } from '../beings/avatar.js';
-import { DOCK, CONSOLE, NOTIFICATIONS, settled } from '../dock/index.js';
+import { BOX, BOX_SEED, NOTIFICATIONS, Notifications, lent, settled } from '../box/index.js';
 import { fresh, joined, localName, ordered, relations, world } from './worlds.js';
 import { giveWorld, takeWorld } from './move.js';
 import { invitationOf, reachOf } from '../beings/link.js';
@@ -89,7 +89,7 @@ export async function app(o) {
     // by class and a class beats the hidden attribute.
     //
     // Its last entry is never a world: it is this device, the box's own ward
-    // shown through the Console, where a human sees what the box lends and
+    // shown through its own being, where a human sees what the box lends and
     // leaves a world. A box that lends nothing has no such page.
     const switcher = () => {
         nav.replaceChildren();
@@ -220,16 +220,16 @@ export async function app(o) {
         });
         side = s;
     };
-    // The box's own ward, as its harbor stood it: the Console carrying every
+    // The box's own ward, as its harbor unpacked it: its being carrying every
     // faculty this box lends. A box that lends nothing stands none, and there
     // is no page of its own to show.
     const deviceWard = async () => {
-        const ward = o.harbor.wards.get(DOCK);
-        if (!ward || !ward.being(CONSOLE))
+        const ward = o.harbor.wards.get(BOX_SEED);
+        if (!ward || !ward.being(BOX))
             return null;
         return ward;
     };
-    const hasDevice = () => o.harbor.wards.get(DOCK)?.being(CONSOLE) !== undefined;
+    const hasDevice = () => o.harbor.wards.get(BOX_SEED)?.being(BOX) !== undefined;
     // The device shown by itself: the last entry of the switcher, and the
     // whole screen of a device that has joined no world. A fresh install has
     // no world's page to carry her forms, and a first screen that says only
@@ -249,7 +249,7 @@ export async function app(o) {
         if (had)
             return { ward, rel: had };
         const rel = await fresh(ward);
-        const inv = await ward.ask('invite', { being: CONSOLE, id: rel.key });
+        const inv = await ward.ask('invite', { being: BOX, id: rel.key });
         if (!inv || typeof inv !== 'object')
             throw new Error('this device is already held under that name');
         const took = (await ward.ask('knock', { being: rel.key, id: USER, invitation: inv }));
@@ -362,7 +362,7 @@ export async function app(o) {
         // was there a moment ago. A page paints once, so asking once more here
         // is the difference between a device with its faculties on screen and a
         // device that looks empty until the person navigates away and back.
-        await settled();
+        await settled(o.harbor);
         const now = await rel.avatar.tools();
         if ('asks' in now)
             got = now;
@@ -464,10 +464,8 @@ export async function app(o) {
     // the shell asks and does not read the answer, since the news is already
     // on the page where the push landed.
     const shown = async (line) => {
-        const dock = o.harbor.wards.get(DOCK);
-        if (!dock)
-            return;
-        await dock.ask('ask', { being: NOTIFICATIONS, method: 'notify', args: line }).catch(() => { });
+        await (await lent(o.harbor, NOTIFICATIONS))?.notify(line).catch(() => { });
+        await o.harbor.wards.get(BOX_SEED)?.save();
     };
     // The device ward before anything is dialed: a harbor announces the wards
     // it hosts when it opens a socket, and a ward made after that is a pk the

package/dist/human/door.d.ts

@@ -15,5 +15,4 @@ export type Landed = {
     at?: string;
     ok: boolean;
 };
-export declare function landedTree(l: Landed): Node;
 export declare function landed(l: Landed): string;

package/dist/human/door.js

@@ -68,7 +68,7 @@ export const ours = {
     ...nobody,
     link: (href, text) => `<a class="link" href="${escape(href)}">${escape(text)}</a>`,
 };
-export function landedTree(l) {
+function landedTree(l) {
     const of = [
         { kind: 'image', src: MARK, alt: '' },
         { kind: 'text', text: l.ok ? 'That is done' : 'That did not finish', role: 'title' },

package/dist/human/html.js

@@ -397,7 +397,7 @@ export function page(m) {
                     const a = inGroup.find((x) => x.name === prefix + name);
                     return a ? one(kept, prefix)(a) : '';
                 },
-                answer: (name, as) => (inGroup.some((x) => x.name === prefix + name) ? answer(prefix + name, as) : ''),
+                answer: (name, shown) => (inGroup.some((x) => x.name === prefix + name) ? answer(prefix + name, shown) : ''),
                 link: linkedBy(kept), // a carried standing vouches by her own look and never her carrier's
                 standing: () => '',
                 standings: () => '',

package/dist/human/move.js

@@ -10,7 +10,7 @@ const KEY = 'courier';
 async function courier(harbor) {
     const ward = harbor.wards.get(COURIER) ?? (await harbor.create(COURIER, 'me'));
     if (!ward.being(KEY)) {
-        const out = (await ward.ask('boot', { key: KEY, class: 'Courier' }));
+        const out = (await ward.ask('boot', { key: KEY, class: 'beings/Courier' }));
         if (out.error)
             throw new Error(`no courier on this device: ${out.error}`);
     }