nervur 0.20.0 → 0.20.2

package/dist/browser/worker.d.ts

@@ -0,0 +1,12 @@
+import type { JsonObject } from '../being/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 type Reaching = {
+    postMessage(message: unknown, transfer: Transferable[]): void;
+};
+export declare const rootOf: (worker: Reaching) => (request: JsonObject) => Promise<JsonObject>;
+export {};

package/dist/browser/worker.js

@@ -0,0 +1,40 @@
+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);
+    }
+    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) => {
+    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)));
+};
+// A tab's root line to the worker's harbor.
+export const rootOf = (worker) => (request) => new Promise((resolve) => {
+    const channel = new MessageChannel();
+    channel.port1.onmessage = (message) => {
+        channel.port1.close();
+        resolve(message.data);
+    };
+    worker.postMessage({ request }, [channel.port2]);
+});

package/dist/browser.d.ts

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

package/dist/browser.js

@@ -0,0 +1,7 @@
+// 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.js';
+import { addGround } from './harbor/index.js';
+export * from './index.js';
+addGround(browserGround);

package/dist/cli/command.d.ts

@@ -0,0 +1,13 @@
+import type { JsonObject } from '../being/index.ts';
+import 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) => RootRequest[];
+export declare const via: (pilot: string, far: RootRequest) => RootRequest;
+export declare const farAnswer: (local: JsonObject) => JsonObject;
+export declare const SERVING = -1;

package/dist/cli/command.js

@@ -0,0 +1,237 @@
+// SPDX-License-Identifier: Apache-2.0
+// `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>                        a module the catalogue runs
+//   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> <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
+//   nervur invite [--ward W] <being> <id>           an invitation on a being
+//   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
+//
+// 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';
+import { readFile } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { harborDir } from '../node/index.js';
+import { carry, isServed, land, open, 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> [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 = [];
+    for (let i = 0; i < argv.length; i += 1) {
+        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)];
+    }
+    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 } });
+// The root request a command names, or a throw saying what it lacks.
+export const requestOf = (command, words, flags) => {
+    const need = (n) => {
+        if (words.length !== n)
+            throw new Error(`${command} takes ${n} argument${n === 1 ? '' : 's'}`);
+        return words;
+    };
+    const at = flags.ward === undefined ? {} : { ward: flags.ward };
+    switch (command) {
+        case 'module': {
+            const [verb, what] = need(2);
+            if (verb === 'add')
+                return catalogue('add', { from: resolve(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': {
+            const [key, kind] = need(2);
+            return { method: 'open', args: { key: key, class: kind } };
+        }
+        case 'host': {
+            const [ward] = need(1);
+            return { method: 'host', args: { ward: ward, ...(flags.seed === undefined ? {} : { seed: flags.seed }) } };
+        }
+        case 'route': {
+            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 } };
+        }
+        case 'unboot':
+            return { ...at, method: 'unboot', args: { being: need(1)[0] } };
+        case 'public':
+            return { ...at, method: 'public', args: { key: none(need(1)[0]) } };
+        case 'invite': {
+            const [being, id] = need(2);
+            return { ...at, method: 'invite', args: { being: being, id: id } };
+        }
+        case 'ask': {
+            if (words.length > 3)
+                throw new Error('ask takes at most a being, a method and its args');
+            const [being, method, args] = words;
+            return { ...at, method: 'ask', args: { ...(being === undefined ? {} : { being }), ...(method === undefined ? {} : { method }), ...(args === undefined ? {} : { args: json(args) }) } };
+        }
+        case 'own':
+        case 'disown':
+            return { ...at, method: command, args: { id: need(1)[0] } };
+        default:
+            throw new Error(USAGE);
+    }
+};
+// An error answer at any depth the root line or an ask carries it.
+const failed = (answer) => {
+    if (typeof answer !== 'object' || answer === null)
+        return false;
+    const a = answer;
+    return 'error' in a || failed(a.answer);
+};
+export const main = async (argv, env, print) => {
+    const { command, words, flags } = parse(argv);
+    if (command === undefined)
+        throw new Error(USAGE);
+    const dir = flags.dir ?? harborDir(env);
+    const out = (answer) => {
+        print(JSON.stringify(answer));
+        return failed(answer) ? 1 : 0;
+    };
+    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 = await open(dir);
+        try {
+            const owner = await harbor.root('own', { id: 'owner' });
+            return out({ pk: harbor.box.pk, owner: owner });
+        }
+        finally {
+            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 === '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 served.close().then(() => process.exit(0));
+        process.once('SIGINT', stop);
+        process.once('SIGTERM', stop);
+        print(JSON.stringify({ pk: served.pk, at: served.at, listening: served.listening, root: served.root }));
+        return SERVING;
+    }
+    if (command === 'pilot') {
+        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 answer = await request(dir, req);
+            if (!failed(answer))
+                continue;
+            if (req.method === 'ask')
+                await request(dir, { method: 'unboot', args: { being: name } });
+            return out(answer);
+        }
+        return out({ piloting: name, ward: held.ward });
+    }
+    if (flags.via === undefined)
+        return out(await request(dir, 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)))));
+};
+// 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, invitation, at) => [
+    ...(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 } } },
+];
+// 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 }) } },
+});
+// The far ward-being's answer out of the pilot's, or the local error.
+export const farAnswer = (local) => {
+    const inner = local.answer?.answer;
+    return typeof inner === 'object' && inner !== null && !Array.isArray(inner) ? inner : local;
+};
+// What `main` answers for a harbor it keeps serving: no exit yet.
+export const SERVING = -1;

package/dist/cli/harbor.d.ts

@@ -0,0 +1,19 @@
+import type { JsonObject } from '../being/index.ts';
+import { Harbor, 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 type Carried = {
+    seed?: string;
+    places: Record<string, Record<string, string>>;
+};
+export declare const carry: (dir: string, seed: boolean) => Promise<Carried>;
+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, host?: string, port?: number) => Promise<Served>;

package/dist/cli/harbor.js

@@ -0,0 +1,99 @@
+// SPDX-License-Identifier: Apache-2.0
+// 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 { existsSync } from 'node:fs';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { hex, isHex, unhex } from '../crypto/index.js';
+import { FolderCustody, FolderMemory } from '../folder/index.js';
+import { Harbor, rootLine } 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';
+// 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 askServed(dir, req);
+    if (served !== undefined)
+        return served;
+    const harbor = await open(dir);
+    try {
+        return await rootLine(harbor, req);
+    }
+    finally {
+        await harbor.close();
+    }
+};
+const carried = (value) => {
+    if (typeof value !== 'object' || value === null)
+        return null;
+    const { seed, places } = value;
+    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 };
+};
+// 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, seed) => {
+    const memory = new FolderMemory(dir);
+    const 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 };
+};
+// 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 = 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);
+};
+// 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/cli/main.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/main.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+// SPDX-License-Identifier: Apache-2.0
+// The `nervur` program: `command.ts` over this process's arguments. A
+// command that cannot run exits 2 and says why on stderr.
+import { main, SERVING } from './command.js';
+try {
+    const code = await main(process.argv.slice(2), process.env, (line) => process.stdout.write(`${line}\n`));
+    if (code !== SERVING)
+        process.exitCode = code;
+}
+catch (e) {
+    process.stderr.write(`nervur: ${e.message}\n`);
+    process.exitCode = 2;
+}

package/dist/contract/index.d.ts

@@ -16,10 +16,24 @@ export interface Rows {
     kept(): Promise<boolean>;
 }
 export declare abstract class Memory {
-    abstract open(name: string): Promise<Rows>;
+    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(name: string): Promise<Uint8Array>;
+    abstract seed(): Promise<Uint8Array>;
+}
+export type Module = {
+    readonly module: string;
+    readonly version: string;
+    readonly classes: readonly unknown[];
+};
+export type Loaded = Module & {
+    readonly from: string;
+};
+export declare abstract class Loader {
+    abstract load(from: string): Promise<Loaded | null>;
 }
 export declare abstract class Carrier {
     abstract carry(pk: string, bytes: Uint8Array): Promise<Uint8Array | null>;

package/dist/contract/index.js

@@ -8,12 +8,22 @@ export class Entropy {
 // The moment, and a wait that ends.
 export class Clock {
 }
+// A harbor's memory as a terrain keeps it: sealed entries it cannot read,
+// in places, each entry by name. Every name is lowercase hex the kit
+// chose, so a body may use it as a file name as it stands.
 export class Memory {
 }
-// A ward's seed by the harbor's name for it: thirty-two bytes, the same
-// every time that name is asked.
+// The harbor's seed: thirty-two bytes, the same every time. It is the one
+// secret a terrain holds.
 export class Custody {
 }
-// Bytes to a ward pk in; bytes, or null for nothing, out.
+// Code, by the name a harbor keeps for it, or null where this loader has
+// none. Code never crosses a door and never lives in a cell, so it is the
+// 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. A harbor hands a
+// terrain's carrier what it holds no route for; what it routes goes to its
+// carrier faculties.
 export class Carrier {
 }

package/dist/edge/index.d.ts

@@ -0,0 +1,57 @@
+import { Custody, Memory, type Entropy, type Module } from '../contract/index.ts';
+import { Harbor, type GroundFaculty, type GroundProbe } from '../harbor/index.ts';
+import { type WebListen } from '../line/index.ts';
+import { PointerTerrain } from '../pointer/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_SECRET?: string;
+};
+export type EdgeGiven = {
+    readonly state: EdgeState;
+    readonly env: EdgeEnv;
+};
+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 declare class EdgeCustody extends Custody {
+    #private;
+    constructor(storage: EdgeStorage, secret: string | undefined, 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);
+    stand(harbor: Harbor): Promise<void>;
+    answer(request: Request): Promise<Response>;
+}
+export declare const edgeGround: GroundProbe;
+export type HarborObjectClass = new (state: EdgeState, env: EdgeEnv) => {
+    readonly harbor: Promise<Harbor>;
+    fetch(request: Request): Promise<Response>;
+};
+export declare const harborObject: (modules: readonly Module[], stood?: (harbor: Harbor) => Promise<void>) => HarborObjectClass;