nervur 0.22.0 → 0.22.2-3

package/dist/core/quo/address.d.ts

@@ -1,19 +0,0 @@
-export declare const schemeOf: (s: unknown) => string | null;
-export type TcpAddress = {
-    host: string;
-    port: number;
-};
-export declare const tcpAddress: (s: unknown) => TcpAddress | null;
-export declare const tcpAt: (host: string, port: number) => string;
-export type WebAddress = {
-    scheme: 'http' | 'https' | 'ws' | 'wss';
-    secure: boolean;
-    held: boolean;
-    host: string;
-    port: number;
-    path: string;
-    href: string;
-};
-export declare const webAddress: (s: unknown) => WebAddress | null;
-export declare const unspecified: (s: unknown) => boolean;
-export declare const readAt: (value: unknown) => string[];

package/dist/core/quo/address.js

@@ -1,84 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// Addresses, as `SPEC.md` names them in an invitation's `at`: a URI of
-// RFC 3986 whose scheme, read in any case, names a carrier.
-// `CARRIER-TCP.md` writes `tcp://host:port`, and `CARRIER-WEB.md` writes
-// `http` and `https` for the post and `ws` and `wss` for the held line.
-// RFC 3986 appendix B, with the characters a URI may hold checked apart.
-const SPLIT = /^(?:([^:/?#]+):)?(?:\/\/([^/?#]*))?([^?#]*)(?:\?([^#]*))?(?:#(.*))?$/;
-const URI_CHARS = /^(?:[A-Za-z0-9\-._~:/?#[\]@!$&'()*+,;=]|%[0-9A-Fa-f]{2})*$/;
-const SCHEME = /^[A-Za-z][A-Za-z0-9+.-]*$/;
-const REG_NAME = /^(?:[A-Za-z0-9\-._~!$&'()*+,;=]|%[0-9A-Fa-f]{2})*$/;
-const IP_LITERAL = /^\[(?:[0-9A-Fa-f:.]+|v[0-9A-Fa-f]+\.[A-Za-z0-9\-._~!$&'()*+,;=:]+)\]$/;
-// A URI with a scheme, taken apart, or null. `host` is as written,
-// brackets included, and `port` the digits as written.
-const parse = (s) => {
-    if (typeof s !== 'string' || !URI_CHARS.test(s))
-        return null;
-    const m = SPLIT.exec(s);
-    if (!m || m[1] === undefined || !SCHEME.test(m[1]))
-        return null;
-    const out = { scheme: m[1].toLowerCase(), authority: m[2] ?? null, userinfo: null, host: null, port: null, path: m[3] ?? '', query: m[4] ?? null, fragment: m[5] ?? null };
-    if (out.authority === null)
-        return out;
-    let rest = out.authority;
-    const at = rest.lastIndexOf('@');
-    if (at >= 0) {
-        out.userinfo = rest.slice(0, at);
-        rest = rest.slice(at + 1);
-    }
-    const hp = /^(\[[^\]]*\]|[^:[\]]*)(?::([0-9]*))?$/.exec(rest);
-    if (!hp)
-        return null;
-    const host = hp[1];
-    if (host.startsWith('[') ? !IP_LITERAL.test(host) : !REG_NAME.test(host))
-        return null;
-    out.host = host;
-    out.port = hp[2] ?? null;
-    return out;
-};
-// The host as a socket takes it: an IPv6 literal without its brackets.
-const bare = (host) => (host.startsWith('[') ? host.slice(1, -1) : host);
-// The scheme an address names, lowercase, or null for what is no URI.
-export const schemeOf = (s) => parse(s)?.scheme ?? null;
-// A `tcp` address as `CARRIER-TCP.md` writes one, or null.
-export const tcpAddress = (s) => {
-    const a = parse(s);
-    if (!a || a.scheme !== 'tcp' || a.authority === null)
-        return null;
-    if (a.userinfo !== null || a.path !== '' || a.query !== null || a.fragment !== null)
-        return null;
-    if (!a.host || a.port === null || !/^[0-9]+$/.test(a.port))
-        return null;
-    const port = Number(a.port);
-    if (port < 1 || port > 65_535)
-        return null;
-    return { host: bare(a.host), port };
-};
-// The `tcp` address of a host and port.
-export const tcpAt = (host, port) => `tcp://${host.includes(':') ? `[${host}]` : host}:${port}`;
-const WEB = new Set(['http', 'https', 'ws', 'wss']);
-// An address of `CARRIER-WEB.md`, or null. `path` is the path and query
-// a request names, `/` when both are empty.
-export const webAddress = (s) => {
-    const a = parse(s);
-    if (!a || !WEB.has(a.scheme) || a.authority === null)
-        return null;
-    if (a.userinfo !== null || a.fragment !== null || !a.host)
-        return null;
-    if (a.port !== null && a.port !== '' && (!/^[0-9]+$/.test(a.port) || Number(a.port) > 65_535))
-        return null;
-    const scheme = a.scheme;
-    const secure = scheme === 'https' || scheme === 'wss';
-    const port = a.port ? Number(a.port) : secure ? 443 : 80;
-    const path = `${a.path || '/'}${a.query !== null ? `?${a.query}` : ''}`;
-    return { scheme, secure, held: scheme === 'ws' || scheme === 'wss', host: bare(a.host), port, path, href: s };
-};
-// Whether a tcp or web address names the unspecified host, where a
-// listener binds every interface and no caller can dial.
-export const unspecified = (s) => {
-    const host = (tcpAddress(s) ?? webAddress(s))?.host;
-    return host === '0.0.0.0' || host === '::';
-};
-// An invitation's `at` as `SPEC.md` reads it: the strings that are URIs
-// with a scheme, in their order. A value that is no array is absent.
-export const readAt = (value) => (Array.isArray(value) ? value.filter((s) => parse(s) !== null) : []);

package/dist/core/quo/door.d.ts

@@ -1,34 +0,0 @@
-import { type Draw, type WardKey } from './keys.ts';
-import type { Invitation } from './invitation.ts';
-import { type Payload } from './payload.ts';
-import type { Relations } from './relations.ts';
-export declare const SPAN = 64;
-export type Choice = {
-    readonly object: string;
-    readonly seen: string | null;
-} | {
-    readonly silence: true;
-};
-export interface Behind {
-    readonly zero: boolean;
-    answer(heir: string | null, payload: Payload): Promise<Choice>;
-}
-export type Judged = {
-    bytes: Uint8Array;
-    case: number;
-    heard: boolean;
-};
-export declare class Door {
-    #private;
-    readonly key: WardKey;
-    readonly relations: Relations;
-    readonly behind: Behind;
-    readonly draw: Draw;
-    constructor(key: WardKey, relations: Relations, behind: Behind, draw: Draw);
-    invite(at?: readonly string[]): Promise<{
-        heir: string;
-        invitation: Invitation;
-    }>;
-    remove(heir: string): boolean;
-    arrive(bytes: Uint8Array): Promise<Judged>;
-}

package/dist/core/quo/door.js

@@ -1,174 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// The door: an ask's box in, a reply's box out, judged by the thirteen cases
-// of the spec in their order. A stranger hears one silence whatever the
-// case. The case is handed back beside the bytes, for the kit's own eyes,
-// with `heard`: whether a key the door holds or keeps spoke.
-import { decapsulate, hex, unhex, utf8, x25519Public, zero } from '../crypto/index.js';
-import { drawLock, SigningKey } from './keys.js';
-import { readPayload } from './payload.js';
-import { writeReply } from './reply.js';
-import { checkBody, follow, HEAD, knockEdge, openBody, openHead, replyKey, sealReply, signBody, SIZE, splitBody, splitKnock, ZERO_EDGE } from './seal.js';
-// The count numbers below the highest a door still honours: those within
-// this span that it has not seen.
-export const SPAN = 64;
-export class Door {
-    key;
-    relations;
-    behind;
-    draw;
-    constructor(key, relations, behind, draw) {
-        this.key = key;
-        this.relations = relations;
-        this.behind = behind;
-        this.draw = draw;
-    }
-    // A new heir, held fresh, and its invitation. The lock is drawn at the
-    // first invitation that names an heir, before the heir's secret.
-    // A new heir, and its invitation, naming in `at` the addresses given.
-    async invite(at = []) {
-        let lock = this.relations.lock();
-        if (!lock)
-            this.relations.setLock((lock = drawLock(this.draw)));
-        const heir = await SigningKey.draw(this.draw);
-        this.relations.set(heir.id, { state: 'fresh' });
-        const invitation = { ward: this.key.pk, heir: heir.id, secret: hex(heir.secret), lock: hex(lock.ek), ...(at.length > 0 ? { at: [...at] } : {}) };
-        return { heir: heir.id, invitation };
-    }
-    // The door stops holding an heir. A fresh one leaves nothing, a spent one
-    // leaves the keys kept at removal.
-    remove(heir) {
-        const record = this.relations.get(heir);
-        if (record === undefined || record.state === 'kept')
-            return false;
-        if (record.state === 'fresh')
-            this.relations.delete(heir);
-        else
-            this.relations.set(heir, { state: 'kept', held: record.held, vouched: record.vouched, open: record.open, offered: record.offered });
-        return true;
-    }
-    async arrive(bytes) {
-        const stranger = async (n) => ({ bytes: await this.#silence(bytes), case: n, heard: false });
-        if (bytes.length > SIZE || bytes.length < HEAD)
-            return stranger(1);
-        const agreement = await this.key.open(bytes.subarray(0, HEAD));
-        const opened = agreement && (await openHead(bytes, agreement));
-        if (!opened)
-            return stranger(1);
-        const isZero = zero(opened.head);
-        const heir = hex(opened.head);
-        const record = isZero ? undefined : this.relations.get(heir);
-        const body = await this.#body(opened, record);
-        if (!body)
-            return stranger(1);
-        const read = readPayload(body.text);
-        if ('fault' in read)
-            return stranger(read.fault === 'not an object' ? 2 : 3);
-        const p = read.payload;
-        if (isZero ? p.to !== null : p.to !== heir)
-            return stranger(3);
-        if (isZero) {
-            if (!this.behind.zero)
-                return stranger(4);
-            if (!(await checkBody(unhex(p.by), body)))
-                return stranger(5);
-            const choice = await this.#choose(null, p);
-            return { bytes: await this.#sealed(opened, choice), case: 'object' in choice ? 12 : 13, heard: false };
-        }
-        if (record === undefined)
-            return stranger(6);
-        if (!admits(record, heir, p.by))
-            return stranger(7);
-        if (!(await checkBody(unhex(p.by), body)))
-            return stranger(8);
-        const reply = await replyKey(this.draw, opened.lid);
-        if (!reply)
-            return stranger(1);
-        const offered = await follow(body.edge, reply.agreement);
-        // Checked again, since another arrival may have moved the keys while
-        // this one was checking its signature.
-        const now = this.relations.get(heir);
-        if (now === undefined || !admits(now, heir, p.by) || !opensUnder(now, body.edge))
-            return stranger(7);
-        if (now.state === 'kept')
-            return this.#heard(reply, { quo: 'removed' }, 9);
-        if (now.state === 'fresh' && (p.next === null || p.next === heir))
-            return this.#heard(reply, { quo: 'unannounced' }, 10);
-        if (now.state === 'spent' && !honours(now, p.seq))
-            return this.#heard(reply, { quo: 'repeated' }, 11);
-        this.relations.set(heir, move(now, heir, p, hex(body.edge), hex(offered)));
-        const choice = await this.#choose(heir, p);
-        const kept = await this.relations.kept().catch(() => false);
-        return this.#heard(reply, kept ? choice : { silence: true }, kept && 'object' in choice ? 12 : 13);
-    }
-    async #heard(key, reply, n) {
-        return { bytes: await sealReply(key, await this.#signed(reply)), case: n, heard: true };
-    }
-    #signed(reply) {
-        return signBody(utf8(writeReply(reply)), this.key.signing);
-    }
-    async #choose(heir, p) {
-        try {
-            return await this.behind.answer(heir, p);
-        }
-        catch {
-            return { silence: true };
-        }
-    }
-    async #sealed(opened, reply) {
-        const key = await replyKey(this.draw, opened.lid);
-        return key ? sealReply(key, await this.#signed(reply)) : this.#silence(opened.lid);
-    }
-    // The body, opened under the edge keys the door takes for this head.
-    async #body(opened, record) {
-        const tries = [];
-        if (record?.state === 'fresh') {
-            const knock = splitKnock(opened.rest);
-            const lock = this.relations.lock();
-            const shared = knock && lock ? decapsulate(lock.dk, knock.ciphertext) : null;
-            if (!knock || !shared)
-                return null;
-            tries.push({ edge: await knockEdge(shared), sealed: knock.sealedBody });
-        }
-        else if (record === undefined)
-            tries.push({ edge: ZERO_EDGE, sealed: opened.rest });
-        else
-            for (const edge of [record.open, record.offered])
-                tries.push({ edge: unhex(edge), sealed: opened.rest });
-        for (const { edge, sealed } of tries) {
-            const plain = await openBody(opened, edge, sealed);
-            if (plain === null)
-                continue;
-            const body = splitBody(plain);
-            return body && { edge, ...body };
-        }
-        return null;
-    }
-    // A stranger's silence: sealed to the first thirty-two bytes that arrived
-    // when they take a seal, and otherwise to a lid nobody holds.
-    async #silence(arrived) {
-        const text = await this.#signed({ silence: true });
-        const candidates = [arrived.length >= HEAD ? arrived.subarray(0, HEAD) : null, this.draw(HEAD)];
-        for (const lid of candidates) {
-            const key = lid && (await replyKey(this.draw, lid));
-            if (key)
-                return sealReply(key, text);
-        }
-        return sealReply((await replyKey(this.draw, await x25519Public(this.draw(HEAD)))), text);
-    }
-}
-const admits = (record, heir, by) => (record.state === 'fresh' ? by === heir : by === record.held || by === record.vouched);
-const opensUnder = (record, edge) => record.state === 'fresh' || hex(edge) === record.open || hex(edge) === record.offered;
-const honours = (record, seq) => seq > record.highest || (seq > record.highest - SPAN && seq !== record.highest && !record.honoured.includes(seq));
-// The move tables: the keys and edge keys after a choice, and the count.
-const move = (record, heir, p, edge, offered) => {
-    const announced = p.next !== null && p.next !== heir && p.next !== p.by ? p.next : null;
-    if (record.state === 'fresh')
-        return { state: 'spent', held: announced, vouched: null, open: edge, offered, highest: p.seq, honoured: [] };
-    if (record.state !== 'spent')
-        return record;
-    if (p.seq < record.highest)
-        return { ...record, honoured: [...record.honoured, p.seq] };
-    const keys = p.by === record.held ? { held: record.held, vouched: announced ?? record.vouched, open: edge, offered } : { held: p.by, vouched: announced, open: edge, offered };
-    const honoured = [...record.honoured, record.highest].filter((n) => n > p.seq - SPAN);
-    return { state: 'spent', ...keys, highest: p.seq, honoured };
-};

package/dist/core/quo/index.d.ts

@@ -1,9 +0,0 @@
-export { readAt, schemeOf, tcpAddress, tcpAt, unspecified, webAddress, type TcpAddress, type WebAddress } from './address.ts';
-export { Door, SPAN, type Behind, type Choice, type Judged } from './door.ts';
-export { readInvitation, type Invitation } from './invitation.ts';
-export { Ephemeral, SigningKey, WardKey, type Draw } from './keys.ts';
-export { readPayload, writePayload, type Payload } from './payload.ts';
-export { GONE, keptLock, lockOf, MemoryRelations, type HeirRecord, type KeptLock, type Relations } from './relations.ts';
-export { readReply, SILENCE, WORDS, writeReply, type Reply, type Word } from './reply.ts';
-export { SIZE } from './seal.ts';
-export { freshStanding, Standing, type Read, type Sent, type StandingState } from './standing.ts';

package/dist/core/quo/index.js

@@ -1,12 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// Quo's wire: keys, the invitation, the payload, the reply, the boxes, the
-// door and the standing. It knows no being, no ward and no terrain.
-export { readAt, schemeOf, tcpAddress, tcpAt, unspecified, webAddress } from './address.js';
-export { Door, SPAN } from './door.js';
-export { readInvitation } from './invitation.js';
-export { Ephemeral, SigningKey, WardKey } from './keys.js';
-export { readPayload, writePayload } from './payload.js';
-export { GONE, keptLock, lockOf, MemoryRelations } from './relations.js';
-export { readReply, SILENCE, WORDS, writeReply } from './reply.js';
-export { SIZE } from './seal.js';
-export { freshStanding, Standing } from './standing.js';

package/dist/core/quo/invitation.d.ts

@@ -1,8 +0,0 @@
-export type Invitation = {
-    readonly ward: string;
-    readonly heir: string;
-    readonly secret: string;
-    readonly lock: string;
-    readonly at?: string[];
-};
-export declare const readInvitation: (value: unknown) => Invitation | null;

package/dist/core/quo/invitation.js

@@ -1,19 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// The invitation: `{ ward, heir, secret, lock, at? }`. A door reads no
-// route from it; `at`, when present, names where the ward is reached.
-import { EK, encapsulate, isHex, unhex } from '../crypto/index.js';
-import { readAt } from './address.js';
-// An invitation, or null for any other shape. A field beside the five is
-// ignored, the lock is held to the modulus check, and `at` keeps the
-// addresses it holds, an `at` with none or of another shape being absent.
-export const readInvitation = (value) => {
-    if (typeof value !== 'object' || value === null || Array.isArray(value))
-        return null;
-    const { ward, heir, secret, lock, at } = value;
-    if (!isHex(ward, 64) || !isHex(heir, 32) || !isHex(secret, 32) || !isHex(lock, EK))
-        return null;
-    if (encapsulate(unhex(lock), new Uint8Array(32)) === null)
-        return null;
-    const addresses = readAt(at);
-    return { ward, heir, secret, lock, ...(addresses.length > 0 ? { at: addresses } : {}) };
-};

package/dist/core/quo/keys.d.ts

@@ -1,40 +0,0 @@
-import { type Lock } from '../crypto/index.ts';
-export type Draw = (length: number) => Uint8Array;
-export declare const LABEL: {
-    readonly seal: Uint8Array<ArrayBufferLike>;
-    readonly edgeSeal: Uint8Array<ArrayBufferLike>;
-    readonly lock: Uint8Array<ArrayBufferLike>;
-    readonly edge: Uint8Array<ArrayBufferLike>;
-    readonly wardSign: Uint8Array<ArrayBufferLike>;
-    readonly wardSeal: Uint8Array<ArrayBufferLike>;
-};
-export declare class SigningKey {
-    readonly secret: Uint8Array;
-    readonly pk: Uint8Array;
-    private constructor();
-    static from(secret: Uint8Array): Promise<SigningKey>;
-    static draw(draw: Draw): Promise<SigningKey>;
-    get id(): string;
-}
-export declare class Ephemeral {
-    readonly secret: Uint8Array;
-    readonly pk: Uint8Array;
-    private constructor();
-    static from(secret: Uint8Array): Promise<Ephemeral>;
-    static draw(draw: Draw): Promise<Ephemeral>;
-    agree(pk: Uint8Array): Promise<Uint8Array | null>;
-}
-export declare class WardKey {
-    readonly signing: SigningKey;
-    readonly sealSecret: Uint8Array;
-    readonly padlock: Uint8Array;
-    private constructor();
-    static from(seed: Uint8Array | string): Promise<WardKey>;
-    get pk(): string;
-    open(lid: Uint8Array): Promise<Uint8Array | null>;
-}
-export declare const wardHalves: (pk: string) => {
-    signing: string;
-    padlock: string;
-};
-export declare const drawLock: (draw: Draw) => Lock;

package/dist/core/quo/keys.js

@@ -1,79 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// The keys of Quo: the ward key derived from a seed, and every other key
-// drawn. A draw is the caller's, so this layer names no source of bytes.
-import { agree, ed25519Public, hex, hkdf, lockFrom, sha256, utf8, x25519Public } from '../crypto/index.js';
-export const LABEL = {
-    seal: utf8('quo-seal'),
-    edgeSeal: utf8('quo-edge-seal'),
-    lock: utf8('quo-lock'),
-    edge: utf8('quo-edge'),
-    wardSign: utf8('quo-ward-sign'),
-    wardSeal: utf8('quo-ward-seal'),
-};
-// An Ed25519 pair: an heir, or a standing's own key.
-export class SigningKey {
-    secret;
-    pk;
-    constructor(secret, pk) {
-        this.secret = secret;
-        this.pk = pk;
-    }
-    static async from(secret) {
-        return new SigningKey(secret, await ed25519Public(secret));
-    }
-    static draw(draw) {
-        return SigningKey.from(draw(32));
-    }
-    get id() {
-        return hex(this.pk);
-    }
-}
-// An X25519 pair used for one box.
-export class Ephemeral {
-    secret;
-    pk;
-    constructor(secret, pk) {
-        this.secret = secret;
-        this.pk = pk;
-    }
-    static async from(secret) {
-        return new Ephemeral(secret, await x25519Public(secret));
-    }
-    static draw(draw) {
-        return Ephemeral.from(draw(32));
-    }
-    agree(pk) {
-        return agree(this.secret, pk);
-    }
-}
-// The ward key: a signing pair and a padlock, both from the seed.
-export class WardKey {
-    signing;
-    sealSecret;
-    padlock;
-    constructor(signing, sealSecret, padlock) {
-        this.signing = signing;
-        this.sealSecret = sealSecret;
-        this.padlock = padlock;
-    }
-    // Thirty-two bytes are the seed. Text, and bytes of any other length, are
-    // hashed to it first.
-    static async from(seed) {
-        const bytes = typeof seed === 'string' ? await sha256(utf8(seed)) : seed.length === 32 ? seed : await sha256(seed);
-        const sealSecret = await hkdf(bytes, LABEL.wardSeal, 32);
-        return new WardKey(await SigningKey.from(await hkdf(bytes, LABEL.wardSign, 32)), sealSecret, await x25519Public(sealSecret));
-    }
-    get pk() {
-        return hex(this.signing.pk) + hex(this.padlock);
-    }
-    open(lid) {
-        return agree(this.sealSecret, lid);
-    }
-}
-// A ward pk's two halves.
-export const wardHalves = (pk) => ({ signing: pk.slice(0, 64), padlock: pk.slice(64) });
-// A lock from sixty-four drawn bytes.
-export const drawLock = (draw) => {
-    const bytes = draw(64);
-    return lockFrom(bytes.subarray(0, 32), bytes.subarray(32));
-};

package/dist/core/quo/payload.d.ts

@@ -1,15 +0,0 @@
-export type Payload = {
-    readonly to: string | null;
-    readonly by: string;
-    readonly next: string | null;
-    readonly seq: number;
-    readonly method?: string;
-    readonly args?: string;
-};
-export declare const writePayload: (p: Payload) => string;
-export type PayloadRead = {
-    payload: Payload;
-} | {
-    fault: 'not an object' | 'not well formed';
-};
-export declare const readPayload: (bytes: Uint8Array) => PayloadRead;

package/dist/core/quo/payload.js

@@ -1,55 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// The payload: `{ to, by, next, seq, method?, args? }`. `args` is carried as
-// the text it was written in, since Quo reads nothing inside it.
-import { isCount, isHex, readObject } from '../crypto/index.js';
-const OWED = ['to', 'by', 'next', 'seq'];
-const ZERO = '0'.repeat(64);
-const isPk = (text) => isHex(text, 32) && text !== ZERO;
-// A pk written as a JSON string, or null written as null.
-const pkOrNull = (text, nullable) => {
-    if (nullable && text === 'null')
-        return null;
-    if (!/^"[0-9a-f]{64}"$/.test(text))
-        return undefined;
-    const pk = text.slice(1, -1);
-    return isPk(pk) ? pk : undefined;
-};
-export const writePayload = (p) => {
-    const parts = [`"to":${JSON.stringify(p.to)}`, `"by":"${p.by}"`, `"next":${JSON.stringify(p.next)}`, `"seq":${p.seq}`];
-    if (p.method !== undefined)
-        parts.push(`"method":${JSON.stringify(p.method)}`);
-    if (p.args !== undefined)
-        parts.push(`"args":${p.args}`);
-    return `{${parts.join(',')}}`;
-};
-// Cases 2 and 3 of the door, before the head is compared.
-export const readPayload = (bytes) => {
-    const fields = readObject(bytes);
-    if (fields === null)
-        return { fault: 'not an object' };
-    const bad = { fault: 'not well formed' };
-    if (!OWED.every((f) => fields.has(f)))
-        return bad;
-    const to = pkOrNull(fields.get('to'), true);
-    const by = pkOrNull(fields.get('by'), false);
-    const next = pkOrNull(fields.get('next'), true);
-    const seq = fields.get('seq');
-    if (to === undefined || !by || next === undefined || !isCount(seq))
-        return bad;
-    const method = fields.get('method');
-    if (method !== undefined && !method.startsWith('"'))
-        return bad;
-    const args = fields.get('args');
-    if (args !== undefined && !args.startsWith('{'))
-        return bad;
-    return {
-        payload: {
-            to,
-            by,
-            next,
-            seq: Number(seq),
-            ...(method === undefined ? {} : { method: JSON.parse(method) }),
-            ...(args === undefined ? {} : { args }),
-        },
-    };
-};

package/dist/core/quo/relations.d.ts

@@ -1,40 +0,0 @@
-import type { Lock } from '../crypto/index.ts';
-export type Keys = {
-    readonly held: string;
-    readonly vouched: string | null;
-    readonly open: string;
-    readonly offered: string;
-};
-export type HeirRecord = {
-    readonly state: 'fresh';
-} | ({
-    readonly state: 'spent';
-    readonly highest: number;
-    readonly honoured: readonly number[];
-} & Keys) | ({
-    readonly state: 'kept';
-} & Keys);
-export type KeptLock = {
-    readonly ek: string;
-    readonly dk: string;
-};
-export interface Relations {
-    lock(): Lock | undefined;
-    setLock(lock: Lock): void;
-    get(heir: string): HeirRecord | undefined;
-    set(heir: string, record: HeirRecord): void;
-    delete(heir: string): void;
-    kept(): Promise<boolean>;
-}
-export declare const lockOf: (kept: KeptLock | undefined) => Lock | undefined;
-export declare const keptLock: (lock: Lock) => KeptLock;
-export declare const GONE = 256;
-export declare class MemoryRelations implements Relations {
-    #private;
-    lock(): Lock | undefined;
-    setLock(lock: Lock): void;
-    get(heir: string): HeirRecord | undefined;
-    set(heir: string, record: HeirRecord): void;
-    delete(heir: string): void;
-    kept(): Promise<boolean>;
-}

package/dist/core/quo/relations.js

@@ -1,33 +0,0 @@
-import { hex, unhex } from '../crypto/index.js';
-export const lockOf = (kept) => (kept ? { ek: unhex(kept.ek), dk: unhex(kept.dk) } : undefined);
-export const keptLock = (lock) => ({ ek: hex(lock.ek), dk: hex(lock.dk) });
-// A bound on the kept records of removed relations, oldest out.
-export const GONE = 256;
-export class MemoryRelations {
-    #lock;
-    #heirs = new Map();
-    #gone = [];
-    lock() {
-        return lockOf(this.#lock);
-    }
-    setLock(lock) {
-        this.#lock = keptLock(lock);
-    }
-    get(heir) {
-        return this.#heirs.get(heir);
-    }
-    set(heir, record) {
-        this.#heirs.set(heir, record);
-        if (record.state !== 'kept')
-            return;
-        this.#gone.push(heir);
-        while (this.#gone.length > GONE)
-            this.#heirs.delete(this.#gone.shift());
-    }
-    delete(heir) {
-        this.#heirs.delete(heir);
-    }
-    kept() {
-        return Promise.resolve(true);
-    }
-}

package/dist/core/quo/reply.d.ts

@@ -1,13 +0,0 @@
-export declare const WORDS: readonly ['removed', 'unannounced', 'repeated'];
-export type Word = (typeof WORDS)[number];
-export type Reply = {
-    readonly object: string;
-    readonly seen: string | null;
-} | {
-    readonly silence: true;
-} | {
-    readonly quo: Word;
-};
-export declare const SILENCE = "{\"silence\":true}";
-export declare const writeReply: (reply: Reply) => string;
-export declare const readReply: (bytes: Uint8Array) => Reply | null;