test(a2ui-toolkit): de-flake deep child-chain cycle tests

The two deep-chain cycle tests in validate.test.ts intermittently tripped
vitest's 5000ms default timeout on CI (~5358ms), reddening the unit
workflow's typescript job repo-wide.

Root cause is not the validator: validateA2UIComponents on the 50k chain
runs in ~59ms (build 6ms + validate 53ms). findChildCycles is already a
linear, Set/Map-backed iterative DFS — no quadratic scan to fix. The
flake is GC/scheduling jitter: each test allocates ~150k objects (50k
components + 50k DFS frames + path/adjacency), and two such tests under
parallel-fork contention on a 2-vCPU runner stall on GC, inflating
wall-clock far past CPU time.

Fix (test-only — validator left untouched, it is optimal):
- N 50000 -> 20000 in both deep tests. V8's recursive overflow depth is
  ~8807 (trivial frame; lower for a real DFS frame), so 20k is still >2x
  past it and proves the walk is iterative, while cutting allocations
  2.5x to shrink the GC-stall window.
- Add an explicit 30000ms timeout to decouple the provably-fast
  assertion from CI runner scheduling jitter.

Toolkit suite: 84/84 pass, validate.test.ts ~103ms.

Author: ranst91

sdks/typescript/packages/a2ui-toolkit/src/__tests__/validate.test.ts

@@ -179,25 +179,39 @@ describe("validateA2UIComponents — child cycles", () => {
     expect(r.errors.some((e) => e.code === "child_cycle")).toBe(false);
   });
 
-  it("handles a pathologically deep child chain without overflowing the stack", () => {
-    // The cycle check runs on untrusted model output; a deep linear chain that
-    // would blow a recursive DFS's call stack must validate iteratively. 50k deep
-    // is well past V8's recursion limit but a no-op for the explicit-stack walk.
-    const N = 50000;
-    const comps: Array<Record<string, unknown>> = [{ id: "root", component: "Row", children: ["n0"] }];
-    for (let i = 0; i < N; i++) comps.push({ id: `n${i}`, component: "Row", children: i + 1 < N ? [`n${i + 1}`] : [] });
-    const r = validateA2UIComponents({ components: comps });
-    expect(r.errors.some((e) => e.code === "child_cycle")).toBe(false);
-  });
-
-  it("detects a cycle that closes at the end of a deep chain", () => {
-    // Same deep chain, but the tail points back at root — one cycle, no overflow.
-    const N = 50000;
-    const comps: Array<Record<string, unknown>> = [{ id: "root", component: "Row", children: ["n0"] }];
-    for (let i = 0; i < N; i++) comps.push({ id: `n${i}`, component: "Row", children: [i + 1 < N ? `n${i + 1}` : "root"] });
-    const r = validateA2UIComponents({ components: comps });
-    expect(r.errors.filter((e) => e.code === "child_cycle").length).toBe(1);
-  });
+  it(
+    "handles a pathologically deep child chain without overflowing the stack",
+    () => {
+      // The cycle check runs on untrusted model output; a deep linear chain that
+      // would blow a recursive DFS's call stack must validate iteratively. 20k deep
+      // is >2x V8's recursion overflow depth (~8.8k for a trivial frame, lower for
+      // a real DFS frame), so it still proves the walk is iterative — but allocates
+      // far less than 50k, keeping GC pressure (and thus the chance of a CI-runner
+      // stall) low. The explicit-stack walk itself is linear (~25ms for this N).
+      const N = 20000;
+      const comps: Array<Record<string, unknown>> = [{ id: "root", component: "Row", children: ["n0"] }];
+      for (let i = 0; i < N; i++) comps.push({ id: `n${i}`, component: "Row", children: i + 1 < N ? [`n${i + 1}`] : [] });
+      const r = validateA2UIComponents({ components: comps });
+      expect(r.errors.some((e) => e.code === "child_cycle")).toBe(false);
+    },
+    // The work is ~25ms; the default 5s timeout flaked under parallel-fork GC
+    // contention on shared CI runners. A generous explicit budget decouples the
+    // (provably fast) assertion from runner scheduling jitter.
+    30000,
+  );
+
+  it(
+    "detects a cycle that closes at the end of a deep chain",
+    () => {
+      // Same deep chain, but the tail points back at root — one cycle, no overflow.
+      const N = 20000;
+      const comps: Array<Record<string, unknown>> = [{ id: "root", component: "Row", children: ["n0"] }];
+      for (let i = 0; i < N; i++) comps.push({ id: `n${i}`, component: "Row", children: [i + 1 < N ? `n${i + 1}` : "root"] });
+      const r = validateA2UIComponents({ components: comps });
+      expect(r.errors.filter((e) => e.code === "child_cycle").length).toBe(1);
+    },
+    30000,
+  );
 });
 
 describe("validateA2UIComponents — data bindings", () => {