@truedat/dd 8.11.4 → 8.11.7

package/src/components/__tests__/LineageGraph.spec.js

@@ -0,0 +1,896 @@
+import {
+  collapseLineageNodes,
+  expandLineageDescendantsUntilOversized,
+  focusLineageEdges,
+  focusedLineageGraphForNodeSet,
+  lineageDirectChildCounts,
+  lineageEdge,
+  lineageCatalogState,
+  lineageNodeContentWidth,
+  lineageNodeMatchesToolbarFilters,
+  lineageOversizedGroupIds,
+  lineagePositionedLayoutNodes,
+  lineageShouldLoadExpanded,
+  lineageSystemType,
+  lineageToolbarSearchResults,
+  redesignedLineageNodeHeight,
+  selectedNodeFromGraphNode,
+} from "../LineageGraph";
+
+describe("focusLineageEdges", () => {
+  const edges = [
+    { id: "focused", data: { animated: false } },
+    { id: "dimmed", data: { animated: false } },
+    {
+      id: "containment",
+      data: { animated: false, containment: true },
+    },
+  ];
+  const focusedEdgeIds = new Set(["focused", "containment"]);
+
+  it("animates only focused dependencies after selecting a node", () => {
+    const result = focusLineageEdges(edges, focusedEdgeIds, true, true);
+
+    expect(result.find((edge) => edge.id === "focused").data.animated).toBe(
+      true,
+    );
+    expect(result.find((edge) => edge.id === "dimmed").data.animated).toBe(
+      false,
+    );
+    expect(result.find((edge) => edge.id === "containment").data.animated).toBe(
+      false,
+    );
+  });
+
+  it("raises selected-node dependencies above selected cards and restores their layer", () => {
+    const baseEdges = edges.map((edge) => ({ ...edge, zIndex: 100 }));
+    const result = focusLineageEdges(
+      baseEdges,
+      focusedEdgeIds,
+      true,
+      true,
+      "node",
+    );
+
+    expect(result.find(({ id }) => id === "focused").zIndex).toBeGreaterThan(
+      300,
+    );
+    expect(result.find(({ id }) => id === "dimmed").zIndex).toBe(100);
+    expect(result.find(({ id }) => id === "containment").zIndex).toBe(100);
+    expect(focusLineageEdges(baseEdges, focusedEdgeIds, false)).toBe(baseEdges);
+    expect(
+      focusLineageEdges(baseEdges, focusedEdgeIds, true).every(
+        ({ zIndex }) => zIndex === 100,
+      ),
+    ).toBe(true);
+  });
+
+  it("raises a selected dependency without raising other edges", () => {
+    const baseEdges = edges.map((edge) => ({ ...edge, zIndex: 100 }));
+    const result = focusLineageEdges(
+      baseEdges,
+      focusedEdgeIds,
+      true,
+      false,
+      null,
+      "focused",
+    );
+
+    expect(result.find(({ id }) => id === "focused").zIndex).toBeGreaterThan(
+      300,
+    );
+    expect(result.find(({ id }) => id === "dimmed").zIndex).toBe(100);
+    expect(result.find(({ id }) => id === "containment").zIndex).toBe(100);
+    expect(result.every(({ data }) => !data.animated)).toBe(true);
+    expect(focusLineageEdges(baseEdges, focusedEdgeIds, false)).toBe(baseEdges);
+  });
+
+  it("keeps animation disabled when focus comes from another state", () => {
+    const result = focusLineageEdges(edges, focusedEdgeIds, true, false);
+
+    expect(result.every((edge) => !edge.data.animated)).toBe(true);
+  });
+});
+
+const groupNode = (id, x, y, w, h, options = {}) => ({
+  id,
+  type: "lineageGroup",
+  width: w,
+  height: h,
+  position: { x, y },
+  data: {
+    absoluteGeometry: { x, y, w, h },
+    collapsed: options.collapsed ?? false,
+    variant: "absolute",
+  },
+});
+
+// Los nodos posicionados reales usan position relativa al padre y
+// absoluteGeometry absoluta (ver lineagePositionedResourceNode), así que el
+// helper deriva la geometría absoluta desde la posición relativa del padre.
+const resourceNode = (id, parent, x, y, w, h) => {
+  const parentGeometry = parent?.data?.absoluteGeometry || { x: 0, y: 0 };
+
+  return {
+    id,
+    type: "lineageResource",
+    parentId: parent?.id,
+    width: w,
+    height: h,
+    position: { x, y },
+    data: {
+      absoluteGeometry: {
+        x: parentGeometry.x + x,
+        y: parentGeometry.y + y,
+        w,
+        h,
+      },
+    },
+  };
+};
+
+describe("redesignedLineageNodeHeight", () => {
+  it("uses actual rows up to the six-row collapsed limit", () => {
+    expect(redesignedLineageNodeHeight(0)).toBe(42);
+    expect(redesignedLineageNodeHeight(4)).toBe(186);
+    expect(redesignedLineageNodeHeight(6)).toBe(258);
+  });
+
+  it("reserves disclosure space and caps expanded geometry at ten rows", () => {
+    expect(redesignedLineageNodeHeight(7)).toBe(290);
+    expect(redesignedLineageNodeHeight(7, true)).toBe(326);
+    expect(redesignedLineageNodeHeight(12, true)).toBe(434);
+  });
+});
+
+describe("selectedNodeFromGraphNode", () => {
+  it("uses the full rendered parent chain and keeps the selected node once", () => {
+    const root = {
+      id: "root",
+      data: { label: "Root", lineageNode: { id: "root" } },
+    };
+    const domain = {
+      id: "domain",
+      parentId: "root",
+      data: { label: "Domain", lineageNode: { id: "domain" } },
+    };
+    const node = {
+      id: "node",
+      parentId: "domain",
+      data: {
+        fieldsKnown: true,
+        iconName: "table",
+        label: "Orders",
+        lineageNode: {
+          id: "node",
+          lineageKind: "resource",
+          name: "Orders",
+          path: ["Orders"],
+        },
+        totalFields: 0,
+      },
+    };
+    const selected = selectedNodeFromGraphNode(
+      node,
+      new Map([
+        [root.id, root],
+        [domain.id, domain],
+        [node.id, node],
+      ]),
+    );
+
+    expect(selected.path).toEqual(["Root", "Domain", "Orders"]);
+    expect(selected.iconName).toBe("table");
+    expect(selected.fieldsKnown).toBe(true);
+  });
+});
+
+describe("redesigned lineage layout", () => {
+  it("repacks positioned siblings and grows their ancestor", () => {
+    const [group, firstNode, secondNode] = collapseLineageNodes(
+      [
+        {
+          id: "group",
+          type: "lineageGroup",
+          width: 360,
+          height: 220,
+          position: { x: 0, y: 0 },
+          data: {
+            absoluteGeometry: { x: 0, y: 0, w: 360, h: 220 },
+            variant: "absolute",
+          },
+        },
+        {
+          id: "a",
+          parentId: "group",
+          type: "lineageResource",
+          width: 288,
+          height: 266,
+          position: { x: 30, y: 52 },
+          data: {
+            absoluteGeometry: { x: 30, y: 52, w: 288, h: 266 },
+          },
+        },
+        {
+          id: "b",
+          parentId: "group",
+          type: "lineageResource",
+          width: 288,
+          height: 394,
+          position: { x: 30, y: 100 },
+          data: {
+            absoluteGeometry: { x: 30, y: 100, w: 288, h: 394 },
+          },
+        },
+      ],
+      new Set(),
+      jest.fn(),
+    );
+
+    expect(secondNode.position.y).toBe(
+      firstNode.position.y + firstNode.height + 6,
+    );
+    expect(group.height).toBeGreaterThanOrEqual(
+      secondNode.position.y + secondNode.height,
+    );
+  });
+
+  it("expands only the selected positioned duplicate instance", () => {
+    const resources = [
+      {
+        fields: Array.from({ length: 12 }, (_, index) => ({
+          name: `field-${index}`,
+        })),
+        id: "duplicate",
+        name: "Duplicate A",
+        x: 0,
+        y: 0,
+        w: 120,
+        h: 60,
+      },
+      {
+        fields: Array.from({ length: 12 }, (_, index) => ({
+          name: `field-${index}`,
+        })),
+        id: "duplicate",
+        name: "Duplicate B",
+        x: 0,
+        y: 100,
+        w: 120,
+        h: 60,
+      },
+    ];
+    const collapsed = lineagePositionedLayoutNodes({
+      nodeDesign: "redesigned",
+      resources,
+    });
+    const expandedId = collapsed[0].id;
+    const expanded = lineagePositionedLayoutNodes({
+      expandedFieldNodeIds: new Set([expandedId]),
+      nodeDesign: "redesigned",
+      resources,
+    });
+
+    expect(expanded.find(({ id }) => id === expandedId).height).toBe(434);
+    expect(expanded.find(({ id }) => id !== expandedId).height).toBe(290);
+  });
+});
+
+describe("focusedLineageGraphForNodeSet", () => {
+  const edges = [
+    { id: "e1", source: "a", target: "b" },
+    { id: "e2", source: "b", target: "c" },
+    { id: "e3", source: "a", target: "c" },
+  ];
+
+  it("returns empty sets when nodeIds is null", () => {
+    expect(focusedLineageGraphForNodeSet(null, edges)).toEqual({
+      focusedNodeIds: new Set(),
+      focusedEdgeIds: new Set(),
+    });
+  });
+
+  it("returns empty sets when nodeIds is empty", () => {
+    expect(focusedLineageGraphForNodeSet(new Set(), edges)).toEqual({
+      focusedNodeIds: new Set(),
+      focusedEdgeIds: new Set(),
+    });
+  });
+
+  it("only includes edges whose both endpoints are in nodeIds", () => {
+    const result = focusedLineageGraphForNodeSet(new Set(["a", "b"]), edges);
+    expect(result.focusedNodeIds).toEqual(new Set(["a", "b"]));
+    expect(result.focusedEdgeIds).toEqual(new Set(["e1"]));
+  });
+
+  it("does not expand to neighbors outside nodeIds", () => {
+    const result = focusedLineageGraphForNodeSet(new Set(["a"]), edges);
+    expect(result.focusedEdgeIds).toEqual(new Set());
+  });
+});
+
+describe("lineageNodeContentWidth", () => {
+  it("returns the minimum width when no content is provided", () => {
+    expect(lineageNodeContentWidth()).toBe(240);
+    expect(lineageNodeContentWidth([])).toBe(240);
+  });
+
+  it("returns the minimum width for short content", () => {
+    expect(lineageNodeContentWidth([{ id: "t1", name: "orders" }])).toBe(240);
+  });
+
+  it("grows with the longest label or field line", () => {
+    expect(
+      lineageNodeContentWidth([
+        {
+          id: "t1",
+          name: "orders",
+          fields: [{ name: "customer_order_id", type: "BIGINT" }],
+        },
+      ]),
+    ).toBeGreaterThan(240);
+  });
+
+  it("clamps the width to the maximum", () => {
+    expect(
+      lineageNodeContentWidth([
+        {
+          id: "t1",
+          name: "a_very_long_table_name_that_covers_many_characters",
+          fields: Array.from({ length: 3 }, (_, index) => ({
+            name: `very_long_field_name_${index}_that_keeps_growing`,
+            type: "VARCHAR(512)",
+          })),
+        },
+      ]),
+    ).toBe(360);
+  });
+});
+
+describe("lineageSystemType", () => {
+  it("treats placeholder and empty system groups as missing without a visible label", () => {
+    [
+      {},
+      { system_group: "" },
+      { system_group: "Without System Group" },
+      { system_group: "without_system_group" },
+      { system_group: "sin grupo de sistema" },
+      { metadata: { system_group: "unknown" } },
+      { dynamic_content: { system_group: { value: "n/a" } } },
+    ].forEach((node) => {
+      expect(lineageSystemType(node)).toMatchObject({
+        missing: true,
+        label: "",
+      });
+    });
+  });
+
+  it("keeps SYSTEM as a real system type", () => {
+    expect(lineageSystemType({ system_group: "SYSTEM" })).toMatchObject({
+      missing: false,
+      label: "SYSTEM",
+    });
+  });
+});
+
+describe("lineageNodeMatchesToolbarFilters", () => {
+  const node = {
+    data: {
+      lineageNode: { id: "n1" },
+      label: "Customer Address",
+      systemType: "sys-oracle",
+    },
+  };
+  const groupWithoutLineageNode = { data: { label: "Orphan group" } };
+
+  it("matches when search term is a case-insensitive substring of the label", () => {
+    expect(lineageNodeMatchesToolbarFilters(node, "address", "")).toBe(true);
+    expect(lineageNodeMatchesToolbarFilters(node, "ADDRESS", "")).toBe(true);
+    expect(lineageNodeMatchesToolbarFilters(node, "invoice", "")).toBe(false);
+  });
+
+  it("matches when systemTypeFilter equals the node systemType key", () => {
+    expect(lineageNodeMatchesToolbarFilters(node, "", "sys-oracle")).toBe(true);
+    expect(lineageNodeMatchesToolbarFilters(node, "", "sys-teradata")).toBe(
+      false,
+    );
+  });
+
+  it("requires both search and system filter to match when both are set", () => {
+    expect(
+      lineageNodeMatchesToolbarFilters(node, "address", "sys-oracle"),
+    ).toBe(true);
+    expect(
+      lineageNodeMatchesToolbarFilters(node, "address", "sys-teradata"),
+    ).toBe(false);
+  });
+
+  it("returns false for nodes without data.lineageNode", () => {
+    expect(
+      lineageNodeMatchesToolbarFilters(groupWithoutLineageNode, "orphan", ""),
+    ).toBe(false);
+  });
+});
+
+describe("lineageToolbarSearchResults", () => {
+  const searchNode = (id, label, options = {}) => ({
+    id,
+    hidden: options.hidden,
+    data: {
+      label,
+      lineageNode: {
+        external_id: options.externalId,
+        id,
+        lineageKind: options.lineageKind || "resource",
+        name: label,
+      },
+      path: options.path,
+      systemType: options.systemType || "oracle",
+      systemTypeLabel: options.systemTypeLabel || "Oracle",
+    },
+  });
+
+  it("finds identifiers and hidden nodes while preserving duplicate labels", () => {
+    const { results, total } = lineageToolbarSearchResults(
+      [
+        searchNode("orders-a", "Orders", {
+          externalId: "warehouse.orders",
+          hidden: true,
+          path: ["Warehouse", "Sales"],
+        }),
+        searchNode("orders-b", "Orders", {
+          externalId: "lake.orders",
+          path: ["Lake", "Curated"],
+        }),
+      ],
+      "orders",
+    );
+
+    expect(total).toBe(2);
+    expect(results).toHaveLength(2);
+    expect(results.map(({ label }) => label)).toEqual(["Orders", "Orders"]);
+    expect(results.map(({ contextLabel }) => contextLabel)).toEqual([
+      "Warehouse / Sales",
+      "Lake / Curated",
+    ]);
+  });
+
+  it("applies the system filter and caps the visible list at 50", () => {
+    const nodes = Array.from({ length: 55 }, (_, index) =>
+      searchNode(`node-${index}`, `Node ${index}`, {
+        systemType: index === 54 ? "postgres" : "oracle",
+      }),
+    );
+    const allResults = lineageToolbarSearchResults(nodes, "node");
+    const postgresResults = lineageToolbarSearchResults(
+      nodes,
+      "node",
+      "postgres",
+    );
+
+    expect(allResults.total).toBe(55);
+    expect(allResults.results).toHaveLength(50);
+    expect(postgresResults.total).toBe(1);
+    expect(postgresResults.results[0].graphNodeId).toBe("node-54");
+  });
+});
+
+describe("lineageEdge inspector context", () => {
+  const nodeById = new Map([
+    ["source", { data: { label: "Orders" } }],
+    ["target", { data: { label: "Customers" } }],
+  ]);
+
+  it("provides endpoints, relation type and the complete metadata payload", () => {
+    const onEdgeSelect = jest.fn();
+    const metadata = {
+      columns: ["customer_id", "id"],
+      nested: { active: true },
+    };
+    const mappedEdge = lineageEdge(
+      onEdgeSelect,
+      (value) => value,
+      nodeById,
+    )(
+      {
+        id: "edge-1",
+        metadata,
+        relation_type: "depends_on",
+        source: "source",
+        target: "target",
+      },
+      0,
+    );
+
+    mappedEdge.data.onClick();
+
+    expect(onEdgeSelect).toHaveBeenCalledWith({
+      type: "edge",
+      edge: {
+        id: "edge-1",
+        label: undefined,
+        metadata,
+        relationType: "depends_on",
+        source: "source",
+        sourceName: "Orders",
+        target: "target",
+        targetName: "Customers",
+      },
+    });
+  });
+
+  it("keeps an edge without metadata non-interactive", () => {
+    const mappedEdge = lineageEdge(
+      jest.fn(),
+      (value) => value,
+      nodeById,
+    )({ id: "edge-2", source: "source", target: "target" }, 0);
+
+    expect(mappedEdge.data.onClick).toBeUndefined();
+  });
+
+  it("points the arrow at the target for impact and at the source for traceability", () => {
+    const baseEdge = { id: "edge-3", source: "source", target: "target" };
+    const impactEdge = lineageEdge(
+      jest.fn(),
+      (value) => value,
+      nodeById,
+    )(baseEdge, 0);
+    const traceabilityEdge = lineageEdge(
+      jest.fn(),
+      (value) => value,
+      nodeById,
+      "lineage",
+    )(baseEdge, 1);
+
+    expect(impactEdge.data.markerPosition).toBe("target");
+    expect(traceabilityEdge.data.markerPosition).toBe("target"); // Flechas estáticas siempre en target; flowDirection controla animación
+  });
+});
+
+describe("lineageShouldLoadExpanded", () => {
+  const nestedGroup = (id, parent, x, y, w, h) => ({
+    ...groupNode(id, x, y, w, h),
+    parentId: parent?.id,
+  });
+
+  it("opens expanded a small nested graph of 4 boxes with 3 and 8 leaves", () => {
+    const outer1 = groupNode("outer1", 0, 0, 900, 500);
+    const inner1 = nestedGroup("inner1", outer1, 40, 40, 800, 400);
+    const outer2 = groupNode("outer2", 1100, 0, 900, 900);
+    const inner2 = nestedGroup("inner2", outer2, 40, 40, 800, 800);
+    const nodes = [
+      outer1,
+      inner1,
+      ...Array.from({ length: 3 }, (_, index) =>
+        resourceNode(
+          `inner1-leaf-${index}`,
+          inner1,
+          20,
+          60 + index * 120,
+          288,
+          120,
+        ),
+      ),
+      outer2,
+      inner2,
+      ...Array.from({ length: 8 }, (_, index) =>
+        resourceNode(
+          `inner2-leaf-${index}`,
+          inner2,
+          20,
+          60 + index * 90,
+          288,
+          90,
+        ),
+      ),
+    ];
+
+    expect(lineageShouldLoadExpanded(nodes)).toBe(true);
+  });
+
+  it("keeps collapsed when there are more than 5 collapsible boxes", () => {
+    const nodes = Array.from({ length: 6 }, (_, index) => {
+      const group = groupNode(`g-${index}`, index * 320, 0, 240, 120);
+
+      return [group, resourceNode(`r-${index}`, group, 20, 20, 288, 120)];
+    }).flat();
+
+    expect(lineageShouldLoadExpanded(nodes)).toBe(false);
+  });
+
+  it("keeps collapsed when a box has more than 20 leaf nodes", () => {
+    const groups = Array.from({ length: 5 }, (_, index) =>
+      groupNode(`g-${index}`, index * 320, 0, 240, 600),
+    );
+    const nodes = [
+      ...groups,
+      ...Array.from({ length: 21 }, (_, index) =>
+        resourceNode(
+          `g0-leaf-${index}`,
+          groups[0],
+          20,
+          60 + index * 20,
+          288,
+          20,
+        ),
+      ),
+      ...groups
+        .slice(1)
+        .flatMap((group, index) =>
+          Array.from({ length: 5 }, (_, leafIndex) =>
+            resourceNode(
+              `g${index + 1}-leaf-${leafIndex}`,
+              group,
+              20,
+              60 + leafIndex * 20,
+              288,
+              20,
+            ),
+          ),
+        ),
+    ];
+
+    expect(lineageShouldLoadExpanded(nodes)).toBe(false);
+  });
+
+  it("opens expanded when 5 boxes each have at most 20 leaf nodes", () => {
+    const groups = Array.from({ length: 5 }, (_, index) =>
+      groupNode(`g-${index}`, index * 320, 0, 240, 500),
+    );
+    const nodes = [
+      ...groups,
+      ...groups.flatMap((group, index) =>
+        Array.from({ length: 20 }, (_, leafIndex) =>
+          resourceNode(
+            `g${index}-leaf-${leafIndex}`,
+            group,
+            20,
+            60 + leafIndex * 20,
+            288,
+            20,
+          ),
+        ),
+      ),
+    ];
+
+    expect(lineageShouldLoadExpanded(nodes)).toBe(true);
+  });
+
+  it("keeps collapsed when an outer box accumulates more than 20 leaves through nesting", () => {
+    const outer = groupNode("outer", 0, 0, 900, 900);
+    const innerGroups = Array.from({ length: 3 }, (_, index) =>
+      nestedGroup(`inner-${index}`, outer, 40, 40 + index * 280, 800, 260),
+    );
+    const nodes = [
+      outer,
+      ...innerGroups,
+      ...innerGroups.flatMap((inner, index) =>
+        Array.from({ length: 8 }, (_, leafIndex) =>
+          resourceNode(
+            `inner${index}-leaf-${leafIndex}`,
+            inner,
+            20,
+            60 + leafIndex * 20,
+            288,
+            20,
+          ),
+        ),
+      ),
+    ];
+
+    expect(lineageShouldLoadExpanded(nodes)).toBe(false);
+  });
+
+  it("returns true for an empty node set", () => {
+    expect(lineageShouldLoadExpanded([])).toBe(true);
+  });
+});
+
+describe("lineageDirectChildCounts", () => {
+  it("counts only direct children, not descendants", () => {
+    const outer = groupNode("outer", 0, 0, 900, 900);
+    const inner = {
+      ...groupNode("inner", 40, 40, 800, 800),
+      parentId: "outer",
+    };
+    const nodes = [outer, inner, resourceNode("leaf", inner, 20, 60, 288, 20)];
+
+    const counts = lineageDirectChildCounts(nodes);
+    expect(counts.get("outer")).toBe(1);
+    expect(counts.get("inner")).toBe(1);
+  });
+
+  it("ignores nodes without parent", () => {
+    const counts = lineageDirectChildCounts([groupNode("g", 0, 0, 240, 120)]);
+    expect(counts.size).toBe(0);
+  });
+});
+
+describe("lineageOversizedGroupIds", () => {
+  it("flags groups with more than 20 direct children", () => {
+    const group = groupNode("g", 0, 0, 240, 600);
+    const nodes = [
+      group,
+      ...Array.from({ length: 21 }, (_, index) =>
+        resourceNode(`leaf-${index}`, group, 20, 60 + index * 20, 288, 20),
+      ),
+    ];
+
+    expect(lineageOversizedGroupIds(nodes).has("g")).toBe(true);
+  });
+
+  it("does not flag groups with at most 20 direct children", () => {
+    const group = groupNode("g", 0, 0, 240, 600);
+    const nodes = [
+      group,
+      ...Array.from({ length: 20 }, (_, index) =>
+        resourceNode(`leaf-${index}`, group, 20, 60 + index * 20, 288, 20),
+      ),
+    ];
+
+    expect(lineageOversizedGroupIds(nodes).has("g")).toBe(false);
+  });
+
+  it("does not count nested grandchildren as direct children", () => {
+    const outer = groupNode("outer", 0, 0, 900, 900);
+    const inner = {
+      ...groupNode("inner", 40, 40, 800, 800),
+      parentId: "outer",
+    };
+    const nodes = [
+      outer,
+      inner,
+      ...Array.from({ length: 25 }, (_, index) =>
+        resourceNode(`leaf-${index}`, inner, 20, 60 + index * 20, 288, 20),
+      ),
+    ];
+
+    const ids = lineageOversizedGroupIds(nodes);
+    expect(ids.has("outer")).toBe(false);
+    expect(ids.has("inner")).toBe(true);
+  });
+});
+
+describe("expandLineageDescendantsUntilOversized", () => {
+  it("expands the subtree but keeps nested oversized groups collapsed", () => {
+    const outer = groupNode("outer", 0, 0, 900, 1500);
+    const innerOversized = {
+      ...groupNode("inner-oversized", 40, 40, 800, 1400),
+      parentId: "outer",
+    };
+    const innerPlain = {
+      ...groupNode("inner-plain", 40, 900, 800, 500),
+      parentId: "outer",
+    };
+    const nodes = [
+      outer,
+      innerOversized,
+      innerPlain,
+      ...Array.from({ length: 25 }, (_, index) =>
+        resourceNode(
+          `oversized-leaf-${index}`,
+          innerOversized,
+          20,
+          40 + index * 40,
+          288,
+          30,
+        ),
+      ),
+      resourceNode("plain-leaf", innerPlain, 20, 40, 288, 30),
+    ];
+    const collapsedIds = new Set(["outer", "inner-oversized", "inner-plain"]);
+    const oversizedIds = new Set(["inner-oversized"]);
+
+    const next = expandLineageDescendantsUntilOversized(
+      collapsedIds,
+      "outer",
+      nodes,
+      oversizedIds,
+    );
+
+    expect(next.has("outer")).toBe(false);
+    expect(next.has("inner-oversized")).toBe(true);
+    expect(next.has("inner-plain")).toBe(false);
+  });
+
+  it("leaves non-descendant oversized groups untouched", () => {
+    const other = groupNode("other", 1000, 0, 900, 600);
+    const root = groupNode("root", 0, 0, 900, 600);
+    const nodes = [root, other];
+    const collapsedIds = new Set(["root", "other"]);
+    const oversizedIds = new Set(["other"]);
+
+    const next = expandLineageDescendantsUntilOversized(
+      collapsedIds,
+      "root",
+      nodes,
+      oversizedIds,
+    );
+
+    expect(next.has("root")).toBe(false);
+    expect(next.has("other")).toBe(true);
+  });
+});
+
+describe("collapseLineageNodes oversized flags", () => {
+  it("injects oversized data and pending warning handlers", () => {
+    const group = groupNode("g", 0, 0, 240, 600);
+    const nodes = [
+      group,
+      ...Array.from({ length: 21 }, (_, index) =>
+        resourceNode(`leaf-${index}`, group, 20, 60 + index * 20, 288, 20),
+      ),
+    ];
+    const oversizedIds = new Set(["g"]);
+    const pendingExpand = { groupId: "g", action: "toggle" };
+    const onConfirm = jest.fn();
+
+    const result = collapseLineageNodes(
+      nodes,
+      new Set(["g"]),
+      jest.fn(),
+      jest.fn(),
+      oversizedIds,
+      pendingExpand,
+      onConfirm,
+    );
+    const rendered = result.find((node) => node.id === "g");
+
+    expect(rendered.data.oversized).toBe(true);
+    expect(rendered.data.oversizedChildCount).toBe(21);
+    expect(rendered.data.oversizedWarningOpen).toBe(true);
+    rendered.data.onConfirmOversizedExpand();
+    expect(onConfirm).toHaveBeenCalledWith("g", "toggle");
+  });
+
+  it("does not flag non-oversized groups", () => {
+    const group = groupNode("g", 0, 0, 240, 600);
+    const nodes = [
+      group,
+      ...Array.from({ length: 3 }, (_, index) =>
+        resourceNode(`leaf-${index}`, group, 20, 60 + index * 20, 288, 20),
+      ),
+    ];
+
+    const result = collapseLineageNodes(
+      nodes,
+      new Set(["g"]),
+      jest.fn(),
+      jest.fn(),
+    );
+    const rendered = result.find((node) => node.id === "g");
+
+    expect(rendered.data.oversized).toBe(false);
+    expect(rendered.data.oversizedWarningOpen).toBe(false);
+  });
+});
+
+describe("lineageCatalogState", () => {
+  it("does not treat missing metadata as catalog absence", () => {
+    expect(lineageCatalogState({ id: "group" })).toBe("unknown");
+    expect(lineageCatalogState({ structure_id: null })).toBe("absent");
+  });
+  it("distinguishes deleted structures from absent structures", () => {
+    expect(
+      lineageCatalogState({ structure_id: null, deleted_at: "2026-09-11" }),
+    ).toBe("deleted");
+    expect(lineageCatalogState({ structure_id: 42, deleted: true })).toBe(
+      "deleted",
+    );
+    expect(lineageCatalogState({ structure_id: 42, deleted: false })).toBe(
+      "present",
+    );
+  });
+  it("preserves catalog membership from merged originals", () => {
+    expect(
+      lineageCatalogState({
+        structure_id: null,
+        originals: [{ structure_id: 42 }],
+      }),
+    ).toBe("present");
+    expect(
+      lineageCatalogState({ originals: [{ metadata: { status: "deleted" } }] }),
+    ).toBe("deleted");
+  });
+});