Skip to content

🪢 Open source agent evals & observability: Trace, evaluate, and improve LLM applications with one open platform.

58.4 KB
Raw Blame
import {
  act,
  fireEvent,
  render,
  screen,
  waitFor,
  within,
} from "@testing-library/react";
import {
  QueryClient,
  QueryClientProvider,
  type UseMutationOptions,
} from "@tanstack/react-query";
import type {
  CreateAnnotationScoreData,
  ScoreConfigDomain,
  ScoreDomain,
} from "@langfuse/shared";
import type HeaderComponent from "@/src/components/layouts/header";
import { LayerProvider } from "@/src/context/LayerContext/LayerContext";
import {
  ScoreCacheProvider,
  useScoreCache,
} from "@/src/features/scores/contexts/ScoreCacheProvider";
import { DualAnnotationContent } from "./DualAnnotationContent";
import { AnnotationForm } from "./AnnotationForm";
import { cloneElement, createRef } from "react";
import type { AnnotationRefreshHandle } from "../types";

const mocks = vi.hoisted(() => ({
  create: vi.fn(),
  update: vi.fn(),
  remove: vi.fn(),
  capture: vi.fn(),
  headerRender: vi.fn(),
  hasConfigAccess: false,
  configsLoading: false,
  scoreEditsDisabled: false,
}));
const defaultConfig = {
  id: "quality",
  name: "Quality",
  projectId: "project",
  dataType: "BOOLEAN",
  categories: [
    { label: "False", value: 0 },
    { label: "True", value: 1 },
  ],
  isArchived: false,
  createdAt: new Date(),
  updatedAt: new Date(),
} satisfies ScoreConfigDomain;
const configs: ScoreConfigDomain[] = [defaultConfig];

vi.mock("@/src/components/layouts/header", async (importOriginal) => {
  const { default: Header } = await importOriginal<{
    default: typeof HeaderComponent;
  }>();
  return {
    default: (props: React.ComponentProps<typeof Header>) => {
      mocks.headerRender();
      return <Header {...props} />;
    },
  };
});

vi.mock("@/src/features/rbac/utils/checkProjectAccess", () => ({
  useHasProjectAccess: () => mocks.hasConfigAccess,
}));
vi.mock("@/src/features/notifications/showErrorToast", () => ({
  showErrorToast: vi.fn(),
}));
vi.mock("@/src/features/scores/hooks/useScoreEditsDisabled", () => ({
  useScoreEditsDisabled: () => mocks.scoreEditsDisabled,
}));
vi.mock("@/src/features/posthog-analytics/usePostHogClientCapture", () => ({
  usePostHogClientCapture: () => mocks.capture,
}));
vi.mock("@/src/features/posthog-analytics/usePostHogClientCapture", () => ({
  usePostHogClientCapture: () => mocks.capture,
}));
vi.mock("@/src/utils/api", async () => {
  const { useMutation } = await import("@tanstack/react-query");
  return {
    api: {
      scoreConfigs: {
        create: {
          useMutation: (options: UseMutationOptions) =>
            useMutation({ ...options, mutationFn: vi.fn() }),
        },
        all: {
          useQuery: () => ({
            isLoading: mocks.configsLoading,
            data: { configs },
          }),
        },
        appendCategory: {
          useMutation: () => ({ mutate: vi.fn(), isPending: false }),
        },
      },
      useUtils: () => ({
        scoreConfigs: { invalidate: vi.fn() },
        annotationQueues: { invalidate: vi.fn() },
      }),
      scores: {
        createAnnotationScore: {
          useMutation: (
            options: UseMutationOptions<
              unknown,
              Error,
              CreateAnnotationScoreData
            >,
          ) => useMutation({ ...options, mutationFn: mocks.create }),
        },
        updateAnnotationScore: {
          useMutation: (options: UseMutationOptions) =>
            useMutation({ ...options, mutationFn: mocks.update }),
        },
        deleteAnnotationScore: {
          useMutation: (options: UseMutationOptions) =>
            useMutation({ ...options, mutationFn: mocks.remove }),
        },
      },
    },
  };
});

function CacheProbe() {
  const cache = useScoreCache();
  return (
    <output aria-label="Cached scores">{JSON.stringify(cache.getAll())}</output>
  );
}

const content = (
  <DualAnnotationContent
    projectId="project"
    isV4
    traceId="trace"
    observationId="observation"
    traceEnvironment="trace-env"
    observationEnvironment="observation-env"
    traceScores={[]}
    observationScores={[]}
  />
);

function serverQualityScore() {
  return {
    longStringValue: "",
    executionTraceId: null,
    datasetRunId: null,
    id: "saved-quality",
    configId: "quality",
    name: "Quality",
    source: "ANNOTATION",
    dataType: "BOOLEAN",
    value: 0,
    stringValue: "False",
    comment: "Saved comment",
    traceId: "trace",
    observationId: "observation",
    projectId: "project",
    timestamp: new Date(),
    createdAt: new Date(),
    updatedAt: new Date(),
    metadata: {},
    environment: "default",
    queueId: null,
    sessionId: null,
    authorUserId: null,
  } satisfies ScoreDomain;
}

function renderContent(children = content) {
  const queryClient = new QueryClient({
    defaultOptions: { mutations: { retry: false } },
  });
  const wrap = (children: React.ReactNode) => (
    <QueryClientProvider client={queryClient}>
      <LayerProvider>
        <ScoreCacheProvider>
          {children}
          <CacheProbe />
        </ScoreCacheProvider>
      </LayerProvider>
    </QueryClientProvider>
  );
  const rendered = render(wrap(children));
  return {
    ...rendered,
    rerenderContent: (next: React.ReactNode) => rendered.rerender(wrap(next)),
  };
}

describe("unified annotation targets", () => {
  beforeEach(() => {
    vi.clearAllMocks();
    mocks.hasConfigAccess = false;
    mocks.configsLoading = false;
    mocks.scoreEditsDisabled = false;
    Element.prototype.scrollIntoView = vi.fn();
    localStorage.clear();
    localStorage.setItem(
      "emptySelectedConfigIds:observation",
      JSON.stringify(["quality"]),
    );
    localStorage.setItem(
      "emptySelectedConfigIds:trace",
      JSON.stringify(["quality"]),
    );
    vi.stubGlobal(
      "ResizeObserver",
      class {
        observe() {}
        unobserve() {}
        disconnect() {}
      },
    );
  });

  afterEach(() => {
    configs.splice(1);
    vi.unstubAllGlobals();
  });

  it("adds scores once and removes only the chosen empty row", async () => {
    configs.push({ ...defaultConfig, id: "accuracy", name: "Accuracy" });
    const rendered = renderContent();
    fireEvent.click(screen.getByRole("button", { name: "Add score" }));
    expect(
      screen.queryByRole("menuitem", { name: /Quality/ }),
    ).not.toBeInTheDocument();
    fireEvent.click(await screen.findByRole("menuitem", { name: /Accuracy/ }));
    expect(screen.getAllByRole("group", { name: "Accuracy" })).toHaveLength(1);
    expect(screen.getByRole("button", { name: "Add score" })).toBeEnabled();
    fireEvent.keyDown(
      screen.getByRole("button", { name: "Score actions for Accuracy" }),
      { key: "ArrowDown" },
    );
    fireEvent.click(
      await screen.findByRole("menuitem", { name: "Remove score" }),
    );
    expect(
      screen.queryByRole("group", { name: "Accuracy" }),
    ).not.toBeInTheDocument();
    expect(screen.getByRole("group", { name: "Quality" })).toBeInTheDocument();
    expect(mocks.remove).not.toHaveBeenCalled();
    await waitFor(() =>
      expect(screen.getByRole("button", { name: "Add score" })).toHaveFocus(),
    );
    rendered.unmount();
    renderContent();
    expect(
      screen.queryByRole("group", { name: "Accuracy" }),
    ).not.toBeInTheDocument();
  });

  it("focuses the first score on activation without taking focus on rerenders", async () => {
    configs.push({ ...defaultConfig, id: "accuracy", name: "Accuracy" });
    mocks.create.mockResolvedValue({});
    const refreshRef = createRef<AnnotationRefreshHandle>();
    const view = (isActive: boolean) => (
      <>
        <button>Outside annotation</button>
        {cloneElement(content, { isActive, refreshRef })}
      </>
    );
    const rendered = renderContent(view(false));
    const outside = screen.getByRole("button", { name: "Outside annotation" });
    outside.focus();
    rendered.rerenderContent(view(true));
    const row = screen.getByRole("group", { name: "Quality" });
    await waitFor(() => expect(row).toHaveFocus());
    fireEvent.keyDown(row, { key: "2" });
    await waitFor(() => expect(mocks.create).toHaveBeenCalledOnce());
    expect(row).toHaveFocus();

    outside.focus();
    rendered.rerenderContent(view(true));
    await new Promise((resolve) => requestAnimationFrame(resolve));
    expect(outside).toHaveFocus();
    act(() => refreshRef.current?.focus());
    await waitFor(() => expect(row).toHaveFocus());
    outside.focus();
    rendered.rerenderContent(view(false));
    rendered.rerenderContent(view(true));
    await waitFor(() => expect(row).toHaveFocus());
  });

  it("focuses a loaded empty form unless its drawer is closing", async () => {
    localStorage.clear();
    mocks.configsLoading = true;
    const view = (state: "open" | "closed") => (
      <>
        <button>Outside annotation</button>
        <div data-state={state}>{content}</div>
      </>
    );
    const rendered = renderContent(view("open"));
    expect(screen.queryByRole("button", { name: "Add score" })).toBeNull();
    mocks.configsLoading = false;
    rendered.rerenderContent(view("open"));
    await waitFor(() =>
      expect(screen.getByRole("button", { name: "Add score" })).toHaveFocus(),
    );

    mocks.configsLoading = true;
    rendered.rerenderContent(view("closed"));
    const outside = screen.getByRole("button", { name: "Outside annotation" });
    outside.focus();
    mocks.configsLoading = false;
    rendered.rerenderContent(view("closed"));
    await new Promise((resolve) => requestAnimationFrame(resolve));
    expect(outside).toHaveFocus();
  });

  it("shows the annotation guidance inline when no scores are selected", () => {
    localStorage.clear();
    renderContent();

    expect(
      screen.getByText(
        "Annotate the trace and observation with scores to capture human evaluation across different dimensions.",
      ),
    ).toBeVisible();
  });

  it("suspends score shortcuts while a shared action menu is open", async () => {
    mocks.create.mockResolvedValue({});
    const view = (menuOpen: boolean) => (
      <>
        {content}
        {menuOpen && <div role="menu" aria-label="More actions" />}
      </>
    );
    const rendered = renderContent(view(false));
    const row = screen.getByRole("group", { name: "Quality" });
    await waitFor(() => expect(row).toHaveFocus());
    rendered.rerenderContent(view(true));
    await act(async () => fireEvent.keyDown(row, { key: "2" }));
    expect(mocks.create).not.toHaveBeenCalled();
    rendered.rerenderContent(view(false));
    row.focus();
    fireEvent.keyDown(row, { key: "2" });
    await waitFor(() => expect(mocks.create).toHaveBeenCalledOnce());
  });

  it("preserves inactive drafts without handling keyboard navigation until reopened", () => {
    configs.push({
      ...defaultConfig,
      id: "feedback",
      name: "Feedback",
      dataType: "TEXT",
      categories: null,
    });
    localStorage.setItem(
      "emptySelectedConfigIds:observation",
      JSON.stringify(["quality", "feedback"]),
    );
    const rendered = renderContent();
    fireEvent.change(screen.getByRole("textbox"), {
      target: { value: "Keep this draft" },
    });
    rendered.rerenderContent(cloneElement(content, { isActive: false }));
    fireEvent.keyDown(document.body, { key: "ArrowDown" });
    expect(document.activeElement).toBe(document.body);
    expect(mocks.create).not.toHaveBeenCalled();
    rendered.rerenderContent(content);
    expect(screen.getByRole("textbox")).toHaveValue("Keep this draft");
    fireEvent.keyDown(document.body, { key: "ArrowDown" });
    expect(screen.getByRole("group", { name: "Feedback" })).toHaveFocus();
  });

  it.each(["picker", "row menu", "category"])(
    "hides an open %s portal while annotation is inactive",
    async (control) => {
      if (control === "picker")
        configs.push({ ...defaultConfig, id: "accuracy", name: "Accuracy" });
      if (control === "category") {
        configs.push({
          ...defaultConfig,
          id: "accuracy",
          name: "Accuracy",
          dataType: "CATEGORICAL",
          categories: [
            { label: "Fully correct", value: 1 },
            { label: "Partly correct", value: 0 },
          ],
        });
        localStorage.setItem(
          "emptySelectedConfigIds:observation",
          JSON.stringify(["accuracy"]),
        );
      }
      const rendered = renderContent();
      if (control === "row menu") {
        fireEvent.keyDown(
          screen.getByRole("button", { name: "Score actions for Quality" }),
          { key: "ArrowDown" },
        );
        expect(await screen.findByRole("menu")).toBeVisible();
      } else {
        const trigger =
          control === "picker"
            ? screen.getByRole("button", { name: "Add score" })
            : within(screen.getByRole("group", { name: "Accuracy" })).getByRole(
                "combobox",
              );
        fireEvent.click(trigger);
        expect(
          await screen.findByRole(control === "picker" ? "menu" : "listbox"),
        ).toBeVisible();
      }
      rendered.rerenderContent(cloneElement(content, { isActive: false }));
      await waitFor(() => {
        expect(screen.queryByRole("listbox")).not.toBeInTheDocument();
        expect(screen.queryByRole("menu")).not.toBeInTheDocument();
      });
      expect(mocks.create).not.toHaveBeenCalled();
    },
  );

  it("locks saved scores when the project disables score edits", async () => {
    mocks.scoreEditsDisabled = true;
    renderContent(
      cloneElement(content, {
        observationScores: [{ ...serverQualityScore(), metadata: "{}" }],
      }),
    );
    const quality = screen.getByRole("group", { name: "Quality" });
    expect(
      within(quality).getByText(
        "Saved scores cannot be edited in this project.",
      ),
    ).toBeInTheDocument();
    fireEvent.click(within(quality).getByText("True"));
    act(() => quality.focus());
    await act(async () => fireEvent.keyDown(quality, { key: "2" }));
    expect(mocks.update).not.toHaveBeenCalled();
    expect(mocks.create).not.toHaveBeenCalled();
  });

  it("refreshes clean scores on reopening while retaining text and score-comment drafts", async () => {
    configs.push({
      ...defaultConfig,
      id: "feedback",
      name: "Feedback",
      dataType: "TEXT",
      categories: undefined,
    });
    localStorage.setItem(
      "emptySelectedConfigIds:observation",
      JSON.stringify(["quality", "feedback"]),
    );
    const score = serverQualityScore();
    const refreshRef = createRef<AnnotationRefreshHandle>();
    renderContent(
      cloneElement(content, {
        observationScores: [{ ...score, metadata: "{}" }],
        refreshRef,
      }),
    );
    const quality = screen.getByRole("group", { name: "Quality" });
    const feedback = within(
      screen.getByRole("group", { name: "Feedback" }),
    ).getByRole("textbox");
    fireEvent.change(feedback, { target: { value: "Unsent feedback" } });
    fireEvent.click(within(quality).getByTitle("Add or view score comment"));
    const comment = await within(screen.getByRole("dialog")).findByRole(
      "textbox",
    );
    fireEvent.change(comment, { target: { value: "Unsent score comment" } });
    act(() =>
      refreshRef.current?.refresh({
        scoreTarget: {
          type: "trace",
          traceId: "trace",
          observationId: "observation",
        },
        scoreMetadata: { projectId: "project" },
        analyticsData: { type: "trace", source: "TraceDetail", isV4: true },
        scores: [
          {
            ...score,
            metadata: "{}",
            value: 1,
            stringValue: "True",
            comment: "Updated remotely",
          },
        ],
        companionTrace: {
          environment: "default",
          scores: [
            {
              ...score,
              metadata: "{}",
              id: "trace-quality",
              observationId: null,
              value: 1,
              stringValue: "True",
            },
          ],
        },
      }),
    );
    expect(
      within(screen.getByRole("group", { name: "Quality (Trace)" })).getByRole(
        "tab",
        { name: /True/ },
      ),
    ).toHaveAttribute("aria-selected", "true");
    expect(within(quality).getByRole("tab", { name: /True/ })).toHaveAttribute(
      "aria-selected",
      "true",
    );
    expect(feedback).toHaveValue("Unsent feedback");
    expect(comment).toHaveValue("Unsent score comment");
    expect(mocks.create).not.toHaveBeenCalled();
    expect(mocks.update).not.toHaveBeenCalled();
  });

  it("retains pending and just-saved values across lagging refreshes, then accepts acknowledged external edits", async () => {
    const score = serverQualityScore();
    const pending = deferred();
    mocks.update.mockReturnValueOnce(pending.promise);
    const refreshRef = createRef<AnnotationRefreshHandle>();
    renderContent(
      cloneElement(content, {
        observationScores: [{ ...score, metadata: "{}" }],
        refreshRef,
      }),
    );
    const row = screen.getByRole("group", { name: "Quality" });
    const refresh = (value: number, scoresPresent = true) =>
      act(() =>
        refreshRef.current?.refresh({
          scoreTarget: {
            type: "trace",
            traceId: "trace",
            observationId: "observation",
          },
          scoreMetadata: { projectId: "project" },
          analyticsData: { type: "trace", source: "TraceDetail", isV4: true },
          scores: scoresPresent
            ? [
                {
                  ...score,
                  metadata: "{}",
                  value,
                  stringValue: value ? "True" : "False",
                },
              ]
            : [],
          companionTrace: { environment: "default", scores: [] },
        }),
      );
    fireEvent.mouseDown(within(row).getByRole("tab", { name: /True/ }));
    await waitFor(() => expect(mocks.update).toHaveBeenCalledOnce());
    refresh(0);
    expect(within(row).getByRole("tab", { name: /True/ })).toHaveAttribute(
      "aria-selected",
      "true",
    );
    await act(async () => pending.resolve({}));
    refresh(0);
    expect(within(row).getByRole("tab", { name: /True/ })).toHaveAttribute(
      "aria-selected",
      "true",
    );
    refresh(1);
    refresh(0);
    expect(within(row).getByRole("tab", { name: /False/ })).toHaveAttribute(
      "aria-selected",
      "true",
    );
    refresh(0, false);
    expect(within(row).getByRole("tab", { name: /False/ })).toHaveAttribute(
      "aria-selected",
      "false",
    );
    expect(mocks.update).toHaveBeenCalledOnce();

    refresh(0);
    const clearing = deferred();
    mocks.remove.mockReturnValueOnce(clearing.promise);
    fireEvent.keyDown(
      screen.getByRole("button", { name: "Score actions for Quality" }),
      { key: "ArrowDown" },
    );
    fireEvent.click(
      await screen.findByRole("menuitem", { name: "Clear score" }),
    );
    await waitFor(() => expect(mocks.remove).toHaveBeenCalledOnce());
    await act(async () => clearing.resolve({}));
    fireEvent.keyDown(
      screen.getByRole("button", { name: "Score actions for Quality" }),
      { key: "ArrowDown" },
    );
    fireEvent.click(
      await screen.findByRole("menuitem", { name: "Remove score" }),
    );
    refresh(0);
    expect(
      screen.queryByRole("group", { name: "Quality" }),
    ).not.toBeInTheDocument();

    refresh(1);
    expect(screen.getByRole("tab", { name: /True/ })).toHaveAttribute(
      "aria-selected",
      "true",
    );
  });

  it("moves between categories with arrow keys and saves only on Enter", async () => {
    mocks.create.mockResolvedValue({});
    renderContent();
    const trueTab = screen.getByRole("tab", { name: /True/ });
    const falseTab = screen.getByRole("tab", { name: /False/ });
    act(() => trueTab.focus());
    fireEvent.keyDown(trueTab, { key: "ArrowRight" });
    await waitFor(() => expect(falseTab).toHaveFocus());
    expect(mocks.create).not.toHaveBeenCalled();
    fireEvent.keyDown(falseTab, { key: "Enter" });
    await waitFor(() => expect(mocks.create).toHaveBeenCalledOnce());
  });

  it("hides the score comment portal without losing its unsaved draft", async () => {
    mocks.create.mockResolvedValue({});
    const rendered = renderContent();
    fireEvent.mouseDown(screen.getByRole("tab", { name: /True/ }));
    await waitFor(() =>
      expect(
        screen.getByRole("status", { name: "Score save status" }),
      ).toHaveTextContent("Saved"),
    );
    fireEvent.click(screen.getByTitle("Add or view score comment"));
    expect(screen.getByRole("dialog")).toHaveClass("ph-no-capture");
    fireEvent.change(screen.getByRole("textbox"), {
      target: { value: "Unsent score comment" },
    });
    rendered.rerenderContent(cloneElement(content, { isActive: false }));
    await waitFor(() =>
      expect(screen.queryByRole("textbox")).not.toBeInTheDocument(),
    );
    rendered.rerenderContent(content);
    expect(await screen.findByRole("textbox")).toHaveValue(
      "Unsent score comment",
    );
    expect(mocks.update).not.toHaveBeenCalled();
  });

  it("hides the saved status after its confirmation window", async () => {
    vi.useFakeTimers({ shouldAdvanceTime: true });
    try {
      mocks.create.mockResolvedValue({});
      renderContent();
      fireEvent.mouseDown(screen.getByRole("tab", { name: /True/ }));
      await waitFor(() =>
        expect(
          screen.getByRole("status", { name: "Score save status" }),
        ).toHaveTextContent("Saved"),
      );

      act(() => vi.advanceTimersByTime(3_000));

      expect(
        screen.queryByRole("status", { name: "Score save status" }),
      ).not.toBeInTheDocument();
    } finally {
      vi.useRealTimers();
    }
  });

  it("retains an unfinished new category while its annotation panel is inactive", async () => {
    mocks.hasConfigAccess = true;
    configs.push({
      ...defaultConfig,
      id: "accuracy",
      name: "Accuracy",
      dataType: "CATEGORICAL",
      categories: [{ label: "Good", value: 1 }],
    });
    localStorage.setItem(
      "emptySelectedConfigIds:observation",
      JSON.stringify(["accuracy"]),
    );
    const rendered = renderContent();
    fireEvent.click(screen.getByRole("button", { name: "Add new category" }));
    fireEvent.change(screen.getByRole("textbox", { name: "Category name" }), {
      target: { value: "Needs follow-up" },
    });
    rendered.rerenderContent(cloneElement(content, { isActive: false }));
    await waitFor(() =>
      expect(
        screen.queryByRole("dialog", { name: "Add category" }),
      ).not.toBeInTheDocument(),
    );
    rendered.rerenderContent(content);
    expect(
      await screen.findByRole("textbox", { name: "Category name" }),
    ).toHaveValue("Needs follow-up");
    expect(mocks.create).not.toHaveBeenCalled();
  });

  it("chooses a target before the first save and cannot change it during or after saving", async () => {
    const pending = deferred();
    mocks.create.mockReturnValue(pending.promise);
    renderContent();
    expect(screen.getAllByRole("group", { name: "Quality" })).toHaveLength(1);
    expect(screen.getByRole("button", { name: "Add score" })).toBeEnabled();
    fireEvent.keyDown(
      screen.getByRole("button", { name: "Score actions for Quality" }),
      { key: "ArrowDown" },
    );
    fireEvent.click(
      await screen.findByRole("menuitem", { name: "Score trace instead" }),
    );
    await waitFor(() =>
      expect(screen.queryByRole("menu")).not.toBeInTheDocument(),
    );
    expect(mocks.create).not.toHaveBeenCalled();
    expect(mocks.update).not.toHaveBeenCalled();
    expect(mocks.remove).not.toHaveBeenCalled();
    expect(mocks.capture).toHaveBeenCalledWith("score:level_changed", {
      type: "trace",
      source: "TraceDetail",
      isV4: true,
      previousTargetType: "observation",
      targetType: "trace",
      dataType: "BOOLEAN",
    });
    fireEvent.mouseDown(screen.getByRole("tab", { name: /True/ }));
    await waitFor(() =>
      expect(mocks.create).toHaveBeenCalledExactlyOnceWith(
        expect.objectContaining({
          scoreTarget: { type: "trace", traceId: "trace" },
          value: 1,
        }),
      ),
    );
    fireEvent.keyDown(
      screen.getByRole("button", { name: "Score actions for Quality" }),
      { key: "ArrowDown" },
    );
    expect(
      await screen.findByText(
        "This score is saved on the trace and cannot be moved.",
      ),
    ).toBeVisible();
    expect(
      screen.queryByRole("menuitem", { name: "Score observation instead" }),
    ).not.toBeInTheDocument();
    await act(async () => pending.resolve({}));
    expect(
      screen.queryByRole("menuitem", { name: "Score observation instead" }),
    ).not.toBeInTheDocument();
    fireEvent.click(
      screen.getByRole("menuitem", { name: "Also score observation" }),
    );
    await waitFor(() =>
      expect(screen.queryByRole("menu")).not.toBeInTheDocument(),
    );
    const observationRow = screen.getByRole("group", {
      name: "Quality (Observation)",
    });
    const traceRow = screen.getByRole("group", { name: "Quality (Trace)" });
    expect(
      within(observationRow).getByRole("tab", { name: /True/ }),
    ).toHaveAttribute("aria-selected", "false");
    expect(within(traceRow).getByRole("tab", { name: /True/ })).toHaveAttribute(
      "aria-selected",
      "true",
    );
    fireEvent.keyDown(
      within(traceRow).getByRole("button", { name: /Score actions/ }),
      { key: "ArrowDown" },
    );
    expect(
      await screen.findByRole("menuitem", {
        name: "Also score observation (already selected)",
      }),
    ).toHaveAttribute("aria-disabled", "true");
    fireEvent.keyDown(screen.getByRole("menu"), { key: "Escape" });
    await waitFor(() => expect(traceRow).toHaveFocus());
    expect(mocks.create).toHaveBeenCalledTimes(1);
    expect(mocks.update).not.toHaveBeenCalled();
    expect(mocks.remove).not.toHaveBeenCalled();
  });

  it("keeps a text draft while changing level without saving it on menu close", async () => {
    configs.push({
      ...defaultConfig,
      id: "feedback",
      name: "Feedback",
      dataType: "TEXT",
      categories: null,
    });
    localStorage.setItem(
      "emptySelectedConfigIds:observation",
      JSON.stringify(["feedback"]),
    );
    localStorage.setItem("emptySelectedConfigIds:trace", JSON.stringify([]));
    mocks.create.mockResolvedValue({});
    renderContent();
    const input = screen.getByRole("textbox");
    act(() => input.focus());
    fireEvent.change(input, { target: { value: "My unsaved review" } });
    const menu = screen.getByRole("button", {
      name: "Score actions for Feedback",
    });
    act(() => menu.focus());
    fireEvent.keyDown(menu, { key: "ArrowDown" });
    fireEvent.click(
      await screen.findByRole("menuitem", { name: "Score trace instead" }),
    );
    await waitFor(() =>
      expect(screen.queryByRole("menu")).not.toBeInTheDocument(),
    );
    expect(screen.getByRole("textbox")).toHaveValue("My unsaved review");
    expect(mocks.create).not.toHaveBeenCalled();
    fireEvent.blur(screen.getByRole("textbox"));
    await waitFor(() =>
      expect(mocks.create).toHaveBeenCalledExactlyOnceWith(
        expect.objectContaining({
          scoreTarget: { type: "trace", traceId: "trace" },
          stringValue: "My unsaved review",
        }),
      ),
    );
  });

  it.each([
    ["fixed", "trace"],
    ["fixed", "session"],
    ["selectable", "trace"],
    ["selectable", "session"],
  ] as const)(
    "keeps %s %s fields in their configured order across refresh without writing scores",
    (mode, targetType) => {
      const accuracy = {
        ...defaultConfig,
        id: "accuracy",
        name: "Accuracy",
      };
      configs.push(accuracy);
      localStorage.setItem(
        `emptySelectedConfigIds:${targetType}`,
        JSON.stringify(["quality", "accuracy"]),
      );
      const score = {
        ...serverQualityScore(),
        id: "saved-accuracy",
        configId: "accuracy",
        name: "Accuracy",
        observationId: null,
        traceId: targetType === "trace" ? "trace" : null,
        sessionId: targetType === "session" ? "session" : null,
        metadata: "{}",
      };
      const refreshRef = createRef<AnnotationRefreshHandle>();
      const scoreTarget =
        targetType === "trace"
          ? { type: "trace" as const, traceId: "trace" }
          : { type: "session" as const, sessionId: "session" };
      const sourceByTargetType = {
        trace: "TraceDetail",
        session: "SessionDetail",
      } as const;
      const analyticsData = {
        type: targetType,
        source:
          mode === "fixed"
            ? ("AnnotationQueue" as const)
            : sourceByTargetType[targetType],
        isV4: true,
      };
      const contentFor = (orderedConfigs: ScoreConfigDomain[]) => (
        <AnnotationForm
          refreshRef={refreshRef}
          scoreTarget={scoreTarget}
          serverScores={[score]}
          scoreMetadata={{ projectId: "project" }}
          analyticsData={analyticsData}
          configSelection={
            mode === "fixed" ? { mode, configs: orderedConfigs } : { mode }
          }
        />
      );
      const rendered = renderContent(contentFor([defaultConfig, accuracy]));
      const fieldOrder = () =>
        screen
          .getAllByRole("group")
          .map((row) => row.getAttribute("aria-label"));
      const expectedOrder =
        mode === "fixed" ? ["Quality", "Accuracy"] : ["Accuracy", "Quality"];
      expect(fieldOrder()).toEqual(expectedOrder);
      act(() =>
        refreshRef.current?.refresh({
          scoreTarget,
          scoreMetadata: { projectId: "project" },
          analyticsData,
          scores: [{ ...score, value: 1, stringValue: "True" }],
        }),
      );
      expect(fieldOrder()).toEqual(expectedOrder);
      expect(
        within(screen.getByRole("group", { name: "Accuracy" })).getByRole(
          "tab",
          { name: /True/ },
        ),
      ).toHaveAttribute("aria-selected", "true");
      if (mode === "fixed") {
        expect(
          screen.queryByRole("button", { name: "Add score" }),
        ).not.toBeInTheDocument();
        rendered.rerenderContent(contentFor([accuracy, defaultConfig]));
        expect(fieldOrder()).toEqual(expectedOrder);
        rendered.unmount();
        renderContent(contentFor([accuracy, defaultConfig]));
        expect(fieldOrder()).toEqual(["Accuracy", "Quality"]);
        expect(
          within(screen.getByRole("group", { name: "Accuracy" })).getByRole(
            "tab",
            { name: /False/ },
          ),
        ).toHaveAttribute("aria-selected", "true");
      }
      expect(mocks.create).not.toHaveBeenCalled();
      expect(mocks.update).not.toHaveBeenCalled();
      expect(mocks.remove).not.toHaveBeenCalled();
    },
  );

  it("keeps draft edits local, preserves them through refetch, and resets only for another target", () => {
    const text = {
      ...defaultConfig,
      id: "feedback",
      name: "Feedback",
      dataType: "TEXT" as const,
      categories: null,
    };
    const score = (sessionId: string, stringValue: string): ScoreDomain => ({
      id: `score-${sessionId}`,
      projectId: "project",
      environment: "default",
      name: "Feedback",
      value: 0,
      dataType: "TEXT",
      stringValue,
      longStringValue: "",
      source: "ANNOTATION",
      authorUserId: null,
      comment: null,
      metadata: {},
      configId: "feedback",
      queueId: null,
      executionTraceId: null,
      createdAt: new Date(),
      updatedAt: new Date(),
      timestamp: new Date(),
      traceId: null,
      sessionId,
      datasetRunId: null,
      observationId: null,
    });
    const contentFor = (sessionId: string, value: string) => (
      <AnnotationForm
        scoreTarget={{ type: "session", sessionId }}
        serverScores={[{ ...score(sessionId, value), metadata: "{}" }]}
        scoreMetadata={{ projectId: "project" }}
        analyticsData={{ type: "session", source: "SessionDetail", isV4: true }}
        configSelection={{ mode: "fixed", configs: [text] }}
      />
    );
    const view = renderContent(contentFor("session", "Original"));
    const input = screen.getByRole("textbox");
    mocks.headerRender.mockClear();
    fireEvent.change(input, { target: { value: "My unsaved draft" } });
    expect(mocks.headerRender).not.toHaveBeenCalled();
    expect(mocks.update).not.toHaveBeenCalled();
    view.rerenderContent(contentFor("session", "Background refetch"));
    expect(screen.getByRole("textbox")).toBe(input);
    expect(input).toHaveValue("My unsaved draft");
    view.rerenderContent(contentFor("next-session", "Other session score"));
    expect(screen.getByRole("textbox")).toHaveValue("Other session score");
    expect(mocks.update).not.toHaveBeenCalled();
  });

  it("remembers queue description visibility per score config across reopened items", async () => {
    const configs = [
      {
        ...defaultConfig,
        id: "description-a",
        name: "Quality",
        description: "Judge answer quality.\nConsider relevance and clarity.",
      },
      {
        ...defaultConfig,
        id: "description-b",
        name: "Accuracy",
        description: "Check factual accuracy.",
      },
    ];
    const contentFor = (sessionId: string) => (
      <AnnotationForm
        scoreTarget={{ type: "session", sessionId }}
        serverScores={[]}
        scoreMetadata={{ projectId: "project", queueId: "queue" }}
        analyticsData={{
          type: "session",
          source: "AnnotationQueue",
          isV4: true,
        }}
        configSelection={{ mode: "fixed", configs }}
      />
    );
    const view = renderContent(contentFor("first-item"));
    expect(
      screen.getByText(
        /Judge answer quality\.\s+Consider relevance and clarity\./,
      ),
    ).toBeVisible();
    fireEvent.click(
      screen.getByRole("button", { name: "Hide description for Quality" }),
    );
    expect(
      screen.getByRole("button", { name: "Show description for Quality" }),
    ).toHaveAttribute("aria-expanded", "false");
    expect(screen.getByText("Check factual accuracy.")).toBeVisible();
    await waitFor(() =>
      expect(
        localStorage.getItem(
          "annotation-score-config-description-description-a",
        ),
      ).toBe("false"),
    );
    view.rerenderContent(contentFor("next-item"));
    expect(
      screen.getByRole("button", { name: "Show description for Quality" }),
    ).toHaveAttribute("aria-expanded", "false");
    view.unmount();
    renderContent(contentFor("reopened-item"));
    expect(
      screen.getByRole("button", { name: "Show description for Quality" }),
    ).toHaveAttribute("aria-expanded", "false");
    expect(screen.getByText("Check factual accuracy.")).toBeVisible();
    fireEvent.click(
      screen.getByRole("button", { name: "Show description for Quality" }),
    );
    expect(
      screen.getByText(
        /Judge answer quality\.\s+Consider relevance and clarity\./,
      ),
    ).toBeVisible();
    expect(mocks.create).not.toHaveBeenCalled();
    expect(mocks.update).not.toHaveBeenCalled();
  });

  it("uses refreshed category definitions without changing an open queue's fields or order", async () => {
    mocks.create.mockResolvedValue({});
    const category: ScoreConfigDomain = {
      ...defaultConfig,
      dataType: "CATEGORICAL",
      categories: [{ label: "Old", value: 1 }],
    };
    const feedback: ScoreConfigDomain = {
      ...defaultConfig,
      id: "feedback",
      name: "Feedback",
      dataType: "TEXT",
      categories: null,
    };
    const contentFor = (orderedConfigs: ScoreConfigDomain[]) => (
      <AnnotationForm
        scoreTarget={{ type: "session", sessionId: "session" }}
        serverScores={[]}
        scoreMetadata={{ projectId: "project", queueId: "queue" }}
        analyticsData={{
          type: "session",
          source: "AnnotationQueue",
          isV4: true,
        }}
        configSelection={{ mode: "fixed", configs: orderedConfigs }}
      />
    );
    const view = renderContent(contentFor([feedback, category]));
    const text = within(
      screen.getByRole("group", { name: "Feedback" }),
    ).getByRole("textbox");
    fireEvent.change(text, { target: { value: "Keep my draft" } });
    view.rerenderContent(
      contentFor([
        {
          ...category,
          description: "Updated guidance",
          categories: [...category.categories!, { label: "New", value: 7 }],
        },
        { ...defaultConfig, id: "extra", name: "Extra" },
        feedback,
      ]),
    );
    expect(screen.getByText("Updated guidance")).toBeVisible();
    expect(text).toHaveValue("Keep my draft");
    expect(
      screen.getAllByRole("group").map((row) => row.getAttribute("aria-label")),
    ).toEqual(["Feedback", "Quality"]);
    const newCategory = within(
      screen.getByRole("group", { name: "Quality" }),
    ).getByRole("tab", { name: /New/ });
    expect(newCategory).toBeEnabled();
    fireEvent.mouseDown(newCategory);
    await waitFor(() =>
      expect(mocks.create).toHaveBeenCalledWith(
        expect.objectContaining({
          configId: "quality",
          value: 7,
          stringValue: "New",
        }),
      ),
    );
  });

  it("preserves fixed queue text and comment drafts through config refresh and applies fields on reopen", async () => {
    const feedback = {
      ...defaultConfig,
      id: "feedback",
      name: "Feedback",
      dataType: "TEXT" as const,
      categories: null,
    };
    const accuracy = { ...defaultConfig, id: "accuracy", name: "Accuracy" };
    const score = {
      ...serverQualityScore(),
      metadata: "{}",
      traceId: null,
      observationId: null,
      sessionId: "session",
    };
    const contentFor = (orderedConfigs: ScoreConfigDomain[]) => (
      <AnnotationForm
        scoreTarget={{ type: "session", sessionId: "session" }}
        serverScores={[score]}
        scoreMetadata={{ projectId: "project", queueId: "queue" }}
        analyticsData={{
          type: "session",
          source: "AnnotationQueue",
          isV4: true,
        }}
        configSelection={{ mode: "fixed", configs: orderedConfigs }}
      />
    );
    const view = renderContent(contentFor([feedback, defaultConfig]));
    const text = within(
      screen.getByRole("group", { name: "Feedback" }),
    ).getByRole("textbox");
    fireEvent.change(text, { target: { value: "Unsent feedback" } });
    fireEvent.click(
      within(screen.getByRole("group", { name: "Quality" })).getByTitle(
        "Add or view score comment",
      ),
    );
    const comment = await within(screen.getByRole("dialog")).findByRole(
      "textbox",
    );
    fireEvent.change(comment, { target: { value: "Unsent score comment" } });
    view.rerenderContent(contentFor([defaultConfig, accuracy]));
    expect(text).toBeInTheDocument();
    expect(text).toHaveValue("Unsent feedback");
    expect(comment).toHaveValue("Unsent score comment");
    expect(
      screen.queryByRole("group", { name: "Accuracy" }),
    ).not.toBeInTheDocument();
    expect(
      screen.getAllByRole("group").map((row) => row.getAttribute("aria-label")),
    ).toEqual(["Feedback", "Quality"]);
    expect(mocks.create).not.toHaveBeenCalled();
    expect(mocks.update).not.toHaveBeenCalled();
    expect(mocks.remove).not.toHaveBeenCalled();
    view.unmount();
    renderContent(contentFor([defaultConfig, accuracy]));
    expect(
      screen.queryByRole("group", { name: "Feedback" }),
    ).not.toBeInTheDocument();
    expect(
      screen.getAllByRole("group").map((row) => row.getAttribute("aria-label")),
    ).toEqual(["Quality", "Accuracy"]);
  });

  it("navigates one form and saves the same config independently for observation and trace", async () => {
    mocks.create.mockResolvedValue({});
    await renderBothTargets();

    expect(screen.getAllByRole("button", { name: "Add score" })).toHaveLength(
      1,
    );
    expect(
      screen.queryByRole("status", { name: "Score save status" }),
    ).not.toBeInTheDocument();
    const observationRow = screen.getByRole("group", {
      name: "Quality (Observation)",
    });
    const traceRow = screen.getByRole("group", { name: "Quality (Trace)" });
    act(() => observationRow.focus());
    fireEvent.keyDown(observationRow, { key: "1" });
    fireEvent.keyDown(observationRow, { key: "ArrowDown" });
    expect(traceRow).toHaveFocus();
    fireEvent.keyDown(traceRow, { key: "2" });

    await waitFor(() => expect(mocks.create).toHaveBeenCalledTimes(2));
    const writes = mocks.create.mock.calls.map(([variables]) => variables);
    expect(writes).toEqual([
      expect.objectContaining({
        configId: "quality",
        value: 0,
        environment: "observation-env",
        scoreTarget: {
          type: "trace",
          traceId: "trace",
          observationId: "observation",
        },
      }),
      expect.objectContaining({
        configId: "quality",
        value: 1,
        environment: "trace-env",
        scoreTarget: { type: "trace", traceId: "trace" },
      }),
    ]);
    expect(writes[0].id).not.toBe(writes[1].id);
    await waitFor(() =>
      expect(
        screen.getByRole("status", { name: "Score save status" }),
      ).toHaveTextContent("Saved"),
    );
    expect(screen.getByRole("button", { name: "Add score" })).toBeEnabled();
    const cached = JSON.parse(
      screen.getByLabelText("Cached scores").textContent!,
    );
    expect(cached).toEqual(
      expect.arrayContaining([
        expect.objectContaining({
          observationId: "observation",
          configId: "quality",
          value: 0,
          environment: "observation-env",
        }),
        expect.objectContaining({
          observationId: null,
          configId: "quality",
          value: 1,
          environment: "trace-env",
        }),
      ]),
    );
    expect(
      within(observationRow).getByRole("tab", { name: /False/ }),
    ).toHaveAttribute("aria-selected", "true");
    expect(within(traceRow).getByRole("tab", { name: /True/ })).toHaveAttribute(
      "aria-selected",
      "true",
    );
  });

  it("restores a categorical score after a failed clear and keeps its field after retry", async () => {
    mocks.create.mockResolvedValue({});
    const firstClear = deferred();
    mocks.remove.mockReturnValueOnce(firstClear.promise).mockResolvedValue({});
    await renderBothTargets();
    const observationRow = screen.getByRole("group", {
      name: "Quality (Observation)",
    });
    const traceRow = screen.getByRole("group", { name: "Quality (Trace)" });
    act(() => observationRow.focus());
    fireEvent.keyDown(observationRow, { key: "1" });
    act(() => traceRow.focus());
    fireEvent.keyDown(traceRow, { key: "2" });
    await waitFor(() =>
      expect(
        screen.getByRole("status", { name: "Score save status" }),
      ).toHaveTextContent("Saved"),
    );
    fireEvent.keyDown(
      screen.getByRole("button", {
        name: "Score actions for Quality (Observation)",
      }),
      { key: "ArrowDown" },
    );
    expect(
      screen.queryByRole("menuitem", { name: "Remove score" }),
    ).not.toBeInTheDocument();
    fireEvent.click(
      await screen.findByRole("menuitem", { name: "Clear score" }),
    );
    fireEvent.keyDown(
      screen.getByRole("button", {
        name: "Score actions for Quality (Observation)",
      }),
      { key: "ArrowDown" },
    );
    const pendingRemoval = await screen.findByRole("menuitem", {
      name: "Remove score",
    });
    expect(pendingRemoval).toHaveAttribute("aria-disabled", "true");
    fireEvent.click(pendingRemoval);
    fireEvent.keyDown(pendingRemoval, { key: "Escape" });
    expect(
      screen.getByRole("group", { name: "Quality (Observation)" }),
    ).toBeInTheDocument();
    await act(async () =>
      firstClear.reject(new Error("Could not clear score")),
    );
    expect(await screen.findByText("Failed to clear score")).toBeVisible();
    const restored = screen.getByRole("group", {
      name: "Quality (Observation)",
    });
    expect(
      within(restored).getByRole("tab", { name: /False/ }),
    ).toHaveAttribute("aria-selected", "true");
    fireEvent.keyDown(
      screen.getByRole("button", {
        name: "Score actions for Quality (Observation)",
      }),
      { key: "ArrowDown" },
    );
    fireEvent.click(
      await screen.findByRole("menuitem", { name: "Clear score" }),
    );
    await waitFor(() => expect(mocks.remove).toHaveBeenCalledTimes(2));
    expect(mocks.remove).toHaveBeenLastCalledWith(
      expect.objectContaining({
        id: mocks.create.mock.calls[0]![0].id,
        projectId: "project",
      }),
    );
    expect(screen.queryByText("Failed to clear score")).not.toBeInTheDocument();
    const cleared = screen.getByRole("group", {
      name: "Quality (Observation)",
    });
    expect(within(cleared).getByRole("tab", { name: /False/ })).toHaveAttribute(
      "aria-selected",
      "false",
    );
    expect(within(traceRow).getByRole("tab", { name: /True/ })).toHaveAttribute(
      "aria-selected",
      "true",
    );
    fireEvent.keyDown(
      screen.getByRole("button", {
        name: "Score actions for Quality (Observation)",
      }),
      { key: "ArrowDown" },
    );
    fireEvent.click(
      await screen.findByRole("menuitem", { name: "Remove score" }),
    );
    expect(screen.getAllByRole("group", { name: "Quality" })).toHaveLength(1);
    expect(mocks.remove).toHaveBeenCalledTimes(2);
  });

  it("keeps the latest saved status when an older edit of the same field fails", async () => {
    const older = deferred();
    const newer = deferred();
    mocks.create.mockResolvedValue({});
    mocks.update
      .mockReturnValueOnce(older.promise)
      .mockReturnValueOnce(newer.promise);
    renderContent();
    const row = screen.getByRole("group", { name: "Quality" });
    fireEvent.mouseDown(within(row).getByRole("tab", { name: /False/ }));
    await waitFor(() =>
      expect(
        screen.getByRole("status", { name: "Score save status" }),
      ).toHaveTextContent("Saved"),
    );
    fireEvent.mouseDown(within(row).getByRole("tab", { name: /True/ }));
    fireEvent.mouseDown(within(row).getByRole("tab", { name: /False/ }));
    await waitFor(() => expect(mocks.update).toHaveBeenCalledTimes(2));
    await act(async () => newer.resolve({}));
    await act(async () => older.reject(new Error("Earlier edit failed")));
    expect(
      screen.getByRole("status", { name: "Score save status" }),
    ).toHaveTextContent("Saved");
    expect(within(row).getByRole("tab", { name: /False/ })).toHaveAttribute(
      "aria-selected",
      "true",
    );
  });

  it.each([false, true])(
    "rolls back a target failure and retries while another save is pending: %s",
    async (retryWhilePending) => {
      const first = deferred();
      const second = deferred();
      mocks.create
        .mockReturnValueOnce(first.promise)
        .mockReturnValueOnce(second.promise)
        .mockResolvedValue({});
      await renderBothTargets();
      expect(
        screen.queryByRole("status", { name: "Score save status" }),
      ).not.toBeInTheDocument();
      const observationRow = screen.getByRole("group", {
        name: "Quality (Observation)",
      });
      const traceRow = screen.getByRole("group", { name: "Quality (Trace)" });
      fireEvent.mouseDown(
        within(observationRow).getByRole("tab", { name: /False/ }),
      );
      fireEvent.mouseDown(within(traceRow).getByRole("tab", { name: /True/ }));
      await waitFor(() => expect(mocks.create).toHaveBeenCalledTimes(2));
      expect(
        screen.getByRole("status", { name: "Score save status" }),
      ).toHaveTextContent("Saving");
      await act(async () => {
        first.reject(new Error("Could not write observation"));
        if (!retryWhilePending) second.resolve({});
      });
      await waitFor(() =>
        expect(
          screen.getByRole("status", { name: "Score save status" }),
        ).toHaveTextContent(retryWhilePending ? "Saving" : "Could not save"),
      );
      expect(
        within(observationRow).getByRole("tab", { name: /False/ }),
      ).toHaveAttribute("aria-selected", "false");
      expect(
        within(traceRow).getByRole("tab", { name: /True/ }),
      ).toHaveAttribute("aria-selected", "true");
      act(() => observationRow.focus());
      fireEvent.keyDown(observationRow, { key: "1" });
      await waitFor(() => expect(mocks.create).toHaveBeenCalledTimes(3));
      expect(mocks.update).not.toHaveBeenCalled();
      if (retryWhilePending) await act(async () => second.resolve({}));
      await waitFor(() =>
        expect(
          screen.getByRole("status", { name: "Score save status" }),
        ).toHaveTextContent("Saved"),
      );
    },
  );

  it("rolls back the same target after an earlier empty row is removed during its save", async () => {
    const pending = deferred();
    mocks.create.mockReturnValueOnce(pending.promise).mockResolvedValue({});
    await renderBothTargets();
    fireEvent.mouseDown(
      within(screen.getByRole("group", { name: "Quality (Trace)" })).getByRole(
        "tab",
        { name: /True/ },
      ),
    );
    await waitFor(() => expect(mocks.create).toHaveBeenCalledTimes(1));
    fireEvent.keyDown(
      screen.getByRole("button", {
        name: "Score actions for Quality (Observation)",
      }),
      { key: "ArrowDown" },
    );
    fireEvent.click(
      await screen.findByRole("menuitem", { name: "Remove score" }),
    );
    await act(async () => pending.reject(new Error("Trace save failed")));
    const remaining = screen.getByRole("group", { name: "Quality" });
    expect(
      within(remaining).getByRole("tab", { name: /True/ }),
    ).toHaveAttribute("aria-selected", "false");
    expect(within(remaining).getByText("Failed to create score")).toBeVisible();
    fireEvent.mouseDown(within(remaining).getByRole("tab", { name: /False/ }));
    await waitFor(() => expect(mocks.create).toHaveBeenCalledTimes(2));
    expect(mocks.create).toHaveBeenLastCalledWith(
      expect.objectContaining({
        scoreTarget: { type: "trace", traceId: "trace" },
        value: 0,
      }),
    );
    expect(mocks.update).not.toHaveBeenCalled();
  });

  it("keeps a single-target numeric form untagged and hides Saved while its next draft is invalid", async () => {
    const numeric = {
      ...defaultConfig,
      id: "numeric",
      name: "Rating",
      dataType: "NUMERIC" as const,
      minValue: 0,
      maxValue: 10,
      categories: null,
    };
    mocks.create.mockResolvedValue({});
    renderContent(
      <AnnotationForm
        scoreTarget={{ type: "session", sessionId: "session" }}
        serverScores={[]}
        scoreMetadata={{ projectId: "project", environment: "session-env" }}
        analyticsData={{ type: "session", source: "SessionDetail", isV4: true }}
        configSelection={{ mode: "fixed", configs: [numeric] }}
      />,
    );
    expect(
      screen.queryByRole("status", { name: "Score save status" }),
    ).not.toBeInTheDocument();
    expect(screen.getByRole("group", { name: "Rating" })).toBeInTheDocument();
    const input = screen.getByRole("spinbutton");
    fireEvent.input(input, { target: { value: "5" } });
    fireEvent.blur(input);
    await waitFor(() =>
      expect(
        screen.getByRole("status", { name: "Score save status" }),
      ).toHaveTextContent("Saved"),
    );
    expect(mocks.create).toHaveBeenCalledWith(
      expect.objectContaining({
        scoreTarget: { type: "session", sessionId: "session" },
        environment: "session-env",
      }),
    );
    fireEvent.input(input, { target: { value: "11" } });
    expect(
      screen.queryByRole("status", { name: "Score save status" }),
    ).not.toBeInTheDocument();
    fireEvent.blur(input);
    expect(mocks.update).not.toHaveBeenCalled();
    expect(
      screen.queryByRole("status", { name: "Score save status" }),
    ).not.toBeInTheDocument();
  });

  it("does not delete a saved score for Firefox badInput and recovers from number and range errors", async () => {
    const numeric = {
      ...defaultConfig,
      id: "numeric",
      name: "Rating",
      dataType: "NUMERIC" as const,
      minValue: 1,
      maxValue: 5,
      categories: null,
    };
    mocks.create.mockResolvedValue({});
    mocks.update.mockResolvedValue({});
    mocks.remove.mockResolvedValue({});
    renderContent(
      <AnnotationForm
        scoreTarget={{ type: "session", sessionId: "session" }}
        serverScores={[]}
        scoreMetadata={{ projectId: "project", environment: "session-env" }}
        analyticsData={{ type: "session", source: "SessionDetail", isV4: true }}
        configSelection={{ mode: "fixed", configs: [numeric] }}
      />,
    );
    const input = screen.getByRole("spinbutton") as HTMLInputElement;
    fireEvent.input(input, { target: { value: "5" } });
    fireEvent.blur(input);
    await waitFor(() =>
      expect(
        screen.getByRole("status", { name: "Score save status" }),
      ).toHaveTextContent("Saved"),
    );

    fireEvent.input(input, { target: { value: "" } });
    const badInput = vi
      .spyOn(input.validity, "badInput", "get")
      .mockReturnValue(true);
    // Firefox emits another input event while its sanitized value stays empty.
    fireEvent.input(input);
    expect(screen.getByText("Enter a number")).toBeVisible();
    expect(input).toHaveAttribute("aria-invalid", "true");
    await act(async () => fireEvent.blur(input));
    expect(mocks.remove).not.toHaveBeenCalled();
    expect(screen.getByText("Enter a number")).toBeVisible();
    expect(input).toHaveAttribute("aria-invalid", "true");
    expect(input).toHaveAccessibleDescription("Enter a number");

    badInput.mockReturnValue(false);
    fireEvent.input(input, { target: { value: "6" } });
    expect(screen.getByText("Enter a value between 1 and 5")).toBeVisible();
    fireEvent.blur(input);
    expect(mocks.update).not.toHaveBeenCalled();
    fireEvent.input(input, { target: { value: "3" } });
    expect(input).toHaveAttribute("aria-invalid", "false");
    expect(
      screen.queryByText("Enter a value between 1 and 5"),
    ).not.toBeInTheDocument();
    fireEvent.blur(input);
    await waitFor(() =>
      expect(mocks.update).toHaveBeenCalledWith(
        expect.objectContaining({
          value: 3,
          scoreTarget: { type: "session", sessionId: "session" },
        }),
      ),
    );
    await act(async () => {
      fireEvent.change(input, { target: { value: "" } });
      fireEvent.blur(input);
    });
    expect(mocks.remove).toHaveBeenCalledTimes(1);
    badInput.mockRestore();
  });

  it("saves on another row's actions and when dismissing its own actions without clearing", async () => {
    const text = {
      ...defaultConfig,
      id: "feedback",
      name: "Feedback",
      dataType: "TEXT" as const,
      categories: null,
    };
    mocks.create.mockResolvedValue({});
    mocks.update.mockResolvedValue({});
    renderContent(
      <AnnotationForm
        scoreTarget={{ type: "session", sessionId: "session" }}
        serverScores={[]}
        scoreMetadata={{ projectId: "project" }}
        analyticsData={{ type: "session", source: "SessionDetail", isV4: true }}
        configSelection={{
          mode: "fixed",
          configs: [text, { ...text, id: "notes", name: "Notes" }],
        }}
      />,
    );
    const input = within(
      screen.getByRole("group", { name: "Feedback" }),
    ).getByRole("textbox");
    const otherInput = within(
      screen.getByRole("group", { name: "Notes" }),
    ).getByRole("textbox");
    fireEvent.change(otherInput, { target: { value: "Other draft" } });
    act(() => input.focus());
    fireEvent.change(input, { target: { value: "Save feedback" } });
    const otherActions = screen.getByRole("button", {
      name: "Score actions for Notes",
    });
    act(() => otherActions.focus());
    await waitFor(() => expect(mocks.create).toHaveBeenCalledTimes(1));
    expect(mocks.create).toHaveBeenCalledWith(
      expect.objectContaining({
        configId: "feedback",
        stringValue: "Save feedback",
      }),
    );

    act(() => input.focus());
    fireEvent.change(input, { target: { value: "Keep this edit" } });
    const actions = screen.getByRole("button", {
      name: "Score actions for Feedback",
    });
    act(() => actions.focus());
    fireEvent.keyDown(actions, { key: "ArrowDown" });
    const clearItem = await screen.findByRole("menuitem", {
      name: "Clear score",
    });
    expect(mocks.update).not.toHaveBeenCalled();
    fireEvent.keyDown(clearItem, { key: "Escape" });
    await waitFor(() =>
      expect(mocks.update).toHaveBeenCalledWith(
        expect.objectContaining({
          configId: "feedback",
          stringValue: "Keep this edit",
        }),
      ),
    );
    expect(mocks.remove).not.toHaveBeenCalled();
    expect(otherInput).toHaveValue("Other draft");
  });

  it("clears an unsaved draft from the labeled menu without posting it or removing a fixed field", async () => {
    const text = {
      ...defaultConfig,
      id: "feedback",
      name: "Feedback",
      dataType: "TEXT" as const,
      categories: null,
    };
    renderContent(
      <AnnotationForm
        scoreTarget={{ type: "session", sessionId: "session" }}
        serverScores={[]}
        scoreMetadata={{ projectId: "project" }}
        analyticsData={{ type: "session", source: "SessionDetail", isV4: true }}
        configSelection={{ mode: "fixed", configs: [text] }}
      />,
    );
    const input = screen.getByRole("textbox");
    expect(
      screen.queryByRole("button", { name: "Score actions for Feedback" }),
    ).not.toBeInTheDocument();
    act(() => input.focus());
    fireEvent.change(input, { target: { value: "Unsent feedback" } });
    const actions = screen.getByRole("button", {
      name: "Score actions for Feedback",
    });
    act(() => actions.focus());
    fireEvent.keyDown(actions, { key: "ArrowDown" });
    fireEvent.click(
      await screen.findByRole("menuitem", { name: "Clear score" }),
    );
    await waitFor(() =>
      expect(screen.queryByRole("menu")).not.toBeInTheDocument(),
    );
    expect(screen.getByRole("textbox")).toHaveValue("");
    expect(screen.getByRole("group", { name: "Feedback" })).toBeInTheDocument();
    expect(mocks.create).not.toHaveBeenCalled();
    expect(mocks.remove).not.toHaveBeenCalled();
    expect(
      screen.queryByRole("status", { name: "Score save status" }),
    ).not.toBeInTheDocument();
  });
});

function deferred() {
  let resolve!: (value: unknown) => void;
  let reject!: (error: Error) => void;
  const promise = new Promise<unknown>((onResolve, onReject) => {
    resolve = onResolve;
    reject = onReject;
  });
  return { promise, resolve, reject };
}

async function renderBothTargets() {
  renderContent();
  fireEvent.keyDown(
    screen.getByRole("button", { name: "Score actions for Quality" }),
    { key: "ArrowDown" },
  );
  fireEvent.click(
    await screen.findByRole("menuitem", { name: "Also score trace" }),
  );
  await waitFor(() =>
    expect(screen.queryByRole("menu")).not.toBeInTheDocument(),
  );
  expect(screen.getAllByRole("group", { name: /Quality/ })).toHaveLength(2);
  expect(mocks.create).not.toHaveBeenCalled();
}