xoonya 2.4.0 → 2.6.0

package/lib/event_system_lane_contract.js

@@ -0,0 +1,76 @@
+"use strict";
+
+const {
+  buildPhase7EventSystemPack,
+  summarizePhase7EventSystemPack
+} = require("./phase_7_event_system_pack");
+const {
+  buildPhase7NatsProofPack,
+  summarizePhase7NatsProofPack
+} = require("./phase_7_nats_proof_pack");
+
+function buildEventSystemLanePack() {
+  const phasePack = buildPhase7EventSystemPack();
+  const natsPack = buildPhase7NatsProofPack();
+  return {
+    product: "xoonya",
+    category: "proof-event-system-lane-pack",
+    pack_version: "xoonya-event-system-lane-pack-v1",
+    lane_state: "first_party_event_system_family_present",
+    posture: "event_and_system_integration_proof_lane",
+    phase_alignment: {
+      phase_ref: phasePack.phase_ref,
+      phase_pack: phasePack,
+      phase_summary: summarizePhase7EventSystemPack(),
+      featured_lane: {
+        pack: natsPack,
+        summary: summarizePhase7NatsProofPack()
+      }
+    },
+    supported_surfaces: {
+      phase_summary_ref: "/v1/phases/phase-7/summary",
+      nats_proof_summary_ref: "/v1/phases/phase-7/nats/proof/summary",
+      kafka_proof_summary_ref: "/v1/phases/phase-7/kafka/proof/summary",
+      mqtt_proof_summary_ref: "/v1/phases/phase-7/mqtt/proof/summary",
+      webhook_proof_summary_ref: "/v1/phases/phase-7/webhook-event-bus/proof/summary",
+      continuity_summary_ref: "/v1/phases/phase-7/event-system-continuity/summary",
+      asyncapi_ref: "/asyncapi.json",
+      cloudevents_ref: "/cloudevents.json",
+      proof_bridge_ref: "/v1/proof-bridge/summary"
+    },
+    first_run_flows: [
+      {
+        flow_ref: "nats_subject_mesh_proof",
+        recommended_reason: "best first durable event-system lane for proof-bearing subject ingress and ack-carry review with NATS plus JetStream-style persistence posture",
+        sequence: [
+          "inspect_event_system_lane_summary",
+          "inspect_nats_proof_summary",
+          "inspect_asyncapi_and_cloudevents_contracts",
+          "inspect_proof_bridge_summary_for_followthrough"
+        ]
+      }
+    ],
+    guardrails: [
+      "event-system proof lanes extend bridge and followthrough rather than replace canonical proof review",
+      "nats and jetstream style durability should improve external proof interoperability without widening xoonya into a generic event bus"
+    ]
+  };
+}
+
+function summarizeEventSystemLanePack() {
+  const pack = buildEventSystemLanePack();
+  return {
+    product: "xoonya",
+    category: "proof-event-system-lane-pack-summary",
+    summary_version: "xoonya-event-system-lane-pack-summary-v1",
+    lane_state: pack.lane_state,
+    posture: pack.posture,
+    first_run_flow_count: pack.first_run_flows.length,
+    linked_surfaces: pack.supported_surfaces
+  };
+}
+
+module.exports = {
+  buildEventSystemLanePack,
+  summarizeEventSystemLanePack
+};

package/lib/external_proof_import_lane_contract.js

@@ -0,0 +1,87 @@
+"use strict";
+
+const {
+  buildPhase8ExternalResultImportProofPack,
+  summarizePhase8ExternalResultImportProofPack
+} = require("./phase_8_external_result_import_proof_pack");
+const {
+  buildPhase8ExternalReceiptImportProofPack,
+  summarizePhase8ExternalReceiptImportProofPack
+} = require("./phase_8_external_receipt_import_proof_pack");
+const {
+  buildPhase8ProofBundleNormalizationProofPack,
+  summarizePhase8ProofBundleNormalizationProofPack
+} = require("./phase_8_proof_bundle_normalization_proof_pack");
+const {
+  buildProofBridgeLanePack,
+  summarizeProofBridgeLanePack
+} = require("./proof_bridge_lane_contract");
+
+function buildExternalProofImportLanePack() {
+  return {
+    product: "xoonya",
+    category: "proof-external-proof-import-lane-pack",
+    pack_version: "xoonya-external-proof-import-lane-pack-v1",
+    lane_state: "first_party_external_proof_import_family_present",
+    posture: "external_result_receipt_and_bundle_import_followthrough_lane",
+    phase_alignment: {
+      external_result_import: {
+        pack: buildPhase8ExternalResultImportProofPack(),
+        summary: summarizePhase8ExternalResultImportProofPack()
+      },
+      external_receipt_import: {
+        pack: buildPhase8ExternalReceiptImportProofPack(),
+        summary: summarizePhase8ExternalReceiptImportProofPack()
+      },
+      proof_bundle_normalization: {
+        pack: buildPhase8ProofBundleNormalizationProofPack(),
+        summary: summarizePhase8ProofBundleNormalizationProofPack()
+      },
+      proof_bridge: {
+        pack: buildProofBridgeLanePack(),
+        summary: summarizeProofBridgeLanePack()
+      }
+    },
+    supported_surfaces: {
+      phase_summary_ref: "/v1/phases/phase-8/summary",
+      external_result_import_ref: "/v1/phases/phase-8/external-result-import/proof/summary",
+      external_receipt_import_ref: "/v1/phases/phase-8/external-receipt-import/proof/summary",
+      proof_bundle_normalization_ref: "/v1/phases/phase-8/proof-bundle-normalization/proof/summary",
+      proof_bridge_ref: "/v1/proof-bridge/summary"
+    },
+    first_run_flows: [
+      {
+        flow_ref: "external_proof_import_review",
+        recommended_reason: "best first path for showing outside builders that imported result, receipt, and bundle material can enter xoonya cleanly",
+        sequence: [
+          "inspect_external_proof_import_lane_summary",
+          "inspect_result_and_receipt_import_summaries",
+          "inspect_bundle_normalization_summary",
+          "inspect_proof_bridge_followthrough"
+        ]
+      }
+    ],
+    guardrails: [
+      "external proof import should strengthen builder trust rather than widen xoonya into arbitrary ingestion",
+      "imported material remains subordinate to review, governance, and bridge compatibility posture"
+    ]
+  };
+}
+
+function summarizeExternalProofImportLanePack() {
+  const pack = buildExternalProofImportLanePack();
+  return {
+    product: "xoonya",
+    category: "proof-external-proof-import-lane-pack-summary",
+    summary_version: "xoonya-external-proof-import-lane-pack-summary-v1",
+    lane_state: pack.lane_state,
+    phase_surface_count: Object.keys(pack.supported_surfaces).length,
+    first_run_flow_count: pack.first_run_flows.length,
+    linked_surfaces: pack.supported_surfaces
+  };
+}
+
+module.exports = {
+  buildExternalProofImportLanePack,
+  summarizeExternalProofImportLanePack
+};

package/lib/feature_control_lane_contract.js

@@ -0,0 +1,54 @@
+"use strict";
+
+function buildFeatureControlLanePack() {
+  return {
+    product: "xoonya",
+    category: "proof-feature-control-lane-pack",
+    pack_version: "xoonya-feature-control-lane-pack-v1",
+    lane_state: "first_party_feature_control_lane_present",
+    posture: "portable_review_and_rollout_control_lane",
+    standards: ["openfeature", "ofrep"],
+    focal_controls: ["role_freeze_policy", "proof_bridge_policy", "result_package_trust_policy", "review_and_governance_gates", "release_candidate_gates"],
+    supported_surfaces: {
+      role_freeze_ref: "/v1/role-freeze",
+      proof_bridge_ref: "/v1/proof-bridge",
+      result_package_trust_ref: "/v1/result-package-trust",
+      release_candidate_ref: "/v1/release-candidate",
+      integration_matrix_ref: "/v1/integration-matrix"
+    },
+    first_run_flows: [
+      {
+        flow_ref: "portable_proof_rollout_control_alignment",
+        recommended_reason: "best path for teams that need portable rollout and review posture without creating a second proof control plane",
+        sequence: [
+          "inspect_feature_control_lane_summary",
+          "map native role, bridge, and trust posture to portable feature-control semantics",
+          "use release and review gates as rollout-compatible control surfaces",
+          "keep xoonya proof and governance truth canonical beneath external control adapters"
+        ]
+      }
+    ],
+    guardrails: [
+      "feature control should expose rollout posture without replacing native proof, bridge, or governance truth",
+      "policy portability should remain bounded to avoid split-brain review semantics"
+    ]
+  };
+}
+
+function summarizeFeatureControlLanePack() {
+  const pack = buildFeatureControlLanePack();
+  return {
+    product: "xoonya",
+    category: "proof-feature-control-lane-pack-summary",
+    summary_version: "xoonya-feature-control-lane-pack-summary-v1",
+    lane_state: pack.lane_state,
+    standard_count: pack.standards.length,
+    focal_control_count: pack.focal_controls.length,
+    linked_surfaces: pack.supported_surfaces
+  };
+}
+
+module.exports = {
+  buildFeatureControlLanePack,
+  summarizeFeatureControlLanePack
+};

package/lib/framework_lane_contract.js

@@ -0,0 +1,76 @@
+"use strict";
+
+const {
+  buildPhase6FrameworkRuntimePack,
+  summarizePhase6FrameworkRuntimePack
+} = require("./phase_6_framework_runtime_pack");
+const {
+  summarizePhase6LanggraphProofPack
+} = require("./phase_6_langgraph_proof_pack");
+const {
+  summarizePhase6LangchainProofPack
+} = require("./phase_6_langchain_proof_pack");
+const {
+  summarizePhase6AutogenProofPack
+} = require("./phase_6_autogen_proof_pack");
+const {
+  summarizePhase6SemanticKernelProofPack
+} = require("./phase_6_semantic_kernel_proof_pack");
+
+function buildFrameworkLanePack() {
+  return {
+    product: "xoonya",
+    category: "proof-framework-lane-pack",
+    pack_version: "xoonya-framework-lane-pack-v1",
+    lane_state: "first_party_framework_family_present",
+    posture: "framework_followthrough_and_proof_carry_family",
+    framework_family: {
+      pack: buildPhase6FrameworkRuntimePack(),
+      summary: summarizePhase6FrameworkRuntimePack()
+    },
+    featured_frameworks: {
+      langgraph: summarizePhase6LanggraphProofPack(),
+      langchain: summarizePhase6LangchainProofPack(),
+      autogen: summarizePhase6AutogenProofPack(),
+      semantic_kernel: summarizePhase6SemanticKernelProofPack()
+    },
+    supported_surfaces: {
+      phase_6_summary_ref: "/v1/phases/phase-6/summary",
+      langgraph_summary_ref: "/v1/phases/phase-6/langgraph/proof/summary",
+      langchain_summary_ref: "/v1/phases/phase-6/langchain/proof/summary",
+      autogen_summary_ref: "/v1/phases/phase-6/autogen/proof/summary",
+      semantic_kernel_summary_ref: "/v1/phases/phase-6/semantic-kernel/proof/summary",
+      integrations_ref: "/v1/integrations"
+    },
+    first_run_flows: [
+      {
+        flow_ref: "framework_family_proof_selection",
+        recommended_reason: "best first path for understanding how orchestration frameworks retain proof continuity instead of becoming isolated compatibility notes",
+        sequence: [
+          "inspect_framework_lane_summary",
+          "inspect_phase_6_framework_summary",
+          "inspect_named_framework_proof_profiles",
+          "choose_framework_followthrough_shape"
+        ]
+      }
+    ]
+  };
+}
+
+function summarizeFrameworkLanePack() {
+  const pack = buildFrameworkLanePack();
+  return {
+    product: "xoonya",
+    category: "proof-framework-lane-pack-summary",
+    summary_version: "xoonya-framework-lane-pack-summary-v1",
+    lane_state: pack.lane_state,
+    featured_framework_count: Object.keys(pack.featured_frameworks).length,
+    first_run_flow_count: pack.first_run_flows.length,
+    linked_surfaces: pack.supported_surfaces
+  };
+}
+
+module.exports = {
+  buildFrameworkLanePack,
+  summarizeFrameworkLanePack
+};

package/lib/identity_interop_contract.js

@@ -0,0 +1,83 @@
+"use strict";
+
+const pkg = require("../package.json");
+
+function buildIdentityInteropContract() {
+  return {
+    product: "xoonya",
+    category: "proof-identity-interop-contract",
+    contract_version: "xoonya-identity-interop-contract-v1",
+    service_version: pkg.version,
+    primary_posture: "native_proof_and_attestation_followthrough_with_jwt_and_did_vc_interop",
+    supported_interop_profiles: [
+      {
+        profile_id: "jwt_jws_jwk_proof_assertions",
+        standards: ["jwt", "jws", "jwk"],
+        intended_use: "signed proof-side assertions and compact interop around verification and bridge intake",
+        primary_routes: ["/v1/proof-bundles/verify", "/v1/auth-profiles"]
+      },
+      {
+        profile_id: "did_vc_attestation_bridge",
+        standards: ["did_core", "vc_data_model"],
+        intended_use: "portable attestation and proof-bearing identity exchange around proof review and external verification",
+        primary_routes: ["/v1/phases/phase-4/identity-registry/proof", "/v1/phases/phase-4/attestation/proof"]
+      },
+      {
+        profile_id: "sd_jwt_vc_selective_review_disclosure",
+        standards: ["sd-jwt-vc", "jwt", "jws"],
+        intended_use: "bounded selective disclosure for proof-side review and bridge compatibility contexts",
+        primary_routes: ["/v1/proof-center/bridge/compatibility-pack", "/v1/proof-center/bridge/economic-handoff"]
+      },
+      {
+        profile_id: "oidc4vc_oidc4vp_wallet_verifier_optional",
+        standards: ["oidc4vc", "oidc4vp"],
+        intended_use: "optional verifier and wallet interoperability for external proof presentation ecosystems",
+        primary_routes: ["/v1/identity-interop", "/v1/proof-center/bridge/profile-support"]
+      }
+    ],
+    deferred_or_optional_profiles: [
+      { profile_id: "cose_cbor_compact_proof_artifacts", standards: ["cose", "cbor"], status: "later_or_environment_specific" },
+      { profile_id: "json_ld_vc_semantic_attestation_line", standards: ["json-ld-vc"], status: "later_or_ecosystem_specific" }
+    ],
+    native_mapping: {
+      proof_verify: "/v1/proof-bundles/verify",
+      receipt_verify: "/v1/receipts/verify",
+      bridge_economic_handoff: "/v1/proof-center/bridge/economic-handoff",
+      bridge_compatibility_pack: "/v1/proof-center/bridge/compatibility-pack",
+      phase_4_identity_registry_proof: "/v1/phases/phase-4/identity-registry/proof",
+      phase_4_attestation_proof: "/v1/phases/phase-4/attestation/proof"
+    },
+    guardrails: [
+      "proof and attestation semantics remain canonical inside xoonya rather than inside external credential formats",
+      "jwt and vc interop may carry proof-bearing identity claims but must not redefine proof truth",
+      "did or vc interoperability must remain subordinate to proof review and governance checks",
+      "selective disclosure may narrow disclosure scope but must not weaken proof-side reviewability"
+    ],
+    linked_surfaces: {
+      auth_interop_ref: "/v1/auth-profiles",
+      openapi_ref: "/openapi.json",
+      asyncapi_ref: "/asyncapi.json",
+      cloudevents_ref: "/cloudevents.json",
+      service_contract_ref: "SERVICE_CONTRACT.md"
+    }
+  };
+}
+
+function summarizeIdentityInteropContract() {
+  const contract = buildIdentityInteropContract();
+  return {
+    product: "xoonya",
+    category: "proof-identity-interop-contract-summary",
+    summary_version: "xoonya-identity-interop-contract-summary-v1",
+    contract_version: contract.contract_version,
+    profile_count: contract.supported_interop_profiles.length,
+    deferred_profile_count: contract.deferred_or_optional_profiles.length,
+    primary_posture: contract.primary_posture,
+    linked_surfaces: contract.linked_surfaces
+  };
+}
+
+module.exports = {
+  buildIdentityInteropContract,
+  summarizeIdentityInteropContract
+};

package/lib/integration_matrix_contract.js

@@ -0,0 +1,81 @@
+"use strict";
+
+const { summarizeProviderLanePack } = require("./provider_lane_contract");
+const { summarizeFrameworkLanePack } = require("./framework_lane_contract");
+const { summarizeMajorRailsProofLanePack } = require("./major_rails_proof_lane_contract");
+const { summarizeTreasuryProofLanePack } = require("./treasury_proof_lane_contract");
+const { summarizeErc8004ProofLanePack } = require("./erc8004_proof_lane_contract");
+const { summarizeProofBridgeLanePack } = require("./proof_bridge_lane_contract");
+const { summarizeExternalProofImportLanePack } = require("./external_proof_import_lane_contract");
+const { summarizeResultPackageTrustLanePack } = require("./result_package_trust_lane_contract");
+const { summarizeEventSystemLanePack } = require("./event_system_lane_contract");
+const { summarizeTelemetryLanePack } = require("./telemetry_lane_contract");
+const { summarizeProvenanceLanePack } = require("./provenance_lane_contract");
+const { summarizeArtifactDistributionLanePack } = require("./artifact_distribution_lane_contract");
+const { summarizeSharedSignalsLanePack } = require("./shared_signals_lane_contract");
+const { summarizeFeatureControlLanePack } = require("./feature_control_lane_contract");
+
+function buildIntegrationMatrixPack(integrations = []) {
+  const rows = Array.isArray(integrations) ? integrations : [];
+  return {
+    product: "xoonya",
+    category: "proof-integration-matrix-pack",
+    pack_version: "xoonya-integration-matrix-pack-v1",
+    posture: "canonical_public_view_of_provider_framework_proof_bridge_registry_and_trust_breadth",
+    counts: {
+      integration_count: rows.length,
+      builtin_count: rows.filter((entry) => entry.source === "builtin").length,
+      third_party_example_count: rows.filter((entry) => entry.source === "third_party_example").length,
+      production_default_count: rows.filter((entry) => entry.integration_maturity === "production_default").length,
+      certified_count: rows.filter((entry) => entry.certification_state === "certified").length
+    },
+    top_level_lanes: {
+      providers: summarizeProviderLanePack(),
+      frameworks: summarizeFrameworkLanePack(),
+      major_rails: summarizeMajorRailsProofLanePack(),
+      treasury: summarizeTreasuryProofLanePack(),
+      erc8004: summarizeErc8004ProofLanePack(),
+      proof_bridge: summarizeProofBridgeLanePack(),
+      external_proof_import: summarizeExternalProofImportLanePack(),
+      result_package_trust: summarizeResultPackageTrustLanePack(),
+      event_systems: summarizeEventSystemLanePack(),
+      telemetry: summarizeTelemetryLanePack(),
+      provenance: summarizeProvenanceLanePack(),
+      artifact_distribution: summarizeArtifactDistributionLanePack(),
+      shared_signals: summarizeSharedSignalsLanePack(),
+      feature_control: summarizeFeatureControlLanePack()
+    },
+    supported_surfaces: {
+      integrations_ref: "/v1/integrations",
+      integration_summary_ref: "/v1/integrations/summary",
+      provider_lane_ref: "/v1/providers",
+      framework_lane_ref: "/v1/frameworks",
+      proof_bridge_ref: "/v1/proof-bridge",
+      external_proof_import_ref: "/v1/external-proof-import",
+      telemetry_lane_ref: "/v1/telemetry",
+      provenance_lane_ref: "/v1/provenance",
+      artifact_distribution_lane_ref: "/v1/artifact-distribution",
+      shared_signals_lane_ref: "/v1/shared-signals",
+      feature_control_lane_ref: "/v1/feature-control"
+    }
+  };
+}
+
+function summarizeIntegrationMatrixPack(integrations = []) {
+  const pack = buildIntegrationMatrixPack(integrations);
+  return {
+    product: "xoonya",
+    category: "proof-integration-matrix-pack-summary",
+    summary_version: "xoonya-integration-matrix-pack-summary-v1",
+    integration_count: pack.counts.integration_count,
+    production_default_count: pack.counts.production_default_count,
+    certified_count: pack.counts.certified_count,
+    lane_count: Object.keys(pack.top_level_lanes).length,
+    linked_surfaces: pack.supported_surfaces
+  };
+}
+
+module.exports = {
+  buildIntegrationMatrixPack,
+  summarizeIntegrationMatrixPack
+};

package/lib/major_rails_proof_lane_contract.js

@@ -0,0 +1,87 @@
+"use strict";
+
+const {
+  buildPhase5MajorRailsPack,
+  summarizePhase5MajorRailsPack
+} = require("./phase_5_major_rails_pack");
+const {
+  buildPhase5SolanaProofPack,
+  summarizePhase5SolanaProofPack
+} = require("./phase_5_solana_proof_pack");
+const {
+  buildPhase5AntelopeProofPack,
+  summarizePhase5AntelopeProofPack
+} = require("./phase_5_antelope_proof_pack");
+const {
+  buildPhase5ProtonXprProofPack,
+  summarizePhase5ProtonXprProofPack
+} = require("./phase_5_proton_xpr_proof_pack");
+
+function buildMajorRailsProofLanePack() {
+  return {
+    product: "xoonya",
+    category: "proof-major-rails-lane-pack",
+    pack_version: "xoonya-major-rails-lane-pack-v1",
+    lane_state: "first_party_major_rails_proof_family_present",
+    posture: "practical_settlement_evidence_breadth_lane",
+    family_summary: summarizePhase5MajorRailsPack(),
+    featured_lanes: {
+      solana: {
+        pack: buildPhase5SolanaProofPack(),
+        summary: summarizePhase5SolanaProofPack()
+      },
+      antelope: {
+        pack: buildPhase5AntelopeProofPack(),
+        summary: summarizePhase5AntelopeProofPack()
+      },
+      proton_xpr_and_metal: {
+        pack: buildPhase5ProtonXprProofPack(),
+        summary: summarizePhase5ProtonXprProofPack(),
+        named_family_members: ["proton_xpr", "metal"]
+      }
+    },
+    supported_surfaces: {
+      phase_summary_ref: "/v1/phases/phase-5/summary",
+      major_rails_summary_ref: "/v1/phases/phase-5/major-rails-continuity/summary",
+      solana_proof_summary_ref: "/v1/phases/phase-5/solana/proof/summary",
+      antelope_proof_summary_ref: "/v1/phases/phase-5/antelope/proof/summary",
+      proton_xpr_proof_summary_ref: "/v1/phases/phase-5/proton-xpr/proof/summary",
+      proof_bridge_ref: "/v1/proof-bridge/summary"
+    },
+    first_run_flows: [
+      {
+        flow_ref: "major_rails_proof_selection",
+        recommended_reason: "best first path for understanding practical settlement-evidence breadth across non-default rail families",
+        sequence: [
+          "inspect_major_rails_proof_lane_summary",
+          "inspect_phase_5_major_rails_summary",
+          "inspect_solana_antelope_and_proton_xpr_proof_profiles",
+          "choose_the_proof_lane_that_matches_external_settlement_evidence_shape"
+        ]
+      }
+    ],
+    guardrails: [
+      "major rails proof lanes should strengthen trust and compatibility rather than widen xoonya into a generic chain toolkit",
+      "named ecosystems help adoption only when they remain subordinate to canonical proof review and bridge followthrough"
+    ]
+  };
+}
+
+function summarizeMajorRailsProofLanePack() {
+  const pack = buildMajorRailsProofLanePack();
+  return {
+    product: "xoonya",
+    category: "proof-major-rails-lane-pack-summary",
+    summary_version: "xoonya-major-rails-lane-pack-summary-v1",
+    lane_state: pack.lane_state,
+    posture: pack.posture,
+    featured_lane_count: Object.keys(pack.featured_lanes).length,
+    first_run_flow_count: pack.first_run_flows.length,
+    linked_surfaces: pack.supported_surfaces
+  };
+}
+
+module.exports = {
+  buildMajorRailsProofLanePack,
+  summarizeMajorRailsProofLanePack
+};