From ffe47644297552fe7f4f0a754819a1876bec6757 Mon Sep 17 00:00:00 2001 From: Wadi Date: Mon, 2 Nov 2026 18:29:37 +0100 Subject: [PATCH 1/9] feat: local API for the desktop app, with sections, categories and offline mode - workspace: categories and sections, each section a set of folders with its own index - library: background indexing with progress (one job at a time), pruning of deleted files while keeping documents of unplugged folders, answers scoped to a section or fused across a category (RRF, one rerank) - ore serve: FastAPI on 127.0.0.1 with a per-launch bearer token, loopback Host check and CORS for the app origin; answers stream as NDJSON; errors are RFC 9457 problem details - offline mode: telemetry off, no progress bars, HF_HUB_OFFLINE when every model is on disk - llm provider 'openai' for OpenAI-compatible local servers such as llama.cpp's llama-server - ADR-0007: WPF + WebView2 + React desktop app over the local engine API --- README.md | 2 + docs/adr/0007-desktop-app.md | 96 +++++++++++ docs/adr/README.md | 1 + pyproject.toml | 3 + src/open_rag_engine/api.py | 279 +++++++++++++++++++++++++++++++ src/open_rag_engine/cli.py | 68 +++++++- src/open_rag_engine/config.py | 2 + src/open_rag_engine/engine.py | 23 ++- src/open_rag_engine/factory.py | 20 ++- src/open_rag_engine/ingest.py | 78 ++++++--- src/open_rag_engine/library.py | 199 ++++++++++++++++++++++ src/open_rag_engine/offline.py | 50 ++++++ src/open_rag_engine/workspace.py | 162 ++++++++++++++++++ tests/test_api.py | 115 +++++++++++++ tests/test_engine_and_cli.py | 15 ++ tests/test_factory.py | 15 ++ tests/test_ingest.py | 28 ++++ tests/test_library.py | 139 +++++++++++++++ tests/test_offline.py | 35 ++++ tests/test_workspace.py | 70 ++++++++ uv.lock | 217 ++++++++++++++++++++++++ 21 files changed, 1588 insertions(+), 29 deletions(-) create mode 100644 docs/adr/0007-desktop-app.md create mode 100644 src/open_rag_engine/api.py create mode 100644 src/open_rag_engine/library.py create mode 100644 src/open_rag_engine/offline.py create mode 100644 src/open_rag_engine/workspace.py create mode 100644 tests/test_api.py create mode 100644 tests/test_factory.py create mode 100644 tests/test_library.py create mode 100644 tests/test_offline.py create mode 100644 tests/test_workspace.py diff --git a/README.md b/README.md index df448e8..c077327 100644 --- a/README.md +++ b/README.md @@ -47,6 +47,8 @@ Der Drucksensor PS-12 kostet 39 Euro [1]. | Cited answers that are checked, and abstention | `answer.py` | `[answer] min_rerank_score` | | Retrieval evaluation (hit rate, MRR, recall) | `evaluation.py` | `ore eval` | +`ore serve` runs the same engine as a local API for the desktop app (categories, sections, background indexing, streamed answers), reachable only from this machine. See [ADR-0007](docs/adr/0007-desktop-app.md). + Every setting lives in [`ore.toml`](examples/ore.toml). `--trace` shows what each stage returned and how long it took. ## What it will do diff --git a/docs/adr/0007-desktop-app.md b/docs/adr/0007-desktop-app.md new file mode 100644 index 0000000..0fb9674 --- /dev/null +++ b/docs/adr/0007-desktop-app.md @@ -0,0 +1,96 @@ +# ADR-0007: A Windows desktop app over a local engine API + +- **Status:** Proposed +- **Date:** 2026-11-02 +- **Deciders:** Wadi, Ghassen +- **Requirements:** D-01, D-02, D-06, D-10, C-03, C-04 + +## Context and problem + +Teachers, researchers and students want to ask questions about their own study material without sending it anywhere. They organise it in **categories** (a subject or research area) and **sections** (a course, session, project or reading list). Each section has its own folders, and an answer must come only from the section, or the category, they choose. Many of their laptops are offline or locked down, so the app must work with no network and ship as one self-contained installer. + +How do we build that app on top of the engine? + +## Decision drivers + +- Fully offline after installation, with nothing to configure (D-02, C-03). +- Runs on ordinary Windows laptops without a GPU (C-04). +- A modern, friendly interface: most users are not technical. +- Answers stay grounded and cited (D-06), and every source can be opened. +- The engine stays the single implementation of retrieval and answering (D-01). + +## Considered options + +1. **WPF shell with WebView2 and a React interface; the engine runs as a hidden child process with a loopback HTTP API.** +2. **Native WPF (XAML)**, calling the engine the same way. +3. **Electron or Tauri.** +4. **No app:** `ore serve` plus the user's browser. + +## Decision + +Option 1, the same structure as our Duet app. + +- **Shell (.NET, WPF).** It owns the window, the native dialogs (pick a folder, open a source file) and the engine's lifetime: + - It starts `ore serve` with a fresh random token in `ORE_API_TOKEN`, and reads the `ORE_READY port=` line. + - It ties the engine to a job object, so the engine dies with the app. `--parent-pid` is the backstop. +- **Interface (React and Tailwind, in WebView2).** + - It is served from the app's own files on a virtual host (`https://app.ore`), so it needs no network. + - It calls the engine's API directly, with the token the shell hands it, and streams answers as newline-delimited JSON. +- **Engine API (FastAPI, `ore serve`).** It is reachable only from this machine, through three guards: + 1. It binds to `127.0.0.1` and rejects any non-loopback `Host` header, which blocks DNS rebinding. + 2. Every request needs the per-launch bearer token. + 3. CORS allows only `https://app.ore`. + + Errors are problem details (RFC 9457) without stack traces or document content. +- **One index per section.** A section is one collection: a Chroma index plus BM25 chunks. + - A **category** question searches each section, fuses the lists with reciprocal rank fusion, and reranks the fused candidates once. + - Indexing runs in the background, one job at a time, and drops files that were deleted from the folders. + - It keeps the documents of folders that are temporarily missing, such as an unplugged USB drive. +- **Offline by construction.** + - When every model is on disk, the engine sets `HF_HUB_OFFLINE`, and telemetry is off. + - The self-contained installer bundles llama.cpp's `llama-server` with a GGUF build of the default model (Qwen3 4B Instruct, Apache-2.0). The engine reaches it through `provider = "openai"`, because the OpenAI-compatible API is what `llama-server` speaks. + - Ollama remains the default for developers, and it is too large to bundle. + +### Consequences + +- **Good:** + - The interface can look modern without fighting XAML. + - The engine stays one Python code path, tested once. + - The same API serves a future web UI or MCP server. +- **Bad:** + - Two runtimes ship together, .NET and Python, which makes the installer large (several GB, mostly models). + - **Mitigation:** the packaging work keeps models and runtimes in separate, cacheable folders, and compresses what compresses. +- **Bad:** + - A local HTTP port is an attack surface. + - **Mitigation:** the three guards above, all covered by tests. + +### Confirmation + +`tests/test_api.py` checks the token, the loopback-host rule and the CORS origin. `tests/test_library.py` checks that a section answers only from its own documents and that a category answers from all of its sections. + +## Pros and cons of the options + +### WPF + WebView2 + React + +- Good, because it uses the stack and patterns we already proved in Duet: virtual-host assets, the job object and Mica. +- Good, because WebView2 is preinstalled on Windows 11. +- Bad, because there are two UI technologies to know. + +### Native WPF + +- Good, because it is one technology with no web layer. +- Bad, because a polished, friendly interface takes much longer to build. + +### Electron or Tauri + +- Good, because they are cross-platform. +- Bad, because Electron adds another large runtime, and Tauri adds Rust. Neither buys us anything for a Windows-first app. + +### Browser plus `ore serve` + +- Good, because there is nothing to build. +- Bad, because it gives no folder picker and no way to open source files, and users would have to start a server themselves. + +## More information + +[ADR-0006](0006-python-and-langchain.md) (engine stack), [interfaces](../architecture/05-interfaces.md) (error categories and problem details). diff --git a/docs/adr/README.md b/docs/adr/README.md index 5a670a9..f07acc5 100644 --- a/docs/adr/README.md +++ b/docs/adr/README.md @@ -15,6 +15,7 @@ Each significant decision gets one short record: the context, the options we wei | [0004](0004-index-generations.md) | Index generations built from independently keyed builds | Proposed | | [0005](0005-verified-citations.md) | Citations are enforced, verified and attributed, not trusted | Proposed | | [0006](0006-python-and-langchain.md) | Python and LangChain for the first engine | Proposed | +| [0007](0007-desktop-app.md) | A Windows desktop app over a local engine API | Proposed | ## Planned diff --git a/pyproject.toml b/pyproject.toml index b86a553..84188bd 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -22,6 +22,9 @@ dependencies = [ "torch>=2.4", "pydantic>=2.7", "typer>=0.12", + "fastapi>=0.115", + "uvicorn>=0.32", + "langchain-openai>=1.0,<2", ] [project.scripts] diff --git a/src/open_rag_engine/api.py b/src/open_rag_engine/api.py new file mode 100644 index 0000000..8024fec --- /dev/null +++ b/src/open_rag_engine/api.py @@ -0,0 +1,279 @@ +"""A local HTTP API for the desktop app, reachable only from this machine. + +Three guards: only loopback Host headers are served (no DNS rebinding), every request needs the bearer token the app +generated at launch, and CORS allows only the app's own origin. Errors are RFC 9457 problem details without stack +traces or document content. +""" + +from __future__ import annotations + +import json +import logging +import queue +import secrets +import threading +from dataclasses import asdict +from typing import Any, Literal + +import httpx +from fastapi import Depends, FastAPI, HTTPException, Request +from fastapi.exceptions import RequestValidationError +from fastapi.middleware.cors import CORSMiddleware +from fastapi.responses import JSONResponse, Response, StreamingResponse +from pydantic import BaseModel, Field +from starlette.middleware.trustedhost import TrustedHostMiddleware + +from . import __version__ +from .answer import Answer +from .documents import PAGE, SOURCE, citation_label +from .ingest import IndexMismatchError +from .library import SECTION_ID, ConflictError, IndexStatus, Library +from .workspace import NotFoundError, Section, WorkspaceError + +log = logging.getLogger(__name__) + +SNIPPET = 400 + + +class NameIn(BaseModel): + name: str = Field(min_length=1, max_length=80) + + +class SectionIn(NameIn): + category_id: str = Field(min_length=1, max_length=64) + + +class SectionPatch(BaseModel): + name: str | None = Field(None, min_length=1, max_length=80) + category_id: str | None = Field(None, min_length=1, max_length=64) + + +class FolderIn(BaseModel): + path: str = Field(min_length=1, max_length=1024) + + +class ScopeIn(BaseModel): + kind: Literal["section", "category"] + id: str = Field(min_length=1, max_length=64) + + +class TurnIn(BaseModel): + question: str = Field(max_length=4000) + answer: str = Field(max_length=20000) + + +class AskIn(BaseModel): + scope: ScopeIn + question: str = Field(min_length=1, max_length=4000) + history: list[TurnIn] = Field(default_factory=list, max_length=20) + + +def create_app(library: Library, token: str, origins: list[str]) -> FastAPI: + expected = f"Bearer {token}".encode() + + def require_token(request: Request) -> None: + if not secrets.compare_digest(request.headers.get("authorization", "").encode(), expected): + raise HTTPException(status_code=401, detail="Missing or wrong token") + + app = FastAPI( + title="open-rag-engine", + version=__version__, + docs_url=None, + redoc_url=None, + openapi_url=None, + dependencies=[Depends(require_token)], + ) + app.add_middleware( + CORSMiddleware, + allow_origins=origins, + allow_methods=["GET", "POST", "PATCH", "DELETE"], + allow_headers=["Authorization", "Content-Type"], + ) + app.add_middleware(TrustedHostMiddleware, allowed_hosts=["127.0.0.1", "localhost"]) + _add_error_handlers(app) + ws = library.workspace + + @app.get("/health") + def health() -> dict[str, str]: + return {"status": "ok", "version": __version__} + + @app.get("/library") + def overview() -> dict[str, Any]: + return { + "categories": [asdict(c) for c in ws.categories()], + "sections": [ + {**_section(s), "documents": library.stats(s.id)["documents"], "status": _status(library.status(s.id))} + for s in ws.sections() + ], + } + + @app.post("/categories", status_code=201) + def add_category(body: NameIn) -> dict[str, str]: + return asdict(ws.add_category(body.name)) + + @app.patch("/categories/{category_id}") + def rename_category(category_id: str, body: NameIn) -> dict[str, str]: + return asdict(ws.rename_category(category_id, body.name)) + + @app.delete("/categories/{category_id}", status_code=204) + def delete_category(category_id: str) -> Response: + ws.delete_category(category_id) + return Response(status_code=204) + + @app.post("/sections", status_code=201) + def add_section(body: SectionIn) -> dict[str, Any]: + return _section(ws.add_section(body.name, body.category_id)) + + @app.patch("/sections/{section_id}") + def update_section(section_id: str, body: SectionPatch) -> dict[str, Any]: + return _section(ws.update_section(section_id, name=body.name, category_id=body.category_id)) + + @app.delete("/sections/{section_id}", status_code=204) + def delete_section(section_id: str) -> Response: + library.delete_section(section_id) + return Response(status_code=204) + + @app.post("/sections/{section_id}/folders") + def add_folder(section_id: str, body: FolderIn) -> dict[str, Any]: + from pathlib import Path + + return _section(ws.add_folder(section_id, Path(body.path))) + + @app.post("/sections/{section_id}/folders/remove") + def remove_folder(section_id: str, body: FolderIn) -> dict[str, Any]: + return _section(ws.remove_folder(section_id, body.path)) + + @app.post("/sections/{section_id}/index", status_code=202) + def index(section_id: str) -> dict[str, Any]: + return _status(library.start_indexing(section_id)) + + @app.get("/sections/{section_id}/status") + def status(section_id: str) -> dict[str, Any]: + return _status(library.status(section_id)) + + @app.get("/sections/{section_id}/documents") + def documents(section_id: str) -> list[dict[str, Any]]: + return library.documents(section_id) + + @app.post("/ask") + def ask(body: AskIn) -> StreamingResponse: + library.scope_sections(body.scope.kind, body.scope.id) # unknown or busy scopes fail before streaming starts + history = [(t.question, t.answer) for t in body.history] + default_section = body.scope.id if body.scope.kind == "section" else None + events: queue.Queue[dict[str, Any] | None] = queue.Queue() + + def work() -> None: + try: + answer = library.ask( + body.scope.kind, + body.scope.id, + body.question, + history, + on_token=lambda text: events.put({"type": "token", "text": text}), + ) + events.put({"type": "done", **_answer(answer, default_section)}) + except Exception as error: # the stream is already open, so the error travels as an event + status, title, detail = _classify(error) + events.put({"type": "error", "status": status, "title": title, "detail": detail}) + finally: + events.put(None) + + threading.Thread(target=work, name="ask", daemon=True).start() + + def lines(): + while (event := events.get()) is not None: + yield json.dumps(event, ensure_ascii=False) + "\n" + + return StreamingResponse(lines(), media_type="application/x-ndjson") + + return app + + +def _section(section: Section) -> dict[str, Any]: + return { + "id": section.id, + "name": section.name, + "category_id": section.category_id, + "folders": list(section.folders), + } + + +def _status(status: IndexStatus) -> dict[str, Any]: + report = status.report + return { + "state": status.state, + "done": status.done, + "total": status.total, + "current": status.current, + "error": status.error, + "missing_folders": list(status.missing_folders), + "report": None + if report is None + else { + "added": len(report.added), + "updated": len(report.updated), + "unchanged": len(report.unchanged), + "removed": len(report.removed), + "failed": [{"source": s, "error": e} for s, e in report.failed], + }, + } + + +def _answer(answer: Answer, default_section: str | None) -> dict[str, Any]: + def source(number: int) -> dict[str, Any]: + passage = answer.retrieval.passages[number - 1] + meta = passage.doc.metadata + return { + "number": number, + "label": citation_label(passage.doc), + "source": meta.get(SOURCE), + "page": meta.get(PAGE), + "section_id": meta.get(SECTION_ID, default_section), + "score": passage.score, + "snippet": passage.doc.page_content[:SNIPPET], + } + + return { + "question": answer.question, + "text": answer.text, + "abstained": answer.abstained, + "grounded": answer.grounded, + "invalid_citations": answer.invalid_citations, + "citations": [source(c.number) for c in answer.citations], + "sources": [source(n) for n in range(1, len(answer.retrieval.passages) + 1)], + } + + +def _classify(error: Exception) -> tuple[int, str, str]: + if isinstance(error, NotFoundError): + return 404, "Not found", str(error) + if isinstance(error, WorkspaceError): + return 422, "Invalid request", str(error) + if isinstance(error, ConflictError | IndexMismatchError): + return 409, "Conflict", str(error) + if isinstance(error, httpx.ConnectError) or type(error).__name__ == "APIConnectionError": + return 503, "Language model unavailable", "The local language model isn't running." + log.exception("Unexpected error", exc_info=error) + return 500, "Internal error", "Something went wrong. The engine log has the details." + + +def _problem(status: int, title: str, detail: str) -> JSONResponse: + body = {"type": "about:blank", "title": title, "status": status, "detail": detail} + return JSONResponse(body, status_code=status, media_type="application/problem+json") + + +def _add_error_handlers(app: FastAPI) -> None: + @app.exception_handler(HTTPException) + async def http_error(_: Request, error: HTTPException) -> JSONResponse: + return _problem(error.status_code, "Unauthorized" if error.status_code == 401 else "Error", str(error.detail)) + + @app.exception_handler(RequestValidationError) + async def invalid(_: Request, error: RequestValidationError) -> JSONResponse: + detail = "; ".join(f"{'.'.join(str(p) for p in e['loc'][1:])}: {e['msg']}" for e in error.errors()) + return _problem(422, "Invalid request", detail) + + async def known_error(_: Request, error: Exception) -> JSONResponse: + return _problem(*_classify(error)) + + for known in (NotFoundError, WorkspaceError, ConflictError, IndexMismatchError, httpx.ConnectError, Exception): + app.add_exception_handler(known, known_error) diff --git a/src/open_rag_engine/cli.py b/src/open_rag_engine/cli.py index 0313d01..7e489f6 100644 --- a/src/open_rag_engine/cli.py +++ b/src/open_rag_engine/cli.py @@ -2,7 +2,11 @@ from __future__ import annotations +import os +import socket import sys +import threading +import time from pathlib import Path from typing import Annotated, Any @@ -15,6 +19,7 @@ from .conversation import Turn from .engine import Engine from .ingest import IndexMismatchError +from .offline import go_offline_if_possible, quiet_and_private from .pipeline import RetrievalResult app = typer.Typer( @@ -27,8 +32,9 @@ @app.callback() -def _utf8_output() -> None: - """Write UTF-8 even when Windows pipes stdout with a legacy code page, so accents and units survive.""" +def _startup() -> None: + """Private, quiet, UTF-8 output. Runs before any command loads a model.""" + quiet_and_private() for stream in (sys.stdout, sys.stderr): reconfigure = getattr(stream, "reconfigure", None) if reconfigure is not None: @@ -50,6 +56,7 @@ def _utf8_output() -> None: def build_engine(config: EngineConfig) -> Engine: + go_offline_if_possible([config.embeddings.model, config.rerank.model]) return Engine.from_config(config) @@ -231,6 +238,63 @@ def action(): _run(action) +TOKEN_VARIABLE = "ORE_API_TOKEN" + + +@app.command() +def serve( + port: Annotated[int, typer.Option(help="Port on 127.0.0.1; 0 picks a free one.")] = 0, + origin: Annotated[list[str] | None, typer.Option(help="Web origin allowed to call the API.")] = None, + parent_pid: Annotated[int | None, typer.Option(help="Exit when this process exits.")] = None, + config: ConfigOpt = None, +) -> None: + """Run the local API for the desktop app. Prints `ORE_READY port=` once it listens.""" + + def action(): + token = os.environ.get(TOKEN_VARIABLE, "") + if len(token) < 32: + raise ValueError(f"Set {TOKEN_VARIABLE} to a random secret of at least 32 characters.") + cfg = _config(config) + go_offline_if_possible([cfg.embeddings.model, cfg.rerank.model]) + from .api import create_app + from .factory import LocalModels + from .library import Library + + api = create_app(Library(cfg, LocalModels(cfg)), token, origin or ["https://app.ore"]) + server = _listen(port) + typer.echo(f"ORE_READY port={server.getsockname()[1]}") + sys.stdout.flush() + if parent_pid: + threading.Thread(target=_exit_with_parent, args=(parent_pid,), daemon=True).start() + import uvicorn + + uvicorn.Server(uvicorn.Config(api, log_level="warning", access_log=False)).run(sockets=[server]) + + _run(action) + + +def _listen(port: int) -> socket.socket: + """Bind to loopback only. The socket is handed to uvicorn, so the chosen port is known before it starts.""" + server = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + server.bind(("127.0.0.1", port)) + return server + + +def _exit_with_parent(pid: int) -> None: + """Backstop for the app's job object: if the app disappears, the engine must not linger.""" + if sys.platform == "win32": + import ctypes + + synchronize, infinite = 0x00100000, 0xFFFFFFFF + handle = ctypes.windll.kernel32.OpenProcess(synchronize, False, pid) + if handle: + ctypes.windll.kernel32.WaitForSingleObject(handle, infinite) + else: + while os.getppid() == pid: + time.sleep(2) + os._exit(0) + + def _echo_token(token: str) -> None: typer.echo(token, nl=False) diff --git a/src/open_rag_engine/config.py b/src/open_rag_engine/config.py index 242d7ac..b01de7f 100644 --- a/src/open_rag_engine/config.py +++ b/src/open_rag_engine/config.py @@ -54,6 +54,8 @@ class RerankConfig(_Section): class LLMConfig(_Section): + provider: Literal["ollama", "openai"] = "ollama" + """`openai` means any OpenAI-compatible server, such as llama.cpp's `llama-server` bundled with the desktop app.""" model: str = "qwen3:4b-instruct-2507-q4_K_M" base_url: str = "http://localhost:11434" temperature: float = Field(0.0, ge=0, le=2) diff --git a/src/open_rag_engine/engine.py b/src/open_rag_engine/engine.py index 59cbc51..58e81d6 100644 --- a/src/open_rag_engine/engine.py +++ b/src/open_rag_engine/engine.py @@ -15,7 +15,7 @@ from .config import EngineConfig from .conversation import Turn, standalone_question from .evaluation import EvalReport, evaluate, load_dataset -from .ingest import IndexMismatchError, IngestReport, ingest +from .ingest import IndexMismatchError, IngestReport, Progress, ingest from .pipeline import RetrievalPipeline, RetrievalResult from .rerank import Reranker from .retrieval import Filter @@ -50,12 +50,21 @@ def from_config(cls, config: EngineConfig) -> Engine: def store(self) -> ChunkStore: return ChunkStore(self.config.data_dir, self.config.collection, self._models.embeddings) - def ingest(self, paths: Iterable[Path], rebuild: bool = False) -> IngestReport: + def ingest( + self, + paths: Iterable[Path], + rebuild: bool = False, + prune: bool = False, + on_progress: Progress | None = None, + keep: Sequence[str] = (), + ) -> IngestReport: cfg = self.config embeddings = self._models.embeddings if cfg.chunking.strategy == "semantic" else None - return ingest(paths, self.store, make_splitter(cfg.chunking, embeddings), cfg.index_fingerprint(), rebuild) + splitter = make_splitter(cfg.chunking, embeddings) + return ingest(paths, self.store, splitter, cfg.index_fingerprint(), rebuild, prune, on_progress, keep) - def pipeline(self) -> RetrievalPipeline: + def pipeline(self, rerank: bool | None = None, top_n: int | None = None) -> RetrievalPipeline: + """The configured pipeline; `rerank` and `top_n` override the configuration for this call only.""" cfg = self.config indexed_with = self.store.manifest().index_fingerprint if indexed_with is not None and indexed_with != cfg.index_fingerprint(): @@ -63,9 +72,11 @@ def pipeline(self) -> RetrievalPipeline: "The collection was indexed with a different chunking or embedding configuration. " "Run `ore ingest --rebuild` with the current configuration first." ) - reranker = Reranker(self._models.cross_encoder, cfg.rerank.top_n) if cfg.rerank.enabled else None + top_n = top_n or cfg.rerank.top_n + use_reranker = cfg.rerank.enabled if rerank is None else rerank + reranker = Reranker(self._models.cross_encoder, top_n) if use_reranker else None llm = self._models.llm if cfg.retrieval.multi_query else None - return RetrievalPipeline(self.store, cfg.retrieval, reranker=reranker, llm=llm, top_n=cfg.rerank.top_n) + return RetrievalPipeline(self.store, cfg.retrieval, reranker=reranker, llm=llm, top_n=top_n) def retrieve(self, query: str, filter: Filter | None = None) -> RetrievalResult: return self.pipeline().run(query, filter) diff --git a/src/open_rag_engine/factory.py b/src/open_rag_engine/factory.py index d7fbfa7..8f4e6cd 100644 --- a/src/open_rag_engine/factory.py +++ b/src/open_rag_engine/factory.py @@ -2,6 +2,7 @@ from __future__ import annotations +import os from functools import cached_property from langchain_community.cross_encoders import HuggingFaceCrossEncoder @@ -19,6 +20,7 @@ def __init__(self, config: EngineConfig): def embeddings(self) -> Embeddings: from langchain_huggingface import HuggingFaceEmbeddings + _quiet_transformers() cfg = self._config.embeddings return HuggingFaceEmbeddings( model_name=cfg.model, @@ -29,13 +31,21 @@ def embeddings(self) -> Embeddings: @cached_property def cross_encoder(self) -> HuggingFaceCrossEncoder: + _quiet_transformers() return HuggingFaceCrossEncoder(model_name=self._config.rerank.model, model_kwargs={"device": "cpu"}) @cached_property def llm(self) -> BaseChatModel: + cfg = self._config.llm + if cfg.provider == "openai": + from langchain_openai import ChatOpenAI + + # A local server needs no key; a hosted one reads the user's own key from the environment (C-03). + key = os.environ.get("ORE_LLM_API_KEY", "not-needed") + return ChatOpenAI(model=cfg.model, base_url=cfg.base_url, api_key=key, temperature=cfg.temperature) + from langchain_ollama import ChatOllama - cfg = self._config.llm # Reasoning adds minutes before the first answer token on a CPU, so it is off by default (LLMConfig.think). return ChatOllama( model=cfg.model, @@ -52,3 +62,11 @@ def _encode_kwargs(prefix: str) -> dict[str, object]: if prefix: kwargs["prompt"] = prefix return kwargs + + +def _quiet_transformers() -> None: + """No "Loading weights" progress bars or advisory warnings on the console.""" + from transformers.utils import logging as transformers_logging + + transformers_logging.disable_progress_bar() + transformers_logging.set_verbosity_error() diff --git a/src/open_rag_engine/ingest.py b/src/open_rag_engine/ingest.py index ec2fdbb..72a0377 100644 --- a/src/open_rag_engine/ingest.py +++ b/src/open_rag_engine/ingest.py @@ -3,7 +3,7 @@ from __future__ import annotations import logging -from collections.abc import Iterable +from collections.abc import Callable, Iterable, Sequence from dataclasses import dataclass, field from pathlib import Path from typing import Protocol @@ -32,11 +32,28 @@ class IngestReport: unchanged: list[str] = field(default_factory=list) failed: list[tuple[str, str]] = field(default_factory=list) chunks_added: int = 0 + removed: list[str] = field(default_factory=list) + + +Progress = Callable[[int, int, str], None] +"""Called after each file with (files done, files in total, source path).""" def ingest( - paths: Iterable[Path], store: ChunkStore, splitter: Splitter, index_fingerprint: str, rebuild: bool = False + paths: Iterable[Path], + store: ChunkStore, + splitter: Splitter, + index_fingerprint: str, + rebuild: bool = False, + prune: bool = False, + on_progress: Progress | None = None, + keep: Sequence[str] = (), ) -> IngestReport: + """Index the files under `paths`. + + With `prune`, documents that are no longer under `paths` leave the index, except those under a folder in + `keep` (for example a USB drive that is unplugged right now). + """ files = discover(paths) stored = store.manifest().index_fingerprint if rebuild: @@ -52,25 +69,46 @@ def ingest( unchanged: list[str] = [] failed: list[tuple[str, str]] = [] chunks_added = 0 - for path in files: + outcomes: dict[str, list[str]] = {"added": added, "updated": updated, "unchanged": unchanged} + for done, path in enumerate(files, start=1): source = path.as_posix() - doc_id = content_hash(path.read_bytes()) - previous = store.manifest().documents.get(source) - if previous == doc_id: - unchanged.append(source) - continue - try: - chunks = _chunk(load(path), splitter, doc_id, index_fingerprint) - except Exception as error: # one unreadable file must not stop the batch - log.warning("Could not ingest %s: %s", source, error) - failed.append((source, str(error))) - continue - if previous is not None: - store.remove(source) - store.add(source, doc_id, chunks, index_fingerprint) - (updated if previous is not None else added).append(source) - chunks_added += len(chunks) - return IngestReport(added, updated, unchanged, failed, chunks_added) + outcome, count, error = _ingest_file(path, source, store, splitter, index_fingerprint) + if error is not None: + failed.append((source, error)) + else: + outcomes[outcome].append(source) + chunks_added += count + if on_progress: + on_progress(done, len(files), source) + + removed: list[str] = [] + if prune: + present = {path.as_posix() for path in files} + kept = tuple(folder.rstrip("/") + "/" for folder in keep) + for source in store.manifest().documents: + if source not in present and not source.startswith(kept): + store.remove(source) + removed.append(source) + return IngestReport(added, updated, unchanged, failed, chunks_added, removed) + + +def _ingest_file( + path: Path, source: str, store: ChunkStore, splitter: Splitter, index_fingerprint: str +) -> tuple[str, int, str | None]: + """Index one file unless it is unchanged: (outcome, chunks added, error message or None).""" + doc_id = content_hash(path.read_bytes()) + previous = store.manifest().documents.get(source) + if previous == doc_id: + return "unchanged", 0, None + try: + chunks = _chunk(load(path), splitter, doc_id, index_fingerprint) + except Exception as error: # one unreadable file must not stop the batch + log.warning("Could not ingest %s: %s", source, error) + return "failed", 0, str(error) + if previous is not None: + store.remove(source) + store.add(source, doc_id, chunks, index_fingerprint) + return ("updated" if previous is not None else "added"), len(chunks), None def _chunk(documents: list[Document], splitter: Splitter, doc_id: str, index_fingerprint: str) -> list[Document]: diff --git a/src/open_rag_engine/library.py b/src/open_rag_engine/library.py new file mode 100644 index 0000000..b439fa8 --- /dev/null +++ b/src/open_rag_engine/library.py @@ -0,0 +1,199 @@ +"""The desktop app's service: sections with their own indexes, background indexing, and answers scoped to a +section or to a whole category.""" + +from __future__ import annotations + +import logging +import shutil +import threading +from collections.abc import Callable, Sequence +from concurrent.futures import Executor, Future, ThreadPoolExecutor +from dataclasses import dataclass +from pathlib import Path, PurePosixPath +from typing import Any, Literal + +from langchain_core.documents import Document + +from .answer import Answer, generate_answer +from .config import EngineConfig +from .conversation import Turn, standalone_question +from .documents import CHUNK_INDEX, SOURCE, citation_label +from .engine import Engine, Models +from .fusion import reciprocal_rank_fusion +from .ingest import IngestReport +from .pipeline import Passage, RetrievalResult, StageTrace +from .rerank import Reranker +from .workspace import Section, Workspace + +log = logging.getLogger(__name__) + +SECTION_ID = "section_id" +ScopeKind = Literal["section", "category"] + + +class ConflictError(RuntimeError): + """The request clashes with work in progress, such as asking a section while it is being indexed.""" + + +@dataclass(frozen=True) +class IndexStatus: + state: Literal["idle", "indexing", "error"] = "idle" + done: int = 0 + total: int = 0 + current: str | None = None + error: str | None = None + missing_folders: tuple[str, ...] = () + report: IngestReport | None = None + + +class Library: + def __init__(self, config: EngineConfig, models: Models, executor: Executor | None = None): + self.config = config + self._models = models + self.workspace = Workspace(Path(config.data_dir) / "workspace.json") + # One indexing job at a time: on a laptop CPU, parallel jobs only slow each other down. + self._executor = executor or ThreadPoolExecutor(max_workers=1, thread_name_prefix="indexer") + self._engines: dict[str, Engine] = {} + self._status: dict[str, IndexStatus] = {} + self._futures: dict[str, Future] = {} + self._lock = threading.RLock() + + def engine(self, section_id: str) -> Engine: + section = self.workspace.section(section_id) + with self._lock: + if section_id not in self._engines: + config = EngineConfig.model_validate({**self.config.model_dump(), "collection": section.collection}) + engine = Engine(config, self._models) + _ = engine.store # open the store now, under the lock + self._engines[section_id] = engine + return self._engines[section_id] + + def status(self, section_id: str) -> IndexStatus: + self.workspace.section(section_id) + return self._status.get(section_id, IndexStatus()) + + def stats(self, section_id: str) -> dict[str, Any]: + return self.engine(section_id).stats() + + def documents(self, section_id: str) -> list[dict[str, Any]]: + counts: dict[str, int] = {} + for chunk in self.engine(section_id).store.chunks(): + source = str(chunk.metadata.get(SOURCE)) + counts[source] = counts.get(source, 0) + 1 + return [{"source": s, "name": PurePosixPath(s).name, "chunks": n} for s, n in sorted(counts.items())] + + def start_indexing(self, section_id: str) -> IndexStatus: + self.workspace.section(section_id) + with self._lock: + current = self.status(section_id) + if current.state == "indexing": + return current + started = IndexStatus(state="indexing", missing_folders=current.missing_folders) + self._status[section_id] = started + self._futures[section_id] = self._executor.submit(self._index, section_id) + return started + + def wait_for_index(self, section_id: str, timeout: float | None = None) -> IndexStatus: + future = self._futures.get(section_id) + if future is not None: + future.result(timeout) + return self.status(section_id) + + def delete_section(self, section_id: str) -> None: + if self.status(section_id).state == "indexing": + raise ConflictError("Wait until this section has finished indexing") + engine = self.engine(section_id) + engine.store.vectors.delete_collection() + with self._lock: + self._engines.pop(section_id, None) + self._status.pop(section_id, None) + shutil.rmtree(engine.store.directory, ignore_errors=True) + self.workspace.delete_section(section_id) + + def ask( + self, + kind: ScopeKind, + scope_id: str, + question: str, + history: Sequence[Turn] = (), + on_token: Callable[[str], None] | None = None, + ) -> Answer: + sections = self.scope_sections(kind, scope_id) + if kind == "section": + return self.engine(scope_id).ask(question, history, on_token=on_token) + llm = self._models.llm + standalone = standalone_question(llm, history, question) + retrieval = self._retrieve_across(sections, standalone) + min_score = self.config.answer.min_rerank_score if self.config.rerank.enabled else None + return generate_answer(standalone, retrieval, llm, min_score, on_token) + + def scope_sections(self, kind: ScopeKind, scope_id: str) -> list[Section]: + """The sections a question searches. Raises when the scope is unknown or a section is still indexing.""" + if kind == "section": + sections = [self.workspace.section(scope_id)] + else: + self.workspace.category(scope_id) + sections = self.workspace.sections(scope_id) + busy = [s.name for s in sections if self.status(s.id).state == "indexing"] + if busy: + raise ConflictError(f"Still indexing: {', '.join(busy)}. Ask again when it has finished.") + return sections + + def _index(self, section_id: str) -> None: + section = self.workspace.section(section_id) + present = [Path(f) for f in section.folders if Path(f).is_dir()] + missing = tuple(f for f in section.folders if not Path(f).is_dir()) + + def progress(done: int, total: int, source: str) -> None: + self._set(section_id, IndexStatus("indexing", done, total, source, None, missing)) + + try: + report = self.engine(section_id).ingest(present, prune=True, keep=missing, on_progress=progress) + except Exception as error: # surfaced to the app as an error state rather than lost in a thread + log.exception("Indexing section %s failed", section_id) + self._set(section_id, IndexStatus(state="error", error=str(error), missing_folders=missing)) + return + files = len(report.added) + len(report.updated) + len(report.unchanged) + len(report.failed) + self._set(section_id, IndexStatus("idle", files, files, None, None, missing, report)) + + def _set(self, section_id: str, status: IndexStatus) -> None: + with self._lock: + self._status[section_id] = status + + def _retrieve_across(self, sections: list[Section], query: str) -> RetrievalResult: + """Search each section, fuse their lists with RRF, then rerank the fused candidates once.""" + cfg = self.config + lists: list[list[Document]] = [] + trace: list[StageTrace] = [] + for section in sections: + result = self.engine(section.id).pipeline(rerank=False, top_n=cfg.retrieval.k).run(query) + docs = [_tagged(p.doc, section.id) for p in result.passages] + lists.append(docs) + trace.append( + StageTrace( + f"section {section.name}", + sum(t.ms for t in result.trace), + [("*", _label(d), p.score) for d, p in zip(docs, result.passages, strict=True)][:10], + ) + ) + fused = reciprocal_rank_fusion(lists, k=cfg.retrieval.rrf_k)[: cfg.retrieval.k] + trace.append(StageTrace("fusion", 0.0, [("*", _label(d), s) for d, s in fused[:10]])) + fusion_scores = {id(d): s for d, s in fused} + if cfg.rerank.enabled: + ranked = Reranker(self._models.cross_encoder, cfg.rerank.top_n).rerank(query, [d for d, _ in fused]) + trace.append(StageTrace("rerank", 0.0, [("*", _label(d), s) for d, s in ranked])) + else: + ranked = fused[: cfg.rerank.top_n] + passages = [ + Passage(d, s, {"fusion": fusion_scores.get(id(d)), **({"rerank": s} if cfg.rerank.enabled else {})}) + for d, s in ranked + ] + return RetrievalResult(query=query, queries=[query], passages=passages, trace=trace) + + +def _tagged(doc: Document, section_id: str) -> Document: + return Document(page_content=doc.page_content, metadata={**doc.metadata, SECTION_ID: section_id}) + + +def _label(doc: Document) -> str: + return f"{citation_label(doc)} #{doc.metadata.get(CHUNK_INDEX, '?')}" diff --git a/src/open_rag_engine/offline.py b/src/open_rag_engine/offline.py new file mode 100644 index 0000000..fb1c484 --- /dev/null +++ b/src/open_rag_engine/offline.py @@ -0,0 +1,50 @@ +"""Keep the engine private and quiet: no telemetry, no progress bars, and no network when the models are on disk. + +Call these before any Hugging Face library is imported; they read the environment once, at import time. +""" + +from __future__ import annotations + +import os +from collections.abc import Iterable, MutableMapping +from pathlib import Path + +PRIVATE_DEFAULTS = { + "HF_HUB_DISABLE_TELEMETRY": "1", + "DO_NOT_TRACK": "1", + "ANONYMIZED_TELEMETRY": "False", + "HF_HUB_DISABLE_PROGRESS_BARS": "1", + "TRANSFORMERS_VERBOSITY": "error", + "TOKENIZERS_PARALLELISM": "false", +} + + +def quiet_and_private(env: MutableMapping[str, str] = os.environ) -> None: + for key, value in PRIVATE_DEFAULTS.items(): + env.setdefault(key, value) + + +def hf_cache(env: MutableMapping[str, str] = os.environ) -> Path: + if "HF_HUB_CACHE" in env: + return Path(env["HF_HUB_CACHE"]) + home = Path(env["HF_HOME"]) if "HF_HOME" in env else Path.home() / ".cache" / "huggingface" + return home / "hub" + + +def available_offline(model: str, env: MutableMapping[str, str] = os.environ) -> bool: + """A local model folder, or a Hugging Face repo that is already in the cache.""" + if Path(model).is_dir(): + return True + if model.count("/") != 1: + return False + snapshots = hf_cache(env) / f"models--{model.replace('/', '--')}" / "snapshots" + return any((snap / "config.json").is_file() for snap in snapshots.glob("*")) if snapshots.is_dir() else False + + +def go_offline_if_possible(models: Iterable[str], env: MutableMapping[str, str] = os.environ) -> bool: + """Forbid network access to Hugging Face when every model is already on disk. Returns whether it did.""" + if not all(available_offline(m, env) for m in models): + return False + env["HF_HUB_OFFLINE"] = "1" + env["TRANSFORMERS_OFFLINE"] = "1" + return True diff --git a/src/open_rag_engine/workspace.py b/src/open_rag_engine/workspace.py new file mode 100644 index 0000000..2cecc7e --- /dev/null +++ b/src/open_rag_engine/workspace.py @@ -0,0 +1,162 @@ +"""Categories and sections for the desktop app. A section is a set of folders with its own index (one collection).""" + +from __future__ import annotations + +import json +import os +import threading +import uuid +from dataclasses import asdict, dataclass, replace +from pathlib import Path + +MAX_NAME = 80 + + +class WorkspaceError(ValueError): + """A request that breaks a workspace rule, such as an empty name.""" + + +class NotFoundError(KeyError): + """An unknown category or section.""" + + def __str__(self) -> str: + return str(self.args[0]) if self.args else "Not found" + + +@dataclass(frozen=True) +class Category: + id: str + name: str + + +@dataclass(frozen=True) +class Section: + id: str + name: str + category_id: str + folders: tuple[str, ...] = () + + @property + def collection(self) -> str: + return f"s-{self.id}" + + +@dataclass(frozen=True) +class _State: + categories: tuple[Category, ...] = () + sections: tuple[Section, ...] = () + + +class Workspace: + """Persisted as one JSON file. Every change writes a new state; nothing is mutated in place.""" + + def __init__(self, path: Path): + self._path = path + self._lock = threading.Lock() + + def categories(self) -> list[Category]: + return list(self._load().categories) + + def sections(self, category_id: str | None = None) -> list[Section]: + return [s for s in self._load().sections if category_id is None or s.category_id == category_id] + + def category(self, category_id: str) -> Category: + return _find(self._load().categories, category_id, "category") + + def section(self, section_id: str) -> Section: + return _find(self._load().sections, section_id, "section") + + def add_category(self, name: str) -> Category: + category = Category(_new_id(), _valid_name(name)) + self._update(lambda s: replace(s, categories=(*s.categories, category))) + return category + + def rename_category(self, category_id: str, name: str) -> Category: + renamed = replace(self.category(category_id), name=_valid_name(name)) + self._update(lambda s: replace(s, categories=_swap(s.categories, renamed))) + return renamed + + def delete_category(self, category_id: str) -> None: + self.category(category_id) + if self.sections(category_id): + raise WorkspaceError("Move or delete the sections in this category first") + self._update(lambda s: replace(s, categories=tuple(c for c in s.categories if c.id != category_id))) + + def add_section(self, name: str, category_id: str) -> Section: + self.category(category_id) + section = Section(_new_id(), _valid_name(name), category_id) + self._update(lambda s: replace(s, sections=(*s.sections, section))) + return section + + def update_section(self, section_id: str, name: str | None = None, category_id: str | None = None) -> Section: + section = self.section(section_id) + if category_id is not None: + self.category(category_id) + updated = replace( + section, + name=_valid_name(name) if name is not None else section.name, + category_id=category_id or section.category_id, + ) + self._update(lambda s: replace(s, sections=_swap(s.sections, updated))) + return updated + + def delete_section(self, section_id: str) -> None: + self.section(section_id) + self._update(lambda s: replace(s, sections=tuple(x for x in s.sections if x.id != section_id))) + + def add_folder(self, section_id: str, folder: Path) -> Section: + section = self.section(section_id) + if not folder.is_dir(): + raise WorkspaceError(f"Not a folder: {folder}") + path = folder.resolve().as_posix() + if path in section.folders: + return section + updated = replace(section, folders=(*section.folders, path)) + self._update(lambda s: replace(s, sections=_swap(s.sections, updated))) + return updated + + def remove_folder(self, section_id: str, folder: Path | str) -> Section: + section = self.section(section_id) + target = Path(folder).resolve().as_posix() if Path(folder).exists() else str(folder) + updated = replace(section, folders=tuple(f for f in section.folders if f not in {target, str(folder)})) + self._update(lambda s: replace(s, sections=_swap(s.sections, updated))) + return updated + + def _load(self) -> _State: + if not self._path.exists(): + return _State() + data = json.loads(self._path.read_text(encoding="utf-8")) + return _State( + categories=tuple(Category(**c) for c in data.get("categories", [])), + sections=tuple(Section(**{**s, "folders": tuple(s.get("folders", []))}) for s in data.get("sections", [])), + ) + + def _update(self, change) -> None: + with self._lock: + state = change(self._load()) + self._path.parent.mkdir(parents=True, exist_ok=True) + tmp = self._path.with_suffix(".tmp") + tmp.write_text(json.dumps(asdict(state), indent=1, ensure_ascii=False), encoding="utf-8") + os.replace(tmp, self._path) + + +def _new_id() -> str: + return uuid.uuid4().hex[:12] + + +def _valid_name(name: str) -> str: + name = (name or "").strip() + if not name or len(name) > MAX_NAME: + raise WorkspaceError(f"A name needs 1 to {MAX_NAME} characters") + return name + + +def _find(items, item_id: str, kind: str): + for item in items: + if item.id == item_id: + return item + raise NotFoundError(f"Unknown {kind}: {item_id}") + + +def _swap(items, new): + return tuple(new if item.id == new.id else item for item in items) diff --git a/tests/test_api.py b/tests/test_api.py new file mode 100644 index 0000000..5088605 --- /dev/null +++ b/tests/test_api.py @@ -0,0 +1,115 @@ +import json +from pathlib import Path + +import pytest +from fastapi.testclient import TestClient +from langchain_core.language_models.fake_chat_models import FakeListChatModel + +from open_rag_engine.api import create_app +from open_rag_engine.library import Library + +from .conftest import FakeModels, HashEmbeddings, OverlapCrossEncoder +from .test_library import ManualExecutor, write + +TOKEN = "t" * 32 +ORIGIN = "https://app.ore" +AUTH = {"Authorization": f"Bearer {TOKEN}"} + + +def make_client(library: Library, base_url: str = "http://127.0.0.1:8765") -> TestClient: + return TestClient(create_app(library, token=TOKEN, origins=[ORIGIN]), base_url=base_url) + + +@pytest.fixture +def library(config) -> Library: + return Library( + config, FakeModels(HashEmbeddings(), OverlapCrossEncoder(), FakeListChatModel(responses=["1.2 kW [1]."])) + ) + + +@pytest.fixture +def client(library) -> TestClient: + return make_client(library) + + +def test_every_request_needs_the_token(client: TestClient): + assert client.get("/health").status_code == 401 + assert client.get("/health", headers={"Authorization": "Bearer wrong"}).status_code == 401 + response = client.get("/health", headers=AUTH) + assert response.status_code == 200 and response.json()["status"] == "ok" + + +def test_only_loopback_hosts_are_served(library: Library): + assert make_client(library, "http://evil.example").get("/health", headers=AUTH).status_code == 400 + + +def test_cors_allows_only_the_app_origin(client: TestClient): + preflight = {"Access-Control-Request-Method": "POST", "Access-Control-Request-Headers": "authorization"} + ok = client.options("/ask", headers={"Origin": ORIGIN, **preflight}) + assert ok.status_code == 200 and ok.headers["access-control-allow-origin"] == ORIGIN + denied = client.options("/ask", headers={"Origin": "https://evil.example", **preflight}) + assert "access-control-allow-origin" not in denied.headers + + +def create_section(client: TestClient, folder: Path) -> str: + category = client.post("/categories", json={"name": "Garden"}, headers=AUTH) + assert category.status_code == 201 + section = client.post("/sections", json={"name": "Pump", "category_id": category.json()["id"]}, headers=AUTH) + assert section.status_code == 201 + section_id = section.json()["id"] + added = client.post(f"/sections/{section_id}/folders", json={"path": str(folder)}, headers=AUTH) + assert added.status_code == 200 and added.json()["folders"] == [folder.resolve().as_posix()] + return section_id + + +def test_library_flow(client: TestClient, library: Library, tmp_path: Path): + section_id = create_section(client, write(tmp_path / "pump", {"power.md": "The pump draws 1.2 kW."})) + started = client.post(f"/sections/{section_id}/index", headers=AUTH) + assert started.status_code == 202 and started.json()["state"] == "indexing" + library.wait_for_index(section_id) + status = client.get(f"/sections/{section_id}/status", headers=AUTH).json() + assert status["state"] == "idle" and status["report"]["added"] == 1 + assert [d["name"] for d in client.get(f"/sections/{section_id}/documents", headers=AUTH).json()] == ["power.md"] + overview = client.get("/library", headers=AUTH).json() + assert overview["categories"][0]["name"] == "Garden" + assert overview["sections"][0]["documents"] == 1 and overview["sections"][0]["status"]["state"] == "idle" + renamed = client.patch(f"/sections/{section_id}", json={"name": "Garden pump"}, headers=AUTH) + assert renamed.json()["name"] == "Garden pump" + assert client.delete(f"/sections/{section_id}", headers=AUTH).status_code == 204 + + +def test_ask_streams_tokens_then_the_cited_answer(client: TestClient, library: Library, tmp_path: Path): + section_id = create_section(client, write(tmp_path / "pump", {"power.md": "The pump draws 1.2 kW."})) + client.post(f"/sections/{section_id}/index", headers=AUTH) + library.wait_for_index(section_id) + body = {"scope": {"kind": "section", "id": section_id}, "question": "How much power?", "history": []} + response = client.post("/ask", json=body, headers=AUTH) + assert response.status_code == 200 and response.headers["content-type"].startswith("application/x-ndjson") + events = [json.loads(line) for line in response.text.splitlines()] + assert "".join(e["text"] for e in events if e["type"] == "token") == "1.2 kW [1]." + done = events[-1] + assert done["type"] == "done" and done["grounded"] is True + citation = done["citations"][0] + assert citation["label"] == "power.md" and citation["section_id"] == section_id + assert citation["source"].endswith("/pump/power.md") and "1.2 kW" in citation["snippet"] + + +def test_errors_are_problem_details(client: TestClient, tmp_path: Path): + missing = client.get("/sections/nope/status", headers=AUTH) + assert missing.status_code == 404 and missing.json()["title"] == "Not found" + assert client.post("/categories", json={"name": ""}, headers=AUTH).status_code == 422 + category_id = client.post("/categories", json={"name": "A"}, headers=AUTH).json()["id"] + section_id = client.post("/sections", json={"name": "S", "category_id": category_id}, headers=AUTH).json()["id"] + bad_folder = client.post(f"/sections/{section_id}/folders", json={"path": str(tmp_path / "nope")}, headers=AUTH) + assert bad_folder.status_code == 422 and "Not a folder" in bad_folder.json()["detail"] + assert client.delete(f"/categories/{category_id}", headers=AUTH).status_code == 422 + + +def test_asking_while_indexing_is_a_conflict(config, tmp_path: Path): + models = FakeModels(HashEmbeddings(), OverlapCrossEncoder(), FakeListChatModel(responses=["-"])) + client = make_client(Library(config, models, executor=ManualExecutor())) + section_id = create_section(client, write(tmp_path / "pump", {"a.md": "pump"})) + client.post(f"/sections/{section_id}/index", headers=AUTH) + body = {"scope": {"kind": "section", "id": section_id}, "question": "pump?"} + response = client.post("/ask", json=body, headers=AUTH) + assert response.status_code == 409 and "Still indexing" in response.json()["detail"] diff --git a/tests/test_engine_and_cli.py b/tests/test_engine_and_cli.py index 7e109af..442e945 100644 --- a/tests/test_engine_and_cli.py +++ b/tests/test_engine_and_cli.py @@ -105,3 +105,18 @@ def test_querying_with_a_changed_index_configuration_asks_for_a_rebuild(monkeypa changed = config.updated("chunking", chunk_size=300) result = run_cli(monkeypatch, changed, "search", "pump") assert result.exit_code == 1 and "--rebuild" in result.output + + +def test_serve_refuses_to_start_without_a_strong_token(monkeypatch): + monkeypatch.delenv("ORE_API_TOKEN", raising=False) + result = CliRunner().invoke(cli.app, ["serve"]) + assert result.exit_code == 1 and "ORE_API_TOKEN" in result.output + + +def test_listen_binds_loopback_on_a_free_port(): + server = cli._listen(0) + try: + host, port = server.getsockname() + assert host == "127.0.0.1" and port > 0 + finally: + server.close() diff --git a/tests/test_factory.py b/tests/test_factory.py new file mode 100644 index 0000000..e924a7d --- /dev/null +++ b/tests/test_factory.py @@ -0,0 +1,15 @@ +from open_rag_engine.config import EngineConfig +from open_rag_engine.factory import LocalModels + + +def test_ollama_is_the_default_llm_runtime(): + llm = LocalModels(EngineConfig()).llm + assert type(llm).__name__ == "ChatOllama" and llm.reasoning is False + + +def test_an_openai_compatible_server_can_replace_ollama(monkeypatch): + monkeypatch.delenv("ORE_LLM_API_KEY", raising=False) + cfg = EngineConfig().updated("llm", provider="openai", base_url="http://127.0.0.1:8090/v1", model="qwen3-4b") + llm = LocalModels(cfg).llm + assert type(llm).__name__ == "ChatOpenAI" and llm.model_name == "qwen3-4b" + assert str(llm.openai_api_base) == "http://127.0.0.1:8090/v1" diff --git a/tests/test_ingest.py b/tests/test_ingest.py index 84dfd5d..cd88780 100644 --- a/tests/test_ingest.py +++ b/tests/test_ingest.py @@ -60,3 +60,31 @@ def test_a_different_index_configuration_needs_a_rebuild(corpus: Path, config): _ingest([corpus], changed, store) _, report = _ingest([corpus], changed, store, rebuild=True) assert len(report.added) == 5 and len(store.chunks()) == 5 + + +def test_prune_removes_documents_whose_files_are_gone(corpus: Path, config): + store, _ = _ingest([corpus], config) + (corpus / "winter.md").unlink() + splitter = make_splitter(config.chunking, embeddings=None) + report = ingest([corpus], store, splitter, config.index_fingerprint(), prune=True) + assert [Path(s).name for s in report.removed] == ["winter.md"] + assert len(store.chunks()) == 4 and len(store.vectors.get()["ids"]) == 4 + + +def test_prune_with_no_paths_empties_the_collection(corpus: Path, config): + store, _ = _ingest([corpus], config) + report = ingest([], store, make_splitter(config.chunking, None), config.index_fingerprint(), prune=True) + assert len(report.removed) == 5 and store.chunks() == [] + + +def test_progress_is_reported_per_file(corpus: Path, config): + seen: list[tuple[int, int]] = [] + store = _store(config) + ingest( + [corpus], + store, + make_splitter(config.chunking, None), + config.index_fingerprint(), + on_progress=lambda done, total, source: seen.append((done, total)), + ) + assert seen == [(1, 5), (2, 5), (3, 5), (4, 5), (5, 5)] diff --git a/tests/test_library.py b/tests/test_library.py new file mode 100644 index 0000000..cba8618 --- /dev/null +++ b/tests/test_library.py @@ -0,0 +1,139 @@ +from concurrent.futures import Future +from pathlib import Path + +import pytest +from langchain_core.language_models.fake_chat_models import FakeListChatModel + +from open_rag_engine.library import ConflictError, Library +from open_rag_engine.workspace import NotFoundError + +from .conftest import FakeModels, HashEmbeddings, OverlapCrossEncoder + + +class ManualExecutor: + """Holds submitted jobs until the test runs them.""" + + def __init__(self): + self.jobs = [] + + def submit(self, fn, *args): + future = Future() + self.jobs.append((fn, args, future)) + return future + + def run_all(self): + for fn, args, future in self.jobs: + future.set_result(fn(*args)) + self.jobs = [] + + +def write(folder: Path, files: dict[str, str]) -> Path: + folder.mkdir(parents=True, exist_ok=True) + for name, text in files.items(): + (folder / name).write_text(text, encoding="utf-8") + return folder + + +@pytest.fixture +def library(config) -> Library: + llm = FakeListChatModel(responses=["It draws 1.2 kW [1]."]) + return Library(config, FakeModels(HashEmbeddings(), OverlapCrossEncoder(), llm)) + + +@pytest.fixture +def two_sections(library: Library, tmp_path: Path): + category = library.workspace.add_category("Garden") + pump = library.workspace.add_section("Pump", category.id) + mower = library.workspace.add_section("Mower", category.id) + library.workspace.add_folder( + pump.id, write(tmp_path / "pump", {"power.md": "The pump draws 1.2 kW at full speed."}) + ) + library.workspace.add_folder( + mower.id, write(tmp_path / "mower", {"blade.md": "Sharpen the mower blade every spring."}) + ) + for section in (pump, mower): + library.start_indexing(section.id) + library.wait_for_index(section.id) + return category, pump, mower + + +def sources(answer) -> set[str]: + return {Path(p.doc.metadata["source"]).name for p in answer.retrieval.passages} + + +def test_indexing_reports_progress_and_counts(library: Library, two_sections): + _, pump, _ = two_sections + status = library.status(pump.id) + assert status.state == "idle" and (status.done, status.total) == (1, 1) + assert library.stats(pump.id)["documents"] == 1 + assert [d["name"] for d in library.documents(pump.id)] == ["power.md"] + + +def test_a_section_answers_only_from_its_own_documents(library: Library, two_sections): + _, pump, _ = two_sections + answer = library.ask("section", pump.id, "When should I sharpen the blade?") + assert sources(answer) <= {"power.md"} + + +def test_a_category_answers_from_all_its_sections(library: Library, two_sections): + category, _, mower = two_sections + answer = library.ask("category", category.id, "sharpen the mower blade") + assert Path(answer.retrieval.passages[0].doc.metadata["source"]).name == "blade.md" + assert answer.retrieval.passages[0].doc.metadata["section_id"] == mower.id + assert {"power.md", "blade.md"} >= sources(answer) + + +def test_cannot_ask_while_the_section_is_indexing(config, tmp_path: Path): + executor = ManualExecutor() + library = Library( + config, + FakeModels(HashEmbeddings(), OverlapCrossEncoder(), FakeListChatModel(responses=["-"])), + executor=executor, + ) + section = library.workspace.add_section("Pump", library.workspace.add_category("Garden").id) + library.workspace.add_folder(section.id, write(tmp_path / "pump", {"a.md": "pump"})) + assert library.start_indexing(section.id).state == "indexing" + assert library.start_indexing(section.id).state == "indexing" and len(executor.jobs) == 1 + with pytest.raises(ConflictError): + library.ask("section", section.id, "pump?") + executor.run_all() + assert library.status(section.id).state == "idle" + + +def test_removed_files_and_folders_leave_the_index(library: Library, two_sections, tmp_path: Path): + _, pump, _ = two_sections + library.workspace.remove_folder(pump.id, tmp_path / "pump") + library.start_indexing(pump.id) + status = library.wait_for_index(pump.id) + assert len(status.report.removed) == 1 and library.stats(pump.id)["documents"] == 0 + + +def test_a_missing_folder_is_reported_and_its_documents_are_kept(library: Library, two_sections, tmp_path: Path): + _, pump, _ = two_sections + for file in (tmp_path / "pump").iterdir(): + file.unlink() + (tmp_path / "pump").rmdir() + library.start_indexing(pump.id) + status = library.wait_for_index(pump.id) + assert status.missing_folders == ((tmp_path / "pump").resolve().as_posix(),) + assert library.stats(pump.id)["documents"] == 1 + + +def test_indexing_errors_are_reported(library: Library, two_sections, monkeypatch): + _, pump, _ = two_sections + + def boom(*args, **kwargs): + raise RuntimeError("disk full") + + monkeypatch.setattr(library.engine(pump.id), "ingest", boom) + library.start_indexing(pump.id) + status = library.wait_for_index(pump.id) + assert status.state == "error" and "disk full" in status.error + + +def test_deleting_a_section_removes_its_index(library: Library, two_sections, config): + _, pump, _ = two_sections + library.delete_section(pump.id) + with pytest.raises(NotFoundError): + library.status(pump.id) + assert not (config.data_dir / pump.collection / "chunks.jsonl").exists() diff --git a/tests/test_offline.py b/tests/test_offline.py new file mode 100644 index 0000000..62d3ee5 --- /dev/null +++ b/tests/test_offline.py @@ -0,0 +1,35 @@ +from pathlib import Path + +from open_rag_engine.offline import available_offline, go_offline_if_possible, quiet_and_private + + +def cached(cache: Path, repo: str) -> None: + snapshot = cache / f"models--{repo.replace('/', '--')}" / "snapshots" / "abc123" + snapshot.mkdir(parents=True) + (snapshot / "config.json").write_text("{}", encoding="utf-8") + + +def test_quiet_and_private_keeps_explicit_settings(): + env = {"DO_NOT_TRACK": "0"} + quiet_and_private(env) + assert env["DO_NOT_TRACK"] == "0" and env["HF_HUB_DISABLE_TELEMETRY"] == "1" + + +def test_local_folders_and_cached_repos_are_available(tmp_path: Path): + env = {"HF_HUB_CACHE": str(tmp_path / "cache")} + cached(tmp_path / "cache", "intfloat/multilingual-e5-small") + folder = tmp_path / "models" / "reranker" + folder.mkdir(parents=True) + assert available_offline("intfloat/multilingual-e5-small", env) + assert available_offline(str(folder), env) + assert not available_offline("other/model", env) + assert not available_offline("qwen3:4b", env) + + +def test_goes_offline_only_when_every_model_is_on_disk(tmp_path: Path): + env = {"HF_HOME": str(tmp_path)} + cached(tmp_path / "hub", "a/one") + assert not go_offline_if_possible(["a/one", "b/two"], env) and "HF_HUB_OFFLINE" not in env + cached(tmp_path / "hub", "b/two") + assert go_offline_if_possible(["a/one", "b/two"], env) + assert env["HF_HUB_OFFLINE"] == "1" and env["TRANSFORMERS_OFFLINE"] == "1" diff --git a/tests/test_workspace.py b/tests/test_workspace.py new file mode 100644 index 0000000..f17d94e --- /dev/null +++ b/tests/test_workspace.py @@ -0,0 +1,70 @@ +from pathlib import Path + +import pytest + +from open_rag_engine.workspace import NotFoundError, Workspace, WorkspaceError + + +@pytest.fixture +def ws(tmp_path: Path) -> Workspace: + return Workspace(tmp_path / "workspace.json") + + +def test_categories_and_sections_persist(ws: Workspace, tmp_path: Path): + physics = ws.add_category("Physics") + optics = ws.add_section("Lesson 3: Optics", physics.id) + again = Workspace(tmp_path / "workspace.json") + assert [c.name for c in again.categories()] == ["Physics"] + assert again.section(optics.id) == optics + assert optics.collection.startswith("s-") and optics.collection != optics.id + + +def test_sections_filter_by_category(ws: Workspace): + a, b = ws.add_category("A"), ws.add_category("B") + ws.add_section("one", a.id) + ws.add_section("two", b.id) + assert [s.name for s in ws.sections(a.id)] == ["one"] + assert len(ws.sections()) == 2 + + +def test_rename_and_move(ws: Workspace): + a, b = ws.add_category("A"), ws.add_category("B") + section = ws.add_section("one", a.id) + assert ws.rename_category(a.id, "Alpha").name == "Alpha" + moved = ws.update_section(section.id, name="uno", category_id=b.id) + assert (moved.name, moved.category_id) == ("uno", b.id) + + +@pytest.mark.parametrize("name", ["", " ", "x" * 81]) +def test_names_are_validated(ws: Workspace, name: str): + with pytest.raises(WorkspaceError): + ws.add_category(name) + + +def test_a_category_with_sections_cannot_be_deleted(ws: Workspace): + cat = ws.add_category("A") + section = ws.add_section("one", cat.id) + with pytest.raises(WorkspaceError): + ws.delete_category(cat.id) + ws.delete_section(section.id) + ws.delete_category(cat.id) + assert ws.categories() == [] + + +def test_unknown_ids_raise_not_found(ws: Workspace): + with pytest.raises(NotFoundError): + ws.section("nope") + with pytest.raises(NotFoundError): + ws.add_section("x", "missing-category") + + +def test_folders_are_validated_and_deduplicated(ws: Workspace, tmp_path: Path): + section = ws.add_section("one", ws.add_category("A").id) + folder = tmp_path / "notes" + folder.mkdir() + ws.add_folder(section.id, folder) + updated = ws.add_folder(section.id, folder) + assert updated.folders == (folder.resolve().as_posix(),) + with pytest.raises(WorkspaceError): + ws.add_folder(section.id, tmp_path / "missing") + assert ws.remove_folder(section.id, folder).folders == () diff --git a/uv.lock b/uv.lock index 918972c..59125a9 100644 --- a/uv.lock +++ b/uv.lock @@ -644,6 +644,23 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/e6/c4/ebdf7837bc4ef6fd98cfb013c28855bb358467bf86c1af011bbc21e21df0/durationpy-0.11-py3-none-any.whl", hash = "sha256:a739fe2b8972c250ff72f8e2c488d18cf25f7b852f49ee76048775d5171df30c", size = 4133, upload-time = "2026-08-26T13:55:59.456Z" }, ] +[[package]] +name = "fastapi" +version = "0.162.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "annotated-doc" }, + { name = "opentelemetry-api" }, + { name = "pydantic" }, + { name = "starlette" }, + { name = "typing-extensions" }, + { name = "typing-inspection" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e9/eb/2cf8c80abf09b2800aef0a83b41066fbfda8ee5495b7a08b9d1af40f7046/fastapi-0.162.0.tar.gz", hash = "sha256:6a22c1e2e6e32e0633ee7e170f00009a29b8228b16feb219ee42f32fd8d88a8f", size = 527867, upload-time = "2026-10-23T18:47:33.264Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b4/4f/3f2c25c9b43970b5e9a08beb5e04776247edea684ddc0930f4f02f0bb6cb/fastapi-0.162.0-py3-none-any.whl", hash = "sha256:3785963de305dd09912426cb81f2d230fce98ab3521cdfe97265c8d14983128c", size = 148912, upload-time = "2026-10-23T18:47:31.734Z" }, +] + [[package]] name = "filelock" version = "4.2.6" @@ -1076,6 +1093,101 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" }, ] +[[package]] +name = "jiter" +version = "0.18.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/63/5b/f68319f4fe624311a744a33d10fdbcac4c971991e348223cba60d31780b2/jiter-0.18.0.tar.gz", hash = "sha256:a0ca63fd9450a212e4e658d4cfe0ab4977c4f9b0003c68828b843c65e27662ff", size = 234470, upload-time = "2026-10-23T13:51:13.103Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/45/0e/075bfa4fa46820da9ac8cf8a67c435b0586012279fba15deccde0e73b9ce/jiter-0.18.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:77a01cdf4381a1becbe5b827f682006f47b712581667451c5b1eb259b9ae7041", size = 290095, upload-time = "2026-10-23T13:49:14.118Z" }, + { url = "https://files.pythonhosted.org/packages/2e/e2/f4000a4d9c519ca019bf0e2922cc0c6b6db347be6303161382eda7635be7/jiter-0.18.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7b41cd64ee6b54db94bea6274e6e37002ed526aa06c114a8be6f36ffe21c184e", size = 316319, upload-time = "2026-10-23T13:49:15.263Z" }, + { url = "https://files.pythonhosted.org/packages/51/93/9aaef4d18d19446fd044b9cff0323b1b45b5526f077f1a80418567a6eef8/jiter-0.18.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d7424194e68ef44e94290961f59319850d7ce11a329a3957f91709c15ded6618", size = 335631, upload-time = "2026-10-23T13:49:16.551Z" }, + { url = "https://files.pythonhosted.org/packages/fd/9e/d2dc5e8179e248df7ef1c7c8822554f4c7f694a33be30790bb523f1e657a/jiter-0.18.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:04a484fce032a8b2c21dec0410a805d7b16573eb34297156a3b4d242c507d2b4", size = 322596, upload-time = "2026-10-23T13:49:17.875Z" }, + { url = "https://files.pythonhosted.org/packages/22/ca/28bfd20743be0b2b37c1ddfe069a637d5180e535f1c8faad555cf7ac0b98/jiter-0.18.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:860ac97858116bda0ac02ef5f50c541fc1a84ad7b9368cac68d4de5697a9012d", size = 333858, upload-time = "2026-10-23T13:49:19.343Z" }, + { url = "https://files.pythonhosted.org/packages/69/89/e42f7dba54dcf7787aa4be3e22cdcb1f14d9635b6527949652ab490d6f8e/jiter-0.18.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:39ef656cf371971486ec545ca0ae2da8d037d5479bc906121e3e46de86ee73c4", size = 348656, upload-time = "2026-10-23T13:49:20.796Z" }, + { url = "https://files.pythonhosted.org/packages/74/6a/b13407f609ddaf9a1f0cdf1336326dc5c8c7fc56943e8450a04a542f5edf/jiter-0.18.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b3c741e6b778c951a6861964ee475118812a33208426c54fb92bf4e318bda834", size = 336286, upload-time = "2026-10-23T13:49:22.152Z" }, + { url = "https://files.pythonhosted.org/packages/b2/7e/b560f97495a485a569e7fa338a13587328854f6a40cd2e93602c327ca4a6/jiter-0.18.0-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:1277ac083a58d2f49a24ff9a28fd9876a6443a1992d4467a1db80fb45e354b18", size = 314415, upload-time = "2026-10-23T13:49:23.645Z" }, + { url = "https://files.pythonhosted.org/packages/8b/97/457b6ec16f1f3f25ec760f23728f43a2b20ddf934fcd8f02c81a2183597e/jiter-0.18.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ccf224d2e706be81d464b59c2bc3f98ba65d12c092c1789e625127e64488944e", size = 332078, upload-time = "2026-10-23T13:49:24.917Z" }, + { url = "https://files.pythonhosted.org/packages/0e/d9/6f616071650f7bb8fcbce674d4dde7e59cfbd8a4d30f5c71c03630425d6e/jiter-0.18.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:5c7fc8e5357d1ad082bb177be71e398fcd3d458726439255ca5cb0d706060269", size = 480354, upload-time = "2026-10-23T13:49:26.221Z" }, + { url = "https://files.pythonhosted.org/packages/42/72/52a3630c8213cdc8093cc86dc6ad50f2bc89ccfa97ef272205d38a24e16d/jiter-0.18.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:a6bba0404b46157a651d1fe512cf2c59c8e42836a9284c35cdff35310758ba4f", size = 515322, upload-time = "2026-10-23T13:49:27.652Z" }, + { url = "https://files.pythonhosted.org/packages/31/54/987cfee52bdf8a286e9c1c58192a9bb64f8773a6be36e4ec46959f67fb7e/jiter-0.18.0-cp312-cp312-win32.whl", hash = "sha256:07ae058bc052ead609b49bbae78c01bf4dee8f5f9d21705cbae9bfe59b33efc9", size = 185341, upload-time = "2026-10-23T13:49:29.147Z" }, + { url = "https://files.pythonhosted.org/packages/c5/c9/b1279eecf68e5f62c918af3f7f856a071ae7db0c90b8fd2235b1b6020c8c/jiter-0.18.0-cp312-cp312-win_amd64.whl", hash = "sha256:79d1fe529bd7065c6f3f50279a08c2ab82eaa0631a6f5dfafa9c65105eeaaafa", size = 225889, upload-time = "2026-10-23T13:49:30.306Z" }, + { url = "https://files.pythonhosted.org/packages/e0/14/715f84be58a7fc97779aa40c37164acfa25ccb2cee89bfb69358e7071ff3/jiter-0.18.0-cp312-cp312-win_arm64.whl", hash = "sha256:1f8b3b3d8761dee3cddcb5d3e99eaccc0155bbefc345affcdedcc758a4933a1f", size = 181852, upload-time = "2026-10-23T13:49:31.811Z" }, + { url = "https://files.pythonhosted.org/packages/50/94/aa275cdb099fd84e402977f8fc8628e2cee2f7c8eafe1d1d5c5e722f5ee5/jiter-0.18.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:1517648b5f6268513dea206241a99d9991d6ffcbdbc406848e77a7f02ed3ccf1", size = 289648, upload-time = "2026-10-23T13:49:33.059Z" }, + { url = "https://files.pythonhosted.org/packages/8d/30/3eaf67279c6183393d3608b6713c93668ae82ea59f0589ea59d8176d8741/jiter-0.18.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7161217e2190b9b2c8c79b81699be29d67010f6f77e09a53a3b62261792d5489", size = 315919, upload-time = "2026-10-23T13:49:34.457Z" }, + { url = "https://files.pythonhosted.org/packages/f8/2b/d18adcfec3516b97b24c0d5cd1b0ced22cada8ea9806f21bece75af49ffe/jiter-0.18.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9623fc90f1a4754452a525383ce70476476c16556098944709b8cdbd9ad905f0", size = 335231, upload-time = "2026-10-23T13:49:35.776Z" }, + { url = "https://files.pythonhosted.org/packages/41/e8/42cff1077883ea5311621dc9384a1ede4799bc3c01411798ac75f7a71f15/jiter-0.18.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f9083a7c2a4ee6358bc0401c46b4d5090f208f6fadfb6275c7b5fe3217e13506", size = 321590, upload-time = "2026-10-23T13:49:36.997Z" }, + { url = "https://files.pythonhosted.org/packages/1d/4d/2fbedfce563223d4783a872cead5f5bb74d2d1e418f963410ca28e4b7394/jiter-0.18.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4632f5172800da4cd42fd53f4553c772acd08f1c33dd7ac135e29d735080fa0d", size = 332960, upload-time = "2026-10-23T13:49:38.615Z" }, + { url = "https://files.pythonhosted.org/packages/04/a0/b082b2d8bd3bef9a888cc0a0f060a24644f24b5195f2e8227a40507e6b71/jiter-0.18.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c00b1f8fc1dd06c610305be36778b38148ed1e9a532bdd81189c3c0d9905c888", size = 348149, upload-time = "2026-10-23T13:49:39.826Z" }, + { url = "https://files.pythonhosted.org/packages/64/11/babc8d3c004bb2f11b7e3adfe27a5bc7c1e13cdfc6360d424c57355c55ff/jiter-0.18.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6e3350b7431f7b8315b925d9ca0f29a44e8fb6ed45c1fe552392cb6297966bb9", size = 335978, upload-time = "2026-10-23T13:49:41.165Z" }, + { url = "https://files.pythonhosted.org/packages/3b/21/c50bf83c39d60f0df896ebcb025b316b670a703397d08bea2c69b9615101/jiter-0.18.0-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:3b49071fb7917cdbc6d80c81a491c6ad146c1a8fd6cb3076cd3c1bfeb6e266f6", size = 313767, upload-time = "2026-10-23T13:49:42.538Z" }, + { url = "https://files.pythonhosted.org/packages/af/19/3f66480d5bfd3f49571a073eefac4d890dd590a8eb3c78b15e0293909cc6/jiter-0.18.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:04e210f5ddcccdbde484821040216a112381e6484abc549c20c38e9698ab07ca", size = 331070, upload-time = "2026-10-23T13:49:43.782Z" }, + { url = "https://files.pythonhosted.org/packages/5a/3d/b5662c84b14475c8b018ed1ca2ea44069194b7d97a03bac81ae6b46f6b9f/jiter-0.18.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:5b339f6ae14fe7be92f391cc65cc5c80ff76e8da76d63b18fc14664f09b7cece", size = 479939, upload-time = "2026-10-23T13:49:45.033Z" }, + { url = "https://files.pythonhosted.org/packages/80/b8/081c0414379ee2564aa7808f78e963538a2c4aed2f8d31775e2423e1cdbf/jiter-0.18.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:5cb43336244e063f9cc11e44730e4b92dea70c6eb9b649d268c5ebebc4bc7685", size = 514734, upload-time = "2026-10-23T13:49:46.236Z" }, + { url = "https://files.pythonhosted.org/packages/0f/1c/6f7bf98786851ae424a1d88562586302536cc137848fd12d2add3960fab3/jiter-0.18.0-cp313-cp313-win32.whl", hash = "sha256:9656d0e9001f69c4af6523874ff445ab4e5db7b835f59733cc5ff51e73a9aa57", size = 184699, upload-time = "2026-10-23T13:49:47.398Z" }, + { url = "https://files.pythonhosted.org/packages/38/53/5803216c024a241a0bf41ed2668713d7228f92c5593e40d5e873e3b20e0b/jiter-0.18.0-cp313-cp313-win_amd64.whl", hash = "sha256:8f26198220165eb9627847401fff4d0ca8bebf3ef840a88c6312918d2291c33a", size = 222493, upload-time = "2026-10-23T13:49:48.533Z" }, + { url = "https://files.pythonhosted.org/packages/fe/8e/484919ccb041c9a1e84059be02bd37ff086b8b084e21630e0958d3ae41a3/jiter-0.18.0-cp313-cp313-win_arm64.whl", hash = "sha256:bef1fe687dc6af17bef9f644a95d465f15f0efa20b743c858e0b6a14e2c0c73e", size = 181250, upload-time = "2026-10-23T13:49:49.777Z" }, + { url = "https://files.pythonhosted.org/packages/74/0e/45a502771d73d4a939132d8bf85d7b049c7ca06a07f84b414b525c3dc084/jiter-0.18.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:248e939f67a9f8030e2624260a9f417decfe275af37aa96728d256468a9c4086", size = 291757, upload-time = "2026-10-23T13:49:50.95Z" }, + { url = "https://files.pythonhosted.org/packages/21/f6/d9cfa2bf2a969fb8e002fb8d8a6cd98d49a6248cb7e4ffe2247766af13fb/jiter-0.18.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0390fa550fcafbf69fb97ccb287bd71192f90410a1c7dd600ca4000aa9aabcf2", size = 318585, upload-time = "2026-10-23T13:49:52.407Z" }, + { url = "https://files.pythonhosted.org/packages/46/38/ea1dae56f123e3a864188cbbc577314293c0dcc019a880fa9c0a8097934a/jiter-0.18.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d8013186f2b9a8c27ededa601050392527aa9d27ffd35d49aae424fbd2062f38", size = 338099, upload-time = "2026-10-23T13:49:53.658Z" }, + { url = "https://files.pythonhosted.org/packages/1f/d9/fcc5c53a32f98d52f4fd46fda62b69f5c7c2c975a582c0e18501250a4f78/jiter-0.18.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bd4316df8e2074fcf5173f6001f1fc9596e7c1e8c4bf499b02f9ebe92babdfb1", size = 324016, upload-time = "2026-10-23T13:49:54.999Z" }, + { url = "https://files.pythonhosted.org/packages/d4/63/c24cd08907f08e6a3ba3173616ad268a3d32dd81c63ba34b991d08577d28/jiter-0.18.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a9e474da7a9f65d3b460cca93cc8a0f4ec0220d1fa41f1f7a3709195ead60056", size = 335904, upload-time = "2026-10-23T13:49:56.214Z" }, + { url = "https://files.pythonhosted.org/packages/0b/78/19ca1c8fe87bd3c8540b91504ff2dd52c9c538233044c4cf787fc1fab39b/jiter-0.18.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d55acd326db8ecfc94f21951abd20902c7939d35925444e48d94527e287bead7", size = 350523, upload-time = "2026-10-23T13:49:57.552Z" }, + { url = "https://files.pythonhosted.org/packages/c3/27/84be9cc1c2b781d2da7c694fd7608311af3aaab91f20eb00d4999285b351/jiter-0.18.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a01642d403b8925f2b1e1bb51b4ba49ece8a2bdc9b9560fc8ed0b1f2b35b567a", size = 338324, upload-time = "2026-10-23T13:49:58.842Z" }, + { url = "https://files.pythonhosted.org/packages/9a/ac/7b3bfb49b19e42ebc2ae56ec307c372602dd1e17892f7e051c9bf97cd7e6/jiter-0.18.0-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:89ba6b674d4bd7290f9943bbeba0e1bf35955bbb1e07e41ba94691648cf133d5", size = 316484, upload-time = "2026-10-23T13:50:00.257Z" }, + { url = "https://files.pythonhosted.org/packages/f9/6a/e37f50885aa4daa1dfe413784692ead6b48a1d9e857cd394a61bf345189c/jiter-0.18.0-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:feadebdfee32c61e91066433f4aa74c891752e26e43032c1feef08dda6d9b6ed", size = 334225, upload-time = "2026-10-23T13:50:01.542Z" }, + { url = "https://files.pythonhosted.org/packages/8b/f8/1026bc92f0fd443a1137993d1448a7d7c4b7a34bec2722a1533302ebc4b4/jiter-0.18.0-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:dd7e57efd54a3580620f635c48a3226f910e23649b7eb83ffbc6f0f3386293b8", size = 482157, upload-time = "2026-10-23T13:50:02.849Z" }, + { url = "https://files.pythonhosted.org/packages/1b/2d/61f3c35736873c34eeee3d0008067febd88ded8e8cf6f9a0ab090348a787/jiter-0.18.0-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:ea69e23481497c2143775a98d273ccc43de5c92a6387df18c903d2d37bc2b181", size = 516956, upload-time = "2026-10-23T13:50:04.19Z" }, + { url = "https://files.pythonhosted.org/packages/6b/bf/9d14be58e76324f4927c7f8e5dbe2f9fd04faaec884a6465173f8142eac1/jiter-0.18.0-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:d9b61af76a3cd90ad9656a331737d97dab8c05facb2d04cb41fb16c9adadc966", size = 112087, upload-time = "2026-10-23T13:50:05.423Z" }, + { url = "https://files.pythonhosted.org/packages/c6/7d/cff751c560d514da283bae595fe154714f285ec5ac15e2b16e9e0c0c8948/jiter-0.18.0-cp314-cp314-win32.whl", hash = "sha256:fe42726d7fe171cd8fc1966d4457a6aae03bd408d519d2cc5e7726805460b51e", size = 186562, upload-time = "2026-10-23T13:50:06.81Z" }, + { url = "https://files.pythonhosted.org/packages/04/70/4e7f51e517be4146400fd1ce642d535380a38c7db5ab475d38bbcd16a82d/jiter-0.18.0-cp314-cp314-win_amd64.whl", hash = "sha256:f1e738b851019d6bb6ff4a42c6319bdede967dec958ef3ec6feb7ab9d12408f7", size = 225448, upload-time = "2026-10-23T13:50:08.302Z" }, + { url = "https://files.pythonhosted.org/packages/78/43/02bfb85f63e04c87c406731197e41f2e6b415035e41497428e0422fb326e/jiter-0.18.0-cp314-cp314-win_arm64.whl", hash = "sha256:80a961b1c5c7786bc03b332deb7f7ebe818b7baa6e26685e2bf480548ca128b4", size = 182907, upload-time = "2026-10-23T13:50:09.795Z" }, + { url = "https://files.pythonhosted.org/packages/9c/66/5cbde35cbb14c8339af39c9bc61cbda08b212116f96603d23b7c9cc84a4d/jiter-0.18.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b066f37dd9ec19fc7931d79dee38f56b6f849217bbe824a7dad4518ef96ee515", size = 318962, upload-time = "2026-10-23T13:50:10.91Z" }, + { url = "https://files.pythonhosted.org/packages/eb/d1/dccc47ed6070d3b25622823048a80a49fe87ccd737e5d66b802ca20e4fde/jiter-0.18.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ccdc09887b04f50f1761eedcfd19da882d9d834096bc1215049af637023f7db7", size = 336718, upload-time = "2026-10-23T13:50:12.149Z" }, + { url = "https://files.pythonhosted.org/packages/de/a5/8d4ec06d7a0f2bccbde8508ed847ccd323a9dd1fbab5900cda3fc5bd71f8/jiter-0.18.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6133abcd0f332964fbb8145adb1ce775cd0312c9eaf6e4bf26b7a5c9b6f7cca7", size = 322945, upload-time = "2026-10-23T13:50:13.591Z" }, + { url = "https://files.pythonhosted.org/packages/7f/50/49d06214b30c685d64ffdd40fdb50a98b6ccff4b012fc9ed491d44de9ef1/jiter-0.18.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ca381b4a466023d1fdd04c889c759b46f7d9654f622b28bb01e65abf31d07bba", size = 335325, upload-time = "2026-10-23T13:50:14.807Z" }, + { url = "https://files.pythonhosted.org/packages/f4/9a/4ecb866a7a01a4e76d9ffbde3fac2cd66ad978c8c797953d44f91fbf2040/jiter-0.18.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9b961fedf589ffa182fe302fc4371acf4606d3ed4a6a48a151fbfd724d811f5a", size = 350578, upload-time = "2026-10-23T13:50:16.125Z" }, + { url = "https://files.pythonhosted.org/packages/16/7e/c8b5ecb6af4c9454376263f167f3f8bb5dec41b10fac4f48ea4557b9f115/jiter-0.18.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3b77eabfbae1ac47872be0076899e66340bbef39b862971c3d6c9a4b7c91fd10", size = 338791, upload-time = "2026-10-23T13:50:17.703Z" }, + { url = "https://files.pythonhosted.org/packages/8a/04/45ba31ce79022706323fd2291f87d956fd51fdfcba2ba8924b3de62f0ce2/jiter-0.18.0-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:92a16933d0fa852133500837d33cd6a4f75e4414d77389c58269e12bafc2ee02", size = 316169, upload-time = "2026-10-23T13:50:18.915Z" }, + { url = "https://files.pythonhosted.org/packages/62/c1/fd36126144f4c32d1b76939278e9d3b7b798075c0478b641d6066621bafd/jiter-0.18.0-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2f7ba518893a4ccef5afb38e41bc3e126bf652354417ec4e75e5a5b000fb1ef6", size = 334754, upload-time = "2026-10-23T13:50:20.169Z" }, + { url = "https://files.pythonhosted.org/packages/cc/e2/30a5ac1a3ee9e01bda75a4fcb55bbeddcf8875f8ce7e680b787c177f14b5/jiter-0.18.0-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:04d67a44b040a6662a35edc9869030f7aa566bf5baaf3549c99d847aa44213e2", size = 481094, upload-time = "2026-10-23T13:50:21.481Z" }, + { url = "https://files.pythonhosted.org/packages/33/de/5e736a36eff6933da012dc440540f79e3ccfc06e27f557638280657df023/jiter-0.18.0-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:e4d4819398d5330636bc0b91ccc0048dba782076fb99257038257ba6f121c840", size = 515524, upload-time = "2026-10-23T13:50:22.872Z" }, + { url = "https://files.pythonhosted.org/packages/0a/ea/1e8bc5b0c920a13e5b698106dbb2d2da5c5e3474668746246f649abb6d5f/jiter-0.18.0-cp314-cp314t-win32.whl", hash = "sha256:c435e795a7ea4b372166a058a5b49a25caeb9c94e469a1414868b14c83ee5c41", size = 185058, upload-time = "2026-10-23T13:50:24.098Z" }, + { url = "https://files.pythonhosted.org/packages/1e/0f/a742b397699c3af52dd95443332164884fe6204e5faa5321b7c073beab0f/jiter-0.18.0-cp314-cp314t-win_amd64.whl", hash = "sha256:5a3d5397da7ae46c7a9601ef02d2c9ec47a6c3abe15e1ea940eaf93e675ee20e", size = 225598, upload-time = "2026-10-23T13:50:25.44Z" }, + { url = "https://files.pythonhosted.org/packages/b3/b7/08ae26347dca48d5cadca33be2f2f5b6b1ae790b322109083d6f95959feb/jiter-0.18.0-cp314-cp314t-win_arm64.whl", hash = "sha256:4b81b474e4a8ec745ab20a6762275a360e1147cb70cf08872ec14e1aa5debc37", size = 183052, upload-time = "2026-10-23T13:50:26.675Z" }, + { url = "https://files.pythonhosted.org/packages/c2/d6/0d2a8a9747ad918141827fabdc05abc3bf73986f7f36647fb8c19708e21e/jiter-0.18.0-cp315-cp315-macosx_10_12_x86_64.whl", hash = "sha256:30f8ae18425e0247ffff4e4a5753ec1952e1b81ed4e7949b84e5ecfaf8315833", size = 291908, upload-time = "2026-10-23T13:50:27.94Z" }, + { url = "https://files.pythonhosted.org/packages/54/b4/19c582727e22681c6069db037c3b3e354c6fbdce7fbc5290a7bc7bc5884f/jiter-0.18.0-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:93150a3bb0317d8f5a94d4c3ea68db1cb434b94ac819e08c443cea97b7645f2f", size = 316544, upload-time = "2026-10-23T13:50:29.167Z" }, + { url = "https://files.pythonhosted.org/packages/c3/62/5d34e93dc5d1e707788a378335efc876cdc731ceb2111b0a9d7c6f9fdada/jiter-0.18.0-cp315-cp315-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c9c8a61d6227cdcb0a67c678f30a020837c9f3dd7e0b3f916781defa157e4eb9", size = 338101, upload-time = "2026-10-23T13:50:30.457Z" }, + { url = "https://files.pythonhosted.org/packages/75/e2/0b16a6ca5479cd9efa3c59497cd42f1979a539b6c664a5b9c87e3632f176/jiter-0.18.0-cp315-cp315-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:285cc15ff9ffcd4ce7f0b9ce02fcbc65e22fcf7dfbda1a3d71ccac8d7b73f8a1", size = 324213, upload-time = "2026-10-23T13:50:31.695Z" }, + { url = "https://files.pythonhosted.org/packages/85/9d/620a97457a0210092bf9faa1eb30f5da094fab2de07a9478af7c254e22fd/jiter-0.18.0-cp315-cp315-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c8f69ef2e28f8c1759bc1522385ab3e4ade0b1056053cecf67449a947c4525a8", size = 335777, upload-time = "2026-10-23T13:50:32.984Z" }, + { url = "https://files.pythonhosted.org/packages/76/08/a3514df093824f10a61dc1d0bbc22285ed779ba42f15d727499a8c877e16/jiter-0.18.0-cp315-cp315-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:eec2da60423287bd60377b0fad1723560dcc51cfb2b99615be8431ad425c4438", size = 350490, upload-time = "2026-10-23T13:50:34.421Z" }, + { url = "https://files.pythonhosted.org/packages/cd/60/8f8b51bae62259b429e83d0adff69d93e39e4fadbc4bd1856dc2a0950639/jiter-0.18.0-cp315-cp315-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5db2cdae6a2f01e8f52ab2154886dcf5bb1844b4f31245440bf623ec91b65b08", size = 338591, upload-time = "2026-10-23T13:50:35.759Z" }, + { url = "https://files.pythonhosted.org/packages/2e/ed/5307f0eb051d987510fdd1020c904927c0b364a4937d372817bdefaced31/jiter-0.18.0-cp315-cp315-manylinux_2_31_riscv64.whl", hash = "sha256:029da1f29852beac2f9001f20209b73b29b4d7bdc748c7f8028895769e2cc0d8", size = 316623, upload-time = "2026-10-23T13:50:37.316Z" }, + { url = "https://files.pythonhosted.org/packages/f9/0e/4bdc945ffbf77c60f07c726fbeb45508018322df9d9942d262256397062e/jiter-0.18.0-cp315-cp315-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:67c6662b1b7e5728a507db06ad1b8a7ff8ade04c2a74f092d467209ef744d3a4", size = 334720, upload-time = "2026-10-23T13:50:38.507Z" }, + { url = "https://files.pythonhosted.org/packages/4b/33/fb3e8f9354e7edab05f3752383eac58ce6e785f2f1626b697dd5dd0a86e4/jiter-0.18.0-cp315-cp315-musllinux_1_1_aarch64.whl", hash = "sha256:4db12daef4a231df528a16f70d5ff7f5e3be21f70e8ad904e4c61442366e8a10", size = 482130, upload-time = "2026-10-23T13:50:40.023Z" }, + { url = "https://files.pythonhosted.org/packages/2e/3d/3aef2be95155bbacadd8691208b6f0f7371cc0cefe80241a1245e38e308d/jiter-0.18.0-cp315-cp315-musllinux_1_1_x86_64.whl", hash = "sha256:4654ea93f525ea96adf289afcf1ead32d773b8325ec326862b4f81f5f4570835", size = 516986, upload-time = "2026-10-23T13:50:41.279Z" }, + { url = "https://files.pythonhosted.org/packages/3c/f6/2aa54fd5da3d0a93de2655e2525426263168454259ba3f2fb70d1b36fbc9/jiter-0.18.0-cp315-cp315-win32.whl", hash = "sha256:f035d01b450ac4e141502f1ce142462cee638198ff5a0237c80e6683798b3b87", size = 186645, upload-time = "2026-10-23T13:50:42.526Z" }, + { url = "https://files.pythonhosted.org/packages/b5/77/5b54ca8c292b83991cafbac6b022f515e46f1ae77dd5f4a97cc33644b235/jiter-0.18.0-cp315-cp315-win_amd64.whl", hash = "sha256:4a18ef4fe95685b000d95eca797cc683e0c178a4b364f2e39f6c79ab107a26e6", size = 225087, upload-time = "2026-10-23T13:50:43.779Z" }, + { url = "https://files.pythonhosted.org/packages/9f/f3/53b7f39b83c757380ab57d9bc3f934431d6b6751f007e8122f7f63c10c2c/jiter-0.18.0-cp315-cp315-win_arm64.whl", hash = "sha256:c73922e4ff4b1ad2929cd795c98223c6688a43c5fd42e9deb8955e4d43b00abb", size = 183120, upload-time = "2026-10-23T13:50:44.985Z" }, + { url = "https://files.pythonhosted.org/packages/77/f8/3a3ef55c528722f3b4be0e7b9686a37ddbe86ed96510bc1c2a63dab7f14b/jiter-0.18.0-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:0ccf55f6fcdcee82fe40ae617e9d64b8e5f433fa6cb5bf7d2969e584e6df0e5d", size = 317996, upload-time = "2026-10-23T13:50:46.266Z" }, + { url = "https://files.pythonhosted.org/packages/e1/15/b06c1c17bed30b5c5dabb40f80a56a3b71b89c16ae86552307f7ccedc93a/jiter-0.18.0-cp315-cp315t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:163a55e77f8e92d739b1f4ef212f1d445ddc58ecdf0da1feca44ef424b5331f8", size = 336638, upload-time = "2026-10-23T13:50:47.444Z" }, + { url = "https://files.pythonhosted.org/packages/87/79/b7bcd3e8c850326a323d18a5607334ea40659e22a4fc321e315d1d230007/jiter-0.18.0-cp315-cp315t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:9de6c9133be12a51ea2d8c270f39a04ed45ee369802bb6270649b952e6cec256", size = 323116, upload-time = "2026-10-23T13:50:48.715Z" }, + { url = "https://files.pythonhosted.org/packages/5e/99/4c53c9d46462cd0691c3c188f89612e63a424d19f5befd1b0631f8f90638/jiter-0.18.0-cp315-cp315t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2ea4f2ed18eba7454182d4ff727444788ae51ad11bf5a25ad892f5f0ad3e754b", size = 335162, upload-time = "2026-10-23T13:50:49.987Z" }, + { url = "https://files.pythonhosted.org/packages/6f/ab/ef873065a3a1c442a4e62558b77bfa338066317dbafdfdc991121201f5ad/jiter-0.18.0-cp315-cp315t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:626d5c9fb8b57babc6ce9d03224846ecb094e1d22ff5bff6080398e7f8aee162", size = 350560, upload-time = "2026-10-23T13:50:51.478Z" }, + { url = "https://files.pythonhosted.org/packages/19/7e/48e78558d7cb3d289211da0397b7ed31cfe3efc98dd85f2324abd574c07c/jiter-0.18.0-cp315-cp315t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b3c3318cc6ef857b6554b43479c30e8249fc143189d500d4137cde9c58412e6d", size = 337848, upload-time = "2026-10-23T13:50:52.961Z" }, + { url = "https://files.pythonhosted.org/packages/2c/35/b0a093e72def7caec970dd8536c3d42af3add3aedfb3c06ac0588effde26/jiter-0.18.0-cp315-cp315t-manylinux_2_31_riscv64.whl", hash = "sha256:9a70f25f6de76a01e309e109c9bcf2143c5c126b3488dd17a25c7aa404b28f16", size = 315870, upload-time = "2026-10-23T13:50:54.152Z" }, + { url = "https://files.pythonhosted.org/packages/48/a4/fd7ca4d1ce8b876be7a260f5e31615854aed5b041553a63e85c4a265cb63/jiter-0.18.0-cp315-cp315t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:22d8dd757e603224e46786d63cb7d7bfbddc8f579a02e7b082840468d18c06f3", size = 335253, upload-time = "2026-10-23T13:50:55.427Z" }, + { url = "https://files.pythonhosted.org/packages/f5/71/ccd7154afecd4687b22a8195d5dc6460f89f6e17537ec78edb58a2faac34/jiter-0.18.0-cp315-cp315t-musllinux_1_1_aarch64.whl", hash = "sha256:552a8714f26ddcb43115c82da6d045b3b9f2fa5997d8b21b2f8ec3721503bebb", size = 480775, upload-time = "2026-10-23T13:50:56.91Z" }, + { url = "https://files.pythonhosted.org/packages/c8/b9/bad5391d7fb734cd6ebc383c8603bc324518bf4ce865f5d813908ae42596/jiter-0.18.0-cp315-cp315t-musllinux_1_1_x86_64.whl", hash = "sha256:8060a206e290410d3bfc3bd91715f3ec90a499246f8335d48927e0b3b6a6ccc5", size = 515619, upload-time = "2026-10-23T13:50:58.231Z" }, + { url = "https://files.pythonhosted.org/packages/c8/5c/9596452ad56340e6ed395c5fe27ab102bb2aa0c4b59de2e6a8b3dc3b03a7/jiter-0.18.0-cp315-cp315t-win32.whl", hash = "sha256:91d463858f11ee76ce8e39f391bbcbf1d4c3cc4703a1496fed3a5666dcd5e01d", size = 185204, upload-time = "2026-10-23T13:50:59.456Z" }, + { url = "https://files.pythonhosted.org/packages/08/c8/62c798e2a1a6f827eac1d45232c93b1b0e387a22d559c8483dc7302d5fd5/jiter-0.18.0-cp315-cp315t-win_amd64.whl", hash = "sha256:6ee49daab0b826279c152ad8d61171ea17f4197f91a5e14251d0d5d4adf51059", size = 224948, upload-time = "2026-10-23T13:51:00.624Z" }, + { url = "https://files.pythonhosted.org/packages/64/42/cdfa494914b6d512431e795d8d6226b84b77b733bb8b5eccafd5a1a86dad/jiter-0.18.0-cp315-cp315t-win_arm64.whl", hash = "sha256:bec676a0dc24d4dabd4bdfb3d1f1bf80d4d3dd892fc5c5b3f8f953e2459dbfce", size = 183182, upload-time = "2026-10-23T13:51:01.797Z" }, + { url = "https://files.pythonhosted.org/packages/a0/c2/49ee8f4743c27e61c52b4746ba636b43bedda97131a14043dc6f5ce5bb9d/jiter-0.18.0-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:118c1fd995f349f1cad0557f31d6860f336b4aeef7f002dedbc068027f68e2c3", size = 287302, upload-time = "2026-10-23T13:51:08.073Z" }, + { url = "https://files.pythonhosted.org/packages/60/72/394036294ac3226216f73bfa4b14df920eb5baf7fb80fa7e0a0d7ef442a6/jiter-0.18.0-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:44d0d719cd7845e66b01a0cf346ec9882073e710a05e89a5b6d87be47a9dc69c", size = 277797, upload-time = "2026-10-23T13:51:09.324Z" }, + { url = "https://files.pythonhosted.org/packages/ce/80/f0dadedaa9a109f31e8978c7db355593916968d5956f382188a3f8c0888c/jiter-0.18.0-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4d1d2dc4d930ebc225f488b6b3790acebb2e51b3a165a4a42cc1d05bb927f83e", size = 300192, upload-time = "2026-10-23T13:51:10.551Z" }, + { url = "https://files.pythonhosted.org/packages/93/51/e57dbc6c264ec6557a677189755fe4525d83439237418e3ae59771ac1cde/jiter-0.18.0-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ebb0c346b6c5d9c033fe9e9b6ed6a1ff6dac0288fe681c3434dde6eb9c264fa1", size = 301141, upload-time = "2026-10-23T13:51:11.882Z" }, +] + [[package]] name = "joblib" version = "1.6.0" @@ -1275,6 +1387,21 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/2c/b2/c2acb076590a98bee2816ed5f285e00df162a34238f9e276e175e14ebc35/langchain_ollama-1.1.0-py3-none-any.whl", hash = "sha256:43ac83a6eacb0f43855810739794dd55019e0d9b17bdcf3ecb3b1991ac3b59dd", size = 31413, upload-time = "2026-04-07T02:47:59.642Z" }, ] +[[package]] +name = "langchain-openai" +version = "1.7.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "langchain-core" }, + { name = "openai" }, + { name = "tiktoken" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/58/f5/a430230cb50b4b4ade021a5fe5df5a8c5adefa468435d460d2f77f2506ea/langchain_openai-1.7.3.tar.gz", hash = "sha256:c1d2d0fbd4f542ddcdf176c07abcf4d86c3b716513929250bbef04e3efc5e0b5", size = 3407726, upload-time = "2026-10-26T23:08:33.98Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c4/52/5bcba40b1d7e46f352a727c57c231b820069bc83310f97933e10eccbd935/langchain_openai-1.7.3-py3-none-any.whl", hash = "sha256:0ab77cc4579b87c50823b7ccb5d8af48d6c6ae2084f156dcdc37151fcc0717e6", size = 146342, upload-time = "2026-10-26T23:08:32.577Z" }, +] + [[package]] name = "langchain-protocol" version = "0.0.20" @@ -1887,6 +2014,7 @@ version = "0.1.0" source = { editable = "." } dependencies = [ { name = "chromadb" }, + { name = "fastapi" }, { name = "langchain-chroma" }, { name = "langchain-classic" }, { name = "langchain-community" }, @@ -1894,6 +2022,7 @@ dependencies = [ { name = "langchain-experimental" }, { name = "langchain-huggingface" }, { name = "langchain-ollama" }, + { name = "langchain-openai" }, { name = "langchain-text-splitters" }, { name = "pydantic" }, { name = "pypdf" }, @@ -1902,6 +2031,7 @@ dependencies = [ { name = "torch", version = "2.15.0", source = { registry = "https://download.pytorch.org/whl/cpu" }, marker = "sys_platform == 'darwin'" }, { name = "torch", version = "2.15.0+cpu", source = { registry = "https://download.pytorch.org/whl/cpu" }, marker = "sys_platform != 'darwin'" }, { name = "typer" }, + { name = "uvicorn" }, ] [package.dev-dependencies] @@ -1914,6 +2044,7 @@ dev = [ [package.metadata] requires-dist = [ { name = "chromadb", specifier = ">=1.0" }, + { name = "fastapi", specifier = ">=0.115" }, { name = "langchain-chroma", specifier = ">=1.0,<2" }, { name = "langchain-classic", specifier = ">=1.0,<2" }, { name = "langchain-community", specifier = ">=0.4,<0.5" }, @@ -1921,6 +2052,7 @@ requires-dist = [ { name = "langchain-experimental", specifier = ">=0.4,<0.5" }, { name = "langchain-huggingface", specifier = ">=1.0,<2" }, { name = "langchain-ollama", specifier = ">=1.0,<2" }, + { name = "langchain-openai", specifier = ">=1.0,<2" }, { name = "langchain-text-splitters", specifier = ">=1.1,<2" }, { name = "pydantic", specifier = ">=2.7" }, { name = "pypdf", specifier = ">=5.0" }, @@ -1928,6 +2060,7 @@ requires-dist = [ { name = "sentence-transformers", specifier = ">=5.0" }, { name = "torch", specifier = ">=2.4", index = "https://download.pytorch.org/whl/cpu" }, { name = "typer", specifier = ">=0.12" }, + { name = "uvicorn", specifier = ">=0.32" }, ] [package.metadata.requires-dev] @@ -1937,6 +2070,23 @@ dev = [ { name = "ruff", specifier = ">=0.6" }, ] +[[package]] +name = "openai" +version = "3.42.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "httpx2" }, + { name = "jiter" }, + { name = "pydantic" }, + { name = "sniffio" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9f/7b/e01d5288d13e3bae3714ed39df402f99f88f422dcd978c5ce94848037200/openai-3.42.1.tar.gz", hash = "sha256:4222d919374648ff572753626e942f26eb1ece8a5e0e9a2708c9be4d560f070f", size = 2356422, upload-time = "2026-11-01T20:57:02.607Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fd/11/37b847d8a057000193974eeea1bcc681355ae50d35865f2eb2b323de6153/openai-3.42.1-py3-none-any.whl", hash = "sha256:c1959518a8e26f81a3564357082cb684540be639a21fece35ac5619415a3eadc", size = 2397433, upload-time = "2026-11-01T20:57:00.622Z" }, +] + [[package]] name = "opentelemetry-api" version = "1.45.2" @@ -3228,6 +3378,19 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/c1/69/c75534e336b06b3fd3f76de73d89736510800e60c77c58d4e4ce18389018/sqlalchemy-2.1.6-py3-none-any.whl", hash = "sha256:106878cf3795cd3d357e2e858609f9e44f20f19b2d8e48a3532bef3f90b03fbe", size = 2063055, upload-time = "2026-10-21T18:42:10.234Z" }, ] +[[package]] +name = "starlette" +version = "1.10.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/48/bb/3d8757f21e9a53d9035c9eb039a777047139a16bfdbedfc7a58241c3d914/starlette-1.10.0.tar.gz", hash = "sha256:b8399098d4c1e3522734f7235dc79b1fc967f96cf139c81e0fa30479e0685f9b", size = 2734356, upload-time = "2026-10-24T15:04:12.342Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/88/2e/947cfe02def9371c07cd5bf5b6b61c829e9aecb9904db02a66cfafbc1eec/starlette-1.10.0-py3-none-any.whl", hash = "sha256:478c0ab3b4ced6e82719849c118fa406f0278a3499c1a898cd15cd31bdc38ce4", size = 80571, upload-time = "2026-10-24T15:04:10.371Z" }, +] + [[package]] name = "sympy" version = "1.14.0" @@ -3258,6 +3421,60 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/43/3f/f88a53f60a472b46f4023f56d204dd7de33d34c5d2acbfa0d70a674e639e/threadpoolctl-3.7.0-py3-none-any.whl", hash = "sha256:cd8b60b5641b45c67bbf73c64c843235fc2d8a480c87389f52f5dbee893b86be", size = 26362, upload-time = "2026-09-15T15:46:19.168Z" }, ] +[[package]] +name = "tiktoken" +version = "0.14.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "regex" }, + { name = "requests" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/66/62/167a842aa0429d45f5e797354fd4343a96f6043d67d0513c675c7b8d36e6/tiktoken-0.14.0.tar.gz", hash = "sha256:231dec90efcdccf1b565a1416107736f1e09b1a08fe736ef9d6363e626d03874", size = 38898, upload-time = "2026-08-17T19:49:49.514Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8c/da/e273746b9d24a63c776bc60fba914351573ad9c575b52601eb5e60632564/tiktoken-0.14.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:8e947aefe98ef74cce94923f90e48c98fe34eb1ec0a6bfdfadfc5a96359bfc36", size = 1094408, upload-time = "2026-08-17T19:48:49.269Z" }, + { url = "https://files.pythonhosted.org/packages/69/9f/fe6b1aca23331aa5271df5a4bd07bf68a7059254d47faee1b8272592a777/tiktoken-0.14.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:d6cebe67765569df3dafac8474e4eccf5c19d24140492567a5e58a11445732a4", size = 1038499, upload-time = "2026-08-17T19:48:50.666Z" }, + { url = "https://files.pythonhosted.org/packages/0b/35/e9f47647c9e163bd1de30fe1a491669b7248cfc67b7404c35c009a701e1a/tiktoken-0.14.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:7db45b98e94adf4173a5cd7422b150999a7ee11ff847783a14f6e1b80cc38cb6", size = 1186355, upload-time = "2026-08-17T19:48:51.93Z" }, + { url = "https://files.pythonhosted.org/packages/51/11/9976ad86980a00cdef05e730a0127a2578a1bc6d11644d8d47246de2eb26/tiktoken-0.14.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:7896eea257fe497a2b7134474d909156c6744ce8da35bce88011a960e008aa0d", size = 1204197, upload-time = "2026-08-17T19:48:53.18Z" }, + { url = "https://files.pythonhosted.org/packages/d4/9c/7035b0bcfaa68d1ee4803fc5be5214ad865669b05bd20e7105ae8a18afc6/tiktoken-0.14.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:b950248272f1b303dc32986396e2dccfa10cf6d1e83ec8f0bba1776660305482", size = 1250635, upload-time = "2026-08-17T19:48:54.392Z" }, + { url = "https://files.pythonhosted.org/packages/bc/1d/69cabf18bed7f4366da076735816abce0d4db3fae491ae338a6612128777/tiktoken-0.14.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3de75343041a1c57333b1e707ac8a9769738241d7d6a55d39e12cf84548337c6", size = 1316085, upload-time = "2026-08-17T19:48:55.525Z" }, + { url = "https://files.pythonhosted.org/packages/bd/bd/a2e884fb1402cba5be08836590320012b2d8ada0e2eef9911a64df4bcd2d/tiktoken-0.14.0-cp312-cp312-win_amd64.whl", hash = "sha256:087538c080e5ff421abd3a0785ed63c5111d06af98e6cd0d374dbe5969147ca3", size = 941208, upload-time = "2026-08-17T19:48:56.938Z" }, + { url = "https://files.pythonhosted.org/packages/50/53/ee1453623bf65f019328721ccb6587846d2c5b7b82f34e73ca09101f072e/tiktoken-0.14.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e9c5fe393aab56469f04e432ff851216d3def3436cf5f07e442a240164bf500f", size = 1094198, upload-time = "2026-08-17T19:48:57.955Z" }, + { url = "https://files.pythonhosted.org/packages/ad/5f/6448cfe278c3664ba9ec5b5ac08344341f7dc3d42888476e215a14eda2be/tiktoken-0.14.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:cbe2cc3bba939bcdaf103e03df9d5039d33887080b315624be28ec69059e5f94", size = 1038820, upload-time = "2026-08-17T19:48:59.015Z" }, + { url = "https://files.pythonhosted.org/packages/69/3b/d67eac1bcce9dee3abe23aff5e3ded3116bbebaf67b80a0811c06d3806fc/tiktoken-0.14.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:2157f52e4b4d7ac5ecc7457b3716834706e7ef9a46f5144029bfeb7cf71f4e06", size = 1186175, upload-time = "2026-08-17T19:49:00.068Z" }, + { url = "https://files.pythonhosted.org/packages/37/62/cae690d9783146b0f81f564ada0f8f611de68178c0c9c7e1e969f0516b48/tiktoken-0.14.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:26e60f6a956ee171ab728b37b8439905d7ea1db435c30f9822f291e9861c861d", size = 1203884, upload-time = "2026-08-17T19:49:01.163Z" }, + { url = "https://files.pythonhosted.org/packages/b9/1e/633e30237b94e383cf814145499079f3bb9cdd4aeafc1bc42e01b0f810a6/tiktoken-0.14.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:380873f330b741c4435574f37edb20813d04603ace2d53e0a63560e1fec83010", size = 1250980, upload-time = "2026-08-17T19:49:02.274Z" }, + { url = "https://files.pythonhosted.org/packages/cb/56/4c12f07b812f84206f38d723eb1ebfdd34bad9309b5dbc0bee6bbcff4cbf/tiktoken-0.14.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:3fd7c14b1cb45b486c39fc9b3443bb341f3e2fc7e6f31247f3435a5836651632", size = 1315434, upload-time = "2026-08-17T19:49:03.434Z" }, + { url = "https://files.pythonhosted.org/packages/c9/e0/c65603f0c44811def666d3fbf611bf2af3b5e1ef613e06c19411419830b3/tiktoken-0.14.0-cp313-cp313-win_amd64.whl", hash = "sha256:90a762670c7f968184723769a06ed51f5cf5ce5dcd1e30164f25c72d85c2d1f1", size = 940883, upload-time = "2026-08-17T19:49:04.583Z" }, + { url = "https://files.pythonhosted.org/packages/59/b0/1cf129f4af8fc513931f931023def596b7c4bfc77026513cd9d851da9e88/tiktoken-0.14.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:e067f4cbcc5d036e8aff7fe7a6b530a8f4de2e4616ad9005a24a1879e24e6450", size = 1096273, upload-time = "2026-08-17T19:49:05.807Z" }, + { url = "https://files.pythonhosted.org/packages/62/85/2ae74575e321148484147e10b53c3b1717c59ebaa9edb4fe18b1f5c055f8/tiktoken-0.14.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:f2af4a336ea56d6c14f27741a0e1d8294a35dd0b038bcf990d232ebb54eb994b", size = 1040269, upload-time = "2026-08-17T19:49:06.943Z" }, + { url = "https://files.pythonhosted.org/packages/89/29/92a1120a12e4bcf2d5464350d1a91b68a433d63ce656bb7f806c27aec09c/tiktoken-0.14.0-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:f702e0aeeb6506e57687e881c59e844ebe8f0a6a097ddafe20e3ab25f387be4e", size = 1186101, upload-time = "2026-08-17T19:49:08.102Z" }, + { url = "https://files.pythonhosted.org/packages/5b/7d/144af98dc5ad68108451a82e2f5a17f80e2663f5115058b8dfd215c1ad02/tiktoken-0.14.0-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:e3442bbb2f0c588cec876061e37ae67b455b9df9978b003c8fe30e45f2ef5b42", size = 1204457, upload-time = "2026-08-17T19:49:09.28Z" }, + { url = "https://files.pythonhosted.org/packages/e6/1f/be7cb06ab2108f612f3e92e7b76cf391e192db0db37a984616f0cc32aafc/tiktoken-0.14.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:979c1524f753b662b0f3cd261b135afe6659cce33caaa7a5ea00dd1756b3055c", size = 1251716, upload-time = "2026-08-17T19:49:10.509Z" }, + { url = "https://files.pythonhosted.org/packages/ab/6b/81f158d0f90adb826cd704069c2129a046cb784a2a09861009519fc41cf4/tiktoken-0.14.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2cc19ac87b41c9493c9778ff5847f0c8bbcf5bd0ec6b87ce06c1c802adc8a771", size = 1315432, upload-time = "2026-08-17T19:49:11.844Z" }, + { url = "https://files.pythonhosted.org/packages/fc/ec/f5fa35ec13f07279fdcaf3cc9c04bbb154ea591d23978651f2b672593e8a/tiktoken-0.14.0-cp314-cp314-win_amd64.whl", hash = "sha256:eceeff0c62419bc78d4b6e70a4762a4d25df3ae8f2d5946e3853ce93e7a57098", size = 988046, upload-time = "2026-08-17T19:49:13.282Z" }, + { url = "https://files.pythonhosted.org/packages/68/c9/7756717408d3d0dfea3f046c9466144b28afde39ff69d5808f2475dcd7f5/tiktoken-0.14.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:6eb94895c45f26bb8f5546e5fd8a069efcf6e3f108ea9d5cbe3bf6f7f3983438", size = 1096261, upload-time = "2026-08-17T19:49:14.351Z" }, + { url = "https://files.pythonhosted.org/packages/79/29/46ad8061f57bd9f8b2ea0aa82bf574e0f2aa040b0857a1582adba9957899/tiktoken-0.14.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:86951a971c53979ec857bd8c4a32dc227ab0fd33f6c12a3bd62d3fbf5f0bfcaa", size = 1040183, upload-time = "2026-08-17T19:49:15.707Z" }, + { url = "https://files.pythonhosted.org/packages/5a/7c/3184d17b868456f17b60b1a75f5ec0405618a43aa753336df341d8f11781/tiktoken-0.14.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:e2eca764c53490f8930dbce329e0769f11108d87d908282a80c5c130e26e7037", size = 1186719, upload-time = "2026-08-17T19:49:16.84Z" }, + { url = "https://files.pythonhosted.org/packages/0b/e8/46de4400d5bf859f640feee85bd7e32235f68ddf25db53c63be78e581e3a/tiktoken-0.14.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:26cc4b4840fa0e9f4b72ed489883e12f57e00d1021ca794720e3c29a12f0edef", size = 1204660, upload-time = "2026-08-17T19:49:17.987Z" }, + { url = "https://files.pythonhosted.org/packages/29/ce/af8964c38bc8226dd8950305b7a255fa33345d5572f78af7275a313d28e0/tiktoken-0.14.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:2fc834fbe3f6a0736905c36ab709537e6840dbd63b982dc9e0216ae7d305ba1a", size = 1250932, upload-time = "2026-08-17T19:49:19.28Z" }, + { url = "https://files.pythonhosted.org/packages/1d/4b/323631116fc986d9cc5bbeb2b8223c7c85e61a8bb94ea5ab4951023b149b/tiktoken-0.14.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ca4db6ff5c5bf600f9b7761a0070ed44dfe5797a76bd432fb978bc480ef40c58", size = 1315190, upload-time = "2026-08-17T19:49:20.467Z" }, + { url = "https://files.pythonhosted.org/packages/18/8b/ba48a73729c9270989b36f37ab2ed5525e52690d715097c9fa791aaa5d05/tiktoken-0.14.0-cp314-cp314t-win_amd64.whl", hash = "sha256:7aab286a020660a039097912a088236b985d18a3090d73f136c4413d29d37ca0", size = 987717, upload-time = "2026-08-17T19:49:21.704Z" }, + { url = "https://files.pythonhosted.org/packages/1d/10/b73b7e319179e0f60b32475f783b044f9cece872c53b6662664e9084b0d0/tiktoken-0.14.0-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:14b47e3674f2624803a8acc8fb367b7e24fc53055f9df3296482fe9a3a34a232", size = 1096280, upload-time = "2026-08-17T19:49:22.779Z" }, + { url = "https://files.pythonhosted.org/packages/c2/6b/09999a9bf1d559670d1680e8f8e419ac0e2c5f6aac82e9bfdf70f260b30a/tiktoken-0.14.0-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:19d643d701fdaa70e5b9c7f8f96abcaffe77ca5e482a3a1a7dde46feb4284695", size = 1040433, upload-time = "2026-08-17T19:49:23.998Z" }, + { url = "https://files.pythonhosted.org/packages/cd/7b/8537be0836f3df99b2a636b44399bfa43cd757f2b8b4097dacb794cf24a7/tiktoken-0.14.0-cp315-cp315-manylinux_2_28_aarch64.whl", hash = "sha256:e4ddf863b59347deaa92302dcd90e5eb003cdc9be06ec2b692c38d1bdd9efd49", size = 1186989, upload-time = "2026-08-17T19:49:25.021Z" }, + { url = "https://files.pythonhosted.org/packages/7c/9d/f9c56d7a943a4468abf9ef37661bb9b8e0cd3aa8aa87368c7146cc3f3222/tiktoken-0.14.0-cp315-cp315-manylinux_2_28_x86_64.whl", hash = "sha256:60c47ca69ddda0dea8256fffd12e1b86f4b59734a20e4a70c61f63cc5f021df4", size = 1204615, upload-time = "2026-08-17T19:49:26.37Z" }, + { url = "https://files.pythonhosted.org/packages/4b/d2/98a38579db25c4a8a84e31dd95d9072ec5f21f7e70de591da0412e29b25b/tiktoken-0.14.0-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:728303a072163130c5b477b1f20d6211895569c1d5302c24ffc93a3009160871", size = 1251828, upload-time = "2026-08-17T19:49:27.423Z" }, + { url = "https://files.pythonhosted.org/packages/0c/83/467be424746c039c5493c0f4102feab16b9b48eb6f5c089b2a2438e3cde2/tiktoken-0.14.0-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:3c5349c9f916283bba32bec8af69b763e4faa304dc004d0eaaea66a3cf004c1f", size = 1316260, upload-time = "2026-08-17T19:49:29.101Z" }, + { url = "https://files.pythonhosted.org/packages/02/ee/ddf46ca78e371f5890e96b6e7d089a85b3536432be219851eb0481786ca8/tiktoken-0.14.0-cp315-cp315-win_amd64.whl", hash = "sha256:1b6e4adcfd285c44502aed51df98aaaca4f0fea028165dbf8a9e857b9f98d8ea", size = 988230, upload-time = "2026-08-17T19:49:30.246Z" }, + { url = "https://files.pythonhosted.org/packages/2a/00/5162e90c851a28da18ed382d34898b79a8022548e5619a64e14c03ce7c3d/tiktoken-0.14.0-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:11d8211b290855d2721334ff17dd9b3a17bfb26872be01f25d73612ef7ece890", size = 1096186, upload-time = "2026-08-17T19:49:31.656Z" }, + { url = "https://files.pythonhosted.org/packages/65/97/a5a7bfccf25b1bb65e82bae8edff11ac3c9c041c374b7b4a823d60c38133/tiktoken-0.14.0-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:d0781223705199b289faa59601bb9c2441712d4c600dd13c43d8fd6a33d22cd5", size = 1039947, upload-time = "2026-08-17T19:49:32.848Z" }, + { url = "https://files.pythonhosted.org/packages/fb/ba/ef427fc638f1439181c5e12dd26b70e881861f89c007aa7e5b36300f8342/tiktoken-0.14.0-cp315-cp315t-manylinux_2_28_aarch64.whl", hash = "sha256:2ea70afba6b9eddbf22c165142e5f0a2ad7aa36a452873c48b57bb2aeb8492ae", size = 1186997, upload-time = "2026-08-17T19:49:34.121Z" }, + { url = "https://files.pythonhosted.org/packages/3e/88/2f3f85a968cdc514152129af0a060ebcccb067005a2f29b0d5ef3c838514/tiktoken-0.14.0-cp315-cp315t-manylinux_2_28_x86_64.whl", hash = "sha256:78571efc311c30b73f31eb949a921d6dac39a5d9dc42d1cfa8f8db157b3447b1", size = 1205211, upload-time = "2026-08-17T19:49:35.284Z" }, + { url = "https://files.pythonhosted.org/packages/4e/f6/80760e98a08e6649d2d68afb6035af713121dfb615acce8c4f73810ec438/tiktoken-0.14.0-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:86f66c85e796f5d05d5c4a60ec1d40cbfebc47a32464053528c797163fa9ab89", size = 1251479, upload-time = "2026-08-17T19:49:36.419Z" }, + { url = "https://files.pythonhosted.org/packages/c5/84/50966fb6918a0fb9b32721277e5342bf729a2d74350074d662fbedf9772e/tiktoken-0.14.0-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:149d97453c4c98c04b081d64a85e635921269b532710d6faf81e9e82b790e7d3", size = 1316673, upload-time = "2026-08-17T19:49:37.756Z" }, + { url = "https://files.pythonhosted.org/packages/35/5e/9b01afd037bfa22a0033963fa091e0f75b6fb15cd85bffb42ff86e697323/tiktoken-0.14.0-cp315-cp315t-win_amd64.whl", hash = "sha256:561e7580f84a79859af1ef6f676968e9030fcc3fe195700b15235bca64f009c9", size = 987929, upload-time = "2026-08-17T19:49:38.947Z" }, +] + [[package]] name = "tokenizers" version = "0.23.3" From 79619dd84366a7484c3d3073cfa9402262a37af1 Mon Sep 17 00:00:00 2001 From: Wadi Date: Mon, 2 Nov 2026 18:59:38 +0100 Subject: [PATCH 2/9] feat: Open RAG, a Windows desktop app with categories and sections - WPF shell (.NET 10) hosting a React 19 + Tailwind 4 interface in WebView2, in the AI Engineering Arena's sticker-arcade theme (light and dark, fonts bundled for offline use) - sidebar of categories and sections; per section: folders, background indexing with progress, documents and a chat; a category chat searches all its sections; citations as pills and source cards that open the file - the app starts ore serve itself (bundled Python when installed, uv in a checkout), ties it to a job object and routes every API call through an EngineProxy that adds the token and allows only the engine's API paths, so the page never sees the token or talks to a local port - conversations kept per section on this computer; follow-up questions use the recent history - ore serve: --data-dir and --warm; python -m open_rag_engine - tests: 36 .NET (engine start, ready line, locator, proxy, safe file opening), 13 web, engine suite; Windows CI job --- .github/workflows/ci.yml | 26 + .gitignore | 6 + desktop/OpenRag.slnx | 9 + desktop/README.md | 55 + desktop/src/OpenRag.App/App.xaml | 3 + desktop/src/OpenRag.App/App.xaml.cs | 39 + desktop/src/OpenRag.App/AssemblyInfo.cs | 10 + desktop/src/OpenRag.App/Assets/OpenRag.ico | Bin 0 -> 63576 bytes desktop/src/OpenRag.App/Assets/OpenRag.png | Bin 0 -> 24587 bytes desktop/src/OpenRag.App/ChildProcessJob.cs | 92 + desktop/src/OpenRag.App/MainWindow.xaml | 9 + desktop/src/OpenRag.App/MainWindow.xaml.cs | 307 + desktop/src/OpenRag.App/OpenRag.App.csproj | 55 + desktop/src/OpenRag.App/SingleInstance.cs | 57 + desktop/src/OpenRag.Core/Engine.cs | 260 + desktop/src/OpenRag.Core/EngineProxy.cs | 90 + desktop/src/OpenRag.Core/OpenRag.Core.csproj | 9 + .../OpenRag.Core.Tests/EngineProxyTests.cs | 103 + .../tests/OpenRag.Core.Tests/EngineTests.cs | 157 + .../OpenRag.Core.Tests.csproj | 25 + desktop/tools/make_icon.py | 65 + desktop/web/.gitignore | 24 + desktop/web/eslint.config.js | 28 + desktop/web/index.html | 12 + desktop/web/package-lock.json | 5140 +++++++++++++++++ desktop/web/package.json | 41 + desktop/web/src/App.tsx | 239 + desktop/web/src/components/Chat.tsx | 133 + desktop/web/src/components/Dialogs.tsx | 102 + desktop/web/src/components/Main.tsx | 80 + desktop/web/src/components/Message.tsx | 127 + desktop/web/src/components/Screens.tsx | 57 + desktop/web/src/components/SectionPanel.tsx | 148 + desktop/web/src/components/Sidebar.tsx | 140 + desktop/web/src/components/primitives.tsx | 96 + desktop/web/src/hooks/useChat.ts | 76 + desktop/web/src/hooks/useEngine.ts | 15 + desktop/web/src/hooks/useLibrary.ts | 50 + desktop/web/src/index.css | 175 + desktop/web/src/main.tsx | 10 + desktop/web/src/vite-env.d.ts | 1 + desktop/web/tsconfig.app.json | 27 + desktop/web/tsconfig.json | 7 + desktop/web/tsconfig.node.json | 25 + desktop/web/vite.config.ts | 11 + docs/adr/0007-desktop-app.md | 10 +- src/open_rag_engine/__main__.py | 5 + src/open_rag_engine/cli.py | 18 +- tests/test_engine_and_cli.py | 16 + 49 files changed, 8186 insertions(+), 4 deletions(-) create mode 100644 desktop/OpenRag.slnx create mode 100644 desktop/README.md create mode 100644 desktop/src/OpenRag.App/App.xaml create mode 100644 desktop/src/OpenRag.App/App.xaml.cs create mode 100644 desktop/src/OpenRag.App/AssemblyInfo.cs create mode 100644 desktop/src/OpenRag.App/Assets/OpenRag.ico create mode 100644 desktop/src/OpenRag.App/Assets/OpenRag.png create mode 100644 desktop/src/OpenRag.App/ChildProcessJob.cs create mode 100644 desktop/src/OpenRag.App/MainWindow.xaml create mode 100644 desktop/src/OpenRag.App/MainWindow.xaml.cs create mode 100644 desktop/src/OpenRag.App/OpenRag.App.csproj create mode 100644 desktop/src/OpenRag.App/SingleInstance.cs create mode 100644 desktop/src/OpenRag.Core/Engine.cs create mode 100644 desktop/src/OpenRag.Core/EngineProxy.cs create mode 100644 desktop/src/OpenRag.Core/OpenRag.Core.csproj create mode 100644 desktop/tests/OpenRag.Core.Tests/EngineProxyTests.cs create mode 100644 desktop/tests/OpenRag.Core.Tests/EngineTests.cs create mode 100644 desktop/tests/OpenRag.Core.Tests/OpenRag.Core.Tests.csproj create mode 100644 desktop/tools/make_icon.py create mode 100644 desktop/web/.gitignore create mode 100644 desktop/web/eslint.config.js create mode 100644 desktop/web/index.html create mode 100644 desktop/web/package-lock.json create mode 100644 desktop/web/package.json create mode 100644 desktop/web/src/App.tsx create mode 100644 desktop/web/src/components/Chat.tsx create mode 100644 desktop/web/src/components/Dialogs.tsx create mode 100644 desktop/web/src/components/Main.tsx create mode 100644 desktop/web/src/components/Message.tsx create mode 100644 desktop/web/src/components/Screens.tsx create mode 100644 desktop/web/src/components/SectionPanel.tsx create mode 100644 desktop/web/src/components/Sidebar.tsx create mode 100644 desktop/web/src/components/primitives.tsx create mode 100644 desktop/web/src/hooks/useChat.ts create mode 100644 desktop/web/src/hooks/useEngine.ts create mode 100644 desktop/web/src/hooks/useLibrary.ts create mode 100644 desktop/web/src/index.css create mode 100644 desktop/web/src/main.tsx create mode 100644 desktop/web/src/vite-env.d.ts create mode 100644 desktop/web/tsconfig.app.json create mode 100644 desktop/web/tsconfig.json create mode 100644 desktop/web/tsconfig.node.json create mode 100644 desktop/web/vite.config.ts create mode 100644 src/open_rag_engine/__main__.py diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index ddff0cd..75c97a7 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -24,3 +24,29 @@ jobs: uv run ruff format --check src tests - name: Test run: uv run pytest --cov --cov-report=term --cov-fail-under=80 + + desktop: + runs-on: windows-latest + defaults: + run: + working-directory: desktop + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-dotnet@v4 + with: + dotnet-version: "10.0.x" + - uses: actions/setup-node@v4 + with: + node-version: "20" + cache: npm + cache-dependency-path: desktop/web/package-lock.json + - name: Interface + working-directory: desktop/web + run: | + npm ci + npx tsc -b + npx eslint . + npx vitest run + npm run build + - name: App and tests + run: dotnet test OpenRag.slnx -c Release diff --git a/.gitignore b/.gitignore index 4ac4051..a21e148 100644 --- a/.gitignore +++ b/.gitignore @@ -221,3 +221,9 @@ __marimo__/ # open-rag-engine local data .ore/ + +# Desktop app build output +desktop/**/bin/ +desktop/**/obj/ +desktop/web/node_modules/ +desktop/web/dist/ diff --git a/desktop/OpenRag.slnx b/desktop/OpenRag.slnx new file mode 100644 index 0000000..32781f1 --- /dev/null +++ b/desktop/OpenRag.slnx @@ -0,0 +1,9 @@ + + + + + + + + + diff --git a/desktop/README.md b/desktop/README.md new file mode 100644 index 0000000..bf6dbc0 --- /dev/null +++ b/desktop/README.md @@ -0,0 +1,55 @@ +# Open RAG (desktop app) + +A Windows app for teachers, researchers and students. Organise documents into **categories** (a subject or research +area) and **sections** (a course, session, project or reading list). Ask questions and get cited answers from one section, or +from a whole category. Everything runs on this computer: see [ADR-0007](../docs/adr/0007-desktop-app.md). + +It looks like the [AI Engineering Arena](https://carthavate.github.io/ai-engineering-arena): the same "sticker arcade" theme, +in light or dark to match Windows, with the fonts bundled so it looks the same offline. + +## How it fits together + +```text +OpenRag.exe (WPF) + ├─ WebView2 ── the React interface (web/), served from the app's folder as https://app.ore + │ │ messages: api, ask, cancel, pickFolder, openSource, … + │ ▼ + ├─ EngineProxy ── adds the per-launch token, allows only the engine's API paths + │ │ HTTP on 127.0.0.1 + │ ▼ + └─ engine ─────── `ore serve` (Python), started and stopped by the app (job object + --parent-pid) +``` + +The page never sees the token and never talks to a local port. Answers stream back line by line through the window. + +| Folder | What | +|---|---| +| `src/OpenRag.App` | WPF shell: window, WebView2, folder dialog, opening cited files, engine lifetime | +| `src/OpenRag.Core` | Finding and starting the engine, the API proxy, safe file opening (unit-tested) | +| `web/` | React 19 + Tailwind 4 interface, with a mock engine for working in a browser | +| `tools/make_icon.py` | Draws the app icon | + +## Develop + +You need the .NET 10 SDK, Node 20 and, for the engine, `uv` with the repo's Python setup (see the main README). + +```bash +cd desktop +dotnet build OpenRag.slnx # builds web/ the first time, then the app +dotnet test OpenRag.slnx +``` + +Run `src/OpenRag.App/bin/Debug/net10.0-windows/OpenRag.exe`. In a checkout it finds the engine by walking up to +`pyproject.toml` and starts it with `uv run ore serve`. `OPENRAG_ENGINE_DIR` points it at another checkout. Its data lives +in `%LOCALAPPDATA%\OpenRag` and the engine's log is in `%LOCALAPPDATA%\OpenRag\logs\engine.log`. + +To work on the interface: + +```bash +cd desktop/web +npm run dev # http://localhost:5176 with a mock engine, no Python needed +npm test +``` + +- **Against a real engine in the browser:** start `ORE_API_TOKEN=<32+ chars> uv run ore serve --origin http://localhost:5176`, then open `http://localhost:5176/?api=http://127.0.0.1:&token=`. +- **Live reload inside the app (Debug builds only):** set `OPENRAG_DEV_URL=http://localhost:5176` before starting `OpenRag.exe`. diff --git a/desktop/src/OpenRag.App/App.xaml b/desktop/src/OpenRag.App/App.xaml new file mode 100644 index 0000000..4b611f4 --- /dev/null +++ b/desktop/src/OpenRag.App/App.xaml @@ -0,0 +1,3 @@ + diff --git a/desktop/src/OpenRag.App/App.xaml.cs b/desktop/src/OpenRag.App/App.xaml.cs new file mode 100644 index 0000000..9c5fbb0 --- /dev/null +++ b/desktop/src/OpenRag.App/App.xaml.cs @@ -0,0 +1,39 @@ +using System.IO; +using System.Windows; +using System.Windows.Threading; +using OpenRag.Core; + +namespace OpenRag.App; + +public partial class App : Application +{ + /// Opens the window, unless Open RAG is already running. Unexpected errors are written down and + /// the window kept alive, instead of closing without a trace. + protected override void OnStartup(StartupEventArgs e) + { + if (!SingleInstance.Claim()) + { + Shutdown(); + return; + } + DispatcherUnhandledException += OnUnhandled; + base.OnStartup(e); + new MainWindow().Show(); + } + + private static void OnUnhandled(object sender, DispatcherUnhandledExceptionEventArgs e) + { + var log = AppPaths.Default.ErrorLog; + try + { + Directory.CreateDirectory(Path.GetDirectoryName(log)!); + File.AppendAllText(log, $"{DateTime.Now:u} {e.Exception}\n\n"); + } + catch (Exception logError) when (logError is IOException or UnauthorizedAccessException) + { + // Nowhere to write it; the message box below still tells the user. + } + MessageBox.Show($"Something went wrong, but Open RAG kept running.\n\n{e.Exception.Message}\n\nDetails: {log}", "Open RAG"); + e.Handled = true; + } +} diff --git a/desktop/src/OpenRag.App/AssemblyInfo.cs b/desktop/src/OpenRag.App/AssemblyInfo.cs new file mode 100644 index 0000000..cc29e7f --- /dev/null +++ b/desktop/src/OpenRag.App/AssemblyInfo.cs @@ -0,0 +1,10 @@ +using System.Windows; + +[assembly:ThemeInfo( + ResourceDictionaryLocation.None, //where theme specific resource dictionaries are located + //(used if a resource is not found in the page, + // or application resource dictionaries) + ResourceDictionaryLocation.SourceAssembly //where the generic resource dictionary is located + //(used if a resource is not found in the page, + // app, or any theme specific resource dictionaries) +)] diff --git a/desktop/src/OpenRag.App/Assets/OpenRag.ico b/desktop/src/OpenRag.App/Assets/OpenRag.ico new file mode 100644 index 0000000000000000000000000000000000000000..c098ca4d2926801c2986b880979d2fa9ecd600ae GIT binary patch literal 63576 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⪙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 P@(<8b(^suhwvG57tL2vY literal 0 HcmV?d00001 diff --git a/desktop/src/OpenRag.App/ChildProcessJob.cs b/desktop/src/OpenRag.App/ChildProcessJob.cs new file mode 100644 index 0000000..57be292 --- /dev/null +++ b/desktop/src/OpenRag.App/ChildProcessJob.cs @@ -0,0 +1,92 @@ +using System.ComponentModel; +using System.Diagnostics; +using System.Runtime.InteropServices; + +namespace OpenRag.App; + +/// A Windows job object that kills its processes when Open RAG exits, even after a crash, so the engine +/// never keeps running (and holding its indexes) without the app. +internal sealed class ChildProcessJob : IDisposable +{ + private const int JobObjectExtendedLimitInformation = 9; + private const uint JobObjectLimitKillOnJobClose = 0x2000; + + private readonly IntPtr _handle; + + [StructLayout(LayoutKind.Sequential)] + private struct BasicLimitInformation + { + public long PerProcessUserTimeLimit; + public long PerJobUserTimeLimit; + public uint LimitFlags; + public UIntPtr MinimumWorkingSetSize; + public UIntPtr MaximumWorkingSetSize; + public uint ActiveProcessLimit; + public UIntPtr Affinity; + public uint PriorityClass; + public uint SchedulingClass; + } + + [StructLayout(LayoutKind.Sequential)] + private struct IoCounters + { + public ulong ReadOperationCount, WriteOperationCount, OtherOperationCount, ReadTransferCount, WriteTransferCount, OtherTransferCount; + } + + [StructLayout(LayoutKind.Sequential)] + private struct ExtendedLimitInformation + { + public BasicLimitInformation BasicLimitInformation; + public IoCounters IoInfo; + public UIntPtr ProcessMemoryLimit; + public UIntPtr JobMemoryLimit; + public UIntPtr PeakProcessMemoryUsed; + public UIntPtr PeakJobMemoryUsed; + } + + [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)] + private static extern IntPtr CreateJobObject(IntPtr attributes, string? name); + + [DllImport("kernel32.dll", SetLastError = true)] + private static extern bool SetInformationJobObject(IntPtr job, int infoClass, ref ExtendedLimitInformation info, int length); + + [DllImport("kernel32.dll", SetLastError = true)] + private static extern bool AssignProcessToJobObject(IntPtr job, IntPtr process); + + [DllImport("kernel32.dll", SetLastError = true)] + private static extern bool CloseHandle(IntPtr handle); + + public ChildProcessJob() + { + _handle = CreateJobObject(IntPtr.Zero, null); + if (_handle == IntPtr.Zero) + { + throw new Win32Exception(Marshal.GetLastWin32Error()); + } + var info = new ExtendedLimitInformation { BasicLimitInformation = new BasicLimitInformation { LimitFlags = JobObjectLimitKillOnJobClose } }; + if (!SetInformationJobObject(_handle, JobObjectExtendedLimitInformation, ref info, Marshal.SizeOf())) + { + var error = Marshal.GetLastWin32Error(); + CloseHandle(_handle); + throw new Win32Exception(error); + } + } + + /// Adds the process (and the children it starts later) to the job. A failure only loses the crash safety net. + public void Add(Process process) + { + try + { + if (!AssignProcessToJobObject(_handle, process.Handle)) + { + Debug.WriteLine($"Couldn't add the engine to the job: error {Marshal.GetLastWin32Error()}"); + } + } + catch (Exception e) when (e is InvalidOperationException or Win32Exception) + { + Debug.WriteLine($"Couldn't add the engine to the job: {e.Message}"); + } + } + + public void Dispose() => CloseHandle(_handle); +} diff --git a/desktop/src/OpenRag.App/MainWindow.xaml b/desktop/src/OpenRag.App/MainWindow.xaml new file mode 100644 index 0000000..8181e12 --- /dev/null +++ b/desktop/src/OpenRag.App/MainWindow.xaml @@ -0,0 +1,9 @@ + + + + diff --git a/desktop/src/OpenRag.App/MainWindow.xaml.cs b/desktop/src/OpenRag.App/MainWindow.xaml.cs new file mode 100644 index 0000000..ac33b8b --- /dev/null +++ b/desktop/src/OpenRag.App/MainWindow.xaml.cs @@ -0,0 +1,307 @@ +using System.Diagnostics; +using System.IO; +using System.Net.Http; +using System.Runtime.InteropServices; +using System.Text.Json; +using System.Windows; +using Microsoft.Web.WebView2.Core; +using Microsoft.Win32; +using OpenRag.Core; + +namespace OpenRag.App; + +/// Hosts the React interface and runs the engine. The page reaches the engine only through this window: its API +/// calls arrive as messages and go out through , which adds the token. The page never sees the +/// token and never talks to a local port. +public partial class MainWindow : Window +{ + private const string AppHost = "app.ore"; + + /// Debug builds only: set to the Vite dev server (http://localhost:5176) to work on the interface with live reload. + private const string DevUrlVariable = "OPENRAG_DEV_URL"; + + private static readonly TimeSpan EngineStartTimeout = TimeSpan.FromMinutes(3); + private static readonly JsonSerializerOptions Json = new(JsonSerializerDefaults.Web); + private static readonly string WebRoot = Path.Combine(AppContext.BaseDirectory, "wwwroot"); + + private readonly AppPaths _paths = AppPaths.Default; + private readonly ChildProcessJob? _job = CreateJob(); + private readonly string _token = Token.New(); + private readonly string? _devUrl = DevServerUrl(); + private readonly HttpClient _http = new() { Timeout = Timeout.InfiniteTimeSpan }; + private readonly Dictionary _asks = []; + private EngineHost? _engine; + private EngineProxy? _proxy; + private object _engineState = new { type = "engine", state = "starting" }; + private string _origin = $"https://{AppHost}"; + + public MainWindow() + { + InitializeComponent(); + Loaded += async (_, _) => await Task.WhenAll(StartWebViewAsync(), StartEngineAsync()); + Closing += async (_, _) => await ShutdownAsync(); + } + + private static ChildProcessJob? CreateJob() + { + try + { + return new ChildProcessJob(); + } + catch (System.ComponentModel.Win32Exception e) + { + Debug.WriteLine($"No job object, so the engine could outlive a crash: {e.Message}"); + return null; + } + } + + /// The dev server is honoured only in Debug builds and only on this machine. + private static string? DevServerUrl() + { +#if DEBUG + var url = Environment.GetEnvironmentVariable(DevUrlVariable); + return url is not null && Uri.TryCreate(url, UriKind.Absolute, out var uri) && uri.IsLoopback ? url : null; +#else + return null; +#endif + } + + private bool IsOwnPage(string url) => + Uri.TryCreate(url, UriKind.Absolute, out var uri) && string.Equals(uri.GetLeftPart(UriPartial.Authority), _origin, StringComparison.OrdinalIgnoreCase); + + private async Task StartEngineAsync() + { + SetEngineState("starting"); + var command = EngineLocator.Find(AppContext.BaseDirectory, Environment.GetEnvironmentVariable); + if (command is null) + { + SetEngineState("failed", "Open RAG couldn't find its engine. Reinstalling the app should fix this."); + return; + } + var engine = new EngineHost(command, command.ServeArguments(_paths.Data, Environment.ProcessId), _paths.EngineLog); + engine.Started += process => _job?.Add(process); + engine.Exited += code => Dispatcher.Invoke(() => + SetEngineState("failed", $"The engine stopped unexpectedly (exit code {code}). Details are in {_paths.EngineLog}.")); + _engine = engine; + try + { + var connection = await engine.StartAsync(new Dictionary { ["ORE_API_TOKEN"] = _token }, EngineStartTimeout); + _proxy = new EngineProxy(_http, connection.BaseUrl, _token); + SetEngineState("ready"); + } + catch (EngineStartException e) + { + SetEngineState("failed", $"{e.Message}\n\nThe full log is in {_paths.EngineLog}."); + } + } + + private async Task RestartEngineAsync() + { + _proxy = null; + if (_engine is not null) + { + await _engine.DisposeAsync(); + _engine = null; + } + await StartEngineAsync(); + } + + private void SetEngineState(string state, string? message = null) + { + _engineState = new { type = "engine", state, message }; + Post(_engineState); + } + + private void Post(object message) + { + if (Web.CoreWebView2 is { } core) + { + core.PostWebMessageAsJson(JsonSerializer.Serialize(message, Json)); + } + } + + private async Task StartWebViewAsync() + { + if (_devUrl is null && !File.Exists(Path.Combine(WebRoot, "index.html"))) + { + MessageBox.Show(this, $"The interface files are missing from {WebRoot}. Run \"npm run build\" in desktop/web, then build again.", "Open RAG"); + return; + } + try + { + var environment = await CoreWebView2Environment.CreateAsync(userDataFolder: _paths.WebView); + await Web.EnsureCoreWebView2Async(environment); + } + catch (Exception e) when (e is WebView2RuntimeNotFoundException or COMException or InvalidOperationException) + { + MessageBox.Show(this, $"Open RAG needs the Microsoft Edge WebView2 Runtime, which comes with Windows 11.\n\n{e.Message}", "Open RAG"); + return; + } + + var core = Web.CoreWebView2; + var dev = _devUrl is not null; + Web.DefaultBackgroundColor = System.Drawing.Color.FromArgb(0xEA, 0xF2, 0xFF); + core.Settings.IsStatusBarEnabled = false; + core.Settings.IsZoomControlEnabled = false; + core.Settings.AreBrowserAcceleratorKeysEnabled = dev; + core.Settings.AreDefaultContextMenusEnabled = dev; + core.Settings.AreDevToolsEnabled = dev || Debugger.IsAttached; + core.SetVirtualHostNameToFolderMapping(AppHost, WebRoot, CoreWebView2HostResourceAccessKind.Allow); + + // Only our own page may run here; anything else (a dropped file, a link) is refused. + var start = dev ? _devUrl!.TrimEnd('/') + "/" : $"{_origin}/index.html"; + _origin = new Uri(start).GetLeftPart(UriPartial.Authority); + core.NavigationStarting += (_, e) => e.Cancel = !IsOwnPage(e.Uri); + core.NewWindowRequested += (_, e) => e.Handled = true; + core.WebMessageReceived += OnWebMessage; + core.ProcessFailed += (_, e) => + { + if (e.ProcessFailedKind is CoreWebView2ProcessFailedKind.RenderProcessExited or CoreWebView2ProcessFailedKind.RenderProcessUnresponsive) + { + Web.CoreWebView2?.Reload(); + } + }; + core.Navigate(start); + } + + private async void OnWebMessage(object? sender, CoreWebView2WebMessageReceivedEventArgs e) + { + if (!IsOwnPage(e.Source)) + { + return; + } + try + { + using var doc = JsonDocument.Parse(e.WebMessageAsJson); + var message = doc.RootElement; + switch (message.GetProperty("type").GetString()) + { + case "ready": + Post(_engineState); + break; + case "pickFolder": + PickFolder(message.GetProperty("id").GetString()); + break; + case "openSource": + OpenSource(message.GetProperty("path").GetString(), reveal: false); + break; + case "revealSource": + OpenSource(message.GetProperty("path").GetString(), reveal: true); + break; + case "restartEngine": + await RestartEngineAsync(); + break; + case "api": + await ForwardAsync(message); + break; + case "ask": + await AskAsync(message); + break; + case "cancel": + if (_asks.TryGetValue(message.GetProperty("id").GetString() ?? "", out var ask)) + { + ask.Cancel(); + } + break; + } + } + // An async void handler must not throw: tell the page instead of losing it. + catch (Exception ex) when (ex is JsonException or KeyNotFoundException or InvalidOperationException) + { + Post(new { type = "notice", message = $"Something went wrong: {ex.Message}" }); + } + } + + private static string? Body(JsonElement message) => + message.TryGetProperty("body", out var body) && body.ValueKind != JsonValueKind.Null ? body.GetRawText() : null; + + private const string NotReady = """{"title":"Engine unavailable","status":503,"detail":"The engine isn't running."}"""; + + /// One API call from the page: forwarded with the token, answered with the status and raw JSON body. + private async Task ForwardAsync(JsonElement message) + { + var id = message.GetProperty("id").GetString(); + var result = _proxy is null + ? new ProxyResponse(503, NotReady) + : await _proxy.SendAsync(message.GetProperty("method").GetString() ?? "", message.GetProperty("path").GetString() ?? "", Body(message)); + Post(new { type = "apiResult", id, status = result.Status, body = result.Body }); + } + + /// A question: the engine's NDJSON lines go to the page one by one as they arrive, then an end marker. + private async Task AskAsync(JsonElement message) + { + var id = message.GetProperty("id").GetString() ?? ""; + if (_proxy is null) + { + Post(new { type = "askEnd", id, status = 503, body = NotReady }); + return; + } + using var cancel = new CancellationTokenSource(); + _asks[id] = cancel; + try + { + var result = await _proxy.StreamAsync("/ask", Body(message) ?? "{}", line => + { + Post(new { type = "askLine", id, line }); + return Task.CompletedTask; + }, cancel.Token); + Post(new { type = "askEnd", id, status = result.Status, body = result.Body }); + } + catch (OperationCanceledException) + { + Post(new { type = "askEnd", id, status = 499, body = "" }); + } + finally + { + _asks.Remove(id); + } + } + + private void PickFolder(string? id) + { + var dialog = new OpenFolderDialog { Title = "Choose a folder for this section" }; + var path = dialog.ShowDialog(this) == true ? dialog.FolderName : null; + Post(new { type = "folderPicked", id, path }); + } + + /// Opens a cited document with its usual app, or shows it in Explorer. Only documents that exist, by absolute + /// path, are opened, so nothing the page sends can launch a program. + private void OpenSource(string? path, bool reveal) + { + if (!SourceFiles.CanOpen(path)) + { + Post(new { type = "notice", message = "That file isn't there anymore. Re-index the section to update it." }); + return; + } + var full = Path.GetFullPath(path!); + try + { + if (reveal) + { + Process.Start("explorer.exe", $"/select,\"{full}\""); + } + else + { + Process.Start(new ProcessStartInfo(full) { UseShellExecute = true }); + } + } + catch (System.ComponentModel.Win32Exception ex) + { + Post(new { type = "notice", message = $"Couldn't open {Path.GetFileName(full)}: {ex.Message}" }); + } + } + + private async Task ShutdownAsync() + { + foreach (var ask in _asks.Values) + { + ask.Cancel(); + } + if (_engine is not null) + { + await _engine.DisposeAsync(); + } + _http.Dispose(); + _job?.Dispose(); + } +} diff --git a/desktop/src/OpenRag.App/OpenRag.App.csproj b/desktop/src/OpenRag.App/OpenRag.App.csproj new file mode 100644 index 0000000..8685a25 --- /dev/null +++ b/desktop/src/OpenRag.App/OpenRag.App.csproj @@ -0,0 +1,55 @@ + + + + + + + + + + + + WinExe + net10.0-windows + enable + enable + true + OpenRag + Open RAG + Open RAG + 0.1.0 + Assets\OpenRag.ico + $(MSBuildThisFileDirectory)..\..\web\ + + + + + + + + + + + + + + + + + + + + + + + + + + + wwwroot\%(RecursiveDir)%(Filename)%(Extension) + PreserveNewest + + + + + diff --git a/desktop/src/OpenRag.App/SingleInstance.cs b/desktop/src/OpenRag.App/SingleInstance.cs new file mode 100644 index 0000000..bf1156f --- /dev/null +++ b/desktop/src/OpenRag.App/SingleInstance.cs @@ -0,0 +1,57 @@ +using System.Diagnostics; +using System.Runtime.InteropServices; + +namespace OpenRag.App; + +/// Keeps Open RAG to one window. A second copy would start a second engine over the same indexes, +/// so opening Open RAG again (a second click on the desktop icon) brings the running window forward instead. +internal static class SingleInstance +{ + private const string MutexName = @"Local\OpenRag.SingleInstance"; + private const int SwRestore = 9; + + // Held for the life of the process; Windows frees it when Open RAG exits, even after a crash. + private static Mutex? _claim; + + [DllImport("user32.dll")] + private static extern bool SetForegroundWindow(IntPtr hwnd); + + [DllImport("user32.dll")] + private static extern bool ShowWindow(IntPtr hwnd, int command); + + [DllImport("user32.dll")] + private static extern bool IsIconic(IntPtr hwnd); + + /// True when no other Open RAG is running. Otherwise shows the running one and returns false. + public static bool Claim() + { + _claim = new Mutex(initiallyOwned: true, MutexName, out var first); + if (!first) + { + ShowRunningCopy(); + } + return first; + } + + private static void ShowRunningCopy() + { + using var current = Process.GetCurrentProcess(); + foreach (var other in Process.GetProcessesByName(current.ProcessName)) + { + using (other) + { + var window = other.Id == current.Id ? IntPtr.Zero : other.MainWindowHandle; + if (window == IntPtr.Zero) + { + continue; + } + if (IsIconic(window)) + { + ShowWindow(window, SwRestore); + } + SetForegroundWindow(window); + return; + } + } + } +} diff --git a/desktop/src/OpenRag.Core/Engine.cs b/desktop/src/OpenRag.Core/Engine.cs new file mode 100644 index 0000000..b9f626c --- /dev/null +++ b/desktop/src/OpenRag.Core/Engine.cs @@ -0,0 +1,260 @@ +using System.Diagnostics; +using System.Security.Cryptography; +using System.Text.RegularExpressions; + +namespace OpenRag.Core; + +/// Where Open RAG keeps its own files: all under %LOCALAPPDATA%\OpenRag, never next to the user's documents. +public sealed record AppPaths(string Root) +{ + public static AppPaths Default { get; } = + new(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "OpenRag")); + + public string Data => Path.Combine(Root, "data"); + public string WebView => Path.Combine(Root, "WebView2"); + public string Logs => Path.Combine(Root, "logs"); + public string EngineLog => Path.Combine(Logs, "engine.log"); + public string ErrorLog => Path.Combine(Logs, "errors.log"); +} + +/// A per-launch secret the engine requires on every request, so no other program on the machine can use it. +public static class Token +{ + public static string New() => Convert.ToHexString(RandomNumberGenerator.GetBytes(32)).ToLowerInvariant(); +} + +/// The engine prints ORE_READY port=N once it listens. +public static partial class ReadyLine +{ + [GeneratedRegex(@"^ORE_READY port=(\d{1,5})$")] + private static partial Regex Pattern(); + + public static int? TryParsePort(string? line) + { + var match = Pattern().Match(line?.Trim() ?? ""); + return match.Success && int.TryParse(match.Groups[1].Value, out var port) && port is > 0 and <= 65535 ? port : null; + } +} + +/// Which source files the app opens when a citation is clicked: documents only, by absolute path, that exist. +public static class SourceFiles +{ + private static readonly HashSet Documents = new(StringComparer.OrdinalIgnoreCase) { ".pdf", ".md", ".markdown", ".txt" }; + + public static bool CanOpen(string? path) => + !string.IsNullOrWhiteSpace(path) + && Path.IsPathFullyQualified(path) + && Documents.Contains(Path.GetExtension(path)) + && File.Exists(path); +} + +/// How to start the engine: a program, its base arguments, where to run it, and an optional config file. +public sealed record EngineCommand(string FileName, IReadOnlyList Arguments, string WorkingDirectory, string? ConfigPath) +{ + public IReadOnlyList ServeArguments(string dataDirectory, int parentProcessId) + { + var args = new List(Arguments) { "--data-dir", dataDirectory, "--parent-pid", parentProcessId.ToString(), "--warm" }; + if (ConfigPath is not null) + { + args.AddRange(["--config", ConfigPath]); + } + return args; + } +} + +public static class EngineLocator +{ + public const string EngineDirVariable = "OPENRAG_ENGINE_DIR"; + + /// The installed layout (a bundled Python next to the app) wins; otherwise a development checkout of + /// open-rag-engine, from or found above the app, run through uv. + public static EngineCommand? Find(string appDirectory, Func environment) + { + var engine = Path.Combine(appDirectory, "engine"); + var python = Path.Combine(engine, "python", "python.exe"); + if (File.Exists(python)) + { + var config = Path.Combine(engine, "ore.toml"); + return new EngineCommand(python, ["-m", "open_rag_engine", "serve"], engine, File.Exists(config) ? config : null); + } + var checkout = environment(EngineDirVariable) is { } dir && IsCheckout(dir) ? dir : FindCheckoutAbove(appDirectory); + return checkout is null ? null : new EngineCommand("uv", ["run", "--project", checkout, "ore", "serve"], checkout, null); + } + + private static string? FindCheckoutAbove(string start) + { + for (var dir = new DirectoryInfo(start); dir is not null; dir = dir.Parent) + { + if (IsCheckout(dir.FullName)) + { + return dir.FullName; + } + } + return null; + } + + private static bool IsCheckout(string dir) + { + var pyproject = Path.Combine(dir, "pyproject.toml"); + return File.Exists(pyproject) && File.ReadAllText(pyproject).Contains("name = \"open-rag-engine\"", StringComparison.Ordinal); + } +} + +public sealed record EngineConnection(Uri BaseUrl); + +public sealed class EngineStartException(string message) : Exception(message); + +/// Runs the engine as a hidden child process, writes its output to a log, and reports the port it listens on. +public sealed class EngineHost(EngineCommand command, IReadOnlyList arguments, string logPath) : IAsyncDisposable +{ + private const int TailLines = 12; + private readonly Queue _tail = new(); + private readonly Lock _log = new(); + private Process? _process; + + /// Raised when the engine exits after it was ready (a crash, or killed from outside). + public event Action? Exited; + + /// Lets the app put the process in its job object, so the engine dies with the app. + public event Action? Started; + + public async Task StartAsync(IReadOnlyDictionary environment, TimeSpan timeout, + CancellationToken cancel = default) + { + Directory.CreateDirectory(Path.GetDirectoryName(logPath)!); + var info = new ProcessStartInfo(command.FileName) + { + WorkingDirectory = command.WorkingDirectory, + UseShellExecute = false, + CreateNoWindow = true, + RedirectStandardOutput = true, + RedirectStandardError = true, + StandardOutputEncoding = System.Text.Encoding.UTF8, + StandardErrorEncoding = System.Text.Encoding.UTF8, + }; + foreach (var argument in arguments) + { + info.ArgumentList.Add(argument); + } + info.Environment["PYTHONUTF8"] = "1"; + foreach (var (key, value) in environment) + { + info.Environment[key] = value; + } + + var ready = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + var process = new Process { StartInfo = info, EnableRaisingEvents = true }; + process.OutputDataReceived += (_, e) => + { + Write(e.Data); + if (ReadyLine.TryParsePort(e.Data) is { } port) + { + ready.TrySetResult(new EngineConnection(new Uri($"http://127.0.0.1:{port}/"))); + } + }; + process.ErrorDataReceived += (_, e) => Write(e.Data); + process.Exited += (_, _) => + { + var code = SafeExitCode(process); + if (!ready.TrySetException(new EngineStartException(FailureMessage(code)))) + { + Exited?.Invoke(code); + } + }; + + try + { + process.Start(); + } + catch (System.ComponentModel.Win32Exception e) + { + throw new EngineStartException($"Couldn't start the engine ({command.FileName}): {e.Message}"); + } + _process = process; + Started?.Invoke(process); + process.BeginOutputReadLine(); + process.BeginErrorReadLine(); + + using var timer = CancellationTokenSource.CreateLinkedTokenSource(cancel); + timer.CancelAfter(timeout); + try + { + return await ready.Task.WaitAsync(timer.Token); + } + catch (OperationCanceledException) when (!cancel.IsCancellationRequested) + { + throw new EngineStartException($"The engine didn't start within {timeout.TotalSeconds:0} seconds. {Tail()}"); + } + } + + public void Stop() + { + try + { + if (_process is { HasExited: false } process) + { + process.Kill(entireProcessTree: true); + } + } + catch (Exception e) when (e is InvalidOperationException or System.ComponentModel.Win32Exception) + { + // Already gone. + } + } + + public async ValueTask DisposeAsync() + { + Stop(); + if (_process is not null) + { + await _process.WaitForExitAsync().WaitAsync(TimeSpan.FromSeconds(5)).ContinueWith(_ => { }); + _process.Dispose(); + } + } + + private void Write(string? line) + { + if (line is null) + { + return; + } + lock (_log) + { + _tail.Enqueue(line); + while (_tail.Count > TailLines) + { + _tail.Dequeue(); + } + try + { + File.AppendAllText(logPath, $"{DateTime.Now:HH:mm:ss} {line}{Environment.NewLine}"); + } + catch (IOException) + { + // The log is a convenience; a locked file must not stop the engine. + } + } + } + + private string Tail() + { + lock (_log) + { + return _tail.Count == 0 ? "" : "Last output:\n" + string.Join("\n", _tail); + } + } + + private string FailureMessage(int code) => $"The engine stopped (exit code {code}) before it was ready. {Tail()}".Trim(); + + private static int SafeExitCode(Process process) + { + try + { + return process.ExitCode; + } + catch (InvalidOperationException) + { + return -1; + } + } +} diff --git a/desktop/src/OpenRag.Core/EngineProxy.cs b/desktop/src/OpenRag.Core/EngineProxy.cs new file mode 100644 index 0000000..0d17c44 --- /dev/null +++ b/desktop/src/OpenRag.Core/EngineProxy.cs @@ -0,0 +1,90 @@ +using System.Net.Http.Headers; +using System.Text; +using System.Text.RegularExpressions; + +namespace OpenRag.Core; + +/// A response from the engine: the HTTP status and the raw JSON body (empty for 204). +public sealed record ProxyResponse(int Status, string Body); + +/// Forwards the page's API calls to the engine, adding the token. The page never sees the token or talks to a +/// local port itself, and it can only reach the engine's own API paths with the usual methods. +public sealed partial class EngineProxy(HttpClient http, Uri baseUrl, string token) +{ + private static readonly HashSet Methods = ["GET", "POST", "PATCH", "DELETE"]; + + [GeneratedRegex(@"^/(health|library|ask|categories(/[a-f0-9]{1,64})?|sections(/[a-f0-9]{1,64}(/(folders|folders/remove|index|status|documents))?)?)$")] + private static partial Regex ApiPath(); + + public static bool IsAllowed(string? method, string? path) => + method is not null && Methods.Contains(method) && path is not null && ApiPath().IsMatch(path); + + public async Task SendAsync(string method, string path, string? json, CancellationToken cancel = default) + { + if (!IsAllowed(method, path)) + { + return Refused(); + } + using var request = Request(method, path, json); + try + { + using var response = await http.SendAsync(request, cancel); + return new ProxyResponse((int)response.StatusCode, await response.Content.ReadAsStringAsync(cancel)); + } + catch (HttpRequestException e) + { + return Unreachable(e); + } + } + + /// Posts to a streaming endpoint and hands over each NDJSON line as it arrives. Returns the status, plus + /// the body when the engine refused the request before streaming. + public async Task StreamAsync(string path, string json, Func onLine, CancellationToken cancel = default) + { + if (!IsAllowed("POST", path)) + { + return Refused(); + } + using var request = Request("POST", path, json); + try + { + using var response = await http.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cancel); + if (!response.IsSuccessStatusCode) + { + return new ProxyResponse((int)response.StatusCode, await response.Content.ReadAsStringAsync(cancel)); + } + using var reader = new StreamReader(await response.Content.ReadAsStreamAsync(cancel), Encoding.UTF8); + while (await reader.ReadLineAsync(cancel) is { } line) + { + if (line.Length > 0) + { + await onLine(line); + } + } + return new ProxyResponse((int)response.StatusCode, ""); + } + catch (HttpRequestException e) + { + return Unreachable(e); + } + } + + private HttpRequestMessage Request(string method, string path, string? json) + { + var request = new HttpRequestMessage(new HttpMethod(method), new Uri(baseUrl, path)); + request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", token); + if (json is not null && method != "GET") + { + request.Content = new StringContent(json, Encoding.UTF8, "application/json"); + } + return request; + } + + private static ProxyResponse Refused() => + new(400, """{"title":"Invalid request","status":400,"detail":"That request isn't part of the engine's API."}"""); + + private static ProxyResponse Unreachable(HttpRequestException e) => + new(503, $$"""{"title":"Engine unavailable","status":503,"detail":"Can't reach the engine: {{Escape(e.Message)}}"}"""); + + private static string Escape(string text) => text.Replace("\\", "\\\\").Replace("\"", "\\\""); +} diff --git a/desktop/src/OpenRag.Core/OpenRag.Core.csproj b/desktop/src/OpenRag.Core/OpenRag.Core.csproj new file mode 100644 index 0000000..9ed914b --- /dev/null +++ b/desktop/src/OpenRag.Core/OpenRag.Core.csproj @@ -0,0 +1,9 @@ + + + + net10.0 + enable + enable + + + diff --git a/desktop/tests/OpenRag.Core.Tests/EngineProxyTests.cs b/desktop/tests/OpenRag.Core.Tests/EngineProxyTests.cs new file mode 100644 index 0000000..938c67f --- /dev/null +++ b/desktop/tests/OpenRag.Core.Tests/EngineProxyTests.cs @@ -0,0 +1,103 @@ +using System.Net; +using System.Text; +using OpenRag.Core; + +namespace OpenRag.Core.Tests; + +public class EngineProxyTests +{ + private sealed class FakeEngine(Func respond) : HttpMessageHandler + { + public List Seen { get; } = []; + public List Bodies { get; } = []; + + protected override async Task SendAsync(HttpRequestMessage request, CancellationToken cancel) + { + Seen.Add(request); + Bodies.Add(request.Content is null ? null : await request.Content.ReadAsStringAsync(cancel)); + return respond(request); + } + } + + private static (EngineProxy, FakeEngine) Make(Func respond) + { + var engine = new FakeEngine(respond); + return (new EngineProxy(new HttpClient(engine), new Uri("http://127.0.0.1:5000/"), "secret"), engine); + } + + private static HttpResponseMessage Json(HttpStatusCode status, string body) => + new(status) { Content = new StringContent(body, Encoding.UTF8, "application/json") }; + + [Theory] + [InlineData("GET", "/library")] + [InlineData("POST", "/categories")] + [InlineData("PATCH", "/categories/abc123")] + [InlineData("DELETE", "/sections/0f9e")] + [InlineData("POST", "/sections/0f9e/folders/remove")] + [InlineData("GET", "/sections/0f9e/documents")] + [InlineData("POST", "/ask")] + public void Allows_the_engine_api(string method, string path) => Assert.True(EngineProxy.IsAllowed(method, path)); + + [Theory] + [InlineData("GET", "/../secret")] + [InlineData("GET", "http://evil.example/library")] + [InlineData("GET", "//evil.example/library")] + [InlineData("PUT", "/library")] + [InlineData("GET", "/sections/ABC/status")] + [InlineData("GET", "/library?x=1")] + [InlineData(null, "/library")] + [InlineData("GET", null)] + public void Refuses_anything_else(string? method, string? path) => Assert.False(EngineProxy.IsAllowed(method, path)); + + [Fact] + public async Task Adds_the_token_and_returns_status_and_body() + { + var (proxy, engine) = Make(_ => Json(HttpStatusCode.Created, """{"id":"abc"}""")); + var result = await proxy.SendAsync("POST", "/categories", """{"name":"Physics"}"""); + Assert.Equal(new ProxyResponse(201, """{"id":"abc"}"""), result); + var sent = Assert.Single(engine.Seen); + Assert.Equal("Bearer secret", sent.Headers.Authorization?.ToString()); + Assert.Equal(new Uri("http://127.0.0.1:5000/categories"), sent.RequestUri); + Assert.Equal("""{"name":"Physics"}""", Assert.Single(engine.Bodies)); + } + + [Fact] + public async Task Refused_paths_never_reach_the_engine() + { + var (proxy, engine) = Make(_ => Json(HttpStatusCode.OK, "{}")); + var result = await proxy.SendAsync("GET", "/../etc", null); + Assert.Equal(400, result.Status); + Assert.Empty(engine.Seen); + } + + [Fact] + public async Task Streams_each_line_then_reports_success() + { + var (proxy, _) = Make(_ => Json(HttpStatusCode.OK, "{\"type\":\"token\",\"text\":\"Hi\"}\n\n{\"type\":\"done\"}\n")); + var lines = new List(); + var result = await proxy.StreamAsync("/ask", "{}", line => + { + lines.Add(line); + return Task.CompletedTask; + }); + Assert.Equal(200, result.Status); + Assert.Equal(["{\"type\":\"token\",\"text\":\"Hi\"}", "{\"type\":\"done\"}"], lines); + } + + [Fact] + public async Task A_refused_stream_returns_the_engines_explanation() + { + var (proxy, _) = Make(_ => Json(HttpStatusCode.Conflict, """{"detail":"Still indexing"}""")); + var result = await proxy.StreamAsync("/ask", "{}", _ => Task.CompletedTask); + Assert.Equal(new ProxyResponse(409, """{"detail":"Still indexing"}"""), result); + } + + [Fact] + public async Task An_unreachable_engine_is_a_503_problem() + { + var (proxy, _) = Make(_ => throw new HttpRequestException("connection refused")); + var result = await proxy.SendAsync("GET", "/library", null); + Assert.Equal(503, result.Status); + Assert.Contains("connection refused", result.Body); + } +} diff --git a/desktop/tests/OpenRag.Core.Tests/EngineTests.cs b/desktop/tests/OpenRag.Core.Tests/EngineTests.cs new file mode 100644 index 0000000..8874c7e --- /dev/null +++ b/desktop/tests/OpenRag.Core.Tests/EngineTests.cs @@ -0,0 +1,157 @@ +using OpenRag.Core; + +namespace OpenRag.Core.Tests; + +public sealed class TempDir : IDisposable +{ + public string Path { get; } = Directory.CreateTempSubdirectory("openrag-").FullName; + + public string Make(params string[] parts) + { + var path = System.IO.Path.Combine([Path, .. parts]); + Directory.CreateDirectory(System.IO.Path.GetDirectoryName(path)!); + File.WriteAllText(path, ""); + return path; + } + + public void Dispose() + { + try + { + Directory.Delete(Path, recursive: true); + } + catch (IOException) + { + // A test process may still hold a file for a moment; the temp folder is cleaned up eventually. + } + } +} + +public class ReadyLineTests +{ + [Theory] + [InlineData("ORE_READY port=62130", 62130)] + [InlineData(" ORE_READY port=8 ", 8)] + public void Parses_the_port(string line, int port) => Assert.Equal(port, ReadyLine.TryParsePort(line)); + + [Theory] + [InlineData(null)] + [InlineData("")] + [InlineData("ORE_READY port=")] + [InlineData("ORE_READY port=99999")] + [InlineData("something ORE_READY port=80")] + public void Ignores_anything_else(string? line) => Assert.Null(ReadyLine.TryParsePort(line)); +} + +public class TokenTests +{ + [Fact] + public void Tokens_are_long_random_hex() + { + var a = Token.New(); + Assert.Equal(64, a.Length); + Assert.Matches("^[0-9a-f]{64}$", a); + Assert.NotEqual(a, Token.New()); + } +} + +public class SourceFilesTests +{ + [Fact] + public void Opens_only_existing_documents_by_absolute_path() + { + using var dir = new TempDir(); + var pdf = dir.Make("notes", "lecture.pdf"); + var exe = dir.Make("tool.exe"); + Assert.True(SourceFiles.CanOpen(pdf)); + Assert.True(SourceFiles.CanOpen(pdf.Replace('\\', '/'))); + Assert.False(SourceFiles.CanOpen(exe)); + Assert.False(SourceFiles.CanOpen(Path.Combine(dir.Path, "missing.md"))); + Assert.False(SourceFiles.CanOpen("notes/lecture.pdf")); + Assert.False(SourceFiles.CanOpen("")); + } +} + +public class EngineLocatorTests +{ + private static Func Env(Dictionary? values = null) => + name => values is not null && values.TryGetValue(name, out var v) ? v : null; + + [Fact] + public void Prefers_the_bundled_engine_next_to_the_app() + { + using var dir = new TempDir(); + var python = dir.Make("engine", "python", "python.exe"); + var config = dir.Make("engine", "ore.toml"); + var command = EngineLocator.Find(dir.Path, Env())!; + Assert.Equal(python, command.FileName); + Assert.Equal(["-m", "open_rag_engine", "serve"], command.Arguments); + Assert.Equal(config, command.ConfigPath); + } + + [Fact] + public void Finds_a_development_checkout_above_the_app() + { + using var dir = new TempDir(); + File.WriteAllText(dir.Make("pyproject.toml"), "[project]\nname = \"open-rag-engine\"\n"); + var appDir = Directory.CreateDirectory(Path.Combine(dir.Path, "desktop", "src", "bin")).FullName; + var command = EngineLocator.Find(appDir, Env())!; + Assert.Equal("uv", command.FileName); + Assert.Equal(["run", "--project", dir.Path, "ore", "serve"], command.Arguments); + Assert.Null(command.ConfigPath); + } + + [Fact] + public void An_environment_variable_points_at_a_checkout() + { + using var dir = new TempDir(); + File.WriteAllText(dir.Make("repo", "pyproject.toml"), "name = \"open-rag-engine\""); + var repo = Path.Combine(dir.Path, "repo"); + var command = EngineLocator.Find(dir.Path, Env(new() { [EngineLocator.EngineDirVariable] = repo }))!; + Assert.Contains(repo, command.Arguments); + } + + [Fact] + public void Returns_null_when_there_is_no_engine() + { + using var dir = new TempDir(); + File.WriteAllText(dir.Make("pyproject.toml"), "name = \"something-else\""); + Assert.Null(EngineLocator.Find(dir.Path, Env())); + } + + [Fact] + public void Serve_arguments_add_data_dir_parent_and_config() + { + var command = new EngineCommand("python.exe", ["-m", "open_rag_engine", "serve"], "C:/app", "C:/app/ore.toml"); + var args = command.ServeArguments("C:/data", 42); + Assert.Equal(["-m", "open_rag_engine", "serve", "--data-dir", "C:/data", "--parent-pid", "42", "--warm", + "--config", "C:/app/ore.toml"], args); + } +} + +public class EngineHostTests +{ + private static EngineCommand Cmd(string script) => new("cmd.exe", ["/c", script], Environment.CurrentDirectory, null); + + [Fact] + public async Task Start_returns_the_port_the_engine_announces() + { + using var dir = new TempDir(); + await using var host = new EngineHost(Cmd("echo starting & echo ORE_READY port=4321 & ping -n 20 127.0.0.1 >nul"), + ["/c", "echo starting & echo ORE_READY port=4321 & ping -n 20 127.0.0.1 >nul"], Path.Combine(dir.Path, "engine.log")); + var connection = await host.StartAsync(new Dictionary { ["ORE_API_TOKEN"] = "x" }, TimeSpan.FromSeconds(20)); + Assert.Equal(new Uri("http://127.0.0.1:4321/"), connection.BaseUrl); + Assert.Contains("starting", File.ReadAllText(Path.Combine(dir.Path, "engine.log"))); + } + + [Fact] + public async Task A_crash_before_ready_reports_the_last_output() + { + using var dir = new TempDir(); + await using var host = new EngineHost(Cmd("echo no module named open_rag_engine 1>&2 & exit 3"), + ["/c", "echo no module named open_rag_engine 1>&2 & exit 3"], Path.Combine(dir.Path, "engine.log")); + var error = await Assert.ThrowsAsync(() => + host.StartAsync(new Dictionary(), TimeSpan.FromSeconds(20))); + Assert.Contains("no module named open_rag_engine", error.Message); + } +} diff --git a/desktop/tests/OpenRag.Core.Tests/OpenRag.Core.Tests.csproj b/desktop/tests/OpenRag.Core.Tests/OpenRag.Core.Tests.csproj new file mode 100644 index 0000000..91b27fc --- /dev/null +++ b/desktop/tests/OpenRag.Core.Tests/OpenRag.Core.Tests.csproj @@ -0,0 +1,25 @@ + + + + net10.0 + enable + enable + false + + + + + + + + + + + + + + + + + + diff --git a/desktop/tools/make_icon.py b/desktop/tools/make_icon.py new file mode 100644 index 0000000..34fc816 --- /dev/null +++ b/desktop/tools/make_icon.py @@ -0,0 +1,65 @@ +"""Draws Open RAG's app icon in the AI Engineering Arena style: a tilted tomato sticker with an ink outline and a +hard shadow, holding a document and a sun-yellow magnifying glass. + +Every size is drawn at 8x and scaled down, so small sizes in the taskbar stay sharp. +Run from the repo root: python desktop/tools/make_icon.py +""" + +from pathlib import Path + +from PIL import Image, ImageDraw + +ASSETS = Path(__file__).resolve().parent.parent / "src" / "OpenRag.App" / "Assets" +SIZES = [16, 20, 24, 32, 40, 48, 64, 96, 128, 256] +SUPERSAMPLE = 8 +INK = (0x17, 0x18, 0x3A, 255) +TOMATO = (0xFF, 0x6B, 0x4A, 255) +SUN = (0xFF, 0xC8, 0x3D, 255) +COBALT = (0x3F, 0x5B, 0xFF, 255) +WHITE = (255, 255, 255, 255) +TILT = -6 + + +def sticker(n: int, small: bool) -> Image.Image: + """The tomato plate with its ink outline and offset shadow, drawn upright (it is rotated afterwards).""" + img = Image.new("RGBA", (n, n), (0, 0, 0, 0)) + d = ImageDraw.Draw(img) + edge = n * (0.05 if small else 0.035) + shadow = n * 0.05 + box = (n * 0.12, n * 0.12, n * 0.84, n * 0.84) + radius = n * 0.17 + d.rounded_rectangle((box[0] + shadow, box[1] + shadow, box[2] + shadow, box[3] + shadow), radius=radius, fill=INK) + d.rounded_rectangle(box, radius=radius, fill=TOMATO, outline=INK, width=int(edge)) + + # A white page with an ink outline. + page = (n * 0.27, n * 0.24, n * 0.6, n * 0.7) + d.rounded_rectangle(page, radius=n * 0.05, fill=WHITE, outline=INK, width=int(edge * 0.8)) + if not small: + for i, width in enumerate((0.2, 0.16, 0.19)): + y = page[1] + n * (0.08 + i * 0.085) + d.rounded_rectangle((page[0] + n * 0.05, y, page[0] + n * (0.05 + width), y + n * 0.035), radius=n * 0.017, + fill=COBALT) + + # The magnifying glass: a sun lens with an ink ring and handle. + cx, cy, r = n * 0.6, n * 0.6, n * (0.13 if not small else 0.15) + ring = n * (0.05 if not small else 0.065) + handle_end = (cx + r + n * 0.13, cy + r + n * 0.13) + d.line((cx + r * 0.6, cy + r * 0.6, *handle_end), fill=INK, width=int(ring * 1.8)) + d.ellipse((cx - r - ring, cy - r - ring, cx + r + ring, cy + r + ring), fill=INK) + d.ellipse((cx - r, cy - r, cx + r, cy + r), fill=SUN) + return img + + +def draw(size: int) -> Image.Image: + n = size * SUPERSAMPLE + small = size <= 24 + img = sticker(n, small).rotate(TILT, resample=Image.BICUBIC, center=(n / 2, n / 2)) + return img.resize((size, size), Image.LANCZOS) + + +if __name__ == "__main__": + ASSETS.mkdir(parents=True, exist_ok=True) + images = [draw(s) for s in SIZES] + images[-1].save(ASSETS / "OpenRag.ico", sizes=[(s, s) for s in SIZES], append_images=images[:-1]) + images[-1].save(ASSETS / "OpenRag.png") + print(f"wrote {ASSETS / 'OpenRag.ico'}") diff --git a/desktop/web/.gitignore b/desktop/web/.gitignore new file mode 100644 index 0000000..a547bf3 --- /dev/null +++ b/desktop/web/.gitignore @@ -0,0 +1,24 @@ +# Logs +logs +*.log +npm-debug.log* +yarn-debug.log* +yarn-error.log* +pnpm-debug.log* +lerna-debug.log* + +node_modules +dist +dist-ssr +*.local + +# Editor directories and files +.vscode/* +!.vscode/extensions.json +.idea +.DS_Store +*.suo +*.ntvs* +*.njsproj +*.sln +*.sw? diff --git a/desktop/web/eslint.config.js b/desktop/web/eslint.config.js new file mode 100644 index 0000000..092408a --- /dev/null +++ b/desktop/web/eslint.config.js @@ -0,0 +1,28 @@ +import js from '@eslint/js' +import globals from 'globals' +import reactHooks from 'eslint-plugin-react-hooks' +import reactRefresh from 'eslint-plugin-react-refresh' +import tseslint from 'typescript-eslint' + +export default tseslint.config( + { ignores: ['dist'] }, + { + extends: [js.configs.recommended, ...tseslint.configs.recommended], + files: ['**/*.{ts,tsx}'], + languageOptions: { + ecmaVersion: 2020, + globals: globals.browser, + }, + plugins: { + 'react-hooks': reactHooks, + 'react-refresh': reactRefresh, + }, + rules: { + ...reactHooks.configs.recommended.rules, + 'react-refresh/only-export-components': [ + 'warn', + { allowConstantExport: true }, + ], + }, + }, +) diff --git a/desktop/web/index.html b/desktop/web/index.html new file mode 100644 index 0000000..36e870d --- /dev/null +++ b/desktop/web/index.html @@ -0,0 +1,12 @@ + + + + + + Open RAG + + +
+ + + diff --git a/desktop/web/package-lock.json b/desktop/web/package-lock.json new file mode 100644 index 0000000..d7f7714 --- /dev/null +++ b/desktop/web/package-lock.json @@ -0,0 +1,5140 @@ +{ + "name": "open-rag-web", + "version": "0.0.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "open-rag-web", + "version": "0.0.0", + "dependencies": { + "@fontsource/atkinson-hyperlegible": "5.3.0", + "@fontsource/ibm-plex-mono": "5.3.0", + "@fontsource/lilita-one": "5.3.0", + "lucide-react": "1.65.0", + "motion": "14.8.0", + "react": "^19.1.0", + "react-dom": "^19.1.0" + }, + "devDependencies": { + "@eslint/js": "^9.25.0", + "@tailwindcss/vite": "4.3.3", + "@testing-library/jest-dom": "6.9.1", + "@testing-library/react": "16.3.3", + "@types/react": "^19.1.2", + "@types/react-dom": "^19.1.2", + "@vitejs/plugin-react": "^4.4.1", + "eslint": "^9.25.0", + "eslint-plugin-react-hooks": "^5.2.0", + "eslint-plugin-react-refresh": "^0.4.19", + "globals": "^16.0.0", + "jsdom": "29.1.1", + "tailwindcss": "4.3.3", + "typescript": "~5.8.3", + "typescript-eslint": "^8.30.1", + "vite": "^6.3.5", + "vitest": "4.1.12" + } + }, + "node_modules/@adobe/css-tools": { + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/@adobe/css-tools/-/css-tools-4.5.0.tgz", + "integrity": "sha512-6OzddxPio9UiWTCemp4N8cYLV2ZN1ncRnV1cVGtve7dhPOtRkleRyx32GQCYSwDYgaHU3USMm84tNsvKzRCa1Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/@asamuzakjp/css-color": { + "version": "5.1.11", + "resolved": "https://registry.npmjs.org/@asamuzakjp/css-color/-/css-color-5.1.11.tgz", + "integrity": "sha512-KVw6qIiCTUQhByfTd78h2yD1/00waTmm9uy/R7Ck/ctUyAPj+AEDLkQIdJW0T8+qGgj3j5bpNKK7Q3G+LedJWg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@asamuzakjp/generational-cache": "^1.0.1", + "@csstools/css-calc": "^3.2.0", + "@csstools/css-color-parser": "^4.1.0", + "@csstools/css-parser-algorithms": "^4.0.0", + "@csstools/css-tokenizer": "^4.0.0" + }, + "engines": { + "node": "^20.19.0 || ^22.12.0 || >=24.0.0" + } + }, + "node_modules/@asamuzakjp/dom-selector": { + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/@asamuzakjp/dom-selector/-/dom-selector-7.1.1.tgz", + "integrity": "sha512-67RZDnYRc8H/8MLDgQCDE//zoqVFwajkepHZgmXrbwybzXOEwOWGPYGmALYl9J2DOLfFPPs6kKCqmbzV895hTQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@asamuzakjp/generational-cache": "^1.0.1", + "@asamuzakjp/nwsapi": "^2.3.9", + "bidi-js": "^1.0.3", + "css-tree": "^3.2.1", + "is-potential-custom-element-name": "^1.0.1" + }, + "engines": { + "node": "^20.19.0 || ^22.12.0 || >=24.0.0" + } + }, + "node_modules/@asamuzakjp/generational-cache": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/@asamuzakjp/generational-cache/-/generational-cache-1.0.1.tgz", + "integrity": "sha512-wajfB8KqzMCN2KGNFdLkReeHncd0AslUSrvHVvvYWuU8ghncRJoA50kT3zP9MVL0+9g4/67H+cdvBskj9THPzg==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^20.19.0 || ^22.12.0 || >=24.0.0" + } + }, + "node_modules/@asamuzakjp/nwsapi": { + "version": "2.3.9", + "resolved": "https://registry.npmjs.org/@asamuzakjp/nwsapi/-/nwsapi-2.3.9.tgz", + "integrity": "sha512-n8GuYSrI9bF7FFZ/SjhwevlHc8xaVlb/7HmHelnc/PZXBD2ZR49NnN9sMMuDdEGPeeRQ5d0hqlSlEpgCX3Wl0Q==", + "dev": true, + "license": "MIT" + }, + "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.12", + "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.29.12.tgz", + "integrity": "sha512-2W76mhjrpQFO1lK5e8IvGYB2D0YZ7S2R1Z2BjO2ZUYuW+amcpK/z60U6ZZmzskwoa7sJ6XohP/Wg8H5KxXI/IA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.29.12", + "@babel/types": "^7.29.11", + "@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-plugin-utils": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.29.7.tgz", + "integrity": "sha512-G7sHYigPY17oO5SYWnfD/0MTBwVR781S/JI643e/JhUYgVgWE/61SoW3NH9KWUKyKq5LVh3npif99Wkt6j86Jw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-string-parser": { + "version": "7.29.11", + "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.29.11.tgz", + "integrity": "sha512-snZbO7MEDOof+hvNa97EjEY7qD7h2kwvQr5AJC3ZhQudKW5dnej6k3kP9NQV88hJwaS8vDqRLFo9rivLEhle2g==", + "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.10", + "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.29.10.tgz", + "integrity": "sha512-EMCx3AGZ3WfAl6ht7AyQoPm2Lh+BGYEMdc4Q6Hf7uSCDOZFuLq44qNwL+iaim8VlyYhRAo4X43+weadK8ZB4Yg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/template": "^7.29.7", + "@babel/types": "^7.29.8" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/parser": { + "version": "7.29.12", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.12.tgz", + "integrity": "sha512-WJ7JBp/Q4+z/ImydtI7jS6NVco5++632ExBemSX+Ysb+G1lCwQ5BVo3SY+jGGOcZXI4ZccbZSUSJLNBW6eEpJg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.29.11" + }, + "bin": { + "parser": "bin/babel-parser.js" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@babel/plugin-transform-react-jsx-self": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-self/-/plugin-transform-react-jsx-self-7.29.7.tgz", + "integrity": "sha512-TL0hMc9xzy86VD31nUiwzd5otRAcyEPcsegCxolO0PvcXuH1v0kECe/UIznYFihpkvU5wg/jk4v0TTEFfm53fw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-react-jsx-source": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-source/-/plugin-transform-react-jsx-source-7.29.7.tgz", + "integrity": "sha512-06IyK09H3wi4cGbhDBwp5gUGo0IKtnYa8tyTiephirPCK6fbobVGiXMMI5zLQ4aKEYP3wZ3ArU44o+8KMrSG/Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/runtime": { + "version": "7.29.10", + "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.29.10.tgz", + "integrity": "sha512-NpugTzbKgGrNe45Ui32cN8vCFFMxVtP/9rtfwv0nP5FRDAjvYBxJcLVpYA9mr1jxP6cnIT7x9LUzuDTbWYYNRA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.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.12", + "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.12.tgz", + "integrity": "sha512-MscXe/NAZcOkYEsRajHZFt3ynsb22PUi6CTrp5U7+RYycR9By84mn9mFN54YgfITiqK4hFx3Ju3tZSyzfpS5ew==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.29.7", + "@babel/generator": "^7.29.12", + "@babel/helper-globals": "^7.29.7", + "@babel/parser": "^7.29.12", + "@babel/template": "^7.29.7", + "@babel/types": "^7.29.11", + "debug": "^4.3.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/types": { + "version": "7.29.11", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.11.tgz", + "integrity": "sha512-WCsemW40Cpc6gouC1SrY6PBaZ+oLRlEVY9XBvZBI7il/HyUrb2nJ505wE1MHEFyDZNnrWDEuy4jL50WVHfTTSQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-string-parser": "^7.29.11", + "@babel/helper-validator-identifier": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@bramus/specificity": { + "version": "2.4.3", + "resolved": "https://registry.npmjs.org/@bramus/specificity/-/specificity-2.4.3.tgz", + "integrity": "sha512-0GEz8qJWokkUVYQYRukmkSHIFNoBH8QTreeHrAFbvz1XFYc3Y+puhMs8PQ5x8GNugiC2l5jvDBXKLbBIByeSBw==", + "dev": true, + "license": "MIT", + "dependencies": { + "css-tree": "^3.2.1" + }, + "bin": { + "specificity": "bin/cli.js" + } + }, + "node_modules/@csstools/color-helpers": { + "version": "6.1.2", + "resolved": "https://registry.npmjs.org/@csstools/color-helpers/-/color-helpers-6.1.2.tgz", + "integrity": "sha512-grhRy3OKmniaAEKXMjua5z/EODX0MSqBGjunw8+j/3HQjOnahs2AGhvEOIYVUWcU6ScApbhLhVrQTX8XqrMrow==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/csstools" + }, + { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + } + ], + "license": "MIT-0", + "engines": { + "node": ">=20.19.0" + } + }, + "node_modules/@csstools/css-calc": { + "version": "3.4.3", + "resolved": "https://registry.npmjs.org/@csstools/css-calc/-/css-calc-3.4.3.tgz", + "integrity": "sha512-iex20d8CHVkyvg6B7UKV7uHnI2Bqo9g+EFfT9E0y+GvTvhZ/DwONJ+9aKb1dlqm0ZiGsL5RXjp0fCoJYnkeDjA==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/csstools" + }, + { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + } + ], + "license": "MIT", + "engines": { + "node": ">=20.19.0" + }, + "peerDependencies": { + "@csstools/css-parser-algorithms": "^4.0.2", + "@csstools/css-tokenizer": "^4.0.2" + } + }, + "node_modules/@csstools/css-color-parser": { + "version": "4.2.7", + "resolved": "https://registry.npmjs.org/@csstools/css-color-parser/-/css-color-parser-4.2.7.tgz", + "integrity": "sha512-zgm9yjQz5iJB4VL8RyVwd71TWB8Q89FSxt/NzXoWqPSkEBOVtn9L6vAPtSc9hpKfB0Awo/AL2VKFHjYetBLFHQ==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/csstools" + }, + { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + } + ], + "license": "MIT", + "dependencies": { + "@csstools/color-helpers": "^6.1.2", + "@csstools/css-calc": "^3.4.3" + }, + "engines": { + "node": ">=20.19.0" + }, + "peerDependencies": { + "@csstools/css-parser-algorithms": "^4.0.2", + "@csstools/css-tokenizer": "^4.0.2" + } + }, + "node_modules/@csstools/css-parser-algorithms": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/@csstools/css-parser-algorithms/-/css-parser-algorithms-4.0.2.tgz", + "integrity": "sha512-40cSKyMvK+tq4qz6Awrlye2WGuOKt3FwPgtGg6KTfbHOWNw+Rk1rzbAtZnZ6IBhsY491HLRnDXwoyBAijmmILA==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/csstools" + }, + { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + } + ], + "license": "MIT", + "engines": { + "node": ">=20.19.0" + }, + "peerDependencies": { + "@csstools/css-tokenizer": "^4.0.2" + } + }, + "node_modules/@csstools/css-syntax-patches-for-csstree": { + "version": "1.1.16", + "resolved": "https://registry.npmjs.org/@csstools/css-syntax-patches-for-csstree/-/css-syntax-patches-for-csstree-1.1.16.tgz", + "integrity": "sha512-LsDbJPP/B8cPasUJyTA5S99F7C4G93ngW8hUluXz8CFeOaaRnBPtBiIlvgcPYU0HmHNz8CXg+1vwFrIB4F6Dgw==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/csstools" + }, + { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + } + ], + "license": "MIT-0", + "peerDependencies": { + "css-tree": "^3.2.1" + }, + "peerDependenciesMeta": { + "css-tree": { + "optional": true + } + } + }, + "node_modules/@csstools/css-tokenizer": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/@csstools/css-tokenizer/-/css-tokenizer-4.0.2.tgz", + "integrity": "sha512-OoKoR0f76dCY666JlcbhmVTs2drYj1GUXZTYTcbUgJjh9Nv41aFfZ21bPQTERm5+L5cBDo466NltB2lplS5GBw==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/csstools" + }, + { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + } + ], + "license": "MIT", + "engines": { + "node": ">=20.19.0" + } + }, + "node_modules/@esbuild/aix-ppc64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.12.tgz", + "integrity": "sha512-Hhmwd6CInZ3dwpuGTF8fJG6yoWmsToE+vYgD4nytZVxcu1ulHpUQRAB1UJ8+N1Am3Mz4+xOByoQoSZf4D+CpkA==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "aix" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-arm": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.12.tgz", + "integrity": "sha512-VJ+sKvNA/GE7Ccacc9Cha7bpS8nyzVv0jdVgwNDaR4gDMC/2TTRc33Ip8qrNYUcpkOHUT5OZ0bUcNNVZQ9RLlg==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-arm64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.12.tgz", + "integrity": "sha512-6AAmLG7zwD1Z159jCKPvAxZd4y/VTO0VkprYy+3N2FtJ8+BQWFXU+OxARIwA46c5tdD9SsKGZ/1ocqBS/gAKHg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-x64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.12.tgz", + "integrity": "sha512-5jbb+2hhDHx5phYR2By8GTWEzn6I9UqR11Kwf22iKbNpYrsmRB18aX/9ivc5cabcUiAT/wM+YIZ6SG9QO6a8kg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/darwin-arm64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.12.tgz", + "integrity": "sha512-N3zl+lxHCifgIlcMUP5016ESkeQjLj/959RxxNYIthIg+CQHInujFuXeWbWMgnTo4cp5XVHqFPmpyu9J65C1Yg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/darwin-x64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.12.tgz", + "integrity": "sha512-HQ9ka4Kx21qHXwtlTUVbKJOAnmG1ipXhdWTmNXiPzPfWKpXqASVcWdnf2bnL73wgjNrFXAa3yYvBSd9pzfEIpA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/freebsd-arm64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.12.tgz", + "integrity": "sha512-gA0Bx759+7Jve03K1S0vkOu5Lg/85dou3EseOGUes8flVOGxbhDDh/iZaoek11Y8mtyKPGF3vP8XhnkDEAmzeg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/freebsd-x64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.12.tgz", + "integrity": "sha512-TGbO26Yw2xsHzxtbVFGEXBFH0FRAP7gtcPE7P5yP7wGy7cXK2oO7RyOhL5NLiqTlBh47XhmIUXuGciXEqYFfBQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-arm": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.12.tgz", + "integrity": "sha512-lPDGyC1JPDou8kGcywY0YILzWlhhnRjdof3UlcoqYmS9El818LLfJJc3PXXgZHrHCAKs/Z2SeZtDJr5MrkxtOw==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-arm64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.12.tgz", + "integrity": "sha512-8bwX7a8FghIgrupcxb4aUmYDLp8pX06rGh5HqDT7bB+8Rdells6mHvrFHHW2JAOPZUbnjUpKTLg6ECyzvas2AQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-ia32": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.12.tgz", + "integrity": "sha512-0y9KrdVnbMM2/vG8KfU0byhUN+EFCny9+8g202gYqSSVMonbsCfLjUO+rCci7pM0WBEtz+oK/PIwHkzxkyharA==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-loong64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.12.tgz", + "integrity": "sha512-h///Lr5a9rib/v1GGqXVGzjL4TMvVTv+s1DPoxQdz7l/AYv6LDSxdIwzxkrPW438oUXiDtwM10o9PmwS/6Z0Ng==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-mips64el": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.12.tgz", + "integrity": "sha512-iyRrM1Pzy9GFMDLsXn1iHUm18nhKnNMWscjmp4+hpafcZjrr2WbT//d20xaGljXDBYHqRcl8HnxbX6uaA/eGVw==", + "cpu": [ + "mips64el" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-ppc64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.12.tgz", + "integrity": "sha512-9meM/lRXxMi5PSUqEXRCtVjEZBGwB7P/D4yT8UG/mwIdze2aV4Vo6U5gD3+RsoHXKkHCfSxZKzmDssVlRj1QQA==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-riscv64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.12.tgz", + "integrity": "sha512-Zr7KR4hgKUpWAwb1f3o5ygT04MzqVrGEGXGLnj15YQDJErYu/BGg+wmFlIDOdJp0PmB0lLvxFIOXZgFRrdjR0w==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-s390x": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.12.tgz", + "integrity": "sha512-MsKncOcgTNvdtiISc/jZs/Zf8d0cl/t3gYWX8J9ubBnVOwlk65UIEEvgBORTiljloIWnBzLs4qhzPkJcitIzIg==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-x64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.12.tgz", + "integrity": "sha512-uqZMTLr/zR/ed4jIGnwSLkaHmPjOjJvnm6TVVitAa08SLS9Z0VM8wIRx7gWbJB5/J54YuIMInDquWyYvQLZkgw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/netbsd-arm64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.12.tgz", + "integrity": "sha512-xXwcTq4GhRM7J9A8Gv5boanHhRa/Q9KLVmcyXHCTaM4wKfIpWkdXiMog/KsnxzJ0A1+nD+zoecuzqPmCRyBGjg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/netbsd-x64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.12.tgz", + "integrity": "sha512-Ld5pTlzPy3YwGec4OuHh1aCVCRvOXdH8DgRjfDy/oumVovmuSzWfnSJg+VtakB9Cm0gxNO9BzWkj6mtO1FMXkQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openbsd-arm64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.12.tgz", + "integrity": "sha512-fF96T6KsBo/pkQI950FARU9apGNTSlZGsv1jZBAlcLL1MLjLNIWPBkj5NlSz8aAzYKg+eNqknrUJ24QBybeR5A==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openbsd-x64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.12.tgz", + "integrity": "sha512-MZyXUkZHjQxUvzK7rN8DJ3SRmrVrke8ZyRusHlP+kuwqTcfWLyqMOE3sScPPyeIXN/mDJIfGXvcMqCgYKekoQw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openharmony-arm64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.25.12.tgz", + "integrity": "sha512-rm0YWsqUSRrjncSXGA7Zv78Nbnw4XL6/dzr20cyrQf7ZmRcsovpcRBdhD43Nuk3y7XIoW2OxMVvwuRvk9XdASg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/sunos-x64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.12.tgz", + "integrity": "sha512-3wGSCDyuTHQUzt0nV7bocDy72r2lI33QL3gkDNGkod22EsYl04sMf0qLb8luNKTOmgF/eDEDP5BFNwoBKH441w==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "sunos" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-arm64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.12.tgz", + "integrity": "sha512-rMmLrur64A7+DKlnSuwqUdRKyd3UE7oPJZmnljqEptesKM8wx9J8gx5u0+9Pq0fQQW8vqeKebwNXdfOyP+8Bsg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-ia32": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.12.tgz", + "integrity": "sha512-HkqnmmBoCbCwxUKKNPBixiWDGCpQGVsrQfJoVGYLPT41XWF8lHuE5N6WhVia2n4o5QK5M4tYr21827fNhi4byQ==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-x64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.12.tgz", + "integrity": "sha512-alJC0uCZpTFrSL0CCDjcgleBXPnCrEAhTBILpeAp7M/OFgoqtAetfBzX0xM00MUsVVPpVjlPuMbREqnZCXaTnA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "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.21.2", + "resolved": "https://registry.npmjs.org/@eslint/config-array/-/config-array-0.21.2.tgz", + "integrity": "sha512-nJl2KGTlrf9GjLimgIru+V/mzgSK0ABCDQRvxw5BjURL7WfH5uoWmizbH7QB6MmnMBd8cIC9uceWnezL1VZWWw==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@eslint/object-schema": "^2.1.7", + "debug": "^4.3.1", + "minimatch": "^3.1.5" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + } + }, + "node_modules/@eslint/config-helpers": { + "version": "0.4.2", + "resolved": "https://registry.npmjs.org/@eslint/config-helpers/-/config-helpers-0.4.2.tgz", + "integrity": "sha512-gBrxN88gOIf3R7ja5K9slwNayVcZgK6SOUORm2uBzTeIEfeVaIhOpCtTox3P6R7o2jLFwLFTLnC7kU/RGcYEgw==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@eslint/core": "^0.17.0" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + } + }, + "node_modules/@eslint/core": { + "version": "0.17.0", + "resolved": "https://registry.npmjs.org/@eslint/core/-/core-0.17.0.tgz", + "integrity": "sha512-yL/sLrpmtDaFEiUj1osRP4TI2MDz1AddJL+jZ7KSqvBuliN4xqYY54IfdN8qD8Toa6g1iloph1fxQNkjOxrrpQ==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@types/json-schema": "^7.0.15" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + } + }, + "node_modules/@eslint/eslintrc": { + "version": "3.3.7", + "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-3.3.7.tgz", + "integrity": "sha512-F42g89Qd5oAWtp0k0nnSrjziAKza7w8SVT4mStc18LZMaRb4J1HQAHLCalEtDCxrTuksx7NU9qsmeLwpOfPqWw==", + "dev": true, + "license": "MIT", + "dependencies": { + "ajv": "^6.14.0", + "debug": "^4.3.2", + "espree": "^10.0.1", + "globals": "^14.0.0", + "ignore": "^5.2.0", + "import-fresh": "^3.2.1", + "js-yaml": "^4.3.2", + "minimatch": "^3.1.5", + "strip-json-comments": "^3.1.1" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/@eslint/eslintrc/node_modules/globals": { + "version": "14.0.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-14.0.0.tgz", + "integrity": "sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/@eslint/js": { + "version": "9.39.5", + "resolved": "https://registry.npmjs.org/@eslint/js/-/js-9.39.5.tgz", + "integrity": "sha512-QywQuszQh77pIXCsq998c8hbhSTI/azTty1Z6N53dmAudKHhy573j3yvRLsX2BSp8YpLtoCEG8E9DJe+8zUh4A==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "url": "https://eslint.org/donate" + } + }, + "node_modules/@eslint/object-schema": { + "version": "2.1.7", + "resolved": "https://registry.npmjs.org/@eslint/object-schema/-/object-schema-2.1.7.tgz", + "integrity": "sha512-VtAOaymWVfZcmZbp6E2mympDIHvyjXs/12LqWYjVw6qjrfF+VK+fyG33kChz3nnK+SU5/NeHOqrTEHS8sXO3OA==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + } + }, + "node_modules/@eslint/plugin-kit": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/@eslint/plugin-kit/-/plugin-kit-0.4.1.tgz", + "integrity": "sha512-43/qtrDUokr7LJqoF2c3+RInu/t4zfrpYdoSDfYyhg52rwLV6TnOvdG4fXm7IkSB3wErkcmJS9iEhjVtOSEjjA==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@eslint/core": "^0.17.0", + "levn": "^0.4.1" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + } + }, + "node_modules/@exodus/bytes": { + "version": "1.16.0", + "resolved": "https://registry.npmjs.org/@exodus/bytes/-/bytes-1.16.0.tgz", + "integrity": "sha512-IcpW84uEn3N7ETtNZMlxKhfl6Pec8rUNGOTBtWbK1FKhJxIFAptZyVrvVRVBimAJxJCgc3PxepxkdWWG4DVzfA==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^20.19.0 || ^22.12.0 || >=24.0.0" + }, + "peerDependencies": { + "@noble/hashes": "^1.8.0 || ^2.0.0" + }, + "peerDependenciesMeta": { + "@noble/hashes": { + "optional": true + } + } + }, + "node_modules/@fontsource/atkinson-hyperlegible": { + "version": "5.3.0", + "resolved": "https://registry.npmjs.org/@fontsource/atkinson-hyperlegible/-/atkinson-hyperlegible-5.3.0.tgz", + "integrity": "sha512-Sp8Ve8+rQmENY2Lv02VH7sLpntzTTvnncnJMTbRE7DX6TLxGraN4ykZfzaUWIoCFmaomwkvNiqmlPkrKBuDoSA==", + "license": "OFL-1.1", + "funding": { + "url": "https://github.com/sponsors/ayuhito" + } + }, + "node_modules/@fontsource/ibm-plex-mono": { + "version": "5.3.0", + "resolved": "https://registry.npmjs.org/@fontsource/ibm-plex-mono/-/ibm-plex-mono-5.3.0.tgz", + "integrity": "sha512-eTgnZjZEGk1QtD3ZstF+Vclo2HLAni8YMy34/DxllwZvyz1lR/1RF/xTiAquOBO7MvqBx8D2Ig2WCPMVfdZu7Q==", + "license": "OFL-1.1", + "funding": { + "url": "https://github.com/sponsors/ayuhito" + } + }, + "node_modules/@fontsource/lilita-one": { + "version": "5.3.0", + "resolved": "https://registry.npmjs.org/@fontsource/lilita-one/-/lilita-one-5.3.0.tgz", + "integrity": "sha512-bNW3tD+m5pOsAQpW/NvtRbFthFe+B73hDJK2DLLCFCtF+1p+UMBgo7ibxdcb9Sftr06LKAVbt080wiMdSqGbOg==", + "license": "OFL-1.1", + "funding": { + "url": "https://github.com/sponsors/ayuhito" + } + }, + "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/@napi-rs/lzma-linux-x64-gnu": { + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/@napi-rs/lzma-linux-x64-gnu/-/lzma-linux-x64-gnu-1.5.1.tgz", + "integrity": "sha512-oTXEIha4SsuXdTA4Iyskj0kpdx2yVXdhd75c2v3xGrHFfVMsbhTPZU/nMPL4sWKo4pBHm3aucLaqGlF696dTyQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^22.20 || ^24.12 || >=25" + } + }, + "node_modules/@rolldown/pluginutils": { + "version": "1.0.0-beta.27", + "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-beta.27.tgz", + "integrity": "sha512-+d0F4MKMCbeVUJwG96uQ4SgAznZNSq93I3V+9NHA4OpvqG8mRCpGdKmK8l/dl02h2CCDHwW2FqilnTyDcAnqjA==", + "dev": true, + "license": "MIT" + }, + "node_modules/@rollup/rollup-android-arm-eabi": { + "version": "4.67.4", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.67.4.tgz", + "integrity": "sha512-/v/pUAPOcwp+r1Hjjdg0cBV1TE89CzGKrKh2FgkIQw2QBcIMmVPOCSfuOZStCn4Xh/98HXfo/ht6ztcssctPNg==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-android-arm64": { + "version": "4.67.4", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.67.4.tgz", + "integrity": "sha512-6tmmB/P52Vt167FXXEw5auiEUgTtZz7aqUgWHqYXToIUE0HFDY6fTdAyeekjjsNk6O/8dtpSKtClxSj1mMneKQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-android-x64": { + "version": "4.67.4", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-x64/-/rollup-android-x64-4.67.4.tgz", + "integrity": "sha512-8Z9Q4RmotVmuL4llOvqX814JNiOK1oqoBv+glG5KbpRfUiypqzz2/fxIzK4Pq129l4dT5a8Gszmpc0/XPYoFuQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-darwin-arm64": { + "version": "4.67.4", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.67.4.tgz", + "integrity": "sha512-pnq6hssxTtwuRAl6Kdi/+IDY+b1IhkUetjhUkdLAAJCssjfqtL2Oqy/FXJVJFtAWOu1oRlArIvf0Yk1O92x2HQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-darwin-x64": { + "version": "4.67.4", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.67.4.tgz", + "integrity": "sha512-BeIrGZvHMVdJg/N+ohZfFywG/gF41684YhDj2wBvouj7m9ziP1tZDUNwzXRiDY+3WIKngaC4hiUBqVtBPGP5og==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-freebsd-arm64": { + "version": "4.67.4", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.67.4.tgz", + "integrity": "sha512-fRFX/oqNg/g780DKoS8RIfYcZD59Ru5O/bSeK1N7gQljBFrTxJY/q5EX4eMs5SrJf32VgVBVVYCdfPpzAwPPnQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ] + }, + "node_modules/@rollup/rollup-freebsd-x64": { + "version": "4.67.4", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.67.4.tgz", + "integrity": "sha512-bSrBRopG1q+0RuOsW0NtYTtIODlvNA3T3ebx5WnQVdSxWIoXFmj+rZdHUHdSLgFdZ5M6VGmekYE7r4RMGQXjfg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ] + }, + "node_modules/@rollup/rollup-linux-arm-gnueabihf": { + "version": "4.67.4", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.67.4.tgz", + "integrity": "sha512-L8IvdrJVtl65g1ozwDSyjGPG+FmibhCdFUwmqTItJLw0S3+Oj4QzFs7rfgTUiK7rsPjkCLdG1/GApFxoynXFJQ==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm-musleabihf": { + "version": "4.67.4", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.67.4.tgz", + "integrity": "sha512-h7PcoQOzC31jshNpQ48J0akB9tsghjkSjSl5AZ6XsVGTxVsln7t7C4SQyw62tNVSaz2SeHgk4VT2ELbL17BSHQ==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-gnu": { + "version": "4.67.4", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.67.4.tgz", + "integrity": "sha512-KSPuOBNHoOl7AsVjeY1KZci8+0up0U4TFAHU5IzBYN8P+Z6cB9DZq28+JQycZW7f6WLLa/tSzhV7Rdy95bVi+g==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-musl": { + "version": "4.67.4", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.67.4.tgz", + "integrity": "sha512-0E/mKmVk1PlQeQYygIwQm0jlwjANTzGSiNBMPrFx+rdFGFj/2Axh4p6XwcrystQIqXZVudTaGsdbDpzYgJ4wSA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-loong64-gnu": { + "version": "4.67.4", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.67.4.tgz", + "integrity": "sha512-Fvw7dOSc2Sa9UOipRZVI0zOgdLCzsjVyD/6JuHXzUHTXFu7mMgmeX/0/bCVBIut1dz+nWz3pV4WpS/Qg0XVnxw==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-loong64-musl": { + "version": "4.67.4", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.67.4.tgz", + "integrity": "sha512-jzxbVHaE7V3F+P0wEK7UydQtvv7Twfdtx58jI5/3VRx1jJxyrn+qFwfXmqjVFxPhBl+zjaRs+ZJMFJw7vdHaQA==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-ppc64-gnu": { + "version": "4.67.4", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.67.4.tgz", + "integrity": "sha512-fhtrzp9p4GjEJVaigaap9g6X9nP6xgJtKiLLXSDgpE18HXufA5aqfltGn+KAqMtVZReJZfOrXm//y5YSA9BWbA==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-ppc64-musl": { + "version": "4.67.4", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.67.4.tgz", + "integrity": "sha512-uynaF7IUHwAckV0S+yC1f5esy9gB+aqCBsPH5BOck32TYdCuAn2lVG5tvUcFnEsrviGEmRZxE1NHSOieUPYJEg==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-riscv64-gnu": { + "version": "4.67.4", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.67.4.tgz", + "integrity": "sha512-uaqRFdfb8eIa2bVHN/FE3ndCvR0zV2xv0AwjCfxrqSu6l6fp/54VhjfhslKlf2RIik9L1jwlt4E56PeVX6tQtQ==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-riscv64-musl": { + "version": "4.67.4", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.67.4.tgz", + "integrity": "sha512-JZRow7kmxUDEASnxHuVG5itTm+nTXi9BQUABcVUnUEngC+OPwMrpx1uJ9hIA/v+IcAEBL52ktCSPXk5OJn9Jqg==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-s390x-gnu": { + "version": "4.67.4", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.67.4.tgz", + "integrity": "sha512-rdrh4e+Lq9fCNKoDPaCqeHXbQCe7yl77Ukl45tlSClwYdZ1gpFGZz1XLJdYtY++FRlfL5aHvb6/0n3GDW/Nxsw==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-gnu": { + "version": "4.67.4", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.67.4.tgz", + "integrity": "sha512-wL7MS4r0fYcxluF3ne2plofHZiB/LsqNCnyaUlyiKpAJLb6agPSFz7DEFCfkonWAZXMrLwCmC08b2ZEnEdJkog==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-musl": { + "version": "4.67.4", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.67.4.tgz", + "integrity": "sha512-4H0XHfd2VufGjX7NjUyeue78sD0bRIoKSGjGqO+F5nSvL6jN48NAU7esdmtFEYxZXwObLtt3MJ/kHS0jASMW3g==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-openbsd-x64": { + "version": "4.67.4", + "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.67.4.tgz", + "integrity": "sha512-osRHQbE55pZpCLetpMsFmhkapyZnAUH73qRKMh+npi3boUom6u6hdaTTPSxlInXxwJHsn9r2uDhdz0V7Yoxx2A==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ] + }, + "node_modules/@rollup/rollup-openharmony-arm64": { + "version": "4.67.4", + "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.67.4.tgz", + "integrity": "sha512-95+exYEyOwrZePsE0czi4q7X5lxKPa21+lmyAZlwbYENITQ0Unk4HAQAFp/p+KhXBHBx9mUABXRYjOC5A1wY3Q==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ] + }, + "node_modules/@rollup/rollup-win32-arm64-msvc": { + "version": "4.67.4", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.67.4.tgz", + "integrity": "sha512-FOXOcKhNQpO4Po+Ynan6IbtM67SrXZbgpRJWVYwz53CT5veI7sVzDwVBmWS65N5Imv+wK3SVhIPAl+C5DXXNCg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-ia32-msvc": { + "version": "4.67.4", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.67.4.tgz", + "integrity": "sha512-cklKh0gJOkAZQcWziQa3hrjxZKN+PCHZ7SPTyGJDAiBVr05ZXlEjGFCG7zFJMaVibxsmzAe1FimN4u/HBns9+Q==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-x64-gnu": { + "version": "4.67.4", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.67.4.tgz", + "integrity": "sha512-AegwxJPc9bvUp8fQtlsUHkFMOMkGylWU7glyL+YD4vwG+QaYoGXYLSsQoeTD7kvoLZrVlMWNVhTg1dedY5C1VQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-x64-msvc": { + "version": "4.67.4", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.67.4.tgz", + "integrity": "sha512-RJZnrwTWj7Iq2ooBwoGbDdC65tDwYawneGcAfFMJqVUrRZMcskka6nTkBpXR/47G7kzn3EW2qupExnaBy11vwg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@standard-schema/spec": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.1.0.tgz", + "integrity": "sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==", + "dev": true, + "license": "MIT" + }, + "node_modules/@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/@testing-library/dom": { + "version": "10.4.2", + "resolved": "https://registry.npmjs.org/@testing-library/dom/-/dom-10.4.2.tgz", + "integrity": "sha512-yzr2S9HyAIdhz2/6qHgbs665Q7PKVcDF05vsOlHPxG1mo36gKVesdYVeDLnXgfjJ03CrKRk08knc6+E/9m8v2Q==", + "dev": true, + "license": "MIT", + "peer": true, + "dependencies": { + "@babel/code-frame": "^7.10.4", + "@babel/runtime": "^7.12.5", + "@types/aria-query": "^5.0.1", + "aria-query": "5.3.0", + "dom-accessibility-api": "^0.5.9", + "lz-string": "^1.5.0", + "picocolors": "1.1.1", + "pretty-format": "^27.0.2" + }, + "engines": { + "node": ">=18" + } + }, + "node_modules/@testing-library/jest-dom": { + "version": "6.9.1", + "resolved": "https://registry.npmjs.org/@testing-library/jest-dom/-/jest-dom-6.9.1.tgz", + "integrity": "sha512-zIcONa+hVtVSSep9UT3jZ5rizo2BsxgyDYU7WFD5eICBE7no3881HGeb/QkGfsJs6JTkY1aQhT7rIPC7e+0nnA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@adobe/css-tools": "^4.4.0", + "aria-query": "^5.0.0", + "css.escape": "^1.5.1", + "dom-accessibility-api": "^0.6.3", + "picocolors": "^1.1.1", + "redent": "^3.0.0" + }, + "engines": { + "node": ">=14", + "npm": ">=6", + "yarn": ">=1" + } + }, + "node_modules/@testing-library/jest-dom/node_modules/dom-accessibility-api": { + "version": "0.6.3", + "resolved": "https://registry.npmjs.org/dom-accessibility-api/-/dom-accessibility-api-0.6.3.tgz", + "integrity": "sha512-7ZgogeTnjuHbo+ct10G9Ffp0mif17idi0IyWNVA/wcwcm7NPOD/WEHVP3n7n3MhXqxoIYm8d6MuZohYWIZ4T3w==", + "dev": true, + "license": "MIT" + }, + "node_modules/@testing-library/react": { + "version": "16.3.3", + "resolved": "https://registry.npmjs.org/@testing-library/react/-/react-16.3.3.tgz", + "integrity": "sha512-Uo193NgQbPMz6lrrhtRQQFcMC6Re/ELLFbbuVL30WDlZxlpZf9/lMHTAVxPRLw1q1iu9OJmR1c2BLiENRstdBg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/runtime": "^7.12.5" + }, + "engines": { + "node": ">=18" + }, + "peerDependencies": { + "@testing-library/dom": "^10.0.0", + "@types/react": "^18.0.0 || ^19.0.0", + "@types/react-dom": "^18.0.0 || ^19.0.0", + "react": "^18.0.0 || ^19.0.0", + "react-dom": "^18.0.0 || ^19.0.0" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@types/aria-query": { + "version": "5.0.4", + "resolved": "https://registry.npmjs.org/@types/aria-query/-/aria-query-5.0.4.tgz", + "integrity": "sha512-rfT93uj5s0PRL7EzccGMs3brplhcrghnDoV26NqKhCAS1hVo+WdNsPvE/yb6ilfr5hi2MEk6d5EWJTKdxg8jVw==", + "dev": true, + "license": "MIT", + "peer": true + }, + "node_modules/@types/babel__core": { + "version": "7.20.5", + "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.5.tgz", + "integrity": "sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.20.7", + "@babel/types": "^7.20.7", + "@types/babel__generator": "*", + "@types/babel__template": "*", + "@types/babel__traverse": "*" + } + }, + "node_modules/@types/babel__generator": { + "version": "7.27.0", + "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.27.0.tgz", + "integrity": "sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.0.0" + } + }, + "node_modules/@types/babel__template": { + "version": "7.4.4", + "resolved": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.4.tgz", + "integrity": "sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.1.0", + "@babel/types": "^7.0.0" + } + }, + "node_modules/@types/babel__traverse": { + "version": "7.28.0", + "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.28.0.tgz", + "integrity": "sha512-8PvcXf70gTDZBgt9ptxJ8elBeBjcLOAcOtoO/mPJjtji1+CdGbHgm77om1GrsPxsiE+uXIpNSK64UYaIwQXd4Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.28.2" + } + }, + "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/deep-eql": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/@types/deep-eql/-/deep-eql-4.0.2.tgz", + "integrity": "sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/estree": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.10.tgz", + "integrity": "sha512-lTyOMnOcmRBzdCv6/4zUZCrEhV0xrqQiUZBZtVcbmLHBXKLnN8q89v/wKRF/Q0HbwVsqbIG3o5HDoFl9sduM+g==", + "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/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==", + "dev": true, + "license": "MIT", + "peerDependencies": { + "@types/react": "^19.3.0" + } + }, + "node_modules/@typescript-eslint/eslint-plugin": { + "version": "8.72.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.72.1.tgz", + "integrity": "sha512-5CokTWXpmbylfFabsbvHC0CAw3XLaGnoa+nFJX5FR592h/LoZsENUE6p/rg5xvkKrFEXz6pYmgI29AgXc2N3BQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@eslint-community/regexpp": "^4.12.2", + "@typescript-eslint/scope-manager": "8.72.1", + "@typescript-eslint/type-utils": "8.72.1", + "@typescript-eslint/utils": "8.72.1", + "@typescript-eslint/visitor-keys": "8.72.1", + "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.72.1", + "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.14", + "resolved": "https://registry.npmjs.org/ignore/-/ignore-7.0.14.tgz", + "integrity": "sha512-wCBiZ77u1tuWde6G/nfOtLaCTYcFDU5yCzARzK10y+rLhzYoL7a7yEemcopcc2Mzow7gZOIjnV2ym1NYmdiJOQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 4" + } + }, + "node_modules/@typescript-eslint/parser": { + "version": "8.72.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-8.72.1.tgz", + "integrity": "sha512-ZGwZP4OCfyA0AQTpEAMWz+rtX01DRhQWW5hB0ucKDEIX5U7jdmPSaMx94rQfaPAQzIYz2BimOgKOJtjfpRFQ9g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/scope-manager": "8.72.1", + "@typescript-eslint/types": "8.72.1", + "@typescript-eslint/typescript-estree": "8.72.1", + "@typescript-eslint/visitor-keys": "8.72.1", + "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.72.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/project-service/-/project-service-8.72.1.tgz", + "integrity": "sha512-fAuVMkwdO/huI8nyo/WKnNKf6Gag93S56Rh3Ts5mGcavwSdaN8tRg1gCeIGX8PF+nzp1BjGfO4gHhGzW1J6jTg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/tsconfig-utils": "^8.72.1", + "@typescript-eslint/types": "^8.72.1", + "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.72.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-8.72.1.tgz", + "integrity": "sha512-lC/t6eMCZZQAAKZEYGL6RDVSuFehpdmMT6h+nJIjIa6oylN/PwDgDVtEIbB7O9xFfZYtZAYLoLlDNWKJhtF+uQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/types": "8.72.1", + "@typescript-eslint/visitor-keys": "8.72.1" + }, + "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.72.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/tsconfig-utils/-/tsconfig-utils-8.72.1.tgz", + "integrity": "sha512-e4D5R5vpeAEPBxT2BAzsFQL3sbwyeeeo5+aczgNSRK1V734jE7pTqaGFU+fXapWEQwnZbpFaTn32+Z8DwS6OTg==", + "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.72.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-8.72.1.tgz", + "integrity": "sha512-iY2wlmyrXJmx4yxUGP3aYCFF3cA/6ShddOKmLU2dx7LnEykbAM8WThlxZEfd1NddqceF6eJmZUayxx9oKIYNlg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/types": "8.72.1", + "@typescript-eslint/typescript-estree": "8.72.1", + "@typescript-eslint/utils": "8.72.1", + "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.72.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-8.72.1.tgz", + "integrity": "sha512-LmE5IhQet1BWOWEXqBrVtBPsMAOQ6Nzk35d+WLh3mk4EUF33sqlfxjio1MdYeSvKSG5skactKKuixBIKXhL4Rw==", + "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.72.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-8.72.1.tgz", + "integrity": "sha512-DAlUoUV93hIvrtIQLwCbmZQYVZwOMhiHJrOVUUIWicFZaIYjTRqlY3I/NZevfkLmSqkNHRu2qYDcq9lrn16oOQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/project-service": "8.72.1", + "@typescript-eslint/tsconfig-utils": "8.72.1", + "@typescript-eslint/types": "8.72.1", + "@typescript-eslint/visitor-keys": "8.72.1", + "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/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/@typescript-eslint/typescript-estree/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/@typescript-eslint/typescript-estree/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/@typescript-eslint/typescript-estree/node_modules/semver": { + "version": "7.8.6", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.8.6.tgz", + "integrity": "sha512-9lpSSU4Mly3mrtruwLs1eLK6+gzbzqeBFwRNjIjE+9LuDpWdYctrQlQ3ej1Ilgi7gknpsTRnPoLP8DpCHqHIJw==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/@typescript-eslint/utils": { + "version": "8.72.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-8.72.1.tgz", + "integrity": "sha512-5v5liypurJBFHCBNqh/RjsymAD+VWcE0djuGY/BUqp5fC3Qn+luWDEksjuTtWjPn6i5zQlUtkZCRG/CYG0yCkA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@eslint-community/eslint-utils": "^4.9.1", + "@typescript-eslint/scope-manager": "8.72.1", + "@typescript-eslint/types": "8.72.1", + "@typescript-eslint/typescript-estree": "8.72.1" + }, + "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.72.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-8.72.1.tgz", + "integrity": "sha512-SB8xqipSzZHUePCCLNeYxqnxq83X61/qzNhjQGbTfjxGZIeOEP7tBgWYX05Tcd6CgE02WdTJnh5b8kMZJ/+bnQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/types": "8.72.1", + "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/@typescript-eslint/visitor-keys/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/@vitejs/plugin-react": { + "version": "4.7.0", + "resolved": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-4.7.0.tgz", + "integrity": "sha512-gUu9hwfWvvEDBBmgtAowQCojwZmJ5mcLn3aufeCsitijs3+f2NsrPtlAWIR6OPiqljl96GVCUbLe0HyqIpVaoA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/core": "^7.28.0", + "@babel/plugin-transform-react-jsx-self": "^7.27.1", + "@babel/plugin-transform-react-jsx-source": "^7.27.1", + "@rolldown/pluginutils": "1.0.0-beta.27", + "@types/babel__core": "^7.20.5", + "react-refresh": "^0.17.0" + }, + "engines": { + "node": "^14.18.0 || >=16.0.0" + }, + "peerDependencies": { + "vite": "^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0" + } + }, + "node_modules/@vitest/expect": { + "version": "4.1.12", + "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-4.1.12.tgz", + "integrity": "sha512-vFlTt+YEu9WBpNjdGayNmlMVzrWPi1+sv853/7t2FU7hpO5gAFBKHzQmkCq5Xjpr+evegF2994LQT3hF3mRlqQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@standard-schema/spec": "^1.1.0", + "@types/chai": "^5.2.2", + "@vitest/spy": "4.1.12", + "@vitest/utils": "4.1.12", + "chai": "^6.2.2", + "tinyrainbow": "^3.1.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@vitest/mocker": { + "version": "4.1.12", + "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-4.1.12.tgz", + "integrity": "sha512-fKShNpKZzupWZuY0z7egydvL0sqW4INEZBEExMBMAa6izlENEVHwoXgdaTCaBZ5fwlr4xf2o1wXC83n9RpO+NA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vitest/spy": "4.1.12", + "estree-walker": "^3.0.3", + "magic-string": "^0.30.21" + }, + "funding": { + "url": "https://opencollective.com/vitest" + }, + "peerDependencies": { + "msw": "^2.4.9", + "vite": "^6.0.0 || ^7.0.0 || ^8.0.0" + }, + "peerDependenciesMeta": { + "msw": { + "optional": true + }, + "vite": { + "optional": true + } + } + }, + "node_modules/@vitest/pretty-format": { + "version": "4.1.12", + "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-4.1.12.tgz", + "integrity": "sha512-XW9O8+Mxx4VpCtkYdMJLZQQwsVryP9wk7cPKDxtXFfwSak6yRh5+2fep/Y0XF/ElBvJHq8bcYdi6aeuai0opZA==", + "dev": true, + "license": "MIT", + "dependencies": { + "tinyrainbow": "^3.1.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@vitest/runner": { + "version": "4.1.12", + "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-4.1.12.tgz", + "integrity": "sha512-NKlVKCr5QnCe8jijdMnmkpHHU+WTqiLFR6G0pHji9uRjXK9xJl1k1nTw6F3pOOj2PDcsDt2GKQMI7wIsaT491w==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vitest/utils": "4.1.12", + "pathe": "^2.0.3" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@vitest/snapshot": { + "version": "4.1.12", + "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-4.1.12.tgz", + "integrity": "sha512-ko1y1Qgb/slzQ9mr+b89Cuqud8WG1TKtsPD8r7ZUBdvVOGt85Af2HwCqHujrhwJq95hs/9RM7fcAPg57o1vlzw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vitest/pretty-format": "4.1.12", + "@vitest/utils": "4.1.12", + "magic-string": "^0.30.21", + "pathe": "^2.0.3" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@vitest/spy": { + "version": "4.1.12", + "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-4.1.12.tgz", + "integrity": "sha512-RGq9x4JNGNTZHEJxvN0oSiJjeSCExm0n2gZKKJZHY9cX5AVA6M7VJILBT3ZJ/tJ/0J9uWT7fETV9/btoi//vSg==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@vitest/utils": { + "version": "4.1.12", + "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-4.1.12.tgz", + "integrity": "sha512-Q3awXrwOfEV+qc3WmO5ONyE0yO7Q1gQ9/oyHxGLZ/pl7N3NO/ZztqQwKLuwMkV+CA1JYSIeO3gkHnRDIo4AVaA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vitest/pretty-format": "4.1.12", + "convert-source-map": "^2.0.0", + "tinyrainbow": "^3.1.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/acorn": { + "version": "8.19.0", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.19.0.tgz", + "integrity": "sha512-oJlA3XiRm7Cyk6qFD2Jn8ak9B7jSy0qy00ADO3+8dpT0LSjFihQYv4C02LFCSYJV3Q37xYwwRy5m+IpIiUzqWw==", + "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/ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "dev": true, + "license": "MIT", + "peer": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dev": true, + "license": "MIT", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/argparse": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", + "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==", + "dev": true, + "license": "Python-2.0" + }, + "node_modules/aria-query": { + "version": "5.3.0", + "resolved": "https://registry.npmjs.org/aria-query/-/aria-query-5.3.0.tgz", + "integrity": "sha512-b0P0sZPKtyu8HkeRAfCq0IfURZK+SuwMjY1UXGBU27wpAiTwQAIlq56IbIO+ytk/JjS1fMR14ee5WBBfKi5J6A==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "dequal": "^2.0.3" + } + }, + "node_modules/assertion-error": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz", + "integrity": "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + } + }, + "node_modules/balanced-match": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz", + "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==", + "dev": true, + "license": "MIT" + }, + "node_modules/baseline-browser-mapping": { + "version": "2.11.34", + "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.11.34.tgz", + "integrity": "sha512-Aqr8mA1kIvyJ3UY5YAY7ib8LSo1DmDMbMnVqGPtsKW1LxaFQFwn9Eb3yvq2fUKJsRvaXjnAV7R5osqETapzNiA==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "baseline-browser-mapping": "dist/cli.cjs" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/bidi-js": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/bidi-js/-/bidi-js-1.1.0.tgz", + "integrity": "sha512-fX1Onk0tdVPC7obPWB5EbJ1z7NVhLq4m2xZLq2YXBkxzMXIGRpNMU88n0EPgWseKl12J7zXs7qrDxPK4sRs2fg==", + "dev": true, + "license": "MIT", + "dependencies": { + "require-from-string": "^2.0.2" + } + }, + "node_modules/brace-expansion": { + "version": "1.1.21", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.21.tgz", + "integrity": "sha512-9zeA+KLZNNzglF2TPKRQEDyx6Yby7daAkuy8MiPzpXPsYDWi/DRM8jmwUDxokQjYqBpv5DgPiwD4h4ZZSy1Ujw==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^1.0.0", + "concat-map": "0.0.1" + } + }, + "node_modules/browserslist": { + "version": "4.29.5", + "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.29.5.tgz", + "integrity": "sha512-khTmKu5NGYTotqcYo8Bew2k4RAE9PuXRSFRXG2lQBrCEQHyeQ/vX6gKMxfokwywBsLiXZMnHsmWMG1pnO8J7uQ==", + "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.33", + "caniuse-lite": "^1.0.30001819", + "electron-to-chromium": "^1.5.464", + "node-releases": "^2.0.60", + "update-browserslist-db": "^1.3.4" + }, + "bin": { + "browserslist": "cli.js" + }, + "engines": { + "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7" + } + }, + "node_modules/callsites": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz", + "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/caniuse-lite": { + "version": "1.0.30001820", + "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001820.tgz", + "integrity": "sha512-gfWD6MxqVCqAOwmODfZf7DchWvlrA+SRdNX7ceLfg3xRqe5ssjjpF7EgslC/0tiLiNTajdaNN/q8c/5u/7Gz8w==", + "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/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "dev": true, + "license": "MIT" + }, + "node_modules/concat-map": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", + "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==", + "dev": true, + "license": "MIT" + }, + "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/css-tree": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/css-tree/-/css-tree-3.2.1.tgz", + "integrity": "sha512-X7sjQzceUhu1u7Y/ylrRZFU2FS6LRiFVp6rKLPg23y3x3c3DOKAwuXGDp+PAGjh6CSnCjYeAul8pcT8bAl+lSA==", + "dev": true, + "license": "MIT", + "dependencies": { + "mdn-data": "2.27.1", + "source-map-js": "^1.2.1" + }, + "engines": { + "node": "^10 || ^12.20.0 || ^14.13.0 || >=15.0.0" + } + }, + "node_modules/css.escape": { + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/css.escape/-/css.escape-1.5.1.tgz", + "integrity": "sha512-YUifsXXuknHlUsmlgyY0PKzgPOr7/FjCePfHNt0jxm83wHZi44VDMQ7/fGNkjY3/jV1MC+1CmZbaHzugyeRtpg==", + "dev": true, + "license": "MIT" + }, + "node_modules/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/data-urls": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/data-urls/-/data-urls-7.0.0.tgz", + "integrity": "sha512-23XHcCF+coGYevirZceTVD7NdJOqVn+49IHyxgszm+JIiHLoB2TkmPtsYkNWT1pvRSGkc35L6NHs0yHkN2SumA==", + "dev": true, + "license": "MIT", + "dependencies": { + "whatwg-mimetype": "^5.0.0", + "whatwg-url": "^16.0.0" + }, + "engines": { + "node": "^20.19.0 || ^22.12.0 || >=24.0.0" + } + }, + "node_modules/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": { + "version": "10.6.0", + "resolved": "https://registry.npmjs.org/decimal.js/-/decimal.js-10.6.0.tgz", + "integrity": "sha512-YpgQiITW3JXGntzdUmyUR1V812Hn8T1YVXhCu+wO3OpS4eU9l4YdD3qjyiKdV6mvV29zapkMeD390UVEf2lkUg==", + "dev": true, + "license": "MIT" + }, + "node_modules/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/dequal": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/dequal/-/dequal-2.0.3.tgz", + "integrity": "sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/detect-libc": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz", + "integrity": "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=8" + } + }, + "node_modules/dom-accessibility-api": { + "version": "0.5.16", + "resolved": "https://registry.npmjs.org/dom-accessibility-api/-/dom-accessibility-api-0.5.16.tgz", + "integrity": "sha512-X7BJ2yElsnOJ30pZF4uIIDfBEVgF4XEBxL9Bxhy6dnrm5hkzqmsWHGTiHqRiITNhMyFLyAiWndIJP7Z1NTteDg==", + "dev": true, + "license": "MIT", + "peer": true + }, + "node_modules/electron-to-chromium": { + "version": "1.5.472", + "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.472.tgz", + "integrity": "sha512-s4+nfT29b0FKpVKoaIxl2pWsoNcn7A/nMPSrxayw4T3BsmPeV2lF9Y06BsAQeMGhCTQ4nYJ5XST7jkqe4ZEqFw==", + "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/entities": { + "version": "9.0.0", + "resolved": "https://registry.npmjs.org/entities/-/entities-9.0.0.tgz", + "integrity": "sha512-oJFNDJg3kTPwAD1cNn2+WmUq4wFoo09npc3Ydf1D7ED4smRiWrsKnaLxykrTWgyGEcusc87P5dxlAleol9kpkg==", + "dev": true, + "license": "BSD-2-Clause", + "engines": { + "node": ">=20.19.0" + }, + "funding": { + "url": "https://github.com/fb55/entities?sponsor=1" + } + }, + "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/esbuild": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.12.tgz", + "integrity": "sha512-bbPBYYrtZbkt6Os6FiTLCTFxvq4tt3JKall1vRwshA3fdVztsLAatFaZobhkBC8/BrPetoa0oksYoKXoG4ryJg==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "bin": { + "esbuild": "bin/esbuild" + }, + "engines": { + "node": ">=18" + }, + "optionalDependencies": { + "@esbuild/aix-ppc64": "0.25.12", + "@esbuild/android-arm": "0.25.12", + "@esbuild/android-arm64": "0.25.12", + "@esbuild/android-x64": "0.25.12", + "@esbuild/darwin-arm64": "0.25.12", + "@esbuild/darwin-x64": "0.25.12", + "@esbuild/freebsd-arm64": "0.25.12", + "@esbuild/freebsd-x64": "0.25.12", + "@esbuild/linux-arm": "0.25.12", + "@esbuild/linux-arm64": "0.25.12", + "@esbuild/linux-ia32": "0.25.12", + "@esbuild/linux-loong64": "0.25.12", + "@esbuild/linux-mips64el": "0.25.12", + "@esbuild/linux-ppc64": "0.25.12", + "@esbuild/linux-riscv64": "0.25.12", + "@esbuild/linux-s390x": "0.25.12", + "@esbuild/linux-x64": "0.25.12", + "@esbuild/netbsd-arm64": "0.25.12", + "@esbuild/netbsd-x64": "0.25.12", + "@esbuild/openbsd-arm64": "0.25.12", + "@esbuild/openbsd-x64": "0.25.12", + "@esbuild/openharmony-arm64": "0.25.12", + "@esbuild/sunos-x64": "0.25.12", + "@esbuild/win32-arm64": "0.25.12", + "@esbuild/win32-ia32": "0.25.12", + "@esbuild/win32-x64": "0.25.12" + } + }, + "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": "9.39.5", + "resolved": "https://registry.npmjs.org/eslint/-/eslint-9.39.5.tgz", + "integrity": "sha512-DgZS62aPLXKlnxILS/AYCoRvHaZeXceIzlXPkkGGzJWSow1aEk0lbTlxUSlyjC8jcaKxAdOnTDz+o1JFSBsyjw==", + "deprecated": "This version is no longer supported. Please see https://eslint.org/version-support for other options.", + "dev": true, + "license": "MIT", + "dependencies": { + "@eslint-community/eslint-utils": "^4.8.0", + "@eslint-community/regexpp": "^4.12.1", + "@eslint/config-array": "^0.21.2", + "@eslint/config-helpers": "^0.4.2", + "@eslint/core": "^0.17.0", + "@eslint/eslintrc": "^3.3.6", + "@eslint/js": "9.39.5", + "@eslint/plugin-kit": "^0.4.1", + "@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", + "chalk": "^4.0.0", + "cross-spawn": "^7.0.6", + "debug": "^4.3.2", + "escape-string-regexp": "^4.0.0", + "eslint-scope": "^8.4.0", + "eslint-visitor-keys": "^4.2.1", + "espree": "^10.4.0", + "esquery": "^1.5.0", + "esutils": "^2.0.2", + "fast-deep-equal": "^3.1.3", + "file-entry-cache": "^8.0.0", + "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", + "lodash.merge": "^4.6.2", + "minimatch": "^3.1.5", + "natural-compare": "^1.4.0", + "optionator": "^0.9.3" + }, + "bin": { + "eslint": "bin/eslint.js" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "url": "https://eslint.org/donate" + }, + "peerDependencies": { + "jiti": "*" + }, + "peerDependenciesMeta": { + "jiti": { + "optional": true + } + } + }, + "node_modules/eslint-plugin-react-hooks": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/eslint-plugin-react-hooks/-/eslint-plugin-react-hooks-5.2.0.tgz", + "integrity": "sha512-+f15FfK64YQwZdJNELETdn5ibXEUQmW1DZL6KXhNnc2heoy/sg9VJJeT7n8TlMWouzWqSWavFkIhHyIbIAEapg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "peerDependencies": { + "eslint": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-0 || ^9.0.0" + } + }, + "node_modules/eslint-plugin-react-refresh": { + "version": "0.4.26", + "resolved": "https://registry.npmjs.org/eslint-plugin-react-refresh/-/eslint-plugin-react-refresh-0.4.26.tgz", + "integrity": "sha512-1RETEylht2O6FM/MvgnyvT+8K21wLqDNg4qD51Zj3guhjt433XbnnkVttHMyaVyAFD03QSV4LPS5iE3VQmO7XQ==", + "dev": true, + "license": "MIT", + "peerDependencies": { + "eslint": ">=8.40" + } + }, + "node_modules/eslint-scope": { + "version": "8.4.0", + "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-8.4.0.tgz", + "integrity": "sha512-sNXOfKCn74rt8RICKMvJS7XKV/Xk9kA7DyJr8mJik3S7Cwgy3qlkkmyS2uQB3jiJg6VNdZd/pDBJu0nvG2NlTg==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "esrecurse": "^4.3.0", + "estraverse": "^5.2.0" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/eslint-visitor-keys": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-4.2.1.tgz", + "integrity": "sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/espree": { + "version": "10.4.0", + "resolved": "https://registry.npmjs.org/espree/-/espree-10.4.0.tgz", + "integrity": "sha512-j6PAQ2uUr79PZhBjP5C5fhl8e39FmRnOjsD5lGnWrFU8i2G776tBK7+nP8KuQUTTyAZUwfQqXAgrVH5MbH9CYQ==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "acorn": "^8.15.0", + "acorn-jsx": "^5.3.2", + "eslint-visitor-keys": "^4.2.1" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "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/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": "8.0.0", + "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-8.0.0.tgz", + "integrity": "sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "flat-cache": "^4.0.0" + }, + "engines": { + "node": ">=16.0.0" + } + }, + "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": "4.0.1", + "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-4.0.1.tgz", + "integrity": "sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==", + "dev": true, + "license": "MIT", + "dependencies": { + "flatted": "^3.2.9", + "keyv": "^4.5.4" + }, + "engines": { + "node": ">=16" + } + }, + "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/framer-motion": { + "version": "14.8.0", + "resolved": "https://registry.npmjs.org/framer-motion/-/framer-motion-14.8.0.tgz", + "integrity": "sha512-PQsSx+UlaKiyPhADjVT5wALBErJJdbMeKQS4gQx6ibOrSNni7qjqfTKMvf6YHGG8pQWi6njs7AqrIG7R2hbnxA==", + "license": "MIT", + "dependencies": { + "motion-dom": "14.8.0", + "motion-utils": "14.7.0", + "tslib": "^2.4.0" + }, + "peerDependencies": { + "react": "^18.0.0 || ^19.0.0", + "react-dom": "^18.0.0 || ^19.0.0", + "remix": "^3.1.0" + }, + "peerDependenciesMeta": { + "react": { + "optional": true + }, + "react-dom": { + "optional": true + }, + "remix": { + "optional": true + } + } + }, + "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/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": "16.5.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-16.5.0.tgz", + "integrity": "sha512-c/c15i26VrJ4IRt5Z89DnIzCGDn9EcebibhAOjw5ibqEHsE1wLUgkPn9RDmNcUKyU87GeaL633nyJ+pplFR2ZQ==", + "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/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/html-encoding-sniffer": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/html-encoding-sniffer/-/html-encoding-sniffer-6.0.0.tgz", + "integrity": "sha512-CV9TW3Y3f8/wT0BRFc1/KAVQ3TUHiXmaAb6VW9vtiMFf7SLoMd1PdAc4W3KFOFETBJUb90KatHqlsZMWV+R9Gg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@exodus/bytes": "^1.6.0" + }, + "engines": { + "node": "^20.19.0 || ^22.12.0 || >=24.0.0" + } + }, + "node_modules/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/import-fresh": { + "version": "3.3.1", + "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz", + "integrity": "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "parent-module": "^1.0.0", + "resolve-from": "^4.0.0" + }, + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "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/indent-string": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/indent-string/-/indent-string-4.0.0.tgz", + "integrity": "sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/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/is-potential-custom-element-name": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-potential-custom-element-name/-/is-potential-custom-element-name-1.0.1.tgz", + "integrity": "sha512-bCYeRA2rVibKZd+s2625gGnGF/t7DSqDs4dP7CrLA1m7jKWz6pps0LpYLJN8Q64HtmPKJ1hrN3nzPNKFEKOUiQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/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/js-yaml": { + "version": "4.3.2", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.3.2.tgz", + "integrity": "sha512-SFNOvSJ+Dgf/9An904Yx+CgSlIPCkIpao4qo51lpee25TIRejdH3rhR4EZMGoNx3/TP3O+wzWuiTFl4sqbltzA==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/puzrin" + }, + { + "type": "github", + "url": "https://github.com/sponsors/nodeca" + } + ], + "license": "MIT", + "dependencies": { + "argparse": "^2.0.1" + }, + "bin": { + "js-yaml": "bin/js-yaml.js" + } + }, + "node_modules/jsdom": { + "version": "29.1.1", + "resolved": "https://registry.npmjs.org/jsdom/-/jsdom-29.1.1.tgz", + "integrity": "sha512-ECi4Fi2f7BdJtUKTflYRTiaMxIB0O6zfR1fX0GXpUrf6flp8QIYn1UT20YQqdSOfk2dfkCwS8LAFoJDEppNK5Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "@asamuzakjp/css-color": "^5.1.11", + "@asamuzakjp/dom-selector": "^7.1.1", + "@bramus/specificity": "^2.4.2", + "@csstools/css-syntax-patches-for-csstree": "^1.1.3", + "@exodus/bytes": "^1.15.0", + "css-tree": "^3.2.1", + "data-urls": "^7.0.0", + "decimal.js": "^10.6.0", + "html-encoding-sniffer": "^6.0.0", + "is-potential-custom-element-name": "^1.0.1", + "lru-cache": "^11.3.5", + "parse5": "^8.0.1", + "saxes": "^6.0.0", + "symbol-tree": "^3.2.4", + "tough-cookie": "^6.0.1", + "undici": "^7.25.0", + "w3c-xmlserializer": "^5.0.0", + "webidl-conversions": "^8.0.1", + "whatwg-mimetype": "^5.0.0", + "whatwg-url": "^16.0.1", + "xml-name-validator": "^5.0.0" + }, + "engines": { + "node": "^20.19.0 || ^22.13.0 || >=24.0.0" + }, + "peerDependencies": { + "canvas": "^3.0.0" + }, + "peerDependenciesMeta": { + "canvas": { + "optional": true + } + } + }, + "node_modules/jsdom/node_modules/lru-cache": { + "version": "11.5.3", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.5.3.tgz", + "integrity": "sha512-U4N8FgzmWxc8k1VH8Kr6lQg18U7Fjvby6wXHVRX/ZZ7IwWbRMgrRbP0Wrb5q5NVinryp4SQampHKdvtecItxUg==", + "dev": true, + "license": "BlueOak-1.0.0", + "engines": { + "node": "20 || >=22" + } + }, + "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-buffer": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz", + "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==", + "dev": true, + "license": "MIT" + }, + "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": "4.5.4", + "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz", + "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==", + "dev": true, + "license": "MIT", + "dependencies": { + "json-buffer": "3.0.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/lodash.merge": { + "version": "4.6.2", + "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz", + "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==", + "dev": true, + "license": "MIT" + }, + "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.65.0", + "resolved": "https://registry.npmjs.org/lucide-react/-/lucide-react-1.65.0.tgz", + "integrity": "sha512-roSdtzudEY39i2hn5LLjA8toYfhF2z4S10WSqZF4ubXpHlOmNTvaxMxZLdJfQDi6pEifQWX+cRmYihKSsvAxfA==", + "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/lz-string": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/lz-string/-/lz-string-1.5.0.tgz", + "integrity": "sha512-h5bgJWpxJNswbU7qCrV0tIKQCaS3blPDrqKWx+QxzuzL1zGUzij9XCWLrSLsJPu5t+eWA/ycetzYAO5IOMcWAQ==", + "dev": true, + "license": "MIT", + "peer": true, + "bin": { + "lz-string": "bin/bin.js" + } + }, + "node_modules/magic-string": { + "version": "0.30.21", + "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz", + "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/sourcemap-codec": "^1.5.5" + } + }, + "node_modules/mdn-data": { + "version": "2.27.1", + "resolved": "https://registry.npmjs.org/mdn-data/-/mdn-data-2.27.1.tgz", + "integrity": "sha512-9Yubnt3e8A0OKwxYSXyhLymGW4sCufcLG6VdiDdUGVkPhpqLxlvP5vl1983gQjJl3tqbrM731mjaZaP68AgosQ==", + "dev": true, + "license": "CC0-1.0" + }, + "node_modules/min-indent": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/min-indent/-/min-indent-1.0.1.tgz", + "integrity": "sha512-I9jwMn07Sy/IwOj3zVkVik2JTvgpaykDZEigL6Rx6N9LbMywwUSMtxET+7lVoDLLd3O3IXwJwvuuns8UB/HeAg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/minimatch": { + "version": "3.1.5", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz", + "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==", + "dev": true, + "license": "ISC", + "dependencies": { + "brace-expansion": "^1.1.7" + }, + "engines": { + "node": "*" + } + }, + "node_modules/motion": { + "version": "14.8.0", + "resolved": "https://registry.npmjs.org/motion/-/motion-14.8.0.tgz", + "integrity": "sha512-4KUxmgq8Lt8o/4/m8WnRicBQ+mJUMHl5Gp00o0R0+uU3NDqLwQX3GuBiqVillZl0NzOrhPuC00c5ydP6lokjmQ==", + "license": "MIT", + "dependencies": { + "framer-motion": "14.8.0", + "tslib": "^2.4.0" + }, + "peerDependencies": { + "react": "^18.0.0 || ^19.0.0", + "react-dom": "^18.0.0 || ^19.0.0", + "remix": "^3.1.0" + }, + "peerDependenciesMeta": { + "react": { + "optional": true + }, + "react-dom": { + "optional": true + }, + "remix": { + "optional": true + } + } + }, + "node_modules/motion-dom": { + "version": "14.8.0", + "resolved": "https://registry.npmjs.org/motion-dom/-/motion-dom-14.8.0.tgz", + "integrity": "sha512-HzA41kvV7BgluM7L/XbW+gHFzDtJUbHnEsrlnIzPS9dqSfoPy9YzL6VKF7ai0TiQcykkkLUqvIxECAdwa9gwAw==", + "license": "MIT", + "dependencies": { + "motion-utils": "14.7.0" + } + }, + "node_modules/motion-utils": { + "version": "14.7.0", + "resolved": "https://registry.npmjs.org/motion-utils/-/motion-utils-14.7.0.tgz", + "integrity": "sha512-woO0/Nb7ys75f94fjvQi/6leiHGvZUYkeHUPEZ3vxsV+9OpEVhkxp01x8MlRwX0zt31EqgXsKDAoBoJLC148Tw==", + "license": "MIT" + }, + "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.20", + "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.20.tgz", + "integrity": "sha512-uKdg2G3GNCKQn9byYOpxbGqrT2fGO5KRt5J/8b3pok8rT6qxGWF6hxMyJiEYtAf+FVyYuD9hRaDqX5uPFYJ4ZQ==", + "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/node-releases": { + "version": "2.0.63", + "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.63.tgz", + "integrity": "sha512-6li2QanLsAXpIH2R6j77MzRyvOyrvdTqlKtO4CgBdHGNvN99ZZfyxszHc5o5+IZBWD5u6Hzwg83JoGXmqZNG9Q==", + "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/parent-module": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz", + "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==", + "dev": true, + "license": "MIT", + "dependencies": { + "callsites": "^3.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/parse5": { + "version": "8.1.0", + "resolved": "https://registry.npmjs.org/parse5/-/parse5-8.1.0.tgz", + "integrity": "sha512-sq3qBFpee5jeocbFbO48VHlGr8sT7mbXS0vxlKN6sottBtJzrOG3998sr0llSZcQAGgfpdmEYAIZE0P9z0dE8w==", + "dev": true, + "license": "MIT", + "dependencies": { + "entities": "^9.0.0" + }, + "funding": { + "url": "https://github.com/inikulin/parse5?sponsor=1" + } + }, + "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/pathe": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz", + "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==", + "dev": true, + "license": "MIT" + }, + "node_modules/picocolors": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz", + "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/postcss": { + "version": "8.5.32", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.32.tgz", + "integrity": "sha512-LJlKCCAUFKOuZxipUdYw1NzIITEsPcgyOG9LkvRJvuKj/bRzbuRY0ARXvL0pWGpsZvn8jku+LMep2eU0seHp8g==", + "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.20", + "picocolors": "^1.1.1", + "source-map-js": "^1.2.2" + }, + "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/pretty-format": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-27.5.1.tgz", + "integrity": "sha512-Qb1gy5OrP5+zDf2Bvnzdl3jsTf1qXVMazbvCoKhtKqVs4/YK4ozX4gKQJJVyNe+cajNPn0KoC0MC3FUmaHWEmQ==", + "dev": true, + "license": "MIT", + "peer": true, + "dependencies": { + "ansi-regex": "^5.0.1", + "ansi-styles": "^5.0.0", + "react-is": "^17.0.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/pretty-format/node_modules/ansi-styles": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-5.2.0.tgz", + "integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==", + "dev": true, + "license": "MIT", + "peer": true, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/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/react": { + "version": "19.3.1", + "resolved": "https://registry.npmjs.org/react/-/react-19.3.1.tgz", + "integrity": "sha512-QNhWdt7nrgVWWQG58QuGsAR3jv3Hbe4mb4vz7w2csnHavciZJgda1CPNaldF6eVxv90ud3jUXpKlHL69gO38yw==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/react-dom": { + "version": "19.3.1", + "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.3.1.tgz", + "integrity": "sha512-Y0bARz53lhEC1NMCASs0/j+faB/zqt3R8hpvg1e8+61ZVJ4UL0UdC4cBbXfZMcIuhrfgeILTLe+ZeBCavQPtKQ==", + "license": "MIT", + "dependencies": { + "scheduler": "^0.28.0" + }, + "peerDependencies": { + "react": "^19.3.1" + } + }, + "node_modules/react-is": { + "version": "17.0.2", + "resolved": "https://registry.npmjs.org/react-is/-/react-is-17.0.2.tgz", + "integrity": "sha512-w2GsyukL62IJnlaff/nRegPQR94C/XXamvMWmSHRJ4y7Ts/4ocGRmTHvOs8PSE6pB3dWOrD/nueuU5sduBsQ4w==", + "dev": true, + "license": "MIT", + "peer": true + }, + "node_modules/react-refresh": { + "version": "0.17.0", + "resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.17.0.tgz", + "integrity": "sha512-z6F7K9bV85EfseRCp2bzrpyQ0Gkw1uLoCel9XBVWPg/TjRj94SkJzUTGfOa4bs7iJvBWtQG0Wq7wnI0syw3EBQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/redent": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/redent/-/redent-3.0.0.tgz", + "integrity": "sha512-6tDA8g98We0zd0GvVeMT9arEOnTw9qM03L9cJXaCjrip1OO764RDBLBfrB4cwzNGDj5OA5ioymC9GkizgWJDUg==", + "dev": true, + "license": "MIT", + "dependencies": { + "indent-string": "^4.0.0", + "strip-indent": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/require-from-string": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz", + "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/resolve-from": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz", + "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/rollup": { + "version": "4.67.4", + "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.67.4.tgz", + "integrity": "sha512-Lsv3oKcz5jgOQJej/p7nfwbVEdAbDT+z6OPf/SCdI+nF+q2ENp0pTKT35ZwXAmH8g45mfrIiJeEyAqKYSYoL9Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/estree": "^1.0.10" + }, + "bin": { + "rollup": "dist/bin/rollup" + }, + "engines": { + "node": ">=18.0.0", + "npm": ">=8.0.0" + }, + "optionalDependencies": { + "@napi-rs/lzma-linux-x64-gnu": "1.5.1", + "@rollup/rollup-android-arm-eabi": "4.67.4", + "@rollup/rollup-android-arm64": "4.67.4", + "@rollup/rollup-android-x64": "4.67.4", + "@rollup/rollup-darwin-arm64": "4.67.4", + "@rollup/rollup-darwin-x64": "4.67.4", + "@rollup/rollup-freebsd-arm64": "4.67.4", + "@rollup/rollup-freebsd-x64": "4.67.4", + "@rollup/rollup-linux-arm-gnueabihf": "4.67.4", + "@rollup/rollup-linux-arm-musleabihf": "4.67.4", + "@rollup/rollup-linux-arm64-gnu": "4.67.4", + "@rollup/rollup-linux-arm64-musl": "4.67.4", + "@rollup/rollup-linux-loong64-gnu": "4.67.4", + "@rollup/rollup-linux-loong64-musl": "4.67.4", + "@rollup/rollup-linux-ppc64-gnu": "4.67.4", + "@rollup/rollup-linux-ppc64-musl": "4.67.4", + "@rollup/rollup-linux-riscv64-gnu": "4.67.4", + "@rollup/rollup-linux-riscv64-musl": "4.67.4", + "@rollup/rollup-linux-s390x-gnu": "4.67.4", + "@rollup/rollup-linux-x64-gnu": "4.67.4", + "@rollup/rollup-linux-x64-musl": "4.67.4", + "@rollup/rollup-openbsd-x64": "4.67.4", + "@rollup/rollup-openharmony-arm64": "4.67.4", + "@rollup/rollup-win32-arm64-msvc": "4.67.4", + "@rollup/rollup-win32-ia32-msvc": "4.67.4", + "@rollup/rollup-win32-x64-gnu": "4.67.4", + "@rollup/rollup-win32-x64-msvc": "4.67.4", + "fsevents": "~2.3.2" + } + }, + "node_modules/saxes": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/saxes/-/saxes-6.0.0.tgz", + "integrity": "sha512-xAg7SOnEhrm5zI3puOOKyy1OMcMlIJZYNJY7xLBwSze0UjhPLnWfj2GF2EpT0jmzaJKIWKHLsaSSajf35bcYnA==", + "dev": true, + "license": "ISC", + "dependencies": { + "xmlchars": "^2.2.0" + }, + "engines": { + "node": ">=v12.22.7" + } + }, + "node_modules/scheduler": { + "version": "0.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/siginfo": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/siginfo/-/siginfo-2.0.0.tgz", + "integrity": "sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==", + "dev": true, + "license": "ISC" + }, + "node_modules/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/stackback": { + "version": "0.0.2", + "resolved": "https://registry.npmjs.org/stackback/-/stackback-0.0.2.tgz", + "integrity": "sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==", + "dev": true, + "license": "MIT" + }, + "node_modules/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/strip-indent": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/strip-indent/-/strip-indent-3.0.0.tgz", + "integrity": "sha512-laJTa3Jb+VQpaC6DseHhF7dXVqHTfJPCRDaEbid/drOhgitgYku/letMUqOXFoWV0zIIUbjpdH2t+tYj4bQMRQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "min-indent": "^1.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/strip-json-comments": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz", + "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dev": true, + "license": "MIT", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/symbol-tree": { + "version": "3.2.4", + "resolved": "https://registry.npmjs.org/symbol-tree/-/symbol-tree-3.2.4.tgz", + "integrity": "sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw==", + "dev": true, + "license": "MIT" + }, + "node_modules/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/tinybench": { + "version": "2.9.0", + "resolved": "https://registry.npmjs.org/tinybench/-/tinybench-2.9.0.tgz", + "integrity": "sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==", + "dev": true, + "license": "MIT" + }, + "node_modules/tinyexec": { + "version": "1.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/tinyrainbow": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-3.2.0.tgz", + "integrity": "sha512-LgO3D9yZJjApUiuUfl9iFAwrtaX4+lok3wJIqttGoKCHlWUqHqbQpnxCf82L8FjgKsh4iGo78hqJwgL8F6To2A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/tldts": { + "version": "7.4.19", + "resolved": "https://registry.npmjs.org/tldts/-/tldts-7.4.19.tgz", + "integrity": "sha512-48dH6aSpQnpbzDUc4vIQZ1VjB8tkK+e8c1yx05/SZK+rkssgjEOlxDd/yU8/a4vGYQ9vRgJr9dwMq9TJ0b3X2Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "tldts-core": "^7.4.19" + }, + "bin": { + "tldts": "bin/cli.js" + } + }, + "node_modules/tldts-core": { + "version": "7.4.20", + "resolved": "https://registry.npmjs.org/tldts-core/-/tldts-core-7.4.20.tgz", + "integrity": "sha512-C630TWXZCZmLq0F2bW4QqwnaaxCQ/svpAqvJwnC4JvgEM5ohhBnGsEzTLSOXcN+xjz+kEaHS5uoWIw2klnqd0A==", + "dev": true, + "license": "MIT" + }, + "node_modules/tough-cookie": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-6.0.2.tgz", + "integrity": "sha512-exgYmnmL/sJpR3upZfXG5PoatXQii55xAiXGXzY+sROLZ/Y+SLcp9PgJNI9Vz37HpQ74WvDcLT8eqm+kV3FzrA==", + "dev": true, + "license": "BSD-3-Clause", + "dependencies": { + "tldts": "^7.0.5" + }, + "engines": { + "node": ">=16" + } + }, + "node_modules/tr46": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/tr46/-/tr46-6.0.0.tgz", + "integrity": "sha512-bLVMLPtstlZ4iMQHpFHTR7GAGj2jxi8Dg0s2h2MafAE4uSWF98FC/3MomU51iQAMf8/qDUbKWf5GxuvvVcXEhw==", + "dev": true, + "license": "MIT", + "dependencies": { + "punycode": "^2.3.1" + }, + "engines": { + "node": ">=20" + } + }, + "node_modules/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.9.1", + "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.9.1.tgz", + "integrity": "sha512-a4Ux9VKuIMHsOS7ENbEq6hK2ZGYIT27Rtl0E4eD9KqwxhKiQeMZE/9xb3IdYwWaSOyIBQLExhQgXDTYoiCxnWA==", + "license": "0BSD" + }, + "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": "5.8.3", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.8.3.tgz", + "integrity": "sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=14.17" + } + }, + "node_modules/typescript-eslint": { + "version": "8.72.1", + "resolved": "https://registry.npmjs.org/typescript-eslint/-/typescript-eslint-8.72.1.tgz", + "integrity": "sha512-3Li9FfPmQp45nxEtFD1ZCrYFI3cYK5kpyNtmm1H7lMagm8u9sy6PTjy3ytwQZs7KNukOyKFHAZ6z6GjYFeaeXw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/eslint-plugin": "8.72.1", + "@typescript-eslint/parser": "8.72.1", + "@typescript-eslint/typescript-estree": "8.72.1", + "@typescript-eslint/utils": "8.72.1" + }, + "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": { + "version": "7.30.1", + "resolved": "https://registry.npmjs.org/undici/-/undici-7.30.1.tgz", + "integrity": "sha512-03KrMbjIFDWQR5RNPrSw3bd1r12JpyFQl9/yxjUbJtqkjmllqC5lFjZh6ujeuJCKr8EOQvRW872Oy/az+nLYxg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=20.18.1" + } + }, + "node_modules/update-browserslist-db": { + "version": "1.3.4", + "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.3.4.tgz", + "integrity": "sha512-t8wonIOdQyOjtPd2VktlBu6QjTVTks6v8bSi7kd0r2Vll8TK1JYDZtRRdbmCHOAMphkZgrzK+L+vXK4pyZ8t4A==", + "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/vite": { + "version": "6.4.5", + "resolved": "https://registry.npmjs.org/vite/-/vite-6.4.5.tgz", + "integrity": "sha512-4enwjFfi4IwtEh0w+jPzpLVOFQiPHmmzPxcHXQOyEur47o6u0jE573DmGpjA+7irXoMLYRZD5ZaFUEneS3abPg==", + "dev": true, + "license": "MIT", + "dependencies": { + "esbuild": "^0.25.0", + "fdir": "^6.4.4", + "picomatch": "^4.0.2", + "postcss": "^8.5.3", + "rollup": "^4.34.9", + "tinyglobby": "^0.2.13" + }, + "bin": { + "vite": "bin/vite.js" + }, + "engines": { + "node": "^18.0.0 || ^20.0.0 || >=22.0.0" + }, + "funding": { + "url": "https://github.com/vitejs/vite?sponsor=1" + }, + "optionalDependencies": { + "fsevents": "~2.3.3" + }, + "peerDependencies": { + "@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0", + "jiti": ">=1.21.0", + "less": "*", + "lightningcss": "^1.21.0", + "sass": "*", + "sass-embedded": "*", + "stylus": "*", + "sugarss": "*", + "terser": "^5.16.0", + "tsx": "^4.8.1", + "yaml": "^2.4.2" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + }, + "jiti": { + "optional": true + }, + "less": { + "optional": true + }, + "lightningcss": { + "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/vitest": { + "version": "4.1.12", + "resolved": "https://registry.npmjs.org/vitest/-/vitest-4.1.12.tgz", + "integrity": "sha512-5eWdz2yb3ajxWF3C8C4TjkXl7FGm3n2E/VlazALrQHzK7nYMSGFnCZto0bbPNl77AwkOZVLk0YnBAejUu0NiWA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vitest/expect": "4.1.12", + "@vitest/mocker": "4.1.12", + "@vitest/pretty-format": "4.1.12", + "@vitest/runner": "4.1.12", + "@vitest/snapshot": "4.1.12", + "@vitest/spy": "4.1.12", + "@vitest/utils": "4.1.12", + "es-module-lexer": "^2.0.0", + "expect-type": "^1.3.0", + "magic-string": "^0.30.21", + "obug": "^2.1.1", + "pathe": "^2.0.3", + "picomatch": "^4.0.3", + "std-env": "^4.0.0-rc.1", + "tinybench": "^2.9.0", + "tinyexec": "^1.0.2", + "tinyglobby": "^0.2.15", + "tinyrainbow": "^3.1.0", + "vite": "^6.0.0 || ^7.0.0 || ^8.0.0", + "why-is-node-running": "^2.3.0" + }, + "bin": { + "vitest": "vitest.mjs" + }, + "engines": { + "node": "^20.0.0 || ^22.0.0 || >=24.0.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + }, + "peerDependencies": { + "@edge-runtime/vm": "*", + "@opentelemetry/api": "^1.9.0", + "@types/node": "^20.0.0 || ^22.0.0 || >=24.0.0", + "@vitest/browser-playwright": "4.1.12", + "@vitest/browser-preview": "4.1.12", + "@vitest/browser-webdriverio": "^4.1.11", + "@vitest/coverage-istanbul": "4.1.12", + "@vitest/coverage-v8": "4.1.12", + "@vitest/ui": "4.1.12", + "happy-dom": "*", + "jsdom": "*", + "vite": "^6.0.0 || ^7.0.0 || ^8.0.0" + }, + "peerDependenciesMeta": { + "@edge-runtime/vm": { + "optional": true + }, + "@opentelemetry/api": { + "optional": true + }, + "@types/node": { + "optional": true + }, + "@vitest/browser-playwright": { + "optional": true + }, + "@vitest/browser-preview": { + "optional": true + }, + "@vitest/browser-webdriverio": { + "optional": true + }, + "@vitest/coverage-istanbul": { + "optional": true + }, + "@vitest/coverage-v8": { + "optional": true + }, + "@vitest/ui": { + "optional": true + }, + "happy-dom": { + "optional": true + }, + "jsdom": { + "optional": true + }, + "vite": { + "optional": false + } + } + }, + "node_modules/w3c-xmlserializer": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/w3c-xmlserializer/-/w3c-xmlserializer-5.0.0.tgz", + "integrity": "sha512-o8qghlI8NZHU1lLPrpi2+Uq7abh4GGPpYANlalzWxyWteJOCsr/P+oPBA49TOLu5FTZO4d3F9MnWJfiMo4BkmA==", + "dev": true, + "license": "MIT", + "dependencies": { + "xml-name-validator": "^5.0.0" + }, + "engines": { + "node": ">=18" + } + }, + "node_modules/webidl-conversions": { + "version": "8.0.1", + "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-8.0.1.tgz", + "integrity": "sha512-BMhLD/Sw+GbJC21C/UgyaZX41nPt8bUTg+jWyDeg7e7YN4xOM05YPSIXceACnXVtqyEw/LMClUQMtMZ+PGGpqQ==", + "dev": true, + "license": "BSD-2-Clause", + "engines": { + "node": ">=20" + } + }, + "node_modules/whatwg-mimetype": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/whatwg-mimetype/-/whatwg-mimetype-5.0.0.tgz", + "integrity": "sha512-sXcNcHOC51uPGF0P/D4NVtrkjSU2fNsm9iog4ZvZJsL3rjoDAzXZhkm2MWt1y+PUdggKAYVoMAIYcs78wJ51Cw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=20" + } + }, + "node_modules/whatwg-url": { + "version": "16.0.1", + "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-16.0.1.tgz", + "integrity": "sha512-1to4zXBxmXHV3IiSSEInrreIlu02vUOvrhxJJH5vcxYTBDAx51cqZiKdyTxlecdKNSjj8EcxGBxNf6Vg+945gw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@exodus/bytes": "^1.11.0", + "tr46": "^6.0.0", + "webidl-conversions": "^8.0.1" + }, + "engines": { + "node": "^20.19.0 || ^22.12.0 || >=24.0.0" + } + }, + "node_modules/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": "2.3.0", + "resolved": "https://registry.npmjs.org/why-is-node-running/-/why-is-node-running-2.3.0.tgz", + "integrity": "sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==", + "dev": true, + "license": "MIT", + "dependencies": { + "siginfo": "^2.0.0", + "stackback": "0.0.2" + }, + "bin": { + "why-is-node-running": "cli.js" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/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/xml-name-validator": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/xml-name-validator/-/xml-name-validator-5.0.0.tgz", + "integrity": "sha512-EvGK8EJ3DhaHfbRlETOWAS5pO9MZITeauHKJyb8wyajUfQUenkIg2MvLDTZ4T/TgIcm3HU0TFBgWWboAZ30UHg==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=18" + } + }, + "node_modules/xmlchars": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/xmlchars/-/xmlchars-2.2.0.tgz", + "integrity": "sha512-JZnDKK8B0RCDw84FNdDAIpZK+JuJw+s7Lz8nksI7SIuU3UXJJslUthsi+uWBUYOwPFwW7W7PRLRfUKpxjtjFCw==", + "dev": true, + "license": "MIT" + }, + "node_modules/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" + } + } + } +} diff --git a/desktop/web/package.json b/desktop/web/package.json new file mode 100644 index 0000000..57fedfb --- /dev/null +++ b/desktop/web/package.json @@ -0,0 +1,41 @@ +{ + "name": "open-rag-web", + "private": true, + "version": "0.0.0", + "type": "module", + "scripts": { + "dev": "vite", + "build": "tsc -b && vite build", + "lint": "eslint .", + "preview": "vite preview", + "test": "vitest run" + }, + "dependencies": { + "@fontsource/atkinson-hyperlegible": "5.3.0", + "@fontsource/ibm-plex-mono": "5.3.0", + "@fontsource/lilita-one": "5.3.0", + "lucide-react": "1.65.0", + "motion": "14.8.0", + "react": "^19.1.0", + "react-dom": "^19.1.0" + }, + "devDependencies": { + "@eslint/js": "^9.25.0", + "@tailwindcss/vite": "4.3.3", + "@testing-library/jest-dom": "6.9.1", + "@testing-library/react": "16.3.3", + "@types/react": "^19.1.2", + "@types/react-dom": "^19.1.2", + "@vitejs/plugin-react": "^4.4.1", + "eslint": "^9.25.0", + "eslint-plugin-react-hooks": "^5.2.0", + "eslint-plugin-react-refresh": "^0.4.19", + "globals": "^16.0.0", + "jsdom": "29.1.1", + "tailwindcss": "4.3.3", + "typescript": "~5.8.3", + "typescript-eslint": "^8.30.1", + "vite": "^6.3.5", + "vitest": "4.1.12" + } +} diff --git a/desktop/web/src/App.tsx b/desktop/web/src/App.tsx new file mode 100644 index 0000000..46afc15 --- /dev/null +++ b/desktop/web/src/App.tsx @@ -0,0 +1,239 @@ +import { useCallback, useEffect, useMemo, useState } from "react"; +import { Chat } from "./components/Chat"; +import { ConfirmDialog, NameDialog, type ConfirmRequest, type NameRequest } from "./components/Dialogs"; +import { CategoryPanel, MainHeader, Toast } from "./components/Main"; +import { Chip, Spinner } from "./components/primitives"; +import { EngineScreen, Pick, Welcome } from "./components/Screens"; +import { SectionPanel } from "./components/SectionPanel"; +import { Sidebar } from "./components/Sidebar"; +import { useChat } from "./hooks/useChat"; +import { useEngine } from "./hooks/useEngine"; +import { useLibrary } from "./hooks/useLibrary"; +import { host } from "./lib/host"; +import type { Category, DocumentInfo, Library, Scope, Section } from "./lib/types"; + +const SELECTION_KEY = "openrag.selection"; +const NOTICE_MS = 7000; + +function savedSelection(): Scope | null { + try { + return JSON.parse(localStorage.getItem(SELECTION_KEY) ?? "null") as Scope | null; + } catch { + return null; + } +} + +function exists(library: Library, scope: Scope | null): boolean { + if (!scope) return false; + const items = scope.kind === "section" ? library.sections : library.categories; + return items.some((item) => item.id === scope.id); +} + +export default function App() { + const { engine, api } = useEngine(); + const [notice, setNotice] = useState(null); + const notify = useCallback((message: string) => setNotice(message), []); + const { library, run } = useLibrary(api, notify); + const [selected, setSelected] = useState(savedSelection); + const [nameRequest, setNameRequest] = useState(null); + const [confirm, setConfirm] = useState(null); + const [documents, setDocuments] = useState(null); + + useEffect(() => host.onNotice(notify), [notify]); + useEffect(() => { + if (!notice) return; + const timer = setTimeout(() => setNotice(null), NOTICE_MS); + return () => clearTimeout(timer); + }, [notice]); + + // Keep the selection valid: fall back to the first section, or nothing. + const selection = useMemo(() => { + if (!library) return null; + if (exists(library, selected)) return selected; + const first = library.sections[0]; + return first ? { kind: "section", id: first.id } : null; + }, [library, selected]); + + const select = useCallback((scope: Scope) => { + setSelected(scope); + localStorage.setItem(SELECTION_KEY, JSON.stringify(scope)); + }, []); + + const section = selection?.kind === "section" ? library?.sections.find((s) => s.id === selection.id) : undefined; + const category = library?.categories.find((c) => c.id === (section ? section.category_id : selection?.id)); + const categorySections = category ? (library?.sections.filter((s) => s.category_id === category.id) ?? []) : []; + const chat = useChat(api, selection); + + const sectionId = section?.id; + const sectionReady = section ? `${section.documents}:${section.status.state}` : ""; + useEffect(() => { + if (!api || !sectionId) return; + let cancelled = false; + setDocuments(null); + api.documents(sectionId).then( + (docs) => !cancelled && setDocuments(docs), + () => !cancelled && setDocuments([]), + ); + return () => { + cancelled = true; + }; + }, [api, sectionId, sectionReady]); + + if (engine.state !== "ready") return host.restartEngine()} />; + + const newCategory = () => + setNameRequest({ + title: "New category", + label: "A subject or research area", + action: "Create", + onSubmit: async (name) => { + const created = await run((a) => a.addCategory(name)); + if (created) select({ kind: "category", id: created.id }); + }, + }); + const newSection = (cat: Category) => + setNameRequest({ + title: `New section in ${cat.name}`, + label: "A course, session, project or reading list", + action: "Create", + onSubmit: async (name) => { + const created = await run((a) => a.addSection(name, cat.id)); + if (created) select({ kind: "section", id: created.id }); + }, + }); + const renameCategory = (cat: Category) => + setNameRequest({ + title: "Rename category", + label: "Name", + action: "Rename", + initial: cat.name, + onSubmit: (name) => void run((a) => a.renameCategory(cat.id, name)), + }); + const deleteCategory = (cat: Category) => + setConfirm({ + title: `Delete "${cat.name}"?`, + body: "Only empty categories can be deleted. Your files are never touched.", + action: "Delete", + onConfirm: () => void run((a) => a.deleteCategory(cat.id)), + }); + const renameSection = (s: Section) => + setNameRequest({ + title: "Rename section", + label: "Name", + action: "Rename", + initial: s.name, + onSubmit: (name) => void run((a) => a.updateSection(s.id, { name })), + }); + const deleteSection = (s: Section) => + setConfirm({ + title: `Delete "${s.name}"?`, + body: "Its index and conversation are removed from Open RAG. Your files stay where they are.", + action: "Delete", + onConfirm: () => void run((a) => a.deleteSection(s.id)), + }); + const addFolder = async (s: Section) => { + const path = await host.pickFolder(); + if (!path) return; + if ((await run((a) => a.addFolder(s.id, path))) !== undefined) await run((a) => a.index(s.id)); + }; + const removeFolder = async (s: Section, path: string) => { + if ((await run((a) => a.removeFolder(s.id, path))) !== undefined) await run((a) => a.index(s.id)); + }; + + return ( +
+ +
+ {!library ? ( +
+ +
+ ) : library.categories.length === 0 ? ( + + ) : section ? ( + <> + {category.name}} + onRename={() => renameSection(section)} + onDelete={() => deleteSection(section)} + /> +
+ void chat.send(q)} + onStop={chat.stop} + onClear={chat.clear} + blocked={sectionBlock(section)} + onOpen={(s) => host.openSource(s.source)} + onReveal={(s) => host.revealSource(s.source)} + /> + void addFolder(section)} + onRemoveFolder={(path) => void removeFolder(section, path)} + onIndex={() => void run((a) => a.index(section.id))} + onOpenDocument={(path) => host.openSource(path)} + /> +
+ + ) : category ? ( + <> + Whole category} + onRename={() => renameCategory(category)} + onDelete={() => deleteCategory(category)} + /> +
+ void chat.send(q)} + onStop={chat.stop} + onClear={chat.clear} + blocked={categoryBlock(categorySections)} + onOpen={(s) => host.openSource(s.source)} + onReveal={(s) => host.revealSource(s.source)} + /> + select({ kind: "section", id })} /> +
+ + ) : ( + + )} +
+ setNameRequest(null)} /> + setConfirm(null)} /> + setNotice(null)} /> +
+ ); +} + +function sectionBlock(section: Section): string | null { + if (section.status.state === "indexing") return "Indexing… you can ask as soon as it finishes."; + if (section.folders.length === 0) return "Add a folder with this section's documents to start."; + if (section.documents === 0) return "Index this section to start asking questions."; + return null; +} + +function categoryBlock(sections: Section[]): string | null { + if (sections.length === 0) return "This category has no sections yet."; + if (sections.some((s) => s.status.state === "indexing")) return "A section in this category is indexing… ask when it finishes."; + if (sections.every((s) => s.documents === 0)) return "Index a section in this category to start asking questions."; + return null; +} diff --git a/desktop/web/src/components/Chat.tsx b/desktop/web/src/components/Chat.tsx new file mode 100644 index 0000000..9291b20 --- /dev/null +++ b/desktop/web/src/components/Chat.tsx @@ -0,0 +1,133 @@ +import { ArrowUp, MessagesSquare, Square, Trash2 } from "lucide-react"; +import { useEffect, useRef, useState } from "react"; +import type { ChatMessage, Source } from "../lib/types"; +import { MessageView } from "./Message"; +import { IconButton } from "./primitives"; + +const IDEAS = ["Summarise the key points", "Explain the main idea in simple terms", "What are the important definitions?"]; + +type Props = { + title: string; + messages: ChatMessage[]; + busy: boolean; + blocked: string | null; + onSend: (question: string) => void; + onStop: () => void; + onClear: () => void; + onOpen: (source: Source) => void; + onReveal: (source: Source) => void; +}; + +export function Chat({ title, messages, busy, blocked, onSend, onStop, onClear, onOpen, onReveal }: Props) { + const [draft, setDraft] = useState(""); + const list = useRef(null); + const box = useRef(null); + + useEffect(() => { + list.current?.scrollTo({ top: list.current.scrollHeight, behavior: "smooth" }); + }, [messages]); + + useEffect(() => { + const el = box.current; + if (!el) return; + el.style.height = "auto"; + el.style.height = `${Math.min(el.scrollHeight, 160)}px`; + }, [draft]); + + const send = () => { + if (!draft.trim() || busy || blocked) return; + onSend(draft); + setDraft(""); + }; + + return ( +
+
+ {messages.length === 0 ? ( + setDraft(idea)} /> + ) : ( +
+ {messages.map((m) => ( + + ))} +
+ )} +
+
+
+ {blocked && ( +
+ {blocked} +
+ )} +
+