xytara 2.3.0 → 2.5.0

package/lib/event_system_lane_contract.js

@@ -0,0 +1,75 @@
+"use strict";
+
+const {
+  buildPhase7EventSystemPack,
+  summarizePhase7EventSystemPack
+} = require("./phase_7_event_system_pack");
+const {
+  buildPhase7NatsRuntimePack,
+  summarizePhase7NatsRuntimePack
+} = require("./phase_7_nats_runtime_pack");
+
+function buildEventSystemLanePack() {
+  const phasePack = buildPhase7EventSystemPack();
+  const natsPack = buildPhase7NatsRuntimePack();
+  return {
+    product: "xytara",
+    category: "machine-commerce-event-system-lane-pack",
+    pack_version: "xytara-event-system-lane-pack-v1",
+    lane_state: "first_party_event_system_family_present",
+    posture: "event_and_system_integration_runtime_lane",
+    phase_alignment: {
+      phase_ref: phasePack.phase_ref,
+      phase_pack: phasePack,
+      phase_summary: summarizePhase7EventSystemPack(),
+      featured_lane: {
+        pack: natsPack,
+        summary: summarizePhase7NatsRuntimePack()
+      }
+    },
+    supported_surfaces: {
+      phase_summary_ref: "/v1/phases/phase-7/summary",
+      nats_runtime_summary_ref: "/v1/phases/phase-7/nats/summary",
+      kafka_runtime_summary_ref: "/v1/phases/phase-7/kafka/summary",
+      mqtt_runtime_summary_ref: "/v1/phases/phase-7/mqtt/summary",
+      webhook_runtime_summary_ref: "/v1/phases/phase-7/webhook-event-bus/summary",
+      continuity_summary_ref: "/v1/phases/phase-7/event-system-continuity/summary",
+      asyncapi_ref: "/asyncapi.json",
+      cloudevents_ref: "/cloudevents.json"
+    },
+    first_run_flows: [
+      {
+        flow_ref: "nats_subject_mesh_runtime",
+        recommended_reason: "best first durable event/system lane for subject-oriented machine coordination with NATS plus JetStream-style persistence posture",
+        sequence: [
+          "inspect_event_system_lane_summary",
+          "inspect_nats_runtime_summary",
+          "inspect_asyncapi_and_cloudevents_contracts",
+          "choose_broker_or_callback_family_for_the_integration"
+        ]
+      }
+    ],
+    guardrails: [
+      "event-system lanes extend runtime coordination rather than replace the default transaction flow",
+      "nats and jetstream style durability should improve integration fit without widening the public runtime core into a generic bus platform"
+    ]
+  };
+}
+
+function summarizeEventSystemLanePack() {
+  const pack = buildEventSystemLanePack();
+  return {
+    product: "xytara",
+    category: "machine-commerce-event-system-lane-pack-summary",
+    summary_version: "xytara-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/feature_control_lane_contract.js

@@ -0,0 +1,54 @@
+"use strict";
+
+function buildFeatureControlLanePack() {
+  return {
+    product: "xytara",
+    category: "machine-commerce-feature-control-lane-pack",
+    pack_version: "xytara-feature-control-lane-pack-v1",
+    lane_state: "first_party_feature_control_lane_present",
+    posture: "portable_policy_and_rollout_control_lane",
+    standards: ["openfeature", "ofrep"],
+    focal_controls: ["pricing_policy", "authority_policy", "machine_identity_policy", "trust_policy", "release_candidate_gates"],
+    supported_surfaces: {
+      pricing_policy_ref: "/v1/economics/accounts/:account_id/pricing-policy-package",
+      authority_policy_ref: "/v1/economics/accounts/:account_id/authority-policy-pack",
+      machine_identity_policy_ref: "/v1/economics/accounts/:account_id/machine-identity-policy-pack",
+      trust_policy_ref: "/v1/economics/accounts/:account_id/trust-layer-policy-pack",
+      release_candidate_ref: "/v1/release-candidate"
+    },
+    first_run_flows: [
+      {
+        flow_ref: "portable_rollout_control_alignment",
+        recommended_reason: "best path for teams that need portable rollout and policy posture without inventing a second control plane around the runtime",
+        sequence: [
+          "inspect_feature_control_lane_summary",
+          "map native policy packs to portable feature-control posture",
+          "use release and trust gates as rollout-compatible control surfaces",
+          "keep xytara policy truth canonical beneath external control adapters"
+        ]
+      }
+    ],
+    guardrails: [
+      "feature control should expose rollout posture without replacing native pricing, authority, identity, or trust truth",
+      "policy portability should remain bounded to avoid accidental split-brain control semantics"
+    ]
+  };
+}
+
+function summarizeFeatureControlLanePack() {
+  const pack = buildFeatureControlLanePack();
+  return {
+    product: "xytara",
+    category: "machine-commerce-feature-control-lane-pack-summary",
+    summary_version: "xytara-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,89 @@
+"use strict";
+
+const {
+  buildPhase6FrameworkRuntimePack,
+  summarizePhase6FrameworkRuntimePack
+} = require("./phase_6_framework_runtime_pack");
+const {
+  summarizePhase6LanggraphRuntimePack
+} = require("./phase_6_langgraph_runtime_pack");
+const {
+  summarizePhase6LangchainRuntimePack
+} = require("./phase_6_langchain_runtime_pack");
+const {
+  summarizePhase6AutogenRuntimePack
+} = require("./phase_6_autogen_runtime_pack");
+const {
+  summarizePhase6SemanticKernelRuntimePack
+} = require("./phase_6_semantic_kernel_runtime_pack");
+
+function buildFrameworkLanePack() {
+  return {
+    product: "xytara",
+    category: "machine-commerce-framework-lane-pack",
+    pack_version: "xytara-framework-lane-pack-v1",
+    lane_state: "first_party_framework_family_present",
+    posture: "framework_orchestration_and_execution_family",
+    framework_family: {
+      pack: buildPhase6FrameworkRuntimePack(),
+      summary: summarizePhase6FrameworkRuntimePack()
+    },
+    featured_frameworks: {
+      langgraph: summarizePhase6LanggraphRuntimePack(),
+      langchain: summarizePhase6LangchainRuntimePack(),
+      autogen: summarizePhase6AutogenRuntimePack(),
+      semantic_kernel: summarizePhase6SemanticKernelRuntimePack()
+    },
+    registry_backed_frameworks: {
+      crewai: {
+        framework_id: "crewai",
+        posture: "registry-backed multi-agent workflow interoperability lane",
+        integration_ref: "builtin.execution.crewai"
+      },
+      llamaindex: {
+        framework_id: "llamaindex",
+        posture: "registry-backed retrieval and agent interoperability lane",
+        integration_ref: "builtin.execution.llamaindex"
+      }
+    },
+    supported_surfaces: {
+      phase_6_summary_ref: "/v1/phases/phase-6/summary",
+      langgraph_summary_ref: "/v1/phases/phase-6/langgraph/summary",
+      langchain_summary_ref: "/v1/phases/phase-6/langchain/summary",
+      autogen_summary_ref: "/v1/phases/phase-6/autogen/summary",
+      semantic_kernel_summary_ref: "/v1/phases/phase-6/semantic-kernel/summary",
+      integrations_ref: "/v1/integrations",
+      integration_matrix_ref: "/v1/integration-matrix"
+    },
+    first_run_flows: [
+      {
+        flow_ref: "framework_family_selection",
+        recommended_reason: "best first path for understanding how orchestration frameworks map into the canonical runtime instead of sitting as disconnected side examples",
+        sequence: [
+          "inspect_framework_lane_summary",
+          "inspect_phase_6_framework_summary",
+          "inspect_named_framework_profiles",
+          "choose_framework_shape_that_best_matches_runtime_carry_needs"
+        ]
+      }
+    ]
+  };
+}
+
+function summarizeFrameworkLanePack() {
+  const pack = buildFrameworkLanePack();
+  return {
+    product: "xytara",
+    category: "machine-commerce-framework-lane-pack-summary",
+    summary_version: "xytara-framework-lane-pack-summary-v1",
+    lane_state: pack.lane_state,
+    featured_framework_count: Object.keys(pack.featured_frameworks).length + Object.keys(pack.registry_backed_frameworks).length,
+    first_run_flow_count: pack.first_run_flows.length,
+    linked_surfaces: pack.supported_surfaces
+  };
+}
+
+module.exports = {
+  buildFrameworkLanePack,
+  summarizeFrameworkLanePack
+};

package/lib/identity_auth.js

@@ -0,0 +1,175 @@
+"use strict";
+
+function normalizeString(value, fallback = null) {
+  const trimmed = typeof value === "string" ? value.trim() : "";
+  return trimmed || fallback;
+}
+
+function ensureArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function buildIdentityBindingPublicView(binding) {
+  if (!binding) return null;
+  return {
+    binding_id: binding.binding_id,
+    account_id: binding.account_id,
+    status: binding.status,
+    identity_kind: binding.identity_kind,
+    identity_ref: binding.identity_ref,
+    registry_scope: binding.registry_scope || null,
+    attached_agent_account_id: binding.attached_agent_account_id || null,
+    source_transaction_id: binding.source_transaction_id || null,
+    expires_at_iso: binding.expires_at_iso || null,
+    rotated_from_binding_id: binding.rotated_from_binding_id || null,
+    replaced_by_binding_id: binding.replaced_by_binding_id || null,
+    created_at_iso: binding.created_at_iso,
+    updated_at_iso: binding.updated_at_iso,
+    revoked_at_iso: binding.revoked_at_iso || null,
+    revoke_reason: binding.revoke_reason || null,
+    labels: ensureArray(binding.labels),
+    issued_by: binding.issued_by || null
+  };
+}
+
+function createIdentityBinding(state, body) {
+  const payload = body && typeof body === "object" && !Array.isArray(body) ? body : {};
+  const createdAtIso = nowIso();
+  const binding = {
+    binding_id: normalizeString(payload.binding_id, `identity_binding_${state.machineIdentityBindings.size + 1}`),
+    account_id: normalizeString(payload.account_id, "acct_demo"),
+    status: normalizeString(payload.status, "active"),
+    identity_kind: normalizeString(payload.identity_kind, "registry_anchor_identity"),
+    identity_ref: normalizeString(payload.identity_ref, `identity_ref_${state.machineIdentityBindings.size + 1}`),
+    registry_scope: normalizeString(payload.registry_scope, null),
+    attached_agent_account_id: normalizeString(payload.attached_agent_account_id, null),
+    source_transaction_id: normalizeString(payload.source_transaction_id, null),
+    expires_at_iso: normalizeString(payload.expires_at_iso, null),
+    labels: ensureArray(payload.labels).map((value) => String(value || "").trim()).filter(Boolean),
+    issued_by: normalizeString(payload.issued_by, "operator"),
+    rotated_from_binding_id: normalizeString(payload.rotated_from_binding_id, null),
+    replaced_by_binding_id: normalizeString(payload.replaced_by_binding_id, null),
+    created_at_iso: createdAtIso,
+    updated_at_iso: createdAtIso,
+    revoked_at_iso: null,
+    revoke_reason: null
+  };
+  state.machineIdentityBindings.set(binding.binding_id, binding);
+  return buildIdentityBindingPublicView(binding);
+}
+
+function listIdentityBindings(state, filters) {
+  const payload = filters && typeof filters === "object" && !Array.isArray(filters) ? filters : {};
+  const accountId = normalizeString(payload.account_id, null);
+  const status = normalizeString(payload.status, null);
+  return Array.from(state.machineIdentityBindings.values())
+    .filter((binding) => {
+      if (accountId && binding.account_id !== accountId) return false;
+      if (status && binding.status !== status) return false;
+      return true;
+    })
+    .map((binding) => buildIdentityBindingPublicView(binding));
+}
+
+function getIdentityBinding(state, bindingId) {
+  if (!bindingId || !state.machineIdentityBindings.has(bindingId)) return null;
+  return buildIdentityBindingPublicView(state.machineIdentityBindings.get(bindingId));
+}
+
+function revokeIdentityBinding(state, bindingId, body) {
+  if (!bindingId || !state.machineIdentityBindings.has(bindingId)) return null;
+  const payload = body && typeof body === "object" && !Array.isArray(body) ? body : {};
+  const current = state.machineIdentityBindings.get(bindingId);
+  const next = {
+    ...current,
+    status: "revoked",
+    revoked_at_iso: nowIso(),
+    revoke_reason: normalizeString(payload.reason, "operator_revoked"),
+    updated_at_iso: nowIso()
+  };
+  state.machineIdentityBindings.set(bindingId, next);
+  return buildIdentityBindingPublicView(next);
+}
+
+function getIdentityBindingRotationSummary(state, bindingId) {
+  if (!bindingId || !state.machineIdentityBindings.has(bindingId)) return null;
+  const binding = state.machineIdentityBindings.get(bindingId);
+  return {
+    summary_version: "xytara-identity-binding-rotation-summary-v1",
+    binding_id: binding.binding_id,
+    account_id: binding.account_id,
+    status: binding.status,
+    predecessor_binding_id: binding.rotated_from_binding_id || null,
+    successor_binding_id: binding.replaced_by_binding_id || null,
+    expires_at_iso: binding.expires_at_iso || null,
+    rotation_state: binding.rotated_from_binding_id || binding.replaced_by_binding_id
+      ? "lineage_present"
+      : "standalone",
+    linked_surfaces: {
+      identity_binding_ref: `/v1/identity/bindings/${encodeURIComponent(binding.binding_id)}`
+    },
+    generated_at_iso: nowIso()
+  };
+}
+
+function renewIdentityBinding(state, bindingId, body) {
+  if (!bindingId || !state.machineIdentityBindings.has(bindingId)) return null;
+  const payload = body && typeof body === "object" && !Array.isArray(body) ? body : {};
+  const current = state.machineIdentityBindings.get(bindingId);
+  const next = {
+    ...current,
+    expires_at_iso: normalizeString(payload.expires_at_iso, current.expires_at_iso || null),
+    updated_at_iso: nowIso()
+  };
+  state.machineIdentityBindings.set(bindingId, next);
+  return buildIdentityBindingPublicView(next);
+}
+
+function rotateIdentityBinding(state, bindingId, body) {
+  if (!bindingId || !state.machineIdentityBindings.has(bindingId)) return null;
+  const payload = body && typeof body === "object" && !Array.isArray(body) ? body : {};
+  const current = state.machineIdentityBindings.get(bindingId);
+  const successorBindingId = normalizeString(payload.successor_binding_id, `${bindingId}_rotated`);
+  const successor = createIdentityBinding(state, {
+    binding_id: successorBindingId,
+    account_id: current.account_id,
+    identity_kind: normalizeString(payload.identity_kind, current.identity_kind),
+    identity_ref: normalizeString(payload.identity_ref, current.identity_ref),
+    registry_scope: normalizeString(payload.registry_scope, current.registry_scope),
+    attached_agent_account_id: normalizeString(payload.attached_agent_account_id, current.attached_agent_account_id),
+    source_transaction_id: normalizeString(payload.source_transaction_id, current.source_transaction_id),
+    expires_at_iso: normalizeString(payload.expires_at_iso, current.expires_at_iso || null),
+    labels: ensureArray(payload.labels).length > 0 ? ensureArray(payload.labels) : ensureArray(current.labels),
+    issued_by: normalizeString(payload.issued_by, current.issued_by || "operator"),
+    rotated_from_binding_id: current.binding_id
+  });
+  revokeIdentityBinding(state, bindingId, {
+    reason: normalizeString(payload.reason, "rotated_to_successor")
+  });
+  state.machineIdentityBindings.set(successor.binding_id, {
+    ...state.machineIdentityBindings.get(successor.binding_id),
+    rotated_from_binding_id: current.binding_id
+  });
+  state.machineIdentityBindings.set(bindingId, {
+    ...state.machineIdentityBindings.get(bindingId),
+    replaced_by_binding_id: successor.binding_id
+  });
+  return {
+    rotated_binding: buildIdentityBindingPublicView(state.machineIdentityBindings.get(bindingId)),
+    successor_identity_binding: buildIdentityBindingPublicView(state.machineIdentityBindings.get(successor.binding_id))
+  };
+}
+
+module.exports = {
+  createIdentityBinding,
+  listIdentityBindings,
+  getIdentityBinding,
+  getIdentityBindingRotationSummary,
+  renewIdentityBinding,
+  revokeIdentityBinding,
+  rotateIdentityBinding
+};

package/lib/identity_interop_contract.js

@@ -0,0 +1,82 @@
+"use strict";
+
+const pkg = require("../package.json");
+
+function buildIdentityInteropContract() {
+  return {
+    product: "xytara",
+    category: "machine-commerce-identity-interop-contract",
+    contract_version: "xytara-identity-interop-contract-v1",
+    service_version: pkg.version,
+    primary_posture: "native_machine_identity_and_authority_with_jwt_and_did_vc_interop",
+    supported_interop_profiles: [
+      {
+        profile_id: "jwt_jws_jwk_runtime_claims",
+        standards: ["jwt", "jws", "jwk"],
+        intended_use: "portable signed claims and upstream assertion interop around runtime access",
+        primary_routes: ["/v1/auth-profiles", "/v1/account-auth/authority-bindings", "/v1/account-auth/spend-credentials"]
+      },
+      {
+        profile_id: "did_vc_machine_identity_bridge",
+        standards: ["did_core", "vc_data_model"],
+        intended_use: "portable machine identity and attestation mapping around native identity bindings",
+        primary_routes: ["/v1/identity/bindings", "/v1/economics/accounts/:account_id/machine-identity-summary"]
+      },
+      {
+        profile_id: "sd_jwt_vc_bounded_disclosure",
+        standards: ["sd-jwt-vc", "jwt", "jws"],
+        intended_use: "selective-disclosure identity or authority assertions without replacing native consequence controls",
+        primary_routes: ["/v1/account-auth/authority-bindings", "/v1/identity/bindings"]
+      },
+      {
+        profile_id: "oidc4vc_oidc4vp_wallet_presentation_optional",
+        standards: ["oidc4vc", "oidc4vp"],
+        intended_use: "optional wallet and presentation interoperability for partner identity exchange",
+        primary_routes: ["/v1/identity-interop", "/v1/auth-profiles"]
+      }
+    ],
+    deferred_or_optional_profiles: [
+      { profile_id: "cose_cbor_compact_identity_artifacts", standards: ["cose", "cbor"], status: "later_or_environment_specific" },
+      { profile_id: "json_ld_vc_semantic_credential_line", standards: ["json-ld-vc"], status: "later_or_ecosystem_specific" }
+    ],
+    native_mapping: {
+      identity_bindings: "/v1/identity/bindings",
+      authority_bindings: "/v1/account-auth/authority-bindings",
+      spend_credentials: "/v1/account-auth/spend-credentials",
+      machine_identity_summary: "/v1/economics/accounts/:account_id/machine-identity-summary",
+      authority_summary: "/v1/economics/accounts/:account_id/authority-summary"
+    },
+    guardrails: [
+      "native machine identity bindings remain canonical inside xytara",
+      "jwt and vc profiles may carry claims but must not replace native authority or consequence bounds",
+      "did or vc interoperability must remain subordinate to runtime identity and authority truth",
+      "selective disclosure may narrow exposure but must not weaken operator auditability"
+    ],
+    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: "xytara",
+    category: "machine-commerce-identity-interop-contract-summary",
+    summary_version: "xytara-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,93 @@
+"use strict";
+
+const { summarizeProviderLanePack } = require("./provider_lane_contract");
+const { summarizeFrameworkLanePack } = require("./framework_lane_contract");
+const { summarizeProtocolLanePack } = require("./protocol_lane_contract");
+const { summarizeMcpLanePack } = require("./mcp_lane_contract");
+const { summarizeA2ALanePack } = require("./a2a_lane_contract");
+const { summarizeA2CLanePack } = require("./a2c_lane_contract");
+const { summarizeX402LanePack } = require("./x402_lane_contract");
+const { summarizeSettlementLanePack } = require("./settlement_lane_contract");
+const { summarizeStablecoinLanePack } = require("./stablecoin_lane_contract");
+const { summarizeMajorRailsLanePack } = require("./major_rails_lane_contract");
+const { summarizeTreasuryLanePack } = require("./treasury_lane_contract");
+const { summarizeErc8004LanePack } = require("./erc8004_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: "xytara",
+    category: "machine-commerce-integration-matrix-pack",
+    pack_version: "xytara-integration-matrix-pack-v1",
+    posture: "canonical_public_view_of_provider_framework_protocol_payment_settlement_and_registry_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(),
+      protocols: summarizeProtocolLanePack(),
+      mcp: summarizeMcpLanePack(),
+      a2a: summarizeA2ALanePack(),
+      a2c: summarizeA2CLanePack(),
+      x402: summarizeX402LanePack(),
+      settlement: summarizeSettlementLanePack(),
+      stablecoins: summarizeStablecoinLanePack(),
+      major_rails: summarizeMajorRailsLanePack(),
+      treasury: summarizeTreasuryLanePack(),
+      erc8004: summarizeErc8004LanePack(),
+      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",
+      protocol_lane_ref: "/v1/protocols",
+      mcp_lane_ref: "/v1/mcp",
+      settlement_lane_ref: "/v1/settlement",
+      event_system_lane_ref: "/v1/event-systems",
+      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",
+      treasury_lane_ref: "/v1/treasury",
+      integration_protocols_ref: "/v1/integrations/protocols"
+    }
+  };
+}
+
+function summarizeIntegrationMatrixPack(integrations = []) {
+  const pack = buildIntegrationMatrixPack(integrations);
+  return {
+    product: "xytara",
+    category: "machine-commerce-integration-matrix-pack-summary",
+    summary_version: "xytara-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_lane_contract.js

@@ -0,0 +1,90 @@
+"use strict";
+
+const {
+  buildPhase5MajorRailsPack,
+  summarizePhase5MajorRailsPack
+} = require("./phase_5_major_rails_pack");
+const {
+  buildPhase5SolanaRuntimePack,
+  summarizePhase5SolanaRuntimePack
+} = require("./phase_5_solana_runtime_pack");
+const {
+  buildPhase5AntelopeRuntimePack,
+  summarizePhase5AntelopeRuntimePack
+} = require("./phase_5_antelope_runtime_pack");
+const {
+  buildPhase5ProtonXprRuntimePack,
+  summarizePhase5ProtonXprRuntimePack
+} = require("./phase_5_proton_xpr_runtime_pack");
+
+function buildMajorRailsLanePack() {
+  const phasePack = buildPhase5MajorRailsPack();
+  return {
+    product: "xytara",
+    category: "machine-commerce-major-rails-lane-pack",
+    pack_version: "xytara-major-rails-lane-pack-v1",
+    lane_state: "first_party_major_rails_family_present",
+    posture: "practical_non_default_settlement_breadth_lane",
+    family_summary: summarizePhase5MajorRailsPack(),
+    featured_lanes: {
+      solana: {
+        pack: buildPhase5SolanaRuntimePack(),
+        summary: summarizePhase5SolanaRuntimePack()
+      },
+      antelope: {
+        pack: buildPhase5AntelopeRuntimePack(),
+        summary: summarizePhase5AntelopeRuntimePack()
+      },
+      proton_xpr_and_metal: {
+        pack: buildPhase5ProtonXprRuntimePack(),
+        summary: summarizePhase5ProtonXprRuntimePack(),
+        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_summary_ref: "/v1/phases/phase-5/solana/summary",
+      antelope_summary_ref: "/v1/phases/phase-5/antelope/summary",
+      proton_xpr_summary_ref: "/v1/phases/phase-5/proton-xpr/summary",
+      settlement_family_ref: "/v1/settlement",
+      stablecoin_lane_ref: "/v1/stablecoins"
+    },
+    first_run_flows: [
+      {
+        flow_ref: "major_rails_family_selection",
+        recommended_reason: "best first path for understanding practical non-default settlement breadth beyond the native and stablecoin defaults",
+        sequence: [
+          "inspect_major_rails_lane_summary",
+          "inspect_phase_5_major_rails_summary",
+          "inspect_solana_antelope_and_proton_xpr_profiles",
+          "choose_the_lane_that_best_matches_integrator_ecosystem_fit"
+        ]
+      }
+    ],
+    guardrails: [
+      "major rails should stay a practical settlement family rather than turn xytara into a generic chain abstraction layer",
+      "named ecosystems improve adoption only when they remain subordinate to the canonical transaction and economics model"
+    ],
+    phase_alignment: phasePack
+  };
+}
+
+function summarizeMajorRailsLanePack() {
+  const pack = buildMajorRailsLanePack();
+  return {
+    product: "xytara",
+    category: "machine-commerce-major-rails-lane-pack-summary",
+    summary_version: "xytara-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 = {
+  buildMajorRailsLanePack,
+  summarizeMajorRailsLanePack
+};