@runfusion/fusion 0.24.0 → 0.25.0

package/dist/plugins/fusion-plugin-dependency-graph/src/__tests__/host-integration.test.ts

@@ -1,74 +0,0 @@
-import { createElement } from "react";
-import { cleanup, fireEvent, render, screen } from "@testing-library/react";
-import { describe, expect, it, vi, afterEach } from "vitest";
-import { definePlugin } from "@fusion/plugin-sdk";
-import { validatePluginManifest } from "@fusion/core";
-import plugin from "../index";
-import { DependencyGraphDashboardView } from "../dashboard-view";
-import { getPluginViewId } from "../../../../packages/dashboard/app/plugins/pluginViewRegistry";
-
-vi.mock("@fusion/dashboard/app/components/TaskCard", () => ({
-  TaskCard: ({ task, onOpenDetail }: { task: { id: string }; onOpenDetail: (task: { id: string }) => void }) =>
-    createElement("button", { "data-testid": `task-${task.id}`, onClick: () => onOpenDetail(task) }, task.id),
-}));
-
-afterEach(() => {
-  cleanup();
-});
-
-describe("dependency graph plugin host integration contract", () => {
-  it("declares dashboard view manifest shape", () => {
-    expect(plugin.manifest.id).toBe("fusion-plugin-dependency-graph");
-    expect(plugin.dashboardViews).toEqual([
-      expect.objectContaining({
-        viewId: "graph",
-        label: "Graph",
-        componentPath: "./dashboard-view",
-        placement: "more",
-      }),
-    ]);
-  });
-
-  it("is valid for definePlugin + manifest validation", () => {
-    const defined = definePlugin(plugin);
-    const validation = validatePluginManifest(defined.manifest);
-
-    expect(validation.valid).toBe(true);
-    expect(validation.errors).toEqual([]);
-  });
-
-  it("produces loader-compatible pluginId/view entries", () => {
-    const entries = (plugin.dashboardViews ?? []).map((view) => ({ pluginId: plugin.manifest.id, view }));
-
-    expect(entries).toHaveLength(1);
-    expect(entries[0]).toEqual(
-      expect.objectContaining({
-        pluginId: "fusion-plugin-dependency-graph",
-        view: expect.objectContaining({ viewId: "graph" }),
-      }),
-    );
-  });
-
-  it("matches host registry lookup key format plugin:{pluginId}:{viewId}", () => {
-    const view = plugin.dashboardViews?.[0];
-    if (!view) throw new Error("missing dashboard view");
-
-    expect(getPluginViewId(plugin.manifest.id, view.viewId)).toBe("plugin:fusion-plugin-dependency-graph:graph");
-  });
-
-  it("uses host openTaskDetail context when rendered through dashboard view entrypoint", () => {
-    const openTaskDetail = vi.fn();
-    render(
-      createElement(DependencyGraphDashboardView, {
-        context: {
-          tasks: [{ id: "FN-HOST", description: "FN-HOST", column: "todo", dependencies: [], steps: [], currentStep: 0, log: [] }],
-          openTaskDetail,
-        } as never,
-      }),
-    );
-
-    fireEvent.click(screen.getByTestId("task-FN-HOST"));
-    expect(openTaskDetail).toHaveBeenCalledTimes(1);
-    expect(openTaskDetail).toHaveBeenCalledWith(expect.objectContaining({ id: "FN-HOST" }));
-  });
-});

package/dist/plugins/fusion-plugin-dependency-graph/src/__tests__/index.test.ts

@@ -1,58 +0,0 @@
-import { mkdtempSync } from "node:fs";
-import { rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { dirname, join } from "node:path";
-import { pathToFileURL } from "node:url";
-import { PluginLoader, PluginStore } from "@fusion/core";
-import { afterEach, describe, expect, it } from "vitest";
-import plugin from "../index";
-
-const testDirs: string[] = [];
-
-afterEach(async () => {
-  await Promise.all(testDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })));
-});
-
-describe("dependency graph plugin index", () => {
-  it("exports node-importable plugin metadata", () => {
-    expect(plugin).toBeDefined();
-    expect(plugin.manifest.id).toBe("fusion-plugin-dependency-graph");
-    expect(plugin.dashboardViews?.[0]).toEqual(
-      expect.objectContaining({
-        viewId: "graph",
-        componentPath: "./dashboard-view",
-      }),
-    );
-  });
-
-  it("loads src/index.ts via Node dynamic import", async () => {
-    const moduleUrl = pathToFileURL(join(process.cwd(), "src/index.ts")).href;
-    const module = await import(moduleUrl);
-    expect(module.default?.manifest?.id).toBe("fusion-plugin-dependency-graph");
-  });
-
-  it("is loadable by PluginLoader without throwing", async () => {
-    const rootDir = mkdtempSync(join(tmpdir(), "fn-3737-plugin-loader-"));
-    testDirs.push(rootDir);
-
-    const pluginStore = new PluginStore(rootDir, { inMemoryDb: true, centralGlobalDir: rootDir });
-    await pluginStore.init();
-
-    const pluginPath = join(process.cwd(), "src/index.ts");
-    await pluginStore.registerPlugin({ manifest: plugin.manifest, path: pluginPath });
-
-    const loader = new PluginLoader({
-      pluginStore,
-      taskStore: { logActivity: async () => undefined } as never,
-      pluginDirs: [dirname(dirname(pluginPath))],
-    });
-
-    await loader.loadPlugin(plugin.manifest.id);
-
-    const loaded = loader.getPlugin(plugin.manifest.id);
-    expect(loaded?.state).toBe("started");
-    expect(loaded?.dashboardViews?.[0]).toEqual(
-      expect.objectContaining({ viewId: "graph", componentPath: "./dashboard-view" }),
-    );
-  });
-});

package/dist/plugins/fusion-plugin-dependency-graph/src/__tests__/interactions.test.tsx

@@ -1,121 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { act, cleanup, fireEvent, render, renderHook, screen } from "@testing-library/react";
-import type { Task } from "@fusion/core";
-import { DependencyGraph } from "../DependencyGraph";
-import { GraphTaskNode } from "../GraphTaskNode";
-import { useGraphInteraction } from "../useGraphInteraction";
-
-vi.mock("@fusion/dashboard/app/components/TaskCard", () => ({
-  TaskCard: ({ task, onOpenDetail }: { task: Task; onOpenDetail: (task: Task) => void }) => (
-    <button data-testid={`task-${task.id}`} onClick={() => onOpenDetail(task)}>
-      {task.id} {task.column === "in-progress" ? "Executing" : "Idle"}
-    </button>
-  ),
-}));
-
-function createTask(id: string, column: Task["column"] = "todo", dependencies: string[] = []): Task {
-  return {
-    id,
-    description: id,
-    column,
-    dependencies,
-    steps: [{ name: "one", status: "in-progress" }],
-    currentStep: 0,
-    status: column === "in-progress" ? "executing" : "queued",
-    log: [],
-  } as Task;
-}
-
-afterEach(() => {
-  cleanup();
-});
-
-describe("dependency graph interactions", () => {
-  it("supports pan and zoom via interaction hook", () => {
-    const { result } = renderHook(() => useGraphInteraction());
-
-    act(() => {
-      result.current.onPointerDown(1, { x: 10, y: 10 });
-      result.current.onPointerMove(1, { x: 110, y: 60 }, 800, 600);
-      result.current.zoomIn();
-    });
-
-    expect(result.current.pan).toEqual({ x: 100, y: 50 });
-    expect(result.current.zoom).toBeGreaterThan(1);
-  });
-
-  it("fit-to-graph computes bounds from actual node positions", () => {
-    const { result } = renderHook(() => useGraphInteraction());
-    const positions = new Map([
-      ["A", { x: 0, y: 0 }],
-      ["B", { x: 1000, y: 400 }],
-    ]);
-
-    act(() => {
-      result.current.fitToGraph(positions, 800, 600, { nodeWidth: 200, nodeHeight: 100, xGap: 40, yGap: 40 });
-    });
-
-    expect(result.current.zoom).toBeCloseTo(0.6, 3);
-    expect(result.current.pan.x).toBeCloseTo(40, 3);
-    expect(result.current.pan.y).toBeCloseTo(150, 3);
-  });
-
-  it("clicking a node opens task detail", () => {
-    const onOpenDetail = vi.fn();
-    render(<DependencyGraph tasks={[createTask("A", "in-progress")]} onOpenDetail={onOpenDetail} />);
-
-    fireEvent.click(screen.getByTestId("task-A"));
-    expect(onOpenDetail).toHaveBeenCalledTimes(1);
-    expect(onOpenDetail).toHaveBeenCalledWith(expect.objectContaining({ id: "A" }));
-    expect(screen.getAllByText(/Executing/).length).toBeGreaterThan(0);
-  });
-
-  it("dragging a node updates its position", () => {
-    const onNodePositionChange = vi.fn();
-
-    render(
-      <GraphTaskNode
-        task={createTask("A")}
-        position={{ x: 0, y: 0 }}
-        scale={1}
-        isHighlighted={false}
-        isDimmed={false}
-        onNodePositionChange={onNodePositionChange}
-        onNodeDragStateChange={vi.fn()}
-        projectId="p1"
-        onOpenDetail={vi.fn()}
-        addToast={vi.fn()}
-        onUpdateTask={vi.fn()}
-        onArchiveTask={vi.fn()}
-        onUnarchiveTask={vi.fn()}
-        onDeleteTask={vi.fn()}
-        onRetryTask={vi.fn()}
-        onOpenDetailWithTab={vi.fn()}
-        onMoveTask={vi.fn()}
-        onOpenMission={vi.fn()}
-        taskStuckTimeoutMs={1_000}
-        lastFetchTimeMs={Date.now()}
-        workflowStepNameLookup={new Map()}
-      />,
-    );
-
-    const node = screen.getByTestId("graph-task-node-A");
-    fireEvent.pointerDown(node, { pointerId: 1, clientX: 10, clientY: 10, isPrimary: true });
-    fireEvent.pointerMove(node, { pointerId: 1, clientX: 25, clientY: 30, isPrimary: true });
-
-    expect(onNodePositionChange).toHaveBeenCalled();
-  });
-
-  it("highlights upstream/downstream chain on hover", () => {
-    render(
-      <DependencyGraph
-        tasks={[createTask("A"), createTask("B", "todo", ["A"]), createTask("C", "todo", ["B"]), createTask("D")]}
-        onOpenDetail={vi.fn()}
-      />,
-    );
-
-    fireEvent.mouseEnter(screen.getByTestId("graph-task-node-C"));
-    expect(screen.getByTestId("graph-task-node-A").className).toContain("graph-task-node--highlighted");
-    expect(screen.getByTestId("graph-task-node-D").className).toContain("graph-task-node--dimmed");
-  });
-});

package/dist/plugins/fusion-plugin-dependency-graph/src/__tests__/layout.test.ts

@@ -1,70 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { GraphData } from "../types";
-import { computeAutoLayout } from "../layout";
-
-function graph(nodeIds: string[], edges: Array<{ source: string; target: string }> = []): GraphData {
-  return {
-    nodes: nodeIds.map((id) => ({ task: { id } as never })),
-    edges,
-  };
-}
-
-describe("computeAutoLayout", () => {
-  it("returns empty map for empty graph", () => {
-    expect(computeAutoLayout({ nodes: [], edges: [] }).size).toBe(0);
-  });
-
-  it("positions single node", () => {
-    const positions = computeAutoLayout(graph(["A"]));
-    expect(positions.has("A")).toBe(true);
-  });
-
-  it("places linear chain in increasing depth", () => {
-    const positions = computeAutoLayout(graph(["A", "B", "C"], [
-      { source: "A", target: "B" },
-      { source: "B", target: "C" },
-    ]));
-
-    expect((positions.get("C")?.y ?? 0)).toBeLessThan(positions.get("B")?.y ?? 0);
-    expect((positions.get("B")?.y ?? 0)).toBeLessThan(positions.get("A")?.y ?? 0);
-  });
-
-  it("spreads wide layer horizontally", () => {
-    const positions = computeAutoLayout(graph(["A", "B", "C"]));
-    const xs = [positions.get("A")?.x, positions.get("B")?.x, positions.get("C")?.x].filter((x): x is number => x !== undefined);
-    expect(new Set(xs).size).toBe(3);
-  });
-
-  it("handles diamond dependencies", () => {
-    const positions = computeAutoLayout(graph(["A", "B", "C", "D"], [
-      { source: "A", target: "B" },
-      { source: "A", target: "C" },
-      { source: "B", target: "D" },
-      { source: "C", target: "D" },
-    ]));
-
-    expect((positions.get("D")?.y ?? 0)).toBeLessThan(positions.get("B")?.y ?? 0);
-    expect((positions.get("D")?.y ?? 0)).toBeLessThan(positions.get("C")?.y ?? 0);
-    expect((positions.get("B")?.y ?? 0)).toBeLessThan(positions.get("A")?.y ?? 0);
-    expect((positions.get("C")?.y ?? 0)).toBeLessThan(positions.get("A")?.y ?? 0);
-  });
-
-  it("handles cycles without crashing", () => {
-    const positions = computeAutoLayout(graph(["A", "B"], [
-      { source: "A", target: "B" },
-      { source: "B", target: "A" },
-    ]));
-
-    expect(positions.size).toBe(2);
-  });
-
-  it("respects custom spacing options", () => {
-    const positions = computeAutoLayout(graph(["A", "B"]), {
-      nodeWidth: 200,
-      nodeHeight: 120,
-      horizontalGap: 100,
-      verticalGap: 20,
-    });
-    expect(Math.abs((positions.get("A")?.x ?? 0) - (positions.get("B")?.x ?? 0))).toBe(300);
-  });
-});

package/dist/plugins/fusion-plugin-dependency-graph/src/__tests__/persistence.test.tsx

@@ -1,89 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { cleanup, fireEvent, render, screen } from "@testing-library/react";
-import type { Task } from "@fusion/core";
-import { DependencyGraph } from "../DependencyGraph";
-import { loadPositions, savePositions } from "../utils/graphPositionStorage";
-
-vi.mock("@fusion/dashboard/app/components/TaskCard", () => ({
-  TaskCard: ({ task }: { task: Task }) => <div>{task.id}</div>,
-}));
-
-function createStorage() {
-  const store = new Map<string, string>();
-  return {
-    getItem: (key: string) => store.get(key) ?? null,
-    setItem: (key: string, value: string) => {
-      store.set(key, value);
-    },
-    removeItem: (key: string) => {
-      store.delete(key);
-    },
-  };
-}
-
-function createTask(id: string, column: Task["column"] = "todo"): Task {
-  return { id, description: id, column, dependencies: [], steps: [], currentStep: 0, log: [] } as Task;
-}
-
-describe("dependency graph position persistence", () => {
-  beforeEach(() => {
-    Object.defineProperty(window, "localStorage", { value: createStorage(), configurable: true });
-  });
-
-  afterEach(() => {
-    cleanup();
-    vi.restoreAllMocks();
-  });
-
-  it("saves/restores project-scoped position shape", () => {
-    savePositions({ A: { x: 10, y: 20 }, B: { x: 30, y: 40 } }, new Set(["A", "B"]), "p1");
-
-    expect(window.localStorage.getItem("kb:p1:fusion-plugin-dependency-graph:positions")).toBe(
-      JSON.stringify({ A: { x: 10, y: 20 }, B: { x: 30, y: 40 } }),
-    );
-    expect(loadPositions("p1")).toEqual({ A: { x: 10, y: 20 }, B: { x: 30, y: 40 } });
-  });
-
-  it("keeps positions isolated across projects", () => {
-    savePositions({ A: { x: 1, y: 2 } }, new Set(["A"]), "p1");
-    savePositions({ A: { x: 99, y: 88 } }, new Set(["A"]), "p2");
-
-    expect(loadPositions("p1")).toEqual({ A: { x: 1, y: 2 } });
-    expect(loadPositions("p2")).toEqual({ A: { x: 99, y: 88 } });
-  });
-
-  it("falls back to auto-layout with corrupt storage and does not crash", () => {
-    window.localStorage.setItem("kb:p1:fusion-plugin-dependency-graph:positions", "{broken");
-
-    render(<DependencyGraph tasks={[createTask("A")]} projectId="p1" />);
-    expect(screen.getByTestId("graph-task-node-A")).toBeTruthy();
-  });
-
-  it("drag persistence only writes localStorage and performs no network writes", () => {
-    const fetchSpy = vi.spyOn(globalThis, "fetch");
-
-    render(<DependencyGraph tasks={[createTask("A")]} projectId="p1" />);
-    const node = screen.getByTestId("graph-task-node-A");
-    fireEvent.pointerDown(node, { pointerId: 1, isPrimary: true, clientX: 10, clientY: 10 });
-    fireEvent.pointerMove(node, { pointerId: 1, isPrimary: true, clientX: 30, clientY: 40 });
-    fireEvent.pointerUp(node, { pointerId: 1, isPrimary: true, clientX: 30, clientY: 40 });
-
-    expect(window.localStorage.getItem("kb:p1:fusion-plugin-dependency-graph:positions")).toContain('"A"');
-    expect(fetchSpy).not.toHaveBeenCalled();
-  });
-
-  it("clearing localStorage causes fresh auto-layout on remount", () => {
-    const { unmount } = render(<DependencyGraph tasks={[createTask("A")]} projectId="p1" />);
-    const node = screen.getByTestId("graph-task-node-A");
-    fireEvent.pointerDown(node, { pointerId: 1, isPrimary: true, clientX: 10, clientY: 10 });
-    fireEvent.pointerMove(node, { pointerId: 1, isPrimary: true, clientX: 40, clientY: 50 });
-    fireEvent.pointerUp(node, { pointerId: 1, isPrimary: true, clientX: 40, clientY: 50 });
-
-    window.localStorage.removeItem("kb:p1:fusion-plugin-dependency-graph:positions");
-    unmount();
-
-    render(<DependencyGraph tasks={[createTask("A")]} projectId="p1" />);
-    expect(window.localStorage.getItem("kb:p1:fusion-plugin-dependency-graph:positions")).toBeNull();
-    expect(screen.getByTestId("graph-task-node-A")).toBeTruthy();
-  });
-});

package/dist/plugins/fusion-plugin-dependency-graph/src/__tests__/useGraphData.test.ts

@@ -1,86 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { renderHook } from "@testing-library/react";
-import type { Task } from "@fusion/core";
-import { useGraphData } from "../useGraphData";
-
-function createTask(id: string, column: Task["column"] = "todo", dependencies: string[] = []): Task {
-  return {
-    id,
-    description: id,
-    column,
-    dependencies,
-    steps: [],
-    currentStep: 0,
-    log: [],
-  } as Task;
-}
-
-describe("useGraphData", () => {
-  it("returns empty graph for empty tasks", () => {
-    const { result } = renderHook(() => useGraphData([]));
-    expect(result.current).toEqual({ nodes: [], edges: [] });
-  });
-
-  it("creates node for single task with no deps", () => {
-    const { result } = renderHook(() => useGraphData([createTask("A")]));
-    expect(result.current.nodes.map((node) => node.task.id)).toEqual(["A"]);
-    expect(result.current.edges).toEqual([]);
-  });
-
-  describe("orphan dependencies to excluded tasks", () => {
-    it("drops dependency edge to done task while keeping dependent node", () => {
-      const filteredTasks = [createTask("A", "in-progress", ["DONE-1"])];
-      const { result } = renderHook(() => useGraphData(filteredTasks));
-
-      expect(result.current.nodes.map((node) => node.task.id)).toEqual(["A"]);
-      expect(result.current.edges).toEqual([]);
-    });
-
-    it("drops dependency edge to archived task while keeping dependent node", () => {
-      const filteredTasks = [createTask("A", "triage", ["ARCH-1"])];
-      const { result } = renderHook(() => useGraphData(filteredTasks));
-
-      expect(result.current.nodes.map((node) => node.task.id)).toEqual(["A"]);
-      expect(result.current.edges).toEqual([]);
-    });
-
-    it("keeps only included dependency edges when mixed dependencies are present", () => {
-      const filteredTasks = [createTask("A", "in-progress", ["B", "DONE-1", "ARCH-1"]), createTask("B", "todo")];
-      const { result } = renderHook(() => useGraphData(filteredTasks));
-
-      expect(result.current.nodes.map((node) => node.task.id)).toEqual(["A", "B"]);
-      expect(result.current.edges).toEqual([{ source: "A", target: "B" }]);
-    });
-
-    it("shows zero edges when all dependencies are excluded", () => {
-      const filteredTasks = [createTask("A", "in-progress", ["DONE-1", "ARCH-1"])];
-      const { result } = renderHook(() => useGraphData(filteredTasks));
-
-      expect(result.current.nodes.map((node) => node.task.id)).toEqual(["A"]);
-      expect(result.current.edges).toEqual([]);
-    });
-  });
-
-  describe("in-review dependency edges", () => {
-    it("renders edges between in-review tasks", () => {
-      const tasks = [createTask("A", "in-review", ["B"]), createTask("B", "in-review")];
-      const { result } = renderHook(() => useGraphData(tasks));
-
-      expect(result.current.edges).toEqual([{ source: "A", target: "B" }]);
-    });
-
-    it("renders edge from in-review task to in-progress task", () => {
-      const tasks = [createTask("A", "in-review", ["B"]), createTask("B", "in-progress")];
-      const { result } = renderHook(() => useGraphData(tasks));
-
-      expect(result.current.edges).toEqual([{ source: "A", target: "B" }]);
-    });
-
-    it("renders edge from in-progress task to in-review task", () => {
-      const tasks = [createTask("A", "in-progress", ["B"]), createTask("B", "in-review")];
-      const { result } = renderHook(() => useGraphData(tasks));
-
-      expect(result.current.edges).toEqual([{ source: "A", target: "B" }]);
-    });
-  });
-});

package/dist/plugins/fusion-plugin-dependency-graph/src/__tests__/useGraphInteraction.test.ts

@@ -1,167 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { act, renderHook } from "@testing-library/react";
-import type React from "react";
-import { useGraphInteraction } from "../useGraphInteraction";
-
-function createKeyEvent(
-  key: string,
-  options?: { ctrlKey?: boolean; metaKey?: boolean; shiftKey?: boolean; target?: EventTarget | null },
-) {
-  return {
-    key,
-    ctrlKey: Boolean(options?.ctrlKey),
-    metaKey: Boolean(options?.metaKey),
-    shiftKey: Boolean(options?.shiftKey),
-    target: options?.target ?? document.createElement("div"),
-    preventDefault: vi.fn(),
-  } as unknown as React.KeyboardEvent;
-}
-
-describe("useGraphInteraction", () => {
-  it("starts with default pan/zoom", () => {
-    const { result } = renderHook(() => useGraphInteraction());
-    expect(result.current.zoom).toBe(1);
-    expect(result.current.zoomPercent).toBe(100);
-    expect(result.current.pan).toEqual({ x: 0, y: 0 });
-  });
-
-  it("clamps zoom between 0.1 and 3", () => {
-    const { result } = renderHook(() => useGraphInteraction());
-
-    act(() => {
-      for (let i = 0; i < 100; i += 1) result.current.zoomOut();
-    });
-    expect(result.current.zoom).toBe(0.1);
-
-    act(() => {
-      for (let i = 0; i < 100; i += 1) result.current.zoomIn();
-    });
-    expect(result.current.zoom).toBe(3);
-  });
-
-  it("keeps wheel zoom anchored to cursor position", () => {
-    const { result } = renderHook(() => useGraphInteraction());
-
-    act(() => {
-      result.current.onWheelZoom(-120, { x: 200, y: 150 }, 800, 600);
-    });
-
-    expect(result.current.zoom).toBe(1.1);
-    expect(result.current.pan.x).toBeCloseTo(-20, 5);
-    expect(result.current.pan.y).toBeCloseTo(-15, 5);
-  });
-
-  it("supports pinch zoom with stationary midpoint", () => {
-    const { result } = renderHook(() => useGraphInteraction());
-
-    act(() => {
-      result.current.onPointerDown(1, { x: 100, y: 100 });
-      result.current.onPointerDown(2, { x: 200, y: 100 });
-      result.current.onPointerMove(2, { x: 250, y: 100 }, 800, 600);
-    });
-
-    expect(result.current.zoom).toBe(1.5);
-    expect(result.current.pan).toEqual({ x: -50, y: -50 });
-  });
-
-  it("applies animation state for fit and reset", () => {
-    vi.useFakeTimers();
-    const { result } = renderHook(() => useGraphInteraction());
-
-    act(() => {
-      result.current.fitToGraph(new Map([["A", { x: 0, y: 0 }]]), 800, 600);
-    });
-    expect(result.current.transitioning).toBe(true);
-
-    act(() => {
-      vi.advanceTimersByTime(210);
-    });
-    expect(result.current.transitioning).toBe(false);
-
-    act(() => {
-      result.current.resetView();
-    });
-    expect(result.current.transitioning).toBe(true);
-
-    act(() => {
-      vi.advanceTimersByTime(210);
-    });
-    expect(result.current.transitioning).toBe(false);
-    vi.useRealTimers();
-  });
-
-  it("fits wide graph", () => {
-    const { result } = renderHook(() => useGraphInteraction());
-    act(() => {
-      result.current.fitToGraph(new Map([
-        ["A", { x: 0, y: 0 }],
-        ["B", { x: 2000, y: 0 }],
-      ]), 800, 600);
-    });
-
-    expect(result.current.zoom).toBeLessThan(1);
-  });
-
-  it("handles keyboard shortcuts for zoom in/out, reset, fit, and escape", () => {
-    const { result } = renderHook(() => useGraphInteraction());
-    const positions = new Map([
-      ["A", { x: 0, y: 0 }],
-      ["B", { x: 500, y: 200 }],
-    ]);
-
-    act(() => {
-      result.current.handleKeyDown(createKeyEvent("=", { ctrlKey: true }), 800, 600, positions);
-    });
-    expect(result.current.zoom).toBe(1.2);
-
-    act(() => {
-      result.current.handleKeyDown(createKeyEvent("-", { ctrlKey: true }), 800, 600, positions);
-    });
-    expect(result.current.zoom).toBeCloseTo(1, 5);
-
-    act(() => {
-      result.current.handleKeyDown(createKeyEvent("F", { ctrlKey: true, shiftKey: true }), 800, 600, positions, { nodeWidth: 280, nodeHeight: 100 });
-    });
-    expect(result.current.zoom).toBeLessThan(1);
-
-    act(() => {
-      result.current.handleKeyDown(createKeyEvent("0", { ctrlKey: true }), 800, 600, positions);
-    });
-    expect(result.current.zoom).toBe(1);
-    expect(result.current.pan).toEqual({ x: 0, y: 0 });
-
-    act(() => {
-      result.current.zoomIn();
-      result.current.handleKeyDown(createKeyEvent("Escape"), 800, 600, positions);
-    });
-    expect(result.current.zoom).toBe(1);
-    expect(result.current.pan).toEqual({ x: 0, y: 0 });
-  });
-
-  it("does not run shortcuts when focused on editable targets", () => {
-    const { result } = renderHook(() => useGraphInteraction());
-    const input = document.createElement("input");
-    const positions = new Map([["A", { x: 0, y: 0 }]]);
-
-    act(() => {
-      result.current.handleKeyDown(createKeyEvent("=", { ctrlKey: true, target: input }), 800, 600, positions);
-    });
-
-    expect(result.current.zoom).toBe(1);
-  });
-
-  it("resets when positions are empty", () => {
-    const { result } = renderHook(() => useGraphInteraction());
-
-    act(() => {
-      result.current.zoomIn();
-      result.current.onPointerDown(1, { x: 10, y: 10 });
-      result.current.onPointerMove(1, { x: 110, y: 60 }, 800, 600);
-      result.current.onPointerUp(1);
-      result.current.fitToGraph(new Map(), 800, 600);
-    });
-
-    expect(result.current.zoom).toBe(1);
-    expect(result.current.pan).toEqual({ x: 0, y: 0 });
-  });
-});