@truedat/dd 8.12.5 → 8.12.7

package/src/components/LineageGraph.js

@@ -1,14 +1,11 @@
-/* eslint-disable fp/no-let, fp/no-mutation -- Geometry packing and route planning use bounded local mutation. */
-
 import _ from "lodash/fp";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import PropTypes from "prop-types";
 import { connect } from "react-redux";
 import { FormattedMessage, useIntl } from "react-intl";
-import { Graph } from "@truedat/core/components";
+import Graph from "@truedat/core/components/Graph";
 import LineageGroupNode from "@truedat/core/components/graph/LineageGroupNode";
 import { EdgeHoverContext } from "@truedat/core/components/graph/ColoredEdge";
-import lineageNodeIcon from "@truedat/core/components/graph/lineageNodeIcon";
 import { cancelPoll } from "../routines";
 import { layoutVisibleLineageGraph } from "../utils/lineageLayout";
 import {
@@ -17,3812 +14,109 @@ import {
   focusLineageFromSeeds,
   projectLineageNodeIds,
 } from "../utils/lineageGraphIndex";
+import {
+  normalizeId,
+  LINEAGE_FIT_VIEW_PADDING,
+  LINEAGE_MIN_ZOOM,
+  LINEAGE_MAX_ZOOM,
+  LINEAGE_WHEEL_ZOOM_SENSITIVITY,
+  LINEAGE_DEFAULT_EXPANSION_DEPTH,
+  LINEAGE_UNKNOWN_SYSTEM_TYPE_LABEL,
+  LINEAGE_UNKNOWN_SYSTEM_TYPE_COLOR,
+  hasPositionedLineageLayout,
+  nodeId,
+  positionedDuplicateNodeIds,
+  nodeAliasValues,
+  nodeAliasMap,
+  resolveNodeId,
+  hasResolvedLineageEndpoints,
+  lineageNodeContentWidth,
+  lineageNode,
+  lineageTopologyNodes,
+  preparePositionedLineageHierarchy,
+  uniqueNodes,
+  normalizedExpansionDepth,
+  lineageMaximumExpansionDepth,
+  lineageCollapsedGroupIdsForDepth,
+  expandLineageDescendantsUntilOversized,
+  lineageDefaultCollapsedGroupIds,
+  lineageShouldLoadExpanded,
+  lineageOversizedGroupIds,
+  collapseLineageNodes,
+  aggregateCollapsedEdges,
+  routeOpenGroupEdgesToSingleVisibleChild,
+  mergeRenderedNode,
+  lineagePositionedLayoutNodes,
+  applyFieldHandlesToEdges,
+  redesignedLineageEdges,
+  planLineageEdgeRoutes,
+  focusLineageNodes,
+  focusLineageEdges,
+  focusedLineageGraphForNodeSet,
+  lineageNodeMatchesToolbarFilters,
+  selectedNodeFromGraphNode,
+  lineageToolbarSearchResults,
+  lineageAncestorNodeIds,
+  lineageEdgeContext,
+  lineageEdge,
+  pathNodeCandidates,
+  spreadLegacyFieldIndexes,
+  legacyPathEdges,
+} from "../utils/lineageGraph";
 import LineageResourceNode from "./LineageResourceNode";
 import LineageGraphToolbar, { visibleLegendKeys } from "./LineageGraphToolbar";
 
-const normalizeId = (value) =>
-  value === undefined || value === null ? "" : `${value}`;
+export {
+  DEFAULT_DEPTH,
+  hasPositionedLineageLayout,
+  isRestrictiveLineageEdge,
+  normalizeLineageEntityType,
+  lineageCatalogState,
+  lineageSystemTypeLabel,
+  lineageSystemTypeClassName,
+  lineageSystemTypeColor,
+  lineageSystemType,
+  lineageNodeContentWidth,
+  redesignedLineageNodeHeight,
+  lineageTopologyNodes,
+  preparePositionedLineageHierarchy,
+  lineageMaximumExpansionDepth,
+  lineageCollapsedGroupIdsForDepth,
+  expandLineageDescendants,
+  LINEAGE_OVERSIZED_CHILD_LIMIT,
+  lineageDirectChildCounts,
+  expandLineageDescendantsUntilOversized,
+  lineageDefaultCollapsedGroupIds,
+  LINEAGE_DEFAULT_EXPAND_MAX_GROUPS,
+  LINEAGE_DEFAULT_EXPAND_MAX_LEAF_NODES,
+  lineageShouldLoadExpanded,
+  lineageOversizedGroupIds,
+  collapseLineageNodes,
+  aggregateCollapsedEdges,
+  routeOpenGroupEdgesToSingleVisibleChild,
+  lineagePositionedLayoutNodes,
+  applyFieldHandlesToEdges,
+  bundleLineageEdges,
+  redesignedLineageEdges,
+  planLineageEdgeRoutes,
+  focusedLineageGraph,
+  focusLineageNodes,
+  focusLineageEdges,
+  focusedLineageGraphForNodeSet,
+  lineageNodeMatchesToolbarFilters,
+  selectedNodeFromGraphNode,
+  lineageToolbarSearchResults,
+  lineageEdge,
+  spreadLegacyFieldIndexes,
+  legacyPathEdge,
+  legacyPathEdges,
+} from "../utils/lineageGraph";
 
-const NODE_FIELD_LIMIT = 5;
-const NODE_FIELD_LIMIT_REDESIGNED = 6;
-const NODE_FIELD_EXPANDED_LIMIT_REDESIGNED = 10;
-const NODE_WIDTH = 240;
-const NODE_WIDTH_REDESIGNED = 288;
-const LINEAGE_NODE_WIDTH_MIN = 240;
-const LINEAGE_NODE_WIDTH_MAX = 360;
-const LINEAGE_NODE_WIDTH_PADDING = 88;
-const LINEAGE_TEXT_WIDTH_FACTOR = 6.5;
-const NODE_BASE_HEIGHT = 68;
-const NODE_BASE_HEIGHT_REDESIGNED = 42;
-const NODE_CONTEXT_HEIGHT = 30;
-const NODE_FIELD_HEIGHT = 24;
-const NODE_FIELD_HEIGHT_REDESIGNED = 36;
-const NODE_MORE_HEIGHT = 18;
-const NODE_MORE_HEIGHT_REDESIGNED = 32;
-const LINEAGE_COMPACT_MIN_WIDTH = 200;
-const LINEAGE_COMPACT_MIN_HEIGHT = 34;
-const LINEAGE_EDGE_COLOR = "var(--td-graph-edge-stroke, #7b8798)";
-const LINEAGE_EDGE_COLOR_BY_TYPE = {
-  impact: "#2563eb",
-  lineage: "#ed5c17",
-};
-const lineageEdgeColor = (graphType) =>
-  LINEAGE_EDGE_COLOR_BY_TYPE[graphType] || LINEAGE_EDGE_COLOR;
-const LINEAGE_FIT_VIEW_PADDING = 0.32;
-const LINEAGE_MIN_ZOOM = 0.05;
-const LINEAGE_MAX_ZOOM = 1.25;
-const LINEAGE_WHEEL_ZOOM_SENSITIVITY = 0.0015;
-const LINEAGE_SEARCH_RESULT_LIMIT = 50;
-const LINEAGE_DEFAULT_EXPANSION_DEPTH = 4;
-export const DEFAULT_DEPTH = LINEAGE_DEFAULT_EXPANSION_DEPTH;
-const LINEAGE_UNKNOWN_SYSTEM_TYPE_LABEL = "Without System Group";
-const LINEAGE_UNKNOWN_SYSTEM_TYPE_COLOR = {
-  accent: "#334155",
-  accentStrong: "#1f2937",
-  accentSoft: "rgba(51, 65, 85, 0.16)",
-  border: "#64748b",
-  bg: "rgba(241, 245, 249, 0.78)",
-  text: "#1f2937",
-  shadow: "rgba(15, 23, 42, 0.18)",
-};
-const LINEAGE_SYSTEM_TYPE_PALETTE = [
-  ["#1f6feb", "#1d4ed8", "#16263a", "rgba(31, 111, 235, 0.14)"],
-  ["#168657", "#15803d", "#bbf7d0", "rgba(22, 134, 87, 0.14)"],
-  ["#b45309", "#9a3412", "#fed7aa", "rgba(180, 83, 9, 0.14)"],
-  ["#6d5bd0", "#5b46be", "#ddd6fe", "rgba(109, 91, 208, 0.14)"],
-  ["#0f8f8c", "#0f766e", "#99f6e4", "rgba(15, 143, 140, 0.14)"],
-  ["#be123c", "#9f1239", "#fecdd3", "rgba(190, 18, 60, 0.14)"],
-  ["#7c3aed", "#6d28d9", "#ddd6fe", "rgba(124, 58, 237, 0.14)"],
-  ["#0369a1", "#075985", "#bae6fd", "rgba(3, 105, 161, 0.14)"],
-  ["#047857", "#065f46", "#a7f3d0", "rgba(4, 120, 87, 0.14)"],
-  ["#c2410c", "#9a3412", "#fed7aa", "rgba(194, 65, 12, 0.14)"],
-  ["#4f46e5", "#4338ca", "#c7d2fe", "rgba(79, 70, 229, 0.14)"],
-  ["#0e7490", "#155e75", "#a5f3fc", "rgba(14, 116, 144, 0.14)"],
-];
-const LINEAGE_COLUMN_HEADER_HEIGHT = 42;
-const POSITIONED_GROUP_PADDING_X = 16;
-const POSITIONED_GROUP_PADDING_BOTTOM = 12;
-const POSITIONED_GROUP_LABEL_GUTTER = 58;
-const POSITIONED_SIBLING_GAP = 14;
-const POSITIONED_LEAF_SIBLING_GAP = 6;
-const POSITIONED_BRANCH_SIBLING_GAP = 40;
-const LINEAGE_GROUP_Z_INDEX = 10;
-const LINEAGE_EDGE_Z_INDEX = 100;
-const LINEAGE_RESOURCE_Z_INDEX = 200;
-const LINEAGE_DIRECT_NODE_Z_INDEX = 250;
-const LINEAGE_SELECTED_NODE_Z_INDEX = 300;
-const LINEAGE_FOCUSED_EDGE_Z_INDEX = 350;
-const LINEAGE_ROUTE_CLEARANCE = 24;
-const LINEAGE_ROUTE_OBSTACLE_PADDING = 10;
-const LINEAGE_ROUTE_LANE_GAP = 8;
-const LINEAGE_ROUTE_MAX_LANE_ATTEMPTS = 12;
-const COLLAPSED_GROUP_WIDTH = 240;
-const COLLAPSED_GROUP_HEIGHT = 82;
-const PATH_NUMBER_PATTERN = /-?\d+(?:\.\d+)?/g;
-const PATH_SEGMENT_PATTERN = /[Mm][^Mm]*/g;
-const ROOT_GROUP_ID = "@@ROOT";
 const LINEAGE_NODE_TYPES = {
   lineageGroup: LineageGroupNode,
   lineageResource: LineageResourceNode,
 };
 
-const toNumber = (value) => {
-  const number = Number(value);
-
-  return Number.isFinite(number) ? number : undefined;
-};
-
-const hasNodeGeometry = (node = {}) =>
-  [node.x, node.y, node.w, node.h].every(
-    (value) => toNumber(value) !== undefined,
-  );
-
-const nodeGeometry = (node = {}) => ({
-  x: toNumber(node.x) || 0,
-  y: toNumber(node.y) || 0,
-  w: toNumber(node.w) || NODE_WIDTH,
-  h: toNumber(node.h) || NODE_BASE_HEIGHT,
-});
-
-const absoluteGeometry = ({ x, y, w, h }) => ({
-  x,
-  y,
-  w,
-  h,
-});
-
-const containsGeometry = (parent, child) => {
-  const parentGeometry = nodeGeometry(parent);
-  const childGeometry = nodeGeometry(child);
-
-  return (
-    childGeometry.x >= parentGeometry.x &&
-    childGeometry.y >= parentGeometry.y &&
-    childGeometry.x + childGeometry.w <= parentGeometry.x + parentGeometry.w &&
-    childGeometry.y + childGeometry.h <= parentGeometry.y + parentGeometry.h
-  );
-};
-
-const geometryArea = (node) => {
-  const { w, h } = nodeGeometry(node);
-
-  return w * h;
-};
-
-const nodeDepth = (node = {}) =>
-  toNumber(node.z) || toNumber(node.data?.z) || 0;
-
-const canBePositionedParent = (group, node) =>
-  group?.id !== node?.id &&
-  hasNodeGeometry(group) &&
-  (node.z === undefined || nodeDepth(group) < nodeDepth(node));
-
-const anchoredParentGeometry = (parent, child) => {
-  const parentGeometry = nodeGeometry(parent);
-  const childGeometry = nodeGeometry(child);
-
-  return (
-    childGeometry.x >= parentGeometry.x &&
-    childGeometry.y >= parentGeometry.y &&
-    childGeometry.x <= parentGeometry.x + parentGeometry.w &&
-    childGeometry.y <= parentGeometry.y + parentGeometry.h &&
-    geometryArea(parent) > geometryArea(child)
-  );
-};
-
-const positionedParentSort = (groupA, groupB) => {
-  const zDiff = nodeDepth(groupB) - nodeDepth(groupA);
-
-  if (zDiff !== 0) return zDiff;
-
-  return geometryArea(groupA) - geometryArea(groupB);
-};
-
-const parentGroupFor = (groups = [], node) =>
-  groups.reduce((parent, group) => {
-    if (
-      !canBePositionedParent(group, node) ||
-      !(containsGeometry(group, node) || anchoredParentGeometry(group, node))
-    ) {
-      return parent;
-    }
-
-    return !parent || positionedParentSort(group, parent) < 0 ? group : parent;
-  }, undefined);
-
-export const hasPositionedLineageLayout = (groups = [], resources = []) => {
-  const nodes = [...groups, ...resources];
-
-  if (_.isEmpty(nodes)) return false;
-  return nodes.some(hasNodeGeometry);
-};
-
-const nodeId = ({ id, external_id, name }) =>
-  normalizeId(external_id || id || name);
-
-const positionedNodeInstanceKey = (node = {}) => {
-  const { x, y, w, h } = nodeGeometry(node);
-
-  return [x, y, w, h, nodeDepth(node)].join(":");
-};
-
-const positionedDuplicateNodeIds = (groups = [], resources = []) => {
-  const counts = [...groups, ...resources].reduce((nodeCounts, node) => {
-    if (!hasNodeGeometry(node)) return nodeCounts;
-
-    const id = nodeId(node);
-
-    if (!id) return nodeCounts;
-
-    nodeCounts.set(id, (nodeCounts.get(id) || 0) + 1);
-
-    return nodeCounts;
-  }, new Map());
-
-  return new Set(
-    Array.from(counts.entries())
-      .filter(([, count]) => count > 1)
-      .map(([id]) => id),
-  );
-};
-
-const positionedNodeInstanceId = (node, duplicateNodeIds = new Set()) => {
-  const id = nodeId(node);
-
-  return duplicateNodeIds.has(id)
-    ? `${id}@@${positionedNodeInstanceKey(node)}`
-    : id;
-};
-
-const centeredGeometry = ({ x, y, w, h }, width, height) => ({
-  x: x + (w - width) / 2,
-  y: y + (h - height) / 2,
-  w: width,
-  h: height,
-});
-
-const resourceRenderedGeometry = (node) => {
-  const geometry = nodeGeometry(node);
-  const width = Math.max(geometry.w, LINEAGE_COMPACT_MIN_WIDTH);
-  const height = Math.max(geometry.h, LINEAGE_COMPACT_MIN_HEIGHT);
-
-  return centeredGeometry(geometry, width, height);
-};
-
-const geometriesOverlap = (geometryA, geometryB, gap = 0) =>
-  geometryA.x < geometryB.x + geometryB.w + gap &&
-  geometryA.x + geometryA.w + gap > geometryB.x &&
-  geometryA.y < geometryB.y + geometryB.h + gap &&
-  geometryA.y + geometryA.h + gap > geometryB.y;
-
-const sortGeometriesByPosition = (nodeA, nodeB) => {
-  const yDiff = nodeA.geometry.y - nodeB.geometry.y;
-
-  return yDiff || nodeA.geometry.x - nodeB.geometry.x;
-};
-
-const packSiblingGeometries = (
-  childIds = [],
-  geometryById,
-  shiftGeometryTree,
-  gap = POSITIONED_SIBLING_GAP,
-) => {
-  const placedGeometries = [];
-  const siblings = childIds
-    .map((id) => ({
-      id,
-      geometry: geometryById.get(id),
-    }))
-    .filter(({ geometry }) => geometry)
-    .sort(sortGeometriesByPosition);
-
-  siblings.forEach(({ id, geometry }) => {
-    let nextY = geometry.y;
-    let nextGeometry = geometry;
-    let shifted = false;
-
-    do {
-      shifted = false;
-
-      placedGeometries.forEach((placedGeometry) => {
-        if (!geometriesOverlap(nextGeometry, placedGeometry, gap)) return;
-
-        nextY = Math.max(nextY, placedGeometry.y + placedGeometry.h + gap);
-        nextGeometry = { ...geometry, y: nextY };
-        shifted = true;
-      });
-    } while (shifted);
-
-    if (nextY !== geometry.y) {
-      shiftGeometryTree(id, 0, nextY - geometry.y);
-    }
-
-    placedGeometries.push(geometryById.get(id) || nextGeometry);
-  });
-};
-
-const stackSiblingGeometries = (
-  childIds = [],
-  geometryById,
-  shiftGeometryTree,
-  gap = POSITIONED_SIBLING_GAP,
-  preserveOrder = false,
-) => {
-  const siblings = childIds
-    .map((id) => ({
-      id,
-      geometry: geometryById.get(id),
-    }))
-    .filter(({ geometry }) => geometry);
-
-  if (_.isEmpty(siblings)) return;
-
-  if (!preserveOrder) siblings.sort(sortGeometriesByPosition);
-
-  const columnX = Math.min(...siblings.map(({ geometry }) => geometry.x));
-  let nextY = Math.min(...siblings.map(({ geometry }) => geometry.y));
-
-  siblings.forEach(({ id }) => {
-    const geometry = geometryById.get(id);
-
-    if (!geometry) return;
-
-    if (columnX !== geometry.x || nextY !== geometry.y) {
-      shiftGeometryTree(id, columnX - geometry.x, nextY - geometry.y);
-    }
-
-    nextY += geometry.h + gap;
-  });
-};
-
-const rowSiblingGeometries = (
-  childIds = [],
-  geometryById,
-  shiftGeometryTree,
-  preserveOrder = false,
-) => {
-  const siblings = childIds
-    .map((id) => ({ id, geometry: geometryById.get(id) }))
-    .filter(({ geometry }) => geometry);
-
-  if (_.isEmpty(siblings)) return;
-
-  if (!preserveOrder) siblings.sort(sortGeometriesByPosition);
-
-  let nextX = Math.min(...siblings.map(({ geometry }) => geometry.x));
-  const rowY = Math.min(...siblings.map(({ geometry }) => geometry.y));
-
-  siblings.forEach(({ id }) => {
-    const geometry = geometryById.get(id);
-
-    if (!geometry) return;
-
-    if (nextX !== geometry.x || rowY !== geometry.y) {
-      shiftGeometryTree(id, nextX - geometry.x, rowY - geometry.y);
-    }
-
-    nextX += geometry.w + POSITIONED_BRANCH_SIBLING_GAP;
-  });
-};
-
-const shouldRowSiblingGroups = (childNodes = []) =>
-  childNodes.length > 1 &&
-  childNodes.every((childNode) => childNode?.type === "lineageGroup");
-
-const shouldCompactVisibleGroupChildren = (node, childNodes = []) =>
-  node.type === "lineageGroup" &&
-  node.data?.variant === "absolute" &&
-  (childNodes.some((childNode) => childNode?.data?.collapsed) ||
-    childNodes.every((childNode) => childNode?.type !== "lineageGroup"));
-
-const buildPositionedGeometryMap = (
-  groups = [],
-  resources = [],
-  duplicateNodeIds = positionedDuplicateNodeIds(groups, resources),
-  resourceGeometry = resourceRenderedGeometry,
-  parentByNode,
-) => {
-  const geometryById = new Map();
-  const groupById = new Map();
-  const childrenByGroupId = new Map();
-  const rootResourceIds = [];
-  const rootGroupIds = [];
-
-  groups.forEach((group) => {
-    if (!hasNodeGeometry(group)) return;
-
-    const id = positionedNodeInstanceId(group, duplicateNodeIds);
-
-    groupById.set(id, group);
-    childrenByGroupId.set(id, []);
-  });
-
-  const addChild = (node, childId) => {
-    const parentGroup = parentByNode.get(node);
-
-    if (!parentGroup) return false;
-
-    const parentId = positionedNodeInstanceId(parentGroup, duplicateNodeIds);
-    const children = childrenByGroupId.get(parentId);
-
-    if (children) children.push(childId);
-    return Boolean(children);
-  };
-
-  const shiftGeometryTree = (id, deltaX, deltaY) => {
-    const geometry = geometryById.get(id);
-
-    if (geometry) {
-      geometryById.set(id, {
-        ...geometry,
-        x: geometry.x + deltaX,
-        y: geometry.y + deltaY,
-      });
-    }
-
-    (childrenByGroupId.get(id) || [])
-      .filter((childId) => childId !== id)
-      .forEach((childId) => shiftGeometryTree(childId, deltaX, deltaY));
-  };
-
-  resources.forEach((resource) => {
-    if (!hasNodeGeometry(resource)) return;
-
-    const id = positionedNodeInstanceId(resource, duplicateNodeIds);
-
-    geometryById.set(id, resourceGeometry(resource));
-    if (!addChild(resource, id)) rootResourceIds.push(id);
-  });
-
-  groups.forEach((group) => {
-    const id = positionedNodeInstanceId(group, duplicateNodeIds);
-
-    if (!addChild(group, id)) rootGroupIds.push(id);
-  });
-
-  const groupGeometry = (id) => {
-    if (geometryById.has(id)) return geometryById.get(id);
-
-    const group = groupById.get(id);
-    const rawGeometry = nodeGeometry(group);
-    const childIds = (childrenByGroupId.get(id) || []).filter(
-      (childId) => childId !== id,
-    );
-
-    childIds.forEach((childId) => {
-      if (groupById.has(childId)) groupGeometry(childId);
-    });
-    if (
-      childIds.length > 1 &&
-      childIds.every((childId) => groupById.has(childId))
-    ) {
-      rowSiblingGeometries(childIds, geometryById, shiftGeometryTree);
-    } else {
-      stackSiblingGeometries(childIds, geometryById, shiftGeometryTree);
-    }
-
-    const children = childIds
-      .map((childId) => geometryById.get(childId))
-      .filter(Boolean);
-
-    if (_.isEmpty(children)) {
-      geometryById.set(id, rawGeometry);
-      return rawGeometry;
-    }
-
-    const minX = Math.min(
-      rawGeometry.x,
-      ...children.map((child) => child.x - POSITIONED_GROUP_PADDING_X),
-    );
-    const minY = Math.min(
-      rawGeometry.y,
-      ...children.map((child) => child.y - POSITIONED_GROUP_LABEL_GUTTER),
-    );
-    const maxX = Math.max(
-      ...children.map(
-        (child) => child.x + child.w + POSITIONED_GROUP_PADDING_X,
-      ),
-    );
-    const maxY = Math.max(
-      ...children.map(
-        (child) => child.y + child.h + POSITIONED_GROUP_PADDING_BOTTOM,
-      ),
-    );
-    const effectiveGeometry = {
-      x: minX,
-      y: minY,
-      w: Math.max(COLLAPSED_GROUP_WIDTH, maxX - minX),
-      h: Math.max(COLLAPSED_GROUP_HEIGHT, maxY - minY),
-    };
-
-    geometryById.set(id, effectiveGeometry);
-    return effectiveGeometry;
-  };
-
-  groups.forEach((group) => {
-    groupGeometry(positionedNodeInstanceId(group, duplicateNodeIds));
-  });
-  packSiblingGeometries(
-    [...rootGroupIds, ...rootResourceIds],
-    geometryById,
-    shiftGeometryTree,
-  );
-
-  return geometryById;
-};
-
-const nodeAliasValues = (node = {}) =>
-  [
-    node.external_id,
-    node.id,
-    node.name,
-    node.structure_id,
-    node.data_structure_id,
-  ]
-    .map(normalizeId)
-    .filter((value) => !_.isEmpty(value));
-
-const nodeAliasMap = (nodes = []) =>
-  nodes.reduce((aliases, node) => {
-    const resolvedId = nodeId(node);
-
-    nodeAliasValues(node).forEach((alias) => {
-      if (!aliases.has(alias)) aliases.set(alias, resolvedId);
-    });
-
-    return aliases;
-  }, new Map());
-
-const resolveNodeId = (aliases) => (value) => {
-  const id = normalizeId(value);
-
-  return aliases.get(id) || id;
-};
-
-const endpointId = (value) => {
-  if (value === undefined || value === null) return "";
-  if (typeof value === "object") return nodeId(value);
-
-  return normalizeId(value);
-};
-
-const firstEndpoint = (...values) =>
-  values.find((value) => !_.isEmpty(endpointId(value)));
-
-const lineageEndpoint = (edge = {}, endpoint) => {
-  if (endpoint === "start") {
-    return firstEndpoint(
-      edge.inicio_nodo,
-      edge.inicioNodo,
-      edge.inicio_nodo_id,
-      edge.inicioNodoId,
-      edge.start_node,
-      edge.startNode,
-      edge.start_node_id,
-      edge.startNodeId,
-      edge.source_inicio_nodo,
-      edge.sourceInicioNodo,
-      edge.source_start_node,
-      edge.sourceStartNode,
-      edge.v1,
-      edge.source?.inicio_nodo,
-      edge.source?.inicioNodo,
-      edge.source?.inicio_nodo_id,
-      edge.source?.inicioNodoId,
-      edge.source?.start_node,
-      edge.source?.startNode,
-      edge.source?.start_node_id,
-      edge.source?.startNodeId,
-      edge.source,
-      edge.source_id,
-      edge.sourceId,
-      edge.from,
-    );
-  }
-
-  return firstEndpoint(
-    edge.fin_nodo,
-    edge.finNodo,
-    edge.fin_nodo_id,
-    edge.finNodoId,
-    edge.end_node,
-    edge.endNode,
-    edge.end_node_id,
-    edge.endNodeId,
-    edge.target_fin_nodo,
-    edge.targetFinNodo,
-    edge.target_end_node,
-    edge.targetEndNode,
-    edge.v2,
-    edge.target?.fin_nodo,
-    edge.target?.finNodo,
-    edge.target?.fin_nodo_id,
-    edge.target?.finNodoId,
-    edge.target?.end_node,
-    edge.target?.endNode,
-    edge.target?.end_node_id,
-    edge.target?.endNodeId,
-    edge.target,
-    edge.target_id,
-    edge.targetId,
-    edge.to,
-  );
-};
-
-const resolveLineageEndpoint = (edge, endpoint, resolveId) => {
-  const id = endpointId(lineageEndpoint(edge, endpoint));
-
-  return id ? resolveId(id) : "";
-};
-
-const hasResolvedLineageEndpoints = (edge, resolveId, nodeById) => {
-  const source = resolveLineageEndpoint(edge, "start", resolveId);
-  const target = resolveLineageEndpoint(edge, "end", resolveId);
-
-  return Boolean(
-    source && target && nodeById.has(source) && nodeById.has(target),
-  );
-};
-
-const truthyRelationValue = (value) => {
-  if (value === true) return true;
-  if (typeof value === "number") return value > 0;
-  if (typeof value === "string") {
-    const normalized = value.trim().toLowerCase();
-
-    if (
-      [
-        "false",
-        "0",
-        "no",
-        "non_restrictive",
-        "non-restrictive",
-        "non restrictive",
-        "no restrictiva",
-        "no restrictivo",
-        "unrestricted",
-      ].includes(normalized)
-    ) {
-      return false;
-    }
-
-    return (
-      [
-        "true",
-        "1",
-        "yes",
-        "si",
-        "sí",
-        "restrictive",
-        "restricted",
-        "restrictiva",
-        "restrictivo",
-      ].includes(normalized) || normalized.includes("restrict")
-    );
-  }
-
-  if (value && typeof value === "object") {
-    return [
-      value.restrictive,
-      value.is_restrictive,
-      value.isRestrictive,
-      value.restrictive_relation,
-      value.restrictiveRelation,
-      value.name,
-      value.label,
-      value.type,
-    ].some(truthyRelationValue);
-  }
-
-  return false;
-};
-
-export const isRestrictiveLineageEdge = (edge = {}) =>
-  [
-    edge.restrictive,
-    edge.is_restrictive,
-    edge.isRestrictive,
-    edge.restrictive_relation,
-    edge.restrictiveRelation,
-    edge.metadata?.restrictive,
-    edge.metadata?.is_restrictive,
-    edge.metadata?.isRestrictive,
-    edge.metadata?.restrictive_relation,
-    edge.metadata?.restrictiveRelation,
-    edge.relation?.restrictive,
-    edge.relation?.is_restrictive,
-    edge.relation_type,
-    edge.relationType,
-    edge.metadata?.relation_type,
-    edge.metadata?.relationType,
-  ].some(truthyRelationValue);
-
-const nodeKind = (node, kind) =>
-  kind === "group" && _.toLower(node.type) === "session" ? "process" : kind;
-
-const LINEAGE_ENTITY_ICON = {
-  column: "grip vertical",
-  database: "database",
-  field: "copy",
-  process: "sync alternate",
-  report: "tasks",
-  schema: "th",
-  system: "sitemap",
-  table: "table",
-  view: "eye",
-};
-
-export const normalizeLineageEntityType = (value, fallback = "table") => {
-  const normalized = compactText(value)
-    .trim()
-    .toLowerCase()
-    .replace(/^lineage[\s_-]*/, "")
-    .replace(/[\s_]+/g, "-");
-  const aliases = {
-    db: "database",
-    "data-base": "database",
-    dataset: "table",
-    dashboard: "report",
-    query: "view",
-    session: "process",
-  };
-  const entityType = aliases[normalized] || normalized;
-
-  return LINEAGE_ENTITY_ICON[entityType] ? entityType : fallback;
-};
-
-const lineageEntityPresentation = (node, kind) => {
-  const fallback =
-    kind === "process" ? "process" : kind === "group" ? "system" : "table";
-  const rawType =
-    node.entity_type || node.entityType || node.type || node.metadata?.type;
-  const entityType = node.topology
-    ? normalizeLineageEntityType(rawType, rawType || "")
-    : normalizeLineageEntityType(rawType, fallback);
-
-  return {
-    entityType,
-    iconName: LINEAGE_ENTITY_ICON[entityType],
-    isSystem: normalizeLineageEntityType(rawType) === "system",
-  };
-};
-
-export const lineageCatalogState = (node = {}) => {
-  const records = [node, ...(node.originals || [])];
-  const isDeleted = (record) =>
-    [record, record.metadata || {}].some(
-      (value) =>
-        Boolean(value.deleted_at || value.deletion_date) ||
-        [value.deleted, value.is_deleted, value.isDeleted].some(
-          (flag) => flag === true || flag === "true",
-        ) ||
-        [value.status, value.state].some(
-          (status) =>
-            typeof status === "string" && status.toLowerCase() === "deleted",
-        ),
-    );
-  const hasStructure = (record) =>
-    [record.structure_id, record.data_structure_id].some(
-      (id) => id !== undefined && id !== null && id !== "",
-    );
-
-  if (records.some((record) => hasStructure(record) && !isDeleted(record)))
-    return "present";
-  if (records.some(isDeleted)) return "deleted";
-  if (
-    records.some(
-      (record) =>
-        record.structure_id === null || record.data_structure_id === null,
-    )
-  )
-    return "absent";
-  return "unknown";
-};
-
-const compactText = (value) => {
-  if (value === undefined || value === null) return "";
-  if (typeof value === "object") {
-    return compactText(
-      value.name || value.label || value.value || value.external_id || value.id,
-    );
-  }
-
-  return `${value}`;
-};
-
-const firstText = (...values) =>
-  values.map(compactText).find((value) => !_.isEmpty(value));
-
-const normalizeFieldText = (value) => compactText(value).trim().toLowerCase();
-
-const lineageFieldName = (field) =>
-  normalizeFieldText(
-    typeof field === "string"
-      ? field
-      : field?.name ||
-          field?.label ||
-          field?.field ||
-          field?.external_id ||
-          field?.id,
-  );
-
-const fieldHandleId = (type, index) => `field-${type}-${index}`;
-
-const normalizeSystemTypeText = (value) => {
-  const text = compactText(value).trim();
-  const normalized = text
-    .toLowerCase()
-    .replace(/[\s_]+/g, " ")
-    .trim();
-  if (
-    !normalized ||
-    normalized === "without system group" ||
-    normalized === "without system" ||
-    normalized === "without group" ||
-    normalized === "sin sistema" ||
-    normalized === "sin grupo" ||
-    normalized === "sin grupo de sistema" ||
-    normalized === "sin grupo sistema" ||
-    normalized.startsWith("without system") ||
-    normalized.startsWith("sin grupo") ||
-    normalized === "unknown" ||
-    normalized === "desconocido" ||
-    normalized === "n/a" ||
-    normalized === "na" ||
-    normalized === "none" ||
-    normalized === "null" ||
-    normalized === "-"
-  )
-    return "";
-  return text;
-};
-
-const nestedSystemGroupValue = (value) => {
-  if (!value || typeof value !== "object") return "";
-
-  return firstText(
-    value.system_group,
-    value.systemGroup,
-    value.system_group_name,
-    value.systemGroupName,
-    value.system_group_id,
-    value.systemGroupId,
-    value.group?.name,
-    value.group?.label,
-    value.group?.value,
-    value.group,
-    value.value,
-    value.name,
-    value.label,
-    value.id,
-  );
-};
-
-export const lineageSystemTypeLabel = (node = {}) =>
-  normalizeSystemTypeText(
-    firstText(
-      node.system_group,
-      node.systemGroup,
-      node.system_group_name,
-      node.systemGroupName,
-      node.system_group_id,
-      node.systemGroupId,
-      node.dynamic_content?.system_group?.value,
-      node.dynamic_content?.systemGroup?.value,
-      node.dynamicContent?.system_group?.value,
-      node.dynamicContent?.systemGroup?.value,
-      node.metadata?.system_group,
-      node.metadata?.systemGroup,
-      node.metadata?.system_group_name,
-      node.metadata?.systemGroupName,
-      node.metadata?.dynamic_content?.system_group?.value,
-      node.metadata?.dynamic_content?.systemGroup?.value,
-      node.metadata?.dynamicContent?.system_group?.value,
-      node.metadata?.dynamicContent?.systemGroup?.value,
-      nestedSystemGroupValue(node.system_group),
-      nestedSystemGroupValue(node.systemGroup),
-      nestedSystemGroupValue(node.metadata?.system_group),
-      nestedSystemGroupValue(node.metadata?.systemGroup),
-      nestedSystemGroupValue(node.system),
-      nestedSystemGroupValue(node.metadata?.system),
-      nestedSystemGroupValue(node.source_system),
-      nestedSystemGroupValue(node.sourceSystem),
-    ),
-  );
-
-const systemTypeKey = (label) =>
-  normalizeSystemTypeText(label).toLowerCase().replace(/\s+/g, " ");
-
-export const lineageSystemTypeClassName = (label) =>
-  systemTypeKey(label)
-    .replace(/[^a-z0-9]+/g, "-")
-    .replace(/^-|-$/g, "") || "without-system-type";
-
-const systemTypeHash = (label) =>
-  systemTypeKey(label)
-    .split("")
-    .reduce((hash, char) => (hash * 31 + char.charCodeAt(0)) >>> 0, 0);
-
-export const lineageSystemTypeColor = (label) => {
-  if (_.isEmpty(systemTypeKey(label))) return LINEAGE_UNKNOWN_SYSTEM_TYPE_COLOR;
-
-  const [accent, accentStrong, border, accentSoft] =
-    LINEAGE_SYSTEM_TYPE_PALETTE[
-      systemTypeHash(label) % LINEAGE_SYSTEM_TYPE_PALETTE.length
-    ];
-
-  return {
-    accent,
-    accentStrong,
-    accentSoft,
-    border,
-    bg: accentSoft.replace(/0\.14\)$/, "0.7)"),
-    text: accentStrong,
-    shadow: accentSoft.replace(/0\.14\)$/, "0.18)"),
-  };
-};
-
-export const lineageSystemType = (node = {}) => {
-  const label = lineageSystemTypeLabel(node);
-  const color = lineageSystemTypeColor(label);
-
-  return {
-    color,
-    className: lineageSystemTypeClassName(label),
-    key: systemTypeKey(label) || "__without_system_type__",
-    label,
-    missing: _.isEmpty(systemTypeKey(label)),
-  };
-};
-
-const lineageSystemTypeWithParentFallback = (parentByNode, node = {}) => {
-  const ownSystemType = lineageSystemType(node);
-
-  if (!ownSystemType.missing) return ownSystemType;
-
-  const visitedIds = new Set([nodeId(node)]);
-  let parentGroup = parentByNode.get(node);
-
-  while (parentGroup) {
-    const parentId = nodeId(parentGroup);
-
-    if (visitedIds.has(parentId)) return ownSystemType;
-    visitedIds.add(parentId);
-
-    const parentSystemType = lineageSystemType(parentGroup);
-
-    if (!parentSystemType.missing) return parentSystemType;
-
-    parentGroup = parentByNode.get(parentGroup);
-  }
-
-  return ownSystemType;
-};
-
-const lineageSystemColorClass = (systemType) =>
-  `td-lineage-system-color--${
-    systemType.missing
-      ? "unknown"
-      : systemTypeHash(systemType.label) % LINEAGE_SYSTEM_TYPE_PALETTE.length
-  }`;
-
-const lineageEntityColorClass = (entityType) =>
-  `td-lineage-entity-color--${LINEAGE_ENTITY_ICON[entityType] ? entityType : "table"}`;
-
-const lineageFieldCollection = (node) =>
-  [
-    node.fields,
-    node.columns,
-    node.metadata?.fields,
-    node.metadata?.columns,
-    node.data_fields,
-  ].find(Array.isArray);
-
-const lineageFields = (node) =>
-  (lineageFieldCollection(node) || []).filter(Boolean);
-
-export const lineageNodeContentWidth = (resources = []) => {
-  const longestLine = resources.reduce((maxLength, node) => {
-    const labelLength = compactText(node.name || node.label || node.id).length;
-    const fieldLines = lineageFields(node).map((field) => {
-      const fieldNameLength = compactText(
-        typeof field === "string"
-          ? field
-          : firstText(
-              field?.name,
-              field?.label,
-              field?.field,
-              field?.external_id,
-              field?.id,
-            ),
-      ).length;
-      const fieldTypeLength =
-        typeof field === "string"
-          ? 0
-          : compactText(
-              firstText(
-                field?.type,
-                field?.data_type,
-                field?.dataType,
-                field?.metadata?.type,
-              ),
-            ).length;
-
-      return fieldNameLength + (fieldTypeLength ? fieldTypeLength + 3 : 0);
-    });
-
-    return Math.max(maxLength, labelLength, ...fieldLines);
-  }, 0);
-  const contentWidth = Math.ceil(
-    longestLine * LINEAGE_TEXT_WIDTH_FACTOR + LINEAGE_NODE_WIDTH_PADDING,
-  );
-
-  return Math.min(
-    LINEAGE_NODE_WIDTH_MAX,
-    Math.max(LINEAGE_NODE_WIDTH_MIN, contentWidth),
-  );
-};
-
-const lineagePath = (node, system, schema) => {
-  const path = node.path || node.ancestry || node.parents || node.parent_path;
-  const pathItems = Array.isArray(path)
-    ? path.map((item) => firstText(item?.name, item?.label, item?.value, item))
-    : typeof path === "string"
-      ? path.split(/\s*(?:>|\/)\s*/)
-      : [];
-
-  return [...pathItems, system, schema].filter(Boolean);
-};
-
-const lineageStatus = (node) =>
-  firstText(
-    node.status,
-    node.health,
-    node.metadata?.status,
-    node.metadata?.health,
-  );
-
-const lineageQuality = (node) =>
-  firstText(
-    node.quality,
-    node.quality_score,
-    node.metadata?.quality,
-    node.metadata?.quality_score,
-    node.metadata?.score,
-  );
-
-const nodeHeight = ({ fields, hiddenFieldsCount, system, schema }) =>
-  NODE_BASE_HEIGHT +
-  (system || schema ? NODE_CONTEXT_HEIGHT : 0) +
-  fields.length * NODE_FIELD_HEIGHT +
-  (hiddenFieldsCount ? NODE_MORE_HEIGHT : 0);
-
-export const redesignedLineageNodeHeight = (
-  fieldCount = 0,
-  fieldsExpanded = false,
-) => {
-  const visibleRowCount = Math.min(
-    fieldCount,
-    fieldsExpanded
-      ? NODE_FIELD_EXPANDED_LIMIT_REDESIGNED
-      : NODE_FIELD_LIMIT_REDESIGNED,
-  );
-  const hasDisclosure = fieldCount > NODE_FIELD_LIMIT_REDESIGNED;
-
-  return (
-    NODE_BASE_HEIGHT_REDESIGNED +
-    visibleRowCount * NODE_FIELD_HEIGHT_REDESIGNED +
-    (hasDisclosure ? NODE_MORE_HEIGHT_REDESIGNED : 0)
-  );
-};
-
-const lineageNode =
-  (
-    kind,
-    selectedNodeId,
-    nodeDesign = "redesigned",
-    {
-      expandedFieldNodeIds = new Set(),
-      instanceId,
-      onToggleFields,
-      nodeWidth,
-    } = {},
-  ) =>
-  (node) => {
-    const id = instanceId || nodeId(node);
-    const resolvedKind = nodeKind(node, kind);
-    const allFields = lineageFields(node);
-    const fieldsKnown = Boolean(lineageFieldCollection(node));
-    const redesigned = nodeDesign === "redesigned";
-    const fieldsExpanded = redesigned && expandedFieldNodeIds.has(id);
-    const fieldLimit = redesigned
-      ? fieldsExpanded
-        ? allFields.length
-        : NODE_FIELD_LIMIT_REDESIGNED
-      : NODE_FIELD_LIMIT;
-    const fields = allFields.slice(0, fieldLimit);
-    const hiddenFieldsCount = Math.max(
-      allFields.length -
-        (redesigned ? NODE_FIELD_LIMIT_REDESIGNED : fieldLimit),
-      0,
-    );
-    const system = firstText(node.system, node.system_name);
-    const schema = firstText(node.schema, node.schema_name, node.database);
-    const systemType = lineageSystemType(node);
-    const entity = lineageEntityPresentation(node, resolvedKind);
-    const path = redesigned ? lineagePath(node, system, schema) : [];
-    const width = redesigned ? nodeWidth || NODE_WIDTH_REDESIGNED : NODE_WIDTH;
-
-    return {
-      id,
-      type: redesigned ? "lineageResource" : "concept",
-      width,
-      height: redesigned
-        ? redesignedLineageNodeHeight(allFields.length, fieldsExpanded)
-        : nodeHeight({ fields, hiddenFieldsCount, system, schema }),
-      draggable: false,
-      className: [
-        lineageSystemColorClass(systemType),
-        lineageEntityColorClass(entity.entityType),
-        `td-lineage-catalog--${lineageCatalogState(node)}`,
-        entity.isSystem ? "td-lineage-resource-node--entity-system" : "",
-      ]
-        .filter(Boolean)
-        .join(" "),
-      style: redesigned
-        ? { "--td-lineage-node-width": `${width}px` }
-        : undefined,
-      data: {
-        label: node.name || id,
-        meta: node.type,
-        kind: resolvedKind,
-        entityType: entity.entityType,
-        iconName: entity.iconName,
-        variant: redesigned ? "lineage-redesigned" : "lineage",
-        systemType: systemType.key,
-        systemTypeClassName: systemType.className,
-        systemTypeColor: systemType.color.accent,
-        systemTypeLabel: systemType.label,
-        systemTypeMissing: systemType.missing,
-        system,
-        schema,
-        path,
-        status: redesigned ? lineageStatus(node) : undefined,
-        quality: redesigned ? lineageQuality(node) : undefined,
-        fields,
-        allFields,
-        fieldsKnown,
-        fieldHandleLimit: redesigned
-          ? Math.min(
-              allFields.length,
-              fieldsExpanded
-                ? NODE_FIELD_EXPANDED_LIMIT_REDESIGNED
-                : NODE_FIELD_LIMIT_REDESIGNED,
-            )
-          : fields.length,
-        fieldsExpanded,
-        hiddenFieldsCount,
-        onToggleFields:
-          redesigned && hiddenFieldsCount > 0 && onToggleFields
-            ? () => onToggleFields(id)
-            : undefined,
-        totalFields: allFields.length,
-        isActive: selectedNodeId === id,
-        lineageNode: { ...node, id, lineageKind: resolvedKind },
-      },
-    };
-  };
-
-const positionedNodeGeometryForDesign = (node, nodeDesign, kind, nodeWidth) => {
-  if (nodeDesign !== "redesigned") return resourceRenderedGeometry(node);
-
-  const geometry = nodeGeometry(node);
-  const baseNode = lineageNode(kind, undefined, nodeDesign, { nodeWidth })(
-    node,
-  );
-
-  return {
-    x: geometry.x,
-    y: geometry.y,
-    w: baseNode.width,
-    h: baseNode.height,
-  };
-};
-
-const lineagePositionedGroupNode =
-  (
-    { parentByNode, childCountsByCanonicalId },
-    selectedNodeId,
-    duplicateNodeIds,
-    geometryById,
-    nodeDesign,
-    resolveSystemType = lineageSystemType,
-  ) =>
-  (node) => {
-    const canonicalId = nodeId(node);
-    const id = positionedNodeInstanceId(node, duplicateNodeIds);
-    const parentGroup = parentByNode.get(node);
-    const parentId = parentGroup
-      ? positionedNodeInstanceId(parentGroup, duplicateNodeIds)
-      : undefined;
-    const { x, y, w, h } = geometryById.get(id) || nodeGeometry(node);
-    const parentGeometry = parentId ? geometryById.get(parentId) : undefined;
-    const position = {
-      x: parentGeometry ? x - parentGeometry.x : x,
-      y: parentGeometry ? y - parentGeometry.y : y,
-    };
-    const systemType = resolveSystemType(node);
-    const entity = lineageEntityPresentation(node, "group");
-    const rootGroup = canonicalId === ROOT_GROUP_ID;
-    const z = nodeDepth(node);
-    const childCounts = childCountsByCanonicalId.get(canonicalId) || {
-      nodeCount: 0,
-      groupCount: 0,
-    };
-
-    return {
-      id,
-      type: "lineageGroup",
-      width: w,
-      height: h,
-      parentId,
-      extent: parentId ? "parent" : undefined,
-      position,
-      draggable: !rootGroup && (!parentId || parentId === ROOT_GROUP_ID),
-      selectable: !rootGroup,
-      data: {
-        canonicalId,
-        designVariant: nodeDesign,
-        isActive: selectedNodeId === canonicalId,
-        label: node.name || "",
-        absoluteGeometry: absoluteGeometry({ x, y, w, h }),
-        variant: "absolute",
-        z,
-        entityType: entity.entityType,
-        iconName: entity.iconName,
-        systemType: systemType.key,
-        systemTypeClassName: systemType.className,
-        systemTypeColor: systemType.color.accent,
-        systemTypeLabel: systemType.label,
-        systemTypeMissing: systemType.missing,
-        nodeCount: childCounts.nodeCount,
-        groupCount: childCounts.groupCount,
-        lineageNode: { ...node, id: canonicalId, lineageKind: "group" },
-      },
-      className: [
-        lineageSystemColorClass(systemType),
-        lineageEntityColorClass(entity.entityType),
-        `td-lineage-catalog--${lineageCatalogState(node)}`,
-        entity.isSystem ? "td-lineage-group-node--entity-system" : "",
-      ]
-        .filter(Boolean)
-        .join(" "),
-      style: { width: w, height: h },
-      zIndex: LINEAGE_GROUP_Z_INDEX + nodeDepth(node),
-    };
-  };
-
-const lineagePositionedResourceNode =
-  (
-    parentByNode,
-    selectedNodeId,
-    duplicateNodeIds,
-    geometryById,
-    nodeDesign,
-    kind = "resource",
-    resolveSystemType = lineageSystemType,
-    expandedFieldNodeIds = new Set(),
-    onToggleFields,
-    nodeWidth,
-  ) =>
-  (node) => {
-    const redesigned = nodeDesign === "redesigned";
-    const canonicalId = nodeId(node);
-    const id = positionedNodeInstanceId(node, duplicateNodeIds);
-    const parentGroup = parentByNode.get(node);
-    const parentId = parentGroup
-      ? positionedNodeInstanceId(parentGroup, duplicateNodeIds)
-      : undefined;
-    const baseNode = lineageNode(kind, selectedNodeId, nodeDesign, {
-      expandedFieldNodeIds,
-      instanceId: id,
-      onToggleFields,
-      nodeWidth,
-    })(node);
-    const systemType = resolveSystemType(node);
-    const rawGeometry =
-      geometryById.get(id) ||
-      positionedNodeGeometryForDesign(node, nodeDesign, kind, nodeWidth);
-    const w = redesigned ? baseNode.width : rawGeometry.w;
-    const h = redesigned ? baseNode.height : rawGeometry.h;
-    const x = rawGeometry.x;
-    const y = rawGeometry.y;
-    const parentGeometry = parentId ? geometryById.get(parentId) : undefined;
-    const position = {
-      x: parentGeometry ? x - parentGeometry.x : x,
-      y: parentGeometry ? y - parentGeometry.y : y,
-    };
-
-    return {
-      ...baseNode,
-      id,
-      className: [
-        lineageSystemColorClass(systemType),
-        `td-lineage-catalog--${lineageCatalogState(node)}`,
-        baseNode.className.includes("td-lineage-resource-node--entity-system")
-          ? "td-lineage-resource-node--entity-system"
-          : "",
-      ]
-        .filter(Boolean)
-        .join(" "),
-      type: "lineageResource",
-      width: w,
-      height: h,
-      parentId,
-      extent: parentId ? "parent" : undefined,
-      position,
-      draggable: false,
-      data: {
-        ...baseNode.data,
-        systemType: systemType.key,
-        systemTypeClassName: systemType.className,
-        systemTypeColor: systemType.color.accent,
-        systemTypeLabel: systemType.label,
-        systemTypeMissing: systemType.missing,
-        absoluteGeometry: absoluteGeometry({
-          x,
-          y,
-          w,
-          h,
-        }),
-        canonicalId,
-        isActive: selectedNodeId === canonicalId,
-        lineageNode: baseNode.data.lineageNode
-          ? { ...baseNode.data.lineageNode, id: canonicalId }
-          : undefined,
-        meta: redesigned ? baseNode.data.meta : undefined,
-        variant: redesigned ? baseNode.data.variant : "lineage-compact",
-      },
-      style: {
-        ...(redesigned ? { "--td-lineage-node-width": `${w}px` } : {}),
-        width: w,
-        height: h,
-      },
-      zIndex: LINEAGE_RESOURCE_Z_INDEX + nodeDepth(parentGroup),
-    };
-  };
-
-export const lineageTopologyNodes = (
-  topology,
-  nodeDesign = "redesigned",
-  nodeWidth = NODE_WIDTH_REDESIGNED,
-) => {
-  const parentByNode = new Map();
-  const childCountsByCanonicalId = new Map();
-  const nodeById = new Map(topology.nodes.map((node) => [node.id, node]));
-  const geometryById = new Map();
-  topology.nodes.forEach((node) => {
-    parentByNode.set(node, nodeById.get(node.parentId));
-    geometryById.set(node.id, {
-      x: 0,
-      y: 0,
-      w: nodeWidth,
-      h: COLLAPSED_GROUP_HEIGHT,
-    });
-    if (!node.parentId) return;
-    const counts = childCountsByCanonicalId.get(node.parentId) || {
-      nodeCount: 0,
-      groupCount: 0,
-    };
-    counts[node.container ? "groupCount" : "nodeCount"] += 1;
-    childCountsByCanonicalId.set(node.parentId, counts);
-  });
-  const resolveSystemType = (node) =>
-    lineageSystemTypeWithParentFallback(parentByNode, node);
-  const groupNode = lineagePositionedGroupNode(
-    { parentByNode, childCountsByCanonicalId },
-    undefined,
-    new Set(),
-    geometryById,
-    nodeDesign,
-    resolveSystemType,
-  );
-  const resourceNode = lineagePositionedResourceNode(
-    parentByNode,
-    undefined,
-    new Set(),
-    geometryById,
-    nodeDesign,
-    "resource",
-    resolveSystemType,
-    new Set(),
-    undefined,
-    nodeWidth,
-  );
-  return [...topology.nodes]
-    .sort((a, b) => a.z - b.z || a.id.localeCompare(b.id))
-    .map((node) => {
-      const rendered = node.container ? groupNode(node) : resourceNode(node);
-      const height = node.field
-        ? NODE_FIELD_HEIGHT_REDESIGNED
-        : rendered.height;
-      return {
-        ...rendered,
-        height,
-        style: { ...rendered.style, height },
-        data: {
-          ...rendered.data,
-          topology: true,
-          resourceContainer: node.resourceContainer,
-          variant: node.field ? "lineage-field" : rendered.data.variant,
-          absoluteGeometry: { ...rendered.data.absoluteGeometry, h: height },
-        },
-      };
-    });
-};
-
-const isRootPositionedGroup = (node) => nodeId(node) === ROOT_GROUP_ID;
-
-const hasPositionedChildren = (group, groups = [], resources = []) =>
-  [...groups, ...resources].some(
-    (node) =>
-      canBePositionedParent(group, node) &&
-      (containsGeometry(group, node) || anchoredParentGeometry(group, node)),
-  );
-
-const splitPositionedGroups = (groups = [], resources = []) =>
-  groups.reduce(
-    (result, group) => {
-      const container =
-        isRootPositionedGroup(group) ||
-        hasPositionedChildren(group, groups, resources);
-
-      result[container ? "containerGroups" : "leafGroups"].push(group);
-
-      return result;
-    },
-    { containerGroups: [], leafGroups: [] },
-  );
-
-export const preparePositionedLineageHierarchy = (
-  groups = [],
-  resources = [],
-) => {
-  const { containerGroups, leafGroups } = splitPositionedGroups(
-    groups,
-    resources,
-  );
-  const parentByNode = new Map();
-  const childrenByParent = new Map();
-  const childCountsByCanonicalId = new Map();
-  const groupSet = new Set(containerGroups);
-
-  [...containerGroups, ...resources, ...leafGroups].forEach((node) => {
-    if (!parentByNode.has(node)) {
-      parentByNode.set(node, parentGroupFor(containerGroups, node));
-    }
-    const parent = parentByNode.get(node);
-
-    if (!parent) return;
-
-    const children = childrenByParent.get(parent) || [];
-    children.push(node);
-    childrenByParent.set(parent, children);
-  });
-
-  childrenByParent.forEach((children, parent) => {
-    const canonicalId = nodeId(parent);
-    const counts = childCountsByCanonicalId.get(canonicalId) || {
-      nodeCount: 0,
-      groupCount: 0,
-    };
-    children.forEach((child) => {
-      counts[groupSet.has(child) ? "groupCount" : "nodeCount"] += 1;
-    });
-    childCountsByCanonicalId.set(canonicalId, counts);
-  });
-
-  return {
-    containerGroups,
-    leafGroups,
-    parentByNode,
-    childrenByParent,
-    childCountsByCanonicalId,
-  };
-};
-
-const sortPositionedGroups = (groups = []) =>
-  [...groups].sort((groupA, groupB) => {
-    const zDiff = nodeDepth(groupA) - nodeDepth(groupB);
-
-    if (zDiff !== 0) return zDiff;
-
-    return geometryArea(groupB) - geometryArea(groupA);
-  });
-
-const uniqueNodes = (nodes = []) => {
-  const seen = new Set();
-
-  return nodes.filter((node) => {
-    if (!node?.id || seen.has(node.id)) return false;
-
-    seen.add(node.id);
-    return true;
-  });
-};
-
-const removeRenderedRootContainer = (nodes = []) =>
-  nodes
-    .filter((node) => !isRootLineageGroupNode(node))
-    .map((node) => {
-      if (node.parentId !== ROOT_GROUP_ID) return node;
-
-      const geometry = lineageNodeAbsoluteGeometry(node);
-
-      return {
-        ...node,
-        parentId: undefined,
-        extent: undefined,
-        position: { x: geometry.x, y: geometry.y },
-      };
-    });
-
-const presentTerminalResourcesAsFieldRows = (nodes = []) => {
-  const childrenByParentId = nodes.reduce((children, node) => {
-    if (!node.parentId) return children;
-
-    const siblings = children.get(node.parentId) || [];
-
-    siblings.push(node);
-    children.set(node.parentId, siblings);
-    return children;
-  }, new Map());
-  const resourceContainerIds = new Set(
-    nodes
-      .filter((node) => {
-        if (node.type !== "lineageGroup") return false;
-
-        const children = childrenByParentId.get(node.id) || [];
-
-        return (
-          children.length > 0 &&
-          children.every(
-            (child) =>
-              child.type === "lineageResource" &&
-              Number(child.data?.totalFields || 0) === 0,
-          )
-        );
-      })
-      .map((node) => node.id),
-  );
-
-  if (!resourceContainerIds.size) return nodes;
-
-  return nodes.map((node) => {
-    if (resourceContainerIds.has(node.id)) {
-      return {
-        ...node,
-        data: {
-          ...node.data,
-          resourceContainer: true,
-          iconName: lineageNodeIcon({
-            kind: "group",
-            resourceContainer: true,
-            z: node.data?.z,
-          }),
-        },
-      };
-    }
-
-    if (!resourceContainerIds.has(node.parentId)) return node;
-
-    const height = NODE_FIELD_HEIGHT_REDESIGNED;
-
-    return {
-      ...node,
-      height,
-      data: {
-        ...node.data,
-        absoluteGeometry: node.data?.absoluteGeometry
-          ? { ...node.data.absoluteGeometry, h: height }
-          : node.data?.absoluteGeometry,
-        variant: "lineage-field",
-      },
-      style: {
-        ...node.style,
-        height,
-      },
-    };
-  });
-};
-
-const lineageNodeParentMap = (nodes = []) =>
-  nodes.reduce((parents, node) => {
-    if (node?.id && node.parentId) parents.set(node.id, node.parentId);
-
-    return parents;
-  }, new Map());
-
-const normalizedExpansionDepth = (value, fallback, maximum) => {
-  const depth = Number(value);
-  const fallbackDepth = Number(fallback);
-  const safeFallback = Math.min(
-    maximum,
-    Math.max(
-      0,
-      Number.isInteger(fallbackDepth)
-        ? fallbackDepth
-        : LINEAGE_DEFAULT_EXPANSION_DEPTH,
-    ),
-  );
-
-  return Number.isInteger(depth) && depth >= 0 && depth <= maximum
-    ? depth
-    : safeFallback;
-};
-
-const lineageGroupDepths = (nodes = []) => {
-  const nodeById = new Map(nodes.map((node) => [node.id, node]));
-  const parentById = lineageNodeParentMap(nodes);
-  const depthById = new Map();
-  const groupDepth = (nodeId, visiting = new Set()) => {
-    if (depthById.has(nodeId)) return depthById.get(nodeId);
-    if (visiting.has(nodeId)) return 1;
-
-    const parentId = parentById.get(nodeId);
-    const parent = nodeById.get(parentId);
-    const nextVisiting = new Set(visiting).add(nodeId);
-    const value =
-      parent?.type === "lineageGroup" && !isRootLineageGroupNode(parent)
-        ? groupDepth(parentId, nextVisiting) + 1
-        : 1;
-
-    depthById.set(nodeId, value);
-    return value;
-  };
-
-  nodes
-    .filter(
-      (node) => node.type === "lineageGroup" && !isRootLineageGroupNode(node),
-    )
-    .forEach((node) => groupDepth(node.id));
-
-  return depthById;
-};
-
-const lineageDepthCollapsibleGroups = (nodes = []) => {
-  const descendantCounts = lineageDescendantCounts(nodes);
-
-  return nodes.filter(
-    (node) =>
-      node.type === "lineageGroup" &&
-      node.data?.variant === "absolute" &&
-      !isRootLineageGroupNode(node) &&
-      (descendantCounts.get(node.id) || 0) > 0,
-  );
-};
-
-export const lineageMaximumExpansionDepth = (nodes = []) => {
-  const depthById = lineageGroupDepths(nodes);
-
-  return lineageDepthCollapsibleGroups(nodes).reduce(
-    (maximumDepth, node) => Math.max(maximumDepth, depthById.get(node.id) || 0),
-    0,
-  );
-};
-
-export const lineageCollapsedGroupIdsForDepth = (nodes = [], depth = 3) => {
-  const depthById = lineageGroupDepths(nodes);
-
-  return new Set(
-    lineageDepthCollapsibleGroups(nodes)
-      .filter((node) => (depthById.get(node.id) || 0) > depth)
-      .map((node) => node.id),
-  );
-};
-
-const lineageDescendantCounts = (nodes = []) => {
-  const parentById = lineageNodeParentMap(nodes);
-  const counts = new Map();
-
-  nodes.forEach((node) => {
-    let parentId = parentById.get(node.id);
-
-    while (parentId) {
-      counts.set(parentId, (counts.get(parentId) || 0) + 1);
-      parentId = parentById.get(parentId);
-    }
-  });
-
-  return counts;
-};
-
-const hiddenByCollapsedAncestor = (node, parentById, collapsedIds) => {
-  let parentId = parentById.get(node.id);
-
-  while (parentId) {
-    if (collapsedIds.has(parentId)) return true;
-
-    parentId = parentById.get(parentId);
-  }
-
-  return false;
-};
-
-export const expandLineageDescendants = (collapsedIds, nodeId, nodes = []) => {
-  const parentById = lineageNodeParentMap(nodes);
-  const expandedIds = new Set([nodeId]);
-
-  nodes.forEach((node) => {
-    let parentId = parentById.get(node.id);
-
-    while (parentId) {
-      if (parentId === nodeId) {
-        expandedIds.add(node.id);
-        break;
-      }
-
-      parentId = parentById.get(parentId);
-    }
-  });
-
-  return new Set(Array.from(collapsedIds).filter((id) => !expandedIds.has(id)));
-};
-
-export const LINEAGE_OVERSIZED_CHILD_LIMIT = 20;
-
-export const lineageDirectChildCounts = (nodes = []) => {
-  const counts = new Map();
-
-  nodes.forEach((node) => {
-    if (!node?.parentId) return;
-
-    counts.set(node.parentId, (counts.get(node.parentId) || 0) + 1);
-  });
-
-  return counts;
-};
-
-export const expandLineageDescendantsUntilOversized = (
-  collapsedIds,
-  nodeId,
-  nodes = [],
-  oversizedIds,
-  warnedIds = new Set(),
-) => {
-  const parentById = lineageNodeParentMap(nodes);
-  const next = expandLineageDescendants(collapsedIds, nodeId, nodes);
-
-  oversizedIds.forEach((id) => {
-    if (id === nodeId || warnedIds.has(id)) return;
-
-    let parentId = parentById.get(id);
-
-    while (parentId) {
-      if (parentId === nodeId) {
-        next.add(id);
-        return;
-      }
-      parentId = parentById.get(parentId);
-    }
-  });
-
-  return next;
-};
-
-const visibleEndpointId = (nodeId, parentById, visibleNodeIds) => {
-  let currentId = nodeId;
-
-  while (currentId) {
-    if (visibleNodeIds.has(currentId)) return currentId;
-
-    currentId = parentById.get(currentId);
-  }
-
-  return "";
-};
-
-const isRootLineageGroupNode = (node = {}) =>
-  node.id === ROOT_GROUP_ID &&
-  node.type === "lineageGroup" &&
-  node.data?.variant === "absolute";
-
-const lineageNodeAbsoluteGeometry = (node = {}) =>
-  node.data?.absoluteGeometry || {
-    x: node.position?.x || node.x || 0,
-    y: node.position?.y || node.y || 0,
-    w: node.width || node.measured?.width || NODE_WIDTH,
-    h: node.height || node.measured?.height || NODE_BASE_HEIGHT,
-  };
-
-const resizeVisibleLineageGroups = (nodes = [], options = {}) => {
-  const { stackChildren = false } = options;
-  const nodeById = new Map(nodes.map((node) => [node.id, node]));
-  const rootNodeIds = [];
-  const childIdsByParentId = nodes.reduce((childrenByParentId, node) => {
-    if (!node.parentId || !nodeById.has(node.parentId)) {
-      if (node.id) rootNodeIds.push(node.id);
-      return childrenByParentId;
-    }
-
-    const childIds = childrenByParentId.get(node.parentId) || [];
-
-    childIds.push(node.id);
-    childrenByParentId.set(node.parentId, childIds);
-
-    return childrenByParentId;
-  }, new Map());
-  const geometryById = new Map();
-
-  const shiftGeometryTree = (id, deltaX, deltaY) => {
-    const geometry = geometryById.get(id);
-
-    if (geometry) {
-      geometryById.set(id, {
-        ...geometry,
-        x: geometry.x + deltaX,
-        y: geometry.y + deltaY,
-      });
-    }
-
-    (childIdsByParentId.get(id) || []).forEach((childId) =>
-      shiftGeometryTree(childId, deltaX, deltaY),
-    );
-  };
-
-  const resolveGeometry = (node) => {
-    if (geometryById.has(node.id)) return geometryById.get(node.id);
-
-    const baseGeometry = lineageNodeAbsoluteGeometry(node);
-    const childIds = childIdsByParentId.get(node.id) || [];
-
-    const childNodes = childIds
-      .map((childId) => nodeById.get(childId))
-      .filter(Boolean);
-
-    childNodes.forEach(resolveGeometry);
-
-    if (stackChildren) {
-      stackSiblingGeometries(
-        childIds,
-        geometryById,
-        shiftGeometryTree,
-        shouldCompactVisibleGroupChildren(node, childNodes)
-          ? POSITIONED_LEAF_SIBLING_GAP
-          : POSITIONED_SIBLING_GAP,
-      );
-    } else if (shouldRowSiblingGroups(childNodes)) {
-      rowSiblingGeometries(childIds, geometryById, shiftGeometryTree);
-    } else {
-      stackSiblingGeometries(
-        childIds,
-        geometryById,
-        shiftGeometryTree,
-        shouldCompactVisibleGroupChildren(node, childNodes)
-          ? POSITIONED_LEAF_SIBLING_GAP
-          : POSITIONED_SIBLING_GAP,
-      );
-    }
-
-    const childGeometries = childIds
-      .map((childId) => geometryById.get(childId))
-      .filter(Boolean);
-
-    if (
-      node.type !== "lineageGroup" ||
-      node.data?.variant !== "absolute" ||
-      _.isEmpty(childGeometries)
-    ) {
-      geometryById.set(node.id, baseGeometry);
-      return baseGeometry;
-    }
-
-    const maxChildX = Math.max(
-      ...childGeometries.map(
-        (geometry) => geometry.x + geometry.w + POSITIONED_GROUP_PADDING_X,
-      ),
-    );
-    const maxChildY = Math.max(
-      ...childGeometries.map(
-        (geometry) => geometry.y + geometry.h + POSITIONED_GROUP_PADDING_BOTTOM,
-      ),
-    );
-    const minChildX = Math.min(
-      ...childGeometries.map(
-        (geometry) => geometry.x - POSITIONED_GROUP_PADDING_X,
-      ),
-    );
-    const minChildY = Math.min(
-      ...childGeometries.map(
-        (geometry) => geometry.y - POSITIONED_GROUP_LABEL_GUTTER,
-      ),
-    );
-    const x = minChildX;
-    const y = minChildY;
-    const nextGeometry = {
-      x,
-      y,
-      w: Math.max(COLLAPSED_GROUP_WIDTH, maxChildX - x),
-      h: Math.max(COLLAPSED_GROUP_HEIGHT, maxChildY - y),
-    };
-
-    geometryById.set(node.id, nextGeometry);
-    return nextGeometry;
-  };
-
-  nodes.forEach(resolveGeometry);
-  packSiblingGeometries(rootNodeIds, geometryById, shiftGeometryTree);
-
-  return nodes.map((node) => {
-    const geometry =
-      geometryById.get(node.id) || lineageNodeAbsoluteGeometry(node);
-    const parentGeometry = node.parentId
-      ? geometryById.get(node.parentId)
-      : null;
-    const position = parentGeometry
-      ? { x: geometry.x - parentGeometry.x, y: geometry.y - parentGeometry.y }
-      : { x: geometry.x, y: geometry.y };
-
-    return {
-      ...node,
-      width: geometry.w,
-      height: geometry.h,
-      position,
-      data: {
-        ...node.data,
-        absoluteGeometry: geometry,
-      },
-      style: {
-        ...node.style,
-        width: geometry.w,
-        height: geometry.h,
-      },
-    };
-  });
-};
-
-export const lineageDefaultCollapsedGroupIds = (nodes = []) => {
-  return lineageDepthCollapsibleGroups(nodes).map((node) => node.id);
-};
-
-export const LINEAGE_DEFAULT_EXPAND_MAX_GROUPS = 5;
-export const LINEAGE_DEFAULT_EXPAND_MAX_LEAF_NODES = 20;
-
-/*
- * A small graph (at most MAX_GROUPS collapsible boxes and at most
- * MAX_LEAF_NODES leaf nodes per box) should load fully expanded, so the
- * user sees every box open instead of collapsed by default.
- */
-export const lineageShouldLoadExpanded = (nodes = []) => {
-  const descendantCounts = lineageDescendantCounts(nodes);
-  const collapsibleGroups = nodes.filter(
-    (node) =>
-      node.type === "lineageGroup" &&
-      node.data?.variant === "absolute" &&
-      !isRootLineageGroupNode(node) &&
-      (descendantCounts.get(node.id) || 0) > 0,
-  );
-
-  if (collapsibleGroups.length > LINEAGE_DEFAULT_EXPAND_MAX_GROUPS) {
-    return false;
-  }
-
-  const parentById = lineageNodeParentMap(nodes);
-  const parentIds = new Set(Array.from(parentById.values()));
-  const isLeaf = (nodeId) => !parentIds.has(nodeId);
-  const leafDescendantCount = (groupId) =>
-    nodes.reduce((count, node) => {
-      let parentId = parentById.get(node.id);
-
-      while (parentId) {
-        if (parentId === groupId) {
-          return isLeaf(node.id) ? count + 1 : count;
-        }
-        parentId = parentById.get(parentId);
-      }
-
-      return count;
-    }, 0);
-
-  return collapsibleGroups.every(
-    (group) =>
-      leafDescendantCount(group.id) <= LINEAGE_DEFAULT_EXPAND_MAX_LEAF_NODES,
-  );
-};
-
-export const lineageOversizedGroupIds = (nodes = []) => {
-  const directChildCounts = lineageDirectChildCounts(nodes);
-
-  return new Set(
-    nodes
-      .filter(
-        (node) =>
-          node.type === "lineageGroup" &&
-          node.data?.variant === "absolute" &&
-          !isRootLineageGroupNode(node) &&
-          (directChildCounts.get(node.id) || 0) > LINEAGE_OVERSIZED_CHILD_LIMIT,
-      )
-      .map((node) => node.id),
-  );
-};
-
-export const collapseLineageNodes = (
-  nodes = [],
-  collapsedIds,
-  onToggleCollapse,
-  onExpandDescendants,
-  oversizedIds = new Set(),
-  pendingExpand = null,
-  onConfirmOversizedExpand,
-  onDismissOversizedWarning,
-) => {
-  if (_.isEmpty(nodes)) return nodes;
-
-  const parentById = lineageNodeParentMap(nodes);
-  const graphIndex = createLineageGraphIndex(nodes);
-  const descendantCounts = lineageDescendantCounts(nodes);
-  const directChildCounts = lineageDirectChildCounts(nodes);
-  const collapsibleIds = new Set(lineageDefaultCollapsedGroupIds(nodes));
-  const effectiveCollapsedIds = new Set(
-    Array.from(collapsedIds).filter((id) => collapsibleIds.has(id)),
-  );
-
-  const visibleNodes = nodes
-    .filter(
-      (node) =>
-        !hiddenByCollapsedAncestor(node, parentById, effectiveCollapsedIds),
-    )
-    .map((node) => {
-      const hiddenChildrenCount = descendantCounts.get(node.id) || 0;
-      const canCollapse =
-        node.type === "lineageGroup" &&
-        node.data?.variant === "absolute" &&
-        !isRootLineageGroupNode(node) &&
-        hiddenChildrenCount > 0;
-
-      if (!canCollapse) {
-        if (
-          node.type !== "lineageGroup" ||
-          node.data?.variant !== "absolute" ||
-          isRootLineageGroupNode(node) ||
-          hiddenChildrenCount > 0 ||
-          node.data?.collapsed
-        )
-          return node;
-
-        const height = 44;
-        return {
-          ...node,
-          height,
-          style: { ...node.style, height },
-          data: {
-            ...node.data,
-            absoluteGeometry: node.data?.absoluteGeometry
-              ? { ...node.data.absoluteGeometry, h: height }
-              : node.data?.absoluteGeometry,
-          },
-        };
-      }
-
-      const collapsed = effectiveCollapsedIds.has(node.id);
-      const hasCollapsedDescendantGroups = Array.from(
-        graphIndex.descendantIds(node.id),
-      ).some((id) => effectiveCollapsedIds.has(id));
-      const width = collapsed ? COLLAPSED_GROUP_WIDTH : node.width;
-      const height = collapsed ? COLLAPSED_GROUP_HEIGHT : node.height;
-
-      return {
-        ...node,
-        width,
-        height,
-        data: {
-          ...node.data,
-          absoluteGeometry: node.data?.absoluteGeometry
-            ? {
-                ...node.data.absoluteGeometry,
-                w: width,
-                h: height,
-              }
-            : node.data?.absoluteGeometry,
-          canCollapse,
-          collapsed,
-          hiddenChildrenCount,
-          hasCollapsedDescendantGroups,
-          oversized: oversizedIds.has(node.id),
-          oversizedChildCount: directChildCounts.get(node.id) || 0,
-          oversizedWarningOpen: pendingExpand?.groupId === node.id,
-          onConfirmOversizedExpand:
-            pendingExpand?.groupId === node.id && onConfirmOversizedExpand
-              ? () => onConfirmOversizedExpand(node.id, pendingExpand.action)
-              : undefined,
-          onDismissOversizedWarning:
-            pendingExpand?.groupId === node.id && onDismissOversizedWarning
-              ? () => onDismissOversizedWarning()
-              : undefined,
-          onToggleCollapse: () => onToggleCollapse(node.id),
-          onExpandDescendants:
-            onExpandDescendants && hasCollapsedDescendantGroups
-              ? () => onExpandDescendants(node.id)
-              : undefined,
-        },
-        style: {
-          ...node.style,
-          width,
-          height,
-        },
-      };
-    });
-
-  return resizeVisibleLineageGroups(visibleNodes);
-};
-
-export const aggregateCollapsedEdges = (
-  edges = [],
-  nodes = [],
-  visibleNodes = [],
-) => {
-  if (_.isEmpty(edges)) return edges;
-
-  const parentById = lineageNodeParentMap(nodes);
-  const visibleNodeIds = new Set(visibleNodes.map((node) => node.id));
-  const hasHiddenEndpoint = edges.some(
-    (edge) =>
-      !visibleNodeIds.has(edge.source) || !visibleNodeIds.has(edge.target),
-  );
-
-  if (!hasHiddenEndpoint) {
-    return edges.filter(
-      (edge) =>
-        visibleNodeIds.has(edge.source) &&
-        visibleNodeIds.has(edge.target) &&
-        edge.source !== edge.target,
-    );
-  }
-
-  const aggregateByKey = new Map();
-  const visibleEdges = [];
-
-  edges.forEach((edge) => {
-    const sourceVisible = visibleNodeIds.has(edge.source);
-    const targetVisible = visibleNodeIds.has(edge.target);
-
-    if (sourceVisible && targetVisible) {
-      if (edge.source !== edge.target) visibleEdges.push(edge);
-      return;
-    }
-
-    const source = visibleEndpointId(edge.source, parentById, visibleNodeIds);
-    const target = visibleEndpointId(edge.target, parentById, visibleNodeIds);
-
-    if (!source || !target || source === target) return;
-
-    const primaryType = edge.data?.primaryType || "";
-    const key = `${source}::${target}::${primaryType}`;
-    const current = aggregateByKey.get(key);
-
-    if (!current) {
-      aggregateByKey.set(key, {
-        count: 1,
-        edge: {
-          ...edge,
-          source,
-          sourceHandle: "end-node",
-          target,
-          targetHandle: "start-node",
-          data: {
-            ...edge.data,
-            originalEdgeIds: edge.data?.originalEdgeIds || [edge.id],
-            sourceFieldIndex: undefined,
-            targetFieldIndex: undefined,
-          },
-        },
-      });
-      return;
-    }
-
-    aggregateByKey.set(key, {
-      count: current.count + 1,
-      edge: {
-        ...current.edge,
-        id: `lineage-aggregated-${key}`,
-        data: {
-          ...current.edge.data,
-          metadata: current.edge.data?.metadata || edge.data?.metadata,
-          onClick: current.edge.data?.onClick || edge.data?.onClick,
-          originalEdgeIds: [
-            ...(current.edge.data?.originalEdgeIds || [current.edge.id]),
-            ...(edge.data?.originalEdgeIds || [edge.id]),
-          ],
-        },
-        style: {
-          ...current.edge.style,
-          strokeWidth: Math.min(
-            Math.max(
-              current.edge.style?.strokeWidth || 1.8,
-              edge.style?.strokeWidth || 1.8,
-            ) + 0.15,
-            3.2,
-          ),
-        },
-      },
-    });
-  });
-
-  const collapsedEdges = Array.from(aggregateByKey.values()).map(
-    ({ count, edge }) => ({
-      ...edge,
-      data: {
-        ...edge.data,
-        aggregatedCount: count > 1 ? count : undefined,
-        label: count > 1 ? `${count}` : edge.data?.label,
-      },
-    }),
-  );
-
-  return [...visibleEdges, ...collapsedEdges];
-};
-
-const singleVisibleDescendantEndpoint = (
-  nodeId,
-  nodeById,
-  childIdsByParentId,
-) => {
-  const node = nodeById.get(nodeId);
-
-  if (
-    !node ||
-    node.type !== "lineageGroup" ||
-    node.data?.variant !== "absolute" ||
-    node.data?.collapsed
-  ) {
-    return nodeId;
-  }
-
-  const childIds = childIdsByParentId.get(nodeId) || [];
-
-  if (childIds.length !== 1) return nodeId;
-
-  return singleVisibleDescendantEndpoint(
-    childIds[0],
-    nodeById,
-    childIdsByParentId,
-  );
-};
-
-const visibleDescendantIds = (nodeId, childIdsByParentId) => {
-  const childIds = childIdsByParentId.get(nodeId) || [];
-
-  return childIds.flatMap((childId) => [
-    childId,
-    ...visibleDescendantIds(childId, childIdsByParentId),
-  ]);
-};
-
-const endpointFieldNameForEdge = (edge, endpoint) =>
-  normalizeFieldText(
-    endpoint === "source"
-      ? edge.data?.sourceFieldName
-      : edge.data?.targetFieldName,
-  );
-
-const nodeVisibleLabel = (node) =>
-  normalizeFieldText(
-    firstText(
-      node?.data?.label,
-      node?.data?.lineageNode?.name,
-      node?.data?.canonicalId,
-      node?.id,
-    ),
-  );
-
-const sortVisibleChildEndpointIds = (nodeById) => (idA, idB) => {
-  const geometryA = lineageNodeAbsoluteGeometry(nodeById.get(idA));
-  const geometryB = lineageNodeAbsoluteGeometry(nodeById.get(idB));
-  const yDiff = geometryA.y - geometryB.y;
-  const xDiff = geometryA.x - geometryB.x;
-
-  if (yDiff !== 0) return yDiff;
-  if (xDiff !== 0) return xDiff;
-
-  return idA.localeCompare(idB);
-};
-
-const visibleChildEndpointsByField = (nodeId, nodeById, childIdsByParentId) => {
-  const descendants = visibleDescendantIds(nodeId, childIdsByParentId)
-    .filter((id) => {
-      const node = nodeById.get(id);
-
-      return node && node.type !== "lineageGroup";
-    })
-    .sort(sortVisibleChildEndpointIds(nodeById));
-
-  return descendants.reduce((byField, id) => {
-    const label = nodeVisibleLabel(nodeById.get(id));
-
-    if (_.isEmpty(label)) return byField;
-
-    const ids = byField.get(label) || [];
-
-    ids.push(id);
-    byField.set(label, ids);
-
-    return byField;
-  }, new Map());
-};
-
-const visibleChildEndpointIds = (nodeId, nodeById, childIdsByParentId) =>
-  visibleDescendantIds(nodeId, childIdsByParentId)
-    .filter((id) => {
-      const node = nodeById.get(id);
-
-      return (
-        node && (node.type !== "lineageGroup" || Boolean(node.data?.collapsed))
-      );
-    })
-    .sort(sortVisibleChildEndpointIds(nodeById));
-
-const endpointLegacyYForEdge = (edge, endpoint) =>
-  endpoint === "source" ? edge.data?.legacySourceY : edge.data?.legacyTargetY;
-
-const endpointFieldIndexForEdge = (edge, endpoint) =>
-  endpoint === "source"
-    ? edge.data?.sourceFieldIndex
-    : edge.data?.targetFieldIndex;
-
-const visibleEndpointClosestToY = (ids = [], nodeById, y) => {
-  if (y === undefined || _.isEmpty(ids)) return undefined;
-
-  return [...ids].sort((idA, idB) => {
-    const geometryA = lineageNodeAbsoluteGeometry(nodeById.get(idA));
-    const geometryB = lineageNodeAbsoluteGeometry(nodeById.get(idB));
-    const distanceA = Math.abs(geometryA.y + geometryA.h / 2 - y);
-    const distanceB = Math.abs(geometryB.y + geometryB.h / 2 - y);
-
-    if (distanceA !== distanceB) return distanceA - distanceB;
-
-    return sortVisibleChildEndpointIds(nodeById)(idA, idB);
-  })[0];
-};
-
-const distributedVisibleEndpoint = ({ ids = [], routeIndexes, routeKey }) => {
-  if (_.isEmpty(ids)) return undefined;
-
-  const routeIndex = routeIndexes.get(routeKey) || 0;
-
-  routeIndexes.set(routeKey, routeIndex + 1);
-
-  return ids[routeIndex % ids.length];
-};
-
-const visibleEndpointForOpenGroup = ({
-  edge,
-  endpoint,
-  nodeById,
-  childIdsByParentId,
-  routeIndexes,
-}) => {
-  const nodeId = endpoint === "source" ? edge.source : edge.target;
-  const node = nodeById.get(nodeId);
-
-  if (
-    !node ||
-    node.type !== "lineageGroup" ||
-    node.data?.variant !== "absolute" ||
-    node.data?.collapsed
-  ) {
-    return nodeId;
-  }
-
-  const fieldName = endpointFieldNameForEdge(edge, endpoint);
-  const endpointsByField = visibleChildEndpointsByField(
-    nodeId,
-    nodeById,
-    childIdsByParentId,
-  );
-  const fieldEndpoints = endpointsByField.get(fieldName) || [];
-
-  if (!_.isEmpty(fieldName) && fieldEndpoints.length) {
-    const routeKey = `${endpoint}:${nodeId}:${fieldName}`;
-
-    return distributedVisibleEndpoint({
-      ids: fieldEndpoints,
-      routeIndexes,
-      routeKey,
-    });
-  }
-
-  const childEndpointIds = visibleChildEndpointIds(
-    nodeId,
-    nodeById,
-    childIdsByParentId,
-  );
-  const endpointClosestToLegacyY = visibleEndpointClosestToY(
-    childEndpointIds,
-    nodeById,
-    endpointLegacyYForEdge(edge, endpoint),
-  );
-
-  if (endpointClosestToLegacyY) return endpointClosestToLegacyY;
-
-  const fieldIndex = endpointFieldIndexForEdge(edge, endpoint);
-
-  if (fieldIndex !== undefined && childEndpointIds[fieldIndex]) {
-    return childEndpointIds[fieldIndex];
-  }
-
-  const singleEndpoint = singleVisibleDescendantEndpoint(
-    nodeId,
-    nodeById,
-    childIdsByParentId,
-  );
-
-  if (singleEndpoint !== nodeId) return singleEndpoint;
-
-  return (
-    distributedVisibleEndpoint({
-      ids: childEndpointIds,
-      routeIndexes,
-      routeKey: `${endpoint}:${nodeId}:visible-descendants`,
-    }) || nodeId
-  );
-};
-
-export const routeOpenGroupEdgesToSingleVisibleChild = (
-  edges = [],
-  visibleNodes = [],
-) => {
-  if (_.isEmpty(edges) || _.isEmpty(visibleNodes)) return edges;
-
-  const nodeById = new Map(visibleNodes.map((node) => [node.id, node]));
-  const childIdsByParentId = visibleNodes.reduce((children, node) => {
-    if (!node.parentId || !nodeById.has(node.parentId)) return children;
-
-    const childIds = children.get(node.parentId) || [];
-
-    childIds.push(node.id);
-    children.set(node.parentId, childIds);
-
-    return children;
-  }, new Map());
-  const routeIndexes = new Map();
-
-  return edges.map((edge) => {
-    if (edge.data?.containment || edge.data?.aggregatedCount !== undefined) {
-      return edge;
-    }
-
-    const source = visibleEndpointForOpenGroup({
-      edge,
-      endpoint: "source",
-      nodeById,
-      childIdsByParentId,
-      routeIndexes,
-    });
-    const target = visibleEndpointForOpenGroup({
-      edge,
-      endpoint: "target",
-      nodeById,
-      childIdsByParentId,
-      routeIndexes,
-    });
-
-    if (source === edge.source && target === edge.target) return edge;
-
-    return {
-      ...edge,
-      source,
-      sourceHandle: source === edge.source ? edge.sourceHandle : "end-node",
-      target,
-      targetHandle: target === edge.target ? edge.targetHandle : "start-node",
-      data: {
-        ...edge.data,
-        sourceFieldIndex:
-          source === edge.source ? edge.data?.sourceFieldIndex : undefined,
-        targetFieldIndex:
-          target === edge.target ? edge.data?.targetFieldIndex : undefined,
-      },
-    };
-  });
-};
-
-const mergeRenderedNode = (baseNode, renderedNode) => ({
-  ...baseNode,
-  ...renderedNode,
-  width: renderedNode.width || baseNode?.width,
-  height: renderedNode.height || baseNode?.height,
-  data: {
-    ...baseNode?.data,
-    ...renderedNode.data,
-  },
-});
-
-export const lineagePositionedLayoutNodes = ({
-  groups = [],
-  resources = [],
-  selectedNodeId,
-  duplicateNodeIds = positionedDuplicateNodeIds(groups, resources),
-  nodeDesign = "redesigned",
-  expandedFieldNodeIds = new Set(),
-  onToggleFields,
-  nodeWidth,
-  preparedHierarchy = preparePositionedLineageHierarchy(groups, resources),
-}) => {
-  const { containerGroups, leafGroups, parentByNode } = preparedHierarchy;
-  const leafGroupIds = new Set(leafGroups.map(nodeId));
-  const positionedResourceGeometry = (node) =>
-    positionedNodeGeometryForDesign(
-      node,
-      nodeDesign,
-      leafGroupIds.has(nodeId(node)) ? "group" : "resource",
-      nodeWidth,
-    );
-  const geometryById = buildPositionedGeometryMap(
-    containerGroups,
-    [...resources, ...leafGroups],
-    duplicateNodeIds,
-    positionedResourceGeometry,
-    parentByNode,
-  );
-  const resolveSystemType = (node) =>
-    lineageSystemTypeWithParentFallback(parentByNode, node);
-
-  return presentTerminalResourcesAsFieldRows(
-    removeRenderedRootContainer(
-      uniqueNodes([
-        ...sortPositionedGroups(containerGroups).map(
-          lineagePositionedGroupNode(
-            preparedHierarchy,
-            selectedNodeId,
-            duplicateNodeIds,
-            geometryById,
-            nodeDesign,
-            resolveSystemType,
-          ),
-        ),
-        ...leafGroups.map(
-          lineagePositionedResourceNode(
-            parentByNode,
-            selectedNodeId,
-            duplicateNodeIds,
-            geometryById,
-            nodeDesign,
-            "group",
-            resolveSystemType,
-            expandedFieldNodeIds,
-            onToggleFields,
-            nodeWidth,
-          ),
-        ),
-        ...resources.map(
-          lineagePositionedResourceNode(
-            parentByNode,
-            selectedNodeId,
-            duplicateNodeIds,
-            geometryById,
-            nodeDesign,
-            "resource",
-            resolveSystemType,
-            expandedFieldNodeIds,
-            onToggleFields,
-            nodeWidth,
-          ),
-        ),
-      ]),
-    ),
-  );
-};
-
-const edgeFieldName = (edge = {}, endpoint) => {
-  const metadata = edge.metadata || {};
-
-  if (endpoint === "source") {
-    return normalizeFieldText(
-      firstText(
-        edge.source_field,
-        edge.sourceField,
-        edge.source_field_name,
-        edge.sourceFieldName,
-        edge.start_field,
-        edge.startField,
-        edge.start_field_name,
-        edge.startFieldName,
-        edge.from_field,
-        edge.fromField,
-        edge.inicio_campo,
-        edge.inicioCampo,
-        edge.source?.field,
-        edge.source?.column,
-        edge.source?.field_name,
-        metadata.source_field,
-        metadata.sourceField,
-        metadata.source_field_name,
-        metadata.sourceFieldName,
-        metadata.start_field,
-        metadata.startField,
-        metadata.from_field,
-        metadata.fromField,
-      ),
-    );
-  }
-
-  return normalizeFieldText(
-    firstText(
-      edge.target_field,
-      edge.targetField,
-      edge.target_field_name,
-      edge.targetFieldName,
-      edge.end_field,
-      edge.endField,
-      edge.end_field_name,
-      edge.endFieldName,
-      edge.to_field,
-      edge.toField,
-      edge.fin_campo,
-      edge.finCampo,
-      edge.target?.field,
-      edge.target?.column,
-      edge.target?.field_name,
-      metadata.target_field,
-      metadata.targetField,
-      metadata.target_field_name,
-      metadata.targetFieldName,
-      metadata.end_field,
-      metadata.endField,
-      metadata.to_field,
-      metadata.toField,
-    ),
-  );
-};
-
-const fieldIndexFromName = (fields = [], name) => {
-  if (_.isEmpty(name)) return undefined;
-
-  const index = fields.findIndex((field) => lineageFieldName(field) === name);
-
-  return index === -1 ? undefined : index;
-};
-
-const fieldIndexForEdge = ({ edge, node, endpoint }) => {
-  const fields = node?.data?.fields || [];
-  const allFields = node?.data?.allFields || fields;
-  const fieldHandleLimit = Math.min(
-    node?.data?.fieldHandleLimit ?? fields.length,
-    fields.length,
-  );
-
-  if (_.isEmpty(fields) || fieldHandleLimit === 0) return undefined;
-
-  const dataIndex =
-    endpoint === "source"
-      ? edge.data?.sourceFieldIndex
-      : edge.data?.targetFieldIndex;
-
-  if (dataIndex !== undefined) {
-    return dataIndex < fieldHandleLimit ? dataIndex : undefined;
-  }
-
-  const fieldName =
-    endpoint === "source"
-      ? edge.data?.sourceFieldName
-      : edge.data?.targetFieldName;
-  const explicitIndex = fieldIndexFromName(allFields, fieldName);
-
-  if (explicitIndex !== undefined) {
-    return explicitIndex < fieldHandleLimit ? explicitIndex : undefined;
-  }
-
-  return undefined;
-};
-
-export const applyFieldHandlesToEdges = (edges = [], nodeById) => {
-  return edges.map((edge) => {
-    const sourceNode = nodeById.get(edge.source);
-    const targetNode = nodeById.get(edge.target);
-    const sourceGeometry = sourceNode?.data?.absoluteGeometry;
-    const targetGeometry = targetNode?.data?.absoluteGeometry;
-    const sourceFieldIndex = fieldIndexForEdge({
-      edge,
-      endpoint: "source",
-      node: sourceNode,
-    });
-    const targetFieldIndex = fieldIndexForEdge({
-      edge,
-      endpoint: "target",
-      node: targetNode,
-    });
-    const sourceUsesFieldHandle =
-      sourceFieldIndex !== undefined &&
-      sourceNode?.data?.variant === "lineage-redesigned";
-    const targetUsesFieldHandle =
-      targetFieldIndex !== undefined &&
-      targetNode?.data?.variant === "lineage-redesigned";
-    const sourcePortPosition = "right";
-    const targetPortPosition = "left";
-
-    return {
-      ...edge,
-      sourceHandle: edge.data?.containment
-        ? edge.sourceHandle
-        : sourceUsesFieldHandle
-          ? fieldHandleId("source", sourceFieldIndex)
-          : "end-node",
-      targetHandle: targetUsesFieldHandle
-        ? fieldHandleId("target", targetFieldIndex)
-        : "start-node",
-      data: {
-        ...edge.data,
-        forceHorizontalPorts: !edge.data?.containment,
-        lockSourcePort: !edge.data?.containment && !sourceUsesFieldHandle,
-        sourceNodeX: sourceGeometry?.x,
-        sourceNodeY: sourceGeometry?.y,
-        sourceNodeWidth: sourceNode?.width,
-        sourceNodeHeight: sourceNode?.height,
-        sourcePortY: edge.data?.legacySourceY,
-        sourceFieldIndex,
-        sourcePortPosition,
-        targetNodeX: targetGeometry?.x,
-        targetNodeY: targetGeometry?.y,
-        targetNodeWidth: targetNode?.width,
-        targetNodeHeight: targetNode?.height,
-        targetPortY: edge.data?.legacyTargetY,
-        targetFieldIndex,
-        targetPortPosition,
-      },
-    };
-  });
-};
-
-export const bundleLineageEdges = (edges = []) => {
-  const sourceCounts = new Map();
-  const targetCounts = new Map();
-  const endpointKey = (nodeId, handleId) => `${nodeId}::${handleId || ""}`;
-
-  edges.forEach((edge) => {
-    if (edge.data?.containment) return;
-
-    const sourceKey = endpointKey(edge.source, edge.sourceHandle);
-    const targetKey = endpointKey(edge.target, edge.targetHandle);
-
-    sourceCounts.set(sourceKey, (sourceCounts.get(sourceKey) || 0) + 1);
-    targetCounts.set(targetKey, (targetCounts.get(targetKey) || 0) + 1);
-  });
-
-  return edges.map((edge) => {
-    if (edge.data?.containment) return edge;
-
-    const sourceCount =
-      sourceCounts.get(endpointKey(edge.source, edge.sourceHandle)) || 0;
-    const targetCount =
-      targetCounts.get(endpointKey(edge.target, edge.targetHandle)) || 0;
-
-    return {
-      ...edge,
-      data: {
-        ...edge.data,
-        bundleOffset: 40,
-        bundleSource: sourceCount > 1,
-        bundleTarget: targetCount > 1,
-      },
-    };
-  });
-};
-
-export const redesignedLineageEdges = (edges = []) =>
-  bundleLineageEdges(
-    edges.map((edge) => ({
-      ...edge,
-      style: _.omit(["stroke", "strokeOpacity", "strokeWidth"])(edge.style),
-      data: {
-        ...edge.data,
-        edgeCurvature: 0.32,
-        edgePath: "bezier",
-        routeGuide: edge.data?.topology ? edge.data.routeGuide : undefined,
-      },
-    })),
-  );
-
-const inflatedRouteObstacle = (node) => {
-  const geometry = lineageNodeAbsoluteGeometry(node);
-  const openGroup =
-    node.type === "lineageGroup" &&
-    node.data?.variant === "absolute" &&
-    !node.data?.collapsed;
-  const height = openGroup
-    ? Math.min(geometry.h, LINEAGE_COLUMN_HEADER_HEIGHT)
-    : geometry.h;
-
-  return {
-    id: node.id,
-    x: geometry.x - LINEAGE_ROUTE_OBSTACLE_PADDING,
-    y: geometry.y - LINEAGE_ROUTE_OBSTACLE_PADDING,
-    w: geometry.w + LINEAGE_ROUTE_OBSTACLE_PADDING * 2,
-    h: height + LINEAGE_ROUTE_OBSTACLE_PADDING * 2,
-  };
-};
-
-const segmentIntersectsRouteObstacle = (start, end, obstacle) => {
-  const minX = Math.min(start.x, end.x);
-  const maxX = Math.max(start.x, end.x);
-  const minY = Math.min(start.y, end.y);
-  const maxY = Math.max(start.y, end.y);
-
-  if (start.y === end.y) {
-    return (
-      start.y > obstacle.y &&
-      start.y < obstacle.y + obstacle.h &&
-      maxX > obstacle.x &&
-      minX < obstacle.x + obstacle.w
-    );
-  }
-
-  if (start.x === end.x) {
-    return (
-      start.x > obstacle.x &&
-      start.x < obstacle.x + obstacle.w &&
-      maxY > obstacle.y &&
-      minY < obstacle.y + obstacle.h
-    );
-  }
-
-  return true;
-};
-
-const routePointsAreClear = (points, obstacles) =>
-  points
-    .slice(1)
-    .every((point, index) =>
-      obstacles.every(
-        (obstacle) =>
-          !segmentIntersectsRouteObstacle(points[index], point, obstacle),
-      ),
-    );
-
-const alternatingLaneOffset = (index) => {
-  if (!index) return 0;
-
-  const direction = index % 2 === 1 ? 1 : -1;
-
-  return Math.ceil(index / 2) * LINEAGE_ROUTE_LANE_GAP * direction;
-};
-
-const routePortGeometry = (node, position) => {
-  const geometry = lineageNodeAbsoluteGeometry(node);
-
-  return {
-    x: position === "right" ? geometry.x + geometry.w : geometry.x,
-    y: geometry.y + geometry.h / 2,
-  };
-};
-
-const verticalStackGuideForEdge = ({
-  sourceGeometry,
-  targetGeometry,
-  sourcePort,
-  targetPort,
-  obstacles,
-}) => {
-  const overlapsHorizontally =
-    sourceGeometry.x < targetGeometry.x + targetGeometry.w &&
-    sourceGeometry.x + sourceGeometry.w > targetGeometry.x;
-  const sourceAboveTarget =
-    sourceGeometry.y + sourceGeometry.h <= targetGeometry.y;
-  const targetAboveSource =
-    targetGeometry.y + targetGeometry.h <= sourceGeometry.y;
-
-  if (!overlapsHorizontally || (!sourceAboveTarget && !targetAboveSource)) {
-    return undefined;
-  }
-
-  const verticalGapStart = sourceAboveTarget
-    ? sourceGeometry.y + sourceGeometry.h
-    : targetGeometry.y + targetGeometry.h;
-  const verticalGapEnd = sourceAboveTarget
-    ? targetGeometry.y
-    : sourceGeometry.y;
-  const laneY = (verticalGapStart + verticalGapEnd) / 2;
-  const edgeOffset = Math.max(8, POSITIONED_GROUP_PADDING_X - 4);
-  const sourceLaneX = sourcePort.x + edgeOffset;
-  const targetLaneX = targetPort.x - edgeOffset;
-  const points = [
-    sourcePort,
-    { x: sourceLaneX, y: sourcePort.y },
-    { x: sourceLaneX, y: laneY },
-    { x: targetLaneX, y: laneY },
-    { x: targetLaneX, y: targetPort.y },
-    targetPort,
-  ];
-
-  if (!routePointsAreClear(points, obstacles)) return undefined;
-
-  return {
-    kind: "bypass",
-    edgeOffset,
-    laneY,
-    sourceLaneX,
-    targetLaneX,
-    labelPoint: {
-      x: (sourceLaneX + targetLaneX) / 2,
-      y: laneY,
-    },
-  };
-};
-
-const corridorGuideForEdge = ({
-  sourcePort,
-  targetPort,
-  obstacles,
-  laneIndex,
-}) => {
-  const minLaneX =
-    Math.min(sourcePort.x, targetPort.x) + LINEAGE_ROUTE_CLEARANCE;
-  const maxLaneX =
-    Math.max(sourcePort.x, targetPort.x) - LINEAGE_ROUTE_CLEARANCE;
-
-  if (maxLaneX <= minLaneX) return undefined;
-
-  const centerX = (minLaneX + maxLaneX) / 2;
-  const preferredOffset = alternatingLaneOffset(laneIndex);
-  const candidateLaneXs = new Set([centerX + preferredOffset, centerX]);
-
-  obstacles.forEach((obstacle) => {
-    candidateLaneXs.add(obstacle.x - LINEAGE_ROUTE_CLEARANCE + preferredOffset);
-    candidateLaneXs.add(
-      obstacle.x + obstacle.w + LINEAGE_ROUTE_CLEARANCE + preferredOffset,
-    );
-  });
-
-  return Array.from(candidateLaneXs)
-    .filter((laneX) => laneX >= minLaneX && laneX <= maxLaneX)
-    .sort(
-      (laneXA, laneXB) =>
-        Math.abs(laneXA - (centerX + preferredOffset)) -
-        Math.abs(laneXB - (centerX + preferredOffset)),
-    )
-    .find((laneX) =>
-      routePointsAreClear(
-        [
-          sourcePort,
-          { x: laneX, y: sourcePort.y },
-          { x: laneX, y: targetPort.y },
-          targetPort,
-        ],
-        obstacles,
-      ),
-    );
-};
-
-const bypassGuideForEdge = ({
-  sourcePort,
-  targetPort,
-  obstacles,
-  laneIndex,
-}) => {
-  const routeMinX = Math.min(sourcePort.x, targetPort.x);
-  const routeMaxX = Math.max(sourcePort.x, targetPort.x);
-  const relevantObstacles = obstacles.filter(
-    (obstacle) => obstacle.x < routeMaxX && obstacle.x + obstacle.w > routeMinX,
-  );
-  const obstaclePool = relevantObstacles.length ? relevantObstacles : obstacles;
-  const top =
-    Math.min(sourcePort.y, targetPort.y, ...obstaclePool.map(({ y }) => y)) -
-    LINEAGE_ROUTE_CLEARANCE;
-  const bottom =
-    Math.max(
-      sourcePort.y,
-      targetPort.y,
-      ...obstaclePool.map(({ y, h }) => y + h),
-    ) + LINEAGE_ROUTE_CLEARANCE;
-  const laneOffset = Math.abs(alternatingLaneOffset(laneIndex));
-  const laneYs = [top - laneOffset, bottom + laneOffset].sort(
-    (laneYA, laneYB) =>
-      Math.abs(sourcePort.y - laneYA) +
-      Math.abs(targetPort.y - laneYA) -
-      (Math.abs(sourcePort.y - laneYB) + Math.abs(targetPort.y - laneYB)),
-  );
-
-  for (
-    let attempt = 0;
-    attempt < LINEAGE_ROUTE_MAX_LANE_ATTEMPTS;
-    attempt += 1
-  ) {
-    const horizontalOffset = attempt * LINEAGE_ROUTE_LANE_GAP;
-    const sourceLaneX =
-      sourcePort.x + LINEAGE_ROUTE_CLEARANCE + horizontalOffset;
-    const targetLaneX =
-      targetPort.x - LINEAGE_ROUTE_CLEARANCE - horizontalOffset;
-
-    for (const laneY of laneYs) {
-      const points = [
-        sourcePort,
-        { x: sourceLaneX, y: sourcePort.y },
-        { x: sourceLaneX, y: laneY },
-        { x: targetLaneX, y: laneY },
-        { x: targetLaneX, y: targetPort.y },
-        targetPort,
-      ];
-
-      if (routePointsAreClear(points, obstacles)) {
-        return { laneY, sourceLaneX, targetLaneX };
-      }
-    }
-  }
-
-  return undefined;
-};
-
-export const planLineageEdgeRoutes = (edges = [], nodes = []) => {
-  if (_.isEmpty(edges) || _.isEmpty(nodes)) return edges;
-
-  const nodeById = new Map(nodes.map((node) => [node.id, node]));
-  const parentById = lineageNodeParentMap(nodes);
-  const obstacles = nodes.map(inflatedRouteObstacle);
-  const bundleLaneIndexes = new Map();
-  const routeGuides = new Array(edges.length);
-  const routePortPositions = new Array(edges.length);
-  const orderedEdges = edges
-    .map((edge, index) => ({ edge, index }))
-    .sort(({ edge: edgeA }, { edge: edgeB }) => {
-      const sourceA = nodeById.get(edgeA.source);
-      const sourceB = nodeById.get(edgeB.source);
-      const targetA = nodeById.get(edgeA.target);
-      const targetB = nodeById.get(edgeB.target);
-      const sourceYDiff =
-        (lineageNodeAbsoluteGeometry(sourceA).y || 0) -
-        (lineageNodeAbsoluteGeometry(sourceB).y || 0);
-      const targetYDiff =
-        (lineageNodeAbsoluteGeometry(targetA).y || 0) -
-        (lineageNodeAbsoluteGeometry(targetB).y || 0);
-
-      return (
-        sourceYDiff || targetYDiff || `${edgeA.id}`.localeCompare(`${edgeB.id}`)
-      );
-    });
-
-  orderedEdges.forEach(({ edge, index }) => {
-    if (edge.data?.containment) return;
-
-    const sourceNode = nodeById.get(edge.source);
-    const targetNode = nodeById.get(edge.target);
-
-    if (!sourceNode || !targetNode) return;
-
-    const sourceGeometry = lineageNodeAbsoluteGeometry(sourceNode);
-    const targetGeometry = lineageNodeAbsoluteGeometry(targetNode);
-    const targetToRight =
-      targetGeometry.x + targetGeometry.w / 2 >=
-      sourceGeometry.x + sourceGeometry.w / 2;
-    const sourcePortPosition = "right";
-    const targetPortPosition = "left";
-    const sourcePort = routePortGeometry(sourceNode, sourcePortPosition);
-    const targetPort = routePortGeometry(targetNode, targetPortPosition);
-    const forward = targetToRight;
-    routePortPositions[index] = {
-      sourcePortPosition,
-      targetPortPosition,
-    };
-    const bundleKey = [
-      parentById.get(edge.source) || edge.source,
-      parentById.get(edge.target) || edge.target,
-      forward ? "forward" : "reverse",
-    ].join("::");
-    const laneIndex = bundleLaneIndexes.get(bundleKey) || 0;
-    const edgeObstacles = obstacles.filter(
-      ({ id }) => id !== edge.source && id !== edge.target,
-    );
-    const sameParent =
-      parentById.get(edge.source) !== undefined &&
-      parentById.get(edge.source) === parentById.get(edge.target);
-    const verticalStackGuide = sameParent
-      ? verticalStackGuideForEdge({
-          sourceGeometry,
-          targetGeometry,
-          sourcePort,
-          targetPort,
-          obstacles: edgeObstacles,
-        })
-      : undefined;
-    const corridorLaneX = !verticalStackGuide
-      ? corridorGuideForEdge({
-          sourcePort,
-          targetPort,
-          obstacles: edgeObstacles,
-          laneIndex,
-        })
-      : undefined;
-    const bypass =
-      verticalStackGuide || corridorLaneX
-        ? undefined
-        : bypassGuideForEdge({
-            sourcePort,
-            targetPort,
-            obstacles: edgeObstacles,
-            laneIndex,
-          });
-
-    bundleLaneIndexes.set(bundleKey, laneIndex + 1);
-
-    if (verticalStackGuide) {
-      routeGuides[index] = verticalStackGuide;
-    } else if (corridorLaneX !== undefined) {
-      routeGuides[index] = {
-        kind: "corridor",
-        laneX: corridorLaneX,
-        labelPoint: {
-          x: corridorLaneX,
-          y: (sourcePort.y + targetPort.y) / 2,
-        },
-      };
-    } else if (bypass) {
-      routeGuides[index] = {
-        kind: "bypass",
-        ...bypass,
-        labelPoint: {
-          x: (bypass.sourceLaneX + bypass.targetLaneX) / 2,
-          y: bypass.laneY,
-        },
-      };
-    }
-  });
-
-  return edges.map((edge, index) => ({
-    ...edge,
-    data: {
-      ...edge.data,
-      ...routePortPositions[index],
-      edgeOffset: routeGuides[index]?.edgeOffset ?? edge.data?.edgeOffset,
-      routeGuide: routeGuides[index] || edge.data?.routeGuide,
-    },
-  }));
-};
-
-export const focusedLineageGraph = (selectedNodeId, edges = []) => {
-  const focusedNodeIds = new Set();
-  const focusedEdgeIds = new Set();
-
-  if (!selectedNodeId) return { focusedEdgeIds, focusedNodeIds };
-
-  focusedNodeIds.add(selectedNodeId);
-
-  edges.forEach((edge) => {
-    if (edge.source !== selectedNodeId && edge.target !== selectedNodeId)
-      return;
-
-    focusedEdgeIds.add(edge.id);
-    focusedNodeIds.add(edge.source);
-    focusedNodeIds.add(edge.target);
-  });
-
-  return { focusedEdgeIds, focusedNodeIds };
-};
-
-export const focusLineageNodes = (
-  nodes = [],
-  focusedNodeIds,
-  focusActive,
-  selectedNodeId,
-) =>
-  focusActive
-    ? nodes.map((node) => {
-        const groupNode =
-          node.type === "lineageGroup" ||
-          node.data?.lineageNode?.lineageKind === "group";
-        const selected = node.id === selectedNodeId;
-        const direct = !selected && focusedNodeIds.has(node.id);
-        const dimmed = !selected && !focusedNodeIds.has(node.id);
-
-        return {
-          ...node,
-          className: [
-            node.className,
-            dimmed ? "lineage-node--muted" : "lineage-node--emphasized",
-          ]
-            .filter(Boolean)
-            .join(" "),
-          data: {
-            ...node.data,
-            focusDirect: direct,
-            focusDimmed: dimmed,
-            focusSelected: selected,
-            isActive: selected,
-          },
-          zIndex: groupNode
-            ? node.zIndex
-            : selected
-              ? LINEAGE_SELECTED_NODE_Z_INDEX
-              : direct
-                ? LINEAGE_DIRECT_NODE_Z_INDEX
-                : node.zIndex,
-          style: {
-            ...node.style,
-            opacity: 1,
-          },
-        };
-      })
-    : nodes;
-
-export const focusLineageEdges = (
-  edges = [],
-  focusedEdgeIds,
-  focusActive,
-  animateFocusedEdges = false,
-  selectedNodeId,
-  selectedEdgeId,
-) =>
-  focusActive
-    ? edges.map((edge) => {
-        const dimmed = !focusedEdgeIds.has(edge.id);
-
-        return {
-          ...edge,
-          zIndex:
-            (selectedNodeId || edge.id === selectedEdgeId) &&
-            !dimmed &&
-            !edge.data?.containment
-              ? LINEAGE_FOCUSED_EDGE_Z_INDEX
-              : edge.zIndex,
-          data: {
-            ...edge.data,
-            animated: Boolean(
-              animateFocusedEdges && !dimmed && !edge.data?.containment,
-            ),
-            selectedEndpoint:
-              selectedNodeId === edge.source
-                ? "source"
-                : selectedNodeId === edge.target
-                  ? "target"
-                  : undefined,
-            focusDimmed: dimmed,
-            focusFocused: !dimmed,
-          },
-          style: {
-            ...edge.style,
-            opacity: 1,
-          },
-        };
-      })
-    : edges;
-
-export const focusedLineageGraphForNodeSet = (nodeIds, edges = []) => {
-  const focusedNodeIds = nodeIds instanceof Set ? nodeIds : new Set();
-
-  if (focusedNodeIds.size === 0) {
-    return { focusedNodeIds: new Set(), focusedEdgeIds: new Set() };
-  }
-
-  const focusedEdgeIds = new Set();
-
-  edges.forEach((edge) => {
-    if (focusedNodeIds.has(edge.source) && focusedNodeIds.has(edge.target)) {
-      focusedEdgeIds.add(edge.id);
-    }
-  });
-
-  return { focusedNodeIds, focusedEdgeIds };
-};
-
-export const lineageNodeMatchesToolbarFilters = (
-  node,
-  normalizedSearchTerm,
-  systemTypeFilter,
-) => {
-  if (!node?.data?.label || !node.data.lineageNode) return false;
-
-  const lineageNodeData = node.data.lineageNode || {};
-  const searchableText = [
-    node.data.label,
-    lineageNodeData.name,
-    lineageNodeData.label,
-    lineageNodeData.id,
-    lineageNodeData.external_id,
-    lineageNodeData.structure_id,
-    ...(lineageNodeData.originals || []).flatMap((original) => [
-      original.id,
-      original.structure_id,
-    ]),
-  ]
-    .filter((value) => value !== undefined && value !== null)
-    .join(" ")
-    .toLowerCase();
-
-  const matchesSearch =
-    !normalizedSearchTerm ||
-    searchableText.includes(normalizedSearchTerm.toLowerCase());
-  const matchesSystem =
-    !systemTypeFilter || node.data.systemType === systemTypeFilter;
-
-  return matchesSearch && matchesSystem;
-};
-
-const lineageParentPath = (
-  node,
-  nodeById,
-  visitedIds = new Set([node?.id]),
-) => {
-  const parent = node?.parentId ? nodeById?.get(node.parentId) : null;
-
-  if (!parent || visitedIds.has(parent.id)) return [];
-
-  return [
-    ...lineageParentPath(parent, nodeById, new Set([...visitedIds, parent.id])),
-    firstText(parent.data?.label, parent.data?.name, parent.id),
-  ];
-};
-
-const selectedNodePath = (node, nodeById, lineageNode) => {
-  const ancestors = lineageParentPath(node, nodeById);
-
-  const system = firstText(node?.data?.system, lineageNode.system);
-  const schema = firstText(node?.data?.schema, lineageNode.schema);
-  const fallback = lineagePath(lineageNode, system, schema);
-  const path = ancestors.length >= fallback.length ? ancestors : fallback;
-  const name = firstText(
-    lineageNode.name,
-    lineageNode.label,
-    node?.data?.label,
-    node?.id,
-  );
-
-  return [...path.filter((part) => part !== name), name]
-    .filter(Boolean)
-    .filter((part, index, parts) => index === 0 || part !== parts[index - 1]);
-};
-
-export const selectedNodeFromGraphNode = (node, nodeById) => {
-  const lineageNode = node?.data?.lineageNode;
-
-  if (!lineageNode) {
-    return {
-      graphNodeId: node.id,
-      iconName: lineageNodeIcon(node.data),
-      name: firstText(node.data?.label, node.data?.name, node.id),
-      lineageKind: "group",
-      path: selectedNodePath(node, nodeById, {}),
-    };
-  }
-
-  const name = firstText(
-    lineageNode.name,
-    lineageNode.label,
-    node.data?.label,
-    node.id,
-  );
-
-  return {
-    ...lineageNode,
-    fieldsKnown: node.data?.fieldsKnown,
-    graphNodeId: node.id,
-    iconName: node.data?.iconName || lineageNodeIcon(node.data),
-    entityType: node.data?.entityType,
-    name,
-    path: selectedNodePath(node, nodeById, { ...lineageNode, name }),
-    quality: firstText(node.data.quality, lineageNode.quality),
-    schema: firstText(node.data.schema, lineageNode.schema),
-    status: firstText(node.data.status, lineageNode.status),
-    system: firstText(node.data.system, lineageNode.system),
-    systemTypeLabel: firstText(
-      node.data.systemTypeLabel,
-      lineageNode.systemTypeLabel,
-    ),
-    totalFields: node.data?.totalFields,
-  };
-};
-
-export const lineageToolbarSearchResults = (
-  nodes = [],
-  normalizedSearchTerm = "",
-  systemTypeFilter = "",
-  limit = LINEAGE_SEARCH_RESULT_LIMIT,
-) => {
-  const matchedNodes = nodes.filter((node) =>
-    lineageNodeMatchesToolbarFilters(
-      node,
-      normalizedSearchTerm,
-      systemTypeFilter,
-    ),
-  );
-  const results = matchedNodes.slice(0, limit).map((node) => {
-    const selectedNode = selectedNodeFromGraphNode(node);
-    const path = Array.isArray(node.data?.path)
-      ? node.data.path.filter(Boolean).join(" / ")
-      : "";
-
-    return {
-      contextLabel:
-        path || node.data?.systemTypeLabel || node.data?.system || "—",
-      graphNodeId: node.id,
-      label: firstText(node.data?.label, selectedNode?.name, node.id),
-      iconName: selectedNode?.iconName,
-      lineageKind: selectedNode?.lineageKind || "group",
-    };
-  });
-
-  return { results, total: matchedNodes.length };
-};
-
-const lineageAncestorNodeIds = (node, nodeById) => {
-  const parentNode = node?.parentId ? nodeById.get(node.parentId) : null;
-
-  return parentNode
-    ? [parentNode.id, ...lineageAncestorNodeIds(parentNode, nodeById)]
-    : [];
-};
-
-const lineageRelationType = (edge = {}) =>
-  firstText(
-    edge.relation_type,
-    edge.relationType,
-    edge.metadata?.relation_type,
-    edge.metadata?.relationType,
-  );
-
-const lineageEdgeContext = ({ edge, id, nodeById, source, target }) => ({
-  type: "edge",
-  edge: {
-    id,
-    label: edge.label,
-    metadata: edge.metadata,
-    relationType: lineageRelationType(edge),
-    originalSource: edge.originalSource,
-    originalTarget: edge.originalTarget,
-    source,
-    sourceName: firstText(nodeById.get(source)?.data?.label, source),
-    target,
-    targetName: firstText(nodeById.get(target)?.data?.label, target),
-  },
-});
-
-export const lineageEdge =
-  (onEdgeSelect, resolveId, nodeById, graphType = "impact") =>
-  (edge, index) => {
-    const start = resolveLineageEndpoint(edge, "start", resolveId);
-    const end = resolveLineageEndpoint(edge, "end", resolveId);
-    const reverse = graphType === "lineage" && !edge.normalizedDirection;
-    const source = reverse ? end : start;
-    const target = reverse ? start : end;
-
-    if (
-      !source ||
-      !target ||
-      source === target ||
-      !nodeById.has(source) ||
-      !nodeById.has(target)
-    ) {
-      return null;
-    }
-
-    const hasMetadata = !_.isEmpty(edge.metadata);
-    const restrictive = isRestrictiveLineageEdge(edge);
-    const markerPosition = "target"; // Flechas estáticas siempre en target; flowDirection controla animación
-    const sourceSystemType = nodeById.get(source)?.data?.systemType;
-    const targetSystemType = nodeById.get(target)?.data?.systemType;
-    const primarySystemType =
-      sourceSystemType || targetSystemType || "__without_system_type__";
-
-    const id = normalizeId(edge.id || `${source}-${target}-${index}`);
-
-    return {
-      id,
-      source,
-      sourceHandle: "end-node",
-      target,
-      targetHandle: "start-node",
-      markerEnd: { type: "arrow", width: 10, height: 10 },
-      type: "colored",
-      zIndex: LINEAGE_EDGE_Z_INDEX,
-      data: {
-        animated: false,
-        flowDirection: "forward",
-        label: edge.label,
-        edgePath: "orthogonal",
-        explicitEndpoints: true,
-        markerPosition,
-        metadata: edge.metadata,
-        relationType: lineageRelationType(edge),
-        originalEdgeIds: [id],
-        topology: Boolean(edge.normalizedDirection),
-        originalSource: edge.originalSource,
-        originalTarget: edge.originalTarget,
-        onClick:
-          hasMetadata || edge.normalizedDirection
-            ? () =>
-                onEdgeSelect(
-                  lineageEdgeContext({ edge, id, nodeById, source, target }),
-                )
-            : undefined,
-        primaryType: primarySystemType,
-        restrictive,
-        showSourceDot: false,
-        showTargetArrow: true,
-        sourceFieldName: edgeFieldName(edge, reverse ? "target" : "source"),
-        targetFieldName: edgeFieldName(edge, reverse ? "source" : "target"),
-      },
-      style: {
-        stroke: lineageEdgeColor(graphType),
-        strokeOpacity: 0.95,
-        strokeWidth: restrictive ? 2.4 : hasMetadata ? 2 : 1.8,
-      },
-    };
-  };
-
-const pathCoordinates = (path) =>
-  `${path || ""}`.match(PATH_NUMBER_PATTERN)?.map((value) => Number(value)) ||
-  [];
-
-const legacyPathEndpoints = (path) => {
-  const coordinates = pathCoordinates(path);
-
-  if (coordinates.length < 4) return {};
-
-  const startPoint = { x: coordinates[0], y: coordinates[1] };
-  const endPoint = {
-    x: coordinates[coordinates.length - 2],
-    y: coordinates[coordinates.length - 1],
-  };
-  const [sourcePoint, targetPoint] =
-    startPoint.x <= endPoint.x
-      ? [startPoint, endPoint]
-      : [endPoint, startPoint];
-
-  return {
-    startPoint,
-    endPoint,
-    sourcePoint,
-    targetPoint,
-  };
-};
-
-const legacyPathSegments = (path) =>
-  `${path || ""}`.match(PATH_SEGMENT_PATTERN) || [];
-
-const pathNodeCandidates = (
-  groups = [],
-  resources = [],
-  duplicateNodeIds = positionedDuplicateNodeIds(groups, resources),
-) =>
-  [...resources, ...groups]
-    .filter(
-      (node) =>
-        node?.id && hasNodeGeometry(node) && !isRootPositionedGroup(node),
-    )
-    .map((node) => ({
-      ...node,
-      id: positionedNodeInstanceId(node, duplicateNodeIds),
-      canonicalId: nodeId(node),
-    }));
-
-const distanceToNodePort = (node, point, endpoint) => {
-  const { x, y, w, h } = nodeGeometry(node);
-  const portX = endpoint === "source" ? x + w : x;
-  const portY = Math.max(y, Math.min(point.y, y + h));
-  const areaPenalty = geometryArea(node) / 1000000;
-
-  return Math.hypot(point.x - portX, point.y - portY) + areaPenalty;
-};
-
-const closestNodeToPathPoint = (nodes, point, endpoint) =>
-  nodes
-    .map((node) => ({
-      node,
-      score: distanceToNodePort(node, point, endpoint),
-    }))
-    .sort((nodeA, nodeB) => nodeA.score - nodeB.score)[0]?.node;
-
-const findNodeCandidate = (nodes = [], id) =>
-  nodes.find((node) => node.id === id || node.canonicalId === id);
-
-const explicitPathPoints = ({
-  sourceNode,
-  targetNode,
-  startPoint,
-  endPoint,
-}) => {
-  if (!sourceNode || !targetNode || !startPoint || !endPoint) return {};
-
-  const startAsSourceScore =
-    distanceToNodePort(sourceNode, startPoint, "source") +
-    distanceToNodePort(targetNode, endPoint, "target");
-  const endAsSourceScore =
-    distanceToNodePort(sourceNode, endPoint, "source") +
-    distanceToNodePort(targetNode, startPoint, "target");
-
-  return startAsSourceScore <= endAsSourceScore
-    ? { sourcePoint: startPoint, targetPoint: endPoint }
-    : { sourcePoint: endPoint, targetPoint: startPoint };
-};
-
-const fieldIndexFromPathPoint = (node, point) => {
-  const fields = lineageFields(node).slice(0, NODE_FIELD_LIMIT);
-
-  if (_.isEmpty(fields)) return undefined;
-
-  const { y, h } = nodeGeometry(node);
-  const fieldAreaHeight = fields.length * NODE_FIELD_HEIGHT;
-  const fieldAreaTop = y + Math.max(0, h - fieldAreaHeight - 4);
-  const relativeY = point.y - fieldAreaTop;
-
-  if (relativeY < 0) return 0;
-
-  return Math.min(Math.floor(relativeY / NODE_FIELD_HEIGHT), fields.length - 1);
-};
-
-const legacyEdgeY = (edge, endpoint) =>
-  endpoint === "source" ? edge.data?.legacySourceY : edge.data?.legacyTargetY;
-
-const legacyFieldIndexByEdge = (edges = [], nodeById, endpoint) => {
-  const edgeIndexes = new Map();
-  const edgesByNodeId = edges.reduce((groups, edge) => {
-    const nodeId = endpoint === "source" ? edge.source : edge.target;
-    const y = legacyEdgeY(edge, endpoint);
-
-    if (y === undefined) return groups;
-
-    const nodeEdges = groups.get(nodeId) || [];
-
-    nodeEdges.push(edge);
-    groups.set(nodeId, nodeEdges);
-
-    return groups;
-  }, new Map());
-
-  edgesByNodeId.forEach((nodeEdges, nodeId) => {
-    const fields = nodeById.get(nodeId)?.data?.fields || [];
-
-    if (_.isEmpty(fields)) return;
-
-    [...nodeEdges]
-      .sort((edgeA, edgeB) => {
-        const yDiff =
-          legacyEdgeY(edgeA, endpoint) - legacyEdgeY(edgeB, endpoint);
-
-        return yDiff || edgeA.id.localeCompare(edgeB.id);
-      })
-      .forEach((edge, index) => {
-        edgeIndexes.set(edge.id, Math.min(index, fields.length - 1));
-      });
-  });
-
-  return edgeIndexes;
-};
-
-export const spreadLegacyFieldIndexes = (edges = [], nodeById) => {
-  const sourceIndexByEdgeId = legacyFieldIndexByEdge(edges, nodeById, "source");
-  const targetIndexByEdgeId = legacyFieldIndexByEdge(edges, nodeById, "target");
-
-  return edges.map((edge) => ({
-    ...edge,
-    data: {
-      ...edge.data,
-      sourceFieldIndex:
-        edge.data?.sourceFieldIndex ?? sourceIndexByEdgeId.get(edge.id),
-      targetFieldIndex:
-        edge.data?.targetFieldIndex ?? targetIndexByEdgeId.get(edge.id),
-    },
-  }));
-};
-
-export const legacyPathEdge =
-  (
-    nodeCandidates,
-    nodeById,
-    onEdgeSelect,
-    resolveId = (id) => id,
-    graphType = "impact",
-  ) =>
-  (edge, index) => {
-    if (!edge?.path) return null;
-
-    const {
-      endPoint,
-      sourcePoint: fallbackSourcePoint,
-      startPoint,
-      targetPoint: fallbackTargetPoint,
-    } = legacyPathEndpoints(edge.path);
-    const explicitSource = resolveLineageEndpoint(edge, "start", resolveId);
-    const explicitTarget = resolveLineageEndpoint(edge, "end", resolveId);
-    const hasExplicitEndpoints =
-      explicitSource &&
-      explicitTarget &&
-      nodeById.has(explicitSource) &&
-      nodeById.has(explicitTarget);
-    const explicitSourceNode = hasExplicitEndpoints
-      ? findNodeCandidate(nodeCandidates, explicitSource)
-      : undefined;
-    const explicitTargetNode = hasExplicitEndpoints
-      ? findNodeCandidate(nodeCandidates, explicitTarget)
-      : undefined;
-    const explicitPoints = explicitPathPoints({
-      sourceNode: explicitSourceNode,
-      targetNode: explicitTargetNode,
-      startPoint,
-      endPoint,
-    });
-    const sourcePoint = hasExplicitEndpoints
-      ? explicitPoints.sourcePoint || fallbackSourcePoint
-      : fallbackSourcePoint;
-    const targetPoint = hasExplicitEndpoints
-      ? explicitPoints.targetPoint || fallbackTargetPoint
-      : fallbackTargetPoint;
-
-    if (!sourcePoint || !targetPoint) return null;
-
-    const resolvedSourceNode =
-      explicitSourceNode ||
-      closestNodeToPathPoint(nodeCandidates, sourcePoint, "source");
-    const resolvedTargetNode =
-      explicitTargetNode ||
-      closestNodeToPathPoint(nodeCandidates, targetPoint, "target");
-    const reverseExplicitLineage =
-      graphType === "lineage" && hasExplicitEndpoints;
-    const sourceNode = reverseExplicitLineage
-      ? resolvedTargetNode
-      : resolvedSourceNode;
-    const targetNode = reverseExplicitLineage
-      ? resolvedSourceNode
-      : resolvedTargetNode;
-    const sourceFieldPoint = reverseExplicitLineage ? targetPoint : sourcePoint;
-    const targetFieldPoint = reverseExplicitLineage ? sourcePoint : targetPoint;
-
-    if (
-      !sourceNode ||
-      !targetNode ||
-      sourceNode.id === targetNode.id ||
-      !nodeById.has(sourceNode.id) ||
-      !nodeById.has(targetNode.id)
-    ) {
-      return null;
-    }
-
-    const hasMetadata = !_.isEmpty(edge.metadata);
-
-    const id = normalizeId(
-      edge.id || `legacy-path-${sourceNode.id}-${targetNode.id}-${index}`,
-    );
-
-    return {
-      id,
-      source: sourceNode.id,
-      sourceHandle: "end-node",
-      target: targetNode.id,
-      targetHandle: "start-node",
-      type: "colored",
-      zIndex: LINEAGE_EDGE_Z_INDEX,
-      data: {
-        animated: false,
-        flowDirection: "forward",
-        label: edge.label,
-        edgePath: "orthogonal",
-        explicitEndpoints: Boolean(hasExplicitEndpoints),
-        legacyPath: true,
-        legacySourceY: sourceFieldPoint.y,
-        legacyTargetY: targetFieldPoint.y,
-        markerPosition: "target",
-        metadata: edge.metadata,
-        relationType: lineageRelationType(edge),
-        originalEdgeIds: [id],
-        onClick: hasMetadata
-          ? () =>
-              onEdgeSelect(
-                lineageEdgeContext({
-                  edge,
-                  id,
-                  nodeById,
-                  source: sourceNode.id,
-                  target: targetNode.id,
-                }),
-              )
-          : undefined,
-        primaryType: "__without_system_type__",
-        restrictive: isRestrictiveLineageEdge(edge),
-        showSourceDot: false,
-        showTargetArrow: true,
-        sourceFieldIndex: fieldIndexFromPathPoint(sourceNode, sourceFieldPoint),
-        targetFieldIndex: fieldIndexFromPathPoint(targetNode, targetFieldPoint),
-      },
-      style: {
-        stroke: lineageEdgeColor(graphType),
-        strokeOpacity: 0.95,
-        strokeWidth: hasMetadata ? 2 : 1.8,
-      },
-    };
-  };
-
-export const legacyPathEdges =
-  (
-    nodeCandidates,
-    nodeById,
-    onEdgeSelect,
-    resolveId = (id) => id,
-    graphType = "impact",
-  ) =>
-  (edge, index) => {
-    const segments = legacyPathSegments(edge?.path);
-
-    if (_.isEmpty(segments)) return [];
-
-    return segments
-      .map((segment, segmentIndex) =>
-        legacyPathEdge(
-          nodeCandidates,
-          nodeById,
-          onEdgeSelect,
-          resolveId,
-          graphType,
-        )(
-          {
-            ...edge,
-            id: normalizeId(
-              edge.id
-                ? `${edge.id}-${segmentIndex}`
-                : `legacy-path-${index}-${segmentIndex}`,
-            ),
-            path: segment,
-          },
-          segmentIndex,
-        ),
-      )
-      .filter(Boolean);
-  };
-
 export const LineageGraph = ({
   defaultExpansionDepth = LINEAGE_DEFAULT_EXPANSION_DEPTH,
   height = "80vh",