nervur 0.16.0 → 0.17.0

package/dist/vector/cases.js

@@ -0,0 +1,195 @@
+// SPDX-License-Identifier: Apache-2.0
+// The door's thirteen cases as records. One record per case, D1 through
+// D13, both halves of D8 and both of D9. Each is taken in its own world, so
+// the stream is at the same place every time and a record is reproduced
+// without running the ones before it.
+//
+// A case is its setup and its arrival, held apart: `arrive` stands the world
+// in the case's state and seals the ask, and whoever holds the record knocks.
+// `doorCases` knocks at once and is what `door.json` is written from and
+// held to. Vector mode stops after `arrive` and lets a verifier bring the
+// bytes, which is the whole reason the two halves are two.
+//
+// `kind` is what the reply is, not what it says: `silence` is the one shape
+// every stranger gets, `word` is what a ward says to a key it has bound, and
+// `object` is an answer. The law of one silence is a law about `silence`
+// alone, and the words are here so a kit sees they are a different length on
+// purpose.
+import { Ward } from '../ward/ward.js';
+import * as seal from '../ward/seal.js';
+import { hex } from '../ward/arithmetic.js';
+import { world, sealed, bound, secret, rnd, partitionDigest, Caller } from './world.js';
+// Stand one case: its world, its setup, its ask. What comes back is enough
+// to knock, and enough for a verifier to check the hand before the door.
+export async function stand(c) {
+    const w = await world();
+    let before = await partitionDigest(w.b, c.ward);
+    const arrival = await c.arrive(w, async () => {
+        before = await partitionDigest(w.b, c.ward);
+    });
+    return { w, before, arrival };
+}
+async function record(c) {
+    const { w, before, arrival } = await stand(c);
+    const judged = await arrival.door.door(arrival.ask.bytes);
+    const after = await partitionDigest(w.b, c.ward);
+    const opens = arrival.ask.open ? (await arrival.ask.open(judged.bytes)) : null;
+    return { case: c.case, name: c.name, state: c.state, ward: c.ward, kind: arrival.kind, heard: judged.heard, ask: hex(arrival.ask.bytes), reply: hex(judged.bytes), opens, before, after, wrote: before !== after };
+}
+// One after another and never at once: the cases share one stream, and two
+// of them in flight together would draw from it in whatever order the
+// machine's crypto happened to finish in.
+export async function doorCases() {
+    const out = [];
+    for (const c of cases)
+        out.push(await record(c));
+    return out;
+}
+// A case by its two names, which together are unique in the corpus.
+export const caseNamed = (kase, name) => cases.find((c) => c.case === kase && c.name === name);
+const at = async (door, to, kind, h = {}) => ({ kind, door, ask: await sealed(door.pk, to, h) });
+// The D2 body: a bound relation, then one field of the wrong shape.
+async function bad(w, pin, h) {
+    const b = await bound(w);
+    await pin();
+    return at(w.WB, b.inv.heir, 'silence', { signer: b.own, ...h });
+}
+export const cases = [
+    {
+        case: 'D1',
+        name: 'wrong padlock',
+        state: "a heir the door holds, sealed to another ward's padlock",
+        ward: 'B',
+        arrive: async (w) => at(w.WB, w.inv.heir, 'silence', { signer: secret(w.inv), padlock: (await seal.wardKey('other')).padlockPk }),
+    },
+    {
+        case: 'D1',
+        name: 'noise',
+        state: 'bytes that are not a sealed ask at all',
+        ward: 'B',
+        // Nobody holds a secret for the lid this one is sealed to: the door
+        // answers to the first thirty-two bytes of the noise, and those are not
+        // a key anyone made. That is the case, not a gap in it.
+        arrive: async (w) => ({ kind: 'silence', door: w.WB, ask: { bytes: Uint8Array.of(1, ...rnd(32), ...rnd(80)), open: null } }),
+    },
+    { case: 'D2', name: 'method is not a string', state: 'a bound key, one field of the wrong shape', ward: 'B', arrive: (w, pin) => bad(w, pin, { method: 7 }) },
+    { case: 'D2', name: 'args is not an object', state: 'a bound key, one field of the wrong shape', ward: 'B', arrive: (w, pin) => bad(w, pin, { args: 7 }) },
+    { case: 'D2', name: 'seq is zero', state: 'a bound key, one field of the wrong shape', ward: 'B', arrive: (w, pin) => bad(w, pin, { seq: 0 }) },
+    { case: 'D2', name: 'time is negative', state: 'a bound key, one field of the wrong shape', ward: 'B', arrive: (w, pin) => bad(w, pin, { time: -1 }) },
+    { case: 'D2', name: 'by is not a key', state: 'a bound key, one field of the wrong shape', ward: 'B', arrive: (w, pin) => bad(w, pin, { by: 'nope' }) },
+    { case: 'D2', name: 'hops at zero', state: 'a bound key, and a chain that has run out', ward: 'B', arrive: (w, pin) => bad(w, pin, { hops: 0 }) },
+    { case: 'D3', name: 'for nobody, nobody home', state: 'a ward with no public being', ward: 'B', arrive: (w) => at(w.WB, null, 'silence') },
+    { case: 'D4', name: 'for nobody, the signature fails', state: 'a ward with a public being, a body signed by another key', ward: 'P', arrive: async (w) => at(w.WP, null, 'silence', { by: (await seal.beingKey(rnd())).pk }) },
+    { case: 'D5', name: 'a heir not held', state: 'a heir this ward never minted', ward: 'B', arrive: (w) => at(w.WB, 'ff'.repeat(32), 'silence') },
+    {
+        case: 'D6',
+        name: 'a key not admitted',
+        state: 'a heir the door holds, a key nobody announced',
+        ward: 'B',
+        arrive: async (w, pin) => {
+            const b = await bound(w);
+            await pin();
+            return at(w.WB, b.inv.heir, 'silence');
+        },
+    },
+    {
+        case: 'D7',
+        name: 'the signature fails under an admitted key',
+        state: 'a bound key named in by, a body signed by another',
+        ward: 'B',
+        arrive: async (w, pin) => {
+            const b = await bound(w);
+            await pin();
+            return at(w.WB, b.inv.heir, 'silence', { signer: rnd(), by: b.ownPk });
+        },
+    },
+    {
+        case: 'D8',
+        name: 'she is not there',
+        state: 'the ward restarted without her class: her heirs stand and she does not',
+        ward: 'B',
+        arrive: async (w, pin) => {
+            const WB = await w.b.reboot('B', Ward, { Caller });
+            await pin();
+            return at(WB, w.inv.heir, 'word', { signer: secret(w.inv), next: 'a'.repeat(64) });
+        },
+    },
+    {
+        case: 'D8',
+        name: 'she is there and the record is not',
+        state: 'the being is booted and the occupant her heir was opened for is gone',
+        ward: 'B',
+        arrive: async (w, pin) => {
+            const b = await bound(w);
+            delete w.host.cells.occupants[b.rec().id];
+            await pin();
+            return at(w.WB, b.inv.heir, 'word', { signer: b.own });
+        },
+    },
+    {
+        case: 'D9',
+        name: 'a heir that announces nothing',
+        state: 'a fresh heir, and no next in the body',
+        ward: 'B',
+        arrive: async (w, pin) => {
+            const inv = await w.host.welcome();
+            await pin();
+            return at(w.WB, inv.heir, 'word', { signer: secret(inv), next: null });
+        },
+    },
+    {
+        case: 'D9',
+        name: 'a bound key that announces nothing',
+        state: 'a key the door already vouched for, and no next in the body',
+        ward: 'B',
+        arrive: async (w, pin) => {
+            const b = await bound(w);
+            await pin();
+            return at(w.WB, b.inv.heir, 'object', { signer: b.own, next: null });
+        },
+    },
+    {
+        case: 'D10',
+        name: 'a number already spent',
+        state: 'a bound key, a seq at or below the mark',
+        ward: 'B',
+        arrive: async (w, pin) => {
+            const b = await bound(w);
+            await pin();
+            return at(w.WB, b.inv.heir, 'word', { signer: b.own, seq: 1 });
+        },
+    },
+    {
+        case: 'D11',
+        name: 'she threw',
+        state: 'a bound key on an ask that raises',
+        ward: 'B',
+        arrive: async (w, pin) => {
+            const b = await bound(w);
+            await pin();
+            return at(w.WB, b.inv.heir, 'word', { signer: b.own, method: 'boom' });
+        },
+    },
+    {
+        case: 'D12',
+        name: 'she said silence',
+        state: 'a bound key on an ask that answers the value silence',
+        ward: 'B',
+        arrive: async (w, pin) => {
+            const b = await bound(w);
+            await pin();
+            return at(w.WB, b.inv.heir, 'silence', { signer: b.own, method: 'quiet' });
+        },
+    },
+    {
+        case: 'D13',
+        name: 'a word out of her',
+        state: 'a bound key on an ask that returns a shape only a ward may make',
+        ward: 'B',
+        arrive: async (w, pin) => {
+            const b = await bound(w);
+            await pin();
+            return at(w.WB, b.inv.heir, 'word', { signer: b.own, method: 'bad' });
+        },
+    },
+];

package/dist/vector/index.d.ts

@@ -0,0 +1,6 @@
+export { splitmix64, STREAM_SEED, rnd, must, P, B, SILENT, WORD, said, secret, snap, heardBy, partitionDigest, Host, Caller, classes, world, sealed, hand, bound } from './world.ts';
+export type { World, Door, Hand, Sealed } from './world.ts';
+export { cases, caseNamed, stand, doorCases } from './cases.ts';
+export type { DoorRecord, Pin, Arrival, Case } from './cases.ts';
+export { Stand } from './stand.ts';
+export type { Answer } from './stand.ts';

package/dist/vector/index.js

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: Apache-2.0
+// The vector shelf: the world the door's cases are taken in, the cases as
+// records, and the stand a verifier replays them against. `door.json` is
+// written from `doorCases` by a hand and held to by the suite; `Stand` is
+// vector mode, the spec's chapter of that name.
+export { splitmix64, STREAM_SEED, rnd, must, P, B, SILENT, WORD, said, secret, snap, heardBy, partitionDigest, Host, Caller, classes, world, sealed, hand, bound } from './world.js';
+export { cases, caseNamed, stand, doorCases } from './cases.js';
+export { Stand } from './stand.js';

package/dist/vector/stand.d.ts

@@ -0,0 +1,9 @@
+export type Answer = {
+    status: number;
+    headers: Record<string, string>;
+    body: Uint8Array;
+};
+export declare class Stand {
+    #private;
+    handle(method: string, path: string, body: Uint8Array, headers?: Record<string, string | undefined>): Promise<Answer>;
+}

package/dist/vector/stand.js

@@ -0,0 +1,76 @@
+// SPDX-License-Identifier: Apache-2.0
+// Vector mode: the harness the spec's chapter of that name describes, as one
+// handler that names no runtime. A listener on any terrain turns its own
+// request into `(method, path, body)` and writes the answer back; on Node
+// that is `test/stand.ts`. What the handler does with an ask is what the
+// request reach does everywhere: post the bytes to `<url>/<pk>`, get the
+// reply bytes back. Beside it, two routes that exist only here: `stand`
+// puts the world in the state of one record of `door.json` and `digest`
+// reads the judged ward's partition as one value.
+//
+// Every answer carries `access-control-allow-origin: *` and an OPTIONS is
+// answered, because a verifier is a page in a stranger's tab as often as a
+// shell, and a stand that only its own origin can reach passes from one and
+// fails from the other while the door is the same.
+//
+// Nothing here is reachable from a harbor that is not in the mode. This file
+// is imported by a hand that stands a kit for a verifier, and by nothing a
+// world runs on.
+import { SUITE } from '../harbor/reach.js';
+import { hex } from '../ward/arithmetic.js';
+import { caseNamed, stand } from './cases.js';
+import { partitionDigest } from './world.js';
+const CORS = {
+    'access-control-allow-origin': '*',
+    'access-control-allow-methods': 'GET, POST, OPTIONS',
+    'access-control-allow-headers': 'content-type, quo-suite',
+};
+const text = (s) => new TextEncoder().encode(s);
+const json = (status, v) => ({ status, headers: { ...CORS, 'content-type': 'application/json' }, body: text(JSON.stringify(v)) });
+const bytes = (b) => ({ status: 200, headers: { ...CORS, 'content-type': 'application/octet-stream' }, body: b });
+const NONE = { status: 404, headers: CORS, body: new Uint8Array(0) };
+export class Stand {
+    #w = null;
+    #ward = '';
+    async handle(method, path, body, headers = {}) {
+        const p = path.replace(/\/$/, '');
+        if (method === 'OPTIONS')
+            return { status: 204, headers: CORS, body: new Uint8Array(0) };
+        if (method === 'POST' && p === '/stand') {
+            let named;
+            try {
+                named = JSON.parse(new TextDecoder().decode(body));
+            }
+            catch {
+                return NONE;
+            }
+            const c = typeof named.case === 'string' && typeof named.name === 'string' ? caseNamed(named.case, named.name) : undefined;
+            if (!c)
+                return NONE;
+            const stood = await stand(c);
+            this.#w = stood.w;
+            this.#ward = c.ward;
+            // What is returned is hex, the corpus's own encoding, so a verifier
+            // compares strings and never decodes anything.
+            return json(200, { ward: stood.arrival.door.pk, before: stood.before, ask: hex(stood.arrival.ask.bytes) });
+        }
+        if (method === 'GET' && p === '/digest') {
+            if (!this.#w)
+                return NONE;
+            return json(200, { after: await partitionDigest(this.#w.b, this.#ward) });
+        }
+        if (method === 'POST' && /^\/[0-9a-f]{128}$/.test(p)) {
+            const suite = headers['quo-suite'];
+            if (suite !== undefined && suite !== String(SUITE))
+                return NONE; // a suite this door does not speak: nothing delivered
+            if (!this.#w)
+                return NONE;
+            const pk = p.slice(1);
+            const door = this.#w.b.doors.get(pk) ?? this.#w.a.doors.get(pk);
+            if (!door)
+                return NONE;
+            return bytes((await door(body)).bytes);
+        }
+        return NONE;
+    }
+}

package/dist/vector/world.d.ts

@@ -0,0 +1,143 @@
+import { MemoryHarbor } from '../harbor/memory.ts';
+import * as seal from '../ward/seal.ts';
+import type { Partition } from '../ward/partition.ts';
+import { Being } from '../being/being.ts';
+import type { Answer, Asker, BeingClass, Blueprint, Invitation, JsonObject, Reply, Wanted } from '../being/types.ts';
+export declare function splitmix64(seed: bigint): () => Uint8Array;
+export declare const STREAM_SEED = 20250901n;
+export declare const rnd: (n?: number) => Uint8Array;
+export declare const must: (ok: boolean, what: string) => void;
+export declare const P: (h: MemoryHarbor, seed: string) => Partition;
+export declare const B: <T>(h: MemoryHarbor, seed: string, key: string) => T;
+export declare const SILENT: {
+    silence: boolean;
+};
+export declare const WORD: (quo: string) => {
+    quo: string;
+};
+export declare const said: (x: unknown, w: string) => boolean;
+export declare const secret: (inv: Invitation) => Uint8Array<ArrayBufferLike>;
+export declare const snap: <T>(v: T) => T;
+export declare const heardBy: (h: Host) => number;
+export declare const partitionDigest: (h: MemoryHarbor, seed: string) => Promise<string>;
+export declare class Host extends Being {
+    static cells: {
+        heard: JsonObject[];
+        describe: string;
+        minted: number;
+    };
+    static asks: {
+        hello: {
+            input: {
+                type: string;
+            };
+        };
+        err: {
+            input: {
+                type: string;
+            };
+        };
+        nul: {
+            input: {
+                type: string;
+            };
+        };
+        quiet: {
+            input: {
+                type: string;
+            };
+        };
+        boom: {
+            input: {
+                type: string;
+            };
+        };
+        bad: {
+            input: {
+                type: string;
+            };
+        };
+        never: {
+            input: {
+                type: string;
+            };
+        };
+        hidden: {
+            input: {
+                type: string;
+            };
+            for: () => boolean;
+        };
+    };
+    hello(args: JsonObject, asker: Asker): {
+        hi: string | null;
+    };
+    err(): {
+        error: string;
+    };
+    nul(): null;
+    quiet(): symbol;
+    boom(): never;
+    bad(): Reply;
+    never(): Promise<Reply>;
+    hidden(): {
+        secret: boolean;
+    };
+    describe(asker: Asker): Blueprint;
+    welcome(id?: string): Promise<Invitation>;
+}
+export declare class Caller extends Being {
+    static asks: {
+        hi: {
+            input: {
+                type: string;
+            };
+        };
+    };
+    hi(): {
+        hi: boolean;
+    };
+    join(id: string, inv: Invitation): Promise<Answer>;
+    ask(id: string, method?: string, args?: JsonObject, wanted?: Wanted): Promise<Answer>;
+}
+export declare const classes: Record<string, BeingClass>;
+export declare function world(): Promise<{
+    a: MemoryHarbor;
+    b: MemoryHarbor;
+    WA: import("../harbor/memory.ts").Booted;
+    WB: import("../harbor/memory.ts").Booted;
+    WP: import("../harbor/memory.ts").Booted;
+    alice: Caller;
+    host: Host;
+    pub: Host;
+    inv: Invitation;
+    heir: () => import("../ward/partition.ts").Heir;
+    alicesSeq: () => number;
+}>;
+export type World = Awaited<ReturnType<typeof world>>;
+export type Door = (b: Uint8Array) => Promise<{
+    bytes: Uint8Array;
+    heard: boolean;
+}>;
+export type Hand = Partial<seal.AskPayload> & {
+    signer?: Uint8Array;
+    padlock?: Uint8Array;
+};
+export type Sealed = {
+    bytes: Uint8Array;
+    open(out: Uint8Array): Promise<seal.ReplyPayload | null>;
+};
+export declare function sealed(wardPk: string, to: string | null, h?: Hand): Promise<Sealed>;
+export declare function hand(door: Door, wardPk: string, to: string | null, h?: Hand): Promise<{
+    bytes: Uint8Array<ArrayBufferLike>;
+    out: Uint8Array<ArrayBufferLike>;
+    heard: boolean;
+    reply: seal.ReplyPayload | null;
+    again: () => Promise<seal.ReplyPayload | null>;
+}>;
+export declare function bound(w: World): Promise<{
+    inv: Invitation;
+    own: Uint8Array<ArrayBufferLike>;
+    ownPk: string;
+    rec: () => import("../ward/partition.ts").Heir;
+}>;

package/dist/vector/world.js

@@ -0,0 +1,198 @@
+// SPDX-License-Identifier: Apache-2.0
+// The world the door's cases are proven in. Two harbors linked as a wire.
+// Alice, a caller, on ward A of harbor a. A host on ward B of harbor b, with
+// an ask for every way of not answering. A public host on ward P of harbor
+// b. And a hand that seals bytes exactly as a ward would, for the cases only
+// bytes can reach.
+//
+// Nothing here draws from the device. A door's reply is sealed under a fresh
+// ephemeral key and a fresh nonce, so the bytes are fixed only where the
+// entropy is, and every draw in this file comes from one written-down stream.
+// That is what lets `protocol/vectors/door.json` be a corpus and not a
+// sample, and what lets a kit stand in vector mode for a verifier that holds
+// no key: the spec's chapter of that name is the contract this file keeps.
+import { MemoryHarbor } from '../harbor/memory.js';
+import { Ward } from '../ward/ward.js';
+import * as seal from '../ward/seal.js';
+import { unhex } from '../ward/arithmetic.js';
+import { Being } from '../being/being.js';
+import { silence, unreached, isSilence, isUnreached, told } from '../being/silence.js';
+import { digest } from '../being/digest.js';
+// ---- the stream
+//
+// SplitMix64. Sixteen lines a kit in any language writes from this comment
+// alone: the state starts at the seed, every draw adds the golden gamma
+// 0x9e3779b97f4a7c15, mixes with two xor-shift-multiplies, and the sixty-four
+// bit result is spent eight bytes at a time, least significant first. It is
+// not a cipher and is not meant to be one. Its whole job is that the bytes
+// this file produces are the same bytes twice.
+const GAMMA = 0x9e3779b97f4a7c15n;
+const M64 = (1n << 64n) - 1n;
+export function splitmix64(seed) {
+    let s = seed & M64;
+    return () => {
+        s = (s + GAMMA) & M64;
+        let z = s;
+        z = ((z ^ (z >> 30n)) * 0xbf58476d1ce4e5b9n) & M64;
+        z = ((z ^ (z >> 27n)) * 0x94d049bb133111ebn) & M64;
+        z = z ^ (z >> 31n);
+        const out = new Uint8Array(8);
+        for (let i = 0; i < 8; i++)
+            out[i] = Number((z >> BigInt(8 * i)) & 0xffn);
+        return out;
+    };
+}
+// The one seed every case stands on, and the first number a kit sets its own
+// stream to when it reproduces `door.json`.
+export const STREAM_SEED = 20250901n;
+let draw = splitmix64(STREAM_SEED);
+// Entropy, from the stream and never from the device. Every signer secret,
+// every ephemeral seed, every byte of noise and every key a ward in this
+// world mints comes through here, in the order the code asks for it.
+export const rnd = (n = 32) => {
+    const out = new Uint8Array(n);
+    for (let i = 0; i < n; i += 8)
+        out.set(draw().subarray(0, Math.min(8, n - i)), i);
+    return out;
+};
+// A claim the world stands on. It throws, because a world that is not the
+// one the corpus was taken in cannot produce the corpus, and the sooner that
+// is said the nearer the fault is named.
+export const must = (ok, what) => {
+    if (!ok)
+        throw new Error(what);
+};
+export const P = (h, seed) => h.partitions.get(seed);
+export const B = (h, seed, key) => h.objects.get(P(h, seed).beings[key]);
+export const SILENT = { silence: true };
+export const WORD = (quo) => ({ quo });
+// Her ward's word for what happened, as she receives it. `told` names the
+// word and leaves everything else alone, so an assertion that goes red says
+// which answer arrived instead of collapsing to false.
+export const said = (x, w) => told(x) === w;
+export const secret = (inv) => unhex(inv.secret);
+// A snapshot that survives the guard on cells: values only, which is all a partition holds.
+export const snap = (v) => JSON.parse(JSON.stringify(v));
+export const heardBy = (h) => h.cells.heard.length;
+// What a partition is, as one value a kit compares. `nothing written` is this
+// number before and after, and never a sentence a reader has to trust.
+export const partitionDigest = (h, seed) => digest(snap(P(h, seed)));
+// A host. One ask per way of not answering, and a describe that can be told
+// to throw or fall silent, so the empty ask has its cases too.
+export class Host extends Being {
+    static cells = { heard: [], describe: 'ok', minted: 0 };
+    static asks = {
+        hello: { input: { type: 'object' } },
+        err: { input: { type: 'object' } },
+        nul: { input: { type: 'object' } },
+        quiet: { input: { type: 'object' } },
+        boom: { input: { type: 'object' } },
+        bad: { input: { type: 'object' } },
+        never: { input: { type: 'object' } },
+        hidden: { input: { type: 'object' }, for: () => false },
+    };
+    hello(args, asker) {
+        this.cells.heard.push({ id: asker.id ?? null, ...args });
+        return { hi: asker.id ?? null };
+    }
+    err() {
+        return { error: 'nope' };
+    }
+    nul() {
+        return null;
+    }
+    quiet() {
+        return silence;
+    }
+    boom() {
+        throw new Error('she threw');
+    }
+    bad() {
+        return unreached(); // a shape that is not hers to make: her ward reads it as silence
+    }
+    never() {
+        return new Promise(() => { });
+    }
+    hidden() {
+        return { secret: true };
+    }
+    describe(asker) {
+        if (this.cells.describe === 'throw')
+            throw new Error('not now');
+        if (this.cells.describe === 'silent')
+            return silence;
+        return super.describe(asker);
+    }
+    async welcome(id) {
+        return (await this.invite(id ?? `g${++this.cells.minted}`));
+    }
+}
+// A caller. Knocks, takes, asks, and hands back exactly what her ward said.
+export class Caller extends Being {
+    static asks = { hi: { input: { type: 'object' } } };
+    hi() {
+        return { hi: true };
+    }
+    async join(id, inv) {
+        const out = await this.knock(inv, 'hello', { via: 'knock' });
+        if (!isSilence(out) && !isUnreached(out))
+            must((await this.take(id, inv)) === id, `take ${id}`);
+        return out;
+    }
+    ask(id, method, args = {}, wanted) {
+        return this.standings[id].ask(method, args, wanted);
+    }
+}
+export const classes = { Host, Caller };
+// The number a hand's asks count from. Reset with the stream, so a case seals
+// the same seq every run and not merely a fresh one.
+let counted = 1000;
+export async function world() {
+    draw = splitmix64(STREAM_SEED); // a fresh world is a fresh stream: two runs, one corpus
+    counted = 1000;
+    const a = new MemoryHarbor(), b = new MemoryHarbor();
+    a.random = rnd;
+    b.random = rnd;
+    a.link(b);
+    const WA = await a.boot('A', Ward, classes);
+    const WB = await b.boot('B', Ward, classes);
+    const WP = await b.boot('P', Ward, classes);
+    await WA.ask('boot', { key: 'alice', class: 'Caller' });
+    await WB.ask('boot', { key: 'host', class: 'Host' });
+    await WP.ask('boot', { key: 'pub', class: 'Host' });
+    await WP.ask('public', { key: 'pub' });
+    const alice = B(a, 'A', 'alice');
+    const host = B(b, 'B', 'host');
+    const pub = B(b, 'P', 'pub');
+    const inv = await host.welcome('alice');
+    const joined = await alice.join('host', inv);
+    must(JSON.stringify(joined) === JSON.stringify({ hi: 'alice' }), 'alice joins the host');
+    const heir = () => P(b, 'B').heirs[inv.heir];
+    const alicesSeq = () => P(a, 'A').bind.alice.standings.host.seq;
+    return { a, b, WA, WB, WP, alice, host, pub, inv, heir, alicesSeq };
+}
+export async function sealed(wardPk, to, h = {}) {
+    const signer = h.signer ?? rnd();
+    const by = h.by ?? (await seal.beingKey(signer)).pk;
+    const payload = { by, next: null, seq: ++counted, time: 30_000, method: 'hello', args: {}, ...h };
+    delete payload.signer;
+    delete payload.padlock;
+    const { bytes, ephemeral } = await seal.sealAsk(to, payload, signer, h.padlock ?? seal.wardPadlock(wardPk), rnd());
+    return { bytes, open: (out) => seal.openReply(out, ephemeral, seal.wardSignPk(wardPk)) };
+}
+export async function hand(door, wardPk, to, h = {}) {
+    const s = await sealed(wardPk, to, h);
+    const judged = await door(s.bytes);
+    const out = judged.bytes;
+    return { bytes: s.bytes, out, heard: judged.heard, reply: await s.open(out), again: async () => s.open((await door(s.bytes)).bytes) };
+}
+// A fresh relation on the host, knocked by hand so the test holds the keys.
+export async function bound(w) {
+    const inv = await w.host.welcome();
+    const own = rnd();
+    const ownPk = (await seal.beingKey(own)).pk;
+    const knock = await hand(w.WB.door, w.WB.pk, inv.heir, { signer: secret(inv), next: ownPk });
+    const minted = w.host.cells.minted;
+    must(JSON.stringify(knock.reply.object) === JSON.stringify({ hi: `g${minted}` }), `bound g${minted}`);
+    return { inv, own, ownPk, rec: () => P(w.b, 'B').heirs[inv.heir] };
+}

package/dist/ward/allowance.d.ts

@@ -0,0 +1,10 @@
+import type { Wanted } from '../being/types.ts';
+export type Allowance = {
+    time: number;
+};
+export declare const DEFAULT: Allowance;
+export declare const CEILING: Allowance;
+export declare function allow(wanted: Wanted | undefined, ceiling?: Allowance, base?: Allowance): Allowance;
+export declare const spent: (a: Allowance) => boolean;
+export declare const LATE: unique symbol;
+export declare function within<T>(ms: number, work: Promise<T>, rang?: () => void): Promise<T | typeof LATE>;