xoonya 3.1.17 → 3.2.1

package/integrations/registry.js

@@ -1,636 +0,0 @@
-"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
-};

package/integrations/views.js

@@ -1,36 +0,0 @@
-"use strict";
-
-function buildMissingResponse(reason) {
-  return {
-    status: 404,
-    payload: {
-      status: "not_found",
-      reason
-    }
-  };
-}
-
-function buildIntegrationListResponse(payload) {
-  return {
-    status: 200,
-    payload
-  };
-}
-
-function buildIntegrationDetailResponse(integration) {
-  if (!integration) {
-    return buildMissingResponse("integration_not_found");
-  }
-  return {
-    status: 200,
-    payload: {
-      ok: true,
-      integration
-    }
-  };
-}
-
-module.exports = {
-  buildIntegrationDetailResponse,
-  buildIntegrationListResponse
-};