nervur 0.19.2 → 0.20.1

package/src/vector/cases.ts

@@ -1,257 +0,0 @@
-// 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.ts';
-import * as seal from '../ward/seal.ts';
-import { hex } from '../ward/arithmetic.ts';
-import { digest } from '../being/digest.ts';
-import type { Json, JsonObject } from '../being/types.ts';
-import type { Booted } from '../harbor/memory.ts';
-import { world, sealed, bound, secret, rnd, drawn, partitionDigest, Caller } from './world.ts';
-import type { World, Hand, Sealed } from './world.ts';
-
-export type DoorRecord = {
-  case: string;
-  name: string;
-  state: string;
-  ward: string; // the seed of the ward whose door judged it
-  kind: 'silence' | 'word' | 'object';
-  heard: boolean; // whether a key that door holds spoke
-  ask: string; // hex, exactly as the bytes arrive
-  reply: string; // hex, exactly as they leave
-  opens: Json | null; // what the reply opens to where the hand holds the lid's secret
-  draws: number; // how many words of the stream were spent before the arrival
-  blueprint?: JsonObject; // the shape `seen` is the digest of, where a reply carries one
-  wrote: boolean; // the partition changed while the door judged. a refusal never sets it
-};
-
-// `pin` is where the case's own setup ends and the arrival begins. A record
-// that measured the partition before its heir was minted would call the
-// minting a write of the door's, and every refusal would read as one.
-export type Pin = () => Promise<void>;
-
-// The world stood in a case's state, the ask sealed and not yet knocked.
-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> };
-
-// 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: Case): Promise<{ w: World; before: string; draws: number; arrival: Arrival }> {
-  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);
-  });
-  // Where the stream stands now, which is where the door is about to draw
-  // from. A kit that stood this case its own way sets its stream here.
-  return { w, before, draws: drawn(), arrival };
-}
-
-// The blueprint a reply's `seen` was taken over. The host is the only being
-// in this world whose shape reaches a stranger, and the asker is the id her
-// heir was opened for, so there is one blueprint to find and it is checked
-// against the digest before it is written down.
-async function shown(w: World, seen: string): Promise<JsonObject | undefined> {
-  for (const id of Object.keys(w.host.cells.occupants)) {
-    const bp = w.host.describe({ id }) as unknown as JsonObject;
-    if ((await digest(bp)) === seen) return bp;
-  }
-  return undefined;
-}
-
-async function record(c: Case): Promise<DoorRecord> {
-  const { w, before, draws, 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)) as Json | null) : null;
-  // A reply that carries `seen` carries a being's shape on the wire, which is
-  // the one place in this corpus where what a being answers reaches a
-  // stranger. So the blueprint that digest is taken over is written down
-  // beside it: a kit stands a being that answers exactly this to the empty
-  // ask, and its door's bytes are these bytes. Every other record is the
-  // door alone and needs no being at all.
-  const seen = opens !== null && typeof opens === 'object' && !Array.isArray(opens) ? (opens).seen : undefined;
-  const blueprint = typeof seen === 'string' ? await shown(w, seen) : undefined;
-  return { case: c.case, name: c.name, state: c.state, ward: c.ward, kind: arrival.kind, heard: judged.heard, draws, ask: hex(arrival.ask.bytes), reply: hex(judged.bytes), opens, ...(blueprint ? { blueprint } : {}), 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(): Promise<DoorRecord[]> {
-  const out: DoorRecord[] = [];
-  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: string, name: string): Case | undefined => cases.find((c) => c.case === kase && c.name === name);
-
-const at = async (door: Booted, to: string | null, kind: DoorRecord['kind'], h: Hand = {}): Promise<Arrival> => ({ 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: World, pin: Pin, h: Hand): Promise<Arrival> {
-  const b = await bound(w);
-  await pin();
-  return at(w.WB, b.inv.heir!, 'silence', { signer: b.own, ...h });
-}
-
-export const cases: Case[] = [
-  {
-    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 as unknown as string }) },
-  { 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 as unknown as JsonObject }) },
-  { 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',
-    // Under the key she bound: the heir was spent by her knock and admits
-    // nothing now, so an arrival signed with its secret would be D6 and not
-    // this case. Her own key is what the door holds for her, and it is the
-    // key that hears the word.
-    arrive: async (w, pin) => {
-      const b = await bound(w);
-      const WB = await w.b.reboot('B', Ward, { Caller });
-      await pin();
-      return at(WB, b.inv.heir!, 'word', { signer: b.own });
-    },
-  },
-  {
-    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 as Record<string, unknown>)[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/src/vector/index.ts

@@ -1,11 +0,0 @@
-// 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.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/src/vector/stand.ts

@@ -1,76 +0,0 @@
-// 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.ts';
-import { hex } from '../ward/arithmetic.ts';
-import { readJson } from '../ward/json.ts';
-import { caseNamed, stand } from './cases.ts';
-import type { World } from './world.ts';
-import { partitionDigest } from './world.ts';
-
-export type Answer = { status: number; headers: Record<string, string>; body: Uint8Array };
-
-const CORS = {
-  'access-control-allow-origin': '*',
-  'access-control-allow-methods': 'GET, POST, OPTIONS',
-  'access-control-allow-headers': 'content-type, quo-suite',
-};
-const text = (s: string) => new TextEncoder().encode(s);
-const json = (status: number, v: unknown): Answer => ({ status, headers: { ...CORS, 'content-type': 'application/json' }, body: text(JSON.stringify(v)) });
-const bytes = (b: Uint8Array): Answer => ({ status: 200, headers: { ...CORS, 'content-type': 'application/octet-stream' }, body: b });
-const NONE: Answer = { status: 404, headers: CORS, body: new Uint8Array(0) };
-
-export class Stand {
-  #w: World | null = null;
-  #ward = '';
-
-  async handle(method: string, path: string, body: Uint8Array, headers: Record<string, string | undefined> = {}): Promise<Answer> {
-    const p = path.replace(/\/$/, '');
-    if (method === 'OPTIONS') return { status: 204, headers: CORS, body: new Uint8Array(0) };
-    if (method === 'POST' && p === '/stand') {
-      let named: { case?: unknown; name?: unknown };
-      try {
-        named = readJson(body) as typeof named;
-      } 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/src/vector/world.ts

@@ -1,232 +0,0 @@
-// 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 `quo/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.ts';
-import { Ward } from '../ward/ward.ts';
-import * as seal from '../ward/seal.ts';
-import { unhex } from '../ward/arithmetic.ts';
-import type { Partition } from '../ward/partition.ts';
-import { Being } from '../being/being.ts';
-import { silence, unreached, isSilence, isUnreached, told } from '../being/silence.ts';
-import { digest } from '../being/digest.ts';
-import type { Answer, Asker, BeingClass, Blueprint, Invitation, Json, JsonObject, Reply, Wanted } from '../being/types.ts';
-
-// ---- the stream
-//
-// SplitMix64, written out in the spec's vector-mode chapter with both
-// multipliers and all three shifts, because a kit that reproduces it by
-// recognising it is a kit that guessed. This is that, and it moves only
-// when that does. 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: bigint): () => Uint8Array {
-  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);
-// How many sixty-four bit words have been spent since the stream was reset.
-// A record carries this number at the moment of its arrival, so a kit that
-// built the door's state its own way sets its stream here and draws what
-// this one would have drawn. It is the whole of what the setup's history is
-// worth to a stranger: not how the world was made, but where the stream
-// stands when the door is about to answer.
-let spent = 0;
-export const drawn = (): number => spent;
-// 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): Uint8Array => {
-  const out = new Uint8Array(n);
-  for (let i = 0; i < n; i += 8) {
-    out.set(draw().subarray(0, Math.min(8, n - i)), i);
-    spent += 1;
-  }
-  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: boolean, what: string): void => {
-  if (!ok) throw new Error(what);
-};
-
-export const P = (h: MemoryHarbor, seed: string) => h.partitions.get(seed) as unknown as Partition;
-export const B = <T>(h: MemoryHarbor, seed: string, key: string) => h.objects.get(P(h, seed).beings[key]) as T;
-export const SILENT = { silence: true };
-export const WORD = (quo: string) => ({ 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: unknown, w: string): boolean => told(x) === w;
-export const secret = (inv: Invitation) => unhex(inv.secret!);
-// A snapshot that survives the guard on cells: values only, which is all a partition holds.
-export const snap = <T>(v: T): T => JSON.parse(JSON.stringify(v)) as T;
-export const heardBy = (h: Host) => (h.cells.heard as JsonObject[]).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: MemoryHarbor, seed: string): Promise<string> => 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 override cells = { heard: [] as JsonObject[], describe: 'ok' as string, minted: 0 };
-  static override 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: JsonObject, asker: Asker) {
-    (this.cells.heard as JsonObject[]).push({ id: asker.id ?? null, ...args });
-    return { hi: asker.id ?? null };
-  }
-  err() {
-    return { error: 'nope' };
-  }
-  nul() {
-    return null;
-  }
-  quiet() {
-    return silence;
-  }
-  boom(): never {
-    throw new Error('she threw');
-  }
-  bad(): Reply {
-    return unreached(); // a shape that is not hers to make: her ward reads it as silence
-  }
-  never(): Promise<Reply> {
-    return new Promise(() => {});
-  }
-  hidden() {
-    return { secret: true };
-  }
-  override describe(asker: Asker): Blueprint {
-    if (this.cells.describe === 'throw') throw new Error('not now');
-    if (this.cells.describe === 'silent') return silence as unknown as Blueprint;
-    return super.describe(asker);
-  }
-  async welcome(id?: string): Promise<Invitation> {
-    return (await this.invite(id ?? `g${++(this.cells.minted as number)}`))!;
-  }
-}
-
-// A caller. Knocks, takes, asks, and hands back exactly what her ward said.
-export class Caller extends Being {
-  static override asks = { hi: { input: { type: 'object' } } };
-  hi() {
-    return { hi: true };
-  }
-  async join(id: string, inv: Invitation): Promise<Answer> {
-    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: string, method?: string, args: JsonObject = {}, wanted?: Wanted): Promise<Answer> {
-    return this.standings[id]!.ask(method, args, wanted);
-  }
-}
-export const classes: Record<string, BeingClass> = { 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
-  spent = 0;
-  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<Caller>(a, 'A', 'alice');
-  const host = B<Host>(b, 'B', 'host');
-  const pub = B<Host>(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 type World = Awaited<ReturnType<typeof world>>;
-
-// What a door answers: the bytes, and whether a key it holds spoke.
-export type Door = (b: Uint8Array) => Promise<{ bytes: Uint8Array; heard: boolean }>;
-
-// A hand at a door, in two halves. `sealed` is the ask as a ward would seal
-// it, with the lid kept so the reply can be opened; `hand` is that and the
-// arrival in one. The halves are apart because vector mode stands a world
-// with the ask sealed and the door not yet knocked on: the verifier brings
-// the bytes, and the stream must already have drawn what the hand draws.
-export type Hand = Partial<seal.AskPayload> & { signer?: Uint8Array; padlock?: Uint8Array };
-export type Sealed = {
-  bytes: Uint8Array; // the ask, exactly as it will arrive
-  open(out: Uint8Array): Promise<seal.ReplyPayload | null>; // what a reply opens to, where the hand holds the lid
-};
-export async function sealed(wardPk: string, to: string | null, h: Hand = {}): Promise<Sealed> {
-  const signer = h.signer ?? rnd();
-  const by = h.by ?? (await seal.beingKey(signer)).pk;
-  const payload: seal.AskPayload = { by, next: null, seq: ++counted, time: 30_000, method: 'hello', args: {}, ...h };
-  delete (payload as Hand).signer;
-  delete (payload as Hand).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: Door, wardPk: string, to: string | null, h: Hand = {}) {
-  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: World) {
-  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 as number;
-  must(JSON.stringify((knock.reply as { object: Json }).object) === JSON.stringify({ hi: `g${minted}` }), `bound g${minted}`);
-  return { inv, own, ownPk, rec: () => P(w.b, 'B').heirs[inv.heir!] };
-}