xoonya 2.10.0 → 2.12.0

package/scripts/verify_all.js

@@ -383,21 +383,21 @@ function verifyProofBundleConformance() {
 function verifyNativeAtomConformance() {
   ensure(nativeAtomVectors.version === "xoonya-native-atom-vectors-v1", "native atom vector version mismatch");
   const payloadBytes = Buffer.from(nativeAtomVectors.payload_ascii, "utf8");
-  const generatedV1 = sdk.createXoonyaNativeAtomV1(nativeAtomVectors.identity_material_hex, payloadBytes);
+  const generatedV1 = sdk.createxoonyaNativeAtomV1(nativeAtomVectors.identity_material_hex, payloadBytes);
   const expectedV1 = nativeAtomVectors.vectors.find((vector) => vector.id === "xnya-v1-with-payload");
   ensure(generatedV1.atom_hex === expectedV1.atom_hex, "native atom v1 payload vector mismatch");
-  const generatedV2 = sdk.createXoonyaNativeAtomV2(nativeAtomVectors.identity_material_hex, payloadBytes);
+  const generatedV2 = sdk.createxoonyaNativeAtomV2(nativeAtomVectors.identity_material_hex, payloadBytes);
   const expectedV2 = nativeAtomVectors.vectors.find((vector) => vector.id === "xnya-v2-with-payload");
   ensure(generatedV2.atom_hex === expectedV2.atom_hex, "native atom v2 payload vector mismatch");
 
   for (const vector of nativeAtomVectors.vectors) {
-    const parsed = sdk.parseXoonyaNativeAtom(vector.atom_hex);
+    const parsed = sdk.parsexoonyaNativeAtom(vector.atom_hex);
     ensure(parsed.atom_version === vector.atom_version, `${vector.id} atom version mismatch`);
     ensure(parsed.byte_length === vector.byte_length, `${vector.id} byte length mismatch`);
     ensure(parsed.agent_id === vector.agent_id, `${vector.id} agent id mismatch`);
     ensure(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, {
+    const verification = sdk.verifyxoonyaNativeAtom(vector.atom_hex, {
       identity_material_hex: nativeAtomVectors.identity_material_hex,
       ...(hasPayload ? { payload_bytes: payloadBytes } : {})
     });
@@ -406,7 +406,7 @@ function verifyNativeAtomConformance() {
   }
 
   for (const vector of nativeAtomVectors.adversarial) {
-    const verification = sdk.verifyXoonyaNativeAtom(vector.atom_hex, {
+    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") } : {})
     });
@@ -420,56 +420,56 @@ function verifyNativeAtomConformance() {
 
 function verifyNativePayloadProfileConformance() {
   ensure(nativePayloadProfileVectors.version === "xoonya-native-payload-profile-vectors-v1", "native payload profile vector version mismatch");
-  ensure(typeof sdk.encodeXoonyaNativePayloadProfileV1 === "function", "missing encodeXoonyaNativePayloadProfileV1");
-  ensure(typeof sdk.parseXoonyaNativePayloadProfileV1 === "function", "missing parseXoonyaNativePayloadProfileV1");
-  ensure(typeof sdk.verifyXoonyaNativePayloadProfileV1 === "function", "missing verifyXoonyaNativePayloadProfileV1");
-  ensure(typeof sdk.createXoonyaNativeLineRateFrameV1 === "function", "missing createXoonyaNativeLineRateFrameV1");
-  ensure(typeof sdk.parseXoonyaNativeLineRateFrameV1 === "function", "missing parseXoonyaNativeLineRateFrameV1");
-  ensure(typeof sdk.verifyXoonyaNativeLineRateFrameV1 === "function", "missing verifyXoonyaNativeLineRateFrameV1");
+  ensure(typeof sdk.encodexoonyaNativePayloadProfileV1 === "function", "missing encodexoonyaNativePayloadProfileV1");
+  ensure(typeof sdk.parsexoonyaNativePayloadProfileV1 === "function", "missing parsexoonyaNativePayloadProfileV1");
+  ensure(typeof sdk.verifyxoonyaNativePayloadProfileV1 === "function", "missing verifyxoonyaNativePayloadProfileV1");
+  ensure(typeof sdk.createxoonyaNativeLineRateFrameV1 === "function", "missing createxoonyaNativeLineRateFrameV1");
+  ensure(typeof sdk.parsexoonyaNativeLineRateFrameV1 === "function", "missing parsexoonyaNativeLineRateFrameV1");
+  ensure(typeof sdk.verifyxoonyaNativeLineRateFrameV1 === "function", "missing verifyxoonyaNativeLineRateFrameV1");
 
   const vector = nativePayloadProfileVectors.profile_vector;
-  const profile = sdk.encodeXoonyaNativePayloadProfileV1(vector.input);
+  const profile = sdk.encodexoonyaNativePayloadProfileV1(vector.input);
   ensure(profile.profile === "xoonya-native-payload-profile/v1", "native payload profile id mismatch");
   ensure(profile.canonical_bytes_hex.startsWith(Buffer.from("XNYP", "ascii").toString("hex")), "native payload profile magic mismatch");
   ensure(profile.field_count === 4, "native payload profile field count mismatch");
   ensure(profile.canonical_bytes_hex === vector.expected.canonical_bytes_hex, "native payload profile canonical vector mismatch");
   ensure(profile.payload_hash_sha256 === vector.expected.payload_hash_sha256, "native payload profile payload hash vector mismatch");
   ensure(profile.schema_hash_sha256 === vector.expected.schema_hash_sha256, "native payload profile schema hash vector mismatch");
-  const parsedProfile = sdk.parseXoonyaNativePayloadProfileV1(profile.canonical_bytes_hex);
+  const parsedProfile = sdk.parsexoonyaNativePayloadProfileV1(profile.canonical_bytes_hex);
   ensure(parsedProfile.payload_hash_sha256 === profile.payload_hash_sha256, "native payload profile hash mismatch");
   ensure(parsedProfile.fields.map((field) => field.field_id).join(",") === "1,2,3,4", "native payload profile canonical ordering mismatch");
   ensure(parsedProfile.fields.find((field) => field.field_id === 2).value === "42", "native payload profile uint64 decode mismatch");
   ensure(parsedProfile.fields.find((field) => field.field_id === 4).value === true, "native payload profile bool decode mismatch");
-  const profileVerification = sdk.verifyXoonyaNativePayloadProfileV1(profile.canonical_bytes_hex, {
+  const profileVerification = sdk.verifyxoonyaNativePayloadProfileV1(profile.canonical_bytes_hex, {
     payload_hash_sha256: profile.payload_hash_sha256,
     schema_ref: "xoonya.payload.test.v1",
     allowed_field_ids: [1, 2, 3, 4]
   });
   ensure(profileVerification.valid === true, "native payload profile verification should pass");
-  const unknownFieldPolicy = sdk.verifyXoonyaNativePayloadProfileV1(profile.canonical_bytes_hex, {
+  const unknownFieldPolicy = sdk.verifyxoonyaNativePayloadProfileV1(profile.canonical_bytes_hex, {
     allowed_field_ids: [1, 2, 3]
   });
   ensure(unknownFieldPolicy.valid === false, "native payload profile policy should reject unknown field ids");
   ensure(unknownFieldPolicy.reason === "payload_profile_unknown_field", "native payload profile unknown field reason mismatch");
 
-  const atom = sdk.createXoonyaNativeAtomV1(
+  const atom = sdk.createxoonyaNativeAtomV1(
     "01" + "11".repeat(33),
     Buffer.from(profile.canonical_bytes_hex, "hex")
   );
-  const frame = sdk.createXoonyaNativeLineRateFrameV1(atom.atom_hex);
+  const frame = sdk.createxoonyaNativeLineRateFrameV1(atom.atom_hex);
   const frameVector = nativePayloadProfileVectors.line_rate_frame_vector;
   ensure(frame.profile === "xoonya-native-line-rate-frame/v1", "line-rate frame profile mismatch");
   ensure(frame.frame_byte_length === 60, "line-rate frame v1 size mismatch");
   ensure(atom.atom_hex === frameVector.atom_hex, "line-rate frame atom vector mismatch");
   ensure(frame.frame_hex === frameVector.frame_hex, "line-rate frame vector mismatch");
   ensure(frame.checksum_hex === frameVector.checksum_hex, "line-rate frame checksum vector mismatch");
-  const frameVerification = sdk.verifyXoonyaNativeLineRateFrameV1(frame.frame_hex, {
+  const frameVerification = sdk.verifyxoonyaNativeLineRateFrameV1(frame.frame_hex, {
     identity_material_hex: "01" + "11".repeat(33),
     payload_bytes: Buffer.from(profile.canonical_bytes_hex, "hex")
   });
   ensure(frameVerification.valid === true, "line-rate frame should verify");
   const tamperedFrameHex = `${frame.frame_hex.slice(0, -1)}${frame.frame_hex.endsWith("0") ? "1" : "0"}`;
-  const tamperedFrameVerification = sdk.verifyXoonyaNativeLineRateFrameV1(tamperedFrameHex, {
+  const tamperedFrameVerification = sdk.verifyxoonyaNativeLineRateFrameV1(tamperedFrameHex, {
     identity_material_hex: "01" + "11".repeat(33),
     payload_bytes: Buffer.from(profile.canonical_bytes_hex, "hex")
   });
@@ -516,33 +516,33 @@ function main() {
   ensure(typeof sdk.getProofVerificationMethod === "function", "missing getProofVerificationMethod");
   ensure(typeof sdk.listNativeSignatureSuites === "function", "missing listNativeSignatureSuites");
   ensure(typeof sdk.getNativeSignatureSuite === "function", "missing getNativeSignatureSuite");
-  ensure(typeof sdk.listXoonyaNativeIdentityTypes === "function", "missing listXoonyaNativeIdentityTypes");
-  ensure(typeof sdk.buildXoonyaNativeAtomSpec === "function", "missing buildXoonyaNativeAtomSpec");
-  ensure(typeof sdk.buildXoonyaNativeAtomConformancePack === "function", "missing buildXoonyaNativeAtomConformancePack");
-  ensure(typeof sdk.summarizeXoonyaNativeAtomConformancePack === "function", "missing summarizeXoonyaNativeAtomConformancePack");
-  ensure(typeof sdk.createXoonyaNativeAtomV1 === "function", "missing createXoonyaNativeAtomV1");
-  ensure(typeof sdk.createXoonyaNativeAtomV2 === "function", "missing createXoonyaNativeAtomV2");
-  ensure(typeof sdk.parseXoonyaNativeAtom === "function", "missing parseXoonyaNativeAtom");
-  ensure(typeof sdk.verifyXoonyaNativeAtom === "function", "missing verifyXoonyaNativeAtom");
+  ensure(typeof sdk.listxoonyaNativeIdentityTypes === "function", "missing listxoonyaNativeIdentityTypes");
+  ensure(typeof sdk.buildxoonyaNativeAtomSpec === "function", "missing buildxoonyaNativeAtomSpec");
+  ensure(typeof sdk.buildxoonyaNativeAtomConformancePack === "function", "missing buildxoonyaNativeAtomConformancePack");
+  ensure(typeof sdk.summarizexoonyaNativeAtomConformancePack === "function", "missing summarizexoonyaNativeAtomConformancePack");
+  ensure(typeof sdk.createxoonyaNativeAtomV1 === "function", "missing createxoonyaNativeAtomV1");
+  ensure(typeof sdk.createxoonyaNativeAtomV2 === "function", "missing createxoonyaNativeAtomV2");
+  ensure(typeof sdk.parsexoonyaNativeAtom === "function", "missing parsexoonyaNativeAtom");
+  ensure(typeof sdk.verifyxoonyaNativeAtom === "function", "missing verifyxoonyaNativeAtom");
   ensure(typeof sdk.buildNativeReceiptSignature === "function", "missing buildNativeReceiptSignature");
   ensure(typeof sdk.buildNativeSignedReceiptProof === "function", "missing buildNativeSignedReceiptProof");
   ensure(typeof sdk.buildNativeAnchoredReceiptProof === "function", "missing buildNativeAnchoredReceiptProof");
-  ensure(typeof sdk.buildXoonyaNativeAnchorProfile === "function", "missing buildXoonyaNativeAnchorProfile");
-  ensure(typeof sdk.summarizeXoonyaNativeAnchorProfile === "function", "missing summarizeXoonyaNativeAnchorProfile");
+  ensure(typeof sdk.buildxoonyaNativeAnchorProfile === "function", "missing buildxoonyaNativeAnchorProfile");
+  ensure(typeof sdk.summarizexoonyaNativeAnchorProfile === "function", "missing summarizexoonyaNativeAnchorProfile");
   ensure(typeof sdk.buildExternalProofImportAdapterPack === "function", "missing buildExternalProofImportAdapterPack");
   ensure(typeof sdk.summarizeExternalProofImportAdapterPack === "function", "missing summarizeExternalProofImportAdapterPack");
-  ensure(typeof sdk.buildXoonyaNativeHybridReadinessPack === "function", "missing buildXoonyaNativeHybridReadinessPack");
-  ensure(typeof sdk.summarizeXoonyaNativeHybridReadinessPack === "function", "missing summarizeXoonyaNativeHybridReadinessPack");
-  ensure(typeof sdk.buildXoonyaNativeStandardizationPack === "function", "missing buildXoonyaNativeStandardizationPack");
-  ensure(typeof sdk.summarizeXoonyaNativeStandardizationPack === "function", "missing summarizeXoonyaNativeStandardizationPack");
-  ensure(typeof sdk.buildXoonyaNativeConformanceMarkPack === "function", "missing buildXoonyaNativeConformanceMarkPack");
-  ensure(typeof sdk.summarizeXoonyaNativeConformanceMarkPack === "function", "missing summarizeXoonyaNativeConformanceMarkPack");
-  ensure(typeof sdk.buildXoonyaNativeReferenceImplementationPack === "function", "missing buildXoonyaNativeReferenceImplementationPack");
-  ensure(typeof sdk.summarizeXoonyaNativeReferenceImplementationPack === "function", "missing summarizeXoonyaNativeReferenceImplementationPack");
-  ensure(typeof sdk.buildXoonyaNativePayloadProfilePack === "function", "missing buildXoonyaNativePayloadProfilePack");
-  ensure(typeof sdk.summarizeXoonyaNativePayloadProfilePack === "function", "missing summarizeXoonyaNativePayloadProfilePack");
-  ensure(typeof sdk.buildXoonyaNativeLineRateFramePack === "function", "missing buildXoonyaNativeLineRateFramePack");
-  ensure(typeof sdk.summarizeXoonyaNativeLineRateFramePack === "function", "missing summarizeXoonyaNativeLineRateFramePack");
+  ensure(typeof sdk.buildxoonyaNativeHybridReadinessPack === "function", "missing buildxoonyaNativeHybridReadinessPack");
+  ensure(typeof sdk.summarizexoonyaNativeHybridReadinessPack === "function", "missing summarizexoonyaNativeHybridReadinessPack");
+  ensure(typeof sdk.buildxoonyaNativeStandardizationPack === "function", "missing buildxoonyaNativeStandardizationPack");
+  ensure(typeof sdk.summarizexoonyaNativeStandardizationPack === "function", "missing summarizexoonyaNativeStandardizationPack");
+  ensure(typeof sdk.buildxoonyaNativeConformanceMarkPack === "function", "missing buildxoonyaNativeConformanceMarkPack");
+  ensure(typeof sdk.summarizexoonyaNativeConformanceMarkPack === "function", "missing summarizexoonyaNativeConformanceMarkPack");
+  ensure(typeof sdk.buildxoonyaNativeReferenceImplementationPack === "function", "missing buildxoonyaNativeReferenceImplementationPack");
+  ensure(typeof sdk.summarizexoonyaNativeReferenceImplementationPack === "function", "missing summarizexoonyaNativeReferenceImplementationPack");
+  ensure(typeof sdk.buildxoonyaNativePayloadProfilePack === "function", "missing buildxoonyaNativePayloadProfilePack");
+  ensure(typeof sdk.summarizexoonyaNativePayloadProfilePack === "function", "missing summarizexoonyaNativePayloadProfilePack");
+  ensure(typeof sdk.buildxoonyaNativeLineRateFramePack === "function", "missing buildxoonyaNativeLineRateFramePack");
+  ensure(typeof sdk.summarizexoonyaNativeLineRateFramePack === "function", "missing summarizexoonyaNativeLineRateFramePack");
   ensure(typeof sdk.reviewExternalProofImport === "function", "missing reviewExternalProofImport");
   ensure(typeof sdk.runExternalProofImport === "function", "missing runExternalProofImport");
   ensure(typeof sdk.buildProofBundle === "function", "missing buildProofBundle");
@@ -566,18 +566,18 @@ function main() {
   ensure(typeof sdk.verifyRegistryProfileV1 === "function", "missing verifyRegistryProfileV1");
   ensure(fs.existsSync(path.resolve(__dirname, "..", "integrations", "registration-record.schema.json")), "missing integration registration schema");
   ensure(fs.existsSync(path.resolve(__dirname, "..", "integrations", "registry-snapshot.schema.json")), "missing integration registry snapshot schema");
-  const hybridReadiness = sdk.summarizeXoonyaNativeHybridReadinessPack();
+  const hybridReadiness = sdk.summarizexoonyaNativeHybridReadinessPack();
   ensure(hybridReadiness.status === "design_gated", "native hybrid readiness must stay design gated");
   ensure(hybridReadiness.implemented_classical_suites.includes("secp256k1"), "native hybrid readiness secp256k1 suite missing");
   ensure(hybridReadiness.implemented_classical_suites.includes("p256"), "native hybrid readiness p256 suite missing");
-  const standardization = sdk.summarizeXoonyaNativeStandardizationPack();
+  const standardization = sdk.summarizexoonyaNativeStandardizationPack();
   ensure(standardization.canonical_magic === "XNYA", "native standardization magic mismatch");
   ensure(standardization.conformance_forbidden_condition_count >= 4, "native standardization forbidden conditions missing");
-  const conformanceMark = sdk.summarizeXoonyaNativeConformanceMarkPack();
+  const conformanceMark = sdk.summarizexoonyaNativeConformanceMarkPack();
   ensure(conformanceMark.mark === "XNYA-compatible", "native conformance mark mismatch");
   ensure(conformanceMark.forbidden_claim_count >= 3, "native conformance mark forbidden claims missing");
   ensure(conformanceMark.implemented_signature_suites.includes("secp256k1"), "native conformance mark secp256k1 suite missing");
-  const referenceImplementations = sdk.summarizeXoonyaNativeReferenceImplementationPack();
+  const referenceImplementations = sdk.summarizexoonyaNativeReferenceImplementationPack();
   ensure(referenceImplementations.status === "js_reference_implemented_independent_references_planned", "native reference implementation status mismatch");
   ensure(referenceImplementations.implemented_reference_count === 1, "native reference implementation count mismatch");
   ensure(referenceImplementations.planned_reference_count >= 2, "native planned reference implementation count mismatch");

package/scripts/verify_native_hybrid_design_gate.js

@@ -28,7 +28,7 @@ function buildHybridAttemptBundle() {
 }
 
 function runNativeHybridDesignGateVerification() {
-  const readiness = sdk.summarizeXoonyaNativeHybridReadinessPack();
+  const readiness = sdk.summarizexoonyaNativeHybridReadinessPack();
   assert.strictEqual(readiness.status, "design_gated", "hybrid readiness must stay design gated");
   assert.strictEqual(
     readiness.current_decision.includes("do_not_claim_pqc"),

package/scripts/verify_reference_promotion_gate.js

@@ -2,9 +2,9 @@
 
 const assert = require("assert");
 const {
-  buildXoonyaNativeReferenceImplementationPack,
-  summarizeXoonyaNativeReferenceImplementationPack,
-  validateXoonyaNativeReferencePromotionEvidence
+  buildxoonyaNativeReferenceImplementationPack,
+  summarizexoonyaNativeReferenceImplementationPack,
+  validatexoonyaNativeReferencePromotionEvidence
 } = require("../proof_sdk");
 
 function buildValidPromotionEvidence(pack, language = "python") {
@@ -23,7 +23,7 @@ function buildValidPromotionEvidence(pack, language = "python") {
 }
 
 function assertRejected(pack, evidence, expectedCode) {
-  const validation = validateXoonyaNativeReferencePromotionEvidence(pack, evidence);
+  const validation = validatexoonyaNativeReferencePromotionEvidence(pack, evidence);
   assert.strictEqual(validation.promotion_allowed, false, `expected ${expectedCode} to block reference promotion`);
   assert.strictEqual(
     validation.rejection_codes.includes(expectedCode),
@@ -34,10 +34,10 @@ function assertRejected(pack, evidence, expectedCode) {
 }
 
 function main() {
-  const pack = buildXoonyaNativeReferenceImplementationPack();
-  const summary = summarizeXoonyaNativeReferenceImplementationPack();
+  const pack = buildxoonyaNativeReferenceImplementationPack();
+  const summary = summarizexoonyaNativeReferenceImplementationPack();
   const validPythonEvidence = buildValidPromotionEvidence(pack, "python");
-  const validPythonPromotion = validateXoonyaNativeReferencePromotionEvidence(pack, validPythonEvidence);
+  const validPythonPromotion = validatexoonyaNativeReferencePromotionEvidence(pack, validPythonEvidence);
 
   assert.strictEqual(pack.category, "xoonya-native-reference-implementation-pack", "native reference pack category mismatch");
   assert.strictEqual(summary.category, "xoonya-native-reference-implementation-summary", "native reference summary category mismatch");

package/scripts/verify_release_candidate.js

@@ -18,12 +18,10 @@ function parsePackDryRun() {
 function verifyReleaseNotes() {
   const notesPath = path.resolve(__dirname, "..", "RELEASE_NOTES.md");
   const notes = fs.readFileSync(notesPath, "utf8");
-  const headings = (notes.match(/^#\s+xoonya\s+\d+\.\d+\.\d+\s+Release Notes\s*$/gm) || [])
-    .map((heading) => heading.trim());
-  assert.deepStrictEqual(
-    headings,
-    [`# xoonya ${packageJson.version} Release Notes`],
-    "RELEASE_NOTES.md must contain only the current xoonya release heading"
+  assert.strictEqual(
+    /^#\s+xoonya\s+\d+\.\d+\.\d+\s+Release Notes\s*$/m.test(notes),
+    false,
+    "RELEASE_NOTES.md must not duplicate the GitHub release title as a heading"
   );
   assert.strictEqual(
     notes.includes(`xoonya\` ${packageJson.version}`),
@@ -102,6 +100,7 @@ function main() {
   assert.strictEqual(dryRun.files.some((entry) => entry.path === "scripts/verify_reference_promotion_gate.js"), true, "npm pack dry-run missing reference promotion gate verifier script");
   assert.strictEqual(dryRun.files.some((entry) => entry.path === "scripts/verify_reference_rust_scaffold.js"), true, "npm pack dry-run missing Rust reference scaffold verifier script");
   assert.strictEqual(dryRun.files.some((entry) => entry.path === "scripts/verify_native_hybrid_design_gate.js"), true, "npm pack dry-run missing native hybrid design-gate verifier script");
+  assert.strictEqual(dryRun.files.some((entry) => entry.path === "scripts/verify_verification_services.js"), true, "npm pack dry-run missing verification services verifier script");
   assert.strictEqual(dryRun.files.some((entry) => entry.path === "scripts/verify_all.js"), true, "npm pack dry-run missing package verifier script");
   assert.strictEqual(dryRun.files.some((entry) => entry.path === "vectors/conformance-vectors.json"), true, "npm pack dry-run missing conformance vectors");
   assert.strictEqual(dryRun.files.some((entry) => entry.path === "vectors/adversarial-vectors.json"), true, "npm pack dry-run missing adversarial vectors");

package/scripts/verify_service.js

@@ -105,6 +105,22 @@ async function main() {
     assert.strictEqual(identityInteropSummaryResponse.json.product, 'xoonya', 'identity interop summary product missing');
     assert.strictEqual(identityInteropSummaryResponse.json.profile_count >= 4, true, 'identity interop summary count missing');
 
+    const trustPortabilityResponse = await getJson(baseUrl, '/v1/proof-center/trust-portability');
+    assert.strictEqual(trustPortabilityResponse.status, 200, 'trust portability route failed');
+    assert.strictEqual(trustPortabilityResponse.json.product, 'xoonya', 'trust portability product missing');
+    assert.strictEqual(trustPortabilityResponse.json.category, 'xoonya-trust-portability-pack', 'trust portability category missing');
+    assert.strictEqual(Array.isArray(trustPortabilityResponse.json.portability_profiles), true, 'trust portability profiles missing');
+    assert.strictEqual(trustPortabilityResponse.json.portability_profiles.length >= 4, true, 'trust portability profile count missing');
+
+    const trustPortabilitySummaryResponse = await getJson(baseUrl, '/v1/proof-center/trust-portability/summary');
+    assert.strictEqual(trustPortabilitySummaryResponse.status, 200, 'trust portability summary route failed');
+    assert.strictEqual(trustPortabilitySummaryResponse.json.product, 'xoonya', 'trust portability summary product missing');
+    assert.strictEqual(trustPortabilitySummaryResponse.json.profile_count >= 4, true, 'trust portability summary profile count missing');
+
+    const trustPortabilityDetailResponse = await getJson(baseUrl, '/v1/proof-center/trust-portability/agent_identity_portability');
+    assert.strictEqual(trustPortabilityDetailResponse.status, 200, 'trust portability detail route failed');
+    assert.strictEqual(trustPortabilityDetailResponse.json.profile.profile_id, 'agent_identity_portability', 'trust portability detail profile missing');
+
     const providerLaneResponse = await getJson(baseUrl, '/v1/providers');
     assert.strictEqual(providerLaneResponse.status, 200, 'provider lane route failed');
     assert.strictEqual(providerLaneResponse.json.product, 'xoonya', 'provider lane product missing');
@@ -191,6 +207,16 @@ async function main() {
     assert.strictEqual(proofBridgeLaneSummaryResponse.json.product, 'xoonya', 'proof bridge lane summary product missing');
     assert.strictEqual(proofBridgeLaneSummaryResponse.json.first_run_flow_count >= 2, true, 'proof bridge lane summary flow count missing');
 
+    const verificationServicesResponse = await getJson(baseUrl, '/v1/proof-center/verification-services');
+    assert.strictEqual(verificationServicesResponse.status, 200, 'verification services route failed');
+    assert.strictEqual(verificationServicesResponse.json.category, 'xoonya-verification-services-pack', 'verification services category missing');
+    assert.strictEqual(verificationServicesResponse.json.service_count >= 6, true, 'verification services count missing');
+
+    const verificationServicesSummaryResponse = await getJson(baseUrl, '/v1/proof-center/verification-services/summary');
+    assert.strictEqual(verificationServicesSummaryResponse.status, 200, 'verification services summary route failed');
+    assert.strictEqual(verificationServicesSummaryResponse.json.category, 'xoonya-verification-services-summary', 'verification services summary category missing');
+    assert.strictEqual(verificationServicesSummaryResponse.json.service_count >= 6, true, 'verification services summary count missing');
+
     const externalProofImportResponse = await getJson(baseUrl, '/v1/external-proof-import');
     assert.strictEqual(externalProofImportResponse.status, 200, 'external proof import lane route failed');
     assert.strictEqual(externalProofImportResponse.json.product, 'xoonya', 'external proof import lane product missing');

package/scripts/verify_trust_portability.js

@@ -0,0 +1,56 @@
+"use strict";
+
+const assert = require("assert");
+const { createServer } = require("../server.js");
+
+async function getJson(baseUrl, path) {
+  const response = await fetch(`${baseUrl}${path}`);
+  return {
+    status: response.status,
+    json: await response.json()
+  };
+}
+
+async function main() {
+  const server = createServer();
+  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+  const address = server.address();
+  const baseUrl = `http://127.0.0.1:${address.port}`;
+
+  try {
+    const pack = await getJson(baseUrl, "/v1/proof-center/trust-portability");
+    assert.strictEqual(pack.status, 200, "trust portability route failed");
+    assert.strictEqual(pack.json.category, "xoonya-trust-portability-pack", "trust portability category mismatch");
+    assert.strictEqual(pack.json.portability_profiles.length >= 4, true, "trust portability profile count mismatch");
+    assert.strictEqual(
+      pack.json.portability_profiles.some((entry) => entry.profile_id === "agent_identity_portability" && entry.callable_surfaces.includes("/v1/identity-interop")),
+      true,
+      "agent identity portability profile missing identity-interop surface"
+    );
+    assert.strictEqual(
+      pack.json.portability_profiles.some((entry) => entry.profile_id === "delivery_history_portability" && entry.supporting_surfaces.includes("/v1/result-package-trust/summary")),
+      true,
+      "delivery history portability profile missing result-package-trust support"
+    );
+
+    const summary = await getJson(baseUrl, "/v1/proof-center/trust-portability/summary");
+    assert.strictEqual(summary.status, 200, "trust portability summary route failed");
+    assert.strictEqual(summary.json.profile_count >= 4, true, "trust portability summary profile count mismatch");
+    assert.strictEqual(summary.json.bounded_live_profile_count >= 4, true, "trust portability bounded-live count mismatch");
+    assert.strictEqual(summary.json.callable_profile_count >= 4, true, "trust portability callable profile count mismatch");
+
+    const detail = await getJson(baseUrl, "/v1/proof-center/trust-portability/agent_identity_portability");
+    assert.strictEqual(detail.status, 200, "trust portability detail route failed");
+    assert.strictEqual(detail.json.profile.profile_id, "agent_identity_portability", "trust portability detail profile mismatch");
+    assert.strictEqual(detail.json.profile.claim_status, "bounded_live", "trust portability detail claim status mismatch");
+  } finally {
+    await new Promise((resolve) => server.close(resolve));
+  }
+
+  console.log("xoonya verify:trust-portability passed");
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/scripts/verify_vectors.js

@@ -79,13 +79,13 @@ function runVectorVerification() {
   const nativeAtomResults = [];
   const nativeAtomPayload = Buffer.from(nativeAtomVectors.payload_ascii, "utf8");
   for (const vector of nativeAtomVectors.vectors) {
-    const parsed = sdk.parseXoonyaNativeAtom(vector.atom_hex);
+    const parsed = sdk.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, {
+    const verification = sdk.verifyxoonyaNativeAtom(vector.atom_hex, {
       identity_material_hex: nativeAtomVectors.identity_material_hex,
       ...(hasPayload ? { payload_bytes: nativeAtomPayload } : {})
     });
@@ -100,7 +100,7 @@ function runVectorVerification() {
 
   const nativeAtomAdversarialResults = [];
   for (const vector of nativeAtomVectors.adversarial) {
-    const verification = sdk.verifyXoonyaNativeAtom(vector.atom_hex, {
+    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") } : {})
     });

package/scripts/verify_verification_services.js

@@ -0,0 +1,56 @@
+"use strict";
+
+const assert = require("assert");
+const { createServer } = require("../server.js");
+
+async function getJson(baseUrl, path) {
+  const response = await fetch(`${baseUrl}${path}`);
+  return {
+    status: response.status,
+    json: await response.json()
+  };
+}
+
+async function main() {
+  const server = createServer();
+  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+  const address = server.address();
+  const baseUrl = `http://127.0.0.1:${address.port}`;
+
+  try {
+    const pack = await getJson(baseUrl, "/v1/proof-center/verification-services");
+    assert.strictEqual(pack.status, 200, "verification services route failed");
+    assert.strictEqual(pack.json.category, "xoonya-verification-services-pack", "verification services category mismatch");
+    assert.strictEqual(pack.json.service_count >= 6, true, "verification services count mismatch");
+    assert.strictEqual(
+      pack.json.verification_services.some((entry) => entry.service_id === "bundle_verify" && entry.callable_surfaces.includes("/v1/proof-bundles/verify")),
+      true,
+      "bundle verify service missing proof-bundles verify surface"
+    );
+    assert.strictEqual(
+      pack.json.verification_services.some((entry) => entry.service_id === "dispute_replay" && entry.callable_surfaces.includes("/v1/proof-center/governance/disputes/case-bundle")),
+      true,
+      "dispute replay service missing case bundle surface"
+    );
+    assert.strictEqual(
+      pack.json.verification_services.some((entry) => entry.service_id === "identity_link_verify" && entry.supporting_surfaces.includes("/v1/identity-interop/summary")),
+      true,
+      "identity-link verification service missing identity interop support"
+    );
+
+    const summary = await getJson(baseUrl, "/v1/proof-center/verification-services/summary");
+    assert.strictEqual(summary.status, 200, "verification services summary route failed");
+    assert.strictEqual(summary.json.service_count >= 6, true, "verification services summary count mismatch");
+    assert.strictEqual(summary.json.live_service_count >= 1, true, "verification services summary live count missing");
+    assert.strictEqual(summary.json.bounded_live_service_count >= 5, true, "verification services summary bounded-live count missing");
+  } finally {
+    await new Promise((resolve) => server.close(resolve));
+  }
+
+  console.log("xoonya verify:verification-services passed");
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});