xytara 3.1.0 → 3.1.2

package/lib/adapter_certification_contract.js

@@ -1,130 +1,130 @@
-"use strict";
-
-const packageJson = require("../package.json");
-
-function buildAdapterCertificationContractPack() {
-  return {
-    ok: true,
-    product: packageJson.name,
-    category: "naxytra-adapter-certification-contract",
-    pack_version: "naxytra-adapter-certification-contract-v1",
-    doctrine: "xytara_certifies_adapters_by_front_specific_normalized_contracts_without_leaking_vendor_truth_into_core_logic",
-    model_state: "core_now",
-    core_claim: "adapter certification is the machine-readable gate for manifest, capability, health, idempotency, failure, proof, and front-specific compatibility claims",
-    certification_states: [
-      { state: "pass", description: "the adapter satisfies the declared front contract without material constraints" },
-      { state: "pass_with_constraints", description: "the adapter is usable but only within declared constraints" },
-      { state: "needs_retest", description: "the adapter needs a fresh run against updated vectors or interface versions" },
-      { state: "blocked", description: "the adapter cannot be certified until a required dependency or vector exists" },
-      { state: "fail", description: "the adapter does not satisfy the declared front contract" }
-    ],
-    certification_fronts: [
-      {
-        front_id: "protocol_front",
-        required_tests: ["protocol negotiation", "surface discovery", "normalized request translation"],
-        required_evidence: ["manifest", "protocol compatibility result", "failure mapping result"],
-        claim_boundary: "only_claim_listed_protocol_front_compatibility"
-      },
-      {
-        front_id: "execution_front",
-        required_tests: ["task dispatch", "idempotency", "execution result normalization"],
-        required_evidence: ["manifest", "task vector results", "proof-compatible output facts"],
-        claim_boundary: "only_claim_listed_execution_front_compatibility"
-      },
-      {
-        front_id: "payment_front",
-        required_tests: ["quote to pay compatibility", "payment admission", "reversal or refund posture"],
-        required_evidence: ["payment state result", "receipt compatibility result", "failure mapping result"],
-        claim_boundary: "only_claim_listed_payment_front_compatibility"
-      },
-      {
-        front_id: "settlement_front",
-        required_tests: ["settlement target translation", "finality reference capture", "batch or direct settlement posture"],
-        required_evidence: ["settlement reference", "finality state", "reconciliation evidence"],
-        claim_boundary: "only_claim_listed_settlement_front_compatibility"
-      },
-      {
-        front_id: "identity_trust_front",
-        required_tests: ["identity schema compatibility", "registry linkage", "attestation or trust-state roundtrip"],
-        required_evidence: ["identity record", "registry proof", "trust-state result"],
-        claim_boundary: "only_claim_listed_identity_trust_front_compatibility"
-      },
-      {
-        front_id: "proof_front",
-        required_tests: ["receipt compatibility", "proof import or export compatibility", "verification hook compatibility"],
-        required_evidence: ["proof contract result", "receipt result", "verification evidence"],
-        claim_boundary: "only_claim_listed_proof_front_compatibility"
-      },
-      {
-        front_id: "treasury_front",
-        required_tests: ["destination routing", "balance model compatibility", "payout landing compatibility"],
-        required_evidence: ["treasury route result", "account abstraction result", "operator review note"],
-        claim_boundary: "only_claim_listed_treasury_front_compatibility"
-      },
-      {
-        front_id: "operator_front",
-        required_tests: ["review surface visibility", "promotion posture", "reporting export compatibility"],
-        required_evidence: ["review summary", "promotion readiness result", "operator export"],
-        claim_boundary: "only_claim_listed_operator_front_compatibility"
-      }
-    ],
-    harness_requirements: {
-      test_categories: [
-        "manifest_validity",
-        "interface_conformance",
-        "capability_declaration",
-        "health_reporting",
-        "failure_mapping",
-        "idempotency_behavior",
-        "proof_compatibility",
-        "front_specific_lifecycle_compatibility"
-      ],
-      required_result_fields: [
-        "certification_state",
-        "interface_version",
-        "tested_fronts",
-        "tested_capabilities",
-        "failed_cases",
-        "warnings",
-        "evidence_refs"
-      ]
-    },
-    linked_surfaces: {
-      integrations_summary_ref: "/v1/integrations/summary",
-      promotion_readiness_ref: "/v1/integrations/promotion-readiness",
-      promotion_actions_ref: "/v1/integrations/promotion-actions",
-      submission_bundle_review_ref: "/v1/integrations/review/submission-bundle",
-      submission_bundle_set_review_ref: "/v1/integrations/review/submission-bundle-set",
-      registry_snapshot_review_ref: "/v1/integrations/review/registry-snapshot"
-    },
-    claim_boundary: "claim_adapter_certification_as_front_specific_compatibility_and_review_gate_without_claiming_vendor_default_or_runtime_truth"
-  };
-}
-
-function summarizeAdapterCertificationContractPack() {
-  const pack = buildAdapterCertificationContractPack();
-  return {
-    ok: true,
-    product: pack.product,
-    category: pack.category,
-    summary_version: "naxytra-adapter-certification-contract-summary-v1",
-    pack_version: pack.pack_version,
-    model_state: pack.model_state,
-    certification_state_count: pack.certification_states.length,
-    certification_front_count: pack.certification_fronts.length,
-    required_test_category_count: pack.harness_requirements.test_categories.length,
-    linked_surfaces: pack.linked_surfaces
-  };
-}
-
-function getAdapterCertificationFrontDetail(frontId) {
-  const normalized = String(frontId || "").trim().toLowerCase();
-  return (buildAdapterCertificationContractPack().certification_fronts || []).find((entry) => entry.front_id === normalized) || null;
-}
-
-module.exports = {
-  buildAdapterCertificationContractPack,
-  summarizeAdapterCertificationContractPack,
-  getAdapterCertificationFrontDetail
-};
-
+"use strict";
+
+const packageJson = require("../package.json");
+
+function buildAdapterCertificationContractPack() {
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "naxytra-adapter-certification-contract",
+    pack_version: "naxytra-adapter-certification-contract-v1",
+    doctrine: "xytara_certifies_adapters_by_front_specific_normalized_contracts_without_leaking_vendor_truth_into_core_logic",
+    model_state: "core_now",
+    core_claim: "adapter certification is the machine-readable gate for manifest, capability, health, idempotency, failure, proof, and front-specific compatibility claims",
+    certification_states: [
+      { state: "pass", description: "the adapter satisfies the declared front contract without material constraints" },
+      { state: "pass_with_constraints", description: "the adapter is usable but only within declared constraints" },
+      { state: "needs_retest", description: "the adapter needs a fresh run against updated vectors or interface versions" },
+      { state: "blocked", description: "the adapter cannot be certified until a required dependency or vector exists" },
+      { state: "fail", description: "the adapter does not satisfy the declared front contract" }
+    ],
+    certification_fronts: [
+      {
+        front_id: "protocol_front",
+        required_tests: ["protocol negotiation", "surface discovery", "normalized request translation"],
+        required_evidence: ["manifest", "protocol compatibility result", "failure mapping result"],
+        claim_boundary: "only_claim_listed_protocol_front_compatibility"
+      },
+      {
+        front_id: "execution_front",
+        required_tests: ["task dispatch", "idempotency", "execution result normalization"],
+        required_evidence: ["manifest", "task vector results", "proof-compatible output facts"],
+        claim_boundary: "only_claim_listed_execution_front_compatibility"
+      },
+      {
+        front_id: "payment_front",
+        required_tests: ["quote to pay compatibility", "payment admission", "reversal or refund posture"],
+        required_evidence: ["payment state result", "receipt compatibility result", "failure mapping result"],
+        claim_boundary: "only_claim_listed_payment_front_compatibility"
+      },
+      {
+        front_id: "settlement_front",
+        required_tests: ["settlement target translation", "finality reference capture", "batch or direct settlement posture"],
+        required_evidence: ["settlement reference", "finality state", "reconciliation evidence"],
+        claim_boundary: "only_claim_listed_settlement_front_compatibility"
+      },
+      {
+        front_id: "identity_trust_front",
+        required_tests: ["identity schema compatibility", "registry linkage", "attestation or trust-state roundtrip"],
+        required_evidence: ["identity record", "registry proof", "trust-state result"],
+        claim_boundary: "only_claim_listed_identity_trust_front_compatibility"
+      },
+      {
+        front_id: "proof_front",
+        required_tests: ["receipt compatibility", "proof import or export compatibility", "verification hook compatibility"],
+        required_evidence: ["proof contract result", "receipt result", "verification evidence"],
+        claim_boundary: "only_claim_listed_proof_front_compatibility"
+      },
+      {
+        front_id: "treasury_front",
+        required_tests: ["destination routing", "balance model compatibility", "payout landing compatibility"],
+        required_evidence: ["treasury route result", "account abstraction result", "operator review note"],
+        claim_boundary: "only_claim_listed_treasury_front_compatibility"
+      },
+      {
+        front_id: "operator_front",
+        required_tests: ["review surface visibility", "promotion posture", "reporting export compatibility"],
+        required_evidence: ["review summary", "promotion readiness result", "operator export"],
+        claim_boundary: "only_claim_listed_operator_front_compatibility"
+      }
+    ],
+    harness_requirements: {
+      test_categories: [
+        "manifest_validity",
+        "interface_conformance",
+        "capability_declaration",
+        "health_reporting",
+        "failure_mapping",
+        "idempotency_behavior",
+        "proof_compatibility",
+        "front_specific_lifecycle_compatibility"
+      ],
+      required_result_fields: [
+        "certification_state",
+        "interface_version",
+        "tested_fronts",
+        "tested_capabilities",
+        "failed_cases",
+        "warnings",
+        "evidence_refs"
+      ]
+    },
+    linked_surfaces: {
+      integrations_summary_ref: "/v1/integrations/summary",
+      promotion_readiness_ref: "/v1/integrations/promotion-readiness",
+      promotion_actions_ref: "/v1/integrations/promotion-actions",
+      submission_bundle_review_ref: "/v1/integrations/review/submission-bundle",
+      submission_bundle_set_review_ref: "/v1/integrations/review/submission-bundle-set",
+      registry_snapshot_review_ref: "/v1/integrations/review/registry-snapshot"
+    },
+    claim_boundary: "claim_adapter_certification_as_front_specific_compatibility_and_review_gate_without_claiming_vendor_default_or_runtime_truth"
+  };
+}
+
+function summarizeAdapterCertificationContractPack() {
+  const pack = buildAdapterCertificationContractPack();
+  return {
+    ok: true,
+    product: pack.product,
+    category: pack.category,
+    summary_version: "naxytra-adapter-certification-contract-summary-v1",
+    pack_version: pack.pack_version,
+    model_state: pack.model_state,
+    certification_state_count: pack.certification_states.length,
+    certification_front_count: pack.certification_fronts.length,
+    required_test_category_count: pack.harness_requirements.test_categories.length,
+    linked_surfaces: pack.linked_surfaces
+  };
+}
+
+function getAdapterCertificationFrontDetail(frontId) {
+  const normalized = String(frontId || "").trim().toLowerCase();
+  return (buildAdapterCertificationContractPack().certification_fronts || []).find((entry) => entry.front_id === normalized) || null;
+}
+
+module.exports = {
+  buildAdapterCertificationContractPack,
+  summarizeAdapterCertificationContractPack,
+  getAdapterCertificationFrontDetail
+};
+

package/lib/adapter_depth_contract.js

@@ -1,156 +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" || normalizedTaskRef.startsWith("adapter.mcp.")) {
-      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
-};
+"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" || normalizedTaskRef.startsWith("adapter.mcp.")) {
+      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
+};