nervur 0.21.4 → 0.22.0

package/dist/tcp/frame.js

@@ -1,64 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// The frames of Quo over TCP, `quo/CARRIER-TCP.md`:
-//
-//   frame = length (4, big-endian) || kind (1) || id (4, big-endian) || rest
-//   00 ask      rest = ward pk (64) || box
-//   01 reply    rest = box
-//   02 nothing  rest = empty
-//
-// A reader says a stream is not a frame as soon as its bytes say so, and
-// reads nothing after it.
-import { concat } from '../crypto/index.js';
-export const ASK = 0;
-export const REPLY = 1;
-export const NOTHING = 2;
-export const MAX_BODY = 1_048_645;
-const PK = 64;
-const frame = (kind, id, ...rest) => {
-    const head = new Uint8Array(9);
-    const view = new DataView(head.buffer);
-    view.setUint32(0, 5 + rest.reduce((n, r) => n + r.length, 0));
-    head[4] = kind;
-    view.setUint32(5, id >>> 0);
-    return concat(head, ...rest);
-};
-export const askFrame = (id, pk, box) => frame(ASK, id, pk, box);
-export const replyFrame = (id, box) => frame(REPLY, id, box);
-export const nothingFrame = (id) => frame(NOTHING, id);
-// Whether a body of this length, and this first byte when known, is no frame.
-const notAFrame = (length, kind) => length > MAX_BODY || length < 5 || (kind !== undefined && (kind > NOTHING || (kind === ASK && length < 5 + PK) || (kind === NOTHING && length !== 5)));
-export class FrameReader {
-    #buffer = new Uint8Array(0);
-    #bad = false;
-    // True once bytes that are not a frame arrived; nothing is read after.
-    get bad() {
-        return this.#bad;
-    }
-    push(chunk) {
-        if (this.#bad)
-            return [];
-        this.#buffer = this.#buffer.length === 0 ? chunk.slice() : concat(this.#buffer, chunk);
-        const out = [];
-        while (this.#buffer.length >= 4) {
-            const view = new DataView(this.#buffer.buffer, this.#buffer.byteOffset);
-            const length = view.getUint32(0);
-            if (notAFrame(length, this.#buffer.length > 4 ? this.#buffer[4] : undefined)) {
-                this.#bad = true;
-                this.#buffer = new Uint8Array(0);
-                return out;
-            }
-            if (this.#buffer.length < 4 + length)
-                break;
-            const body = this.#buffer.subarray(4, 4 + length);
-            this.#buffer = this.#buffer.slice(4 + length);
-            const id = new DataView(body.buffer, body.byteOffset).getUint32(1);
-            if (body[0] === ASK)
-                out.push({ kind: 'ask', id, pk: body.slice(5, 5 + PK), box: body.slice(5 + PK) });
-            else if (body[0] === REPLY)
-                out.push({ kind: 'reply', id, box: body.slice(5) });
-            else
-                out.push({ kind: 'nothing', id });
-        }
-        return out;
-    }
-}

package/dist/ward/index.d.ts

@@ -1,6 +0,0 @@
-export { allow, CEILING, DEFAULT } from './allowance.ts';
-export { HEAD_ROW, Partition, type BeingRow, type Head, type StandingRow } from './partition.ts';
-export { DEPTH } from './stance.ts';
-export { DOCK, Ward, type Catalogue, type Lender, type Routes, type WardParts } from './ward.ts';
-export { ownerAsk, PILOT, pilots, rootAsk, WardBeing, type Steward, type WardBeingStance } from './ward-being.ts';
-export { Pilot } from './pilot.ts';

package/dist/ward/index.js

@@ -1,8 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// The ward: its partition, its stances, its ward-being, and the ward.
-export { allow, CEILING, DEFAULT } from './allowance.js';
-export { HEAD_ROW, Partition } from './partition.js';
-export { DEPTH } from './stance.js';
-export { DOCK, Ward } from './ward.js';
-export { ownerAsk, PILOT, pilots, rootAsk, WardBeing } from './ward-being.js';
-export { Pilot } from './pilot.js';

package/dist/ward/pilot.d.ts

@@ -1,8 +0,0 @@
-import { Being, type AskSpec, type JsonObject } from '../being/index.ts';
-export declare class Pilot extends Being {
-    static readonly kind: string;
-    static asks: Record<string, AskSpec>;
-    hold(args: JsonObject): Promise<JsonObject>;
-    pilot(args: JsonObject): Promise<JsonObject>;
-    drop(): JsonObject;
-}

package/dist/ward/pilot.js

@@ -1,50 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// The pilot: a kit being that holds an owner's relation on another ward's
-// ward-being, so whoever pilots her ward pilots that ward from afar. The
-// relation is an ordinary standing, kept in her ward's partition, so it
-// moves its keys and survives a restart like any other.
-//
-//   hold   { invitation }        the owner invitation taken, under `far`
-//   pilot  { method?, args? }    the far ward-being asked, as its owner
-//   drop                         the relation let go
-//
-// She is the kit's, of kind `org.nervur.pilot`, and answers whoever pilots
-// her own ward alone.
-import { Being, isSilence, isWord, told } from '../being/index.js';
-import { readInvitation } from '../quo/index.js';
-import { ownerAsk, PILOT } from './ward-being.js';
-// The standing id the far ward-being is held under.
-const FAR = 'far';
-const object = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
-export class Pilot extends Being {
-    static kind = PILOT;
-    static asks = {
-        hold: ownerAsk('an owner invitation on a far ward, held from now on', { required: ['invitation'] }),
-        pilot: ownerAsk('the far ward-being, asked as its owner'),
-        drop: ownerAsk('the far ward let go'),
-    };
-    async hold(args) {
-        const invitation = readInvitation(args.invitation);
-        if (invitation === null)
-            return { error: 'no invitation' };
-        if (this.stance.standings.get(FAR))
-            return { error: 'a ward is held' };
-        return (await this.stance.standings.take(FAR, invitation)) === null ? { error: 'not taken' } : { held: invitation.ward };
-    }
-    async pilot(args) {
-        if ((args.method !== undefined && typeof args.method !== 'string') || (args.args !== undefined && !object(args.args)))
-            return { error: 'method is text, args an object' };
-        const standing = this.stance.standings.get(FAR);
-        if (!standing)
-            return { error: 'no ward is held' };
-        const out = await standing.ask(args.method, args.args ?? {});
-        if (isSilence(out))
-            return { error: 'silence' };
-        if (isWord(out))
-            return { error: told(out) };
-        return { answer: out };
-    }
-    drop() {
-        return this.stance.standings.remove(FAR) ? { dropped: true } : { error: 'no ward is held' };
-    }
-}

package/dist/ward/ward-being.js

@@ -1,82 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// The ward-being: the first being of every ward, the ward itself. Her asks
-// are the root's, shown and answered to `OWNER` alone.
-import { Being, isSilence, isWord, KIT, OWNER, told } from '../being/index.js';
-// Whoever pilots a ward: the root, holding its unsealed ask, or an owner,
-// an occupant of the ward-being the root invited as one.
-export const pilots = (asker, notes) => asker.id === OWNER || notes?.owner === true;
-// An ask whoever pilots the ward may make.
-export const ownerAsk = (description, input = {}) => ({ description, input: { type: 'object', ...input }, for: pilots });
-// An ask the root alone may make, so a carried key pilots but never hands
-// piloting on.
-export const rootAsk = (description, input = {}) => ({ description, input: { type: 'object', ...input }, for: (asker) => asker.id === OWNER });
-// The one kit kind the root boots: every other kit class stands where the
-// kit puts it.
-export const PILOT = 'org.nervur.pilot';
-const text = (v) => typeof v === 'string';
-const object = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
-export class WardBeing extends Being {
-    static kind = 'org.nervur.ward-being';
-    static asks = {
-        boot: ownerAsk('a new being of this ward', { required: ['key', 'class'] }),
-        unboot: ownerAsk('a being out, with every relation she holds', { required: ['being'] }),
-        public: ownerAsk('the being a stranger reaches, or none', { required: ['key'] }),
-        invite: ownerAsk('an invitation on a being of this ward', { required: ['being', 'id'] }),
-        ask: ownerAsk('a being of this ward, asked as the owner; with no being, the public being asked as nobody'),
-        own: rootAsk('an invitation for an owner of this ward, under an id', { required: ['id'] }),
-        disown: rootAsk('an owner no more', { required: ['id'] }),
-    };
-    steward;
-    constructor(stance) {
-        super(stance);
-        this.steward = stance.steward;
-    }
-    describe(asker) {
-        const { asks } = super.describe(asker);
-        return { asks, notes: pilots(asker, this.notes(asker)) ? { pk: this.steward.pk(), beings: this.steward.beings() } : {} };
-    }
-    async own(args) {
-        if (!text(args.id))
-            return { error: 'id is text' };
-        return (await this.stance.occupants.invite(args.id, { owner: true })) ?? { error: 'id taken' };
-    }
-    disown(args) {
-        if (!text(args.id) || this.stance.occupants.notes(args.id)?.owner !== true)
-            return { error: 'no such owner' };
-        this.stance.occupants.remove(args.id);
-        return { disowned: args.id };
-    }
-    async boot(args) {
-        if (!text(args.key) || !text(args.class))
-            return { error: 'key and class are text' };
-        if (args.class.startsWith(KIT) && args.class !== PILOT)
-            return { error: 'no such class' };
-        const out = await this.steward.boot(args.key, args.class);
-        return out === 'booted' ? { booted: args.key } : { error: out };
-    }
-    unboot(args) {
-        return text(args.being) && this.steward.unboot(args.being) ? { unbooted: args.being } : { error: 'no such being' };
-    }
-    public(args) {
-        if (args.key !== null && !text(args.key))
-            return { error: 'key is text or null' };
-        return this.steward.publish(args.key) ? { public: args.key } : { error: 'no such being' };
-    }
-    async invite(args) {
-        if (!text(args.being) || !text(args.id) || (args.notes !== undefined && !object(args.notes)))
-            return { error: 'being and id are text, notes an object' };
-        const invitation = await this.steward.invite(args.being, args.id, args.notes ?? {});
-        return invitation ?? { error: 'not invited' };
-    }
-    async ask(args) {
-        if ((args.being !== undefined && !text(args.being)) || (args.method !== undefined && !text(args.method)) || (args.args !== undefined && !object(args.args))) {
-            return { error: 'being and method are text, args an object' };
-        }
-        const out = await this.steward.ask(args.being ?? null, args.method, args.args ?? {});
-        if (isSilence(out))
-            return { error: 'silence' };
-        if (isWord(out))
-            return { error: told(out) };
-        return { answer: out };
-    }
-}

package/dist/ward/ward.js

@@ -1,290 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// The ward: one door, one partition, and the beings behind the door. It
-// unpacks from its seed, its memory and a catalogue of classes, the
-// ward-being first and every other being from her own row, and it stands
-// what is behind its door for `quo/`.
-import { readValue, writeValue } from '../crypto/index.js';
-import { Door, readInvitation, WardKey } from '../quo/index.js';
-import { digest, isSilence, isWord, kindOf, OWNER, silence, WARD, word } from '../being/index.js';
-import { Partition, PartitionRelations } from './partition.js';
-import { DEPTH, WardStance } from './stance.js';
-import { WardBeing } from './ward-being.js';
-// The standing every hosted ward's ward-being holds on the dock.
-export const DOCK = 'dock';
-const lends = (being) => typeof being.offer === 'function';
-class RootStance extends WardStance {
-    steward;
-    constructor(inside, row, steward) {
-        super(inside, WARD, row);
-        this.steward = steward;
-    }
-}
-export class Ward {
-    key;
-    partition;
-    door;
-    clock;
-    #parts;
-    #residents = new Map();
-    #birthing = new Set();
-    constructor(parts, key) {
-        this.#parts = parts;
-        this.key = key;
-        this.clock = parts.clock;
-        this.partition = new Partition(parts.memory);
-        this.door = new Door(key, new PartitionRelations(this.partition), this, parts.entropy.drawer);
-    }
-    // The ward-being first, then every being her row names. A class the
-    // catalogue lacks, or one that throws, leaves that being absent and her
-    // row as it was.
-    static async unpack(parts) {
-        const ward = new Ward(parts, await WardKey.from(parts.seed));
-        if (!ward.partition.being(WARD)) {
-            ward.partition.beings[WARD] = { class: '', cells: {}, occupants: {}, standings: {} };
-            ward.partition.told(WARD);
-            ward.partition.toldHead();
-        }
-        const own = ward.partition.being(WARD);
-        const stance = new RootStance(ward, own, ward.#steward);
-        const being = parts.root ? parts.root(stance) : new WardBeing(stance);
-        own.class = kindOf(being.constructor);
-        ward.#residents.set(WARD, { being, row: own, stance });
-        // The standing on the dock is kept at once: its heir is spent, so a
-        // restart before the ward's first keep would find no way back.
-        if (parts.dock && !Object.hasOwn(own.standings, DOCK) && (await stance.standings.take(DOCK, parts.dock)) !== null && !(await ward.partition.kept())) {
-            throw new Error('the standing on the dock was not kept');
-        }
-        for (const [key, row] of Object.entries(ward.partition.beings)) {
-            const C = key === WARD ? undefined : parts.catalogue.classOf(row.class);
-            if (C)
-                ward.#bear(key, row, C);
-        }
-        return ward;
-    }
-    get pk() {
-        return this.key.pk;
-    }
-    get draw() {
-        return this.#parts.entropy.drawer;
-    }
-    get wardBeing() {
-        return this.#residents.get(WARD).being;
-    }
-    // The being standing under a key, for the harbor's own faculties.
-    being(key) {
-        return this.#residents.get(key)?.being;
-    }
-    // Every being her row names, of the class the catalogue now resolves for
-    // her kind: an absent being is born, and one whose class a module
-    // replaced is born again of the new class on the stance she holds, so
-    // her relations and their lanes stay hers. A new class that throws at
-    // birth leaves her as she was.
-    bearAnew() {
-        for (const [key, row] of Object.entries(this.partition.beings)) {
-            const C = key === WARD ? undefined : this.#parts.catalogue.classOf(row.class);
-            const resident = this.#residents.get(key);
-            if (!C || resident?.being.constructor === C)
-                continue;
-            if (!resident) {
-                this.#bear(key, row, C);
-                continue;
-            }
-            try {
-                resident.being = new C(resident.stance);
-            }
-            catch {
-                continue;
-            }
-        }
-    }
-    // The unsealed ask: the ward-being, asked by whoever holds this ward.
-    // It reaches every being of the ward through the ward-being, so every
-    // row is put back where the memory refuses.
-    async root(method, args = {}) {
-        return this.#kept(Object.keys(this.partition.beings), () => this.#answer(WARD, { id: OWNER }, method, args));
-    }
-    // An answer, kept. Where the memory refuses, what the beings wrote is put
-    // back and the answer is silence. What their relations stand on is not
-    // put back: a relation's keys move only as far as its standing follows.
-    async #kept(keys, work) {
-        const before = keys.flatMap((key) => {
-            const row = this.partition.being(key);
-            return row ? [[key, row.cells, JSON.stringify(row.cells)]] : [];
-        });
-        const out = await work();
-        if (await this.partition.kept())
-            return out;
-        for (const [key, cells, was] of before) {
-            if (JSON.stringify(cells) === was)
-                continue;
-            for (const k of Object.keys(cells))
-                delete cells[k];
-            for (const [k, v] of Object.entries(JSON.parse(was)))
-                Object.defineProperty(cells, k, { value: v, enumerable: true, writable: true, configurable: true });
-            this.partition.told(key);
-        }
-        return silence;
-    }
-    // Behind: the zero head reaches the public being, an heir the being that
-    // invited it.
-    get zero() {
-        const key = this.partition.head.public;
-        return key !== null && this.#residents.has(key);
-    }
-    async answer(heir, p) {
-        const bound = heir === null ? undefined : this.partition.head.bind[heir];
-        const key = heir === null ? this.partition.head.public : bound?.being;
-        const asker = bound ? { id: bound.id } : {};
-        const args = p.args === undefined ? {} : readValue(p.args, DEPTH + 1);
-        if (key === null || key === undefined || typeof args !== 'object' || args === null || Array.isArray(args))
-            return { silence: true };
-        const out = await this.#kept([key], () => this.#answer(key, asker, p.method, args));
-        const object = isSilence(out) || isWord(out) ? undefined : writeValue(out, DEPTH);
-        if (object === undefined)
-            return { silence: true };
-        const being = this.#residents.get(key)?.being;
-        const seen = p.method === undefined || !being?.describe ? null : await digest(being.describe(asker));
-        return { object, seen };
-    }
-    // Every path that reaches a being's answer. A throw, a word out of her,
-    // or nothing at all is silence.
-    async #answer(key, asker, method, args) {
-        const resident = this.#residents.get(key);
-        if (!resident)
-            return silence;
-        let out;
-        try {
-            out = await resident.being.answer(asker, method, args);
-        }
-        catch {
-            return silence;
-        }
-        return out === undefined || isWord(out) ? silence : out;
-    }
-    // Inside: what every stance of this ward stands on.
-    // One path through a door for every ask, this ward's own included.
-    async send(pk, bytes) {
-        if (pk === this.pk)
-            return (await this.door.arrive(bytes)).bytes;
-        return this.#parts.carrier.carry(pk, bytes);
-    }
-    // A lend: the ward-being lends herself, as the dock does, or asks the dock
-    // through her standing.
-    async offer(contract) {
-        const own = this.#residents.get(WARD);
-        if (lends(own.being))
-            return own.being.offer(contract);
-        const out = await own.stance.standings.get(DOCK)?.ask('lend', { contract });
-        return readInvitation(out?.invitation);
-    }
-    async retract(contract, heir) {
-        const own = this.#residents.get(WARD);
-        if (lends(own.being))
-            return own.being.withdraw(contract, heir);
-        await own.stance.standings.get(DOCK)?.ask('retract', { contract, heir });
-    }
-    reach() {
-        return this.#parts.routes?.reach() ?? [];
-    }
-    learn(ward, at) {
-        return this.#parts.routes?.learn(ward, at) ?? Promise.resolve();
-    }
-    live(key, row) {
-        return this.#residents.get(key)?.row === row;
-    }
-    // A being boots another of this ward. With an id, the new being invites
-    // her maker under the maker's key, and the maker takes it under id; a
-    // relation that could not be made unmakes the new being.
-    async boot(maker, className, key, id) {
-        if ((await this.#make(key, className)) !== 'booted')
-            return null;
-        if (id === undefined)
-            return key;
-        const invitation = await this.#residents.get(key).stance.occupants.invite(maker);
-        const taken = invitation ? await this.#residents.get(maker)?.stance.standings.take(id, invitation) : null;
-        if (taken)
-            return key;
-        this.#unboot(key);
-        return null;
-    }
-    async #make(key, className) {
-        if (key === '' || key === WARD || this.partition.being(key) || this.#birthing.has(key))
-            return 'key taken';
-        const C = this.#parts.catalogue.classOf(className);
-        if (!C)
-            return 'no such class';
-        this.#birthing.add(key);
-        try {
-            const row = { class: className, cells: {}, occupants: {}, standings: {} };
-            this.partition.beings[key] = row;
-            if (!this.#bear(key, row, C)) {
-                delete this.partition.beings[key];
-                return 'threw at birth';
-            }
-            this.partition.told(key);
-            return 'booted';
-        }
-        finally {
-            this.#birthing.delete(key);
-        }
-    }
-    #bear(key, row, C) {
-        const stance = new WardStance(this, key, row);
-        try {
-            this.#residents.set(key, { being: new C(stance), row, stance });
-            return true;
-        }
-        catch {
-            this.#residents.delete(key);
-            return false;
-        }
-    }
-    #unboot(key) {
-        const row = key === WARD ? undefined : this.partition.being(key);
-        if (!row)
-            return false;
-        for (const { heir } of Object.values(row.occupants)) {
-            this.door.remove(heir);
-            delete this.partition.head.bind[heir];
-        }
-        if (this.partition.head.public === key)
-            this.partition.head.public = null;
-        delete this.partition.beings[key];
-        this.#residents.delete(key);
-        this.partition.toldHead();
-        this.partition.told(key);
-        return true;
-    }
-    // What the ward-being asks of her ward.
-    #steward = {
-        pk: () => this.pk,
-        classOf: (name) => this.#parts.catalogue.classOf(name),
-        beings: () => {
-            const out = {};
-            for (const [key, row] of Object.entries(this.partition.beings)) {
-                if (key !== WARD)
-                    out[key] = { class: row.class, public: this.partition.head.public === key, absent: !this.#residents.has(key) };
-            }
-            return out;
-        },
-        boot: (key, className) => this.#make(key, className),
-        unboot: (key) => this.#unboot(key),
-        publish: (key) => {
-            if (key !== null && (key === WARD || !this.partition.being(key)))
-                return false;
-            this.partition.head.public = key;
-            this.partition.toldHead();
-            return true;
-        },
-        invite: (being, id, notes) => {
-            const resident = being === WARD ? undefined : this.#residents.get(being);
-            return resident ? resident.stance.occupants.invite(id, notes) : Promise.resolve(null);
-        },
-        ask: (being, method, args) => {
-            const key = being ?? this.partition.head.public;
-            if (key === null || key === WARD)
-                return Promise.resolve(word('unreached'));
-            return this.#answer(key, being === null ? {} : { id: OWNER }, method, args);
-        },
-    };
-}

package/src/cli/main.ts

@@ -1,13 +0,0 @@
-#!/usr/bin/env node
-// SPDX-License-Identifier: Apache-2.0
-// The `nervur` program: `command.ts` over this process's arguments. A
-// command that cannot run exits 2 and says why on stderr.
-import { main, SERVING } from './command.ts';
-
-try {
-  const code = await main(process.argv.slice(2), process.env, (line) => process.stdout.write(`${line}\n`));
-  if (code !== SERVING) process.exitCode = code;
-} catch (e) {
-  process.stderr.write(`nervur: ${(e as Error).message}\n`);
-  process.exitCode = 2;
-}

package/src/crypto/subtle.ts

@@ -1,33 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// Web Crypto, read at every use. A page on a plain http origin has `crypto`
-// without `subtle`, and a terrain may install it after this module loads.
-export const subtle = (): SubtleCrypto => {
-  const found = globalThis.crypto?.subtle;
-  if (!found) throw new Error('this terrain has no crypto.subtle: a ward needs a secure context');
-  return found;
-};
-
-export type Bytes = Uint8Array<ArrayBuffer>;
-
-// Web Crypto takes a buffer it owns, so every input is copied into one.
-export const own = (bytes: Uint8Array): Bytes => Uint8Array.from(bytes);
-
-// The PKCS#8 wrapping of a thirty-two byte secret, which is the whole of it
-// for both curves.
-const PKCS8 = { Ed25519: '302e020100300506032b657004220420', X25519: '302e020100300506032b656e04220420' } as const;
-
-export const importSecret = (curve: keyof typeof PKCS8, secret: Uint8Array, uses: KeyUsage[]): Promise<CryptoKey> => {
-  if (secret.length !== 32) throw new TypeError('a secret is thirty-two bytes');
-  const prefix = Uint8Array.from(PKCS8[curve].match(/../g)!, (b) => parseInt(b, 16));
-  const wrapped = new Uint8Array(48);
-  wrapped.set(prefix);
-  wrapped.set(secret, 16);
-  return subtle().importKey('pkcs8', wrapped, { name: curve }, true, uses);
-};
-
-// Web Crypto gives a private key's public half only through a JWK.
-export const publicOf = async (key: CryptoKey): Promise<Uint8Array> => {
-  const { x } = await subtle().exportKey('jwk', key);
-  const binary = atob(x!.replaceAll('-', '+').replaceAll('_', '/'));
-  return Uint8Array.from(binary, (c) => c.charCodeAt(0));
-};

package/src/crypto/x25519.ts

@@ -1,21 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// X25519 agrees. A secret is thirty-two bytes, clamped by the function and
-// never before.
-import { zero } from './bytes.ts';
-import { importSecret, own, publicOf, subtle } from './subtle.ts';
-
-export const x25519Public = async (secret: Uint8Array): Promise<Uint8Array> => publicOf(await importSecret('X25519', secret, ['deriveBits']));
-
-// The agreement, or null for a public key that takes no seal: one whose
-// agreement is thirty-two zero bytes, or one the terrain refuses to read.
-export const agree = async (secret: Uint8Array, pk: Uint8Array): Promise<Uint8Array | null> => {
-  if (pk.length !== 32) return null;
-  try {
-    const mine = await importSecret('X25519', secret, ['deriveBits']);
-    const theirs = await subtle().importKey('raw', own(pk), { name: 'X25519' }, false, []);
-    const shared = new Uint8Array(await subtle().deriveBits({ name: 'X25519', public: theirs }, mine, 256));
-    return zero(shared) ? null : shared;
-  } catch {
-    return null;
-  }
-};