xoonya 1.0.0 → 1.2.0

package/LICENSE

@@ -186,7 +186,7 @@ file or class name and description of purpose be included on the
 same "printed page" as the copyright notice for easier
 identification within third-party archives.
 
-Copyright [yyyy] [name of copyright owner]
+Copyright 2026 Parth Mauria Saxena
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

package/NOTICE

@@ -0,0 +1,3 @@
+Copyright 2026 Parth Mauria Saxena
+
+This product is released under the Apache License, Version 2.0.

package/README.md

@@ -56,6 +56,8 @@ node examples/package_quickstart.js
 
 The package quickstart demonstrates:
 
+- proof integration discovery and certification posture
+- staged proof-integration registration and snapshot export
 - legacy compact receipt verification
 - legacy proof-envelope verification
 - canonical event creation
@@ -93,6 +95,9 @@ Primary proof-model routes:
 - `POST /v1/receipts/emit`
 - `POST /v1/proof-bundles/build`
 - `POST /v1/proof-bundles/verify`
+- `GET /v1/integrations`
+- `GET /v1/integrations/summary`
+- `GET /v1/integrations/snapshot`
 
 Preserved compatibility routes:
 
@@ -111,10 +116,13 @@ Local verification commands:
 - `npm run verify:vectors`
 - `npm run verify:examples`
 - `npm run verify:service`
+- `npm run verify:tooling`
 - `npm run verify:all`
 
 The current verification covers:
 
+- proof integration discovery metadata and filtering
+- staged proof integration registration import and snapshot export
 - package export presence
 - deterministic event hashing
 - proof-bundle tamper detection
@@ -137,6 +145,40 @@ Published proof hardening artifacts:
 - `SERVICE_CONTRACT.md`
 - `COMPATIBILITY_NOTE.md`
 
-Internal program-history docs for this repo live under:
+## Proof Integration Toolkit
 
-- [xoonya program archive](C:/Users/Yoga/Desktop/workspace/vscode_workspace_public/naxytra/_program/xoonya)
+`xoonya` keeps its integration model narrower than `xytara`. The proof-side toolkit is for additive proof helpers only:
+
+- identity-material providers
+- proof-bundle reference adapters
+- profile verification helpers
+
+The package now includes:
+
+- `validateIntegrationRegistration(...)`
+- `importRegisteredIntegration(...)`
+- `exportIntegrationRegistrySnapshot(...)`
+- `validateIntegrationRegistrySnapshot(...)`
+- `summarizeIntegrationPromotionReadiness(...)`
+
+Those helpers are intended to normalize proof-adjacent integrations without letting pricing, workflow, or settlement logic leak into the proof kernel.
+
+For the lightweight external-builder path, use:
+
+- [PROOF_INTEGRATION_PROCESS.md](C:/Users/Yoga/Desktop/workspace/vscode_workspace_public/naxytra/xoonya/integrations/PROOF_INTEGRATION_PROCESS.md)
+
+For lightweight local review flows, `xoonya` also includes a small repo-local proof-side CLI when working from a cloned `xoonya` repository:
+
+```bash
+node scripts/registry_cli.js validate-registration --example verifier
+node scripts/registry_cli.js export-snapshot --registration_state staging_registered
+```
+
+That tooling is intentionally narrow: validate proof-integration registration posture and export filtered proof registry snapshots.
+
+The proof-side readiness layer now also makes promotion posture explicit without expanding `xoonya` into a control plane:
+
+- review-ready means a proof integration is staged and inspectable
+- default-eligible means it can participate in the proof-side default posture
+- production-default-ready means certification, maturity, bundled posture, and selection posture all line up
+- blockers are returned as data instead of being left implicit

package/index.js

@@ -1,3 +1,6 @@
 "use strict";
 
-module.exports = require("./proof_sdk");
+module.exports = {
+  ...require("./proof_sdk"),
+  ...require("./integrations/registry")
+};

package/integrations/PROOF_INTEGRATION_PROCESS.md

@@ -0,0 +1,45 @@
+# Proof Integration Process
+
+This note captures the lighter third-party path for `xoonya`.
+
+`xoonya` is not a commerce registry. Its integration model is intentionally narrower.
+
+## Goal
+
+Allow proof-adjacent integrations to be registered, inspected, and exported without letting pricing, workflow, or settlement logic leak into the proof kernel.
+
+## Typical proof-side integrations
+
+- identity-material providers
+- proof-bundle reference adapters
+- profile verification helpers
+- external verifier references
+
+## Recommended flow
+
+1. Define the proof-adjacent integration boundary.
+2. Create the registration record.
+3. Validate registration posture locally.
+4. Export a filtered snapshot when you need a reviewable proof-side state view.
+5. Treat promotion posture as explicit review data, not as an assumption.
+
+## Local commands
+
+From a cloned `xoonya` repo:
+
+```bash
+node scripts/registry_cli.js validate-registration --example verifier
+node scripts/registry_cli.js export-snapshot --registration_state staging_registered
+node scripts/registry_cli.js promotion-readiness --integration verifier.bundle.reference
+```
+
+## Posture rules
+
+- staged proof integrations can be visible
+- staged proof integrations can be review-ready
+- staged proof integrations should not become default by accident
+- blockers should be returned as data
+
+## Boundary rule
+
+If a proposed proof-side integration needs workflow, pricing, payment, or settlement semantics to make sense, it probably belongs in `xytara`, not `xoonya`.

package/integrations/examples/example-third-party-verifier-registration.record.json

@@ -0,0 +1,22 @@
+{
+  "integration_id": "partner.verifier.lattice_notary",
+  "integration_class": "verification_helper_adapter",
+  "proof_scope": "profile_verification",
+  "registration_state": "staging_registered",
+  "integration_maturity": "staging_candidate",
+  "certification_state": "self_attested",
+  "bundled": false,
+  "default_selection_enabled": false,
+  "requires_explicit_selection": true,
+  "registered_at": "2026-03-20T00:00:00Z",
+  "registered_by": "partner:lattice-labs",
+  "verified_with": [
+    "schema_conformance",
+    "profile_verification_smoke"
+  ],
+  "certification_scope": [
+    "self_attested_contract_shape",
+    "staging_profile_smoke"
+  ],
+  "notes": "Reference staged verifier registration for proof-side import and discovery validation."
+}

package/integrations/registration-record.schema.json

@@ -0,0 +1,99 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "xoonya/registration-record.schema.json",
+  "title": "xoonya Proof Integration Registration Record",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "integration_id",
+    "integration_class",
+    "proof_scope",
+    "registration_state",
+    "integration_maturity",
+    "certification_state",
+    "bundled",
+    "default_selection_enabled",
+    "registered_at"
+  ],
+  "properties": {
+    "integration_id": {
+      "type": "string",
+      "minLength": 1
+    },
+    "integration_class": {
+      "type": "string",
+      "enum": [
+        "identity_material_provider",
+        "attestation_reference_adapter",
+        "anchor_reference_adapter",
+        "verification_helper_adapter"
+      ]
+    },
+    "proof_scope": {
+      "type": "string",
+      "enum": [
+        "receipt_emission",
+        "proof_bundle",
+        "profile_verification"
+      ]
+    },
+    "registration_state": {
+      "type": "string",
+      "enum": [
+        "local_only",
+        "staging_registered",
+        "production_registered"
+      ]
+    },
+    "integration_maturity": {
+      "type": "string",
+      "enum": [
+        "reference_example",
+        "staging_candidate",
+        "production_default"
+      ]
+    },
+    "certification_state": {
+      "type": "string",
+      "enum": [
+        "reference_example",
+        "self_attested",
+        "certified"
+      ]
+    },
+    "bundled": {
+      "type": "boolean"
+    },
+    "default_selection_enabled": {
+      "type": "boolean"
+    },
+    "requires_explicit_selection": {
+      "type": "boolean"
+    },
+    "registered_at": {
+      "type": "string",
+      "minLength": 1
+    },
+    "registered_by": {
+      "type": "string",
+      "minLength": 1
+    },
+    "verified_with": {
+      "type": "array",
+      "items": {
+        "type": "string",
+        "minLength": 1
+      }
+    },
+    "certification_scope": {
+      "type": "array",
+      "items": {
+        "type": "string",
+        "minLength": 1
+      }
+    },
+    "notes": {
+      "type": "string"
+    }
+  }
+}

package/integrations/registry-snapshot.schema.json

@@ -0,0 +1,36 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "xoonya/registry-snapshot.schema.json",
+  "title": "xoonya Proof Integration Registry Snapshot",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "snapshot_version",
+    "generated_at",
+    "integration_count",
+    "integrations"
+  ],
+  "properties": {
+    "snapshot_version": {
+      "type": "string",
+      "minLength": 1
+    },
+    "generated_at": {
+      "type": "string",
+      "minLength": 1
+    },
+    "integration_count": {
+      "type": "integer",
+      "minimum": 0
+    },
+    "integrations": {
+      "type": "array",
+      "items": {
+        "type": "object"
+      }
+    },
+    "filters": {
+      "type": "object"
+    }
+  }
+}

package/integrations/registry.js

@@ -0,0 +1,465 @@
+"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 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 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
+    })
+  };
+}
+
+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,
+  validateIntegrationRegistration,
+  importRegisteredIntegration,
+  createIntegrationRegistrySnapshot,
+  exportIntegrationRegistrySnapshot,
+  validateIntegrationRegistrySnapshot,
+  createIntegrationDescriptor,
+  buildIntegrationRegistrationView,
+  buildIntegrationView
+};

package/integrations/views.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xoonya",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "Deterministic proof SDK for canonical events, receipts, proof bundles, and verification.",
   "main": "index.js",
   "type": "commonjs",
@@ -24,10 +24,12 @@
     "index.js",
     "proof_sdk.js",
     "server.js",
+    "integrations/",
     "vectors/",
     ".env.example",
     "README.md",
-    "LICENSE"
+    "LICENSE",
+    "NOTICE"
   ],
   "sideEffects": false,
   "keywords": [
@@ -42,9 +44,11 @@
   "scripts": {
     "start": "node server.js",
     "verify:package": "node scripts/verify_all.js",
+    "verify:integrations": "node scripts/verify_integrations.js",
+    "verify:tooling": "node scripts/verify_tooling.js",
     "verify:vectors": "node scripts/verify_vectors.js",
     "verify:examples": "node scripts/verify_examples.js",
     "verify:service": "node scripts/verify_service.js",
-    "verify:all": "node scripts/verify_all.js && node scripts/verify_vectors.js && node scripts/verify_examples.js && node scripts/verify_service.js"
+    "verify:all": "node scripts/verify_all.js && node scripts/verify_integrations.js && node scripts/verify_tooling.js && node scripts/verify_vectors.js && node scripts/verify_examples.js && node scripts/verify_service.js"
   }
 }

package/server.js

@@ -1,6 +1,16 @@
 const http = require('http');
 const { URL } = require('url');
 const proofSdk = require('./index.js');
+const {
+  getIntegration,
+  exportIntegrationRegistrySnapshot,
+  summarizeIntegrationPromotionReadiness,
+  summarizeIntegrations
+} = require('./integrations/registry');
+const {
+  buildIntegrationDetailResponse,
+  buildIntegrationListResponse
+} = require('./integrations/views');
 
 function readJsonBody(req) {
   return new Promise((resolve, reject) => {
@@ -81,6 +91,90 @@ async function routeRequest(req, res) {
     return;
   }
 
+  if (req.method === 'GET' && url.pathname === '/v1/integrations') {
+    const response = buildIntegrationListResponse({
+      ok: true,
+      integrations: proofSdk.listIntegrations({
+        integration_class: url.searchParams.get('class'),
+        capability: url.searchParams.get('capability'),
+        surface: url.searchParams.get('surface'),
+        source: url.searchParams.get('source'),
+        certification_state: url.searchParams.get('certification_state'),
+        integration_maturity: url.searchParams.get('integration_maturity'),
+        bundled: url.searchParams.get('bundled')
+      })
+    });
+    sendJson(res, response.status, response.payload);
+    return;
+  }
+
+  if (req.method === 'GET' && url.pathname === '/v1/integrations/summary') {
+    const response = buildIntegrationListResponse(summarizeIntegrations({
+      integration_class: url.searchParams.get('class'),
+      capability: url.searchParams.get('capability'),
+      surface: url.searchParams.get('surface'),
+      source: url.searchParams.get('source'),
+      certification_state: url.searchParams.get('certification_state'),
+      integration_maturity: url.searchParams.get('integration_maturity'),
+      bundled: url.searchParams.get('bundled')
+    }));
+    sendJson(res, response.status, response.payload);
+    return;
+  }
+
+  if (req.method === 'GET' && url.pathname === '/v1/integrations/snapshot') {
+    const response = buildIntegrationListResponse(exportIntegrationRegistrySnapshot({
+      integration_class: url.searchParams.get('class'),
+      capability: url.searchParams.get('capability'),
+      surface: url.searchParams.get('surface'),
+      source: url.searchParams.get('source'),
+      certification_state: url.searchParams.get('certification_state'),
+      integration_maturity: url.searchParams.get('integration_maturity'),
+      registration_state: url.searchParams.get('registration_state'),
+      proof_scope: url.searchParams.get('proof_scope'),
+      bundled: url.searchParams.get('bundled')
+    }));
+    sendJson(res, response.status, response.payload);
+    return;
+  }
+
+  if (req.method === 'GET' && url.pathname === '/v1/integrations/promotion-readiness') {
+    const response = buildIntegrationListResponse({
+      ok: true,
+      integrations: proofSdk.listIntegrations({
+        integration_class: url.searchParams.get('class'),
+        capability: url.searchParams.get('capability'),
+        surface: url.searchParams.get('surface'),
+        source: url.searchParams.get('source'),
+        certification_state: url.searchParams.get('certification_state'),
+        integration_maturity: url.searchParams.get('integration_maturity'),
+        registration_state: url.searchParams.get('registration_state'),
+        proof_scope: url.searchParams.get('proof_scope'),
+        bundled: url.searchParams.get('bundled')
+      }).map((integration) => summarizeIntegrationPromotionReadiness(integration))
+    });
+    sendJson(res, response.status, response.payload);
+    return;
+  }
+
+  if (req.method === 'GET' && url.pathname.startsWith('/v1/integrations/') && url.pathname.endsWith('/promotion-readiness')) {
+    const integrationId = decodeURIComponent(
+      url.pathname
+        .slice('/v1/integrations/'.length, -'/promotion-readiness'.length)
+        .replace(/\/$/, '')
+    );
+    const response = buildIntegrationListResponse(summarizeIntegrationPromotionReadiness(integrationId));
+    sendJson(res, response.status || 200, response.payload || response);
+    return;
+  }
+
+  if (req.method === 'GET' && url.pathname.startsWith('/v1/integrations/')) {
+    const integrationId = decodeURIComponent(url.pathname.slice('/v1/integrations/'.length));
+    const response = buildIntegrationDetailResponse(getIntegration(integrationId));
+    sendJson(res, response.status, response.payload);
+    return;
+  }
+
   if (req.method === 'POST' && url.pathname === '/v1/events/canonicalize') {
     try {
       const body = await readJsonBody(req);