nervur 0.20.0 → 0.20.2

package/dist/harbor/catalogue.js

@@ -0,0 +1,101 @@
+// SPDX-License-Identifier: Apache-2.0
+// The catalogue: the dock's first faculty, the code a harbor runs. Her
+// cells name each module by the name it declares, its version, and where
+// the terrain's loader finds it. The harbor wakes her before any other
+// faculty, and she runs every module she names that is found and splits
+// no kind. One that is not stays out alone, with its reason, and the
+// beings of its kinds stand absent.
+//
+//   add     { from }      the module the loader finds there, run from now
+//                         on; the same module again takes its new version
+//   remove  { module }    a module no being stands on, by the kinds kept
+//                         for it, run no more
+//   modules               what she names, each with the version running,
+//                         and why one does not run
+//
+// She is the kit's, of kind `org.nervur.catalogue`, and answers the root
+// and an owner alone.
+import { Faculty } from '../being/index.js';
+import { ownerAsk } from '../ward/index.js';
+export const CATALOGUE = 'catalogue';
+const text = (v) => typeof v === 'string';
+export class Catalogue extends Faculty {
+    static kind = 'org.nervur.catalogue';
+    static cells = { modules: {} };
+    static asks = {
+        add: ownerAsk('a module run from now on', { required: ['from'] }),
+        remove: ownerAsk('a module run no more', { required: ['module'] }),
+        modules: ownerAsk('the modules this harbor runs'),
+    };
+    #harbor;
+    #running = new Map();
+    #failed = new Map();
+    constructor(stance, harbor) {
+        super(stance);
+        this.#harbor = harbor;
+    }
+    get #rows() {
+        return this.cells.modules;
+    }
+    // Every module her cells name, in their order, loaded and run where it
+    // is found, is the module named, and splits no kind with those before
+    // it. The rest stay out, each with its reason.
+    async wake() {
+        for (const [module, row] of Object.entries(this.#rows)) {
+            const loaded = await this.#harbor.load(row.from).catch(() => null);
+            const refused = loaded === null ? `not found at ${row.from}` : loaded.module !== module ? `${row.from} is module ${loaded.module}` : this.#harbor.check([...this.#running.values(), loaded]);
+            if (refused === null)
+                this.#running.set(module, loaded);
+            else
+                this.#failed.set(module, refused);
+        }
+        this.#harbor.run([...this.#running.values()]);
+    }
+    async add(args) {
+        if (!text(args.from))
+            return { error: 'from is text' };
+        const loaded = await this.#harbor.load(args.from);
+        if (loaded === null)
+            return { error: 'no such module' };
+        const running = new Map(this.#running);
+        running.set(loaded.module, loaded);
+        const refused = this.#harbor.run([...running.values()]);
+        if (refused !== null)
+            return { error: refused };
+        this.#running.set(loaded.module, loaded);
+        this.#failed.delete(loaded.module);
+        this.#rows[loaded.module] = { version: loaded.version, from: loaded.from, kinds: this.#harbor.kindsOf(loaded.module) };
+        return { added: loaded.module, version: loaded.version };
+    }
+    remove(args) {
+        const module = args.module;
+        if (!text(module) || !Object.hasOwn(this.#rows, module))
+            return { error: 'no such module' };
+        const kinds = new Set([...this.#rows[module].kinds, ...this.#harbor.kindsOf(module)]);
+        if (this.#harbor.stands([...kinds]))
+            return { error: 'a being stands on this module' };
+        const running = new Map(this.#running);
+        running.delete(module);
+        this.#harbor.run([...running.values()]);
+        this.#running.delete(module);
+        this.#failed.delete(module);
+        delete this.#rows[module];
+        return { removed: module };
+    }
+    modules() {
+        const out = {};
+        for (const [module, row] of Object.entries(this.#rows)) {
+            const failed = this.#failed.get(module);
+            out[module] = { version: row.version, running: this.#running.get(module)?.version ?? null, from: row.from, ...(failed === undefined ? {} : { failed }) };
+        }
+        return out;
+    }
+}
+// The catalogue class one harbor stands: a being is born of her class and
+// her stance alone, so the class holds its harbor.
+export const catalogueFor = (harbor) => class extends Catalogue {
+    static kind = Catalogue.kind;
+    constructor(stance) {
+        super(stance, harbor);
+    }
+};

package/dist/harbor/dock.d.ts

@@ -1,16 +1,45 @@
-import { type AskSpec, type Invitation, type JsonObject } from '../being/index.ts';
+import { type Asker, type AskSpec, type Blueprint, type Invitation, type JsonObject } from '../being/index.ts';
 import { WardBeing, type Lender, type WardBeingStance } from '../ward/index.ts';
 export interface Hosting {
-    host(name: string, invitation: Invitation): Promise<boolean>;
+    host(name: string, invitation: Invitation, seed?: string): Promise<string | null>;
+    route(pk: string, at: readonly string[] | null): boolean;
+    keep(): Promise<boolean>;
+    failures(): Failures;
+    sweep(): Promise<string[]>;
+    grounds(kind: string): boolean;
+    awaken(key: string): Promise<void>;
+    lull(key: string): Promise<void>;
 }
+export type Hosted = {
+    ward: string;
+    seed: string;
+};
+export type Failures = {
+    wards: Record<string, string>;
+    routes: Record<string, string>;
+};
 export declare const BOX = "box";
 export declare class Dock extends WardBeing implements Lender {
     #private;
+    static readonly kind: string;
     static cells: JsonObject;
     static asks: Record<string, AskSpec>;
     constructor(stance: WardBeingStance, hosting: Hosting);
-    get hosted(): string[];
+    describe(asker: Asker): Blueprint;
+    get hosted(): Hosted[];
+    get routes(): Record<string, string[]>;
+    get addresses(): string[];
+    route(args: JsonObject): JsonObject;
+    reach(args: JsonObject): JsonObject;
+    learn(ward: string, at: readonly string[]): Promise<void>;
+    standCatalogue(): Promise<void>;
+    unboot(args: JsonObject): Promise<JsonObject>;
+    standCarriers(opens: readonly {
+        key: string;
+        kind: string;
+    }[]): Promise<void>;
     open(args: JsonObject): Promise<JsonObject>;
+    sweep(): Promise<JsonObject>;
     host(args: JsonObject): Promise<JsonObject>;
     lend(args: JsonObject): Promise<JsonObject>;
     retract(args: JsonObject): Promise<JsonObject>;

package/dist/harbor/dock.js

@@ -5,23 +5,40 @@
 //
 //   open    { key, class }      a faculty stands in the box ward, and the
 //                               dock holds a standing on her under her key
-//   host    { ward }            a hosted ward stands, holding a standing on
-//                               the dock
+//   host    { ward, seed? }     a hosted ward stands under the seed named,
+//                               or a drawn one, holding a standing on the
+//                               dock; the dock keeps its name and seed
 //   lend    { contract }        asked by a hosted ward: an offer from a
 //                               faculty that fulfils the contract
 //   retract { contract, heir }  an offer that was not taken
-import { Faculty } from '../being/index.js';
-import { readInvitation } from '../quo/index.js';
-import { ownerAsk, WardBeing } from '../ward/index.js';
+//   route   { ward, at }        where a ward pk is reached, addresses in the
+//                               order they are tried, or null to forget
+//                               it; the dock keeps it and the harbor hands
+//                               it to its carrier
+//   reach   { at }              where this harbor is reached, the
+//                               addresses every invitation it gives carries
+//
+// A take of an invitation that carries `at` teaches the dock that ward's
+// route, where the root set none.
+import { Faculty, KIT } from '../being/index.js';
+import { CATALOGUE } from './catalogue.js';
+import { readAt, readInvitation } from '../quo/index.js';
+import { ownerAsk, pilots, rootAsk, WardBeing } from '../ward/index.js';
 export const BOX = 'box';
 const text = (v) => typeof v === 'string';
+// A list of addresses, each a URI with a scheme, and at least one.
+const addresses = (v) => Array.isArray(v) && v.length > 0 && readAt(v).length === v.length;
 const hosted = (_, notes) => notes?.hosted === true;
 export class Dock extends WardBeing {
-    static cells = { hosted: [] };
+    static kind = 'org.nervur.dock';
+    static cells = { hosted: [], routes: {}, reach: [] };
     static asks = {
         ...WardBeing.asks,
         open: ownerAsk('a faculty of this harbor', { required: ['key', 'class'] }),
         host: ownerAsk('a ward this harbor hosts', { required: ['ward'] }),
+        route: ownerAsk('where a ward is reached, addresses in order, or null', { required: ['ward', 'at'] }),
+        reach: ownerAsk('where this harbor is reached, the addresses every invitation carries', { required: ['at'] }),
+        sweep: rootAsk('every place of the memory this harbor does not name, gone'),
         lend: { description: 'an offer from a faculty fulfilling a contract', input: { type: 'object', required: ['contract'] }, for: hosted },
         retract: { description: 'an offer that was not taken', input: { type: 'object', required: ['contract', 'heir'] }, for: hosted },
     };
@@ -30,29 +47,98 @@ export class Dock extends WardBeing {
         super(stance);
         this.#hosting = hosting;
     }
+    // The census adds what did not stand, for whoever pilots.
+    describe(asker) {
+        const blueprint = super.describe(asker);
+        if (pilots(asker, this.notes(asker)))
+            blueprint.notes.failed = this.#hosting.failures();
+        return blueprint;
+    }
     get hosted() {
-        return [...this.cells.hosted];
+        return this.cells.hosted.map(({ ward, seed }) => ({ ward, seed }));
+    }
+    get routes() {
+        return Object.fromEntries(Object.entries(this.cells.routes).map(([pk, at]) => [pk, [...at]]));
+    }
+    // Where this harbor is reached, in the order a caller tries it.
+    get addresses() {
+        return [...this.cells.reach];
+    }
+    route(args) {
+        const { ward } = args;
+        const at = typeof args.at === 'string' ? [args.at] : args.at;
+        if (!text(ward) || (at !== null && !addresses(at)) || !this.#hosting.route(ward, at))
+            return { error: 'not routed' };
+        const routes = this.cells.routes;
+        if (at === null)
+            delete routes[ward];
+        else
+            routes[ward] = [...at];
+        return { routed: ward };
+    }
+    reach(args) {
+        if (!addresses(args.at))
+            return { error: 'at is a list of addresses' };
+        this.cells.reach = [...args.at];
+        return { reach: [...args.at] };
+    }
+    // A route learned from an invitation's `at`, where the root set none,
+    // and where the carrier dials one of its addresses.
+    async learn(ward, at) {
+        const routes = this.cells.routes;
+        if (Object.hasOwn(routes, ward) || !this.#hosting.route(ward, at))
+            return;
+        routes[ward] = [...at];
+        await this.#hosting.keep();
+    }
+    // Genesis: the catalogue stands first, and is kept at once.
+    async standCatalogue() {
+        const kind = 'org.nervur.catalogue';
+        if ((await this.stance.boot(kind, CATALOGUE, CATALOGUE)) === null || !(await this.#hosting.keep()))
+            throw new Error('the catalogue did not stand');
+    }
+    // A faculty that goes stops listening first.
+    async unboot(args) {
+        if (typeof args.being === 'string')
+            await this.#hosting.lull(args.being);
+        return super.unboot(args);
+    }
+    // Genesis: the carriers the terrain names stand next, each kept at once.
+    async standCarriers(opens) {
+        for (const { key, kind } of opens)
+            await this.open({ key, class: kind });
+        await this.#hosting.keep();
     }
     async open(args) {
         if (!text(args.key) || !text(args.class))
             return { error: 'key and class are text' };
-        if (!Faculty.fulfils(this.steward.classOf(args.class)))
+        const mine = args.class.startsWith(KIT) ? this.#hosting.grounds(args.class) : true;
+        if (!mine || !Faculty.fulfils(this.steward.classOf(args.class)))
             return { error: 'no such faculty' };
         const opened = await this.stance.boot(args.class, args.key, args.key);
-        return opened === null ? { error: 'not opened' } : { opened };
+        if (opened === null)
+            return { error: 'not opened' };
+        await this.#hosting.awaken(opened);
+        return { opened };
+    }
+    async sweep() {
+        return { swept: await this.#hosting.sweep() };
     }
     async host(args) {
         const name = args.ward;
-        if (!text(name) || name === BOX || this.hosted.includes(name))
+        if (!text(name) || name === BOX || this.hosted.some((h) => h.ward === name))
             return { error: 'no such ward to host' };
+        if (args.seed !== undefined && !text(args.seed))
+            return { error: 'seed is text' };
         const invitation = await this.stance.occupants.invite(name, { hosted: true });
         if (invitation === null)
             return { error: 'not hosted' };
-        if (!(await this.#hosting.host(name, invitation))) {
+        const seed = await this.#hosting.host(name, invitation, args.seed);
+        if (seed === null) {
             this.stance.occupants.remove(name);
             return { error: 'not hosted' };
         }
-        this.cells.hosted.push(name);
+        this.cells.hosted.push({ ward: name, seed });
         return { hosted: name };
     }
     async lend(args) {

package/dist/harbor/harbor.d.ts

@@ -1,22 +1,41 @@
 import type { Answer, BeingClass, Invitation, JsonObject } from '../being/index.ts';
-import { Carrier } from '../contract/index.ts';
-import { Ward } from '../ward/index.ts';
-import { Dock, type Hosting } from './dock.ts';
+import { Carrier, type Loaded } from '../contract/index.ts';
+import { Ward, type Catalogue as Resolving } from '../ward/index.ts';
+import { Catalogue, type Cataloguing } from './catalogue.ts';
+import { CarrierFaculty } from './carrying.ts';
+import { Dock, type Failures, type Hosting } from './dock.ts';
 import { Registry } from './registry.ts';
-import type { Terrain } from './terrain.ts';
-export declare class Harbor extends Carrier implements Hosting {
+import { type Probing } from './probe.ts';
+import { Terrain } from './terrain.ts';
+export declare class Harbor extends Carrier implements Hosting, Cataloguing, Resolving {
     #private;
     readonly terrain: Terrain;
-    readonly registry: Registry;
     private constructor();
-    static open(terrain: Terrain, classes: readonly BeingClass[]): Promise<Harbor>;
+    static open(from?: Terrain | Probing): Promise<Harbor>;
+    sweep(): Promise<string[]>;
+    failures(): Failures;
     get box(): Ward;
     get dock(): Dock;
+    get catalogue(): Catalogue;
+    get registry(): Registry;
     ward(name: string): Ward | undefined;
     get names(): string[];
     root(method?: string, args?: JsonObject): Promise<Answer>;
     holds(pk: string): boolean;
     arrive(pk: string, bytes: Uint8Array): Promise<Uint8Array | null>;
     carry(pk: string, bytes: Uint8Array): Promise<Uint8Array | null>;
-    host(name: string, invitation: Invitation): Promise<boolean>;
+    classOf(kind: string): BeingClass | undefined;
+    load(from: string): Promise<Loaded | null>;
+    check(modules: readonly Loaded[]): string | null;
+    run(modules: readonly Loaded[]): string | null;
+    stands(kinds: readonly string[]): boolean;
+    kindsOf(module: string): string[];
+    host(name: string, invitation: Invitation, seed?: string): Promise<string | null>;
+    keep(): Promise<boolean>;
+    route(pk: string, at: readonly string[] | null): boolean;
+    grounds(kind: string): boolean;
+    awaken(key: string): Promise<void>;
+    lull(key: string): Promise<void>;
+    get carriers(): CarrierFaculty[];
+    close(): Promise<void>;
 }

package/dist/harbor/harbor.js

@@ -1,29 +1,108 @@
 import { Carrier } from '../contract/index.js';
-import { DOCK, Ward } from '../ward/index.js';
+import { hex, isHex, unhex } from '../crypto/index.js';
+import { unspecified, WardKey } from '../quo/index.js';
+import { DOCK, Pilot, Ward } from '../ward/index.js';
+import { Catalogue, CATALOGUE, catalogueFor } from './catalogue.js';
+import { CarrierFaculty, UNDIALED } from './carrying.js';
 import { BOX, Dock } from './dock.js';
+import { Package } from './package.js';
 import { Registry } from './registry.js';
+import { relayClient, relayFaculty } from './relay.js';
+import { probeGround } from './probe.js';
+import { Terrain } from './terrain.js';
 export class Harbor extends Carrier {
     terrain;
-    registry;
+    #package;
     #wards = new Map();
-    constructor(terrain, registry) {
+    #kit;
+    #grounds;
+    #registry;
+    #failed = { wards: {}, routes: {} };
+    constructor(terrain, pack) {
         super();
         this.terrain = terrain;
-        this.registry = registry;
+        this.#package = pack;
+        const faculties = [...terrain.faculties.map((make) => make(this)), relayFaculty(terrain.clock), relayClient(this, terrain.clock)];
+        this.#grounds = new Set(faculties.map((C) => C.kind));
+        this.#kit = [catalogueFor(this), Pilot, ...faculties];
+        this.#registry = new Registry(this.#kit, []);
     }
-    static async open(terrain, classes) {
-        const harbor = new Harbor(terrain, new Registry(classes));
-        await harbor.#unpack(BOX, undefined, (stance) => new Dock(stance, harbor));
-        for (const name of harbor.dock.hosted)
-            await harbor.#unpack(name);
+    // A harbor on the terrain handed in, or, with none, on the ground the
+    // probe finds here. A ground another run holds refuses, and what the
+    // ground serves beside the harbor stands once it is whole.
+    static async open(from = {}) {
+        const terrain = from instanceof Terrain ? from : probeGround(from).terrain;
+        await terrain.claim();
+        let harbor;
+        try {
+            harbor = await Harbor.#stand(terrain);
+        }
+        catch (e) {
+            await terrain.release();
+            throw e;
+        }
+        try {
+            await terrain.stand(harbor);
+        }
+        catch (e) {
+            await harbor.close();
+            throw e;
+        }
+        return harbor;
+    }
+    static async #stand(terrain) {
+        const seed = await terrain.custody.seed();
+        const harbor = new Harbor(terrain, await Package.open(terrain.memory, terrain.entropy, seed));
+        await harbor.#unpack(BOX, seed, undefined, (stance) => new Dock(stance, harbor));
+        const genesis = !harbor.box.partition.being(CATALOGUE);
+        if (genesis)
+            await harbor.dock.standCatalogue();
+        await harbor.catalogue.wake();
+        if (genesis)
+            await harbor.dock.standCarriers(terrain.opens);
+        else if (terrain.wakes)
+            for (const carrier of harbor.carriers)
+                await carrier.awake();
+        for (const [pk, at] of Object.entries(harbor.dock.routes)) {
+            if (!harbor.#dialable(at))
+                harbor.#failed.routes[pk] = 'no carrier dials it';
+        }
+        for (const hosted of harbor.dock.hosted) {
+            try {
+                await harbor.#unpack(hosted.ward, unhex(hosted.seed));
+            }
+            catch (e) {
+                harbor.#failed.wards[hosted.ward] = e instanceof Error ? e.message : String(e);
+            }
+        }
         return harbor;
     }
+    // Hosting: every place of the terrain's memory the dock does not name,
+    // gone. A crash inside `host` leaves such a place, sealed under a seed
+    // nothing kept, and nothing else writes one.
+    async sweep() {
+        const mine = new Set(await Promise.all([BOX, ...this.dock.hosted.map((h) => h.ward)].map((name) => this.#package.place(name))));
+        const swept = (await this.terrain.memory.places()).filter((place) => !mine.has(place));
+        for (const place of swept)
+            await this.terrain.memory.forget(place);
+        return swept;
+    }
+    // Hosting: what did not stand when the harbor opened, each alone.
+    failures() {
+        return { wards: { ...this.#failed.wards }, routes: { ...this.#failed.routes } };
+    }
     get box() {
         return this.#wards.get(BOX);
     }
     get dock() {
         return this.box.wardBeing;
     }
+    get catalogue() {
+        return this.box.being(CATALOGUE);
+    }
+    get registry() {
+        return this.#registry;
+    }
     ward(name) {
         return this.#wards.get(name);
     }
@@ -37,44 +116,156 @@ export class Harbor extends Carrier {
     holds(pk) {
         return this.#door(pk) !== undefined;
     }
-    // Bytes for one of this harbor's doors, or nothing.
+    // Bytes for one of this harbor's doors, or for a ward a relay of this
+    // harbor answers for, or nothing.
     async arrive(pk, bytes) {
         const ward = this.#door(pk);
-        return ward ? (await ward.door.arrive(bytes)).bytes : null;
+        if (ward)
+            return (await ward.door.arrive(bytes)).bytes;
+        return (await this.#relaying(pk)?.relay(pk, bytes)) ?? null;
     }
-    // Carrier: this harbor's own doors first, then the terrain's.
-    carry(pk, bytes) {
-        return this.holds(pk) ? this.arrive(pk, bytes) : this.terrain.carrier.carry(pk, bytes);
+    // Carrier: this harbor's own doors and relays first, then a route's
+    // addresses in order, each to the carrier that dials it, and with no
+    // route the terrain's carrier.
+    async carry(pk, bytes) {
+        if (this.holds(pk) || this.#relaying(pk))
+            return this.arrive(pk, bytes);
+        const at = this.dock.routes[pk];
+        if (at === undefined)
+            return this.terrain.carrier.carry(pk, bytes);
+        for (const address of at) {
+            const carrier = this.carriers.find((c) => c.accepts(address));
+            const out = carrier ? await carrier.dial(address, pk, bytes) : UNDIALED;
+            if (out !== UNDIALED)
+                return out;
+        }
+        return null;
     }
-    // Hosting: a ward the dock hosts stands now.
-    async host(name, invitation) {
+    // Resolving: a kind, by the registry the catalogue runs.
+    classOf(kind) {
+        return this.#registry.classOf(kind);
+    }
+    // Cataloguing: code through the terrain, and the modules run.
+    load(from) {
+        return this.terrain.loader.load(from);
+    }
+    check(modules) {
+        return Registry.refusal(this.#kit, modules);
+    }
+    run(modules) {
+        try {
+            this.#registry = new Registry(this.#kit, modules);
+        }
+        catch (e) {
+            return e.message;
+        }
+        for (const ward of this.#wards.values())
+            ward.bearAnew();
+        return null;
+    }
+    stands(kinds) {
+        for (const ward of this.#wards.values()) {
+            for (const row of Object.values(ward.partition.beings))
+                if (kinds.includes(row.class))
+                    return true;
+        }
+        return false;
+    }
+    kindsOf(module) {
+        return this.#registry.kindsOf(module);
+    }
+    // Hosting: a ward the dock hosts stands now, under the seed named or a
+    // drawn one, and the seed it stands under comes back. A ward whose key
+    // another ward of this harbor already has does not stand.
+    async host(name, invitation, seed) {
         if (this.#wards.has(name))
-            return false;
+            return null;
+        const bytes = seed === undefined ? this.terrain.entropy.draw(32) : isHex(seed, 32) ? unhex(seed) : null;
+        if (bytes === null || this.holds((await WardKey.from(bytes)).pk))
+            return null;
         try {
-            await this.#unpack(name, invitation);
+            await this.#unpack(name, bytes, invitation);
         }
         catch {
-            return false;
+            return null;
         }
         if (this.#wards.get(name).wardBeing.stance.standings.get(DOCK))
-            return true;
+            return hex(bytes);
         this.#wards.delete(name);
-        return false;
+        return null;
+    }
+    keep() {
+        return this.box.partition.kept();
+    }
+    // Hosting: a route is taken where a carrier of this harbor dials one of
+    // its addresses; forgetting one always is.
+    route(pk, at) {
+        const taken = isHex(pk, 64) && (at === null || this.#dialable(at));
+        if (taken)
+            delete this.#failed.routes[pk];
+        return taken;
+    }
+    // Hosting: the carriers this ground ships, and their sleep and waking.
+    grounds(kind) {
+        return this.#grounds.has(kind);
+    }
+    async awaken(key) {
+        const being = this.box.being(key);
+        if (being instanceof CarrierFaculty)
+            await being.awake();
+    }
+    async lull(key) {
+        const being = this.box.being(key);
+        if (being instanceof CarrierFaculty)
+            await being.sleep();
+    }
+    // The carrier faculties standing in the box ward.
+    get carriers() {
+        return Object.keys(this.box.partition.beings)
+            .map((key) => this.box.being(key))
+            .filter((being) => being instanceof CarrierFaculty);
+    }
+    // Every carrier asleep, the last opened first: nothing listens and no
+    // line stays open.
+    async close() {
+        for (const carrier of this.carriers.reverse())
+            await carrier.sleep();
+        await this.terrain.release();
+    }
+    #relaying(pk) {
+        return this.carriers.find((carrier) => carrier.relays(pk));
+    }
+    #dialable(at) {
+        return at.some((address) => this.carriers.some((carrier) => carrier.accepts(address)));
     }
-    async #unpack(name, dock, root) {
-        const { entropy, clock, custody, memory } = this.terrain;
+    async #unpack(name, seed, dock, root) {
+        const { entropy, clock } = this.terrain;
         const ward = await Ward.unpack({
-            seed: await custody.seed(name),
-            memory: await memory.open(name),
-            catalogue: this.registry,
+            seed,
+            memory: await this.#package.rows(name),
+            catalogue: this,
             entropy,
             clock,
             carrier: this,
+            routes: this.#routes,
             ...(dock ? { dock } : {}),
             ...(root ? { root } : {}),
         });
         this.#wards.set(name, ward);
     }
+    // Every ward is reached where the harbor is: where the root's `reach`
+    // says, and where it said nothing, where its carriers listen, save the
+    // unspecified host. What a ward learns from an invitation's `at` is the
+    // dock's to keep. A ward of this harbor needs no route.
+    #routes = {
+        reach: () => {
+            if (!this.#wards.has(BOX))
+                return [];
+            const set = this.dock.addresses;
+            return set.length > 0 ? set : this.carriers.flatMap((carrier) => carrier.listening()).filter((address) => !unspecified(address));
+        },
+        learn: (ward, at) => (this.holds(ward) ? Promise.resolve() : this.dock.learn(ward, at)),
+    };
     #door(pk) {
         for (const ward of this.#wards.values())
             if (ward.pk === pk)

package/dist/harbor/index.d.ts

@@ -1,4 +1,10 @@
-export { BOX, Dock, type Hosting } from './dock.ts';
+export { Catalogue, CATALOGUE, type Cataloguing, type ModuleRow } from './catalogue.ts';
+export { BOX, Dock, type Failures, type Hosted, type Hosting } from './dock.ts';
+export { CarrierFaculty, UNDIALED, type Dialed, type Ground, type GroundFaculty } from './carrying.ts';
 export { Harbor } from './harbor.ts';
+export { copyPackage, Package } from './package.ts';
+export { readRootRequest, rootLine, type RootRequest } from './root-line.ts';
+export { addGround, grounds, probeGround, type GroundProbe, type Probing } from './probe.ts';
 export { Registry } from './registry.ts';
-export { Terrain } from './terrain.ts';
+export { Push, PUSH, RELAY, RELAY_CLIENT, RELAY_HOLD, RELAY_REST, RELAY_WAIT, RELAYED } from './relay.ts';
+export { Terrain, type Opening } from './terrain.ts';