nervur 0.22.0 → 0.22.2-3

package/dist/bench/bench.d.ts

@@ -0,0 +1,87 @@
+import type { Json, Position } from '../being/being.ts';
+import { type Table } from '../being/table.ts';
+import type { BeingClass } from '../foundation.ts';
+import { type Answer, type Offer } from '../house/house.ts';
+import { FakeClock } from './fake-clock.ts';
+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;
+}
+/** A being the bench placed, asked through a handle as any role. */
+export declare class Placed {
+    #private;
+    readonly id: string;
+    constructor(bench: Bench, id: string, table: Table);
+    /** The role an ask's entry names first; `steward` where it names every occupant. */
+    roleFor(method: string): string;
+    /** One ask, crossing as a box, as the occupant who plays `role`. `null` is silence or nothing. */
+    ask(method: string, args?: Json, { role }?: {
+        role?: string;
+    }): Promise<Answer | null>;
+    /** Her describe as `role` sees it: `root` where she is the steward, her steward otherwise. */
+    describe({ role }?: {
+        role?: string;
+    }): Promise<{
+        state: string;
+        asks: {
+            method: string;
+        }[];
+    } | null>;
+    /** Her cells as they stand. */
+    cells(): Promise<Record<string, Json> | null>;
+}
+export declare class Bench {
+    #private;
+    readonly clock: FakeClock;
+    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, from her `born` or from the cells
+     * an example starts from.
+     */
+    place(Class: BeingClass, { id, cells, born }?: {
+        id?: string;
+        cells?: Record<string, Json>;
+        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>;
+    cellsOf(being: string): Promise<Record<string, Json> | null>;
+    through(being: string, role: string, ask: string | undefined, method: string | undefined, args: Json): Promise<Answer | {
+        describe: Json;
+    } | null>;
+    /** Every example of her class run, twice, on two fresh benches. */
+    static examples(Class: BeingClass, options?: CheckOptions): Promise<Finding[]>;
+    /**
+     * Every state her default cells and her examples reach, described to
+     * every role she names: what each is shown is what her table says.
+     */
+    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[]>;
+}

package/dist/bench/bench.js

@@ -0,0 +1,260 @@
+import { resolve } from '../being/table.js';
+import { blueprintOf } from '../being/need.js';
+import { StrictTools } from '../bodies/strict-tools.js';
+import { ClassList } from '../bodies/class-list.js';
+import { openForBench } from '../house/house.js';
+import { Room } from '../quo/room.js';
+import { FakeCarry } from './fake-carry.js';
+import { FakeClock } from './fake-clock.js';
+import { FakeKeys } from './fake-keys.js';
+import { FakeMemory } from './fake-memory.js';
+import { SeededCrypto } from './seeded.js';
+import { settle } from './settle.js';
+import { BenchSteward, BenchTester } from './stewards.js';
+const STEWARD = 'steward';
+const PUBLIC = 'public';
+const tools = new StrictTools();
+/** A being the bench placed, asked through a handle as any role. */
+export class Placed {
+    id;
+    #bench;
+    #table;
+    constructor(bench, id, table) {
+        this.#bench = bench;
+        this.id = id;
+        this.#table = table;
+    }
+    /** The role an ask's entry names first; `steward` where it names every occupant. */
+    roleFor(method) {
+        const entry = this.#table.asks[method];
+        return entry?.for?.[0] ?? STEWARD;
+    }
+    /** One ask, crossing as a box, as the occupant who plays `role`. `null` is silence or nothing. */
+    async ask(method, args = {}, { role = this.roleFor(method) } = {}) {
+        const answered = await this.#bench.through(this.id, role, method, method, args);
+        return answered === null || 'describe' in answered ? null : answered;
+    }
+    /** Her describe as `role` sees it: `root` where she is the steward, her steward otherwise. */
+    async describe({ role = this.id === STEWARD ? 'root' : STEWARD } = {}) {
+        const answered = await this.#bench.through(this.id, role, undefined, undefined, {});
+        return answered !== null && 'describe' in answered ? answered.describe : null;
+    }
+    /** Her cells as they stand. */
+    cells() {
+        return this.#bench.cellsOf(this.id);
+    }
+}
+export class Bench {
+    clock;
+    #author;
+    #tester;
+    #standings = new Map();
+    #steward;
+    #public;
+    #stranger;
+    #count = 0;
+    constructor(clock, author, tester, placed, stranger) {
+        this.clock = clock;
+        this.#author = author;
+        this.#tester = tester;
+        this.#steward = placed.steward;
+        this.#public = placed.public;
+        this.#stranger = stranger;
+    }
+    static async open({ classes, offers = [], seed = 'bench', steward, public: open }) {
+        const clock = new FakeClock();
+        const network = new Map();
+        const house = async (name, list, handed) => {
+            const crypto = new SeededCrypto(`${seed}:${name}`);
+            const carry = new FakeCarry({ network, address: `bench://${name}` });
+            const opened = await openForBench({ keys: new FakeKeys(`${seed}:${name}`, crypto), memory: new FakeMemory(), classes: list, carry, clock, crypto, tools }, handed);
+            carry.listen(opened.opened);
+            return opened;
+        };
+        const author = await house('author', new ClassList({ steward: steward ?? BenchSteward, ...(open === undefined ? {} : { public: open }), beings: classes }), offers);
+        const tester = await house('bench', new ClassList({ steward: BenchTester }), []);
+        // The stranger's key, drawn from the seed, so a re-run signs as the first run did.
+        const crypto = new SeededCrypto(`${seed}:stranger`);
+        const stranger = { room: new Room(new FakeKeys(`${seed}:stranger`, crypto), crypto, tools), secret: tools.hex(crypto.random(32)) };
+        return new Bench(clock, author, tester, { steward, public: open }, stranger);
+    }
+    /**
+     * Her class here: the steward or the public being where the bench opened
+     * with her there, and otherwise borne, from her `born` or from the cells
+     * an example starts from.
+     */
+    async place(Class, { id, cells, born } = {}) {
+        const table = resolve(Class);
+        const position = Class === this.#steward ? STEWARD : Class === this.#public ? PUBLIC : undefined;
+        const name = position ?? id ?? `placed-${++this.#count}`;
+        if (position === undefined)
+            await this.#author.access.bear(table.kind, name, born);
+        await this.settle();
+        if (cells !== undefined) {
+            const patched = await this.#author.access.patch(name, (row) => {
+                row.cells = { ...row.cells, ...cells };
+            });
+            if (!patched)
+                throw new Error('memory refused the example’s cells');
+        }
+        return new Placed(this, name, table);
+    }
+    /** Lets every ask, effect and reply the houses started run to its end. */
+    async settle() {
+        await settle();
+    }
+    /** The clock moved on, and what came due run. */
+    async advance(ms) {
+        this.clock.advance(ms);
+        await this.settle();
+    }
+    cellsOf(being) {
+        return this.#author.access.cells(being);
+    }
+    // Who plays a role. On the public being, a role `stranger` holds is played
+    // by a box with the zero head. A role `root` holds is played through the
+    // hand, on any being. Otherwise an occupant named for it plays it, the
+    // role true in both sets of notes. A handle is admitted to one ask;
+    // `being` is introduced; `steward` is hers.
+    async through(being, role, ask, method, args) {
+        const holds = async (asker) => role === asker || (await this.#author.access.roles(being, asker)).includes(role);
+        const played = being === PUBLIC && (await holds('stranger')) ? this.#zero(method, args) : (await holds('root')) ? this.#hand(being, method, args) : undefined;
+        if (played !== undefined) {
+            const answered = await played;
+            await this.settle();
+            return answered;
+        }
+        const occupant = role === 'handle' ? `handle:bench-${ask}` : role === 'being' ? 'being:bench' : role;
+        const key = `${being}\n${occupant}`;
+        let standing = this.#standings.get(key);
+        if (standing === undefined) {
+            const notes = role === STEWARD || role === 'being' || role === 'handle' ? {} : { [role]: true };
+            const invitation = await this.#author.access.occupant(being, occupant, { notes, steward: notes, ...(role === 'handle' ? { ask: ask } : {}) });
+            const adopted = await this.#tester.opened.ask({ method: 'adopt', args: { invitation } });
+            if (!('result' in adopted))
+                throw new Error(`the bench could not hold ${role}: ${JSON.stringify(adopted)}`);
+            standing = adopted.result;
+            this.#standings.set(key, standing);
+        }
+        const answered = await this.#tester.access.far(STEWARD, standing, method, args);
+        await this.settle();
+        return answered;
+    }
+    // A being asked by the holder of the house's hand, which no box carries.
+    #hand(being, method, args) {
+        return this.#author.opened.ask({ id: being, ...(method === undefined ? {} : { method, args }) });
+    }
+    // The public being asked by a stranger: a box with the zero head, signed with the bench's stranger key.
+    async #zero(method, args) {
+        const { room, secret } = this.#stranger;
+        const ward = this.#author.opened.ward;
+        const sealed = await room.stranger(ward, secret, { ...(method === undefined ? {} : { method }), args: tools.canonical(args) });
+        const read = await room.strangerRead(ward, sealed.lid, await this.#author.opened.door(sealed.box));
+        if (!('object' in read))
+            return null;
+        return method === undefined ? { describe: read.object } : read.object;
+    }
+    /** Every example of her class run, twice, on two fresh benches. */
+    static async examples(Class, options = {}) {
+        const table = resolve(Class);
+        const where = { ...options, seed: options.seed ?? 'examples' };
+        const findings = [];
+        for (const entry of Object.values(table.asks)) {
+            for (const [index, raw] of entry.examples.entries()) {
+                const example = raw;
+                const what = `${entry.method}, example ${index + 1}${example.description === undefined ? '' : `: ${example.description}`}`;
+                try {
+                    const first = await Bench.#run(Class, table, entry, example, where);
+                    const second = await Bench.#run(Class, table, entry, example, where);
+                    if (example.gives !== undefined && tools.canonical(first.answer) !== tools.canonical(example.gives)) {
+                        findings.push({ ok: false, what, why: `it gives ${JSON.stringify(first.answer)}, and the example says ${JSON.stringify(example.gives)}` });
+                    }
+                    else if (tools.canonical(first) !== tools.canonical(second)) {
+                        findings.push({ ok: false, what, why: 'a re-run on the same cells answered differently' });
+                    }
+                    else
+                        findings.push({ ok: true, what });
+                }
+                catch (error) {
+                    findings.push({ ok: false, what, why: error instanceof Error ? error.message : String(error) });
+                }
+            }
+        }
+        return findings;
+    }
+    // A fresh bench with her in the position the check names, and the steward beside her where one is given.
+    static #opening(Class, table, example, { classes = [], seed, position = 'normal', steward }) {
+        return Bench.open({
+            classes: position === 'normal' ? [Class, ...classes] : classes,
+            offers: fakes(table, example),
+            ...(seed === undefined ? {} : { seed }),
+            ...(position === 'steward' ? { steward: Class } : steward === undefined ? {} : { steward }),
+            ...(position === 'public' ? { public: Class } : {}),
+        });
+    }
+    static async #run(Class, table, entry, example, options) {
+        const bench = await Bench.#opening(Class, table, example, options);
+        const placed = await bench.place(Class, example.cells === undefined ? {} : { cells: example.cells });
+        const answer = await placed.ask(entry.method, example.args ?? {}, example.role === undefined ? {} : { role: example.role });
+        return { answer: answer ?? { nothing: true }, cells: await placed.cells() };
+    }
+    /**
+     * Every state her default cells and her examples reach, described to
+     * every role she names: what each is shown is what her table says.
+     */
+    static async walk(Class, options = {}) {
+        const table = resolve(Class);
+        const where = { ...options, seed: options.seed ?? 'walk' };
+        const position = options.position ?? 'normal';
+        const findings = [];
+        const starts = [undefined, ...Object.values(table.asks).flatMap((entry) => entry.examples.map((example) => example.cells))];
+        const seen = new Set();
+        // Each role her position lets someone hold: the steward has no steward, and only the public being has strangers.
+        const roles = [...new Set([STEWARD, ...Object.keys(table.roles), ...Object.values(table.asks).flatMap((entry) => entry.for ?? [])])].filter((role) => role !== 'handle' && (role !== 'stranger' || position === 'public') && (role !== STEWARD || position !== 'steward'));
+        for (const cells of starts) {
+            // One visit a state, from the first cells that reach it.
+            const state = table.state({ id: '', position, cells: { ...table.cells, ...cells } });
+            if (seen.has(state))
+                continue;
+            seen.add(state);
+            const bench = await Bench.#opening(Class, table, {}, where);
+            const placed = await bench.place(Class, cells === undefined ? {} : { cells });
+            // The roles a stranger holds, to whom a public being never shows an effect.
+            const strange = position === 'public' ? await bench.#author.access.roles(PUBLIC, 'stranger') : [];
+            for (const role of roles) {
+                const what = `${state}, as ${role}`;
+                const described = await placed.describe({ role });
+                const shown = (described?.asks ?? []).map((entry) => entry.method).sort();
+                const owed = Object.values(table.asks)
+                    .filter((entry) => !(entry.effect && (role === 'stranger' || strange.includes(role))))
+                    .filter((entry) => (entry.for === null ? true : entry.for.includes(role)))
+                    .map((entry) => entry.method)
+                    .sort();
+                if (described === null)
+                    findings.push({ ok: false, what, why: 'she answered nothing' });
+                else if (described.state !== state)
+                    findings.push({ ok: false, what, why: `she says ${described.state}` });
+                else if (shown.join() !== owed.join())
+                    findings.push({ ok: false, what, why: `she shows ${shown.join(', ') || 'nothing'}, and her table owes ${owed.join(', ') || 'nothing'}` });
+                else
+                    findings.push({ ok: true, what });
+            }
+        }
+        return findings;
+    }
+    /** Her examples and her walk, and an error naming every finding that failed. */
+    static async check(Class, options = {}) {
+        const findings = [...(await Bench.examples(Class, options)), ...(await Bench.walk(Class, options))];
+        const failed = findings.filter((finding) => !finding.ok);
+        if (failed.length > 0)
+            throw new Error(`the bench found ${failed.length}:\n${failed.map((finding) => `- ${finding.what}: ${finding.why}`).join('\n')}`);
+        return findings;
+    }
+}
+// A fake of each faculty her needs name, answering what an example says,
+// and `{ result: null }` where it says nothing.
+const fakes = (table, example) => Object.entries(table.needs).map(([member, blueprint]) => {
+    const said = example.fakes?.[member] ?? {};
+    const object = Object.fromEntries(Object.keys(blueprint.methods).map((method) => [method, async () => said[method] ?? { result: null }]));
+    return { blueprint: blueprintOf(blueprint) ?? blueprint, object, kinds: [table.kind] };
+});

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

@@ -0,0 +1,32 @@
+import type { Carry, Sent } from '../foundation.ts';
+export type Door = (box: Uint8Array) => Promise<Uint8Array | null>;
+export declare class FakeCarry implements Carry {
+    #private;
+    /** The next `lose` replies are lost after the far door answered. */
+    lose: number;
+    /** Every address a box was carried to, in order. */
+    readonly tried: string[];
+    /** `at` names the addresses written into invitations, as a ground names its own; omitted, the one it listens at. */
+    constructor({ network, address, at }: {
+        network: Map<string, Door>;
+        address: string;
+        at?: readonly string[];
+    });
+    /** A house's door answers at this carry's address, and by pointer to whoever sends through this carry. */
+    listen({ ward, door }: {
+        ward: string;
+        door: Door;
+    }): void;
+    /** A ward this carry answers no more, by pointer or at its address. */
+    unlisten({ ward }: {
+        ward: string;
+    }): void;
+    send({ ward, at, box }: {
+        ward: string;
+        at: readonly string[];
+        box: Uint8Array;
+    }): Promise<Sent>;
+    at(_options?: {
+        toward?: string;
+    }): readonly string[];
+}

package/dist/bench/fake-carry.js

@@ -0,0 +1,56 @@
+export class FakeCarry {
+    #network;
+    #address;
+    #at;
+    /** The next `lose` replies are lost after the far door answered. */
+    lose = 0;
+    /** Every address a box was carried to, in order. */
+    tried = [];
+    /** `at` names the addresses written into invitations, as a ground names its own; omitted, the one it listens at. */
+    constructor({ network, address, at }) {
+        this.#network = network;
+        this.#address = address;
+        this.#at = at;
+    }
+    #doors = new Map();
+    /** A house's door answers at this carry's address, and by pointer to whoever sends through this carry. */
+    listen({ ward, door }) {
+        this.#doors.set(ward, door);
+        this.#network.set(this.#address, door);
+    }
+    /** A ward this carry answers no more, by pointer or at its address. */
+    unlisten({ ward }) {
+        const door = this.#doors.get(ward);
+        this.#doors.delete(ward);
+        if (door !== undefined && this.#network.get(this.#address) === door)
+            this.#network.delete(this.#address);
+    }
+    async send({ ward, at, box }) {
+        const held = this.#doors.get(ward);
+        if (held !== undefined) {
+            const reply = await held(box);
+            if (reply !== null)
+                return { reply };
+        }
+        for (const address of at) {
+            const door = this.#network.get(address);
+            if (door === undefined)
+                continue;
+            this.tried.push(address);
+            const reply = await door(box);
+            // A reply lost after the door answered was heard, so no other address is tried.
+            if (this.lose > 0) {
+                this.lose--;
+                return { reply: null, heard: true };
+            }
+            // A door that gives nothing was not delivered to, so the next address may be.
+            if (reply === null)
+                continue;
+            return { reply, via: address };
+        }
+        return { reply: null, heard: false };
+    }
+    at(_options = {}) {
+        return this.#at ?? [this.#address];
+    }
+}

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

@@ -0,0 +1,17 @@
+import type { Clock } from '../foundation.ts';
+export declare class FakeClock implements Clock {
+    #private;
+    constructor(start?: number);
+    now(): number;
+    wait({ id, ms }: {
+        id: string;
+        ms: number;
+    }): Promise<boolean>;
+    cancel({ id }: {
+        id: string;
+    }): void;
+    /** The time moved on, and every wait it passes fired, earliest first. */
+    advance(ms: number): void;
+    /** The time of the earliest wait, or `null`. */
+    next(): number | null;
+}

package/dist/bench/fake-clock.js

@@ -0,0 +1,34 @@
+export class FakeClock {
+    #now;
+    #waits = new Map();
+    constructor(start = Date.UTC(2026, 0, 1)) {
+        this.#now = start;
+    }
+    now() {
+        return this.#now;
+    }
+    wait({ id, ms }) {
+        this.#waits.get(id)?.resolve(false);
+        return new Promise((resolve) => {
+            this.#waits.set(id, { at: this.#now + Math.max(0, ms), resolve });
+        });
+    }
+    cancel({ id }) {
+        this.#waits.get(id)?.resolve(false);
+        this.#waits.delete(id);
+    }
+    /** The time moved on, and every wait it passes fired, earliest first. */
+    advance(ms) {
+        this.#now += ms;
+        const due = [...this.#waits].filter(([, waiting]) => waiting.at <= this.#now).sort(([, a], [, b]) => a.at - b.at);
+        for (const [id, waiting] of due) {
+            this.#waits.delete(id);
+            waiting.resolve(true);
+        }
+    }
+    /** The time of the earliest wait, or `null`. */
+    next() {
+        const times = [...this.#waits.values()].map((waiting) => waiting.at);
+        return times.length === 0 ? null : Math.min(...times);
+    }
+}

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

@@ -0,0 +1,9 @@
+import type { Custody } from '../ground/ground.ts';
+import type { Keys } from '../foundation.ts';
+export declare class FakeCustody implements Custody {
+    #private;
+    constructor(seed?: string);
+    keys({ house }: {
+        house: string;
+    }): Keys;
+}

package/dist/bench/fake-custody.js

@@ -0,0 +1,10 @@
+import { FakeKeys } from './fake-keys.js';
+export class FakeCustody {
+    #seed;
+    constructor(seed = 'custody') {
+        this.#seed = seed;
+    }
+    keys({ house }) {
+        return new FakeKeys(`${this.#seed}:${house}`);
+    }
+}

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

@@ -0,0 +1,25 @@
+import type { Json } from '../being/being.ts';
+import type { Faculty } from '../ground/ground.ts';
+type Method = (args: Json) => Json | Promise<Json>;
+/** One call the faculty received. */
+export interface Called {
+    readonly method: string;
+    readonly args: Json;
+    readonly id: string;
+}
+export declare class FakeFaculty {
+    #private;
+    /** Every call, in the order it came, repeats of one call id among them. */
+    readonly calls: Called[];
+    /** `blueprint` is a need or a blueprint; `methods` answer each method's args with its result. */
+    constructor(blueprint: unknown, methods: Readonly<Record<string, Method>>);
+    /** The next `count` calls throw, as a crash does. */
+    throwNext(count?: number): void;
+    /** The next call answers `{ error: { message } }`, which is final. */
+    refuseNext(message: string): void;
+    /** The next `count` calls never answer. */
+    hangNext(count?: number): void;
+    /** The offer a ground hands: the blueprint, and an object whose methods take args and a context. */
+    get offer(): Faculty;
+}
+export {};

package/dist/bench/fake-faculty.js

@@ -0,0 +1,48 @@
+export class FakeFaculty {
+    /** Every call, in the order it came, repeats of one call id among them. */
+    calls = [];
+    #blueprint;
+    #methods;
+    #throw = 0;
+    #refuse = [];
+    #hang = 0;
+    /** `blueprint` is a need or a blueprint; `methods` answer each method's args with its result. */
+    constructor(blueprint, methods) {
+        this.#blueprint = blueprint;
+        this.#methods = methods;
+    }
+    /** The next `count` calls throw, as a crash does. */
+    throwNext(count = 1) {
+        this.#throw += count;
+    }
+    /** The next call answers `{ error: { message } }`, which is final. */
+    refuseNext(message) {
+        this.#refuse.push(message);
+    }
+    /** The next `count` calls never answer. */
+    hangNext(count = 1) {
+        this.#hang += count;
+    }
+    /** The offer a ground hands: the blueprint, and an object whose methods take args and a context. */
+    get offer() {
+        const object = Object.fromEntries(Object.entries(this.#methods).map(([method, answer]) => [
+            method,
+            async (args, context) => {
+                this.calls.push({ method, args, id: context.id });
+                if (this.#hang > 0) {
+                    this.#hang--;
+                    return new Promise(() => undefined);
+                }
+                if (this.#throw > 0) {
+                    this.#throw--;
+                    throw new Error('the fake faculty crashed');
+                }
+                const refused = this.#refuse.shift();
+                if (refused !== undefined)
+                    return { error: { message: refused } };
+                return { result: await answer(args) };
+            },
+        ]));
+        return { blueprint: this.#blueprint, object };
+    }
+}

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

@@ -0,0 +1,5 @@
+import { SeedKeys } from '../bodies/seed-keys.ts';
+import type { Crypto } from '../foundation.ts';
+export declare class FakeKeys extends SeedKeys {
+    constructor(name?: string, crypto?: Crypto);
+}

package/dist/bench/fake-keys.js

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: Apache-2.0
+// Keys from a name: every ward of a test named, and the same each run.
+import { SeedKeys } from '../bodies/seed-keys.js';
+import { seedOf } from './seeded.js';
+export class FakeKeys extends SeedKeys {
+    constructor(name = 'fake', crypto) {
+        super(seedOf(name), crypto);
+    }
+}

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

@@ -0,0 +1,14 @@
+import type { Memory, PlaceRead } from '../foundation.ts';
+export declare class FakeMemory implements Memory {
+    #private;
+    /** The next `count` writes are refused, as a memory another writer moved. */
+    refuseNext(count?: number): void;
+    read({ place }: {
+        place: string;
+    }): Promise<PlaceRead>;
+    list(): Promise<readonly string[]>;
+    write({ writes, expect, }: {
+        writes: Readonly<Record<string, Readonly<Record<string, Uint8Array | null>>>>;
+        expect: Readonly<Record<string, string | null>>;
+    }): Promise<Readonly<Record<string, string | null>> | null>;
+}

package/dist/bench/fake-memory.js

@@ -0,0 +1,46 @@
+export class FakeMemory {
+    #places = new Map();
+    #refuse = 0;
+    /** The next `count` writes are refused, as a memory another writer moved. */
+    refuseNext(count = 1) {
+        this.#refuse += count;
+    }
+    async read({ place }) {
+        const held = this.#places.get(place);
+        if (held === undefined)
+            return { entries: {}, version: null };
+        return { entries: Object.fromEntries([...held.entries].map(([name, bytes]) => [name, bytes.slice()])), version: String(held.version) };
+    }
+    async list() {
+        return [...this.#places.keys()];
+    }
+    async write({ writes, expect, }) {
+        if (this.#refuse > 0) {
+            this.#refuse--;
+            return null;
+        }
+        for (const place of new Set([...Object.keys(writes), ...Object.keys(expect)])) {
+            const held = this.#places.get(place);
+            const version = held === undefined ? null : String(held.version);
+            if (!(place in expect) || expect[place] !== version)
+                return null;
+        }
+        const versions = {};
+        for (const [place, entries] of Object.entries(writes)) {
+            const held = this.#places.get(place) ?? { entries: new Map(), version: 0 };
+            for (const [name, bytes] of Object.entries(entries)) {
+                if (bytes === null)
+                    held.entries.delete(name);
+                else
+                    held.entries.set(name, bytes.slice());
+            }
+            held.version++;
+            if (held.entries.size === 0)
+                this.#places.delete(place);
+            else
+                this.#places.set(place, held);
+            versions[place] = held.entries.size === 0 ? null : String(held.version);
+        }
+        return versions;
+    }
+}