nervur 0.20.1 → 0.20.2

package/src/browser/worker.ts

@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: Apache-2.0
+// The browser harbor in a worker, one for every tab. A shared, dedicated
+// or service worker calls `serveWorker` as its script starts, with the
+// harbor it opens; every tab reaches that harbor's root line with
+// `rootOf`, one request on a channel of its own. A service worker that
+// hears a push asks every relay client of its harbor to `ring`, since a
+// push carries nothing but the news that something waits.
+import type { JsonObject } from '../being/index.ts';
+import { RELAY_CLIENT, rootLine, type Harbor } from '../harbor/index.ts';
+
+type Asked = { request?: unknown };
+type Answering = { postMessage(message: unknown): void };
+type Scope = {
+  addEventListener(type: string, listener: (event: never) => void): void;
+};
+type Connecting = { ports: readonly MessagePort[] };
+type Messaging = { data: unknown; ports: readonly MessagePort[] };
+type Pushing = { waitUntil(work: Promise<unknown>): void };
+
+const answer = async (harbor: Promise<Harbor>, data: unknown, reply: Answering | undefined): Promise<void> => {
+  if (!reply) return;
+  let out: JsonObject;
+  try {
+    out = await rootLine(await harbor, (data as Asked | null)?.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: Harbor): Promise<JsonObject[]> => {
+  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' })) as JsonObject));
+};
+
+// Called as the worker's script starts, so no tab's first message is
+// lost while the harbor opens.
+export const serveWorker = (harbor: Promise<Harbor>, scope: Scope = globalThis as unknown as Scope): void => {
+  scope.addEventListener('connect', (event: Connecting) => {
+    const port = event.ports[0]!;
+    port.onmessage = (message) => void answer(harbor, message.data, message.ports[0]);
+    port.start();
+  });
+  scope.addEventListener('message', (event: Messaging) => void answer(harbor, event.data, event.ports[0]));
+  scope.addEventListener('push', (event: Pushing) => event.waitUntil(harbor.then(ringAll)));
+};
+
+// Where a tab sends root requests: a shared worker's port, a dedicated
+// worker, or a service worker.
+export type Reaching = { postMessage(message: unknown, transfer: Transferable[]): void };
+
+// A tab's root line to the worker's harbor.
+export const rootOf =
+  (worker: Reaching) =>
+  (request: JsonObject): Promise<JsonObject> =>
+    new Promise((resolve) => {
+      const channel = new MessageChannel();
+      channel.port1.onmessage = (message) => {
+        channel.port1.close();
+        resolve(message.data as JsonObject);
+      };
+      worker.postMessage({ request }, [channel.port2]);
+    });

package/src/browser.ts

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: Apache-2.0
+// `nervur` as a browser bundle reads it: the main entry, with the browser
+// ground added, so `Harbor.open()` keeps a harbor in IndexedDB.
+import { browserGround } from './browser/index.ts';
+import { addGround } from './harbor/index.ts';
+
+export * from './index.ts';
+
+addGround(browserGround);

package/src/cli/command.ts

@@ -11,9 +11,18 @@
 //   nervur module remove <module>                   a module it runs no more
 //   nervur modules                                  what the catalogue runs
 //   nervur census [--ward W]                        the empty ask
+//   nervur sweep                                    every place of the folder this
+//                                                   harbor does not name, gone
+//   nervur export [--with-seed]                     the harbor as one JSON line, to
+//                                                   carry it to another ground; with
+//                                                   --with-seed the seed goes too
+//   nervur import <file>                            a carried harbor into an empty
+//                                                   folder, `-` being this input
 //   nervur open   <key> <kind>                      a faculty stands in the box ward
 //   nervur host   <ward> [--seed S]                 a hosted ward stands
-//   nervur route  <ward pk> <host:port | none>      where a ward is reached
+//   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
 //   nervur boot   [--ward W] <key> <kind>           a being stands
 //   nervur unboot [--ward W] <being>                a being goes
 //   nervur public [--ward W] <key | none>           the being a stranger reaches
@@ -21,8 +30,9 @@
 //   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> <host:port>   a far ward held as its owner, by a
-//                                                   pilot being of the box ward
+//   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
 //
@@ -31,14 +41,17 @@
 // 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';
-import { homedir } from 'node:os';
+import { readFile } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
 import type { JsonObject } from '../being/index.ts';
 import type { RootRequest } from '../harbor/index.ts';
-import { open, request, serve } from './harbor.ts';
+import { harborDir } from '../node/index.ts';
+import { carry, isServed, land, open, request, serve } from './harbor.ts';
 
-const USAGE = 'usage: nervur <init|serve|module|modules|census|open|host|route|boot|unboot|public|invite|ask|own|disown|pilot> [args] [--dir D] [--ward W] [--via V] [--seed S] [--host H] [--port P]';
+const USAGE = 'usage: nervur <init|serve|module|modules|census|sweep|open|host|route|reach|boot|unboot|public|invite|ask|own|disown|pilot|export|import> [args] [--dir D] [--ward W] [--via V] [--seed S] [--with-seed] [--host H] [--port P]';
 const FLAGS = new Set(['dir', 'ward', 'via', 'seed', 'host', 'port']);
+// The one flag that stands alone, since what it names is a yes.
+const ALONE = 'with-seed';
 
 export const parse = (argv: string[]): { command?: string; words: string[]; flags: Record<string, string> } => {
   const flags: Record<string, string> = {};
@@ -47,6 +60,7 @@ export const parse = (argv: string[]): { command?: string; words: string[]; flag
     const arg = argv[i]!;
     const name = arg.startsWith('--') ? arg.slice(2) : undefined;
     if (name === undefined) words.push(arg);
+    else if (name === ALONE) flags[name] = 'yes';
     else if (!FLAGS.has(name) || argv[i + 1] === undefined) throw new Error(`--${name} is no flag with a value`);
     else flags[name] = argv[(i += 1)]!;
   }
@@ -54,6 +68,13 @@ export const parse = (argv: string[]): { command?: string; words: string[]; flag
   return { ...(command === undefined ? {} : { command }), words: rest, flags };
 };
 
+// What this command was handed on its input, for `import -`.
+const standingIn = async (): Promise<string> => {
+  let text = '';
+  for await (const chunk of process.stdin) text += (chunk as Buffer).toString('utf8');
+  return text;
+};
+
 const none = (word: string): string | null => (word === 'none' ? null : word);
 const json = (word: string | undefined): JsonObject | undefined => (word === undefined ? undefined : (JSON.parse(word) as JsonObject));
 const catalogue = (method: string, args: JsonObject = {}): RootRequest => ({ method: 'ask', args: { being: 'catalogue', method, args } });
@@ -74,6 +95,8 @@ export const requestOf = (command: string, words: string[], flags: Record<string
     }
     case 'modules':
       return (need(0), catalogue('modules'));
+    case 'sweep':
+      return (need(0), { method: 'sweep', args: {} });
     case 'census':
       return (need(0), at);
     case 'open': {
@@ -85,9 +108,13 @@ export const requestOf = (command: string, words: string[], flags: Record<string
       return { method: 'host', args: { ward: ward!, ...(flags.seed === undefined ? {} : { seed: flags.seed }) } };
     }
     case 'route': {
-      const [ward, where] = need(2);
-      return { method: 'route', args: { ward: ward!, at: none(where!) } };
+      const [ward, ...where] = words;
+      if (ward === undefined || where.length === 0) throw new Error('route takes a ward pk and its addresses, or none');
+      return { method: 'route', args: { ward, at: where.length === 1 && where[0] === 'none' ? null : where } };
     }
+    case 'reach':
+      if (words.length === 0) throw new Error('reach takes the addresses this harbor is reached at');
+      return { method: 'reach', args: { at: words } };
     case 'boot': {
       const [key, kind] = need(2);
       return { ...at, method: 'boot', args: { key: key!, class: kind! } };
@@ -123,7 +150,7 @@ const failed = (answer: unknown): boolean => {
 export const main = async (argv: string[], env: Record<string, string | undefined>, print: (line: string) => void): Promise<number> => {
   const { command, words, flags } = parse(argv);
   if (command === undefined) throw new Error(USAGE);
-  const dir = flags.dir ?? env.NERVUR_DIR ?? join(homedir(), '.nervur');
+  const dir = flags.dir ?? harborDir(env);
   const out = (answer: JsonObject): number => {
     print(JSON.stringify(answer));
     return failed(answer) ? 1 : 0;
@@ -131,26 +158,34 @@ export const main = async (argv: string[], env: Record<string, string | undefine
   if (command === 'init') {
     if (words.length > 0) throw new Error('init takes no argument');
     if (existsSync(join(dir, 'seed'))) return out({ error: `a harbor stands at ${dir}` });
-    const { harbor, carrier } = await open(dir);
+    const harbor = await open(dir);
     try {
       const owner = await harbor.root('own', { id: 'owner' });
       return out({ pk: harbor.box.pk, owner: owner as JsonObject });
     } finally {
-      await carrier.close();
+      await harbor.close();
     }
   }
+  if (command === 'export' || command === 'import') {
+    if (words.length !== (command === 'import' ? 1 : 0)) throw new Error(`${command} takes ${command === 'import' ? 'one file' : 'no argument'}`);
+    if (flags.via !== undefined) throw new Error(`${command} reads this folder, so it takes no --via`);
+    if (await isServed(dir)) throw new Error(`a harbor is served from ${dir}: stop it first`);
+    if (command === 'export') return out((await carry(dir, flags[ALONE] !== undefined)) as unknown as JsonObject);
+    const text = words[0] === '-' ? await standingIn() : await readFile(words[0]!, 'utf8');
+    return out({ landed: await land(dir, JSON.parse(text)) });
+  }
   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 stop = (): void => void served.close().then(() => process.exit(0));
     process.once('SIGINT', stop);
     process.once('SIGTERM', stop);
-    print(JSON.stringify({ pk: served.pk, at: served.at, root: served.root }));
+    print(JSON.stringify({ pk: served.pk, at: served.at, listening: served.listening, root: served.root }));
     return SERVING;
   }
   if (command === 'pilot') {
-    if (words.length !== 3) throw new Error('pilot takes 3 arguments');
-    const [name, invitation, at] = words as [string, string, string];
+    if (words.length !== 2 && words.length !== 3) throw new Error('pilot takes a name, an invitation, and an address where the invitation carries none');
+    const [name, invitation, at] = words as [string, string, string | undefined];
     const held = JSON.parse(invitation) as JsonObject;
     for (const req of pilotRequests(name, held, at)) {
       const answer = await request(dir, req);
@@ -165,9 +200,10 @@ export const main = async (argv: string[], env: Record<string, string | undefine
   return out(farAnswer(await request(dir, via(flags.via, requestOf(command, words, flags)))));
 };
 
-// The root requests that hold a far ward: its route, the pilot, the take.
-export const pilotRequests = (name: string, invitation: JsonObject, at: string): RootRequest[] => [
-  { method: 'route', args: { ward: invitation.ward ?? null, at } },
+// The root requests that hold a far ward: its route where one is named,
+// else the take learns it from the invitation's `at`; the pilot; the take.
+export const pilotRequests = (name: string, invitation: JsonObject, at?: string): RootRequest[] => [
+  ...(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 } } },
 ];

package/src/cli/harbor.ts

@@ -1,137 +1,103 @@
 // SPDX-License-Identifier: Apache-2.0
-// A harbor on this machine, as the `nervur` command stands it: its seed and
-// sealed memory in a folder, its code imported from the files its
-// catalogue names, Quo over TCP as its carrier, and the root line on a
-// local socket beside them.
-//
-//   <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
+// A harbor on this machine, as the `nervur` command stands it: a harbor of
+// the Node ground in a folder, served while `serve` runs, and asked over
+// its root line's socket.
 //
 // A root request goes to a served harbor over its socket. With none served,
 // the command unpacks the harbor from its folder, asks, and closes it, so
 // one process at a time writes the folder.
-import { createHash } from 'node:crypto';
-import { chmod, rm } from 'node:fs/promises';
-import { connect, createServer, type Server } from 'node:net';
-import { tmpdir } from 'node:os';
-import { join, resolve } from 'node:path';
-import { pathToFileURL } from 'node:url';
+import { existsSync } from 'node:fs';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
 import type { JsonObject } from '../being/index.ts';
-import { Loader, type Loaded } from '../contract/index.ts';
+import { hex, isHex, unhex } from '../crypto/index.ts';
 import { FolderCustody, FolderMemory } from '../folder/index.ts';
-import { Harbor, rootLine, type RootRequest } from '../harbor/index.ts';
-import { CryptoEntropy, PointerTerrain } from '../pointer/index.ts';
-import { TcpCarrier, TcpListener } from '../tcp/index.ts';
-
-// 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: string): string => {
-  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: string): Promise<Loaded | null> {
-    const path = resolve(from);
-    let exported: { module?: unknown; version?: unknown; classes?: unknown };
-    try {
-      exported = (await import(pathToFileURL(path).href)) as typeof exported;
-    } 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 };
-  }
-}
-
-export type Opened = { harbor: Harbor; carrier: TcpCarrier };
+import { Harbor, rootLine, type CarrierFaculty, type RootRequest } from '../harbor/index.ts';
+import { askServed, NodeTerrain, socketOf } from '../node/index.ts';
+import { CryptoEntropy } from '../pointer/index.ts';
+import { TCP_OPENING } from '../tcp/index.ts';
 
-export const open = async (dir: string): Promise<Opened> => {
-  const entropy = new CryptoEntropy();
-  const carrier = new TcpCarrier();
-  const harbor = await Harbor.open(new PointerTerrain({ entropy, carrier, loader: new ImportLoader(), custody: new FolderCustody(dir, entropy), memory: new FolderMemory(dir) }));
-  return { harbor, carrier };
-};
+// A harbor of a folder, opened for one ask: it listens nowhere and serves
+// nothing.
+export const open = (dir: string): Promise<Harbor> => Harbor.open(new NodeTerrain({ dir, wakes: false, serves: false }));
 
-// One root request over a served harbor's socket, or undefined where none
-// is served.
-const overSocket = (dir: string, request: RootRequest): Promise<JsonObject | undefined> =>
-  new Promise((done, fail) => {
-    const socket = connect(socketOf(dir));
-    let text = '';
-    socket.once('connect', () => socket.write(`${JSON.stringify(request)}\n`));
-    socket.on('data', (chunk: Buffer) => {
-      text += chunk.toString('utf8');
-      const end = text.indexOf('\n');
-      if (end < 0) return;
-      socket.end();
-      done(JSON.parse(text.slice(0, end)) as JsonObject);
-    });
-    socket.once('error', (e: NodeJS.ErrnoException) => (e.code === 'ENOENT' || e.code === 'ECONNREFUSED' ? done(undefined) : fail(e)));
-  });
+// Whether a harbor of this folder is served now.
+export const isServed = async (dir: string): Promise<boolean> => (await askServed(dir, {})) !== undefined;
 
 export const request = async (dir: string, req: RootRequest): Promise<JsonObject> => {
-  const served = await overSocket(dir, req);
+  const served = await askServed(dir, req);
   if (served !== undefined) return served;
-  const { harbor, carrier } = await open(dir);
+  const harbor = await open(dir);
   try {
     return await rootLine(harbor, req);
   } finally {
-    await carrier.close();
+    await harbor.close();
+  }
+};
+
+// A harbor as one JSON value, for carrying it to another ground: every
+// place of its memory with its sealed entries as hex, and its seed only
+// where the one who asks says so, since custody holds it and a package
+// without it opens nowhere.
+export type Carried = { seed?: string; places: Record<string, Record<string, string>> };
+
+const carried = (value: unknown): Carried | null => {
+  if (typeof value !== 'object' || value === null) return null;
+  const { seed, places } = value as { seed?: unknown; places?: unknown };
+  if (seed !== undefined && !isHex(seed, 32)) return null;
+  if (typeof places !== 'object' || places === null || Array.isArray(places)) return null;
+  for (const entries of Object.values(places)) {
+    if (typeof entries !== 'object' || entries === null || Array.isArray(entries)) return null;
+    for (const bytes of Object.values(entries)) if (!isHex(bytes)) return null;
+  }
+  return { ...(seed === undefined ? {} : { seed }), places: places as Carried['places'] };
+};
+
+// The harbor of a folder, read as bytes alone. No harbor opens, so
+// nothing is asked and nothing is written.
+export const carry = async (dir: string, seed: boolean): Promise<Carried> => {
+  const memory = new FolderMemory(dir);
+  const places: Carried['places'] = {};
+  for (const place of await memory.places()) {
+    places[place] = Object.fromEntries([...(await memory.read(place))].map(([name, bytes]) => [name, hex(bytes)]));
   }
+  if (!seed) return { places };
+  return { seed: hex(await new FolderCustody(dir, new CryptoEntropy()).seed()), places };
 };
 
-export type Served = { pk: string; at: string; root: string; close(): Promise<void> };
+// A carried harbor into an empty folder. A folder holding a seed or a
+// place is left as it stands, and a package with no seed needs one there
+// already, which a terrain that seals its custody writes its own way.
+export const land = async (dir: string, value: unknown): Promise<string[]> => {
+  const held = carried(value);
+  if (held === null) throw new Error('that is no carried harbor');
+  const memory = new FolderMemory(dir);
+  if ((await memory.places()).length > 0 || (held.seed !== undefined && existsSync(join(dir, 'seed')))) throw new Error(`a harbor stands at ${dir}`);
+  await mkdir(dir, { recursive: true, mode: 0o700 });
+  if (held.seed !== undefined) 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');
+  for (const [place, entries] of Object.entries(held.places)) {
+    await memory.write(place, new Map(Object.entries(entries).map(([name, bytes]) => [name, unhex(bytes)])));
+  }
+  return Object.keys(held.places);
+};
+
+// A served harbor: its pk, its tcp address, every address its carriers
+// listen at, and its root line's socket.
+export type Served = { pk: string; at: string; listening: string[]; root: string; close(): Promise<void> };
 
-// The harbor served: Quo over TCP on host and port, the root line on the
-// socket. A socket file nobody answers on is a stale one, and is replaced.
+// The harbor served: a harbor of the Node ground, with Quo over TCP on
+// host and port.
 export const serve = async (dir: string, host?: string, port?: number): Promise<Served> => {
-  if ((await overSocket(dir, {})) !== undefined) throw new Error(`a harbor is already served from ${dir}`);
-  const { harbor, carrier } = await open(dir);
-  const listener = await TcpListener.listen(harbor, host, port);
-  const root = socketOf(dir);
-  await rm(root, { force: true });
-  const server: Server = createServer((socket) => {
-    let text = '';
-    socket.on('data', (chunk: Buffer) => {
-      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: unknown;
-        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<void>((done) => server.listen(root, done));
-  await chmod(root, 0o600);
-  return {
-    pk: harbor.box.pk,
-    at: listener.at,
-    root,
-    close: async () => {
-      await new Promise((done) => server.close(done));
-      await rm(root, { force: true });
-      await listener.close();
-      await carrier.close();
-    },
-  };
+  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) as CarrierFaculty;
+  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 }) } })) as JsonObject;
+    if (typeof (heard.answer as JsonObject | undefined)?.at !== 'string') {
+      await harbor.close();
+      throw new Error(`the harbor does not listen: ${JSON.stringify(heard)}`);
+    }
+  }
+  return { pk: harbor.box.pk, at: tcp.listening()[0]!, listening: harbor.carriers.flatMap((c) => c.listening()), root: socketOf(dir), close: () => harbor.close() };
 };

package/src/contract/index.ts

@@ -36,8 +36,15 @@ export interface Rows {
 export abstract class Memory {
   // Every entry kept in a place; a place nothing was kept in is empty.
   abstract read(place: string): Promise<Map<string, Uint8Array>>;
-  // One keep: each entry written whole, or removed where it is null.
+  // One keep, whole: every entry written and every null removed together,
+  // or none of them. A read after a keep that did not finish, in this run
+  // or in the run before it, holds the place as it was or as the keep
+  // leaves it, and never half of each.
   abstract write(place: string, entries: ReadonlyMap<string, Uint8Array | null>): Promise<void>;
+  // Every place this memory holds something in, in any order.
+  abstract places(): Promise<string[]>;
+  // A place and everything in it, gone.
+  abstract forget(place: string): Promise<void>;
 }
 
 // The harbor's seed: thirty-two bytes, the same every time. It is the one
@@ -61,13 +68,9 @@ export abstract class Loader {
   abstract load(from: string): Promise<Loaded | null>;
 }
 
-// Bytes to a ward pk in; bytes, or null for nothing, out.
+// Bytes to a ward pk in; bytes, or null for nothing, out. A harbor hands a
+// terrain's carrier what it holds no route for; what it routes goes to its
+// carrier faculties.
 export abstract class Carrier {
   abstract carry(pk: string, bytes: Uint8Array): Promise<Uint8Array | null>;
-  // Where a ward pk is reached, or null to forget it: true when this
-  // carrier dials by address and took it. The addresses live in the dock's
-  // cells, and the harbor hands them here as it unpacks.
-  route(_pk: string, _at: string | null): boolean {
-    return false;
-  }
 }