nervur 0.21.4 → 0.22.0

package/dist/{browser → core/browser}/index.d.ts

@@ -1,7 +1,7 @@
-import { Custody, Memory, type Entropy, type Module } from '../contract/index.ts';
-import type { GroundProbe } from '../harbor/index.ts';
+import { Custody, Memory, type Bundled, type Entropy } from '../contract/index.ts';
+import type { Defaults, GroundProbe } from '../harbor/index.ts';
 import { PointerTerrain } from '../pointer/index.ts';
-export { ringAll, rootOf, serveWorker, type Reaching } from './worker.ts';
+export { rootOf, serveWorker, type Reaching } from './worker.ts';
 export declare const BROWSER = "browser";
 export declare const BROWSER_HARBOR = "nervur";
 export declare class IdbMemory extends Memory {
@@ -23,12 +23,13 @@ export declare class IdbCustody extends Custody {
 }
 export type BrowserParts = {
     readonly where?: string;
-    readonly modules?: readonly Module[];
+    readonly bundle?: readonly Bundled[];
+    readonly defaults: Defaults;
 };
 export declare class BrowserTerrain extends PointerTerrain {
     #private;
     readonly where: string;
-    constructor(parts?: BrowserParts);
+    constructor(parts: BrowserParts);
     get foreground(): boolean;
     claim(): Promise<void>;
     release(): Promise<void>;

package/dist/{browser → core/browser}/index.js

@@ -2,7 +2,8 @@
 // `nervur/browser`: the browser ground, in a page or a worker. A harbor
 // keeps its sealed memory and its seed in one IndexedDB database, named
 // by `where`, speaks the web, and holds its database to one run with a
-// Web Lock of the same name.
+// Web Lock of the same name. It imports a module's source from a Blob
+// URL, or, handed a bundle, runs the bundle alone.
 //
 //   entries   one sealed entry per key [place, name]
 //   custody   the seed, sealed under an AES-GCM key the engine never
@@ -11,9 +12,8 @@
 // A keep is one transaction, so it is whole or nothing by IndexedDB's own
 // rule.
 import { Custody, Memory } from '../contract/index.js';
-import { webFaculty, WEB_OPENING, webPush } from '../line/index.js';
-import { CryptoEntropy, HeldLoader, PointerTerrain } from '../pointer/index.js';
-export { ringAll, rootOf, serveWorker } from './worker.js';
+import { BundleLoader, CryptoEntropy, PointerTerrain, SourceLoader } from '../pointer/index.js';
+export { rootOf, serveWorker } from './worker.js';
 export const BROWSER = 'browser';
 // The database a harbor keeps itself in unless named.
 export const BROWSER_HARBOR = 'nervur';
@@ -144,16 +144,16 @@ export class IdbCustody extends Custody {
         return this.#db.close();
     }
 }
-// A harbor of the browser: its database, the web opened at genesis, Web
-// Push beside it, and one run to a database, held by a Web Lock where the
-// engine has them.
+// A harbor of the browser: its database, and one run to a database, held
+// by a Web Lock where the engine has them. It listens nowhere and has no
+// sockets, so the web carrier dials from it and nothing else carries.
 export class BrowserTerrain extends PointerTerrain {
     where;
     #release;
-    constructor(parts = {}) {
+    constructor(parts) {
         const where = parts.where ?? BROWSER_HARBOR;
         const entropy = new CryptoEntropy();
-        super({ entropy, loader: new HeldLoader(parts.modules ?? []), custody: new IdbCustody(where, entropy), memory: new IdbMemory(where), faculties: [webFaculty(), webPush], opens: [WEB_OPENING] });
+        super({ entropy, loader: parts.bundle ? new BundleLoader(parts.bundle) : new SourceLoader(), custody: new IdbCustody(where, entropy), memory: new IdbMemory(where), defaults: parts.defaults });
         this.where = where;
     }
     // A shared or a service worker outlives any one tab, and a service
@@ -192,5 +192,5 @@ export class BrowserTerrain extends PointerTerrain {
 export const browserGround = {
     name: BROWSER,
     fits: () => typeof indexedDB !== 'undefined' && typeof crypto?.subtle !== 'undefined',
-    terrain: ({ modules, where }) => new BrowserTerrain({ ...(where ? { where } : {}), ...(modules ? { modules } : {}) }),
+    terrain: ({ where, bundle }, defaults) => new BrowserTerrain({ ...(where ? { where } : {}), ...(bundle ? { bundle } : {}), defaults }),
 };

package/dist/{browser → core/browser}/worker.d.ts

@@ -1,10 +1,9 @@
 import type { JsonObject } from '../being/index.ts';
-import { type Harbor } from '../harbor/index.ts';
+import type { Harbor } from '../harbor/index.ts';
 type Scope = {
     addEventListener(type: string, listener: (event: never) => void): void;
 };
-export declare const ringAll: (harbor: Harbor) => Promise<JsonObject[]>;
-export declare const serveWorker: (harbor: Promise<Harbor>, scope?: Scope) => void;
+export declare const serveWorker: (opening: Promise<Harbor>, scope?: Scope) => void;
 export type Reaching = {
     postMessage(message: unknown, transfer: Transferable[]): void;
 };

package/dist/{browser → core/browser}/worker.js

@@ -1,33 +1,30 @@
-import { RELAY_CLIENT, rootLine } from '../harbor/index.js';
 const answer = async (harbor, data, reply) => {
     if (!reply)
         return;
     let out;
     try {
-        out = await rootLine(await harbor, data?.request);
+        out = await (await harbor).ask(data?.request);
     }
     catch {
         out = { error: 'the harbor threw' };
     }
     reply.postMessage(out);
 };
-// Every relay client of the harbor asked to collect what waits.
-export const ringAll = async (harbor) => {
-    const keys = Object.entries(harbor.box.partition.beings)
-        .filter(([, row]) => row.class === RELAY_CLIENT)
-        .map(([key]) => key);
-    return Promise.all(keys.map(async (being) => (await harbor.root('ask', { being, method: 'ring' }))));
-};
 // Called as the worker's script starts, so no tab's first message is
 // lost while the harbor opens.
-export const serveWorker = (harbor, scope = globalThis) => {
+export const serveWorker = (opening, scope = globalThis) => {
+    // The worker holds the harbor, so it asks its `stand` before any tab's.
+    const harbor = opening.then(async (h) => {
+        await h.ask({ method: 'stand' });
+        return h;
+    });
     scope.addEventListener('connect', (event) => {
         const port = event.ports[0];
         port.onmessage = (message) => void answer(harbor, message.data, message.ports[0]);
         port.start();
     });
     scope.addEventListener('message', (event) => void answer(harbor, event.data, event.ports[0]));
-    scope.addEventListener('push', (event) => event.waitUntil(harbor.then(ringAll)));
+    scope.addEventListener('push', (event) => event.waitUntil(harbor.then((h) => h.ask({ method: 'heard' }))));
 };
 // A tab's root line to the worker's harbor.
 export const rootOf = (worker) => (request) => new Promise((resolve) => {

package/dist/{cli → core/cli}/command.d.ts

@@ -1,13 +1,13 @@
 import type { JsonObject } from '../being/index.ts';
-import type { RootRequest } from '../harbor/index.ts';
+import { type Defaults, type RootRequest } from '../harbor/index.ts';
 export declare const parse: (argv: string[]) => {
     command?: string;
     words: string[];
     flags: Record<string, string>;
 };
 export declare const requestOf: (command: string, words: string[], flags: Record<string, string>) => RootRequest;
-export declare const main: (argv: string[], env: Record<string, string | undefined>, print: (line: string) => void) => Promise<number>;
-export declare const pilotRequests: (name: string, invitation: JsonObject, at?: string, web?: boolean) => RootRequest[];
-export declare const via: (pilot: string, far: RootRequest) => RootRequest;
+export declare const main: (argv: string[], env: Record<string, string | undefined>, print: (line: string) => void, defaults: Defaults) => Promise<number>;
+export declare const pilotRequests: (name: string, invitation: JsonObject, at?: string, web?: RootRequest) => RootRequest[];
+export declare const via: (name: string, far: RootRequest) => RootRequest;
 export declare const farAnswer: (local: JsonObject) => JsonObject;
 export declare const SERVING = -1;

package/dist/{cli → core/cli}/command.js

@@ -2,16 +2,33 @@
 // `nervur`: a harbor on this machine. Each command is one root request, the
 // same the root line carries from any front, printed as one JSON line.
 //
-//   nervur init   [--dir D]                         the harbor made: its seed drawn,
-//                                                   its catalogue stood, and an owner
-//                                                   invitation for whoever made it
-//   nervur serve  [--dir D] [--host H] [--port P]   the harbor served: Quo over TCP,
-//                                                   and the root line on its socket
-//   nervur module add <file | package | id>         a module the catalogue runs, kept
-//                                                   by the id it declares
-//   nervur module remove <module>                   a module it runs no more
-//   nervur modules                                  what the catalogue runs
+//   nervur init   [--dir D] [--no-tcp]              the harbor made: its seed drawn,
+//                                                   its catalogue stood, the tcp
+//                                                   carrier opened unless --no-tcp,
+//                                                   and an owner invitation for
+//                                                   whoever made it
+//   nervur serve  [--dir D] [--host H] [--port P]   the harbor served: Quo over the
+//                                                   tcp carrier it holds, and the
+//                                                   root line on its socket
+//   nervur module add <file>                        the module's source committed on
+//                                                   live, and live moved to it
+//   nervur module remove <module>                   its file committed away, and live
+//                                                   moved
+//   nervur modules                                  what live runs
+//   nervur live   [commit | ref]                    live moved there, or the commit
+//                                                   that stands
+//   nervur log                                      the commits from live back
+//   nervur origin <url | none>                      where fetch reads
+//   nervur fetch                                    every ref of origin and all it
+//                                                   reaches, kept
+//   nervur gc                                       every object live and the
+//                                                   fetched refs reach no more, gone
 //   nervur census [--ward W]                        the empty ask
+//   nervur stand  [--ward W]                        what does not stand yet, stood:
+//                                                   the dock's faculties and wards,
+//                                                   or one ward's beings; every
+//                                                   command asks it of the harbor
+//                                                   it opens
 //   nervur sweep                                    every place of the folder this
 //                                                   harbor does not name, gone
 //   nervur export [--with-seed]                     the harbor as one JSON line, to
@@ -22,16 +39,21 @@
 //   nervur edge pack <file> <name>                  the harbor for an edge, under its
 //                                                   name, in the pack the file holds:
 //                                                   its seed sealed under
-//                                                   $NERVUR_SECRET, and its places
+//                                                   $NERVUR_SECRET, and its places,
+//                                                   its code among them
 //   nervur edge dev <file> <name> [--port P]        the harbor packed so, and the pack
 //                                                   run by the worker's own wrangler
 //                                                   dev, from this folder, at
 //                                                   http://127.0.0.1:P/<name>/quo
-//   nervur open   <key> <kind>                      a faculty stands in the box ward
-//   nervur host   <ward> [--seed S] [--store K]     a hosted ward stands, kept by the
-//                                                   root memory or the store K
-//   nervur move   <ward> <store | root>             a hosted ward carried to a store,
-//                                                   or back to the root memory
+//   nervur open   <key> <kind> [--registry R]       a faculty stands in the box ward,
+//                                                   her class resolved through the
+//                                                   registry faculty R or the catalogue
+//   nervur host   <ward> [--seed S] [--memory K]    a hosted ward stands, kept by the
+//                 [--class C] [--registry R]        root memory or the memory faculty K,
+//                                                   its ward of the ward class C, every
+//                                                   class of it resolved through R
+//   nervur move   <ward> <memory | root>            a hosted ward carried to a memory
+//                                                   faculty, or back to the root memory
 //   nervur route  <ward pk> <address... | none>     where a ward is reached, in order
 //   nervur reach  <address...>                      where this harbor is reached, as
 //                                                   every invitation it gives says
@@ -42,30 +64,37 @@
 //   nervur ask    [--ward W] [being] [method] [args] a being, asked as the owner
 //   nervur own    [--ward W] <id>                   an invitation for an owner
 //   nervur disown [--ward W] <id>                   an owner no more
-//   nervur pilot  <name> <invitation> [address]     a far ward held as its owner, by a
-//                                                   pilot being of the box ward, at
-//                                                   the address or the invitation's at
-//   nervur <command> --via <name> ...               the command asked of the far ward
-//                                                   that pilot holds, as its owner
+//   nervur become [--ward W] <kind>                 the ward born again of that class;
+//                 [--registry R]                    the dock's resolved through R
+//   nervur pilot  <name> <invitation> [address]     a far being held as its owner by the
+//                                                   dock, under the name, at the address
+//                                                   or the invitation's at, the web
+//                                                   carrier opened first where it is on
+//                                                   the web and none stands
+//   nervur <command> --via <name> ...               the command asked of the far being
+//                                                   the dock holds under that name, as
+//                                                   its owner
 //
 // D is --dir, then $NERVUR_DIR, then ~/.nervur. A module file is named from
-// where the command runs and kept by its absolute path. No --ward is the box
-// ward, and a pilot holds one ward, so --via takes no --ward. The exit is 1
-// when the answer is an error.
-import { existsSync } from 'node:fs';
+// where the command runs, and its text is what the harbor keeps. No --ward is the box
+// ward, and a name holds one far being, so --via takes no --ward. The exit
+// is 1 when the answer is an error.
+import { existsSync, readFileSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
-import { WEB_OPENING } from '../line/index.js';
-import { harborDir, isFile } from '../node/index.js';
+import { carrierIn } from '../harbor/index.js';
+import { harborDir } from '../node/index.js';
 import { readAt, webAddress } from '../quo/index.js';
 import { edgeDev } from './edge.js';
-import { carry, isServed, land, open, pack, request, serve } from './harbor.js';
+import { carry, census, isServed, land, open, pack, request, serve } from './harbor.js';
 // Where `edge dev` answers unless --port names another, wrangler's own.
 const EDGE_PORT = 8787;
-const USAGE = 'usage: nervur <init|serve|module|modules|census|sweep|open|host|move|route|reach|boot|unboot|public|invite|ask|own|disown|pilot|export|import|edge> [args] [--dir D] [--ward W] [--via V] [--seed S] [--store K] [--with-seed] [--host H] [--port P]';
-const FLAGS = new Set(['dir', 'ward', 'via', 'seed', 'store', 'host', 'port']);
-// The one flag that stands alone, since what it names is a yes.
+const USAGE = 'usage: nervur <init|serve|module|modules|live|log|origin|fetch|gc|census|stand|sweep|open|host|move|route|reach|boot|unboot|public|invite|ask|own|disown|become|pilot|export|import|edge> [args] [--dir D] [--ward W] [--via V] [--seed S] [--memory K] [--class C] [--registry R] [--with-seed] [--no-tcp] [--host H] [--port P]';
+const FLAGS = new Set(['dir', 'ward', 'via', 'seed', 'memory', 'class', 'registry', 'host', 'port']);
+// The flags that stand alone, since what each names is a yes.
 const ALONE = 'with-seed';
+const NO_TCP = 'no-tcp';
+const YES = new Set([ALONE, NO_TCP]);
 export const parse = (argv) => {
     const flags = {};
     const words = [];
@@ -74,7 +103,7 @@ export const parse = (argv) => {
         const name = arg.startsWith('--') ? arg.slice(2) : undefined;
         if (name === undefined)
             words.push(arg);
-        else if (name === ALONE)
+        else if (YES.has(name))
             flags[name] = 'yes';
         else if (!FLAGS.has(name) || argv[i + 1] === undefined)
             throw new Error(`--${name} is no flag with a value`);
@@ -102,32 +131,45 @@ export const requestOf = (command, words, flags) => {
         return words;
     };
     const at = flags.ward === undefined ? {} : { ward: flags.ward };
+    const through = flags.registry === undefined ? {} : { registry: flags.registry };
     switch (command) {
         case 'module': {
             const [verb, what] = need(2);
             if (verb === 'add')
-                return catalogue('add', { from: isFile(what) ? resolve(what) : what });
+                return catalogue('add', { source: readFileSync(resolve(what), 'utf8') });
             if (verb === 'remove')
                 return catalogue('remove', { module: what });
             throw new Error('module is add or remove');
         }
         case 'modules':
             return (need(0), catalogue('modules'));
+        case 'live':
+            if (words.length > 1)
+                throw new Error('live takes a commit, or nothing');
+            return catalogue('live', words[0] === undefined ? {} : { commit: words[0] });
+        case 'log':
+            return (need(0), catalogue('log'));
+        case 'origin':
+            return catalogue('origin', { url: none(need(1)[0]) });
+        case 'fetch':
+            return (need(0), catalogue('fetch'));
+        case 'gc':
+            return (need(0), catalogue('gc'));
         case 'sweep':
             return (need(0), { method: 'sweep', args: {} });
         case 'census':
             return (need(0), at);
         case 'open': {
             const [key, kind] = need(2);
-            return { method: 'open', args: { key: key, class: kind } };
+            return { method: 'open', args: { key: key, class: kind, ...through } };
         }
         case 'host': {
             const [ward] = need(1);
-            return { method: 'host', args: { ward: ward, ...(flags.seed === undefined ? {} : { seed: flags.seed }), ...(flags.store === undefined ? {} : { store: flags.store }) } };
+            return { method: 'host', args: { ward: ward, ...(flags.seed === undefined ? {} : { seed: flags.seed }), ...(flags.memory === undefined ? {} : { memory: flags.memory }), ...(flags.class === undefined ? {} : { class: flags.class }), ...through } };
         }
         case 'move': {
-            const [ward, store] = need(2);
-            return { method: 'move', args: { ward: ward, store: store === 'root' ? null : store } };
+            const [ward, memory] = need(2);
+            return { method: 'move', args: { ward: ward, memory: memory === 'root' ? null : memory } };
         }
         case 'route': {
             const [ward, ...where] = words;
@@ -160,6 +202,10 @@ export const requestOf = (command, words, flags) => {
         case 'own':
         case 'disown':
             return { ...at, method: command, args: { id: need(1)[0] } };
+        case 'stand':
+            return (need(0), { ...at, method: 'stand', args: {} });
+        case 'become':
+            return { ...at, method: 'become', args: { class: need(1)[0], ...through } };
         default:
             throw new Error(USAGE);
     }
@@ -171,7 +217,9 @@ const failed = (answer) => {
     const a = answer;
     return 'error' in a || failed(a.answer);
 };
-export const main = async (argv, env, print) => {
+// The command, over the harbors of this machine, each running the defaults
+// its entry hands it.
+export const main = async (argv, env, print, defaults) => {
     const { command, words, flags } = parse(argv);
     if (command === undefined)
         throw new Error(USAGE);
@@ -185,10 +233,18 @@ export const main = async (argv, env, print) => {
             throw new Error('init takes no argument');
         if (existsSync(join(dir, 'seed')))
             return out({ error: `a harbor stands at ${dir}` });
-        const harbor = await open(dir);
+        const harbor = await open(dir, defaults);
         try {
-            const owner = await harbor.root('own', { id: 'owner' });
-            return out({ pk: harbor.box.pk, owner: owner });
+            if (flags[NO_TCP] === undefined) {
+                const tcp = carrierIn((await census(harbor)).beings, defaults.classes, 'tcp');
+                if (tcp === null)
+                    return out({ error: 'no class this command runs carries tcp' });
+                const opened = tcp.open === undefined ? {} : (await harbor.ask(tcp.open)).answer;
+                if (opened.error !== undefined)
+                    return out(opened);
+            }
+            const owner = (await harbor.ask({ method: 'own', args: { id: 'owner' } })).answer;
+            return out({ pk: (await census(harbor)).pk, owner });
         }
         finally {
             await harbor.close();
@@ -225,7 +281,7 @@ export const main = async (argv, env, print) => {
     if (command === 'serve') {
         if (words.length > 0)
             throw new Error('serve takes no argument');
-        const served = await serve(dir, flags.host, flags.port === undefined ? undefined : Number(flags.port));
+        const served = await serve(dir, defaults, flags.host, flags.port === undefined ? undefined : Number(flags.port));
         const stop = () => void served.close().then(() => process.exit(0));
         process.once('SIGINT', stop);
         process.once('SIGTERM', stop);
@@ -237,43 +293,37 @@ export const main = async (argv, env, print) => {
             throw new Error('pilot takes a name, an invitation, and an address where the invitation carries none');
         const [name, invitation, at] = words;
         const held = JSON.parse(invitation);
-        const census = (await request(dir, {}));
-        const beings = census.answer?.notes?.beings;
-        const web = beings !== undefined && Object.hasOwn(beings, WEB_OPENING.key);
+        const asked = (await request(dir, defaults, {}));
+        const web = carrierIn(asked.answer?.notes?.beings ?? {}, defaults.classes, 'web')?.open;
         for (const req of pilotRequests(name, held, at, web)) {
-            const answer = await request(dir, req);
-            if (!failed(answer))
-                continue;
-            if (req.method === 'ask')
-                await request(dir, { method: 'unboot', args: { being: name } });
-            return out(answer);
+            const answer = await request(dir, defaults, req);
+            if (failed(answer))
+                return out(answer);
         }
         return out({ piloting: name, ward: held.ward });
     }
     if (flags.via === undefined)
-        return out(await request(dir, requestOf(command, words, flags)));
+        return out(await request(dir, defaults, requestOf(command, words, flags)));
     if (flags.ward !== undefined)
         throw new Error('--via takes no --ward');
-    return out(farAnswer(await request(dir, via(flags.via, requestOf(command, words, flags)))));
+    return out(farAnswer(await request(dir, defaults, via(flags.via, requestOf(command, words, flags)))));
 };
 // The root requests that hold a far ward: the web carrier opened, where the
-// far ward is reached on the web and this harbor has none; its route where
-// one is named, else the take learns it from the invitation's `at`; the
-// pilot; the take.
-export const pilotRequests = (name, invitation, at, web = false) => [
-    ...(!web && readAt([...(at === undefined ? [] : [at]), ...readAt(invitation.at)]).some((a) => webAddress(a) !== null) ? [{ method: 'open', args: { key: WEB_OPENING.key, class: WEB_OPENING.kind } }] : []),
-    ...(at === undefined ? [] : [{ method: 'route', args: { ward: invitation.ward ?? null, at: [at] } }]),
-    { method: 'boot', args: { key: name, class: 'org.nervur.pilot' } },
-    { method: 'ask', args: { being: name, method: 'hold', args: { invitation } } },
+// far ward is reached on the web and `web` is the open this harbor still
+// needs; then the dock's `hold`, at the address named, else where the
+// invitation's `at` says.
+export const pilotRequests = (name, invitation, at, web) => [
+    ...(web !== undefined && readAt([...(at === undefined ? [] : [at]), ...readAt(invitation.at)]).some((a) => webAddress(a) !== null) ? [web] : []),
+    { method: 'hold', args: { name, invitation, ...(at === undefined ? {} : { at }) } },
 ];
-// A root request, asked of the far ward a pilot holds.
-export const via = (pilot, far) => ({
-    method: 'ask',
-    args: { being: pilot, method: 'pilot', args: { ...(far.method === undefined ? {} : { method: far.method }), ...(far.args === undefined ? {} : { args: far.args }) } },
+// A root request, asked of the far being the dock holds under a name.
+export const via = (name, far) => ({
+    method: 'pilot',
+    args: { name, ...(far.method === undefined ? {} : { method: far.method }), ...(far.args === undefined ? {} : { args: far.args }) },
 });
-// The far ward-being's answer out of the pilot's, or the local error.
+// The far being's answer out of the dock's, or the local error.
 export const farAnswer = (local) => {
-    const inner = local.answer?.answer;
+    const inner = local.answer;
     return typeof inner === 'object' && inner !== null && !Array.isArray(inner) ? inner : local;
 };
 // What `main` answers for a harbor it keeps serving: no exit yet.

package/dist/{cli → core/cli}/edge.js

@@ -19,8 +19,10 @@ import { hex } from '../crypto/index.js';
 import { CryptoEntropy } from '../pointer/index.js';
 import { pack } from './harbor.js';
 export const EDGE_STATE = '.nervur-edge';
-const READY_TRIES = 240;
-const READY_EVERY = 250;
+// A refused fetch costs next to nothing, so wrangler is asked often and is
+// found the moment it answers, within the same minute as ever.
+const READY_TRIES = 2400;
+const READY_EVERY = 25;
 const answers = (url) => fetch(url).then(() => true, () => false);
 // Resolved once wrangler answers at `url`, rejected once it exits or never
 // answers.

package/dist/core/cli/harbor.d.ts

@@ -0,0 +1,25 @@
+import type { JsonObject } from '../being/index.ts';
+import { Harbor, type Carried, type Defaults, type RootRequest } from '../harbor/index.ts';
+export type Census = {
+    pk: string;
+    beings: Record<string, {
+        class: string;
+        absent: boolean;
+    }>;
+    listening: string[];
+};
+export declare const census: (harbor: Harbor) => Promise<Census>;
+export declare const open: (dir: string, defaults: Defaults) => Promise<Harbor>;
+export declare const isServed: (dir: string) => Promise<boolean>;
+export declare const request: (dir: string, defaults: Defaults, req: RootRequest) => Promise<JsonObject>;
+export declare const carry: (dir: string, seed: boolean) => Promise<Carried>;
+export declare const pack: (dir: string, file: string, name: string, secret: string | undefined) => Promise<JsonObject>;
+export declare const land: (dir: string, value: unknown) => Promise<string[]>;
+export type Served = {
+    pk: string;
+    at: string;
+    listening: string[];
+    root: string;
+    close(): Promise<void>;
+};
+export declare const serve: (dir: string, defaults: Defaults, host?: string, port?: number) => Promise<Served>;

package/dist/{cli → core/cli}/harbor.js

@@ -12,22 +12,30 @@ import { join } from 'node:path';
 import { hex, unhex } from '../crypto/index.js';
 import { isHarborName, readPack, sealSeed } from '../edge/index.js';
 import { FolderCustody, FolderMemory } from '../folder/index.js';
-import { carryPlaces, Harbor, landPlaces, readCarried, rootLine } from '../harbor/index.js';
-import { askServed, MODULES, NodeTerrain, socketOf } from '../node/index.js';
+import { carrierIn, carryPlaces, Harbor, landPlaces, readCarried } from '../harbor/index.js';
+import { askServed, NodeTerrain, socketOf } from '../node/index.js';
 import { CryptoEntropy } from '../pointer/index.js';
-import { TCP_OPENING } from '../tcp/index.js';
+import { tcpAddress } from '../quo/index.js';
 // A harbor of a folder, opened for one ask: it listens nowhere and serves
 // nothing.
-export const open = (dir) => Harbor.open(new NodeTerrain({ dir, wakes: false, serves: false }));
+// Every harbor the command opens runs the defaults its entry hands it, and
+// the command holds it, so it asks its `stand` once it opens.
+const standing = async (terrain) => {
+    const harbor = await Harbor.open(terrain);
+    await harbor.ask({ method: 'stand' });
+    return harbor;
+};
+export const census = async (harbor) => (await harbor.ask({})).answer.notes;
+export const open = (dir, defaults) => standing(new NodeTerrain({ dir, defaults, wakes: false, serves: false }));
 // Whether a harbor of this folder is served now.
 export const isServed = async (dir) => (await askServed(dir, {})) !== undefined;
-export const request = async (dir, req) => {
+export const request = async (dir, defaults, req) => {
     const served = await askServed(dir, req);
     if (served !== undefined)
         return served;
-    const harbor = await open(dir);
+    const harbor = await open(dir, defaults);
     try {
-        return await rootLine(harbor, req);
+        return await harbor.ask(req);
     }
     finally {
         await harbor.close();
@@ -37,20 +45,16 @@ export const request = async (dir, req) => {
 // one who asks says so, since custody holds it and a package without it
 // opens nowhere. No harbor opens, so nothing is asked and nothing is
 // written.
-export const carry = async (dir, seed) => {
-    const places = await carryPlaces(new FolderMemory(dir));
-    const modules = await readFile(join(dir, MODULES), 'utf8').then((text) => JSON.parse(text), () => undefined);
-    return {
-        ...(seed ? { seed: hex(await new FolderCustody(dir, new CryptoEntropy()).seed()) } : {}),
-        places,
-        ...(modules ? { modules } : {}),
-    };
-};
+export const carry = async (dir, seed) => ({
+    ...(seed ? { seed: hex(await new FolderCustody(dir, new CryptoEntropy()).seed()) } : {}),
+    places: await carryPlaces(new FolderMemory(dir)),
+});
 // What `nervur edge pack` hands a deploy: the harbor of a folder, under
 // its name, in the pack the worker bundles, its seed sealed under the
-// worker's `NERVUR_SECRET` beside its sealed places. Every other harbor
-// the pack holds stays, so one worker carries them all, and nothing in the
-// pack opens without the secret.
+// worker's `NERVUR_SECRET` beside its sealed places. Its code travels in
+// its places, as its DNA, so the edge loads what `live` names from there.
+// Every other harbor the pack holds stays, so one worker carries them all,
+// and nothing in the pack opens without the secret.
 export const pack = async (dir, file, name, secret) => {
     if (!isHarborName(name))
         throw new Error(`${name} is no harbor name: lowercase letters, digits and -`);
@@ -81,23 +85,31 @@ export const land = async (dir, value) => {
         await writeFile(join(dir, 'seed'), `${held.seed}\n`, { mode: 0o600, flag: 'wx' });
     else if (!existsSync(join(dir, 'seed')))
         throw new Error('the package carries no seed, and none is held here');
-    if (held.modules && !existsSync(join(dir, MODULES)))
-        await writeFile(join(dir, MODULES), `${JSON.stringify(held.modules, null, 2)}\n`, { mode: 0o600 });
     return landPlaces(memory, held);
 };
-// The harbor served: a harbor of the Node ground, with Quo over TCP on
-// host and port.
-export const serve = async (dir, host, port) => {
-    const harbor = await Harbor.open(new NodeTerrain({ dir }));
-    if (!harbor.box.being(TCP_OPENING.key))
-        await harbor.root('open', { key: TCP_OPENING.key, class: TCP_OPENING.kind });
-    const tcp = harbor.box.being(TCP_OPENING.key);
-    if (host !== undefined || port !== undefined || tcp.listening().length === 0) {
-        const heard = (await harbor.root('ask', { being: TCP_OPENING.key, method: 'listen', args: { ...(host === undefined ? {} : { host }), ...(port === undefined ? {} : { port }) } }));
-        if (typeof heard.answer?.at !== 'string') {
+// The harbor served: a harbor of the Node ground, with Quo over the TCP
+// carrier its root opened, on host and port. Serving adds nothing to the
+// harbor, so one with no TCP carrier is not served.
+export const serve = async (dir, defaults, host, port) => {
+    if (!existsSync(join(dir, 'seed')))
+        throw new Error(`no harbor stands at ${dir}: init one first`);
+    const harbor = await standing(new NodeTerrain({ dir, defaults }));
+    const tcpOf = (listening) => listening.find((address) => tcpAddress(address) !== null);
+    const before = await census(harbor);
+    const present = Object.fromEntries(Object.entries(before.beings).filter(([, being]) => !being.absent));
+    const tcp = carrierIn(present, defaults.classes, 'tcp');
+    if (tcp?.open !== undefined || tcp === null) {
+        await harbor.close();
+        const kind = tcp?.open?.args?.class;
+        throw new Error(`the harbor at ${dir} has no tcp carrier${typeof kind === 'string' ? `: open one with \`nervur open tcp ${kind}\`` : ''}`);
+    }
+    if (host !== undefined || port !== undefined || tcpOf(before.listening) === undefined) {
+        const heard = await harbor.ask({ method: 'ask', args: { being: tcp.key, method: 'listen', args: { ...(host === undefined ? {} : { host }), ...(port === undefined ? {} : { port }) } } });
+        if (typeof heard.answer?.answer?.at !== 'string') {
             await harbor.close();
-            throw new Error(`the harbor does not listen: ${JSON.stringify(heard)}`);
+            throw new Error(`the harbor does not listen: ${JSON.stringify(heard.answer ?? heard)}`);
         }
     }
-    return { pk: harbor.box.pk, at: tcp.listening()[0], listening: harbor.carriers.flatMap((c) => c.listening()), root: socketOf(dir), close: () => harbor.close() };
+    const { pk, listening } = await census(harbor);
+    return { pk, at: tcpOf(listening), listening, root: socketOf(dir), close: () => harbor.close() };
 };