xoonya 3.0.1 → 3.1.0

package/integrations/registry.js

@@ -1,636 +1,636 @@
-"use strict";
-
-const stagedPartnerVerifierRegistrationRecord = require("./examples/example-third-party-verifier-registration.record.json");
-
-function clone(value) {
-  return JSON.parse(JSON.stringify(value));
-}
-
-function sortStrings(values) {
-  return Array.from(new Set((Array.isArray(values) ? values : []).filter(Boolean))).sort();
-}
-
-function summarizeCounts(values, fieldName) {
-  return sortStrings(values).map((value) => ({
-    [fieldName]: value,
-    count: values.filter((entry) => entry === value).length
-  }));
-}
-
-function createIntegrationDescriptor(descriptor, extras = {}) {
-  return {
-    integration_id: descriptor.integration_id,
-    integration_class: descriptor.integration_class,
-    display_name: descriptor.display_name,
-    description: descriptor.description,
-    proof_scope: descriptor.proof_scope,
-    source: extras.source || descriptor.source || "builtin",
-    bundled: extras.bundled !== false,
-    status: extras.status || descriptor.status || "available",
-    certification_state: extras.certification_state || descriptor.certification_state || "reference_example",
-    certification_scope: sortStrings(extras.certification_scope || descriptor.certification_scope),
-    integration_maturity: extras.integration_maturity || descriptor.integration_maturity || "reference_example",
-    operational_readiness: extras.operational_readiness || descriptor.operational_readiness || "reference",
-    capabilities: sortStrings(descriptor.capabilities),
-    public_surfaces: sortStrings(descriptor.public_surfaces),
-    compatibility: clone(descriptor.compatibility || {}),
-    required_inputs: sortStrings(descriptor.required_inputs),
-    emitted_artifacts: sortStrings(descriptor.emitted_artifacts),
-    verification_targets: sortStrings(descriptor.verification_targets),
-    selection_hints: {
-      default_for_proof_scopes: sortStrings(
-        extras.default_for_proof_scopes || descriptor.default_for_proof_scopes || [descriptor.proof_scope]
-      )
-    }
-  };
-}
-
-function buildIntegrationRegistrationView(integration, registrationRecord) {
-  const integrationEntry = integration || {};
-  const record = registrationRecord && typeof registrationRecord === "object" ? registrationRecord : null;
-  return {
-    registration_state: record ? record.registration_state : "production_registered",
-    bundled: record ? record.bundled : integrationEntry.bundled === true,
-    default_selection_enabled: record ? record.default_selection_enabled === true : integrationEntry.bundled === true,
-    requires_explicit_selection: record ? record.requires_explicit_selection === true : integrationEntry.bundled !== true,
-    registered_at: record ? record.registered_at : null,
-    registered_by: record ? record.registered_by || null : null,
-    verified_with: sortStrings(record && record.verified_with),
-    notes: record ? record.notes || null : null
-  };
-}
-
-function buildIntegrationView(integration, registrationRecord) {
-  const entry = clone(integration);
-  entry.registration = buildIntegrationRegistrationView(entry, registrationRecord);
-  entry.registration_state = entry.registration.registration_state;
-  return entry;
-}
-
-function validateIntegrationRegistration(descriptor, registrationRecord) {
-  const errors = [];
-  const integrationDescriptor = descriptor && typeof descriptor === "object" ? descriptor : {};
-  const record = registrationRecord && typeof registrationRecord === "object" ? registrationRecord : {};
-
-  if (!integrationDescriptor.integration_id) errors.push("descriptor.integration_id is required");
-  if (!record.integration_id) errors.push("registration_record.integration_id is required");
-  if (!integrationDescriptor.integration_class) errors.push("descriptor.integration_class is required");
-  if (!record.integration_class) errors.push("registration_record.integration_class is required");
-  if (!integrationDescriptor.proof_scope) errors.push("descriptor.proof_scope is required");
-  if (!record.proof_scope) errors.push("registration_record.proof_scope is required");
-  if (integrationDescriptor.integration_id && record.integration_id && integrationDescriptor.integration_id !== record.integration_id) {
-    errors.push("descriptor.integration_id must match registration_record.integration_id");
-  }
-  if (integrationDescriptor.integration_class && record.integration_class && integrationDescriptor.integration_class !== record.integration_class) {
-    errors.push("descriptor.integration_class must match registration_record.integration_class");
-  }
-  if (integrationDescriptor.proof_scope && record.proof_scope && integrationDescriptor.proof_scope !== record.proof_scope) {
-    errors.push("descriptor.proof_scope must match registration_record.proof_scope");
-  }
-
-  return {
-    ok: errors.length === 0,
-    errors
-  };
-}
-
-function importRegisteredIntegration(descriptor, registrationRecord, extras = {}) {
-  const validation = validateIntegrationRegistration(descriptor, registrationRecord);
-  if (!validation.ok) {
-    const error = new Error(`invalid proof integration registration:\n${validation.errors.join("\n")}`);
-    error.code = "invalid_proof_integration_registration";
-    error.validation = validation;
-    throw error;
-  }
-  const record = registrationRecord || {};
-  const integration = createIntegrationDescriptor(descriptor, {
-    ...extras,
-    bundled: Object.prototype.hasOwnProperty.call(record, "bundled") ? record.bundled : extras.bundled,
-    certification_state: record.certification_state || extras.certification_state,
-    certification_scope: record.certification_scope || extras.certification_scope,
-    integration_maturity: record.integration_maturity || extras.integration_maturity,
-    operational_readiness: record.operational_readiness || extras.operational_readiness,
-    default_for_proof_scopes: record.default_selection_enabled === true
-      ? (extras.default_for_proof_scopes || [descriptor.proof_scope])
-      : []
-  });
-  return buildIntegrationView(integration, record);
-}
-
-function createIntegrationRegistrySnapshot(integrations, filters = {}) {
-  const rows = Array.isArray(integrations) ? integrations.map(clone) : [];
-  return {
-    snapshot_version: "xoonya/integration-registry-snapshot/v1",
-    generated_at: new Date().toISOString(),
-    integration_count: rows.length,
-    filters: clone(filters || {}),
-    integrations: rows
-  };
-}
-
-function exportIntegrationRegistrySnapshot(filters = {}) {
-  return createIntegrationRegistrySnapshot(listIntegrations(filters), filters);
-}
-
-function validateIntegrationRegistrySnapshot(snapshot) {
-  const entry = snapshot && typeof snapshot === "object" ? snapshot : {};
-  const errors = [];
-  if (!entry.snapshot_version) errors.push("snapshot.snapshot_version is required");
-  if (!entry.generated_at) errors.push("snapshot.generated_at is required");
-  if (!Number.isInteger(entry.integration_count) || entry.integration_count < 0) {
-    errors.push("snapshot.integration_count must be a non-negative integer");
-  }
-  if (!Array.isArray(entry.integrations)) {
-    errors.push("snapshot.integrations must be an array");
-  } else if (entry.integrations.length !== entry.integration_count) {
-    errors.push("snapshot.integration_count must match snapshot.integrations.length");
-  }
-  return {
-    ok: errors.length === 0,
-    errors
-  };
-}
-
-function buildProofPromotionReadinessSummary(input = {}) {
-  const registration = input.registration && typeof input.registration === "object" ? input.registration : {};
-  const integration = input.integration && typeof input.integration === "object" ? input.integration : {};
-  const blockers = [];
-  const registrationState = registration.registration_state || null;
-  const certificationState = integration.certification_state || null;
-  const maturity = integration.integration_maturity || null;
-  const defaultSelectionEnabled = registration.default_selection_enabled === true;
-  const requiresExplicitSelection = registration.requires_explicit_selection === true;
-  const bundled = registration.bundled === true;
-
-  if (!registrationState) blockers.push("registration_state_missing");
-  if (!certificationState) blockers.push("certification_state_missing");
-  if (!maturity) blockers.push("integration_maturity_missing");
-  if (certificationState !== "certified") blockers.push("not_certified");
-  if (maturity !== "production_default") blockers.push("not_marked_production_default");
-  if (!defaultSelectionEnabled) blockers.push("default_selection_disabled");
-  if (requiresExplicitSelection) blockers.push("still_requires_explicit_selection");
-  if (!bundled) blockers.push("not_bundled_for_default_rollout");
-
-  const reviewReady = registrationState === "staging_registered";
-  const productionDefaultReady = blockers.length === 0;
-
-  let posture = "unknown";
-  if (productionDefaultReady) {
-    posture = "production_default_ready";
-  } else if (reviewReady && certificationState === "certified") {
-    posture = "promotion_candidate";
-  } else if (reviewReady) {
-    posture = "staged_review";
-  } else if (defaultSelectionEnabled) {
-    posture = "production_registered";
-  }
-
-  return {
-    registration_state: registrationState,
-    certification_state: certificationState,
-    integration_maturity: maturity,
-    review_ready: reviewReady,
-    default_eligible: defaultSelectionEnabled,
-    production_default_ready: productionDefaultReady,
-    posture,
-    blockers
-  };
-}
-
-function summarizeProofPromotionBlockerCategories(blockers = []) {
-  const values = Array.isArray(blockers) ? blockers : [];
-  const categories = [];
-  if (values.some((entry) => entry === "registration_state_missing")) categories.push("registration");
-  if (values.some((entry) => entry === "certification_state_missing" || entry === "not_certified")) categories.push("certification");
-  if (values.some((entry) => entry === "integration_maturity_missing" || entry === "not_marked_production_default")) categories.push("maturity");
-  if (values.some((entry) => entry === "default_selection_disabled" || entry === "still_requires_explicit_selection")) categories.push("selection");
-  if (values.some((entry) => entry === "not_bundled_for_default_rollout")) categories.push("rollout");
-  return summarizeCounts(categories, "category");
-}
-
-function buildProofCertificationGapSummary(readiness = {}, integration = {}) {
-  const blockers = Array.isArray(readiness.blockers) ? readiness.blockers : [];
-  const certificationScope = Array.isArray(integration.certification_scope) ? integration.certification_scope.filter(Boolean) : [];
-  const verifiedWith = integration.registration && Array.isArray(integration.registration.verified_with)
-    ? integration.registration.verified_with.filter(Boolean)
-    : [];
-  const missingRequirements = [];
-  const productionReady = readiness.production_default_ready === true;
-
-  if (blockers.includes("certification_state_missing") || blockers.includes("not_certified")) {
-    missingRequirements.push("certification_state");
-  }
-  if (!productionReady && certificationScope.length < 1) {
-    missingRequirements.push("certification_scope");
-  }
-  if (!productionReady && verifiedWith.length < 1) {
-    missingRequirements.push("verified_with");
-  }
-
-  return {
-    certification_state: readiness.certification_state || null,
-    certification_scope_count: certificationScope.length,
-    verified_with_count: verifiedWith.length,
-    missing_requirements: missingRequirements,
-    certifiable: missingRequirements.length === 0
-  };
-}
-
-function buildProofNextTransitionSummary(readiness = {}) {
-  const blockers = Array.isArray(readiness.blockers) ? readiness.blockers : [];
-  if (readiness.production_default_ready === true) {
-    return {
-      action: "maintain_production_default",
-      reason: "integration already satisfies proof-side production-default posture",
-      requirements: [],
-      later_actions: []
-    };
-  }
-  if (blockers.includes("registration_state_missing")) {
-    return {
-      action: "register_integration",
-      reason: "proof integration is missing a registration state",
-      requirements: ["registration_state"],
-      later_actions: ["complete_certification", "promote_maturity", "enable_default_selection", "bundle_for_default_rollout"]
-    };
-  }
-  if (blockers.includes("not_certified") || blockers.includes("certification_state_missing")) {
-    return {
-      action: "complete_certification",
-      reason: "proof integration is not yet certified",
-      requirements: ["certification_state"],
-      later_actions: ["promote_maturity", "enable_default_selection", "bundle_for_default_rollout"]
-    };
-  }
-  if (blockers.includes("not_marked_production_default") || blockers.includes("integration_maturity_missing")) {
-    return {
-      action: "promote_maturity",
-      reason: "proof integration maturity is not yet aligned with production-default posture",
-      requirements: ["integration_maturity"],
-      later_actions: ["enable_default_selection", "bundle_for_default_rollout"]
-    };
-  }
-  if (blockers.includes("default_selection_disabled") || blockers.includes("still_requires_explicit_selection")) {
-    return {
-      action: "enable_default_selection",
-      reason: "proof integration remains explicit-selection only",
-      requirements: ["default_selection_enabled", "requires_explicit_selection=false"],
-      later_actions: blockers.includes("not_bundled_for_default_rollout") ? ["bundle_for_default_rollout"] : []
-    };
-  }
-  if (blockers.includes("not_bundled_for_default_rollout")) {
-    return {
-      action: "bundle_for_default_rollout",
-      reason: "proof integration is not yet bundled for production-default rollout",
-      requirements: ["bundled=true"],
-      later_actions: []
-    };
-  }
-  return {
-    action: "review_manually",
-    reason: "proof integration posture needs review",
-    requirements: [],
-    later_actions: []
-  };
-}
-
-function buildProofPromotionRecommendationSummary(readiness = {}) {
-  const nextTransition = buildProofNextTransitionSummary(readiness);
-  if (readiness.production_default_ready === true) {
-    return {
-      recommendation: "eligible_for_production_default",
-      rationale: "proof integration is ready for production-default posture"
-    };
-  }
-  if (readiness.review_ready === true && readiness.default_eligible === false) {
-    return {
-      recommendation: "keep_staged_until_requirements_clear",
-      rationale: nextTransition.reason
-    };
-  }
-  if (readiness.review_ready === true) {
-    return {
-      recommendation: "review_for_promotion",
-      rationale: nextTransition.reason
-    };
-  }
-  return {
-    recommendation: "complete_prerequisites_first",
-    rationale: nextTransition.reason
-  };
-}
-
-function summarizeIntegrationPromotionReadiness(integrationOrId) {
-  const integration = typeof integrationOrId === "string"
-    ? getIntegration(integrationOrId)
-    : clone(integrationOrId || null);
-  if (!integration) {
-    return {
-      ok: false,
-      reason: "integration_not_found"
-    };
-  }
-  return {
-    ok: true,
-    integration_id: integration.integration_id,
-    display_name: integration.display_name,
-    integration_class: integration.integration_class,
-    proof_scope: integration.proof_scope,
-    source: integration.source,
-    registration: clone(integration.registration || {}),
-    certification_state: integration.certification_state || null,
-    integration_maturity: integration.integration_maturity || null,
-    promotion_readiness: buildProofPromotionReadinessSummary({
-      registration: integration.registration,
-      integration
-    })
-  };
-}
-
-function summarizeIntegrationPromotionWorkflow(integrationOrId) {
-  const summary = summarizeIntegrationPromotionReadiness(integrationOrId);
-  if (!summary.ok) {
-    return summary;
-  }
-  const readiness = clone(summary.promotion_readiness || {});
-  return {
-    ...summary,
-    certification_gaps: buildProofCertificationGapSummary(readiness, summary),
-    blocker_categories: summarizeProofPromotionBlockerCategories(readiness.blockers),
-    next_transition: buildProofNextTransitionSummary(readiness),
-    promotion_recommendation: buildProofPromotionRecommendationSummary(readiness)
-  };
-}
-
-function summarizeIntegrationPromotionWorkflowList(filters = {}) {
-  const integrations = listIntegrations(filters).map((integration) => summarizeIntegrationPromotionWorkflow(integration));
-  return {
-    ok: true,
-    integration_count: integrations.length,
-    review_ready_count: integrations.filter((entry) => entry.promotion_readiness.review_ready).length,
-    production_default_ready_count: integrations.filter((entry) => entry.promotion_readiness.production_default_ready).length,
-    certifiable_count: integrations.filter((entry) => entry.certification_gaps.certifiable).length,
-    next_actions: summarizeCounts(
-      integrations.map((entry) => entry.next_transition.action).filter(Boolean),
-      "action"
-    ),
-    recommendations: summarizeCounts(
-      integrations.map((entry) => entry.promotion_recommendation.recommendation).filter(Boolean),
-      "recommendation"
-    ),
-    blocker_categories: summarizeCounts(
-      integrations.flatMap((entry) => (entry.blocker_categories || []).map((item) => item.category)).filter(Boolean),
-      "category"
-    ),
-    integrations
-  };
-}
-
-const BUILTIN_INTEGRATIONS = [
-  createIntegrationDescriptor({
-    integration_id: "builtin.identity.legacy_material",
-    integration_class: "identity_material_provider",
-    display_name: "Legacy Identity Material Provider",
-    description: "Provides legacy identity material compatibility for receipt emission and verification bridges.",
-    certification_scope: ["compatibility_surface", "receipt_emission"],
-    capabilities: ["identity.material", "legacy.receipt.compatibility"],
-    public_surfaces: ["sdk", "service"],
-    proof_scope: "receipt_emission",
-    operational_readiness: "production",
-    integration_maturity: "production_default",
-    certification_state: "certified",
-    compatibility: {
-      proof_contract: "xoonya/v1"
-    },
-    required_inputs: ["legacy_identity_material_hex"],
-    emitted_artifacts: ["receipt"],
-    verification_targets: ["legacy_receipt"]
-  }, {
-    source: "builtin",
-    status: "available",
-    certification_state: "certified",
-    certification_scope: ["compatibility_surface", "receipt_emission"],
-    integration_maturity: "production_default",
-    operational_readiness: "production",
-    default_for_proof_scopes: ["receipt_emission"]
-  }),
-  createIntegrationDescriptor({
-    integration_id: "builtin.reference.evidence",
-    integration_class: "attestation_reference_adapter",
-    display_name: "Evidence Reference Adapter",
-    description: "Admits external evidence references into proof bundles without changing proof validity semantics.",
-    certification_scope: ["proof_bundle_shape"],
-    capabilities: ["proof_bundle.evidence_refs"],
-    public_surfaces: ["sdk", "service"],
-    proof_scope: "proof_bundle",
-    operational_readiness: "production",
-    integration_maturity: "production_default",
-    certification_state: "certified",
-    compatibility: {
-      proof_contract: "xoonya/v1"
-    },
-    required_inputs: ["evidence_refs"],
-    emitted_artifacts: ["proof_bundle"],
-    verification_targets: ["proof_bundle_shape"]
-  }, {
-    source: "builtin",
-    status: "available",
-    certification_state: "certified",
-    certification_scope: ["proof_bundle_shape"],
-    integration_maturity: "production_default",
-    operational_readiness: "production",
-    default_for_proof_scopes: ["proof_bundle"]
-  }),
-  createIntegrationDescriptor({
-    integration_id: "builtin.reference.anchor",
-    integration_class: "anchor_reference_adapter",
-    display_name: "Anchor Reference Adapter",
-    description: "Carries additive anchor references inside proof bundles while keeping proof semantics fixed.",
-    certification_scope: ["proof_bundle_shape"],
-    capabilities: ["proof_bundle.anchors"],
-    public_surfaces: ["sdk"],
-    proof_scope: "proof_bundle",
-    operational_readiness: "production",
-    integration_maturity: "production_default",
-    certification_state: "certified",
-    compatibility: {
-      proof_contract: "xoonya/v1"
-    },
-    required_inputs: ["anchor_refs"],
-    emitted_artifacts: ["proof_bundle"],
-    verification_targets: ["proof_bundle_shape"]
-  }, {
-    source: "builtin",
-    status: "available",
-    certification_state: "certified",
-    certification_scope: ["proof_bundle_shape"],
-    integration_maturity: "production_default",
-    operational_readiness: "production",
-    default_for_proof_scopes: ["proof_bundle"]
-  }),
-  createIntegrationDescriptor({
-    integration_id: "builtin.verifier.registry_profile",
-    integration_class: "verification_helper_adapter",
-    display_name: "Registry Profile Verifier",
-    description: "Verifies additive registry lifecycle profiles without redefining receipt or bundle validity.",
-    certification_scope: ["profile_verification"],
-    capabilities: ["registry_profile.verify"],
-    public_surfaces: ["sdk", "service"],
-    proof_scope: "profile_verification",
-    operational_readiness: "production",
-    integration_maturity: "production_default",
-    certification_state: "certified",
-    compatibility: {
-      proof_contract: "xoonya/v1"
-    },
-    required_inputs: ["profile"],
-    emitted_artifacts: [],
-    verification_targets: ["registry_profile"]
-  }, {
-    source: "builtin",
-    status: "available",
-    certification_state: "certified",
-    certification_scope: ["profile_verification"],
-    integration_maturity: "production_default",
-    operational_readiness: "production",
-    default_for_proof_scopes: ["profile_verification"]
-  }),
-  createIntegrationDescriptor({
-    integration_id: "builtin.verifier.economic_profile",
-    integration_class: "verification_helper_adapter",
-    display_name: "Economic Profile Verifier",
-    description: "Verifies additive economic profiles while keeping the proof kernel neutral.",
-    certification_scope: ["profile_verification"],
-    capabilities: ["economic_profile.verify"],
-    public_surfaces: ["sdk", "service"],
-    proof_scope: "profile_verification",
-    operational_readiness: "production",
-    integration_maturity: "production_default",
-    certification_state: "certified",
-    compatibility: {
-      proof_contract: "xoonya/v1"
-    },
-    required_inputs: ["profile"],
-    emitted_artifacts: [],
-    verification_targets: ["economic_profile"]
-  }, {
-    source: "builtin",
-    status: "available",
-    certification_state: "certified",
-    certification_scope: ["profile_verification"],
-    integration_maturity: "production_default",
-    operational_readiness: "production",
-    default_for_proof_scopes: ["profile_verification"]
-  })
-];
-
-const STAGED_PARTNER_VERIFIER_DESCRIPTOR = {
-  integration_id: stagedPartnerVerifierRegistrationRecord.integration_id,
-  integration_class: stagedPartnerVerifierRegistrationRecord.integration_class,
-  display_name: "Lattice Notary Verifier",
-  description: "Reference third-party proof verifier showing how staged additive profile verification integrations can appear in discovery without changing proof validity semantics.",
-  proof_scope: stagedPartnerVerifierRegistrationRecord.proof_scope,
-  capabilities: ["notary_profile.verify", "evidence_reference.verify"],
-  public_surfaces: ["sdk", "service"],
-  compatibility: {
-    proof_contract: "xoonya/v1"
-  },
-  required_inputs: ["profile", "evidence_refs"],
-  emitted_artifacts: [],
-  verification_targets: ["notary_profile", "evidence_reference"]
-};
-
-const EXAMPLE_INTEGRATIONS = [
-  importRegisteredIntegration(STAGED_PARTNER_VERIFIER_DESCRIPTOR, stagedPartnerVerifierRegistrationRecord, {
-    source: "third_party_example",
-    status: "available",
-    certification_scope: ["self_attested_contract_shape", "staging_profile_smoke"],
-    operational_readiness: "staging",
-    default_for_proof_scopes: []
-  })
-];
-
-const INTEGRATIONS = BUILTIN_INTEGRATIONS.concat(EXAMPLE_INTEGRATIONS).map(clone);
-
-const INTEGRATION_REGISTRATION_RECORDS = {
-  [stagedPartnerVerifierRegistrationRecord.integration_id]: clone(stagedPartnerVerifierRegistrationRecord)
-};
-
-function listIntegrations(filters = {}) {
-  const normalized = {
-    integration_class: String(filters.integration_class || filters.class || "").trim(),
-    capability: String(filters.capability || "").trim(),
-    surface: String(filters.surface || "").trim(),
-    source: String(filters.source || "").trim(),
-    certification_state: String(filters.certification_state || "").trim(),
-    integration_maturity: String(filters.integration_maturity || filters.maturity || "").trim(),
-    registration_state: String(filters.registration_state || "").trim(),
-    proof_scope: String(filters.proof_scope || "").trim(),
-    bundled: String(filters.bundled || "").trim().toLowerCase()
-  };
-  return INTEGRATIONS.filter((integration) => {
-    if (normalized.integration_class && integration.integration_class !== normalized.integration_class) return false;
-    if (normalized.capability && !integration.capabilities.includes(normalized.capability)) return false;
-    if (normalized.surface && !integration.public_surfaces.includes(normalized.surface)) return false;
-    if (normalized.source && integration.source !== normalized.source) return false;
-    if (normalized.certification_state && integration.certification_state !== normalized.certification_state) return false;
-    if (normalized.integration_maturity && integration.integration_maturity !== normalized.integration_maturity) return false;
-    if (normalized.proof_scope && integration.proof_scope !== normalized.proof_scope) return false;
-    const registrationState = INTEGRATION_REGISTRATION_RECORDS[integration.integration_id]
-      ? INTEGRATION_REGISTRATION_RECORDS[integration.integration_id].registration_state
-      : "production_registered";
-    if (normalized.registration_state && registrationState !== normalized.registration_state) return false;
-    if (normalized.bundled === "true" && integration.bundled !== true) return false;
-    if (normalized.bundled === "false" && integration.bundled !== false) return false;
-    return true;
-  }).map((integration) => buildIntegrationView(integration, INTEGRATION_REGISTRATION_RECORDS[integration.integration_id]));
-}
-
-function getIntegration(integrationId) {
-  const lookup = String(integrationId || "").trim();
-  const found = INTEGRATIONS.find((integration) => integration.integration_id === lookup);
-  return found ? buildIntegrationView(found, INTEGRATION_REGISTRATION_RECORDS[found.integration_id]) : null;
-}
-
-function summarizeIntegrations(filters = {}) {
-  const integrations = listIntegrations(filters);
-  return {
-    ok: true,
-    integration_count: integrations.length,
-    certified_integration_count: integrations.filter((integration) => integration.certification_state === "certified").length,
-    production_default_count: integrations.filter((integration) => integration.integration_maturity === "production_default").length,
-    staged_registration_count: integrations.filter((integration) => integration.registration.registration_state === "staging_registered").length,
-    integration_ids: integrations.map((integration) => integration.integration_id),
-    integration_class_count: Array.from(new Set(integrations.map((integration) => integration.integration_class))).length,
-    proof_scope_count: Array.from(new Set(integrations.map((integration) => integration.proof_scope))).length,
-    integrations: integrations.map((integration) => ({
-      integration_id: integration.integration_id,
-      integration_class: integration.integration_class,
-      display_name: integration.display_name,
-      source: integration.source,
-      proof_scope: integration.proof_scope,
-      certification_state: integration.certification_state,
-      integration_maturity: integration.integration_maturity,
-      registration_state: integration.registration.registration_state,
-      bundled: integration.registration.bundled,
-      capability_count: integration.capabilities.length
-    }))
-  };
-}
-
-module.exports = {
-  getIntegration,
-  listIntegrations,
-  summarizeIntegrations,
-  summarizeIntegrationPromotionReadiness,
-  summarizeIntegrationPromotionWorkflow,
-  summarizeIntegrationPromotionWorkflowList,
-  validateIntegrationRegistration,
-  importRegisteredIntegration,
-  createIntegrationRegistrySnapshot,
-  exportIntegrationRegistrySnapshot,
-  validateIntegrationRegistrySnapshot,
-  createIntegrationDescriptor,
-  buildIntegrationRegistrationView,
-  buildIntegrationView
-};
+"use strict";
+
+const stagedPartnerVerifierRegistrationRecord = require("./examples/example-third-party-verifier-registration.record.json");
+
+function clone(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+function sortStrings(values) {
+  return Array.from(new Set((Array.isArray(values) ? values : []).filter(Boolean))).sort();
+}
+
+function summarizeCounts(values, fieldName) {
+  return sortStrings(values).map((value) => ({
+    [fieldName]: value,
+    count: values.filter((entry) => entry === value).length
+  }));
+}
+
+function createIntegrationDescriptor(descriptor, extras = {}) {
+  return {
+    integration_id: descriptor.integration_id,
+    integration_class: descriptor.integration_class,
+    display_name: descriptor.display_name,
+    description: descriptor.description,
+    proof_scope: descriptor.proof_scope,
+    source: extras.source || descriptor.source || "builtin",
+    bundled: extras.bundled !== false,
+    status: extras.status || descriptor.status || "available",
+    certification_state: extras.certification_state || descriptor.certification_state || "reference_example",
+    certification_scope: sortStrings(extras.certification_scope || descriptor.certification_scope),
+    integration_maturity: extras.integration_maturity || descriptor.integration_maturity || "reference_example",
+    operational_readiness: extras.operational_readiness || descriptor.operational_readiness || "reference",
+    capabilities: sortStrings(descriptor.capabilities),
+    public_surfaces: sortStrings(descriptor.public_surfaces),
+    compatibility: clone(descriptor.compatibility || {}),
+    required_inputs: sortStrings(descriptor.required_inputs),
+    emitted_artifacts: sortStrings(descriptor.emitted_artifacts),
+    verification_targets: sortStrings(descriptor.verification_targets),
+    selection_hints: {
+      default_for_proof_scopes: sortStrings(
+        extras.default_for_proof_scopes || descriptor.default_for_proof_scopes || [descriptor.proof_scope]
+      )
+    }
+  };
+}
+
+function buildIntegrationRegistrationView(integration, registrationRecord) {
+  const integrationEntry = integration || {};
+  const record = registrationRecord && typeof registrationRecord === "object" ? registrationRecord : null;
+  return {
+    registration_state: record ? record.registration_state : "production_registered",
+    bundled: record ? record.bundled : integrationEntry.bundled === true,
+    default_selection_enabled: record ? record.default_selection_enabled === true : integrationEntry.bundled === true,
+    requires_explicit_selection: record ? record.requires_explicit_selection === true : integrationEntry.bundled !== true,
+    registered_at: record ? record.registered_at : null,
+    registered_by: record ? record.registered_by || null : null,
+    verified_with: sortStrings(record && record.verified_with),
+    notes: record ? record.notes || null : null
+  };
+}
+
+function buildIntegrationView(integration, registrationRecord) {
+  const entry = clone(integration);
+  entry.registration = buildIntegrationRegistrationView(entry, registrationRecord);
+  entry.registration_state = entry.registration.registration_state;
+  return entry;
+}
+
+function validateIntegrationRegistration(descriptor, registrationRecord) {
+  const errors = [];
+  const integrationDescriptor = descriptor && typeof descriptor === "object" ? descriptor : {};
+  const record = registrationRecord && typeof registrationRecord === "object" ? registrationRecord : {};
+
+  if (!integrationDescriptor.integration_id) errors.push("descriptor.integration_id is required");
+  if (!record.integration_id) errors.push("registration_record.integration_id is required");
+  if (!integrationDescriptor.integration_class) errors.push("descriptor.integration_class is required");
+  if (!record.integration_class) errors.push("registration_record.integration_class is required");
+  if (!integrationDescriptor.proof_scope) errors.push("descriptor.proof_scope is required");
+  if (!record.proof_scope) errors.push("registration_record.proof_scope is required");
+  if (integrationDescriptor.integration_id && record.integration_id && integrationDescriptor.integration_id !== record.integration_id) {
+    errors.push("descriptor.integration_id must match registration_record.integration_id");
+  }
+  if (integrationDescriptor.integration_class && record.integration_class && integrationDescriptor.integration_class !== record.integration_class) {
+    errors.push("descriptor.integration_class must match registration_record.integration_class");
+  }
+  if (integrationDescriptor.proof_scope && record.proof_scope && integrationDescriptor.proof_scope !== record.proof_scope) {
+    errors.push("descriptor.proof_scope must match registration_record.proof_scope");
+  }
+
+  return {
+    ok: errors.length === 0,
+    errors
+  };
+}
+
+function importRegisteredIntegration(descriptor, registrationRecord, extras = {}) {
+  const validation = validateIntegrationRegistration(descriptor, registrationRecord);
+  if (!validation.ok) {
+    const error = new Error(`invalid proof integration registration:\n${validation.errors.join("\n")}`);
+    error.code = "invalid_proof_integration_registration";
+    error.validation = validation;
+    throw error;
+  }
+  const record = registrationRecord || {};
+  const integration = createIntegrationDescriptor(descriptor, {
+    ...extras,
+    bundled: Object.prototype.hasOwnProperty.call(record, "bundled") ? record.bundled : extras.bundled,
+    certification_state: record.certification_state || extras.certification_state,
+    certification_scope: record.certification_scope || extras.certification_scope,
+    integration_maturity: record.integration_maturity || extras.integration_maturity,
+    operational_readiness: record.operational_readiness || extras.operational_readiness,
+    default_for_proof_scopes: record.default_selection_enabled === true
+      ? (extras.default_for_proof_scopes || [descriptor.proof_scope])
+      : []
+  });
+  return buildIntegrationView(integration, record);
+}
+
+function createIntegrationRegistrySnapshot(integrations, filters = {}) {
+  const rows = Array.isArray(integrations) ? integrations.map(clone) : [];
+  return {
+    snapshot_version: "xoonya/integration-registry-snapshot/v1",
+    generated_at: new Date().toISOString(),
+    integration_count: rows.length,
+    filters: clone(filters || {}),
+    integrations: rows
+  };
+}
+
+function exportIntegrationRegistrySnapshot(filters = {}) {
+  return createIntegrationRegistrySnapshot(listIntegrations(filters), filters);
+}
+
+function validateIntegrationRegistrySnapshot(snapshot) {
+  const entry = snapshot && typeof snapshot === "object" ? snapshot : {};
+  const errors = [];
+  if (!entry.snapshot_version) errors.push("snapshot.snapshot_version is required");
+  if (!entry.generated_at) errors.push("snapshot.generated_at is required");
+  if (!Number.isInteger(entry.integration_count) || entry.integration_count < 0) {
+    errors.push("snapshot.integration_count must be a non-negative integer");
+  }
+  if (!Array.isArray(entry.integrations)) {
+    errors.push("snapshot.integrations must be an array");
+  } else if (entry.integrations.length !== entry.integration_count) {
+    errors.push("snapshot.integration_count must match snapshot.integrations.length");
+  }
+  return {
+    ok: errors.length === 0,
+    errors
+  };
+}
+
+function buildProofPromotionReadinessSummary(input = {}) {
+  const registration = input.registration && typeof input.registration === "object" ? input.registration : {};
+  const integration = input.integration && typeof input.integration === "object" ? input.integration : {};
+  const blockers = [];
+  const registrationState = registration.registration_state || null;
+  const certificationState = integration.certification_state || null;
+  const maturity = integration.integration_maturity || null;
+  const defaultSelectionEnabled = registration.default_selection_enabled === true;
+  const requiresExplicitSelection = registration.requires_explicit_selection === true;
+  const bundled = registration.bundled === true;
+
+  if (!registrationState) blockers.push("registration_state_missing");
+  if (!certificationState) blockers.push("certification_state_missing");
+  if (!maturity) blockers.push("integration_maturity_missing");
+  if (certificationState !== "certified") blockers.push("not_certified");
+  if (maturity !== "production_default") blockers.push("not_marked_production_default");
+  if (!defaultSelectionEnabled) blockers.push("default_selection_disabled");
+  if (requiresExplicitSelection) blockers.push("still_requires_explicit_selection");
+  if (!bundled) blockers.push("not_bundled_for_default_rollout");
+
+  const reviewReady = registrationState === "staging_registered";
+  const productionDefaultReady = blockers.length === 0;
+
+  let posture = "unknown";
+  if (productionDefaultReady) {
+    posture = "production_default_ready";
+  } else if (reviewReady && certificationState === "certified") {
+    posture = "promotion_candidate";
+  } else if (reviewReady) {
+    posture = "staged_review";
+  } else if (defaultSelectionEnabled) {
+    posture = "production_registered";
+  }
+
+  return {
+    registration_state: registrationState,
+    certification_state: certificationState,
+    integration_maturity: maturity,
+    review_ready: reviewReady,
+    default_eligible: defaultSelectionEnabled,
+    production_default_ready: productionDefaultReady,
+    posture,
+    blockers
+  };
+}
+
+function summarizeProofPromotionBlockerCategories(blockers = []) {
+  const values = Array.isArray(blockers) ? blockers : [];
+  const categories = [];
+  if (values.some((entry) => entry === "registration_state_missing")) categories.push("registration");
+  if (values.some((entry) => entry === "certification_state_missing" || entry === "not_certified")) categories.push("certification");
+  if (values.some((entry) => entry === "integration_maturity_missing" || entry === "not_marked_production_default")) categories.push("maturity");
+  if (values.some((entry) => entry === "default_selection_disabled" || entry === "still_requires_explicit_selection")) categories.push("selection");
+  if (values.some((entry) => entry === "not_bundled_for_default_rollout")) categories.push("rollout");
+  return summarizeCounts(categories, "category");
+}
+
+function buildProofCertificationGapSummary(readiness = {}, integration = {}) {
+  const blockers = Array.isArray(readiness.blockers) ? readiness.blockers : [];
+  const certificationScope = Array.isArray(integration.certification_scope) ? integration.certification_scope.filter(Boolean) : [];
+  const verifiedWith = integration.registration && Array.isArray(integration.registration.verified_with)
+    ? integration.registration.verified_with.filter(Boolean)
+    : [];
+  const missingRequirements = [];
+  const productionReady = readiness.production_default_ready === true;
+
+  if (blockers.includes("certification_state_missing") || blockers.includes("not_certified")) {
+    missingRequirements.push("certification_state");
+  }
+  if (!productionReady && certificationScope.length < 1) {
+    missingRequirements.push("certification_scope");
+  }
+  if (!productionReady && verifiedWith.length < 1) {
+    missingRequirements.push("verified_with");
+  }
+
+  return {
+    certification_state: readiness.certification_state || null,
+    certification_scope_count: certificationScope.length,
+    verified_with_count: verifiedWith.length,
+    missing_requirements: missingRequirements,
+    certifiable: missingRequirements.length === 0
+  };
+}
+
+function buildProofNextTransitionSummary(readiness = {}) {
+  const blockers = Array.isArray(readiness.blockers) ? readiness.blockers : [];
+  if (readiness.production_default_ready === true) {
+    return {
+      action: "maintain_production_default",
+      reason: "integration already satisfies proof-side production-default posture",
+      requirements: [],
+      later_actions: []
+    };
+  }
+  if (blockers.includes("registration_state_missing")) {
+    return {
+      action: "register_integration",
+      reason: "proof integration is missing a registration state",
+      requirements: ["registration_state"],
+      later_actions: ["complete_certification", "promote_maturity", "enable_default_selection", "bundle_for_default_rollout"]
+    };
+  }
+  if (blockers.includes("not_certified") || blockers.includes("certification_state_missing")) {
+    return {
+      action: "complete_certification",
+      reason: "proof integration is not yet certified",
+      requirements: ["certification_state"],
+      later_actions: ["promote_maturity", "enable_default_selection", "bundle_for_default_rollout"]
+    };
+  }
+  if (blockers.includes("not_marked_production_default") || blockers.includes("integration_maturity_missing")) {
+    return {
+      action: "promote_maturity",
+      reason: "proof integration maturity is not yet aligned with production-default posture",
+      requirements: ["integration_maturity"],
+      later_actions: ["enable_default_selection", "bundle_for_default_rollout"]
+    };
+  }
+  if (blockers.includes("default_selection_disabled") || blockers.includes("still_requires_explicit_selection")) {
+    return {
+      action: "enable_default_selection",
+      reason: "proof integration remains explicit-selection only",
+      requirements: ["default_selection_enabled", "requires_explicit_selection=false"],
+      later_actions: blockers.includes("not_bundled_for_default_rollout") ? ["bundle_for_default_rollout"] : []
+    };
+  }
+  if (blockers.includes("not_bundled_for_default_rollout")) {
+    return {
+      action: "bundle_for_default_rollout",
+      reason: "proof integration is not yet bundled for production-default rollout",
+      requirements: ["bundled=true"],
+      later_actions: []
+    };
+  }
+  return {
+    action: "review_manually",
+    reason: "proof integration posture needs review",
+    requirements: [],
+    later_actions: []
+  };
+}
+
+function buildProofPromotionRecommendationSummary(readiness = {}) {
+  const nextTransition = buildProofNextTransitionSummary(readiness);
+  if (readiness.production_default_ready === true) {
+    return {
+      recommendation: "eligible_for_production_default",
+      rationale: "proof integration is ready for production-default posture"
+    };
+  }
+  if (readiness.review_ready === true && readiness.default_eligible === false) {
+    return {
+      recommendation: "keep_staged_until_requirements_clear",
+      rationale: nextTransition.reason
+    };
+  }
+  if (readiness.review_ready === true) {
+    return {
+      recommendation: "review_for_promotion",
+      rationale: nextTransition.reason
+    };
+  }
+  return {
+    recommendation: "complete_prerequisites_first",
+    rationale: nextTransition.reason
+  };
+}
+
+function summarizeIntegrationPromotionReadiness(integrationOrId) {
+  const integration = typeof integrationOrId === "string"
+    ? getIntegration(integrationOrId)
+    : clone(integrationOrId || null);
+  if (!integration) {
+    return {
+      ok: false,
+      reason: "integration_not_found"
+    };
+  }
+  return {
+    ok: true,
+    integration_id: integration.integration_id,
+    display_name: integration.display_name,
+    integration_class: integration.integration_class,
+    proof_scope: integration.proof_scope,
+    source: integration.source,
+    registration: clone(integration.registration || {}),
+    certification_state: integration.certification_state || null,
+    integration_maturity: integration.integration_maturity || null,
+    promotion_readiness: buildProofPromotionReadinessSummary({
+      registration: integration.registration,
+      integration
+    })
+  };
+}
+
+function summarizeIntegrationPromotionWorkflow(integrationOrId) {
+  const summary = summarizeIntegrationPromotionReadiness(integrationOrId);
+  if (!summary.ok) {
+    return summary;
+  }
+  const readiness = clone(summary.promotion_readiness || {});
+  return {
+    ...summary,
+    certification_gaps: buildProofCertificationGapSummary(readiness, summary),
+    blocker_categories: summarizeProofPromotionBlockerCategories(readiness.blockers),
+    next_transition: buildProofNextTransitionSummary(readiness),
+    promotion_recommendation: buildProofPromotionRecommendationSummary(readiness)
+  };
+}
+
+function summarizeIntegrationPromotionWorkflowList(filters = {}) {
+  const integrations = listIntegrations(filters).map((integration) => summarizeIntegrationPromotionWorkflow(integration));
+  return {
+    ok: true,
+    integration_count: integrations.length,
+    review_ready_count: integrations.filter((entry) => entry.promotion_readiness.review_ready).length,
+    production_default_ready_count: integrations.filter((entry) => entry.promotion_readiness.production_default_ready).length,
+    certifiable_count: integrations.filter((entry) => entry.certification_gaps.certifiable).length,
+    next_actions: summarizeCounts(
+      integrations.map((entry) => entry.next_transition.action).filter(Boolean),
+      "action"
+    ),
+    recommendations: summarizeCounts(
+      integrations.map((entry) => entry.promotion_recommendation.recommendation).filter(Boolean),
+      "recommendation"
+    ),
+    blocker_categories: summarizeCounts(
+      integrations.flatMap((entry) => (entry.blocker_categories || []).map((item) => item.category)).filter(Boolean),
+      "category"
+    ),
+    integrations
+  };
+}
+
+const BUILTIN_INTEGRATIONS = [
+  createIntegrationDescriptor({
+    integration_id: "builtin.identity.legacy_material",
+    integration_class: "identity_material_provider",
+    display_name: "Legacy Identity Material Provider",
+    description: "Provides legacy identity material compatibility for receipt emission and verification bridges.",
+    certification_scope: ["compatibility_surface", "receipt_emission"],
+    capabilities: ["identity.material", "legacy.receipt.compatibility"],
+    public_surfaces: ["sdk", "service"],
+    proof_scope: "receipt_emission",
+    operational_readiness: "production",
+    integration_maturity: "production_default",
+    certification_state: "certified",
+    compatibility: {
+      proof_contract: "xoonya/v1"
+    },
+    required_inputs: ["legacy_identity_material_hex"],
+    emitted_artifacts: ["receipt"],
+    verification_targets: ["legacy_receipt"]
+  }, {
+    source: "builtin",
+    status: "available",
+    certification_state: "certified",
+    certification_scope: ["compatibility_surface", "receipt_emission"],
+    integration_maturity: "production_default",
+    operational_readiness: "production",
+    default_for_proof_scopes: ["receipt_emission"]
+  }),
+  createIntegrationDescriptor({
+    integration_id: "builtin.reference.evidence",
+    integration_class: "attestation_reference_adapter",
+    display_name: "Evidence Reference Adapter",
+    description: "Admits external evidence references into proof bundles without changing proof validity semantics.",
+    certification_scope: ["proof_bundle_shape"],
+    capabilities: ["proof_bundle.evidence_refs"],
+    public_surfaces: ["sdk", "service"],
+    proof_scope: "proof_bundle",
+    operational_readiness: "production",
+    integration_maturity: "production_default",
+    certification_state: "certified",
+    compatibility: {
+      proof_contract: "xoonya/v1"
+    },
+    required_inputs: ["evidence_refs"],
+    emitted_artifacts: ["proof_bundle"],
+    verification_targets: ["proof_bundle_shape"]
+  }, {
+    source: "builtin",
+    status: "available",
+    certification_state: "certified",
+    certification_scope: ["proof_bundle_shape"],
+    integration_maturity: "production_default",
+    operational_readiness: "production",
+    default_for_proof_scopes: ["proof_bundle"]
+  }),
+  createIntegrationDescriptor({
+    integration_id: "builtin.reference.anchor",
+    integration_class: "anchor_reference_adapter",
+    display_name: "Anchor Reference Adapter",
+    description: "Carries additive anchor references inside proof bundles while keeping proof semantics fixed.",
+    certification_scope: ["proof_bundle_shape"],
+    capabilities: ["proof_bundle.anchors"],
+    public_surfaces: ["sdk"],
+    proof_scope: "proof_bundle",
+    operational_readiness: "production",
+    integration_maturity: "production_default",
+    certification_state: "certified",
+    compatibility: {
+      proof_contract: "xoonya/v1"
+    },
+    required_inputs: ["anchor_refs"],
+    emitted_artifacts: ["proof_bundle"],
+    verification_targets: ["proof_bundle_shape"]
+  }, {
+    source: "builtin",
+    status: "available",
+    certification_state: "certified",
+    certification_scope: ["proof_bundle_shape"],
+    integration_maturity: "production_default",
+    operational_readiness: "production",
+    default_for_proof_scopes: ["proof_bundle"]
+  }),
+  createIntegrationDescriptor({
+    integration_id: "builtin.verifier.registry_profile",
+    integration_class: "verification_helper_adapter",
+    display_name: "Registry Profile Verifier",
+    description: "Verifies additive registry lifecycle profiles without redefining receipt or bundle validity.",
+    certification_scope: ["profile_verification"],
+    capabilities: ["registry_profile.verify"],
+    public_surfaces: ["sdk", "service"],
+    proof_scope: "profile_verification",
+    operational_readiness: "production",
+    integration_maturity: "production_default",
+    certification_state: "certified",
+    compatibility: {
+      proof_contract: "xoonya/v1"
+    },
+    required_inputs: ["profile"],
+    emitted_artifacts: [],
+    verification_targets: ["registry_profile"]
+  }, {
+    source: "builtin",
+    status: "available",
+    certification_state: "certified",
+    certification_scope: ["profile_verification"],
+    integration_maturity: "production_default",
+    operational_readiness: "production",
+    default_for_proof_scopes: ["profile_verification"]
+  }),
+  createIntegrationDescriptor({
+    integration_id: "builtin.verifier.economic_profile",
+    integration_class: "verification_helper_adapter",
+    display_name: "Economic Profile Verifier",
+    description: "Verifies additive economic profiles while keeping the proof kernel neutral.",
+    certification_scope: ["profile_verification"],
+    capabilities: ["economic_profile.verify"],
+    public_surfaces: ["sdk", "service"],
+    proof_scope: "profile_verification",
+    operational_readiness: "production",
+    integration_maturity: "production_default",
+    certification_state: "certified",
+    compatibility: {
+      proof_contract: "xoonya/v1"
+    },
+    required_inputs: ["profile"],
+    emitted_artifacts: [],
+    verification_targets: ["economic_profile"]
+  }, {
+    source: "builtin",
+    status: "available",
+    certification_state: "certified",
+    certification_scope: ["profile_verification"],
+    integration_maturity: "production_default",
+    operational_readiness: "production",
+    default_for_proof_scopes: ["profile_verification"]
+  })
+];
+
+const STAGED_PARTNER_VERIFIER_DESCRIPTOR = {
+  integration_id: stagedPartnerVerifierRegistrationRecord.integration_id,
+  integration_class: stagedPartnerVerifierRegistrationRecord.integration_class,
+  display_name: "Lattice Notary Verifier",
+  description: "Reference third-party proof verifier showing how staged additive profile verification integrations can appear in discovery without changing proof validity semantics.",
+  proof_scope: stagedPartnerVerifierRegistrationRecord.proof_scope,
+  capabilities: ["notary_profile.verify", "evidence_reference.verify"],
+  public_surfaces: ["sdk", "service"],
+  compatibility: {
+    proof_contract: "xoonya/v1"
+  },
+  required_inputs: ["profile", "evidence_refs"],
+  emitted_artifacts: [],
+  verification_targets: ["notary_profile", "evidence_reference"]
+};
+
+const EXAMPLE_INTEGRATIONS = [
+  importRegisteredIntegration(STAGED_PARTNER_VERIFIER_DESCRIPTOR, stagedPartnerVerifierRegistrationRecord, {
+    source: "third_party_example",
+    status: "available",
+    certification_scope: ["self_attested_contract_shape", "staging_profile_smoke"],
+    operational_readiness: "staging",
+    default_for_proof_scopes: []
+  })
+];
+
+const INTEGRATIONS = BUILTIN_INTEGRATIONS.concat(EXAMPLE_INTEGRATIONS).map(clone);
+
+const INTEGRATION_REGISTRATION_RECORDS = {
+  [stagedPartnerVerifierRegistrationRecord.integration_id]: clone(stagedPartnerVerifierRegistrationRecord)
+};
+
+function listIntegrations(filters = {}) {
+  const normalized = {
+    integration_class: String(filters.integration_class || filters.class || "").trim(),
+    capability: String(filters.capability || "").trim(),
+    surface: String(filters.surface || "").trim(),
+    source: String(filters.source || "").trim(),
+    certification_state: String(filters.certification_state || "").trim(),
+    integration_maturity: String(filters.integration_maturity || filters.maturity || "").trim(),
+    registration_state: String(filters.registration_state || "").trim(),
+    proof_scope: String(filters.proof_scope || "").trim(),
+    bundled: String(filters.bundled || "").trim().toLowerCase()
+  };
+  return INTEGRATIONS.filter((integration) => {
+    if (normalized.integration_class && integration.integration_class !== normalized.integration_class) return false;
+    if (normalized.capability && !integration.capabilities.includes(normalized.capability)) return false;
+    if (normalized.surface && !integration.public_surfaces.includes(normalized.surface)) return false;
+    if (normalized.source && integration.source !== normalized.source) return false;
+    if (normalized.certification_state && integration.certification_state !== normalized.certification_state) return false;
+    if (normalized.integration_maturity && integration.integration_maturity !== normalized.integration_maturity) return false;
+    if (normalized.proof_scope && integration.proof_scope !== normalized.proof_scope) return false;
+    const registrationState = INTEGRATION_REGISTRATION_RECORDS[integration.integration_id]
+      ? INTEGRATION_REGISTRATION_RECORDS[integration.integration_id].registration_state
+      : "production_registered";
+    if (normalized.registration_state && registrationState !== normalized.registration_state) return false;
+    if (normalized.bundled === "true" && integration.bundled !== true) return false;
+    if (normalized.bundled === "false" && integration.bundled !== false) return false;
+    return true;
+  }).map((integration) => buildIntegrationView(integration, INTEGRATION_REGISTRATION_RECORDS[integration.integration_id]));
+}
+
+function getIntegration(integrationId) {
+  const lookup = String(integrationId || "").trim();
+  const found = INTEGRATIONS.find((integration) => integration.integration_id === lookup);
+  return found ? buildIntegrationView(found, INTEGRATION_REGISTRATION_RECORDS[found.integration_id]) : null;
+}
+
+function summarizeIntegrations(filters = {}) {
+  const integrations = listIntegrations(filters);
+  return {
+    ok: true,
+    integration_count: integrations.length,
+    certified_integration_count: integrations.filter((integration) => integration.certification_state === "certified").length,
+    production_default_count: integrations.filter((integration) => integration.integration_maturity === "production_default").length,
+    staged_registration_count: integrations.filter((integration) => integration.registration.registration_state === "staging_registered").length,
+    integration_ids: integrations.map((integration) => integration.integration_id),
+    integration_class_count: Array.from(new Set(integrations.map((integration) => integration.integration_class))).length,
+    proof_scope_count: Array.from(new Set(integrations.map((integration) => integration.proof_scope))).length,
+    integrations: integrations.map((integration) => ({
+      integration_id: integration.integration_id,
+      integration_class: integration.integration_class,
+      display_name: integration.display_name,
+      source: integration.source,
+      proof_scope: integration.proof_scope,
+      certification_state: integration.certification_state,
+      integration_maturity: integration.integration_maturity,
+      registration_state: integration.registration.registration_state,
+      bundled: integration.registration.bundled,
+      capability_count: integration.capabilities.length
+    }))
+  };
+}
+
+module.exports = {
+  getIntegration,
+  listIntegrations,
+  summarizeIntegrations,
+  summarizeIntegrationPromotionReadiness,
+  summarizeIntegrationPromotionWorkflow,
+  summarizeIntegrationPromotionWorkflowList,
+  validateIntegrationRegistration,
+  importRegisteredIntegration,
+  createIntegrationRegistrySnapshot,
+  exportIntegrationRegistrySnapshot,
+  validateIntegrationRegistrySnapshot,
+  createIntegrationDescriptor,
+  buildIntegrationRegistrationView,
+  buildIntegrationView
+};