nervur 0.23.0 → 0.24.0

package/dist/being/table.js

@@ -1,344 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// A class resolved: her declaration checked and settled into the table the
-// house reads. Every way a class fails is gathered, and the refusal names
-// each one.
-import { DECLARATION, MEMBERS } from './being.js';
-import { blueprintOf, method, WAIT_BOUND } from './need.js';
-import { outside } from './schema.js';
-/** The roles the house names. */
-export const HOUSE_ROLES = new Set(['handle', 'stranger', 'steward', 'being', 'root']);
-/** The state of a class that names none. */
-export const READY = 'ready';
-/** A class the house will not resolve, and every reason why. */
-export class Refused extends Error {
-    reasons;
-    constructor(what, reasons) {
-        super(`${what} is refused: ${reasons.join('; ')}`);
-        this.name = 'Refused';
-        this.reasons = reasons;
-    }
-}
-const KIND = /^[a-z][a-z0-9-]*(\.[a-z][a-z0-9-]*){2,}$/;
-const VIEW_BYTES = 65_536;
-const NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
-const BLUEPRINT_NAME = /^[a-z][a-z0-9._-]*$/;
-const ENTRY_FIELDS = new Set(['in', 'for', 'to', 'args', 'result', 'hints', 'examples', 'description', 'wait']);
-const METHOD_FIELDS = new Set(['args', 'result', 'hints', 'description', 'wait']);
-const HINTS = new Set(['readOnly', 'idempotent', 'destructive']);
-const EXAMPLE_FIELDS = new Set(['description', 'given', 'role', 'args', 'fakes', 'gives']);
-const STEP_FIELDS = new Set(['ask', 'args', 'role']);
-const EVERY_OBJECT = new Set(Object.getOwnPropertyNames(Object.prototype));
-// The bytes a text takes as UTF-8, where a lone surrogate takes the three of its replacement.
-const utf8Length = (text) => {
-    let length = 0;
-    for (const char of text) {
-        const point = char.codePointAt(0);
-        length += point < 0x80 ? 1 : point < 0x800 ? 2 : point < 0x10000 ? 3 : 4;
-    }
-    return length;
-};
-const plain = (value) => {
-    if (typeof value !== 'object' || value === null || Array.isArray(value))
-        return false;
-    const proto = Object.getPrototypeOf(value);
-    return proto === Object.prototype || proto === null;
-};
-/** Whether a value is JSON, as cells and notes hold. */
-export const isJson = (value) => {
-    if (value === null || typeof value === 'string' || typeof value === 'boolean')
-        return true;
-    if (typeof value === 'number')
-        return Number.isFinite(value);
-    if (Array.isArray(value))
-        return value.every(isJson);
-    return plain(value) && Object.values(value).every(isJson);
-};
-const names = (value, where, reasons) => {
-    if (value === undefined)
-        return null;
-    const list = typeof value === 'string' ? [value] : value;
-    if (!Array.isArray(list) || list.length === 0 || !list.every((name) => typeof name === 'string' && name.length > 0)) {
-        reasons.push(`${where} is not a name or a list of names`);
-        return [];
-    }
-    return Object.freeze([...new Set(list)]);
-};
-// Args are always an object: one, or a choice of several, as a reply is.
-const objectSchema = (schema) => schema.type === 'object' || (Array.isArray(schema.anyOf) && schema.anyOf.length > 0 && schema.anyOf.every((branch) => plain(branch) && objectSchema(branch)));
-const methodChecked = (spec, fields, where, reasons) => {
-    if (!plain(spec)) {
-        reasons.push(`${where} is not an object`);
-        return undefined;
-    }
-    for (const key of Object.keys(spec))
-        if (!fields.has(key))
-            reasons.push(`${where} names ${key}, which is no field`);
-    const { args, result, hints, description, wait } = spec;
-    if (wait !== undefined && !(Number.isInteger(wait) && wait > 0 && wait <= WAIT_BOUND))
-        reasons.push(`${where}.wait is not a count of milliseconds within five minutes`);
-    if (args !== undefined) {
-        reasons.push(...outside(args, `${where}.args`));
-        if (plain(args) && !objectSchema(args))
-            reasons.push(`${where}.args is not an object schema`);
-    }
-    if (result !== undefined)
-        reasons.push(...outside(result, `${where}.result`));
-    if (description !== undefined && typeof description !== 'string')
-        reasons.push(`${where}.description is not a string`);
-    if (hints !== undefined) {
-        if (!plain(hints))
-            reasons.push(`${where}.hints is not an object`);
-        else {
-            for (const [key, value] of Object.entries(hints)) {
-                if (!HINTS.has(key))
-                    reasons.push(`${where}.hints names ${key}, which is no hint`);
-                else if (typeof value !== 'boolean')
-                    reasons.push(`${where}.hints.${key} is not true or false`);
-            }
-            if (hints.readOnly === true && hints.idempotent === false)
-                reasons.push(`${where} is readOnly and not idempotent`);
-        }
-    }
-    return method(spec);
-};
-// A blueprint held to its rules as its author wrote it: a need keeps her
-// methods as written beside the blueprint they settle into, and a program
-// describes one as JSON. Settling drops a field and bounds a wait, so the
-// written methods are what is checked.
-const blueprintChecked = (value, where, reasons) => {
-    const settled = blueprintOf(value);
-    const written = settled === undefined ? value : { name: settled.name, methods: Object.fromEntries(Object.keys(settled.methods).map((name) => [name, value[name]])) };
-    if (!plain(written) || !plain(written.methods)) {
-        reasons.push(`${where} is not a need`);
-        return undefined;
-    }
-    const { name } = written;
-    if (typeof name !== 'string' || !BLUEPRINT_NAME.test(name))
-        reasons.push(`${where} has a name that is no blueprint name`);
-    const methods = {};
-    for (const [called, spec] of Object.entries(written.methods)) {
-        if (!NAME.test(called))
-            reasons.push(`${where}.${called} is no method name`);
-        const checked = methodChecked(spec, METHOD_FIELDS, `${where}.${called}`, reasons);
-        if (checked !== undefined)
-            methods[called] = checked;
-    }
-    return settled ?? Object.freeze({ name: String(name), methods: Object.freeze(methods) });
-};
-/**
- * An offer's blueprint as it arrives, from a need or from a program's
- * describe, held to the rules a need is: a keyword outside the subset,
- * or a field that is none, refuses it where it arrives.
- */
-export const offered = (value, where = 'the offer') => {
-    const reasons = [];
-    const blueprint = blueprintChecked(value, where, reasons);
-    if (blueprint === undefined || reasons.length > 0)
-        throw new Refused(where, reasons);
-    return blueprint;
-};
-// Her examples: each a history of her own asks, then the one it shows.
-const examplesChecked = (examples, where, asks, reasons) => {
-    if (examples === undefined)
-        return [];
-    if (!Array.isArray(examples)) {
-        reasons.push(`${where}.examples is not a list`);
-        return [];
-    }
-    examples.forEach((example, index) => {
-        const at = `${where}.examples[${index}]`;
-        if (!plain(example) || !isJson(example)) {
-            reasons.push(`${at} is not a JSON object`);
-            return;
-        }
-        for (const key of Object.keys(example))
-            if (!EXAMPLE_FIELDS.has(key))
-                reasons.push(`${at} names ${key}, which is no field`);
-        const given = example.given;
-        if (given === undefined)
-            return;
-        if (!Array.isArray(given)) {
-            reasons.push(`${at}.given is not a list`);
-            return;
-        }
-        given.forEach((step, place) => {
-            const one = step;
-            if (!plain(step) || typeof one.ask !== 'string' || !asks.includes(one.ask))
-                reasons.push(`${at}.given[${place}] names no ask of hers`);
-            else
-                for (const key of Object.keys(step))
-                    if (!STEP_FIELDS.has(key))
-                        reasons.push(`${at}.given[${place}] names ${key}, which is no field`);
-        });
-    });
-    return Object.freeze([...examples]);
-};
-/** Her class checked and settled, or refused with every reason. */
-export const resolve = (Class) => {
-    const declaration = typeof Class === 'function' ? Class[DECLARATION] : undefined;
-    if (declaration === undefined)
-        throw new Refused('the class', ['it is not a class of Being.of']);
-    const reasons = [];
-    const kind = declaration.kind;
-    if (typeof kind !== 'string' || !KIND.test(kind))
-        reasons.push('its kind is not a reversed domain and a name');
-    const what = typeof kind === 'string' ? kind : 'the class';
-    if (declaration.description !== undefined && typeof declaration.description !== 'string')
-        reasons.push('its description is not a string');
-    // A view is data a screen renders, never more than a screen holds.
-    if (declaration.view !== undefined && (typeof declaration.view !== 'string' || utf8Length(declaration.view) > VIEW_BYTES))
-        reasons.push('its view is not text of at most 64 KiB');
-    const cells = declaration.cells ?? {};
-    if (!plain(cells) || !isJson(cells))
-        reasons.push('its cells are not a JSON object');
-    // Needs, each a blueprint under her own member name.
-    const needs = {};
-    const declaredNeeds = declaration.needs ?? {};
-    if (!plain(declaredNeeds))
-        reasons.push('its needs are not an object');
-    else {
-        for (const [member, value] of Object.entries(declaredNeeds)) {
-            if (blueprintOf(value) === undefined) {
-                reasons.push(`its need ${member} is not a need`);
-                continue;
-            }
-            const blueprint = blueprintChecked(value, `its need ${member}`, reasons);
-            if (blueprint !== undefined)
-                needs[member] = blueprint;
-        }
-    }
-    // Roles, the author's tests over the asker and her cells.
-    const roles = declaration.roles ?? {};
-    if (!plain(roles))
-        reasons.push('its roles are not an object');
-    for (const [name, test] of Object.entries(plain(roles) ? roles : {})) {
-        if (HOUSE_ROLES.has(name))
-            reasons.push(`its role ${name} is the house's`);
-        if (typeof test !== 'function')
-            reasons.push(`its role ${name} is not a function`);
-    }
-    // Asks, each an entry and a method.
-    const asks = {};
-    const declaredAsks = declaration.asks;
-    if (!plain(declaredAsks))
-        reasons.push('its asks are not an object');
-    const prototype = Class.prototype;
-    for (const [name, entry] of Object.entries(plain(declaredAsks) ? declaredAsks : {})) {
-        const where = `its ask ${name}`;
-        if (!NAME.test(name))
-            reasons.push(`${where} is no method name`);
-        const settled = methodChecked(entry, ENTRY_FIELDS, where, reasons);
-        if (settled === undefined)
-            continue;
-        const raw = entry;
-        if (typeof prototype[name] !== 'function')
-            reasons.push(`${where} has no method`);
-        asks[name] = Object.freeze({
-            ...settled,
-            method: name,
-            in: names(raw.in, `${where}.in`, reasons),
-            for: names(raw.for, `${where}.for`, reasons),
-            to: names(raw.to, `${where}.to`, reasons),
-            effect: raw.hints?.idempotent === false,
-            examples: examplesChecked(raw.examples, where, plain(declaredAsks) ? Object.keys(declaredAsks) : [], reasons),
-        });
-    }
-    // Member names: a need, an ask, a member of Being and her own methods.
-    const own = new Set();
-    for (let proto = prototype; proto !== null && proto !== Object.prototype; proto = Object.getPrototypeOf(proto)) {
-        for (const key of Object.getOwnPropertyNames(proto))
-            if (key !== 'constructor')
-                own.add(key);
-    }
-    for (const member of Object.keys(needs)) {
-        if (member in asks)
-            reasons.push(`its need ${member} and its ask ${member} share a name`);
-        if (MEMBERS.has(member))
-            reasons.push(`its need ${member} and Being's ${member} share a name`);
-        if (own.has(member))
-            reasons.push(`its need ${member} and its method ${member} share a name`);
-        if (EVERY_OBJECT.has(member))
-            reasons.push(`its need ${member} is a member of every object`);
-    }
-    for (const name of Object.keys(asks)) {
-        if (MEMBERS.has(name))
-            reasons.push(`its ask ${name} and Being's ${name} share a name`);
-        if (EVERY_OBJECT.has(name))
-            reasons.push(`its ask ${name} is a member of every object`);
-    }
-    // The state, and the state of her default cells.
-    const state = declaration.state ?? (() => READY);
-    let first = READY;
-    if (declaration.state !== undefined) {
-        if (typeof declaration.state !== 'function')
-            reasons.push('its state is not a function');
-        else {
-            try {
-                first = declaration.state({ id: '', position: 'normal', cells: cells });
-            }
-            catch {
-                reasons.push('its state throws on its default cells');
-            }
-            if (typeof first !== 'string' || first.length === 0)
-                reasons.push('its state names no state on its default cells');
-        }
-    }
-    const states = table(asks, roles, first, declaration.state !== undefined, reasons);
-    if (reasons.length > 0)
-        throw new Refused(what, reasons);
-    return Object.freeze({
-        kind,
-        ...(declaration.description === undefined ? {} : { description: declaration.description }),
-        ...(declaration.view === undefined ? {} : { view: declaration.view }),
-        cells: cells,
-        needs: Object.freeze(needs),
-        roles: Object.freeze({ ...roles }),
-        state: state,
-        first,
-        states,
-        asks: Object.freeze(asks),
-    });
-};
-// The table: every state reached from the first, every ask reached by a
-// role, and every role named by an ask. A terminal state is allowed.
-const table = (asks, roles, first, stated, reasons) => {
-    const named = new Set([first]);
-    for (const entry of Object.values(asks))
-        for (const name of [...(entry.in ?? []), ...(entry.to ?? [])])
-            named.add(name);
-    if (!stated)
-        for (const name of named)
-            if (name !== READY)
-                reasons.push(`it names the state ${name} and has no state of its own`);
-    const reached = new Set([first]);
-    const queue = [first];
-    while (queue.length > 0) {
-        const at = queue.shift();
-        for (const entry of Object.values(asks)) {
-            if (entry.in !== null && !entry.in.includes(at))
-                continue;
-            for (const next of entry.to ?? [at]) {
-                if (reached.has(next))
-                    continue;
-                reached.add(next);
-                queue.push(next);
-            }
-        }
-    }
-    for (const name of named)
-        if (!reached.has(name))
-            reasons.push(`no ask reaches the state ${name}`);
-    const declared = new Set(Object.keys(roles));
-    const used = new Set();
-    for (const entry of Object.values(asks)) {
-        for (const role of entry.for ?? []) {
-            used.add(role);
-            if (!declared.has(role) && !HOUSE_ROLES.has(role))
-                reasons.push(`its ask ${entry.method} is for ${role}, which is no role`);
-        }
-    }
-    for (const role of declared)
-        if (!used.has(role))
-            reasons.push(`its role ${role} is named by no ask`);
-    return Object.freeze([...named]);
-};

package/dist/bench/bench-ground.d.ts

@@ -1,73 +0,0 @@
-import { ClassList, Ground, type Body, type Registry } from '../index.ts';
-import { FakeMemory } from './fake-memory.ts';
-import { type FakeNetwork } from './fake-network.ts';
-import { FakeUnlock } from './fake-unlock.ts';
-import { SeededCrypto } from './seeded.ts';
-type BeingClass = ConstructorParameters<typeof ClassList>[0]['steward'];
-type Entry = Parameters<Ground['add']>[1];
-type Standing = Awaited<ReturnType<Ground['add']>>;
-/** A house module: what a folder's index exports. */
-export interface HouseModule {
-    readonly steward: BeingClass;
-    readonly public?: BeingClass;
-    readonly beings?: readonly BeingClass[];
-}
-/** A body the test writes, living, with the kinds it is granted. */
-export type Living = Body & {
-    readonly kinds?: readonly string[];
-};
-/** What a ground keeps across its lives: its key, its randomness, its memory, and each house's own where it names the `fake` body. */
-export declare class Machine {
-    readonly unlock: FakeUnlock;
-    readonly crypto: SeededCrypto;
-    readonly memory: FakeMemory;
-    readonly houses: Map<string, FakeMemory>;
-    constructor(seed: string);
-    /** The memory of a house on the `fake` body, which a test may have refuse its next writes. */
-    memoryOf(house: string): FakeMemory;
-}
-export interface BenchGroundOptions {
-    /** The network it joins, whose clock it reads. */
-    readonly network: FakeNetwork;
-    /** Its host on the network. */
-    readonly host: string;
-    /** The names that point at it; a ground with none is a device, and is never dialled. */
-    readonly names?: readonly string[];
-    /** The house modules its entries name, by name. */
-    readonly modules?: Readonly<Record<string, HouseModule>>;
-    /** Faculties the test hands living, by name: each stands on its first up, granted the kinds it names. */
-    readonly faculties?: Readonly<Record<string, Living>>;
-    /** Makers beside the bench's own `module` classes and `fake` memory, as a host installs them. */
-    readonly registry?: Registry;
-    /** The machine it opens on; a fresh one, seeded by its host, where none is named. */
-    readonly machine?: Machine;
-}
-export declare class BenchGround {
-    #private;
-    readonly host: string;
-    readonly machine: Machine;
-    private constructor();
-    static open(options: BenchGroundOptions): Promise<BenchGround>;
-    /** The ground on its machine again, joined to the network, its ladder standing and every house of its drawer open. */
-    up(): Promise<void>;
-    /** The ground off: its houses closed, its host answering nothing. Its machine keeps everything. */
-    down(): Promise<void>;
-    /**
-     * A house: of a module by that module's name, keeping its places in the
-     * ground's memory, or on the whole entry the test gives, custom bodies
-     * and all.
-     */
-    add(name: string, from?: string | Entry, rest?: Omit<Entry, 'classes'>): Promise<Standing>;
-    remove(name: string): Promise<void>;
-    list(): readonly Standing[];
-    /** A being in a house asked as `root`, the house's steward where no id is named. */
-    ask(request: Parameters<Ground['ask']>[0]): ReturnType<Ground['ask']>;
-    /** The ground's hand, as its owner holds it: `describe`, or an ask of a being in a house, or of the dock's steward where no house is named. */
-    hand(request: Parameters<Ground['hand']>[0]): ReturnType<Ground['hand']>;
-    /**
-     * A request to the ground's one listener, with no socket: each faculty's
-     * handler in turn, the first answer standing, and 404 where none takes it.
-     */
-    fetch(request: Request): Promise<Response>;
-}
-export {};

package/dist/bench/bench-ground.js

@@ -1,153 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// A ground in memory. It joins a FakeNetwork under its host, keeps its key
-// and its memory in a machine that outlives it, and opens house modules by
-// name. So a test turns it off, opens it again on the same machine, or
-// moves the machine to another host.
-import { s } from '../being/index.js';
-import { ClassList, Ground } from '../index.js';
-import { FakeMemory } from './fake-memory.js';
-import { clockOf } from './fake-network.js';
-import { FakeUnlock } from './fake-unlock.js';
-import { SeededCrypto } from './seeded.js';
-// Registries' faculties as one, the first first: a name one holds is refused to the next, never replaced.
-const NONE = { args: s.object({}) };
-const joined = (...each) => {
-    const all = {};
-    for (const faculties of each) {
-        for (const [name, faculty] of Object.entries(faculties)) {
-            if (Object.hasOwn(all, name))
-                throw new TypeError(`the faculty ${name} is the bench's own`);
-            all[name] = faculty;
-        }
-    }
-    return all;
-};
-/** What a ground keeps across its lives: its key, its randomness, its memory, and each house's own where it names the `fake` body. */
-export class Machine {
-    unlock;
-    // One stream across every life, so a ground opened again never draws the bytes it drew before.
-    crypto;
-    memory = new FakeMemory();
-    houses = new Map();
-    constructor(seed) {
-        this.unlock = new FakeUnlock(seed);
-        this.crypto = new SeededCrypto(seed);
-    }
-    /** The memory of a house on the `fake` body, which a test may have refuse its next writes. */
-    memoryOf(house) {
-        return this.houses.get(house) ?? this.houses.set(house, new FakeMemory()).get(house);
-    }
-}
-export class BenchGround {
-    host;
-    machine;
-    #options;
-    #ground;
-    constructor(options, machine) {
-        this.host = options.host;
-        this.machine = machine;
-        this.#options = options;
-    }
-    static async open(options) {
-        const bench = new BenchGround(options, options.machine ?? new Machine(options.host));
-        await bench.up();
-        return bench;
-    }
-    #live() {
-        if (this.#ground === undefined)
-            throw new Error(`the ground ${this.host} is down`);
-        return this.#ground;
-    }
-    /** The ground on its machine again, joined to the network, its ladder standing and every house of its drawer open. */
-    async up() {
-        if (this.#ground !== undefined)
-            return;
-        const { network, host, names = [], modules = {}, faculties = {}, registry = {} } = this.#options;
-        network.up(host);
-        const machine = this.machine;
-        // Each living body the test hands stands through a faculty whose `up` answers it, as any body stands.
-        const living = Object.fromEntries(Object.entries(faculties).map(([name, { kinds: _kinds, ...body }]) => [name, { up: () => body }]));
-        const own = {
-            faculties: {
-                'bench-unlock': { takes: NONE, up: () => ({ serves: 'unlock', object: machine.unlock }) },
-                'bench-memory': { takes: NONE, up: () => ({ serves: 'memory', object: machine.memory }) },
-                seeded: { takes: NONE, up: () => ({ serves: 'crypto', object: machine.crypto }) },
-                // The test holds the hand in its own process, so this hand listens on nothing.
-                'bench-hand': { takes: NONE, up: () => ({ serves: 'hand' }) },
-                'bench-clock': { takes: NONE, up: () => ({ serves: 'clock', object: clockOf(network) }) },
-                // Its listener on the network is the ground's one, which its entry names in `faculties`.
-                'bench-carry': {
-                    takes: NONE,
-                    up: ({ faculties: called }) => {
-                        const listener = called.listener;
-                        const serve = async (request) => (await listener.fetch(request)) ?? new Response(null, { status: 404 });
-                        return { serves: 'carry', schemes: ['bench'], object: network.join(host, { names, listens: names.length > 0, serve }) };
-                    },
-                },
-                fake: { takes: NONE, up: () => ({ serves: 'memory', house: ({ house }) => machine.memoryOf(house) }) },
-                module: {
-                    takes: NONE,
-                    up: () => ({
-                        serves: 'classes',
-                        house: ({ args }) => {
-                            const module = modules[args.name];
-                            if (module === undefined)
-                                throw new Error(`no house module ${String(args.name)}`);
-                            return new ClassList({ steward: module.steward, ...(module.public === undefined ? {} : { public: module.public }), beings: module.beings ?? [] });
-                        },
-                    }),
-                },
-            },
-        };
-        this.#ground = await Ground.open({
-            // The bench's own faculties, then the test's beside them, never in their place.
-            registry: { faculties: joined(own.faculties ?? {}, living, registry.faculties ?? {}) },
-            primordial: { unlock: { make: 'bench-unlock' }, memory: { make: 'bench-memory' }, crypto: { make: 'seeded' }, tools: { make: 'strict' }, clock: { make: 'bench-clock' }, hand: { make: 'bench-hand' } },
-            entries: { listener: { make: 'listener' }, carry: { make: 'bench-carry', faculties: ['listener'] }, module: { make: 'module' }, fake: { make: 'fake' } },
-        });
-        // Each living faculty stands on its first up, as its owner would stand it through the hand.
-        for (const [name, { kinds }] of Object.entries(faculties)) {
-            const { why } = await this.#ground.stand(name, { make: name, ...(kinds === undefined ? {} : { kinds }) });
-            if (why !== undefined)
-                throw new Error(`the faculty ${name} did not stand: ${why}`);
-        }
-    }
-    /** The ground off: its houses closed, its host answering nothing. Its machine keeps everything. */
-    async down() {
-        const ground = this.#ground;
-        if (ground === undefined)
-            return;
-        this.#ground = undefined;
-        await ground.close();
-        this.#options.network.down(this.host);
-    }
-    /**
-     * A house: of a module by that module's name, keeping its places in the
-     * ground's memory, or on the whole entry the test gives, custom bodies
-     * and all.
-     */
-    add(name, from = name, rest = {}) {
-        return this.#live().add(name, typeof from === 'string' ? { classes: { faculty: 'module', name: from }, ...rest } : from);
-    }
-    remove(name) {
-        return this.#live().remove(name);
-    }
-    list() {
-        return this.#live().list();
-    }
-    /** A being in a house asked as `root`, the house's steward where no id is named. */
-    ask(request) {
-        return this.#live().ask(request);
-    }
-    /** The ground's hand, as its owner holds it: `describe`, or an ask of a being in a house, or of the dock's steward where no house is named. */
-    hand(request) {
-        return this.#live().hand(request);
-    }
-    /**
-     * A request to the ground's one listener, with no socket: each faculty's
-     * handler in turn, the first answer standing, and 404 where none takes it.
-     */
-    async fetch(request) {
-        return (await this.#live().handler.fetch(request)) ?? new Response(null, { status: 404 });
-    }
-}

package/dist/bench/bench.d.ts

@@ -1,101 +0,0 @@
-import { type Json, type Table } from '../being/index.ts';
-import type { ClassList, Offer } from '../index.ts';
-type BeingClass = ConstructorParameters<typeof ClassList>[0]['steward'];
-type Position = 'normal' | 'steward' | 'public';
-/** What an ask answered. */
-export type Answer = {
-    readonly result: Json;
-} | {
-    readonly error: {
-        readonly message: string;
-    };
-};
-export interface BenchOptions {
-    /** Her classes, and any other class her beings meet. */
-    readonly classes: readonly BeingClass[];
-    /** Fakes of the faculties her needs name. */
-    readonly offers?: readonly Offer[];
-    /** One seed, so a bench runs the same each time. */
-    readonly seed?: string;
-    /** Her steward, placed as the author's house's steward; the bench's own where none is given. */
-    readonly steward?: BeingClass;
-    /** Her public being, placed as the author's house's public being. */
-    readonly public?: BeingClass;
-}
-/** Where a check places her: a normal being, the steward, or the public being. */
-export interface CheckOptions {
-    readonly classes?: readonly BeingClass[];
-    readonly seed?: string;
-    readonly position?: Position;
-    /** The steward beside her, where she is not it. */
-    readonly steward?: BeingClass;
-}
-/** One thing the bench checked: what, and why it failed where it did. */
-export interface Finding {
-    readonly ok: boolean;
-    readonly what: string;
-    readonly why?: string;
-}
-/** What a being shows one asker. */
-interface Described {
-    readonly state: string;
-    readonly asks: readonly {
-        readonly method: string;
-    }[];
-}
-/** A being the bench placed, asked and described as any role the bench can play. */
-export declare class Placed {
-    #private;
-    readonly id: string;
-    readonly position: Position;
-    constructor(bench: Bench, id: string, position: Position, table: Table);
-    /** The role an ask's entry names first; `root` where it names every occupant. */
-    roleFor(method: string): string;
-    /**
-     * One ask, as whoever plays `role`. An effect's answer is the reply it
-     * brings once it lands, and `null` is silence.
-     */
-    ask(method: string, args?: Json, { role }?: {
-        role?: string;
-    }): Promise<Answer | null>;
-    /** Her describe as `role` sees it: her state and the asks it shows. */
-    describe({ role }?: {
-        role?: string;
-    }): Promise<Described | null>;
-    /** Her cells as last landed, read through the hand, as her owner reads them. */
-    cells(): Promise<Record<string, Json>>;
-}
-export declare class Bench {
-    #private;
-    private constructor();
-    static open({ classes, offers, seed, steward, public: open }: BenchOptions): Promise<Bench>;
-    /**
-     * Her class here: the steward or the public being where the bench opened
-     * with her there, and otherwise borne by the bench's own steward, from
-     * her `born`.
-     */
-    place(Class: BeingClass, { id, born }?: {
-        id?: string;
-        born?: Record<string, Json>;
-    }): Promise<Placed>;
-    /** Lets every ask, effect and reply the houses started run to its end. */
-    settle(): Promise<void>;
-    /** The clock moved on, and what came due run. */
-    advance(ms: number): Promise<void>;
-    /** A placed being's cells, read through the hand. */
-    cellsOf(placed: Placed): Promise<Record<string, Json>>;
-    /** One ask of a placed being, as whoever plays the role. */
-    asked(placed: Placed, table: Table, role: string, method: string, args: Json): Promise<Answer | null>;
-    /** What a placed being shows whoever plays the role. */
-    described(placed: Placed, table: Table, role: string): Promise<Described | null>;
-    /** Every example of her class run, twice, on two fresh benches. */
-    static examples(Class: BeingClass, options?: CheckOptions): Promise<Finding[]>;
-    /**
-     * Every state her `born` and her examples' histories reach, described to
-     * every role the bench can play: what each is shown is what her table owes.
-     */
-    static walk(Class: BeingClass, options?: CheckOptions): Promise<Finding[]>;
-    /** Her examples and her walk, and an error naming every finding that failed. */
-    static check(Class: BeingClass, options?: CheckOptions): Promise<Finding[]>;
-}
-export {};