nervur 0.22.0 → 0.22.2-3

package/src/core/quo/standing.ts

@@ -1,111 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// The standing's side of a relation: it seals asks and reads replies, and
-// moves to its announced key and the following edge key when an object
-// comes back to an ask above every ask it has moved on, and on nothing else.
-//
-// Its state is a value, so a ward keeps it in its partition.
-import { encapsulate, hex, unhex } from '../crypto/index.ts';
-import type { Invitation } from './invitation.ts';
-import { Ephemeral, SigningKey, wardHalves, type Draw } from './keys.ts';
-import { writePayload } from './payload.ts';
-import { readReply, type Reply } from './reply.ts';
-import { checkBody, follow, knockEdge, openReply, sealAsk, signBody, splitBody } from './seal.ts';
-
-export type Read = Reply | { readonly nothing: true };
-
-// A knock that brought no object back: its bytes, sent again as they are,
-// and what the standing moves to if it bound.
-type Knock = { readonly bytes: string; readonly lid: string; readonly next: string; readonly edge: string; readonly seq: number };
-
-export type StandingState = {
-  readonly key: string | null;
-  readonly edge: string | null;
-  readonly sent: number;
-  readonly moved: number;
-  readonly knock: Knock | null;
-  // Whether the last ask after an unanswered knock asked under its own key,
-  // so the next sends the knock again.
-  readonly probed: boolean;
-};
-
-export const freshStanding = (): StandingState => ({ key: null, edge: null, sent: 0, moved: 0, knock: null, probed: false });
-
-// One ask out: what `read` needs to read its reply and to move.
-export type Sent = { readonly bytes: Uint8Array; readonly lid: Ephemeral; readonly next: string; readonly edge: string; readonly seq: number };
-
-export class Standing {
-  readonly invitation: Invitation;
-  state: StandingState;
-  readonly draw: Draw;
-
-  constructor(invitation: Invitation, state: StandingState, draw: Draw) {
-    this.invitation = invitation;
-    this.state = state;
-    this.draw = draw;
-  }
-
-  async ask(method?: string, args?: string): Promise<Sent | null> {
-    const s = this.state;
-    if (s.key !== null) return this.#ask(unhex(s.key), unhex(s.edge!), method, args);
-    if (s.knock === null) return this.#knock(method, args);
-    if (!s.probed) {
-      this.state = { ...s, probed: true };
-      return this.#ask(unhex(s.knock.next), unhex(s.knock.edge), method, args);
-    }
-    this.state = { ...s, probed: false };
-    // The same bytes again: a new lid would be a new box.
-    return { bytes: unhex(s.knock.bytes), lid: await Ephemeral.from(unhex(s.knock.lid)), next: s.knock.next, edge: s.knock.edge, seq: s.knock.seq };
-  }
-
-  async read(sent: Sent, bytes: Uint8Array | null): Promise<Read> {
-    if (bytes === null) return { nothing: true };
-    const reply = await this.#open(sent, bytes);
-    if (reply === null) return { silence: true };
-    if ('object' in reply.text && sent.seq > this.state.moved) {
-      const edge = await follow(unhex(sent.edge), reply.agreement);
-      this.state = { ...this.state, key: sent.next, edge: hex(edge), moved: sent.seq, knock: null, probed: false };
-    }
-    return reply.text;
-  }
-
-  async #knock(method?: string, args?: string): Promise<Sent | null> {
-    const heir = await SigningKey.from(unhex(this.invitation.secret));
-    const next = await SigningKey.draw(this.draw);
-    const lid = await Ephemeral.draw(this.draw);
-    const sent = encapsulate(unhex(this.invitation.lock), this.draw(32));
-    if (sent === null) return null;
-    const edge = await knockEdge(sent.shared);
-    const seq = this.state.sent + 1;
-    const body = await this.#body(heir, next, seq, method, args);
-    const bytes = await sealAsk(lid, unhex(wardHalves(this.invitation.ward).padlock), unhex(this.invitation.heir), edge, body, sent.ciphertext);
-    if (bytes === null) return null;
-    this.state = { ...this.state, sent: seq, knock: { bytes: hex(bytes), lid: hex(lid.secret), next: hex(next.secret), edge: hex(edge), seq } };
-    return { bytes, lid, next: hex(next.secret), edge: hex(edge), seq };
-  }
-
-  async #ask(secret: Uint8Array, edge: Uint8Array, method?: string, args?: string): Promise<Sent | null> {
-    const by = await SigningKey.from(secret);
-    const next = await SigningKey.draw(this.draw);
-    const lid = await Ephemeral.draw(this.draw);
-    const seq = this.state.sent + 1;
-    const body = await this.#body(by, next, seq, method, args);
-    const bytes = await sealAsk(lid, unhex(wardHalves(this.invitation.ward).padlock), unhex(this.invitation.heir), edge, body);
-    if (bytes === null) return null;
-    this.state = { ...this.state, sent: seq };
-    return { bytes, lid, next: hex(next.secret), edge: hex(edge), seq };
-  }
-
-  #body(by: SigningKey, next: SigningKey, seq: number, method?: string, args?: string): Promise<Uint8Array> {
-    const text = writePayload({ to: this.invitation.heir, by: by.id, next: next.id, seq, ...(method === undefined ? {} : { method }), ...(args === undefined ? {} : { args }) });
-    return signBody(new TextEncoder().encode(text), by);
-  }
-
-  async #open(sent: Sent, bytes: Uint8Array): Promise<{ text: Reply; agreement: Uint8Array } | null> {
-    const opened = await openReply(bytes, sent.lid);
-    const body = opened && splitBody(opened.bytes);
-    if (!opened || !body) return null;
-    if (!(await checkBody(unhex(wardHalves(this.invitation.ward).signing), body))) return null;
-    const text = readReply(body.text);
-    return text && { text, agreement: opened.agreement };
-  }
-}

package/src/core/stand/main.ts

@@ -1,20 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// The stand program: one JSON request a line on stdin, one answer a line on
-// stdout, until stdin closes.
-import { createInterface } from 'node:readline';
-import { Stand } from './stand.ts';
-
-const stand = new Stand((n) => globalThis.crypto.getRandomValues(new Uint8Array(n)));
-const pending: Promise<void>[] = [];
-
-for await (const line of createInterface({ input: process.stdin, crlfDelay: Infinity })) {
-  if (line === '') continue;
-  pending.push(
-    stand.handle(line).then(
-      (answer) => void process.stdout.write(`${JSON.stringify(answer)}\n`),
-      (error: unknown) => void process.stderr.write(`${String(error)}\n`),
-    ),
-  );
-}
-await Promise.all(pending);
-await stand.close();

package/src/core/stand/stand.ts

@@ -1,259 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// The stand of `quo/vectors/HARNESS.md`, over `quo/`, `nervur/tcp` and
-// `nervur/http`: part one judged, and part two carried, its wards
-// answering on one tcp listener and one web listener, a post's and a held
-// line's, and asking through a dialer of each.
-import { hex, isHex, unhex } from '../crypto/index.ts';
-import { UNDIALED, type Dialed, type WebListener } from '../harbor/index.ts';
-import { webServe } from '../http/index.ts';
-import { WebDialer } from '../line/index.ts';
-import { Door, freshStanding, MemoryRelations, readInvitation, Standing, tcpAddress, WardKey, webAddress, type Behind, type Choice, type Draw, type Invitation, type Payload, type Read, type Sent } from '../quo/index.ts';
-import { TcpCarrier, TcpListener } from '../tcp/index.ts';
-
-type Answer = Record<string, unknown>;
-const ERRORS = ['bad request', 'no such op', 'no such ward', 'not reached', 'ward stood', 'name held'] as const;
-type Error = (typeof ERRORS)[number];
-class Refused {
-  readonly error: Error;
-  constructor(error: Error) {
-    this.error = error;
-  }
-}
-const refuse = (error: Error): never => {
-  throw new Refused(error);
-};
-
-// What the verifier names behind a door.
-const REACHES: Record<string, (p: Payload) => Choice> = {
-  echo: (p) => ({ object: p.method === undefined ? '{}' : (p.args ?? '{}'), seen: null }),
-  marked: (p) => ({ object: p.method === undefined ? '{}' : (p.args ?? '{}'), seen: p.method === undefined ? null : '1' }),
-  null: () => ({ object: 'null', seen: null }),
-  silent: () => ({ silence: true }),
-};
-
-class StandWard implements Behind {
-  readonly door: Door;
-  readonly zero: boolean;
-  readonly #zero: string | undefined;
-  readonly names = new Map<string, string>();
-  readonly reaches = new Map<string, string>();
-  readonly standings = new Map<string, { standing: Standing; last?: Sent }>();
-
-  constructor(key: WardKey, zero: string | undefined, draw: Draw) {
-    this.#zero = zero;
-    this.zero = zero !== undefined;
-    this.door = new Door(key, new MemoryRelations(), this, draw);
-  }
-
-  answer(heir: string | null, p: Payload): Promise<Choice> {
-    const reach = heir === null ? this.#zero! : this.reaches.get(heir);
-    return Promise.resolve(reach === undefined ? { silence: true } : REACHES[reach]!(p));
-  }
-}
-
-const OPS = new Set(['ward', 'invite', 'release', 'arrive', 'ask', 'read', 'listen', 'route', 'send']);
-
-export class Stand {
-  readonly #wards = new Map<string, StandWard>();
-  readonly #draw: Draw;
-  readonly #tcp = new TcpCarrier();
-  readonly #web = new WebDialer();
-  readonly #routes = new Map<string, string>();
-  #tcpListener: Promise<TcpListener> | undefined;
-  #webListener: Promise<WebListener> | undefined;
-
-  constructor(draw: Draw) {
-    this.#draw = draw;
-  }
-
-  async close(): Promise<void> {
-    await this.#tcp.close();
-    await this.#web.close();
-    await (await this.#tcpListener)?.close();
-    await (await this.#webListener)?.close();
-  }
-
-  // Every ward this program stands, as a listener reaches them.
-  readonly #doors = {
-    arrive: async (pk: string, bytes: Uint8Array): Promise<Uint8Array | null> => {
-      const ward = this.#wards.get(pk);
-      return ward ? (await ward.door.arrive(bytes)).bytes : null;
-    },
-  };
-
-  // Bytes to a ward at one address, over the carrier its scheme names.
-  #dial(at: string, pk: string, bytes: Uint8Array): Promise<Dialed> {
-    return tcpAddress(at) ? this.#tcp.dial(at, pk, bytes) : this.#web.dial(at, pk, bytes);
-  }
-
-  // The addresses this program listens at, for an invitation's `at`.
-  async #listening(): Promise<string[]> {
-    const tcp = await this.#tcpListener;
-    const web = await this.#webListener;
-    return [...(tcp ? [tcp.at] : []), ...(web ? web.at : [])];
-  }
-
-  async handle(line: string): Promise<Answer> {
-    let request: unknown;
-    try {
-      request = JSON.parse(line);
-    } catch {
-      return { id: null, error: 'bad request' };
-    }
-    if (typeof request !== 'object' || request === null || Array.isArray(request)) return { id: null, error: 'bad request' };
-    const r = request as Record<string, unknown>;
-    if (typeof r.id !== 'string') return { id: null, error: 'bad request' };
-    try {
-      return { id: r.id, ...(await this.#op(r)) };
-    } catch (e) {
-      if (e instanceof Refused) return { id: r.id, error: e.error };
-      throw e;
-    }
-  }
-
-  async #op(r: Record<string, unknown>): Promise<Answer> {
-    if (typeof r.op !== 'string') return refuse('bad request');
-    if (!OPS.has(r.op)) return refuse('no such op');
-    switch (r.op) {
-      case 'ward':
-        return this.#ward(text(r.seed), optional(r.reach));
-      case 'invite':
-        return this.#invite(r);
-      case 'release':
-        return this.#release(r);
-      case 'arrive':
-        return this.#arrive(r);
-      case 'ask':
-        return this.#ask(r);
-      case 'read':
-        return this.#read(r);
-      case 'listen':
-        return this.#listen(r.scheme);
-      case 'route':
-        return this.#route(r);
-      default:
-        return this.#send(r);
-    }
-  }
-
-  // One listener of a scheme this program stands, answering for every ward
-  // it stands.
-  async #listen(scheme: unknown): Promise<Answer> {
-    if (scheme === undefined || scheme === 'tcp') {
-      this.#tcpListener ??= TcpListener.listen(this.#doors);
-      return { at: (await this.#tcpListener).at };
-    }
-    if (scheme !== 'http' && scheme !== 'ws') return refuse('bad request');
-    this.#webListener ??= webServe(this.#doors, { host: '127.0.0.1', port: 0, path: '/quo', origins: ['*'] });
-    return { at: (await this.#webListener).at.find((at) => at.startsWith(`${scheme}:`))! };
-  }
-
-  #route(r: Record<string, unknown>): Answer {
-    const far = r.far;
-    if (!isHex(far, 64) || (tcpAddress(r.at) === null && webAddress(r.at) === null)) return refuse('bad request');
-    this.#routes.set(far, r.at as string);
-    return { routed: far };
-  }
-
-  async #send(r: Record<string, unknown>): Promise<Answer> {
-    const invitation = inviteOf(r.invitation);
-    const method = r.method === undefined ? undefined : text(r.method);
-    const args = r.args === undefined ? undefined : objectText(r.args);
-    const ward = this.#ward_(r.ward);
-    const held = this.#standing(ward, invitation);
-    const sent = await held.standing.ask(method, args);
-    if (sent === null) return refuse('bad request');
-    held.last = sent;
-    const far = invitation.ward;
-    const route = this.#routes.get(far);
-    let reply: Uint8Array | null = null;
-    for (const at of route === undefined ? (invitation.at ?? []) : [route]) {
-      const out = await this.#dial(at, far, sent.bytes);
-      if (out === UNDIALED) continue;
-      reply = out;
-      break;
-    }
-    return { read: readOf(await held.standing.read(sent, reply)) };
-  }
-
-  async #ward(seed: string, reach: string | undefined): Promise<Answer> {
-    reached(reach);
-    const key = await WardKey.from(seed);
-    if (this.#wards.has(key.pk)) refuse('ward stood');
-    this.#wards.set(key.pk, new StandWard(key, reach, this.#draw));
-    return { ward: key.pk };
-  }
-
-  async #invite(r: Record<string, unknown>): Promise<Answer> {
-    const name = text(r.heir);
-    const reach = optional(r.reach) ?? 'echo';
-    const ward = this.#ward_(r.ward);
-    reached(reach);
-    if (ward.names.has(name)) refuse('name held');
-    const { heir, invitation } = await ward.door.invite(await this.#listening());
-    ward.names.set(name, heir);
-    ward.reaches.set(heir, reach);
-    return { invitation };
-  }
-
-  #release(r: Record<string, unknown>): Answer {
-    const name = text(r.heir);
-    const ward = this.#ward_(r.ward);
-    const heir = ward.names.get(name);
-    if (heir === undefined) return { released: null };
-    ward.names.delete(name);
-    ward.door.remove(heir);
-    return { released: name };
-  }
-
-  async #arrive(r: Record<string, unknown>): Promise<Answer> {
-    const box = r.box;
-    if (!isHex(box)) return refuse('bad request');
-    const ward = this.#ward_(r.ward);
-    const judged = await ward.door.arrive(unhex(box));
-    return { reply: hex(judged.bytes) };
-  }
-
-  async #ask(r: Record<string, unknown>): Promise<Answer> {
-    const invitation = inviteOf(r.invitation);
-    const method = r.method === undefined ? undefined : text(r.method);
-    const args = r.args === undefined ? undefined : objectText(r.args);
-    const ward = this.#ward_(r.ward);
-    const held = this.#standing(ward, invitation);
-    const sent = await held.standing.ask(method, args);
-    if (sent === null) return refuse('bad request');
-    held.last = sent;
-    return { box: hex(sent.bytes) };
-  }
-
-  async #read(r: Record<string, unknown>): Promise<Answer> {
-    const invitation = inviteOf(r.invitation);
-    if (r.reply !== null && !isHex(r.reply)) return refuse('bad request');
-    const ward = this.#ward_(r.ward);
-    const held = this.#standing(ward, invitation);
-    if (held.last === undefined) return refuse('bad request');
-    const read = await held.standing.read(held.last, r.reply === null ? null : unhex(r.reply as string));
-    return { read: readOf(read) };
-  }
-
-  #standing(ward: StandWard, invitation: Invitation): { standing: Standing; last?: Sent } {
-    const key = `${invitation.ward}.${invitation.heir}`;
-    let held = ward.standings.get(key);
-    if (!held) ward.standings.set(key, (held = { standing: new Standing(invitation, freshStanding(), this.#draw) }));
-    return held;
-  }
-
-  #ward_(pk: unknown): StandWard {
-    if (!isHex(pk, 64)) return refuse('bad request');
-    return this.#wards.get(pk) ?? refuse('no such ward');
-  }
-}
-
-const text = (value: unknown): string => (typeof value === 'string' ? value : refuse('bad request'));
-const optional = (value: unknown): string | undefined => (value === undefined ? undefined : text(value));
-const reached = (reach: string | undefined): void => {
-  if (reach !== undefined && !Object.hasOwn(REACHES, reach)) refuse('not reached');
-};
-const inviteOf = (value: unknown): Invitation => readInvitation(value) ?? refuse('bad request');
-const objectText = (value: unknown): string => (typeof value === 'object' && value !== null && !Array.isArray(value) ? JSON.stringify(value) : refuse('bad request'));
-const readOf = (read: Read): unknown => ('object' in read ? { object: JSON.parse(read.object) as unknown, seen: read.seen } : read);

package/src/core/tcp/index.ts

@@ -1,227 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// Quo over TCP: `nervur/tcp`, an entry that names a platform, Node's
-// sockets.
-//
-//   TcpCarrier    a Carrier that dials: bytes to a ward pk go in an ask
-//                 frame to the `tcp://host:port` addresses its book holds
-//                 for that pk, in their order
-//   TcpListener   answers ask frames for the doors it is handed, a harbor
-//                 among them, at a `tcp://` address
-//   NodeSockets   both, as the body a Node terrain hands the TCP carrier
-//
-// A connection is opened per address, carries many asks at once, and is
-// dropped when either side closes it; the next ask dials again. An ask
-// goes to the next address only when the one before could not be dialed,
-// since an ask a line took may have been heard.
-import { connect, createServer, type Server, type Socket } from 'node:net';
-import { hex, isHex, unhex } from '../crypto/index.ts';
-import { Carrier } from '../contract/index.ts';
-import { UNDIALED, type Arrivals, type Dialed, type Sockets } from '../harbor/index.ts';
-import { tcpAddress, tcpAt, type TcpAddress } from '../quo/index.ts';
-import { askFrame, FrameReader, nothingFrame, replyFrame } from '../line/index.ts';
-
-// What a listener hands an ask to: bytes for a ward pk, or nothing.
-export interface Doors {
-  arrive(pk: string, bytes: Uint8Array): Promise<Uint8Array | null>;
-}
-
-const MAX_ID = 0xffff_ffff;
-
-// The `tcp` addresses among some, in their order.
-const tcpAddresses = (at: readonly string[]): TcpAddress[] => at.map(tcpAddress).filter((a): a is TcpAddress => a !== null);
-
-class Line {
-  readonly #socket: Socket;
-  readonly #reader = new FrameReader();
-  readonly #waiting = new Map<number, (box: Uint8Array | null) => void>();
-  #next = 1;
-  closed = false;
-
-  constructor(socket: Socket, onClose: () => void) {
-    this.#socket = socket;
-    socket.on('data', (chunk: Buffer) => {
-      for (const f of this.#reader.push(new Uint8Array(chunk))) {
-        if (f.kind === 'ask') continue;
-        const resolve = this.#waiting.get(f.id);
-        this.#waiting.delete(f.id);
-        resolve?.(f.kind === 'reply' ? f.box : null);
-      }
-      if (this.#reader.bad) socket.destroy();
-    });
-    socket.on('error', () => socket.destroy());
-    socket.on('close', () => {
-      this.closed = true;
-      onClose();
-      for (const resolve of this.#waiting.values()) resolve(null);
-      this.#waiting.clear();
-    });
-  }
-
-  static open(host: string, port: number, onClose: () => void): Promise<Line | null> {
-    return new Promise((resolve) => {
-      const socket = connect({ host, port });
-      socket.once('connect', () => resolve(new Line(socket, onClose)));
-      socket.once('error', () => {
-        socket.destroy();
-        resolve(null);
-      });
-    });
-  }
-
-  ask(pk: Uint8Array, box: Uint8Array): Promise<Uint8Array | null> {
-    if (this.closed) return Promise.resolve(null);
-    const id = this.#next;
-    this.#next = this.#next === MAX_ID ? 1 : this.#next + 1;
-    return new Promise((resolve) => {
-      this.#waiting.set(id, resolve);
-      this.#socket.write(askFrame(id, pk, box));
-    });
-  }
-
-  close(): void {
-    this.#socket.destroy();
-  }
-}
-
-export class TcpCarrier extends Carrier {
-  readonly #routes = new Map<string, TcpAddress[]>();
-  readonly #lines = new Map<string, Promise<Line | null>>();
-
-  // Where a ward pk is reached, replacing any route before: its `tcp`
-  // addresses in order, the others skipped. A list with none is not
-  // taken; null forgets the route.
-  route(pk: string, at: readonly string[] | null): boolean {
-    if (!isHex(pk, 64)) return false;
-    if (at === null) return this.#routes.delete(pk) || true;
-    const mine = tcpAddresses(at);
-    if (mine.length === 0) return false;
-    this.#routes.set(pk, mine);
-    return true;
-  }
-
-  // Whether a ward pk has a route.
-  routed(pk: string): boolean {
-    return this.#routes.has(pk);
-  }
-
-  // Nothing where the pk has no route, no address is reached, or the
-  // connection closed before an answer.
-  carry(pk: string, bytes: Uint8Array): Promise<Uint8Array | null> {
-    return this.#carry(this.#routes.get(pk) ?? [], pk, bytes);
-  }
-
-  // Bytes to a ward pk at the addresses named, as a route would carry them.
-  carryAt(at: readonly string[], pk: string, bytes: Uint8Array): Promise<Uint8Array | null> {
-    return isHex(pk, 64) ? this.#carry(tcpAddresses(at), pk, bytes) : Promise.resolve(null);
-  }
-
-  async #carry(addresses: readonly TcpAddress[], pk: string, bytes: Uint8Array): Promise<Uint8Array | null> {
-    for (const address of addresses) {
-      const out = await this.#dial(address, pk, bytes);
-      if (out !== UNDIALED) return out;
-    }
-    return null;
-  }
-
-  // Bytes to a ward pk at one address, or `UNDIALED` where no line opens.
-  dial(at: string, pk: string, bytes: Uint8Array): Promise<Dialed> {
-    const address = tcpAddress(at);
-    return address && isHex(pk, 64) ? this.#dial(address, pk, bytes) : Promise.resolve(UNDIALED);
-  }
-
-  async #dial(address: TcpAddress, pk: string, bytes: Uint8Array): Promise<Dialed> {
-    const line = await this.#line(address);
-    return line ? line.ask(unhex(pk), bytes) : UNDIALED;
-  }
-
-  #line({ host, port }: TcpAddress): Promise<Line | null> {
-    const at = tcpAt(host, port);
-    let line = this.#lines.get(at);
-    if (!line) {
-      line = Line.open(host, port, () => this.#lines.delete(at)).then((dialed) => {
-        if (!dialed) this.#lines.delete(at);
-        return dialed;
-      });
-      this.#lines.set(at, line);
-    }
-    return line;
-  }
-
-  async close(): Promise<void> {
-    const lines = [...this.#lines.values()];
-    this.#lines.clear();
-    for (const line of await Promise.all(lines)) line?.close();
-  }
-}
-
-export class TcpListener {
-  readonly #server: Server;
-  readonly #doors: Doors;
-  readonly #sockets = new Set<Socket>();
-
-  private constructor(doors: Doors) {
-    this.#doors = doors;
-    this.#server = createServer((socket) => this.#serve(socket));
-  }
-
-  // A listener on `host` and `port`, 127.0.0.1 and a free port unless named.
-  static listen(doors: Doors, host = '127.0.0.1', port = 0): Promise<TcpListener> {
-    const listener = new TcpListener(doors);
-    return new Promise((resolve, reject) => {
-      listener.#server.once('error', reject);
-      listener.#server.listen(port, host, () => resolve(listener));
-    });
-  }
-
-  // The `tcp://host:port` address this listener answers at.
-  get at(): string {
-    const address = this.#server.address() as { address: string; port: number };
-    return tcpAt(address.address, address.port);
-  }
-
-  #serve(socket: Socket): void {
-    this.#sockets.add(socket);
-    const reader = new FrameReader();
-    socket.on('data', (chunk: Buffer) => {
-      for (const f of reader.push(new Uint8Array(chunk))) {
-        if (f.kind === 'ask') void this.#answer(socket, f.id, f.pk, f.box);
-      }
-      if (reader.bad) socket.destroy();
-    });
-    socket.on('error', () => socket.destroy());
-    socket.on('close', () => this.#sockets.delete(socket));
-  }
-
-  async #answer(socket: Socket, id: number, pk: Uint8Array, box: Uint8Array): Promise<void> {
-    let reply: Uint8Array | null = null;
-    try {
-      reply = await this.#doors.arrive(hex(pk), box);
-    } catch {
-      reply = null;
-    }
-    if (!socket.destroyed) socket.write(reply === null ? nothingFrame(id) : replyFrame(id, reply));
-  }
-
-  close(): Promise<void> {
-    for (const socket of this.#sockets) socket.destroy();
-    return new Promise((resolve) => this.#server.close(() => resolve()));
-  }
-}
-
-// Node's sockets under the TCP carrier: a dialer of its own for each
-// carrier that asks, and a listener wherever it is told.
-export class NodeSockets implements Sockets {
-  readonly #dialer = new TcpCarrier();
-
-  dial(address: string, pk: string, bytes: Uint8Array): Promise<Dialed> {
-    return this.#dialer.dial(address, pk, bytes);
-  }
-
-  listen(ground: Arrivals, host: string, port: number): Promise<TcpListener> {
-    return TcpListener.listen(ground, host, port);
-  }
-
-  close(): Promise<void> {
-    return this.#dialer.close();
-  }
-}

package/src/core/ward/allowance.ts

@@ -1,47 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// The allowance: how long a being waits on one ask. It is on no wire. A
-// being who says nothing gets the default, and nobody gets past the
-// ceiling.
-import type { Clock } from '../contract/index.ts';
-import type { Wanted } from '../being/index.ts';
-
-export const DEFAULT = 30_000;
-export const CEILING = 300_000;
-
-export const allow = (wanted: Wanted | undefined): number => {
-  const whole = typeof wanted?.time === 'number' ? Math.floor(wanted.time) : NaN;
-  return Math.min(Number.isFinite(whole) && whole > 0 ? whole : DEFAULT, CEILING);
-};
-
-export const LATE: unique symbol = Symbol('late');
-export type Late = typeof LATE;
-
-// One ask's bell. It bounds the wait of the being who asked and the send
-// that holds the relation's line, so a far side that never answers holds
-// neither for longer than the allowance.
-export class Bell {
-  readonly #wait: { done: Promise<void>; cancel(): void };
-  readonly #late: Promise<Late>;
-  #rang = false;
-
-  constructor(clock: Clock, ms: number) {
-    this.#wait = clock.wait(ms);
-    this.#late = this.#wait.done.then((): Late => {
-      this.#rang = true;
-      return LATE;
-    });
-  }
-
-  get rang(): boolean {
-    return this.#rang;
-  }
-
-  race<T>(work: Promise<T>): Promise<T | Late> {
-    work.catch(() => {});
-    return Promise.race([work, this.#late]);
-  }
-
-  cancel(): void {
-    this.#wait.cancel();
-  }
-}