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 ( +