Skip to content

OpenRAG is a comprehensive, single package Retrieval-Augmented Generation platform built on Langflow, Docling, and Opensearch.

Python

chore: Setup UI testing framework (#2341)

Mike Fortman1f775796f141
diff --git a/.github/workflows/test-frontend-unit.yml b/.github/workflows/test-frontend-unit.yml
new file mode 100644
index 000000000..432bd41b4
--- /dev/null
+++ b/.github/workflows/test-frontend-unit.yml
@@ -0,0 +1,74 @@
+name: Frontend Unit Tests
+
+# Fast Vitest layer: jsdom + Testing Library + MSW, no Docker and no services.
+# The Playwright E2E suite is unchanged and still runs in test-ci.yml.
+# See local/plans/frontend-testing-foundation.md.
+
+on:
+ pull_request:
+ paths:
+ - 'frontend/**'
+ - '.github/workflows/test-frontend-unit.yml'
+ push:
+ branches:
+ - main
+ paths:
+ - 'frontend/**'
+ - '.github/workflows/test-frontend-unit.yml'
+
+permissions:
+ contents: read
+
+jobs:
+ vitest:
+ name: Vitest
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v7
+ with:
+ persist-credentials: false
+
+ - name: Set up Node.js
+ uses: actions/setup-node@v7
+ with:
+ node-version: '22'
+ cache: 'npm'
+ cache-dependency-path: frontend/package-lock.json
+
+ - name: Install dependencies
+ working-directory: frontend
+ run: npm ci
+
+ - name: Vitest
+ working-directory: frontend
+ run: npm test
+
+ diff-coverage:
+ name: Diff coverage
+ # PRs only: there is no meaningful base to diff against on a push to main.
+ if: github.event_name == 'pull_request'
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v7
+ with:
+ persist-credentials: false
+ # Full history so the merge base with the target branch is reachable.
+ fetch-depth: 0
+
+ - name: Set up Node.js
+ uses: actions/setup-node@v7
+ with:
+ node-version: '22'
+ cache: 'npm'
+ cache-dependency-path: frontend/package-lock.json
+
+ - name: Install dependencies
+ working-directory: frontend
+ run: npm ci
+
+ - name: Check coverage of changed lines
+ working-directory: frontend
+ env:
+ DIFF_COVERAGE_BASE: origin/${{ github.base_ref }}
+ DIFF_COVERAGE_THRESHOLD: '80'
+ run: npm run test:diff-coverage
diff --git a/AGENTS.md b/AGENTS.md
index 6079737f5..898d2f6ff 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -39,6 +39,31 @@ Read the `SKILL.md` files directly. The frontmatter `description` tells you when
- Claude-Code-specific plumbing belongs in `plugin.json` or `.claude/`, not in `SKILL.md`.
- See `plugins/README.md` for the full layout and distribution model.
+## Frontend tests
+
+Two suites live in `frontend/`, and **the file extension names the runner**:
+
+| Pattern | Runner | Command | Needs a backend? |
+|---|---|---|---|
+| `**/*.test.ts(x)` | Vitest | `npm test` (`test:watch`) | No |
+| `tests/**/*.spec.ts` | Playwright | `npx playwright test` | Yes — full Docker stack |
+
+- **Co-locate** Vitest files with their source: `lib/metrics.ts` → `lib/metrics.test.ts`, `components/task-dialog/filters.tsx` → `components/task-dialog/filters.test.tsx`.
+- `tests/` is Playwright's `testDir` and holds only `.spec.ts`. Shared Vitest infrastructure lives in `test-utils/`, never in `tests/`.
+- Query by accessible role/label/text. Do not assert on class names or add test-only ids — tests should fail on user-visible behaviour changes, not markup refactors.
+- Never `vi.mock` a module in `app/api/queries/` or `app/api/mutations/`. Mock the network instead, so the URL, `response.ok` handling, payload shape, and react-query wiring stay under test.
+- Use `renderWithProviders` from `test-utils/render.tsx`, not `app/providers.tsx`. The latter monkey-patches `window.fetch` for 401 redirects, and `app/api/get-query-client.ts` memoizes one client per browser process, which leaks cache between tests.
+
+**Diff coverage gate.** PRs must cover the lines they change: `npm run test:diff-coverage` runs the suite and then `scripts/check-diff-coverage.mjs`, which fails when under 80% of *changed executable lines* are covered. Enforced by the `diff-coverage` job in `test-frontend-unit.yml`.
+
+The gate is on changed **lines**, not changed files — a one-line fix to an untested legacy file is not blocked, but new logic must come with tests. It diffs the merge base against the working tree, so it also reports on uncommitted work locally. Tune with `--threshold` / `--base` or `DIFF_COVERAGE_THRESHOLD` / `DIFF_COVERAGE_BASE`.
+
+There is deliberately **no global coverage threshold** (overall is ~5%). A global floor rewards writing the cheapest tests; the diff gate makes new code carry its own weight, and existing gaps get closed by churn priority instead — target the files git history shows are repeatedly fixed, not the ones that look most complex.
+
+**What does not belong in Vitest.** jsdom has no CSS engine and no layout: `getBoundingClientRect()` returns zeros, and `pointer-events`, `opacity`, and other style-driven guards are never applied. Anything whose behaviour depends on real geometry or real CSS — ag-grid virtualization, `use-stick-to-bottom`, `disabled:pointer-events-none` on a Radix trigger — belongs in Playwright. A component's *disabled attribute* is testable in Vitest; the *click being blocked by CSS* is not.
+
+Design notes and phased rollout: `local/plans/frontend-testing-foundation.md`.
+
## Operational constraints
**Single-worker only (until Redis cache lands).** The RBAC permission cache and OAuth-subject→DB-id cache are both per-process (`cachetools.TTLCache`). Running with multiple uvicorn workers or multiple helm replicas means a role grant or revoke takes effect in only one process; the others serve stale permissions for up to `OPENRAG_PERM_CACHE_TTL` seconds (default 60). The startup event in `src/main.py` enforces `UVICORN_WORKERS<=1` and `CACHE_BACKEND=memory` and hard-fails otherwise. To horizontally scale, swap the cache to Redis first.
diff --git a/frontend/app/api/queries/useGetSearchQuery.test.tsx b/frontend/app/api/queries/useGetSearchQuery.test.tsx
new file mode 100644
index 000000000..d29fadb5b
--- /dev/null
+++ b/frontend/app/api/queries/useGetSearchQuery.test.tsx
@@ -0,0 +1,392 @@
+import { HttpResponse, http } from "msw";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { ParsedQueryData } from "@/contexts/knowledge-filter-context";
+import { server } from "@/test-utils/msw/server";
+import { createQueryWrapper, renderHook, waitFor } from "@/test-utils/render";
+import {
+ type ChunkResult,
+ type SearchPayload,
+ useGetSearchQuery,
+} from "./useGetSearchQuery";
+
+/**
+ * Chosen by churn: 4 of this file's 18 commits in the last year were bug fixes
+ * ("tune search relevance for partial and unique queries", "Knowledge search
+ * fails with embedding model error" #1499, "display file names and fix
+ * ingestion for onedrive" #1609, "bubble up search errors to ui").
+ *
+ * The request payload matters as much as the parsing here — several of those
+ * fixes changed what gets SENT — so most tests capture the POST body.
+ */
+
+function chunk(overrides: Partial<ChunkResult> = {}): ChunkResult {
+ return {
+ filename: "a.pdf",
+ mimetype: "application/pdf",
+ page: 1,
+ text: "body",
+ score: 1,
+ ...overrides,
+ };
+}
+
+function queryData(overrides: Partial<ParsedQueryData> = {}): ParsedQueryData {
+ return {
+ query: "",
+ filters: {
+ data_sources: [],
+ document_types: [],
+ owners: [],
+ connector_types: [],
+ },
+ limit: 100,
+ scoreThreshold: 1.25,
+ color: "blue" as ParsedQueryData["color"],
+ icon: "file" as ParsedQueryData["icon"],
+ ...overrides,
+ };
+}
+
+/** Serves /api/search and records the payload the hook sent. */
+function serveSearch(body: Record<string, unknown>, status = 200) {
+ const seen: { payload?: SearchPayload } = {};
+ server.use(
+ http.post("/api/search", async ({ request }) => {
+ seen.payload = (await request.json()) as SearchPayload;
+ return status === 200
+ ? HttpResponse.json(body)
+ : HttpResponse.json(body, { status });
+ }),
+ );
+ return seen;
+}
+
+async function runSearch(query: string, data?: ParsedQueryData | null) {
+ const rendered = renderHook(() => useGetSearchQuery(query, data), {
+ wrapper: createQueryWrapper(),
+ });
+ await waitFor(() =>
+ expect(
+ rendered.result.current.isSuccess || rendered.result.current.isError,
+ ).toBe(true),
+ );
+ return rendered;
+}
+
+beforeEach(() => {
+ // getFiles console.errors before rethrowing; keep the test output clean.
+ vi.spyOn(console, "error").mockImplementation(() => {});
+});
+
+describe("useGetSearchQuery", () => {
+ describe("request payload", () => {
+ it("defaults an empty query to the wildcard with a high limit", async () => {
+ const seen = serveSearch({ results: [] });
+
+ await runSearch("");
+
+ // Regression: "update limits so knowledge filters file list isn't
+ // limited to one" — wildcard must not use the 100 default.
+ expect(seen.payload).toMatchObject({ query: "*", limit: 10000 });
+ });
+
+ it("uses queryData.query when the query argument is empty", async () => {
+ const seen = serveSearch({ results: [] });
+
+ await runSearch("", queryData({ query: "invoices" }));
+
+ expect(seen.payload?.query).toBe("invoices");
+ expect(seen.payload?.limit).toBe(100);
+ });
+
+ it("prefers the explicit query over queryData", async () => {
+ const seen = serveSearch({ results: [] });
+
+ await runSearch("explicit", queryData({ query: "ignored" }));
+
+ expect(seen.payload?.query).toBe("explicit");
+ });
+
+ it("honours a custom limit from queryData", async () => {
+ const seen = serveSearch({ results: [] });
+
+ await runSearch("term", queryData({ limit: 7 }));
+
+ expect(seen.payload?.limit).toBe(7);
+ });
+
+ it("caps the score threshold for short single-token queries", async () => {
+ const seen = serveSearch({ results: [] });
+
+ // Regression: "tune search relevance for partial and unique queries".
+ await runSearch("acme", queryData({ scoreThreshold: 1.25 }));
+
+ expect(seen.payload?.scoreThreshold).toBe(1.0);
+ });
+
+ it("leaves the threshold alone for longer or multi-word queries", async () => {
+ const longQuery = serveSearch({ results: [] });
+ await runSearch("quarterly", queryData({ scoreThreshold: 1.25 }));
+ expect(longQuery.payload?.scoreThreshold).toBe(1.25);
+
+ const multiWord = serveSearch({ results: [] });
+ await runSearch("a b", queryData({ scoreThreshold: 1.25 }));
+ expect(multiWord.payload?.scoreThreshold).toBe(1.25);
+ });
+
+ it("does not raise a threshold already below the cap", async () => {
+ const seen = serveSearch({ results: [] });
+
+ await runSearch("acme", queryData({ scoreThreshold: 0.4 }));
+
+ expect(seen.payload?.scoreThreshold).toBe(0.4);
+ });
+
+ it("omits filters entirely when every dimension is empty", async () => {
+ const seen = serveSearch({ results: [] });
+
+ await runSearch("term", queryData());
+
+ expect(seen.payload?.filters).toBeUndefined();
+ });
+
+ it("sends only the populated filter dimensions", async () => {
+ const seen = serveSearch({ results: [] });
+
+ await runSearch(
+ "term",
+ queryData({
+ filters: {
+ data_sources: ["s3"],
+ document_types: [],
+ owners: ["[email protected]"],
+ connector_types: [],
+ },
+ }),
+ );
+
+ expect(seen.payload?.filters).toEqual({
+ data_sources: ["s3"],
+ owners: ["[email protected]"],
+ });
+ });
+
+ it("treats a '*' dimension as unfiltered", async () => {
+ const seen = serveSearch({ results: [] });
+
+ await runSearch(
+ "term",
+ queryData({
+ filters: {
+ data_sources: ["*"],
+ document_types: ["pdf"],
+ owners: [],
+ connector_types: [],
+ },
+ }),
+ );
+
+ expect(seen.payload?.filters).toEqual({ document_types: ["pdf"] });
+ });
+ });
+
+ describe("grouping chunks into files", () => {
+ it("groups chunks by filename and averages their scores", async () => {
+ serveSearch({
+ results: [
+ chunk({ filename: "a.pdf", score: 2 }),
+ chunk({ filename: "a.pdf", score: 4 }),
+ chunk({ filename: "b.pdf", score: 1 }),
+ ],
+ });
+
+ const { result } = await runSearch("term");
+
+ const files = result.current.data?.files ?? [];
+ expect(files).toHaveLength(2);
+ expect(files[0]).toMatchObject({
+ filename: "a.pdf",
+ chunkCount: 2,
+ avgScore: 3,
+ });
+ expect(files[1]).toMatchObject({ filename: "b.pdf", chunkCount: 1 });
+ });
+
+ it("falls back to source_url, then to Untitled source (#1609)", async () => {
+ serveSearch({
+ results: [
+ chunk({ filename: " ", source_url: "https://x.dev/doc" }),
+ chunk({ filename: "", source_url: "" }),
+ ],
+ });
+
+ const { result } = await runSearch("term");
+
+ expect(result.current.data?.files.map((f) => f.filename)).toEqual([
+ "https://x.dev/doc",
+ "Untitled source",
+ ]);
+ });
+
+ it("backfills embedding metadata from a later chunk (#1499)", async () => {
+ serveSearch({
+ results: [
+ chunk({ filename: "a.pdf" }),
+ chunk({
+ filename: "a.pdf",
+ embedding_model: "granite",
+ embedding_dimensions: 768,
+ }),
+ ],
+ });
+
+ const { result } = await runSearch("term");
+
+ expect(result.current.data?.files[0]).toMatchObject({
+ embedding_model: "granite",
+ embedding_dimensions: 768,
+ });
+ });
+
+ it("keeps the first chunk's embedding model once set (#1499)", async () => {
+ serveSearch({
+ results: [
+ chunk({ filename: "a.pdf", embedding_model: "first" }),
+ chunk({ filename: "a.pdf", embedding_model: "second" }),
+ ],
+ });
+
+ const { result } = await runSearch("term");
+
+ expect(result.current.data?.files[0].embedding_model).toBe("first");
+ });
+
+ it("treats embedding_dimensions of 0 as a real value", async () => {
+ serveSearch({
+ results: [
+ chunk({ filename: "a.pdf", embedding_dimensions: 0 }),
+ chunk({ filename: "a.pdf", embedding_dimensions: 512 }),
+ ],
+ });
+
+ const { result } = await runSearch("term");
+
+ // `== null` guard, so 0 must not be overwritten.
+ expect(result.current.data?.files[0].embedding_dimensions).toBe(0);
+ });
+
+ it("applies defaults for missing optional fields", async () => {
+ serveSearch({ results: [chunk({ filename: "a.pdf" })] });
+
+ const { result } = await runSearch("term");
+
+ expect(result.current.data?.files[0]).toMatchObject({
+ source_url: "",
+ owner: "",
+ size: 0,
+ connector_type: "local",
+ allowed_users: [],
+ allowed_groups: [],
+ });
+ });
+
+ it("carries ACL fields through when present (#1611)", async () => {
+ serveSearch({
+ results: [
+ chunk({
+ filename: "a.pdf",
+ allowed_users: ["u1"],
+ allowed_groups: ["g1"],
+ }),
+ ],
+ });
+
+ const { result } = await runSearch("term");
+
+ expect(result.current.data?.files[0]).toMatchObject({
+ allowed_users: ["u1"],
+ allowed_groups: ["g1"],
+ });
+ });
+
+ it("returns an empty result when the payload has no results key", async () => {
+ serveSearch({});
+
+ const { result } = await runSearch("term");
+
+ expect(result.current.data).toEqual({ files: [], warnings: [] });
+ });
+ });
+
+ describe("warnings", () => {
+ it("passes backend warnings straight through (#1499)", async () => {
+ serveSearch({
+ results: [],
+ warnings: [{ code: "embedding_model_missing", models: ["old-model"] }],
+ });
+
+ const { result } = await runSearch("term");
+
+ expect(result.current.data?.warnings).toEqual([
+ { code: "embedding_model_missing", models: ["old-model"] },
+ ]);
+ });
+
+ it("normalizes a non-array warnings field to an empty list", async () => {
+ serveSearch({ results: [], warnings: "oops" });
+
+ const { result } = await runSearch("term");
+
+ expect(result.current.data?.warnings).toEqual([]);
+ });
+ });
+
+ describe("errors", () => {
+ it("surfaces the backend error message (bubble up search errors to ui)", async () => {
+ serveSearch({ error: "index missing" }, 500);
+
+ const { result } = await runSearch("term");
+
+ expect(result.current.isError).toBe(true);
+ expect(result.current.error?.message).toBe("index missing");
+ });
+
+ it("falls back to the status code when the body has no error field", async () => {
+ serveSearch({}, 503);
+
+ const { result } = await runSearch("term");
+
+ expect(result.current.error?.message).toBe(
+ "Search failed with status 503",
+ );
+ });
+
+ it("handles a non-JSON error body", async () => {
+ server.use(
+ http.post("/api/search", () =>
+ HttpResponse.text("<html>bad gateway</html>", { status: 502 }),
+ ),
+ );
+
+ const { result } = await runSearch("term");
+
+ expect(result.current.isError).toBe(true);
+ expect(result.current.error?.message).toBe("Unknown error");
+ });
+
+ it("does not retry a failed search", async () => {
+ let calls = 0;
+ server.use(
+ http.post("/api/search", () => {
+ calls++;
+ return HttpResponse.json({ error: "nope" }, { status: 500 });
+ }),
+ );
+
+ await runSearch("term");
+
+ // retry: false is set explicitly so errors show immediately.
+ expect(calls).toBe(1);
+ });
+ });
+});
diff --git a/frontend/app/api/queries/useGetTasksQuery.test.tsx b/frontend/app/api/queries/useGetTasksQuery.test.tsx
new file mode 100644
index 000000000..8d0ab4ef7
--- /dev/null
+++ b/frontend/app/api/queries/useGetTasksQuery.test.tsx
@@ -0,0 +1,84 @@
+import { HttpResponse, http } from "msw";
+import { describe, expect, it } from "vitest";
+import { server } from "@/test-utils/msw/server";
+import { createQueryWrapper, renderHook, waitFor } from "@/test-utils/render";
+import { type Task, useGetTasksQuery } from "./useGetTasksQuery";
+
+/**
+ * Reference pattern for testing a query hook.
+ *
+ * Nothing here is mocked with `vi.mock`. The real `getTasks` runs, so the URL,
+ * the `response.ok` branch, the `data.tasks || []` unwrapping, and the
+ * react-query wiring are all genuinely under test — MSW only answers the
+ * network underneath.
+ */
+
+function task(overrides: Partial<Task> = {}): Task {
+ return {
+ task_id: "t1",
+ status: "completed",
+ created_at: "2026-09-08T10:00:00Z",
+ updated_at: "2026-09-08T10:01:00Z",
+ ...overrides,
+ };
+}
+
+describe("useGetTasksQuery", () => {
+ it("resolves a relative /api path through MSW and unwraps tasks", async () => {
+ server.use(
+ http.get("/api/tasks/enhanced", () =>
+ HttpResponse.json({ tasks: [task({ task_id: "abc" })] }),
+ ),
+ );
+
+ const { result } = renderHook(() => useGetTasksQuery(), {
+ wrapper: createQueryWrapper(),
+ });
+
+ await waitFor(() => expect(result.current.isSuccess).toBe(true));
+ expect(result.current.data).toHaveLength(1);
+ expect(result.current.data?.[0].task_id).toBe("abc");
+ });
+
+ it("returns [] when the payload has no tasks key", async () => {
+ server.use(http.get("/api/tasks/enhanced", () => HttpResponse.json({})));
+
+ const { result } = renderHook(() => useGetTasksQuery(), {
+ wrapper: createQueryWrapper(),
+ });
+
+ await waitFor(() => expect(result.current.isSuccess).toBe(true));
+ expect(result.current.data).toEqual([]);
+ });
+
+ it("surfaces an error when the backend returns 500", async () => {
+ server.use(
+ http.get(
+ "/api/tasks/enhanced",
+ () => new HttpResponse(null, { status: 500 }),
+ ),
+ );
+
+ const { result } = renderHook(() => useGetTasksQuery(), {
+ wrapper: createQueryWrapper(),
+ });
+
+ await waitFor(() => expect(result.current.isError).toBe(true));
+ expect(result.current.error?.message).toBe("Failed to fetch tasks");
+ });
+
+ it("surfaces an error when the backend returns 401", async () => {
+ server.use(
+ http.get(
+ "/api/tasks/enhanced",
+ () => new HttpResponse(null, { status: 401 }),
+ ),
+ );
+
+ const { result } = renderHook(() => useGetTasksQuery(), {
+ wrapper: createQueryWrapper(),
+ });
+
+ await waitFor(() => expect(result.current.isError).toBe(true));
+ });
+});
diff --git a/frontend/app/onboarding/_components/onboarding-completion.test.ts b/frontend/app/onboarding/_components/onboarding-completion.test.ts
index a99c79547..80e7190d9 100644
--- a/frontend/app/onboarding/_components/onboarding-completion.test.ts
+++ b/frontend/app/onboarding/_components/onboarding-completion.test.ts
@@ -1,5 +1,5 @@
import assert from "node:assert/strict";
-import { describe, it } from "node:test";
+import { describe, it } from "vitest";
// Node's built-in TypeScript runner requires the extension; tsc resolves the same source.
// @ts-expect-error TS5097
import { canCompleteOnboarding } from "./onboarding-completion.ts";
diff --git a/frontend/components/console-status/refresh.test.ts b/frontend/components/console-status/refresh.test.ts
index 697c4a828..929fb15e8 100644
--- a/frontend/components/console-status/refresh.test.ts
+++ b/frontend/components/console-status/refresh.test.ts
@@ -1,5 +1,5 @@
import assert from "node:assert/strict";
-import { describe, it } from "node:test";
+import { describe, it } from "vitest";
import { refreshConsoleStatusQueries } from "./refresh";
describe("refreshConsoleStatusQueries", () => {
diff --git a/frontend/components/models/catalog-models.test.ts b/frontend/components/models/catalog-models.test.ts
index a698deca2..dba087bd8 100644
--- a/frontend/components/models/catalog-models.test.ts
+++ b/frontend/components/models/catalog-models.test.ts
@@ -1,5 +1,5 @@
import assert from "node:assert/strict";
-import { describe, it } from "node:test";
+import { describe, it } from "vitest";
import {
findGroupedSelection,
groupedCatalogOptions,
diff --git a/frontend/components/models/model-helpers.test.ts b/frontend/components/models/model-helpers.test.ts
index 4e7905135..e56a84998 100644
--- a/frontend/components/models/model-helpers.test.ts
+++ b/frontend/components/models/model-helpers.test.ts
@@ -9,7 +9,7 @@
*/
import assert from "node:assert/strict";
-import { describe, it } from "node:test";
+import { describe, it } from "vitest";
import {
canRemoveProvider,
EMBEDDING_PROVIDER_ORDER,
diff --git a/frontend/components/task-dialog/filters.test.tsx b/frontend/components/task-dialog/filters.test.tsx
new file mode 100644
index 000000000..e0ec340ca
--- /dev/null
+++ b/frontend/components/task-dialog/filters.test.tsx
@@ -0,0 +1,88 @@
+import { describe, expect, it, vi } from "vitest";
+import { ALL_TASK_FILE_TYPES } from "@/lib/task-utils";
+import { render, screen, userEvent, within } from "@/test-utils/render";
+import { TaskDialogFilters } from "./filters";
+
+// TaskDialogFilters is props-only, so plain `render` is enough — no
+// QueryClient needed. It reads `useIsCloudBrand`, but BrandContext has a
+// default value, so these tests exercise the default (OSS) brand path.
+
+function setup(
+ overrides: Partial<Parameters<typeof TaskDialogFilters>[0]> = {},
+) {
+ const onSearchChange = vi.fn();
+ const onFileTypeChange = vi.fn();
+
+ render(
+ <TaskDialogFilters
+ search=""
+ onSearchChange={onSearchChange}
+ fileType={ALL_TASK_FILE_TYPES}
+ onFileTypeChange={onFileTypeChange}
+ fileTypes={["pdf", "docx"]}
+ fileTypeLabel="All file types"
+ searchDisabled={false}
+ fileTypeDisabled={false}
+ {...overrides}
+ />,
+ );
+
+ return { onSearchChange, onFileTypeChange, user: userEvent.setup() };
+}
+
+describe("TaskDialogFilters", () => {
+ it("reports each keystroke in the search field", async () => {
+ const { onSearchChange, user } = setup();
+
+ await user.type(screen.getByPlaceholderText("Search files..."), "ab");
+
+ // Controlled input pinned to search="", so each call sees a single char.
+ expect(onSearchChange).toHaveBeenCalledTimes(2);
+ expect(onSearchChange).toHaveBeenNthCalledWith(1, "a");
+ expect(onSearchChange).toHaveBeenNthCalledWith(2, "b");
+ });
+
+ it("disables the search field when searchDisabled is set", () => {
+ setup({ searchDisabled: true });
+
+ expect(screen.getByPlaceholderText("Search files...")).toBeDisabled();
+ });
+
+ it("opens the file type menu and lists all types plus the catch-all", async () => {
+ const { user } = setup();
+
+ await user.click(screen.getByRole("button", { name: /all file types/i }));
+
+ const menu = await screen.findByRole("menu");
+ const items = within(menu).getAllByRole("menuitem");
+ expect(items.map((item) => item.textContent)).toEqual([
+ "All file types",
+ "PDF",
+ "DOCX",
+ ]);
+ });
+
+ it("emits the raw file type value when an option is chosen", async () => {
+ const { onFileTypeChange, user } = setup();
+
+ await user.click(screen.getByRole("button", { name: /all file types/i }));
+ await user.click(await screen.findByRole("menuitem", { name: "PDF" }));
+
+ expect(onFileTypeChange).toHaveBeenCalledExactlyOnceWith("pdf");
+ });
+
+ it("marks the file type trigger disabled when fileTypeDisabled is set", () => {
+ setup({ fileTypeDisabled: true });
+
+ expect(
+ screen.getByRole("button", { name: /all file types/i }),
+ ).toBeDisabled();
+ });
+
+ // NOT TESTED HERE, ON PURPOSE: that a disabled trigger leaves the menu shut.
+ // components/ui/button.tsx:7 enforces that with `disabled:pointer-events-none`,
+ // a CSS rule. jsdom has no CSS engine, so Radix's pointerdown listener fires
+ // anyway and the menu opens — the assertion would fail against code that is
+ // correct in a real browser. CSS-enforced behaviour belongs in Playwright.
+ // See R3 in local/plans/frontend-testing-foundation.md.
+});
diff --git a/frontend/components/task-dialog/use-task-dialog.test.tsx b/frontend/components/task-dialog/use-task-dialog.test.tsx
new file mode 100644
index 000000000..c5f987efb
--- /dev/null
+++ b/frontend/components/task-dialog/use-task-dialog.test.tsx
@@ -0,0 +1,346 @@
+import { HttpResponse, http } from "msw";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { RetryTaskResponse } from "@/app/api/mutations/useRetryTaskMutation";
+import type { Task, TaskFileEntry } from "@/app/api/queries/useGetTasksQuery";
+import { server } from "@/test-utils/msw/server";
+import {
+ act,
+ createQueryWrapper,
+ renderHook,
+ waitFor,
+} from "@/test-utils/render";
+import { useTaskDialog } from "./use-task-dialog";
+
+/**
+ * Phase 4 vertical slice: the task dialog's orchestration hook.
+ *
+ * What is real here: useGetTaskQuery, useRetryTaskMutation, the whole of
+ * lib/task-utils, and the react-query cache. Requests are answered by MSW, so
+ * URLs, `response.ok` branches, and payload shapes are all under test.
+ *
+ * What is mocked, and why:
+ * - `@/contexts/task-context` — `useTask()` throws outside a TaskProvider,
+ * and that provider is ~700 lines that fetch on mount. Mocking a *context*
+ * is fine; mocking `app/api/queries|mutations` is not (see AGENTS.md).
+ * - `sonner` — toasts are a side effect we assert on, not a thing to render.
+ */
+
+const markTaskFilesProcessing = vi.fn();
+const refreshTasks = vi.fn().mockResolvedValue(undefined);
+
+vi.mock("@/contexts/task-context", () => ({
+ useTask: () => ({ markTaskFilesProcessing, refreshTasks }),
+}));
+
+const toast = vi.hoisted(() => ({
+ success: vi.fn(),
+ warning: vi.fn(),
+ error: vi.fn(),
+}));
+vi.mock("sonner", () => ({ toast }));
+
+const TASK_ID = "task-1";
+
+function file(overrides: Partial<TaskFileEntry> = {}): TaskFileEntry {
+ return { status: "completed", ...overrides };
+}
+
+function task(files: Record<string, TaskFileEntry>): Task {
+ return {
+ task_id: TASK_ID,
+ status: "completed",
+ created_at: "2026-09-08T10:00:00Z",
+ updated_at: "2026-09-08T10:05:00Z",
+ files,
+ };
+}
+
+/** Answers GET /api/tasks/:id/enhanced with `body`. */
+function serveTask(body: Task | null, status = 200) {
+ server.use(
+ http.get(`/api/tasks/${TASK_ID}/enhanced`, () =>
+ status === 200
+ ? HttpResponse.json(body)
+ : new HttpResponse(null, { status }),
+ ),
+ );
+}
+
+function renderDialog() {
+ return renderHook(() => useTaskDialog(true, TASK_ID), {
+ wrapper: createQueryWrapper(),
+ });
+}
+
+/** Renders and waits for the task fetch to settle. */
+async function renderLoaded() {
+ const rendered = renderDialog();
+ await waitFor(() => expect(rendered.result.current.isLoading).toBe(false));
+ return rendered;
+}
+
+beforeEach(() => {
+ vi.clearAllMocks();
+});
+
+describe("useTaskDialog", () => {
+ describe("loading the task", () => {
+ it("starts in a loading state and then exposes the task", async () => {
+ serveTask(task({ "a.pdf": file() }));
+
+ const { result } = renderDialog();
+ expect(result.current.isLoading).toBe(true);
+
+ await waitFor(() => expect(result.current.isLoading).toBe(false));
+ expect(result.current.task?.task_id).toBe(TASK_ID);
+ expect(result.current.fileEntries).toHaveLength(1);
+ });
+
+ it("reports an error when the backend fails", async () => {
+ serveTask(null, 500);
+
+ const { result } = renderDialog();
+
+ await waitFor(() => expect(result.current.isError).toBe(true));
+ expect(result.current.task).toBeUndefined();
+ });
+
+ it("treats a 404 as an empty task rather than an error", async () => {
+ serveTask(null, 404);
+
+ const { result } = await renderLoaded();
+
+ expect(result.current.isError).toBe(false);
+ expect(result.current.task).toBeUndefined();
+ expect(result.current.fileEntries).toEqual([]);
+ });
+ });
+
+ describe("filtering", () => {
+ it("narrows entries by search text", async () => {
+ serveTask(task({ "report.pdf": file(), "notes.docx": file() }));
+
+ const { result } = await renderLoaded();
+ expect(result.current.sortedEntries).toHaveLength(2);
+
+ act(() => result.current.setSearch("report"));
+
+ await waitFor(() => expect(result.current.sortedEntries).toHaveLength(1));
+ expect(result.current.sortedEntries[0][0]).toBe("report.pdf");
+ });
+
+ it("derives the available file types from the task", async () => {
+ serveTask(task({ "a.pdf": file(), "b.docx": file(), "c.pdf": file() }));
+
+ const { result } = await renderLoaded();
+
+ expect(result.current.fileTypes.sort()).toEqual(["docx", "pdf"]);
+ });
+
+ it("falls back to all file types when the selected type is absent", async () => {
+ serveTask(task({ "a.pdf": file() }));
+
+ const { result } = await renderLoaded();
+ act(() => result.current.setFileType("xlsx"));
+
+ // activeFileType, not the raw state, is what the hook exposes.
+ await waitFor(() => expect(result.current.fileType).toBe("__all__"));
+ });
+
+ it("counts entries by status category", async () => {
+ serveTask(
+ task({
+ "ok.pdf": file({ status: "completed" }),
+ "bad.pdf": file({ status: "failed" }),
+ "skip.pdf": file({ status: "skipped" }),
+ }),
+ );
+
+ const { result } = await renderLoaded();
+
+ expect(result.current.categoryCounts).toMatchObject({
+ completed: 1,
+ warning: 1,
+ });
+ });
+ });
+
+ describe("sorting", () => {
+ it("toggles name sort between asc and desc", async () => {
+ serveTask(task({ "a.pdf": file(), "b.pdf": file() }));
+
+ const { result } = await renderLoaded();
+ expect(result.current.nameSort).toBe("asc");
+ expect(result.current.sortedEntries.map(([p]) => p)).toEqual([
+ "a.pdf",
+ "b.pdf",
+ ]);
+
+ act(() => result.current.toggleNameSort());
+
+ await waitFor(() => expect(result.current.nameSort).toBe("desc"));
+ expect(result.current.sortedEntries.map(([p]) => p)).toEqual([
+ "b.pdf",
+ "a.pdf",
+ ]);
+ });
+ });
+
+ describe("selection", () => {
+ it("toggles a single path on and off", async () => {
+ serveTask(
+ task({
+ "a.pdf": file({ status: "failed", actionable_by: "RETRYABLE" }),
+ }),
+ );
+
+ const { result } = await renderLoaded();
+
+ act(() => result.current.toggleSelectedPath("a.pdf"));
+ await waitFor(() => expect(result.current.selectedCount).toBe(1));
+
+ act(() => result.current.toggleSelectedPath("a.pdf"));
+ await waitFor(() => expect(result.current.selectedCount).toBe(0));
+ });
+
+ it("selects and clears all visible retryable paths", async () => {
+ serveTask(
+ task({
+ "a.pdf": file({ status: "failed", actionable_by: "RETRYABLE" }),
+ "b.pdf": file({ status: "failed", actionable_by: "RETRYABLE" }),
+ "done.pdf": file({ status: "completed" }),
+ }),
+ );
+
+ const { result } = await renderLoaded();
+
+ act(() => result.current.toggleSelectAllVisible());
+ await waitFor(() =>
+ expect(result.current.allSelectableSelected).toBe(true),
+ );
+ // The completed file is not selectable.
+ expect(result.current.selectedCount).toBe(2);
+
+ act(() => result.current.toggleSelectAllVisible());
+ await waitFor(() => expect(result.current.selectedCount).toBe(0));
+ });
+ });
+
+ describe("retry", () => {
+ const retryable = {
+ "a.pdf": file({ status: "failed", actionable_by: "RETRYABLE" }),
+ };
+
+ /** Builds a full RetryTaskResponse so fixtures stay faithful to the type. */
+ function retryResponse(
+ overrides: Partial<RetryTaskResponse> = {},
+ ): RetryTaskResponse {
+ return {
+ task_id: TASK_ID,
+ retried: 0,
+ skipped: [],
+ status: "completed",
+ ...overrides,
+ };
+ }
+
+ function serveRetry(body: RetryTaskResponse | null, status = 200) {
+ server.use(
+ http.post(`/api/tasks/${TASK_ID}/retry`, () =>
+ status === 200
+ ? HttpResponse.json(body)
+ : new HttpResponse(null, { status }),
+ ),
+ );
+ }
+
+ it("retries every retryable file and reports success", async () => {
+ serveTask(task(retryable));
+ serveRetry(retryResponse({ retried: 1 }));
+
+ const { result } = await renderLoaded();
+ expect(result.current.retryableCount).toBe(1);
+
+ await act(async () => {
+ await result.current.handleRetryAll();
+ });
+
+ expect(markTaskFilesProcessing).toHaveBeenCalledWith(TASK_ID, ["a.pdf"]);
+ expect(toast.success).toHaveBeenCalledWith(
+ "Retry started",
+ expect.objectContaining({
+ description: "1 file(s) queued for ingestion",
+ }),
+ );
+ expect(result.current.retryingTarget).toBeNull();
+ });
+
+ it("warns when files were skipped because the source is missing", async () => {
+ serveTask(task(retryable));
+ serveRetry(
+ retryResponse({
+ skipped: [{ file_path: "a.pdf", reason: "source_file_missing" }],
+ }),
+ );
+
+ const { result } = await renderLoaded();
+ await act(async () => {
+ await result.current.handleRetryAll();
+ });
+
+ expect(toast.warning).toHaveBeenCalledWith(
+ "Some files could not be retried",
+ expect.objectContaining({
+ description: expect.stringContaining("need to be uploaded again"),
+ }),
+ );
+ expect(toast.success).not.toHaveBeenCalled();
+ });
+
+ it("refreshes tasks and surfaces an error toast when retry fails", async () => {
+ serveTask(task(retryable));
+ serveRetry(null, 500);
+
+ const { result } = await renderLoaded();
+ await act(async () => {
+ await result.current.handleRetryAll();
+ });
+
+ expect(refreshTasks).toHaveBeenCalled();
+ expect(toast.error).toHaveBeenCalledWith(
+ "Retry failed",
+ expect.objectContaining({ description: expect.any(String) }),
+ );
+ expect(result.current.retryingTarget).toBeNull();
+ });
+
+ it("does nothing when there is nothing retryable", async () => {
+ serveTask(task({ "done.pdf": file({ status: "completed" }) }));
+
+ const { result } = await renderLoaded();
+ expect(result.current.retryableCount).toBe(0);
+
+ await act(async () => {
+ await result.current.handleRetryAll();
+ });
+
+ expect(markTaskFilesProcessing).not.toHaveBeenCalled();
+ expect(toast.success).not.toHaveBeenCalled();
+ });
+
+ it("clears the selection after a successful retry", async () => {
+ serveTask(task(retryable));
+ serveRetry(retryResponse({ retried: 1 }));
+
+ const { result } = await renderLoaded();
+ act(() => result.current.toggleSelectedPath("a.pdf"));
+ await waitFor(() => expect(result.current.selectedCount).toBe(1));
+
+ await act(async () => {
+ await result.current.handleRetrySelected();
+ });
+
+ await waitFor(() => expect(result.current.selectedCount).toBe(0));
+ });
+ });
+});
diff --git a/frontend/hooks/useChatStreaming.test.tsx b/frontend/hooks/useChatStreaming.test.tsx
new file mode 100644
index 000000000..ceb73ca22
--- /dev/null
+++ b/frontend/hooks/useChatStreaming.test.tsx
@@ -0,0 +1,372 @@
+import { HttpResponse, http } from "msw";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { server } from "@/test-utils/msw/server";
+import { act, renderHook, waitFor } from "@/test-utils/render";
+import { useChatStreaming } from "./useChatStreaming";
+
+/**
+ * The most-fixed file in the frontend: 6 of 16 commits in the last year were
+ * bug fixes (#2127 "surface provider errors in chat instead of generic
+ * connection failures", #1534 "make watsonx work in chat", #859 "use correct
+ * error handling for chat messages and ingestion", "Error handling for chats
+ * that are slow to respond").
+ *
+ * The transport is newline-delimited JSON, not SSE — the hook splits on "\n"
+ * and JSON.parses each complete line, buffering any partial trailing line.
+ *
+ * Real under test: the whole of lib/chat-stream-parsers and
+ * lib/chat-stream-errors. Only the chat context is mocked, because useChat()
+ * throws outside its provider.
+ */
+
+const refreshConversations = vi.fn();
+vi.mock("@/contexts/chat-context", () => ({
+ useChat: () => ({ refreshConversations }),
+}));
+
+const ENDPOINT = "/api/langflow";
+
+/** A text delta in the OpenAI-style shape the hook's first parser accepts. */
+function textChunk(text: string) {
+ return { object: "response.chunk", delta: { content: text } };
+}
+
+/**
+ * Serves `endpoint` as an NDJSON stream. `raw` lets a test send bytes that are
+ * not one-object-per-line, to exercise the buffering of split lines.
+ */
+function serveStream(chunks: Array<object | string>, endpoint = ENDPOINT) {
+ const seen: { body?: Record<string, unknown> } = {};
+ server.use(
+ http.post(endpoint, async ({ request }) => {
+ seen.body = (await request.json()) as Record<string, unknown>;
+ const encoder = new TextEncoder();
+ const stream = new ReadableStream({
+ start(controller) {
+ for (const c of chunks) {
+ controller.enqueue(
+ encoder.encode(
+ typeof c === "string" ? c : `${JSON.stringify(c)}\n`,
+ ),
+ );
+ }
+ controller.close();
+ },
+ });
+ return new HttpResponse(stream, {
+ headers: { "Content-Type": "application/x-ndjson" },
+ });
+ }),
+ );
+ return seen;
+}
+
+type StreamResult = Awaited<
+ ReturnType<ReturnType<typeof useChatStreaming>["sendMessage"]>
+>;
+
+/**
+ * Sends a message inside act() and returns the result.
+ *
+ * The holder object exists because assigning to a `let` from inside the act()
+ * callback makes TypeScript narrow it to `never`.
+ */
+async function send(
+ result: { current: ReturnType<typeof useChatStreaming> },
+ options: Parameters<ReturnType<typeof useChatStreaming>["sendMessage"]>[0],
+): Promise<StreamResult> {
+ const holder: { value: StreamResult } = { value: null };
+ await act(async () => {
+ holder.value = await result.current.sendMessage(options);
+ });
+ return holder.value;
+}
+
+function setup(options: Parameters<typeof useChatStreaming>[0] = {}) {
+ const onComplete = vi.fn();
+ const onError = vi.fn();
+ const rendered = renderHook(() =>
+ useChatStreaming({ onComplete, onError, ...options }),
+ );
+ return { ...rendered, onComplete, onError };
+}
+
+beforeEach(() => {
+ vi.clearAllMocks();
+ vi.spyOn(console, "error").mockImplementation(() => {});
+ vi.spyOn(console, "warn").mockImplementation(() => {});
+});
+
+describe("useChatStreaming", () => {
+ describe("request body", () => {
+ it("always sends prompt, stream and the limit/threshold defaults", async () => {
+ const seen = serveStream([textChunk("hi")]);
+ const { result } = setup();
+
+ await act(async () => {
+ await result.current.sendMessage({ prompt: "hello" });
+ });
+
+ expect(seen.body).toEqual({
+ prompt: "hello",
+ stream: true,
+ limit: 10,
+ scoreThreshold: 0,
+ });
+ });
+
+ it("includes the optional ids only when provided", async () => {
+ const seen = serveStream([textChunk("hi")]);
+ const { result } = setup();
+
+ await act(async () => {
+ await result.current.sendMessage({
+ prompt: "hello",
+ previousResponseId: "prev-1",
+ conversationId: "conv-1",
+ filter_id: "f-1",
+ limit: 3,
+ scoreThreshold: 0.5,
+ });
+ });
+
+ expect(seen.body).toMatchObject({
+ previous_response_id: "prev-1",
+ conversation_id: "conv-1",
+ filter_id: "f-1",
+ limit: 3,
+ scoreThreshold: 0.5,
+ });
+ });
+
+ it("normalizes filters and omits them when nothing is selected", async () => {
+ const withFilters = serveStream([textChunk("hi")]);
+ const { result } = setup();
+
+ await act(async () => {
+ await result.current.sendMessage({
+ prompt: "p",
+ filters: { data_sources: ["s3"], owners: ["*"] },
+ });
+ });
+ expect(withFilters.body?.filters).toEqual({ data_sources: ["s3"] });
+
+ const empty = serveStream([textChunk("hi")]);
+ await act(async () => {
+ await result.current.sendMessage({
+ prompt: "p",
+ filters: { data_sources: ["*"] },
+ });
+ });
+ expect(empty.body?.filters).toBeUndefined();
+ });
+
+ it("posts to a custom endpoint when configured", async () => {
+ const seen = serveStream([textChunk("hi")], "/api/custom");
+ const { result } = setup({ endpoint: "/api/custom" });
+
+ await act(async () => {
+ await result.current.sendMessage({ prompt: "p" });
+ });
+
+ expect(seen.body?.prompt).toBe("p");
+ });
+ });
+
+ describe("streaming success", () => {
+ it("accumulates deltas into one final message", async () => {
+ serveStream([textChunk("Hel"), textChunk("lo "), textChunk("there")]);
+ const { result, onComplete } = setup();
+
+ const returned = await send(result, { prompt: "p" });
+
+ expect(returned).toMatchObject({
+ role: "assistant",
+ content: "Hello there",
+ isStreaming: false,
+ });
+ expect(onComplete).toHaveBeenCalledOnce();
+ expect(onComplete.mock.calls[0][0].content).toBe("Hello there");
+ });
+
+ it("reassembles a JSON object split across two network chunks", async () => {
+ const line = JSON.stringify(textChunk("split"));
+ serveStream([line.slice(0, 12), `${line.slice(12)}\n`]);
+ const { result } = setup();
+
+ const returned = await send(result, { prompt: "p" });
+
+ expect(returned?.content).toBe("split");
+ });
+
+ it("skips unparseable lines instead of failing the stream", async () => {
+ serveStream(["not json at all\n", textChunk("good")]);
+ const { result } = setup();
+
+ const returned = await send(result, { prompt: "p" });
+
+ expect(returned?.content).toBe("good");
+ });
+
+ it("captures the response id from id or response_id", async () => {
+ serveStream([{ id: "resp-1" }, textChunk("hi")]);
+ const { result, onComplete } = setup();
+ await act(async () => {
+ await result.current.sendMessage({ prompt: "p" });
+ });
+ expect(onComplete.mock.calls[0][1]).toBe("resp-1");
+
+ serveStream([{ response_id: "resp-2" }, textChunk("hi")]);
+ await act(async () => {
+ await result.current.sendMessage({ prompt: "p" });
+ });
+ expect(onComplete.mock.calls[1][1]).toBe("resp-2");
+ });
+
+ it("reads OpenRAG output_text chunks (#1534)", async () => {
+ serveStream([{ output_text: "watsonx says hi" }]);
+ const { result } = setup();
+
+ const returned = await send(result, { prompt: "p" });
+
+ expect(returned?.content).toBe("watsonx says hi");
+ });
+
+ it("clears the streaming message and refreshes history when done", async () => {
+ serveStream([textChunk("hi")]);
+ const { result } = setup();
+
+ await act(async () => {
+ await result.current.sendMessage({ prompt: "p" });
+ });
+
+ await waitFor(() => expect(result.current.streamingMessage).toBeNull());
+ expect(result.current.isLoading).toBe(false);
+ expect(refreshConversations).toHaveBeenCalledWith(true);
+ });
+ });
+
+ describe("errors", () => {
+ it("reports a non-OK response with its status and body (#859)", async () => {
+ server.use(
+ http.post(ENDPOINT, () =>
+ HttpResponse.text("upstream exploded", { status: 502 }),
+ ),
+ );
+ const { result, onError, onComplete } = setup();
+
+ const returned = await send(result, { prompt: "p" });
+
+ expect(returned?.error).toBe(true);
+ expect(returned?.content).toContain("upstream exploded");
+ expect(onError).toHaveBeenCalledOnce();
+ // onComplete still fires so the failed turn is appended to history.
+ expect(onComplete).toHaveBeenCalledOnce();
+ expect(onComplete.mock.calls[0][0].error).toBe(true);
+ });
+
+ it("reports an empty stream as no response received", async () => {
+ serveStream([]);
+ const { result } = setup();
+
+ const returned = await send(result, { prompt: "p" });
+
+ expect(returned?.content).toBe(
+ "The server didn't return a response. Please try again.",
+ );
+ });
+
+ it("surfaces a provider error carried in the stream (#2127)", async () => {
+ serveStream([
+ textChunk("partial answer"),
+ { finish_reason: "error", error: "Invalid API key for watsonx" },
+ ]);
+ const { result } = setup();
+
+ const returned = await send(result, { prompt: "p" });
+
+ expect(returned?.error).toBe(true);
+ expect(returned?.content).toContain("Invalid API key");
+ });
+
+ it("keeps a benign partial answer above the error text (#2127)", async () => {
+ serveStream([
+ textChunk("The capital is Paris."),
+ { finish_reason: "error", error: "connection reset" },
+ ]);
+ const { result } = setup();
+
+ const returned = await send(result, { prompt: "p" });
+
+ expect(returned?.content).toContain("The capital is Paris.");
+ expect(returned?.content).toContain("connection reset");
+ });
+
+ it("does not prepend a partial that is itself a provider dump (#2127)", async () => {
+ serveStream([
+ textChunk("Error: invalid api key for provider"),
+ { finish_reason: "error", error: "Authentication failed" },
+ ]);
+ const { result } = setup();
+
+ const returned = await send(result, { prompt: "p" });
+
+ // Content starting with "Error:" trips looksLikeProviderErrorContent
+ // (chat-stream-errors.ts:107), so the thrown message IS the content. The
+ // guard being pinned here is that it is not ALSO prepended as a partial,
+ // which would show the same text twice.
+ const occurrences =
+ returned?.content?.match(/invalid api key for provider/g)?.length ?? 0;
+ expect(occurrences).toBe(1);
+ });
+
+ it("treats accumulated content that looks like a provider error as one", async () => {
+ serveStream([textChunk('{"error": {"message": "Rate limit exceeded"}}')]);
+ const { result } = setup();
+
+ const returned = await send(result, { prompt: "p" });
+
+ expect(returned?.error).toBe(true);
+ expect(returned?.content).not.toContain("{");
+ });
+
+ it("stops loading after an error", async () => {
+ server.use(
+ http.post(ENDPOINT, () => HttpResponse.text("nope", { status: 500 })),
+ );
+ const { result } = setup();
+
+ await act(async () => {
+ await result.current.sendMessage({ prompt: "p" });
+ });
+
+ expect(result.current.isLoading).toBe(false);
+ expect(result.current.streamingMessage).toBeNull();
+ });
+ });
+
+ describe("abortStream", () => {
+ it("clears streaming state immediately", async () => {
+ const { result } = setup();
+
+ act(() => {
+ result.current.abortStream();
+ });
+
+ expect(result.current.isLoading).toBe(false);
+ expect(result.current.streamingMessage).toBeNull();
+ });
+
+ // NOT TESTED HERE, ON PURPOSE: aborting a stream that is still open.
+ //
+ // It needs a handler that holds the response open, then an abort at just
+ // the right moment. Under MSW the reader's pending read() does not settle
+ // when the controller aborts, so the test hangs until the suite timeout.
+ // Making it pass would mean sleeping on wall-clock timing — precisely the
+ // flakiness this fast layer exists to avoid.
+ //
+ // Mid-stream abort is a real user action (clicking stop), so it belongs in
+ // Playwright against a real server. What is checkable here — that
+ // abortStream clears state synchronously — is covered above.
+ });
+});
diff --git a/frontend/lib/chat-stream-errors.test.ts b/frontend/lib/chat-stream-errors.test.ts
index 8b3caa832..1bf4d42f0 100644
--- a/frontend/lib/chat-stream-errors.test.ts
+++ b/frontend/lib/chat-stream-errors.test.ts
@@ -1,5 +1,5 @@
import assert from "node:assert/strict";
-import { describe, it } from "node:test";
+import { describe, it } from "vitest";
import {
dedupeConsecutiveErrorMessages,
extractStreamProviderError,
diff --git a/frontend/lib/knowledge-table-state.test.ts b/frontend/lib/knowledge-table-state.test.ts
new file mode 100644
index 000000000..1ba7c3b93
--- /dev/null
+++ b/frontend/lib/knowledge-table-state.test.ts
@@ -0,0 +1,359 @@
+import { describe, expect, it } from "vitest";
+import type { File as SearchFile } from "@/app/api/queries/useGetSearchQuery";
+import type { TaskFile } from "@/contexts/task-context";
+import {
+ buildActiveSourceOptions,
+ buildKnowledgeTableRows,
+ getKnowledgeFileAliasKeys,
+ getKnowledgeFileIdentity,
+ inferTaskFileConnectorType,
+ resolveKnowledgeRowConnectorType,
+} from "./knowledge-table-state";
+
+/**
+ * Chosen by churn: 5 of this file's 7 commits in the last year were bug fixes.
+ * The `regressions` block below pins one behaviour per shipped fix, named with
+ * its PR, so a future refactor cannot quietly reintroduce them.
+ */
+
+function searchFile(overrides: Partial<SearchFile> = {}): SearchFile {
+ return {
+ filename: "doc.pdf",
+ mimetype: "application/pdf",
+ source_url: "",
+ size: 100,
+ connector_type: "local",
+ ...overrides,
+ };
+}
+
+function taskFile(overrides: Partial<TaskFile> = {}): TaskFile {
+ return {
+ filename: "doc.pdf",
+ mimetype: "application/pdf",
+ source_url: "",
+ size: 100,
+ connector_type: "local",
+ status: "processing",
+ task_id: "t1",
+ created_at: "2026-09-08T10:00:00Z",
+ updated_at: "2026-09-08T10:00:00Z",
+ ...overrides,
+ };
+}
+
+describe("getKnowledgeFileIdentity", () => {
+ it("prefers filename, falls back to source_url, else empty", () => {
+ expect(getKnowledgeFileIdentity({ filename: "a.pdf" })).toBe("a.pdf");
+ expect(
+ getKnowledgeFileIdentity({ filename: " ", source_url: "http://x/a" }),
+ ).toBe("http://x/a");
+ expect(getKnowledgeFileIdentity({})).toBe("");
+ expect(getKnowledgeFileIdentity()).toBe("");
+ });
+});
+
+describe("getKnowledgeFileAliasKeys", () => {
+ it("pairs .txt and .md so either spelling matches", () => {
+ expect(getKnowledgeFileAliasKeys({ filename: "notes.txt" })).toContain(
+ "notes.md",
+ );
+ expect(getKnowledgeFileAliasKeys({ filename: "notes.md" })).toContain(
+ "notes.txt",
+ );
+ });
+
+ it("adds underscore variants for spaces and slashes", () => {
+ const keys = getKnowledgeFileAliasKeys({ filename: "my report/v2.txt" });
+ expect(keys).toContain("my report/v2.txt");
+ expect(keys).toContain("my_report_v2.txt");
+ // Extension pairing applies to the underscored variant too.
+ expect(keys).toContain("my_report_v2.md");
+ });
+
+ it("does not derive variants from an http url filename", () => {
+ expect(
+ getKnowledgeFileAliasKeys({ filename: "https://x.dev/a.txt" }),
+ ).toEqual(["https://x.dev/a.txt"]);
+ });
+
+ it("indexes a source_url by both full url and basename", () => {
+ const keys = getKnowledgeFileAliasKeys({
+ filename: "",
+ source_url: "s3://bucket/deep/report.txt",
+ });
+ expect(keys).toContain("s3://bucket/deep/report.txt");
+ expect(keys).toContain("report.txt");
+ expect(keys).toContain("report.md");
+ });
+
+ it("returns no keys for an empty file", () => {
+ expect(getKnowledgeFileAliasKeys({})).toEqual([]);
+ expect(getKnowledgeFileAliasKeys()).toEqual([]);
+ });
+});
+
+describe("inferTaskFileConnectorType", () => {
+ it("trusts a meaningful connector type from the task", () => {
+ expect(inferTaskFileConnectorType("a.pdf", "a.pdf", " aws_s3 ")).toBe(
+ "aws_s3",
+ );
+ });
+
+ it("ignores 'local' and blank as non-meaningful", () => {
+ expect(inferTaskFileConnectorType("a.pdf", "a.pdf", "local")).toBe("local");
+ expect(inferTaskFileConnectorType("a.pdf", "a.pdf", " ")).toBe("local");
+ });
+
+ it("classifies http paths as url, and openr.ag as openrag_docs", () => {
+ expect(inferTaskFileConnectorType("https://example.com/a", "a")).toBe(
+ "url",
+ );
+ expect(inferTaskFileConnectorType("https://openr.ag/docs/x", "x")).toBe(
+ "openrag_docs",
+ );
+ });
+
+ it("falls back to the filename when the path is not a url", () => {
+ expect(inferTaskFileConnectorType("", "https://example.com/a")).toBe("url");
+ });
+
+ it("defaults to local for bucket-style keys it cannot distinguish", () => {
+ expect(inferTaskFileConnectorType("container::blob", "blob")).toBe("local");
+ });
+});
+
+describe("resolveKnowledgeRowConnectorType", () => {
+ it("prefers the backend type for active rows", () => {
+ expect(resolveKnowledgeRowConnectorType("aws_s3", "url", "active")).toBe(
+ "aws_s3",
+ );
+ });
+
+ it("prefers the task type for non-active rows", () => {
+ expect(
+ resolveKnowledgeRowConnectorType("aws_s3", "url", "processing"),
+ ).toBe("url");
+ });
+
+ it("skips a non-meaningful backend type in favour of the task type", () => {
+ expect(
+ resolveKnowledgeRowConnectorType("local", "azure_blob", "active"),
+ ).toBe("azure_blob");
+ });
+
+ it("falls back to local when neither side offers anything", () => {
+ expect(resolveKnowledgeRowConnectorType(undefined, undefined)).toBe(
+ "local",
+ );
+ });
+
+ it("treats a missing status as active", () => {
+ expect(resolveKnowledgeRowConnectorType("aws_s3", "url")).toBe("aws_s3");
+ });
+});
+
+describe("buildKnowledgeTableRows", () => {
+ it("returns backend rows untouched when there are no task overlays", () => {
+ const rows = buildKnowledgeTableRows([searchFile()], []);
+ expect(rows).toHaveLength(1);
+ expect(rows[0].filename).toBe("doc.pdf");
+ });
+
+ it("appends task files that the index does not yet know about", () => {
+ const rows = buildKnowledgeTableRows(
+ [searchFile({ filename: "indexed.pdf" })],
+ [taskFile({ filename: "brand-new.pdf" })],
+ );
+ expect(rows.map((r) => r.filename)).toEqual([
+ "indexed.pdf",
+ "brand-new.pdf",
+ ]);
+ });
+
+ it("labels a task file with no name or url as Untitled source", () => {
+ const rows = buildKnowledgeTableRows(
+ [],
+ [taskFile({ filename: "", source_url: "" })],
+ );
+ expect(rows[0].filename).toBe("Untitled source");
+ });
+
+ it("leaves openrag_docs backend rows entirely alone", () => {
+ const rows = buildKnowledgeTableRows(
+ [searchFile({ connector_type: "openrag_docs", status: "active" })],
+ [taskFile({ status: "failed", error: "boom" })],
+ );
+ expect(rows[0].status).toBe("active");
+ expect(rows[0].error).toBeUndefined();
+ });
+
+ describe("regressions", () => {
+ it("does not duplicate a file that the index already lists (#1892)", () => {
+ // The overlay and the indexed row are the same document; only one row.
+ const rows = buildKnowledgeTableRows(
+ [searchFile({ filename: "report.pdf" })],
+ [taskFile({ filename: "report.pdf" })],
+ );
+ expect(rows).toHaveLength(1);
+ });
+
+ it("dedupes across .txt/.md and underscore aliases (#1892)", () => {
+ const rows = buildKnowledgeTableRows(
+ [searchFile({ filename: "my notes.txt" })],
+ [taskFile({ filename: "my_notes.md" })],
+ );
+ expect(rows).toHaveLength(1);
+ });
+
+ it("keeps the connector icon source for url rows (#1887)", () => {
+ const rows = buildKnowledgeTableRows(
+ [searchFile({ filename: "page", connector_type: "" })],
+ [taskFile({ filename: "page", connector_type: "url" })],
+ );
+ expect(rows[0].connector_type).toBe("url");
+ });
+
+ it("keeps a meaningful backend connector type over the overlay (#1887)", () => {
+ const rows = buildKnowledgeTableRows(
+ [searchFile({ filename: "obj", connector_type: "azure_blob" })],
+ [taskFile({ filename: "obj", connector_type: "url" })],
+ );
+ expect(rows[0].connector_type).toBe("azure_blob");
+ });
+
+ it("merges embedding metadata from the overlay onto the row (#1576)", () => {
+ const rows = buildKnowledgeTableRows(
+ [searchFile({ filename: "a.pdf" })],
+ [
+ taskFile({
+ filename: "a.pdf",
+ embedding_model: "granite-embed",
+ embedding_dimensions: 768,
+ }),
+ ],
+ );
+ expect(rows[0].embedding_model).toBe("granite-embed");
+ expect(rows[0].embedding_dimensions).toBe(768);
+ });
+
+ it("does not let an overlay erase embedding metadata it lacks (#1576)", () => {
+ const rows = buildKnowledgeTableRows(
+ [
+ searchFile({
+ filename: "a.pdf",
+ embedding_model: "backend-model",
+ embedding_dimensions: 1024,
+ }),
+ ],
+ [taskFile({ filename: "a.pdf" })],
+ );
+ expect(rows[0].embedding_model).toBe("backend-model");
+ expect(rows[0].embedding_dimensions).toBe(1024);
+ });
+
+ it("hides unindexed processing rows while a filter is active (#1282)", () => {
+ const rows = buildKnowledgeTableRows(
+ [searchFile({ filename: "indexed.pdf" })],
+ [taskFile({ filename: "still-processing.pdf" })],
+ true,
+ );
+ expect(rows.map((r) => r.filename)).toEqual(["indexed.pdf"]);
+ });
+
+ it("still overlays status onto matched rows when filtered (#1282)", () => {
+ const rows = buildKnowledgeTableRows(
+ [searchFile({ filename: "a.pdf", status: "active" })],
+ [taskFile({ filename: "a.pdf", status: "processing" })],
+ true,
+ );
+ expect(rows).toHaveLength(1);
+ expect(rows[0].status).toBe("processing");
+ });
+
+ it("excludes the OpenRAG docs refresh pseudo-task (#1282)", () => {
+ const rows = buildKnowledgeTableRows(
+ [],
+ [
+ taskFile({ filename: "OpenRAG docs refresh" }),
+ taskFile({ filename: "d", source_url: "https://openr.ag/docs" }),
+ taskFile({ filename: "e", connector_type: "openrag_docs" }),
+ ],
+ );
+ expect(rows).toEqual([]);
+ });
+
+ it("promotes processing and failed status onto the indexed row", () => {
+ const processing = buildKnowledgeTableRows(
+ [searchFile({ filename: "a.pdf", status: "active" })],
+ [taskFile({ filename: "a.pdf", status: "processing" })],
+ );
+ expect(processing[0].status).toBe("processing");
+
+ const failed = buildKnowledgeTableRows(
+ [searchFile({ filename: "a.pdf", status: "active" })],
+ [taskFile({ filename: "a.pdf", status: "failed", error: "nope" })],
+ );
+ expect(failed[0].status).toBe("failed");
+ expect(failed[0].error).toBe("nope");
+ });
+
+ it("keeps the backend status when the overlay is merely active", () => {
+ const rows = buildKnowledgeTableRows(
+ [searchFile({ filename: "a.pdf", status: "unavailable" })],
+ [taskFile({ filename: "a.pdf", status: "active" })],
+ );
+ expect(rows[0].status).toBe("unavailable");
+ });
+
+ it("prefers the highest-priority overlay when several share a key", () => {
+ const rows = buildKnowledgeTableRows(
+ [searchFile({ filename: "a.pdf", status: "active" })],
+ [
+ taskFile({ filename: "a.pdf", status: "active" }),
+ taskFile({ filename: "a.pdf", status: "processing" }),
+ ],
+ );
+ expect(rows[0].status).toBe("processing");
+ });
+ });
+});
+
+describe("buildActiveSourceOptions", () => {
+ // acc4d1c2b — "align source filter options with active table rows".
+ it("lists only active rows, deduped and sorted (acc4d1c2b)", () => {
+ const options = buildActiveSourceOptions([
+ searchFile({ filename: "zebra.pdf", status: "active" }),
+ searchFile({ filename: "apple.pdf", status: "active" }),
+ searchFile({ filename: "apple.pdf", status: "active" }),
+ searchFile({ filename: "hidden.pdf", status: "processing" }),
+ searchFile({ filename: "gone.pdf", status: "failed" }),
+ ]);
+
+ expect(options.map((o) => o.value)).toEqual(["apple.pdf", "zebra.pdf"]);
+ });
+
+ it("treats a missing status as active", () => {
+ const options = buildActiveSourceOptions([
+ searchFile({ filename: "a.pdf", status: undefined }),
+ ]);
+ expect(options).toHaveLength(1);
+ });
+
+ it("falls back to source_url when there is no filename", () => {
+ const options = buildActiveSourceOptions([
+ searchFile({
+ filename: "",
+ source_url: "https://x.dev/a",
+ status: "active",
+ }),
+ ]);
+ expect(options[0].value).toBe("https://x.dev/a");
+ });
+
+ it("skips rows with neither filename nor source_url", () => {
+ expect(
+ buildActiveSourceOptions([searchFile({ filename: "", source_url: "" })]),
+ ).toEqual([]);
+ });
+});
diff --git a/frontend/lib/metrics.test.ts b/frontend/lib/metrics.test.ts
index f93a251b0..d1fe785f9 100644
--- a/frontend/lib/metrics.test.ts
+++ b/frontend/lib/metrics.test.ts
@@ -1,5 +1,5 @@
import assert from "node:assert/strict";
-import { describe, it } from "node:test";
+import { describe, it } from "vitest";
import { normalizePath, normalizeRoute } from "./metrics";
describe("normalizeRoute", () => {
diff --git a/frontend/lib/navigation-events.test.ts b/frontend/lib/navigation-events.test.ts
index 89997f318..9d45603a1 100644
--- a/frontend/lib/navigation-events.test.ts
+++ b/frontend/lib/navigation-events.test.ts
@@ -1,5 +1,5 @@
import assert from "node:assert/strict";
-import { describe, it } from "node:test";
+import { describe, it } from "vitest";
// Node's built-in TypeScript runner requires the extension; tsc resolves the same source.
// @ts-expect-error TS5097
import { getInterceptedNavigationHref } from "./navigation-events.ts";
diff --git a/frontend/lib/task-error-display.test.ts b/frontend/lib/task-error-display.test.ts
index 03d9825dd..163136dce 100644
--- a/frontend/lib/task-error-display.test.ts
+++ b/frontend/lib/task-error-display.test.ts
@@ -1,11 +1,37 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import type { TaskFileEntry } from "@/app/api/queries/useGetTasksQuery";
-import { resolveTaskFileError } from "@/lib/task-error-display";
+import { describe, expect, it } from "vitest";
+import type {
+ TaskFailurePhase,
+ TaskFileEntry,
+} from "@/app/api/queries/useGetTasksQuery";
+import {
+ analyzeTaskFileIngestionFailure,
+ buildRowStatusLabel,
+ FILE_ERROR_MAX_LINE_LENGTH,
+ formatApiComponent,
+ getTaskFailureToastDescription,
+ normalizeFailurePhase,
+ resolveTaskFileError,
+} from "./task-error-display";
+
+/**
+ * Chosen by churn: 3 of this file's 9 commits in the last year were bug fixes
+ * (#2152 "provide real error for onboarding apiKey setup and settings", #2127
+ * "surface provider errors in chat instead of generic connection failures",
+ * #1771 "cancel case not retryable"), plus #1769 which added skipped-task
+ * warnings.
+ *
+ * `formatProviderErrorMessage` is deliberately NOT stubbed — the #2127 fix is
+ * precisely that these messages get run through it, so the real function is
+ * part of what is under test.
+ */
+
+function entry(overrides: Partial<TaskFileEntry> = {}): TaskFileEntry {
+ return { status: "failed", ...overrides };
+}
// A real _update_by_query 409 as opensearch-py renders it: the whole response
// body becomes the exception message, because that response carries no
-// top-level "error" key for the client to use instead.
+// top-level "error" key for the client to use instead (#2349).
const OPENSEARCH_CONFLICT_ERROR =
'ConflictError(409, \'{"took":2719,"timed_out":false,"total":300,' +
'"updated":19,"version_conflicts":1,"failures":[{"index":"documents",' +
@@ -15,66 +41,318 @@ const BACKEND_CLASSIFIED_MESSAGE =
"The search index was busy and this change conflicted with another " +
"update. Nothing is wrong with the file — retry ingestion.";
+describe("formatApiComponent", () => {
+ it("maps every known component to its display label", () => {
+ expect(formatApiComponent("docling")).toBe("Docling");
+ expect(formatApiComponent("openrag")).toBe("OpenRAG");
+ expect(formatApiComponent("langflow")).toBe("Langflow");
+ expect(formatApiComponent("opensearch")).toBe("OpenSearch");
+ });
+
+ it("returns undefined when no component is given", () => {
+ expect(formatApiComponent(undefined)).toBeUndefined();
+ });
+});
+
+describe("normalizeFailurePhase", () => {
+ it("accepts every known phase", () => {
+ for (const phase of [
+ "parsing",
+ "chunking",
+ "embedding",
+ "indexing",
+ "file_validation",
+ "cancelled",
+ "unknown",
+ ]) {
+ expect(normalizeFailurePhase(phase)).toBe(phase);
+ }
+ });
+
+ it("rejects unknown or missing phases", () => {
+ expect(normalizeFailurePhase("teleporting")).toBeUndefined();
+ expect(normalizeFailurePhase("")).toBeUndefined();
+ expect(normalizeFailurePhase(undefined)).toBeUndefined();
+ });
+});
+
+describe("buildRowStatusLabel", () => {
+ it("uses bespoke wording for cancelled, validation and unknown (#1771)", () => {
+ expect(buildRowStatusLabel("cancelled")).toBe("Cancelled");
+ expect(buildRowStatusLabel("file_validation")).toBe(
+ "File validation issue",
+ );
+ expect(buildRowStatusLabel("unknown")).toBe("Failed");
+ });
+
+ it("suffixes pipeline phases with 'issue'", () => {
+ expect(buildRowStatusLabel("parsing")).toBe("Parsing issue");
+ expect(buildRowStatusLabel("embedding")).toBe("Embedding issue");
+ });
+});
+
describe("resolveTaskFileError", () => {
- it("prefers the backend's user_facing_message over the raw error", () => {
+ it("prefers a result warning over everything else (#1769)", () => {
+ const message = resolveTaskFileError(
+ entry({
+ result: { warning: "Skipped: unsupported page" },
+ user_facing_message: "ignored",
+ error: "ignored too",
+ }),
+ "task level ignored",
+ );
+
+ expect(message).toContain("unsupported page");
+ });
+
+ it("falls back to user_facing_message, then error, then task error (#2152)", () => {
+ expect(
+ resolveTaskFileError(
+ entry({ user_facing_message: "Invalid API key", error: "raw" }),
+ "task",
+ ),
+ ).toBe("Invalid API key");
+
+ expect(resolveTaskFileError(entry({ error: "raw failure" }), "task")).toBe(
+ "raw failure",
+ );
+
+ expect(resolveTaskFileError(entry({}), "task level boom")).toBe(
+ "task level boom",
+ );
+ });
+
+ it("skips blank candidates rather than returning empty text", () => {
+ expect(
+ resolveTaskFileError(
+ entry({
+ result: { warning: " " },
+ user_facing_message: " ",
+ error: " ",
+ }),
+ " ",
+ ),
+ ).toBe("Unknown error");
+ });
+
+ it("ignores a result object without a string warning", () => {
+ expect(
+ resolveTaskFileError(entry({ result: { warning: 42 }, error: "real" })),
+ ).toBe("real");
+ });
+
+ it("returns Unknown error when nothing is available", () => {
+ expect(resolveTaskFileError(entry({}))).toBe("Unknown error");
+ });
+
+ it("runs messages through provider-error formatting (#2127)", () => {
+ // A raw provider JSON blob must not reach the UI verbatim.
+ const message = resolveTaskFileError(
+ entry({ error: '{"message": "Rate limit exceeded"}' }),
+ );
+
+ expect(message).not.toContain("{");
+ expect(message).toContain("Rate limit exceeded");
+ });
+
+ it("prefers the backend's classified message over a raw payload (#2349)", () => {
// This precedence is what makes the backend classifier work at all. If these
// checks are ever reordered, a classified OpenSearch failure would fall back
// to the raw payload and be mangled again.
- const entry: TaskFileEntry = {
- status: "failed",
- error: OPENSEARCH_CONFLICT_ERROR,
- user_facing_message: BACKEND_CLASSIFIED_MESSAGE,
- };
-
- assert.equal(resolveTaskFileError(entry), BACKEND_CLASSIFIED_MESSAGE);
+ expect(
+ resolveTaskFileError(
+ entry({
+ error: OPENSEARCH_CONFLICT_ERROR,
+ user_facing_message: BACKEND_CLASSIFIED_MESSAGE,
+ }),
+ ),
+ ).toBe(BACKEND_CLASSIFIED_MESSAGE);
});
- it("passes a clean sentence through the provider parser unchanged", () => {
+ it("passes a clean sentence through the provider parser unchanged (#2349)", () => {
// The message contains no JSON, so the chat provider-error parser must not
// rewrite or truncate it.
- const entry: TaskFileEntry = {
- status: "failed",
- user_facing_message: BACKEND_CLASSIFIED_MESSAGE,
- };
-
- assert.equal(resolveTaskFileError(entry), BACKEND_CLASSIFIED_MESSAGE);
+ expect(
+ resolveTaskFileError(
+ entry({ user_facing_message: BACKEND_CLASSIFIED_MESSAGE }),
+ ),
+ ).toBe(BACKEND_CLASSIFIED_MESSAGE);
});
- it("keeps the whole raw error when the backend did not classify it", () => {
+ it("keeps the whole raw error when the backend did not classify it (#2349)", () => {
// Regression guard: this used to collapse to the 20-character fragment
// "ConflictError(409, '", discarding the failures[] array that names the
// index, shard and document — the only way to diagnose the failure.
- const entry: TaskFileEntry = {
- status: "failed",
- error: OPENSEARCH_CONFLICT_ERROR,
- };
-
- const resolved = resolveTaskFileError(entry);
- assert.equal(resolved, OPENSEARCH_CONFLICT_ERROR);
- assert.ok(resolved.includes("version_conflict_engine_exception"));
- });
-
- it("still prefers a result warning over everything else", () => {
- const entry: TaskFileEntry = {
- status: "skipped",
- error: OPENSEARCH_CONFLICT_ERROR,
- user_facing_message: BACKEND_CLASSIFIED_MESSAGE,
- result: {
- warning: "File no longer exists at source; removed from index.",
+ const resolved = resolveTaskFileError(
+ entry({ error: OPENSEARCH_CONFLICT_ERROR }),
+ );
+
+ expect(resolved).toBe(OPENSEARCH_CONFLICT_ERROR);
+ expect(resolved).toContain("version_conflict_engine_exception");
+ });
+});
+
+describe("getTaskFailureToastDescription", () => {
+ it("uses the first meaningful failed-file message", () => {
+ const description = getTaskFailureToastDescription({
+ files: {
+ "ok.pdf": entry({ status: "completed" }),
+ "bad.pdf": entry({ status: "failed", error: "parser died" }),
+ },
+ });
+
+ expect(description).toBe("parser died");
+ });
+
+ it("treats status 'error' as failed too", () => {
+ expect(
+ getTaskFailureToastDescription({
+ files: { "a.pdf": entry({ status: "error", error: "boom" }) },
+ }),
+ ).toBe("boom");
+ });
+
+ it("skips files whose message resolves to Unknown error", () => {
+ const description = getTaskFailureToastDescription({
+ files: {
+ "a.pdf": entry({ status: "failed" }),
+ "b.pdf": entry({ status: "failed", error: "real reason" }),
},
- };
+ });
+
+ expect(description).toBe("real reason");
+ });
+
+ it("falls back to the task-level error", () => {
+ expect(
+ getTaskFailureToastDescription({ error: " task blew up ", files: {} }),
+ ).toBe("task blew up");
+ });
+
+ it("falls back to a failed-file count, pluralized", () => {
+ expect(getTaskFailureToastDescription({ failed_files: 1 })).toBe(
+ "1 file failed",
+ );
+ expect(getTaskFailureToastDescription({ failed_files: 3 })).toBe(
+ "3 files failed",
+ );
+ });
- assert.equal(
- resolveTaskFileError(entry),
- "File no longer exists at source; removed from index.",
+ it("derives the count from files when failed_files is absent", () => {
+ expect(
+ getTaskFailureToastDescription({
+ files: {
+ "a.pdf": entry({ status: "failed" }),
+ "b.pdf": entry({ status: "error" }),
+ "c.pdf": entry({ status: "completed" }),
+ },
+ }),
+ ).toBe("2 files failed");
+ });
+
+ it("returns Unknown error for a task with nothing to report", () => {
+ expect(getTaskFailureToastDescription({})).toBe("Unknown error");
+ expect(getTaskFailureToastDescription({ error: null, files: null })).toBe(
+ "Unknown error",
+ );
+ });
+});
+
+describe("analyzeTaskFileIngestionFailure", () => {
+ it("marks earlier pipeline steps completed and the failing one failed", () => {
+ const analysis = analyzeTaskFileIngestionFailure(
+ entry({ failure_phase: "embedding", error: "vector store down" }),
);
+
+ expect(analysis.failedStep).toBe("embedding");
+ expect(analysis.pipelineSteps).toEqual([
+ { id: "parsing", label: "Parsing", status: "completed" },
+ { id: "chunking", label: "Chunking", status: "completed" },
+ { id: "embedding", label: "Embedding", status: "failed" },
+ ]);
+ expect(analysis.rowStatusLabel).toBe("Embedding issue");
+ expect(analysis.failureSummary).toBe("Failed at embedding");
+ });
+
+ it("shows only the failing step for parsing", () => {
+ const analysis = analyzeTaskFileIngestionFailure(
+ entry({ failure_phase: "parsing" }),
+ );
+
+ expect(analysis.pipelineSteps).toEqual([
+ { id: "parsing", label: "Parsing", status: "failed" },
+ ]);
});
- it("falls back to the task-level error, then to Unknown error", () => {
- assert.equal(
- resolveTaskFileError({ status: "failed" }, "task blew up"),
- "task blew up",
+ it("collapses cancelled to a single step with no pipeline (#1771)", () => {
+ const analysis = analyzeTaskFileIngestionFailure(
+ entry({ failure_phase: "cancelled" }),
);
- assert.equal(resolveTaskFileError({ status: "failed" }), "Unknown error");
+
+ expect(analysis.pipelineSteps).toEqual([
+ { id: "cancelled", label: "Cancelled", status: "failed" },
+ ]);
+ expect(analysis.rowStatusLabel).toBe("Cancelled");
+ expect(analysis.failureSummary).toBe("Cancelled");
+ });
+
+ it("collapses file_validation to a single step", () => {
+ const analysis = analyzeTaskFileIngestionFailure(
+ entry({ failure_phase: "file_validation" }),
+ );
+
+ expect(analysis.pipelineSteps).toEqual([
+ { id: "file_validation", label: "File validation", status: "failed" },
+ ]);
+ });
+
+ it("defaults an unrecognized phase to unknown", () => {
+ const analysis = analyzeTaskFileIngestionFailure(
+ // Cast deliberately: TaskFailurePhase is a closed union, but the backend
+ // can send a phase this frontend build has never heard of. That is the
+ // case normalizeFailurePhase exists to absorb, so it must be tested.
+ entry({ failure_phase: "teleporting" as TaskFailurePhase }),
+ );
+
+ expect(analysis.failedStep).toBe("unknown");
+ expect(analysis.pipelineSteps).toEqual([
+ { id: "unknown", label: "Ingestion", status: "failed" },
+ ]);
+ expect(analysis.rowStatusLabel).toBe("Failed");
+ });
+
+ it("tags the failing component when the API reports one", () => {
+ const analysis = analyzeTaskFileIngestionFailure(
+ entry({ failure_phase: "indexing", component: "opensearch" }),
+ );
+
+ expect(analysis.componentCause).toBe("OpenSearch");
+ expect(analysis.componentTags).toEqual(["OpenSearch"]);
+ });
+
+ it("leaves component tags empty when none is reported", () => {
+ const analysis = analyzeTaskFileIngestionFailure(entry({}));
+
+ expect(analysis.componentCause).toBeUndefined();
+ expect(analysis.componentTags).toEqual([]);
+ });
+
+ it("truncates a long summary line with an ellipsis", () => {
+ const analysis = analyzeTaskFileIngestionFailure(
+ entry({ error: "x".repeat(200) }),
+ );
+
+ expect(analysis.summaryLine).toHaveLength(FILE_ERROR_MAX_LINE_LENGTH);
+ expect(analysis.summaryLine.endsWith("…")).toBe(true);
+ // The full message stays available for the expanded view.
+ expect(analysis.resolvedError).toHaveLength(200);
+ });
+
+ it("leaves a short summary line untouched", () => {
+ const analysis = analyzeTaskFileIngestionFailure(
+ entry({ error: "short message" }),
+ );
+
+ expect(analysis.summaryLine).toBe("short message");
});
});
diff --git a/frontend/lib/upload-utils.test.ts b/frontend/lib/upload-utils.test.ts
new file mode 100644
index 000000000..db4e5a05e
--- /dev/null
+++ b/frontend/lib/upload-utils.test.ts
@@ -0,0 +1,414 @@
+import { HttpResponse, http } from "msw";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import {
+ field,
+ type ParsedMultipart,
+ parseMultipart,
+} from "@/test-utils/msw/multipart";
+import { server } from "@/test-utils/msw/server";
+import {
+ duplicateCheck,
+ uploadFile,
+ uploadFileForContext,
+ uploadFiles,
+} from "./upload-utils";
+
+/**
+ * Chosen by churn: 5 of this file's 15 commits in the last year were bug fixes
+ * ("Ingesting folder doesn't seem to work", "fixed onboarding upload to be
+ * linked to the task id", "duplicate filter check", plus the CustomEvent →
+ * callbacks refactor in #1578 and the context-upload handler in #1624).
+ *
+ * Everything here goes over real `fetch` with MSW answering, so the request
+ * URLs, methods, and FormData bodies are under test alongside the parsing.
+ */
+
+const UPLOAD_INGEST = "/api/router/upload_ingest";
+const UPLOAD_CONTEXT = "/api/upload_context";
+const CHECK_FILENAME = "/api/documents/check-filename";
+
+function txt(name = "a.txt", body = "hello") {
+ return new File([body], name, { type: "text/plain" });
+}
+
+/**
+ * Captures the multipart body of the next POST so tests can assert what was
+ * sent. Uses parseMultipart rather than `request.formData()` — see the note in
+ * test-utils/msw/multipart.ts for why the latter cannot work under jsdom.
+ */
+function captureForm(path: string, respond: () => Response) {
+ const seen: { form?: ParsedMultipart } = {};
+ server.use(
+ http.post(path, async ({ request }) => {
+ seen.form = parseMultipart(await request.text());
+ return respond();
+ }),
+ );
+ return seen;
+}
+
+beforeEach(() => {
+ vi.restoreAllMocks();
+});
+
+describe("uploadFileForContext", () => {
+ it("returns a task result for 201 and sends the endpoint", async () => {
+ const seen = captureForm(UPLOAD_CONTEXT, () =>
+ HttpResponse.json({ task_id: "t-9" }, { status: 201 }),
+ );
+
+ const result = await uploadFileForContext(txt(), "/chat", null);
+
+ expect(result).toEqual({ type: "task", taskId: "t-9" });
+ expect(field(seen.form!, "endpoint")).toBe("/chat");
+ expect(field(seen.form!, "previous_response_id")).toBeUndefined();
+ });
+
+ it("forwards previous_response_id only when provided", async () => {
+ const seen = captureForm(UPLOAD_CONTEXT, () =>
+ HttpResponse.json({ task_id: "t-1" }, { status: 201 }),
+ );
+
+ await uploadFileForContext(txt(), "/chat", "resp-7");
+
+ expect(field(seen.form!, "previous_response_id")).toBe("resp-7");
+ });
+
+ it("accepts `id` as an alias for task_id on 201", async () => {
+ server.use(
+ http.post(UPLOAD_CONTEXT, () =>
+ HttpResponse.json({ id: "t-alias" }, { status: 201 }),
+ ),
+ );
+
+ await expect(uploadFileForContext(txt(), "/chat", null)).resolves.toEqual({
+ type: "task",
+ taskId: "t-alias",
+ });
+ });
+
+ it("throws when a 201 carries no task id", async () => {
+ server.use(
+ http.post(UPLOAD_CONTEXT, () => HttpResponse.json({}, { status: 201 })),
+ );
+
+ await expect(uploadFileForContext(txt(), "/chat", null)).rejects.toThrow(
+ "No task ID received from server",
+ );
+ });
+
+ it("returns a direct result for 200", async () => {
+ server.use(
+ http.post(UPLOAD_CONTEXT, () =>
+ HttpResponse.json({ filename: "a.txt", response_id: "r-1" }),
+ ),
+ );
+
+ await expect(uploadFileForContext(txt(), "/chat", null)).resolves.toEqual({
+ type: "direct",
+ filename: "a.txt",
+ responseId: "r-1",
+ });
+ });
+
+ it("rejects a 200 missing filename or response_id", async () => {
+ server.use(
+ http.post(UPLOAD_CONTEXT, () => HttpResponse.json({ response_id: "r" })),
+ );
+ await expect(uploadFileForContext(txt(), "/chat", null)).rejects.toThrow(
+ "no filename",
+ );
+
+ server.use(
+ http.post(UPLOAD_CONTEXT, () => HttpResponse.json({ filename: "a.txt" })),
+ );
+ await expect(uploadFileForContext(txt(), "/chat", null)).rejects.toThrow(
+ "no response_id",
+ );
+ });
+
+ it("surfaces the server's error body, falling back to a default", async () => {
+ server.use(
+ http.post(UPLOAD_CONTEXT, () =>
+ HttpResponse.text("disk full", { status: 500 }),
+ ),
+ );
+ await expect(uploadFileForContext(txt(), "/chat", null)).rejects.toThrow(
+ "disk full",
+ );
+
+ server.use(
+ http.post(UPLOAD_CONTEXT, () => HttpResponse.text("", { status: 500 })),
+ );
+ await expect(uploadFileForContext(txt(), "/chat", null)).rejects.toThrow(
+ "Failed to process document",
+ );
+ });
+});
+
+describe("duplicateCheck", () => {
+ it("encodes the filename into the query string", async () => {
+ let url = "";
+ server.use(
+ http.get(CHECK_FILENAME, ({ request }) => {
+ url = request.url;
+ return HttpResponse.json({ exists: true });
+ }),
+ );
+
+ await expect(duplicateCheck(txt("my report&v2.pdf"))).resolves.toEqual({
+ exists: true,
+ });
+ // encodeURIComponent, so a space is %20 (not the form-encoded "+").
+ expect(url).toContain("filename=my%20report%26v2.pdf");
+ });
+
+ it("throws with the server body when the check fails", async () => {
+ server.use(
+ http.get(CHECK_FILENAME, () =>
+ HttpResponse.text("nope", { status: 500 }),
+ ),
+ );
+
+ await expect(duplicateCheck(txt())).rejects.toThrow("nope");
+ });
+});
+
+describe("uploadFiles", () => {
+ it("posts every file in one request and returns the task id", async () => {
+ const seen = captureForm(UPLOAD_INGEST, () =>
+ HttpResponse.json({ task_id: "t-5", file_count: 3 }),
+ );
+
+ const result = await uploadFiles([
+ txt("a.txt"),
+ txt("b.txt"),
+ txt("c.txt"),
+ ]);
+
+ // Regression: "Ingesting folder doesn't seem to work" — every file must go.
+ expect(seen.form?.fileCount).toBe(3);
+ expect(result).toEqual({ taskId: "t-5", fileCount: 3, previewMode: false });
+ });
+
+ it("defaults fileCount to the number of files sent", async () => {
+ server.use(
+ http.post(UPLOAD_INGEST, () => HttpResponse.json({ task_id: "t" })),
+ );
+
+ const result = await uploadFiles([txt("a.txt"), txt("b.txt")]);
+
+ expect(result.fileCount).toBe(2);
+ });
+
+ it("sends replace_duplicates and omits preview unless requested", async () => {
+ const seen = captureForm(UPLOAD_INGEST, () =>
+ HttpResponse.json({ task_id: "t" }),
+ );
+
+ await uploadFiles([txt()], true);
+
+ expect(field(seen.form!, "replace_duplicates")).toBe("true");
+ expect(field(seen.form!, "preview")).toBeUndefined();
+ });
+
+ it("sends preview and reflects preview_mode back", async () => {
+ const seen = captureForm(UPLOAD_INGEST, () =>
+ HttpResponse.json({ task_id: "t", preview_mode: true }),
+ );
+
+ const result = await uploadFiles([txt()], false, true);
+
+ expect(field(seen.form!, "preview")).toBe("true");
+ expect(result.previewMode).toBe(true);
+ });
+
+ it("throws the server error message on a failed upload", async () => {
+ server.use(
+ http.post(UPLOAD_INGEST, () =>
+ HttpResponse.json({ error: "too big" }, { status: 413 }),
+ ),
+ );
+
+ await expect(uploadFiles([txt()])).rejects.toThrow("too big");
+ });
+
+ it("throws when the response body is not JSON", async () => {
+ server.use(
+ http.post(UPLOAD_INGEST, () => HttpResponse.text("<html>502</html>")),
+ );
+
+ await expect(uploadFiles([txt()])).rejects.toThrow(
+ "unable to parse server response",
+ );
+ });
+
+ it("throws when a successful response carries no task id", async () => {
+ server.use(http.post(UPLOAD_INGEST, () => HttpResponse.json({})));
+
+ await expect(uploadFiles([txt()])).rejects.toThrow("no task ID returned");
+ });
+});
+
+describe("uploadFile", () => {
+ it("reads id and path from the nested upload object", async () => {
+ server.use(
+ http.post(UPLOAD_INGEST, () =>
+ HttpResponse.json({ upload: { id: "f-1", path: "/data/a.txt" } }),
+ ),
+ );
+
+ const result = await uploadFile(txt());
+
+ expect(result.fileId).toBe("f-1");
+ expect(result.filePath).toBe("/data/a.txt");
+ expect(result.unified).toBe(true);
+ });
+
+ it("falls back through id then task_id for the file id", async () => {
+ server.use(
+ http.post(UPLOAD_INGEST, () => HttpResponse.json({ id: "f-2" })),
+ );
+ await expect(uploadFile(txt())).resolves.toMatchObject({ fileId: "f-2" });
+
+ server.use(
+ http.post(UPLOAD_INGEST, () => HttpResponse.json({ task_id: "t-3" })),
+ );
+ // Regression: onboarding upload had to stay linked to the task id.
+ await expect(uploadFile(txt())).resolves.toMatchObject({
+ fileId: "t-3",
+ taskId: "t-3",
+ });
+ });
+
+ it("defaults filePath to 'uploaded' when the server sends none", async () => {
+ server.use(http.post(UPLOAD_INGEST, () => HttpResponse.json({ id: "f" })));
+
+ await expect(uploadFile(txt())).resolves.toMatchObject({
+ filePath: "uploaded",
+ });
+ });
+
+ it("passes create_filter through and echoes the server's decision", async () => {
+ const seen = captureForm(UPLOAD_INGEST, () =>
+ HttpResponse.json({ id: "f", create_filter: true, filename: "a.txt" }),
+ );
+
+ const result = await uploadFile(txt(), false, true);
+
+ expect(field(seen.form!, "create_filter")).toBe("true");
+ expect(result.createFilter).toBe(true);
+ expect(result.filename).toBe("a.txt");
+ });
+
+ it("accepts a COMPLETED or SUCCESS ingestion status", async () => {
+ for (const status of ["COMPLETED", "SUCCESS"]) {
+ server.use(
+ http.post(UPLOAD_INGEST, () =>
+ HttpResponse.json({ id: "f", ingestion: { status } }),
+ ),
+ );
+ await expect(uploadFile(txt())).resolves.toMatchObject({ fileId: "f" });
+ }
+ });
+
+ it("throws when the ingestion pipeline reports another status", async () => {
+ server.use(
+ http.post(UPLOAD_INGEST, () =>
+ HttpResponse.json({
+ id: "f",
+ ingestion: { status: "FAILED", error: "parser died" },
+ }),
+ ),
+ );
+
+ await expect(uploadFile(txt())).rejects.toThrow(
+ /Ingestion failed: parser died/,
+ );
+ });
+
+ it("ignores an ingestion object with no status field", async () => {
+ server.use(
+ http.post(UPLOAD_INGEST, () =>
+ HttpResponse.json({ id: "f", ingestion: { note: "queued" } }),
+ ),
+ );
+
+ await expect(uploadFile(txt())).resolves.toMatchObject({ fileId: "f" });
+ });
+
+ it("throws when no file id comes back", async () => {
+ server.use(http.post(UPLOAD_INGEST, () => HttpResponse.json({})));
+
+ await expect(uploadFile(txt())).rejects.toThrow("no file id returned");
+ });
+
+ describe("callbacks (#1578, replacing CustomEvents)", () => {
+ it("calls onComplete after a successful upload", async () => {
+ server.use(
+ http.post(UPLOAD_INGEST, () => HttpResponse.json({ id: "f" })),
+ );
+ const onComplete = vi.fn();
+ const onError = vi.fn();
+
+ await uploadFile(txt(), false, false, { onComplete, onError });
+
+ expect(onComplete).toHaveBeenCalledOnce();
+ expect(onError).not.toHaveBeenCalled();
+ });
+
+ it("calls onError with the filename and message, then still onComplete", async () => {
+ server.use(
+ http.post(UPLOAD_INGEST, () =>
+ HttpResponse.json({ error: "boom" }, { status: 500 }),
+ ),
+ );
+ const onComplete = vi.fn();
+ const onError = vi.fn();
+
+ await expect(
+ uploadFile(txt("bad.txt"), false, false, { onComplete, onError }),
+ ).rejects.toThrow("boom");
+
+ expect(onError).toHaveBeenCalledWith("bad.txt", "boom");
+ // `finally` must still run — the upload UI unblocks on this.
+ expect(onComplete).toHaveBeenCalledOnce();
+ });
+
+ it("does not let a throwing onError mask the original failure", async () => {
+ server.use(
+ http.post(UPLOAD_INGEST, () =>
+ HttpResponse.json({ error: "original" }, { status: 500 }),
+ ),
+ );
+ vi.spyOn(console, "warn").mockImplementation(() => {});
+ const onComplete = vi.fn();
+
+ await expect(
+ uploadFile(txt(), false, false, {
+ onComplete,
+ onError: () => {
+ throw new Error("callback exploded");
+ },
+ }),
+ ).rejects.toThrow("original");
+
+ expect(onComplete).toHaveBeenCalledOnce();
+ });
+
+ it("does not let a throwing onComplete mask a successful result", async () => {
+ server.use(
+ http.post(UPLOAD_INGEST, () => HttpResponse.json({ id: "f" })),
+ );
+ vi.spyOn(console, "warn").mockImplementation(() => {});
+
+ await expect(
+ uploadFile(txt(), false, false, {
+ onComplete: () => {
+ throw new Error("callback exploded");
+ },
+ }),
+ ).resolves.toMatchObject({ fileId: "f" });
+ });
+ });
+});
diff --git a/frontend/package-lock.json b/frontend/package-lock.json
index b580374d2..4ef681806 100644
--- a/frontend/package-lock.json
+++ b/frontend/package-lock.json
@@ -63,22 +63,37 @@
"@emnapi/runtime": "^1.11.1",
"@emnapi/wasi-threads": "^1.2.2",
"@playwright/test": "^1.61.1",
+ "@testing-library/jest-dom": "^7.0.1",
+ "@testing-library/react": "^16.3.3",
+ "@testing-library/user-event": "^14.6.7",
"@types/node": "^26.0.1",
"@types/react": "^19.2.17",
"@types/react-dom": "^19.2.3",
"@types/react-syntax-highlighter": "^15.5.13",
+ "@vitejs/plugin-react": "^6.1.1",
+ "@vitest/coverage-v8": "^4.1.11",
"autoprefixer": "^10.5.2",
"husky": "^9.1.7",
+ "jsdom": "^30.0.1",
"knip": "^6.23.0",
"lint-staged": "^17.0.8",
+ "msw": "^2.15.0",
"postcss": "8.5.26",
"tailwindcss": "^3.4.19",
- "typescript": "^6.0.3"
+ "typescript": "^6.0.3",
+ "vitest": "^4.1.11"
},
"engines": {
"node": ">=20.20.0"
}
},
+ "node_modules/@adobe/css-tools": {
+ "version": "4.5.0",
+ "resolved": "https://registry.npmjs.org/@adobe/css-tools/-/css-tools-4.5.0.tgz",
+ "integrity": "sha512-6OzddxPio9UiWTCemp4N8cYLV2ZN1ncRnV1cVGtve7dhPOtRkleRyx32GQCYSwDYgaHU3USMm84tNsvKzRCa1Q==",
+ "dev": true,
+ "license": "MIT"
+ },
"node_modules/@alloc/quick-lru": {
"version": "5.2.0",
"resolved": "https://registry.npmjs.org/@alloc/quick-lru/-/quick-lru-5.2.0.tgz",
@@ -91,6 +106,91 @@
"url": "https://github.com/sponsors/sindresorhus"
}
},
+ "node_modules/@asamuzakjp/css-color": {
+ "version": "6.0.7",
+ "resolved": "https://registry.npmjs.org/@asamuzakjp/css-color/-/css-color-6.0.7.tgz",
+ "integrity": "sha512-vC/bk1Lz7Tn/EfU9/apOTBk80/8dyGyWMowPoV1tJ52muDGsDqt2HPT2klrFUiY60MQmQv9q8yIht15JnBgDGw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@csstools/css-calc": "^3.3.0",
+ "@csstools/css-color-parser": "^4.1.10",
+ "@csstools/css-parser-algorithms": "^4.0.0",
+ "@csstools/css-tokenizer": "^4.0.0",
+ "lru-cache": "^11.5.2"
+ },
+ "engines": {
+ "node": "^22.13.0 || >=24.0.0"
+ }
+ },
+ "node_modules/@asamuzakjp/dom-selector": {
+ "version": "8.3.2",
+ "resolved": "https://registry.npmjs.org/@asamuzakjp/dom-selector/-/dom-selector-8.3.2.tgz",
+ "integrity": "sha512-93Z1N+BQNXysodoicpOIyNh2drHfz/CTf9nnT0FEx72GJcIiwgydD7tGAr78j41LsYn3hlRn+LdGPuBLn1Bl8Q==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "bidi-js": "^1.0.3",
+ "css-tree": "^3.2.1",
+ "is-potential-custom-element-name": "^1.0.1",
+ "lru-cache": "^11.5.2"
+ },
+ "engines": {
+ "node": "^22.13.0 || >=24.0.0"
+ }
+ },
+ "node_modules/@babel/code-frame": {
+ "version": "7.29.7",
+ "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.7.tgz",
+ "integrity": "sha512-Aup7aUOfpbAUg2ROOJN6Iw5f9DMBlzu0mIkm/malLQFN/YQgO48wCj0Kxa3sEHJvPVFg7siR+qRInwXd2qhQKw==",
+ "dev": true,
+ "license": "MIT",
+ "peer": true,
+ "dependencies": {
+ "@babel/helper-validator-identifier": "^7.29.7",
+ "js-tokens": "^4.0.0",
+ "picocolors": "^1.1.1"
+ },
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/helper-string-parser": {
+ "version": "7.29.7",
+ "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.29.7.tgz",
+ "integrity": "sha512-Pb5ijPrZ89GDH8223L4UP8i6QApWxs04RbPQJTeWDV0/keR2E36MeKnyr6LYmUUvqRRI+Iv87SuF1W6ErINzYw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/helper-validator-identifier": {
+ "version": "7.29.7",
+ "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.29.7.tgz",
+ "integrity": "sha512-qehxGkRj55h/ff8EMaJ+cYhyaKlHIxqYDn682wQD7RNp9UujOQsHog2uS0r2vzr4pW+sXf90NeeayjcNaX3fFg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/parser": {
+ "version": "7.29.8",
+ "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.8.tgz",
+ "integrity": "sha512-E8lTAYNB1KW+FH+VGJuZM1ioAx2E6oVlvQFRrf5P8ZZmsiJXYAD9vTFV7yyEURNzgh1dFqMZuO6tUwcARbqFCA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/types": "^7.29.8"
+ },
+ "bin": {
+ "parser": "bin/babel-parser.js"
+ },
+ "engines": {
+ "node": ">=6.0.0"
+ }
+ },
"node_modules/@babel/runtime": {
"version": "7.28.4",
"resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.28.4.tgz",
@@ -100,6 +200,30 @@
"node": ">=6.9.0"
}
},
+ "node_modules/@babel/types": {
+ "version": "7.29.8",
+ "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.8.tgz",
+ "integrity": "sha512-Vj1jF3cPfxg7OAfoI7QnVKLoILlm2JF9pnVHrX8qx7AHMiYWT+NDAA7jChlNgRS4WTLc/fD1lXLmPixluj+3Gg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/helper-string-parser": "^7.29.7",
+ "@babel/helper-validator-identifier": "^7.29.7"
+ },
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@bcoe/v8-coverage": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/@bcoe/v8-coverage/-/v8-coverage-1.0.2.tgz",
+ "integrity": "sha512-6zABk/ECA/QYSCQ1NGiVwwbQerUCZ+TQbp64Q3AgmfNvurHH0j8TtXa1qbShXA6qqkpAj4V5W8pP6mLe1mcMqA==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=18"
+ }
+ },
"node_modules/@biomejs/biome": {
"version": "2.5.1",
"resolved": "https://registry.npmjs.org/@biomejs/biome/-/biome-2.5.1.tgz",
@@ -263,6 +387,19 @@
"node": ">=14.21.3"
}
},
+ "node_modules/@bramus/specificity": {
+ "version": "2.4.2",
+ "resolved": "https://registry.npmjs.org/@bramus/specificity/-/specificity-2.4.2.tgz",
+ "integrity": "sha512-ctxtJ/eA+t+6q2++vj5j7FYX3nRu311q1wfYH3xjlLOsczhlhxAg2FWNUXhpGvAw3BWo1xBcvOV6/YLc2r5FJw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "css-tree": "^3.0.0"
+ },
+ "bin": {
+ "specificity": "bin/cli.js"
+ }
+ },
"node_modules/@colors/colors": {
"version": "1.6.0",
"resolved": "https://registry.npmjs.org/@colors/colors/-/colors-1.6.0.tgz",
@@ -272,6 +409,146 @@
"node": ">=0.1.90"
}
},
+ "node_modules/@csstools/color-helpers": {
+ "version": "6.1.1",
+ "resolved": "https://registry.npmjs.org/@csstools/color-helpers/-/color-helpers-6.1.1.tgz",
+ "integrity": "sha512-gLNsunvwf3mCi5u5o46/Z/JcJMnhbHSaZ69rkgPzNM3J4s8hWwpPUQB6/tt0EDFyCiWzxANlx+2LJwpYj4zS1w==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/csstools"
+ },
+ {
+ "type": "opencollective",
+ "url": "https://opencollective.com/csstools"
+ }
+ ],
+ "license": "MIT-0",
+ "engines": {
+ "node": ">=20.19.0"
+ }
+ },
+ "node_modules/@csstools/css-calc": {
+ "version": "3.3.0",
+ "resolved": "https://registry.npmjs.org/@csstools/css-calc/-/css-calc-3.3.0.tgz",
+ "integrity": "sha512-c5ihYsPkdG6JCkU2zTMm4+k6r7RXuGxtWYhu5DHMIiF1FHzrfmHL5so11AoFpUv/tu61xfcmT4AmKoFfMPoqdQ==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/csstools"
+ },
+ {
+ "type": "opencollective",
+ "url": "https://opencollective.com/csstools"
+ }
+ ],
+ "license": "MIT",
+ "engines": {
+ "node": ">=20.19.0"
+ },
+ "peerDependencies": {
+ "@csstools/css-parser-algorithms": "^4.0.0",
+ "@csstools/css-tokenizer": "^4.0.0"
+ }
+ },
+ "node_modules/@csstools/css-color-parser": {
+ "version": "4.2.2",
+ "resolved": "https://registry.npmjs.org/@csstools/css-color-parser/-/css-color-parser-4.2.2.tgz",
+ "integrity": "sha512-3QKjR/vxyjcSXBLgb6lP0S3MGdvwbmqSsvLPbYdVORqPDc8FX1HAJ0Spk38bxaRXgvENTA47tlhhbb5Z2e8hEg==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/csstools"
+ },
+ {
+ "type": "opencollective",
+ "url": "https://opencollective.com/csstools"
+ }
+ ],
+ "license": "MIT",
+ "dependencies": {
+ "@csstools/color-helpers": "^6.1.1",
+ "@csstools/css-calc": "^3.3.0"
+ },
+ "engines": {
+ "node": ">=20.19.0"
+ },
+ "peerDependencies": {
+ "@csstools/css-parser-algorithms": "^4.0.0",
+ "@csstools/css-tokenizer": "^4.0.0"
+ }
+ },
+ "node_modules/@csstools/css-parser-algorithms": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/@csstools/css-parser-algorithms/-/css-parser-algorithms-4.0.0.tgz",
+ "integrity": "sha512-+B87qS7fIG3L5h3qwJ/IFbjoVoOe/bpOdh9hAjXbvx0o8ImEmUsGXN0inFOnk2ChCFgqkkGFQ+TpM5rbhkKe4w==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/csstools"
+ },
+ {
+ "type": "opencollective",
+ "url": "https://opencollective.com/csstools"
+ }
+ ],
+ "license": "MIT",
+ "engines": {
+ "node": ">=20.19.0"
+ },
+ "peerDependencies": {
+ "@csstools/css-tokenizer": "^4.0.0"
+ }
+ },
+ "node_modules/@csstools/css-syntax-patches-for-csstree": {
+ "version": "1.1.12",
+ "resolved": "https://registry.npmjs.org/@csstools/css-syntax-patches-for-csstree/-/css-syntax-patches-for-csstree-1.1.12.tgz",
+ "integrity": "sha512-3vLQK+dXxhBMR2Wx99PTCifE+vHtW2ndZWyla8yK813ev6oGhyn8Lja8jCyGAWTJ+LEYZK7EVtJxrDj8ztevJw==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/csstools"
+ },
+ {
+ "type": "opencollective",
+ "url": "https://opencollective.com/csstools"
+ }
+ ],
+ "license": "MIT-0",
+ "peerDependencies": {
+ "css-tree": "^3.2.1"
+ },
+ "peerDependenciesMeta": {
+ "css-tree": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@csstools/css-tokenizer": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/@csstools/css-tokenizer/-/css-tokenizer-4.0.0.tgz",
+ "integrity": "sha512-QxULHAm7cNu72w97JUNCBFODFaXpbDg+dP8b/oWFAZ2MTRppA3U00Y2L1HqaS4J6yBqxwa/Y3nMBaxVKbB/NsA==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/csstools"
+ },
+ {
+ "type": "opencollective",
+ "url": "https://opencollective.com/csstools"
+ }
+ ],
+ "license": "MIT",
+ "engines": {
+ "node": ">=20.19.0"
+ }
+ },
"node_modules/@dabh/diagnostics": {
"version": "2.0.8",
"resolved": "https://registry.npmjs.org/@dabh/diagnostics/-/diagnostics-2.0.8.tgz",
@@ -306,7 +583,6 @@
"integrity": "sha512-RSvbQmHzdKzNsLYa/wHrbc3KN4sYLKAdPZxqiM2HATqv/SBk2/ENSHpvXGaLOMcsAyz0poEGqkmmKYG3OWiJEQ==",
"dev": true,
"license": "MIT",
- "peer": true,
"dependencies": {
"@emnapi/wasi-threads": "1.2.2",
"tslib": "^2.4.0"
@@ -318,7 +594,6 @@
"integrity": "sha512-vgj7R3y3Wgx24IQaGPA/R6YFXLHVMOZ0uVEyIQPaWs+rd1AzfEMXlAC22FYwO1XkKR6NPsq7mUandH8oIRdZFw==",
"dev": true,
"license": "MIT",
- "peer": true,
"dependencies": {
"tslib": "^2.4.0"
}
@@ -333,6 +608,24 @@
"tslib": "^2.4.0"
}
},
+ "node_modules/@exodus/bytes": {
+ "version": "1.15.1",
+ "resolved": "https://registry.npmjs.org/@exodus/bytes/-/bytes-1.15.1.tgz",
+ "integrity": "sha512-S6mL0yNB/Abt9Ei4tq8gDhcczc4S3+vQ4ra7vxnAf+YHC02srtqxKKZghx2Dq6p0e66THKwR6r8N6P95wEty7Q==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+ },
+ "peerDependencies": {
+ "@noble/hashes": "^1.8.0 || ^2.0.0"
+ },
+ "peerDependenciesMeta": {
+ "@noble/hashes": {
+ "optional": true
+ }
+ }
+ },
"node_modules/@floating-ui/core": {
"version": "1.7.5",
"resolved": "https://registry.npmjs.org/@floating-ui/core/-/core-1.7.5.tgz",
@@ -371,6 +664,93 @@
"integrity": "sha512-RiB/yIh78pcIxl6lLMG0CgBXAZ2Y0eVHqMPYugu+9U0AeT6YBeiJpf7lbdJNIugFP5SIjwNRgo4DhR1Qxi26Gg==",
"license": "MIT"
},
+ "node_modules/@inquirer/ansi": {
+ "version": "2.0.8",
+ "resolved": "https://registry.npmjs.org/@inquirer/ansi/-/ansi-2.0.8.tgz",
+ "integrity": "sha512-WpQM+Ti6Z40EFwwt+uL2p4UabT+W179zHp6HhLVOzfbwnVn05IPO/eXIZXGNqcT1jbQ15SujNLzQ39k4QPPxBQ==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=23.5.0 || ^22.13.0 || ^20.17.0"
+ }
+ },
+ "node_modules/@inquirer/confirm": {
+ "version": "6.3.2",
+ "resolved": "https://registry.npmjs.org/@inquirer/confirm/-/confirm-6.3.2.tgz",
+ "integrity": "sha512-Xvr/0HggjddPtGppuqVmxhTw+Hr8PvsZ/k0HmOEaAqQEt80OITNkFWnsdNmyT0/eM4Ab+iJLx2R8rctlEyfSVg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@inquirer/core": "^12.0.3",
+ "@inquirer/type": "4.1.1"
+ },
+ "engines": {
+ "node": ">=23.5.0 || ^22.13.0 || ^20.17.0"
+ },
+ "peerDependencies": {
+ "@types/node": ">=18"
+ },
+ "peerDependenciesMeta": {
+ "@types/node": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@inquirer/core": {
+ "version": "12.0.3",
+ "resolved": "https://registry.npmjs.org/@inquirer/core/-/core-12.0.3.tgz",
+ "integrity": "sha512-wsSy0sznmXwkty+2PzZwx00Cazc/E0r0B7mAzdGROz2Ct+DFZXaK7WDjGZvgjRldxH5ZhFVfF2lgkYrqgOw2KA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@inquirer/ansi": "^2.0.8",
+ "@inquirer/figures": "^2.0.9",
+ "@inquirer/type": "4.1.1",
+ "cli-width": "^4.1.0",
+ "fast-wrap-ansi": "^0.2.0",
+ "mute-stream": "^3.0.0",
+ "signal-exit": "^4.1.0"
+ },
+ "engines": {
+ "node": ">=23.5.0 || ^22.13.0 || ^20.17.0"
+ },
+ "peerDependencies": {
+ "@types/node": ">=18"
+ },
+ "peerDependenciesMeta": {
+ "@types/node": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@inquirer/figures": {
+ "version": "2.0.9",
+ "resolved": "https://registry.npmjs.org/@inquirer/figures/-/figures-2.0.9.tgz",
+ "integrity": "sha512-EAWgUTGQ/Umgga51dE3B2PUHbufuXarDfg86uVgoSgNHNNQnyFKcOrQLWVqYMghuSyHh8+2HUH0Js9cTC1WAdg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=23.5.0 || ^22.13.0 || ^20.17.0"
+ }
+ },
+ "node_modules/@inquirer/type": {
+ "version": "4.1.1",
+ "resolved": "https://registry.npmjs.org/@inquirer/type/-/type-4.1.1.tgz",
+ "integrity": "sha512-yJoHYrMnxIsJZCY+0Vb66Dy3he3kL3e2wOBKhoSwWWAzZAY82emlxwgprCtp6yRixvNRNq9ztfRWQYPNr3Go7A==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=23.5.0 || ^22.13.0 || ^20.17.0"
+ },
+ "peerDependencies": {
+ "@types/node": ">=18"
+ },
+ "peerDependenciesMeta": {
+ "@types/node": {
+ "optional": true
+ }
+ }
+ },
"node_modules/@jridgewell/gen-mapping": {
"version": "0.3.13",
"resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
@@ -451,6 +831,31 @@
"node": ">=8"
}
},
+ "node_modules/@mswjs/interceptors": {
+ "version": "0.41.9",
+ "resolved": "https://registry.npmjs.org/@mswjs/interceptors/-/interceptors-0.41.9.tgz",
+ "integrity": "sha512-VVPPgHyQ6ShqnrmDWuxjmUIsO9gWyOZFmuOfLd9LfBGQJwZfy0gvv9pbHSJuoFNIYC7ZDX9aoFwowjcdSC4E8w==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@open-draft/deferred-promise": "^2.2.0",
+ "@open-draft/logger": "^0.3.0",
+ "@open-draft/until": "^2.0.0",
+ "is-node-process": "^1.2.0",
+ "outvariant": "^1.4.3",
+ "strict-event-emitter": "^0.5.1"
+ },
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@mswjs/interceptors/node_modules/@open-draft/deferred-promise": {
+ "version": "2.2.0",
+ "resolved": "https://registry.npmjs.org/@open-draft/deferred-promise/-/deferred-promise-2.2.0.tgz",
+ "integrity": "sha512-CecwLWx3rhxVQF6V4bAgPS5t+So2sTbPgAzafKkVizyi7tlwpcFpdFqq+wqF2OwNBmqFuu6tOyouTuxgpMfzmA==",
+ "dev": true,
+ "license": "MIT"
+ },
"node_modules/@napi-rs/wasm-runtime": {
"version": "1.1.6",
"resolved": "https://registry.npmjs.org/@napi-rs/wasm-runtime/-/wasm-runtime-1.1.6.tgz",
@@ -639,12 +1044,36 @@
"node": ">= 8"
}
},
+ "node_modules/@open-draft/deferred-promise": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/@open-draft/deferred-promise/-/deferred-promise-3.0.0.tgz",
+ "integrity": "sha512-XW375UK8/9SqUVNVa6M0yEy8+iTi4QN5VZ7aZuRFQmy76LRwI9wy5F4YIBU6T+eTe2/DNDo8tqu8RHlwLHM6RA==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@open-draft/logger": {
+ "version": "0.3.0",
+ "resolved": "https://registry.npmjs.org/@open-draft/logger/-/logger-0.3.0.tgz",
+ "integrity": "sha512-X2g45fzhxH238HKO4xbSr7+wBS8Fvw6ixhTDuvLd5mqh6bJJCFAPwU9mPDxbcrRtfxv4u5IHCEH77BmxvXmmxQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "is-node-process": "^1.2.0",
+ "outvariant": "^1.4.0"
+ }
+ },
+ "node_modules/@open-draft/until": {
+ "version": "2.1.0",
+ "resolved": "https://registry.npmjs.org/@open-draft/until/-/until-2.1.0.tgz",
+ "integrity": "sha512-U69T3ItWHvLwGg5eJ0n3I62nWuE6ilHlmz7zM0npLBRvPRd7e6NYmg54vvRtP5mZG7kZqZCFVdsTWo7BPtBujg==",
+ "dev": true,
+ "license": "MIT"
+ },
"node_modules/@opentelemetry/api": {
"version": "1.9.1",
"resolved": "https://registry.npmjs.org/@opentelemetry/api/-/api-1.9.1.tgz",
"integrity": "sha512-gLyJlPHPZYdAk1JENA9LeHejZe1Ti77/pTeFm/nMXmQH/HFZlcS/O2XJB+L8fkbrNSqhdtlvjBVjxwUYanNH5Q==",
"license": "Apache-2.0",
- "peer": true,
"engines": {
"node": ">=8.0.0"
}
@@ -1301,7 +1730,6 @@
"integrity": "sha512-8nKv6+0RJSL9FE4jYOEGXnPeM/Hg12qZpmqzZjRh3qM0Y7c3z1mrOTfFLids72RDQYVh9WpLEfR5WdpNX4fkig==",
"devOptional": true,
"license": "Apache-2.0",
- "peer": true,
"dependencies": {
"playwright": "1.61.1"
},
@@ -2469,8 +2897,288 @@
"integrity": "sha512-xnXE7wG13PI+cxieVssYXlQJuYVRhH9NBoxt3KNwzghDIA69GMm7d4wXRouHIYjE+KvS6U/MsMO73NdS2MH9ZA==",
"license": "MIT"
},
- "node_modules/@segment/analytics-core": {
- "version": "1.8.3",
+ "node_modules/@rolldown/binding-android-arm-eabi": {
+ "version": "1.2.7",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-android-arm-eabi/-/binding-android-arm-eabi-1.2.7.tgz",
+ "integrity": "sha512-EypzgnYCwyVY4NDHKzGmNJT5b+XaQEBniHxsMdeIQLB/tcCzZnhqrzHpZFbX9iaxx+5RiB8caATBtfvZP7zVxQ==",
+ "cpu": [
+ "arm"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "android"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-android-arm64": {
+ "version": "1.2.7",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-android-arm64/-/binding-android-arm64-1.2.7.tgz",
+ "integrity": "sha512-l17HE9EweWaqJZhuUuNBN/FzM62xw+DECVnJyvMsxn8vJFAGLy5QfLDoYAcronkAN8VxKZHezDpulHDPx95vFw==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "android"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-darwin-arm64": {
+ "version": "1.2.7",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-arm64/-/binding-darwin-arm64-1.2.7.tgz",
+ "integrity": "sha512-8ED8ELFvHXc6OCETIn4gXObPiaR6bckM/ipXtbzlPVDRMBfEGjCKgO90F9YtfdpDatVx/ZQw7aZ1vUMf/+T3Mw==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "darwin"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-darwin-x64": {
+ "version": "1.2.7",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-x64/-/binding-darwin-x64-1.2.7.tgz",
+ "integrity": "sha512-/WPripjtiAIZ2tWY7ddijORT0Ujg87wxWW/qcoFVCKAWVDPhtY0xr7Dj0M3GyNGz60jGwTElhro/mkF9dT7dDQ==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "darwin"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-freebsd-x64": {
+ "version": "1.2.7",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-freebsd-x64/-/binding-freebsd-x64-1.2.7.tgz",
+ "integrity": "sha512-14DI4NcqpvbICxSnGLx3PmtDaWqRP/KGSGb6C+JLLVPeZRl6dKdHba3pGsqT3vpdTqhEYIPG0MMQ8c0xYqoJxA==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "freebsd"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-linux-arm-gnueabihf": {
+ "version": "1.2.7",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm-gnueabihf/-/binding-linux-arm-gnueabihf-1.2.7.tgz",
+ "integrity": "sha512-bxrWIRvHWQvbJwi+VIie/kDJmQxcNE6xxWwZdqF/ExVAigtHkv54WTLQPb+QsZdnFy18fg7JPfWGL0RH6vwIlQ==",
+ "cpu": [
+ "arm"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-linux-arm64-gnu": {
+ "version": "1.2.7",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-gnu/-/binding-linux-arm64-gnu-1.2.7.tgz",
+ "integrity": "sha512-toOY2BChBZyuxU7OYX6Tn389di4IzAqPTycVcci0O7FSfBqzRB3RZn+K5Is6ANf4tmgRd/K1yZTsNTXbkXsnLg==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "libc": [
+ "glibc"
+ ],
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-linux-arm64-musl": {
+ "version": "1.2.7",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-musl/-/binding-linux-arm64-musl-1.2.7.tgz",
+ "integrity": "sha512-lAIXTH/aiLRLxsTgQvfhjo4K1ydWIp00+V0voOr9beb/9ZmkUFrSIb03dXNFRgMNvkE6oGsF10ioQ6UsI+vS5Q==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "libc": [
+ "musl"
+ ],
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-linux-ppc64-gnu": {
+ "version": "1.2.7",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-ppc64-gnu/-/binding-linux-ppc64-gnu-1.2.7.tgz",
+ "integrity": "sha512-kdnwS28Pkenp/mZMRwjXXXwxQ7pIsm+bF919LUK93BOyhcLsrVKdP2p9fxpiPNPAbNuch8ypQt0pm2P2LYCAGg==",
+ "cpu": [
+ "ppc64"
+ ],
+ "dev": true,
+ "libc": [
+ "glibc"
+ ],
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-linux-s390x-gnu": {
+ "version": "1.2.7",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-s390x-gnu/-/binding-linux-s390x-gnu-1.2.7.tgz",
+ "integrity": "sha512-516OdsyLdr5E65paF3yBF55t8mfm9+gmtCsK3xI7XKXIT7EfRlHhxL8K/NR6Hu8BWSgF5+1w74lTL0+nxcc8Qw==",
+ "cpu": [
+ "s390x"
+ ],
+ "dev": true,
+ "libc": [
+ "glibc"
+ ],
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-linux-x64-gnu": {
+ "version": "1.2.7",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-gnu/-/binding-linux-x64-gnu-1.2.7.tgz",
+ "integrity": "sha512-r8/z8n7GFaYRln3xmP1Cxy0HH/HLM0uBUPkEuSVEfKGDA89M0FsZRZJRSwe/tJjRx+fpH/gjorfhB8tmEbSFLA==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "libc": [
+ "glibc"
+ ],
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-linux-x64-musl": {
+ "version": "1.2.7",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-musl/-/binding-linux-x64-musl-1.2.7.tgz",
+ "integrity": "sha512-pAsE8iiDxUg1xBqdhrTfg45AVDVpirjz00sblEYClGNNcMnDb+e8beQgqIAw6LvauX/APvgxUnwrgun/YYGBhw==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "libc": [
+ "musl"
+ ],
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-openharmony-arm64": {
+ "version": "1.2.7",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-openharmony-arm64/-/binding-openharmony-arm64-1.2.7.tgz",
+ "integrity": "sha512-lTcIYmmnQQA8Or/2DatS6oSqcdLHvendjS+zLu+FwgToynWMRSmQdpM65fTANJgIS4mjbMOo5KT2lnT9SAb96w==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "openharmony"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-win32-arm64-msvc": {
+ "version": "1.2.7",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-arm64-msvc/-/binding-win32-arm64-msvc-1.2.7.tgz",
+ "integrity": "sha512-e3Gu3WxbNk/UqQhxqU7YIYO+9ZBvWNz3U+h/qRFosscMFzdRPbXYSaSWgSnklv2fz1TgzBTcti2z35c/7irsHw==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "win32"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-win32-x64-msvc": {
+ "version": "1.2.7",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-x64-msvc/-/binding-win32-x64-msvc-1.2.7.tgz",
+ "integrity": "sha512-W/jg5qoRSqjsEv0+dZi4e687mcHqmVuU0P4fK6qS/xjetW2Gmc1W8j//z5nAeNcC8Ttm0hV46IjcYeuVwYhuiw==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "win32"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/pluginutils": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.1.tgz",
+ "integrity": "sha512-2j9bGt5Jh8hj+vPtgzPtl72j0yRxHAyumoo6TNfAjsLB04UtpSvPbPcDcBMxz7n+9CYB0c1GxQFxYRg2jimqGw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@segment/analytics-core": {
+ "version": "1.8.3",
"resolved": "https://registry.npmjs.org/@segment/analytics-core/-/analytics-core-1.8.3.tgz",
"integrity": "sha512-63X8e2DWb2ZnJ9S3H8iSOFnbeDXMkTGhA8kZG4eFAO07QBwBVyWo5BCpv6vmuOMEkv2le6t2FMg1p6ZeJQA/4A==",
"license": "MIT",
@@ -2579,6 +3287,13 @@
"text-hex": "1.0.x"
}
},
+ "node_modules/@standard-schema/spec": {
+ "version": "1.1.0",
+ "resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.1.0.tgz",
+ "integrity": "sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==",
+ "dev": true,
+ "license": "MIT"
+ },
"node_modules/@swc/helpers": {
"version": "0.5.15",
"resolved": "https://registry.npmjs.org/@swc/helpers/-/helpers-0.5.15.tgz",
@@ -2638,46 +3353,171 @@
"react": "^18 || ^19"
}
},
- "node_modules/@tybys/wasm-util": {
- "version": "0.10.3",
- "resolved": "https://registry.npmjs.org/@tybys/wasm-util/-/wasm-util-0.10.3.tgz",
- "integrity": "sha512-F3fo1MYrRJYL3zER0OUOmkutjr1Vp23m7OsSgp7nq4SP6OqX6C/56XFIPAl5bt3zaBRjmW7SGz3u/6LwFpYcOg==",
+ "node_modules/@testing-library/dom": {
+ "version": "10.4.1",
+ "resolved": "https://registry.npmjs.org/@testing-library/dom/-/dom-10.4.1.tgz",
+ "integrity": "sha512-o4PXJQidqJl82ckFaXUeoAW+XysPLauYI43Abki5hABd853iMhitooc6znOnczgbTYmEP6U6/y1ZyKAIsvMKGg==",
"dev": true,
"license": "MIT",
- "optional": true,
+ "peer": true,
"dependencies": {
- "tslib": "^2.4.0"
+ "@babel/code-frame": "^7.10.4",
+ "@babel/runtime": "^7.12.5",
+ "@types/aria-query": "^5.0.1",
+ "aria-query": "5.3.0",
+ "dom-accessibility-api": "^0.5.9",
+ "lz-string": "^1.5.0",
+ "picocolors": "1.1.1",
+ "pretty-format": "^27.0.2"
+ },
+ "engines": {
+ "node": ">=18"
}
},
- "node_modules/@types/debug": {
- "version": "4.1.12",
- "resolved": "https://registry.npmjs.org/@types/debug/-/debug-4.1.12.tgz",
- "integrity": "sha512-vIChWdVG3LG1SMxEvI/AK+FWJthlrqlTu7fbrlywTkkaONwk/UAGaULXRlf8vkzFBLVm0zkMdCquhL5aOjhXPQ==",
+ "node_modules/@testing-library/jest-dom": {
+ "version": "7.0.1",
+ "resolved": "https://registry.npmjs.org/@testing-library/jest-dom/-/jest-dom-7.0.1.tgz",
+ "integrity": "sha512-oMDTC3oA+6CXSO2JZnvOI7CA6oVub6kij5ggk9ohwye5slmkwxYDXcPOVxgMw/RQlticjtO0C1RZkR97HgrWMw==",
+ "dev": true,
+ "license": "MIT",
"dependencies": {
- "@types/ms": "*"
+ "@adobe/css-tools": "^4.4.0",
+ "aria-query": "^5.0.0",
+ "css.escape": "^1.5.1",
+ "dom-accessibility-api": "^0.6.3",
+ "picocolors": "^1.1.1",
+ "redent": "^3.0.0"
+ },
+ "engines": {
+ "node": ">=22",
+ "npm": ">=6",
+ "yarn": ">=1"
+ },
+ "peerDependencies": {
+ "@testing-library/dom": ">=10 <11",
+ "vitest": ">= 0.32"
+ },
+ "peerDependenciesMeta": {
+ "vitest": {
+ "optional": true
+ }
}
},
- "node_modules/@types/estree": {
- "version": "1.0.8",
- "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
- "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
+ "node_modules/@testing-library/jest-dom/node_modules/dom-accessibility-api": {
+ "version": "0.6.3",
+ "resolved": "https://registry.npmjs.org/dom-accessibility-api/-/dom-accessibility-api-0.6.3.tgz",
+ "integrity": "sha512-7ZgogeTnjuHbo+ct10G9Ffp0mif17idi0IyWNVA/wcwcm7NPOD/WEHVP3n7n3MhXqxoIYm8d6MuZohYWIZ4T3w==",
+ "dev": true,
"license": "MIT"
},
- "node_modules/@types/estree-jsx": {
- "version": "1.0.5",
- "resolved": "https://registry.npmjs.org/@types/estree-jsx/-/estree-jsx-1.0.5.tgz",
- "integrity": "sha512-52CcUVNFyfb1A2ALocQw/Dd1BQFNmSdkuC3BkZ6iqhdMfQz7JWOFRuJFloOzjk+6WijU56m9oKXFAXc7o3Towg==",
- "dependencies": {
- "@types/estree": "*"
- }
- },
- "node_modules/@types/hast": {
- "version": "3.0.4",
- "resolved": "https://registry.npmjs.org/@types/hast/-/hast-3.0.4.tgz",
- "integrity": "sha512-WPs+bbQw5aCj+x6laNGWLH3wviHtoCv/P3+otBhbOhJgG8qtpdAMlTCxLtsTWA7LH1Oh/bFCHsBn0TPS5m30EQ==",
+ "node_modules/@testing-library/react": {
+ "version": "16.3.3",
+ "resolved": "https://registry.npmjs.org/@testing-library/react/-/react-16.3.3.tgz",
+ "integrity": "sha512-Uo193NgQbPMz6lrrhtRQQFcMC6Re/ELLFbbuVL30WDlZxlpZf9/lMHTAVxPRLw1q1iu9OJmR1c2BLiENRstdBg==",
+ "dev": true,
"license": "MIT",
"dependencies": {
- "@types/unist": "*"
+ "@babel/runtime": "^7.12.5"
+ },
+ "engines": {
+ "node": ">=18"
+ },
+ "peerDependencies": {
+ "@testing-library/dom": "^10.0.0",
+ "@types/react": "^18.0.0 || ^19.0.0",
+ "@types/react-dom": "^18.0.0 || ^19.0.0",
+ "react": "^18.0.0 || ^19.0.0",
+ "react-dom": "^18.0.0 || ^19.0.0"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ },
+ "@types/react-dom": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@testing-library/user-event": {
+ "version": "14.6.7",
+ "resolved": "https://registry.npmjs.org/@testing-library/user-event/-/user-event-14.6.7.tgz",
+ "integrity": "sha512-MPCpX8bxe8zS+JmmTwLp8jd0dy1rAm60Te/SL8JrQM3qvQJcBOs1d7IefJMyZzqM3EWBrDn/LWDt1BCGu4ASfg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=12",
+ "npm": ">=6"
+ },
+ "peerDependencies": {
+ "@testing-library/dom": ">=7.21.4"
+ }
+ },
+ "node_modules/@tybys/wasm-util": {
+ "version": "0.10.3",
+ "resolved": "https://registry.npmjs.org/@tybys/wasm-util/-/wasm-util-0.10.3.tgz",
+ "integrity": "sha512-F3fo1MYrRJYL3zER0OUOmkutjr1Vp23m7OsSgp7nq4SP6OqX6C/56XFIPAl5bt3zaBRjmW7SGz3u/6LwFpYcOg==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "dependencies": {
+ "tslib": "^2.4.0"
+ }
+ },
+ "node_modules/@types/aria-query": {
+ "version": "5.0.4",
+ "resolved": "https://registry.npmjs.org/@types/aria-query/-/aria-query-5.0.4.tgz",
+ "integrity": "sha512-rfT93uj5s0PRL7EzccGMs3brplhcrghnDoV26NqKhCAS1hVo+WdNsPvE/yb6ilfr5hi2MEk6d5EWJTKdxg8jVw==",
+ "dev": true,
+ "license": "MIT",
+ "peer": true
+ },
+ "node_modules/@types/chai": {
+ "version": "5.2.3",
+ "resolved": "https://registry.npmjs.org/@types/chai/-/chai-5.2.3.tgz",
+ "integrity": "sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/deep-eql": "*",
+ "assertion-error": "^2.0.1"
+ }
+ },
+ "node_modules/@types/debug": {
+ "version": "4.1.12",
+ "resolved": "https://registry.npmjs.org/@types/debug/-/debug-4.1.12.tgz",
+ "integrity": "sha512-vIChWdVG3LG1SMxEvI/AK+FWJthlrqlTu7fbrlywTkkaONwk/UAGaULXRlf8vkzFBLVm0zkMdCquhL5aOjhXPQ==",
+ "dependencies": {
+ "@types/ms": "*"
+ }
+ },
+ "node_modules/@types/deep-eql": {
+ "version": "4.0.2",
+ "resolved": "https://registry.npmjs.org/@types/deep-eql/-/deep-eql-4.0.2.tgz",
+ "integrity": "sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@types/estree": {
+ "version": "1.0.8",
+ "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
+ "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
+ "license": "MIT"
+ },
+ "node_modules/@types/estree-jsx": {
+ "version": "1.0.5",
+ "resolved": "https://registry.npmjs.org/@types/estree-jsx/-/estree-jsx-1.0.5.tgz",
+ "integrity": "sha512-52CcUVNFyfb1A2ALocQw/Dd1BQFNmSdkuC3BkZ6iqhdMfQz7JWOFRuJFloOzjk+6WijU56m9oKXFAXc7o3Towg==",
+ "dependencies": {
+ "@types/estree": "*"
+ }
+ },
+ "node_modules/@types/hast": {
+ "version": "3.0.4",
+ "resolved": "https://registry.npmjs.org/@types/hast/-/hast-3.0.4.tgz",
+ "integrity": "sha512-WPs+bbQw5aCj+x6laNGWLH3wviHtoCv/P3+otBhbOhJgG8qtpdAMlTCxLtsTWA7LH1Oh/bFCHsBn0TPS5m30EQ==",
+ "license": "MIT",
+ "dependencies": {
+ "@types/unist": "*"
}
},
"node_modules/@types/mathjax": {
@@ -2719,7 +3559,6 @@
"resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.17.tgz",
"integrity": "sha512-MXfmqaVPEVgkBT/aY0aGCkRWWtByiYQXo3xdQ8r5RzuFrPiRn8Gar2tQdXSUQ2GKV3bkXckek89V8wQBY2Q/Aw==",
"license": "MIT",
- "peer": true,
"dependencies": {
"csstype": "^3.2.2"
}
@@ -2730,7 +3569,6 @@
"integrity": "sha512-jp2L/eY6fn+KgVVQAOqYItbF0VY/YApe5Mz2F0aykSO8gx31bYCZyvSeYxCHKvzHG5eZjc+zyaS5BrBWya2+kQ==",
"devOptional": true,
"license": "MIT",
- "peer": true,
"peerDependencies": {
"@types/react": "^19.2.0"
}
@@ -2744,6 +3582,23 @@
"@types/react": "*"
}
},
+ "node_modules/@types/set-cookie-parser": {
+ "version": "2.4.10",
+ "resolved": "https://registry.npmjs.org/@types/set-cookie-parser/-/set-cookie-parser-2.4.10.tgz",
+ "integrity": "sha512-GGmQVGpQWUe5qglJozEjZV/5dyxbOOZ0LHe/lqyWssB88Y4svNfst0uqBVscdDeIKl5Jy5+aPSvy7mI9tYRguw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/node": "*"
+ }
+ },
+ "node_modules/@types/statuses": {
+ "version": "2.0.6",
+ "resolved": "https://registry.npmjs.org/@types/statuses/-/statuses-2.0.6.tgz",
+ "integrity": "sha512-xMAgYwceFhRA2zY+XbEA7mxYbA093wdiW8Vu6gZPGWy9cmOyU9XesH1tNcEWsKFd5Vzrqx5T3D38PWx1FIIXkA==",
+ "dev": true,
+ "license": "MIT"
+ },
"node_modules/@types/triple-beam": {
"version": "1.3.5",
"resolved": "https://registry.npmjs.org/@types/triple-beam/-/triple-beam-1.3.5.tgz",
@@ -2767,6 +3622,180 @@
"resolved": "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.3.0.tgz",
"integrity": "sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g=="
},
+ "node_modules/@vitejs/plugin-react": {
+ "version": "6.1.1",
+ "resolved": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-6.1.1.tgz",
+ "integrity": "sha512-yxLaQV9gkhS8ezJqCM6+ndU7mDY6gqAg75NQ+0IjwEI8IYOmQCgkRwHKVSfWXW076DsqMo0Dk+0FK1U+M5RgFw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@rolldown/pluginutils": "^1.0.1"
+ },
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ },
+ "peerDependencies": {
+ "@rolldown/plugin-babel": "^0.1.7 || ^0.2.0",
+ "babel-plugin-react-compiler": "^1.0.0",
+ "oxc-transform-react": "^0.145.0",
+ "vite": "^8.0.0"
+ },
+ "peerDependenciesMeta": {
+ "@rolldown/plugin-babel": {
+ "optional": true
+ },
+ "babel-plugin-react-compiler": {
+ "optional": true
+ },
+ "oxc-transform-react": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@vitest/coverage-v8": {
+ "version": "4.1.11",
+ "resolved": "https://registry.npmjs.org/@vitest/coverage-v8/-/coverage-v8-4.1.11.tgz",
+ "integrity": "sha512-8MVGEFnJIcdGjcbfKmeq8z0pZHH0JlVtoVZH9Q/qwUp6wyFnEJUBMrw9DCaj+ra3vShGmhavjalMIhPNxZAUcw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@bcoe/v8-coverage": "^1.0.2",
+ "@vitest/utils": "4.1.11",
+ "ast-v8-to-istanbul": "^1.0.0",
+ "istanbul-lib-coverage": "^3.2.2",
+ "istanbul-lib-report": "^3.0.1",
+ "istanbul-reports": "^3.2.0",
+ "magicast": "^0.5.2",
+ "obug": "^2.1.1",
+ "std-env": "^4.0.0-rc.1",
+ "tinyrainbow": "^3.1.0"
+ },
+ "funding": {
+ "url": "https://opencollective.com/vitest"
+ },
+ "peerDependencies": {
+ "@vitest/browser": "4.1.11",
+ "vitest": "4.1.11"
+ },
+ "peerDependenciesMeta": {
+ "@vitest/browser": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@vitest/expect": {
+ "version": "4.1.11",
+ "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-4.1.11.tgz",
+ "integrity": "sha512-VX2x5vNJXET47KAFzwERI+KRMtTTCSWTfSMKsW7JsUsXV4psq++e3DvZpuTDOpHcxytiDs6p2nhVb2tVDiiUYw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@standard-schema/spec": "^1.1.0",
+ "@types/chai": "^5.2.2",
+ "@vitest/spy": "4.1.11",
+ "@vitest/utils": "4.1.11",
+ "chai": "^6.2.2",
+ "tinyrainbow": "^3.1.0"
+ },
+ "funding": {
+ "url": "https://opencollective.com/vitest"
+ }
+ },
+ "node_modules/@vitest/mocker": {
+ "version": "4.1.11",
+ "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-4.1.11.tgz",
+ "integrity": "sha512-2XJVD55d1o5AZous5CCGKS74g/riOj9odEt2bQpCVZeblHyHdnMeFl4jl0XjU21stf4mbjUkew2eXQZt65g5CQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@vitest/spy": "4.1.11",
+ "estree-walker": "^3.0.3",
+ "magic-string": "^0.30.21"
+ },
+ "funding": {
+ "url": "https://opencollective.com/vitest"
+ },
+ "peerDependencies": {
+ "msw": "^2.4.9",
+ "vite": "^6.0.0 || ^7.0.0 || ^8.0.0"
+ },
+ "peerDependenciesMeta": {
+ "msw": {
+ "optional": true
+ },
+ "vite": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@vitest/pretty-format": {
+ "version": "4.1.11",
+ "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-4.1.11.tgz",
+ "integrity": "sha512-yiZzPbGTS9Sr/JpFl8zHrcIkAofNbFV6k21vIgQN/cY/oxZeXhJv5sc/MBJ5jFKWmWs+oJHw0UXLZjmf931+Vw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "tinyrainbow": "^3.1.0"
+ },
+ "funding": {
+ "url": "https://opencollective.com/vitest"
+ }
+ },
+ "node_modules/@vitest/runner": {
+ "version": "4.1.11",
+ "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-4.1.11.tgz",
+ "integrity": "sha512-LztvUgdwMNJMIkj3hQnnxiC2Xy1zNxq928W/xhjCLaNCzqTZOudjwbQf6v9IntZGPw132i2Lq2rgTRZHD3JHNw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@vitest/utils": "4.1.11",
+ "pathe": "^2.0.3"
+ },
+ "funding": {
+ "url": "https://opencollective.com/vitest"
+ }
+ },
+ "node_modules/@vitest/snapshot": {
+ "version": "4.1.11",
+ "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-4.1.11.tgz",
+ "integrity": "sha512-pN7ikn1ON7h8ee4gIAp4AzyK+zBtJPzVbqOgu5LCEh4VaJVbPQcgYQYJIMGQPXVeJJq1fnfazis7a5pFNPahog==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@vitest/pretty-format": "4.1.11",
+ "@vitest/utils": "4.1.11",
+ "magic-string": "^0.30.21",
+ "pathe": "^2.0.3"
+ },
+ "funding": {
+ "url": "https://opencollective.com/vitest"
+ }
+ },
+ "node_modules/@vitest/spy": {
+ "version": "4.1.11",
+ "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-4.1.11.tgz",
+ "integrity": "sha512-apNa/prQy2qCeywhnixOHPRCgGNhvg7T4Dapfl1GahLp/R+uhBm5cPyFoNVyqsNd2h1nJxL6BqqdIjiABL60YA==",
+ "dev": true,
+ "license": "MIT",
+ "funding": {
+ "url": "https://opencollective.com/vitest"
+ }
+ },
+ "node_modules/@vitest/utils": {
+ "version": "4.1.11",
+ "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-4.1.11.tgz",
+ "integrity": "sha512-zTCVGpyFsGWBhllOyKlTw/vnr6D9qxsfSDyfbyZmTyjHw5N/VuvzHpHoQjm2ZJzn4RJgx5w4r7V0er69CmLgPQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@vitest/pretty-format": "4.1.11",
+ "convert-source-map": "^2.0.0",
+ "tinyrainbow": "^3.1.0"
+ },
+ "funding": {
+ "url": "https://opencollective.com/vitest"
+ }
+ },
"node_modules/@xmldom/xmldom": {
"version": "0.9.10",
"resolved": "https://registry.npmjs.org/@xmldom/xmldom/-/xmldom-0.9.10.tgz",
@@ -2891,6 +3920,45 @@
"node": ">=10"
}
},
+ "node_modules/aria-query": {
+ "version": "5.3.0",
+ "resolved": "https://registry.npmjs.org/aria-query/-/aria-query-5.3.0.tgz",
+ "integrity": "sha512-b0P0sZPKtyu8HkeRAfCq0IfURZK+SuwMjY1UXGBU27wpAiTwQAIlq56IbIO+ytk/JjS1fMR14ee5WBBfKi5J6A==",
+ "dev": true,
+ "license": "Apache-2.0",
+ "dependencies": {
+ "dequal": "^2.0.3"
+ }
+ },
+ "node_modules/assertion-error": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz",
+ "integrity": "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/ast-v8-to-istanbul": {
+ "version": "1.0.6",
+ "resolved": "https://registry.npmjs.org/ast-v8-to-istanbul/-/ast-v8-to-istanbul-1.0.6.tgz",
+ "integrity": "sha512-fvpl29helSO2w/z7utIbrkNXILdrLwDwAMH2I/zPKlGf5244+gf+B4cyS1sANcrPY2h+hWCGSgC8N61s/+AF9A==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@jridgewell/trace-mapping": "^0.3.31",
+ "estree-walker": "^3.0.3",
+ "js-tokens": "^10.0.0"
+ }
+ },
+ "node_modules/ast-v8-to-istanbul/node_modules/js-tokens": {
+ "version": "10.0.0",
+ "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-10.0.0.tgz",
+ "integrity": "sha512-lM/UBzQmfJRo9ABXbPWemivdCW8V2G8FHaHdypQaIy523snUjog0W71ayWXTjiR+ixeMyVHN2XcpnTd/liPg/Q==",
+ "dev": true,
+ "license": "MIT"
+ },
"node_modules/async": {
"version": "3.2.6",
"resolved": "https://registry.npmjs.org/async/-/async-3.2.6.tgz",
@@ -2964,6 +4032,16 @@
"node": ">=6.0.0"
}
},
+ "node_modules/bidi-js": {
+ "version": "1.1.0",
+ "resolved": "https://registry.npmjs.org/bidi-js/-/bidi-js-1.1.0.tgz",
+ "integrity": "sha512-fX1Onk0tdVPC7obPWB5EbJ1z7NVhLq4m2xZLq2YXBkxzMXIGRpNMU88n0EPgWseKl12J7zXs7qrDxPK4sRs2fg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "require-from-string": "^2.0.2"
+ }
+ },
"node_modules/binary-extensions": {
"version": "2.3.0",
"resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.3.0.tgz",
@@ -3014,7 +4092,6 @@
}
],
"license": "MIT",
- "peer": true,
"dependencies": {
"baseline-browser-mapping": "^2.10.38",
"caniuse-lite": "^1.0.30001799",
@@ -3068,6 +4145,16 @@
"url": "https://github.com/sponsors/wooorm"
}
},
+ "node_modules/chai": {
+ "version": "6.2.2",
+ "resolved": "https://registry.npmjs.org/chai/-/chai-6.2.2.tgz",
+ "integrity": "sha512-NUPRluOfOiTKBKvWPtSD4PhFvWCqOi0BGStNWs57X9js7XGTprSmFoz5F0tWhR4WPjNeR9jXqdC7/UpSJTnlRg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=18"
+ }
+ },
"node_modules/character-entities-html4": {
"version": "2.1.0",
"resolved": "https://registry.npmjs.org/character-entities-html4/-/character-entities-html4-2.1.0.tgz",
@@ -3166,48 +4253,175 @@
"url": "https://github.com/sponsors/sindresorhus"
}
},
+ "node_modules/cli-width": {
+ "version": "4.1.0",
+ "resolved": "https://registry.npmjs.org/cli-width/-/cli-width-4.1.0.tgz",
+ "integrity": "sha512-ouuZd4/dm2Sw5Gmqy6bGyNNNe1qt9RpmxveLSO7KcgsTnU7RXfsw+/bukWGo1abgBiMAic068rclZsO4IWmmxQ==",
+ "dev": true,
+ "license": "ISC",
+ "engines": {
+ "node": ">= 12"
+ }
+ },
"node_modules/client-only": {
"version": "0.0.1",
"resolved": "https://registry.npmjs.org/client-only/-/client-only-0.0.1.tgz",
"integrity": "sha512-IV3Ou0jSMzZrd3pZ48nLkT9DA7Ag1pnPzaiQhpW7c3RbcqqzvzzVu+L8gfqMp/8IM2MQtSiqaCxrrcfu8I8rMA==",
"license": "MIT"
},
- "node_modules/clsx": {
- "version": "2.1.1",
- "resolved": "https://registry.npmjs.org/clsx/-/clsx-2.1.1.tgz",
- "integrity": "sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==",
- "license": "MIT",
+ "node_modules/cliui": {
+ "version": "8.0.1",
+ "resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz",
+ "integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "string-width": "^4.2.0",
+ "strip-ansi": "^6.0.1",
+ "wrap-ansi": "^7.0.0"
+ },
"engines": {
- "node": ">=6"
+ "node": ">=12"
}
},
- "node_modules/cmdk": {
- "version": "1.1.1",
- "resolved": "https://registry.npmjs.org/cmdk/-/cmdk-1.1.1.tgz",
- "integrity": "sha512-Vsv7kFaXm+ptHDMZ7izaRsP70GgrW9NBNGswt9OZaVBLlE0SNpDq8eu/VGXyF9r7M0azK3Wy7OlYXsuyYLFzHg==",
+ "node_modules/cliui/node_modules/ansi-regex": {
+ "version": "5.0.1",
+ "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+ "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+ "dev": true,
"license": "MIT",
- "dependencies": {
- "@radix-ui/react-compose-refs": "^1.1.1",
- "@radix-ui/react-dialog": "^1.1.6",
- "@radix-ui/react-id": "^1.1.0",
- "@radix-ui/react-primitive": "^2.0.2"
- },
- "peerDependencies": {
- "react": "^18 || ^19 || ^19.0.0-rc",
- "react-dom": "^18 || ^19 || ^19.0.0-rc"
+ "engines": {
+ "node": ">=8"
}
},
- "node_modules/color": {
- "version": "5.0.3",
- "resolved": "https://registry.npmjs.org/color/-/color-5.0.3.tgz",
- "integrity": "sha512-ezmVcLR3xAVp8kYOm4GS45ZLLgIE6SPAFoduLr6hTDajwb3KZ2F46gulK3XpcwRFb5KKGCSezCBAY4Dw4HsyXA==",
+ "node_modules/cliui/node_modules/ansi-styles": {
+ "version": "4.3.0",
+ "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+ "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+ "dev": true,
"license": "MIT",
"dependencies": {
- "color-convert": "^3.1.3",
- "color-string": "^2.1.3"
+ "color-convert": "^2.0.1"
},
"engines": {
- "node": ">=18"
+ "node": ">=8"
+ },
+ "funding": {
+ "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+ }
+ },
+ "node_modules/cliui/node_modules/color-convert": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
+ "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "color-name": "~1.1.4"
+ },
+ "engines": {
+ "node": ">=7.0.0"
+ }
+ },
+ "node_modules/cliui/node_modules/color-name": {
+ "version": "1.1.4",
+ "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
+ "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/cliui/node_modules/is-fullwidth-code-point": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+ "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/cliui/node_modules/string-width": {
+ "version": "4.2.3",
+ "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+ "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "emoji-regex": "^8.0.0",
+ "is-fullwidth-code-point": "^3.0.0",
+ "strip-ansi": "^6.0.1"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/cliui/node_modules/strip-ansi": {
+ "version": "6.0.1",
+ "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+ "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "ansi-regex": "^5.0.1"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/cliui/node_modules/wrap-ansi": {
+ "version": "7.0.0",
+ "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
+ "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "ansi-styles": "^4.0.0",
+ "string-width": "^4.1.0",
+ "strip-ansi": "^6.0.0"
+ },
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
+ }
+ },
+ "node_modules/clsx": {
+ "version": "2.1.1",
+ "resolved": "https://registry.npmjs.org/clsx/-/clsx-2.1.1.tgz",
+ "integrity": "sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==",
+ "license": "MIT",
+ "engines": {
+ "node": ">=6"
+ }
+ },
+ "node_modules/cmdk": {
+ "version": "1.1.1",
+ "resolved": "https://registry.npmjs.org/cmdk/-/cmdk-1.1.1.tgz",
+ "integrity": "sha512-Vsv7kFaXm+ptHDMZ7izaRsP70GgrW9NBNGswt9OZaVBLlE0SNpDq8eu/VGXyF9r7M0azK3Wy7OlYXsuyYLFzHg==",
+ "license": "MIT",
+ "dependencies": {
+ "@radix-ui/react-compose-refs": "^1.1.1",
+ "@radix-ui/react-dialog": "^1.1.6",
+ "@radix-ui/react-id": "^1.1.0",
+ "@radix-ui/react-primitive": "^2.0.2"
+ },
+ "peerDependencies": {
+ "react": "^18 || ^19 || ^19.0.0-rc",
+ "react-dom": "^18 || ^19 || ^19.0.0-rc"
+ }
+ },
+ "node_modules/color": {
+ "version": "5.0.3",
+ "resolved": "https://registry.npmjs.org/color/-/color-5.0.3.tgz",
+ "integrity": "sha512-ezmVcLR3xAVp8kYOm4GS45ZLLgIE6SPAFoduLr6hTDajwb3KZ2F46gulK3XpcwRFb5KKGCSezCBAY4Dw4HsyXA==",
+ "license": "MIT",
+ "dependencies": {
+ "color-convert": "^3.1.3",
+ "color-string": "^2.1.3"
+ },
+ "engines": {
+ "node": ">=18"
}
},
"node_modules/color-convert": {
@@ -3262,6 +4476,48 @@
"node": ">=18"
}
},
+ "node_modules/convert-source-map": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz",
+ "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/cookie": {
+ "version": "1.1.1",
+ "resolved": "https://registry.npmjs.org/cookie/-/cookie-1.1.1.tgz",
+ "integrity": "sha512-ei8Aos7ja0weRpFzJnEA9UHJ/7XQmqglbRwnf2ATjcB9Wq874VKH9kfjjirM6UhU2/E5fFYadylyhFldcqSidQ==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=18"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/express"
+ }
+ },
+ "node_modules/css-tree": {
+ "version": "3.2.1",
+ "resolved": "https://registry.npmjs.org/css-tree/-/css-tree-3.2.1.tgz",
+ "integrity": "sha512-X7sjQzceUhu1u7Y/ylrRZFU2FS6LRiFVp6rKLPg23y3x3c3DOKAwuXGDp+PAGjh6CSnCjYeAul8pcT8bAl+lSA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "mdn-data": "2.27.1",
+ "source-map-js": "^1.2.1"
+ },
+ "engines": {
+ "node": "^10 || ^12.20.0 || ^14.13.0 || >=15.0.0"
+ }
+ },
+ "node_modules/css.escape": {
+ "version": "1.5.1",
+ "resolved": "https://registry.npmjs.org/css.escape/-/css.escape-1.5.1.tgz",
+ "integrity": "sha512-YUifsXXuknHlUsmlgyY0PKzgPOr7/FjCePfHNt0jxm83wHZi44VDMQ7/fGNkjY3/jV1MC+1CmZbaHzugyeRtpg==",
+ "dev": true,
+ "license": "MIT"
+ },
"node_modules/cssesc": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/cssesc/-/cssesc-3.0.0.tgz",
@@ -3280,6 +4536,58 @@
"integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==",
"license": "MIT"
},
+ "node_modules/data-urls": {
+ "version": "7.0.0",
+ "resolved": "https://registry.npmjs.org/data-urls/-/data-urls-7.0.0.tgz",
+ "integrity": "sha512-23XHcCF+coGYevirZceTVD7NdJOqVn+49IHyxgszm+JIiHLoB2TkmPtsYkNWT1pvRSGkc35L6NHs0yHkN2SumA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "whatwg-mimetype": "^5.0.0",
+ "whatwg-url": "^16.0.0"
+ },
+ "engines": {
+ "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+ }
+ },
+ "node_modules/data-urls/node_modules/tr46": {
+ "version": "6.0.0",
+ "resolved": "https://registry.npmjs.org/tr46/-/tr46-6.0.0.tgz",
+ "integrity": "sha512-bLVMLPtstlZ4iMQHpFHTR7GAGj2jxi8Dg0s2h2MafAE4uSWF98FC/3MomU51iQAMf8/qDUbKWf5GxuvvVcXEhw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "punycode": "^2.3.1"
+ },
+ "engines": {
+ "node": ">=20"
+ }
+ },
+ "node_modules/data-urls/node_modules/webidl-conversions": {
+ "version": "8.0.1",
+ "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-8.0.1.tgz",
+ "integrity": "sha512-BMhLD/Sw+GbJC21C/UgyaZX41nPt8bUTg+jWyDeg7e7YN4xOM05YPSIXceACnXVtqyEw/LMClUQMtMZ+PGGpqQ==",
+ "dev": true,
+ "license": "BSD-2-Clause",
+ "engines": {
+ "node": ">=20"
+ }
+ },
+ "node_modules/data-urls/node_modules/whatwg-url": {
+ "version": "16.0.1",
+ "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-16.0.1.tgz",
+ "integrity": "sha512-1to4zXBxmXHV3IiSSEInrreIlu02vUOvrhxJJH5vcxYTBDAx51cqZiKdyTxlecdKNSjj8EcxGBxNf6Vg+945gw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@exodus/bytes": "^1.11.0",
+ "tr46": "^6.0.0",
+ "webidl-conversions": "^8.0.1"
+ },
+ "engines": {
+ "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+ }
+ },
"node_modules/debug": {
"version": "4.3.7",
"resolved": "https://registry.npmjs.org/debug/-/debug-4.3.7.tgz",
@@ -3297,6 +4605,13 @@
}
}
},
+ "node_modules/decimal.js": {
+ "version": "10.6.0",
+ "resolved": "https://registry.npmjs.org/decimal.js/-/decimal.js-10.6.0.tgz",
+ "integrity": "sha512-YpgQiITW3JXGntzdUmyUR1V812Hn8T1YVXhCu+wO3OpS4eU9l4YdD3qjyiKdV6mvV29zapkMeD390UVEf2lkUg==",
+ "dev": true,
+ "license": "MIT"
+ },
"node_modules/decode-named-character-reference": {
"version": "1.2.0",
"resolved": "https://registry.npmjs.org/decode-named-character-reference/-/decode-named-character-reference-1.2.0.tgz",
@@ -3329,6 +4644,16 @@
"node": ">=6"
}
},
+ "node_modules/detect-libc": {
+ "version": "2.1.2",
+ "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz",
+ "integrity": "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==",
+ "dev": true,
+ "license": "Apache-2.0",
+ "engines": {
+ "node": ">=8"
+ }
+ },
"node_modules/detect-node-es": {
"version": "1.1.0",
"resolved": "https://registry.npmjs.org/detect-node-es/-/detect-node-es-1.1.0.tgz",
@@ -3359,6 +4684,14 @@
"integrity": "sha512-+HlytyjlPKnIG8XuRG8WvmBP8xs8P71y+SKKS6ZXWoEgLuePxtDoUEiH7WkdePWrQ5JBpE6aoVqfZfJUQkjXwA==",
"license": "MIT"
},
+ "node_modules/dom-accessibility-api": {
+ "version": "0.5.16",
+ "resolved": "https://registry.npmjs.org/dom-accessibility-api/-/dom-accessibility-api-0.5.16.tgz",
+ "integrity": "sha512-X7BJ2yElsnOJ30pZF4uIIDfBEVgF4XEBxL9Bxhy6dnrm5hkzqmsWHGTiHqRiITNhMyFLyAiWndIJP7Z1NTteDg==",
+ "dev": true,
+ "license": "MIT",
+ "peer": true
+ },
"node_modules/dotenv": {
"version": "17.4.2",
"resolved": "https://registry.npmjs.org/dotenv/-/dotenv-17.4.2.tgz",
@@ -3387,6 +4720,13 @@
"dev": true,
"license": "ISC"
},
+ "node_modules/emoji-regex": {
+ "version": "8.0.0",
+ "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+ "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+ "dev": true,
+ "license": "MIT"
+ },
"node_modules/enabled": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/enabled/-/enabled-2.0.0.tgz",
@@ -3426,6 +4766,13 @@
"node": ">= 0.4"
}
},
+ "node_modules/es-module-lexer": {
+ "version": "2.3.2",
+ "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-2.3.2.tgz",
+ "integrity": "sha512-poHGpORABojJJucnV9KbOavETW8lBVnphkW77ER5/BQ5Fz7oXSoCNek7IH3vR5nRjdsEz926ibFYX8KtLQmdyw==",
+ "dev": true,
+ "license": "MIT"
+ },
"node_modules/escalade": {
"version": "3.2.0",
"resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
@@ -3454,6 +4801,16 @@
"url": "https://opencollective.com/unified"
}
},
+ "node_modules/estree-walker": {
+ "version": "3.0.3",
+ "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-3.0.3.tgz",
+ "integrity": "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/estree": "^1.0.0"
+ }
+ },
"node_modules/eventemitter3": {
"version": "5.0.4",
"resolved": "https://registry.npmjs.org/eventemitter3/-/eventemitter3-5.0.4.tgz",
@@ -3461,6 +4818,16 @@
"dev": true,
"license": "MIT"
},
+ "node_modules/expect-type": {
+ "version": "1.4.0",
+ "resolved": "https://registry.npmjs.org/expect-type/-/expect-type-1.4.0.tgz",
+ "integrity": "sha512-KfYbmpRm0VbLjEvVa9yGwCi9GI34xvi7A/HXYWQO65CSD2u3MczUJSuwXKFIxlGsgBQizV9q5J9NHj4VG0n+pA==",
+ "dev": true,
+ "license": "Apache-2.0",
+ "engines": {
+ "node": ">=12.0.0"
+ }
+ },
"node_modules/extend": {
"version": "3.0.2",
"resolved": "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz",
@@ -3483,6 +4850,33 @@
"node": ">=8.6.0"
}
},
+ "node_modules/fast-string-truncated-width": {
+ "version": "3.0.3",
+ "resolved": "https://registry.npmjs.org/fast-string-truncated-width/-/fast-string-truncated-width-3.0.3.tgz",
+ "integrity": "sha512-0jjjIEL6+0jag3l2XWWizO64/aZVtpiGE3t0Zgqxv0DPuxiMjvB3M24fCyhZUO4KomJQPj3LTSUnDP3GpdwC0g==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/fast-string-width": {
+ "version": "3.0.2",
+ "resolved": "https://registry.npmjs.org/fast-string-width/-/fast-string-width-3.0.2.tgz",
+ "integrity": "sha512-gX8LrtNEI5hq8DVUfRQMbr5lpaS4nMIWV+7XEbXk2b8kiQIizgnlr12B4dA3ZEx3308ze0O4Q1R+cHts8kyUJg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "fast-string-truncated-width": "^3.0.2"
+ }
+ },
+ "node_modules/fast-wrap-ansi": {
+ "version": "0.2.2",
+ "resolved": "https://registry.npmjs.org/fast-wrap-ansi/-/fast-wrap-ansi-0.2.2.tgz",
+ "integrity": "sha512-7F2Fl+TjRSenLqlU3UjSH0iyqopqoZIu7eZVpEirP2g1GtWa2G/ecEmBdgz31+Mxr+ELclgg6sokpSFIQiZ02Q==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "fast-string-width": "^3.0.2"
+ }
+ },
"node_modules/fastq": {
"version": "1.20.1",
"resolved": "https://registry.npmjs.org/fastq/-/fastq-1.20.1.tgz",
@@ -3668,6 +5062,16 @@
"url": "https://github.com/sponsors/krisk"
}
},
+ "node_modules/get-caller-file": {
+ "version": "2.0.5",
+ "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz",
+ "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==",
+ "dev": true,
+ "license": "ISC",
+ "engines": {
+ "node": "6.* || 8.* || >= 10.*"
+ }
+ },
"node_modules/get-east-asian-width": {
"version": "1.6.0",
"resolved": "https://registry.npmjs.org/get-east-asian-width/-/get-east-asian-width-1.6.0.tgz",
@@ -3715,6 +5119,26 @@
"node": ">= 6"
}
},
+ "node_modules/graphql": {
+ "version": "16.14.2",
+ "resolved": "https://registry.npmjs.org/graphql/-/graphql-16.14.2.tgz",
+ "integrity": "sha512-Chq1s4CY7jmh8gO2qvLIJyfCDIN+EHLFW/9iShnp1z8FjBQMoodWP1kDC36VAMXXIvAjj4ARa7ntfAV2BrjsbA==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": "^12.22.0 || ^14.16.0 || ^16.0.0 || >=17.0.0"
+ }
+ },
+ "node_modules/has-flag": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
+ "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
"node_modules/hasown": {
"version": "2.0.4",
"resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.4.tgz",
@@ -3912,6 +5336,17 @@
"url": "https://opencollective.com/unified"
}
},
+ "node_modules/headers-polyfill": {
+ "version": "5.0.1",
+ "resolved": "https://registry.npmjs.org/headers-polyfill/-/headers-polyfill-5.0.1.tgz",
+ "integrity": "sha512-1TJ6Fih/b8h5TIcv+1+Hw0PDQWJTKDKzFZzcKOiW1wJza3XoAQlkCuXLbymPYB8+ZQyw8mHvdw560e8zVFIWyA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/set-cookie-parser": "^2.4.10",
+ "set-cookie-parser": "^3.0.1"
+ }
+ },
"node_modules/highlight.js": {
"version": "10.7.3",
"resolved": "https://registry.npmjs.org/highlight.js/-/highlight.js-10.7.3.tgz",
@@ -3927,6 +5362,26 @@
"integrity": "sha512-PDEfEF102G23vHmPhLyPboFCD+BkMGu+GuJe2d9/eH4FsCwvgBpnc9n0pGE+ffKdph38s6foEZiEjdgHdzp+IA==",
"license": "CC0-1.0"
},
+ "node_modules/html-encoding-sniffer": {
+ "version": "6.0.0",
+ "resolved": "https://registry.npmjs.org/html-encoding-sniffer/-/html-encoding-sniffer-6.0.0.tgz",
+ "integrity": "sha512-CV9TW3Y3f8/wT0BRFc1/KAVQ3TUHiXmaAb6VW9vtiMFf7SLoMd1PdAc4W3KFOFETBJUb90KatHqlsZMWV+R9Gg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@exodus/bytes": "^1.6.0"
+ },
+ "engines": {
+ "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+ }
+ },
+ "node_modules/html-escaper": {
+ "version": "2.0.2",
+ "resolved": "https://registry.npmjs.org/html-escaper/-/html-escaper-2.0.2.tgz",
+ "integrity": "sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==",
+ "dev": true,
+ "license": "MIT"
+ },
"node_modules/html-url-attributes": {
"version": "3.0.1",
"resolved": "https://registry.npmjs.org/html-url-attributes/-/html-url-attributes-3.0.1.tgz",
@@ -3961,6 +5416,16 @@
"url": "https://github.com/sponsors/typicode"
}
},
+ "node_modules/indent-string": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/indent-string/-/indent-string-4.0.0.tgz",
+ "integrity": "sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
"node_modules/inherits": {
"version": "2.0.4",
"resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
@@ -4080,6 +5545,13 @@
"url": "https://github.com/sponsors/wooorm"
}
},
+ "node_modules/is-node-process": {
+ "version": "1.2.0",
+ "resolved": "https://registry.npmjs.org/is-node-process/-/is-node-process-1.2.0.tgz",
+ "integrity": "sha512-Vg4o6/fqPxIjtxgUH5QLJhwZ7gW5diGCVlXpuUfELC62CuxM1iHcRe51f2W1FDy04Ai4KJkagKjx3XaqyfRKXw==",
+ "dev": true,
+ "license": "MIT"
+ },
"node_modules/is-number": {
"version": "7.0.0",
"resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
@@ -4101,6 +5573,13 @@
"url": "https://github.com/sponsors/sindresorhus"
}
},
+ "node_modules/is-potential-custom-element-name": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/is-potential-custom-element-name/-/is-potential-custom-element-name-1.0.1.tgz",
+ "integrity": "sha512-bCYeRA2rVibKZd+s2625gGnGF/t7DSqDs4dP7CrLA1m7jKWz6pps0LpYLJN8Q64HtmPKJ1hrN3nzPNKFEKOUiQ==",
+ "dev": true,
+ "license": "MIT"
+ },
"node_modules/is-stream": {
"version": "2.0.1",
"resolved": "https://registry.npmjs.org/is-stream/-/is-stream-2.0.1.tgz",
@@ -4113,6 +5592,45 @@
"url": "https://github.com/sponsors/sindresorhus"
}
},
+ "node_modules/istanbul-lib-coverage": {
+ "version": "3.2.2",
+ "resolved": "https://registry.npmjs.org/istanbul-lib-coverage/-/istanbul-lib-coverage-3.2.2.tgz",
+ "integrity": "sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg==",
+ "dev": true,
+ "license": "BSD-3-Clause",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/istanbul-lib-report": {
+ "version": "3.0.1",
+ "resolved": "https://registry.npmjs.org/istanbul-lib-report/-/istanbul-lib-report-3.0.1.tgz",
+ "integrity": "sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw==",
+ "dev": true,
+ "license": "BSD-3-Clause",
+ "dependencies": {
+ "istanbul-lib-coverage": "^3.0.0",
+ "make-dir": "^4.0.0",
+ "supports-color": "^7.1.0"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/istanbul-reports": {
+ "version": "3.2.0",
+ "resolved": "https://registry.npmjs.org/istanbul-reports/-/istanbul-reports-3.2.0.tgz",
+ "integrity": "sha512-HGYWWS/ehqTV3xN10i23tkPkpH46MLCIMFNCaaKNavAXTF1RkqxawEPtnjnGZ6XKSInBKkiOA5BKS+aZiY3AvA==",
+ "dev": true,
+ "license": "BSD-3-Clause",
+ "dependencies": {
+ "html-escaper": "^2.0.0",
+ "istanbul-lib-report": "^3.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
"node_modules/jiti": {
"version": "2.7.0",
"resolved": "https://registry.npmjs.org/jiti/-/jiti-2.7.0.tgz",
@@ -4129,6 +5647,111 @@
"integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
"license": "MIT"
},
+ "node_modules/jsdom": {
+ "version": "30.0.1",
+ "resolved": "https://registry.npmjs.org/jsdom/-/jsdom-30.0.1.tgz",
+ "integrity": "sha512-52v7mUVUfNQVYYqE1lcdaymWL0njO7lTLUog6ZvW2U5KsbiLk/GnZlVJ+qx0xfNJZ6Gn+KSpPNE52vurbxZwrA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@asamuzakjp/css-color": "^6.0.5",
+ "@asamuzakjp/dom-selector": "^8.3.0",
+ "@bramus/specificity": "^2.4.2",
+ "@csstools/css-syntax-patches-for-csstree": "^1.1.7",
+ "@exodus/bytes": "^1.15.1",
+ "css-tree": "^3.2.1",
+ "data-urls": "^7.0.0",
+ "decimal.js": "^10.6.0",
+ "html-encoding-sniffer": "^6.0.0",
+ "is-potential-custom-element-name": "^1.0.1",
+ "lru-cache": "^11.5.2",
+ "parse5": "^8.0.1",
+ "saxes": "^6.0.0",
+ "symbol-tree": "^3.2.4",
+ "tough-cookie": "^6.0.2",
+ "undici": "^8.9.0",
+ "w3c-xmlserializer": "^5.0.0",
+ "webidl-conversions": "^8.0.1",
+ "whatwg-mimetype": "^5.0.0",
+ "whatwg-url": "^17.1.0",
+ "xml-name-validator": "^5.0.0"
+ },
+ "engines": {
+ "node": "^22.22.2 || ^24.15.0 || >=26.0.0"
+ },
+ "peerDependencies": {
+ "canvas": "^3.2.3"
+ },
+ "peerDependenciesMeta": {
+ "canvas": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/jsdom/node_modules/entities": {
+ "version": "8.1.0",
+ "resolved": "https://registry.npmjs.org/entities/-/entities-8.1.0.tgz",
+ "integrity": "sha512-kxL7msIffSuh9aaFAMD7rxAIuTRMAHMeBtgHW2yUdWw732ZNh4MehkF2gdjvtdmikkaIP9bFDDJOPlsvm7avrA==",
+ "dev": true,
+ "license": "BSD-2-Clause",
+ "engines": {
+ "node": ">=20.19.0"
+ },
+ "funding": {
+ "url": "https://github.com/fb55/entities?sponsor=1"
+ }
+ },
+ "node_modules/jsdom/node_modules/parse5": {
+ "version": "8.0.1",
+ "resolved": "https://registry.npmjs.org/parse5/-/parse5-8.0.1.tgz",
+ "integrity": "sha512-z1e/HMG90obSGeidlli3hj7cbocou0/wa5HacvI3ASx34PecNjNQeaHNo5WIZpWofN9kgkqV1q5YvXe3F0FoPw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "entities": "^8.0.0"
+ },
+ "funding": {
+ "url": "https://github.com/inikulin/parse5?sponsor=1"
+ }
+ },
+ "node_modules/jsdom/node_modules/tr46": {
+ "version": "6.0.0",
+ "resolved": "https://registry.npmjs.org/tr46/-/tr46-6.0.0.tgz",
+ "integrity": "sha512-bLVMLPtstlZ4iMQHpFHTR7GAGj2jxi8Dg0s2h2MafAE4uSWF98FC/3MomU51iQAMf8/qDUbKWf5GxuvvVcXEhw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "punycode": "^2.3.1"
+ },
+ "engines": {
+ "node": ">=20"
+ }
+ },
+ "node_modules/jsdom/node_modules/webidl-conversions": {
+ "version": "8.0.1",
+ "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-8.0.1.tgz",
+ "integrity": "sha512-BMhLD/Sw+GbJC21C/UgyaZX41nPt8bUTg+jWyDeg7e7YN4xOM05YPSIXceACnXVtqyEw/LMClUQMtMZ+PGGpqQ==",
+ "dev": true,
+ "license": "BSD-2-Clause",
+ "engines": {
+ "node": ">=20"
+ }
+ },
+ "node_modules/jsdom/node_modules/whatwg-url": {
+ "version": "17.1.0",
+ "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-17.1.0.tgz",
+ "integrity": "sha512-3GeworPmc2ZfEEHP7lEbUfBX/L75wdEsi0rLNhXcXxnoN5jyq0SL5gCy06SGW2cyTIZdTvWIDQNQoza++vKeaw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@exodus/bytes": "^1.15.1",
+ "tr46": "^6.0.0",
+ "webidl-conversions": "^8.0.1"
+ },
+ "engines": {
+ "node": "^22.14.0 || >=24.0.0"
+ }
+ },
"node_modules/knip": {
"version": "6.23.0",
"resolved": "https://registry.npmjs.org/knip/-/knip-6.23.0.tgz",
@@ -4173,20 +5796,293 @@
"resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-5.0.3.tgz",
"integrity": "sha512-1tB5mhVo7U+ETBKNf92xT4hrQa3pm0MZ0PQvuDnWgAAGHDsfp4lPSpiS6psrSiet87wyGPh9ft6wmhOMQ0hDiw==",
"dev": true,
- "license": "MIT",
+ "license": "MIT",
+ "engines": {
+ "node": ">=14.16"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/kuler": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/kuler/-/kuler-2.0.0.tgz",
+ "integrity": "sha512-Xq9nH7KlWZmXAtodXDDRE7vs6DU1gTU8zYDHDiWLSip45Egwq3plLHzPn27NgvzL2r1LMPC1vdqh98sQxtqj4A==",
+ "license": "MIT"
+ },
+ "node_modules/lightningcss": {
+ "version": "1.33.0",
+ "resolved": "https://registry.npmjs.org/lightningcss/-/lightningcss-1.33.0.tgz",
+ "integrity": "sha512-WkUDrojuJs0xkgGf2udWxa3yGBRxPtxUkB79i6aCZLRgc7PM8fZe9TosfPDcvEpQZbuFASnHYmRLBLUbmLOIIA==",
+ "dev": true,
+ "license": "MPL-2.0",
+ "dependencies": {
+ "detect-libc": "^2.0.3"
+ },
+ "engines": {
+ "node": ">= 12.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/parcel"
+ },
+ "optionalDependencies": {
+ "lightningcss-android-arm64": "1.33.0",
+ "lightningcss-darwin-arm64": "1.33.0",
+ "lightningcss-darwin-x64": "1.33.0",
+ "lightningcss-freebsd-x64": "1.33.0",
+ "lightningcss-linux-arm-gnueabihf": "1.33.0",
+ "lightningcss-linux-arm64-gnu": "1.33.0",
+ "lightningcss-linux-arm64-musl": "1.33.0",
+ "lightningcss-linux-x64-gnu": "1.33.0",
+ "lightningcss-linux-x64-musl": "1.33.0",
+ "lightningcss-win32-arm64-msvc": "1.33.0",
+ "lightningcss-win32-x64-msvc": "1.33.0"
+ }
+ },
+ "node_modules/lightningcss-android-arm64": {
+ "version": "1.33.0",
+ "resolved": "https://registry.npmjs.org/lightningcss-android-arm64/-/lightningcss-android-arm64-1.33.0.tgz",
+ "integrity": "sha512-gEpRTalKdosp4Bb8qWtc2iOgE5SeIHlpS1up9bFq2wAyYhl1UdTObYiHe98zEM9SQvSoqQZ1IQD0JNpg3Ml5pg==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MPL-2.0",
+ "optional": true,
+ "os": [
+ "android"
+ ],
+ "engines": {
+ "node": ">= 12.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/parcel"
+ }
+ },
+ "node_modules/lightningcss-darwin-arm64": {
+ "version": "1.33.0",
+ "resolved": "https://registry.npmjs.org/lightningcss-darwin-arm64/-/lightningcss-darwin-arm64-1.33.0.tgz",
+ "integrity": "sha512-Sciaz8eenNTKn9b3t7+xr0ipTp9YxKQY4npwQ3mrRuL0BAVHBLyZxofhaKBAVtzmtRZ/zTyo0/to4B1uWG/Djg==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MPL-2.0",
+ "optional": true,
+ "os": [
+ "darwin"
+ ],
+ "engines": {
+ "node": ">= 12.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/parcel"
+ }
+ },
+ "node_modules/lightningcss-darwin-x64": {
+ "version": "1.33.0",
+ "resolved": "https://registry.npmjs.org/lightningcss-darwin-x64/-/lightningcss-darwin-x64-1.33.0.tgz",
+ "integrity": "sha512-Z5UPAxzrjlWNNyGy6i65cJzzvgJ5D3T6wMvs+gWpY9d7qRhANrxqAp6LhxIgZhWEw18RfJTGcRxjuLIBr+m8XQ==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MPL-2.0",
+ "optional": true,
+ "os": [
+ "darwin"
+ ],
+ "engines": {
+ "node": ">= 12.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/parcel"
+ }
+ },
+ "node_modules/lightningcss-freebsd-x64": {
+ "version": "1.33.0",
+ "resolved": "https://registry.npmjs.org/lightningcss-freebsd-x64/-/lightningcss-freebsd-x64-1.33.0.tgz",
+ "integrity": "sha512-QQM/Ti/hQajJwCY+RiWuCZ9sdtI/XQk7nDK5vC8kkdwixezOlDgvDx7+RT+QjK6FcFT4MpsuoBnHIo/O3StRRg==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MPL-2.0",
+ "optional": true,
+ "os": [
+ "freebsd"
+ ],
+ "engines": {
+ "node": ">= 12.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/parcel"
+ }
+ },
+ "node_modules/lightningcss-linux-arm-gnueabihf": {
+ "version": "1.33.0",
+ "resolved": "https://registry.npmjs.org/lightningcss-linux-arm-gnueabihf/-/lightningcss-linux-arm-gnueabihf-1.33.0.tgz",
+ "integrity": "sha512-N7FVBe6iS24MlM6R/4RBTxGhQheZGs7tiQ9U32UtF75NzP5Q7xWPRqLBCKxlRQRk3rY1jCIPLzx7WzOhuUIRLQ==",
+ "cpu": [
+ "arm"
+ ],
+ "dev": true,
+ "license": "MPL-2.0",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": ">= 12.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/parcel"
+ }
+ },
+ "node_modules/lightningcss-linux-arm64-gnu": {
+ "version": "1.33.0",
+ "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-gnu/-/lightningcss-linux-arm64-gnu-1.33.0.tgz",
+ "integrity": "sha512-j2v/itmy4HlNxlc6voKXYgBqNi0Ng2LShg4z7GufpEgs05P+2suBVyi9I6YHq5uoVFx9ETin3eCEhLVyXGQnKg==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "libc": [
+ "glibc"
+ ],
+ "license": "MPL-2.0",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": ">= 12.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/parcel"
+ }
+ },
+ "node_modules/lightningcss-linux-arm64-musl": {
+ "version": "1.33.0",
+ "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-musl/-/lightningcss-linux-arm64-musl-1.33.0.tgz",
+ "integrity": "sha512-yiO5ROMuYQgXbC60yjZU5CYSFZGKXL0HFATXt9mHJn1+zW55oCtMI9NfcVhYLMFDL7gV7oBPon/EmMMGg2OvtQ==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "libc": [
+ "musl"
+ ],
+ "license": "MPL-2.0",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": ">= 12.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/parcel"
+ }
+ },
+ "node_modules/lightningcss-linux-x64-gnu": {
+ "version": "1.33.0",
+ "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-gnu/-/lightningcss-linux-x64-gnu-1.33.0.tgz",
+ "integrity": "sha512-ar+Ju7LmcN0Jo4FpL4hpFybwNG9/3A/Br5KW2n2jyODg3MEZXaDYADdemoNS+BDNfMgKvylJLj4S5tyRActuAg==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "libc": [
+ "glibc"
+ ],
+ "license": "MPL-2.0",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": ">= 12.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/parcel"
+ }
+ },
+ "node_modules/lightningcss-linux-x64-musl": {
+ "version": "1.33.0",
+ "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-musl/-/lightningcss-linux-x64-musl-1.33.0.tgz",
+ "integrity": "sha512-RYiYbkokw0trfKqqzfF55lginwEPrD3OJDfTuJzFs1MK6iFnDenaz1fqLLtX4ITG3OktJQXOeTaw1awrBAlZPw==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "libc": [
+ "musl"
+ ],
+ "license": "MPL-2.0",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": ">= 12.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/parcel"
+ }
+ },
+ "node_modules/lightningcss-win32-arm64-msvc": {
+ "version": "1.33.0",
+ "resolved": "https://registry.npmjs.org/lightningcss-win32-arm64-msvc/-/lightningcss-win32-arm64-msvc-1.33.0.tgz",
+ "integrity": "sha512-1K+MPfLSFVpphzpdbfkhlWk6wBrTObBzS2T6db10PNOZgR9GoVsAWzwNyuhUYYbTp23j+4RrncfujZ4uAzXvwA==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MPL-2.0",
+ "optional": true,
+ "os": [
+ "win32"
+ ],
+ "engines": {
+ "node": ">= 12.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/parcel"
+ }
+ },
+ "node_modules/lightningcss-win32-x64-msvc": {
+ "version": "1.33.0",
+ "resolved": "https://registry.npmjs.org/lightningcss-win32-x64-msvc/-/lightningcss-win32-x64-msvc-1.33.0.tgz",
+ "integrity": "sha512-OlEICDx/Xl0FqSp4bry8zFnCvGpig3Gl4gCquvYwHuqJKEC1+n9NgDniFvqHGmMv1ZkqDJrDqKKSykTDX+ehuA==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MPL-2.0",
+ "optional": true,
+ "os": [
+ "win32"
+ ],
"engines": {
- "node": ">=14.16"
+ "node": ">= 12.0.0"
},
"funding": {
- "url": "https://github.com/sponsors/sindresorhus"
+ "type": "opencollective",
+ "url": "https://opencollective.com/parcel"
}
},
- "node_modules/kuler": {
- "version": "2.0.0",
- "resolved": "https://registry.npmjs.org/kuler/-/kuler-2.0.0.tgz",
- "integrity": "sha512-Xq9nH7KlWZmXAtodXDDRE7vs6DU1gTU8zYDHDiWLSip45Egwq3plLHzPn27NgvzL2r1LMPC1vdqh98sQxtqj4A==",
- "license": "MIT"
- },
"node_modules/lilconfig": {
"version": "3.1.3",
"resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-3.1.3.tgz",
@@ -4411,6 +6307,16 @@
"url": "https://github.com/sponsors/wooorm"
}
},
+ "node_modules/lru-cache": {
+ "version": "11.5.2",
+ "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.5.2.tgz",
+ "integrity": "sha512-4pfM1Ff0x50o0tQwb5ucw/RzNyD0/YJME6IVcStalZuMWxdt3sR3huStTtxz4PUmvZfRguvDejasvQ2kifR11g==",
+ "dev": true,
+ "license": "BlueOak-1.0.0",
+ "engines": {
+ "node": "20 || >=22"
+ }
+ },
"node_modules/lucide-react": {
"version": "1.22.0",
"resolved": "https://registry.npmjs.org/lucide-react/-/lucide-react-1.22.0.tgz",
@@ -4420,6 +6326,55 @@
"react": "^16.5.1 || ^17.0.0 || ^18.0.0 || ^19.0.0"
}
},
+ "node_modules/lz-string": {
+ "version": "1.5.0",
+ "resolved": "https://registry.npmjs.org/lz-string/-/lz-string-1.5.0.tgz",
+ "integrity": "sha512-h5bgJWpxJNswbU7qCrV0tIKQCaS3blPDrqKWx+QxzuzL1zGUzij9XCWLrSLsJPu5t+eWA/ycetzYAO5IOMcWAQ==",
+ "dev": true,
+ "license": "MIT",
+ "peer": true,
+ "bin": {
+ "lz-string": "bin/bin.js"
+ }
+ },
+ "node_modules/magic-string": {
+ "version": "0.30.21",
+ "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz",
+ "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@jridgewell/sourcemap-codec": "^1.5.5"
+ }
+ },
+ "node_modules/magicast": {
+ "version": "0.5.4",
+ "resolved": "https://registry.npmjs.org/magicast/-/magicast-0.5.4.tgz",
+ "integrity": "sha512-llBEhWm1SacoRwgHUoQJYtwp4PBLF4faQi5TCpIGyGs9n4y5+juI0tDgyKIfpqxckRHaHzouUEph3THklWh03w==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/parser": "^7.29.7",
+ "@babel/types": "^7.29.7",
+ "source-map-js": "^1.2.1"
+ }
+ },
+ "node_modules/make-dir": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-4.0.0.tgz",
+ "integrity": "sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "semver": "^7.5.3"
+ },
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
"node_modules/markdown-table": {
"version": "3.0.4",
"resolved": "https://registry.npmjs.org/markdown-table/-/markdown-table-3.0.4.tgz",
@@ -4723,6 +6678,13 @@
"url": "https://opencollective.com/unified"
}
},
+ "node_modules/mdn-data": {
+ "version": "2.27.1",
+ "resolved": "https://registry.npmjs.org/mdn-data/-/mdn-data-2.27.1.tgz",
+ "integrity": "sha512-9Yubnt3e8A0OKwxYSXyhLymGW4sCufcLG6VdiDdUGVkPhpqLxlvP5vl1983gQjJl3tqbrM731mjaZaP68AgosQ==",
+ "dev": true,
+ "license": "CC0-1.0"
+ },
"node_modules/merge2": {
"version": "1.4.1",
"resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz",
@@ -5299,6 +7261,16 @@
"url": "https://github.com/sponsors/sindresorhus"
}
},
+ "node_modules/min-indent": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/min-indent/-/min-indent-1.0.1.tgz",
+ "integrity": "sha512-I9jwMn07Sy/IwOj3zVkVik2JTvgpaykDZEigL6Rx6N9LbMywwUSMtxET+7lVoDLLd3O3IXwJwvuuns8UB/HeAg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=4"
+ }
+ },
"node_modules/mini-svg-data-uri": {
"version": "1.4.4",
"resolved": "https://registry.npmjs.org/mini-svg-data-uri/-/mini-svg-data-uri-1.4.4.tgz",
@@ -5361,6 +7333,61 @@
"integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
"license": "MIT"
},
+ "node_modules/msw": {
+ "version": "2.15.0",
+ "resolved": "https://registry.npmjs.org/msw/-/msw-2.15.0.tgz",
+ "integrity": "sha512-2wQAmKkQKxRuXvYJxVhPGG0wZNBQyD06oJvxqw90XqLvptdqxdlHrFUfEteKkpaNORX3Xzc+HtEl/q0nfmN2wQ==",
+ "dev": true,
+ "hasInstallScript": true,
+ "license": "MIT",
+ "dependencies": {
+ "@inquirer/confirm": "^6.0.11",
+ "@mswjs/interceptors": "^0.41.3",
+ "@open-draft/deferred-promise": "^3.0.0",
+ "@types/statuses": "^2.0.6",
+ "cookie": "^1.1.1",
+ "graphql": "^16.13.2",
+ "headers-polyfill": "^5.0.1",
+ "is-node-process": "^1.2.0",
+ "outvariant": "^1.4.3",
+ "path-to-regexp": "^6.3.0",
+ "picocolors": "^1.1.1",
+ "rettime": "^0.11.11",
+ "statuses": "^2.0.2",
+ "strict-event-emitter": "^0.5.1",
+ "tough-cookie": "^6.0.1",
+ "type-fest": "^5.5.0",
+ "until-async": "^3.0.2",
+ "yargs": "^17.7.2"
+ },
+ "bin": {
+ "msw": "cli/index.js"
+ },
+ "engines": {
+ "node": ">=18"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/mswjs"
+ },
+ "peerDependencies": {
+ "typescript": ">= 4.8.x"
+ },
+ "peerDependenciesMeta": {
+ "typescript": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/mute-stream": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/mute-stream/-/mute-stream-3.0.0.tgz",
+ "integrity": "sha512-dkEJPVvun4FryqBmZ5KhDo0K9iDXAwn08tMLDinNdRBNPcYEDiWYysLcc6k3mjTMlbP9KyylvRpd4wFtwrT9rw==",
+ "dev": true,
+ "license": "ISC",
+ "engines": {
+ "node": "^20.17.0 || >=22.9.0"
+ }
+ },
"node_modules/mz": {
"version": "2.7.0",
"resolved": "https://registry.npmjs.org/mz/-/mz-2.7.0.tgz",
@@ -5528,6 +7555,20 @@
"node": ">= 6"
}
},
+ "node_modules/obug": {
+ "version": "2.1.4",
+ "resolved": "https://registry.npmjs.org/obug/-/obug-2.1.4.tgz",
+ "integrity": "sha512-4a+OsYv9UktOJKE+l1A4OufDgdRF9PifWj+tJnHURo/P+WOxpG4GzUFL9qCalmWauao6ogiG+QvnCovwPoyAWA==",
+ "dev": true,
+ "funding": [
+ "https://github.com/sponsors/sxzz",
+ "https://opencollective.com/debug"
+ ],
+ "license": "MIT",
+ "engines": {
+ "node": ">=12.20.0"
+ }
+ },
"node_modules/one-time": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/one-time/-/one-time-1.0.0.tgz",
@@ -5553,6 +7594,13 @@
"url": "https://github.com/sponsors/sindresorhus"
}
},
+ "node_modules/outvariant": {
+ "version": "1.4.3",
+ "resolved": "https://registry.npmjs.org/outvariant/-/outvariant-1.4.3.tgz",
+ "integrity": "sha512-+Sl2UErvtsoajRDKCE5/dBz4DIvHXQQnAxtQTF04OJxY0+DyZXSo5P5Bb7XYWOh81syohlYL24hbDwxedPUJCA==",
+ "dev": true,
+ "license": "MIT"
+ },
"node_modules/oxc-parser": {
"version": "0.137.0",
"resolved": "https://registry.npmjs.org/oxc-parser/-/oxc-parser-0.137.0.tgz",
@@ -5658,6 +7706,20 @@
"integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==",
"license": "MIT"
},
+ "node_modules/path-to-regexp": {
+ "version": "6.3.0",
+ "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-6.3.0.tgz",
+ "integrity": "sha512-Yhpw4T9C6hPpgPeA28us07OJeqZ5EzQTkbfwuhsUg0c237RomFoETJgmp2sa3F/41gfLE6G5cqcYwznmeEeOlQ==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/pathe": {
+ "version": "2.0.3",
+ "resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz",
+ "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==",
+ "dev": true,
+ "license": "MIT"
+ },
"node_modules/picocolors": {
"version": "1.1.1",
"resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
@@ -5745,7 +7807,6 @@
}
],
"license": "MIT",
- "peer": true,
"dependencies": {
"nanoid": "^3.3.17",
"picocolors": "^1.1.1",
@@ -5883,6 +7944,55 @@
"integrity": "sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ==",
"license": "MIT"
},
+ "node_modules/pretty-format": {
+ "version": "27.5.1",
+ "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-27.5.1.tgz",
+ "integrity": "sha512-Qb1gy5OrP5+zDf2Bvnzdl3jsTf1qXVMazbvCoKhtKqVs4/YK4ozX4gKQJJVyNe+cajNPn0KoC0MC3FUmaHWEmQ==",
+ "dev": true,
+ "license": "MIT",
+ "peer": true,
+ "dependencies": {
+ "ansi-regex": "^5.0.1",
+ "ansi-styles": "^5.0.0",
+ "react-is": "^17.0.1"
+ },
+ "engines": {
+ "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0"
+ }
+ },
+ "node_modules/pretty-format/node_modules/ansi-regex": {
+ "version": "5.0.1",
+ "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+ "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+ "dev": true,
+ "license": "MIT",
+ "peer": true,
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/pretty-format/node_modules/ansi-styles": {
+ "version": "5.2.0",
+ "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-5.2.0.tgz",
+ "integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==",
+ "dev": true,
+ "license": "MIT",
+ "peer": true,
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+ }
+ },
+ "node_modules/pretty-format/node_modules/react-is": {
+ "version": "17.0.2",
+ "resolved": "https://registry.npmjs.org/react-is/-/react-is-17.0.2.tgz",
+ "integrity": "sha512-w2GsyukL62IJnlaff/nRegPQR94C/XXamvMWmSHRJ4y7Ts/4ocGRmTHvOs8PSE6pB3dWOrD/nueuU5sduBsQ4w==",
+ "dev": true,
+ "license": "MIT",
+ "peer": true
+ },
"node_modules/prismjs": {
"version": "1.30.0",
"resolved": "https://registry.npmjs.org/prismjs/-/prismjs-1.30.0.tgz",
@@ -5925,6 +8035,16 @@
"url": "https://github.com/sponsors/wooorm"
}
},
+ "node_modules/punycode": {
+ "version": "2.3.1",
+ "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
+ "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=6"
+ }
+ },
"node_modules/queue-microtask": {
"version": "1.2.3",
"resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz",
@@ -5950,7 +8070,6 @@
"resolved": "https://registry.npmjs.org/react/-/react-19.2.7.tgz",
"integrity": "sha512-HNe9WslTbXmFK8o8cmwgAeJFSBvt1bPdHCVKtaaV+WlAN36mpT4hcRpwbf3fY56ar2oIXzsBpOAiIRHAdY0OlQ==",
"license": "MIT",
- "peer": true,
"engines": {
"node": ">=0.10.0"
}
@@ -5960,7 +8079,6 @@
"resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.2.7.tgz",
"integrity": "sha512-t0BRVXvbiE/o20Hfw669rLbMCDWtYZLvmJigy2f0MxsXF+71pxhR3xOkspmsO8h3ZlNzyibAmtCa3l4lYKk6gQ==",
"license": "MIT",
- "peer": true,
"dependencies": {
"scheduler": "^0.27.0"
},
@@ -6174,6 +8292,20 @@
"node": ">=8.10.0"
}
},
+ "node_modules/redent": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/redent/-/redent-3.0.0.tgz",
+ "integrity": "sha512-6tDA8g98We0zd0GvVeMT9arEOnTw9qM03L9cJXaCjrip1OO764RDBLBfrB4cwzNGDj5OA5ioymC9GkizgWJDUg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "indent-string": "^4.0.0",
+ "strip-indent": "^3.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
"node_modules/refractor": {
"version": "5.0.0",
"resolved": "https://registry.npmjs.org/refractor/-/refractor-5.0.0.tgz",
@@ -6285,6 +8417,26 @@
"url": "https://opencollective.com/unified"
}
},
+ "node_modules/require-directory": {
+ "version": "2.1.1",
+ "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",
+ "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/require-from-string": {
+ "version": "2.0.2",
+ "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz",
+ "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
"node_modules/resolve": {
"version": "1.22.12",
"resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.12.tgz",
@@ -6333,6 +8485,13 @@
"url": "https://github.com/sponsors/sindresorhus"
}
},
+ "node_modules/rettime": {
+ "version": "0.11.11",
+ "resolved": "https://registry.npmjs.org/rettime/-/rettime-0.11.11.tgz",
+ "integrity": "sha512-ILJRqVWBCTlg9r42fFgwVZx1gnFAcQF8mRoMkbgQfIrjEDf9nbBFDFx00oloOa+Q869FUtaYDXZvEfnecQSCoQ==",
+ "dev": true,
+ "license": "MIT"
+ },
"node_modules/reusify": {
"version": "1.1.0",
"resolved": "https://registry.npmjs.org/reusify/-/reusify-1.1.0.tgz",
@@ -6350,6 +8509,50 @@
"dev": true,
"license": "MIT"
},
+ "node_modules/rolldown": {
+ "version": "1.2.7",
+ "resolved": "https://registry.npmjs.org/rolldown/-/rolldown-1.2.7.tgz",
+ "integrity": "sha512-g0EtLvBjTUB7jhyV0S/TCup3v/XSVl45vUIGbOGU4QPiyjTenCe4mKuFvW9fEgYmS2Fo42AUssRmNuMziXdrig==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@oxc-project/types": "=0.148.0",
+ "@rolldown/pluginutils": "^1.0.0"
+ },
+ "bin": {
+ "rolldown": "bin/cli.mjs"
+ },
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ },
+ "optionalDependencies": {
+ "@rolldown/binding-android-arm-eabi": "1.2.7",
+ "@rolldown/binding-android-arm64": "1.2.7",
+ "@rolldown/binding-darwin-arm64": "1.2.7",
+ "@rolldown/binding-darwin-x64": "1.2.7",
+ "@rolldown/binding-freebsd-x64": "1.2.7",
+ "@rolldown/binding-linux-arm-gnueabihf": "1.2.7",
+ "@rolldown/binding-linux-arm64-gnu": "1.2.7",
+ "@rolldown/binding-linux-arm64-musl": "1.2.7",
+ "@rolldown/binding-linux-ppc64-gnu": "1.2.7",
+ "@rolldown/binding-linux-s390x-gnu": "1.2.7",
+ "@rolldown/binding-linux-x64-gnu": "1.2.7",
+ "@rolldown/binding-linux-x64-musl": "1.2.7",
+ "@rolldown/binding-openharmony-arm64": "1.2.7",
+ "@rolldown/binding-win32-arm64-msvc": "1.2.7",
+ "@rolldown/binding-win32-x64-msvc": "1.2.7"
+ }
+ },
+ "node_modules/rolldown/node_modules/@oxc-project/types": {
+ "version": "0.148.0",
+ "resolved": "https://registry.npmjs.org/@oxc-project/types/-/types-0.148.0.tgz",
+ "integrity": "sha512-Nm4s/jB+4FpFsPhWGEC4h7rzksesmtnMXomo6rCMcg/b8zLQuOziRgkCS1fxDCXOlJB/6Q8oABOZ/OP6RIPj9A==",
+ "dev": true,
+ "license": "MIT",
+ "funding": {
+ "url": "https://github.com/sponsors/oxc-project"
+ }
+ },
"node_modules/run-parallel": {
"version": "1.2.0",
"resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz",
@@ -6402,12 +8605,68 @@
"node": ">=10"
}
},
+ "node_modules/saxes": {
+ "version": "6.0.0",
+ "resolved": "https://registry.npmjs.org/saxes/-/saxes-6.0.0.tgz",
+ "integrity": "sha512-xAg7SOnEhrm5zI3puOOKyy1OMcMlIJZYNJY7xLBwSze0UjhPLnWfj2GF2EpT0jmzaJKIWKHLsaSSajf35bcYnA==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "xmlchars": "^2.2.0"
+ },
+ "engines": {
+ "node": ">=v12.22.7"
+ }
+ },
"node_modules/scheduler": {
"version": "0.27.0",
"resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.27.0.tgz",
"integrity": "sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q==",
"license": "MIT"
},
+ "node_modules/semver": {
+ "version": "7.5.4",
+ "resolved": "https://registry.npmjs.org/semver/-/semver-7.5.4.tgz",
+ "integrity": "sha512-1bCSESV6Pv+i21Hvpxp3Dx+pSD8lIPt8uVjRrxAUt/nbswYc+tK6Y2btiULjd4+fnq15PX+nqQDC7Oft7WkwcA==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "lru-cache": "^6.0.0"
+ },
+ "bin": {
+ "semver": "bin/semver.js"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/semver/node_modules/lru-cache": {
+ "version": "6.0.0",
+ "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz",
+ "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "yallist": "^4.0.0"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/set-cookie-parser": {
+ "version": "3.1.2",
+ "resolved": "https://registry.npmjs.org/set-cookie-parser/-/set-cookie-parser-3.1.2.tgz",
+ "integrity": "sha512-5/r/lTwbJ3zQ+qwdUFZYeRNqda7P5HD8zQKqlSjdGt1/S0cjLAphHusj4Y58ahDtWn/g32xrIS58/ikOvwl0Lw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/siginfo": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/siginfo/-/siginfo-2.0.0.tgz",
+ "integrity": "sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==",
+ "dev": true,
+ "license": "ISC"
+ },
"node_modules/signal-exit": {
"version": "4.1.0",
"resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz",
@@ -6502,6 +8761,37 @@
"node": "*"
}
},
+ "node_modules/stackback": {
+ "version": "0.0.2",
+ "resolved": "https://registry.npmjs.org/stackback/-/stackback-0.0.2.tgz",
+ "integrity": "sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/statuses": {
+ "version": "2.0.2",
+ "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.2.tgz",
+ "integrity": "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.8"
+ }
+ },
+ "node_modules/std-env": {
+ "version": "4.2.0",
+ "resolved": "https://registry.npmjs.org/std-env/-/std-env-4.2.0.tgz",
+ "integrity": "sha512-oCUKSupKTHX53EyjDtuZQ64pjLJ6yYCtpmEw0goYxtjG9KpbRe8KAsl2tBUGU9DyMcJ0RwJ8GqJAFzMXcXW1Rw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/strict-event-emitter": {
+ "version": "0.5.1",
+ "resolved": "https://registry.npmjs.org/strict-event-emitter/-/strict-event-emitter-0.5.1.tgz",
+ "integrity": "sha512-vMgjE/GGEPEFnhFub6pa4FmJBRBVOLpIII2hvCZ8Kzb7K0hlHo7mQv6xYrBvCL2LtAIBwFUK8wvuJgTVSQ5MFQ==",
+ "dev": true,
+ "license": "MIT"
+ },
"node_modules/string_decoder": {
"version": "1.3.0",
"resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz",
@@ -6567,6 +8857,19 @@
"url": "https://github.com/chalk/strip-ansi?sponsor=1"
}
},
+ "node_modules/strip-indent": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/strip-indent/-/strip-indent-3.0.0.tgz",
+ "integrity": "sha512-laJTa3Jb+VQpaC6DseHhF7dXVqHTfJPCRDaEbid/drOhgitgYku/letMUqOXFoWV0zIIUbjpdH2t+tYj4bQMRQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "min-indent": "^1.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
"node_modules/style-to-js": {
"version": "1.1.17",
"resolved": "https://registry.npmjs.org/style-to-js/-/style-to-js-1.1.17.tgz",
@@ -6637,6 +8940,19 @@
"node": ">= 6"
}
},
+ "node_modules/supports-color": {
+ "version": "7.2.0",
+ "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
+ "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "has-flag": "^4.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
"node_modules/supports-preserve-symlinks-flag": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz",
@@ -6649,6 +8965,26 @@
"url": "https://github.com/sponsors/ljharb"
}
},
+ "node_modules/symbol-tree": {
+ "version": "3.2.4",
+ "resolved": "https://registry.npmjs.org/symbol-tree/-/symbol-tree-3.2.4.tgz",
+ "integrity": "sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/tagged-tag": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/tagged-tag/-/tagged-tag-1.0.0.tgz",
+ "integrity": "sha512-yEFYrVhod+hdNyx7g5Bnkkb0G6si8HJurOoOEgC8B/O0uXLHlaey/65KRv6cuWBNhBgHKAROVpc7QyYqE5gFng==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=20"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
"node_modules/tailwind-merge": {
"version": "3.6.0",
"resolved": "https://registry.npmjs.org/tailwind-merge/-/tailwind-merge-3.6.0.tgz",
@@ -6664,7 +9000,6 @@
"resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-3.4.19.tgz",
"integrity": "sha512-3ofp+LL8E+pK/JuPLPggVAIaEuhvIz4qNcf3nA1Xn2o/7fb7s/TYpHhwGDv1ZU3PkBluUVaF8PyCHcm48cKLWQ==",
"license": "MIT",
- "peer": true,
"dependencies": {
"@alloc/quick-lru": "^5.2.0",
"arg": "^5.0.2",
@@ -6751,6 +9086,13 @@
"node": ">=0.8"
}
},
+ "node_modules/tinybench": {
+ "version": "2.9.0",
+ "resolved": "https://registry.npmjs.org/tinybench/-/tinybench-2.9.0.tgz",
+ "integrity": "sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==",
+ "dev": true,
+ "license": "MIT"
+ },
"node_modules/tinyexec": {
"version": "1.2.4",
"resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-1.2.4.tgz",
@@ -6777,6 +9119,36 @@
"url": "https://github.com/sponsors/SuperchupuDev"
}
},
+ "node_modules/tinyrainbow": {
+ "version": "3.1.1",
+ "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-3.1.1.tgz",
+ "integrity": "sha512-yau8yJdTt989Mm0Bd/236QnzEiPf2xLLTqUZRUJOo/3CB078LSwzei343DgtJVmfJKJE3TMINY1u42SQsP6mXw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=14.0.0"
+ }
+ },
+ "node_modules/tldts": {
+ "version": "7.4.12",
+ "resolved": "https://registry.npmjs.org/tldts/-/tldts-7.4.12.tgz",
+ "integrity": "sha512-WylhSDKVeYnWXL3a+vKTaOxjnOeEGw938hImY8zoRWJjRRK/Jp1K+IihBzIONpUmW4e3WmXT6q5FW6vlESVZCA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "tldts-core": "^7.4.12"
+ },
+ "bin": {
+ "tldts": "bin/cli.js"
+ }
+ },
+ "node_modules/tldts-core": {
+ "version": "7.4.12",
+ "resolved": "https://registry.npmjs.org/tldts-core/-/tldts-core-7.4.12.tgz",
+ "integrity": "sha512-nYNzS2WRf4QJmjzFFgAxLOBjyBxAGRbCy9PVBPaglcYyYajh40VBn+v5Ngr96ZMc7oM0+aCJdtQnNejvdBnXMQ==",
+ "dev": true,
+ "license": "MIT"
+ },
"node_modules/to-regex-range": {
"version": "5.0.1",
"resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
@@ -6789,6 +9161,19 @@
"node": ">=8.0"
}
},
+ "node_modules/tough-cookie": {
+ "version": "6.0.2",
+ "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-6.0.2.tgz",
+ "integrity": "sha512-exgYmnmL/sJpR3upZfXG5PoatXQii55xAiXGXzY+sROLZ/Y+SLcp9PgJNI9Vz37HpQ74WvDcLT8eqm+kV3FzrA==",
+ "dev": true,
+ "license": "BSD-3-Clause",
+ "dependencies": {
+ "tldts": "^7.0.5"
+ },
+ "engines": {
+ "node": ">=16"
+ }
+ },
"node_modules/tr46": {
"version": "0.0.3",
"resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz",
@@ -6835,6 +9220,22 @@
"integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
"license": "0BSD"
},
+ "node_modules/type-fest": {
+ "version": "5.9.0",
+ "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-5.9.0.tgz",
+ "integrity": "sha512-yANm3Jr3GiJ1qgJlxGAVxTOIcEOk1rhQHamlXtnrCK7EHP4HeM9OGxtMg/W7HFdrVzw/ZWJKGVIJusVH85sLtw==",
+ "dev": true,
+ "license": "(MIT OR CC0-1.0)",
+ "dependencies": {
+ "tagged-tag": "^1.0.0"
+ },
+ "engines": {
+ "node": ">=20"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
"node_modules/typescript": {
"version": "6.0.3",
"resolved": "https://registry.npmjs.org/typescript/-/typescript-6.0.3.tgz",
@@ -6859,6 +9260,16 @@
"node": ">=14"
}
},
+ "node_modules/undici": {
+ "version": "8.10.2",
+ "resolved": "https://registry.npmjs.org/undici/-/undici-8.10.2.tgz",
+ "integrity": "sha512-/y4/bH9YNU5hi9NIrpOuvGXFcxrj3CMrV+/AYpowAYTpHn8gX/XPFjNy766FPoYY0miQhdW977JFWKGNhBdwyQ==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=22.19.0"
+ }
+ },
"node_modules/undici-types": {
"version": "8.3.0",
"resolved": "https://registry.npmjs.org/undici-types/-/undici-types-8.3.0.tgz",
@@ -7001,6 +9412,16 @@
"resolved": "https://registry.npmjs.org/@types/unist/-/unist-3.0.3.tgz",
"integrity": "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q=="
},
+ "node_modules/until-async": {
+ "version": "3.0.2",
+ "resolved": "https://registry.npmjs.org/until-async/-/until-async-3.0.2.tgz",
+ "integrity": "sha512-IiSk4HlzAMqTUseHHe3VhIGyuFmN90zMTpD3Z3y8jeQbzLIq500MVM7Jq2vUAnTKAFPJrqwkzr6PoTcPhGcOiw==",
+ "dev": true,
+ "license": "MIT",
+ "funding": {
+ "url": "https://github.com/sponsors/kettanaito"
+ }
+ },
"node_modules/update-browserslist-db": {
"version": "1.2.3",
"resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.2.3.tgz",
@@ -7195,6 +9616,202 @@
"resolved": "https://registry.npmjs.org/@types/unist/-/unist-3.0.3.tgz",
"integrity": "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q=="
},
+ "node_modules/vite": {
+ "version": "8.2.2",
+ "resolved": "https://registry.npmjs.org/vite/-/vite-8.2.2.tgz",
+ "integrity": "sha512-cFKLV/PRgAUlIRm5WjMjJ86jrftzpqcgH+Us+DS8mI3CDNiH30Whrz8uHL3+MOLPAgqbMBAqWdAHAphOAM+z/Q==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "lightningcss": "^1.33.0",
+ "picomatch": "^4.0.5",
+ "postcss": "^8.5.26",
+ "rolldown": "~1.2.4",
+ "tinyglobby": "^0.2.17"
+ },
+ "bin": {
+ "vite": "bin/vite.js"
+ },
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ },
+ "funding": {
+ "url": "https://github.com/vitejs/vite?sponsor=1"
+ },
+ "optionalDependencies": {
+ "fsevents": "~2.3.3"
+ },
+ "peerDependencies": {
+ "@types/node": "^20.19.0 || >=22.12.0",
+ "@vitejs/devtools": "^0.4.0 || ^0.5.0",
+ "esbuild": "^0.27.0 || ^0.28.0",
+ "jiti": ">=1.21.0",
+ "less": "^4.0.0",
+ "sass": "^1.70.0",
+ "sass-embedded": "^1.70.0",
+ "stylus": ">=0.54.8",
+ "sugarss": "^5.0.0",
+ "terser": "^5.16.0",
+ "tsx": "^4.8.1",
+ "yaml": "^2.4.2"
+ },
+ "peerDependenciesMeta": {
+ "@types/node": {
+ "optional": true
+ },
+ "@vitejs/devtools": {
+ "optional": true
+ },
+ "esbuild": {
+ "optional": true
+ },
+ "jiti": {
+ "optional": true
+ },
+ "less": {
+ "optional": true
+ },
+ "sass": {
+ "optional": true
+ },
+ "sass-embedded": {
+ "optional": true
+ },
+ "stylus": {
+ "optional": true
+ },
+ "sugarss": {
+ "optional": true
+ },
+ "terser": {
+ "optional": true
+ },
+ "tsx": {
+ "optional": true
+ },
+ "yaml": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/vite/node_modules/fsevents": {
+ "version": "2.3.3",
+ "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+ "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+ "dev": true,
+ "hasInstallScript": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "darwin"
+ ],
+ "engines": {
+ "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+ }
+ },
+ "node_modules/vitest": {
+ "version": "4.1.11",
+ "resolved": "https://registry.npmjs.org/vitest/-/vitest-4.1.11.tgz",
+ "integrity": "sha512-fhACrNXUidIbGSBr5FlbuBkO7VWC1ZyLl0DO4CU2DrQoAPxX84Ysxs+HeGQpii5lZWV1Q4gBZTTu49mF+A6Edw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@vitest/expect": "4.1.11",
+ "@vitest/mocker": "4.1.11",
+ "@vitest/pretty-format": "4.1.11",
+ "@vitest/runner": "4.1.11",
+ "@vitest/snapshot": "4.1.11",
+ "@vitest/spy": "4.1.11",
+ "@vitest/utils": "4.1.11",
+ "es-module-lexer": "^2.0.0",
+ "expect-type": "^1.3.0",
+ "magic-string": "^0.30.21",
+ "obug": "^2.1.1",
+ "pathe": "^2.0.3",
+ "picomatch": "^4.0.3",
+ "std-env": "^4.0.0-rc.1",
+ "tinybench": "^2.9.0",
+ "tinyexec": "^1.0.2",
+ "tinyglobby": "^0.2.15",
+ "tinyrainbow": "^3.1.0",
+ "vite": "^6.0.0 || ^7.0.0 || ^8.0.0",
+ "why-is-node-running": "^2.3.0"
+ },
+ "bin": {
+ "vitest": "vitest.mjs"
+ },
+ "engines": {
+ "node": "^20.0.0 || ^22.0.0 || >=24.0.0"
+ },
+ "funding": {
+ "url": "https://opencollective.com/vitest"
+ },
+ "peerDependencies": {
+ "@edge-runtime/vm": "*",
+ "@opentelemetry/api": "^1.9.0",
+ "@types/node": "^20.0.0 || ^22.0.0 || >=24.0.0",
+ "@vitest/browser-playwright": "4.1.11",
+ "@vitest/browser-preview": "4.1.11",
+ "@vitest/browser-webdriverio": "4.1.11",
+ "@vitest/coverage-istanbul": "4.1.11",
+ "@vitest/coverage-v8": "4.1.11",
+ "@vitest/ui": "4.1.11",
+ "happy-dom": "*",
+ "jsdom": "*",
+ "vite": "^6.0.0 || ^7.0.0 || ^8.0.0"
+ },
+ "peerDependenciesMeta": {
+ "@edge-runtime/vm": {
+ "optional": true
+ },
+ "@opentelemetry/api": {
+ "optional": true
+ },
+ "@types/node": {
+ "optional": true
+ },
+ "@vitest/browser-playwright": {
+ "optional": true
+ },
+ "@vitest/browser-preview": {
+ "optional": true
+ },
+ "@vitest/browser-webdriverio": {
+ "optional": true
+ },
+ "@vitest/coverage-istanbul": {
+ "optional": true
+ },
+ "@vitest/coverage-v8": {
+ "optional": true
+ },
+ "@vitest/ui": {
+ "optional": true
+ },
+ "happy-dom": {
+ "optional": true
+ },
+ "jsdom": {
+ "optional": true
+ },
+ "vite": {
+ "optional": false
+ }
+ }
+ },
+ "node_modules/w3c-xmlserializer": {
+ "version": "5.0.0",
+ "resolved": "https://registry.npmjs.org/w3c-xmlserializer/-/w3c-xmlserializer-5.0.0.tgz",
+ "integrity": "sha512-o8qghlI8NZHU1lLPrpi2+Uq7abh4GGPpYANlalzWxyWteJOCsr/P+oPBA49TOLu5FTZO4d3F9MnWJfiMo4BkmA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "xml-name-validator": "^5.0.0"
+ },
+ "engines": {
+ "node": ">=18"
+ }
+ },
"node_modules/walk-up-path": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/walk-up-path/-/walk-up-path-4.0.0.tgz",
@@ -7220,6 +9837,16 @@
"integrity": "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==",
"license": "BSD-2-Clause"
},
+ "node_modules/whatwg-mimetype": {
+ "version": "5.0.0",
+ "resolved": "https://registry.npmjs.org/whatwg-mimetype/-/whatwg-mimetype-5.0.0.tgz",
+ "integrity": "sha512-sXcNcHOC51uPGF0P/D4NVtrkjSU2fNsm9iog4ZvZJsL3rjoDAzXZhkm2MWt1y+PUdggKAYVoMAIYcs78wJ51Cw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=20"
+ }
+ },
"node_modules/whatwg-url": {
"version": "5.0.0",
"resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz",
@@ -7230,6 +9857,23 @@
"webidl-conversions": "^3.0.0"
}
},
+ "node_modules/why-is-node-running": {
+ "version": "2.3.0",
+ "resolved": "https://registry.npmjs.org/why-is-node-running/-/why-is-node-running-2.3.0.tgz",
+ "integrity": "sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "siginfo": "^2.0.0",
+ "stackback": "0.0.2"
+ },
+ "bin": {
+ "why-is-node-running": "cli.js"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
"node_modules/wicked-good-xpath": {
"version": "1.3.0",
"resolved": "https://registry.npmjs.org/wicked-good-xpath/-/wicked-good-xpath-1.3.0.tgz",
@@ -7290,6 +9934,40 @@
"url": "https://github.com/chalk/wrap-ansi?sponsor=1"
}
},
+ "node_modules/xml-name-validator": {
+ "version": "5.0.0",
+ "resolved": "https://registry.npmjs.org/xml-name-validator/-/xml-name-validator-5.0.0.tgz",
+ "integrity": "sha512-EvGK8EJ3DhaHfbRlETOWAS5pO9MZITeauHKJyb8wyajUfQUenkIg2MvLDTZ4T/TgIcm3HU0TFBgWWboAZ30UHg==",
+ "dev": true,
+ "license": "Apache-2.0",
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/xmlchars": {
+ "version": "2.2.0",
+ "resolved": "https://registry.npmjs.org/xmlchars/-/xmlchars-2.2.0.tgz",
+ "integrity": "sha512-JZnDKK8B0RCDw84FNdDAIpZK+JuJw+s7Lz8nksI7SIuU3UXJJslUthsi+uWBUYOwPFwW7W7PRLRfUKpxjtjFCw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/y18n": {
+ "version": "5.0.8",
+ "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz",
+ "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==",
+ "dev": true,
+ "license": "ISC",
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/yallist": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",
+ "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==",
+ "dev": true,
+ "license": "ISC"
+ },
"node_modules/yaml": {
"version": "2.9.0",
"resolved": "https://registry.npmjs.org/yaml/-/yaml-2.9.0.tgz",
@@ -7306,6 +9984,83 @@
"url": "https://github.com/sponsors/eemeli"
}
},
+ "node_modules/yargs": {
+ "version": "17.7.3",
+ "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.3.tgz",
+ "integrity": "sha512-GZtjxm/J/4TSxuL3FNYjCmLktBTnIw/rVmKSIyKeYAZpmJB2ig9VauCC5xsa82GNKVKDAqpOn3KVzNt0zmrU0g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "cliui": "^8.0.1",
+ "escalade": "^3.1.1",
+ "get-caller-file": "^2.0.5",
+ "require-directory": "^2.1.1",
+ "string-width": "^4.2.3",
+ "y18n": "^5.0.5",
+ "yargs-parser": "^21.1.1"
+ },
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/yargs-parser": {
+ "version": "21.1.1",
+ "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz",
+ "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==",
+ "dev": true,
+ "license": "ISC",
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/yargs/node_modules/ansi-regex": {
+ "version": "5.0.1",
+ "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+ "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/yargs/node_modules/is-fullwidth-code-point": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+ "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/yargs/node_modules/string-width": {
+ "version": "4.2.3",
+ "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+ "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "emoji-regex": "^8.0.0",
+ "is-fullwidth-code-point": "^3.0.0",
+ "strip-ansi": "^6.0.1"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/yargs/node_modules/strip-ansi": {
+ "version": "6.0.1",
+ "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+ "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "ansi-regex": "^5.0.1"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
"node_modules/zod": {
"version": "4.1.13",
"resolved": "https://registry.npmjs.org/zod/-/zod-4.1.13.tgz",
diff --git a/frontend/package.json b/frontend/package.json
index 6314c2f44..8ed6f4d6f 100644
--- a/frontend/package.json
+++ b/frontend/package.json
@@ -9,6 +9,10 @@
"dev": "next dev",
"build": "node build.js",
"start": "next start",
+ "test": "vitest run",
+ "test:watch": "vitest",
+ "test:coverage": "vitest run --coverage",
+ "test:diff-coverage": "vitest run --coverage && node scripts/check-diff-coverage.mjs",
"lint": "biome check .",
"typecheck": "tsc --noEmit",
"lint:fix": "biome check --write",
@@ -72,17 +76,25 @@
"@emnapi/runtime": "^1.11.1",
"@emnapi/wasi-threads": "^1.2.2",
"@playwright/test": "^1.61.1",
+ "@testing-library/jest-dom": "^7.0.1",
+ "@testing-library/react": "^16.3.3",
+ "@testing-library/user-event": "^14.6.7",
"@types/node": "^26.0.1",
"@types/react": "^19.2.17",
"@types/react-dom": "^19.2.3",
"@types/react-syntax-highlighter": "^15.5.13",
+ "@vitejs/plugin-react": "^6.1.1",
+ "@vitest/coverage-v8": "^4.1.11",
"autoprefixer": "^10.5.2",
"husky": "^9.1.7",
+ "jsdom": "^30.0.1",
"knip": "^6.23.0",
"lint-staged": "^17.0.8",
+ "msw": "^2.15.0",
"postcss": "8.5.26",
"tailwindcss": "^3.4.19",
- "typescript": "^6.0.3"
+ "typescript": "^6.0.3",
+ "vitest": "^4.1.11"
},
"overrides": {
"postcss-selector-parser": "6.1.4",
@@ -102,6 +114,9 @@
"svgo": "4.0.1",
"node-forge": "1.4.0",
"path-to-regexp": "0.1.13",
+ "msw": {
+ "path-to-regexp": "^6.3.0"
+ },
"@xmldom/xmldom": "0.9.10"
},
"lint-staged": {
diff --git a/frontend/scripts/check-diff-coverage.mjs b/frontend/scripts/check-diff-coverage.mjs
new file mode 100644
index 000000000..6405d5340
--- /dev/null
+++ b/frontend/scripts/check-diff-coverage.mjs
@@ -0,0 +1,219 @@
+#!/usr/bin/env node
+/**
+ * Diff coverage gate.
+ *
+ * Fails when lines ADDED OR CHANGED by this branch are not covered by the
+ * Vitest suite. Deliberately scoped to changed lines rather than whole changed
+ * files: gating on file coverage would fail a one-line fix to an untested
+ * legacy file, which teaches people to avoid touching legacy code. Gating on
+ * changed lines says only "test what you just wrote".
+ *
+ * Usage:
+ * node scripts/check-diff-coverage.mjs [--base <ref>] [--threshold <0-100>]
+ *
+ * Env:
+ * DIFF_COVERAGE_BASE base ref (default: origin/main)
+ * DIFF_COVERAGE_THRESHOLD minimum percent (default: 80)
+ *
+ * Requires `vitest run --coverage` to have produced coverage/lcov.info.
+ */
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+
+const args = process.argv.slice(2);
+function arg(name, fallback) {
+ const i = args.indexOf(`--${name}`);
+ return i !== -1 && args[i + 1] ? args[i + 1] : fallback;
+}
+
+const BASE = arg("base", process.env.DIFF_COVERAGE_BASE || "origin/main");
+const THRESHOLD = Number(
+ arg("threshold", process.env.DIFF_COVERAGE_THRESHOLD || "80"),
+);
+const COVERAGE_FILE = path.resolve("coverage/lcov.info");
+
+/** Source files we gate on. Mirrors coverage.include in vitest.config.mts. */
+const INCLUDED =
+ /^(app|components|contexts|hooks|lib|enhancements)\/.*\.(ts|tsx)$/;
+/** Never gate on these: tests themselves, types, and Next route plumbing. */
+const EXCLUDED =
+ /(\.test\.tsx?$|\.d\.ts$|\/(layout|error|global-error|loading)\.tsx$|\/route\.ts$)/;
+
+function git(...a) {
+ return execFileSync("git", a, {
+ encoding: "utf8",
+ maxBuffer: 64 * 1024 * 1024,
+ });
+}
+
+/** Resolves the merge base, so we only judge lines this branch introduced. */
+function mergeBase(base) {
+ try {
+ return git("merge-base", base, "HEAD").trim();
+ } catch {
+ console.error(
+ `diff-coverage: cannot resolve base ref "${base}".\n` +
+ "In CI, check out with fetch-depth: 0 so history is available.",
+ );
+ process.exit(2);
+ }
+}
+
+/**
+ * Returns Map<file, Set<lineNumber>> of lines added or modified vs the base.
+ * `-U0` keeps hunks tight so we never attribute untouched context lines.
+ *
+ * Diffs the merge base against the WORKING TREE, not against HEAD. In CI the
+ * two are identical, but locally this makes the gate cover uncommitted work —
+ * which is when a developer actually wants the answer.
+ */
+function changedLines(baseSha) {
+ const out = git("diff", "-U0", "--diff-filter=d", "--relative", baseSha);
+ const files = new Map();
+ let file = null;
+ let line = 0;
+
+ for (const raw of out.split("\n")) {
+ if (raw.startsWith("+++ ")) {
+ const p = raw.slice(4).trim();
+ file = p === "/dev/null" ? null : p.replace(/^b\//, "");
+ continue;
+ }
+ if (raw.startsWith("@@")) {
+ // @@ -old,count +new,count @@
+ const m = /^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@/.exec(raw);
+ if (m) line = Number(m[1]);
+ continue;
+ }
+ if (!file) continue;
+ if (raw.startsWith("+")) {
+ if (!files.has(file)) files.set(file, new Set());
+ files.get(file).add(line);
+ line++;
+ }
+ // '-' lines do not advance the new-file counter; with -U0 there is no context.
+ }
+ return files;
+}
+
+/** Maps LCOV source paths to Map<relPath, Map<line, hitCount>>. */
+function lineHitsByFile() {
+ if (!existsSync(COVERAGE_FILE)) {
+ console.error(
+ `diff-coverage: ${path.relative(process.cwd(), COVERAGE_FILE)} not found.\n` +
+ "Run `npm run test:coverage` first.",
+ );
+ process.exit(2);
+ }
+ const raw = readFileSync(COVERAGE_FILE, "utf8");
+ const byFile = new Map();
+ let hits = null;
+
+ for (const line of raw.split(/\r?\n/)) {
+ if (line.startsWith("SF:")) {
+ const source = line.slice(3);
+ const absolute = path.isAbsolute(source)
+ ? source
+ : path.resolve(process.cwd(), source);
+ const rel = path.relative(process.cwd(), absolute);
+ hits = byFile.get(rel) ?? new Map();
+ byFile.set(rel, hits);
+ continue;
+ }
+ if (line === "end_of_record") {
+ hits = null;
+ continue;
+ }
+ if (!hits) continue;
+ const match = /^DA:(\d+),(\d+)/.exec(line);
+ if (!match) continue;
+ const lineNumber = Number(match[1]);
+ const count = Number(match[2]);
+ hits.set(lineNumber, Math.max(hits.get(lineNumber) ?? 0, count));
+ }
+ return byFile;
+}
+
+const baseSha = mergeBase(BASE);
+const changed = changedLines(baseSha);
+const coverage = lineHitsByFile();
+
+let totalRelevant = 0;
+let totalCovered = 0;
+const offenders = [];
+
+for (const [file, lines] of changed) {
+ if (!INCLUDED.test(file) || EXCLUDED.test(file)) continue;
+
+ const hits = coverage.get(file);
+ // A changed source file absent from the coverage report has no executed
+ // statements at all — every changed executable line is uncovered. We cannot
+ // know which lines are executable, so treat the file as fully uncovered only
+ // if it is a real source file; report it explicitly rather than silently.
+ if (!hits) {
+ offenders.push({ file, relevant: lines.size, covered: 0, unknown: true });
+ totalRelevant += lines.size;
+ continue;
+ }
+
+ let relevant = 0;
+ let covered = 0;
+ const missed = [];
+ for (const ln of lines) {
+ if (!hits.has(ln)) continue; // not an executable line (blank, comment, type)
+ relevant++;
+ if (hits.get(ln) > 0) covered++;
+ else missed.push(ln);
+ }
+ totalRelevant += relevant;
+ totalCovered += covered;
+ if (missed.length) offenders.push({ file, relevant, covered, missed });
+}
+
+if (totalRelevant === 0) {
+ console.log("diff-coverage: no changed executable lines to check — passing.");
+ process.exit(0);
+}
+
+const pct = (100 * totalCovered) / totalRelevant;
+const verdict = pct >= THRESHOLD ? "PASS" : "FAIL";
+
+console.log(
+ `diff-coverage: ${pct.toFixed(1)}% of changed lines covered ` +
+ `(${totalCovered}/${totalRelevant}), threshold ${THRESHOLD}% — ${verdict}`,
+);
+
+if (offenders.length) {
+ console.log("\nUncovered changed lines:");
+ for (const o of offenders.sort((a, b) => a.file.localeCompare(b.file))) {
+ if (o.unknown) {
+ console.log(
+ ` ${o.file} — no coverage data (file never imported by a test)`,
+ );
+ continue;
+ }
+ console.log(` ${o.file} — ${o.covered}/${o.relevant} covered`);
+ console.log(` lines: ${formatRanges(o.missed)}`);
+ }
+}
+
+/** Collapses [3,4,5,9] into "3-5, 9" so long lists stay readable. */
+function formatRanges(nums) {
+ const s = [...nums].sort((a, b) => a - b);
+ const parts = [];
+ let start = s[0];
+ let prev = s[0];
+ for (let i = 1; i <= s.length; i++) {
+ if (s[i] === prev + 1) {
+ prev = s[i];
+ continue;
+ }
+ parts.push(start === prev ? `${start}` : `${start}-${prev}`);
+ start = s[i];
+ prev = s[i];
+ }
+ return parts.join(", ");
+}
+
+process.exit(pct >= THRESHOLD ? 0 : 1);
diff --git a/frontend/scripts/check-diff-coverage.test.ts b/frontend/scripts/check-diff-coverage.test.ts
new file mode 100644
index 000000000..491833bfe
--- /dev/null
+++ b/frontend/scripts/check-diff-coverage.test.ts
@@ -0,0 +1,64 @@
+import { execFileSync, spawnSync } from "node:child_process";
+import {
+ mkdirSync,
+ mkdtempSync,
+ readFileSync,
+ rmSync,
+ writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+
+const fixtures = path.resolve("scripts/fixtures/diff-coverage");
+const script = path.resolve("scripts/check-diff-coverage.mjs");
+
+describe("diff coverage line accounting", () => {
+ it("counts a changed continuation line from its LCOV DA record", () => {
+ const repo = mkdtempSync(path.join(tmpdir(), "diff-coverage-"));
+ try {
+ mkdirSync(path.join(repo, "lib"));
+ mkdirSync(path.join(repo, "coverage"));
+ execFileSync("git", ["init", "-q"], { cwd: repo });
+ writeFileSync(
+ path.join(repo, "lib/multiline.ts"),
+ readFileSync(path.join(fixtures, "multiline.before.txt")),
+ );
+ execFileSync("git", ["add", "lib/multiline.ts"], { cwd: repo });
+ execFileSync(
+ "git",
+ [
+ "-c",
+ "user.name=Diff Coverage Test",
+ "-c",
+ "commit",
+ "-qm",
+ "baseline",
+ ],
+ { cwd: repo },
+ );
+
+ writeFileSync(
+ path.join(repo, "lib/multiline.ts"),
+ readFileSync(path.join(fixtures, "multiline.after.txt")),
+ );
+ writeFileSync(
+ path.join(repo, "coverage/lcov.info"),
+ readFileSync(path.join(fixtures, "lcov.info")),
+ );
+
+ const result = spawnSync(
+ process.execPath,
+ [script, "--base", "HEAD", "--threshold", "100"],
+ { cwd: repo, encoding: "utf8" },
+ );
+
+ expect(result.status).toBe(1);
+ expect(result.stdout).toContain("(0/1)");
+ expect(result.stdout).toContain("lines: 4");
+ } finally {
+ rmSync(repo, { recursive: true, force: true });
+ }
+ });
+});
diff --git a/frontend/scripts/fixtures/diff-coverage/lcov.info b/frontend/scripts/fixtures/diff-coverage/lcov.info
new file mode 100644
index 000000000..1c3bae0a6
--- /dev/null
+++ b/frontend/scripts/fixtures/diff-coverage/lcov.info
@@ -0,0 +1,6 @@
+TN:
+SF:lib/multiline.ts
+DA:2,1
+DA:3,1
+DA:4,0
+end_of_record
diff --git a/frontend/scripts/fixtures/diff-coverage/multiline.after.txt b/frontend/scripts/fixtures/diff-coverage/multiline.after.txt
new file mode 100644
index 000000000..ee7c3b757
--- /dev/null
+++ b/frontend/scripts/fixtures/diff-coverage/multiline.after.txt
@@ -0,0 +1,5 @@
+export function normalize(value: string): string {
+ return value
+ .trim()
+ .toUpperCase();
+}
diff --git a/frontend/scripts/fixtures/diff-coverage/multiline.before.txt b/frontend/scripts/fixtures/diff-coverage/multiline.before.txt
new file mode 100644
index 000000000..d4c49145f
--- /dev/null
+++ b/frontend/scripts/fixtures/diff-coverage/multiline.before.txt
@@ -0,0 +1,5 @@
+export function normalize(value: string): string {
+ return value
+ .trim()
+ .toLowerCase();
+}
diff --git a/frontend/test-utils/msw/handlers.ts b/frontend/test-utils/msw/handlers.ts
new file mode 100644
index 000000000..0bd0d4777
--- /dev/null
+++ b/frontend/test-utils/msw/handlers.ts
@@ -0,0 +1,36 @@
+import { HttpResponse, http } from "msw";
+import type { TasksResponse } from "@/app/api/queries/useGetTasksQuery";
+
+/**
+ * Default handlers, shared by every test.
+ *
+ * Paths are RELATIVE and match what the app actually calls. Every browser-side
+ * request goes through the catch-all proxy at `app/api/[...path]/route.ts`, so
+ * `/api/*` covers the whole surface. MSW resolves relative paths against
+ * `location.origin`, which vitest.config.mts pins to http://localhost:3000 via
+ * `environmentOptions.jsdom.url`.
+ *
+ * Keep this list minimal: only endpoints many tests need in a boring happy-path
+ * shape. Anything test-specific belongs in that test via `server.use(...)`,
+ * which setup.ts resets after every test.
+ *
+ * ── On typing (see R4 in local/plans/frontend-testing-foundation.md) ─────────
+ * Handler bodies are annotated with the frontend's own exported response
+ * interfaces. This catches drift between a handler and what the app believes
+ * the API returns — a change to `TasksResponse` breaks `npm run typecheck`
+ * here.
+ *
+ * It does NOT catch backend drift. The original plan was to generate these
+ * types from the backend's /openapi.json, but 122 of 140 operations declare
+ * `"schema": {}` because the FastAPI routes have no `response_model`, so the
+ * generated types would be `unknown` almost everywhere. Typing against
+ * frontend interfaces is the honest subset of that idea; detecting real
+ * backend drift needs either `response_model` on the backend routes or a
+ * separate contract test against a live stack.
+ */
+
+const emptyTasks: TasksResponse = { tasks: [] };
+
+export const handlers = [
+ http.get("/api/tasks/enhanced", () => HttpResponse.json(emptyTasks)),
+];
diff --git a/frontend/test-utils/msw/multipart.ts b/frontend/test-utils/msw/multipart.ts
new file mode 100644
index 000000000..e3930738c
--- /dev/null
+++ b/frontend/test-utils/msw/multipart.ts
@@ -0,0 +1,68 @@
+/**
+ * Minimal multipart/form-data reader for MSW handlers.
+ *
+ * Why not `await request.formData()`: under vitest's jsdom environment, jsdom
+ * supplies its own `File`/`Blob`, which undici (the fetch implementation MSW
+ * intercepts) cannot re-parse. `request.formData()` throws, and MSW turns that
+ * into a 500 that surfaces as a confusing "Upload failed" from app code.
+ *
+ * Reading `request.text()` works, so this parses the raw body instead.
+ *
+ * LIMITS, and they are environment limits rather than choices:
+ * - Text fields round-trip exactly.
+ * - File parts are COUNTED but their filename and bytes are NOT available —
+ * jsdom's File crosses the boundary as an unnamed, empty blob. Assertions
+ * about uploaded file *content* or *names* belong in Playwright.
+ */
+
+export interface ParsedMultipart {
+ /** Text field values by name. Repeated fields keep every value. */
+ fields: Record<string, string[]>;
+ /** Number of parts that carried a `filename` (i.e. file inputs). */
+ fileCount: number;
+}
+
+export function parseMultipart(body: string): ParsedMultipart {
+ const fields: Record<string, string[]> = {};
+ let fileCount = 0;
+
+ const boundaryMatch = /^(--[^\r\n]+)\r\n/.exec(body);
+ if (!boundaryMatch) {
+ return { fields, fileCount };
+ }
+ const boundary = boundaryMatch[1];
+
+ for (const rawPart of body.split(boundary)) {
+ const part = rawPart.replace(/^\r\n/, "");
+ if (!part || part.startsWith("--")) continue;
+
+ const split = part.indexOf("\r\n\r\n");
+ if (split === -1) continue;
+
+ const headers = part.slice(0, split);
+ const value = part.slice(split + 4).replace(/\r\n$/, "");
+
+ const name = /name="([^"]*)"/.exec(headers)?.[1];
+ if (!name) continue;
+
+ if (/filename="/.test(headers)) {
+ fileCount++;
+ continue;
+ }
+
+ if (!fields[name]) {
+ fields[name] = [];
+ }
+ fields[name].push(value);
+ }
+
+ return { fields, fileCount };
+}
+
+/** Convenience: first value of a text field, or undefined when absent. */
+export function field(
+ parsed: ParsedMultipart,
+ name: string,
+): string | undefined {
+ return parsed.fields[name]?.[0];
+}
diff --git a/frontend/test-utils/msw/server.ts b/frontend/test-utils/msw/server.ts
new file mode 100644
index 000000000..9cfb987e6
--- /dev/null
+++ b/frontend/test-utils/msw/server.ts
@@ -0,0 +1,15 @@
+import { setupServer } from "msw/node";
+import { handlers } from "./handlers";
+
+/**
+ * The MSW server, shared across the whole Vitest run.
+ *
+ * Intercepts below the app: the code under test keeps using real `fetch`, real
+ * `Response` objects, and the real react-query cache. Nothing in
+ * `app/api/queries/` or `app/api/mutations/` is mocked away, so the URL, the
+ * `response.ok` branch, the payload shape, and the query wiring all stay under
+ * test. See R4 in local/plans/frontend-testing-foundation.md.
+ *
+ * Lifecycle is registered in test-utils/setup.ts.
+ */
+export const server = setupServer(...handlers);
diff --git a/frontend/test-utils/render.tsx b/frontend/test-utils/render.tsx
new file mode 100644
index 000000000..1cb9669e7
--- /dev/null
+++ b/frontend/test-utils/render.tsx
@@ -0,0 +1,78 @@
+/**
+ * Test render helper.
+ *
+ * Deliberately does NOT use `app/providers.tsx` or
+ * `app/api/get-query-client.ts`:
+ *
+ * - `app/providers.tsx` monkey-patches `window.fetch` to intercept 401s and
+ * redirect. MSW's Node interceptor also patches `globalThis.fetch`, and the
+ * ordering between the two is unpredictable.
+ * - `getQueryClient()` memoizes a single client in browser environments, so
+ * cache would leak between tests in the same file.
+ *
+ * Each render therefore gets a fresh QueryClient with retries off, so a test
+ * asserting an error state fails fast instead of waiting out react-query's
+ * default retry/backoff.
+ */
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { type RenderOptions, render } from "@testing-library/react";
+import type { ReactElement, ReactNode } from "react";
+
+export function createTestQueryClient() {
+ return new QueryClient({
+ defaultOptions: {
+ queries: {
+ retry: false,
+ staleTime: 0,
+ gcTime: 0,
+ refetchOnWindowFocus: false,
+ },
+ mutations: { retry: false },
+ },
+ });
+}
+
+interface RenderWithProvidersOptions extends Omit<RenderOptions, "wrapper"> {
+ queryClient?: QueryClient;
+}
+
+/**
+ * Renders `ui` inside a fresh react-query provider.
+ *
+ * Returns the QueryClient alongside RTL's usual result so a test can seed or
+ * inspect the cache directly when it needs to.
+ */
+export function renderWithProviders(
+ ui: ReactElement,
+ {
+ queryClient = createTestQueryClient(),
+ ...options
+ }: RenderWithProvidersOptions = {},
+) {
+ function Wrapper({ children }: { children: ReactNode }) {
+ return (
+ <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+ );
+ }
+
+ return {
+ queryClient,
+ ...render(ui, { wrapper: Wrapper, ...options }),
+ };
+}
+
+/**
+ * Wrapper for `renderHook`, which takes a component rather than a render call.
+ *
+ * Each call builds its own QueryClient, so hooks under test never share cache.
+ */
+export function createQueryWrapper(queryClient = createTestQueryClient()) {
+ return function QueryWrapper({ children }: { children: ReactNode }) {
+ return (
+ <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+ );
+ };
+}
+
+export * from "@testing-library/react";
+export { default as userEvent } from "@testing-library/user-event";
diff --git a/frontend/test-utils/setup.ts b/frontend/test-utils/setup.ts
new file mode 100644
index 000000000..09958a039
--- /dev/null
+++ b/frontend/test-utils/setup.ts
@@ -0,0 +1,88 @@
+/**
+ * Global Vitest setup. Wired via `setupFiles` in vitest.config.mts, so it runs
+ * once per test file before any test.
+ *
+ * Two jobs: register jest-dom matchers, and polyfill the browser APIs jsdom
+ * does not implement.
+ */
+import "@testing-library/jest-dom/vitest";
+import { cleanup } from "@testing-library/react";
+import { afterAll, afterEach, beforeAll, vi } from "vitest";
+import { server } from "./msw/server";
+
+// RTL auto-cleans when it detects a global afterEach, but we register it
+// explicitly so behaviour does not silently change if `globals` is turned off.
+afterEach(() => {
+ cleanup();
+});
+
+// `onUnhandledRequest: "error"` makes an unmocked call fail loudly and
+// immediately. Without it a missing handler surfaces as a mystery timeout.
+beforeAll(() => {
+ server.listen({ onUnhandledRequest: "error" });
+});
+
+// Drops per-test `server.use(...)` overrides so tests cannot leak into each
+// other through the handler list.
+afterEach(() => {
+ server.resetHandlers();
+});
+
+afterAll(() => {
+ server.close();
+});
+
+// jsdom has no layout engine and ships none of the observer APIs. Components
+// that merely *call* these can be tested; components whose behaviour depends on
+// real geometry (ag-grid virtualization, use-stick-to-bottom) cannot, and
+// belong in Playwright instead. See R3 in
+// local/plans/frontend-testing-foundation.md.
+
+if (!window.matchMedia) {
+ window.matchMedia = vi.fn().mockImplementation((query: string) => ({
+ matches: false,
+ media: query,
+ onchange: null,
+ addListener: vi.fn(), // deprecated, still called by some libs
+ removeListener: vi.fn(),
+ addEventListener: vi.fn(),
+ removeEventListener: vi.fn(),
+ dispatchEvent: vi.fn(),
+ }));
+}
+
+class MockObserver {
+ observe = vi.fn();
+ unobserve = vi.fn();
+ disconnect = vi.fn();
+ takeRecords = vi.fn(() => []);
+ root = null;
+ rootMargin = "";
+ thresholds = [];
+}
+
+if (!globalThis.ResizeObserver) {
+ globalThis.ResizeObserver =
+ MockObserver as unknown as typeof globalThis.ResizeObserver;
+}
+
+if (!globalThis.IntersectionObserver) {
+ globalThis.IntersectionObserver =
+ MockObserver as unknown as typeof globalThis.IntersectionObserver;
+}
+
+// Not implemented by jsdom; Radix calls it when moving focus between items.
+if (!Element.prototype.scrollIntoView) {
+ Element.prototype.scrollIntoView = vi.fn();
+}
+
+// Radix primitives measure with these; jsdom returns undefined rather than 0.
+if (!Element.prototype.hasPointerCapture) {
+ Element.prototype.hasPointerCapture = vi.fn(() => false);
+}
+if (!Element.prototype.setPointerCapture) {
+ Element.prototype.setPointerCapture = vi.fn();
+}
+if (!Element.prototype.releasePointerCapture) {
+ Element.prototype.releasePointerCapture = vi.fn();
+}
diff --git a/frontend/vitest.config.mts b/frontend/vitest.config.mts
new file mode 100644
index 000000000..37b319331
--- /dev/null
+++ b/frontend/vitest.config.mts
@@ -0,0 +1,63 @@
+import path from "node:path";
+import react from "@vitejs/plugin-react";
+import { defineConfig } from "vitest/config";
+
+// .mts so Vite loads this as ESM. package.json has no "type": "module", so a
+// .ts config here is loaded as CommonJS and warns on the import syntax below.
+export default defineConfig({
+ plugins: [react()],
+ resolve: {
+ // Vite does not read tsconfig "paths"; this mirrors "@/*" -> "./*".
+ alias: {
+ "@": path.resolve(import.meta.dirname, "."),
+ },
+ },
+ test: {
+ environment: "jsdom",
+ // Pinned so relative MSW handler paths ("/api/...") have a stable origin to
+ // resolve against, and so tests never depend on a jsdom default changing.
+ environmentOptions: {
+ jsdom: { url: "http://localhost:3000" },
+ },
+ globals: true,
+ setupFiles: ["./test-utils/setup.ts"],
+ include: ["**/*.test.ts", "**/*.test.tsx"],
+ // tests/ is Playwright's testDir. Both suites use describe/it, so without
+ // this exclude Vitest would try to run the 24 E2E specs.
+ exclude: [
+ "**/node_modules/**",
+ "**/.next*/**",
+ "tests/**",
+ "playwright-report/**",
+ "test-results/**",
+ ],
+ coverage: {
+ provider: "v8",
+ // "lcov" emits DA records, which scripts/check-diff-coverage.mjs uses for
+ // per-line hit counts (including executable multiline continuations).
+ reporter: ["text", "json", "json-summary", "html", "lcov"],
+ reportsDirectory: "coverage",
+ // `include` is what makes the number honest: without it, coverage is
+ // reported only for files some test already imports, which reads as a
+ // high percentage of a tiny denominator.
+ include: [
+ "app/**/*.{ts,tsx}",
+ "components/**/*.{ts,tsx}",
+ "contexts/**/*.{ts,tsx}",
+ "hooks/**/*.{ts,tsx}",
+ "lib/**/*.{ts,tsx}",
+ "enhancements/**/*.{ts,tsx}",
+ ],
+ exclude: [
+ "**/*.test.{ts,tsx}",
+ "**/*.d.ts",
+ // Next.js route/layout plumbing, not logic worth a coverage target.
+ "app/**/layout.tsx",
+ "app/**/error.tsx",
+ "app/**/global-error.tsx",
+ "app/**/loading.tsx",
+ "app/**/route.ts",
+ ],
+ },
+ },
+});