nervur 0.16.0 → 0.17.0

package/dist/harbor/dial.js

@@ -0,0 +1,81 @@
+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/index.d.ts

@@ -0,0 +1,8 @@
+export { MemoryHarbor, type Booted, type WardFactory } from './memory.ts';
+export { Harbor, DEFAULT_CODE, type Hosted, type Bound, type Loader } from './core.ts';
+export { dial, type Dialer } from './dial.ts';
+export { MemoryStore, values, rowsOf, type Store, type Kept, type WardRecord } from './store.ts';
+export { HEAD, fromRows, rowsIn } from '../ward/partition.ts';
+export { request, Socket, SUITE, REFUSED, type Reach, type Carry, type Line, type Announce } from './reach.ts';
+export type { Ground, WardPointers, Lend } from '../ward/ground.ts';
+export { maker, entropy, learnPk } from '../ward/ground.ts';

package/dist/harbor/index.js

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: Apache-2.0
+// nervur/harbor — the Ground contract and the harbors. The only
+// place in the package that may know a wire, and it knows one on the
+// standard surface alone: fetch and WebSocket. MemoryHarbor knows none: it
+// is one process talking to itself, where every ward assertion is made.
+export { MemoryHarbor } from './memory.js';
+export { Harbor, DEFAULT_CODE } from './core.js';
+export { dial } from './dial.js';
+export { MemoryStore, values, rowsOf } from './store.js';
+// What a store keeping a ward in rows needs: the name of the row that is not
+// a being, and the partition back from the rows it was cut into.
+export { HEAD, fromRows, rowsIn } from '../ward/partition.js';
+export { request, Socket, SUITE, REFUSED } from './reach.js';
+// What a harbor builds a ground out of. Convenience, never contract: a kit
+// writing its own harbor may write these three again.
+export { maker, entropy, learnPk } from '../ward/ground.js';

package/dist/harbor/memory.d.ts

@@ -0,0 +1,25 @@
+import type { BeingClass, BeingLike } from '../being/types.ts';
+import { type Ground, type WardPointers, type Lend } 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>, lend?: Lend): Promise<Booted>;
+    reboot(seed: string, Ward: WardFactory, classes: Record<string, BeingClass>, lend?: Lend): Promise<Booted>;
+}

package/dist/harbor/memory.js

@@ -0,0 +1,72 @@
+import { maker, entropy, learnPk } from '../ward/ground.js';
+import { hex } from '../ward/arithmetic.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.
+    // `lend` is what this device lends the ward's beings, and a test's stand-in
+    // for a real terrain's: left out, every name answers null.
+    async boot(seed, Ward, classes, lend) {
+        this.partitions.set(seed, {});
+        return this.reboot(seed, Ward, classes, lend);
+    }
+    // a restart: same seed, same partition, fresh ward. the ward's files are the harbor's to keep.
+    async reboot(seed, Ward, classes, lend) {
+        const memory = this.partitions.get(seed);
+        if (!memory)
+            throw new Error(`no partition for ${seed}`);
+        const ground = {
+            seed,
+            memory,
+            ...(lend ? { lend } : {}),
+            // 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;
+    }
+}

package/dist/harbor/reach.d.ts

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,191 @@
+// 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';
+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 = JSON.parse(e.data);
+                    // 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;
+            if (!buf || buf.length < 5)
+                return;
+            const kind = buf[0], id = new DataView(buf.buffer, buf.byteOffset, buf.byteLength).getUint32(1);
+            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

@@ -0,0 +1,40 @@
+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>;
+    hints(): Promise<Record<string, string>>;
+    hint(pk: string, url: string): Promise<void>;
+};
+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>;
+    readonly reach: Map<string, string>;
+    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>;
+    hints(): Promise<Record<string, string>>;
+    hint(pk: string, url: string): Promise<void>;
+}
+export {};

package/dist/harbor/store.js

@@ -0,0 +1,70 @@
+// 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. Plus the directory's hints, which are the harbor's and
+// survive a restart. 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();
+    reach = 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;
+    }
+    async hints() {
+        return Object.fromEntries(this.reach);
+    }
+    async hint(pk, url) {
+        this.reach.set(pk, url);
+    }
+}

package/dist/vector/cases.d.ts

@@ -0,0 +1,41 @@
+import type { Json } 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;
+    before: string;
+    after: string;
+    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;
+    arrival: Arrival;
+}>;
+export declare function doorCases(): Promise<DoorRecord[]>;
+export declare const caseNamed: (kase: string, name: string) => Case | undefined;
+export declare const cases: Case[];