import { describe, expect, it } from "vitest";
import type { WorkflowDefinition } from "@fusion/core";
import { parseWorkflowIr } from "@fusion/core";
import type { Node as FlowNode } from "@xyflow/react";
import {
  irToFlow,
  flowToIr,
  insertFragment,
  fragmentSeamConflicts,
  copyIrWithFreshIds,
  columnsOf,
  columnForY,
  bandTop,
  columnsToBandNodes,
  isColumnBandNode,
  validateColumnsClient,
  unplacedNodeIds,
  foreachChildFlowId,
  templateNodeIdFromChild,
  shortConditionLabel,
  edgeClassName,
  edgeConditionEditability,
  wouldCreateCycle,
  buildConnectionEdge,
  cascadeDelete,
  COLUMN_BAND_HEIGHT,
  WF_CARD_WIDTH,
  WF_CARD_MAX_WIDTH,
  WF_CARD_HEIGHT,
  FOREACH_GROUP_WIDTH,
  FOREACH_GROUP_HEIGHT,
  FOREACH_CHILD_X,
  FOREACH_CHILD_Y,
} from "../workflow-flow-mapping";
import type { WorkflowFlowNodeData } from "../nodes/WorkflowNodeTypes";
import type { TraitCatalogEntry } from "../../api";

function makeDef(ir: WorkflowDefinition["ir"]): WorkflowDefinition {
  return {
    id: "WF-001",
    kind: "workflow",
    name: ir.name,
    description: "",
    ir,
    layout: {},
    createdAt: "2024-01-01T00:00:00.000Z",
    updatedAt: "2024-01-01T00:00:00.000Z",
  };
}

describe("workflow-flow-mapping name preservation", () => {
  it("does not inject synthetic names for unnamed start/end/merge nodes on round-trip", () => {
    const ir: WorkflowDefinition["ir"] = {
      version: "v1",
      name: "wf",
      nodes: [
        { id: "start", kind: "start" },
        { id: "n1", kind: "prompt", config: { prompt: "do work" } },
        { id: "m1", kind: "prompt", config: { seam: "merge" } },
        { id: "end", kind: "end" },
      ],
      edges: [
        { from: "start", to: "n1", condition: "success" },
        { from: "n1", to: "m1", condition: "success" },
        { from: "m1", to: "end", condition: "success" },
      ],
    };

    const { nodes, edges } = irToFlow(makeDef(ir));
    const { ir: out } = flowToIr("wf", nodes, edges);

    const byId = Object.fromEntries(out.nodes.map((n) => [n.id, n]));
    // start/end carry no config or a config without an injected name
    expect(byId.start.config?.name).toBeUndefined();
    expect(byId.end.config?.name).toBeUndefined();
    // merge boundary keeps its seam but does not gain a synthetic "Merge boundary" name
    expect(byId.m1.config?.seam).toBe("merge");
    expect(byId.m1.config?.name).toBeUndefined();
    // an unnamed prompt node keeps no synthetic id-as-name
    expect(byId.n1.config?.name).toBeUndefined();
    expect(byId.n1.config?.prompt).toBe("do work");
  });

  it("preserves an explicit node name across round-trips", () => {
    const ir: WorkflowDefinition["ir"] = {
      version: "v1",
      name: "wf",
      nodes: [
        { id: "start", kind: "start" },
        { id: "n1", kind: "prompt", config: { name: "Implement", prompt: "do work" } },
        { id: "end", kind: "end" },
      ],
      edges: [
        { from: "start", to: "n1", condition: "success" },
        { from: "n1", to: "end", condition: "success" },
      ],
    };

    const { nodes, edges } = irToFlow(makeDef(ir));
    const { ir: out } = flowToIr("wf", nodes, edges);
    const n1 = out.nodes.find((n) => n.id === "n1");
    expect(n1?.config?.name).toBe("Implement");
  });

  it("persists a user-entered label as the node name", () => {
    const ir: WorkflowDefinition["ir"] = {
      version: "v1",
      name: "wf",
      nodes: [
        { id: "start", kind: "start" },
        { id: "n1", kind: "prompt", config: { prompt: "do work" } },
        { id: "end", kind: "end" },
      ],
      edges: [
        { from: "start", to: "n1", condition: "success" },
        { from: "n1", to: "end", condition: "success" },
      ],
    };

    const { nodes, edges } = irToFlow(makeDef(ir));
    // Simulate the editor renaming the node via its label input.
    const renamed = nodes.map((n) =>
      n.id === "n1" ? { ...n, data: { ...n.data, label: "Build feature" } } : n,
    );
    const { ir: out } = flowToIr("wf", renamed, edges);
    const n1 = out.nodes.find((n) => n.id === "n1");
    expect(n1?.config?.name).toBe("Build feature");
  });
});

// ── U10: v2 round-trip (columns, placement, hold, split/join) ────────────────

const CATALOG: TraitCatalogEntry[] = [
  { id: "intake", name: "Intake", builtin: true, flags: { intake: true } },
  { id: "complete", name: "Complete", builtin: true, flags: { complete: true } },
  { id: "archived", name: "Archived", builtin: true, flags: { archived: true, hiddenFromBoard: true } },
  { id: "wip", name: "WIP", builtin: true, flags: { countsTowardWip: true } },
  { id: "hold", name: "Hold", builtin: true, flags: { hold: true } },
];

function v2Def(ir: WorkflowDefinition["ir"], layout: WorkflowDefinition["layout"] = {}): WorkflowDefinition {
  return { ...makeDef(ir), layout };
}

describe("workflow-flow-mapping v2 round-trip", () => {
  const ir: WorkflowDefinition["ir"] = {
    version: "v2",
    name: "wf2",
    columns: [
      { id: "triage", name: "Triage", traits: [{ trait: "intake" }] },
      { id: "in-progress", name: "In progress", traits: [{ trait: "wip", config: { limit: 2 } }] },
      { id: "done", name: "Done", traits: [{ trait: "complete" }] },
    ],
    nodes: [
      { id: "start", kind: "start", column: "triage" },
      { id: "h1", kind: "hold", column: "triage", config: { release: "manual" } },
      { id: "s1", kind: "split", column: "in-progress" },
      { id: "b1", kind: "prompt", column: "in-progress", config: { prompt: "lint" } },
      { id: "b2", kind: "prompt", column: "in-progress", config: { prompt: "test" } },
      { id: "j1", kind: "join", column: "in-progress", config: { mode: { quorum: 2 }, onBranchFailure: "fail-fast" } },
      { id: "end", kind: "end", column: "done" },
    ],
    edges: [
      { from: "start", to: "h1", condition: "success" },
      { from: "h1", to: "s1", condition: "success" },
      { from: "s1", to: "b1", condition: "success" },
      { from: "s1", to: "b2", condition: "success" },
      { from: "b1", to: "j1", condition: "success" },
      { from: "b2", to: "j1", condition: "success" },
      { from: "j1", to: "end", condition: "success" },
    ],
  };

  it("round-trips columns, placement, hold, and split/join config losslessly", () => {
    const { nodes, edges } = irToFlow(v2Def(ir));
    const columns = columnsOf(v2Def(ir));
    const { ir: out } = flowToIr("wf2", nodes, edges, columns);

    expect(out.version).toBe("v2");
    if (out.version !== "v2") return;

    // Columns preserved in order with their traits.
    expect(out.columns.map((c) => c.id)).toEqual(["triage", "in-progress", "done"]);
    expect(out.columns[1].traits).toEqual([{ trait: "wip", config: { limit: 2 } }]);

    const byId = Object.fromEntries(out.nodes.map((n) => [n.id, n]));
    // Placement preserved for every node.
    expect(byId.h1.column).toBe("triage");
    expect(byId.s1.column).toBe("in-progress");
    expect(byId.j1.column).toBe("in-progress");
    expect(byId.end.column).toBe("done");
    // Hold release config preserved.
    expect(byId.h1.config?.release).toBe("manual");
    // Split/join shape preserved.
    expect(byId.s1.kind).toBe("split");
    expect(byId.j1.kind).toBe("join");
    expect(byId.j1.config?.mode).toEqual({ quorum: 2 });
    expect(byId.j1.config?.onBranchFailure).toBe("fail-fast");
  });

  it("emits swimlane band group nodes that flowToIr strips back out", () => {
    const { nodes } = irToFlow(v2Def(ir));
    const bands = nodes.filter((n) => isColumnBandNode(n.id));
    expect(bands).toHaveLength(3);
    expect(bands.every((b) => b.type === "group")).toBe(true);
    // flowToIr must not emit band group nodes as IR nodes.
    const { ir: out } = flowToIr("wf2", nodes, [], columnsOf(v2Def(ir)));
    expect(out.nodes.some((n) => isColumnBandNode(n.id))).toBe(false);
  });

  it("derives node.column by position when a node is dropped into a band", () => {
    const columns = columnsOf(v2Def(ir));
    // Band index 2 = "done"; a node dragged to that band's y resolves to it.
    const yInDone = bandTop(2) + 40;
    expect(columnForY(yInDone, columns)).toBe("done");

    // Simulate a node moved into the "done" band with no explicit data.column.
    const stepNode: FlowNode<WorkflowFlowNodeData> = {
      id: "n9",
      type: "prompt",
      position: { x: 100, y: yInDone },
      data: { kind: "prompt", label: "ship", config: {} },
    };
    const bandNodes = columnsToBandNodes(columns);
    const { ir: out } = flowToIr("wf2", [...bandNodes, stepNode], [], columns);
    const n9 = out.version === "v2" ? out.nodes.find((n) => n.id === "n9") : undefined;
    expect(n9?.column).toBe("done");
  });

  it("v1 definitions map to empty columns (legacy round-trip stays v1)", () => {
    const v1: WorkflowDefinition["ir"] = {
      version: "v1",
      name: "wf",
      nodes: [
        { id: "start", kind: "start" },
        { id: "end", kind: "end" },
      ],
      edges: [{ from: "start", to: "end", condition: "success" }],
    };
    const def = makeDef(v1);
    expect(columnsOf(def)).toEqual([]);
    const { nodes, edges } = irToFlow(def);
    const { ir: out } = flowToIr("wf", nodes, edges, columnsOf(def));
    expect(out.version).toBe("v1");
  });
});

describe("workflow-flow-mapping validation helpers", () => {
  it("flags a trait conflict on the offending column", () => {
    const columns = [
      { id: "done", name: "Done", traits: [{ trait: "complete" }, { trait: "wip" }] },
    ];
    const violations = validateColumnsClient(columns, CATALOG);
    const conflict = violations.find((v) => v.code === "complete-with-wip");
    expect(conflict).toBeTruthy();
    expect(conflict?.columnId).toBe("done");
    expect(conflict?.severity).toBe("error");
  });

  it("flags more than one intake column workflow-wide", () => {
    const columns = [
      { id: "a", name: "A", traits: [{ trait: "intake" }] },
      { id: "b", name: "B", traits: [{ trait: "intake" }] },
    ];
    const v = validateColumnsClient(columns, CATALOG).find((x) => x.code === "multiple-intake-columns");
    expect(v?.columnId).toBeNull();
  });

  it("reports unplaced step nodes (not start/end, not bands)", () => {
    const columns = columnsOf(
      v2Def({
        version: "v2",
        name: "w",
        columns: [{ id: "c1", name: "C1", traits: [] }],
        nodes: [
          { id: "start", kind: "start" },
          { id: "end", kind: "end" },
        ],
        edges: [{ from: "start", to: "end", condition: "success" }],
      }),
    );
    const placed: FlowNode<WorkflowFlowNodeData> = {
      id: "p1",
      type: "prompt",
      position: { x: 0, y: bandTop(0) + 20 },
      data: { kind: "prompt", label: "x", config: {}, column: "c1" },
    };
    // A fresh node parked far below the single band (no explicit column) is
    // strictly outside every band → unplaced.
    const floating: FlowNode<WorkflowFlowNodeData> = {
      id: "float",
      type: "prompt",
      position: { x: 0, y: bandTop(0) + COLUMN_BAND_HEIGHT * 5 },
      data: { kind: "prompt", label: "y", config: {} },
    };
    const ids = unplacedNodeIds(
      [...columnsToBandNodes(columns), placed, floating,
        { id: "start", type: "start", position: { x: 0, y: 0 }, data: { kind: "start", label: "" } },
        { id: "end", type: "end", position: { x: 0, y: 0 }, data: { kind: "end", label: "" } },
      ],
      columns,
    );
    expect(ids).not.toContain("p1");
    expect(ids).not.toContain("start");
    expect(ids).not.toContain("end");
    expect(ids).toContain("float");
  });

  it("treats a node with an unknown column id as unplaced", () => {
    const columns = [{ id: "c1", name: "C1", traits: [] }];
    const ghost: FlowNode<WorkflowFlowNodeData> = {
      id: "ghost",
      type: "prompt",
      position: { x: 0, y: bandTop(0) },
      data: { kind: "prompt", label: "x", config: {}, column: "no-such-column" },
    };
    const ids = unplacedNodeIds([ghost], columns);
    expect(ids).toContain("ghost");
  });

  it("band height stays positive (geometry sanity)", () => {
    expect(COLUMN_BAND_HEIGHT).toBeGreaterThan(0);
  });
});

// ── U8: step-inversion round-trip (foreach template, rework edges) ───────────

describe("workflow-flow-mapping foreach + rework round-trip", () => {
  const ir: WorkflowDefinition["ir"] = {
    version: "v2",
    name: "stepwise",
    columns: [
      { id: "plan", name: "Plan", traits: [] },
      { id: "in-progress", name: "In progress", traits: [] },
      { id: "done", name: "Done", traits: [] },
    ],
    nodes: [
      { id: "start", kind: "start", column: "plan" },
      { id: "parse", kind: "parse-steps", column: "plan", config: { artifact: "PROMPT.md", parser: "step-headings" } },
      {
        id: "loop",
        kind: "foreach",
        column: "in-progress",
        config: {
          source: "task-steps",
          mode: "sequential",
          isolation: "shared",
          maxReworkCycles: 3,
          template: {
            nodes: [
              { id: "exec", kind: "prompt", config: { seam: "step-execute", prompt: "do step" } },
              { id: "review", kind: "step-review", config: { type: "code" } },
            ],
            edges: [
              { from: "exec", to: "review", condition: "success" },
              { from: "review", to: "exec", condition: "outcome:revise", kind: "rework" },
            ],
          },
        },
      },
      { id: "end", kind: "end", column: "done" },
    ],
    edges: [
      { from: "start", to: "parse", condition: "success" },
      { from: "parse", to: "loop", condition: "success" },
      { from: "loop", to: "end", condition: "success" },
    ],
  };

  it("round-trips foreach template (children partitioned by parentId) losslessly", () => {
    const def = makeDef(ir);
    const { nodes, edges } = irToFlow(def);
    const columns = columnsOf(def);

    // The foreach group + its two template children render as parented nodes.
    const group = nodes.find((n) => n.id === "loop");
    expect(group?.type).toBe("foreach");
    const children = nodes.filter((n) => n.parentId === "loop");
    expect(children.map((c) => c.id).sort()).toEqual(
      [foreachChildFlowId("loop", "exec"), foreachChildFlowId("loop", "review")].sort(),
    );
    // Template edges (incl. the rework edge) live inside the group's id-scope.
    const reworkFlowEdge = edges.find((e) => e.data?.kind === "rework");
    expect(reworkFlowEdge).toBeTruthy();
    expect(reworkFlowEdge?.source).toBe(foreachChildFlowId("loop", "review"));

    const { ir: out } = flowToIr("stepwise", nodes, edges, columns);
    if (out.version !== "v2") throw new Error("expected v2");
    const loop = out.nodes.find((n) => n.id === "loop");
    expect(loop?.kind).toBe("foreach");
    const cfg = loop?.config as Record<string, unknown>;
    expect(cfg.source).toBe("task-steps");
    expect(cfg.mode).toBe("sequential");
    expect(cfg.maxReworkCycles).toBe(3);
    const template = cfg.template as { nodes: unknown[]; edges: { from: string; to: string; condition?: string; kind?: string }[] };
    // Template node ids are template-local (de-namespaced), not flow ids.
    expect((template.nodes as { id: string }[]).map((n) => n.id).sort()).toEqual(["exec", "review"]);
    // The rework edge survives with its kind and outcome condition.
    const rework = template.edges.find((e) => e.kind === "rework");
    expect(rework).toEqual({ from: "review", to: "exec", condition: "outcome:revise", kind: "rework" });
    // The plain success edge has no kind.
    const success = template.edges.find((e) => e.condition === "success");
    expect(success?.kind).toBeUndefined();
    // Top-level edges exclude the intra-template ones.
    expect(out.edges.map((e) => `${e.from}->${e.to}`)).toEqual([
      "start->parse",
      "parse->loop",
      "loop->end",
    ]);
    // parse-steps config preserved.
    const parse = out.nodes.find((n) => n.id === "parse");
    expect(parse?.config).toMatchObject({ artifact: "PROMPT.md", parser: "step-headings" });
  });

  it("round-trips loop templates through parented group children", () => {
    const loopIr: WorkflowDefinition["ir"] = {
      version: "v2",
      name: "bounded-loop",
      columns: ir.columns,
      nodes: [
        { id: "start", kind: "start", column: "plan" },
        {
          id: "retry",
          kind: "loop",
          column: "in-progress",
          config: {
            maxIterations: 4,
            timeoutMs: 60000,
            exitWhen: { type: "output-matches", nodeId: "check", pattern: "DONE|COMPLETE" },
            template: {
              nodes: [
                { id: "try", kind: "prompt", config: { prompt: "try once" } },
                { id: "check", kind: "gate", config: { prompt: "done?" } },
              ],
              edges: [{ from: "try", to: "check", condition: "success" }],
            },
          },
        },
        { id: "end", kind: "end", column: "done" },
      ],
      edges: [
        { from: "start", to: "retry", condition: "success" },
        { from: "retry", to: "end", condition: "success" },
      ],
    };
    const { nodes, edges } = irToFlow(makeDef(loopIr));

    const group = nodes.find((n) => n.id === "retry");
    expect(group?.type).toBe("loop");
    expect(group?.data.kind).toBe("loop");
    expect(nodes.filter((n) => n.parentId === "retry").map((n) => templateNodeIdFromChild("retry", n.id))).toEqual([
      "try",
      "check",
    ]);

    const { ir: out } = flowToIr("bounded-loop", nodes, edges, columnsOf(makeDef(loopIr)));
    if (out.version !== "v2") throw new Error("expected v2");
    const retry = out.nodes.find((n) => n.id === "retry");
    expect(retry?.kind).toBe("loop");
    expect(retry?.config).toMatchObject({
      maxIterations: 4,
      timeoutMs: 60000,
      exitWhen: { type: "output-matches", nodeId: "check", pattern: "DONE|COMPLETE" },
    });
    const template = retry?.config?.template as { nodes: { id: string }[]; edges: { from: string; to: string }[] };
    expect(template.nodes.map((n) => n.id)).toEqual(["try", "check"]);
    expect(template.edges).toEqual([{ from: "try", to: "check", condition: "success" }]);
  });

  it("inserts loop fragments with their template children intact", () => {
    const fragment: WorkflowDefinition["ir"] = {
      version: "v2",
      name: "fragment",
      columns: ir.columns,
      nodes: [
        { id: "start", kind: "start" },
        {
          id: "retry",
          kind: "loop",
          config: {
            maxIterations: 2,
            exitWhen: { type: "output-contains", value: "DONE" },
            template: {
              nodes: [{ id: "try", kind: "prompt", config: { prompt: "again" } }],
              edges: [],
            },
          },
        },
        { id: "end", kind: "end" },
      ],
      edges: [
        { from: "start", to: "retry" },
        { from: "retry", to: "end" },
      ],
    };
    const inserted = insertFragment([], [], parseWorkflowIr(fragment), { x: 10, y: 20 }, {
      [foreachChildFlowId("retry", "try")]: { x: 86, y: 132 },
    });
    const group = inserted.nodes.find((n) => n.data.kind === "loop");
    const child = inserted.nodes.find((n) => n.parentId === group?.id);

    expect(group).toBeTruthy();
    expect(group?.type).toBe("loop");
    expect(child?.position).toEqual({ x: 86, y: 132 });
    expect(inserted.nodes.filter((n) => n.parentId === group?.id)).toHaveLength(1);
    expect(inserted.edges).toHaveLength(0);
  });

  it("round-trips a code node config (source + timeoutMs)", () => {
    const codeIr: WorkflowDefinition["ir"] = {
      version: "v1",
      name: "wf",
      nodes: [
        { id: "start", kind: "start" },
        { id: "c1", kind: "code", config: { source: "export default async()=>({})", timeoutMs: 5000 } },
        { id: "end", kind: "end" },
      ],
      edges: [
        { from: "start", to: "c1", condition: "success" },
        { from: "c1", to: "end", condition: "success" },
      ],
    };
    const { nodes, edges } = irToFlow(makeDef(codeIr));
    const { ir: out } = flowToIr("wf", nodes, edges);
    const c1 = out.nodes.find((n) => n.id === "c1");
    expect(c1?.kind).toBe("code");
    expect(c1?.config).toMatchObject({ source: "export default async()=>({})", timeoutMs: 5000 });
  });

  it("child id namespacing helpers are inverse", () => {
    const fid = foreachChildFlowId("loop", "exec");
    expect(templateNodeIdFromChild("loop", fid)).toBe("exec");
    // A non-namespaced id passes through unchanged.
    expect(templateNodeIdFromChild("loop", "other")).toBe("other");
  });

  it("shortens outcome:<verdict> edge labels", () => {
    expect(shortConditionLabel("outcome:approve")).toBe("approve");
    expect(shortConditionLabel("success")).toBe("success");
  });

  it("does not flag foreach template children as unplaced", () => {
    const def = makeDef(ir);
    const { nodes } = irToFlow(def);
    const columns = columnsOf(def);
    const ids = unplacedNodeIds(nodes, columns);
    expect(ids).not.toContain(foreachChildFlowId("loop", "exec"));
    expect(ids).not.toContain(foreachChildFlowId("loop", "review"));
  });
});

describe("card dimension constants (U1)", () => {
  it("card max width is at least the nominal card width", () => {
    expect(WF_CARD_MAX_WIDTH).toBeGreaterThanOrEqual(WF_CARD_WIDTH);
  });

  it("a child card fits inside the foreach group with padding", () => {
    // Child offset + card max dimensions must stay inside the group box so a
    // card never overflows or gets clamped by extent:"parent".
    expect(FOREACH_CHILD_X + WF_CARD_MAX_WIDTH).toBeLessThanOrEqual(FOREACH_GROUP_WIDTH);
    expect(FOREACH_CHILD_Y + WF_CARD_HEIGHT).toBeLessThanOrEqual(FOREACH_GROUP_HEIGHT);
  });
});

describe("edge-condition authoring (U2)", () => {
  it("round-trips a failure condition through flowToIr → irToFlow with class + label", () => {
    const ir: WorkflowDefinition["ir"] = {
      version: "v1",
      name: "wf",
      nodes: [
        { id: "start", kind: "start" },
        { id: "n1", kind: "prompt", config: { prompt: "do" } },
        { id: "ok", kind: "prompt", config: { prompt: "ok" } },
        { id: "bad", kind: "prompt", config: { prompt: "bad" } },
        { id: "end", kind: "end" },
      ],
      edges: [
        { from: "start", to: "n1", condition: "success" },
        { from: "n1", to: "ok", condition: "success" },
        { from: "n1", to: "bad", condition: "failure" },
        { from: "ok", to: "end", condition: "success" },
        { from: "bad", to: "end", condition: "success" },
      ],
    };
    const { nodes, edges } = irToFlow(makeDef(ir));
    const failFlow = edges.find((e) => e.source === "n1" && e.target === "bad")!;
    expect(failFlow.data?.condition).toBe("failure");
    expect(failFlow.label).toBe("failure");
    expect(failFlow.className).toBe("wf-edge-failure");

    const { ir: out } = flowToIr("wf", nodes, edges);
    const irFail = out.edges.find((e) => e.from === "n1" && e.to === "bad");
    expect(irFail?.condition).toBe("failure");
  });

  it("preserves parallel success+failure edges between the same pair through the round-trip", () => {
    const flowNodes: FlowNode<WorkflowFlowNodeData>[] = [
      { id: "a", type: "prompt", position: { x: 0, y: 0 }, data: { kind: "prompt", label: "a" } },
      { id: "b", type: "prompt", position: { x: 100, y: 0 }, data: { kind: "prompt", label: "b" } },
    ];
    const flowEdges = [
      { id: "e-1", source: "a", target: "b", data: { condition: "success" } },
      { id: "e-2", source: "a", target: "b", data: { condition: "failure" } },
    ];
    const { ir } = flowToIr("wf", flowNodes, flowEdges);
    expect(ir.edges).toHaveLength(2);
    expect(ir.edges.map((e) => e.condition).sort()).toEqual(["failure", "success"]);

    const { edges: reFlow } = irToFlow(makeDef(ir));
    expect(reFlow).toHaveLength(2);
    const ids = new Set(reFlow.map((e) => e.id));
    expect(ids.size).toBe(2);
  });

  it("edgeClassName: failure → wf-edge-failure, rework precedence, success → undefined", () => {
    expect(edgeClassName("failure", false)).toBe("wf-edge-failure");
    expect(edgeClassName("success", false)).toBeUndefined();
    expect(edgeClassName("failure", true)).toBe("wf-edge-rework");
  });

  it("edgeConditionEditability gates by source kind (KTD-2)", () => {
    expect(edgeConditionEditability("step-review")).toBe("verdicts");
    expect(edgeConditionEditability("prompt")).toBe("conditions");
    expect(edgeConditionEditability("script")).toBe("conditions");
    expect(edgeConditionEditability("gate")).toBe("conditions");
    expect(edgeConditionEditability("code")).toBe("conditions");
    expect(edgeConditionEditability("foreach")).toBe("conditions");
    expect(edgeConditionEditability("split")).toBe("readonly");
    expect(edgeConditionEditability("parse-steps")).toBe("readonly");
    expect(edgeConditionEditability("start")).toBe("readonly");
    expect(edgeConditionEditability(undefined)).toBe("readonly");
  });

  it("wouldCreateCycle detects back-edges and ignores forward + rework edges", () => {
    const chain = [
      { id: "1", source: "a", target: "b", data: { condition: "success" } },
      { id: "2", source: "b", target: "c", data: { condition: "success" } },
    ];
    // c → a closes the loop a→b→c→a.
    expect(wouldCreateCycle(chain, "c", "a")).toBe(true);
    // a → c is forward, no cycle.
    expect(wouldCreateCycle(chain, "a", "c")).toBe(false);
    // self-loop.
    expect(wouldCreateCycle(chain, "a", "a")).toBe(true);

    // rework edges are excluded from the reachability walk.
    const withRework = [
      { id: "1", source: "a", target: "b", data: { condition: "success" } },
      { id: "2", source: "b", target: "c", data: { condition: "success", kind: "rework" } },
    ];
    // c only reachable from b via a rework edge, so c→a is NOT a (non-rework) cycle.
    expect(wouldCreateCycle(withRework, "c", "a")).toBe(false);
  });

  it("buildConnectionEdge: builds a success edge, rejects missing endpoints, duplicates, cycles", () => {
    const nodes: FlowNode<WorkflowFlowNodeData>[] = [
      { id: "a", type: "prompt", position: { x: 0, y: 0 }, data: { kind: "prompt", label: "a" } },
      { id: "b", type: "prompt", position: { x: 100, y: 0 }, data: { kind: "prompt", label: "b" } },
      { id: "c", type: "prompt", position: { x: 200, y: 0 }, data: { kind: "prompt", label: "c" } },
    ];
    const edges = [
      { id: "1", source: "a", target: "b", data: { condition: "success" } },
      { id: "2", source: "b", target: "c", data: { condition: "success" } },
    ];

    // happy path: new success edge with a unique id + interactionWidth.
    const ok = buildConnectionEdge({ source: "a", target: "c" }, edges, nodes);
    expect("edge" in ok).toBe(true);
    if ("edge" in ok) {
      expect(ok.edge.data?.condition).toBe("success");
      expect(ok.edge.label).toBe("success");
      expect(ok.edge.interactionWidth).toBeGreaterThan(0);
      expect(typeof ok.edge.id).toBe("string");
    }

    // missing endpoint.
    expect(buildConnectionEdge({ source: "a", target: null }, edges, nodes)).toEqual({
      error: "missing-endpoint",
    });

    // second connect of an existing success pair (prompt source supports
    // conditions) → births the parallel failure edge rather than rejecting.
    const failureBirth = buildConnectionEdge({ source: "a", target: "b" }, edges, nodes);
    expect("edge" in failureBirth).toBe(true);
    if ("edge" in failureBirth) {
      expect(failureBirth.edge.data?.condition).toBe("failure");
    }

    // once BOTH success and failure exist, a third connect is a duplicate.
    const bothConditions = [
      ...edges,
      { id: "3", source: "a", target: "b", data: { condition: "failure" } },
    ];
    expect(buildConnectionEdge({ source: "a", target: "b" }, bothConditions, nodes)).toEqual({
      error: "duplicate",
    });

    // a source kind that does NOT support conditions stays a hard duplicate.
    const readonlyNodes: FlowNode<WorkflowFlowNodeData>[] = [
      { id: "a", type: "start", position: { x: 0, y: 0 }, data: { kind: "start", label: "a" } },
      { id: "b", type: "prompt", position: { x: 100, y: 0 }, data: { kind: "prompt", label: "b" } },
    ];
    expect(
      buildConnectionEdge(
        { source: "a", target: "b" },
        [{ id: "1", source: "a", target: "b", data: { condition: "success" } }],
        readonlyNodes,
      ),
    ).toEqual({ error: "duplicate" });

    // cycle: c→a closes a→b→c→a.
    expect(buildConnectionEdge({ source: "c", target: "a" }, edges, nodes)).toEqual({
      error: "cycle",
    });
  });

  it("buildConnectionEdge exempts intra-foreach-template connections from the cycle guard", () => {
    const nodes: FlowNode<WorkflowFlowNodeData>[] = [
      { id: "g", type: "foreach", position: { x: 0, y: 0 }, data: { kind: "foreach", label: "g" } },
      { id: "g::a", type: "prompt", position: { x: 0, y: 0 }, parentId: "g", data: { kind: "prompt", label: "a" } },
      { id: "g::b", type: "prompt", position: { x: 0, y: 0 }, parentId: "g", data: { kind: "prompt", label: "b" } },
    ];
    const edges = [{ id: "1", source: "g::a", target: "g::b", data: { condition: "success" } }];
    // b→a would be a cycle, but both are children of the same group → allowed.
    const res = buildConnectionEdge({ source: "g::b", target: "g::a" }, edges, nodes);
    expect("edge" in res).toBe(true);
  });
});

describe("cascadeDelete (U3, R6)", () => {
  // start → a → b → c → end (a/b/c are prompt nodes), so deleting a mid-chain
  // node must drop its two incident edges with no bridge created.
  const chainDef = (): WorkflowDefinition =>
    makeDef({
      version: "v1",
      name: "chain",
      nodes: [
        { id: "start", kind: "start" },
        { id: "a", kind: "prompt", config: { prompt: "a" } },
        { id: "b", kind: "prompt", config: { prompt: "b" } },
        { id: "c", kind: "prompt", config: { prompt: "c" } },
        { id: "end", kind: "end" },
      ],
      edges: [
        { from: "start", to: "a", condition: "success" },
        { from: "a", to: "b", condition: "success" },
        { from: "b", to: "c", condition: "success" },
        { from: "c", to: "end", condition: "success" },
      ],
    });

  it("deletes a mid-chain node + both incident edges, with NO bridge edge", () => {
    const { nodes, edges } = irToFlow(chainDef());
    const bEdge = edges.find((e) => e.source === "a" && e.target === "b")!;
    const result = cascadeDelete(nodes, edges, [/* node */ "b"]);
    expect(result.nodes.find((n) => n.id === "b")).toBeUndefined();
    // Both incident edges (a→b and b→c) are gone.
    expect(result.edges.find((e) => e.source === "a" && e.target === "b")).toBeUndefined();
    expect(result.edges.find((e) => e.source === "b" && e.target === "c")).toBeUndefined();
    // No auto-bridge a→c.
    expect(result.edges.find((e) => e.source === "a" && e.target === "c")).toBeUndefined();
    // Untouched edges survive.
    expect(result.edges.find((e) => e.source === "start" && e.target === "a")).toBeTruthy();
    expect(result.edges.find((e) => e.source === "c" && e.target === "end")).toBeTruthy();
    void bEdge;
  });

  // A foreach group with two template children (exec → review, review → exec
  // rework), plus top-level edges parse→loop→end.
  const foreachDef = (): WorkflowDefinition =>
    makeDef({
      version: "v1",
      name: "loopwf",
      nodes: [
        { id: "start", kind: "start" },
        {
          id: "loop",
          kind: "foreach",
          config: {
            source: "task-steps",
            template: {
              nodes: [
                { id: "exec", kind: "prompt", config: { seam: "step-execute", prompt: "do" } },
                { id: "review", kind: "step-review", config: { type: "code" } },
              ],
              edges: [
                { from: "exec", to: "review", condition: "success" },
                { from: "review", to: "exec", condition: "outcome:revise", kind: "rework" },
              ],
            },
          },
        },
        { id: "end", kind: "end" },
      ],
      edges: [
        { from: "start", to: "loop", condition: "success" },
        { from: "loop", to: "end", condition: "success" },
      ],
    });

  it("deleting a foreach group removes the group + children + template edges + incident edges", () => {
    const { nodes, edges } = irToFlow(foreachDef());
    const execId = foreachChildFlowId("loop", "exec");
    const reviewId = foreachChildFlowId("loop", "review");
    // Sanity: children + their template edges exist before delete.
    expect(nodes.find((n) => n.id === execId)).toBeTruthy();
    expect(edges.some((e) => e.source === execId && e.target === reviewId)).toBe(true);

    const result = cascadeDelete(nodes, edges, ["loop"]);
    // Group + both children gone.
    expect(result.nodes.find((n) => n.id === "loop")).toBeUndefined();
    expect(result.nodes.find((n) => n.id === execId)).toBeUndefined();
    expect(result.nodes.find((n) => n.id === reviewId)).toBeUndefined();
    // Intra-template edges gone.
    expect(result.edges.some((e) => e.source === execId || e.target === execId)).toBe(false);
    expect(result.edges.some((e) => e.source === reviewId || e.target === reviewId)).toBe(false);
    // The group's own incident edges (start→loop, loop→end) gone.
    expect(result.edges.some((e) => e.source === "loop" || e.target === "loop")).toBe(false);
    // start and end nodes survive.
    expect(result.nodes.find((n) => n.id === "start")).toBeTruthy();
    expect(result.nodes.find((n) => n.id === "end")).toBeTruthy();
  });

  it("deleting only a template child removes the child + its edges, leaving the group", () => {
    const { nodes, edges } = irToFlow(foreachDef());
    const execId = foreachChildFlowId("loop", "exec");
    const reviewId = foreachChildFlowId("loop", "review");

    const result = cascadeDelete(nodes, edges, [execId]);
    // The exec child is gone; the group + sibling remain.
    expect(result.nodes.find((n) => n.id === execId)).toBeUndefined();
    expect(result.nodes.find((n) => n.id === "loop")).toBeTruthy();
    expect(result.nodes.find((n) => n.id === reviewId)).toBeTruthy();
    // Edges touching exec (both directions) are gone.
    expect(result.edges.some((e) => e.source === execId || e.target === execId)).toBe(false);
  });

  it("never deletes start/end nodes (and preserves their edges)", () => {
    const { nodes, edges } = irToFlow(chainDef());
    const result = cascadeDelete(nodes, edges, ["start", "end"]);
    expect(result.nodes.find((n) => n.id === "start")).toBeTruthy();
    expect(result.nodes.find((n) => n.id === "end")).toBeTruthy();
    // Their incident edges survive too (start→a, c→end).
    expect(result.edges.some((e) => e.source === "start")).toBe(true);
    expect(result.edges.some((e) => e.target === "end")).toBe(true);
    // Nothing was removed at all.
    expect(result.nodes).toHaveLength(nodes.length);
    expect(result.edges).toHaveLength(edges.length);
  });

  it("never deletes column band nodes", () => {
    const v2: WorkflowDefinition["ir"] = {
      version: "v2",
      name: "wf",
      columns: [{ id: "col1", name: "Col 1", traits: [] }],
      nodes: [
        { id: "start", kind: "start", column: "col1" },
        { id: "end", kind: "end", column: "col1" },
      ],
      edges: [{ from: "start", to: "end", condition: "success" }],
    };
    const { nodes, edges } = irToFlow(makeDef(v2));
    const bandId = nodes.find((n) => isColumnBandNode(n.id))!.id;
    const result = cascadeDelete(nodes, edges, [bandId]);
    expect(result.nodes.find((n) => n.id === bandId)).toBeTruthy();
  });

  it("deletes an edge id directly, removing just that edge", () => {
    const { nodes, edges } = irToFlow(chainDef());
    const target = edges.find((e) => e.source === "b" && e.target === "c")!;
    const result = cascadeDelete(nodes, edges, [target.id]);
    expect(result.edges.find((e) => e.id === target.id)).toBeUndefined();
    // No nodes removed, all other edges intact.
    expect(result.nodes).toHaveLength(nodes.length);
    expect(result.edges).toHaveLength(edges.length - 1);
  });
});

// ── Fragment insertion + graph copy (U8, R7/R8) ──────────────────────────────

/** start → a → b → c → end (top-level scope, reused by the U8 suites). */
const u8ChainDef = (): WorkflowDefinition =>
  makeDef({
    version: "v1",
    name: "chain",
    nodes: [
      { id: "start", kind: "start" },
      { id: "a", kind: "prompt", config: { prompt: "a" } },
      { id: "b", kind: "prompt", config: { prompt: "b" } },
      { id: "c", kind: "prompt", config: { prompt: "c" } },
      { id: "end", kind: "end" },
    ],
    edges: [
      { from: "start", to: "a", condition: "success" },
      { from: "a", to: "b", condition: "success" },
      { from: "b", to: "c", condition: "success" },
      { from: "c", to: "end", condition: "success" },
    ],
  });

/** A small fragment IR: start → a → b → end, b carries a merge seam + name. */
function fragmentIr(): WorkflowDefinition["ir"] {
  return {
    version: "v1",
    name: "frag",
    nodes: [
      { id: "start", kind: "start" },
      { id: "a", kind: "prompt", config: { prompt: "do a", name: "Step A" } },
      { id: "b", kind: "prompt", config: { seam: "merge", name: "Merge" } },
      { id: "end", kind: "end" },
    ],
    edges: [
      { from: "start", to: "a", condition: "success" },
      { from: "a", to: "b", condition: "failure" },
      { from: "b", to: "end", condition: "success" },
    ],
  };
}

describe("insertFragment", () => {
  it("strips start/end, remaps every node id, preserves internal edges/config/conditions", () => {
    const existing = irToFlow(u8ChainDef());
    const before = new Set(existing.nodes.map((n) => n.id));
    const { nodes, edges, insertedNodeIds } = insertFragment(
      existing.nodes,
      existing.edges,
      fragmentIr(),
      { x: 500, y: 200 },
    );

    // Two body nodes inserted (start/end stripped).
    expect(insertedNodeIds).toHaveLength(2);
    expect(nodes).toHaveLength(existing.nodes.length + 2);

    // Inserted ids are fresh (disjoint from existing) and not the fragment's.
    for (const id of insertedNodeIds) {
      expect(before.has(id)).toBe(false);
      expect(["start", "a", "b", "end"]).not.toContain(id);
    }

    const inserted = nodes.filter((n) => insertedNodeIds.includes(n.id));
    // No start/end among inserted nodes.
    expect(inserted.some((n) => n.data.kind === "start" || n.data.kind === "end")).toBe(false);
    // Config preserved: the merge node keeps its seam; the prompt keeps its prompt.
    const merge = inserted.find((n) => n.data.kind === "merge")!;
    expect(merge.data.config?.seam).toBe("merge");
    const promptNode = inserted.find((n) => n.data.config?.prompt === "do a")!;
    expect(promptNode).toBeTruthy();

    // Only the single internal a→b edge survives (start→a, b→end stripped).
    const newEdges = edges.slice(existing.edges.length);
    expect(newEdges).toHaveLength(1);
    const e = newEdges[0];
    expect(insertedNodeIds).toContain(e.source);
    expect(insertedNodeIds).toContain(e.target);
    // Edge condition preserved.
    expect(e.data?.condition).toBe("failure");

    // Inputs not mutated.
    expect(existing.nodes).toHaveLength(before.size);
  });

  it("positions inserted nodes near the requested position", () => {
    const existing = irToFlow(u8ChainDef());
    const { nodes, insertedNodeIds } = insertFragment(
      existing.nodes,
      existing.edges,
      fragmentIr(),
      { x: 500, y: 200 },
    );
    const inserted = nodes.filter((n) => insertedNodeIds.includes(n.id));
    for (const n of inserted) {
      expect(n.position.x).toBeGreaterThanOrEqual(500);
      expect(n.position.y).toBeGreaterThanOrEqual(200);
      expect(n.position.y).toBeLessThan(500);
    }
  });

  it("double-insert of the same fragment yields two disjoint id sets", () => {
    const existing = irToFlow(u8ChainDef());
    const first = insertFragment(existing.nodes, existing.edges, fragmentIr(), { x: 500, y: 200 });
    const second = insertFragment(first.nodes, first.edges, fragmentIr(), { x: 800, y: 200 });
    const setA = new Set(first.insertedNodeIds);
    for (const id of second.insertedNodeIds) expect(setA.has(id)).toBe(false);
    // All ids across the graph are unique.
    const allIds = second.nodes.map((n) => n.id);
    expect(new Set(allIds).size).toBe(allIds.length);
  });

  it("expands a foreach fragment's template so flowToIr round-trips the full template", () => {
    // Fragment: start → loop(foreach with a 2-node template) → end.
    const foreachFragment: WorkflowDefinition["ir"] = {
      version: "v1",
      name: "frag",
      nodes: [
        { id: "start", kind: "start" },
        {
          id: "loop",
          kind: "foreach",
          config: {
            source: "task-steps",
            template: {
              nodes: [
                { id: "t1", kind: "prompt", config: { prompt: "inner1" } },
                { id: "t2", kind: "prompt", config: { prompt: "inner2" } },
              ],
              edges: [{ from: "t1", to: "t2", condition: "success" }],
            },
          },
        },
        { id: "end", kind: "end" },
      ],
      edges: [
        { from: "start", to: "loop", condition: "success" },
        { from: "loop", to: "end", condition: "success" },
      ],
    };

    const existing = irToFlow(u8ChainDef());
    const { nodes, edges, insertedNodeIds } = insertFragment(
      existing.nodes,
      existing.edges,
      foreachFragment,
      { x: 400, y: 200 },
    );

    // The foreach group's template children were expanded as parented nodes.
    const groupId = insertedNodeIds[0];
    const children = nodes.filter((n) => n.parentId === groupId);
    expect(children).toHaveLength(2);

    // Round-trip the live canvas back to IR — the inserted foreach must carry its
    // full template (not an empty one) with both inner nodes and the inner edge.
    const { ir: out } = flowToIr("wf", nodes, edges);
    const loop = out.nodes.find((n) => n.kind === "foreach")!;
    expect(loop).toBeTruthy();
    const template = (loop.config as { template?: { nodes: unknown[]; edges: unknown[] } })
      .template;
    expect(template?.nodes).toHaveLength(2);
    expect(template?.edges).toHaveLength(1);
  });
});

describe("fragmentSeamConflicts", () => {
  it("flags a merge seam present in both fragment and canvas", () => {
    // Canvas containing a merge node.
    const canvas = irToFlow(
      makeDef({
        version: "v1",
        name: "wf",
        nodes: [
          { id: "start", kind: "start" },
          { id: "m", kind: "prompt", config: { seam: "merge" } },
          { id: "end", kind: "end" },
        ],
        edges: [
          { from: "start", to: "m", condition: "success" },
          { from: "m", to: "end", condition: "success" },
        ],
      }),
    );
    expect(fragmentSeamConflicts(fragmentIr(), canvas.nodes)).toEqual(["merge"]);
  });

  it("returns [] when the canvas has no overlapping seam", () => {
    const canvas = irToFlow(u8ChainDef());
    expect(fragmentSeamConflicts(fragmentIr(), canvas.nodes)).toEqual([]);
  });

  it("treats the editor 'merge' node kind as the merge seam on the canvas", () => {
    // Canvas node has no config.seam but is rendered as a merge node.
    const canvas: FlowNode<WorkflowFlowNodeData>[] = [
      {
        id: "x",
        type: "merge",
        position: { x: 0, y: 0 },
        data: { kind: "merge", label: "Merge boundary" },
      },
    ];
    expect(fragmentSeamConflicts(fragmentIr(), canvas)).toEqual(["merge"]);
  });
});

describe("copyIrWithFreshIds", () => {
  function v2WithForeach(): WorkflowDefinition["ir"] {
    return {
      version: "v2",
      name: "wf",
      columns: [{ id: "in-progress", name: "In Progress", traits: [] }],
      nodes: [
        { id: "start", kind: "start", column: "in-progress" },
        {
          id: "loop",
          kind: "foreach",
          column: "in-progress",
          config: {
            source: "task-steps",
            template: {
              nodes: [
                { id: "t1", kind: "prompt", config: { prompt: "inner" } },
                { id: "t2", kind: "prompt", config: { prompt: "inner2" } },
              ],
              edges: [{ from: "t1", to: "t2", condition: "success" }],
            },
          },
        },
        { id: "end", kind: "end", column: "in-progress" },
      ],
      edges: [
        { from: "start", to: "loop", condition: "success" },
        { from: "loop", to: "end", condition: "success" },
      ],
    };
  }

  it("preserves structure but remaps all node ids; layout keys remapped consistently", () => {
    const ir = u8ChainDef().ir;
    const layout = { start: { x: 0, y: 0 }, a: { x: 100, y: 0 }, b: { x: 200, y: 0 }, c: { x: 300, y: 0 }, end: { x: 400, y: 0 } };
    const result = copyIrWithFreshIds(ir, layout);

    // Same counts + kinds.
    expect(result.ir.nodes).toHaveLength(ir.nodes.length);
    expect(result.ir.edges).toHaveLength(ir.edges.length);
    expect(result.ir.nodes.map((n) => n.kind)).toEqual(ir.nodes.map((n) => n.kind));

    // All new ids, disjoint from originals.
    const origIds = new Set(ir.nodes.map((n) => n.id));
    for (const n of result.ir.nodes) expect(origIds.has(n.id)).toBe(false);

    // Edges reference only new ids.
    const newIds = new Set(result.ir.nodes.map((n) => n.id));
    for (const e of result.ir.edges) {
      expect(newIds.has(e.from)).toBe(true);
      expect(newIds.has(e.to)).toBe(true);
    }

    // Layout keys remapped consistently: same value set, all keys are new ids.
    expect(Object.keys(result.layout)).toHaveLength(Object.keys(layout).length);
    for (const key of Object.keys(result.layout)) expect(newIds.has(key)).toBe(true);

    // Original inputs untouched.
    expect(ir.nodes[0].id).toBe("start");
    expect(layout.start).toEqual({ x: 0, y: 0 });

    // The copy is a valid IR (value import works under the test-runner alias).
    const parsed = parseWorkflowIr(result.ir);
    expect(parsed.nodes).toHaveLength(ir.nodes.length);
  });

  it("remaps foreach template node ids + edges, preserving columns", () => {
    const ir = v2WithForeach();
    const result = copyIrWithFreshIds(ir, {});
    const loop = result.ir.nodes.find((n) => n.kind === "foreach")!;
    const template = (loop.config as { template: { nodes: { id: string; kind: string }[]; edges: { from: string; to: string }[] } }).template;

    // Template node ids are remapped (not the originals t1/t2).
    expect(template.nodes.map((n) => n.id)).not.toEqual(["t1", "t2"]);
    expect(template.nodes.map((n) => n.kind)).toEqual(["prompt", "prompt"]);

    // Template edges reference the remapped template ids.
    const tIds = new Set(template.nodes.map((n) => n.id));
    expect(template.edges).toHaveLength(1);
    expect(tIds.has(template.edges[0].from)).toBe(true);
    expect(tIds.has(template.edges[0].to)).toBe(true);

    // Columns preserved untouched.
    expect(result.ir.version).toBe("v2");
    if (result.ir.version === "v2") {
      expect(result.ir.columns).toEqual(ir.columns);
      // Node columns carried through.
      expect(result.ir.nodes.every((n) => n.column === "in-progress")).toBe(true);
    }
  });

  it("remaps namespaced foreach child layout keys consistently with the template ids", () => {
    const ir = v2WithForeach();
    const layout = {
      start: { x: 0, y: 0 },
      loop: { x: 100, y: 0 },
      "loop::t1": { x: 10, y: 20 },
      "loop::t2": { x: 270, y: 20 },
      end: { x: 400, y: 0 },
    };
    const result = copyIrWithFreshIds(ir, layout);

    const loop = result.ir.nodes.find((n) => n.kind === "foreach")!;
    const template = (loop.config as { template: { nodes: { id: string }[] } }).template;
    const newGroupId = loop.id;
    const childKeys = Object.keys(result.layout).filter((k) => k.includes("::"));

    // Both namespaced child keys survive (count preserved).
    expect(childKeys).toHaveLength(2);
    // Each child key is `${newGroupId}::${newTemplateId}` for a real template id.
    const newInnerIds = new Set(template.nodes.map((n) => n.id));
    for (const k of childKeys) {
      const [g, inner] = k.split("::");
      expect(g).toBe(newGroupId);
      expect(newInnerIds.has(inner)).toBe(true);
      // No stale original ids leak through.
      expect(g).not.toBe("loop");
      expect(["t1", "t2"]).not.toContain(inner);
    }
    // Values preserved by position (t1's offset stays with the remapped t1 key).
    const t1NewId = result.layout[`${newGroupId}::${template.nodes[0].id}`];
    expect(t1NewId).toEqual({ x: 10, y: 20 });
  });
});