nervur 0.20.1 → 0.20.3

package/dist/cli/command.js

@@ -7,13 +7,27 @@
 //                                                   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>                        a module the catalogue runs
+//   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 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 edge pack <file>                         the harbor for an edge: its seed
+//                                                   printed, for the worker's
+//                                                   NERVUR_SEED, and its sealed
+//                                                   package written to the file
 //   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 +35,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,11 +46,16 @@
 // 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 { open, request, serve } from './harbor.js';
-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]';
+import { WEB_OPENING } from '../line/index.js';
+import { harborDir, isFile } from '../node/index.js';
+import { readAt, webAddress } from '../quo/index.js';
+import { carry, isServed, land, open, pack, request, serve } from './harbor.js';
+const USAGE = 'usage: nervur <init|serve|module|modules|census|sweep|open|host|route|reach|boot|unboot|public|invite|ask|own|disown|pilot|export|import|edge> [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) => {
     const flags = {};
     const words = [];
@@ -44,6 +64,8 @@ export const parse = (argv) => {
         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
@@ -52,6 +74,13 @@ export const parse = (argv) => {
     const [command, ...rest] = words;
     return { ...(command === undefined ? {} : { command }), words: rest, flags };
 };
+// What this command was handed on its input, for `import -`.
+const standingIn = async () => {
+    let text = '';
+    for await (const chunk of process.stdin)
+        text += chunk.toString('utf8');
+    return text;
+};
 const none = (word) => (word === 'none' ? null : word);
 const json = (word) => (word === undefined ? undefined : JSON.parse(word));
 const catalogue = (method, args = {}) => ({ method: 'ask', args: { being: 'catalogue', method, args } });
@@ -67,13 +96,15 @@ export const requestOf = (command, words, flags) => {
         case 'module': {
             const [verb, what] = need(2);
             if (verb === 'add')
-                return catalogue('add', { from: resolve(what) });
+                return catalogue('add', { from: isFile(what) ? resolve(what) : what });
             if (verb === 'remove')
                 return catalogue('remove', { module: what });
             throw new Error('module is add or remove');
         }
         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 +116,15 @@ export const requestOf = (command, words, flags) => {
             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 } };
@@ -124,7 +161,7 @@ export const main = async (argv, env, print) => {
     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) => {
         print(JSON.stringify(answer));
         return failed(answer) ? 1 : 0;
@@ -134,15 +171,36 @@ 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, 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 });
         }
         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)));
+        const text = words[0] === '-' ? await standingIn() : await readFile(words[0], 'utf8');
+        return out({ landed: await land(dir, JSON.parse(text)) });
+    }
+    if (command === 'edge') {
+        if (words[0] !== 'pack' || words.length !== 2)
+            throw new Error('edge takes pack and a file');
+        if (flags.via !== undefined)
+            throw new Error('edge pack reads this folder, so it takes no --via');
+        if (await isServed(dir))
+            throw new Error(`a harbor is served from ${dir}: stop it first`);
+        return out(await pack(dir, words[1]));
+    }
     if (command === 'serve') {
         if (words.length > 0)
             throw new Error('serve takes no argument');
@@ -150,15 +208,17 @@ export const main = async (argv, env, print) => {
         const stop = () => 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');
+        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;
         const held = JSON.parse(invitation);
-        for (const req of pilotRequests(name, held, at)) {
+        const census = (await request(dir, {}));
+        const web = census.answer?.beings !== undefined && Object.hasOwn(census.answer.beings, WEB_OPENING.key);
+        for (const req of pilotRequests(name, held, at, web)) {
             const answer = await request(dir, req);
             if (!failed(answer))
                 continue;
@@ -174,9 +234,13 @@ export const main = async (argv, env, print) => {
         throw new Error('--via takes no --ward');
     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, invitation, at) => [
-    { method: 'route', args: { ward: invitation.ward ?? null, at } },
+// 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 } } },
 ];

package/dist/cli/harbor.d.ts

@@ -1,20 +1,15 @@
 import type { JsonObject } from '../being/index.ts';
-import { Loader, type Loaded } from '../contract/index.ts';
-import { Harbor, type RootRequest } from '../harbor/index.ts';
-import { TcpCarrier } from '../tcp/index.ts';
-export declare const socketOf: (dir: string) => string;
-export declare class ImportLoader extends Loader {
-    load(from: string): Promise<Loaded | null>;
-}
-export type Opened = {
-    harbor: Harbor;
-    carrier: TcpCarrier;
-};
-export declare const open: (dir: string) => Promise<Opened>;
+import { Harbor, type Carried, type RootRequest } from '../harbor/index.ts';
+export declare const open: (dir: string) => Promise<Harbor>;
+export declare const isServed: (dir: string) => Promise<boolean>;
 export declare const request: (dir: string, req: RootRequest) => Promise<JsonObject>;
+export declare const carry: (dir: string, seed: boolean) => Promise<Carried>;
+export declare const pack: (dir: string, file: string) => 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>;
 };

package/dist/cli/harbor.js

@@ -1,141 +1,91 @@
-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
-// 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 } from 'node:net';
-import { tmpdir } from 'node:os';
-import { join, resolve } from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { Loader } from '../contract/index.js';
+import { existsSync } from 'node:fs';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { hex } from '../crypto/index.js';
 import { FolderCustody, FolderMemory } from '../folder/index.js';
-import { Harbor, rootLine } from '../harbor/index.js';
-import { CryptoEntropy, PointerTerrain } from '../pointer/index.js';
-import { TcpCarrier, TcpListener } from '../tcp/index.js';
-// 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 };
-    }
-}
-export const open = async (dir) => {
-    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 };
-};
-// One root request over a served harbor's socket, or undefined where none
-// is served.
-const overSocket = (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)));
-});
+import { carryPlaces, Harbor, landPlaces, readCarried, rootLine } from '../harbor/index.js';
+import { askServed, MODULES, NodeTerrain, socketOf } from '../node/index.js';
+import { CryptoEntropy } from '../pointer/index.js';
+import { TCP_OPENING } from '../tcp/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 }));
+// Whether a harbor of this folder is served now.
+export const isServed = async (dir) => (await askServed(dir, {})) !== undefined;
 export const request = async (dir, req) => {
-    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();
     }
 };
-// 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.
-export const serve = async (dir, host, port) => {
-    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 = 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);
+// The harbor of a folder, read as bytes alone, its seed only where the
+// 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 {
-        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();
-        },
+        ...(seed ? { seed: hex(await new FolderCustody(dir, new CryptoEntropy()).seed()) } : {}),
+        places,
+        ...(modules ? { modules } : {}),
     };
 };
+// What `nervur edge pack` hands a deploy: the seed, for the worker's
+// `NERVUR_SEED`, and the sealed package without it, for the bundle.
+export const pack = async (dir, file) => {
+    if (!existsSync(join(dir, 'seed')))
+        throw new Error(`no harbor stands at ${dir}`);
+    const { seed, places } = await carry(dir, true);
+    await writeFile(file, `${JSON.stringify({ places })}\n`, { mode: 0o600 });
+    return { seed: seed, package: file, places: Object.keys(places).length };
+};
+// 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, value) => {
+    const held = readCarried(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');
+    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') {
+            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/dist/contract/index.d.ts

@@ -18,6 +18,8 @@ export interface Rows {
 export declare abstract class Memory {
     abstract read(place: string): Promise<Map<string, Uint8Array>>;
     abstract write(place: string, entries: ReadonlyMap<string, Uint8Array | null>): Promise<void>;
+    abstract places(): Promise<string[]>;
+    abstract forget(place: string): Promise<void>;
 }
 export declare abstract class Custody {
     abstract seed(): Promise<Uint8Array>;
@@ -35,5 +37,4 @@ export declare abstract class Loader {
 }
 export declare abstract class Carrier {
     abstract carry(pk: string, bytes: Uint8Array): Promise<Uint8Array | null>;
-    route(_pk: string, _at: string | null): boolean;
 }

package/dist/contract/index.js

@@ -22,12 +22,8 @@ export class Custody {
 // one thing beside the seed a terrain hands in: a map, an import, a bundle.
 export class Loader {
 }
-// 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 class Carrier {
-    // 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, _at) {
-        return false;
-    }
 }

package/dist/edge/index.d.ts

@@ -0,0 +1,71 @@
+import { Custody, Memory, type Entropy, type Module } from '../contract/index.ts';
+import { Harbor, type Carried, type GroundFaculty, type GroundProbe } from '../harbor/index.ts';
+import { type WebListen } from '../line/index.ts';
+import { PointerTerrain } from '../pointer/index.ts';
+export type { Carried } from '../harbor/index.ts';
+export declare const EDGE = "edge";
+export interface EdgeStorage {
+    get(key: string): Promise<unknown>;
+    put(entries: Record<string, unknown>): Promise<void>;
+    delete(keys: string[]): Promise<number>;
+    list(options: {
+        prefix: string;
+    }): Promise<Map<string, unknown>>;
+    transaction<T>(work: (txn: EdgeStorage) => Promise<T>): Promise<T>;
+}
+export interface EdgeState {
+    readonly storage: EdgeStorage;
+    blockConcurrencyWhile<T>(work: () => Promise<T>): Promise<T>;
+}
+export type EdgeEnv = {
+    readonly NERVUR_SEED?: string;
+    readonly NERVUR_SECRET?: string;
+};
+export type EdgeGiven = {
+    readonly state: EdgeState;
+    readonly env: EdgeEnv;
+    readonly package?: Carried;
+};
+export declare class EdgeMemory extends Memory {
+    #private;
+    constructor(storage: EdgeStorage, root?: string);
+    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>;
+}
+export type EdgeKeys = {
+    readonly seed?: string | undefined;
+    readonly secret?: string | undefined;
+};
+export declare class EdgeCustody extends Custody {
+    #private;
+    constructor(storage: EdgeStorage, keys: EdgeKeys, entropy?: Entropy, root?: string);
+    seed(): Promise<Uint8Array>;
+}
+export declare const edgeTcp: GroundFaculty;
+export type EdgeParts = {
+    readonly given: EdgeGiven;
+    readonly modules?: readonly Module[];
+};
+export declare class EdgeTerrain extends PointerTerrain {
+    #private;
+    readonly given: EdgeGiven;
+    listening: WebListen | undefined;
+    constructor(parts: EdgeParts);
+    claim(): Promise<void>;
+    stand(harbor: Harbor): Promise<void>;
+    answer(request: Request): Promise<Response>;
+}
+export declare const edgeGround: GroundProbe;
+export type HarborObjectParts = {
+    readonly modules: readonly Module[];
+    readonly package?: Carried | ((env: EdgeEnv) => Carried | undefined);
+    readonly path?: string;
+    readonly stood?: (harbor: Harbor) => Promise<void>;
+};
+export type HarborObjectClass = new (state: EdgeState, env: EdgeEnv) => {
+    readonly harbor: Promise<Harbor>;
+    fetch(request: Request): Promise<Response>;
+};
+export declare const harborObject: ({ modules, package: carried, path, stood }: HarborObjectParts) => HarborObjectClass;