nervur 0.19.2 → 0.20.0

package/dist/being/lent.d.ts

@@ -1,32 +0,0 @@
-import { Being } from './being.ts';
-import type { Asker, Blueprint, JsonObject, Reply } from './types.ts';
-export declare const BOX = "box";
-export declare const LENT_ASKS: {
-    offer: {
-        name: string;
-        description: string;
-        input: {
-            type: string;
-        };
-    };
-    retract: {
-        name: string;
-        description: string;
-        input: {
-            type: string;
-            properties: {
-                heir: {
-                    type: string;
-                };
-            };
-            required: string[];
-        };
-    };
-};
-export declare class Lent extends Being {
-    #private;
-    offer(): Promise<JsonObject>;
-    retract(args: JsonObject): JsonObject;
-    describe(asker: Asker): Blueprint;
-    answer(asker: Asker, method?: string, args?: JsonObject): Promise<Reply>;
-}

package/dist/being/lent.js

@@ -1,72 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// A lent being: a being of the box's own ward, standing for one thing the
-// device can do. What makes her one is two asks the box's being alone may
-// make, whom she knows as the occupant `box`. `offer`: she mints an
-// invitation on herself and answers it, so that a ward the box vouches for
-// may knock and take a standing at her. `retract`: an offer that was not
-// taken, named by its heir, is removed, so a refused lend leaves nothing.
-//
-// The two are the base's and never a subclass's to declare: a class says
-// her own asks and nothing of the seam she is lent through, so they are
-// answered here before her asks are read, and shown to the box alone. No
-// root mints for her, and nothing else about her is decided here.
-//
-// A convenience, not a contract: a being that answers the two the same way
-// to `box` is lendable, whatever she extends.
-import { Being } from './being.js';
-// The one word for the box's being: her key in the box's ward, the id every
-// lent being knows her by, and the standing every hosted ward takes at
-// birth.
-export const BOX = 'box';
-export const LENT_ASKS = {
-    offer: { name: 'offer', description: 'an invitation on me, for a ward the box vouches for', input: { type: 'object' } },
-    retract: { name: 'retract', description: 'an offer that was not taken, by its heir', input: { type: 'object', properties: { heir: { type: 'string' } }, required: ['heir'] } },
-};
-export class Lent extends Being {
-    // The offers she has open, heir to the id she minted under.
-    #open() {
-        return (this.cells.open ??= {});
-    }
-    async offer() {
-        const n = (this.cells.lent ?? 0) + 1;
-        this.cells.lent = n;
-        const id = `lent:${n}`;
-        const inv = await this.invite(id);
-        if (inv === null)
-            return { error: 'could not mint' };
-        this.#open()[inv.heir] = id;
-        return inv;
-    }
-    retract(args) {
-        const open = this.#open();
-        const heir = typeof args.heir === 'string' ? args.heir : '';
-        const id = Object.hasOwn(open, heir) ? open[heir] : undefined;
-        if (id === undefined)
-            return { retracted: null };
-        this.occupants.remove(id);
-        delete open[heir];
-        return { retracted: id };
-    }
-    describe(asker) {
-        const bp = super.describe(asker);
-        if (asker.id !== BOX)
-            return bp;
-        return { ...bp, asks: [...bp.asks, LENT_ASKS.offer, LENT_ASKS.retract] };
-    }
-    // An offer is open until it is taken or retracted. The taker's knock is the
-    // first word she hears from the occupant she minted for it, so hearing
-    // from that id closes the offer, and `open` holds only offers still
-    // waiting and not every lend she ever made.
-    async answer(asker, method, args = {}) {
-        const open = this.cells.open;
-        if (open && asker.id !== undefined && asker.id !== BOX)
-            for (const [heir, id] of Object.entries(open))
-                if (id === asker.id)
-                    delete open[heir];
-        if (asker.id === BOX && method === 'offer')
-            return this.offer();
-        if (asker.id === BOX && method === 'retract')
-            return this.retract(args);
-        return super.answer(asker, method, args);
-    }
-}

package/dist/being/silence.d.ts

@@ -1,12 +0,0 @@
-import { type DoorWord, type Unreached, type Word, type WordName } from './types.ts';
-export declare const silence: unique symbol;
-export declare const isSilence: (x: unknown) => x is typeof silence;
-export declare const DOOR_WORDS: readonly DoorWord[];
-export declare const isDoorWord: (s: unknown) => s is DoorWord;
-export declare const word: <W extends WordName>(name: W) => Word<W>;
-export declare const isWord: (x: unknown) => x is Word;
-export declare const wordOf: (x: Word) => WordName;
-export declare const answered: <T>(x: T) => x is Exclude<T, typeof silence | Word>;
-export declare const told: (x: unknown) => unknown;
-export declare const unreached: () => Unreached;
-export declare const isUnreached: (x: unknown) => x is Unreached;

package/dist/being/silence.js

@@ -1,41 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// Silence is one distinguished value. Null is an answer. Silence is no answer.
-//
-// The ward's words are the other distinguished values: what her ward tells
-// her when no object came back and it knows why. Each is one frozen object
-// under one symbol key, so a being cannot make one by accident, none of them
-// crosses an edge as a value, and a being who compares against them needs
-// no fourth shape. `unreached` is one of them.
-import { WORD_KEY } from './types.js';
-export const silence = Symbol.for('quo.silence');
-export const isSilence = (x) => x === silence;
-// The words a door says to a key it has bound, and no other. They ride on
-// the wire as `{ quo: word }`, so a reply is checked against this list.
-export const DOOR_WORDS = ['removed', 'absent', 'unannounced', 'repeated', 'threw'];
-export const isDoorWord = (s) => typeof s === 'string' && DOOR_WORDS.includes(s);
-const WORDS = new Map();
-export const word = (name) => {
-    let w = WORDS.get(name);
-    if (!w)
-        WORDS.set(name, (w = Object.freeze({ [WORD_KEY]: name })));
-    return w;
-};
-export const isWord = (x) => x !== null && typeof x === 'object' && typeof x[WORD_KEY] === 'string';
-export const wordOf = (x) => x[WORD_KEY];
-// What came back is an answer and not one of the two things that are not
-// answers. A being who only wants the object writes one test instead of
-// three, and the three shapes stay three shapes: silence is no answer, a word
-// is her ward telling her why there is none.
-export const answered = (x) => !isSilence(x) && !isWord(x);
-// What she was told, with a word given its name and everything else left
-// exactly as it came. One value to compare against, so asking which word came
-// back is one test and not two joined by an and: `told(out) === 'late'` says
-// what `isWord(out) && wordOf(out) === 'late'` says, and says which answer
-// arrived instead when it is wrong, where the pair collapses to false and
-// names nothing. Silence stays the symbol it is, and an object stays itself.
-export const told = (x) => (isWord(x) ? wordOf(x) : x);
-// Unreached: no far door was reached. Nothing is known to have been
-// delivered, so asking again is safe. A being cannot produce it: a ward that
-// sees a word come out of a being reads it as her having thrown.
-export const unreached = () => word('unreached');
-export const isUnreached = (x) => isWord(x) && wordOf(x) === 'unreached';

package/dist/conformance/assert.d.ts

@@ -1,11 +0,0 @@
-export declare class Failed extends Error {
-}
-export declare function same(a: unknown, b: unknown): boolean;
-export type Assert = {
-    ok(value: unknown, message?: string): asserts value;
-    equal(actual: unknown, expected: unknown, message?: string): void;
-    notEqual(actual: unknown, expected: unknown, message?: string): void;
-    deepEqual(actual: unknown, expected: unknown, message?: string): void;
-    match(actual: string, re: RegExp, message?: string): void;
-};
-export declare const assert: Assert;

package/dist/conformance/assert.js

@@ -1,106 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// The five assertions the conformance suite makes, and no more. Node has all
-// five in `node:assert/strict`, and naming that module would tie the suite to
-// one terrain -- the suite is the ward's truth, and the ward's truth has to be
-// checkable wherever a ward runs. So they are written here, in the language
-// alone, and `test/assert.test.ts` holds them to Node's own behaviour.
-export class Failed extends Error {
-}
-const show = (v) => {
-    if (typeof v === 'symbol')
-        return v.toString();
-    if (typeof v === 'bigint')
-        return `${v}n`;
-    if (v === undefined)
-        return 'undefined';
-    if (typeof v === 'function')
-        return `[function ${v.name}]`;
-    // A ward's word is a frozen object under one symbol key, and JSON shows it
-    // as `{}`. A red estate chapter saying `{} is not {}` names nothing, so a
-    // value whose own keys are all symbols is shown by its keys.
-    if (v !== null && typeof v === 'object') {
-        const keys = Object.keys(v);
-        const syms = Object.getOwnPropertySymbols(v).filter((s) => Object.getOwnPropertyDescriptor(v, s).enumerable);
-        if (keys.length === 0 && syms.length > 0)
-            return `{ ${syms.map((s) => `${s.toString()}: ${show(v[s])}`).join(', ')} }`;
-    }
-    try {
-        return JSON.stringify(v) ?? Object.prototype.toString.call(v);
-    }
-    catch {
-        return Object.prototype.toString.call(v); // a cycle, or a null prototype
-    }
-};
-const fail = (why, message) => {
-    throw new Failed(message ? `${message}: ${why}` : why);
-};
-// Structural, and strict about shape the way `node:assert/strict` is: a value
-// is not equal to one of another kind, and an array is not equal to an object
-// that happens to hold the same keys.
-// The four kinds this compares, and every other object is refused rather than
-// guessed at. A Date, a RegExp, a boxed primitive and a class instance each
-// carry state no key walk can see, so two of them with the same keys are
-// equal here and unequal in node, which is a wrong yes: the one answer a
-// suite must never give. A refusal is a red test that says so.
-const KNOWN = [Object.prototype, null, Array.prototype, Uint8Array.prototype];
-// What node compares: own enumerable keys, strings then enumerable symbols.
-// Not `Reflect.ownKeys`, which also lists what a definition hid.
-const keysOf = (v) => [...Object.keys(v), ...Object.getOwnPropertySymbols(v).filter((s) => Object.getOwnPropertyDescriptor(v, s).enumerable)];
-export function same(a, b) {
-    if (Object.is(a, b))
-        return true;
-    if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null)
-        return false;
-    const proto = Object.getPrototypeOf(a);
-    if (proto !== Object.getPrototypeOf(b))
-        return false;
-    if (!KNOWN.includes(proto))
-        return false; // a Date, a RegExp, a boxed number, a class of hers
-    if (Array.isArray(a) !== Array.isArray(b))
-        return false;
-    if (a instanceof Uint8Array && b instanceof Uint8Array)
-        return a.length === b.length && a.every((x, i) => x === b[i]);
-    // An array is its indices and whatever else was hung on it, and a hole is
-    // not a present undefined: `[, 1]` and `[undefined, 1]` differ in node and
-    // must differ here. `every` skips holes, so the loop is written out.
-    if (Array.isArray(a) && Array.isArray(b)) {
-        if (a.length !== b.length)
-            return false;
-        for (let i = 0; i < a.length; i += 1) {
-            if (i in a !== i in b)
-                return false;
-            if (i in a && !same(a[i], b[i]))
-                return false;
-        }
-        const extra = (v) => keysOf(v).filter((k) => typeof k !== 'string' || !/^(?:0|[1-9]\d*)$/.test(k));
-        const xa = extra(a), xb = extra(b);
-        const at = (v, k) => v[k];
-        return xa.length === xb.length && xa.every((k) => xb.includes(k) && same(at(a, k), at(b, k)));
-    }
-    const ka = keysOf(a), kb = keysOf(b);
-    if (ka.length !== kb.length)
-        return false;
-    return ka.every((k) => kb.includes(k) && same(a[k], b[k]));
-}
-export const assert = {
-    ok(value, message) {
-        if (!value)
-            fail(`${show(value)} is not truthy`, message);
-    },
-    equal(actual, expected, message) {
-        if (!Object.is(actual, expected))
-            fail(`${show(actual)} !== ${show(expected)}`, message);
-    },
-    notEqual(actual, expected, message) {
-        if (Object.is(actual, expected))
-            fail(`${show(actual)} === ${show(expected)}`, message);
-    },
-    deepEqual(actual, expected, message) {
-        if (!same(actual, expected))
-            fail(`${show(actual)} is not ${show(expected)}`, message);
-    },
-    match(actual, re, message) {
-        if (typeof actual !== 'string' || !re.test(actual))
-            fail(`${show(actual)} does not match ${String(re)}`, message);
-    },
-};

package/dist/conformance/beings.d.ts

@@ -1,199 +0,0 @@
-import { Being } from '../being/being.ts';
-import { Lent } from '../being/lent.ts';
-import type { Asker, Blueprint, Invitation, Json, JsonObject, OccupantRecord, Reply, Stance } from '../being/types.ts';
-export declare class Printer extends Being {
-    static cells: {
-        jobs: JsonObject[];
-        asks: JsonObject[];
-    };
-    static asks: {
-        print: {
-            input: {
-                type: string;
-            };
-        };
-    };
-    describe(): Blueprint;
-    print({ doc }: JsonObject, asker: Asker): {
-        printed: string | number | boolean | Json[] | {
-            [key: string]: Json;
-        } | null;
-    };
-}
-export declare class Shop extends Being {
-    static cells: {
-        printerId: string | null;
-        sales: JsonObject[];
-        minted: number;
-    };
-    static asks: {
-        hello: {
-            input: {
-                type: string;
-            };
-        };
-        buy: {
-            input: {
-                type: string;
-                properties: {
-                    item: {
-                        type: string;
-                    };
-                };
-            };
-        };
-        refund: {
-            input: {
-                type: string;
-            };
-            for: (rec: OccupantRecord | undefined) => boolean;
-        };
-    };
-    answer(asker: Asker, method?: string, args?: JsonObject): Promise<Reply>;
-    invite(tier?: string): Promise<Invitation>;
-    keepPrinter(invitation: Invitation): Promise<boolean>;
-    hello({ invitation }: JsonObject, asker: Asker): Promise<{
-        welcome: boolean;
-    }>;
-    buy({ item }: JsonObject, asker: Asker): Promise<{
-        error: string;
-        retry?: undefined;
-        ok?: undefined;
-        receipt?: undefined;
-    } | {
-        error: string;
-        retry: boolean;
-        ok?: undefined;
-        receipt?: undefined;
-    } | {
-        error?: undefined;
-        retry?: undefined;
-        ok: boolean;
-        receipt: Json;
-    }>;
-    refund(): {
-        ok: boolean;
-    };
-}
-export declare class Customer extends Being {
-    static cells: {
-        heard: JsonObject[];
-    };
-    static asks: {
-        hi: {
-            input: {
-                type: string;
-            };
-        };
-    };
-    join(invitation: Invitation): Promise<string | number | boolean | typeof import("../being/silence.ts").silence | Json[] | import("../being/types.ts").Word<import("../being/types.ts").WordName> | {
-        [key: string]: Json;
-    } | null>;
-    buy(item: string): Promise<import("../being/types.ts").Answer>;
-    learn(): Promise<import("../being/types.ts").Answer>;
-    hi(_args: JsonObject, asker: Asker): {
-        heard: string;
-    };
-}
-export declare class Echo {
-    s: Stance;
-    constructor(stance: Stance);
-    answer(asker: Asker, method?: string, args?: JsonObject): Reply;
-}
-export declare class Maker extends Being {
-    static cells: {
-        made: string[];
-    };
-    static asks: {
-        open: {
-            input: {
-                type: string;
-                properties: {
-                    class: {
-                        type: string;
-                    };
-                    key: {
-                        type: string;
-                    };
-                    id: {
-                        type: string;
-                    };
-                };
-                required: string[];
-            };
-        };
-        say: {
-            input: {
-                type: string;
-                properties: {
-                    id: {
-                        type: string;
-                    };
-                };
-                required: string[];
-            };
-        };
-        borrow: {
-            input: {
-                type: string;
-                properties: {
-                    name: {
-                        type: string;
-                    };
-                    id: {
-                        type: string;
-                    };
-                };
-                required: string[];
-            };
-        };
-    };
-    open({ class: className, key, id }: JsonObject): Promise<{
-        made: string | null;
-    }>;
-    say({ id }: JsonObject): Promise<{
-        said: Json;
-    }>;
-    borrow({ name, id }: JsonObject): Promise<{
-        lent: string | null;
-    }>;
-}
-export declare class Member extends Lent {
-    static cells: {
-        heard: JsonObject[];
-    };
-    static asks: {
-        ping: {
-            input: {
-                type: string;
-            };
-        };
-        relay: {
-            input: {
-                type: string;
-                properties: {
-                    id: {
-                        type: string;
-                    };
-                    method: {
-                        type: string;
-                    };
-                    time: {
-                        type: string;
-                    };
-                };
-                required: string[];
-            };
-        };
-    };
-    ping(_args: JsonObject, asker: Asker): {
-        pong: string | null;
-    };
-    relay({ id, method, args, time }: JsonObject): Promise<{
-        said: string;
-        out: null;
-    } | {
-        said: null;
-        out: Json;
-    }>;
-}

package/dist/conformance/beings.js

@@ -1,188 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// The fixture beings. Fixed, so that the ward is what varies. A printer, a
-// shop, a customer on the base class, a maker, a member, and one raw being
-// with no base at all.
-import { Being } from '../being/being.js';
-import { Lent } from '../being/lent.js';
-import { answered, isSilence, isUnreached, isWord, wordOf } from '../being/silence.js';
-import { invitationArgs } from '../being/types.js';
-// A printer. Invites whom she is told to, prints for her occupants. Her
-// blueprint lives in her cells so a test can change her shape.
-export class Printer extends Being {
-    static cells = { jobs: [], asks: [{ name: 'print', input: { type: 'object' } }] };
-    static asks = { print: { input: { type: 'object' } } };
-    describe() {
-        // Her own cells, which a test writes to change her shape. Cells are Json
-        // to the ward, so the asks are named for what she keeps in them.
-        return { asks: this.cells.asks, notes: { model: 'LX-2' } };
-    }
-    print({ doc }, asker) {
-        this.cells.jobs.push({ by: asker.id ?? null, doc: doc ?? null });
-        return { printed: doc ?? null };
-    }
-}
-// A shop. Invites customers in her own time. Keeps a printer as a standing.
-// Takes a gold customer back if the customer offers a way. Counts every ask
-// per occupant, by wrapping answer.
-export class Shop extends Being {
-    static cells = { printerId: null, sales: [], minted: 0 };
-    static asks = {
-        hello: { input: { type: 'object' } },
-        buy: { input: { type: 'object', properties: { item: { type: 'string' } } } },
-        refund: { input: { type: 'object' }, for: (rec) => rec?.notes.tier === 'gold' },
-    };
-    async answer(asker, method, args) {
-        const rec = this.occupant(asker);
-        if (rec && method !== undefined)
-            rec.notes.asks = (Number(rec.notes.asks) || 0) + 1;
-        return super.answer(asker, method, args);
-    }
-    // Outside any ask. She mints, her ward seals, she hands it out by mail.
-    async invite(tier = 'plain') {
-        const id = `cust${++this.cells.minted}`;
-        const inv = (await super.invite(id));
-        this.cells.occupants[id].notes.tier = tier;
-        return inv;
-    }
-    async keepPrinter(invitation) {
-        const bp = await this.knock(invitation);
-        if (!answered(bp))
-            return false;
-        this.cells.printerId = await this.take('prn', invitation);
-        return true;
-    }
-    async hello({ invitation }, asker) {
-        const rec = this.occupant(asker);
-        if (rec?.notes.tier === 'gold' && invitation) {
-            const back = await this.knock(invitation, 'hi');
-            if (answered(back))
-                await this.take(`vip-${asker.id}`, invitation);
-        }
-        return { welcome: true };
-    }
-    async buy({ item }, asker) {
-        if (typeof item !== 'string')
-            return { error: 'no such item' }; // args are hers to check
-        const id = this.cells.printerId;
-        const printer = id ? this.standings[id] : undefined;
-        if (!printer)
-            return { error: 'no printer' };
-        const out = await printer.ask('print', { doc: `receipt for ${item}` });
-        if (isUnreached(out))
-            return { error: 'printer unreachable', retry: true };
-        if (!answered(out))
-            return { error: 'printer refused' };
-        const st = this.cells.standings[id];
-        if (st.seen !== st.digest)
-            this.occupant(asker).notes.printerChanged = true;
-        this.cells.sales.push({ item: item ?? null, by: asker.id ?? null });
-        return { ok: true, receipt: out.printed };
-    }
-    refund() {
-        return { ok: true };
-    }
-}
-// A customer. Consumes an invitation, and only then decides to keep the
-// shop. Offers the shop a way back so the shop can reach her.
-export class Customer extends Being {
-    static cells = { heard: [] };
-    static asks = { hi: { input: { type: 'object' } } };
-    async join(invitation) {
-        // A way back for the shop, if she can mint one. She may not: two joins on
-        // one invitation race, and the second finds the id taken. Then she offers
-        // nothing and knocks all the same, which is what the shop is asked to
-        // survive. The old shape said `!` here and was wrong about it.
-        const mine = await this.invite('shop-back');
-        const out = await this.knock(invitation, 'hello', { invitation: mine === null ? null : invitationArgs(mine) });
-        if (!answered(out))
-            return out; // nothing was born
-        await this.take('shop', invitation); // now, and only now
-        return out;
-    }
-    buy(item) {
-        return this.standings.shop.ask('buy', { item });
-    }
-    learn() {
-        return this.standings.shop.ask();
-    }
-    hi(_args, asker) {
-        this.cells.heard.push({ from: asker.id ?? null, method: 'hi' });
-        return { heard: 'hi' };
-    }
-}
-// The raw shape. No base class, no import from the kit. A being all the same.
-export class Echo {
-    s;
-    constructor(stance) {
-        this.s = stance;
-    }
-    answer(asker, method, args = {}) {
-        if (method === undefined)
-            return { asks: [{ name: 'echo', input: {} }], notes: {} };
-        return { from: asker.id ?? null, ...args };
-    }
-}
-// A member of an estate. Nothing scripted: she invites whom she is told to,
-// knocks where she is told to, and answers `ping` with the asker's own name.
-// The estate chapter drives her, and what it drives is the graph, not her.
-// A being who makes beings. `boot` is on every stance, so it is the ward's
-// promise and not this kit's, and a second kit that never wired it hands its
-// beings a call that answers null for ever. She says what came of it: the key
-// back, or null for a key already taken, a class the harbor does not hold, or
-// a constructor that threw. With an id she also asks for a way back, and then
-// she holds a standing to what she made like any other.
-export class Maker extends Being {
-    static cells = { made: [] };
-    static asks = {
-        open: { input: { type: 'object', properties: { class: { type: 'string' }, key: { type: 'string' }, id: { type: 'string' } }, required: ['class', 'key'] } },
-        say: { input: { type: 'object', properties: { id: { type: 'string' } }, required: ['id'] } },
-        borrow: { input: { type: 'object', properties: { name: { type: 'string' }, id: { type: 'string' } }, required: ['name', 'id'] } },
-    };
-    async open({ class: className, key, id }) {
-        const made = await this.boot(className, key, id);
-        if (made !== null)
-            this.cells.made.push(made);
-        return { made };
-    }
-    async say({ id }) {
-        const standing = this.standings[id];
-        return { said: standing === undefined ? null : (await standing.ask('ping')) };
-    }
-    // Making's other half: a standing at something the box already has, by the
-    // name the box knows it under. She is handed the id and never the value.
-    async borrow({ name, id }) {
-        return { lent: await this.lend(name, id) };
-    }
-}
-// A member is also lendable: lent by a box that stands her in its own ward,
-// she offers an invitation on herself when the box's being asks, and is an
-// ordinary being to everyone else.
-export class Member extends Lent {
-    static cells = { ...Lent.cells, heard: [] };
-    static asks = {
-        ...Lent.asks,
-        ping: { input: { type: 'object' } },
-        relay: { input: { type: 'object', properties: { id: { type: 'string' }, method: { type: 'string' }, time: { type: 'number' } }, required: ['id'] } },
-    };
-    ping(_args, asker) {
-        this.cells.heard.push({ from: asker.id ?? null });
-        return { pong: asker.id ?? null };
-    }
-    // She asks on one of her standings from inside her own answer, and says
-    // what came back as a word rather than as the word itself, since a word is
-    // her ward's value and never a thing that crosses. `time` is what she is
-    // willing to wait, which is the whole of what the third argument is for.
-    // Two members holding each other and relaying make a cycle, and a cycle is
-    // how a suite that owns no clock can see a wait end.
-    async relay({ id, method, args, time }) {
-        const standing = this.standings[id];
-        if (standing === undefined)
-            return { said: 'no standing', out: null };
-        const out = await standing.ask(method, (args ?? {}), time === undefined ? undefined : { time: time });
-        if (isSilence(out))
-            return { said: 'silence', out: null };
-        if (isWord(out))
-            return { said: wordOf(out), out: null };
-        return { said: null, out: out };
-    }
-}

package/dist/conformance/estate.d.ts

@@ -1,5 +0,0 @@
-import type { Runner, World } from './index.ts';
-export declare function estate(label: string, make: () => Promise<World>, { canDown, test }: {
-    canDown: boolean;
-    test: Runner;
-}): void;