From dc0035e625e14e8f69ffdec6e79d0dc6b3e098b0 Mon Sep 17 00:00:00 2001 From: Dmitriy Date: Fri, 2 Oct 2026 00:50:24 +0300 Subject: [PATCH] feat: add web panel and reliable session analytics Embed the shadcn/ui panel in signed appliance builds with local terminal authentication, scoped controls, content-free usage analytics and telemetry. Price local inference against verified cloud tariffs for the same model. Persist Codex providers for saved sessions, produce visible compaction summaries and account for failed response translations. Bound health history queries and operation listing so panel polling preserves agent resources. --- .github/workflows/ci.yml | 8 + .github/workflows/spark-release.yml | 14 + .gitignore | 6 + Makefile | 21 +- README.md | 17 +- build.rs | 50 + configs/apparmor.d/sparkplane-executor | 1 + configs/sparkplane/agent.toml | 5 + data/economics-prices.json | 41 +- docs/how-to/develop-spark.md | 10 + docs/reference/spark.md | 111 +- src/generated_files.rs | 134 + src/main.rs | 15 +- src/spark/agent.rs | 285 +- src/spark/analytics.rs | 1138 +++++ src/spark/client.rs | 65 + src/spark/economics.rs | 100 +- src/spark/executor.rs | 313 +- src/spark/gateway.rs | 113 +- src/spark/launch.rs | 16 +- src/spark/mod.rs | 5 + src/spark/sessions.rs | 126 +- src/spark/state.rs | 103 +- src/spark/telemetry.rs | 84 + src/spark/upstream.rs | 7 + src/spark/web.rs | 1548 ++++++ src/spark/webauth.rs | 364 ++ src/spark/wire.rs | 4 + tests/eco_launch.rs | 2 +- tests/generated_files.rs | 44 + web/components.json | 20 + web/eslint.config.js | 28 + web/index.html | 2 + web/package-lock.json | 5924 +++++++++++++++++++++++ web/package.json | 45 + web/playwright.config.ts | 18 + web/src/App.tsx | 981 ++++ web/src/components/panel.tsx | 404 ++ web/src/components/ui/badge.tsx | 47 + web/src/components/ui/button.tsx | 63 + web/src/components/ui/card.tsx | 91 + web/src/components/ui/chart.tsx | 373 ++ web/src/components/ui/dialog.tsx | 156 + web/src/components/ui/dropdown-menu.tsx | 254 + web/src/components/ui/input.tsx | 20 + web/src/components/ui/label.tsx | 21 + web/src/components/ui/select.tsx | 189 + web/src/components/ui/separator.tsx | 25 + web/src/components/ui/sheet.tsx | 142 + web/src/components/ui/sidebar.tsx | 724 +++ web/src/components/ui/skeleton.tsx | 13 + web/src/components/ui/sonner.tsx | 40 + web/src/components/ui/switch.tsx | 32 + web/src/components/ui/table.tsx | 113 + web/src/components/ui/tabs.tsx | 90 + web/src/components/ui/tooltip.tsx | 56 + web/src/hooks/use-mobile.ts | 21 + web/src/index.css | 119 + web/src/lib/api.test.ts | 33 + web/src/lib/api.ts | 169 + web/src/lib/utils.ts | 5 + web/src/main.tsx | 10 + web/src/pages/managed.tsx | 1134 +++++ web/tests/auth-flow.mjs | 35 + web/tests/panel.spec.ts | 389 ++ web/tsconfig.json | 17 + web/vite.config.ts | 11 + 67 files changed, 16402 insertions(+), 162 deletions(-) create mode 100644 build.rs create mode 100644 src/spark/analytics.rs create mode 100644 src/spark/telemetry.rs create mode 100644 src/spark/web.rs create mode 100644 src/spark/webauth.rs create mode 100644 web/components.json create mode 100644 web/eslint.config.js create mode 100644 web/index.html create mode 100644 web/package-lock.json create mode 100644 web/package.json create mode 100644 web/playwright.config.ts create mode 100644 web/src/App.tsx create mode 100644 web/src/components/panel.tsx create mode 100644 web/src/components/ui/badge.tsx create mode 100644 web/src/components/ui/button.tsx create mode 100644 web/src/components/ui/card.tsx create mode 100644 web/src/components/ui/chart.tsx create mode 100644 web/src/components/ui/dialog.tsx create mode 100644 web/src/components/ui/dropdown-menu.tsx create mode 100644 web/src/components/ui/input.tsx create mode 100644 web/src/components/ui/label.tsx create mode 100644 web/src/components/ui/select.tsx create mode 100644 web/src/components/ui/separator.tsx create mode 100644 web/src/components/ui/sheet.tsx create mode 100644 web/src/components/ui/sidebar.tsx create mode 100644 web/src/components/ui/skeleton.tsx create mode 100644 web/src/components/ui/sonner.tsx create mode 100644 web/src/components/ui/switch.tsx create mode 100644 web/src/components/ui/table.tsx create mode 100644 web/src/components/ui/tabs.tsx create mode 100644 web/src/components/ui/tooltip.tsx create mode 100644 web/src/hooks/use-mobile.ts create mode 100644 web/src/index.css create mode 100644 web/src/lib/api.test.ts create mode 100644 web/src/lib/api.ts create mode 100644 web/src/lib/utils.ts create mode 100644 web/src/main.tsx create mode 100644 web/src/pages/managed.tsx create mode 100644 web/tests/auth-flow.mjs create mode 100644 web/tests/panel.spec.ts create mode 100644 web/tsconfig.json create mode 100644 web/vite.config.ts diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 8585d75..ea9cdf4 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -13,6 +13,11 @@ jobs: runs-on: ubuntu-24.04 steps: - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4 + - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4 + with: + node-version: '22' + cache: npm + cache-dependency-path: web/package-lock.json - uses: dtolnay/rust-toolchain@02cb101ec7c40f2c49e1d9714d64511d8e1b74de with: toolchain: '1.95.0' @@ -25,6 +30,9 @@ jobs: - run: make lint - run: make test - run: make test-client + - run: cd web && npx playwright install --with-deps chromium + - run: make web-test-browser + - run: cd web && npm audit --omit=dev --audit-level=high - run: cargo doc --locked --workspace --all-features --no-deps env: RUSTDOCFLAGS: -D warnings diff --git a/.github/workflows/spark-release.yml b/.github/workflows/spark-release.yml index b3318ad..adb9f94 100644 --- a/.github/workflows/spark-release.yml +++ b/.github/workflows/spark-release.yml @@ -10,6 +10,11 @@ jobs: runs-on: ubuntu-24.04 steps: - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4 + - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4 + with: + node-version: '22' + cache: npm + cache-dependency-path: web/package-lock.json - uses: dtolnay/rust-toolchain@02cb101ec7c40f2c49e1d9714d64511d8e1b74de with: toolchain: '1.95.0' @@ -25,6 +30,9 @@ jobs: - run: make lint-spark - run: make test - run: make test-client + - run: cd web && npx playwright install --with-deps chromium + - run: make web-test-browser + - run: cd web && npm audit --omit=dev --audit-level=high build: needs: contract runs-on: ubuntu-24.04 @@ -33,6 +41,11 @@ jobs: target: [x86_64-unknown-linux-gnu, aarch64-unknown-linux-gnu] steps: - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4 + - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4 + with: + node-version: '22' + cache: npm + cache-dependency-path: web/package-lock.json - uses: dtolnay/rust-toolchain@02cb101ec7c40f2c49e1d9714d64511d8e1b74de with: toolchain: '1.95.0' @@ -53,6 +66,7 @@ jobs: - name: Build ARM64 appliance if: matrix.target == 'aarch64-unknown-linux-gnu' run: | + make web-build cargo auditable zigbuild --locked --release --target aarch64-unknown-linux-gnu --features appliance --bin sparkplane scripts/package-spark-release.sh target/aarch64-unknown-linux-gnu/release/sparkplane target/release-assets/appliance cargo metadata --locked --format-version 1 > target/release-assets/appliance/cargo-metadata.json diff --git a/.gitignore b/.gitignore index a7b4800..a8949dd 100644 --- a/.gitignore +++ b/.gitignore @@ -4,3 +4,9 @@ __pycache__/ *.key *.minisig .env +/web/node_modules/ +/web/dist/ +/web/test-results/ +/web/playwright-report/ +/web/*.tsbuildinfo +/.config/sparkplane/spark-launch.lock diff --git a/Makefile b/Makefile index 9aff265..9fa7b90 100644 --- a/Makefile +++ b/Makefile @@ -1,13 +1,26 @@ -.PHONY: build test lint lint-spark test-client fmt-check audit update -build: +.PHONY: build test lint lint-spark test-client fmt-check audit update web-build web-check web-test web-test-browser +.DEFAULT_GOAL := build +web/node_modules/.sparkplane-deps: web/package.json web/package-lock.json + cd web && npm ci --no-fund + touch web/node_modules/.sparkplane-deps +web-build: web/node_modules/.sparkplane-deps + cd web && npm run build +web-check: web/node_modules/.sparkplane-deps + cd web && npm run check +web-test: web/node_modules/.sparkplane-deps + cd web && npm test +web-test-browser: web-build + cd web && npm run test:browser + cargo test --locked --features appliance --lib browser_authentication_redirects_over_https -- --ignored +build: web-build cargo build --locked --release --features appliance -test: +test: web-build web-test python3 tests/standalone_contract.py python3 tests/spark_update.py cargo test --locked --workspace --all-targets --features appliance test-client: cargo test --locked --no-default-features --all-targets -lint: +lint: web-build web-check cargo fmt --all -- --check cargo clippy --locked --workspace --all-targets --features appliance -- -D warnings cargo clippy --locked --no-default-features --all-targets -- -D warnings diff --git a/README.md b/README.md index e1f3d55..ee2c765 100644 --- a/README.md +++ b/README.md @@ -11,6 +11,7 @@ cargo build --locked --release ./target/release/sparkplane dgx-spark status --json ./target/release/sparkplane dgx-spark serve qwen3.8:flash-next --dry-run --json ./target/release/sparkplane dgx-spark launch codex +./target/release/sparkplane webui ``` Use the pinned Rust 1.95.0 toolchain (selected automatically by rustup), a @@ -26,8 +27,9 @@ within a supported sandbox. See [launch permissions](docs/reference/spark.md#int Launches also default to `--eco-mode=max`, using RTK filters embedded in the Sparkplane executable. Use `--eco-mode=none` to disable compression. When the -coding session exits, Sparkplane prints token usage and public cloud price -comparisons; `sparkplane economics --json` reads the latest retained report. +coding session exits, Sparkplane prints token usage and the same model's public +cloud-equivalent cost when a verified tariff exists; `sparkplane economics +--json` reads the latest retained report. See [session economics](docs/reference/spark.md#eco-mode-and-session-economics). Vision launches also retain recent images automatically and archive older @@ -47,11 +49,22 @@ executor, database, gateway and bootstrap implementation. The owned `sparkplane-core` and `sparkplane-ipc` crates contain only platform vocabulary, trace propagation, notification and bounded IPC. +The web panel uses shadcn/ui with a black and NVIDIA-green theme. Run +`sparkplane webui` to open it and click **Authenticate**, using your existing +CLI credential. The local authentication service stops after login. If you +open `/panel/` directly, run `sparkplane webauthsvc start` on the browser's +computer. See [web panel](docs/reference/spark.md#web-panel). + +Appliance builds additionally need Node.js 22.12+ and npm to compile the panel: +run `make web-build` before invoking Cargo with `--features appliance`. +Compiled assets are embedded in the signed binary; Spark needs no Node runtime. + ```sh make lint make test make test-client make audit +make web-test-browser # first: cd web && npx playwright install chromium cargo build --locked --release --features appliance ``` diff --git a/build.rs b/build.rs new file mode 100644 index 0000000..c26679c --- /dev/null +++ b/build.rs @@ -0,0 +1,50 @@ +use std::{env, fs, path::Path}; + +fn main() { + if env::var_os("CARGO_FEATURE_APPLIANCE").is_none() { + return; + } + println!("cargo:rerun-if-changed=web/dist"); + let root = env::current_dir().expect("repository").join("web/dist"); + assert!( + root.join("index.html").exists(), + "panel assets missing: run `make web-build` before building the appliance" + ); + let mut files = Vec::new(); + collect(&root, &mut files); + files.sort(); + let mut generated = String::from("static ASSETS: &[(&str, &[u8], &str)] = &[\n"); + for file in files { + let relative = file.strip_prefix(&root).unwrap().to_str().unwrap(); + let mime = match file.extension().and_then(|s| s.to_str()) { + Some("html") => "text/html; charset=utf-8", + Some("js") => "text/javascript; charset=utf-8", + Some("css") => "text/css; charset=utf-8", + Some("svg") => "image/svg+xml", + Some("png") => "image/png", + Some("woff2") => "font/woff2", + _ => "application/octet-stream", + }; + generated.push_str(&format!( + "({relative:?}, include_bytes!({:?}), {mime:?}),\n", + file.to_str().unwrap() + )); + } + generated.push_str("];\n"); + fs::write( + Path::new(&env::var_os("OUT_DIR").unwrap()).join("panel_assets.rs"), + generated, + ) + .unwrap(); +} + +fn collect(path: &Path, files: &mut Vec) { + for entry in fs::read_dir(path).unwrap() { + let path = entry.unwrap().path(); + if path.is_dir() { + collect(&path, files); + } else { + files.push(path); + } + } +} diff --git a/configs/apparmor.d/sparkplane-executor b/configs/apparmor.d/sparkplane-executor index f38bd0b..e258beb 100644 --- a/configs/apparmor.d/sparkplane-executor +++ b/configs/apparmor.d/sparkplane-executor @@ -26,6 +26,7 @@ profile sparkplane-executor /opt/sparkplane/current/sparkplane flags=(attach_dis /var/lib/sparkplane/huggingface/** r, /proc/*/cgroup r, /proc/*/stat r, + /proc/stat r, /proc/meminfo r, /proc/vmstat r, /proc/pressure/memory r, diff --git a/configs/sparkplane/agent.toml b/configs/sparkplane/agent.toml index 3081d6b..0960466 100644 --- a/configs/sparkplane/agent.toml +++ b/configs/sparkplane/agent.toml @@ -6,6 +6,11 @@ allowed_client_cidrs = ["10.1.30.0/24"] plain_http_loopback_only = true executor_socket = "/run/sparkplane/executor.sock" +[webui] +enabled = true +# Optional exact HTTPS origin; otherwise use the certificate's DNS/IP identities. +# origin = "https://10.1.30.143:9843" + [gateway] # Public uploads are normalized to the selected engine's stricter image policy. request_body_bytes = 33554432 diff --git a/data/economics-prices.json b/data/economics-prices.json index fa97ceb..a1254ab 100644 --- a/data/economics-prices.json +++ b/data/economics-prices.json @@ -1,37 +1,30 @@ { - "version": "2026-09-30.1", + "version": "2026-10-01.1", "currency": "USD", "tariff": "standard_uncached", "models": [ { - "model": "gpt-6.1-sol", - "source": "https://developers.openai.com/api/docs/models/gpt-6.1-sol", - "verified_at": "2026-09-30", - "effective_from": "2026-09-30", - "input_microusd_per_million": 2000000, - "output_microusd_per_million": 10000000, - "long_context_threshold": 272000, - "long_input_microusd_per_million": 4000000, - "long_output_microusd_per_million": 15000000 - }, - { - "model": "claude-sonnet-4-6", - "source": "https://platform.claude.com/docs/en/models/sonnet-4-6/overview", - "verified_at": "2026-09-30", - "effective_from": "2026-09-30", - "input_microusd_per_million": 3000000, - "output_microusd_per_million": 15000000, + "model": "qwen3.8-flash-next", + "aliases": ["qwen/qwen3.8-flash-next", "qwen3.8:flash-next", "qwen3.8:flash-next-nvfp4", "qwen3.8:flash-next-iq4-xs", "Qwen/Qwen3.8-Flash-Next", "RadixArk/Qwen3.8-Flash-Next-NVFP4", "unsloth/Qwen3.8-Flash-Next-GGUF"], + "provider": "Lyceum", + "source": "https://lyceum.technology/products/inference/models/qwen/qwen3.8-flash-next/", + "verified_at": "2026-10-01", + "effective_from": "2026-10-01", + "input_microusd_per_million": 200000, + "output_microusd_per_million": 500000, "long_context_threshold": null, "long_input_microusd_per_million": null, "long_output_microusd_per_million": null }, { - "model": "gemini-3.5-flash", - "source": "https://ai.google.dev/gemini-api/docs/pricing", - "verified_at": "2026-09-30", - "effective_from": "2026-09-30", - "input_microusd_per_million": 1500000, - "output_microusd_per_million": 9000000, + "model": "qwen3.8-27b", + "aliases": ["qwen/qwen3.8-27b", "qwen3.8:27b", "qwen3.8:27b-q4-k-m", "qwen3.8:27b-fp8", "Qwen/Qwen3.8-27B", "Qwen/Qwen3.8-27B-FP8", "ggml-org/Qwen3.8-27B-GGUF"], + "provider": "Lyceum", + "source": "https://lyceum.technology/products/inference/models/qwen/qwen3.8-27b/", + "verified_at": "2026-10-01", + "effective_from": "2026-10-01", + "input_microusd_per_million": 400000, + "output_microusd_per_million": 2400000, "long_context_threshold": null, "long_input_microusd_per_million": null, "long_output_microusd_per_million": null diff --git a/docs/how-to/develop-spark.md b/docs/how-to/develop-spark.md index ddc5101..9449adf 100644 --- a/docs/how-to/develop-spark.md +++ b/docs/how-to/develop-spark.md @@ -42,6 +42,13 @@ the workstation update helper also reads the installed public release key over S ## Local development loop +Install Node.js 22.12+ and npm for appliance development. The web panel's exact +dependencies are recorded in `web/package-lock.json`. `make lint`, `make test` +and `make build` compile it automatically; a direct Cargo appliance build needs +`make web-build` first. Client-only Cargo builds and `make test-client` need no +Node tooling. The panel assets are embedded inside the existing signed executable, +so the signed release inventory remains unchanged. + Run the same checks that gate the release before opening a pull request: ```bash @@ -49,6 +56,8 @@ make lint make test make test-client make audit +cd web && npx playwright install chromium && cd .. +make web-test-browser RUSTDOCFLAGS='-D warnings' cargo doc --locked --workspace --all-features --no-deps ``` @@ -152,6 +161,7 @@ python3 -m pip install --user ziglang==0.16.0 Build locally with the same feature boundary as Spark: ```bash +make web-build cargo auditable zigbuild --locked --release \ --target aarch64-unknown-linux-gnu \ --no-default-features --features appliance --bin sparkplane diff --git a/docs/reference/spark.md b/docs/reference/spark.md index b2c8430..7e91930 100644 --- a/docs/reference/spark.md +++ b/docs/reference/spark.md @@ -28,6 +28,8 @@ bounded, cursored, redacted, and protected by `logs:read`. ## Synopsis ```text +sparkplane webui [--host ] [--json] +sparkplane webauthsvc start [--host ] [--json] sparkplane install --dry-run --json sparkplane install --yes --release-manifest --release-signature --release-public-key sparkplane upgrade --dry-run --json @@ -49,6 +51,85 @@ sparkplane client-config --client ## Description +### Web panel + +The panel is served at `https://:9843/panel/`, using the existing TLS and +allowed-client CIDR policy. Its pages cover overview, analytics, verified models, +managed instances, operations, host health and administration. Access and controls +inherit the selected CLI credential's scopes; `analytics:read` permits usage and +health data. Administrator credentials can manage tokens, audit history, +certificates and release-signed qualification jobs. Updates, rollback and +certificate rotation remain CLI-assisted. + +Run `sparkplane webui` to start a temporary loopback authentication service and +open the browser. Click **Authenticate**. Spark creates an HttpOnly browser +session through a single-use, browser-bound handoff; the stored API token is +never sent to browser JavaScript. The CLI exits and closes all local connections +after Spark confirms login. Sessions expire after eight hours or 30 idle minutes; +logout, token expiry and token revocation invalidate access. + +For a panel opened directly, run `sparkplane webauthsvc start` on the same +computer as the browser. The page checks `127.0.0.1:9844` and displays Authenticate +when the service appears. Some browsers require local-network permission. If +detection is blocked, use **I started the local service**, then **Authenticate**. +Both entrypoints use the single configured host automatically; use `--host` +when multiple profiles exist. The helper expires after ten minutes; Ctrl-C stops +it earlier. An occupied port produces an error instead of replacing a process. +No sudo or password is required. The browser must trust the installed Spark TLS +certificate; the helper continues to verify the CLI's existing pinned CA. + +The panel is enabled by default. Set `[webui] enabled = false` in the agent +configuration to disable it. An optional `origin` restricts browser access to +one exact HTTPS origin; otherwise certificate DNS/IP identities are accepted. +Browser sessions cannot authorize inference endpoints. State-changing panel +requests require the session's CSRF proof and matching origin. + +Panel operation lists use `GET /operations?view=summary` for bounded metadata +without qualification result payloads. `GET /operations/` retrieves the full +result on demand; the existing unfiltered operation-list API retains its format. + +Analytics count reported inference tokens from ordinary API clients as well as +launched sessions, including embeddings. Unknown and interrupted accounting stays +explicit. Cloud-equivalent cost matches each actual model to the bundled +public-price catalog's dated standard uncached tariff. Unpriced models make the +total unavailable; filter to a priced model to inspect its estimate. Prices for +GPT, Claude or Gemini are never substituted for a different local model. +RTK compression estimates use authenticated, +client-reported byte aggregates and are shown separately. They are not net +ownership savings. No prompts, generated text, images or command output are +stored in analytics. + +Request and session details are retained for 90 days, daily usage and RTK rollups +for one year. Health samples are retained at five-second resolution for 24 hours, +minute resolution for 30 days and hourly resolution for one year. History before +this upgrade covers only retained launch sessions. GB10 dedicated VRAM figures +may be unavailable; the panel displays host unified memory separately. +GPU utilization, temperature and power use a fixed, time-limited query inside +an existing exact managed engine. They are unavailable when no such engine or +driver utility is present. The executor keeps its private devices and network. + +Panel tables use a separate verified migration ledger after a verified backup. +The qualified engine state schema stays compatible with the preceding release. +The new analytics permission is stored separately from legacy token scopes, so +older releases can decode credentials without granting new permissions. + +Additional control API endpoints include `web-auth/approve`, `web-auth/flows/`, +`web-session`, `analytics`, `analytics/requests`, `analytics/sessions`, `audit`, +`health`, `health/history`, `instances//recover` and +`launch-sessions//compression`. Analytics use `days` (1–365), `limit` (1–200), +`offset`, and optional `model`, `instance`, `token`, `integration`, `session` +filters; `previous=true` selects the preceding equal period. Days use UTC calendar +boundaries. Paginated results expose `items` and nullable `next_offset`. + +Recovery previews and then durably sequences stop and serve, retaining the +qualified engine settings. It rejects catalog/settings differences before +stopping. Every lifecycle action still passes the normal typed executor, +resource admission, confinement and exact-container cleanup checks. +If the agent restarts mid-recovery, the sequence is marked interrupted and its +child lifecycle operations reconcile independently. Inspect those operations +before retrying. In-flight usage from the previous agent is marked interrupted +with unknown counts; it never remains pending indefinitely. + `ls` is the everyday inventory of verified models available to run. Its default columns are `NAME`, `ID`, `SIZE`, and `MODIFIED`. `ps` is the active lifecycle view: it omits absent and failed historical records and prints `NAME`, `MODEL`, @@ -253,6 +334,18 @@ profile/catalog files. `-y` permits the fixed Claude or OpenCode installer when the executable is absent. Only arguments after `--` are forwarded, without a shell. +Launch also registers its provider in the user-level Codex `config.toml`, +preserving defaults, preferences and other providers. Provider definitions remain +across model changes and `--restore` so saved threads can still resolve their +provider IDs. User edits to a managed provider are preserved and reported as a +conflict. Definitions contain an environment variable name, never a token. +Resume through the launcher to initialize credentials, the pinned CA and image +history handling: + +```sh +sparkplane launch codex -- resume [session-id] +``` + State is serialized with a local lock. Metadata stores only the token ID; the bearer is held separately in a mode-0600 credential file. The child receives an inference-only token and pinned CA, never the administrator credential. Claude @@ -312,6 +405,13 @@ observations. Codex launches compact the conversation at 75% of the qualified context window, preserving room for new tool results and compaction. Image retention remains active with `--eco-mode=none`; that switch controls RTK command compression. These bounds do not change engine context, sampling or resources. +Codex checkpoint requests marked `request_kind=compaction` in +`client_metadata.x-codex-turn-metadata`, without tools, use non-thinking generation +on translated Responses routes. This returns a visible handoff summary instead +of a reasoning-only response that Codex cannot compact. Ordinary coding requests +retain their selected effort; native Responses routes retain their own behavior. +Translation failures count as failed requests while retaining reported tokens, +and streamed errors report the safe failure reason. Codex `view_image` results and other typed function/custom tool outputs preserve inline images as multimodal tool content, including resizing and the shared request image budget. Their base64 is never converted into prompt text. Regular @@ -385,18 +485,21 @@ input/output tokens, duration, compressed command counts, estimated output reduction and two separate USD columns: - **Cloud equivalent:** known local inference tokens valued at published - standard uncached input/output rates for GPT-6.1 Sol, Claude Sonnet 4.6 and - Gemini 3.5 Flash. The GPT comparison applies its longer-context tier per - request above 272,000 input tokens. + standard uncached input/output rates for the same model in the cloud. + The catalog currently covers Lyceum's Qwen3.8 Flash Next and Qwen3.8 27B. + Exact, explicitly listed checkpoint aliases match their cloud model; + other models show unavailable until a verified tariff is added. - **Estimated RTK savings:** removed tool-output bytes divided by four, valued once at standard input rates. This estimate does not assume repeated context reuse and is unavailable when compression metrics are incomplete. -These columns are not added together. Different tokenizers, prompt caching, +These columns are not added together. Cloud quantization, tokenizers, prompt caching, hardware and electricity can change actual costs; these are comparisons, not bills or measured cash savings. The bundled price catalog records official source links, verification dates, rates and a version. Launch never fetches prices from the network; each report retains the catalog it used. +Older retained reports keep their original tariff evidence, but unrelated-model +comparisons are no longer displayed. `sparkplane economics` displays the most recent report; `economics --session --json` emits the structured report on stdout. diff --git a/src/generated_files.rs b/src/generated_files.rs index 9b14865..a0510e5 100644 --- a/src/generated_files.rs +++ b/src/generated_files.rs @@ -167,6 +167,140 @@ pub fn publish(home: &Path, profile: &[u8], catalog: &[u8]) -> Result<()> { atomic(home, RECEIPT, &serde_json::to_vec(&committed)?) } +/// Keep saved thread provider IDs available when Codex resumes without a profile. +/// Only owned provider tables change; user defaults and other settings stay intact. +pub fn publish_provider(home: &Path, profile: &[u8]) -> Result<()> { + const CONFIG: &str = "config.toml"; + const LEDGER: &str = "sparkplane-providers.ownership.json"; + const PROVIDER_SCHEMA: &str = "sparkplane.codex-providers/v1"; + #[derive(Serialize, Deserialize)] + #[serde(deny_unknown_fields)] + struct Providers { + schema: String, + providers: BTreeMap>, + } + fn valid_name(name: &str) -> bool { + name.starts_with("sparkplane_") + && name.len() <= 256 + && name.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'_') + } + fn digest(value: &toml::Value) -> Result { + Ok(format!("{:x}", Sha256::digest(serde_json::to_vec(value)?))) + } + ensure!( + profile.len() as u64 <= MAX_BYTES, + "provider profile exceeds size limit" + ); + let text = std::str::from_utf8(profile)?; + let incoming: toml::Value = toml::from_str(text)?; + let tables = incoming + .get("model_providers") + .and_then(toml::Value::as_table) + .context("profile has no provider definitions")?; + ensure!( + !tables.is_empty() && tables.len() <= 128, + "invalid provider count" + ); + ensure!( + tables.iter().all(|(name, table)| valid_name(name) + && table + .as_table() + .is_some_and(|table| table.keys().all(|key| matches!( + key.as_str(), + "name" + | "base_url" + | "env_key" + | "env_key_instructions" + | "wire_api" + | "supports_standalone_web_search" + | "supports_websockets" + )))), + "invalid managed provider definition" + ); + fs::DirBuilder::new() + .recursive(true) + .mode(0o700) + .create(home)?; + let _lock = lock(home)?; + let mut pending: Providers = match read(home, LEDGER)? { + Some(bytes) => serde_json::from_slice(&bytes)?, + None => Providers { + schema: PROVIDER_SCHEMA.into(), + providers: BTreeMap::new(), + }, + }; + ensure!( + pending.schema == PROVIDER_SCHEMA + && pending.providers.len() <= 128 + && pending + .providers + .iter() + .all(|(name, hashes)| valid_name(name) + && !hashes.is_empty() + && hashes.len() <= 2 + && hashes.iter().all( + |hash| hash.len() == 64 && hash.bytes().all(|b| b.is_ascii_hexdigit()) + )), + "invalid provider ownership receipt" + ); + let original = read(home, CONFIG)?; + let config_text = std::str::from_utf8(original.as_deref().unwrap_or(b""))?; + let current: toml::Value = toml::from_str(config_text)?; + let mut document: toml_edit::DocumentMut = config_text.parse()?; + let additions: toml_edit::DocumentMut = text.parse()?; + if !document.contains_key("model_providers") { + document["model_providers"] = toml_edit::Item::Table(toml_edit::Table::new()); + } + ensure!( + document["model_providers"].is_table(), + "model_providers must be a table" + ); + let mut committed = Providers { + schema: PROVIDER_SCHEMA.into(), + providers: pending.providers.clone(), + }; + for (name, value) in tables { + let hash = digest(value)?; + let mut hashes = vec![hash.clone()]; + if let Some(old) = current.get("model_providers").and_then(|v| v.get(name)) { + let old_hash = digest(old)?; + ensure!( + old == value + || pending + .providers + .get(name) + .is_some_and(|owned| owned.contains(&old_hash)), + "refusing to overwrite user-edited Codex provider {name}" + ); + if old_hash != hash { + hashes.push(old_hash); + } + } + pending.providers.insert(name.clone(), hashes); + committed.providers.insert(name.clone(), vec![hash]); + document["model_providers"][name] = additions["model_providers"][name].clone(); + } + ensure!( + pending.providers.len() <= 128, + "provider registry exceeds size limit" + ); + let output = document.to_string(); + ensure!( + output.len() as u64 <= MAX_BYTES, + "Codex config exceeds size limit" + ); + let _: toml::Value = toml::from_str(&output)?; + atomic(home, LEDGER, &serde_json::to_vec(&pending)?)?; + ensure!( + read(home, CONFIG)? == original, + "Codex config changed concurrently; retry launch" + ); + if original.as_deref() != Some(output.as_bytes()) { + atomic(home, CONFIG, output.as_bytes())?; + } + atomic(home, LEDGER, &serde_json::to_vec(&committed)?) +} + pub fn remove(home: &Path) -> Result<()> { let _lock = lock(home)?; let receipt = receipt(home)?; diff --git a/src/main.rs b/src/main.rs index 09d095b..0070829 100644 --- a/src/main.rs +++ b/src/main.rs @@ -6,7 +6,8 @@ use tracing_subscriber::prelude::*; #[command( name = "sparkplane", version, - about = "Independent DGX Spark inference appliance" + about = "Independent DGX Spark inference appliance", + after_help = "Web panel:\n sparkplane webui [--host ALIAS]\n sparkplane webauthsvc start [--host ALIAS]" )] struct Cli { #[command(flatten)] @@ -14,6 +15,18 @@ struct Cli { } fn main() { + if std::env::args_os() + .nth(1) + .is_some_and(|a| a == "webui" || a == "webauthsvc") + { + if let Err(error) = + sparkplane::spark::webauth::dispatch(sparkplane::spark::webauth::WebCli::parse()) + { + eprintln!("error: {error}"); + std::process::exit(2); + } + return; + } if std::env::args_os().nth(1).is_some_and(|a| a == "__eco") { let code = match sparkplane::spark::eco::run(std::env::args_os().skip(2).collect()) { Ok(code) => code, diff --git a/src/spark/agent.rs b/src/spark/agent.rs index f498b1b..3bb9f20 100644 --- a/src/spark/agent.rs +++ b/src/spark/agent.rs @@ -75,6 +75,9 @@ type TokenLimiter = RateLimiter, DefaultClock> type InferenceSlots = BTreeMap)>; const DATABASE_QUEUE_CAPACITY: usize = 64; +#[path = "web.rs"] +mod web; + #[derive(Debug, Clone, Deserialize)] #[serde(deny_unknown_fields)] pub struct AgentConfig { @@ -91,6 +94,8 @@ pub struct AgentConfig { pub models: ModelsConfig, #[serde(default)] pub gateway: gateway::IngressLimits, + #[serde(default)] + pub webui: web::PanelConfig, } #[derive(Debug, Clone, Deserialize)] @@ -137,6 +142,7 @@ pub struct AgentState { admission: TransitionCoordinator, routes: RouteRegistry, qualification_authority: Option>, + web: Arc, #[cfg(test)] executor_ready_override: bool, } @@ -209,6 +215,7 @@ impl AgentState { admission: TransitionCoordinator::new(), routes: RouteRegistry::default(), qualification_authority: None, + web: Arc::new(web::WebState::default()), #[cfg(test)] executor_ready_override: false, } @@ -519,9 +526,14 @@ pub fn router(state: AgentState) -> Router { inference_ingress, )); let authenticated = authenticated + .merge(web::api_routes()) .merge(inference) .route_layer(middleware::from_fn_with_state(state.clone(), authenticate)); - authenticated.fallback(not_found).with_state(state) + authenticated + .merge(web::public_routes(state.clone())) + .fallback(not_found) + .layer(middleware::from_fn(web::normalize_authority)) + .with_state(state) } // The worker owns a clone so cancellation cannot free its CPU/memory slot early. @@ -659,10 +671,17 @@ async fn meter_inference_route( auth: &AuthenticatedToken, instance: &str, route: Arc, + protocol: &str, ) -> Result, StateError> { let mut metered_route = (*route).clone(); metered_route.upstream = metered_route.upstream.with_meter(Arc::new( - super::sessions::UsageMeter::begin(state.database.as_ref(), &auth.id, instance).await?, + super::sessions::UsageMeter::begin_protocol( + state.database.as_ref(), + &auth.id, + instance, + protocol, + ) + .await?, )); Ok(Arc::new(metered_route)) } @@ -800,10 +819,11 @@ async fn gateway_anthropic_messages( Ok(request) => request, Err(error) => return anthropic_error(StatusCode::BAD_REQUEST, error), }; - let route = match meter_inference_route(&state, &auth, &instance, route).await { - Ok(route) => route, - Err(error) => return state_problem(error), - }; + let route = + match meter_inference_route(&state, &auth, &instance, route, "anthropic.messages").await { + Ok(route) => route, + Err(error) => return state_problem(error), + }; let token_permit = match auth.acquire_inference().await { Ok(permit) => permit, Err(()) => return anthropic_upstream_unavailable(), @@ -1049,7 +1069,13 @@ async fn gateway_completions( }; let mut metered_route = (*route).clone(); metered_route.upstream = metered_route.upstream.with_meter(Arc::new( - match super::sessions::UsageMeter::begin(state.database.as_ref(), &auth.id, &instance).await + match super::sessions::UsageMeter::begin_protocol( + state.database.as_ref(), + &auth.id, + &instance, + "openai.completions", + ) + .await { Ok(meter) => meter, Err(error) => return state_problem(error), @@ -1291,7 +1317,9 @@ async fn gateway_responses( Ok(request) => request, Err(error) => return openai_error(StatusCode::BAD_REQUEST, error), }; - let route = match meter_inference_route(&state, &auth, &instance, route).await { + let route = match meter_inference_route(&state, &auth, &instance, route, "openai.responses") + .await + { Ok(route) => route, Err(error) => return state_problem(error), }; @@ -1309,10 +1337,11 @@ async fn gateway_responses( Ok(request) => request, Err(error) => return openai_error(StatusCode::BAD_REQUEST, error), }; - let route = match meter_inference_route(&state, &auth, &instance, route).await { - Ok(route) => route, - Err(error) => return state_problem(error), - }; + let route = + match meter_inference_route(&state, &auth, &instance, route, "openai.responses").await { + Ok(route) => route, + Err(error) => return state_problem(error), + }; let token_permit = match auth.acquire_inference().await { Ok(permit) => permit, Err(()) => return gateway_upstream_unavailable(), @@ -1415,6 +1444,11 @@ async fn gateway_embeddings( if !route.profile.allows(PublicAction::Embeddings) { return openai_not_found().await; } + let route = + match meter_inference_route(&state, &auth, &instance, route, "openai.embeddings").await { + Ok(route) => route, + Err(error) => return state_problem(error), + }; let rewritten = match gateway::rewrite_embeddings_request(&body, &route.served_model, &route.profile) { Ok(request) => request, @@ -1481,7 +1515,13 @@ async fn gateway_chat_completions( }; let mut metered_route = (*route).clone(); metered_route.upstream = metered_route.upstream.with_meter(Arc::new( - match super::sessions::UsageMeter::begin(state.database.as_ref(), &auth.id, &instance).await + match super::sessions::UsageMeter::begin_protocol( + state.database.as_ref(), + &auth.id, + &instance, + "openai.chat", + ) + .await { Ok(meter) => meter, Err(error) => return state_problem(error), @@ -1643,23 +1683,37 @@ async fn responses_json( while let Some(event) = upstream.next().await { match event { Ok(GenerationEvent::Done) => { - if encoder.accept(GenerationEvent::Done).is_err() { + if let Err(error) = encoder.accept(GenerationEvent::Done) { + upstream.response_failed(); + tracing::warn!( + event_code = "spark.inference.response-invalid", + reason = error.message + ); return gateway_upstream_unavailable(); } done = true; break; } Ok(event) => { - if encoder.accept(event).is_err() { + if let Err(error) = encoder.accept(event) { + upstream.response_failed(); + tracing::warn!( + event_code = "spark.inference.response-invalid", + reason = error.message + ); return gateway_upstream_unavailable(); } } - _ => return gateway_upstream_unavailable(), + _ => { + upstream.response_failed(); + return gateway_upstream_unavailable(); + } } } if done { Json(encoder.final_document()).into_response() } else { + upstream.response_failed(); gateway_upstream_unavailable() } } @@ -1689,12 +1743,18 @@ fn responses_sse( match upstream.next().await { Some(Ok(event)) => { terminal = matches!(event, GenerationEvent::Done); - if encoder.accept(event).is_err() { - encoder.fail(); + if let Err(error) = encoder.accept(event) { + upstream.response_failed(); + tracing::warn!( + event_code = "spark.inference.response-invalid", + reason = error.message + ); + encoder.fail_with_message(error.message); terminal = true; } } _ => { + upstream.response_failed(); encoder.fail(); terminal = true; } @@ -2607,7 +2667,7 @@ async fn reconcile_once( .into_iter() .map(|engine| ((engine.instance_id.clone(), engine.generation), engine)) .collect::>(); - let operations = database.list_operations().await.map_err(|_| ())?; + let operations = database.list_operation_summaries().await.map_err(|_| ())?; for instance in instances { let Ok(_transition) = coordinator.try_acquire(format!("reconcile:{}:{}", instance.id, instance.generation)) @@ -4054,7 +4114,10 @@ async fn metrics(State(state): State, RawQuery(query): RawQuery) -> } let (operations, instances, models) = match &state.database { Some(database) => { - let operations = database.list_operations().await.map(|items| items.len()); + let operations = database + .list_operation_summaries() + .await + .map(|items| items.len()); let instances = database.list_instances().await.map(|items| items.len()); let models = database.list_models().await.map(|items| items.len()); match (operations, instances, models) { @@ -4104,6 +4167,21 @@ impl AuthenticatedToken { #[utoipa::path(get, path = "/api/sparkplane/v1/operations", responses((status = 200, body = OperationListDocument)))] async fn list_operations(State(state): State, RawQuery(query): RawQuery) -> Response { + if query.as_deref() == Some("view=summary") { + let Some(database) = &state.database else { + return database_unavailable(); + }; + return match database + .panel_query( + crate::spark::analytics::QueryKind::Operations, + crate::spark::analytics::AnalyticsQuery::default(), + ) + .await + { + Ok(operations) => Json(operations).into_response(), + Err(error) => state_problem(error), + }; + } if let Some(response) = reject_query(query) { return response; } @@ -4925,7 +5003,9 @@ async fn authenticate( next: Next, ) -> Response { let request_path = request.uri().path().to_owned(); - if headers.contains_key(header::ORIGIN) { + let cookie_auth = web::authenticate_cookie(&state, &request); + let using_cookie = cookie_auth.is_some(); + if headers.contains_key(header::ORIGIN) && cookie_auth.is_none() { return authentication_layer_error( &request_path, StatusCode::FORBIDDEN, @@ -4961,61 +5041,72 @@ async fn authenticate( (Some(token), None) | (None, Some(token)) => Some(token), _ => None, }; - let Some(presented) = presented else { - return authentication_layer_error( - &request_path, - StatusCode::UNAUTHORIZED, - "spark.auth.failed", - "authentication failed", - ); - }; - let auth = if token_matches(state.token.expose_secret(), presented) { - AuthenticatedToken::admin(state.inference_slot("bootstrap-admin", 64)) + let auth = if let Some(auth) = cookie_auth { + auth } else { - let Some((id, secret)) = parse_bearer(presented) else { - return auth_failed(&request_path); - }; - let snapshot = state.auth.load(); - let Some(verifier) = snapshot.tokens.get(id) else { - return auth_failed(&request_path); + let Some(presented) = presented else { + return authentication_layer_error( + &request_path, + StatusCode::UNAUTHORIZED, + "spark.auth.failed", + "authentication failed", + ); }; - if verifier.token.revoked_at.is_some() - || verifier.token.expires_at.as_ref().is_some_and(|expiry| { - chrono::DateTime::parse_from_rfc3339(expiry) - .map_or(true, |expiry| expiry <= chrono::Utc::now()) - }) - { - return auth_failed(&request_path); - } - if !verifier.verify( - &state - .database - .as_ref() - .map(DbActor::pepper) - .unwrap_or_else(|| Arc::new(SecretString::from("invalid"))), - secret, - ) { - return auth_failed(&request_path); - } - if let Some(peer) = request.extensions().get::>() - && !verifier.token.allowed_cidrs.is_empty() - && !verifier - .token - .allowed_cidrs - .iter() - .filter_map(|value| value.parse::().ok()) - .any(|cidr| cidr.contains(peer.ip())) - { - return auth_failed(&request_path); - } - AuthenticatedToken { - id: id.into(), - scopes: verifier.token.scopes.clone(), - inference: state.inference_slot(id, verifier.token.max_concurrent_inference), + if token_matches(state.token.expose_secret(), presented) { + AuthenticatedToken::admin(state.inference_slot("bootstrap-admin", 64)) + } else { + let Some((id, secret)) = parse_bearer(presented) else { + return auth_failed(&request_path); + }; + let snapshot = state.auth.load(); + let Some(verifier) = snapshot.tokens.get(id) else { + return auth_failed(&request_path); + }; + if verifier.token.revoked_at.is_some() + || verifier.token.expires_at.as_ref().is_some_and(|expiry| { + chrono::DateTime::parse_from_rfc3339(expiry) + .map_or(true, |expiry| expiry <= chrono::Utc::now()) + }) + { + return auth_failed(&request_path); + } + if !verifier.verify( + &state + .database + .as_ref() + .map(DbActor::pepper) + .unwrap_or_else(|| Arc::new(SecretString::from("invalid"))), + secret, + ) { + return auth_failed(&request_path); + } + if let Some(peer) = request.extensions().get::>() + && !verifier.token.allowed_cidrs.is_empty() + && !verifier + .token + .allowed_cidrs + .iter() + .filter_map(|value| value.parse::().ok()) + .any(|cidr| cidr.contains(peer.ip())) + { + return auth_failed(&request_path); + } + AuthenticatedToken { + id: id.into(), + scopes: verifier.token.scopes.clone(), + inference: state.inference_slot(id, verifier.token.max_concurrent_inference), + } } }; let required = required_scope(request.method(), request.uri().path()); if required.as_ref().is_some_and(|scope| !auth.permits(scope)) { + if using_cookie { + return problem( + StatusCode::FORBIDDEN, + "spark.auth.scope-required", + "token does not permit this action", + ); + } return auth_failed(&request_path); } let limiter_key = format!( @@ -5054,6 +5145,14 @@ fn parse_bearer(value: &str) -> Option<(&str, &str)> { } fn required_scope(method: &Method, path: &str) -> Option { + if path.starts_with(&format!("{API_BASE}/analytics")) + || path.starts_with(&format!("{API_BASE}/health")) + { + return Some(TokenScope::AnalyticsRead); + } + if path == format!("{API_BASE}/audit") { + return Some(TokenScope::Admin); + } if path.starts_with("/openai/") || path.starts_with("/anthropic/") { return Some(TokenScope::Inference); } @@ -5465,7 +5564,12 @@ pub async fn serve( state = state.with_executor(executor); } state.certificate = certificate_status; + Arc::get_mut(&mut state.web) + .expect("unshared initial web state") + .config = config.webui; + web::validate_config(&state)?; let state = state.with_allowed_clients(allowed_clients); + tokio::spawn(web::sample_health(state.clone())); if let Some(executor) = state.executor.clone() { let routes = state.routes.clone(); let coordinator = state.admission.clone(); @@ -8489,8 +8593,17 @@ mod tests { false, true, ), + ( + "/openai/ornith/v1/responses", + serde_json::json!({"input":"reasoning-only fixture","stream":true}), + false, + false, + ), ] { - let fixture = if missing { + let failed_translation = body["input"] == "reasoning-only fixture"; + let fixture = if failed_translation { + reasoning_only_chat_sse() + } else if missing { llama_chat_sse() .lines() .filter(|line| !line.contains("usage")) @@ -8531,6 +8644,12 @@ mod tests { String::from_utf8_lossy(&output) ); assert!(!output.is_empty()); + if failed_translation { + let output = String::from_utf8_lossy(&output); + assert!(output.contains("response.failed")); + assert!(output.contains("upstream generation produced no actionable output")); + assert!(!output.contains("response.completed")); + } task.await.unwrap(); } for stream in [false, true] { @@ -8607,11 +8726,27 @@ mod tests { .json() .await .unwrap(); - assert_eq!(finished.usage.requests, 6); - assert_eq!(finished.usage.input_tokens, 43); - assert_eq!(finished.usage.output_tokens, 19); + assert_eq!(finished.usage.requests, 7); + assert_eq!(finished.usage.input_tokens, 50); + assert_eq!(finished.usage.output_tokens, 22); + assert_eq!(finished.usage.failed_requests, 1); assert_eq!(finished.usage.unknown_usage_requests, 1); assert_eq!(finished.usage.pending_requests, 0); + let analytics: serde_json::Value = client + .get(format!("{base}{API_BASE}/analytics?session={id}")) + .bearer_auth(TOKEN) + .send() + .await + .unwrap() + .error_for_status() + .unwrap() + .json() + .await + .unwrap(); + assert_eq!(analytics["summary"]["requests"], 7); + assert_eq!(analytics["summary"]["failed_requests"], 1); + assert_eq!(analytics["summary"]["input_tokens"], 50); + assert_eq!(analytics["summary"]["output_tokens"], 22); let repeated: LaunchSessionDocument = client .post(&finish) .bearer_auth(TOKEN) @@ -8624,7 +8759,7 @@ mod tests { .await .unwrap(); assert_eq!(finished.finished_at, repeated.finished_at); - assert_eq!(repeated.usage.input_tokens, 43); + assert_eq!(repeated.usage.input_tokens, 50); assert_eq!( client .get(format!("{base}/openai/ornith/v1/models")) diff --git a/src/spark/analytics.rs b/src/spark/analytics.rs new file mode 100644 index 0000000..613e06a --- /dev/null +++ b/src/spark/analytics.rs @@ -0,0 +1,1138 @@ +//! Content-free analytics, retained by the existing bounded database actor. +use super::{ + economics::{Compression, Price}, + state::{DbActor, StateError}, +}; +use rusqlite::{Connection, OptionalExtension, params}; +use serde::Deserialize; +use serde_json::{Value, json}; +use sha2::{Digest, Sha256}; +use tokio::sync::oneshot; + +const MIGRATION: &str = r#" +CREATE TABLE panel_token_scopes (token_id TEXT PRIMARY KEY REFERENCES token_metadata(id) ON DELETE CASCADE, analytics_read INTEGER NOT NULL CHECK(analytics_read=1)); +CREATE TABLE panel_requests ( + id TEXT PRIMARY KEY, token_id TEXT NOT NULL, session_id TEXT, model TEXT NOT NULL, + instance TEXT NOT NULL, generation INTEGER NOT NULL, integration TEXT NOT NULL, + protocol TEXT NOT NULL, started_at TEXT NOT NULL, finished_at TEXT, + input_tokens INTEGER, output_tokens INTEGER, outcome TEXT NOT NULL DEFAULT 'pending', + accounting_error INTEGER NOT NULL DEFAULT 0, duration_ms INTEGER, ttft_ms INTEGER +); +CREATE INDEX panel_requests_time ON panel_requests(started_at); +CREATE TABLE panel_usage_daily ( + day TEXT NOT NULL, model TEXT NOT NULL, instance TEXT NOT NULL, token_id TEXT NOT NULL, + integration TEXT NOT NULL, session_id TEXT NOT NULL, generation INTEGER NOT NULL, protocol TEXT NOT NULL, + requests INTEGER NOT NULL DEFAULT 0, input_tokens INTEGER NOT NULL DEFAULT 0, output_tokens INTEGER NOT NULL DEFAULT 0, + unknown_usage_requests INTEGER NOT NULL DEFAULT 0, pending_requests INTEGER NOT NULL DEFAULT 0, + failed_requests INTEGER NOT NULL DEFAULT 0, accounting_errors INTEGER NOT NULL DEFAULT 0, + long_context_input_tokens INTEGER NOT NULL DEFAULT 0, long_context_output_tokens INTEGER NOT NULL DEFAULT 0, + duration_ms INTEGER NOT NULL DEFAULT 0, duration_samples INTEGER NOT NULL DEFAULT 0, + ttft_ms INTEGER NOT NULL DEFAULT 0, ttft_samples INTEGER NOT NULL DEFAULT 0, + PRIMARY KEY(day,model,instance,token_id,integration,session_id,generation,protocol) +); +CREATE TABLE panel_session_reports (session_id TEXT PRIMARY KEY REFERENCES launch_sessions(id) ON DELETE CASCADE, report_json TEXT NOT NULL); +CREATE TABLE panel_rtk_daily (session_id TEXT PRIMARY KEY,day TEXT NOT NULL,model TEXT NOT NULL,integration TEXT NOT NULL,instance TEXT NOT NULL,token_id TEXT NOT NULL,report_json TEXT NOT NULL); +CREATE INDEX panel_rtk_day ON panel_rtk_daily(day); +CREATE TABLE panel_health (resolution TEXT NOT NULL, bucket INTEGER NOT NULL, sample_json TEXT NOT NULL, PRIMARY KEY(resolution,bucket)); +"#; + +pub(crate) fn migration_needed(db: &Connection) -> Result { + db.query_row( + "SELECT NOT EXISTS(SELECT 1 FROM sqlite_master WHERE name='panel_migrations')", + [], + |r| r.get(0), + ) + .map_err(sql) +} +pub(crate) fn migrate(db: &mut Connection) -> Result<(), StateError> { + let checksum = format!("{:x}", Sha256::digest(MIGRATION)); + if !migration_needed(db)? { + let versions: Vec<(u32, String)> = db + .prepare("SELECT version,checksum FROM panel_migrations ORDER BY version") + .map_err(sql)? + .query_map([], |r| Ok((r.get(0)?, r.get(1)?))) + .map_err(sql)? + .collect::>() + .map_err(sql)?; + if versions != [(1, checksum)] { + return Err(StateError::Unavailable( + "unsupported or modified panel migration".into(), + )); + } + return Ok(()); + } + let tx = db.transaction().map_err(sql)?; + tx.execute_batch( + "CREATE TABLE panel_migrations(version INTEGER PRIMARY KEY,checksum TEXT NOT NULL);", + ) + .map_err(sql)?; + tx.execute_batch(MIGRATION).map_err(sql)?; + tx.execute("INSERT INTO panel_migrations VALUES(1,?1)", [checksum]) + .map_err(sql)?; + tx.execute_batch("INSERT INTO panel_requests(id,token_id,session_id,model,instance,generation,integration,protocol,started_at,finished_at,input_tokens,output_tokens,outcome,accounting_error) SELECT r.id,s.token_id,s.id,s.model,r.instance,0,s.integration,'historical',r.started_at,r.finished_at,r.input_tokens,r.output_tokens,r.outcome,r.accounting_error FROM launch_requests r JOIN launch_sessions s ON r.session_id=s.id;") .map_err(sql)?; + tx.execute_batch("INSERT INTO panel_usage_daily(day,model,instance,token_id,integration,session_id,generation,protocol,requests,input_tokens,output_tokens,unknown_usage_requests,pending_requests,failed_requests,accounting_errors,long_context_input_tokens,long_context_output_tokens) SELECT substr(started_at,1,10),model,instance,token_id,integration,COALESCE(session_id,''),generation,protocol,COUNT(*),COALESCE(SUM(input_tokens),0),COALESCE(SUM(output_tokens),0),SUM(input_tokens IS NULL),SUM(finished_at IS NULL),SUM(outcome NOT IN ('succeeded','pending')),SUM(accounting_error),COALESCE(SUM(CASE WHEN input_tokens>272000 THEN input_tokens ELSE 0 END),0),COALESCE(SUM(CASE WHEN input_tokens>272000 THEN output_tokens ELSE 0 END),0) FROM panel_requests GROUP BY 1,2,3,4,5,6,7,8;").map_err(sql)?; + tx.commit().map_err(sql) +} +fn sql(error: rusqlite::Error) -> StateError { + StateError::Unavailable(format!("panel database: {error}")) +} + +// Meters belong to the previous agent process and cannot complete after restart. +// Retain unknown usage and close their pending accounting exactly once. +pub(crate) fn interrupt_pending(db: &mut Connection) -> Result<(), StateError> { + let tx = db.transaction().map_err(sql)?; + tx.execute_batch("UPDATE panel_usage_daily SET failed_requests=failed_requests+pending_requests,accounting_errors=accounting_errors+pending_requests,pending_requests=0 WHERE pending_requests>0;") .map_err(sql)?; + let now = super::state::now(); + for table in ["panel_requests", "launch_requests"] { + tx.execute( + &format!("UPDATE {table} SET finished_at=?1,outcome='interrupted',accounting_error=1 WHERE finished_at IS NULL"), + [&now], + ).map_err(sql)?; + } + tx.commit().map_err(sql) +} + +pub(crate) enum Command { + Query { + kind: QueryKind, + query: AnalyticsQuery, + reply: oneshot::Sender>, + }, + Compression { + actor: String, + session: String, + report: Compression, + reply: oneshot::Sender>, + }, + Health { + sample: Value, + reply: oneshot::Sender>, + }, + Cleanup { + reply: oneshot::Sender>, + }, +} +pub(crate) enum QueryKind { + Summary, + Operations, + Requests, + Sessions, + Audit, + Health, +} +#[derive(Clone, Debug, Deserialize)] +#[serde(default, deny_unknown_fields)] +pub struct AnalyticsQuery { + pub days: u32, + pub offset: u32, + pub limit: u32, + pub model: Option, + pub instance: Option, + pub token: Option, + pub integration: Option, + pub session: Option, + pub previous: bool, +} +impl Default for AnalyticsQuery { + fn default() -> Self { + Self { + days: 7, + offset: 0, + limit: 50, + model: None, + instance: None, + token: None, + integration: None, + session: None, + previous: false, + } + } +} +impl AnalyticsQuery { + pub fn validate(&self) -> Result<(), StateError> { + if !(1..=365).contains(&self.days) + || !(1..=200).contains(&self.limit) + || self.offset > 100000 + || [ + &self.model, + &self.instance, + &self.token, + &self.integration, + &self.session, + ] + .into_iter() + .flatten() + .any(|s| s.len() > 256) + { + return Err(StateError::Invalid( + "invalid analytics range or pagination".into(), + )); + } + Ok(()) + } + fn dates(&self) -> (String, String) { + let end = chrono::Utc::now().date_naive() + chrono::Duration::days(1) + - chrono::Duration::days(if self.previous { + i64::from(self.days) + } else { + 0 + }); + let start = end - chrono::Duration::days(i64::from(self.days)); + (start.to_string(), end.to_string()) + } +} +impl DbActor { + pub(crate) async fn list_operation_summaries( + &self, + ) -> Result, StateError> { + let mut summary = self + .panel_query(QueryKind::Operations, AnalyticsQuery::default()) + .await?; + serde_json::from_value(summary["operations"].take()) + .map_err(|_| StateError::Unavailable("invalid operation metadata".into())) + } + pub(crate) async fn panel_query( + &self, + kind: QueryKind, + query: AnalyticsQuery, + ) -> Result { + query.validate()?; + let (reply, receive) = oneshot::channel(); + self.panel_command(Command::Query { kind, query, reply })?; + receive + .await + .map_err(|_| StateError::Unavailable("panel database unavailable".into()))? + } + pub async fn session_compression( + &self, + actor: &str, + session: &str, + report: Compression, + ) -> Result { + let (reply, receive) = oneshot::channel(); + self.panel_command(Command::Compression { + actor: actor.into(), + session: session.into(), + report, + reply, + })?; + receive + .await + .map_err(|_| StateError::Unavailable("panel database unavailable".into()))? + } + pub(crate) async fn panel_health(&self, sample: Value) -> Result<(), StateError> { + let (reply, receive) = oneshot::channel(); + self.panel_command(Command::Health { sample, reply })?; + receive + .await + .map_err(|_| StateError::Unavailable("panel database unavailable".into()))? + } + pub(crate) async fn panel_cleanup(&self) -> Result<(), StateError> { + let (reply, receive) = oneshot::channel(); + self.panel_command(Command::Cleanup { reply })?; + receive + .await + .map_err(|_| StateError::Unavailable("panel database unavailable".into()))? + } +} +pub(crate) fn begin( + db: &Connection, + id: &str, + token: &str, + instance: &str, + protocol: &str, +) -> Result<(), StateError> { + let session: Option<(String,String,String)> = db.query_row("SELECT id,model,integration FROM launch_sessions WHERE token_id=?1 AND finished_at IS NULL",[token],|r|Ok((r.get(0)?,r.get(1)?,r.get(2)?))).optional().map_err(sql)?; + let document = super::state::read_instance(db, instance).ok(); + let model = document + .as_ref() + .map(|d| d.model.clone()) + .or_else(|| session.as_ref().map(|s| s.1.clone())) + .unwrap_or_else(|| instance.into()); + let generation = i64::try_from(document.as_ref().map(|d| d.generation).unwrap_or(0)) + .map_err(|_| StateError::Invalid("generation overflow".into()))?; + let integration = session.as_ref().map(|s| s.2.as_str()).unwrap_or("api"); + let now = super::state::now(); + db.execute("INSERT INTO panel_requests(id,token_id,session_id,model,instance,generation,integration,protocol,started_at) VALUES(?1,?2,?3,?4,?5,?6,?7,?8,?9)",params![id,token,session.as_ref().map(|s|&s.0),model,instance,generation,integration,protocol,now]).map_err(sql)?; + db.execute("INSERT INTO panel_usage_daily(day,model,instance,token_id,integration,session_id,generation,protocol,requests,unknown_usage_requests,pending_requests) VALUES(substr(?1,1,10),?2,?3,?4,?5,?6,?7,?8,1,1,1) ON CONFLICT DO UPDATE SET requests=requests+1,unknown_usage_requests=unknown_usage_requests+1,pending_requests=pending_requests+1",params![now,model,instance,token,integration,session.as_ref().map(|s|s.0.as_str()).unwrap_or(""),generation,protocol]).map_err(sql)?; + Ok(()) +} +pub(crate) fn record( + db: &Connection, + id: &str, + counts: Option<(i64, i64)>, + outcome: &str, + incomplete: bool, + duration_ms: Option, + ttft_ms: Option, +) -> Result<(), StateError> { + let changed=db.execute("UPDATE panel_requests SET input_tokens=?2,output_tokens=?3,outcome=?4,accounting_error=?5,finished_at=?6,duration_ms=?7,ttft_ms=?8 WHERE id=?1 AND finished_at IS NULL",params![id,counts.map(|c|c.0),counts.map(|c|c.1),outcome,incomplete,super::state::now(),duration_ms.map(|v|v.min(i64::MAX as u64) as i64),ttft_ms.map(|v|v.min(i64::MAX as u64) as i64)]).map_err(sql)?; + if changed == 0 { + return Ok(()); + } + db.execute("UPDATE panel_usage_daily SET input_tokens=input_tokens+?2,output_tokens=output_tokens+?3,unknown_usage_requests=unknown_usage_requests-?4,pending_requests=pending_requests-1,failed_requests=failed_requests+?5,accounting_errors=accounting_errors+?6,long_context_input_tokens=long_context_input_tokens+?7,long_context_output_tokens=long_context_output_tokens+?8,duration_ms=duration_ms+?9,duration_samples=duration_samples+?10,ttft_ms=ttft_ms+?11,ttft_samples=ttft_samples+?12 WHERE (day,model,instance,token_id,integration,session_id,generation,protocol)=(SELECT substr(started_at,1,10),model,instance,token_id,integration,COALESCE(session_id,''),generation,protocol FROM panel_requests WHERE id=?1)",params![id,counts.map(|c|c.0).unwrap_or(0),counts.map(|c|c.1).unwrap_or(0),counts.is_some(),outcome!="succeeded",incomplete,counts.filter(|c|c.0>272000).map(|c|c.0).unwrap_or(0),counts.filter(|c|c.0>272000).map(|c|c.1).unwrap_or(0),duration_ms.unwrap_or(0).min(i64::MAX as u64) as i64,duration_ms.is_some(),ttft_ms.unwrap_or(0).min(i64::MAX as u64) as i64,ttft_ms.is_some()]).map_err(sql)?; + Ok(()) +} +pub(crate) fn dispatch(db: &mut Connection, command: Command) { + match command { + Command::Query { kind, query, reply } => { + let _ = reply.send(query_data(db, kind, query)); + } + Command::Compression { + actor, + session, + report, + reply, + } => { + let _ = reply.send(compression(db, &actor, &session, report)); + } + Command::Health { sample, reply } => { + let _ = reply.send(store_health(db, &sample)); + } + Command::Cleanup { reply } => { + let _ = reply.send(cleanup(db)); + } + } +} +fn rows( + db: &Connection, + sql_text: &str, + parameters: impl rusqlite::Params, +) -> Result, StateError> { + let mut statement = db.prepare(sql_text).map_err(sql)?; + let names = statement + .column_names() + .iter() + .map(|s| s.to_string()) + .collect::>(); + statement + .query_map(parameters, |row| { + let mut object = serde_json::Map::new(); + for (i, name) in names.iter().enumerate() { + let value = match row.get_ref(i)? { + rusqlite::types::ValueRef::Null => Value::Null, + rusqlite::types::ValueRef::Integer(v) => json!(v), + rusqlite::types::ValueRef::Real(v) => json!(v), + rusqlite::types::ValueRef::Text(v) => json!(String::from_utf8_lossy(v)), + rusqlite::types::ValueRef::Blob(_) => Value::Null, + }; + object.insert(name.clone(), value); + } + Ok(Value::Object(object)) + }) + .map_err(sql)? + .collect::>() + .map_err(sql) +} +const FILTER: &str = "day>=?1 AND day Result { + query.validate()?; + let (start, end) = query.dates(); + let parameters = params![ + start, + end, + query.model, + query.instance, + query.token, + query.integration, + query.session + ]; + match kind { + QueryKind::Operations => { + // Qualification evidence can be megabytes per operation. Select + // list metadata directly without loading or decoding result_json. + let mut operations = rows( + db, + "SELECT id,kind,actor_token_id,target,state,progress_json progress,created_at,updated_at,NULL result,problem_json problem FROM operations ORDER BY created_at DESC,id DESC LIMIT 256", + [], + )?; + for operation in &mut operations { + operation["schema"] = json!(super::wire::OPERATION_SCHEMA); + for key in ["progress", "problem"] { + if let Some(text) = operation[key].as_str() { + operation[key] = serde_json::from_str(text).map_err(|_| { + StateError::Unavailable("invalid operation metadata".into()) + })?; + } + } + } + Ok(json!({"schema":super::wire::OPERATION_LIST_SCHEMA,"operations":operations})) + } + QueryKind::Summary => { + let catalog = + super::economics::catalog().map_err(|e| StateError::Unavailable(e.to_string()))?; + let mut summary = rows( + db, + &format!("SELECT {SUMS} FROM panel_usage_daily WHERE {FILTER}"), + parameters, + )? + .remove(0); + // Price each actual model before aggregation. Never apply one model's + // tariff to another model, or silently present an unpriced subtotal. + let models = rows( + db, + &format!( + "SELECT model,{SUMS} FROM panel_usage_daily WHERE {FILTER} GROUP BY model ORDER BY requests DESC,model" + ), + parameters, + )?; + let mut equivalent = Some(0u64); + let mut unpriced_requests = 0u64; + let mut comparisons = Vec::new(); + for usage in &models { + let model = usage["model"].as_str().unwrap_or_default(); + let price = catalog.models.iter().find(|p| p.matches_model(model)); + let value = price.and_then(|p| cost(usage, p)); + equivalent = equivalent + .zip(value) + .and_then(|(total, value)| total.checked_add(value)); + if price.is_none() { + unpriced_requests = + unpriced_requests.saturating_add(usage["requests"].as_u64().unwrap_or(0)); + } + if comparisons.len() < 200 { + comparisons.push(json!({"model":model,"cloud_model":price.map(|p|&p.model),"provider":price.and_then(|p|p.provider.as_ref()),"source":price.map(|p|&p.source),"verified_at":price.map(|p|&p.verified_at),"cloud_equivalent_usd_nanos":value})); + } + } + let series = rows( + db, + &format!( + "SELECT day,{SUMS} FROM panel_usage_daily WHERE {FILTER} GROUP BY day ORDER BY day" + ), + parameters, + )?; + let mut breakdown = serde_json::Map::new(); + for key in [ + "model", + "instance", + "token_id", + "integration", + "session_id", + "protocol", + ] { + breakdown.insert(key.into(),json!(rows(db,&format!("SELECT {key},{SUMS} FROM panel_usage_daily WHERE {FILTER} GROUP BY {key} ORDER BY requests DESC LIMIT 200"),parameters)?)); + } + let reports = rows( + db, + &format!("SELECT model,report_json FROM panel_rtk_daily WHERE {FILTER}"), + parameters, + )?; + let mut compression = Compression { + status: "active".into(), + ..Default::default() + }; + let mut covered = 0; + let mut unpriced_sessions = 0; + let mut saved_tokens = 0u64; + let mut rtk_value = Some(0u64); + for row in &reports { + if let Some(text) = row["report_json"].as_str() + && let Ok(report) = serde_json::from_str::(text) + && report.status == "active" + && report.metrics_errors == 0 + { + compression.raw_bytes = compression.raw_bytes.saturating_add(report.raw_bytes); + compression.filtered_bytes = compression + .filtered_bytes + .saturating_add(report.filtered_bytes); + compression.commands = compression.commands.saturating_add(report.commands); + covered += 1; + saved_tokens = saved_tokens.saturating_add(report.saved_tokens()); + let price = catalog + .models + .iter() + .find(|p| p.matches_model(row["model"].as_str().unwrap_or_default())); + if price.is_none() { + unpriced_sessions += 1; + } + let value = price.and_then(|p| { + u64::try_from( + u128::from(report.saved_tokens()) + * u128::from(p.input_microusd_per_million) + / 1000, + ) + .ok() + }); + rtk_value = rtk_value + .zip(value) + .and_then(|(total, value)| total.checked_add(value)); + } + } + summary["comparisons"] = json!(comparisons); + summary["cloud_equivalent_usd_nanos"] = json!(equivalent); + summary["unpriced_requests"] = json!(unpriced_requests); + if covered == 0 { + rtk_value = None; + } + Ok( + json!({"schema":"sparkplane.analytics/v1","from":start,"to":end,"summary":summary,"series":series,"breakdown":breakdown,"catalog":catalog,"rtk":{"client_reported":true,"reported_sessions":reports.len(),"covered_sessions":covered,"unpriced_sessions":unpriced_sessions,"commands":compression.commands,"raw_bytes":compression.raw_bytes,"filtered_bytes":compression.filtered_bytes,"estimated_saved_tokens":saved_tokens,"estimated_saved_usd_nanos":rtk_value},"coverage":{"request_detail_days":90,"rollup_days":365,"historical_clients":"launch sessions only before panel upgrade"}}), + ) + } + QueryKind::Requests => { + let filter = FILTER.replace("day", "substr(started_at,1,10)"); + let items = rows( + db, + &format!( + "SELECT * FROM panel_requests WHERE {filter} ORDER BY started_at DESC,id DESC LIMIT ?8 OFFSET ?9" + ), + params![ + start, + end, + query.model, + query.instance, + query.token, + query.integration, + query.session, + query.limit + 1, + query.offset + ], + )?; + Ok(page(items, &query)) + } + QueryKind::Sessions => { + let items = rows( + db, + "SELECT s.id,s.token_id,s.instance,s.model,s.integration,s.eco_mode,s.started_at,s.finished_at,p.report_json compression_json FROM launch_sessions s LEFT JOIN panel_session_reports p ON p.session_id=s.id WHERE substr(s.started_at,1,10)>=?1 AND substr(s.started_at,1,10) Ok(page( + rows( + db, + "SELECT sequence,occurred_at,actor_token_id,action,target,outcome,metadata_json FROM audit WHERE substr(occurred_at,1,10)>=?1 AND substr(occurred_at,1,10) { + let resolution = if query.days == 1 { + "raw" + } else if query.days <= 30 { + "minute" + } else { + "hour" + }; + let after = (chrono::Utc::now() - chrono::Duration::days(i64::from(query.days))) + .timestamp_millis(); + let width = match resolution { + "raw" => 5000, + "minute" => 60000, + _ => 3600000, + }; + let stride = + (i64::from(query.days) * 86400000 / i64::from(query.limit) / width).max(1) * width; + // Group only timestamp keys. Sorting every full telemetry document + // can spill outside the confined agent's writable paths as history + // grows; fetch at most one bounded page of documents afterwards. + let mut items = rows( + db, + "SELECT MAX(bucket) bucket FROM panel_health WHERE resolution=?1 AND bucket>=?2 GROUP BY bucket/?3 ORDER BY bucket DESC LIMIT ?4 OFFSET ?5", + params![resolution, after, stride, query.limit + 1, query.offset], + )?; + let mut samples = db + .prepare("SELECT sample_json FROM panel_health WHERE resolution=?1 AND bucket=?2") + .map_err(sql)?; + for item in &mut items { + let sample: String = samples + .query_row(params![resolution, item["bucket"].as_i64()], |row| { + row.get(0) + }) + .map_err(sql)?; + item["sample_json"] = json!(sample); + } + Ok(page(items, &query)) + } + } +} +fn page(mut items: Vec, query: &AnalyticsQuery) -> Value { + let next = (items.len() > query.limit as usize).then_some(query.offset + query.limit); + items.truncate(query.limit as usize); + json!({"items":items,"next_offset":next}) +} +pub(crate) fn cost(usage: &Value, price: &Price) -> Option { + let requests = usage["requests"].as_u64()?; + if requests > 0 && usage["unknown_usage_requests"].as_u64()? == requests { + return None; + } + if price + .long_context_threshold + .is_some_and(|threshold| threshold != 272000) + { + return None; + } + let input = u128::from(usage["input_tokens"].as_u64()?); + let output = u128::from(usage["output_tokens"].as_u64()?); + let long_input = u128::from(usage["long_context_input_tokens"].as_u64()?); + let long_output = u128::from(usage["long_context_output_tokens"].as_u64()?); + let value = (input.checked_sub(long_input)? * u128::from(price.input_microusd_per_million)) + + (output.checked_sub(long_output)? * u128::from(price.output_microusd_per_million)) + + long_input + * u128::from( + price + .long_input_microusd_per_million + .unwrap_or(price.input_microusd_per_million), + ) + + long_output + * u128::from( + price + .long_output_microusd_per_million + .unwrap_or(price.output_microusd_per_million), + ); + u64::try_from(value / 1000).ok() +} +fn compression( + db: &mut Connection, + actor: &str, + session: &str, + report: Compression, +) -> Result { + if ![ + "active", + "unavailable", + "disabled", + "inactive", + "inactive (inherited permissions)", + "inactive (hook unavailable or awaiting trust)", + ] + .contains(&report.status.as_str()) + || report.raw_bytes > i64::MAX as u64 + || report.filtered_bytes > i64::MAX as u64 + { + return Err(StateError::Invalid( + "invalid aggregate compression report".into(), + )); + } + let text = + serde_json::to_string(&report).map_err(|_| StateError::Invalid("invalid report".into()))?; + if let Some(old) = db + .query_row( + "SELECT report_json FROM panel_session_reports WHERE session_id=?1", + [session], + |r| r.get::<_, String>(0), + ) + .optional() + .map_err(sql)? + { + if old == text { + return Ok(json!({"stored":true})); + } + return Err(StateError::Conflict( + "compression report already finalized".into(), + )); + } + let tx = db.transaction().map_err(sql)?; + let (model,integration,instance,token,finished):(String,String,String,String,Option)=tx.query_row("SELECT model,integration,instance,token_id,finished_at FROM launch_sessions WHERE id=?1",[session],|r|Ok((r.get(0)?,r.get(1)?,r.get(2)?,r.get(3)?,r.get(4)?))).optional().map_err(sql)?.ok_or(StateError::NotFound)?; + let finished = finished.ok_or_else(|| { + StateError::Conflict("finish session before submitting compression".into()) + })?; + tx.execute( + "INSERT INTO panel_session_reports VALUES(?1,?2)", + params![session, text], + ) + .map_err(sql)?; + tx.execute( + "INSERT INTO panel_rtk_daily VALUES(?1,substr(?2,1,10),?3,?4,?5,?6,?7)", + params![session, finished, model, integration, instance, token, text], + ) + .map_err(sql)?; + tx.execute("INSERT INTO audit(occurred_at,actor_token_id,action,target,outcome,metadata_json) VALUES(?1,?2,'launch-session.compression',?3,'succeeded','{}')",params![super::state::now(),actor,session]).map_err(sql)?; + tx.commit().map_err(sql)?; + Ok(json!({"stored":true})) +} +fn store_health(db: &mut Connection, sample: &Value) -> Result<(), StateError> { + let time = sample["observed_at_unix_ms"] + .as_u64() + .ok_or_else(|| StateError::Invalid("health sample lacks time".into()))?; + let text = serde_json::to_string(sample) + .map_err(|_| StateError::Invalid("invalid health sample".into()))?; + let tx = db.transaction().map_err(sql)?; + for (resolution, width) in [("raw", 5000), ("minute", 60000), ("hour", 3600000)] { + tx.execute("INSERT INTO panel_health VALUES(?1,?2,?3) ON CONFLICT DO UPDATE SET sample_json=excluded.sample_json",params![resolution,(time/width*width) as i64,text]).map_err(sql)?; + } + tx.commit().map_err(sql) +} +fn cleanup(db: &mut Connection) -> Result<(), StateError> { + let tx = db.transaction().map_err(sql)?; + tx.execute_batch("DELETE FROM panel_requests WHERE started_at(0)) + .unwrap(), + 272013 + ); + } + #[test] + fn cloud_costs_use_each_models_tariff_and_expose_unpriced_coverage() { + let root = tempfile::tempdir().unwrap(); + let db = DbActor::open( + root.path().join("state"), + root.path().join("backups"), + 64, + 2, + secrecy::SecretString::from("fixture"), + ) + .unwrap(); + db.shutdown().unwrap(); + let connection = Connection::open(root.path().join("state")).unwrap(); + let models = [ + "huggingface:RadixArk/Qwen3.8-Flash-Next-NVFP4@revision#artifact", + "huggingface:Qwen/Qwen3.8-27B-FP8@revision#artifact", + ]; + for (index, model) in models.iter().enumerate() { + connection.execute("INSERT INTO panel_usage_daily(day,model,instance,token_id,integration,session_id,generation,protocol,requests,input_tokens,output_tokens) VALUES(date('now'),?1,'fixture','token','codex',?2,1,'openai.responses',1,100,10)", params![model, index.to_string()]).unwrap(); + connection.execute("INSERT INTO panel_rtk_daily VALUES(?1,date('now'),?2,'codex','fixture','token',?3)", params![index.to_string(), model, serde_json::to_string(&Compression {status:"active".into(), commands:1, raw_bytes:400, filtered_bytes:0, metrics_errors:0}).unwrap()]).unwrap(); + } + let summary = + query_data(&connection, QueryKind::Summary, AnalyticsQuery::default()).unwrap(); + assert_eq!(summary["summary"]["cloud_equivalent_usd_nanos"], 89_000); + assert_eq!(summary["summary"]["unpriced_requests"], 0); + assert_eq!(summary["rtk"]["estimated_saved_usd_nanos"], 60_000); + let filtered = query_data( + &connection, + QueryKind::Summary, + AnalyticsQuery { + model: Some(models[0].into()), + ..Default::default() + }, + ) + .unwrap(); + assert_eq!(filtered["summary"]["cloud_equivalent_usd_nanos"], 25_000); + connection.execute("INSERT INTO panel_usage_daily(day,model,instance,token_id,integration,session_id,generation,protocol,requests,input_tokens) VALUES(date('now'),'unpriced-model','fixture','token','codex','unpriced',1,'openai.responses',1,100)", []).unwrap(); + connection.execute("INSERT INTO panel_rtk_daily VALUES('unpriced',date('now'),'unpriced-model','codex','fixture','token',?1)", [serde_json::to_string(&Compression {status:"active".into(), commands:1, raw_bytes:400, ..Default::default()}).unwrap()]).unwrap(); + let summary = + query_data(&connection, QueryKind::Summary, AnalyticsQuery::default()).unwrap(); + assert!(summary["summary"]["cloud_equivalent_usd_nanos"].is_null()); + assert_eq!(summary["summary"]["unpriced_requests"], 1); + assert_eq!(summary["summary"]["requests"], 3); + assert!(summary["rtk"]["estimated_saved_usd_nanos"].is_null()); + assert_eq!(summary["rtk"]["unpriced_sessions"], 1); + } + #[test] + fn price_tiers_and_unknown_usage_remain_distinct() { + let mut catalog = super::super::economics::catalog().unwrap(); + catalog.models[0].input_microusd_per_million = 2_000_000; + catalog.models[0].output_microusd_per_million = 10_000_000; + catalog.models[0].long_context_threshold = Some(272_000); + catalog.models[0].long_input_microusd_per_million = Some(4_000_000); + catalog.models[0].long_output_microusd_per_million = Some(15_000_000); + let usage = json!({"requests":1,"unknown_usage_requests":0,"input_tokens":272001,"output_tokens":7,"long_context_input_tokens":272001,"long_context_output_tokens":7}); + assert_eq!(cost(&usage, &catalog.models[0]), Some(1088109000)); + let mut unknown = usage; + unknown["unknown_usage_requests"] = json!(1); + assert_eq!(cost(&unknown, &catalog.models[0]), None); + } + #[test] + fn health_history_stays_bounded_with_large_samples() { + // SQLite's heap limit is process-wide, so isolate this resource test. + const CHILD: &str = "SPARKPLANE_HEALTH_MEMORY_TEST_CHILD"; + if std::env::var_os(CHILD).is_none() { + let output = std::process::Command::new(std::env::current_exe().unwrap()) + .args([ + "--exact", + "spark::analytics::tests::health_history_stays_bounded_with_large_samples", + "--nocapture", + ]) + .env(CHILD, "1") + .output() + .unwrap(); + assert!( + output.status.success(), + "{}{}", + String::from_utf8_lossy(&output.stdout), + String::from_utf8_lossy(&output.stderr) + ); + return; + } + let mut db = Connection::open_in_memory().unwrap(); + db.execute_batch("CREATE TABLE panel_health(resolution TEXT NOT NULL,bucket INTEGER NOT NULL,sample_json TEXT NOT NULL,PRIMARY KEY(resolution,bucket)); PRAGMA temp_store=MEMORY;").unwrap(); + let latest = chrono::Utc::now().timestamp_millis() / 5000 * 5000; + let payload = json!({"fixture":"x".repeat(8192)}).to_string(); + let transaction = db.transaction().unwrap(); + for index in 0..6000 { + transaction + .execute( + "INSERT INTO panel_health VALUES('raw',?1,?2)", + params![latest - index * 5000, payload], + ) + .unwrap(); + } + transaction.commit().unwrap(); + db.pragma_update(None, "hard_heap_limit", 96 * 1024 * 1024) + .unwrap(); + let query = AnalyticsQuery { + days: 1, + ..Default::default() + }; + let data = query_data(&db, QueryKind::Health, query).unwrap(); + let items = data["items"].as_array().unwrap(); + assert_eq!(items[0]["bucket"], latest); + assert!(items.len() <= 50); + for item in items { + assert_eq!(item["sample_json"], payload); + } + for pair in items.windows(2) { + assert!(pair[0]["bucket"].as_i64().unwrap() > pair[1]["bucket"].as_i64().unwrap()); + } + } + #[test] + fn retention_preserves_daily_rollups_and_migration_identity() { + let root = tempfile::tempdir().unwrap(); + let db = DbActor::open( + root.path().join("state"), + root.path().join("backups"), + 64, + 2, + secrecy::SecretString::from("fixture"), + ) + .unwrap(); + db.shutdown().unwrap(); + let mut connection = Connection::open(root.path().join("state")).unwrap(); + begin(&connection, "old", "token", "model", "openai.chat").unwrap(); + record( + &connection, + "old", + Some((20, 5)), + "succeeded", + false, + Some(30), + Some(10), + ) + .unwrap(); + connection + .execute( + "UPDATE panel_requests SET started_at=strftime('%Y-%m-%d','now','-100 days')", + [], + ) + .unwrap(); + connection + .execute( + "UPDATE panel_usage_daily SET day=strftime('%Y-%m-%d','now','-100 days')", + [], + ) + .unwrap(); + cleanup(&mut connection).unwrap(); + assert_eq!( + connection + .query_row("SELECT COUNT(*) FROM panel_requests", [], |r| r + .get::<_, i64>(0)) + .unwrap(), + 0 + ); + assert_eq!( + connection + .query_row("SELECT SUM(input_tokens) FROM panel_usage_daily", [], |r| r + .get::<_, i64>(0)) + .unwrap(), + 20 + ); + connection + .execute("UPDATE panel_migrations SET checksum='modified'", []) + .unwrap(); + assert!(migrate(&mut connection).is_err()); + } +} diff --git a/src/spark/client.rs b/src/spark/client.rs index 1a3169e..cd6a188 100644 --- a/src/spark/client.rs +++ b/src/spark/client.rs @@ -263,6 +263,71 @@ impl Drop for SparkClient { } impl SparkClient { + pub fn configured_hosts(config_dir: &Path) -> Result, ClientError> { + let profiles: Profiles = toml::from_str(&read_text(&config_dir.join("spark.toml"))?) + .map_err(|_| usage("invalid Spark host profiles"))?; + Ok(profiles.hosts.into_keys().collect()) + } + + pub fn base_url(&self) -> &Url { + &self.base + } + + pub fn approve_web_login( + &self, + flow: &str, + intent: &str, + ) -> Result { + let url = self + .base + .join("api/sparkplane/v1/web-auth/approve") + .map_err(|_| usage("invalid web authentication route"))?; + let response = self + .http + .post(url) + .bearer_auth(&self.token) + .timeout(Duration::from_secs(5)) + .json(&serde_json::json!({"flow":flow,"intent":intent})) + .send() + .map_err(|_| unreachable("web authentication unavailable"))?; + if !response.status().is_success() { + return Err(map_problem(response.status(), response.json().ok())); + } + decode_response(response) + } + + pub fn web_login_complete(&self, flow: &str) -> Result { + let result: serde_json::Value = + self.get_json(&format!("api/sparkplane/v1/web-auth/flows/{flow}"))?; + Ok(result["complete"].as_bool() == Some(true)) + } + pub fn upload_compression( + &self, + id: &str, + report: &super::economics::Compression, + ) -> Result<(), ClientError> { + if id.parse::().is_err() { + return Err(usage("invalid session id")); + } + let response = self + .http + .post( + self.base + .join(&format!( + "api/sparkplane/v1/launch-sessions/{id}/compression" + )) + .map_err(|_| usage("invalid report route"))?, + ) + .bearer_auth(&self.token) + .timeout(Duration::from_secs(5)) + .json(report) + .send() + .map_err(|_| unreachable("compression report upload unavailable"))?; + if !response.status().is_success() { + return Err(map_problem(response.status(), response.json().ok())); + } + Ok(()) + } pub fn create_launch_session( &self, request: &super::wire::LaunchSessionRequest, diff --git a/src/spark/economics.rs b/src/spark/economics.rs index f2cb813..3a2c845 100644 --- a/src/spark/economics.rs +++ b/src/spark/economics.rs @@ -15,6 +15,10 @@ pub const SCHEMA: &str = "sparkplane.session-economics/v1"; #[derive(Debug, Clone, Serialize, Deserialize)] pub struct Price { pub model: String, + #[serde(default)] + pub aliases: Vec, + #[serde(default)] + pub provider: Option, pub source: String, pub verified_at: String, pub effective_from: String, @@ -24,6 +28,17 @@ pub struct Price { pub long_input_microusd_per_million: Option, pub long_output_microusd_per_million: Option, } +impl Price { + pub fn matches_model(&self, model: &str) -> bool { + let identity = model.strip_prefix("huggingface:").unwrap_or(model); + let identity = identity.split(['@', '#']).next().unwrap_or(identity); + self.model.eq_ignore_ascii_case(identity) + || self + .aliases + .iter() + .any(|alias| alias.eq_ignore_ascii_case(identity)) + } +} #[derive(Debug, Clone, Serialize, Deserialize)] pub struct PriceCatalog { @@ -78,6 +93,7 @@ impl Report { .catalog .models .iter() + .filter(|price| price.matches_model(&self.model)) .map(|price| { let inference = self.inference.as_ref().and_then(|session| { let usage = &session.usage; @@ -247,11 +263,14 @@ pub fn load(config: &Path, host: &str, id: Option<&str>) -> Result { .pop() .ok_or_else(|| anyhow::anyhow!("no retained economics reports"))? }; - let report: Report = read_record(&path)?; + let mut report: Report = read_record(&path)?; ensure!( report.schema == SCHEMA && report.host == host, "economics report identity mismatch" ); + // Retain the original tariff evidence, but stop presenting unrelated models + // in reports produced before same-model matching was introduced. + report.calculate(); Ok(report) } @@ -354,6 +373,9 @@ pub fn render(report: &Report, fancy: bool, width: usize) -> String { } } text.push_str("\nCloud equivalent / estimated RTK savings (USD):\n"); + if report.comparisons.is_empty() { + text.push_str(" Unavailable: no verified public tariff for this model.\n"); + } for row in &report.comparisons { text.push_str(&format!( " {:<20} {:>11} / {:>11}\n", @@ -362,16 +384,19 @@ pub fn render(report: &Report, fancy: bool, width: usize) -> String { money(row.estimated_rtk_usd_nanos) )); } - text.push_str(&format!( - "Public standard uncached rates · verified {}\n", - report - .catalog - .models - .first() - .map(|p| p.verified_at.as_str()) - .unwrap_or("unknown") - )); - text.push_str("Estimates use local token counts; RTK is valued once at input rates.\nCloud comparisons exclude electricity/hardware and are not added together.\n"); + for price in report + .catalog + .models + .iter() + .filter(|p| p.matches_model(&report.model)) + { + text.push_str(&format!( + "{} standard uncached rates · verified {}\n", + price.provider.as_deref().unwrap_or("Public"), + price.verified_at + )); + } + text.push_str("Same-model estimates use local token counts; cloud quantization may differ.\nRTK is valued once at input rates, separately from inference.\nEstimates exclude electricity/hardware.\n"); text } @@ -400,10 +425,32 @@ mod tests { assert_eq!(money(Some(999_000_000)), "$1.00"); } #[test] - fn catalog_has_official_sources_and_known_context_tier() { + fn catalog_has_same_model_prices_and_primary_sources() { let prices = catalog().unwrap(); - assert_eq!(prices.models.len(), 3); - assert_eq!(prices.models[0].long_context_threshold, Some(272_000)); + assert_eq!(prices.models.len(), 2); + for price in prices.models { + assert!( + price + .source + .starts_with("https://lyceum.technology/products/inference/models/qwen/") + ); + assert_eq!(price.provider.as_deref(), Some("Lyceum")); + assert!(price.matches_model(&price.model)); + assert!(!price.matches_model("gpt-6.1-sol")); + assert!(!price.matches_model("qwen3.6:35b-a3b")); + } + } + + #[test] + fn cloud_equivalent_never_substitutes_another_model() { + let mut report = report(); + report.calculate(); + assert!(report.comparisons.is_empty()); + report.model = "huggingface:RadixArk/Qwen3.8-Flash-Next-NVFP4@revision#artifact".into(); + report.calculate(); + assert_eq!(report.comparisons.len(), 1); + assert_eq!(report.comparisons[0].model, "qwen3.8-flash-next"); + assert_eq!(report.comparisons[0].inference_usd_nanos, Some(54_402_200)); } fn report() -> Report { @@ -451,13 +498,21 @@ mod tests { #[test] fn costs_use_each_requests_context_tier_and_keep_rtk_separate() { let mut report = report(); + let price = &mut report.catalog.models[0]; + price.model = "local-model".into(); + price.aliases.clear(); + price.input_microusd_per_million = 2_000_000; + price.output_microusd_per_million = 10_000_000; + price.long_context_threshold = Some(272_000); + price.long_input_microusd_per_million = Some(4_000_000); + price.long_output_microusd_per_million = Some(15_000_000); report.calculate(); assert_eq!( report.comparisons[0].inference_usd_nanos, Some(1_088_064_000) ); assert_eq!(report.comparisons[0].estimated_rtk_usd_nanos, Some(150_000)); - assert_eq!(report.comparisons[1].inference_usd_nanos, Some(816_063_000)); + assert_eq!(report.comparisons.len(), 1); let usage = &mut report.inference.as_mut().unwrap().usage; usage.input_tokens = 272000; usage.long_context_input_tokens = 0; @@ -484,14 +539,27 @@ mod tests { let root = tempfile::tempdir().unwrap(); let mut report = report(); report.calculate(); + report.comparisons.push(Comparison { + model: "unrelated-cloud-model".into(), + inference_usd_nanos: Some(1_000_000), + estimated_rtk_usd_nanos: Some(10), + }); save(root.path(), &report).unwrap(); + let path = directory(root.path(), "fixture").join(format!("{}.json", report.session_id)); + let evidence = fs::read(&path).unwrap(); + assert!( + load(root.path(), "fixture", None) + .unwrap() + .comparisons + .is_empty() + ); + assert_eq!(fs::read(&path).unwrap(), evidence); assert_eq!( load(root.path(), "fixture", None).unwrap().session_id, report.session_id ); assert!(load(root.path(), "other", Some(&report.session_id)).is_err()); assert!(load(root.path(), "fixture", Some("../escape")).is_err()); - let path = directory(root.path(), "fixture").join(format!("{}.json", report.session_id)); assert_eq!(fs::metadata(&path).unwrap().mode() & 0o777, 0o600); fs::set_permissions(&path, fs::Permissions::from_mode(0o644)).unwrap(); assert!(load(root.path(), "fixture", None).is_err()); diff --git a/src/spark/executor.rs b/src/spark/executor.rs index 5e9a40a..3889e3b 100644 --- a/src/spark/executor.rs +++ b/src/spark/executor.rs @@ -17,10 +17,12 @@ use std::{ use bollard::{ API_DEFAULT_VERSION, Docker, container::LogOutput, + exec::{StartExecOptions, StartExecResults}, models::{ ContainerCreateBody, ContainerUpdateBody, DeviceMapping, DeviceRequest, EndpointSettings, - EventMessage, EventMessageTypeEnum, HealthConfig, HostConfig, ImageInspect, Mount, - MountType, NetworkCreateRequest, NetworkingConfig, RestartPolicy, RestartPolicyNameEnum, + EventMessage, EventMessageTypeEnum, ExecConfig, HealthConfig, HostConfig, ImageInspect, + Mount, MountType, NetworkCreateRequest, NetworkingConfig, RestartPolicy, + RestartPolicyNameEnum, }, query_parameters::{ AttachContainerOptionsBuilder, CreateContainerOptionsBuilder, CreateImageOptionsBuilder, @@ -872,6 +874,7 @@ enum ExecutorActionKind { InspectProtectedHost, InspectDockerVersion, InspectResources, + InspectPanelTelemetry, InspectCandidateStorage(CandidateStorageInput), InspectEmergencyRecords, InspectQualification(QualificationSubmission), @@ -889,6 +892,9 @@ enum ExecutorActionKind { #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] #[serde(tag = "action", rename_all = "snake_case")] enum ExecutorResult { + InspectPanelTelemetry { + telemetry: super::telemetry::PanelTelemetry, + }, Health { health: ExecutorHealth, }, @@ -1003,6 +1009,13 @@ trait ContainerRuntime: Send + Sync + 'static { fn logs(&self, input: LogInput) -> RuntimeFuture; fn scan_managed(&self) -> RuntimeFuture>; fn quarantine(&self, container_id: String) -> RuntimeFuture<()>; + fn panel_gpu( + &self, + _input: StopInstanceInput, + _container_id: String, + ) -> RuntimeFuture> { + Box::pin(async { Ok(None) }) + } } struct BollardContainerRuntime; @@ -1369,6 +1382,79 @@ fn qualification_image_architecture(host_architecture: &str) -> Result<&'static } impl ContainerRuntime for BollardContainerRuntime { + fn panel_gpu( + &self, + input: StopInstanceInput, + container_id: String, + ) -> RuntimeFuture> { + Box::pin(async move { + let docker = Self::docker().await?; + let Some(observed) = inspect_input(&docker, &input).await? else { + return Ok(None); + }; + if observed.container_id != container_id || !observed.running { + return Ok(None); + } + // A finite read-only command inherits the engine's existing device, + // user, cgroup and confinement policy. No caller can choose argv. + let exec = docker + .create_exec( + &container_id, + ExecConfig { + attach_stdin: Some(false), + attach_stdout: Some(true), + attach_stderr: Some(false), + tty: Some(false), + privileged: Some(false), + cmd: Some( + super::telemetry::gpu_command() + .into_iter() + .map(str::to_owned) + .collect(), + ), + ..Default::default() + }, + ) + .await + .map_err(|_| ())?; + let StartExecResults::Attached { mut output, .. } = docker + .start_exec( + &exec.id, + Some(StartExecOptions { + detach: false, + tty: false, + output_capacity: Some(8192), + }), + ) + .await + .map_err(|_| ())? + else { + return Ok(None); + }; + let mut bytes = Vec::new(); + while let Some(chunk) = output.next().await { + let chunk = chunk.map_err(|_| ())?; + if let LogOutput::StdOut { message } = chunk { + if bytes.len().saturating_add(message.len()) > 8192 { + return Ok(None); + } + bytes.extend_from_slice(&message); + } + } + if docker + .inspect_exec(&exec.id) + .await + .map_err(|_| ())? + .exit_code + != Some(0) + { + return Ok(None); + } + Ok(std::str::from_utf8(&bytes) + .ok() + .and_then(super::telemetry::gpu)) + }) + } fn qualify( &self, spec: QualificationContainerSpec, @@ -2668,6 +2754,9 @@ struct ExecutorHandler { kernel_release: String, machine_id_path: PathBuf, engine_catalog: Arc, + // Read-only telemetry targets adopted by exact catalogued reconciliation. + // This cache does not participate in admission or emergency decisions. + panel_targets: RwLock>, resources: Option>, qualification: Option>, } @@ -2721,6 +2810,7 @@ impl ExecutorHandler { .into_owned(), machine_id_path: "/etc/machine-id".into(), engine_catalog: Arc::new(engine_catalog), + panel_targets: RwLock::new(Vec::new()), resources: Some(resources), qualification: Some(Arc::new(QualificationExecutorConfig { authority, @@ -2771,6 +2861,62 @@ impl ExecutorHandler { cancellation: CancellationToken, ) -> Result { match action.action { + ExecutorActionKind::InspectPanelTelemetry => { + let (guard_heartbeat, event_heartbeat) = self.heartbeats.healthy(); + let cpu = tokio::fs::read_to_string("/proc/stat") + .await + .ok() + .and_then(|s| super::telemetry::cpu_ticks(&s)); + let target = self + .resources + .as_ref() + .and_then(|monitor| { + let identities = monitor.identities.read().ok()?; + identities.values().next().map(|identity| { + ( + StopInstanceInput { + instance_id: identity.instance_id.clone(), + generation: identity.generation, + grace_seconds: 0, + }, + identity.container_id.clone(), + ) + }) + }) + .or_else(|| self.panel_targets.read().ok()?.first().cloned()); + let gpu = if let Some((input, container_id)) = target { + tokio::time::timeout( + Duration::from_millis(2500), + self.runtime.panel_gpu(input, container_id), + ) + .await + .ok() + .and_then(Result::ok) + .flatten() + } else { + None + }; + Ok(ExecutorResult::InspectPanelTelemetry { + telemetry: super::telemetry::PanelTelemetry { + health: ExecutorHealth { + schema: "sparkplane.executor.health/v1".into(), + version: env!("CARGO_PKG_VERSION").into(), + authorized_agent_uid: self.agent_uid, + guard_heartbeat, + event_heartbeat, + event_epoch: self.heartbeats.event_epoch(), + }, + resources: self + .resources + .as_ref() + .and_then(|r| r.snapshot()) + .map(|(s, _)| s), + cpu_total_ticks: cpu.map(|c| c.0), + cpu_idle_ticks: cpu.map(|c| c.1), + gpu, + }, + }) + } ExecutorActionKind::Health => { let (guard_heartbeat, event_heartbeat) = self.heartbeats.healthy(); Ok(ExecutorResult::Health { @@ -2935,6 +3081,12 @@ impl ExecutorHandler { if let Some(resources) = &self.resources { resources.forget_engine(&input.instance_id, input.generation); } + if let Ok(mut targets) = self.panel_targets.write() { + targets.retain(|(target, _)| { + target.instance_id != input.instance_id + || target.generation != input.generation + }); + } Ok(ExecutorResult::StopInstance) } ExecutorActionKind::InspectInstance(input) => self @@ -3077,6 +3229,22 @@ impl ExecutorHandler { (!matched_keys.contains(&identity)).then_some(expected) }) .collect(); + if let Ok(mut targets) = self.panel_targets.write() { + *targets = matched + .iter() + .filter(|engine| engine.running) + .map(|engine| { + ( + StopInstanceInput { + instance_id: engine.instance_id.clone(), + generation: engine.generation, + grace_seconds: 0, + }, + engine.container_id.clone(), + ) + }) + .collect(); + } Ok(ReconcileScan { matched, missing, @@ -3472,6 +3640,20 @@ impl ExecutorClient { } } + pub async fn panel_telemetry( + &self, + ) -> Result { + match self + .call(ExecutorAction { + action: ExecutorActionKind::InspectPanelTelemetry, + }) + .await? + { + ExecutorResult::InspectPanelTelemetry { telemetry } => Ok(telemetry), + _ => Err(protocol_error()), + } + } + pub async fn candidate_storage( &self, input: CandidateStorageInput, @@ -4076,6 +4258,56 @@ async fn actuate_emergency_at( mod tests { use super::*; + #[tokio::test] + async fn panel_telemetry_round_trips_only_for_the_authorized_ipc_peer() { + let uid = rustix::process::geteuid().as_raw(); + for authorized_uid in [uid, uid + 1] { + let root = tempfile::tempdir().unwrap(); + let socket = root.path().join("executor.sock"); + let listener = UnixListener::bind(&socket).unwrap(); + let heartbeats = Arc::new(Heartbeats::default()); + heartbeats.mark_guard(); + heartbeats.mark_events(); + let handler = ExecutorHandler { + agent_uid: authorized_uid, + cancellation: Arc::new(CancelRegistry::new()), + docker: Arc::new(BollardDockerInspector), + runtime: Arc::new(FakeRuntime::new()), + heartbeats, + hostname_path: "/etc/hostname".into(), + kernel_release: "fixture".into(), + machine_id_path: "/etc/machine-id".into(), + engine_catalog: engine_catalog(), + panel_targets: RwLock::new(Vec::new()), + resources: None, + qualification: None, + }; + let server = tokio::spawn( + Server::with_authorizer(handler, SparkUidAuthorizer::new(authorized_uid)) + .with_max_request_frame_length(MAX_REQUEST_FRAME) + .serve(listener), + ); + let result = ExecutorClient::new(socket).panel_telemetry().await; + if uid == authorized_uid { + let telemetry = result.unwrap(); + assert!(telemetry.health.guard_heartbeat); + assert!(telemetry.cpu_total_ticks.is_some()); + assert!(telemetry.resources.is_none()); + assert!(telemetry.gpu.is_none()); + } else { + assert!(result.is_err()); + } + server.abort(); + let _ = server.await; + } + assert!( + serde_json::from_value::( + serde_json::json!({"action":"inspect_panel_telemetry","argv":["sh"]}) + ) + .is_err() + ); + } + #[test] fn compute_devices_survive_restart_policy_updates() { let paths: Vec<_> = nvidia_compute_devices() @@ -4628,6 +4860,22 @@ mod tests { } impl ContainerRuntime for FakeRuntime { + fn panel_gpu( + &self, + input: StopInstanceInput, + container_id: String, + ) -> RuntimeFuture> { + self.record("panel-gpu"); + assert_eq!(input.instance_id, self.observed.instance_id); + assert_eq!(input.generation, self.observed.generation); + assert_eq!(container_id, self.observed.container_id); + Box::pin(async { + Ok(super::super::telemetry::gpu( + "NVIDIA GB10, 0, 45, 10.48, [N/A], [N/A]", + )) + }) + } + fn qualify( &self, _: QualificationContainerSpec, @@ -5142,6 +5390,7 @@ mod tests { kernel_release: "6.17-test".into(), machine_id_path: root.path().join("machine-id"), engine_catalog: engine_catalog(), + panel_targets: RwLock::new(Vec::new()), resources: None, qualification: None, }; @@ -5233,6 +5482,7 @@ mod tests { kernel_release: "6.17-test".into(), machine_id_path: root.path().join("machine-id"), engine_catalog: engine_catalog(), + panel_targets: RwLock::new(Vec::new()), resources: None, qualification: None, }); @@ -5271,6 +5521,7 @@ mod tests { kernel_release: "6.17-test".into(), machine_id_path: "/etc/machine-id".into(), engine_catalog: engine_catalog(), + panel_targets: RwLock::new(Vec::new()), resources: None, qualification: None, }; @@ -5307,6 +5558,7 @@ mod tests { kernel_release: "6.17-test".into(), machine_id_path: "/etc/machine-id".into(), engine_catalog: engine_catalog(), + panel_targets: RwLock::new(Vec::new()), resources: None, qualification: None, }; @@ -5821,6 +6073,7 @@ mod tests { kernel_release: "6.17-test".into(), machine_id_path: "/etc/machine-id".into(), engine_catalog: engine_catalog(), + panel_targets: RwLock::new(Vec::new()), resources: None, qualification: None, }; @@ -5889,6 +6142,7 @@ mod tests { kernel_release: "6.17-test".into(), machine_id_path: "/etc/machine-id".into(), engine_catalog: engine_catalog(), + panel_targets: RwLock::new(Vec::new()), resources: None, qualification: None, }; @@ -5964,6 +6218,7 @@ mod tests { kernel_release: "6.17-test".into(), machine_id_path: "/etc/machine-id".into(), engine_catalog: engine_catalog(), + panel_targets: RwLock::new(Vec::new()), resources: None, qualification: None, }; @@ -5987,6 +6242,19 @@ mod tests { ), (0, 1, 1) ); + let ExecutorResult::InspectPanelTelemetry { telemetry } = handler + .execute( + ExecutorAction { + action: ExecutorActionKind::InspectPanelTelemetry, + }, + CancellationToken::new(), + ) + .await + .unwrap() + else { + panic!("wrong result"); + }; + assert!(telemetry.gpu.is_none()); managed.lock().unwrap()[0].name = format!( "sparkplane-{}-g{}", expected.instance_id, expected.generation @@ -5994,7 +6262,7 @@ mod tests { let result = handler .execute( ExecutorAction { - action: ExecutorActionKind::ReconcileScan(vec![expected]), + action: ExecutorActionKind::ReconcileScan(vec![expected.clone()]), }, CancellationToken::new(), ) @@ -6004,6 +6272,44 @@ mod tests { panic!("wrong result"); }; assert_eq!((scan.matched.len(), scan.missing.len()), (1, 0)); + let ExecutorResult::InspectPanelTelemetry { telemetry } = handler + .execute( + ExecutorAction { + action: ExecutorActionKind::InspectPanelTelemetry, + }, + CancellationToken::new(), + ) + .await + .unwrap() + else { + panic!("wrong result"); + }; + assert_eq!(telemetry.gpu.unwrap().name, "NVIDIA GB10"); + + // A later failed identity check must evict the old telemetry target. + managed.lock().unwrap()[0].engine_fingerprint = Some("untrusted".into()); + handler + .execute( + ExecutorAction { + action: ExecutorActionKind::ReconcileScan(vec![expected]), + }, + CancellationToken::new(), + ) + .await + .unwrap(); + let ExecutorResult::InspectPanelTelemetry { telemetry } = handler + .execute( + ExecutorAction { + action: ExecutorActionKind::InspectPanelTelemetry, + }, + CancellationToken::new(), + ) + .await + .unwrap() + else { + panic!("wrong result"); + }; + assert!(telemetry.gpu.is_none()); } #[tokio::test] @@ -6028,6 +6334,7 @@ mod tests { kernel_release: "6.17-test".into(), machine_id_path: "/etc/machine-id".into(), engine_catalog: engine_catalog(), + panel_targets: RwLock::new(Vec::new()), resources: Some(monitor.clone()), qualification: None, }; diff --git a/src/spark/gateway.rs b/src/spark/gateway.rs index 1d9baed..2ccc0fe 100644 --- a/src/spark/gateway.rs +++ b/src/spark/gateway.rs @@ -890,12 +890,18 @@ impl ResponsesEncoder { } pub fn fail(&mut self) { + self.fail_with_message("upstream stream failed"); + } + + pub fn fail_with_message(&mut self, message: &'static str) { let sequence = self.next_sequence(); - self.pending.push_back(OpenAiStreamEvent { name: "response.failed", + self.pending.push_back(OpenAiStreamEvent { + name: "response.failed", data: serde_json::json!({"type":"response.failed","response":{ "id":self.id,"object":"response","status":"failed","model":self.model, - "output":self.output_items(),"error":{"code":"server_error","message":"upstream stream failed"}}, - "sequence_number":sequence}) }); + "output":self.output_items(),"error":{"code":"server_error","message":message}}, + "sequence_number":sequence}), + }); } pub fn final_document(&self) -> Value { @@ -2267,17 +2273,26 @@ pub fn rewrite_responses_request_with_profile( } let max_tokens = response_max_tokens(object.get("max_output_tokens"))?; let tool_choice = response_tool_choice(object.get("tool_choice"))?; - let reasoning_effort = object - .get("reasoning") - .and_then(|reasoning| reasoning.get("effort")) - .and_then(Value::as_str) - .map(|effort| { - profile - .sampling - .reasoning_effort_map - .get(effort) - .map_or_else(|| effort.to_owned(), Clone::clone) - }); + let reasoning_effort = if !profile.native_responses && codex_context_compaction(object, &tools) + { + // A summary request must return visible text for Codex's local compactor. + // Thinking-only summaries otherwise retry the same long history. Use + // the existing per-request non-thinking path; qualified instance settings + // and the reasoning effort of ordinary agent steps stay intact. + Some("none".to_owned()) + } else { + object + .get("reasoning") + .and_then(|reasoning| reasoning.get("effort")) + .and_then(Value::as_str) + .map(|effort| { + profile + .sampling + .reasoning_effort_map + .get(effort) + .map_or_else(|| effort.to_owned(), Clone::clone) + }) + }; let disable_thinking = reasoning_effort.as_deref() == Some("none"); let stream = object .get("stream") @@ -2332,6 +2347,22 @@ pub fn rewrite_responses_request_with_profile( }) } +fn codex_context_compaction(object: &serde_json::Map, tools: &[Value]) -> bool { + if !tools.is_empty() { + return false; + } + let Some(metadata) = object + .get("client_metadata") + .and_then(|metadata| metadata.get("x-codex-turn-metadata")) + .and_then(Value::as_str) + .filter(|metadata| metadata.len() <= 16 * 1024) + else { + return false; + }; + serde_json::from_str::(metadata) + .is_ok_and(|metadata| metadata["request_kind"] == "compaction") +} + pub fn rewrite_native_responses_request_with_profile( bytes: &[u8], public_model: &str, @@ -3191,6 +3222,60 @@ mod tests { assert_eq!(body["chat_template_kwargs"]["enable_thinking"], false); } + #[test] + fn codex_compaction_requests_produce_visible_summaries_without_changing_coding_effort() { + let mut request = serde_json::json!({ + "input":"checkpoint", "tools":[], "reasoning":{"effort":"xhigh"}, + "client_metadata":{"x-codex-turn-metadata":"{\"request_kind\":\"compaction\"}"} + }); + let rewrite = |request: &Value| { + let rewritten = rewrite_responses_request_with_profile( + &serde_json::to_vec(request).unwrap(), + "served-model", + &configured_sampling_profile(), + ) + .unwrap(); + serde_json::from_slice::(&rewritten.body).unwrap() + }; + let summary = rewrite(&request); + assert_eq!(summary["reasoning_effort"], "none"); + assert_eq!(summary["chat_template_kwargs"]["enable_thinking"], false); + assert_eq!(summary["temperature"], 0.6); + assert!(summary.get("thinking_token_budget").is_none()); + assert!(summary.get("max_tokens").is_none()); + + for marker in ["{\"request_kind\":\"turn\"}", "invalid json", "{}"] { + request["client_metadata"]["x-codex-turn-metadata"] = marker.into(); + let coding = rewrite(&request); + assert_eq!(coding["reasoning_effort"], "xhigh"); + assert!( + coding["chat_template_kwargs"] + .get("enable_thinking") + .is_none() + ); + } + request["client_metadata"]["x-codex-turn-metadata"] = + "{\"request_kind\":\"compaction\"}".into(); + let mut native_profile = configured_sampling_profile(); + native_profile.native_responses = true; + let native = rewrite_native_responses_request_with_profile( + &serde_json::to_vec(&request).unwrap(), + "served-model", + &native_profile, + ) + .unwrap(); + let native: Value = serde_json::from_slice(&native.body).unwrap(); + assert_eq!(native["reasoning"]["effort"], "xhigh"); + assert!( + native["chat_template_kwargs"] + .get("enable_thinking") + .is_none() + ); + request["tools"] = + serde_json::json!([{"type":"function","name":"run","parameters":{"type":"object"}}]); + assert_eq!(rewrite(&request)["reasoning_effort"], "xhigh"); + } + #[test] fn responses_without_tools_omit_tool_controls() { let request = diff --git a/src/spark/launch.rs b/src/spark/launch.rs index 0f79081..9c860d8 100644 --- a/src/spark/launch.rs +++ b/src/spark/launch.rs @@ -373,6 +373,18 @@ pub fn run(host: &str, config_dir: &Path, args: LaunchArgs) -> Result<(), Client comparisons: Vec::new(), }; report.calculate(); + if report + .inference + .as_ref() + .is_some_and(|session| session.finished_at.is_some()) + && client + .upload_compression(&report.session_id, &report.compression) + .is_err() + { + eprintln!( + "Panel compression reporting unavailable; aggregate retained in local economics report." + ); + } if super::economics::save(config_dir, &report).is_err() { eprintln!("Could not retain the private economics report."); } @@ -723,7 +735,9 @@ fn configure_integration( let catalog_text = serde_json::to_vec_pretty(&catalog_value) .map_err(|_| failure(EXIT_INTERNAL, "could not encode Codex model catalog"))?; crate::generated_files::publish(&home, profile_text.as_bytes(), &catalog_text) - .map_err(|error| usage(format!("generated client files: {error:#}"))) + .map_err(|error| usage(format!("generated client files: {error:#}")))?; + crate::generated_files::publish_provider(&home, profile_text.as_bytes()) + .map_err(|error| usage(format!("Codex provider registration: {error:#}"))) } fn codex_catalog(model: &ModelDocument, instance: &InstanceDocument) -> Value { diff --git a/src/spark/mod.rs b/src/spark/mod.rs index 3ee65e9..adf3084 100644 --- a/src/spark/mod.rs +++ b/src/spark/mod.rs @@ -15,10 +15,13 @@ pub mod qualification; pub mod reconcile; #[cfg(feature = "appliance")] pub mod sessions; +pub mod webauth; pub mod wire; #[cfg(feature = "appliance")] pub mod agent; +#[cfg(feature = "appliance")] +pub mod analytics; #[cfg(all(feature = "appliance", test))] pub mod bench; #[cfg(feature = "appliance")] @@ -35,6 +38,8 @@ pub mod resources; #[cfg(feature = "appliance")] pub mod state; #[cfg(feature = "appliance")] +pub mod telemetry; +#[cfg(feature = "appliance")] pub mod upstream; pub const EXIT_INTERNAL: i32 = 1; diff --git a/src/spark/sessions.rs b/src/spark/sessions.rs index ef98676..b6dbe60 100644 --- a/src/spark/sessions.rs +++ b/src/spark/sessions.rs @@ -77,6 +77,7 @@ pub(crate) enum Command { token: String, id: String, instance: String, + protocol: String, reply: oneshot::Sender>, }, Record { @@ -84,6 +85,8 @@ pub(crate) enum Command { usage: Option<(u64, u64)>, outcome: String, incomplete: bool, + duration_ms: u64, + ttft_ms: Option, reply: oneshot::Sender>, }, } @@ -121,12 +124,19 @@ impl DbActor { .await .map_err(|_| StateError::Unavailable("session database unavailable".into()))? } - async fn begin_usage(&self, token: &str, id: &str, instance: &str) -> Result { + pub(crate) async fn begin_usage( + &self, + token: &str, + id: &str, + instance: &str, + protocol: &str, + ) -> Result { let (reply, receive) = oneshot::channel(); self.session_command(Command::Begin { token: token.into(), id: id.into(), instance: instance.into(), + protocol: protocol.into(), reply, })?; receive @@ -139,6 +149,8 @@ impl DbActor { usage: Option<(u64, u64)>, outcome: &str, incomplete: bool, + duration_ms: u64, + ttft_ms: Option, ) -> Result<(), StateError> { let (reply, receive) = oneshot::channel(); self.session_command(Command::Record { @@ -146,6 +158,8 @@ impl DbActor { usage, outcome: outcome.into(), incomplete, + duration_ms, + ttft_ms, reply, })?; receive @@ -184,6 +198,7 @@ pub(crate) fn dispatch(db: &mut Connection, pepper: &SecretString, command: Comm token, id, instance, + protocol, reply, } => { let result = (|| { @@ -195,15 +210,19 @@ pub(crate) fn dispatch(db: &mut Connection, pepper: &SecretString, command: Comm ) .optional() .map_err(sql)?; - let Some((expected, finished)) = expected else { - return Ok(false); - }; - if expected != instance || finished.is_some() { + if expected + .as_ref() + .is_some_and(|(expected, finished)| expected != &instance || finished.is_some()) + { return Err(StateError::Invalid( "launch session is not active for this instance".into(), )); } - db.execute("INSERT INTO launch_requests(id,session_id,instance,started_at) SELECT ?1,id,?2,?3 FROM launch_sessions WHERE token_id=?4 AND finished_at IS NULL", params![id,instance,super::state::now(),token]).map(|n| n == 1).map_err(sql) + let tx = db.transaction().map_err(sql)?; + tx.execute("INSERT INTO launch_requests(id,session_id,instance,started_at) SELECT ?1,id,?2,?3 FROM launch_sessions WHERE token_id=?4 AND finished_at IS NULL", params![id,instance,super::state::now(),token]).map_err(sql)?; + super::analytics::begin(&tx, &id, &token, &instance, &protocol)?; + tx.commit().map_err(sql)?; + Ok(true) })(); let _ = reply.send(result); } @@ -212,10 +231,15 @@ pub(crate) fn dispatch(db: &mut Connection, pepper: &SecretString, command: Comm usage, outcome, incomplete, + duration_ms, + ttft_ms, reply, } => { let result = usage.map(|(a,b)| (i64::try_from(a),i64::try_from(b))).map(|(a,b)| Ok((a.map_err(|_| StateError::Invalid("usage overflow".into()))?,b.map_err(|_| StateError::Invalid("usage overflow".into()))?))).transpose().and_then(|counts| { - db.execute("UPDATE launch_requests SET input_tokens=?2,output_tokens=?3,outcome=?4,finished_at=?5,accounting_error=?6 WHERE id=?1 AND finished_at IS NULL",params![id,counts.map(|c|c.0),counts.map(|c|c.1),outcome,super::state::now(),incomplete]).map(|_|()).map_err(sql) + let tx=db.transaction().map_err(sql)?; + tx.execute("UPDATE launch_requests SET input_tokens=?2,output_tokens=?3,outcome=?4,finished_at=?5,accounting_error=?6 WHERE id=?1 AND finished_at IS NULL",params![id,counts.map(|c|c.0),counts.map(|c|c.1),outcome,super::state::now(),incomplete]).map_err(sql)?; + super::analytics::record(&tx,&id,counts,&outcome,incomplete,Some(duration_ms),ttft_ms)?; + tx.commit().map_err(sql) }); let _ = reply.send(result); } @@ -326,23 +350,34 @@ struct MeterValues { usage: Option<(u64, u64)>, outcome: &'static str, incomplete: bool, + ttft_ms: Option, } struct MeterInner { db: DbActor, id: String, values: Mutex, + started: std::time::Instant, } impl UsageMeter { + #[cfg(test)] pub async fn begin( db: Option<&DbActor>, token: &str, instance: &str, + ) -> Result { + Self::begin_protocol(db, token, instance, "inference").await + } + pub async fn begin_protocol( + db: Option<&DbActor>, + token: &str, + instance: &str, + protocol: &str, ) -> Result { let Some(db) = db else { return Ok(Self::default()); }; let id = ulid::Ulid::new().to_string(); - match db.begin_usage(token, &id, instance).await { + match db.begin_usage(token, &id, instance, protocol).await { Ok(true) => Ok(Self(Some(Arc::new(MeterInner { db: db.clone(), id, @@ -350,7 +385,9 @@ impl UsageMeter { usage: None, outcome: "interrupted", incomplete: false, + ttft_ms: None, }), + started: std::time::Instant::now(), })))), Ok(false) => Ok(Self::default()), Err(error) => Err(error), @@ -361,6 +398,17 @@ impl UsageMeter { && let Ok(mut values) = inner.values.lock() { match event { + super::upstream::GenerationEvent::TextDelta { .. } + | super::upstream::GenerationEvent::ReasoningDelta { .. } + | super::upstream::GenerationEvent::ToolCallDelta { .. } => { + values.ttft_ms.get_or_insert( + inner + .started + .elapsed() + .as_millis() + .min(u128::from(u64::MAX)) as u64, + ); + } super::upstream::GenerationEvent::Usage { prompt_tokens, completion_tokens, @@ -386,7 +434,17 @@ impl UsageMeter { usage .get("completion_tokens") .or_else(|| usage.get("output_tokens")) - .and_then(|v| v.as_u64()), + .and_then(|v| v.as_u64()) + .or_else(|| { + usage + .get("prompt_tokens") + .and_then(|v| v.as_u64()) + .is_some_and(|prompt| { + usage.get("total_tokens").and_then(|v| v.as_u64()) + == Some(prompt) + }) + .then_some(0) + }), ); } } @@ -405,6 +463,37 @@ impl UsageMeter { .collect::>() .join(&b'\n'); if let Ok(document) = serde_json::from_slice::(&data) { + let kind = document.get("type").and_then(|v| v.as_str()); + let output = matches!( + kind, + Some( + "response.output_text.delta" + | "response.reasoning_text.delta" + | "response.reasoning_summary_text.delta" + | "response.function_call_arguments.delta" + | "response.custom_tool_call_input.delta" + ) + ) && document + .get("delta") + .and_then(|v| v.as_str()) + .is_some_and(|v| !v.is_empty()); + let tool = kind == Some("response.output_item.added") + && matches!( + document["item"]["type"].as_str(), + Some("function_call" | "custom_tool_call") + ); + if (output || tool) + && let Some(inner) = &self.0 + && let Ok(mut values) = inner.values.lock() + { + values.ttft_ms.get_or_insert( + inner + .started + .elapsed() + .as_millis() + .min(u128::from(u64::MAX)) as u64, + ); + } let response = document.get("response").unwrap_or(&document); let terminal = matches!( document.get("type").and_then(|v| v.as_str()), @@ -424,13 +513,22 @@ impl Drop for MeterInner { usage: None, outcome: "interrupted", incomplete: true, + ttft_ms: None, }); values.incomplete |= values.outcome != "succeeded"; let db = self.db.clone(); let id = self.id.clone(); + let duration_ms = self.started.elapsed().as_millis().min(u128::from(u64::MAX)) as u64; tokio::spawn(async move { if db - .record_usage(&id, values.usage, values.outcome, values.incomplete) + .record_usage( + &id, + values.usage, + values.outcome, + values.incomplete, + duration_ms, + values.ttft_ms, + ) .await .is_err() { @@ -457,4 +555,12 @@ impl super::upstream::UsageObserver for UsageMeter { values.incomplete = true; } } + fn response_failed(&self) { + if let Some(inner) = &self.0 + && let Ok(mut values) = inner.values.lock() + { + // Failed delivery still burns the engine's reported tokens. + values.outcome = "failed"; + } + } } diff --git a/src/spark/state.rs b/src/spark/state.rs index 9aefe4d..766b184 100644 --- a/src/spark/state.rs +++ b/src/spark/state.rs @@ -123,7 +123,7 @@ impl std::fmt::Display for StateError { impl std::error::Error for StateError {} -#[derive(Debug, Clone, PartialEq, Eq)] +#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize)] pub struct DatabaseHealth { pub journal_mode: String, pub synchronous: String, @@ -298,6 +298,7 @@ enum Command { }, Snapshot(oneshot::Sender>), Sessions(super::sessions::Command), + Panel(super::analytics::Command), Shutdown(std_mpsc::SyncSender<()>), } @@ -309,6 +310,14 @@ pub struct DbActor { } impl DbActor { + pub(crate) fn panel_command( + &self, + command: super::analytics::Command, + ) -> Result<(), StateError> { + self.sender + .try_send(Command::Panel(command)) + .map_err(|_| StateError::Overloaded) + } pub(crate) fn session_command( &self, command: super::sessions::Command, @@ -700,7 +709,11 @@ fn open_connection( let version: u32 = connection .pragma_query_value(None, "user_version", |row| row.get(0)) .map_err(state_sql)?; - if version > 0 && (version < 4 || super::sessions::migration_needed(&connection)?) { + if version > 0 + && (version < 4 + || super::sessions::migration_needed(&connection)? + || super::analytics::migration_needed(&connection)?) + { verified_backup(&connection, backup_dir, max_backups)?; } let migrations = Migrations::new(vec![ @@ -718,10 +731,56 @@ fn open_connection( // Additive launch tables have a separate version ledger. Older releases // still read the qualified engine state under the unchanged main schema. super::sessions::migrate(&mut connection)?; + super::analytics::migrate(&mut connection)?; + super::analytics::interrupt_pending(&mut connection)?; + interrupt_panel_recoveries(&mut connection)?; verified_backup(&connection, backup_dir, max_backups)?; Ok(connection) } +fn interrupt_panel_recoveries(connection: &mut Connection) -> Result<(), StateError> { + loop { + let ids = connection + .prepare("SELECT id FROM operations WHERE kind='instance.recover' AND state IN ('accepted','running') LIMIT 256") + .map_err(state_sql)? + .query_map([], |row| row.get::<_, String>(0)) + .map_err(state_sql)? + .collect::, _>>() + .map_err(state_sql)?; + if ids.is_empty() { + return Ok(()); + } + for id in ids { + let progress = OperationProgress { + stage: "interrupted".into(), + current: None, + total: None, + unit: None, + message: "Recovery sequence interrupted by an agent restart".into(), + }; + if read_operation(connection, &id)?.state == OperationState::Accepted { + transition( + connection, + &id, + OperationState::Running, + progress.clone(), + None, + None, + )?; + } + transition(connection, &id, OperationState::Failed, progress, None, Some(ProblemDocument { + schema: PROBLEM_SCHEMA.into(), + r#type: "about:blank".into(), + code: "spark.instance.recovery-interrupted".into(), + status: 409, + detail: "The agent restarted during managed recovery. Child lifecycle operations reconcile independently.".into(), + remediation: vec!["Inspect the instance and child operations before starting a new recovery.".into()], + operation_id: Some(id.clone()), + }))?; + } + } +} + fn verified_backup( connection: &Connection, directory: &Path, @@ -790,6 +849,7 @@ fn actor_loop( ) { while let Some(command) = receiver.blocking_recv() { match command { + Command::Panel(command) => super::analytics::dispatch(&mut connection, command), Command::Sessions(command) => { super::sessions::dispatch(&mut connection, &pepper, command) } @@ -1220,8 +1280,18 @@ fn create_token( } connection.execute( "INSERT INTO token_metadata(id,name,verifier,scopes_json,allowed_cidrs_json,expires_at,max_concurrent_inference,created_at) VALUES(?1,?2,?3,?4,?5,?6,?7,?8)", - params![token_id, request.name, verifier.as_slice(), json(&request.scopes)?, json(&request.allowed_cidrs)?, request.expires_at, request.max_concurrent_inference, created_at], + params![token_id, request.name, verifier.as_slice(), json(&request.scopes.iter().filter(|scope| **scope!=super::wire::TokenScope::AnalyticsRead).collect::>())?, json(&request.allowed_cidrs)?, request.expires_at, request.max_concurrent_inference, created_at], ).map_err(state_sql)?; + // New permissions live in an additive table so preceding releases can still + // decode their token metadata; downgrading never grants analytics access. + if request + .scopes + .contains(&super::wire::TokenScope::AnalyticsRead) + { + connection + .execute("INSERT INTO panel_token_scopes VALUES(?1,1)", [&token_id]) + .map_err(state_sql)?; + } let result = serde_json::json!({"token_id":token_id}); let running = transition( connection, @@ -2059,10 +2129,29 @@ fn read_token(connection: &Connection, id: &str) -> Result(0)?,row.get::<_, String>(1)?,row.get::<_, String>(2)?,row.get::<_, String>(3)?,row.get::<_, Option>(4)?,row.get::<_, u32>(5)?,row.get::<_, String>(6)?,row.get::<_, Option>(7)?,row.get::<_, Option>(8)?)), ).optional().map_err(state_sql)?.ok_or(StateError::NotFound).and_then(|(id,name,scopes,cidrs,expires_at,max_concurrent_inference,created_at,last_used_at,revoked_at)| Ok(TokenDocument { - schema: TOKEN_SCHEMA.into(), id, name, scopes: from_json(&scopes)?, allowed_cidrs: from_json(&cidrs)?, expires_at, max_concurrent_inference, created_at, last_used_at, revoked_at, + schema: TOKEN_SCHEMA.into(), id:id.clone(), name, scopes: token_scopes(connection,&id,&scopes)?, allowed_cidrs: from_json(&cidrs)?, expires_at, max_concurrent_inference, created_at, last_used_at, revoked_at, })) } +fn token_scopes( + connection: &Connection, + id: &str, + legacy: &str, +) -> Result, StateError> { + let mut scopes: Vec = from_json(legacy)?; + if connection + .query_row( + "SELECT EXISTS(SELECT 1 FROM panel_token_scopes WHERE token_id=?1)", + [id], + |row| row.get::<_, bool>(0), + ) + .map_err(state_sql)? + { + scopes.push(super::wire::TokenScope::AnalyticsRead); + } + Ok(scopes) +} + fn load_snapshot(connection: &Connection) -> Result { let mut statement = connection.prepare( "SELECT id,name,verifier,scopes_json,allowed_cidrs_json,expires_at,max_concurrent_inference,created_at,last_used_at,revoked_at FROM token_metadata WHERE revoked_at IS NULL AND (expires_at IS NULL OR julianday(expires_at)>julianday('now')) LIMIT 1024" @@ -2104,7 +2193,7 @@ fn load_snapshot(connection: &Connection) -> Result { schema: TOKEN_SCHEMA.into(), id: id.clone(), name, - scopes: from_json(&scopes)?, + scopes: token_scopes(connection, &id, &scopes)?, allowed_cidrs: from_json(&cidrs)?, expires_at, max_concurrent_inference, @@ -2166,9 +2255,9 @@ fn validate_token_request(request: &TokenCreateRequest) -> Result<(), StateError "token name must contain 1..80 bytes".into(), )); } - if request.scopes.is_empty() || request.scopes.len() > 11 { + if request.scopes.is_empty() || request.scopes.len() > 12 { return Err(StateError::Invalid( - "token must contain 1..11 scopes".into(), + "token must contain 1..12 scopes".into(), )); } if request.allowed_cidrs.len() > 16 diff --git a/src/spark/telemetry.rs b/src/spark/telemetry.rs new file mode 100644 index 0000000..f588d84 --- /dev/null +++ b/src/spark/telemetry.rs @@ -0,0 +1,84 @@ +//! Fixed read-only host telemetry. Never participates in resource admission. +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] +pub struct PanelTelemetry { + pub health: super::wire::ExecutorHealth, + pub resources: Option, + pub cpu_total_ticks: Option, + pub cpu_idle_ticks: Option, + pub gpu: Option, +} +#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] +pub struct GpuTelemetry { + pub name: String, + pub utilization_percent: Option, + pub temperature_celsius: Option, + pub power_watts: Option, + pub dedicated_memory_total_mib: Option, + pub dedicated_memory_used_mib: Option, +} +pub(crate) fn cpu_ticks(text: &str) -> Option<(u64, u64)> { + let line = text.lines().find(|l| l.starts_with("cpu "))?; + let values = line + .split_whitespace() + .skip(1) + .take(8) + .map(str::parse::) + .collect::, _>>() + .ok()?; + if values.len() < 4 { + return None; + } + Some(( + values.iter().try_fold(0u64, |sum, v| sum.checked_add(*v))?, + values[3].checked_add(values.get(4).copied().unwrap_or(0))?, + )) +} +pub(crate) fn gpu(text: &str) -> Option { + let parts = text + .lines() + .next()? + .split(',') + .map(str::trim) + .collect::>(); + if parts.len() != 6 || parts[0].len() > 128 { + return None; + } + let number = |index: usize| { + parts[index] + .parse::() + .ok() + .filter(|v| v.is_finite() && *v >= 0.0) + }; + Some(GpuTelemetry { + name: parts[0].into(), + utilization_percent: number(1).filter(|v| *v <= 100.0), + temperature_celsius: number(2), + power_watts: number(3), + dedicated_memory_total_mib: number(4), + dedicated_memory_used_mib: number(5), + }) +} +pub(crate) fn gpu_command() -> [&'static str; 6] { + [ + "/usr/bin/timeout", + "--signal=KILL", + "2s", + "/usr/bin/nvidia-smi", + "--query-gpu=name,utilization.gpu,temperature.gpu,power.draw,memory.total,memory.used", + "--format=csv,noheader,nounits", + ] +} + +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn gb10_reports_unavailable_dedicated_memory() { + let sample = gpu("NVIDIA GB10, 93, 70, 39.35, [N/A], [N/A]\n").unwrap(); + assert_eq!(sample.dedicated_memory_total_mib, None); + assert_eq!(sample.utilization_percent, Some(93.0)); + assert_eq!(cpu_ticks("cpu 1 2 3 4 5 6 7 8 99 99\n"), Some((36, 9))); + } +} diff --git a/src/spark/upstream.rs b/src/spark/upstream.rs index 1bbeb5a..dc7ffc3 100644 --- a/src/spark/upstream.rs +++ b/src/spark/upstream.rs @@ -271,6 +271,7 @@ pub trait UsageObserver: std::fmt::Debug + Send + Sync { fn json(&self, bytes: &[u8], success: bool); fn raw(&self, bytes: &[u8]); fn incomplete(&self) {} + fn response_failed(&self) {} } pub struct CompletionStream { @@ -282,6 +283,12 @@ pub struct CompletionStream { } impl CompletionStream { + pub fn response_failed(&self) { + if let Some(meter) = &self.meter { + meter.response_failed(); + } + } + pub async fn next(&mut self) -> Option> { match tokio::time::timeout(self.idle_timeout, self.receiver.recv()).await { Ok(event) => { diff --git a/src/spark/web.rs b/src/spark/web.rs new file mode 100644 index 0000000..ec36a3a --- /dev/null +++ b/src/spark/web.rs @@ -0,0 +1,1548 @@ +//! Browser sessions and panel APIs. The original bearer never enters the browser. + +use super::*; +use axum::response::{Html, Redirect}; +use serde::Serialize; +use std::{collections::HashMap, sync::Mutex, time::Instant}; + +include!(concat!(env!("OUT_DIR"), "/panel_assets.rs")); + +#[derive(Clone, Debug, Deserialize)] +#[serde(default, deny_unknown_fields)] +pub struct PanelConfig { + pub enabled: bool, + pub origin: Option, +} +impl Default for PanelConfig { + fn default() -> Self { + Self { + enabled: true, + origin: None, + } + } +} + +#[derive(Default)] +pub(super) struct WebState { + pub config: PanelConfig, + flows: Mutex>, + sessions: Mutex>, + health: Mutex>, +} +struct LoginFlow { + intent: String, + browser_hash: String, + origin: String, + created: Instant, + approval: Option<(String, String, Instant)>, + consumed: bool, +} +struct WebSession { + token_id: String, + origin: String, + csrf: String, + created: Instant, + touched: Instant, +} +pub(super) fn secret() -> String { + format!( + "{}{}", + uuid::Uuid::new_v4().simple(), + uuid::Uuid::new_v4().simple() + ) +} +fn hash(value: &str) -> String { + format!("{:x}", Sha256::digest(value.as_bytes())) +} +fn valid_secret(value: &str) -> bool { + value.len() == 64 && value.bytes().all(|b| b.is_ascii_hexdigit()) +} +fn cookie<'a>(headers: &'a HeaderMap, name: &str) -> Option<&'a str> { + headers + .get(header::COOKIE)? + .to_str() + .ok()? + .split(';') + .filter_map(|part| part.trim().split_once('=')) + .find_map(|(key, value)| (key == name).then_some(value)) +} +// HTTP/2 sends :authority rather than Host. Preserve one validated identity for +// both transports before origin checks and header extractors run. +pub(super) async fn normalize_authority(mut request: Request, next: Next) -> Response { + if let Some(authority) = request.uri().authority() { + let Ok(host) = HeaderValue::from_str(authority.as_str()) else { + return denied(); + }; + if request + .headers() + .get(header::HOST) + .is_some_and(|existing| !existing.as_bytes().eq_ignore_ascii_case(host.as_bytes())) + { + return denied(); + } + request.headers_mut().insert(header::HOST, host); + } + next.run(request).await +} +fn origin(state: &AgentState, headers: &HeaderMap) -> Option { + let host = headers.get(header::HOST)?.to_str().ok()?; + let url = reqwest::Url::parse(&format!("https://{host}")).ok()?; + if !url.username().is_empty() + || url.password().is_some() + || url.path() != "/" + || url.query().is_some() + || url.fragment().is_some() + { + return None; + } + let hostname = url.host_str()?.trim_matches(['[', ']']); + if !state + .certificate + .dns_sans + .iter() + .chain(&state.certificate.ip_sans) + .any(|san| san.eq_ignore_ascii_case(hostname)) + { + return None; + } + let origin = url.origin().ascii_serialization(); + if state + .web + .config + .origin + .as_ref() + .is_some_and(|configured| configured != &origin) + { + return None; + } + Some(origin) +} +pub(super) fn validate_config(state: &AgentState) -> anyhow::Result<()> { + if let Some(configured) = &state.web.config.origin { + let url = reqwest::Url::parse(configured)?; + anyhow::ensure!( + url.scheme() == "https" + && url.path() == "/" + && url.query().is_none() + && url.fragment().is_none() + && url.origin().ascii_serialization() == *configured, + "webui.origin must be an exact HTTPS origin without a path" + ); + let mut headers = HeaderMap::new(); + let host = configured + .strip_prefix("https://") + .expect("validated scheme"); + headers.insert(header::HOST, HeaderValue::from_str(host)?); + anyhow::ensure!( + origin(state, &headers).is_some(), + "webui.origin must match an installed certificate identity" + ); + } + Ok(()) +} +fn secure(mut response: Response) -> Response { + response + .headers_mut() + .entry(header::CACHE_CONTROL) + .or_insert(HeaderValue::from_static("no-store")); + for (name, value) in [ + ("referrer-policy", "no-referrer"), + ("x-content-type-options", "nosniff"), + ("x-frame-options", "DENY"), + ( + "content-security-policy", + "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; connect-src 'self' http://127.0.0.1:9844; frame-ancestors 'none'; base-uri 'none'; form-action 'self'", + ), + ] { + response.headers_mut().insert( + axum::http::HeaderName::from_static(name), + HeaderValue::from_static(value), + ); + } + response +} +fn denied() -> Response { + secure(auth_failed("/panel/")) +} +fn set_cookie(response: &mut Response, value: String) { + response.headers_mut().append( + header::SET_COOKIE, + HeaderValue::from_str(&value).expect("generated cookie"), + ); +} + +pub(super) fn public_routes(state: AgentState) -> Router { + Router::new() + .route("/panel", get(|| async { Redirect::to("/panel/") })) + .route("/panel/", get(asset)) + .route("/panel/auth/begin", get(begin)) + .route("/panel/auth/finish", get(finish)) + .route( + "/panel/auth/complete.js", + get(|| async { + secure( + ( + [(header::CONTENT_TYPE, "text/javascript")], + "window.location.replace('/panel/');", + ) + .into_response(), + ) + }), + ) + .route("/panel/{*path}", get(asset)) + .route_layer(middleware::from_fn_with_state(state, public_guard)) +} +async fn public_guard(State(state): State, request: Request, next: Next) -> Response { + if !state.web.config.enabled + || !peer_allowed( + &state, + request.extensions().get::>(), + ) + || origin(&state, request.headers()).is_none() + { + return denied(); + } + secure(next.run(request).await) +} +pub(super) fn api_routes() -> Router { + Router::new() + .route( + &format!("{API_BASE}/web-auth/approve"), + axum::routing::post(approve), + ) + .route( + &format!("{API_BASE}/web-auth/flows/{{id}}"), + get(flow_status), + ) + .route(&format!("{API_BASE}/web-session"), get(me).delete(logout)) + .route(&format!("{API_BASE}/analytics"), get(analytics_summary)) + .route( + &format!("{API_BASE}/analytics/requests"), + get(analytics_requests), + ) + .route( + &format!("{API_BASE}/analytics/sessions"), + get(analytics_sessions), + ) + .route(&format!("{API_BASE}/audit"), get(audit)) + .route(&format!("{API_BASE}/health"), get(health)) + .route(&format!("{API_BASE}/health/history"), get(health_history)) + .route( + &format!("{API_BASE}/launch-sessions/{{id}}/compression"), + axum::routing::post(session_compression), + ) + .route( + &format!("{API_BASE}/instances/{{id}}/recover"), + axum::routing::post(recover), + ) +} + +#[derive(Deserialize, serde::Serialize)] +#[serde(deny_unknown_fields)] +struct RecoverRequest { + #[serde(default)] + dry_run: bool, +} +async fn recover( + State(state): State, + Extension(auth): Extension, + AxumPath(id): AxumPath, + headers: HeaderMap, + Json(body): Json, +) -> Response { + let Some(db) = state.database.clone() else { + return database_unavailable(); + }; + let instance = match db.instance(&id).await { + Ok(i) => i, + Err(error) => return state_problem(error), + }; + if let Err(detail) = recovery_settings(&state, &instance).await { + return problem( + StatusCode::CONFLICT, + "spark.instance.recovery-settings", + &detail, + ); + } + if body.dry_run { + return Json(serde_json::json!({"instance":instance,"actions":["stop","serve"],"preserves":"qualified engine settings","interrupts_active_requests":true})).into_response(); + } + if let Err(response) = require_executor_for_mutation(&state).await { + return response; + } + let key = match required_idempotency(&headers) { + Ok(key) => key, + Err(()) => return missing_idempotency(), + }; + let hash = + super::super::wire::canonical_request_sha256(&serde_json::json!({"instance":instance.id})) + .expect("finite recovery intent"); + let accepted = match db + .accept_operation( + &auth.id, + "instance.recover", + &key, + &hash, + Some(instance.id.clone()), + ) + .await + { + Ok(op) => op, + Err(error) => return state_problem(error), + }; + if !accepted.reused { + let operation = accepted.operation.id.clone(); + tokio::spawn(async move { + let result = run_recovery(state.clone(), auth, instance, &operation).await; + let state_value = if result.is_ok() { + super::super::wire::OperationState::Succeeded + } else { + super::super::wire::OperationState::Failed + }; + let problem = result.err().map(|detail| ProblemDocument { + schema: PROBLEM_SCHEMA.into(), + r#type: "about:blank".into(), + code: "spark.instance.recovery-failed".into(), + status: 409, + detail, + remediation: vec![ + "Inspect the child operations and instance state before retrying.".into(), + ], + operation_id: Some(operation.clone()), + }); + let _ = db + .transition( + &operation, + state_value, + OperationProgress { + stage: "finished".into(), + current: None, + total: None, + unit: None, + message: "Managed recovery finished".into(), + }, + None, + problem, + ) + .await; + }); + } + accepted_response(accepted.operation) +} +async fn run_recovery( + state: AgentState, + auth: AuthenticatedToken, + instance: InstanceDocument, + parent: &str, +) -> Result<(), String> { + let db = state.database.as_ref().ok_or("database unavailable")?; + db.transition( + parent, + super::super::wire::OperationState::Running, + lifecycle_progress("validating", "Validating qualified recovery settings"), + None, + None, + ) + .await + .map_err(|e| e.to_string())?; + for phase in ["stop", "serve"] { + recovery_settings(&state, &instance).await?; + let current = db.operation(parent).await.map_err(|e| e.to_string())?; + if current.state.is_terminal() { + return Err("recovery no longer active".into()); + } + let _ = db + .transition( + parent, + super::super::wire::OperationState::Running, + OperationProgress { + stage: phase.into(), + current: None, + total: None, + unit: None, + message: format!("Managed recovery: {phase}"), + }, + None, + None, + ) + .await; + let mut headers = HeaderMap::new(); + headers.insert( + "idempotency-key", + HeaderValue::from_str(&format!("{parent}-{phase}")).expect("bounded key"), + ); + let response = if phase == "stop" { + stop_instance( + State(state.clone()), + AxumPath(instance.id.clone()), + headers, + Extension(auth.clone()), + Json(StopRequest { + timeout_seconds: 30, + dry_run: false, + }), + ) + .await + } else { + serve_instance( + State(state.clone()), + headers, + Extension(auth.clone()), + Json(ServeRequest { + model: instance.model.clone(), + name: Some(instance.name.clone()), + dry_run: false, + }), + ) + .await + }; + if !response.status().is_success() { + return Err(format!( + "{phase} was rejected; inspect instance health and admission" + )); + } + let bytes = axum::body::to_bytes(response.into_body(), 1024 * 1024) + .await + .map_err(|_| "child response unavailable")?; + let child: OperationDocument = + serde_json::from_slice(&bytes).map_err(|_| "child operation unavailable")?; + let deadline = Instant::now() + + Duration::from_secs(super::super::MAX_ENGINE_STARTUP_DEADLINE_SECONDS + 60); + loop { + let current = db.operation(&child.id).await.map_err(|e| e.to_string())?; + if current.state.is_terminal() { + if current.state != super::super::wire::OperationState::Succeeded { + return Err(format!("{phase} operation did not succeed")); + } + break; + } + if Instant::now() >= deadline { + return Err(format!( + "{phase} operation remains pending; inspect its progress" + )); + } + if db + .operation(parent) + .await + .map_err(|e| e.to_string())? + .state + .is_terminal() + { + return Err( + "recovery cancelled; child operation remains visible in Operations".into(), + ); + } + tokio::time::sleep(Duration::from_millis(500)).await; + } + } + Ok(()) +} +async fn recovery_settings(state: &AgentState, instance: &InstanceDocument) -> Result<(), String> { + let db = state.database.as_ref().ok_or("database unavailable")?; + let model = db + .model(&instance.model_id) + .await + .map_err(|e| e.to_string())?; + let artifacts = model + .artifacts + .as_ref() + .ok_or("verified artifact traits unavailable")?; + let policy = state + .engine_catalog + .as_ref() + .ok_or("engine catalog unavailable")? + .select(artifacts)?; + let profile = policy.profile_for(None, artifacts)?; + if policy.fingerprint() != instance.engine_fingerprint + || policy.config().id != instance.engine_id + || model.canonical != instance.model + || model.commit != instance.model_commit + || artifacts != &instance.artifacts + || instance.objective != "inference" + || profile.context_window != instance.context_window + || profile.sampling.default_reasoning_effort != instance.default_reasoning_effort + || policy.resources_for(None, artifacts)? != instance.resources + { + return Err("Current catalog differs from this instance's qualified settings; use the signed capability activation workflow.".into()); + } + Ok(()) +} + +async fn panel_query( + state: AgentState, + query: crate::spark::analytics::AnalyticsQuery, + kind: crate::spark::analytics::QueryKind, +) -> Response { + let Some(db) = &state.database else { + return database_unavailable(); + }; + match db.panel_query(kind, query).await { + Ok(value) => secure(Json(value).into_response()), + Err(error) => state_problem(error), + } +} +async fn analytics_summary( + State(state): State, + Query(query): Query, +) -> Response { + panel_query(state, query, crate::spark::analytics::QueryKind::Summary).await +} +async fn analytics_requests( + State(state): State, + Query(query): Query, +) -> Response { + panel_query(state, query, crate::spark::analytics::QueryKind::Requests).await +} +async fn analytics_sessions( + State(state): State, + Query(query): Query, +) -> Response { + panel_query(state, query, crate::spark::analytics::QueryKind::Sessions).await +} +async fn audit( + State(state): State, + Query(query): Query, +) -> Response { + panel_query(state, query, crate::spark::analytics::QueryKind::Audit).await +} +async fn health_history( + State(state): State, + Query(query): Query, +) -> Response { + panel_query(state, query, crate::spark::analytics::QueryKind::Health).await +} +async fn session_compression( + State(state): State, + Extension(auth): Extension, + AxumPath(id): AxumPath, + Json(report): Json, +) -> Response { + let Some(db) = &state.database else { + return database_unavailable(); + }; + match db.session_compression(&auth.id, &id, report).await { + Ok(value) => Json(value).into_response(), + Err(error) => state_problem(error), + } +} +async fn health(State(state): State) -> Response { + let sample = state + .web + .health + .lock() + .unwrap_or_else(std::sync::PoisonError::into_inner) + .clone(); + match sample { + Some(sample) => secure(Json(sample).into_response()), + None => problem( + StatusCode::SERVICE_UNAVAILABLE, + "spark.health.pending", + "health sample is not available yet", + ), + } +} +pub(super) async fn sample_health(state: AgentState) { + let mut tick = tokio::time::interval(Duration::from_secs(5)); + let mut cycle = 0u64; + let mut previous_cpu: Option<(u64, u64)> = None; + loop { + tick.tick().await; + let telemetry = if let Some(executor) = &state.executor { + tokio::time::timeout(Duration::from_secs(3), executor.panel_telemetry()) + .await + .ok() + .and_then(Result::ok) + } else { + None + }; + let database = if let Some(db) = &state.database { + db.health().await.ok() + } else { + None + }; + let cpu = telemetry + .as_ref() + .and_then(|t| t.cpu_total_ticks.zip(t.cpu_idle_ticks)); + let cpu_percent = cpu + .zip(previous_cpu) + .and_then(|((total, idle), (old_total, old_idle))| { + total.checked_sub(old_total).zip(idle.checked_sub(old_idle)) + }) + .filter(|(total, idle)| *total > 0 && idle <= total) + .map(|(total, idle)| 100.0 * (total - idle) as f64 / total as f64); + previous_cpu = cpu; + let sample = serde_json::json!({"schema":"sparkplane.health/v1","observed_at_unix_ms":unix_millis(),"agent_version":env!("CARGO_PKG_VERSION"),"cpu_percent":cpu_percent,"executor":telemetry,"database":database}); + *state + .web + .health + .lock() + .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(sample.clone()); + if let Some(db) = &state.database { + let _ = db.panel_health(sample).await; + if cycle.is_multiple_of(12) { + let _ = db.panel_cleanup().await; + } + } + cycle = cycle.wrapping_add(1); + } +} +fn peer_allowed(state: &AgentState, peer: Option<&ConnectInfo>) -> bool { + peer.is_none_or(|peer| { + state + .allowed_clients + .iter() + .any(|cidr| cidr.contains(peer.0.ip())) + }) +} +async fn asset( + State(state): State, + headers: HeaderMap, + uri: axum::http::Uri, + peer: Option>>, +) -> Response { + let peer = peer.map(|Extension(peer)| peer); + if !state.web.config.enabled + || !peer_allowed(&state, peer.as_ref()) + || origin(&state, &headers).is_none() + { + return denied(); + } + let path = uri.path().strip_prefix("/panel/").unwrap_or(""); + let file = if path.is_empty() + || [ + "overview", + "analytics", + "models", + "instances", + "operations", + "health", + "admin", + ] + .contains(&path) + { + "index.html" + } else { + path + }; + match ASSETS.iter().find(|(name, _, _)| *name == file) { + Some((_, bytes, mime)) => { + let mut response = secure(([(header::CONTENT_TYPE, *mime)], *bytes).into_response()); + if file.starts_with("assets/") { + response.headers_mut().insert( + header::CACHE_CONTROL, + HeaderValue::from_static("public, max-age=31536000, immutable"), + ); + } + response + } + None => not_found().await, + } +} +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] +struct BeginQuery { + intent: String, +} +async fn begin( + State(state): State, + headers: HeaderMap, + Query(query): Query, + peer: Option>>, +) -> Response { + let peer = peer.map(|Extension(peer)| peer); + if !state.web.config.enabled + || !valid_secret(&query.intent) + || !peer_allowed(&state, peer.as_ref()) + { + return denied(); + } + let Some(origin) = origin(&state, &headers) else { + return denied(); + }; + let mut flows = state + .web + .flows + .lock() + .unwrap_or_else(std::sync::PoisonError::into_inner); + flows.retain(|_, flow| flow.created.elapsed() < Duration::from_secs(600)); + if flows.len() >= 128 { + return problem( + StatusCode::TOO_MANY_REQUESTS, + "spark.web.busy", + "too many pending logins", + ); + } + let id = secret(); + let browser = secret(); + flows.insert( + id.clone(), + LoginFlow { + intent: query.intent.clone(), + browser_hash: hash(&browser), + origin, + created: Instant::now(), + approval: None, + consumed: false, + }, + ); + let mut response = Redirect::to(&format!( + "http://127.0.0.1:9844/auth/approve?flow={id}&intent={}", + query.intent + )) + .into_response(); + set_cookie( + &mut response, + format!( + "sparkplane_web_pending={browser}; Path=/panel/auth; HttpOnly; Secure; SameSite=Lax; Max-Age=600" + ), + ); + secure(response) +} +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] +struct ApprovalRequest { + flow: String, + intent: String, +} +async fn approve( + State(state): State, + Extension(auth): Extension, + Json(body): Json, +) -> Response { + if !state.web.config.enabled { + return denied(); + } + let mut flows = state + .web + .flows + .lock() + .unwrap_or_else(std::sync::PoisonError::into_inner); + let Some(flow) = flows.get_mut(&body.flow) else { + return denied(); + }; + if flow.created.elapsed() >= Duration::from_secs(600) + || flow.consumed + || flow.approval.is_some() + || !token_matches(&flow.intent, &body.intent) + { + return denied(); + } + let code = secret(); + flow.approval = Some((auth.id, hash(&code), Instant::now())); + secure(Json(serde_json::json!({"code":code})).into_response()) +} +async fn flow_status( + State(state): State, + Extension(auth): Extension, + AxumPath(id): AxumPath, +) -> Response { + let flows = state + .web + .flows + .lock() + .unwrap_or_else(std::sync::PoisonError::into_inner); + match flows.get(&id) { + Some(flow) + if flow.created.elapsed() < Duration::from_secs(600) + && flow + .approval + .as_ref() + .is_some_and(|(token, _, _)| token == &auth.id) => + { + secure(Json(serde_json::json!({"complete":flow.consumed})).into_response()) + } + _ => denied(), + } +} +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] +struct FinishQuery { + flow: String, + code: String, +} +async fn finish( + State(state): State, + headers: HeaderMap, + Query(query): Query, + peer: Option>>, +) -> Response { + let peer = peer.map(|Extension(peer)| peer); + if !state.web.config.enabled || !peer_allowed(&state, peer.as_ref()) { + return denied(); + } + let Some(origin) = origin(&state, &headers) else { + return denied(); + }; + let Some(browser) = cookie(&headers, "sparkplane_web_pending") else { + return denied(); + }; + let mut flows = state + .web + .flows + .lock() + .unwrap_or_else(std::sync::PoisonError::into_inner); + let Some(flow) = flows.get_mut(&query.flow) else { + return denied(); + }; + let Some((token_id, code_hash, approved)) = flow.approval.as_ref() else { + return denied(); + }; + if flow.consumed + || flow.origin != origin + || approved.elapsed() >= Duration::from_secs(60) + || flow.created.elapsed() >= Duration::from_secs(600) + || !token_matches(&flow.browser_hash, &hash(browser)) + || !token_matches(code_hash, &hash(&query.code)) + || token_identity(&state, token_id, peer.as_ref()).is_none() + { + return denied(); + } + let mut sessions = state + .web + .sessions + .lock() + .unwrap_or_else(std::sync::PoisonError::into_inner); + sessions.retain(|_, session| { + session.created.elapsed() < Duration::from_secs(8 * 3600) + && session.touched.elapsed() < Duration::from_secs(1800) + }); + if sessions.len() >= 1024 { + return denied(); + } + let session = secret(); + sessions.insert( + hash(&session), + WebSession { + token_id: token_id.clone(), + origin, + csrf: secret(), + created: Instant::now(), + touched: Instant::now(), + }, + ); + flow.consumed = true; + let mut response = Html("Authenticated · SparkplaneOpen Sparkplane").into_response(); + set_cookie( + &mut response, + format!( + "sparkplane_web={session}; Path=/; HttpOnly; Secure; SameSite=Strict; Max-Age=28800" + ), + ); + set_cookie( + &mut response, + "sparkplane_web_pending=; Path=/panel/auth; HttpOnly; Secure; SameSite=Lax; Max-Age=0" + .into(), + ); + secure(response) +} +fn token_identity( + state: &AgentState, + id: &str, + peer: Option<&ConnectInfo>, +) -> Option { + if id == "bootstrap-admin" { + return Some(AuthenticatedToken::admin(state.inference_slot(id, 64))); + } + let snapshot = state.auth.load(); + let token = &snapshot.tokens.get(id)?.token; + if token.revoked_at.is_some() + || token.expires_at.as_ref().is_some_and(|expiry| { + chrono::DateTime::parse_from_rfc3339(expiry) + .map_or(true, |expiry| expiry <= chrono::Utc::now()) + }) + { + return None; + } + if !token.allowed_cidrs.is_empty() + && !peer.is_some_and(|peer| { + token + .allowed_cidrs + .iter() + .filter_map(|c| c.parse::().ok()) + .any(|c| c.contains(peer.0.ip())) + }) + { + return None; + } + Some(AuthenticatedToken { + id: id.into(), + scopes: token.scopes.clone(), + inference: state.inference_slot(id, token.max_concurrent_inference), + }) +} +pub(super) fn authenticate_cookie( + state: &AgentState, + request: &Request, +) -> Option { + if !state.web.config.enabled + || !request.uri().path().starts_with(API_BASE) + || request + .uri() + .path() + .starts_with(&format!("{API_BASE}/web-auth")) + || request.headers().contains_key(header::AUTHORIZATION) + { + return None; + } + let session = cookie(request.headers(), "sparkplane_web")?; + let origin = origin(state, request.headers())?; + if request + .headers() + .get("sec-fetch-site") + .is_some_and(|v| v != "same-origin" && v != "none") + { + return None; + } + let mut sessions = state + .web + .sessions + .lock() + .unwrap_or_else(std::sync::PoisonError::into_inner); + let session = sessions.get_mut(&hash(session))?; + if session.origin != origin + || session.created.elapsed() >= Duration::from_secs(8 * 3600) + || session.touched.elapsed() >= Duration::from_secs(1800) + { + return None; + } + if ![Method::GET, Method::HEAD].contains(request.method()) + && (request + .headers() + .get(header::ORIGIN) + .and_then(|v| v.to_str().ok()) + != Some(origin.as_str()) + || !request + .headers() + .get("x-sparkplane-csrf") + .and_then(|v| v.to_str().ok()) + .is_some_and(|v| token_matches(&session.csrf, v))) + { + return None; + } + if request + .headers() + .get(header::ORIGIN) + .is_some_and(|v| v.to_str().ok() != Some(origin.as_str())) + { + return None; + } + let auth = token_identity( + state, + &session.token_id, + request.extensions().get::>(), + )?; + session.touched = Instant::now(); + Some(auth) +} +#[derive(Serialize)] +struct SessionDocument { + token_id: String, + scopes: Vec, + csrf: Option, +} +async fn me( + State(state): State, + headers: HeaderMap, + Extension(auth): Extension, +) -> Response { + let csrf = cookie(&headers, "sparkplane_web").and_then(|value| { + state + .web + .sessions + .lock() + .ok()? + .get(&hash(value)) + .map(|s| s.csrf.clone()) + }); + secure( + Json(SessionDocument { + token_id: auth.id, + scopes: auth.scopes, + csrf, + }) + .into_response(), + ) +} +async fn logout(State(state): State, headers: HeaderMap) -> Response { + if let Some(value) = cookie(&headers, "sparkplane_web") { + state + .web + .sessions + .lock() + .unwrap_or_else(std::sync::PoisonError::into_inner) + .remove(&hash(value)); + } + let mut response = StatusCode::NO_CONTENT.into_response(); + set_cookie( + &mut response, + "sparkplane_web=; Path=/; HttpOnly; Secure; SameSite=Strict; Max-Age=0".into(), + ); + secure(response) +} + +#[cfg(test)] +mod tests { + use super::*; + use axum::{body::Body, http::Request}; + use tower::ServiceExt; + + #[tokio::test] + async fn session_lifetimes_logout_and_http2_authority_are_enforced() { + let state = AgentState::new("fixture-secret", vec!["localhost".into()], vec![]); + let value = secret(); + let csrf = secret(); + state.web.sessions.lock().unwrap().insert( + hash(&value), + WebSession { + token_id: "bootstrap-admin".into(), + origin: "https://localhost".into(), + csrf: csrf.clone(), + created: Instant::now(), + touched: Instant::now(), + }, + ); + let app = super::super::router(state.clone()); + let make = || { + Request::builder() + .uri("https://localhost/api/sparkplane/v1/web-session") + .version(axum::http::Version::HTTP_2) + .header("cookie", format!("sparkplane_web={value}")) + }; + assert_eq!( + app.clone() + .oneshot(make().body(Body::empty()).unwrap()) + .await + .unwrap() + .status(), + StatusCode::OK + ); + assert_eq!( + app.clone() + .oneshot( + make() + .header("host", "other-host") + .body(Body::empty()) + .unwrap() + ) + .await + .unwrap() + .status(), + StatusCode::UNAUTHORIZED + ); + for (age, idle) in [(0, 1801), (8 * 3600 + 1, 0)] { + { + let mut sessions = state.web.sessions.lock().unwrap(); + let session = sessions.get_mut(&hash(&value)).unwrap(); + session.created = Instant::now() - Duration::from_secs(age); + session.touched = Instant::now() - Duration::from_secs(idle); + } + assert_eq!( + app.clone() + .oneshot(make().body(Body::empty()).unwrap()) + .await + .unwrap() + .status(), + StatusCode::UNAUTHORIZED + ); + } + { + let mut sessions = state.web.sessions.lock().unwrap(); + let session = sessions.get_mut(&hash(&value)).unwrap(); + session.created = Instant::now(); + session.touched = Instant::now(); + } + let logout = app + .clone() + .oneshot( + make() + .method("DELETE") + .header("origin", "https://localhost") + .header("x-sparkplane-csrf", csrf) + .body(Body::empty()) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!(logout.status(), StatusCode::NO_CONTENT); + assert!( + logout.headers()[header::SET_COOKIE] + .to_str() + .unwrap() + .contains("Max-Age=0") + ); + assert_eq!( + app.oneshot(make().body(Body::empty()).unwrap()) + .await + .unwrap() + .status(), + StatusCode::UNAUTHORIZED + ); + } + + #[tokio::test] + async fn local_helper_and_browser_sessions_round_trip_over_pinned_https() { + authentication_fixture(false).await; + } + + #[tokio::test] + #[ignore = "requires Node and an installed Playwright Chromium browser"] + async fn browser_authentication_redirects_over_https() { + authentication_fixture(true).await; + } + + async fn authentication_fixture(browser: bool) { + use std::os::unix::fs::PermissionsExt; + let root = tempfile::tempdir().unwrap(); + let database = DbActor::open( + root.path().join("state"), + root.path().join("backups"), + 64, + 2, + SecretString::from("fixture-secret"), + ) + .unwrap(); + let created = database + .create_token( + "bootstrap-admin", + "fixture-reader", + TokenCreateRequest { + name: "panel-reader".into(), + scopes: vec![TokenScope::AnalyticsRead], + allowed_cidrs: vec!["127.0.0.0/8".into()], + expires_at: None, + max_concurrent_inference: 1, + }, + ) + .await + .unwrap(); + let token = created.bearer_token.unwrap(); + let state = AgentState::new("fixture-secret", vec!["localhost".into()], vec![]) + .with_database(database.clone()) + .await + .unwrap(); + let server_state = state.clone(); + let rcgen::CertifiedKey { cert, signing_key } = + rcgen::generate_simple_self_signed(vec!["localhost".into()]).unwrap(); + let certificate = cert.pem(); + let tls = super::super::tls13_config( + certificate.as_bytes().to_vec(), + signing_key.serialize_pem().into_bytes(), + ) + .await + .unwrap(); + let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap(); + listener.set_nonblocking(true).unwrap(); + let address = listener.local_addr().unwrap(); + let handle = axum_server::Handle::new(); + let shutdown = handle.clone(); + let server = tokio::spawn(async move { + axum_server::from_tcp_rustls(listener, tls) + .unwrap() + .handle(shutdown) + .serve( + super::super::router(server_state) + .into_make_service_with_connect_info::(), + ) + .await + .unwrap(); + }); + let base = format!("https://localhost:{}", address.port()); + std::fs::create_dir_all(root.path().join("spark")).unwrap(); + std::fs::create_dir_all(root.path().join("credentials")).unwrap(); + std::fs::write(root.path().join("spark/fixture.ca.pem"), &certificate).unwrap(); + std::fs::write(root.path().join("credentials/fixture"), &token).unwrap(); + std::fs::set_permissions( + root.path().join("credentials/fixture"), + std::fs::Permissions::from_mode(0o600), + ) + .unwrap(); + std::fs::write(root.path().join("spark.toml"),format!("[hosts.fixture]\nurl='{base}/'\nca_cert_sha256='sha256:{:x}'\ncredential='fixture'\nrequest_timeout_seconds=5\n",Sha256::digest(certificate.as_bytes()))).unwrap(); + let local = std::net::TcpListener::bind(super::super::super::webauth::ADDRESS).unwrap(); + local.set_nonblocking(true).unwrap(); + let helper = tokio::spawn(super::super::super::webauth::test_service( + root.path().to_owned(), + local, + )); + let client = reqwest::Client::builder() + .no_proxy() + .tls_built_in_root_certs(false) + .add_root_certificate(reqwest::Certificate::from_pem(certificate.as_bytes()).unwrap()) + .redirect(reqwest::redirect::Policy::none()) + .build() + .unwrap(); + let local_base = "http://127.0.0.1:9844"; + let mut available = false; + for _ in 0..100 { + if client + .get(format!("{local_base}/health")) + .header("origin", &base) + .send() + .await + .is_ok_and(|r| r.status().is_success()) + { + available = true; + break; + } + tokio::time::sleep(Duration::from_millis(10)).await; + } + assert!(available); + let accepted = database + .accept_operation( + "bootstrap-admin", + "fixture", + "https-summary", + &"a".repeat(64), + None, + ) + .await + .unwrap() + .operation; + let running = database + .transition( + &accepted.id, + super::super::super::wire::OperationState::Running, + accepted.progress, + None, + None, + ) + .await + .unwrap(); + let complete = database + .transition( + &running.id, + super::super::super::wire::OperationState::Succeeded, + running.progress, + Some(serde_json::json!({"evidence":"x".repeat(2*1024*1024)})), + None, + ) + .await + .unwrap(); + let response = client + .get(format!("{base}{API_BASE}/operations?view=summary")) + .bearer_auth("fixture-secret") + .send() + .await + .unwrap(); + assert_eq!(response.status(), 200); + let summary: serde_json::Value = response.json().await.unwrap(); + assert!(serde_json::to_vec(&summary).unwrap().len() < 8192); + let projected = summary["operations"] + .as_array() + .unwrap() + .iter() + .find(|operation| operation["id"] == complete.id) + .unwrap(); + assert!(projected["result"].is_null()); + let detail: super::super::super::wire::OperationDocument = client + .get(format!("{base}{API_BASE}/operations/{}", complete.id)) + .bearer_auth("fixture-secret") + .send() + .await + .unwrap() + .json() + .await + .unwrap(); + assert_eq!(detail, complete); + assert_eq!( + client + .get(format!("{base}{API_BASE}/operations?view=summary")) + .bearer_auth(&token) + .send() + .await + .unwrap() + .status(), + 401 + ); + assert_eq!( + client + .get(format!( + "{base}{API_BASE}/operations?view=summary&other=true" + )) + .bearer_auth("fixture-secret") + .send() + .await + .unwrap() + .status(), + 400 + ); + if browser { + let result = tokio::time::timeout( + Duration::from_secs(45), + tokio::process::Command::new("node") + .arg("web/tests/auth-flow.mjs") + .arg(&base) + .kill_on_drop(true) + .output(), + ) + .await + .unwrap() + .unwrap(); + assert!( + result.status.success(), + "browser flow failed: {}", + String::from_utf8_lossy(&result.stderr) + ); + assert!( + tokio::time::timeout(Duration::from_secs(5), helper) + .await + .unwrap() + .unwrap() + .unwrap() + ); + handle.graceful_shutdown(Some(Duration::from_secs(1))); + server.await.unwrap(); + database.shutdown().unwrap(); + return; + } + assert_eq!( + client + .get(format!("{local_base}/health")) + .header("origin", "https://evil.example") + .send() + .await + .unwrap() + .status(), + 403 + ); + assert_eq!( + client + .get(format!("{local_base}/health")) + .header("host", "evil.example") + .send() + .await + .unwrap() + .status(), + 403 + ); + let local_start = client + .get(format!("{local_base}/auth/start")) + .send() + .await + .unwrap(); + let local_cookie = local_start.headers()[header::SET_COOKIE] + .to_str() + .unwrap() + .split(';') + .next() + .unwrap() + .to_owned(); + let begin = client + .get(local_start.headers()[header::LOCATION].to_str().unwrap()) + .send() + .await + .unwrap(); + let browser_cookie = begin.headers()[header::SET_COOKIE] + .to_str() + .unwrap() + .split(';') + .next() + .unwrap() + .to_owned(); + let approve_url = begin.headers()[header::LOCATION].to_str().unwrap(); + assert_eq!(client.get(approve_url).send().await.unwrap().status(), 403); + let approval = client + .get(approve_url) + .header("cookie", local_cookie) + .send() + .await + .unwrap(); + assert_eq!(approval.status(), 303); + let finish_url = approval.headers()[header::LOCATION] + .to_str() + .unwrap() + .to_owned(); + assert!(!finish_url.contains(&token)); + assert_eq!(client.get(&finish_url).send().await.unwrap().status(), 401); + let finish = client + .get(&finish_url) + .header("cookie", &browser_cookie) + .send() + .await + .unwrap(); + assert_eq!(finish.status(), 200); + let session = finish.headers()[header::SET_COOKIE] + .to_str() + .unwrap() + .split(';') + .next() + .unwrap() + .to_owned(); + assert!(!session.contains(&token)); + let me: serde_json::Value = client + .get(format!("{base}{API_BASE}/web-session")) + .header("cookie", &session) + .send() + .await + .unwrap() + .json() + .await + .unwrap(); + assert_eq!(me["scopes"], serde_json::json!(["analytics:read"])); + let csrf = me["csrf"].as_str().unwrap(); + assert_eq!( + client + .get(format!("{base}{API_BASE}/analytics")) + .header("cookie", &session) + .send() + .await + .unwrap() + .status(), + 200 + ); + assert_eq!( + client + .get(format!("{base}{API_BASE}/tokens")) + .header("cookie", &session) + .send() + .await + .unwrap() + .status(), + 403 + ); + assert_eq!( + client + .get(format!("{base}/openai/no-model/v1/models")) + .header("cookie", &session) + .send() + .await + .unwrap() + .status(), + 401 + ); + assert_eq!( + client + .delete(format!("{base}{API_BASE}/web-session")) + .header("cookie", &session) + .send() + .await + .unwrap() + .status(), + 401 + ); + assert_eq!( + client + .delete(format!("{base}{API_BASE}/web-session")) + .header("cookie", &session) + .header("x-sparkplane-csrf", csrf) + .header("origin", "https://evil.example") + .send() + .await + .unwrap() + .status(), + 403 + ); + assert!( + tokio::time::timeout(Duration::from_secs(5), helper) + .await + .unwrap() + .unwrap() + .unwrap() + ); + assert!( + client + .get(format!("{local_base}/health")) + .send() + .await + .is_err() + ); + database + .revoke_token("bootstrap-admin", "fixture-revoke", &created.token.id) + .await + .unwrap(); + state.store_auth(database.auth_snapshot().await.unwrap()); + assert_eq!( + client + .get(format!("{base}{API_BASE}/web-session")) + .header("cookie", &session) + .send() + .await + .unwrap() + .status(), + 401 + ); + handle.graceful_shutdown(Some(Duration::from_secs(1))); + server.await.unwrap(); + database.shutdown().unwrap(); + } + + #[tokio::test] + async fn login_requires_browser_binding_and_consumes_code_once() { + let state = AgentState::new("fixture-secret", vec!["localhost".into()], vec![]); + let app = super::super::router(state); + let start = app.clone().oneshot(Request::builder() + .uri("/panel/auth/begin?intent=1111111111111111111111111111111111111111111111111111111111111111") + .header("host", "localhost").body(Body::empty()).unwrap()).await.unwrap(); + assert_eq!(start.status(), StatusCode::SEE_OTHER); + let cookie = start.headers()[header::SET_COOKIE] + .to_str() + .unwrap() + .split(';') + .next() + .unwrap() + .to_owned(); + let callback = + reqwest::Url::parse(start.headers()[header::LOCATION].to_str().unwrap()).unwrap(); + let flow = callback + .query_pairs() + .find(|(k, _)| k == "flow") + .unwrap() + .1 + .into_owned(); + let approval = app.clone().oneshot(Request::builder().method("POST") + .uri("/api/sparkplane/v1/web-auth/approve").header("authorization", "Bearer fixture-secret") + .header("content-type", "application/json") + .body(Body::from(serde_json::json!({"flow":flow,"intent":"1111111111111111111111111111111111111111111111111111111111111111"}).to_string())).unwrap()).await.unwrap(); + assert_eq!(approval.status(), StatusCode::OK); + let bytes = axum::body::to_bytes(approval.into_body(), 4096) + .await + .unwrap(); + let data: serde_json::Value = serde_json::from_slice(&bytes).unwrap(); + let finish = format!( + "/panel/auth/finish?flow={flow}&code={}", + data["code"].as_str().unwrap() + ); + let missing = app + .clone() + .oneshot( + Request::builder() + .uri(&finish) + .header("host", "localhost") + .body(Body::empty()) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!(missing.status(), StatusCode::UNAUTHORIZED); + let ok = app + .clone() + .oneshot( + Request::builder() + .uri(&finish) + .header("host", "localhost") + .header("cookie", &cookie) + .body(Body::empty()) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!(ok.status(), StatusCode::OK); + assert!( + ok.headers()[header::SET_COOKIE] + .to_str() + .unwrap() + .contains("HttpOnly; Secure; SameSite=Strict") + ); + let replay = app + .oneshot( + Request::builder() + .uri(&finish) + .header("host", "localhost") + .header("cookie", cookie) + .body(Body::empty()) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!(replay.status(), StatusCode::UNAUTHORIZED); + } +} diff --git a/src/spark/webauth.rs b/src/spark/webauth.rs new file mode 100644 index 0000000..1ab0e0e --- /dev/null +++ b/src/spark/webauth.rs @@ -0,0 +1,364 @@ +//! Finite, workstation-local authentication bridge. It never serves API tokens. +use super::client::SparkClient; +use anyhow::{Result, bail, ensure}; +use bytes::Bytes; +use clap::{Args, Parser, Subcommand}; +use http_body_util::Full; +use hyper::{Request, Response, body::Incoming, server::conn::http1, service::service_fn}; +use hyper_util::rt::TokioIo; +use std::{ + convert::Infallible, + path::PathBuf, + sync::{Arc, Mutex}, + time::Duration, +}; +use tokio::sync::Semaphore; + +pub const ADDRESS: &str = "127.0.0.1:9844"; + +#[derive(Parser)] +#[command(name = "sparkplane")] +pub struct WebCli { + #[command(subcommand)] + pub command: WebCommand, +} +#[derive(Subcommand)] +pub enum WebCommand { + /// Open the panel and authenticate with a temporary local service. + Webui(WebArgs), + /// Start the temporary local service for a panel already open in your browser. + Webauthsvc { + #[command(subcommand)] + command: ServiceCommand, + }, +} +#[derive(Subcommand)] +pub enum ServiceCommand { + Start(WebArgs), +} +#[derive(Args)] +pub struct WebArgs { + #[arg(long)] + pub host: Option, + #[arg(long, env = "SPARKPLANE_CONFIG_DIR")] + pub config_dir: Option, + #[arg(long, env = "SPARKPLANE_JSON")] + pub json: bool, +} +struct Helper { + client: Arc, + origin: String, + intent: Mutex>, + flow: Mutex>, +} +fn nonce() -> String { + format!( + "{}{}", + uuid::Uuid::new_v4().simple(), + uuid::Uuid::new_v4().simple() + ) +} +fn cookie<'a>(request: &'a Request, name: &str) -> Option<&'a str> { + request + .headers() + .get("cookie")? + .to_str() + .ok()? + .split(';') + .filter_map(|s| s.trim().split_once('=')) + .find_map(|(key, value)| (key == name).then_some(value)) +} +fn response(status: u16, body: &str) -> Response> { + Response::builder() + .status(status) + .header("cache-control", "no-store") + .header("referrer-policy", "no-referrer") + .header("x-content-type-options", "nosniff") + .header( + "content-security-policy", + "default-src 'none'; frame-ancestors 'none'", + ) + .body(Full::new(Bytes::copy_from_slice(body.as_bytes()))) + .expect("fixed response") +} +fn redirect(url: &reqwest::Url, cookie: Option) -> Response> { + let mut response = response(303, ""); + response + .headers_mut() + .insert("location", url.as_str().parse().expect("validated URL")); + if let Some(cookie) = cookie { + response + .headers_mut() + .insert("set-cookie", cookie.parse().expect("generated cookie")); + } + response +} +async fn handle( + helper: Arc, + request: Request, +) -> Result>, Infallible> { + if request.headers().get("host").and_then(|v| v.to_str().ok()) != Some(ADDRESS) + || request.method() != hyper::Method::GET + { + return Ok(response(403, "Local authentication request rejected")); + } + let allowed_origin = request + .headers() + .get("origin") + .and_then(|v| v.to_str().ok()); + if allowed_origin.is_some_and(|origin| origin != helper.origin) { + return Ok(response(403, "Origin rejected")); + } + match request.uri().path() { + "/health" => { + let mut response = response( + 200, + &serde_json::json!({"protocol":"sparkplane.webauth/v1","origin":helper.origin}) + .to_string(), + ); + response + .headers_mut() + .insert("content-type", "application/json".parse().unwrap()); + if allowed_origin == Some(helper.origin.as_str()) { + response.headers_mut().insert( + "access-control-allow-origin", + helper.origin.parse().unwrap(), + ); + response + .headers_mut() + .insert("vary", "Origin".parse().unwrap()); + } + Ok(response) + } + "/auth/start" => { + let intent = nonce(); + *helper.intent.lock().unwrap() = Some(intent.clone()); + let mut url = helper + .client + .base_url() + .join("panel/auth/begin") + .expect("fixed route"); + url.query_pairs_mut().append_pair("intent", &intent); + Ok(redirect( + &url, + Some(format!( + "sparkplane_local_intent={intent}; Path=/auth; HttpOnly; SameSite=Lax; Max-Age=600" + )), + )) + } + "/auth/approve" => { + let url = reqwest::Url::parse(&format!("http://{ADDRESS}{}", request.uri())) + .expect("HTTP request URI"); + let pairs = url.query_pairs().collect::>(); + let flow = pairs + .iter() + .find(|(k, _)| k == "flow") + .map(|(_, v)| v.to_string()); + let intent = pairs + .iter() + .find(|(k, _)| k == "intent") + .map(|(_, v)| v.to_string()); + let valid = pairs.len() == 2 + && intent.as_deref().is_some_and(|value| { + cookie(&request, "sparkplane_local_intent") == Some(value) + && helper.intent.lock().unwrap().as_deref() == Some(value) + }) + && flow.as_ref().is_some_and(|value| { + value.len() == 64 && value.bytes().all(|b| b.is_ascii_hexdigit()) + }); + if !valid { + return Ok(response( + 403, + "Login intent is missing, expired or does not match this browser", + )); + } + let flow = flow.unwrap(); + let intent = intent.unwrap(); + let client = Arc::clone(&helper.client); + let flow_copy = flow.clone(); + let result = + tokio::task::spawn_blocking(move || client.approve_web_login(&flow_copy, &intent)) + .await; + let Ok(Ok(data)) = result else { + return Ok(response( + 502, + "Spark rejected authentication; return to the panel and try again", + )); + }; + let Some(code) = data["code"] + .as_str() + .filter(|code| code.len() == 64 && code.bytes().all(|b| b.is_ascii_hexdigit())) + else { + return Ok(response(502, "Invalid authentication response")); + }; + *helper.intent.lock().unwrap() = None; + *helper.flow.lock().unwrap() = Some(flow.clone()); + let mut url = helper + .client + .base_url() + .join("panel/auth/finish") + .expect("fixed route"); + url.query_pairs_mut() + .append_pair("flow", &flow) + .append_pair("code", code); + Ok(redirect( + &url, + Some( + "sparkplane_local_intent=; Path=/auth; HttpOnly; SameSite=Lax; Max-Age=0" + .into(), + ), + )) + } + _ => Ok(response(404, "Not found")), + } +} + +pub fn dispatch(cli: WebCli) -> Result<()> { + let (args, open) = match cli.command { + WebCommand::Webui(args) => (args, true), + WebCommand::Webauthsvc { + command: ServiceCommand::Start(args), + } => (args, false), + }; + let config = args.config_dir.unwrap_or_else(|| { + std::env::var_os("XDG_CONFIG_HOME") + .map(PathBuf::from) + .or_else(|| std::env::var_os("HOME").map(|home| PathBuf::from(home).join(".config"))) + .unwrap_or_else(|| PathBuf::from(".config")) + .join("sparkplane") + }); + let hosts = SparkClient::configured_hosts(&config)?; + let host = match args.host { + Some(host) => host, + None if hosts.len() == 1 => hosts[0].clone(), + _ => bail!("select a configured Spark using --host ALIAS"), + }; + let client = SparkClient::load(&config, &host)?; + ensure!( + client.base_url().scheme() == "https", + "web authentication requires HTTPS" + ); + client.get_json::("api/sparkplane/v1/web-session")?; + let mut panel = client.base_url().join("panel/")?; + if open { + panel.set_fragment(Some("local-auth")); + } + let helper = Arc::new(Helper { + origin: client.base_url().origin().ascii_serialization(), + client: Arc::new(client), + intent: Mutex::new(None), + flow: Mutex::new(None), + }); + let listener = std::net::TcpListener::bind(ADDRESS).map_err(|_| { + anyhow::anyhow!("{ADDRESS} is already occupied; finish or stop the existing local service") + })?; + listener.set_nonblocking(true)?; + eprintln!( + "Local authentication service ready. Open {panel} and click Authenticate. Expires in ten minutes; Ctrl-C stops it." + ); + if open { + match std::process::Command::new("xdg-open") + .arg(panel.as_str()) + .stdin(std::process::Stdio::null()) + .stdout(std::process::Stdio::null()) + .stderr(std::process::Stdio::null()) + .spawn() + { + Ok(mut child) => { + std::thread::spawn(move || { + let _ = child.wait(); + }); + } + Err(_) => eprintln!("Could not open your browser; open {panel} manually."), + } + } + let runtime = tokio::runtime::Builder::new_multi_thread() + .worker_threads(2) + .enable_all() + .build()?; + let complete = runtime.block_on(serve(listener, helper))?; + if args.json { + println!( + "{}", + serde_json::json!({"schema":"sparkplane.webauth/v1","host":host,"authenticated":complete,"service_stopped":true}) + ); + } + if !complete { + bail!("local authentication service stopped before authentication completed"); + } + eprintln!("Authenticated. Local authentication service stopped."); + Ok(()) +} +async fn serve(listener: std::net::TcpListener, helper: Arc) -> Result { + let listener = tokio::net::TcpListener::from_std(listener)?; + let slots = Arc::new(Semaphore::new(16)); + let mut tick = tokio::time::interval(Duration::from_millis(500)); + let expiry = tokio::time::sleep(Duration::from_secs(600)); + let mut connections = tokio::task::JoinSet::new(); + tokio::pin!(expiry); + let completed = loop { + tokio::select! { + _ = &mut expiry => break false, + _ = tokio::signal::ctrl_c() => break false, + _ = connections.join_next(), if !connections.is_empty() => {}, + _ = tick.tick() => { + let flow = helper.flow.lock().unwrap().clone(); + if let Some(flow) = flow { + let client = Arc::clone(&helper.client); + if tokio::task::spawn_blocking(move || client.web_login_complete(&flow)).await.is_ok_and(|r| r.unwrap_or(false)) { break true; } + } + }, + accepted = listener.accept() => { + let (stream,peer) = accepted?; + if !peer.ip().is_loopback() { continue; } + let Ok(permit) = slots.clone().try_acquire_owned() else { continue; }; + let helper = helper.clone(); + connections.spawn(async move { + let _permit = permit; + let connection = http1::Builder::new().max_buf_size(16*1024).serve_connection(TokioIo::new(stream),service_fn(move |req|handle(helper.clone(),req))); + let _ = tokio::time::timeout(Duration::from_secs(10),connection).await; + }); + } + } + }; + connections.abort_all(); + while connections.join_next().await.is_some() {} + Ok(completed) +} + +#[cfg(all(test, feature = "appliance"))] +pub(crate) async fn test_service(config: PathBuf, listener: std::net::TcpListener) -> Result { + let client = + tokio::task::spawn_blocking(move || SparkClient::load(&config, "fixture")).await??; + let helper = Arc::new(Helper { + origin: client.base_url().origin().ascii_serialization(), + client: Arc::new(client), + intent: Mutex::new(None), + flow: Mutex::new(None), + }); + serve(listener, helper).await +} + +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn hostless_commands_parse_without_changing_host_first_cli() { + assert!(matches!( + WebCli::try_parse_from(["sparkplane", "webui"]) + .unwrap() + .command, + WebCommand::Webui(_) + )); + assert!(matches!( + WebCli::try_parse_from(["sparkplane", "webauthsvc", "start", "--host", "spark"]) + .unwrap() + .command, + WebCommand::Webauthsvc { .. } + )); + assert!( + WebCli::try_parse_from(["sparkplane", "webauthsvc", "start", "--token", "secret"]) + .is_err() + ); + } +} diff --git a/src/spark/wire.rs b/src/spark/wire.rs index 2cf1b91..29e5e6b 100644 --- a/src/spark/wire.rs +++ b/src/spark/wire.rs @@ -801,6 +801,8 @@ pub struct OperationEvent { #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] #[cfg_attr(feature = "appliance", derive(utoipa::ToSchema))] pub enum TokenScope { + #[serde(rename = "analytics:read")] + AnalyticsRead, #[serde(rename = "models:read")] ModelsRead, #[serde(rename = "models:write")] @@ -828,6 +830,7 @@ pub enum TokenScope { impl TokenScope { pub fn as_str(&self) -> &'static str { match self { + Self::AnalyticsRead => "analytics:read", Self::ModelsRead => "models:read", Self::ModelsWrite => "models:write", Self::InstancesRead => "instances:read", @@ -848,6 +851,7 @@ impl std::str::FromStr for TokenScope { fn from_str(value: &str) -> Result { match value { + "analytics:read" => Ok(Self::AnalyticsRead), "models:read" => Ok(Self::ModelsRead), "models:write" => Ok(Self::ModelsWrite), "instances:read" => Ok(Self::InstancesRead), diff --git a/tests/eco_launch.rs b/tests/eco_launch.rs index b65c32d..1f1c979 100644 --- a/tests/eco_launch.rs +++ b/tests/eco_launch.rs @@ -160,7 +160,7 @@ fn economics_json_is_a_retained_offline_report() { assert_eq!(value["session_id"], report.session_id); assert_eq!(value["exit_code"], 7); assert!(value["inference"].is_null()); - assert!(value["comparisons"][0]["inference_usd_nanos"].is_null()); + assert_eq!(value["comparisons"], serde_json::json!([])); } #[test] diff --git a/tests/generated_files.rs b/tests/generated_files.rs index b17a411..f34de28 100644 --- a/tests/generated_files.rs +++ b/tests/generated_files.rs @@ -95,3 +95,47 @@ fn an_interrupted_pair_update_can_be_completed_without_losing_ownership() { sparkplane::generated_files::remove(root.path()).unwrap(); assert!(!root.path().join("sparkplane-launch.config.toml").exists()); } + +#[test] +fn resume_providers_survive_model_changes_and_profile_removal() { + let root = tempfile::tempdir().unwrap(); + let original = "# User preferences\nmodel = 'gpt-6.1-sol'\n[model_providers.other]\nname = 'Other'\nbase_url = 'https://other.example/v1'\nwire_api = 'responses'\n"; + std::fs::write(root.path().join("config.toml"), original).unwrap(); + let first = b"model='qwen'\nmodel_provider='sparkplane_qwen'\n[model_providers.sparkplane_qwen]\nname='Sparkplane Qwen'\nbase_url='https://spark.example/openai/qwen/v1'\nenv_key='SPARKPLANE_INFERENCE_TOKEN'\nwire_api='responses'\n"; + let second = b"model='other'\nmodel_provider='sparkplane_other'\n[model_providers.sparkplane_other]\nname='Sparkplane Other'\nbase_url='https://spark.example/openai/other/v1'\nenv_key='SPARKPLANE_INFERENCE_TOKEN'\nwire_api='responses'\n"; + for profile in [first.as_slice(), second.as_slice()] { + sparkplane::generated_files::publish(root.path(), profile, b"catalog").unwrap(); + sparkplane::generated_files::publish_provider(root.path(), profile).unwrap(); + } + sparkplane::generated_files::remove(root.path()).unwrap(); + let text = std::fs::read_to_string(root.path().join("config.toml")).unwrap(); + let config: toml::Value = toml::from_str(&text).unwrap(); + assert_eq!(config["model"].as_str(), Some("gpt-6.1-sol")); + assert!(config.get("model_provider").is_none()); + assert!(text.starts_with("# User preferences\nmodel = 'gpt-6.1-sol'\n")); + for name in ["sparkplane_qwen", "sparkplane_other", "other"] { + assert!(config["model_providers"].get(name).is_some(), "{name}"); + } + assert!(!root.path().join("sparkplane-launch.config.toml").exists()); + // Missing definitions are repaired without replacing user preferences. + std::fs::write(root.path().join("config.toml"), original).unwrap(); + sparkplane::generated_files::publish_provider(root.path(), first).unwrap(); + let text = std::fs::read_to_string(root.path().join("config.toml")).unwrap(); + assert!(text.contains("sparkplane_qwen")); +} + +#[test] +fn resume_provider_registration_preserves_edits_and_rejects_symlinks() { + let root = tempfile::tempdir().unwrap(); + let profile = b"[model_providers.sparkplane_qwen]\nname='Sparkplane Qwen'\nbase_url='https://spark.example/v1'\nwire_api='responses'\n"; + sparkplane::generated_files::publish_provider(root.path(), profile).unwrap(); + let path = root.path().join("config.toml"); + let text = std::fs::read_to_string(&path).unwrap(); + let edited = text.replace("https://spark.example/v1", "https://custom.example/v1"); + std::fs::write(&path, &edited).unwrap(); + assert!(sparkplane::generated_files::publish_provider(root.path(), profile).is_err()); + assert_eq!(std::fs::read_to_string(&path).unwrap(), edited); + std::fs::rename(&path, root.path().join("user-original")).unwrap(); + std::os::unix::fs::symlink("user-original", &path).unwrap(); + assert!(sparkplane::generated_files::publish_provider(root.path(), profile).is_err()); +} diff --git a/web/components.json b/web/components.json new file mode 100644 index 0000000..89b3f2f --- /dev/null +++ b/web/components.json @@ -0,0 +1,20 @@ +{ + "$schema": "https://ui.shadcn.com/schema.json", + "style": "new-york", + "rsc": false, + "tsx": true, + "tailwind": { + "config": "", + "css": "src/index.css", + "baseColor": "neutral", + "cssVariables": true + }, + "iconLibrary": "lucide", + "aliases": { + "components": "@/components", + "utils": "@/lib/utils", + "ui": "@/components/ui", + "lib": "@/lib", + "hooks": "@/hooks" + } +} diff --git a/web/eslint.config.js b/web/eslint.config.js new file mode 100644 index 0000000..9940731 --- /dev/null +++ b/web/eslint.config.js @@ -0,0 +1,28 @@ +import js from "@eslint/js"; +import tseslint from "typescript-eslint"; +import hooks from "eslint-plugin-react-hooks"; +import globals from "globals"; + +export default tseslint.config( + { + ignores: ["dist", "node_modules", "playwright-report", "test-results"], + }, + { + languageOptions: { globals: { ...globals.browser, ...globals.node } }, + }, + js.configs.recommended, + ...tseslint.configs.recommended, + { + files: ["**/*.{ts,tsx}"], + languageOptions: { globals: { ...globals.browser, ...globals.node } }, + plugins: { "react-hooks": hooks }, + rules: { + "react-hooks/rules-of-hooks": "error", + "react-hooks/exhaustive-deps": "error", + "@typescript-eslint/no-unused-vars": [ + "error", + { argsIgnorePattern: "^_", varsIgnorePattern: "^_" }, + ], + }, + }, +); diff --git a/web/index.html b/web/index.html new file mode 100644 index 0000000..50c4b6f --- /dev/null +++ b/web/index.html @@ -0,0 +1,2 @@ + +Sparkplane
diff --git a/web/package-lock.json b/web/package-lock.json new file mode 100644 index 0000000..745643f --- /dev/null +++ b/web/package-lock.json @@ -0,0 +1,5924 @@ +{ + "name": "sparkplane-panel", + "version": "0.1.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "sparkplane-panel", + "version": "0.1.0", + "dependencies": { + "class-variance-authority": "0.7.1", + "clsx": "2.1.1", + "lucide-react": "1.49.0", + "next-themes": "0.4.6", + "radix-ui": "1.6.7", + "react": "19.3.0", + "react-dom": "19.3.0", + "recharts": "3.10.1", + "sonner": "2.0.8", + "tailwind-merge": "3.7.0" + }, + "devDependencies": { + "@eslint/js": "10.0.1", + "@playwright/test": "1.63.0", + "@tailwindcss/vite": "4.3.3", + "@types/node": "26.6.3", + "@types/react": "19.3.0", + "@types/react-dom": "19.3.0", + "@vitejs/plugin-react": "6.1.1", + "eslint": "10.11.0", + "eslint-plugin-react-hooks": "7.1.1", + "eslint-plugin-react-refresh": "0.5.7", + "globals": "17.12.0", + "prettier": "3.9.9", + "tailwindcss": "4.3.3", + "tw-animate-css": "1.4.0", + "typescript": "6.0.3", + "typescript-eslint": "8.71.0", + "vite": "8.3.1", + "vitest": "5.0.3" + } + }, + "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", + "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/compat-data": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.29.7.tgz", + "integrity": "sha512-locTkQyKvwIEgBzVrn8693ebc97F2U8ZHjbXwDXJ5Fn2TCpNwTlKcaKLkdHop5c/icOFE7qt7Q9JC5hnKNa6Gg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/core": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.29.7.tgz", + "integrity": "sha512-RgHBCvtjbOK2gXSNBNIkNoEc9qoVEtau3hj8gEqKQuL3HZAibKarWFEI3Lfm6EYKkLalOh8eSrj9b+ch9H/VBA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.29.7", + "@babel/generator": "^7.29.7", + "@babel/helper-compilation-targets": "^7.29.7", + "@babel/helper-module-transforms": "^7.29.7", + "@babel/helpers": "^7.29.7", + "@babel/parser": "^7.29.7", + "@babel/template": "^7.29.7", + "@babel/traverse": "^7.29.7", + "@babel/types": "^7.29.7", + "@jridgewell/remapping": "^2.3.5", + "convert-source-map": "^2.0.0", + "debug": "^4.1.0", + "gensync": "^1.0.0-beta.2", + "json5": "^2.2.3", + "semver": "^6.3.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/babel" + } + }, + "node_modules/@babel/generator": { + "version": "7.29.8", + "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.29.8.tgz", + "integrity": "sha512-gZbepsdh3WDtgZKWL+vTPh71LSBrm/Y4/QDZBVCcYfmeTEEuoOYwlSy+G1StfJg+/Zy550u/3TATbm7qDbbMtg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.29.8", + "@babel/types": "^7.29.8", + "@jridgewell/gen-mapping": "^0.3.12", + "@jridgewell/trace-mapping": "^0.3.28", + "jsesc": "^3.0.2" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-compilation-targets": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.29.7.tgz", + "integrity": "sha512-wem6WaBj4NaVYVdNhLPPVacES6ZJ+KBBfSkTMD3YZxbP3rm3Di85tJU5ljaUNhaOynt+Aj0xruhYuzQBt8n71g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/compat-data": "^7.29.7", + "@babel/helper-validator-option": "^7.29.7", + "browserslist": "^4.24.0", + "lru-cache": "^5.1.1", + "semver": "^6.3.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-globals": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.29.7.tgz", + "integrity": "sha512-3nQVUAtvkKH9zahfWgw96Jc/uFOmjACE1kQz82E2lqWmHBgjzbNlsC22nuQTfahmWeQtTq5nQ/4Nnd2A1wj4zA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-module-imports": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.29.7.tgz", + "integrity": "sha512-ejHwrQQYcm9xnTivShn2IDOlIzInN34AXskvq9QicvCtEzq1Vzclu/tKF8Jq1Cg8JG2GL6/EmjgsCT7lXepE3g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/traverse": "^7.29.7", + "@babel/types": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-module-transforms": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.29.7.tgz", + "integrity": "sha512-UPUVSyXbOh627KiCIGQSgwWzGeBKLkaJ9PJEdrngIwMSzxLR4jS4+f1f1jb7VzBbg8nFLaYotvVPFCTqdrmTAg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-module-imports": "^7.29.7", + "@babel/helper-validator-identifier": "^7.29.7", + "@babel/traverse": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.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/helper-validator-option": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.29.7.tgz", + "integrity": "sha512-N9ZErrD+yW5geCDtBqnOoxmR8+tNKiGuxKlDpuJxfsqpa2dFcexaziGAE/qoHLiDDreVNMupxGmSoNlyvsA3gw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helpers": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.29.7.tgz", + "integrity": "sha512-1k2lAGRMfHTcwuNYcCNUmaUffmQv8KWMfh2iJUUeRlwlwH4FdNG7mfPI10NPfLHJFThE4Tyr4mv7kTNZOiPuBg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/template": "^7.29.7", + "@babel/types": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/parser": { + "version": "7.29.9", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.9.tgz", + "integrity": "sha512-CjXrNHTnvqBVqHgdBysY3vk2T8tpJHb5/RMeHJBTyVa9xgugCB0CJTx/3oO8RV2QRQP391RWpB7D6hLjm8V9uA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.29.8" + }, + "bin": { + "parser": "bin/babel-parser.js" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@babel/template": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.29.7.tgz", + "integrity": "sha512-puq+Gf35oI24FeN11LkoUQFqv9uwNeWpxXZi/Ji3rRIoKAzKnxRaZ+Gkj0vKS9ZCiTESfng1N9LyOyXvo+m+Gg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.29.7", + "@babel/parser": "^7.29.7", + "@babel/types": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/traverse": { + "version": "7.29.8", + "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.8.tgz", + "integrity": "sha512-I5z7H3bf/41ktsNVLtpN0wAa336HkqIHQ5BuPLEhTkt1jVSyZpeNKIzTgEWmlxjdg81R0IgUCcaE+Ok3NvrfZg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.29.7", + "@babel/generator": "^7.29.8", + "@babel/helper-globals": "^7.29.7", + "@babel/parser": "^7.29.8", + "@babel/template": "^7.29.7", + "@babel/types": "^7.29.8", + "debug": "^4.3.1" + }, + "engines": { + "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/@cacheable/memory": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/@cacheable/memory/-/memory-2.2.0.tgz", + "integrity": "sha512-CTLKqLItRCEixEAewD3/j9DB3/o96gpTPD4eJ1v+DGOlxZRZncRQkGYqqnAGCscYd6RNeXfGeiuCphsPtqyIfQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@cacheable/utils": "^2.5.0", + "@keyv/bigmap": "^1.3.1", + "hookified": "^1.15.1", + "keyv": "^5.6.0" + } + }, + "node_modules/@cacheable/utils": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/@cacheable/utils/-/utils-2.5.0.tgz", + "integrity": "sha512-buipgOVDkkPXNR5+xBpDw7Zk2n1EvU7qBJCNUcL7rhQ//kfpOXPAvQ511Os0vpLYJ1pZnvudNytkQt2hst3wqA==", + "dev": true, + "license": "MIT", + "dependencies": { + "hashery": "^1.5.1", + "keyv": "^5.6.0" + } + }, + "node_modules/@eslint-community/eslint-utils": { + "version": "4.10.1", + "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.10.1.tgz", + "integrity": "sha512-cuadcxVFE8sDK6iWJbs8Sn0av2Nrh2QSGQhVlBW9AaAHqHwjWsZHT8LJ4hFGPh7ASBV2deFdM7H/DPjulmh8rg==", + "dev": true, + "license": "MIT", + "dependencies": { + "eslint-visitor-keys": "^3.4.3" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + }, + "peerDependencies": { + "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0" + } + }, + "node_modules/@eslint-community/eslint-utils/node_modules/eslint-visitor-keys": { + "version": "3.4.3", + "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz", + "integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/@eslint-community/regexpp": { + "version": "4.12.2", + "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.12.2.tgz", + "integrity": "sha512-EriSTlt5OC9/7SXkRSCAhfSxxoSUgBm33OH+IkwbdpgoqsSsUg7y3uh+IICI/Qg4BBWr3U2i39RpmycbxMq4ew==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^12.0.0 || ^14.0.0 || >=16.0.0" + } + }, + "node_modules/@eslint/config-array": { + "version": "0.23.5", + "resolved": "https://registry.npmjs.org/@eslint/config-array/-/config-array-0.23.5.tgz", + "integrity": "sha512-Y3kKLvC1dvTOT+oGlqNQ1XLqK6D1HU2YXPc52NmAlJZbMMWDzGYXMiPRJ8TYD39muD/OTjlZmNJ4ib7dvSrMBA==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@eslint/object-schema": "^3.0.5", + "debug": "^4.3.1", + "minimatch": "^10.2.4" + }, + "engines": { + "node": "^20.19.0 || ^22.13.0 || >=24" + } + }, + "node_modules/@eslint/config-helpers": { + "version": "0.7.0", + "resolved": "https://registry.npmjs.org/@eslint/config-helpers/-/config-helpers-0.7.0.tgz", + "integrity": "sha512-DObd/KKUsU+FaFv4PLxSRenpXfQWmPXXP3pPZ6/K1PCrMu2vQpMDMuQe/BqYeoLcz8ro0bVDF1RxOJgfVEdhUw==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@eslint/core": "^1.2.1" + }, + "engines": { + "node": "^20.19.0 || ^22.13.0 || >=24" + } + }, + "node_modules/@eslint/core": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/@eslint/core/-/core-1.2.1.tgz", + "integrity": "sha512-MwcE1P+AZ4C6DWlpin/OmOA54mmIZ/+xZuJiQd4SyB29oAJjN30UW9wkKNptW2ctp4cEsvhlLY/CsQ1uoHDloQ==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@types/json-schema": "^7.0.15" + }, + "engines": { + "node": "^20.19.0 || ^22.13.0 || >=24" + } + }, + "node_modules/@eslint/js": { + "version": "10.0.1", + "resolved": "https://registry.npmjs.org/@eslint/js/-/js-10.0.1.tgz", + "integrity": "sha512-zeR9k5pd4gxjZ0abRoIaxdc7I3nDktoXZk2qOv9gCNWx3mVwEn32VRhyLaRsDiJjTs0xq/T8mfPtyuXu7GWBcA==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^20.19.0 || ^22.13.0 || >=24" + }, + "funding": { + "url": "https://eslint.org/donate" + }, + "peerDependencies": { + "eslint": "^10.0.0" + }, + "peerDependenciesMeta": { + "eslint": { + "optional": true + } + } + }, + "node_modules/@eslint/object-schema": { + "version": "3.0.5", + "resolved": "https://registry.npmjs.org/@eslint/object-schema/-/object-schema-3.0.5.tgz", + "integrity": "sha512-vqTaUEgxzm+YDSdElad6PiRoX4t8VGDjCtt05zn4nU810UIx/uNEV7/lZJ6KwFThKZOzOxzXy48da+No7HZaMw==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": "^20.19.0 || ^22.13.0 || >=24" + } + }, + "node_modules/@eslint/plugin-kit": { + "version": "0.7.3", + "resolved": "https://registry.npmjs.org/@eslint/plugin-kit/-/plugin-kit-0.7.3.tgz", + "integrity": "sha512-IkO+/KEUvwbVpiURZg+P7zF74z5Jxe0UgJxVni+RtoHQ6IZieXaO02kmadomap/q+l6bc/jdPGGqTjhuZnuz1Q==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@eslint/core": "^1.2.1", + "levn": "^0.4.1" + }, + "engines": { + "node": "^20.19.0 || ^22.13.0 || >=24" + } + }, + "node_modules/@floating-ui/core": { + "version": "1.8.0", + "resolved": "https://registry.npmjs.org/@floating-ui/core/-/core-1.8.0.tgz", + "integrity": "sha512-0CIZ5itps/8x7BG8dEIhs53BvCUH2PCoogtakwRTut+Arm58sJooJ0AuZhLw2HJYIR5cMLNPBSS728sPho2khQ==", + "license": "MIT", + "dependencies": { + "@floating-ui/utils": "^0.2.12" + } + }, + "node_modules/@floating-ui/dom": { + "version": "1.8.0", + "resolved": "https://registry.npmjs.org/@floating-ui/dom/-/dom-1.8.0.tgz", + "integrity": "sha512-yXSrzeHZBTZadLOlfyhCkJHNeLJnHRnRInwdZ40L7ZiaAtrBwoYlsDrX3v5zB1Utk7CLfzcOVnVVWoXEky7Ceg==", + "license": "MIT", + "dependencies": { + "@floating-ui/core": "^1.8.0", + "@floating-ui/utils": "^0.2.12" + } + }, + "node_modules/@floating-ui/react-dom": { + "version": "2.1.9", + "resolved": "https://registry.npmjs.org/@floating-ui/react-dom/-/react-dom-2.1.9.tgz", + "integrity": "sha512-JDjEFGCpImxDCA7JJKviA0M9+RtmJdj0m/NVU5IMgBK+AmZouAQQ7/+2GLH0GXXY0YMw9oXPB8hKdbPYg5QLYg==", + "license": "MIT", + "dependencies": { + "@floating-ui/dom": "^1.8.0" + }, + "peerDependencies": { + "react": ">=16.8.0", + "react-dom": ">=16.8.0" + } + }, + "node_modules/@floating-ui/utils": { + "version": "0.2.12", + "resolved": "https://registry.npmjs.org/@floating-ui/utils/-/utils-0.2.12.tgz", + "integrity": "sha512-HpCo8tmWzLVad5s2d19EhAz5zqrrQ6s69qd6moPMQvkOuSwDT1YgRfWSVuc4ennqrgv3OHppiOGMQ7oC13yIww==", + "license": "MIT" + }, + "node_modules/@humanfs/core": { + "version": "0.19.2", + "resolved": "https://registry.npmjs.org/@humanfs/core/-/core-0.19.2.tgz", + "integrity": "sha512-UhXNm+CFMWcbChXywFwkmhqjs3PRCmcSa/hfBgLIb7oQ5HNb1wS0icWsGtSAUNgefHeI+eBrA8I1fxmbHsGdvA==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@humanfs/types": "^0.15.0" + }, + "engines": { + "node": ">=18.18.0" + } + }, + "node_modules/@humanfs/node": { + "version": "0.16.8", + "resolved": "https://registry.npmjs.org/@humanfs/node/-/node-0.16.8.tgz", + "integrity": "sha512-gE1eQNZ3R++kTzFUpdGlpmy8kDZD/MLyHqDwqjkVQI0JMdI1D51sy1H958PNXYkM2rAac7e5/CnIKZrHtPh3BQ==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@humanfs/core": "^0.19.2", + "@humanfs/types": "^0.15.0", + "@humanwhocodes/retry": "^0.4.0" + }, + "engines": { + "node": ">=18.18.0" + } + }, + "node_modules/@humanfs/types": { + "version": "0.15.0", + "resolved": "https://registry.npmjs.org/@humanfs/types/-/types-0.15.0.tgz", + "integrity": "sha512-ZZ1w0aoQkwuUuC7Yf+7sdeaNfqQiiLcSRbfI08oAxqLtpXQr9AIVX7Ay7HLDuiLYAaFPu8oBYNq/QIi9URHJ3Q==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=18.18.0" + } + }, + "node_modules/@humanwhocodes/module-importer": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz", + "integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=12.22" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/nzakas" + } + }, + "node_modules/@humanwhocodes/retry": { + "version": "0.4.3", + "resolved": "https://registry.npmjs.org/@humanwhocodes/retry/-/retry-0.4.3.tgz", + "integrity": "sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=18.18" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/nzakas" + } + }, + "node_modules/@jridgewell/gen-mapping": { + "version": "0.3.13", + "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz", + "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/sourcemap-codec": "^1.5.0", + "@jridgewell/trace-mapping": "^0.3.24" + } + }, + "node_modules/@jridgewell/remapping": { + "version": "2.3.5", + "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz", + "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/gen-mapping": "^0.3.5", + "@jridgewell/trace-mapping": "^0.3.24" + } + }, + "node_modules/@jridgewell/resolve-uri": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz", + "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/sourcemap-codec": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.6.0.tgz", + "integrity": "sha512-T7jf+5zgsZHwNJ4lvQ7/aezbyk0nNX+zJVWpmHA7VYsEx7a7qr5Rg5IbtJFqkgze5Y2sruq1RUY8Q837Od7iFw==", + "dev": true, + "license": "MIT" + }, + "node_modules/@jridgewell/trace-mapping": { + "version": "0.3.31", + "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz", + "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/resolve-uri": "^3.1.0", + "@jridgewell/sourcemap-codec": "^1.4.14" + } + }, + "node_modules/@keyv/bigmap": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/@keyv/bigmap/-/bigmap-1.3.1.tgz", + "integrity": "sha512-WbzE9sdmQtKy8vrNPa9BRnwZh5UF4s1KTmSK0KUVLo3eff5BlQNNWDnFOouNpKfPKDnms9xynJjsMYjMaT/aFQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "hashery": "^1.4.0", + "hookified": "^1.15.0" + }, + "engines": { + "node": ">= 18" + }, + "peerDependencies": { + "keyv": "^5.6.0" + } + }, + "node_modules/@keyv/serialize": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/@keyv/serialize/-/serialize-1.1.1.tgz", + "integrity": "sha512-dXn3FZhPv0US+7dtJsIi2R+c7qWYiReoEh5zUntWCf4oSpMNib8FDhSoed6m3QyZdx5hK7iLFkYk3rNxwt8vTA==", + "dev": true, + "license": "MIT" + }, + "node_modules/@oxc-project/types": { + "version": "0.152.0", + "resolved": "https://registry.npmjs.org/@oxc-project/types/-/types-0.152.0.tgz", + "integrity": "sha512-oM/5rLBm2tPkg0iBgkH/FOeR3PCDpY19GTgAZjMFM8h9WI9VW7cLgzp6nwtarYKmovavIQZ+Fe/RKX/8C8O/Rw==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/oxc-project" + } + }, + "node_modules/@playwright/test": { + "version": "1.63.0", + "resolved": "https://registry.npmjs.org/@playwright/test/-/test-1.63.0.tgz", + "integrity": "sha512-oxMK4vllB9RK5NQ2l1pq1IfOf2AvnEuj/vYGDj0H2nMtmtZpKtCwt/l00GEO6xjGfpBNAvjovvYdCm50dRQkpQ==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "playwright": "1.63.0" + }, + "bin": { + "playwright": "cli.js" + }, + "engines": { + "node": ">=20" + } + }, + "node_modules/@radix-ui/number": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/@radix-ui/number/-/number-1.1.3.tgz", + "integrity": "sha512-Road2bidD0uu/1BGDOWNdPI06g0lIRy6IF9GZcIrDK2KGItfor8IQwQa+yM2ERgHM1MmHxaxpTzk0/Jp42lNfA==", + "license": "MIT" + }, + "node_modules/@radix-ui/primitive": { + "version": "1.1.7", + "resolved": "https://registry.npmjs.org/@radix-ui/primitive/-/primitive-1.1.7.tgz", + "integrity": "sha512-rqWnm76nYT8HoNNqEjpgJ7Pw/DrBj5iBTrmEPo6HTX5+VJyBNOqTdv4g89G63HuR5g0AaENoAcH7Is5fF2kZ8Q==", + "license": "MIT" + }, + "node_modules/@radix-ui/react-accessible-icon": { + "version": "1.1.15", + "resolved": "https://registry.npmjs.org/@radix-ui/react-accessible-icon/-/react-accessible-icon-1.1.15.tgz", + "integrity": "sha512-WTQwcAvQf5sOcuUyi90lKPbhwcvQ+j55cjrSmeaN+L2vKU3DooOvlKw2MDeiJ5IkV5N905KW0/fGojKOBhD11A==", + "license": "MIT", + "dependencies": { + "@radix-ui/react-visually-hidden": "1.2.11" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-accordion": { + "version": "1.2.20", + "resolved": "https://registry.npmjs.org/@radix-ui/react-accordion/-/react-accordion-1.2.20.tgz", + "integrity": "sha512-jDhG9FvAEnlhnjrsINbNXcUa4G+L1KqSkJSunkbKEzFRcAb52jvM0PjPxPRvhe1HNc5F5yc0yzzWeeqlH4yBIg==", + "license": "MIT", + "dependencies": { + "@radix-ui/primitive": "1.1.7", + "@radix-ui/react-collapsible": "1.1.20", + "@radix-ui/react-collection": "1.1.15", + "@radix-ui/react-compose-refs": "1.1.5", + "@radix-ui/react-context": "1.2.2", + "@radix-ui/react-direction": "1.1.4", + "@radix-ui/react-id": "1.1.4", + "@radix-ui/react-primitive": "2.1.10", + "@radix-ui/react-use-controllable-state": "1.2.6" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-alert-dialog": { + "version": "1.1.23", + "resolved": "https://registry.npmjs.org/@radix-ui/react-alert-dialog/-/react-alert-dialog-1.1.23.tgz", + "integrity": "sha512-VAYOiQRqj3GPpYJE0I9J+X8Ip05cyVlNdKOFeiGS2Ou1HHGfpl0BxOyZm6nmVDyU+W+NF3/XLzmjHmVGydhwgA==", + "license": "MIT", + "dependencies": { + "@radix-ui/primitive": "1.1.7", + "@radix-ui/react-compose-refs": "1.1.5", + "@radix-ui/react-context": "1.2.2", + "@radix-ui/react-dialog": "1.1.23", + "@radix-ui/react-primitive": "2.1.10" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-arrow": { + "version": "1.1.15", + "resolved": "https://registry.npmjs.org/@radix-ui/react-arrow/-/react-arrow-1.1.15.tgz", + "integrity": "sha512-v4zggRcjadnI+ClKDuijlQEW4tw3NoaeHc/PwpKnLoLLKNUG4InLegkstooLcRIUWCs+8L22dGURCVuFfOKfnA==", + "license": "MIT", + "dependencies": { + "@radix-ui/react-primitive": "2.1.10" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-aspect-ratio": { + "version": "1.1.15", + "resolved": "https://registry.npmjs.org/@radix-ui/react-aspect-ratio/-/react-aspect-ratio-1.1.15.tgz", + "integrity": "sha512-fy+dyVR+90nelK8rqIznFlxzx7uPcGbhxH8Nfr2bHb4UfSe+e3hklOC0luK0hDwVwnRX7xTRySpsrQVeW+/oNQ==", + "license": "MIT", + "dependencies": { + "@radix-ui/react-primitive": "2.1.10" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-avatar": { + "version": "1.2.6", + "resolved": "https://registry.npmjs.org/@radix-ui/react-avatar/-/react-avatar-1.2.6.tgz", + "integrity": "sha512-4ULOTJ/mqy2hT9GlWa/MFHxHSvH3nJzHnZM1waNsc5Bonv7i70aNenghXmD97S6OJ81ekXONGGt4nT1r0PfEdA==", + "license": "MIT", + "dependencies": { + "@radix-ui/primitive": "1.1.7", + "@radix-ui/react-context": "1.2.2", + "@radix-ui/react-primitive": "2.1.10", + "@radix-ui/react-use-callback-ref": "1.1.4", + "@radix-ui/react-use-is-hydrated": "0.1.3", + "@radix-ui/react-use-layout-effect": "1.1.4" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-checkbox": { + "version": "1.3.11", + "resolved": "https://registry.npmjs.org/@radix-ui/react-checkbox/-/react-checkbox-1.3.11.tgz", + "integrity": "sha512-Gnptr9pDDQxD3hgq2dtPbtrp/c2qH1mBwIzw3X/ivrMb2e1t0jMTi606fVEqFPaQR1ggXIVQWKj3P2WW9v7zGQ==", + "license": "MIT", + "dependencies": { + "@radix-ui/primitive": "1.1.7", + "@radix-ui/react-compose-refs": "1.1.5", + "@radix-ui/react-context": "1.2.2", + "@radix-ui/react-presence": "1.1.10", + "@radix-ui/react-primitive": "2.1.10", + "@radix-ui/react-use-controllable-state": "1.2.6", + "@radix-ui/react-use-size": "1.1.4" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-collapsible": { + "version": "1.1.20", + "resolved": "https://registry.npmjs.org/@radix-ui/react-collapsible/-/react-collapsible-1.1.20.tgz", + "integrity": "sha512-mcGesGplBnzN2sbvJETzpCNfSMyPnb29q1GRLU+Ib7bJrpIG2ywmRoh2V5VbA2uNvKikKUlVbAPks7JDjz4A8Q==", + "license": "MIT", + "dependencies": { + "@radix-ui/primitive": "1.1.7", + "@radix-ui/react-compose-refs": "1.1.5", + "@radix-ui/react-context": "1.2.2", + "@radix-ui/react-id": "1.1.4", + "@radix-ui/react-presence": "1.1.10", + "@radix-ui/react-primitive": "2.1.10", + "@radix-ui/react-use-controllable-state": "1.2.6", + "@radix-ui/react-use-layout-effect": "1.1.4" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-collection": { + "version": "1.1.15", + "resolved": "https://registry.npmjs.org/@radix-ui/react-collection/-/react-collection-1.1.15.tgz", + "integrity": "sha512-9W+B9NPF0NaaPh/1NJd3+KqsnlLqU9H7T2rvww+fp+T/evVXdNAyYcnfRQZFOjkR1ajQp3yORlqnI8soawLvNA==", + "license": "MIT", + "dependencies": { + "@radix-ui/react-compose-refs": "1.1.5", + "@radix-ui/react-context": "1.2.2", + "@radix-ui/react-primitive": "2.1.10", + "@radix-ui/react-slot": "1.3.3" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-compose-refs": { + "version": "1.1.5", + "resolved": "https://registry.npmjs.org/@radix-ui/react-compose-refs/-/react-compose-refs-1.1.5.tgz", + "integrity": "sha512-+48PbAAbq3didjJxa+OaWY2ZwgAKsNiRGyeHKszblZMQ+kcpd9pAaT11cMkGEie0vsOi3QdeTE6d5Fe3Gn61kA==", + "license": "MIT", + "peerDependencies": { + "@types/react": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-context": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/@radix-ui/react-context/-/react-context-1.2.2.tgz", + "integrity": "sha512-RHCUGwKHDr0hDGg4X7ma4JG4/+12qxw8rkh5QKdDldlCvtja6nUx1Ef/8HVrJze81lEsgLQlqjzjGNHantgnQA==", + "license": "MIT", + "peerDependencies": { + "@types/react": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-context-menu": { + "version": "2.3.7", + "resolved": "https://registry.npmjs.org/@radix-ui/react-context-menu/-/react-context-menu-2.3.7.tgz", + "integrity": "sha512-CtXP35dxaB5T3zXSd+E3uHe/QpXcpYnZmxp6OaIbfthtfW4wyb77M23BG+bwIJDtsMwEP/YssdsmNyZu7jhWew==", + "license": "MIT", + "dependencies": { + "@radix-ui/primitive": "1.1.7", + "@radix-ui/react-context": "1.2.2", + "@radix-ui/react-menu": "2.1.24", + "@radix-ui/react-primitive": "2.1.10", + "@radix-ui/react-use-controllable-state": "1.2.6" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-dialog": { + "version": "1.1.23", + "resolved": "https://registry.npmjs.org/@radix-ui/react-dialog/-/react-dialog-1.1.23.tgz", + "integrity": "sha512-Ksw4WeROkO4rC9k/onilX/Ao2Cr1ku1unMNH+XSCcP4jSXYu7HDsg9n4ojMjVb22XpYjAQ9qfrFlVbru1vXDUA==", + "license": "MIT", + "dependencies": { + "@radix-ui/primitive": "1.1.7", + "@radix-ui/react-compose-refs": "1.1.5", + "@radix-ui/react-context": "1.2.2", + "@radix-ui/react-dismissable-layer": "1.1.19", + "@radix-ui/react-focus-guards": "1.1.6", + "@radix-ui/react-focus-scope": "1.1.16", + "@radix-ui/react-id": "1.1.4", + "@radix-ui/react-portal": "1.1.17", + "@radix-ui/react-presence": "1.1.10", + "@radix-ui/react-primitive": "2.1.10", + "@radix-ui/react-slot": "1.3.3", + "@radix-ui/react-use-controllable-state": "1.2.6", + "@radix-ui/react-use-layout-effect": "1.1.4", + "aria-hidden": "^1.2.4", + "react-remove-scroll": "^2.7.2" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-direction": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/@radix-ui/react-direction/-/react-direction-1.1.4.tgz", + "integrity": "sha512-5pzg4FGQNpExhnhT2zlrP1wZFaYCd1K0nYWoFAdcYoYK868IEigqMX3B3f8yIoRlAhAeDWciLI6ZdCKHF9P4Vg==", + "license": "MIT", + "peerDependencies": { + "@types/react": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-dismissable-layer": { + "version": "1.1.19", + "resolved": "https://registry.npmjs.org/@radix-ui/react-dismissable-layer/-/react-dismissable-layer-1.1.19.tgz", + "integrity": "sha512-8g4pfOL9HoKKLWGiypT+dphVqjFfmcXO5GBnhsG6zI+lxAx/8feQpr+1LSN8Re3hiZ+XkLNS4O9ztK11/LzQ6w==", + "license": "MIT", + "dependencies": { + "@radix-ui/primitive": "1.1.7", + "@radix-ui/react-compose-refs": "1.1.5", + "@radix-ui/react-primitive": "2.1.10", + "@radix-ui/react-use-callback-ref": "1.1.4", + "@radix-ui/react-use-effect-event": "0.0.5" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-dropdown-menu": { + "version": "2.1.24", + "resolved": "https://registry.npmjs.org/@radix-ui/react-dropdown-menu/-/react-dropdown-menu-2.1.24.tgz", + "integrity": "sha512-geq8l2rJkxvkXsT9RMgtUE3P8pITFpTsvYpbySi1IH4fZEABD/Gp85myayFgxk0ktljGMJnCbeFkyTusvSvv7g==", + "license": "MIT", + "dependencies": { + "@radix-ui/primitive": "1.1.7", + "@radix-ui/react-compose-refs": "1.1.5", + "@radix-ui/react-context": "1.2.2", + "@radix-ui/react-id": "1.1.4", + "@radix-ui/react-menu": "2.1.24", + "@radix-ui/react-primitive": "2.1.10", + "@radix-ui/react-use-controllable-state": "1.2.6" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-focus-guards": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/@radix-ui/react-focus-guards/-/react-focus-guards-1.1.6.tgz", + "integrity": "sha512-RNOJjfZMTyBM6xYmV3IVGXkPjIhcBAuv48POevAXwrGJhkWZ9p1rFoIS1JFooPuT193AZmRsCPhpoVJxx6OPoQ==", + "license": "MIT", + "peerDependencies": { + "@types/react": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-focus-scope": { + "version": "1.1.16", + "resolved": "https://registry.npmjs.org/@radix-ui/react-focus-scope/-/react-focus-scope-1.1.16.tgz", + "integrity": "sha512-wmRZ2WWLvmt6KHy2rNPOdPUjwq5xOHY02+m+udwJTn0aNIox/rkskAvJTyTLGhPK6KgrUjlJUJpgmx/+wFiFIQ==", + "license": "MIT", + "dependencies": { + "@radix-ui/react-compose-refs": "1.1.5", + "@radix-ui/react-primitive": "2.1.10", + "@radix-ui/react-use-callback-ref": "1.1.4" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-form": { + "version": "0.1.16", + "resolved": "https://registry.npmjs.org/@radix-ui/react-form/-/react-form-0.1.16.tgz", + "integrity": "sha512-Q4TLEn2A7TAypxwmd6R9EwrlXDvkfYSDMrq9/887AXAGh+G1rH+kYJKSTv+Si9Y0JPKTwKYv6PviAJosysNimA==", + "license": "MIT", + "dependencies": { + "@radix-ui/primitive": "1.1.7", + "@radix-ui/react-compose-refs": "1.1.5", + "@radix-ui/react-context": "1.2.2", + "@radix-ui/react-id": "1.1.4", + "@radix-ui/react-label": "2.1.15", + "@radix-ui/react-primitive": "2.1.10" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-hover-card": { + "version": "1.1.23", + "resolved": "https://registry.npmjs.org/@radix-ui/react-hover-card/-/react-hover-card-1.1.23.tgz", + "integrity": "sha512-H8qONfZd3ltrU3+jHCIgITbWo6e1iTKvP9DHdrvYbX48ooRM5FjEDTn16AMwdfuOGkWdZEhpl3PLL/Wk/AnHDQ==", + "license": "MIT", + "dependencies": { + "@radix-ui/primitive": "1.1.7", + "@radix-ui/react-compose-refs": "1.1.5", + "@radix-ui/react-context": "1.2.2", + "@radix-ui/react-dismissable-layer": "1.1.19", + "@radix-ui/react-popper": "1.3.7", + "@radix-ui/react-portal": "1.1.17", + "@radix-ui/react-presence": "1.1.10", + "@radix-ui/react-primitive": "2.1.10", + "@radix-ui/react-use-controllable-state": "1.2.6" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-id": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/@radix-ui/react-id/-/react-id-1.1.4.tgz", + "integrity": "sha512-TMQp2llA+RYn7JcjnrMnz7wN4pcVttPZnRZo52PLQsoLVKzNlVwUeHmfePgTgRluXFvlD3GD5g5MOVVTJCO0qA==", + "license": "MIT", + "dependencies": { + "@radix-ui/react-use-layout-effect": "1.1.4" + }, + "peerDependencies": { + "@types/react": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-label": { + "version": "2.1.15", + "resolved": "https://registry.npmjs.org/@radix-ui/react-label/-/react-label-2.1.15.tgz", + "integrity": "sha512-o/rdYEwZTTo5tjknnPeyQFU45kUC4i/XyeDPP+HGyi6XqpOP6Zf5Ya5vh/Yfe9Id5JiuWnnAx2XqIeD3UYZt0g==", + "license": "MIT", + "dependencies": { + "@radix-ui/react-primitive": "2.1.10" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-menu": { + "version": "2.1.24", + "resolved": "https://registry.npmjs.org/@radix-ui/react-menu/-/react-menu-2.1.24.tgz", + "integrity": "sha512-uW7RVuU6Lp/ZtfeY4b3kL32zccgEWvPv1+cf17ubYzHa9cL8AHokmk36cG/XEiH/smbQvumnieXX9j/e9RqJWA==", + "license": "MIT", + "dependencies": { + "@radix-ui/primitive": "1.1.7", + "@radix-ui/react-collection": "1.1.15", + "@radix-ui/react-compose-refs": "1.1.5", + "@radix-ui/react-context": "1.2.2", + "@radix-ui/react-direction": "1.1.4", + "@radix-ui/react-dismissable-layer": "1.1.19", + "@radix-ui/react-focus-guards": "1.1.6", + "@radix-ui/react-focus-scope": "1.1.16", + "@radix-ui/react-id": "1.1.4", + "@radix-ui/react-popper": "1.3.7", + "@radix-ui/react-portal": "1.1.17", + "@radix-ui/react-presence": "1.1.10", + "@radix-ui/react-primitive": "2.1.10", + "@radix-ui/react-roving-focus": "1.1.19", + "@radix-ui/react-slot": "1.3.3", + "@radix-ui/react-use-callback-ref": "1.1.4", + "aria-hidden": "^1.2.4", + "react-remove-scroll": "^2.7.2" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-menubar": { + "version": "1.1.24", + "resolved": "https://registry.npmjs.org/@radix-ui/react-menubar/-/react-menubar-1.1.24.tgz", + "integrity": "sha512-eeVs0vf7cuqXaM0qLQCPcufImiJNVBXdJDLu7ZGYl2732UH23Qat/foNGrr6vYV3/DdTsBqASoggUFgH14OcZA==", + "license": "MIT", + "dependencies": { + "@radix-ui/primitive": "1.1.7", + "@radix-ui/react-collection": "1.1.15", + "@radix-ui/react-compose-refs": "1.1.5", + "@radix-ui/react-context": "1.2.2", + "@radix-ui/react-direction": "1.1.4", + "@radix-ui/react-id": "1.1.4", + "@radix-ui/react-menu": "2.1.24", + "@radix-ui/react-primitive": "2.1.10", + "@radix-ui/react-roving-focus": "1.1.19", + "@radix-ui/react-use-controllable-state": "1.2.6" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-navigation-menu": { + "version": "1.2.22", + "resolved": "https://registry.npmjs.org/@radix-ui/react-navigation-menu/-/react-navigation-menu-1.2.22.tgz", + "integrity": "sha512-ou7iLEJ+yrhQndkkA4U21XIdS/CS45F4iXIkTZcb6/Ne9EMsOuDudVmCwmDnfFZZ+y1FZqXRNSIgBy+YMvZVZg==", + "license": "MIT", + "dependencies": { + "@radix-ui/primitive": "1.1.7", + "@radix-ui/react-collection": "1.1.15", + "@radix-ui/react-compose-refs": "1.1.5", + "@radix-ui/react-context": "1.2.2", + "@radix-ui/react-direction": "1.1.4", + "@radix-ui/react-dismissable-layer": "1.1.19", + "@radix-ui/react-id": "1.1.4", + "@radix-ui/react-presence": "1.1.10", + "@radix-ui/react-primitive": "2.1.10", + "@radix-ui/react-use-callback-ref": "1.1.4", + "@radix-ui/react-use-controllable-state": "1.2.6", + "@radix-ui/react-use-layout-effect": "1.1.4", + "@radix-ui/react-use-previous": "1.1.4", + "@radix-ui/react-visually-hidden": "1.2.11" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-one-time-password-field": { + "version": "0.1.16", + "resolved": "https://registry.npmjs.org/@radix-ui/react-one-time-password-field/-/react-one-time-password-field-0.1.16.tgz", + "integrity": "sha512-Tj9P6ntAJEw52oq/F0AGknXR4XncxEt7XU47O3xJQOiWfLzEy3d9gtgKfvjSzGxzHkfL+VzvxGu2KTFsloJqXw==", + "license": "MIT", + "dependencies": { + "@radix-ui/number": "1.1.3", + "@radix-ui/primitive": "1.1.7", + "@radix-ui/react-collection": "1.1.15", + "@radix-ui/react-compose-refs": "1.1.5", + "@radix-ui/react-context": "1.2.2", + "@radix-ui/react-direction": "1.1.4", + "@radix-ui/react-primitive": "2.1.10", + "@radix-ui/react-roving-focus": "1.1.19", + "@radix-ui/react-use-controllable-state": "1.2.6", + "@radix-ui/react-use-effect-event": "0.0.5", + "@radix-ui/react-use-is-hydrated": "0.1.3", + "@radix-ui/react-use-layout-effect": "1.1.4" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-password-toggle-field": { + "version": "0.1.11", + "resolved": "https://registry.npmjs.org/@radix-ui/react-password-toggle-field/-/react-password-toggle-field-0.1.11.tgz", + "integrity": "sha512-4gvFnmDXu3dgj21CqsufzIameRvlRd4SBqaWhcrlrNhRo0Y5i/49AmRJYe1fdAM3G2VNBbmin4b0D6cdQocwgw==", + "license": "MIT", + "dependencies": { + "@radix-ui/primitive": "1.1.7", + "@radix-ui/react-compose-refs": "1.1.5", + "@radix-ui/react-context": "1.2.2", + "@radix-ui/react-id": "1.1.4", + "@radix-ui/react-primitive": "2.1.10", + "@radix-ui/react-use-controllable-state": "1.2.6", + "@radix-ui/react-use-effect-event": "0.0.5", + "@radix-ui/react-use-is-hydrated": "0.1.3" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-popover": { + "version": "1.1.23", + "resolved": "https://registry.npmjs.org/@radix-ui/react-popover/-/react-popover-1.1.23.tgz", + "integrity": "sha512-mw58MrBlyHWFisTOYignD0vf/3gdcgAR+9of1s9G/38CbFiUwH1nCDkc0AUM9IrXFgN5Ue8n45j9WCgyM1sbiQ==", + "license": "MIT", + "dependencies": { + "@radix-ui/primitive": "1.1.7", + "@radix-ui/react-compose-refs": "1.1.5", + "@radix-ui/react-context": "1.2.2", + "@radix-ui/react-dismissable-layer": "1.1.19", + "@radix-ui/react-focus-guards": "1.1.6", + "@radix-ui/react-focus-scope": "1.1.16", + "@radix-ui/react-id": "1.1.4", + "@radix-ui/react-popper": "1.3.7", + "@radix-ui/react-portal": "1.1.17", + "@radix-ui/react-presence": "1.1.10", + "@radix-ui/react-primitive": "2.1.10", + "@radix-ui/react-slot": "1.3.3", + "@radix-ui/react-use-controllable-state": "1.2.6", + "aria-hidden": "^1.2.4", + "react-remove-scroll": "^2.7.2" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-popper": { + "version": "1.3.7", + "resolved": "https://registry.npmjs.org/@radix-ui/react-popper/-/react-popper-1.3.7.tgz", + "integrity": "sha512-UsJrrd7w4wuKKTdvd/DNERVlwSlUcyXzjhyDwBk+3aPOsCjOY6ZSbxuw8E6lZTjjfP8Cpd0J8VVkrYUWyGYXyg==", + "license": "MIT", + "dependencies": { + "@floating-ui/react-dom": "^2.0.0", + "@radix-ui/react-arrow": "1.1.15", + "@radix-ui/react-compose-refs": "1.1.5", + "@radix-ui/react-context": "1.2.2", + "@radix-ui/react-primitive": "2.1.10", + "@radix-ui/react-use-callback-ref": "1.1.4", + "@radix-ui/react-use-layout-effect": "1.1.4", + "@radix-ui/react-use-rect": "1.1.4", + "@radix-ui/react-use-size": "1.1.4", + "@radix-ui/rect": "1.1.3" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-portal": { + "version": "1.1.17", + "resolved": "https://registry.npmjs.org/@radix-ui/react-portal/-/react-portal-1.1.17.tgz", + "integrity": "sha512-vKQLcWypUnwZVvfV7UkGahH2g6ySe8M8R+zYBwPrv5byZ9QAW6cQVvNKo7GgmD+p8aYb6D9JBuvy8/WhOno2wQ==", + "license": "MIT", + "dependencies": { + "@radix-ui/react-primitive": "2.1.10", + "@radix-ui/react-use-layout-effect": "1.1.4" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-presence": { + "version": "1.1.10", + "resolved": "https://registry.npmjs.org/@radix-ui/react-presence/-/react-presence-1.1.10.tgz", + "integrity": "sha512-3wyzCQ6+ubRA+D4uv9m95JYLXxmOHp05qjrkjeA7uKHHtjpPggQzc6DAb0URl7j67oR0K2foO4ip27TiX037Bw==", + "license": "MIT", + "dependencies": { + "@radix-ui/react-use-layout-effect": "1.1.4" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-primitive": { + "version": "2.1.10", + "resolved": "https://registry.npmjs.org/@radix-ui/react-primitive/-/react-primitive-2.1.10.tgz", + "integrity": "sha512-MucOnzh6hR5mid6VpkbglRAMYMjKLqRnGBbjXkzjK52fuQDd1qbkx78a5P40mkcnVXJdEVxm26E9OPAiUq7nBg==", + "license": "MIT", + "dependencies": { + "@radix-ui/react-slot": "1.3.3" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-progress": { + "version": "1.1.16", + "resolved": "https://registry.npmjs.org/@radix-ui/react-progress/-/react-progress-1.1.16.tgz", + "integrity": "sha512-5XnomAsoZZCY+KNTxbIghpGqPruZvKFNlvcAljVAOdDRDsH4/OZQxhtwo5wdtoDM5R6MhJBb2sPnDuRFep3lzg==", + "license": "MIT", + "dependencies": { + "@radix-ui/react-context": "1.2.2", + "@radix-ui/react-primitive": "2.1.10" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-radio-group": { + "version": "1.4.7", + "resolved": "https://registry.npmjs.org/@radix-ui/react-radio-group/-/react-radio-group-1.4.7.tgz", + "integrity": "sha512-cgYFEkntCxppHZgtSZ+7vh0wbZQ+IC7PPMw8DSnRG27B6kDd32/Zw0OJt7dGDigCoprMuWHjg2PvUn3PYvPFoQ==", + "license": "MIT", + "dependencies": { + "@radix-ui/primitive": "1.1.7", + "@radix-ui/react-compose-refs": "1.1.5", + "@radix-ui/react-context": "1.2.2", + "@radix-ui/react-direction": "1.1.4", + "@radix-ui/react-presence": "1.1.10", + "@radix-ui/react-primitive": "2.1.10", + "@radix-ui/react-roving-focus": "1.1.19", + "@radix-ui/react-use-controllable-state": "1.2.6", + "@radix-ui/react-use-size": "1.1.4" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-roving-focus": { + "version": "1.1.19", + "resolved": "https://registry.npmjs.org/@radix-ui/react-roving-focus/-/react-roving-focus-1.1.19.tgz", + "integrity": "sha512-V9jI6hDjT7l3jsCQD9bLNvDLM3tH/gdbOTp7Tefp3hbbgCGQoK7tUvrWiRlcoBHIZ809ElXwNQwVo0B98LuTXQ==", + "license": "MIT", + "dependencies": { + "@radix-ui/primitive": "1.1.7", + "@radix-ui/react-collection": "1.1.15", + "@radix-ui/react-compose-refs": "1.1.5", + "@radix-ui/react-context": "1.2.2", + "@radix-ui/react-direction": "1.1.4", + "@radix-ui/react-id": "1.1.4", + "@radix-ui/react-primitive": "2.1.10", + "@radix-ui/react-use-callback-ref": "1.1.4", + "@radix-ui/react-use-controllable-state": "1.2.6", + "@radix-ui/react-use-is-hydrated": "0.1.3", + "@radix-ui/react-use-layout-effect": "1.1.4" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-scroll-area": { + "version": "1.2.18", + "resolved": "https://registry.npmjs.org/@radix-ui/react-scroll-area/-/react-scroll-area-1.2.18.tgz", + "integrity": "sha512-Zn5Cd171wxsO3Dfg8HaW6RifTb9CYTKQJHs/G4+LN1GfmJpaQMZQyQxMprVPHpaz7QY4l9BxK2JwQuzHsXC8nA==", + "license": "MIT", + "dependencies": { + "@radix-ui/number": "1.1.3", + "@radix-ui/primitive": "1.1.7", + "@radix-ui/react-compose-refs": "1.1.5", + "@radix-ui/react-context": "1.2.2", + "@radix-ui/react-direction": "1.1.4", + "@radix-ui/react-presence": "1.1.10", + "@radix-ui/react-primitive": "2.1.10", + "@radix-ui/react-use-callback-ref": "1.1.4", + "@radix-ui/react-use-layout-effect": "1.1.4" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-select": { + "version": "2.3.7", + "resolved": "https://registry.npmjs.org/@radix-ui/react-select/-/react-select-2.3.7.tgz", + "integrity": "sha512-WFGImkmbzcfxeIwq/+4HvRN0pizBwbwQUED4I13ezQsDdfl38ZntN6TmR8XaSzPBqoCToe8rF75j6NPNDSzhbg==", + "license": "MIT", + "dependencies": { + "@radix-ui/number": "1.1.3", + "@radix-ui/primitive": "1.1.7", + "@radix-ui/react-collection": "1.1.15", + "@radix-ui/react-compose-refs": "1.1.5", + "@radix-ui/react-context": "1.2.2", + "@radix-ui/react-direction": "1.1.4", + "@radix-ui/react-dismissable-layer": "1.1.19", + "@radix-ui/react-focus-guards": "1.1.6", + "@radix-ui/react-focus-scope": "1.1.16", + "@radix-ui/react-id": "1.1.4", + "@radix-ui/react-popper": "1.3.7", + "@radix-ui/react-portal": "1.1.17", + "@radix-ui/react-presence": "1.1.10", + "@radix-ui/react-primitive": "2.1.10", + "@radix-ui/react-slot": "1.3.3", + "@radix-ui/react-use-callback-ref": "1.1.4", + "@radix-ui/react-use-controllable-state": "1.2.6", + "@radix-ui/react-use-layout-effect": "1.1.4", + "@radix-ui/react-use-previous": "1.1.4", + "@radix-ui/react-visually-hidden": "1.2.11", + "aria-hidden": "^1.2.4", + "react-remove-scroll": "^2.7.2" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-separator": { + "version": "1.1.15", + "resolved": "https://registry.npmjs.org/@radix-ui/react-separator/-/react-separator-1.1.15.tgz", + "integrity": "sha512-jOLO4lssEzWpoDu7G+Ze4VjwMRUBt291pnZD0gmalREZipnTX3wadQo7Fy48GCTfe14/YRN6rw/rOJqrE85Wxw==", + "license": "MIT", + "dependencies": { + "@radix-ui/react-primitive": "2.1.10" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-slider": { + "version": "1.4.7", + "resolved": "https://registry.npmjs.org/@radix-ui/react-slider/-/react-slider-1.4.7.tgz", + "integrity": "sha512-mTSLf1GC/C0moWjTbvCM6Qn/gBjvlFt1azuWF2v7MN5C3Zq2U2J2lN3ZEYkpujuOU5Ro7A28wkviSxaKnG0BYg==", + "license": "MIT", + "dependencies": { + "@radix-ui/number": "1.1.3", + "@radix-ui/primitive": "1.1.7", + "@radix-ui/react-collection": "1.1.15", + "@radix-ui/react-compose-refs": "1.1.5", + "@radix-ui/react-context": "1.2.2", + "@radix-ui/react-direction": "1.1.4", + "@radix-ui/react-primitive": "2.1.10", + "@radix-ui/react-use-controllable-state": "1.2.6", + "@radix-ui/react-use-layout-effect": "1.1.4", + "@radix-ui/react-use-previous": "1.1.4", + "@radix-ui/react-use-size": "1.1.4" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-slot": { + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/@radix-ui/react-slot/-/react-slot-1.3.3.tgz", + "integrity": "sha512-qx7oqnYbxnK9kYI9m317qmFmEgo6ywqWvbTogdj7cL9p3/yx4M48p7Rnw5z3H890cL/ow/EeWJsuTykeZVXP5Q==", + "license": "MIT", + "dependencies": { + "@radix-ui/react-compose-refs": "1.1.5" + }, + "peerDependencies": { + "@types/react": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-switch": { + "version": "1.3.7", + "resolved": "https://registry.npmjs.org/@radix-ui/react-switch/-/react-switch-1.3.7.tgz", + "integrity": "sha512-48tB/4dn2UVLBCYhTu9AuR63IHl73l/qLbLgxd86noTUor4/K4LFDAcYjK+isP5313qxaFpjPVogE7+Y0/V3Kw==", + "license": "MIT", + "dependencies": { + "@radix-ui/primitive": "1.1.7", + "@radix-ui/react-compose-refs": "1.1.5", + "@radix-ui/react-context": "1.2.2", + "@radix-ui/react-primitive": "2.1.10", + "@radix-ui/react-use-controllable-state": "1.2.6", + "@radix-ui/react-use-size": "1.1.4" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-tabs": { + "version": "1.1.21", + "resolved": "https://registry.npmjs.org/@radix-ui/react-tabs/-/react-tabs-1.1.21.tgz", + "integrity": "sha512-UKxJlZid7FVtsk/WTxj4i4uSEgj2Au+KBbS7SQyTlzMhhn+86Cz3tISZdTa87bfEfcuvZezf2ZsxD4xuEKtkog==", + "license": "MIT", + "dependencies": { + "@radix-ui/primitive": "1.1.7", + "@radix-ui/react-context": "1.2.2", + "@radix-ui/react-direction": "1.1.4", + "@radix-ui/react-id": "1.1.4", + "@radix-ui/react-presence": "1.1.10", + "@radix-ui/react-primitive": "2.1.10", + "@radix-ui/react-roving-focus": "1.1.19", + "@radix-ui/react-use-controllable-state": "1.2.6" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-toast": { + "version": "1.2.23", + "resolved": "https://registry.npmjs.org/@radix-ui/react-toast/-/react-toast-1.2.23.tgz", + "integrity": "sha512-ofhyAsYaocRGOs/n0XWdUOSVzEAG6BfrMVM8z0c0kLEWY38w/0WuMFPTJP/HVaZPYkMvHZoKIIhNcjbTCBILPg==", + "license": "MIT", + "dependencies": { + "@radix-ui/primitive": "1.1.7", + "@radix-ui/react-collection": "1.1.15", + "@radix-ui/react-compose-refs": "1.1.5", + "@radix-ui/react-context": "1.2.2", + "@radix-ui/react-dismissable-layer": "1.1.19", + "@radix-ui/react-portal": "1.1.17", + "@radix-ui/react-presence": "1.1.10", + "@radix-ui/react-primitive": "2.1.10", + "@radix-ui/react-use-callback-ref": "1.1.4", + "@radix-ui/react-use-controllable-state": "1.2.6", + "@radix-ui/react-use-layout-effect": "1.1.4", + "@radix-ui/react-visually-hidden": "1.2.11" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-toggle": { + "version": "1.1.18", + "resolved": "https://registry.npmjs.org/@radix-ui/react-toggle/-/react-toggle-1.1.18.tgz", + "integrity": "sha512-7lonPlKfSacd20GlOBx2ltuVKz9oqWYZz+oMQyOltw6t1y2nyftj2ZmwwUHYn49kqfDWcp8dNZm5NgV+5Z+mug==", + "license": "MIT", + "dependencies": { + "@radix-ui/primitive": "1.1.7", + "@radix-ui/react-primitive": "2.1.10", + "@radix-ui/react-use-controllable-state": "1.2.6" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-toggle-group": { + "version": "1.1.19", + "resolved": "https://registry.npmjs.org/@radix-ui/react-toggle-group/-/react-toggle-group-1.1.19.tgz", + "integrity": "sha512-OtnwuSVjd1Ofi+AdnvhsjQdyuhCDwYs1w9RyB5BN/OavXOVQo42SYqQjwUnbPnaiPFBpQ9aX70dWeee+v2oBLA==", + "license": "MIT", + "dependencies": { + "@radix-ui/primitive": "1.1.7", + "@radix-ui/react-context": "1.2.2", + "@radix-ui/react-direction": "1.1.4", + "@radix-ui/react-primitive": "2.1.10", + "@radix-ui/react-roving-focus": "1.1.19", + "@radix-ui/react-toggle": "1.1.18", + "@radix-ui/react-use-controllable-state": "1.2.6" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-toolbar": { + "version": "1.1.19", + "resolved": "https://registry.npmjs.org/@radix-ui/react-toolbar/-/react-toolbar-1.1.19.tgz", + "integrity": "sha512-Ph0IvtYw4VB12ZnZg+YtrGs8yJQsnizwo/zu0R4Y/nWugtJzA7Pg1eWeuDR9+LSqn+xjamss+UOSOJJJ4gx8jw==", + "license": "MIT", + "dependencies": { + "@radix-ui/primitive": "1.1.7", + "@radix-ui/react-context": "1.2.2", + "@radix-ui/react-direction": "1.1.4", + "@radix-ui/react-primitive": "2.1.10", + "@radix-ui/react-roving-focus": "1.1.19", + "@radix-ui/react-separator": "1.1.15", + "@radix-ui/react-toggle-group": "1.1.19" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-tooltip": { + "version": "1.2.16", + "resolved": "https://registry.npmjs.org/@radix-ui/react-tooltip/-/react-tooltip-1.2.16.tgz", + "integrity": "sha512-6EamKFRRnlpdadndbZ6LMwycfwkwPte1B42hs6QA0gYhjaOKqW4PZ4pjaW9UrlDX5eVt/OjncE7BFTPL5nmZhg==", + "license": "MIT", + "dependencies": { + "@radix-ui/primitive": "1.1.7", + "@radix-ui/react-compose-refs": "1.1.5", + "@radix-ui/react-context": "1.2.2", + "@radix-ui/react-dismissable-layer": "1.1.19", + "@radix-ui/react-id": "1.1.4", + "@radix-ui/react-popper": "1.3.7", + "@radix-ui/react-portal": "1.1.17", + "@radix-ui/react-presence": "1.1.10", + "@radix-ui/react-primitive": "2.1.10", + "@radix-ui/react-slot": "1.3.3", + "@radix-ui/react-use-controllable-state": "1.2.6", + "@radix-ui/react-use-layout-effect": "1.1.4", + "@radix-ui/react-visually-hidden": "1.2.11" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-use-callback-ref": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/@radix-ui/react-use-callback-ref/-/react-use-callback-ref-1.1.4.tgz", + "integrity": "sha512-R6OUY2e2fA6Yn6s+VSx5KBV6Nx8LQEhu+cz7LCej18rQ1HLyg9PSC9jP/ZNx0o6FAIK9c0F1kHylzSxKsdlkrQ==", + "license": "MIT", + "peerDependencies": { + "@types/react": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-use-controllable-state": { + "version": "1.2.6", + "resolved": "https://registry.npmjs.org/@radix-ui/react-use-controllable-state/-/react-use-controllable-state-1.2.6.tgz", + "integrity": "sha512-uEQJGT97ZA/TgP/Hydw47lHu+/vQj6z/0jA+WeTbK1o9Rx45GImjpD0tc3W5ad3D6XTSR6e1yEO0FvGq6WQfVQ==", + "license": "MIT", + "dependencies": { + "@radix-ui/primitive": "1.1.7", + "@radix-ui/react-use-effect-event": "0.0.5", + "@radix-ui/react-use-layout-effect": "1.1.4" + }, + "peerDependencies": { + "@types/react": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-use-effect-event": { + "version": "0.0.5", + "resolved": "https://registry.npmjs.org/@radix-ui/react-use-effect-event/-/react-use-effect-event-0.0.5.tgz", + "integrity": "sha512-7cshFL8HGS/7HEiHH+9kL9HBwp2sa9yX18Knwek6KYWmXwM7pegMgta2AXMQKI+rq3JnfSj9x8wYqFMTdG1Jgg==", + "license": "MIT", + "dependencies": { + "@radix-ui/react-use-layout-effect": "1.1.4" + }, + "peerDependencies": { + "@types/react": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-use-escape-keydown": { + "version": "1.1.5", + "resolved": "https://registry.npmjs.org/@radix-ui/react-use-escape-keydown/-/react-use-escape-keydown-1.1.5.tgz", + "integrity": "sha512-ge3ipobwSXTj4JyVtswQ7qZj0ZHdtbGuOno/LrgAAeSxtsJ6Vs4Gz5IkPH2bmqpjcLUFoqGhA/mueuIf63UXlA==", + "license": "MIT", + "dependencies": { + "@radix-ui/react-use-callback-ref": "1.1.4" + }, + "peerDependencies": { + "@types/react": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-use-is-hydrated": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/@radix-ui/react-use-is-hydrated/-/react-use-is-hydrated-0.1.3.tgz", + "integrity": "sha512-umO/aJ+82CpOnhDZUTbILCQf7kU/g0iv+oGs/Q8jw7IkhWBzaEP4sA268PhFAJTFetbwp3ICc6ktpI4TqtxcIw==", + "license": "MIT", + "peerDependencies": { + "@types/react": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-use-layout-effect": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/@radix-ui/react-use-layout-effect/-/react-use-layout-effect-1.1.4.tgz", + "integrity": "sha512-K20DkRkUwDnxEYMBPcg3Y6voLkEy5p5QQmszZgLngKKiC7dzBR/aEuK3w1qlx2JWDUNH6FluahYdgR3BP+QbYw==", + "license": "MIT", + "peerDependencies": { + "@types/react": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-use-previous": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/@radix-ui/react-use-previous/-/react-use-previous-1.1.4.tgz", + "integrity": "sha512-XoSLhbRbqxFtgJoi2fNHA3C6pDlY34x508vUpUGoFZfvePfHXHbE1lC4FYFMnJWgiCRroSTw6fOsXQoVS9RwZg==", + "license": "MIT", + "peerDependencies": { + "@types/react": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-use-rect": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/@radix-ui/react-use-rect/-/react-use-rect-1.1.4.tgz", + "integrity": "sha512-cSOCh6JlkmfjLyNcLiu2nB4v+nm+dkZ+Q5KHWk/soo4U7ZLiEQFKHK9/YmtBHjfCEaU43IBKQOc4/uJmCaiCTQ==", + "license": "MIT", + "dependencies": { + "@radix-ui/rect": "1.1.3" + }, + "peerDependencies": { + "@types/react": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-use-size": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/@radix-ui/react-use-size/-/react-use-size-1.1.4.tgz", + "integrity": "sha512-D3anSY15EJoxrihpsXI6SMrmmonnQtR2ni7arO+Lfdg3O95b9hNXxONk8jA5C8ANdF/h5HMAxejgs8PWJ6rlhw==", + "license": "MIT", + "dependencies": { + "@radix-ui/react-use-layout-effect": "1.1.4" + }, + "peerDependencies": { + "@types/react": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-visually-hidden": { + "version": "1.2.11", + "resolved": "https://registry.npmjs.org/@radix-ui/react-visually-hidden/-/react-visually-hidden-1.2.11.tgz", + "integrity": "sha512-NFS86RYYZb4/exihaESBGOpMJFz8MGLAfu3mOBSGByVnVPC9JPASfYubxd/8KbkQK0sYAv8lVQDEQukDX/qXvQ==", + "license": "MIT", + "dependencies": { + "@radix-ui/react-primitive": "2.1.10" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/rect": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/@radix-ui/rect/-/rect-1.1.3.tgz", + "integrity": "sha512-JtyZR+mqgBibTo8xea3B6ZRmzZiM/YeVBtUkas6zMuXjAlfIFIW2FgqeM9eLyvEaYX66vr6DJMK+4U6LV0KhNw==", + "license": "MIT" + }, + "node_modules/@reduxjs/toolkit": { + "version": "2.13.0", + "resolved": "https://registry.npmjs.org/@reduxjs/toolkit/-/toolkit-2.13.0.tgz", + "integrity": "sha512-f6jwVRfwW30+tnllz4YcsHHpPYYOE7abcHkyUCovD+P7DyhdAI5prz2Fh/8TLhakjpN+7aIEion1s5L/tvlYlA==", + "license": "MIT", + "dependencies": { + "@standard-schema/spec": "^1.0.0", + "@standard-schema/utils": "^0.3.0", + "immer": "^11.0.0", + "redux": "^5.0.1", + "redux-thunk": "^3.1.0", + "reselect": "^5.1.0" + }, + "peerDependencies": { + "react": "^16.9.0 || ^17.0.0 || ^18 || ^19", + "react-redux": "^7.2.1 || ^8.1.3 || ^9.0.0" + }, + "peerDependenciesMeta": { + "react": { + "optional": true + }, + "react-redux": { + "optional": true + } + } + }, + "node_modules/@rolldown/binding-android-arm-eabi": { + "version": "1.2.12", + "resolved": "https://registry.npmjs.org/@rolldown/binding-android-arm-eabi/-/binding-android-arm-eabi-1.2.12.tgz", + "integrity": "sha512-dB/a1214qKfHMXCpgqR4OZT+jS4kTyEXbQGJPqzobt5EwH5rX080pxE37alt3RzvR1bf1Yz/yGqRfrYAxuPw0A==", + "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.12", + "resolved": "https://registry.npmjs.org/@rolldown/binding-android-arm64/-/binding-android-arm64-1.2.12.tgz", + "integrity": "sha512-7KHFgQ5VJxIHcLlrwrc3Xbds7oTNQT7Pgi9gQCJKrd2VGab/UksIOYp6VD8MzCstGxOKMgNamPwUCfxPdP1OHg==", + "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.12", + "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-arm64/-/binding-darwin-arm64-1.2.12.tgz", + "integrity": "sha512-3YIhqHD96nA5SaYNRBR16HnGv4oavZvXfD/ayHM+oYZ0WD/8lBAtf6zQua4kEyAvpqrluKXl0lnOBoiNby7x9w==", + "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.12", + "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-x64/-/binding-darwin-x64-1.2.12.tgz", + "integrity": "sha512-UuuJ35MFw4gmFOrE9pEqIV+K3syIKveph+Qc1/ljHZVdoDW4pz/JHR/eMVom+TZGl/5OOvGJOWaOCVt3ZfqhxA==", + "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.12", + "resolved": "https://registry.npmjs.org/@rolldown/binding-freebsd-x64/-/binding-freebsd-x64-1.2.12.tgz", + "integrity": "sha512-uMvssit0a4W+/7D8CbHUvG719mH3R2jwXAlh/XcPvuHTE0g++LymF88DCGNX0HM2rBOn0xrzgXktIB6fLSJBTQ==", + "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.12", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm-gnueabihf/-/binding-linux-arm-gnueabihf-1.2.12.tgz", + "integrity": "sha512-XcFu0R0xWnwzSf4IQgFH1rJIckPN1pLy2R+4r9IDB7Yfu/ys9cVqfa4pBrMHj7a3gl8mIR4nRNPg0e5IvEVs6g==", + "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.12", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-gnu/-/binding-linux-arm64-gnu-1.2.12.tgz", + "integrity": "sha512-260UrKgn8tz39ak+SMDOirKzr7V04M9dWPw5llW00SwBivCZoWcRBKV1d8cXnRkUmSZA3BdiUmBHWk7734Ulpw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-linux-arm64-musl": { + "version": "1.2.12", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-musl/-/binding-linux-arm64-musl-1.2.12.tgz", + "integrity": "sha512-5YK1I9SqDkbPgc1IA8BgDl34suqUS2q0KWnBrirm0E51YjOs6eo6dV6jbQfNE/argHRSvd0QUGgtpIoYx+WWpw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-linux-ppc64-gnu": { + "version": "1.2.12", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-ppc64-gnu/-/binding-linux-ppc64-gnu-1.2.12.tgz", + "integrity": "sha512-Rkcrmp7eFRg74yL5fXEU91JEWbdEPLevWwGtXpmhbjlD1StScbWTmO94Bhly+Mo+ketKYkdmM1vNUKeWSlx8cQ==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-linux-s390x-gnu": { + "version": "1.2.12", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-s390x-gnu/-/binding-linux-s390x-gnu-1.2.12.tgz", + "integrity": "sha512-qvK4DuAsQc2BSjlx+Xr+IzOIvvxbGZqxFwdWfG6F518Erj0GGISyQbJ6pIappnOxlNPzNHvo/L0BwB30GZ+zVw==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-linux-x64-gnu": { + "version": "1.2.12", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-gnu/-/binding-linux-x64-gnu-1.2.12.tgz", + "integrity": "sha512-Q9uLBO53Xd4QIq1WOycVQyPP1O4HhraEV2qqb3uTrnVw6QZih9duY4vNXOivL1xoUS1/z+W8eF4NMfl2a8Sdjw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-linux-x64-musl": { + "version": "1.2.12", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-musl/-/binding-linux-x64-musl-1.2.12.tgz", + "integrity": "sha512-3IBxWFMjbOZskDPKv8Lf9BCnahlKuHthWkYnyIxOH/QcJrFcS4EmcenthApkwr/5+nEqZlLzeYbxeMaX7A5u4g==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-openharmony-arm64": { + "version": "1.2.12", + "resolved": "https://registry.npmjs.org/@rolldown/binding-openharmony-arm64/-/binding-openharmony-arm64-1.2.12.tgz", + "integrity": "sha512-xtX61xg4LKPkPWilZU1ynKClz5Gj4bf74LML4r3eVLWumKnGjoEr1OSHQhMdbBDoYTi+yjrujvpZe2pUnqCrrA==", + "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.12", + "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-arm64-msvc/-/binding-win32-arm64-msvc-1.2.12.tgz", + "integrity": "sha512-At7fPB6PCaIjzgIhEZFxuT+BBFqiQibJDT4d3PhiR3f4E7bbMZF4aKblbFfEM3sETRDd1YiQx/+U/g/B/ou5Ew==", + "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.12", + "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-x64-msvc/-/binding-win32-x64-msvc-1.2.12.tgz", + "integrity": "sha512-WIw2haVKwjuYdXkHaoC0mF8Le71TuCBxjrdKqLbJGctbBABj+ClfmNvtbOnzpq3RokNo5+V1qhtSzJyXorsklQ==", + "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/@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==", + "license": "MIT" + }, + "node_modules/@standard-schema/utils": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/@standard-schema/utils/-/utils-0.3.0.tgz", + "integrity": "sha512-e7Mew686owMaPJVNNLs55PUvgz371nKgwsc4vxE49zsODpJEnxgxRo2y/OKrqueavXgZNMDVj3DdHFlaSAeU8g==", + "license": "MIT" + }, + "node_modules/@tailwindcss/node": { + "version": "4.3.3", + "resolved": "https://registry.npmjs.org/@tailwindcss/node/-/node-4.3.3.tgz", + "integrity": "sha512-/T8IKEsf9VTU6tLjgC7+sv2mOPtQxzE2jMw7u4Tt40Tx+QSZxpzh95/H6cMKoja9XuW7iMdLJYBB0o9G1CaAgg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/remapping": "^2.3.5", + "enhanced-resolve": "^5.24.1", + "jiti": "^2.7.0", + "lightningcss": "1.32.0", + "magic-string": "^0.30.21", + "source-map-js": "^1.2.1", + "tailwindcss": "4.3.3" + } + }, + "node_modules/@tailwindcss/oxide": { + "version": "4.3.3", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide/-/oxide-4.3.3.tgz", + "integrity": "sha512-krXjAikiaFSPaK/FkAQT5UTx3VormQaiZ5hBFlJZ9UFQGB/rwg1MZIhHAG9smMQRTdyJxP6Qt5MwMtdyU5FWrA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 20" + }, + "optionalDependencies": { + "@tailwindcss/oxide-android-arm64": "4.3.3", + "@tailwindcss/oxide-darwin-arm64": "4.3.3", + "@tailwindcss/oxide-darwin-x64": "4.3.3", + "@tailwindcss/oxide-freebsd-x64": "4.3.3", + "@tailwindcss/oxide-linux-arm-gnueabihf": "4.3.3", + "@tailwindcss/oxide-linux-arm64-gnu": "4.3.3", + "@tailwindcss/oxide-linux-arm64-musl": "4.3.3", + "@tailwindcss/oxide-linux-x64-gnu": "4.3.3", + "@tailwindcss/oxide-linux-x64-musl": "4.3.3", + "@tailwindcss/oxide-wasm32-wasi": "4.3.3", + "@tailwindcss/oxide-win32-arm64-msvc": "4.3.3", + "@tailwindcss/oxide-win32-x64-msvc": "4.3.3" + } + }, + "node_modules/@tailwindcss/oxide-android-arm64": { + "version": "4.3.3", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-android-arm64/-/oxide-android-arm64-4.3.3.tgz", + "integrity": "sha512-Y85A2gmPSkl5Ve5qR86GL4HT509cFqQh1aes9p3sSkyTPwt0Pppf3GkwGe4JPACcRYjgJIEhQgM6dBClnr0NYw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">= 20" + } + }, + "node_modules/@tailwindcss/oxide-darwin-arm64": { + "version": "4.3.3", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-darwin-arm64/-/oxide-darwin-arm64-4.3.3.tgz", + "integrity": "sha512-BiaWatpBcERQFDlOjRDpIVXuFK5PJez5SA4JMg6VYZdBYU+qKfV/vqjcIs+IYmtitf1xYQZTwXvU/8y4lfZUGw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">= 20" + } + }, + "node_modules/@tailwindcss/oxide-darwin-x64": { + "version": "4.3.3", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-darwin-x64/-/oxide-darwin-x64-4.3.3.tgz", + "integrity": "sha512-fAeUqfV5ndhxRwai8cXGzdLvul9utWOmeTkv69unv4ZXixjn61Z+p9lCWdwOwA3TYboG3BwdVuN/RDjhBRl0mw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">= 20" + } + }, + "node_modules/@tailwindcss/oxide-freebsd-x64": { + "version": "4.3.3", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-freebsd-x64/-/oxide-freebsd-x64-4.3.3.tgz", + "integrity": "sha512-iyf5bV6+wnAlflVeEy7R25dupxTNECZN5QMI0qNT6eT+EgaGdZcKhGkr5SdoaWiLJ3spLqIY9VCeSGrwmtg4kw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">= 20" + } + }, + "node_modules/@tailwindcss/oxide-linux-arm-gnueabihf": { + "version": "4.3.3", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-arm-gnueabihf/-/oxide-linux-arm-gnueabihf-4.3.3.tgz", + "integrity": "sha512-aAYUprJAJQWWbRrPvtjdroZ56Md+JM8pMiopS6xGEwDfLhqj+2ver2p4nU4Mb3CRqcMmNBjo8KkUgcxhkzVQGQ==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 20" + } + }, + "node_modules/@tailwindcss/oxide-linux-arm64-gnu": { + "version": "4.3.3", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-arm64-gnu/-/oxide-linux-arm64-gnu-4.3.3.tgz", + "integrity": "sha512-nDxldcEENOxZRzC2uu9jrutZdAAQtb+8WWDCSnWL1zvBk1+FN+x6MtDViPB5AJMfttVCUhehGWus3XBPgatM/w==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 20" + } + }, + "node_modules/@tailwindcss/oxide-linux-arm64-musl": { + "version": "4.3.3", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-arm64-musl/-/oxide-linux-arm64-musl-4.3.3.tgz", + "integrity": "sha512-Md44bD6veX/PC5iyF8cDVnw4HBIANZepRZZ7a8DQOvkfo5WUBwcp6iAuCUz23u+4SUkhJlD3eL7hNdW8ezd/kA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 20" + } + }, + "node_modules/@tailwindcss/oxide-linux-x64-gnu": { + "version": "4.3.3", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-x64-gnu/-/oxide-linux-x64-gnu-4.3.3.tgz", + "integrity": "sha512-tx7us1muwOKAKWao2v/GaafFeQboE6aj88vC6ziN2NCGcRm8gWUhwjzg+YdVB1e4boAtdtma4L43onunI6NS4w==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 20" + } + }, + "node_modules/@tailwindcss/oxide-linux-x64-musl": { + "version": "4.3.3", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-x64-musl/-/oxide-linux-x64-musl-4.3.3.tgz", + "integrity": "sha512-SJxX60smvHgasZoBy11dX6YRjXJFovwWBoedhbQPOBzgFWBHGB+TVPWB9BxzR7TTxU8FQZAI2AyiNCMzFm8Img==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 20" + } + }, + "node_modules/@tailwindcss/oxide-wasm32-wasi": { + "version": "4.3.3", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-wasm32-wasi/-/oxide-wasm32-wasi-4.3.3.tgz", + "integrity": "sha512-jx1+rPhY/5Ympkktd656HBWEBLxP7dH06losBLjjf5vgCODXvi9KhtftWcMIwTFIDqBr7cRnQkdLnAG+IOlGvQ==", + "bundleDependencies": [ + "@napi-rs/wasm-runtime", + "@emnapi/core", + "@emnapi/runtime", + "@tybys/wasm-util", + "@emnapi/wasi-threads", + "tslib" + ], + "cpu": [ + "wasm32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "@emnapi/core": "^1.11.1", + "@emnapi/runtime": "^1.11.1", + "@emnapi/wasi-threads": "^1.2.2", + "@napi-rs/wasm-runtime": "^1.1.4", + "@tybys/wasm-util": "^0.10.2", + "tslib": "^2.8.1" + }, + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/@tailwindcss/oxide-win32-arm64-msvc": { + "version": "4.3.3", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-win32-arm64-msvc/-/oxide-win32-arm64-msvc-4.3.3.tgz", + "integrity": "sha512-3rc292Ca2ceK6Ulcc/bAVnTs/3nDtoPhyEKlgPv+yQJQi/JS/AMJlqzxvlDacL1nekbrcf6bTqp/jV4qgnPxNQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">= 20" + } + }, + "node_modules/@tailwindcss/oxide-win32-x64-msvc": { + "version": "4.3.3", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-win32-x64-msvc/-/oxide-win32-x64-msvc-4.3.3.tgz", + "integrity": "sha512-yJ0pwIVc/nYeGoV02WtsN8KYyLQv7kyI2wDnkezyJlGGjkd4QLwDGAwl47YpPJeuI0M0ObaXGSPjvWDPeTPggw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">= 20" + } + }, + "node_modules/@tailwindcss/vite": { + "version": "4.3.3", + "resolved": "https://registry.npmjs.org/@tailwindcss/vite/-/vite-4.3.3.tgz", + "integrity": "sha512-yYU8cogLeSh/ms2jh8Fj7jaba/EWa7Ja6GoUqYZaraEuCI5YS6ms6ObZgjjedm+jm6XZjdNRWBpPP6Z86oOxcw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@tailwindcss/node": "4.3.3", + "@tailwindcss/oxide": "4.3.3", + "tailwindcss": "4.3.3" + }, + "peerDependencies": { + "vite": "^5.2.0 || ^6 || ^7 || ^8" + } + }, + "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/d3-array": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/@types/d3-array/-/d3-array-3.2.2.tgz", + "integrity": "sha512-hOLWVbm7uRza0BYXpIIW5pxfrKe0W+D5lrFiAEYR+pb6w3N2SwSMaJbXdUfSEv+dT4MfHBLtn5js0LAWaO6otw==", + "license": "MIT" + }, + "node_modules/@types/d3-color": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/@types/d3-color/-/d3-color-3.1.3.tgz", + "integrity": "sha512-iO90scth9WAbmgv7ogoq57O9YpKmFBbmoEoCHDB2xMBY0+/KVrqAaCDyCE16dUspeOvIxFFRI+0sEtqDqy2b4A==", + "license": "MIT" + }, + "node_modules/@types/d3-ease": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/@types/d3-ease/-/d3-ease-3.0.2.tgz", + "integrity": "sha512-NcV1JjO5oDzoK26oMzbILE6HW7uVXOHLQvHshBUW4UMdZGfiY6v5BeQwh9a9tCzv+CeefZQHJt5SRgK154RtiA==", + "license": "MIT" + }, + "node_modules/@types/d3-interpolate": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/@types/d3-interpolate/-/d3-interpolate-3.0.4.tgz", + "integrity": "sha512-mgLPETlrpVV1YRJIglr4Ez47g7Yxjl1lj7YKsiMCb27VJH9W8NVM6Bb9d8kkpG/uAQS5AmbA48q2IAolKKo1MA==", + "license": "MIT", + "dependencies": { + "@types/d3-color": "*" + } + }, + "node_modules/@types/d3-path": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/@types/d3-path/-/d3-path-3.1.1.tgz", + "integrity": "sha512-VMZBYyQvbGmWyWVea0EHs/BwLgxc+MKi1zLDCONksozI4YJMcTt8ZEuIR4Sb1MMTE8MMW49v0IwI5+b7RmfWlg==", + "license": "MIT" + }, + "node_modules/@types/d3-scale": { + "version": "4.0.9", + "resolved": "https://registry.npmjs.org/@types/d3-scale/-/d3-scale-4.0.9.tgz", + "integrity": "sha512-dLmtwB8zkAeO/juAMfnV+sItKjlsw2lKdZVVy6LRr0cBmegxSABiLEpGVmSJJ8O08i4+sGR6qQtb6WtuwJdvVw==", + "license": "MIT", + "dependencies": { + "@types/d3-time": "*" + } + }, + "node_modules/@types/d3-shape": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/@types/d3-shape/-/d3-shape-3.2.0.tgz", + "integrity": "sha512-kVd74ta9eof3eJOvbNd1vGKS/XERRyQbT26Og63hIsvDO84cjD5gEOhsXf26w3FSoNlPVz84DOFcKv/oou+fMw==", + "license": "MIT", + "dependencies": { + "@types/d3-path": "*" + } + }, + "node_modules/@types/d3-time": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/@types/d3-time/-/d3-time-3.0.4.tgz", + "integrity": "sha512-yuzZug1nkAAaBlBBikKZTgzCeA+k1uy4ZFwWANOfKw5z5LRhV0gNA7gNkKm7HoK+HRN0wX3EkxGk0fpbWhmB7g==", + "license": "MIT" + }, + "node_modules/@types/d3-timer": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/@types/d3-timer/-/d3-timer-3.0.2.tgz", + "integrity": "sha512-Ps3T8E8dZDam6fUyNiMkekK3XUsaUEik+idO9/YjPtfj2qruF8tFBXS7XhtE4iIXBLxhmLjP3SXpLhVf21I9Lw==", + "license": "MIT" + }, + "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/esrecurse": { + "version": "4.3.1", + "resolved": "https://registry.npmjs.org/@types/esrecurse/-/esrecurse-4.3.1.tgz", + "integrity": "sha512-xJBAbDifo5hpffDBuHl0Y8ywswbiAp/Wi7Y/GtAgSlZyIABppyurxVueOPE8LUQOxdlgi6Zqce7uoEpqNTeiUw==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/estree": { + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.9.tgz", + "integrity": "sha512-GhdPgy1el4/ImP05X05Uw4cw2/M93BCUmnEvWZNStlCzEKME4Fkk+YpoA5OiHNQmoS7Cafb8Xa3Pya8m1Qrzeg==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/json-schema": { + "version": "7.0.15", + "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz", + "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/node": { + "version": "26.6.3", + "resolved": "https://registry.npmjs.org/@types/node/-/node-26.6.3.tgz", + "integrity": "sha512-dsqMQQoeTLqu9wynDD00q573mNzso3IdQOAfHRJqLCcmCFPoGo9A1bDpUcv/9tnKpErQWv9uKeGfl37EIS02Yg==", + "dev": true, + "license": "MIT", + "dependencies": { + "undici-types": "~8.9.0" + } + }, + "node_modules/@types/react": { + "version": "19.3.0", + "resolved": "https://registry.npmjs.org/@types/react/-/react-19.3.0.tgz", + "integrity": "sha512-N0rFCuH9YoxG9/m61l9MfpJKfmLOVU0em7ipIz6TRgSSkvReLB9vL85GB+yr8Bs5leqpvg96JSwF4ZS1s4viQg==", + "devOptional": true, + "license": "MIT", + "dependencies": { + "csstype": "^3.2.2" + } + }, + "node_modules/@types/react-dom": { + "version": "19.3.0", + "resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-19.3.0.tgz", + "integrity": "sha512-ZI7bU42mZXXKHn/qNLEw2IrbiINU7X5+vfgdixBHkCNpYWXjKgfQ/P+uyGb5CjOLB9UcnTeg3rylQtV2hym44Q==", + "devOptional": true, + "license": "MIT", + "peerDependencies": { + "@types/react": "^19.3.0" + } + }, + "node_modules/@types/use-sync-external-store": { + "version": "0.0.6", + "resolved": "https://registry.npmjs.org/@types/use-sync-external-store/-/use-sync-external-store-0.0.6.tgz", + "integrity": "sha512-zFDAD+tlpf2r4asuHEj0XH6pY6i0g5NeAHPn+15wk3BV6JA69eERFXC1gyGThDkVa1zCyKr5jox1+2LbV/AMLg==", + "license": "MIT" + }, + "node_modules/@typescript-eslint/eslint-plugin": { + "version": "8.71.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.71.0.tgz", + "integrity": "sha512-pqcS9c1HxZTHt7End4nXqd0s5lJrrFzrgCkKFJrsbUnaL6M3+6oBFZaslg6Gjsl3argl2DDRFROnXARaZ2e4Nw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@eslint-community/regexpp": "^4.12.2", + "@typescript-eslint/scope-manager": "8.71.0", + "@typescript-eslint/type-utils": "8.71.0", + "@typescript-eslint/utils": "8.71.0", + "@typescript-eslint/visitor-keys": "8.71.0", + "ignore": "^7.0.5", + "natural-compare": "^1.4.0", + "ts-api-utils": "^2.5.0" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "@typescript-eslint/parser": "^8.71.0", + "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0", + "typescript": ">=4.8.4 <6.1.0" + } + }, + "node_modules/@typescript-eslint/eslint-plugin/node_modules/ignore": { + "version": "7.0.11", + "resolved": "https://registry.npmjs.org/ignore/-/ignore-7.0.11.tgz", + "integrity": "sha512-YChdK5txDjwGUvgR7oCJcLGkwi3LDh8Zx8tS7ndYciLEg/oOCL26VUBSUEtgS7EjiybcBqFxh5j0rAdDX7/bbg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 4" + } + }, + "node_modules/@typescript-eslint/parser": { + "version": "8.71.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-8.71.0.tgz", + "integrity": "sha512-CG4nPk1f2zc8yw4pALqHsFYH2hdo+h1T9daSp21+Hnxi9LOE3GT9hAfTKJCBXVNM2GmYs1eMEP615wPoeOgk3A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/scope-manager": "8.71.0", + "@typescript-eslint/types": "8.71.0", + "@typescript-eslint/typescript-estree": "8.71.0", + "@typescript-eslint/visitor-keys": "8.71.0", + "debug": "^4.4.3" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0", + "typescript": ">=4.8.4 <6.1.0" + } + }, + "node_modules/@typescript-eslint/project-service": { + "version": "8.71.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/project-service/-/project-service-8.71.0.tgz", + "integrity": "sha512-aABjw5rjBacYONVPaPiWOCjJu0vEF4a25iQuodlmQYL1trtLZ0X/y+2Vzl3BKI1odM4LnwLE1oUDXYp1wzx1TQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/tsconfig-utils": "^8.71.0", + "@typescript-eslint/types": "^8.71.0", + "debug": "^4.4.3" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "typescript": ">=4.8.4 <6.1.0" + } + }, + "node_modules/@typescript-eslint/scope-manager": { + "version": "8.71.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-8.71.0.tgz", + "integrity": "sha512-gWF0BhUcnjZxSpLE8ngS/59n2SB0J3YqRxvX1+2aoRJk9hNtHSLOV+TcarFiOr5ipXm3yc1QrI4c9YZc8zyCxw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/types": "8.71.0", + "@typescript-eslint/visitor-keys": "8.71.0" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + } + }, + "node_modules/@typescript-eslint/tsconfig-utils": { + "version": "8.71.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/tsconfig-utils/-/tsconfig-utils-8.71.0.tgz", + "integrity": "sha512-Z1UlWHADEK2Mlb9NpWfDeSjqoZ5EyrOv4R3eQpbkzqn/EwaIdOpXXupEA1+0ZIOSJSZZDBHG0BrQyN8zUG6Pwg==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "typescript": ">=4.8.4 <6.1.0" + } + }, + "node_modules/@typescript-eslint/type-utils": { + "version": "8.71.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-8.71.0.tgz", + "integrity": "sha512-i8uO1qbdxeKgRnS5sCRt6On3/nfo2d2DwQe3Yvjx543zLy7r8ySqRuPPiIIXAhS03U0v5NfAFx+rUgxFzKKwNw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/types": "8.71.0", + "@typescript-eslint/typescript-estree": "8.71.0", + "@typescript-eslint/utils": "8.71.0", + "debug": "^4.4.3", + "ts-api-utils": "^2.5.0" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0", + "typescript": ">=4.8.4 <6.1.0" + } + }, + "node_modules/@typescript-eslint/types": { + "version": "8.71.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-8.71.0.tgz", + "integrity": "sha512-cJ4OoxPGWvFnBTnSZyaU+qJzGTqPTGJY+gDchj6cRyLRdmIdt4rcsE4twj+zPfrNiWuVi38wijHzShL++Z9atQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + } + }, + "node_modules/@typescript-eslint/typescript-estree": { + "version": "8.71.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-8.71.0.tgz", + "integrity": "sha512-PEEF4G5sLLWAS5BpPrUvms4ySZkiBQQZM4z+3ReI46axK5Vqr/vXBQatJQIZZOYdGyPUAKTtsrWzpqKuU+3DEw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/project-service": "8.71.0", + "@typescript-eslint/tsconfig-utils": "8.71.0", + "@typescript-eslint/types": "8.71.0", + "@typescript-eslint/visitor-keys": "8.71.0", + "debug": "^4.4.3", + "minimatch": "^10.2.2", + "semver": "^7.7.3", + "tinyglobby": "^0.2.15", + "ts-api-utils": "^2.5.0" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "typescript": ">=4.8.4 <6.1.0" + } + }, + "node_modules/@typescript-eslint/typescript-estree/node_modules/semver": { + "version": "7.8.5", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.8.5.tgz", + "integrity": "sha512-Y7/KDsb8LjooZpwaqGyulO6DQlksgCncchHGk+sZIY4SBvUocMBEFH5Ur1fI4dV+Jvl0w6cjvucaIi40puRioA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/@typescript-eslint/utils": { + "version": "8.71.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-8.71.0.tgz", + "integrity": "sha512-pKR/tEMVrXZG23UFKUn5BQf3zfmfk7KQceI2cGzywZ5nxM5Eu3hEJU1utjWzydtzBbcJAQhHN8iPCxobHpPcZQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@eslint-community/eslint-utils": "^4.9.1", + "@typescript-eslint/scope-manager": "8.71.0", + "@typescript-eslint/types": "8.71.0", + "@typescript-eslint/typescript-estree": "8.71.0" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0", + "typescript": ">=4.8.4 <6.1.0" + } + }, + "node_modules/@typescript-eslint/visitor-keys": { + "version": "8.71.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-8.71.0.tgz", + "integrity": "sha512-8eQ9R218XORK+KLosnf4bu/QsUXvUyVwTbArg7/0NMB1Pu87OJKvj4nhFblkYE8gQV73mW1dx1ptlPCkwRGa7A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/types": "8.71.0", + "eslint-visitor-keys": "^5.0.0" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + } + }, + "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/mocker": { + "version": "5.0.3", + "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-5.0.3.tgz", + "integrity": "sha512-T8sWAIbkSyAjkwTcaEc3Iu0o9A27X1/kdXrizhZkGuSKScRQtRzclfAMpOTcGdXCsqxeWlpGy3XjqaW8CpLORg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/trace-mapping": "0.3.31", + "@vitest/spy": "5.0.3", + "estree-walker": "^3.0.3", + "magic-string": "^1.2.3" + }, + "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/mocker/node_modules/magic-string": { + "version": "1.4.2", + "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-1.4.2.tgz", + "integrity": "sha512-vG+rjFRj1PqdIBozIxAGMjPlOhaVe+GXpbttY/iSK7rGcJRMlwNJO7dcUwmUqkymsFLJiNGI06t4D7Fr7yRC9g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/sourcemap-codec": "^1.6.0" + } + }, + "node_modules/@vitest/spy": { + "version": "5.0.3", + "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-5.0.3.tgz", + "integrity": "sha512-XhFysQTB8AZ+P4gMi+Lpo99vg2AZi0qKpaB9yXQl37+CaMEAPO3iH/wGVnSyL5MPERiLezpqTVtrR6UZH5GCXg==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/acorn": { + "version": "8.18.0", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.18.0.tgz", + "integrity": "sha512-lGq+9yr1/GuAWaVYIHRjvvySG5/4VfKIvC8EWxStPdcDh/Ka7FG3twP6v4d5BkravUilhIAsG4Qj83t02LWUPQ==", + "dev": true, + "license": "MIT", + "bin": { + "acorn": "bin/acorn" + }, + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/acorn-jsx": { + "version": "5.3.2", + "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz", + "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==", + "dev": true, + "license": "MIT", + "peerDependencies": { + "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0" + } + }, + "node_modules/ajv": { + "version": "6.15.0", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.15.0.tgz", + "integrity": "sha512-fgFx7Hfoq60ytK2c7DhnF8jIvzYgOMxfugjLOSMHjLIPgenqa7S7oaagATUq99mV6IYvN2tRmC0wnTYX6iPbMw==", + "dev": true, + "license": "MIT", + "dependencies": { + "fast-deep-equal": "^3.1.1", + "fast-json-stable-stringify": "^2.0.0", + "json-schema-traverse": "^0.4.1", + "uri-js": "^4.2.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, + "node_modules/aria-hidden": { + "version": "1.2.6", + "resolved": "https://registry.npmjs.org/aria-hidden/-/aria-hidden-1.2.6.tgz", + "integrity": "sha512-ik3ZgC9dY/lYVVM++OISsaYDeg1tb0VtP5uL3ouh1koGOaUMDPpbFIei4JkFimWUFPn90sbMNMXQAIVOlnYKJA==", + "license": "MIT", + "dependencies": { + "tslib": "^2.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "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/balanced-match": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz", + "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==", + "dev": true, + "license": "MIT", + "engines": { + "node": "18 || 20 || >=22" + } + }, + "node_modules/baseline-browser-mapping": { + "version": "2.11.26", + "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.11.26.tgz", + "integrity": "sha512-GLQdD3y6UF8iVuMJl5fHgE4jdn/ua7n+toKfLgNlg3BqQtOZjpy68T8Tup8/wGWZCDlm7KMg7tPb4MPn7oN0TQ==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "baseline-browser-mapping": "dist/cli.cjs" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/brace-expansion": { + "version": "5.0.12", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.12.tgz", + "integrity": "sha512-YovQ3rzhaLMIrDjNDMkNS01tea93qhEhG5xy8f6+R0l+dw3Ki+5sCoIoI942iuLZTHWogWktgwVDhU09iNEimQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^4.0.2" + }, + "engines": { + "node": "20 || >=22" + } + }, + "node_modules/browserslist": { + "version": "4.29.3", + "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.29.3.tgz", + "integrity": "sha512-1R4kiYKXGViqEN0CnoDrXc1StD9niAwu+j2dukWzrD4bJgsD4lDmEp0CRbc6E/vYJIfTHwPmwyaKtVSudICdPA==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/browserslist" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "baseline-browser-mapping": "^2.11.26", + "caniuse-lite": "^1.0.30001813", + "electron-to-chromium": "^1.5.439", + "node-releases": "^2.0.57", + "update-browserslist-db": "^1.3.3" + }, + "bin": { + "browserslist": "cli.js" + }, + "engines": { + "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7" + } + }, + "node_modules/cacheable": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/cacheable/-/cacheable-2.5.0.tgz", + "integrity": "sha512-60cyAOytib/OzBw1JNSoSV/boK1AtHryDIjvVBk7XbN4ugfkM3+Sry7fEjNgPMGgOjuaZPAp8ruZ0Cxafwyq9g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@cacheable/memory": "^2.2.0", + "@cacheable/utils": "^2.5.0", + "hookified": "^1.15.0", + "keyv": "^5.6.0", + "qified": "^0.10.1" + } + }, + "node_modules/caniuse-lite": { + "version": "1.0.30001814", + "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001814.tgz", + "integrity": "sha512-/Uaf1lAzr59XcMpW0o96WoEfr+VXK2OX4U9AgFoiSHsVJ4HppnIFUjtYzsyDH2+tgANaQb2/oxYGwCPapN1FpA==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/caniuse-lite" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "CC-BY-4.0" + }, + "node_modules/chai": { + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/chai/-/chai-6.3.0.tgz", + "integrity": "sha512-XWAtwJ6OHO+tj0EKCs0Y2UamnyOxseZWltU4x2U2wh8g4AigdjwvtUjvLP2tqkA/avxHEtzxNaqGq/YGNwckKg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + } + }, + "node_modules/class-variance-authority": { + "version": "0.7.1", + "resolved": "https://registry.npmjs.org/class-variance-authority/-/class-variance-authority-0.7.1.tgz", + "integrity": "sha512-Ka+9Trutv7G8M6WT6SeiRWz792K5qEqIGEGzXKhAE6xOWAY6pPH8U+9IY3oCMv6kqTmLsv7Xh/2w2RigkePMsg==", + "license": "Apache-2.0", + "dependencies": { + "clsx": "^2.1.1" + }, + "funding": { + "url": "https://polar.sh/cva" + } + }, + "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/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/cross-spawn": { + "version": "7.0.6", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz", + "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==", + "dev": true, + "license": "MIT", + "dependencies": { + "path-key": "^3.1.0", + "shebang-command": "^2.0.0", + "which": "^2.0.1" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/csstype": { + "version": "3.2.3", + "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz", + "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==", + "devOptional": true, + "license": "MIT" + }, + "node_modules/d3-array": { + "version": "3.2.4", + "resolved": "https://registry.npmjs.org/d3-array/-/d3-array-3.2.4.tgz", + "integrity": "sha512-tdQAmyA18i4J7wprpYq8ClcxZy3SC31QMeByyCFyRt7BVHdREQZ5lpzoe5mFEYZUWe+oq8HBvk9JjpibyEV4Jg==", + "license": "ISC", + "dependencies": { + "internmap": "1 - 2" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-color": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/d3-color/-/d3-color-3.1.0.tgz", + "integrity": "sha512-zg/chbXyeBtMQ1LbD/WSoW2DpC3I0mpmPdW+ynRTj/x2DAWYrIY7qeZIHidozwV24m4iavr15lNwIwLxRmOxhA==", + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-ease": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-ease/-/d3-ease-3.0.1.tgz", + "integrity": "sha512-wR/XK3D3XcLIZwpbvQwQ5fK+8Ykds1ip7A2Txe0yxncXSdq1L9skcG7blcedkOX+ZcgxGAmLX1FrRGbADwzi0w==", + "license": "BSD-3-Clause", + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-format": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/d3-format/-/d3-format-3.1.2.tgz", + "integrity": "sha512-AJDdYOdnyRDV5b6ArilzCPPwc1ejkHcoyFarqlPqT7zRYjhavcT3uSrqcMvsgh2CgoPbK3RCwyHaVyxYcP2Arg==", + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-interpolate": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-interpolate/-/d3-interpolate-3.0.1.tgz", + "integrity": "sha512-3bYs1rOD33uo8aqJfKP3JWPAibgw8Zm2+L9vBKEHJ2Rg+viTR7o5Mmv5mZcieN+FRYaAOWX5SJATX6k1PWz72g==", + "license": "ISC", + "dependencies": { + "d3-color": "1 - 3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-path": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/d3-path/-/d3-path-3.1.0.tgz", + "integrity": "sha512-p3KP5HCf/bvjBSSKuXid6Zqijx7wIfNW+J/maPs+iwR35at5JCbLUT0LzF1cnjbCHWhqzQTIN2Jpe8pRebIEFQ==", + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-scale": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/d3-scale/-/d3-scale-4.0.2.tgz", + "integrity": "sha512-GZW464g1SH7ag3Y7hXjf8RoUuAFIqklOAq3MRl4OaWabTFJY9PN/E1YklhXLh+OQ3fM9yS2nOkCoS+WLZ6kvxQ==", + "license": "ISC", + "dependencies": { + "d3-array": "2.10.0 - 3", + "d3-format": "1 - 3", + "d3-interpolate": "1.2.0 - 3", + "d3-time": "2.1.1 - 3", + "d3-time-format": "2 - 4" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-shape": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/d3-shape/-/d3-shape-3.2.0.tgz", + "integrity": "sha512-SaLBuwGm3MOViRq2ABk3eLoxwZELpH6zhl3FbAoJ7Vm1gofKx6El1Ib5z23NUEhF9AsGl7y+dzLe5Cw2AArGTA==", + "license": "ISC", + "dependencies": { + "d3-path": "^3.1.0" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-time": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/d3-time/-/d3-time-3.1.0.tgz", + "integrity": "sha512-VqKjzBLejbSMT4IgbmVgDjpkYrNWUYJnbCGo874u7MMKIWsILRX+OpX/gTk8MqjpT1A/c6HY2dCA77ZN0lkQ2Q==", + "license": "ISC", + "dependencies": { + "d3-array": "2 - 3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-time-format": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/d3-time-format/-/d3-time-format-4.1.0.tgz", + "integrity": "sha512-dJxPBlzC7NugB2PDLwo9Q8JiTR3M3e4/XANkreKSUxF8vvXKqm1Yfq4Q5dl8budlunRVlUUaDUgFt7eA8D6NLg==", + "license": "ISC", + "dependencies": { + "d3-time": "1 - 3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-timer": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-timer/-/d3-timer-3.0.1.tgz", + "integrity": "sha512-ndfJ/JxxMd3nw31uyKoY2naivF+r29V+Lc0svZxe1JvvIRmi8hUsrMvdOwgS1o6uBHmiz91geQ0ylPP0aj1VUA==", + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/debug": { + "version": "4.4.3", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", + "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", + "dev": true, + "license": "MIT", + "dependencies": { + "ms": "^2.1.3" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/decimal.js-light": { + "version": "2.5.1", + "resolved": "https://registry.npmjs.org/decimal.js-light/-/decimal.js-light-2.5.1.tgz", + "integrity": "sha512-qIMFpTMZmny+MMIitAB6D7iVPEorVw6YQRWkvarTkT4tBeSLLiHzcwj6q0MmYSFCiVpiqPJTJEYIrpcPzVEIvg==", + "license": "MIT" + }, + "node_modules/deep-is": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz", + "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==", + "dev": true, + "license": "MIT" + }, + "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", + "integrity": "sha512-ypdmJU/TbBby2Dxibuv7ZLW3Bs1QEmM7nHjEANfohJLvE0XVujisn1qPJcZxg+qDucsr+bP6fLD1rPS3AhJ7EQ==", + "license": "MIT" + }, + "node_modules/electron-to-chromium": { + "version": "1.5.443", + "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.443.tgz", + "integrity": "sha512-TDJG36L9A3CWWwZ97HKaE+Iz1sW80pNp6sAU0owzCIV3Zc9eVyRqZK8Vz6NKuMIU8WjP0pIkoqCa0VRf/yFD0Q==", + "dev": true, + "license": "ISC" + }, + "node_modules/enhanced-resolve": { + "version": "5.26.0", + "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.26.0.tgz", + "integrity": "sha512-9vhedylFonb2YGogzUKX6+Ja72gOJbN1QHAqdrvqLwhdl/QWbKopzoUC9EbQNVsAns/bx/4uyqalrQAoy1IByw==", + "dev": true, + "license": "MIT", + "dependencies": { + "graceful-fs": "^4.2.4", + "tapable": "^2.3.3" + }, + "engines": { + "node": ">=10.13.0" + } + }, + "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/es-toolkit": { + "version": "1.52.0", + "resolved": "https://registry.npmjs.org/es-toolkit/-/es-toolkit-1.52.0.tgz", + "integrity": "sha512-XTNEJQh1tY1ZJVcf6ayP/2n4ZPyaHlW2FWs7xvw5ddPuhUVjLD3olQVQS7kf58JbAB48iL0uL/jerTrjtV3lDA==", + "license": "MIT", + "workspaces": [ + "docs", + "benchmarks", + "tests/types", + "tests/browser-compat" + ] + }, + "node_modules/escalade": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz", + "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/escape-string-regexp": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz", + "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/eslint": { + "version": "10.11.0", + "resolved": "https://registry.npmjs.org/eslint/-/eslint-10.11.0.tgz", + "integrity": "sha512-P7a6UEEqb9G95MYAtqkmsTbVXIYyzIfl6NGOIJk162PaahFxFyeGcrlXYFSiagECg4sEm8IseJdZBKR3rx6MsQ==", + "dev": true, + "license": "MIT", + "workspaces": [ + "packages/*" + ], + "dependencies": { + "@eslint-community/eslint-utils": "^4.8.0", + "@eslint-community/regexpp": "^4.12.2", + "@eslint/config-array": "^0.23.5", + "@eslint/config-helpers": "^0.7.0", + "@eslint/core": "^1.2.1", + "@eslint/plugin-kit": "^0.7.3", + "@humanfs/node": "^0.16.6", + "@humanwhocodes/module-importer": "^1.0.1", + "@humanwhocodes/retry": "^0.4.2", + "@types/estree": "^1.0.6", + "ajv": "^6.14.0", + "cross-spawn": "^7.0.6", + "debug": "^4.3.2", + "escape-string-regexp": "^4.0.0", + "eslint-scope": "^9.1.2", + "eslint-visitor-keys": "^5.0.1", + "espree": "^11.2.0", + "esquery": "^1.7.0", + "esutils": "^2.0.2", + "fast-deep-equal": "^3.1.3", + "file-entry-cache": "11.1.5 || >11.1.6 <12", + "find-up": "^5.0.0", + "glob-parent": "^6.0.2", + "ignore": "^5.2.0", + "imurmurhash": "^0.1.4", + "is-glob": "^4.0.0", + "json-stable-stringify-without-jsonify": "^1.0.1", + "minimatch": "^10.2.5", + "natural-compare": "^1.4.0", + "optionator": "^0.9.3" + }, + "bin": { + "eslint": "bin/eslint.js" + }, + "engines": { + "node": "^20.19.0 || ^22.13.0 || >=24" + }, + "funding": { + "url": "https://eslint.org/donate" + }, + "peerDependencies": { + "jiti": "*" + }, + "peerDependenciesMeta": { + "jiti": { + "optional": true + } + } + }, + "node_modules/eslint-plugin-react-hooks": { + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/eslint-plugin-react-hooks/-/eslint-plugin-react-hooks-7.1.1.tgz", + "integrity": "sha512-f2I7Gw6JbvCexzIInuSbZpfdQ44D7iqdWX01FKLvrPgqxoE7oMj8clOfto8U6vYiz4yd5oKu39rRSVOe1zRu0g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/core": "^7.24.4", + "@babel/parser": "^7.24.4", + "hermes-parser": "^0.25.1", + "zod": "^3.25.0 || ^4.0.0", + "zod-validation-error": "^3.5.0 || ^4.0.0" + }, + "engines": { + "node": ">=18" + }, + "peerDependencies": { + "eslint": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-0 || ^9.0.0 || ^10.0.0" + } + }, + "node_modules/eslint-plugin-react-refresh": { + "version": "0.5.7", + "resolved": "https://registry.npmjs.org/eslint-plugin-react-refresh/-/eslint-plugin-react-refresh-0.5.7.tgz", + "integrity": "sha512-XhJSzLljuYD4UjNuFGJu2v7aD3sqNVK12w5/DCUfrNfHWegZo2+TsavNx8MuxMwEquuFAzNbNfXKU0WoZ+YUIg==", + "dev": true, + "license": "MIT", + "peerDependencies": { + "eslint": "^9 || ^10" + } + }, + "node_modules/eslint-scope": { + "version": "9.1.2", + "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-9.1.2.tgz", + "integrity": "sha512-xS90H51cKw0jltxmvmHy2Iai1LIqrfbw57b79w/J7MfvDfkIkFZ+kj6zC3BjtUwh150HsSSdxXZcsuv72miDFQ==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "@types/esrecurse": "^4.3.1", + "@types/estree": "^1.0.8", + "esrecurse": "^4.3.0", + "estraverse": "^5.2.0" + }, + "engines": { + "node": "^20.19.0 || ^22.13.0 || >=24" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/eslint-visitor-keys": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-5.0.1.tgz", + "integrity": "sha512-tD40eHxA35h0PEIZNeIjkHoDR4YjjJp34biM0mDvplBe//mB+IHCqHDGV7pxF+7MklTvighcCPPZC7ynWyjdTA==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": "^20.19.0 || ^22.13.0 || >=24" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/espree": { + "version": "11.2.0", + "resolved": "https://registry.npmjs.org/espree/-/espree-11.2.0.tgz", + "integrity": "sha512-7p3DrVEIopW1B1avAGLuCSh1jubc01H2JHc8B4qqGblmg5gI9yumBgACjWo4JlIc04ufug4xJ3SQI8HkS/Rgzw==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "acorn": "^8.16.0", + "acorn-jsx": "^5.3.2", + "eslint-visitor-keys": "^5.0.1" + }, + "engines": { + "node": "^20.19.0 || ^22.13.0 || >=24" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/esquery": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.7.0.tgz", + "integrity": "sha512-Ap6G0WQwcU/LHsvLwON1fAQX9Zp0A2Y6Y/cJBl9r/JbW90Zyg4/zbG6zzKa2OTALELarYHmKu0GhpM5EO+7T0g==", + "dev": true, + "license": "BSD-3-Clause", + "dependencies": { + "estraverse": "^5.1.0" + }, + "engines": { + "node": ">=0.10" + } + }, + "node_modules/esrecurse": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz", + "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "estraverse": "^5.2.0" + }, + "engines": { + "node": ">=4.0" + } + }, + "node_modules/estraverse": { + "version": "5.3.0", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz", + "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==", + "dev": true, + "license": "BSD-2-Clause", + "engines": { + "node": ">=4.0" + } + }, + "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/esutils": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz", + "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==", + "dev": true, + "license": "BSD-2-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/eventemitter3": { + "version": "5.0.4", + "resolved": "https://registry.npmjs.org/eventemitter3/-/eventemitter3-5.0.4.tgz", + "integrity": "sha512-mlsTRyGaPBjPedk6Bvw+aqbsXDtoAyAzm5MO7JgU+yVRyMQ5O8bD4Kcci7BS85f93veegeCPkL8R4GLClnjLFw==", + "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/fast-deep-equal": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz", + "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/fast-json-stable-stringify": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz", + "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==", + "dev": true, + "license": "MIT" + }, + "node_modules/fast-levenshtein": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz", + "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==", + "dev": true, + "license": "MIT" + }, + "node_modules/fdir": { + "version": "6.5.0", + "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz", + "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12.0.0" + }, + "peerDependencies": { + "picomatch": "^3 || ^4" + }, + "peerDependenciesMeta": { + "picomatch": { + "optional": true + } + } + }, + "node_modules/file-entry-cache": { + "version": "11.1.5", + "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-11.1.5.tgz", + "integrity": "sha512-+PFTHITI08JIGhnNpGNI8T8inUpgZfk3GNEqfT9R2zZV2iFXg3CvqzSl/uEhs7TSGujYRELEANyDvS8Fj7+S7Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "flat-cache": "^6.1.23" + } + }, + "node_modules/find-up": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz", + "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==", + "dev": true, + "license": "MIT", + "dependencies": { + "locate-path": "^6.0.0", + "path-exists": "^4.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/flat-cache": { + "version": "6.1.23", + "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-6.1.23.tgz", + "integrity": "sha512-f++BY9pTk+983xK1FLzlLpmM0i0z+jHmx3QESGkURMXujQZz1k5wzwX6hjnQ8goaD0B+sYnDK1yZ6MTyZfUaqA==", + "dev": true, + "license": "MIT", + "dependencies": { + "cacheable": "^2.5.0", + "flatted": "^3.4.2", + "hookified": "^1.15.0" + } + }, + "node_modules/flatted": { + "version": "3.4.4", + "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.4.4.tgz", + "integrity": "sha512-5+ybhBZANEJxaH3X5evAFatUxLfEHSr7n6kYJ+1Qd0mUqr4eu9gIf6GDbWHf8RJijHrjjO8G+la14SlL2SeS1Q==", + "dev": true, + "license": "ISC" + }, + "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/gensync": { + "version": "1.0.0-beta.2", + "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz", + "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/get-nonce": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/get-nonce/-/get-nonce-1.0.1.tgz", + "integrity": "sha512-FJhYRoDaiatfEkUK8HKlicmu/3SGFD51q3itKDGoSTysQJBnfOcxU5GxnhE1E6soB76MbT0MBtnKJuXyAx+96Q==", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/glob-parent": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz", + "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==", + "dev": true, + "license": "ISC", + "dependencies": { + "is-glob": "^4.0.3" + }, + "engines": { + "node": ">=10.13.0" + } + }, + "node_modules/globals": { + "version": "17.12.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-17.12.0.tgz", + "integrity": "sha512-cezEd/DTyyht9cvSSURyygXPfy04GtWO/5e6ZPvH7fCtjKz9PYOmuawphw1Ctd1f6C+5JypXfGD7ahNMXvevBA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/graceful-fs": { + "version": "4.2.11", + "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz", + "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==", + "dev": true, + "license": "ISC" + }, + "node_modules/hashery": { + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/hashery/-/hashery-1.5.1.tgz", + "integrity": "sha512-iZyKG96/JwPz1N55vj2Ie2vXbhu440zfUfJvSwEqEbeLluk7NnapfGqa7LH0mOsnDxTF85Mx8/dyR6HfqcbmbQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "hookified": "^1.15.0" + }, + "engines": { + "node": ">=20" + } + }, + "node_modules/hermes-estree": { + "version": "0.25.1", + "resolved": "https://registry.npmjs.org/hermes-estree/-/hermes-estree-0.25.1.tgz", + "integrity": "sha512-0wUoCcLp+5Ev5pDW2OriHC2MJCbwLwuRx+gAqMTOkGKJJiBCLjtrvy4PWUGn6MIVefecRpzoOZ/UV6iGdOr+Cw==", + "dev": true, + "license": "MIT" + }, + "node_modules/hermes-parser": { + "version": "0.25.1", + "resolved": "https://registry.npmjs.org/hermes-parser/-/hermes-parser-0.25.1.tgz", + "integrity": "sha512-6pEjquH3rqaI6cYAXYPcz9MS4rY6R4ngRgrgfDshRptUZIc3lw0MCIJIGDj9++mfySOuPTHB4nrSW99BCvOPIA==", + "dev": true, + "license": "MIT", + "dependencies": { + "hermes-estree": "0.25.1" + } + }, + "node_modules/hookified": { + "version": "1.15.1", + "resolved": "https://registry.npmjs.org/hookified/-/hookified-1.15.1.tgz", + "integrity": "sha512-MvG/clsADq1GPM2KGo2nyfaWVyn9naPiXrqIe4jYjXNZQt238kWyOGrsyc/DmRAQ+Re6yeo6yX/yoNCG5KAEVg==", + "dev": true, + "license": "MIT" + }, + "node_modules/ignore": { + "version": "5.3.2", + "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz", + "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 4" + } + }, + "node_modules/immer": { + "version": "11.1.18", + "resolved": "https://registry.npmjs.org/immer/-/immer-11.1.18.tgz", + "integrity": "sha512-EQyQtLiYW029lyoczMl/Hh4Xu7cDecSc58JRYpHyL4tIAu3eqd1yJzQX04d2BZHDkzFFvm6qJEJWOtfDSWAXbQ==", + "license": "MIT", + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/immer" + } + }, + "node_modules/imurmurhash": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz", + "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.8.19" + } + }, + "node_modules/internmap": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/internmap/-/internmap-2.0.3.tgz", + "integrity": "sha512-5Hh7Y1wQbvY5ooGgPbDaL5iYLAPzMTUrjMulskHLH6wnv/A+1q5rgEaiuqEjB+oxGXIVZs1FF+R/KPN3ZSQYYg==", + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/is-extglob": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", + "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-glob": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz", + "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==", + "dev": true, + "license": "MIT", + "dependencies": { + "is-extglob": "^2.1.1" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/isexe": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", + "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==", + "dev": true, + "license": "ISC" + }, + "node_modules/jiti": { + "version": "2.7.0", + "resolved": "https://registry.npmjs.org/jiti/-/jiti-2.7.0.tgz", + "integrity": "sha512-AC/7JofJvZGrrneWNaEnJeOLUx+JlGt7tNa0wZiRPT4MY1wmfKjt2+6O2p2uz2+skll8OZZmJMNqeke7kKbNgQ==", + "dev": true, + "license": "MIT", + "bin": { + "jiti": "lib/jiti-cli.mjs" + } + }, + "node_modules/js-tokens": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz", + "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/jsesc": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz", + "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==", + "dev": true, + "license": "MIT", + "bin": { + "jsesc": "bin/jsesc" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/json-schema-traverse": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz", + "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==", + "dev": true, + "license": "MIT" + }, + "node_modules/json-stable-stringify-without-jsonify": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz", + "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==", + "dev": true, + "license": "MIT" + }, + "node_modules/json5": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz", + "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==", + "dev": true, + "license": "MIT", + "bin": { + "json5": "lib/cli.js" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/keyv": { + "version": "5.6.0", + "resolved": "https://registry.npmjs.org/keyv/-/keyv-5.6.0.tgz", + "integrity": "sha512-CYDD3SOtsHtyXeEORYRx2qBtpDJFjRTGXUtmNEMGyzYOKj1TE3tycdlho7kA1Ufx9OYWZzg52QFBGALTirzDSw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@keyv/serialize": "^1.1.1" + } + }, + "node_modules/levn": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz", + "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "prelude-ls": "^1.2.1", + "type-check": "~0.4.0" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/lightningcss": { + "version": "1.32.0", + "resolved": "https://registry.npmjs.org/lightningcss/-/lightningcss-1.32.0.tgz", + "integrity": "sha512-NXYBzinNrblfraPGyrbPoD19C1h9lfI/1mzgWYvXUTe414Gz/X1FD2XBZSZM7rRTrMA8JL3OtAaGifrIKhQ5yQ==", + "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.32.0", + "lightningcss-darwin-arm64": "1.32.0", + "lightningcss-darwin-x64": "1.32.0", + "lightningcss-freebsd-x64": "1.32.0", + "lightningcss-linux-arm-gnueabihf": "1.32.0", + "lightningcss-linux-arm64-gnu": "1.32.0", + "lightningcss-linux-arm64-musl": "1.32.0", + "lightningcss-linux-x64-gnu": "1.32.0", + "lightningcss-linux-x64-musl": "1.32.0", + "lightningcss-win32-arm64-msvc": "1.32.0", + "lightningcss-win32-x64-msvc": "1.32.0" + } + }, + "node_modules/lightningcss-android-arm64": { + "version": "1.32.0", + "resolved": "https://registry.npmjs.org/lightningcss-android-arm64/-/lightningcss-android-arm64-1.32.0.tgz", + "integrity": "sha512-YK7/ClTt4kAK0vo6w3X+Pnm0D2cf2vPHbhOXdoNti1Ga0al1P4TBZhwjATvjNwLEBCnKvjJc2jQgHXH0NEwlAg==", + "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.32.0", + "resolved": "https://registry.npmjs.org/lightningcss-darwin-arm64/-/lightningcss-darwin-arm64-1.32.0.tgz", + "integrity": "sha512-RzeG9Ju5bag2Bv1/lwlVJvBE3q6TtXskdZLLCyfg5pt+HLz9BqlICO7LZM7VHNTTn/5PRhHFBSjk5lc4cmscPQ==", + "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.32.0", + "resolved": "https://registry.npmjs.org/lightningcss-darwin-x64/-/lightningcss-darwin-x64-1.32.0.tgz", + "integrity": "sha512-U+QsBp2m/s2wqpUYT/6wnlagdZbtZdndSmut/NJqlCcMLTWp5muCrID+K5UJ6jqD2BFshejCYXniPDbNh73V8w==", + "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.32.0", + "resolved": "https://registry.npmjs.org/lightningcss-freebsd-x64/-/lightningcss-freebsd-x64-1.32.0.tgz", + "integrity": "sha512-JCTigedEksZk3tHTTthnMdVfGf61Fky8Ji2E4YjUTEQX14xiy/lTzXnu1vwiZe3bYe0q+SpsSH/CTeDXK6WHig==", + "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.32.0", + "resolved": "https://registry.npmjs.org/lightningcss-linux-arm-gnueabihf/-/lightningcss-linux-arm-gnueabihf-1.32.0.tgz", + "integrity": "sha512-x6rnnpRa2GL0zQOkt6rts3YDPzduLpWvwAF6EMhXFVZXD4tPrBkEFqzGowzCsIWsPjqSK+tyNEODUBXeeVHSkw==", + "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.32.0", + "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-gnu/-/lightningcss-linux-arm64-gnu-1.32.0.tgz", + "integrity": "sha512-0nnMyoyOLRJXfbMOilaSRcLH3Jw5z9HDNGfT/gwCPgaDjnx0i8w7vBzFLFR1f6CMLKF8gVbebmkUN3fa/kQJpQ==", + "cpu": [ + "arm64" + ], + "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-musl": { + "version": "1.32.0", + "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-musl/-/lightningcss-linux-arm64-musl-1.32.0.tgz", + "integrity": "sha512-UpQkoenr4UJEzgVIYpI80lDFvRmPVg6oqboNHfoH4CQIfNA+HOrZ7Mo7KZP02dC6LjghPQJeBsvXhJod/wnIBg==", + "cpu": [ + "arm64" + ], + "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-x64-gnu": { + "version": "1.32.0", + "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-gnu/-/lightningcss-linux-x64-gnu-1.32.0.tgz", + "integrity": "sha512-V7Qr52IhZmdKPVr+Vtw8o+WLsQJYCTd8loIfpDaMRWGUZfBOYEJeyJIkqGIDMZPwPx24pUMfwSxxI8phr/MbOA==", + "cpu": [ + "x64" + ], + "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-x64-musl": { + "version": "1.32.0", + "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-musl/-/lightningcss-linux-x64-musl-1.32.0.tgz", + "integrity": "sha512-bYcLp+Vb0awsiXg/80uCRezCYHNg1/l3mt0gzHnWV9XP1W5sKa5/TCdGWaR/zBM2PeF/HbsQv/j2URNOiVuxWg==", + "cpu": [ + "x64" + ], + "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-win32-arm64-msvc": { + "version": "1.32.0", + "resolved": "https://registry.npmjs.org/lightningcss-win32-arm64-msvc/-/lightningcss-win32-arm64-msvc-1.32.0.tgz", + "integrity": "sha512-8SbC8BR40pS6baCM8sbtYDSwEVQd4JlFTOlaD3gWGHfThTcABnNDBda6eTZeqbofalIJhFx0qKzgHJmcPTnGdw==", + "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.32.0", + "resolved": "https://registry.npmjs.org/lightningcss-win32-x64-msvc/-/lightningcss-win32-x64-msvc-1.32.0.tgz", + "integrity": "sha512-Amq9B/SoZYdDi1kFrojnoqPLxYhQ4Wo5XiL8EVJrVsB8ARoC1PWW6VGtT0WKCemjy8aC+louJnjS7U18x3b06Q==", + "cpu": [ + "x64" + ], + "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/locate-path": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz", + "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==", + "dev": true, + "license": "MIT", + "dependencies": { + "p-locate": "^5.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/lru-cache": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz", + "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==", + "dev": true, + "license": "ISC", + "dependencies": { + "yallist": "^3.0.2" + } + }, + "node_modules/lucide-react": { + "version": "1.49.0", + "resolved": "https://registry.npmjs.org/lucide-react/-/lucide-react-1.49.0.tgz", + "integrity": "sha512-ApfaNM4/7jBrVopqLJ84Jz8TMQ1Q1JeZ1PmKh25aeS3E1FTVcMkSh1bEQB7dfzdIrwXRP8p3z4AJjTIHHb5IIA==", + "license": "ISC", + "peerDependencies": { + "@types/react": "*", + "react": "^16.5.1 || ^17.0.0 || ^18.0.0 || ^19.0.0" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "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/minimatch": { + "version": "10.2.6", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.6.tgz", + "integrity": "sha512-vpLQEs+VLCr1nU0BXS07maYoFwlDAH0gngQuuttxIwutDFEMHq2blX+8vpgxDdK3J1PwjCJiep77OitTZ4Ll1A==", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "brace-expansion": "^5.0.8" + }, + "engines": { + "node": "18 || 20 || >=22" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "dev": true, + "license": "MIT" + }, + "node_modules/nanoid": { + "version": "3.3.19", + "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.19.tgz", + "integrity": "sha512-Y2tUNy4ouw6tq5oDSKeQYGOyhkUBhNOcGV/02KC+6kd9eDGqdZd++mjMiIDilrBYvjEnCYvVtsuHCuP+okSfug==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "bin": { + "nanoid": "bin/nanoid.cjs" + }, + "engines": { + "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1" + } + }, + "node_modules/natural-compare": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz", + "integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==", + "dev": true, + "license": "MIT" + }, + "node_modules/next-themes": { + "version": "0.4.6", + "resolved": "https://registry.npmjs.org/next-themes/-/next-themes-0.4.6.tgz", + "integrity": "sha512-pZvgD5L0IEvX5/9GWyHMf3m8BKiVQwsCMHfoFosXtXBMnaS0ZnIJ9ST4b4NqLVKDEm8QBxoNNGNaBv2JNF6XNA==", + "license": "MIT", + "peerDependencies": { + "react": "^16.8 || ^17 || ^18 || ^19 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17 || ^18 || ^19 || ^19.0.0-rc" + } + }, + "node_modules/node-releases": { + "version": "2.0.57", + "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.57.tgz", + "integrity": "sha512-kQK9LGGFiHtrWiNhZtA7Qbw17AQz+dmsEKODRIVTXA9+e5MS/2gZEBhYJt13GrAz5/IOZKddH/0Z3TP/Zgo+yw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + } + }, + "node_modules/obug": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/obug/-/obug-2.2.1.tgz", + "integrity": "sha512-XrsrhT5sybtKI6wakr2SPOlGZWWYbUXZ7a0jT8/QOeAPau+1X/bSegNe5YR75oJmEZQbKningirmGOEJCIk61Q==", + "dev": true, + "funding": [ + "https://github.com/sponsors/sxzz", + "https://opencollective.com/debug" + ], + "license": "MIT", + "engines": { + "node": ">=12.20.0" + } + }, + "node_modules/optionator": { + "version": "0.9.4", + "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz", + "integrity": "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==", + "dev": true, + "license": "MIT", + "dependencies": { + "deep-is": "^0.1.3", + "fast-levenshtein": "^2.0.6", + "levn": "^0.4.1", + "prelude-ls": "^1.2.1", + "type-check": "^0.4.0", + "word-wrap": "^1.2.5" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/p-limit": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", + "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "yocto-queue": "^0.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/p-locate": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz", + "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==", + "dev": true, + "license": "MIT", + "dependencies": { + "p-limit": "^3.0.2" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/path-exists": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", + "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/path-key": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz", + "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/picocolors": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz", + "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==", + "dev": true, + "license": "ISC" + }, + "node_modules/picomatch": { + "version": "4.0.7", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.7.tgz", + "integrity": "sha512-qcJu88Q2IWqJsDD529JKMdwGm/dvInW4HvQnRwiH9JtihJvzGOscDtHE3x1pBKeUOTysQ8kVmLnJ2kJu7yhcGA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/playwright": { + "version": "1.63.0", + "resolved": "https://registry.npmjs.org/playwright/-/playwright-1.63.0.tgz", + "integrity": "sha512-+7ziBLidS4NaNCdt57SUDT+wYmmd5fmiQejUic/kb+YsYSCPyOOE9sebzMjNmQrsnNpDJqd4WHvV/8lfKfUDUg==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "playwright-core": "1.63.0" + }, + "bin": { + "playwright": "cli.js" + }, + "engines": { + "node": ">=20" + } + }, + "node_modules/playwright-core": { + "version": "1.63.0", + "resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.63.0.tgz", + "integrity": "sha512-rYCsBF/M5HjUch52bbtVONEFjv6Xu8sm8h72dNlR5bzIE1fvC/bxgspzkjSfU+MweEMmPM8KJebG6nnyxo5mCg==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "playwright-core": "cli.js" + }, + "engines": { + "node": ">=20" + } + }, + "node_modules/postcss": { + "version": "8.5.28", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.28.tgz", + "integrity": "sha512-RRuzqDtt5Y9h3quz5hWhK+TPnsmVs6WwSU6LkJMeY4HstUEDuYTG8UJSdawMRzmzAtV+KEoG8N3Qg2qLy5vM/A==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/postcss" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "nanoid": "^3.3.18", + "picocolors": "^1.1.1", + "source-map-js": "^1.2.1" + }, + "engines": { + "node": "^10 || ^12 || >=14" + } + }, + "node_modules/prelude-ls": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz", + "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/prettier": { + "version": "3.9.9", + "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.9.9.tgz", + "integrity": "sha512-Z/CJHIkdujO/OtN7nXUii0Rf3VT5SRuhjBA82Xvu2XhBUgX3nhP67T0LHceBdQLex7OOFGTox+Q5Yg8Jk2Qivg==", + "dev": true, + "license": "MIT", + "bin": { + "prettier": "bin/prettier.cjs" + }, + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/prettier/prettier?sponsor=1" + } + }, + "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/qified": { + "version": "0.10.1", + "resolved": "https://registry.npmjs.org/qified/-/qified-0.10.1.tgz", + "integrity": "sha512-+Owyggi9IxT1ePKGafcI87ubSmxol6smwJ+RAHDQlx9+9cPwFWDiKFFCPuWhr9ignlGpZ9vDQLw67N4dcTVFEA==", + "dev": true, + "license": "MIT", + "dependencies": { + "hookified": "^2.1.1" + }, + "engines": { + "node": ">=20" + } + }, + "node_modules/qified/node_modules/hookified": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/hookified/-/hookified-2.2.0.tgz", + "integrity": "sha512-p/LgFzRN5FeoD3DLS6bkUapeye6E4SI6yJs6KetENd18S+FBthqYq2amJUWpt5z0EQwwHemidjY5OqJGEKm5uA==", + "dev": true, + "license": "MIT" + }, + "node_modules/radix-ui": { + "version": "1.6.7", + "resolved": "https://registry.npmjs.org/radix-ui/-/radix-ui-1.6.7.tgz", + "integrity": "sha512-QBdhh1arIEUvPC0dQ5+nwWAxt7+N+oP/9jPwjJkGFoSk/sqxg32gJtSXGtFh8frAIcS6oC9cx2Q+7KYCQLOAeA==", + "license": "MIT", + "dependencies": { + "@radix-ui/primitive": "1.1.7", + "@radix-ui/react-accessible-icon": "1.1.15", + "@radix-ui/react-accordion": "1.2.20", + "@radix-ui/react-alert-dialog": "1.1.23", + "@radix-ui/react-arrow": "1.1.15", + "@radix-ui/react-aspect-ratio": "1.1.15", + "@radix-ui/react-avatar": "1.2.6", + "@radix-ui/react-checkbox": "1.3.11", + "@radix-ui/react-collapsible": "1.1.20", + "@radix-ui/react-collection": "1.1.15", + "@radix-ui/react-compose-refs": "1.1.5", + "@radix-ui/react-context": "1.2.2", + "@radix-ui/react-context-menu": "2.3.7", + "@radix-ui/react-dialog": "1.1.23", + "@radix-ui/react-direction": "1.1.4", + "@radix-ui/react-dismissable-layer": "1.1.19", + "@radix-ui/react-dropdown-menu": "2.1.24", + "@radix-ui/react-focus-guards": "1.1.6", + "@radix-ui/react-focus-scope": "1.1.16", + "@radix-ui/react-form": "0.1.16", + "@radix-ui/react-hover-card": "1.1.23", + "@radix-ui/react-label": "2.1.15", + "@radix-ui/react-menu": "2.1.24", + "@radix-ui/react-menubar": "1.1.24", + "@radix-ui/react-navigation-menu": "1.2.22", + "@radix-ui/react-one-time-password-field": "0.1.16", + "@radix-ui/react-password-toggle-field": "0.1.11", + "@radix-ui/react-popover": "1.1.23", + "@radix-ui/react-popper": "1.3.7", + "@radix-ui/react-portal": "1.1.17", + "@radix-ui/react-presence": "1.1.10", + "@radix-ui/react-primitive": "2.1.10", + "@radix-ui/react-progress": "1.1.16", + "@radix-ui/react-radio-group": "1.4.7", + "@radix-ui/react-roving-focus": "1.1.19", + "@radix-ui/react-scroll-area": "1.2.18", + "@radix-ui/react-select": "2.3.7", + "@radix-ui/react-separator": "1.1.15", + "@radix-ui/react-slider": "1.4.7", + "@radix-ui/react-slot": "1.3.3", + "@radix-ui/react-switch": "1.3.7", + "@radix-ui/react-tabs": "1.1.21", + "@radix-ui/react-toast": "1.2.23", + "@radix-ui/react-toggle": "1.1.18", + "@radix-ui/react-toggle-group": "1.1.19", + "@radix-ui/react-toolbar": "1.1.19", + "@radix-ui/react-tooltip": "1.2.16", + "@radix-ui/react-use-callback-ref": "1.1.4", + "@radix-ui/react-use-controllable-state": "1.2.6", + "@radix-ui/react-use-effect-event": "0.0.5", + "@radix-ui/react-use-escape-keydown": "1.1.5", + "@radix-ui/react-use-is-hydrated": "0.1.3", + "@radix-ui/react-use-layout-effect": "1.1.4", + "@radix-ui/react-use-size": "1.1.4", + "@radix-ui/react-visually-hidden": "1.2.11" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/react": { + "version": "19.3.0", + "resolved": "https://registry.npmjs.org/react/-/react-19.3.0.tgz", + "integrity": "sha512-E8LUcbtBWt20bbl2YoHfx4ZDBdxVTfOKtCZn9cDSJ4l6/nuoApcpIBcj47t2wZoVX8g2ZHuMHbiShgCR1T5Sog==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/react-dom": { + "version": "19.3.0", + "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.3.0.tgz", + "integrity": "sha512-JDk8dgif51OjFoDE70+OT9ICyYr+69HlmihNwp1+Nsfbna3t5sIiCa9ZJktDmQ4/1b/rn26hIAR2uYXDMr5r0Q==", + "license": "MIT", + "dependencies": { + "scheduler": "^0.28.0" + }, + "peerDependencies": { + "react": "^19.3.0" + } + }, + "node_modules/react-is": { + "version": "19.3.0", + "resolved": "https://registry.npmjs.org/react-is/-/react-is-19.3.0.tgz", + "integrity": "sha512-UpMYezM4v5/18F28aC66AEsjXIgE02kyEMH6yLdgLXu/UTfa1Ntwck/nNLrbqJsEXW7gPb0coNO9FQse9WTovA==", + "license": "MIT", + "peer": true + }, + "node_modules/react-redux": { + "version": "9.3.0", + "resolved": "https://registry.npmjs.org/react-redux/-/react-redux-9.3.0.tgz", + "integrity": "sha512-KQopgqFo/p/fgmAs5qz6p5RWaNAzq40WAu7fJIXnQpYxFPbJYtsJPWvGeF2rOBaY/kEuV77AVsX8TsQzKm+A/g==", + "license": "MIT", + "dependencies": { + "@types/use-sync-external-store": "^0.0.6", + "use-sync-external-store": "^1.4.0" + }, + "peerDependencies": { + "@types/react": "^18.2.25 || ^19", + "react": "^18.0 || ^19", + "redux": "^5.0.0" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "redux": { + "optional": true + } + } + }, + "node_modules/react-remove-scroll": { + "version": "2.7.2", + "resolved": "https://registry.npmjs.org/react-remove-scroll/-/react-remove-scroll-2.7.2.tgz", + "integrity": "sha512-Iqb9NjCCTt6Hf+vOdNIZGdTiH1QSqr27H/Ek9sv/a97gfueI/5h1s3yRi1nngzMUaOOToin5dI1dXKdXiF+u0Q==", + "license": "MIT", + "dependencies": { + "react-remove-scroll-bar": "^2.3.7", + "react-style-singleton": "^2.2.3", + "tslib": "^2.1.0", + "use-callback-ref": "^1.3.3", + "use-sidecar": "^1.1.3" + }, + "engines": { + "node": ">=10" + }, + "peerDependencies": { + "@types/react": "*", + "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/react-remove-scroll-bar": { + "version": "2.3.8", + "resolved": "https://registry.npmjs.org/react-remove-scroll-bar/-/react-remove-scroll-bar-2.3.8.tgz", + "integrity": "sha512-9r+yi9+mgU33AKcj6IbT9oRCO78WriSj6t/cF8DWBZJ9aOGPOTEDvdUDz1FwKim7QXWwmHqtdHnRJfhAxEG46Q==", + "license": "MIT", + "dependencies": { + "react-style-singleton": "^2.2.2", + "tslib": "^2.0.0" + }, + "engines": { + "node": ">=10" + }, + "peerDependencies": { + "@types/react": "*", + "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/react-style-singleton": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/react-style-singleton/-/react-style-singleton-2.2.3.tgz", + "integrity": "sha512-b6jSvxvVnyptAiLjbkWLE/lOnR4lfTtDAl+eUC7RZy+QQWc6wRzIV2CE6xBuMmDxc2qIihtDCZD5NPOFl7fRBQ==", + "license": "MIT", + "dependencies": { + "get-nonce": "^1.0.0", + "tslib": "^2.0.0" + }, + "engines": { + "node": ">=10" + }, + "peerDependencies": { + "@types/react": "*", + "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/recharts": { + "version": "3.10.1", + "resolved": "https://registry.npmjs.org/recharts/-/recharts-3.10.1.tgz", + "integrity": "sha512-QXFrvt6IVcw7eeZCoyXTwkIJAX3Dv1nyVhMicXJ47GsGDDpcN8z6o644DibE9XjpBTThtsomLKnTV6lc+cVFUA==", + "license": "MIT", + "workspaces": [ + "www" + ], + "dependencies": { + "@reduxjs/toolkit": "^1.9.0 || 2.x.x", + "clsx": "^2.1.1", + "decimal.js-light": "^2.5.1", + "es-toolkit": "^1.39.3", + "eventemitter3": "^5.0.1", + "immer": "^11.1.8", + "react-redux": "8.x.x || 9.x.x", + "reselect": "5.2.0", + "tiny-invariant": "^1.3.3", + "use-sync-external-store": "^1.2.2", + "victory-vendor": "^37.0.2" + }, + "engines": { + "node": ">=18" + }, + "peerDependencies": { + "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", + "react-dom": "^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", + "react-is": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" + } + }, + "node_modules/recharts/node_modules/reselect": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/reselect/-/reselect-5.2.0.tgz", + "integrity": "sha512-AgZ3UOZm3YndfrJ4OYjgrT7bmCm/1iqkjvEfH/oYjzh6PD2qw4QuT3jjnXIrpdt4MTpMXclMT3lXbmRY+XRakw==", + "license": "MIT" + }, + "node_modules/redux": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/redux/-/redux-5.0.1.tgz", + "integrity": "sha512-M9/ELqF6fy8FwmkpnF0S3YKOqMyoWJ4+CS5Efg2ct3oY9daQvd/Pc71FpGZsVsbl3Cpb+IIcjBDUnnyBdQbq4w==", + "license": "MIT" + }, + "node_modules/redux-thunk": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/redux-thunk/-/redux-thunk-3.1.0.tgz", + "integrity": "sha512-NW2r5T6ksUKXCabzhL9z+h206HQw/NJkcLm1GPImRQ8IzfXwRGqjVhKJGauHirT0DAuyy6hjdnMZaRoAcy0Klw==", + "license": "MIT", + "peerDependencies": { + "redux": "^5.0.0" + } + }, + "node_modules/reselect": { + "version": "5.3.0", + "resolved": "https://registry.npmjs.org/reselect/-/reselect-5.3.0.tgz", + "integrity": "sha512-XGoLeRAVzUTcJ1qkxPQhDJyIZ5d6zzZD9nT7AEZOaaU9UbWclhycElmhO+VD5bFeLuzhPBaOV2oXC8uG35ZSpg==", + "license": "MIT" + }, + "node_modules/rolldown": { + "version": "1.2.12", + "resolved": "https://registry.npmjs.org/rolldown/-/rolldown-1.2.12.tgz", + "integrity": "sha512-8wafseiaG80xmXSfqidUNqZcylTlhmPZZt+za2m+js2sFZ8dTNlhIOV2WcbIPx2hgwPBJpEUGFAMZ9bgBBLTSQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@oxc-project/types": "=0.152.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.12", + "@rolldown/binding-android-arm64": "1.2.12", + "@rolldown/binding-darwin-arm64": "1.2.12", + "@rolldown/binding-darwin-x64": "1.2.12", + "@rolldown/binding-freebsd-x64": "1.2.12", + "@rolldown/binding-linux-arm-gnueabihf": "1.2.12", + "@rolldown/binding-linux-arm64-gnu": "1.2.12", + "@rolldown/binding-linux-arm64-musl": "1.2.12", + "@rolldown/binding-linux-ppc64-gnu": "1.2.12", + "@rolldown/binding-linux-s390x-gnu": "1.2.12", + "@rolldown/binding-linux-x64-gnu": "1.2.12", + "@rolldown/binding-linux-x64-musl": "1.2.12", + "@rolldown/binding-openharmony-arm64": "1.2.12", + "@rolldown/binding-win32-arm64-msvc": "1.2.12", + "@rolldown/binding-win32-x64-msvc": "1.2.12" + } + }, + "node_modules/scheduler": { + "version": "0.28.0", + "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.28.0.tgz", + "integrity": "sha512-juorfCmIkIw8tT+p5BXSm6PJjQF/ycEYmKyzURCIt/RaZIhL+PulbQ9Yu2z1HdOJDdqDTlxA1+xKBmHXJsczAw==", + "license": "MIT" + }, + "node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/shebang-command": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz", + "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==", + "dev": true, + "license": "MIT", + "dependencies": { + "shebang-regex": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/shebang-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz", + "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/sonner": { + "version": "2.0.8", + "resolved": "https://registry.npmjs.org/sonner/-/sonner-2.0.8.tgz", + "integrity": "sha512-UM/ByIoFra8yzV75n1o0Puu0bw5U/9UNnDacrJNspekBewIfsQ3D6ez1nvlWpt7aTsO6rujQtifBpycwIivqlg==", + "license": "MIT", + "peerDependencies": { + "@types/react": "^18.0.0 || ^19.0.0", + "react": "^18.0.0 || ^19.0.0 || ^19.0.0-rc", + "react-dom": "^18.0.0 || ^19.0.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/source-map-js": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.2.tgz", + "integrity": "sha512-KGj/8Y43x35aZVDtt+J4mK1hoLGHULMYfSkODJNQjNDC3oW1PqPoxMwo0pLUsWM/UEGzON/NxeHywEfNXNP3Vw==", + "dev": true, + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/std-env": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/std-env/-/std-env-4.3.0.tgz", + "integrity": "sha512-OtU/EgQ1kIm5KwqQpBC6ZEMXrZRui11w8zgfTWp8cdO9B8OaPsbA8bTHO2P+HNo1VlUTGMVBwPhydu6poeXiag==", + "dev": true, + "license": "MIT" + }, + "node_modules/tailwind-merge": { + "version": "3.7.0", + "resolved": "https://registry.npmjs.org/tailwind-merge/-/tailwind-merge-3.7.0.tgz", + "integrity": "sha512-XPPUyAc+cvspz3lHTcR/QgPfW2A0lv/xQNIjX3HGhLR+Nq2lHaLq5MtTesHn8GUr3W3DguT2KT5x3NVgRtYwmA==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/dcastil" + } + }, + "node_modules/tailwindcss": { + "version": "4.3.3", + "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-4.3.3.tgz", + "integrity": "sha512-gOhV3P7ufE62QDGg1zVaTgCR+EtPv92k2nIhVcVKcLmxT1sUBsQGhnZj175j+MqRt4zLF7ic+sCYjfhxMxj7YQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/tapable": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/tapable/-/tapable-2.3.3.tgz", + "integrity": "sha512-uxc/zpqFg6x7C8vOE7lh6Lbda8eEL9zmVm/PLeTPBRhh1xCgdWaQ+J1CUieGpIfm2HdtsUpRv+HshiasBMcc6A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + } + }, + "node_modules/tiny-invariant": { + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/tiny-invariant/-/tiny-invariant-1.3.3.tgz", + "integrity": "sha512-+FbBPE1o9QAYvviau/qC5SE3caw21q3xkvWKBtja5vgqOWIHHJ3ioaq1VPfn/Szqctz2bU/oYeKd9/z5BL+PVg==", + "license": "MIT" + }, + "node_modules/tinybench": { + "version": "6.2.0", + "resolved": "https://registry.npmjs.org/tinybench/-/tinybench-6.2.0.tgz", + "integrity": "sha512-78U2TlB2CnVenajOFzf3BKSm0J6oz5L0NV7g32LCPccvYc0lbWvys4d3uUUCS2B1N8PAf2+aekR8i1KbC3HO7Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=20.0.0" + } + }, + "node_modules/tinyexec": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-1.3.1.tgz", + "integrity": "sha512-GCvB3aoys96IuDFBMcTB46JOR6mdMtAToqwiW8JlWhsoh1mhHi/xn9ss/Dg7N555GiJyEt2qzoG/NHCwM6h1EA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + } + }, + "node_modules/tinyglobby": { + "version": "0.2.17", + "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.17.tgz", + "integrity": "sha512-wXR/dYpcqKmfWpEdZjiKJOwCNFndD0DMnrW/cYjVGttEkBfVgcLFHoNrlj47mjOVic9yyNu65alsgF4NQyTa2g==", + "dev": true, + "license": "MIT", + "dependencies": { + "fdir": "^6.5.0", + "picomatch": "^4.0.4" + }, + "engines": { + "node": ">=12.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/SuperchupuDev" + } + }, + "node_modules/ts-api-utils": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/ts-api-utils/-/ts-api-utils-2.5.0.tgz", + "integrity": "sha512-OJ/ibxhPlqrMM0UiNHJ/0CKQkoKF243/AEmplt3qpRgkW8VG7IfOS41h7V8TjITqdByHzrjcS/2si+y4lIh8NA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18.12" + }, + "peerDependencies": { + "typescript": ">=4.8.4" + } + }, + "node_modules/tslib": { + "version": "2.8.1", + "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz", + "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==", + "license": "0BSD" + }, + "node_modules/tw-animate-css": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/tw-animate-css/-/tw-animate-css-1.4.0.tgz", + "integrity": "sha512-7bziOlRqH0hJx80h/3mbicLW7o8qLsH5+RaLR2t+OHM3D0JlWGODQKQ4cxbK7WlvmUxpcj6Kgu6EKqjrGFe3QQ==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/Wombosvideo" + } + }, + "node_modules/type-check": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz", + "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==", + "dev": true, + "license": "MIT", + "dependencies": { + "prelude-ls": "^1.2.1" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/typescript": { + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-6.0.3.tgz", + "integrity": "sha512-y2TvuxSZPDyQakkFRPZHKFm+KKVqIisdg9/CZwm9ftvKXLP8NRWj38/ODjNbr43SsoXqNuAisEf1GdCxqWcdBw==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=14.17" + } + }, + "node_modules/typescript-eslint": { + "version": "8.71.0", + "resolved": "https://registry.npmjs.org/typescript-eslint/-/typescript-eslint-8.71.0.tgz", + "integrity": "sha512-fBdHYiqQ14RW6mOMXD14Svn82ZsCYAoQSzGRzyEjR59S5A2Krh/l7fGTOQ7iCr8gGy/mHVXtEF7s5fgjEdV0Pw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/eslint-plugin": "8.71.0", + "@typescript-eslint/parser": "8.71.0", + "@typescript-eslint/typescript-estree": "8.71.0", + "@typescript-eslint/utils": "8.71.0" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0", + "typescript": ">=4.8.4 <6.1.0" + } + }, + "node_modules/undici-types": { + "version": "8.9.0", + "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-8.9.0.tgz", + "integrity": "sha512-KTDyRTYX8sWmKXAikPHHSyc63CRPETMctyjKFupcC6OBLXT3xsN0e9aF7m+mIXutFWpUXuedtowG7iLOzp0kQg==", + "dev": true, + "license": "MIT" + }, + "node_modules/update-browserslist-db": { + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.3.3.tgz", + "integrity": "sha512-pJ2sYawQS0R/WI928Gj5GlPhTGzbMelq0+4INtSYNDV9ErKJcX6xjGWkoG/VnB3dpUm00zALaqkrUD77pO5TDQ==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/browserslist" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "escalade": "^3.2.0", + "picocolors": "^1.1.1" + }, + "bin": { + "update-browserslist-db": "cli.js" + }, + "peerDependencies": { + "browserslist": ">= 4.21.0" + } + }, + "node_modules/uri-js": { + "version": "4.4.1", + "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz", + "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "punycode": "^2.1.0" + } + }, + "node_modules/use-callback-ref": { + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/use-callback-ref/-/use-callback-ref-1.3.3.tgz", + "integrity": "sha512-jQL3lRnocaFtu3V00JToYz/4QkNWswxijDaCVNZRiRTO3HQDLsdu1ZtmIUvV4yPp+rvWm5j0y0TG/S61cuijTg==", + "license": "MIT", + "dependencies": { + "tslib": "^2.0.0" + }, + "engines": { + "node": ">=10" + }, + "peerDependencies": { + "@types/react": "*", + "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/use-sidecar": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/use-sidecar/-/use-sidecar-1.1.3.tgz", + "integrity": "sha512-Fedw0aZvkhynoPYlA5WXrMCAMm+nSWdZt6lzJQ7Ok8S6Q+VsHmHpRWndVRJ8Be0ZbkfPc5LRYH+5XrzXcEeLRQ==", + "license": "MIT", + "dependencies": { + "detect-node-es": "^1.1.0", + "tslib": "^2.0.0" + }, + "engines": { + "node": ">=10" + }, + "peerDependencies": { + "@types/react": "*", + "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/use-sync-external-store": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/use-sync-external-store/-/use-sync-external-store-1.7.0.tgz", + "integrity": "sha512-6L+EeigHMQhdaIPNIFUKwfWJSwWFQ8gJbJ2DLOs5sDIegTwR9fRxvnM3uciHKjIZhFz+KAv2emhWMRvDmMcY8A==", + "license": "MIT", + "peerDependencies": { + "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" + } + }, + "node_modules/victory-vendor": { + "version": "37.3.6", + "resolved": "https://registry.npmjs.org/victory-vendor/-/victory-vendor-37.3.6.tgz", + "integrity": "sha512-SbPDPdDBYp+5MJHhBCAyI7wKM3d5ivekigc2Dk2s7pgbZ9wIgIBYGVw4zGHBml/qTFbexrofXW6Gu4noGxrOwQ==", + "license": "MIT AND ISC", + "dependencies": { + "@types/d3-array": "^3.0.3", + "@types/d3-ease": "^3.0.0", + "@types/d3-interpolate": "^3.0.1", + "@types/d3-scale": "^4.0.2", + "@types/d3-shape": "^3.1.0", + "@types/d3-time": "^3.0.0", + "@types/d3-timer": "^3.0.0", + "d3-array": "^3.1.6", + "d3-ease": "^3.0.1", + "d3-interpolate": "^3.0.1", + "d3-scale": "^4.0.2", + "d3-shape": "^3.1.0", + "d3-time": "^3.0.0", + "d3-timer": "^3.0.1" + } + }, + "node_modules/vite": { + "version": "8.3.1", + "resolved": "https://registry.npmjs.org/vite/-/vite-8.3.1.tgz", + "integrity": "sha512-/bvH9E9tmCXRGp2uXY3WbOldqpTwFkbha/8ANaEQ6VkxhH60KyqLwgZq6lG2y+4uT55x9+9eUHMpQ7uGnOCKjA==", + "dev": true, + "license": "MIT", + "dependencies": { + "lightningcss": "^1.33.0", + "picomatch": "^4.0.7", + "postcss": "^8.5.28", + "rolldown": "~1.2.9", + "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.7.1", + "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/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/vite/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/vite/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/vite/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/vite/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/vite/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/vite/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, + "license": "MPL-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/vite/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, + "license": "MPL-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/vite/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, + "license": "MPL-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/vite/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, + "license": "MPL-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/vite/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/vite/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": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/vitest": { + "version": "5.0.3", + "resolved": "https://registry.npmjs.org/vitest/-/vitest-5.0.3.tgz", + "integrity": "sha512-xMw97S3rjdtj5dkVat7jCsqWBpvchs3RlpQctUqwJD0KkERk40vz2fJ77lDwW/Vzh/pk18eItYAzkodhSes3jQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/chai": "^5.2.2", + "@vitest/mocker": "5.0.3", + "chai": "^6.2.2", + "es-module-lexer": "^2.3.2", + "expect-type": "^1.4.0", + "magic-string": "^1.2.3", + "obug": "^2.1.4", + "picomatch": "^4.0.7", + "std-env": "^4.2.0", + "tinybench": "^6.1.4", + "tinyexec": "^1.3.0", + "tinyglobby": "^0.2.17", + "why-is-node-running": "3.2.1" + }, + "bin": { + "vitest": "vitest.mjs" + }, + "engines": { + "node": "^22.12.0 || ^24.0.0 || >=26.0.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + }, + "peerDependencies": { + "@edge-runtime/vm": "*", + "@opentelemetry/api": "^1.9.0", + "@types/node": "^22.0.0 || >=24.0.0", + "@vitest/browser-playwright": "5.0.3", + "@vitest/browser-preview": "5.0.3", + "@vitest/browser-webdriverio": "^5.0.0-beta.5 || >=5.0.0", + "@vitest/coverage-istanbul": "5.0.3", + "@vitest/coverage-v8": "5.0.3", + "@vitest/ui": "5.0.3", + "happy-dom": "*", + "jsdom": "*", + "vite": "^6.4.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/vitest/node_modules/magic-string": { + "version": "1.4.2", + "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-1.4.2.tgz", + "integrity": "sha512-vG+rjFRj1PqdIBozIxAGMjPlOhaVe+GXpbttY/iSK7rGcJRMlwNJO7dcUwmUqkymsFLJiNGI06t4D7Fr7yRC9g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/sourcemap-codec": "^1.6.0" + } + }, + "node_modules/which": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz", + "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==", + "dev": true, + "license": "ISC", + "dependencies": { + "isexe": "^2.0.0" + }, + "bin": { + "node-which": "bin/node-which" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/why-is-node-running": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/why-is-node-running/-/why-is-node-running-3.2.1.tgz", + "integrity": "sha512-Tb2FUhB4vUsGQlfSquQLYkApkuPAFQXGFzxWKHHumVz2dK+X1RUm/HnID4+TfIGYJ1kTcwOaCk/buYCEJr6YjQ==", + "dev": true, + "license": "MIT", + "bin": { + "why-is-node-running": "cli.js" + }, + "engines": { + "node": ">=20.11" + } + }, + "node_modules/word-wrap": { + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz", + "integrity": "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/yallist": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz", + "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==", + "dev": true, + "license": "ISC" + }, + "node_modules/yocto-queue": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz", + "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/zod": { + "version": "4.6.5", + "resolved": "https://registry.npmjs.org/zod/-/zod-4.6.5.tgz", + "integrity": "sha512-v5l/aFXZQeai4awLbOpSoHecE9UiMrnfx75tEXLjNonXVARxQ5mOeipTjROUchszUNCqnE+hqAMujRsRHsut2Q==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/colinhacks" + } + }, + "node_modules/zod-validation-error": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/zod-validation-error/-/zod-validation-error-4.0.2.tgz", + "integrity": "sha512-Q6/nZLe6jxuU80qb/4uJ4t5v2VEZ44lzQjPDhYJNztRQ4wyWc6VF3D3Kb/fAuPetZQnhS3hnajCf9CsWesghLQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18.0.0" + }, + "peerDependencies": { + "zod": "^3.25.0 || ^4.0.0" + } + } + } +} diff --git a/web/package.json b/web/package.json new file mode 100644 index 0000000..f586f99 --- /dev/null +++ b/web/package.json @@ -0,0 +1,45 @@ +{ + "name": "sparkplane-panel", + "private": true, + "version": "0.1.0", + "type": "module", + "scripts": { + "build": "tsc -b && vite build", + "check": "tsc -b && eslint .", + "test": "vitest run src", + "test:browser": "playwright test", + "dev": "vite --host 127.0.0.1" + }, + "dependencies": { + "class-variance-authority": "0.7.1", + "clsx": "2.1.1", + "lucide-react": "1.49.0", + "next-themes": "0.4.6", + "radix-ui": "1.6.7", + "react": "19.3.0", + "react-dom": "19.3.0", + "recharts": "3.10.1", + "sonner": "2.0.8", + "tailwind-merge": "3.7.0" + }, + "devDependencies": { + "@eslint/js": "10.0.1", + "@playwright/test": "1.63.0", + "@tailwindcss/vite": "4.3.3", + "@types/node": "26.6.3", + "@types/react": "19.3.0", + "@types/react-dom": "19.3.0", + "@vitejs/plugin-react": "6.1.1", + "eslint": "10.11.0", + "eslint-plugin-react-hooks": "7.1.1", + "eslint-plugin-react-refresh": "0.5.7", + "globals": "17.12.0", + "prettier": "3.9.9", + "tailwindcss": "4.3.3", + "tw-animate-css": "1.4.0", + "typescript": "6.0.3", + "typescript-eslint": "8.71.0", + "vite": "8.3.1", + "vitest": "5.0.3" + } +} diff --git a/web/playwright.config.ts b/web/playwright.config.ts new file mode 100644 index 0000000..9846967 --- /dev/null +++ b/web/playwright.config.ts @@ -0,0 +1,18 @@ +import { defineConfig, devices } from "@playwright/test"; +export default defineConfig({ + testDir: "tests", + fullyParallel: true, + use: { baseURL: "http://127.0.0.1:5173", trace: "retain-on-failure" }, + webServer: { + command: "npm run dev -- --port 5173 --strictPort", + url: "http://127.0.0.1:5173/panel/", + reuseExistingServer: false, + }, + projects: [ + { name: "desktop", use: { ...devices["Desktop Chrome"] } }, + { + name: "mobile", + use: { ...devices["iPhone 13"], defaultBrowserType: "chromium" }, + }, + ], +}); diff --git a/web/src/App.tsx b/web/src/App.tsx new file mode 100644 index 0000000..0c3d538 --- /dev/null +++ b/web/src/App.tsx @@ -0,0 +1,981 @@ +import { useEffect, useState } from "react"; +import { + Activity, + ArrowUpRight, + BarChart3, + Box, + ChevronDown, + Cpu, + LayoutDashboard, + LogOut, + Server, + Settings, + ShieldCheck, + Terminal, + Zap, +} from "lucide-react"; +import { Area, AreaChart, CartesianGrid, XAxis } from "recharts"; +import { toast } from "sonner"; +import { Button } from "@/components/ui/button"; +import { + Sidebar, + SidebarContent, + SidebarFooter, + SidebarGroup, + SidebarGroupContent, + SidebarHeader, + SidebarInset, + SidebarMenu, + SidebarMenuButton, + SidebarMenuItem, + SidebarProvider, + SidebarTrigger, + useSidebar, +} from "@/components/ui/sidebar"; +import { TooltipProvider } from "@/components/ui/tooltip"; +import { Toaster } from "@/components/ui/sonner"; +import { + Select, + SelectContent, + SelectItem, + SelectTrigger, + SelectValue, +} from "@/components/ui/select"; +import { + DropdownMenu, + DropdownMenuContent, + DropdownMenuItem, + DropdownMenuLabel, + DropdownMenuTrigger, +} from "@/components/ui/dropdown-menu"; +import { + ChartContainer, + ChartTooltip, + ChartTooltipContent, +} from "@/components/ui/chart"; +import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs"; +import { + api, + ApiError, + count, + exportCsv, + money, + number, + object, + permits, + records, + setCsrf, + text, + useResource, + type Doc, + type Session, +} from "@/lib/api"; +import { + Card, + CardContent, + CardDescription, + CardHeader, + CardTitle, + Code, + DataTable, + ErrorNotice, + Loading, + Metric, + PageTitle, + Paginated, + StateBadge, +} from "@/components/panel"; +import { + AdminPage, + HealthPage, + InstancesPage, + ModelsPage, + OperationsPage, +} from "@/pages/managed"; + +const navigation = [ + { id: "overview", title: "Overview", icon: LayoutDashboard, scope: null }, + { + id: "analytics", + title: "Analytics", + icon: BarChart3, + scope: "analytics:read", + }, + { id: "models", title: "Models", icon: Box, scope: "models:read" }, + { + id: "instances", + title: "Instances", + icon: Server, + scope: "instances:read", + }, + { + id: "operations", + title: "Operations", + icon: Activity, + scope: "operations:read", + }, + { id: "health", title: "Health", icon: Cpu, scope: "analytics:read" }, + { id: "admin", title: "Administration", icon: Settings, scope: "admin" }, +]; +function Logo() { + return ( +
+
+ +
+ + Sparkplane. + +
+ ); +} + +function Login() { + const [ready, setReady] = useState(window.location.hash === "#local-auth"); + const [checking, setChecking] = useState(true); + useEffect(() => { + let active = true; + const controller = new AbortController(); + const check = async () => { + try { + const response = await fetch("http://127.0.0.1:9844/health", { + signal: AbortSignal.any([ + controller.signal, + AbortSignal.timeout(1200), + ]), + credentials: "omit", + cache: "no-store", + }); + const value = object(await response.json()); + if ( + active && + value.protocol === "sparkplane.webauth/v1" && + value.origin === window.location.origin + ) + setReady(true); + } catch { + /* A stopped helper and blocked local-network detection both use the redirect fallback. */ + } finally { + if (active) setChecking(false); + } + }; + void check(); + const timer = setInterval(() => { + if (document.visibilityState === "visible") void check(); + }, 2000); + return () => { + active = false; + controller.abort(); + clearInterval(timer); + }; + }, []); + return ( +
+
+ +
+
+ + +
+ +
+ Your Spark, one place. + + Models, operations and the economics of your AI workloads. + +
+ + {ready ? ( + <> +
+ + Local authentication service ready +
+ +

+ Uses your existing Sparkplane credential. The temporary local + service closes after login. +

+ + ) : ( + <> +

+ Start the local authentication service in a terminal on this + computer. +

+ +

+ {checking + ? "Checking for your local service…" + : "Waiting for the local service. Authenticate appears when it is detected."}{" "} + If your browser blocks detection, allow local-network access + or use the button below after starting the service. +

+ + + )} +
+ + + Open directly from your terminal + + +
+
+
+
+
+ Authenticated access · LAN / VPN · {window.location.host} +
+
+ ); +} + +function UsageChart({ series }: { series: Doc[] }) { + if (series.length === 0) + return ( +
+ Usage will appear after your first model request. +
+ ); + return ( + + + + String(value).slice(5)} + /> + } /> + + + + + ); +} +function UsageMetrics({ data }: { data: Doc }) { + const summary = object(data.summary), + rtk = object(data.rtk); + const requests = number(summary.requests), + failed = number(summary.failed_requests), + pending = number(summary.pending_requests); + return ( +
+ + 0 + ? `${count(summary.unpriced_requests)} requests without a verified same-model tariff` + : "Same models · public standard tariffs" + } + /> + 0 + ? `≈ ${count(rtk.estimated_saved_tokens)}` + : "—" + } + hint={`${count(rtk.covered_sessions)} sessions with valid client reports`} + /> + 0 + ? `${(((requests - failed - pending) / (requests - pending)) * 100).toFixed(1)}%` + : "—" + } + hint={`${count(requests)} requests · ${count(pending)} pending`} + /> +
+ ); +} +function Overview({ session }: { session: Session }) { + const usage = useResource( + permits(session, "analytics:read") ? "analytics?days=7" : null, + ); + const instances = useResource( + permits(session, "instances:read") ? "instances" : null, + 5000, + ); + const operations = useResource( + permits(session, "operations:read") ? "operations?view=summary" : null, + 5000, + ); + const status = useResource( + permits(session, "instances:read") ? "status" : null, + 10000, + ); + return ( +
+ + { + status.refresh(); + usage.refresh(); + instances.refresh(); + }} + /> + {usage.data ? ( + + ) : permits(session, "analytics:read") ? ( + + ) : ( + + + This credential does not include analytics access. + + + )} +
+ {permits(session, "analytics:read") && ( + + + Token activity + + Last seven days · reported input and output tokens + + + + + + + )} + + + Appliance status + + {permits(session, "instances:read") + ? window.location.host + : "Instance status is outside this credential’s permissions."} + + + +
+ Agent + +
+
+ Executor + +
+
+ + Healthy instances + + + {instances.data + ? records(instances.data.instances).filter( + (row) => row.healthy, + ).length + : "—"} + +
+ {records(status.data?.degraded_reasons).map((reason, index) => ( +

+ {text(reason.detail)} +

+ ))} +

+ Cloud-equivalent cost estimates what reported usage would cost at + public tariffs for the same models. RTK estimates are shown + separately. +

+
+
+
+ {permits(session, "operations:read") && ( + + + Recent operations + + Progress survives browser reloads and disconnects. + + + + , + }, + { + key: "updated_at", + label: "Updated", + render: (row) => + new Date(text(row.updated_at)).toLocaleString(), + }, + ]} + /> + + + )} +
+ ); +} +function Analytics() { + const initial = new URLSearchParams(window.location.search); + const [days, setDays] = useState(initial.get("days") ?? "7"); + const [model, setModel] = useState(initial.get("model") ?? "all"); + const [dimension, setDimension] = useState("model"); + const [filters, setFilters] = useState(() => + Object.fromEntries( + ["instance", "token", "integration", "session"].map((key) => [ + key, + initial.get(key) ?? "", + ]), + ), + ); + const query = new URLSearchParams({ days }); + if (model !== "all") query.set("model", model); + for (const [key, value] of Object.entries(filters)) + if (value) query.set(key, value); + const queryText = query.toString(); + const resource = useResource(`analytics?${queryText}`); + const previous = useResource(`analytics?${queryText}&previous=true`); + useEffect(() => { + const url = new URL(window.location.href); + url.search = queryText; + window.history.replaceState(null, "", url); + }, [queryText]); + const summary = object(resource.data?.summary), + rtk = object(resource.data?.rtk); + const catalog = object(resource.data?.catalog); + const tariffs = records(summary.comparisons).filter( + (row) => row.cloud_model != null, + ); + const breakdown = records(object(resource.data?.breakdown)[dimension]); + const requestChange = previous.data + ? number(summary.requests) - number(object(previous.data.summary).requests) + : null; + return ( +
+ + exportCsv( + records(resource.data?.series), + [ + "day", + "requests", + "input_tokens", + "output_tokens", + "unknown_usage_requests", + "failed_requests", + ], + "sparkplane-usage.csv", + ) + } + > + Export daily usage + + } + /> +
+ + +
+
+ {Object.entries(filters).map(([key, value]) => ( + + ))} +
+ + {resource.data ? ( + <> + +

+ {requestChange == null + ? "Previous period unavailable" + : `${requestChange >= 0 ? "+" : ""}${count(requestChange)} requests versus the previous period`}{" "} + · {count(summary.unknown_usage_requests)} requests with unknown + usage · {count(summary.accounting_errors)} incomplete accounting + records +

+
+ + + Token activity + + {text(resource.data.from)} → {text(resource.data.to)} · UTC + calendar days + + + + + + + + + Compression economics + Client-reported RTK estimates + + + +

+ {count(rtk.commands)} filtered commands.{" "} + {count(rtk.covered_sessions)} valid reports out of{" "} + {count(rtk.reported_sessions)} reported sessions. This + estimate is separate from cloud-equivalent inference cost. +

+ {tariffs.map((tariff) => ( + + {text(tariff.provider)} · {text(tariff.cloud_model)} · + verified {text(tariff.verified_at)} + + ))} + {number(rtk.unpriced_sessions) > 0 && ( +

+ {count(rtk.unpriced_sessions)} RTK sessions without a + verified same-model tariff. +

+ )} +

+ Catalog {text(catalog.version)} · standard uncached pricing. + Same model; cloud quantization may differ. Cache and reasoning + subdivisions are unavailable unless reported by the engine. +

+
+
+
+
+ + + +
+ + + Breakdown + Requests + Sessions + + + + count(row.requests), + }, + { + key: "input_tokens", + label: "Input tokens", + render: (row) => count(row.input_tokens), + }, + { + key: "output_tokens", + label: "Output tokens", + render: (row) => count(row.output_tokens), + }, + { key: "unknown_usage_requests", label: "Unknown usage" }, + ]} + /> + + + + + + + + +

+ Details are retained for 90 days; daily rollups for one year. Before + the panel upgrade, retained history covers launched sessions only. + No prompts, outputs or images are stored in analytics. +

+ + ) : ( + + )} +
+ ); +} + +function Panel({ session }: { session: Session }) { + return ( + + + + ); +} +function PanelLayout({ session }: { session: Session }) { + const { setOpenMobile } = useSidebar(); + const getPage = () => window.location.pathname.split("/")[2] || "overview"; + const [page, setPage] = useState(getPage); + const status = useResource( + permits(session, "instances:read") ? "status" : null, + 10000, + ); + useEffect(() => { + const pop = () => setPage(getPage()); + window.addEventListener("popstate", pop); + return () => window.removeEventListener("popstate", pop); + }, []); + const current = navigation.find((item) => item.id === page); + const allowed = + current && (!current.scope || permits(session, current.scope)); + const navigate = (value: string) => { + window.history.pushState(null, "", `/panel/${value}`); + setPage(value); + setOpenMobile(false); + window.scrollTo(0, 0); + }; + return ( + <> + + + + + + + + + {navigation + .filter((item) => !item.scope || permits(session, item.scope)) + .map((item) => ( + + + { + if ( + event.button === 0 && + !event.metaKey && + !event.ctrlKey + ) { + event.preventDefault(); + navigate(item.id); + } + }} + > + + {item.title} + + + + ))} + + + + + +
+ + + {!permits(session, "instances:read") + ? "DGX Spark · scoped view" + : status.error + ? "Connection interrupted" + : "DGX Spark · managed"} + +
+ + LOCAL INTELLIGENCE. VISIBLE VALUE. + +
+
+ +
+ + + Spark/ + {current?.title ?? "Panel"} + +
+
+ +
+ + + + + + + {session.token_id} + + { + void api("web-session", { method: "DELETE" }) + .then(() => { + setCsrf(null); + window.location.assign("/panel/"); + }) + .catch((error) => toast.error(String(error))); + }} + > + + Log out + + + +
+
+
+ {!allowed ? ( + + ) : page === "overview" ? ( + + ) : page === "analytics" ? ( + + ) : page === "models" ? ( + + ) : page === "instances" ? ( + + ) : page === "operations" ? ( + + ) : page === "health" ? ( + + ) : ( + + )} +
+
+ + ); +} +export default function App() { + const resource = useResource("web-session", 60000); + const refreshSession = resource.refresh; + useEffect(() => { + setCsrf(resource.data?.csrf ?? null); + }, [resource.data]); + useEffect(() => { + window.addEventListener("sparkplane:unauthenticated", refreshSession); + return () => + window.removeEventListener("sparkplane:unauthenticated", refreshSession); + }, [refreshSession]); + const unauthenticated = + resource.error instanceof ApiError && resource.error.status === 401; + return ( + + {resource.data && !unauthenticated ? ( + + ) : unauthenticated ? ( + + ) : ( +
+ +
+ + {resource.error && ( + + )} +
+
+ )} + +
+ ); +} diff --git a/web/src/components/panel.tsx b/web/src/components/panel.tsx new file mode 100644 index 0000000..e3ced49 --- /dev/null +++ b/web/src/components/panel.tsx @@ -0,0 +1,404 @@ +import { useRef, useState, type ReactNode } from "react"; +import { Copy, LoaderCircle, RefreshCw } from "lucide-react"; +import { toast } from "sonner"; +import { Button } from "@/components/ui/button"; +import { + Card, + CardContent, + CardDescription, + CardHeader, + CardTitle, +} from "@/components/ui/card"; +import { Badge } from "@/components/ui/badge"; +import { + Dialog, + DialogContent, + DialogDescription, + DialogFooter, + DialogHeader, + DialogTitle, + DialogTrigger, +} from "@/components/ui/dialog"; +import { Skeleton } from "@/components/ui/skeleton"; +import { + Table, + TableBody, + TableCell, + TableHead, + TableHeader, + TableRow, +} from "@/components/ui/table"; +import { api, records, text, useResource, type Doc } from "@/lib/api"; + +export function StateBadge({ value }: { value: unknown }) { + const state = text(value); + const good = [ + "healthy", + "succeeded", + "active", + "ready", + "running", + "ok", + ].includes(state); + const bad = [ + "failed", + "degraded", + "revoked", + "error", + "unavailable", + ].includes(state); + return ( + + {state.replaceAll("_", " ")} + + ); +} +export function Metric({ + title, + value, + hint, +}: { + title: string; + value: ReactNode; + hint: string; +}) { + return ( + + + {title} + + +
+ {value} +
+

{hint}

+
+
+ ); +} +export function ErrorNotice({ + error, + refresh, +}: { + error?: Error; + refresh?: () => void; +}) { + if (!error) return null; + return ( +
+ {error.message}. Previously loaded data may be stale. + {refresh && ( + + )} +
+ ); +} +export function Loading({ error }: { error?: Error }) { + return error ? ( + + ) : ( +
+ {[1, 2, 3].map((key) => ( + + ))} +
+ ); +} +export function JsonView({ value }: { value: unknown }) { + return ( +
+      {JSON.stringify(value, null, 2)}
+    
+ ); +} +export function Details({ + title, + value, + path, +}: { + title: string; + value?: unknown; + path?: string; +}) { + const [open, setOpen] = useState(false); + const resource = useResource(path && open ? path : null, 3000); + return ( + + + + + + + {title} + + Current managed appliance information. + + + {path ? ( + <> + + + + ) : ( + + )} + + + ); +} +export function Code({ value }: { value: string }) { + return ( +
+ + {value} + + +
+ ); +} +export function DataTable({ + rows, + columns, + actions, + empty = "No records in this period.", +}: { + rows: Doc[]; + columns: { key: string; label: string; render?: (row: Doc) => ReactNode }[]; + actions?: (row: Doc) => ReactNode; + empty?: string; +}) { + return ( +
+ + + + {columns.map((column) => ( + {column.label} + ))} + {actions && Actions} + + + + {rows.length === 0 ? ( + + + {empty} + + + ) : ( + rows.map((row, index) => ( + + {columns.map((column) => ( + + {column.render ? column.render(row) : text(row[column.key])} + + ))} + {actions && ( + +
{actions(row)}
+
+ )} +
+ )) + )} +
+
+
+ ); +} +export function Action({ + title, + description, + children, + prepare, + execute, + onDone, + danger = false, +}: { + title: string; + description: string; + children?: ReactNode; + prepare?: () => Promise; + execute: (key: string) => Promise; + onDone?: () => void; + danger?: boolean; +}) { + const [open, setOpen] = useState(false); + const [busy, setBusy] = useState(false); + const [preview, setPreview] = useState(); + const [error, setError] = useState(); + const key = useRef(""); + const act = async () => { + setBusy(true); + setError(undefined); + try { + if (prepare && preview === undefined) { + setPreview(await prepare()); + return; + } + const result = await execute(key.current); + const operation = result.id ?? result.operation_id; + toast.success( + operation + ? `Operation accepted: ${text(operation)}` + : "Action completed", + ); + onDone?.(); + setOpen(false); + } catch (error) { + setError(error instanceof Error ? error : new Error(String(error))); + } finally { + setBusy(false); + } + }; + return ( + { + setOpen(value); + if (value) { + key.current = crypto.randomUUID(); + setPreview(undefined); + setError(undefined); + } + }} + > + + + + + + {title} + {description} + + {preview === undefined ? ( +
{children}
+ ) : ( + + )} + + + + + +
+
+ ); +} +export function PageTitle({ + title, + description, + action, +}: { + title: string; + description: string; + action?: ReactNode; +}) { + return ( +
+
+

{title}

+

{description}

+
+ {action} +
+ ); +} +export function Paginated({ + path, + columns, +}: { + path: string; + columns: { key: string; label: string }[]; +}) { + const [offset, setOffset] = useState(0); + const resource = useResource( + `${path}${path.includes("?") ? "&" : "?"}offset=${offset}&limit=50`, + ); + return ( +
+ + {resource.data ? ( +
} + /> + ) : ( + + )} +
+ + +
+
+ ); +} +export { api, Card, CardContent, CardHeader, CardTitle, CardDescription }; diff --git a/web/src/components/ui/badge.tsx b/web/src/components/ui/badge.tsx new file mode 100644 index 0000000..eee82f0 --- /dev/null +++ b/web/src/components/ui/badge.tsx @@ -0,0 +1,47 @@ +import * as React from "react"; +import { cva, type VariantProps } from "class-variance-authority"; +import { cn } from "@/lib/utils"; +import { Slot } from "radix-ui"; + +const badgeVariants = cva( + "inline-flex w-fit shrink-0 items-center justify-center gap-1 overflow-hidden rounded-full border border-transparent px-2 py-0.5 text-xs font-medium whitespace-nowrap transition-[color,box-shadow] focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50 aria-invalid:border-destructive aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 [&>svg]:pointer-events-none [&>svg]:size-3", + { + variants: { + variant: { + default: "bg-primary text-primary-foreground [a&]:hover:bg-primary/90", + secondary: + "bg-secondary text-secondary-foreground [a&]:hover:bg-secondary/90", + destructive: + "bg-destructive text-white focus-visible:ring-destructive/20 dark:bg-destructive/60 dark:focus-visible:ring-destructive/40 [a&]:hover:bg-destructive/90", + outline: + "border-border text-foreground [a&]:hover:bg-accent [a&]:hover:text-accent-foreground", + ghost: "[a&]:hover:bg-accent [a&]:hover:text-accent-foreground", + link: "text-primary underline-offset-4 [a&]:hover:underline", + }, + }, + defaultVariants: { + variant: "default", + }, + }, +); + +function Badge({ + className, + variant = "default", + asChild = false, + ...props +}: React.ComponentProps<"span"> & + VariantProps & { asChild?: boolean }) { + const Comp = asChild ? Slot.Root : "span"; + + return ( + + ); +} + +export { Badge, badgeVariants }; diff --git a/web/src/components/ui/button.tsx b/web/src/components/ui/button.tsx new file mode 100644 index 0000000..7a9e60a --- /dev/null +++ b/web/src/components/ui/button.tsx @@ -0,0 +1,63 @@ +import * as React from "react"; +import { cva, type VariantProps } from "class-variance-authority"; +import { cn } from "@/lib/utils"; +import { Slot } from "radix-ui"; + +const buttonVariants = cva( + "inline-flex shrink-0 items-center justify-center gap-2 rounded-md text-sm font-medium whitespace-nowrap transition-all outline-none focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50 disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4", + { + variants: { + variant: { + default: "bg-primary text-primary-foreground hover:bg-primary/90", + destructive: + "bg-destructive text-white hover:bg-destructive/90 focus-visible:ring-destructive/20 dark:bg-destructive/60 dark:focus-visible:ring-destructive/40", + outline: + "border bg-background shadow-xs hover:bg-accent hover:text-accent-foreground dark:border-input dark:bg-input/30 dark:hover:bg-input/50", + secondary: + "bg-secondary text-secondary-foreground hover:bg-secondary/80", + ghost: + "hover:bg-accent hover:text-accent-foreground dark:hover:bg-accent/50", + link: "text-primary underline-offset-4 hover:underline", + }, + size: { + default: "h-9 px-4 py-2 has-[>svg]:px-3", + xs: "h-6 gap-1 rounded-md px-2 text-xs has-[>svg]:px-1.5 [&_svg:not([class*='size-'])]:size-3", + sm: "h-8 gap-1.5 rounded-md px-3 has-[>svg]:px-2.5", + lg: "h-10 rounded-md px-6 has-[>svg]:px-4", + icon: "size-9", + "icon-xs": "size-6 rounded-md [&_svg:not([class*='size-'])]:size-3", + "icon-sm": "size-8", + "icon-lg": "size-10", + }, + }, + defaultVariants: { + variant: "default", + size: "default", + }, + }, +); + +function Button({ + className, + variant = "default", + size = "default", + asChild = false, + ...props +}: React.ComponentProps<"button"> & + VariantProps & { + asChild?: boolean; + }) { + const Comp = asChild ? Slot.Root : "button"; + + return ( + + ); +} + +export { Button, buttonVariants }; diff --git a/web/src/components/ui/card.tsx b/web/src/components/ui/card.tsx new file mode 100644 index 0000000..e0bf47a --- /dev/null +++ b/web/src/components/ui/card.tsx @@ -0,0 +1,91 @@ +import * as React from "react"; +import { cn } from "@/lib/utils"; + +function Card({ className, ...props }: React.ComponentProps<"div">) { + return ( +
+ ); +} + +function CardHeader({ className, ...props }: React.ComponentProps<"div">) { + return ( +
+ ); +} + +function CardTitle({ className, ...props }: React.ComponentProps<"div">) { + return ( +
+ ); +} + +function CardDescription({ className, ...props }: React.ComponentProps<"div">) { + return ( +
+ ); +} + +function CardAction({ className, ...props }: React.ComponentProps<"div">) { + return ( +
+ ); +} + +function CardContent({ className, ...props }: React.ComponentProps<"div">) { + return ( +
+ ); +} + +function CardFooter({ className, ...props }: React.ComponentProps<"div">) { + return ( +
+ ); +} + +export { + Card, + CardHeader, + CardFooter, + CardTitle, + CardAction, + CardDescription, + CardContent, +}; diff --git a/web/src/components/ui/chart.tsx b/web/src/components/ui/chart.tsx new file mode 100644 index 0000000..1960b21 --- /dev/null +++ b/web/src/components/ui/chart.tsx @@ -0,0 +1,373 @@ +"use client"; + +import * as React from "react"; +import { cn } from "@/lib/utils"; +import * as RechartsPrimitive from "recharts"; +import type { TooltipValueType } from "recharts"; + +// Format: { THEME_NAME: CSS_SELECTOR } +const THEMES = { light: "", dark: ".dark" } as const; + +const INITIAL_DIMENSION = { width: 320, height: 200 } as const; +type TooltipNameType = number | string; + +export type ChartConfig = Record< + string, + { + label?: React.ReactNode; + icon?: React.ComponentType; + } & ( + | { color?: string; theme?: never } + | { color?: never; theme: Record } + ) +>; + +type ChartContextProps = { + config: ChartConfig; +}; + +const ChartContext = React.createContext(null); + +function useChart() { + const context = React.useContext(ChartContext); + + if (!context) { + throw new Error("useChart must be used within a "); + } + + return context; +} + +function ChartContainer({ + id, + className, + children, + config, + initialDimension = INITIAL_DIMENSION, + ...props +}: React.ComponentProps<"div"> & { + config: ChartConfig; + children: React.ComponentProps< + typeof RechartsPrimitive.ResponsiveContainer + >["children"]; + initialDimension?: { + width: number; + height: number; + }; +}) { + const uniqueId = React.useId(); + const chartId = `chart-${id ?? uniqueId.replace(/:/g, "")}`; + + return ( + +
+ + + {children} + +
+
+ ); +} + +const ChartStyle = ({ id, config }: { id: string; config: ChartConfig }) => { + const colorConfig = Object.entries(config).filter( + ([, config]) => config.theme ?? config.color, + ); + + if (!colorConfig.length) { + return null; + } + + return ( +