fix: treat non-finite coordinates as needing layout, cover ELK rejection

Addresses review feedback on #14258.

`needsLayout` used a typeof + NaN check, which let `Infinity` through: it is a
number and is not NaN, so a node with an infinite coordinate skipped the
synchronous seeding and could still reach React Flow as an unusable position.
`Number.isFinite` does not coerce, so it subsumes the typeof check while also
rejecting NaN and ±Infinity.

Also adds the missing error-path coverage for the ELK fallback: the previous
tests only exercised successful layouts, never the catch branch. The new test
mocks elk.layout to reject and asserts getLayoutedNodes resolves to the
deterministic grid rather than propagating.

Both tests fail without their corresponding fix.

Author: erichare

src/frontend/src/utils/__tests__/layoutUtils.test.ts

@@ -74,6 +74,19 @@ describe("needsLayout", () => {
     expect(needsLayout([node])).toBe(true);
   });
 
+  it("flags non-finite coordinates", () => {
+    const positive = {
+      ...makeNode("A"),
+      position: { x: Number.POSITIVE_INFINITY, y: 0 },
+    };
+    const negative = {
+      ...makeNode("B"),
+      position: { x: 0, y: Number.NEGATIVE_INFINITY },
+    };
+    expect(needsLayout([positive])).toBe(true);
+    expect(needsLayout([negative])).toBe(true);
+  });
+
   it("accepts well-formed positions", () => {
     const node = { ...makeNode("A"), position: { x: 0, y: 0 } };
     expect(needsLayout([node])).toBe(false);
@@ -103,6 +116,41 @@ describe("getLayoutedNodes with handle-less edges", () => {
   });
 });
 
+describe("getLayoutedNodes when ELK rejects", () => {
+  afterEach(() => {
+    jest.dontMock("elkjs/lib/elk.bundled.js");
+    jest.resetModules();
+    jest.restoreAllMocks();
+  });
+
+  it("falls back to the deterministic grid instead of propagating", async () => {
+    jest.resetModules();
+    jest.doMock("elkjs/lib/elk.bundled.js", () => ({
+      __esModule: true,
+      default: class {
+        layout = jest.fn().mockRejectedValue(new Error("ELK exploded"));
+      },
+    }));
+    jest.spyOn(console, "error").mockImplementation(() => {});
+
+    // Re-require so the module picks up the failing ELK singleton.
+    const {
+      getFallbackGridPositions: freshFallback,
+      getLayoutedNodes: withFailingElk,
+    } = require("../layoutUtils");
+
+    const nodes = ["ChatInput-a", "Prompt-b", "ChatOutput-c"].map(makeNode);
+    const edges = [makeHandlelessEdge("ChatInput-a", "Prompt-b")];
+
+    const layouted = await withFailingElk(nodes, edges);
+
+    // Resolves rather than rejecting, and every node is usable.
+    expect(layouted).toHaveLength(3);
+    expect(layouted.every(hasNumericPosition)).toBe(true);
+    expect(layouted).toEqual(freshFallback(nodes));
+  });
+});
+
 describe("processFlows on a flow with no positions", () => {
   const makeFlow = () =>
     ({

src/frontend/src/utils/reactflowUtils.ts

@@ -609,13 +609,13 @@ export const processFlows = (DbData: FlowType[], skipUpdate = true) => {
 };
 
 export const needsLayout = (nodes: AllNodeType[]) => {
+  // Number.isFinite does not coerce, so this also rejects non-numeric
+  // coordinates as well as NaN and ±Infinity.
   return nodes.some(
     (node) =>
       !node.position ||
-      typeof node.position.x !== "number" ||
-      typeof node.position.y !== "number" ||
-      Number.isNaN(node.position.x) ||
-      Number.isNaN(node.position.y),
+      !Number.isFinite(node.position.x) ||
+      !Number.isFinite(node.position.y),
   );
 };