nervur 0.21.4 → 0.22.0

package/dist/cli/main.js

@@ -1,14 +0,0 @@
-#!/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/crypto/subtle.d.ts

@@ -1,10 +0,0 @@
-export declare const subtle: () => SubtleCrypto;
-export type Bytes = Uint8Array<ArrayBuffer>;
-export declare const own: (bytes: Uint8Array) => Bytes;
-declare const PKCS8: {
-    readonly Ed25519: '302e020100300506032b657004220420';
-    readonly X25519: '302e020100300506032b656e04220420';
-};
-export declare const importSecret: (curve: keyof typeof PKCS8, secret: Uint8Array, uses: KeyUsage[]) => Promise<CryptoKey>;
-export declare const publicOf: (key: CryptoKey) => Promise<Uint8Array>;
-export {};

package/dist/crypto/subtle.js

@@ -1,29 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// Web Crypto, read at every use. A page on a plain http origin has `crypto`
-// without `subtle`, and a terrain may install it after this module loads.
-export const subtle = () => {
-    const found = globalThis.crypto?.subtle;
-    if (!found)
-        throw new Error('this terrain has no crypto.subtle: a ward needs a secure context');
-    return found;
-};
-// Web Crypto takes a buffer it owns, so every input is copied into one.
-export const own = (bytes) => Uint8Array.from(bytes);
-// The PKCS#8 wrapping of a thirty-two byte secret, which is the whole of it
-// for both curves.
-const PKCS8 = { Ed25519: '302e020100300506032b657004220420', X25519: '302e020100300506032b656e04220420' };
-export const importSecret = (curve, secret, uses) => {
-    if (secret.length !== 32)
-        throw new TypeError('a secret is thirty-two bytes');
-    const prefix = Uint8Array.from(PKCS8[curve].match(/../g), (b) => parseInt(b, 16));
-    const wrapped = new Uint8Array(48);
-    wrapped.set(prefix);
-    wrapped.set(secret, 16);
-    return subtle().importKey('pkcs8', wrapped, { name: curve }, true, uses);
-};
-// Web Crypto gives a private key's public half only through a JWK.
-export const publicOf = async (key) => {
-    const { x } = await subtle().exportKey('jwk', key);
-    const binary = atob(x.replaceAll('-', '+').replaceAll('_', '/'));
-    return Uint8Array.from(binary, (c) => c.charCodeAt(0));
-};

package/dist/crypto/x25519.js

@@ -1,21 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// X25519 agrees. A secret is thirty-two bytes, clamped by the function and
-// never before.
-import { zero } from './bytes.js';
-import { importSecret, own, publicOf, subtle } from './subtle.js';
-export const x25519Public = async (secret) => publicOf(await importSecret('X25519', secret, ['deriveBits']));
-// The agreement, or null for a public key that takes no seal: one whose
-// agreement is thirty-two zero bytes, or one the terrain refuses to read.
-export const agree = async (secret, pk) => {
-    if (pk.length !== 32)
-        return null;
-    try {
-        const mine = await importSecret('X25519', secret, ['deriveBits']);
-        const theirs = await subtle().importKey('raw', own(pk), { name: 'X25519' }, false, []);
-        const shared = new Uint8Array(await subtle().deriveBits({ name: 'X25519', public: theirs }, mine, 256));
-        return zero(shared) ? null : shared;
-    }
-    catch {
-        return null;
-    }
-};

package/dist/edge/index.d.ts

@@ -1,81 +0,0 @@
-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_SECRET?: string;
-};
-export type EdgeGiven = {
-    readonly state: EdgeState;
-    readonly env: EdgeEnv;
-    readonly package?: Packed;
-};
-export type Packed = {
-    readonly sealed: string;
-    readonly places: Carried['places'];
-};
-export type Pack = Record<string, Packed>;
-export declare const isHarborName: (name: unknown) => name is string;
-export declare const readPack: (value: unknown) => Pack | null;
-export declare const sealSeed: (secret: string, seed: Uint8Array, entropy?: Entropy) => Promise<string>;
-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);
-    kept(): Promise<boolean>;
-    land(sealed: string, txn?: EdgeStorage): Promise<void>;
-    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 declare const harborNameOf: (request: Request) => string | null;
-export type HarborObjectParts = {
-    readonly modules: readonly Module[];
-    readonly pack?: Pack | ((env: EdgeEnv) => Pack | undefined);
-    readonly born?: (name: string) => boolean;
-    readonly stood?: (harbor: Harbor, name: string) => Promise<void>;
-};
-export type HarborObject = {
-    harborFor(request: Request): Promise<Harbor | null>;
-    fetch(request: Request): Promise<Response>;
-};
-export type HarborObjectClass = new (state: EdgeState, env: EdgeEnv) => HarborObject;
-export declare const harborObject: ({ modules, pack, born, stood }: HarborObjectParts) => HarborObjectClass;
-export declare const harborWorker: (binding?: string) => {
-    fetch(request: Request, env: Record<string, unknown>): Promise<Response>;
-};

package/dist/edge/index.js

@@ -1,400 +0,0 @@
-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 { concat, decrypt, encrypt, hex, hkdf, isHex, unhex, utf8 } from '../crypto/index.js';
-import { addGround, CarrierFaculty, Harbor, landPlaces, readCarried, 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;
-// A harbor's name on the edge: one path segment, so it is where the
-// harbor answers, `/<name>/quo`.
-export const isHarborName = (name) => typeof name === 'string' && /^[a-z0-9][a-z0-9-]{0,62}$/.test(name);
-const NONCE = 12;
-// A pack as JSON reads, or null for anything else.
-export const readPack = (value) => {
-    if (typeof value !== 'object' || value === null || Array.isArray(value))
-        return null;
-    const pack = {};
-    for (const [name, entry] of Object.entries(value)) {
-        const { sealed, places } = (entry ?? {});
-        const carried = readCarried({ places });
-        if (!isHarborName(name) || !isHex(sealed) || sealed.length <= NONCE * 2 || carried === null)
-            return null;
-        pack[name] = { sealed: sealed, places: carried.places };
-    }
-    return pack;
-};
-const sealKey = (secret) => hkdf(utf8(secret), SEAL_INFO, 32);
-// A seed sealed under a worker's secret, as a pack keeps it.
-export const sealSeed = async (secret, seed, entropy = new CryptoEntropy()) => {
-    const nonce = entropy.draw(NONCE);
-    return hex(concat(nonce, await encrypt(await sealKey(secret), nonce, new Uint8Array(0), seed)));
-};
-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, kept sealed under a key the worker's secret gives, so the
-// storage alone opens nothing: the one a pack landed, or one drawn the
-// first time it is asked for. A worker with no secret stands no harbor.
-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}`;
-    }
-    // Whether a seed is kept, so a pack lands only where none is.
-    async kept() {
-        return (await this.#storage.get(this.#key)) !== undefined;
-    }
-    // A packed seed, sealed as `sealSeed` sealed it, kept as it came.
-    async land(sealed, txn = this.#storage) {
-        const bytes = unhex(sealed);
-        await txn.put({ [this.#key]: { nonce: bytes.slice(0, NONCE), sealed: bytes.slice(NONCE) } });
-    }
-    async seed() {
-        if (!this.#secret)
-            throw new Error('the worker holds no NERVUR_SECRET');
-        const key = await sealKey(this.#secret);
-        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(NONCE);
-            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;
-    }
-    // A packed harbor lands where the object keeps no seed yet: its places
-    // first and its seed last, so a start cut short lands it whole again,
-    // and once the seed is kept the storage is the harbor and a new deploy
-    // leaves it be. A seed sealed under another secret does not open.
-    async claim() {
-        const packed = this.given.package;
-        const custody = this.custody;
-        if (!packed || (await custody.kept()))
-            return;
-        await landPlaces(this.memory, { places: packed.places });
-        await custody.land(packed.sealed);
-    }
-    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 } : {}) }),
-};
-// The harbor a request is for: the first segment of its path.
-export const harborNameOf = (request) => {
-    const name = new URL(request.url).pathname.split('/')[1];
-    return isHarborName(name) ? name : null;
-};
-// A Durable Object class whose every instance is one harbor, by the name
-// the worker reached it under: opened at its first request, the one its
-// pack holds under that name or one `born` allows, its web carrier opened,
-// and every request it receives answered by that carrier at
-// `/<name>/quo`. An object answers the one name it opened under, and a
-// name it may not open is 404, with nothing written.
-export const harborObject = ({ modules, pack, born, stood }) => class {
-    #state;
-    #env;
-    #name;
-    #opening;
-    constructor(state, env) {
-        addGround(edgeGround);
-        this.#state = state;
-        this.#env = env;
-    }
-    // The harbor a request names, opened once, or null where it names
-    // another harbor or none.
-    harborFor(request) {
-        const name = harborNameOf(request);
-        if (name === null || (this.#name !== undefined && this.#name !== name))
-            return Promise.resolve(null);
-        const packed = typeof pack === 'function' ? pack(this.#env) : pack;
-        const held = packed && Object.hasOwn(packed, name) ? packed[name] : undefined;
-        if (this.#name === undefined && !held && !born?.(name))
-            return Promise.resolve(null);
-        this.#name = name;
-        // Opened inside the object's block, so no request reaches it half
-        // open and its storage answers the opening.
-        this.#opening ??= this.#state.blockConcurrencyWhile(async () => {
-            const given = { state: this.#state, env: this.#env, ...(held ? { package: held } : {}) };
-            const harbor = await Harbor.open({ modules, given });
-            if (!harbor.box.being(WEB_OPENING.key))
-                await harbor.root('open', { key: WEB_OPENING.key, class: WEB_OPENING.kind });
-            await stood?.(harbor, name);
-            return harbor;
-        });
-        return this.#opening;
-    }
-    async fetch(request) {
-        const harbor = await this.harborFor(request);
-        if (!harbor)
-            return new Response(null, { status: 404 });
-        const terrain = harbor.terrain;
-        const path = `/${this.#name}/quo`;
-        if (terrain.listening?.path !== path) {
-            const url = new URL(request.url);
-            await harbor.root('ask', { being: WEB_OPENING.key, method: 'listen', args: { host: url.hostname, port: url.port === '' ? 0 : Number(url.port), path } });
-        }
-        return terrain.answer(request);
-    }
-};
-// A worker of many harbors: each request goes to the object of the
-// harbor its path names, in the Durable Object namespace bound as
-// `binding`, and a path naming none is 404.
-export const harborWorker = (binding = 'HARBOR') => ({
-    fetch(request, env) {
-        const name = harborNameOf(request);
-        const objects = env[binding];
-        if (name === null || !objects)
-            return Promise.resolve(new Response(null, { status: 404 }));
-        return objects.get(objects.idFromName(name)).fetch(request);
-    },
-});

package/dist/harbor/carrying.d.ts

@@ -1,17 +0,0 @@
-import { Faculty, type BeingClass } from '../being/index.ts';
-export interface Ground {
-    arrive(pk: string, bytes: Uint8Array): Promise<Uint8Array | null>;
-}
-export type GroundFaculty = (ground: Ground) => BeingClass;
-export declare const UNDIALED: unique symbol;
-export type Dialed = Uint8Array | null | typeof UNDIALED;
-export declare abstract class CarrierFaculty extends Faculty {
-    static readonly kind: string;
-    abstract accepts(address: string): boolean;
-    abstract dial(address: string, pk: string, bytes: Uint8Array): Promise<Dialed>;
-    listening(): string[];
-    relays(_pk: string): boolean;
-    relay(_pk: string, _bytes: Uint8Array): Promise<Uint8Array | null>;
-    awake(): Promise<void>;
-    sleep(): Promise<void>;
-}

package/dist/harbor/carrying.js

@@ -1,38 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// A carrier is a faculty. It speaks the schemes of the addresses it dials,
-// dials an address when the harbor carries a box there, and listens where
-// its cells say, handing each box it hears to the harbor. The harbor keeps
-// every route and walks it in order, handing each address to the carrier
-// that speaks its scheme.
-//
-// A ground ships its carriers as classes the terrain names, each made for
-// one harbor, so the class holds the harbor it hands boxes to. They are
-// the kit's, of kinds under `org.nervur.`, and the dock opens them as
-// faculties, at genesis where the terrain says, and on the root's `open`.
-import { Faculty } from '../being/index.js';
-// Beside a reply and nothing, a dial answers `undialed` when the address
-// could not be reached at all, so the harbor tries the next one. A box a
-// line took may have been heard, so after it no other address is tried.
-export const UNDIALED = Symbol('undialed');
-export class CarrierFaculty extends Faculty {
-    static kind = 'org.nervur.carrier';
-    // The addresses it listens at now.
-    listening() {
-        return [];
-    }
-    // Whether it answers for a ward pk no door of this harbor holds, as a
-    // relay does, and its answer.
-    relays(_pk) {
-        return false;
-    }
-    relay(_pk, _bytes) {
-        return Promise.resolve(null);
-    }
-    // Once the harbor has unpacked, and once before it closes.
-    awake() {
-        return Promise.resolve();
-    }
-    sleep() {
-        return Promise.resolve();
-    }
-}

package/dist/harbor/catalogue.d.ts

@@ -1,28 +0,0 @@
-import { Faculty, type AskSpec, type BeingClass, type JsonObject, type Stance } from '../being/index.ts';
-import type { Loaded } from '../contract/index.ts';
-export declare const CATALOGUE = "catalogue";
-export type ModuleRow = {
-    version: string;
-    from: string;
-    kinds: string[];
-};
-export interface Cataloguing {
-    load(from: string): Promise<Loaded | null>;
-    missing(from: string): string | null;
-    check(modules: readonly Loaded[]): string | null;
-    run(modules: readonly Loaded[]): string | null;
-    stands(kinds: readonly string[]): boolean;
-    kindsOf(module: string): string[];
-}
-export declare class Catalogue extends Faculty {
-    #private;
-    static readonly kind: string;
-    static cells: JsonObject;
-    static asks: Record<string, AskSpec>;
-    constructor(stance: Stance, harbor: Cataloguing);
-    wake(): Promise<void>;
-    add(args: JsonObject): Promise<JsonObject>;
-    remove(args: JsonObject): JsonObject;
-    modules(): JsonObject;
-}
-export declare const catalogueFor: (harbor: Cataloguing) => BeingClass;