nervur 0.20.1 → 0.20.2

package/dist/cli/harbor.d.ts

@@ -1,20 +1,18 @@
 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>;
+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>;
 };

package/dist/cli/harbor.js

@@ -1,141 +1,99 @@
-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, 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 { 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 { 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 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.
+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) => {
-    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);
-    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);
+    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,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;

package/dist/edge/index.js

@@ -0,0 +1,306 @@
+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;
+};
+import { Custody, Memory } from '../contract/index.js';
+import { decrypt, encrypt, hkdf, isHex, unhex, utf8 } from '../crypto/index.js';
+import { addGround, CarrierFaculty, Harbor, UNDIALED } from '../harbor/index.js';
+import { answerHeld, answerPost, askFrame, FrameReader, TCP, TCP_OPENING, WEB_OPENING, webFaculty, webPush } from '../line/index.js';
+import { CryptoEntropy, HeldLoader, PointerTerrain } from '../pointer/index.js';
+import { tcpAddress, tcpAt } from '../quo/index.js';
+import { ownerAsk } from '../ward/index.js';
+export const EDGE = 'edge';
+const ENTRY = 'm/';
+const SEED = 'c/seed';
+// The most keys one storage call takes.
+const BATCH = 128;
+const SEAL_INFO = utf8('nervur edge custody');
+const MAX_ID = 0xffff_ffff;
+const chunks = (items) => Array.from({ length: Math.ceil(items.length / BATCH) }, (_, i) => items.slice(i * BATCH, (i + 1) * BATCH));
+const bytesOf = (value) => new Uint8Array(value instanceof ArrayBuffer ? value : value);
+// A body keeps its keys under `root`, so one object may hold more than one
+// keeping.
+export class EdgeMemory extends Memory {
+    #storage;
+    #entry;
+    constructor(storage, root = '') {
+        super();
+        this.#storage = storage;
+        this.#entry = `${root}${ENTRY}`;
+    }
+    async read(place) {
+        const prefix = `${this.#entry}${place}/`;
+        const listed = await this.#storage.list({ prefix });
+        return new Map([...listed].map(([key, value]) => [key.slice(prefix.length), bytesOf(value).slice()]));
+    }
+    write(place, entries) {
+        const put = [];
+        const gone = [];
+        for (const [name, bytes] of entries) {
+            if (bytes === null)
+                gone.push(`${this.#entry}${place}/${name}`);
+            else
+                put.push([`${this.#entry}${place}/${name}`, bytes.slice()]);
+        }
+        return this.#storage.transaction(async (txn) => {
+            for (const batch of chunks(put))
+                await txn.put(Object.fromEntries(batch));
+            for (const batch of chunks(gone))
+                await txn.delete(batch);
+        });
+    }
+    async places() {
+        const entry = this.#entry;
+        const keys = [...(await this.#storage.list({ prefix: entry })).keys()];
+        return [...new Set(keys.map((key) => key.slice(entry.length, key.indexOf('/', entry.length))))];
+    }
+    async forget(place) {
+        const keys = [...(await this.#storage.list({ prefix: `${this.#entry}${place}/` })).keys()];
+        await this.#storage.transaction(async (txn) => {
+            for (const batch of chunks(keys))
+                await txn.delete(batch);
+        });
+    }
+}
+// The seed, drawn once and kept sealed under a key the secret gives, so
+// the storage alone opens nothing. A harbor with no secret does not stand.
+export class EdgeCustody extends Custody {
+    #storage;
+    #secret;
+    #entropy;
+    #key;
+    constructor(storage, secret, entropy = new CryptoEntropy(), root = '') {
+        super();
+        this.#storage = storage;
+        this.#secret = secret;
+        this.#entropy = entropy;
+        this.#key = `${root}${SEED}`;
+    }
+    async seed() {
+        if (!this.#secret)
+            throw new Error('the worker holds no NERVUR_SECRET');
+        const key = await hkdf(utf8(this.#secret), SEAL_INFO, 32);
+        return this.#storage.transaction(async (txn) => {
+            const kept = (await txn.get(this.#key));
+            if (kept) {
+                const seed = await decrypt(key, bytesOf(kept.nonce), new Uint8Array(0), bytesOf(kept.sealed));
+                if (seed === null)
+                    throw new Error('the seed does not open under this NERVUR_SECRET');
+                return seed;
+            }
+            const seed = this.#entropy.draw(32);
+            const nonce = this.#entropy.draw(12);
+            await txn.put({ [this.#key]: { nonce, sealed: await encrypt(key, nonce, new Uint8Array(0), seed) } });
+            return seed.slice();
+        });
+    }
+}
+class EdgeLine {
+    #socket;
+    #writer;
+    #waiting = new Map();
+    #next = 1;
+    #closed = false;
+    constructor(socket, onClose) {
+        this.#socket = socket;
+        this.#writer = socket.writable.getWriter();
+        const reader = new FrameReader();
+        void (async () => {
+            try {
+                for await (const chunk of socket.readable) {
+                    for (const frame of reader.push(new Uint8Array(chunk))) {
+                        if (frame.kind === 'ask')
+                            continue;
+                        const done = this.#waiting.get(frame.id);
+                        this.#waiting.delete(frame.id);
+                        done?.(frame.kind === 'reply' ? frame.box : null);
+                    }
+                    if (reader.bad)
+                        break;
+                }
+            }
+            catch {
+                // A line that broke answers nothing more.
+            }
+            this.#closed = true;
+            onClose();
+            for (const done of this.#waiting.values())
+                done(null);
+            this.#waiting.clear();
+            await socket.close().catch(() => undefined);
+        })();
+    }
+    ask(pk, box) {
+        if (this.#closed)
+            return Promise.resolve(null);
+        const id = this.#next;
+        this.#next = this.#next === MAX_ID ? 1 : this.#next + 1;
+        return new Promise((resolve) => {
+            this.#waiting.set(id, resolve);
+            this.#writer.write(askFrame(id, pk, box)).catch(() => resolve(null));
+        });
+    }
+    close() {
+        this.#closed = true;
+        return this.#socket.close().catch(() => undefined);
+    }
+}
+const sockets = 'cloudflare:sockets';
+const connector = async () => {
+    try {
+        return (await import(__rewriteRelativeImportExtension(/* @vite-ignore */ sockets))).connect;
+    }
+    catch {
+        return null;
+    }
+};
+// Quo over TCP from a worker: it dials, and takes no inbound TCP.
+export const edgeTcp = () => class EdgeTcp extends CarrierFaculty {
+    static kind = TCP;
+    static asks = {
+        listen: ownerAsk('an edge takes no inbound TCP'),
+        deaf: ownerAsk('listen nowhere'),
+    };
+    #lines = new Map();
+    accepts(address) {
+        return tcpAddress(address) !== null;
+    }
+    async dial(address, pk, bytes) {
+        const at = tcpAddress(address);
+        if (at === null || !isHex(pk, 64))
+            return UNDIALED;
+        const line = await this.#line(at);
+        return line ? line.ask(unhex(pk), bytes) : UNDIALED;
+    }
+    #line({ host, port }) {
+        const at = tcpAt(host, port);
+        let line = this.#lines.get(at);
+        if (!line) {
+            line = (async () => {
+                const connect = await connector();
+                if (!connect)
+                    return null;
+                try {
+                    const socket = connect({ hostname: host, port });
+                    await socket.opened;
+                    return new EdgeLine(socket, () => this.#lines.delete(at));
+                }
+                catch {
+                    return null;
+                }
+            })();
+            this.#lines.set(at, line);
+            void line.then((open) => open ?? this.#lines.delete(at));
+        }
+        return line;
+    }
+    async sleep() {
+        const lines = [...this.#lines.values()];
+        this.#lines.clear();
+        for (const line of await Promise.all(lines))
+            await line?.close();
+    }
+    listen() {
+        return { error: 'an edge takes no inbound TCP' };
+    }
+    deaf() {
+        return { deaf: true };
+    }
+};
+// Where the edge's web carrier listens: the object's own requests, at the
+// host and path its cells name. A port of 0 is the edge's own https.
+const edgeServe = (ground, listen) => {
+    const terrain = ground.terrain;
+    if (!(terrain instanceof EdgeTerrain))
+        return Promise.reject(new Error('this harbor stands on no edge'));
+    terrain.listening = listen;
+    const authority = listen.port === 0 ? listen.host : `${tcpAt(listen.host, listen.port).slice('tcp://'.length)}`;
+    const [post, held] = listen.port === 0 ? ['https', 'wss'] : ['http', 'ws'];
+    return Promise.resolve({
+        port: listen.port,
+        at: [`${post}://${authority}${listen.path}`, `${held}://${authority}${listen.path}`],
+        close: () => {
+            if (terrain.listening === listen)
+                terrain.listening = undefined;
+            return Promise.resolve();
+        },
+    });
+};
+export class EdgeTerrain extends PointerTerrain {
+    given;
+    // Where the web carrier listens now, as the object answers requests.
+    listening;
+    #harbor;
+    constructor(parts) {
+        const entropy = new CryptoEntropy();
+        const { storage } = parts.given.state;
+        super({
+            entropy,
+            loader: new HeldLoader(parts.modules ?? []),
+            custody: new EdgeCustody(storage, parts.given.env.NERVUR_SECRET, entropy),
+            memory: new EdgeMemory(storage),
+            faculties: [edgeTcp, webFaculty(edgeServe), webPush],
+            opens: [TCP_OPENING, WEB_OPENING],
+        });
+        this.given = parts.given;
+    }
+    stand(harbor) {
+        this.#harbor = harbor;
+        return Promise.resolve();
+    }
+    // One request to the object: a post, or a held line opened, where the
+    // web carrier listens.
+    answer(request) {
+        const listen = this.listening;
+        const harbor = this.#harbor;
+        if (!listen || !harbor)
+            return Promise.resolve(new Response(null, { status: 404 }));
+        if (request.headers.get('upgrade')?.toLowerCase() !== 'websocket')
+            return answerPost(harbor, listen, request);
+        const offered = (request.headers.get('sec-websocket-protocol') ?? '').split(',').map((p) => p.trim());
+        if (new URL(request.url).pathname !== listen.path || !offered.includes('quo'))
+            return Promise.resolve(new Response(null, { status: 400 }));
+        const Pair = globalThis.WebSocketPair;
+        const pair = new Pair();
+        const [client, server] = [pair[0], pair[1]];
+        server.accept();
+        const side = { send: (body) => server.send(new Uint8Array(body)), close: () => server.close() };
+        server.addEventListener('message', (event) => answerHeld(harbor, side, typeof event.data === 'string' ? event.data : new Uint8Array(event.data)));
+        return Promise.resolve(new Response(null, { status: 101, webSocket: client, headers: { 'sec-websocket-protocol': 'quo' } }));
+    }
+}
+const isGiven = (value) => {
+    const given = value;
+    return typeof given?.state?.storage?.transaction === 'function' && typeof given.env === 'object';
+};
+// A harbor handed a Durable Object's state and environment.
+export const edgeGround = {
+    name: EDGE,
+    fits: ({ given }) => isGiven(given),
+    terrain: ({ given, modules }) => new EdgeTerrain({ given: given, ...(modules ? { modules } : {}) }),
+};
+export const harborObject = (modules, stood) => class HarborObject {
+    #opening;
+    // The object's harbor, once it stands.
+    get harbor() {
+        return this.#opening;
+    }
+    constructor(state, env) {
+        addGround(edgeGround);
+        // Opened inside the object's block, so no request reaches it half
+        // open and its storage answers the opening.
+        this.#opening = state.blockConcurrencyWhile(async () => {
+            const harbor = await Harbor.open({ modules, given: { state, env } });
+            await stood?.(harbor);
+            return harbor;
+        });
+    }
+    async fetch(request) {
+        const harbor = await this.#opening;
+        return harbor.terrain.answer(request);
+    }
+};

package/dist/edge.d.ts

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

package/dist/edge.js

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: Apache-2.0
+// `nervur` as a Workers bundle reads it: the main entry, with the edge
+// ground added, so `Harbor.open({ given: { state, env } })` in a Durable
+// Object keeps a harbor in its storage.
+import { edgeGround } from './edge/index.js';
+import { addGround } from './harbor/index.js';
+export * from './index.js';
+addGround(edgeGround);