xoonya 2.7.0 → 2.9.0

package/proof_sdk.js

@@ -1056,6 +1056,9 @@ function verifyReceiptProofMethod(receipt, ceb, bundle) {
   if (algorithm === VERIFICATION_METHOD_NONE) {
     return { valid: false, reason: "verification_method_none" };
   }
+  if (algorithm === XOONYA_NATIVE_HYBRID_METHOD) {
+    return { valid: false, reason: "native_hybrid_design_gated" };
+  }
 
   const method = PROOF_VERIFICATION_METHODS[algorithm];
   if (!method) {
@@ -1135,7 +1138,8 @@ function verifyReceiptProofMethod(receipt, ceb, bundle) {
     if (
       signature.startsWith(`${XOONYA_NATIVE_SHA256_METHOD}:`) ||
       signature.startsWith(`${XOONYA_NATIVE_SIGNED_METHOD}:`) ||
-      signature.startsWith(`${XOONYA_NATIVE_ANCHORED_METHOD}:`)
+      signature.startsWith(`${XOONYA_NATIVE_ANCHORED_METHOD}:`) ||
+      signature.startsWith(`${XOONYA_NATIVE_HYBRID_METHOD}:`)
     ) {
       return { valid: false, reason: "signature_method_mismatch" };
     }
@@ -2046,6 +2050,20 @@ function normalizeExternalProofMaterial(value) {
   throw new Error("external_proof_material_required");
 }
 
+const EXTERNAL_PROOF_IMPORT_REJECTION_CODES = Object.freeze([
+  "verification_method_required",
+  "verification_method_unsupported",
+  "verification_method_not_external_importable",
+  "external_proof_material_required",
+  "external_proof_material_empty",
+  "external_proof_hash_mismatch",
+  "external_issuer_truth_claim_requires_external_verifier",
+  "external_signature_truth_claim_requires_external_verifier",
+  "external_revocation_status_claim_requires_external_verifier",
+  "did_resolution_truth_claim_requires_external_verifier",
+  "secret_material_forbidden"
+]);
+
 function pickExternalProofMaterial(body) {
   if (body.external_proof != null) return body.external_proof;
   if (body.external_envelope != null) return body.external_envelope;
@@ -2056,6 +2074,32 @@ function pickExternalProofMaterial(body) {
   return undefined;
 }
 
+function containsExternalImportSecretMaterial(value) {
+  if (!value || typeof value !== "object") return false;
+  const materialKeys = new Set([
+    "external_proof",
+    "external_envelope",
+    "proof_envelope",
+    "proof_material",
+    "token",
+    "compact"
+  ]);
+  const secretishKey = /(private[_-]?key|password|credential|authorization|access[_-]?token|api[_-]?key|secret)/i;
+  const secretishValue = /(bearer\s+[a-z0-9._-]{8,}|sk_live_|npm_[a-z0-9]|ghp_[a-z0-9]|xox[baprs]-)/i;
+  const stack = [value];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (!current || typeof current !== "object") continue;
+    for (const [key, entry] of Object.entries(current)) {
+      if (materialKeys.has(key)) continue;
+      if (secretishKey.test(String(key))) return true;
+      if (typeof entry === "string" && secretishValue.test(entry)) return true;
+      if (entry && typeof entry === "object") stack.push(entry);
+    }
+  }
+  return false;
+}
+
 function normalizeExternalProofImport(input) {
   const body = input && typeof input === "object" && !Array.isArray(input) ? input : {};
   const method = normalizeString(body.method || body.verification_method || body.proof_method);
@@ -2099,6 +2143,47 @@ function normalizeExternalProofImport(input) {
   };
 }
 
+function validateExternalProofImportEvidence(input) {
+  const body = input && typeof input === "object" && !Array.isArray(input) ? input : {};
+  const rejectionCodes = [];
+  let imported = null;
+  try {
+    imported = normalizeExternalProofImport(body);
+  } catch (error) {
+    const message = error && error.message ? error.message : "external_proof_material_required";
+    if (EXTERNAL_PROOF_IMPORT_REJECTION_CODES.includes(message)) {
+      rejectionCodes.push(message);
+    } else {
+      rejectionCodes.push("external_proof_material_required");
+    }
+  }
+
+  if (body.claim_external_issuer_truth === true && !normalizeString(body.external_issuer_verifier_ref)) {
+    rejectionCodes.push("external_issuer_truth_claim_requires_external_verifier");
+  }
+  if (body.claim_external_signature_truth === true && !normalizeString(body.external_signature_verifier_ref)) {
+    rejectionCodes.push("external_signature_truth_claim_requires_external_verifier");
+  }
+  if (body.claim_external_revocation_status === true && !normalizeString(body.external_revocation_verifier_ref)) {
+    rejectionCodes.push("external_revocation_status_claim_requires_external_verifier");
+  }
+  if (body.claim_did_resolution_truth === true && !normalizeString(body.did_resolution_verifier_ref)) {
+    rejectionCodes.push("did_resolution_truth_claim_requires_external_verifier");
+  }
+  if (containsExternalImportSecretMaterial(body)) {
+    rejectionCodes.push("secret_material_forbidden");
+  }
+
+  return {
+    validation_version: "xoonya-external-proof-import-evidence-validation-v1",
+    import_allowed: rejectionCodes.length === 0,
+    method: imported ? imported.method : normalizeString(body.method || body.verification_method || body.proof_method) || null,
+    rejection_codes: Array.from(new Set(rejectionCodes)),
+    deterministic_rejection_codes: EXTERNAL_PROOF_IMPORT_REJECTION_CODES.slice(),
+    boundary: "xoonya_import_validation_binds_external_evidence_without_claiming_external_issuer_signature_revocation_or_did_truth"
+  };
+}
+
 function buildExternalProofImportAdapterPack() {
   return {
     ok: true,
@@ -2129,6 +2214,17 @@ function buildExternalProofImportAdapterPack() {
       "policy_ref",
       "received_at_iso"
     ],
+    deterministic_rejection_codes: EXTERNAL_PROOF_IMPORT_REJECTION_CODES.slice(),
+    external_truth_claim_template: {
+      claim_external_issuer_truth: false,
+      claim_external_signature_truth: false,
+      claim_external_revocation_status: false,
+      claim_did_resolution_truth: false,
+      external_issuer_verifier_ref: "external.verifier.issuer.<optional>",
+      external_signature_verifier_ref: "external.verifier.signature.<optional>",
+      external_revocation_verifier_ref: "external.verifier.revocation.<optional>",
+      did_resolution_verifier_ref: "external.verifier.did_resolution.<optional>"
+    },
     output_artifacts: [
       "canonical_event",
       "receipt",
@@ -2176,6 +2272,7 @@ function summarizeExternalProofImportAdapterPack() {
     output_artifact_count: pack.output_artifacts.length,
     xoonya_verified_boundary_count: pack.verification_boundary.xoonya_verifies.length,
     external_verifier_boundary_count: pack.verification_boundary.external_verifier_retains.length,
+    deterministic_rejection_code_count: pack.deterministic_rejection_codes.length,
     linked_surfaces: pack.linked_surfaces
   };
 }
@@ -2769,6 +2866,7 @@ function buildXoonyaNativeHybridReadinessPack() {
     promotion_requirements: [
       "runtime_validator_available_without_experimental_flags",
       "positive_conformance_vectors",
+      "design_gate_adversarial_vector",
       "wrong_key_adversarial_vectors",
       "tampered_signature_adversarial_vectors",
       "downgrade_and_method_confusion_vectors",
@@ -2779,6 +2877,7 @@ function buildXoonyaNativeHybridReadinessPack() {
     hybrid_object_model_boundary: {
       atom_rule: "XNYA_atom_remains_commitment_only",
       envelope_rule: "hybrid_or_pqc_material_lives_in_proof_envelope_or_profile",
+      current_deterministic_reject_reason: "native_hybrid_design_gated",
       downgrade_rule: "hybrid_receipts_must_not_verify_as_classical_native_signed_receipts",
       claim_rule: "claim_candidate_or_design_gated_until_validators_and_vectors_are_real"
     },
@@ -2805,6 +2904,7 @@ function summarizeXoonyaNativeHybridReadinessPack() {
     implemented_classical_suites: pack.implemented_classical_suites.map((entry) => entry.suite),
     gated_candidate_suite_count: pack.gated_candidate_suites.length,
     promotion_requirement_count: pack.promotion_requirements.length,
+    deterministic_reject_reason: pack.hybrid_object_model_boundary.current_deterministic_reject_reason,
     current_decision: pack.current_decision,
     linked_surfaces: pack.linked_surfaces
   };
@@ -2956,16 +3056,19 @@ function buildXoonyaNativeStandardizationPack() {
     },
     standard_artifacts: [
       "XOONYA_NATIVE_PROOF_FORMAT.md",
+      "XNYA_CONFORMANCE_MARK.md",
       "vectors/native-atom-vectors.json",
       "vectors/native-payload-profile-vectors.json",
       "vectors/conformance-vectors.json",
       "vectors/adversarial-vectors.json",
       "proof_sdk.js reference validator",
+      "XNYA_REFERENCE_IMPLEMENTATIONS.md",
       "/v1/proof-center/native-standard",
       "/v1/proof-center/native-atom-conformance",
       "/v1/proof-center/native-hybrid-readiness",
       "/v1/proof-center/native-payload-profile",
-      "/v1/proof-center/native-line-rate-frame"
+      "/v1/proof-center/native-line-rate-frame",
+      "/v1/proof-center/native-reference-implementations"
     ],
     adoption_steps: [
       "keep_xoonya_package_as_reference_implementation",
@@ -2987,6 +3090,7 @@ function buildXoonyaNativeStandardizationPack() {
       native_hybrid_readiness_ref: "/v1/proof-center/native-hybrid-readiness",
       native_payload_profile_ref: "/v1/proof-center/native-payload-profile",
       native_line_rate_frame_ref: "/v1/proof-center/native-line-rate-frame",
+      native_reference_implementations_ref: "/v1/proof-center/native-reference-implementations/summary",
       import_adapter_ref: "/v1/proof-center/import-adapter"
     }
   };
@@ -3012,6 +3116,499 @@ function summarizeXoonyaNativeStandardizationPack() {
   };
 }
 
+const XNYA_REFERENCE_PROMOTION_REQUIREMENTS = Object.freeze([
+  "candidate_repository_or_packaged_reference",
+  "all_required_vector_sets_pass",
+  "matching_deterministic_error_codes",
+  "independent_parser_not_wrapping_javascript",
+  "native_signature_suite_crypto_parity",
+  "cross_language_round_trip",
+  "conformance_mark_review",
+  "forbidden_claim_review"
+]);
+
+const XNYA_REFERENCE_PROMOTION_REJECTION_CODES = Object.freeze([
+  "reference_language_not_registered",
+  "candidate_repository_missing",
+  "required_vector_set_missing",
+  "deterministic_error_code_parity_missing",
+  "independent_parser_evidence_missing",
+  "signature_crypto_parity_missing",
+  "round_trip_evidence_missing",
+  "conformance_mark_review_missing",
+  "forbidden_claim_review_missing",
+  "javascript_wrapper_forbidden",
+  "secret_material_forbidden"
+]);
+
+function normalizeReferencePromotionString(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function containsReferencePromotionSecretMaterial(value) {
+  if (!value || typeof value !== "object") return false;
+  const secretishKey = /(secret|token|credential|password|private[_-]?key|authorization)/i;
+  const secretishValue = /(bearer\s+[a-z0-9._-]{8,}|sk_live_|npm_[a-z0-9]|ghp_[a-z0-9]|xox[baprs]-)/i;
+  const stack = [value];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (!current || typeof current !== "object") continue;
+    for (const [key, entry] of Object.entries(current)) {
+      if (secretishKey.test(String(key))) return true;
+      if (typeof entry === "string" && secretishValue.test(entry)) return true;
+      if (entry && typeof entry === "object") stack.push(entry);
+    }
+  }
+  return false;
+}
+
+function buildXoonyaNativeReferenceImplementationPack() {
+  const conformanceMark = summarizeXoonyaNativeConformanceMarkPack();
+  const atomConformance = summarizeXoonyaNativeAtomConformancePack();
+  const payloadProfile = summarizeXoonyaNativePayloadProfilePack();
+  return {
+    ok: true,
+    product: "xoonya",
+    category: "xoonya-native-reference-implementation-pack",
+    pack_version: "xoonya-native-reference-implementation-pack-v1",
+    standard: XOONYA_NATIVE_PROOF_FORMAT_VERSION,
+    canonical_magic: XOONYA_NATIVE_ATOM_MAGIC_ASCII,
+    status: "js_reference_implemented_independent_references_planned",
+    posture: "javascript_package_is_canonical_reference_python_and_rust_require_vector_parity_before_claims",
+    repo_strategy: "ship_reference_inside_xoonya_package_until_external_adoption_pressure_justifies_split_repo",
+    conformance_mark: conformanceMark.mark,
+    implemented_reference_implementations: [
+      {
+        language: "javascript",
+        package: "xoonya",
+        status: "implemented",
+        role: "canonical_reference_implementation",
+        entrypoints: [
+          "proof_sdk.js",
+          "bin/xoonya.js",
+          "bin/xoonya-release.js",
+          "server.js"
+        ],
+        public_checks: [
+          "npm run verify:release-candidate",
+          "npm run verify:all",
+          "xoonya conformance --json",
+          "xoonya first-run --verify-native --pretty"
+        ]
+      }
+    ],
+    planned_reference_candidates: [
+      {
+        language: "python",
+        package_candidate: "xoonya-native-python",
+        status: "atom_payload_vector_parity_scaffold_implemented",
+        promotion_gate: "full_native_proof_round_trip_and_all_positive_adversarial_vectors_pass"
+      },
+      {
+        language: "rust",
+        package_candidate: "xoonya-native-rust",
+        status: "source_scaffold_packaged_vector_parity_not_verified",
+        promotion_gate: "independent_parser_and_verifier_pass_all_positive_and_adversarial_vectors"
+      }
+    ],
+    candidate_scaffolds: [
+      {
+        language: "python",
+        path: "reference/python",
+        status: "verified_atom_payload_frame_non_signed_proof_bundle_and_optional_ed25519_crypto_gate",
+        command: "npm run verify:reference-python",
+        optional_crypto_command: "npm run verify:reference-python-crypto",
+        optional_crypto_dependency_file: "reference/python/requirements-optional.txt",
+        covered_vector_sets: [
+          "vectors/native-atom-vectors.json",
+          "vectors/native-payload-profile-vectors.json",
+          "vectors/conformance-vectors.json",
+          "vectors/adversarial-vectors.json"
+        ],
+        covered_behaviors: [
+          "xnya_atom_v1_create_parse_verify",
+          "xnya_atom_v2_create_parse_verify",
+          "native_atom_adversarial_error_codes",
+          "xnyp_payload_profile_encode_parse",
+          "line_rate_frame_checksum",
+          "canonical_event_hash_parity",
+          "receipt_emission_for_external_native_digest_legacy_and_anchored_methods",
+          "proof_bundle_build_verify_for_non_signed_methods",
+          "proof_bundle_adversarial_reason_parity_for_non_signed_methods",
+          "ed25519_native_signed_verification_when_python_cryptography_dependency_exists",
+          "deterministic_native_signature_crypto_dependency_missing_gate"
+        ],
+        not_yet_claimed: [
+          "always_on_native_signature_suite_cryptographic_verification_without_optional_dependency",
+          "secp256k1_or_p256_python_signature_suite_verification",
+          "external_method_import_reference",
+          "cross_language_round_trip_for_all_native_signed_proof_bundles",
+          "XNYA-compatible_mark_for_python_package"
+        ]
+      },
+      {
+        language: "rust",
+        path: "reference/rust",
+        status: "source_scaffold_packaged_not_vector_verified",
+        command: "npm run verify:reference-rust-scaffold",
+        covered_vector_sets: [],
+        covered_behaviors: [
+          "source_packaging_guard",
+          "xnya_atom_constants_declared",
+          "deterministic_atom_parser_error_codes_declared",
+          "cargo_publish_false_boundary_declared"
+        ],
+        not_yet_claimed: [
+          "compiled_rust_toolchain_check",
+          "native_atom_vector_parity",
+          "native_payload_profile_vector_parity",
+          "canonical_event_or_proof_bundle_parity",
+          "signature_suite_cryptographic_verification",
+          "XNYA-compatible_mark_for_rust_package"
+        ]
+      }
+    ],
+    required_vector_sets: [
+      "vectors/conformance-vectors.json",
+      "vectors/adversarial-vectors.json",
+      "vectors/native-atom-vectors.json",
+      "vectors/native-payload-profile-vectors.json"
+    ],
+    required_artifacts: [
+      "XOONYA_NATIVE_PROOF_FORMAT.md",
+      "XOONYA_NATIVE_ATOM_SPEC.md",
+      "XOONYA_NATIVE_STANDARD_GOVERNANCE.md",
+      "XNYA_CONFORMANCE_MARK.md",
+      "XNYA_REFERENCE_IMPLEMENTATIONS.md"
+    ],
+    required_behaviors: [
+      "parse_XNYA_atoms_without_loose_json_or_string_reinterpretation",
+      "derive_identity_and_payload_hashes_with_exact_domain_separation",
+      "return_stable_error_codes_for_rejects",
+      "reject_algorithm_none_for_production_native_proofs",
+      "verify_ed25519_secp256k1_and_p256_only_when_suite_specific_validators_exist",
+      "treat_pq_hybrid_as_design_gated_until_validators_and_vectors_exist",
+      "bind_external_methods_without_claiming_external_issuer_truth",
+      "preserve_anchor_binding_boundary_without_claiming_external_finality_truth"
+    ],
+    independence_rules: [
+      "non_javascript_references_must_not_wrap_the_node_runtime",
+      "each_reference_must_implement_its_own_byte_parser",
+      "each_reference_must_emit_matching_deterministic_error_codes",
+      "each_reference_must_pass_positive_and_adversarial_vectors_before_public_compatibility_claims",
+      "reference_claims_must_link_to_the_exact_package_version_and vector set"
+    ],
+    promotion_gates: [
+      {
+        gate: "candidate_repository_created",
+        required_evidence: "public_repo_or_package_with_license_docs_and_test_runner"
+      },
+      {
+        gate: "vector_parity",
+        required_evidence: "all_required_vector_sets_pass_with_matching_error_codes"
+      },
+      {
+        gate: "interop_round_trip",
+        required_evidence: "candidate_generates_artifacts_verified_by_javascript_reference_and vice versa"
+      },
+      {
+        gate: "conformance_mark_allowed",
+        required_evidence: "candidate_satisfies_XNYA-compatible_mark_rules_without_forbidden_claims"
+      }
+    ],
+    promotion_requirements: XNYA_REFERENCE_PROMOTION_REQUIREMENTS.slice(),
+    deterministic_rejection_codes: XNYA_REFERENCE_PROMOTION_REJECTION_CODES.slice(),
+    promotion_evidence_template: {
+      language: "python",
+      candidate_repository_ref: "repo-or-package-ref",
+      vector_sets_passed: [
+        "vectors/conformance-vectors.json",
+        "vectors/adversarial-vectors.json",
+        "vectors/native-atom-vectors.json",
+        "vectors/native-payload-profile-vectors.json"
+      ],
+      deterministic_error_code_parity_ref: "xnya.reference.error_codes.<language>.<version>",
+      independent_parser_ref: "xnya.reference.parser.<language>.<version>",
+      signature_crypto_parity_ref: "xnya.reference.crypto.<language>.<version>",
+      round_trip_ref: "xnya.reference.round_trip.<language>.<version>",
+      conformance_mark_review_ref: "xnya.reference.conformance_mark.<language>.<version>",
+      forbidden_claim_review_ref: "xnya.reference.claim_boundary.<language>.<version>",
+      wraps_javascript_runtime: false
+    },
+    explicit_non_claims: [
+      "no_pq_or_hybrid_runtime_validation_claim",
+      "no_live_external_provider_claim",
+      "no_identity_auth_custody_transport_or_settlement_claim",
+      "no_python_or_rust_full_reference_claim_until_signature_suite_crypto_full_vector_parity_and_round_trip",
+      "no_rust_reference_claim_until_cargo_compilation_and_vector_parity_exist",
+      "no_external_issuer_or_chain_truth_claim_without_external_verifier_evidence"
+    ],
+    conformance_floor: {
+      native_atom_error_code_count: atomConformance.deterministic_error_code_count,
+      native_payload_field_type_count: payloadProfile.field_type_count,
+      conformance_mark_required_artifact_count: conformanceMark.required_artifact_count,
+      forbidden_claim_count: conformanceMark.forbidden_claim_count
+    },
+    linked_surfaces: {
+      native_standard_ref: "/v1/proof-center/native-standard",
+      native_standardization_ref: "/v1/proof-center/native-standardization",
+      native_reference_implementations_summary_ref: "/v1/proof-center/native-reference-implementations/summary",
+      native_conformance_mark_ref: "/v1/proof-center/native-conformance-mark",
+      native_atom_conformance_ref: "/v1/proof-center/native-atom-conformance",
+      native_payload_profile_ref: "/v1/proof-center/native-payload-profile"
+    },
+    boundary: "only_the_javascript_reference_is_full_implemented_today_python_has_atom_payload_frame_non_signed_proof_bundle_and_optional_ed25519_crypto_gate_scaffold_rust_is_source_scaffold_not_vector_verified"
+  };
+}
+
+function validateXoonyaNativeReferencePromotionEvidence(pack, evidence) {
+  const referencePack = pack || {};
+  const evidencePacket = evidence || {};
+  const language = normalizeReferencePromotionString(evidencePacket.language).toLowerCase();
+  const planned = Array.isArray(referencePack.planned_reference_candidates)
+    ? referencePack.planned_reference_candidates
+    : [];
+  const implemented = Array.isArray(referencePack.implemented_reference_implementations)
+    ? referencePack.implemented_reference_implementations
+    : [];
+  const candidate = planned.find((entry) => entry && entry.language === language) || null;
+  const alreadyImplemented = implemented.find((entry) => entry && entry.language === language) || null;
+  const requiredVectorSets = Array.isArray(referencePack.required_vector_sets) ? referencePack.required_vector_sets : [];
+  const vectorSetsPassed = Array.isArray(evidencePacket.vector_sets_passed) ? evidencePacket.vector_sets_passed : [];
+  const rejectionCodes = [];
+
+  if (!candidate || alreadyImplemented) rejectionCodes.push("reference_language_not_registered");
+  if (!normalizeReferencePromotionString(evidencePacket.candidate_repository_ref)) {
+    rejectionCodes.push("candidate_repository_missing");
+  }
+  if (!requiredVectorSets.every((entry) => vectorSetsPassed.includes(entry))) {
+    rejectionCodes.push("required_vector_set_missing");
+  }
+  if (!normalizeReferencePromotionString(evidencePacket.deterministic_error_code_parity_ref)) {
+    rejectionCodes.push("deterministic_error_code_parity_missing");
+  }
+  if (!normalizeReferencePromotionString(evidencePacket.independent_parser_ref)) {
+    rejectionCodes.push("independent_parser_evidence_missing");
+  }
+  if (!normalizeReferencePromotionString(evidencePacket.signature_crypto_parity_ref)) {
+    rejectionCodes.push("signature_crypto_parity_missing");
+  }
+  if (!normalizeReferencePromotionString(evidencePacket.round_trip_ref)) {
+    rejectionCodes.push("round_trip_evidence_missing");
+  }
+  if (!normalizeReferencePromotionString(evidencePacket.conformance_mark_review_ref)) {
+    rejectionCodes.push("conformance_mark_review_missing");
+  }
+  if (!normalizeReferencePromotionString(evidencePacket.forbidden_claim_review_ref)) {
+    rejectionCodes.push("forbidden_claim_review_missing");
+  }
+  if (evidencePacket.wraps_javascript_runtime === true) {
+    rejectionCodes.push("javascript_wrapper_forbidden");
+  }
+  if (containsReferencePromotionSecretMaterial(evidencePacket)) {
+    rejectionCodes.push("secret_material_forbidden");
+  }
+
+  return {
+    validation_version: "xoonya-native-reference-promotion-evidence-validation-v1",
+    promotion_allowed: rejectionCodes.length === 0,
+    language: language || null,
+    rejection_codes: Array.from(new Set(rejectionCodes)),
+    required_requirements: XNYA_REFERENCE_PROMOTION_REQUIREMENTS.slice(),
+    boundary: "native_reference_promotion_requires_independent_vector_crypto_round_trip_and_conformance_mark_evidence_without_secret_material"
+  };
+}
+
+function summarizeXoonyaNativeReferenceImplementationPack() {
+  const pack = buildXoonyaNativeReferenceImplementationPack();
+  return {
+    ok: true,
+    product: pack.product,
+    category: "xoonya-native-reference-implementation-summary",
+    summary_version: "xoonya-native-reference-implementation-summary-v1",
+    standard: pack.standard,
+    canonical_magic: pack.canonical_magic,
+    status: pack.status,
+    implemented_reference_count: pack.implemented_reference_implementations.length,
+    planned_reference_count: pack.planned_reference_candidates.length,
+    candidate_scaffold_count: pack.candidate_scaffolds.length,
+    verified_candidate_scaffold_count: pack.candidate_scaffolds.filter((entry) => entry.status.startsWith("verified_")).length,
+    required_vector_set_count: pack.required_vector_sets.length,
+    required_behavior_count: pack.required_behaviors.length,
+    promotion_gate_count: pack.promotion_gates.length,
+    deterministic_rejection_code_count: pack.deterministic_rejection_codes.length,
+    boundary: pack.boundary,
+    linked_surfaces: pack.linked_surfaces
+  };
+}
+
+function buildXoonyaNativeConformanceMarkPack() {
+  const standardization = buildXoonyaNativeStandardizationPack();
+  const atomConformance = summarizeXoonyaNativeAtomConformancePack();
+  const nativeStandard = summarizeXoonyaNativeProofStandard();
+  const hybridReadiness = summarizeXoonyaNativeHybridReadinessPack();
+  return {
+    ok: true,
+    product: "xoonya",
+    category: "xoonya-native-conformance-mark-pack",
+    pack_version: "xoonya-native-conformance-mark-pack-v1",
+    mark: "XNYA-compatible",
+    status: "active",
+    posture: "compatibility_mark_requires_exact_vectors_errors_and_claim_boundaries",
+    standard: standardization.standard,
+    canonical_magic: standardization.canonical_magic,
+    repo_strategy: standardization.repo_strategy,
+    required_spec_versions: [
+      "xoonya-native-proof/v1",
+      "xoonya-native-atom-spec/v1",
+      "xoonya-native-payload-profile/v1",
+      "xoonya-native-line-rate-frame/v1"
+    ],
+    required_artifacts: [
+      "XOONYA_NATIVE_PROOF_FORMAT.md",
+      "XOONYA_NATIVE_ATOM_SPEC.md",
+      "XOONYA_NATIVE_STANDARD_GOVERNANCE.md",
+      "XNYA_CONFORMANCE_MARK.md",
+      "vectors/conformance-vectors.json",
+      "vectors/adversarial-vectors.json",
+      "vectors/native-atom-vectors.json",
+      "vectors/native-payload-profile-vectors.json"
+    ],
+    required_cli_checks: [
+      "xoonya first-run --verify-native --pretty",
+      "xoonya conformance --json",
+      "npm run verify:release-candidate",
+      "npm run verify:service"
+    ],
+    required_surface_checks: [
+      "/v1/proof-center/native-standard",
+      "/v1/proof-center/native-atom-conformance",
+      "/v1/proof-center/native-payload-profile",
+      "/v1/proof-center/native-line-rate-frame",
+      "/v1/proof-center/native-hybrid-readiness",
+      "/v1/proof-center/native-conformance-mark"
+    ],
+    claim_classes: [
+      {
+        claim: "xnya_atom_compatible",
+        allowed_when: [
+          "canonical_magic_is_XNYA",
+          "atom_version_and_fixed_size_match",
+          "payload_and_identity_hash_derivation_match_vectors",
+          "native_atom_adversarial_vectors_fail_with_stable_error_codes"
+        ]
+      },
+      {
+        claim: "xnya_payload_profile_compatible",
+        allowed_when: [
+          "binary_magic_is_XNYP",
+          "field_ordering_and_fixed_width_integer_rules_match_profile",
+          "unknown_field_policy_is_explicit",
+          "loose_json_float_and_implicit_type_semantics_are_not_used"
+        ]
+      },
+      {
+        claim: "xnya_native_proof_compatible",
+        allowed_when: [
+          "registered_native_methods_verify",
+          "algorithm_none_is_rejected",
+          "signature_suite_is_declared_and_registered",
+          "anchor_binding_is_verified_without_external_finality_overclaim"
+        ]
+      },
+      {
+        claim: "xnya_external_interop_compatible",
+        allowed_when: [
+          "external_envelope_is_bound_to_canonical_receipt",
+          "issuer_or_signature_truth_is_left_to_declared_external_verifier",
+          "method_boundary_is_machine_readable"
+        ]
+      }
+    ],
+    forbidden_claims_without_extra_evidence: [
+      {
+        claim: "pqc_or_hybrid_verified",
+        required_extra_evidence: [
+          "non_experimental_runtime_validator",
+          "suite_specific_public_key_rules",
+          "positive_conformance_vectors",
+          "adversarial_downgrade_vectors",
+          "deterministic_error_codes"
+        ],
+        current_state: hybridReadiness.status
+      },
+      {
+        claim: "live_external_framework_provider",
+        required_extra_evidence: [
+          "real_external_endpoint",
+          "auth_and_secret_boundary",
+          "health_and_tool_catalog_checks",
+          "failure_behavior",
+          "latency_and_live_execution_evidence"
+        ],
+        current_state: "not_a_xoonya_native_mark_claim"
+      },
+      {
+        claim: "external_chain_or_provider_truth_verified_by_xoonya",
+        required_extra_evidence: [
+          "declared_external_verifier",
+          "verifier_policy",
+          "verifier_result_binding",
+          "replayable_verifier_evidence"
+        ],
+        current_state: "anchor_binding_only"
+      }
+    ],
+    conformance_floor: {
+      native_method_count: nativeStandard.current_native_method_count,
+      implemented_signature_suites: nativeStandard.implemented_signature_suites,
+      native_atom_error_code_count: atomConformance.deterministic_error_code_count,
+      conformance_requirement_count: atomConformance.conformance_requirement_count,
+      adversarial_vector_category_count: atomConformance.adversarial_vector_category_count
+    },
+    mark_usage_rules: [
+      "do_not_change_magic_layout_or_fixed_sizes_and_keep_the_mark",
+      "do_not_claim_pqc_hybrid_or_live_external_truth_without_extra_evidence",
+      "do_not_accept_algorithm_none_as_production_proof",
+      "do_not_remove_adversarial_failures_from_compatibility_evidence",
+      "do_not_use_the_mark_for_identity_auth_custody_transport_or_settlement_claims"
+    ],
+    governance_rule: "new_mark_claims_require_vectors_error_codes_docs_and_release_candidate_checks_before_public_use",
+    linked_surfaces: {
+      native_standard_ref: "/v1/proof-center/native-standard",
+      native_standardization_ref: "/v1/proof-center/native-standardization",
+      native_conformance_mark_summary_ref: "/v1/proof-center/native-conformance-mark/summary",
+      native_atom_conformance_ref: "/v1/proof-center/native-atom-conformance",
+      native_hybrid_readiness_ref: "/v1/proof-center/native-hybrid-readiness"
+    }
+  };
+}
+
+function summarizeXoonyaNativeConformanceMarkPack() {
+  const pack = buildXoonyaNativeConformanceMarkPack();
+  return {
+    ok: true,
+    product: pack.product,
+    category: "xoonya-native-conformance-mark-summary",
+    summary_version: "xoonya-native-conformance-mark-summary-v1",
+    mark: pack.mark,
+    status: pack.status,
+    posture: pack.posture,
+    standard: pack.standard,
+    canonical_magic: pack.canonical_magic,
+    required_spec_version_count: pack.required_spec_versions.length,
+    required_artifact_count: pack.required_artifacts.length,
+    required_cli_check_count: pack.required_cli_checks.length,
+    required_surface_check_count: pack.required_surface_checks.length,
+    claim_class_count: pack.claim_classes.length,
+    forbidden_claim_count: pack.forbidden_claims_without_extra_evidence.length,
+    native_atom_error_code_count: pack.conformance_floor.native_atom_error_code_count,
+    implemented_signature_suites: pack.conformance_floor.implemented_signature_suites,
+    governance_rule: pack.governance_rule,
+    linked_surfaces: pack.linked_surfaces
+  };
+}
+
 function buildXoonyaNativeAnchorProfile() {
   return {
     ok: true,
@@ -5207,6 +5804,9 @@ module.exports = {
   buildXoonyaNativeLineRateFramePack,
   buildXoonyaNativePayloadProfilePack,
   buildXoonyaNativeStandardizationPack,
+  buildXoonyaNativeConformanceMarkPack,
+  buildXoonyaNativeReferenceImplementationPack,
+  validateXoonyaNativeReferencePromotionEvidence,
   buildXoonyaNativeAtomSpec,
   buildXoonyaNativeAtomConformancePack,
   buildXoonyaNativeProofStandard,
@@ -5220,6 +5820,7 @@ module.exports = {
   canonicalizeInteractionResultPackageHandoff,
   canonicalizeInteractionSpineProofHandoff,
   normalizeExternalProofImport,
+  validateExternalProofImportEvidence,
   getDefaultProofLoop,
   canonicalizeTransactionProofHandoff,
   runDefaultProofLoop,
@@ -5279,6 +5880,8 @@ module.exports = {
   summarizeXoonyaNativeLineRateFramePack,
   summarizeXoonyaNativePayloadProfilePack,
   summarizeXoonyaNativeStandardizationPack,
+  summarizeXoonyaNativeConformanceMarkPack,
+  summarizeXoonyaNativeReferenceImplementationPack,
   summarizeXoonyaNativeAtomSpec,
   summarizeXoonyaNativeAtomConformancePack,
   summarizeXoonyaNativeProofStandard,