nervur 0.21.4 → 0.22.0

package/dist/line/web.d.ts

@@ -1,30 +0,0 @@
-import { type Dialed, type Ground, type GroundFaculty } from '../harbor/index.ts';
-export declare const MIN_POST = 65;
-export declare const MAX_POST: number;
-export declare class WebDialer {
-    #private;
-    dial(at: string, pk: string, bytes: Uint8Array): Promise<Dialed>;
-    close(): Promise<void>;
-}
-export type WebListen = {
-    host: string;
-    port: number;
-    path: string;
-    origins: string[];
-};
-export interface WebListener {
-    readonly at: string[];
-    readonly port: number;
-    close(): Promise<void>;
-}
-export type WebServe = (ground: Ground, listen: WebListen) => Promise<WebListener>;
-export declare const WEB = "org.nervur.web";
-export declare const WEB_OPENING: {
-    readonly key: 'web';
-    readonly kind: "org.nervur.web";
-};
-export declare const webFaculty: (serve?: WebServe) => GroundFaculty;
-export declare const readPost: (body: Uint8Array) => {
-    pk: string;
-    box: Uint8Array;
-} | null;

package/dist/node/index.js

@@ -1,236 +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;
-};
-// SPDX-License-Identifier: Apache-2.0
-// `nervur/node`: the Node ground. A harbor keeps its seed and sealed
-// memory in a folder, finds its code among the modules it is handed and
-// then in files, speaks TCP from genesis and the web and Web Push where
-// the root opens them, and serves the root line on a local socket, so the
-// `nervur` command reaches it while it stands.
-//
-//   <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
-//
-// One run holds a folder: a terrain refuses a folder another run serves.
-import { createHash } from 'node:crypto';
-import { chmod, mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
-import { createRequire } from 'node:module';
-import { connect, createServer } from 'node:net';
-import { homedir, tmpdir } from 'node:os';
-import { dirname, join, resolve } from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { Loader } from '../contract/index.js';
-import { FolderCustody, FolderMemory } from '../folder/index.js';
-import { rootLine } from '../harbor/index.js';
-import { webGround } from '../http/index.js';
-import { webPush } from '../line/index.js';
-import { CryptoEntropy, HeldLoader, PointerTerrain } from '../pointer/index.js';
-import { TCP_OPENING, tcpFaculty } from '../tcp/index.js';
-export const NODE = 'node';
-// Where a harbor of this user lives unless named: $NERVUR_DIR, then
-// ~/.nervur.
-export const harborDir = (env = process.env) => env.NERVUR_DIR ?? join(homedir(), '.nervur');
-// 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`);
-};
-// A specifier that names a file rather than a package.
-export const isFile = (from) => /^(\.{1,2}[\\/]|[\\/]|[A-Za-z]:[\\/])/.test(from) || /\.(m?[jt]s|c[jt]s)$/.test(from);
-// Code from a file or an installed package: a module that exports
-// `module`, `version` and `classes`, found again by where it was found, a
-// file by its absolute path and a package by its name, resolved from each
-// folder of `bases` in order. What is not there, or exports no module, is
-// none. Code that is there and does not import throws Node's reason, so
-// whoever added it learns why; an ES module read as CommonJS says which
-// field its package.json lacks.
-export class ImportLoader extends Loader {
-    #bases;
-    constructor(bases = [process.cwd()]) {
-        super();
-        this.#bases = bases;
-    }
-    async load(from) {
-        const found = isFile(from) ? resolve(from) : this.#package(from);
-        if (found === null)
-            return null;
-        let exported;
-        try {
-            exported = (await import(__rewriteRelativeImportExtension(pathToFileURL(found).href)));
-        }
-        catch (e) {
-            const said = e.message;
-            // The name itself is nowhere, as against code there that needs
-            // something that is not.
-            if (e.code === 'ERR_MODULE_NOT_FOUND' && said.includes(`'${found}'`))
-                return null;
-            const commonjs = e instanceof SyntaxError && /\b(export|import)\b/.test(said);
-            throw new Error(`${found} did not load: ${said}${commonjs ? '; it is an ES module read as CommonJS, so set "type": "module" in its package.json' : ''}`, { cause: e });
-        }
-        const { module, version, classes } = exported;
-        if (typeof module !== 'string' || typeof version !== 'string' || !Array.isArray(classes))
-            return null;
-        return { module, version, classes, from: isFile(from) ? found : from };
-    }
-    #package(name) {
-        for (const base of this.#bases) {
-            try {
-                return createRequire(join(resolve(base), 'noop.js')).resolve(name);
-            }
-            catch {
-                // Not installed from here; the next base may hold it.
-            }
-        }
-        return null;
-    }
-}
-// A module by its id, the name it declares, so the catalogue's cells name
-// code the same way on every ground. `add` may name a module by its id, a
-// file, or an installed package, and the ground works out which. The
-// modules a harbor is handed are found by their id first. Where else an id
-// is found, a file's path or a package's name, is this ground's own
-// knowledge, kept beside the harbor in `<dir>/modules.json` and never in
-// the sealed package, since another ground finds the same id in its own
-// bundle. Packages resolve from where the command runs, then from the
-// harbor's folder.
-export class NodeLoader extends ImportLoader {
-    #held;
-    #map;
-    constructor(modules = [], dir) {
-        super(dir === undefined ? [process.cwd()] : [process.cwd(), dir]);
-        this.#held = new HeldLoader(modules);
-        this.#map = dir === undefined ? undefined : join(dir, MODULES);
-    }
-    async load(from) {
-        const held = await this.#held.load(from);
-        if (held)
-            return held;
-        const known = await this.#known();
-        const where = known[from];
-        if (where !== undefined) {
-            const loaded = await super.load(where);
-            return loaded?.module === from ? { ...loaded, from } : null;
-        }
-        const loaded = await super.load(from);
-        if (!loaded)
-            return null;
-        if (this.#map && known[loaded.module] !== loaded.from)
-            await this.#keep({ ...known, [loaded.module]: loaded.from });
-        return { ...loaded, from: loaded.module };
-    }
-    async #known() {
-        if (!this.#map)
-            return {};
-        try {
-            return JSON.parse(await readFile(this.#map, 'utf8'));
-        }
-        catch {
-            return {};
-        }
-    }
-    async #keep(files) {
-        await mkdir(dirname(this.#map), { recursive: true, mode: 0o700 });
-        await writeFile(`${this.#map}.new`, `${JSON.stringify(files, null, 2)}\n`, { mode: 0o600 });
-        await rename(`${this.#map}.new`, this.#map);
-    }
-}
-// Where a Node harbor's module ids find their files.
-export const MODULES = 'modules.json';
-// One root request over a served harbor's socket, or undefined where none
-// is served.
-export const askServed = (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)));
-});
-export class NodeTerrain extends PointerTerrain {
-    dir;
-    serves;
-    #server;
-    constructor(parts) {
-        const entropy = new CryptoEntropy();
-        super({
-            entropy,
-            loader: new NodeLoader(parts.modules, parts.dir),
-            custody: new FolderCustody(parts.dir, entropy),
-            memory: new FolderMemory(parts.dir),
-            faculties: [tcpFaculty, webGround, webPush],
-            opens: [TCP_OPENING],
-            wakes: parts.wakes ?? true,
-        });
-        this.dir = parts.dir;
-        this.serves = parts.serves ?? true;
-    }
-    async claim() {
-        if ((await askServed(this.dir, {})) !== undefined)
-            throw new Error(`a harbor is already served from ${this.dir}`);
-    }
-    // The root line on the socket. A socket file nobody answers on is a
-    // stale one, and is replaced.
-    async stand(harbor) {
-        if (!this.serves)
-            return;
-        const root = socketOf(this.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);
-        this.#server = server;
-    }
-    async release() {
-        const server = this.#server;
-        if (!server)
-            return;
-        this.#server = undefined;
-        await new Promise((done) => server.close(done));
-        await rm(socketOf(this.dir), { force: true });
-    }
-}
-// Node, and the engines that answer as Node does.
-export const nodeGround = {
-    name: NODE,
-    fits: () => typeof process !== 'undefined' && typeof process.versions?.node === 'string',
-    terrain: ({ modules, where }) => new NodeTerrain({ dir: where ?? harborDir(), ...(modules ? { modules } : {}) }),
-};

package/dist/pointer/bodies.js

@@ -1,80 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// The pointer terrain's bodies: each contract fulfilled in one process,
-// with nothing beyond JavaScript.
-import { Clock, Custody, Entropy, Loader, Memory } from '../contract/index.js';
-export class CryptoEntropy extends Entropy {
-    draw(length) {
-        return globalThis.crypto.getRandomValues(new Uint8Array(length));
-    }
-}
-export class SystemClock extends Clock {
-    now() {
-        return Date.now();
-    }
-    wait(ms) {
-        let timer;
-        const done = new Promise((resolve) => (timer = setTimeout(resolve, ms)));
-        return { done, cancel: () => clearTimeout(timer) };
-    }
-}
-// The harbor's seed, drawn once and held by this object.
-export class HeldCustody extends Custody {
-    #seed;
-    constructor(entropy) {
-        super();
-        this.#seed = entropy.draw(32);
-    }
-    seed() {
-        return Promise.resolve(this.#seed.slice());
-    }
-}
-// Modules handed to this object, found by the name each declares: the
-// bundle a ground with no disk to load from carries, an edge's or a
-// browser's. A path, a package or any other name is no module of it.
-export class HeldLoader extends Loader {
-    #modules = new Map();
-    constructor(modules = []) {
-        super();
-        for (const m of modules)
-            this.#modules.set(m.module, m);
-    }
-    load(from) {
-        const m = this.#modules.get(from);
-        return Promise.resolve(m ? { module: m.module, version: m.version, classes: m.classes, from } : null);
-    }
-    missing(from) {
-        const carried = [...this.#modules.keys()];
-        return `${from} is no module this bundle carries${carried.length === 0 ? ', and it carries none' : `: it carries ${carried.join(', ')}`}`;
-    }
-}
-// Entries that live as long as this object, copied in and out, which is
-// what a restart in one process finds.
-export class VolatileMemory extends Memory {
-    #places = new Map();
-    read(place) {
-        const entries = this.#places.get(place) ?? new Map();
-        return Promise.resolve(new Map([...entries].map(([name, bytes]) => [name, bytes.slice()])));
-    }
-    // One object holds it, so a keep is whole by the run of one turn.
-    write(place, entries) {
-        let kept = this.#places.get(place);
-        if (!kept)
-            this.#places.set(place, (kept = new Map()));
-        for (const [name, bytes] of entries) {
-            if (bytes === null)
-                kept.delete(name);
-            else
-                kept.set(name, bytes.slice());
-        }
-        if (kept.size === 0)
-            this.#places.delete(place);
-        return Promise.resolve();
-    }
-    places() {
-        return Promise.resolve([...this.#places.keys()]);
-    }
-    forget(place) {
-        this.#places.delete(place);
-        return Promise.resolve();
-    }
-}

package/dist/pointer/index.d.ts

@@ -1,2 +0,0 @@
-export { CryptoEntropy, HeldCustody, HeldLoader, SystemClock, VolatileMemory } from './bodies.ts';
-export { NoCarrier, PointerCarrier, PointerTerrain, World, type PointerParts } from './world.ts';

package/dist/proof/index.d.ts

@@ -1,3 +0,0 @@
-export { entropyScenes, custodyScenes, loaderScenes, memoryScenes, type Cut, type Scene } from './contracts.ts';
-export { expect, type Expect } from './expect.ts';
-export { keeperScenes, law, lawScenes, type Bodies, type Terrain } from './law.ts';

package/dist/proof/law.d.ts

@@ -1,90 +0,0 @@
-import { Being, Faculty, type Asker, type JsonObject } from '../being/index.ts';
-import { Memory, type Custody, type Module } from '../contract/index.ts';
-import { Store, type Harbor } from '../harbor/index.ts';
-import { World } from '../pointer/index.ts';
-import type { Expect } from './expect.ts';
-export type Bodies = {
-    custody: Custody;
-    memory: Memory;
-};
-export type Terrain = {
-    name: string;
-    make(): Bodies;
-    again(bodies: Bodies): Bodies;
-};
-declare abstract class Echoes extends Faculty {
-    static kind: string;
-}
-declare class Echo extends Echoes {
-    static kind: string;
-    static asks: {
-        echo: {};
-    };
-    echo(args: JsonObject, asker: Asker): JsonObject;
-}
-declare class Shop extends Being {
-    static kind: string;
-    static cells: {
-        sold: string[];
-    };
-    static asks: {
-        buy: {};
-    };
-    buy(args: JsonObject, asker: Asker): JsonObject;
-}
-declare class Customer extends Being {
-    static kind: string;
-    static asks: {
-        join: {};
-        buy: {};
-        echo: {};
-        spoil: {};
-    };
-    spoil(): JsonObject;
-    join(args: JsonObject): Promise<JsonObject>;
-    buy(args: JsonObject): Promise<JsonObject>;
-    echo(args: JsonObject): Promise<JsonObject>;
-}
-declare class Profile extends Being {
-    static kind: string;
-    static cells: {
-        name: string;
-        age: number;
-    };
-    static asks: {
-        set: {};
-        get: {};
-    };
-    set(args: JsonObject): JsonObject;
-    get(): JsonObject;
-}
-declare class Shelf extends Store {
-    #private;
-    static kind: string;
-    static shelf(key: string): Watched;
-    static reset(): void;
-    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 const classes: (typeof Echo | typeof Shop | typeof Customer | typeof Profile | typeof Shelf)[];
-export declare const law: Module;
-export declare const standOne: (world: World, name: string, parts?: Partial<Bodies>) => Promise<Harbor>;
-declare class Watched extends Memory {
-    readonly inner: Memory;
-    readonly seen: {
-        place: string;
-        name: string;
-        bytes: Uint8Array | null;
-    }[];
-    refuse: (place: string) => boolean;
-    constructor(inner: Memory);
-    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 const lawScenes: (t: Terrain, expect: Expect) => [string, () => Promise<void>][];
-export declare const keeperScenes: (t: Terrain, expect: Expect) => [string, () => Promise<void>][];
-export {};