nervur 0.20.0 → 0.20.2

package/dist/line/web.js

@@ -0,0 +1,181 @@
+import { concat, hex, isHex, unhex } from '../crypto/index.js';
+import { CarrierFaculty, UNDIALED } from '../harbor/index.js';
+import { webAddress } from '../quo/index.js';
+import { ownerAsk } from '../ward/index.js';
+import { askBody, readBody } from './frame.js';
+export const MIN_POST = 65;
+export const MAX_POST = 64 + 1_048_576;
+const MAX_ID = 0xffff_ffff;
+// Bytes on a buffer of their own, as a body and a message take them.
+const own = (bytes) => new Uint8Array(bytes);
+// One held line to one address.
+class HeldLine {
+    #socket;
+    #waiting = new Map();
+    #next = 1;
+    constructor(socket) {
+        this.#socket = socket;
+        socket.binaryType = 'arraybuffer';
+        socket.addEventListener('message', (e) => {
+            const frame = typeof e.data === 'string' ? null : readBody(new Uint8Array(e.data));
+            if (frame === null)
+                return this.close();
+            if (frame.kind === 'ask')
+                return;
+            const done = this.#waiting.get(frame.id);
+            this.#waiting.delete(frame.id);
+            done?.(frame.kind === 'reply' ? frame.box : null);
+        });
+        socket.addEventListener('close', () => {
+            for (const done of this.#waiting.values())
+                done(null);
+            this.#waiting.clear();
+        });
+    }
+    // A line that opened with the subprotocol `quo`, or null.
+    static open(href, onClose) {
+        return new Promise((resolve) => {
+            let socket;
+            try {
+                socket = new WebSocket(href, 'quo');
+            }
+            catch {
+                resolve(null);
+                return;
+            }
+            const line = new HeldLine(socket);
+            socket.addEventListener('open', () => (socket.protocol === 'quo' ? resolve(line) : (socket.close(), resolve(null))));
+            socket.addEventListener('close', () => {
+                onClose();
+                resolve(null);
+            });
+            socket.addEventListener('error', () => resolve(null));
+        });
+    }
+    ask(pk, box) {
+        if (this.#socket.readyState !== WebSocket.OPEN)
+            return Promise.resolve(null);
+        const id = this.#next;
+        this.#next = this.#next === MAX_ID ? 1 : this.#next + 1;
+        return new Promise((resolve) => {
+            this.#waiting.set(id, resolve);
+            this.#socket.send(own(askBody(id, pk, box)));
+        });
+    }
+    close() {
+        this.#socket.close();
+    }
+}
+export class WebDialer {
+    #lines = new Map();
+    dial(at, pk, bytes) {
+        const address = webAddress(at);
+        if (address === null || !isHex(pk, 64))
+            return Promise.resolve(UNDIALED);
+        return address.held ? this.#held(address, pk, bytes) : this.#post(address, pk, bytes);
+    }
+    async #post(address, pk, bytes) {
+        let response;
+        try {
+            response = await fetch(address.href, { method: 'POST', body: own(concat(unhex(pk), bytes)) });
+        }
+        catch {
+            return UNDIALED;
+        }
+        const body = new Uint8Array(await response.arrayBuffer().catch(() => new ArrayBuffer(0)));
+        return response.status === 200 && body.length > 0 ? body : null;
+    }
+    async #held(address, pk, bytes) {
+        let line = this.#lines.get(address.href);
+        if (!line) {
+            line = HeldLine.open(address.href, () => this.#lines.delete(address.href));
+            this.#lines.set(address.href, line);
+            void line.then((held) => held ?? this.#lines.delete(address.href));
+        }
+        const held = await line;
+        return held ? held.ask(unhex(pk), bytes) : UNDIALED;
+    }
+    async close() {
+        const lines = [...this.#lines.values()];
+        this.#lines.clear();
+        for (const line of await Promise.all(lines))
+            line?.close();
+    }
+}
+export const WEB = 'org.nervur.web';
+export const WEB_OPENING = { key: 'web', kind: WEB };
+const listenOf = (value) => {
+    if (typeof value !== 'object' || value === null)
+        return null;
+    const { host, port, path, origins } = value;
+    const fine = typeof host === 'string' &&
+        Number.isInteger(port) &&
+        port >= 0 &&
+        port <= 65_535 &&
+        typeof path === 'string' &&
+        path.startsWith('/') &&
+        Array.isArray(origins) &&
+        origins.every((o) => typeof o === 'string');
+    return fine ? { host, port: port, path, origins: origins } : null;
+};
+// Quo over the web as a carrier faculty of one harbor, listening through
+// `serve` where the ground has one:
+//
+//   listen  { host?, port?, path?, origins? }
+//                  listen there from now on, 127.0.0.1, a free port, `/`
+//                  and every origin unless named, and on every wake at the
+//                  port it bound
+//   deaf           listen nowhere from now on
+export const webFaculty = (serve) => (ground) => class WebFaculty extends CarrierFaculty {
+    static kind = WEB;
+    static asks = {
+        listen: ownerAsk('listen for Quo over the web, and on every wake'),
+        deaf: ownerAsk('listen nowhere'),
+    };
+    #dialer = new WebDialer();
+    #listener;
+    accepts(address) {
+        return webAddress(address) !== null;
+    }
+    dial(address, pk, bytes) {
+        return this.#dialer.dial(address, pk, bytes);
+    }
+    listening() {
+        return this.#listener ? [...this.#listener.at] : [];
+    }
+    async awake() {
+        const at = listenOf(this.cells.listen);
+        if (at && serve && !this.#listener)
+            this.#listener = await serve(ground, at);
+    }
+    async sleep() {
+        await this.#dialer.close();
+        await this.#listener?.close();
+        this.#listener = undefined;
+    }
+    async listen(args) {
+        if (!serve)
+            return { error: 'this ground listens nowhere on the web' };
+        const at = listenOf({ host: args.host ?? '127.0.0.1', port: args.port ?? 0, path: args.path ?? '/', origins: args.origins ?? ['*'] });
+        if (at === null)
+            return { error: 'host is text, port a port, path a path and origins a list' };
+        await this.#listener?.close();
+        this.#listener = undefined;
+        try {
+            this.#listener = await serve(ground, at);
+        }
+        catch (e) {
+            return { error: e.message };
+        }
+        this.cells.listen = { ...at, port: this.#listener.port };
+        return { at: [...this.#listener.at] };
+    }
+    async deaf() {
+        await this.#listener?.close();
+        this.#listener = undefined;
+        delete this.cells.listen;
+        return { deaf: true };
+    }
+};
+// The ward pk and box a post carries, or null for a body that is no ask.
+export const readPost = (body) => body.length < MIN_POST || body.length > MAX_POST ? null : { pk: hex(body.subarray(0, 64)), box: body.slice(64) };

package/dist/node/index.d.ts

@@ -0,0 +1,32 @@
+import type { JsonObject } from '../being/index.ts';
+import { Loader, type Loaded, type Module } from '../contract/index.ts';
+import { type GroundProbe, type Harbor, type RootRequest } from '../harbor/index.ts';
+import { PointerTerrain } from '../pointer/index.ts';
+export declare const NODE = "node";
+export declare const harborDir: (env?: Record<string, string | undefined>) => string;
+export declare const socketOf: (dir: string) => string;
+export declare class ImportLoader extends Loader {
+    load(from: string): Promise<Loaded | null>;
+}
+export declare class NodeLoader extends ImportLoader {
+    #private;
+    constructor(modules?: readonly Module[]);
+    load(from: string): Promise<Loaded | null>;
+}
+export declare const askServed: (dir: string, request: RootRequest) => Promise<JsonObject | undefined>;
+export type NodeParts = {
+    readonly dir: string;
+    readonly modules?: readonly Module[];
+    readonly wakes?: boolean;
+    readonly serves?: boolean;
+};
+export declare class NodeTerrain extends PointerTerrain {
+    #private;
+    readonly dir: string;
+    readonly serves: boolean;
+    constructor(parts: NodeParts);
+    claim(): Promise<void>;
+    stand(harbor: Harbor): Promise<void>;
+    release(): Promise<void>;
+}
+export declare const nodeGround: GroundProbe;

package/dist/node/index.js

@@ -0,0 +1,164 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+// SPDX-License-Identifier: Apache-2.0
+// `nervur/node`: the Node ground. A harbor keeps its seed and sealed
+// memory in a folder, finds its code among the modules it is handed and
+// then in files, speaks TCP from genesis and the web and Web Push where
+// the root opens them, and serves the root line on a local socket, so the
+// `nervur` command reaches it while it stands.
+//
+//   <dir>/seed        the harbor's seed
+//   <dir>/<place>/    its sealed memory
+//   <dir>/root.sock   the root line while the harbor is served, open to
+//                     this user alone, or in the temporary folder for a
+//                     folder too deep for a socket path
+//
+// One run holds a folder: a terrain refuses a folder another run serves.
+import { createHash } from 'node:crypto';
+import { chmod, rm } from 'node:fs/promises';
+import { connect, createServer } from 'node:net';
+import { homedir, tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { Loader } from '../contract/index.js';
+import { FolderCustody, FolderMemory } from '../folder/index.js';
+import { rootLine } from '../harbor/index.js';
+import { webGround } from '../http/index.js';
+import { webPush } from '../line/index.js';
+import { CryptoEntropy, HeldLoader, PointerTerrain } from '../pointer/index.js';
+import { TCP_OPENING, tcpFaculty } from '../tcp/index.js';
+export const NODE = 'node';
+// Where a harbor of this user lives unless named: $NERVUR_DIR, then
+// ~/.nervur.
+export const harborDir = (env = process.env) => env.NERVUR_DIR ?? join(homedir(), '.nervur');
+// A socket path has a hundred bytes or so on every system, so a folder too
+// deep for one puts its socket in this user's temporary folder, under a
+// name drawn from the folder's own path.
+const SOCKET_PATH = 100;
+export const socketOf = (dir) => {
+    const beside = join(resolve(dir), 'root.sock');
+    if (Buffer.byteLength(beside) <= SOCKET_PATH)
+        return beside;
+    return join(tmpdir(), `nervur-${createHash('sha256').update(resolve(dir)).digest('hex').slice(0, 32)}.sock`);
+};
+// Code from a file: a module that exports `module`, `version` and
+// `classes`, found again by its absolute path. A file that cannot be
+// imported, or exports no module, is none.
+export class ImportLoader extends Loader {
+    async load(from) {
+        const path = resolve(from);
+        let exported;
+        try {
+            exported = (await import(__rewriteRelativeImportExtension(pathToFileURL(path).href)));
+        }
+        catch {
+            return null;
+        }
+        const { module, version, classes } = exported;
+        if (typeof module !== 'string' || typeof version !== 'string' || !Array.isArray(classes))
+            return null;
+        return { module, version, classes, from: path };
+    }
+}
+// The modules a harbor is handed, by name, and then files.
+export class NodeLoader extends ImportLoader {
+    #held;
+    constructor(modules = []) {
+        super();
+        this.#held = new HeldLoader(modules);
+    }
+    async load(from) {
+        return (await this.#held.load(from)) ?? super.load(from);
+    }
+}
+// One root request over a served harbor's socket, or undefined where none
+// is served.
+export const askServed = (dir, request) => new Promise((done, fail) => {
+    const socket = connect(socketOf(dir));
+    let text = '';
+    socket.once('connect', () => socket.write(`${JSON.stringify(request)}\n`));
+    socket.on('data', (chunk) => {
+        text += chunk.toString('utf8');
+        const end = text.indexOf('\n');
+        if (end < 0)
+            return;
+        socket.end();
+        done(JSON.parse(text.slice(0, end)));
+    });
+    socket.once('error', (e) => (e.code === 'ENOENT' || e.code === 'ECONNREFUSED' ? done(undefined) : fail(e)));
+});
+export class NodeTerrain extends PointerTerrain {
+    dir;
+    serves;
+    #server;
+    constructor(parts) {
+        const entropy = new CryptoEntropy();
+        super({
+            entropy,
+            loader: new NodeLoader(parts.modules),
+            custody: new FolderCustody(parts.dir, entropy),
+            memory: new FolderMemory(parts.dir),
+            faculties: [tcpFaculty, webGround, webPush],
+            opens: [TCP_OPENING],
+            wakes: parts.wakes ?? true,
+        });
+        this.dir = parts.dir;
+        this.serves = parts.serves ?? true;
+    }
+    async claim() {
+        if ((await askServed(this.dir, {})) !== undefined)
+            throw new Error(`a harbor is already served from ${this.dir}`);
+    }
+    // The root line on the socket. A socket file nobody answers on is a
+    // stale one, and is replaced.
+    async stand(harbor) {
+        if (!this.serves)
+            return;
+        const root = socketOf(this.dir);
+        await rm(root, { force: true });
+        const server = createServer((socket) => {
+            let text = '';
+            socket.on('data', (chunk) => {
+                text += chunk.toString('utf8');
+                for (let end = text.indexOf('\n'); end >= 0; end = text.indexOf('\n')) {
+                    const line = text.slice(0, end);
+                    text = text.slice(end + 1);
+                    let value;
+                    try {
+                        value = JSON.parse(line);
+                    }
+                    catch {
+                        value = undefined;
+                    }
+                    void rootLine(harbor, value)
+                        .catch(() => ({ error: 'the harbor threw' }))
+                        .then((answer) => socket.write(`${JSON.stringify(answer)}\n`));
+                }
+            });
+            socket.on('error', () => socket.destroy());
+        });
+        await new Promise((done) => server.listen(root, done));
+        await chmod(root, 0o600);
+        this.#server = server;
+    }
+    async release() {
+        const server = this.#server;
+        if (!server)
+            return;
+        this.#server = undefined;
+        await new Promise((done) => server.close(done));
+        await rm(socketOf(this.dir), { force: true });
+    }
+}
+// Node, and the engines that answer as Node does.
+export const nodeGround = {
+    name: NODE,
+    fits: () => typeof process !== 'undefined' && typeof process.versions?.node === 'string',
+    terrain: ({ modules, where }) => new NodeTerrain({ dir: where ?? harborDir(), ...(modules ? { modules } : {}) }),
+};

package/dist/node.d.ts

@@ -0,0 +1 @@
+export * from './index.ts';

package/dist/node.js

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: Apache-2.0
+// `nervur` as Node reads it: the main entry, with the Node ground added, so
+// `Harbor.open()` keeps a harbor in a folder and serves its root line.
+import { addGround } from './harbor/index.js';
+import { nodeGround } from './node/index.js';
+export * from './index.js';
+addGround(nodeGround);

package/dist/pointer/bodies.d.ts

@@ -1,4 +1,4 @@
-import { Clock, Custody, Entropy, Memory, type Rows } from '../contract/index.ts';
+import { Clock, Custody, Entropy, Loader, Memory, type Loaded, type Module } from '../contract/index.ts';
 export declare class CryptoEntropy extends Entropy {
     draw(length: number): Uint8Array;
 }
@@ -12,9 +12,17 @@ export declare class SystemClock extends Clock {
 export declare class HeldCustody extends Custody {
     #private;
     constructor(entropy: Entropy);
-    seed(name: string): Promise<Uint8Array>;
+    seed(): Promise<Uint8Array>;
+}
+export declare class HeldLoader extends Loader {
+    #private;
+    constructor(modules?: readonly Module[]);
+    load(from: string): Promise<Loaded | null>;
 }
 export declare class VolatileMemory extends Memory {
     #private;
-    open(name: string): Promise<Rows>;
+    read(place: string): Promise<Map<string, Uint8Array>>;
+    write(place: string, entries: ReadonlyMap<string, Uint8Array | null>): Promise<void>;
+    places(): Promise<string[]>;
+    forget(place: string): Promise<void>;
 }

package/dist/pointer/bodies.js

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 // The pointer terrain's bodies: each contract fulfilled in one process,
 // with nothing beyond JavaScript.
-import { Clock, Custody, Entropy, Memory } from '../contract/index.js';
+import { Clock, Custody, Entropy, Loader, Memory } from '../contract/index.js';
 export class CryptoEntropy extends Entropy {
     draw(length) {
         return globalThis.crypto.getRandomValues(new Uint8Array(length));
@@ -17,29 +17,58 @@ export class SystemClock extends Clock {
         return { done, cancel: () => clearTimeout(timer) };
     }
 }
-// Seeds drawn once per name and held by this object.
+// The harbor's seed, drawn once and held by this object.
 export class HeldCustody extends Custody {
-    #entropy;
-    #seeds = new Map();
+    #seed;
     constructor(entropy) {
         super();
-        this.#entropy = entropy;
+        this.#seed = entropy.draw(32);
     }
-    seed(name) {
-        let seed = this.#seeds.get(name);
-        if (!seed)
-            this.#seeds.set(name, (seed = this.#entropy.draw(32)));
-        return Promise.resolve(seed);
+    seed() {
+        return Promise.resolve(this.#seed.slice());
     }
 }
-// Rows that live as long as this object: opening a name again gives the
-// same rows, which is what a restart in one process finds.
+// Modules handed to this object, found by the name each declares.
+export class HeldLoader extends Loader {
+    #modules = new Map();
+    constructor(modules = []) {
+        super();
+        for (const m of modules)
+            this.#modules.set(m.module, m);
+    }
+    load(from) {
+        const m = this.#modules.get(from);
+        return Promise.resolve(m ? { module: m.module, version: m.version, classes: m.classes, from } : null);
+    }
+}
+// Entries that live as long as this object, copied in and out, which is
+// what a restart in one process finds.
 export class VolatileMemory extends Memory {
-    #wards = new Map();
-    open(name) {
-        let rows = this.#wards.get(name);
-        if (!rows)
-            this.#wards.set(name, (rows = { rows: {}, told: () => { }, kept: () => Promise.resolve(true) }));
-        return Promise.resolve(rows);
+    #places = new Map();
+    read(place) {
+        const entries = this.#places.get(place) ?? new Map();
+        return Promise.resolve(new Map([...entries].map(([name, bytes]) => [name, bytes.slice()])));
+    }
+    // One object holds it, so a keep is whole by the run of one turn.
+    write(place, entries) {
+        let kept = this.#places.get(place);
+        if (!kept)
+            this.#places.set(place, (kept = new Map()));
+        for (const [name, bytes] of entries) {
+            if (bytes === null)
+                kept.delete(name);
+            else
+                kept.set(name, bytes.slice());
+        }
+        if (kept.size === 0)
+            this.#places.delete(place);
+        return Promise.resolve();
+    }
+    places() {
+        return Promise.resolve([...this.#places.keys()]);
+    }
+    forget(place) {
+        this.#places.delete(place);
+        return Promise.resolve();
     }
 }

package/dist/pointer/index.d.ts

@@ -1,2 +1,2 @@
-export { CryptoEntropy, HeldCustody, SystemClock, VolatileMemory } from './bodies.ts';
+export { CryptoEntropy, HeldCustody, HeldLoader, SystemClock, VolatileMemory } from './bodies.ts';
 export { NoCarrier, PointerCarrier, PointerTerrain, World, type PointerParts } from './world.ts';

package/dist/pointer/index.js

@@ -1,4 +1,4 @@
 // SPDX-License-Identifier: Apache-2.0
 // The pointer dock: a whole world with `nervur` alone.
-export { CryptoEntropy, HeldCustody, SystemClock, VolatileMemory } from './bodies.js';
+export { CryptoEntropy, HeldCustody, HeldLoader, SystemClock, VolatileMemory } from './bodies.js';
 export { NoCarrier, PointerCarrier, PointerTerrain, World } from './world.js';

package/dist/pointer/world.d.ts

@@ -1,6 +1,5 @@
-import type { BeingClass } from '../being/index.ts';
-import { Carrier, type Clock, type Custody, type Entropy, type Memory } from '../contract/index.ts';
-import { Harbor, Terrain } from '../harbor/index.ts';
+import { Carrier, type Clock, type Custody, type Entropy, type Loader, type Memory, type Module } from '../contract/index.ts';
+import { Harbor, Terrain, type GroundFaculty, type Opening } from '../harbor/index.ts';
 export declare class NoCarrier extends Carrier {
     carry(): Promise<Uint8Array | null>;
 }
@@ -15,6 +14,10 @@ export type PointerParts = {
     custody?: Custody;
     memory?: Memory;
     carrier?: Carrier;
+    loader?: Loader;
+    faculties?: readonly GroundFaculty[];
+    opens?: readonly Opening[];
+    wakes?: boolean;
 };
 export declare class PointerTerrain extends Terrain {
     readonly entropy: Entropy;
@@ -22,13 +25,17 @@ export declare class PointerTerrain extends Terrain {
     readonly custody: Custody;
     readonly memory: Memory;
     readonly carrier: Carrier;
+    readonly loader: Loader;
+    readonly faculties: readonly GroundFaculty[];
+    readonly opens: readonly Opening[];
+    readonly wakes: boolean;
     constructor(parts?: PointerParts);
 }
 export declare class World {
     #private;
     readonly cut: Set<string>;
-    harbor(name: string, classes: readonly BeingClass[], parts?: Omit<PointerParts, 'carrier'>): Promise<Harbor>;
+    harbor(name: string, modules?: readonly Module[], parts?: Omit<PointerParts, 'carrier'>): Promise<Harbor>;
     get(name: string): Harbor;
-    restart(name: string, classes?: readonly BeingClass[], parts?: Omit<PointerParts, 'carrier'>): Promise<Harbor>;
+    restart(name: string, parts?: Omit<PointerParts, 'carrier'>): Promise<Harbor>;
     carry(pk: string, bytes: Uint8Array): Promise<Uint8Array | null>;
 }

package/dist/pointer/world.js

@@ -1,6 +1,11 @@
+// SPDX-License-Identifier: Apache-2.0
+// The pointer world: harbors in one process, an address book from ward pk
+// to harbor that stands in for the internet, and weather between them. A
+// restart drops a harbor and opens a new one on the terrain the world
+// keeps for it, so only what its memory kept comes back.
 import { Carrier } from '../contract/index.js';
 import { Harbor, Terrain } from '../harbor/index.js';
-import { CryptoEntropy, HeldCustody, SystemClock, VolatileMemory } from './bodies.js';
+import { CryptoEntropy, HeldCustody, HeldLoader, SystemClock, VolatileMemory } from './bodies.js';
 // A carrier that reaches no one: a harbor alone.
 export class NoCarrier extends Carrier {
     carry() {
@@ -24,6 +29,10 @@ export class PointerTerrain extends Terrain {
     custody;
     memory;
     carrier;
+    loader;
+    faculties;
+    opens;
+    wakes;
     constructor(parts = {}) {
         super();
         this.entropy = parts.entropy ?? new CryptoEntropy();
@@ -31,20 +40,26 @@ export class PointerTerrain extends Terrain {
         this.custody = parts.custody ?? new HeldCustody(this.entropy);
         this.memory = parts.memory ?? new VolatileMemory();
         this.carrier = parts.carrier ?? new NoCarrier();
+        this.loader = parts.loader ?? new HeldLoader();
+        this.faculties = parts.faculties ?? [];
+        this.opens = parts.opens ?? [];
+        this.wakes = parts.wakes ?? true;
     }
 }
 export class World {
     #places = new Map();
     // Harbors the world reaches no one in, nor anyone out of.
     cut = new Set();
-    // A harbor of this world. `parts` replaces the pointer bodies, a folder's
-    // memory and custody among them.
-    async harbor(name, classes, parts = {}) {
+    // A harbor of this world, whose loader holds `modules` unless `parts`
+    // names a loader. `parts` replaces the pointer bodies, a folder's memory
+    // and custody among them. The harbor runs only the modules its catalogue
+    // was told to add.
+    async harbor(name, modules = [], parts = {}) {
         if (this.#places.has(name))
             throw new Error(`a harbor named ${name} stands`);
-        const terrain = new PointerTerrain({ ...parts, carrier: new PointerCarrier(this) });
-        const harbor = await Harbor.open(terrain, classes);
-        this.#places.set(name, { harbor, terrain, classes });
+        const terrain = new PointerTerrain({ loader: new HeldLoader(modules), ...parts, carrier: new PointerCarrier(this) });
+        const harbor = await Harbor.open(terrain);
+        this.#places.set(name, { harbor, terrain });
         return harbor;
     }
     get(name) {
@@ -53,17 +68,17 @@ export class World {
             throw new Error(`no harbor named ${name}`);
         return place.harbor;
     }
-    // The harbor opened again on its own terrain, with the classes it was
-    // made with unless others are named. `parts` replaces bodies of the
-    // terrain, as a new process would build them over the same disk.
-    async restart(name, classes, parts) {
+    // The harbor opened again on its own terrain. `parts` replaces bodies of
+    // the terrain, as a new process would build them over the same disk, or
+    // with other code.
+    async restart(name, parts) {
         const place = this.#places.get(name);
         if (!place)
             throw new Error(`no harbor named ${name}`);
         const t = place.terrain;
-        const terrain = parts ? new PointerTerrain({ entropy: t.entropy, clock: t.clock, custody: t.custody, memory: t.memory, ...parts, carrier: t.carrier }) : t;
-        const harbor = await Harbor.open(terrain, classes ?? place.classes);
-        this.#places.set(name, { ...place, harbor, terrain });
+        const terrain = parts ? new PointerTerrain({ entropy: t.entropy, clock: t.clock, custody: t.custody, memory: t.memory, loader: t.loader, ...parts, carrier: t.carrier }) : t;
+        const harbor = await Harbor.open(terrain);
+        this.#places.set(name, { harbor, terrain });
         return harbor;
     }
     carry(pk, bytes) {

package/dist/quo/address.d.ts

@@ -0,0 +1,19 @@
+export declare const schemeOf: (s: unknown) => string | null;
+export type TcpAddress = {
+    host: string;
+    port: number;
+};
+export declare const tcpAddress: (s: unknown) => TcpAddress | null;
+export declare const tcpAt: (host: string, port: number) => string;
+export type WebAddress = {
+    scheme: 'http' | 'https' | 'ws' | 'wss';
+    secure: boolean;
+    held: boolean;
+    host: string;
+    port: number;
+    path: string;
+    href: string;
+};
+export declare const webAddress: (s: unknown) => WebAddress | null;
+export declare const unspecified: (s: unknown) => boolean;
+export declare const readAt: (value: unknown) => string[];