nervur 0.19.2 → 0.20.1

package/dist/harbor/dial.js

@@ -1,81 +0,0 @@
-import { REFUSED, Socket } from './reach.js';
-export function dial(harbor, url) {
-    const d = { url, socket: null, wake: () => { }, close: () => { } };
-    let stopped = false, wait = 1000, timer, line, // the line in hand, open or still opening: close() closes it either way
-    held; // the one this dialer owns now, and how it gives back what the line took
-    const connect = () => {
-        timer = undefined; // no wait pending: this is the dial it was waiting for
-        if (stopped)
-            return;
-        line = new WebSocket(url.replace(/\/$/, '').replace(/^http/, 'ws'));
-        const s = new Socket(line, (pk, bytes) => harbor.deliver(pk, bytes), (far) => {
-            // A line that opened is not a line that works. The wait goes back to
-            // a second here, where the far side has answered and been taken, and
-            // not at the handshake: a listener that opens and then refuses every
-            // time would otherwise be dialed at a fixed two seconds for good.
-            wait = 1000;
-            void harbor.bind(far, s, false); // the listener's claims, each proven at its door: reached through this socket, not held for others
-        }, (why) => {
-            shed();
-            // A line this dialer already put down. Its close arrives whenever the
-            // system gets round to noticing, which on a socket that died under a
-            // sleeping device is minutes; by then the line dialed in its place is
-            // the one in hand, so this one gives back what it took and dials
-            // nothing. Only the line the dialer still holds dials again.
-            if (held?.socket !== s)
-                return;
-            held = undefined;
-            // A suite this listener will not speak is not a line that dropped. It
-            // will not become speakable by asking again sooner, so the wait goes
-            // straight to the ceiling and stays there until it changes its mind.
-            if (why.code === REFUSED)
-                wait = 30000;
-            if (!stopped)
-                timer = setTimeout(connect, wait);
-            wait = Math.min(wait * 2, 30000);
-        });
-        // Everything this line took from the harbor, given back. Said when it
-        // closes, and when the dialer puts it down without waiting for that.
-        const shed = () => {
-            harbor.announcers.delete(say);
-            harbor.unbind(s);
-            if (d.socket === s)
-                d.socket = null;
-            const at = harbor.fallbacks.indexOf(s);
-            if (at !== -1)
-                harbor.fallbacks.splice(at, 1); // this line only: another dialer's stays
-        };
-        held = { socket: s, shed };
-        harbor.fallbacks.push(s); // from the moment it is dialed: an ask made before the handshake waits on the socket, and is not unreached
-        // What this harbor holds, said when the line opens and again whenever it
-        // changes. A ward booted or adopted after the handshake is announced on
-        // the line already in hand, and a dropped one stops being claimed at once.
-        const say = () => s.announce([...harbor.doors.keys()]);
-        line.addEventListener('open', () => {
-            if (stopped)
-                return s.close(); // closed while it was opening: it opens into nothing
-            d.socket = s;
-            harbor.announcers.add(say);
-            say();
-        });
-    };
-    d.wake = () => {
-        if (stopped)
-            return;
-        clearTimeout(timer);
-        timer = undefined;
-        wait = 1000; // the device is back, and the wait it froze belongs to the sleep, not to this line
-        const old = held;
-        held = undefined; // put down before the new one is dialed, so a fallback list never holds the dead line ahead of the live one
-        old?.shed();
-        old?.socket.close();
-        connect();
-    };
-    d.close = () => {
-        stopped = true;
-        clearTimeout(timer);
-        line?.close(); // open or opening: a line closed while connecting fires close and never open
-    };
-    connect();
-    return d;
-}

package/dist/harbor/memory.d.ts

@@ -1,29 +0,0 @@
-import type { BeingClass, BeingLike, Invitation } from '../being/types.ts';
-import { type Ground, type WardPointers } from '../ward/ground.ts';
-export type Booted = WardPointers & {
-    pk: string;
-};
-export type WardFactory = (ground: Ground) => Promise<WardPointers>;
-export declare class MemoryHarbor {
-    readonly doors: Map<string, (bytes: Uint8Array) => Promise<{
-        bytes: Uint8Array;
-        heard: boolean;
-    }>>;
-    readonly down: Set<string>;
-    readonly wire: string[];
-    readonly refused: Map<string, number>;
-    readonly peers: Set<MemoryHarbor>;
-    cut: boolean;
-    readonly partitions: Map<string, Record<string, unknown>>;
-    readonly wards: Map<string, Booted>;
-    readonly objects: WeakMap<object, BeingLike>;
-    random: Ground['random'];
-    route(farPk: string, bytes: Uint8Array): Promise<Uint8Array | undefined>;
-    link(harbor: MemoryHarbor): void;
-    boot(seed: string, Ward: WardFactory, classes: Record<string, BeingClass>, box?: Invitation): Promise<Booted>;
-    reboot(seed: string, Ward: WardFactory, classes: Record<string, BeingClass>, box?: Invitation): Promise<Booted>;
-    up(Ward: WardFactory, lent?: Record<string, BeingClass>): Promise<Booted>;
-    get box(): Booted | undefined;
-    host(seed: string, Ward: WardFactory, classes: Record<string, BeingClass>): Promise<Booted>;
-    hosted(Ward: WardFactory, classes: Record<string, BeingClass>): Promise<string[]>;
-}

package/dist/harbor/memory.js

@@ -1,104 +0,0 @@
-import { maker, entropy, learnPk, volatile } from '../ward/ground.js';
-import { hex } from '../ward/arithmetic.js';
-import { Box, BOX_SEED, stand, offerTo, roll } from './box.js';
-export class MemoryHarbor {
-    doors = new Map(); // ward pk -> door
-    down = new Set(); // ward pks this harbor cannot reach right now
-    wire = []; // every byte string that ever crossed, as hex. for inspection
-    refused = new Map(); // ward pk -> arrivals its door would not admit: strangers, counted
-    peers = new Set();
-    cut = false;
-    partitions = new Map(); // seed -> memory. the harbor keeps it and reads nothing
-    wards = new Map(); // seed -> pointers
-    objects = new WeakMap(); // cells -> being object. what instantiate constructed. a hand for tests, never the ward's; it follows the cells out when she is unbooted
-    // Where the wards this harbor boots draw their entropy. The device's own
-    // by default. A harbor may hand a fixed stream instead, which is what pins
-    // bytes: every key a ward mints and every nonce it seals under comes from
-    // here, so a ward on a known seed with a known stream answers the same
-    // bytes every run, and a corpus of them is a corpus and not a sample.
-    random = entropy;
-    // the directory: its own doors, else a peer it is linked to. Quo says nothing about how.
-    async route(farPk, bytes) {
-        if (this.down.has(farPk))
-            return undefined;
-        const door = this.doors.get(farPk);
-        if (door) {
-            const r = await door(bytes);
-            if (!r.heard)
-                this.refused.set(farPk, (this.refused.get(farPk) ?? 0) + 1);
-            return r.bytes;
-        }
-        const peer = [...this.peers].find((h) => h.doors.has(farPk) && !h.down.has(farPk));
-        if (!peer || this.cut)
-            return undefined; // nothing. the harbor has no word silence
-        return peer.route(farPk, bytes);
-    }
-    link(harbor) {
-        this.peers.add(harbor);
-        harbor.peers.add(this);
-    }
-    // boot by seed. the harbor gets a door and an ask, and learns the pk by
-    // asking. `box` is the invitation on this device's box being, for this
-    // ward: left out, the ward holds no box and every lend is null.
-    async boot(seed, Ward, classes, box) {
-        this.partitions.set(seed, {});
-        return this.reboot(seed, Ward, classes, box);
-    }
-    // a restart: same seed, same partition, fresh ward. the ward's files are the harbor's to keep.
-    async reboot(seed, Ward, classes, box) {
-        const rows = this.partitions.get(seed);
-        if (!rows)
-            throw new Error(`no partition for ${seed}`);
-        const ground = {
-            seed,
-            memory: volatile(rows),
-            ...(box ? { box } : {}),
-            // One objects map for the whole harbor, not one per ward: every ward
-            // here is in this process and a test reaches any being of any of them.
-            instantiate: maker(this.objects, classes),
-            // bytes cross, copied, never a reference. both ways.
-            carry: async (farPk, bytes) => {
-                this.wire.push(hex(bytes));
-                const back = await this.route(farPk, new Uint8Array(bytes));
-                return back === undefined ? undefined : new Uint8Array(back);
-            },
-            random: (n) => this.random(n),
-        };
-        const w = await Ward(ground);
-        const booted = { ...w, pk: await learnPk(w) };
-        this.doors.set(booted.pk, booted.door);
-        this.wards.set(seed, booted);
-        return booted;
-    }
-    // Act one. The box's own ward, the box's being and the lent beings named,
-    // each booted under its name and held by her under it. Run again on a
-    // harbor whose box ward stands, it changes nothing.
-    async up(Ward, lent = {}) {
-        const classes = { Box };
-        for (const C of Object.values(lent))
-            classes[C.name] = C;
-        const box = this.wards.get(BOX_SEED) ?? (await this.boot(BOX_SEED, Ward, classes));
-        await stand(box, lent);
-        return box;
-    }
-    get box() {
-        return this.wards.get(BOX_SEED);
-    }
-    // Act two, one ward: on the roll and handed one invitation on the box's being.
-    // A harbor with no box ward up hosts as `boot` does, with nothing.
-    async host(seed, Ward, classes) {
-        const box = this.box;
-        const inv = box ? await offerTo(box, seed) : undefined;
-        return this.partitions.has(seed) ? this.reboot(seed, Ward, classes, inv) : this.boot(seed, Ward, classes, inv);
-    }
-    // Act two, whole: the box's being says who is hosted, and each comes up.
-    async hosted(Ward, classes) {
-        const box = this.box;
-        if (!box)
-            return [];
-        const seeds = await roll(box);
-        for (const seed of seeds)
-            await this.host(seed, Ward, classes);
-        return seeds;
-    }
-}

package/dist/harbor/reach.d.ts

@@ -1,36 +0,0 @@
-export type Carry = (pk: string, bytes: Uint8Array) => Promise<Uint8Array | undefined>;
-export type Reach = {
-    carry: Carry;
-    close(): void;
-};
-export declare function request(url: string): Reach;
-export declare const SUITE = 1;
-export declare const REFUSED = 4001;
-export type Line = {
-    readyState: number;
-    binaryType: string;
-    send(data: string | Uint8Array): void;
-    close(code?: number, reason?: string): void;
-    addEventListener(type: 'open' | 'error', fn: () => void): void;
-    addEventListener(type: 'close', fn: (e?: {
-        code?: number;
-        reason?: string;
-    }) => void): void;
-    addEventListener(type: 'message', fn: (e: {
-        data: unknown;
-    }) => void): void;
-};
-export type Announce = (pks: string[]) => void;
-export declare class Socket implements Reach {
-    #private;
-    readonly line: Line;
-    readonly pending: Map<number, (bytes: Uint8Array | undefined) => void>;
-    far: string[];
-    constructor(line: Line, deliver: Carry, onAnnounce: Announce, onClose: (why: {
-        code?: number;
-        reason?: string;
-    }) => void);
-    announce(pks: string[]): void;
-    carry(pk: string, bytes: Uint8Array): Promise<Uint8Array | undefined>;
-    close(): void;
-}

package/dist/harbor/reach.js

@@ -1,199 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// Reach: carrying bytes to a pk off the device. One interface, two
-// implementations:
-//
-//   request   a URL. POST the bytes to `<url>/<pk>`, get bytes back.
-//             Listener to listener.
-//   socket    a held WebSocket at `<url>`, opened by whichever side can
-//             dial, used in both directions with a frame id. Each side
-//             announces the ward pks it holds when the socket opens, and the
-//             other binds them.
-//
-// Both are written on what every terrain has: fetch, and the standard
-// WebSocket surface, which a browser, Node, an edge worker's pair and the
-// `ws` server all offer. The listener half of a socket is the terrain's
-// own and stays outside this tree; what is here is the framing, either end
-// of a line, and the request. Nothing here names a runtime, and
-// `src/conformance/reach.ts` is what every reach passes. A reach carries and returns; it reads
-// nothing. `undefined` is a promise that nothing was delivered: no such pk
-// at the far end, a connection that would not open, a socket that is gone.
-// A reach that sent the bytes and lost the line afterwards answers nothing
-// at all, and the ward's own bound ends the ask.
-import { concat, hex, unhex } from '../ward/arithmetic.js';
-import { readJson } from '../ward/json.js';
-const never = () => new Promise(() => { }); // sent, and no word since: the ward's bound decides
-// A request reach to one listener.
-export function request(url) {
-    const base = url.replace(/\/$/, '');
-    return {
-        close: () => { },
-        carry: async (pk, bytes) => {
-            let res;
-            // A body of its own, not the caller's view: fetch reads it after this
-            // line returns, and a buffer somebody else may write is not a body. The
-            // copy is its own ArrayBuffer, which is what a body is; the bytes handed
-            // in are typed as backed by anything, shared memory included.
-            const body = new Uint8Array(bytes.length);
-            body.set(bytes);
-            try {
-                res = await fetch(`${base}/${pk}`, { method: 'POST', headers: { 'content-type': 'application/octet-stream', 'quo-suite': String(SUITE) }, body });
-            }
-            catch {
-                return undefined; // the connection never opened: nothing was delivered
-            }
-            // A status that says the listener did not take the bytes is nothing
-            // delivered: no reach for that pk, a request it refused on its face, a
-            // gateway with nobody behind it. Any other failure is a listener that
-            // took them and failed after, which is sent and no word since.
-            if (res.status === 404 || (res.status >= 400 && res.status < 500) || res.status === 502 || res.status === 503 || res.status === 504)
-                return undefined;
-            if (!res.ok)
-                return never();
-            return new Uint8Array(await res.arrayBuffer());
-        },
-    };
-}
-// The frames on a socket. Binary, one byte of kind first.
-//   ask    [0][id: 4 bytes][pk: 64 bytes][bytes]
-//   reply  [1][id: 4 bytes][bytes]
-//   none   [2][id: 4 bytes]                    nothing was delivered
-// And one text frame, JSON: { announce: [pk, ...], suite }, the ward pks this
-// side holds and the wire suite it speaks, sent when the socket opens and
-// whenever the pks change.
-const ASK = 0, REPLY = 1, NONE = 2;
-// The wire suite: which frames these are and which five algorithms seal what
-// they carry. One value, and it is not negotiated. It rides in the handshake
-// and never on an ask, so an ask stays bytes nobody can tell from noise, and
-// a line still learns before it carries anything whether the far side speaks
-// what this side speaks. A side meeting a suite it does not know carries
-// nothing for it and closes: the alternative is bytes that will never open,
-// answered by a silence that says nothing about why, forever. Nothing
-// changes this number before 1.0.0. After it, this is the one place a second
-// suite can be told from a first without guessing.
-export const SUITE = 1;
-// The close a side sends when it refuses a suite, in the range a protocol
-// may spend on itself. A line that just closes tells the far side nothing,
-// and a dialer that learns nothing dials again on its backoff for good: the
-// whole reason this number exists is that a kit which cannot be understood
-// should be told so instead of meeting a silence that names no reason. So
-// the refusal names itself on the way out, and the far side may read it.
-export const REFUSED = 4001;
-const OPEN = 1; // WebSocket.OPEN, on every terrain
-// How many asks a socket keeps a resolver for. An ask the far side never
-// answers is ended by the ward's bound, and its resolver stays until the
-// line closes; a far side that answers nothing for long enough would grow
-// the map for as long as this side asks, so the oldest goes when it is full.
-const PENDING = 4096;
-// One held socket, either side of it. `deliver` is what this side does with
-// an ask that arrives for a pk: its own door, or a socket it holds for that
-// pk, and nothing else. `onAnnounce` learns the far side's pks; `onClose`
-// forgets them.
-export class Socket {
-    line;
-    pending = new Map();
-    far = []; // the pks the far side announced
-    #id = 1;
-    #open;
-    constructor(line, deliver, onAnnounce, onClose) {
-        this.line = line;
-        line.binaryType = 'arraybuffer';
-        // A line that opens is a reach; one that errors, or closes before it
-        // opened, is a reach that failed, and an ask waiting on the handshake is
-        // nothing delivered.
-        this.#open =
-            line.readyState === OPEN
-                ? Promise.resolve()
-                : new Promise((ok, no) => {
-                    line.addEventListener('open', ok);
-                    line.addEventListener('error', no);
-                    line.addEventListener('close', () => no(new Error('closed before it opened')));
-                });
-        this.#open.catch(() => { }); // a handshake refused is a reach that failed, not a process that dies
-        line.addEventListener('message', (e) => {
-            if (typeof e.data === 'string') {
-                try {
-                    const m = readJson(e.data);
-                    if (m === null || typeof m !== 'object')
-                        return;
-                    // Absent is this suite: a side that says nothing says one.
-                    if (m.suite !== undefined && m.suite !== SUITE) {
-                        this.far = [];
-                        line.close(REFUSED, 'suite');
-                        return;
-                    }
-                    if (Array.isArray(m.announce)) {
-                        this.far = m.announce.filter((x) => typeof x === 'string');
-                        onAnnounce(this.far);
-                    }
-                }
-                catch {
-                    /* not for us */
-                }
-                return;
-            }
-            const buf = e.data instanceof ArrayBuffer ? new Uint8Array(e.data) : ArrayBuffer.isView(e.data) ? new Uint8Array(e.data.buffer, e.data.byteOffset, e.data.byteLength) : undefined;
-            // A frame that is none of the three is not a frame: an unknown kind, an
-            // ask too short to hold a pk, a nothing with bytes after its id. It is
-            // dropped, and tells no ask waiting on its id that nothing was delivered.
-            if (!buf || buf.length < 5)
-                return;
-            const kind = buf[0], id = new DataView(buf.buffer, buf.byteOffset, buf.byteLength).getUint32(1);
-            if (kind > NONE || (kind === ASK && buf.length < 69) || (kind === NONE && buf.length !== 5))
-                return;
-            if (kind === ASK) {
-                const pk = hex(buf.subarray(5, 69));
-                // A deliver that rejects has delivered nothing this side can vouch
-                // for, and a listener does not die of it: the far side hears none.
-                void deliver(pk, new Uint8Array(buf.subarray(69)))
-                    .then((back) => back, () => undefined)
-                    .then((back) => {
-                    const head = new Uint8Array(5);
-                    head[0] = back === undefined ? NONE : REPLY;
-                    new DataView(head.buffer).setUint32(1, id);
-                    if (line.readyState === OPEN)
-                        line.send(back === undefined ? head : concat([head, back]));
-                });
-                return;
-            }
-            const waiting = this.pending.get(id);
-            if (!waiting)
-                return;
-            this.pending.delete(id);
-            waiting(kind === REPLY ? new Uint8Array(buf.subarray(5)) : undefined);
-        });
-        line.addEventListener('error', () => { });
-        line.addEventListener('close', (e) => {
-            this.pending.clear(); // in flight and no word since: nothing is answered
-            onClose({ code: e?.code, reason: e?.reason });
-        });
-    }
-    // Say which ward pks this side holds.
-    announce(pks) {
-        if (this.line.readyState === OPEN)
-            this.line.send(JSON.stringify({ announce: pks, suite: SUITE }));
-    }
-    async carry(pk, bytes) {
-        try {
-            await this.#open;
-        }
-        catch {
-            return undefined;
-        }
-        if (this.line.readyState !== OPEN)
-            return undefined;
-        const id = this.#id++;
-        const head = new Uint8Array(69);
-        head[0] = ASK;
-        new DataView(head.buffer).setUint32(1, id);
-        head.set(unhex(pk), 5);
-        return new Promise((ok) => {
-            if (this.pending.size >= PENDING)
-                this.pending.delete(this.pending.keys().next().value); // the oldest, which the ward's bound ended long ago
-            this.pending.set(id, ok);
-            this.line.send(concat([head, bytes]));
-        });
-    }
-    close() {
-        this.line.close();
-    }
-}

package/dist/harbor/store.d.ts

@@ -1,35 +0,0 @@
-export type WardRecord = {
-    pk: string;
-    code: string;
-    user: string;
-};
-export type Kept = {
-    seed: Uint8Array;
-    partition: Record<string, unknown>;
-    record: WardRecord;
-};
-export type Store = {
-    list(): Promise<string[]>;
-    load(name: string): Promise<Kept | undefined>;
-    put(name: string, kept: Kept): Promise<void>;
-    save(name: string, partition: Record<string, unknown>, rows: readonly string[]): Promise<void>;
-    record(name: string, record: WardRecord): Promise<void>;
-    take(name: string): Promise<Kept | undefined>;
-};
-export declare const values: (p: Record<string, unknown>) => Record<string, unknown>;
-export declare const rowsOf: (partition: Record<string, unknown>, rows: readonly string[]) => [string, Record<string, unknown> | undefined][];
-type Row = {
-    seed: Uint8Array;
-    parts: Map<string, Record<string, unknown>>;
-    record: WardRecord;
-};
-export declare class MemoryStore implements Store {
-    readonly rows: Map<string, Row>;
-    list(): Promise<string[]>;
-    load(name: string): Promise<Kept | undefined>;
-    put(name: string, kept: Kept): Promise<void>;
-    save(name: string, partition: Record<string, unknown>, rows: readonly string[]): Promise<void>;
-    record(name: string, record: WardRecord): Promise<void>;
-    take(name: string): Promise<Kept | undefined>;
-}
-export {};

package/dist/harbor/store.js

@@ -1,62 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// The store: keeping wards by name. A ward is three things and the store
-// keeps all three under one name: the seed, the partition and the ward
-// record, which says where the class bodies come from and which being is
-// the user's. The store reads nothing it keeps; the partition is
-// values the ward wrote, and the seed is bytes only the ward derives from.
-// Every terrain has one: files on a disk, IndexedDB in a tab, an object's
-// storage on the edge; the memory store below is the library's own, for a
-// harbor core with no device under it. `src/conformance/store.ts` is what
-// every one of them passes.
-import { fromRows, rowOf, rowsIn } from '../ward/partition.js';
-// The partition is values only, and the ward hands it out through a guard,
-// so a store takes a copy of the values the way a file would: through JSON.
-export const values = (p) => JSON.parse(JSON.stringify(p));
-// The rows a store was told about, as values, ready to be written down. A row
-// whose key names nobody is a being who left, and comes back undefined, which
-// is the store dropping what it holds for her.
-export const rowsOf = (partition, rows) => rows.map((row) => {
-    const value = rowOf(partition, row);
-    return [row, value === undefined ? undefined : (values(value))];
-});
-// One store's copy, brought up to date with the rows it was told about.
-const keep = (row, partition, rows) => {
-    for (const [id, value] of rowsOf(partition, rows)) {
-        if (value === undefined)
-            row.parts.delete(id);
-        else
-            row.parts.set(id, value);
-    }
-};
-export class MemoryStore {
-    rows = new Map();
-    async list() {
-        return [...this.rows.keys()];
-    }
-    async load(name) {
-        const row = this.rows.get(name);
-        return row && { seed: new Uint8Array(row.seed), partition: fromRows(Object.fromEntries(row.parts)), record: { ...row.record } };
-    }
-    async put(name, kept) {
-        if (this.rows.has(name))
-            throw new Error(`ward ${name} already exists here`);
-        const row = { seed: new Uint8Array(kept.seed), parts: new Map(), record: { ...kept.record } };
-        this.rows.set(name, row);
-        keep(row, kept.partition, rowsIn(kept.partition));
-    }
-    async save(name, partition, rows) {
-        const row = this.rows.get(name);
-        if (row)
-            keep(row, partition, rows);
-    }
-    async record(name, record) {
-        const row = this.rows.get(name);
-        if (row)
-            row.record = { ...record };
-    }
-    async take(name) {
-        const kept = await this.load(name);
-        this.rows.delete(name);
-        return kept;
-    }
-}

package/dist/vector/cases.d.ts

@@ -1,42 +0,0 @@
-import type { Json, JsonObject } from '../being/types.ts';
-import type { Booted } from '../harbor/memory.ts';
-import type { World, Sealed } from './world.ts';
-export type DoorRecord = {
-    case: string;
-    name: string;
-    state: string;
-    ward: string;
-    kind: 'silence' | 'word' | 'object';
-    heard: boolean;
-    ask: string;
-    reply: string;
-    opens: Json | null;
-    draws: number;
-    blueprint?: JsonObject;
-    wrote: boolean;
-};
-export type Pin = () => Promise<void>;
-export type Arrival = {
-    kind: DoorRecord['kind'];
-    door: Booted;
-    ask: Sealed | {
-        bytes: Uint8Array;
-        open: null;
-    };
-};
-export type Case = {
-    case: string;
-    name: string;
-    state: string;
-    ward: string;
-    arrive: (w: World, pin: Pin) => Promise<Arrival>;
-};
-export declare function stand(c: Case): Promise<{
-    w: World;
-    before: string;
-    draws: number;
-    arrival: Arrival;
-}>;
-export declare function doorCases(): Promise<DoorRecord[]>;
-export declare const caseNamed: (kase: string, name: string) => Case | undefined;
-export declare const cases: Case[];