nervur 0.23.0 → 0.24.0

package/dist/bench/fake-network.js

@@ -1,222 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// A network in the process. Grounds join it under a host, names point at
-// hosts as DNS points them, and every box between hosts crosses it. A test
-// makes it slow, drops, loses and repeats boxes on it, cuts it one way or
-// both, turns a host off and points a name elsewhere, as the world does.
-// It keeps the one clock every ground on it reads, which the test alone
-// moves, and its chance is drawn from a seed, so a run goes the same way
-// twice.
-import { vouchesOf } from '../index.js';
-import { FakeClock } from './fake-clock.js';
-import { stream } from './seeded.js';
-import { settle } from './settle.js';
-const SCHEME = 'bench://';
-const LATE = Symbol('late');
-const pair = (a, b) => [a, b].sort().join('\n');
-// Each network's clock, which the grounds on it and the bench read, and no entry exports.
-const clocks = new WeakMap();
-/** The clock of a network, as a BenchGround reads it. */
-export const clockOf = (network) => clocks.get(network);
-export class FakeNetwork {
-    #hosts = new Map();
-    #names = new Map();
-    // One-way cuts, `from` then `to`.
-    #cuts = new Set();
-    #links = new Map();
-    #clock;
-    #chance;
-    #drop = 0;
-    #lose = 0;
-    #twice = 0;
-    #waits = 0;
-    /** Every box that crossed between two hosts, in order. A box by pointer inside a host crosses nothing. */
-    crossings = [];
-    /** `seed` draws every chance; `start` is the time its clock starts at. */
-    constructor({ seed = 'network', start } = {}) {
-        this.#clock = new FakeClock(start);
-        clocks.set(this, this.#clock);
-        this.#chance = stream(`network:${seed}`);
-    }
-    /** The time on its clock, which every ground on it reads. */
-    now() {
-        return this.#clock.now();
-    }
-    /** Every ask, effect and reply the grounds started, run to where it waits on the clock or ends. */
-    settle() {
-        return settle();
-    }
-    /** The clock moved on by `ms` at once, every wait it passes fired, and what came due run. */
-    async advance(ms) {
-        this.#clock.advance(ms);
-        await settle();
-    }
-    /** A host's carry. One that listens is dialled at its names; one that does not only dials, as a device. */
-    join(host, { names = [], listens = true, serve } = {}) {
-        const held = this.#hosts.get(host) ?? { doors: new Map(), listens, up: true };
-        if (serve !== undefined)
-            held.serve = serve;
-        this.#hosts.set(host, held);
-        for (const name of names)
-            this.#names.set(name, host);
-        return {
-            listen: ({ ward, door }) => void held.doors.set(ward, door),
-            unlisten: ({ ward }) => void held.doors.delete(ward),
-            send: (options) => this.#send(host, options),
-            at: () => (held.listens ? [...this.#names].filter(([, to]) => to === host).map(([name]) => SCHEME + name) : []),
-            // Each name its addresses write is a domain, read at the listener of the host it points at.
-            vouched: ({ ward, at }) => vouchesOf({ fetcher: (url) => this.#get(host, url), ward, at, schemes: ['bench'] }),
-        };
-    }
-    // A GET over the web from one host to the host a name points at, which a cut or a host off stops.
-    async #get(from, url) {
-        const to = this.#names.get(new URL(url).hostname);
-        const held = to === undefined ? undefined : this.#hosts.get(to);
-        if (to === undefined || held?.serve === undefined || !held.up || this.#cuts.has(`${from}\n${to}`))
-            throw new TypeError('fetch failed');
-        return held.serve(new Request(url));
-    }
-    /** A name pointed at a host, as a DNS record moved. */
-    point(name, host) {
-        this.#names.set(name, host);
-    }
-    /** How the link between two hosts behaves, both ways, until it is set again. */
-    link(a, b, link) {
-        for (const share of [link.drop, link.lose, link.duplicate])
-            if (share !== undefined && !(share >= 0 && share <= 1))
-                throw new TypeError('a share is between 0 and 1');
-        this.#links.set(pair(a, b), link);
-    }
-    /** No box crosses from `from` to `to` until `heal`; the other way stands. */
-    cut(from, to) {
-        this.#cuts.add(`${from}\n${to}`);
-    }
-    /** No box crosses between the two hosts, either way, until `heal`. */
-    partition(a, b) {
-        this.cut(a, b);
-        this.cut(b, a);
-    }
-    /** Every cut mended. Links keep how they behave. */
-    heal() {
-        this.#cuts.clear();
-    }
-    /** The host answers nothing, its doors forgotten, until `up`. */
-    down(host) {
-        const held = this.#hosts.get(host);
-        if (held === undefined)
-            return;
-        held.up = false;
-        held.doors.clear();
-    }
-    up(host) {
-        const held = this.#hosts.get(host);
-        if (held !== undefined)
-            held.up = true;
-    }
-    /** The next `count` boxes between hosts are dropped before their door. */
-    dropNext(count = 1) {
-        this.#drop += count;
-    }
-    /** The next `count` replies are lost after the far door answered. */
-    loseNext(count = 1) {
-        this.#lose += count;
-    }
-    /** The next `count` boxes are delivered twice, and the first reply returns. */
-    duplicateNext(count = 1) {
-        this.#twice += count;
-    }
-    /**
-     * The clock moved on by `ms` in steps of `step`, the bench settling after
-     * each, so latencies end, retries leave and replies land as time passes.
-     */
-    async elapse(ms, { step = 1_000 } = {}) {
-        await settle();
-        for (let left = ms; left > 0; left -= step) {
-            this.#clock.advance(Math.min(step, left));
-            await settle();
-        }
-    }
-    // Whether a chance of `share` comes up, drawn from the seed.
-    #roll(share) {
-        if (share === undefined || share <= 0)
-            return false;
-        const [a, b] = this.#chance(2);
-        return (a * 256 + b) / 65_536 < share;
-    }
-    async #delay(ms) {
-        if (ms === undefined || ms <= 0)
-            return;
-        await this.#clock.wait({ id: `network:${++this.#waits}`, ms });
-    }
-    // A door's answer, or LATE where the box's wait on the network's clock runs out first.
-    async #within(answer, wait) {
-        if (wait === undefined)
-            return answer;
-        const id = `network:late:${++this.#waits}`;
-        const late = this.#clock.wait({ id, ms: wait }).then((fired) => (fired ? LATE : new Promise(() => undefined)));
-        try {
-            return await Promise.race([answer, late]);
-        }
-        finally {
-            this.#clock.cancel({ id });
-        }
-    }
-    async #send(from, { ward, at, box, wait }) {
-        const own = this.#hosts.get(from);
-        if (own === undefined || !own.up)
-            return { reply: null, heard: false };
-        // A ward on this host takes the box by pointer, before any address, and crosses nothing.
-        const near = own.doors.get(ward);
-        if (near !== undefined) {
-            const reply = await near(box);
-            if (reply !== null)
-                return { reply };
-        }
-        for (const address of at) {
-            if (!address.startsWith(SCHEME))
-                continue;
-            const to = this.#names.get(address.slice(SCHEME.length));
-            const host = to === undefined ? undefined : this.#hosts.get(to);
-            if (to === undefined || host === undefined || !host.up || !host.listens || this.#cuts.has(`${from}\n${to}`))
-                continue;
-            const link = this.#links.get(pair(from, to)) ?? {};
-            const log = (outcome) => this.crossings.push({ from, to, ward, outcome });
-            await this.#delay(link.latency);
-            if (this.#drop > 0 || this.#roll(link.drop)) {
-                if (this.#drop > 0)
-                    this.#drop--;
-                log('dropped');
-                continue;
-            }
-            // The door is read again after the latency: a host may have gone down, or a cut come, meanwhile.
-            const door = host.up && !this.#cuts.has(`${from}\n${to}`) ? host.doors.get(ward) : undefined;
-            if (door === undefined)
-                continue;
-            const twice = this.#twice > 0 || this.#roll(link.duplicate);
-            if (this.#twice > 0)
-                this.#twice--;
-            const reply = await this.#within(door(box), wait);
-            // A door that answered past the box's wait may have heard it.
-            if (reply === LATE) {
-                log('late');
-                return { reply: null, heard: true };
-            }
-            if (twice)
-                await door(box);
-            await this.#delay(link.latency);
-            // A reply lost after the door answered was heard, so no other address is tried.
-            if (this.#lose > 0 || this.#roll(link.lose) || this.#cuts.has(`${to}\n${from}`)) {
-                if (this.#lose > 0)
-                    this.#lose--;
-                log('lost');
-                return { reply: null, heard: true };
-            }
-            if (reply === null) {
-                log('silent');
-                continue;
-            }
-            log(twice ? 'twice' : 'answered');
-            return { reply, via: address };
-        }
-        return { reply: null, heard: false };
-    }
-}

package/dist/bench/fake-unlock.d.ts

@@ -1,6 +0,0 @@
-import type { Unlock } from '../index.ts';
-export declare class FakeUnlock implements Unlock {
-    #private;
-    constructor(seed?: string);
-    key(): Promise<string>;
-}

package/dist/bench/fake-unlock.js

@@ -1,10 +0,0 @@
-import { seedOf } from './seeded.js';
-export class FakeUnlock {
-    #key;
-    constructor(seed = 'unlock') {
-        this.#key = seedOf(`${seed}:key`);
-    }
-    key() {
-        return Promise.resolve(this.#key);
-    }
-}

package/dist/bench/index.d.ts

@@ -1,3 +0,0 @@
-export { Bench } from './bench.ts';
-export { BenchGround } from './bench-ground.ts';
-export { FakeNetwork } from './fake-network.ts';

package/dist/bench/index.js

@@ -1,5 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// `nervur/bench`: what a test imports to hold a class, a faculty or a body.
-export { Bench } from './bench.js';
-export { BenchGround } from './bench-ground.js';
-export { FakeNetwork } from './fake-network.js';

package/dist/bench/seeded.d.ts

@@ -1,11 +0,0 @@
-import { NobleCrypto } from '../index.ts';
-/** A stream of bytes from a name: the same name, the same bytes. */
-export declare const stream: (name: string) => (length: number) => Uint8Array;
-/** Sixty-four hex digits from a name. */
-export declare const seedOf: (name: string) => string;
-/** The default crypto, with randomness drawn from a seed. */
-export declare class SeededCrypto extends NobleCrypto {
-    #private;
-    constructor(name: string);
-    random(length: number): Uint8Array;
-}

package/dist/bench/seeded.js

@@ -1,37 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// What makes a bench run the same twice: bytes drawn from a seed, never
-// from the platform. They are for tests alone and guard nothing.
-import { NobleCrypto } from '../index.js';
-/** A stream of bytes from a name: the same name, the same bytes. */
-export const stream = (name) => {
-    // FNV-1a over the name seeds xorshift32.
-    let state = 0x811c9dc5;
-    for (let at = 0; at < name.length; at++)
-        state = Math.imul(state ^ name.charCodeAt(at), 0x01000193) >>> 0;
-    if (state === 0)
-        state = 1;
-    return (length) => {
-        const out = new Uint8Array(length);
-        for (let at = 0; at < length; at++) {
-            state ^= state << 13;
-            state ^= state >>> 17;
-            state ^= state << 5;
-            state >>>= 0;
-            out[at] = state & 0xff;
-        }
-        return out;
-    };
-};
-/** Sixty-four hex digits from a name. */
-export const seedOf = (name) => Array.from(stream(`seed:${name}`)(32), (byte) => byte.toString(16).padStart(2, '0')).join('');
-/** The default crypto, with randomness drawn from a seed. */
-export class SeededCrypto extends NobleCrypto {
-    #draw;
-    constructor(name) {
-        super();
-        this.#draw = stream(`random:${name}`);
-    }
-    random(length) {
-        return this.#draw(length);
-    }
-}

package/dist/bench/settle.d.ts

@@ -1,2 +0,0 @@
-/** Every ask, effect and reply the fakes started, run to where it waits on the clock or ends. */
-export declare const settle: () => Promise<void>;

package/dist/bench/settle.js

@@ -1,49 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// Letting the bench go idle. The fakes do no I/O, so every ask, effect and
-// reply they started runs on the event loop, and the one thing that leaves
-// it is WebCrypto, which runs on the engine's own threads and outlasts any
-// count of turns on a loaded machine. So the bench counts WebCrypto calls
-// in flight, at `crypto.subtle` itself, the one door every body's crypto
-// passes, and calls the loop idle only once none has been in flight for a
-// run of turns. It counts in the process that imports the bench alone.
-// Turns with nothing in flight before the bench calls the loop idle: the
-// promise chains between two crypto calls resolve well within them.
-const QUIET = 20;
-// A loop that never goes idle is a fault the bench names, never a hang.
-const BOUND = 200_000;
-let inFlight = 0;
-const METHODS = ['digest', 'importKey', 'exportKey', 'deriveBits', 'deriveKey', 'encrypt', 'decrypt', 'sign', 'verify', 'generateKey', 'wrapKey', 'unwrapKey'];
-// Each method of the engine's `subtle`, counted while its promise is open. Wrapped once, however often the bench loads.
-const subtle = globalThis.crypto?.subtle;
-const COUNTED = Symbol.for('nervur.bench.counted');
-if (subtle !== undefined && subtle[COUNTED] !== true) {
-    for (const method of METHODS) {
-        const original = subtle[method];
-        if (typeof original !== 'function')
-            continue;
-        subtle[method] = (...args) => {
-            inFlight++;
-            const done = () => {
-                inFlight--;
-            };
-            const called = original.apply(globalThis.crypto.subtle, args);
-            void called.then(done, done);
-            return called;
-        };
-    }
-    subtle[COUNTED] = true;
-}
-// One turn of the event loop: an immediate where the engine has one, else the shortest timer.
-const turnOnce = typeof globalThis.setImmediate === 'function'
-    ? (next) => globalThis.setImmediate(next)
-    : (next) => setTimeout(next, 0);
-/** Every ask, effect and reply the fakes started, run to where it waits on the clock or ends. */
-export const settle = async () => {
-    let quiet = 0;
-    for (let turn = 0; quiet < QUIET; turn++) {
-        if (turn >= BOUND)
-            throw new Error('the bench never went idle: crypto stayed in flight');
-        await new Promise((next) => turnOnce(next));
-        quiet = inFlight === 0 ? quiet + 1 : 0;
-    }
-};

package/dist/bench/stewards.d.ts

@@ -1,169 +0,0 @@
-import { type Args, type Json } from '../being/index.ts';
-/** One ask's outcome: its answer, or `queued` where it left as an effect whose reply lands later. */
-type Outcome = {
-    answer: {
-        result: Json;
-    } | {
-        error: {
-            message: string;
-        };
-    };
-} | {
-    queued: true;
-};
-declare const BenchSteward_base: import("../being/being.ts").BeingClass<{
-    heard: Json[];
-}, Record<never, never>, {
-    readonly bear: {
-        readonly for: "root";
-        readonly args: import("../being/schema.ts").Schema<{
-            args?: undefined;
-            id: string;
-            kind: string;
-        }>;
-    };
-    readonly door: {
-        readonly for: "root";
-        readonly args: import("../being/schema.ts").Schema<{
-            id: string;
-            occupant: string;
-            role?: string | undefined;
-        }>;
-        readonly result: import("../being/schema.ts").Schema<{
-            door: import("../being/schema.ts").HandleMark;
-        }>;
-    };
-    readonly introduce: {
-        readonly for: "root";
-        readonly args: import("../being/schema.ts").Schema<{
-            from: string;
-            to: string;
-        }>;
-    };
-    readonly ask: {
-        readonly for: "root";
-        readonly hints: {
-            readonly idempotent: true;
-        };
-        readonly args: import("../being/schema.ts").Schema<{
-            args?: undefined;
-            id: string;
-            method: string;
-        }>;
-        readonly result: Readonly<{}>;
-    };
-    readonly shows: {
-        readonly for: "root";
-        readonly hints: {
-            readonly idempotent: true;
-        };
-        readonly args: import("../being/schema.ts").Schema<{
-            id: string;
-        }>;
-        readonly result: Readonly<{}>;
-    };
-    readonly heard: {
-        readonly for: "steward";
-        readonly args: Readonly<{
-            type: "object";
-        }>;
-    };
-    readonly replies: {
-        readonly for: "root";
-        readonly hints: {
-            readonly readOnly: true;
-        };
-        readonly result: import("../being/schema.ts").Schema<unknown[]>;
-    };
-}>;
-export declare class BenchSteward extends BenchSteward_base {
-    bear({ kind, id, args }: Args<BenchSteward, 'bear'>): void;
-    door({ id, occupant, role }: Args<BenchSteward, 'door'>): {
-        door: import("../being/schema.ts").Handle;
-    };
-    introduce({ from, to }: Args<BenchSteward, 'introduce'>): void;
-    ask({ id, method, args }: Args<BenchSteward, 'ask'>): Promise<Outcome>;
-    shows({ id }: Args<BenchSteward, 'shows'>): Promise<Json>;
-    heard(answer: Args<BenchSteward, 'heard'>): void;
-    replies(): Json[];
-}
-declare const BenchCaller_base: import("../being/being.ts").BeingClass<{
-    heard: Json[];
-}, Record<never, never>, {
-    readonly adopt: {
-        readonly for: "root";
-        readonly args: import("../being/schema.ts").Schema<{
-            invitation: import("../being/schema.ts").HandleMark;
-        }>;
-        readonly result: import("../being/schema.ts").Schema<string>;
-    };
-    readonly ask: {
-        readonly for: "root";
-        readonly hints: {
-            readonly idempotent: true;
-        };
-        readonly args: import("../being/schema.ts").Schema<{
-            args?: undefined;
-            method: string;
-            standing: string;
-        }>;
-        readonly result: Readonly<{}>;
-    };
-    readonly describe: {
-        readonly for: "root";
-        readonly hints: {
-            readonly idempotent: true;
-        };
-        readonly args: import("../being/schema.ts").Schema<{
-            standing: string;
-        }>;
-        readonly result: Readonly<{}>;
-    };
-    readonly visit: {
-        readonly for: "root";
-        readonly hints: {
-            readonly idempotent: true;
-        };
-        readonly args: import("../being/schema.ts").Schema<{
-            args?: undefined;
-            at: string[];
-            method: string;
-            ward: string;
-        }>;
-        readonly result: Readonly<{}>;
-    };
-    readonly looks: {
-        readonly for: "root";
-        readonly hints: {
-            readonly idempotent: true;
-        };
-        readonly args: import("../being/schema.ts").Schema<{
-            at: string[];
-            ward: string;
-        }>;
-        readonly result: Readonly<{}>;
-    };
-    readonly heard: {
-        readonly for: "steward";
-        readonly args: Readonly<{
-            type: "object";
-        }>;
-    };
-    readonly replies: {
-        readonly for: "root";
-        readonly hints: {
-            readonly readOnly: true;
-        };
-        readonly result: import("../being/schema.ts").Schema<unknown[]>;
-    };
-}>;
-export declare class BenchCaller extends BenchCaller_base {
-    adopt({ invitation }: Args<BenchCaller, 'adopt'>): string;
-    ask({ standing, method, args }: Args<BenchCaller, 'ask'>): Promise<Outcome>;
-    describe({ standing }: Args<BenchCaller, 'describe'>): Promise<Json>;
-    visit({ ward, at, method, args }: Args<BenchCaller, 'visit'>): Promise<Outcome>;
-    looks({ ward, at }: Args<BenchCaller, 'looks'>): Promise<Json>;
-    heard(answer: Args<BenchCaller, 'heard'>): void;
-    replies(): Json[];
-}
-export {};

package/dist/bench/stewards.js

@@ -1,128 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// The bench's own beings, written as any author writes hers. The steward
-// keeps the author's house where the test brings no steward of its own:
-// it bears, invites and introduces through its powers, and asks as her
-// steward. The caller asks through a standing, as a stranger, or as a
-// being introduced to her. Each keeps the answers her effects' replies
-// bring, so the bench reads what an effect answered once it lands.
-import { Being, need, s } from '../being/index.js';
-/** Any JSON value: a schema with no keyword. */
-const ANY = Object.freeze({});
-/** A reply's args: the answer an effect brought, a result or an error. */
-const ANSWER = Object.freeze({ type: 'object' });
-/** A card and one ask, as the caller asks a far public being. */
-const CARD = { ward: s.string(), at: s.array(s.string()) };
-const failed = (error) => ({ answer: { error: { message: error instanceof Error ? error.message : String(error) } } });
-// A need for one ask a describe showed, whose result is read as the JSON it is.
-const needFor = (shown) => {
-    const required = shown.args?.required;
-    const readOnly = shown.hints?.readOnly === true;
-    return need('asked', {
-        [shown.method]: {
-            args: { type: 'object', ...(Array.isArray(required) ? { required } : {}) },
-            result: ANY,
-            hints: { readOnly, idempotent: readOnly || shown.hints?.idempotent === true },
-        },
-    });
-};
-export class BenchSteward extends Being.of({
-    kind: 'org.nervur.bench.steward',
-    cells: { heard: [] },
-    asks: {
-        bear: { for: 'root', args: s.object({ kind: s.string(), id: s.string(), args: s.optional(ANY) }) },
-        door: { for: 'root', args: s.object({ id: s.string(), occupant: s.string(), role: s.optional(s.string()) }), result: s.object({ door: s.handle() }) },
-        introduce: { for: 'root', args: s.object({ from: s.string(), to: s.string() }) },
-        ask: { for: 'root', hints: { idempotent: true }, args: s.object({ id: s.string(), method: s.string(), args: s.optional(ANY) }), result: ANY },
-        shows: { for: 'root', hints: { idempotent: true }, args: s.object({ id: s.string() }), result: ANY },
-        heard: { for: 'steward', args: ANSWER },
-        replies: { for: 'root', hints: { readOnly: true }, result: s.array(ANY) },
-    },
-}) {
-    bear({ kind, id, args }) {
-        this.powers.bear({ kind, id, ...(args === undefined ? {} : { args }) });
-    }
-    // A new occupant of hers, whose steward notes hold the role the bench plays.
-    door({ id, occupant, role }) {
-        return { door: this.powers.invite({ id, occupant, notes: role === undefined ? {} : { [role]: true } }) };
-    }
-    introduce({ from, to }) {
-        this.powers.introduce({ from, to });
-    }
-    // As her steward: awaited where her entry says so, an effect otherwise, whose answer lands as a reply.
-    async ask({ id, method, args }) {
-        try {
-            const answered = await this.powers.ask({ id, method, ...(args === undefined ? {} : { args }) }, { reply: 'heard' });
-            return answered === undefined ? { queued: true } : { answer: { result: (answered ?? null) } };
-        }
-        catch (error) {
-            return failed(error);
-        }
-    }
-    shows({ id }) {
-        return this.powers.ask({ id });
-    }
-    heard(answer) {
-        this.cells.heard = [...this.cells.heard, answer];
-    }
-    replies() {
-        return this.cells.heard;
-    }
-}
-export class BenchCaller extends Being.of({
-    kind: 'org.nervur.bench.caller',
-    cells: { heard: [] },
-    asks: {
-        adopt: { for: 'root', args: s.object({ invitation: s.handle() }), result: s.string() },
-        ask: { for: 'root', hints: { idempotent: true }, args: s.object({ standing: s.string(), method: s.string(), args: s.optional(ANY) }), result: ANY },
-        describe: { for: 'root', hints: { idempotent: true }, args: s.object({ standing: s.string() }), result: ANY },
-        visit: { for: 'root', hints: { idempotent: true }, args: s.object({ ...CARD, method: s.string(), args: s.optional(ANY) }), result: ANY },
-        looks: { for: 'root', hints: { idempotent: true }, args: s.object(CARD), result: ANY },
-        heard: { for: 'steward', args: ANSWER },
-        replies: { for: 'root', hints: { readOnly: true }, result: s.array(ANY) },
-    },
-}) {
-    adopt({ invitation }) {
-        return invitation;
-    }
-    // Through a standing she holds: what it shows her, then the ask by a need that describe covers.
-    async ask({ standing, method, args }) {
-        try {
-            const { asks } = await this.held(standing).describe();
-            const shown = asks.find((one) => one.method === method);
-            if (shown === undefined)
-                return failed('no such ask');
-            const face = this.held(standing, needFor(shown));
-            const answered = await face[method](args ?? {}, { reply: 'heard' });
-            return answered === undefined ? { queued: true } : { answer: { result: (answered ?? null) } };
-        }
-        catch (error) {
-            return failed(error);
-        }
-    }
-    async describe({ standing }) {
-        return (await this.held(standing).describe());
-    }
-    // As a stranger to a far public being: what she shows a stranger, then the ask.
-    async visit({ ward, at, method, args }) {
-        try {
-            const { asks } = await this.stranger({ ward, at }).describe();
-            const shown = asks.find((one) => one.method === method);
-            if (shown === undefined)
-                return failed('no such ask');
-            const face = this.stranger({ ward, at }, needFor(shown));
-            return { answer: { result: ((await face[method](args ?? {})) ?? null) } };
-        }
-        catch (error) {
-            return failed(error);
-        }
-    }
-    async looks({ ward, at }) {
-        return (await this.stranger({ ward, at }).describe());
-    }
-    heard(answer) {
-        this.cells.heard = [...this.cells.heard, answer];
-    }
-    replies() {
-        return this.cells.heard;
-    }
-}

package/dist/bodies/class-list.d.ts

@@ -1,14 +0,0 @@
-import type { BeingClass, Classes } from '../foundation.ts';
-export declare class ClassList implements Classes {
-    #private;
-    constructor({ steward, public: open, beings }: {
-        steward: BeingClass;
-        public?: BeingClass;
-        beings?: readonly BeingClass[];
-    });
-    resolve({ kind }: {
-        kind: string;
-    }): Promise<BeingClass | undefined>;
-    steward(): string;
-    public(): string | undefined;
-}