@dispatch-foo/protocol 0.0.0 → 0.2.0

package/dist/federation/index.js

@@ -0,0 +1,628 @@
+import { createCipheriv, createDecipheriv, createHash, createHmac, createPrivateKey, createPublicKey, diffieHellman, generateKeyPairSync, randomBytes, sign, verify } from "node:crypto";
+
+//#region src/federation/hlc.ts
+const MAX_HLC_COUNTER = 999999999;
+const HLC = /^(\d{13})\.(\d{4,9})\.(.+)$/;
+function parseOpHlc(hlc) {
+	const m = HLC.exec(hlc);
+	if (m === null) return null;
+	return {
+		ms: Number(m[1]),
+		counter: Number(m[2]),
+		replica: m[3] ?? ""
+	};
+}
+function compareHlc(a, b) {
+	if (a.ms !== b.ms) return a.ms < b.ms ? -1 : 1;
+	if (a.counter !== b.counter) return a.counter < b.counter ? -1 : 1;
+	return 0;
+}
+const MAX_CLOCK_LEAD_MS = 300 * 1e3;
+/** Whether a reading's wall time is past the bound for the wall time `nowMs`. */
+function aheadOfClock(hlc, nowMs) {
+	const clock = readClamped(hlc);
+	return clock !== null && clock.ms > nowMs + MAX_CLOCK_LEAD_MS;
+}
+function hlcWallMs(hlc) {
+	return parseOpHlc(hlc)?.ms ?? null;
+}
+function readClamped(hlc) {
+	const m = /^(\d{13})\.(\d{4,})\./.exec(hlc);
+	if (m === null) return null;
+	return {
+		ms: Number(m[1]),
+		counter: Math.min(Number(m[2]), MAX_HLC_COUNTER)
+	};
+}
+var OpClock = class {
+	ms;
+	counter;
+	constructor(replica, last = null, now = Date.now) {
+		this.replica = replica;
+		this.now = now;
+		const start = last === null ? null : readClamped(last);
+		this.ms = start?.ms ?? 0;
+		this.counter = start?.counter ?? 0;
+	}
+	/** A reading for a change made now, after every reading seen so far. */
+	tick() {
+		const wall = this.now();
+		if (wall > this.ms) {
+			this.ms = wall;
+			this.counter = 0;
+		} else if (this.counter < MAX_HLC_COUNTER) this.counter += 1;
+		else {
+			this.ms += 1;
+			this.counter = 0;
+		}
+		return this.last;
+	}
+	/** Moves past a reading from elsewhere, so the next tick sorts after it,
+	*  unless it is past the bound (FW-R21); false when it refused. */
+	observe(remote) {
+		const clock = readClamped(remote);
+		if (clock === null) return true;
+		if (clock.ms > this.now() + MAX_CLOCK_LEAD_MS) return false;
+		if (clock.ms > this.ms || clock.ms === this.ms && clock.counter > this.counter) {
+			this.ms = clock.ms;
+			this.counter = clock.counter;
+		}
+		return true;
+	}
+	/** The latest reading, for persisting across restarts. */
+	get last() {
+		return `${String(this.ms).padStart(13, "0")}.${String(this.counter).padStart(4, "0")}.${this.replica}`;
+	}
+};
+
+//#endregion
+//#region src/federation/jcs.ts
+var CanonicalizeError = class extends TypeError {
+	name = "CanonicalizeError";
+};
+const MAX_JSON_DEPTH = 256;
+const LONE_SURROGATE = /\p{Cs}/u;
+function iJsonString(s) {
+	if (LONE_SURROGATE.test(s)) throw new CanonicalizeError("JCS refuses a lone surrogate");
+	return JSON.stringify(s);
+}
+function write(value, str, depth) {
+	if (value === null) return "null";
+	switch (typeof value) {
+		case "boolean": return value ? "true" : "false";
+		case "number":
+			if (!Number.isFinite(value)) throw new CanonicalizeError("JCS refuses non-finite numbers");
+			return JSON.stringify(value);
+		case "string": return str(value);
+		case "object": {
+			if (depth >= MAX_JSON_DEPTH) throw new CanonicalizeError(`JCS refuses nesting past ${MAX_JSON_DEPTH}`);
+			const inner = depth + 1;
+			if (Array.isArray(value)) return `[${value.map((v) => write(v === void 0 ? null : v, str, inner)).join(",")}]`;
+			const obj = value;
+			return `{${Object.keys(obj).filter((k) => obj[k] !== void 0).sort().map((k) => `${str(k)}:${write(obj[k], str, inner)}`).join(",")}}`;
+		}
+		default: throw new CanonicalizeError(`JCS cannot serialize a ${typeof value}`);
+	}
+}
+function canonicalize(value) {
+	return write(value, iJsonString, 0);
+}
+function canonicalizeLenient(value) {
+	return write(value, JSON.stringify, 0);
+}
+
+//#endregion
+//#region src/federation/encoding.ts
+const B64U = /^[A-Za-z0-9_-]*$/;
+const CROCKFORD = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+function b64u(bytes) {
+	return Buffer.from(bytes).toString("base64url");
+}
+function fromB64u(text) {
+	if (!B64U.test(text)) throw new TypeError("not base64url");
+	const bytes = Buffer.from(text, "base64url");
+	if (b64u(bytes) !== text) throw new TypeError("not canonical base64url");
+	return bytes;
+}
+function sha256Hex(data) {
+	return createHash("sha256").update(data).digest("hex");
+}
+function crockford32(bytes) {
+	let out = "";
+	let buffer = 0;
+	let bits = 0;
+	for (const byte of bytes) {
+		buffer = (buffer << 8 | byte) & 65535;
+		bits += 8;
+		while (bits >= 5) {
+			out += CROCKFORD.charAt(buffer >>> bits - 5 & 31);
+			bits -= 5;
+		}
+	}
+	if (bits > 0) out += CROCKFORD.charAt(buffer << 5 - bits & 31);
+	return out;
+}
+
+//#endregion
+//#region src/federation/keys.ts
+const ED25519_PKCS8 = Buffer.from("302e020100300506032b657004220420", "hex");
+const FIELD_PRIME$1 = 2n ** 255n - 19n;
+const ORDER_8_Y = 2707385501144840649318225287225658788936804267575313519463743609750303402022n;
+const SMALL_ORDER_Y = new Set([
+	0n,
+	1n,
+	FIELD_PRIME$1 - 1n,
+	ORDER_8_Y,
+	FIELD_PRIME$1 - ORDER_8_Y
+]);
+function hasSmallOrder(raw) {
+	let y = 0n;
+	for (let i = raw.length - 1; i >= 0; i--) y = y << 8n | BigInt(raw[i] ?? 0);
+	return SMALL_ORDER_Y.has((y & (1n << 255n) - 1n) % FIELD_PRIME$1);
+}
+function rawPublic(key) {
+	const jwk = key.export({ format: "jwk" });
+	if (typeof jwk.x !== "string") throw new Error("expected an OKP public key");
+	return jwk.x;
+}
+function generateReplicaKeys() {
+	const s = generateKeyPairSync("ed25519");
+	const x = generateKeyPairSync("x25519");
+	return {
+		signPriv: s.privateKey.export({
+			type: "pkcs8",
+			format: "der"
+		}).toString("base64url"),
+		signPub: rawPublic(s.publicKey),
+		sealPriv: x.privateKey.export({
+			type: "pkcs8",
+			format: "der"
+		}).toString("base64url"),
+		sealPub: rawPublic(x.publicKey)
+	};
+}
+function ed25519FromSeed(seed) {
+	const der = Buffer.concat([ED25519_PKCS8, Buffer.from(seed)]);
+	const key = createPrivateKey({
+		key: der,
+		format: "der",
+		type: "pkcs8"
+	});
+	return {
+		signPriv: der.toString("base64url"),
+		signPub: rawPublic(createPublicKey(key))
+	};
+}
+function privateKeyOf(der) {
+	return createPrivateKey({
+		key: fromB64u(der),
+		format: "der",
+		type: "pkcs8"
+	});
+}
+function publicKeyOf(raw, crv) {
+	return createPublicKey({
+		key: {
+			kty: "OKP",
+			crv,
+			x: raw
+		},
+		format: "jwk"
+	});
+}
+function publicOfPrivate(der) {
+	return rawPublic(createPublicKey(privateKeyOf(der)));
+}
+function signText(signPriv, text) {
+	return b64u(sign(null, Buffer.from(text, "utf8"), privateKeyOf(signPriv)));
+}
+function verifyText(signPub, text, sig) {
+	try {
+		if (hasSmallOrder(fromB64u(signPub))) return false;
+		return verify(null, Buffer.from(text, "utf8"), publicKeyOf(signPub, "Ed25519"), fromB64u(sig));
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+//#region src/federation/ops.ts
+const OP_TYPES = [
+	"key",
+	"roster",
+	"task",
+	"presence",
+	"agent",
+	"channel",
+	"mail",
+	"state",
+	"memory",
+	"doc",
+	"a2a"
+];
+const SEALED_TYPES = new Set([
+	"mail",
+	"state",
+	"a2a"
+]);
+const STUBBABLE_TYPES = new Set([
+	"mail",
+	"state",
+	"presence",
+	"a2a"
+]);
+const MAX_OP_BYTES = 1048576;
+const MAX_SEALED_RECIPIENTS = 256;
+const MAX_STATE_ENTRIES = 500;
+const REPLICA_ID = /^[A-Za-z0-9._-]{1,32}-[0-9a-f]{8}$/;
+const ZERO_HASH = "0".repeat(64);
+const TAG = {
+	op: "dispatch-op-v2",
+	sealed: "dispatch-sealed-v1",
+	ack: "dispatch-ack-v1",
+	relay: "dispatch-relay-v1",
+	invite: "dispatch-invite-v1",
+	recovery: "dispatch-recovery-v1",
+	fingerprint: "dispatch-fp-v1"
+};
+function isStub(e) {
+	return "pruned" in e && e.pruned === true;
+}
+function headerOf(e) {
+	const h = {
+		v: 2,
+		replica: e.replica,
+		seq: e.seq,
+		prev: e.prev,
+		hlc: e.hlc,
+		type: e.type,
+		bodyHash: e.bodyHash
+	};
+	if (e.to !== void 0) h.to = e.to;
+	return h;
+}
+function contentHash(content) {
+	return sha256Hex(canonicalize(content));
+}
+function signingInput(h) {
+	return `${TAG.op}\n${canonicalize(h)}`;
+}
+function opHash(e) {
+	return sha256Hex(canonicalize({
+		...headerOf(e),
+		sig: e.sig
+	}));
+}
+function stubOf(op) {
+	return {
+		...headerOf(op),
+		sig: op.sig,
+		pruned: true
+	};
+}
+
+//#endregion
+//#region src/federation/chain.ts
+const TYPE = /^[a-z][a-z0-9-]{0,31}$/;
+const HEX64 = /^[0-9a-f]{64}$/;
+function buildOp(fields, signPriv) {
+	const problem = headerProblem(fields) ?? contentProblem(fields);
+	if (problem !== null) throw new RangeError(`cannot sign: ${problem}`);
+	const content = {};
+	if (fields.body !== void 0) content.body = fields.body;
+	if (fields.sealed !== void 0) content.sealed = fields.sealed;
+	const header = {
+		v: 2,
+		replica: fields.replica,
+		seq: fields.seq,
+		prev: fields.prev,
+		hlc: fields.hlc,
+		type: fields.type,
+		bodyHash: contentHash(content)
+	};
+	if (fields.to !== void 0) header.to = fields.to;
+	return {
+		...header,
+		...content,
+		sig: signText(signPriv, signingInput(header))
+	};
+}
+const fail = (reason) => ({
+	ok: false,
+	reason
+});
+function sortedUnique(list, max) {
+	if (!Array.isArray(list) || list.length === 0 || list.length > max) return false;
+	let last = "";
+	for (const r of list) {
+		if (typeof r !== "string" || !REPLICA_ID.test(r) || r <= last) return false;
+		last = r;
+	}
+	return true;
+}
+function sameKeys(sorted, keys) {
+	const other = [...keys].sort();
+	return sorted.length === other.length && sorted.every((r, i) => r === other[i]);
+}
+const isHex64 = (v) => typeof v === "string" && HEX64.test(v);
+function headerProblem(h) {
+	if (typeof h.replica !== "string" || !REPLICA_ID.test(h.replica)) return "replica id outside the grammar";
+	if (typeof h.type !== "string" || !TYPE.test(h.type)) return "not a v2 op";
+	if (!Number.isSafeInteger(h.seq) || h.seq < 1) return "seq must rise";
+	if (!isHex64(h.prev)) return "malformed op";
+	const clock = typeof h.hlc === "string" ? parseOpHlc(h.hlc) : null;
+	if (clock === null) return "hlc outside the grammar";
+	if (clock.replica !== h.replica) return "hlc must name its own replica";
+	if (h.to !== void 0 && !sortedUnique(h.to, MAX_SEALED_RECIPIENTS)) return "bad recipient list";
+	return null;
+}
+function contentProblem(e) {
+	const sealedType = SEALED_TYPES.has(e.type);
+	if (sealedType && e.sealed === void 0) return "sealed types carry sealed content";
+	if (e.type === "state" && e.body !== void 0) return "state ops carry only sealed content";
+	if (!sealedType && (e.sealed !== void 0 || e.to !== void 0)) return "only mail and state are sealed";
+	if (sealedType && (e.to === void 0 || !sameKeys(e.to, Object.keys(e.sealed?.keys ?? {})))) return "keys must equal to";
+	return null;
+}
+function wellFormed(e) {
+	if (typeof e !== "object" || e === null || Array.isArray(e)) return false;
+	const { prev, bodyHash, sig } = e;
+	return typeof sig === "string" && isHex64(prev) && isHex64(bodyHash);
+}
+function orNull(step) {
+	try {
+		return step();
+	} catch {
+		return null;
+	}
+}
+function verifyEntry(head, e, signPub) {
+	if (!wellFormed(e)) return fail("malformed op");
+	if (e.v !== 2) return fail("not a v2 op");
+	const problem = headerProblem(e);
+	if (problem !== null) return fail(problem);
+	const bytes = orNull(() => Buffer.byteLength(canonicalize(e)));
+	if (bytes === null) return fail("malformed op");
+	if (bytes > MAX_OP_BYTES) return fail("over MAX_OP_BYTES");
+	if (head === null) {
+		if (isStub(e) || e.type !== "key" || e.prev !== ZERO_HASH) return fail("a log must start with its key op");
+	} else {
+		if (e.type === "key") return fail("a second key op");
+		if (e.prev !== head.hash) return fail("prev does not match");
+		if (e.seq <= head.seq) return fail("seq must rise");
+		const clock = parseOpHlc(e.hlc);
+		const before = parseOpHlc(head.hlc);
+		if (clock !== null && before !== null && compareHlc(clock, before) <= 0) return fail("hlc must rise");
+	}
+	if (!verifyText(signPub, signingInput(headerOf(e)), e.sig)) return fail("bad signature");
+	if (isStub(e)) {
+		if (!STUBBABLE_TYPES.has(e.type)) return fail(`a ${e.type} op cannot be a stub`);
+		if ("body" in e || "sealed" in e) return fail("a stub carries no content");
+	} else {
+		const content = {};
+		if (e.body !== void 0) content.body = e.body;
+		if (e.sealed !== void 0) content.sealed = e.sealed;
+		const hash = orNull(() => contentHash(content));
+		if (hash === null) return fail("malformed op");
+		if (hash !== e.bodyHash) return fail("bodyHash mismatch");
+		const broken = contentProblem(e);
+		if (broken !== null) return fail(broken);
+	}
+	return {
+		ok: true,
+		head: {
+			seq: e.seq,
+			hash: opHash(e),
+			hlc: e.hlc
+		}
+	};
+}
+
+//#endregion
+//#region src/federation/fingerprint.ts
+function fingerprint(signPub, sealPub) {
+	return (crockford32(createHash("sha256").update(`${TAG.fingerprint}\n${signPub}\n${sealPub}`).digest().subarray(0, 15)).match(/.{4}/g) ?? []).join("-");
+}
+
+//#endregion
+//#region src/federation/hpke.ts
+const i2osp2 = (n) => Buffer.from([n >> 8 & 255, n & 255]);
+const KEM_SUITE = Buffer.concat([Buffer.from("KEM"), i2osp2(32)]);
+const HPKE_SUITE = Buffer.concat([
+	Buffer.from("HPKE"),
+	i2osp2(32),
+	i2osp2(1),
+	i2osp2(2)
+]);
+const V1 = Buffer.from("HPKE-v1");
+const NH = 32;
+const NK = 32;
+const NN = 12;
+const TAG_BYTES = 16;
+const EMPTY = Buffer.alloc(0);
+function extract(salt, ikm) {
+	return createHmac("sha256", salt.length === 0 ? Buffer.alloc(NH) : salt).update(ikm).digest();
+}
+function expand(prk, info, length) {
+	const blocks = [];
+	let t = EMPTY;
+	for (let i = 1; blocks.length * NH < length; i++) {
+		t = createHmac("sha256", prk).update(Buffer.concat([
+			t,
+			info,
+			Buffer.from([i])
+		])).digest();
+		blocks.push(t);
+	}
+	return Buffer.concat(blocks).subarray(0, length);
+}
+function labeledExtract(suite, salt, label, ikm) {
+	return extract(salt, Buffer.concat([
+		V1,
+		suite,
+		Buffer.from(label),
+		ikm
+	]));
+}
+function labeledExpand(suite, prk, label, info, length) {
+	return expand(prk, Buffer.concat([
+		i2osp2(length),
+		V1,
+		suite,
+		Buffer.from(label),
+		info
+	]), length);
+}
+function x25519Public(raw) {
+	return publicKeyOf(raw.toString("base64url"), "X25519");
+}
+function freshEphemeral() {
+	const pair = generateKeyPairSync("x25519");
+	const { x } = pair.publicKey.export({ format: "jwk" });
+	if (typeof x !== "string") throw new Error("expected an OKP public key");
+	return {
+		privateKey: pair.privateKey,
+		publicRaw: fromB64u(x)
+	};
+}
+function sharedSecretOf(dh, enc, pkR) {
+	return labeledExpand(KEM_SUITE, labeledExtract(KEM_SUITE, EMPTY, "eae_prk", dh), "shared_secret", Buffer.concat([enc, pkR]), NH);
+}
+function encap(pkR, ephemeral = freshEphemeral()) {
+	return {
+		sharedSecret: sharedSecretOf(diffieHellman({
+			privateKey: ephemeral.privateKey,
+			publicKey: x25519Public(pkR)
+		}), ephemeral.publicRaw, pkR),
+		enc: ephemeral.publicRaw
+	};
+}
+function decap(enc, skR, pkR) {
+	return sharedSecretOf(diffieHellman({
+		privateKey: skR,
+		publicKey: x25519Public(enc)
+	}), enc, pkR);
+}
+function keySchedule(sharedSecret, info) {
+	const pskIdHash = labeledExtract(HPKE_SUITE, EMPTY, "psk_id_hash", EMPTY);
+	const infoHash = labeledExtract(HPKE_SUITE, EMPTY, "info_hash", info);
+	const context = Buffer.concat([
+		Buffer.from([0]),
+		pskIdHash,
+		infoHash
+	]);
+	const secret = labeledExtract(HPKE_SUITE, sharedSecret, "secret", EMPTY);
+	return {
+		key: labeledExpand(HPKE_SUITE, secret, "key", context, NK),
+		baseNonce: labeledExpand(HPKE_SUITE, secret, "base_nonce", context, NN)
+	};
+}
+function aeadSeal(key, nonce, aad, pt) {
+	const c = createCipheriv("aes-256-gcm", key, nonce);
+	c.setAAD(aad);
+	return Buffer.concat([
+		c.update(pt),
+		c.final(),
+		c.getAuthTag()
+	]);
+}
+function aeadOpen(key, nonce, aad, ct) {
+	if (ct.length < TAG_BYTES) throw new RangeError("ciphertext too short");
+	const d = createDecipheriv("aes-256-gcm", key, nonce);
+	d.setAAD(aad);
+	d.setAuthTag(ct.subarray(ct.length - TAG_BYTES));
+	return Buffer.concat([d.update(ct.subarray(0, ct.length - TAG_BYTES)), d.final()]);
+}
+function sealBase(pkR, info, pt) {
+	const { sharedSecret, enc } = encap(pkR);
+	const { key, baseNonce } = keySchedule(sharedSecret, info);
+	return {
+		enc,
+		ct: aeadSeal(key, baseNonce, EMPTY, pt)
+	};
+}
+function openBase(enc, skR, pkR, info, ct) {
+	const { key, baseNonce } = keySchedule(decap(enc, skR, pkR), info);
+	return aeadOpen(key, baseNonce, EMPTY, ct);
+}
+
+//#endregion
+//#region src/federation/seal.ts
+const CONTENT_KEY_BYTES = 32;
+const NONCE_BYTES = 12;
+const X25519_PUBLIC_BYTES = 32;
+const FIELD_PRIME = 2n ** 255n - 19n;
+function sealedAad(replica, seq, type) {
+	return `${TAG.sealed}\n${replica}\n${seq}\n${type}`;
+}
+function sealPayload(input) {
+	const to = [...input.recipients.keys()].sort();
+	if (to.length === 0 || to.length > MAX_SEALED_RECIPIENTS) throw new RangeError(`a sealed op names 1-${MAX_SEALED_RECIPIENTS} recipients`);
+	for (const r of to) {
+		if (!REPLICA_ID.test(r)) throw new RangeError(`${r} is not a replica id`);
+		if (!canSealTo(input.recipients.get(r) ?? "")) throw new RangeError(`cannot seal to ${r}: its sealPub is unusable`);
+	}
+	const key = randomBytes(CONTENT_KEY_BYTES);
+	const nonce = randomBytes(NONCE_BYTES);
+	const aad = sealedAad(input.replica, input.seq, input.type);
+	const ct = aeadSeal(key, nonce, Buffer.from(aad), Buffer.from(canonicalizeLenient(input.payload)));
+	const keys = {};
+	for (const r of to) keys[r] = wrapContentKey(key, aad, r, input.recipients.get(r) ?? "");
+	return {
+		to,
+		sealed: {
+			nonce: b64u(nonce),
+			ct: b64u(ct),
+			keys
+		},
+		key
+	};
+}
+function canSealTo(sealPub) {
+	try {
+		const raw = fromB64u(sealPub);
+		if (raw.length !== X25519_PUBLIC_BYTES) return false;
+		if (BigInt(`0x${Buffer.from(raw).reverse().toString("hex")}`) >= FIELD_PRIME) return false;
+		encap(raw);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function wrapContentKey(key, aad, recipient, sealPub) {
+	const { enc, ct } = sealBase(fromB64u(sealPub), Buffer.from(`${aad}\n${recipient}`), key);
+	return {
+		enc: b64u(enc),
+		ct: b64u(ct)
+	};
+}
+function unwrapContentKey(op, me, sealPriv) {
+	const wrap = op.sealed?.keys[me];
+	if (wrap === void 0) return null;
+	try {
+		const skR = privateKeyOf(sealPriv);
+		const pkR = fromB64u(publicOfPrivate(sealPriv));
+		const aad = sealedAad(op.replica, op.seq, op.type);
+		return openBase(fromB64u(wrap.enc), skR, pkR, Buffer.from(`${aad}\n${me}`), fromB64u(wrap.ct));
+	} catch {
+		return null;
+	}
+}
+function openWithKey(op, key) {
+	if (op.sealed === void 0) return null;
+	try {
+		const aad = sealedAad(op.replica, op.seq, op.type);
+		const pt = aeadOpen(key, fromB64u(op.sealed.nonce), Buffer.from(aad), fromB64u(op.sealed.ct));
+		return JSON.parse(pt.toString("utf8"));
+	} catch {
+		return null;
+	}
+}
+function openPayload(op, me, sealPriv) {
+	const key = unwrapContentKey(op, me, sealPriv);
+	return key === null ? null : openWithKey(op, key);
+}
+
+//#endregion
+export { CanonicalizeError, MAX_CLOCK_LEAD_MS, MAX_HLC_COUNTER, MAX_JSON_DEPTH, MAX_OP_BYTES, MAX_SEALED_RECIPIENTS, MAX_STATE_ENTRIES, OP_TYPES, OpClock, REPLICA_ID, SEALED_TYPES, STUBBABLE_TYPES, TAG, ZERO_HASH, aheadOfClock, b64u, buildOp, canSealTo, canonicalize, compareHlc, contentHash, crockford32, ed25519FromSeed, fingerprint, fromB64u, generateReplicaKeys, headerOf, hlcWallMs, isStub, opHash, openPayload, openWithKey, parseOpHlc, publicOfPrivate, sealPayload, sealedAad, sha256Hex, signText, stubOf, unwrapContentKey, verifyEntry, verifyText, wrapContentKey };
+//# sourceMappingURL=index.js.map