xoonya 2.5.0 → 2.7.0

package/proof_sdk.js

@@ -3,6 +3,8 @@
 const crypto = require("crypto");
 
 const MAGIC_HEX = "50524654";
+const XOONYA_NATIVE_ATOM_MAGIC_ASCII = "XNYA";
+const XOONYA_NATIVE_ATOM_MAGIC_HEX = "584e5941";
 const VERSION_V1_HEX = "01";
 const VERSION_V2_HEX = "02";
 const TYPE_REGISTER = "01";
@@ -15,11 +17,201 @@ const REGISTRY_PROFILE_VERSION = "registry-profile-v1";
 const CANONICAL_EVENT_BUNDLE_VERSION = "canonical-event-bundle/v1";
 const CANONICAL_RECEIPT_VERSION = "receipt/v1";
 const PROOF_BUNDLE_VERSION = "proof-bundle/v1";
+const VERIFICATION_METHOD_NONE = "none";
+const LEGACY_OPRETURN_METHOD = "legacy-opreturn-v1";
+const DETACHED_ASSERTION_METHOD = "detached-assertion-v1";
+const XOONYA_NATIVE_SHA256_METHOD = "xoonya-native-sha256-v1";
+const JWT_ASSERTION_METHOD = "jwt-assertion-v1";
+const DID_VC_METHOD = "did-vc-v1";
+const SD_JWT_VC_METHOD = "sd-jwt-vc-v1";
+const SIGNED_ENVELOPE_METHOD = "signed-envelope-v1";
+const PARTNER_PROOF_ENVELOPE_METHOD = "partner-proof-envelope-v1";
+const XOONYA_NATIVE_PROOF_FORMAT_VERSION = "xoonya-native-proof/v1";
+const XOONYA_NATIVE_SIGNED_METHOD = "xoonya-native-signed-v1";
+const XOONYA_NATIVE_ANCHORED_METHOD = "xoonya-native-anchored-v1";
+const XOONYA_NATIVE_HYBRID_METHOD = "xoonya-native-hybrid-v1";
+const XOONYA_NATIVE_ATOM_V1 = "xoonya-native-atom/v1";
+const XOONYA_NATIVE_ATOM_V2 = "xoonya-native-atom/v2";
+const XOONYA_NATIVE_ATOM_V3_CONTINGENCY = "xoonya-native-atom/v3-contingency";
+const XOONYA_NATIVE_PAYLOAD_PROFILE_V1 = "xoonya-native-payload-profile/v1";
+const XOONYA_NATIVE_LINE_RATE_FRAME_V1 = "xoonya-native-line-rate-frame/v1";
+const XNYA_DS_AGENT_V1 = "xoonya:agent:v1:";
+const XNYA_DS_PAYLOAD_V1 = "xoonya:payload:v1:";
+const XNYA_DS_AGENT_V2 = "xoonya:agent:v2:";
+const XNYA_DS_PAYLOAD_V2 = "xoonya:payload:v2:";
+const XNYA_DS_PAYLOAD_PROFILE_V1 = "xoonya:payload-profile:v1:";
+const XNYA_DS_LINE_RATE_FRAME_V1 = "xoonya:line-rate-frame:v1:";
+const XNYA_NATIVE_ATOM_ERROR_CODES = Object.freeze({
+  ATOM_HEX_NOT_HEX: "atom_hex_not_hex",
+  ATOM_UNSUPPORTED_LENGTH: "atom_unsupported_length",
+  ATOM_BAD_MAGIC: "atom_bad_magic",
+  ATOM_UNSUPPORTED_RECORD_TYPE: "atom_unsupported_record_type",
+  ATOM_VERSION_LENGTH_MISMATCH: "atom_version_length_mismatch",
+  IDENTITY_UNSUPPORTED_TYPE_PREFIX: "identity_unsupported_type_prefix",
+  IDENTITY_MISSING_RAW_BYTES: "identity_missing_raw_bytes",
+  AGENT_ID_MISMATCH: "agent_id_mismatch",
+  PAYLOAD_HASH_MISMATCH: "payload_hash_mismatch"
+});
 const REGISTRY_EVENT_TO_TYPE = {
   register: "01",
   update: "02",
   revoke: "03"
 };
+const PROOF_VERIFICATION_METHODS = Object.freeze({
+  [LEGACY_OPRETURN_METHOD]: Object.freeze({
+    id: LEGACY_OPRETURN_METHOD,
+    family: "legacy_receipt",
+    verification_posture: "compatibility_verified",
+    description: "Verifies the compatibility OP_RETURN receipt and requires the receipt signature to match it."
+  }),
+  [DETACHED_ASSERTION_METHOD]: Object.freeze({
+    id: DETACHED_ASSERTION_METHOD,
+    family: "detached_assertion",
+    verification_posture: "structure_verified_external_signature",
+    description: "Accepts an explicit detached assertion signature after canonical receipt checks; cryptographic verification is external to this helper."
+  }),
+  [XOONYA_NATIVE_SHA256_METHOD]: Object.freeze({
+    id: XOONYA_NATIVE_SHA256_METHOD,
+    family: "xoonya_native",
+    verification_posture: "native_deterministic_digest",
+    description: "Verifies Xoonya's native deterministic receipt digest format for method-agnostic proof bundles."
+  }),
+  [XOONYA_NATIVE_SIGNED_METHOD]: Object.freeze({
+    id: XOONYA_NATIVE_SIGNED_METHOD,
+    family: "xoonya_native",
+    verification_posture: "native_signature_verified",
+    description: "Verifies Xoonya's native signed proof envelope with explicit signature-suite and public-key binding."
+  }),
+  [XOONYA_NATIVE_ANCHORED_METHOD]: Object.freeze({
+    id: XOONYA_NATIVE_ANCHORED_METHOD,
+    family: "xoonya_native",
+    verification_posture: "native_anchor_binding_verified",
+    description: "Verifies Xoonya's native anchor-binding proof envelope for chain, batch, finality, or external attestation references."
+  }),
+  [JWT_ASSERTION_METHOD]: Object.freeze({
+    id: JWT_ASSERTION_METHOD,
+    family: "jwt",
+    verification_posture: "structure_verified_external_signature",
+    description: "Accepts a compact JWT assertion after canonical receipt checks; JWT signature verification is external to this helper."
+  }),
+  [DID_VC_METHOD]: Object.freeze({
+    id: DID_VC_METHOD,
+    family: "did_vc",
+    verification_posture: "structure_verified_external_signature",
+    description: "Accepts a DID/VC proof envelope after canonical receipt checks; DID resolution and VC proof verification are external to this helper."
+  }),
+  [SD_JWT_VC_METHOD]: Object.freeze({
+    id: SD_JWT_VC_METHOD,
+    family: "sd_jwt_vc",
+    verification_posture: "structure_verified_external_signature",
+    description: "Accepts an SD-JWT VC disclosure envelope after canonical receipt checks; disclosure and issuer verification are external to this helper."
+  }),
+  [SIGNED_ENVELOPE_METHOD]: Object.freeze({
+    id: SIGNED_ENVELOPE_METHOD,
+    family: "signed_envelope",
+    verification_posture: "structure_verified_external_signature",
+    description: "Accepts a signed envelope after canonical receipt checks; envelope-specific signature verification is external to this helper."
+  }),
+  [PARTNER_PROOF_ENVELOPE_METHOD]: Object.freeze({
+    id: PARTNER_PROOF_ENVELOPE_METHOD,
+    family: "partner_proof_envelope",
+    verification_posture: "structure_verified_external_signature",
+    description: "Accepts partner-specific proof envelopes after canonical receipt checks; partner verifier policy is external to this helper."
+  })
+});
+const NATIVE_SIGNATURE_SUITES = Object.freeze({
+  ed25519: Object.freeze({
+    id: "ed25519",
+    maturity: "implemented",
+    public_key_format: "spki-pem",
+    verification_posture: "native_verified"
+  }),
+  secp256k1: Object.freeze({
+    id: "secp256k1",
+    maturity: "implemented",
+    public_key_format: "spki-pem",
+    verification_posture: "native_verified",
+    curve: "secp256k1",
+    signing_hash: "sha256"
+  }),
+  p256: Object.freeze({
+    id: "p256",
+    maturity: "implemented",
+    public_key_format: "spki-pem",
+    verification_posture: "native_verified",
+    curve: "prime256v1",
+    signing_hash: "sha256"
+  }),
+  "webauthn-cose": Object.freeze({
+    id: "webauthn-cose",
+    maturity: "planned",
+    public_key_format: "cose-key",
+    verification_posture: "registry_declared_not_yet_verified"
+  }),
+  dilithium: Object.freeze({
+    id: "dilithium",
+    maturity: "planned_pqc",
+    public_key_format: "suite_defined",
+    verification_posture: "registry_declared_not_yet_verified"
+  }),
+  falcon: Object.freeze({
+    id: "falcon",
+    maturity: "planned_pqc",
+    public_key_format: "suite_defined",
+    verification_posture: "registry_declared_not_yet_verified"
+  }),
+  "sphincs-plus": Object.freeze({
+    id: "sphincs-plus",
+    maturity: "planned_pqc",
+    public_key_format: "suite_defined",
+    verification_posture: "registry_declared_not_yet_verified"
+  })
+});
+const XOONYA_NATIVE_IDENTITY_TYPES = Object.freeze({
+  "01": Object.freeze({
+    prefix: "01",
+    id: "secp256k1-public-key",
+    canonical_material: "compressed-sec1-public-key"
+  }),
+  "02": Object.freeze({
+    prefix: "02",
+    id: "device-identifier",
+    canonical_material: "raw-device-identifier-bytes"
+  }),
+  "03": Object.freeze({
+    prefix: "03",
+    id: "did-string",
+    canonical_material: "utf8-did-string-no-bom-no-normalization"
+  }),
+  "04": Object.freeze({
+    prefix: "04",
+    id: "opaque-agent-key",
+    canonical_material: "opaque-agent-key-bytes"
+  }),
+  "05": Object.freeze({
+    prefix: "05",
+    id: "dilithium-public-key",
+    canonical_material: "suite-defined-pqc-public-key-bytes"
+  }),
+  "06": Object.freeze({
+    prefix: "06",
+    id: "falcon-public-key",
+    canonical_material: "suite-defined-pqc-public-key-bytes"
+  }),
+  "07": Object.freeze({
+    prefix: "07",
+    id: "sphincs-plus-public-key",
+    canonical_material: "suite-defined-pqc-public-key-bytes"
+  })
+});
+const EXTERNAL_PROOF_IMPORT_METHODS = Object.freeze([
+  DETACHED_ASSERTION_METHOD,
+  JWT_ASSERTION_METHOD,
+  DID_VC_METHOD,
+  SD_JWT_VC_METHOD,
+  SIGNED_ENVELOPE_METHOD,
+  PARTNER_PROOF_ENVELOPE_METHOD
+]);
 
 function sha256Hex(buf) {
   return crypto.createHash("sha256").update(buf).digest("hex");
@@ -38,6 +230,14 @@ function assertHex(hex, expectedLen, label) {
   return normalized;
 }
 
+function assertVariableHex(hex, label) {
+  const normalized = String(hex || "").trim().toLowerCase();
+  if (!/^[a-f0-9]+$/.test(normalized) || normalized.length === 0 || normalized.length % 2 !== 0) {
+    throw new Error(`${label} must be non-empty byte-aligned hex`);
+  }
+  return normalized;
+}
+
 function canonicalize(value) {
   if (Array.isArray(value)) {
     return `[${value.map((item) => canonicalize(item)).join(",")}]`;
@@ -53,6 +253,286 @@ function canonicalJsonSha256Hex(value) {
   return sha256Hex(Buffer.from(canonicalize(value), "utf8"));
 }
 
+function base64urlEncode(buf) {
+  return Buffer.from(buf)
+    .toString("base64")
+    .replace(/\+/g, "-")
+    .replace(/\//g, "_")
+    .replace(/=+$/g, "");
+}
+
+function base64urlDecode(value, label) {
+  const normalized = normalizeString(value);
+  if (!/^[A-Za-z0-9_-]+$/.test(normalized)) {
+    throw new Error(`${label} must be base64url`);
+  }
+  const padded = normalized + "=".repeat((4 - (normalized.length % 4)) % 4);
+  return Buffer.from(padded.replace(/-/g, "+").replace(/_/g, "/"), "base64");
+}
+
+function uint16Buffer(value, label) {
+  const n = Number(value);
+  if (!Number.isInteger(n) || n < 0 || n > 0xffff) {
+    throw new Error(`${label} must be uint16`);
+  }
+  const out = Buffer.alloc(2);
+  out.writeUInt16BE(n, 0);
+  return out;
+}
+
+function uint64Buffer(value, label) {
+  let n;
+  try {
+    n = BigInt(value);
+  } catch (error) {
+    throw new Error(`${label} must be uint64`);
+  }
+  if (n < 0n || n > 0xffffffffffffffffn) {
+    throw new Error(`${label} must be uint64`);
+  }
+  const out = Buffer.alloc(8);
+  out.writeBigUInt64BE(n, 0);
+  return out;
+}
+
+function readUInt64String(buf) {
+  return buf.readBigUInt64BE(0).toString();
+}
+
+const XNYA_PAYLOAD_FIELD_TYPES = Object.freeze({
+  bytes32: Object.freeze({ id: 1, fixed_length: 32 }),
+  bytes20: Object.freeze({ id: 2, fixed_length: 20 }),
+  uint64: Object.freeze({ id: 3, fixed_length: 8 }),
+  utf8: Object.freeze({ id: 4, max_length: 1024 }),
+  bool: Object.freeze({ id: 5, fixed_length: 1 })
+});
+const XNYA_PAYLOAD_FIELD_TYPE_BY_ID = Object.freeze(
+  Object.fromEntries(Object.entries(XNYA_PAYLOAD_FIELD_TYPES).map(([name, spec]) => [spec.id, { name, ...spec }]))
+);
+
+function normalizePayloadFieldValue(fieldType, value, label) {
+  const spec = XNYA_PAYLOAD_FIELD_TYPES[fieldType];
+  if (!spec) {
+    throw new Error(`${label}.field_type unsupported`);
+  }
+  if (fieldType === "bytes32" || fieldType === "bytes20") {
+    const expectedHexLen = spec.fixed_length * 2;
+    return Buffer.from(assertHex(value, expectedHexLen, `${label}.value_hex`), "hex");
+  }
+  if (fieldType === "uint64") {
+    return uint64Buffer(value, `${label}.value`);
+  }
+  if (fieldType === "utf8") {
+    const text = String(value == null ? "" : value);
+    const out = Buffer.from(text, "utf8");
+    if (out.length === 0 || out.length > spec.max_length) {
+      throw new Error(`${label}.value must be non-empty utf8 up to ${spec.max_length} bytes`);
+    }
+    return out;
+  }
+  if (fieldType === "bool") {
+    if (typeof value !== "boolean") {
+      throw new Error(`${label}.value must be boolean`);
+    }
+    return Buffer.from([value ? 1 : 0]);
+  }
+  throw new Error(`${label}.field_type unsupported`);
+}
+
+function normalizePayloadProfileFields(fields) {
+  if (!Array.isArray(fields) || fields.length === 0) {
+    throw new Error("payload profile fields must be a non-empty array");
+  }
+  if (fields.length > 64) {
+    throw new Error("payload profile fields must contain at most 64 entries");
+  }
+  const normalized = fields.map((field, index) => {
+    if (!field || typeof field !== "object" || Array.isArray(field)) {
+      throw new Error(`payload profile fields[${index}] must be an object`);
+    }
+    const fieldId = Number(field.field_id || field.id);
+    if (!Number.isInteger(fieldId) || fieldId < 1 || fieldId > 0xffff) {
+      throw new Error(`payload profile fields[${index}].field_id must be uint16`);
+    }
+    const fieldType = normalizeString(field.field_type || field.type);
+    const rawValue = Object.prototype.hasOwnProperty.call(field, "value_hex")
+      ? field.value_hex
+      : field.value;
+    const value = normalizePayloadFieldValue(fieldType, rawValue, `payload profile fields[${index}]`);
+    return {
+      field_id: fieldId,
+      field_type: fieldType,
+      field_type_id: XNYA_PAYLOAD_FIELD_TYPES[fieldType].id,
+      value
+    };
+  }).sort((a, b) => a.field_id - b.field_id || a.field_type_id - b.field_type_id);
+  const seen = new Set();
+  for (const field of normalized) {
+    const key = `${field.field_id}:${field.field_type_id}`;
+    if (seen.has(key)) {
+      throw new Error("payload profile duplicate field id/type");
+    }
+    seen.add(key);
+  }
+  return normalized;
+}
+
+function encodeXoonyaNativePayloadProfileV1(input = {}) {
+  const schemaRef = normalizeString(input.schema_ref || input.schemaRef || "xoonya.payload.schema.generic.v1");
+  if (!schemaRef) {
+    throw new Error("payload profile schema_ref required");
+  }
+  const fields = normalizePayloadProfileFields(input.fields);
+  const schemaHash = sha256Hex(Buffer.from(`xoonya:payload-schema:v1:${schemaRef}`, "utf8"));
+  const fieldBuffers = fields.map((field) => Buffer.concat([
+    uint16Buffer(field.field_id, "payload profile field_id"),
+    Buffer.from([field.field_type_id]),
+    uint16Buffer(field.value.length, "payload profile field length"),
+    field.value
+  ]));
+  const canonicalBytes = Buffer.concat([
+    Buffer.from("XNYP", "ascii"),
+    Buffer.from([1]),
+    Buffer.from(schemaHash, "hex"),
+    Buffer.from([fields.length]),
+    ...fieldBuffers
+  ]);
+  const payloadHash = sha256Hex(Buffer.concat([
+    Buffer.from(XNYA_DS_PAYLOAD_PROFILE_V1, "utf8"),
+    canonicalBytes
+  ]));
+  return {
+    profile: XOONYA_NATIVE_PAYLOAD_PROFILE_V1,
+    schema_ref: schemaRef,
+    schema_hash_sha256: schemaHash,
+    field_count: fields.length,
+    canonical_bytes_hex: canonicalBytes.toString("hex"),
+    payload_hash_sha256: payloadHash,
+    fields: fields.map((field) => ({
+      field_id: field.field_id,
+      field_type: field.field_type,
+      value_hex: field.value.toString("hex")
+    }))
+  };
+}
+
+function parseXoonyaNativePayloadProfileV1(canonicalBytesHex) {
+  const hex = assertVariableHex(canonicalBytesHex, "payload profile canonical bytes");
+  const buf = Buffer.from(hex, "hex");
+  if (buf.length < 38) {
+    throw new Error("payload profile bytes too short");
+  }
+  if (buf.subarray(0, 4).toString("ascii") !== "XNYP") {
+    throw new Error("payload profile magic mismatch");
+  }
+  if (buf[4] !== 1) {
+    throw new Error("payload profile version unsupported");
+  }
+  const schemaHash = buf.subarray(5, 37).toString("hex");
+  const fieldCount = buf[37];
+  if (fieldCount === 0 || fieldCount > 64) {
+    throw new Error("payload profile field count unsupported");
+  }
+  let offset = 38;
+  const fields = [];
+  const seen = new Set();
+  for (let i = 0; i < fieldCount; i += 1) {
+    if (offset + 5 > buf.length) {
+      throw new Error("payload profile truncated field header");
+    }
+    const fieldId = buf.readUInt16BE(offset);
+    const fieldTypeId = buf[offset + 2];
+    const length = buf.readUInt16BE(offset + 3);
+    offset += 5;
+    if (offset + length > buf.length) {
+      throw new Error("payload profile truncated field value");
+    }
+    const typeSpec = XNYA_PAYLOAD_FIELD_TYPE_BY_ID[fieldTypeId];
+    if (!typeSpec) {
+      throw new Error("payload profile field type unsupported");
+    }
+    const value = buf.subarray(offset, offset + length);
+    offset += length;
+    if (typeSpec.fixed_length && value.length !== typeSpec.fixed_length) {
+      throw new Error("payload profile fixed field length mismatch");
+    }
+    if (typeSpec.max_length && (value.length === 0 || value.length > typeSpec.max_length)) {
+      throw new Error("payload profile variable field length mismatch");
+    }
+    if (typeSpec.name === "bool" && value[0] !== 0 && value[0] !== 1) {
+      throw new Error("payload profile bool value invalid");
+    }
+    const key = `${fieldId}:${fieldTypeId}`;
+    if (seen.has(key)) {
+      throw new Error("payload profile duplicate field id/type");
+    }
+    seen.add(key);
+    fields.push({
+      field_id: fieldId,
+      field_type: typeSpec.name,
+      field_type_id: fieldTypeId,
+      value_hex: value.toString("hex"),
+      ...(typeSpec.name === "uint64" ? { value: readUInt64String(value) } : {}),
+      ...(typeSpec.name === "bool" ? { value: value[0] === 1 } : {})
+    });
+  }
+  if (offset !== buf.length) {
+    throw new Error("payload profile trailing bytes");
+  }
+  const sorted = fields.slice().sort((a, b) => a.field_id - b.field_id || a.field_type_id - b.field_type_id);
+  if (canonicalize(fields) !== canonicalize(sorted)) {
+    throw new Error("payload profile fields not canonical order");
+  }
+  return {
+    profile: XOONYA_NATIVE_PAYLOAD_PROFILE_V1,
+    version: 1,
+    schema_hash_sha256: schemaHash,
+    field_count: fieldCount,
+    fields,
+    canonical_bytes_hex: hex,
+    payload_hash_sha256: sha256Hex(Buffer.concat([
+      Buffer.from(XNYA_DS_PAYLOAD_PROFILE_V1, "utf8"),
+      buf
+    ]))
+  };
+}
+
+function verifyXoonyaNativePayloadProfileV1(canonicalBytesHex, options = {}) {
+  try {
+    const parsed = parseXoonyaNativePayloadProfileV1(canonicalBytesHex);
+    const expectedHash = normalizeString(options.payload_hash_sha256 || options.expected_payload_hash_sha256).toLowerCase();
+    if (expectedHash && expectedHash !== parsed.payload_hash_sha256) {
+      return { valid: false, reason: "payload_profile_hash_mismatch", parsed };
+    }
+    const schemaRef = normalizeString(options.schema_ref || options.schemaRef);
+    if (schemaRef) {
+      const expectedSchemaHash = sha256Hex(Buffer.from(`xoonya:payload-schema:v1:${schemaRef}`, "utf8"));
+      if (expectedSchemaHash !== parsed.schema_hash_sha256) {
+        return { valid: false, reason: "payload_profile_schema_mismatch", parsed };
+      }
+    }
+    const allowedFieldIds = Array.isArray(options.allowed_field_ids)
+      ? options.allowed_field_ids.map((entry) => Number(entry))
+      : null;
+    if (allowedFieldIds) {
+      const allowed = new Set(allowedFieldIds);
+      if (parsed.fields.some((field) => !allowed.has(field.field_id))) {
+        return { valid: false, reason: "payload_profile_unknown_field", parsed };
+      }
+    }
+    return { valid: true, parsed };
+  } catch (error) {
+    return { valid: false, reason: error.message };
+  }
+}
+
+function lineRateFrameChecksum(atomBytes) {
+  return sha256Hex(Buffer.concat([
+    Buffer.from(XNYA_DS_LINE_RATE_FRAME_V1, "utf8"),
+    atomBytes
+  ])).slice(0, 4);
+}
+
 function normalizeString(value) {
   return String(value == null ? "" : value).trim();
 }
@@ -142,6 +622,349 @@ function buildCanonicalReceiptSigningMaterial(receipt) {
   };
 }
 
+function listProofVerificationMethods() {
+  return Object.values(PROOF_VERIFICATION_METHODS).map((method) => ({ ...method }));
+}
+
+function getProofVerificationMethod(methodId) {
+  const normalized = normalizeString(methodId);
+  const method = PROOF_VERIFICATION_METHODS[normalized];
+  return method ? { ...method } : null;
+}
+
+function listNativeSignatureSuites() {
+  return Object.values(NATIVE_SIGNATURE_SUITES).map((suite) => ({ ...suite }));
+}
+
+function getNativeSignatureSuite(suiteId) {
+  const normalized = normalizeString(suiteId);
+  const suite = NATIVE_SIGNATURE_SUITES[normalized];
+  return suite ? { ...suite } : null;
+}
+
+function listXoonyaNativeIdentityTypes() {
+  return Object.values(XOONYA_NATIVE_IDENTITY_TYPES).map((entry) => ({ ...entry }));
+}
+
+function getXoonyaNativeIdentityType(prefixHex) {
+  const normalized = normalizeString(prefixHex).toLowerCase();
+  const entry = XOONYA_NATIVE_IDENTITY_TYPES[normalized];
+  return entry ? { ...entry } : null;
+}
+
+function isExternalAssertionMethod(algorithm) {
+  return EXTERNAL_PROOF_IMPORT_METHODS.includes(algorithm);
+}
+
+function selectReceiptAlgorithm(options, compatibility) {
+  const requested = normalizeString(options.algorithm);
+  if (requested) {
+    return requested;
+  }
+  if (compatibility) {
+    return LEGACY_OPRETURN_METHOD;
+  }
+  if (options.signature != null || typeof options.signer === "function") {
+    return DETACHED_ASSERTION_METHOD;
+  }
+  return XOONYA_NATIVE_SHA256_METHOD;
+}
+
+function buildNativeReceiptSignature(receipt, canonicalEvent) {
+  const material = {
+    method: XOONYA_NATIVE_SHA256_METHOD,
+    receipt_signing_material: buildCanonicalReceiptSigningMaterial(receipt),
+    event_commitment: hashEvent(canonicalEvent)
+  };
+  return `${XOONYA_NATIVE_SHA256_METHOD}:${sha256Hex(Buffer.from(canonicalize(material), "utf8"))}`;
+}
+
+function normalizePublicKeyPem(value) {
+  const pem = String(value || "").replace(/\r\n/g, "\n").trim();
+  if (!pem.includes("BEGIN PUBLIC KEY")) {
+    throw new Error("native public key must be SPKI PEM");
+  }
+  return `${pem}\n`;
+}
+
+function normalizePrivateKeyPem(value) {
+  const pem = String(value || "").replace(/\r\n/g, "\n").trim();
+  if (!pem.includes("BEGIN PRIVATE KEY")) {
+    throw new Error("native private key must be PKCS8 PEM");
+  }
+  return `${pem}\n`;
+}
+
+function nativePublicKeyRefFromPem(publicKeyPem, signatureSuite = "ed25519") {
+  const suite = getNativeSignatureSuite(signatureSuite);
+  if (!suite) {
+    throw new Error("native signature suite unsupported");
+  }
+  if (suite.maturity !== "implemented") {
+    throw new Error("native signature suite not implemented");
+  }
+  const publicKey = crypto.createPublicKey(normalizePublicKeyPem(publicKeyPem));
+  const der = publicKey.export({ type: "spki", format: "der" });
+  return `${suite.id}-spki-sha256:${sha256Hex(der)}`;
+}
+
+function nativeSigningHashForSuite(suite) {
+  return suite && suite.signing_hash ? suite.signing_hash : null;
+}
+
+function assertNativeKeyMatchesSuite(keyObject, suite, label) {
+  if (suite && suite.curve) {
+    const details = keyObject.asymmetricKeyDetails || {};
+    if (details.namedCurve !== suite.curve) {
+      throw new Error(`${label} curve must be ${suite.curve}`);
+    }
+  }
+}
+
+function buildNativeSignedProofMaterial(receipt, canonicalEvent, proofDescriptor) {
+  return {
+    identity_ref: proofDescriptor.identity_ref,
+    method: XOONYA_NATIVE_SIGNED_METHOD,
+    public_key_ref: proofDescriptor.public_key_ref,
+    receipt_signing_material: buildCanonicalReceiptSigningMaterial(receipt),
+    event_commitment: hashEvent(canonicalEvent),
+    signature_suite: proofDescriptor.signature_suite,
+    standard_version: XOONYA_NATIVE_PROOF_FORMAT_VERSION
+  };
+}
+
+function buildNativeSignedReceiptProof(receipt, canonicalEvent, options = {}) {
+  const signatureSuite = normalizeString(options.signature_suite || options.native_signature_suite || "ed25519");
+  const suite = getNativeSignatureSuite(signatureSuite);
+  if (!suite) {
+    throw new Error("native signature suite unsupported");
+  }
+  if (suite.maturity !== "implemented") {
+    throw new Error("native signature suite not implemented");
+  }
+  const publicKeyPem = normalizePublicKeyPem(options.public_key_pem || options.native_public_key_pem);
+  const privateKeyPem = normalizePrivateKeyPem(options.private_key_pem || options.native_private_key_pem);
+  const publicKey = crypto.createPublicKey(publicKeyPem);
+  const privateKey = crypto.createPrivateKey(privateKeyPem);
+  assertNativeKeyMatchesSuite(publicKey, suite, "native public key");
+  assertNativeKeyMatchesSuite(privateKey, suite, "native private key");
+  const identityRef = normalizeString(options.identity_ref || options.native_identity_ref || receipt.agent_identity);
+  if (!identityRef) {
+    throw new Error("native identity_ref required");
+  }
+  const publicKeyRef = nativePublicKeyRefFromPem(publicKeyPem, suite.id);
+  const descriptor = {
+    identity_ref: identityRef,
+    public_key_ref: publicKeyRef,
+    signature_suite: suite.id
+  };
+  const signingMaterial = buildNativeSignedProofMaterial(receipt, canonicalEvent, descriptor);
+  const signingBytes = Buffer.from(canonicalize(signingMaterial), "utf8");
+  const signatureBytes = crypto.sign(nativeSigningHashForSuite(suite), signingBytes, privateKey);
+  const signature = base64urlEncode(signatureBytes);
+  return {
+    method: XOONYA_NATIVE_SIGNED_METHOD,
+    signature_suite: suite.id,
+    identity_ref: identityRef,
+    public_key_ref: publicKeyRef,
+    public_key_material: {
+      format: suite.public_key_format,
+      value: publicKeyPem
+    },
+    proof_material: {
+      signing_material_sha256: sha256Hex(signingBytes),
+      signature
+    },
+    compact_signature: `${XOONYA_NATIVE_SIGNED_METHOD}:${suite.id}:${signature}`
+  };
+}
+
+function normalizeNativeAnchorRefs(anchorRefs, label = "native anchors") {
+  if (!Array.isArray(anchorRefs) || anchorRefs.length === 0) {
+    throw new Error(`${label} must be a non-empty array`);
+  }
+  if (anchorRefs.length > 32) {
+    throw new Error(`${label} must contain at most 32 entries`);
+  }
+  const normalized = anchorRefs.map((anchor, index) => {
+    if (!anchor || typeof anchor !== "object" || Array.isArray(anchor)) {
+      throw new Error(`${label}[${index}] must be an object`);
+    }
+    const entry = {
+      anchor_id: normalizeString(anchor.anchor_id || anchor.id),
+      anchor_kind: normalizeString(anchor.anchor_kind || anchor.kind),
+      anchor_ref: normalizeString(anchor.anchor_ref || anchor.ref),
+      anchor_hash_sha256: normalizeString(anchor.anchor_hash_sha256 || anchor.hash_sha256 || anchor.anchor_hash).toLowerCase()
+    };
+    if (!entry.anchor_id) throw new Error(`${label}[${index}].anchor_id required`);
+    if (!entry.anchor_kind) throw new Error(`${label}[${index}].anchor_kind required`);
+    if (!entry.anchor_ref) throw new Error(`${label}[${index}].anchor_ref required`);
+    entry.anchor_hash_sha256 = assertHex(entry.anchor_hash_sha256, 64, `${label}[${index}].anchor_hash_sha256`);
+
+    const network = normalizeString(anchor.network);
+    if (network) entry.network = network;
+    const finalityState = normalizeString(anchor.finality_state);
+    if (finalityState) entry.finality_state = finalityState;
+    const observedAtIso = normalizeString(anchor.observed_at_iso);
+    if (observedAtIso) entry.observed_at_iso = observedAtIso;
+    const providerRef = normalizeString(anchor.provider_ref);
+    if (providerRef) entry.provider_ref = providerRef;
+    const inclusionProofRef = normalizeString(anchor.inclusion_proof_ref);
+    if (inclusionProofRef) entry.inclusion_proof_ref = inclusionProofRef;
+    return entry;
+  });
+  return normalized.sort((a, b) => canonicalize(a).localeCompare(canonicalize(b)));
+}
+
+function buildNativeAnchorBindingMaterial(receipt, canonicalEvent, anchorRefs) {
+  const normalizedAnchors = normalizeNativeAnchorRefs(anchorRefs);
+  return {
+    anchor_refs: normalizedAnchors,
+    base_method: XOONYA_NATIVE_SHA256_METHOD,
+    event_commitment: hashEvent(canonicalEvent),
+    method: XOONYA_NATIVE_ANCHORED_METHOD,
+    receipt_signing_material: buildCanonicalReceiptSigningMaterial(receipt),
+    standard_version: XOONYA_NATIVE_PROOF_FORMAT_VERSION
+  };
+}
+
+function buildNativeAnchoredReceiptProof(receipt, canonicalEvent, options = {}) {
+  const anchorRefs = normalizeNativeAnchorRefs(options.anchors || options.native_anchor_refs || options.anchor_refs);
+  const bindingMaterial = buildNativeAnchorBindingMaterial(receipt, canonicalEvent, anchorRefs);
+  const bindingBytes = Buffer.from(canonicalize(bindingMaterial), "utf8");
+  const bindingHash = sha256Hex(bindingBytes);
+  const anchorRootHash = canonicalJsonSha256Hex(anchorRefs);
+  return {
+    method: XOONYA_NATIVE_ANCHORED_METHOD,
+    base_method: XOONYA_NATIVE_SHA256_METHOD,
+    anchor_refs: anchorRefs,
+    proof_material: {
+      anchor_root_sha256: anchorRootHash,
+      binding_material_sha256: bindingHash
+    },
+    compact_signature: `${XOONYA_NATIVE_ANCHORED_METHOD}:${bindingHash}`
+  };
+}
+
+function verifyNativeSignedReceiptProof(receipt, ceb) {
+  try {
+    const proof = receipt.native_proof;
+    if (!proof || typeof proof !== "object" || Array.isArray(proof)) {
+      return { valid: false, reason: "native_proof_missing" };
+    }
+    if (normalizeString(proof.method) !== XOONYA_NATIVE_SIGNED_METHOD) {
+      return { valid: false, reason: "native_proof_method_mismatch" };
+    }
+    const signatureSuite = normalizeString(proof.signature_suite);
+    const suite = getNativeSignatureSuite(signatureSuite);
+    if (!suite) {
+      return { valid: false, reason: "native_signature_suite_unsupported" };
+    }
+    if (suite.maturity !== "implemented") {
+      return { valid: false, reason: "native_signature_suite_not_implemented" };
+    }
+    const identityRef = normalizeString(proof.identity_ref);
+    if (!identityRef) {
+      return { valid: false, reason: "native_identity_ref_missing" };
+    }
+    const publicKeyMaterial = proof.public_key_material;
+    if (!publicKeyMaterial || typeof publicKeyMaterial !== "object" || Array.isArray(publicKeyMaterial)) {
+      return { valid: false, reason: "native_public_key_material_missing" };
+    }
+    if (normalizeString(publicKeyMaterial.format) !== suite.public_key_format) {
+      return { valid: false, reason: "native_public_key_format_mismatch" };
+    }
+    const publicKeyPem = normalizePublicKeyPem(publicKeyMaterial.value);
+    const publicKey = crypto.createPublicKey(publicKeyPem);
+    assertNativeKeyMatchesSuite(publicKey, suite, "native public key");
+    const expectedPublicKeyRef = nativePublicKeyRefFromPem(publicKeyPem, suite.id);
+    if (normalizeString(proof.public_key_ref) !== expectedPublicKeyRef) {
+      return { valid: false, reason: "native_public_key_ref_mismatch" };
+    }
+    const proofMaterial = proof.proof_material;
+    if (!proofMaterial || typeof proofMaterial !== "object" || Array.isArray(proofMaterial)) {
+      return { valid: false, reason: "native_proof_material_missing" };
+    }
+    const signature = normalizeString(proofMaterial.signature);
+    if (!signature) {
+      return { valid: false, reason: "native_signature_missing" };
+    }
+    const expectedCompactSignature = `${XOONYA_NATIVE_SIGNED_METHOD}:${suite.id}:${signature}`;
+    if (normalizeString(receipt.signature) !== expectedCompactSignature) {
+      return { valid: false, reason: "signature_native_signed_mismatch" };
+    }
+    const signingMaterial = buildNativeSignedProofMaterial(receipt, ceb, {
+      identity_ref: identityRef,
+      public_key_ref: expectedPublicKeyRef,
+      signature_suite: suite.id
+    });
+    const signingBytes = Buffer.from(canonicalize(signingMaterial), "utf8");
+    const expectedSigningHash = sha256Hex(signingBytes);
+    if (normalizeString(proofMaterial.signing_material_sha256).toLowerCase() !== expectedSigningHash) {
+      return { valid: false, reason: "native_signing_material_hash_mismatch" };
+    }
+    const signatureBytes = base64urlDecode(signature, "native signature");
+    const verified = crypto.verify(nativeSigningHashForSuite(suite), signingBytes, publicKey, signatureBytes);
+    if (!verified) {
+      return { valid: false, reason: "native_signature_invalid" };
+    }
+    return {
+      valid: true,
+      verification_state: "verified_native_signature",
+      signature_suite: suite.id
+    };
+  } catch (error) {
+    return { valid: false, reason: error.message };
+  }
+}
+
+function verifyNativeAnchoredReceiptProof(receipt, ceb, bundle) {
+  try {
+    const proof = receipt.native_proof;
+    if (!proof || typeof proof !== "object" || Array.isArray(proof)) {
+      return { valid: false, reason: "native_proof_missing" };
+    }
+    if (normalizeString(proof.method) !== XOONYA_NATIVE_ANCHORED_METHOD) {
+      return { valid: false, reason: "native_proof_method_mismatch" };
+    }
+    if (normalizeString(proof.base_method) !== XOONYA_NATIVE_SHA256_METHOD) {
+      return { valid: false, reason: "native_anchor_base_method_unsupported" };
+    }
+    if (!bundle || !Array.isArray(bundle.anchors)) {
+      return { valid: false, reason: "native_anchor_bundle_missing" };
+    }
+    const proofAnchors = normalizeNativeAnchorRefs(proof.anchor_refs);
+    const bundleAnchors = normalizeNativeAnchorRefs(bundle.anchors);
+    if (canonicalize(proofAnchors) !== canonicalize(bundleAnchors)) {
+      return { valid: false, reason: "native_anchor_bundle_mismatch" };
+    }
+    const proofMaterial = proof.proof_material;
+    if (!proofMaterial || typeof proofMaterial !== "object" || Array.isArray(proofMaterial)) {
+      return { valid: false, reason: "native_anchor_proof_material_missing" };
+    }
+    const expectedAnchorRoot = canonicalJsonSha256Hex(proofAnchors);
+    if (normalizeString(proofMaterial.anchor_root_sha256).toLowerCase() !== expectedAnchorRoot) {
+      return { valid: false, reason: "native_anchor_root_mismatch" };
+    }
+    const bindingMaterial = buildNativeAnchorBindingMaterial(receipt, ceb, proofAnchors);
+    const bindingHash = sha256Hex(Buffer.from(canonicalize(bindingMaterial), "utf8"));
+    if (normalizeString(proofMaterial.binding_material_sha256).toLowerCase() !== bindingHash) {
+      return { valid: false, reason: "native_anchor_binding_hash_mismatch" };
+    }
+    if (normalizeString(receipt.signature) !== `${XOONYA_NATIVE_ANCHORED_METHOD}:${bindingHash}`) {
+      return { valid: false, reason: "signature_native_anchored_mismatch" };
+    }
+    return {
+      valid: true,
+      verification_state: "verified_native_anchor_binding",
+      anchor_count: proofAnchors.length,
+      anchor_root_sha256: expectedAnchorRoot
+    };
+  } catch (error) {
+    return { valid: false, reason: error.message };
+  }
+}
+
 function emitReceipt(event, options = {}) {
   const canonicalEvent = canonicalizeEvent(event);
   const eventCommitment = hashEvent(canonicalEvent);
@@ -184,7 +1007,7 @@ function emitReceipt(event, options = {}) {
     domain_id: canonicalEvent.domain_id,
     sequence: canonicalEvent.sequence,
     event_commitment: eventCommitment,
-    algorithm: normalizeString(options.algorithm || (compatibility ? "legacy-opreturn-v1" : "none"))
+    algorithm: selectReceiptAlgorithm(options, compatibility)
   };
 
   if (compatibility) {
@@ -192,9 +1015,25 @@ function emitReceipt(event, options = {}) {
   }
 
   let signature = options.signature == null ? "" : normalizeString(options.signature);
+  let nativeProof = options.native_proof && typeof options.native_proof === "object" && !Array.isArray(options.native_proof)
+    ? options.native_proof
+    : null;
   if (!signature && typeof options.signer === "function") {
     signature = normalizeString(options.signer(buildCanonicalReceiptSigningMaterial(unsignedReceipt), canonicalEvent));
   }
+  if (!signature && unsignedReceipt.algorithm === XOONYA_NATIVE_SIGNED_METHOD) {
+    nativeProof = buildNativeSignedReceiptProof(unsignedReceipt, canonicalEvent, options);
+    signature = nativeProof.compact_signature;
+    delete nativeProof.compact_signature;
+  }
+  if (!signature && unsignedReceipt.algorithm === XOONYA_NATIVE_ANCHORED_METHOD) {
+    nativeProof = buildNativeAnchoredReceiptProof(unsignedReceipt, canonicalEvent, options);
+    signature = nativeProof.compact_signature;
+    delete nativeProof.compact_signature;
+  }
+  if (!signature && unsignedReceipt.algorithm === XOONYA_NATIVE_SHA256_METHOD) {
+    signature = buildNativeReceiptSignature(unsignedReceipt, canonicalEvent);
+  }
   if (!signature && compatibility) {
     signature = compatibility.legacy_receipt.opreturn_hex;
   }
@@ -204,21 +1043,134 @@ function emitReceipt(event, options = {}) {
 
   return {
     ...unsignedReceipt,
+    ...(nativeProof ? { native_proof: nativeProof } : {}),
     signature
   };
 }
 
+function verifyReceiptProofMethod(receipt, ceb, bundle) {
+  const algorithm = normalizeString(receipt.algorithm);
+  if (!algorithm) {
+    return { valid: false, reason: "verification_method_missing" };
+  }
+  if (algorithm === VERIFICATION_METHOD_NONE) {
+    return { valid: false, reason: "verification_method_none" };
+  }
+
+  const method = PROOF_VERIFICATION_METHODS[algorithm];
+  if (!method) {
+    return { valid: false, reason: "verification_method_unsupported" };
+  }
+
+  const legacyReceipt = receipt.compatibility && receipt.compatibility.legacy_receipt;
+  if (legacyReceipt && algorithm !== LEGACY_OPRETURN_METHOD) {
+    return { valid: false, reason: "legacy_receipt_method_mismatch" };
+  }
+
+  if (algorithm === LEGACY_OPRETURN_METHOD) {
+    if (!legacyReceipt) {
+      return { valid: false, reason: "legacy_receipt_missing" };
+    }
+    const legacyVerification = verifyReceipt(
+      legacyReceipt.opreturn_hex,
+      Buffer.from(canonicalize(ceb), "utf8")
+    );
+    if (!legacyVerification.valid) {
+      return { valid: false, reason: `legacy_receipt_${legacyVerification.reason}` };
+    }
+    if (normalizeString(legacyReceipt.agent_id).toLowerCase() !== normalizeString(legacyVerification.agent_id).toLowerCase()) {
+      return { valid: false, reason: "legacy_agent_id_mismatch" };
+    }
+    if (normalizeString(receipt.signature).toLowerCase() !== normalizeString(legacyReceipt.opreturn_hex).toLowerCase()) {
+      return { valid: false, reason: "signature_legacy_mismatch" };
+    }
+    return {
+      valid: true,
+      method,
+      verification_state: "verified_legacy_opreturn"
+    };
+  }
+
+  if (algorithm === XOONYA_NATIVE_SHA256_METHOD) {
+    const expectedSignature = buildNativeReceiptSignature(receipt, ceb);
+    if (normalizeString(receipt.signature) !== expectedSignature) {
+      return { valid: false, reason: "signature_native_mismatch" };
+    }
+    return {
+      valid: true,
+      method,
+      verification_state: "verified_native_digest"
+    };
+  }
+
+  if (algorithm === XOONYA_NATIVE_SIGNED_METHOD) {
+    const verification = verifyNativeSignedReceiptProof(receipt, ceb);
+    if (!verification.valid) {
+      return { valid: false, reason: verification.reason };
+    }
+    return {
+      valid: true,
+      method,
+      verification_state: verification.verification_state,
+      signature_suite: verification.signature_suite
+    };
+  }
+
+  if (algorithm === XOONYA_NATIVE_ANCHORED_METHOD) {
+    const verification = verifyNativeAnchoredReceiptProof(receipt, ceb, bundle);
+    if (!verification.valid) {
+      return { valid: false, reason: verification.reason };
+    }
+    return {
+      valid: true,
+      method,
+      verification_state: verification.verification_state,
+      anchor_count: verification.anchor_count,
+      anchor_root_sha256: verification.anchor_root_sha256
+    };
+  }
+
+  if (isExternalAssertionMethod(algorithm)) {
+    const signature = normalizeString(receipt.signature);
+    if (
+      signature.startsWith(`${XOONYA_NATIVE_SHA256_METHOD}:`) ||
+      signature.startsWith(`${XOONYA_NATIVE_SIGNED_METHOD}:`) ||
+      signature.startsWith(`${XOONYA_NATIVE_ANCHORED_METHOD}:`)
+    ) {
+      return { valid: false, reason: "signature_method_mismatch" };
+    }
+    return {
+      valid: true,
+      method,
+      verification_state: algorithm === DETACHED_ASSERTION_METHOD
+        ? "accepted_detached_assertion"
+        : "accepted_external_proof_envelope"
+    };
+  }
+
+  return { valid: false, reason: "verification_method_unsupported" };
+}
+
 function buildProofBundle(input) {
   if (!input || typeof input !== "object" || Array.isArray(input)) {
     throw new Error("input must be an object");
   }
   const ceb = canonicalizeEvent(input.ceb || input.event);
-  const receipt = input.receipt || emitReceipt(ceb, input.receipt_options || {});
+  const anchors = Array.isArray(input.anchors) ? input.anchors : undefined;
+  const receiptOptions = input.receipt_options && typeof input.receipt_options === "object" && !Array.isArray(input.receipt_options)
+    ? input.receipt_options
+    : {};
+  const receipt = input.receipt || emitReceipt(ceb, {
+    ...receiptOptions,
+    ...(anchors && receiptOptions.anchors == null && receiptOptions.native_anchor_refs == null && receiptOptions.anchor_refs == null
+      ? { anchors }
+      : {})
+  });
   return {
     version: PROOF_BUNDLE_VERSION,
     ceb,
     receipt,
-    anchors: Array.isArray(input.anchors) ? input.anchors : undefined,
+    anchors,
     attestations: Array.isArray(input.attestations) ? input.attestations : undefined,
     evidence_refs: Array.isArray(input.evidence_refs) ? input.evidence_refs : undefined,
     batch_refs: Array.isArray(input.batch_refs) ? input.batch_refs : undefined,
@@ -272,21 +1224,9 @@ function verifyProofBundle(bundle) {
       return { valid: false, reason: "signature_missing" };
     }
 
-    const legacyReceipt = receipt.compatibility && receipt.compatibility.legacy_receipt;
-    if (legacyReceipt) {
-      const legacyVerification = verifyReceipt(
-        legacyReceipt.opreturn_hex,
-        Buffer.from(canonicalize(ceb), "utf8")
-      );
-      if (!legacyVerification.valid) {
-        return { valid: false, reason: `legacy_receipt_${legacyVerification.reason}` };
-      }
-      if (normalizeString(legacyReceipt.agent_id).toLowerCase() !== normalizeString(legacyVerification.agent_id).toLowerCase()) {
-        return { valid: false, reason: "legacy_agent_id_mismatch" };
-      }
-      if (normalizeString(receipt.signature).toLowerCase() !== normalizeString(legacyReceipt.opreturn_hex).toLowerCase()) {
-        return { valid: false, reason: "signature_legacy_mismatch" };
-      }
+    const methodVerification = verifyReceiptProofMethod(receipt, ceb, bundle);
+    if (!methodVerification.valid) {
+      return { valid: false, reason: methodVerification.reason };
     }
 
     return {
@@ -294,7 +1234,13 @@ function verifyProofBundle(bundle) {
       reason: null,
       version: PROOF_BUNDLE_VERSION,
       event_commitment: expectedCommitment,
-      receipt_id: expectedReceiptId
+      receipt_id: expectedReceiptId,
+      verification_method: methodVerification.method.id,
+      verification_method_family: methodVerification.method.family,
+      verification_state: methodVerification.verification_state,
+      ...(methodVerification.anchor_count != null ? { anchor_count: methodVerification.anchor_count } : {}),
+      ...(methodVerification.anchor_root_sha256 ? { anchor_root_sha256: methodVerification.anchor_root_sha256 } : {}),
+      ...(methodVerification.signature_suite ? { signature_suite: methodVerification.signature_suite } : {})
     };
   } catch (error) {
     return { valid: false, reason: error.message };
@@ -513,27 +1459,292 @@ function verifyReceiptV2(opreturnHex, payloadBytes) {
   };
 }
 
-function createProofEnvelopeV1(opreturnHex, proofs, metadata = {}) {
-  const receiptRef = parseReceipt(opreturnHex);
-  const normalizedProofs = Array.isArray(proofs) ? proofs.map(normalizeProofEntry) : [];
-  if (normalizedProofs.length === 0) throw new Error("proofs must be a non-empty array");
-  const proofIds = new Set();
-  normalizedProofs.forEach((proof) => {
-    if (proofIds.has(proof.proof_id)) throw new Error(`duplicate proof_id: ${proof.proof_id}`);
-    proofIds.add(proof.proof_id);
-  });
-  return {
-    envelope_version: PROOF_ENVELOPE_VERSION,
-    receipt_ref: {
-      opreturn_hex: receiptRef.opreturn_hex,
-      spec_version: receiptRef.spec_version,
-      receipt_hash_sha256: receiptRef.receipt_hash_sha256,
-      payload_hash_sha256: receiptRef.payload_hash_sha256
-    },
-    proofs: normalizedProofs,
-    binding_hash_sha256: canonicalJsonSha256Hex(makeProofEnvelopeBindingMaterial(receiptRef, normalizedProofs)),
-    metadata: metadata && typeof metadata === "object" && !Array.isArray(metadata) ? metadata : {}
-  };
+function normalizeXoonyaNativeAtomType(typeHex = TYPE_REGISTER) {
+  const type = assertHex(typeHex, 2, "typeHex");
+  if (!VALID_TYPES.has(type)) {
+    throw new Error("typeHex must be 01, 02, or 03");
+  }
+  return type;
+}
+
+function atomValidationError(code, message) {
+  const error = new Error(message);
+  error.code = code;
+  return error;
+}
+
+function normalizeXoonyaNativeIdentityMaterial(identityMaterialHex) {
+  const materialHex = assertVariableHex(identityMaterialHex, "identityMaterialHex");
+  const typePrefix = materialHex.slice(0, 2);
+  if (!XOONYA_NATIVE_IDENTITY_TYPES[typePrefix]) {
+    throw atomValidationError(
+      XNYA_NATIVE_ATOM_ERROR_CODES.IDENTITY_UNSUPPORTED_TYPE_PREFIX,
+      "identityMaterialHex has unsupported identity type prefix"
+    );
+  }
+  if (materialHex.length === 2) {
+    throw atomValidationError(
+      XNYA_NATIVE_ATOM_ERROR_CODES.IDENTITY_MISSING_RAW_BYTES,
+      "identityMaterialHex must include raw identity bytes"
+    );
+  }
+  return materialHex;
+}
+
+function hashXoonyaNativePayload(payloadBytes, domainSeparator) {
+  if (!payloadBytes || payloadBytes.length === 0) {
+    return ZERO_HASH32;
+  }
+  const digest = sha256Hex(Buffer.concat([
+    Buffer.from(domainSeparator, "utf8"),
+    Buffer.from(payloadBytes)
+  ]));
+  if (digest === ZERO_HASH32) {
+    throw new Error("payload hash cannot equal the absent-payload sentinel");
+  }
+  return digest;
+}
+
+function createXoonyaNativeAtomV1(identityMaterialHex, payloadBytes, typeHex = TYPE_REGISTER) {
+  const materialHex = normalizeXoonyaNativeIdentityMaterial(identityMaterialHex);
+  const type = normalizeXoonyaNativeAtomType(typeHex);
+  const agentId = hash160Hex(Buffer.concat([
+    Buffer.from(XNYA_DS_AGENT_V1, "utf8"),
+    Buffer.from(materialHex, "hex")
+  ]));
+  const payloadHash = hashXoonyaNativePayload(payloadBytes, XNYA_DS_PAYLOAD_V1);
+  const atomHex = XOONYA_NATIVE_ATOM_MAGIC_HEX + VERSION_V1_HEX + type + agentId + payloadHash;
+  return {
+    atom_hex: atomHex,
+    magic: XOONYA_NATIVE_ATOM_MAGIC_ASCII,
+    atom_version: XOONYA_NATIVE_ATOM_V1,
+    spec_version: "v1",
+    byte_length: 58,
+    record_type_hex: type,
+    agent_id: agentId,
+    payload_hash_sha256: payloadHash,
+    identity_type_prefix: materialHex.slice(0, 2),
+    domain_separation: {
+      agent: XNYA_DS_AGENT_V1,
+      payload: XNYA_DS_PAYLOAD_V1
+    }
+  };
+}
+
+function createXoonyaNativeAtomV2(identityMaterialHex, payloadBytes, typeHex = TYPE_REGISTER) {
+  const materialHex = normalizeXoonyaNativeIdentityMaterial(identityMaterialHex);
+  const type = normalizeXoonyaNativeAtomType(typeHex);
+  const agentId = sha256Hex(Buffer.concat([
+    Buffer.from(XNYA_DS_AGENT_V2, "utf8"),
+    Buffer.from(materialHex, "hex")
+  ]));
+  const payloadHash = hashXoonyaNativePayload(payloadBytes, XNYA_DS_PAYLOAD_V2);
+  const atomHex = XOONYA_NATIVE_ATOM_MAGIC_HEX + VERSION_V2_HEX + type + agentId + payloadHash;
+  return {
+    atom_hex: atomHex,
+    magic: XOONYA_NATIVE_ATOM_MAGIC_ASCII,
+    atom_version: XOONYA_NATIVE_ATOM_V2,
+    spec_version: "v2",
+    byte_length: 70,
+    record_type_hex: type,
+    agent_id: agentId,
+    payload_hash_sha256: payloadHash,
+    identity_type_prefix: materialHex.slice(0, 2),
+    domain_separation: {
+      agent: XNYA_DS_AGENT_V2,
+      payload: XNYA_DS_PAYLOAD_V2
+    }
+  };
+}
+
+function parseXoonyaNativeAtom(atomHex) {
+  const hex = String(atomHex || "").trim().toLowerCase();
+  if (!/^[a-f0-9]+$/.test(hex)) {
+    throw atomValidationError(XNYA_NATIVE_ATOM_ERROR_CODES.ATOM_HEX_NOT_HEX, "atomHex must be hex");
+  }
+  if (hex.length !== 116 && hex.length !== 140) {
+    throw atomValidationError(
+      XNYA_NATIVE_ATOM_ERROR_CODES.ATOM_UNSUPPORTED_LENGTH,
+      "atomHex must be a supported Xoonya native atom"
+    );
+  }
+  const magic = hex.slice(0, 8);
+  const version = hex.slice(8, 10);
+  const recordType = hex.slice(10, 12);
+  if (magic !== XOONYA_NATIVE_ATOM_MAGIC_HEX.toLowerCase()) {
+    throw atomValidationError(
+      XNYA_NATIVE_ATOM_ERROR_CODES.ATOM_BAD_MAGIC,
+      "atomHex has bad Xoonya native atom magic"
+    );
+  }
+  if (!VALID_TYPES.has(recordType)) {
+    throw atomValidationError(
+      XNYA_NATIVE_ATOM_ERROR_CODES.ATOM_UNSUPPORTED_RECORD_TYPE,
+      "atomHex has unsupported record type"
+    );
+  }
+  if (version === VERSION_V1_HEX && hex.length === 116) {
+    const agentId = hex.slice(12, 52);
+    const payloadHash = hex.slice(52, 116);
+    return {
+      atom_version: XOONYA_NATIVE_ATOM_V1,
+      spec_version: "v1",
+      byte_length: 58,
+      record_type_hex: recordType,
+      agent_id: agentId,
+      payload_hash_sha256: payloadHash,
+      atom_hash_sha256: sha256Hex(Buffer.from(hex, "hex")),
+      atom_hex: hex
+    };
+  }
+  if (version === VERSION_V2_HEX && hex.length === 140) {
+    const agentId = hex.slice(12, 76);
+    const payloadHash = hex.slice(76, 140);
+    return {
+      atom_version: XOONYA_NATIVE_ATOM_V2,
+      spec_version: "v2",
+      byte_length: 70,
+      record_type_hex: recordType,
+      agent_id: agentId,
+      payload_hash_sha256: payloadHash,
+      atom_hash_sha256: sha256Hex(Buffer.from(hex, "hex")),
+      atom_hex: hex
+    };
+  }
+  throw atomValidationError(
+    XNYA_NATIVE_ATOM_ERROR_CODES.ATOM_VERSION_LENGTH_MISMATCH,
+    "atomHex/version length mismatch"
+  );
+}
+
+function verifyXoonyaNativeAtom(atomHex, options = {}) {
+  try {
+    const parsed = parseXoonyaNativeAtom(atomHex);
+    const hasIdentityMaterial = options.identity_material_hex != null;
+    if (hasIdentityMaterial) {
+      const materialHex = normalizeXoonyaNativeIdentityMaterial(options.identity_material_hex);
+      const expectedAgentId = parsed.spec_version === "v1"
+        ? hash160Hex(Buffer.concat([Buffer.from(XNYA_DS_AGENT_V1, "utf8"), Buffer.from(materialHex, "hex")]))
+        : sha256Hex(Buffer.concat([Buffer.from(XNYA_DS_AGENT_V2, "utf8"), Buffer.from(materialHex, "hex")]));
+      if (parsed.agent_id !== expectedAgentId) {
+        return {
+          valid: false,
+          reason: "agent_id_mismatch",
+          error_code: XNYA_NATIVE_ATOM_ERROR_CODES.AGENT_ID_MISMATCH,
+          ...parsed
+        };
+      }
+    }
+
+    const hasPayload = options.payload_bytes != null;
+    if (hasPayload) {
+      const payloadHash = parsed.spec_version === "v1"
+        ? hashXoonyaNativePayload(options.payload_bytes, XNYA_DS_PAYLOAD_V1)
+        : hashXoonyaNativePayload(options.payload_bytes, XNYA_DS_PAYLOAD_V2);
+      if (payloadHash !== parsed.payload_hash_sha256) {
+        return {
+          valid: false,
+          reason: "payload_hash_mismatch",
+          error_code: XNYA_NATIVE_ATOM_ERROR_CODES.PAYLOAD_HASH_MISMATCH,
+          ...parsed
+        };
+      }
+    } else if (parsed.payload_hash_sha256 === ZERO_HASH32) {
+      return { valid: true, reason: null, error_code: null, payload_state: "absent", ...parsed };
+    }
+
+    return {
+      valid: true,
+      reason: null,
+      error_code: null,
+      payload_state: parsed.payload_hash_sha256 === ZERO_HASH32 ? "absent" : "committed",
+      ...parsed
+    };
+  } catch (error) {
+    return { valid: false, reason: error.message, error_code: error.code || "native_atom_validation_error" };
+  }
+}
+
+function createXoonyaNativeLineRateFrameV1(atomHex) {
+  const parsed = parseXoonyaNativeAtom(atomHex);
+  const atomBytes = Buffer.from(parsed.atom_hex, "hex");
+  const checksumHex = lineRateFrameChecksum(atomBytes);
+  return {
+    profile: XOONYA_NATIVE_LINE_RATE_FRAME_V1,
+    frame_hex: `${parsed.atom_hex}${checksumHex}`,
+    atom_hex: parsed.atom_hex,
+    atom_version: parsed.atom_version,
+    atom_byte_length: parsed.byte_length,
+    frame_byte_length: parsed.byte_length + 2,
+    checksum_hex: checksumHex,
+    checksum_rule: "first_2_bytes_sha256(domain_separator || atom_bytes)"
+  };
+}
+
+function parseXoonyaNativeLineRateFrameV1(frameHex) {
+  const hex = assertVariableHex(frameHex, "line-rate frame");
+  const byteLength = hex.length / 2;
+  if (![60, 72].includes(byteLength)) {
+    throw new Error("line-rate frame unsupported length");
+  }
+  const atomHex = hex.slice(0, -4);
+  const checksumHex = hex.slice(-4);
+  const parsedAtom = parseXoonyaNativeAtom(atomHex);
+  const expectedChecksum = lineRateFrameChecksum(Buffer.from(parsedAtom.atom_hex, "hex"));
+  return {
+    profile: XOONYA_NATIVE_LINE_RATE_FRAME_V1,
+    frame_hex: hex,
+    atom_hex: parsedAtom.atom_hex,
+    atom_version: parsedAtom.atom_version,
+    atom_byte_length: parsedAtom.byte_length,
+    frame_byte_length: byteLength,
+    checksum_hex: checksumHex,
+    expected_checksum_hex: expectedChecksum,
+    checksum_valid: checksumHex === expectedChecksum
+  };
+}
+
+function verifyXoonyaNativeLineRateFrameV1(frameHex, options = {}) {
+  try {
+    const parsedFrame = parseXoonyaNativeLineRateFrameV1(frameHex);
+    if (!parsedFrame.checksum_valid) {
+      return { valid: false, reason: "line_rate_frame_checksum_mismatch", parsed_frame: parsedFrame };
+    }
+    const atomVerification = verifyXoonyaNativeAtom(parsedFrame.atom_hex, options);
+    if (!atomVerification.valid) {
+      return { valid: false, reason: `line_rate_frame_atom_${atomVerification.reason}`, parsed_frame: parsedFrame, atom_verification: atomVerification };
+    }
+    return {
+      valid: true,
+      parsed_frame: parsedFrame,
+      atom_verification: atomVerification
+    };
+  } catch (error) {
+    return { valid: false, reason: error.message };
+  }
+}
+
+function createProofEnvelopeV1(opreturnHex, proofs, metadata = {}) {
+  const receiptRef = parseReceipt(opreturnHex);
+  const normalizedProofs = Array.isArray(proofs) ? proofs.map(normalizeProofEntry) : [];
+  if (normalizedProofs.length === 0) throw new Error("proofs must be a non-empty array");
+  const proofIds = new Set();
+  normalizedProofs.forEach((proof) => {
+    if (proofIds.has(proof.proof_id)) throw new Error(`duplicate proof_id: ${proof.proof_id}`);
+    proofIds.add(proof.proof_id);
+  });
+  return {
+    envelope_version: PROOF_ENVELOPE_VERSION,
+    receipt_ref: {
+      opreturn_hex: receiptRef.opreturn_hex,
+      spec_version: receiptRef.spec_version,
+      receipt_hash_sha256: receiptRef.receipt_hash_sha256,
+      payload_hash_sha256: receiptRef.payload_hash_sha256
+    },
+    proofs: normalizedProofs,
+    binding_hash_sha256: canonicalJsonSha256Hex(makeProofEnvelopeBindingMaterial(receiptRef, normalizedProofs)),
+    metadata: metadata && typeof metadata === "object" && !Array.isArray(metadata) ? metadata : {}
+  };
 }
 
 function verifyProofEnvelopeV1(envelope) {
@@ -746,8 +1957,12 @@ function buildDefaultProofCenter() {
         "verifyReceipt",
         "createReceiptV2",
         "verifyReceiptV2",
+        "createXoonyaNativeAtomV1",
+        "createXoonyaNativeAtomV2",
+        "verifyXoonyaNativeAtom",
         "createProofEnvelopeV1",
-        "verifyProofEnvelopeV1"
+        "verifyProofEnvelopeV1",
+        "runExternalProofImport"
       ],
       posture: "compatibility_helpers_preserved_but_not_public_center"
     },
@@ -756,14 +1971,16 @@ function buildDefaultProofCenter() {
       "/v1/events/hash",
       "/v1/receipts/emit",
       "/v1/proof-bundles/build",
-      "/v1/proof-bundles/verify"
+      "/v1/proof-bundles/verify",
+      "/v1/proof-center/import-adapter/run"
     ],
     suggested_package_flow: [
       "canonicalizeEvent",
       "hashEvent",
       "emitReceipt",
       "buildProofBundle",
-      "verifyProofBundle"
+      "verifyProofBundle",
+      "runExternalProofImport"
     ],
     proof_posture: {
       deterministic: true,
@@ -771,7 +1988,8 @@ function buildDefaultProofCenter() {
       replayable: true,
       settlement_agnostic: true,
       workflow_agnostic: true
-    }
+    },
+    verification_methods: listProofVerificationMethods()
   };
 }
 
@@ -789,10 +2007,1097 @@ function summarizeDefaultProofCenter() {
     compatibility_helper_count: Array.isArray(center.compatibility_surface.preserved_helpers)
       ? center.compatibility_surface.preserved_helpers.length
       : 0,
+    verification_method_count: Array.isArray(center.verification_methods) ? center.verification_methods.length : 0,
+    external_verification_method_count: Array.isArray(center.verification_methods)
+      ? center.verification_methods.filter((method) => method.verification_posture === "structure_verified_external_signature").length
+      : 0,
+    verification_methods: Array.isArray(center.verification_methods)
+      ? center.verification_methods.map((method) => method.id)
+      : [],
     proof_posture: center.proof_posture
   };
 }
 
+function normalizeExternalProofMaterial(value) {
+  if (typeof value === "string") {
+    const compact = normalizeString(value);
+    if (!compact) {
+      throw new Error("external_proof_material_empty");
+    }
+    return {
+      material_kind: "compact",
+      material: compact,
+      canonical_material: compact,
+      material_hash_sha256: sha256Hex(Buffer.from(compact, "utf8"))
+    };
+  }
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    if (Object.keys(value).length === 0) {
+      throw new Error("external_proof_material_empty");
+    }
+    const canonicalMaterial = canonicalize(value);
+    return {
+      material_kind: "object",
+      material: value,
+      canonical_material: canonicalMaterial,
+      material_hash_sha256: sha256Hex(Buffer.from(canonicalMaterial, "utf8"))
+    };
+  }
+  throw new Error("external_proof_material_required");
+}
+
+function pickExternalProofMaterial(body) {
+  if (body.external_proof != null) return body.external_proof;
+  if (body.external_envelope != null) return body.external_envelope;
+  if (body.proof_envelope != null) return body.proof_envelope;
+  if (body.proof_material != null) return body.proof_material;
+  if (body.token != null) return body.token;
+  if (body.compact != null) return body.compact;
+  return undefined;
+}
+
+function normalizeExternalProofImport(input) {
+  const body = input && typeof input === "object" && !Array.isArray(input) ? input : {};
+  const method = normalizeString(body.method || body.verification_method || body.proof_method);
+  if (!method) {
+    throw new Error("verification_method_required");
+  }
+  const methodInfo = getProofVerificationMethod(method);
+  if (!methodInfo) {
+    throw new Error("verification_method_unsupported");
+  }
+  if (!EXTERNAL_PROOF_IMPORT_METHODS.includes(method)) {
+    throw new Error("verification_method_not_external_importable");
+  }
+  const material = normalizeExternalProofMaterial(pickExternalProofMaterial(body));
+  const declaredHash = normalizeString(body.declared_hash_sha256 || body.external_hash_sha256).toLowerCase();
+  if (declaredHash && declaredHash !== material.material_hash_sha256) {
+    throw new Error("external_proof_hash_mismatch");
+  }
+  const importRef = normalizeString(body.import_ref || body.external_ref || `external-proof.${material.material_hash_sha256.slice(0, 16)}`);
+  const issuerRef = normalizeString(body.issuer_ref || body.issuer || `${method}.issuer`);
+  const subjectRef = normalizeString(body.subject_ref || body.subject || importRef);
+  const evidenceRefs = normalizeStringArray(body.evidence_refs, "evidence_refs") || [];
+  const profileRefs = normalizeStringArray(body.profile_refs, "profile_refs") || [];
+  const receivedAtIso = normalizeString(body.received_at_iso);
+  const policyRef = normalizeString(body.policy_ref);
+  return {
+    method,
+    method_family: methodInfo.family,
+    verification_posture: methodInfo.verification_posture,
+    import_ref: importRef,
+    issuer_ref: issuerRef,
+    subject_ref: subjectRef,
+    material_kind: material.material_kind,
+    external_proof_material_hash_sha256: material.material_hash_sha256,
+    declared_hash_sha256: declaredHash || null,
+    evidence_refs: evidenceRefs,
+    profile_refs: profileRefs,
+    received_at_iso: receivedAtIso || null,
+    policy_ref: policyRef || null,
+    material: material.material
+  };
+}
+
+function buildExternalProofImportAdapterPack() {
+  return {
+    ok: true,
+    product: "xoonya",
+    category: "xoonya-external-proof-import-adapter",
+    adapter_version: "xoonya-external-proof-import-adapter-v1",
+    posture: "method_agnostic_external_proof_intake_into_canonical_xoonya_bundles",
+    supported_methods: EXTERNAL_PROOF_IMPORT_METHODS.map((method) => {
+      const methodInfo = getProofVerificationMethod(method);
+      return {
+        method,
+        family: methodInfo ? methodInfo.family : null,
+        verification_posture: methodInfo ? methodInfo.verification_posture : null
+      };
+    }),
+    required_fields: [
+      "method",
+      "external_proof"
+    ],
+    optional_fields: [
+      "import_ref",
+      "external_ref",
+      "issuer_ref",
+      "subject_ref",
+      "declared_hash_sha256",
+      "evidence_refs",
+      "profile_refs",
+      "policy_ref",
+      "received_at_iso"
+    ],
+    output_artifacts: [
+      "canonical_event",
+      "receipt",
+      "proof_bundle",
+      "bundle_verification",
+      "import_review"
+    ],
+    verification_boundary: {
+      xoonya_verifies: [
+        "registered_method",
+        "external_material_hash",
+        "declared_hash_when_supplied",
+        "canonical_event_binding",
+        "proof_bundle_shape",
+        "receipt_method_binding"
+      ],
+      external_verifier_retains: [
+        "issuer_cryptographic_truth",
+        "credential_revocation_status",
+        "did_resolution",
+        "jwt_jws_signature_truth",
+        "partner_policy_decision"
+      ]
+    },
+    linked_surfaces: {
+      proof_center_ref: "/v1/proof-center",
+      import_adapter_summary_ref: "/v1/proof-center/import-adapter/summary",
+      import_review_ref: "/v1/proof-center/import-adapter/review",
+      import_run_ref: "/v1/proof-center/import-adapter/run",
+      native_standard_ref: "/v1/proof-center/native-standard"
+    }
+  };
+}
+
+function summarizeExternalProofImportAdapterPack() {
+  const pack = buildExternalProofImportAdapterPack();
+  return {
+    ok: true,
+    product: pack.product,
+    category: "xoonya-external-proof-import-adapter-summary",
+    summary_version: "xoonya-external-proof-import-adapter-summary-v1",
+    posture: pack.posture,
+    supported_method_count: pack.supported_methods.length,
+    supported_methods: pack.supported_methods.map((entry) => entry.method),
+    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,
+    linked_surfaces: pack.linked_surfaces
+  };
+}
+
+function reviewExternalProofImport(input) {
+  const imported = normalizeExternalProofImport(input);
+  return {
+    ok: true,
+    product: "xoonya",
+    category: "xoonya-external-proof-import-review",
+    review_version: "xoonya-external-proof-import-review-v1",
+    accepted: true,
+    import_ref: imported.import_ref,
+    method: imported.method,
+    method_family: imported.method_family,
+    verification_posture: imported.verification_posture,
+    material_kind: imported.material_kind,
+    external_proof_material_hash_sha256: imported.external_proof_material_hash_sha256,
+    issuer_ref: imported.issuer_ref,
+    subject_ref: imported.subject_ref,
+    evidence_ref_count: imported.evidence_refs.length,
+    profile_ref_count: imported.profile_refs.length,
+    boundary: "xoonya_imports_and_binds_external_evidence_without_claiming_external_issuer_truth",
+    run_surface: "/v1/proof-center/import-adapter/run"
+  };
+}
+
+function summarizeExternalProofImportReview(input) {
+  const review = reviewExternalProofImport(input);
+  return {
+    ok: review.ok,
+    category: "xoonya-external-proof-import-review-summary",
+    import_ref: review.import_ref,
+    method: review.method,
+    method_family: review.method_family,
+    accepted: review.accepted,
+    material_hash_present: Boolean(review.external_proof_material_hash_sha256),
+    evidence_ref_count: review.evidence_ref_count,
+    boundary: review.boundary,
+    run_surface: review.run_surface
+  };
+}
+
+function buildExternalProofImportEvent(imported) {
+  const importMaterial = {
+    evidence_refs: imported.evidence_refs,
+    external_proof_material_hash_sha256: imported.external_proof_material_hash_sha256,
+    import_ref: imported.import_ref,
+    issuer_ref: imported.issuer_ref,
+    method: imported.method,
+    method_family: imported.method_family,
+    profile_refs: imported.profile_refs,
+    subject_ref: imported.subject_ref
+  };
+  return canonicalizeEvent({
+    version: CANONICAL_EVENT_BUNDLE_VERSION,
+    domain_id: "xoonya.external_proof_import",
+    sequence: imported.import_ref,
+    actor_id: imported.issuer_ref,
+    adapter_source: "xoonya.external_proof_import_adapter",
+    event_type: `${imported.method}.imported`,
+    event_hash: canonicalJsonSha256Hex(importMaterial),
+    parent_refs: imported.evidence_refs,
+    semantic_slots: {
+      ...importMaterial,
+      received_at_iso: imported.received_at_iso,
+      policy_ref: imported.policy_ref,
+      verification_boundary: "external_issuer_truth_out_of_scope_for_import_adapter"
+    }
+  });
+}
+
+function runExternalProofImport(input) {
+  const imported = normalizeExternalProofImport(input);
+  const event = buildExternalProofImportEvent(imported);
+  const signature = `${imported.method}:${imported.external_proof_material_hash_sha256}`;
+  const receipt = emitReceipt(event, {
+    agent_identity: imported.issuer_ref,
+    algorithm: imported.method,
+    signature
+  });
+  const proofBundle = buildProofBundle({
+    ceb: event,
+    receipt,
+    evidence_refs: [
+      imported.import_ref,
+      ...imported.evidence_refs
+    ],
+    attestations: [
+      {
+        attestation_id: imported.import_ref,
+        attestation_kind: "external_proof_import",
+        method: imported.method,
+        issuer_ref: imported.issuer_ref,
+        subject_ref: imported.subject_ref,
+        material_hash_sha256: imported.external_proof_material_hash_sha256,
+        verification_boundary: "structure_and_binding_verified_external_truth_out_of_scope"
+      }
+    ],
+    metadata: {
+      import_adapter_version: "xoonya-external-proof-import-adapter-v1",
+      method_family: imported.method_family,
+      profile_refs: imported.profile_refs
+    }
+  });
+  const verification = verifyProofBundle(proofBundle);
+  return {
+    ok: verification.valid === true,
+    product: "xoonya",
+    category: "xoonya-external-proof-import-run",
+    import_ref: imported.import_ref,
+    import_review: reviewExternalProofImport(input),
+    canonical_event: event,
+    event_commitment: hashEvent(event),
+    receipt,
+    proof_bundle: proofBundle,
+    bundle_verification: verification,
+    boundary: "external_material_is_bound_into_xoonya_proof_bundle_external_cryptographic_truth_remains_with_external_verifier"
+  };
+}
+
+function summarizeExternalProofImportRun(input) {
+  const run = runExternalProofImport(input);
+  return {
+    ok: run.ok,
+    category: "xoonya-external-proof-import-run-summary",
+    import_ref: run.import_ref,
+    event_commitment: run.event_commitment,
+    receipt_id: run.receipt ? run.receipt.receipt_id : null,
+    proof_bundle_version: run.proof_bundle ? run.proof_bundle.version : null,
+    bundle_valid: run.bundle_verification ? run.bundle_verification.valid === true : false,
+    verification_method: run.bundle_verification ? run.bundle_verification.verification_method : null,
+    verification_state: run.bundle_verification ? run.bundle_verification.verification_state : null,
+    boundary: run.boundary
+  };
+}
+
+function buildXoonyaNativeAtomSpec() {
+  return {
+    ok: true,
+    product: "xoonya",
+    category: "xoonya-native-atom-spec",
+    spec_version: "xoonya-native-atom-spec/v1",
+    status: "formal_spec_pack_active",
+    canonical_magic: XOONYA_NATIVE_ATOM_MAGIC_ASCII,
+    canonical_magic_hex: XOONYA_NATIVE_ATOM_MAGIC_HEX.toLowerCase(),
+    canonical_magic_rule: "new_xoonya_native_atoms_use_xnya_only",
+    repo_strategy: {
+      current: "ship_inside_xoonya_package",
+      reason: "one_public_package_is_simpler_for_adoption_and_keeps_native_proof_near_verifier_implementation",
+      extraction_rule: "extract_to_separate_standards_repo_only_after_external_adoption_or_governance_pressure"
+    },
+    versions: [
+      {
+        atom_version: XOONYA_NATIVE_ATOM_V1,
+        version_byte: VERSION_V1_HEX,
+        fixed_size_bytes: 58,
+        field_layout: [
+          { field: "MAGIC", bytes: 4, value: XOONYA_NATIVE_ATOM_MAGIC_ASCII },
+          { field: "VERSION", bytes: 1, value: "0x01" },
+          { field: "TYPE", bytes: 1, values: ["0x01", "0x02", "0x03"] },
+          { field: "AGENT_ID", bytes: 20, derivation: `HASH160(${XNYA_DS_AGENT_V1} || identity_material)` },
+          { field: "PAYLOAD_HASH", bytes: 32, derivation: `SHA256(${XNYA_DS_PAYLOAD_V1} || payload_bytes) or zero sentinel when absent` }
+        ],
+        role: "classical minimal identity and payload commitment"
+      },
+      {
+        atom_version: XOONYA_NATIVE_ATOM_V2,
+        version_byte: VERSION_V2_HEX,
+        fixed_size_bytes: 70,
+        field_layout: [
+          { field: "MAGIC", bytes: 4, value: XOONYA_NATIVE_ATOM_MAGIC_ASCII },
+          { field: "VERSION", bytes: 1, value: "0x02" },
+          { field: "TYPE", bytes: 1, values: ["0x01", "0x02", "0x03"] },
+          { field: "AGENT_ID", bytes: 32, derivation: `SHA256(${XNYA_DS_AGENT_V2} || identity_material)` },
+          { field: "PAYLOAD_HASH", bytes: 32, derivation: `SHA256(${XNYA_DS_PAYLOAD_V2} || payload_bytes) or zero sentinel when absent` }
+        ],
+        role: "pq_horizon_identity_commitment_with_32_byte_agent_digest"
+      }
+    ],
+    validation_rules: [
+      "magic_must_equal_XNYA",
+      "version_must_match_length",
+      "type_must_be_01_02_or_03",
+      "identity_type_prefix_must_be_registered",
+      "wire_format_is_raw_bytes_hex_is_display_only",
+      "payload_absent_is_exactly_32_zero_bytes",
+      "present_payload_must_not_use_absent_zero_sentinel",
+      "signatures_timestamps_prices_settlement_refs_and_runtime_metadata_are_forbidden_in_atom"
+    ],
+    deterministic_error_codes: Object.values(XNYA_NATIVE_ATOM_ERROR_CODES),
+    identity_type_registry: listXoonyaNativeIdentityTypes(),
+    linked_surfaces: {
+      native_standard_ref: "/v1/proof-center/native-standard",
+      native_atom_spec_summary_ref: "/v1/proof-center/native-atom-spec/summary",
+      native_atom_conformance_ref: "/v1/proof-center/native-atom-conformance"
+    }
+  };
+}
+
+function summarizeXoonyaNativeAtomSpec() {
+  const spec = buildXoonyaNativeAtomSpec();
+  return {
+    ok: true,
+    product: spec.product,
+    category: "xoonya-native-atom-spec-summary",
+    spec_version: spec.spec_version,
+    status: spec.status,
+    canonical_magic: spec.canonical_magic,
+    version_count: spec.versions.length,
+    fixed_size_bytes: spec.versions.map((entry) => entry.fixed_size_bytes),
+    identity_type_count: spec.identity_type_registry.length,
+    deterministic_error_code_count: spec.deterministic_error_codes.length,
+    repo_strategy: spec.repo_strategy.current,
+    linked_surfaces: spec.linked_surfaces
+  };
+}
+
+function buildXoonyaNativeAtomConformancePack() {
+  const spec = buildXoonyaNativeAtomSpec();
+  return {
+    ok: true,
+    product: "xoonya",
+    category: "xoonya-native-atom-conformance-pack",
+    pack_version: "xoonya-native-atom-conformance-pack-v1",
+    status: "active",
+    canonical_magic: spec.canonical_magic,
+    atom_versions: spec.versions.map((entry) => ({
+      atom_version: entry.atom_version,
+      fixed_size_bytes: entry.fixed_size_bytes,
+      version_byte: entry.version_byte
+    })),
+    deterministic_error_codes: spec.deterministic_error_codes,
+    conformance_requirements: [
+      "emit_exact_v1_and_v2_vectors",
+      "parse_exact_field_boundaries",
+      "verify_identity_material_against_agent_id",
+      "verify_payload_bytes_against_payload_hash",
+      "reject_bad_magic",
+      "reject_bad_length",
+      "reject_unsupported_record_type",
+      "reject_version_length_mismatch",
+      "reject_unsupported_identity_type_prefix",
+      "return_stable_error_code_for_each_reject"
+    ],
+    adversarial_vector_categories: [
+      "non_hex",
+      "bad_length",
+      "bad_magic",
+      "unsupported_type",
+      "version_length_mismatch",
+      "payload_mismatch",
+      "agent_mismatch",
+      "unsupported_identity_prefix",
+      "identity_missing_raw_bytes"
+    ],
+    reference_vector_file: "vectors/native-atom-vectors.json",
+    validator_entrypoint: "verifyXoonyaNativeAtom(atomHex, { identity_material_hex, payload_bytes })",
+    public_claim_boundary: "Xoonya Native atom compatibility requires exact XNYA bytes, exact version lengths, exact hash derivation, and stable reject codes.",
+    linked_surfaces: {
+      native_atom_spec_ref: "/v1/proof-center/native-atom-spec",
+      native_atom_spec_summary_ref: "/v1/proof-center/native-atom-spec/summary",
+      native_atom_conformance_summary_ref: "/v1/proof-center/native-atom-conformance/summary"
+    }
+  };
+}
+
+function summarizeXoonyaNativeAtomConformancePack() {
+  const pack = buildXoonyaNativeAtomConformancePack();
+  return {
+    ok: true,
+    product: pack.product,
+    category: "xoonya-native-atom-conformance-summary",
+    summary_version: "xoonya-native-atom-conformance-summary-v1",
+    status: pack.status,
+    canonical_magic: pack.canonical_magic,
+    atom_version_count: pack.atom_versions.length,
+    deterministic_error_code_count: pack.deterministic_error_codes.length,
+    conformance_requirement_count: pack.conformance_requirements.length,
+    adversarial_vector_category_count: pack.adversarial_vector_categories.length,
+    reference_vector_file: pack.reference_vector_file,
+    linked_surfaces: pack.linked_surfaces
+  };
+}
+
+function buildXoonyaNativeProofStandard() {
+  return {
+    ok: true,
+    product: "xoonya",
+    category: "xoonya-native-proof-standard",
+    standard_version: XOONYA_NATIVE_PROOF_FORMAT_VERSION,
+    status: "design_contract_active",
+    posture: "optional_native_cold_truth_format_not_identity_or_auth_replacement",
+    design_doctrine: [
+      "xoonya_remains_method_agnostic",
+      "native_format_is_first_class_but_optional",
+      "external_formats_remain_interop_lanes",
+      "verification_methods_are_registry_backed",
+      "native_standard_optimizes_for_replayable_machine_proof_not_login_or_sessions"
+    ],
+    not_a_replacement_for: [
+      "JWT",
+      "OAuth",
+      "OIDC",
+      "DID/VC",
+      "SD-JWT VC",
+      "generic_credential_wallet_interop"
+    ],
+    native_design_carry_in: {
+      lineage: "fixed_atom_plus_proof_envelope",
+      durable_invention: [
+        "fixed_size_hot_path_commitment_atom",
+        "variable_size_cold_path_proof_envelope",
+        "semantic_free_core_bytes",
+        "strict_deterministic_validation",
+        "profile_layers_for_economics_registry_anchors_and_disputes"
+      ],
+      strategic_assessment: "substantial_native_machine_evidence_line_not_jwt_did_vc_reimplementation"
+    },
+    layer_model: [
+      {
+        layer: "L0",
+        name: "native_atom",
+        role: "fixed length identity and payload commitment"
+      },
+      {
+        layer: "L1",
+        name: "canonical_payload_or_intent",
+        role: "deterministic machine meaning committed by the atom, with optional strict binary payload profile"
+      },
+      {
+        layer: "L2",
+        name: "proof_envelope",
+        role: "signatures attestations anchors finality refs and external proof material"
+      },
+      {
+        layer: "L3",
+        name: "profiles",
+        role: "registry economic batch dispute and anchor evidence semantics"
+      },
+      {
+        layer: "L4",
+        name: "runtime_and_policy_consumers",
+        role: "systems that consume proof without redefining core bytes"
+      }
+    ],
+    hot_path_atom: {
+      candidate_version: XOONYA_NATIVE_ATOM_V1,
+      magic: XOONYA_NATIVE_ATOM_MAGIC_ASCII,
+      magic_hex: XOONYA_NATIVE_ATOM_MAGIC_HEX.toLowerCase(),
+      native_lineage: "xoonya-native-atom/v1",
+      fixed_size_bytes: 58,
+      shape: "MAGIC(4)|VERSION(1)|TYPE(1)|AGENT_ID(20)|PAYLOAD_HASH(32)",
+      core_boundary: "commitment_only_no_signatures_timestamps_prices_settlement_refs_or_runtime_metadata",
+      validation_posture: "strict_fixed_length_deterministic_rejects"
+    },
+    future_atom_candidates: [
+      {
+        candidate_version: XOONYA_NATIVE_ATOM_V1,
+        magic: XOONYA_NATIVE_ATOM_MAGIC_ASCII,
+        fixed_size_bytes: 58,
+        purpose: "classical minimal identity and payload commitment",
+        domain_separation: [
+          XNYA_DS_AGENT_V1,
+          XNYA_DS_PAYLOAD_V1
+        ]
+      },
+      {
+        candidate_version: XOONYA_NATIVE_ATOM_V2,
+        magic: XOONYA_NATIVE_ATOM_MAGIC_ASCII,
+        fixed_size_bytes: 70,
+        purpose: "pq_horizon_identity_commitment_with_32_byte_agent_digest",
+        domain_separation: [
+          XNYA_DS_AGENT_V2,
+          XNYA_DS_PAYLOAD_V2
+        ]
+      },
+      {
+        candidate_version: XOONYA_NATIVE_ATOM_V3_CONTINGENCY,
+        maturity: "not_an_implementation_target",
+        purpose: "future_digest_family_shift_only_if_sha256_assumptions_materially_change"
+      }
+    ],
+    atom_registry_policy: {
+      canonical_magic: XOONYA_NATIVE_ATOM_MAGIC_ASCII,
+      canonical_magic_status: "XNYA_is_the_only_canonical_magic_for_xoonya_native_atoms",
+      repo_strategy: "ship_inside_xoonya_package_first_extract_to_standards_repo_only_after_external_adoption_pressure",
+      identity_type_registry: listXoonyaNativeIdentityTypes()
+    },
+    object_model: [
+      {
+        object: "canonical_event",
+        version: CANONICAL_EVENT_BUNDLE_VERSION,
+        role: "deterministic machine event input"
+      },
+      {
+        object: "native_receipt",
+        version: CANONICAL_RECEIPT_VERSION,
+        role: "portable event commitment and proof-method boundary"
+      },
+      {
+        object: "proof_bundle",
+        version: PROOF_BUNDLE_VERSION,
+        role: "replayable verification container with optional references"
+      },
+      {
+        object: "native_envelope",
+        version: XOONYA_NATIVE_PROOF_FORMAT_VERSION,
+        role: "future formal wrapper for receipt, method, proof material, anchors, and attestations"
+      }
+    ],
+    current_native_methods: [
+      {
+        method: XOONYA_NATIVE_SHA256_METHOD,
+        maturity: "implemented",
+        purpose: "deterministic digest proof for replayable local proof integrity"
+      },
+      {
+        method: XOONYA_NATIVE_SIGNED_METHOD,
+        maturity: "implemented",
+        purpose: "native signature envelope with explicit signature-suite and public-key binding"
+      },
+      {
+        method: XOONYA_NATIVE_ANCHORED_METHOD,
+        maturity: "implemented",
+        purpose: "native anchor binding for chain, batch, finality, or external attestation references"
+      }
+    ],
+    planned_native_methods: [
+      {
+        method: XOONYA_NATIVE_HYBRID_METHOD,
+        maturity: "future_extension",
+        purpose: "stronger-crypto or PQC-sensitive proof lane without changing the native object model"
+      }
+    ],
+    supported_external_method_families: listProofVerificationMethods()
+      .filter((method) => method.verification_posture === "structure_verified_external_signature")
+      .map((method) => ({
+        method: method.id,
+        family: method.family,
+        posture: "interop_lane_external_verifier"
+      })),
+    native_signature_suite_policy: {
+      algorithm_policy: "pluggable_explicit_suite",
+      default_constraint: "no_single_algorithm_or_chain_is_mandatory",
+      implemented_suites: listNativeSignatureSuites()
+        .filter((suite) => suite.maturity === "implemented")
+        .map((suite) => suite.id),
+      suite_registry: listNativeSignatureSuites(),
+      required_fields_for_signed_native_method: [
+        "method",
+        "signature_suite",
+        "identity_ref",
+        "public_key_ref",
+        "proof_material"
+      ]
+    },
+    crypto_support_boundary: {
+      native_provides: [
+        "identity_commitment",
+        "payload_commitment",
+        "proof_binding",
+        "replayable_verification_material"
+      ],
+      native_does_not_provide: [
+        "encryption",
+        "forward_secrecy",
+        "transport_security",
+        "custody",
+        "access_control"
+      ],
+      cleanly_layers_with: [
+        "secp256k1",
+        "ed25519",
+        "p256",
+        "webauthn",
+        "did_vc",
+        "jwt_jws",
+        "sd_jwt_vc",
+        "dilithium",
+        "falcon",
+        "sphincs_plus",
+        "hpke",
+        "zk_proof_commitments"
+      ]
+    },
+    competitive_positioning: {
+      category: "deterministic_machine_evidence",
+      jwt_boundary: "jwt_wins_for_broad_web_signed_json_xoonya_native_wins_for_byte_stable_replayable_machine_proof",
+      did_vc_boundary: "did_vc_wins_for_rich_identity_credentials_xoonya_native_wins_for_compact_machine_receipts_and_proof_roots",
+      chain_proof_boundary: "chain_specific_proofs_win_on_native_settlement_xoonya_native_wins_cross_runtime_cross_rail_proof_continuity",
+      unique_claim: "minimal_deterministic_replayable_chain_neutral_machine_evidence_standard"
+    },
+    standardization_protection: {
+      technical_controls: [
+        "frozen_version_lines",
+        "canonical_conformance_vectors",
+        "adversarial_vectors",
+        "reference_validators",
+        "deterministic_error_codes",
+        "method_and_suite_registries",
+        "bounded_public_claims"
+      ],
+      legal_and_brand_controls: [
+        "tagged_releases_and_checksummed_specs",
+        "apache_2_0_implementation_licensing_where_intended",
+        "xoonya_name_and_conformance_mark_usage_rules",
+        "qualified_ip_counsel_for_patent_trademark_or_defensive_publication_strategy"
+      ]
+    },
+    standardization_steps: [
+      "publish_native_format_doc",
+      "freeze_xnya_atom_ladder_as_xoonya_native_lineage",
+      "add_xoonya_native_signed_v1_method",
+      "add_signature_suite_registry",
+      "add_native_signed_conformance_vectors",
+      "add_native_payload_profile_for_strict_binary_machine_evidence",
+      "add_optional_line_rate_frame_profile_for_transport_fast_reject",
+      "add_cross_runtime_canonicalization_vectors",
+      "add_anchor_and_attestation_reference_vectors",
+      "ship_external_proof_import_adapter_for_registered_interop_methods",
+      "keep_external_methods_as_interop_lanes"
+    ],
+    linked_surfaces: {
+      proof_center_summary_ref: "/v1/proof-center/summary",
+      native_standard_summary_ref: "/v1/proof-center/native-standard/summary",
+      native_atom_conformance_ref: "/v1/proof-center/native-atom-conformance",
+      native_anchor_profile_ref: "/v1/proof-center/native-anchor-profile",
+      native_payload_profile_ref: "/v1/proof-center/native-payload-profile",
+      native_line_rate_frame_ref: "/v1/proof-center/native-line-rate-frame",
+      external_import_adapter_ref: "/v1/proof-center/import-adapter",
+      verification_methods_ref: "/v1/proof-center",
+      default_loop_ref: "/v1/proof-center/default-loops/run"
+    }
+  };
+}
+
+function summarizeXoonyaNativeProofStandard() {
+  const standard = buildXoonyaNativeProofStandard();
+  return {
+    ok: true,
+    product: standard.product,
+    category: "xoonya-native-proof-standard-summary",
+    standard_version: standard.standard_version,
+    status: standard.status,
+    posture: standard.posture,
+    current_native_method_count: standard.current_native_methods.length,
+    planned_native_method_count: standard.planned_native_methods.length,
+    external_method_family_count: standard.supported_external_method_families.length,
+    object_count: standard.object_model.length,
+    doctrine_count: standard.design_doctrine.length,
+    native_design_lineage: standard.native_design_carry_in.lineage,
+    native_atom_magic: standard.hot_path_atom.magic,
+    native_hot_atom_fixed_size_bytes: standard.hot_path_atom.fixed_size_bytes,
+    future_atom_candidate_count: standard.future_atom_candidates.length,
+    native_identity_type_count: standard.atom_registry_policy.identity_type_registry.length,
+    layer_count: standard.layer_model.length,
+    competitive_category: standard.competitive_positioning.category,
+    native_methods: standard.current_native_methods.map((entry) => entry.method),
+    next_native_method: XOONYA_NATIVE_HYBRID_METHOD,
+    implemented_signature_suites: standard.native_signature_suite_policy.implemented_suites,
+    linked_surfaces: standard.linked_surfaces
+  };
+}
+
+function buildXoonyaNativeHybridReadinessPack() {
+  return {
+    ok: true,
+    product: "xoonya",
+    category: "xoonya-native-hybrid-readiness-pack",
+    pack_version: "xoonya-native-hybrid-readiness-v1",
+    method: XOONYA_NATIVE_HYBRID_METHOD,
+    status: "design_gated",
+    posture: "future_stronger_crypto_or_pqc_sensitive_lane_without_changing_xnya_atom_core",
+    current_decision: "do_not_claim_pqc_or_hybrid_verification_until_runtime_validators_and_vectors_exist",
+    implemented_classical_suites: listNativeSignatureSuites()
+      .filter((suite) => suite.maturity === "implemented")
+      .map((suite) => ({
+        suite: suite.id,
+        public_key_format: suite.public_key_format,
+        verification_posture: suite.verification_posture
+      })),
+    gated_candidate_suites: listNativeSignatureSuites()
+      .filter((suite) => suite.maturity !== "implemented")
+      .map((suite) => ({
+        suite: suite.id,
+        maturity: suite.maturity,
+        public_key_format: suite.public_key_format,
+        verification_posture: suite.verification_posture
+      })),
+    promotion_requirements: [
+      "runtime_validator_available_without_experimental_flags",
+      "positive_conformance_vectors",
+      "wrong_key_adversarial_vectors",
+      "tampered_signature_adversarial_vectors",
+      "downgrade_and_method_confusion_vectors",
+      "public_key_format_documented",
+      "deterministic_error_codes_documented",
+      "independent_reference_verifier_or_cross_runtime_vector"
+    ],
+    hybrid_object_model_boundary: {
+      atom_rule: "XNYA_atom_remains_commitment_only",
+      envelope_rule: "hybrid_or_pqc_material_lives_in_proof_envelope_or_profile",
+      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"
+    },
+    linked_surfaces: {
+      native_standard_ref: "/v1/proof-center/native-standard",
+      hybrid_readiness_summary_ref: "/v1/proof-center/native-hybrid-readiness/summary",
+      native_atom_spec_ref: "/v1/proof-center/native-atom-spec",
+      native_atom_conformance_ref: "/v1/proof-center/native-atom-conformance"
+    }
+  };
+}
+
+function summarizeXoonyaNativeHybridReadinessPack() {
+  const pack = buildXoonyaNativeHybridReadinessPack();
+  return {
+    ok: true,
+    product: pack.product,
+    category: "xoonya-native-hybrid-readiness-summary",
+    summary_version: "xoonya-native-hybrid-readiness-summary-v1",
+    method: pack.method,
+    status: pack.status,
+    posture: pack.posture,
+    implemented_classical_suite_count: pack.implemented_classical_suites.length,
+    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,
+    current_decision: pack.current_decision,
+    linked_surfaces: pack.linked_surfaces
+  };
+}
+
+function buildXoonyaNativePayloadProfilePack() {
+  return {
+    ok: true,
+    product: "xoonya",
+    category: "xoonya-native-payload-profile-pack",
+    profile_version: XOONYA_NATIVE_PAYLOAD_PROFILE_V1,
+    status: "implemented",
+    posture: "strict_canonical_binary_payload_profile_for_xnya_commitments",
+    binary_magic: "XNYP",
+    domain_separator: XNYA_DS_PAYLOAD_PROFILE_V1,
+    field_types: Object.entries(XNYA_PAYLOAD_FIELD_TYPES).map(([fieldType, spec]) => ({
+      field_type: fieldType,
+      field_type_id: spec.id,
+      fixed_length: spec.fixed_length || null,
+      max_length: spec.max_length || null
+    })),
+    canonical_rules: [
+      "binary_not_json",
+      "schema_ref_hash_is_committed",
+      "fields_sorted_by_uint16_field_id_then_type_id",
+      "duplicate_field_id_type_pairs_rejected",
+      "unknown_field_ids_can_be_rejected_by_verifier_policy",
+      "integers_are_big_endian_fixed_width",
+      "floats_null_undefined_functions_and_symbol_values_are_not_supported",
+      "payload_hash_is_sha256_domain_separator_plus_canonical_bytes"
+    ],
+    output_artifacts: [
+      "canonical_bytes_hex",
+      "payload_hash_sha256",
+      "schema_hash_sha256",
+      "field_count"
+    ],
+    example_profile: encodeXoonyaNativePayloadProfileV1({
+      schema_ref: "xoonya.payload.example.v1",
+      fields: [
+        { field_id: 1, field_type: "bytes32", value_hex: "11".repeat(32) },
+        { field_id: 2, field_type: "uint64", value: "42" },
+        { field_id: 3, field_type: "utf8", value: "example" },
+        { field_id: 4, field_type: "bool", value: true }
+      ]
+    }),
+    linked_surfaces: {
+      native_standard_ref: "/v1/proof-center/native-standard",
+      payload_profile_summary_ref: "/v1/proof-center/native-payload-profile/summary",
+      native_atom_spec_ref: "/v1/proof-center/native-atom-spec"
+    }
+  };
+}
+
+function summarizeXoonyaNativePayloadProfilePack() {
+  const pack = buildXoonyaNativePayloadProfilePack();
+  return {
+    ok: true,
+    product: pack.product,
+    category: "xoonya-native-payload-profile-summary",
+    summary_version: "xoonya-native-payload-profile-summary-v1",
+    profile_version: pack.profile_version,
+    status: pack.status,
+    binary_magic: pack.binary_magic,
+    field_type_count: pack.field_types.length,
+    canonical_rule_count: pack.canonical_rules.length,
+    output_artifact_count: pack.output_artifacts.length,
+    example_payload_hash_sha256: pack.example_profile.payload_hash_sha256,
+    linked_surfaces: pack.linked_surfaces
+  };
+}
+
+function buildXoonyaNativeLineRateFramePack() {
+  const exampleAtom = createXoonyaNativeAtomV1("01" + "22".repeat(33), Buffer.from("line-rate-example", "utf8"));
+  const exampleFrame = createXoonyaNativeLineRateFrameV1(exampleAtom.atom_hex);
+  return {
+    ok: true,
+    product: "xoonya",
+    category: "xoonya-native-line-rate-frame-pack",
+    profile_version: XOONYA_NATIVE_LINE_RATE_FRAME_V1,
+    status: "implemented_optional_transport_profile",
+    posture: "fast_reject_transport_wrapper_around_existing_xnya_atoms_without_changing_atom_layout",
+    checksum_rule: "first_2_bytes_sha256(domain_separator || atom_bytes)",
+    domain_separator: XNYA_DS_LINE_RATE_FRAME_V1,
+    supported_frame_sizes_bytes: [60, 72],
+    wrapped_atom_sizes_bytes: [58, 70],
+    validation_steps: [
+      "reject_non_hex",
+      "reject_unsupported_frame_length",
+      "parse_wrapped_xnya_atom",
+      "verify_2_byte_checksum_before_heavier_policy_checks",
+      "optionally_verify_identity_material_and_payload_bytes_against_wrapped_atom"
+    ],
+    boundary: "line_rate_frame_is_a_transport_fast_reject_profile_not_a_signature_encryption_or_finality_claim",
+    example_frame: exampleFrame,
+    linked_surfaces: {
+      native_standard_ref: "/v1/proof-center/native-standard",
+      line_rate_frame_summary_ref: "/v1/proof-center/native-line-rate-frame/summary",
+      native_atom_spec_ref: "/v1/proof-center/native-atom-spec"
+    }
+  };
+}
+
+function summarizeXoonyaNativeLineRateFramePack() {
+  const pack = buildXoonyaNativeLineRateFramePack();
+  return {
+    ok: true,
+    product: pack.product,
+    category: "xoonya-native-line-rate-frame-summary",
+    summary_version: "xoonya-native-line-rate-frame-summary-v1",
+    profile_version: pack.profile_version,
+    status: pack.status,
+    supported_frame_sizes_bytes: pack.supported_frame_sizes_bytes,
+    wrapped_atom_sizes_bytes: pack.wrapped_atom_sizes_bytes,
+    validation_step_count: pack.validation_steps.length,
+    checksum_rule: pack.checksum_rule,
+    boundary: pack.boundary,
+    linked_surfaces: pack.linked_surfaces
+  };
+}
+
+function buildXoonyaNativeStandardizationPack() {
+  return {
+    ok: true,
+    product: "xoonya",
+    category: "xoonya-native-standardization-pack",
+    pack_version: "xoonya-native-standardization-pack-v1",
+    standard: XOONYA_NATIVE_PROOF_FORMAT_VERSION,
+    canonical_magic: XOONYA_NATIVE_ATOM_MAGIC_ASCII,
+    posture: "formalize_xnya_as_optional_deterministic_machine_evidence_standard",
+    standardization_state: "package_embedded_reference_standard_ready_for_external_feedback",
+    public_claim: "minimal_deterministic_replayable_chain_neutral_machine_evidence_standard",
+    repo_strategy: "ship_inside_xoonya_until_external_adoption_or_governance_pressure_justifies_a_standards_repo",
+    conformance_mark_policy: {
+      mark: "XNYA-compatible",
+      allowed_only_when: [
+        "canonical_magic_is_XNYA",
+        "atom_version_and_fixed_size_match",
+        "payload_and_identity_hash_derivation_match_vectors",
+        "required_native_methods_verify_or_are_explicitly_declared_unsupported",
+        "adversarial_vectors_fail_with_stable_error_codes"
+      ],
+      not_allowed_when: [
+        "magic_or_atom_layout_is_changed",
+        "algorithm_none_is_accepted_as_production_proof",
+        "external_issuer_truth_is_claimed_without_external_verifier",
+        "pqc_or_hybrid_support_is_claimed_without_validators_and_vectors"
+      ]
+    },
+    standard_artifacts: [
+      "XOONYA_NATIVE_PROOF_FORMAT.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",
+      "/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"
+    ],
+    adoption_steps: [
+      "keep_xoonya_package_as_reference_implementation",
+      "publish_exact_vectors_and_error_codes_with_each_release",
+      "invite_external_verifier_implementations_against_vectors",
+      "open_a_standards_repo_only_after_real_external_adoption_pressure",
+      "define_conformance_mark_usage_before_third_party_claims",
+      "pursue_trademark_patent_or_defensive_publication_guidance_with_qualified_counsel"
+    ],
+    competitor_boundaries: {
+      jwt: "JWT remains better for broad web signed claims; XNYA optimizes byte-stable replayable machine evidence.",
+      did_vc: "DID/VC remains better for rich credentials; XNYA optimizes compact proof roots and deterministic receipts.",
+      cose_jws: "COSE/JWS remain envelope standards; XNYA can carry or bind them without becoming them.",
+      chain_specific_proofs: "Chain-native proofs remain authoritative for their chains; XNYA links cross-runtime proof continuity."
+    },
+    linked_surfaces: {
+      native_standard_ref: "/v1/proof-center/native-standard",
+      native_standardization_summary_ref: "/v1/proof-center/native-standardization/summary",
+      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",
+      import_adapter_ref: "/v1/proof-center/import-adapter"
+    }
+  };
+}
+
+function summarizeXoonyaNativeStandardizationPack() {
+  const pack = buildXoonyaNativeStandardizationPack();
+  return {
+    ok: true,
+    product: pack.product,
+    category: "xoonya-native-standardization-summary",
+    summary_version: "xoonya-native-standardization-summary-v1",
+    standard: pack.standard,
+    canonical_magic: pack.canonical_magic,
+    standardization_state: pack.standardization_state,
+    public_claim: pack.public_claim,
+    conformance_allowed_condition_count: pack.conformance_mark_policy.allowed_only_when.length,
+    conformance_forbidden_condition_count: pack.conformance_mark_policy.not_allowed_when.length,
+    artifact_count: pack.standard_artifacts.length,
+    adoption_step_count: pack.adoption_steps.length,
+    repo_strategy: pack.repo_strategy,
+    linked_surfaces: pack.linked_surfaces
+  };
+}
+
+function buildXoonyaNativeAnchorProfile() {
+  return {
+    ok: true,
+    product: "xoonya",
+    category: "xoonya-native-anchor-profile",
+    profile_version: "xoonya-native-anchor-profile/v1",
+    method: XOONYA_NATIVE_ANCHORED_METHOD,
+    status: "implemented",
+    posture: "optional_anchor_binding_without_external_finality_assertion",
+    verification_posture: "native_anchor_binding_verified",
+    core_boundary: "anchors_are_bound_to_receipt_and_event_commitment_without_changing_the_xnya_atom",
+    base_method: XOONYA_NATIVE_SHA256_METHOD,
+    supported_anchor_kinds: [
+      "chain_tx",
+      "batch_inclusion",
+      "finality_ref",
+      "external_attestation",
+      "content_hash"
+    ],
+    required_anchor_fields: [
+      "anchor_id",
+      "anchor_kind",
+      "anchor_ref",
+      "anchor_hash_sha256"
+    ],
+    optional_anchor_fields: [
+      "network",
+      "finality_state",
+      "observed_at_iso",
+      "provider_ref",
+      "inclusion_proof_ref"
+    ],
+    native_proof_shape: {
+      method: XOONYA_NATIVE_ANCHORED_METHOD,
+      base_method: XOONYA_NATIVE_SHA256_METHOD,
+      anchor_refs: "non_empty_sorted_canonical_anchor_refs",
+      proof_material: [
+        "anchor_root_sha256",
+        "binding_material_sha256"
+      ],
+      compact_signature: `${XOONYA_NATIVE_ANCHORED_METHOD}:<binding_material_sha256>`
+    },
+    validation_semantics: [
+      "normalize_anchor_refs_deterministically",
+      "require_bundle_anchors_to_match_native_proof_anchor_refs",
+      "verify_anchor_root_sha256",
+      "verify_binding_material_sha256",
+      "verify_compact_signature_binding",
+      "do_not_claim_external_chain_or_provider_finality"
+    ],
+    failure_reasons: [
+      "native_anchor_bundle_missing",
+      "native_anchor_bundle_mismatch",
+      "native_anchor_root_mismatch",
+      "native_anchor_binding_hash_mismatch",
+      "signature_native_anchored_mismatch"
+    ],
+    linked_surfaces: {
+      native_standard_ref: "/v1/proof-center/native-standard",
+      native_anchor_profile_summary_ref: "/v1/proof-center/native-anchor-profile/summary",
+      native_atom_spec_ref: "/v1/proof-center/native-atom-spec",
+      proof_center_ref: "/v1/proof-center"
+    }
+  };
+}
+
+function summarizeXoonyaNativeAnchorProfile() {
+  const profile = buildXoonyaNativeAnchorProfile();
+  return {
+    ok: true,
+    product: profile.product,
+    category: "xoonya-native-anchor-profile-summary",
+    summary_version: "xoonya-native-anchor-profile-summary-v1",
+    method: profile.method,
+    status: profile.status,
+    posture: profile.posture,
+    verification_posture: profile.verification_posture,
+    base_method: profile.base_method,
+    supported_anchor_kind_count: profile.supported_anchor_kinds.length,
+    required_anchor_field_count: profile.required_anchor_fields.length,
+    optional_anchor_field_count: profile.optional_anchor_fields.length,
+    failure_reason_count: profile.failure_reasons.length,
+    linked_surfaces: profile.linked_surfaces
+  };
+}
+
 function buildDefaultProofLoops() {
   const center = buildDefaultProofCenter();
   return [
@@ -2897,6 +5202,15 @@ module.exports = {
   buildDefaultProofCenter,
   buildDefaultProofLoopCatalog,
   buildDefaultProofLoops,
+  buildExternalProofImportAdapterPack,
+  buildXoonyaNativeHybridReadinessPack,
+  buildXoonyaNativeLineRateFramePack,
+  buildXoonyaNativePayloadProfilePack,
+  buildXoonyaNativeStandardizationPack,
+  buildXoonyaNativeAtomSpec,
+  buildXoonyaNativeAtomConformancePack,
+  buildXoonyaNativeProofStandard,
+  buildXoonyaNativeAnchorProfile,
   buildInteractionResultPackageHandoffCenter,
   buildInteractionSpineProofHandoffCenter,
   buildTransactionProofHandoffCenter,
@@ -2905,10 +5219,15 @@ module.exports = {
   buildTransactionProofHandoffEvent,
   canonicalizeInteractionResultPackageHandoff,
   canonicalizeInteractionSpineProofHandoff,
+  normalizeExternalProofImport,
   getDefaultProofLoop,
   canonicalizeTransactionProofHandoff,
   runDefaultProofLoop,
+  runExternalProofImport,
   reviewInteractionResultPackageHandoff,
+  reviewExternalProofImport,
+  summarizeExternalProofImportReview,
+  summarizeExternalProofImportRun,
   summarizeReviewedInteractionResultPackageHandoff,
   summarizeReviewExtensionReadiness,
   summarizeReviewExtensionBoundary,
@@ -2955,6 +5274,15 @@ module.exports = {
   runTransactionProofHandoff,
   summarizeDefaultProofCenter,
   summarizeDefaultProofLoops,
+  summarizeExternalProofImportAdapterPack,
+  summarizeXoonyaNativeHybridReadinessPack,
+  summarizeXoonyaNativeLineRateFramePack,
+  summarizeXoonyaNativePayloadProfilePack,
+  summarizeXoonyaNativeStandardizationPack,
+  summarizeXoonyaNativeAtomSpec,
+  summarizeXoonyaNativeAtomConformancePack,
+  summarizeXoonyaNativeProofStandard,
+  summarizeXoonyaNativeAnchorProfile,
   summarizeGuidedProofLoopBundle,
   summarizeInteractionResultPackageHandoff,
   summarizeInteractionResultPackageHandoffCenter,
@@ -2965,11 +5293,30 @@ module.exports = {
   canonicalizeEvent,
   hashEvent,
   emitReceipt,
+  listProofVerificationMethods,
+  getProofVerificationMethod,
+  listNativeSignatureSuites,
+  getNativeSignatureSuite,
+  listXoonyaNativeIdentityTypes,
+  getXoonyaNativeIdentityType,
+  buildNativeReceiptSignature,
+  buildNativeSignedReceiptProof,
+  buildNativeAnchoredReceiptProof,
   buildProofBundle,
   verifyProofBundle,
   parseReceipt,
   makeIdentityMaterial,
   createIdentity,
+  createXoonyaNativeAtomV1,
+  createXoonyaNativeAtomV2,
+  parseXoonyaNativeAtom,
+  verifyXoonyaNativeAtom,
+  encodeXoonyaNativePayloadProfileV1,
+  parseXoonyaNativePayloadProfileV1,
+  verifyXoonyaNativePayloadProfileV1,
+  createXoonyaNativeLineRateFrameV1,
+  parseXoonyaNativeLineRateFrameV1,
+  verifyXoonyaNativeLineRateFrameV1,
   createReceipt,
   verifyReceipt,
   createReceiptV2,