xoonya 3.1.16 → 3.2.0

package/scripts/verify_vectors.js

@@ -1,170 +1,412 @@
 "use strict";
 
+// Conformance + adversarial vector run for the xoonya verifier.
+//
+// Runs on the standalone verifier (lib/native_verify.js + lib/external_proof_verify.js)
+// with Node built-ins only, so it works identically from the published package and
+// from the source checkout. When the proof engine is present next to this script
+// (source checkout only; proof_sdk.js is never published), it additionally runs an
+// engine-parity cross-check: every vector, every option variant, every freshly
+// emitted bundle and every mutation is verified by BOTH the engine and the
+// standalone verifier and the full result objects must be deep-equal.
+
 const assert = require("assert");
+const crypto = require("crypto");
 const fs = require("fs");
 const path = require("path");
-const sdk = require("..");
-
-const conformanceVectors = JSON.parse(
-  fs.readFileSync(path.resolve(__dirname, "..", "vectors", "conformance-vectors.json"), "utf8")
-);
-const adversarialVectors = JSON.parse(
-  fs.readFileSync(path.resolve(__dirname, "..", "vectors", "adversarial-vectors.json"), "utf8")
-);
-const nativeAtomVectors = JSON.parse(
-  fs.readFileSync(path.resolve(__dirname, "..", "vectors", "native-atom-vectors.json"), "utf8")
-);
+const nv = require("../lib/native_verify");
+const external = require("../lib/external_proof_verify");
+
+const ROOT = path.resolve(__dirname, "..");
+const ENGINE_FILE = path.join(ROOT, "proof_sdk.js");
+const REQUIRED_NATIVE_METHODS = Object.freeze([
+  "xoonya-native-sha256-v1",
+  "xoonya-native-signed-v1",
+  "xoonya-native-anchored-v1"
+]);
+
+function loadVectors(name) {
+  return JSON.parse(fs.readFileSync(path.join(ROOT, "vectors", name), "utf8"));
+}
+
+const conformanceVectors = loadVectors("conformance-vectors.json");
+const adversarialVectors = loadVectors("adversarial-vectors.json");
+const nativeAtomVectors = loadVectors("native-atom-vectors.json");
+const nativePayloadProfileVectors = loadVectors("native-payload-profile-vectors.json");
 
 function unique(values) {
   return Array.from(new Set(values.filter(Boolean))).sort();
 }
 
-function runVectorVerification() {
-  assert.strictEqual(conformanceVectors.version, "proof-conformance-v1", "conformance vector version mismatch");
-  assert.strictEqual(adversarialVectors.version, "proof-adversarial-v1", "adversarial vector version mismatch");
-  assert.strictEqual(nativeAtomVectors.version, "xoonya-native-atom-vectors-v1", "native atom vector version mismatch");
+function clone(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+function flipLastChar(text) {
+  const value = String(text || "");
+  if (!value) return "A";
+  const last = value[value.length - 1];
+  return `${value.slice(0, -1)}${last === "A" ? "B" : "A"}`;
+}
 
-  const conformanceResults = [];
+function conformanceBundle(vector) {
+  return {
+    version: vector.expected.proof_bundle_version,
+    ceb: nv.canonicalizeEvent(vector.event),
+    receipt: vector.expected.receipt,
+    anchors: Array.isArray(vector.anchors) ? vector.anchors : undefined
+  };
+}
+
+function atomOptions(vector, defaults) {
+  const hasPayload = vector.payload_ascii
+    ? true
+    : vector.payload_hash_sha256 && vector.payload_hash_sha256 !== "00".repeat(32);
+  return {
+    identity_material_hex: vector.identity_material_hex || defaults.identity_material_hex,
+    ...(hasPayload ? { payload_bytes: Buffer.from(vector.payload_ascii || defaults.payload_ascii, "utf8") } : {})
+  };
+}
+
+// Option variants every conformance bundle is verified under (standalone and, in
+// parity mode, engine). Trust-root variants must reject signed/hybrid proofs whose
+// key is not the declared one and leave digest/structural results untouched.
+function verificationOptionVariants(receipt) {
+  return [
+    {},
+    { strict: true },
+    { expected_public_key_ref: "ed25519-spki-sha256:" + "00".repeat(32) },
+    { trusted_public_key_refs: { [receipt.agent_identity]: { classical: "none", pq: "none" } } }
+  ];
+}
+
+function verifyConformance() {
+  const results = [];
+  let strictModeChecks = 0;
   for (const vector of conformanceVectors.vectors) {
-    const eventCommitment = sdk.hashEvent(vector.event);
-    assert.strictEqual(eventCommitment, vector.expected.event_commitment, `${vector.id} event commitment mismatch`);
+    assert.strictEqual(nv.hashEvent(vector.event), vector.expected.event_commitment, `${vector.id} event commitment mismatch`);
+    const bundle = conformanceBundle(vector);
+    const receipt = bundle.receipt;
+    assert.strictEqual(receipt.event_commitment, vector.expected.event_commitment, `${vector.id} receipt commitment mismatch`);
+    const verification = nv.verifyProofBundle(bundle);
+    assert.strictEqual(verification.valid, true, `${vector.id} proof bundle should verify (${verification.reason})`);
+    assert.strictEqual(verification.verification_method, receipt.algorithm, `${vector.id} verification method mismatch`);
+    assert.strictEqual(verification.receipt_id, receipt.receipt_id, `${vector.id} receipt id mismatch`);
 
-    const receipt = sdk.emitReceipt(vector.event, vector.receipt_options || {});
-    if (vector.expected.receipt.algorithm === "xoonya-native-hybrid-v1") {
-      assert.strictEqual(receipt.version, vector.expected.receipt.version, `${vector.id} hybrid receipt version mismatch`);
-      assert.strictEqual(receipt.receipt_id, vector.expected.receipt.receipt_id, `${vector.id} hybrid receipt id mismatch`);
-      assert.strictEqual(receipt.agent_identity, vector.expected.receipt.agent_identity, `${vector.id} hybrid agent mismatch`);
-      assert.strictEqual(receipt.domain_id, vector.expected.receipt.domain_id, `${vector.id} hybrid domain mismatch`);
-      assert.strictEqual(receipt.sequence, vector.expected.receipt.sequence, `${vector.id} hybrid sequence mismatch`);
-      assert.strictEqual(receipt.event_commitment, vector.expected.receipt.event_commitment, `${vector.id} hybrid event commitment mismatch`);
-      assert.strictEqual(receipt.algorithm, vector.expected.receipt.algorithm, `${vector.id} hybrid algorithm mismatch`);
-      assert.strictEqual(receipt.native_proof.method, vector.expected.receipt.native_proof.method, `${vector.id} hybrid method mismatch`);
-      assert.strictEqual(receipt.native_proof.hybrid_suite, vector.expected.receipt.native_proof.hybrid_suite, `${vector.id} hybrid suite mismatch`);
-      assert.strictEqual(receipt.native_proof.identity_ref, vector.expected.receipt.native_proof.identity_ref, `${vector.id} hybrid identity ref mismatch`);
-      assert.strictEqual(receipt.native_proof.hybrid_public_key_ref, vector.expected.receipt.native_proof.hybrid_public_key_ref, `${vector.id} hybrid public key ref mismatch`);
-      assert.strictEqual(receipt.native_proof.classical_public_key_ref, vector.expected.receipt.native_proof.classical_public_key_ref, `${vector.id} hybrid classical key ref mismatch`);
-      assert.strictEqual(receipt.native_proof.pq_public_key_ref, vector.expected.receipt.native_proof.pq_public_key_ref, `${vector.id} hybrid pq key ref mismatch`);
-      assert.deepStrictEqual(receipt.native_proof.classical_public_key_material, vector.expected.receipt.native_proof.classical_public_key_material, `${vector.id} hybrid classical key material mismatch`);
-      assert.deepStrictEqual(receipt.native_proof.pq_public_key_material, vector.expected.receipt.native_proof.pq_public_key_material, `${vector.id} hybrid pq key material mismatch`);
-      assert.strictEqual(receipt.native_proof.proof_material.signing_material_sha256, vector.expected.receipt.native_proof.proof_material.signing_material_sha256, `${vector.id} hybrid signing material hash mismatch`);
-      assert.strictEqual(typeof receipt.native_proof.proof_material.classical_signature, "string", `${vector.id} hybrid classical signature missing`);
-      assert.strictEqual(receipt.native_proof.proof_material.classical_signature.length > 10, true, `${vector.id} hybrid classical signature too small`);
-      assert.strictEqual(typeof receipt.native_proof.proof_material.pq_signature, "string", `${vector.id} hybrid pq signature missing`);
-      assert.strictEqual(receipt.native_proof.proof_material.pq_signature.length > 100, true, `${vector.id} hybrid pq signature too small`);
-      assert.strictEqual(
-        receipt.signature,
-        `xoonya-native-hybrid-v1:${receipt.native_proof.hybrid_suite}:${receipt.native_proof.proof_material.classical_signature}.${receipt.native_proof.proof_material.pq_signature}`,
-        `${vector.id} hybrid compact signature mismatch`
-      );
+    const strict = nv.verifyProofBundle(bundle, { strict: true });
+    if (verification.cryptographically_verified) {
+      assert.strictEqual(strict.valid, true, `${vector.id} cryptographic method must pass strict mode`);
     } else {
-      assert.deepStrictEqual(receipt, vector.expected.receipt, `${vector.id} receipt mismatch`);
+      assert.strictEqual(strict.valid, false, `${vector.id} non-cryptographic method must fail strict mode`);
+      assert.strictEqual(nv.PROOF_VERIFICATION_STRICT_REJECTION_CODES.includes(strict.reason), true, `${vector.id} strict rejection code mismatch`);
     }
+    strictModeChecks += 1;
 
-    const bundle = sdk.buildProofBundle({
-      ceb: vector.event,
-      receipt,
-      anchors: Array.isArray(vector.anchors) ? vector.anchors : undefined
-    });
-    assert.strictEqual(bundle.version, vector.expected.proof_bundle_version, `${vector.id} proof bundle version mismatch`);
-    const verification = sdk.verifyProofBundle(bundle);
-    assert.strictEqual(verification.valid, true, `${vector.id} proof bundle should verify`);
-    conformanceResults.push({
+    const untrusted = nv.verifyProofBundle(bundle, { expected_public_key_ref: "ed25519-spki-sha256:" + "00".repeat(32) });
+    if (verification.cryptographically_verified) {
+      assert.strictEqual(untrusted.valid, false, `${vector.id} undeclared key must be rejected under a trust root`);
+      assert.strictEqual(nv.PROOF_VERIFICATION_TRUST_ROOT_REJECTION_CODES.includes(untrusted.reason), true, `${vector.id} trust root rejection code mismatch`);
+    } else {
+      assert.strictEqual(untrusted.valid, true, `${vector.id} trust root must not affect non-keyed methods`);
+    }
+
+    results.push({
       id: vector.id,
       verification_method: verification.verification_method,
-      verification_state: verification.verification_state
+      verification_state: verification.verification_state,
+      verification_class: verification.verification_class,
+      cryptographically_verified: verification.cryptographically_verified
     });
   }
+  return { results, strictModeChecks };
+}
 
-  const adversarialResults = [];
+function verifyAdversarial() {
+  const results = [];
   for (const vector of adversarialVectors.vectors) {
     if (vector.kind === "canonicalize_event_error") {
       assert.throws(
-        () => sdk.canonicalizeEvent(vector.event),
+        () => nv.canonicalizeEvent(vector.event),
         (error) => error && error.message === vector.expected_reason,
         `${vector.id} should throw expected reason`
       );
-      adversarialResults.push({
-        id: vector.id,
-        kind: vector.kind,
-        reason: vector.expected_reason
-      });
+      results.push({ id: vector.id, kind: vector.kind, reason: vector.expected_reason });
       continue;
     }
     if (vector.kind === "verify_bundle_reason") {
-      const result = sdk.verifyProofBundle(vector.bundle);
+      const result = nv.verifyProofBundle(vector.bundle);
       assert.strictEqual(result.valid, false, `${vector.id} should fail`);
       assert.strictEqual(result.reason, vector.expected_reason, `${vector.id} failure reason mismatch`);
-      adversarialResults.push({
-        id: vector.id,
-        kind: vector.kind,
-        reason: result.reason
-      });
+      results.push({ id: vector.id, kind: vector.kind, reason: result.reason });
       continue;
     }
     throw new Error(`${vector.id} has unsupported vector kind`);
   }
+  return results;
+}
 
-  const nativeAtomResults = [];
-  const nativeAtomPayload = Buffer.from(nativeAtomVectors.payload_ascii, "utf8");
+function verifyNativeAtoms() {
+  const results = [];
   for (const vector of nativeAtomVectors.vectors) {
-    const parsed = sdk.parsexoonyaNativeAtom(vector.atom_hex);
+    const parsed = nv.parsexoonyaNativeAtom(vector.atom_hex);
     assert.strictEqual(parsed.atom_version, vector.atom_version, `${vector.id} atom version mismatch`);
     assert.strictEqual(parsed.byte_length, vector.byte_length, `${vector.id} byte length mismatch`);
     assert.strictEqual(parsed.agent_id, vector.agent_id, `${vector.id} agent id mismatch`);
     assert.strictEqual(parsed.payload_hash_sha256, vector.payload_hash_sha256, `${vector.id} payload hash mismatch`);
-    const hasPayload = vector.payload_hash_sha256 !== "00".repeat(32);
-    const verification = sdk.verifyxoonyaNativeAtom(vector.atom_hex, {
-      identity_material_hex: nativeAtomVectors.identity_material_hex,
-      ...(hasPayload ? { payload_bytes: nativeAtomPayload } : {})
-    });
+    const verification = nv.verifyxoonyaNativeAtom(vector.atom_hex, atomOptions(vector, nativeAtomVectors));
     assert.strictEqual(verification.valid, true, `${vector.id} should verify`);
     assert.strictEqual(verification.error_code, null, `${vector.id} should not have error code`);
-    nativeAtomResults.push({
-      id: vector.id,
-      atom_version: vector.atom_version,
-      byte_length: vector.byte_length
-    });
+    results.push({ id: vector.id, atom_version: vector.atom_version, byte_length: vector.byte_length });
   }
-
-  const nativeAtomAdversarialResults = [];
+  const adversarial = [];
   for (const vector of nativeAtomVectors.adversarial) {
-    const verification = sdk.verifyxoonyaNativeAtom(vector.atom_hex, {
-      identity_material_hex: vector.identity_material_hex || nativeAtomVectors.identity_material_hex,
-      ...(vector.payload_ascii ? { payload_bytes: Buffer.from(vector.payload_ascii, "utf8") } : {})
-    });
+    const verification = nv.verifyxoonyaNativeAtom(vector.atom_hex, atomOptions(vector, nativeAtomVectors));
     assert.strictEqual(verification.valid, false, `${vector.id} should fail`);
     assert.strictEqual(verification.reason, vector.expected_reason, `${vector.id} failure reason mismatch`);
     assert.strictEqual(verification.error_code, vector.expected_error_code, `${vector.id} error code mismatch`);
-    nativeAtomAdversarialResults.push({
-      id: vector.id,
-      reason: verification.reason,
-      error_code: verification.error_code
+    adversarial.push({ id: vector.id, reason: verification.reason, error_code: verification.error_code });
+  }
+  return { results, adversarial };
+}
+
+function verifyPayloadProfileAndFrame() {
+  const profileVector = nativePayloadProfileVectors.profile_vector;
+  const parsed = nv.parsexoonyaNativePayloadProfileV1(profileVector.expected.canonical_bytes_hex);
+  assert.strictEqual(parsed.payload_hash_sha256, profileVector.expected.payload_hash_sha256, `${profileVector.id} payload hash mismatch`);
+  assert.strictEqual(parsed.schema_hash_sha256, profileVector.expected.schema_hash_sha256, `${profileVector.id} schema hash mismatch`);
+  assert.deepStrictEqual(parsed.fields.map((field) => field.field_id), profileVector.expected.field_order, `${profileVector.id} field order mismatch`);
+  const profileVerification = nv.verifyxoonyaNativePayloadProfileV1(profileVector.expected.canonical_bytes_hex, {
+    payload_hash_sha256: profileVector.expected.payload_hash_sha256,
+    schema_ref: profileVector.input.schema_ref,
+    allowed_field_ids: profileVector.expected.field_order
+  });
+  assert.strictEqual(profileVerification.valid, true, `${profileVector.id} should verify`);
+  const unknownField = nv.verifyxoonyaNativePayloadProfileV1(profileVector.expected.canonical_bytes_hex, {
+    allowed_field_ids: profileVector.expected.field_order.slice(0, -1)
+  });
+  assert.strictEqual(unknownField.reason, "payload_profile_unknown_field", `${profileVector.id} unknown field policy mismatch`);
+
+  const frameVector = nativePayloadProfileVectors.line_rate_frame_vector;
+  const payloadBytes = Buffer.from(profileVector.expected.canonical_bytes_hex, "hex");
+  const frameVerification = nv.verifyxoonyaNativeLineRateFrameV1(frameVector.frame_hex, {
+    identity_material_hex: frameVector.identity_material_hex,
+    payload_bytes: payloadBytes
+  });
+  assert.strictEqual(frameVerification.valid, true, `${frameVector.id} should verify (${frameVerification.reason})`);
+  assert.strictEqual(frameVerification.parsed_frame.atom_hex, frameVector.atom_hex, `${frameVector.id} atom mismatch`);
+  assert.strictEqual(frameVerification.parsed_frame.checksum_hex, frameVector.checksum_hex, `${frameVector.id} checksum mismatch`);
+  assert.strictEqual(frameVerification.parsed_frame.frame_byte_length, frameVector.frame_byte_length, `${frameVector.id} frame length mismatch`);
+  const tamperedFrame = `${frameVector.frame_hex.slice(0, -1)}${frameVector.frame_hex.endsWith("0") ? "1" : "0"}`;
+  const tamperedVerification = nv.verifyxoonyaNativeLineRateFrameV1(tamperedFrame, {
+    identity_material_hex: frameVector.identity_material_hex,
+    payload_bytes: payloadBytes
+  });
+  assert.strictEqual(tamperedVerification.reason, "line_rate_frame_checksum_mismatch", `${frameVector.id} tamper reason mismatch`);
+  return {
+    profile_results: [{ id: profileVector.id, field_count: parsed.field_count }],
+    frame_results: [{ id: frameVector.id, frame_byte_length: frameVector.frame_byte_length }]
+  };
+}
+
+// Self-test of the detached-signature verifier with throwaway keys: Ed25519 and
+// ML-DSA-65 (FIPS 204) signatures must verify, a flipped signature must not, and a
+// declared trusted-key fingerprint must bind.
+function verifyExternalSignatureSelfTest() {
+  const material = Buffer.from("xoonya-verifier-external-signature-self-test", "utf8");
+  const checks = {};
+  for (const [alg, keyType] of [["EdDSA", "ed25519"], ["ML-DSA-65", "ml-dsa-65"]]) {
+    const pair = crypto.generateKeyPairSync(keyType);
+    const signature = crypto.sign(null, material, pair.privateKey).toString("base64");
+    const publicKeyPem = pair.publicKey.export({ type: "spki", format: "pem" });
+    const ok = external.verifyDetachedSignature({ material, signature, public_key: publicKeyPem, algorithm: alg });
+    assert.strictEqual(ok.signature_valid, true, `${alg} detached signature should verify`);
+    assert.strictEqual(ok.expected_key_match, null, `${alg} no expectation declared`);
+    const anchored = external.verifyDetachedSignature({ material, signature, public_key: publicKeyPem, algorithm: alg, expected_key_ref: ok.signing_key_ref });
+    assert.strictEqual(anchored.trust_anchored, true, `${alg} declared key must anchor`);
+    const wrongKey = external.verifyDetachedSignature({ material, signature, public_key: publicKeyPem, algorithm: alg, expected_key_ref: "nope" });
+    assert.strictEqual(wrongKey.trust_anchored, false, `${alg} wrong declared key must not anchor`);
+    const tampered = external.verifyDetachedSignature({ material: Buffer.concat([material, Buffer.from("x")]), signature, public_key: publicKeyPem, algorithm: alg });
+    assert.strictEqual(tampered.signature_valid, false, `${alg} tampered material must fail`);
+    const privateRefused = external.toPublicKeyObject(pair.privateKey.export({ type: "pkcs8", format: "pem" }));
+    assert.strictEqual(privateRefused, null, `${alg} private key material must be refused`);
+    checks[alg] = true;
+  }
+  return checks;
+}
+
+// Engine-parity cross-check (source checkout only).
+function runEngineParity() {
+  // eslint-disable-next-line global-require
+  const engine = require(ENGINE_FILE);
+  let comparisons = 0;
+  const compare = (label, standalone, fromEngine) => {
+    assert.deepStrictEqual(standalone, fromEngine, `engine parity mismatch: ${label}`);
+    comparisons += 1;
+  };
+
+  for (const vector of conformanceVectors.vectors) {
+    const bundle = conformanceBundle(vector);
+    compare(`${vector.id} hashEvent`, nv.hashEvent(vector.event), engine.hashEvent(vector.event));
+    compare(`${vector.id} canonicalizeEvent`, nv.canonicalizeEvent(vector.event), engine.canonicalizeEvent(vector.event));
+    for (const options of verificationOptionVariants(bundle.receipt)) {
+      compare(`${vector.id} ${JSON.stringify(options)}`, nv.verifyProofBundle(bundle, options), engine.verifyProofBundle(bundle, options));
+    }
+
+    // Freshly emitted by the engine (new ML-DSA randomness for hybrid), verified by both.
+    const fresh = engine.buildProofBundle({
+      ceb: vector.event,
+      receipt_options: vector.receipt_options || {},
+      anchors: Array.isArray(vector.anchors) ? vector.anchors : undefined
     });
+    const freshStandalone = nv.verifyProofBundle(fresh);
+    assert.strictEqual(freshStandalone.valid, true, `${vector.id} engine-emitted bundle must verify standalone (${freshStandalone.reason})`);
+    compare(`${vector.id} fresh engine bundle`, freshStandalone, engine.verifyProofBundle(fresh));
+    if (vector.expected.receipt.algorithm === "xoonya-native-hybrid-v1") {
+      const strip = (receipt) => {
+        const copy = clone(receipt);
+        delete copy.signature;
+        delete copy.native_proof.proof_material.classical_signature;
+        delete copy.native_proof.proof_material.pq_signature;
+        return copy;
+      };
+      compare(`${vector.id} fresh hybrid receipt (minus randomized signatures)`, strip(fresh.receipt), strip(vector.expected.receipt));
+    } else {
+      compare(`${vector.id} fresh receipt equals vector receipt`, fresh.receipt, vector.expected.receipt);
+    }
+
+    // Mutations: both verifiers must reject identically.
+    const mutations = {
+      signature_flipped: (b) => { b.receipt.signature = flipLastChar(b.receipt.signature); },
+      sequence_replayed: (b) => { b.receipt.sequence = `${b.receipt.sequence}0`; },
+      algorithm_none: (b) => { b.receipt.algorithm = "none"; },
+      algorithm_unknown: (b) => { b.receipt.algorithm = "not-a-method"; },
+      agent_identity_swapped: (b) => { b.receipt.agent_identity = `${b.receipt.agent_identity}-other`; },
+      event_hash_swapped: (b) => { b.ceb.event_hash = "ff".repeat(32); },
+      native_proof_dropped: (b) => { delete b.receipt.native_proof; },
+      anchors_dropped: (b) => { delete b.anchors; },
+      downgrade_to_digest: (b) => { b.receipt.algorithm = "xoonya-native-sha256-v1"; },
+      bundle_version_bad: (b) => { b.version = "proof-bundle/v0"; }
+    };
+    for (const [name, mutate] of Object.entries(mutations)) {
+      const mutated = clone(bundle);
+      mutate(mutated);
+      compare(`${vector.id} mutation ${name}`, nv.verifyProofBundle(mutated), engine.verifyProofBundle(mutated));
+    }
+  }
+
+  for (const vector of adversarialVectors.vectors) {
+    if (vector.kind === "canonicalize_event_error") {
+      let standaloneMessage = null;
+      let engineMessage = null;
+      try { nv.canonicalizeEvent(vector.event); } catch (error) { standaloneMessage = error.message; }
+      try { engine.canonicalizeEvent(vector.event); } catch (error) { engineMessage = error.message; }
+      compare(`${vector.id} canonicalize error`, standaloneMessage, engineMessage);
+      continue;
+    }
+    for (const options of verificationOptionVariants(vector.bundle.receipt || {})) {
+      compare(`${vector.id} ${JSON.stringify(options)}`, nv.verifyProofBundle(vector.bundle, options), engine.verifyProofBundle(vector.bundle, options));
+    }
+  }
+
+  for (const vector of [...nativeAtomVectors.vectors, ...nativeAtomVectors.adversarial]) {
+    const options = atomOptions(vector, nativeAtomVectors);
+    compare(`${vector.id} atom verify`, nv.verifyxoonyaNativeAtom(vector.atom_hex, options), engine.verifyxoonyaNativeAtom(vector.atom_hex, options));
+    let standaloneParsed;
+    let engineParsed;
+    try { standaloneParsed = nv.parsexoonyaNativeAtom(vector.atom_hex); } catch (error) { standaloneParsed = { error: error.message, code: error.code }; }
+    try { engineParsed = engine.parsexoonyaNativeAtom(vector.atom_hex); } catch (error) { engineParsed = { error: error.message, code: error.code }; }
+    compare(`${vector.id} atom parse`, standaloneParsed, engineParsed);
+  }
+
+  const profileHex = nativePayloadProfileVectors.profile_vector.expected.canonical_bytes_hex;
+  compare("payload profile parse", nv.parsexoonyaNativePayloadProfileV1(profileHex), engine.parsexoonyaNativePayloadProfileV1(profileHex));
+  const frameVector = nativePayloadProfileVectors.line_rate_frame_vector;
+  const frameOptions = { identity_material_hex: frameVector.identity_material_hex, payload_bytes: Buffer.from(profileHex, "hex") };
+  compare("line-rate frame verify", nv.verifyxoonyaNativeLineRateFrameV1(frameVector.frame_hex, frameOptions), engine.verifyxoonyaNativeLineRateFrameV1(frameVector.frame_hex, frameOptions));
+
+  // Compatibility receipt verifiers share bytes with the legacy-opreturn vector.
+  const legacy = conformanceVectors.vectors.find((vector) => vector.expected.receipt.algorithm === "legacy-opreturn-v1");
+  if (legacy) {
+    const opreturnHex = legacy.expected.receipt.compatibility.legacy_receipt.opreturn_hex;
+    const payload = Buffer.from(nv.canonicalize(nv.canonicalizeEvent(legacy.event)), "utf8");
+    compare("legacy receipt verify", nv.verifyReceipt(opreturnHex, payload), engine.verifyReceipt(opreturnHex, payload));
+    compare("legacy receipt parse", nv.parseReceipt(opreturnHex), engine.parseReceipt(opreturnHex));
+  }
+
+  compare("verification method registry", nv.listProofVerificationMethods(), engine.listProofVerificationMethods());
+  compare("verification class registry", nv.listProofVerificationClasses(), engine.listProofVerificationClasses());
+  compare("native signature suite registry", nv.listNativeSignatureSuites(), engine.listNativeSignatureSuites());
+  compare("native identity type registry", nv.listxoonyaNativeIdentityTypes(), engine.listxoonyaNativeIdentityTypes());
+
+  return { checked: true, engine_file: path.basename(ENGINE_FILE), comparisons };
+}
+
+function runVectorVerification(options = {}) {
+  assert.strictEqual(conformanceVectors.version, "proof-conformance-v1", "conformance vector version mismatch");
+  assert.strictEqual(adversarialVectors.version, "proof-adversarial-v1", "adversarial vector version mismatch");
+  assert.strictEqual(nativeAtomVectors.version, "xoonya-native-atom-vectors-v1", "native atom vector version mismatch");
+  assert.strictEqual(nativePayloadProfileVectors.version, "xoonya-native-payload-profile-vectors-v1", "native payload profile vector version mismatch");
+
+  const conformance = verifyConformance();
+  const adversarialResults = verifyAdversarial();
+  const atoms = verifyNativeAtoms();
+  const profileAndFrame = verifyPayloadProfileAndFrame();
+  const externalSignatureChecks = verifyExternalSignatureSelfTest();
+
+  const verificationMethods = unique(conformance.results.map((result) => result.verification_method));
+  for (const method of REQUIRED_NATIVE_METHODS) {
+    assert.strictEqual(verificationMethods.includes(method), true, `required native method missing: ${method}`);
+  }
+
+  const enginePresent = fs.existsSync(ENGINE_FILE);
+  let engineParity;
+  if (options.engine_parity === false) {
+    engineParity = { checked: false, reason: "disabled" };
+  } else if (enginePresent) {
+    engineParity = runEngineParity();
+  } else {
+    engineParity = { checked: false, reason: "engine_not_present" };
+  }
+  if (options.require_engine_parity === true) {
+    assert.strictEqual(engineParity.checked, true, "engine parity check required but not run");
   }
 
   return {
     ok: true,
     product: "xoonya",
+    role: "verifier",
     suite: "proof-conformance-and-adversarial-vectors",
     conformance_version: conformanceVectors.version,
     adversarial_version: adversarialVectors.version,
-    conformance_count: conformanceResults.length,
+    native_atom_version: nativeAtomVectors.version,
+    native_payload_profile_version: nativePayloadProfileVectors.version,
+    conformance_count: conformance.results.length,
     adversarial_count: adversarialResults.length,
-    native_atom_vector_count: nativeAtomResults.length,
-    native_atom_adversarial_count: nativeAtomAdversarialResults.length,
-    verification_methods: unique(conformanceResults.map((result) => result.verification_method)),
+    native_atom_vector_count: atoms.results.length,
+    native_atom_adversarial_count: atoms.adversarial.length,
+    native_payload_profile_vector_count: profileAndFrame.profile_results.length,
+    line_rate_frame_vector_count: profileAndFrame.frame_results.length,
+    strict_mode_checks: conformance.strictModeChecks,
+    verification_methods: verificationMethods,
+    required_native_methods_present: REQUIRED_NATIVE_METHODS.every((method) => verificationMethods.includes(method)),
     adversarial_reasons: unique(adversarialResults.map((result) => result.reason)),
-    native_atom_error_codes: unique(nativeAtomAdversarialResults.map((result) => result.error_code)),
-    conformance_results: conformanceResults,
+    native_atom_error_codes: unique(atoms.adversarial.map((result) => result.error_code)),
+    external_signature_checks: externalSignatureChecks,
+    engine_parity: engineParity,
+    conformance_results: conformance.results,
     adversarial_results: adversarialResults,
-    native_atom_results: nativeAtomResults,
-    native_atom_adversarial_results: nativeAtomAdversarialResults
+    native_atom_results: atoms.results,
+    native_atom_adversarial_results: atoms.adversarial
   };
 }
 
 function main() {
-  const json = process.argv.includes("--json");
-  const summary = runVectorVerification();
+  const argv = process.argv.slice(2);
+  const json = argv.includes("--json");
+  const summary = runVectorVerification({
+    engine_parity: argv.includes("--no-engine-parity") ? false : undefined,
+    require_engine_parity: argv.includes("--require-engine-parity")
+  });
   if (json) {
     process.stdout.write(`${JSON.stringify(summary, null, 2)}\n`);
     return;
@@ -176,9 +418,13 @@ function main() {
       `adversarial vectors: ${summary.adversarial_count}`,
       `native atom vectors: ${summary.native_atom_vector_count}`,
       `native atom adversarial vectors: ${summary.native_atom_adversarial_count}`,
+      `native payload profile vectors: ${summary.native_payload_profile_vector_count}`,
+      `line-rate frame vectors: ${summary.line_rate_frame_vector_count}`,
       `verification methods: ${summary.verification_methods.join(", ")}`,
       `adversarial reasons: ${summary.adversarial_reasons.join(", ")}`,
-      `native atom error codes: ${summary.native_atom_error_codes.join(", ")}`
+      `native atom error codes: ${summary.native_atom_error_codes.join(", ")}`,
+      `external signature checks: ${Object.keys(summary.external_signature_checks).join(", ")}`,
+      `engine parity: ${summary.engine_parity.checked ? `${summary.engine_parity.comparisons} comparisons identical` : summary.engine_parity.reason}`
     ].join("\n") + "\n"
   );
 }
@@ -188,5 +434,6 @@ if (require.main === module) {
 }
 
 module.exports = {
-  runVectorVerification
+  runVectorVerification,
+  REQUIRED_NATIVE_METHODS
 };

package/verify.js

@@ -0,0 +1,95 @@
+"use strict";
+
+// xoonya verifier package entry.
+//
+// This package verifies xoonya proofs and naxytra delivery evidence. It carries
+// the verifier only: the proof engine (receipt emission, signing, review,
+// governance, bridges) and the server are a hosted service and are not
+// distributed. Everything here runs on Node built-ins.
+
+const nativeVerify = require("./lib/native_verify");
+const externalProofVerify = require("./lib/external_proof_verify");
+const packageJson = require("./package.json");
+
+const endpoints = Object.freeze({
+  hosted_service: "https://xoonya.onrender.com",
+  website: "https://www.naxytra.com",
+  product: "https://www.naxytra.com/xoonya",
+  agents: "https://www.naxytra.com/agents",
+  first_run_kit: "https://www.naxytra.com/v1/first-run-kit"
+});
+
+function normalizeString(value) {
+  return String(value == null ? "" : value).trim();
+}
+
+// Verify an external (non-native) signature: a compact JWS, or a detached
+// signature over supplied material. Mirrors the hosted service's
+// proof.verify-signature lane. Reports what can be established from the request
+// alone (signature_valid under signing_key_ref); trust in that key is yours to
+// declare through expected_key_ref.
+function verifyExternalProofSignature(input) {
+  const body = input && typeof input === "object" && !Array.isArray(input) ? input : {};
+  const sv = body.signature_verification && typeof body.signature_verification === "object" ? body.signature_verification : body;
+  const jws = normalizeString(sv.jws || sv.compact_jws);
+  if (jws) {
+    return {
+      ok: true,
+      product: "xoonya",
+      category: "xoonya-external-proof-signature-verification",
+      method: "jws",
+      ...externalProofVerify.verifyJws(jws, {
+        trusted_public_key: sv.trusted_public_key || sv.public_key || null,
+        expected_key_ref: sv.expected_key_ref
+      })
+    };
+  }
+  if (sv.signature) {
+    return {
+      ok: true,
+      product: "xoonya",
+      category: "xoonya-external-proof-signature-verification",
+      method: "detached",
+      ...externalProofVerify.verifyDetachedSignature({
+        material: sv.material !== undefined ? sv.material : body.material,
+        signature: sv.signature,
+        signature_encoding: sv.signature_encoding,
+        public_key: sv.public_key || sv.trusted_public_key,
+        algorithm: sv.algorithm,
+        expected_key_ref: sv.expected_key_ref
+      })
+    };
+  }
+  return {
+    ok: false,
+    product: "xoonya",
+    category: "xoonya-external-proof-signature-verification",
+    reason: "no_signature_verification_input"
+  };
+}
+
+// Run the shipped conformance + adversarial vectors through this verifier and
+// return the summary (ok, counts, verification_methods, ...).
+function verifyVectors(options) {
+  // eslint-disable-next-line global-require
+  return require("./scripts/verify_vectors").runVectorVerification(options || {});
+}
+
+module.exports = {
+  name: packageJson.name,
+  version: packageJson.version,
+  role: "verifier",
+  endpoints,
+
+  // Native proof bundles, receipts, atoms, payload profiles, line-rate frames.
+  ...nativeVerify,
+
+  // External signatures (compact JWS and detached; Ed25519, ECDSA, RSA, ML-DSA-44/65/87).
+  verifyJws: externalProofVerify.verifyJws,
+  verifyDetachedSignature: externalProofVerify.verifyDetachedSignature,
+  verifyExternalProofSignature,
+  toPublicKeyObject: externalProofVerify.toPublicKeyObject,
+  looksLikeCompactJws: externalProofVerify.looksLikeCompactJws,
+
+  verifyVectors
+};

package/.env.example

@@ -1,10 +0,0 @@
-XOONYA_HOST=127.0.0.1
-XOONYA_PORT=4310
-# Set to 1 to make every proof-bundle verification strict: only cryptographically verified
-# (native signed / native hybrid) results are valid; digest and structural results are rejected.
-# XOONYA_STRICT_VERIFY=1
-# Whether POST /v1/receipts/emit, /v1/proof-bundles/build, and the proof-center run routes may
-# receive private key material (private_key_pem, classical_private_key_pem, pq_private_key_pem).
-# Unset = accepted locally, rejected when RENDER is set. Set to false on any shared deployment
-# and sign locally with the xoonya SDK or CLI instead.
-# XOONYA_ACCEPT_PRIVATE_KEY_MATERIAL=false