@nervur-org/dock 0.5.0 → 0.6.0

package/harbor/edge/edge.ts

@@ -30,16 +30,15 @@
 // those pages are painted with. It also holds what this terrain lends, since
 // a worker stands a box ward like every other terrain: the box's state has
 // one home everywhere, and what differs is which faculties that ward lends.
-import type { BeingClass } from 'nervur';
+import type { Stance } from 'nervur';
 import { isSilence } from 'nervur';
-import { User, Desk, Avatar, Clock } from '../../beings/index.ts';
+import { BEINGS } from '../../beings/index.ts';
 import { setup } from '../../beings/setup.ts';
 import { Harbor, Socket as Held } from 'nervur/harbor';
 import { quoRoute } from '../quo.ts';
 import { webRoute, type Folder } from '../../human/web.ts';
-import { DOCK, TIMER, Console, facultyOf, settled, stand } from '../../dock/index.ts';
 import { Alarm, alarmsIn } from './alarm.ts';
-import { Grants, GRANTS } from '../../dock/grants.ts';
+import { BOX_SEED, GRANTS, Grants, Http, TIMER, WIRE, harborageOver, keyed, lent, settled, standHarbor, type Harborage, type Tree } from '../../box/index.ts';
 import { find, letIn } from '../../beings/join.ts';
 import { apiRoute } from '../../api/route.ts';
 import { mcpRoute, type Routes } from '../../mcp/route.ts';
@@ -47,14 +46,10 @@ import { McpHttp } from '../../mcp/http.ts';
 import { Exchange } from '../../mcp/allow.ts';
 import type { Invitation } from 'nervur';
 import { DurableStorage, danceInStorage, folderInStorage, settingsInStorage, wearInStorage } from './storage.ts';
-import { LENT, type Deployed, type Given, type Settings, type SettingsStore } from './given.ts';
+import { type Deployed, type Given, type Settings, type SettingsStore } from './given.ts';
 import { sealKey } from '../seal.ts';
-import type { State, Env, Storage } from './platform.d.ts';
+import type { State, Env } from './platform.d.ts';
 
-// 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: Record<string, BeingClass> = { User, Desk, Avatar, Clock };
 const json = (status: number, v: unknown, headers: Record<string, string> = {}) => new Response(JSON.stringify(v), { status, headers: { 'content-type': 'application/json', ...headers } });
 
 export class EdgeHarbor extends Harbor {
@@ -69,9 +64,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.
   readonly dance: ReturnType<typeof danceInStorage>;
-  // The object's storage, unprefixed and unsealed: the alarm is the object's
-  // own and is no row.
-  readonly #storage: Storage;
   #booted: Promise<void> | undefined;
   // 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.
@@ -84,19 +76,33 @@ export class EdgeHarbor extends Harbor {
   static async open(state: State, env: Env, deployed: Deployed = {}): Promise<EdgeHarbor> {
     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: Stance, box?: Harborage) {
+        super(stance, box, alarms);
+      }
+    }
+    harbor.faculties = { box: { Grants, Http }, harbor: { edge: { Alarm: ObjectAlarm } } };
     return harbor;
   }
 
   constructor(store: DurableStorage, root: string | undefined, deployed: 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.
@@ -112,11 +118,14 @@ export class EdgeHarbor extends Harbor {
     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: Record<string, string> | undefined;
+  // 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: Tree | undefined;
+  // 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.
+  readonly 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
@@ -131,20 +140,13 @@ export class EdgeHarbor extends Harbor {
   // keeps, then the beings who took what the box lends: a box is up when
   // they have landed.
   override async boot(): Promise<void> {
-    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<Grants>(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<Alarm>(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
@@ -156,7 +158,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(): Promise<void> {
-    const timer = facultyOf<Alarm>(this, TIMER);
+    const timer = await lent<Alarm>(this, TIMER);
     if (!timer) return;
     try {
       await timer.rang();
@@ -169,8 +171,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(): Grants | undefined {
-    return facultyOf<Grants>(this, GRANTS);
+  grants(): Promise<Grants | undefined> {
+    return lent<Grants>(this, GRANTS);
   }
 
   // The web side, built per request because its whole configuration is rows
@@ -211,7 +213,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(): string {
-    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] : '';
   }
 
@@ -231,17 +233,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: Request, path: string, base: string): Promise<Response> {
-    const grants = this.grants;
+  async api(request: Request, path: string): Promise<Response> {
+    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' });
   }
 
@@ -252,9 +253,9 @@ 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: Request, path: string, base: string): Promise<Response> {
-    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 () => {
+    const endpoint =(this.#mcp ??= new McpHttp(this.#resolve, async () => {
       for (const h of this.wards.values()) await h.save();
     }));
     endpoint.gone = (identity, ward) => grants.revoke(identity, ward); // removal at the ward ends the grant at the box
@@ -266,7 +267,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: Request, path: string, base: string): Promise<Response> {
-    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);
     return (await route.wellKnown(request, path.slice('/.well-known'.length))) ?? json(404, { error: 'no such route' });
@@ -275,7 +276,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: string): Promise<Exchange | undefined> {
-    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);
     return new Exchange({ oauth: route.oauth, worlds: this.#worlds, join: this.#join });
@@ -293,7 +294,7 @@ export class EdgeHarbor extends Harbor {
   async fetch(request: Request, path: string, base: string): Promise<Response> {
     await this.ready();
     const out = await this.#route(request, path, base);
-    await facultyOf<Alarm>(this, TIMER)?.setting;
+    await (await lent<Alarm>(this, TIMER))?.setting;
     return out;
   }
 
@@ -301,7 +302,7 @@ export class EdgeHarbor extends Harbor {
     if (path === '/health') return json(200, this.health(), { 'access-control-allow-origin': '*' });
     if (path === '/root') return this.rootAsk(request);
     if (path === '/web' || path.startsWith('/web/')) return this.web(request, path, base);
-    if (path === '/api' || path.startsWith('/api/')) return this.api(request, path, base);
+    if (path === '/api' || path.startsWith('/api/')) return this.api(request, path);
     if (path === '/mcp' || path.startsWith('/mcp/')) return this.mcp(request, path, base);
     if (path.startsWith('/.well-known/')) return this.wellKnown(request, path, base);
     // The sealed bytes are the same route the daemon mounts; the upgrade is
@@ -310,7 +311,12 @@ export class EdgeHarbor extends Harbor {
       if ((path === '/quo' || path === '/quo/') && request.headers.get('upgrade')?.toLowerCase() === 'websocket') 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<Http>(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() {
@@ -356,7 +362,7 @@ export class EdgeHarbor extends Harbor {
   async rootAsk(request: Request): Promise<Response> {
     const bearer = request.headers.get('authorization')?.replace(/^Bearer\s+/i, '') ?? '';
     if (request.method !== 'POST' || !this.root || bearer.length !== this.root.length || !same(bearer, this.root)) return json(401, { error: 'the root holds the secret' });
-    let body: { init?: { ward?: unknown; user?: unknown }; settings?: Partial<Settings>; wear?: Record<string, unknown>; ward?: unknown; method?: unknown; args?: unknown } = {};
+    let body: { init?: { ward?: unknown; user?: unknown; class?: unknown }; settings?: Partial<Settings>; wear?: Record<string, unknown>; ward?: unknown; method?: unknown; args?: unknown } = {};
     try {
       body = (await request.json()) as typeof body;
     } catch {
@@ -368,7 +374,7 @@ export class EdgeHarbor extends Harbor {
         const user = typeof body.init.user === 'string' ? body.init.user : 'me';
         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/harbor/edge/exercise.ts

@@ -189,14 +189,14 @@ export async function exercise(request: Request, base: string, path: string, sta
   // 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') as unknown as Printer;

package/harbor/edge/given.ts

@@ -2,7 +2,7 @@
 // What a side mounted at the edge is given. `Given` is the one shape: the
 // code a page runs, the design a world wears, the public origins, the apps
 // table and the bell key. On the daemon the same list is what `cli/daemon.ts`
-// reads off a disk and out of `routes.json`; here it has two provenances,
+// reads off a disk and out of the Dock's cells; here it has two provenances,
 // and the split is what the value is, not an accident of this file.
 //
 // `Deployed` is the half the deploy carries: the tab's bundle, the service
@@ -18,39 +18,9 @@
 // rows beside it, one per file, reached through `Folder` like every other
 // terrain's.
 import type { BeingClass } from 'nervur';
-import { GRANTS } from '../../dock/grants.ts';
-import { TIMER } from '../../dock/index.ts';
 import type { Apps, Folder } from '../../human/web.ts';
 import type { Routes } from '../../mcp/route.ts';
 
-// 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: Record<string, string> = { [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
@@ -74,7 +44,7 @@ export type Code = { tab: string; worker: string };
 // the worker's own origin, no apps, no doorbell.
 export type Settings = {
   // the public faces of the four routes, as the proxy serves them, the same
-  // shape `routes.json` holds on a disk
+  // shape the Dock's routes cell holds on a disk
   routes?: Routes;
   // the apps this world's links open, or none
   apps?: Apps | null;
@@ -97,7 +67,7 @@ export type SettingsStore = {
 // platform is, and never a deploy.
 export type Deployed = {
   code?: Code;
-  // being classes beyond the built-ins, this deployment's own
+  // this deployment's own classes, held under `classes/` beside the dock's `beings/`
   classes?: Record<string, BeingClass>;
 };
 

package/harbor/edge/storage.ts

@@ -39,8 +39,8 @@ export function settingsInStorage(storage: Rows, prefix = ''): SettingsStore {
 // 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: Rows, prefix = ''): Folder {
   const design = (file: string) => `${prefix}${DESIGN_ROW}${file}`;

package/harbor/http.ts

@@ -100,7 +100,9 @@ export async function listenHttp(harbor: DiskHarbor, host: string, port: number,
           { 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) return out;
@@ -167,14 +169,14 @@ function asRequest(req: import('node:http').IncomingMessage, url: URL): Request
     method,
     headers,
     ...(bodied ? { body: Readable.toWeb(req) as ReadableStream<Uint8Array>, duplex: 'half' } : {}),
-  } as RequestInit);
+  });
 }
 
 // And the one translation out.
 async function writeResponse(out: Response, res: import('node:http').ServerResponse): Promise<void> {
   const headers: Record<string, string | string[]> = {};
   out.headers.forEach((v, k) => {
-    headers[k] = k === 'set-cookie' ? [...(Array.isArray(headers[k]) ? (headers[k] as string[]) : []), v] : v;
+    headers[k] = k === 'set-cookie' ? [...(Array.isArray(headers[k]) ? (headers[k]) : []), v] : v;
   });
   res.writeHead(out.status, headers);
   if (!out.body) return void res.end();

package/harbor/sealed.ts

@@ -146,38 +146,3 @@ export class Sealed implements Store {
     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(): { files: Files; secrets: Secrets; disk: Map<string, string> } {
-  const disk = new Map<string, string>();
-  const dirs = new Set<string>();
-  const vault = new Map<string, string>();
-  const under = (dir: string) => [...disk.keys()].filter((k) => k.startsWith(`${dir}/`));
-  const files: 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: 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/harbor/tauri.ts

@@ -11,7 +11,7 @@
 // ships no daemon. It has no ear, since no store rings a desk; a desk is
 // reached while the app is open and drains what it missed when it opens.
 import type { BeingClass, JsonObject } from 'nervur';
-import { NOTIFICATIONS, Notifications } from '../dock/index.ts';
+import { Notifications } from '../box/index.ts';
 import { BrowserHarbor } from './browser.ts';
 import { Sealed, type Files, type Secrets } from './sealed.ts';
 
@@ -24,6 +24,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 override stands(): boolean {
+    return true;
+  }
   override async notify(args: JsonObject): Promise<JsonObject> {
     const title = typeof args.title === 'string' ? args.title : '';
     const body = typeof args.body === 'string' ? args.body : '';
@@ -32,13 +37,6 @@ export class DeskNotifications extends Notifications {
   }
 }
 
-// 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: Record<string, string> = { [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.
@@ -72,8 +70,13 @@ export async function deskHarbor(core: Core, name = 'nervur', classes: Record<st
     }
   }
   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/human/app.ts

@@ -19,12 +19,12 @@ import { domSurface } from './dom.ts';
 import { guest } from './guest.ts';
 import { door, held as heldPage } from './door.ts';
 import { USER } from '../beings/avatar.ts';
-import { DOCK, CONSOLE, NOTIFICATIONS, settled } from '../dock/index.ts';
+import { BOX, BOX_SEED, NOTIFICATIONS, Notifications, lent, settled } from '../box/index.ts';
 import { fresh, joined, localName, ordered, relations, world, type Joined, type Relation, type World } from './worlds.ts';
 import { giveWorld, takeWorld, type Giving } from './move.ts';
 import { invitationOf, reachOf } from '../beings/link.ts';
 import { doorbell, drained, told, notice as noticeOf, type Bell, type Held } from './wake.ts';
-import type { Token } from '../dock/index.ts';
+import type { Token } from '../box/index.ts';
 import type { Config } from './tab.ts';
 
 // What one world's address answers when an app asks it for JSON, and the
@@ -58,7 +58,7 @@ export type Dialing = Harbor & { dial(url: string): unknown };
 //
 // What the human reads when the device was woken while nobody was looking
 // is composed here from objects that crossed sealed, never from the ring,
-// and shown by asking the dock ward's notifications being through the
+// and shown by asking the box ward's notifications being through the
 // harbor's own pointer: the same act on every terrain, and no second body.
 export type Ear = () => Promise<Token | null>;
 
@@ -161,7 +161,7 @@ export async function app(o: AppOptions): Promise<Running> {
   // 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();
@@ -289,15 +289,15 @@ export async function app(o: AppOptions): Promise<Running> {
     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 (): Promise<Hosted | null> => {
-    const ward = o.harbor.wards.get(DOCK);
-    if (!ward || !ward.being(CONSOLE)) return null;
+    const ward = o.harbor.wards.get(BOX_SEED);
+    if (!ward || !ward.being(BOX)) return null;
     return ward;
   };
-  const hasDevice = (): boolean => o.harbor.wards.get(DOCK)?.being(CONSOLE) !== undefined;
+  const hasDevice = (): boolean => 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
@@ -316,7 +316,7 @@ export async function app(o: AppOptions): Promise<Running> {
     const had = relations(ward)[0];
     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 as unknown as JsonObject })) as { taken?: string; error?: string };
     if (took.taken !== USER) throw new Error(took.error ?? 'the shell could not take this device');
@@ -424,7 +424,7 @@ export async function app(o: AppOptions): Promise<Running> {
     // 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;
     await inside(ward, rel, notice, got);
@@ -518,9 +518,8 @@ export async function app(o: AppOptions): Promise<Running> {
   // 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: { title: string; body: string }) => {
-    const dock = o.harbor.wards.get(DOCK);
-    if (!dock) return;
-    await dock.ask('ask', { being: NOTIFICATIONS, method: 'notify', args: line }).catch(() => {});
+    await (await lent<Notifications>(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

package/human/door.ts

@@ -90,7 +90,7 @@ export const ours: Painter = {
 // an error object to a machine, and neither is a sentence.
 export type Landed = { world?: string; host: string; at?: string; ok: boolean };
 
-export function landedTree(l: Landed): Node {
+function landedTree(l: Landed): Node {
   const of: Node[] = [
     { kind: 'image', src: MARK, alt: '' },
     { kind: 'text', text: l.ok ? 'That is done' : 'That did not finish', role: 'title' },

package/human/html.ts

@@ -436,7 +436,7 @@ export function page(m: Model): string {
           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/human/local.ts

@@ -11,7 +11,7 @@
 // the subject is the owner's `ask` and nothing else: no standing and no
 // relation, since the local ward is the human's and she is on it. The ward
 // names the asker, bounds the wait, judges her answer and saves before the
-// pointer returns, so this file holds an id nobody minted no longer.
+// pointer returns, so this file holds no id of its own.
 import type { Answer, Blueprint, JsonObject } from 'nervur';
 import type { Subject } from '../beings/side.ts';
 

package/human/move.ts

@@ -35,7 +35,7 @@ const KEY = 'courier';
 async function courier(harbor: Harbor): Promise<Courier> {
   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' })) as { error?: string };
+    const out = (await ward.ask('boot', { key: KEY, class: 'beings/Courier' })) as { error?: string };
     if (out.error) throw new Error(`no courier on this device: ${out.error}`);
   }
   return ward.being(KEY) as Courier;