@nervur-org/dock 0.4.1 → 0.6.0

package/dist/human/worlds.js

@@ -1,5 +1,5 @@
 import { Avatar, USER } from '../beings/avatar.js';
-import { settled } from '../dock/faculty.js';
+import { settled } from '../box/join.js';
 // The list as a browser keeps it, the tab's and the app's alike: one item
 // under one key. A device with no storage still works and forgets, which is
 // why every read has a floor.
@@ -84,7 +84,7 @@ export async function fresh(ward) {
     // is a tab that hangs.
     for (let n = 1; n <= 64; n++) {
         const key = `r${n}`;
-        const out = (await ward.ask('boot', { key, class: 'Presence' }));
+        const out = (await ward.ask('boot', { key, class: 'beings/Presence' }));
         if (out.error)
             continue;
         // She takes what the box lends at her birth, and birth is synchronous
@@ -92,7 +92,7 @@ export async function fresh(ward) {
         // landed, not before: a screen painted from her describe a moment early
         // is a page missing every faculty of the box, and nothing paints it
         // again until the person navigates.
-        await settled();
+        await settled(ward);
         return { key, avatar: ward.being(key) };
     }
     throw new Error('the tab could not boot an avatar: every key it tries is taken');

package/dist/mcp/agent.d.ts

@@ -2,7 +2,6 @@ import type { Json, JsonObject } from 'nervur';
 import type { Avatar } from '../beings/avatar.ts';
 import { type Serving } from '../beings/side.ts';
 export type Run = (event: JsonObject) => Promise<Json>;
-export declare const REPORT = "report";
 export declare function processRun(command: string, args: string[], dir: string): Run;
 export type Agent = Serving & {
     idle(): Promise<void>;

package/dist/mcp/agent.js

@@ -13,7 +13,7 @@ import { spawn } from 'node:child_process';
 import { word, wordText, SILENCE_TEXT, UNREACHED_TEXT } from '../beings/side.js';
 // The ask on the user being that takes the result. Gated to devices; the
 // agent's client identity is what the gate reads.
-export const REPORT = 'report';
+const REPORT = 'report';
 // `claude -p` or any CLI agent: the command runs in the agent's folder with
 // the event, as JSON, as its last argument. The result is what it printed.
 // A non-zero exit is an error object with what it said on stderr.

package/dist/mcp/allow.js

@@ -49,8 +49,9 @@ export class Exchange {
             if (!world)
                 return again('That invitation is for a world that does not live here.');
             const identity = word(f.get('identity'));
-            if (identity === null || identity === world.user || identity === 'desk')
-                return again('An identity is one word, and not the user or the desk.');
+            // the ward judges the rest: an identity that is one of its beings is refused at the join
+            if (identity === null)
+                return again('An identity is one word.');
             const joined = await this.o.join(identity, inv, world.ward);
             if (joined.error)
                 return again(`Not in: ${joined.error}.`);

package/dist/mcp/http.d.ts

@@ -8,7 +8,6 @@ export type Session = {
     serving: Serving;
     touched: number;
 };
-export declare const SESSION_IDLE: number;
 export type Resolve = (identity: string, ward: string) => Promise<{
     avatar?: Avatar;
     error?: string;

package/dist/mcp/http.js

@@ -10,7 +10,7 @@
 // for an hour is dropped, since HTTP tells the server nothing else.
 import { WebStandardStreamableHTTPServerTransport as StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js';
 import { mcpSide } from './server.js';
-export const SESSION_IDLE = 60 * 60 * 1000;
+const SESSION_IDLE = 60 * 60 * 1000;
 export class McpHttp {
     sessions = new Map();
     resolve;

package/dist/mcp/oauth.d.ts

@@ -1,5 +1,5 @@
-import { type Grants } from '../dock/grants.ts';
-export { ACCESS_TTL, REFRESH_TTL } from '../dock/grants.ts';
+import { type Bearers as Grants } from '../box/grants.ts';
+export { ACCESS_TTL, REFRESH_TTL } from '../box/grants.ts';
 export declare const CODE_TTL: number;
 export type Client = {
     client_id: string;
@@ -82,10 +82,9 @@ export declare class OAuth {
         error: string;
     }>;
     token(body: URLSearchParams): Promise<Record<string, unknown>>;
-    issue(identity: string, ward: string, client_id: string): Promise<import("../dock/grants.ts").Tokens>;
+    issue(identity: string, ward: string, client_id: string): Promise<import("../box/grants.ts").Tokens>;
     sweep(): void;
     handle(req: Request, rest: string): Promise<Response | undefined>;
     challenge(): Response;
 }
-export declare function readBody(req: Request, limit?: number): Promise<string>;
 export declare function readForm(req: Request): Promise<URLSearchParams>;

package/dist/mcp/oauth.js

@@ -5,7 +5,7 @@
 // S256, the code grant, refresh, opaque tokens. It is a route, not Quo. Its
 // one job is to end with a client identity, which the front desk trades for
 // an invitation and the avatar knocks with; the grant it issues is the
-// box's, `dock/grants.ts`, honoured on every route, and what this file
+// box's, `box/grants.ts`, honoured on every route, and what this file
 // keeps for itself is only the dance: clients, pending requests and codes.
 // No secret of Quo's is ever here.
 //
@@ -18,8 +18,8 @@
 // The web route finishes a request by calling `complete(request, identity)`
 // after its allow page, where the human hands the invitation the root minted;
 // that returns the redirect that carries the code back to the client.
-import { REFRESH_TTL } from '../dock/grants.js';
-export { ACCESS_TTL, REFRESH_TTL } from '../dock/grants.js';
+import { REFRESH_TTL } from '../box/grants.js';
+export { ACCESS_TTL, REFRESH_TTL } from '../box/grants.js';
 // A code, a client id: every key here is a string the far side chose, and a
 // bare lookup would find `__proto__` and hand back an object with no
 // identity. Own keys only.
@@ -212,7 +212,7 @@ function withQuery(base, params) {
             u.searchParams.set(k, v);
     return u.toString();
 }
-export async function readBody(req, limit = 64 * 1024) {
+async function readBody(req, limit = 64 * 1024) {
     const s = await req.text();
     if (s.length > limit)
         throw new Error('too large');

package/dist/mcp/route.d.ts

@@ -1,7 +1,7 @@
 import { OAuth, type Store } from './oauth.ts';
 import type { McpHttp } from './http.ts';
 import type { Handler } from '../harbor/http.ts';
-import type { Grants } from '../dock/grants.ts';
+import type { Bearers as Grants } from '../box/grants.ts';
 export type Routes = {
     mcp: string;
     web: string;

package/dist/mcp/runner.d.ts

@@ -7,7 +7,6 @@ export type Model = {
     key?: string;
     turns?: number;
 };
-export declare const TURNS = 10;
 export type Tool = {
     type: 'function';
     function: {

package/dist/mcp/runner.js

@@ -1,6 +1,6 @@
 import { word, wordText, SILENCE_TEXT, UNREACHED_TEXT } from '../beings/side.js';
 import { presentation } from '../beings/look.js';
-export const TURNS = 10;
+const TURNS = 10;
 // Her describe, spoken as a tools array. Name, description and input are
 // verbatim, with the one narrowing an endpoint has asked for: an ask that
 // declares no properties is sent with an empty `properties`, because

package/dist/mcp/server.d.ts

@@ -6,6 +6,5 @@ import { type Look } from '../beings/look.ts';
 export declare const NAME = "nervur";
 export declare const VERSION = "0.0.0";
 export type { Subject } from '../beings/side.ts';
-export declare const DESCRIBE: Tool;
 export declare function tools(bp: Blueprint, look?: Look): Tool[];
 export declare function mcpSide(avatar: Subject, transport: Transport, after?: () => Promise<void>): Promise<Serving>;

package/dist/mcp/server.js

@@ -16,7 +16,7 @@ import { isSilence, isWord, digest } from 'nervur';
 export const NAME = 'nervur';
 export const VERSION = '0.0.0';
 // The empty ask as a tool: her describe whole, asks and notes.
-export const DESCRIBE = { name: 'describe', description: 'the empty ask: her describe, the asks and the notes', inputSchema: { type: 'object' } };
+const DESCRIBE = { name: 'describe', description: 'the empty ask: her describe, the asks and the notes', inputSchema: { type: 'object' } };
 // Her describe, spoken as tools, the empty ask first. Name, description and
 // input are verbatim; an output schema crosses when she declared one. Her
 // look, when she has one, is the hints: a title, and the annotations a host

package/harbor/browser.ts

@@ -7,56 +7,54 @@
 // a second tab on one origin meets the lock and is a screen, not a harbor.
 // In an app the store is handed in, and the process that holds it is the
 // lease: an app has one harbor and nothing else can open its files. The
-// classes are the estate's beings, handed in with the bundle, plus whatever
-// a page hands in beside them.
+// classes are the dock's beings under `beings/`, plus whatever a page hands
+// in beside them under `classes/`.
 import type { BeingClass } from 'nervur';
-import { User, Desk, Avatar, Presence, Courier } from '../beings/index.ts';
-import { Harbor, dial, type Dialer, type Lend, type Store } from 'nervur/harbor';
-import { FACULTY_CLASSES, settled, stand } from '../dock/index.ts';
+import { BEINGS } from '../beings/index.ts';
+import { Harbor, dial, type Dialer, type Store } from 'nervur/harbor';
+import { BOX_SEED, harborageOver, keyed, settled, standHarbor, type Tree } from '../box/index.ts';
 import { Idb } from './idb.ts';
 
-export const BUILT_IN: Record<string, BeingClass> = { User, Desk, Avatar, Presence, Courier, ...FACULTY_CLASSES };
-
 export class BrowserHarbor extends Harbor {
   readonly name: string;
   readonly dialers: Dialer[] = [];
   readonly #locked: boolean;
   #release: (() => void) | undefined;
 
-  // `lend` is what this box lends the beings of the wards it hosts: a name
-  // to an invitation on a being of its own ward. `stand` builds one; a bare
-  // tab hands none and every name answers null.
-  constructor(store: string | Store = 'nervur', classes: Record<string, BeingClass> = {}, lend?: Lend) {
+  constructor(store: string | Store = 'nervur', classes: Record<string, BeingClass> = {}) {
     const s = typeof store === 'string' ? new Idb(store) : store;
-    super(s, async () => ({ ...BUILT_IN, ...classes }), lend);
+    super(s, async () => keyed({ ...BEINGS, classes }));
     this.name = typeof store === 'string' ? store : 'nervur';
     this.#locked = typeof store === 'string';
   }
 
-  // What this box lends, by name. A bare tab says nothing, stands no ward of
-  // its own and lends nothing.
-  lent: Record<string, string> | undefined;
+  // The classes this terrain brings to its own ward, as a tree. A bare tab
+  // brings none, stands no ward of its own and lends nothing.
+  faculties: Tree | undefined;
+  // What this harbor is to its faculties, up once it has booted.
+  readonly box = harborageOver(() => this.wards.get(BOX_SEED)?.save() ?? Promise.resolve());
 
-  // What this box lends is said before it boots, and standing the ward is
-  // part of booting: a being born in any other ward lends from her first
-  // line, and a ground that could not reach it yet would leave her holding
-  // nothing until her next birth.
-  async stand(lent: Record<string, string>): Promise<void> {
-    this.lent = lent;
-    if (this.wards.size > 0) this.lend = await stand(this, lent);
+  // What this box brings is said before it boots, and standing its own ward
+  // is act one of booting: a being born in any other ward takes the box at
+  // her ward's birth, and a box that was not standing yet would leave that
+  // ward holding nothing until its next boot.
+  async stand(faculties: Tree): Promise<void> {
+    this.faculties = faculties;
+    if (this.wards.size > 0) await standHarbor(this, faculties, this.box);
   }
 
   // Take the lock and boot every ward kept here. A lock already held is
   // another tab's harbor over this seed, and this one refuses to boot.
   override async boot(): Promise<void> {
     if (this.#locked) await this.#lease();
-    if (this.lent) this.lend = await stand(this, this.lent);
+    if (this.faculties) await standHarbor(this, this.faculties, this.box);
     await super.boot();
     // Every being who takes what this box lends does it at her birth, and
     // birth is synchronous while taking a standing is not. A box is up when
     // they have landed, not before, here as on a daemon: a page painted
     // ahead of them shows a device that can do nothing.
-    await settled();
+    await settled(this);
+    await this.box.raise();
   }
 
   // Hold one socket to a world's quo. route.

package/harbor/capacitor.ts

@@ -17,7 +17,7 @@ import { Geolocation } from '@capacitor/geolocation';
 import { LocalNotifications } from '@capacitor/local-notifications';
 import { PushNotifications } from '@capacitor/push-notifications';
 import type { BeingClass, JsonObject } from 'nervur';
-import { LOCATION, NOTIFICATIONS, Location, Notifications, type Token, type Where } from '../dock/index.ts';
+import { Location, Notifications, type Token, type Where } from '../box/index.ts';
 import { BrowserHarbor } from './browser.ts';
 import { Sealed, type Files, type Secrets } from './sealed.ts';
 
@@ -34,6 +34,9 @@ const asked = (what: string) => new Error(`the human is being asked to allow ${w
 const refused = (what: string) => new Error(`${what} is not allowed on this device`);
 
 export class PhoneLocation extends Location {
+  static override stands(): boolean {
+    return Capacitor.isPluginAvailable('Geolocation');
+  }
   override async where(): Promise<Where | JsonObject> {
     const { location } = await Geolocation.checkPermissions();
     if (location === 'prompt' || location === 'prompt-with-rationale') {
@@ -47,6 +50,9 @@ export class PhoneLocation extends Location {
 }
 
 export class PhoneNotifications extends Notifications {
+  static override stands(): boolean {
+    return Capacitor.isPluginAvailable('LocalNotifications');
+  }
   override async notify(args: JsonObject): Promise<JsonObject> {
     const title = typeof args.title === 'string' ? args.title : '';
     const body = typeof args.body === 'string' ? args.body : '';
@@ -101,11 +107,6 @@ export class PhoneNotifications extends Notifications {
   }
 }
 
-// What a phone lends: the two faculties above under the names every box
-// lends them under, and nothing a phone has not. The harbor holds these
-// class bodies for its own ward, and boots one being of each in it.
-export const PHONE_FACULTIES: Record<string, BeingClass> = { Location: PhoneLocation, Notifications: PhoneNotifications };
-export const phoneLent: Record<string, string> = { [LOCATION]: 'Location', [NOTIFICATIONS]: 'Notifications' };
 
 // The phone's ear, as `human/app.ts` asks for one: the token this device is
 // reachable at while it sleeps, or null.
@@ -163,8 +164,8 @@ export function phoneEar(sandbox = false, within = 10_000, named: { bell?: strin
 // told `wake` every time the app comes to the foreground, since a phone
 // asleep loses its sockets silently.
 export async function nativeHarbor(name = 'nervur', classes: Record<string, BeingClass> = {}): Promise<BrowserHarbor> {
-  const h = new BrowserHarbor(await Native.open(name), { ...PHONE_FACULTIES, ...classes });
-  await h.stand(phoneLent);
+  const h = new BrowserHarbor(await Native.open(name), classes);
+  await h.stand({ harbor: { PhoneLocation, PhoneNotifications } });
   await h.boot();
   await App.addListener('appStateChange', ({ isActive }) => {
     if (isActive) h.wake();

package/harbor/disk.ts

@@ -2,9 +2,8 @@
 // The node daemon's harbor: the core over a folder on disk. The store is
 // `files.ts`, one folder per ward; the class bodies come from a module the
 // ward record names, loaded from the folder; the lease is a pid file. The
-// estate's own beings, the user being, the front desk and the avatar, are
-// held by every harbor here: they are what every side needs, and a folder's
-// class source adds to them.
+// dock's beings are held by every harbor here under `beings/`, and a
+// folder's class source adds to them under the folder it sits in.
 //
 //   <dir>/
 //     lease                 pid of the one process that holds this harbor
@@ -16,26 +15,25 @@
 //     reach.json            the directory's hints
 import { mkdir, readFile, writeFile, unlink, stat } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
-import { join, resolve, isAbsolute } from 'node:path';
+import { dirname, join, resolve, isAbsolute, relative } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { register } from 'node:module';
 import process from 'node:process';
 import type { BeingClass } from 'nervur';
-import { User, Desk, Avatar, Presence, Clock, Courier } from '../beings/index.ts';
+import { BEINGS } from '../beings/index.ts';
 import { setup } from '../beings/setup.ts';
-import { Harbor, DEFAULT_CODE, type Hosted, type Lend } from 'nervur/harbor';
-import { FACULTY_CLASSES, settled, stand } from '../dock/index.ts';
+import { Harbor, DEFAULT_CODE, BOX_SEED, type Hosted } from 'nervur/harbor';
+import { BOX, harborageOver, keyed, settled, standHarbor, type Tree } from '../box/index.ts';
 import { Files } from './files.ts';
 
 export type { Hosted, Bound } from 'nervur/harbor';
 export type { WardRecord } from 'nervur/harbor';
-export const BUILT_IN: Record<string, BeingClass> = { User, Desk, Avatar, Presence, Clock, Courier, ...FACULTY_CLASSES };
 
 // The default ward, the one a caller means when naming none: the one marked,
 // or the one ward hosted when there is exactly one, which is every harbor an
 // adopter stands with one `nervur init`. Several wards and none marked is
 // refused by name, since agents and a door would otherwise hang off a
-// guess. The dock ward is furniture, never a candidate.
+// guess. The box ward is furniture, never a candidate.
 export function defaultWard(marked: string[], hosted: string[]): string {
   if (marked.length > 1) throw new Error(`this device marks ${marked.join(', ')} as default, and one at most may be`);
   const one = marked[0];
@@ -43,7 +41,7 @@ export function defaultWard(marked: string[], hosted: string[]): string {
     if (!hosted.includes(one)) throw new Error(`this device says its default ward is ${one}, and hosts no such ward`);
     return one;
   }
-  const [first, ...more] = hosted.filter((n) => n !== 'dock');
+  const [first, ...more] = hosted.filter((n) => n !== BOX_SEED);
   if (first !== undefined && more.length === 0) return first;
   const names = first === undefined ? [] : [first, ...more];
   throw new Error(names.length === 0 ? 'this device hosts no ward: run `nervur init`' : `this device hosts ${names.join(', ')} and says which is the default: nervur default <name>`);
@@ -89,19 +87,30 @@ export class DiskHarbor extends Harbor {
   // ward and nothing in Quo knows of it: a harbor is not a being and has no
   // self to be, so it can only point at one of its wards. Its agents boot
   // there, and its door answers for it when a caller names no ward. The one
-  // ward it hosts when there is one, the one marked otherwise, resolved by
-  // the daemon at boot; empty until then.
+  // ward it hosts when there is one, the one the Dock's cells say otherwise,
+  // placed by the root's `default` ask and resolved by the daemon at boot;
+  // empty until then.
   defaultWard = '';
 
-  // The mark is a file in the ward's own folder, `wards/<name>/default`, so
-  // it moves with the ward and nothing beside the wards says it. One at most:
-  // marking one takes the mark off every other.
-  static async setDefault(dir: string, name: string): Promise<void> {
+  // The root saying what the box is, with no daemon over the folder: the
+  // Dock's own asks, `domain`, `apps` and `default`, on the box ward stood
+  // alone, which the lease refuses while a daemon serves. The daemon reads
+  // what she keeps at its next boot, so a domain said is stop, say, start,
+  // like an init.
+  static async say(dir: string, method: 'domain' | 'apps' | 'default', args: Record<string, unknown>): Promise<Record<string, unknown>> {
     const h = new DiskHarbor(dir);
-    const names = await h.store.list();
-    if (!names.includes(name)) throw new Error(`no ward ${name} in ${h.dir}`);
-    for (const n of names) await unlink(join(h.dir, 'wards', n, 'default')).catch(() => {});
-    await writeFile(join(h.dir, 'wards', name, 'default'), '');
+    h.faculties = {};
+    await h.boot();
+    try {
+      const ward = h.wards.get(BOX_SEED);
+      if (!ward) throw new Error('this box stands no ward of its own');
+      const out = (await ward.ask('ask', { being: BOX, method, args })) as Record<string, unknown>;
+      if (typeof out.error === 'string') throw new Error(out.error);
+      await ward.save();
+      return out;
+    } finally {
+      await h.close();
+    }
   }
 
   // Whether a ward is shown at the web route: listed at its root and its
@@ -122,52 +131,45 @@ export class DiskHarbor extends Harbor {
     return existsSync(join(resolve(dir), 'wards', name, 'shown'));
   }
 
-  static async marked(dir: string): Promise<string[]> {
-    const h = new DiskHarbor(dir);
-    return (await h.store.list()).filter((n) => existsSync(join(h.dir, 'wards', n, 'default')));
-  }
-
-  // The default ward read from the folder alone, for a command with no
-  // daemon in front of it and no `--ward` given.
-  static async defaultOf(dir: string): Promise<string> {
-    const h = new DiskHarbor(dir);
-    return defaultWard(await DiskHarbor.marked(dir), await h.store.list());
-  }
   #held = false;
 
-  // `lend` is what this box lends the beings of every ward here: a name to
-  // an invitation on a being of its own ward, which `stand` puts up. A
-  // folder booted by a command lends nothing.
-  // `own` are this terrain's own class bodies, the faculty subclasses a box
-  // has: they stand in front of the built-ins, so a daemon that can ring
-  // hands its own `Push` and the dock ward boots that one.
-  constructor(dir: string, lend?: Lend, own: Record<string, BeingClass> = {}) {
+  constructor(dir: string) {
     const abs = resolve(dir);
     // The key the environment gives, the edge's name for it: from the
     // Keychain through the app that spawned this daemon, or nothing on a
     // droplet, whose folder stays plain under its file modes.
-    super(new Files(abs, process.env.NERVUR_SEED_KEY), async (rec) => ({ ...BUILT_IN, ...own, ...(await loadClasses(isAbsolute(rec.code) ? rec.code : join(abs, rec.code))) }), lend);
+    // A class is keyed where it lives: the dock's under `beings/`, the
+    // folder's under the folder its source sits in, `classes/Corpus`.
+    const lookup = async (rec: { code: string }) => {
+      const path = isAbsolute(rec.code) ? rec.code : join(abs, rec.code);
+      return keyed({ ...BEINGS, [relative(abs, dirname(path))]: await loadClasses(path) });
+    };
+    super(new Files(abs, process.env.NERVUR_SEED_KEY), lookup);
     this.dir = abs;
   }
 
-  // What this box lends, by name. Set before `boot` and read there; a box
-  // that says nothing stands no ward of its own and lends nothing.
-  lent: Record<string, string> | undefined;
+  // The classes this terrain brings to its own ward, as a tree. Set before
+  // `boot` and read there; a box that brings none stands no ward of its own
+  // and lends nothing. The folder's own classes join them under the folder
+  // they live in, so an estate's faculty stands beside the terrain's.
+  faculties: Tree | undefined;
+  // What this harbor is to its faculties. The terrain raises it once the box
+  // is up, which on a daemon is after its routes are mounted.
+  readonly box = harborageOver(() => this.wards.get(BOX_SEED)?.save() ?? Promise.resolve());
 
   // Create a harbor folder with one ward, and the root's setup in it: the
   // front desk, public, and one user being, with the desk holding a standing
   // to her placed by the root's knock. Boots the ward once, with no lease, to
   // do that and to learn its pk, and writes the record. Refuses a folder that
   // has one.
-  static async init(dir: string, name = 'main', user = 'me', cls = 'User', mark = false, shown = false): Promise<{ dir: string; name: string; pk: string; user: string }> {
+  static async init(dir: string, name = 'main', user = 'me', cls?: string, shown = false): Promise<{ dir: string; name: string; pk: string; user: string }> {
     const h = new DiskHarbor(dir);
     if ((await h.store.list()).includes(name)) throw new Error(`ward ${name} already exists in ${h.dir}`);
     await mkdir(join(h.dir, 'classes'), { recursive: true });
     const classes = join(h.dir, DEFAULT_CODE);
-    if (!existsSync(classes)) await writeFile(classes, '// The classes this harbor holds beside the built-in ones. Export each one by name.\nexport {};\n');
+    if (!existsSync(classes)) await writeFile(classes, "// The classes this harbor holds beside the dock's beings. Each export is classes/<its name>.\nexport {};\n");
     const hosted = await h.create(name, user);
-    await setup(hosted, user, cls);
-    if (mark) await DiskHarbor.setDefault(h.dir, name);
+    await setup(hosted, user, cls ? { home: cls } : {});
     if (shown) await DiskHarbor.setShown(h.dir, name, true);
     return { dir: h.dir, name, pk: hosted.pk, user };
   }
@@ -181,12 +183,15 @@ export class DiskHarbor extends Harbor {
   // it yet would leave her holding nothing until her next birth.
   override async boot(): Promise<void> {
     await this.#lease();
-    if (this.lent) this.lend = await stand(this, this.lent);
+    if (this.faculties) {
+      const tree = { ...this.faculties, [dirname(DEFAULT_CODE)]: await loadClasses(join(this.dir, DEFAULT_CODE)) };
+      await standHarbor(this, tree, this.box);
+    }
     await super.boot();
     // Every being who takes what this box lends does it at her birth, and
     // birth is synchronous while taking a standing is not. A box is up when
     // they have landed, not before.
-    await settled();
+    await settled(this);
   }
 
   // Every ward's writing finished, then the lease. A ward says it wrote and

package/harbor/edge/alarm.ts

@@ -6,12 +6,11 @@
 // is a terrain's answer and what it does when it wakes is not.
 //
 // One harbor is one Durable Object, and every ward of it lives in that
-// object, so the alarm wakes the whole harbor and a tick from her to a home's
-// Clock is in-process here as it is on a disk. Only the object may set its
-// own alarm, so the two calls are handed to her after the box ward stands,
-// the way the grants are handed their save: a faculty is built by her ward
-// with a stance and nothing else.
-import { Timer } from '../../dock/index.ts';
+// object, so the alarm wakes the whole harbor. Only the object may set its
+// own alarm, so the two calls are handed to her at birth by the class body
+// the object brings.
+import type { Stance } from 'nervur';
+import { Timer, type Harborage } from '../../box/index.ts';
 import type { Storage } from './platform.d.ts';
 
 // Be woken at this moment, or at no moment at all. One alarm per object,
@@ -27,11 +26,16 @@ export const alarmsIn =
   };
 
 export class Alarm extends Timer {
-  // Handed in after the box ward stands. A timer holding none arms nothing
-  // and wakes nobody, which is a harbor standing no box ward.
-  alarms: Alarms | undefined;
+  // Handed at birth by the object that brings her. A timer holding none arms
+  // nothing and wakes nobody.
+  readonly alarms: Alarms | undefined;
   #setting: Promise<void> = Promise.resolve();
 
+  constructor(stance: Stance, box?: Harborage, alarms?: Alarms) {
+    super(stance, box);
+    this.alarms = alarms;
+  }
+
   // The arming written, for the device's own code and a suite: on this
   // terrain an arming is a write to storage, and a reader of the alarm waits
   // for it. It crosses no door.
@@ -40,9 +44,8 @@ export class Alarm extends Timer {
   }
 
   protected override arm(when: number | null): void {
-    // A faculty arms inside whatever ask learned the moment, and a write is
-    // not something that ask can answer for, so this is left to finish on its
-    // own. An alarm the platform refused is armed again by the next round.
+    // An arming is left to finish on its own; an alarm the platform refused is
+    // armed again by the next round.
     this.#setting = (this.alarms?.(when) ?? Promise.resolve()).catch(() => {});
   }
 }