@labacacia/nps-sdk 1.0.0-alpha.3 → 1.0.0-alpha.4

package/tests/ncp/preamble.test.ts

@@ -0,0 +1,93 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) 2026 LabAcacia / INNO LOTUS PTY LTD
+//
+// Parity tests for NPS-RFC-0001 NCP native-mode connection preamble.
+
+import { describe, it, expect } from "vitest";
+import {
+  PREAMBLE_BYTES,
+  PREAMBLE_LENGTH,
+  PREAMBLE_LITERAL,
+  PREAMBLE_ERROR_CODE,
+  PREAMBLE_STATUS_CODE,
+  preambleMatches,
+  tryValidatePreamble,
+  validatePreamble,
+  writePreamble,
+  NcpPreambleInvalidError,
+} from "../../src/ncp/preamble.js";
+
+const SPEC_BYTES = new Uint8Array([0x4e, 0x50, 0x53, 0x2f, 0x31, 0x2e, 0x30, 0x0a]);
+
+describe("NCP preamble", () => {
+  it("bytes are exactly the spec constant", () => {
+    expect(PREAMBLE_LENGTH).toBe(8);
+    expect(PREAMBLE_LITERAL).toBe("NPS/1.0\n");
+    expect(PREAMBLE_BYTES).toEqual(SPEC_BYTES);
+  });
+
+  it("matches returns true for exact preamble", () => {
+    expect(preambleMatches(PREAMBLE_BYTES)).toBe(true);
+  });
+
+  it("matches returns true when preamble is at start of longer buffer", () => {
+    const combined = new Uint8Array(16);
+    combined.set(PREAMBLE_BYTES, 0);
+    combined[8] = 0x06;
+    expect(preambleMatches(combined)).toBe(true);
+  });
+
+  it.each([0, 1, 7])("matches returns false on short read length=%i", (n) => {
+    expect(preambleMatches(PREAMBLE_BYTES.slice(0, n))).toBe(false);
+  });
+
+  it("tryValidate accepts exact preamble", () => {
+    const r = tryValidatePreamble(PREAMBLE_BYTES);
+    expect(r.valid).toBe(true);
+    expect(r.reason).toBe("");
+  });
+
+  it("tryValidate rejects short read with reason", () => {
+    const r = tryValidatePreamble(new Uint8Array(3));
+    expect(r.valid).toBe(false);
+    expect(r.reason).toContain("short read");
+    expect(r.reason).toContain("3/8");
+  });
+
+  it("tryValidate rejects arbitrary garbage", () => {
+    const r = tryValidatePreamble(new TextEncoder().encode("GET / HTT"));
+    expect(r.valid).toBe(false);
+    expect(r.reason).not.toContain("future");
+    expect(r.reason).toContain("not speaking NPS");
+  });
+
+  it("tryValidate flags future-major-version distinctly", () => {
+    const r = tryValidatePreamble(new TextEncoder().encode("NPS/2.0\n"));
+    expect(r.valid).toBe(false);
+    expect(r.reason).toContain("future-major");
+  });
+
+  it("validate throws with codes exposed", () => {
+    try {
+      validatePreamble(new TextEncoder().encode("BADXXXXX"));
+      throw new Error("expected throw");
+    } catch (e) {
+      const err = e as NcpPreambleInvalidError;
+      expect(err.errorCode).toBe("NCP-PREAMBLE-INVALID");
+      expect(err.statusCode).toBe("NPS-PROTO-PREAMBLE-INVALID");
+      expect(err.message).not.toBe("");
+    }
+  });
+
+  it("writePreamble emits exactly the constant bytes", () => {
+    const chunks: Uint8Array[] = [];
+    writePreamble({ write: (b) => chunks.push(b) });
+    expect(chunks).toHaveLength(1);
+    expect(chunks[0]).toEqual(SPEC_BYTES);
+  });
+
+  it("status and error code constants match spec", () => {
+    expect(PREAMBLE_ERROR_CODE).toBe("NCP-PREAMBLE-INVALID");
+    expect(PREAMBLE_STATUS_CODE).toBe("NPS-PROTO-PREAMBLE-INVALID");
+  });
+});

package/tests/nip-acme-agent01.test.ts

@@ -0,0 +1,192 @@
+// Copyright 2026 INNO LOTUS PTY LTD
+// SPDX-License-Identifier: Apache-2.0
+
+// TypeScript parallel of Java AcmeAgent01Tests / .NET AcmeAgent01Tests
+// per NPS-RFC-0002 §4.4. End-to-end agent-01 round-trip plus tampered-signature
+// negative path.
+
+import { describe, expect, it } from "vitest";
+import * as ed25519 from "@noble/ed25519";
+import { sha512 } from "@noble/hashes/sha512";
+import * as x509 from "@peculiar/x509";
+
+import { AssuranceLevel } from "../src/nip/assurance-level.js";
+import * as ec from "../src/nip/error-codes.js";
+import { issueRoot } from "../src/nip/x509/builder.js";
+import { verify as verifyX509 } from "../src/nip/x509/verifier.js";
+import { AcmeClient } from "../src/nip/acme/client.js";
+import { AcmeServer } from "../src/nip/acme/server.js";
+import * as Jws from "../src/nip/acme/jws.js";
+import * as wire from "../src/nip/acme/wire.js";
+import type {
+  Authorization, ChallengeRespondPayload, Directory, NewAccountPayload,
+  NewOrderPayload, Order, ProblemDetail,
+} from "../src/nip/acme/messages.js";
+import { generateDualKeyPair, randomHexSerial } from "./_rfc0002-keys.js";
+
+ed25519.etc.sha512Sync = (...m) => sha512(ed25519.etc.concatBytes(...m));
+x509.cryptoProvider.set(globalThis.crypto);
+
+interface Fixture {
+  caNid:     string;
+  agentNid:  string;
+  caRoot:    x509.X509Certificate;
+  agentKeys: Awaited<ReturnType<typeof generateDualKeyPair>>;
+  server:    AcmeServer;
+}
+
+async function createFixture(): Promise<Fixture> {
+  const caNid    = "urn:nps:ca:acme-test";
+  const agentNid = "urn:nps:agent:acme-test:1";
+
+  const caKeys = await generateDualKeyPair();
+  const caRoot = await issueRoot({
+    caNid, caKeys: caKeys.webCrypto,
+    notBefore: new Date(Date.now() - 60_000),
+    notAfter:  new Date(Date.now() + 365 * 24 * 3600_000),
+    serialNumber: "01",
+  });
+
+  const agentKeys = await generateDualKeyPair();
+
+  const server = new AcmeServer({
+    caNid, caKeys: caKeys.webCrypto, caRootCert: caRoot,
+    certValidityMs: 30 * 24 * 3600_000,
+  });
+  await server.start();
+
+  return { caNid, agentNid, caRoot, agentKeys, server };
+}
+
+describe("ACME agent-01 — RFC-0002 §4.4 round-trip", () => {
+
+  it("issueAgentCert round-trip returns a PEM chain that verifies against the CA root", async () => {
+    const fx = await createFixture();
+    try {
+      const client = new AcmeClient({
+        directoryUrl:  fx.server.directoryUrl,
+        privateKey:    fx.agentKeys.privRaw,
+        publicKey:     fx.agentKeys.pubRaw,
+        webCryptoKeys: fx.agentKeys.webCrypto,
+      });
+
+      const pem = await client.issueAgentCert(fx.agentNid);
+      expect(pem).toContain("BEGIN CERTIFICATE");
+
+      // Parse PEM chain and re-encode as base64url DER for the X.509 verifier.
+      const certs = x509.PemConverter.decode(pem)
+        .map((buf) => new x509.X509Certificate(buf));
+      expect(certs.length).toBeGreaterThan(0);
+      const chainB64 = certs.map((c) => b64uEncode(new Uint8Array(c.rawData)));
+
+      const result = await verifyX509({
+        certChainBase64UrlDer:  chainB64,
+        assertedNid:            fx.agentNid,
+        assertedAssuranceLevel: AssuranceLevel.ANONYMOUS,
+        trustedRootCerts:       [fx.caRoot],
+      });
+      expect(result.valid).toBe(true);
+      expect(extractCn(result.leaf!.subject)).toBe(fx.agentNid);
+    } finally {
+      await fx.server.close();
+    }
+  });
+
+  it("respondAgent01 with tampered agent_signature → server returns NIP-ACME-CHALLENGE-FAILED", async () => {
+    const fx = await createFixture();
+    try {
+      // Drive the flow manually so we can splice in a forged challenge response.
+      const dirResp = await fetch(fx.server.directoryUrl);
+      expect(dirResp.ok).toBe(true);
+      const dir = await dirResp.json() as Directory;
+
+      const nonceResp = await fetch(dir.newNonce, { method: "HEAD" });
+      let nonce = nonceResp.headers.get("Replay-Nonce")!;
+      expect(nonce).not.toBeNull();
+
+      // newAccount.
+      const jwk = Jws.jwkFromPublicKey(fx.agentKeys.pubRaw);
+      const acctEnv = Jws.sign(
+        { alg: Jws.ALG_EDDSA, nonce, url: dir.newAccount, jwk },
+        { termsOfServiceAgreed: true } as NewAccountPayload,
+        fx.agentKeys.privRaw);
+      const acctResp = await postJose(dir.newAccount, acctEnv);
+      expect(acctResp.status).toBe(201);
+      const accountUrl = acctResp.headers.get("Location")!;
+      nonce = acctResp.headers.get("Replay-Nonce")!;
+
+      // newOrder.
+      const orderEnv = Jws.sign(
+        { alg: Jws.ALG_EDDSA, nonce, url: dir.newOrder, kid: accountUrl },
+        {
+          identifiers: [{ type: wire.IDENTIFIER_TYPE_NID, value: fx.agentNid }],
+        } as NewOrderPayload,
+        fx.agentKeys.privRaw);
+      const orderResp = await postJose(dir.newOrder, orderEnv);
+      expect(orderResp.status).toBe(201);
+      const order = await orderResp.json() as Order;
+      nonce = orderResp.headers.get("Replay-Nonce")!;
+
+      // POST-as-GET on authz to discover the challenge URL + token.
+      const authzEnv = Jws.sign(
+        { alg: Jws.ALG_EDDSA, nonce, url: order.authorizations[0], kid: accountUrl },
+        null, fx.agentKeys.privRaw);
+      const authzResp = await postJose(order.authorizations[0], authzEnv);
+      const authz = await authzResp.json() as Authorization;
+      nonce = authzResp.headers.get("Replay-Nonce")!;
+
+      const challenge = authz.challenges.find((c) => c.type === wire.CHALLENGE_AGENT_01);
+      expect(challenge).toBeDefined();
+
+      // ★ Tampered: sign challenge token with a *different* keypair, but submit
+      //   the JWS envelope under the registered account's key — server verifies
+      //   the JWS sig (passes with account key) and then verifies the agent
+      //   signature against the account key (fails).
+      const forger = await generateDualKeyPair();
+      const tokenBytes = new TextEncoder().encode(challenge!.token);
+      const forgedSig  = ed25519.sign(tokenBytes, forger.privRaw);
+
+      const chEnv = Jws.sign(
+        { alg: Jws.ALG_EDDSA, nonce, url: challenge!.url, kid: accountUrl },
+        { agent_signature: Jws.b64uEncode(forgedSig) } as ChallengeRespondPayload,
+        fx.agentKeys.privRaw);
+      const chResp = await postJose(challenge!.url, chEnv);
+
+      expect(chResp.status).toBe(400);
+      const problem = await chResp.json() as ProblemDetail;
+      expect(problem.type).toBe(ec.ACME_CHALLENGE_FAILED);
+    } finally {
+      await fx.server.close();
+    }
+  });
+});
+
+// ── helpers ──────────────────────────────────────────────────────────────────
+
+async function postJose(url: string, env: Jws.Envelope): Promise<Response> {
+  return await fetch(url, {
+    method:  "POST",
+    headers: { "Content-Type": wire.CONTENT_TYPE_JOSE_JSON },
+    body:    JSON.stringify(env),
+  });
+}
+
+function b64uEncode(bytes: Uint8Array): string {
+  return Buffer.from(bytes).toString("base64").replace(/=+$/, "")
+    .replace(/\+/g, "-").replace(/\//g, "_");
+}
+
+function extractCn(dn: string): string | null {
+  for (const rdn of dn.split(",")) {
+    const t = rdn.trim();
+    if (t.startsWith("CN=")) {
+      let v = t.slice(3);
+      if (v.startsWith("\"") && v.endsWith("\"")) v = v.slice(1, -1);
+      return v.replace(/\\([",+;<>\\])/g, "$1");
+    }
+  }
+  return null;
+}
+
+// Touch the import so unused-symbol lint doesn't trip.
+void randomHexSerial;

package/tests/nip-x509.test.ts

@@ -0,0 +1,280 @@
+// Copyright 2026 INNO LOTUS PTY LTD
+// SPDX-License-Identifier: Apache-2.0
+
+// TypeScript parallel of Java NipX509Tests / .NET NipX509Tests per NPS-RFC-0002 §4.
+// Covers the 5 verification scenarios documented in the .NET reference.
+
+import { describe, expect, it } from "vitest";
+import * as ed25519 from "@noble/ed25519";
+import { sha512 } from "@noble/hashes/sha512";
+import * as x509 from "@peculiar/x509";
+
+import { AssuranceLevel } from "../src/nip/assurance-level.js";
+import { V2_X509 } from "../src/nip/cert-format.js";
+import * as ec from "../src/nip/error-codes.js";
+import { IdentFrame } from "../src/nip/frames.js";
+import { NipIdentVerifier } from "../src/nip/verifier.js";
+import { issueLeaf, issueRoot } from "../src/nip/x509/builder.js";
+import { generateDualKeyPair, randomHexSerial, type DualKeyPair } from "./_rfc0002-keys.js";
+
+ed25519.etc.sha512Sync = (...m) => sha512(ed25519.etc.concatBytes(...m));
+x509.cryptoProvider.set(globalThis.crypto);
+
+describe("NipX509 — RFC-0002 §4 verifier scenarios", () => {
+
+  it("registerX509 round-trip — dual-trust verifier accepts", async () => {
+    const caNid    = "urn:nps:ca:test";
+    const agentNid = "urn:nps:agent:happy:1";
+
+    const ca    = await generateDualKeyPair();
+    const agent = await generateDualKeyPair();
+
+    const root = await issueRoot({
+      caNid, caKeys: ca.webCrypto,
+      notBefore: minutesAgo(1), notAfter: daysFromNow(365),
+      serialNumber: "01",
+    });
+    const leaf = await issueLeaf({
+      subjectNid: agentNid, subjectPublicKey: agent.webCrypto.publicKey,
+      caKeys: ca.webCrypto, issuerNid: caNid, role: "agent",
+      assuranceLevel: AssuranceLevel.ATTESTED,
+      notBefore: minutesAgo(1), notAfter: daysFromNow(30),
+      serialNumber: "02",
+    });
+
+    const frame = await buildV2Frame(agentNid, agent.pubRaw, ca.privRaw,
+      AssuranceLevel.ATTESTED, leaf, root);
+
+    const verifier = new NipIdentVerifier({
+      trustedCaPublicKeys: { [caNid]: pubKeyHex(ca.pubRaw) },
+      trustedX509Roots:    [root],
+    });
+    const result = await verifier.verify(frame, caNid);
+
+    expect(result.valid).toBe(true);
+    expect(result.stepFailed).toBe(0);
+  });
+
+  it("leaf without EKU extension — verifier rejects with NIP-CERT-EKU-MISSING", async () => {
+    const caNid    = "urn:nps:ca:test";
+    const agentNid = "urn:nps:agent:eku-stripped:1";
+
+    const ca    = await generateDualKeyPair();
+    const agent = await generateDualKeyPair();
+
+    const root = await issueRoot({
+      caNid, caKeys: ca.webCrypto,
+      notBefore: minutesAgo(1), notAfter: daysFromNow(365),
+      serialNumber: "01",
+    });
+    const tampered = await buildLeafWithoutEku(
+      agentNid, agent.webCrypto.publicKey, ca.webCrypto, caNid, "63");
+
+    const frame = await buildV2Frame(agentNid, agent.pubRaw, ca.privRaw,
+      null, tampered, root);
+
+    const verifier = new NipIdentVerifier({
+      trustedCaPublicKeys: { [caNid]: pubKeyHex(ca.pubRaw) },
+      trustedX509Roots:    [root],
+    });
+    const result = await verifier.verify(frame, caNid);
+
+    expect(result.valid).toBe(false);
+    expect(result.errorCode).toBe(ec.CERT_EKU_MISSING);
+    expect(result.stepFailed).toBe(3);
+  });
+
+  it("leaf for different NID — verifier rejects with NIP-CERT-SUBJECT-NID-MISMATCH", async () => {
+    const caNid    = "urn:nps:ca:test";
+    const victimNid = "urn:nps:agent:victim:1";
+    const forgedNid = "urn:nps:agent:attacker:9";
+
+    const ca    = await generateDualKeyPair();
+    const agent = await generateDualKeyPair();
+
+    const root = await issueRoot({
+      caNid, caKeys: ca.webCrypto,
+      notBefore: minutesAgo(1), notAfter: daysFromNow(365),
+      serialNumber: "01",
+    });
+    // Issue a leaf whose CN/SAN are the *forged* NID, but splice it into a
+    // frame asserting the *victim* NID. The v1 Ed25519 sig still asserts victim.
+    const forgedLeaf = await issueLeaf({
+      subjectNid: forgedNid, subjectPublicKey: agent.webCrypto.publicKey,
+      caKeys: ca.webCrypto, issuerNid: caNid, role: "agent",
+      assuranceLevel: AssuranceLevel.ANONYMOUS,
+      notBefore: minutesAgo(1), notAfter: daysFromNow(30),
+      serialNumber: "4d",
+    });
+
+    const frame = await buildV2Frame(victimNid, agent.pubRaw, ca.privRaw,
+      null, forgedLeaf, root);
+
+    const verifier = new NipIdentVerifier({
+      trustedCaPublicKeys: { [caNid]: pubKeyHex(ca.pubRaw) },
+      trustedX509Roots:    [root],
+    });
+    const result = await verifier.verify(frame, caNid);
+
+    expect(result.valid).toBe(false);
+    expect(result.errorCode).toBe(ec.CERT_SUBJECT_NID_MISMATCH);
+    expect(result.stepFailed).toBe(3);
+  });
+
+  it("v1-only verifier ignores cert_chain and accepts v2 frames (Phase 1 backward compat)", async () => {
+    const caNid    = "urn:nps:ca:test";
+    const agentNid = "urn:nps:agent:v1-compat:1";
+
+    const ca    = await generateDualKeyPair();
+    const agent = await generateDualKeyPair();
+
+    const root = await issueRoot({
+      caNid, caKeys: ca.webCrypto,
+      notBefore: minutesAgo(1), notAfter: daysFromNow(365),
+      serialNumber: "01",
+    });
+    const leaf = await issueLeaf({
+      subjectNid: agentNid, subjectPublicKey: agent.webCrypto.publicKey,
+      caKeys: ca.webCrypto, issuerNid: caNid, role: "agent",
+      assuranceLevel: AssuranceLevel.ANONYMOUS,
+      notBefore: minutesAgo(1), notAfter: daysFromNow(30),
+      serialNumber: "02",
+    });
+
+    const frame = await buildV2Frame(agentNid, agent.pubRaw, ca.privRaw,
+      null, leaf, root);
+
+    // Verifier WITHOUT trustedX509Roots — Step 3b is skipped entirely.
+    const verifier = new NipIdentVerifier({
+      trustedCaPublicKeys: { [caNid]: pubKeyHex(ca.pubRaw) },
+    });
+    const result = await verifier.verify(frame, caNid);
+
+    expect(result.valid).toBe(true);
+    expect(result.stepFailed).toBe(0);
+  });
+
+  it("v2 verifier with unrelated trust root rejects with NIP-CERT-FORMAT-INVALID", async () => {
+    const caNid    = "urn:nps:ca:test";
+    const agentNid = "urn:nps:agent:wrong-trust:1";
+
+    const ca    = await generateDualKeyPair();
+    const agent = await generateDualKeyPair();
+
+    const root = await issueRoot({
+      caNid, caKeys: ca.webCrypto,
+      notBefore: minutesAgo(1), notAfter: daysFromNow(365),
+      serialNumber: "01",
+    });
+    const leaf = await issueLeaf({
+      subjectNid: agentNid, subjectPublicKey: agent.webCrypto.publicKey,
+      caKeys: ca.webCrypto, issuerNid: caNid, role: "agent",
+      assuranceLevel: AssuranceLevel.ANONYMOUS,
+      notBefore: minutesAgo(1), notAfter: daysFromNow(30),
+      serialNumber: "02",
+    });
+
+    const frame = await buildV2Frame(agentNid, agent.pubRaw, ca.privRaw,
+      null, leaf, root);
+
+    // Different unrelated CA root — chain won't anchor.
+    const otherCa   = await generateDualKeyPair();
+    const otherRoot = await issueRoot({
+      caNid: "urn:nps:ca:other", caKeys: otherCa.webCrypto,
+      notBefore: minutesAgo(1), notAfter: daysFromNow(365),
+      serialNumber: "01",
+    });
+
+    const verifier = new NipIdentVerifier({
+      trustedCaPublicKeys: { [caNid]: pubKeyHex(ca.pubRaw) },
+      trustedX509Roots:    [otherRoot],
+    });
+    const result = await verifier.verify(frame, caNid);
+
+    expect(result.valid).toBe(false);
+    expect(result.errorCode).toBe(ec.CERT_FORMAT_INVALID);
+    expect(result.stepFailed).toBe(3);
+  });
+});
+
+// ── helpers ──────────────────────────────────────────────────────────────────
+
+/**
+ * Build a v2 IdentFrame including a v1 Ed25519 CA signature over the canonical
+ * unsigned dict (matches IdentFrame.unsignedDict + NipIdentVerifier signing path).
+ */
+async function buildV2Frame(
+  subjectNid:  string,
+  subjectPub:  Uint8Array,
+  caPriv:      Uint8Array,
+  level:       AssuranceLevel | null,
+  leaf:        x509.X509Certificate,
+  root:        x509.X509Certificate,
+): Promise<IdentFrame> {
+  const pubKeyStr = pubKeyHex(subjectPub);
+  const metadata  = { issued_by: "test-ca" };
+
+  const unsigned: Record<string, unknown> = {
+    nid:      subjectNid,
+    pub_key:  pubKeyStr,
+    metadata,
+  };
+  if (level !== null) unsigned["assurance_level"] = level.wire;
+
+  const canonical = JSON.stringify(unsigned, Object.keys(unsigned).sort());
+  const sig       = ed25519.sign(new TextEncoder().encode(canonical), caPriv);
+  const sigWire   = "ed25519:" + Buffer.from(sig).toString("base64");
+
+  const chain = [
+    b64uEncode(new Uint8Array(leaf.rawData)),
+    b64uEncode(new Uint8Array(root.rawData)),
+  ];
+
+  return new IdentFrame(subjectNid, pubKeyStr, metadata, sigWire, {
+    assuranceLevel: level,
+    certFormat:     V2_X509,
+    certChain:      chain,
+  });
+}
+
+/** Issue a leaf cert with EKU extension deliberately omitted. */
+async function buildLeafWithoutEku(
+  subjectNid:  string,
+  subjectPub:  CryptoKey,
+  caKeys:      CryptoKeyPair,
+  caNid:       string,
+  serial:      string,
+): Promise<x509.X509Certificate> {
+  const escape = (v: string) => v.replace(/([",+;<>\\])/g, "\\$1");
+  return x509.X509CertificateGenerator.create({
+    serialNumber: serial,
+    issuer:       `CN=${escape(caNid)}`,
+    subject:      `CN=${escape(subjectNid)}`,
+    notBefore:    minutesAgo(1),
+    notAfter:     daysFromNow(30),
+    publicKey:    subjectPub,
+    signingAlgorithm: { name: "Ed25519" },
+    signingKey:   caKeys.privateKey,
+    extensions: [
+      new x509.BasicConstraintsExtension(false, undefined, true),
+      new x509.KeyUsagesExtension(x509.KeyUsageFlags.digitalSignature, true),
+      // ★ Deliberately NO ExtendedKeyUsage extension.
+      new x509.SubjectAlternativeNameExtension([{ type: "url", value: subjectNid }], false),
+    ],
+  });
+}
+
+function pubKeyHex(raw: Uint8Array): string {
+  return "ed25519:" + Buffer.from(raw).toString("hex");
+}
+
+function b64uEncode(bytes: Uint8Array): string {
+  return Buffer.from(bytes).toString("base64").replace(/=+$/, "")
+    .replace(/\+/g, "-").replace(/\//g, "_");
+}
+
+function minutesAgo(n: number):    Date { return new Date(Date.now() - n * 60_000); }
+function daysFromNow(n: number):   Date { return new Date(Date.now() + n * 24 * 3600_000); }
+
+// Touch the type so TS doesn't tree-shake the import in declaration emit.
+type _ = DualKeyPair;