nervur 0.22.0 → 0.22.2-3

package/dist/bench/fake-network.d.ts

@@ -0,0 +1,57 @@
+import type { Hooked } from '../ground/ground.ts';
+import type { Clock } from '../foundation.ts';
+/** How one link behaves, each way: its latency in milliseconds, and the share of boxes dropped, of replies lost, and of boxes delivered twice. */
+export interface Link {
+    readonly latency?: number;
+    readonly drop?: number;
+    readonly lose?: number;
+    readonly duplicate?: number;
+}
+/** What became of one box: dropped before its door, delivered, its reply lost, or delivered twice. */
+export interface Crossing {
+    readonly from: string;
+    readonly to: string;
+    readonly ward: string;
+    readonly outcome: 'dropped' | 'answered' | 'silent' | 'lost' | 'twice';
+}
+export declare class FakeNetwork {
+    #private;
+    /** Every box that crossed between two hosts, in order. A box by pointer inside a host crosses nothing. */
+    readonly crossings: Crossing[];
+    /** `clock` is the bench's, and times every latency; `seed` draws every chance. */
+    constructor({ clock, seed }?: {
+        clock?: Clock;
+        seed?: string;
+    });
+    /** A host's carry. One that listens is dialled at its names; one that does not only dials, as a device. */
+    join(host: string, { names, listens }?: {
+        names?: readonly string[];
+        listens?: boolean;
+    }): Hooked;
+    /** A name pointed at a host, as a DNS record moved. */
+    point(name: string, host: string): void;
+    /** How the link between two hosts behaves, both ways, until it is set again. */
+    link(a: string, b: string, link: Link): void;
+    /** No box crosses from `from` to `to` until `heal`; the other way stands. */
+    cut(from: string, to: string): void;
+    /** No box crosses between the two hosts, either way, until `heal`. */
+    partition(a: string, b: string): void;
+    /** Every cut mended. Links keep how they behave. */
+    heal(): void;
+    /** The host answers nothing, its doors forgotten, until `up`. */
+    down(host: string): void;
+    up(host: string): void;
+    /** The next `count` boxes between hosts are dropped before their door. */
+    dropNext(count?: number): void;
+    /** The next `count` replies are lost after the far door answered. */
+    loseNext(count?: number): void;
+    /** The next `count` boxes are delivered twice, and the first reply returns. */
+    duplicateNext(count?: number): void;
+    /**
+     * The clock moved on by `ms` in steps of `step`, the bench settling after
+     * each, so latencies end, retries leave and replies land as time passes.
+     */
+    elapse(ms: number, { step }?: {
+        step?: number;
+    }): Promise<void>;
+}

package/dist/bench/fake-network.js

@@ -0,0 +1,169 @@
+import { stream } from './seeded.js';
+import { settle } from './settle.js';
+const SCHEME = 'bench://';
+const pair = (a, b) => [a, b].sort().join('\n');
+export class FakeNetwork {
+    #hosts = new Map();
+    #names = new Map();
+    // One-way cuts, `from` then `to`.
+    #cuts = new Set();
+    #links = new Map();
+    #clock;
+    #chance;
+    #drop = 0;
+    #lose = 0;
+    #twice = 0;
+    #waits = 0;
+    /** Every box that crossed between two hosts, in order. A box by pointer inside a host crosses nothing. */
+    crossings = [];
+    /** `clock` is the bench's, and times every latency; `seed` draws every chance. */
+    constructor({ clock, seed = 'network' } = {}) {
+        this.#clock = clock;
+        this.#chance = stream(`network:${seed}`);
+    }
+    /** A host's carry. One that listens is dialled at its names; one that does not only dials, as a device. */
+    join(host, { names = [], listens = true } = {}) {
+        const held = this.#hosts.get(host) ?? { doors: new Map(), listens, up: true };
+        this.#hosts.set(host, held);
+        for (const name of names)
+            this.#names.set(name, host);
+        return {
+            listen: ({ ward, door }) => void held.doors.set(ward, door),
+            unlisten: ({ ward }) => void held.doors.delete(ward),
+            send: (options) => this.#send(host, options),
+            at: () => (held.listens ? [...this.#names].filter(([, to]) => to === host).map(([name]) => SCHEME + name) : []),
+        };
+    }
+    /** A name pointed at a host, as a DNS record moved. */
+    point(name, host) {
+        this.#names.set(name, host);
+    }
+    /** How the link between two hosts behaves, both ways, until it is set again. */
+    link(a, b, link) {
+        if (link.latency !== undefined && link.latency > 0 && this.#clock === undefined)
+            throw new TypeError('a network with latency is made with the bench’s clock');
+        for (const share of [link.drop, link.lose, link.duplicate])
+            if (share !== undefined && !(share >= 0 && share <= 1))
+                throw new TypeError('a share is between 0 and 1');
+        this.#links.set(pair(a, b), link);
+    }
+    /** No box crosses from `from` to `to` until `heal`; the other way stands. */
+    cut(from, to) {
+        this.#cuts.add(`${from}\n${to}`);
+    }
+    /** No box crosses between the two hosts, either way, until `heal`. */
+    partition(a, b) {
+        this.cut(a, b);
+        this.cut(b, a);
+    }
+    /** Every cut mended. Links keep how they behave. */
+    heal() {
+        this.#cuts.clear();
+    }
+    /** The host answers nothing, its doors forgotten, until `up`. */
+    down(host) {
+        const held = this.#hosts.get(host);
+        if (held === undefined)
+            return;
+        held.up = false;
+        held.doors.clear();
+    }
+    up(host) {
+        const held = this.#hosts.get(host);
+        if (held !== undefined)
+            held.up = true;
+    }
+    /** The next `count` boxes between hosts are dropped before their door. */
+    dropNext(count = 1) {
+        this.#drop += count;
+    }
+    /** The next `count` replies are lost after the far door answered. */
+    loseNext(count = 1) {
+        this.#lose += count;
+    }
+    /** The next `count` boxes are delivered twice, and the first reply returns. */
+    duplicateNext(count = 1) {
+        this.#twice += count;
+    }
+    /**
+     * The clock moved on by `ms` in steps of `step`, the bench settling after
+     * each, so latencies end, retries leave and replies land as time passes.
+     */
+    async elapse(ms, { step = 1_000 } = {}) {
+        const clock = this.#clock;
+        if (clock === undefined || !('advance' in clock) || typeof clock.advance !== 'function')
+            throw new TypeError('a network elapses on the bench’s clock');
+        const advance = clock.advance.bind(clock);
+        await settle();
+        for (let left = ms; left > 0; left -= step) {
+            advance(Math.min(step, left));
+            await settle();
+        }
+    }
+    // Whether a chance of `share` comes up, drawn from the seed.
+    #roll(share) {
+        if (share === undefined || share <= 0)
+            return false;
+        const [a, b] = this.#chance(2);
+        return (a * 256 + b) / 65_536 < share;
+    }
+    async #delay(ms) {
+        if (ms === undefined || ms <= 0 || this.#clock === undefined)
+            return;
+        await this.#clock.wait({ id: `network:${++this.#waits}`, ms });
+    }
+    async #send(from, { ward, at, box }) {
+        const own = this.#hosts.get(from);
+        if (own === undefined || !own.up)
+            return { reply: null, heard: false };
+        // A ward on this host takes the box by pointer, before any address, and crosses nothing.
+        const near = own.doors.get(ward);
+        if (near !== undefined) {
+            const reply = await near(box);
+            if (reply !== null)
+                return { reply };
+        }
+        for (const address of at) {
+            if (!address.startsWith(SCHEME))
+                continue;
+            const to = this.#names.get(address.slice(SCHEME.length));
+            const host = to === undefined ? undefined : this.#hosts.get(to);
+            if (to === undefined || host === undefined || !host.up || !host.listens || this.#cuts.has(`${from}\n${to}`))
+                continue;
+            const link = this.#links.get(pair(from, to)) ?? {};
+            const log = (outcome) => this.crossings.push({ from, to, ward, outcome });
+            await this.#delay(link.latency);
+            if (this.#drop > 0 || this.#roll(link.drop)) {
+                if (this.#drop > 0)
+                    this.#drop--;
+                log('dropped');
+                continue;
+            }
+            // The door is read again after the latency: a host may have gone down, or a cut come, meanwhile.
+            const door = host.up && !this.#cuts.has(`${from}\n${to}`) ? host.doors.get(ward) : undefined;
+            if (door === undefined)
+                continue;
+            const twice = this.#twice > 0 || this.#roll(link.duplicate);
+            if (this.#twice > 0)
+                this.#twice--;
+            const reply = await door(box);
+            if (twice)
+                await door(box);
+            await this.#delay(link.latency);
+            // A reply lost after the door answered was heard, so no other address is tried.
+            if (this.#lose > 0 || this.#roll(link.lose) || this.#cuts.has(`${to}\n${from}`)) {
+                if (this.#lose > 0)
+                    this.#lose--;
+                log('lost');
+                return { reply: null, heard: true };
+            }
+            if (reply === null) {
+                log('silent');
+                continue;
+            }
+            log(twice ? 'twice' : 'answered');
+            return { reply, via: address };
+        }
+        return { reply: null, heard: false };
+    }
+}

package/dist/bench/index.d.ts

@@ -0,0 +1,11 @@
+export { Bench, Placed, type BenchOptions, type CheckOptions, type Finding } from './bench.ts';
+export { BenchGround, Machine, type BenchGroundOptions, type HouseModule } from './bench-ground.ts';
+export { FakeNetwork, type Crossing, type Link } from './fake-network.ts';
+export { settle } from './settle.ts';
+export { FakeFaculty, type Called } from './fake-faculty.ts';
+export { FakeCarry } from './fake-carry.ts';
+export { FakeCustody } from './fake-custody.ts';
+export { FakeClock } from './fake-clock.ts';
+export { FakeKeys } from './fake-keys.ts';
+export { FakeMemory } from './fake-memory.ts';
+export { covers } from '../being/covers.ts';

package/dist/bench/index.js

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: Apache-2.0
+// `nervur/bench`: what a test imports to hold a class, a faculty or a body.
+export { Bench, Placed } from './bench.js';
+export { BenchGround, Machine } from './bench-ground.js';
+export { FakeNetwork } from './fake-network.js';
+export { settle } from './settle.js';
+export { FakeFaculty } from './fake-faculty.js';
+export { FakeCarry } from './fake-carry.js';
+export { FakeCustody } from './fake-custody.js';
+export { FakeClock } from './fake-clock.js';
+export { FakeKeys } from './fake-keys.js';
+export { FakeMemory } from './fake-memory.js';
+export { covers } from '../being/covers.js';

package/dist/bench/seeded.d.ts

@@ -0,0 +1,11 @@
+import { NobleCrypto } from '../bodies/noble-crypto.ts';
+/** A stream of bytes from a name: the same name, the same bytes. */
+export declare const stream: (name: string) => (length: number) => Uint8Array;
+/** Sixty-four hex digits from a name. */
+export declare const seedOf: (name: string) => string;
+/** The default crypto, with randomness drawn from a seed. */
+export declare class SeededCrypto extends NobleCrypto {
+    #private;
+    constructor(name: string);
+    random(length: number): Uint8Array;
+}

package/dist/bench/seeded.js

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: Apache-2.0
+// What makes a bench run the same twice: bytes drawn from a seed, never
+// from the platform. They are for tests alone and guard nothing.
+import { NobleCrypto } from '../bodies/noble-crypto.js';
+/** A stream of bytes from a name: the same name, the same bytes. */
+export const stream = (name) => {
+    // FNV-1a over the name seeds xorshift32.
+    let state = 0x811c9dc5;
+    for (let at = 0; at < name.length; at++)
+        state = Math.imul(state ^ name.charCodeAt(at), 0x01000193) >>> 0;
+    if (state === 0)
+        state = 1;
+    return (length) => {
+        const out = new Uint8Array(length);
+        for (let at = 0; at < length; at++) {
+            state ^= state << 13;
+            state ^= state >>> 17;
+            state ^= state << 5;
+            state >>>= 0;
+            out[at] = state & 0xff;
+        }
+        return out;
+    };
+};
+/** Sixty-four hex digits from a name. */
+export const seedOf = (name) => Array.from(stream(`seed:${name}`)(32), (byte) => byte.toString(16).padStart(2, '0')).join('');
+/** The default crypto, with randomness drawn from a seed. */
+export class SeededCrypto extends NobleCrypto {
+    #draw;
+    constructor(name) {
+        super();
+        this.#draw = stream(`random:${name}`);
+    }
+    random(length) {
+        return this.#draw(length);
+    }
+}

package/dist/bench/settle.d.ts

@@ -0,0 +1,2 @@
+/** Every ask, effect and reply the fakes started, run to where it waits on the clock or ends. */
+export declare const settle: () => Promise<void>;

package/dist/bench/settle.js

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: Apache-2.0
+// Letting the bench go idle. The fakes do no I/O, so every ask, effect and
+// reply they started runs on the event loop, and the one thing that leaves
+// it is WebCrypto, which runs on the engine's own threads and outlasts any
+// count of turns on a loaded machine. So the bench counts WebCrypto calls
+// in flight, at `crypto.subtle` itself, the one door every body's crypto
+// passes, and calls the loop idle only once none has been in flight for a
+// run of turns. It counts in the process that imports the bench alone.
+// Turns with nothing in flight before the bench calls the loop idle: the
+// promise chains between two crypto calls resolve well within them.
+const QUIET = 20;
+// A loop that never goes idle is a fault the bench names, never a hang.
+const BOUND = 200_000;
+let inFlight = 0;
+const METHODS = ['digest', 'importKey', 'exportKey', 'deriveBits', 'deriveKey', 'encrypt', 'decrypt', 'sign', 'verify', 'generateKey', 'wrapKey', 'unwrapKey'];
+// Each method of the engine's `subtle`, counted while its promise is open. Wrapped once, however often the bench loads.
+const subtle = globalThis.crypto?.subtle;
+const COUNTED = Symbol.for('nervur.bench.counted');
+if (subtle !== undefined && subtle[COUNTED] !== true) {
+    for (const method of METHODS) {
+        const original = subtle[method];
+        if (typeof original !== 'function')
+            continue;
+        subtle[method] = (...args) => {
+            inFlight++;
+            const done = () => {
+                inFlight--;
+            };
+            const called = original.apply(globalThis.crypto.subtle, args);
+            void called.then(done, done);
+            return called;
+        };
+    }
+    subtle[COUNTED] = true;
+}
+// One turn of the event loop: an immediate where the engine has one, else the shortest timer.
+const turnOnce = typeof globalThis.setImmediate === 'function'
+    ? (next) => globalThis.setImmediate(next)
+    : (next) => setTimeout(next, 0);
+/** Every ask, effect and reply the fakes started, run to where it waits on the clock or ends. */
+export const settle = async () => {
+    let quiet = 0;
+    for (let turn = 0; quiet < QUIET; turn++) {
+        if (turn >= BOUND)
+            throw new Error('the bench never went idle: crypto stayed in flight');
+        await new Promise((next) => turnOnce(next));
+        quiet = inFlight === 0 ? quiet + 1 : 0;
+    }
+};

package/dist/bench/stewards.d.ts

@@ -0,0 +1,17 @@
+import { type Args } from '../being/index.ts';
+declare const BenchSteward_base: import("../being/being.ts").BeingClass<Record<string, never>, Record<never, never>, {}>;
+export declare class BenchSteward extends BenchSteward_base {
+}
+declare const BenchTester_base: import("../being/being.ts").BeingClass<Record<string, never>, Record<never, never>, {
+    readonly adopt: {
+        readonly for: "root";
+        readonly args: import("../being/schema.ts").Schema<{
+            invitation: import("../being/schema.ts").HandleMark;
+        }>;
+        readonly result: import("../being/schema.ts").Schema<string>;
+    };
+}>;
+export declare class BenchTester extends BenchTester_base {
+    adopt({ invitation }: Args<BenchTester, 'adopt'>): string;
+}
+export {};

package/dist/bench/stewards.js

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: Apache-2.0
+// The two stewards the bench stands on: one keeps the author's house where
+// the test brings no steward of its own, the other adopts a handle to each
+// being the bench places, in the bench's own house.
+import { Being, s } from '../being/index.js';
+export class BenchSteward extends Being.of({
+    kind: 'org.nervur.bench.steward',
+    asks: {},
+}) {
+}
+export class BenchTester extends Being.of({
+    kind: 'org.nervur.bench.tester',
+    asks: {
+        adopt: { for: 'root', args: s.object({ invitation: s.handle() }), result: s.string() },
+    },
+}) {
+    adopt({ invitation }) {
+        return invitation;
+    }
+}

package/dist/bodies/class-list.d.ts

@@ -0,0 +1,14 @@
+import type { BeingClass, Classes } from '../foundation.ts';
+export declare class ClassList implements Classes {
+    #private;
+    constructor({ steward, public: open, beings }: {
+        steward: BeingClass;
+        public?: BeingClass;
+        beings?: readonly BeingClass[];
+    });
+    resolve({ kind }: {
+        kind: string;
+    }): Promise<BeingClass | undefined>;
+    steward(): string;
+    public(): string | undefined;
+}

package/dist/bodies/class-list.js

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: Apache-2.0
+// Classes from a plain list, each kind from the one class that declares it.
+import { declarationOf } from '../being/being.js';
+export class ClassList {
+    #kinds = new Map();
+    #steward;
+    #public;
+    constructor({ steward, public: open, beings = [] }) {
+        const kindOf = (Class) => {
+            const kind = declarationOf(Class)?.kind;
+            if (typeof kind !== 'string')
+                throw new TypeError('a class in the list is not a class of Being.of');
+            const held = this.#kinds.get(kind);
+            if (held !== undefined && held !== Class)
+                throw new TypeError(`two classes claim the kind ${kind}`);
+            this.#kinds.set(kind, Class);
+            return kind;
+        };
+        this.#steward = kindOf(steward);
+        this.#public = open === undefined ? undefined : kindOf(open);
+        for (const Class of beings)
+            kindOf(Class);
+    }
+    async resolve({ kind }) {
+        return this.#kinds.get(kind);
+    }
+    steward() {
+        return this.#steward;
+    }
+    public() {
+        return this.#public;
+    }
+}

package/dist/bodies/joined-carry.d.ts

@@ -0,0 +1,23 @@
+import type { Carry, Sent } from '../foundation.ts';
+export declare class JoinedCarry implements Carry {
+    #private;
+    /** `carries` by scheme: `{ tcp: tcpCarry, https: webCarry }`. */
+    constructor(carries: Readonly<Record<string, Carry>>);
+    /** A ward's door, hooked to every carry here that listens. */
+    listen(options: {
+        ward: string;
+        door: (box: Uint8Array) => Promise<Uint8Array | null>;
+    }): Promise<void>;
+    /** A ward unhooked from every carry here that listens. */
+    unlisten(options: {
+        ward: string;
+    }): void;
+    send({ ward, at, box }: {
+        ward: string;
+        at: readonly string[];
+        box: Uint8Array;
+    }): Promise<Sent>;
+    at(options?: {
+        toward?: string;
+    }): readonly string[];
+}

package/dist/bodies/joined-carry.js

@@ -0,0 +1,42 @@
+export class JoinedCarry {
+    #carries;
+    // Each carry once, where one serves two schemes, as the web serves http and https.
+    #each;
+    /** `carries` by scheme: `{ tcp: tcpCarry, https: webCarry }`. */
+    constructor(carries) {
+        this.#carries = new Map(Object.entries(carries));
+        this.#each = [...new Set(this.#carries.values())];
+    }
+    /** A ward's door, hooked to every carry here that listens. */
+    async listen(options) {
+        for (const carry of this.#each)
+            await carry.listen?.(options);
+    }
+    /** A ward unhooked from every carry here that listens. */
+    unlisten(options) {
+        for (const carry of this.#each)
+            carry.unlisten?.(options);
+    }
+    async send({ ward, at, box }) {
+        // A carry that listens for the ward hands it the box by pointer, and no address is dialled.
+        for (const carry of this.#each) {
+            const sent = await carry.send({ ward, at: [], box });
+            if (sent.reply !== null)
+                return sent;
+        }
+        for (const address of at) {
+            // A scheme is read in any case, as a URI's is.
+            const scheme = address.slice(0, Math.max(0, address.indexOf('://'))).toLowerCase();
+            const carry = this.#carries.get(scheme);
+            if (carry === undefined)
+                continue;
+            const sent = await carry.send({ ward, at: [address], box });
+            if (sent.reply !== null || sent.heard)
+                return sent;
+        }
+        return { reply: null, heard: false };
+    }
+    at(options = {}) {
+        return this.#each.flatMap((carry) => carry.at(options));
+    }
+}

package/dist/bodies/noble-crypto.d.ts

@@ -0,0 +1,22 @@
+import type { Crypto } from '../foundation.ts';
+export declare class NobleCrypto implements Crypto {
+    random(length: number): Uint8Array;
+    sha256(data: Uint8Array): Promise<Uint8Array>;
+    hkdf(ikm: Uint8Array, info: string, length: number): Promise<Uint8Array>;
+    seal(key: Uint8Array, nonce: Uint8Array, plaintext: Uint8Array, additional: Uint8Array): Promise<Uint8Array>;
+    open(key: Uint8Array, nonce: Uint8Array, ciphertext: Uint8Array, additional: Uint8Array): Promise<Uint8Array | null>;
+    signingPublic(secret: Uint8Array): Promise<Uint8Array>;
+    sign(secret: Uint8Array, message: Uint8Array): Promise<Uint8Array>;
+    verify(pk: Uint8Array, message: Uint8Array, signature: Uint8Array): Promise<boolean>;
+    agreePublic(secret: Uint8Array): Promise<Uint8Array>;
+    agree(secret: Uint8Array, pk: Uint8Array): Promise<Uint8Array | null>;
+    lockPair(seed: Uint8Array): Promise<{
+        encapsulation: Uint8Array;
+        decapsulation: Uint8Array;
+    }>;
+    encapsulate(encapsulation: Uint8Array): Promise<{
+        ciphertext: Uint8Array;
+        shared: Uint8Array;
+    } | null>;
+    decapsulate(decapsulation: Uint8Array, ciphertext: Uint8Array): Promise<Uint8Array>;
+}

package/dist/bodies/noble-crypto.js

@@ -0,0 +1,88 @@
+// SPDX-License-Identifier: Apache-2.0
+// The default crypto: Ed25519, X25519 and ML-KEM-768 from noble, SHA-256,
+// HKDF and AES-GCM from Web Crypto.
+import { ed25519, x25519 } from '@noble/curves/ed25519.js';
+import { ml_kem768 } from '@noble/post-quantum/ml-kem.js';
+const subtle = globalThis.crypto.subtle;
+const ascii = new TextEncoder();
+const view = (bytes) => new Uint8Array(bytes);
+export class NobleCrypto {
+    random(length) {
+        const out = new Uint8Array(length);
+        for (let at = 0; at < length; at += 65_536)
+            globalThis.crypto.getRandomValues(out.subarray(at, Math.min(length, at + 65_536)));
+        return out;
+    }
+    async sha256(data) {
+        return new Uint8Array(await subtle.digest('SHA-256', view(data)));
+    }
+    async hkdf(ikm, info, length) {
+        const key = await subtle.importKey('raw', view(ikm), 'HKDF', false, ['deriveBits']);
+        const bits = await subtle.deriveBits({ name: 'HKDF', hash: 'SHA-256', salt: new Uint8Array(0), info: ascii.encode(info) }, key, length * 8);
+        return new Uint8Array(bits);
+    }
+    async seal(key, nonce, plaintext, additional) {
+        const aes = await subtle.importKey('raw', view(key), 'AES-GCM', false, ['encrypt']);
+        return new Uint8Array(await subtle.encrypt({ name: 'AES-GCM', iv: view(nonce), additionalData: view(additional) }, aes, view(plaintext)));
+    }
+    async open(key, nonce, ciphertext, additional) {
+        if (ciphertext.length < 16)
+            return null;
+        const aes = await subtle.importKey('raw', view(key), 'AES-GCM', false, ['decrypt']);
+        try {
+            return new Uint8Array(await subtle.decrypt({ name: 'AES-GCM', iv: view(nonce), additionalData: view(additional) }, aes, view(ciphertext)));
+        }
+        catch {
+            return null;
+        }
+    }
+    async signingPublic(secret) {
+        return ed25519.getPublicKey(secret);
+    }
+    async sign(secret, message) {
+        return ed25519.sign(message, secret);
+    }
+    async verify(pk, message, signature) {
+        if (pk.length !== 32 || signature.length !== 64)
+            return false;
+        try {
+            // Strict decoding refuses a y at or above the prime and a non-canonical R.
+            if (ed25519.Point.fromBytes(pk, false).isSmallOrder())
+                return false;
+            return ed25519.verify(signature, message, pk, { zip215: false });
+        }
+        catch {
+            return false;
+        }
+    }
+    async agreePublic(secret) {
+        return x25519.getPublicKey(secret);
+    }
+    async agree(secret, pk) {
+        if (pk.length !== 32)
+            return null;
+        try {
+            const shared = x25519.getSharedSecret(secret, pk);
+            return shared.every((byte) => byte === 0) ? null : shared;
+        }
+        catch {
+            return null;
+        }
+    }
+    async lockPair(seed) {
+        const { publicKey, secretKey } = ml_kem768.keygen(seed);
+        return { encapsulation: publicKey, decapsulation: secretKey };
+    }
+    async encapsulate(encapsulation) {
+        try {
+            const { cipherText, sharedSecret } = ml_kem768.encapsulate(encapsulation);
+            return { ciphertext: cipherText, shared: sharedSecret };
+        }
+        catch {
+            return null;
+        }
+    }
+    async decapsulate(decapsulation, ciphertext) {
+        return ml_kem768.decapsulate(ciphertext, decapsulation);
+    }
+}

package/dist/bodies/seed-keys.d.ts

@@ -0,0 +1,10 @@
+import type { Crypto, Keys, WardKeys } from '../foundation.ts';
+export declare class SeedKeys implements Keys {
+    #private;
+    constructor(seed: string | undefined, crypto?: Crypto);
+    ward(): Promise<WardKeys>;
+    sign(message: Uint8Array): Promise<Uint8Array>;
+    agree(pk: Uint8Array): Promise<Uint8Array | null>;
+    decapsulate(ciphertext: Uint8Array): Promise<Uint8Array>;
+    derive(label: string, length: number): Promise<Uint8Array>;
+}