Skip to content

Automate browser based workflows with AI

70.8 KB
Raw Blame
// @vitest-environment jsdom

import { AxiosError } from "axios";
import { useEffect, useState, type ReactNode } from "react";
import {
  act,
  fireEvent,
  render,
  renderHook,
  screen,
  waitFor,
} from "@testing-library/react";
import { ReactFlowProvider } from "@xyflow/react";
import { toast } from "@/components/ui/use-toast";
import type { AppNode } from "@/routes/workflows/editor/nodes";
import { actionNodeDefaultData } from "@/routes/workflows/editor/nodes/ActionNode/types";
import {
  getWorkflowBlocks,
  getWorkflowErrors,
} from "@/routes/workflows/editor/workflowEditorUtils";
import { WorkflowBlockInputTextarea } from "@/components/WorkflowBlockInputTextarea";
import { CodeEditor } from "@/routes/workflows/components/CodeEditor";
import { EditorView } from "@codemirror/view";
import {
  QueryClient,
  QueryClientProvider,
  useQuery,
} from "@tanstack/react-query";
import { parse as parseYaml } from "yaml";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";

import {
  reflectYamlDraftDirtiness,
  SaveRefusedError,
  useWorkflowHasChangesStore,
  useWorkflowSave,
  usePendingWorkflowSaveRecovery,
  type WorkflowSaveData,
} from "./WorkflowHasChangesStore";
import {
  confirmCodeCacheDeletion,
  useSaveWorkflow,
} from "@/routes/workflows/editor/hooks/useSaveWorkflow";
import { useWorkflowParametersStore } from "./WorkflowParametersStore";
import { useWorkflowTitleStore } from "./WorkflowTitleStore";
import {
  beginSaveTransaction,
  beginCopilotAcceptance,
  beginYamlCommit,
  commitYamlDraft,
  registerEditorOwner,
  unregisterEditorOwner,
  createYamlCommitOwner,
  finishCopilotAcceptance,
  finishYamlCommit,
  useWorkflowYamlEditorStore,
  withCopilotAcceptance,
} from "./WorkflowYamlEditorStore";

import {
  WorkflowSaveConflictNotice,
  WorkflowSavePendingNotice,
} from "@/routes/workflows/editor/WorkflowYamlEditor";

const mocks = vi.hoisted(() => ({
  workflowId: "wpid-1",
  post: vi.fn(),
  getClient: vi.fn(),
  get: vi.fn(),
  put: vi.fn(),
  capture: vi.fn(),
  getNodes: vi.fn<() => AppNode[]>(() => []),
}));

vi.mock("@xyflow/react", async (importOriginal) => ({
  ...(await importOriginal<typeof import("@xyflow/react")>()),
  useReactFlow: () => ({ getNodes: mocks.getNodes }),
}));
vi.mock("@/routes/workflows/WorkflowPermanentIdContext", () => ({
  useWorkflowPermanentId: () => mocks.workflowId,
}));
vi.mock("@/routes/workflows/hooks/useWorkflowQuery", () => ({
  useWorkflowQuery: () => ({ data: undefined }),
}));
vi.mock("@/routes/workflows/studio/useStudioPanes", () => ({
  useStudioPanes: () => ({ openPane: vi.fn() }),
}));
vi.mock("@/api/AxiosClient", () => ({
  getClient: mocks.getClient,
}));
vi.mock("@/components/ui/use-toast", () => ({ toast: vi.fn() }));
vi.mock("@/hooks/useCredentialGetter", () => ({
  useCredentialGetter: () => vi.fn(async () => "test-token"),
}));
vi.mock("posthog-js/react", () => ({
  usePostHog: () => ({ capture: mocks.capture }),
}));

function wrapper({ children }: { children: ReactNode }) {
  return (
    <QueryClientProvider client={new QueryClient()}>
      {children}
    </QueryClientProvider>
  );
}

const saveData = {
  title: "Recorded workflow",
  description: null,
  blocks: [],
  parameters: [],
  workflowDefinitionVersion: 1,
  settings: {
    proxyLocation: "RESIDENTIAL",
    runWith: "agent",
  },
  workflow: {
    workflow_permanent_id: "wpid-1",
    version: 1,
    workflow_definition: { version: 1, blocks: [], parameters: [] },
    status: "published",
  },
} as unknown as WorkflowSaveData;

describe("workflow save reservation", () => {
  afterEach(() => vi.useRealTimers());
  beforeEach(() => {
    vi.clearAllMocks();
    mocks.getNodes.mockReset().mockReturnValue([]);
    sessionStorage.clear();
    mocks.workflowId = "wpid-1";
    useWorkflowHasChangesStore.setState(
      useWorkflowHasChangesStore.getInitialState(),
    );
    useWorkflowYamlEditorStore.setState(
      useWorkflowYamlEditorStore.getInitialState(),
    );
    registerEditorOwner(createYamlCommitOwner("wpid-1"));
    mocks.getClient.mockResolvedValue({
      get: mocks.get,
      post: mocks.post,
      put: mocks.put,
    });
    mocks.put.mockResolvedValue({
      data: {
        ...saveData.workflow,
        title: saveData.title,
        description: saveData.description,
      },
    });
    useWorkflowHasChangesStore.setState({
      getSaveData: () => saveData,
    });
  });

  it("keeps a transport-failed PUT reserved despite canonical advancement and allows another workflow", async () => {
    mocks.put.mockRejectedValueOnce(
      new AxiosError("connection reset", "ERR_NETWORK"),
    );
    const hydrate = vi.fn();
    useWorkflowHasChangesStore.setState({
      hasChanges: true,
      hydrateSavedSettings: hydrate,
    });
    const hook = renderHook(() => useWorkflowSave(), { wrapper });
    await act(async () => {
      await expect(hook.result.current.mutateAsync(undefined)).rejects.toThrow(
        "connection reset",
      );
    });
    render(<WorkflowSavePendingNotice />);
    expect(screen.getByRole("button", { name: "Reload" })).toBeTruthy();
    expect(
      beginSaveTransaction(useWorkflowYamlEditorStore.getState().editorOwner!),
    ).toBe(false);
    renderHook(
      () =>
        usePendingWorkflowSaveRecovery({ ...saveData.workflow, version: 2 }),
      { wrapper },
    );
    expect(hydrate).not.toHaveBeenCalled();
    expect(
      useWorkflowYamlEditorStore.getState().pendingSaves["wpid-1"],
    ).toMatchObject({ persisting: true });
    expect(useWorkflowHasChangesStore.getState().hasChanges).toBe(true);
    registerEditorOwner(createYamlCommitOwner("wpid-other"));
    useWorkflowHasChangesStore.setState({
      getSaveData: () => ({
        ...saveData,
        workflow: { ...saveData.workflow, workflow_permanent_id: "wpid-other" },
      }),
    });
    const other = renderHook(() => useWorkflowSave(), { wrapper });
    await act(async () => {
      await other.result.current.mutateAsync(undefined);
    });
    expect(mocks.put).toHaveBeenCalledTimes(2);
    expect(
      useWorkflowYamlEditorStore.getState().pendingSaves["wpid-1"],
    ).toBeDefined();
  });

  it("holds Save, YAML commit, and Copilot apply after reload with an unchanged canonical version and offers Discard and Reload", async () => {
    sessionStorage.setItem(
      "workflow-pending-save:wpid-1",
      JSON.stringify({
        workflowPermanentId: "wpid-1",
        baseVersion: 1,
        timestamp: Date.now(),
      }),
    );
    useWorkflowYamlEditorStore.setState(
      useWorkflowYamlEditorStore.getInitialState(),
    );
    const owner = createYamlCommitOwner("wpid-1");
    registerEditorOwner(owner);
    const hydrate = vi.fn();
    const commit = vi.fn(async () => true);
    const apply = vi.fn();
    useWorkflowYamlEditorStore.getState().registerCommit(commit);
    useWorkflowHasChangesStore.setState({ hydrateSavedSettings: hydrate });
    const hook = renderHook(
      () => {
        usePendingWorkflowSaveRecovery(saveData.workflow);
        return useWorkflowSave();
      },
      { wrapper },
    );
    render(<WorkflowSavePendingNotice />);

    expect(beginSaveTransaction(owner)).toBe(false);
    await act(async () => {
      await expect(hook.result.current.mutateAsync(undefined)).rejects.toThrow(
        "A save is in progress",
      );
      expect(await commitYamlDraft(true)).toBe(false);
      expect(beginCopilotAcceptance()).toBeNull();
      expect(withCopilotAcceptance(undefined, apply)).toBe(false);
    });
    expect(mocks.put).not.toHaveBeenCalled();
    expect(commit).not.toHaveBeenCalled();
    expect(apply).not.toHaveBeenCalled();
    expect(hydrate).not.toHaveBeenCalled();
    expect(screen.getByRole("button", { name: "Reload" })).toBeTruthy();
    expect(
      screen.getByRole("button", { name: "Discard pending save" }),
    ).toBeTruthy();
  });

  it.each([false, true])(
    "hydrates canonical before discarding the restored save hold (stale stores: %s)",
    async (edited) => {
      const marker = JSON.stringify({
        workflowPermanentId: "wpid-1",
        baseVersion: 1,
        timestamp: Date.now(),
      });
      sessionStorage.setItem("workflow-pending-save:wpid-1", marker);
      sessionStorage.setItem(
        "workflow-pending-save:wpid-other",
        "other marker",
      );
      useWorkflowYamlEditorStore.setState(
        useWorkflowYamlEditorStore.getInitialState(),
      );
      registerEditorOwner(createYamlCommitOwner("wpid-1"));
      const hydrate = vi.fn();
      const currentSaveData = {
        ...saveData,
        title: edited ? "Edited after reload" : "Loaded canonical title",
        description: edited ? "Edited description" : null,
      };
      const canonical = {
        ...saveData.workflow,
        title: "Loaded canonical title",
        description: "Loaded canonical description",
      };
      mocks.get.mockResolvedValueOnce({ data: canonical });
      useWorkflowHasChangesStore.setState({
        getSaveData: () => ({
          ...currentSaveData,
          workflow: canonical,
          title: useWorkflowTitleStore.getState().title,
          description: useWorkflowTitleStore.getState().description,
        }),
        hasChanges: edited,
        hydrateSavedSettings: hydrate,
      });
      useWorkflowTitleStore.setState({
        title: currentSaveData.title,
        description: currentSaveData.description,
      });
      const hook = renderHook(
        () => {
          usePendingWorkflowSaveRecovery(saveData.workflow);
          return useWorkflowSave();
        },
        { wrapper },
      );
      render(<WorkflowSavePendingNotice />);
      await act(async () =>
        fireEvent.click(
          screen.getByRole("button", { name: "Discard pending save" }),
        ),
      );

      expect(sessionStorage.getItem("workflow-pending-save:wpid-1")).toBeNull();
      expect(sessionStorage.getItem("workflow-pending-save:wpid-other")).toBe(
        "other marker",
      );
      expect(useWorkflowYamlEditorStore.getState()).toMatchObject({
        pendingSaves: {},
        commitOwner: null,
        persistingOwner: null,
        commitInProgress: false,
        committing: false,
        lockKind: null,
      });
      expect(useWorkflowHasChangesStore.getState().hasChanges).toBe(false);
      expect(useWorkflowTitleStore.getState()).toMatchObject({
        title: canonical.title,
        description: canonical.description,
      });
      expect(hydrate).toHaveBeenCalledExactlyOnceWith(canonical, {
        hydrateGraph: true,
      });
      expect(mocks.put).not.toHaveBeenCalled();
      expect(mocks.post).not.toHaveBeenCalled();
      expect(mocks.capture).not.toHaveBeenCalled();
      expect(screen.queryByRole("status")).toBeNull();

      await act(async () => {
        await hook.result.current.mutateAsync(undefined);
      });
      expect(mocks.put).toHaveBeenCalledOnce();
      expect(parseYaml(mocks.put.mock.calls[0]![1])).toMatchObject({
        title: canonical.title,
        description: canonical.description,
      });
    },
  );

  it("keeps the restored save locked when Discard cannot read canonical state, then retries", async () => {
    const marker = JSON.stringify({
      workflowPermanentId: "wpid-1",
      baseVersion: 1,
      timestamp: Date.now(),
    });
    sessionStorage.setItem("workflow-pending-save:wpid-1", marker);
    useWorkflowYamlEditorStore.setState(
      useWorkflowYamlEditorStore.getInitialState(),
    );
    const owner = createYamlCommitOwner("wpid-1");
    registerEditorOwner(owner);
    const hydrate = vi.fn();
    useWorkflowHasChangesStore.setState({
      hydrateSavedSettings: hydrate,
      getSaveData: () => ({
        ...saveData,
        workflow: { ...saveData.workflow, title: saveData.title },
      }),
    });
    mocks.get.mockRejectedValueOnce(new Error("Canonical unavailable"));
    render(<WorkflowSavePendingNotice />);

    await act(async () =>
      fireEvent.click(
        screen.getByRole("button", { name: "Discard pending save" }),
      ),
    );
    expect(useWorkflowYamlEditorStore.getState().commitInProgress).toBe(true);
    expect(sessionStorage.getItem("workflow-pending-save:wpid-1")).toBe(marker);
    expect(hydrate).not.toHaveBeenCalled();
    expect(beginSaveTransaction(owner)).toBe(false);
    expect(beginCopilotAcceptance()).toBeNull();
    const canonical = {
      ...saveData.workflow,
      version: 2,
      title: "Landed title",
    };
    mocks.get.mockResolvedValueOnce({ data: canonical });
    await act(async () =>
      fireEvent.click(
        screen.getByRole("button", { name: "Discard pending save" }),
      ),
    );
    expect(hydrate).toHaveBeenCalledExactlyOnceWith(canonical, {
      hydrateGraph: true,
    });
    expect(useWorkflowYamlEditorStore.getState().commitInProgress).toBe(false);
    expect(sessionStorage.getItem("workflow-pending-save:wpid-1")).toBeNull();
  });

  it.each([
    ["after", false],
    ["before", true],
  ])(
    "keeps the second save latest when a PUT held across reload reaches the server %s Discard",
    async (_, heldLandsFirst) => {
      const server = [{ ...saveData.workflow, title: "Loaded" }];
      const serve = (body: string, params: { expected_version?: number }) => {
        const latest = server[server.length - 1]!;
        if (
          params.expected_version !== undefined &&
          params.expected_version !== latest.version
        )
          return { status: 409 } as const;
        const saved = {
          ...latest,
          version: latest.version + 1,
          title: parseYaml(body).title,
        };
        server.push(saved);
        return { status: 200, data: saved } as const;
      };
      let held!: [string, { expected_version?: number }];
      mocks.put
        .mockImplementationOnce((_url, body, config) => {
          held = [body, config.params];
          return new Promise(() => {});
        })
        .mockImplementation(async (_url, body, config) => {
          const response = serve(body, config.params);
          if (response.status === 409)
            throw new AxiosError("conflict", undefined, undefined, undefined, {
              status: 409,
              data: { detail: "conflict" },
            } as NonNullable<AxiosError["response"]>);
          return response;
        });
      mocks.get.mockImplementation(async () => ({
        data: server[server.length - 1],
      }));
      useWorkflowHasChangesStore.setState({
        hasChanges: true,
        hydrateSavedSettings: vi.fn(),
        getSaveData: () => ({ ...saveData, title: "First save" }),
      });
      const firstTab = renderHook(() => useWorkflowSave(), { wrapper });
      act(() => {
        void firstTab.result.current.mutateAsync(undefined);
      });
      await waitFor(() => expect(mocks.put).toHaveBeenCalledOnce());
      firstTab.unmount();

      useWorkflowHasChangesStore.setState(
        useWorkflowHasChangesStore.getInitialState(),
      );
      useWorkflowYamlEditorStore.setState(
        useWorkflowYamlEditorStore.getInitialState(),
      );
      registerEditorOwner(createYamlCommitOwner("wpid-1"));
      useWorkflowHasChangesStore.setState({
        hydrateSavedSettings: vi.fn(),
        getSaveData: () => ({ ...saveData, title: "Second save" }),
      });
      if (heldLandsFirst) serve(...held);
      const reloaded = renderHook(
        () => {
          usePendingWorkflowSaveRecovery(saveData.workflow);
          return useWorkflowSave();
        },
        { wrapper },
      );
      render(<WorkflowSavePendingNotice />);
      await act(async () =>
        fireEvent.click(
          screen.getByRole("button", { name: "Discard pending save" }),
        ),
      );
      act(() => useWorkflowHasChangesStore.getState().setHasChanges(true));
      await act(async () => {
        await reloaded.result.current.mutateAsync(undefined);
      });
      if (!heldLandsFirst) expect(serve(...held).status).toBe(409);

      expect(server[server.length - 1]!.title).toBe("Second save");
      expect(
        mocks.put.mock.calls.map(
          ([, , config]) => config.params.expected_version,
        ),
      ).toEqual(heldLandsFirst ? [1, 2] : [1, 1]);
    },
  );

  it("keeps a rejected stale save on the canvas and reloads the latest version only on request", async () => {
    const latest = {
      ...saveData.workflow,
      version: 3,
      title: "Saved elsewhere",
    };
    mocks.put.mockRejectedValueOnce(
      new AxiosError("conflict", undefined, undefined, undefined, {
        status: 409,
        data: { detail: "conflict" },
      } as NonNullable<AxiosError["response"]>),
    );
    mocks.get.mockResolvedValueOnce({ data: latest });
    const hydrate = vi.fn();
    useWorkflowHasChangesStore.setState({
      hasChanges: true,
      hydrateSavedSettings: hydrate,
    });
    const hook = renderHook(() => useWorkflowSave(), { wrapper });
    const viewHistory = vi.fn();
    render(<WorkflowSaveConflictNotice onViewHistory={viewHistory} />);
    act(() =>
      useWorkflowYamlEditorStore.getState().open("title: Rejected draft\n"),
    );

    await act(async () => {
      await hook.result.current.mutateAsync(undefined).catch(() => undefined);
    });
    expect(screen.getByRole("alert").textContent).toContain(
      "your changes were not saved",
    );
    expect(useWorkflowHasChangesStore.getState().hasChanges).toBe(true);
    expect(hydrate).not.toHaveBeenCalled();
    fireEvent.click(screen.getByRole("button", { name: "View history" }));
    expect(viewHistory).toHaveBeenCalledOnce();

    await act(async () =>
      fireEvent.click(screen.getByRole("button", { name: "Reload latest" })),
    );
    expect(hydrate).toHaveBeenCalledExactlyOnceWith(latest, {
      hydrateGraph: true,
    });
    expect(useWorkflowHasChangesStore.getState().hasChanges).toBe(false);
    expect(useWorkflowYamlEditorStore.getState()).toMatchObject({
      active: false,
      draft: "",
    });
    expect(screen.queryByRole("alert")).toBeNull();

    await act(async () => {
      await hook.result.current.mutateAsync(undefined);
    });
    expect(
      mocks.put.mock.calls.map(
        ([, , config]) => config.params.expected_version,
      ),
    ).toEqual([1, 3]);
  });

  it("offers only Reload for a live PUT, including after an editor remount", async () => {
    let resolvePut!: (value: unknown) => void;
    mocks.put.mockImplementationOnce(
      () =>
        new Promise((resolve) => {
          resolvePut = resolve;
        }),
    );
    const hook = renderHook(() => useWorkflowSave(), { wrapper });
    render(<WorkflowSavePendingNotice />);
    vi.useFakeTimers();
    let saving!: Promise<unknown>;
    await act(async () => {
      saving = hook.result.current.mutateAsync(undefined);
    });
    await act(async () => vi.advanceTimersByTimeAsync(30_000));
    expect(mocks.put).toHaveBeenCalledOnce();
    expect(screen.getByRole("button", { name: "Reload" })).toBeTruthy();
    expect(
      screen.queryByRole("button", { name: "Discard pending save" }),
    ).toBeNull();
    const owner = useWorkflowYamlEditorStore.getState().editorOwner!;
    act(() => {
      unregisterEditorOwner(owner);
      registerEditorOwner(createYamlCommitOwner("wpid-1"));
    });
    expect(screen.getByRole("button", { name: "Reload" })).toBeTruthy();
    expect(
      screen.queryByRole("button", { name: "Discard pending save" }),
    ).toBeNull();
    expect(
      beginSaveTransaction(useWorkflowYamlEditorStore.getState().editorOwner!),
    ).toBe(false);
    await act(async () => {
      resolvePut({ data: saveData.workflow });
      await saving;
    });
  });

  it.each([false, true])(
    "restores a save marker and hydrates only a newer canonical version (local edits: %s)",
    (edited) => {
      sessionStorage.setItem(
        "workflow-pending-save:wpid-1",
        JSON.stringify({
          workflowPermanentId: "wpid-1",
          baseVersion: 1,
          timestamp: Date.now(),
        }),
      );
      useWorkflowYamlEditorStore.setState(
        useWorkflowYamlEditorStore.getInitialState(),
      );
      const owner = createYamlCommitOwner("wpid-1");
      registerEditorOwner(owner);
      const hydrate = vi.fn();
      useWorkflowHasChangesStore.setState({
        hasChanges: false,
        hydrateSavedSettings: hydrate,
      });
      const hook = renderHook(
        ({ workflow }) => usePendingWorkflowSaveRecovery(workflow),
        { wrapper, initialProps: { workflow: saveData.workflow } },
      );
      expect(beginSaveTransaction(owner)).toBe(false);
      expect(hydrate).not.toHaveBeenCalled();
      render(<WorkflowSavePendingNotice />);
      expect(screen.getByRole("button", { name: "Reload" })).toBeTruthy();
      if (edited) useWorkflowHasChangesStore.setState({ hasChanges: true });
      const canonical = {
        ...saveData.workflow,
        title: "Canonical after reload",
        description: "Canonical description",
        version: 2,
      };
      hook.rerender({ workflow: canonical });
      expect(hydrate).toHaveBeenCalledExactlyOnceWith(canonical, {
        hydrateGraph: true,
      });
      expect(useWorkflowTitleStore.getState().title).toBe(canonical.title);
      expect(
        useWorkflowYamlEditorStore.getState().pendingSaves["wpid-1"],
      ).toBeUndefined();
      expect(sessionStorage.getItem("workflow-pending-save:wpid-1")).toBeNull();
      expect(screen.queryByRole("status")).toBeNull();
      expect(useWorkflowHasChangesStore.getState().hasChanges).toBe(false);
      expect(beginSaveTransaction(owner)).toBe(true);
    },
  );

  it.each([200, 422, 500])(
    "writes the save marker before PUT and removes it on HTTP %s",
    async (status) => {
      let markerDuringPut: unknown;
      mocks.put.mockImplementationOnce(() => {
        markerDuringPut = JSON.parse(
          sessionStorage.getItem("workflow-pending-save:wpid-1")!,
        );
        if (status !== 200)
          return Promise.reject(
            new AxiosError("HTTP error", undefined, undefined, undefined, {
              status,
              data: { detail: "HTTP error" },
            } as NonNullable<AxiosError["response"]>),
          );
        return Promise.resolve({
          data: { ...saveData.workflow, title: saveData.title },
        });
      });
      const hook = renderHook(() => useWorkflowSave(), { wrapper });
      await act(async () => {
        await hook.result.current.mutateAsync(undefined).catch(() => undefined);
      });
      expect(mocks.put).toHaveBeenCalledOnce();
      expect(markerDuringPut).toMatchObject({
        workflowPermanentId: "wpid-1",
        baseVersion: 1,
        timestamp: expect.any(Number),
      });
      expect(sessionStorage.getItem("workflow-pending-save:wpid-1")).toBeNull();
      expect(
        useWorkflowYamlEditorStore.getState().pendingSaves["wpid-1"],
      ).toBeUndefined();
    },
  );

  it.each(["visual", "YAML"])(
    "sends a %s PUT and retains its hold with a notice when session storage is unavailable",
    async (mode) => {
      const storage = vi
        .spyOn(Storage.prototype, "setItem")
        .mockImplementation(() => {
          throw new DOMException("Storage unavailable", "QuotaExceededError");
        });
      let resolvePut!: (value: unknown) => void;
      mocks.put.mockReset().mockImplementationOnce(
        () =>
          new Promise((resolve) => {
            resolvePut = resolve;
          }),
      );
      const owner = useWorkflowYamlEditorStore.getState().editorOwner!;
      const hook = renderHook(() => useWorkflowSave(), { wrapper });
      render(<WorkflowSavePendingNotice />);
      if (mode === "YAML") beginYamlCommit(owner);
      let saving!: Promise<unknown>;
      try {
        act(() => {
          saving = hook.result.current
            .mutateAsync(
              mode === "YAML"
                ? {
                    yamlCommit: {
                      owner,
                      revision: useWorkflowYamlEditorStore.getState().revision,
                    },
                  }
                : undefined,
            )
            .catch((error) => error);
        });
        await waitFor(() => expect(mocks.put).toHaveBeenCalledOnce());
        expect(
          useWorkflowYamlEditorStore.getState().pendingSaves["wpid-1"],
        ).toMatchObject({ persisting: true });
        expect(beginSaveTransaction(owner)).toBe(false);
        expect(beginCopilotAcceptance()).toBeNull();
        expect(screen.getByRole("status").textContent).toContain(
          "Reload protection for this save is unavailable because session storage is unavailable.",
        );
        const returning = createYamlCommitOwner("wpid-1");
        act(() => {
          unregisterEditorOwner(owner);
          registerEditorOwner(returning);
        });
        expect(beginSaveTransaction(returning)).toBe(false);
        expect(screen.getByRole("status").textContent).toContain(
          "Reload protection",
        );
        await act(async () => {
          resolvePut({
            data: {
              ...saveData.workflow,
              title: saveData.title,
              description: saveData.description,
            },
          });
          await saving;
        });
        expect(screen.queryByRole("status")).toBeNull();
        expect(
          useWorkflowYamlEditorStore.getState().pendingSaves["wpid-1"],
        ).toBeUndefined();
      } finally {
        storage.mockRestore();
      }
    },
  );

  it("writes the pending-save marker without a degraded-mode notice when storage works", async () => {
    let resolvePut!: (value: unknown) => void;
    mocks.put.mockReset().mockImplementationOnce(
      () =>
        new Promise((resolve) => {
          resolvePut = resolve;
        }),
    );
    const hook = renderHook(() => useWorkflowSave(), { wrapper });
    render(<WorkflowSavePendingNotice />);
    let saving!: Promise<unknown>;
    act(() => {
      saving = hook.result.current.mutateAsync(undefined);
    });
    await waitFor(() => expect(mocks.put).toHaveBeenCalledOnce());
    expect(
      JSON.parse(sessionStorage.getItem("workflow-pending-save:wpid-1")!),
    ).toMatchObject({
      workflowPermanentId: "wpid-1",
      baseVersion: 1,
      timestamp: expect.any(Number),
    });
    expect(
      beginSaveTransaction(useWorkflowYamlEditorStore.getState().editorOwner!),
    ).toBe(false);
    expect(screen.queryByText(/Reload protection/)).toBeNull();
    await act(async () => {
      resolvePut({
        data: {
          ...saveData.workflow,
          title: saveData.title,
          description: saveData.description,
        },
      });
      await saving;
    });
    expect(sessionStorage.getItem("workflow-pending-save:wpid-1")).toBeNull();
  });

  it.each([false, true])(
    "A46 hydrates another workflow while a disposed YAML PUT is pending (return: %s)",
    async (returnToOriginal) => {
      const owner = useWorkflowYamlEditorStore.getState().editorOwner!;
      let resolvePut!: (value: unknown) => void;
      mocks.put.mockImplementationOnce(
        () =>
          new Promise((resolve) => {
            resolvePut = resolve;
          }),
      );
      const hook = renderHook(() => useWorkflowSave(), { wrapper });
      beginYamlCommit(owner);
      let saving!: Promise<unknown>;
      act(() => {
        saving = hook.result.current.mutateAsync({
          yamlCommit: {
            owner,
            revision: useWorkflowYamlEditorStore.getState().revision,
          },
        });
      });
      await waitFor(() => expect(mocks.put).toHaveBeenCalledOnce());
      hook.unmount();
      unregisterEditorOwner(owner);
      const next = createYamlCommitOwner("wpid-next");
      const parameters = [
        {
          key: "next_input",
          parameterType: "context" as const,
          sourceParameterKey: "source",
        },
      ];
      useWorkflowParametersStore
        .getState()
        .setParameters(parameters, { workflowPermanentId: "wpid-next" });
      useWorkflowTitleStore
        .getState()
        .initializeTitle("Next title", "wpid-next");
      useWorkflowTitleStore
        .getState()
        .initializeDescription("wpid-next", "Next description");
      registerEditorOwner(next);
      expect(useWorkflowParametersStore.getState().parameters).toEqual(
        parameters,
      );
      expect(useWorkflowTitleStore.getState()).toMatchObject({
        title: "Next title",
        description: "Next description",
      });
      const hydrate = vi.fn();
      useWorkflowHasChangesStore.setState({ hydrateSavedSettings: hydrate });
      if (returnToOriginal) {
        unregisterEditorOwner(next);
        registerEditorOwner(createYamlCommitOwner("wpid-1"));
        expect(useWorkflowYamlEditorStore.getState().commitInProgress).toBe(
          true,
        );
      }
      await act(async () => {
        resolvePut({
          data: {
            ...saveData.workflow,
            title: "Original saved",
            description: "Original description",
          },
        });
        await saving;
      });
      expect(hydrate).toHaveBeenCalledTimes(returnToOriginal ? 1 : 0);
      expect(useWorkflowTitleStore.getState().title).toBe(
        returnToOriginal ? "Original saved" : "Next title",
      );
    },
  );

  it.each(["skyvern-3.0", null])(
    "A46 keeps the cached effective_default_engine %s when a disposed-owner PUT without it hydrates the active editor",
    async (cachedEngine) => {
      const owner = useWorkflowYamlEditorStore.getState().editorOwner!;
      const queryClient = new QueryClient({
        defaultOptions: { queries: { staleTime: 5 * 60 * 1000, retry: false } },
      });
      const queryKey = ["workflow", "wpid-1"];
      queryClient.setQueryData(queryKey, {
        ...saveData.workflow,
        effective_default_engine: cachedEngine,
      });
      function cacheWrapper({ children }: { children: ReactNode }) {
        return (
          <QueryClientProvider client={queryClient}>
            {children}
          </QueryClientProvider>
        );
      }
      let resolvePut!: (value: unknown) => void;
      mocks.put.mockImplementationOnce(
        () =>
          new Promise((resolve) => {
            resolvePut = resolve;
          }),
      );
      const hook = renderHook(() => useWorkflowSave(), {
        wrapper: cacheWrapper,
      });
      beginYamlCommit(owner);
      let saving!: Promise<unknown>;
      act(() => {
        saving = hook.result.current.mutateAsync({
          yamlCommit: {
            owner,
            revision: useWorkflowYamlEditorStore.getState().revision,
          },
        });
      });
      await waitFor(() => expect(mocks.put).toHaveBeenCalledOnce());
      hook.unmount();
      unregisterEditorOwner(owner);
      registerEditorOwner(createYamlCommitOwner("wpid-1"));
      const hydrate = vi.fn();
      useWorkflowHasChangesStore.setState({ hydrateSavedSettings: hydrate });
      await act(async () => {
        resolvePut({
          data: {
            ...saveData.workflow,
            title: "Original saved",
          },
        });
        await saving;
      });
      expect(hydrate).toHaveBeenCalledOnce();
      expect(queryClient.getQueryData(queryKey)).toMatchObject({
        title: "Original saved",
        effective_default_engine: cachedEngine,
      });
    },
  );

  it("A47 keeps a slow PUT reserved until its own response despite newer canonical versions", async () => {
    const owner = useWorkflowYamlEditorStore.getState().editorOwner!;
    let resolvePut!: (value: unknown) => void;
    mocks.put.mockImplementationOnce(
      () =>
        new Promise((resolve) => {
          resolvePut = resolve;
        }),
    );
    let canonical = { ...saveData.workflow, version: 1 };
    const get = vi.fn(async () => ({ data: canonical }));
    mocks.getClient.mockResolvedValue({
      put: mocks.put,
      get,
    });
    useWorkflowHasChangesStore.setState({
      getSaveData: () => ({
        ...saveData,
        workflow: { ...saveData.workflow, version: 1 },
      }),
    });
    const hook = renderHook(() => useWorkflowSave(), { wrapper });
    vi.useFakeTimers();
    beginYamlCommit(owner);
    let saving!: Promise<unknown>;
    act(() => {
      saving = hook.result.current.mutateAsync({
        yamlCommit: {
          owner,
          revision: useWorkflowYamlEditorStore.getState().revision,
        },
      });
    });
    await act(async () => {});
    expect(mocks.put).toHaveBeenCalledOnce();
    let settled = false;
    void saving.then(() => {
      settled = true;
    });
    hook.unmount();
    unregisterEditorOwner(owner);
    const next = createYamlCommitOwner("wpid-next");
    registerEditorOwner(next);
    expect(beginYamlCommit(next)).toBe(true);
    finishYamlCommit(next);
    const nextData = {
      ...saveData,
      title: "Next saved",
      workflow: { ...saveData.workflow, workflow_permanent_id: "wpid-next" },
    };
    useWorkflowHasChangesStore.setState({ getSaveData: () => nextData });
    const nextSave = renderHook(() => useWorkflowSave(), { wrapper });
    mocks.put.mockResolvedValueOnce({
      data: {
        ...nextData.workflow,
        title: nextData.title,
        description: nextData.description,
      },
    });
    await act(async () => {
      await nextSave.result.current.mutateAsync(undefined);
    });
    expect(mocks.put.mock.calls[1]?.[0]).toBe("/workflows/wpid-next");
    await act(async () => vi.advanceTimersByTimeAsync(30_000));
    expect(
      useWorkflowYamlEditorStore.getState().pendingSaves["wpid-1"]?.slow,
    ).toBe(true);
    expect(
      useWorkflowYamlEditorStore.getState().pendingSaves["wpid-next"],
    ).toBeUndefined();
    expect(useWorkflowYamlEditorStore.getState().commitInProgress).toBe(false);
    unregisterEditorOwner(next);
    registerEditorOwner(createYamlCommitOwner("wpid-1"));
    expect(useWorkflowYamlEditorStore.getState().commitInProgress).toBe(true);
    for (const workflow_definition of [
      { version: 1, blocks: [], parameters: [] },
      {
        ...canonical.workflow_definition,
        blocks: [{ block_type: "task", label: "other_writer" }],
      },
    ]) {
      canonical = {
        ...canonical,
        version: canonical.version + 1,
        workflow_definition,
      } as typeof canonical;
      await act(async () => {
        await get();
        await vi.advanceTimersByTimeAsync(2_000);
      });
      expect(settled).toBe(false);
      expect(useWorkflowYamlEditorStore.getState().commitInProgress).toBe(true);
      expect(
        beginSaveTransaction(
          useWorkflowYamlEditorStore.getState().editorOwner!,
        ),
      ).toBe(false);
    }
    expect(get).toHaveBeenCalledTimes(2);
    expect(mocks.put.mock.calls[0]?.[2]).not.toHaveProperty("timeout");
    expect(mocks.put.mock.calls[0]?.[2]).not.toHaveProperty("signal");
    const ownResponse = { data: { ...saveData.workflow, version: 4 } };
    await act(async () => {
      resolvePut(ownResponse);
      expect(await saving).toBe(ownResponse);
    });
    expect(settled).toBe(true);
    expect(useWorkflowYamlEditorStore.getState().commitInProgress).toBe(false);
    expect(
      useWorkflowYamlEditorStore.getState().pendingSaves["wpid-1"],
    ).toBeUndefined();
    vi.useRealTimers();
  });

  it.each(["conversion failure", "refused", "stale", "disposed"])(
    "clears confirmation approval when YAML Save exits before mutation: %s",
    async (outcome) => {
      const state = useWorkflowYamlEditorStore.getState();
      state.open("blocks: []");
      state.setDraft("blocks: []\ntitle: changed");
      const convert = vi.fn().mockRejectedValue(new Error("conversion failed"));
      state.registerCommit(async () => {
        if (outcome === "conversion failure") {
          try {
            await convert();
          } catch {
            return false;
          }
        }
        if (outcome === "disposed")
          unregisterEditorOwner(
            useWorkflowYamlEditorStore.getState().editorOwner!,
          );
        return false;
      });
      if (outcome === "refused")
        useWorkflowYamlEditorStore.setState({ authoringInProgress: true });
      useWorkflowHasChangesStore.getState().setSaidOkToCodeCacheDeletion(true);
      const first = renderHook(() => useSaveWorkflow(), { wrapper });
      await act(async () => {
        await expect(first.result.current()).rejects.toThrow();
      });
      expect(mocks.put).not.toHaveBeenCalled();
      expect(
        useWorkflowHasChangesStore.getState().saidOkToCodeCacheDeletion,
      ).toBe(false);
      if (outcome === "conversion failure")
        expect(convert).toHaveBeenCalledOnce();
      useWorkflowYamlEditorStore.setState(
        useWorkflowYamlEditorStore.getInitialState(),
      );
      registerEditorOwner(createYamlCommitOwner("wpid-1"));
      const next = renderHook(() => useWorkflowSave(), { wrapper });
      await act(async () => next.result.current.mutateAsync(undefined));
      expect(mocks.put.mock.calls[0]?.[2].params.delete_code_cache_is_ok).toBe(
        "false",
      );
    },
  );

  it("keeps the approved YAML Save when Yes is clicked twice during conversion", async () => {
    let finishConversion!: () => void;
    const conversion = new Promise<void>((resolve) => {
      finishConversion = resolve;
    });
    const owner = useWorkflowYamlEditorStore.getState().editorOwner!;
    const hook = renderHook(
      () => ({ save: useSaveWorkflow(), mutation: useWorkflowSave() }),
      { wrapper },
    );
    const state = useWorkflowYamlEditorStore.getState();
    state.open("blocks: []");
    state.registerCommit(async (_persist, codeCacheDeletionApproved) => {
      if (!beginYamlCommit(owner)) return false;
      await conversion;
      await hook.result.current.mutation.mutateAsync({
        codeCacheDeletionApproved,
        yamlCommit: {
          owner,
          revision: useWorkflowYamlEditorStore.getState().revision,
        },
      });
      finishYamlCommit(owner);
      return true;
    });
    useWorkflowHasChangesStore.getState().setSaidOkToCodeCacheDeletion(true);
    let first!: Promise<void>;
    act(() => {
      first = hook.result.current.save();
    });
    useWorkflowHasChangesStore.getState().setSaidOkToCodeCacheDeletion(true);
    await act(async () => {
      await expect(hook.result.current.save()).rejects.toThrow();
    });
    await act(async () => {
      finishConversion();
      await first;
    });
    expect(mocks.put.mock.calls[0]?.[2].params.delete_code_cache_is_ok).toBe(
      "true",
    );
  });

  it.each(["save", "confirmation"] as const)(
    "does not clear a newer approval when disposed conversion settles through %s",
    async (entry) => {
      let finishConversion!: () => void;
      const conversion = new Promise<void>((resolve) => {
        finishConversion = resolve;
      });
      const owner = useWorkflowYamlEditorStore.getState().editorOwner!;
      const hook = renderHook(() => useSaveWorkflow(), { wrapper });
      useWorkflowYamlEditorStore.getState().open("blocks: []");
      useWorkflowYamlEditorStore.getState().registerCommit(async () => {
        await conversion;
        return false;
      });
      useWorkflowHasChangesStore.getState().setSaidOkToCodeCacheDeletion(true);
      let first!: Promise<void | boolean>;
      act(() => {
        first =
          entry === "confirmation"
            ? confirmCodeCacheDeletion(hook.result.current)
            : hook.result.current();
        void first.catch(() => undefined);
      });
      unregisterEditorOwner(owner);
      registerEditorOwner(createYamlCommitOwner("wpid-next"));
      useWorkflowHasChangesStore.getState().setSaidOkToCodeCacheDeletion(true);
      await act(async () => {
        finishConversion();
        if (entry === "confirmation") expect(await first).toBe(false);
        else await expect(first).rejects.toThrow();
      });
      expect(
        useWorkflowHasChangesStore.getState().saidOkToCodeCacheDeletion,
      ).toBe(true);
    },
  );

  it.each(["ordinary", "YAML"])(
    "hydrates a revisited workflow under the pending %s lock before marking it clean",
    async (mode) => {
      const owner = useWorkflowYamlEditorStore.getState().editorOwner!;
      let resolvePut!: (value: unknown) => void;
      mocks.put.mockImplementationOnce(
        () =>
          new Promise((resolve) => {
            resolvePut = resolve;
          }),
      );
      const first = renderHook(() => useWorkflowSave(), { wrapper });
      let saving!: Promise<unknown>;
      act(() => {
        if (mode === "YAML") beginYamlCommit(owner);
        saving = first.result.current.mutateAsync(
          mode === "YAML"
            ? {
                yamlCommit: {
                  owner,
                  revision: useWorkflowYamlEditorStore.getState().revision,
                },
              }
            : undefined,
        );
      });
      await waitFor(() => expect(mocks.put).toHaveBeenCalledOnce());
      first.unmount();
      unregisterEditorOwner(owner);
      registerEditorOwner(createYamlCommitOwner("wpid-1"));
      expect(useWorkflowYamlEditorStore.getState().commitInProgress).toBe(true);
      const saved = {
        ...saveData.workflow,
        title: "Saved on server",
        workflow_definition: {
          version: 1,
          blocks: [{ block_type: "task", label: "saved" }],
          parameters: [],
        },
      };
      let hydrated = false;
      const hydrateSavedSettings = vi.fn(() => {
        expect(useWorkflowYamlEditorStore.getState().commitInProgress).toBe(
          true,
        );
        expect(useWorkflowHasChangesStore.getState().hasChanges).toBe(true);
        hydrated = true;
      });
      useWorkflowHasChangesStore.setState({
        hasChanges: true,
        hydrateSavedSettings,
      });
      const unsubscribe = useWorkflowHasChangesStore.subscribe((state) => {
        if (!state.hasChanges) expect(hydrated).toBe(true);
      });
      await act(async () => {
        resolvePut({ data: saved });
        await saving;
      });
      unsubscribe();
      expect(hydrateSavedSettings).toHaveBeenCalledExactlyOnceWith(saved, {
        hydrateGraph: true,
      });
      expect(useWorkflowTitleStore.getState().title).toBe("Saved on server");
      expect(useWorkflowHasChangesStore.getState().hasChanges).toBe(false);
      expect(useWorkflowYamlEditorStore.getState().commitInProgress).toBe(
        false,
      );
    },
  );

  it.each(
    ["ordinary", "YAML"].flatMap((mode) =>
      ["success", "error"].map((outcome) => [mode, outcome]),
    ),
  )(
    "A42 consumes cache deletion approval for a disposed %s save on %s",
    async (mode, outcome) => {
      const owner = useWorkflowYamlEditorStore.getState().editorOwner!;
      useWorkflowHasChangesStore.getState().setSaidOkToCodeCacheDeletion(true);
      let resolvePut!: (value: unknown) => void;
      let rejectPut!: (error: Error) => void;
      mocks.put.mockImplementationOnce(
        () =>
          new Promise((resolve, reject) => {
            resolvePut = resolve;
            rejectPut = reject;
          }),
      );
      const first = renderHook(() => useWorkflowSave(), { wrapper });
      if (mode === "YAML") expect(beginYamlCommit(owner)).toBe(true);
      let saving!: Promise<unknown>;
      act(() => {
        saving = first.result.current
          .mutateAsync(
            mode === "YAML"
              ? {
                  yamlCommit: {
                    owner,
                    revision: useWorkflowYamlEditorStore.getState().revision,
                  },
                }
              : undefined,
          )
          .catch((error: unknown) => error);
      });
      await waitFor(() => expect(mocks.put).toHaveBeenCalledOnce());
      expect(mocks.put.mock.calls[0]?.[2].params.delete_code_cache_is_ok).toBe(
        "true",
      );
      first.unmount();
      unregisterEditorOwner(owner);
      await act(async () => {
        if (outcome === "success") resolvePut({ data: saveData.workflow });
        else rejectPut(new Error("save failed"));
        await saving;
      });
      expect(
        useWorkflowHasChangesStore.getState().saidOkToCodeCacheDeletion,
      ).toBe(false);
      registerEditorOwner(createYamlCommitOwner("wpid-next"));
      useWorkflowHasChangesStore.setState({
        getSaveData: () => ({
          ...saveData,
          workflow: {
            ...saveData.workflow,
            workflow_permanent_id: "wpid-next",
          },
        }),
      });
      const next = renderHook(() => useWorkflowSave(), { wrapper });
      await act(async () => next.result.current.mutateAsync(undefined));
      expect(mocks.put.mock.calls[1]?.[2].params.delete_code_cache_is_ok).toBe(
        "false",
      );
    },
  );

  it.each(["success", "error", "abort"])(
    "reserves an in-flight Save until %s settlement",
    async (outcome) => {
      let resolvePut!: (value: unknown) => void;
      let rejectPut!: (error: Error) => void;
      mocks.put.mockImplementationOnce(
        () =>
          new Promise((resolve, reject) => {
            resolvePut = resolve;
            rejectPut = reject;
          }),
      );
      const failure =
        outcome === "abort"
          ? new AxiosError("aborted", "ERR_CANCELED")
          : new AxiosError(outcome, undefined, undefined, undefined, {
              status: 500,
              data: { detail: "Server error" },
            } as NonNullable<AxiosError["response"]>);
      const commit = vi.fn().mockResolvedValue(true);
      useWorkflowYamlEditorStore.getState().registerCommit(commit);
      const { result } = renderHook(() => useWorkflowSave(), { wrapper });
      let saving!: Promise<unknown>;
      act(() => {
        saving = result.current.mutateAsync(undefined);
      });
      const settled = saving.then(
        () => null,
        (error: Error) => error,
      );
      await waitFor(() => expect(mocks.put).toHaveBeenCalledOnce());
      expect(beginCopilotAcceptance()).toBeNull();
      expect(beginYamlCommit(createYamlCommitOwner("wpid-1"))).toBe(false);
      expect(await commitYamlDraft(true)).toBe(false);
      expect(commit).not.toHaveBeenCalled();
      await expect(
        act(async () => result.current.mutateAsync(undefined)),
      ).rejects.toThrow("A save is in progress");
      await act(async () => {
        if (outcome === "success")
          resolvePut({
            data: {
              ...saveData.workflow,
              title: saveData.title,
              description: null,
            },
          });
        else rejectPut(failure);
        expect(await settled).toEqual(outcome === "success" ? null : failure);
      });
      const token = beginCopilotAcceptance();
      if (outcome === "abort") {
        expect(token).toBeNull();
        expect(
          useWorkflowYamlEditorStore.getState().pendingSaves["wpid-1"],
        ).toMatchObject({ persisting: true, slow: true });
      } else {
        expect(token).not.toBeNull();
        finishCopilotAcceptance(token!);
      }
    },
  );

  it("keeps the Save reservation after editor disposal until the PUT settles", async () => {
    const owner = useWorkflowYamlEditorStore.getState().editorOwner!;
    let resolvePut!: (value: unknown) => void;
    mocks.put.mockImplementationOnce(
      () =>
        new Promise((resolve) => {
          resolvePut = resolve;
        }),
    );
    const { result, unmount } = renderHook(() => useWorkflowSave(), {
      wrapper,
    });
    let saving!: Promise<unknown>;
    act(() => {
      saving = result.current.mutateAsync(undefined);
    });
    await waitFor(() => expect(mocks.put).toHaveBeenCalledOnce());
    unmount();
    unregisterEditorOwner(owner);
    useWorkflowYamlEditorStore.getState().setCommitInProgress(false);
    expect(beginCopilotAcceptance()).toBeNull();
    await act(async () => {
      resolvePut({
        data: {
          ...saveData.workflow,
          title: saveData.title,
          description: null,
        },
      });
      await saving;
    });
    const token = beginCopilotAcceptance();
    expect(token).not.toBeNull();
    finishCopilotAcceptance(token!);
  });

  it.each(
    ["ordinary", "YAML commit"].flatMap((mode) =>
      ["success", "network error", "confirmation error"].map((outcome) => [
        mode,
        outcome,
      ]),
    ),
  )(
    "invalidates the submitted workflow after disposal for %s on %s without changing editor state",
    async (mode, outcome) => {
      const owner = useWorkflowYamlEditorStore.getState().editorOwner!;
      const queryClient = new QueryClient({
        defaultOptions: { queries: { staleTime: 5 * 60 * 1000, retry: false } },
      });
      const queryKey = ["workflow", "wpid-1"];
      const otherQueryKey = ["workflow", "wpid-other"];
      const originalWorkflow = { ...saveData.workflow, title: "Before save" };
      const serverWorkflow = {
        ...originalWorkflow,
        title: outcome === "success" ? "Saved title" : originalWorkflow.title,
      };
      queryClient.setQueryData(queryKey, originalWorkflow);
      queryClient.setQueryData(["workflows"], []);
      queryClient.setQueryData(["block-scripts", "wpid-1"], []);
      queryClient.setQueryData(otherQueryKey, { title: "Other workflow" });
      function cacheWrapper({ children }: { children: ReactNode }) {
        return (
          <QueryClientProvider client={queryClient}>
            {children}
          </QueryClientProvider>
        );
      }
      let resolvePut!: (value: unknown) => void;
      let rejectPut!: (error: Error) => void;
      mocks.put.mockImplementationOnce(
        () =>
          new Promise((resolve, reject) => {
            resolvePut = resolve;
            rejectPut = reject;
          }),
      );
      const failure = new AxiosError("save failed");
      if (outcome === "confirmation error") {
        failure.response = {
          data: { detail: "No confirmation for code cache deletion" },
        } as NonNullable<AxiosError["response"]>;
      }
      let currentSaveData = saveData;
      useWorkflowHasChangesStore.setState({
        getSaveData: () => currentSaveData,
      });
      const { result, unmount } = renderHook(() => useWorkflowSave(), {
        wrapper: cacheWrapper,
      });
      if (mode === "YAML commit") expect(beginYamlCommit(owner)).toBe(true);
      let saving!: Promise<unknown>;
      act(() => {
        saving = result.current.mutateAsync(
          mode === "YAML commit"
            ? {
                yamlCommit: {
                  owner,
                  revision: useWorkflowYamlEditorStore.getState().revision,
                },
              }
            : undefined,
        );
      });
      const settled = saving.catch((error: unknown) => error);
      await waitFor(() => expect(mocks.put).toHaveBeenCalledOnce());
      expect(mocks.put.mock.calls[0]?.[0]).toBe("/workflows/wpid-1");
      unmount();
      unregisterEditorOwner(owner);
      registerEditorOwner(createYamlCommitOwner("wpid-other"));
      currentSaveData = {
        ...saveData,
        workflow: { ...saveData.workflow, workflow_permanent_id: "wpid-other" },
      };
      const hydrateSavedSettings = vi.fn();
      useWorkflowHasChangesStore.setState({
        hydrateSavedSettings,
        hasChanges: true,
        saidOkToCodeCacheDeletion: true,
        showConfirmCodeCacheDeletion: false,
      });
      const editorState = useWorkflowHasChangesStore.getState();
      const metadataState = useWorkflowTitleStore.getState();
      expect(queryClient.getQueryState(queryKey)?.isInvalidated).toBe(false);
      await act(async () => {
        if (outcome === "success") resolvePut({ data: serverWorkflow });
        else rejectPut(failure);
        const result = await settled;
        if (outcome !== "success") expect(result).toBe(failure);
      });
      expect(queryClient.getQueryState(queryKey)?.isInvalidated).toBe(true);
      expect(queryClient.getQueryState(["workflows"])?.isInvalidated).toBe(
        true,
      );
      expect(
        queryClient.getQueryState(["block-scripts", "wpid-1"])?.isInvalidated,
      ).toBe(true);
      expect(queryClient.getQueryState(otherQueryKey)?.isInvalidated).toBe(
        false,
      );
      expect(hydrateSavedSettings).not.toHaveBeenCalled();
      expect(useWorkflowHasChangesStore.getState()).toEqual(editorState);
      expect(useWorkflowTitleStore.getState()).toBe(metadataState);
      const refetch = vi.fn().mockResolvedValue(serverWorkflow);
      const reopened = renderHook(
        () => useQuery({ queryKey, queryFn: refetch }),
        { wrapper: cacheWrapper },
      );
      await waitFor(() => expect(refetch).toHaveBeenCalledOnce());
      await waitFor(() =>
        expect(reopened.result.current.data).toEqual(serverWorkflow),
      );
      reopened.unmount();
      queryClient.clear();
    },
  );

  it.each(["before save", "while credentials load"])(
    "preserves the draft when authoring starts %s",
    async (timing) => {
      useWorkflowHasChangesStore.setState({ hasChanges: true });
      if (timing === "before save") {
        useWorkflowYamlEditorStore.setState({ authoringInProgress: true });
      } else {
        mocks.getClient.mockImplementationOnce(async () => {
          useWorkflowYamlEditorStore.setState({ authoringInProgress: true });
          return { put: mocks.put };
        });
      }
      const { result } = renderHook(() => useWorkflowSave(), { wrapper });

      const refused = act(async () => result.current.mutateAsync(undefined));
      await expect(refused).rejects.toBeInstanceOf(SaveRefusedError);
      await expect(refused).rejects.toThrow(
        "Finish the current authoring action before saving",
      );
      expect(mocks.put).not.toHaveBeenCalled();
      expect(useWorkflowHasChangesStore.getState()).toMatchObject({
        hasChanges: true,
      });

      useWorkflowYamlEditorStore.setState({ authoringInProgress: false });
      await act(async () => result.current.mutateAsync(undefined));
      expect(mocks.put).toHaveBeenCalledOnce();
    },
  );

  it("refuses Save when Copilot already reserves the workflow", async () => {
    useWorkflowHasChangesStore.setState({ hasChanges: true });
    const reservation = beginCopilotAcceptance()!;
    const { result } = renderHook(() => useWorkflowSave(), { wrapper });
    await expect(
      act(async () => result.current.mutateAsync(undefined)),
    ).rejects.toThrow("Wait for the Copilot change to finish");
    expect(mocks.getClient).not.toHaveBeenCalled();
    expect(mocks.put).not.toHaveBeenCalled();
    expect(useWorkflowHasChangesStore.getState()).toMatchObject({
      hasChanges: true,
    });
    finishCopilotAcceptance(reservation);
  });

  it("reserves Save before credentials load and refuses a competing Save", async () => {
    let resolveClient!: (value: unknown) => void;
    mocks.getClient.mockImplementationOnce(
      () =>
        new Promise((resolve) => {
          resolveClient = resolve;
        }),
    );
    const { result } = renderHook(() => useWorkflowSave(), { wrapper });
    let saving!: Promise<unknown>;
    act(() => {
      saving = result.current.mutateAsync(undefined);
    });
    await waitFor(() => expect(mocks.getClient).toHaveBeenCalledOnce());
    expect(beginCopilotAcceptance()).toBeNull();
    expect(beginYamlCommit(createYamlCommitOwner("wpid-1"))).toBe(false);
    await expect(
      act(async () => result.current.mutateAsync(undefined)),
    ).rejects.toThrow("A save is in progress");
    expect(beginCopilotAcceptance()).toBeNull();
    await act(async () => {
      resolveClient({ put: mocks.put });
      await saving;
    });
    expect(mocks.put).toHaveBeenCalledOnce();
    const token = beginCopilotAcceptance();
    expect(token).not.toBeNull();
    finishCopilotAcceptance(token!);
  });

  it("allows only the matching YAML transaction to save", async () => {
    const owner = useWorkflowYamlEditorStore.getState().editorOwner!;
    useWorkflowHasChangesStore.setState({ hasChanges: true });
    expect(beginYamlCommit(owner)).toBe(true);
    const { result } = renderHook(() => useWorkflowSave(), { wrapper });
    await expect(
      act(async () => result.current.mutateAsync(undefined)),
    ).rejects.toThrow("A YAML commit is in progress");
    expect(mocks.put).not.toHaveBeenCalled();
    await act(async () =>
      result.current.mutateAsync({
        yamlCommit: {
          owner,
          revision: useWorkflowYamlEditorStore.getState().revision,
        },
        title: "Committed YAML title",
      }),
    );
    expect(mocks.put).toHaveBeenCalledOnce();
    expect(parseYaml(mocks.put.mock.calls[0]?.[1])).toMatchObject({
      title: "Committed YAML title",
    });
    expect(useWorkflowYamlEditorStore.getState().commitOwner).toBe(owner);
    await act(async () => {
      useWorkflowHasChangesStore
        .getState()
        .setHasChanges(false, { fromYamlCommit: true });
    });
    finishYamlCommit(owner);
  });

  it("releases Save when credential loading fails", async () => {
    mocks.getClient.mockRejectedValueOnce(new Error("credentials unavailable"));
    const { result } = renderHook(() => useWorkflowSave(), { wrapper });
    await expect(
      act(async () => result.current.mutateAsync(undefined)),
    ).rejects.toThrow("credentials unavailable");
    expect(mocks.put).not.toHaveBeenCalled();
    const token = beginCopilotAcceptance();
    expect(token).not.toBeNull();
    finishCopilotAcceptance(token!);
  });

  it("initializes another workflow clean while the previous workflow save stays pending", async () => {
    useWorkflowHasChangesStore.getState().setHasChanges(true);
    const firstOwner = useWorkflowYamlEditorStore.getState().editorOwner!;
    let resolveSave!: (value: unknown) => void;
    mocks.put.mockImplementationOnce(
      () =>
        new Promise((resolve) => {
          resolveSave = resolve;
        }),
    );
    const { result } = renderHook(() => useWorkflowSave(), { wrapper });
    let saving!: Promise<unknown>;
    act(() => {
      saving = result.current.mutateAsync(undefined);
    });
    await waitFor(() => expect(resolveSave).toBeTypeOf("function"));
    act(() => {
      unregisterEditorOwner(firstOwner);
      registerEditorOwner(createYamlCommitOwner("wpid-2"));
      useWorkflowHasChangesStore.getState().setHasChanges(false);
    });
    expect(useWorkflowHasChangesStore.getState().hasChanges).toBe(false);
    await act(async () => {
      resolveSave({ data: saveData.workflow });
      await saving;
    });
    expect(useWorkflowHasChangesStore.getState()).toMatchObject({
      hasChanges: false,
      saveGenerationsByWorkflow: {},
    });
    expect(
      useWorkflowHasChangesStore.getState().saveGenerationsByWorkflow["wpid-2"],
    ).toBeUndefined();
    expect(useWorkflowYamlEditorStore.getState().commitInProgress).toBe(false);
  });

  it("clears a revisited workflow's dirty state after its previous owner's save settles", async () => {
    useWorkflowHasChangesStore.getState().setHasChanges(true);
    const firstOwner = useWorkflowYamlEditorStore.getState().editorOwner!;
    const savedWorkflow = {
      ...saveData.workflow,
      title: saveData.title,
      description: saveData.description,
    };
    const hydrateSavedSettings = vi.fn(() => {
      expect(useWorkflowYamlEditorStore.getState().commitInProgress).toBe(true);
      expect(useWorkflowHasChangesStore.getState().hasChanges).toBe(true);
    });
    let resolveSave!: (value: unknown) => void;
    mocks.put.mockImplementationOnce(
      () =>
        new Promise((resolve) => {
          resolveSave = resolve;
        }),
    );
    const { result } = renderHook(() => useWorkflowSave(), { wrapper });
    let saving!: Promise<unknown>;
    act(() => {
      saving = result.current.mutateAsync(undefined);
    });
    await waitFor(() => expect(resolveSave).toBeTypeOf("function"));
    expect(useWorkflowYamlEditorStore.getState().commitInProgress).toBe(true);

    act(() => {
      unregisterEditorOwner(firstOwner);
      registerEditorOwner(
        createYamlCommitOwner(firstOwner.workflowPermanentId),
      );
      useWorkflowHasChangesStore.setState({ hydrateSavedSettings });
      useWorkflowHasChangesStore.getState().setHasChanges(false);
    });
    expect(useWorkflowHasChangesStore.getState().hasChanges).toBe(true);

    await act(async () => {
      resolveSave({ data: savedWorkflow });
      await saving;
    });
    expect(hydrateSavedSettings).toHaveBeenCalledExactlyOnceWith(
      savedWorkflow,
      {
        hydrateGraph: true,
      },
    );
    expect(useWorkflowYamlEditorStore.getState().commitInProgress).toBe(false);
    expect(useWorkflowHasChangesStore.getState().hasChanges).toBe(false);
  });

  it.each(["before save", "while credentials load"])(
    "refuses Save when Copilot reserves the workflow %s",
    async (timing) => {
      useWorkflowHasChangesStore.setState({ hasChanges: true });
      let reservation: symbol | null = null;
      if (timing === "before save") {
        reservation = beginCopilotAcceptance();
      } else {
        mocks.getClient.mockImplementationOnce(async () => {
          expect(beginCopilotAcceptance()).toBeNull();
          // Revalidate even if a writer bypasses the transaction entry point.
          reservation = Symbol("competing Copilot reservation");
          useWorkflowYamlEditorStore.setState({
            copilotAcceptance: reservation,
            lockKind: "copilot",
          });
          return { put: mocks.put };
        });
      }
      const { result } = renderHook(() => useWorkflowSave(), { wrapper });

      await expect(
        act(async () => result.current.mutateAsync(undefined)),
      ).rejects.toThrow("Wait for the Copilot change to finish");
      expect(mocks.getClient).toHaveBeenCalledTimes(
        timing === "before save" ? 0 : 1,
      );
      expect(mocks.put).not.toHaveBeenCalled();
      expect(useWorkflowHasChangesStore.getState()).toMatchObject({
        hasChanges: true,
      });
      expect(useWorkflowHasChangesStore.getState().getSaveData()).toBe(
        saveData,
      );
      finishCopilotAcceptance(reservation!);
    },
  );

  it.each(["before save", "while credentials load"])(
    "allows only the matching YAML transaction when a commit starts %s",
    async (timing) => {
      const owner = createYamlCommitOwner("wpid-1");
      useWorkflowHasChangesStore.setState({ hasChanges: true });
      if (timing === "before save") {
        expect(beginYamlCommit(owner)).toBe(true);
      } else {
        mocks.getClient.mockImplementationOnce(async () => {
          expect(beginYamlCommit(owner)).toBe(false);
          // Revalidate ownership even if a writer bypasses the transaction entry point.
          useWorkflowYamlEditorStore.setState({
            commitOwner: owner,
            commitInProgress: true,
            lockKind: "yaml",
          });
          return { put: mocks.put };
        });
      }
      const { result } = renderHook(() => useWorkflowSave(), { wrapper });
      await expect(
        act(async () => result.current.mutateAsync(undefined)),
      ).rejects.toThrow("A YAML commit is in progress");
      expect(mocks.getClient).toHaveBeenCalledTimes(
        timing === "before save" ? 0 : 1,
      );
      expect(mocks.put).not.toHaveBeenCalled();
      expect(useWorkflowHasChangesStore.getState().hasChanges).toBe(true);

      await act(async () =>
        result.current.mutateAsync({
          yamlCommit: {
            owner,
            revision: useWorkflowYamlEditorStore.getState().revision,
          },
          title: "Committed YAML title",
        }),
      );
      expect(mocks.put).toHaveBeenCalledTimes(1);
      expect(parseYaml(mocks.put.mock.calls[0]?.[1])).toMatchObject({
        title: "Committed YAML title",
      });
      finishYamlCommit(owner);
    },
  );

  it("does not hydrate over authoring that starts while a save is pending", async () => {
    const hydrate = vi.fn();
    useWorkflowHasChangesStore.setState({
      hasChanges: true,
      hydrateSavedSettings: hydrate,
    });
    let resolveSave!: (value: unknown) => void;
    mocks.put.mockImplementationOnce(
      () =>
        new Promise((resolve) => {
          resolveSave = resolve;
        }),
    );
    const { result } = renderHook(() => useWorkflowSave(), { wrapper });
    let saving!: Promise<unknown>;
    act(() => {
      saving = result.current.mutateAsync(undefined);
    });
    await waitFor(() => expect(resolveSave).toBeTypeOf("function"));
    const rejected = expect(saving).rejects.toThrow(
      "Saved on the server, but local edits changed during the save; reload.",
    );
    await act(async () => {
      useWorkflowYamlEditorStore.setState({ authoringInProgress: true });
      resolveSave({ data: saveData.workflow });
      await rejected;
    });
    expect(hydrate).not.toHaveBeenCalled();
    expect(useWorkflowHasChangesStore.getState()).toMatchObject({
      hasChanges: true,
      saveGenerationsByWorkflow: { "wpid-1": 1 },
    });
    expect(useWorkflowYamlEditorStore.getState().commitInProgress).toBe(false);
  });

  it("saves a corrected required Action Instruction before the debounce without a destructive toast", async () => {
    let saving!: Promise<void>;
    function BufferedAction() {
      const [instruction, setInstruction] = useState("");
      const save = useSaveWorkflow();
      useEffect(() => {
        const nodes: AppNode[] = [
          {
            id: "action",
            type: "action",
            position: { x: 0, y: 0 },
            data: {
              ...actionNodeDefaultData,
              label: "action",
              navigationGoal: instruction,
            },
          },
        ];
        mocks.getNodes.mockImplementation(() => nodes);
        useWorkflowHasChangesStore.getState().setGetSaveData(() => ({
          ...saveData,
          blocks: getWorkflowBlocks(nodes, []),
        }));
      }, [instruction]);
      return (
        <>
          <WorkflowBlockInputTextarea
            nodeId="action"
            name="navigationGoal"
            aria-label="Action Instruction"
            value={instruction}
            onChange={setInstruction}
            hideActions
          />
          <button
            onClick={() => {
              saving = save();
            }}
          >
            Save
          </button>
        </>
      );
    }
    const client = new QueryClient();
    const view = render(
      <QueryClientProvider client={client}>
        <ReactFlowProvider>
          <BufferedAction />
        </ReactFlowProvider>
      </QueryClientProvider>,
    );
    vi.useFakeTimers();
    try {
      const instruction = "Click the Continue button";
      fireEvent.change(
        screen.getByRole("textbox", { name: "Action Instruction" }),
        {
          target: { value: instruction },
        },
      );
      expect(getWorkflowErrors(mocks.getNodes())).toEqual([
        "action: Action Instruction is required.",
      ]);
      expect(
        useWorkflowHasChangesStore.getState().getSaveData()?.blocks[0],
      ).toMatchObject({
        navigation_goal: "",
      });
      await act(async () => {
        fireEvent.click(screen.getByRole("button", { name: "Save" }));
        await saving;
      });
      expect(mocks.put).toHaveBeenCalledOnce();
      expect(
        parseYaml(mocks.put.mock.calls[0]![1]).workflow_definition.blocks[0],
      ).toMatchObject({
        navigation_goal: instruction,
      });
      expect(toast).not.toHaveBeenCalledWith(
        expect.objectContaining({ variant: "destructive" }),
      );
    } finally {
      view.unmount();
      client.clear();
      vi.useRealTimers();
    }
  });

  it.each(["textarea", "code"] as const)(
    "includes buffered %s edits in a programmatic save before the debounce",
    async (kind) => {
      vi.stubGlobal("IntersectionObserver", undefined);
      let save!: () => Promise<unknown>;
      function BufferedBlock() {
        const [text, setText] = useState("original");
        const mutation = useWorkflowSave();
        save = () => mutation.mutateAsync(undefined);
        useEffect(() => {
          useWorkflowHasChangesStore.getState().setGetSaveData(() => ({
            ...saveData,
            blocks: [
              {
                block_type: "code",
                label: "code",
                code: text,
                error_code_mapping: null,
              },
            ],
          }));
        }, [text]);
        return kind === "textarea" ? (
          <WorkflowBlockInputTextarea
            nodeId="code"
            name="code"
            aria-label="Buffered instructions"
            value={text}
            onChange={setText}
            hideActions
          />
        ) : (
          <CodeEditor value={text} onChange={setText} deferKey="code" />
        );
      }
      const client = new QueryClient();
      const view = render(
        <QueryClientProvider client={client}>
          <ReactFlowProvider>
            <BufferedBlock />
          </ReactFlowProvider>
        </QueryClientProvider>,
      );
      vi.useFakeTimers();
      try {
        const newest = "new instructions before autoplay";
        act(() => {
          if (kind === "textarea")
            fireEvent.change(
              screen.getByRole("textbox", { name: "Buffered instructions" }),
              { target: { value: newest } },
            );
          else {
            const editor = EditorView.findFromDOM(
              view.container.querySelector<HTMLElement>(".cm-content")!,
            )!;
            editor.dispatch({
              changes: { from: 0, to: editor.state.doc.length, insert: newest },
            });
          }
        });
        expect(
          useWorkflowHasChangesStore.getState().getSaveData()?.blocks[0],
        ).toMatchObject({ code: "original" });
        await act(async () => {
          await save();
        });
        expect(mocks.put).toHaveBeenCalledOnce();
        expect(
          parseYaml(mocks.put.mock.calls[0]![1]).workflow_definition.blocks[0],
        ).toMatchObject({ code: newest });
        await act(async () => vi.advanceTimersByTimeAsync(300));
        expect(
          useWorkflowHasChangesStore.getState().getSaveData()?.blocks[0],
        ).toMatchObject({ code: newest });
      } finally {
        view.unmount();
        client.clear();
        vi.useRealTimers();
        vi.unstubAllGlobals();
      }
    },
  );
});

describe("blocked saves", () => {
  it("refuses to write the workflow and keeps it dirty while a save is blocked", async () => {
    mocks.put.mockClear();
    mocks.getClient.mockResolvedValue({ put: mocks.put });
    useWorkflowHasChangesStore.setState({
      getSaveData: () => saveData,
      hasChanges: true,
      saveBlockedReason: "An Accept's outcome is still unconfirmed.",
    });
    const { result } = renderHook(() => useWorkflowSave(), { wrapper });

    await act(async () => {
      await expect(result.current.mutateAsync(undefined)).rejects.toBeTruthy();
    });

    expect(mocks.put).not.toHaveBeenCalled();
    expect(useWorkflowHasChangesStore.getState().hasChanges).toBe(true);
    useWorkflowHasChangesStore.setState({ saveBlockedReason: null });
  });
});

describe("YAML draft dirtiness", () => {
  afterEach(() => {
    useWorkflowYamlEditorStore.setState(
      useWorkflowYamlEditorStore.getInitialState(),
    );
    useWorkflowHasChangesStore.setState({ hasChanges: false });
  });

  it("opens a clean YAML view during a Copilot turn without tripping its lock", () => {
    useWorkflowHasChangesStore.setState({ hasChanges: true });
    const token = beginCopilotAcceptance()!;
    vi.mocked(toast).mockClear();
    reflectYamlDraftDirtiness(true, false);
    expect(toast).not.toHaveBeenCalled();
    expect(useWorkflowHasChangesStore.getState().hasChanges).toBe(true);
    finishCopilotAcceptance(token);

    const revision = useWorkflowYamlEditorStore.getState().revision;
    reflectYamlDraftDirtiness(true, true);
    expect(useWorkflowYamlEditorStore.getState().revision).toBe(revision + 1);
  });
});