xytara 2.5.0 → 2.6.0

package/lib/activity_audit_contract.js

@@ -0,0 +1,322 @@
+"use strict";
+
+function toArrayFromMap(mapValue) {
+  if (!(mapValue instanceof Map)) return [];
+  return Array.from(mapValue.values());
+}
+
+function normalizeTimestamp(value) {
+  if (typeof value !== "string" || !value.trim()) return null;
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? new Date(parsed).toISOString() : null;
+}
+
+function firstTimestamp(record, fieldNames) {
+  for (const fieldName of fieldNames) {
+    const timestamp = normalizeTimestamp(record && record[fieldName]);
+    if (timestamp) return timestamp;
+  }
+  return null;
+}
+
+function sortByTimestampDescending(items) {
+  return [...items].sort((left, right) => {
+    const leftTime = left && left.at_iso ? Date.parse(left.at_iso) : 0;
+    const rightTime = right && right.at_iso ? Date.parse(right.at_iso) : 0;
+    return rightTime - leftTime;
+  });
+}
+
+function buildQuoteActivities(state, accountId) {
+  return toArrayFromMap(state.quotes)
+    .filter((quote) => !accountId || quote.account_id === accountId)
+    .map((quote) => ({
+      activity_id: `quote.${quote.quote_id}`,
+      activity_kind: "quote",
+      activity_family: "commercial_admission",
+      at_iso: firstTimestamp(quote, ["executed_at_iso", "payment_recorded_at_iso", "created_at_iso"]),
+      account_id: quote.account_id || null,
+      actor_ref: quote.account_id || null,
+      action: quote.status === "executed" ? "quoted_and_executed" : "quoted",
+      status: quote.status || null,
+      amount_minor: quote.amount_minor || null,
+      currency: quote.currency || null,
+      settlement_mode: quote.settlement_mode || null,
+      payment_protocol: quote.payment_protocol || null,
+      route_ref: "/v1/payment-quotes",
+      linked_refs: {
+        quote_ref: quote.quote_id ? `/v1/quotes/${encodeURIComponent(quote.quote_id)}` : null
+      }
+    }));
+}
+
+function buildTransactionActivities(state, accountId) {
+  return toArrayFromMap(state.transactions)
+    .map((entry) => entry && entry.transaction ? entry.transaction : null)
+    .filter(Boolean)
+    .filter((transaction) => !accountId || transaction.account_id === accountId)
+    .map((transaction) => ({
+      activity_id: `transaction.${transaction.transaction_id}`,
+      activity_kind: "transaction",
+      activity_family: "runtime_execution",
+      at_iso: firstTimestamp(transaction, ["completed_at_iso", "created_at_iso"]),
+      account_id: transaction.account_id || null,
+      actor_ref: transaction.account_id || null,
+      action: "executed_runtime_work",
+      status: transaction.status || null,
+      amount_minor: transaction.payment && transaction.payment.amount_minor ? transaction.payment.amount_minor : null,
+      currency: transaction.payment && transaction.payment.currency ? transaction.payment.currency : null,
+      settlement_mode: transaction.settlement && transaction.settlement.mode ? transaction.settlement.mode : null,
+      payment_protocol: transaction.payment && transaction.payment.protocol ? transaction.payment.protocol : null,
+      delivery_target_kind: transaction.callback_url ? "callback" : "direct",
+      route_ref: "/v1/commands/execute",
+      linked_refs: {
+        transaction_ref: transaction.transaction_id ? `/v1/transactions/${encodeURIComponent(transaction.transaction_id)}` : null,
+        proof_ref: transaction.proof_ref || null
+      }
+    }));
+}
+
+function buildReceiptActivities(state, accountId) {
+  return toArrayFromMap(state.receipts)
+    .map((entry) => entry && entry.receipt ? entry.receipt : null)
+    .filter(Boolean)
+    .filter((receipt) => !accountId || receipt.account_id === accountId)
+    .map((receipt) => ({
+      activity_id: `receipt.${receipt.receipt_id}`,
+      activity_kind: "receipt",
+      activity_family: "delivery_proof",
+      at_iso: firstTimestamp(receipt, ["created_at_iso", "completed_at_iso"]),
+      account_id: receipt.account_id || null,
+      actor_ref: receipt.account_id || null,
+      action: "receipt_issued",
+      status: receipt.status || null,
+      proof_ref: receipt.proof_ref || null,
+      route_ref: receipt.receipt_id ? `/v1/receipts/${encodeURIComponent(receipt.receipt_id)}` : "/v1/receipts",
+      linked_refs: {
+        receipt_ref: receipt.receipt_id ? `/v1/receipts/${encodeURIComponent(receipt.receipt_id)}` : null
+      }
+    }));
+}
+
+function buildPaymentActivities(state, accountId) {
+  const ledger = Array.isArray(state.paymentLedger) ? state.paymentLedger : [];
+  return ledger
+    .filter((payment) => !accountId || payment.account_id === accountId)
+    .map((payment) => ({
+      activity_id: `payment.${payment.payment_id}`,
+      activity_kind: "payment",
+      activity_family: "funds_in",
+      at_iso: firstTimestamp(payment, ["recorded_at_iso"]),
+      account_id: payment.account_id || null,
+      actor_ref: payment.account_id || null,
+      action: "payment_recorded",
+      status: payment.payment && payment.payment.status ? payment.payment.status : null,
+      amount_minor: payment.amount_minor || null,
+      currency: payment.currency || null,
+      settlement_mode: payment.settlement && payment.settlement.mode ? payment.settlement.mode : null,
+      settlement_adapter: payment.settlement_adapter || null,
+      settlement_integration_id: payment.settlement_integration_id || null,
+      payment_protocol: payment.payment && payment.payment.protocol ? payment.payment.protocol : null,
+      treasury_destination_id: payment.treasury && payment.treasury.destination_id ? payment.treasury.destination_id : null,
+      treasury_external_ref: payment.treasury && payment.treasury.custody_external_ref ? payment.treasury.custody_external_ref : null,
+      route_ref: payment.payment_id ? `/v1/payment-ledger/${encodeURIComponent(payment.payment_id)}` : "/v1/payment-ledger",
+      linked_refs: {
+        payment_ref: payment.payment_id ? `/v1/payment-ledger/${encodeURIComponent(payment.payment_id)}` : null,
+        operator_pack_ref: payment.payment_id ? `/v1/payment-ledger/${encodeURIComponent(payment.payment_id)}/operator-pack` : null
+      }
+    }));
+}
+
+function buildDeliveryActivities(state, accountId) {
+  return toArrayFromMap(state.deliveries)
+    .filter((delivery) => !accountId || delivery.account_id === accountId)
+    .map((delivery) => ({
+      activity_id: `delivery.${delivery.delivery_id}`,
+      activity_kind: "delivery",
+      activity_family: "delivery_proof",
+      at_iso: firstTimestamp(delivery, ["delivered_at_iso", "last_attempt_at_iso", "created_at_iso"]),
+      account_id: delivery.account_id || null,
+      actor_ref: delivery.account_id || null,
+      action: delivery.status === "delivered" ? "delivered_result" : "delivery_pending",
+      status: delivery.status || null,
+      output_ref: delivery.output_ref || null,
+      proof_ref: delivery.proof_ref || null,
+      payment_id: delivery.payment_id || null,
+      delivery_target_kind: delivery.delivery_target_kind || null,
+      route_ref: delivery.transaction_id ? `/v1/transactions/${encodeURIComponent(delivery.transaction_id)}` : null,
+      linked_refs: {
+        transaction_ref: delivery.transaction_id ? `/v1/transactions/${encodeURIComponent(delivery.transaction_id)}` : null,
+        receipt_ref: delivery.receipt_id ? `/v1/receipts/${encodeURIComponent(delivery.receipt_id)}` : null
+      }
+    }));
+}
+
+function buildHistoryActivities(records, accountId, config) {
+  return records.flatMap((record) => {
+    const history = Array.isArray(record && record.history) ? record.history : [];
+    return history
+      .filter((entry) => {
+        const recordAccountId = record && record.account_id ? record.account_id : null;
+        const transactionId = record && record.transaction_id ? record.transaction_id : null;
+        if (!accountId) return true;
+        return recordAccountId === accountId || transactionId === accountId || record && record.requested_by === accountId;
+      })
+      .map((entry, index) => ({
+        activity_id: `${config.prefix}.${record[config.idField]}.${index}`,
+        activity_kind: config.kind,
+        activity_family: config.family,
+        at_iso: firstTimestamp(entry, ["at_iso"]) || firstTimestamp(record, ["updated_at_iso", "created_at_iso"]),
+        account_id: record && record.account_id ? record.account_id : null,
+        actor_ref: entry && entry.actor ? `${entry.actor.type || "actor"}:${entry.actor.role || "unknown"}` : null,
+        action: entry && entry.event ? entry.event : config.defaultAction,
+        status: entry && entry.next_status ? entry.next_status : record.status || null,
+        reason_code: entry && entry.reason_code ? entry.reason_code : record.reason_code || null,
+        note: entry && entry.note ? entry.note : null,
+        route_ref: config.routeTemplate(record[config.idField]),
+        linked_refs: {
+          transaction_ref: record && record.transaction_id ? `/v1/transactions/${encodeURIComponent(record.transaction_id)}` : null,
+          receipt_ref: record && record.receipt_id ? `/v1/receipts/${encodeURIComponent(record.receipt_id)}` : null
+        }
+      }));
+  });
+}
+
+function buildCreditGrantActivities(state, accountId) {
+  return toArrayFromMap(state.externalCreditGrants)
+    .filter((grant) => !accountId || grant.account_id === accountId)
+    .map((grant) => ({
+      activity_id: `credit_grant.${grant.grant_id || grant.credit_grant_id || grant.account_id || "unknown"}`,
+      activity_kind: "credit_grant",
+      activity_family: "funding",
+      at_iso: firstTimestamp(grant, ["created_at_iso", "granted_at_iso", "recorded_at_iso"]),
+      account_id: grant.account_id || null,
+      actor_ref: grant.account_id || null,
+      action: "credit_granted",
+      status: grant.status || null,
+      amount_minor: grant.amount_minor || grant.credit_amount_minor || null,
+      currency: grant.currency || null,
+      route_ref: "/v1/credit-bridge/grants",
+      linked_refs: {}
+    }));
+}
+
+function buildBridgeActivities(state, accountId) {
+  return toArrayFromMap(state.runtimeBridgeDispatches)
+    .filter((dispatch) => !accountId || dispatch.account_id === accountId)
+    .map((dispatch) => ({
+      activity_id: `bridge.${dispatch.dispatch_id || dispatch.bridge_dispatch_id || "unknown"}`,
+      activity_kind: "bridge_dispatch",
+      activity_family: "runtime_proof_handoff",
+      at_iso: firstTimestamp(dispatch, ["created_at_iso", "dispatched_at_iso", "recorded_at_iso"]),
+      account_id: dispatch.account_id || null,
+      actor_ref: dispatch.account_id || null,
+      action: "bridge_dispatched",
+      status: dispatch.status || null,
+      route_ref: "/v1/proof-bridge",
+      linked_refs: {
+        proof_ref: dispatch.proof_ref || null,
+        receipt_ref: dispatch.receipt_id ? `/v1/receipts/${encodeURIComponent(dispatch.receipt_id)}` : null
+      }
+    }));
+}
+
+function buildParticipantActivities(records, kind, routeRef) {
+  return records.map((participant) => ({
+    activity_id: `${kind}.${participant.participant_id || participant.operator_id || participant.network_participant_id || "unknown"}`,
+    activity_kind: kind,
+    activity_family: "third_party_participation",
+    at_iso: firstTimestamp(participant, ["created_at_iso", "updated_at_iso", "admitted_at_iso"]),
+    account_id: participant.account_id || null,
+    actor_ref: participant.account_id || null,
+    action: `registered_${kind}`,
+    status: participant.status || null,
+    route_ref: routeRef,
+    linked_refs: {}
+  }));
+}
+
+function buildActivityLedger(state, options) {
+  const accountId = options && options.account_id ? options.account_id : null;
+  const activities = sortByTimestampDescending([
+    ...buildQuoteActivities(state, accountId),
+    ...buildTransactionActivities(state, accountId),
+    ...buildReceiptActivities(state, accountId),
+    ...buildPaymentActivities(state, accountId),
+    ...buildDeliveryActivities(state, accountId),
+    ...buildHistoryActivities(toArrayFromMap(state.refunds), accountId, {
+      prefix: "refund",
+      idField: "refund_id",
+      kind: "refund",
+      family: "remediation",
+      defaultAction: "refund_review",
+      routeTemplate: (id) => `/v1/refunds/${encodeURIComponent(id)}`
+    }),
+    ...buildHistoryActivities(toArrayFromMap(state.disputes), accountId, {
+      prefix: "dispute",
+      idField: "dispute_id",
+      kind: "dispute",
+      family: "remediation",
+      defaultAction: "dispute_review",
+      routeTemplate: (id) => `/v1/disputes/${encodeURIComponent(id)}`
+    }),
+    ...buildHistoryActivities(toArrayFromMap(state.remediationTickets), accountId, {
+      prefix: "remediation_ticket",
+      idField: "ticket_id",
+      kind: "remediation_ticket",
+      family: "remediation",
+      defaultAction: "remediation_review",
+      routeTemplate: (id) => `/v1/remediation-tickets/${encodeURIComponent(id)}`
+    }),
+    ...buildCreditGrantActivities(state, accountId),
+    ...buildBridgeActivities(state, accountId),
+    ...buildParticipantActivities(toArrayFromMap(state.operatorParticipants), "operator_participant", "/v1/multi-operator"),
+    ...buildParticipantActivities(toArrayFromMap(state.networkParticipants), "network_participant", "/v1/network-participation")
+  ]).slice(0, 300);
+
+  return {
+    product: "xytara",
+    category: "machine-commerce-activity-ledger",
+    pack_version: "xytara-activity-ledger-v1",
+    posture: "operator_facing_runtime_and_funds_activity_visibility",
+    audit_posture: "operator_visibility_first",
+    account_scope: accountId || "all_accounts",
+    counts: {
+      activity_count: activities.length,
+      payment_count: activities.filter((entry) => entry.activity_kind === "payment").length,
+      transaction_count: activities.filter((entry) => entry.activity_kind === "transaction").length,
+      delivery_count: activities.filter((entry) => entry.activity_kind === "delivery").length,
+      remediation_count: activities.filter((entry) => entry.activity_family === "remediation").length,
+      participation_count: activities.filter((entry) => entry.activity_family === "third_party_participation").length
+    },
+    activities,
+    linked_surfaces: {
+      payment_ledger_ref: "/v1/payment-ledger",
+      reconciliation_report_ref: "/v1/reconciliation-report",
+      integration_registry_ref: "/v1/integrations",
+      treasury_summary_ref_template: "/v1/economics/accounts/:account_id/treasury-summary",
+      rail_summary_ref_template: "/v1/economics/accounts/:account_id/rail-summary",
+      proof_bridge_ref: "/v1/proof-bridge",
+      activity_summary_ref: "/v1/activity-ledger/summary"
+    },
+    operator_note: "use this ledger to inspect who did what, what was paid, what was delivered, and how funds and consequence moved through the runtime"
+  };
+}
+
+function summarizeActivityLedger(state, options) {
+  const pack = buildActivityLedger(state, options);
+  return {
+    product: "xytara",
+    category: "machine-commerce-activity-ledger-summary",
+    summary_version: "xytara-activity-ledger-summary-v1",
+    activity_count: pack.counts.activity_count,
+    account_scope: pack.account_scope,
+    counts: pack.counts,
+    linked_surfaces: pack.linked_surfaces
+  };
+}
+
+module.exports = {
+  buildActivityLedger,
+  summarizeActivityLedger
+};

package/lib/adapter_depth_contract.js

@@ -0,0 +1,156 @@
+"use strict";
+
+const packageJson = require("../package.json");
+const { catalog } = require("../fixtures/catalog");
+const { loadExecutionTargetRegistry } = require("./external_execution_runtime");
+
+function normalizeString(value, fallback = "") {
+  const raw = typeof value === "string" ? value.trim() : "";
+  return raw || fallback;
+}
+
+function listAdapterTasks() {
+  return (Array.isArray(catalog.tasks) ? catalog.tasks : [])
+    .filter((task) => normalizeString(task && task.public_category) === "adapter")
+    .map((task) => ({
+      task_ref: task.public_task_ref,
+      internal_task_ref: task.task_ref,
+      public_title: task.public_title,
+      execution_mode: task.execution_mode,
+      latency_class: task.latency_class
+    }));
+}
+
+function listTargetsForTask(taskRef) {
+  const normalizedTaskRef = normalizeString(taskRef);
+  return loadExecutionTargetRegistry().filter((target) => {
+    if (!target || target.enabled === false) return false;
+    if (normalizeString(target.task_ref) === normalizedTaskRef) return true;
+    if (normalizedTaskRef === "adapter.mcp.invoke") {
+      return Boolean(normalizeString(target.tool_name) || normalizeString(target.integration_id));
+    }
+    return false;
+  });
+}
+
+function summarizeTarget(target) {
+  const provider = normalizeString(target && target.provider, "external_execution");
+  const toolName = normalizeString(target && target.tool_name);
+  return {
+    target_id: target.target_id,
+    provider,
+    task_ref: target.task_ref || null,
+    tool_name: toolName || null,
+    integration_id: target.integration_id || null,
+    enabled: target.enabled !== false,
+    timeout_ms: target.timeout_ms,
+    endpoint_configured: Boolean(normalizeString(target.endpoint_url)),
+    auth_configured: Boolean(normalizeString(target.auth_token)),
+    operational_coverage: {
+      execute_endpoint: Boolean(normalizeString(target.endpoint_url)),
+      bearer_auth: Boolean(normalizeString(target.auth_token)),
+      bounded_timeout: Number(target.timeout_ms || 0) >= 500,
+      proof_fact_compatible: provider === "xytara_mcp_executor" || toolName === "summarize" || toolName === "zones.lookup",
+      deterministic_retry_surface: true,
+      tool_level_binding: Boolean(toolName),
+      operator_health_surface: provider === "xytara_mcp_executor" ? "/health" : null,
+      operator_tool_catalog_surface: provider === "xytara_mcp_executor" ? "/tools" : null
+    }
+  };
+}
+
+function summarizeAdapterTaskDepth(task) {
+  const targets = listTargetsForTask(task.task_ref).map(summarizeTarget);
+  const enabledTargets = targets.filter((target) => target.enabled);
+  const toolNames = Array.from(new Set(enabledTargets.map((target) => target.tool_name).filter(Boolean))).sort();
+  const allTargetsCovered = enabledTargets.length > 0 && enabledTargets.every((target) =>
+    target.operational_coverage.execute_endpoint
+    && target.operational_coverage.bounded_timeout
+    && target.operational_coverage.proof_fact_compatible
+  );
+  const depthState = enabledTargets.length >= 2 && allTargetsCovered
+    ? "provider_live_path_deepened"
+    : enabledTargets.length > 0
+      ? "initial_provider_live_path"
+      : "provider_wiring_required";
+
+  return {
+    ...task,
+    provider_depth_state: depthState,
+    provider_live: enabledTargets.length > 0,
+    configured_target_count: targets.length,
+    enabled_target_count: enabledTargets.length,
+    configured_tool_count: toolNames.length,
+    configured_tools: toolNames,
+    execution_targets: targets,
+    operator_claim_boundary: enabledTargets.length > 0
+      ? "claim_only_the_listed_task_and_tool_bindings_as_provider_live"
+      : "do_not_claim_provider_live_until_execution_targets_are_configured"
+  };
+}
+
+function buildAdapterDepthPack() {
+  const adapterTasks = listAdapterTasks().map(summarizeAdapterTaskDepth);
+  const providerLiveTasks = adapterTasks.filter((task) => task.provider_live);
+  const deepenedTasks = adapterTasks.filter((task) => task.provider_depth_state === "provider_live_path_deepened");
+  const configuredTargets = loadExecutionTargetRegistry().filter((target) => target && target.enabled !== false);
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "machine-commerce-adapter-depth-pack",
+    pack_version: "xytara-adapter-depth-pack-v1",
+    adapter_depth_state: deepenedTasks.length > 0
+      ? "provider_live_path_deepened"
+      : providerLiveTasks.length > 0
+        ? "initial_provider_live_path"
+        : "provider_wiring_required",
+    counts: {
+      adapter_task_count: adapterTasks.length,
+      provider_live_task_count: providerLiveTasks.length,
+      deepened_provider_live_task_count: deepenedTasks.length,
+      configured_execution_target_count: configuredTargets.length,
+      configured_provider_count: new Set(configuredTargets.map((target) => normalizeString(target.provider))).size,
+      configured_tool_count: new Set(configuredTargets.map((target) => normalizeString(target.tool_name)).filter(Boolean)).size
+    },
+    adapter_tasks: adapterTasks,
+    production_depth_requirements: [
+      "at_least_one_enabled_execution_target_for_provider_backed_task",
+      "tool_or_integration_level_binding_for_claimed_provider_lane",
+      "bounded_timeout_and_retry_observability",
+      "proof_fact_compatible_result_shape",
+      "operator_health_or_catalog_surface_for_target_service"
+    ],
+    public_claim_boundary: {
+      live_provider_claim_allowed: providerLiveTasks.length > 0,
+      deep_provider_claim_allowed: deepenedTasks.length > 0,
+      live_task_refs: providerLiveTasks.map((task) => task.task_ref),
+      deepened_task_refs: deepenedTasks.map((task) => task.task_ref),
+      rule: "only_claim_provider_depth_for_task_refs_and_tool_bindings_listed_in_this_pack"
+    },
+    linked_surfaces: {
+      execution_truth_ref: "/v1/capability-registry/execution-truth",
+      adapter_depth_summary_ref: "/v1/adapter-depth/summary",
+      integrations_ref: "/v1/integrations",
+      runtime_bridge_ref: "/v1/runtime-bridge/dispatches"
+    }
+  };
+}
+
+function summarizeAdapterDepthPack() {
+  const pack = buildAdapterDepthPack();
+  return {
+    ok: true,
+    product: pack.product,
+    category: "machine-commerce-adapter-depth-summary",
+    summary_version: "xytara-adapter-depth-summary-v1",
+    adapter_depth_state: pack.adapter_depth_state,
+    counts: pack.counts,
+    public_claim_boundary: pack.public_claim_boundary,
+    linked_surfaces: pack.linked_surfaces
+  };
+}
+
+module.exports = {
+  buildAdapterDepthPack,
+  summarizeAdapterDepthPack
+};

package/lib/bolt_lane_contract.js

@@ -0,0 +1,55 @@
+"use strict";
+
+function buildBoltLanePack() {
+  return {
+    product: "xytara",
+    category: "machine-commerce-bolt-lane-pack",
+    pack_version: "xytara-bolt-lane-pack-v1",
+    lane_state: "adapter_front_contract_present",
+    posture: "utxo_native_or_spv_provable_payment_front",
+    settlement_family: "utxo_native_settlement",
+    proof_family: "spv_or_block_header_verifiable_payment_proof",
+    role_in_xytara: "optional_permissionless_payment_and_proof_front",
+    supported_surfaces: {
+      security_ref: "/v1/bolt/security",
+      commands_execute_ref: "/bolt/commands/execute",
+      mcp_invoke_ref: "/bolt/mcp/tools/invoke",
+      payment_protocols_ref: "/v1/payment-protocols",
+      payment_protocol_strategy_ref: "/v1/payment-protocols/strategy",
+      settlement_lane_ref: "/v1/settlement",
+      execution_truth_ref: "/v1/capability-registry/execution-truth"
+    },
+    integration_rules: [
+      "treat BOLT-style or UTXO-SPV payment fronts as adapter lanes into the same execution core",
+      "keep settlement proof and runtime proof composable rather than hardwiring one chain ideology into the package",
+      "bind chain-specific proof verification through explicit adapters or settlement runtimes"
+    ],
+    recommended_uses: [
+      "operators who want stronger peer-to-peer payment properties",
+      "architectures that value block-header or SPV-verifiable settlement proof",
+      "ecosystems that prefer native UTXO payment models"
+    ],
+    non_claims: [
+      "not claimed as a first-party launch-default lane",
+      "not claimed as fully bound unless operator-configured against a real runtime"
+    ]
+  };
+}
+
+function summarizeBoltLanePack() {
+  const pack = buildBoltLanePack();
+  return {
+    product: pack.product,
+    category: pack.category,
+    summary_version: "xytara-bolt-lane-pack-summary-v1",
+    lane_state: pack.lane_state,
+    posture: pack.posture,
+    supported_surface_count: Object.keys(pack.supported_surfaces).length,
+    linked_surfaces: pack.supported_surfaces
+  };
+}
+
+module.exports = {
+  buildBoltLanePack,
+  summarizeBoltLanePack
+};