diff --git a/.gitattributes b/.gitattributes
index fb3a8d58506e0b3d8bc3ec8ac1f2e1a740c7b9aa..4c502e1e9af9541cf2ff5f505be9a13ad6d62a5a 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -44,3 +44,5 @@ collector/**/*.task filter=lfs diff=lfs merge=lfs -text
 
 # processor 文档截图走 LFS(HF 拒绝非 LFS 二进制)
 processor/**/*.png filter=lfs diff=lfs merge=lfs -text
+# MediaPipe 手部模型(7.5MB 二进制)—— 与 collector 侧同一条规则,HF 不收非 LFS 二进制
+processor/**/*.task filter=lfs diff=lfs merge=lfs -text
diff --git a/processor/.env.example b/processor/.env.example
index d1e5b71472a0fd365de6735b419012b3d62088ba..a2b8ae2dec15446428083611b6bba8d1291b4d64 100644
--- a/processor/.env.example
+++ b/processor/.env.example
@@ -13,8 +13,8 @@ SFTP_CONNECT_TIMEOUT=15
 API_KEY=change-me
 WORKER_API_KEY=change-me-worker-key
 JWT_SECRET=change-me-jwt-secret
-EGODATA_BOOTSTRAP_USERNAME=demo-admin
-EGODATA_BOOTSTRAP_PASSWORD=change-me-bootstrap-password
+EGODATA_BOOTSTRAP_USERNAME=Root
+EGODATA_BOOTSTRAP_PASSWORD=Root
 EGODATA_BOOTSTRAP_EMAIL=root@egodata.local
 DEFAULT_WORKFLOW_ID=
 WORKER_LEASE_SECONDS=90
diff --git a/processor/.gitignore b/processor/.gitignore
index e3510ef52b3fc7c00802993e0486623d19168a4e..024d26279fcf995a6289c1c2e392fcc2f2ee432b 100644
--- a/processor/.gitignore
+++ b/processor/.gitignore
@@ -33,6 +33,14 @@ web/workflow-studio/*.tsbuildinfo
 *.db
 *.log
 
+# 编辑器/工具留下的备份与冲突残留文件 —— 一律不入库。
+# 起因:`web/static/plyr.js.bak`(改 plyr.js 时留下的备份)被误提交进了版本库,
+# 而仓库里没有任何规则拦它。改 JS 时留的 .bak 尤其容易混进来。
+*.bak
+*.orig
+*.rej
+*~
+
 # Local model assets and scratch (large binaries, never in git).
 models/
 *.deb
diff --git a/processor/README.md b/processor/README.md
index 420f2d33fc4c6786b8f16b789427469dda2779f9..c9b5bfc66cb2660b3df2c2cdda7f82c150d9d862 100644
--- a/processor/README.md
+++ b/processor/README.md
@@ -4,7 +4,7 @@
 
 [English](README.md) | [中文](README.zh-CN.md)
 
-> Documentation: 2026-09-02  ·  Backend: `1.6.8`  ·  Web frontend: `1.5.6`
+> Documentation: 2026-09-28  ·  Backend: `1.19.4`  ·  Frontend: `1.12.3`
 
 processor is EgoData's service for data capture, processing, review, and export. It is
 designed for embodied AI and robot manipulation data. The system consists of a FastAPI backend,
@@ -523,12 +523,22 @@ Troubleshooting order:
 <details>
 <summary>Click to expand: version maintenance rules</summary>
 
-- The backend version is maintained in `app/version.py`;
-- the Web frontend version is maintained in `web/workflow-studio/package.json`;
+- The backend version is maintained in `app/version.py` and covers the backend **only**;
+- **the frontend version is maintained in `web/VERSION`**. It covers every piece of frontend
+  code under `processor/web/` (`templates/`, `static/`, `workflow-studio/`) — **not just the
+  React SPA**. The version inside `web/workflow-studio/package.json` only represents the SPA
+  itself; all three numbers are independent and do not need to stay in sync.
+- **Bump `web/VERSION` — that one file — whenever you change the frontend.** A single number
+  serves two purposes: ① the `?v={{ asset_version }}` cache key on static assets (so browsers
+  re-fetch changed JS/CSS), ② the "frontend X" part of commit messages. Sharing one number
+  means the commit message can never disagree with what the browser actually loaded.
+  You do **not** need to touch the backend version for a frontend change.
+- `web/VERSION` is read once at startup and cached (`app/web_version.py`), so **restart the
+  service** after bumping it.
 - increment the patch version for fixes and small adjustments, the minor version for new features,
   and the major version for architectural changes;
 - before release, record the software version, data format, and API changes together.
 
-Current versions: backend `1.6.8`, Web frontend `1.5.6`.
+Current versions: backend `1.19.4`, frontend `1.12.3`.
 
 </details>
diff --git a/processor/README.zh-CN.md b/processor/README.zh-CN.md
index 363a79a0cd2046d6a1b0b7d0753c1f2914da90f4..681f290531e07cbdcd2f7b67289872d988238eb3 100644
--- a/processor/README.zh-CN.md
+++ b/processor/README.zh-CN.md
@@ -2,7 +2,7 @@
 
 [中文](README.zh-CN.md) | [English](README.md)
 
-> 文档版本：2026-09-02  ·  后端版本：`1.6.8`  ·  WEB 前端版本：`1.5.6`
+> 文档版本：2026-09-28  ·  后端版本：`1.19.4`  ·  前端版本：`1.12.3`
 
 processor 是 EgoData 的数据采集、处理、审核和导出服务，面向具身智能与机器人
 操作数据。系统由 FastAPI 后端、异步 Worker、Web 审核页面和 Workflow Studio 组成。
@@ -506,11 +506,19 @@ npm run build
 <details>
 <summary>点击展开：版本维护规则</summary>
 
-- 后端版本在 `app/version.py` 中维护；
-- Web 前端版本在 `web/workflow-studio/package.json` 中维护；
+- 后端版本在 `app/version.py` 中维护，**只管后端**；
+- **前端版本在 `web/VERSION` 中维护**。它覆盖 `processor/web/` 下的全部前端代码
+  （`templates/`、`static/`、`workflow-studio/`），**不只是那个 React SPA**。
+  `web/workflow-studio/package.json` 里的 version 只代表 SPA 自己，三者互相独立、不必同步。
+- **改了前端就只 bump `web/VERSION` 这一个文件**。它一个号管两件事：
+  ① 模板里的 `?v={{ asset_version }}` 缓存键（读了它浏览器才会重新拉 JS/CSS）
+  ② 提交信息里的「前端 X」。
+  两个用途共用一个数，不会出现"提交信息写 1.12.3、浏览器却拿 1.12.2"这种对不上的情况。
+  改前端**不需要**动后端版本号。
+- 改完 `web/VERSION` 要**重启服务**才生效（`app/web_version.py` 启动时读一次就缓存）。
 - 修复和小调整增加修订号；新增功能增加次版本号；重大架构变更增加主版本号；
 - 发布前应同步记录软件版本、数据格式和 API 变化。
 
-当前版本：后端 `1.6.8`，WEB 前端 `1.5.6`。
+当前版本：后端 `1.19.4`，前端 `1.12.3`。
 
 </details>
diff --git a/processor/app/ai_annotation.py b/processor/app/ai_annotation.py
index 1a4e16cb15febd3454ce070182d0240b0b28bb1f..7430a4dc79e6a7454c99b334591156faf4ba9999 100644
--- a/processor/app/ai_annotation.py
+++ b/processor/app/ai_annotation.py
@@ -41,7 +41,6 @@ from app.localstore import (
     read_episode_state,
     write_episode_state,
 )
-from app.routes.annotations import notify_annotations_changed
 from app.video_quality import check_video_quality_async
 from app.workflow_types import HAND_PROCESS_TYPES, canonical_node_type
 
@@ -612,23 +611,36 @@ def _set_ai_quality_state(episode_id: str, report: dict, *,
 
     The web UI continues to use only Reviewing/Approved.  The detailed report
     is kept in episode state for diagnostics and future review tooling.
+
+    ★ ``auto_approve`` 会被【数据质检】否决 —— 判 FAIL/ERROR 的批次在
+      ``cleaning_summary.blocking`` 上留了粘性标记。AI 标注覆盖率合格不代表
+      数据本身没问题；只看自己那份报告的话，坏数据会被一路自动批准放行
+      （质检与视频门禁是并发跑的，谁先写没有保证，所以必须查标记而不是
+      比谁写得晚）。
     """
-    state = read_episode_state(episode_id)
-    state["ai_quality_status"] = "passed" if report.get("passed") else "failed"
-    state["ai_quality_report"] = report
-    state["updated_at"] = _utcnow()
-    current = str(state.get("status") or "")
-    if report.get("passed") and auto_approve:
-        if current in {"processing", "to_review", "completed", "failed"}:
-            state["status"] = "reviewed"
-            if not state.get("approved_at"):
-                state["approved_at"] = _utcnow()
-    elif not report.get("passed"):
-        # Fail closed: an incomplete/failed AI result remains in Reviewing.
-        if current in {"processing", "completed", "reviewed", "approved", "failed"}:
-            state["status"] = "to_review"
-            state["approved_at"] = None
-    write_episode_state(episode_id, state)
+    from app.localstore import mutate_episode_state
+    from app.processing.cleaning.store import is_approval_blocked
+
+    def _apply(state: dict) -> None:
+        state["ai_quality_status"] = "passed" if report.get("passed") else "failed"
+        state["ai_quality_report"] = report
+        state["updated_at"] = _utcnow()
+        current = str(state.get("status") or "")
+        if report.get("passed") and auto_approve:
+            if (current in {"processing", "to_review", "completed", "failed"}
+                    and not is_approval_blocked(state)):
+                state["status"] = "reviewed"
+                if not state.get("approved_at"):
+                    state["approved_at"] = _utcnow()
+        elif not report.get("passed"):
+            # Fail closed: an incomplete/failed AI result remains in Reviewing.
+            if current in {"processing", "completed", "reviewed", "approved", "failed"}:
+                state["status"] = "to_review"
+                state["approved_at"] = None
+
+    # 锁内 RMW：数据质检 / 视频门禁在同一次 run 后并发写同一份 state。分开
+    # read→write 的话，后写的会用旧快照把先写的 ``status`` 冲掉。
+    mutate_episode_state(episode_id, _apply)
 
 
 def _set_ai_quality_pending(episode_id: str) -> None:
@@ -2697,6 +2709,11 @@ def _persist_ai_segment(episode_id: str, generation: int, candidate: dict,
                         index: int, media_sources: list[str], *,
                         pending: bool = False, error: str = "") -> dict:
     """Atomically insert/update one segment without waiting for its siblings."""
+    # 惰性导入 —— 不要提到模块顶层。本模块在路由层**之下**,而 routes.annotations
+    # 反过来惰性引用 ai_annotation(_schedule_dataset_sync)。模块级导入会形成
+    # import 环:谁先被导入,谁就拿不到对方完整的模块对象。放进调用点后方向保持
+    # 单向(路由 → 本模块),将来搬文件也不会因顺序踩坑。
+    from app.routes.annotations import notify_annotations_changed
     record = _ai_annotation_record(
         episode_id, candidate, index, media_sources,
         pending=pending, error=error)
@@ -2823,6 +2840,8 @@ def run_ai_annotation(episode_id: str, mode: str, min_confidence: float,
     走本地 vLLM 抽帧图;provider=api 走 Kimi 原生视频 —— 两模式严格
     分离,配置缺失/请求失败显式报错(任务 detail 可见),绝不互回退。
     """
+    # 同 _persist_ai_segment:惰性导入,避免与 routes.annotations 形成 import 环。
+    from app.routes.annotations import notify_annotations_changed
     episode_id = str(episode_id)
     quality_review_enabled = bool(quality_gate or video_quality_gate)
     if quality_review_enabled:
@@ -3538,7 +3557,7 @@ def _connected_quality_node_config(graph: dict, node_configs: dict,
     }
     quality_nodes = {
         str(node.get("id")): node for node in nodes
-        if canonical_node_type((node.get("data") or {}).get("nodeType")) == "ai_quality_review"
+        if canonical_node_type((node.get("data") or {}).get("nodeType")) == "data_quality"
         and node.get("id") is not None
     }
     if not source_ids or not quality_nodes:
@@ -3570,25 +3589,32 @@ def _connected_quality_node_config(graph: dict, node_configs: dict,
     return None
 
 
-def ai_quality_review_node_config(graph: dict, node_configs: dict) -> dict | None:
-    """Return the quality card only when it is connected to AI Annotation.
+def annotation_coverage_gate_config(graph: dict, node_configs: dict) -> dict | None:
+    """Return the Data Quality card only when it is connected to AI Annotation.
 
     A card sitting alone in the canvas is configuration only.  The gate is
-    enabled for a directed path ``AI Annotation -> ... -> AI Quality Review``;
+    enabled for a directed path ``AI Annotation -> ... -> Data Quality``;
     allowing pass-through nodes in the middle keeps existing workflow layouts
     compatible while making a dangling quality card inert.
+
+    以前叫 ``ai_quality_review_node_config`` —— 当时节点叫 AI Quality Review。
+    节点合并为 Data Quality 后按"它能开启哪项检查"重命名，函数名不再绑定
+    已废弃的 slug。
     """
     return _connected_quality_node_config(
         graph, node_configs, {"ai_annotation"})
 
 
-def video_quality_review_node_config(graph: dict, node_configs: dict) -> dict | None:
-    """Return the quality card when it is connected to a media/data source.
+def video_quality_gate_config(graph: dict, node_configs: dict) -> dict | None:
+    """Return the Data Quality card when it is connected to a media/data source.
 
     This enables a video-only workflow to run the post-processing media gate,
-    while an unconnected ``AI Quality Review`` card remains inert.  The list
+    while an unconnected ``Data Quality`` card remains inert.  The list
     intentionally contains existing input/process node types only; export
     nodes cannot accidentally activate a review gate.
+
+    历史上这段逻辑属于 ``AI Quality Review`` 卡片 —— 视频检查当时"寄居"在
+    标注节点里，好让没有 AI 标注的纯视频工作流也有质量门禁。
     """
     return _connected_quality_node_config(
         graph,
@@ -3656,7 +3682,7 @@ def _workflow_ai_quality_enabled(episode_id: str) -> bool:
         wf = get_workflow(wf_id)
         if wf is None:
             continue
-        if ai_quality_review_node_config(
+        if annotation_coverage_gate_config(
                 wf.get("graph") or {}, wf.get("node_configs") or {}) is not None:
             return True
     return False
@@ -3683,7 +3709,7 @@ def _workflow_video_quality_enabled(episode_id: str) -> bool:
         wf = get_workflow(wf_id)
         if wf is None:
             continue
-        if video_quality_review_node_config(
+        if video_quality_gate_config(
                 wf.get("graph") or {}, wf.get("node_configs") or {}) is not None:
             return True
     return False
diff --git a/processor/app/api/quality.py b/processor/app/api/quality.py
new file mode 100644
index 0000000000000000000000000000000000000000..2e7295582ecec907e84bbf90a61fb7400448c9f1
--- /dev/null
+++ b/processor/app/api/quality.py
@@ -0,0 +1,172 @@
+"""数据质检 API —— 检查项目录、报告查询、手动触发。
+
+给前端两件事：
+* 设置面板的**数据源** —— ``/checks`` 返回检查项目录 + 按设备卡片的分组，
+  面板按它渲染 tab 和每一项的阈值输入框。新增检查项前端零改动。
+* 报告的**读取入口** —— 列表页和详情页。
+
+写端点少而克制：只有"重跑某集"。质检本身不做任何数据修改，
+所以没有删除/清理类的接口。
+"""
+
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+
+from fastapi import APIRouter, HTTPException, Query
+
+router = APIRouter(prefix="/api/v1/quality", tags=["quality"])
+
+
+def _check_catalog() -> dict:
+    """检查项目录 + 按设备卡片分组 —— 前端设置面板的渲染数据。
+
+    ``checks`` 是平铺清单（每项带 ``device_cards`` / ``default_params``）；
+    ``by_device`` 是按设备卡片分好组的视图，前端 tab 直接用。
+    两者给同一份数据，前端按方便取用。
+    """
+    from app.processing.cleaning.checks import all_checks, all_check_specs
+    from app.processing.cleaning.contract import (
+        DEVICE_MODALITIES, MODALITY_CHANNELS,
+    )
+    from app.processing.cleaning.engine import ruleset_revision
+
+    specs = all_check_specs()
+    by_device: dict[str, list[str]] = {}
+    for modality in DEVICE_MODALITIES:
+        by_device[modality] = [
+            spec["slug"] for spec in specs
+            if modality in (spec.get("device_cards") or [])
+        ]
+
+    return {
+        "ruleset_revision": ruleset_revision(),
+        "checks": specs,
+        "by_device": by_device,
+        "device_labels": _device_labels(),
+        "device_channels": {
+            modality: list(channels)
+            for modality, channels in MODALITY_CHANNELS.items()
+        },
+        "severity_labels": _severity_labels(),
+        "total": len(all_checks()),
+    }
+
+
+def _device_labels() -> dict[str, str]:
+    """设备卡片的显示名 —— 复用 device_naming，不另起一套。"""
+    try:
+        from app.device_naming import DEVICE_LABELS
+        return dict(DEVICE_LABELS)
+    except Exception:
+        return {}
+
+
+def _severity_labels() -> dict[str, str]:
+    from app.processing.cleaning.contract import SEVERITY_LABELS
+    return dict(SEVERITY_LABELS)
+
+
+@router.get("/checks")
+def list_checks() -> dict:
+    """检查项目录（含按设备卡片分组）—— 设置面板用。"""
+    return _check_catalog()
+
+
+@router.get("/summary")
+def list_summaries(project: str | None = Query(None),
+                   status: str | None = Query(None),
+                   limit: int = Query(200, ge=1, le=2000)) -> dict:
+    """质检报告列表（摘要），按时间倒序。
+
+    ``status`` 过滤按 episode 结论（pass / warn / fail / pending_review / error）。
+    """
+    from app.processing.cleaning.store import list_reports
+
+    items = list_reports()
+    if project:
+        items = [item for item in items if str(item.get("project")) == project]
+    if status:
+        items = [item for item in items if item.get("status") == status]
+
+    counts: dict[str, int] = {}
+    for item in items:
+        key = str(item.get("status") or "unknown")
+        counts[key] = counts.get(key, 0) + 1
+
+    return {"reports": items[:limit], "total": len(items), "counts": counts}
+
+
+@router.get("/episodes/{episode_id}")
+def get_report(episode_id: str) -> dict:
+    """某一集的完整质检报告（四层结果）。"""
+    from app.processing.cleaning.store import load_report, load_summary
+
+    report = load_report(episode_id)
+    if report is not None:
+        return report
+    summary = load_summary(episode_id)
+    if summary is not None:
+        # 完整报告被清掉了但摘要还在（state 里）—— 至少把摘要给出去
+        return {"episode_id": episode_id, "summary_only": True, **summary}
+    raise HTTPException(status_code=404, detail="No quality report for this episode")
+
+
+@router.post("/episodes/{episode_id}/run")
+async def run_episode_checks(
+    episode_id: str,
+    probe_video: bool = Query(False, description="是否跑视频检查（慢）"),
+    persist: bool = Query(True, description="是否把报告写进 episode state"),
+) -> dict:
+    """重跑某一集的质检。
+
+    跑在**线程池**里 —— 读 parquet/视频是阻塞 IO，直接放事件循环上会把
+    页面请求卡住（仓库里 ``routes/devices.py`` 有同样的处理）。
+    """
+    episode = await asyncio.to_thread(_find_episode, episode_id)
+    if episode is None:
+        raise HTTPException(status_code=404, detail="Episode not found")
+
+    report = await asyncio.to_thread(_run_checks_for, episode, probe_video)
+    saved = False
+    if persist:
+        from app.processing.cleaning.store import save_report
+        saved = await asyncio.to_thread(save_report, episode_id, report)
+    return {"episode_id": episode_id, "saved": saved, "report": report}
+
+
+def _find_episode(episode_id: str) -> dict | None:
+    """在会话索引里找这一集（含 ``path``，质检要用它读数据）。"""
+    from app.localstore import scan_sessions
+
+    for episode in scan_sessions():
+        if str(episode.get("id")) == episode_id:
+            return episode
+    return None
+
+
+def _run_checks_for(episode: dict, probe_video: bool) -> dict:
+    from app.processing.cleaning.engine import run_checks
+
+    path = Path(str(episode.get("path") or ""))
+    if not path.is_dir():
+        raise HTTPException(status_code=409, detail="Episode data directory missing")
+
+    # 设备卡片取自 episode 的设备信息 —— 与工作流派发用的是同一套口径
+    modality = None
+    try:
+        from app.workflow_dispatch import _episode_input_groups
+        groups = _episode_input_groups(episode) or []
+        if groups:
+            modality = str(groups[0].get("input_type") or "") or None
+    except Exception:
+        modality = None
+
+    return run_checks(
+        path,
+        episode_id=str(episode.get("id") or ""),
+        project=str(episode.get("project") or ""),
+        probe_video=probe_video,
+        modality_hint=modality,
+    )
diff --git a/processor/app/api/worker.py b/processor/app/api/worker.py
index ad33512b3ced98af2dc0826cd9c46fc38bb99570..a68cd156a536d5465b1dfd0d07a3300fd0047071 100644
--- a/processor/app/api/worker.py
+++ b/processor/app/api/worker.py
@@ -520,14 +520,14 @@ async def complete_job(
         from app.ai_annotation import (
             run_ai_annotation,
             ai_annotation_node_config,
-            ai_quality_review_node_config,
-            video_quality_review_node_config,
+            annotation_coverage_gate_config,
+            video_quality_gate_config,
         )
         graph = run.get("graph") or {}
         node_configs = run.get("node_configs") or {}
         cfg = ai_annotation_node_config(graph, node_configs)
-        quality_cfg = ai_quality_review_node_config(graph, node_configs)
-        video_quality_cfg = video_quality_review_node_config(graph, node_configs)
+        quality_cfg = annotation_coverage_gate_config(graph, node_configs)
+        video_quality_cfg = video_quality_gate_config(graph, node_configs)
         if cfg is not None and not run.get("ai_suggest_triggered"):
             run["ai_suggest_triggered"] = True
             save_run(run)
@@ -572,6 +572,26 @@ async def complete_job(
     except Exception as exc:
         print(f"[Worker] AI annotation trigger skipped: {exc}")
 
+    # 数据质检联动:工作流里 Data Quality 卡片**接了数据链路**就跑一次检查。
+    #
+    # 与上面两条是两套东西:ai_annotation / video_quality 会改 episode 状态
+    # (通过→reviewed、失败→卡到 to_review),而质检**只把结论记进**
+    # state 的 cleaning_report,不参与状态流转。
+    #
+    # 两者会同时触发(相机类工作流就同时命中 video_quality_gate 和这里),而且
+    # 都各要解码一遍视频 —— 所以它们几乎同时结束、同时写状态,状态写入一律走
+    # localstore.mutate_episode_state(锁内 RMW),否则后写的会用旧快照把先写的
+    # 冲掉(尤其 status)。
+    #
+    # 必须放后台任务:probe_video 要解码视频(实测约 4.8s/集),不能拖住完成响应。
+    try:
+        from app.processing.cleaning.trigger import spawn_cleaning_for_run
+        if ep is not None and spawn_cleaning_for_run(run, ep):
+            print(f"[Worker] Data quality checks triggered "
+                  f"for {run['episode_id']}")
+    except Exception as exc:
+        print(f"[Worker] Data quality trigger skipped: {exc}")
+
     # 归档联动:处理完成后后台把该批次增量推送到 NAS(只推不删;rsync
     # 逐块校验+断点续传,失败仅记日志不阻塞响应;每晚 cron 兜底补传)。
     # 脚本不存在(如 Windows 环境)时静默跳过。
diff --git a/processor/app/cleaning.py b/processor/app/cleaning.py
index 57ec0257631adb872e260d667e4d6dd9740674c0..5bc62c4bf71dd06aabeae4fa443a35e98b0f986a 100644
--- a/processor/app/cleaning.py
+++ b/processor/app/cleaning.py
@@ -281,20 +281,41 @@ def _check_frame_alignment_fs(batch_dir: Path) -> dict:
                 except Exception:
                     continue
         parquet_frames = len(seen)
+        if parquet_frames == 0:
+            return {"name": "frame_alignment", "passed": True, "detail": "No parquet data"}
+
+        # 2026-09-23 修:此处此前直接用 cv2 却没 import,异常被下方 except 吞掉,
+        # 整个帧对齐检查在文件级路径下**永远静默通过**(detail 里写的是
+        # "Check error (skipped)" 但 passed=True,不会引起任何人注意)。
+        try:
+            import cv2
+        except ImportError:
+            return {"name": "frame_alignment", "passed": True,
+                    "detail": "OpenCV not available — video frame count skipped"}
+
+        mp4s = sorted(batch_dir.rglob("*.mp4"))
+        if not mp4s:
+            # 与 _check_video_decode_fs 同款处理:没有视频就没有可比对的对象,
+            # 判"未适用"而不是"不匹配"——只有传感器的批次(如纯手套)是合法的。
+            # 修复 cv2 漏 import 后,这里若不给守卫会退化成 dev=10000% 的误报。
+            return {"name": "frame_alignment", "passed": True,
+                    "detail": "No video to compare against"}
+
         video_frames = 0
-        for mp4 in batch_dir.rglob("*.mp4"):
+        for mp4 in mp4s:
             cap = cv2.VideoCapture(str(mp4))
             try:
                 video_frames = max(video_frames, int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) or 0)
             finally:
                 cap.release()
-        if parquet_frames == 0:
-            return {"name": "frame_alignment", "passed": True, "detail": "No parquet data"}
         ratio = abs(parquet_frames - video_frames) / max(video_frames, 1)
         return {"name": "frame_alignment", "passed": ratio < 0.10,
                 "detail": f"parquet={parquet_frames}, video={video_frames}, dev={ratio:.1%}"}
     except Exception as e:
-        return {"name": "frame_alignment", "passed": True, "detail": f"Check error (skipped): {e}"}
+        # 保持 passed=True(不改变既有行为),但 detail 必须说清是"降级通过",
+        # 免得再出现"看起来全过了其实根本没检查"的情况。
+        return {"name": "frame_alignment", "passed": True,
+                "detail": f"Degraded pass — check errored: {e}"}
 
 
 def _check_sensor_completeness_fs(batch_dir: Path) -> dict:
diff --git a/processor/app/config.py b/processor/app/config.py
index 395f3a444dd71fa9e0ad2a7faef496acdeba0ee1..14d51d89ab6312b606d7ff8dc649af59625c4ec4 100644
--- a/processor/app/config.py
+++ b/processor/app/config.py
@@ -56,6 +56,27 @@ class Settings(BaseSettings):
     EXPORT_SHARD_SIZE: int = 100000
     VIDEO_SHARD_FRAMES: int = 5000
 
+    # Training. Checkpoints are produced *outside* the platform by the official
+    # ``lerobot-train`` CLI (conda env ``lerobot052_base_piper``), so this points
+    # at an existing directory we only ever read. Empty = use the default below.
+    TRAIN_OUTPUT_ROOT: str = ""
+
+    @property
+    def train_root(self) -> Path:
+        """Trained-model directory — **read-only**, never created here.
+
+        Defaults to ``<repo>/文件测试/umi_act_model``, i.e. beside ``processor/``.
+        The directory is git-ignored and may legitimately be absent (fresh
+        clone, or training never run on this host): callers must treat a
+        missing path as "no runs" rather than creating it.  Creating it would
+        make an empty training dir appear out of nowhere on every boot.
+        """
+        raw = str(self.TRAIN_OUTPUT_ROOT or "").strip()
+        if raw:
+            return Path(raw).expanduser()
+        return (Path(__file__).resolve().parent.parent.parent
+                / "文件测试" / "umi_act_model")
+
     model_config = {
         "env_prefix": "",
         "case_sensitive": False,
diff --git a/processor/app/hdf5_export.py b/processor/app/hdf5_export.py
index d5b4538925b7cd2f01691070ed48c3547a8dab25..45a9a1fec2d71254fef2eedd7f34a3b9f9f44e1b 100644
--- a/processor/app/hdf5_export.py
+++ b/processor/app/hdf5_export.py
@@ -34,6 +34,7 @@ from app.localstore import get_episode
 from app.lerobot_export import (
     _annotation_maps,
     _calibration_docs,
+    _depth_video_paths,
     _hand_columns,
     _infer_hand_3d_unit,
     _key_matches_any,
@@ -288,6 +289,66 @@ def build_hdf5_dataset(dataset_name: str, episode_ids: list[str], output_dir: Pa
                     "video_info": {"video.fps": vfps, "video.is_depth_map": False},
                 }
 
+            # 1b) 深度流 → 逐帧 uint16 毫米(单独一组,不和 RGB 混在 images/ 下)
+            #
+            # 深度**不在** camera_streams 里 —— 它单独放在 depth/<source>/,
+            # 所以上面的 RGB 循环根本看不到它,必须用 lerobot_export 的发现函数。
+            #
+            # 解码必须走 DepthVideoReader(ffmpeg 解 gray12le):OpenCV 会把
+            # 12-bit 深度当普通显示图转成 8-bit,真实毫米值全丢。
+            #
+            # **0 表示"没测到深度"的无效像素,不是 0 毫米** —— 与采集端语义一致,
+            # 原样保留,不要当数值去算均值。
+            for source_key, depth_path in _depth_video_paths(session_dir, episode_id):
+                if include_video_keys is not None and not _key_matches_any(
+                        source_key, include_video_keys):
+                    continue
+                reader = None
+                try:
+                    from app.lerobot_v21 import DEPTH_VIDEO_ENCODING, DepthVideoReader
+                    reader = DepthVideoReader(depth_path)
+                    dheight, dwidth = reader.height, reader.width
+                    if dheight <= 0 or dwidth <= 0 or T <= 0:
+                        continue
+                    dfps = float(reader.fps or episode_fps)
+                    ds = obs.create_dataset(
+                        f"depth/{source_key}", shape=(T, dheight, dwidth),
+                        dtype="uint16", chunks=(1, dheight, dwidth),
+                        compression=compression, compression_opts=level)
+                    ds.attrs["unit"] = "millimetre"
+                    ds.attrs["invalid_value"] = 0
+                    ds.attrs["fps"] = dfps
+                    ds.attrs["source_key"] = source_key
+                    ds.attrs["source_episode"] = episode_id
+                    ds.attrs["encoding"] = DEPTH_VIDEO_ENCODING
+                    i = 0
+                    while i < T:
+                        frame = reader.read_mm()
+                        if frame is None:
+                            break
+                        ds[i] = frame
+                        i += 1
+                    features[f"observation.depth.{source_key}"] = {
+                        "dtype": "uint16", "shape": [T, dheight, dwidth],
+                        "unit": "millimetre",
+                        "note": "0 = 无效像素(该点未测到深度),不是 0 毫米",
+                        "video_info": {
+                            "video.fps": dfps,
+                            "video.is_depth_map": True,
+                            "video.height": dheight,
+                            "video.width": dwidth,
+                        },
+                    }
+                except Exception as exc:
+                    print(f"[hdf5_export] depth stream {source_key} "
+                          f"skipped: {exc}")
+                finally:
+                    if reader is not None:
+                        try:
+                            reader.close()
+                        except Exception:
+                            pass
+
             # 2) 表列:传感器 + 手部骨骼 + 标注(与 LeRobot 列同构,按帧号对齐)
             columns: dict[str, dict[int, Any]] = {}
             str_columns: set[str] = set()
@@ -406,11 +467,11 @@ def build_hdf5_dataset(dataset_name: str, episode_ids: list[str], output_dir: Pa
                     annotation_defs, ensure_ascii=False)
 
             # 6) 标定 → /meta/calibration/<episode>/<name> attrs(JSON 字符串)
-            # 与 stereo_triangulate 一致:批次标定缺失/全零 → 回退内置默认标定
-            # (否则 meta 里声明的是未生效的标定,3D 数据无法复现)。
-            # 回退逻辑统一在 lerobot_export._calibration_docs(单点维护)。
+            # 每集一份,所以把 episode_id 一起传进去 —— 批次内各集标定可以不同,
+            # 不传就只会看到批次级的 calibration/ 目录。
+            # 缺失/全零时的默认标定回退统一在 lerobot_export._calibration_docs。
             cal_group = meta.create_group(f"calibration/{episode_id}")
-            cal_docs = _calibration_docs(session_dir)
+            cal_docs = _calibration_docs(session_dir, episode_id)
             for name, value in cal_docs.items():
                 cal_group.attrs[name] = json.dumps(value, ensure_ascii=False)
 
@@ -506,7 +567,16 @@ def _build_readme(dataset_name: str, h5: Any) -> str:
     img_keys = sorted(n for n in all_names
                       if n.startswith(f"{root}/observation/images/"))
     if img_keys:
-        rows.append(f"| **原视频** | {len(img_keys)} 路原始帧 | ✅ 全量 |")
+        # 不写"全量" —— 视频可能被工作流的 include_video_keys 过滤过,而且
+        # 深度流走 depth_sources、不经 camera_streams,本文件**从来不导**。
+        # 声称"全量"会让客户以为拿到的是全部视频。
+        rows.append(f"| **原视频** | {len(img_keys)} 路原始帧(逐帧 uint8 RGB)"
+                    " | ✅ 已导出,清单见上方结构树 |")
+    depth_keys = sorted(n for n in all_names
+                        if n.startswith(f"{root}/observation/depth/"))
+    if depth_keys:
+        rows.append(f"| **深度图** | {len(depth_keys)} 路,uint16 **毫米**"
+                    " | ✅ 0 = 无效像素(未测到),不是 0 毫米 |")
     hand_coordinate = next(
         (coord for coord in ("world", "3d", "2d")
          if f"{root}/observation/state/hand_left_{coord}" in all_names),
@@ -558,6 +628,27 @@ with open("hand_skeleton.mp4", "wb") as f:
 ```
 """
 
+    # 读取示例:只给文件里**确实存在**的路径。原来是左目写死 stereo_left、
+    # 手部无数据时仍回落到 hand_right_3d —— 客户照抄都是 KeyError;而且
+    # `import h5py` 在 0 列、`with` 却缩进了 4 格,示例本身就不是合法 Python。
+    first_img = img_keys[0].split("/")[-1] if img_keys else None
+    example = ["import h5py", "", 'with h5py.File("dataset.h5", "r") as h5:']
+    if first_img:
+        example.append(f"    # 读一帧图像({first_img})")
+        example.append(f'    img = h5["{root}/observation/images/{first_img}"][0]')
+    if depth_keys:
+        first_depth = depth_keys[0].split("/")[-1]
+        example.append(f"    # 读一帧深度({first_depth};uint16 毫米,0 = 无效像素)")
+        example.append(f'    depth = h5["{root}/observation/depth/{first_depth}"][0]')
+    if hand_coordinate:
+        example.append("    # 读第一帧右手骨骼(字段可能是 world / 3d / 2d)")
+        example.append(f'    hand3d = h5["{root}/observation/state/'
+                       f'hand_right_{hand_coordinate}"][0]')
+    if f"{root}/observation/annotation" in all_names:
+        example.append("    # 读全部标注")
+        example.append(f'    labels = h5["{root}/observation/annotation"][:]')
+    read_example = "\n".join(example)
+
     readme = f"""# {dataset_name} 数据文件说明(HDF5 格式)
 
 > 本文件由 EgoData 数据采集系统工作流自动生成
@@ -588,15 +679,7 @@ with open("hand_skeleton.mp4", "wb") as f:
 ## 四、如何读取
 
 ```python
-import h5py
-
-    with h5py.File("dataset.h5", "r") as h5:
-        # 读一帧左目图像
-        img = h5["episode_000000/observation/images/stereo_left"][0]
-    # 读第一帧右手骨骼(字段可能是 world / 3d / 2d)
-    hand3d = h5["episode_000000/observation/state/hand_right_{hand_coordinate or '3d'}"][0]
-    # 读全部标注
-    labels = h5["episode_000000/observation/annotation"][:]
+{read_example}
 ```
 {video_extract}
 其他工具:HDFView、Panoply、MATLAB(h5read)等支持 HDF5 的软件均可打开。
diff --git a/processor/app/i18n.py b/processor/app/i18n.py
new file mode 100644
index 0000000000000000000000000000000000000000..056f4a6c5d065f16bcda294aac5335eab86d21d1
--- /dev/null
+++ b/processor/app/i18n.py
@@ -0,0 +1,89 @@
+"""服务端 i18n —— 让首屏 HTML 直接是正确语言,消掉"先英文后中文"的闪烁。
+
+**问题**:语言原本只存在浏览器的 ``localStorage`` 里,服务端不知道。所以渲染出来
+的 ``data-i18n`` 元素只能填**默认语言(英文)**,再由 ``DOMContentLoaded`` 里的 JS
+改成中文 —— 改的时机在首屏之后,于是每次整页导航都闪一下。
+
+**做法**:语言同时写进 cookie,服务端渲染时就用它取词。首屏直接是对的语言,
+不需要任何"先渲染再纠正"。
+
+**词典的真源**是 ``web/static/js/i18n-data.js`` —— 一个合法 JSON 载荷外面包一行
+``window.__I18N__ = …``:
+
+    * 浏览器把它当**普通脚本**同步加载(带 ``?v=`` 缓存,不会每页重下)
+    * 这里剥掉包装后 ``json.loads``,拿到的就是同一份数据
+
+两边读同一份文件,所以**不会分叉**。改词条只改那一个文件。
+"""
+
+from __future__ import annotations
+
+import json
+from contextvars import ContextVar
+from pathlib import Path
+
+from starlette.middleware.base import BaseHTTPMiddleware
+
+# cookie 名与前端 localStorage 的键保持一致,便于两边对照排查。
+LANG_COOKIE = "lang"
+LANGUAGES = ("zh", "en")
+# 没选过语言时用哪个。刻意保持 **en** —— 与前端原来的行为一致(切语言前的默认),
+# 不借这次改动偷偷改变默认观感。要改成 zh 的话两边一起改(i18n.js 的 currentLang)。
+DEFAULT_LANG = "en"
+
+_DICT_PATH = (Path(__file__).resolve().parent.parent
+              / "web" / "static" / "js" / "i18n-data.js")
+
+
+def _load() -> dict[str, dict[str, str]]:
+    """读 ``i18n-data.js`` 并把 JSON 载荷解析出来。
+
+    解析失败**不抛异常**:页面照常起得来,只是文案退回 key 本身 —— 比整个服务
+    因为一个词典文件挂掉好。真要查的话看 ``data`` 是不是空的。
+    """
+    try:
+        raw = _DICT_PATH.read_text(encoding="utf-8")
+        payload = raw[raw.index("{"):raw.rindex("}") + 1]
+        data = json.loads(payload)
+    except (OSError, ValueError, IndexError):
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+DATA: dict[str, dict[str, str]] = _load()
+
+
+def normalize(lang: str | None) -> str:
+    """把任意输入收敛成一个可用语言码。认不出来就回默认。"""
+    value = str(lang or "").strip().lower()
+    return value if value in DATA else DEFAULT_LANG
+
+
+_current: ContextVar[str] = ContextVar("egodata_lang", default=DEFAULT_LANG)
+
+
+def get_current_lang() -> str:
+    return _current.get()
+
+
+def t(key: str, lang: str | None = None) -> str:
+    """取词。**取不到就返回 key 本身** —— 页面上会显示出一个明显的
+    ``nav_foo`` 而不是空白,一眼看得出是漏翻,比静默空着好排查。"""
+    use = normalize(lang) if lang is not None else _current.get()
+    table = DATA.get(use) or DATA.get(DEFAULT_LANG) or {}
+    return table.get(key) or key
+
+
+class LanguageMiddleware(BaseHTTPMiddleware):
+    """从 cookie 读语言,放进 ContextVar —— Jinja 里注册的 ``t`` 直接用。
+
+    用 ContextVar 而不是往每个 ``TemplateResponse`` 的 context 里塞:后者要改
+    20 多处调用点,而 ``t`` 是**每个模板都要用**的东西,漏一个就是一片英文。
+    """
+
+    async def dispatch(self, request, call_next):
+        token = _current.set(normalize(request.cookies.get(LANG_COOKIE)))
+        try:
+            return await call_next(request)
+        finally:
+            _current.reset(token)
diff --git a/processor/app/lerobot_export.py b/processor/app/lerobot_export.py
index 38e39a010c552f16c2b8042a2eda940182a0de20..573893665c962f269ac052c4e09e8f17db435843 100644
--- a/processor/app/lerobot_export.py
+++ b/processor/app/lerobot_export.py
@@ -1806,6 +1806,82 @@ def _depth_assets(session_dir: Path, frame_count: int,
     return assets
 
 
+# 内置默认双目标定 —— 批次标定缺失或整份全零时的兜底。键名取自该文件的
+# ``name`` 字段(head_stereo),与会话里真有一份 head_stereo.json 时算出的键一致。
+_DEFAULT_CALIBRATION_PATH = (Path(__file__).resolve().parent
+                             / "processing" / "modules"
+                             / "calibration_default_head_stereo.json")
+
+
+def _calibration_is_blank(doc: Any) -> bool:
+    """整份标定里找不出任何非零数值 —— 视为未生效的空白标定。
+
+    只递归看数值叶子(标定本质上就是嵌套的数值结构);字符串等非数值字段
+    不构成"有效标定"的证据。所以 ``{"depth_scale": 0.001}`` 不算空白,
+    而全零的 intrinsic/rotation/translation 算。
+    """
+    if isinstance(doc, bool):
+        return True                    # bool 是 int 子类,必须先挡掉
+    if isinstance(doc, (int, float)):
+        return doc == 0
+    if isinstance(doc, dict):
+        return all(_calibration_is_blank(v) for v in doc.values())
+    if isinstance(doc, (list, tuple)):
+        return all(_calibration_is_blank(v) for v in doc)
+    return True
+
+
+def _default_calibration_docs() -> dict[str, Any]:
+    """读内置默认标定;文件缺失/损坏时返回 {} (调用方自行回落到空)。"""
+    try:
+        doc = json.loads(_DEFAULT_CALIBRATION_PATH.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return {}
+    if not isinstance(doc, dict):
+        return {}
+    return {str(doc.get("name") or _DEFAULT_CALIBRATION_PATH.stem): doc}
+
+
+def _calibration_docs(session_dir: str | Path,
+                      episode_id: str | None = None) -> dict[str, Any]:
+    """会话标定 → ``{名称: 标定内容}``,供导出侧写进数据集 meta。
+
+    目录口径与其余读取点一致(media_groups / depth_hand_3d / lerobot_v21 /
+    本文件的深度标定段):先看 ``calibration/``;给了 ``episode_id`` 时优先
+    ``meta/calibration/<episode_id>/``,再回退 ``meta/calibration/``。键名优先
+    取 JSON 里的 ``name`` 字段,否则用文件名 stem。
+
+    **批次标定缺失、或整份全零时回退内置默认标定**
+    (``processing/modules/calibration_default_head_stereo.json``)。不这么做的话,
+    导出的 meta 会声明一个从未生效的标定,下游照它复现 3D 全是错的。
+
+    只有**每一份**都空白才回退 —— 只要有一份像样的就用会话里的。
+    """
+    session_dir = Path(session_dir)
+    calib_dir = session_dir / "calibration"
+    if episode_id:
+        namespaced = session_dir / "meta" / "calibration" / str(episode_id)
+        if namespaced.is_dir():
+            calib_dir = namespaced
+    if not calib_dir.is_dir():
+        calib_dir = session_dir / "meta" / "calibration"
+
+    docs: dict[str, Any] = {}
+    if calib_dir.is_dir():
+        for path in sorted(calib_dir.glob("*.json")):
+            try:
+                value = json.loads(path.read_text(encoding="utf-8"))
+            except (OSError, ValueError, TypeError):
+                continue
+            if not isinstance(value, dict):
+                continue
+            docs[str(value.get("name") or path.stem)] = value
+
+    if docs and not all(_calibration_is_blank(v) for v in docs.values()):
+        return docs
+    return _default_calibration_docs() or docs
+
+
 def _device_metadata(session_dir: Path) -> list[dict]:
     """Return physical-device declarations for export-side pairing metadata."""
     for name in ("metadata.json", "meta/info.json"):
diff --git a/processor/app/localstore.py b/processor/app/localstore.py
index f1bc5051e23092cf387f0e35a0a6cb8feb653e21..c98bb2ddbcbd7c1f6154b2d0f7259bd499e0fbdd 100644
--- a/processor/app/localstore.py
+++ b/processor/app/localstore.py
@@ -704,6 +704,36 @@ def write_episode_state(episode_id: str, state: dict) -> None:
     invalidate_session_cache()
 
 
+def mutate_episode_state(
+    episode_id: str,
+    mutator: Callable[[dict], _MutationResult],
+) -> _MutationResult | None:
+    """Atomically read, mutate, and persist one episode's state.
+
+    ``read_episode_state`` / ``write_episode_state`` each take ``_lock`` on
+    their own, so a read-modify-write *across* them is not atomic.  Two writers
+    that overlap lose one side's fields — and when the lost field is ``status``,
+    a batch already pushed back to ``to_review`` can be silently restored to
+    ``reviewed``.
+
+    That window is not theoretical: the post-run quality tasks (the video gate
+    and data quality) both decode the same episode's video and therefore finish
+    within milliseconds of each other, which is exactly when they overlap.
+
+    Mutate the ``state`` dict in place inside ``mutator``; the return value is
+    passed straight through.  Returns ``None`` (and writes nothing) when the
+    episode has no state — callers must not invent one.
+    """
+    key = str(episode_id)
+    with _lock:
+        state = read_episode_state(key)
+        if not state:
+            return None
+        result = mutator(state)
+        write_episode_state(key, state)
+        return result
+
+
 def set_episode_status(episode_id: str, status: str) -> dict:
     with _lock:
         state = read_episode_state(episode_id)
diff --git a/processor/app/main.py b/processor/app/main.py
index b64a0dbc5398e205ae2dc20f572eb4c1acd70e1f..b96043c9de263c8455dca0d03dbbf4d7fd64dae5 100644
--- a/processor/app/main.py
+++ b/processor/app/main.py
@@ -12,8 +12,10 @@ from starlette.middleware.gzip import GZipMiddleware
 
 from app.config import settings
 from app.routes import ingestion, video, export, pages, session, annotations, dashboard, devices, auth
-from app.api import workflows, worker, projects, exceptions
+from app.routes import training
+from app.api import workflows, worker, projects, exceptions, quality
 from app.api import users
+from app.i18n import LanguageMiddleware
 from app.middleware import AuthMiddleware
 from app.paths import STATIC_DIR
 from app.version import __version__
@@ -75,7 +77,10 @@ app = FastAPI(
 app.add_middleware(GZipMiddleware, minimum_size=500)
 
 # Auth middleware — protect routes (after gzip, before everything else)
+# 语言中间件要在 Auth 之外(先于它)跑:鉴权失败跳登录页时,那个页面本身也要
+# 按 cookie 里的语言渲染。add_middleware 是**后加的先跑**,所以放在 Auth 之后加。
 app.add_middleware(AuthMiddleware)
+app.add_middleware(LanguageMiddleware)
 
 # 媒体/压缩文件下载不走 gzip:zip/mp4/parquet/hdf5 本身已是压缩格式,
 # 再压一遍只是烧 CPU(zlib level 9 压缩 180MB ≈ 10s),而且流式压缩会
@@ -109,6 +114,15 @@ async def static_cache_headers(request, call_next):
             response.headers["Cache-Control"] = "public, max-age=31536000, immutable"
         elif request.url.query:
             response.headers["Cache-Control"] = "public, max-age=86400"
+        elif path.startswith("/static/js/"):
+            # ES module 的相对 import 解析出来的 URL **不带查询串** —— 就算入口
+            # script 写了 ?v=,`import './api.js'` 也永远是同一个地址。给它任何
+            # 正数的 max-age,升级后都会出现「新入口 + 旧子模块」混用,直接抛
+            # TypeError。这类文件必须每次回源校验(未变则 304,开销可忽略)。
+            #
+            # 范围刻意收窄到 /static/js/:带 ?v= 的老脚本走上面那支不受影响;
+            # /static/ 顶层的第三方库(plyr.js、iconify-*)也不在范围里。
+            response.headers["Cache-Control"] = "no-cache"
         else:
             response.headers["Cache-Control"] = "public, max-age=3600"
     return response
@@ -139,4 +153,6 @@ app.include_router(workflows.router)
 app.include_router(worker.router)
 app.include_router(projects.router)
 app.include_router(exceptions.router)
+app.include_router(quality.router)
 app.include_router(users.router)
+app.include_router(training.router)
diff --git a/processor/app/processing/black_glove/hand_landmarker.task b/processor/app/processing/black_glove/hand_landmarker.task
new file mode 100644
index 0000000000000000000000000000000000000000..5ecab741879892d97c2f90bbf03bf55d7213db7c
--- /dev/null
+++ b/processor/app/processing/black_glove/hand_landmarker.task
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fbc2a30080c3c557093b5ddfc334698132eb341044ccee322ccf8bcf3607cde1
+size 7819105
diff --git a/processor/app/processing/cleaning/__init__.py b/processor/app/processing/cleaning/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..4f9867b6020cfb23132a2c86bc027e990b1ee7e3
--- /dev/null
+++ b/processor/app/processing/cleaning/__init__.py
@@ -0,0 +1,40 @@
+"""数据清洗 —— 按数据类型检查 episode 质量，异常退回人工审核。
+
+对应《以 Episode 为单位的数据清洗方案》(PDF)。核心设计:
+
+* **按信道声明需求**，不按"这是 UMI 还是 EGO" —— 检查项自己声明需要哪些信道，
+  实际有哪些信道由数据决定，两者匹配上才跑（见 ``checks.applicable_checks``）。
+* **四层结果** —— 数据流 / 时间区间 / episode / 训练用途（见 ``report.build_report``）。
+* **只出结论，不产出数据** —— 原始数据一字不改，也不生成 clean_v1 之类的副本。
+  区间信息完整保留在报告里，下游按 ``training_use`` 过滤即可。
+* **可插拔** —— 新增检查项 = 在 ``checks/`` 下放一个 .py（与 processing/modules 同款）。
+
+这个包的算法实现与工作流适配器是分开的，与 ``app/processing/black_glove`` 同构:
+
+    app/processing/cleaning/               ← 本包：契约 + 检查项 + 报告组装
+    app/processing/modules/data_cleaning.py ← 工作流节点（artifact 契约 + 端口 + 配置）
+"""
+
+from app.processing.cleaning.contract import (
+    DEVICE_MODALITIES, CAMERA_MODALITIES, CHANNELS, MODALITY_CHANNELS,
+    PASS, WARN, FAIL, PENDING, ERROR,
+    SEVERITY_ORDER, SEVERITY_LABELS,
+    Finding, Range, StreamResult,
+    channels_for, normalize_device_modality, worst, is_blocking,
+)
+from app.processing.cleaning.report import (
+    SCHEMA_VERSION, TRAINING_USE_RULES,
+    build_report, build_timeline, rollup_episode, rollup_training_use,
+    empty_report, passed_for,
+)
+
+__all__ = [
+    "DEVICE_MODALITIES", "CAMERA_MODALITIES", "CHANNELS", "MODALITY_CHANNELS",
+    "PASS", "WARN", "FAIL", "PENDING", "ERROR",
+    "SEVERITY_ORDER", "SEVERITY_LABELS",
+    "Finding", "Range", "StreamResult",
+    "channels_for", "normalize_device_modality", "worst", "is_blocking",
+    "SCHEMA_VERSION", "TRAINING_USE_RULES",
+    "build_report", "build_timeline", "rollup_episode", "rollup_training_use",
+    "empty_report", "passed_for",
+]
diff --git a/processor/app/processing/cleaning/checks/__init__.py b/processor/app/processing/cleaning/checks/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..659c8c9247f751031632395fb137b2613ac5f6f1
--- /dev/null
+++ b/processor/app/processing/cleaning/checks/__init__.py
@@ -0,0 +1,294 @@
+"""清洗检查项注册表 —— 一个文件 = 一个检查项，自动发现。
+
+与 app/processing/modules/ 同一套思路（见那里的 __init__.py）:
+
+    for _m in pkgutil.iter_modules(__path__):
+        importlib.import_module(...)
+
+新增检查项只需在 checks/ 下放一个 .py，内部用 @register_check 装饰类定义。
+
+检查项**按信道/模态声明需求**，不按"这个 episode 是 UMI 还是 EGO"。
+所以同一份检查项集合能自动适配任何数据组合:
+    UMI 夹爪来了 → 只跑需要 slam/force/gripper_state 的那些
+    触觉手套来了 → 只跑需要 tactile 的那些
+    EGO 来了     → 只跑需要 rgb/keypoints 的那些
+这就是 PDF §2「用采集模板决定跑哪些清洗规则」的落地方式。
+"""
+
+from __future__ import annotations
+
+import importlib
+import pkgutil
+from dataclasses import dataclass, field as dc_field
+from pathlib import Path
+from typing import Any, Callable, Iterable
+
+from app.processing.cleaning.contract import (
+    Finding, Range, PASS, WARN, FAIL, PENDING, ERROR,
+    SEVERITY_LABELS, worst, is_blocking,
+)
+
+__all__ = [
+    "CheckContext", "StreamEvidence", "CleaningCheck", "register_check",
+    "get_check", "all_checks", "all_check_specs", "applicable_checks",
+    "checks_for_device_cards",
+    "Finding", "Range", "PASS", "WARN", "FAIL", "PENDING", "ERROR",
+    "SEVERITY_LABELS", "worst", "is_blocking",
+]
+
+_registry: dict[str, "CleaningCheck"] = {}
+
+
+@dataclass(frozen=True)
+class StreamEvidence:
+    """一条数据流的证据 —— 由 evidence.py 采集，检查项**只读不采**。
+
+    把"读磁盘"和"做判断"分开，是让检查项可纯测的关键：测试直接构造本对象，
+    不需要真的 mp4 / parquet / cv2。
+    """
+
+    key: str                             # 流标识，如 "umi_rgb" / "slam_trajectory"
+    channel: str = ""                    # rgb | depth | slam | tactile | ...
+    path: str = ""                       # 相对批次目录的路径（仅用于报错定位）
+    # video_quality 的报告（黑屏/冻结/丢帧/解码）。非视频流为空 dict。
+    # 结构见 app/video_quality.py::_check_stream 的返回。
+    video: dict[str, Any] = dc_field(default_factory=dict)
+    # parquet 概览
+    columns: tuple[str, ...] = ()
+    rows: int = 0
+    fps: float = 0.0
+    # 逐帧数值序列（按帧对齐）。evidence.py 采集时**派生好的**，检查项不自己算。
+    # 例：SLAM 流 → {"pose": ((x,y,z,qx,qy,qz,qw), ...), "t": (...)}
+    #     夹爪流 → {"gripper_state": ((open, gripped, raw), ...),
+    #               "force": ((fx,fy,fz), ...)}
+    # ★ 派生复用 app/umi_slam_action.py 的函数，保证与 action 口径同源。
+    series: dict[str, tuple] = dc_field(default_factory=dict)
+
+
+@dataclass
+class CheckContext:
+    """检查项执行上下文。
+
+    IO 走注入（``read_columns`` / ``probe_video`` …），这样检查项本体是纯逻辑，
+    测试可以喂假数据而不需要真的 mp4 或 cv2。
+    """
+
+    batch_dir: Path                      # 批次目录（含 data/ videos/ meta/）
+    episode_id: str = ""
+    channels: frozenset[str] = frozenset()      # 实际存在的信道
+    modalities: tuple[str, ...] = ()            # 实际存在的设备模态
+    params: dict[str, Any] = dc_field(default_factory=dict)   # 节点配置里的阈值
+    duration_sec: float = 0.0
+    fps: float = 0.0
+    progress: Callable[[float], None] = lambda _value: None
+
+    # ── 证据包（evidence.py 采集好，检查项只读）────────────────
+    streams: tuple["StreamEvidence", ...] = ()
+    # parquet 侧的汇总：行数 / 时间戳列等，跨流共用的信息
+    data_rows: int = 0
+    data_columns: tuple[str, ...] = ()
+
+    # ── 注入式 IO ────────────────────────────────────────────
+    read_columns: Callable[[Path], list[str]] = lambda _p: []
+    read_head: Callable[[Path, int], list[dict]] = lambda _p, _n: []
+    probe_video: Callable[[Path], dict] = lambda _p: {}
+
+    # ── 证据查询便捷方法 ──────────────────────────────────────
+    def streams_of(self, channel: str) -> tuple["StreamEvidence", ...]:
+        """取某信道的全部流。检查项用它筛选自己要看的流。"""
+        return tuple(item for item in self.streams if item.channel == channel)
+
+    def param(self, name: str, default: Any = None) -> Any:
+        """取阈值配置；节点未配置时回落到检查项声明的默认值。"""
+        value = self.params.get(name)
+        return default if value is None else value
+
+
+class CleaningCheck:
+    """清洗检查项基类。
+
+    子类填元数据 + 实现 ``run()``，用 ``@register_check`` 装饰即可被自动发现。
+    """
+
+    slug: str = ""                       # "video.frame_drop"
+    label: str = ""
+    version: str = "1.0"                 # 改了要 bump —— 进 ruleset_revision
+    description: str = ""
+
+    # 必需的信道/设备模态；全部满足才跑
+    requires_channels: tuple[str, ...] = ()
+    requires_modality: tuple[str, ...] = ()
+    # 需要 ≥2 类设备模态同时存在（PDF 的"跨模态联合检查"）
+    cross_modal: bool = False
+
+    # ★ 本项属于哪些【设备卡片】—— 前端按它把检查项分到设置面板的各 tab。
+    #
+    # 取值来自 contract.DEVICE_MODALITIES，空元组 = 不绑定单个设备
+    # （跨设备检查用，它们只在"跨设备" tab 里出现）。
+    #
+    # 为什么用声明而不是靠目录分：同一个检查项往往多张卡片都要用 ——
+    # ``video.frame_drop`` 对 RGB Camera、RGB-D Camera、UMI Gripper 都成立，
+    # 按目录分只能放一处。声明式的话它能同时出现在多个 tab 里，
+    # 且各自的阈值配置互不影响（见 node.data.config.devices.<卡片>.params）。
+    device_cards: tuple[str, ...] = ()
+
+    default_severity: str = FAIL
+    # 阈值默认值 —— 节点配置可覆盖。PDF 明确要求"阈值不要照搬"，
+    # 所以这里给的是**平台初始值**，必须在真实数据上验证后再固化。
+    default_params: dict[str, Any] = dc_field(default_factory=dict)
+
+    def param(self, ctx: "CheckContext", name: str, fallback: Any = None) -> Any:
+        """取阈值。顺序：节点配置 → 本项声明的 default_params → fallback。
+
+        检查项一律用这个方法读阈值，不要写 ``ctx.params.get(..., 字面量)`` ——
+        那样声明的 default_params 就成了死代码，改它不生效。
+        """
+        value = (ctx.params or {}).get(name)
+        if value is not None:
+            return value
+        if name in self.default_params:
+            return self.default_params[name]
+        return fallback
+
+    def run(self, ctx: CheckContext) -> list[Finding]:
+        raise NotImplementedError
+
+    # ── 便捷构造 ─────────────────────────────────────────────
+    def finding(self, ctx: CheckContext, status: str, *,
+                stream: str = "", message: str = "",
+                metrics: dict | None = None,
+                ranges: Iterable[Range] = ()) -> Finding:
+        return Finding(
+            rule=self.slug, version=self.version, status=status,
+            scope="cross_modal" if self.cross_modal else "stream",
+            stream=stream, message=message, metrics=dict(metrics or {}),
+            ranges=tuple(ranges),
+        )
+
+
+def checks_for_device_cards(cards: Iterable[str]) -> dict[str, list[CleaningCheck]]:
+    """按【设备卡片】把检查项分组 —— 前端设置面板的 tab 就按这个渲染。
+
+    只返回传进来的卡片（= 工作流里实际连接的设备），未连接的不会出现。
+    一个检查项可能落在多个卡片下（如 ``video.frame_drop`` 对每种带摄像头的
+    设备都成立），各 tab 里的阈值配置互不影响。
+
+    例::
+
+        checks_for_device_cards(["rgbd_camera", "glove_sensor"])
+        → {"rgbd_camera": [video.frame_drop, video.black_screen, ...],
+           "glove_sensor": [glove.tactile_health, ...]}
+    """
+    wanted = [str(card) for card in cards]
+    grouped: dict[str, list[CleaningCheck]] = {card: [] for card in wanted}
+    for check in all_checks():
+        for card in check.device_cards:
+            if card in grouped:
+                grouped[card].append(check)
+    return grouped
+
+
+def register_check(cls):
+    """按 slug 注册检查项（装饰器）。"""
+    if not cls.slug:
+        raise ValueError(f"Check {cls.__name__} has no slug")
+    if cls.slug in _registry:
+        raise ValueError(f"Duplicate check slug: {cls.slug}")
+    _registry[cls.slug] = cls()
+    return cls
+
+
+def get_check(slug: str) -> CleaningCheck | None:
+    return _registry.get(slug)
+
+
+def all_checks() -> list[CleaningCheck]:
+    """全部已注册检查项（按 slug 排序，保证 ruleset_revision 稳定）。"""
+    return [_registry[key] for key in sorted(_registry)]
+
+
+def all_check_specs() -> list[dict]:
+    """检查项目录 —— 给 API / UI 用。
+
+    前端配置面板直接渲染这个：按 ``category`` 分组，每个检查项一行开关，
+    下面按 ``default_params`` 动态生成输入框。新增检查项前端零改动。
+    """
+    return [
+        {
+            "slug": check.slug,
+            # 分类取自 slug 前缀（video.frame_drop → video），与 checks/ 下的
+            # 目录名一致。前端按它分组。
+            "category": check.slug.split(".", 1)[0] if "." in check.slug else "other",
+            "label": check.label,
+            "version": check.version,
+            "description": check.description,
+            "requires_channels": list(check.requires_channels),
+            "requires_modality": list(check.requires_modality),
+            "cross_modal": check.cross_modal,
+            "device_cards": list(check.device_cards),
+            "default_severity": check.default_severity,
+            "default_params": dict(check.default_params),
+        }
+        for check in all_checks()
+    ]
+
+
+def applicable_checks(channels: Iterable[str],
+                      modalities: Iterable[str],
+                      *,
+                      cross_modal_active: bool = False,
+                      enabled: Iterable[str] | None = None,
+                      disabled: Iterable[str] | None = None) -> list[CleaningCheck]:
+    """筛出该跑哪些检查项。纯函数。
+
+    - ``requires_channels`` / ``requires_modality`` 必须**全部**具备
+    - ``cross_modal`` 的额外要求至少两类模态同时存在
+    - ``enabled`` / ``disabled`` 是节点配置里的按类型开关
+    """
+    have_channels = {str(item) for item in channels}
+    have_modalities = {str(item) for item in modalities}
+    allow = {str(item) for item in enabled} if enabled is not None else None
+    deny = {str(item) for item in disabled or ()}
+
+    result: list[CleaningCheck] = []
+    for check in all_checks():
+        if not set(check.requires_channels) <= have_channels:
+            continue
+        if not set(check.requires_modality) <= have_modalities:
+            continue
+        # ★ 设备卡片闸门 —— 声明了归属的检查项只在【对应设备】上跑。
+        #
+        # 光按信道筛不够：`umi.action_present` 只要"有 action 列"就满足，
+        # 而手套项目同样有一列（采集端写的全零占位）—— 结果 UMI 的检查跑到了
+        # 手套项目上、报出一个对方根本不关心的失败。
+        # 空 device_cards = 跨设备检查，不设闸门。
+        if check.device_cards and not (set(check.device_cards) & have_modalities):
+            continue
+        if check.cross_modal and not cross_modal_active:
+            continue
+        if allow is not None and check.slug not in allow:
+            continue
+        if check.slug in deny:
+            continue
+        result.append(check)
+    return result
+
+
+# 自动发现检查项。
+#
+# 用 walk_packages 而非 iter_modules —— 前者递归进子包，后者只认平铺的 .py。
+# 检查项按数据类型分类放在子包里，目录即分类，便于定位:
+#
+#     checks/video/frame_drop.py      视频
+#     checks/umi/slam_continuity.py   UMI 夹爪
+#     checks/glove/baseline_drift.py  触觉手套
+#     checks/ego/hand_side.py         EGO 头戴
+#     checks/depth/presence.py        深度
+#     checks/cross/video_data_sync.py 跨模态
+#
+# 子包不需要写任何注册代码 —— 空 __init__.py 即可，里面的模块会被自动导入。
+# 新增一项检查 = 在对应目录放一个 .py，注册表/节点/前端都不用改。
+for _info in pkgutil.walk_packages(__path__, prefix=f"{__name__}."):
+    if _info.name.rsplit(".", 1)[-1].startswith("_"):
+        continue
+    importlib.import_module(_info.name)
diff --git a/processor/app/processing/cleaning/checks/cross/__init__.py b/processor/app/processing/cleaning/checks/cross/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..8fef4fc41d0e15161e1778cea42b1d7f7d3e1479
--- /dev/null
+++ b/processor/app/processing/cleaning/checks/cross/__init__.py
@@ -0,0 +1,5 @@
+"""跨模态检查 —— 需要 ≥2 类设备模态同时存在。
+
+本目录下一个 .py = 一个检查项（用 @register_check 注册）。
+新增检查项只需在此放文件，注册表会自动发现（见上级 __init__.py 的 walk_packages）。
+"""
diff --git a/processor/app/processing/cleaning/checks/depth/__init__.py b/processor/app/processing/cleaning/checks/depth/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..3fd08de4146280f60e1486a3f51845282b21c368
--- /dev/null
+++ b/processor/app/processing/cleaning/checks/depth/__init__.py
@@ -0,0 +1,5 @@
+"""深度类检查 —— 是否存在/有效占比。
+
+本目录下一个 .py = 一个检查项（用 @register_check 注册）。
+新增检查项只需在此放文件，注册表会自动发现（见上级 __init__.py 的 walk_packages）。
+"""
diff --git a/processor/app/processing/cleaning/checks/ego/__init__.py b/processor/app/processing/cleaning/checks/ego/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..78bb8e37a6d7a9bb0e21bbc208238c26488d75e7
--- /dev/null
+++ b/processor/app/processing/cleaning/checks/ego/__init__.py
@@ -0,0 +1,5 @@
+"""EGO 头戴检查 —— 关键点/左右手/曝光。
+
+本目录下一个 .py = 一个检查项（用 @register_check 注册）。
+新增检查项只需在此放文件，注册表会自动发现（见上级 __init__.py 的 walk_packages）。
+"""
diff --git a/processor/app/processing/cleaning/checks/glove/__init__.py b/processor/app/processing/cleaning/checks/glove/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..b2b8fb9a25d5fd0590090a695eb5d784e1c73528
--- /dev/null
+++ b/processor/app/processing/cleaning/checks/glove/__init__.py
@@ -0,0 +1,5 @@
+"""触觉手套检查 —— 阵列健康/基线漂移/缺帧。
+
+本目录下一个 .py = 一个检查项（用 @register_check 注册）。
+新增检查项只需在此放文件，注册表会自动发现（见上级 __init__.py 的 walk_packages）。
+"""
diff --git a/processor/app/processing/cleaning/checks/glove/array_shape.py b/processor/app/processing/cleaning/checks/glove/array_shape.py
new file mode 100644
index 0000000000000000000000000000000000000000..2bd547ba27d5c50ec77dcd20615b7a63ae07cd3f
--- /dev/null
+++ b/processor/app/processing/cleaning/checks/glove/array_shape.py
@@ -0,0 +1,82 @@
+"""触觉阵列形状 —— 每帧必须是一整块 16×16。
+
+为什么值得单列一项
+------------------
+看着像废话，但它是**静默截断的哨兵**：采集层曾经因为宽度表里没有 ``tactile``
+而落到 3 的兜底值，256 个感应点被悄悄截成 3 个 —— 有列、有值、能加载，检查项
+只看得到 1% 的阵列，而且不报任何错。同一类问题还会再来（换手套、换固件、改列
+宽），所以这里明确把"整块阵列"写成契约。
+
+判据
+----
+每帧长度必须等于 ``expected_size``（默认 256 = 16×16）。空元组（``None`` 帧）
+也算不合格 —— 它意味着这一帧根本没读到。
+
+超出 ``max_bad_ratio`` 判 FAIL，否则 WARN：单帧缺失多半是偶发，系统性截断会是
+接近 100% 的比例。
+"""
+
+from __future__ import annotations
+
+from app.processing.cleaning.checks import (
+    CheckContext, CleaningCheck, register_check,
+    Finding, PASS, WARN, FAIL,
+)
+
+
+@register_check
+class GloveArrayShapeCheck(CleaningCheck):
+    slug = "glove.array_shape"
+    label = "Tactile Array Integrity"
+    version = "1.0"
+    description = "Every frame must be a complete 16×16 array (catches silent truncation)"
+
+    requires_channels = ("tactile",)
+    device_cards = ("glove_sensor",)
+    default_params = {
+        "expected_size": 256,     # 16×16
+        "max_bad_ratio": 0.01,    # 不合格帧超过 1% 判 FAIL
+    }
+    default_severity = WARN
+
+    def run(self, ctx: CheckContext) -> list[Finding]:
+        findings: list[Finding] = []
+        expected = int(self.param(ctx, "expected_size", 256))
+        max_ratio = float(self.param(ctx, "max_bad_ratio", 0.01))
+
+        for stream in ctx.streams_of("tactile"):
+            values = tuple(stream.series.get("tactile") or ())
+            total = len(values)
+            if not total:
+                # 列在但一行都没有 —— 与"列不存在"同义，交给别的检查去报
+                continue
+
+            bad = [len(item) for item in values if len(item) != expected]
+            ratio = len(bad) / total
+            # 出现过的长度 —— 一眼看出是被截断(如 3)还是别的形状
+            observed = sorted({len(item) for item in values})
+
+            if not bad:
+                findings.append(self.finding(
+                    ctx, PASS, stream=stream.key,
+                    message=f"{stream.key}: {expected}-wide for the whole episode",
+                    metrics={"frames": total, "expected_size": expected},
+                ))
+                continue
+
+            status = FAIL if ratio > max_ratio else WARN
+            findings.append(self.finding(
+                ctx, status, stream=stream.key,
+                message=(f"{stream.key}: {len(bad)}/{total} frames are not "
+                         f"{expected}-wide (observed lengths {observed[:5]})"),
+                metrics={
+                    "frames": total, "bad_frames": len(bad),
+                    "bad_ratio": round(ratio, 4),
+                    "expected_size": expected,
+                    "observed_sizes": observed[:10],
+                    "first_bad_frame": next(
+                        (i for i, item in enumerate(values) if len(item) != expected), None),
+                },
+            ))
+
+        return findings
diff --git a/processor/app/processing/cleaning/checks/glove/device_status.py b/processor/app/processing/cleaning/checks/glove/device_status.py
new file mode 100644
index 0000000000000000000000000000000000000000..39d49aae69161298aa984557c9ab2053846e82d7
--- /dev/null
+++ b/processor/app/processing/cleaning/checks/glove/device_status.py
@@ -0,0 +1,107 @@
+"""手套连接状态 —— 录制途中掉线。
+
+为什么重要
+----------
+手套掉线时阵列读数会**静默保持最后一个值**，看起来完全正常：有列、有 16×16、
+数值也在合理范围。只有状态列说实话。所以这一项是唯一能看见"设备其实没了"
+的检查。
+
+判定口径（分两种，因为状态词表只见过一个值）
+------------------------------------------
+``connected`` 是实测见到的**唯一**取值（S80C / D435 两个项目、全部集、全部帧）。
+其余词表未知，所以：
+
+  录制中途**状态发生变化**  → **FAIL**
+      无论变成什么，从"连着"变成别的就是掉线，这个判断不依赖词表。
+
+  全程恒定但不是 ``connected`` → **WARN**
+      可能是掉线，也可能是我们没见过的正常状态词（如 "ok"/"active"）。
+      词表未证实之前不拦批次 —— 拦错了用户会开始无脑点通过，比不拦更糟。
+
+  空字符串 → **WARN**（这一帧没读到状态）
+
+★ 阈值不放进 ``default_params``：词表是字符串，而前端设置面板把所有参数都渲染
+  成数字输入框。硬塞会把面板显示成 NaN。真需要可配时先改面板的类型支持。
+"""
+
+from __future__ import annotations
+
+from app.processing.cleaning.checks import (
+    CheckContext, CleaningCheck, register_check,
+    Finding, PASS, WARN, FAIL,
+)
+
+# 实测唯一见过的取值。其余一律按"词表未知"处理，不直接判失败。
+_HEALTHY = "connected"
+
+
+@register_check
+class GloveDeviceStatusCheck(CleaningCheck):
+    slug = "glove.device_status"
+    label = "Glove Connection"
+    version = "1.0"
+    description = "Device dropped out mid-recording (from status.*_glove)"
+
+    requires_channels = ("device_status",)
+    device_cards = ("glove_sensor",)
+    default_params: dict = {}
+    default_severity = FAIL
+
+    def run(self, ctx: CheckContext) -> list[Finding]:
+        findings: list[Finding] = []
+
+        for stream in ctx.streams_of("device_status"):
+            values = tuple(stream.series.get("device_status") or ())
+            # 流名就是那一列的最后一段（left_glove / right_glove），用它报位置
+            hand = stream.key
+            if not values:
+                findings.append(self.finding(
+                    ctx, WARN, stream=hand,
+                    message=f"{hand}: no status column data",
+                    metrics={"frames": 0},
+                ))
+                continue
+
+            blanks = sum(1 for item in values if not item)
+            distinct: list[str] = []
+            for item in values:
+                if item and item not in distinct:
+                    distinct.append(item)
+
+            # ① 中途变过 —— 与词表无关，见到即掉线
+            if len(distinct) > 1:
+                changes = [i for i in range(1, len(values)) if values[i] != values[i - 1]]
+                findings.append(self.finding(
+                    ctx, FAIL, stream=hand,
+                    message=(f"{hand}: status changed {len(changes)} times "
+                             f"during recording: {' -> '.join(distinct)}"),
+                    metrics={"frames": len(values), "distinct": distinct,
+                             "first_change_frame": changes[0] if changes else None,
+                             "blank_frames": blanks},
+                ))
+                continue
+
+            status = distinct[0] if distinct else ""
+            # ② 恒定但词表未知 / ③ 全空
+            if not status:
+                findings.append(self.finding(
+                    ctx, WARN, stream=hand,
+                    message=f"{hand}: status column is entirely blank",
+                    metrics={"frames": len(values), "blank_frames": blanks},
+                ))
+            elif status != _HEALTHY:
+                findings.append(self.finding(
+                    ctx, WARN, stream=hand,
+                    message=(f"{hand}: status is constantly {status!r} (only "
+                             f"{_HEALTHY!r} has ever been observed; vocabulary "
+                             f"unconfirmed - please verify manually)"),
+                    metrics={"frames": len(values), "status": status},
+                ))
+            else:
+                findings.append(self.finding(
+                    ctx, PASS, stream=hand,
+                    message=f"{hand}: {_HEALTHY} for the whole episode",
+                    metrics={"frames": len(values), "status": status},
+                ))
+
+        return findings
diff --git a/processor/app/processing/cleaning/checks/glove/frozen_array.py b/processor/app/processing/cleaning/checks/glove/frozen_array.py
new file mode 100644
index 0000000000000000000000000000000000000000..4d7c890df7e852a6f718deca01ed6babed98e057
--- /dev/null
+++ b/processor/app/processing/cleaning/checks/glove/frozen_array.py
@@ -0,0 +1,132 @@
+"""触觉阵列卡死 —— 设备停止更新，录制端却继续写。
+
+为什么重要
+----------
+这是最难发现的一类：**录制链路完全正常**。帧数对得上、时间戳连续、阵列是完整
+的 16×16、数值也在合理区间 —— 只是内容是**很久以前的那一帧**，一直没变。
+事后看数据一切正常，只有对比相邻帧才发现它静止了。
+
+判定口径（阈值有实测依据）
+--------------------------
+**静止本身不是问题**。实测设备更新率约 7.5Hz，而录制是 30fps，所以同一个值会
+**连续保持 4 帧** —— 这是正常的，不是卡死。
+
+  S80C 全部集：受压时的保持段长度**只有 4**（`{4}`，无其他取值）
+  D435 全部集：没有受压保持段
+
+（本文件统计的是"保持帧数"= 一个取值连续占了多少帧。同一现象另一种常见记法是
+"相邻帧相等的对数"，那个数是 3 —— 4 帧有 3 个间隔。两个数不矛盾，别混。）
+
+所以阈值有充足余量：``warn_frames=40``（约 1.3 秒）已经远超正常值。取 40 而不是
+"比 4 大一点"，是给将来换更新率更低的设备留空间 —— 卡死检测宁可慢一点发现，
+也不该把正常的低更新率设备全报一遍。
+
+★ 只在**受压时**才判。全零段天然"完全相同"（都是零），把它算进去的话，一集里
+  88% 都是全零帧的批次会报出几百帧的假静止（实测踩过：最长静止段 575 帧，全部
+  来自全零段）。
+"""
+
+from __future__ import annotations
+
+from app.processing.cleaning.checks import (
+    CheckContext, CleaningCheck, register_check,
+    Finding, PASS, WARN, FAIL,
+)
+from app.processing.cleaning.contract import Range
+
+# 报告的区间数上限 —— 真卡死时可能几百段，全塞进报告没意义
+_MAX_RANGES = 20
+
+
+def _static_runs(values: tuple, min_length: int) -> list[tuple[int, int]]:
+    """受压时完全相同的连续帧段 ``[(起始帧, 长度), ...]``。
+
+    只统计**非空且有压力**的帧：全零段天然完全相同，算进来会造出大片假区间。
+    """
+    runs: list[tuple[int, int]] = []
+    total = len(values)
+    index = 0
+    while index < total:
+        # 向后找同一取值的最长延伸
+        end = index
+        while end + 1 < total and values[end + 1] == values[index]:
+            end += 1
+        length = end - index + 1
+        frame = values[index]
+        pressed = bool(frame) and any(value > 0.0 for value in frame)
+        if length >= min_length and pressed:
+            runs.append((index, length))
+        index = end + 1
+    return runs
+
+
+@register_check
+class GloveFrozenArrayCheck(CleaningCheck):
+    slug = "glove.frozen_array"
+    label = "Tactile Array Frozen"
+    version = "1.0"
+    description = "Array unchanged for a long stretch while pressed (device stopped updating)"
+
+    requires_channels = ("tactile",)
+    device_cards = ("glove_sensor",)
+    default_params = {
+        "warn_frames": 40,        # 约 1.3 秒 @30fps；实测正常值 3 帧
+        "fail_frames": 300,       # 约 10 秒
+    }
+    default_severity = WARN
+
+    def run(self, ctx: CheckContext) -> list[Finding]:
+        findings: list[Finding] = []
+        fps = float(ctx.fps or 0.0) or 30.0
+        warn_frames = int(self.param(ctx, "warn_frames", 40))
+        fail_frames = int(self.param(ctx, "fail_frames", 300))
+
+        for stream in ctx.streams_of("tactile"):
+            values = tuple(stream.series.get("tactile") or ())
+            if not values:
+                continue
+
+            runs = _static_runs(values, warn_frames)
+            if not runs:
+                findings.append(self.finding(
+                    ctx, PASS, stream=stream.key,
+                    message=f"{stream.key}: no abnormal frozen stretch",
+                    metrics={"frames": len(values), "warn_frames": warn_frames},
+                ))
+                continue
+
+            longest = max(length for _, length in runs)
+            status = FAIL if longest >= fail_frames else WARN
+            ranges = tuple(
+                Range(
+                    start_sec=start / fps,
+                    end_sec=(start + length - 1) / fps,
+                    code=self.slug,
+                    severity=FAIL if length >= fail_frames else WARN,
+                    stream=stream.key,
+                    channel="tactile",
+                    start_frame=start,
+                    end_frame=start + length - 1,
+                    rule=self.slug,
+                    message=f"array unchanged for {length} frames",
+                    evidence={"frozen_frames": length},
+                )
+                for start, length in runs[:_MAX_RANGES]
+            )
+
+            findings.append(self.finding(
+                ctx, status, stream=stream.key,
+                message=(f"{stream.key}: {len(runs)} frozen stretches while "
+                         f"pressed (longest {longest} frames ~= {longest / fps:.1f}s)"),
+                metrics={
+                    "frames": len(values),
+                    "static_runs": len(runs),
+                    "longest_run_frames": longest,
+                    "longest_run_sec": round(longest / fps, 3),
+                    "warn_frames": warn_frames,
+                    "fail_frames": fail_frames,
+                },
+                ranges=ranges,
+            ))
+
+        return findings
diff --git a/processor/app/processing/cleaning/checks/glove/gate_floor.py b/processor/app/processing/cleaning/checks/glove/gate_floor.py
new file mode 100644
index 0000000000000000000000000000000000000000..ec5cb514e04cf0a3afff6546e943d08081e1246f
--- /dev/null
+++ b/processor/app/processing/cleaning/checks/glove/gate_floor.py
@@ -0,0 +1,87 @@
+"""触觉阵列取值下限 —— 检测**编码/量纲漂移**。
+
+为什么需要它
+------------
+实测这份手套数据有个硬门限：取值**要么是 0，要么 ≥ 500.02**，0 到 500 之间
+一个值都没有（从 0 直接跳到 508.09，没有过渡）。所以
+
+    ``0`` 的含义是"未接触"，**不是"力为零"**
+
+这个门限是固件行为，也是所有下游解读的前提。它一旦变了，**别的一切看起来都还
+正常**：列还在、还是 16×16、数还在合理区间 —— 但含义已经不同了。典型触发：
+
+  * 固件改版，直接输出原始 ADC（0–4095）而不是门限后的值
+  * 标定系数 ``scale`` 被应用了两次（或该应用而没应用）
+  * 换了另一款手套
+
+判据
+----
+非零值里低于 ``min_contact_value``（默认 500）的**占比**。
+超出 ``fail_ratio`` 判 FAIL，否则 WARN。实测两个项目全部集都是 0 个越界值，
+所以正常数据有充足余量。
+"""
+
+from __future__ import annotations
+
+from app.processing.cleaning.checks import (
+    CheckContext, CleaningCheck, register_check,
+    Finding, PASS, WARN, FAIL,
+)
+
+
+@register_check
+class GloveGateFloorCheck(CleaningCheck):
+    slug = "glove.gate_floor"
+    label = "Contact Threshold"
+    version = "1.0"
+    description = "Non-zero values must exceed the contact floor (catches silent encoding changes)"
+
+    requires_channels = ("tactile",)
+    device_cards = ("glove_sensor",)
+    default_params = {
+        # 实测最小非零值 500.02。留一点余量给固件微调，但远低于它就没有意义了
+        # —— 那正是"编码变了"的样子。
+        "min_contact_value": 500.0,
+        "fail_ratio": 0.05,       # 非零值里超过 5% 低于门限 → FAIL
+    }
+    default_severity = WARN
+
+    def run(self, ctx: CheckContext) -> list[Finding]:
+        findings: list[Finding] = []
+        floor = float(self.param(ctx, "min_contact_value", 500.0))
+        fail_ratio = float(self.param(ctx, "fail_ratio", 0.05))
+
+        for stream in ctx.streams_of("tactile"):
+            values = tuple(stream.series.get("tactile") or ())
+            flat = [float(v) for item in values if item for v in item]
+            nonzero = [v for v in flat if v > 0.0]
+            if not nonzero:
+                # 整集没有非零值 —— 那是 glove.no_contact 的事，这里不重复报
+                continue
+
+            below = [v for v in nonzero if v < floor]
+            ratio = len(below) / len(nonzero)
+
+            if not below:
+                findings.append(self.finding(
+                    ctx, PASS, stream=stream.key,
+                    message=f"{stream.key}: all non-zero values above the floor",
+                    metrics={"nonzero": len(nonzero), "min_value": round(min(nonzero), 3)},
+                ))
+                continue
+
+            status = FAIL if ratio > fail_ratio else WARN
+            findings.append(self.finding(
+                ctx, status, stream=stream.key,
+                message=(f"{stream.key}: {len(below)}/{len(nonzero)} non-zero values"
+                         f" are below the contact floor {floor:g} (min {min(below):.3f})"
+                         f" - the array encoding may have changed"),
+                metrics={
+                    "nonzero": len(nonzero), "below_floor": len(below),
+                    "below_ratio": round(ratio, 4),
+                    "min_contact_value": floor,
+                    "min_value": round(min(nonzero), 3),
+                },
+            ))
+
+        return findings
diff --git a/processor/app/processing/cleaning/checks/glove/no_contact.py b/processor/app/processing/cleaning/checks/glove/no_contact.py
new file mode 100644
index 0000000000000000000000000000000000000000..62d5cd972e024a2dda4086ced334fabf50b38eeb
--- /dev/null
+++ b/processor/app/processing/cleaning/checks/glove/no_contact.py
@@ -0,0 +1,70 @@
+"""整集无接触 —— 手套没戴上、没开机，或阵列整体失效。
+
+为什么单列一项
+--------------
+它和"某一根手指没碰"完全不同量级：后者是正常的（实测单集里 30–86% 的感应点
+全程为 0，因为只压到阵列的一部分）。**整只手套一帧都没有值**才是设备层面的问题。
+
+判据保守是故意的
+----------------
+实测最低的一集也有 **11.4%** 的帧存在压力，所以"全零"离正常值有极大余量，
+不需要为它编阈值。``min_active_ratio`` 默认 0.0 = 只在**整集恒为 0** 时才报，
+用户想更严可以往上调。
+
+只报 WARN：手套没戴上也可能是**操作员故意的**（这一段就是不给触觉），
+没到判失败的程度。
+"""
+
+from __future__ import annotations
+
+from app.processing.cleaning.checks import (
+    CheckContext, CleaningCheck, register_check,
+    Finding, PASS, WARN,
+)
+
+
+@register_check
+class GloveNoContactCheck(CleaningCheck):
+    slug = "glove.no_contact"
+    label = "No Contact"
+    version = "1.0"
+    description = "No pressure readings at all in this episode (not worn / not working)"
+
+    requires_channels = ("tactile",)
+    device_cards = ("glove_sensor",)
+    default_params = {
+        # 0.0 = 只在整集恒为 0 时报。实测最低 11.4%，余量充足。
+        "min_active_ratio": 0.0,
+    }
+    default_severity = WARN
+
+    def run(self, ctx: CheckContext) -> list[Finding]:
+        findings: list[Finding] = []
+        min_ratio = float(self.param(ctx, "min_active_ratio", 0.0))
+
+        for stream in ctx.streams_of("tactile"):
+            values = tuple(stream.series.get("tactile") or ())
+            if not values:
+                continue
+
+            active = sum(1 for frame in values
+                         if frame and any(value > 0.0 for value in frame))
+            ratio = active / len(values)
+
+            if ratio > min_ratio:
+                findings.append(self.finding(
+                    ctx, PASS, stream=stream.key,
+                    message=f"{stream.key}: has contact frames",
+                    metrics={"frames": len(values), "active_frames": active,
+                             "active_ratio": round(ratio, 4)},
+                ))
+            else:
+                findings.append(self.finding(
+                    ctx, WARN, stream=stream.key,
+                    message=(f"{stream.key}: no pressure readings in any of the "
+                             f"{len(values)} frames (not worn, or the array failed)"),
+                    metrics={"frames": len(values), "active_frames": active,
+                             "active_ratio": round(ratio, 4)},
+                ))
+
+        return findings
diff --git a/processor/app/processing/cleaning/checks/umi/__init__.py b/processor/app/processing/cleaning/checks/umi/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..29101c679b7b0589f958e307df0f99afb15a7871
--- /dev/null
+++ b/processor/app/processing/cleaning/checks/umi/__init__.py
@@ -0,0 +1,5 @@
+"""UMI 夹爪检查 —— SLAM 连续性/帧同步/夹爪量程。
+
+本目录下一个 .py = 一个检查项（用 @register_check 注册）。
+新增检查项只需在此放文件，注册表会自动发现（见上级 __init__.py 的 walk_packages）。
+"""
diff --git a/processor/app/processing/cleaning/checks/umi/action_present.py b/processor/app/processing/cleaning/checks/umi/action_present.py
new file mode 100644
index 0000000000000000000000000000000000000000..04fac07cc1a4a9bccd60f779f6b18e21ee39f98d
--- /dev/null
+++ b/processor/app/processing/cleaning/checks/umi/action_present.py
@@ -0,0 +1,118 @@
+"""action 有效性 —— 监督信号是否真的存在、是否可用。
+
+为什么重要
+----------
+**action 是 ACT 的监督信号**（``L1(预测, action)``）。没有它就算不出 loss。
+而它是**派生**出来的，不是采出来的，所以有四种失效方式：
+
+  ① 工作流没跑 / 跑失败 → action 还是采集端的**全零占位**
+     ★ 最阴险：有列、有 7 维、能加载，全是 0 —— 不报任何错
+  ② 整集派生失败（位姿样本不足）→ 列根本不写 → 导出时缺失
+     ★ 训练直接 KeyError（2026-09-11 踩过）
+  ③ 部分帧派生失败 → 那些帧的 action 是 null
+  ④ 派生成功但数值离群 → 归一化统计量被撑大（交给 umi.slam_continuity 解释）
+
+严重度
+------
+① ② 判 **FAIL** —— 没有监督信号，这一集对训练毫无价值。
+③ 判 **WARN** —— 部分帧缺失，剩余帧仍可训练。
+
+关于"全零"
+----------
+采集端在 UMI 硬件上写的就是全零（硬件不录 action），所以**必须区分**
+"还没派生"和"派生了但动作真的是零"。判据是**整列方差**：
+派生的 action 即使动作很小，帧间也会有变化；全零占位则方差严格为 0。
+"""
+
+from __future__ import annotations
+
+from app.processing.cleaning.checks import (
+    CheckContext, CleaningCheck, register_check,
+    Finding, PASS, WARN, FAIL,
+)
+
+
+@register_check
+class UmiActionPresentCheck(CleaningCheck):
+    slug = "umi.action_present"
+    label = "Action Validity"
+    version = "1.0"
+    description = "Missing supervision signal, all-zero placeholder, or frames never derived"
+
+    requires_channels = ("action",)
+
+    # 属于哪些设备卡片 —— 前端设置面板按它分 tab
+
+    device_cards = ("gripper_device",)
+
+    default_params = {
+        "min_coverage": 0.95,     # 有 action 的帧占比下限
+        "zero_epsilon": 1e-9,     # 判定"全零"的容差
+    }
+    default_severity = FAIL
+
+    def run(self, ctx: CheckContext) -> list[Finding]:
+        findings: list[Finding] = []
+        min_coverage = float(self.param(ctx, "min_coverage", 0.95))
+        epsilon = float(self.param(ctx, "zero_epsilon", 1e-9))
+
+        for stream in ctx.streams_of("action"):
+            rows = int(stream.rows or 0)
+            if not rows:
+                # 列存在但一行都没有 —— 与"列不存在"同义
+                findings.append(self.finding(
+                    ctx, FAIL, stream=stream.key,
+                    message="the action column has no data at all (derivation failed for the whole episode)",
+                    metrics={"rows": 0},
+                ))
+                continue
+
+            values = stream.series.get("action") or ()
+            usable = [item for item in values if item]
+            coverage = len(usable) / rows if rows else 0.0
+
+            # 整列方差 —— 区分"全零占位"和"动作真的很小"
+            flat: list[float] = []
+            for item in usable[:5000]:          # 抽样即可，全零占位必然处处为零
+                try:
+                    flat.extend(float(value) for value in item)
+                except (TypeError, ValueError):
+                    continue
+            spread = (max(flat) - min(flat)) if flat else 0.0
+            all_zero = spread <= epsilon
+
+            metrics = {
+                "rows": rows,
+                "usable": len(usable),
+                "coverage": round(coverage, 4),
+                "value_spread": spread,
+            }
+
+            if all_zero and usable:
+                findings.append(self.finding(
+                    ctx, FAIL, stream=stream.key,
+                    message="action is all zeros - likely still the recorder placeholder (workflow never ran, or derivation failed)",
+                    metrics=metrics,
+                ))
+                continue
+
+            if not usable:
+                findings.append(self.finding(
+                    ctx, FAIL, stream=stream.key,
+                    message="the action column exists but every value is empty (derivation produced no frames)",
+                    metrics=metrics,
+                ))
+                continue
+
+            if coverage < min_coverage:
+                findings.append(self.finding(
+                    ctx, WARN, stream=stream.key,
+                    message=f"only {len(usable)}/{rows} frames have action"
+                            f"（{coverage:.1%}），其余帧无监督信号",
+                    metrics=metrics,
+                ))
+                continue
+
+            findings.append(self.finding(ctx, PASS, stream=stream.key,
+                                         metrics=metrics))
+        return findings
diff --git a/processor/app/processing/cleaning/checks/umi/av_sync.py b/processor/app/processing/cleaning/checks/umi/av_sync.py
new file mode 100644
index 0000000000000000000000000000000000000000..4c0884d30458c589e6d8ffa60b4d9bd1ba720843
--- /dev/null
+++ b/processor/app/processing/cleaning/checks/umi/av_sync.py
@@ -0,0 +1,84 @@
+"""视频 ↔ 数据 帧同步 —— 各数据流的帧数与 RGB 视频是否一致。
+
+为什么重要
+----------
+UMI 的 action 按帧号对齐：第 i 行动作对应第 i 帧画面。任何一路数据与视频
+帧数不一致，都会让"看这一帧、预测下一步"的监督信号整体错位。
+
+与 ``video.frame_drop`` 的分工
+-----------------------------
+``video.frame_drop`` 比的是 **视频帧数 vs parquet 总行数**（整体量）。
+本项比的是 **每一路数据流各自的帧数**（结构性）——
+UMI 特有：Slam / gripper_state / force 是三条独立写入的列，
+采集端丢帧时可能只有其中一路短了，总数却对得上。
+
+这也是用户提的"整个的数据有没有根据 RGB 视频进行帧同步"。
+"""
+
+from __future__ import annotations
+
+from app.processing.cleaning.checks import (
+    CheckContext, CleaningCheck, register_check,
+    Finding, PASS, WARN, FAIL,
+)
+
+
+@register_check
+class UmiAvSyncCheck(CleaningCheck):
+    slug = "umi.av_sync"
+    label = "Video ↔ Data Frame Sync"
+    version = "1.0"
+    description = "Frame counts differ between data streams"
+
+    # 需要视频和至少一路数据同时存在才有意义。
+    # ★ 不加 cross_modal —— 它比的是【同一个 UMI 设备内部】的视频与各数据列，
+    #   不是两张设备卡片之间。requires_channels 已经把"必须有 rgb"表达清楚了，
+    #   再加 cross_modal 会把它错误地挤进"跨设备" tab。
+    requires_channels = ("rgb", "time")
+    # 属于哪些设备卡片 —— 前端设置面板按它分 tab
+    device_cards = ("gripper_device",)
+
+    default_params = {"tolerance": 2}
+    default_severity = FAIL
+
+    def run(self, ctx: CheckContext) -> list[Finding]:
+        # 视频侧：取第一路 RGB 的帧数作为基准
+        rgb_streams = ctx.streams_of("rgb")
+        if not rgb_streams:
+            return []
+        reference = None
+        reference_key = ""
+        for stream in rgb_streams:
+            frames = int((stream.video or {}).get("frame_count") or stream.rows or 0)
+            if frames:
+                reference, reference_key = frames, stream.key
+                break
+        if not reference:
+            return []
+
+        tolerance = int(self.param(ctx, "tolerance", 2))
+        drifted: dict[str, int] = {}
+        for stream in ctx.streams:
+            if stream.channel in ("rgb", "depth") or not stream.rows:
+                continue
+            if stream.key == reference_key:
+                continue
+            diff = abs(int(stream.rows) - reference)
+            if diff > tolerance:
+                drifted[stream.key] = int(stream.rows)
+
+        metrics = {"reference_stream": reference_key,
+                   "reference_frames": reference,
+                   "tolerance": tolerance,
+                   "drifted": drifted}
+
+        if not drifted:
+            return [self.finding(ctx, PASS, metrics=metrics)]
+
+        detail = "，".join(f"{key}={rows}" for key, rows in sorted(drifted.items()))
+        return [self.finding(
+            ctx,
+            FAIL,
+            message=f"these streams do not match the video frame count ({reference}): {detail}",
+            metrics=metrics,
+        )]
diff --git a/processor/app/processing/cleaning/checks/umi/gripper_range.py b/processor/app/processing/cleaning/checks/umi/gripper_range.py
new file mode 100644
index 0000000000000000000000000000000000000000..0b92af3b67923d2ce8f12eff123c689aa1850491
--- /dev/null
+++ b/processor/app/processing/cleaning/checks/umi/gripper_range.py
@@ -0,0 +1,157 @@
+"""夹爪量程与力基线 —— 开合度越界、力读数漂移。
+
+为什么重要
+----------
+**开合度越界**：``umi_slam_action._gripper_fraction()`` 会把开合度
+``np.clip(0, 1)``。也就是说越界值在派生 action 时被**静默夹掉**了 ——
+标定异常的集看起来"正常"，但动作里的夹爪维度是失真的。本项就是在
+clip 之前把它抓出来（原始列 ``observation.gripper_state[0]`` 是 0–100）。
+
+**力基线漂移**：夹爪没接触物体时力读数应在零附近。若整集的静息基线缓慢
+上移，说明传感器漂移/温漂，用力做阈值判断的模型会失真。
+
+判定口径
+--------
+开合度越界默认判 **WARN**（数据还能用，但要知道标定有问题）；
+力漂移默认判 **WARN**（同上）。两者都不拦数据，只报告。
+"""
+
+from __future__ import annotations
+
+import math
+
+from app.processing.cleaning.checks import (
+    CheckContext, CleaningCheck, register_check,
+    Finding, Range, PASS, WARN,
+)
+
+# 原始列里开合度的量程（采集端契约：[open_pct, gripped, fz_mn]）
+OPEN_PCT_MIN = 0.0
+OPEN_PCT_MAX = 100.0
+
+
+def _median(values: list[float]) -> float:
+    if not values:
+        return 0.0
+    ordered = sorted(values)
+    middle = len(ordered) // 2
+    if len(ordered) % 2:
+        return ordered[middle]
+    return (ordered[middle - 1] + ordered[middle]) / 2.0
+
+
+@register_check
+class UmiGripperRangeCheck(CleaningCheck):
+    slug = "umi.gripper_range"
+    label = "Gripper Range / Force Baseline"
+    version = "1.0"
+    description = "Gripper opening out of range, or force baseline drift"
+
+    requires_channels = ("gripper_state",)
+
+    # 属于哪些设备卡片 —— 前端设置面板按它分 tab
+
+    device_cards = ("gripper_device",)
+
+    default_params = {
+        "max_out_of_range_ratio": 0.01,   # 越界帧占比上限
+        "max_force_drift": 200.0,          # 前后半段基线差（mN）
+    }
+    default_severity = WARN
+
+    def run(self, ctx: CheckContext) -> list[Finding]:
+        findings: list[Finding] = []
+        max_ratio = float(self.param(ctx, "max_out_of_range_ratio", 0.01))
+        max_drift = float(self.param(ctx, "max_force_drift", 200.0))
+
+        for stream in ctx.streams_of("gripper_state"):
+            samples = stream.series.get("gripper_state") or ()
+            if not samples:
+                continue
+            fps = float(stream.fps or ctx.fps or 30.0)
+
+            out_of_range: list[Range] = []
+            values: list[float] = []
+            for index, sample in enumerate(samples):
+                if not sample:
+                    continue
+                try:
+                    pct = float(sample[0])
+                except (TypeError, ValueError, IndexError):
+                    continue
+                values.append(pct)
+                if OPEN_PCT_MIN <= pct <= OPEN_PCT_MAX:
+                    continue
+                out_of_range.append(Range(
+                    start_sec=index / fps, end_sec=(index + 1) / fps,
+                    code=self.slug, severity=WARN,
+                    stream=stream.key, channel="gripper_state",
+                    start_frame=index, end_frame=index,
+                    rule=self.slug,
+                    message=f"opening {pct:.1f} is outside the 0-100 range"
+                            f"（派生 action 时会被静默夹掉）",
+                    evidence={"open_pct": round(pct, 2)},
+                ))
+
+            if not values:
+                continue
+
+            ratio = len(out_of_range) / len(values)
+            metrics: dict = {
+                "samples": len(values),
+                "out_of_range": len(out_of_range),
+                "out_of_range_ratio": round(ratio, 4),
+                "min": round(min(values), 2),
+                "max": round(max(values), 2),
+            }
+
+            if ratio > max_ratio:
+                findings.append(self.finding(
+                    ctx, WARN, stream=stream.key,
+                    message=f"{len(out_of_range)}/{len(values)} frames out of range"
+                            f"（{ratio:.1%}），标定可能异常",
+                    metrics=metrics,
+                    ranges=out_of_range[:50],
+                ))
+            else:
+                findings.append(self.finding(ctx, PASS, stream=stream.key,
+                                             metrics=metrics))
+
+        # 力基线漂移 —— 独立的信道，单独一轮
+        for stream in ctx.streams_of("force"):
+            forces = stream.series.get("force") or ()
+            if len(forces) < 20:
+                continue
+            magnitudes = []
+            for sample in forces:
+                if not sample:
+                    continue
+                try:
+                    magnitudes.append(_norm3(sample))
+                except (TypeError, ValueError):
+                    continue
+            if len(magnitudes) < 20:
+                continue
+
+            half = len(magnitudes) // 2
+            first, second = _median(magnitudes[:half]), _median(magnitudes[half:])
+            drift = abs(second - first)
+            metrics = {"baseline_first_half": round(first, 2),
+                       "baseline_second_half": round(second, 2),
+                       "drift_mN": round(drift, 2)}
+
+            if drift <= max_drift:
+                findings.append(self.finding(ctx, PASS, stream=stream.key,
+                                             metrics=metrics))
+                continue
+            findings.append(self.finding(
+                ctx, WARN, stream=stream.key,
+                message=f"force baseline drift {drift:.0f} mN"
+                        f"（前半 {first:.0f} → 后半 {second:.0f}），疑似传感器漂移",
+                metrics=metrics,
+            ))
+        return findings
+
+
+def _norm3(sample) -> float:
+    return math.sqrt(sum(float(value) ** 2 for value in sample[:3]))
diff --git a/processor/app/processing/cleaning/checks/umi/slam_continuity.py b/processor/app/processing/cleaning/checks/umi/slam_continuity.py
new file mode 100644
index 0000000000000000000000000000000000000000..8a98cc92b2ee36f507d810fb146291fd0f943739
--- /dev/null
+++ b/processor/app/processing/cleaning/checks/umi/slam_continuity.py
@@ -0,0 +1,158 @@
+"""SLAM 轨迹连续性 —— 相邻位姿之间出现不可能的速度/角速度跳变。
+
+为什么重要
+----------
+UMI 的 action 是从 SLAM 位姿**差分**出来的（见 ``app/umi_slam_action.py``）。
+位姿一旦跳变，差分出来的动作就是一个巨大的假位移；模型会学到"突然瞬移"。
+官方也承认 ORB_SLAM3 是整条流水线"最脆弱的部分"。
+
+常见来源：视觉跟踪丢失后重定位、弱纹理/暗光、快速转手腕导致运动模糊。
+
+判定分两档（这正是本项的设计，不是"只报告不判定"）
+--------------------------------------------------
+方案明确警告：「SLAM 单帧跳了 113.9 毫米可以作为问题线索，但不能马上定成
+全平台红线」。113.9mm 来自本平台实测（`umi_slam_action.py` 的 docstring 记录了
+插值方案会横跨重定位跳变），它是**观测线索**不是阈值来源。
+
+所以**单次跳变只判 WARN** —— 一次重定位不该废掉一整集（实测
+UMIGripper_Action_AI_000001 就有一次真实的 6.8 m/s 跳变，属"该警告、不该拦"）。
+
+但跳变**达到 ``fail_jumps``（默认 10 处）判 FAIL**：那已经不是偶发重定位，而是
+SLAM 全程没跟住，差分出来的动作整段都是假的 —— 这种数据确实不能训，按"数据不对
+就拦回人工审核"处理。
+
+★ 本文件的旧注释曾写成"默认判 WARN 而非 FAIL……只报告"，与实现不符（实现一直
+  是分档的）。以本段为准。阈值本身仍须用人工确认过的好/坏数据校准后才固化。
+"""
+
+from __future__ import annotations
+
+import math
+
+from app.processing.cleaning.checks import (
+    CheckContext, CleaningCheck, register_check,
+    Finding, Range, PASS, WARN, FAIL,
+)
+from app.processing.cleaning.contract import pose_is_valid
+
+
+def _norm3(vector) -> float:
+    return math.sqrt(sum(float(value) ** 2 for value in vector[:3]))
+
+
+@register_check
+class UmiSlamContinuityCheck(CleaningCheck):
+    slug = "umi.slam_continuity"
+    label = "SLAM Trajectory Continuity"
+    version = "1.0"
+    description = "Impossible linear or angular velocity between adjacent poses"
+
+    requires_channels = ("slam",)
+
+    # 属于哪些设备卡片 —— 前端设置面板按它分 tab
+
+    device_cards = ("gripper_device",)
+
+    # 单位：米/秒、弧度/秒。人手快速挥动约 2 m/s、6 rad/s 量级，
+    # 这里给的是"明显超出人类可达"的起点值。
+    #
+    # 判级用两个计数阈值，而不是"速度超过多少倍"—— 后者在默认值下会退化成
+    # "任何一次跳变都判失败"（一次跳变就废掉一整集太重了）。实测 episode 1
+    # 帧 293 有一次 6.8 m/s 的真实重定位跳变，属"该警告、但不该直接拦"。
+    default_params = {
+        "max_linear_mps": 5.0,
+        "max_angular_rps": 20.0,
+        "warn_jumps": 1,      # 达到此数即警告
+        "fail_jumps": 10,     # 达到此数判失败（说明 SLAM 全程不稳）
+    }
+    default_severity = WARN
+
+    def run(self, ctx: CheckContext) -> list[Finding]:
+        findings: list[Finding] = []
+        max_linear = float(self.param(ctx, "max_linear_mps", 5.0))
+        max_angular = float(self.param(ctx, "max_angular_rps", 20.0))
+        fail_jumps = int(self.param(ctx, "fail_jumps", 10))
+
+        for stream in ctx.streams_of("slam"):
+            poses = stream.series.get("pose") or ()
+            stamps = stream.series.get("t") or ()
+            if len(poses) < 2:
+                continue
+            fps = float(stream.fps or ctx.fps or 30.0)
+            dt_default = 1.0 / fps if fps > 0 else 1.0 / 30.0
+
+            jumps: list[Range] = []
+            peak_linear = 0.0
+            peak_angular = 0.0
+
+            for index in range(1, len(poses)):
+                prev, cur = poses[index - 1], poses[index]
+                # ★ 必须用 pose_is_valid，不能只判长度。
+                #
+                # 全零占位位姿长度也是 7，能过 len 检查，但四元数模为 0 ——
+                # 两个零四元数点积为 0，acos(0)=π/2 ⇒ 夹角 180° ⇒ 每帧
+                # 94.25 rad/s。实测 Test94 的 slam_pose 有 437/599 行是全零，
+                # 于是 599 帧报出 465 处"跳变"，整集被假判 FAIL 并拦住批次。
+                if not pose_is_valid(prev) or not pose_is_valid(cur):
+                    continue
+                try:
+                    delta = [float(cur[i]) - float(prev[i]) for i in range(3)]
+                except (TypeError, ValueError):
+                    continue
+
+                # 时间间隔取真实时间戳；缺失时回落到 fps
+                dt = dt_default
+                if len(stamps) > index and stamps[index] and stamps[index - 1]:
+                    try:
+                        span = float(stamps[index]) - float(stamps[index - 1])
+                        if 0 < span < 1.0:      # 超过 1 秒说明中间丢了整段
+                            dt = span
+                    except (TypeError, ValueError):
+                        pass
+
+                linear = _norm3(delta) / dt
+                # 姿态差：四元数点积 → 夹角。|dot| 接近 1 表示几乎没转。
+                dot = sum(float(prev[3 + i]) * float(cur[3 + i]) for i in range(4))
+                angle = 2.0 * math.acos(max(-1.0, min(1.0, abs(dot))))
+                angular = angle / dt
+
+                peak_linear = max(peak_linear, linear)
+                peak_angular = max(peak_angular, angular)
+
+                if linear <= max_linear and angular <= max_angular:
+                    continue
+                jumps.append(Range(
+                    start_sec=index / fps, end_sec=(index + 1) / fps,
+                    code=self.slug, severity=WARN,
+                    stream=stream.key, channel="slam",
+                    start_frame=index - 1, end_frame=index,
+                    rule=self.slug,
+                    message=f"pose jump at frame {index}: "
+                            f"{_norm3(delta) * 1000:.1f}mm / {math.degrees(angle):.1f}°",
+                    evidence={"linear_mps": round(linear, 3),
+                              "angular_rps": round(angular, 3)},
+                ))
+
+            metrics = {
+                "frames": len(poses),
+                "jumps": len(jumps),
+                "peak_linear_mps": round(peak_linear, 3),
+                "peak_angular_rps": round(peak_angular, 3),
+            }
+            if not jumps:
+                findings.append(self.finding(ctx, PASS, stream=stream.key,
+                                             metrics=metrics))
+                continue
+
+            findings.append(self.finding(
+                ctx,
+                FAIL if len(jumps) >= fail_jumps else WARN,
+                stream=stream.key,
+                message=f"{len(jumps)} pose jumps, peak "
+                        f"{peak_linear:.1f} m/s / "
+                        f"{math.degrees(peak_angular):.0f} deg/s "
+                        f"(verify against the video)",
+                metrics=metrics,
+                ranges=jumps[:50],       # 报告里最多带 50 个，避免 JSON 过大
+            ))
+        return findings
diff --git a/processor/app/processing/cleaning/checks/umi/slam_coverage.py b/processor/app/processing/cleaning/checks/umi/slam_coverage.py
new file mode 100644
index 0000000000000000000000000000000000000000..496cf50ba3718c74bfa2a1c57b27a0f42bb3504a
--- /dev/null
+++ b/processor/app/processing/cleaning/checks/umi/slam_coverage.py
@@ -0,0 +1,105 @@
+"""SLAM 位姿覆盖率 —— 多少帧的位姿是**插值补出来的**。
+
+★ 别把"自己格子为空"当成问题
+--------------------------------
+采集端的位姿流是 20/20/60ms **突发**，而数据帧是 1/30s 均匀网格。某个
+33ms 窗口里一个位姿都没到，这一格的缓冲就是空的 —— **这是设计使然**。
+
+实测（52 集训练集）：**28.2% 的帧自己格子为空**（p90 32.8%）。
+第一版检查项拿这个当指标，结果 52/52 集全部报警 —— 典型的阈值照搬。
+
+真正该关心的是：既没有本地样本、**相邻格子也没有**，只能靠插值硬补的帧。
+``poses_from_trajectory`` 汇总所有格子按时间取最近样本，实测能救回绝大多数
+空帧，只有剩下的才插值。
+
+实测（同上，4 集抽样）：
+    集 0: 插值  2/326 = 0.6%
+    集 1: 插值 17/313 = 5.4%   ← ★ 明显高于其他集
+    集 2: 插值  4/384 = 1.0%
+    集 7: 插值  0/308 = 0.0%
+
+★ 集 1 正是 ``umi.slam_continuity`` 报出 6.8 m/s 跳变的那一集 ——
+两个独立指标指向同一件事：那一集 SLAM 跟丢过。
+所以这两项要**一起看**：插值率高 + 有跳变 = 基本可以确定是跟踪丢失。
+
+判定口径
+--------
+默认 **WARN**：插值帧本身不代表数据不可用（插值的是平滑轨迹），
+它是"这段 SLAM 不稳"的信号。
+"""
+
+from __future__ import annotations
+
+from app.processing.cleaning.checks import (
+    CheckContext, CleaningCheck, register_check,
+    Finding, PASS, WARN, FAIL,
+)
+
+
+@register_check
+class UmiSlamCoverageCheck(CleaningCheck):
+    slug = "umi.slam_coverage"
+    label = "SLAM Pose Coverage"
+    version = "2.0"
+    description = "Poses only recoverable by interpolation (no real sample in nearby slots)"
+
+    requires_channels = ("slam",)
+
+    # 属于哪些设备卡片 —— 前端设置面板按它分 tab
+
+    device_cards = ("gripper_device",)
+
+    # 实测正常集 0~1%，异常集 5.4%。起点值取 2% / 10%：
+    # 低于 2% 属正常抖动，超过 10% 说明这一段基本没有真实位姿。
+    # ★ 这两个数是拿 52 集训练集跑出来的，不是拍脑袋 —— 但样本只有 52 集，
+    #   上生产前应拿更多数据复核。
+    default_params = {
+        "warn_ratio": 0.02,
+        "fail_ratio": 0.10,
+    }
+    default_severity = WARN
+
+    def run(self, ctx: CheckContext) -> list[Finding]:
+        findings: list[Finding] = []
+        warn_ratio = float(self.param(ctx, "warn_ratio", 0.02))
+        fail_ratio = float(self.param(ctx, "fail_ratio", 0.10))
+
+        for stream in ctx.streams_of("slam"):
+            # evidence 提供两种粒度：
+            #   "interpolated" —— 逐帧布尔（本检查项用这个，能出区间）
+            #   "coverage"     —— 直接给汇总数字（{"frames","direct","interpolated"}）
+            flags = stream.series.get("interpolated")
+            summary = stream.series.get("coverage") or {}
+            if flags:
+                total = len(flags)
+                count = sum(1 for item in flags if item)
+            elif summary:
+                total = int(summary.get("frames") or 0)
+                count = int(summary.get("interpolated") or 0)
+            else:
+                continue
+            if not total:
+                continue
+            ratio = count / total
+
+            metrics = {
+                "frames": total,
+                "interpolated_frames": count,
+                "interpolated_ratio": round(ratio, 4),
+            }
+
+            if ratio < warn_ratio:
+                findings.append(self.finding(ctx, PASS, stream=stream.key,
+                                             metrics=metrics))
+                continue
+            findings.append(self.finding(
+                ctx,
+                FAIL if ratio >= fail_ratio else WARN,
+                stream=stream.key,
+                message=f"{count}/{total} poses ({ratio:.1%}) are interpolation-"
+                        f"only - no real sample in the local or neighbouring slots,"
+                        f" which suggests SLAM lost tracking (review together with"
+                        f" SLAM Trajectory Continuity)",
+                metrics=metrics,
+            ))
+        return findings
diff --git a/processor/app/processing/cleaning/checks/video/__init__.py b/processor/app/processing/cleaning/checks/video/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..8718f4ac343e8e67615ede5276b177ae39408d9a
--- /dev/null
+++ b/processor/app/processing/cleaning/checks/video/__init__.py
@@ -0,0 +1,5 @@
+"""视频类检查 —— 解码/黑屏/冻结/丢帧。
+
+本目录下一个 .py = 一个检查项（用 @register_check 注册）。
+新增检查项只需在此放文件，注册表会自动发现（见上级 __init__.py 的 walk_packages）。
+"""
diff --git a/processor/app/processing/cleaning/checks/video/black_screen.py b/processor/app/processing/cleaning/checks/video/black_screen.py
new file mode 100644
index 0000000000000000000000000000000000000000..85cacce7e9a65871e8148fbb8b4c9afdca9863d1
--- /dev/null
+++ b/processor/app/processing/cleaning/checks/video/black_screen.py
@@ -0,0 +1,86 @@
+"""黑屏 —— 镜头被挡、补光灯没开、或采集程序写了空帧。
+
+为什么重要
+----------
+黑屏段里的视觉信息为零。模型在这些帧上学到的是"画面全黑时该做什么"，
+通常是噪声；若黑屏占比高，还会把图像归一化统计量带偏。
+
+判定口径
+----------
+检测本身由 ``app/video_quality.py`` 完成（按灰度均值 + 暗像素占比双阈值）。
+本检查项只负责把它的区间翻成统一的 Finding/Range 并套用节点配置的阈值 ——
+**不重复实现检测算法**，避免两处口径漂移。
+"""
+
+from __future__ import annotations
+
+from app.processing.cleaning.contract import VIDEO_CAPABLE_MODALITIES
+from app.processing.cleaning.checks import (
+    CheckContext, CleaningCheck, register_check,
+    Finding, Range, PASS, WARN, FAIL,
+)
+
+
+@register_check
+class VideoBlackScreenCheck(CleaningCheck):
+    slug = "video.black_screen"
+    label = "Black Screen"
+    version = "1.0"
+    description = "Frame is fully or nearly black"
+
+    requires_channels = ("rgb",)
+
+    # 属于哪些设备卡片 —— 前端设置面板按它分 tab
+
+    device_cards = VIDEO_CAPABLE_MODALITIES
+
+    default_params = {"min_sec": 0.5, "fail_ratio": 0.05}
+    default_severity = WARN
+
+    def run(self, ctx: CheckContext) -> list[Finding]:
+        findings: list[Finding] = []
+        for stream in ctx.streams_of("rgb"):
+            report = stream.video or {}
+            ranges = report.get("black_ranges") or []
+            if not ranges:
+                continue
+
+            fps = float(report.get("fps") or stream.fps or ctx.fps or 30.0)
+            min_sec = float(self.param(ctx, "min_sec", 0.5))
+            converted: list[Range] = []
+            total_sec = 0.0
+            for item in ranges:
+                try:
+                    start, end = float(item[0]), float(item[1])
+                except (TypeError, ValueError, IndexError):
+                    continue
+                if end - start < min_sec:
+                    continue
+                total_sec += end - start
+                converted.append(Range(
+                    start_sec=start, end_sec=end,
+                    code=self.slug, severity=WARN,
+                    stream=stream.key, channel="rgb",
+                    start_frame=int(start * fps), end_frame=int(end * fps),
+                    rule=self.slug,
+                    message=f"black screen for {end - start:.1f}s",
+                ))
+
+            if not converted:
+                continue
+
+            duration = float(ctx.duration_sec or 0.0)
+            ratio = (total_sec / duration) if duration > 0 else 0.0
+            fail_ratio = float(self.param(ctx, "fail_ratio", 0.05))
+            status = FAIL if ratio >= fail_ratio else WARN
+
+            findings.append(self.finding(
+                ctx, status, stream=stream.key,
+                message=f"{len(converted)} black-screen stretches, {total_sec:.1f}s total"
+                        + (f"（占 {ratio:.1%}）" if duration else ""),
+                metrics={"segments": len(converted),
+                         "total_sec": round(total_sec, 3),
+                         "ratio": round(ratio, 4)},
+                ranges=converted,
+            ))
+        return findings
diff --git a/processor/app/processing/cleaning/checks/video/decode_error.py b/processor/app/processing/cleaning/checks/video/decode_error.py
new file mode 100644
index 0000000000000000000000000000000000000000..5a7ea67353c0af8cd2531792f0f791cb1db2a1c1
--- /dev/null
+++ b/processor/app/processing/cleaning/checks/video/decode_error.py
@@ -0,0 +1,99 @@
+"""解码失败 / 文件打不开 —— 最硬的一类问题。
+
+为什么重要
+----------
+解码失败意味着这段视频在任何下游都无法使用：训练读取会抛异常、浏览器预览
+会黑屏、导出会失败。而且它常常是文件损坏的前兆 —— 与其等到训练时才发现，
+不如在入库后就标出来。
+
+严重度
+------
+本项默认 **FAIL**（其余视频检查默认 WARN）：能解码是"数据可用"的最低门槛，
+不存在"阈值调松就能接受"的余地。
+
+opencv 不可用是**环境问题不是数据问题** —— 判 ERROR（处理失败）而不是 FAIL，
+避免把环境缺依赖记成数据质量事故。
+"""
+
+from __future__ import annotations
+
+from app.processing.cleaning.contract import VIDEO_CAPABLE_MODALITIES
+from app.processing.cleaning.checks import (
+    CheckContext, CleaningCheck, register_check,
+    Finding, Range, PASS, FAIL, ERROR,
+)
+
+# 这些 reason 说明"没检查成"，不是"数据坏了"
+_ENV_REASONS = {"opencv_unavailable"}
+
+
+@register_check
+class VideoDecodeErrorCheck(CleaningCheck):
+    slug = "video.decode_error"
+    label = "Decode Errors"
+    version = "1.0"
+    description = "Video won't open, or contains undecodable frames"
+
+    requires_channels = ("rgb",)
+
+    # 属于哪些设备卡片 —— 前端设置面板按它分 tab
+
+    device_cards = VIDEO_CAPABLE_MODALITIES
+
+    default_params = {"max_errors": 0}
+    default_severity = FAIL
+
+    def run(self, ctx: CheckContext) -> list[Finding]:
+        findings: list[Finding] = []
+        for stream in ctx.streams_of("rgb"):
+            report = stream.video or {}
+            if not report:
+                continue
+
+            reason = str(report.get("reason") or "")
+            if reason in _ENV_REASONS:
+                findings.append(self.finding(
+                    ctx, ERROR, stream=stream.key,
+                    message="OpenCV unavailable, could not check (environment issue, not a data issue)",
+                    metrics={"reason": reason},
+                ))
+                continue
+
+            # 整条流打不开 —— 比丢几帧严重得多
+            if reason in ("video_open_failed", "video_metadata_invalid"):
+                findings.append(self.finding(
+                    ctx, FAIL, stream=stream.key,
+                    message=f"video cannot be opened or has invalid metadata ({reason})",
+                    metrics={"reason": reason,
+                             "error": str(report.get("error") or "")[:200]},
+                ))
+                continue
+
+            count = int(report.get("decode_error_count") or 0)
+            max_errors = int(self.param(ctx, "max_errors", 0))
+            if count <= max_errors:
+                findings.append(self.finding(ctx, PASS, stream=stream.key,
+                                             metrics={"decode_error_count": count}))
+                continue
+
+            fps = float(report.get("fps") or stream.fps or ctx.fps or 30.0)
+            frames = [int(item) for item in (report.get("decode_errors") or [])
+                      if isinstance(item, (int, float))]
+            # 每个失败帧给一个零长度区间 —— 时间轴上就是一个可点击的红点
+            marks = tuple(
+                Range(start_sec=frame / fps, end_sec=frame / fps,
+                      code=self.slug, severity=FAIL,
+                      stream=stream.key, channel="rgb",
+                      start_frame=frame, end_frame=frame,
+                      rule=self.slug, message=f"frame {frame} failed to decode")
+                for frame in frames[:20]
+            )
+            findings.append(self.finding(
+                ctx, FAIL, stream=stream.key,
+                message=f"{count} frames failed to decode"
+                        + (f"（示例：{frames[:5]}）" if frames else ""),
+                metrics={"decode_error_count": count,
+                         "sample_frames": frames[:20]},
+                ranges=marks,
+            ))
+        return findings
diff --git a/processor/app/processing/cleaning/checks/video/frame_drop.py b/processor/app/processing/cleaning/checks/video/frame_drop.py
new file mode 100644
index 0000000000000000000000000000000000000000..9ee41de9dc4f8f32b1d1c08935a3478a7995e6c9
--- /dev/null
+++ b/processor/app/processing/cleaning/checks/video/frame_drop.py
@@ -0,0 +1,82 @@
+"""丢帧 / 帧数对齐 —— 视频帧数与 parquet 行数不一致。
+
+为什么重要
+----------
+两者不一致时，按帧号取动作会整体错位；漏帧则会让模型学到"同一帧对应两个
+动作"。真实的采集侧表现是视频比数据少几帧（编码器丢帧）或多几帧（尾部多录）。
+
+判定口径
+--------
+容差取 ``max(tolerance_min, data_rows × tolerance_ratio)``：
+小批次按绝对帧数兜底（默认 2 帧），大批次按比例（默认 0.5%）。
+超出容差 5 倍判 FAIL，否则 WARN —— 差几帧和差几百帧不是一回事。
+"""
+
+from __future__ import annotations
+
+from app.processing.cleaning.contract import VIDEO_CAPABLE_MODALITIES
+from app.processing.cleaning.checks import (
+    CheckContext, CleaningCheck, register_check,
+    Finding, PASS, WARN, FAIL,
+)
+
+
+@register_check
+class VideoFrameDropCheck(CleaningCheck):
+    slug = "video.frame_drop"
+    label = "Frame Drop / Count Alignment"
+    version = "1.0"
+    description = "Video frame count differs from data row count"
+
+    requires_channels = ("rgb",)
+
+    # 属于哪些设备卡片 —— 前端设置面板按它分 tab
+
+    device_cards = VIDEO_CAPABLE_MODALITIES
+
+    # 阈值默认值 —— 节点配置可覆盖。
+    # 方案要求「阈值不要照搬」：这是平台起点值，必须用人工确认过的好/坏数据验证。
+    default_params = {"tolerance_ratio": 0.005, "tolerance_min": 2}
+    default_severity = WARN
+
+    def run(self, ctx: CheckContext) -> list[Finding]:
+        findings: list[Finding] = []
+        for stream in ctx.streams_of("rgb"):
+            report = stream.video or {}
+            if not report:
+                continue
+            # 打不开/读不了元数据的流不算"丢帧问题"，交给 video.decode_error
+            if report.get("reason") in ("video_open_failed", "video_metadata_invalid"):
+                continue
+
+            video_frames = int(report.get("frame_count") or 0)
+            data_rows = int(stream.rows or ctx.data_rows or 0)
+            if not video_frames or not data_rows:
+                continue
+
+            diff = abs(video_frames - data_rows)
+            tolerance = max(
+                int(self.param(ctx, "tolerance_min", 2)),
+                int(data_rows * float(self.param(ctx, "tolerance_ratio", 0.005))),
+            )
+            metrics = {
+                "video_frames": video_frames,
+                "data_rows": data_rows,
+                "diff": diff,
+                "tolerance": tolerance,
+            }
+
+            if diff <= tolerance:
+                findings.append(self.finding(ctx, PASS, stream=stream.key,
+                                             metrics=metrics))
+                continue
+
+            findings.append(self.finding(
+                ctx,
+                FAIL if diff > tolerance * 5 else WARN,
+                stream=stream.key,
+                message=f"video has {video_frames} frames / data has {data_rows} rows"
+                        f"，差 {diff} 帧（容差 {tolerance}）",
+                metrics=metrics,
+            ))
+        return findings
diff --git a/processor/app/processing/cleaning/checks/video/freeze.py b/processor/app/processing/cleaning/checks/video/freeze.py
new file mode 100644
index 0000000000000000000000000000000000000000..817723f574ab3c72eaa3bbdf27c389ff48e97381
--- /dev/null
+++ b/processor/app/processing/cleaning/checks/video/freeze.py
@@ -0,0 +1,86 @@
+"""冻结 —— 画面连续多帧几乎不变。
+
+为什么重要
+----------
+冻结段通常是采集程序卡住、编码器 stall、或 USB 带宽不足导致丢帧后补重复帧。
+它和黑屏不同：画面是"正常的样子"，但时间已经不动了。模型会以为任务停滞。
+
+注意与"合理的静止"区分
+----------------------
+人拿着夹爪停在物体上方思考时，画面也接近静止。所以本项默认判 **WARN 而非
+FAIL**，并在 metrics 里带上每段时长供人工/AI 复核 —— 方案明确要求
+「阈值不要照搬」，静止多久算异常要按任务节奏定。
+"""
+
+from __future__ import annotations
+
+from app.processing.cleaning.contract import VIDEO_CAPABLE_MODALITIES
+from app.processing.cleaning.checks import (
+    CheckContext, CleaningCheck, register_check,
+    Finding, Range, WARN, FAIL,
+)
+
+
+@register_check
+class VideoFreezeCheck(CleaningCheck):
+    slug = "video.freeze"
+    label = "Frozen Frame"
+    version = "1.0"
+    description = "Frame nearly unchanged across consecutive frames"
+
+    requires_channels = ("rgb",)
+
+    # 属于哪些设备卡片 —— 前端设置面板按它分 tab
+
+    device_cards = VIDEO_CAPABLE_MODALITIES
+
+    default_params = {"min_sec": 2.0, "fail_sec": 10.0}
+    default_severity = WARN
+
+    def run(self, ctx: CheckContext) -> list[Finding]:
+        findings: list[Finding] = []
+        for stream in ctx.streams_of("rgb"):
+            report = stream.video or {}
+            ranges = report.get("freeze_ranges") or []
+            if not ranges:
+                continue
+
+            fps = float(report.get("fps") or stream.fps or ctx.fps or 30.0)
+            min_sec = float(self.param(ctx, "min_sec", 2.0))
+            fail_sec = float(self.param(ctx, "fail_sec", 10.0))
+
+            converted: list[Range] = []
+            longest = 0.0
+            worst_status = WARN
+            for item in ranges:
+                try:
+                    start, end = float(item[0]), float(item[1])
+                except (TypeError, ValueError, IndexError):
+                    continue
+                span = end - start
+                if span < min_sec:
+                    continue
+                longest = max(longest, span)
+                status = FAIL if span >= fail_sec else WARN
+                if status == FAIL:
+                    worst_status = FAIL
+                converted.append(Range(
+                    start_sec=start, end_sec=end,
+                    code=self.slug, severity=status,
+                    stream=stream.key, channel="rgb",
+                    start_frame=int(start * fps), end_frame=int(end * fps),
+                    rule=self.slug,
+                    message=f"frozen for {span:.1f}s",
+                ))
+
+            if not converted:
+                continue
+
+            findings.append(self.finding(
+                ctx, worst_status, stream=stream.key,
+                message=f"{len(converted)} frozen stretches, longest {longest:.1f}s",
+                metrics={"segments": len(converted),
+                         "longest_sec": round(longest, 3)},
+                ranges=converted,
+            ))
+        return findings
diff --git a/processor/app/processing/cleaning/collect.py b/processor/app/processing/cleaning/collect.py
new file mode 100644
index 0000000000000000000000000000000000000000..c784f4f18192c0f02d64f24681e9fd7309f5f85a
--- /dev/null
+++ b/processor/app/processing/cleaning/collect.py
@@ -0,0 +1,647 @@
+"""证据采集 —— 从批次目录读出检查项需要的一切。
+
+检查项**不碰磁盘**（见 ``checks.CheckContext`` 的 IO 注入设计）。所有读取集中在
+这里，好处有两个：
+
+* 检查项本体是纯逻辑，测试喂假证据即可，不需要真 mp4 / parquet / cv2；
+* "读什么、怎么读"只有一处实现，不会出现两个检查项对同一列用不同口径。
+
+**本模块只读** —— 不写任何文件、不改任何数据。质检出结论，不出数据。
+"""
+
+from __future__ import annotations
+
+import glob
+import re
+from dataclasses import dataclass, field as dc_field
+from pathlib import Path
+from typing import Any, Iterable
+
+import numpy as np
+
+from app.processing.cleaning.checks import StreamEvidence
+from app.processing.cleaning.contract import (
+    pose_is_valid,
+    channels_for, normalize_device_modality,
+)
+
+# SLAM 列的命名：``observation.slam_*`` 是默认相机；双目/多把第二路存成
+# ``observation.<相机名>_slam_*``。这里按**相机**分组，每组里 trajectory 优先。
+#
+# 为什么不能写死两个列名：实测 Test94/episode_000003 **只有** gripper_2 前缀的
+# 两列，没有不带前缀的 —— 那种集有 SLAM 数据、却一个 SLAM 检查都不跑，且不报
+# 任何错。同一项目里不同集的列名不一致是常态（见 MODALITY_CHANNELS 的告诫）。
+#
+# 两个**不要**匹配进去的近亲：
+#   observation.slam_trajectory_ns            —— 时间戳伴生列，不是位姿
+#   processing.umi_slam_action.data_4.action  —— 处理缓存列，名字里恰好含 slam
+_SLAM_COLUMN_RE = re.compile(r"^observation\.(?:(.+)_)?slam_(trajectory|pose)$")
+
+# 列名 → 信道。值为**可能的列名**（含历史名）。同一信道的每个存在的列都会
+# 登记成一条流（左右两路力就是两条），流名取列名最后一段。
+#
+# ★ 这里**不能**用 `break` 只取第一个 —— 那样左右两路力只剩一路。
+#   要与别名列去重的话看 ``_COLUMN_ALIASES``，别在这里提前退出。
+#
+# slam 不在下表里 —— 它按相机分组解析，见 ``_slam_columns``。
+_COLUMN_CHANNELS: dict[str, tuple[str, ...]] = {
+    "slam": (
+        "observation.slam_trajectory",   # 高频样本缓冲（优先）
+        "observation.slam_pose",         # 低频快照（旧批才有）
+    ),
+    "gripper_state": ("observation.gripper_state",),
+    "force": (
+        "observation.gripper_left_force",
+        "observation.gripper_right_force",
+        "observation.gripper_force",
+    ),
+    "tactile": (
+        "observation.left_glove",
+        "observation.right_glove",
+        "observation.glove",
+    ),
+    "device_status": (
+        "status.left_glove",
+        "status.right_glove",
+        "status.glove",
+    ),
+    "depth": ("observation.images.depth",),
+    "action": ("action",),
+}
+
+# 别名列 → 协议列名。**同一份数据的第二套命名**，不新增信道，只是改名。
+#
+# 触觉数据有两套名字：
+#   采集协议写  observation.left_glove / right_glove
+#   导出时统一成 observation.tactile.left / right
+#   （见 lerobot_export._TACTILE_RENAME，hdf5_export / ai_annotation 读的是后者）
+#
+# 原始 session 目录里两套可能同时在（导出产物被合并回 canonical）；而**只跑过
+# 导出的树里只有后者**。此前只认协议名 —— 那种树上手套信道直接为空，所有手套
+# 检查静默跳过，不报任何错。
+_COLUMN_ALIASES: dict[str, str] = {
+    "observation.tactile.left": "observation.left_glove",
+    "observation.tactile.right": "observation.right_glove",
+}
+
+# 各信道的向量宽度 —— 用于把列值切成定长元组。
+#
+# ★ 不在表里的信道**不截断**（见 ``vector_series``）。默认截断到某个数字是
+#   危险的：触觉阵列是 16×16=256 维，此前因为这里没有 ``tactile`` 项而落到
+#   3 的兜底值，256 个感应点被静默截成 3 个 —— 检查项只看得到 1% 的阵列。
+#   换手套（或加新阵列通道）时同样会静默丢数据，所以默认必须是"不截断"。
+_CHANNEL_WIDTH: dict[str, int] = {
+    "gripper_state": 3,
+    "force": 3,
+    "action": 7,
+}
+
+
+def _apply_column_aliases(frame):
+    """把别名列归一成协议列名。
+
+    **只在协议名缺失时改** —— 两套都在时保留协议名：它们是同一份数据，
+    登记成两条流会让同一处缺陷被报两次，也让"左右手"的流名对不上。
+    （实测 S80C / D435 两套都在时逐元素完全相同。）
+    """
+    rename = {alias: canonical for alias, canonical in _COLUMN_ALIASES.items()
+              if alias in frame.columns and canonical not in frame.columns}
+    return frame.rename(columns=rename) if rename else frame
+
+_DEFAULT_FPS = 30.0
+_MAX_VIDEO_PROBES = 4
+
+
+@dataclass(frozen=True)
+class Evidence:
+    """一个 episode 的全部证据 —— engine 交给检查项的那一份。"""
+
+    batch_dir: Path
+    streams: tuple[StreamEvidence, ...] = ()
+    channels: frozenset[str] = frozenset()
+    modalities: tuple[str, ...] = ()
+    fps: float = _DEFAULT_FPS
+    rows: int = 0
+    columns: tuple[str, ...] = ()
+    parquet: str = ""
+    notes: dict[str, Any] = dc_field(default_factory=dict)
+
+    @property
+    def duration_sec(self) -> float:
+        return (self.rows / self.fps) if self.fps else 0.0
+
+
+# ── 读文件 ────────────────────────────────────────────────────
+
+def _glob(pattern: str, root: Path) -> list[Path]:
+    return [Path(item) for item in sorted(glob.glob(str(root / pattern)))]
+
+
+def _file_holding(parquets: list[Path], episode_index: int) -> Path | None:
+    """哪个文件里装着这一集 —— 只读 ``episode_index`` 一列，不整份加载。
+
+    文件名对不上时的兜底（历史命名、手工搬过的目录）。返回 None 表示都没有。
+    """
+    import pyarrow.parquet as pq
+
+    for path in parquets:
+        try:
+            column = pq.ParquetFile(path).read(columns=["episode_index"])
+        except Exception:
+            continue
+        values = column.column("episode_index").to_pylist()
+        if episode_index in values:
+            return path
+    return None
+
+
+def resolve_episode_data(batch_dir: Path,
+                         episode_index: int | None = None) -> tuple[Path | None, bool]:
+    """定位这一集的数据文件。返回 ``(parquet, 还要不要按行过滤)``。
+
+    两种布局的粒度**不一样**，混了就会读出空帧：
+
+      canonical ``data/chunk-*/episode_NNNNNN.parquet`` —— 一集一文件。
+        选对**文件**即可，行全是这一集的。
+      导出产物 ``data/chunk-*/file-NNN.parquet`` —— 一文件多集，
+        必须再按 ``episode_index`` 列筛行。
+
+    ★ 这里曾经是「取 ``parquets[0]`` 再按列过滤」。canonical 布局下第 0 个文件
+      只装第 0 集，于是传任何**别的** ``episode_index`` 都筛出空帧 —— 不报错，
+      只是报告变成 ``empty_report``（``episode.status = ERROR``）。在"数据不对
+      就拦回人工审核"的链路里，表现是**除第 0 集外每一集都被卡住**。
+    """
+    root = Path(batch_dir)
+
+    canonical = _glob("data/chunk-*/episode_*.parquet", root)
+    if canonical:
+        if episode_index is None:
+            return canonical[0], False
+        # 文件名就是集号（LeRobot canonical 约定，注意编号可能有空洞）
+        wanted = f"episode_{int(episode_index):06d}.parquet"
+        for path in canonical:
+            if path.name == wanted:
+                return path, False
+        # 文件名对不上 —— 按列找，别静默返回空
+        return _file_holding(canonical, int(episode_index)), False
+
+    multi = _glob("data/chunk-*/*.parquet", root)
+    if not multi:
+        return None, False
+    if episode_index is None:
+        return multi[0], False
+    return _file_holding(multi, int(episode_index)), True
+
+
+def load_rows(parquet: Path, filter_episode_index: int | None = None):
+    """读 parquet；给了 ``filter_episode_index`` 就只取那一集的行。
+
+    只在**一文件多集**的布局下才该传它 —— canonical 的一集一文件布局下传了会
+    把这一集自己的行全筛掉。用 ``resolve_episode_data`` 拿到的第二个返回值决定。
+    """
+    import pyarrow.parquet as pq
+
+    frame = pq.ParquetFile(parquet).read().to_pandas()
+    if filter_episode_index is not None and "episode_index" in frame.columns:
+        frame = frame[frame["episode_index"].values == filter_episode_index]
+    return frame.reset_index(drop=True)
+
+
+# ── 列 → 序列 ─────────────────────────────────────────────────
+
+def slam_valid_counts(values) -> tuple[int, ...]:
+    """每帧的有效位姿样本数 —— 空帧即为 0。
+
+    slam_trajectory 是扁平的 ``[t,x,y,z,qx,qy,qz,qw]×N``。导出产物会把它补齐到
+    定长（补 NaN），所以"有效"= 非 NaN 的 8 元组个数。
+    """
+    counts: list[int] = []
+    for item in values:
+        if item is None:
+            counts.append(0)
+            continue
+        array = np.asarray(item, dtype=float).ravel()
+        valid = 0
+        for index in range(array.size // 8):
+            if np.isfinite(array[index * 8:index * 8 + 8]).all():
+                valid += 1
+        counts.append(valid)
+    return tuple(counts)
+
+
+def slam_poses(values, counts) -> tuple[tuple, ...]:
+    """逐帧取【第一个有效样本】的位姿（位置 + 四元数）。
+
+    ★ 刻意不重用 ``umi_slam_action.poses_from_trajectory`` 的插值重建 ——
+    那是生产口径（含时间基拟合与插值）。连续性检查要看的是**原始落盘数据**
+    有没有跳变；用插值后的平滑轨迹会掩盖真实跳变。
+    """
+    poses: list[tuple] = []
+    for item, count in zip(values, counts):
+        if not count:
+            poses.append(())
+            continue
+        array = np.asarray(item, dtype=float).ravel()
+        poses.append(tuple(float(v) for v in array[1:8]))
+    return tuple(poses)
+
+
+def _slam_columns(columns) -> list[str]:
+    """按**相机**挑出 SLAM 列，每个相机一个：trajectory 优先，回落到 pose。
+
+    相机名 = ``observation.`` 与 ``_slam_`` 之间那段，默认相机没有前缀：
+
+        observation.slam_trajectory           → 相机 ""
+        observation.gripper_2_slam_trajectory → 相机 "gripper_2"
+
+    每个相机只取一个 —— trajectory 是高频样本缓冲、pose 是低频快照，
+    两个都有时用前者（与旧行为一致，只是现在**每个相机各自**取一个，
+    而不是全局只取一个）。
+    """
+    by_camera: dict[str, dict[str, str]] = {}
+    for column in sorted(str(name) for name in columns):
+        match = _SLAM_COLUMN_RE.match(column)
+        if not match:
+            continue
+        camera, kind = match.group(1) or "", match.group(2)
+        by_camera.setdefault(camera, {})[kind] = column
+
+    picked: list[str] = []
+    for camera in sorted(by_camera):
+        kinds = by_camera[camera]
+        picked.append(kinds.get("trajectory") or kinds["pose"])
+    return picked
+
+
+def _column_series(values, channel: str, width: int | None = None) -> tuple:
+    """一列 → 序列。**字符串列原样保留，不试着数值化。**
+
+    ``vector_series`` 对字符串会走 ``np.asarray(..., dtype=float)`` 抛
+    ``ValueError``，被 ``except`` 吞掉后**每帧都变成空元组** —— 检查项拿到的是
+    "这一列没有数据"，看起来像"检查通过"。设备状态列（``status.left_glove``）
+    正是字符串，所以这里必须先分流。
+    """
+    if len(values) and isinstance(values.iloc[0], str):
+        return tuple("" if item is None else str(item) for item in values)
+    if width is None:
+        width = _CHANNEL_WIDTH.get(channel)
+    return vector_series(values.tolist(), width)
+
+
+def vector_series(values, width: int | None = None) -> tuple[tuple, ...]:
+    """把一列向量值转成元组序列；空/坏的写成空元组。
+
+    ``width=None``（默认）**不截断**。截断是静默的 —— 调用方只有显式声明了
+    正确宽度时才该发生（如 action 固定 7 维）；未知列宽一律保留整条，
+    免得"少了一半感应点"这种问题要等到训练效果不对才发现。
+    """
+    out: list[tuple] = []
+    for item in values:
+        if item is None:
+            out.append(())
+            continue
+        try:
+            array = np.asarray(item, dtype=float).ravel()
+            if width is not None:
+                array = array[:width]
+            out.append(tuple(float(v) for v in array))
+        except (TypeError, ValueError):
+            out.append(())
+    return tuple(out)
+
+
+def _video_files(video_dir: Path) -> list[Path]:
+    """列出视频目录下的 mp4（按名字排序，稳定可预期）。"""
+    root = Path(video_dir)
+    if not root.is_dir():
+        return []
+    return sorted(path for path in root.rglob("*.mp4") if path.is_file())
+
+
+def videos_for_episode(root: Path, episode_index: int | None) -> list[Path]:
+    """**这一集自己的**视频文件。取不到就返回空 —— 绝不猜。
+
+    ★ 不能"把 videos/ 下的 mp4 都拿来用"：v3.0 导出把 52 集的视频全放在
+    ``videos/chunk-000/<流名>/file-NNN.mp4`` 同一个目录里，随便取几个会拿
+    别的集的画面去比对这一集的数据行数，得出荒谬的丢帧结论（实测出现过
+    "视频 9164 帧 / 数据 819 行"）。
+
+    两种布局各有映射来源:
+      * canonical —— ``videos/<流名>/chunk-XXX/episode_XXXXXX.mp4``，
+        目录本身就对应这一集；有 ``project_dataset.episode_files`` 时用它。
+      * 导出产物 —— ``meta/episodes`` 里逐流记着 ``chunk_index``/``file_index``。
+    """
+    root = Path(root)
+    if episode_index is None:
+        # 一集一文件的布局：videos/ 下就是这一集的全部视频
+        return _video_files(root / "videos")
+
+    # canonical：走既有索引
+    try:
+        from app.project_dataset import episode_files
+        entry = episode_files(root, episode_index) or {}
+        found: list[Path] = []
+        for item in entry.get("videos") or []:
+            # episode_files 返回 (source_key, path) 的形式
+            path = item[1] if isinstance(item, (tuple, list)) and len(item) > 1 else item
+            candidate = Path(path)
+            if candidate.is_file():
+                found.append(candidate)
+        if found:
+            return found
+    except Exception:
+        pass
+
+    # 导出产物：查 meta/episodes 的逐流索引
+    return _videos_from_episode_meta(root, episode_index)
+
+
+def _videos_from_episode_meta(root: Path, episode_index: int) -> list[Path]:
+    """从 ``meta/episodes`` 的逐流 chunk/file index 拼出视频路径。"""
+    import pyarrow.parquet as pq
+
+    for path in sorted(glob.glob(str(root / "meta" / "episodes" / "**" / "*.parquet"),
+                                 recursive=True)):
+        try:
+            frame = pq.ParquetFile(path).read().to_pandas()
+        except Exception:
+            continue
+        if "episode_index" not in frame.columns:
+            continue
+        rows = frame[frame["episode_index"].values == episode_index]
+        if rows.empty:
+            continue
+
+        # 列名形如 videos/<流名>/chunk_index 与 videos/<流名>/file_index
+        columns = {str(name) for name in frame.columns}
+        streams = sorted({
+            name[len("videos/"):-len("/chunk_index")]
+            for name in columns
+            if name.startswith("videos/") and name.endswith("/chunk_index")
+        })
+        row = rows.iloc[0]
+        found: list[Path] = []
+        for stream in streams:
+            try:
+                chunk = int(row[f"videos/{stream}/chunk_index"])
+                file_index = int(row[f"videos/{stream}/file_index"])
+            except (KeyError, TypeError, ValueError):
+                continue
+            candidate = (root / "videos" / f"chunk-{chunk:03d}" / stream
+                         / f"file-{file_index:03d}.mp4")
+            if candidate.is_file():
+                found.append(candidate)
+        if found:
+            return found
+    return []
+
+
+def _is_depth_key(name: str) -> bool:
+    """这个流名是不是纯深度流。
+
+    复用 ``lerobot_v21.is_depth_source`` —— 深度口径在这个仓库里有好几处实现
+    （``device_naming.is_depth_only_key`` 是同一套），但权威定义在那儿。
+    导入失败时回落到保守判断：名字含 depth 且不含 rgb/color。
+    """
+    try:
+        from app.lerobot_v21 import is_depth_source
+        return bool(is_depth_source(name))
+    except Exception:
+        low = str(name or "").lower()
+        return "depth" in low and not any(
+            token in low for token in ("rgb", "color", "video"))
+
+
+# ── 主入口 ────────────────────────────────────────────────────
+
+def gather_evidence(batch_dir: Path, *,
+                    episode_index: int | None = None,
+                    probe_video: bool = False,
+                    modality_hint: str | Iterable[str] | None = None) -> Evidence:
+    """读一个 episode 的全部证据。
+
+    ``probe_video=False``（默认）只读 parquet，毫秒级；视频检查要解码抽样，
+    一集几秒到几十秒，按需开。
+
+    ``modality_hint`` 用于告诉采集层"这台设备是什么"（来自工作流连线的设备
+    卡片）。**可以是多个** —— 一个质检节点上游同时连相机和夹爪时就有多个。
+    给不出时按数据特征推断；两个来源取并集，理由见 ``_detect_modalities``。
+
+    ★ ``batch_dir`` 必须是**单个 episode 的目录**，且 ``episode_index`` 必须
+      与它匹配。``localstore.get_episode()`` 返回的 ``path`` 是**项目目录**
+      （几十集共享），直接传进来会拿第 0 集的 parquet 去比全部集的视频
+      —— 实测过，会得出"视频 9164 帧 / 数据 819 行"。见 ``videos_for_episode``。
+    """
+    root = Path(batch_dir)
+    parquet, filter_rows = resolve_episode_data(root, episode_index)
+    if parquet is None:
+        return Evidence(batch_dir=root, notes={"reason": "no_parquet"})
+
+    # ★ 按行过滤只在"一文件多集"的布局下做。canonical 是一集一文件，文件已经
+    #   选对了，再按 episode_index 列筛会把这一集自己的行全筛空 —— 结果是不报
+    #   任何错的 empty_report。见 resolve_episode_data。
+    frame = load_rows(parquet, episode_index if filter_rows else None)
+    if frame.empty:
+        return Evidence(batch_dir=root, parquet=str(parquet.relative_to(root)),
+                        notes={"reason": "empty_episode"})
+
+    # 别名列先归一成协议名，再算 columns —— 必须在下面所有列名判断之前，
+    # 否则 observation.tactile.* 会被当成"这列不存在"
+    frame = _apply_column_aliases(frame)
+    columns = {str(name) for name in frame.columns}
+    fps = _detect_fps(root)
+    rows = len(frame)
+    streams: list[StreamEvidence] = []
+    channels: set[str] = {"time"}
+
+    def _relative(path: Path) -> str:
+        try:
+            return str(path.relative_to(root))
+        except ValueError:
+            return str(path)
+
+    # SLAM —— **每个相机一路**，各取 trajectory 优先（见 _slam_columns）。
+    # 这里曾经是 `break`：全局只登记一路，双目集第二路的 SLAM 从来没被采集过。
+    for column in _slam_columns(columns):
+        values = frame[column].tolist()
+        series: dict[str, Any] = {}
+        if column.endswith("trajectory"):
+            counts = slam_valid_counts(values)
+            series["valid_count"] = counts
+            series["pose"] = slam_poses(values, counts)
+            # 覆盖率必须走生产口径 —— "插值帧"的定义就是 poses_from_trajectory
+            # 里本地与相邻格子都够不到的那些，只读原始数据推不出来。
+            try:
+                from app.umi_slam_action import poses_from_trajectory
+                stamps = (frame["timestamp"].to_numpy(dtype=float)
+                          if "timestamp" in columns
+                          else np.arange(rows) / fps)
+                diag: dict[str, Any] = {}
+                poses_from_trajectory(values, stamps, rows, diagnostics=diag)
+                series["coverage"] = diag
+            except Exception as exc:
+                series["coverage_error"] = str(exc)[:200]
+        else:
+            poses = vector_series(values, 7)
+            series["valid_count"] = tuple(
+                1 if pose_is_valid(item) else 0 for item in poses)
+            series["pose"] = poses
+        # 流名取列名最后一段 —— 多相机时是 "gripper_2_slam_trajectory"，
+        # 单相机时是 "slam_trajectory"，两条流不会撞名。
+        streams.append(StreamEvidence(
+            key=column.rsplit(".", 1)[-1],
+            channel="slam", path=_relative(parquet),
+            columns=(column,), rows=rows, fps=fps, series=series,
+        ))
+        channels.add("slam")
+
+    # 其余标量/向量列
+    #
+    # ★ series 的键一律用【信道名】。检查项按信道取序列（``series["force"]``），
+    #   如果这里用列名（``series["gripper_left_force"]``），检查项就静默地取不到
+    #   数据、全部判通过 —— 而且不报任何错。左右两路力共用 ``force`` 键，
+    #   靠 stream.key 区分。
+    for channel, candidates in _COLUMN_CHANNELS.items():
+        if channel == "slam":
+            continue
+        for column in candidates:
+            if column not in columns:
+                continue
+            streams.append(StreamEvidence(
+                key=column.rsplit(".", 1)[-1], channel=channel,
+                path=_relative(parquet), columns=(column,), rows=rows, fps=fps,
+                # 走 _column_series：宽度取不到就**不截断**（兜底成某个数字会
+                # 静默丢数据），字符串列原样保留（数值化会变成全空元组）
+                series={channel: _column_series(frame[column], channel)},
+            ))
+            channels.add(channel)
+
+    # 视频 —— ★ 无论检不检查，都要登记成一条流。
+    #
+    # 只登记不检查时 ``video`` 是空 dict（视频检查项会自行跳过），但信道
+    # ``rgb`` 必须出现 —— 否则报告会写成"未采集 rgb"，而实际上视频就在那儿，
+    # 只是这一轮没去解码。那会让"训练用途"给出错误的结论。
+    video_root = root / "videos"
+    for path in videos_for_episode(root, episode_index)[:_MAX_VIDEO_PROBES]:
+        report: dict[str, Any] = {}
+        if probe_video:
+            try:
+                from app.video_quality import _check_stream
+                report = _check_stream(path, rows, fps)
+            except Exception as exc:
+                report = {"passed": False, "reason": "video_check_failed",
+                          "error": str(exc)[:200]}
+        # 流名 = 流名目录那一层（observation.images.xxx），**不是** chunk-XXX。
+        # 两种布局的层级顺序相反，所以不能写死取第几段：
+        #   canonical/v2.1  videos/<流名>/chunk-000/episode_000000.mp4
+        #   v3.0            videos/chunk-000/<流名>/file-000.mp4
+        # 取"路径里第一个不是 chunk-* 的目录段"，两边都成立。
+        # 写错的话所有视频流会同名（都叫 chunk-000），报告分不清哪路相机，
+        # 且下游按 stream 去重时会互相覆盖。
+        try:
+            relative = str(path.relative_to(root))
+            segments = path.relative_to(video_root).parts[:-1]   # 去掉文件名
+            key = next((seg for seg in segments
+                        if not seg.startswith("chunk-")), path.stem)
+        except ValueError:
+            relative, key = str(path), path.stem
+
+        # ★ 深度流不能算作 rgb 信道。之前一律按 rgb 登记，结果 D435 项目的
+        # 深度视频引出了"视频 9164 帧 / 数据 819 行"这种荒谬的丢帧结论 ——
+        # 那是拿深度流跟 rgb 数据行数比。判定复用 lerobot_v21 的既有口径，
+        # 不另起一套字符串匹配。
+        channel = "depth" if _is_depth_key(key) else "rgb"
+        streams.append(StreamEvidence(
+            key=key, channel=channel, path=relative,
+            rows=rows, fps=fps, video=report,
+        ))
+        channels.add(channel)
+
+    modalities = _detect_modalities(channels, modality_hint)
+    return Evidence(
+        batch_dir=root, streams=tuple(streams), channels=frozenset(channels),
+        modalities=modalities, fps=fps, rows=rows,
+        columns=tuple(sorted(columns)), parquet=_relative(parquet),
+    )
+
+
+def _detect_fps(root: Path) -> float:
+    """从 meta/info.json 取 fps；拿不到就用默认 30。"""
+    import json
+
+    for relative in ("meta/info.json", "info.json"):
+        candidate = root / relative
+        if not candidate.is_file():
+            continue
+        try:
+            data = json.loads(candidate.read_text(encoding="utf-8"))
+            value = float(data.get("fps") or 0)
+            if 0 < value < 1000:
+                return value
+        except Exception:
+            continue
+    return _DEFAULT_FPS
+
+
+def hint_values(hint: str | Iterable[str] | None) -> list[str]:
+    """把 hint 归一成字符串列表 —— 调用方有单数（旧调用）也有复数（工作流连线）。"""
+    if hint is None:
+        return []
+    if isinstance(hint, str):
+        return [hint] if hint.strip() else []
+    try:
+        return [str(item) for item in hint]
+    except TypeError:
+        return [str(hint)]
+
+
+def _infer_modalities(channels: set[str]) -> list[str]:
+    """只看数据特征能推断出什么。
+
+    ★ 永远给不出 ``stereo_rgb`` / ``stereo_rgbd_camera`` —— "立体"不是列名里
+      能看见的特征。这两个模态**只能**由工作流连线给出。所以它们是
+      ``_detect_modalities`` 取并集、而不是二选一的主要理由。
+    """
+    if "slam" in channels or "gripper_state" in channels:
+        return ["gripper_device"]
+    if "tactile" in channels:
+        return ["glove_sensor"]
+    if "depth" in channels:
+        return ["rgbd_camera"]
+    if "rgb" in channels:
+        return ["mono_rgb"]
+    return []
+
+
+def _detect_modalities(channels: set[str],
+                       hint: str | Iterable[str] | None) -> tuple[str, ...]:
+    """这台设备是什么 —— hint（工作流连线）与数据特征取**并集**。
+
+    两个来源各有各的盲区，缺一个都会让检查静默不跑：
+
+      只有 hint  → 按数据模态声明的检查项不跑（将来接 ``depth.*`` 时，
+                   D435 数据在但模态被写成 stereo_rgb 就查不到）
+      只有推断   → 工作流里那张卡片的 tab 键查不到，**用户在设置面板里配的
+                   阈值被静默忽略、一律走默认值**（推断不出 stereo_*）
+
+    并集对"配置查找"和"检查项筛除"都更宽 —— 而本项目反复踩的坑恰恰是
+    "检查项静默不跑"，所以宁可宽。
+
+    hint 在前：``engine.resolve_config`` 按这个顺序合并各设备卡片的配置，
+    "先出现的优先"，工作流连线的顺序才是用户预期的顺序。
+    """
+    from app.processing.cleaning.contract import DEVICE_MODALITIES
+
+    ordered: dict[str, None] = {}
+    for raw in hint_values(hint):
+        canonical = normalize_device_modality(raw)
+        if canonical in DEVICE_MODALITIES:
+            ordered.setdefault(canonical, None)
+    for modality in _infer_modalities(channels):
+        ordered.setdefault(modality, None)
+    return tuple(ordered)
+
+
+def channels_from_modalities(modalities) -> tuple[str, ...]:
+    """设备模态 → 该设备可能提供的信道（转调 contract，供 engine 用）。"""
+    return channels_for(modalities)
diff --git a/processor/app/processing/cleaning/contract.py b/processor/app/processing/cleaning/contract.py
new file mode 100644
index 0000000000000000000000000000000000000000..a7dc3fde47b00335e7110ad40ef5ff5c8541bb03
--- /dev/null
+++ b/processor/app/processing/cleaning/contract.py
@@ -0,0 +1,274 @@
+"""清洗契约 —— 模态、信道、严重度的公共定义。
+
+这个文件把"平台里同一个东西有好几个名字"这件事收敛到一处:
+
+    device_naming.DEVICE_LABELS        mono_rgb / stereo_rgb / ...
+    workflow_dispatch.semantic_type    同上（同一套值，只是没人敢这么说）
+    api/projects._device_input_sources mono_camera / stereo_camera  ← 名字不一样
+    处理模块 slug                       mono_camera / stereo_camera
+
+**本模块不新建第 7 套枚举** —— DEVICE_MODALITIES 就是 device_naming 那 6 个值的
+权威声明，其余几套通过 ``normalize_device_modality()`` 单向映射进来。新增设备类型时
+只需改这一处，测试会锁住映射完整性。
+
+信道(channel) 是比设备模态更细的粒度: PDF 里"IMU 可选""SLAM 必须"这类判断
+是**信道级**的，硬塞进设备模态会毁掉它。所以设备模态 → 信道的推导放在这里。
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field as dc_field
+from typing import Any, Iterable
+
+# ── 设备模态 ──────────────────────────────────────────────────
+# 与 app/device_naming.py:15 DEVICE_LABELS 的键**逐字一致**。
+# 改这里必须同步改那里，tests/test_cleaning_contract.py 会断言两边相等。
+DEVICE_MODALITIES: tuple[str, ...] = (
+    "mono_rgb",
+    "stereo_rgb",
+    "rgbd_camera",
+    "stereo_rgbd_camera",
+    "glove_sensor",
+    "gripper_device",
+)
+
+# 「摄像机类」模态 —— 判定 collection_type 时要用
+CAMERA_MODALITIES: frozenset[str] = frozenset({
+    "mono_rgb", "stereo_rgb", "rgbd_camera", "stereo_rgbd_camera",
+})
+
+# 会产出 RGB 视频的**全部**设备卡片 —— ``video.*`` 类检查适用于它们每一个。
+# 比 CAMERA_MODALITIES 多一个 gripper_device：UMI 夹爪自带鱼眼相机，
+# 视频检查对同样它成立。
+VIDEO_CAPABLE_MODALITIES: tuple[str, ...] = (
+    "mono_rgb", "stereo_rgb", "rgbd_camera", "stereo_rgbd_camera",
+    "gripper_device",
+)
+
+# ── 信道 ──────────────────────────────────────────────────────
+# 检查项按信道声明需求，而不是按设备模态 —— 这样一条"SLAM 连续性"检查
+# 既能被 UMI 夹爪触发，将来也能被别的带 SLAM 的设备复用。
+CHANNELS: tuple[str, ...] = (
+    "time",           # 时间戳 / 帧号
+    "rgb",            # RGB 视频
+    "depth",          # 深度
+    "slam",           # SLAM 位姿/轨迹
+    "gripper_state",  # 夹爪开合
+    "force",          # 力 / 触觉（夹爪力）
+    "tactile",        # 触觉阵列（手套）
+    "imu",            # 惯性单元
+    "keypoints",      # 手部关键点
+    "action",         # 动作（派生列）
+    # 设备的连接状态（``status.left_glove`` 这类**字符串**列）。
+    # 单独算一个信道而不是塞进 tactile 的 series：它是"设备这一帧在不在"，
+    # 与阵列读数正交 —— 手套掉线时阵列会静默保持最后一个值，看起来完全正常。
+    "device_status",
+)
+
+# 设备模态 → 该设备**可能**提供的信道。
+# 注意这是"可能"不是"必然" —— 实际有哪些信道由 collect.py 从真实列名推导，
+# 这里只用来回答"这个模态需不需要某类检查"。
+MODALITY_CHANNELS: dict[str, tuple[str, ...]] = {
+    "mono_rgb":           ("rgb", "time"),
+    "stereo_rgb":         ("rgb", "time"),
+    "rgbd_camera":        ("rgb", "depth", "time"),
+    "stereo_rgbd_camera": ("rgb", "depth", "time"),
+    "glove_sensor":       ("tactile", "device_status", "imu", "time"),
+    "gripper_device":     ("rgb", "slam", "gripper_state", "force", "action", "time"),
+}
+
+# 非设备来源的信道 —— 由处理节点产出，不属于任何输入设备
+DERIVED_CHANNELS: frozenset[str] = frozenset({"keypoints", "action"})
+
+
+def channels_for(modalities: Iterable[str]) -> tuple[str, ...]:
+    """一组设备模态覆盖的全部信道（去重、保序）。纯函数。"""
+    seen: dict[str, None] = {}
+    for modality in modalities:
+        for channel in MODALITY_CHANNELS.get(str(modality), ()):
+            seen.setdefault(channel, None)
+    return tuple(seen)
+
+
+def pose_is_valid(item) -> bool:
+    """位姿能不能用 —— 空元组和**全零占位**都不算。
+
+    ★ 全零占位长得像合法位姿：长度 7、能索引、能相减。但它的四元数模是 0，
+      任何涉及它的差分都会算出"瞬移"：
+
+          两个零四元数的点积 = 0 → acos(0) = π/2 → 夹角 180°
+
+      30fps 下就是 180°×30 = **94.25 rad/s** —— 一个物理上荒谬的角速度。
+      实测 Test94 的 ``observation.slam_pose`` 有 437/599 行是全零，SLAM 连续性
+      因此报出 465 处"跳变"（599 帧里几乎每一帧），把整集假判成 FAIL 并拦住批次。
+
+    判据只看四元数模：**位置可以合法地是 (0,0,0)**（原点就是合法位姿），
+    四元数模为 0 则一定不是合法朝向。
+
+    放在 contract 而不是 collect：检查项要用它，而 collect 依赖 checks
+    （检查项自动发现），collect ← checks 的导入会成环。
+    """
+    if not item or len(item) < 7:
+        return False
+    try:
+        return sum(float(value) ** 2 for value in item[3:7]) > 1e-12
+    except (TypeError, ValueError):
+        return False
+
+
+def normalize_device_modality(value: object) -> str | None:
+    """把别处的设备/输入类型名映射到 canonical 设备模态。
+
+    覆盖两套现存命名:
+      * ``stereo_camera`` / ``mono_camera``（api/projects、processing 模块 slug）
+      * ``fisheye_camera`` / ``rgb_camera``（历史工作流节点类型）
+    认不出来返回 ``None``（调用方应跳过该值，而不是终止）。
+    """
+    text = str(value or "").strip()
+    if not text:
+        return None
+    if text in DEVICE_MODALITIES:
+        return text
+    return _ALIASES.get(text)
+
+
+# 别名表 —— 只列真实存在于代码里的历史/并行命名。
+# 新增别名时同步加进 tests/test_cleaning_contract.py 的用例。
+_ALIASES: dict[str, str] = {
+    # api/projects._device_input_sources 与处理模块 slug 用的是 camera 后缀
+    "mono_camera": "mono_rgb",
+    "stereo_camera": "stereo_rgb",
+    "fisheye_camera": "mono_rgb",     # 历史节点，镜头类型对清洗不可见
+    "rgb_camera": "mono_rgb",         # 历史节点
+    "rgbd": "rgbd_camera",
+    "stereo_rgbd": "stereo_rgbd_camera",
+    # 中文/展示名兜底
+    "umi": "gripper_device",
+    "umi_gripper": "gripper_device",
+    "glove": "glove_sensor",
+}
+
+
+# ── 严重度 ────────────────────────────────────────────────────
+PASS = "pass"
+WARN = "warn"
+FAIL = "fail"
+PENDING = "pending_review"
+ERROR = "error"
+
+# 越靠前越严重 —— worst() 与排序都用它
+SEVERITY_ORDER: tuple[str, ...] = (ERROR, FAIL, PENDING, WARN, PASS)
+
+# 面向用户的展示文案（报告里的 ``status_label``）。界面是英文的，这里保持一致。
+SEVERITY_LABELS: dict[str, str] = {
+    PASS: "Pass",
+    WARN: "Warning",
+    FAIL: "Fail",
+    PENDING: "Pending review",
+    ERROR: "Error",
+}
+
+
+def worst(statuses: Iterable[str]) -> str:
+    """取一组状态里最严重的；空集合视为 PASS。纯函数。"""
+    rank = {status: index for index, status in enumerate(SEVERITY_ORDER)}
+    result = PASS
+    best = len(SEVERITY_ORDER)
+    for status in statuses:
+        index = rank.get(str(status), len(SEVERITY_ORDER))
+        if index < best:
+            best = index
+            result = str(status)
+    return result
+
+
+def is_blocking(status: str) -> bool:
+    """该状态是否应当拦截（退回人工审核）。"""
+    return str(status) in (FAIL, ERROR)
+
+
+# ── 结构 ──────────────────────────────────────────────────────
+@dataclass(frozen=True)
+class Range:
+    """一段时间区间 —— PDF §5「第二层结果」。"""
+
+    start_sec: float
+    end_sec: float
+    code: str
+    severity: str
+    stream: str = ""
+    channel: str = ""
+    start_frame: int | None = None
+    end_frame: int | None = None
+    rule: str = ""
+    message: str = ""
+    evidence: dict[str, Any] = dc_field(default_factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "start_sec": round(float(self.start_sec), 3),
+            "end_sec": round(float(self.end_sec), 3),
+            "code": self.code,
+            "severity": self.severity,
+            "stream": self.stream,
+            "channel": self.channel,
+            "start_frame": self.start_frame,
+            "end_frame": self.end_frame,
+            "rule": self.rule,
+            "message": self.message,
+            "evidence": dict(self.evidence or {}),
+        }
+
+
+@dataclass(frozen=True)
+class StreamResult:
+    """一条数据流的检查结果 —— PDF §5「第一层结果」。"""
+
+    stream: str
+    modality: str = ""
+    label: str = ""
+    channels: tuple[str, ...] = ()
+    status: str = PASS
+    reasons: tuple[str, ...] = ()
+    metrics: dict[str, Any] = dc_field(default_factory=dict)
+    ranges: tuple[Range, ...] = ()
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "stream": self.stream,
+            "modality": self.modality,
+            "label": self.label,
+            "channels": list(self.channels),
+            "status": self.status,
+            "reasons": list(self.reasons),
+            "metrics": dict(self.metrics or {}),
+            "ranges": [item.to_dict() for item in self.ranges],
+        }
+
+
+@dataclass(frozen=True)
+class Finding:
+    """一次检查产出的结论 —— 检查项 run() 的返回值单元。"""
+
+    rule: str
+    version: str
+    status: str
+    scope: str                        # stream | episode | cross_modal
+    stream: str = ""
+    message: str = ""
+    metrics: dict[str, Any] = dc_field(default_factory=dict)
+    ranges: tuple[Range, ...] = ()
+    elapsed_ms: int = 0
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "rule": self.rule,
+            "version": self.version,
+            "status": self.status,
+            "scope": self.scope,
+            "stream": self.stream,
+            "message": self.message,
+            "metrics": dict(self.metrics or {}),
+            "ranges": [item.to_dict() for item in self.ranges],
+            "elapsed_ms": self.elapsed_ms,
+        }
diff --git a/processor/app/processing/cleaning/engine.py b/processor/app/processing/cleaning/engine.py
new file mode 100644
index 0000000000000000000000000000000000000000..be7c4c2a8cdfbf737d68f3d5341d5f14d07ea45d
--- /dev/null
+++ b/processor/app/processing/cleaning/engine.py
@@ -0,0 +1,302 @@
+"""质检引擎 —— 把检查项串成一次运行，产出四层报告。
+
+流程::
+
+    collect.gather_evidence()      读批次目录 → Evidence
+            │
+            ▼
+    applicable_checks()            按实际信道/模态选检查项
+            │
+            ▼
+    逐项 run(ctx)                  产出 Finding
+            │
+            ▼
+    rollup 成 StreamResult        每条流一个结论
+            │
+            ▼
+    report.build_report()          四层结果
+
+**只出结论，不产出数据**：不写文件、不改 episode 状态、不做任何清理动作。
+报告由调用方决定怎么用（落盘 / 展示 / 过滤导出）。
+
+设计取舍
+--------
+* **检查项失败不拖垮整轮** —— 单项抛异常记成 ``ERROR`` 结论继续跑，
+  否则一个 bug 会让整集没有报告。
+* **不设 `on_failure`** —— 按用户要求简化：清洗只记录，不碰 episode 状态流转。
+  需要拦截时由调用方读报告的 ``passed`` / ``verdict`` 自行决定。
+"""
+
+from __future__ import annotations
+
+import hashlib
+import time
+from pathlib import Path
+from typing import Any, Iterable
+
+from app.processing.cleaning import collect
+from app.processing.cleaning.checks import (
+    CheckContext, applicable_checks, all_checks,
+)
+from app.processing.cleaning.contract import (
+    ERROR, PASS, SEVERITY_LABELS, StreamResult, worst,
+)
+from app.processing.cleaning.report import build_report, empty_report
+
+
+def ruleset_revision() -> str:
+    """规则集指纹 —— 任何检查项的 slug/version 变了它就变。
+
+    用途：报告里带上这个值，规则更新后能识别出"这份报告是用旧规则跑的"。
+    与 ``workflow_dispatch.workflow_revision()`` 同款思路 —— 用内容哈希而不是
+    自增版本号，省掉版本分配和迁移。
+    """
+    parts = sorted(f"{check.slug}@{check.version}" for check in all_checks())
+    return hashlib.sha256("|".join(parts).encode("utf-8")).hexdigest()[:24]
+
+
+def resolve_config(evidence: collect.Evidence,
+                   config: dict | None) -> dict[str, dict]:
+    """把节点配置解析成 ``{检查项 slug: {"enabled": bool, "params": {...}}}``。
+
+    节点配置结构（见 data_quality 节点）::
+
+        {
+          "devices": {
+            "gripper_device": {
+              "checks": {
+                "umi.slam_continuity": {"enabled": true,
+                                        "params": {"max_linear_mps": 3.0}},
+                "video.freeze":       {"enabled": false}
+              }
+            }
+          }
+        }
+
+    本 episode 有多个设备卡片时，按 ``evidence.modalities`` 的顺序合并；
+    **先出现的优先**（后面的不覆盖前面已设的值）。实际采集里一个 episode
+    基本只对应一张卡片，多卡片是罕见情况，规则简单可预期即可。
+
+    没配到的检查项走默认：启用、用检查项自己声明的 ``default_params``。
+    """
+    resolved: dict[str, dict] = {}
+    devices = (config or {}).get("devices") or {}
+    for modality in evidence.modalities:
+        card = devices.get(str(modality)) or {}
+        for slug, item in (card.get("checks") or {}).items():
+            if slug in resolved:
+                continue                    # 先出现的优先
+            entry = item if isinstance(item, dict) else {}
+            resolved[slug] = {
+                "enabled": bool(entry.get("enabled", True)),
+                "params": dict(entry.get("params") or {}),
+            }
+    return resolved
+
+
+def _context_for(evidence: collect.Evidence, cfg: dict[str, dict]) -> CheckContext:
+    """按证据构造检查上下文。阈值按"当前检查项"逐个注入。"""
+    return CheckContext(
+        batch_dir=evidence.batch_dir,
+        channels=evidence.channels,
+        modalities=evidence.modalities,
+        data_rows=evidence.rows,
+        data_columns=evidence.columns,
+        duration_sec=evidence.duration_sec,
+        fps=evidence.fps,
+        streams=evidence.streams,
+    )
+
+
+def _stream_results(evidence: collect.Evidence,
+                    findings: Iterable) -> list[StreamResult]:
+    """把 findings 归拢成"每条流一个结论" —— 报告的第一层。"""
+    by_stream: dict[str, list] = {}
+    for item in findings:
+        by_stream.setdefault(item.stream or "", []).append(item)
+
+    results: list[StreamResult] = []
+    seen: set[str] = set()
+    for stream in evidence.streams:
+        items = by_stream.get(stream.key) or []
+        seen.add(stream.key)
+        status = worst(item.status for item in items) if items else PASS
+        results.append(StreamResult(
+            stream=stream.key,
+            modality=",".join(evidence.modalities),
+            label=stream.key,
+            channels=(stream.channel,) if stream.channel else (),
+            status=status,
+            reasons=tuple(item.rule for item in items if item.status != PASS),
+            metrics={k: v for item in items
+                     for k, v in (item.metrics or {}).items()
+                     if isinstance(v, (int, float, str, bool))},
+            ranges=tuple(r for item in items for r in (item.ranges or ())),
+        ))
+
+    # 没有对应证据流的 finding（如整集级结论）也要留在第一层里
+    for key, items in by_stream.items():
+        if key in seen:
+            continue
+        results.append(StreamResult(
+            stream=key or "episode",
+            status=worst(item.status for item in items),
+            reasons=tuple(item.rule for item in items if item.status != PASS),
+            ranges=tuple(r for item in items for r in (item.ranges or ())),
+        ))
+    return results
+
+
+def run_checks(batch_dir: Path, *,
+               episode_id: str = "",
+               episode_index: int | None = None,
+               project: str = "",
+               config: dict | None = None,
+               probe_video: bool = False,
+               modality_hint: str | Iterable[str] | None = None) -> dict:
+    """跑一个 episode 的全部适用检查，返回四层报告（纯 dict，不含副作用）。
+
+    ``modality_hint`` 是设备模态（可多个，来自工作流连线的设备卡片）。给了它，
+    ``resolve_config`` 才能查到用户在设置面板里按设备卡片配的阈值；给不出就
+    走数据推断（推断不出 ``stereo_*``，那些 tab 的配置会被静默忽略）。
+
+    ``episode_index`` 只在【一个文件装多集】的布局下需要（LeRobot v3.0 导出
+    产物就是这种）；canonical 布局一集一文件，留空即可。**传错会导致把整份
+    文件当成一集读**，所有指标因此失真 —— 而 ``localstore.get_episode()``
+    返回的 ``path`` 是**项目目录**（多集共享），所以工作流路径**必须**带上它。
+
+    ``probe_video=False``（默认）只读 parquet，毫秒级；视频检查要解码抽样，
+    每集约几秒到几十秒，按需开。
+    """
+    started = time.perf_counter()
+    evidence = collect.gather_evidence(
+        batch_dir, episode_index=episode_index,
+        probe_video=probe_video, modality_hint=modality_hint)
+
+    if not evidence.streams:
+        return empty_report(
+            episode_id=episode_id, project=project,
+            reason=str(evidence.notes.get("reason") or "no_data"))
+
+    resolved = resolve_config(evidence, config)
+    ctx = _context_for(evidence, resolved)
+
+    # ★ 配置是【黑名单】，**不是白名单** —— 不传 ``enabled``。
+    #
+    # ``applicable_checks`` 的 ``enabled`` 是白名单语义（``slug not in allow``
+    # 就跳过）。而前端设置面板只在用户**碰过**的检查项上写 entry（见
+    # DeviceQualityModal 的 setEntry，未触碰的项不落进 config），所以
+    # ``resolved`` 里通常只有一两条。把它当白名单 = 「用户在弹窗里改了一个
+    # 阈值 → 其余检查项全部静默停跑」：实测只配 umi.gripper_range 时，
+    # 9 项变 1 项，且不报任何错。
+    #
+    # 检查项没有"默认关闭"的概念（CleaningCheck 无 default_enabled），
+    # 适用即跑；配置唯一的语义就是**关掉某项**。
+    #
+    # （曾经写成 `{...enabled} or None`：那个 ``or None`` 只修了空集那半边
+    #   ——"空集=一个都不跑"——非空的白名单照样是错的。整条白名单都不该有。）
+    deny = {slug for slug, item in resolved.items() if not item["enabled"]} or None
+
+    checks = applicable_checks(
+        channels=evidence.channels,
+        modalities=evidence.modalities,
+        cross_modal_active=len(set(evidence.modalities)) >= 2
+                          or len({item.channel for item in evidence.streams}) >= 2,
+        disabled=deny,
+    )
+
+    findings: list = []
+    failed_checks: list[str] = []
+    for check in checks:
+        entry = resolved.get(check.slug) or {}
+        ctx.params = dict(entry.get("params") or {})
+        try:
+            findings.extend(check.run(ctx) or [])
+        except Exception as exc:
+            failed_checks.append(f"{check.slug}: {exc}")
+            findings.append(_error_finding(check, exc))
+
+    # 视频流登记了却没检查 —— 必须显式记一笔，但**不能混进 findings**。
+    #
+    # 视频检查项"适用"（rgb 信道存在）不等于"查过"：``probe_video=False`` 时
+    # 它们拿到的是空报告，内部直接 continue，一条结论都不产出。报告若就此收尾，
+    # 会得出 ``passed=True 全部通过`` —— 而实际上视频根本没看。
+    #
+    # ★ 但它不该混进 findings 的严重度排序：``PENDING`` 排在 ``WARN`` 之前，
+    #   一条"视频未检查"会把真实的力漂移警告盖掉（实测 52 集全被标成"待人工
+    #   确认"）。"覆盖度"和"数据有多坏"是两个维度 —— 分开报。
+    unchecked: list[dict] = []
+    if not probe_video:
+        rgb_streams = [item for item in evidence.streams if item.channel == "rgb"]
+        if rgb_streams:
+            unchecked.append({
+                "channel": "rgb",
+                "reason": "probe_video_disabled",
+                "message": f"{len(rgb_streams)} 路视频未检查（本轮只读了 parquet）",
+                "streams": [item.key for item in rgb_streams],
+            })
+
+    elapsed_ms = int((time.perf_counter() - started) * 1000)
+    report = build_report(
+        _stream_results(evidence, findings),
+        findings,
+        episode_id=episode_id,
+        project=project,
+        modalities=_modality_summary(evidence, [c.slug for c in checks]),
+        channels=evidence.channels,
+        ruleset_revision=ruleset_revision(),
+        template_source=modality_hint or "",
+        elapsed_ms=elapsed_ms,
+    )
+
+    report["unchecked"] = unchecked
+
+    if not checks:
+        # 一个检查项都没跑 —— 报告在说"没问题"，而实际是"没查"。
+        # 与 ``empty_report`` 同一条原则：没有结论不等于结论合格（fail closed）。
+        report["no_checks_ran"] = True
+
+    # ``episode`` 只反映【数据本身】的结论；``passed`` 额外要求没有未检查项。
+    #
+    # 分开的理由：前者是"数据有多坏"，后者是"我们看全了没有"。混在一起会让
+    # "视频没检查"盖过"力漂移"，也会让"数据确实没问题但没看全"看起来像数据坏了。
+    if unchecked or not checks:
+        report["passed"] = False
+
+    if failed_checks:
+        # 检查项本身出错不改判定 —— 但要让人看见，否则会误以为"这集没问题"
+        report["check_errors"] = failed_checks
+    return report
+
+
+def _modality_summary(evidence: collect.Evidence,
+                      checks_run: Iterable[str]) -> dict:
+    """PDF §1 的「数据清单」—— 这台设备是什么、有哪些信道、**实际跑了**哪些检查。
+
+    ``checks_run`` 必须是【真正执行了】的检查项（``applicable_checks`` 的结果），
+    不是配置里写的那份。两者可能差很远：设备卡片闸门会把不属于本设备的检查项
+    滤掉，而报告如果只报配置，就分不清"检查了没问题"和"压根没检查"。
+    """
+    return {
+        "device_cards": list(evidence.modalities),
+        "channels": sorted(evidence.channels),
+        "rows": evidence.rows,
+        "fps": evidence.fps,
+        "parquet": evidence.parquet,
+        "checks_run": sorted(checks_run),
+    }
+
+
+def _error_finding(check, exc: Exception):
+    """检查项抛异常时的占位结论。
+
+    用 ``ERROR``（处理失败）而不是 ``FAIL`` —— 这是"没检查成"，
+    不是"数据坏了"。混为一谈会让数据质量问题看起来比实际多。
+    """
+    from app.processing.cleaning.contract import Finding
+
+    return Finding(
+        rule=check.slug, version=check.version, status=ERROR,
+        scope="episode",
+        message=f"check failed to run: {type(exc).__name__}: {exc}",
+    )
diff --git a/processor/app/processing/cleaning/report.py b/processor/app/processing/cleaning/report.py
new file mode 100644
index 0000000000000000000000000000000000000000..1925371e5ba0c26e3ee59164c8750ccfe1101595
--- /dev/null
+++ b/processor/app/processing/cleaning/report.py
@@ -0,0 +1,250 @@
+"""清洗报告组装 —— PDF §5 的「四层结果」。
+
+    第一层 数据流     哪条流好、哪条流坏
+    第二层 时间区间   问题发生在哪几秒、哪些帧
+    第三层 episode    这一集整体什么结论
+    第四层 训练用途   能用于什么训练、不能用于什么
+
+全部是纯函数 —— 输入是检查项产出的 ``StreamResult`` / ``Finding``，
+输出是可 JSON 序列化的 dict。不碰磁盘、不碰 cv2，因此完全可单测。
+"""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Any, Iterable
+
+from app.processing.cleaning.contract import (
+    Finding, Range, StreamResult,
+    PASS, WARN, FAIL, PENDING, ERROR,
+    SEVERITY_ORDER, SEVERITY_LABELS, worst, is_blocking,
+)
+
+SCHEMA_VERSION = 2
+
+# 「训练用途」判定表 —— 声明式，不是 if-else 堆出来的。
+# requires 里的信道必须全部具备，该用途才成立。
+# PDF §7 要求"说明 episode 适合纯视觉、触觉或联合训练"，这张表就是那个说明。
+TRAINING_USE_RULES: tuple[dict[str, Any], ...] = (
+    {"use": "pure_vision",           "label": "Pure vision",
+     "requires": ("rgb", "time")},
+    {"use": "vision_gripper_joint",  "label": "Vision + gripper",
+     "requires": ("rgb", "gripper_state", "time")},
+    {"use": "slam_trajectory",       "label": "SLAM trajectory",
+     "requires": ("slam", "time")},
+    {"use": "vision_tactile_joint",  "label": "Vision + tactile",
+     "requires": ("rgb", "tactile", "time")},
+    {"use": "bimanual_tactile",      "label": "Bimanual tactile",
+     "requires": ("tactile", "time")},
+)
+
+
+def _utcnow() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def build_timeline(streams: Iterable[StreamResult | dict]) -> list[dict]:
+    """把各条流里的区间拍平成一条时间轴，按时间排序去重。
+
+    详情页要一次拉完整条时间轴，而 streams 是嵌套的 —— 所以顶层冗余一份。
+    单一来源、单一方向（从 streams 派生），有测试保证一致。
+    """
+    items: list[dict] = []
+    for stream in streams:
+        if isinstance(stream, StreamResult):
+            for item in stream.ranges:
+                items.append(_range_row(item.to_dict(), stream.stream))
+        elif isinstance(stream, dict):
+            for item in stream.get("ranges") or []:
+                if isinstance(item, dict):
+                    items.append(_range_row(item, str(stream.get("stream") or "")))
+    items.sort(key=lambda row: (row["start_sec"], row["end_sec"], row["code"]))
+    deduped: list[dict] = []
+    for row in items:
+        if deduped and all(
+            row[key] == deduped[-1][key]
+            for key in ("start_sec", "end_sec", "code", "stream")
+        ):
+            continue
+        deduped.append(row)
+    return deduped
+
+
+def _range_row(item: dict, stream: str) -> dict:
+    return {
+        "stream": item.get("stream") or stream,
+        "channel": item.get("channel") or "",
+        "start_sec": float(item.get("start_sec") or 0.0),
+        "end_sec": float(item.get("end_sec") or 0.0),
+        "start_frame": item.get("start_frame"),
+        "end_frame": item.get("end_frame"),
+        "code": str(item.get("code") or ""),
+        "severity": str(item.get("severity") or WARN),
+        "rule": str(item.get("rule") or ""),
+        "message": str(item.get("message") or ""),
+    }
+
+
+def rollup_episode(streams: Iterable[StreamResult | dict],
+                   findings: Iterable[Finding | dict] = ()) -> dict:
+    """第三层：整集结论。纯函数。
+
+    取所有流 + 所有 finding 里最严重的那个状态。
+    """
+    statuses: list[str] = []
+    failed: list[str] = []
+    warned: list[str] = []
+    pending: list[str] = []
+
+    for stream in streams:
+        if isinstance(stream, StreamResult):
+            name, status = stream.stream, stream.status
+        else:
+            name, status = str(stream.get("stream") or ""), str(stream.get("status") or PASS)
+        statuses.append(status)
+        if is_blocking(status):
+            failed.append(name)
+        elif status == PENDING:
+            pending.append(name)
+        elif status == WARN:
+            warned.append(name)
+
+    for finding in findings:
+        status = finding.status if isinstance(finding, Finding) else str(finding.get("status") or PASS)
+        statuses.append(status)
+
+    overall = worst(statuses) if statuses else PASS
+    pieces: list[str] = []
+    if failed:
+        pieces.append(f"{len(failed)} stream(s) failed")
+    if warned:
+        pieces.append(f"{len(warned)} stream(s) with warnings")
+    if pending:
+        pieces.append(f"{len(pending)} stream(s) pending review")
+    return {
+        "status": overall,
+        "status_label": SEVERITY_LABELS.get(overall, overall),
+        "failed_streams": failed,
+        "warn_streams": warned,
+        "pending_streams": pending,
+        "summary": "; ".join(pieces) if pieces else "All checks passed",
+    }
+
+
+def rollup_training_use(channels: Iterable[str],
+                        episode_status: str = PASS) -> list[dict]:
+    """第四层：这个 episode 能用于哪些训练。纯函数。
+
+    信道不具备 → 该用途判 fail（"未采集"），这是**用途维度**的失败，
+    不代表数据本身坏 —— 所以 reason 写清楚是"未采集"而不是"质量差"。
+    """
+    have = {str(item) for item in channels}
+    rows: list[dict] = []
+    for rule in TRAINING_USE_RULES:
+        required = tuple(rule["requires"])
+        missing = [channel for channel in required if channel not in have]
+        if missing:
+            rows.append({
+                "use": rule["use"],
+                "label": rule["label"],
+                "status": FAIL,
+                "reason": f"not collected: {', '.join(missing)}",
+                "requires": list(required),
+                "missing": missing,
+            })
+        else:
+            rows.append({
+                "use": rule["use"],
+                "label": rule["label"],
+                "status": episode_status,
+                "reason": "" if episode_status == PASS else "data quality problem",
+                "requires": list(required),
+                "missing": [],
+            })
+    return rows
+
+
+def passed_for(status: str) -> bool:
+    """该状态是否算"通过"（只有 PASS 算通过，WARN 不算）。"""
+    return status == PASS
+
+
+def build_report(streams: Iterable[StreamResult],
+                 findings: Iterable[Finding] = (),
+                 *,
+                 episode_id: str = "",
+                 project: str = "",
+                 modalities: dict[str, Any] | None = None,
+                 channels: Iterable[str] = (),
+                 ruleset_revision: str = "",
+                 template_source: str = "",
+                 elapsed_ms: int = 0) -> dict:
+    """组装完整报告。纯函数 —— 唯一的副作用是 ``_utcnow()``。"""
+    stream_list = list(streams)
+    finding_list = list(findings)
+    episode = rollup_episode(stream_list, finding_list)
+    use_channels = {str(item) for item in channels}
+    for stream in stream_list:
+        use_channels.update(stream.channels)
+
+    return {
+        "schema_version": SCHEMA_VERSION,
+        "episode_id": episode_id,
+        "project": project,
+        "computed_at": _utcnow(),
+        "elapsed_ms": int(elapsed_ms),
+        "ruleset_revision": ruleset_revision,
+        "template_source": template_source,
+
+        # 模态清单 —— PDF §1 的「数据清单」
+        "modalities": dict(modalities or {}),
+
+        # 判定总入口：只有 PASS 算通过
+        "passed": passed_for(episode["status"]),
+
+        # 四层结果
+        "streams": [
+            item.to_dict() if isinstance(item, StreamResult) else dict(item)
+            for item in stream_list
+        ],
+        "ranges": build_timeline(stream_list),
+        "episode": episode,
+        "training_use": rollup_training_use(use_channels, episode["status"]),
+
+        "findings": [
+            item.to_dict() if isinstance(item, Finding) else dict(item)
+            for item in finding_list
+        ],
+    }
+
+
+def empty_report(*, episode_id: str = "", project: str = "",
+                 reason: str = "no_data") -> dict:
+    """没有任何数据可检查时的占位报告。
+
+    ``passed`` 恒为 False —— 没有数据不等于数据合格（fail closed）。
+    """
+    return {
+        "schema_version": SCHEMA_VERSION,
+        "episode_id": episode_id,
+        "project": project,
+        "computed_at": _utcnow(),
+        "elapsed_ms": 0,
+        "ruleset_revision": "",
+        "template_source": "",
+        "modalities": {},
+        "passed": False,
+        "streams": [],
+        "ranges": [],
+        "episode": {
+            "status": ERROR,
+            "status_label": SEVERITY_LABELS[ERROR],
+            "failed_streams": [],
+            "warn_streams": [],
+            "pending_streams": [],
+            "summary": reason,
+        },
+        "training_use": [],
+        "findings": [],
+        "reason": reason,
+    }
diff --git a/processor/app/processing/cleaning/store.py b/processor/app/processing/cleaning/store.py
new file mode 100644
index 0000000000000000000000000000000000000000..7b245ab84c338ba387757394639d6353c001966f
--- /dev/null
+++ b/processor/app/processing/cleaning/store.py
@@ -0,0 +1,189 @@
+"""质检报告落盘 —— 写进 episode state 的 ``cleaning_report`` 字段。
+
+**报告与状态流转是同一次写入**：判 FAIL/ERROR 的批次会被拦回
+``to_review``（人工审核），并留下 ``cleaning_summary.blocking`` 这个粘性标记。
+
+只写报告、不碰状态的方案看着更"干净"，但挡住不坏数据 —— 自动批准散在
+``ai_annotation`` / ``video_quality`` 两处门禁里，它们各看各的报告，
+谁都不会读质检结论。判 FAIL 的集只要视频干净，照样被自动批准放行。
+
+另外**不动** ``deleted`` / ``rejected`` 这类状态：质检不能把用户删掉或否决过的
+批次复活。
+
+放在 ``state/episode_states/<episode_id>.json`` 而不是项目数据集里：
+后者是给 LeRobot 消费的干净树（``project_dataset`` 明确不建 ``processed/``、
+``meta/processing/``），而质检报告是 episode 级的可变状态 —— ``state/`` 正是
+它的既有归属，``ai_quality_report`` / ``video_quality_report`` 也都在这。
+
+读走 ``localstore.read_episode_state``（带内存缓存），写走
+``write_episode_state``（原子替换 + 同步更新缓存）—— 两条路径都自带锁，
+不要自己读写那个文件。
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from app.processing.cleaning.contract import is_blocking
+
+# episode state 里放质检报告的字段名。
+REPORT_FIELD = "cleaning_report"
+# 只放摘要，完整报告另存 —— 报告里可能有几十条区间，全塞进 state 会让
+# 每次 ``read_episode_state`` 都要解析几百 KB。完整报告见 ``reports_dir()``。
+SUMMARY_FIELD = "cleaning_summary"
+
+# 完整报告单独存一个目录，避免污染 episode state
+_REPORTS_SUBDIR = "quality_reports"
+
+# 允许被质检拦回人工审核的状态。
+#
+# **不含 ``to_review``**（本来就在那儿，再写一次是空操作）、也不含 ``deleted``
+# 与 ``rejected`` —— 质检不能把用户删掉/否决过的批次复活。
+_BLOCKABLE_STATUSES = frozenset({
+    "processing", "completed", "reviewed", "approved", "failed",
+})
+
+
+def _reports_dir():
+    from app.localstore import STATE_ROOT
+    return STATE_ROOT / _REPORTS_SUBDIR
+
+
+def summary_of(report: dict) -> dict[str, Any]:
+    """从完整报告里抽一个轻量摘要 —— 列表页/徽标只读这个。
+
+    ``blocking`` 是**给自动批准路径看的**闸门（见 ``is_approval_blocked``），
+    不是展示字段：判 FAIL/ERROR 才为真，WARN 只是警告、不拦。
+    """
+    episode = report.get("episode") or {}
+    return {
+        "schema_version": report.get("schema_version"),
+        "passed": bool(report.get("passed")),
+        "blocking": is_blocking(str(episode.get("status") or "")),
+        "status": episode.get("status"),
+        "status_label": episode.get("status_label"),
+        "summary": episode.get("summary"),
+        "counts": {
+            "fail": len(episode.get("failed_streams") or []),
+            "warn": len(episode.get("warn_streams") or []),
+            "pending": len(episode.get("pending_streams") or []),
+        },
+        "ranges": len(report.get("ranges") or []),
+        "ruleset_revision": report.get("ruleset_revision"),
+        "computed_at": report.get("computed_at"),
+        "reason": report.get("reason"),
+    }
+
+
+def is_approval_blocked(state: dict) -> bool:
+    """该集的质检结论是否禁止**自动批准**。
+
+    自动批准（``to_review`` → ``reviewed``）散在好几处：AI 标注的质量门禁
+    （``ai_annotation._set_ai_quality_state``）、视频门禁
+    （``video_quality._apply_video_quality_result``）。它们只看**自己的**
+    报告，不看数据质检的结论 —— 于是质检判 FAIL、视频门禁判 PASS 时，坏数据
+    会被自动放行。
+
+    ★ 为什么不能只靠"把 status 推回 to_review"：
+      几条门禁是**并发**跑的（都在 run 完成回调里 create_task），写的先后没有
+      保证。若质检先把状态推回 to_review、视频门禁随后又置成 reviewed，
+      拦截就白做了。所以质检除了推状态，还留下这个**粘性标记**，让所有自动
+      批准路径都先看一眼。
+
+    标记不需要手工清除：下一次质检会整份覆盖 ``cleaning_summary``，
+    数据修好后 ``blocking`` 自然变回 False。
+    """
+    summary = (state or {}).get(SUMMARY_FIELD) or {}
+    return bool(summary.get("blocking"))
+
+
+def save_report(episode_id: str, report: dict) -> bool:
+    """把报告写进 episode state。返回是否写入成功。
+
+    **不改 ``status``** —— 只设 ``cleaning_report`` / ``cleaning_summary`` /
+    ``cleaning_at`` 三个字段。
+
+    episode 不存在时静默跳过（外键不存在就别凭空造一条 state）。
+    """
+    from app.localstore import mutate_episode_state, _write_json
+
+    key = str(episode_id)
+    if not key:
+        return False
+
+    # 完整报告先单独落盘 —— 它可能有几十条区间，塞进 episode state 会让每次
+    # read_episode_state 都要解析几百 KB。放在下面临界区**外面**：这是个大文件
+    # 写入（在 NAS 上可能是几十毫秒），不该占着状态锁。
+    try:
+        _write_json(_reports_dir() / f"{key}.json", report)
+    except Exception:
+        pass                                # 摘要照样进 state，完整报告失败不影响
+
+    summary = summary_of(report)
+
+    def _apply(state: dict) -> bool:
+        state[REPORT_FIELD] = report
+        state[SUMMARY_FIELD] = summary
+        state["cleaning_at"] = report.get("computed_at")
+
+        # 数据不对 → 拦回人工审核。与写报告**同一次锁内 RMW**：分成两次写的话
+        # 中间那个窗口里，另一条并发的门禁可能把状态改成 reviewed。
+        if summary.get("blocking"):
+            current = str(state.get("status") or "")
+            if current in _BLOCKABLE_STATUSES:
+                state["status"] = "to_review"
+                state["approved_at"] = None
+        return True
+
+    # 走锁内 RMW：跑完工作流后 video_quality 的门禁任务与本任务是并发写的，
+    # 手写 read→write 会让其中一方的字段被另一方的旧快照覆盖（详见
+    # localstore.mutate_episode_state 的注释）。episode 不存在时返回 None，
+    # 保持"不凭空造 state"的既有行为。
+    return bool(mutate_episode_state(key, _apply))
+
+
+def load_report(episode_id: str) -> dict | None:
+    """读完整报告（不存在返回 None）。"""
+    from app.localstore import _read_json
+
+    return _read_json(_reports_dir() / f"{episode_id}.json")
+
+
+def load_summary(episode_id: str) -> dict | None:
+    """读摘要（从 episode state 取，快）。"""
+    from app.localstore import read_episode_state
+
+    return (read_episode_state(str(episode_id)) or {}).get(SUMMARY_FIELD)
+
+
+def list_reports(limit: int = 0) -> list[dict]:
+    """列出全部摘要，按时间倒序 —— 给质量列表页用。
+
+    只扫 ``quality_reports/`` 目录，不 join ``scan_sessions()`` —— 后者在
+    SSHFS 上冷读极慢，而报告是自包含的（项目名就在里面）。
+    """
+    from app.localstore import _read_json
+
+    directory = _reports_dir()
+    if not directory.is_dir():
+        return []
+    items: list[dict] = []
+    for path in directory.glob("*.json"):
+        report = _read_json(path)
+        if not isinstance(report, dict):
+            continue
+        item = summary_of(report)
+        item["episode_id"] = report.get("episode_id") or path.stem
+        item["project"] = report.get("project")
+        items.append(item)
+    items.sort(key=lambda item: str(item.get("computed_at") or ""), reverse=True)
+    return items[:limit] if limit else items
+
+
+def forget_report(episode_id: str) -> None:
+    """删除报告（episode 被删除时调用）。"""
+    for path in (_reports_dir() / f"{episode_id}.json",):
+        try:
+            path.unlink(missing_ok=True)
+        except OSError:
+            pass
diff --git a/processor/app/processing/cleaning/trigger.py b/processor/app/processing/cleaning/trigger.py
new file mode 100644
index 0000000000000000000000000000000000000000..6b90a17e65d824b54265860928dc8142864dcdb9
--- /dev/null
+++ b/processor/app/processing/cleaning/trigger.py
@@ -0,0 +1,225 @@
+"""质检触发 —— 把纯引擎接到运行时（工作流跑完之后）。
+
+三层分工，别混：
+
+    engine.py    纯函数：读证据 → 跑检查 → 出报告。不写盘、不改状态。
+    store.py     落盘：写进 episode state 的 ``cleaning_report``，**不碰 status**。
+    trigger.py   本文件：从 run 快照里判断"该不该跑、按什么配置跑"，
+                 丢到线程池执行，再把报告交给 store。
+
+调用方是 ``api/worker.py`` 的 run 完成回调（与 ``video_quality`` 的门禁任务
+同一个挂载点）。
+
+★ 为什么这里要 `to_thread`
+-------------------------
+``engine.run_checks`` 是**同步**的，而且会读 parquet / 必要时解码视频。直接在
+协程里调用会把整个事件循环卡住几秒到几十秒（存储根在 NAS 上时更甚，见
+``routes/pages.py`` 里同样的告诫）。``asyncio.to_thread`` 把它挪到线程池。
+
+★ 与 video_quality 门禁的关系
+----------------------------
+两者挂在同一张 Data Quality 卡片上，**可能同时触发**（相机类工作流就是）：
+
+    video_quality_gate   → 通过→reviewed / 失败→to_review
+    cleaning（本模块）    → 判 FAIL/ERROR 才拦回 to_review；其余只记录
+
+三条路都写同一份 episode state，所以读改写都必须走
+``localstore.mutate_episode_state``（锁内 RMW），否则后写的一方会把另一方
+刚写的字段用旧快照冲掉 —— 尤其是 ``status``，被冲掉意味着失败批次看起来
+像已通过。
+
+**光推状态还不够**：几条门禁是并发跑的，谁先写没有保证。质检除了推状态，
+还在 ``cleaning_summary.blocking`` 上留一个粘性标记，让
+``ai_annotation`` / ``video_quality`` 的**自动批准**路径主动让路 ——
+否则质检刚推回 to_review，视频门禁随后又置成 reviewed。
+"""
+
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+
+from app.processing.cleaning import engine, store
+from app.processing.cleaning.contract import normalize_device_modality
+from app.workflow_types import canonical_node_type
+
+# 质检节点在工作流里的 slug。合并前的两个旧 slug（ai_quality_review /
+# data_cleaning）由 ``workflow_types.canonical_node_type`` 统一映射到这里。
+_QUALITY_NODE = "data_quality"
+
+
+def _nodes_by_id(graph: dict) -> dict[str, dict]:
+    nodes = (graph or {}).get("nodes") or []
+    return {str(node.get("id")): node for node in nodes if node.get("id") is not None}
+
+
+def _incoming_edges(graph: dict) -> dict[str, list[str]]:
+    """``{目标节点 id: [源节点 id, ...]}``。"""
+    incoming: dict[str, list[str]] = {}
+    for edge in (graph or {}).get("edges") or []:
+        source, target = edge.get("source"), edge.get("target")
+        if source is None or target is None:
+            continue
+        incoming.setdefault(str(target), []).append(str(source))
+    return incoming
+
+
+def _node_type(node: dict | None) -> str:
+    return canonical_node_type((node or {}).get("data", {}).get("nodeType"))
+
+
+def _upstream_device_cards(node_id: str, by_id: dict[str, dict],
+                           incoming: dict[str, list[str]]) -> tuple[str, ...]:
+    """从质检节点往回找，收集上游的**设备卡片**模态。
+
+    往回找而不是只看直接上游，是因为中间可能夹着处理节点
+    （相机 → RGB-D_3D_BareHand → 质检），直接上游是个处理节点、认不出模态。
+
+    设备卡片就是链路源头，遇到就不再往回走 —— 否则会顺着"卡片A → 卡片B"
+    这种不合法的连线继续爬到别处。
+    """
+    seen: set[str] = set()
+    queue = list(incoming.get(str(node_id), ()))
+    cards: list[str] = []
+    while queue:
+        current = queue.pop(0)
+        if current in seen:
+            continue
+        seen.add(current)
+        modality = normalize_device_modality(_node_type(by_id.get(current)))
+        if modality:
+            if modality not in cards:
+                cards.append(modality)
+            continue
+        queue.extend(incoming.get(current, ()))
+    return tuple(cards)
+
+
+def data_quality_target(graph: dict,
+                        node_configs: dict) -> tuple[dict, tuple[str, ...]] | None:
+    """找到**接在数据链路上**的 Data Quality 卡片。
+
+    返回 ``(卡片配置, 上游设备卡片模态)``；没有卡片、或卡片没接线 → ``None``
+    （画布上孤零零摆一张卡片只是配置，不该触发）。
+
+    ★ 判据是"**有入边**"，不是列举"哪些源节点算数"。
+      ``ai_annotation.video_quality_gate_config`` 用的是后者，它的白名单里
+      **没有 ``gripper_device``** —— 于是 UMI 夹爪工作流接上质检卡片后静默
+      地什么都不跑。这种白名单还会继续漏：每加一种设备就漏一次，而且漏了
+      不报错。质检节点的语义本来就与上游是哪类设备无关 —— 它检查的是
+      "这个批次目录里实际有什么数据"，跑哪些检查由引擎按真实信道决定。
+    """
+    by_id = _nodes_by_id(graph)
+    incoming = _incoming_edges(graph)
+
+    # 排序保证多张卡片时结果确定，不受画布 JSON 顺序影响
+    for node_id in sorted(by_id):
+        node = by_id[node_id]
+        if _node_type(node) != _QUALITY_NODE:
+            continue
+        if not incoming.get(node_id):
+            continue                        # 没接线 —— 只是块配置，不触发
+
+        data = node.get("data") or {}
+        config = dict(data.get("config") or {})
+        config.update((node_configs or {}).get(node.get("id")) or {})
+        return config, _upstream_device_cards(node_id, by_id, incoming)
+    return None
+
+
+async def run_cleaning_checks(episode_id: str, batch_dir: str | Path, *,
+                              config: dict | None = None,
+                              device_cards: tuple[str, ...] = (),
+                              episode_index: int | None = None,
+                              project: str = "",
+                              probe_video: bool = True) -> dict:
+    """跑一次质检并落盘，返回四层报告。
+
+    ``episode_index`` 必传 —— 工作流给的 ``batch_dir`` 是**项目目录**，多集
+    共享（见 ``collect.gather_evidence`` 的告诫）。漏传的后果不是报错，而是
+    拿第 0 集的数据去比全部集的视频，得出一堆假的丢帧结论。
+
+    ``probe_video=True`` 是刻意的：只读 parquet 时视频检查拿不到证据，
+    报告会被标 ``unchecked`` 并强制 ``passed=False`` —— 每一集都"未通过"的
+    门禁等于没有门禁。代价实测约 4.8s/集（单流 UMI，本机），跑在线程池里。
+    """
+    report = await asyncio.to_thread(
+        engine.run_checks,
+        Path(batch_dir),
+        episode_id=str(episode_id),
+        episode_index=episode_index,
+        project=str(project or ""),
+        config=config,
+        probe_video=probe_video,
+        modality_hint=device_cards or None,
+    )
+    await asyncio.to_thread(store.save_report, str(episode_id), report)
+    return report
+
+
+# 后台任务的强引用。
+#
+# ``asyncio.create_task`` 的返回值**必须有人持有**：只把它丢给事件循环的话，
+# 任务可能在执行到一半时被 GC 回收（asyncio 文档原文："Save a reference to
+# the result of this function, to avoid a task disappearing mid-execution"）。
+# 这里持有到它跑完为止。
+_BACKGROUND_TASKS: set[asyncio.Task] = set()
+
+
+def spawn_cleaning_for_run(run: dict, episode: dict) -> bool:
+    """worker 完成回调调用的**同步**入口。返回是否已调度。
+
+    先做图查找再建任务：卡片没接线时连任务都不建（同步、纯字典遍历，很快），
+    这样"没有质检节点"这条常见路径不会往事件循环里塞空任务。
+    """
+    if data_quality_target((run or {}).get("graph") or {},
+                           (run or {}).get("node_configs") or {}) is None:
+        return False
+    task = asyncio.create_task(trigger_cleaning_for_run(run, episode))
+    _BACKGROUND_TASKS.add(task)
+    task.add_done_callback(_BACKGROUND_TASKS.discard)
+    return True
+
+
+async def trigger_cleaning_for_run(run: dict, episode: dict) -> dict | None:
+    """跑一次质检的后台协程。卡片没接线时返回 None。
+
+    **永不抛异常**：这是后台任务，抛出去会变成 unhandled asyncio exception，
+    而调用方（worker 的完成响应）已经返回了，没人能处理。失败只记日志 ——
+    与 ``video_quality.run_video_quality_review`` 同样的取舍。
+    """
+    episode_id = str((run or {}).get("episode_id") or (episode or {}).get("id") or "")
+    batch_dir = (episode or {}).get("path")
+    if not episode_id or not batch_dir:
+        return None
+
+    try:
+        target = data_quality_target(
+            (run or {}).get("graph") or {},
+            (run or {}).get("node_configs") or {},
+        )
+        if target is None:
+            return None
+        config, device_cards = target
+
+        report = await run_cleaning_checks(
+            episode_id, batch_dir,
+            config=config, device_cards=device_cards,
+            # ``get_episode`` 的记录里 episode_index 可能是 0，不能用 or 兜底
+            episode_index=(episode.get("episode_index")
+                           if episode.get("episode_index") is not None else None),
+            project=str(episode.get("project") or ""),
+        )
+    except Exception as exc:                # noqa: BLE001 —— 后台任务不抛
+        print(f"[Quality] Data quality checks failed for {episode_id}: "
+              f"{type(exc).__name__}: {exc}")
+        return None
+
+    summary = store.summary_of(report)
+    verdict = str(summary.get("status"))
+    if summary.get("blocking"):
+        verdict += " -> blocked, back to manual review"
+    print(f"[Quality] {episode_id}: {verdict} "
+          f"({summary.get('ranges', 0)} ranges, "
+          f"{len(device_cards)} device card(s))")
+    return report
diff --git a/processor/app/processing/modules/ai_quality_review.py b/processor/app/processing/modules/ai_quality_review.py
deleted file mode 100644
index c5438601c4fe86974e65a5ee6b9712f251e36847..0000000000000000000000000000000000000000
--- a/processor/app/processing/modules/ai_quality_review.py
+++ /dev/null
@@ -1,36 +0,0 @@
-"""AI Quality Review — lightweight media and annotation quality gate.
-
-The actual check runs after the workflow result is persisted.  It checks video
-decode/frame continuity/black screens/freezes and, when connected after AI
-Annotation, annotation coverage too.  This node keeps the normal artifact
-contract so existing worker graphs remain compatible.  The service-level gate
-moves failed/incomplete batches to the existing Reviewing queue and only
-allows a passed result to become Approved.
-"""
-
-from app.processing import ProcessingModule, JobContext, ArtifactRef
-from app.processing.registry import register
-from app.processing.theme import REVIEW_COLOR
-
-
-@register
-class AIQualityReviewModule(ProcessingModule):
-    slug = "ai_quality_review"
-    version = "1.0"
-    category = "review"
-    label = "AI Quality Review"
-    icon = "ant-design:robot-outlined"
-    color = REVIEW_COLOR
-    inputs = ({"key": "data", "label": "Quality Review Target"},)
-    outputs = ({"key": "reviewed", "label": "Reviewed Data"},)
-    default_config = {"mode": "gate"}
-    execution_target = "server"
-    capabilities = ("quality_review",)
-
-    def run(self, ctx: JobContext) -> dict[str, ArtifactRef] | None:
-        # The workflow executor still receives the upstream artifact.  The
-        # episode-level gate is applied by the AI annotation service after its
-        # persisted ranges have been validated.
-        if not ctx.incoming:
-            ctx.skip("No upstream data — skipped")
-        return dict(ctx.incoming)
diff --git a/processor/app/processing/modules/data_quality.py b/processor/app/processing/modules/data_quality.py
new file mode 100644
index 0000000000000000000000000000000000000000..6b66e34dcaea94b1580119feaac23e4ddb4beb4a
--- /dev/null
+++ b/processor/app/processing/modules/data_quality.py
@@ -0,0 +1,126 @@
+"""Data Cleaning —— 数据清洗（质检）：一个节点统管确定性与 AI 两类检查。
+
+显示名是 Data Cleaning；slug 仍是 ``data_quality``（持久化契约，改它会让已保存
+工作流的 nodeType 对不上）。两者不一致是有意的 —— 见下方端口 key 的同类说明。
+
+本节点由两个旧节点合并而来，两者功能高度重叠：
+
+    ai_quality_review  视频检查(黑屏/冻结/丢帧/解码) + AI 标注覆盖率
+    data_cleaning      视频检查 + UMI/手套/EGO 检查（第 2 期接入）
+
+历史原因：视频检查最早"寄居"在 ``ai_quality_review`` 里，好让纯视频工作流
+也有质量门禁（见 ``ai_annotation.py`` 的 ``video_quality_review_node_config``
+docstring）。现在合并成一张卡片，语义与配置都归一处。
+
+**两个旧 slug 都作为别名保留**（``workflow_types.LEGACY_TO_CANONICAL``），
+已保存的工作流打开时自动迁移，连线不受影响 —— 端口的 key 刻意保持不变：
+
+    输入  data      所有旧连线都用它
+    输出  reviewed  旧连线用它接 lerobot_export
+
+检查分两层，与清洗方案 PDF §4 的两栏一一对应：
+
+    机器可直接判断（确定性、免费、可每集跑）
+      ├─ 视频：解码 / 黑屏 / 冻结 / 丢帧
+      ├─ UMI：帧对齐 / action / 夹爪量程 / SLAM 连续性
+      ├─ 手套：全零 / 死点 / 漂移 / 饱和
+      └─ EGO：曝光 / 关键点缺失 / 左右手
+
+    需联合判断或复核（有成本、可选）
+      └─ AI 标注覆盖率；将来的 VLM 语义复核
+
+检查项的算法实现与工作流适配器分开，与 ``app/processing/black_glove`` 同构：
+
+    app/processing/cleaning/                ← 契约 + 检查项 + 报告组装
+    app/processing/modules/data_quality.py  ← 本文件：artifact 契约 + 端口 + 配置
+
+新增检查项 = 在 ``app/processing/cleaning/checks/`` 下放一个 .py，本文件不用改。
+
+**只出结论，不产出数据** —— 原始数据一字不改，也不生成 clean_v1 之类的副本。
+区间信息完整保留在报告的 ``ranges`` 里，下游按 ``training_use`` 过滤即可。
+
+数据不对时**卡在人工审核**：判 FAIL/ERROR 的批次会被推回 ``to_review``
+（就是审核页的入口），并在 ``cleaning_summary.blocking`` 上留一个粘性标记，
+让 AI 标注 / 视频门禁的自动批准路径让路。WARN 只记录、不拦。
+"""
+
+from __future__ import annotations
+
+from app.processing import ProcessingModule, JobContext, ArtifactRef
+from app.processing.registry import register
+from app.processing.theme import REVIEW_COLOR
+
+
+@register
+class DataQualityModule(ProcessingModule):
+    slug = "data_quality"
+    version = "1.0"
+    category = "review"
+    label = "Data Cleaning"
+    # 必须取自 web/static/iconify-preload.js 的白名单 —— 图标是离线预载的,
+    # 不在表内的名字 iconify-icon 会去 api.iconify.design 拉,调色板一次渲染
+    # 全部节点,一个漏网图标就能让整块面板卡住。check-circle 表示"校验",
+    # 与同组 review 节点的 eye(human) 不冲突。
+    # 改图标后请跑 scripts/check_icon_preload.sh。
+    icon = "ant-design:check-circle-outlined"
+    color = REVIEW_COLOR
+
+    # 端口 key 是持久化契约 —— 取值必须与合并前的 ai_quality_review 逐字一致,
+    # 否则已保存工作流的连线会因 sourceHandle/targetHandle 对不上而失效。
+    # 详见 workflow_types.py 里前端对 ``out.key === inp.key`` 的校验。
+    inputs = ({"key": "data", "label": "Data"},)
+    outputs = ({"key": "reviewed", "label": "Reviewed Data"},)
+
+    # 配置结构（前端设置弹窗按设备卡片写入）::
+    #
+    #     {"devices": {
+    #        "gripper_device": {
+    #          "checks": {
+    #            "umi.slam_continuity": {"enabled": true,
+    #                                    "params": {"max_linear_mps": 3.0}},
+    #            "video.freeze":       {"enabled": false}
+    #          }}}}
+    #
+    # 引擎侧由 ``cleaning.engine.resolve_config()`` 解析。
+    default_config = {"devices": {}}
+
+    # ★ 刻意留空 —— 配置全部走专用弹窗（DeviceQualityModal），不走通用
+    #   config_schema 渲染。
+    #
+    #   通用那套是**平铺字段列表**，表达不了"按设备卡片分组 + 每项带阈值"的
+    #   嵌套结构；硬塞会变成一长串 enable_xxx 开关。曾短暂用过那套，结果是
+    #   三个阈值在节点里和检查项里各存一份（frame_tolerance 与
+    #   video.frame_drop.tolerance_ratio 同义），迟早不一致。
+    #
+    #   现在阈值只有一处定义：检查项的 ``default_params``；节点只存"覆盖值"。
+    config_schema = ()
+
+    # 真实检查在 run 完成回调里跑（那时才能读到合并后的 episode 数据），
+    # 与 human_review / 旧 ai_quality_review 的分工一致。
+    # 注：该字段当前无消费方，仅作语义标注（全仓 grep 只见 schema 与文档）。
+    execution_target = "server"
+    capabilities = ("data_quality", "quality_gate", "quality_review")
+
+    def run(self, ctx: JobContext) -> dict[str, ArtifactRef] | None:
+        """透传上游 artifact。上游没连 → skipped。
+
+        **真正的检查不在 ``run()`` 里跑** —— 在 worker 的 run 完成回调里
+        （``api/worker.py`` 调 ``cleaning.trigger.spawn_cleaning_for_run``）。
+
+        为什么不在 ``run()``：DAG 执行期 worker 是在 staging 目录里干活、
+        产物要等 ``_publish_episode_result`` 才合并回批次目录。在这一步读
+        批次目录，拿到的是**上一轮**的数据 —— 尤其 ``action`` 列，它由
+        ``umi_slam_action`` 派生产出，读早了会全是采集端的零占位。
+        完成回调时数据已经合并完毕，与 ``human_review`` / 旧
+        ``ai_quality_review`` 的分工一致。
+
+        检查所需的数据**不靠端口传** —— 完成回调手上就有
+        ``localstore.get_episode()`` 的记录（``path`` + ``episode_index``），
+        检查项直接读批次目录。
+
+        ★ 进来的是 ``episode_index`` 不是可选的：``path`` 是**项目目录**，
+          几十集共享，漏传会拿第 0 集的数据去比全部集的视频。
+        """
+        if not ctx.incoming:
+            ctx.skip("No upstream data — skipped")
+        return dict(ctx.incoming)
diff --git a/processor/app/project_dataset.py b/processor/app/project_dataset.py
index cba14102fc16b2303512255fdd37f3ef5c9beb04..34b7806dfe5b41c446443daa7b97432dace342bc 100644
--- a/processor/app/project_dataset.py
+++ b/processor/app/project_dataset.py
@@ -102,6 +102,17 @@ def write_project_episode_index(project_root: Path,
     # The legacy flat JSONL index is intentionally not generated anymore.
     (project_root / "meta" / "episodes.jsonl").unlink(missing_ok=True)
 
+    # ★ 必须失效缓存 —— 本函数是**索引的唯一写入点**，而 project_episode_rows()
+    #   读的是带 60s TTL 的模块级缓存。不失效的话，同一次调用里"写完再读"会拿到
+    #   删除前的旧行。
+    #
+    #   实测后果（2026-09-11 引入缓存时漏掉这步，删除从此全坏）：
+    #     delete_project_episode: 读一次(预热缓存) → 删文件 → 写索引 → 校验
+    #     校验又调 project_episode_rows → 旧缓存 → 报 "missing data" → RuntimeError
+    #     →「清空回收站」500。盘上的索引其实是对的，纯粹是缓存没跟上。
+    #   （delete_episode 末尾也会 invalidate_session_cache()，但那要等异常之后。）
+    invalidate_project_cache(project_root)
+
 
 def is_project_dataset(root: Path) -> bool:
     root = Path(root)
@@ -1402,13 +1413,30 @@ def merge_normalized_episode(project_root: Path, episode_root: Path,
     }
 
 
+# 人工/脚本留下的备份与临时文件 —— 不是删除或合并操作产生的，不该算到校验头上。
+#
+# ★ 为什么必须放过它们：``delete_episode`` 在**删完文件之后**才跑本校验，校验失败就
+#   抛 RuntimeError → 500，而「清空回收站」是循环处理的，一个项目失败整轮中止。
+#   实测踩过：两个 D435 项目的 meta/ 里各有一个 ``info.json.bak-20260908-144550``
+#   （9-08 留下的），于是**每次清空都 500、什么都删不掉**，而前端没有错误分支，
+#   用户看到的是"点了没反应"。一个备份文件不该有这种杀伤力。
+_IGNORED_ENTRY_SUFFIXES = (".bak", ".orig", ".tmp", ".save", "~")
+
+
+def _is_ignorable_entry(name: str) -> bool:
+    """备份/临时文件，或隐藏文件 —— 校验一律不看。"""
+    if name.startswith("."):
+        return True
+    return name.endswith(_IGNORED_ENTRY_SUFFIXES) or ".bak-" in name
+
+
 def verify_project_dataset(project_root: Path) -> dict[str, Any]:
     root = Path(project_root)
     rows = project_episode_rows(root)
     errors: list[str] = []
     unexpected = sorted(
         path.name for path in root.iterdir()
-        if path.name not in _CANONICAL_ROOTS and not path.name.startswith(".")
+        if path.name not in _CANONICAL_ROOTS and not _is_ignorable_entry(path.name)
     ) if root.is_dir() else []
     errors.extend(f"unexpected project root entry: {name}" for name in unexpected)
     expected_meta = {"info.json", "stats.json", "tasks.json", "episodes"}
@@ -1416,7 +1444,7 @@ def verify_project_dataset(project_root: Path) -> dict[str, Any]:
     if meta_root.is_dir():
         unexpected_meta = sorted(
             path.name for path in meta_root.iterdir()
-            if path.name not in expected_meta and not path.name.startswith(".")
+            if path.name not in expected_meta and not _is_ignorable_entry(path.name)
         )
         errors.extend(f"unexpected meta entry: {name}" for name in unexpected_meta)
     for row in rows:
@@ -2074,11 +2102,25 @@ def append_project_episode(project_root: Path, episode_root: Path,
         existing = next((row for row in rows
                          if str(row.get("episode_id") or row.get("source_batch") or "") == str(episode_id)), None)
         if existing is None:
-            target_episode_index = max(
-                [_episode_index(row.get("episode_index")) for row in rows
-                 if _episode_index(row.get("episode_index")) is not None],
-                default=-1,
-            ) + 1
+            used = {_episode_index(row.get("episode_index")) for row in rows
+                    if _episode_index(row.get("episode_index")) is not None}
+            # ★ 优先沿用**名字里的编号**，让存储索引与公开 ID 一致。
+            #
+            #   此前一律 max(used)+1，于是"名字说 000005、索引是 3"这种对不上的
+            #   情况会出现 —— 实测 119 个带编号批次里 **21 个**中招。它的直接
+            #   危害在 _match_episode_row 的名字回退：按名字推出索引后会撞上
+            #   别的批次（模拟：删 ..._000002 时若它自己的行已缺失，会去删
+            #   index=2 那个批次的数据和视频）。
+            #
+            #   编号允许空洞（见本模块 delete_project_episode 的说明
+            #   "gaps are valid"），所以直接采用名字里的编号是安全的。
+            #   两种情况仍回落到 max+1：名字里没有编号；或该编号已被别的批次
+            #   占用（撞号）。
+            named = episode_index_from_name(episode_id)
+            if named is not None and named not in used:
+                target_episode_index = named
+            else:
+                target_episode_index = max(used, default=-1) + 1
             chunk_index = episode_chunk_for_index(target_episode_index)
         else:
             if not replace:
@@ -2104,6 +2146,17 @@ def append_project_episode(project_root: Path, episode_root: Path,
             if project_existed and backup_root.exists():
                 backup_root.rename(project_root)
             raise
+        # ★ 换入之后必须失效【project_root】的缓存，不能只靠
+        #   write_project_episode_index 里那次 —— 那次失效的是 **temp_root**
+        #   的 key，而内容是靠 rename 换过来的。
+        #
+        #   不失效的后果有两条：
+        #     (1) 紧跟的 verify_project_dataset(project_root) 读到的还是**追加前**
+        #         的旧行 —— 校验等于在验旧树，"通过"是空头支票（实测：连续三次
+        #         append 全部通过，而盘上索引早已是 [0,1,2,5,6,7]）；
+        #     (2) 缓存有 60 秒的盲目 TTL（TTL 内连指纹都不查），上传后前端
+        #         最长 60 秒看不到新批次。
+        invalidate_project_cache(project_root)
         result["verification"] = verify_project_dataset(project_root)
         result["backup"] = str(backup_root) if project_existed else None
         return result
diff --git a/processor/app/routes/export.py b/processor/app/routes/export.py
index 9ec1461ae378a999e8eb5a1d0bb8996d97a3b0ec..ee2702c7d0b90ef06888c1a09e3645bee5fb3b73 100644
--- a/processor/app/routes/export.py
+++ b/processor/app/routes/export.py
@@ -38,6 +38,9 @@ router = APIRouter(prefix="/api/v1/export", tags=["export"])
 
 EXPORTS_DIR = STATE_ROOT / "exports"
 EXPORT_TASKS_DIR = STATE_ROOT / "export_tasks"
+# 可训练的数据集 —— 与 EXPORTS_DIR 分开:那边是按 run_id 命名的**处理产物**
+# (每条一集),这边是**能拿去训练的成品**,训练页只列这个目录。
+DATASETS_DIR = STATE_ROOT / "datasets"
 # 导出页/批量导出的构建目录与 zip 放本地盘:同一份视频数据不再在
 # NAS(SSHFS ~28MB/s)上读写三遍,只保留一次源文件读取。
 LOCAL_EXPORTS_DIR = settings.upload_staging_root / "exports"
@@ -484,6 +487,38 @@ async def batch_download_sessions(request: Request):
 
 # ── 导出任务(JSON,后台打包)─────────────────────────
 
+def _persist_trainable_dataset(export_root: Path, dataset_name: str) -> Path | None:
+    """把导出好的数据集落到 ``state/datasets/<名字>/``,让它能当训练输入。
+
+    原来是打包完直接 ``rmtree``(省本地空间)—— 结果导出的成果只剩一个 zip,
+    磁盘上什么都没有,训练页根本无从列起。
+
+    **交换式替换**,不是"先删旧的再搬新的":先把新数据集搬进 ``.staging``,
+    再把旧的挪到 ``.old``,然后 rename 上位,最后删 ``.old``。任何一步失败都不会
+    让目标位置处于"半个数据集"的状态 —— 直接 rmtree 再 move 的话,搬到一半
+    失败就两头落空。
+
+    返回落位后的路径;``export_root`` 里没有 ``meta/info.json``(不是数据集)时
+    返回 None,调用方照旧删掉临时目录。
+    """
+    if not (export_root / "meta" / "info.json").is_file():
+        return None
+
+    DATASETS_DIR.mkdir(parents=True, exist_ok=True)
+    target = DATASETS_DIR / dataset_name
+    staging = DATASETS_DIR / f".{dataset_name}.staging"
+    previous = DATASETS_DIR / f".{dataset_name}.old"
+
+    shutil.rmtree(staging, ignore_errors=True)
+    shutil.move(str(export_root), str(staging))
+    shutil.rmtree(previous, ignore_errors=True)
+    if target.exists():
+        target.rename(previous)
+    staging.rename(target)          # 同盘 rename,原子
+    shutil.rmtree(previous, ignore_errors=True)
+    return target
+
+
 def _load_task(job_id: str) -> dict | None:
     return _read_json(EXPORT_TASKS_DIR / f"{job_id}.json", None)
 
@@ -573,8 +608,9 @@ def _run_export_task(job_id: str, episode_ids: list[str], export_format: str,
         ]
         if blocked:
             raise RuntimeError("Some episodes are still in Reviewing")
-        # 构建与 zip 都在本地盘进行(NAS 只读一次源文件);zip 是最终
-        # 产物,构建目录打包完成后即删除以节省本地空间。
+        # 构建与 zip 都在本地盘进行(NAS 只读一次源文件)。产物两样都留:
+        # zip 供下载,数据集目录(LeRobot 分支)供训练页选用 —— 后者走
+        # _persist_trainable_dataset 落到 state/datasets/,不再是"打完包就删"。
         dest = LOCAL_EXPORTS_DIR / f"{job_id}.zip"
         dest.parent.mkdir(parents=True, exist_ok=True)
         export_root = LOCAL_EXPORTS_DIR / f"{dataset_name}-{job_id[:8]}"
@@ -591,12 +627,17 @@ def _run_export_task(job_id: str, episode_ids: list[str], export_format: str,
                                   progress_callback=_on_episode)
             _set_progress(0.75)
             _zip_directory(export_root, dest)
+            # 打包后**留下**数据集,不要删 —— 训练页的数据集列表就是从这里读的
+            # (state/datasets/)。只有它压根不是数据集时才清掉临时目录。
+            if _persist_trainable_dataset(export_root, dataset_name) is None:
+                shutil.rmtree(export_root, ignore_errors=True)
             _set_progress(0.95)
         else:
             _set_progress(0.2)
             _zip_episode_selection([str(e) for e in episode_ids], dest)
             _set_progress(0.95)
-        shutil.rmtree(export_root, ignore_errors=True)
+            # 非 LeRobot 分支产出的只是一个选集的 zip,没有数据集目录可留。
+            shutil.rmtree(export_root, ignore_errors=True)
         task = _load_task(job_id)
         if task:
             task["status"] = "completed"
@@ -788,7 +829,9 @@ _RE_TASKS: dict[str, dict] = {}
 _RE_TASKS_DIR = STATE_ROOT / "re_export_tasks"
 
 _PASSTHROUGH_TYPES = {
-    "annotation", "human_review", "ai_annotation", "ai_quality_review",
+    # data_quality 由 ai_quality_review + data_cleaning 合并而来；此处的 t 已过
+    # canonical_node_type()，旧 slug 不会出现。
+    "annotation", "human_review", "ai_annotation", "data_quality",
 }
 _CAMERA_TYPES = {"rgb_camera", "fisheye_camera", "rgbd_camera", "stereo_camera",
                  "stereo_rgbd_camera", "mono_camera"}
diff --git a/processor/app/routes/pages.py b/processor/app/routes/pages.py
index 26766a8019c797ceac1d0f085767e59000f0e2ad..804f93cc737e97a4abf40a0d65dd3b8d43b078ba 100644
--- a/processor/app/routes/pages.py
+++ b/processor/app/routes/pages.py
@@ -21,10 +21,30 @@ _static_dir = STATIC_DIR
 
 # 静态资源缓存键的唯一来源:模板里写 ``?v={{ asset_version }}``。
 # 以前每个模板各写各的日期串,发版时靠人记得逐个改 —— 漏一个,那个页面
-# 就会继续发浏览器缓存里的旧脚本。现在只 bump app/version.py 一处。
-from app.version import __version__ as _asset_version
-
-templates.env.globals["asset_version"] = _asset_version
+# 就会继续发浏览器缓存里的旧脚本。
+#
+# ★ 取的是**前端号**(web/VERSION),不是后端号。改前端只 bump 那一个文件即可,
+#   提交信息里的「前端 X」就是它 —— 缓存键和版本记录是同一个数,不会对不上。
+#   (原来取后端号,于是每次改前端都要同时 bump 后端号和前端号两个地方。)
+from app.web_version import frontend_version as _frontend_version
+
+templates.env.globals["asset_version"] = _frontend_version()
+
+# 服务端取词 —— 模板里写 ``{{ t('nav_home') }}``。语言由 app/i18n.py 的
+# LanguageMiddleware 从 cookie 读进 ContextVar,这里是同一个上下文,读得到。
+# 这样首屏渲染出来的就是正确语言,不再"先英文后由 JS 纠正"(那会闪一下)。
+from app.i18n import get_current_lang as _get_lang
+from app.i18n import t as _t
+
+templates.env.globals["t"] = _t
+# 模板要写 <html lang="…">,所以语言码也放进全局。
+#
+# ★ 注册的是**函数**,模板里必须写成 ``{{ current_lang() }}`` 带括号。
+#   Jinja 的全局是"每次渲染取一次这个对象" —— 值是固定的,而语言是**每请求**
+#   才定的(存在 ContextVar 里),所以只能注册一个可调用的东西,渲染时调它。
+#   少写括号不会报错,只会把函数的 repr 渲染进 HTML:
+#       <html lang="&lt;function get_current_lang at 0x7f…&gt;">
+templates.env.globals["current_lang"] = _get_lang
 
 
 @router.get("/", response_class=HTMLResponse)
@@ -68,6 +88,16 @@ async def trash_page(request: Request):
     return templates.TemplateResponse("trash.html", {"request": request})
 
 
+@router.get("/train", response_class=HTMLResponse)
+async def train_page(request: Request):
+    """Model training — read-only view of checkpoints produced outside the platform.
+
+    Data comes from ``GET /api/v1/training/runs`` (see ``app/routes/training.py``).
+    Nothing on this page starts or stops training yet.
+    """
+    return templates.TemplateResponse("train.html", {"request": request})
+
+
 @router.get("/users", response_class=HTMLResponse)
 async def users_page(request: Request, _: dict = Depends(require_roles("admin"))):
     """Account management is visible only to administrators."""
diff --git a/processor/app/routes/training.py b/processor/app/routes/training.py
new file mode 100644
index 0000000000000000000000000000000000000000..c999590ee4b76543c1acd9cc9e584d070317705b
--- /dev/null
+++ b/processor/app/routes/training.py
@@ -0,0 +1,78 @@
+"""Training API —— 路由层,薄薄一层。
+
+业务逻辑在 ``app/training/`` 下(产物扫描 / GPU 读取 / 数据集发现),这里只负责
+把它们挂到 URL 上。**没有任何训练执行** —— 见那个包的 docstring。
+
+将来接执行时,新端点加在这里(创建 / 停止 / 日志),形状与现有的保持一致;
+真正的子进程管理写在 ``app/training/runner.py``。
+"""
+
+from __future__ import annotations
+
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import FileResponse
+
+from app.training import (
+    list_datasets, list_gpus, list_projects_progress, list_runs,
+)
+from app.training.runs import resolve_checkpoint_file
+
+router = APIRouter(prefix="/api/v1/training", tags=["training"])
+
+
+@router.get("/gpus")
+def gpus():
+    """本机 GPU(读 ``nvidia-smi``)。
+
+    **驱动不可用时靠 ``available: false`` 区分**,不要把它当成"利用率 0%" ——
+    详见 ``app/training/gpus.py``。
+    """
+    return list_gpus()
+
+
+@router.get("/datasets")
+def datasets():
+    """可训练的数据集 —— 审核页导出后落在 ``state/datasets/`` 的成品。
+
+    空列表是**正常**的(还没导出过),前端据此渲染引导而不是报错。
+    """
+    return list_datasets()
+
+
+@router.get("/runs")
+def runs():
+    """训练产物(checkpoints)。目录不存在时返回空列表,不是 404。"""
+    return list_runs()
+
+
+@router.get("/ready")
+def ready():
+    """各项目离「可以导出」还有多远 —— 训练页「到点提醒」用。
+
+    判据:**已通过集数达到项目设置的采集上限**(``params.target_episodes``)。
+    到点之后只**提醒**,不自动导出 —— 理由见 ``app/training/projects.py``。
+    """
+    return list_projects_progress()
+
+
+@router.get("/runs/{run_name}/checkpoints/{step}/files/{name:path}")
+def download_checkpoint_file(run_name: str, step: str, name: str):
+    """下载 checkpoint 里的单个文件。
+
+    ``{name:path}`` 而不是 ``{name}``:要下的文件在子目录里
+    (``pretrained_model/model.safetensors``),默认的路径参数不匹配斜杠。
+
+    **安全性由 ``resolve_checkpoint_file`` 保证** —— 它只在扫描出的真实文件清单里
+    按名精确匹配,不做路径拼接,所以构造不出清单外的路径(比如 ``../../etc/passwd``)。
+    详见那个函数的 docstring。
+
+    单个文件而不是打包 zip:一个 checkpoint 约 600MB,其中 ``training_state/``
+    (优化器状态,约 400MB)**只在续训时有用**,拿去推理/部署只需要
+    ``pretrained_model/``(约 200MB)。让用户按需下载,比强制他拉一个 600MB 的包好。
+    """
+    path = resolve_checkpoint_file(run_name, step, name)
+    if path is None or not path.is_file():
+        raise HTTPException(status_code=404, detail="No such checkpoint file")
+    # filename 只取最后一段 —— 让浏览器存成 model.safetensors 而不是把整条相对路径
+    # 当成文件名(带斜杠的文件名在多数系统上写不出来)。
+    return FileResponse(path, filename=path.name)
diff --git a/processor/app/training/__init__.py b/processor/app/training/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..ea9d69f9d034e3937d887f85776cf8ffd508304b
--- /dev/null
+++ b/processor/app/training/__init__.py
@@ -0,0 +1,24 @@
+"""训练域 —— 产物发现、GPU 读取,以及将来的训练执行。
+
+**目前不含任何训练执行。** 下面三个模块都只是**只读扫描**:
+
+    gpus.py       本机 GPU(nvidia-smi)
+    datasets.py   state/datasets/ 下的可训练数据集
+    runs.py       settings.train_root 下的训练产物(checkpoints)
+
+将来接执行时,子进程管理、任务状态、日志解析落在 ``runner.py``;路由仍旧留在
+``app/routes/training.py``(与 ``app/ai_annotation.py`` + ``routes/annotations.py``
+的分工一致:域逻辑在域包里,HTTP 那层很薄)。
+
+**为什么单独开一个包而不是继续放 ``routes/training.py``**:和前端
+``static/js/train/`` 对称,让训练功能一开始就有个像样的家。反例就在旁边 ——
+``app/ai_annotation.py`` 长到 180KB 才想起来该拆。新功能先模块化,比事后从
+大文件里往外抠容易得多。
+"""
+
+from app.training.datasets import DATASETS_DIR, list_datasets
+from app.training.gpus import list_gpus
+from app.training.projects import list_projects_progress
+from app.training.runs import list_runs
+
+__all__ = ["DATASETS_DIR", "list_datasets", "list_gpus", "list_projects_progress", "list_runs"]
diff --git a/processor/app/training/datasets.py b/processor/app/training/datasets.py
new file mode 100644
index 0000000000000000000000000000000000000000..fb64b9de9ba00b200de622215a7c1510887add2b
--- /dev/null
+++ b/processor/app/training/datasets.py
@@ -0,0 +1,71 @@
+"""可训练数据集的发现 —— ``state/datasets/<名字>``。
+
+这些是**在视频审核页选中「已通过」的集、导出后留下来的成品**(落盘见
+``app/routes/export.py: _persist_trainable_dataset``)。
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from app.localstore import STATE_ROOT
+
+# 与 `app/routes/export.py` 的 DATASETS_DIR 是同一个目录。从 STATE_ROOT 推出来
+# 而不是 import 那个模块:写进去的和读出来的必须指向同一处,而"唯一真源"本来
+# 就是 STATE_ROOT。两边若哪天分叉,导出落下的数据集训练页就会看不见 ——
+# 改其中一处时记得对照另一处。
+DATASETS_DIR = STATE_ROOT / "datasets"
+
+
+def list_datasets() -> dict:
+    """``{"datasets": [...], "root": str, "exists": bool}``。
+
+    **不列 ``sessions/<项目>`` 原始项目。** 原始项目里混着未审核的集,而且
+    留出集(UMIGripper_Action_AI 的 52–73)就在里面 —— 按项目选等于同时踩两个
+    坑,UI 上只能报警拦不住。导出那一步才是唯一能明确控制"到底训了哪些集"的
+    地方,所以以导出产物为准。
+
+    **也不列 ``state/exports/*``。** 那边是按 run_id 命名的**处理产物**,实测
+    168 条里每条 ``total_episodes`` 都是 1(单集),凑不成训练集。
+    """
+    root = DATASETS_DIR
+    if not root.is_dir():
+        return {"datasets": [], "root": str(root), "exists": False}
+
+    datasets: list[dict] = []
+    try:
+        for entry in sorted(root.iterdir()):
+            # 跳过 .staging / .old 这类交换中间态 —— 它们只在替换过程中短暂出现。
+            if not entry.is_dir() or entry.name.startswith("."):
+                continue
+            info_path = entry / "meta" / "info.json"
+            if not info_path.is_file():
+                continue
+            try:
+                info = json.loads(info_path.read_text(encoding="utf-8"))
+            except (OSError, ValueError):
+                continue
+            if not isinstance(info, dict):
+                continue
+            episodes = int(info.get("total_episodes") or 0)
+            if episodes <= 0:
+                continue
+            try:
+                mtime = int(info_path.stat().st_mtime)
+            except OSError:
+                mtime = 0
+            datasets.append({
+                "name": entry.name,
+                "path": str(entry),
+                "total_episodes": episodes,
+                "total_frames": int(info.get("total_frames") or 0),
+                "fps": float(info.get("fps") or 0),
+                "codebase_version": str(info.get("codebase_version") or ""),
+                "mtime": mtime,
+            })
+    except OSError:
+        return {"datasets": [], "root": str(root), "exists": True}
+
+    datasets.sort(key=lambda d: (-d["total_episodes"], d["name"]))
+    return {"datasets": datasets, "root": str(root), "exists": True}
diff --git a/processor/app/training/gpus.py b/processor/app/training/gpus.py
new file mode 100644
index 0000000000000000000000000000000000000000..21e20ff3abe758f248e4d8f9be03049106682fc6
--- /dev/null
+++ b/processor/app/training/gpus.py
@@ -0,0 +1,67 @@
+"""本机 GPU 读取 —— 直接问 ``nvidia-smi``。
+
+这一层**不认识 HTTP**:它返回普通 dict,由 ``app/routes/training.py`` 直接
+交给 FastAPI 序列化。所以它可以被将来任何地方复用(比如训练 runner 起子进程
+前先确认显卡可用),而不必绕道走一遍路由。
+"""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+
+# nvidia-smi 的查询字段 —— 顺序即解析顺序,改这里必须同步改 _parse 的索引。
+_QUERY = "index,name,memory.used,memory.total,utilization.gpu,temperature.gpu"
+
+
+def _parse(stdout: str) -> list[dict]:
+    gpus: list[dict] = []
+    for line in stdout.strip().splitlines():
+        parts = [p.strip() for p in line.split(",")]
+        if len(parts) < 6:
+            continue
+        try:
+            gpus.append({
+                "index": int(parts[0]),
+                "name": parts[1],
+                "memory_used_mb": int(float(parts[2])),
+                "memory_total_mb": int(float(parts[3])),
+                "utilization": int(float(parts[4])),
+                "temperature": int(float(parts[5])),
+            })
+        except ValueError:
+            continue                  # 单卡读不出来不该让整张列表失败
+    return gpus
+
+
+def list_gpus() -> dict:
+    """``{"available": bool, "error": str, "gpus": [...]}``。
+
+    **驱动没起来时如实报错,不要返回一排 0。** 实测这台机器上 ``nvidia-smi``
+    会以 "couldn't communicate with the NVIDIA driver" 失败;若把它当成
+    "利用率 0%、显存 0" 渲染出去,看起来是"显卡闲着可以训",而真相是"根本
+    问不到显卡"。前端据此显示明确的错误条 —— `available` 这个字段存在的唯一
+    理由就是让调用方**必须**区分这两种情况。
+    """
+    nvidia_smi = shutil.which("nvidia-smi")
+    if not nvidia_smi:
+        return {"available": False, "error": "nvidia-smi not found", "gpus": []}
+
+    try:
+        proc = subprocess.run(
+            [nvidia_smi, f"--query-gpu={_QUERY}", "--format=csv,noheader,nounits"],
+            capture_output=True, text=True, timeout=10, check=False,
+        )
+    except (OSError, subprocess.SubprocessError) as exc:
+        return {"available": False, "error": str(exc), "gpus": []}
+
+    if proc.returncode != 0:
+        # 驱动没起来走的就是这条 —— nvidia-smi 把原因写在 stderr。
+        lines = (proc.stderr or proc.stdout or "").strip().splitlines()
+        return {
+            "available": False,
+            "error": lines[0] if lines else f"nvidia-smi exited {proc.returncode}",
+            "gpus": [],
+        }
+
+    return {"available": True, "error": "", "gpus": _parse(proc.stdout)}
diff --git a/processor/app/training/projects.py b/processor/app/training/projects.py
new file mode 100644
index 0000000000000000000000000000000000000000..7851b19f482084322407f52feb5cd2cd83f567b8
--- /dev/null
+++ b/processor/app/training/projects.py
@@ -0,0 +1,83 @@
+"""项目离「可以导出」还有多远 —— 训练页「到点提醒」的数据源。
+
+判据由用户定:**已通过集数达到项目设置的采集上限**(``params.target_episodes``)
+就算「到点」。到点之后训练页提醒一下,由人去点导出,而不是自动跑 8 小时。
+
+★ 为什么不做全自动:导出一次约 **30 秒/集**(见 UI 的 batch_export_hint),
+一个 1000 集的项目要跑 8 小时以上,而且构建好的数据集会被"固定"下来 ——
+已经拿去训练的那份不能悄悄变。让机器跑 8 小时 vs 让人点一下,后者换到的是
+"我知道现在在导什么、用哪份数据"。
+"""
+
+from __future__ import annotations
+
+from app.localstore import list_projects, scan_sessions
+
+# 与项目「已通过」口径一致的状态。与 export.py 的导出前置校验用的是同一组
+# (那边是 ("reviewed", "approved")),不要各写一套。
+_APPROVED = ("reviewed", "approved")
+
+
+def _count_by_project() -> tuple[dict[str, int], dict[str, int]]:
+    """``({项目名: 已上传集数}, {项目名: 已通过集数})``。
+
+    **只扫一次。** ``scan_sessions()`` 是全量遍历,数据挂在 NAS/sshfs 上时很贵
+    (见 README 里"打开 episode 慢"那一条);按项目各扫一遍就是 O(项目数) 次全量。
+    """
+    uploaded: dict[str, int] = {}
+    approved: dict[str, int] = {}
+    try:
+        episodes = scan_sessions()
+    except Exception:
+        return uploaded, approved        # 存储暂时不可用时不该让整页炸掉
+    for episode in episodes:
+        name = episode.get("project")
+        if not name:
+            continue
+        uploaded[name] = uploaded.get(name, 0) + 1
+        if episode.get("status") in _APPROVED:
+            approved[name] = approved.get(name, 0) + 1
+    return uploaded, approved
+
+
+def list_projects_progress() -> dict:
+    """``{"projects": [...], "ready_count": int}``,按接近上限的程度排序。
+
+    每个项目带 ``target`` / ``uploaded`` / ``approved`` / ``ready``:
+
+        target    项目设置的采集上限(params.target_episodes);没设就是 0
+        uploaded  已上传的集数(不分审核状态)
+        approved  已通过(``reviewed``/``approved``)的集数
+        ready     approved >= target,且 target > 0
+
+    **target 为 0 的项目永远不算 ready** —— 没设上限就没有"到点"这回事,
+    不能把"没配"当成"已达"。
+    """
+    uploaded, approved = _count_by_project()
+
+    projects: list[dict] = []
+    for project in list_projects():
+        name = str(project.get("name") or "")
+        if not name:
+            continue
+        target = int((project.get("params") or {}).get("target_episodes") or 0)
+        done = approved.get(name, 0)
+        projects.append({
+            "name": name,
+            "target": target,
+            "uploaded": uploaded.get(name, 0),
+            "approved": done,
+            # target <= 0 ⇒ 没配上限 ⇒ 永不 ready(见 docstring)
+            "ready": target > 0 and done >= target,
+        })
+
+    # 已达上限的排最前,其次按完成度高的排 —— 页面从上往下读就是"先看这个"。
+    def sort_key(item: dict) -> tuple:
+        ratio = (item["approved"] / item["target"]) if item["target"] else -1.0
+        return (not item["ready"], -ratio, -item["approved"])
+
+    projects.sort(key=sort_key)
+    return {
+        "projects": projects,
+        "ready_count": sum(1 for p in projects if p["ready"]),
+    }
diff --git a/processor/app/training/runs.py b/processor/app/training/runs.py
new file mode 100644
index 0000000000000000000000000000000000000000..550b02a5564e5590a34762471875cb3689a21ea7
--- /dev/null
+++ b/processor/app/training/runs.py
@@ -0,0 +1,175 @@
+"""训练产物的发现 —— ``settings.train_root`` 下的 ``checkpoints/<step>/``。
+
+模型由官方 ``lerobot-train`` 在平台**之外**训练,产物就是一棵目录树。这一层
+只负责如实把它读出来,不判断好坏、不执行任何训练。
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from app.config import settings
+
+
+def _step_of(name: str) -> int | None:
+    """``checkpoints`` 下的目录名 ⇒ 步数。
+
+    正常的 checkpoint 目录就是零填充的步数(``005000``)。``last/`` 之类的
+    非数字目录**跳过** —— 它通常是个空的符号链接残留,列出来只会让人以为
+    多了一个模型。无法解析一律返回 None,调用方据此过滤。
+    """
+    try:
+        return int(str(name).strip())
+    except (TypeError, ValueError):
+        return None
+
+
+def _collect_files(root: Path) -> tuple[int, list[dict]]:
+    """递归列出一个 checkpoint 的全部文件与总字节数。
+
+    用 ``rglob`` 遍历真实磁盘内容而不是写死 ``pretrained_model/`` 与
+    ``training_state/`` 两棵子树 —— 不同 LeRobot 版本落盘的文件集不一样
+    (我们比参考实现少 ``scheduler_state.json``、多四个 pre/postprocessor),
+    写死会在版本升级时静默漏列文件。
+    """
+    files: list[dict] = []
+    total = 0
+    for path in sorted(root.rglob("*")):
+        try:
+            if not path.is_file():
+                continue
+            st = path.stat()
+        except OSError:
+            continue                      # 竞态:训练正在写/文件刚被删
+        files.append({
+            "name": str(path.relative_to(root)),
+            "size": st.st_size,
+            "mtime": int(st.st_mtime),
+        })
+        total += st.st_size
+    return total, files
+
+
+def _read_train_config(checkpoint: Path) -> dict:
+    """读 checkpoint 的 ``train_config.json``;缺失/损坏返回 {}。
+
+    这份就是「训练参数」页签的数据源 —— 训练当时实际用的超参,而不是我们
+    事后猜的默认值。
+    """
+    path = checkpoint / "pretrained_model" / "train_config.json"
+    try:
+        doc = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return {}
+    return doc if isinstance(doc, dict) else {}
+
+
+def _scan_run(run_dir: Path) -> dict | None:
+    """把一个 ``output_dir`` 扫成一个 run;没有 ``checkpoints/`` 就返回 None。"""
+    checkpoint_root = run_dir / "checkpoints"
+    if not checkpoint_root.is_dir():
+        return None
+
+    checkpoints: list[dict] = []
+    for entry in sorted(checkpoint_root.iterdir()):
+        if not entry.is_dir():
+            continue
+        step = _step_of(entry.name)
+        if step is None:
+            continue
+        total_bytes, files = _collect_files(entry)
+        if not files:
+            continue                      # 空目录(如 last/ 的残留)不成其为模型
+        checkpoints.append({
+            "step": step,
+            "name": entry.name,
+            "file_count": len(files),
+            "total_bytes": total_bytes,
+            "files": files,
+            # 参数按**该 checkpoint**自己的配置读,不跨 checkpoint 复用 ——
+            # 同一个 output_dir 下不同步数的超参可以不同(改过参数续训)。
+            "train_config": _read_train_config(entry),
+        })
+
+    if not checkpoints:
+        return None
+    # 最新的排最前 —— 页面按这个顺序展示,「训练参数」页签也取第一份。
+    checkpoints.sort(key=lambda item: item["step"], reverse=True)
+    newest = checkpoints[0]
+    policy = newest["train_config"].get("policy") or {}
+    return {
+        "name": run_dir.name,
+        "path": str(run_dir),
+        "model_type": str(policy.get("type") or ""),
+        "checkpoint_count": len(checkpoints),
+        "total_bytes": sum(c["total_bytes"] for c in checkpoints),
+        "checkpoints": checkpoints,
+    }
+
+
+def resolve_checkpoint_file(run_name: str, step: str, relative_name: str) -> Path | None:
+    """把 (run 名, checkpoint 名, 相对文件名) 解析成一个可下载的**真实路径**。
+
+    找不到返回 None,由路由层转成 404。
+
+    ★ **安全:不做路径拼接。** 直觉写法是 `checkpoint_dir / relative_name`,但那样
+    ``../../../../etc/passwd`` 就能读到任意文件 —— 这个端点是要对外开下载的,
+    必须挡住。这里改成:**先扫一遍拿到磁盘上的真实文件清单,再按名字精确匹配**,
+    所以返回的路径必然来自真实条目,构造不出清单外的路径。
+
+    (不用 `Path.resolve()` + `is_relative_to` 那种断言式校验 —— 清单匹配是从
+    源头上就没有越界的可能,而不是"先拼出来再检查拼对了没"。)
+    """
+    wanted = str(relative_name or "").strip()
+    if not wanted:
+        return None
+
+    data = list_runs()
+    for run in data.get("runs", []):
+        if run.get("name") != run_name:
+            continue
+        for checkpoint in run.get("checkpoints", []):
+            if checkpoint.get("name") != step:
+                continue
+            for entry in checkpoint.get("files", []):
+                if entry.get("name") == wanted:
+                    root = Path(run["path"]) / "checkpoints" / step
+                    return root / wanted
+    return None
+
+
+def list_runs() -> dict:
+    """``{"runs": [...], "root": str, "exists": bool}``。
+
+    **两种层级都支持**,因为两种都很常见、也都会被人配进来:
+
+        root 本身就是 run      <root>/checkpoints/<step>/…
+        root 是 run 的父目录   <root>/<run>/checkpoints/<step>/…
+
+    实测默认路径 ``文件测试/umi_act_model`` 属于前者 —— 把它按后者扫会
+    一律返回空列表(``umi_act_model/checkpoints/checkpoints`` 当然不存在)。
+
+    目录不存在 ⇒ ``{"runs": []}``(不是错误):新机器、或本机从未跑过训练,
+    都是正常情况,前端据此渲染空态而不是把"没有模型"显示成"出错了"。
+    """
+    root = settings.train_root
+    if not root.is_dir():
+        return {"runs": [], "root": str(root), "exists": False}
+
+    runs: list[dict] = []
+    try:
+        own = _scan_run(root)
+        if own is not None:
+            runs.append(own)
+        else:
+            for entry in sorted(root.iterdir()):
+                if not entry.is_dir():
+                    continue
+                run = _scan_run(entry)
+                if run is not None:
+                    runs.append(run)
+    except OSError:
+        return {"runs": [], "root": str(root), "exists": True}
+
+    return {"runs": runs, "root": str(root), "exists": True}
diff --git a/processor/app/umi_slam_action.py b/processor/app/umi_slam_action.py
index 3a362bad20414dc83984b70182053571a4ad4241..51bb5c068c4cbbff9a432a4a2f95047218c64fec 100644
--- a/processor/app/umi_slam_action.py
+++ b/processor/app/umi_slam_action.py
@@ -73,7 +73,8 @@ def matrix_to_rotvec(rotation: np.ndarray) -> np.ndarray:
 
 
 def poses_from_trajectory(trajectories, timestamps,
-                          frame_count: int) -> np.ndarray | None:
+                          frame_count: int,
+                          diagnostics: dict | None = None) -> np.ndarray | None:
     """从 ``observation.slam_trajectory`` 的样本缓冲重建逐帧位姿 ``(N, 7)``。
 
     slam_trajectory 是采集端的高频(50Hz)样本缓冲,每格存
@@ -90,6 +91,18 @@ def poses_from_trajectory(trajectories, timestamps,
     的锚点做最小二乘拟合,不依赖外部时钟。
 
     返回 ``(frame_count, 7)``;样本不足返回 ``None``。
+
+    传入 ``diagnostics`` 时会把覆盖率统计写进去(就地更新,不改返回值):
+
+        {"frames": N,              # 总帧数
+         "direct": n,              # 有真实样本直接覆盖的帧
+         "interpolated": n,        # 只能插值兜底的帧  ← ★ 真正该关心的数字
+         "empty_slots": n}         # 自己格子里没有样本的帧(含被相邻格子救回的)
+
+    ★ 注意 ``empty_slots`` 不是问题指标 —— 位姿流是 20/20/60ms 突发、数据帧是
+    1/30s 均匀网格,自己格子为空是**设计使然**(实测占 ~28%),其中 97% 能被
+    相邻格子覆盖。真正该关心的是 ``interpolated``:既没有本地样本、邻近格子
+    也没有,只能靠插值硬补 —— 那才是 SLAM 跟丢的证据。
     """
     import numpy as np
 
@@ -110,13 +123,24 @@ def poses_from_trajectory(trajectories, timestamps,
         groups = values.size // 8
         if groups <= 0:
             continue
+        last_sample_t: float | None = None
         for g in range(groups):
             chunk = values[g * 8:g * 8 + 8]
             if not np.isfinite(chunk).all():
                 continue
-            samples.append((float(chunk[0]), [float(v) for v in chunk[1:8]]))
-        if has_anchor[index]:
-            anchor_slam.append(float(values[(groups - 1) * 8]))
+            last_sample_t = float(chunk[0])
+            samples.append((last_sample_t, [float(v) for v in chunk[1:8]]))
+        # 锚点取【最后一个有效组】的 t,而不是盲取最后一组。
+        #
+        # 导出产物会把 slam_trajectory 补齐到定长(如 128 = 16 组),补的是 NaN
+        # (见 lerobot_export._pad_sparse_matrix_columns)。盲取最后一组会把
+        # NaN 塞进下面的 polyfit 方程 → SVD 不收敛 → LinAlgError,整集派生失败。
+        #
+        # canonical 数据(采集端直接写的变长列表)不含 NaN,所以生产路径碰不到;
+        # 但任何"读导出数据集再派生"的场景(质检、re-export、数据回灌)都会踩。
+        # 上面的循环已经跳过 NaN 组了,这里复用同一个判定即可。
+        if has_anchor[index] and last_sample_t is not None:
+            anchor_slam.append(last_sample_t)
             anchor_data.append(float(stamp[index]))
     if len(samples) < 2 or len(anchor_slam) < 2:
         return None
@@ -153,6 +177,16 @@ def poses_from_trajectory(trajectories, timestamps,
 
     # 4) 真实样本覆盖不到的少数帧(实测约 3%)才插值兜底
     valid = np.where(~missing)[0]
+    if diagnostics is not None and frame_count > 0:
+        # 注意用 missing.sum() 而不是 len(missing) —— 后者是数组长度(恒等于
+        # frame_count),不是 True 的个数。两者相加必须等于 frames。
+        diagnostics.update({
+            "frames": int(frame_count),
+            "direct": int(len(valid)),            # 有真实样本直接覆盖
+            "interpolated": int(missing.sum()),   # 只能插值兜底
+            # 自己格子里没样本的帧数 —— 由调用方按需统计,这里只报总数
+            "empty_slots": int(diagnostics.get("empty_slots", 0)),
+        })
     if len(valid) < 2:
         return None
     for index in np.where(missing)[0]:
diff --git a/processor/app/version.py b/processor/app/version.py
index 75e90ae8a60aa4afaa3e60d3c9513ecd834be711..2838e61c399db2e2888f21b7138b661af411344e 100644
--- a/processor/app/version.py
+++ b/processor/app/version.py
@@ -6,12 +6,13 @@
   - 新增功能 / 接口变化      → 次版本 +1 (0.1.x → 0.2.0)
   - 不兼容的大改动           → 主版本 +1 (x.0.0)
 
-这个号同时被用作**静态资源的缓存键**(见 app/routes/pages.py 注入的
-``asset_version``):改了 JS/CSS 只要 bump 这里,所有模板的 ``?v=`` 一起失效。
-不要再逐个模板手写日期串 —— 漏掉一个就会给用户继续发旧脚本
-(本次就漏过 exports.html,它加载的还是 202609032200 版 app.js)。
+**这个号只管后端。** 它**不再是**静态资源的缓存键 —— 从 1.19.4 起,模板里的
+``?v={{ asset_version }}`` 取自 **web/VERSION**(前端号,见 app/web_version.py)。
+改前端不用再动这里;改后端也不用(前端资源没变,不需要失效缓存)。
 
-前端版本独立管理, 见 web/workflow-studio/package.json 的 version 字段.
+前端版本独立管理, 见 **web/VERSION** —— 它覆盖 processor/web/ 下的全部前端代码
+(templates/ + static/ + workflow-studio/),不只是那个 React SPA。
+`web/workflow-studio/package.json` 的 version 只代表 SPA 自己,两者不必同步。
 """
 # 1.8.0 审核页选择功能重构(项目级三态全选、批量栏置顶 + 快慢双路径、
 #       15s 轮询不再整表重绘)+ 导出性能(力矩阵分位数向量化 15×)
@@ -38,4 +39,877 @@
 #       (启动前 fusermount3 -u -z)、API/worker 改 Requires+After 挂载、
 #       Restart 一律 always;另加每分钟看门狗自动重挂/重启。纯运维配置,
 #       无代码行为与用户可见变化
-__version__ = "1.8.6"
+# 1.8.7 图标离线化收尾。iconify-icon 对**不在** iconify-preload.js 白名单里的
+#       图标会去 api.iconify.design 拉,国内网络下表现为页面/面板卡住几秒。
+#       替换三处漏网图标:侧边栏 Users(team-outlined → user-outlined,
+#       每个页面都渲染)、AI 标注遮罩(loading-3-quarters-outlined →
+#       loading-outlined)、以及新增的工作流清洗节点。同时把
+#       scripts/check_icon_preload.sh 的扫描范围扩到 app/processing/modules/
+#       —— 节点图标是在 Python 里声明的,此前漏扫,改了白名单外的图标
+#       检查脚本仍报「全部已预加载」
+# 1.9.0 数据质检子系统上线(后端 + 设置面板)。
+#       卡片合并:AI Quality Review + Data Cleaning → Data Quality(旧 slug 自动迁移,
+#       端口 key 不变因此连线不受影响)。9 个检查项(视频 4 + UMI 5)按设备卡片
+#       声明归属,设置面板按连线出的设备分 tab 独立配置检查项与阈值。
+#       新 API:/api/v1/quality/{checks,summary,episodes/*}。报告只写
+#       episode state 的 cleaning_report,**不碰 status 流转**(只记录不拦截)。
+#       阈值只有一处定义(检查项的 default_params),节点只存覆盖值
+# 1.9.1 质检**真正跑起来**。1.9.0 只把节点和面板立了起来,``run()`` 还是透传,
+#       跑工作流并不会执行任何检查。接法:worker 的 run 完成回调调
+#       ``cleaning.trigger.spawn_cleaning_for_run``(与 video_quality 门禁同一
+#       挂载点,放后台任务、走线程池)——**不在 ``run()`` 里跑**,因为 DAG 执行期
+#       worker 在 staging 目录干活,那时读到的是上一轮数据(action 列会是采集端
+#       的零占位)。需要 ``episode_index``:``get_episode()['path']`` 是**项目
+#       目录**、多集共享,漏传会拿第 0 集的 parquet 比全部集的视频。
+#
+#       同时修掉三处「检查项静默不跑」——都不报错、报告照常生成:
+#       (1) 配置白名单 bug:前端只在用户**碰过**的项上写 entry,引擎却把"显式
+#           启用的那些"当白名单,于是**改一个阈值 = 其余检查项全部停跑**
+#           (实测 9 项变 1 项)。配置只该是黑名单。
+#       (2) 模态推断推不出 stereo_rgb/stereo_rgbd_camera("立体"不是列名能看见
+#           的特征),双目工作流在设置面板配的阈值查不到 tab、静默用默认值。
+#           改为「工作流连线的 hint ∪ 数据推断」。
+#       (3) 状态覆盖竞态:``read/write_episode_state`` 各自加锁,RMW 跨两步不是
+#           原子的;质检与 video_quality 门禁在同一个 run 后并发写同一份 state,
+#           后写的会用旧快照把先写的冲掉(``status`` 被冲 = 失败批次看着像已通过)。
+#           新增 ``localstore.mutate_episode_state``(锁内 RMW),两条路都改用它。
+#           对照实验:12 线程并发下手写 RMW 存活 1/12 且抛 10 次 FileNotFoundError
+#           (``_write_json`` 的临时文件名是固定的、多人共用),锁内 RMW 存活 12/12。
+# 1.9.2 数据不对 → **卡在人工审核**。质检判 FAIL/ERROR 的批次推回 to_review
+#       (审核页的入口,复用既有状态机,不新建状态),WARN 只记录不拦。
+#
+#       光推状态挡不住:自动批准散在 ai_annotation._set_ai_quality_state 与
+#       video_quality._apply_video_quality_result 两处,它们只看**自己的**报告
+#       —— 质检判 FAIL、视频判 PASS 时坏数据照样被放行。而且三条门禁是并发跑
+#       的(都在 run 完成回调里 create_task),谁先写没有保证。所以质检额外在
+#       cleaning_summary.blocking 上留一个**粘性标记**,两条自动批准路径都先
+#       查它;标记由下一次质检整份覆盖,数据修好后自动解封。
+#
+#       拦截只针对**自动**批准:人工批准不受影响(实测 verified)。
+#       另外不碰 deleted/rejected —— 质检不能把用户删掉或否决过的批次复活。
+#       顺带把 _set_ai_quality_state 也收进锁内 RMW(它此前是手写 read→write,
+#       与修复前的视频门禁同一个竞态)。
+# 1.9.3 修采集层三处静默失效(为接入手套检查清路)。都不报错、报告照常生成:
+#       (1) **非首集读出空帧** —— canonical 是一集一文件,采集却取
+#           ``parquets[0]`` 再按 ``episode_index`` 列筛行,于是第 0 个文件只装
+#           第 0 集、其余集全筛成空。报告退化成 empty_report(episode.status=
+#           ERROR),在 1.9.2 的"数据不对就拦"链路里表现为**除第 0 集外每一集都
+#           被卡在人工审核**。改成按布局解析:canonical 选对文件且不再筛行,
+#           导出产物(一文件多集)才筛行。全量验证 22 集/16 个不同 episode_index
+#           零空报告(含编号有空洞的 000007)。
+#       (2) **触觉阵列被截断** —— _CHANNEL_WIDTH 没有 tactile 项,落到 3 的兜底
+#           值,16x16=256 个感应点被静默截成 3 个(检查项只看得到 1%)。改为
+#           "不在表里的信道一律不截断",兜底成某个具体数字本身就是隐患。
+#       (3) **observation.tactile.* 认不出** —— 触觉有两套命名:采集协议写
+#           observation.*_glove,导出统一成 observation.tactile.*。只认前者,
+#           于是只跑过导出的树上手套信道为空、手套检查整条静默跳过。加别名
+#           归一化;两套并存时保留协议名(同一份数据,登记两条流会让缺陷报两次)。
+#       顺带核对:同项目内 schema 不一致(实测 D435 第 3 集只有右手)采集层本就
+#       按"有什么收什么"处理,无需改;但**写手套检查项时不能假设双手都在**。
+# 1.9.4 手套检查项上线(5 项),设置面板的 Glove Sensor tab 不再是空的。
+#       阈值不是拍的 —— 全部从真实数据反推,过程写在 checks/glove/ 各文件里:
+#         (1) **16×16 空间快照,行主序展平**。证据分两条,强度不同:
+#             - 行主序+每行 16 个: 自相关 |v[i]-v[i+k]| 对 k=1..40 在 **k=16**
+#               处有尖锐极小值(S80C 左 43.6,而 k=15 是 86、k=17 是 87),
+#               四份数据全部如此 → i 与 i+16 是空间邻居 ⇒ 每行 16 个、行主序。
+#             - 16×16 这个分解: 试了 6 种(16x16、8x32、32x8、4x64、64x4),
+#               16x16 的相邻格平均差最小(187 vs 227+)。**但行主序与列主序的
+#               数值完全相同(互为转置,总和对称)—— 这个测试区分不了行列,
+#               行列是上面那条自相关定的。**
+#             快照 vs 滚动缓冲: 相邻帧做任何格数平移差异都**更大**(不平移 33.0
+#             vs 平移 78+,随机帧对 57.6) → 是快照。接触区稳定是 11-13 高 x
+#             3-7 宽(沿行索引长、沿列索引窄);把它读成"手指"是**推测**,没证实。
+#         (2) **取值被固件门限:要么 0,要么 >= 500.02**,0 到 500 之间一个值都
+#             没有(实测最小非零 500.0234)。所以 0 的含义是"未接触"而不是
+#             "力为零"。glove.gate_floor 就是盯这个门限的 —— 固件改版/scale
+#             应用两次时,列还在、还是 256 维、数还在合理区间,只有值域整体位移。
+#         (3) **设备更新约 7.5Hz**(30fps 录制下同一个值连续保持恰好 4 帧) →
+#             受压时静止 3-4 帧是**正常**。阈值取 warn 40 / fail 300 帧,留足
+#             余量给将来更新率更低的设备。
+#         (4) **不做逐点"死点"检查**。整集恒定的感应点占 30-86%,图案是规则
+#             条纹/块状(左右手不同、跨项目也不同),那是**手套的传感分区**与
+#             手指是否接触,不是坏点 —— 做死点会在每一集误报 136-161/256。
+#             跨集基线也救不了:某根手指在全部集里都没用过同样分不出来。
+#       顺带加 device_status 信道(字符串列)。**数值化会把字符串列变成全空
+#       元组**(vector_series 转 float 抛异常被吞),检查项拿到的是"没有数据"
+#       看起来像通过 —— 所以 _column_series 对字符串先分流。
+#
+#       设置面板的 tab 只显示**画布上连到本节点**的设备卡片(用户明确要求:
+#       没连接的设备不显示)。注意与执行侧的口径差异: 检查跑不跑取决于批次数据
+#       里有哪些信道(engine 按 evidence.channels 筛),连线只决定"卡片有没有
+#       入边(质检跑不跑)"和"显示哪些 tab"。所以理论上存在"数据里有该类设备、
+#       但画布上没连到质检卡 —— 检查照跑、阈值却在面板里配不到"的情况。
+# 1.9.5 采集层认多相机 SLAM 命名。``observation.slam_*`` 是默认相机,双目/多把
+#       第二路存成 ``observation.<相机名>_slam_*``,而采集写死了两个不带前缀的
+#       列名**并且循环末尾 break** —— 于是(1)只有前缀命名的集**有 SLAM 数据却一个
+#       SLAM 检查都不跑**,(2)双目的第二路从来没被检查过,两处都不报错。
+#       改为按相机分组解析(每个相机各一条流,组内 trajectory 优先),列名用正则
+#       匹配并排除两个近亲: ``observation.slam_trajectory_ns``(时间戳伴生列) 与
+#       ``processing.umi_slam_action.data_4.action``(处理缓存,名字里恰好含 slam)。
+#       实测 Test94_000003 立刻暴露真问题: 第二路相机 44.3%(601/1358) 的帧靠插值
+#       兜底,之前完全不可见。
+#       顺带把 slam_continuity 的注释与实现对齐(注释写"默认判 WARN 只报告",
+#       实现一直是分档的: 单次跳变 WARN、>=10 处 FAIL)。**只改注释不改行为**。
+# 1.9.6 工作流调色板"进入页面后要等一会才刷新"。节点注册表 registry 是**模块级
+#       Map、不是 React state** —— 往里面塞节点不触发重渲染。而 App 挂载后才异步
+#       拉 /api/v1/workflows/modules 并 hydrate 一次,且 App() 自身既无 useState 也
+#       不订阅 store(它只渲染一次),NodePalette 也没被 memo —— 于是调色板停留在
+#       BUILTIN 兜底清单上,要等**用户跟它交互**(打字搜索/点折叠/悬停出提示)才
+#       顺带刷新。「UMI Slam Action」这类不在 BUILTIN 里的节点因此迟迟不出现。
+#
+#       接口本身不慢:实测一次页面加载里 /modules 与其他请求都在 1 秒内返回,
+#       所以问题不在网络而在**不重渲染**。
+#
+#       修法:registry 加版本号+订阅,NodePalette 用 useSyncExternalStore 订阅;
+#       hydrateNodeTypes 结束时通知一次(循环内逐条通知会让调色板重渲染 N 次)。
+#       纯前端改动,刷新即生效,不用重启后端。
+# 1.9.7 质检全链路文案英文化。工作台界面本就是英文的(Home / Projects / Reviewing /
+#       Approved …),只有新加的质检是中文 —— 现在对齐:14 个检查项的 label/
+#       description、30 条 Finding.message、SEVERITY_LABELS、report 里的训练用途
+#       标签与 summary、前端弹窗与参数标签、以及质检的日志输出。
+#       代码注释与 docstring **保持中文**(与全仓一致),只改面向用户的字符串。
+#       测试里断言文案的 6 处一并同步。
+# 1.9.8 画布端口与模块命名（前端为主，后端只有显示名）。
+#       (1) **模块显示名 Data Quality → Data Cleaning**（用户要求：它就是数据清洗功能）。
+#           slug 仍是 data_quality —— 那是持久化契约，改它会让已保存工作流的
+#           nodeType 对不上，要再迁一次。只改显示名，不动 slug。
+#       (2) **Data Quality 的输入端口按入边动态生成**：每接一个设备多一个口，口名
+#           取上游那个端口的名字。此前所有线挤在同一个 data 口上，口名只能把几个
+#           上游拼起来（"Glove Sensor Data, RGB Video"），越长越读不出来。
+#           端口 key = `dynamicInputKey(源节点, 源端口)`，稳定可重复；老图的边在
+#           normalizeWorkflowGraphForEditor 里迁移（全库实测只影响 1 个工作流 5 条边）。
+#           往**任意已有的口**上拖也能新增连接 —— onConnect 会把 targetHandle 重写
+#           成新上游的 key。**只对 data_quality 这一张卡生效**（DYNAMIC_INPUT_TYPES），
+#           其余节点的端口文字一律保持声明文案。
+#       (3) **卡片高度改为按各自端口数算**。此前是画布统一算的（取注册表里静态端口
+#           的最大值）—— 对运行时才长出来的动态口无能为力，接第 5 个设备时被撑破。
+#           顺带删掉那条全局计算与 getMaxPortRows（已被完全覆盖）。
+#       (4) 修三处「拿规范化后的类型去比旧 slug」的**死条目**（永远匹配不上）：
+#           canonicalLabelTypes / controlledPorts / _migrateWorkflowGraph 的
+#           result→reviewed 改写。前两者导致老图一直显示旧标签 "AI Quality Review"
+#           （不走 descriptor.label）；第三处本就该与后端 workflow_types.py 的
+#           {"human_review","data_quality"} 对齐。另删 CANONICAL_PORTS 与 BUILTIN 里
+#           两个同类的死条目（BUILTIN 那个会让卡片在水合完成前短暂显示旧名）。
+#
+#       走过又撤掉的弯路（记录在此免得再走）：曾把「输入 key 是 data 就显示上游
+#       端口名」应用到**所有**泛化端口节点，以及把设备卡片的数据种类（后端从
+#       MODALITY_CHANNELS 派生）展开成标签 —— 两者都被否掉了：前者波及导出/标注卡，
+#       后者字长且与上游卡片重复。
+# 1.10.0 用户菜单加「界面语言」切换（中/英）。i18n.js 早就写好了一整套
+#       （225 个 key × 2 语言、t()/setLang()/localStorage），但**切换入口从来没接**
+#       —— updateLangToggle() 找的是 #lang-toggle，所有模板里都没有这个元素，
+#       功能等于死的。现在在用户下拉里加了 English / 中文 两个选项。
+#
+#       顺带修一个真 bug：setLang() 一直写 localStorage，但**没有任何地方读它** ——
+#       currentLang 写死 'en'，每次刷新都退回英文，切换等于没切。DOMContentLoaded
+#       现在先读回保存的语言（隐私模式禁 storage 时 try/catch 回落默认）。
+#
+#       ⚠️ 覆盖度仍然不全：9 个模板里只有 4 个有 data-i18n 标注（index 24 / tasks 13 /
+#       base 7 / trash 3），exports、login、overview、users **一处都没有**（users 约
+#       39 处可见文本）。工作流画布是独立 React 应用，完全不走这套。补齐是第二步。
+# 1.10.1 侧边栏与用户菜单补齐中英切换（1.10.0 只接了入口，导航项没标注）。
+#       补 6 处：Workflow / Users / Annotation 三个导航项，以及用户菜单里的
+#       Profile / Change Password / Logout。侧边栏每个页面都渲染，感知最强。
+#       EgoData（品牌名）与 English / 中文（语言自名）**刻意不翻** —— 语言选项
+#       写自己的文字，切到中文后英文项不该变成"英语"，否则反而找不到。
+#
+#       ★ 菜单项的文字必须先包进 <span>：applyTranslations 用的是
+#         ``el.textContent = t(...)``，直接在 <a> 上挂 data-i18n 会把同级的
+#         iconify-icon 一起冲掉（图标会消失）。
+#
+#       登录页（login.html）**保持英文**，不进这套 —— 用户要求：登录后再切。
+#       剩余未标注：users(45) / overview(14) / index(13) / exports(10) / tasks(2)
+#       模板文案，以及 JS 动态生成的约 50-70 处；工作流画布是独立 React 应用，
+#       完全不覆盖。
+# 1.10.2 工作流画布接中英切换（第一段：语言通道 + 调色板 + 工具栏）。
+#       画布是**独立 React 应用**，不加载 web/static/js/i18n.js。两边靠两个约定打通：
+#         1. 同一个 localStorage 键 `lang` —— 模板侧 setLang 写、React 侧读
+#         2. 自定义事件 `egodata:lang` —— 模板侧切换时派发，React 侧监听
+#       ★ 不用 storage 事件：那个**只在别的标签页**触发；而切换按钮就在本页侧边栏。
+#       新增 src/i18n.ts：useT() 订阅语言，语言一变所有用到它的组件重渲染。
+#       本轮覆盖：调色板（Input/Review/Process/Export 四个分组 + 搜索框 + 底部提示）、
+#       PipelineToolbar（New/Save/Save As/Export/Workflow list）、顶栏（Template/
+#       设为模板/取消模板/Del/Cancel/新建工作流/从模板开始 + 模板对话框说明）。
+#       缺词回落 key 本身（如 palette.search）而不是静默显示英文 —— 漏翻一眼看得见。
+#
+#       未覆盖（后续）：节点卡片名（后端 20 个模块 label）、节点端口名（registry.ts
+#       约 38 处）、DeviceQualityModal 参数标签（26 处）、NodeSettingsModal（11 处）、
+#       workflowStore 的 toast（10 处）。
+# 1.10.3 工作流画布中文化（第二段：节点卡片名 + 端口名 + 搜索）。
+#       新增两张对照表（都放在 src/i18n.ts，查不到回落到英文原文，不显示成空白）：
+#         NODE_LABELS_ZH   20 个模块 slug → 中文卡名（后端 label 是英文，只做显示层对照）
+#         PORT_LABELS_ZH   端口名，key 用 ``*:端口key`` 表通用、``节点:端口key`` 表特例
+#       ★ 端口必须按「节点+端口」查而不是只按端口 key：同一个 ``data`` 在导出卡上
+#         是"可导出数据"、质检卡上是"数据"、审核卡上是"待审核数据"，只按 key 会串味。
+#       调色板搜索同时匹配英文原名与中文译名 —— 切到中文后输入"手套"要能找到
+#       Glove Sensor。已实测覆盖：端口 42/42、模块 20/20，无遗漏。
+#       （上一轮 1.10.2 只做了语言通道 + 调色板分组 + 工具栏。）
+# 1.10.4 工作流画布中文化收尾（第三段）。补完 1.10.2/1.10.3 漏掉的：
+#       PipelineToolbar 的 Run 与"保存中"三元、App 顶栏的 Template/Save、模板与
+#       共享对话框、AI 标注设置弹窗（API 供应商/模型/Key/标注语言 + 四处测试结果
+#       提示）、质检弹窗的参数标签（23 个）与单位（frames→帧 / s→秒 / jumps→处）、
+#       工作流抽屉、连线删除、节点悬停提示、store 里的四条 toast。
+#       store 不是 React 组件、不能调 hook —— 那里直接 translate(k, currentLang())。
+#
+#       ★ 用了两轮才补全的教训：**字符串替换会漏掉特定写法**。`>Save<` 匹配不到
+#         `{isSaving ? '...' : 'Save'}` 这种三元，也匹配不到图标后面的裸文本
+#         (`<IconifyIcon /> Template`)。第二轮专门扫了这两类才补齐。若将来还要
+#         批量改 JSX 文案，先扫这两种模式。
+#
+#       未覆盖：节点卡片描述（后端 description，仅悬停提示）；后端报告的结论文案
+#       （Finding.message）仍是英文 —— 那部分要中文得在后端加语言参数。
+# 1.10.5 首页概览（Overview）中文化。词条**早就写好在字典里**（overview_title /
+#       stat_reviewing / retry / view_all …）但 overview.html **一处 data-i18n 都没标**
+#       —— 和侧边栏同一类问题：翻译写了，标记没做。补 13 处静态标记 + 补 9 个缺的
+#       词条（stat_to_review / stat_distribution / daily_uploads / last_30_days /
+#       donut_total / stat_processing / stat_received / cleaning_passed / cleaning_failed）。
+#
+#       环形图、柱状图、状态徽标是 dashboard.js **现画**的，静态标注管不到：
+#       label/title 改成 t() 调用，并给 setLang 的重渲染列表补上 refreshDashboard
+#       —— 之前那份列表有 loadTasks/loadProjects/… 但没有它，切语言后首页图表
+#       不跟着变，要手动刷新才生效。
+# 1.10.6 用户管理页中文化。用户相关的词条此前**一个都没有**（只有 nav_users），
+#       users.html 也没有 data-i18n —— 整页 35 处文案 + users.js 里 16 处动态生成的
+#       （表格行的 Extend/Enable/Disable 按钮、角色与状态徽标、下拉选项、确认框）。
+#       新增 56 个词条。角色/状态走 key 映射查表、查不到回落原始值 —— 后端加新角色
+#       时显示原始值而不是空白。
+#
+#       ★ 两处裸文本必须包 <span> 再挂 data-i18n：``Password <span id="password-hint">``
+#         与 ``<span>Disable</span> blocks login temporarily...`` —— applyTranslations
+#         用 textContent 赋值，直接挂在父元素上会把平级的兄弟元素（提示 span）冲掉。
+#
+#       同时给 setLang 的重渲染列表补 loadUsers（与 1.10.5 的 refreshDashboard 同一
+#       类缺口：表格行是 JS 现画的，不重跑就不跟着切语言）。
+#       已核对：users.html 用到的 33 个 data-i18n 键，中英两个字典都齐。
+# 1.10.7 模板层中文化收尾：index(12) / exports(10) / tasks(2) 三页补标注，
+#       新增 23 个键。**模板层到此 9 个页面全部标注完毕**（login 按要求保持英文）。
+#       核对：各模板共引用 123 处 data-i18n 键，中英两个字典都齐。
+#
+#       ★ 顺带修掉字典里**4 个重复键**（all_status / save_changes / slice_conflict /
+#         target_episodes 在每个字典各定义了两次）。后一份静默覆盖前一份，其中
+#         slice_conflict 与 target_episodes 两份**值不同** —— 前一份是死代码。
+#         去重时我一开始保留了第一份（错的），**那会改变实际显示文案**；已改回生效值。
+#         教训：去重"保留哪一份"必须按 JS 语义（后者覆盖前者）来，不能想当然。
+#
+#       另修一处会回退的文案：SORT_MODES 的 label 存的是英文原文，而
+#       toggleSortOrder() 会把它直接写进 DOM —— 切中文后点一次排序就变回英文。
+#       改成存 i18n key、写入时翻译。
+#
+#       剩下：JS 层动态文案（player / slice-preview / annotations / tasks 等约 50 处）。
+# 1.10.8 修中英**不匹配**（不是"没翻译"，是两个方向对不上）。审计结果：
+#       ① 键集合完全对齐（各 310 个，无单边键）
+#       ② 中英**值相同**的 8 个里，4 个是真漏翻：overview_title / cameras /
+#          left_hand / right_hand（中文界面一直显示英文）。另外 4 个是品牌名
+#          processor / 死键 episodes / 术语 Port / 单位 s —— 保持英文正确。
+#       ③ **反方向**：代码里写死中文、英文界面会露出来，9 处。已抽成词条：
+#          annotations 的四个状态（切段中/VLM 分析中/写入/写入数据集）、player 的
+#          「力 mN」与力场提示、slice-preview 的候选提示、index 的 AI 模式说明。
+#          （base.html 的「中文」是语言自名，不翻是对的；index 的「只读」已有
+#          data-i18n，只是初始 HTML 写中文，会被覆盖。）
+#
+#       顺带补一个缺口：applyTranslations **只处理 data-i18n 与 data-i18n-placeholder，
+#       不处理 title** —— 带提示的按钮/图标没法靠标记翻译，只能写死。加了
+#       data-i18n-title。
+# 1.10.9 修 1.10.6 引入的显示 bug：用户表的「操作」列渲染成字面量
+#       ``+ t('users_edit') +`` 而不是按钮。
+#
+#       ★ 根因是**拼接语法用错了上下文**：那段 HTML 在**反引号模板字面量**里，
+#         而我在里面写了单引号拼接 ``title="' + t('x') + '"`` —— 在反引号里
+#         ``'`` 和 ``+`` 就是普通字符，原样显示。模板字面量里必须用 ``${t('x')}``。
+#         反过来，**单引号串**里用 ``${t('x')}`` 也会原样显示。
+#
+#       口诀：<反引号模板>用 ${t()}；<单引号拼接>用 ' + t() + '。看外层容器是哪个。
+#       自查命令（两个方向都能抓）：
+#         grep -n "' \+ t(" web/static/js/*.js        # 反引号里的误用
+#         grep -n '\${t(' web/static/js/*.js          # 逐个确认外层是反引号
+#
+#       共修 10 处（users.js 的 Extend/Enable/Disable/Edit/Delete 五个按钮的
+#       文字与 title）。已核对：反引号模板里无残留错误拼接，单引号串里的拼接合法。
+# 1.11.0 修「回收站清不掉」。
+#
+#       现象：点「清空回收站」没反应，也不报错。后端日志里是
+#       ``POST /api/v1/episodes/purge-trash → 500``。
+#
+#       根因是一个 9-08 留下的备份文件：两个 D435 项目的 ``meta/`` 里各有
+#       ``info.json.bak-20260908-144550``，而 ``verify_project_dataset`` 的 meta
+#       白名单是硬编码的 ``{info.json, stats.json, tasks.json, episodes}``，多出
+#       任何非点开头的文件都判 unexpected。而 ``delete_episode`` 是**先删文件、
+#       后跑校验**，校验失败就抛 RuntimeError；「清空」又是循环处理的，一个项目
+#       失败整轮中止 → 500。**一个备份文件让清空彻底不可用。**
+#
+#       修两处：
+#       (1) 校验放过备份/临时文件（``.bak`` / ``.bak-*`` / ``.orig`` / ``.tmp`` /
+#           ``.save`` / ``~`` / 隐藏文件）。实测四个项目现在全 passed，而
+#           ``junk.txt`` / ``real_data.csv`` 这类真杂项仍然被抓 —— 不是放水。
+#       (2) 前端 ``restoreEpisode`` / ``permanentDeleteEpisode`` / ``purgeTrash``
+#           **只有 ``if (res.ok)`` 一个分支**，非 2xx 时什么都不做 —— 这就是
+#           "点了没反应、也无从查起"的原因。补 else 分支，用新增的
+#           ``apiErrorDetail()`` 把后端 ``detail`` 显示出来（取不到就退状态码，
+#           **绝不返回空**）。
+#
+#       ⚠️ 遗留隐患（本次未改）：删除是**先删文件后校验**，校验因真实原因失败时
+#       文件已经没了、记录还在。实测 ``D435---black_glove_3d_keypoints_AI`` 的
+#       ``episode_000001`` 就是这么没的（索引本身是对的，空洞合法）。
+# 1.11.1 修「回收站删不掉」的**真正**根因 —— 项目索引缓存未失效。
+#
+#       1.11.0 修掉的那个 .bak 只是**第一个**拦路的，放行之后暴露出真问题：
+#       ``write_project_episode_index`` 是索引的唯一写入点，却没有失效
+#       ``_PROJECT_CACHE``（2026-09-11 commit 2bb9fe 引入缓存时漏的）。于是同一次
+#       调用里"写完再读"拿到的是删除前的旧行：
+#
+#         delete_project_episode:
+#           读一次(预热 60s TTL 缓存) → 删文件 → 写索引 → verify_project_dataset
+#           → 又调 project_episode_rows → **旧缓存** → 报 "missing data: ..." → 500
+#
+#       盘上的索引其实一直是对的，纯粹是缓存没跟上。delete_episode 末尾确实会
+#       invalidate_session_cache()，但那要等异常之后 —— 永远走不到。
+#       **删除功能自 9-11 起就是坏的。**
+#
+#       修在唯一的写入点，5 个调用方（delete / merge / repack ×2 / …）一并受益。
+#       实测：副本上连续删 7 个批次全部成功（5 个留行、2 个清空），校验零失败。
+#
+#       ★ 教训：加缓存时，**必须同时审所有写方**。这次是"读方加了缓存、写方忘了
+#         失效"，症状还是那个老毛病 —— 不报错、报的是**别的**错误（"文件缺失"），
+#         把人往数据损坏的方向引，而真相在缓存里。
+# 1.11.2 修回收站页的 JS 报错：``TypeError: Cannot set properties of null
+#       (setting 'textContent') at trash:248:55``。
+#
+#       trash.html 的内联脚本在设 ``nav-review`` / ``nav-trash`` 的 textContent，
+#       但 base.html 里**从来没有这两个 id**（侧边栏用的是
+#       ``<span data-i18n="nav_review">``，由 i18n.js 的 applyTranslations 处理）。
+#       getElementById 返回 null → 每次 DOMContentLoaded 必抛。``git log -S`` 查过：
+#       该 id 从未存在过，所以是**一直就坏**，不是本轮引入。
+#       （app.js / i18n.js 里同样的取值都写了 ``if (x)`` 保护，只有 trash.html 没有。）
+#
+#       处理：删掉那段多余的导航文案逻辑，本页只保留页面标题；标题在
+#       DOMContentLoaded 与 egodata:lang 事件上各更新一次。
+# 1.11.3 修双目自动配对把动态端口画重复的 bug（前端为主）。
+#
+#       现象：Stereo RGB-D Camera 的 3 个输出，在 Data Cleaning 上画出【4 个输入口】，
+#       其中 "Left RGB Video" 重复。用户实测截图发现。
+#
+#       根因在 onConnect 的双目配对：``siblingConn = {...next, sourceHandle: 副目}``
+#       —— 只换了源端口，**targetHandle 沿用了主端口的动态 key**。而 isDup() 恰好
+#       按 targetHandle 判重，于是用户再手动连"另一目"时判成"没连过"，又加一条。
+#       端口 key 只由「源节点+源端口」算出，两条同源端口的边 → 同一个 key → 两个同名口。
+#
+#       普通节点（targetHandle 恒为 "video"）主副相同，所以这个 bug 一直没暴露 ——
+#       是 1.9.8 的动态端口把它揭出来的。
+#
+#       对照实验（真实 store 驱动，非静态检查）：
+#         with bug : 连左目→右目 → 4 条边 / 2 个 key；再连深度 → 6 条边 / 3 个 key
+#                    （配对边甚至把 depth 的目标口也抄走了）
+#         fixed    : 2 → 2 → 3 条边，key 数恒等于边数
+#       同时给 useDynamicInputs 加了按 key 去重 —— 一个 key 只能有一个口，
+#       渲染层兜底，防止历史遗留的重复边再画出重复端口。
+# 1.11.4 上传后的存储索引改为**沿用名字里的编号**。
+#
+#       此前 append_project_episode 一律用 max(现有)+1，而公开 ID（批次名）是
+#       沿用上传包的 —— 两套编号各走各的，于是"名字 Test94_000005 / 索引 3"
+#       这种对不上的情况出现。**实测 119 个带编号批次里 21 个中招**（18%）。
+#
+#       危害在 _match_episode_row 的名字回退：按 id 匹配不到时会用
+#       episode_index_from_name() 反推索引，从而撞上别的批次。模拟确认：
+#       删「..._000002」时若它自己的行已缺失，会去删 index=2 那个**别的批次**
+#       的数据和视频。
+#
+#       现在优先采用名字里的编号（编号允许空洞，模块里已写明 gaps are valid）；
+#       仅两种情况回落 max+1：名字里没有编号，或该编号已被别的批次占用。
+#       副本实测：传 Anything_000005 → 索引 5；传 Anything_000002（撞号）→ 6；
+#       传 NoNumberHere → 7。
+#
+#       顺带修同一处的缓存缺口：append 是在 temp_root 上写完再 rename 换入的，
+#       而 write_project_episode_index 失效的是 **temp_root** 的 key —— 换入后
+#       project_root 的缓存仍是旧行。后果两条：(1) 紧跟的
+#       verify_project_dataset(project_root) 读旧行，**校验在验旧树**（三次
+#       append 全部"通过"而盘上早已是 [0,1,2,5,6,7]）；(2) 缓存有 60 秒盲目
+#       TTL，上传后前端最长 60 秒看不到新批次。换入后显式失效。
+# 1.12.0 新增「模型训练」页 —— 只读展示训练产物;新页面前端改用真 ES module。
+#
+#       背景:模型由官方 lerobot-train 在本平台**之外**训练(conda 环境
+#       lerobot052_base_piper),产物落在 文件测试/umi_act_model/checkpoints/。
+#       此前要了解训练结果只能自己去翻文件系统。
+#
+#       本期**只做界面,不执行训练**:
+#         • 后端 app/routes/training.py —— 唯一端点 GET /api/v1/training/runs,
+#           只读扫描 checkpoints/ 并读 train_config.json。目录不存在返回
+#           runs:[](新机器从没训过是正常情况,不是错误)。
+#           两种层级都支持:root 本身是 run,或 root 是装多个 run 的父目录。
+#         • 前端 web/static/js/train/ —— 真 ES module(import/export),不再往
+#           app.js 里堆。六个文件:api / dom / format / params / checkpoints /
+#           main,main.js 是唯一入口,其余是它 import 的模块。
+#         • 「训练指标」「实时日志」两个页签**故意不做** —— 训练在平台外执行,
+#           没有 loss/lr/grad_norm 落盘,也没留日志。没有数据就不显示:摆一个
+#           空页签比不摆更让人以为功能坏了。将来接了训练执行再加回 TABS 数组。
+#
+#       ★ 顺带堵一个缓存陷阱:static_cache_headers 现在对 /static/js/ 下**无查询
+#         串**的 JS 发 no-cache。原因:ES module 的相对 import 解析出的 URL 不带
+#         查询串 —— 入口 script 写了 ?v=,`import './api.js'` 也永远是同一个地址,
+#         给它任何正数 max-age,升级后都会出现「新 main.js + 旧 api.js」混用,
+#         直接抛 TypeError。范围刻意收窄:带 ?v= 的老脚本仍走 86400 那支,
+#         /static/ 顶层的第三方库(plyr.js、iconify-*)也不在范围内。
+# 1.12.1 侧边栏「模型」改成一级项(与 Video Review 同级同款),不是灰色分组标签。
+#
+#       位置对了但层级不对:原来是「不可点击的小字标题 + 一个 sidebar-link」,
+#       视觉上像个分组标签。改成 **一级项(robot 图标 + 可点击 + 选中蓝底)+
+#       二级短名项(训练)**,与 Video Review 的结构一致。
+#
+#       ★ 顺带修高亮脚本:它原来只遍历 .sidebar-link,而二级项挂的是
+#         sidebar-sub —— 不一起遍历的话「训练」永远不会亮。选择器加
+#         [data-page] 限定,避开另一段脚本管的 review 状态快捷项。
+#       ★ i18n key 改名 nav_group_model → nav_model(它不再是"分组标题")。
+#
+#       一并 bump 版本号:浏览器已按 ?v=1.12.0 缓存了 i18n.js 24 小时,
+#       不换 URL 的话上面这些文案改动根本到不了前端。
+# 1.12.2 训练页去掉硬编码中文 —— 英文模式下会露出"模型: act""[下载][删除]"。
+#
+#       页面标题/页签走了 t(),但 run 头部的「模型/位置」、checkpoint 的
+#       「步骤/文件明细/下载/删除/推理/离线部署」、文件表的三个表头、参数页的分组
+#       标题与「来源:」全都写死成中文 —— 中文模式看不出来,切英文就半中半英。
+#
+#       一并两处结构性的:
+#         • 新增 static/js/train/text.js:i18n 桥接。应用的词典是**经典脚本**
+#           (只有全局 t(),没有 export),ES module import 不到,三个视图各自去
+#           摸 window.t 不如集中一处 + 防御性回退(取不到就显示英文,不白屏)。
+#         • 参数页的分组标题存 **i18n key** 而非翻好的文字:它原来在模块加载那
+#           一刻就定死了,用户之后再切语言不会跟着变。改为渲染时取值。
+#         • main.js 接 egodata:lang 重画 —— 本页内容全是 JS 现画的,setLang()
+#           只翻 DOM 上的 data-i18n 属性,翻不到动态节点,不重跑就还是旧语言。
+# 1.13.0 训练页加顶部一级页签:「模型训练」+「新建训练」。
+#
+#       右侧内容区顶部两个页签(对齐参考实现):模型训练 = 已有产物清单,
+#       新建训练 = 五段式向导(选模型 / 选数据 / 导出设置 / 训练参数 / 生成命令)。
+#
+#       两个页签都是**真内容**,没有占位:
+#         • 模型训练 —— 上一版做的就是它,原样搬进来。
+#         • 新建训练 —— 新增 static/js/train/newrun.js。选数据那一段走既有的
+#           GET /api/v1/ingestion/episodes(训练数据就是采集来的 episode,没
+#           必要另开一套列表)。
+#         • 默认超参全部取自**实测那一次**的真实 train_config.json,不是拍的。
+#         • **仍然不接后端执行** —— 这一页的产出是一条完整的 lerobot-train
+#           命令行(复制 / 下载 .sh)。比放一个点了没反应的"开始训练"有用,而且
+#           表单每个字段就是一个 --key=value,天然定义了将来后端的接口契约。
+#
+#       ★ 留出集防线:UMIGripper_Action_AI 的 52–73 集模型没见过,重训混进去会
+#         让泛化评估失效 —— 而代码里**没有任何硬编码排除**。UI 上做成可改的区间
+#         输入框(不是写死常数,换数据集时区间就变了):命中行标红 HOLDOUT、默认
+#         不勾、「全选」自动跳过、单独勾选要二次确认。
+#
+#       ★ 懒渲染:面板第一次显示时才拉数据。否则一进页面就同时请求训练产物和
+#         几百条 episode 列表,而后者多半没人点。
+#       ★ dom.js 的 el() 增加 SET_ATTR:<iconify-icon> 是自定义元素,只监听
+#         attribute。`node.icon = x` 不给它挂 attribute,图标画不出来且不报错。
+# 1.14.0 「新建训练」按参考实现重排成六段:位置 / 模型 / 参数 / 数据集 / 续训 / 归属。
+#
+#       • ① 训练位置 —— 只做本机。勾选参与训练的 GPU,命令里落成
+#         CUDA_VISIBLE_DEVICES。云端算力(RunPod/AWS/腾讯/阿里)不摆点不动的卡片。
+#       • ② 模型 —— 只 ACT 一张;训练框架 LeRobot 做成**只读文本**而不是下拉框
+#         (ACT 只有一种实现,给个下拉框是假的)。
+#       • ③ 参数 —— 8 项各带一句说明;默认值仍是**实测那一次**的值
+#         (batch_size=16 / steps=20000),不是参考实现的示例值(那个 2/10000
+#         是给它 8GB 的 pi0 用的)。
+#       • ④ 数据集 —— **改成按「项目」选(多集)**。原来按 episode 逐个勾:
+#         实测 state/exports 下 168 条记录**每条 total_episodes 都是 1**(单集
+#         导出),凑不成训练集;项目树本来就是多集的(UMIGripper_Action_AI 81 集),
+#         且被官方加载器验证过。
+#       • ⑤ 续训 / ⑥ 项目归属 —— 前者用已有 checkpoint,后者用 /api/v1/projects。
+#       • 「创建训练任务」**存在但禁用**,旁边给出真正的产出:完整 lerobot-train
+#         命令行(复制 / 下载 .sh)。后端执行以后接,接口契约就是这些 --key=value。
+#
+#       ★ 留出集防线换了形态。上一版按 episode 勾选,可以"默认不勾 + 全选跳过";
+#         现在选的是整个项目,而留出集就在项目内部(UMIGripper_Action_AI 81 集,
+#         留出集是其中第 52–73 集)—— 没法"默认不勾",只能选中会覆盖到留出集的
+#         项目时**明确报警**。区间仍是可改的输入框,不是写死常数。
+#
+#       新增两个只读端点:
+#         GET /api/v1/training/gpus     —— 读 nvidia-smi。**驱动没起来时如实报错**,
+#           不返回一排 0:0% 利用率看起来像"显卡闲着",而真相是"问不到"。
+#         GET /api/v1/training/datasets —— 扫 sessions/<项目>,只列 total_episodes>0 的。
+# 1.14.1 新建训练页两处文案调整。
+#
+#       ① 训练位置那张卡片改名:「本机 GPU 服务器」→「私有算力」。
+#          原来那个名字只说了"在哪台机器",没说"这是什么性质的算力"。参考实现
+#          那条叫「私有云算力」—— 与自家机器相对的是**租来的云算力**,「私有
+#          算力」才把这条线划清楚。
+#
+#       ② 删掉两段说明文字:
+#          • 「目前只做 ACT。其它 LeRobot 内置策略同样可跑,但本平台没实测过。」
+#          • 「云端算力(RunPod / AWS / 腾讯 / 阿里)本期不做 —— 不摆点不动的卡片。」
+#          摆一张卡片只在旁边写一句"别的不做"是噪音;真要扩展时直接加卡片即可。
+#
+#       ③ 段落顺序改成:数据集 → 模型 → 算力(训练位置)→ 参数 → 续训 → 归属。
+#          原来是 位置 → 模型 → 参数 → 数据集。新顺序按**决策依赖**排:先用什么
+#          数据、再训什么模型、再在哪训、最后怎么训 —— 数据集本身就决定命令里的
+#          --dataset.root,放最后意味着要先看后面的表单才知道上面该填什么。
+#          注意 newrun.js 里**构造顺序 ≠ 展示顺序**:各段必须先构造好(GPU 面板、
+#          留出集警告、命令生成互有依赖),最后由一个 append 数组决定谁在上面。
+#
+#       一并清掉一个死 key(train_files_empty),它定义了但没有引用点。
+# 1.15.0 训练数据集改为「审核页导出后的成品」;导出不再把数据集删掉。
+#
+#       原来的链路是断的:审核页导出 → 构建 LeRobot 数据集 → 打包 zip →
+#       **rmtree 删掉数据集目录**。用户拿到的只有一个 zip,磁盘上什么都不剩,
+#       训练页自然无从列起 —— 只能退而列 sessions/<项目> 原始项目。
+#
+#       改法(两处,都很小):
+#         • export.py 打包后调用 _persist_trainable_dataset(),把数据集落到
+#           state/datasets/<数据集名>/,而不是删。**交换式替换**:新的先搬进
+#           .staging,旧的挪到 .old,再 rename 上位,最后删 .old —— 中途失败
+#           不会让目标位置停在"半个数据集"上(直接 rmtree + move 就会)。
+#         • training.py 的 /datasets 改扫 state/datasets/,不再扫 sessions/。
+#
+#       ★ 为什么这个改法更好:原始项目里混着**未审核**的集,而且**留出集**
+#         (UMIGripper_Action_AI 的 52–73)就在里面 —— 按项目选等于同时踩两个
+#         坑,UI 上只能报警、拦不住。以导出产物为准之后,两个坑都在导出那一步
+#         被排掉:导出本来就校验 status ∈ {reviewed, approved}。
+#
+#       ★ 留出集防线**从训练页移走**了。导出后的数据集集号会被重排成 0..N-1,
+#         训练页已经认不出哪一集原本是 52–73。控制点转到导出那一步 —— 导出时
+#         别把留出集勾进去。要加硬校验的话,位置在审核/导出页。相关 UI(区间
+#         输入框 + 红色报警)与 parseRanges 一并删除,不留死代码。
+#
+#       数据集为空时训练页给的是**可点的引导**(跳 /review?status=approved),
+#       而不是一句"没有数据" —— 首次使用时这个列表必然是空的。
+# 1.15.1 「项目归属」改成名副其实的归档标签 —— 之前承诺了做不到的事。
+#
+#       那一栏原来写「不选项目时,这次训练是私密的,只有创建者能看到」,是照搬
+#       参考实现的说法。**但本系统的项目根本没有属主**:list_projects() 返回的
+#       字段只有 id/name/description/status/workflow_id/observed_inputs/
+#       uploaded_total/params/name_aliases —— 没有 owner、没有 created_by。权限
+#       也是全局角色制(require_roles),不是按项目授权。
+#
+#       也就是说"私密任务"这句是**空头支票**:选与不选,能看到的人完全一样。
+#
+#       改成写实的说法:它只是个归档标签,便于日后按项目查找这次训练,并**显式
+#       说明没有可见性控制**。将来真要做按项目授权,得先给项目加属主、给训练
+#       任务加属主、再改中间件 —— 那是另一个量级的改动。
+# 1.16.0 新建训练去掉「⑥ 项目归属」;job_name / output_dir 改成真正的参数。
+#
+#       ① 删掉项目归属那一栏。上一版已经把它的说明改成写实(只是归档标签、不含
+#          可见性控制),但一个**不产生任何行为差异**的下拉框留着就是噪音 ——
+#          本系统的项目没有属主字段,选与不选对数据的去向、谁能看到,全都没有
+#          影响。真要按项目授权,得先给项目加属主再谈 UI。
+#          一并删掉 train_sec_project / train_project_* 四个 key,不留死词条。
+#
+#       ② output_dir 与 job_name 原来是**从项目名推出来的**
+#          (`文件测试/${项目名}` / `${项目名}`)。项目没了就没有来源,而这两项
+#          本来就是 lerobot-train 的顶层参数,放进「③ 训练参数」更名副其实:
+#            output_dir  默认 文件测试/umi_act_model(实测那次的值)
+#            job_name    默认 act
+#          output_dir 是路径,给的是宽输入框(窄列里看不全)。
+# 1.16.1 前端三处修复 —— Tailwind 类静默失效 / 图标离线化 / 前端版本号。
+#
+#       ① **训练页一半的 Tailwind 类根本没生效**。tailwind-generated.css 是
+#          构建产物,而全仓**没有任何记录说明它怎么生成** —— 唯一的配置文件是
+#          workflow-studio 的,content 范围只有 ./src/**,不含 Jinja 模板和
+#          static/js。那份 CSS 停在 8/19,没人能复现。后果是 w-28 /
+#          text-[10px] / accent-blue-500 / divide-y / break-all 等类全部静默
+#          失效(页面能显示,只是样式没上)。
+#          修法:用覆盖全部前端的 glob **先生成到临时文件**,逐个核对会被删掉
+#          的类(8 个,全部验证为死类 —— 注意别用 grep 直接搜类名,select-all
+#          会误命中 id="select-all-bar"),确认是超集后才替换现场。
+#          一并修掉 app/version.py 与两个 README 里「前端版本见
+#          workflow-studio/package.json」这个错误说法 —— 那只代表 SPA 自己。
+#          新增 **web/VERSION**(当前 1.9.x)覆盖整个 processor/web/。
+#
+#       ② 图标收尾。训练页用了 emoji(📁)与字符(⊙),与全站的 iconify 图标
+#          不一致,换成 ant-design:folder-outlined 与 info-circle-outlined。
+#          后者白名单里没有 —— 从 iconify **构建期**拉下来内联进
+#          iconify-preload.js(59 → 60 个),运行时仍然不联网。
+#
+#       ③ web/VERSION 与 README/version.py 的版本号对齐(原来 README 写的是
+#          后端 1.6.8 / 前端 1.5.6,差了十几个版本)。
+#
+# 1.16.2 「新建训练」删掉整段「创建训练任务」,checkpoint 改为默认折叠。
+#
+#       ① 删掉禁用的按钮 + 「后端执行还没接」那句 + 生成的 lerobot-train 命令
+#          行 + 复制/下载。后端接上之前,那两样要么是假按钮、要么是绕路把命令
+#          当交付物。**这一页因此变成纯表单** —— 数据集/GPU/参数/续训都不再
+#          驱动任何输出,它们是为将来后端准备的状态。文件头注释写明了这点,
+#          免得下一个人以为坏了。
+#          一并清掉 renderCommand / commandBox / LEROBOT_TRAIN / COPYABLE
+#          (43 行)、10 个 i18n key(中英双份 20 行)、3 处还写着「六段」
+#          「归属」「下面生成的命令」的过期文案。newrun.js 485 → 379 行。
+#
+#       ② checkpoint 全部默认折叠。原来让最新的那个展开,结果一进页面就被
+#          11 个文件名顶下去,反而看不到下面还有几个 checkpoint。
+#
+# 1.16.3 后端新增 app/training/ 包 —— 训练域从路由层抽出来。
+#
+#       与前端 static/js/train/ 对称:routes/training.py 退回成薄薄一层路由,
+#       域逻辑进包:
+#           app/training/gpus.py        nvidia-smi 读取
+#           app/training/datasets.py    state/datasets/ 扫描
+#           app/training/runs.py        训练产物(checkpoints)扫描
+#       三个模块都**不认识 HTTP**,返回普通 dict,所以将来 runner 起子进程前
+#       要确认显卡时可以直接复用,不必绕道走一遍路由。
+#
+#       **这是"新功能先模块化"的第一次实践** —— 域包里的东西没有任何存量引用,
+#       抽出来零风险。反例就在旁边:app/ai_annotation.py 长到 180KB 才想起来
+#       该拆,而那时候拆要动 64+ 个 import 点。
+#
+#       注:老的 37 个顶层 .py 按域归位是**另一件事**、风险中高(90+ 个 import
+#       点跨 worker/scripts/tests/model_eval 五个地方),不在本次范围内。
+# 1.16.4 修训练页半英半中:ES module 在 DOMContentLoaded 之前就渲染了。
+#
+#       现象:中文模式下,顶部两个页签是英文(Model Training / New Training),
+#       而它下面的子页签(模型输出 / 训练参数)是中文 —— 同一页两种语言。
+#
+#       根因是**渲染时机**。i18n.js 的 currentLang 默认写死 'en',要到它自己的
+#       DOMContentLoaded 回调里才从 localStorage 读出 'zh'。而 main.js 原来是:
+#
+#           if (document.readyState === 'loading') addEventListener(DOMContentLoaded, boot)
+#           else boot()
+#
+#       ES module 是 **deferred** 的 —— 它在"文档解析完、DOMContentLoaded 还没
+#       触发"这个中间态执行,那一刻 readyState === 'interactive',所以
+#       `=== 'loading'` 为假,直接走 else **当场渲染**。于是:
+#         顶部页签(boot 里同步建)→ currentLang 还是 'en' → 英文
+#         子页签(await listRuns 之后才建)→ 已经是 'zh' → 中文
+#       切换语言后能正常,是因为 setLang() 会派发 egodata:lang,而 main.js
+#       接了这个事件重跑 boot —— **只有首次加载是坏的**。
+#
+#       修法:判据改成 `readyState !== 'complete'`(interactive 也算"还没 fire",
+#       这时挂监听一定会被调到)。
+#
+#       ★ **这是 ES module 独有的坑,老页面不受影响** —— 那 13 个经典脚本都在
+#         解析期执行、老老实实挂 DOMContentLoaded。以后往 static/js/ 下加
+#         module 时都得留意这个中间态。
+#
+#       一并删掉 train.html 顶部的页面大标题「模型训练」(四个字)+ 它的 i18n
+#       key。下面的两个页签已经说明"你在哪一页",侧边栏也重复说了同一件事。
+#       那一行改成 justify-end —— 只剩刷新按钮一个子元素时,space-between 会
+#       把它推到左边去。
+# 1.16.5 修训练页内容贴左边 —— 又是 Tailwind 构建产物没跟上。
+#
+#       现象:把 train.html 的 `p-6` 拆成 `px-6 pt-3 pb-6` 想让页签上提,结果
+#       **左右内边距直接归零**,内容贴到侧边栏上。原因不是 CSS 写错 —— 是
+#       px-6 / pb-6 当时**没人用过**,tailwind-generated.css 里根本没有这两条
+#       规则,写了等于没写。而那次改动发生在**上一次重新生成 CSS 之后**。
+#
+#       ★ 这是同一个坑第二次踩:
+#         第一次 → 训练页一半的类(w-28 / text-[10px] / accent-500 / divide-y)
+#                   因为 CSS 停在几周前而全部静默失效(1.16.1)
+#         第二次 → 本次,padding 归零
+#       共同点:**加/改 Tailwind 类之后忘记重新生成,而且全程不报错**。
+#
+#       所以这次加了防呆脚本 scripts/check_tailwind_build.sh:
+#         用同样的 content 范围重新生成到临时文件,和现场那份 cmp 比对;
+#         不一致就报错,`--fix` 则就地重新生成。
+#       跑法:bash scripts/check_tailwind_build.sh [--fix]
+#
+#       ★ 改完 CSS 记得 bump 缓存键。**这条在 1.19.4 之后指的已经不是本文件了**
+#         —— 缓存键改用 web/VERSION(前端号),见那一条。此处保留原文不改,
+#         因为它是当时的事实记录。
+# 1.17.0 训练页加「到点提醒」—— 项目已通过集数达到采集上限时提示可以导出。
+#
+#       判据由用户定:**已通过集数 >= 项目设置的采集上限**(params.target_episodes)。
+#       到点只**提醒**,不自动导出 —— 页面上一块绿色提示 + 「去导出」链接。
+#
+#       ★ 为什么不做全自动(讨论过,用户选了提醒):
+#         • 导出一次约 **30 秒/集**(UI 自己的 batch_export_hint 文案),1000 集要
+#           跑 8 小时以上;深夜跑、NAS 中途断了没人知道,而现在的导出是全成或全败。
+#         • 构建好的数据集会被**固定**下来 —— 已经拿去训练的那份不能悄悄变。
+#           同一个路径指向不同内容,训练就没法复现了(这也是自动导出必须先解决
+#           版本命名的原因)。
+#         • 让人点一下,换到的是"我知道现在在导什么、用哪份数据"。
+#
+#       实现:
+#         app/training/projects.py   list_projects_progress()
+#         GET /api/v1/training/ready  {projects:[{name,target,uploaded,approved,ready}], ready_count}
+#         前端 newrun.js 的 ① 训练数据集里,到点则绿框列出,没到点则给一行「最接近的」
+#         (否则那块永远是空的,看不出进展)。
+#
+#       ★ 两个刻意的取舍:
+#         (1) **target 为 0 的项目永不 ready** —— 没配上限就没有"到点"这回事,
+#             不能把"没配"当成"已达"。
+#         (2) **只扫一次 scan_sessions()**。它是全量遍历,数据在 NAS/sshfs 上时
+#             很贵(见 README 的"打开 episode 慢");按项目各扫一遍就是 O(项目数)
+#             次全量。上传数与通过数在同一次遍历里一起数出来。
+#
+#       ⚠ 实测现状:没有一个项目接近上限(52/10000、4/200、3/1000…),所以
+#         ready_count 现在恒为 0,页面只会显示「离采集上限最近的」那一行。
+#         这不是 bug —— 现有 target_episodes 是**采集计划量**,而实际工作流里
+#         远没到那个量就会先导出。要不要把上限调成"导出阈值"由用户决定。
+#
+#       顺带:新增 scripts/check_tailwind_build.sh,并且**当场抓到了我自己这次
+#       忘了重新生成 CSS**(加了 bg-green-950/40 等新类)。
+# 1.17.1 训练页:删掉 output_dir 表单字段;checkpoint 文件支持下载。
+#
+#       ① 删 `output_dir`。它本来就不该是前端的字段 —— 输出去哪是**服务端配置**
+#          (settings.TRAIN_OUTPUT_ROOT,默认 文件测试/umi_act_model,可用环境变量
+#          覆盖),而且训练页正是读它来列 checkpoint 的。让前端再选一次,等于
+#          让用户有机会选到一个页面上根本列不出来的目录。
+#          顺带删掉 WIDE_FIELDS(它只服务这个字段)和相应的宽输入框分支。
+#
+#       ② checkpoint 文件下载上线(原来按钮是禁用的):
+#            GET /api/v1/training/runs/{run}/checkpoints/{step}/files/{name:path}
+#          逐文件而不是整包:一个 checkpoint 约 600MB,其中 training_state/
+#          (优化器状态,约 400MB)**只在续训时有用**;拿去推理/部署只要
+#          pretrained_model/(约 200MB)。按需下载比强制拉一个 600MB 的包合理,
+#          所以整包下载那个按钮直接去掉了。
+#
+#       ★ 安全:路径**不做拼接**。直觉写法 `checkpoint_dir / relative_name` 会让
+#         `../../../../etc/passwd` 读到任意文件 —— 这个端点是对外开下载的。
+#         改成:先扫一遍拿到磁盘上的真实文件清单,再按名字**精确匹配**。返回的
+#         路径必然来自真实条目,构造不出清单外的。实测四种穿越写法(相对、
+#         带前缀的相对、绝对路径)全部返回 None。
+#         (刻意**不用** resolve()+is_relative_to 那种"先拼出来再检查"的写法 ——
+#          清单匹配是从源头上就没有越界的可能。)
+#
+#       `{name:path}` 而不是 `{name}`:要下的文件在子目录里
+#       (pretrained_model/model.safetensors),默认的路径参数不匹配斜杠。前端拼
+#       URL 时也要**逐段编码、保留斜杠** —— 整串 encodeURIComponent 会把斜杠也
+#       编掉,后端就找不到文件。
+# 1.18.0 服务端 i18n —— 修「每次翻页先闪一下英文」。
+#
+#       现象:中文用户点任何一个导航,新页面先渲染成英文,再由 JS 纠正成中文。
+#       每次整页导航都闪一下。
+#
+#       根因:语言只存在浏览器的 **localStorage** 里 —— 服务端看不到,所以渲染
+#       ``data-i18n`` 元素时只能填**默认语言(英文)**,再由 DOMContentLoaded
+#       里的 applyTranslations() 改。改的时机在首屏之后,必然闪。
+#
+#       改法(用户选的「A 方案」):语言同时写 **cookie**,服务端渲染时就用它取词。
+#
+#         web/static/js/i18n-data.js   ← 词典的**唯一真源**(合法 JSON + 一行赋值)
+#         app/i18n.py                  ← 读它 + t(key) + ContextVar + 中间件
+#         app/routes/pages.py          ← 注册 Jinja 全局 t / current_lang
+#         base.html / login.html       ← <html lang="{{ current_lang() }}">
+#         8 个模板 132 处              ← 硬编码文案 → {{ t('key') }}
+#         i18n.js 921 → 130 行         ← 只剩逻辑,词典搬走
+#
+#       ★ 词典为什么单独一个文件:i18n.js 是 JS,而服务端是 Python。写在里面的话
+#         Python 要么重复维护一份、要么去解析 JS 源码。现在两边读**同一份**文件,
+#         不会分叉。浏览器当普通脚本同步加载(带 ?v= 缓存)。
+#
+#       ★ 客户端的 currentLang **以 <html lang> 为准**,不再只读 localStorage。
+#         服务端是从 cookie 读的,两者可能不一致(清了 localStorage 但 cookie
+#         还在);一旦不一致,applyTranslations() 会把服务端刚渲染好的中文**又翻
+#         回英文** —— 页面反而变成"先中文后英文",比原来更难看。
+#         以 <html lang> 为准还有个好处:它和 DOM 里的文案**必然一致**(服务端就
+#         是按它渲染的),所以首次 applyTranslations() 是个空操作。
+#
+#       ★ Jinja 全局 current_lang 注册的是**函数**,模板里必须写
+#         ``{{ current_lang() }}`` 带括号 —— 语言是每请求才定的(ContextVar),
+#         全局对象本身是固定的。少写括号不报错,只会把函数 repr 渲进 HTML:
+#             <html lang="&lt;function get_current_lang at 0x7f…&gt;">
+#
+#       ⚠ 改这轮的教训:批量正则改模板**连错两次** ——
+#         第一次丢掉了 129 处 `</`(分组用错),第二次又没删掉旧文案(替换函数
+#         把原文案原样返回)。两处都是靠"改完做结构校验"发现的,不是靠看:
+#           · 每个 data-i18n 元素的 t(key) 是否与 key 一致 → 0 处不符
+#           · 标签开闭是否配平(排除 input/img 等空元素)→ 全平
+#           · <script> 块里有没有被误伤的 {{ t() }} → 0 处
+#           · Jinja 能否解析全部 10 个模板 → 全通过
+#         其中 trash.html 是被"漏掉"的那一个:它的 JS 注释里有一个**示例标签**
+#         <span data-i18n="nav_review">,被当成真标签处理;而它同时吞掉了
+#         </script> 的 `</`,导致扫描脚本没能识别出那个脚本块。
+# 1.19.0 新增「推理」模块(模型 → 推理);前端抽出 shared/ 共用工具。
+#
+#       侧边栏「模型」下现在两项:训练 / 推理,与参考实现一致。
+#
+#       推理页做什么(本期**只做选型与查看,不执行**):
+#         ① 选择模型 + 检查点   → 真实数据(GET /api/v1/training/runs)
+#         ② 该检查点的训练参数  → 真实数据(checkpoint 里的 train_config.json)
+#                                 只挑 policy.* 那几个关键项 —— chunk_size /
+#                                 n_action_steps 这类直接决定推理输出,推理前最该确认
+#         ③ 测试集             → 真实数据(GET /api/v1/training/datasets)
+#         ④ 运行推理 + 结果     → **故意禁用**,旁边写明原因;结果区是空态
+#
+#       ★ 不摆空页签:参考图里还有「训练指标」「实时日志」,我们没加 —— 没有数据
+#         的页签比不摆更让人以为功能坏了(同训练页的理由)。这两个要等**训练执行
+#         后端**,那时候 loss/lr/grad_norm 才有地方来。
+#
+#       ★ 「离线部署」也没做 —— 参考图里它是 checkpoint 上的另一个按钮,和「推理」
+#         不是一回事(推理是跑起来看指标,部署是打包成交给机器人的交付物)。
+#         checkpoint 上那个「离线部署」按钮仍是禁用的。
+#
+#       前端结构:新增 static/js/shared/,把 dom.js / format.js / text.js 从
+#       train/ 挪出来 —— 它们是**纯工具、没有领域概念**,两个页面都要用。不这么
+#       做的话推理页得写 `import ... from '../train/dom.js'` —— 推理引训练的工具
+#       是没道理的依赖方向。
+#       推理页的数据源(runs / datasets)仍**直接引 ../train/api.js**:那两个端点
+#       属于训练域(推理消费的是训练产物),这个依赖方向是对的。等有第三个页面也
+#       用到它们,再抽到 shared/。
+#
+#       ★ 页面入口的 boot 时机照抄训练页:ES module 在"文档解析完、DOMContentLoaded
+#         未触发"的中间态执行,那时 i18n.js 还没定好语言 —— 必须等 DOMContentLoaded。
+#         训练页为此踩过一次(顶部页签显示英文而子页签中文),不再踩第二次。
+#
+#       顺带:tailwind 防呆脚本这次又抓到一次(推理页引入了新类),已 --fix。
+#       这是它上线后第二次立功 —— 加/改 Tailwind 类之后忘记重新生成,失败是
+#       静默的,没有脚本就只能靠肉眼在页面上发现"这个间距怎么不对"。
+# 1.19.1 「推理」并进「模型」页 —— 侧边栏去掉二级项,页内三个页签。
+#
+#       侧边栏原来是这样,两个二级项指向**两个页面**:
+#
+#           模型
+#             ⚡ 训练    → /train
+#             ▶ 推理    → /inference
+#
+#       改成:
+#
+#           模型        → /train,页内三个页签:模型训练 / 新建训练 / 模型推理
+#
+#       理由:训练和推理本来是**同一批产物的上下游**(训练产出 checkpoint,推理
+#       消费它),拆成两个导航项反而要来回跳。
+#
+#       顺带两处:
+#         • 删掉训练页右上角的**刷新按钮**。浏览器自带 F5/Ctrl+R,自己做一个是
+#           多余的;它一走,顶部那行也就没必要留着,内容直接从顶部开始。
+#         • `/inference` 路由与 `templates/inference.html` 一并删除。
+#           static/js/inference/main.js → **view.js**,不再是页面入口,而是被
+#           train/main.js 当第三个页签 import(`render: renderInference`)——
+#           名字跟着职责改,免得下一个看的人以为它还会自己启动。
+#
+#       配色/结构不变,只是搬家:inference/view.js 的内容一字未改。
+#
+#       ⚠ `/inference` 这个地址现在 404。它只存在了一小会儿,没有外部引用;
+#         要是有人收藏了,重新点侧边栏「模型」即可。
+# 1.19.2 模型页三个页签重排:新建训练 → 模型训练 → 模型推理。
+#
+#       原来是 模型训练 → 新建训练 → 模型推理。**数组顺序同时决定展示顺序和默认
+#       打开哪个**(boot() 里把第 0 个设为激活),所以这一改,进页面直接落在
+#       「新建训练」上 —— 这是用户要的。
+# 1.19.3 「新建训练」删掉三段说明文字;顺带修一处过期兜底。
+#
+#       ① 「离采集上限最近的 X: n/N」整段删掉(连同它的两个 i18n key)。
+#          那行**每次都在**,而绝大多数时候又离得很远(实测 3/100、52/10000),
+#          读起来就是一句永远不变的噪音。到点了自然会冒出来,没到点就安静待着。
+#
+#       ② 「这里列的是从审核页导出的数据集…先选一个,或者先去导出一份」删掉。
+#
+#       ③ 「续训需要 --policy.path=…;命令里会带上,但本页不会真的启动训练」删掉。
+#          ★ 这条其实**早就过期了** —— 生成命令那一整段在 1.16.2 就删了,
+#          "命令里会带上"已经无从谈起,当时漏改了这句。
+#
+#       ④ 顺带修一处同类的过期:GPU 不可用那条提示的**英文兜底**还写着
+#          "the command below will fail without it"。字典里的中文值当时改对了,
+#          但兜底字符串没跟着改 —— 只有字典缺 key 时才会显出来,平时看不见。
+#
+#       一并清掉 4 个变成孤儿的 key(train_ready_nearest / train_ready_approved /
+#       train_dataset_hint / train_resume_hint),词条 417 → 413。
+# 1.19.4 静态资源缓存键改用**前端号**(web/VERSION),不再用后端号。
+#
+#       起因:用户看到 web/VERSION 没跟后端号一起变,问"这个文件要删吗"。
+#       查下来文件是好的(1.12.2→1.12.3 确实涨了),但暴露出一个真问题 ——
+#       **改一次前端要 bump 两个号**:后端号给 ?v= 用、前端号给提交信息用。
+#       而且两个数一旦对不上(提交信息写 1.12.3、浏览器拿的却是后端号那版),
+#       看提交记录的人没法判断线上到底是哪一版。
+#
+#       改法:`app/routes/pages.py` 的 asset_version 从 `app.version.__version__`
+#       换成新模块 `app/web_version.py` 的 `frontend_version()`。
+#       于是一个号管两件事 —— 缓存键和提交信息里的「前端 X」是同一个数。
+#
+#       顺带把散在三处的旧说明一起改了(不改的话下一个人会照着写过期的规矩):
+#         app/version.py 文件头、web/VERSION 的注释、README 第 11 节(中英)
+#
+#       ★ 代价:web/VERSION 在启动时读一次就缓存住(lru_cache),所以 **bump 完
+#         要重启服务**才生效 —— 与后端号原来的行为一致(它也是模块级常量)。
+#         想让它立刻生效得改成可调用对象、模板写 `{{ asset_version() }}`,
+#         那要改 22 处模板,不划算。
+#
+#       ⚠ 1.16.5 那条变更日志里写的"bump 本文件当缓存键"已经过期,在原文后加了
+#         指向本条的说明,没有改写历史记录。
+__version__ = "1.19.4"
\ No newline at end of file
diff --git a/processor/app/video_quality.py b/processor/app/video_quality.py
index 729c15b30a563c68ecb1dd4dbe527a439137159e..4e453eb832de6477820015724f9a21a851e10b02 100644
--- a/processor/app/video_quality.py
+++ b/processor/app/video_quality.py
@@ -23,7 +23,8 @@ import asyncio
 import os
 from pathlib import Path
 
-from app.localstore import read_episode_state, write_episode_state
+# 状态写入走 localstore.mutate_episode_state（锁内 RMW），在用到的地方局部导入 ——
+# 见 _apply_video_quality_result 的注释。
 
 
 DEFAULT_SAMPLE_INTERVAL_SEC = 0.5
@@ -330,19 +331,29 @@ async def check_video_quality_async(batch_dir: str | Path,
 
 def _apply_video_quality_result(episode_id: str, report: dict) -> None:
     """Persist the result while preserving the two-state review UI."""
-    state = read_episode_state(episode_id)
-    state["video_quality_status"] = "passed" if report.get("passed") else "failed"
-    state["video_quality_report"] = report
-    current = str(state.get("status") or "")
-    if report.get("passed"):
-        if current in {"to_review", "completed", "reviewed"}:
-            state["status"] = "reviewed"
-            if not state.get("approved_at"):
-                state["approved_at"] = _utcnow()
-    elif current in {"processing", "completed", "reviewed", "approved", "failed"}:
-        state["status"] = "to_review"
-        state["approved_at"] = None
-    write_episode_state(episode_id, state)
+    from app.localstore import mutate_episode_state
+    from app.processing.cleaning.store import is_approval_blocked
+
+    def _apply(state: dict) -> None:
+        state["video_quality_status"] = "passed" if report.get("passed") else "failed"
+        state["video_quality_report"] = report
+        current = str(state.get("status") or "")
+        if report.get("passed"):
+            # 视频干净 ≠ 数据干净。数据质检判 FAIL/ERROR 的批次留了粘性标记，
+            # 这里必须让路 —— 否则质检刚推回 to_review，又被本函数置成 reviewed。
+            if (current in {"to_review", "completed", "reviewed"}
+                    and not is_approval_blocked(state)):
+                state["status"] = "reviewed"
+                if not state.get("approved_at"):
+                    state["approved_at"] = _utcnow()
+        elif current in {"processing", "completed", "reviewed", "approved", "failed"}:
+            state["status"] = "to_review"
+            state["approved_at"] = None
+
+    # 锁内 RMW：本函数会改 ``status``，而数据质检任务在同一个 run 完成后并发
+    # 写同一份 state。分开 read/write 的话，质检那边写回的旧快照会把这里的
+    # to_review 冲掉 —— 失败批次看上去像已通过。
+    mutate_episode_state(episode_id, _apply)
 
 
 def _utcnow() -> str:
diff --git a/processor/app/web_version.py b/processor/app/web_version.py
new file mode 100644
index 0000000000000000000000000000000000000000..418502950bbb938ad4efcb1bc5da4eb08d58f0d2
--- /dev/null
+++ b/processor/app/web_version.py
@@ -0,0 +1,38 @@
+"""前端版本号 —— 读 ``processor/web/VERSION`` 的第一行。
+
+一个号,两个用途:
+
+    1. 模板里的 ``?v=`` 静态资源缓存键 —— 改了 JS/CSS 就 bump 它,浏览器才会重新拉
+    2. 提交信息里的「前端 X」
+
+**为什么不让后端号来当缓存键**(那是原来的做法):那样每次改前端都要 bump
+*两个*号 —— 后端号给 ``?v=`` 用、前端号给提交信息用 —— 而且两个数对不上时,
+看提交信息的人没法判断浏览器该拿哪一版。现在改前端只动一个数。
+
+★ 读一次就缓存住(``lru_cache``),不是每请求读盘。代价是**改完 ``web/VERSION``
+  要重启服务才生效** —— 与后端号原来的行为一致(它也是模块级常量)。真要让
+  bump 立刻生效,得把它做成可调用对象、模板里写 ``{{ asset_version() }}``,
+  那就得改 22 处模板,不划算。
+"""
+
+from __future__ import annotations
+
+from functools import lru_cache
+from pathlib import Path
+
+VERSION_FILE = Path(__file__).resolve().parent.parent / "web" / "VERSION"
+
+
+@lru_cache(maxsize=1)
+def frontend_version() -> str:
+    """``web/VERSION`` 的第一行(去空白)。文件缺失/为空时返回 ``"0"``。
+
+    读不出来**不抛异常**:静态资源照样能服务,只是 ``?v=`` 退化成一个常量 ——
+    页面完全可用,代价仅仅是缓存可能不新鲜。为了让整个站点因为一个版本文件
+    挂掉,不值得。
+    """
+    try:
+        first_line = VERSION_FILE.read_text(encoding="utf-8").splitlines()[0]
+    except (OSError, IndexError):
+        return "0"
+    return first_line.strip() or "0"
diff --git a/processor/app/workflow_types.py b/processor/app/workflow_types.py
index b0d061b549924f4f1df7f8f8af7bf05d4e19f9dd..a91298f86f078d8a1b4fc9b4046f98e1b7b8019b 100644
--- a/processor/app/workflow_types.py
+++ b/processor/app/workflow_types.py
@@ -18,6 +18,11 @@ LEGACY_TO_CANONICAL: dict[str, str] = {
     "black_hand_rgb_3d": "rgb_to_2d_black_glove",
     "stereo_triangulate": "rgbd_to_3d_bare_hand",
     "black_glove_hand": "rgbd_to_3d_black_glove",
+    # 质量门禁两个卡片的合并：ai_quality_review（视频检查 + AI 标注覆盖率）
+    # 与 data_cleaning（按数据类型清洗）功能重叠，合并为 data_quality。
+    # 端口 key 刻意不变（data / reviewed），旧工作流的连线可直接复用。
+    "ai_quality_review": "data_quality",
+    "data_cleaning": "data_quality",
 }
 
 RGB_2D_TYPES = {
@@ -175,7 +180,9 @@ def migrate_graph_types(graph: dict | None) -> tuple[dict, bool]:
         handle = str(edge.get("sourceHandle") or "")
         result_output = (
             "annotation" if source_type in {"annotation", "ai_annotation"}
-            else "reviewed" if source_type in {"human_review", "ai_quality_review"}
+            # data_quality 是 ai_quality_review 合并后的 slug；node_types 存的是
+            # canonical_node_type() 规范化后的值，所以这里只可能见到新名。
+            else "reviewed" if source_type in {"human_review", "data_quality"}
             else ""
         )
         if result_output and handle == "result":
diff --git a/processor/deploy.py b/processor/deploy.py
index 4c656b1f2359818ee805e06f1a43aa249d49aad0..0f94473d57a3f0d9a72b5d20ceca9fcfdd90c2d0 100644
--- a/processor/deploy.py
+++ b/processor/deploy.py
@@ -914,10 +914,30 @@ def _systemd_available() -> bool:
     return rc in (0, 1) and out.strip() in ("running", "degraded", "starting")
 
 
+# scripts/systemd/host-units/ 那套手工维护的生产单元。它与本脚本渲染的
+# egodata-backend / egodata-workers 是**两套不同的东西**, 并存会抢同一个
+# 8000 端口 —— 谁后启动谁 bind 失败, 然后按 Restart 策略反复重启。
+HOST_UNIT_NAMES = ("egodata-storage", "egodata-db-tunnel", "egodata-api",
+                   "egodata-worker", "egodata-stack-coordinator")
+
+
+def _unit_dir() -> Path:
+    return Path.home() / ".config" / "systemd" / "user"
+
+
+def _host_units_active() -> bool:
+    """本机是否已装 host-units 那套手工单元.
+
+    只要看到 egodata-api.service 就认定是 —— 该单元不由本脚本生成, 它的存在
+    就说明这台机器的服务是由 scripts/systemd/host-units/install.sh 管的。
+    """
+    return (_unit_dir() / "egodata-api.service").is_file()
+
+
 def phase_services_systemd(ports: dict, vllm_enabled: bool) -> None:
     """渲染并安装 systemd 用户级单元 + enable --now (开机自启)."""
     src_dir = PROJECT_ROOT / "scripts" / "systemd"
-    dst_dir = Path.home() / ".config" / "systemd" / "user"
+    dst_dir = _unit_dir()
     dst_dir.mkdir(parents=True, exist_ok=True)
 
     vllm_url = f"http://127.0.0.1:{ports['vllm_port']}/v1/chat/completions"
@@ -1094,6 +1114,17 @@ def phase_services(rep: dict, ports: dict, vllm_enabled: bool, args) -> None:
         phase_services_foreground(ports, vllm_enabled, rep)
         return
     if _systemd_available():
+        if _host_units_active():
+            # 这台机器的 systemd 已经由 scripts/systemd/host-units/ 接管。
+            # 再渲染一套 egodata-backend/egodata-workers 会跟 egodata-api
+            # 抢 8000 端口, 而且那两个单元指向的 Data Acquisition 目录早已
+            # 废弃。这里什么都不装, 直接沿用现有单元。
+            warn("已检测到 scripts/systemd/host-units/ 那套手工单元 "
+                 "(egodata-api / worker / storage / db-tunnel)。")
+            warn("本次跳过 systemd 单元安装, 以免与它争抢端口。")
+            warn("服务管理: systemctl --user restart egodata-api "
+                 "(前端与后端是同一个进程)")
+            return
         phase_services_systemd(ports, vllm_enabled)
     else:
         warn("systemd 用户实例不可用 → 退回前台监督模式")
@@ -1147,10 +1178,13 @@ def phase_report(rep: dict, ports: dict, vllm_enabled: bool, args) -> None:
             + ("   (⚠️ 已避开被占用的 8001)" if ports["vllm_switched"] else ""))
 
     if not IS_WINDOWS and not args.no_services:
-        states = "  ".join(
-            f"{n}: {_unit_state(n)}"
-            for n in (["egodata-backend", "egodata-workers"]
-                      + (["egodata-vllm"] if vllm_enabled else [])))
+        if _host_units_active():
+            managed = list(HOST_UNIT_NAMES)
+        else:
+            managed = ["egodata-backend", "egodata-workers"]
+        states = "  ".join(f"{n}: {_unit_state(n)}"
+                           for n in managed
+                           + (["egodata-vllm"] if vllm_enabled else []))
         say(f"  systemd 服务状态: {states}")
         say("  开机自启: 已启用 (loginctl linger)")
 
diff --git a/processor/deploy.sh b/processor/deploy.sh
old mode 100755
new mode 100644
diff --git a/processor/scripts/archive_sync.sh b/processor/scripts/archive_sync.sh
old mode 100755
new mode 100644
diff --git a/processor/scripts/check_icon_preload.sh b/processor/scripts/check_icon_preload.sh
old mode 100755
new mode 100644
index 38affd71bb4da2f87bf84a522cc728f150e432ee..699c405d8807f8434993ae2044b5cb327083733f
--- a/processor/scripts/check_icon_preload.sh
+++ b/processor/scripts/check_icon_preload.sh
@@ -6,9 +6,18 @@ ROOT="$(cd "$(dirname "$0")/.." && pwd)"
 PRE="$ROOT/web/static/iconify-preload.js"
 [ -f "$PRE" ] || { echo "找不到 $PRE"; exit 1; }
 
-# 代码里所有 "前缀:图标名" 引用(ant-design:xxx 等)
+# 代码里所有 "前缀:图标名" 引用(ant-design:xxx 等)。
+#
+# ★ app/processing/modules/ 也必须扫 —— 工作流节点的 icon 是在 Python 里声明的
+#   (如 data_cleaning.py 的 ``icon = "ant-design:check-circle-outlined"``),
+#   这些图标和前端硬编码的一样会被调色板渲染。曾经漏扫这里,导致新增节点
+#   用了白名单外的图标而检查脚本仍报"全部已预加载"。
+#
+#   Python 文件里会有 ``cuda:0`` / ``-c:v`` 之类的噪声,但下面只认 ant-design:
+#   前缀,噪声会被过滤掉。
 USED="$(grep -rhoE "[a-z0-9-]+:[a-z0-9-]+" \
-  "$ROOT/web/workflow-studio/src" "$ROOT/web/static/js" "$ROOT/web/templates" 2>/dev/null \
+  "$ROOT/web/workflow-studio/src" "$ROOT/web/static/js" "$ROOT/web/templates" \
+  "$ROOT/app/processing/modules" 2>/dev/null \
   | sort -u)"
 
 MISSING=""
@@ -19,11 +28,19 @@ while IFS= read -r ref; do
     *) continue ;;
   esac
   name="${ref#ant-design:}"
-  grep -q "'${name}': { body" "$PRE" || MISSING="$MISSING"$'\n'"  $ref"
+  if ! grep -q "'${name}': { body" "$PRE"; then
+    # 指出是谁声明的,便于补齐
+    WHERE="$(grep -rlE "[\"']?${ref}[\"']?" \
+      "$ROOT/web/workflow-studio/src" "$ROOT/web/static/js" "$ROOT/web/templates" \
+      "$ROOT/app/processing/modules" 2>/dev/null \
+      | sed "s|^$ROOT/||" | paste -sd, -)"
+    MISSING="$MISSING"$'\n'"  $ref    ← ${WHERE:-未知位置}"
+  fi
 done <<< "$USED"
 
 if [ -n "$MISSING" ]; then
-  echo "以下图标未预加载(页面会出现闪烁/空白),请补进 $PRE :"
+  echo "以下图标未预加载(iconify-icon 会去 api.iconify.design 拉,页面卡顿/空白)。"
+  echo "请改用 $PRE 白名单里的图标,或把图标数据补进去:"
   echo "$MISSING"
   exit 1
 fi
diff --git a/processor/scripts/check_tailwind_build.sh b/processor/scripts/check_tailwind_build.sh
new file mode 100644
index 0000000000000000000000000000000000000000..ff577e5bf338dcb69c2f5a8faf47874fcaa86764
--- /dev/null
+++ b/processor/scripts/check_tailwind_build.sh
@@ -0,0 +1,54 @@
+#!/usr/bin/env bash
+# 检查 web/static/tailwind-generated.css 是否与当前源码同步。
+#
+# 为什么需要这个:那份 CSS 是**构建产物**,只包含生成时源码里出现过的类。
+# 往 templates/ 或 static/js/ 里写了一个没被用过的 Tailwind 类(比如把 p-6
+# 改成 px-6 pt-3 pb-6),类就**静默失效** —— 页面照常显示,只是样式没上,
+# 而且不报任何错。已经踩过两次:
+#   第一次:p-6 拆成 px-6 pt-3 pb-6,左右内边距直接归零,内容贴到侧边栏上
+#   第二次:训练页一半的类(w-28 / text-[10px] / accent-blue-500 / divide-y)
+#           因为 CSS 停在几周前而全部失效
+#
+# 做法:用同样的 content 范围重新生成一份到临时文件,和现场那份比对。
+# 有差异 = 忘了重新生成(或改了 content 范围)。
+#
+# 用法:
+#   bash scripts/check_tailwind_build.sh          # 只检查
+#   bash scripts/check_tailwind_build.sh --fix    # 检查并就地重新生成
+
+set -euo pipefail
+
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+WEB="$(dirname "$HERE")/web"
+OUT="$WEB/static/tailwind-generated.css"
+INPUT="$WEB/static/tailwind-input.css"
+CONTENT="$WEB/templates/**/*.html,$WEB/static/js/**/*.js"
+CLI="$WEB/workflow-studio/node_modules/.bin/tailwindcss"
+
+if [ ! -x "$CLI" ]; then
+    echo "找不到 tailwindcss CLI:$CLI"
+    echo "先跑 cd web/workflow-studio && npm install"
+    exit 2
+fi
+
+TMP="$(mktemp -t tw-check-XXXXXX.css)"
+trap 'rm -f "$TMP"' EXIT
+
+"$CLI" -i "$INPUT" -o "$TMP" --content "$CONTENT" >/dev/null 2>&1
+
+if cmp -s "$TMP" "$OUT"; then
+    echo "tailwind-generated.css 与源码同步 ✓"
+    exit 0
+fi
+
+if [ "${1:-}" = "--fix" ]; then
+    cp "$TMP" "$OUT"
+    echo "已重新生成 tailwind-generated.css"
+    echo "⚠ 记得 bump app/version.py 的 __version__ —— 它是这个文件的 ?v= 缓存键,"
+    echo "  不 bump 的话浏览器会继续用旧的,新样式到不了前端。"
+    exit 0
+fi
+
+echo "❌ tailwind-generated.css 与源码不一致 —— 有类的样式没生效。"
+echo "   跑 bash scripts/check_tailwind_build.sh --fix 重新生成"
+exit 1
diff --git a/processor/scripts/ensure_stack_linux.sh b/processor/scripts/ensure_stack_linux.sh
old mode 100755
new mode 100644
diff --git a/processor/scripts/run_quality_checks.py b/processor/scripts/run_quality_checks.py
new file mode 100644
index 0000000000000000000000000000000000000000..e3b7fa3e58cc27ffc96e3f5f1305c75a20c7c752
--- /dev/null
+++ b/processor/scripts/run_quality_checks.py
@@ -0,0 +1,180 @@
+#!/usr/bin/env python3
+"""离线跑数据质检 —— 只读数据集，打印真实分布。
+
+**这个脚本不写任何东西**：不落盘、不改数据、不碰 state/、不接工作流。
+它的唯一目的是拿真实数据回答"阈值该定多少"——在此之前所有阈值都是猜。
+
+引擎是 ``app.processing.cleaning.engine``，本脚本只负责遍历与展示。
+
+用法::
+
+    # 快速（只看 parquet，不碰视频）
+    python scripts/run_quality_checks.py --dataset <LeRobot数据集路径>
+
+    # 含视频检查（慢，每集要解码抽样）
+    python scripts/run_quality_checks.py --dataset <路径> --video --limit 5
+
+    # 看某一集的逐项结果
+    python scripts/run_quality_checks.py --dataset <路径> --episode 1 -v
+
+    # 用配置文件覆盖阈值（结构见 data_quality 节点的 config）
+    python scripts/run_quality_checks.py --dataset <路径> --config cfg.json
+
+数据集可以是 LeRobot v2.1/v3.0 导出产物（meta/info.json + data/*.parquet），
+也可以是 sessions/<项目>/ 下的 canonical 数据。
+"""
+
+from __future__ import annotations
+
+import argparse
+import glob
+import json
+import sys
+import time
+from collections import Counter, defaultdict
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+import numpy as np  # noqa: E402
+
+from app.processing.cleaning.contract import (  # noqa: E402
+    PASS, WARN, FAIL, PENDING, ERROR, SEVERITY_LABELS,
+)
+from app.processing.cleaning.engine import run_checks, ruleset_revision  # noqa: E402
+
+_MARK = {PASS: "✓", WARN: "!", FAIL: "✗", PENDING: "?", ERROR: "E"}
+
+
+def iter_episodes(dataset: Path) -> list[tuple[int | None, Path]]:
+    """列出要跑的 (episode_index, 文件) 组合。
+
+    canonical 一集一文件 → episode_index 为 None（文件本身就是那一集）；
+    导出产物一文件多集 → 需要逐个 episode_index 筛。
+    """
+    out: list[tuple[int | None, Path]] = []
+    for path in sorted(glob.glob(str(dataset / "data" / "chunk-*" / "*.parquet"))):
+        parquet = Path(path)
+        if parquet.name.startswith("episode_"):
+            out.append((None, parquet))          # canonical：一集一文件
+        else:
+            import pyarrow.parquet as pq
+            table = pq.ParquetFile(parquet)
+            if "episode_index" not in table.schema_arrow.names:
+                out.append((None, parquet))
+                continue
+            for value in sorted(set(table.read(columns=["episode_index"])
+                                     ["episode_index"].to_pylist())):
+                out.append((int(value), parquet))
+    return out
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--dataset", required=True, help="数据集根目录")
+    parser.add_argument("--limit", type=int, default=0, help="最多跑几集（0=全部）")
+    parser.add_argument("--episode", type=int, default=None, help="只看这一集")
+    parser.add_argument("--video", action="store_true", help="跑视频检查（慢）")
+    parser.add_argument("--config", default=None, help="阈值配置文件（JSON）")
+    parser.add_argument("--modality", default=None,
+                        help="设备卡片（如 gripper_device）；不传则按数据推断")
+    parser.add_argument("-v", "--verbose", action="store_true", help="逐项打印")
+    args = parser.parse_args()
+
+    root = Path(args.dataset).expanduser().resolve()
+    if not root.is_dir():
+        print(f"找不到数据集目录: {root}")
+        return 1
+
+    config = None
+    if args.config:
+        config = json.loads(Path(args.config).read_text(encoding="utf-8"))
+
+    episodes = iter_episodes(root)
+    if args.episode is not None:
+        episodes = [item for item in episodes if item[0] == args.episode]
+    if args.limit:
+        episodes = episodes[: args.limit]
+    if not episodes:
+        print(f"{root} 下没有找到可跑的 episode")
+        return 1
+
+    print(f"数据集: {root}")
+    print(f"集数:   {len(episodes)}   （**只读，不写入任何东西**）")
+    print(f"规则集: {ruleset_revision()}")
+    print()
+
+    per_episode: list[dict] = []
+    rule_hits: Counter = Counter()
+    metric_samples: dict[str, list] = defaultdict(list)
+
+    started = time.time()
+    for index, _parquet in episodes:
+        report = run_checks(
+            root, episode_index=index,
+            episode_id=f"{root.name}_{index if index is not None else 0:06d}",
+            project=root.name, config=config,
+            probe_video=args.video, modality_hint=args.modality,
+        )
+        status = report["episode"]["status"]
+        per_episode.append({"index": index, "status": status, "report": report})
+
+        for finding in report["findings"]:
+            if finding["status"] != PASS:
+                rule_hits[finding["rule"]] += 1
+            for key, value in (finding["metrics"] or {}).items():
+                if isinstance(value, (int, float)) and not isinstance(value, bool):
+                    metric_samples[f"{finding['rule']}.{key}"].append(float(value))
+
+        if args.verbose:
+            print(f"── 集 {index if index is not None else '-':>5}  "
+                  f"{report['modalities'].get('rows', 0):>5} 帧  "
+                  f"{SEVERITY_LABELS.get(status, status)} ──")
+            for finding in report["findings"]:
+                print(f"   {_MARK.get(finding['status'], ' ')} "
+                      f"{finding['rule']:24s} "
+                      f"{SEVERITY_LABELS.get(finding['status'], finding['status']):6s} "
+                      f"{finding['message'][:56]}")
+            for item in report["ranges"][:8]:
+                print(f"       [{item['start_sec']:7.2f}s] {item['message'][:52]}")
+            print()
+
+    # ── 汇总 ────────────────────────────────────────────────
+    print("=" * 72)
+    print(f"跑了 {len(per_episode)} 集，用时 {time.time() - started:.1f} 秒")
+    print("=" * 72)
+    print()
+
+    overall = Counter(item["status"] for item in per_episode)
+    print("★ 按集统计（取每集最严重的）:")
+    for status in (PASS, WARN, FAIL, PENDING, ERROR):
+        count = overall.get(status, 0)
+        if count:
+            print(f"    {SEVERITY_LABELS[status]:8s} {count:>4} 集"
+                  f"  ({count / len(per_episode):>5.1%})")
+    print()
+
+    print("★ 命中的检查项:")
+    if not rule_hits:
+        print("    （没有任何检查项报警）")
+    for rule, count in rule_hits.most_common():
+        print(f"    {rule:28s} {count:>4} 集")
+    print()
+
+    print("★ 关键指标的真实分布（定阈值要用这个）:")
+    for key in sorted(metric_samples):
+        values = np.asarray(metric_samples[key], dtype=float)
+        if values.size < 2:
+            continue
+        print(f"    {key:48s} "
+              f"中位 {np.median(values):>10.4f}  "
+              f"p90 {np.percentile(values, 90):>10.4f}  "
+              f"max {values.max():>10.4f}")
+    print()
+    print("★ 未写入任何文件。")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/processor/scripts/systemd/host-units/egodata-watchdog.sh b/processor/scripts/systemd/host-units/egodata-watchdog.sh
old mode 100755
new mode 100644
diff --git a/processor/scripts/systemd/host-units/install.sh b/processor/scripts/systemd/host-units/install.sh
old mode 100755
new mode 100644
diff --git a/processor/tests/test_check_video.py b/processor/tests/test_check_video.py
new file mode 100644
index 0000000000000000000000000000000000000000..8bc5b5136e519a7d7344e5389f7bbcba12cb113f
--- /dev/null
+++ b/processor/tests/test_check_video.py
@@ -0,0 +1,199 @@
+"""视频类检查项单测。
+
+这些检查项**不读磁盘** —— 证据由 evidence.py 采集好放进 StreamEvidence，
+测试直接构造假证据即可，不需要真 mp4 或 cv2。这正是当初把 IO 做成注入的目的。
+
+    pytest tests/test_check_video.py
+    python3 tests/test_check_video.py
+"""
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from app.processing.cleaning.checks import (  # noqa: E402
+    CheckContext, StreamEvidence, get_check, PASS, WARN, FAIL, ERROR,
+)
+
+
+def _ctx(streams, **kwargs) -> CheckContext:
+    """装一个最小的执行上下文。"""
+    return CheckContext(batch_dir=Path("/tmp/nonexistent"),
+                        streams=tuple(streams), **kwargs)
+
+
+def _rgb(key="umi_rgb", **video) -> StreamEvidence:
+    return StreamEvidence(key=key, channel="rgb", fps=30.0, video=video)
+
+
+# ── video.frame_drop ────────────────────────────────────────
+def test_frame_drop_passes_within_tolerance():
+    check = get_check("video.frame_drop")
+    ctx = _ctx([_rgb(frame_count=1188, reason="passed")], data_rows=1190)
+    findings = check.run(ctx)
+    assert len(findings) == 1
+    assert findings[0].status == PASS
+
+
+def test_frame_drop_warns_on_small_gap():
+    check = get_check("video.frame_drop")
+    # 差 20 帧 / 容差 max(2, 1200*0.005=6) = 6 → 20 > 6*5=30? 否 → WARN
+    ctx = _ctx([_rgb(frame_count=1180, reason="passed")], data_rows=1200)
+    findings = check.run(ctx)
+    assert findings[0].status == WARN
+    assert findings[0].metrics["diff"] == 20
+    assert findings[0].metrics["tolerance"] == 6
+
+
+def test_frame_drop_fails_on_large_gap():
+    check = get_check("video.frame_drop")
+    # 差 500 帧 >> 容差*5 → FAIL
+    ctx = _ctx([_rgb(frame_count=700, reason="passed")], data_rows=1200)
+    assert check.run(ctx)[0].status == FAIL
+
+
+def test_frame_drop_tolerance_floor_for_small_batches():
+    """小批次按绝对帧数兜底：100 行 × 0.5% = 0 → 用下限 2。"""
+    check = get_check("video.frame_drop")
+    ctx = _ctx([_rgb(frame_count=98, reason="passed")], data_rows=100)
+    findings = check.run(ctx)
+    assert findings[0].metrics["tolerance"] == 2
+    assert findings[0].status == PASS
+
+
+def test_frame_drop_ignores_unreadable_video():
+    """打不开的流不该被算成"丢帧" —— 那是 decode_error 的职责。"""
+    check = get_check("video.frame_drop")
+    ctx = _ctx([_rgb(frame_count=0, reason="video_open_failed")], data_rows=1200)
+    assert check.run(ctx) == []
+
+
+def test_frame_drop_uses_node_params_over_defaults():
+    """节点配置的阈值要盖过 default_params。"""
+    check = get_check("video.frame_drop")
+    ctx = _ctx([_rgb(frame_count=900, reason="passed")], data_rows=1000,
+               params={"tolerance_ratio": 0.5, "tolerance_min": 500})
+    assert check.run(ctx)[0].status == PASS
+
+
+# ── video.black_screen ──────────────────────────────────────
+def test_black_screen_passes_when_no_ranges():
+    check = get_check("video.black_screen")
+    assert check.run(_ctx([_rgb(frame_count=300, reason="passed")])) == []
+
+
+def test_black_screen_reports_ranges_and_frames():
+    check = get_check("video.black_screen")
+    # 30 秒里黑 1 秒 = 3.3%，低于 fail_ratio(5%) → WARN
+    ctx = _ctx([_rgb(frame_count=900, fps=30.0, reason="black_screen",
+                     black_ranges=[[12.0, 13.0]])],
+               duration_sec=30.0)
+    finding = check.run(ctx)[0]
+    assert finding.status == WARN
+    assert finding.metrics["segments"] == 1
+    assert len(finding.ranges) == 1
+    item = finding.ranges[0]
+    assert item.start_sec == 12.0 and item.end_sec == 13.0
+    assert item.start_frame == 360 and item.end_frame == 390
+
+
+def test_black_screen_fails_when_ratio_exceeds_threshold():
+    """占比超过 5% → FAIL。30 秒里黑 3 秒 = 10%。"""
+    check = get_check("video.black_screen")
+    ctx = _ctx([_rgb(frame_count=900, reason="black_screen",
+                     black_ranges=[[0.0, 3.0]])],
+               duration_sec=30.0)
+    assert check.run(ctx)[0].status == FAIL
+
+
+def test_black_screen_drops_ranges_below_min_sec():
+    """短于 min_sec(0.5s) 的黑屏段忽略 —— 避免逐帧闪烁刷屏。"""
+    check = get_check("video.black_screen")
+    ctx = _ctx([_rgb(frame_count=900, reason="black_screen",
+                     black_ranges=[[1.0, 1.2]])],
+               duration_sec=30.0)
+    assert check.run(ctx) == []
+
+
+# ── video.freeze ────────────────────────────────────────────
+def test_freeze_warns_and_escalates_by_duration():
+    check = get_check("video.freeze")
+    short = _ctx([_rgb(frame_count=900, reason="freeze_suspected",
+                       freeze_ranges=[[5.0, 8.0]])])
+    assert check.run(short)[0].status == WARN          # 3 秒 < fail_sec(10)
+
+    long = _ctx([_rgb(frame_count=900, reason="freeze_suspected",
+                      freeze_ranges=[[5.0, 20.0]])])
+    assert check.run(long)[0].status == FAIL           # 15 秒 >= 10
+
+
+def test_freeze_metrics_report_longest():
+    """longest_sec 取最长的那一段：4.0s 和 5.0s → 5.0。"""
+    check = get_check("video.freeze")
+    ctx = _ctx([_rgb(frame_count=900, reason="freeze_suspected",
+                     freeze_ranges=[[5.0, 9.0], [20.0, 25.0]])])
+    finding = check.run(ctx)[0]
+    assert finding.metrics["segments"] == 2
+    assert finding.metrics["longest_sec"] == 5.0
+
+
+# ── video.decode_error ──────────────────────────────────────
+def test_decode_error_passes_without_errors():
+    check = get_check("video.decode_error")
+    ctx = _ctx([_rgb(frame_count=300, reason="passed", decode_error_count=0)])
+    assert check.run(ctx)[0].status == PASS
+
+
+def test_decode_error_fails_and_marks_frames():
+    check = get_check("video.decode_error")
+    ctx = _ctx([_rgb(frame_count=300, fps=30.0, reason="decode_error",
+                     decode_error_count=3, decode_errors=[30, 60, 90])])
+    finding = check.run(ctx)[0]
+    assert finding.status == FAIL
+    assert len(finding.ranges) == 3
+    assert finding.ranges[0].start_frame == 30
+    assert finding.ranges[0].start_sec == 1.0
+
+
+def test_decode_error_marks_opencv_missing_as_error_not_fail():
+    """缺 OpenCV 是环境问题，不该记成数据质量事故。"""
+    check = get_check("video.decode_error")
+    ctx = _ctx([_rgb(reason="opencv_unavailable")])
+    assert check.run(ctx)[0].status == ERROR
+
+
+def test_decode_error_marks_unopenable_video_as_fail():
+    check = get_check("video.decode_error")
+    ctx = _ctx([_rgb(reason="video_open_failed", error="moov atom not found")])
+    finding = check.run(ctx)[0]
+    assert finding.status == FAIL
+    assert "moov atom" in finding.metrics["error"]
+
+
+# ── 跨流 ────────────────────────────────────────────────────
+def test_checks_iterate_all_rgb_streams():
+    """双目项目有两路 RGB，都要检查。"""
+    check = get_check("video.frame_drop")
+    ctx = _ctx([_rgb("cam_left", frame_count=700, reason="passed"),
+                _rgb("cam_right", frame_count=1200, reason="passed")],
+               data_rows=1200)
+    findings = check.run(ctx)
+    assert {item.stream for item in findings} == {"cam_left", "cam_right"}
+    assert [item.status for item in findings].count(FAIL) == 1
+
+
+if __name__ == "__main__":
+    import traceback
+    failures = 0
+    for name, fn in sorted(globals().items()):
+        if not name.startswith("test_") or not callable(fn):
+            continue
+        try:
+            fn()
+            print(f"  ✓ {name}")
+        except Exception:
+            failures += 1
+            print(f"  ✗ {name}")
+            traceback.print_exc()
+    print(f"\n{'FAILED' if failures else 'OK'} ({failures} 个失败)")
+    sys.exit(1 if failures else 0)
diff --git a/processor/tests/test_cleaning_collect.py b/processor/tests/test_cleaning_collect.py
new file mode 100644
index 0000000000000000000000000000000000000000..9e1b1008f3b047f35cc33fae99a6e47ffcf54c75
--- /dev/null
+++ b/processor/tests/test_cleaning_collect.py
@@ -0,0 +1,231 @@
+"""采集层的两条静默失效，各上一把锁。
+
+它们都不报错、报告照常生成，只是内容是错的：
+
+  1. **非首集读出空帧** —— canonical 是一集一文件，曾经取 ``parquets[0]`` 再按
+     ``episode_index`` 列筛行，于是除第 0 集外全筛成空。报告退化成
+     ``empty_report``（``episode.status = ERROR``），在"数据不对就拦回人工审核"
+     的链路里表现为**每一集都被卡住**。
+  2. **触觉阵列被截断** —— ``_CHANNEL_WIDTH`` 没有 ``tactile`` 项，落到 3 的
+     兜底值，16×16=256 个感应点被静默截成 3 个，检查项只看得到 1%。
+
+外加两套命名的去重（``observation.tactile.*`` 与 ``observation.*_glove``）。
+
+造的是最小 fixture，不依赖真实数据、不需要 cv2。
+
+    pytest tests/test_cleaning_collect.py
+    python3 tests/test_cleaning_collect.py
+"""
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))  # noqa: E402
+
+import numpy as np  # noqa: E402
+import pandas as pd  # noqa: E402
+
+from app.processing.cleaning import collect  # noqa: E402
+
+
+# ── fixture ─────────────────────────────────────────────────
+def _canonical_batch(root: Path, episodes) -> Path:
+    """canonical 布局：一集一文件。``episodes`` 是 {集号: 行数}。"""
+    (root / "data" / "chunk-000").mkdir(parents=True, exist_ok=True)
+    (root / "meta").mkdir(exist_ok=True)
+    for index, rows in episodes.items():
+        pd.DataFrame({
+            "episode_index": np.full(rows, index, dtype="int64"),
+            "frame_index": np.arange(rows, dtype="int64"),
+            "timestamp": np.arange(rows, dtype=float) / 30.0,
+        }).to_parquet(root / "data" / "chunk-000" / f"episode_{index:06d}.parquet")
+    return root
+
+
+def _tactile_batch(root: Path, *, columns, frames=8, width=256) -> Path:
+    """带触觉阵列的批次。``columns`` 决定用哪套命名。"""
+    (root / "data" / "chunk-000").mkdir(parents=True, exist_ok=True)
+    (root / "meta").mkdir(exist_ok=True)
+    data = {"timestamp": np.arange(frames, dtype=float) / 30.0}
+    for name in columns:
+        data[name] = [list(np.full(width, float(i))) for i in range(frames)]
+    pd.DataFrame(data).to_parquet(root / "data" / "chunk-000" / "episode_000000.parquet")
+    return root
+
+
+# ── 定位这一集的数据文件 ─────────────────────────────────────
+def test_picks_the_file_for_the_requested_episode(tmp_path):
+    """★ 核心回归：非首集必须读到**自己**那个文件，而不是空帧。"""
+    batch = _canonical_batch(tmp_path / "b", {0: 10, 1: 20, 7: 30})
+
+    for index, rows in ((0, 10), (1, 20), (7, 30)):
+        path, filter_rows = collect.resolve_episode_data(batch, index)
+        assert path is not None and path.name == f"episode_{index:06d}.parquet"
+        assert filter_rows is False, "canonical 一集一文件，不该再按列筛行"
+        assert len(collect.load_rows(path)) == rows
+
+
+def test_the_original_bug_is_actually_a_bug(tmp_path):
+    """把当初的写法钉在这里：它**不报错**，只是静默返回空帧。
+
+    当初是「取 ``parquets[0]`` 再按 ``episode_index`` 列筛行」。canonical 每一集
+    一个文件，第 0 个文件里只有第 0 集的行 —— 拿它去筛第 3 集得到 0 行。
+    """
+    batch = _canonical_batch(tmp_path / "b", {0: 10, 3: 25})
+    first = collect.resolve_episode_data(batch, 0)[0]
+
+    assert len(collect.load_rows(first, 3)) == 0        # ← 当初的 bug
+    assert len(collect.load_rows(first, 0)) == 10       # 只有筛自己那集才对
+
+    # 现在的做法：选对文件，且**不再按列筛行**
+    third, filter_rows = collect.resolve_episode_data(batch, 3)
+    assert filter_rows is False
+    assert len(collect.load_rows(third, None)) == 25
+
+
+def test_gather_evidence_reads_the_requested_episode(tmp_path):
+    """★ 端到端那把锁。
+
+    上面两条直接测 ``resolve_episode_data``，**测不到接线**：把
+    ``gather_evidence`` 改回"取第一个文件 + 按列筛行"，它们照样全绿。而当初
+    出 bug 的正是接线那一处。这里断言的是采集**结果**。
+    """
+    batch = _canonical_batch(tmp_path / "b", {0: 10, 3: 25, 9: 40})
+
+    for index, rows in ((0, 10), (3, 25), (9, 40)):
+        evidence = collect.gather_evidence(batch, episode_index=index)
+        assert evidence.rows == rows, (
+            f"episode {index} 读到 {evidence.rows} 行、应为 {rows} 行 —— "
+            f"多半是又退回了「取第一个文件再按列筛行」")
+        assert evidence.notes.get("reason") is None, "退化成空报告了"
+
+
+def test_missing_episode_returns_none(tmp_path):
+    batch = _canonical_batch(tmp_path / "b", {0: 5})
+    assert collect.resolve_episode_data(batch, 99)[0] is None
+
+
+def test_multi_episode_layout_still_filters_rows(tmp_path):
+    """导出产物是一文件多集，那条路必须继续按行筛。"""
+    root = tmp_path / "b" / "data" / "chunk-000"
+    root.mkdir(parents=True)
+    pd.DataFrame({
+        "episode_index": np.repeat([4, 5], 6),
+        "timestamp": np.arange(12, dtype=float),
+    }).to_parquet(root / "file-000.parquet")
+
+    path, filter_rows = collect.resolve_episode_data(tmp_path / "b", 5)
+    assert path is not None and filter_rows is True
+    frame = collect.load_rows(path, 5)
+    assert len(frame) == 6 and set(frame["episode_index"]) == {5}
+
+
+# ── 触觉阵列 ────────────────────────────────────────────────
+def test_tactile_array_is_not_truncated(tmp_path):
+    """★ 256 个感应点必须原样保留 —— 截成 3 个检查项就废了。"""
+    batch = _tactile_batch(tmp_path / "b", columns=["observation.left_glove"])
+    evidence = collect.gather_evidence(batch)
+
+    stream = next(s for s in evidence.streams if s.channel == "tactile")
+    series = stream.series["tactile"]
+    assert len(series[0]) == 256, f"触觉阵列被截断成 {len(series[0])}"
+
+
+def test_unknown_channel_is_not_truncated():
+    """兜底宽度不能是某个具体数字 —— 换设备时同样会静默丢数据。"""
+    assert collect.vector_series([[1.0] * 40])[0] == tuple([1.0] * 40)
+    assert len(collect.vector_series([[1.0] * 40], 7)[0]) == 7   # 显式声明才截断
+
+
+def test_tactile_alias_is_recognized(tmp_path):
+    """★ 只跑过导出的树上只有 observation.tactile.* —— 以前认不出，手套检查
+    整条静默跳过。"""
+    batch = _tactile_batch(tmp_path / "b", columns=["observation.tactile.left"])
+    evidence = collect.gather_evidence(batch)
+
+    assert "tactile" in evidence.channels
+    keys = [s.key for s in evidence.streams if s.channel == "tactile"]
+    assert keys == ["left_glove"], f"别名列没归一成协议流名: {keys}"
+
+
+def test_both_naming_schemes_do_not_duplicate(tmp_path):
+    """两套命名同时存在时是同一份数据，登记成两条流会让缺陷被报两次。"""
+    batch = _tactile_batch(
+        tmp_path / "b",
+        columns=["observation.left_glove", "observation.tactile.left"])
+    evidence = collect.gather_evidence(batch)
+
+    keys = [s.key for s in evidence.streams if s.channel == "tactile"]
+    assert keys == ["left_glove"], f"同一份数据被登记了多条流: {keys}"
+
+
+def test_one_handed_episode_yields_one_stream(tmp_path):
+    """同项目内 schema 不一致是真实存在的（D435 第 3 集只有右手）。
+
+    采集层只要"有什么收什么"即可；检查项不能假设双手都在。
+    """
+    batch = _tactile_batch(tmp_path / "b", columns=["observation.right_glove"])
+    evidence = collect.gather_evidence(batch)
+
+    keys = [s.key for s in evidence.streams if s.channel == "tactile"]
+    assert keys == ["right_glove"]
+    assert evidence.modalities == ("glove_sensor",)
+
+
+# ── SLAM 列的多相机命名 ─────────────────────────────────────
+#
+# 双目/多相机把第二路存成 observation.<相机名>_slam_*，而采集只认不带前缀的
+# 两个名字 —— 那种集**有 SLAM 数据、却一个 SLAM 检查都不跑**，且不报任何错
+# （实测 Test94/episode_000003 只有 gripper_2 前缀，整集 SLAM 检查全空）。
+def test_slam_single_camera_prefers_trajectory():
+    """一个相机两列都在时只取一条 —— trajectory 是高频样本缓冲。"""
+    assert collect._slam_columns(
+        {"observation.slam_trajectory", "observation.slam_pose"}
+    ) == ["observation.slam_trajectory"]
+
+
+def test_slam_prefixed_camera_is_recognized():
+    """★ 回归：只有 observation.<相机名>_slam_* 时也要认出来。"""
+    picked = collect._slam_columns(
+        {"observation.gripper_2_slam_trajectory", "observation.gripper_2_slam_pose"})
+    assert picked == ["observation.gripper_2_slam_trajectory"]
+
+
+def test_slam_multiple_cameras_yield_one_stream_each():
+    """★ 双目：每个相机各一条流 —— 之前是全局 break，只取第一路。"""
+    picked = collect._slam_columns({
+        "observation.slam_pose", "observation.gripper_2_slam_pose"})
+    assert sorted(picked) == ["observation.gripper_2_slam_pose",
+                              "observation.slam_pose"]
+
+
+def test_slam_ignores_lookalike_columns():
+    """名字里含 slam 但不是位姿的列不能被当成 SLAM。"""
+    assert collect._slam_columns({"observation.slam_trajectory_ns"}) == []
+    assert collect._slam_columns(
+        {"processing.umi_slam_action.data_4.action"}) == []
+    # 伴生列在场也不影响正常列
+    assert collect._slam_columns(
+        {"observation.slam_pose", "observation.slam_trajectory_ns"}
+    ) == ["observation.slam_pose"]
+
+
+def test_gather_evidence_reads_prefixed_slam(tmp_path):
+    """端到端：只有前缀命名的集也要产出 slam 流与 slam 信道。"""
+    root = tmp_path / "b" / "data" / "chunk-000"
+    root.mkdir(parents=True)
+    (tmp_path / "b" / "meta").mkdir()
+    rows = 6
+    pd.DataFrame({
+        "observation.gripper_2_slam_pose": [
+            [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0]] * rows,
+    }).to_parquet(root / "episode_000000.parquet")
+
+    evidence = collect.gather_evidence(tmp_path / "b")
+    slam = [s for s in evidence.streams if s.channel == "slam"]
+    assert [s.key for s in slam] == ["gripper_2_slam_pose"]
+    assert "slam" in evidence.channels
+
+
+if __name__ == "__main__":
+    import pytest
+    raise SystemExit(pytest.main([__file__, "-q"]))
diff --git a/processor/tests/test_cleaning_config.py b/processor/tests/test_cleaning_config.py
new file mode 100644
index 0000000000000000000000000000000000000000..7a02c3350594a9195f4641bfb606173d7e8c378b
--- /dev/null
+++ b/processor/tests/test_cleaning_config.py
@@ -0,0 +1,170 @@
+"""质检配置解析单测(engine.resolve_config / applicable_checks 的用法 +
+trigger 的工作流接线判定)。
+
+**这个文件盯的是一类 bug：检查项静默不跑。** 报告照常生成、``passed`` 照常
+写，只是有一条本该跑的检查根本没执行 —— 没有任何异常、没有任何日志。项目里
+已经因此踩过好几次，所以这里每条都用"跑了几项"来断言，而不是断言没抛异常。
+
+全是纯函数 + 一次针对临时目录的引擎调用，不需要真视频、不需要 cv2。
+
+    pytest tests/test_cleaning_config.py
+    python3 tests/test_cleaning_config.py
+"""
+import sys
+import tempfile
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))  # noqa: E402
+
+from app.processing.cleaning import engine  # noqa: E402
+from app.processing.cleaning.collect import _detect_modalities  # noqa: E402
+from app.processing.cleaning.trigger import data_quality_target  # noqa: E402
+
+
+# ── 模态推断 ────────────────────────────────────────────────
+def test_infers_from_channels_when_no_hint():
+    assert _detect_modalities({"rgb"}, None) == ("mono_rgb",)
+    assert _detect_modalities({"tactile"}, None) == ("glove_sensor",)
+    assert _detect_modalities({"slam", "rgb"}, None) == ("gripper_device",)
+
+
+def test_alias_node_types_normalize():
+    # 工作流节点类型用的是 camera 后缀，要映射到 canonical 设备模态
+    assert _detect_modalities({"rgb"}, "mono_camera") == ("mono_rgb",)
+    assert _detect_modalities({"depth"}, "rgbd_camera") == ("rgbd_camera",)
+
+
+def test_hint_wins_for_modalities_inference_cannot_produce():
+    """★ ``stereo_rgb`` 推断不出来 —— "立体"不是列名里看得见的特征。
+
+    没有这条，双目工作流在设置面板里配的阈值会被静默忽略（查不到那个 tab）。
+    """
+    assert "stereo_rgb" in _detect_modalities({"rgb"}, ["stereo_rgb"])
+    assert "stereo_rgbd_camera" in _detect_modalities({"depth"}, ["stereo_rgbd_camera"])
+
+
+def test_hint_and_inference_are_unioned():
+    """两个来源各有盲区，取并集 —— 缺一个都会有检查项不跑。"""
+    got = _detect_modalities({"rgb", "depth"}, ["stereo_rgbd_camera"])
+    assert "stereo_rgbd_camera" in got          # 来自 hint
+    assert "rgbd_camera" in got                 # 来自数据推断
+
+
+def test_multiple_hints_keep_order():
+    """多设备时工作流连线的顺序 = 用户预期顺序（resolve_config 先出现的优先）。"""
+    assert _detect_modalities({"rgb", "slam"}, ["gripper_device", "mono_rgb"]) == \
+        ("gripper_device", "mono_rgb")
+
+
+# ── 工作流接线判定 ──────────────────────────────────────────
+def _graph(nodes, edges):
+    return {
+        "nodes": [{"id": i, "data": {"nodeType": t}} for i, t in nodes],
+        "edges": [{"source": s, "target": t} for s, t in edges],
+    }
+
+
+def test_target_requires_incoming_edge():
+    """孤零零摆一张卡片只是配置，不该触发 —— 与 video_quality_gate 同语义。"""
+    assert data_quality_target(_graph([("q", "data_quality")], []), {}) is None
+
+
+def test_target_accepts_gripper_device():
+    """★ ``gripper_device`` 不在 video_quality_gate_config 的源类型白名单里。
+
+    那条白名单漏一个设备类型，卡片就静默失效一次。这里用"有入边"当判据，
+    所以 UMI 工作流能正常触发 —— 这是本项目的主用例。
+    """
+    got = data_quality_target(
+        _graph([("a", "gripper_device"), ("q", "data_quality")], [("a", "q")]), {})
+    assert got is not None and got[1] == ("gripper_device",)
+
+
+def test_target_walks_through_process_nodes():
+    """相机 → 处理节点 → 质检：直接上游是处理节点，要往回找到设备卡片。"""
+    got = data_quality_target(
+        _graph([("a", "mono_camera"), ("p", "rgbd_to_3d_bare_hand"), ("q", "data_quality")],
+               [("a", "p"), ("p", "q")]), {})
+    assert got is not None and got[1] == ("mono_rgb",)
+
+
+def test_target_handles_legacy_slug():
+    """合并前的旧 slug 要能识别（已保存的工作流打开时自动迁移）。"""
+    for legacy in ("ai_quality_review", "data_cleaning"):
+        got = data_quality_target(
+            _graph([("a", "gripper_device"), ("q", legacy)], [("a", "q")]), {})
+        assert got is not None, legacy
+
+
+def test_target_merges_node_configs_over_card():
+    """``node_configs`` 覆盖卡片里的 ``data.config``（与既有的卡片配置读取一致）。"""
+    graph = _graph([("a", "gripper_device"), ("q", "data_quality")], [("a", "q")])
+    graph["nodes"][1]["data"]["config"] = {"devices": {"stale": {}}}
+    cfg, _ = data_quality_target(graph, {"q": {"devices": {"gripper_device": {}}}})
+    assert "gripper_device" in cfg["devices"]
+
+
+# ── ★ 配置是黑名单，不是白名单 ──────────────────────────────
+#
+# 前端设置面板只在用户**碰过**的检查项上写 entry，未触碰的不进 config。
+# 曾把"显式启用的那些"当白名单传进 applicable_checks(enabled=...)，
+# 后果是「在弹窗里改一个阈值 → 其余检查项全部静默停跑」：
+# 实测只配 umi.gripper_range 时 9 项变 1 项，不报任何错。
+#
+# 下面用真实引擎跑一个最小批次（只有 parquet，无视频），断言项数。
+def _minimal_batch(tmp: Path) -> Path:
+    """造一个只有 UMI 标量列的批次 —— 够触发若干检查项，又不依赖 cv2。"""
+    import numpy as np
+    import pandas as pd
+
+    import json
+
+    # 目录层级不能省：find_episode_parquets 只认 data/chunk-*/episode_*.parquet
+    (tmp / "data" / "chunk-000").mkdir(parents=True, exist_ok=True)
+    (tmp / "meta").mkdir(exist_ok=True)
+    (tmp / "meta" / "info.json").write_text(
+        json.dumps({"fps": 30.0}), encoding="utf-8")
+
+    rows = 30
+    pd.DataFrame({
+        # 列名必须与 _COLUMN_CHANNELS 逐字一致 —— 对不上不会有任何报错，
+        # 只是信道识别不出来、检查项静默不跑（正是本文件要盯住的那类 bug）
+        "timestamp": np.arange(rows, dtype=float) / 30.0,
+        "observation.gripper_state": np.linspace(0.0, 1.0, rows),
+        "observation.gripper_left_force": np.linspace(0.0, 5.0, rows),
+        "action": np.tile(np.arange(7, dtype=float), (rows, 1)).tolist(),
+    }).to_parquet(tmp / "data" / "chunk-000" / "episode_000000.parquet")
+    return tmp
+
+
+def _checks_run(config: dict) -> list[str]:
+    with tempfile.TemporaryDirectory() as tmp:
+        batch = _minimal_batch(Path(tmp) / "batch")
+        report = engine.run_checks(batch, episode_id="t", config=config)
+        return sorted(report["modalities"]["checks_run"])
+
+
+def test_config_only_touched_entry_does_not_disable_the_rest():
+    """配了一项阈值 ≠ 只跑这一项。"""
+    baseline = _checks_run({})
+    assert baseline, "夹具没触发任何检查项，测试无意义"
+
+    only_one = _checks_run({"devices": {"gripper_device": {"checks": {
+        "umi.gripper_range": {"enabled": True, "params": {"max_force_drift": 500}},
+    }}}})
+    assert only_one == baseline
+
+
+def test_explicit_disable_still_works():
+    """黑名单那半边必须仍然生效 —— 别把白名单 bug 修成"配置完全无效"。"""
+    baseline = _checks_run({})
+    disabled = _checks_run({"devices": {"gripper_device": {"checks": {
+        "umi.gripper_range": {"enabled": False},
+    }}}})
+    assert "umi.gripper_range" not in disabled
+    assert len(disabled) == len(baseline) - 1
+
+
+if __name__ == "__main__":
+    import pytest
+    raise SystemExit(pytest.main([__file__, "-q"]))
diff --git a/processor/tests/test_cleaning_contract.py b/processor/tests/test_cleaning_contract.py
new file mode 100644
index 0000000000000000000000000000000000000000..68afe60f5369ea62f995e5b4058711d50f9f05fa
--- /dev/null
+++ b/processor/tests/test_cleaning_contract.py
@@ -0,0 +1,318 @@
+"""清洗契约与检查项注册表单测。
+
+覆盖:设备模态与 device_naming 的口径一致性(漂移守卫)、别名映射、
+信道推导、严重度合成、检查项筛选。
+
+    pytest tests/test_cleaning_contract.py
+    python3 tests/test_cleaning_contract.py     # 无 pytest 也能跑
+"""
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from app.device_naming import DEVICE_LABELS  # noqa: E402
+from app.processing.cleaning import contract as C  # noqa: E402
+from app.processing.cleaning import checks as K  # noqa: E402
+
+
+# ── 漂移守卫 ────────────────────────────────────────────────
+def test_device_modalities_match_device_naming():
+    """两个文件声明的设备模态必须逐字一致。
+
+    这是本套设计里唯一靠"人工保持同步"的地方 —— 所以用测试锁死。
+    任何人在 device_naming 加了新设备类型而忘了同步这里，这个测试立刻红。
+    """
+    assert set(C.DEVICE_MODALITIES) == set(DEVICE_LABELS)
+
+
+def test_every_channel_of_every_modality_is_declared():
+    """MODALITY_CHANNELS 用到的信道都必须在 CHANNELS 里声明。"""
+    declared = set(C.CHANNELS)
+    for modality in C.DEVICE_MODALITIES:
+        assert modality in C.MODALITY_CHANNELS, f"{modality} 没声明信道"
+        unknown = set(C.MODALITY_CHANNELS[modality]) - declared
+        assert not unknown, f"{modality} 用了未声明的信道: {unknown}"
+
+
+def test_aliases_map_into_canonical_set():
+    """别名表的值必须是合法的设备模态。"""
+    for alias, target in C._ALIASES.items():
+        assert target in C.DEVICE_MODALITIES, f"{alias} → {target} 不是合法模态"
+
+
+# ── 别名映射 ────────────────────────────────────────────────
+def test_normalize_accepts_canonical_and_alias():
+    # canonical 值原样返回
+    assert C.normalize_device_modality("mono_rgb") == "mono_rgb"
+    assert C.normalize_device_modality("gripper_device") == "gripper_device"
+    # api/projects 与处理模块 slug 用的 camera 后缀写法
+    assert C.normalize_device_modality("mono_camera") == "mono_rgb"
+    assert C.normalize_device_modality("stereo_camera") == "stereo_rgb"
+    # 历史节点类型
+    assert C.normalize_device_modality("fisheye_camera") == "mono_rgb"
+
+
+def test_normalize_rejects_unknown_without_raising():
+    """认不出来要返回 None 而不是抛异常 —— 调用方据此跳过。"""
+    assert C.normalize_device_modality("") is None
+    assert C.normalize_device_modality(None) is None
+    assert C.normalize_device_modality("some_future_sensor") is None
+
+
+def test_normalize_accepts_whitespace():
+    assert C.normalize_device_modality("  mono_rgb  ") == "mono_rgb"
+
+
+# ── 信道推导 ────────────────────────────────────────────────
+def test_channels_for_unions_and_dedupes():
+    channels = C.channels_for(["gripper_device", "mono_rgb"])
+    assert channels[0] == "rgb"          # 保序:gripper_device 先出现
+    assert "time" in channels
+    assert len(channels) == len(set(channels)), "有重复信道"
+
+
+def test_channels_for_unknown_modality_is_empty():
+    assert C.channels_for(["not_a_modality"]) == ()
+    assert C.channels_for([]) == ()
+
+
+# ── 严重度 ──────────────────────────────────────────────────
+def test_worst_picks_most_severe():
+    assert C.worst([C.PASS, C.WARN]) == C.WARN
+    assert C.worst([C.WARN, C.FAIL]) == C.FAIL
+    assert C.worst([C.FAIL, C.ERROR]) == C.ERROR
+    assert C.worst([C.ERROR, C.PENDING, C.WARN]) == C.ERROR
+
+
+def test_worst_of_empty_is_pass():
+    assert C.worst([]) == C.PASS
+
+
+def test_worst_ignores_unknown_status_names():
+    """未知状态名按"最轻"处理,不崩溃 —— 新旧报告混读时不炸。"""
+    assert C.worst([C.PASS, "some_new_status"]) == C.PASS
+
+
+def test_is_blocking_only_for_fail_and_error():
+    assert C.is_blocking(C.FAIL) is True
+    assert C.is_blocking(C.ERROR) is True
+    assert C.is_blocking(C.WARN) is False
+    assert C.is_blocking(C.PENDING) is False
+    assert C.is_blocking(C.PASS) is False
+
+
+# ── 检查项筛选 ──────────────────────────────────────────────
+class _FakeVideoCheck(K.CleaningCheck):
+    slug = "_test.video"
+    label = "fake video"
+    requires_channels = ("rgb",)
+    # 多张卡片共享 —— video.* 就是这样，只要命中其一就跑
+    device_cards = ("mono_rgb", "stereo_rgb", "rgbd_camera", "gripper_device")
+
+
+class _FakeUmiCheck(K.CleaningCheck):
+    slug = "_test.umi"
+    label = "fake umi"
+    requires_channels = ("slam",)
+    requires_modality = ("gripper_device",)
+    device_cards = ("gripper_device",)
+
+
+class _FakeCrossCheck(K.CleaningCheck):
+    slug = "_test.cross"
+    label = "fake cross"
+    cross_modal = True
+
+
+def _with_checks(*classes, fn):
+    """临时注册一批检查项,跑完清理 —— 不污染全局注册表。"""
+    registered = []
+    try:
+        for cls in classes:
+            K._registry[cls.slug] = cls()
+            registered.append(cls.slug)
+        return fn()
+    finally:
+        for slug in registered:
+            K._registry.pop(slug, None)
+
+
+def test_applicable_filters_by_channel():
+    def run():
+        got = {c.slug for c in K.applicable_checks({"rgb"}, {"mono_rgb"})}
+        assert "_test.video" in got
+        assert "_test.umi" not in got          # 缺 slam 信道
+    _with_checks(_FakeVideoCheck, _FakeUmiCheck, fn=run)
+
+
+def test_applicable_filters_by_modality():
+    def run():
+        # 有 slam 信道但设备不是 gripper_device → umi 检查不跑
+        got = {c.slug for c in K.applicable_checks({"slam"}, {"mono_rgb"})}
+        assert "_test.umi" not in got
+        got = {c.slug for c in K.applicable_checks({"slam"}, {"gripper_device"})}
+        assert "_test.umi" in got
+    _with_checks(_FakeUmiCheck, fn=run)
+
+
+def test_applicable_filters_by_device_cards():
+    """设备卡片闸门 —— 光按信道筛不够。
+
+    真实踩过的坑：手套项目（rgbd_camera）的批次里同样有一列 ``action``
+    （采集端写的全零占位），于是 ``umi.action_present`` 满足
+    ``requires_channels=("action",)`` 就跑了起来，给手套项目报了个
+    "action 全零"的失败 —— 而对方根本不训练动作。
+
+    声明了 device_cards 的检查项，必须只在该设备上跑。
+    """
+    def run():
+        channels = {"action", "slam"}   # 信道全够，只剩设备这一关
+        # 设备是手套相机 → UMI 检查不跑，尽管信道满足了
+        got = {c.slug for c in K.applicable_checks(channels, {"rgbd_camera"})}
+        assert "_test.umi" not in got
+        # 设备是 UMI 夹爪 → 跑
+        got = {c.slug for c in K.applicable_checks(channels, {"gripper_device"})}
+        assert "_test.umi" in got
+    _with_checks(_FakeUmiCheck, fn=run)
+
+
+def test_device_cards_gate_is_skipped_for_shared_checks():
+    """声明了多张卡片的检查项，只要命中其一就跑（video.* 就是这种）。"""
+    def run():
+        got = {c.slug for c in K.applicable_checks({"rgb"}, {"stereo_rgb"})}
+        assert "_test.video" in got
+    _with_checks(_FakeVideoCheck, fn=run)
+
+
+def test_cross_modal_requires_two_modalities():
+    def run():
+        # 单模态 → 跨模态检查不跑
+        got = {c.slug for c in K.applicable_checks(set(), {"mono_rgb"})}
+        assert "_test.cross" not in got
+        # 显式声明跨模态成立 → 跑
+        got = {c.slug for c in K.applicable_checks(
+            set(), {"mono_rgb", "glove_sensor"}, cross_modal_active=True)}
+        assert "_test.cross" in got
+    _with_checks(_FakeCrossCheck, fn=run)
+
+
+def test_applicable_respects_enabled_and_disabled():
+    def run():
+        got = {c.slug for c in K.applicable_checks(
+            {"rgb"}, {"mono_rgb"}, disabled={"_test.video"})}
+        assert "_test.video" not in got
+        got = {c.slug for c in K.applicable_checks(
+            {"rgb"}, {"mono_rgb"}, enabled={"_test.video"})}
+        assert got == {"_test.video"}
+    _with_checks(_FakeVideoCheck, fn=run)
+
+
+def test_all_checks_is_sorted_by_slug():
+    """排序稳定 —— ruleset_revision 是对它取哈希,顺序变了指纹就变。"""
+    slugs = [c.slug for c in K.all_checks()]
+    assert slugs == sorted(slugs)
+
+
+def test_register_rejects_duplicate_slug():
+    class First(K.CleaningCheck):
+        slug = "_test.dupe"
+
+    class Second(K.CleaningCheck):
+        slug = "_test.dupe"
+
+    try:
+        K.register_check(First)
+        try:
+            K.register_check(Second)
+        except ValueError as exc:
+            assert "_test.dupe" in str(exc)
+        else:
+            raise AssertionError("重复 slug 应当抛 ValueError")
+    finally:
+        K._registry.pop("_test.dupe", None)
+
+
+def test_register_rejects_empty_slug():
+    class NoSlug(K.CleaningCheck):
+        slug = ""
+
+    try:
+        K.register_check(NoSlug)
+    except ValueError:
+        pass
+    else:
+        raise AssertionError("空 slug 应当抛 ValueError")
+
+
+# ── 设备卡片分组（设置面板的 tab）────────────────────────────
+def test_every_check_declares_device_cards():
+    """除跨设备检查外，每项都必须声明属于哪些设备卡片。
+
+    否则它在设置面板里【无处可去】—— 用户看不到、也改不了它的阈值。
+    跨设备检查（cross_modal=True）约定不绑单卡片，只在"跨设备" tab 出现。
+    """
+    for check in K.all_checks():
+        if check.cross_modal:
+            continue
+        assert check.device_cards, f"{check.slug} 没有声明 device_cards"
+
+
+def test_device_cards_are_known_modalities():
+    """device_cards 的取值必须来自 contract 的设备模态表 —— 防止拼错字符串。
+
+    拼错不会报错，只会让检查项在面板上凭空消失，很难发现。
+    """
+    known = set(C.DEVICE_MODALITIES)
+    for check in K.all_checks():
+        for card in check.device_cards:
+            assert card in known, f"{check.slug} 声明了未知设备卡片 {card!r}"
+
+
+def test_checks_for_device_cards_only_returns_requested():
+    """未连接的设备不该出现在分组结果里。"""
+    grouped = K.checks_for_device_cards(["gripper_device"])
+    assert set(grouped) == {"gripper_device"}
+    assert all(c.device_cards.count("gripper_device") for c in grouped["gripper_device"])
+
+
+def test_checks_for_device_cards_places_multi_card_checks():
+    """一个检查项可以同时属于多张卡片（video.* 对每种带摄像头的设备都成立）。"""
+    grouped = K.checks_for_device_cards(["rgbd_camera", "gripper_device"])
+    in_a = {c.slug for c in grouped["rgbd_camera"]}
+    in_b = {c.slug for c in grouped["gripper_device"]}
+    assert "video.frame_drop" in in_a and "video.frame_drop" in in_b
+    # UMI 专有的只出现在 gripper_device 下
+    assert "umi.slam_continuity" in in_b and "umi.slam_continuity" not in in_a
+
+
+def test_video_checks_cover_gripper_device():
+    """UMI 夹爪自带鱼眼相机，视频检查对它同样成立。
+
+    历史坑：video.* 早期只声明了四种摄像机模态，漏了 gripper_device ——
+    结果 UMI 项目的设置面板里视频检查整组消失。
+    """
+    grouped = K.checks_for_device_cards(["gripper_device"])
+    slugs = {c.slug for c in grouped["gripper_device"]}
+    assert {"video.frame_drop", "video.black_screen",
+            "video.freeze", "video.decode_error"} <= slugs
+
+
+if __name__ == "__main__":
+    _failures = 0
+    for _name, _fn in sorted(globals().items()):
+        if not _name.startswith("test_") or not callable(_fn):
+            continue
+        import inspect
+        try:
+            if "tmp_path" in inspect.signature(_fn).parameters:
+                import tempfile
+                with tempfile.TemporaryDirectory() as _tmp:
+                    _fn(Path(_tmp))
+            else:
+                _fn()
+            print(f"PASS {_name}")
+        except Exception as _exc:  # noqa: BLE001
+            _failures += 1
+            print(f"FAIL {_name}: {_exc}")
+    raise SystemExit(1 if _failures else 0)
diff --git a/processor/tests/test_cleaning_frame_alignment.py b/processor/tests/test_cleaning_frame_alignment.py
new file mode 100644
index 0000000000000000000000000000000000000000..2596643cd7463c80e123e374e7f51244782dcffd
--- /dev/null
+++ b/processor/tests/test_cleaning_frame_alignment.py
@@ -0,0 +1,125 @@
+"""帧对齐检查的回归测试(app/cleaning.py)。
+
+背景:2026-09-23 之前 ``_check_frame_alignment_fs`` 直接用了 ``cv2`` 却没 import,
+``NameError`` 被外层 ``except`` 吞掉 → 该检查在文件级路径下**永远静默通过**,
+detail 写着 "Check error (skipped)" 而 passed=True,没人会注意。
+
+本文件锁住三件事:
+  1. 检查真的跑了(不再返回 Check error / Degraded pass)
+  2. 没有视频时不误报 —— 纯传感器批次(如纯手套)是合法的,判"未适用"
+  3. 帧数真的不匹配时能抓出来
+
+    pytest tests/test_cleaning_frame_alignment.py
+    python3 tests/test_cleaning_frame_alignment.py
+"""
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+import numpy as np  # noqa: E402
+import pandas as pd  # noqa: E402
+
+from app.cleaning import _check_frame_alignment_fs  # noqa: E402
+
+CHECK = "frame_alignment"
+
+
+def _write_parquet(batch: Path, frames: int) -> None:
+    """写一个带 frame_index 列的 data parquet(检查按 rglob('data') 找)。"""
+    data_dir = batch / "data" / "chunk-000"
+    data_dir.mkdir(parents=True, exist_ok=True)
+    pd.DataFrame({"frame_index": range(frames)}).to_parquet(
+        data_dir / "episode_000000.parquet")
+
+
+def _write_video(batch: Path, frames: int, name: str = "cam.mp4") -> None:
+    """写一个真 mp4,帧数可控。"""
+    import cv2
+    path = batch / name
+    path.parent.mkdir(parents=True, exist_ok=True)
+    writer = cv2.VideoWriter(str(path), cv2.VideoWriter_fourcc(*"mp4v"), 30, (64, 48))
+    try:
+        for index in range(frames):
+            writer.write(np.full((48, 64, 3), index % 256, dtype=np.uint8))
+    finally:
+        writer.release()
+
+
+# ── 不再静默通过 ────────────────────────────────────────────
+def test_check_actually_runs_without_video(tmp_path):
+    """没有视频时必须给出明确结论,而不是被异常吞掉的伪通过。"""
+    _write_parquet(tmp_path, 100)
+    result = _check_frame_alignment_fs(tmp_path)
+    assert result["name"] == CHECK
+    # 修复前的症状:detail 里写 "Check error (skipped)"
+    assert "Check error" not in result["detail"]
+    assert "Degraded pass" not in result["detail"]
+
+
+def test_no_video_is_not_a_failure(tmp_path):
+    """纯传感器批次(只有手套、没有相机)是合法的 —— 没有可比对的对象。"""
+    _write_parquet(tmp_path, 100)
+    result = _check_frame_alignment_fs(tmp_path)
+    assert result["passed"] is True
+    assert "No video" in result["detail"]
+
+
+def test_no_parquet_is_skipped(tmp_path):
+    result = _check_frame_alignment_fs(tmp_path)
+    assert result["passed"] is True
+    assert "No parquet" in result["detail"]
+
+
+# ── 真的能抓出不匹配 ────────────────────────────────────────
+def test_matching_counts_pass(tmp_path):
+    _write_parquet(tmp_path, 50)
+    _write_video(tmp_path, 50)
+    result = _check_frame_alignment_fs(tmp_path)
+    assert result["passed"] is True, result["detail"]
+
+
+def test_short_video_fails(tmp_path):
+    """视频只有 10 帧、数据有 100 帧 → 必须判失败(容差 10%)。"""
+    _write_parquet(tmp_path, 100)
+    _write_video(tmp_path, 10)
+    result = _check_frame_alignment_fs(tmp_path)
+    assert result["passed"] is False, result["detail"]
+
+
+def test_within_tolerance_passes(tmp_path):
+    """差 5% 在 ±10% 容差内 → 通过。"""
+    _write_parquet(tmp_path, 100)
+    _write_video(tmp_path, 95)
+    result = _check_frame_alignment_fs(tmp_path)
+    assert result["passed"] is True, result["detail"]
+
+
+def test_result_shape_is_stable(tmp_path):
+    """返回结构必须与本模块另外两个检查一致(前端按 name/passed/detail 读)。"""
+    _write_parquet(tmp_path, 30)
+    _write_video(tmp_path, 30)
+    result = _check_frame_alignment_fs(tmp_path)
+    assert set(result) == {"name", "passed", "detail"}
+    assert isinstance(result["passed"], bool)
+
+
+if __name__ == "__main__":
+    import inspect
+    import tempfile
+
+    failures = 0
+    for name, fn in sorted(globals().items()):
+        if not name.startswith("test_") or not callable(fn):
+            continue
+        try:
+            if "tmp_path" in inspect.signature(fn).parameters:
+                with tempfile.TemporaryDirectory() as tmp:
+                    fn(Path(tmp))
+            else:
+                fn()
+            print(f"PASS {name}")
+        except Exception as exc:  # noqa: BLE001
+            failures += 1
+            print(f"FAIL {name}: {exc}")
+    raise SystemExit(1 if failures else 0)
diff --git a/processor/tests/test_cleaning_gate.py b/processor/tests/test_cleaning_gate.py
new file mode 100644
index 0000000000000000000000000000000000000000..26374e53813e4c6b2833fc0d129f3aba33c18c8e
--- /dev/null
+++ b/processor/tests/test_cleaning_gate.py
@@ -0,0 +1,183 @@
+"""「数据不对 → 卡在人工审核」的行为锁。
+
+盯住三件事，每一件坏掉都是**静默**的（不报错、流程照常走完）：
+
+  1. 判 FAIL/ERROR 的批次被推回 ``to_review``，且清掉 ``approved_at``
+  2. WARN 只记录、不拦 —— 否则警告阈值一响，整批数据全卡住
+  3. **自动批准路径主动让路** —— AI 标注 / 视频门禁各看各的报告，不看质检
+     结论；不查那个粘性标记的话，它们会在质检推回 to_review 之后又把状态
+     置成 reviewed，坏数据照样被放行
+
+全部在临时存储根上跑（monkeypatch ``localstore`` 的路径常量），不碰真实数据。
+
+    pytest tests/test_cleaning_gate.py
+    python3 tests/test_cleaning_gate.py
+"""
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))  # noqa: E402
+
+import pytest  # noqa: E402
+
+from app import localstore  # noqa: E402
+from app.processing.cleaning import store  # noqa: E402
+from app.processing.cleaning import contract as C  # noqa: E402
+
+
+@pytest.fixture
+def sandbox(tmp_path, monkeypatch):
+    """把 episode state 落到临时目录 —— 别碰 ~/.cache/egodata-data。"""
+    states = tmp_path / "state" / "episode_states"
+    states.mkdir(parents=True, exist_ok=True)
+    monkeypatch.setattr(localstore, "STATE_ROOT", tmp_path / "state")
+    monkeypatch.setattr(localstore, "EPISODE_STATES_DIR", states)
+    localstore._episode_state_cache.clear()
+    yield states
+    localstore._episode_state_cache.clear()
+
+
+def _report(status, *, ranges=0):
+    """造一份最小报告 —— 只关心 ``episode.status``，那是拦截判据。"""
+    return {
+        "schema_version": 2,
+        "episode_id": "E1",
+        "computed_at": "2026-09-24T00:00:00+00:00",
+        "passed": status == C.PASS,
+        "streams": [],
+        "ranges": [{}] * ranges,
+        "episode": {
+            "status": status,
+            "status_label": C.SEVERITY_LABELS.get(status, status),
+            "failed_streams": [], "warn_streams": [], "pending_streams": [],
+            "summary": "test",
+        },
+        "findings": [],
+    }
+
+
+def _seed(states, status="to_review", approved_at=None):
+    import json
+    eid = "E1"
+    (states / f"{eid}.json").write_text(json.dumps({
+        "id": eid, "name": eid, "project": "P", "status": status,
+        "approved_at": approved_at,
+    }, ensure_ascii=False), encoding="utf-8")
+    localstore._episode_state_cache.pop(eid, None)
+    return eid
+
+
+# ── 拦截 ────────────────────────────────────────────────────
+@pytest.mark.parametrize("status", [C.FAIL, C.ERROR])
+def test_failure_pushes_back_to_review(sandbox, status):
+    eid = _seed(sandbox, status="reviewed", approved_at="2026-01-01T00:00:00Z")
+    assert store.save_report(eid, _report(status)) is True
+
+    state = localstore.read_episode_state(eid)
+    assert state["status"] == "to_review"          # 自动批准被撤销
+    assert state["approved_at"] is None            # 批准时间一起清掉
+    assert store.is_approval_blocked(state) is True
+
+
+@pytest.mark.parametrize("status", [C.WARN, C.PASS, C.PENDING])
+def test_non_failure_does_not_block(sandbox, status):
+    """WARN/PENDING 只是警告 —— 拦的话整批数据都会卡住。"""
+    eid = _seed(sandbox, status="reviewed")
+    store.save_report(eid, _report(status))
+
+    state = localstore.read_episode_state(eid)
+    assert state["status"] == "reviewed"           # 状态没被动过
+    assert store.is_approval_blocked(state) is False
+
+
+def test_does_not_resurrect_deleted_episode(sandbox):
+    """质检不能把用户删掉/否决过的批次复活。"""
+    for status in ("deleted", "rejected"):
+        eid = _seed(sandbox, status=status)
+        store.save_report(eid, _report(C.FAIL))
+        assert localstore.read_episode_state(eid)["status"] == status
+
+
+def test_report_still_written_when_not_blocking(sandbox):
+    """不拦也得把报告写进去 —— 拦截不是写报告的前提。"""
+    eid = _seed(sandbox)
+    store.save_report(eid, _report(C.WARN, ranges=3))
+    summary = store.load_summary(eid)
+    assert summary["status"] == C.WARN and summary["ranges"] == 3
+
+
+# ── 自动批准让路 ────────────────────────────────────────────
+def _quality_gate(state):
+    """转调 ai_annotation 的真实写入路径，避免测试复制一份逻辑。"""
+    from app.ai_annotation import _set_ai_quality_state
+    return _set_ai_quality_state
+
+
+def test_ai_gate_refuses_to_auto_approve_when_blocked(sandbox):
+    """★ 核心用例：质检判 FAIL 后，AI 标注门禁即使自己通过也不得自动批准。"""
+    eid = _seed(sandbox, status="to_review")
+    store.save_report(eid, _report(C.FAIL))
+
+    _quality_gate(None)(eid, {"passed": True}, auto_approve=True)
+
+    state = localstore.read_episode_state(eid)
+    assert state["status"] == "to_review", "坏数据被 AI 门禁放行了"
+    assert state["ai_quality_status"] == "passed"   # 它自己的结论照常记录
+
+
+def test_ai_gate_still_auto_approves_when_not_blocked(sandbox):
+    """别把拦截修成"自动批准彻底失效" —— 干净数据该自动过。"""
+    eid = _seed(sandbox, status="to_review")
+    store.save_report(eid, _report(C.PASS))
+
+    _quality_gate(None)(eid, {"passed": True}, auto_approve=True)
+
+    assert localstore.read_episode_state(eid)["status"] == "reviewed"
+
+
+def test_video_gate_refuses_to_auto_approve_when_blocked(sandbox):
+    """视频干净 ≠ 数据干净 —— 视频门禁同样要让路。"""
+    from app.video_quality import _apply_video_quality_result
+
+    eid = _seed(sandbox, status="to_review")
+    store.save_report(eid, _report(C.FAIL))
+
+    _apply_video_quality_result(eid, {"passed": True})
+
+    state = localstore.read_episode_state(eid)
+    assert state["status"] == "to_review", "坏数据被视频门禁放行了"
+    assert state["video_quality_status"] == "passed"
+
+
+# ── 标记的粘性 ──────────────────────────────────────────────
+def test_block_clears_once_data_is_fixed(sandbox):
+    """数据修好后重跑要能自动批准 —— 否则卡住就再也出不来了。
+
+    注意 ``save_report`` **只拦不批**：它解封后不会自己把状态改回 reviewed，
+    批准是 AI/视频门禁或人工的事。所以这里走一遍真实的"修好 → 重跑"顺序：
+    worker 先置 to_review，质检复核（清除标记），随后门禁自动批准。
+    """
+    eid = _seed(sandbox, status="to_review")
+
+    store.save_report(eid, _report(C.FAIL))
+    assert store.is_approval_blocked(localstore.read_episode_state(eid)) is True
+
+    # —— 重跑 ——
+    localstore.set_episode_status(eid, "to_review")   # worker 完成回调做的
+    store.save_report(eid, _report(C.PASS))           # 质检复核：数据已修好
+    state = localstore.read_episode_state(eid)
+    assert store.is_approval_blocked(state) is False
+
+    _quality_gate(None)(eid, {"passed": True}, auto_approve=True)
+    assert localstore.read_episode_state(eid)["status"] == "reviewed"
+
+
+def test_save_report_never_approves(sandbox):
+    """质检**只拦不批** —— 它不该越过门禁自己把批次标成通过。"""
+    eid = _seed(sandbox, status="to_review")
+    store.save_report(eid, _report(C.PASS))
+    assert localstore.read_episode_state(eid)["status"] == "to_review"
+
+
+if __name__ == "__main__":
+    raise SystemExit(pytest.main([__file__, "-q"]))
diff --git a/processor/tests/test_cleaning_glove.py b/processor/tests/test_cleaning_glove.py
new file mode 100644
index 0000000000000000000000000000000000000000..d9d89d1f2ed06b9276a8a714cb7e22a5260df10a
--- /dev/null
+++ b/processor/tests/test_cleaning_glove.py
@@ -0,0 +1,202 @@
+"""手套检查项 —— 每一项都必须**被证明能抓到失败**。
+
+真实数据上 5 项全绿（6 集、左右手各 5-6 条流、零误报）。但"全绿"证明不了什么：
+**检查项从来没触发过，和检查项根本跑不起来，报告长得一模一样。** 所以这里每条
+都构造一份明确的坏数据，断言它被抓到；再造一份好数据，断言不误报。
+
+阈值全部来自实测：
+  * 阵列 16×16 = 256 维
+  * 取值门限 500（0 到 500 之间没有值）
+  * 设备更新 ~7.5Hz → 受压时静止**恰好 4 帧**（正常，不是卡死）
+  * 整集最低有 11.4% 的帧有压力
+
+    pytest tests/test_cleaning_glove.py
+    python3 tests/test_cleaning_glove.py
+"""
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))  # noqa: E402
+
+from app.processing.cleaning.checks import (  # noqa: E402
+    CheckContext, StreamEvidence, applicable_checks, get_check,
+    PASS, WARN, FAIL,
+)
+
+SIZE = 256
+
+
+# ── 构造 ────────────────────────────────────────────────────
+def _frame(value: float = 0.0, size: int = SIZE) -> tuple:
+    return tuple([value] * size)
+
+
+def _context(series: dict, *, channel="tactile", key="left_glove",
+             fps=30.0) -> CheckContext:
+    stream = StreamEvidence(key=key, channel=channel, series=series)
+    return CheckContext(batch_dir=Path("/nonexistent"), fps=fps, streams=(stream,))
+
+
+def _run(slug: str, ctx: CheckContext, params: dict | None = None):
+    ctx.params = params or {}
+    findings = get_check(slug).run(ctx)
+    assert findings, f"{slug} 一条结论都没产出 —— 报告会显示为『没问题』"
+    return findings
+
+
+def _only(slug, ctx, params=None):
+    findings = _run(slug, ctx, params)
+    statuses = {f.status for f in findings}
+    assert len(statuses) == 1, f"期望单一结论，得到 {statuses}"
+    return findings[0]
+
+
+# ── 可达性：检查项必须真的会被选中 ───────────────────────────
+def test_glove_checks_are_applicable():
+    """★ 防"检查项静默不跑"—— 声明与闸门对不上时它们一条都不会执行。"""
+    slugs = {c.slug for c in applicable_checks(
+        channels={"tactile", "device_status", "time"},
+        modalities={"glove_sensor"})}
+    for expected in ("glove.array_shape", "glove.device_status",
+                     "glove.frozen_array", "glove.gate_floor",
+                     "glove.no_contact"):
+        assert expected in slugs, f"{expected} 在手套数据上不可达"
+
+
+def test_glove_checks_skip_other_devices():
+    """UMI 夹爪上不该跑手套检查 —— 设备卡片闸门要生效。"""
+    slugs = {c.slug for c in applicable_checks(
+        channels={"tactile", "slam", "time"}, modalities={"gripper_device"})}
+    assert not any(s.startswith("glove.") for s in slugs)
+
+
+def test_device_status_check_needs_its_channel():
+    """没有状态列（老批次）时不该跑 —— 跑起来只会报"没数据"。"""
+    slugs = {c.slug for c in applicable_checks(
+        channels={"tactile", "time"}, modalities={"glove_sensor"})}
+    assert "glove.device_status" not in slugs
+    assert "glove.frozen_array" in slugs
+
+
+# ── 1. 连接状态 ─────────────────────────────────────────────
+def test_status_constant_connected_passes():
+    ctx = _context({"device_status": tuple(["connected"] * 100)}, channel="device_status")
+    assert _only("glove.device_status", ctx).status is PASS
+
+
+def test_status_change_mid_recording_fails():
+    """★ 从"连着"变成别的 = 掉线，与状态词表无关，见到即拦。"""
+    values = tuple(["connected"] * 50 + ["disconnected"] * 50)
+    ctx = _context({"device_status": values}, channel="device_status")
+    finding = _only("glove.device_status", ctx)
+    assert finding.status is FAIL
+    assert finding.metrics["first_change_frame"] == 50
+
+
+def test_status_unknown_constant_only_warns():
+    """词表只见过 connected；别的取值不拦批次（拦错了比不拦更糟）。"""
+    ctx = _context({"device_status": tuple(["ok"] * 100)}, channel="device_status")
+    assert _only("glove.device_status", ctx).status is WARN
+
+
+def test_status_all_blank_warns():
+    ctx = _context({"device_status": tuple([""] * 100)}, channel="device_status")
+    assert _only("glove.device_status", ctx).status is WARN
+
+
+# ── 2. 阵列完整性 ───────────────────────────────────────────
+def test_shape_full_array_passes():
+    ctx = _context({"tactile": tuple([_frame()] * 50)})
+    assert _only("glove.array_shape", ctx).status is PASS
+
+
+def test_shape_catches_truncation():
+    """★ 正是那个真实踩过的 bug：256 维被静默截成 3 维。"""
+    ctx = _context({"tactile": tuple([_frame(size=3)] * 500)})
+    finding = _only("glove.array_shape", ctx)
+    assert finding.status is FAIL
+    assert finding.metrics["bad_ratio"] == 1.0
+    assert finding.metrics["observed_sizes"] == [3]
+
+
+def test_shape_single_null_frame_only_warns():
+    """偶发一帧缺失不该拦住整批。"""
+    values = [_frame(600.0)] * 999 + [()]
+    ctx = _context({"tactile": tuple(values)})
+    assert _only("glove.array_shape", ctx).status is WARN
+
+
+# ── 3. 取值下限 ─────────────────────────────────────────────
+def test_gate_floor_normal_values_pass():
+    ctx = _context({"tactile": (_frame(0.0), _frame(508.09), _frame(1500.0))})
+    assert _only("glove.gate_floor", ctx).status is PASS
+
+
+def test_gate_floor_catches_encoding_change():
+    """★ 固件改成直接输出原始 ADC 时，值会掉到门限以下 —— 而别的检查全绿。"""
+    values = [_frame(v) for v in (5.0, 20.0, 137.0, 400.0)] + [_frame(900.0)]
+    ctx = _context({"tactile": tuple(values)})
+    finding = _only("glove.gate_floor", ctx)
+    assert finding.status is FAIL
+    assert finding.metrics["below_ratio"] == 0.8
+
+
+def test_gate_floor_all_zero_is_not_its_business():
+    """整集全零是 glove.no_contact 的事，不在这里重复报。"""
+    findings = get_check("glove.gate_floor").run(_context({"tactile": (_frame(),)}))
+    assert findings == []
+
+
+# ── 4. 阵列卡死 ─────────────────────────────────────────────
+def test_frozen_normal_device_rate_passes():
+    """★ 设备本来就每 4 帧才更新一次 —— 静止 4 帧是**正常**，不是卡死。"""
+    values = []
+    for block in range(100):
+        values.extend([_frame(600.0 + block)] * 4)
+    ctx = _context({"tactile": tuple(values)})
+    assert _only("glove.frozen_array", ctx).status is PASS
+
+
+def test_frozen_detects_stall():
+    values = [_frame(600.0)] * 500 + [_frame(900.0)] * 10
+    ctx = _context({"tactile": tuple(values)})
+    finding = _only("glove.frozen_array", ctx)
+    assert finding.status is FAIL                      # 500 帧 ≥ fail_frames(300)
+    assert finding.metrics["longest_run_frames"] == 500
+    # 区间要能定位到哪儿卡了
+    assert finding.ranges and finding.ranges[0].start_frame == 0
+
+
+def test_frozen_ignores_all_zero_stretches():
+    """★ 实测踩过的坑：全零段天然"完全相同"，算进去会报出大片假区间。
+
+    真实数据里一集有 88% 的帧全零，最长"静止"575 帧 —— 全部来自全零段。
+    """
+    values = [_frame(0.0)] * 800 + [_frame(600.0)] * 10
+    ctx = _context({"tactile": tuple(values)})
+    assert _only("glove.frozen_array", ctx).status is PASS
+
+
+def test_frozen_warn_threshold_between_normal_and_stall():
+    """40~300 帧是警告区（正常 4 帧，卡死 300+）。"""
+    values = [_frame(600.0)] * 100 + [_frame(700.0)] * 10
+    ctx = _context({"tactile": tuple(values)})
+    assert _only("glove.frozen_array", ctx).status is WARN
+
+
+# ── 5. 无接触 ───────────────────────────────────────────────
+def test_no_contact_with_pressure_passes():
+    ctx = _context({"tactile": (_frame(0.0), _frame(620.0))})
+    assert _only("glove.no_contact", ctx).status is PASS
+
+
+def test_no_contact_all_zero_warns():
+    ctx = _context({"tactile": tuple([_frame(0.0)] * 500)})
+    finding = _only("glove.no_contact", ctx)
+    assert finding.status is WARN
+    assert finding.metrics["active_frames"] == 0
+
+
+if __name__ == "__main__":
+    import pytest
+    raise SystemExit(pytest.main([__file__, "-q"]))
diff --git a/processor/tests/test_cleaning_pose_validity.py b/processor/tests/test_cleaning_pose_validity.py
new file mode 100644
index 0000000000000000000000000000000000000000..0199f25ab8455fdfa6d5c482e88c22bc3144d9ee
--- /dev/null
+++ b/processor/tests/test_cleaning_pose_validity.py
@@ -0,0 +1,126 @@
+"""全零占位位姿 —— 一个把整集假判成 FAIL 的 bug 的回归锁。
+
+bug 长什么样
+------------
+``observation.slam_pose`` 里没采到的帧写的是**全零占位** ``(0,0,0,0,0,0,0)``。
+它长得完全像合法位姿：长度 7、能索引、能相减。但它的四元数模是 0，于是
+
+    两个零四元数的点积 = 0
+    acos(0) = π/2  →  夹角 = 2 × π/2 = **π = 180°**
+    30fps 下角速度 = π × 30 = **94.248 rad/s**
+
+**任何涉及零占位的相邻对都会报一次"180° 跳变"** —— 不只是"真实↔零"的过渡，
+两个零之间也一样。
+
+实测 Test94 的 slam_pose 有 437/599 行是全零，SLAM 连续性因此报出 **465 处**
+"跳变"（599 帧里几乎每一帧），整集被判 FAIL → **拦回人工审核**。而峰值角速度
+94.248 就是上面那个 π×30，是识别这个 bug 的指纹。
+
+    pytest tests/test_cleaning_pose_validity.py
+    python3 tests/test_cleaning_pose_validity.py
+"""
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))  # noqa: E402
+
+from app.processing.cleaning import collect  # noqa: E402
+from app.processing.cleaning.checks import (  # noqa: E402
+    CheckContext, StreamEvidence, get_check, PASS, WARN, FAIL,
+)
+from app.processing.cleaning.contract import pose_is_valid  # noqa: E402
+
+# π × 30fps —— 零四元数产生的"每帧 180°"角速度
+ZERO_QUAT_RPS = 94.248
+
+# 一个模不为 0 的合法朝向
+VALID = (0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0)
+ZERO = (0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0)
+
+
+def _context(poses, fps=30.0):
+    stream = StreamEvidence(key="slam_pose", channel="slam", fps=fps,
+                            series={"pose": tuple(poses)})
+    return CheckContext(batch_dir=Path("/nonexistent"), fps=fps, streams=(stream,))
+
+
+def _continuity(poses, fps=30.0):
+    ctx = _context(poses, fps)
+    ctx.params = {}
+    findings = get_check("umi.slam_continuity").run(ctx)
+    assert findings, "一条结论都没产出"
+    return findings[0]
+
+
+# ── 判据本身 ────────────────────────────────────────────────
+def test_zero_quaternion_is_invalid():
+    assert pose_is_valid(VALID) is True
+    assert pose_is_valid(ZERO) is False          # ← 核心
+    assert pose_is_valid(()) is False            # 空元组本来就不算
+    assert pose_is_valid((1.0, 2.0, 3.0)) is False
+
+
+def test_zero_position_is_still_a_valid_pose():
+    """位置可以合法地是原点；只有四元数模为 0 才不是合法朝向。"""
+    assert pose_is_valid((0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0)) is True
+
+
+# ── 核心回归 ────────────────────────────────────────────────
+def test_zero_placeholders_do_not_create_jumps():
+    """★ 全是零占位的一集不该报任何跳变。"""
+    finding = _continuity([ZERO] * 500)
+    assert finding.status is PASS, f"零占位被当成了跳变：{finding.message}"
+    assert finding.metrics["jumps"] == 0
+
+
+def test_mixed_valid_and_zero_placeholders_do_not_create_jumps():
+    """★ 真实↔零占位的过渡同样不该报 —— 这正是 Test94 的情况。"""
+    poses = []
+    for index in range(200):
+        poses.append(VALID if index % 3 == 0 else ZERO)
+    finding = _continuity(poses)
+    assert finding.status is PASS, f"混合占位报出 {finding.metrics['jumps']} 处跳变"
+    assert finding.metrics["jumps"] == 0
+
+
+def test_zero_placeholder_would_have_produced_the_94_rps_signature():
+    """把守卫去掉，峰值角速度应当落回 94.248 —— 确认这确实是那个 bug。"""
+    finding = _continuity([ZERO] * 100)
+    assert finding.metrics["peak_angular_rps"] < ZERO_QUAT_RPS / 10
+
+
+# ── 真阳性不能被一起修掉 ─────────────────────────────────────
+def test_real_relocation_jump_is_still_detected():
+    """两帧合法位姿之间突然位移 → 仍要报出来。"""
+    near = (0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0)
+    far = (10.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0)      # 10 米瞬移
+    finding = _continuity([near] * 50 + [far] * 50)
+    assert finding.status is WARN
+    assert finding.metrics["jumps"] == 1
+    assert finding.metrics["peak_linear_mps"] > 100   # 10m / (1/30s) = 300 m/s
+
+
+def test_many_real_jumps_still_fail():
+    near = (0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0)
+    far = (5.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0)
+    poses = []
+    for _ in range(30):
+        poses.extend([near, far])
+    finding = _continuity(poses)
+    assert finding.status is FAIL
+    assert finding.metrics["jumps"] >= 10
+
+
+# ── 采集层的 valid_count 也要认这个 ─────────────────────────
+def test_collector_valid_count_excludes_zero_placeholders():
+    """位姿流的 valid_count 若把零占位算作有效，别的检查也会被带偏。"""
+    values = [list(VALID), list(ZERO), None, list(VALID)]
+    counts = tuple(
+        1 if collect.pose_is_valid(tuple(item)) else 0
+        for item in collect.vector_series(values, 7))
+    assert counts == (1, 0, 0, 1)
+
+
+if __name__ == "__main__":
+    import pytest
+    raise SystemExit(pytest.main([__file__, "-q"]))
diff --git a/processor/tests/test_cleaning_report.py b/processor/tests/test_cleaning_report.py
new file mode 100644
index 0000000000000000000000000000000000000000..ac17fc44c46e24fae8dc59f805df81d95520b224
--- /dev/null
+++ b/processor/tests/test_cleaning_report.py
@@ -0,0 +1,194 @@
+"""清洗报告组装单测(app/processing/cleaning/report.py)。
+
+覆盖:四层结果的每一层、时间轴拍平与去重、训练用途判定、fail-closed 语义。
+
+全是纯函数 —— 不需要真视频、不需要 cv2、不需要任何 mock。
+
+    pytest tests/test_cleaning_report.py
+    python3 tests/test_cleaning_report.py
+"""
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from app.processing.cleaning import contract as C  # noqa: E402
+from app.processing.cleaning import report as R  # noqa: E402
+
+
+def _range(start, end, code="video.freeze", severity=C.WARN, stream="s1"):
+    return C.Range(start_sec=start, end_sec=end, code=code,
+                   severity=severity, stream=stream)
+
+
+def _stream(name="s1", status=C.PASS, ranges=(), channels=("rgb", "time")):
+    return C.StreamResult(stream=name, status=status, ranges=tuple(ranges),
+                          channels=tuple(channels))
+
+
+# ── 第二层:时间轴 ───────────────────────────────────────────
+def test_timeline_sorted_by_time():
+    streams = [
+        _stream("s1", ranges=[_range(5, 6), _range(1, 2)]),
+        _stream("s2", ranges=[_range(3, 4)]),
+    ]
+    axis = R.build_timeline(streams)
+    assert [row["start_sec"] for row in axis] == [1, 3, 5]
+
+
+def test_timeline_dedupes_identical_rows():
+    dup = _range(1, 2)
+    axis = R.build_timeline([_stream("s1", ranges=[dup, dup])])
+    assert len(axis) == 1
+
+
+def test_timeline_fills_stream_from_parent():
+    """range 自己没写 stream 时,从所属的 stream 补上。"""
+    bare = C.Range(start_sec=1, end_sec=2, code="x", severity=C.WARN)
+    axis = R.build_timeline([_stream("cam_a", ranges=[bare])])
+    assert axis[0]["stream"] == "cam_a"
+
+
+def test_timeline_accepts_dict_streams():
+    """报告从磁盘读回来时 streams 是 dict,不是 StreamResult。"""
+    axis = R.build_timeline([{
+        "stream": "s1",
+        "ranges": [{"start_sec": 1, "end_sec": 2, "code": "x", "severity": C.WARN}],
+    }])
+    assert axis[0]["code"] == "x"
+
+
+def test_timeline_empty():
+    assert R.build_timeline([]) == []
+
+
+# ── 第三层:整集结论 ─────────────────────────────────────────
+def test_episode_takes_worst_stream():
+    episode = R.rollup_episode([_stream("a", C.PASS), _stream("b", C.FAIL)])
+    assert episode["status"] == C.FAIL
+    assert episode["failed_streams"] == ["b"]
+
+
+def test_episode_includes_findings_in_rollup():
+    """跨模态检查没有对应的 stream,它的结论也要参与整集判定。"""
+    finding = C.Finding(rule="cross.sync", version="1.0", status=C.FAIL,
+                        scope="cross_modal")
+    episode = R.rollup_episode([_stream("a", C.PASS)], [finding])
+    assert episode["status"] == C.FAIL
+
+
+def test_episode_all_pass():
+    episode = R.rollup_episode([_stream("a", C.PASS), _stream("b", C.PASS)])
+    assert episode["status"] == C.PASS
+    assert episode["summary"] == "All checks passed"
+
+
+def test_episode_summary_counts_each_bucket():
+    episode = R.rollup_episode([
+        _stream("a", C.FAIL), _stream("b", C.WARN), _stream("c", C.PENDING),
+    ])
+    assert "1 stream(s) failed" in episode["summary"]
+    assert "1 stream(s) with warnings" in episode["summary"]
+    assert "1 stream(s) pending review" in episode["summary"]
+
+
+def test_episode_empty_streams_is_pass():
+    """没有流可检查 → 这一层判 PASS(是否 fail-closed 由 build_report/passed 决定)。"""
+    assert R.rollup_episode([])["status"] == C.PASS
+
+
+# ── 第四层:训练用途 ─────────────────────────────────────────
+def test_training_use_fails_on_missing_channel():
+    rows = {row["use"]: row for row in R.rollup_training_use({"rgb", "time"})}
+    assert rows["pure_vision"]["status"] == C.PASS
+    assert rows["vision_tactile_joint"]["status"] == C.FAIL
+    assert "not collected" in rows["vision_tactile_joint"]["reason"]
+    assert rows["vision_tactile_joint"]["missing"] == ["tactile"]
+
+
+def test_training_use_reports_all_missing_channels():
+    rows = {row["use"]: row for row in R.rollup_training_use(set())}
+    assert set(rows["pure_vision"]["missing"]) == {"rgb", "time"}
+
+
+def test_training_use_inherits_episode_status():
+    """信道齐全但整集有问题 → 该用途跟着判 warn/fail,而不是 pass。"""
+    rows = {row["use"]: row for row in R.rollup_training_use({"rgb", "time"}, C.WARN)}
+    assert rows["pure_vision"]["status"] == C.WARN
+    assert rows["pure_vision"]["reason"] == "data quality problem"
+
+
+def test_training_use_covers_every_declared_rule():
+    rows = R.rollup_training_use({"rgb", "time"})
+    assert len(rows) == len(R.TRAINING_USE_RULES)
+
+
+# ── 完整报告 ────────────────────────────────────────────────
+def test_build_report_shape():
+    rep = R.build_report(
+        [_stream("cam_a", C.WARN, [_range(1, 2)])],
+        [],
+        episode_id="ep1", project="proj",
+        modalities={"actual": ["mono_rgb"]},
+        channels={"rgb", "time"},
+        ruleset_revision="abc123",
+        template_source="workflow",
+    )
+    assert rep["schema_version"] == R.SCHEMA_VERSION
+    assert rep["episode_id"] == "ep1"
+    assert rep["ruleset_revision"] == "abc123"
+    assert rep["template_source"] == "workflow"
+    assert rep["episode"]["status"] == C.WARN
+    assert rep["passed"] is False          # 只有 PASS 算通过,WARN 不算
+    assert len(rep["ranges"]) == 1
+    assert len(rep["streams"]) == 1
+    assert rep["training_use"]
+
+
+def test_build_report_passed_only_when_all_clean():
+    rep = R.build_report([_stream("a", C.PASS)], [], channels={"rgb", "time"})
+    assert rep["episode"]["status"] == C.PASS
+    assert rep["passed"] is True
+
+
+def test_warn_is_not_passed():
+    """WARN 不算通过 —— 这是"卡在人工审核"的判定依据,必须显式锁住。"""
+    assert R.passed_for(C.WARN) is False
+    assert R.passed_for(C.PASS) is True
+
+
+def test_build_report_pulls_channels_from_streams():
+    """没显式传 channels 时,从各条流自己声明的信道汇总。"""
+    rep = R.build_report([_stream("a", C.PASS, channels=("rgb", "time", "tactile"))])
+    rows = {row["use"]: row for row in rep["training_use"]}
+    assert rows["vision_tactile_joint"]["status"] == C.PASS
+
+
+def test_empty_report_is_fail_closed():
+    """没有数据 ≠ 数据合格。"""
+    rep = R.empty_report(episode_id="ep1", reason="no_data")
+    assert rep["passed"] is False
+    assert rep["episode"]["status"] == C.ERROR
+    assert rep["reason"] == "no_data"
+    assert rep["streams"] == []
+
+
+if __name__ == "__main__":
+    import inspect
+    import tempfile
+
+    _failures = 0
+    for _name, _fn in sorted(globals().items()):
+        if not _name.startswith("test_") or not callable(_fn):
+            continue
+        try:
+            if "tmp_path" in inspect.signature(_fn).parameters:
+                with tempfile.TemporaryDirectory() as _tmp:
+                    _fn(Path(_tmp))
+            else:
+                _fn()
+            print(f"PASS {_name}")
+        except Exception as _exc:  # noqa: BLE001
+            _failures += 1
+            print(f"FAIL {_name}: {_exc}")
+    raise SystemExit(1 if _failures else 0)
diff --git a/processor/web/VERSION b/processor/web/VERSION
new file mode 100644
index 0000000000000000000000000000000000000000..3291e5b98f77b0606e11368fd8e073607e29aba3
--- /dev/null
+++ b/processor/web/VERSION
@@ -0,0 +1,29 @@
+1.12.4
+
+# 前端版本 —— 覆盖 processor/web/ 下的**全部**前端代码:
+#
+#     templates/           Jinja2 页面(含 base 布局与侧边栏)
+#     static/js/           手写脚本(老的是经典脚本;train/ 与 inference/ 是 ES module)
+#     static/*.js|css      第三方 vendored 资源与构建产物
+#     workflow-studio/     React SPA 源码
+#
+# ── 一个号,两个用途 ──────────────────────────────────────────────
+#
+#   1. 模板里的 `?v={{ asset_version }}` 缓存键 —— 读了它,改了 JS/CSS 浏览器
+#      才会重新拉
+#   2. 提交信息里的「前端 X」
+#
+#   ★ **改前端只 bump 这一个文件。** 两个用途共用一个数,不会出现"提交信息写
+#     1.12.3、但浏览器拿的是 1.12.2"这种对不上的情况。
+#
+# ── 和另外两个号的关系 ───────────────────────────────────────────
+#
+#   后端号   processor/app/version.py —— 只管后端(**不再是**缓存键)
+#   SPA 号   workflow-studio/package.json —— 只代表那个 React SPA
+#   三个号互相独立,不必同步。
+#
+# ── 改完要重启 ───────────────────────────────────────────────────
+#
+#   app/web_version.py 在服务启动时读一次就缓存住(不是每请求读盘),所以
+#   bump 完要重启服务才生效。想让它立刻生效得改成可调用对象、模板写
+#   `{{ asset_version() }}` —— 那要改 22 处模板,不划算。
diff --git a/processor/web/static/iconify-preload.js b/processor/web/static/iconify-preload.js
index 1bdf794b2149c68b4c65b58d9835a3695d405622..c8d816e463c0be3211bd2ad1be7ad921b25e8055 100644
--- a/processor/web/static/iconify-preload.js
+++ b/processor/web/static/iconify-preload.js
@@ -73,5 +73,6 @@ window.IconifyPreload.push({
     'logout-outlined': { body: '<path fill="currentColor" d="M868 732h-70.3c-4.8 0-9.3 2.1-12.3 5.8c-7 8.5-14.5 16.7-22.4 24.5a353.8 353.8 0 0 1-112.7 75.9A352.8 352.8 0 0 1 512.4 866c-47.9 0-94.3-9.4-137.9-27.8a353.8 353.8 0 0 1-112.7-75.9a353.3 353.3 0 0 1-76-112.5C167.3 606.2 158 559.9 158 512s9.4-94.2 27.8-137.8c17.8-42.1 43.4-80 76-112.5s70.5-58.1 112.7-75.9c43.6-18.4 90-27.8 137.9-27.8s94.3 9.3 137.9 27.8c42.2 17.8 80.1 43.4 112.7 75.9c7.9 7.9 15.3 16.1 22.4 24.5c3 3.7 7.6 5.8 12.3 5.8H868c6.3 0 10.2-7 6.7-12.3C798 160.5 663.8 81.6 511.3 82C271.7 82.6 79.6 277.1 82 516.4C84.4 751.9 276.2 942 512.4 942c152.1 0 285.7-78.8 362.3-197.7c3.4-5.3-.4-12.3-6.7-12.3m88.9-226.3L815 393.7c-5.3-4.2-13-.4-13 6.3v76H488c-4.4 0-8 3.6-8 8v56c0 4.4 3.6 8 8 8h314v76c0 6.7 7.8 10.5 13 6.3l141.9-112a8 8 0 0 0 0-12.6"/>' },
     'thunderbolt-outlined': { body: '<path fill="currentColor" d="M848 359.3H627.7L825.8 109c4.1-5.3.4-13-6.3-13H436c-2.8 0-5.5 1.5-6.9 4L170 547.5c-3.1 5.3.7 12 6.9 12h174.4l-89.4 357.6c-1.9 7.8 7.5 13.3 13.3 7.7L853.5 373c5.2-4.9 1.7-13.7-5.5-13.7M378.2 732.5l60.3-241H281.1l189.6-327.4h224.6L487 427.4h211z"/>' },
     'menu-outlined': { body: '<path fill="currentColor" d="M904 160H120c-4.4 0-8 3.6-8 8v64c0 4.4 3.6 8 8 8h784c4.4 0 8-3.6 8-8v-64c0-4.4-3.6-8-8-8m0 624H120c-4.4 0-8 3.6-8 8v64c0 4.4 3.6 8 8 8h784c4.4 0 8-3.6 8-8v-64c0-4.4-3.6-8-8-8m0-312H120c-4.4 0-8 3.6-8 8v64c0 4.4 3.6 8 8 8h784c4.4 0 8-3.6 8-8v-64c0-4.4-3.6-8-8-8"/>' },
+      'info-circle-outlined': { body: '<path fill="currentColor" d="M512 64C264.6 64 64 264.6 64 512s200.6 448 448 448s448-200.6 448-448S759.4 64 512 64m0 820c-205.4 0-372-166.6-372-372s166.6-372 372-372s372 166.6 372 372s-166.6 372-372 372"/><path fill="currentColor" d="M464 336a48 48 0 1 0 96 0a48 48 0 1 0-96 0m72 112h-48c-4.4 0-8 3.6-8 8v272c0 4.4 3.6 8 8 8h48c4.4 0 8-3.6 8-8V456c0-4.4-3.6-8-8-8"/>' },
   }
 });
diff --git a/processor/web/static/js/annotations.js b/processor/web/static/js/annotations.js
index fdee2e7c5ac2cd0538021daf5ab0a57330dc34db..7b3488607bac21d00528d095601f267e7e56b319 100644
--- a/processor/web/static/js/annotations.js
+++ b/processor/web/static/js/annotations.js
@@ -475,10 +475,10 @@ async function aiAnnotate() {
             try {
                 st = await (await fetch(`/api/v1/episode/${currentEpisodeId}/ai-annotate/status`)).json();
             } catch (_) { /* keep polling */ }
-            if (st.status === 'signal_segmenting') setLabel('<iconify-icon icon="ant-design:loading-outlined" class="icon-sm animate-spin"></iconify-icon> <span>切段中…</span>');
-            else if (st.status === 'vlm_analyzing') setLabel('<iconify-icon icon="ant-design:loading-outlined" class="icon-sm animate-spin"></iconify-icon> <span>VLM 分析中…</span>');
-            else if (st.status === 'writing') setLabel('<iconify-icon icon="ant-design:loading-outlined" class="icon-sm animate-spin"></iconify-icon> <span>写入…</span>');
-            else if (st.status === 'exporting') setLabel('<iconify-icon icon="ant-design:loading-outlined" class="icon-sm animate-spin"></iconify-icon> <span>写入数据集…</span>');
+            if (st.status === 'signal_segmenting') setLabel('<iconify-icon icon="ant-design:loading-outlined" class="icon-sm animate-spin"></iconify-icon> <span>' + t('ai_status_segmenting') + '</span>');
+            else if (st.status === 'vlm_analyzing') setLabel('<iconify-icon icon="ant-design:loading-outlined" class="icon-sm animate-spin"></iconify-icon> <span>' + t('ai_status_analyzing') + '</span>');
+            else if (st.status === 'writing') setLabel('<iconify-icon icon="ant-design:loading-outlined" class="icon-sm animate-spin"></iconify-icon> <span>' + t('ai_status_writing') + '</span>');
+            else if (st.status === 'exporting') setLabel('<iconify-icon icon="ant-design:loading-outlined" class="icon-sm animate-spin"></iconify-icon> <span>' + t('ai_status_exporting') + '</span>');
             if (st.status === 'done') break;
             if (st.status === 'failed') {
                 console.warn('AI annotation failed:', st.detail);
diff --git a/processor/web/static/js/app.js b/processor/web/static/js/app.js
index ab7c006ea1bddfe86e568cf57d720a0f4d20f383..e83d1e9c616a67629c25c76ffa6034e80945d686 100644
--- a/processor/web/static/js/app.js
+++ b/processor/web/static/js/app.js
@@ -1,1571 +1,1532 @@
-/* Episode list, info panel, review/delete/export */
-
-function escHtml(s) {
-    if (!s) return '';
-    return String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
-}
-
-let selectedEpisodes = new Set();  // batch selection
-let allEpisodes = [];
-let hierarchyData = [];            // Project → Task → Episode tree for the list view
-const _expandedProjects = new Set();  // expanded project ids (default: collapsed)
-const _collapsedTasks = new Set();     // collapsed task ids
-let _loadEpoch = 0;  // stale-response guard — discard out-of-order poll results
-let _formatEpoch = 0;  // 导出格式徽标防竞态:快速切换批次时丢弃过期响应
-let _silentReloadTimer = null;  // coalesce background list refreshes after actions
-let _listLoadController = null; // abort obsolete hierarchy requests on fast navigation
-let _episodesLoadedAt = 0;      // snapshot freshness for background reconciliation
-let selectMode = false;  // selection mode toggle — hides checkboxes by default
-
-// 视图缓存。筛选结果只依赖 [筛选条件 + 排序模式 + 层级快照],与勾选状态无关;
-// 但勾选一行原先要重算三遍(visibleEpisodes → hierarchy → updateBatchUI),
-// 每次都 spread 复制全部 episode。缓存后勾选只改 Set 和那一行 DOM。
-// _hierarchyRev 在层级数据变化时自增 —— 快照替换、局部增删、局部改字段都要加。
-let _hierarchyRev = 0;
-let _viewCache = { key: null, groups: [], visible: [], visibleIds: new Set(), reviewedIds: [] };
-// 上一次渲染所依据的服务端快照指纹;一致就跳过一次整表重绘。
-let _hierarchySignatureAt = null;
-
-// A short-lived cross-navigation snapshot makes the Review page paint
-// immediately after leaving Projects/Workflow. The server remains
-// authoritative: loadEpisodes still refreshes in the background.
-const REVIEW_SNAPSHOT_CACHE_KEY = 'egodata.review.hierarchy.v1';
-const REVIEW_SNAPSHOT_CACHE_TTL = 60 * 1000;
-
-function readReviewSnapshotCache() {
-    try {
-        const cached = JSON.parse(sessionStorage.getItem(REVIEW_SNAPSHOT_CACHE_KEY) || 'null');
-        if (!cached || !Array.isArray(cached.projects)
-                || Date.now() - Number(cached.savedAt || 0) > REVIEW_SNAPSHOT_CACHE_TTL) return null;
-        return cached;
-    } catch (_) { return null; }
-}
-
-function saveReviewSnapshotCache(projects) {
-    try {
-        sessionStorage.setItem(REVIEW_SNAPSHOT_CACHE_KEY, JSON.stringify({
-            savedAt: Date.now(), projects,
-        }));
-    } catch (_) { /* storage quota/private mode — network refresh still works */ }
-}
-
-// 渲染只依赖这些字段;其余字段(如 duration、camera_streams)变了不影响卡片。
-function _episodeRenderSignature(ep) {
-    return [ep.id, ep.status, ep.ai_quality_status, ep._uiWorkflowState,
-            ep.frame_count, ep.fps, ep.name, ep.episode_index,
-            (ep.camera_names || []).length, ep.timestamp, ep.created_at].join(':');
-}
-
-function _hierarchySignature(projects) {
-    let parts = [];
-    (projects || []).forEach(node => {
-        parts.push(`P${node.project?.id}:${node.project?.name}`);
-        (node.episodes || []).forEach(ep => parts.push(_episodeRenderSignature(ep)));
-    });
-    return parts.join(';');
-}
-
-function applyHierarchySnapshot(projects, savedAt = Date.now()) {
-    const incoming = projects || [];
-    // 15 秒轮询每次都会走到这里。卡片渲染只依赖上面那些字段,内容没变时
-    // 直接返回 —— 否则用户正勾选着,列表被整表重建,会闪、丢焦点、丢点击。
-    const signature = _hierarchySignature(incoming);
-    if (signature === _hierarchySignatureAt) {
-        _episodesLoadedAt = savedAt;
-        return;
-    }
-    _hierarchySignatureAt = signature;
-    hierarchyData = incoming;
-    _hierarchyRev++;
-    _episodesLoadedAt = savedAt;
-    allEpisodes = hierarchyData.flatMap(node =>
-        (node.episodes || []).map(e => ({ ...e, task_description: node.project.name })));
-    // updateTaskFilter 可能清掉已失效的 filter-task —— 必须在算视图之前调用,
-    // 否则 currentView() 会按一个已经不存在的筛选条件构建缓存。
-    updateTaskFilter(visibleEpisodesForCurrentView());
-    updateEpisodeListCount(allEpisodes, '', document.getElementById('filter-task')?.value || '');
-    renderEpisodeCards();
-}
-
-// ── Nav tree → filter bridge (called from base.html) ──
-
-function applyNavFilter(statusParam, taskName) {
-    // Set hidden filter controls
-    const statusSel = document.getElementById('filter-status');
-    const taskSel = document.getElementById('filter-task');
-    const searchInput = document.getElementById('search-input');
-    if (statusSel) statusSel.value = statusParam;
-    const requestedTask = taskName || '';
-    if (taskSel) taskSel.value = requestedTask;
-    if (searchInput) searchInput.value = requestedTask;
-    // Update URL
-    const url = new URL(document.location);
-    url.searchParams.set('status', statusParam);
-    url.searchParams.set('search', requestedTask);
-    history.replaceState({}, '', url);
-    // Close detail panel (if open), then filter the in-memory snapshot.
-    backToList();
-    if (hierarchyData.length) {
-        renderEpisodeListFromMemory();
-        scheduleSilentEpisodeRefresh(250);
-    } else {
-        loadEpisodes();
-    }
-    // Highlight nav tree
-    if (typeof window.highlightNavActive === 'function') {
-        window.highlightNavActive(statusParam, taskName);
-    }
-}
-window.applyNavFilter = applyNavFilter;
-
-function syncReviewShortcutActive(status) {
-    const key = status === 'reviewed' ? 'approved'
-        : (status === 'failed' ? 'failed' : 'reviewing');
-    document.querySelectorAll('.sidebar-sub[data-review-status]').forEach(link => {
-        link.classList.toggle('active', link.dataset.reviewStatus === key);
-    });
-}
-
-function switchReviewStatus(status, options = {}) {
-    const allowed = new Set(['completed', 'to_review', 'reviewed', 'failed']);
-    const nextStatus = allowed.has(status) ? status : 'completed';
-    const statusSel = document.getElementById('filter-status');
-    const taskSel = document.getElementById('filter-task');
-    const searchInput = document.getElementById('search-input');
-    if (statusSel) statusSel.value = nextStatus;
-    if (taskSel) taskSel.value = '';
-    if (searchInput) searchInput.value = '';
-
-    const url = new URL(window.location.href);
-    url.searchParams.set('status', nextStatus);
-    url.searchParams.delete('search');
-    if (options.replace) history.replaceState({}, '', url);
-    else history.pushState({}, '', url);
-
-    syncReviewShortcutActive(nextStatus);
-    backToList();
-    if (hierarchyData.length) {
-        renderEpisodeListFromMemory();
-        // Keep the switch instant; only reconcile in the background when the
-        // current snapshot is older than a moment.
-        if (Date.now() - _episodesLoadedAt > 1000) scheduleSilentEpisodeRefresh(200);
-    } else {
-        loadEpisodes();
-    }
-}
-window.switchReviewStatus = switchReviewStatus;
-
-function installReviewStatusNavigation() {
-    if (window.location.pathname !== '/review') return;
-    const statusByShortcut = { reviewing: 'completed', approved: 'reviewed', failed: 'failed' };
-    document.querySelectorAll('.sidebar-sub[data-review-status]').forEach(link => {
-        link.addEventListener('click', event => {
-            event.preventDefault();
-            switchReviewStatus(statusByShortcut[link.dataset.reviewStatus] || 'completed');
-        });
-    });
-    window.addEventListener('popstate', () => {
-        const params = new URLSearchParams(window.location.search);
-        const status = params.get('status') || 'completed';
-        const statusSel = document.getElementById('filter-status');
-        const searchInput = document.getElementById('search-input');
-        if (statusSel) statusSel.value = status;
-        if (searchInput) searchInput.value = params.get('search') || '';
-        syncReviewShortcutActive(status);
-        if (hierarchyData.length) renderEpisodeListFromMemory();
-        else loadEpisodes();
-    });
-}
-
-// ── Init from URL param ─────────────────────────────
-
-function initStatusFromURL() {
-    const params = new URLSearchParams(document.location.search);
-    const statusParam = params.get('status') || 'completed';
-    const sel = document.getElementById('filter-status');
-    if (sel) sel.value = statusParam;
-
-    const searchParam = params.get('search') || '';
-    const searchInput = document.getElementById('search-input');
-    if (searchInput && searchParam) searchInput.value = searchParam;
-}
-
-// ── Sort order ──────────────────────────────────────
-
-const SORT_MODES = [
-    { dir: 'asc',  label: 'Name 1→N', icon: 'ant-design:ordered-list-outlined' },
-    { dir: 'desc', label: 'Name N→1', icon: 'ant-design:ordered-list-outlined' },
-];
-let sortModeIdx = 0;  // cycles 0→1→2→3→0
-
-function currentSortMode() {
-    return SORT_MODES[sortModeIdx];
-}
-
-function toggleSortOrder() {
-    sortModeIdx = (sortModeIdx + 1) % SORT_MODES.length;
-    const mode = currentSortMode();
-    const icon = document.getElementById('sort-order-icon');
-    const label = document.getElementById('sort-order-label');
-    const btn = document.getElementById('btn-sort-order');
-    if (icon) icon.setAttribute('icon', mode.icon);
-    if (label) label.textContent = mode.label;
-    if (btn) btn.title = 'Sort: ' + mode.label;
-    // Re-sort in memory (no network round trip) — only refetch if not yet loaded
-    if (hierarchyData.length === 0) {
-        loadEpisodes();
-    } else {
-        renderEpisodeListFromMemory();
-    }
-}
-
-// Extract trailing numeric suffix: "Chew_gum_0005" → 5, "ep_00020" → 20, "no_number" → 0
-function extractEpisodeNumber(name) {
-    const m = String(name || '').match(/(\d+)\s*$/);
-    return m ? parseInt(m[1], 10) : 0;
-}
-
-// ── Selection mode ──────────────────────────────────
-
-function toggleSelectMode() {
-    selectMode = !selectMode;
-    if (!selectMode) {
-        // 退出选择模式:清空选择,但**不动项目的展开/折叠状态** ——
-        // 用户展开过哪些项目是他自己的布局,不该被模式切换重置。
-        selectedEpisodes.clear();
-    }
-    // 进入选择模式**不再自动展开所有项目**。项目行本身就有三态全选框,
-    // 折叠状态下点一下即可选中整批(卡片仍在 DOM 里),所以没有展开的必要;
-    // 自动展开会让几十个项目同时铺开,列表瞬间变长、滚动位置也丢了。
-    // 退出时的按钮态与批量栏显隐统一交给 updateBatchUI。
-    renderEpisodeListFromMemory();
-}
-
-// ── Load ────────────────────────────────────────────
-
-function currentReviewStatus() {
-    return document.getElementById('filter-status')?.value || 'completed';
-}
-
-function isEpisodeTemporarilyHidden(ep) {
-    // Reprocessing invalidates the previous review artifact immediately. Keep
-    // the episode out of every list until the server publishes the new state;
-    // otherwise the old card can remain visible as "Processing…".
-    return Boolean(ep && (ep.status === 'processing'
-        || ep._uiWorkflowState === 'queued'));
-}
-
-function matchesReviewStatus(status, filter = currentReviewStatus()) {
-    if (!filter) return true;
-    if (filter === 'completed' || filter === 'to_review') {
-        if (status === 'completed' || status === 'to_review') return true;
-        // processing 由 hierarchyForCurrentView 统一隐藏，避免用户打开
-        // 旧产物；处理完成后由下一次静默刷新重新出现。
-        return false;
-    }
-    if (filter === 'reviewed') {
-        return status === 'reviewed' || status === 'approved';
-    }
-    return status === filter;
-}
-
-function matchesEpisodeSearch(ep, projectName, rawSearch) {
-    const search = String(rawSearch || '').trim().toLowerCase();
-    if (!search) return true;
-    return (ep.name || '').toLowerCase().includes(search)
-        || String(ep.id || '').toLowerCase().includes(search)
-        || String(projectName || '').toLowerCase().includes(search);
-}
-
-// The server snapshot contains all live episode metadata. Status/search
-// filtering happens here, so Reviewing ↔ Approved never starts another scan.
-function hierarchyForCurrentView() {
-    const status = currentReviewStatus();
-    const search = document.getElementById('search-input')?.value || '';
-    return hierarchyData.map(node => ({
-        ...node,
-        episodes: (node.episodes || []).filter(ep =>
-            !isEpisodeTemporarilyHidden(ep)
-            && matchesReviewStatus(ep.status, status)
-            && matchesEpisodeSearch(ep, node.project?.name, search)),
-    }));
-}
-
-// 缓存后的视图模型:分组(已按 task 筛选并按当前排序模式排好)+ 扁平的
-// 可见 / 已审核 id 列表。渲染、勾选、计数全部读这一份,不再各自重算。
-function currentView() {
-    const status = currentReviewStatus();
-    const search = document.getElementById('search-input')?.value || '';
-    const taskFilter = document.getElementById('filter-task')?.value || '';
-    const dir = currentSortMode().dir === 'asc' ? 1 : -1;
-    const key = [_hierarchyRev, status, search, taskFilter, dir].join('|');
-    if (_viewCache.key === key) return _viewCache;
-
-    const groups = hierarchyForCurrentView()
-        .filter(node => !taskFilter || (node.project?.name || '') === taskFilter)
-        .map(node => ({
-            project: node.project,
-            // 组内按尾部序号排序(Test1_000012 → 12),只排副本不动原始数据
-            episodes: [...(node.episodes || [])].sort((a, b) =>
-                (extractEpisodeNumber(a.name) - extractEpisodeNumber(b.name)) * dir),
-        }));
-
-    const visible = [];
-    const visibleIds = new Set();
-    const reviewedIds = [];
-    const framesById = new Map();
-    groups.forEach(group => {
-        group.episodes.forEach(ep => {
-            visible.push({ ...ep, task_description: group.project?.name });
-            visibleIds.add(String(ep.id));
-            framesById.set(String(ep.id), Number(ep.frame_count) || 0);
-            if (ep.status === 'reviewed' || ep.status === 'approved') {
-                reviewedIds.push(String(ep.id));
-            }
-        });
-    });
-    _viewCache = { key, groups, visible, visibleIds, reviewedIds, framesById };
-    return _viewCache;
-}
-
-function visibleEpisodesForCurrentView() {
-    return currentView().visible;
-}
-
-async function loadEpisodes(options = {}) {
-    const silent = Boolean(options.silent);
-    if (!silent && _silentReloadTimer) {
-        clearTimeout(_silentReloadTimer);
-        _silentReloadTimer = null;
-    }
-    const taskFilter = document.getElementById('filter-task')?.value || '';
-    const listEl = document.getElementById('episode-list-inline');
-    if (!listEl) return;
-
-    // Paint the last successful hierarchy immediately on a new page load.
-    // A normal request below still reconciles status/uploads in the background.
-    if (!silent && hierarchyData.length === 0) {
-        const cached = readReviewSnapshotCache();
-        if (cached) applyHierarchySnapshot(cached.projects, Number(cached.savedAt) || Date.now());
-    }
-
-    // Save scroll position before innerHTML rebuild (prevent 15s poll reset)
-    const scrollContainer = document.getElementById('episode-list-section');
-    const savedScrollTop = scrollContainer ? scrollContainer.scrollTop : 0;
-
-    if (!silent && hierarchyData.length === 0) {
-        listEl.innerHTML = `<div class="p-4 text-center text-gray-500 text-sm">${t('loading')}</div>`;
-    }
-
-    if (_listLoadController) _listLoadController.abort();
-    const controller = new AbortController();
-    _listLoadController = controller;
-    const fetchEpoch = ++_loadEpoch;
-    try {
-        // Hierarchy view: Project → Task (upload batch) → Episodes.
-        // Status and search are applied after the full snapshot arrives.
-
-        // ``fetchEpoch`` was captured before dispatch so stale responses are ignored.
-        const res = await fetch('/api/v1/projects/hierarchy', { signal: controller.signal });
-        if (!res.ok) throw new Error(`HTTP ${res.status}`);
-        const data = await res.json();
-        if (fetchEpoch !== _loadEpoch) return;  // newer request in flight — discard
-        saveReviewSnapshotCache(data.projects || []);
-        applyHierarchySnapshot(data.projects || []);
-        // Restore scroll position after render
-        if (scrollContainer) {
-            requestAnimationFrame(() => { scrollContainer.scrollTop = savedScrollTop; });
-        }
-    } catch (err) {
-        if (err?.name === 'AbortError') return;
-        if (!silent && hierarchyData.length === 0) {
-            listEl.innerHTML = `<div class="p-4 text-center text-red-400 text-sm">${t('load_failed')}: ${err.message}</div>`;
-        }
-    } finally {
-        if (_listLoadController === controller) _listLoadController = null;
-    }
-}
-
-
-function updateEpisodeListCount(episodes, search, taskFilter) {
-    const countEl = document.getElementById('episode-list-count');
-    if (!countEl) return;
-    let filtered = episodes.filter(ep => !isEpisodeTemporarilyHidden(ep)
-        && matchesReviewStatus(ep.status));
-    if (taskFilter) filtered = filtered.filter(ep => (ep.task_description || '') === taskFilter);
-    if (search) {
-        const s = search.toLowerCase();
-        filtered = filtered.filter(ep =>
-            (ep.name || '').toLowerCase().includes(s) ||
-            (ep.task_description || '').toLowerCase().includes(s) ||
-            String(ep.id).toLowerCase().includes(s));
-    }
-    countEl.textContent = filtered.length + ' episodes';
-}
-
-function updateTaskFilter(episodes) {
-    // filter-task is now a hidden input (not a select). Values are set by applyNavFilter().
-    // This function remains as a hook: clear the value if the task no longer exists in results.
-    const sel = document.getElementById('filter-task');
-    if (!sel) return;
-    const current = sel.value;
-    if (current) {
-        const taskNames = new Set(episodes.map(e => e.task_description || 'unknown'));
-        if (!taskNames.has(current)) {
-            sel.value = '';
-        }
-    }
-}
-
-
-function renderEpisodeCards() {
-    const listEl = document.getElementById('episode-list-inline');
-    if (!listEl) return;
-
-    // Auto-exit selection mode when switching away from Reviewed
-    const statusFilter = document.getElementById('filter-status')?.value || '';
-    if (selectMode && statusFilter !== 'reviewed') {
-        selectMode = false;
-        selectedEpisodes.clear();
-    }
-
-    // 分组、筛选、排序都来自缓存的视图模型 —— 渲染只负责拼 HTML。
-    const view = currentView();
-
-    // 项目文件夹**始终渲染**(含空项目/刚创建的项目):几个项目就显示几个
-    // 文件夹,哪怕里面没有批次;只有没有任何项目时才显示 No data。
-    if (view.groups.length === 0) {
-        listEl.innerHTML = `<div class="p-4 text-center text-gray-500 text-sm">${t('no_data')}</div>`;
-        updateBatchUI();
-        return;
-    }
-
-    // 任务概念已移除:项目 → Episodes 两层(组内排序已在 currentView 完成)
-    let html = '';
-    view.groups.forEach((group) => {
-        const sorted = group.episodes;
-        const projectId = String(group.project?.id ?? '');
-        // 默认折叠:只在用户点击展开过的项目才展开视频卡片
-        const pCollapsed = !_expandedProjects.has(group.project?.id);
-        html += `
-        <div class="project-group border-b border-gray-800" data-project-id="${escHtml(projectId)}">
-            <div class="project-header px-3 py-2 flex items-center gap-2 cursor-pointer hover:bg-gray-800/50 select-none"
-                 onclick="toggleProjectCollapse('${escHtml(projectId)}')">
-                ${projectSelectBoxHtml(projectId, sorted)}
-                <iconify-icon icon="ant-design:folder-outlined" class="text-blue-500"></iconify-icon>
-                <span class="text-sm font-medium text-gray-200 truncate">${escHtml(group.project?.name || '')}</span>
-                <span class="text-xs text-gray-500 flex-shrink-0">${sorted.length}</span>
-                <span class="project-select-count text-xs text-blue-400 flex-shrink-0"></span>
-                <iconify-icon icon="ant-design:${pCollapsed ? 'right' : 'down'}-outlined"
-                              class="project-caret text-gray-600 ml-auto"></iconify-icon>
-            </div>
-            <div class="project-body ${pCollapsed ? 'hidden' : ''}">`;
-        if (sorted.length === 0) {
-            html += `<div class="text-center text-gray-600 text-xs py-2">${t('no_tasks_in_project')}</div>`;
-        }
-        sorted.forEach(ep => { html += episodeCardHtml(ep, group.project?.name); });
-        html += `</div></div>`;
-    });
-    listEl.innerHTML = html;
-    syncProjectSelectDom();
-    updateBatchUI();
-}
-
-// 项目行左侧的三态全选框。只作用于当前筛选下该项目可见的已审核批次;
-// 折叠状态照常可点 —— 卡片仍在 DOM 里,只是 .project-body 被 hidden,
-// 所以点一下就能选中折叠中的整批,不必先展开。
-function projectSelectBoxHtml(projectId, episodes) {
-    const statusFilter = document.getElementById('filter-status')?.value || '';
-    if (!selectMode || statusFilter !== 'reviewed') return '';
-    const reviewed = episodes.filter(ep => ep.status === 'reviewed' || ep.status === 'approved');
-    const disabled = reviewed.length === 0 ? ' disabled' : '';
-    return `<input type="checkbox" class="project-checkbox w-3.5 h-3.5 rounded accent-blue-600 flex-shrink-0"
-                   data-project-id="${escHtml(projectId)}"${disabled}
-                   title="${escHtml(t('select_project_all'))}"
-                   onclick="event.stopPropagation();toggleProjectSelect('${escHtml(projectId)}', this.checked)">`;
-}
-
-// 该项目在当前视图下可见的、可勾选的批次 id。
-function projectReviewedIds(projectId) {
-    const group = currentView().groups.find(
-        item => String(item.project?.id ?? '') === String(projectId));
-    if (!group) return [];
-    return group.episodes
-        .filter(ep => ep.status === 'reviewed' || ep.status === 'approved')
-        .map(ep => String(ep.id));
-}
-
-function toggleProjectSelect(projectId, checked) {
-    projectReviewedIds(projectId).forEach(id => {
-        if (checked) selectedEpisodes.add(id);
-        else selectedEpisodes.delete(id);
-    });
-    syncProjectSelectionDom(projectId);
-    updateBatchUI();
-}
-
-// 把选中状态同步回 DOM:项目行三态框 + 该项目下每张卡片。只碰受影响的项目,
-// 不重建整个列表 —— 这是勾选不再"闪一下"的关键。
-function syncProjectSelectionDom(onlyProjectId) {
-    document.querySelectorAll('#episode-list-inline .project-group').forEach(group => {
-        if (onlyProjectId !== undefined
-                && String(group.dataset.projectId) !== String(onlyProjectId)) return;
-        group.querySelectorAll('input.batch-checkbox').forEach(box => {
-            box.checked = selectedEpisodes.has(String(box.dataset.episodeId));
-            box.closest('.episode-card')?.classList.toggle('selected', box.checked);
-        });
-        syncProjectSelectBox(group);
-    });
-}
-
-function syncProjectSelectBox(group) {
-    const box = group.querySelector('.project-checkbox');
-    if (!box) return;
-    const ids = projectReviewedIds(box.dataset.projectId);
-    const selected = ids.filter(id => selectedEpisodes.has(id)).length;
-    box.checked = ids.length > 0 && selected === ids.length;
-    box.indeterminate = selected > 0 && selected < ids.length;
-    const badge = group.querySelector('.project-select-count');
-    if (badge) badge.textContent = selected > 0 ? `${selected}/${ids.length}` : '';
-}
-
-function syncProjectSelectDom() {
-    syncProjectSelectionDom();
-}
-
-function toggleProjectCollapse(projectId) {
-    if (_expandedProjects.has(projectId)) _expandedProjects.delete(projectId);
-    else _expandedProjects.add(projectId);
-    // 只切这一个项目的 body 与箭头:整表重绘会丢掉滚动位置和焦点,
-    // 大列表上肉眼可见地闪。
-    document.querySelectorAll('#episode-list-inline .project-group').forEach(group => {
-        if (String(group.dataset.projectId) !== String(projectId)) return;
-        const collapsed = !_expandedProjects.has(projectId);
-        group.querySelector('.project-body')?.classList.toggle('hidden', collapsed);
-        group.querySelector('.project-caret')
-            ?.setAttribute('icon', collapsed ? 'ant-design:right-outlined' : 'ant-design:down-outlined');
-    });
-}
-
-// Apply small action results locally so the list responds immediately. The
-// server remains authoritative; a coalesced silent refresh reconciles state
-// after the filesystem-backed hierarchy has caught up.
-function renderEpisodeListFromMemory() {
-    // updateTaskFilter 可能清掉已失效的 filter-task,所以要在取视图之前调用。
-    updateTaskFilter(visibleEpisodesForCurrentView());
-    updateEpisodeListCount(allEpisodes, '', document.getElementById('filter-task')?.value || '');
-    renderEpisodeCards();
-}
-
-function removeEpisodeFromLocalList(episodeId) {
-    const id = String(episodeId);
-    selectedEpisodes.delete(id);
-    _hierarchyRev++;
-    hierarchyData.forEach(node => {
-        node.episodes = (node.episodes || []).filter(ep => String(ep.id) !== id);
-    });
-    allEpisodes = allEpisodes.filter(ep => String(ep.id) !== id);
-    renderEpisodeListFromMemory();
-}
-
-function updateEpisodeInLocalList(episodeId, patch) {
-    const id = String(episodeId);
-    _hierarchyRev++;
-    hierarchyData.forEach(node => {
-        const ep = (node.episodes || []).find(item => String(item.id) === id);
-        if (ep) Object.assign(ep, patch);
-    });
-    const flat = allEpisodes.find(ep => String(ep.id) === id);
-    if (flat) Object.assign(flat, patch);
-    renderEpisodeListFromMemory();
-}
-
-function scheduleSilentEpisodeRefresh(delay = 1200) {
-    clearTimeout(_silentReloadTimer);
-    _silentReloadTimer = setTimeout(() => {
-        _silentReloadTimer = null;
-        loadEpisodes({ silent: true });
-    }, delay);
-}
-
-function toggleTaskCollapse(taskId) {
-    if (_collapsedTasks.has(taskId)) _collapsedTasks.delete(taskId);
-    else _collapsedTasks.add(taskId);
-    renderEpisodeListFromMemory();
-}
-
-function episodeCardHtml(ep, taskName) {
-    const activeClass = currentEpisodeId === ep.id ? 'active' : '';
-    // 前端入队标记(点击后立即显示)或后端真实状态(静默刷新后保持显示)
-    const isWorkflowQueued = ep._uiWorkflowState === 'queued' || ep.status === 'processing';
-    // AI 标注运行中:整批数据等标注完成后才允许查看
-    const isAiAnnotating = !isWorkflowQueued && ep.ai_quality_status === 'running';
-    const cardClass = (isWorkflowQueued || isAiAnnotating)
-        ? 'cursor-default opacity-80'
-        : 'cursor-pointer';
-    const cardClick = (isWorkflowQueued || isAiAnnotating)
-        ? '' : `onclick="selectEpisode('${ep.id}')"`;
-    const isReviewed = ep.status === 'reviewed' || ep.status === 'approved';
-    const isFailed = ep.status === 'failed';
-    const statusDot = (isWorkflowQueued || isAiAnnotating)
-        ? '<span class="inline-block w-2 h-2 rounded-full bg-blue-400 mr-1"></span>'
-        : (isFailed
-        ? '<span class="inline-block w-2 h-2 rounded-full bg-red-400 mr-1"></span>'
-        : (isReviewed
-            ? '<span class="inline-block w-2 h-2 rounded-full bg-green-400 mr-1"></span>'
-            : '<span class="inline-block w-2 h-2 rounded-full bg-yellow-400 mr-1"></span>'));
-    const statusText = isWorkflowQueued ? t('processing')
-        : (isAiAnnotating ? t('ai_annotating')
-        : (isFailed ? t('stat_failed') : (isReviewed ? t('reviewed') : t('reviewing'))));
-    const statusColor = (isWorkflowQueued || isAiAnnotating) ? 'text-blue-400'
-        : (isFailed ? 'text-red-400' : (isReviewed ? 'text-green-400' : 'text-yellow-400'));
-    const cameraCount = (ep.camera_names || []).length;
-    const timestamp = ep.timestamp || '';
-    const time = timestamp ? timestamp : new Date(ep.created_at).toLocaleDateString('zh-CN');
-
-    const checked = selectedEpisodes.has(ep.id) ? 'checked' : '';
-    const checkbox = (isReviewed && selectMode)
-        ? `<input type="checkbox" class="batch-checkbox w-3.5 h-3.5 rounded accent-blue-600 flex-shrink-0"
-                  data-episode-id="${ep.id}" ${checked}
-                  onclick="event.stopPropagation();toggleBatchSelect('${ep.id}', this.checked)">`
-        : '';
-
-    const isAnnotationPage = window.EGODATA_PAGE_MODE === 'annotation';
-    const statusFilter = document.getElementById('filter-status')?.value
-        || new URLSearchParams(document.location.search).get('status')
-        || 'completed';
-    const isReviewingMode = statusFilter === 'completed' || statusFilter === 'to_review';
-    const userRole = String(window.__EGO_USER__?.role || '').toLowerCase();
-    const canReprocess = userRole === 'admin' || userRole === 'engineer';
-    // processing(含前端入队标记)显示禁用的"处理中"状态按钮,不要求角色;
-    // 主动重跑按钮仍只对 admin/engineer 开放且要求 completed/to_review。
-    const workflowButton = !isAnnotationPage && isReviewingMode
-        ? (isWorkflowQueued
-            ? `<button disabled
-                       class="mt-1.5 w-full bg-blue-950/60 text-blue-300/80 text-xs px-3 py-1 rounded cursor-wait">
-                       <iconify-icon icon="ant-design:loading-outlined" class="icon-sm"></iconify-icon> ${t('processing')}</button>`
-            : (canReprocess && (ep.status === 'completed' || ep.status === 'to_review')
-                ? `<button onclick="event.stopPropagation();reprocessEpisode('${ep.id}')"
-                     title="Re-run the bound workflow for this episode"
-                     class="mt-1.5 w-full bg-purple-900/70 hover:bg-purple-800 text-purple-200 text-xs px-3 py-1 rounded">
-                     <iconify-icon icon="ant-design:tool-outlined" class="icon-sm"></iconify-icon> ${t('reprocess')}</button>`
-                : ''))
-        : '';
-    const buttons = isAnnotationPage ? '' : (isFailed
-        ? `<div class="flex gap-2">
-             <button onclick="event.stopPropagation();retryEpisode('${ep.id}')"
-                     class="bg-blue-800 hover:bg-blue-700 text-blue-200 text-xs px-3 py-1 rounded flex-1"><iconify-icon icon="ant-design:reload-outlined" class="icon-sm"></iconify-icon> ${t('retry_review')}</button>
-             <button onclick="event.stopPropagation();deleteEpisode('${ep.id}')"
-                     class="bg-gray-800 hover:bg-red-900 text-gray-400 hover:text-red-300 text-xs px-3 py-1 rounded flex-1"><iconify-icon icon="ant-design:delete-outlined" class="icon-sm"></iconify-icon> ${t('delete')}</button>
-           </div>`
-        : (isReviewed
-            ? `<div class="flex gap-2">
-                 <button onclick="event.stopPropagation();downloadEpisode('${ep.id}')"
-                         title="${t('export_hint')}"
-                         class="bg-blue-800 hover:bg-blue-700 text-blue-200 text-xs px-3 py-1 rounded flex-1"><iconify-icon icon="ant-design:export-outlined" class="icon-sm"></iconify-icon> ${t('export')}</button>
-                 <button onclick="event.stopPropagation();unreviewEpisode('${ep.id}')"
-                         class="bg-yellow-800 hover:bg-yellow-700 text-yellow-200 text-xs px-3 py-1 rounded flex-1"><iconify-icon icon="ant-design:rollback-outlined" class="icon-sm"></iconify-icon> ${t('unreview')}</button>
-               </div>`
-            : `<div class="flex gap-2">
-                 <button onclick="event.stopPropagation();markReviewed('${ep.id}')"
-                         class="bg-green-800 hover:bg-green-700 text-green-200 text-xs px-3 py-1 rounded flex-1"><iconify-icon icon="ant-design:check-outlined" class="icon-sm"></iconify-icon> ${t('approve')}</button>
-                 <button onclick="event.stopPropagation();deleteEpisode('${ep.id}')"
-                         class="bg-gray-800 hover:bg-red-900 text-gray-400 hover:text-red-300 text-xs px-3 py-1 rounded"><iconify-icon icon="ant-design:delete-outlined" class="icon-sm"></iconify-icon></button>
-               </div>${workflowButton}`));
-
-    return `
-    <div class="episode-card ${activeClass} p-3 border-b border-gray-800 hover:bg-gray-800/50 ${cardClass} flex gap-2"
-         data-episode-id="${ep.id}"
-         ${cardClick}
-         ${isWorkflowQueued ? `title="${t('processing')}"` : ''}>
-        ${checkbox}
-        <div class="flex-1 min-w-0">
-        <div class="flex items-center gap-1.5 mb-2">
-            ${statusDot}
-            <span class="text-xs ${statusColor}">${statusText}</span>
-        </div>
-        <div class="flex items-center gap-1.5 mb-1">
-            ${typeof ep.episode_index === 'number'
-                ? `<div class="text-sm font-semibold text-blue-300 truncate" title="${ep.name || ''}">#${ep.episode_index}</div>`
-                : `<div class="text-sm truncate text-gray-200">${ep.name || taskName || ep.id.slice(0, 8)}</div>`}
-        </div>
-        <div class="text-xs text-gray-500 space-y-0.5 mb-2">
-            <div><iconify-icon icon="ant-design:field-time-outlined" class="icon-sm"></iconify-icon> ${ep.fps || 30}FPS · ${ep.frame_count || 0}${t('frame')}</div>
-            ${cameraCount > 0 ? `<div><iconify-icon icon="ant-design:video-camera-outlined" class="icon-sm"></iconify-icon> ${cameraCount} ${t('cameras')}</div>` : ''}
-            <div><iconify-icon icon="ant-design:calendar-outlined" class="icon-sm"></iconify-icon> ${time}</div>
-        </div>
-        ${buttons}
-        </div>
-    </div>`;
-}
-
-
-// ── Back to list ─────────────────────────────────────
-
-function backToList() {
-    // Closing detail must release decoders, 3D canvases, timers, sockets and
-    // in-flight media requests. Hiding the panel alone leaves the old video
-    // workload alive behind Reviewing/Approved and makes the next click lag.
-    if (typeof clearEpisodeWorkspace === 'function') clearEpisodeWorkspace();
-    const detail = document.getElementById('episode-detail');
-    const listSection = document.getElementById('episode-list-section');
-    if (detail) detail.classList.add('hidden');
-    if (listSection) listSection.classList.remove('hidden');
-    // 返回批次列表 → 隐藏漂浮预览控件(点开视频后才有)
-    if (typeof setPreviewPanelsVisible === 'function') setPreviewPanelsVisible(false);
-    const warning = document.getElementById('input-warning-banner');
-    if (warning) {
-        warning.classList.add('hidden');
-        warning.innerHTML = '';
-    }
-}
-
-function renderInputWarning(ep) {
-    const warning = document.getElementById('input-warning-banner');
-    if (!warning) return;
-    const missing = [];
-    const matched = [];
-    (ep.exceptions || []).filter(ex => ex.kind === 'input_missing').forEach(ex => {
-        (ex.missing || []).forEach(value => {
-            if (!missing.includes(String(value))) missing.push(String(value));
-        });
-        (ex.matched || []).forEach(value => {
-            if (!matched.includes(String(value))) matched.push(String(value));
-        });
-    });
-    if (!missing.length) {
-        warning.classList.add('hidden');
-        warning.innerHTML = '';
-        return;
-    }
-    warning.innerHTML =
-        '<div class="flex items-start gap-2">' +
-            '<iconify-icon icon="ant-design:warning-filled" class="text-amber-300 text-base flex-shrink-0 mt-0.5"></iconify-icon>' +
-            '<div class="min-w-0">' +
-                '<div class="font-medium text-amber-100">' + escHtml(t('input_missing_title')) + '</div>' +
-                '<div class="mt-0.5 text-amber-300/90">' + escHtml(t('input_missing_detail')) + '</div>' +
-                '<div class="mt-1 font-mono break-words">' + escHtml(missing.join(', ')) + '</div>' +
-                (matched.length ? '<div class="mt-1 text-emerald-300/90">✓ ' + escHtml(matched.join(', ')) + '</div>' : '') +
-            '</div>' +
-        '</div>';
-    warning.classList.remove('hidden');
-}
-
-// ── Batch selection ──────────────────────────────────
-
-function toggleBatchSelect(episodeId, checked) {
-    const id = String(episodeId);
-    if (checked) selectedEpisodes.add(id);
-    else selectedEpisodes.delete(id);
-    // 只同步这一行与它所属项目的三态框 —— 不重算筛选、不重建列表。
-    const card = document.querySelector(
-        `#episode-list-inline .episode-card[data-episode-id="${CSS.escape(id)}"]`);
-    card?.classList.toggle('selected', checked);
-    const group = card?.closest('.project-group');
-    if (group) syncProjectSelectBox(group);
-    updateBatchUI();
-}
-
-
-function toggleSelectAll(checked) {
-    if (!selectMode) return;
-    if ((document.getElementById('filter-status')?.value || '') !== 'reviewed') return;
-
-    currentView().reviewedIds.forEach(id => {
-        if (checked) selectedEpisodes.add(id);
-        else selectedEpisodes.delete(id);
-    });
-    // 直接写已渲染的 checkbox,不重建整个列表。
-    document.querySelectorAll('#episode-list-inline input.batch-checkbox').forEach(box => {
-        box.checked = selectedEpisodes.has(String(box.dataset.episodeId));
-        box.closest('.episode-card')?.classList.toggle('selected', box.checked);
-    });
-    syncProjectSelectDom();
-    updateBatchUI();
-}
-
-
-function updateBatchUI() {
-    const selectAllBar = document.getElementById('select-all-bar');
-    const batchBar = document.getElementById('batch-bar');
-    const selectBtn = document.getElementById('btn-toggle-select');
-    const statusFilter = document.getElementById('filter-status')?.value || '';
-    const isReviewedMode = statusFilter === 'reviewed';
-    const showSelection = selectMode && isReviewedMode;
-
-    // 「Select」只在非选择模式出现 —— 进入选择模式后由批量栏里的 Cancel 接管。
-    if (selectBtn) {
-        selectBtn.classList.toggle('hidden', !isReviewedMode || selectMode);
-    }
-    // Force-exit selection mode when switching away from Reviewed
-    if (!isReviewedMode && selectMode) {
-        selectMode = false;
-        selectedEpisodes.clear();
-    }
-
-    if (selectAllBar) {
-        selectAllBar.classList.toggle('hidden', !showSelection);
-    }
-    // 批量栏只要在选择模式就显示(哪怕一集都没选)—— 否则 Cancel 没地方放。
-    if (batchBar) {
-        batchBar.classList.toggle('hidden', !showSelection);
-    }
-    if (!showSelection) {
-        if (!selectMode) selectedEpisodes.clear();
-        return;
-    }
-
-    // Update counts
-    const view = currentView();
-    const reviewedCount = view.reviewedIds.length;
-    const selCount = view.reviewedIds.filter(id => selectedEpisodes.has(id)).length;
-
-    const selectCount = document.getElementById('select-count');
-    if (selectCount) selectCount.textContent = `(${selCount}/${reviewedCount})`;
-
-    const selectAllCb = document.getElementById('select-all-checkbox');
-    if (selectAllCb) {
-        selectAllCb.checked = reviewedCount > 0 && selCount === reviewedCount;
-        selectAllCb.indeterminate = selCount > 0 && selCount < reviewedCount;
-    }
-
-    // 选中规模:让用户在点之前知道这一下要跑多久 —— 打包下载是秒级原样 zip,
-    // 导出数据集是整库重建(实测约 30 秒/集)。
-    let frames = 0;
-    view.reviewedIds.forEach(id => {
-        if (selectedEpisodes.has(id)) frames += view.framesById.get(id) || 0;
-    });
-    const batchCount = document.getElementById('batch-count');
-    if (batchCount) {
-        batchCount.textContent = t('batch_selected_summary')
-            .replace('%s', String(selCount))
-            .replace('%f', frames.toLocaleString());
-    }
-    const exportBtnLabel = document.getElementById('batch-export-label');
-    if (exportBtnLabel) {
-        const minutes = Math.max(1, Math.round(selCount * 30 / 60));
-        exportBtnLabel.textContent = selCount >= 5
-            ? `${t('batch_export_dataset')} ~${minutes}${t('minutes_short')}`
-            : t('batch_export_dataset');
-    }
-    // 一集都没选时两个动作按钮禁用(Cancel 仍可点,否则退不出去)。
-    const exportBtn = document.getElementById('batch-export-btn');
-    if (exportBtn) exportBtn.disabled = selCount === 0;
-    const zipBtn = document.getElementById('batch-zip-btn');
-    if (zipBtn) zipBtn.disabled = selCount === 0;
-}
-
-
-// 导出数据集:合并成一个可训练数据集。整库重建 —— 每路视频重编码、
-// 逐帧重采样、全量重算 stats,实测约 30 秒/集。
-async function batchDownload(button = null) {
-    if (selectedEpisodes.size === 0) return;
-    const ids = Array.from(selectedEpisodes);
-    const done = await startReviewExport(ids, null, null, button);
-    if (done && selectMode) toggleSelectMode();
-}
-
-// 打包下载:每集一个目录原样 zip,不重建,秒级返回。
-// 用原生表单提交而非 fetch + blob —— 浏览器自己流式写盘,不会把整个
-// zip 缓冲进内存(几十集的包很容易上 GB)。
-function batchZipDownload(button = null) {
-    if (selectedEpisodes.size === 0) return;
-    const form = document.createElement('form');
-    form.method = 'POST';
-    form.action = '/api/v1/export/batch-download';
-    form.style.display = 'none';
-    const field = document.createElement('input');
-    field.type = 'hidden';
-    field.name = 'episode_ids';
-    field.value = Array.from(selectedEpisodes).join(',');
-    form.appendChild(field);
-    document.body.appendChild(form);
-    form.submit();
-    form.remove();
-    if (button) button.blur();
-}
-
-
-function waitForExportJob(jobId, button) {
-    const originalHtml = button ? button.innerHTML : null;
-    return new Promise(resolve => {
-        const poll = async () => {
-            try {
-                const res = await fetch(`/api/v1/export/${jobId}`);
-                const job = await res.json();
-                if (job.status === 'completed') {
-                    resolve(true);
-                    return;
-                }
-                if (job.status === 'failed') {
-                    alert('Export failed: ' + (job.error || 'unknown'));
-                    resolve(false);
-                    return;
-                }
-                if (button) {
-                    // 导出期间按钮直接显示百分比进度,不再静默等待
-                    const pct = Math.round((Number(job.progress) || 0) * 100);
-                    button.textContent = 'Exporting… ' + pct + '%';
-                }
-            } catch (err) {
-                alert('Export status failed: ' + err.message);
-                resolve(false);
-                return;
-            }
-            setTimeout(poll, 800);
-        };
-        poll();
-    }).finally(() => {
-        if (button) {
-            if (originalHtml !== null) button.innerHTML = originalHtml;
-            button.disabled = false;
-            button.dataset.exporting = '';
-            button.classList.remove('opacity-60', 'cursor-wait');
-        }
-    });
-}
-
-
-async function startReviewExport(ids, format, datasetName, button = null) {
-    if (!ids || ids.length === 0) return false;
-    if (button) {
-        button.disabled = true;
-        button.dataset.exporting = '1';
-        button.classList.add('opacity-60', 'cursor-wait');
-    }
-    try {
-        const payload = {
-            episode_ids: ids,
-            split_ratio: 0.9,
-        };
-        if (datasetName) payload.dataset_name = datasetName;
-        // Normal review-page exports omit the format deliberately: the
-        // backend resolves it from the selected project's workflow node.
-        if (format) payload.export_format = format;
-        const res = await fetch('/api/v1/export/start', {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify(payload),
-        });
-        if (!res.ok) {
-            const err = await res.json().catch(() => ({}));
-            alert('Export failed: ' + (err.detail || 'unknown'));
-            if (button) {
-                button.disabled = false;
-                button.dataset.exporting = '';
-                button.classList.remove('opacity-60', 'cursor-wait');
-            }
-            return false;
-        }
-        const job = await res.json();
-        const done = await waitForExportJob(job.id, button);
-        if (done) {
-            window.location.href = `/api/v1/export/download/${job.id}`;
-            return true;
-        }
-        return false;
-    } catch (err) {
-        alert('Export failed: ' + err.message);
-        if (button) {
-            button.disabled = false;
-            button.dataset.exporting = '';
-            button.classList.remove('opacity-60', 'cursor-wait');
-        }
-        return false;
-    }
-}
-
-
-// ── Select / Info Panel ──────────────────────────────
-
-function showAiPendingGate(episodeId) {
-    // 全屏等待遮罩:AI 标注未完成时批次数据不可查看。每 4 秒轮询层级
-    // 接口,标注结束(非 running)后自动移除遮罩并重新进入批次。
-    const listSection = document.getElementById('episode-list-section');
-    const detail = document.getElementById('episode-detail');
-    if (listSection) listSection.classList.add('hidden');
-    if (detail) detail.classList.remove('hidden');
-    let overlay = document.getElementById('ai-pending-overlay');
-    if (!overlay) {
-        overlay = document.createElement('div');
-        overlay.id = 'ai-pending-overlay';
-        overlay.className = 'fixed inset-0 z-[999] flex flex-col items-center justify-center gap-3 bg-black/85';
-        document.body.appendChild(overlay);
-    }
-    overlay.innerHTML = `
-        <iconify-icon icon="ant-design:loading-3-quarters-outlined" class="text-blue-400 text-4xl animate-spin"></iconify-icon>
-        <div class="text-gray-200 text-sm">${t('ai_annotating')}</div>
-        <div class="text-gray-500 text-xs">${t('ai_annotating_hint')}</div>`;
-    if (overlay.dataset.polling === '1') return;
-    overlay.dataset.polling = '1';
-    (async function poll() {
-        for (let i = 0; i < 300; i++) {  // 最多约 20 分钟
-            await new Promise(resolve => setTimeout(resolve, 4000));
-            try {
-                const res = await fetch('/api/v1/projects/hierarchy');
-                if (!res.ok) continue;
-                const data = await res.json();
-                const projects = Array.isArray(data)
-                    ? data : (data && data.projects) || [];
-                let done = false;
-                for (const projectNode of projects) {
-                    const hit = (projectNode.episodes || [])
-                        .find(e => e.id === episodeId);
-                    if (!hit) continue;
-                    if (hit.ai_quality_status !== 'running') {
-                        done = true;  // passed / failed / null → 可查看
-                    } else if (hit.status === 'processing') {
-                        done = true;  // 回到 processing,由现有门禁接管
-                    }
-                    break;
-                }
-                if (done) {
-                    overlay.dataset.polling = '';
-                    overlay.remove();
-                    if (typeof selectEpisode === 'function') {
-                        selectEpisode(episodeId);
-                    }
-                    return;
-                }
-            } catch (_) { /* 网络抖动,继续轮询 */ }
-        }
-        overlay.dataset.polling = '';
-        overlay.remove();
-        if (typeof backToList === 'function') backToList();
-    })();
-}
-
-function selectEpisode(episodeId) {
-    const ep = allEpisodes.find(e => e.id === episodeId);
-    if (!ep) return;
-    // Reprocessing keeps the list card visible, but its previous artifacts are
-    // no longer a valid review target. Do not reopen stale media while the
-    // worker is replacing the processed output.
-    if (ep.status === 'processing' || ep._uiWorkflowState === 'queued') {
-        backToList();
-        return;
-    }
-    // AI 标注运行中:整批数据等标注完成后才显示(全屏等待遮罩 + 轮询,
-    // 完成后自动载入)。
-    if (ep.ai_quality_status === 'running') {
-        showAiPendingGate(episodeId);
-        return;
-    }
-
-    // Annotation is a separate workspace: start every selected file with a
-    // clean editor while leaving the review page's approval flow untouched.
-    if (window.EGODATA_PAGE_MODE === 'annotation' && typeof hideAnnotationForm === 'function') {
-        hideAnnotationForm();
-    }
-
-    // Highlight card
-    document.querySelectorAll('.episode-card').forEach(el => el.classList.remove('active'));
-    const card = document.querySelector('.episode-card[data-episode-id="' + episodeId + '"]');
-    if (card) card.classList.add('active');
-
-    // Load video
-    const cameras = ep.camera_names || [];
-    const playbackMeta = { frameCount: ep.frame_count, fps: ep.fps };
-    if (typeof loadGroupedEpisodeVideo === 'function') {
-        loadGroupedEpisodeVideo(episodeId, cameras, {
-            hasSkeleton: Boolean(ep.has_skeleton),
-            ...playbackMeta,
-        });
-    } else {
-        loadEpisodeVideo(episodeId, cameras, playbackMeta);
-    }
-
-    // Switch to detail view: hide list, show detail panel
-    const listSection = document.getElementById('episode-list-section');
-    const detail = document.getElementById('episode-detail');
-    if (listSection) listSection.classList.add('hidden');
-    if (detail) detail.classList.remove('hidden');
-    // 进入批次详情(审核/通过/标注页)→ 显示漂浮预览控件
-    if (typeof setPreviewPanelsVisible === 'function') setPreviewPanelsVisible(true);
-    renderInputWarning(ep);
-
-    // Fill detail header
-    const nameEl = document.getElementById('detail-episode-name');
-    if (nameEl) {
-        const episodeNumber = typeof ep.episode_index === 'number'
-            ? `#${ep.episode_index}` : '';
-        const title = ep.task_description || ep.name || ep.id.slice(0, 8);
-        nameEl.textContent = episodeNumber ? `${episodeNumber} · ${title}` : title;
-        nameEl.title = ep.id || title;
-    }
-    const statusBadge = document.getElementById('detail-status-badge');
-    if (statusBadge) {
-        const isReviewed = ep.status === 'reviewed' || ep.status === 'approved';
-        const isFailed = ep.status === 'failed';
-        const isProcessing = ep.status === 'processing';
-        statusBadge.className = 'text-xs flex-shrink-0 ' + (isFailed ? 'text-red-400' : (isReviewed ? 'text-green-400' : (isProcessing ? 'text-blue-400' : 'text-yellow-400')));
-        statusBadge.textContent = isFailed ? t('stat_failed') : (isReviewed ? t('reviewed') : (isProcessing ? t('processing') : t('reviewing')));
-    }
-
-    // Fill detail info
-    const infoDiv = document.getElementById('episode-detail-info');
-    const meta = ep.meta || {};
-    const timestamp = meta.timestamp || '';
-    const time = timestamp || new Date(ep.created_at).toLocaleString('zh-CN');
-    const isReviewed = ep.status === 'reviewed' || ep.status === 'approved';
-    const isFailed = ep.status === 'failed';
-    const duration = ep.fps > 0 ? (ep.frame_count / ep.fps).toFixed(1) : '0';
-    const cameraList = (ep.camera_names || []).join(', ');
-
-    let cleaningHTML = '';
-    if (ep.cleaning_report) {
-        const cr = ep.cleaning_report;
-        if (cr.passed) {
-            cleaningHTML = '<div class="flex items-center gap-1 text-green-400 text-xs"><iconify-icon icon="ant-design:check-circle-filled" class="icon-sm"></iconify-icon> Cleaning passed</div>';
-        } else {
-            const failList = (cr.checks || []).filter(c => !c.passed).map(c => c.name).join(', ');
-            cleaningHTML = '<div class="flex items-center gap-1 text-red-400 text-xs" title="' + failList + '"><iconify-icon icon="ant-design:warning-filled" class="icon-sm"></iconify-icon> Cleaning failed</div>';
-        }
-    }
-
-    // 上传不匹配/运行失败异常:点击文件后在此详情显示(不在项目列表显示)
-    let exceptionHTML = '';
-    if (ep.exceptions && ep.exceptions.length) {
-        exceptionHTML = ep.exceptions.map(function (ex) {
-            const kindLabel = ex.kind === 'run_failed'
-                ? t('exception_kind_failed')
-                : (ex.kind === 'input_missing' ? t('exception_kind_missing') : t('exception_kind_mismatch'));
-            const safeMsg = escHtml(ex.message || '');
-            const msg = safeMsg ? ': ' + safeMsg : '';
-            const color = ex.kind === 'input_missing' ? 'text-amber-300' : 'text-red-400';
-            return '<div class="flex items-center gap-1 ' + color + ' text-xs" title="' + safeMsg + '">' +
-                '<iconify-icon icon="ant-design:warning-filled" class="icon-sm"></iconify-icon> ' + kindLabel + msg + '</div>';
-        }).join('');
-    }
-
-    const isAnnotationPage = window.EGODATA_PAGE_MODE === 'annotation';
-    const buttons = isAnnotationPage ? '' : (isFailed
-        ? '<button onclick="retryEpisode(\'' + ep.id + '\')" class="flex-1 bg-blue-800 hover:bg-blue-700 text-blue-200 py-1.5 rounded text-xs"><iconify-icon icon="ant-design:reload-outlined" class="icon-sm"></iconify-icon> ' + t('retry_review') + '</button>' +
-          '<button onclick="deleteEpisode(\'' + ep.id + '\')" class="bg-gray-800 hover:bg-red-900 text-gray-400 hover:text-red-300 py-1.5 px-3 rounded text-xs"><iconify-icon icon="ant-design:delete-outlined" class="icon-sm"></iconify-icon></button>'
-        : (ep.status === 'processing'
-        ? '<button disabled class="flex-1 bg-blue-950/60 text-blue-300/80 py-1.5 rounded text-xs cursor-wait"><iconify-icon icon="ant-design:loading-outlined" class="icon-sm"></iconify-icon> ' + t('processing') + '</button>' +
-          '<button onclick="deleteEpisode(\'' + ep.id + '\')" class="bg-gray-800 hover:bg-red-900 text-gray-400 hover:text-red-300 py-1.5 px-3 rounded text-xs"><iconify-icon icon="ant-design:delete-outlined" class="icon-sm"></iconify-icon></button>'
-        : (isReviewed
-        ? '<button onclick="downloadEpisode(\'' + ep.id + '\')" title="' + t('export_hint') + '" class="flex-1 bg-blue-800 hover:bg-blue-700 text-blue-200 py-1.5 rounded text-xs"><iconify-icon icon="ant-design:export-outlined" class="icon-sm"></iconify-icon> ' + t('export') + '</button>' +
-          '<button onclick="unreviewEpisode(\'' + ep.id + '\')" class="flex-1 bg-yellow-800 hover:bg-yellow-700 text-yellow-200 py-1.5 rounded text-xs"><iconify-icon icon="ant-design:rollback-outlined" class="icon-sm"></iconify-icon> ' + t('unreview') + '</button>'
-        : '<button onclick="markReviewed(\'' + ep.id + '\')" class="flex-1 bg-green-700 hover:bg-green-600 text-white py-1.5 rounded text-xs font-medium"><iconify-icon icon="ant-design:check-outlined" class="icon-sm"></iconify-icon> ' + t('approve') + '</button>' +
-          '<button onclick="deleteEpisode(\'' + ep.id + '\')" class="bg-gray-800 hover:bg-red-900 text-gray-400 hover:text-red-300 py-1.5 px-3 rounded text-xs"><iconify-icon icon="ant-design:delete-outlined" class="icon-sm"></iconify-icon></button>')));
-
-    if (infoDiv) {
-        infoDiv.innerHTML =
-            '<div class="space-y-1.5 text-xs">' +
-                (cleaningHTML || '') +
-                (exceptionHTML || '') +
-                '<div class="text-gray-500 space-y-0.5">' +
-                    '<div><iconify-icon icon="ant-design:field-time-outlined" class="icon-sm"></iconify-icon> ' + ep.frame_count + ' frames · ' + ep.fps + ' FPS · ' + duration + 's</div>' +
-                    (cameraList ? '<div><iconify-icon icon="ant-design:video-camera-outlined" class="icon-sm"></iconify-icon> ' + cameraList + '</div>' : '') +
-                    '<div><iconify-icon icon="ant-design:calendar-outlined" class="icon-sm"></iconify-icon> ' + time + '</div>' +
-                    '<div id="episode-detail-sync-status" class="hidden"></div>' +
-                    '<div id="episode-detail-ai-status" class="hidden"></div>' +
-                '</div>' +
-                '<div class="flex items-center gap-2 bg-gray-800 rounded px-3 py-1.5">' +
-                    '<span class="text-gray-500">Frame</span>' +
-                    '<span id="heatmap-frame" class="text-blue-400 font-mono font-bold text-lg">-</span>' +
-                    '<span class="text-gray-600">/ ' + ep.frame_count + '</span>' +
-                '</div>' +
-                '<div class="flex gap-2">' + buttons + '</div>' +
-                '<div id="episode-detail-format"></div>' +
-            '</div>';
-        if (typeof updateEpisodeDetailSyncStatus === 'function') updateEpisodeDetailSyncStatus();
-
-        // 导出格式徽标(工作流连接驱动:HDF5 / LeRobot v2.1 / v3.0 / Raw 兜底)
-        const fmtEl = document.getElementById('episode-detail-format');
-        if (fmtEl) {
-            fmtEl.innerHTML = '';
-            if (!isAnnotationPage && isReviewed) {
-                const fmtEpoch = ++_formatEpoch;
-                fetch(`/api/v1/export/episode-format/${episodeId}`)
-                    .then(r => r.json())
-                    .then(d => {
-                        if (fmtEpoch !== _formatEpoch) return;  // 已切换批次,丢弃过期响应
-                        const el = document.getElementById('episode-detail-format');
-                        if (!el) return;
-                        const label = escHtml(d.label || 'Raw');
-                        const badge = d.available
-                            ? '<span class="text-blue-300 font-medium">' + label + '</span>'
-                            : '<span class="text-gray-500">' + label + '</span>';
-                        el.innerHTML = '<div class="flex items-center gap-1 text-gray-500"><iconify-icon icon="ant-design:export-outlined" class="icon-sm"></iconify-icon> ' +
-                            t('export') + ': ' + badge +
-                            (d.available ? ' · <button id="btn-re-export" onclick="reExportEpisode()" class="text-blue-400 hover:underline text-xs">' + t('re_export') + '</button>' : '') +
-                            '</div>';
-                    })
-                    .catch(() => {});
-            }
-        }
-    }
-
-// Re-export:只重建导出,不重跑检测(复用最新 run 的检测产物 +
-// 当前工作流的导出配置/连线)。Review 详情 Export 徽标旁按钮。
-// (挂 window:inline onclick 需要全局可见)
-window.reExportEpisode = async function () {
-    if (!currentEpisodeId) return;
-    const btn = document.getElementById('btn-re-export');
-    if (!btn || btn.dataset.busy === '1') return;
-    btn.dataset.busy = '1';
-    btn.textContent = t('re_exporting') + '…';
-    let finalStatus = 'done';
-    try {
-        const res = await fetch(`/api/v1/export/re-export/${currentEpisodeId}`, { method: 'POST' });
-        if (!res.ok) throw new Error((await res.json().catch(() => ({}))).detail || res.status);
-        for (let i = 0; i < 300; i++) {
-            await new Promise(r => setTimeout(r, 1000));
-            let st = { status: 'running' };
-            try {
-                st = await (await fetch(`/api/v1/export/re-export/${currentEpisodeId}/status`)).json();
-            } catch (_) { /* keep polling */ }
-            if (st.status === 'done' || st.status === 'failed' || st.status === 'interrupted') {
-                finalStatus = st.status;
-                if (st.status !== 'done') {
-                    alert(t('re_export_failed') + ': ' + (st.detail || st.status));
-                } else {
-                    alert(t('re_export_done') + ': ' + (st.detail || ''));
-                }
-                break;
-            }
-        }
-    } catch (err) {
-        finalStatus = 'failed';
-        alert(t('re_export_failed') + ': ' + (err.message || err));
-    }
-    btn.dataset.busy = '';
-    btn.textContent = t('re_export');
-    if (finalStatus === 'done') {
-        // 刷新徽标(格式可能已变)
-        const fmtEpoch = ++_formatEpoch;
-        try {
-            const d = await (await fetch(`/api/v1/export/episode-format/${currentEpisodeId}`)).json();
-            if (fmtEpoch !== _formatEpoch || !currentEpisodeId) return;
-            const el = document.getElementById('episode-detail-format');
-            if (!el) return;
-            const label = escHtml(d.label || 'Raw');
-            const badge = d.available
-                ? '<span class="text-blue-300 font-medium">' + label + '</span>'
-                : '<span class="text-gray-500">' + label + '</span>';
-            el.innerHTML = '<div class="flex items-center gap-1 text-gray-500"><iconify-icon icon="ant-design:export-outlined" class="icon-sm"></iconify-icon> ' +
-                t('export') + ': ' + badge +
-                (d.available ? ' · <button id="btn-re-export" onclick="reExportEpisode()" class="text-blue-400 hover:underline text-xs">' + t('re_export') + '</button>' : '') +
-                '</div>';
-        } catch (_) { /* 刷新失败下次进入详情自动重取 */ }
-    }
-}
-
-    // Update frame info header
-    const frameHeader = document.getElementById('frame-info-header');
-    const totalFramesEl = document.getElementById('detail-total-frames');
-    if (frameHeader) frameHeader.classList.remove('hidden');
-    if (totalFramesEl) totalFramesEl.textContent = ep.frame_count || 0;
-
-    // Show frame controls
-    if (typeof showAnnotationUI === 'function') showAnnotationUI();
-
-    // Annotations are loaded by loadEpisodeVideo after frame data is ready
-    // (avoid race: loadAnnotations needs episodeTotalFrames from loadFrameData)
-}
-
-
-// ── Review ──────────────────────────────────────────
-
-async function markReviewed(episodeId) {
-    try {
-        const res = await fetch(`/api/v1/episode/${episodeId}/review`, { method: 'POST' });
-        if (res.ok) {
-            backToList();
-            removeEpisodeFromLocalList(episodeId);
-            scheduleSilentEpisodeRefresh();
-        }
-    } catch (err) {
-        alert('Operation failed: ' + err.message);
-    }
-}
-
-
-async function unreviewEpisode(episodeId) {
-    try {
-        const res = await fetch(`/api/v1/episode/${episodeId}/unreview`, { method: 'POST' });
-        if (res.ok) {
-            backToList();
-            removeEpisodeFromLocalList(episodeId);
-            scheduleSilentEpisodeRefresh();
-        }
-    } catch (err) {
-        alert('Operation failed: ' + err.message);
-    }
-}
-
-
-async function retryEpisode(episodeId) {
-    try {
-        const res = await fetch(`/api/v1/episode/${episodeId}/retry`, { method: 'POST' });
-        if (res.ok) {
-            backToList();
-            removeEpisodeFromLocalList(episodeId);
-            scheduleSilentEpisodeRefresh();
-        }
-    } catch (err) {
-        alert('Operation failed: ' + err.message);
-    }
-}
-
-
-// ── Reprocess(主动重新处理)──────────────────────────
-
-async function reprocessEpisode(episodeId) {
-    if (!confirm(t('confirm_reprocess'))) return;
-    // The worker will replace the canonical parquet. Do not reuse the old
-    // full depth/3D browser buffers when this episode is opened again.
-    if (typeof window.invalidateEpisodePlaybackCache === 'function') {
-        window.invalidateEpisodePlaybackCache(episodeId);
-    }
-    // Clear the old detail workspace before waiting for the queue response.
-    // Reprocessing is asynchronous; the old media must not remain active
-    // while the user navigates to another review section.
-    backToList();
-    // Mark the local snapshot before the POST resolves. This closes the small
-    // window in which a fast click could reopen the old completed artifact.
-    updateEpisodeInLocalList(episodeId, { _uiWorkflowState: 'queued' });
-    try {
-        const res = await fetch(`/api/v1/episode/${episodeId}/reprocess`, { method: 'POST' });
-        if (res.ok) {
-            scheduleSilentEpisodeRefresh();
-        } else {
-            updateEpisodeInLocalList(episodeId, { _uiWorkflowState: null });
-            const err = await res.json();
-            alert(t('reprocess_failed') + (err.detail || res.status));
-        }
-    } catch (err) {
-        updateEpisodeInLocalList(episodeId, { _uiWorkflowState: null });
-        alert(t('reprocess_failed') + err.message);
-    }
-}
-
-
-// ── Delete ──────────────────────────────────────────
-
-async function deleteEpisode(episodeId) {
-    if (!confirm(t('confirm_trash'))) return;
-
-    try {
-        const res = await fetch(`/api/v1/episode/${episodeId}/delete`, { method: 'POST' });
-        if (res.ok) {
-            updateTrashBadge();  // 垃圾桶徽标立即 +1,无需刷新页面
-            backToList();       // instant feedback — close detail, show list
-            if (currentEpisodeId === episodeId) {
-                document.getElementById('video-grid').innerHTML =
-                    '<div class="flex items-center justify-center h-64 text-gray-600">' + t('deleted_msg') + '</div>';
-                // Clear annotations
-                annotations = [];
-                if (typeof clearAnnotationOverlay === 'function') clearAnnotationOverlay();
-            }
-            removeEpisodeFromLocalList(episodeId);
-            scheduleSilentEpisodeRefresh();
-        }
-    } catch (err) {
-        alert(t('op_failed') + ': ' + err.message);
-    }
-}
-
-
-async function restoreEpisode(episodeId) {
-    try {
-        const res = await fetch(`/api/v1/episode/${episodeId}/restore`, { method: 'POST' });
-        if (res.ok) {
-            updateTrashBadge();  // 恢复后徽标立即 -1
-            loadTrashList();
-            if (typeof refreshReviewTree === 'function') refreshReviewTree();
-        }
-    } catch (err) {
-        alert(t('restore_failed') + ': ' + err.message);
-    }
-}
-
-
-async function permanentDeleteEpisode(episodeId) {
-    if (!confirm(t('confirm_permanent'))) return;
-    try {
-        const res = await fetch(`/api/v1/episode/${episodeId}/permanent`, { method: 'DELETE' });
-        if (res.ok) {
-            updateTrashBadge();
-            loadTrashList();
-            if (typeof refreshReviewTree === 'function') refreshReviewTree();
-        }
-    } catch (err) {
-        alert(t('delete_failed') + ': ' + err.message);
-    }
-}
-
-
-async function purgeTrash() {
-    if (!confirm(t('confirm_purge'))) return;
-    try {
-        const res = await fetch('/api/v1/episodes/purge-trash', { method: 'POST' });
-        if (res.ok) {
-            updateTrashBadge();
-            loadTrashList();
-            if (typeof refreshReviewTree === 'function') refreshReviewTree();
-        }
-    } catch (err) {
-        alert(t('purge_failed') + ': ' + err.message);
-    }
-}
-
-
-// ── Export ────────────────────────────────────────────
-
-async function downloadEpisode(episodeId) {
-    // A single episode already has its workflow-published export product.
-    // That endpoint returns the version selected in the workflow export node.
-    window.location.href = `/api/v1/export/download-episode/${episodeId}`;
-}
-
-
-// ── Export Page ───────────────────────────────────────
-
-async function loadExportJobs() {
-    const listEl = document.getElementById('export-list');
-    if (!listEl) return;
-
-    try {
-        const res = await fetch('/api/v1/export/list?limit=50');
-        const jobs = await res.json();
-
-        if (jobs.length === 0) {
-            listEl.innerHTML = '<tr><td colspan="5" class="text-center text-gray-500 py-8">No export jobs</td></tr>';
-            return;
-        }
-
-        listEl.innerHTML = jobs.map(job => {
-            const time = new Date(job.created_at).toLocaleString('zh-CN');
-            const statusColors = { pending: 'text-yellow-400', running: 'text-blue-400', completed: 'text-green-400', failed: 'text-red-400' };
-            const statusText = { pending: 'Pending', running: 'Running', completed: 'Completed', failed: 'Failed' };
-            const progressBar = job.status === 'running'
-                ? `<div class="w-full bg-gray-700 rounded h-2"><div class="bg-blue-500 h-2 rounded" style="width:${job.progress}%"></div></div>`
-                : job.status === 'completed' ? '100%' : '-';
-            const actions = job.status === 'completed'
-                ? `<a href="/api/v1/export/download/${job.id}" class="text-blue-400 hover:underline text-xs"><iconify-icon icon="ant-design:download-outlined" class="icon-sm"></iconify-icon> Download</a>`
-                : job.status === 'running'
-                    ? `<button onclick="loadExportJobs()" class="text-gray-400 hover:underline text-xs">Refresh</button>`
-                    : '';
-
-            return `<tr class="border-b border-gray-800">
-                <td class="px-4 py-2">${job.dataset_name}</td>
-                <td class="px-4 py-2 ${statusColors[job.status]||'text-gray-400'}">${statusText[job.status]||job.status}</td>
-                <td class="px-4 py-2">${progressBar}</td>
-                <td class="px-4 py-2 text-xs text-gray-400">${time}</td>
-                <td class="px-4 py-2">${actions}</td>
-            </tr>`;
-        }).join('');
-    } catch (err) {
-        listEl.innerHTML = `<tr><td colspan="5" class="text-center text-red-400 py-8">Load failed</td></tr>`;
-    }
-}
-
-
-async function startExport() {
-    const name = document.getElementById('new-dataset-name')?.value;
-    const ratio = parseFloat(document.getElementById('new-split-ratio')?.value) || 0.9;
-    if (!name) return alert('Please enter a dataset name');
-
-    try {
-        const res = await fetch('/api/v1/export/start', {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ dataset_name: name, episode_ids: null, split_ratio: ratio }),
-        });
-        if (res.ok) { document.getElementById('new-dataset-name').value = ''; loadExportJobs(); }
-        else { const err = await res.json(); alert('Export creation failed: ' + (err.detail || 'unknown')); }
-    } catch (err) {
-        alert('Export creation failed: ' + err.message);
-    }
-}
-
-
-// ── Init ────────────────────────────────────────────
-
-document.addEventListener('DOMContentLoaded', () => {
-    // Apply data-i18n translations
-    document.querySelectorAll('[data-i18n]').forEach(el => {
-        el.textContent = t(el.dataset.i18n);
-    });
-    document.querySelectorAll('[data-i18n-placeholder]').forEach(el => {
-        el.placeholder = t(el.dataset.i18nPlaceholder);
-    });
-    // Init nav labels
-    const navReview = document.getElementById('nav-review');
-    const navTrash = document.getElementById('nav-trash');
-    if (navReview) navReview.textContent = t('video_review');
-    if (navTrash) navTrash.textContent = t('trash');
-
-    if (document.getElementById('episode-list-inline')) {
-        initStatusFromURL();
-        installReviewStatusNavigation();
-        loadEpisodes();
-        setInterval(() => { loadEpisodes({ silent: true }); updateTrashBadge(); }, 15000);
-        updateTrashBadge();
-        // 两个批量按钮的提示:说清一个是重建、一个是原样打包。
-        const exportBtn = document.getElementById('batch-export-btn');
-        if (exportBtn) exportBtn.title = t('batch_export_hint');
-        const zipBtn = document.getElementById('batch-zip-btn');
-        if (zipBtn) zipBtn.title = t('batch_zip_hint');
-    }
-    if (document.getElementById('export-list')) {
-        loadExportJobs();
-        setInterval(loadExportJobs, 10000);
-    }
-    if (document.getElementById('trash-list')) {
-        loadTrashList();
-    }
-});
-
-
-async function loadTrashList() {
-    const listEl = document.getElementById('trash-list');
-    if (!listEl) return;
-
-    listEl.innerHTML = `<div class="p-4 text-center text-gray-500 text-sm">${t('loading')}</div>`;
-
-    try {
-        const res = await fetch('/api/v1/episodes?status=deleted&limit=200');
-        const data = await res.json();
-        const episodes = data.episodes || [];
-
-        if (episodes.length === 0) {
-            listEl.innerHTML = `<div class="p-8 text-center text-gray-500"><iconify-icon icon="ant-design:delete-outlined" class="icon-md"></iconify-icon> ${t('trash_empty')}</div>`;
-        } else {
-            const now = new Date();
-            listEl.innerHTML = episodes.map(ep => {
-                const delTime = new Date(ep.deleted_at);
-                const daysLeft = Math.max(0, Math.ceil(7 - (now - delTime) / (1000 * 60 * 60 * 24)));
-                const time = new Date(ep.created_at).toLocaleString('zh-CN');
-                return `
-                <div class="bg-gray-800 rounded p-4 flex items-center justify-between">
-                    <div class="flex-1">
-                        <div class="text-sm font-medium text-gray-200">${ep.task_description || ep.name || 'unknown'}</div>
-                        <div class="text-xs text-gray-500 mt-1">
-                            <iconify-icon icon="ant-design:field-time-outlined" class="icon-sm"></iconify-icon> ${ep.fps}FPS · ${ep.frame_count}${t('frame')} · <iconify-icon icon="ant-design:video-camera-outlined" class="icon-sm"></iconify-icon> ${(ep.camera_names||[]).join(', ') || t('not_found')}
-                        </div>
-                        <div class="text-xs text-gray-500"><iconify-icon icon="ant-design:calendar-outlined" class="icon-sm"></iconify-icon> ${time}</div>
-                    </div>
-                    <div class="text-xs text-gray-400 mr-4"><iconify-icon icon="ant-design:hourglass-outlined" class="icon-sm"></iconify-icon> ${t('days_left')} ${daysLeft} ${t('day_unit')}</div>
-                    <div class="flex gap-2">
-                        <button onclick="restoreEpisode('${ep.id}')"
-                                class="bg-green-700 hover:bg-green-600 text-white text-xs px-3 py-1.5 rounded"><iconify-icon icon="ant-design:rollback-outlined" class="icon-sm"></iconify-icon> ${t('restore')}</button>
-                        <button onclick="permanentDeleteEpisode('${ep.id}')"
-                                class="bg-red-800 hover:bg-red-700 text-red-200 text-xs px-3 py-1.5 rounded"><iconify-icon icon="ant-design:delete-outlined" class="icon-sm"></iconify-icon> ${t('permanent_delete')}</button>
-                    </div>
-                </div>`;
-            }).join('');
-        }
-        updateTrashBadge();
-    } catch (err) {
-        listEl.innerHTML = `<div class="p-4 text-center text-red-400 text-sm">${t('load_failed')}</div>`;
-    }
-}
-
-
-// updateTrashBadge 由 base.html 全局提供(所有页面生效),删除/恢复/清空后
-// 各操作函数调用它立即刷新徽标,无需刷新页面。
+/* Episode list, info panel, review/delete/export */
+
+function escHtml(s) {
+    if (!s) return '';
+    return String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+}
+
+let selectedEpisodes = new Set();  // batch selection
+let allEpisodes = [];
+let hierarchyData = [];            // Project → Task → Episode tree for the list view
+const _expandedProjects = new Set();  // expanded project ids (default: collapsed)
+const _collapsedTasks = new Set();     // collapsed task ids
+let _loadEpoch = 0;  // stale-response guard — discard out-of-order poll results
+let _formatEpoch = 0;  // 导出格式徽标防竞态:快速切换批次时丢弃过期响应
+let _silentReloadTimer = null;  // coalesce background list refreshes after actions
+let _listLoadController = null; // abort obsolete hierarchy requests on fast navigation
+let _episodesLoadedAt = 0;      // snapshot freshness for background reconciliation
+let selectMode = false;  // selection mode toggle — hides checkboxes by default
+
+// 视图缓存。筛选结果只依赖 [筛选条件 + 排序模式 + 层级快照],与勾选状态无关;
+// 但勾选一行原先要重算三遍(visibleEpisodes → hierarchy → updateBatchUI),
+// 每次都 spread 复制全部 episode。缓存后勾选只改 Set 和那一行 DOM。
+// _hierarchyRev 在层级数据变化时自增 —— 快照替换、局部增删、局部改字段都要加。
+let _hierarchyRev = 0;
+let _viewCache = { key: null, groups: [], visible: [], visibleIds: new Set(), reviewedIds: [] };
+// 上一次渲染所依据的服务端快照指纹;一致就跳过一次整表重绘。
+let _hierarchySignatureAt = null;
+
+// A short-lived cross-navigation snapshot makes the Review page paint
+// immediately after leaving Projects/Workflow. The server remains
+// authoritative: loadEpisodes still refreshes in the background.
+const REVIEW_SNAPSHOT_CACHE_KEY = 'egodata.review.hierarchy.v1';
+const REVIEW_SNAPSHOT_CACHE_TTL = 60 * 1000;
+
+function readReviewSnapshotCache() {
+    try {
+        const cached = JSON.parse(sessionStorage.getItem(REVIEW_SNAPSHOT_CACHE_KEY) || 'null');
+        if (!cached || !Array.isArray(cached.projects)
+                || Date.now() - Number(cached.savedAt || 0) > REVIEW_SNAPSHOT_CACHE_TTL) return null;
+        return cached;
+    } catch (_) { return null; }
+}
+
+function saveReviewSnapshotCache(projects) {
+    try {
+        sessionStorage.setItem(REVIEW_SNAPSHOT_CACHE_KEY, JSON.stringify({
+            savedAt: Date.now(), projects,
+        }));
+    } catch (_) { /* storage quota/private mode — network refresh still works */ }
+}
+
+// 渲染只依赖这些字段;其余字段(如 duration、camera_streams)变了不影响卡片。
+function _episodeRenderSignature(ep) {
+    return [ep.id, ep.status, ep.ai_quality_status, ep._uiWorkflowState,
+            ep.frame_count, ep.fps, ep.name, ep.episode_index,
+            (ep.camera_names || []).length, ep.timestamp, ep.created_at].join(':');
+}
+
+function _hierarchySignature(projects) {
+    let parts = [];
+    (projects || []).forEach(node => {
+        parts.push(`P${node.project?.id}:${node.project?.name}`);
+        (node.episodes || []).forEach(ep => parts.push(_episodeRenderSignature(ep)));
+    });
+    return parts.join(';');
+}
+
+function applyHierarchySnapshot(projects, savedAt = Date.now()) {
+    const incoming = projects || [];
+    // 15 秒轮询每次都会走到这里。卡片渲染只依赖上面那些字段,内容没变时
+    // 直接返回 —— 否则用户正勾选着,列表被整表重建,会闪、丢焦点、丢点击。
+    const signature = _hierarchySignature(incoming);
+    if (signature === _hierarchySignatureAt) {
+        _episodesLoadedAt = savedAt;
+        return;
+    }
+    _hierarchySignatureAt = signature;
+    hierarchyData = incoming;
+    _hierarchyRev++;
+    _episodesLoadedAt = savedAt;
+    allEpisodes = hierarchyData.flatMap(node =>
+        (node.episodes || []).map(e => ({ ...e, task_description: node.project.name })));
+    // updateTaskFilter 可能清掉已失效的 filter-task —— 必须在算视图之前调用,
+    // 否则 currentView() 会按一个已经不存在的筛选条件构建缓存。
+    updateTaskFilter(visibleEpisodesForCurrentView());
+    updateEpisodeListCount(allEpisodes, '', document.getElementById('filter-task')?.value || '');
+    renderEpisodeCards();
+}
+
+// ── Nav tree → filter bridge (called from base.html) ──
+
+function applyNavFilter(statusParam, taskName) {
+    // Set hidden filter controls
+    const statusSel = document.getElementById('filter-status');
+    const taskSel = document.getElementById('filter-task');
+    const searchInput = document.getElementById('search-input');
+    if (statusSel) statusSel.value = statusParam;
+    const requestedTask = taskName || '';
+    if (taskSel) taskSel.value = requestedTask;
+    if (searchInput) searchInput.value = requestedTask;
+    // Update URL
+    const url = new URL(document.location);
+    url.searchParams.set('status', statusParam);
+    url.searchParams.set('search', requestedTask);
+    history.replaceState({}, '', url);
+    // Close detail panel (if open), then filter the in-memory snapshot.
+    backToList();
+    if (hierarchyData.length) {
+        renderEpisodeListFromMemory();
+        scheduleSilentEpisodeRefresh(250);
+    } else {
+        loadEpisodes();
+    }
+    // Highlight nav tree
+    if (typeof window.highlightNavActive === 'function') {
+        window.highlightNavActive(statusParam, taskName);
+    }
+}
+window.applyNavFilter = applyNavFilter;
+
+function syncReviewShortcutActive(status) {
+    const key = status === 'reviewed' ? 'approved'
+        : (status === 'failed' ? 'failed' : 'reviewing');
+    document.querySelectorAll('.sidebar-sub[data-review-status]').forEach(link => {
+        link.classList.toggle('active', link.dataset.reviewStatus === key);
+    });
+}
+
+function switchReviewStatus(status, options = {}) {
+    const allowed = new Set(['completed', 'to_review', 'reviewed', 'failed']);
+    const nextStatus = allowed.has(status) ? status : 'completed';
+    const statusSel = document.getElementById('filter-status');
+    const taskSel = document.getElementById('filter-task');
+    const searchInput = document.getElementById('search-input');
+    if (statusSel) statusSel.value = nextStatus;
+    if (taskSel) taskSel.value = '';
+    if (searchInput) searchInput.value = '';
+
+    const url = new URL(window.location.href);
+    url.searchParams.set('status', nextStatus);
+    url.searchParams.delete('search');
+    if (options.replace) history.replaceState({}, '', url);
+    else history.pushState({}, '', url);
+
+    syncReviewShortcutActive(nextStatus);
+    backToList();
+    if (hierarchyData.length) {
+        renderEpisodeListFromMemory();
+        // Keep the switch instant; only reconcile in the background when the
+        // current snapshot is older than a moment.
+        if (Date.now() - _episodesLoadedAt > 1000) scheduleSilentEpisodeRefresh(200);
+    } else {
+        loadEpisodes();
+    }
+}
+window.switchReviewStatus = switchReviewStatus;
+
+function installReviewStatusNavigation() {
+    if (window.location.pathname !== '/review') return;
+    const statusByShortcut = { reviewing: 'completed', approved: 'reviewed', failed: 'failed' };
+    document.querySelectorAll('.sidebar-sub[data-review-status]').forEach(link => {
+        link.addEventListener('click', event => {
+            event.preventDefault();
+            switchReviewStatus(statusByShortcut[link.dataset.reviewStatus] || 'completed');
+        });
+    });
+    window.addEventListener('popstate', () => {
+        const params = new URLSearchParams(window.location.search);
+        const status = params.get('status') || 'completed';
+        const statusSel = document.getElementById('filter-status');
+        const searchInput = document.getElementById('search-input');
+        if (statusSel) statusSel.value = status;
+        if (searchInput) searchInput.value = params.get('search') || '';
+        syncReviewShortcutActive(status);
+        if (hierarchyData.length) renderEpisodeListFromMemory();
+        else loadEpisodes();
+    });
+}
+
+// ── Init from URL param ─────────────────────────────
+
+function initStatusFromURL() {
+    const params = new URLSearchParams(document.location.search);
+    const statusParam = params.get('status') || 'completed';
+    const sel = document.getElementById('filter-status');
+    if (sel) sel.value = statusParam;
+
+    const searchParam = params.get('search') || '';
+    const searchInput = document.getElementById('search-input');
+    if (searchInput && searchParam) searchInput.value = searchParam;
+}
+
+// ── Sort order ──────────────────────────────────────
+
+// label 存 **i18n key** 而不是文案 —— 这个标签会被 toggleSortOrder() 直接写进
+// DOM，写死英文的话切了中文后点一下排序又变回英文。
+const SORT_MODES = [
+    { dir: 'asc',  labelKey: 'name_1_to_n', icon: 'ant-design:ordered-list-outlined' },
+    { dir: 'desc', labelKey: 'name_n_to_1', icon: 'ant-design:ordered-list-outlined' },
+];
+let sortModeIdx = 0;  // cycles 0→1→2→3→0
+
+function currentSortMode() {
+    return SORT_MODES[sortModeIdx];
+}
+
+function toggleSortOrder() {
+    sortModeIdx = (sortModeIdx + 1) % SORT_MODES.length;
+    const mode = currentSortMode();
+    const icon = document.getElementById('sort-order-icon');
+    const label = document.getElementById('sort-order-label');
+    const btn = document.getElementById('btn-sort-order');
+    if (icon) icon.setAttribute('icon', mode.icon);
+    if (label) label.textContent = t(mode.labelKey);
+    if (btn) btn.title = t('sort_label') + t(mode.labelKey);
+    // Re-sort in memory (no network round trip) — only refetch if not yet loaded
+    if (hierarchyData.length === 0) {
+        loadEpisodes();
+    } else {
+        renderEpisodeListFromMemory();
+    }
+}
+
+// Extract trailing numeric suffix: "Chew_gum_0005" → 5, "ep_00020" → 20, "no_number" → 0
+function extractEpisodeNumber(name) {
+    const m = String(name || '').match(/(\d+)\s*$/);
+    return m ? parseInt(m[1], 10) : 0;
+}
+
+// ── Selection mode ──────────────────────────────────
+
+function toggleSelectMode() {
+    selectMode = !selectMode;
+    if (!selectMode) {
+        // 退出选择模式:清空选择,但**不动项目的展开/折叠状态** ——
+        // 用户展开过哪些项目是他自己的布局,不该被模式切换重置。
+        selectedEpisodes.clear();
+    }
+    // 进入选择模式**不再自动展开所有项目**。项目行本身就有三态全选框,
+    // 折叠状态下点一下即可选中整批(卡片仍在 DOM 里),所以没有展开的必要;
+    // 自动展开会让几十个项目同时铺开,列表瞬间变长、滚动位置也丢了。
+    // 退出时的按钮态与批量栏显隐统一交给 updateBatchUI。
+    renderEpisodeListFromMemory();
+}
+
+// ── Load ────────────────────────────────────────────
+
+function currentReviewStatus() {
+    return document.getElementById('filter-status')?.value || 'completed';
+}
+
+function isEpisodeTemporarilyHidden(ep) {
+    // Reprocessing invalidates the previous review artifact immediately. Keep
+    // the episode out of every list until the server publishes the new state;
+    // otherwise the old card can remain visible as "Processing…".
+    return Boolean(ep && (ep.status === 'processing'
+        || ep._uiWorkflowState === 'queued'));
+}
+
+function matchesReviewStatus(status, filter = currentReviewStatus()) {
+    if (!filter) return true;
+    if (filter === 'completed' || filter === 'to_review') {
+        if (status === 'completed' || status === 'to_review') return true;
+        // processing 由 hierarchyForCurrentView 统一隐藏，避免用户打开
+        // 旧产物；处理完成后由下一次静默刷新重新出现。
+        return false;
+    }
+    if (filter === 'reviewed') {
+        return status === 'reviewed' || status === 'approved';
+    }
+    return status === filter;
+}
+
+function matchesEpisodeSearch(ep, projectName, rawSearch) {
+    const search = String(rawSearch || '').trim().toLowerCase();
+    if (!search) return true;
+    return (ep.name || '').toLowerCase().includes(search)
+        || String(ep.id || '').toLowerCase().includes(search)
+        || String(projectName || '').toLowerCase().includes(search);
+}
+
+// The server snapshot contains all live episode metadata. Status/search
+// filtering happens here, so Reviewing ↔ Approved never starts another scan.
+function hierarchyForCurrentView() {
+    const status = currentReviewStatus();
+    const search = document.getElementById('search-input')?.value || '';
+    return hierarchyData.map(node => ({
+        ...node,
+        episodes: (node.episodes || []).filter(ep =>
+            !isEpisodeTemporarilyHidden(ep)
+            && matchesReviewStatus(ep.status, status)
+            && matchesEpisodeSearch(ep, node.project?.name, search)),
+    }));
+}
+
+// 缓存后的视图模型:分组(已按 task 筛选并按当前排序模式排好)+ 扁平的
+// 可见 / 已审核 id 列表。渲染、勾选、计数全部读这一份,不再各自重算。
+function currentView() {
+    const status = currentReviewStatus();
+    const search = document.getElementById('search-input')?.value || '';
+    const taskFilter = document.getElementById('filter-task')?.value || '';
+    const dir = currentSortMode().dir === 'asc' ? 1 : -1;
+    const key = [_hierarchyRev, status, search, taskFilter, dir].join('|');
+    if (_viewCache.key === key) return _viewCache;
+
+    const groups = hierarchyForCurrentView()
+        .filter(node => !taskFilter || (node.project?.name || '') === taskFilter)
+        .map(node => ({
+            project: node.project,
+            // 组内按尾部序号排序(Test1_000012 → 12),只排副本不动原始数据
+            episodes: [...(node.episodes || [])].sort((a, b) =>
+                (extractEpisodeNumber(a.name) - extractEpisodeNumber(b.name)) * dir),
+        }));
+
+    const visible = [];
+    const visibleIds = new Set();
+    const reviewedIds = [];
+    const framesById = new Map();
+    groups.forEach(group => {
+        group.episodes.forEach(ep => {
+            visible.push({ ...ep, task_description: group.project?.name });
+            visibleIds.add(String(ep.id));
+            framesById.set(String(ep.id), Number(ep.frame_count) || 0);
+            if (ep.status === 'reviewed' || ep.status === 'approved') {
+                reviewedIds.push(String(ep.id));
+            }
+        });
+    });
+    _viewCache = { key, groups, visible, visibleIds, reviewedIds, framesById };
+    return _viewCache;
+}
+
+function visibleEpisodesForCurrentView() {
+    return currentView().visible;
+}
+
+async function loadEpisodes(options = {}) {
+    const silent = Boolean(options.silent);
+    if (!silent && _silentReloadTimer) {
+        clearTimeout(_silentReloadTimer);
+        _silentReloadTimer = null;
+    }
+    const taskFilter = document.getElementById('filter-task')?.value || '';
+    const listEl = document.getElementById('episode-list-inline');
+    if (!listEl) return;
+
+    // Paint the last successful hierarchy immediately on a new page load.
+    // A normal request below still reconciles status/uploads in the background.
+    if (!silent && hierarchyData.length === 0) {
+        const cached = readReviewSnapshotCache();
+        if (cached) applyHierarchySnapshot(cached.projects, Number(cached.savedAt) || Date.now());
+    }
+
+    // Save scroll position before innerHTML rebuild (prevent 15s poll reset)
+    const scrollContainer = document.getElementById('episode-list-section');
+    const savedScrollTop = scrollContainer ? scrollContainer.scrollTop : 0;
+
+    if (!silent && hierarchyData.length === 0) {
+        listEl.innerHTML = `<div class="p-4 text-center text-gray-500 text-sm">${t('loading')}</div>`;
+    }
+
+    if (_listLoadController) _listLoadController.abort();
+    const controller = new AbortController();
+    _listLoadController = controller;
+    const fetchEpoch = ++_loadEpoch;
+    try {
+        // Hierarchy view: Project → Task (upload batch) → Episodes.
+        // Status and search are applied after the full snapshot arrives.
+
+        // ``fetchEpoch`` was captured before dispatch so stale responses are ignored.
+        const res = await fetch('/api/v1/projects/hierarchy', { signal: controller.signal });
+        if (!res.ok) throw new Error(`HTTP ${res.status}`);
+        const data = await res.json();
+        if (fetchEpoch !== _loadEpoch) return;  // newer request in flight — discard
+        saveReviewSnapshotCache(data.projects || []);
+        applyHierarchySnapshot(data.projects || []);
+        // Restore scroll position after render
+        if (scrollContainer) {
+            requestAnimationFrame(() => { scrollContainer.scrollTop = savedScrollTop; });
+        }
+    } catch (err) {
+        if (err?.name === 'AbortError') return;
+        if (!silent && hierarchyData.length === 0) {
+            listEl.innerHTML = `<div class="p-4 text-center text-red-400 text-sm">${t('load_failed')}: ${err.message}</div>`;
+        }
+    } finally {
+        if (_listLoadController === controller) _listLoadController = null;
+    }
+}
+
+
+function updateEpisodeListCount(episodes, search, taskFilter) {
+    const countEl = document.getElementById('episode-list-count');
+    if (!countEl) return;
+    let filtered = episodes.filter(ep => !isEpisodeTemporarilyHidden(ep)
+        && matchesReviewStatus(ep.status));
+    if (taskFilter) filtered = filtered.filter(ep => (ep.task_description || '') === taskFilter);
+    if (search) {
+        const s = search.toLowerCase();
+        filtered = filtered.filter(ep =>
+            (ep.name || '').toLowerCase().includes(s) ||
+            (ep.task_description || '').toLowerCase().includes(s) ||
+            String(ep.id).toLowerCase().includes(s));
+    }
+    countEl.textContent = filtered.length + ' episodes';
+}
+
+function updateTaskFilter(episodes) {
+    // filter-task is now a hidden input (not a select). Values are set by applyNavFilter().
+    // This function remains as a hook: clear the value if the task no longer exists in results.
+    const sel = document.getElementById('filter-task');
+    if (!sel) return;
+    const current = sel.value;
+    if (current) {
+        const taskNames = new Set(episodes.map(e => e.task_description || 'unknown'));
+        if (!taskNames.has(current)) {
+            sel.value = '';
+        }
+    }
+}
+
+
+function renderEpisodeCards() {
+    const listEl = document.getElementById('episode-list-inline');
+    if (!listEl) return;
+
+    // Auto-exit selection mode when switching away from Reviewed
+    const statusFilter = document.getElementById('filter-status')?.value || '';
+    if (selectMode && statusFilter !== 'reviewed') {
+        selectMode = false;
+        selectedEpisodes.clear();
+    }
+
+    // 分组、筛选、排序都来自缓存的视图模型 —— 渲染只负责拼 HTML。
+    const view = currentView();
+
+    // 项目文件夹**始终渲染**(含空项目/刚创建的项目):几个项目就显示几个
+    // 文件夹,哪怕里面没有批次;只有没有任何项目时才显示 No data。
+    if (view.groups.length === 0) {
+        listEl.innerHTML = `<div class="p-4 text-center text-gray-500 text-sm">${t('no_data')}</div>`;
+        updateBatchUI();
+        return;
+    }
+
+    // 任务概念已移除:项目 → Episodes 两层(组内排序已在 currentView 完成)
+    let html = '';
+    view.groups.forEach((group) => {
+        const sorted = group.episodes;
+        const projectId = String(group.project?.id ?? '');
+        // 默认折叠:只在用户点击展开过的项目才展开视频卡片
+        const pCollapsed = !_expandedProjects.has(group.project?.id);
+        html += `
+        <div class="project-group border-b border-gray-800" data-project-id="${escHtml(projectId)}">
+            <div class="project-header px-3 py-2 flex items-center gap-2 cursor-pointer hover:bg-gray-800/50 select-none"
+                 onclick="toggleProjectCollapse('${escHtml(projectId)}')">
+                ${projectSelectBoxHtml(projectId, sorted)}
+                <iconify-icon icon="ant-design:folder-outlined" class="text-blue-500"></iconify-icon>
+                <span class="text-sm font-medium text-gray-200 truncate">${escHtml(group.project?.name || '')}</span>
+                <span class="text-xs text-gray-500 flex-shrink-0">${sorted.length}</span>
+                <span class="project-select-count text-xs text-blue-400 flex-shrink-0"></span>
+                <iconify-icon icon="ant-design:${pCollapsed ? 'right' : 'down'}-outlined"
+                              class="project-caret text-gray-600 ml-auto"></iconify-icon>
+            </div>
+            <div class="project-body ${pCollapsed ? 'hidden' : ''}">`;
+        if (sorted.length === 0) {
+            html += `<div class="text-center text-gray-600 text-xs py-2">${t('no_tasks_in_project')}</div>`;
+        }
+        sorted.forEach(ep => { html += episodeCardHtml(ep, group.project?.name); });
+        html += `</div></div>`;
+    });
+    listEl.innerHTML = html;
+    syncProjectSelectDom();
+    updateBatchUI();
+}
+
+// 项目行左侧的三态全选框。只作用于当前筛选下该项目可见的已审核批次;
+// 折叠状态照常可点 —— 卡片仍在 DOM 里,只是 .project-body 被 hidden,
+// 所以点一下就能选中折叠中的整批,不必先展开。
+function projectSelectBoxHtml(projectId, episodes) {
+    const statusFilter = document.getElementById('filter-status')?.value || '';
+    if (!selectMode || statusFilter !== 'reviewed') return '';
+    const reviewed = episodes.filter(ep => ep.status === 'reviewed' || ep.status === 'approved');
+    const disabled = reviewed.length === 0 ? ' disabled' : '';
+    return `<input type="checkbox" class="project-checkbox w-3.5 h-3.5 rounded accent-blue-600 flex-shrink-0"
+                   data-project-id="${escHtml(projectId)}"${disabled}
+                   title="${escHtml(t('select_project_all'))}"
+                   onclick="event.stopPropagation();toggleProjectSelect('${escHtml(projectId)}', this.checked)">`;
+}
+
+// 该项目在当前视图下可见的、可勾选的批次 id。
+function projectReviewedIds(projectId) {
+    const group = currentView().groups.find(
+        item => String(item.project?.id ?? '') === String(projectId));
+    if (!group) return [];
+    return group.episodes
+        .filter(ep => ep.status === 'reviewed' || ep.status === 'approved')
+        .map(ep => String(ep.id));
+}
+
+function toggleProjectSelect(projectId, checked) {
+    projectReviewedIds(projectId).forEach(id => {
+        if (checked) selectedEpisodes.add(id);
+        else selectedEpisodes.delete(id);
+    });
+    syncProjectSelectionDom(projectId);
+    updateBatchUI();
+}
+
+// 把选中状态同步回 DOM:项目行三态框 + 该项目下每张卡片。只碰受影响的项目,
+// 不重建整个列表 —— 这是勾选不再"闪一下"的关键。
+function syncProjectSelectionDom(onlyProjectId) {
+    document.querySelectorAll('#episode-list-inline .project-group').forEach(group => {
+        if (onlyProjectId !== undefined
+                && String(group.dataset.projectId) !== String(onlyProjectId)) return;
+        group.querySelectorAll('input.batch-checkbox').forEach(box => {
+            box.checked = selectedEpisodes.has(String(box.dataset.episodeId));
+            box.closest('.episode-card')?.classList.toggle('selected', box.checked);
+        });
+        syncProjectSelectBox(group);
+    });
+}
+
+function syncProjectSelectBox(group) {
+    const box = group.querySelector('.project-checkbox');
+    if (!box) return;
+    const ids = projectReviewedIds(box.dataset.projectId);
+    const selected = ids.filter(id => selectedEpisodes.has(id)).length;
+    box.checked = ids.length > 0 && selected === ids.length;
+    box.indeterminate = selected > 0 && selected < ids.length;
+    const badge = group.querySelector('.project-select-count');
+    if (badge) badge.textContent = selected > 0 ? `${selected}/${ids.length}` : '';
+}
+
+function syncProjectSelectDom() {
+    syncProjectSelectionDom();
+}
+
+function toggleProjectCollapse(projectId) {
+    if (_expandedProjects.has(projectId)) _expandedProjects.delete(projectId);
+    else _expandedProjects.add(projectId);
+    // 只切这一个项目的 body 与箭头:整表重绘会丢掉滚动位置和焦点,
+    // 大列表上肉眼可见地闪。
+    document.querySelectorAll('#episode-list-inline .project-group').forEach(group => {
+        if (String(group.dataset.projectId) !== String(projectId)) return;
+        const collapsed = !_expandedProjects.has(projectId);
+        group.querySelector('.project-body')?.classList.toggle('hidden', collapsed);
+        group.querySelector('.project-caret')
+            ?.setAttribute('icon', collapsed ? 'ant-design:right-outlined' : 'ant-design:down-outlined');
+    });
+}
+
+// Apply small action results locally so the list responds immediately. The
+// server remains authoritative; a coalesced silent refresh reconciles state
+// after the filesystem-backed hierarchy has caught up.
+function renderEpisodeListFromMemory() {
+    // updateTaskFilter 可能清掉已失效的 filter-task,所以要在取视图之前调用。
+    updateTaskFilter(visibleEpisodesForCurrentView());
+    updateEpisodeListCount(allEpisodes, '', document.getElementById('filter-task')?.value || '');
+    renderEpisodeCards();
+}
+
+function removeEpisodeFromLocalList(episodeId) {
+    const id = String(episodeId);
+    selectedEpisodes.delete(id);
+    _hierarchyRev++;
+    hierarchyData.forEach(node => {
+        node.episodes = (node.episodes || []).filter(ep => String(ep.id) !== id);
+    });
+    allEpisodes = allEpisodes.filter(ep => String(ep.id) !== id);
+    renderEpisodeListFromMemory();
+}
+
+function updateEpisodeInLocalList(episodeId, patch) {
+    const id = String(episodeId);
+    _hierarchyRev++;
+    hierarchyData.forEach(node => {
+        const ep = (node.episodes || []).find(item => String(item.id) === id);
+        if (ep) Object.assign(ep, patch);
+    });
+    const flat = allEpisodes.find(ep => String(ep.id) === id);
+    if (flat) Object.assign(flat, patch);
+    renderEpisodeListFromMemory();
+}
+
+function scheduleSilentEpisodeRefresh(delay = 1200) {
+    clearTimeout(_silentReloadTimer);
+    _silentReloadTimer = setTimeout(() => {
+        _silentReloadTimer = null;
+        loadEpisodes({ silent: true });
+    }, delay);
+}
+
+function toggleTaskCollapse(taskId) {
+    if (_collapsedTasks.has(taskId)) _collapsedTasks.delete(taskId);
+    else _collapsedTasks.add(taskId);
+    renderEpisodeListFromMemory();
+}
+
+function episodeCardHtml(ep, taskName) {
+    const activeClass = currentEpisodeId === ep.id ? 'active' : '';
+    // 前端入队标记(点击后立即显示)或后端真实状态(静默刷新后保持显示)
+    const isWorkflowQueued = ep._uiWorkflowState === 'queued' || ep.status === 'processing';
+    // AI 标注运行中:整批数据等标注完成后才允许查看
+    const isAiAnnotating = !isWorkflowQueued && ep.ai_quality_status === 'running';
+    const cardClass = (isWorkflowQueued || isAiAnnotating)
+        ? 'cursor-default opacity-80'
+        : 'cursor-pointer';
+    const cardClick = (isWorkflowQueued || isAiAnnotating)
+        ? '' : `onclick="selectEpisode('${ep.id}')"`;
+    const isReviewed = ep.status === 'reviewed' || ep.status === 'approved';
+    const isFailed = ep.status === 'failed';
+    const statusDot = (isWorkflowQueued || isAiAnnotating)
+        ? '<span class="inline-block w-2 h-2 rounded-full bg-blue-400 mr-1"></span>'
+        : (isFailed
+        ? '<span class="inline-block w-2 h-2 rounded-full bg-red-400 mr-1"></span>'
+        : (isReviewed
+            ? '<span class="inline-block w-2 h-2 rounded-full bg-green-400 mr-1"></span>'
+            : '<span class="inline-block w-2 h-2 rounded-full bg-yellow-400 mr-1"></span>'));
+    const statusText = isWorkflowQueued ? t('processing')
+        : (isAiAnnotating ? t('ai_annotating')
+        : (isFailed ? t('stat_failed') : (isReviewed ? t('reviewed') : t('reviewing'))));
+    const statusColor = (isWorkflowQueued || isAiAnnotating) ? 'text-blue-400'
+        : (isFailed ? 'text-red-400' : (isReviewed ? 'text-green-400' : 'text-yellow-400'));
+    const cameraCount = (ep.camera_names || []).length;
+    const timestamp = ep.timestamp || '';
+    const time = timestamp ? timestamp : new Date(ep.created_at).toLocaleDateString('zh-CN');
+
+    const checked = selectedEpisodes.has(ep.id) ? 'checked' : '';
+    const checkbox = (isReviewed && selectMode)
+        ? `<input type="checkbox" class="batch-checkbox w-3.5 h-3.5 rounded accent-blue-600 flex-shrink-0"
+                  data-episode-id="${ep.id}" ${checked}
+                  onclick="event.stopPropagation();toggleBatchSelect('${ep.id}', this.checked)">`
+        : '';
+
+    const isAnnotationPage = window.EGODATA_PAGE_MODE === 'annotation';
+    const statusFilter = document.getElementById('filter-status')?.value
+        || new URLSearchParams(document.location.search).get('status')
+        || 'completed';
+    const isReviewingMode = statusFilter === 'completed' || statusFilter === 'to_review';
+    const userRole = String(window.__EGO_USER__?.role || '').toLowerCase();
+    const canReprocess = userRole === 'admin' || userRole === 'engineer';
+    // processing(含前端入队标记)显示禁用的"处理中"状态按钮,不要求角色;
+    // 主动重跑按钮仍只对 admin/engineer 开放且要求 completed/to_review。
+    const workflowButton = !isAnnotationPage && isReviewingMode
+        ? (isWorkflowQueued
+            ? `<button disabled
+                       class="mt-1.5 w-full bg-blue-950/60 text-blue-300/80 text-xs px-3 py-1 rounded cursor-wait">
+                       <iconify-icon icon="ant-design:loading-outlined" class="icon-sm"></iconify-icon> ${t('processing')}</button>`
+            : (canReprocess && (ep.status === 'completed' || ep.status === 'to_review')
+                ? `<button onclick="event.stopPropagation();reprocessEpisode('${ep.id}')"
+                     title="Re-run the bound workflow for this episode"
+                     class="mt-1.5 w-full bg-purple-900/70 hover:bg-purple-800 text-purple-200 text-xs px-3 py-1 rounded">
+                     <iconify-icon icon="ant-design:tool-outlined" class="icon-sm"></iconify-icon> ${t('reprocess')}</button>`
+                : ''))
+        : '';
+    const buttons = isAnnotationPage ? '' : (isFailed
+        ? `<div class="flex gap-2">
+             <button onclick="event.stopPropagation();retryEpisode('${ep.id}')"
+                     class="bg-blue-800 hover:bg-blue-700 text-blue-200 text-xs px-3 py-1 rounded flex-1"><iconify-icon icon="ant-design:reload-outlined" class="icon-sm"></iconify-icon> ${t('retry_review')}</button>
+             <button onclick="event.stopPropagation();deleteEpisode('${ep.id}')"
+                     class="bg-gray-800 hover:bg-red-900 text-gray-400 hover:text-red-300 text-xs px-3 py-1 rounded flex-1"><iconify-icon icon="ant-design:delete-outlined" class="icon-sm"></iconify-icon> ${t('delete')}</button>
+           </div>`
+        : (isReviewed
+            ? `<div class="flex gap-2">
+                 <button onclick="event.stopPropagation();downloadEpisode('${ep.id}')"
+                         title="${t('export_hint')}"
+                         class="bg-blue-800 hover:bg-blue-700 text-blue-200 text-xs px-3 py-1 rounded flex-1"><iconify-icon icon="ant-design:export-outlined" class="icon-sm"></iconify-icon> ${t('export')}</button>
+                 <button onclick="event.stopPropagation();unreviewEpisode('${ep.id}')"
+                         class="bg-yellow-800 hover:bg-yellow-700 text-yellow-200 text-xs px-3 py-1 rounded flex-1"><iconify-icon icon="ant-design:rollback-outlined" class="icon-sm"></iconify-icon> ${t('unreview')}</button>
+               </div>`
+            : `<div class="flex gap-2">
+                 <button onclick="event.stopPropagation();markReviewed('${ep.id}')"
+                         class="bg-green-800 hover:bg-green-700 text-green-200 text-xs px-3 py-1 rounded flex-1"><iconify-icon icon="ant-design:check-outlined" class="icon-sm"></iconify-icon> ${t('approve')}</button>
+                 <button onclick="event.stopPropagation();deleteEpisode('${ep.id}')"
+                         class="bg-gray-800 hover:bg-red-900 text-gray-400 hover:text-red-300 text-xs px-3 py-1 rounded"><iconify-icon icon="ant-design:delete-outlined" class="icon-sm"></iconify-icon></button>
+               </div>${workflowButton}`));
+
+    return `
+    <div class="episode-card ${activeClass} p-3 border-b border-gray-800 hover:bg-gray-800/50 ${cardClass} flex gap-2"
+         data-episode-id="${ep.id}"
+         ${cardClick}
+         ${isWorkflowQueued ? `title="${t('processing')}"` : ''}>
+        ${checkbox}
+        <div class="flex-1 min-w-0">
+        <div class="flex items-center gap-1.5 mb-2">
+            ${statusDot}
+            <span class="text-xs ${statusColor}">${statusText}</span>
+        </div>
+        <div class="flex items-center gap-1.5 mb-1">
+            ${typeof ep.episode_index === 'number'
+                ? `<div class="text-sm font-semibold text-blue-300 truncate" title="${ep.name || ''}">#${ep.episode_index}</div>`
+                : `<div class="text-sm truncate text-gray-200">${ep.name || taskName || ep.id.slice(0, 8)}</div>`}
+        </div>
+        <div class="text-xs text-gray-500 space-y-0.5 mb-2">
+            <div><iconify-icon icon="ant-design:field-time-outlined" class="icon-sm"></iconify-icon> ${ep.fps || 30}FPS · ${ep.frame_count || 0}${t('frame')}</div>
+            ${cameraCount > 0 ? `<div><iconify-icon icon="ant-design:video-camera-outlined" class="icon-sm"></iconify-icon> ${cameraCount} ${t('cameras')}</div>` : ''}
+            <div><iconify-icon icon="ant-design:calendar-outlined" class="icon-sm"></iconify-icon> ${time}</div>
+        </div>
+        ${buttons}
+        </div>
+    </div>`;
+}
+
+
+// ── Back to list ─────────────────────────────────────
+
+function backToList() {
+    // Closing detail must release decoders, 3D canvases, timers, sockets and
+    // in-flight media requests. Hiding the panel alone leaves the old video
+    // workload alive behind Reviewing/Approved and makes the next click lag.
+    if (typeof clearEpisodeWorkspace === 'function') clearEpisodeWorkspace();
+    const detail = document.getElementById('episode-detail');
+    const listSection = document.getElementById('episode-list-section');
+    if (detail) detail.classList.add('hidden');
+    if (listSection) listSection.classList.remove('hidden');
+    // 返回批次列表 → 隐藏漂浮预览控件(点开视频后才有)
+    if (typeof setPreviewPanelsVisible === 'function') setPreviewPanelsVisible(false);
+    const warning = document.getElementById('input-warning-banner');
+    if (warning) {
+        warning.classList.add('hidden');
+        warning.innerHTML = '';
+    }
+}
+
+function renderInputWarning(ep) {
+    const warning = document.getElementById('input-warning-banner');
+    if (!warning) return;
+    const missing = [];
+    const matched = [];
+    (ep.exceptions || []).filter(ex => ex.kind === 'input_missing').forEach(ex => {
+        (ex.missing || []).forEach(value => {
+            if (!missing.includes(String(value))) missing.push(String(value));
+        });
+        (ex.matched || []).forEach(value => {
+            if (!matched.includes(String(value))) matched.push(String(value));
+        });
+    });
+    if (!missing.length) {
+        warning.classList.add('hidden');
+        warning.innerHTML = '';
+        return;
+    }
+    warning.innerHTML =
+        '<div class="flex items-start gap-2">' +
+            '<iconify-icon icon="ant-design:warning-filled" class="text-amber-300 text-base flex-shrink-0 mt-0.5"></iconify-icon>' +
+            '<div class="min-w-0">' +
+                '<div class="font-medium text-amber-100">' + escHtml(t('input_missing_title')) + '</div>' +
+                '<div class="mt-0.5 text-amber-300/90">' + escHtml(t('input_missing_detail')) + '</div>' +
+                '<div class="mt-1 font-mono break-words">' + escHtml(missing.join(', ')) + '</div>' +
+                (matched.length ? '<div class="mt-1 text-emerald-300/90">✓ ' + escHtml(matched.join(', ')) + '</div>' : '') +
+            '</div>' +
+        '</div>';
+    warning.classList.remove('hidden');
+}
+
+// ── Batch selection ──────────────────────────────────
+
+function toggleBatchSelect(episodeId, checked) {
+    const id = String(episodeId);
+    if (checked) selectedEpisodes.add(id);
+    else selectedEpisodes.delete(id);
+    // 只同步这一行与它所属项目的三态框 —— 不重算筛选、不重建列表。
+    const card = document.querySelector(
+        `#episode-list-inline .episode-card[data-episode-id="${CSS.escape(id)}"]`);
+    card?.classList.toggle('selected', checked);
+    const group = card?.closest('.project-group');
+    if (group) syncProjectSelectBox(group);
+    updateBatchUI();
+}
+
+
+function toggleSelectAll(checked) {
+    if (!selectMode) return;
+    if ((document.getElementById('filter-status')?.value || '') !== 'reviewed') return;
+
+    currentView().reviewedIds.forEach(id => {
+        if (checked) selectedEpisodes.add(id);
+        else selectedEpisodes.delete(id);
+    });
+    // 直接写已渲染的 checkbox,不重建整个列表。
+    document.querySelectorAll('#episode-list-inline input.batch-checkbox').forEach(box => {
+        box.checked = selectedEpisodes.has(String(box.dataset.episodeId));
+        box.closest('.episode-card')?.classList.toggle('selected', box.checked);
+    });
+    syncProjectSelectDom();
+    updateBatchUI();
+}
+
+
+function updateBatchUI() {
+    const selectAllBar = document.getElementById('select-all-bar');
+    const batchBar = document.getElementById('batch-bar');
+    const selectBtn = document.getElementById('btn-toggle-select');
+    const statusFilter = document.getElementById('filter-status')?.value || '';
+    const isReviewedMode = statusFilter === 'reviewed';
+    const showSelection = selectMode && isReviewedMode;
+
+    // 「Select」只在非选择模式出现 —— 进入选择模式后由批量栏里的 Cancel 接管。
+    if (selectBtn) {
+        selectBtn.classList.toggle('hidden', !isReviewedMode || selectMode);
+    }
+    // Force-exit selection mode when switching away from Reviewed
+    if (!isReviewedMode && selectMode) {
+        selectMode = false;
+        selectedEpisodes.clear();
+    }
+
+    if (selectAllBar) {
+        selectAllBar.classList.toggle('hidden', !showSelection);
+    }
+    // 批量栏只要在选择模式就显示(哪怕一集都没选)—— 否则 Cancel 没地方放。
+    if (batchBar) {
+        batchBar.classList.toggle('hidden', !showSelection);
+    }
+    if (!showSelection) {
+        if (!selectMode) selectedEpisodes.clear();
+        return;
+    }
+
+    // Update counts
+    const view = currentView();
+    const reviewedCount = view.reviewedIds.length;
+    const selCount = view.reviewedIds.filter(id => selectedEpisodes.has(id)).length;
+
+    const selectCount = document.getElementById('select-count');
+    if (selectCount) selectCount.textContent = `(${selCount}/${reviewedCount})`;
+
+    const selectAllCb = document.getElementById('select-all-checkbox');
+    if (selectAllCb) {
+        selectAllCb.checked = reviewedCount > 0 && selCount === reviewedCount;
+        selectAllCb.indeterminate = selCount > 0 && selCount < reviewedCount;
+    }
+
+    // 选中规模:让用户在点之前知道这一下要跑多久 —— 打包下载是秒级原样 zip,
+    // 导出数据集是整库重建(实测约 30 秒/集)。
+    let frames = 0;
+    view.reviewedIds.forEach(id => {
+        if (selectedEpisodes.has(id)) frames += view.framesById.get(id) || 0;
+    });
+    const batchCount = document.getElementById('batch-count');
+    if (batchCount) {
+        batchCount.textContent = t('batch_selected_summary')
+            .replace('%s', String(selCount))
+            .replace('%f', frames.toLocaleString());
+    }
+    const exportBtnLabel = document.getElementById('batch-export-label');
+    if (exportBtnLabel) {
+        const minutes = Math.max(1, Math.round(selCount * 30 / 60));
+        exportBtnLabel.textContent = selCount >= 5
+            ? `${t('batch_export_dataset')} ~${minutes}${t('minutes_short')}`
+            : t('batch_export_dataset');
+    }
+    // 一集都没选时两个动作按钮禁用(Cancel 仍可点,否则退不出去)。
+    const exportBtn = document.getElementById('batch-export-btn');
+    if (exportBtn) exportBtn.disabled = selCount === 0;
+    const zipBtn = document.getElementById('batch-zip-btn');
+    if (zipBtn) zipBtn.disabled = selCount === 0;
+}
+
+
+// 导出数据集:合并成一个可训练数据集。整库重建 —— 每路视频重编码、
+// 逐帧重采样、全量重算 stats,实测约 30 秒/集。
+async function batchDownload(button = null) {
+    if (selectedEpisodes.size === 0) return;
+    const ids = Array.from(selectedEpisodes);
+    const done = await startReviewExport(ids, null, null, button);
+    if (done && selectMode) toggleSelectMode();
+}
+
+// 打包下载:每集一个目录原样 zip,不重建,秒级返回。
+// 用原生表单提交而非 fetch + blob —— 浏览器自己流式写盘,不会把整个
+// zip 缓冲进内存(几十集的包很容易上 GB)。
+function batchZipDownload(button = null) {
+    if (selectedEpisodes.size === 0) return;
+    const form = document.createElement('form');
+    form.method = 'POST';
+    form.action = '/api/v1/export/batch-download';
+    form.style.display = 'none';
+    const field = document.createElement('input');
+    field.type = 'hidden';
+    field.name = 'episode_ids';
+    field.value = Array.from(selectedEpisodes).join(',');
+    form.appendChild(field);
+    document.body.appendChild(form);
+    form.submit();
+    form.remove();
+    if (button) button.blur();
+}
+
+
+function waitForExportJob(jobId, button) {
+    const originalHtml = button ? button.innerHTML : null;
+    return new Promise(resolve => {
+        const poll = async () => {
+            try {
+                const res = await fetch(`/api/v1/export/${jobId}`);
+                const job = await res.json();
+                if (job.status === 'completed') {
+                    resolve(true);
+                    return;
+                }
+                if (job.status === 'failed') {
+                    alert('Export failed: ' + (job.error || 'unknown'));
+                    resolve(false);
+                    return;
+                }
+                if (button) {
+                    // 导出期间按钮直接显示百分比进度,不再静默等待
+                    const pct = Math.round((Number(job.progress) || 0) * 100);
+                    button.textContent = 'Exporting… ' + pct + '%';
+                }
+            } catch (err) {
+                alert('Export status failed: ' + err.message);
+                resolve(false);
+                return;
+            }
+            setTimeout(poll, 800);
+        };
+        poll();
+    }).finally(() => {
+        if (button) {
+            if (originalHtml !== null) button.innerHTML = originalHtml;
+            button.disabled = false;
+            button.dataset.exporting = '';
+            button.classList.remove('opacity-60', 'cursor-wait');
+        }
+    });
+}
+
+
+async function startReviewExport(ids, format, datasetName, button = null) {
+    if (!ids || ids.length === 0) return false;
+    if (button) {
+        button.disabled = true;
+        button.dataset.exporting = '1';
+        button.classList.add('opacity-60', 'cursor-wait');
+    }
+    try {
+        const payload = {
+            episode_ids: ids,
+            split_ratio: 0.9,
+        };
+        if (datasetName) payload.dataset_name = datasetName;
+        // Normal review-page exports omit the format deliberately: the
+        // backend resolves it from the selected project's workflow node.
+        if (format) payload.export_format = format;
+        const res = await fetch('/api/v1/export/start', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(payload),
+        });
+        if (!res.ok) {
+            const err = await res.json().catch(() => ({}));
+            alert('Export failed: ' + (err.detail || 'unknown'));
+            if (button) {
+                button.disabled = false;
+                button.dataset.exporting = '';
+                button.classList.remove('opacity-60', 'cursor-wait');
+            }
+            return false;
+        }
+        const job = await res.json();
+        const done = await waitForExportJob(job.id, button);
+        if (done) {
+            window.location.href = `/api/v1/export/download/${job.id}`;
+            return true;
+        }
+        return false;
+    } catch (err) {
+        alert('Export failed: ' + err.message);
+        if (button) {
+            button.disabled = false;
+            button.dataset.exporting = '';
+            button.classList.remove('opacity-60', 'cursor-wait');
+        }
+        return false;
+    }
+}
+
+
+// ── Select / Info Panel ──────────────────────────────
+
+function showAiPendingGate(episodeId) {
+    // 全屏等待遮罩:AI 标注未完成时批次数据不可查看。每 4 秒轮询层级
+    // 接口,标注结束(非 running)后自动移除遮罩并重新进入批次。
+    const listSection = document.getElementById('episode-list-section');
+    const detail = document.getElementById('episode-detail');
+    if (listSection) listSection.classList.add('hidden');
+    if (detail) detail.classList.remove('hidden');
+    let overlay = document.getElementById('ai-pending-overlay');
+    if (!overlay) {
+        overlay = document.createElement('div');
+        overlay.id = 'ai-pending-overlay';
+        overlay.className = 'fixed inset-0 z-[999] flex flex-col items-center justify-center gap-3 bg-black/85';
+        document.body.appendChild(overlay);
+    }
+    overlay.innerHTML = `
+        <!-- 图标须取自 iconify-preload.js 白名单(loading-3-quarters-outlined
+             不在表内,会走 api.iconify.design → 遮罩出现时卡一下)。
+             用表内的 loading-outlined,配合 animate-spin 视觉一致。 -->
+        <iconify-icon icon="ant-design:loading-outlined" class="text-blue-400 text-4xl animate-spin"></iconify-icon>
+        <div class="text-gray-200 text-sm">${t('ai_annotating')}</div>
+        <div class="text-gray-500 text-xs">${t('ai_annotating_hint')}</div>`;
+    if (overlay.dataset.polling === '1') return;
+    overlay.dataset.polling = '1';
+    (async function poll() {
+        for (let i = 0; i < 300; i++) {  // 最多约 20 分钟
+            await new Promise(resolve => setTimeout(resolve, 4000));
+            try {
+                const res = await fetch('/api/v1/projects/hierarchy');
+                if (!res.ok) continue;
+                const data = await res.json();
+                const projects = Array.isArray(data)
+                    ? data : (data && data.projects) || [];
+                let done = false;
+                for (const projectNode of projects) {
+                    const hit = (projectNode.episodes || [])
+                        .find(e => e.id === episodeId);
+                    if (!hit) continue;
+                    if (hit.ai_quality_status !== 'running') {
+                        done = true;  // passed / failed / null → 可查看
+                    } else if (hit.status === 'processing') {
+                        done = true;  // 回到 processing,由现有门禁接管
+                    }
+                    break;
+                }
+                if (done) {
+                    overlay.dataset.polling = '';
+                    overlay.remove();
+                    if (typeof selectEpisode === 'function') {
+                        selectEpisode(episodeId);
+                    }
+                    return;
+                }
+            } catch (_) { /* 网络抖动,继续轮询 */ }
+        }
+        overlay.dataset.polling = '';
+        overlay.remove();
+        if (typeof backToList === 'function') backToList();
+    })();
+}
+
+function selectEpisode(episodeId) {
+    const ep = allEpisodes.find(e => e.id === episodeId);
+    if (!ep) return;
+    // Reprocessing keeps the list card visible, but its previous artifacts are
+    // no longer a valid review target. Do not reopen stale media while the
+    // worker is replacing the processed output.
+    if (ep.status === 'processing' || ep._uiWorkflowState === 'queued') {
+        backToList();
+        return;
+    }
+    // AI 标注运行中:整批数据等标注完成后才显示(全屏等待遮罩 + 轮询,
+    // 完成后自动载入)。
+    if (ep.ai_quality_status === 'running') {
+        showAiPendingGate(episodeId);
+        return;
+    }
+
+    // Annotation is a separate workspace: start every selected file with a
+    // clean editor while leaving the review page's approval flow untouched.
+    if (window.EGODATA_PAGE_MODE === 'annotation' && typeof hideAnnotationForm === 'function') {
+        hideAnnotationForm();
+    }
+
+    // Highlight card
+    document.querySelectorAll('.episode-card').forEach(el => el.classList.remove('active'));
+    const card = document.querySelector('.episode-card[data-episode-id="' + episodeId + '"]');
+    if (card) card.classList.add('active');
+
+    // Load video
+    const cameras = ep.camera_names || [];
+    const playbackMeta = { frameCount: ep.frame_count, fps: ep.fps };
+    if (typeof loadGroupedEpisodeVideo === 'function') {
+        loadGroupedEpisodeVideo(episodeId, cameras, {
+            hasSkeleton: Boolean(ep.has_skeleton),
+            ...playbackMeta,
+        });
+    } else {
+        loadEpisodeVideo(episodeId, cameras, playbackMeta);
+    }
+
+    // Switch to detail view: hide list, show detail panel
+    const listSection = document.getElementById('episode-list-section');
+    const detail = document.getElementById('episode-detail');
+    if (listSection) listSection.classList.add('hidden');
+    if (detail) detail.classList.remove('hidden');
+    // 进入批次详情(审核/通过/标注页)→ 显示漂浮预览控件
+    if (typeof setPreviewPanelsVisible === 'function') setPreviewPanelsVisible(true);
+    renderInputWarning(ep);
+
+    // Fill detail header
+    const nameEl = document.getElementById('detail-episode-name');
+    if (nameEl) {
+        const episodeNumber = typeof ep.episode_index === 'number'
+            ? `#${ep.episode_index}` : '';
+        const title = ep.task_description || ep.name || ep.id.slice(0, 8);
+        nameEl.textContent = episodeNumber ? `${episodeNumber} · ${title}` : title;
+        nameEl.title = ep.id || title;
+    }
+    const statusBadge = document.getElementById('detail-status-badge');
+    if (statusBadge) {
+        const isReviewed = ep.status === 'reviewed' || ep.status === 'approved';
+        const isFailed = ep.status === 'failed';
+        const isProcessing = ep.status === 'processing';
+        statusBadge.className = 'text-xs flex-shrink-0 ' + (isFailed ? 'text-red-400' : (isReviewed ? 'text-green-400' : (isProcessing ? 'text-blue-400' : 'text-yellow-400')));
+        statusBadge.textContent = isFailed ? t('stat_failed') : (isReviewed ? t('reviewed') : (isProcessing ? t('processing') : t('reviewing')));
+    }
+
+    // Fill detail info
+    const infoDiv = document.getElementById('episode-detail-info');
+    const meta = ep.meta || {};
+    const timestamp = meta.timestamp || '';
+    const time = timestamp || new Date(ep.created_at).toLocaleString('zh-CN');
+    const isReviewed = ep.status === 'reviewed' || ep.status === 'approved';
+    const isFailed = ep.status === 'failed';
+    const duration = ep.fps > 0 ? (ep.frame_count / ep.fps).toFixed(1) : '0';
+    const cameraList = (ep.camera_names || []).join(', ');
+
+    let cleaningHTML = '';
+    if (ep.cleaning_report) {
+        const cr = ep.cleaning_report;
+        if (cr.passed) {
+            cleaningHTML = '<div class="flex items-center gap-1 text-green-400 text-xs"><iconify-icon icon="ant-design:check-circle-filled" class="icon-sm"></iconify-icon> Cleaning passed</div>';
+        } else {
+            const failList = (cr.checks || []).filter(c => !c.passed).map(c => c.name).join(', ');
+            cleaningHTML = '<div class="flex items-center gap-1 text-red-400 text-xs" title="' + failList + '"><iconify-icon icon="ant-design:warning-filled" class="icon-sm"></iconify-icon> Cleaning failed</div>';
+        }
+    }
+
+    // 上传不匹配/运行失败异常:点击文件后在此详情显示(不在项目列表显示)
+    let exceptionHTML = '';
+    if (ep.exceptions && ep.exceptions.length) {
+        exceptionHTML = ep.exceptions.map(function (ex) {
+            const kindLabel = ex.kind === 'run_failed'
+                ? t('exception_kind_failed')
+                : (ex.kind === 'input_missing' ? t('exception_kind_missing') : t('exception_kind_mismatch'));
+            const safeMsg = escHtml(ex.message || '');
+            const msg = safeMsg ? ': ' + safeMsg : '';
+            const color = ex.kind === 'input_missing' ? 'text-amber-300' : 'text-red-400';
+            return '<div class="flex items-center gap-1 ' + color + ' text-xs" title="' + safeMsg + '">' +
+                '<iconify-icon icon="ant-design:warning-filled" class="icon-sm"></iconify-icon> ' + kindLabel + msg + '</div>';
+        }).join('');
+    }
+
+    const isAnnotationPage = window.EGODATA_PAGE_MODE === 'annotation';
+    const buttons = isAnnotationPage ? '' : (isFailed
+        ? '<button onclick="retryEpisode(\'' + ep.id + '\')" class="flex-1 bg-blue-800 hover:bg-blue-700 text-blue-200 py-1.5 rounded text-xs"><iconify-icon icon="ant-design:reload-outlined" class="icon-sm"></iconify-icon> ' + t('retry_review') + '</button>' +
+          '<button onclick="deleteEpisode(\'' + ep.id + '\')" class="bg-gray-800 hover:bg-red-900 text-gray-400 hover:text-red-300 py-1.5 px-3 rounded text-xs"><iconify-icon icon="ant-design:delete-outlined" class="icon-sm"></iconify-icon></button>'
+        : (ep.status === 'processing'
+        ? '<button disabled class="flex-1 bg-blue-950/60 text-blue-300/80 py-1.5 rounded text-xs cursor-wait"><iconify-icon icon="ant-design:loading-outlined" class="icon-sm"></iconify-icon> ' + t('processing') + '</button>' +
+          '<button onclick="deleteEpisode(\'' + ep.id + '\')" class="bg-gray-800 hover:bg-red-900 text-gray-400 hover:text-red-300 py-1.5 px-3 rounded text-xs"><iconify-icon icon="ant-design:delete-outlined" class="icon-sm"></iconify-icon></button>'
+        : (isReviewed
+        ? '<button onclick="downloadEpisode(\'' + ep.id + '\')" title="' + t('export_hint') + '" class="flex-1 bg-blue-800 hover:bg-blue-700 text-blue-200 py-1.5 rounded text-xs"><iconify-icon icon="ant-design:export-outlined" class="icon-sm"></iconify-icon> ' + t('export') + '</button>' +
+          '<button onclick="unreviewEpisode(\'' + ep.id + '\')" class="flex-1 bg-yellow-800 hover:bg-yellow-700 text-yellow-200 py-1.5 rounded text-xs"><iconify-icon icon="ant-design:rollback-outlined" class="icon-sm"></iconify-icon> ' + t('unreview') + '</button>'
+        : '<button onclick="markReviewed(\'' + ep.id + '\')" class="flex-1 bg-green-700 hover:bg-green-600 text-white py-1.5 rounded text-xs font-medium"><iconify-icon icon="ant-design:check-outlined" class="icon-sm"></iconify-icon> ' + t('approve') + '</button>' +
+          '<button onclick="deleteEpisode(\'' + ep.id + '\')" class="bg-gray-800 hover:bg-red-900 text-gray-400 hover:text-red-300 py-1.5 px-3 rounded text-xs"><iconify-icon icon="ant-design:delete-outlined" class="icon-sm"></iconify-icon></button>')));
+
+    if (infoDiv) {
+        infoDiv.innerHTML =
+            '<div class="space-y-1.5 text-xs">' +
+                (cleaningHTML || '') +
+                (exceptionHTML || '') +
+                '<div class="text-gray-500 space-y-0.5">' +
+                    '<div><iconify-icon icon="ant-design:field-time-outlined" class="icon-sm"></iconify-icon> ' + ep.frame_count + ' frames · ' + ep.fps + ' FPS · ' + duration + 's</div>' +
+                    (cameraList ? '<div><iconify-icon icon="ant-design:video-camera-outlined" class="icon-sm"></iconify-icon> ' + cameraList + '</div>' : '') +
+                    '<div><iconify-icon icon="ant-design:calendar-outlined" class="icon-sm"></iconify-icon> ' + time + '</div>' +
+                    '<div id="episode-detail-sync-status" class="hidden"></div>' +
+                    '<div id="episode-detail-ai-status" class="hidden"></div>' +
+                '</div>' +
+                '<div class="flex items-center gap-2 bg-gray-800 rounded px-3 py-1.5">' +
+                    '<span class="text-gray-500">Frame</span>' +
+                    '<span id="heatmap-frame" class="text-blue-400 font-mono font-bold text-lg">-</span>' +
+                    '<span class="text-gray-600">/ ' + ep.frame_count + '</span>' +
+                '</div>' +
+                '<div class="flex gap-2">' + buttons + '</div>' +
+                '<div id="episode-detail-format"></div>' +
+            '</div>';
+        if (typeof updateEpisodeDetailSyncStatus === 'function') updateEpisodeDetailSyncStatus();
+
+        // 导出格式徽标(工作流连接驱动:HDF5 / LeRobot v2.1 / v3.0 / Raw 兜底)
+        const fmtEl = document.getElementById('episode-detail-format');
+        if (fmtEl) {
+            fmtEl.innerHTML = '';
+            if (!isAnnotationPage && isReviewed) {
+                const fmtEpoch = ++_formatEpoch;
+                fetch(`/api/v1/export/episode-format/${episodeId}`)
+                    .then(r => r.json())
+                    .then(d => {
+                        if (fmtEpoch !== _formatEpoch) return;  // 已切换批次,丢弃过期响应
+                        const el = document.getElementById('episode-detail-format');
+                        if (!el) return;
+                        const label = escHtml(d.label || 'Raw');
+                        const badge = d.available
+                            ? '<span class="text-blue-300 font-medium">' + label + '</span>'
+                            : '<span class="text-gray-500">' + label + '</span>';
+                        el.innerHTML = '<div class="flex items-center gap-1 text-gray-500"><iconify-icon icon="ant-design:export-outlined" class="icon-sm"></iconify-icon> ' +
+                            t('export') + ': ' + badge +
+                            (d.available ? ' · <button id="btn-re-export" onclick="reExportEpisode()" class="text-blue-400 hover:underline text-xs">' + t('re_export') + '</button>' : '') +
+                            '</div>';
+                    })
+                    .catch(() => {});
+            }
+        }
+    }
+
+// Re-export:只重建导出,不重跑检测(复用最新 run 的检测产物 +
+// 当前工作流的导出配置/连线)。Review 详情 Export 徽标旁按钮。
+// (挂 window:inline onclick 需要全局可见)
+window.reExportEpisode = async function () {
+    if (!currentEpisodeId) return;
+    const btn = document.getElementById('btn-re-export');
+    if (!btn || btn.dataset.busy === '1') return;
+    btn.dataset.busy = '1';
+    btn.textContent = t('re_exporting') + '…';
+    let finalStatus = 'done';
+    try {
+        const res = await fetch(`/api/v1/export/re-export/${currentEpisodeId}`, { method: 'POST' });
+        if (!res.ok) throw new Error((await res.json().catch(() => ({}))).detail || res.status);
+        for (let i = 0; i < 300; i++) {
+            await new Promise(r => setTimeout(r, 1000));
+            let st = { status: 'running' };
+            try {
+                st = await (await fetch(`/api/v1/export/re-export/${currentEpisodeId}/status`)).json();
+            } catch (_) { /* keep polling */ }
+            if (st.status === 'done' || st.status === 'failed' || st.status === 'interrupted') {
+                finalStatus = st.status;
+                if (st.status !== 'done') {
+                    alert(t('re_export_failed') + ': ' + (st.detail || st.status));
+                } else {
+                    alert(t('re_export_done') + ': ' + (st.detail || ''));
+                }
+                break;
+            }
+        }
+    } catch (err) {
+        finalStatus = 'failed';
+        alert(t('re_export_failed') + ': ' + (err.message || err));
+    }
+    btn.dataset.busy = '';
+    btn.textContent = t('re_export');
+    if (finalStatus === 'done') {
+        // 刷新徽标(格式可能已变)
+        const fmtEpoch = ++_formatEpoch;
+        try {
+            const d = await (await fetch(`/api/v1/export/episode-format/${currentEpisodeId}`)).json();
+            if (fmtEpoch !== _formatEpoch || !currentEpisodeId) return;
+            const el = document.getElementById('episode-detail-format');
+            if (!el) return;
+            const label = escHtml(d.label || 'Raw');
+            const badge = d.available
+                ? '<span class="text-blue-300 font-medium">' + label + '</span>'
+                : '<span class="text-gray-500">' + label + '</span>';
+            el.innerHTML = '<div class="flex items-center gap-1 text-gray-500"><iconify-icon icon="ant-design:export-outlined" class="icon-sm"></iconify-icon> ' +
+                t('export') + ': ' + badge +
+                (d.available ? ' · <button id="btn-re-export" onclick="reExportEpisode()" class="text-blue-400 hover:underline text-xs">' + t('re_export') + '</button>' : '') +
+                '</div>';
+        } catch (_) { /* 刷新失败下次进入详情自动重取 */ }
+    }
+}
+
+    // Update frame info header
+    const frameHeader = document.getElementById('frame-info-header');
+    const totalFramesEl = document.getElementById('detail-total-frames');
+    if (frameHeader) frameHeader.classList.remove('hidden');
+    if (totalFramesEl) totalFramesEl.textContent = ep.frame_count || 0;
+
+    // Show frame controls
+    if (typeof showAnnotationUI === 'function') showAnnotationUI();
+
+    // Annotations are loaded by loadEpisodeVideo after frame data is ready
+    // (avoid race: loadAnnotations needs episodeTotalFrames from loadFrameData)
+}
+
+
+// ── Review ──────────────────────────────────────────
+
+async function markReviewed(episodeId) {
+    try {
+        const res = await fetch(`/api/v1/episode/${episodeId}/review`, { method: 'POST' });
+        if (res.ok) {
+            backToList();
+            removeEpisodeFromLocalList(episodeId);
+            scheduleSilentEpisodeRefresh();
+        }
+    } catch (err) {
+        alert('Operation failed: ' + err.message);
+    }
+}
+
+
+async function unreviewEpisode(episodeId) {
+    try {
+        const res = await fetch(`/api/v1/episode/${episodeId}/unreview`, { method: 'POST' });
+        if (res.ok) {
+            backToList();
+            removeEpisodeFromLocalList(episodeId);
+            scheduleSilentEpisodeRefresh();
+        }
+    } catch (err) {
+        alert('Operation failed: ' + err.message);
+    }
+}
+
+
+async function retryEpisode(episodeId) {
+    try {
+        const res = await fetch(`/api/v1/episode/${episodeId}/retry`, { method: 'POST' });
+        if (res.ok) {
+            backToList();
+            removeEpisodeFromLocalList(episodeId);
+            scheduleSilentEpisodeRefresh();
+        }
+    } catch (err) {
+        alert('Operation failed: ' + err.message);
+    }
+}
+
+
+// ── Reprocess(主动重新处理)──────────────────────────
+
+async function reprocessEpisode(episodeId) {
+    if (!confirm(t('confirm_reprocess'))) return;
+    // The worker will replace the canonical parquet. Do not reuse the old
+    // full depth/3D browser buffers when this episode is opened again.
+    if (typeof window.invalidateEpisodePlaybackCache === 'function') {
+        window.invalidateEpisodePlaybackCache(episodeId);
+    }
+    // Clear the old detail workspace before waiting for the queue response.
+    // Reprocessing is asynchronous; the old media must not remain active
+    // while the user navigates to another review section.
+    backToList();
+    // Mark the local snapshot before the POST resolves. This closes the small
+    // window in which a fast click could reopen the old completed artifact.
+    updateEpisodeInLocalList(episodeId, { _uiWorkflowState: 'queued' });
+    try {
+        const res = await fetch(`/api/v1/episode/${episodeId}/reprocess`, { method: 'POST' });
+        if (res.ok) {
+            scheduleSilentEpisodeRefresh();
+        } else {
+            updateEpisodeInLocalList(episodeId, { _uiWorkflowState: null });
+            const err = await res.json();
+            alert(t('reprocess_failed') + (err.detail || res.status));
+        }
+    } catch (err) {
+        updateEpisodeInLocalList(episodeId, { _uiWorkflowState: null });
+        alert(t('reprocess_failed') + err.message);
+    }
+}
+
+
+// ── Delete ──────────────────────────────────────────
+
+async function deleteEpisode(episodeId) {
+    if (!confirm(t('confirm_trash'))) return;
+
+    try {
+        const res = await fetch(`/api/v1/episode/${episodeId}/delete`, { method: 'POST' });
+        if (res.ok) {
+            updateTrashBadge();  // 垃圾桶徽标立即 +1,无需刷新页面
+            backToList();       // instant feedback — close detail, show list
+            if (currentEpisodeId === episodeId) {
+                document.getElementById('video-grid').innerHTML =
+                    '<div class="flex items-center justify-center h-64 text-gray-600">' + t('deleted_msg') + '</div>';
+                // Clear annotations
+                annotations = [];
+                if (typeof clearAnnotationOverlay === 'function') clearAnnotationOverlay();
+            }
+            removeEpisodeFromLocalList(episodeId);
+            scheduleSilentEpisodeRefresh();
+        }
+    } catch (err) {
+        alert(t('op_failed') + ': ' + err.message);
+    }
+}
+
+
+/** 从失败的响应里取出可读的失败原因。
+ *
+ * FastAPI 的 ``HTTPException`` 把原因放在 ``detail`` 里（如"Episode is not in
+ * trash"、"Episode delete verification failed: [...]"）。拿不到就退回状态码，
+ * **绝不能返回空** —— 静默的失败比报错更难查。 */
+async function apiErrorDetail(res) {
+    try {
+        const body = await res.json();
+        if (body && body.detail) return String(body.detail);
+    } catch (e) { /* 非 JSON 响应 */ }
+    return `HTTP ${res.status}`;
+}
+
+async function restoreEpisode(episodeId) {
+    try {
+        const res = await fetch(`/api/v1/episode/${episodeId}/restore`, { method: 'POST' });
+        if (res.ok) {
+            updateTrashBadge();  // 恢复后徽标立即 -1
+            loadTrashList();
+            if (typeof refreshReviewTree === 'function') refreshReviewTree();
+        } else {
+            // ★ 非 2xx 时必须发声。此前只有 if(res.ok) 一个分支 —— 后端返回
+            //   409/500 时前端什么都不做，用户看到的是"点了没反应"，也无从查起。
+            alert(t('restore_failed') + ': ' + await apiErrorDetail(res));
+        }
+    } catch (err) {
+        alert(t('restore_failed') + ': ' + err.message);
+    }
+}
+
+
+async function permanentDeleteEpisode(episodeId) {
+    if (!confirm(t('confirm_permanent'))) return;
+    try {
+        const res = await fetch(`/api/v1/episode/${episodeId}/permanent`, { method: 'DELETE' });
+        if (res.ok) {
+            updateTrashBadge();
+            loadTrashList();
+            if (typeof refreshReviewTree === 'function') refreshReviewTree();
+        } else {
+            alert(t('delete_failed') + ': ' + await apiErrorDetail(res));
+        }
+    } catch (err) {
+        alert(t('delete_failed') + ': ' + err.message);
+    }
+}
+
+
+async function purgeTrash() {
+    if (!confirm(t('confirm_purge'))) return;
+    try {
+        const res = await fetch('/api/v1/episodes/purge-trash', { method: 'POST' });
+        if (res.ok) {
+            updateTrashBadge();
+            loadTrashList();
+            if (typeof refreshReviewTree === 'function') refreshReviewTree();
+        } else {
+            alert(t('purge_failed') + ': ' + await apiErrorDetail(res));
+        }
+    } catch (err) {
+        alert(t('purge_failed') + ': ' + err.message);
+    }
+}
+
+
+// ── Export ────────────────────────────────────────────
+
+async function downloadEpisode(episodeId) {
+    // A single episode already has its workflow-published export product.
+    // That endpoint returns the version selected in the workflow export node.
+    window.location.href = `/api/v1/export/download-episode/${episodeId}`;
+}
+
+
+// ── Init ────────────────────────────────────────────
+
+document.addEventListener('DOMContentLoaded', () => {
+    // Apply data-i18n translations
+    document.querySelectorAll('[data-i18n]').forEach(el => {
+        el.textContent = t(el.dataset.i18n);
+    });
+    document.querySelectorAll('[data-i18n-placeholder]').forEach(el => {
+        el.placeholder = t(el.dataset.i18nPlaceholder);
+    });
+    // Init nav labels
+    const navReview = document.getElementById('nav-review');
+    const navTrash = document.getElementById('nav-trash');
+    if (navReview) navReview.textContent = t('video_review');
+    if (navTrash) navTrash.textContent = t('trash');
+
+    if (document.getElementById('episode-list-inline')) {
+        initStatusFromURL();
+        installReviewStatusNavigation();
+        loadEpisodes();
+        setInterval(() => { loadEpisodes({ silent: true }); updateTrashBadge(); }, 15000);
+        updateTrashBadge();
+        // 两个批量按钮的提示:说清一个是重建、一个是原样打包。
+        const exportBtn = document.getElementById('batch-export-btn');
+        if (exportBtn) exportBtn.title = t('batch_export_hint');
+        const zipBtn = document.getElementById('batch-zip-btn');
+        if (zipBtn) zipBtn.title = t('batch_zip_hint');
+    }
+    if (document.getElementById('trash-list')) {
+        loadTrashList();
+    }
+});
+
+
+async function loadTrashList() {
+    const listEl = document.getElementById('trash-list');
+    if (!listEl) return;
+
+    listEl.innerHTML = `<div class="p-4 text-center text-gray-500 text-sm">${t('loading')}</div>`;
+
+    try {
+        const res = await fetch('/api/v1/episodes?status=deleted&limit=200');
+        const data = await res.json();
+        const episodes = data.episodes || [];
+
+        if (episodes.length === 0) {
+            listEl.innerHTML = `<div class="p-8 text-center text-gray-500"><iconify-icon icon="ant-design:delete-outlined" class="icon-md"></iconify-icon> ${t('trash_empty')}</div>`;
+        } else {
+            const now = new Date();
+            listEl.innerHTML = episodes.map(ep => {
+                const delTime = new Date(ep.deleted_at);
+                const daysLeft = Math.max(0, Math.ceil(7 - (now - delTime) / (1000 * 60 * 60 * 24)));
+                const time = new Date(ep.created_at).toLocaleString('zh-CN');
+                return `
+                <div class="bg-gray-800 rounded p-4 flex items-center justify-between">
+                    <div class="flex-1">
+                        <div class="text-sm font-medium text-gray-200">${ep.task_description || ep.name || 'unknown'}</div>
+                        <div class="text-xs text-gray-500 mt-1">
+                            <iconify-icon icon="ant-design:field-time-outlined" class="icon-sm"></iconify-icon> ${ep.fps}FPS · ${ep.frame_count}${t('frame')} · <iconify-icon icon="ant-design:video-camera-outlined" class="icon-sm"></iconify-icon> ${(ep.camera_names||[]).join(', ') || t('not_found')}
+                        </div>
+                        <div class="text-xs text-gray-500"><iconify-icon icon="ant-design:calendar-outlined" class="icon-sm"></iconify-icon> ${time}</div>
+                    </div>
+                    <div class="text-xs text-gray-400 mr-4"><iconify-icon icon="ant-design:hourglass-outlined" class="icon-sm"></iconify-icon> ${t('days_left')} ${daysLeft} ${t('day_unit')}</div>
+                    <div class="flex gap-2">
+                        <button onclick="restoreEpisode('${ep.id}')"
+                                class="bg-green-700 hover:bg-green-600 text-white text-xs px-3 py-1.5 rounded"><iconify-icon icon="ant-design:rollback-outlined" class="icon-sm"></iconify-icon> ${t('restore')}</button>
+                        <button onclick="permanentDeleteEpisode('${ep.id}')"
+                                class="bg-red-800 hover:bg-red-700 text-red-200 text-xs px-3 py-1.5 rounded"><iconify-icon icon="ant-design:delete-outlined" class="icon-sm"></iconify-icon> ${t('permanent_delete')}</button>
+                    </div>
+                </div>`;
+            }).join('');
+        }
+        updateTrashBadge();
+    } catch (err) {
+        listEl.innerHTML = `<div class="p-4 text-center text-red-400 text-sm">${t('load_failed')}</div>`;
+    }
+}
+
+
+// updateTrashBadge 由 base.html 全局提供(所有页面生效),删除/恢复/清空后
+// 各操作函数调用它立即刷新徽标,无需刷新页面。
diff --git a/processor/web/static/js/dashboard.js b/processor/web/static/js/dashboard.js
index a2458f6ab1e7ffad5a12b0b3c0789c34a7748323..ec3b8cbee5097690e898b72901a03f37193e1862 100644
--- a/processor/web/static/js/dashboard.js
+++ b/processor/web/static/js/dashboard.js
@@ -28,13 +28,13 @@ function timeAgo(isoStr) {
 
 function statusBadge(status) {
     var map = {
-        'completed':  { cls: 'bg-yellow-900/50 text-yellow-400', label: 'Reviewing' },
-        'to_review':  { cls: 'bg-yellow-900/50 text-yellow-400', label: 'Reviewing' },
-        'reviewed':   { cls: 'bg-green-900/50 text-green-400',  label: 'Approved' },
-        'approved':   { cls: 'bg-green-900/50 text-green-400',  label: 'Approved' },
-        'processing': { cls: 'bg-blue-900/50 text-blue-400',    label: 'Processing' },
-        'received':   { cls: 'bg-indigo-900/50 text-indigo-400', label: 'Received' },
-        'failed':     { cls: 'bg-red-900/50 text-red-400',      label: 'Failed' },
+        'completed':  { cls: 'bg-yellow-900/50 text-yellow-400', label: t('stat_reviewing') },
+        'to_review':  { cls: 'bg-yellow-900/50 text-yellow-400', label: t('stat_reviewing') },
+        'reviewed':   { cls: 'bg-green-900/50 text-green-400',  label: t('stat_approved') },
+        'approved':   { cls: 'bg-green-900/50 text-green-400',  label: t('stat_approved') },
+        'processing': { cls: 'bg-blue-900/50 text-blue-400',    label: t('stat_processing') },
+        'received':   { cls: 'bg-indigo-900/50 text-indigo-400', label: t('stat_received') },
+        'failed':     { cls: 'bg-red-900/50 text-red-400',      label: t('stat_failed') },
     };
     var m = map[status] || { cls: 'bg-gray-800 text-gray-400', label: status || 'unknown' };
     return '<span class="text-xs px-2 py-0.5 rounded ' + m.cls + '">' + m.label + '</span>';
@@ -180,9 +180,9 @@ function renderRecent(episodes) {
     el.innerHTML = episodes.map(function(ep) {
         var cleanIcon = '';
         if (ep.cleaning_passed === false) {
-            cleanIcon = ' <iconify-icon icon="ant-design:warning-filled" class="text-red-400 icon-sm" title="Cleaning failed"></iconify-icon>';
+            cleanIcon = ' <iconify-icon icon="ant-design:warning-filled" class="text-red-400 icon-sm" title="' + t('cleaning_failed') + '"></iconify-icon>';
         } else if (ep.cleaning_passed === true) {
-            cleanIcon = ' <iconify-icon icon="ant-design:check-circle-filled" class="text-green-400 icon-sm" title="Cleaning passed"></iconify-icon>';
+            cleanIcon = ' <iconify-icon icon="ant-design:check-circle-filled" class="text-green-400 icon-sm" title="' + t('cleaning_passed') + '"></iconify-icon>';
         }
         return '<a href="/review" class="flex items-center gap-3 px-2 py-2 rounded hover:bg-gray-800/50 transition-colors text-xs border-b border-gray-800/50 last:border-0">' +
             '<span class="text-gray-300 w-24 truncate flex-shrink-0">' + (ep.task_name || '').slice(0, 18) + cleanIcon + '</span>' +
@@ -203,9 +203,9 @@ function renderDonut(reviewing, approved, failed) {
     var total = reviewing + approved + failed || 1;
 
     var segments = [
-        { value: reviewing, color: '#eab308', label: 'To Review' },  // yellow
-        { value: approved,  color: '#22c55e', label: 'Approved'  },  // green
-        { value: failed,    color: '#ef4444', label: 'Failed'    },  // red
+        { value: reviewing, color: '#eab308', label: t('stat_to_review') },  // yellow
+        { value: approved,  color: '#22c55e', label: t('stat_approved')  },  // green
+        { value: failed,    color: '#ef4444', label: t('stat_failed')    },  // red
     ];
 
     var radius = 60;
@@ -240,7 +240,7 @@ function renderDonut(reviewing, approved, failed) {
     html += '<text x="' + cx + '" y="' + (cy - 8) + '" text-anchor="middle" ' +
         'class="fill-white font-bold" style="font-size:22px">' + fmtNum(total) + '</text>';
     html += '<text x="' + cx + '" y="' + (cy + 12) + '" text-anchor="middle" ' +
-        'class="fill-gray-500" style="font-size:11px">Total</text>';
+        'class="fill-gray-500" style="font-size:11px">' + t('donut_total') + '</text>';
 
     html += '</svg>';
 
diff --git a/processor/web/static/js/i18n-data.js b/processor/web/static/js/i18n-data.js
new file mode 100644
index 0000000000000000000000000000000000000000..56286ce64072cfc60a7da8c7d0cba1bd8acbc16f
--- /dev/null
+++ b/processor/web/static/js/i18n-data.js
@@ -0,0 +1,843 @@
+// 中英词典 —— **唯一的真源**。
+//
+// 为什么单独一个文件、而不是写在 i18n.js 里:
+//   服务端渲染需要它(app/i18n.py 读这个文件),而服务端是 Python。
+//   写在 .js 里的话,Python 要么重复维护一份、要么去解析 JS 源码。
+//   这里用**合法 JSON** 作为载荷,外面只包一行赋值 —— Python 剥掉包装就能
+//   json.loads,浏览器当一个普通脚本同步加载(带 ?v= 缓存,不会每页重下)。
+//
+// 改词条只改这个文件。别在 i18n.js 里再加字面量。
+window.__I18N__ = {
+  "zh": {
+    "app_title": "processor",
+    "language": "语言",
+    "video_review": "视频审核",
+    "trash": "回收站",
+    "all_status": "全部状态",
+    "reviewing": "审核中",
+    "reviewed": "已审核",
+    "all_tasks": "全部任务",
+    "search": "搜索...",
+    "loading": "加载中...",
+    "processing": "处理中...",
+    "ai_annotating": "AI 标注处理中...",
+    "ai_annotating_hint": "AI 标注完成后自动载入本批次数据",
+    "no_data": "暂无数据",
+    "load_failed": "加载失败",
+    "select_episode": "选择一个视频开始审核 →",
+    "no_video": "此 Episode 没有视频数据",
+    "cameras": "相机",
+    "play_all": "▶ 全部播放",
+    "pause_all": "⏸ 全部暂停",
+    "play_btn": "播放",
+    "pause_btn": "暂停",
+    "layout_row": "并排",
+    "layout_grid": "网格",
+    "layout_column": "上下",
+    "no_description": "无任务描述",
+    "frame": "帧",
+    "download": "下载",
+    "export": "导出",
+    "export_hint": "按工作流导出格式下载最终数据集",
+    "re_export": "重新导出",
+    "re_exporting": "重新导出中",
+    "re_export_done": "重新导出完成",
+    "re_export_failed": "重新导出失败",
+    "delete": "删除",
+    "approve": "通过",
+    "deleted_msg": "已移入回收站",
+    "select_hint": "选择 Episode 后显示详情",
+    "trash_empty": "回收站为空",
+    "trash_title": "回收站",
+    "purge_all": "全部清空",
+    "restore": "恢复",
+    "permanent_delete": "永久删除",
+    "days_left": "剩余",
+    "day_unit": "天",
+    "confirm_trash": "确定将此视频移入回收站吗？\n7 天后自动清理。",
+    "confirm_permanent": "确定永久删除吗？此操作不可恢复！",
+    "confirm_purge": "确定清空回收站吗？所有内容将被永久删除！",
+    "op_failed": "操作失败",
+    "restore_failed": "恢复失败",
+    "delete_failed": "删除失败",
+    "purge_failed": "清空失败",
+    "export_failed": "导出失败",
+    "no_reviewed": "没有已审核的 Episode 可导出",
+    "export_created": "导出任务已创建，完成后自动下载",
+    "left_hand": "左手",
+    "right_hand": "右手",
+    "single_mono": "单目视频",
+    "glove_sensor": "手套传感器",
+    "depth_image": "深度图",
+    "aux_video": "辅助视频",
+    "skeleton_suffix": "骨骼",
+    "glove_suffix": "手套",
+    "depth_suffix": "深度",
+    "stereo_pair": "双目并排",
+    "3d_skeleton": "3D 骨骼",
+    "stereo_render": "3D 拼接",
+    "hand3d_no_data": "该帧无 3D 骨骼数据",
+    "hand3d_hand0": "手 0",
+    "hand3d_hand1": "手 1",
+    "hand3d_world": "3D 手部世界坐标",
+    "heatmap_toggle": "深度热力图",
+    "synced_ok": "同步正常",
+    "drag_here": "拖拽素材到这里",
+    "remove_source": "移除素材",
+    "video_suffix": "视频",
+    "hand_pressure": "手部压力",
+    "media_assets": "素材",
+    "drag_to_canvas": "拖拽素材到中间视频区域",
+    "raw_vs_processed": "原始视频 / 处理结果",
+    "refresh": "刷新",
+    "not_found": "未找到",
+    "deleted": "已删除",
+    "port_label": "Port",
+    "annotation": "动作标注",
+    "annotation_readonly": "只读",
+    "annotations": "标注段",
+    "new_annotation": "新增标注",
+    "edit_annotation": "编辑标注",
+    "delete_annotation": "删除标注",
+    "label_name": "标注名称",
+    "start_frame": "起始帧",
+    "end_frame": "结束帧",
+    "set_start_frame": "设起始帧",
+    "set_end_frame": "设结束帧",
+    "keyframe": "关键帧",
+    "add_keyframe": "添加关键帧",
+    "frames_covered": "帧已标注",
+    "per_frame_label": "每帧标注",
+    "no_annotations": "暂无标注，点击\"新增\"创建第一个标注段",
+    "confirm_delete_anno": "确定删除此标注段吗？",
+    "save_annotation": "保存标注",
+    "save_changes": "保存修改",
+    "slice_conflict": "此切片已在另一台电脑修改，已加载最新版本。请确认后再次保存。",
+    "current_frame": "当前帧",
+    "anno_color": "颜色",
+    "anno_frame_range": "帧范围",
+    "anno_duration": "时长",
+    "anno_keyframe_event": "关键帧事件",
+    "seconds_abbr": "s",
+    "select_all": "全选",
+    "batch_download": "批量下载",
+    "batch_export_dataset": "导出数据集 (慢)",
+    "batch_zip_download": "打包下载 (快)",
+    "batch_zip_hint": "从源数据集原样裁出所选批次 —— 产出仍是单个 LeRobot 结构(data/ + meta/ + videos/),不重建、秒级返回。只想把这批数据拿走就用这个。",
+    "batch_export_hint": "把所选批次合并成**一个**可训练数据集(需要整库重建:重编码视频 + 重算统计,约 30 秒/集)。要拿去训练才用这个。",
+    "batch_selected_summary": "已选 %s 集 · %f 帧",
+    "minutes_short": "分",
+    "select_project_all": "全选本项目(含折叠中的批次)",
+    "unreview": "撤销",
+    "retry_review": "放入审核",
+    "reprocess": "重新处理",
+    "confirm_reprocess": "重新运行该批次绑定的工作流?新产物将替换旧处理结果。",
+    "reprocess_failed": "重新处理失败: ",
+    "nav_home": "首页",
+    "nav_tasks": "项目",
+    "nav_review": "视频审核",
+    "nav_trash": "回收站",
+    "nav_workflow": "工作流",
+    "nav_users": "用户",
+    "nav_annotation": "标注",
+    "nav_model": "模型",
+    "train_tab_checkpoints": "模型输出",
+    "train_tab_params": "训练参数",
+    "train_label_model": "模型",
+    "train_label_location": "位置",
+    "train_files_unit": "个文件",
+    "train_group_train": "训练",
+    "train_group_policy": "策略 Policy",
+    "train_group_optimizer": "优化器",
+    "train_group_dataset": "数据集",
+    "train_step_badge": "步骤",
+    "train_file_details": "文件明细",
+    "train_col_name": "文件名",
+    "train_col_size": "大小",
+    "train_col_mtime": "修改时间",
+    "train_btn_download": "下载",
+    "train_btn_delete": "删除",
+    "train_btn_infer": "推理",
+    "train_btn_deploy": "离线部署",
+    "train_btn_hint_delete": "删除 checkpoint 是破坏性操作,暂不开放",
+    "train_btn_hint_download_row": "展开文件明细 —— 那里每行单独下载",
+    "train_btn_hint_infer_row": "切到「模型推理」页签并选中本检查点",
+    "train_btn_hint_deploy": "属于部署模块,本期未做",
+    "train_checkpoints_empty": "这个训练目录下没有 checkpoint。",
+    "train_params_source": "来源:",
+    "train_params_empty": "这个 checkpoint 没有 train_config.json,读不到训练参数。",
+    "train_page_runs": "模型训练",
+    "train_page_new": "新建训练",
+    "train_page_inference": "模型推理",
+    "train_new_live": "实时",
+    "train_new_pending": "待接入",
+    "train_new_model_tested": "已实测",
+    "train_new_model_act_desc": "基于 Transformer 的动作分块模仿学习模型",
+    "train_new_frames": "帧",
+    "train_new_reset": "恢复实测默认值",
+    "train_sec_dataset": "① 训练数据集",
+    "train_sec_model": "② 选择模型",
+    "train_sec_location": "③ 训练位置",
+    "train_sec_params": "④ 训练参数",
+    "train_sec_resume": "⑤ 从已有训练继续(可选)",
+    "train_loc_local": "私有算力",
+    "train_loc_local_desc": "本机显卡直连",
+    "train_gpu_unavailable": "读不到 GPU",
+    "train_gpu_unavailable_hint": "训练前请先修驱动 —— 驱动不可用时训练起不来。",
+    "train_gpu_none": "nvidia-smi 没有报告任何 GPU。",
+    "train_gpu_busy": "占用中",
+    "train_gpu_idle": "空闲",
+    "train_gpu_mem": "显存",
+    "train_gpu_util": "GPU 利用率",
+    "train_gpu_temp": "温度",
+    "train_gpu_include": "参与训练",
+    "train_framework": "训练框架",
+    "train_framework_hint": "ACT 在 LeRobot 里只有一种实现,这里没有可选项。",
+    "train_help_job_name": "这次训练的名字,会成为 checkpoint 的文件夹名 —— 取短一点、别重名。",
+    "train_help_batch": "较大的批次可以提高训练稳定性,但需要更多显存;较小的批次训练更快但可能不稳定。建议范围 1-32。",
+    "train_help_steps": "更多步数通常能提高模型性能,但可能导致过拟合。建议从 10000 开始,根据验证结果调整。",
+    "train_help_seed": "设置固定种子可以复现相同的训练结果,便于调试和比较。建议用 1000、42 等固定值。",
+    "train_help_workers": "更多工作进程可以加速数据加载,但会占用更多内存。建议设置为 CPU 核心数的 1/2 到 1 倍。",
+    "train_help_eval_freq": "设置多少步进行一次模型评估,建议设为总步数的 10%。",
+    "train_help_log_freq": "设置多少步刷新一次进度,建议 10 到 100 步。",
+    "train_help_save_ckpt": "开启后会在训练过程中保存模型检查点,便于恢复训练或部署模型。",
+    "train_help_save_freq": "设置多少步保存一次模型检查点,建议设为总步数的 30%。",
+    "train_ready_title": "已达采集上限,可以导出了",
+    "train_ready_go": "去导出",
+    "train_dataset_none": "还没有导出的数据集。",
+    "train_dataset_goto_export": "去导出已通过的集",
+    "train_episodes": "集",
+    "train_resume_none": "— 全新训练 —",
+    "train_resume_latest": "— 最新 —",
+    "train_resume_task": "源训练任务",
+    "train_resume_step": "检查点",
+    "train_no_output": "这次训练没有可展示的产物。",
+    "train_no_root": "本机没有训练产物目录",
+    "train_no_runs": "该目录下没有训练产物",
+    "train_load_failed": "读取训练产物失败",
+    "menu_profile": "个人资料",
+    "menu_change_password": "修改密码",
+    "menu_logout": "退出登录",
+    "users_title": "用户管理",
+    "users_subtitle": "管理账号、角色与账号生命周期。",
+    "users_new": "新建用户",
+    "users_total": "用户总数",
+    "users_active": "活跃用户",
+    "users_disabled_expired": "已禁用 / 已过期",
+    "status_active": "正常",
+    "status_expired": "已过期",
+    "status_disabled": "已禁用",
+    "users_disable_warning": "会临时禁止登录，但保留账号与数据，之后可再启用。",
+    "users_all_roles": "全部角色",
+    "users_all_status": "全部状态",
+    "role_admin": "管理员",
+    "role_engineer": "工程师",
+    "role_reviewer": "审核员",
+    "col_user": "用户",
+    "col_role": "角色",
+    "col_status": "状态",
+    "col_last_login": "最近登录",
+    "col_expires": "到期",
+    "col_actions": "操作",
+    "users_extend": "延期",
+    "users_extend_hint": "修改到期时间以重新启用该账号",
+    "users_disable": "禁用",
+    "users_disable_hint": "临时禁止登录，之后可再启用",
+    "users_enable": "启用",
+    "users_enable_hint": "允许该用户重新登录",
+    "users_edit": "编辑",
+    "users_edit_hint": "编辑账号",
+    "users_edit_user": "编辑用户",
+    "users_save_changes": "保存修改",
+    "users_create": "创建用户",
+    "users_delete": "删除",
+    "users_delete_hint": "永久删除该账号",
+    "users_delete_warning": "将永久删除该账号。",
+    "users_confirm_delete": "永久删除 %s？如果以后可能还要用这个账号，禁用更稳妥。",
+    "users_role_perms": "角色权限",
+    "users_perm_admin": "用户、项目、工作流、处理、审核与系统设置",
+    "users_perm_engineer": "项目、工作流、处理与审核",
+    "users_perm_reviewer": "查看数据、视频审核与标注审核",
+    "field_username": "用户名",
+    "field_email": "邮箱",
+    "field_password": "密码",
+    "field_expires_at": "到期时间",
+    "users_pw_hint": "（至少 6 个字符）",
+    "users_pw_keep": "（留空则保持原密码）",
+    "users_optional": "（可选）",
+    "users_no_found": "未找到用户",
+    "users_no_email": "无邮箱",
+    "users_never": "从未",
+    "users_count": "%s 个用户",
+    "preview_options": "预览选项",
+    "video_sources": "视频源",
+    "all": "全部",
+    "hand_skeleton": "手部骨骼",
+    "hand_trail": "手部轨迹",
+    "frame_label": "帧：",
+    "play": "播放",
+    "select": "选择",
+    "name_1_to_n": "命名 1→N",
+    "name_n_to_1": "命名 N→1",
+    "sort_label": "排序：",
+    "n_selected": "已选 %s",
+    "undo": "撤销",
+    "new_export": "新建导出",
+    "dataset_name": "数据集名称",
+    "train_ratio": "训练集占比",
+    "start_export": "开始导出",
+    "dataset": "数据集",
+    "progress": "进度",
+    "created": "创建时间",
+    "task_active": "进行中",
+    "task_paused": "已暂停",
+    "ai_status_segmenting": "切段中…",
+    "ai_status_analyzing": "VLM 分析中…",
+    "ai_status_writing": "写入…",
+    "ai_status_exporting": "写入数据集…",
+    "force_unit_mn": "力 mN",
+    "force_field_title": "接触力场（固定全幅，不可缩放）",
+    "slice_boundary_suspect": "边界可疑或标签未命中词表",
+    "anno_ai_mode_title": "AI 自动切段并提案标注（模式由工作流 AI Annotation 卡片配置决定）",
+    "overview_title": "概览",
+    "load_failed_stats": "加载统计数据失败",
+    "retry": "重试",
+    "stat_reviewing": "待审核",
+    "stat_approved": "已通过",
+    "stat_failed": "异常",
+    "stat_total": "全部",
+    "stat_to_review": "待审核",
+    "stat_distribution": "状态分布",
+    "daily_uploads": "每日上传",
+    "last_30_days": "（近 30 天）",
+    "donut_total": "总计",
+    "stat_processing": "处理中",
+    "stat_received": "已接收",
+    "cleaning_passed": "质检通过",
+    "cleaning_failed": "质检未通过",
+    "stat_anomaly": "异常",
+    "recent_episodes": "最近 Episode",
+    "view_all": "查看全部",
+    "pipeline_status": "Pipeline 状态",
+    "new_task": "新建任务",
+    "edit_task": "编辑任务",
+    "task_name": "任务名称",
+    "task_name_hint": "请使用字母/数字/下划线/中文，需与上传文件前缀匹配",
+    "task_description": "描述",
+    "claimer": "认领人",
+    "target_episodes": "目标条数",
+    "target_duration": "目标时长(秒)",
+    "fps": "帧率",
+    "save": "保存",
+    "cancel": "取消",
+    "delete_task": "删除任务",
+    "confirm_delete_task": "确定删除此任务吗？（已有采集数据将保留）",
+    "episodes": "Episodes",
+    "frames": "帧",
+    "no_frame_target": "无帧数目标",
+    "devices": "设备",
+    "online": "在线",
+    "offline": "离线",
+    "unknown": "未知",
+    "last_seen": "最近活跃",
+    "device_empty": "暂无设备接入",
+    "expand_episodes": "查看 Episodes",
+    "load_more": "加载更多",
+    "no_tasks": "暂无任务，点击\"新建任务\"创建第一个采集任务",
+    "projects_title": "项目",
+    "search_projects": "搜索项目...",
+    "new_project": "新建项目",
+    "edit_project": "编辑项目",
+    "project_name": "项目名称",
+    "bind_workflow": "绑定工作流",
+    "workflow_placeholder": "— 选择工作流 —",
+    "device_type": "设备类型",
+    "status": "状态",
+    "no_projects": "暂无项目，点击右上角「新建项目」创建",
+    "tasks_count": "任务",
+    "videos_count": "视频",
+    "ep_count": "条",
+    "upload_new": "新批次",
+    "upload_reupload": "重传",
+    "upload_total": "总上传",
+    "upload_unclassified": "历史未分类",
+    "target_unlimited": "不限",
+    "no_tasks_in_project": "该项目下暂无任务（上传数据后自动归类）",
+    "delete_project": "删除",
+    "confirm_delete_project": "确定删除项目「",
+    "confirm_delete_project_suffix": "」？项目下的任务/视频记录不会被删除。",
+    "project_saved": "保存成功",
+    "project_save_failed": "保存失败",
+    "project_delete_failed": "删除失败",
+    "project_load_failed": "加载失败",
+    "unbound_workflow": "未绑定工作流",
+    "workflow_edit": "编辑",
+    "workflow_selected": "已选 %s 个工作流",
+    "project_need_workflow": "项目设为 active 前必须先绑定至少一个工作流",
+    "new_workflow_panel": "新建工作流",
+    "new_workflow_prompt": "新工作流名称：",
+    "workflow_create_failed": "创建工作流失败",
+    "workflow_empty": "空",
+    "template_badge": "模板",
+    "project_saved_go_build": "项目已保存。是否前往工作流画布搭建/查看工作流?",
+    "status_purged": "已彻底删除",
+    "observed_inputs": "输入",
+    "exceptions_badge": "异常",
+    "exceptions": "异常",
+    "exception_kind_mismatch": "输入不匹配",
+    "exception_kind_missing": "设备数据缺失",
+    "input_missing_title": "工作流设备数据不完整",
+    "input_missing_detail": "以下设备缺失，本批次仅处理已上传设备：",
+    "exception_kind_failed": "运行失败",
+    "exception_delete": "删除异常",
+    "exception_delete_failed": "删除异常失败",
+    "anno_timeline": "标记时间轴",
+    "slice_marker": "切片标记",
+    "new_slice": "新建切片",
+    "no_slices": "暂无切片标记",
+    "no_slices_hint": "拖动时间轴后创建一个标记区间",
+    "current_slice": "当前标记",
+    "enter_slice_name": "请输入标记名称",
+    "add_slice": "添加切片",
+    "ai_annotate": "AI 标注",
+    "unnamed_slice": "未命名切片",
+    "slice_save_failed": "保存失败: ",
+    "slice_delete_failed": "删除失败: ",
+    "inf_sec_model": "① 选择模型",
+    "inf_sec_data": "② 测试数据",
+    "inf_sec_run": "③ 运行",
+    "inf_sec_result": "④ 结果",
+    "inf_label_run": "训练任务",
+    "inf_label_step": "检查点",
+    "inf_label_dataset": "测试集",
+    "inf_live": "实时",
+    "inf_pending": "待接入",
+    "inf_no_params": "这个检查点没有 train_config.json,读不到训练参数。",
+    "inf_params_from": "来源",
+    "inf_no_models": "还没有训练好的模型",
+    "inf_dataset_none": "— 选择测试集 —",
+    "inf_datasets_available": "个数据集可选",
+    "inf_no_datasets": "还没有导出的数据集 —— 先去审核页导出一份。",
+    "inf_run_btn": "运行推理",
+    "inf_run_disabled": "后端执行尚未接入",
+    "inf_run_note": "后端执行还没接 —— 这个按钮是**故意禁用**的。",
+    "inf_run_hint": "接上之后:用所选检查点在测试集上跑一遍,给出方向余弦、幅度比、夹爪 MAE 与误差曲线(eval_gui.py 那套指标)。",
+    "inf_no_result": "还没有评估结果。"
+  },
+  "en": {
+    "app_title": "processor",
+    "language": "Language",
+    "video_review": "Video Review",
+    "trash": "Trash",
+    "all_status": "All Status",
+    "reviewing": "Reviewing",
+    "reviewed": "Reviewed",
+    "all_tasks": "All Tasks",
+    "search": "Search...",
+    "loading": "Loading...",
+    "processing": "Processing...",
+    "ai_annotating": "AI annotation running...",
+    "ai_annotating_hint": "This batch becomes viewable once AI annotation finishes",
+    "no_data": "No data",
+    "load_failed": "Load failed",
+    "select_episode": "Select an episode to review →",
+    "no_video": "No video data",
+    "cameras": "Cameras",
+    "play_all": "▶ Play All",
+    "pause_all": "⏸ Pause All",
+    "play_btn": "Play",
+    "pause_btn": "Pause",
+    "layout_row": "Row",
+    "layout_grid": "Grid",
+    "layout_column": "Stack",
+    "no_description": "No description",
+    "frame": "frames",
+    "download": "Download",
+    "export": "Export",
+    "export_hint": "Download final dataset in workflow export format",
+    "re_export": "Re-export",
+    "re_exporting": "Re-exporting…",
+    "re_export_done": "Re-export done",
+    "re_export_failed": "Re-export failed",
+    "delete": "Delete",
+    "approve": "Approve",
+    "deleted_msg": "Moved to trash",
+    "select_hint": "Select an episode to view details",
+    "trash_empty": "Trash is empty",
+    "trash_title": "Trash",
+    "purge_all": "Purge All",
+    "restore": "Restore",
+    "permanent_delete": "Delete",
+    "days_left": "Remaining",
+    "day_unit": "days",
+    "confirm_trash": "Move to trash?\nAuto-cleaned after 7 days.",
+    "confirm_permanent": "Permanently delete? This cannot be undone!",
+    "confirm_purge": "Purge all trash? All items will be permanently deleted!",
+    "op_failed": "Operation failed",
+    "restore_failed": "Restore failed",
+    "delete_failed": "Delete failed",
+    "purge_failed": "Purge failed",
+    "export_failed": "Export failed",
+    "no_reviewed": "No reviewed episodes to export",
+    "export_created": "Export job created; it will download when ready",
+    "left_hand": "Left Hand",
+    "right_hand": "Right Hand",
+    "single_mono": "Single Camera",
+    "glove_sensor": "Glove Sensors",
+    "depth_image": "Depth Images",
+    "aux_video": "Aux Video",
+    "skeleton_suffix": "Skeleton",
+    "glove_suffix": "Glove",
+    "depth_suffix": "Depth",
+    "stereo_pair": "Stereo Pair",
+    "3d_skeleton": "3D Skeleton",
+    "stereo_render": "3D Side-by-Side",
+    "hand3d_no_data": "No 3D skeleton data for this frame",
+    "hand3d_hand0": "Hand 0",
+    "hand3d_hand1": "Hand 1",
+    "hand3d_world": "3D Hand World",
+    "heatmap_toggle": "Depth Heatmap",
+    "synced_ok": "Synced",
+    "drag_here": "Drag assets here",
+    "remove_source": "Remove",
+    "video_suffix": "Video",
+    "hand_pressure": "Hand Pressure",
+    "media_assets": "Assets",
+    "drag_to_canvas": "Drag assets onto the video area",
+    "raw_vs_processed": "Raw video / Processing results",
+    "refresh": "Refresh",
+    "not_found": "Not found",
+    "deleted": "Deleted",
+    "port_label": "Port",
+    "annotation": "Annotation",
+    "annotation_readonly": "Read only",
+    "annotations": "Annotations",
+    "new_annotation": "New Annotation",
+    "edit_annotation": "Edit Annotation",
+    "delete_annotation": "Delete Annotation",
+    "label_name": "Label Name",
+    "start_frame": "Start Frame",
+    "end_frame": "End Frame",
+    "set_start_frame": "Set Start",
+    "set_end_frame": "Set End",
+    "keyframe": "Keyframe",
+    "add_keyframe": "Add Keyframe",
+    "frames_covered": "frames labeled",
+    "per_frame_label": "per-frame label",
+    "no_annotations": "No annotations. Click \"+\" to create one.",
+    "confirm_delete_anno": "Delete this annotation segment?",
+    "save_annotation": "Save Annotation",
+    "save_changes": "Save Changes",
+    "slice_conflict": "This slice was changed on another computer. The latest version has been loaded.",
+    "current_frame": "Current Frame",
+    "anno_color": "Color",
+    "anno_frame_range": "Frame Range",
+    "anno_duration": "Duration",
+    "anno_keyframe_event": "Keyframe Event",
+    "seconds_abbr": "s",
+    "select_all": "Select All",
+    "batch_download": "Batch Download",
+    "batch_export_dataset": "Export dataset (slow)",
+    "batch_zip_download": "Zip download (fast)",
+    "batch_zip_hint": "Carves the selected episodes out of the source dataset as-is — still a single LeRobot structure (data/ + meta/ + videos/), no rebuild, returns in seconds. Use this to just take the data away.",
+    "batch_export_hint": "Merges the selected episodes into ONE trainable dataset (full rebuild: re-encode videos + recompute stats, ~30s/episode). Use this only for training.",
+    "batch_selected_summary": "%s episodes · %f frames",
+    "minutes_short": "min",
+    "select_project_all": "Select all in this project (including collapsed)",
+    "unreview": "Unreview",
+    "retry_review": "Re-review",
+    "reprocess": "Reprocess",
+    "confirm_reprocess": "Re-run the bound workflows for this episode? New output will replace the old processing result.",
+    "reprocess_failed": "Reprocess failed: ",
+    "nav_home": "Home",
+    "nav_tasks": "Projects",
+    "nav_review": "Video Review",
+    "nav_trash": "Trash",
+    "nav_workflow": "Workflow",
+    "nav_users": "Users",
+    "nav_annotation": "Annotation",
+    "nav_model": "Model",
+    "train_tab_checkpoints": "Model Output",
+    "train_tab_params": "Training Config",
+    "train_label_model": "Model",
+    "train_label_location": "Location",
+    "train_files_unit": "files",
+    "train_group_train": "Training",
+    "train_group_policy": "Policy",
+    "train_group_optimizer": "Optimizer",
+    "train_group_dataset": "Dataset",
+    "train_step_badge": "Step",
+    "train_file_details": "File details",
+    "train_col_name": "Name",
+    "train_col_size": "Size",
+    "train_col_mtime": "Modified",
+    "train_btn_download": "Download",
+    "train_btn_delete": "Delete",
+    "train_btn_infer": "Inference",
+    "train_btn_deploy": "Offline Deploy",
+    "train_btn_hint_delete": "Deleting a checkpoint is destructive; not exposed yet",
+    "train_btn_hint_download_row": "Expand the file list — each file downloads individually",
+    "train_btn_hint_infer_row": "Open the Inference tab with this checkpoint selected",
+    "train_btn_hint_deploy": "Belongs to the Deployment module, not built yet",
+    "train_checkpoints_empty": "No checkpoints under this run.",
+    "train_params_source": "Source:",
+    "train_params_empty": "No train_config.json in this checkpoint; parameters unavailable.",
+    "train_page_runs": "Model Training",
+    "train_page_new": "New Training",
+    "train_page_inference": "Model Inference",
+    "train_new_live": "live",
+    "train_new_pending": "not wired",
+    "train_new_model_tested": "tested",
+    "train_new_model_act_desc": "Transformer action-chunking imitation learning policy",
+    "train_new_frames": "frames",
+    "train_new_reset": "Restore measured defaults",
+    "train_sec_dataset": "1. Training Dataset",
+    "train_sec_model": "2. Model",
+    "train_sec_location": "3. Training Location",
+    "train_sec_params": "4. Training Parameters",
+    "train_sec_resume": "5. Continue From a Previous Run (optional)",
+    "train_loc_local": "Private Compute",
+    "train_loc_local_desc": "GPUs on this machine",
+    "train_gpu_unavailable": "Cannot read the GPUs",
+    "train_gpu_unavailable_hint": "Fix the driver before training — training cannot start without it.",
+    "train_gpu_none": "nvidia-smi reported no GPUs.",
+    "train_gpu_busy": "busy",
+    "train_gpu_idle": "idle",
+    "train_gpu_mem": "VRAM",
+    "train_gpu_util": "GPU util",
+    "train_gpu_temp": "Temp",
+    "train_gpu_include": "Use for training",
+    "train_framework": "Training framework",
+    "train_framework_hint": "ACT ships as a single LeRobot implementation, so there is nothing to choose here.",
+    "train_help_job_name": "Name of this run. It becomes the checkpoint folder name, so keep it short and unique.",
+    "train_help_batch": "Larger batches train more stably but need more VRAM; smaller ones are faster but less stable. Suggested 1-32.",
+    "train_help_steps": "More steps usually improve the policy but risk overfitting. Start at 10000 and adjust from validation.",
+    "train_help_seed": "A fixed seed reproduces the same run, which makes debugging and comparison possible. 1000 or 42.",
+    "train_help_workers": "More workers load data faster but use more memory. About 1/2 to 1x the CPU core count.",
+    "train_help_eval_freq": "How often to run an evaluation, in steps. About 10% of total steps.",
+    "train_help_log_freq": "How often to refresh progress, in steps. 10-100 works well.",
+    "train_help_save_ckpt": "Save checkpoints while training so a run can be resumed or deployed.",
+    "train_help_save_freq": "How often to save a checkpoint, in steps. About 30% of total steps.",
+    "train_ready_title": "Collection limit reached — ready to export",
+    "train_ready_go": "Go export",
+    "train_dataset_none": "No exported dataset yet.",
+    "train_dataset_goto_export": "Go export approved episodes",
+    "train_episodes": "episodes",
+    "train_resume_none": "— Start fresh —",
+    "train_resume_latest": "— latest —",
+    "train_resume_task": "Source run",
+    "train_resume_step": "Checkpoint",
+    "train_no_output": "This run has no artifacts to show.",
+    "train_no_root": "No training output directory on this host",
+    "train_no_runs": "No training output under this directory",
+    "train_load_failed": "Failed to load training output",
+    "menu_profile": "Profile",
+    "menu_change_password": "Change Password",
+    "menu_logout": "Logout",
+    "users_title": "User management",
+    "users_subtitle": "Manage accounts, roles and account lifecycle.",
+    "users_new": "New user",
+    "users_total": "Total users",
+    "users_active": "Active users",
+    "users_disabled_expired": "Disabled / expired",
+    "status_active": "Active",
+    "status_expired": "Expired",
+    "status_disabled": "Disabled",
+    "users_disable_warning": "blocks login temporarily and keeps the account/data; it can be enabled later.",
+    "users_all_roles": "All roles",
+    "users_all_status": "All status",
+    "role_admin": "Admin",
+    "role_engineer": "Engineer",
+    "role_reviewer": "Reviewer",
+    "col_user": "User",
+    "col_role": "Role",
+    "col_status": "Status",
+    "col_last_login": "Last login",
+    "col_expires": "Expires",
+    "col_actions": "Actions",
+    "users_extend": "Extend",
+    "users_extend_hint": "Edit the expiry date to reactivate this account",
+    "users_disable": "Disable",
+    "users_disable_hint": "Block login temporarily; can be enabled later",
+    "users_enable": "Enable",
+    "users_enable_hint": "Allow this user to log in again",
+    "users_edit": "Edit",
+    "users_edit_hint": "Edit account",
+    "users_edit_user": "Edit user",
+    "users_save_changes": "Save changes",
+    "users_create": "Create user",
+    "users_delete": "Delete",
+    "users_delete_hint": "Permanently delete this account",
+    "users_delete_warning": "permanently removes the account.",
+    "users_confirm_delete": "Permanently delete %s? Disable is safer if you may need the account later.",
+    "users_role_perms": "Role permissions",
+    "users_perm_admin": "Users, projects, workflows, processing, review and system settings",
+    "users_perm_engineer": "Projects, workflows, processing and review",
+    "users_perm_reviewer": "View data, video review and annotation review",
+    "field_username": "Username",
+    "field_email": "Email",
+    "field_password": "Password",
+    "field_expires_at": "Expires at",
+    "users_pw_hint": "(at least 6 characters)",
+    "users_pw_keep": "(leave blank to keep current password)",
+    "users_optional": "(optional)",
+    "users_no_found": "No users found",
+    "users_no_email": "No email",
+    "users_never": "Never",
+    "users_count": "%s users",
+    "preview_options": "Preview Options",
+    "video_sources": "Video Sources",
+    "all": "All",
+    "hand_skeleton": "Hand Skeleton",
+    "hand_trail": "Hand Trail",
+    "frame_label": "Frame:",
+    "play": "Play",
+    "select": "Select",
+    "name_1_to_n": "Name 1→N",
+    "name_n_to_1": "Name N→1",
+    "sort_label": "Sort: ",
+    "n_selected": "%s selected",
+    "undo": "Undo",
+    "new_export": "New Export",
+    "dataset_name": "Dataset Name",
+    "train_ratio": "Train Ratio",
+    "start_export": "Start Export",
+    "dataset": "Dataset",
+    "progress": "Progress",
+    "created": "Created",
+    "task_active": "active",
+    "task_paused": "paused",
+    "ai_status_segmenting": "Segmenting…",
+    "ai_status_analyzing": "Analyzing (VLM)…",
+    "ai_status_writing": "Writing…",
+    "ai_status_exporting": "Writing dataset…",
+    "force_unit_mn": "Force (mN)",
+    "force_field_title": "Contact force field (fixed full frame, not zoomable)",
+    "slice_boundary_suspect": "Suspicious boundary or label not in vocabulary",
+    "anno_ai_mode_title": "AI auto-segments and proposes annotations (mode is configured on the workflow AI Annotation card)",
+    "overview_title": "Overview",
+    "load_failed_stats": "Failed to load statistics",
+    "retry": "Retry",
+    "stat_reviewing": "Reviewing",
+    "stat_approved": "Approved",
+    "stat_failed": "Failed",
+    "stat_total": "All Episodes",
+    "stat_to_review": "To Review",
+    "stat_distribution": "Status Distribution",
+    "daily_uploads": "Daily Uploads",
+    "last_30_days": "(last 30 days)",
+    "donut_total": "Total",
+    "stat_processing": "Processing",
+    "stat_received": "Received",
+    "cleaning_passed": "Cleaning passed",
+    "cleaning_failed": "Cleaning failed",
+    "stat_anomaly": "Anomaly",
+    "recent_episodes": "Recent Episodes",
+    "view_all": "View All",
+    "pipeline_status": "Pipeline Status",
+    "new_task": "New Task",
+    "edit_task": "Edit Task",
+    "task_name": "Task Name",
+    "task_name_hint": "Letters/digits/underscore/Chinese; must match zip filename prefix",
+    "task_description": "Description",
+    "claimer": "Claimer",
+    "target_episodes": "Target Episodes",
+    "target_duration": "Target Duration (s)",
+    "fps": "FPS",
+    "save": "Save",
+    "cancel": "Cancel",
+    "delete_task": "Delete Task",
+    "confirm_delete_task": "Delete this task? (Existing episodes will be kept)",
+    "episodes": "Episodes",
+    "frames": "Frames",
+    "no_frame_target": "No frame target",
+    "devices": "Devices",
+    "online": "Online",
+    "offline": "Offline",
+    "unknown": "Unknown",
+    "last_seen": "Last Seen",
+    "device_empty": "No devices connected",
+    "expand_episodes": "View Episodes",
+    "load_more": "Load More",
+    "no_tasks": "No tasks yet. Click \"New Task\" to create one.",
+    "projects_title": "Projects",
+    "search_projects": "Search projects...",
+    "new_project": "New Project",
+    "edit_project": "Edit Project",
+    "project_name": "Project Name",
+    "bind_workflow": "Workflow",
+    "workflow_placeholder": "— Select workflow —",
+    "device_type": "Device Type",
+    "status": "Status",
+    "no_projects": "No projects yet. Click \"New Project\" to create one.",
+    "tasks_count": "tasks",
+    "videos_count": "videos",
+    "ep_count": "episodes",
+    "upload_new": "new batches",
+    "upload_reupload": "reuploads",
+    "upload_total": "total uploads",
+    "upload_unclassified": "legacy unclassified",
+    "target_unlimited": "unlimited",
+    "no_tasks_in_project": "No tasks under this project (uploads are grouped automatically).",
+    "delete_project": "Delete",
+    "confirm_delete_project": "Delete project \"",
+    "confirm_delete_project_suffix": "\"? Task/episode records are kept.",
+    "project_saved": "Saved",
+    "project_save_failed": "Save failed",
+    "project_delete_failed": "Delete failed",
+    "project_load_failed": "Load failed",
+    "unbound_workflow": "No workflow bound",
+    "workflow_edit": "Edit",
+    "workflow_selected": "%s workflows selected",
+    "project_need_workflow": "Bind at least one workflow before activating this project",
+    "new_workflow_panel": "+ New Workflow",
+    "new_workflow_prompt": "Name for the new workflow:",
+    "workflow_create_failed": "Failed to create workflow",
+    "workflow_empty": "empty",
+    "template_badge": "Template",
+    "project_saved_go_build": "Project saved. Go to Workflow Studio to build/view the workflow?",
+    "status_purged": "Purged",
+    "observed_inputs": "Inputs",
+    "exceptions_badge": "exceptions",
+    "exceptions": "Exceptions",
+    "exception_kind_mismatch": "Input mismatch",
+    "exception_kind_missing": "Missing device data",
+    "input_missing_title": "Workflow inputs are incomplete",
+    "input_missing_detail": "The following devices are missing; only uploaded devices were processed:",
+    "exception_kind_failed": "Run failed",
+    "exception_delete": "Remove exception",
+    "exception_delete_failed": "Failed to remove exception",
+    "anno_timeline": "Annotation Timeline",
+    "slice_marker": "Slice Markers",
+    "new_slice": "New Slice",
+    "no_slices": "No slices yet",
+    "no_slices_hint": "Drag the timeline to create a marker range",
+    "current_slice": "Current Slice",
+    "enter_slice_name": "Enter a slice name",
+    "add_slice": "Add Slice",
+    "ai_annotate": "AI Annotate",
+    "unnamed_slice": "Untitled slice",
+    "slice_save_failed": "Save failed: ",
+    "slice_delete_failed": "Delete failed: ",
+    "inf_sec_model": "1. Model",
+    "inf_sec_data": "2. Test Data",
+    "inf_sec_run": "3. Run",
+    "inf_sec_result": "4. Results",
+    "inf_label_run": "Run",
+    "inf_label_step": "Checkpoint",
+    "inf_label_dataset": "Test dataset",
+    "inf_live": "live",
+    "inf_pending": "not wired",
+    "inf_no_params": "This checkpoint has no train_config.json; parameters unavailable.",
+    "inf_params_from": "From",
+    "inf_no_models": "No trained model yet",
+    "inf_dataset_none": "— Select a test dataset —",
+    "inf_datasets_available": "dataset(s) available",
+    "inf_no_datasets": "No exported dataset yet — export one from the review page first.",
+    "inf_run_btn": "Run inference",
+    "inf_run_disabled": "Backend execution is not wired up yet",
+    "inf_run_note": "Backend execution is not connected yet — this button is intentionally disabled.",
+    "inf_run_hint": "Once wired: runs the checkpoint over the test set and reports direction cosine, amplitude ratio, gripper MAE and the error curve.",
+    "inf_no_result": "No evaluation result yet."
+  }
+};
diff --git a/processor/web/static/js/i18n.js b/processor/web/static/js/i18n.js
index 75a36ea50060a39a8d409816c5a43a7d915ec7b2..92e96e030574108e89a55b299df1627813fdcaaf 100644
--- a/processor/web/static/js/i18n.js
+++ b/processor/web/static/js/i18n.js
@@ -1,492 +1,74 @@
 /* i18n — 中英文切换 */
 
-const I18N = {
-    zh: {
-        app_title: 'processor',
-        video_review: '视频审核',
-        trash: '回收站',
-        all_status: '全部状态',
-        reviewing: '审核中',
-        reviewed: '已审核',
-        all_tasks: '全部任务',
-        search: '搜索...',
-        loading: '加载中...',
-        processing: '处理中...',
-        ai_annotating: 'AI 标注处理中...',
-        ai_annotating_hint: 'AI 标注完成后自动载入本批次数据',
-        no_data: '暂无数据',
-        load_failed: '加载失败',
-        select_episode: '选择一个视频开始审核 →',
-        no_video: '此 Episode 没有视频数据',
-        cameras: 'Cameras',
-        play_all: '▶ 全部播放',
-        pause_all: '⏸ 全部暂停',
-        play_btn: '播放',
-        pause_btn: '暂停',
-        layout_row: '并排',
-        layout_grid: '网格',
-        layout_column: '上下',
-        no_description: '无任务描述',
-        frame: '帧',
-        download: '下载',
-        export: '导出',
-        export_hint: '按工作流导出格式下载最终数据集',
-        re_export: '重新导出',
-        re_exporting: '重新导出中',
-        re_export_done: '重新导出完成',
-        re_export_failed: '重新导出失败',
-        delete: '删除',
-        approve: '通过',
-        deleted_msg: '已移入回收站',
-        select_hint: '选择 Episode 后显示详情',
-        trash_empty: '回收站为空',
-        trash_title: '回收站',
-        purge_all: '全部清空',
-        restore: '恢复',
-        permanent_delete: '永久删除',
-        days_left: '剩余',
-        day_unit: '天',
-        confirm_trash: '确定将此视频移入回收站吗？\n7 天后自动清理。',
-        confirm_permanent: '确定永久删除吗？此操作不可恢复！',
-        confirm_purge: '确定清空回收站吗？所有内容将被永久删除！',
-        op_failed: '操作失败',
-        restore_failed: '恢复失败',
-        delete_failed: '删除失败',
-        purge_failed: '清空失败',
-        export_failed: '导出失败',
-        no_reviewed: '没有已审核的 Episode 可导出',
-        export_created: '导出任务已创建，完成后自动下载',
-        left_hand: 'Left Hand',
-        right_hand: 'Right Hand',
-        single_mono: '单目视频',
-        glove_sensor: '手套传感器',
-        depth_image: '深度图',
-        aux_video: '辅助视频',
-        skeleton_suffix: '骨骼',
-        glove_suffix: '手套',
-        depth_suffix: '深度',
-        stereo_pair: '双目并排',
-        '3d_skeleton': '3D 骨骼',
-        stereo_render: '3D 拼接',
-        hand3d_no_data: '该帧无 3D 骨骼数据',
-        hand3d_hand0: '手 0',
-        hand3d_hand1: '手 1',
-        hand3d_world: '3D 手部世界坐标',
-        heatmap_toggle: '深度热力图',
-        synced_ok: '同步正常',
-        drag_here: '拖拽素材到这里',
-        remove_source: '移除素材',
-        video_suffix: '视频',
-        hand_pressure: '手部压力',
-        media_assets: '素材',
-        drag_to_canvas: '拖拽素材到中间视频区域',
-        raw_vs_processed: '原始视频 / 处理结果',
-        refresh: '刷新',
-        not_found: '未找到',
-        deleted: '已删除',
-        port_label: 'Port',
-        // Annotation
-        annotation: '动作标注',
-        annotation_readonly: '只读',
-        annotations: '标注段',
-        new_annotation: '新增标注',
-        edit_annotation: '编辑标注',
-        delete_annotation: '删除标注',
-        label_name: '标注名称',
-        start_frame: '起始帧',
-        end_frame: '结束帧',
-        set_start_frame: '设起始帧',
-        set_end_frame: '设结束帧',
-        keyframe: '关键帧',
-        add_keyframe: '添加关键帧',
-        frames_covered: '帧已标注',
-        per_frame_label: '每帧标注',
-        no_annotations: '暂无标注，点击"新增"创建第一个标注段',
-        confirm_delete_anno: '确定删除此标注段吗？',
-        save_annotation: '保存标注',
-        save_changes: '保存修改',
-        slice_conflict: '该切片已被其他设备修改，已加载最新版本，请重新确认后保存。',
-        current_frame: '当前帧',
-        anno_color: '颜色',
-        anno_frame_range: '帧范围',
-        anno_duration: '时长',
-        anno_keyframe_event: '关键帧事件',
-        seconds_abbr: 's',
-        // Batch
-        select_all: '全选',
-        batch_download: '批量下载',
-        batch_export_dataset: '导出数据集 (慢)',
-        batch_zip_download: '打包下载 (快)',
-        batch_zip_hint: '从源数据集原样裁出所选批次 —— 产出仍是单个 LeRobot 结构(data/ + meta/ + videos/),不重建、秒级返回。只想把这批数据拿走就用这个。',
-        batch_export_hint: '把所选批次合并成**一个**可训练数据集(需要整库重建:重编码视频 + 重算统计,约 30 秒/集)。要拿去训练才用这个。',
-        batch_selected_summary: '已选 %s 集 · %f 帧',
-        minutes_short: '分',
-        select_project_all: '全选本项目(含折叠中的批次)',
-        unreview: '撤销',
-        retry_review: '放入审核',
-        reprocess: '重新处理',
-        confirm_reprocess: '重新运行该批次绑定的工作流?新产物将替换旧处理结果。',
-        reprocess_failed: '重新处理失败: ',
-        // Sidebar & Nav
-        nav_home: '首页',
-        nav_tasks: '项目',
-        nav_review: '视频审核',
-        nav_trash: '回收站',
-        // Overview Dashboard
-        overview_title: 'Overview',
-        load_failed_stats: '加载统计数据失败',
-        retry: '重试',
-        stat_reviewing: '待审核',
-        stat_approved: '已通过',
-        stat_failed: '异常',
-        stat_total: '全部',
-        stat_anomaly: '异常',
-        recent_episodes: '最近 Episode',
-        view_all: '查看全部',
-        pipeline_status: 'Pipeline 状态',
-        // Task Management
-        new_task: '新建任务',
-        edit_task: '编辑任务',
-        task_name: '任务名称',
-        task_name_hint: '请使用字母/数字/下划线/中文，需与上传文件前缀匹配',
-        task_description: '描述',
-        claimer: '认领人',
-        target_episodes: '目标批次数',
-        target_duration: '目标时长(秒)',
-        fps: '帧率',
-        save: '保存',
-        cancel: '取消',
-        delete_task: '删除任务',
-        confirm_delete_task: '确定删除此任务吗？（已有采集数据将保留）',
-        episodes: 'Episodes',
-        frames: '帧',
-        no_frame_target: '无帧数目标',
-        devices: '设备',
-        online: '在线',
-        offline: '离线',
-        unknown: '未知',
-        last_seen: '最近活跃',
-        device_empty: '暂无设备接入',
-        expand_episodes: '查看 Episodes',
-        load_more: '加载更多',
-        no_tasks: '暂无任务，点击"新建任务"创建第一个采集任务',
-        all_status: '全部状态',
-        // Project management
-        projects_title: '项目',
-        search_projects: '搜索项目...',
-        new_project: '新建项目',
-        edit_project: '编辑项目',
-        project_name: '项目名称',
-        bind_workflow: '绑定工作流',
-        workflow_placeholder: '— 选择工作流 —',
-        device_type: '设备类型',
-        status: '状态',
-        no_projects: '暂无项目，点击右上角「新建项目」创建',
-        tasks_count: '任务',
-        videos_count: '视频',
-        ep_count: '条',
-        upload_new: '新批次',
-        upload_reupload: '重传',
-        upload_total: '总上传',
-        upload_unclassified: '历史未分类',
-        target_episodes: '目标条数',
-        target_unlimited: '不限',
-        no_tasks_in_project: '该项目下暂无任务（上传数据后自动归类）',
-        delete_project: '删除',
-        confirm_delete_project: '确定删除项目「',
-        confirm_delete_project_suffix: '」？项目下的任务/视频记录不会被删除。',
-        project_saved: '保存成功',
-        project_save_failed: '保存失败',
-        project_delete_failed: '删除失败',
-        project_load_failed: '加载失败',
-        unbound_workflow: '未绑定工作流',
-        workflow_edit: '编辑',
-        workflow_selected: '已选 %s 个工作流',
-        project_need_workflow: '项目设为 active 前必须先绑定至少一个工作流',
-        new_workflow_panel: '新建工作流',
-        new_workflow_prompt: '新工作流名称：',
-        workflow_create_failed: '创建工作流失败',
-        workflow_empty: '空',
-        template_badge: '模板',
-        project_saved_go_build: '项目已保存。是否前往工作流画布搭建/查看工作流?',
-        status_purged: '已彻底删除',
-        observed_inputs: '输入',
-        exceptions_badge: '异常',
-        exceptions: '异常',
-        exception_kind_mismatch: '输入不匹配',
-        exception_kind_missing: '设备数据缺失',
-        input_missing_title: '工作流设备数据不完整',
-        input_missing_detail: '以下设备缺失，本批次仅处理已上传设备：',
-        exception_kind_failed: '运行失败',
-        exception_delete: '删除异常',
-        exception_delete_failed: '删除异常失败',
-        anno_timeline: '标记时间轴',
-        slice_marker: '切片标记',
-        new_slice: '新建切片',
-        no_slices: '暂无切片标记',
-        no_slices_hint: '拖动时间轴后创建一个标记区间',
-        current_slice: '当前标记',
-        enter_slice_name: '请输入标记名称',
-        add_slice: '添加切片',
-        save_changes: '保存修改',
-        ai_annotate: 'AI 标注',
-        slice_conflict: '此切片已在另一台电脑修改，已加载最新版本。请确认后再次保存。',
-        unnamed_slice: '未命名切片',
-        slice_save_failed: '保存失败: ',
-        slice_delete_failed: '删除失败: ',
-    },
-    en: {
-        app_title: 'processor',
-        video_review: 'Video Review',
-        trash: 'Trash',
-        all_status: 'All Status',
-        reviewing: 'Reviewing',
-        reviewed: 'Reviewed',
-        all_tasks: 'All Tasks',
-        search: 'Search...',
-        loading: 'Loading...',
-        processing: 'Processing...',
-        ai_annotating: 'AI annotation running...',
-        ai_annotating_hint: 'This batch becomes viewable once AI annotation finishes',
-        no_data: 'No data',
-        load_failed: 'Load failed',
-        select_episode: 'Select an episode to review →',
-        no_video: 'No video data',
-        cameras: 'Cameras',
-        play_all: '▶ Play All',
-        pause_all: '⏸ Pause All',
-        play_btn: 'Play',
-        pause_btn: 'Pause',
-        layout_row: 'Row',
-        layout_grid: 'Grid',
-        layout_column: 'Stack',
-        no_description: 'No description',
-        frame: 'frames',
-        download: 'Download',
-        export: 'Export',
-        export_hint: 'Download final dataset in workflow export format',
-        re_export: 'Re-export',
-        re_exporting: 'Re-exporting…',
-        re_export_done: 'Re-export done',
-        re_export_failed: 'Re-export failed',
-        delete: 'Delete',
-        approve: 'Approve',
-        deleted_msg: 'Moved to trash',
-        select_hint: 'Select an episode to view details',
-        trash_empty: 'Trash is empty',
-        trash_title: 'Trash',
-        purge_all: 'Purge All',
-        restore: 'Restore',
-        permanent_delete: 'Delete',
-        days_left: 'Remaining',
-        day_unit: 'days',
-        confirm_trash: 'Move to trash?\nAuto-cleaned after 7 days.',
-        confirm_permanent: 'Permanently delete? This cannot be undone!',
-        confirm_purge: 'Purge all trash? All items will be permanently deleted!',
-        op_failed: 'Operation failed',
-        restore_failed: 'Restore failed',
-        delete_failed: 'Delete failed',
-        purge_failed: 'Purge failed',
-        export_failed: 'Export failed',
-        no_reviewed: 'No reviewed episodes to export',
-        export_created: 'Export job created; it will download when ready',
-        left_hand: 'Left Hand',
-        right_hand: 'Right Hand',
-        single_mono: 'Single Camera',
-        glove_sensor: 'Glove Sensors',
-        depth_image: 'Depth Images',
-        aux_video: 'Aux Video',
-        skeleton_suffix: 'Skeleton',
-        glove_suffix: 'Glove',
-        depth_suffix: 'Depth',
-        stereo_pair: 'Stereo Pair',
-        '3d_skeleton': '3D Skeleton',
-        stereo_render: '3D Side-by-Side',
-        hand3d_no_data: 'No 3D skeleton data for this frame',
-        hand3d_hand0: 'Hand 0',
-        hand3d_hand1: 'Hand 1',
-        hand3d_world: '3D Hand World',
-        heatmap_toggle: 'Depth Heatmap',
-        synced_ok: 'Synced',
-        drag_here: 'Drag assets here',
-        remove_source: 'Remove',
-        video_suffix: 'Video',
-        hand_pressure: 'Hand Pressure',
-        media_assets: 'Assets',
-        drag_to_canvas: 'Drag assets onto the video area',
-        raw_vs_processed: 'Raw video / Processing results',
-        refresh: 'Refresh',
-        not_found: 'Not found',
-        deleted: 'Deleted',
-        port_label: 'Port',
-        // Annotation
-        annotation: 'Annotation',
-        annotation_readonly: 'Read only',
-        annotations: 'Annotations',
-        new_annotation: 'New Annotation',
-        edit_annotation: 'Edit Annotation',
-        delete_annotation: 'Delete Annotation',
-        label_name: 'Label Name',
-        start_frame: 'Start Frame',
-        end_frame: 'End Frame',
-        set_start_frame: 'Set Start',
-        set_end_frame: 'Set End',
-        keyframe: 'Keyframe',
-        add_keyframe: 'Add Keyframe',
-        frames_covered: 'frames labeled',
-        per_frame_label: 'per-frame label',
-        no_annotations: 'No annotations. Click "+" to create one.',
-        confirm_delete_anno: 'Delete this annotation segment?',
-        save_annotation: 'Save Annotation',
-        save_changes: 'Save Changes',
-        slice_conflict: 'This slice was modified by another device. The latest version was loaded — please confirm and save again.',
-        current_frame: 'Current Frame',
-        anno_color: 'Color',
-        anno_frame_range: 'Frame Range',
-        anno_duration: 'Duration',
-        anno_keyframe_event: 'Keyframe Event',
-        seconds_abbr: 's',
-        // Batch
-        select_all: 'Select All',
-        batch_download: 'Batch Download',
-        batch_export_dataset: 'Export dataset (slow)',
-        batch_zip_download: 'Zip download (fast)',
-        batch_zip_hint: 'Carves the selected episodes out of the source dataset as-is — still a single LeRobot structure (data/ + meta/ + videos/), no rebuild, returns in seconds. Use this to just take the data away.',
-        batch_export_hint: 'Merges the selected episodes into ONE trainable dataset (full rebuild: re-encode videos + recompute stats, ~30s/episode). Use this only for training.',
-        batch_selected_summary: '%s episodes · %f frames',
-        minutes_short: 'min',
-        select_project_all: 'Select all in this project (including collapsed)',
-        unreview: 'Unreview',
-        retry_review: 'Re-review',
-        reprocess: 'Reprocess',
-        confirm_reprocess: 'Re-run the bound workflows for this episode? New output will replace the old processing result.',
-        reprocess_failed: 'Reprocess failed: ',
-        // Sidebar & Nav
-        nav_home: 'Home',
-        nav_tasks: 'Projects',
-        nav_review: 'Video Review',
-        nav_trash: 'Trash',
-        // Overview Dashboard
-        overview_title: 'Overview',
-        load_failed_stats: 'Failed to load statistics',
-        retry: 'Retry',
-        stat_reviewing: 'Reviewing',
-        stat_approved: 'Approved',
-        stat_failed: 'Failed',
-        stat_total: 'All Episodes',
-        stat_anomaly: 'Anomaly',
-        recent_episodes: 'Recent Episodes',
-        view_all: 'View All',
-        pipeline_status: 'Pipeline Status',
-        // Task Management
-        new_task: 'New Task',
-        edit_task: 'Edit Task',
-        task_name: 'Task Name',
-        task_name_hint: 'Letters/digits/underscore/Chinese; must match zip filename prefix',
-        task_description: 'Description',
-        claimer: 'Claimer',
-        target_episodes: 'Target Batches',
-        target_duration: 'Target Duration (s)',
-        fps: 'FPS',
-        save: 'Save',
-        cancel: 'Cancel',
-        delete_task: 'Delete Task',
-        confirm_delete_task: 'Delete this task? (Existing episodes will be kept)',
-        episodes: 'Episodes',
-        frames: 'Frames',
-        no_frame_target: 'No frame target',
-        devices: 'Devices',
-        online: 'Online',
-        offline: 'Offline',
-        unknown: 'Unknown',
-        last_seen: 'Last Seen',
-        device_empty: 'No devices connected',
-        expand_episodes: 'View Episodes',
-        load_more: 'Load More',
-        no_tasks: 'No tasks yet. Click "New Task" to create one.',
-        all_status: 'All Status',
-        // Project management
-        projects_title: 'Projects',
-        search_projects: 'Search projects...',
-        new_project: 'New Project',
-        edit_project: 'Edit Project',
-        project_name: 'Project Name',
-        bind_workflow: 'Workflow',
-        workflow_placeholder: '— Select workflow —',
-        device_type: 'Device Type',
-        status: 'Status',
-        no_projects: 'No projects yet. Click "New Project" to create one.',
-        tasks_count: 'tasks',
-        videos_count: 'videos',
-        ep_count: 'episodes',
-        upload_new: 'new batches',
-        upload_reupload: 'reuploads',
-        upload_total: 'total uploads',
-        upload_unclassified: 'legacy unclassified',
-        target_episodes: 'Target Episodes',
-        target_unlimited: 'unlimited',
-        no_tasks_in_project: 'No tasks under this project (uploads are grouped automatically).',
-        delete_project: 'Delete',
-        confirm_delete_project: 'Delete project "',
-        confirm_delete_project_suffix: '"? Task/episode records are kept.',
-        project_saved: 'Saved',
-        project_save_failed: 'Save failed',
-        project_delete_failed: 'Delete failed',
-        project_load_failed: 'Load failed',
-        unbound_workflow: 'No workflow bound',
-        workflow_edit: 'Edit',
-        workflow_selected: '%s workflows selected',
-        project_need_workflow: 'Bind at least one workflow before activating this project',
-        new_workflow_panel: '+ New Workflow',
-        new_workflow_prompt: 'Name for the new workflow:',
-        workflow_create_failed: 'Failed to create workflow',
-        workflow_empty: 'empty',
-        template_badge: 'Template',
-        project_saved_go_build: 'Project saved. Go to Workflow Studio to build/view the workflow?',
-        status_purged: 'Purged',
-        observed_inputs: 'Inputs',
-        exceptions_badge: 'exceptions',
-        exceptions: 'Exceptions',
-        exception_kind_mismatch: 'Input mismatch',
-        exception_kind_missing: 'Missing device data',
-        input_missing_title: 'Workflow inputs are incomplete',
-        input_missing_detail: 'The following devices are missing; only uploaded devices were processed:',
-        exception_kind_failed: 'Run failed',
-        exception_delete: 'Remove exception',
-        exception_delete_failed: 'Failed to remove exception',
-        anno_timeline: 'Annotation Timeline',
-        slice_marker: 'Slice Markers',
-        new_slice: 'New Slice',
-        no_slices: 'No slices yet',
-        no_slices_hint: 'Drag the timeline to create a marker range',
-        current_slice: 'Current Slice',
-        enter_slice_name: 'Enter a slice name',
-        add_slice: 'Add Slice',
-        save_changes: 'Save Changes',
-        ai_annotate: 'AI Annotate',
-        slice_conflict: 'This slice was changed on another computer. The latest version has been loaded.',
-        unnamed_slice: 'Untitled slice',
-        slice_save_failed: 'Save failed: ',
-        slice_delete_failed: 'Delete failed: ',
-    }
-};
+// 词典**不在这里** —— 见同目录的 i18n-data.js。
+// 它同时被服务端读取(app/i18n.py),而服务端是 Python;两边读同一份才不会分叉。
+// 那个文件在 base.html 里**先于本文件**同步加载,所以这里读得到。
+// 真读不到(比如有人单独引这个脚本)时退化成空字典 —— 页面照常起得来,
+// t() 会返回 key 本身,一眼看得出是加载顺序出了问题。
+const I18N = (typeof window !== 'undefined' && window.__I18N__) || { zh: {}, en: {} };
+
+/**
+ * 客户端语言**以服务端渲染时用的那个为准** —— 它就写在 `<html lang>` 上。
+ *
+ * ★ 不能只读 localStorage。服务端是从 **cookie** 读语言的,两者可能不一致
+ *   (比如清了 localStorage 但 cookie 还在)。一旦不一致,下面的
+ *   applyTranslations() 会把服务端刚渲染好的中文**又翻回英文** —— 页面反而
+ *   变成了"先中文后英文",比原来的闪烁更难看。
+ *
+ * 以 <html lang> 为准还有个好处:它和 DOM 里已有的文案**必然一致**(服务端就是
+ * 按它渲染的),所以首次 applyTranslations() 是个空操作。
+ *
+ * <head> 里的脚本执行时 <html> 已经解析完了,所以这里读得到。
+ */
+function _initialLang() {
+    const fromHtml = String(document.documentElement.lang || '').toLowerCase();
+    if (I18N[fromHtml]) return fromHtml;
+    try {
+        const saved = localStorage.getItem('lang');
+        if (saved && I18N[saved]) return saved;
+    } catch (e) { /* 隐私模式禁 storage */ }
+    return 'en';
+}
 
-let currentLang = 'en';
+let currentLang = _initialLang();
 
 function t(key) {
     return (I18N[currentLang] && I18N[currentLang][key]) || I18N['zh'][key] || key;
 }
 
-function setLang(lang) {
-    currentLang = lang;
-    localStorage.setItem('lang', lang);
-    // Re-apply all data-i18n text
+/** 把静态标注（data-i18n / data-i18n-placeholder）应用到 DOM。 */
+function applyTranslations() {
     document.querySelectorAll('[data-i18n]').forEach(el => {
         el.textContent = t(el.dataset.i18n);
     });
     document.querySelectorAll('[data-i18n-placeholder]').forEach(el => {
         el.placeholder = t(el.dataset.i18nPlaceholder);
     });
+    // title 属性此前没人处理 —— 只有 data-i18n（写 textContent）和 placeholder 两种，
+    // 于是带提示的按钮/图标没法靠标记翻译，只能写死中文。
+    document.querySelectorAll('[data-i18n-title]').forEach(el => {
+        el.title = t(el.dataset.i18nTitle);
+    });
+}
+
+function setLang(lang) {
+    if (!I18N[lang]) return;                 // 只认字典里有的语言
+    currentLang = lang;
+    try { localStorage.setItem('lang', lang); } catch (e) { /* 隐私模式禁 storage */ }
+    // ★ 同时写 cookie —— **服务端渲染时要读它**,否则每次整页导航都会先渲染
+    //   默认语言、再由 JS 纠正,表现为"闪一下另一种语言"。
+    //   localStorage 在这里已经不够用了:它是浏览器本地的,服务端看不到。
+    //   max-age 一年;SameSite=Lax 免得外站发起的请求也带上这个 cookie。
+    try {
+        document.cookie = `lang=${encodeURIComponent(lang)}; path=/; max-age=31536000; SameSite=Lax`;
+    } catch (e) { /* 禁 cookie:退回旧行为,靠上面的 applyTranslations() 事后翻 */ }
+    // 通知**同页面里的其他应用**：工作流画布是独立的 React 应用，不加载本文件，
+    // 它靠这个事件跟着切。不能用 storage 事件 —— 那个只在**别的标签页**触发，
+    // 而切换按钮就在本页侧边栏上。
+    try {
+        window.dispatchEvent(new CustomEvent('egodata:lang', { detail: { lang } }));
+    } catch (e) { /* 老浏览器不支持 CustomEvent 构造：画布不跟随，其余照常 */ }
+    applyTranslations();
     // Update header nav
     const navReview = document.getElementById('nav-review');
     const navTrash = document.getElementById('nav-trash');
@@ -503,9 +85,12 @@ function setLang(lang) {
     if (typeof loadDevices === 'function') loadDevices();
     if (typeof loadEpisodes === 'function') loadEpisodes();
     if (typeof loadTrashList === 'function') loadTrashList();
-    if (typeof loadExportJobs === 'function') loadExportJobs();
     if (typeof renderSourceBar === 'function') renderSourceBar();
     if (typeof updateInfoBar === 'function') updateInfoBar();
+    // 首页概览的环形图/柱状图/状态徽标都是 JS 现画的，不重跑就不跟着切语言
+    if (typeof refreshDashboard === 'function') refreshDashboard();
+    // 用户列表同样是 JS 现画的（表头是静态标注，行内容是动态的）
+    if (typeof loadUsers === 'function') loadUsers();
     updateLangToggle();
 }
 
@@ -514,16 +99,27 @@ function updateLangToggle() {
     if (btn) {
         btn.textContent = currentLang === 'zh' ? 'EN' : '中';
     }
+    // 用户菜单里的语言选项：高亮当前项。用的是 class 切换而不是重建 DOM ——
+    // 菜单是常驻元素，重建会丢掉挂在它上面的监听。
+    document.querySelectorAll('[data-lang-option]').forEach(el => {
+        const active = el.dataset.langOption === currentLang;
+        el.setAttribute('aria-pressed', active ? 'true' : 'false');
+        el.classList.toggle('text-cyan-300', active);
+        el.classList.toggle('border-cyan-700', active);
+        el.classList.toggle('bg-cyan-900/30', active);
+        el.classList.toggle('text-gray-400', !active);
+        el.classList.toggle('border-gray-700', !active);
+    });
 }
 
-// Apply translations on every page at load. Default language is English;
-// the toggle (lang-toggle) switches to Chinese for the session.
+// Apply translations on every page at load.
+//
+// ★ 必须**先读回上次选的语言**：setLang 一直在写 localStorage，但此前没有任何
+//   地方读它 —— currentLang 写死 'en'，于是每次刷新都退回英文，切换等于没切。
 document.addEventListener('DOMContentLoaded', () => {
-    document.querySelectorAll('[data-i18n]').forEach(el => {
-        el.textContent = t(el.dataset.i18n);
-    });
-    document.querySelectorAll('[data-i18n-placeholder]').forEach(el => {
-        el.placeholder = t(el.dataset.i18nPlaceholder);
-    });
+    // currentLang 在上面就用 _initialLang() 定好了(以 <html lang> 为准),
+    // 这里**不再从 localStorage 覆盖** —— 那正是会把服务端渲染好的语言翻回去的操作。
+    // 语言由服务端按 cookie 渲染,客户端只负责后续切换。
+    applyTranslations();
     updateLangToggle();
 });
diff --git a/processor/web/static/js/inference/view.js b/processor/web/static/js/inference/view.js
new file mode 100644
index 0000000000000000000000000000000000000000..e439713e36566435f2b7b522272bed723724a69d
--- /dev/null
+++ b/processor/web/static/js/inference/view.js
@@ -0,0 +1,235 @@
+/** 模型推理视图 —— 选模型/检查点、看它的训练参数、选测试集,然后跑评估。
+ *
+ * 与 `static/js/train/` 同构:一个入口 + 若干模块,共用 `static/js/shared/` 下的
+ * 纯工具。**不新开一套** —— 推理和训练本来就是同一批产物的上下游。
+ *
+ * **后端执行未接** —— 「运行推理」按钮和训练页一样是**故意禁用**的,旁边写明原因。
+ * 这一页真正能用的是前面三段(选模型 / 看参数 / 选测试集),数据都是真的:
+ *   模型与检查点 → GET /api/v1/training/runs
+ *   训练参数     → 那些 checkpoint 里的 train_config.json
+ *   测试集       → GET /api/v1/training/datasets
+ *
+ * 没有「实时日志」「指标曲线」之类的空页签 —— 没有数据的页签不摆,理由同训练页。
+ *
+ * ★ 数据源为什么直接引 `../train/api.js`:runs / datasets 这两个端点属于**训练域**
+ *   (推理消费的是训练产物)。等将来有第三个页面也用到它们,再抽到 shared/ 去。
+ */
+
+import { el, clear } from '../shared/dom.js';
+import { tr } from '../shared/text.js';
+import { listDatasets, listRuns } from '../train/api.js';
+
+const INPUT_CLASS = 'bg-gray-800 text-xs rounded px-2 py-1 border border-gray-700 '
+  + 'focus:border-blue-500 focus:outline-none font-mono';
+const BTN = 'bg-gray-800 hover:bg-gray-700 text-gray-300 text-xs px-2.5 py-1 '
+  + 'rounded border border-gray-700';
+
+const LIVE = 'bg-green-900/50 text-green-300';
+const PENDING = 'bg-amber-900/50 text-amber-300';
+
+function section(titleKey, fallback, badge, children) {
+  return el('div', { class: 'bg-gray-900 rounded-lg border border-gray-800 p-4 mb-4' }, [
+    el('div', { class: 'flex items-center gap-3 mb-3' }, [
+      el('div', { class: 'text-sm font-semibold text-gray-200', text: tr(titleKey, fallback) }),
+      badge ? el('span', { class: `text-[10px] px-1.5 py-0.5 rounded ${badge.cls}`, text: badge.text }) : null,
+    ]),
+    ...children,
+  ]);
+}
+
+function labeled(label, control, labelClass = 'text-gray-500 shrink-0 w-32') {
+  return el('div', { class: 'flex items-center gap-3 text-xs' }, [
+    el('span', { class: labelClass, text: label }),
+    control,
+  ]);
+}
+
+function hint(key, fallback) {
+  return el('div', { class: 'text-xs text-gray-600 mt-3', text: tr(key, fallback) });
+}
+
+/** 一行「参数名 → 值」。推理前最该确认的就是**训练时用的 chunk_size /
+ *  n_action_steps** 这类会直接影响推理输出的参数,所以这里只挑这几个关键的,
+ *  完整的训练参数在训练页那个「训练参数」页签里有。 */
+function paramRow(name, value) {
+  return el('div', { class: 'flex items-baseline gap-3 text-xs py-0.5' }, [
+    el('span', { class: 'text-gray-500 shrink-0 w-32 font-mono', text: name }),
+    el('span', { class: 'text-gray-200 font-mono break-all', text: value ?? '—' }),
+  ]);
+}
+
+const KEY_PARAMS = [
+  'policy.type', 'policy.chunk_size', 'policy.n_action_steps',
+  'policy.dim_model', 'policy.vision_backbone',
+];
+
+function pick(obj, path) {
+  return path.split('.').reduce((a, k) => (a === null || a === undefined ? undefined : a[k]), obj);
+}
+
+/**
+ * @param {HTMLElement} container
+ * @param {{runName?: string, checkpointName?: string}} [preselect]
+ *        从「模型训练」页签点某个检查点的「推理」跳过来时带上 —— 直接选中它,
+ *        不用再手动在下拉里找一遍。
+ */
+export function renderInference(container, preselect) {
+  clear(container);
+
+  const state = { run: null, checkpoint: null, dataset: null };
+
+  // ── 选择模型 / 检查点 ────────────────────────────────
+  const runSelect = el('select', { class: INPUT_CLASS + ' w-64' });
+  const stepSelect = el('select', { class: INPUT_CLASS + ' w-40', disabled: true });
+  const paramHost = el('div', { class: 'mt-3' });
+  let runs = [];
+
+  function renderCheckpointParams() {
+    clear(paramHost);
+    const config = state.checkpoint?.train_config;
+    if (!config || !Object.keys(config).length) {
+      paramHost.appendChild(el('div', {
+        class: 'text-xs text-gray-600 py-2',
+        text: tr('inf_no_params', 'This checkpoint has no train_config.json; parameters unavailable.'),
+      }));
+      return;
+    }
+    paramHost.appendChild(el('div', {
+      class: 'text-[10px] text-gray-600 mb-2',
+      text: `${tr('inf_params_from', 'From')} checkpoints/${state.checkpoint.name}/pretrained_model/train_config.json`,
+    }));
+    paramHost.appendChild(el('div', { class: 'border border-gray-800 rounded p-3' },
+      KEY_PARAMS.map((p) => paramRow(p, pick(config, p)))));
+  }
+
+  function fillSteps(wantedStep) {
+    clear(stepSelect);
+    const run = runs.find((r) => r.name === runSelect.value);
+    if (!run) {
+      stepSelect.disabled = true;
+      stepSelect.appendChild(el('option', { value: '', text: '—' }));
+      state.checkpoint = null;
+      renderCheckpointParams();
+      return;
+    }
+    stepSelect.disabled = false;
+    for (const c of run.checkpoints) {
+      stepSelect.appendChild(el('option', { value: c.name, text: `${c.name} (${c.step})` }));
+    }
+    // 有预选就用预选,否则用最新的那个。预选名可能对不上(比如那个 checkpoint
+    // 刚被删),对不上就退回最新 —— 不要因为一个过期的参数让整页空着。
+    const pick = (wantedStep && run.checkpoints.find((c) => c.name === wantedStep))
+      || run.checkpoints[0] || null;
+    state.checkpoint = pick;
+    if (pick) stepSelect.value = pick.name;
+    renderCheckpointParams();
+  }
+
+  runSelect.addEventListener('change', () => {
+    state.run = runSelect.value || null;
+    fillSteps();
+  });
+  stepSelect.addEventListener('change', () => {
+    const run = runs.find((r) => r.name === runSelect.value);
+    state.checkpoint = (run?.checkpoints || []).find((c) => c.name === stepSelect.value) || null;
+    renderCheckpointParams();
+  });
+
+  const sectionModel = section('inf_sec_model', '1. Model', null, [
+    el('div', { class: 'flex gap-6 flex-wrap' }, [
+      labeled(tr('inf_label_run', 'Run'), runSelect),
+      labeled(tr('inf_label_step', 'Checkpoint'), stepSelect),
+    ]),
+    paramHost,
+  ]);
+  paramHost.appendChild(el('div', { class: 'text-xs text-gray-600 py-2', text: tr('loading', 'Loading...') }));
+
+  listRuns()
+    .then((payload) => {
+      runs = payload.runs || [];
+      clear(runSelect);
+      if (!runs.length) {
+        runSelect.appendChild(el('option', { value: '', text: tr('inf_no_models', 'No trained model yet') }));
+        renderCheckpointParams();
+        return;
+      }
+      for (const r of runs) {
+        runSelect.appendChild(el('option', { value: r.name, text: `${r.name} (${r.checkpoint_count})` }));
+      }
+      const chosen = runs.find((r) => r.name === preselect?.runName) || runs[0];
+      runSelect.value = chosen.name;
+      state.run = chosen.name;
+      fillSteps(preselect?.checkpointName);
+    })
+    .catch((err) => {
+      clear(paramHost);
+      paramHost.appendChild(el('div', {
+        class: 'text-xs text-red-400 py-2',
+        text: `${tr('train_load_failed', 'Failed to load')}: ${err.message}`,
+      }));
+    });
+
+  // ── 测试集 ──────────────────────────────────────────
+  const datasetSelect = el('select', { class: INPUT_CLASS + ' w-80' }, [
+    el('option', { value: '', text: tr('inf_dataset_none', '— Select a test dataset —') }),
+  ]);
+  datasetSelect.addEventListener('change', () => {
+    const value = datasetSelect.value;
+    state.dataset = value ? { name: value } : null;
+  });
+  const datasetNote = el('div', { class: 'text-xs text-gray-600 mt-2' });
+
+  const sectionData = section('inf_sec_data', '2. Test Data',
+    { cls: LIVE, text: tr('inf_live', 'live') }, [
+      labeled(tr('inf_label_dataset', 'Test dataset'), datasetSelect),
+      datasetNote,
+    ]);
+  datasetNote.textContent = tr('loading', 'Loading...');
+
+  listDatasets()
+    .then((payload) => {
+      const items = payload.datasets || [];
+      datasetNote.textContent = items.length
+        ? `${items.length} ${tr('inf_datasets_available', 'dataset(s) available')}`
+        : tr('inf_no_datasets', 'No exported dataset yet — export one from the review page first.');
+      for (const d of items) {
+        datasetSelect.appendChild(el('option', {
+          value: d.name,
+          text: `${d.name} — ${d.total_episodes} ${tr('train_episodes', 'episodes')}`,
+        }));
+      }
+    })
+    .catch(() => { datasetNote.textContent = ''; });
+
+  // ── 运行 ────────────────────────────────────────────
+  const sectionRun = section('inf_sec_run', '3. Run', { cls: PENDING, text: tr('inf_pending', 'not wired') }, [
+    el('div', { class: 'flex items-center gap-3' }, [
+      el('button', {
+        class: 'bg-blue-600/40 text-blue-200/60 text-sm px-5 py-2 rounded cursor-not-allowed',
+        text: tr('inf_run_btn', 'Run inference'),
+        disabled: true,
+        title: tr('inf_run_disabled', 'Backend execution is not wired up yet'),
+      }),
+      el('span', {
+        class: 'text-xs text-amber-400',
+        text: tr('inf_run_note', 'Backend execution is not connected yet — this button is intentionally disabled.'),
+      }),
+    ]),
+    hint('inf_run_hint', 'Once wired, this runs the checkpoint over the chosen test set and reports direction cosine, amplitude ratio, gripper MAE and the error curve.'),
+  ]);
+
+  // ── 结果 ────────────────────────────────────────────
+  const sectionResult = section('inf_sec_result', '4. Results', null, [
+    el('div', { class: 'text-center py-8' }, [
+      el('div', { class: 'text-xs text-gray-600', text: tr('inf_no_result', 'No evaluation result yet.') }),
+    ]),
+  ]);
+
+  for (const node of [sectionModel, sectionData, sectionRun, sectionResult]) {
+    container.appendChild(node);
+  }
+}
+
+// 这里**没有** boot/自启动 —— 本模块不再是页面入口,而是被 train/main.js
+// 当作第三个页签 import 进去(`render: renderInference`)。
+// 页签的 render 签名是 (panel, run),本函数只用到 panel,多收一个参数无妨。
diff --git a/processor/web/static/js/player.js b/processor/web/static/js/player.js
index 2c1d327c0a221cd9d8856b712e31bf734eb29ef7..568dacb3543e232bb229fa9e5eb47f7fbec765c9 100644
--- a/processor/web/static/js/player.js
+++ b/processor/web/static/js/player.js
@@ -2003,7 +2003,7 @@ async function mountGroupedSource(source, tile) {
         const curveCaption = document.createElement('div');
         curveCaption.className = 'absolute pointer-events-none';
         curveCaption.style.cssText = 'top:2px;left:6px;font-size:10px;color:#64748b;';
-        curveCaption.textContent = '力 mN';
+        curveCaption.textContent = t('force_unit_mn');
         curveBox.appendChild(curveCaption);
         holder.appendChild(matrixBox);
         holder.appendChild(curveBox);
@@ -2014,7 +2014,7 @@ async function mountGroupedSource(source, tile) {
             chunks: new Map(), chunkInflight: new Set(),
             frameCount: Number(tactileMatrixData?.frame_count) || 0 };
         _resetTactileView(renderer);
-        canvas.title = '接触力场(固定全幅,不可缩放)';
+        canvas.title = t('force_field_title');
         currentTactileTiles.push(entry);
         const frame = typeof currentFrameTarget === 'number' ? currentFrameTarget : 0;
         _updateTactileForceTile(entry, frame);
diff --git a/processor/web/static/js/shared/dom.js b/processor/web/static/js/shared/dom.js
new file mode 100644
index 0000000000000000000000000000000000000000..3d4739792a0b0166bad52abc155cd97281b64c8d
--- /dev/null
+++ b/processor/web/static/js/shared/dom.js
@@ -0,0 +1,69 @@
+/** 极小的 DOM 构造 helper —— 一律 createElement + textContent。
+ *
+ * 为什么不用 innerHTML 拼字符串:checkpoint 的文件名、路径、后端错误信息都
+ * 来自磁盘和网络,拼进 HTML 就是一个转义面。仓库里 `escHtml()` 已经有**四份
+ * 实现**,其中 dashboard.js 那份还漏了 `String()` 转换 —— 与其再加第五份,
+ * 不如让新代码从根上不产生转义需求。
+ *
+ * 用法:
+ *     el('div', { class: 'p-2', text: 'hi' }, [el('span', { text: 'x' })])
+ */
+
+const ATTR_ALIASES = { class: 'class', for: 'for', style: 'style' };
+
+/** 必须走 setAttribute 的键(即使不含连字符)。
+ *
+ *  `icon` 是给 `<iconify-icon>` 这个**自定义元素**用的:它只监听 attribute
+ *  变化。`node.icon = '...'` 只是给元素挂了个 JS 属性,不反映成 attribute,
+ *  结果就是图标位置一片空白 —— 而且不报错,很难查。 */
+const SET_ATTR = new Set(['icon']);
+
+/**
+ * @param {string} tag
+ * @param {object} [attrs]  `text` 走 textContent;`on` 是 {事件名: 处理函数};
+ *                          `dataset` 是 {键: 值};其余按属性 setAttribute。
+ * @param {Array}  [children]  子节点(字符串会被转成文本节点)
+ */
+export function el(tag, attrs = {}, children = []) {
+  const node = document.createElement(tag);
+
+  for (const [key, value] of Object.entries(attrs)) {
+    if (value === undefined || value === null || value === false) continue;
+
+    if (key === 'text') {
+      node.textContent = String(value);
+    } else if (key === 'on') {
+      for (const [event, handler] of Object.entries(value)) {
+        node.addEventListener(event, handler);
+      }
+    } else if (key === 'dataset') {
+      for (const [k, v] of Object.entries(value)) node.dataset[k] = String(v);
+    } else if (ATTR_ALIASES[key] || SET_ATTR.has(key) || key.includes('-')) {
+      node.setAttribute(key, String(value));
+    } else {
+      node[key] = value;
+    }
+  }
+
+  append(node, children);
+  return node;
+}
+
+/** 把 children(数组或单值)追加进 node。null/undefined/false 会被跳过,
+ *  这样 `cond && el(...)` 这种写法可以直接塞进数组。 */
+export function append(node, children) {
+  const list = Array.isArray(children) ? children : [children];
+  for (const child of list) {
+    if (child === null || child === undefined || child === false) continue;
+    node.appendChild(
+      child instanceof Node ? child : document.createTextNode(String(child)),
+    );
+  }
+  return node;
+}
+
+/** 清空一个容器 —— 比 `innerHTML = ''` 明确,也不会触发 HTML 解析。 */
+export function clear(node) {
+  while (node.firstChild) node.removeChild(node.firstChild);
+  return node;
+}
diff --git a/processor/web/static/js/shared/format.js b/processor/web/static/js/shared/format.js
new file mode 100644
index 0000000000000000000000000000000000000000..6a466477cf130d94b25c76bab6c3a919f1ebca39
--- /dev/null
+++ b/processor/web/static/js/shared/format.js
@@ -0,0 +1,46 @@
+/** 展示层格式化工具 —— 纯函数,不碰 DOM、不发请求。
+ *
+ * 单独成文件的原因:checkpoints 与 params 两个视图都要用,而它们之间不该
+ * 互相依赖。放在这里,两边都只依赖这一个叶子模块。
+ */
+
+/**
+ * 字节数 → 人类可读。1024 进制,和后端报的 total_bytes 口径一致。
+ * 0 与非法值都返回 '0 B'(不返回 NaN —— 它会在表格里显示成 "NaN MB")。
+ */
+export function bytes(n) {
+  const v = Number(n);
+  if (!Number.isFinite(v) || v <= 0) return '0 B';
+  const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+  let i = 0;
+  let x = v;
+  while (x >= 1024 && i < units.length - 1) {
+    x /= 1024;
+    i += 1;
+  }
+  // 字节和 KB 不留小数(4.0 KB 不如 4 KB 好读),MB 以上留一位。
+  return `${i <= 1 ? Math.round(x) : x.toFixed(1)} ${units[i]}`;
+}
+
+/**
+ * Unix 秒 → `YYYY-MM-DD HH:MM`。
+ *
+ * 刻意不用 toLocaleString:它受浏览器语言影响,中英切换时同一个时间会变成
+ * 两种格式,表格列宽跟着跳。这里固定格式,与时区无关的部分保持稳定。
+ */
+export function dateTime(seconds) {
+  const v = Number(seconds);
+  if (!Number.isFinite(v) || v <= 0) return '—';
+  const d = new Date(v * 1000);
+  if (Number.isNaN(d.getTime())) return '—';
+  const p = (x) => String(x).padStart(2, '0');
+  return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())} `
+    + `${p(d.getHours())}:${p(d.getMinutes())}`;
+}
+
+/** 大整数 → 千分位。20000 显示成 20,000,免得数零。 */
+export function thousands(n) {
+  const v = Number(n);
+  if (!Number.isFinite(v)) return '—';
+  return v.toLocaleString('en-US');
+}
diff --git a/processor/web/static/js/shared/text.js b/processor/web/static/js/shared/text.js
new file mode 100644
index 0000000000000000000000000000000000000000..4c01d981d73621dfe04d2d09876640dde759c0a1
--- /dev/null
+++ b/processor/web/static/js/shared/text.js
@@ -0,0 +1,17 @@
+/** i18n 桥接 —— 把经典脚本 i18n.js 的全局 `t()` 包一层。
+ *
+ * 为什么要单独一个文件:应用的词典在 `static/js/i18n.js`,那是个**经典脚本**
+ * (没有 export),ES module 里 `import ... from '../i18n.js'` 拿不到任何东西。
+ * 与其让每个视图自己去摸 `window.t`,不如集中在这一处,顺带做防御:
+ *
+ * 页面照常渲染优先于文案语言正确 —— i18n.js 万一没加载(脚本 404、加载顺序
+ * 出问题),退回英文而不是抛异常、白屏。三个视图都依赖本模块,所以只写一份。
+ */
+
+/**
+ * @param {string} key      词典键
+ * @param {string} fallback 取不到时的英文兜底
+ */
+export function tr(key, fallback) {
+  return typeof window.t === 'function' ? window.t(key) : fallback;
+}
diff --git a/processor/web/static/js/slice-preview.js b/processor/web/static/js/slice-preview.js
index 389813ca5dfb8f1bd5f97bd1b0bd5aad58a23b9a..e4922c1a8920cc4d374a2328798ca6c66b6effbf 100644
--- a/processor/web/static/js/slice-preview.js
+++ b/processor/web/static/js/slice-preview.js
@@ -181,7 +181,7 @@
         const boundaryBad = seg.boundary_ok === false || seg.label_matched === false;
         mid.innerHTML = `
             <div style="color:${isCurrent ? '#e0f2fe' : '#d1d5db'};white-space:normal;overflow-wrap:anywhere;line-height:1.35;">
-                ${isCandidate ? '<span style="color:#22d3ee;" title="AI candidate">✨</span> ' : ''}${boundaryBad ? '<span style="color:#f59e0b;" title="边界可疑或标签未命中词表">⚠</span> ' : ''}${globalIdx + 1} · ${esc(seg.label || '—')}
+                ${isCandidate ? '<span style="color:#22d3ee;" title="AI candidate">✨</span> ' : ''}${boundaryBad ? '<span style="color:#f59e0b;" title="' + t('slice_boundary_suspect') + '">⚠</span> ' : ''}${globalIdx + 1} · ${esc(seg.label || '—')}
             </div>
             <div style="color:#9ca3af;font-family:monospace;font-size:10px;">
                 ${seg.start_frame_index}-${seg.end_frame_index} · ${(seg.start_frame_index / fps).toFixed(1)}s
diff --git a/processor/web/static/js/train/api.js b/processor/web/static/js/train/api.js
new file mode 100644
index 0000000000000000000000000000000000000000..e1bd1682094135ed10e81036622a6d41d16eb63b
--- /dev/null
+++ b/processor/web/static/js/train/api.js
@@ -0,0 +1,86 @@
+/** 训练页的后端调用 —— 全页只有这里出现 `fetch`。
+ *
+ * **这里刻意没有**提交训练 / 停止 / 删除 / 下载。本期不接后端执行,与其放一个
+ * 点了会 404 的函数,不如等端点真正存在时再加进来 —— 视图层也就不会误以为
+ * 它们可用。将来接执行时,新端点加在本文件顶部即可,形状保持一致。
+ *
+ * 对应后端:`app/routes/training.py`(只读,不执行任何训练)。
+ */
+
+const BASE = '/api/v1/training';
+
+async function getJSON(url) {
+  const res = await fetch(url, { headers: { Accept: 'application/json' } });
+  if (!res.ok) {
+    // 后端的错误体是 {detail: ...}。取不到就退回状态码 —— 不要吞成空消息,
+    // 否则页面上只剩一个没有原因的空白。
+    let detail = '';
+    try {
+      detail = (await res.json()).detail || '';
+    } catch {
+      /* 非 JSON 响应(网关/代理错误页),用状态码兜底 */
+    }
+    throw new Error(detail || `${res.status} ${res.statusText}`);
+  }
+  return res.json();
+}
+
+/**
+ * 列出训练产物。
+ *
+ * @returns {Promise<{runs: Array, root: string, exists: boolean}>}
+ *   `exists: false` 表示训练目录不存在(新机器、或本机从未跑过训练)。
+ *   这是**正常情况**,由调用方渲染空态,不要当错误抛。
+ */
+export function listRuns() {
+  return getJSON(`${BASE}/runs`);
+}
+
+/**
+ * 单个 checkpoint 文件的下载地址 —— 给 `<a download>` 用的**字符串**,不是请求。
+ *
+ * 路由是 ``/runs/{run}/checkpoints/{step}/files/{name:path}``,``{name:path}`` 要收
+ * 子目录路径(``pretrained_model/model.safetensors``),所以**整体保留斜杠、只逐段
+ * 编码**;整串 encodeURIComponent 会把斜杠也编掉,后端就找不到文件。
+ */
+export function checkpointFileUrl(runName, step, name) {
+  const seg = encodeURIComponent;
+  const path = String(name).split('/').map(seg).join('/');
+  return `${BASE}/runs/${seg(runName)}/checkpoints/${seg(step)}/files/${path}`;
+}
+
+/**
+ * 本机 GPU 列表(读 nvidia-smi)。
+ *
+ * @returns {Promise<{available: boolean, error: string, gpus: Array}>}
+ *   `available: false` 表示**问不到显卡**(驱动没起来 / 没装 nvidia-smi),
+ *   与"显卡闲着"完全是两回事 —— 调用方必须区别显示,不能当 0 用。
+ */
+export function listGpus() {
+  return getJSON(`${BASE}/gpus`);
+}
+
+/**
+ * 可训练的数据集 = `sessions/<项目>` 下的多集 LeRobot 树。
+ *
+ * 不是 `state/exports/*`:那里每条都是单集导出(total_episodes=1),凑不成训练集。
+ */
+export function listDatasets() {
+  return getJSON(`${BASE}/datasets`);
+}
+
+/**
+ * 各项目离「可以导出」还有多远 —— 训练页的「到点提醒」用。
+ *
+ * 判据是**已通过集数达到项目设置的采集上限**(`params.target_episodes`),
+ * 到点只提醒、不自动导出 —— 理由见 `app/training/projects.py` 的 docstring。
+ *
+ * @returns {Promise<{projects: Array, ready_count: number}>}
+ */
+export function listReadyProjects() {
+  return getJSON(`${BASE}/ready`);
+}
+
+// 注:这里曾经有一个 listEpisodes()(走 /api/v1/ingestion/episodes 逐个勾选
+// episode)。改成"按数据集(项目)选"之后就没人用了,已删除 —— 等真要做
+// "从已审核的集组装训练集"那一步时再加回来,那时它多半还要带上筛选参数。
diff --git a/processor/web/static/js/train/checkpoints.js b/processor/web/static/js/train/checkpoints.js
new file mode 100644
index 0000000000000000000000000000000000000000..7ca8f6c2d613ecbea0666bb15d148dfccb0be709
--- /dev/null
+++ b/processor/web/static/js/train/checkpoints.js
@@ -0,0 +1,152 @@
+/** 「模型输出」页签 —— 每个 checkpoint 一个可展开块 + 文件明细表。
+ *
+ * 数据全部来自磁盘真实文件(后端 rglob 出来的),没有任何凑数的假行。
+ *
+ * **下载已经能用了** —— 文件表逐行一个链接,走后端
+ * ``GET /runs/{run}/checkpoints/{step}/files/{name:path}``(逐文件而不是整包:
+ * 一个 checkpoint 约 600MB,其中 training_state/ 只在续训时有用)。
+ *
+ * **其余操作按钮仍然 disabled**:删除 / 推理 / 离线部署都还没有端点。做成可点
+ * 但没反应是最糟的 —— 用户会反复点、以为坏了。disabled 加上 title 说明,一眼就
+ * 知道"还没接",和有端点了再放开是两回事。
+ */
+
+import { el, clear } from '../shared/dom.js';
+import { bytes, dateTime } from '../shared/format.js';
+import { tr } from '../shared/text.js';
+import { checkpointFileUrl } from './api.js';
+
+/** 逐个文件一行。文件名可能很长(pretrained_model/xxx.safetensors),
+ *  用 break-all 而不是省略号 —— 训练产物看的就是完整名字。 */
+function fileRow(runName, checkpoint, file) {
+  return el('tr', { class: 'border-b border-gray-800/60 last:border-0' }, [
+    el('td', { class: 'py-1.5 pr-4 text-gray-300 font-mono text-[11px] break-all', text: file.name }),
+    el('td', { class: 'py-1.5 pr-4 text-gray-400 text-right whitespace-nowrap', text: bytes(file.size) }),
+    el('td', { class: 'py-1.5 pr-4 text-gray-500 whitespace-nowrap', text: dateTime(file.mtime) }),
+    el('td', { class: 'py-1.5 text-right whitespace-nowrap' }, [
+      // 带 download 属性:浏览器直接存盘,不跳转到一个只会显示二进制内容的页面。
+      el('a', {
+        class: 'text-blue-400 hover:underline',
+        href: checkpointFileUrl(runName, checkpoint.name, file.name),
+        download: true,
+        text: tr('train_btn_download', 'Download'),
+      }),
+    ]),
+  ]);
+}
+
+function fileTable(runName, checkpoint) {
+  return el('table', { class: 'w-full text-xs mt-3' }, [
+    el('thead', {}, [
+      el('tr', { class: 'border-b border-gray-800' }, [
+        el('th', { class: 'text-left py-1.5 pr-4 font-medium text-gray-500', text: tr('train_col_name', 'Name') }),
+        el('th', { class: 'text-right py-1.5 pr-4 font-medium text-gray-500', text: tr('train_col_size', 'Size') }),
+        el('th', { class: 'text-left py-1.5 pr-4 font-medium text-gray-500', text: tr('train_col_mtime', 'Modified') }),
+        el('th', { class: 'text-right py-1.5 font-medium text-gray-500' }),
+      ]),
+    ]),
+    el('tbody', {}, checkpoint.files.map((f) => fileRow(runName, checkpoint, f))),
+  ]);
+}
+
+/** **真的还没接端点**的按钮 —— disabled,title 说明原因。 */
+function pendingButton(label, hint) {
+  return el('button', {
+    class: 'text-[11px] px-2 py-1 rounded border border-gray-700 text-gray-600 cursor-not-allowed',
+    text: label,
+    disabled: true,
+    title: hint,
+  });
+}
+
+/** 能点的按钮。 */
+function actionButton(label, hint, onClick) {
+  return el('button', {
+    class: 'text-[11px] px-2 py-1 rounded border border-gray-600 text-gray-300 '
+      + 'hover:border-gray-500 hover:text-gray-100',
+    title: hint,
+    text: label,
+    on: { click: onClick },
+  });
+}
+
+function checkpointBlock(runName, checkpoint, expanded, handlers) {
+  const body = el('div', { class: expanded ? '' : 'hidden' }, [fileTable(runName, checkpoint)]);
+  const chevron = el('span', {
+    class: 'text-gray-500 text-[10px] transition-transform',
+    text: expanded ? '▾' : '▸',
+  });
+
+  const toggle = () => {
+    body.classList.toggle('hidden');
+    const open = !body.classList.contains('hidden');
+    chevron.textContent = open ? '▾' : '▸';
+  };
+
+  return el('div', { class: 'bg-gray-900 rounded-lg border border-gray-800 p-4' }, [
+    el('div', { class: 'flex items-center flex-wrap gap-3' }, [
+      el('iconify-icon', { icon: 'ant-design:folder-outlined', class: 'text-base' }),
+      el('span', { class: 'text-gray-200 font-mono font-semibold', text: checkpoint.name }),
+      el('span', {
+        class: 'text-[10px] px-1.5 py-0.5 rounded bg-blue-900/50 text-blue-300',
+        text: tr('train_step_badge', 'Step'),
+      }),
+      el('span', {
+        class: 'text-xs text-gray-500',
+        text: `${checkpoint.file_count} ${tr('train_files_unit', 'files')}`
+        + ` · ${bytes(checkpoint.total_bytes)}`,
+      }),
+      el('div', { class: 'ml-auto flex gap-2' }, [
+        // 「下载」= **展开文件表**(那里每行才有真下载)。不做整包下载:一个
+        // checkpoint 约 600MB,其中 training_state/(优化器状态,约 400MB)只在
+        // 续训时有用;拿去推理/部署只要 pretrained_model/(约 200MB)。
+        // 要"一键整包"得后端加一个压 zip 的端点,本期没有。
+        actionButton(tr('train_btn_download', 'Download'),
+                     tr('train_btn_hint_download_row',
+                        'Expand the file list — each file downloads individually'),
+                     () => { if (body.classList.contains('hidden')) toggle(); }),
+        // 「推理」= 跳到「模型推理」页签并选中本检查点。**纯前端跳转,不需要后端** ——
+        // 那正是"我要拿这个模型去推理"的自然动作。
+        actionButton(tr('train_btn_infer', 'Inference'),
+                     tr('train_btn_hint_infer_row',
+                        'Open the Inference tab with this checkpoint selected'),
+                     () => handlers?.onInfer?.(checkpoint)),
+        pendingButton(tr('train_btn_delete', 'Delete'),
+                      tr('train_btn_hint_delete', 'Destructive; no endpoint yet')),
+        pendingButton(tr('train_btn_deploy', 'Offline Deploy'),
+                      tr('train_btn_hint_deploy', 'Belongs to the Deployment module')),
+      ]),
+    ]),
+    el('button', {
+      class: 'mt-3 text-xs text-gray-500 hover:text-gray-300 flex items-center gap-1.5',
+      on: { click: toggle },
+    }, [chevron, el('span', { text: tr('train_file_details', 'File details') })]),
+    body,
+  ]);
+}
+
+/**
+ * @param {HTMLElement} container
+ * @param {object} run  后端给的一个 run(`{name, checkpoints, …}`)—— 需要 name
+ *                      才能拼出文件下载地址(`/runs/{name}/checkpoints/{step}/files/…`)
+ * @param {{onInfer?: (checkpoint: object) => void}} [handlers]
+ *        由 train/main.js 注入 —— 本模块不认识"页签"这回事,只负责喊一声。
+ */
+export function renderCheckpoints(container, run, handlers = {}) {
+  clear(container);
+  const checkpoints = run.checkpoints || [];
+
+  if (checkpoints.length === 0) {
+    container.appendChild(el('div', {
+      class: 'text-center text-gray-600 text-sm py-10',
+      text: tr('train_checkpoints_empty', 'No checkpoints under this run.'),
+    }));
+    return;
+  }
+
+  // **全部默认折叠。** 曾经让最新的那个默认展开,但一进页面就被一大堆文件名
+  // (每个 checkpoint 11 个文件)顶下去,反而看不到下面还有几个 checkpoint。
+  // 折叠状态下每行就是一行摘要,扫一眼能看全;要看细节自己点。
+  container.appendChild(el('div', { class: 'space-y-3' },
+    checkpoints.map((c) => checkpointBlock(run.name, c, false, handlers))));
+}
diff --git a/processor/web/static/js/train/main.js b/processor/web/static/js/train/main.js
new file mode 100644
index 0000000000000000000000000000000000000000..5f525910e0517fd3de7ac57b476fc04a9f7e8a03
--- /dev/null
+++ b/processor/web/static/js/train/main.js
@@ -0,0 +1,296 @@
+/** 训练页入口 —— 取数据、画任务头、组织页签。
+ *
+ * 这是 `static/js/train/` 下唯一的入口,由 `templates/train.html` 以
+ * `<script type="module" src=".../main.js?v={{ asset_version }}">` 引入。
+ * 其余文件都是被它 import 的模块 —— 新页面不再往 app.js 里堆代码。
+ *
+ * 缓存注意:子模块的相对 import 解析出的 URL 不带查询串,靠 `main.py` 里
+ * `static_cache_headers` 对「/static/js/ 下无查询串的 JS」发 no-cache 来保证
+ * 不会出现新旧模块混用。改动中间件前先看那段注释。
+ */
+
+import { listRuns } from './api.js';
+import { el, clear } from '../shared/dom.js';
+import { bytes } from '../shared/format.js';
+import { tr } from '../shared/text.js';
+import { renderCheckpoints } from './checkpoints.js';
+import { renderParams } from './params.js';
+import { renderNewRun } from './newrun.js';
+import { renderInference } from '../inference/view.js';
+
+/**
+ * 页签定义。
+ *
+ * ⚠ **「训练指标」与「实时日志」故意不在这里。** 训练由官方 `lerobot-train`
+ * 在平台之外执行,没有保存 loss/lr/grad_norm 曲线,也没有留日志 —— 没有数据
+ * 的页签就不显示(摆一个空页签比不摆更让人以为功能坏了)。将来接上训练执行、
+ * 有了指标落盘,把这两项加回数组即可,`available()` 会自动判断。
+ */
+const TABS = [
+  {
+    id: 'checkpoints',
+    label: () => tr('train_tab_checkpoints', 'Model Output'),
+    available: (run) => (run.checkpoints || []).length > 0,
+    render: (panel, run, ctx) => renderCheckpoints(panel, run, {
+      onInfer: (checkpoint) => ctx?.goToInference?.(run.name, checkpoint.name),
+    }),
+  },
+  {
+    id: 'params',
+    label: () => tr('train_tab_params', 'Training Config'),
+    available: (run) => {
+      const newest = (run.checkpoints || [])[0];
+      return !!newest && Object.keys(newest.train_config || {}).length > 0;
+    },
+    render: (panel, run) => {
+      const newest = run.checkpoints[0];
+      renderParams(panel, newest.train_config, { step: newest.step });
+    },
+  },
+];
+
+function field(label, value, extraClass = '') {
+  return el('div', { class: `flex items-baseline gap-2 text-xs ${extraClass}` }, [
+    el('span', { class: 'text-gray-500', text: `${label}:` }),
+    el('span', { class: 'text-gray-300 font-mono break-all', text: value }),
+  ]);
+}
+
+/** 任务头:名字 + 模型类型 + 产物概况 + 输出目录。 */
+function renderRunHeader(run, root) {
+  const newest = (run.checkpoints || [])[0];
+  return el('div', { class: 'bg-gray-900 rounded-lg border border-gray-800 p-4 mb-4' }, [
+    el('div', { class: 'flex items-start flex-wrap gap-4' }, [
+      el('div', { class: 'min-w-0' }, [
+        el('div', { class: 'text-base font-semibold text-gray-100 font-mono', text: run.name }),
+        el('div', {
+          class: 'text-xs text-gray-500 mt-1',
+          text: `${run.checkpoint_count} 个 checkpoint · ${bytes(run.total_bytes)}`
+            + (newest ? ` · 最新 ${newest.name} 步` : ''),
+        }),
+      ]),
+      el('div', { class: 'ml-auto flex flex-col gap-1 items-end' }, [
+        field(tr('train_label_model', 'Model'), run.model_type || '—'),
+        field(tr('train_label_location', 'Location'), root, 'text-gray-500'),
+      ]),
+    ]),
+  ]);
+}
+
+/** 页签态样式。集中在这里,是因为切换时只改 className —— 重建 DOM 会丢掉
+ *  各页签自己的展开/折叠状态(文件明细表默认展开最新那个)。 */
+const ACTIVE_TAB = 'px-3 py-1.5 text-xs rounded-t border-b-2 -mb-px transition-colors '
+  + 'border-blue-500 text-blue-300 font-medium';
+const IDLE_TAB = 'px-3 py-1.5 text-xs rounded-t border-b-2 -mb-px transition-colors '
+  + 'border-transparent text-gray-500 hover:text-gray-300';
+
+/** 页签栏 + 面板。只渲染 available() 为真的页签。 */
+function renderTabs(container, run, ctx = {}) {
+  clear(container);
+
+  const usable = TABS.filter((tab) => tab.available(run));
+  if (!usable.length) {
+    container.appendChild(el('div', {
+      class: 'text-center text-gray-600 text-sm py-10',
+      text: tr('train_no_output', 'This run has no checkpoints to show.'),
+    }));
+    return;
+  }
+
+  const bar = el('div', { class: 'flex gap-2 px-1 border-b border-gray-800 mb-4' });
+  const panels = el('div', {});
+
+  const buttons = usable.map((tab, index) => {
+    const panel = el('div', { class: index === 0 ? '' : 'hidden' });
+    panels.appendChild(panel);
+    tab.render(panel, run, ctx);
+
+    const button = el('button', {
+      class: 'px-3 py-1.5 text-xs rounded-t border-b-2 -mb-px transition-colors',
+      text: tab.label(),
+    });
+    button.addEventListener('click', () => {
+      // 只改 class,不重建面板 —— 重建会丢掉各页签自己的展开/折叠状态。
+      buttons.forEach((other, i) => {
+        other.className = i === index ? ACTIVE_TAB : IDLE_TAB;
+      });
+      usable.forEach((_, i) => {
+        panels.children[i].classList.toggle('hidden', i !== index);
+      });
+    });
+    bar.appendChild(button);
+    return button;
+  });
+
+  buttons[0].className = ACTIVE_TAB;
+  container.appendChild(bar);
+  container.appendChild(panels);
+}
+
+export function emptyState(message) {
+  return el('div', { class: 'text-center text-gray-600 text-sm py-16' }, [
+    el('div', { class: 'text-3xl text-gray-600 mb-3' }, [
+      el('iconify-icon', { icon: 'ant-design:folder-outlined' }),
+    ]),
+    el('div', { text: message }),
+  ]);
+}
+
+/** 「模型训练」页签的内容 —— 每次调用重新拉一次数据并重画。
+ *  ``ctx.goToInference`` 是 boot() 注入的跨页签跳转能力(检查点行的「推理」按钮用)。 */
+async function renderRunsPanel(host, _arg, ctx = {}) {
+  clear(host);
+  host.appendChild(el('div', {
+    class: 'text-center text-gray-600 text-sm py-10',
+    text: tr('loading', 'Loading...'),
+  }));
+
+  let payload;
+  try {
+    payload = await listRuns();
+  } catch (err) {
+    clear(host);
+    host.appendChild(el('div', {
+      class: 'text-center text-red-400 text-sm py-10',
+      text: `${tr('train_load_failed', 'Failed to load training runs')}: ${err.message}`,
+    }));
+    return;
+  }
+
+  clear(host);
+
+  if (!payload.exists) {
+    // 目录不存在是正常的(新机器/本机没训过),说清楚路径比说"没有数据"有用 ——
+    // 用户能立刻判断是不是路径配错了。
+    host.appendChild(emptyState(
+      `${tr('train_no_root', 'No training directory on this host')}: ${payload.root}`,
+    ));
+    return;
+  }
+  if (!payload.runs.length) {
+    host.appendChild(emptyState(
+      `${tr('train_no_runs', 'No training output found under')} ${payload.root}`,
+    ));
+    return;
+  }
+
+  for (const run of payload.runs) {
+    host.appendChild(renderRunHeader(run, payload.root));
+    const tabs = el('div', {});
+    renderTabs(tabs, run, ctx);
+    host.appendChild(tabs);
+  }
+}
+
+/** 顶部一级页签 —— 切的是**整块内容**(已有产物 / 新建向导 / 推理),
+ *  跟卡片里「模型输出 / 训练参数」那层子页签不是一回事。
+ *
+ *  推理曾经是侧边栏里独立的一项(独立页面 + 独立路由),后来并进来 —— 它和训练
+ *  本来就是同一批产物的上下游,分两个导航项反而要来回跳。侧边栏现在只有
+ *  「模型」一个一级项,点进来就是这三个页签。 */
+// 顺序即**展示顺序**,也决定**默认打开哪个** —— 下面 boot() 里把第 0 个设为激活。
+// 用户指定:新建训练 → 模型训练 → 模型推理。
+const PAGE_TABS = [
+  {
+    id: 'new',
+    label: () => tr('train_page_new', 'New Training'),
+    icon: 'ant-design:plus-outlined',
+    render: renderNewRun,
+  },
+  {
+    id: 'runs',
+    label: () => tr('train_page_runs', 'Model Training'),
+    icon: 'ant-design:ordered-list-outlined',
+    render: renderRunsPanel,
+  },
+  {
+    id: 'inference',
+    label: () => tr('train_page_inference', 'Model Inference'),
+    icon: 'ant-design:play-circle-outlined',
+    render: renderInference,
+  },
+];
+
+const PAGE_ACTIVE = 'px-4 py-2 text-sm rounded-t border-b-2 -mb-px transition-colors '
+  + 'border-blue-500 text-blue-300 font-semibold flex items-center gap-1.5';
+const PAGE_IDLE = 'px-4 py-2 text-sm rounded-t border-b-2 -mb-px transition-colors '
+  + 'border-transparent text-gray-500 hover:text-gray-300 flex items-center gap-1.5';
+
+function boot() {
+  const host = document.getElementById('train-runs');
+  if (!host) return;
+  clear(host);
+
+  const bar = el('div', { class: 'flex gap-1 border-b border-gray-800 mb-5' });
+  const panels = el('div', {});
+  const INFERENCE_INDEX = PAGE_TABS.findIndex((t) => t.id === 'inference');
+
+  /** 切到某个页签。
+   *
+   *  ``arg`` 有值时**强制重渲染**该面板 —— 用于「在检查点行上点『推理』,跳到
+   *  推理页签并选中它」:那个面板很可能早就渲染过了(用户先前点过),不重渲染
+   *  的话带不进去这个参数。
+   *
+   *  没有 arg 时仍然是**第一次显示才渲染** —— 否则一进页面就把三个页签的数据
+   *  全拉一遍(其中推理页要拉 runs + datasets 两份)。
+   */
+  function selectTab(index, arg) {
+    buttons.forEach((other, i) => {
+      other.className = i === index ? PAGE_ACTIVE : PAGE_IDLE;
+    });
+    for (let i = 0; i < panels.children.length; i += 1) {
+      panels.children[i].classList.toggle('hidden', i !== index);
+    }
+    const panel = panels.children[index];
+    if (arg !== undefined || !panel.dataset.rendered) {
+      panel.dataset.rendered = '1';
+      // 第三个参数是**导航能力**,注入给需要跨页签跳转的面板(见下面的 TABS)。
+      PAGE_TABS[index].render(panel, arg, {
+        goToInference: (runName, checkpointName) => selectTab(
+          INFERENCE_INDEX, { runName, checkpointName }),
+      });
+    }
+  }
+
+  const buttons = PAGE_TABS.map((tab, index) => {
+    const panel = el('div', { class: index === 0 ? '' : 'hidden' });
+    panels.appendChild(panel);
+
+    const button = el('button', { class: PAGE_IDLE, title: tab.label() }, [
+      el('iconify-icon', { icon: tab.icon, class: 'icon-sm' }),
+      el('span', { text: tab.label() }),
+    ]);
+    button.addEventListener('click', () => selectTab(index));
+    bar.appendChild(button);
+    return button;
+  });
+
+  host.appendChild(bar);
+  host.appendChild(panels);
+
+  // 首个页签立即渲染;其余等第一次显示
+  selectTab(0);
+}
+
+// ★ 必须等 DOMContentLoaded,不能在模块求值时直接跑。
+//
+// ES module 是 **deferred** 的:它在"文档解析完、DOMContentLoaded 还没触发"这个
+// 中间态执行,此时 readyState === 'interactive' —— 所以原来那句
+// `if (readyState === 'loading')` 为假,直接走了 else 分支**当场渲染**。
+//
+// 而 i18n.js 要到自己的 DOMContentLoaded 回调里才从 localStorage 读出语言
+// (它的 currentLang 默认写死 'en')。于是**同步渲染的那批先出来,是英文**,
+// 而 await 之后才渲染的那批(子页签)已经是中文了 —— 同一页上半英半中。
+//
+// 判据用 !== 'complete' 而不是 === 'loading':interactive 也算"还没 fire",
+// 这时挂监听一定会被调到。只有文档已经彻底加载完(动态 import 进来)才直接跑。
+if (document.readyState !== 'complete') {
+  document.addEventListener('DOMContentLoaded', boot);
+} else {
+  boot();
+}
+
+// 切语言后重画。本页内容全是 JS 现画的,i18n.js 的 setLang() 只会去翻 DOM 上的
+// data-i18n 属性,翻不到动态生成的这些节点 —— 不重跑一遍 boot(),页面会半中半英。
+// 其它动态页面(dashboard / tasks / users)也是这么接这个事件的。
+window.addEventListener('egodata:lang', boot);
diff --git a/processor/web/static/js/train/newrun.js b/processor/web/static/js/train/newrun.js
new file mode 100644
index 0000000000000000000000000000000000000000..81db992affec8d6664f33810a845a67b92350596
--- /dev/null
+++ b/processor/web/static/js/train/newrun.js
@@ -0,0 +1,411 @@
+/** 「新建训练」页签 —— 五段式向导。
+ *
+ *   ① 训练数据集(审核页导出后留下的成品,见 state/datasets/)
+ *   ② 选择模型(ACT)+ 训练框架(LeRobot,只读)
+ *   ③ 训练位置(私有算力 + 勾选参与训练的 GPU)
+ *   ④ 训练参数(每项带一句说明)
+ *   ⑤ 从已有训练继续(可选)
+ *
+ * **本期只做前端 —— 所以这一页是纯表单。**
+ *
+ * 这里曾经有一个禁用的「创建训练任务」按钮、外加一条生成好的 `lerobot-train`
+ * 命令行(带复制 / 下载 .sh)。已经删掉了:后端执行接上之前,那两样要么是假的
+ * 按钮,要么是绕路把命令当交付物。等真接上后端时,直接加一个**能点的**按钮,
+ * 把下面这些字段 POST 出去即可 —— 表单本身就已经是接口形状了。
+ *
+ * ★ 相应地,现在这一页的选择(数据集 / GPU / 参数 / 续训)**都不驱动任何输出**。
+ *   它们是为将来后端准备的状态,不是装饰;但也别指望现在改一下会有什么反应。
+ *
+ * 只有 ACT —— 其它策略(π0 / SmolVLA / diffusion…)都是 LeRobot 内置、跑得通,
+ * 但没在这套硬件上实测过,所以不摆一排点不动的卡片。
+ */
+
+import { el, clear } from '../shared/dom.js';
+import { bytes, dateTime, thousands } from '../shared/format.js';
+import { tr } from '../shared/text.js';
+import { listDatasets, listGpus, listReadyProjects, listRuns } from './api.js';
+
+/** 默认超参 —— 取自**实测那一次**的真实 train_config.json
+ *  (checkpoints/020000),不是参考实现的示例值。
+ *
+ *  参考实现里 batch_size=2、steps=10000 是给它那个 8GB 的 pi0 用的;我们这次
+ *  198MB 的 ACT 在这台机器上 batch_size=16 / steps=20000 是跑通过的。首次训练
+ *  用跑通过的更稳。 */
+const DEFAULTS = {
+  job_name: 'act',
+  batch_size: 16,
+  steps: 20000,
+  seed: 1000,
+  num_workers: 4,
+  eval_freq: 1000,
+  log_freq: 100,
+  save_checkpoint: true,
+  save_freq: 5000,
+};
+
+/** 参数说明 —— 直接对应参考实现每项右侧那句话,首次训练的人看得懂。 */
+const PARAM_HELP = {
+  job_name: ['train_help_job_name', 'Name of this run. It becomes the checkpoint folder name, so keep it short and unique.'],
+  batch_size: ['train_help_batch', 'Larger batches train more stably but need more VRAM; smaller ones are faster but less stable. Suggested 1-32.'],
+  steps: ['train_help_steps', 'More steps usually improve the policy but risk overfitting. Start at 10000 and adjust from validation.'],
+  seed: ['train_help_seed', 'A fixed seed reproduces the same run, which makes debugging and comparison possible. 1000 or 42.'],
+  num_workers: ['train_help_workers', 'More workers load data faster but use more memory. About 1/2 to 1x the CPU core count.'],
+  eval_freq: ['train_help_eval_freq', 'How often to run an evaluation, in steps. About 10% of total steps.'],
+  log_freq: ['train_help_log_freq', 'How often to refresh progress, in steps. 10-100 works well.'],
+  save_checkpoint: ['train_help_save_ckpt', 'Save checkpoints while training so a run can be resumed or deployed.'],
+  save_freq: ['train_help_save_freq', 'How often to save a checkpoint, in steps. About 30% of total steps.'],
+};
+
+
+const INPUT_CLASS = 'bg-gray-800 text-xs rounded px-2 py-1 border border-gray-700 '
+  + 'focus:border-blue-500 focus:outline-none font-mono';
+const BTN = 'bg-gray-800 hover:bg-gray-700 text-gray-300 text-xs px-2.5 py-1 '
+  + 'rounded border border-gray-700';
+
+const LIVE = 'bg-green-900/50 text-green-300';
+const PENDING = 'bg-amber-900/50 text-amber-300';
+
+function section(titleKey, fallback, badge, children) {
+  return el('div', { class: 'bg-gray-900 rounded-lg border border-gray-800 p-4 mb-4' }, [
+    el('div', { class: 'flex items-center gap-3 mb-3' }, [
+      el('div', { class: 'text-sm font-semibold text-gray-200', text: tr(titleKey, fallback) }),
+      badge ? el('span', { class: `text-[10px] px-1.5 py-0.5 rounded ${badge.cls}`, text: badge.text }) : null,
+    ]),
+    ...children,
+  ]);
+}
+
+function hint(key, fallback) {
+  return el('div', { class: 'text-xs text-gray-600 mt-3', text: tr(key, fallback) });
+}
+
+/** 一行「标签 + 控件」,失败/加载中都用它占位。 */
+function labeled(label, control, labelClass = 'text-gray-500 shrink-0 w-32') {
+  return el('div', { class: 'flex items-center gap-3 text-xs' }, [
+    el('span', { class: labelClass, text: label }),
+    control,
+  ]);
+}
+
+function loadingRow(text) {
+  return el('div', { class: 'text-xs text-gray-600 py-3', text });
+}
+
+function errorRow(text) {
+  return el('div', { class: 'text-xs text-red-400 py-3', text });
+}
+
+export function renderNewRun(container) {
+  clear(container);
+
+  const state = { gpus: new Set(), dataset: null, resume: null };
+
+  // ── ① 训练位置 ──────────────────────────────────────
+  const gpuHost = el('div', {});
+  const locationCard = el('div', {
+    class: 'inline-block border-2 border-blue-500 bg-blue-950/30 rounded-lg px-4 py-3 min-w-[220px]',
+  }, [
+    el('div', { class: 'text-sm font-semibold text-gray-100', text: tr('train_loc_local', 'Local GPU server') }),
+    el('div', { class: 'text-xs text-gray-400 mt-1', text: tr('train_loc_local_desc', 'GPUs on this machine') }),
+  ]);
+
+  const sectionLocation = section('train_sec_location', '1. Training Location', null, [
+    locationCard,
+    el('div', { class: 'mt-4' }, [gpuHost]),
+  ]);
+
+  function renderGpus(payload) {
+    clear(gpuHost);
+    if (!payload.available) {
+      // 驱动没起来时**必须区别显示** —— 渲染成"利用率 0%"会让人以为显卡闲着。
+      gpuHost.appendChild(el('div', {
+        class: 'text-xs text-amber-300 bg-amber-950/40 border border-amber-900 rounded px-3 py-2',
+      }, [
+        el('div', { text: tr('train_gpu_unavailable', 'Cannot read the GPUs') }),
+        el('div', { class: 'text-amber-500/80 mt-1 font-mono break-all', text: payload.error }),
+        el('div', { class: 'text-amber-500/80 mt-1', text: tr('train_gpu_unavailable_hint', 'Fix the driver before training — training cannot start without it.') }),
+      ]));
+      return;
+    }
+    if (!payload.gpus.length) {
+      gpuHost.appendChild(errorRow(tr('train_gpu_none', 'nvidia-smi reported no GPUs.')));
+      return;
+    }
+
+    gpuHost.appendChild(el('div', { class: 'flex gap-3 flex-wrap' },
+      payload.gpus.map((gpu) => {
+        const usedRatio = gpu.memory_total_mb
+          ? Math.round((gpu.memory_used_mb / gpu.memory_total_mb) * 100) : 0;
+        const busy = gpu.utilization > 5 && gpu.index !== 0;
+
+        const checkbox = el('input', {
+          type: 'checkbox', class: 'accent-blue-500',
+          checked: state.gpus.has(gpu.index),
+        });
+        checkbox.addEventListener('change', () => {
+          if (checkbox.checked) state.gpus.add(gpu.index);
+          else state.gpus.delete(gpu.index);
+        });
+
+        return el('div', { class: 'bg-gray-900 border border-gray-800 rounded-lg p-3 w-64' }, [
+          el('div', { class: 'flex items-center gap-2' }, [
+            el('span', { class: 'text-sm font-semibold text-gray-100', text: `GPU ${gpu.index}` }),
+            el('span', {
+              class: `ml-auto text-[10px] px-1.5 py-0.5 rounded ${busy ? 'bg-amber-900/50 text-amber-300' : 'bg-green-900/50 text-green-300'}`,
+              text: busy ? tr('train_gpu_busy', 'busy') : tr('train_gpu_idle', 'idle'),
+            }),
+          ]),
+          el('div', { class: 'text-xs text-gray-400 mt-1', text: gpu.name }),
+          el('div', { class: 'mt-2 text-xs text-gray-500' }, [
+            el('div', { text: `${tr('train_gpu_mem', 'VRAM')} ${gpu.memory_used_mb} / ${gpu.memory_total_mb} MB (${usedRatio}%)` }),
+            el('div', { class: 'h-1.5 bg-gray-800 rounded mt-1' }, [
+              el('div', { class: 'h-1.5 bg-blue-500 rounded', style: `width:${usedRatio}%` }),
+            ]),
+            el('div', { class: 'mt-1', text: `${tr('train_gpu_util', 'Utilization')} ${gpu.utilization}%` }),
+            el('div', { text: `${tr('train_gpu_temp', 'Temp')} ${gpu.temperature}°C` }),
+          ]),
+          el('label', { class: 'flex items-center gap-2 mt-2 text-xs text-gray-400 cursor-pointer' }, [
+            checkbox,
+            el('span', { text: tr('train_gpu_include', 'Use for training') }),
+          ]),
+        ]);
+      })));
+  }
+
+  gpuHost.appendChild(loadingRow(tr('loading', 'Loading...')));
+  listGpus()
+    .then(renderGpus)
+    .catch((err) => { clear(gpuHost); gpuHost.appendChild(errorRow(`${tr('train_load_failed', 'Failed to load')}: ${err.message}`)); });
+
+  // ── ② 选择模型 + 训练框架 ───────────────────────────
+  const modelCard = el('div', {
+    class: 'inline-block border-2 border-blue-500 bg-blue-950/30 rounded-lg px-4 py-3 min-w-[240px]',
+  }, [
+    el('div', { class: 'flex items-center gap-2' }, [
+      el('span', { class: 'text-sm font-semibold text-gray-100', text: 'ACT' }),
+      el('span', { class: 'text-[10px] px-1.5 py-0.5 rounded bg-blue-900/60 text-blue-300', text: tr('train_new_model_tested', 'tested') }),
+    ]),
+    el('div', { class: 'text-xs text-gray-400 mt-1.5', text: tr('train_new_model_act_desc', 'Transformer action-chunking imitation learning policy') }),
+  ]);
+
+  const sectionModel = section('train_sec_model', '2. Model', null, [
+    el('div', { class: 'flex items-start gap-6 flex-wrap' }, [
+      el('div', {}, [modelCard]),
+      el('div', {}, [
+        el('div', { class: 'text-xs text-gray-500 mb-1.5', text: tr('train_framework', 'Training framework') }),
+        // 只读:ACT 在 LeRobot 里只有一种实现,没有可选项。做成下拉框是假的。
+        el('div', {
+          class: 'inline-block bg-gray-800 border border-gray-700 rounded px-3 py-1.5 text-xs text-gray-200 font-mono',
+          text: 'LeRobot',
+        }),
+        el('div', { class: 'text-xs text-gray-600 mt-1.5', text: tr('train_framework_hint', 'ACT ships as a single LeRobot implementation, so there is nothing to choose here.') }),
+      ]),
+    ]),
+  ]);
+
+  // ── ③ 训练参数 ──────────────────────────────────────
+  const paramInputs = {};
+  const paramRows = Object.keys(DEFAULTS).map((name) => {
+    const [helpKey, helpFallback] = PARAM_HELP[name] || ['', ''];
+    let control;
+    if (name === 'save_checkpoint') {
+      control = el('select', { class: INPUT_CLASS + ' w-28' }, [
+        el('option', { value: 'true', text: 'true' }),
+        el('option', { value: 'false', text: 'false' }),
+      ]);
+    } else {
+      control = el('input', { class: INPUT_CLASS + ' w-28', value: String(DEFAULTS[name]) });
+    }
+    paramInputs[name] = control;
+
+    return el('div', { class: 'flex items-start gap-4 text-xs py-1' }, [
+      el('span', { class: 'text-gray-400 shrink-0 w-36 font-mono pt-1.5', text: name }),
+      el('div', { class: 'shrink-0' }, [control]),
+      el('span', { class: 'text-gray-600 pt-1.5 flex items-start gap-1.5' }, [
+        el('iconify-icon', {
+          icon: 'ant-design:info-circle-outlined',
+          class: 'mt-0.5 shrink-0',
+        }),
+        el('span', { text: tr(helpKey, helpFallback) }),
+      ]),
+    ]);
+  });
+
+  const sectionParams = section('train_sec_params', '3. Training Parameters',
+    { cls: PENDING, text: tr('train_new_pending', 'not wired') }, [
+      ...paramRows,
+      el('button', {
+        class: 'mt-3 ' + BTN,
+        text: tr('train_new_reset', 'Restore measured defaults'),
+        on: {
+          click: () => {
+            for (const [name, control] of Object.entries(paramInputs)) control.value = String(DEFAULTS[name]);
+          },
+        },
+      }),
+    ]);
+
+  // ── ④ 训练数据集 ────────────────────────────────────
+  //
+  // 来源是**在视频审核页导出后留下来的成品**(`state/datasets/<名字>`),不是
+  // 原始项目。原始项目里混着未审核的集,而且留出集(UMIGripper_Action_AI 的
+  // 52–73)就在里面 —— 按项目选只能报警、拦不住。改以导出产物为准之后,两个
+  // 坑都在导出那一步被排掉了。
+  //
+  // ★ 正因如此,这里**不再有留出集防线**:导出后的数据集集号会被重排成
+  //   0..N-1,已经认不出哪一集原本是 52–73。控制点转移到了导出那一步 ——
+  //   导出时别把留出集勾进去。要加硬校验的话,位置在审核/导出页而不是这里。
+  const datasetHost = el('div', {});
+  const readyHost = el('div', {});
+
+  const sectionDataset = section('train_sec_dataset', '4. Training Dataset',
+    { cls: LIVE, text: tr('train_new_live', 'live') }, [
+      datasetHost,
+      readyHost,
+    ]);
+
+  /** 「到点提醒」—— 项目已通过集数达到它自己设的采集上限时高亮出来。
+   *
+   *  **只提醒,不自动导出。** 导出一次约 30 秒/集(UI 自己的文案),1000 集要跑
+   *  8 小时以上;而且构建好的数据集会被"固定"下来 —— 已经拿去训练的那份不能
+   *  悄悄变。让人点一下,换到的是"我知道现在在导什么、用哪份数据"。
+   *
+   *  没到点时也给一行「最接近的」,否则这块永远是空的,看不出进展。 */
+  function renderReady(payload) {
+    clear(readyHost);
+    const ready = (payload.projects || []).filter((p) => p.ready);
+
+    if (ready.length) {
+      readyHost.appendChild(el('div', {
+        class: 'mt-3 text-xs bg-green-950/40 border border-green-900 rounded px-3 py-2',
+      }, [
+        el('div', {
+          class: 'text-green-300 font-medium mb-2',
+          text: tr('train_ready_title', 'Reached its collection limit — ready to export'),
+        }),
+        ...ready.map((p) => el('div', { class: 'flex items-center gap-3 py-0.5' }, [
+          el('span', { class: 'text-gray-200 font-mono flex-1 truncate', text: p.name }),
+          el('span', { class: 'text-gray-400 shrink-0', text: `${p.approved} / ${p.target}` }),
+          el('a', {
+            href: '/review?status=approved',
+            class: 'text-blue-400 hover:underline shrink-0',
+            text: tr('train_ready_go', 'Go export'),
+          }),
+        ])),
+      ]));
+      return;
+    }
+
+    // 没到点就**什么都不显示** —— 曾经在这里给一行「离采集上限最近的 X: n/N」,
+    // 但它每次都在,而绝大多数时候又离得很远(实测 3/100、52/10000),读起来像
+    // 一句永远不变的噪音。到点了自然会冒出来,没到点就安静待着。
+  }
+
+  function datasetEmptyState() {
+    return el('div', { class: 'text-center py-6' }, [
+      el('div', { class: 'text-xs text-gray-500 mb-3', text: tr('train_dataset_none', 'No exported dataset yet.') }),
+      el('a', {
+        href: '/review?status=approved',
+        class: 'inline-block bg-blue-600 hover:bg-blue-500 text-white text-xs px-3 py-1.5 rounded',
+        text: tr('train_dataset_goto_export', 'Go export approved episodes'),
+      }),
+    ]);
+  }
+
+  function renderDatasets(payload) {
+    clear(datasetHost);
+    if (!payload.datasets.length) {
+      datasetHost.appendChild(datasetEmptyState());
+      return;
+    }
+    datasetHost.appendChild(el('div', { class: 'border border-gray-800 rounded divide-y divide-gray-800' },
+      payload.datasets.map((ds) => {
+        const radio = el('input', { type: 'radio', name: 'train-dataset', class: 'accent-blue-500 shrink-0' });
+        radio.addEventListener('change', () => {
+          state.dataset = ds;
+        });
+        return el('label', {
+          class: 'flex items-center gap-3 px-3 py-2 text-xs cursor-pointer hover:bg-gray-800/40',
+        }, [
+          radio,
+          el('span', { class: 'text-gray-200 font-mono w-64 truncate', text: ds.name }),
+          el('span', { class: 'text-gray-400 w-20 text-right', text: `${ds.total_episodes} ${tr('train_episodes', 'episodes')}` }),
+          el('span', { class: 'text-gray-500 w-24 text-right', text: `${thousands(ds.total_frames)} ${tr('train_new_frames', 'frames')}` }),
+          el('span', { class: 'text-gray-600 w-12 text-right', text: ds.codebase_version }),
+          el('span', { class: 'text-gray-600 ml-auto', text: ds.fps ? `${ds.fps} fps` : '' }),
+        ]);
+      })));
+  }
+
+  datasetHost.appendChild(loadingRow(tr('loading', 'Loading...')));
+  listDatasets()
+    .then(renderDatasets)
+    .catch((err) => { clear(datasetHost); datasetHost.appendChild(errorRow(`${tr('train_load_failed', 'Failed to load')}: ${err.message}`)); });
+
+  // 到点提醒是**加分项**:拿不到(比如扫描超时)就整块不显示,不拦这一页 ——
+  // 它只是提示"该导出了",不是这一页的主功能。
+  listReadyProjects()
+    .then(renderReady)
+    .catch(() => clear(readyHost));
+
+  // ── ⑤ 从已有训练继续(可选)─────────────────────────
+  const resumeTask = el('select', { class: INPUT_CLASS + ' w-64' }, [
+    el('option', { value: '', text: tr('train_resume_none', '— Start fresh —') }),
+  ]);
+  const resumeStep = el('select', { class: INPUT_CLASS + ' w-40', disabled: true }, [
+    el('option', { value: '', text: '—' }),
+  ]);
+  let runsCache = [];
+
+  resumeTask.addEventListener('change', () => {
+    clear(resumeStep);
+    const run = runsCache.find((r) => r.name === resumeTask.value);
+    if (!run) {
+      resumeStep.disabled = true;
+      resumeStep.appendChild(el('option', { value: '', text: '—' }));
+      state.resume = null;
+      return;
+    }
+    resumeStep.disabled = false;
+    resumeStep.appendChild(el('option', { value: '', text: tr('train_resume_latest', '— latest —') }));
+    for (const c of run.checkpoints) {
+      resumeStep.appendChild(el('option', { value: String(c.step), text: `${c.name} (${bytes(c.total_bytes)})` }));
+    }
+    state.resume = { run: run.name, step: run.checkpoints[0]?.step ?? null };
+  });
+  resumeStep.addEventListener('change', () => {
+    state.resume = resumeTask.value
+      ? { run: resumeTask.value, step: resumeStep.value ? parseInt(resumeStep.value, 10) : null }
+      : null;
+  });
+
+  const sectionResume = section('train_sec_resume', '5. Continue From a Previous Run',
+    { cls: PENDING, text: tr('train_new_pending', 'not wired') }, [
+      el('div', { class: 'flex gap-6 flex-wrap' }, [
+        labeled(tr('train_resume_task', 'Source run'), resumeTask),
+        labeled(tr('train_resume_step', 'Checkpoint'), resumeStep),
+      ]),
+    ]);
+
+  listRuns()
+    .then((payload) => {
+      runsCache = payload.runs || [];
+      for (const run of runsCache) {
+        resumeTask.appendChild(el('option', { value: run.name, text: `${run.name} (${run.checkpoint_count})` }));
+      }
+    })
+    .catch(() => { /* 拿不到就保持"全新训练",不拦整页 */ });
+
+
+
+  // 展示顺序 ≠ 构造顺序。构造时必须先定义好各自依赖的变量(GPU 面板、数据集的
+  // 留出集警告、命令生成…),这里才决定它们从上到下怎么排。
+  //
+  // 顺序:数据集 → 模型 → 算力 → 参数。先定"用什么数据",再定"训什么模型",
+  // 再定"在哪训",最后"怎么训" —— 决策依赖就是按这个方向走的(比如数据集决定了
+  // 命令里的 --dataset.root)。
+  for (const node of [sectionDataset, sectionModel, sectionLocation, sectionParams,
+                      sectionResume]) {
+    container.appendChild(node);
+  }
+}
diff --git a/processor/web/static/js/train/params.js b/processor/web/static/js/train/params.js
new file mode 100644
index 0000000000000000000000000000000000000000..421f9608755de3f7631cf7b421bf5e7d156e573a
--- /dev/null
+++ b/processor/web/static/js/train/params.js
@@ -0,0 +1,141 @@
+/** 「训练参数」页签 —— 渲染 train_config.json 里的真实超参。
+ *
+ * 数据是**训练当时实际用的那份配置**(lerobot-train 自己写进 checkpoint 的),
+ * 不是我们事后补的默认值。
+ *
+ * 缺字段就**整行不渲染**。不同 LeRobot 版本的键名会变(我们比参考实现少
+ * `scheduler_state.json`、多四个 pre/postprocessor 文件就是同一类差异),写死
+ * "缺了就显示 N/A"会让人误以为训练时那个参数是 null。
+ */
+
+import { el, clear } from '../shared/dom.js';
+import { thousands } from '../shared/format.js';
+import { tr } from '../shared/text.js';
+
+/** 分组 → 每行 [显示名, 取值路径, 可选格式化函数]。
+ *
+ *  分组标题存的是 **i18n key** 而不是翻好的文字:它是模块级常量,在这里调
+ *  `tr()` 会在模块加载那一刻定死,用户之后再切语言就不会跟着变。渲染时再取。 */
+const GROUPS = [
+  {
+    titleKey: 'train_group_train',
+    titleFallback: 'Training',
+    rows: [
+      ['steps', 'steps', thousands],
+      ['batch_size', 'batch_size'],
+      ['save_freq', 'save_freq', thousands],
+      ['seed', 'seed'],
+      ['num_workers', 'num_workers'],
+    ],
+  },
+  {
+    titleKey: 'train_group_policy',
+    titleFallback: 'Policy',
+    rows: [
+      ['type', 'policy.type'],
+      ['dim_model', 'policy.dim_model'],
+      ['chunk_size', 'policy.chunk_size'],
+      ['n_action_steps', 'policy.n_action_steps'],
+      ['vision_backbone', 'policy.vision_backbone'],
+      ['kl_weight', 'policy.kl_weight'],
+    ],
+  },
+  {
+    titleKey: 'train_group_optimizer',
+    titleFallback: 'Optimizer',
+    rows: [
+      ['type', 'optimizer.type'],
+      ['lr', 'optimizer.lr'],
+      ['weight_decay', 'optimizer.weight_decay'],
+      ['grad_clip_norm', 'optimizer.grad_clip_norm'],
+    ],
+  },
+  {
+    titleKey: 'train_group_dataset',
+    titleFallback: 'Dataset',
+    rows: [
+      ['repo_id', 'dataset.repo_id'],
+      ['root', 'dataset.root'],
+      ['eval_split', 'dataset.eval_split'],
+      ['episodes', 'dataset.episodes'],
+    ],
+  },
+];
+
+/** 按点号路径取值;任一层缺失返回 undefined(不抛)。 */
+function pick(obj, path) {
+  return path.split('.').reduce(
+    (acc, key) => (acc === null || acc === undefined ? undefined : acc[key]),
+    obj,
+  );
+}
+
+/** 值 → 显示文本。null/undefined/空串统一成 '—',数组/对象转紧凑 JSON。 */
+function display(value, format) {
+  if (value === null || value === undefined || value === '') return '—';
+  if (format) return format(value);
+  if (Array.isArray(value) || typeof value === 'object') {
+    return JSON.stringify(value);
+  }
+  return String(value);
+}
+
+function renderGroup(group, config) {
+  // 先算一遍哪些行有值 —— 全组都没值的分组直接不渲染,避免出现空卡片。
+  const present = group.rows
+    .map(([label, path, format]) => [label, pick(config, path), format])
+    .filter(([, value]) => value !== undefined && value !== null);
+
+  if (!present.length) return null;
+
+  return el('div', { class: 'bg-gray-900 rounded-lg border border-gray-800 p-4' }, [
+    el('div', {
+      class: 'text-xs font-semibold text-gray-400 mb-3',
+      text: tr(group.titleKey, group.titleFallback),
+    }),
+    el('div', { class: 'space-y-1.5' }, present.map(([label, value, format]) => (
+      el('div', { class: 'flex items-baseline gap-3 text-xs' }, [
+        el('span', { class: 'text-gray-500 shrink-0 w-32', text: label }),
+        el('span', {
+          class: 'text-gray-200 font-mono break-all',
+          text: display(value, format),
+        }),
+      ])
+    ))),
+  ]);
+}
+
+/**
+ * @param {HTMLElement} container
+ * @param {object} config        train_config.json 的内容
+ * @param {{step: number}} meta  这份配置取自哪个 checkpoint
+ */
+export function renderParams(container, config, meta = {}) {
+  clear(container);
+
+  if (!config || Object.keys(config).length === 0) {
+    container.appendChild(emptyState(
+      tr('train_params_empty',
+         'No train_config.json in this checkpoint; parameters unavailable.'),
+    ));
+    return;
+  }
+
+  container.appendChild(el('div', {
+    class: 'text-xs text-gray-500 mb-4',
+    text: `${tr('train_params_source', 'Source:')} `
+      + `checkpoints/${meta.step ?? '?'}/pretrained_model/train_config.json`,
+  }));
+
+  const cards = GROUPS.map((g) => renderGroup(g, config)).filter(Boolean);
+  container.appendChild(
+    el('div', { class: 'grid grid-cols-1 md:grid-cols-2 gap-4' }, cards),
+  );
+}
+
+function emptyState(message) {
+  return el('div', {
+    class: 'text-center text-gray-600 text-sm py-10',
+    text: message,
+  });
+}
diff --git a/processor/web/static/js/users.js b/processor/web/static/js/users.js
index ff0402535e3e1e82cd29ebcd1766bbf724e8e728..479c036a818b76ddefaaef3ad38f0866c9b85c3b 100644
--- a/processor/web/static/js/users.js
+++ b/processor/web/static/js/users.js
@@ -1,7 +1,9 @@
 /* Administrator account management. */
 let managedUsers = [];
 
-const ROLE_LABELS = { admin: 'Admin', engineer: 'Engineer', reviewer: 'Reviewer' };
+// 显示时翻译；查不到就回落原始值（后端加了新角色也不会显示成空白）
+const ROLE_LABEL_KEYS = { admin: 'role_admin', engineer: 'role_engineer', reviewer: 'role_reviewer' };
+const STATUS_LABEL_KEYS = { active: 'status_active', disabled: 'status_disabled', expired: 'status_expired' };
 const ROLE_CLASSES = {
     admin: 'text-blue-400 bg-blue-900/30 border-blue-800',
     engineer: 'text-purple-400 bg-purple-900/30 border-purple-800',
@@ -68,10 +70,10 @@ function renderUsers() {
     const users = managedUsers.filter(user => !query
         || user.username.toLowerCase().includes(query)
         || (user.email || '').toLowerCase().includes(query));
-    document.getElementById('user-list-count').textContent = `${users.length} users`;
+    document.getElementById('user-list-count').textContent = t('users_count').replace('%s', users.length);
     const body = document.getElementById('users-body');
     if (!users.length) {
-        body.innerHTML = '<tr><td colspan="6" class="px-4 py-10 text-center text-gray-600">No users found</td></tr>';
+        body.innerHTML = '<tr><td colspan="6" class="px-4 py-10 text-center text-gray-600">' + t('users_no_found') + '</td></tr>';
         return;
     }
     body.innerHTML = users.map(user => {
@@ -82,19 +84,19 @@ function renderUsers() {
                 : 'text-gray-400 bg-gray-800 border-gray-700';
         let action = '';
         if (user.status === 'expired') {
-            action = `<button onclick="openUserModal('${escUser(user.id)}')" title="Edit the expiry date to reactivate this account" class="border border-yellow-800 text-yellow-400 hover:bg-yellow-900/30 px-2 py-1 rounded">Extend</button>`;
+            action = `<button onclick="openUserModal('${escUser(user.id)}')" title="${t('users_extend_hint')}" class="border border-yellow-800 text-yellow-400 hover:bg-yellow-900/30 px-2 py-1 rounded">${t('users_extend')}</button>`;
         } else if (user.account_status === 'active') {
-            action = `<button onclick="toggleUser('${escUser(user.id)}', 'disabled')" title="Block login temporarily; can be enabled later" class="border border-yellow-900 text-yellow-400 hover:bg-yellow-900/30 px-2 py-1 rounded">Disable</button>`;
+            action = `<button onclick="toggleUser('${escUser(user.id)}', 'disabled')" title="${t('users_disable_hint')}" class="border border-yellow-900 text-yellow-400 hover:bg-yellow-900/30 px-2 py-1 rounded">${t('users_disable')}</button>`;
         } else {
-            action = `<button onclick="toggleUser('${escUser(user.id)}', 'active')" title="Allow this user to log in again" class="border border-green-900 text-green-400 hover:bg-green-900/30 px-2 py-1 rounded">Enable</button>`;
+            action = `<button onclick="toggleUser('${escUser(user.id)}', 'active')" title="${t('users_enable_hint')}" class="border border-green-900 text-green-400 hover:bg-green-900/30 px-2 py-1 rounded">${t('users_enable')}</button>`;
         }
         return `<tr class="border-t border-gray-800 hover:bg-gray-800/30">
-            <td class="px-4 py-3"><div class="text-gray-200">${escUser(user.username)}</div><div class="text-xs text-gray-600">${escUser(user.email || 'No email')}</div></td>
-            <td class="px-4 py-3"><span class="inline-flex px-2 py-0.5 rounded border text-xs ${ROLE_CLASSES[user.role] || 'text-gray-400 bg-gray-800 border-gray-700'}">${escUser(ROLE_LABELS[user.role] || user.role)}</span></td>
-            <td class="px-4 py-3"><span class="inline-flex px-2 py-0.5 rounded border text-xs ${statusClass}">${escUser(user.status)}</span></td>
+            <td class="px-4 py-3"><div class="text-gray-200">${escUser(user.username)}</div><div class="text-xs text-gray-600">${escUser(user.email || t('users_no_email'))}</div></td>
+            <td class="px-4 py-3"><span class="inline-flex px-2 py-0.5 rounded border text-xs ${ROLE_CLASSES[user.role] || 'text-gray-400 bg-gray-800 border-gray-700'}">${escUser(ROLE_LABEL_KEYS[user.role] ? t(ROLE_LABEL_KEYS[user.role]) : user.role)}</span></td>
+            <td class="px-4 py-3"><span class="inline-flex px-2 py-0.5 rounded border text-xs ${statusClass}">${escUser(STATUS_LABEL_KEYS[user.status] ? t(STATUS_LABEL_KEYS[user.status]) : user.status)}</span></td>
             <td class="px-4 py-3 text-xs text-gray-500">${escUser(formatDate(user.last_login_at))}</td>
-            <td class="px-4 py-3 text-xs ${user.status === 'expired' ? 'text-yellow-400' : 'text-gray-500'}">${escUser(user.expires_at ? formatDate(user.expires_at) : 'Never')}</td>
-            <td class="px-4 py-3"><div class="flex justify-end items-center gap-2 whitespace-nowrap text-xs"><button onclick="openUserModal('${escUser(user.id)}')" title="Edit account" class="border border-blue-900 text-blue-400 hover:bg-blue-900/30 px-2 py-1 rounded">Edit</button>${action}<button onclick="deleteUser('${escUser(user.id)}')" title="Permanently delete this account" class="border border-red-900 text-red-400 hover:bg-red-900/30 px-2 py-1 rounded">Delete</button></div></td>
+            <td class="px-4 py-3 text-xs ${user.status === 'expired' ? 'text-yellow-400' : 'text-gray-500'}">${escUser(user.expires_at ? formatDate(user.expires_at) : t('users_never'))}</td>
+            <td class="px-4 py-3"><div class="flex justify-end items-center gap-2 whitespace-nowrap text-xs"><button onclick="openUserModal('${escUser(user.id)}')" title="${t('users_edit_hint')}" class="border border-blue-900 text-blue-400 hover:bg-blue-900/30 px-2 py-1 rounded">${t('users_edit')}</button>${action}<button onclick="deleteUser('${escUser(user.id)}')" title="${t('users_delete_hint')}" class="border border-red-900 text-red-400 hover:bg-red-900/30 px-2 py-1 rounded">${t('users_delete')}</button></div></td>
         </tr>`;
     }).join('');
 }
@@ -110,15 +112,15 @@ function toLocalInput(value) {
 function openUserModal(userId = '') {
     const user = managedUsers.find(item => item.id === userId);
     document.getElementById('user-id').value = user?.id || '';
-    document.getElementById('user-modal-title').textContent = user ? 'Edit user' : 'New user';
-    document.getElementById('user-save-btn').textContent = user ? 'Save changes' : 'Create user';
+    document.getElementById('user-modal-title').textContent = user ? t('users_edit_user') : t('users_new');
+    document.getElementById('user-save-btn').textContent = user ? t('users_save_changes') : t('users_create');
     document.getElementById('user-username').value = user?.username || '';
     document.getElementById('user-username').disabled = Boolean(user);
     document.getElementById('user-role').value = user?.role || 'engineer';
     document.getElementById('user-email').value = user?.email || '';
     document.getElementById('user-password').value = '';
     document.getElementById('user-password').required = !user;
-    document.getElementById('password-hint').textContent = user ? '(leave blank to keep current password)' : '(at least 6 characters)';
+    document.getElementById('password-hint').textContent = user ? t('users_pw_keep') : t('users_pw_hint');
     document.getElementById('user-status').value = user?.account_status || 'active';
     document.getElementById('user-expires').value = toLocalInput(user?.expires_at);
     document.getElementById('user-modal').classList.remove('hidden');
@@ -168,7 +170,7 @@ async function toggleUser(id, status) {
 
 async function deleteUser(id) {
     const user = managedUsers.find(item => item.id === id);
-    if (!user || !window.confirm(`Permanently delete ${user.username}? Disable is safer if you may need the account later.`)) return;
+    if (!user || !window.confirm(t('users_confirm_delete').replace('%s', user.username))) return;
     try {
         await apiUsers(`/api/v1/users/${encodeURIComponent(id)}`, { method: 'DELETE' });
         showUserAlert('User deleted');
diff --git a/processor/web/static/logo.png b/processor/web/static/logo.png
index 0952101315249d72e45369dd6c65158f88aad348..97ab564400c979d71a2cbffef1aaa8acfd47b648 100644
Binary files a/processor/web/static/logo.png and b/processor/web/static/logo.png differ
diff --git a/processor/web/static/tailwind-generated.css b/processor/web/static/tailwind-generated.css
index 282dc2a425837cb44dc59ff2d2eabfee244881d7..268d3249bfd350c3633cf750cfb4871b1b1c1126 100644
--- a/processor/web/static/tailwind-generated.css
+++ b/processor/web/static/tailwind-generated.css
@@ -672,10 +672,6 @@ video {
   left: 0.75rem;
 }
 
-.right-1 {
-  right: 0.25rem;
-}
-
 .right-3 {
   right: 0.75rem;
 }
@@ -708,6 +704,10 @@ video {
   z-index: 50;
 }
 
+.z-\[999\] {
+  z-index: 999;
+}
+
 .order-1 {
   order: 1;
 }
@@ -743,6 +743,10 @@ video {
   margin-right: auto;
 }
 
+.-mb-px {
+  margin-bottom: -1px;
+}
+
 .mb-1 {
   margin-bottom: 0.25rem;
 }
@@ -763,6 +767,10 @@ video {
   margin-bottom: 1rem;
 }
 
+.mb-5 {
+  margin-bottom: 1.25rem;
+}
+
 .mb-6 {
   margin-bottom: 1.5rem;
 }
@@ -819,6 +827,14 @@ video {
   margin-top: 0.5rem;
 }
 
+.mt-3 {
+  margin-top: 0.75rem;
+}
+
+.mt-4 {
+  margin-top: 1rem;
+}
+
 .mt-6 {
   margin-top: 1.5rem;
 }
@@ -863,6 +879,10 @@ video {
   aspect-ratio: 16 / 9;
 }
 
+.h-1\.5 {
+  height: 0.375rem;
+}
+
 .h-10 {
   height: 2.5rem;
 }
@@ -899,10 +919,6 @@ video {
   height: 12rem;
 }
 
-.h-5 {
-  height: 1.25rem;
-}
-
 .h-6 {
   height: 1.5rem;
 }
@@ -971,30 +987,46 @@ video {
   width: 6rem;
 }
 
+.w-28 {
+  width: 7rem;
+}
+
+.w-3 {
+  width: 0.75rem;
+}
+
 .w-3\.5 {
   width: 0.875rem;
 }
 
-.w-4 {
-  width: 1rem;
+.w-32 {
+  width: 8rem;
 }
 
-.w-48 {
-  width: 12rem;
+.w-36 {
+  width: 9rem;
+}
+
+.w-4 {
+  width: 1rem;
 }
 
-.w-5 {
-  width: 1.25rem;
+.w-40 {
+  width: 10rem;
 }
 
-.w-56 {
-  width: 14rem;
+.w-48 {
+  width: 12rem;
 }
 
 .w-6 {
   width: 1.5rem;
 }
 
+.w-64 {
+  width: 16rem;
+}
+
 .w-7 {
   width: 1.75rem;
 }
@@ -1003,6 +1035,10 @@ video {
   width: 2rem;
 }
 
+.w-80 {
+  width: 20rem;
+}
+
 .w-full {
   width: 100%;
 }
@@ -1011,6 +1047,14 @@ video {
   min-width: 0px;
 }
 
+.min-w-\[220px\] {
+  min-width: 220px;
+}
+
+.min-w-\[240px\] {
+  min-width: 240px;
+}
+
 .max-w-2xl {
   max-width: 42rem;
 }
@@ -1019,6 +1063,10 @@ video {
   max-width: 48rem;
 }
 
+.max-w-lg {
+  max-width: 32rem;
+}
+
 .max-w-md {
   max-width: 28rem;
 }
@@ -1058,6 +1106,10 @@ video {
   animation: spin 1s linear infinite;
 }
 
+.cursor-default {
+  cursor: default;
+}
+
 .cursor-grab {
   cursor: grab;
 }
@@ -1070,18 +1122,16 @@ video {
   cursor: pointer;
 }
 
+.cursor-wait {
+  cursor: wait;
+}
+
 .select-none {
   -webkit-user-select: none;
      -moz-user-select: none;
           user-select: none;
 }
 
-.select-all {
-  -webkit-user-select: all;
-     -moz-user-select: all;
-          user-select: all;
-}
-
 .resize {
   resize: both;
 }
@@ -1094,6 +1144,10 @@ video {
   grid-template-columns: repeat(2, minmax(0, 1fr));
 }
 
+.grid-cols-3 {
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+}
+
 .grid-cols-4 {
   grid-template-columns: repeat(4, minmax(0, 1fr));
 }
@@ -1106,10 +1160,6 @@ video {
   flex-wrap: wrap;
 }
 
-.flex-nowrap {
-  flex-wrap: nowrap;
-}
-
 .items-start {
   align-items: flex-start;
 }
@@ -1122,6 +1172,10 @@ video {
   align-items: center;
 }
 
+.items-baseline {
+  align-items: baseline;
+}
+
 .justify-end {
   justify-content: flex-end;
 }
@@ -1176,6 +1230,12 @@ video {
   margin-bottom: calc(0.125rem * var(--tw-space-y-reverse));
 }
 
+.space-y-1 > :not([hidden]) ~ :not([hidden]) {
+  --tw-space-y-reverse: 0;
+  margin-top: calc(0.25rem * calc(1 - var(--tw-space-y-reverse)));
+  margin-bottom: calc(0.25rem * var(--tw-space-y-reverse));
+}
+
 .space-y-1\.5 > :not([hidden]) ~ :not([hidden]) {
   --tw-space-y-reverse: 0;
   margin-top: calc(0.375rem * calc(1 - var(--tw-space-y-reverse)));
@@ -1200,6 +1260,17 @@ video {
   margin-bottom: calc(1rem * var(--tw-space-y-reverse));
 }
 
+.divide-y > :not([hidden]) ~ :not([hidden]) {
+  --tw-divide-y-reverse: 0;
+  border-top-width: calc(1px * calc(1 - var(--tw-divide-y-reverse)));
+  border-bottom-width: calc(1px * var(--tw-divide-y-reverse));
+}
+
+.divide-gray-800 > :not([hidden]) ~ :not([hidden]) {
+  --tw-divide-opacity: 1;
+  border-color: rgb(31 41 55 / var(--tw-divide-opacity, 1));
+}
+
 .overflow-auto {
   overflow: auto;
 }
@@ -1216,10 +1287,6 @@ video {
   overflow-y: auto;
 }
 
-.overflow-y-hidden {
-  overflow-y: hidden;
-}
-
 .truncate {
   overflow: hidden;
   text-overflow: ellipsis;
@@ -1230,6 +1297,14 @@ video {
   white-space: nowrap;
 }
 
+.break-words {
+  overflow-wrap: break-word;
+}
+
+.break-all {
+  word-break: break-all;
+}
+
 .rounded {
   border-radius: 0.25rem;
 }
@@ -1259,6 +1334,14 @@ video {
   border-width: 1px;
 }
 
+.border-2 {
+  border-width: 2px;
+}
+
+.border-4 {
+  border-width: 4px;
+}
+
 .border-b {
   border-bottom-width: 1px;
 }
@@ -1279,6 +1362,11 @@ video {
   border-top-width: 1px;
 }
 
+.border-amber-900 {
+  --tw-border-opacity: 1;
+  border-color: rgb(120 53 15 / var(--tw-border-opacity, 1));
+}
+
 .border-blue-500 {
   --tw-border-opacity: 1;
   border-color: rgb(59 130 246 / var(--tw-border-opacity, 1));
@@ -1297,14 +1385,29 @@ video {
   border-color: rgb(37 99 235 / 0.6);
 }
 
+.border-blue-800 {
+  --tw-border-opacity: 1;
+  border-color: rgb(30 64 175 / var(--tw-border-opacity, 1));
+}
+
 .border-blue-800\/60 {
   border-color: rgb(30 64 175 / 0.6);
 }
 
+.border-blue-900 {
+  --tw-border-opacity: 1;
+  border-color: rgb(30 58 138 / var(--tw-border-opacity, 1));
+}
+
 .border-cyan-600\/60 {
   border-color: rgb(8 145 178 / 0.6);
 }
 
+.border-cyan-700 {
+  --tw-border-opacity: 1;
+  border-color: rgb(14 116 144 / var(--tw-border-opacity, 1));
+}
+
 .border-cyan-700\/50 {
   border-color: rgb(14 116 144 / 0.5);
 }
@@ -1340,11 +1443,25 @@ video {
   border-color: rgb(31 41 55 / 0.5);
 }
 
+.border-gray-800\/60 {
+  border-color: rgb(31 41 55 / 0.6);
+}
+
 .border-green-800 {
   --tw-border-opacity: 1;
   border-color: rgb(22 101 52 / var(--tw-border-opacity, 1));
 }
 
+.border-green-900 {
+  --tw-border-opacity: 1;
+  border-color: rgb(20 83 45 / var(--tw-border-opacity, 1));
+}
+
+.border-purple-800 {
+  --tw-border-opacity: 1;
+  border-color: rgb(107 33 168 / var(--tw-border-opacity, 1));
+}
+
 .border-red-500 {
   --tw-border-opacity: 1;
   border-color: rgb(239 68 68 / var(--tw-border-opacity, 1));
@@ -1359,11 +1476,25 @@ video {
   border-color: rgb(153 27 27 / 0.6);
 }
 
+.border-red-900 {
+  --tw-border-opacity: 1;
+  border-color: rgb(127 29 29 / var(--tw-border-opacity, 1));
+}
+
+.border-transparent {
+  border-color: transparent;
+}
+
 .border-yellow-800 {
   --tw-border-opacity: 1;
   border-color: rgb(133 77 14 / var(--tw-border-opacity, 1));
 }
 
+.border-yellow-900 {
+  --tw-border-opacity: 1;
+  border-color: rgb(113 63 18 / var(--tw-border-opacity, 1));
+}
+
 .border-b-green-500 {
   --tw-border-opacity: 1;
   border-bottom-color: rgb(34 197 94 / var(--tw-border-opacity, 1));
@@ -1384,15 +1515,40 @@ video {
   border-bottom-color: rgb(234 179 8 / var(--tw-border-opacity, 1));
 }
 
+.border-t-transparent {
+  border-top-color: transparent;
+}
+
+.bg-amber-900\/50 {
+  background-color: rgb(120 53 15 / 0.5);
+}
+
+.bg-amber-950\/40 {
+  background-color: rgb(69 26 3 / 0.4);
+}
+
 .bg-black {
   --tw-bg-opacity: 1;
   background-color: rgb(0 0 0 / var(--tw-bg-opacity, 1));
 }
 
+.bg-black\/60 {
+  background-color: rgb(0 0 0 / 0.6);
+}
+
 .bg-black\/70 {
   background-color: rgb(0 0 0 / 0.7);
 }
 
+.bg-black\/85 {
+  background-color: rgb(0 0 0 / 0.85);
+}
+
+.bg-blue-400 {
+  --tw-bg-opacity: 1;
+  background-color: rgb(96 165 250 / var(--tw-bg-opacity, 1));
+}
+
 .bg-blue-500 {
   --tw-bg-opacity: 1;
   background-color: rgb(59 130 246 / var(--tw-bg-opacity, 1));
@@ -1407,6 +1563,10 @@ video {
   background-color: rgb(37 99 235 / 0.1);
 }
 
+.bg-blue-600\/40 {
+  background-color: rgb(37 99 235 / 0.4);
+}
+
 .bg-blue-800 {
   --tw-bg-opacity: 1;
   background-color: rgb(30 64 175 / var(--tw-bg-opacity, 1));
@@ -1424,10 +1584,26 @@ video {
   background-color: rgb(30 58 138 / 0.5);
 }
 
+.bg-blue-900\/60 {
+  background-color: rgb(30 58 138 / 0.6);
+}
+
+.bg-blue-950\/30 {
+  background-color: rgb(23 37 84 / 0.3);
+}
+
+.bg-blue-950\/60 {
+  background-color: rgb(23 37 84 / 0.6);
+}
+
 .bg-cyan-900\/20 {
   background-color: rgb(22 78 99 / 0.2);
 }
 
+.bg-cyan-900\/30 {
+  background-color: rgb(22 78 99 / 0.3);
+}
+
 .bg-cyan-900\/50 {
   background-color: rgb(22 78 99 / 0.5);
 }
@@ -1459,10 +1635,6 @@ video {
   background-color: rgb(17 24 39 / var(--tw-bg-opacity, 1));
 }
 
-.bg-gray-900\/40 {
-  background-color: rgb(17 24 39 / 0.4);
-}
-
 .bg-gray-900\/55 {
   background-color: rgb(17 24 39 / 0.55);
 }
@@ -1484,6 +1656,14 @@ video {
   background-color: rgb(3 7 18 / var(--tw-bg-opacity, 1));
 }
 
+.bg-gray-950\/40 {
+  background-color: rgb(3 7 18 / 0.4);
+}
+
+.bg-gray-950\/60 {
+  background-color: rgb(3 7 18 / 0.6);
+}
+
 .bg-gray-950\/95 {
   background-color: rgb(3 7 18 / 0.95);
 }
@@ -1503,16 +1683,32 @@ video {
   background-color: rgb(22 101 52 / var(--tw-bg-opacity, 1));
 }
 
+.bg-green-900\/20 {
+  background-color: rgb(20 83 45 / 0.2);
+}
+
+.bg-green-900\/30 {
+  background-color: rgb(20 83 45 / 0.3);
+}
+
 .bg-green-900\/50 {
   background-color: rgb(20 83 45 / 0.5);
 }
 
+.bg-green-950\/40 {
+  background-color: rgb(5 46 22 / 0.4);
+}
+
 .bg-indigo-900\/50 {
   background-color: rgb(49 46 129 / 0.5);
 }
 
-.bg-purple-900\/60 {
-  background-color: rgb(88 28 135 / 0.6);
+.bg-purple-900\/30 {
+  background-color: rgb(88 28 135 / 0.3);
+}
+
+.bg-purple-900\/70 {
+  background-color: rgb(88 28 135 / 0.7);
 }
 
 .bg-red-400 {
@@ -1552,6 +1748,10 @@ video {
   background-color: rgb(133 77 14 / var(--tw-bg-opacity, 1));
 }
 
+.bg-yellow-900\/30 {
+  background-color: rgb(113 63 18 / 0.3);
+}
+
 .bg-yellow-900\/50 {
   background-color: rgb(113 63 18 / 0.5);
 }
@@ -1636,6 +1836,11 @@ video {
   padding-right: 1.25rem;
 }
 
+.px-6 {
+  padding-left: 1.5rem;
+  padding-right: 1.5rem;
+}
+
 .py-0\.5 {
   padding-top: 0.125rem;
   padding-bottom: 0.125rem;
@@ -1651,6 +1856,16 @@ video {
   padding-bottom: 0.375rem;
 }
 
+.py-10 {
+  padding-top: 2.5rem;
+  padding-bottom: 2.5rem;
+}
+
+.py-16 {
+  padding-top: 4rem;
+  padding-bottom: 4rem;
+}
+
 .py-2 {
   padding-top: 0.5rem;
   padding-bottom: 0.5rem;
@@ -1671,6 +1886,11 @@ video {
   padding-bottom: 1rem;
 }
 
+.py-6 {
+  padding-top: 1.5rem;
+  padding-bottom: 1.5rem;
+}
+
 .py-8 {
   padding-top: 2rem;
   padding-bottom: 2rem;
@@ -1684,6 +1904,14 @@ video {
   padding-bottom: 0.25rem;
 }
 
+.pb-6 {
+  padding-bottom: 1.5rem;
+}
+
+.pr-4 {
+  padding-right: 1rem;
+}
+
 .pt-1 {
   padding-top: 0.25rem;
 }
@@ -1692,6 +1920,10 @@ video {
   padding-top: 0.375rem;
 }
 
+.pt-2 {
+  padding-top: 0.5rem;
+}
+
 .pt-3 {
   padding-top: 0.75rem;
 }
@@ -1721,6 +1953,11 @@ video {
   line-height: 2rem;
 }
 
+.text-3xl {
+  font-size: 1.875rem;
+  line-height: 2.25rem;
+}
+
 .text-4xl {
   font-size: 2.25rem;
   line-height: 2.5rem;
@@ -1742,6 +1979,11 @@ video {
   font-size: 9px;
 }
 
+.text-base {
+  font-size: 1rem;
+  line-height: 1.5rem;
+}
+
 .text-lg {
   font-size: 1.125rem;
   line-height: 1.75rem;
@@ -1786,21 +2028,47 @@ video {
   letter-spacing: -0.025em;
 }
 
+.text-amber-100 {
+  --tw-text-opacity: 1;
+  color: rgb(254 243 199 / var(--tw-text-opacity, 1));
+}
+
+.text-amber-300 {
+  --tw-text-opacity: 1;
+  color: rgb(252 211 77 / var(--tw-text-opacity, 1));
+}
+
+.text-amber-300\/90 {
+  color: rgb(252 211 77 / 0.9);
+}
+
 .text-amber-400 {
   --tw-text-opacity: 1;
   color: rgb(251 191 36 / var(--tw-text-opacity, 1));
 }
 
+.text-amber-500\/80 {
+  color: rgb(245 158 11 / 0.8);
+}
+
 .text-blue-200 {
   --tw-text-opacity: 1;
   color: rgb(191 219 254 / var(--tw-text-opacity, 1));
 }
 
+.text-blue-200\/60 {
+  color: rgb(191 219 254 / 0.6);
+}
+
 .text-blue-300 {
   --tw-text-opacity: 1;
   color: rgb(147 197 253 / var(--tw-text-opacity, 1));
 }
 
+.text-blue-300\/80 {
+  color: rgb(147 197 253 / 0.8);
+}
+
 .text-blue-400 {
   --tw-text-opacity: 1;
   color: rgb(96 165 250 / var(--tw-text-opacity, 1));
@@ -1826,9 +2094,8 @@ video {
   color: rgb(34 211 238 / var(--tw-text-opacity, 1));
 }
 
-.text-emerald-400 {
-  --tw-text-opacity: 1;
-  color: rgb(52 211 153 / var(--tw-text-opacity, 1));
+.text-emerald-300\/90 {
+  color: rgb(110 231 183 / 0.9);
 }
 
 .text-gray-100 {
@@ -1871,6 +2138,11 @@ video {
   color: rgb(187 247 208 / var(--tw-text-opacity, 1));
 }
 
+.text-green-300 {
+  --tw-text-opacity: 1;
+  color: rgb(134 239 172 / var(--tw-text-opacity, 1));
+}
+
 .text-green-400 {
   --tw-text-opacity: 1;
   color: rgb(74 222 128 / var(--tw-text-opacity, 1));
@@ -1891,6 +2163,11 @@ video {
   color: rgb(233 213 255 / var(--tw-text-opacity, 1));
 }
 
+.text-purple-400 {
+  --tw-text-opacity: 1;
+  color: rgb(192 132 252 / var(--tw-text-opacity, 1));
+}
+
 .text-red-200 {
   --tw-text-opacity: 1;
   color: rgb(254 202 202 / var(--tw-text-opacity, 1));
@@ -1959,10 +2236,18 @@ video {
   color: rgb(75 85 99 / var(--tw-placeholder-opacity, 1));
 }
 
+.accent-blue-500 {
+  accent-color: #3b82f6;
+}
+
 .accent-blue-600 {
   accent-color: #2563eb;
 }
 
+.accent-cyan-500 {
+  accent-color: #06b6d4;
+}
+
 .opacity-40 {
   opacity: 0.4;
 }
@@ -1971,10 +2256,18 @@ video {
   opacity: 0.5;
 }
 
+.opacity-60 {
+  opacity: 0.6;
+}
+
 .opacity-70 {
   opacity: 0.7;
 }
 
+.opacity-80 {
+  opacity: 0.8;
+}
+
 .shadow-2xl {
   --tw-shadow: 0 25px 50px -12px rgb(0 0 0 / 0.25);
   --tw-shadow-colored: 0 25px 50px -12px var(--tw-shadow-color);
@@ -2029,6 +2322,20 @@ video {
   --tw-ring-color: rgb(59 130 246 / 0.5);
 }
 
+.blur {
+  --tw-blur: blur(8px);
+  filter: var(--tw-blur) var(--tw-brightness) var(--tw-contrast) var(--tw-grayscale) var(--tw-hue-rotate) var(--tw-invert) var(--tw-saturate) var(--tw-sepia) var(--tw-drop-shadow);
+}
+
+.grayscale {
+  --tw-grayscale: grayscale(100%);
+  filter: var(--tw-blur) var(--tw-brightness) var(--tw-contrast) var(--tw-grayscale) var(--tw-hue-rotate) var(--tw-invert) var(--tw-saturate) var(--tw-sepia) var(--tw-drop-shadow);
+}
+
+.\!filter {
+  filter: var(--tw-blur) var(--tw-brightness) var(--tw-contrast) var(--tw-grayscale) var(--tw-hue-rotate) var(--tw-invert) var(--tw-saturate) var(--tw-sepia) var(--tw-drop-shadow) !important;
+}
+
 .filter {
   filter: var(--tw-blur) var(--tw-brightness) var(--tw-contrast) var(--tw-grayscale) var(--tw-hue-rotate) var(--tw-invert) var(--tw-saturate) var(--tw-sepia) var(--tw-drop-shadow);
 }
@@ -2117,6 +2424,10 @@ video {
   background-color: rgb(29 78 216 / var(--tw-bg-opacity, 1));
 }
 
+.hover\:bg-blue-900\/30:hover {
+  background-color: rgb(30 58 138 / 0.3);
+}
+
 .hover\:bg-blue-900\/40:hover {
   background-color: rgb(30 58 138 / 0.4);
 }
@@ -2135,6 +2446,10 @@ video {
   background-color: rgb(55 65 81 / var(--tw-bg-opacity, 1));
 }
 
+.hover\:bg-gray-700\/70:hover {
+  background-color: rgb(55 65 81 / 0.7);
+}
+
 .hover\:bg-gray-800:hover {
   --tw-bg-opacity: 1;
   background-color: rgb(31 41 55 / var(--tw-bg-opacity, 1));
@@ -2144,6 +2459,10 @@ video {
   background-color: rgb(31 41 55 / 0.3);
 }
 
+.hover\:bg-gray-800\/40:hover {
+  background-color: rgb(31 41 55 / 0.4);
+}
+
 .hover\:bg-gray-800\/50:hover {
   background-color: rgb(31 41 55 / 0.5);
 }
@@ -2158,6 +2477,10 @@ video {
   background-color: rgb(21 128 61 / var(--tw-bg-opacity, 1));
 }
 
+.hover\:bg-green-900\/30:hover {
+  background-color: rgb(20 83 45 / 0.3);
+}
+
 .hover\:bg-purple-800:hover {
   --tw-bg-opacity: 1;
   background-color: rgb(107 33 168 / var(--tw-bg-opacity, 1));
@@ -2173,6 +2496,10 @@ video {
   background-color: rgb(127 29 29 / var(--tw-bg-opacity, 1));
 }
 
+.hover\:bg-red-900\/30:hover {
+  background-color: rgb(127 29 29 / 0.3);
+}
+
 .hover\:bg-red-900\/40:hover {
   background-color: rgb(127 29 29 / 0.4);
 }
@@ -2182,6 +2509,10 @@ video {
   background-color: rgb(161 98 7 / var(--tw-bg-opacity, 1));
 }
 
+.hover\:bg-yellow-900\/30:hover {
+  background-color: rgb(113 63 18 / 0.3);
+}
+
 .hover\:text-blue-300:hover {
   --tw-text-opacity: 1;
   color: rgb(147 197 253 / var(--tw-text-opacity, 1));
@@ -2192,11 +2523,6 @@ video {
   color: rgb(96 165 250 / var(--tw-text-opacity, 1));
 }
 
-.hover\:text-emerald-300:hover {
-  --tw-text-opacity: 1;
-  color: rgb(110 231 183 / var(--tw-text-opacity, 1));
-}
-
 .hover\:text-gray-200:hover {
   --tw-text-opacity: 1;
   color: rgb(229 231 235 / var(--tw-text-opacity, 1));
@@ -2269,6 +2595,14 @@ video {
   background-color: rgb(29 78 216 / var(--tw-bg-opacity, 1));
 }
 
+.disabled\:cursor-not-allowed:disabled {
+  cursor: not-allowed;
+}
+
+.disabled\:opacity-40:disabled {
+  opacity: 0.4;
+}
+
 .group:hover .group-hover\:text-gray-300 {
   --tw-text-opacity: 1;
   color: rgb(209 213 219 / var(--tw-text-opacity, 1));
@@ -2293,3 +2627,9 @@ video {
   --tw-bg-opacity: 1;
   background-color: rgb(225 29 72 / var(--tw-bg-opacity, 1));
 }
+
+@media (min-width: 768px) {
+  .md\:grid-cols-2 {
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+  }
+}
diff --git a/processor/web/static/workflow-studio/.vite/manifest.json b/processor/web/static/workflow-studio/.vite/manifest.json
index fb0ad2d81969279f0aec7cb050d7543fc73a2e45..0c61fa6b201572db93a639ae86062bc70e115c52 100644
--- a/processor/web/static/workflow-studio/.vite/manifest.json
+++ b/processor/web/static/workflow-studio/.vite/manifest.json
@@ -1,11 +1,11 @@
 {
   "index.html": {
-    "file": "assets/index-CcWpS4e6.js",
+    "file": "assets/index-BxCEjQee.js",
     "name": "index",
     "src": "index.html",
     "isEntry": true,
     "css": [
-      "assets/index-Byx6G-Zk.css"
+      "assets/index-ap1gwH28.css"
     ]
   }
 }
\ No newline at end of file
diff --git a/processor/web/static/workflow-studio/assets/index-BxCEjQee.js b/processor/web/static/workflow-studio/assets/index-BxCEjQee.js
new file mode 100644
index 0000000000000000000000000000000000000000..4c94294a3acbd00a722c459cb34a8e7d24a0b838
--- /dev/null
+++ b/processor/web/static/workflow-studio/assets/index-BxCEjQee.js
@@ -0,0 +1,72 @@
+(function(){const l=document.createElement("link").relList;if(l&&l.supports&&l.supports("modulepreload"))return;for(const u of document.querySelectorAll('link[rel="modulepreload"]'))r(u);new MutationObserver(u=>{for(const f of u)if(f.type==="childList")for(const d of f.addedNodes)d.tagName==="LINK"&&d.rel==="modulepreload"&&r(d)}).observe(document,{childList:!0,subtree:!0});function o(u){const f={};return u.integrity&&(f.integrity=u.integrity),u.referrerPolicy&&(f.referrerPolicy=u.referrerPolicy),u.crossOrigin==="use-credentials"?f.credentials="include":u.crossOrigin==="anonymous"?f.credentials="omit":f.credentials="same-origin",f}function r(u){if(u.ep)return;u.ep=!0;const f=o(u);fetch(u.href,f)}})();function Oy(n){return n&&n.__esModule&&Object.prototype.hasOwnProperty.call(n,"default")?n.default:n}var ff={exports:{}},so={};/**
+ * @license React
+ * react-jsx-runtime.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */var rm;function Gx(){if(rm)return so;rm=1;var n=Symbol.for("react.transitional.element"),l=Symbol.for("react.fragment");function o(r,u,f){var d=null;if(f!==void 0&&(d=""+f),u.key!==void 0&&(d=""+u.key),"key"in u){f={};for(var h in u)h!=="key"&&(f[h]=u[h])}else f=u;return u=f.ref,{$$typeof:n,type:r,key:d,ref:u!==void 0?u:null,props:f}}return so.Fragment=l,so.jsx=o,so.jsxs=o,so}var um;function qx(){return um||(um=1,ff.exports=Gx()),ff.exports}var N=qx(),df={exports:{}},Ne={};/**
+ * @license React
+ * react.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */var sm;function Yx(){if(sm)return Ne;sm=1;var n=Symbol.for("react.transitional.element"),l=Symbol.for("react.portal"),o=Symbol.for("react.fragment"),r=Symbol.for("react.strict_mode"),u=Symbol.for("react.profiler"),f=Symbol.for("react.consumer"),d=Symbol.for("react.context"),h=Symbol.for("react.forward_ref"),m=Symbol.for("react.suspense"),g=Symbol.for("react.memo"),v=Symbol.for("react.lazy"),p=Symbol.for("react.activity"),b=Symbol.iterator;function x(E){return E===null||typeof E!="object"?null:(E=b&&E[b]||E["@@iterator"],typeof E=="function"?E:null)}var _={isMounted:function(){return!1},enqueueForceUpdate:function(){},enqueueReplaceState:function(){},enqueueSetState:function(){}},T=Object.assign,z={};function A(E,O,W){this.props=E,this.context=O,this.refs=z,this.updater=W||_}A.prototype.isReactComponent={},A.prototype.setState=function(E,O){if(typeof E!="object"&&typeof E!="function"&&E!=null)throw Error("takes an object of state variables to update or a function which returns an object of state variables.");this.updater.enqueueSetState(this,E,O,"setState")},A.prototype.forceUpdate=function(E){this.updater.enqueueForceUpdate(this,E,"forceUpdate")};function R(){}R.prototype=A.prototype;function S(E,O,W){this.props=E,this.context=O,this.refs=z,this.updater=W||_}var D=S.prototype=new R;D.constructor=S,T(D,A.prototype),D.isPureReactComponent=!0;var H=Array.isArray;function j(){}var k={H:null,A:null,T:null,S:null},q=Object.prototype.hasOwnProperty;function Z(E,O,W){var le=W.ref;return{$$typeof:n,type:E,key:O,ref:le!==void 0?le:null,props:W}}function ie(E,O){return Z(E.type,O,E.props)}function J(E){return typeof E=="object"&&E!==null&&E.$$typeof===n}function ne(E){var O={"=":"=0",":":"=2"};return"$"+E.replace(/[=:]/g,function(W){return O[W]})}var P=/\/+/g;function C(E,O){return typeof E=="object"&&E!==null&&E.key!=null?ne(""+E.key):O.toString(36)}function V(E){switch(E.status){case"fulfilled":return E.value;case"rejected":throw E.reason;default:switch(typeof E.status=="string"?E.then(j,j):(E.status="pending",E.then(function(O){E.status==="pending"&&(E.status="fulfilled",E.value=O)},function(O){E.status==="pending"&&(E.status="rejected",E.reason=O)})),E.status){case"fulfilled":return E.value;case"rejected":throw E.reason}}throw E}function M(E,O,W,le,ce){var me=typeof E;(me==="undefined"||me==="boolean")&&(E=null);var ge=!1;if(E===null)ge=!0;else switch(me){case"bigint":case"string":case"number":ge=!0;break;case"object":switch(E.$$typeof){case n:case l:ge=!0;break;case v:return ge=E._init,M(ge(E._payload),O,W,le,ce)}}if(ge)return ce=ce(E),ge=le===""?"."+C(E,0):le,H(ce)?(W="",ge!=null&&(W=ge.replace(P,"$&/")+"/"),M(ce,O,W,"",function(ee){return ee})):ce!=null&&(J(ce)&&(ce=ie(ce,W+(ce.key==null||E&&E.key===ce.key?"":(""+ce.key).replace(P,"$&/")+"/")+ge)),O.push(ce)),1;ge=0;var ae=le===""?".":le+":";if(H(E))for(var fe=0;fe<E.length;fe++)le=E[fe],me=ae+C(le,fe),ge+=M(le,O,W,me,ce);else if(fe=x(E),typeof fe=="function")for(E=fe.call(E),fe=0;!(le=E.next()).done;)le=le.value,me=ae+C(le,fe++),ge+=M(le,O,W,me,ce);else if(me==="object"){if(typeof E.then=="function")return M(V(E),O,W,le,ce);throw O=String(E),Error("Objects are not valid as a React child (found: "+(O==="[object Object]"?"object with keys {"+Object.keys(E).join(", ")+"}":O)+"). If you meant to render a collection of children, use an array instead.")}return ge}function B(E,O,W){if(E==null)return E;var le=[],ce=0;return M(E,le,"","",function(me){return O.call(W,me,ce++)}),le}function X(E){if(E._status===-1){var O=E._result;O=O(),O.then(function(W){(E._status===0||E._status===-1)&&(E._status=1,E._result=W)},function(W){(E._status===0||E._status===-1)&&(E._status=2,E._result=W)}),E._status===-1&&(E._status=0,E._result=O)}if(E._status===1)return E._result.default;throw E._result}var Y=typeof reportError=="function"?reportError:function(E){if(typeof window=="object"&&typeof window.ErrorEvent=="function"){var O=new window.ErrorEvent("error",{bubbles:!0,cancelable:!0,message:typeof E=="object"&&E!==null&&typeof E.message=="string"?String(E.message):String(E),error:E});if(!window.dispatchEvent(O))return}else if(typeof process=="object"&&typeof process.emit=="function"){process.emit("uncaughtException",E);return}console.error(E)},U={map:B,forEach:function(E,O,W){B(E,function(){O.apply(this,arguments)},W)},count:function(E){var O=0;return B(E,function(){O++}),O},toArray:function(E){return B(E,function(O){return O})||[]},only:function(E){if(!J(E))throw Error("React.Children.only expected to receive a single React element child.");return E}};return Ne.Activity=p,Ne.Children=U,Ne.Component=A,Ne.Fragment=o,Ne.Profiler=u,Ne.PureComponent=S,Ne.StrictMode=r,Ne.Suspense=m,Ne.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE=k,Ne.__COMPILER_RUNTIME={__proto__:null,c:function(E){return k.H.useMemoCache(E)}},Ne.cache=function(E){return function(){return E.apply(null,arguments)}},Ne.cacheSignal=function(){return null},Ne.cloneElement=function(E,O,W){if(E==null)throw Error("The argument must be a React element, but you passed "+E+".");var le=T({},E.props),ce=E.key;if(O!=null)for(me in O.key!==void 0&&(ce=""+O.key),O)!q.call(O,me)||me==="key"||me==="__self"||me==="__source"||me==="ref"&&O.ref===void 0||(le[me]=O[me]);var me=arguments.length-2;if(me===1)le.children=W;else if(1<me){for(var ge=Array(me),ae=0;ae<me;ae++)ge[ae]=arguments[ae+2];le.children=ge}return Z(E.type,ce,le)},Ne.createContext=function(E){return E={$$typeof:d,_currentValue:E,_currentValue2:E,_threadCount:0,Provider:null,Consumer:null},E.Provider=E,E.Consumer={$$typeof:f,_context:E},E},Ne.createElement=function(E,O,W){var le,ce={},me=null;if(O!=null)for(le in O.key!==void 0&&(me=""+O.key),O)q.call(O,le)&&le!=="key"&&le!=="__self"&&le!=="__source"&&(ce[le]=O[le]);var ge=arguments.length-2;if(ge===1)ce.children=W;else if(1<ge){for(var ae=Array(ge),fe=0;fe<ge;fe++)ae[fe]=arguments[fe+2];ce.children=ae}if(E&&E.defaultProps)for(le in ge=E.defaultProps,ge)ce[le]===void 0&&(ce[le]=ge[le]);return Z(E,me,ce)},Ne.createRef=function(){return{current:null}},Ne.forwardRef=function(E){return{$$typeof:h,render:E}},Ne.isValidElement=J,Ne.lazy=function(E){return{$$typeof:v,_payload:{_status:-1,_result:E},_init:X}},Ne.memo=function(E,O){return{$$typeof:g,type:E,compare:O===void 0?null:O}},Ne.startTransition=function(E){var O=k.T,W={};k.T=W;try{var le=E(),ce=k.S;ce!==null&&ce(W,le),typeof le=="object"&&le!==null&&typeof le.then=="function"&&le.then(j,Y)}catch(me){Y(me)}finally{O!==null&&W.types!==null&&(O.types=W.types),k.T=O}},Ne.unstable_useCacheRefresh=function(){return k.H.useCacheRefresh()},Ne.use=function(E){return k.H.use(E)},Ne.useActionState=function(E,O,W){return k.H.useActionState(E,O,W)},Ne.useCallback=function(E,O){return k.H.useCallback(E,O)},Ne.useContext=function(E){return k.H.useContext(E)},Ne.useDebugValue=function(){},Ne.useDeferredValue=function(E,O){return k.H.useDeferredValue(E,O)},Ne.useEffect=function(E,O){return k.H.useEffect(E,O)},Ne.useEffectEvent=function(E){return k.H.useEffectEvent(E)},Ne.useId=function(){return k.H.useId()},Ne.useImperativeHandle=function(E,O,W){return k.H.useImperativeHandle(E,O,W)},Ne.useInsertionEffect=function(E,O){return k.H.useInsertionEffect(E,O)},Ne.useLayoutEffect=function(E,O){return k.H.useLayoutEffect(E,O)},Ne.useMemo=function(E,O){return k.H.useMemo(E,O)},Ne.useOptimistic=function(E,O){return k.H.useOptimistic(E,O)},Ne.useReducer=function(E,O,W){return k.H.useReducer(E,O,W)},Ne.useRef=function(E){return k.H.useRef(E)},Ne.useState=function(E){return k.H.useState(E)},Ne.useSyncExternalStore=function(E,O,W){return k.H.useSyncExternalStore(E,O,W)},Ne.useTransition=function(){return k.H.useTransition()},Ne.version="19.2.8",Ne}var cm;function Do(){return cm||(cm=1,df.exports=Yx()),df.exports}var $=Do();const go=Oy($);var hf={exports:{}},co={},gf={exports:{}},mf={};/**
+ * @license React
+ * scheduler.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */var fm;function Vx(){return fm||(fm=1,(function(n){function l(M,B){var X=M.length;M.push(B);e:for(;0<X;){var Y=X-1>>>1,U=M[Y];if(0<u(U,B))M[Y]=B,M[X]=U,X=Y;else break e}}function o(M){return M.length===0?null:M[0]}function r(M){if(M.length===0)return null;var B=M[0],X=M.pop();if(X!==B){M[0]=X;e:for(var Y=0,U=M.length,E=U>>>1;Y<E;){var O=2*(Y+1)-1,W=M[O],le=O+1,ce=M[le];if(0>u(W,X))le<U&&0>u(ce,W)?(M[Y]=ce,M[le]=X,Y=le):(M[Y]=W,M[O]=X,Y=O);else if(le<U&&0>u(ce,X))M[Y]=ce,M[le]=X,Y=le;else break e}}return B}function u(M,B){var X=M.sortIndex-B.sortIndex;return X!==0?X:M.id-B.id}if(n.unstable_now=void 0,typeof performance=="object"&&typeof performance.now=="function"){var f=performance;n.unstable_now=function(){return f.now()}}else{var d=Date,h=d.now();n.unstable_now=function(){return d.now()-h}}var m=[],g=[],v=1,p=null,b=3,x=!1,_=!1,T=!1,z=!1,A=typeof setTimeout=="function"?setTimeout:null,R=typeof clearTimeout=="function"?clearTimeout:null,S=typeof setImmediate<"u"?setImmediate:null;function D(M){for(var B=o(g);B!==null;){if(B.callback===null)r(g);else if(B.startTime<=M)r(g),B.sortIndex=B.expirationTime,l(m,B);else break;B=o(g)}}function H(M){if(T=!1,D(M),!_)if(o(m)!==null)_=!0,j||(j=!0,ne());else{var B=o(g);B!==null&&V(H,B.startTime-M)}}var j=!1,k=-1,q=5,Z=-1;function ie(){return z?!0:!(n.unstable_now()-Z<q)}function J(){if(z=!1,j){var M=n.unstable_now();Z=M;var B=!0;try{e:{_=!1,T&&(T=!1,R(k),k=-1),x=!0;var X=b;try{t:{for(D(M),p=o(m);p!==null&&!(p.expirationTime>M&&ie());){var Y=p.callback;if(typeof Y=="function"){p.callback=null,b=p.priorityLevel;var U=Y(p.expirationTime<=M);if(M=n.unstable_now(),typeof U=="function"){p.callback=U,D(M),B=!0;break t}p===o(m)&&r(m),D(M)}else r(m);p=o(m)}if(p!==null)B=!0;else{var E=o(g);E!==null&&V(H,E.startTime-M),B=!1}}break e}finally{p=null,b=X,x=!1}B=void 0}}finally{B?ne():j=!1}}}var ne;if(typeof S=="function")ne=function(){S(J)};else if(typeof MessageChannel<"u"){var P=new MessageChannel,C=P.port2;P.port1.onmessage=J,ne=function(){C.postMessage(null)}}else ne=function(){A(J,0)};function V(M,B){k=A(function(){M(n.unstable_now())},B)}n.unstable_IdlePriority=5,n.unstable_ImmediatePriority=1,n.unstable_LowPriority=4,n.unstable_NormalPriority=3,n.unstable_Profiling=null,n.unstable_UserBlockingPriority=2,n.unstable_cancelCallback=function(M){M.callback=null},n.unstable_forceFrameRate=function(M){0>M||125<M?console.error("forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported"):q=0<M?Math.floor(1e3/M):5},n.unstable_getCurrentPriorityLevel=function(){return b},n.unstable_next=function(M){switch(b){case 1:case 2:case 3:var B=3;break;default:B=b}var X=b;b=B;try{return M()}finally{b=X}},n.unstable_requestPaint=function(){z=!0},n.unstable_runWithPriority=function(M,B){switch(M){case 1:case 2:case 3:case 4:case 5:break;default:M=3}var X=b;b=M;try{return B()}finally{b=X}},n.unstable_scheduleCallback=function(M,B,X){var Y=n.unstable_now();switch(typeof X=="object"&&X!==null?(X=X.delay,X=typeof X=="number"&&0<X?Y+X:Y):X=Y,M){case 1:var U=-1;break;case 2:U=250;break;case 5:U=1073741823;break;case 4:U=1e4;break;default:U=5e3}return U=X+U,M={id:v++,callback:B,priorityLevel:M,startTime:X,expirationTime:U,sortIndex:-1},X>Y?(M.sortIndex=X,l(g,M),o(m)===null&&M===o(g)&&(T?(R(k),k=-1):T=!0,V(H,X-Y))):(M.sortIndex=U,l(m,M),_||x||(_=!0,j||(j=!0,ne()))),M},n.unstable_shouldYield=ie,n.unstable_wrapCallback=function(M){var B=b;return function(){var X=b;b=B;try{return M.apply(this,arguments)}finally{b=X}}}})(mf)),mf}var dm;function Xx(){return dm||(dm=1,gf.exports=Vx()),gf.exports}var yf={exports:{}},vt={};/**
+ * @license React
+ * react-dom.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */var hm;function Qx(){if(hm)return vt;hm=1;var n=Do();function l(m){var g="https://react.dev/errors/"+m;if(1<arguments.length){g+="?args[]="+encodeURIComponent(arguments[1]);for(var v=2;v<arguments.length;v++)g+="&args[]="+encodeURIComponent(arguments[v])}return"Minified React error #"+m+"; visit "+g+" for the full message or use the non-minified dev environment for full errors and additional helpful warnings."}function o(){}var r={d:{f:o,r:function(){throw Error(l(522))},D:o,C:o,L:o,m:o,X:o,S:o,M:o},p:0,findDOMNode:null},u=Symbol.for("react.portal");function f(m,g,v){var p=3<arguments.length&&arguments[3]!==void 0?arguments[3]:null;return{$$typeof:u,key:p==null?null:""+p,children:m,containerInfo:g,implementation:v}}var d=n.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;function h(m,g){if(m==="font")return"";if(typeof g=="string")return g==="use-credentials"?g:""}return vt.__DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE=r,vt.createPortal=function(m,g){var v=2<arguments.length&&arguments[2]!==void 0?arguments[2]:null;if(!g||g.nodeType!==1&&g.nodeType!==9&&g.nodeType!==11)throw Error(l(299));return f(m,g,null,v)},vt.flushSync=function(m){var g=d.T,v=r.p;try{if(d.T=null,r.p=2,m)return m()}finally{d.T=g,r.p=v,r.d.f()}},vt.preconnect=function(m,g){typeof m=="string"&&(g?(g=g.crossOrigin,g=typeof g=="string"?g==="use-credentials"?g:"":void 0):g=null,r.d.C(m,g))},vt.prefetchDNS=function(m){typeof m=="string"&&r.d.D(m)},vt.preinit=function(m,g){if(typeof m=="string"&&g&&typeof g.as=="string"){var v=g.as,p=h(v,g.crossOrigin),b=typeof g.integrity=="string"?g.integrity:void 0,x=typeof g.fetchPriority=="string"?g.fetchPriority:void 0;v==="style"?r.d.S(m,typeof g.precedence=="string"?g.precedence:void 0,{crossOrigin:p,integrity:b,fetchPriority:x}):v==="script"&&r.d.X(m,{crossOrigin:p,integrity:b,fetchPriority:x,nonce:typeof g.nonce=="string"?g.nonce:void 0})}},vt.preinitModule=function(m,g){if(typeof m=="string")if(typeof g=="object"&&g!==null){if(g.as==null||g.as==="script"){var v=h(g.as,g.crossOrigin);r.d.M(m,{crossOrigin:v,integrity:typeof g.integrity=="string"?g.integrity:void 0,nonce:typeof g.nonce=="string"?g.nonce:void 0})}}else g==null&&r.d.M(m)},vt.preload=function(m,g){if(typeof m=="string"&&typeof g=="object"&&g!==null&&typeof g.as=="string"){var v=g.as,p=h(v,g.crossOrigin);r.d.L(m,v,{crossOrigin:p,integrity:typeof g.integrity=="string"?g.integrity:void 0,nonce:typeof g.nonce=="string"?g.nonce:void 0,type:typeof g.type=="string"?g.type:void 0,fetchPriority:typeof g.fetchPriority=="string"?g.fetchPriority:void 0,referrerPolicy:typeof g.referrerPolicy=="string"?g.referrerPolicy:void 0,imageSrcSet:typeof g.imageSrcSet=="string"?g.imageSrcSet:void 0,imageSizes:typeof g.imageSizes=="string"?g.imageSizes:void 0,media:typeof g.media=="string"?g.media:void 0})}},vt.preloadModule=function(m,g){if(typeof m=="string")if(g){var v=h(g.as,g.crossOrigin);r.d.m(m,{as:typeof g.as=="string"&&g.as!=="script"?g.as:void 0,crossOrigin:v,integrity:typeof g.integrity=="string"?g.integrity:void 0})}else r.d.m(m)},vt.requestFormReset=function(m){r.d.r(m)},vt.unstable_batchedUpdates=function(m,g){return m(g)},vt.useFormState=function(m,g,v){return d.H.useFormState(m,g,v)},vt.useFormStatus=function(){return d.H.useHostTransitionStatus()},vt.version="19.2.8",vt}var gm;function Hy(){if(gm)return yf.exports;gm=1;function n(){if(!(typeof __REACT_DEVTOOLS_GLOBAL_HOOK__>"u"||typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE!="function"))try{__REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(n)}catch(l){console.error(l)}}return n(),yf.exports=Qx(),yf.exports}/**
+ * @license React
+ * react-dom-client.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */var mm;function $x(){if(mm)return co;mm=1;var n=Xx(),l=Do(),o=Hy();function r(e){var t="https://react.dev/errors/"+e;if(1<arguments.length){t+="?args[]="+encodeURIComponent(arguments[1]);for(var a=2;a<arguments.length;a++)t+="&args[]="+encodeURIComponent(arguments[a])}return"Minified React error #"+e+"; visit "+t+" for the full message or use the non-minified dev environment for full errors and additional helpful warnings."}function u(e){return!(!e||e.nodeType!==1&&e.nodeType!==9&&e.nodeType!==11)}function f(e){var t=e,a=e;if(e.alternate)for(;t.return;)t=t.return;else{e=t;do t=e,(t.flags&4098)!==0&&(a=t.return),e=t.return;while(e)}return t.tag===3?a:null}function d(e){if(e.tag===13){var t=e.memoizedState;if(t===null&&(e=e.alternate,e!==null&&(t=e.memoizedState)),t!==null)return t.dehydrated}return null}function h(e){if(e.tag===31){var t=e.memoizedState;if(t===null&&(e=e.alternate,e!==null&&(t=e.memoizedState)),t!==null)return t.dehydrated}return null}function m(e){if(f(e)!==e)throw Error(r(188))}function g(e){var t=e.alternate;if(!t){if(t=f(e),t===null)throw Error(r(188));return t!==e?null:e}for(var a=e,i=t;;){var s=a.return;if(s===null)break;var c=s.alternate;if(c===null){if(i=s.return,i!==null){a=i;continue}break}if(s.child===c.child){for(c=s.child;c;){if(c===a)return m(s),e;if(c===i)return m(s),t;c=c.sibling}throw Error(r(188))}if(a.return!==i.return)a=s,i=c;else{for(var y=!1,w=s.child;w;){if(w===a){y=!0,a=s,i=c;break}if(w===i){y=!0,i=s,a=c;break}w=w.sibling}if(!y){for(w=c.child;w;){if(w===a){y=!0,a=c,i=s;break}if(w===i){y=!0,i=c,a=s;break}w=w.sibling}if(!y)throw Error(r(189))}}if(a.alternate!==i)throw Error(r(190))}if(a.tag!==3)throw Error(r(188));return a.stateNode.current===a?e:t}function v(e){var t=e.tag;if(t===5||t===26||t===27||t===6)return e;for(e=e.child;e!==null;){if(t=v(e),t!==null)return t;e=e.sibling}return null}var p=Object.assign,b=Symbol.for("react.element"),x=Symbol.for("react.transitional.element"),_=Symbol.for("react.portal"),T=Symbol.for("react.fragment"),z=Symbol.for("react.strict_mode"),A=Symbol.for("react.profiler"),R=Symbol.for("react.consumer"),S=Symbol.for("react.context"),D=Symbol.for("react.forward_ref"),H=Symbol.for("react.suspense"),j=Symbol.for("react.suspense_list"),k=Symbol.for("react.memo"),q=Symbol.for("react.lazy"),Z=Symbol.for("react.activity"),ie=Symbol.for("react.memo_cache_sentinel"),J=Symbol.iterator;function ne(e){return e===null||typeof e!="object"?null:(e=J&&e[J]||e["@@iterator"],typeof e=="function"?e:null)}var P=Symbol.for("react.client.reference");function C(e){if(e==null)return null;if(typeof e=="function")return e.$$typeof===P?null:e.displayName||e.name||null;if(typeof e=="string")return e;switch(e){case T:return"Fragment";case A:return"Profiler";case z:return"StrictMode";case H:return"Suspense";case j:return"SuspenseList";case Z:return"Activity"}if(typeof e=="object")switch(e.$$typeof){case _:return"Portal";case S:return e.displayName||"Context";case R:return(e._context.displayName||"Context")+".Consumer";case D:var t=e.render;return e=e.displayName,e||(e=t.displayName||t.name||"",e=e!==""?"ForwardRef("+e+")":"ForwardRef"),e;case k:return t=e.displayName||null,t!==null?t:C(e.type)||"Memo";case q:t=e._payload,e=e._init;try{return C(e(t))}catch{}}return null}var V=Array.isArray,M=l.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE,B=o.__DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE,X={pending:!1,data:null,method:null,action:null},Y=[],U=-1;function E(e){return{current:e}}function O(e){0>U||(e.current=Y[U],Y[U]=null,U--)}function W(e,t){U++,Y[U]=e.current,e.current=t}var le=E(null),ce=E(null),me=E(null),ge=E(null);function ae(e,t){switch(W(me,t),W(ce,e),W(le,null),t.nodeType){case 9:case 11:e=(e=t.documentElement)&&(e=e.namespaceURI)?C0(e):0;break;default:if(e=t.tagName,t=t.namespaceURI)t=C0(t),e=D0(t,e);else switch(e){case"svg":e=1;break;case"math":e=2;break;default:e=0}}O(le),W(le,e)}function fe(){O(le),O(ce),O(me)}function ee(e){e.memoizedState!==null&&W(ge,e);var t=le.current,a=D0(t,e.type);t!==a&&(W(ce,e),W(le,a))}function se(e){ce.current===e&&(O(le),O(ce)),ge.current===e&&(O(ge),io._currentValue=X)}var de,pe;function we(e){if(de===void 0)try{throw Error()}catch(a){var t=a.stack.trim().match(/\n( *(at )?)/);de=t&&t[1]||"",pe=-1<a.stack.indexOf(`
+    at`)?" (<anonymous>)":-1<a.stack.indexOf("@")?"@unknown:0:0":""}return`
+`+de+e+pe}var he=!1;function ye(e,t){if(!e||he)return"";he=!0;var a=Error.prepareStackTrace;Error.prepareStackTrace=void 0;try{var i={DetermineComponentFrameRoot:function(){try{if(t){var ue=function(){throw Error()};if(Object.defineProperty(ue.prototype,"props",{set:function(){throw Error()}}),typeof Reflect=="object"&&Reflect.construct){try{Reflect.construct(ue,[])}catch(te){var F=te}Reflect.construct(e,[],ue)}else{try{ue.call()}catch(te){F=te}e.call(ue.prototype)}}else{try{throw Error()}catch(te){F=te}(ue=e())&&typeof ue.catch=="function"&&ue.catch(function(){})}}catch(te){if(te&&F&&typeof te.stack=="string")return[te.stack,F.stack]}return[null,null]}};i.DetermineComponentFrameRoot.displayName="DetermineComponentFrameRoot";var s=Object.getOwnPropertyDescriptor(i.DetermineComponentFrameRoot,"name");s&&s.configurable&&Object.defineProperty(i.DetermineComponentFrameRoot,"name",{value:"DetermineComponentFrameRoot"});var c=i.DetermineComponentFrameRoot(),y=c[0],w=c[1];if(y&&w){var L=y.split(`
+`),I=w.split(`
+`);for(s=i=0;i<L.length&&!L[i].includes("DetermineComponentFrameRoot");)i++;for(;s<I.length&&!I[s].includes("DetermineComponentFrameRoot");)s++;if(i===L.length||s===I.length)for(i=L.length-1,s=I.length-1;1<=i&&0<=s&&L[i]!==I[s];)s--;for(;1<=i&&0<=s;i--,s--)if(L[i]!==I[s]){if(i!==1||s!==1)do if(i--,s--,0>s||L[i]!==I[s]){var oe=`
+`+L[i].replace(" at new "," at ");return e.displayName&&oe.includes("<anonymous>")&&(oe=oe.replace("<anonymous>",e.displayName)),oe}while(1<=i&&0<=s);break}}}finally{he=!1,Error.prepareStackTrace=a}return(a=e?e.displayName||e.name:"")?we(a):""}function Ae(e,t){switch(e.tag){case 26:case 27:case 5:return we(e.type);case 16:return we("Lazy");case 13:return e.child!==t&&t!==null?we("Suspense Fallback"):we("Suspense");case 19:return we("SuspenseList");case 0:case 15:return ye(e.type,!1);case 11:return ye(e.type.render,!1);case 1:return ye(e.type,!0);case 31:return we("Activity");default:return""}}function Ke(e){try{var t="",a=null;do t+=Ae(e,a),a=e,e=e.return;while(e);return t}catch(i){return`
+Error generating stack: `+i.message+`
+`+i.stack}}var ft=Object.prototype.hasOwnProperty,yt=n.unstable_scheduleCallback,kt=n.unstable_cancelCallback,za=n.unstable_shouldYield,Nn=n.unstable_requestPaint,Fe=n.unstable_now,Rt=n.unstable_getCurrentPriorityLevel,Xt=n.unstable_ImmediatePriority,Qt=n.unstable_UserBlockingPriority,$t=n.unstable_NormalPriority,di=n.unstable_LowPriority,ul=n.unstable_IdlePriority,Iu=n.log,Ju=n.unstable_setDisableYieldValue,Ca=null,bt=null;function hn(e){if(typeof Iu=="function"&&Ju(e),bt&&typeof bt.setStrictMode=="function")try{bt.setStrictMode(Ca,e)}catch{}}var xt=Math.clz32?Math.clz32:Pu,Wu=Math.log,Fu=Math.LN2;function Pu(e){return e>>>=0,e===0?32:31-(Wu(e)/Fu|0)|0}var sl=256,cl=262144,fl=4194304;function Tn(e){var t=e&42;if(t!==0)return t;switch(e&-e){case 1:return 1;case 2:return 2;case 4:return 4;case 8:return 8;case 16:return 16;case 32:return 32;case 64:return 64;case 128:return 128;case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:return e&261888;case 262144:case 524288:case 1048576:case 2097152:return e&3932160;case 4194304:case 8388608:case 16777216:case 33554432:return e&62914560;case 67108864:return 67108864;case 134217728:return 134217728;case 268435456:return 268435456;case 536870912:return 536870912;case 1073741824:return 0;default:return e}}function dl(e,t,a){var i=e.pendingLanes;if(i===0)return 0;var s=0,c=e.suspendedLanes,y=e.pingedLanes;e=e.warmLanes;var w=i&134217727;return w!==0?(i=w&~c,i!==0?s=Tn(i):(y&=w,y!==0?s=Tn(y):a||(a=w&~e,a!==0&&(s=Tn(a))))):(w=i&~c,w!==0?s=Tn(w):y!==0?s=Tn(y):a||(a=i&~e,a!==0&&(s=Tn(a)))),s===0?0:t!==0&&t!==s&&(t&c)===0&&(c=s&-s,a=t&-t,c>=a||c===32&&(a&4194048)!==0)?t:s}function Da(e,t){return(e.pendingLanes&~(e.suspendedLanes&~e.pingedLanes)&t)===0}function es(e,t){switch(e){case 1:case 2:case 4:case 8:case 64:return t+250;case 16:case 32:case 128:case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:case 262144:case 524288:case 1048576:case 2097152:return t+5e3;case 4194304:case 8388608:case 16777216:case 33554432:return-1;case 67108864:case 134217728:case 268435456:case 536870912:case 1073741824:return-1;default:return-1}}function Go(){var e=fl;return fl<<=1,(fl&62914560)===0&&(fl=4194304),e}function hi(e){for(var t=[],a=0;31>a;a++)t.push(e);return t}function ka(e,t){e.pendingLanes|=t,t!==268435456&&(e.suspendedLanes=0,e.pingedLanes=0,e.warmLanes=0)}function ts(e,t,a,i,s,c){var y=e.pendingLanes;e.pendingLanes=a,e.suspendedLanes=0,e.pingedLanes=0,e.warmLanes=0,e.expiredLanes&=a,e.entangledLanes&=a,e.errorRecoveryDisabledLanes&=a,e.shellSuspendCounter=0;var w=e.entanglements,L=e.expirationTimes,I=e.hiddenUpdates;for(a=y&~a;0<a;){var oe=31-xt(a),ue=1<<oe;w[oe]=0,L[oe]=-1;var F=I[oe];if(F!==null)for(I[oe]=null,oe=0;oe<F.length;oe++){var te=F[oe];te!==null&&(te.lane&=-536870913)}a&=~ue}i!==0&&qo(e,i,0),c!==0&&s===0&&e.tag!==0&&(e.suspendedLanes|=c&~(y&~t))}function qo(e,t,a){e.pendingLanes|=t,e.suspendedLanes&=~t;var i=31-xt(t);e.entangledLanes|=t,e.entanglements[i]=e.entanglements[i]|1073741824|a&261930}function Yo(e,t){var a=e.entangledLanes|=t;for(e=e.entanglements;a;){var i=31-xt(a),s=1<<i;s&t|e[i]&t&&(e[i]|=t),a&=~s}}function Vo(e,t){var a=t&-t;return a=(a&42)!==0?1:gi(a),(a&(e.suspendedLanes|t))!==0?0:a}function gi(e){switch(e){case 2:e=1;break;case 8:e=4;break;case 32:e=16;break;case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:case 262144:case 524288:case 1048576:case 2097152:case 4194304:case 8388608:case 16777216:case 33554432:e=128;break;case 268435456:e=134217728;break;default:e=0}return e}function mi(e){return e&=-e,2<e?8<e?(e&134217727)!==0?32:268435456:8:2}function Xo(){var e=B.p;return e!==0?e:(e=window.event,e===void 0?32:em(e.type))}function Qo(e,t){var a=B.p;try{return B.p=e,t()}finally{B.p=a}}var gn=Math.random().toString(36).slice(2),rt="__reactFiber$"+gn,pt="__reactProps$"+gn,An="__reactContainer$"+gn,hl="__reactEvents$"+gn,$o="__reactListeners$"+gn,ns="__reactHandles$"+gn,Zo="__reactResources$"+gn,Ra="__reactMarker$"+gn;function yi(e){delete e[rt],delete e[pt],delete e[hl],delete e[$o],delete e[ns]}function In(e){var t=e[rt];if(t)return t;for(var a=e.parentNode;a;){if(t=a[An]||a[rt]){if(a=t.alternate,t.child!==null||a!==null&&a.child!==null)for(e=L0(e);e!==null;){if(a=e[rt])return a;e=L0(e)}return t}e=a,a=e.parentNode}return null}function Jn(e){if(e=e[rt]||e[An]){var t=e.tag;if(t===5||t===6||t===13||t===31||t===26||t===27||t===3)return e}return null}function Wn(e){var t=e.tag;if(t===5||t===26||t===27||t===6)return e.stateNode;throw Error(r(33))}function Fn(e){var t=e[Zo];return t||(t=e[Zo]={hoistableStyles:new Map,hoistableScripts:new Map}),t}function tt(e){e[Ra]=!0}var Ko=new Set,Io={};function Mn(e,t){Pn(e,t),Pn(e+"Capture",t)}function Pn(e,t){for(Io[e]=t,e=0;e<t.length;e++)Ko.add(t[e])}var as=RegExp("^[:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD][:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$"),Jo={},pi={};function ls(e){return ft.call(pi,e)?!0:ft.call(Jo,e)?!1:as.test(e)?pi[e]=!0:(Jo[e]=!0,!1)}function gl(e,t,a){if(ls(t))if(a===null)e.removeAttribute(t);else{switch(typeof a){case"undefined":case"function":case"symbol":e.removeAttribute(t);return;case"boolean":var i=t.toLowerCase().slice(0,5);if(i!=="data-"&&i!=="aria-"){e.removeAttribute(t);return}}e.setAttribute(t,""+a)}}function ml(e,t,a){if(a===null)e.removeAttribute(t);else{switch(typeof a){case"undefined":case"function":case"symbol":case"boolean":e.removeAttribute(t);return}e.setAttribute(t,""+a)}}function tn(e,t,a,i){if(i===null)e.removeAttribute(a);else{switch(typeof i){case"undefined":case"function":case"symbol":case"boolean":e.removeAttribute(a);return}e.setAttributeNS(t,a,""+i)}}function St(e){switch(typeof e){case"bigint":case"boolean":case"number":case"string":case"undefined":return e;case"object":return e;default:return""}}function Wo(e){var t=e.type;return(e=e.nodeName)&&e.toLowerCase()==="input"&&(t==="checkbox"||t==="radio")}function is(e,t,a){var i=Object.getOwnPropertyDescriptor(e.constructor.prototype,t);if(!e.hasOwnProperty(t)&&typeof i<"u"&&typeof i.get=="function"&&typeof i.set=="function"){var s=i.get,c=i.set;return Object.defineProperty(e,t,{configurable:!0,get:function(){return s.call(this)},set:function(y){a=""+y,c.call(this,y)}}),Object.defineProperty(e,t,{enumerable:i.enumerable}),{getValue:function(){return a},setValue:function(y){a=""+y},stopTracking:function(){e._valueTracker=null,delete e[t]}}}}function vi(e){if(!e._valueTracker){var t=Wo(e)?"checked":"value";e._valueTracker=is(e,t,""+e[t])}}function ja(e){if(!e)return!1;var t=e._valueTracker;if(!t)return!0;var a=t.getValue(),i="";return e&&(i=Wo(e)?e.checked?"true":"false":e.value),e=i,e!==a?(t.setValue(e),!0):!1}function yl(e){if(e=e||(typeof document<"u"?document:void 0),typeof e>"u")return null;try{return e.activeElement||e.body}catch{return e.body}}var Fo=/[\n"\\]/g;function Et(e){return e.replace(Fo,function(t){return"\\"+t.charCodeAt(0).toString(16)+" "})}function bi(e,t,a,i,s,c,y,w){e.name="",y!=null&&typeof y!="function"&&typeof y!="symbol"&&typeof y!="boolean"?e.type=y:e.removeAttribute("type"),t!=null?y==="number"?(t===0&&e.value===""||e.value!=t)&&(e.value=""+St(t)):e.value!==""+St(t)&&(e.value=""+St(t)):y!=="submit"&&y!=="reset"||e.removeAttribute("value"),t!=null?xi(e,y,St(t)):a!=null?xi(e,y,St(a)):i!=null&&e.removeAttribute("value"),s==null&&c!=null&&(e.defaultChecked=!!c),s!=null&&(e.checked=s&&typeof s!="function"&&typeof s!="symbol"),w!=null&&typeof w!="function"&&typeof w!="symbol"&&typeof w!="boolean"?e.name=""+St(w):e.removeAttribute("name")}function pl(e,t,a,i,s,c,y,w){if(c!=null&&typeof c!="function"&&typeof c!="symbol"&&typeof c!="boolean"&&(e.type=c),t!=null||a!=null){if(!(c!=="submit"&&c!=="reset"||t!=null)){vi(e);return}a=a!=null?""+St(a):"",t=t!=null?""+St(t):a,w||t===e.value||(e.value=t),e.defaultValue=t}i=i??s,i=typeof i!="function"&&typeof i!="symbol"&&!!i,e.checked=w?e.checked:!!i,e.defaultChecked=!!i,y!=null&&typeof y!="function"&&typeof y!="symbol"&&typeof y!="boolean"&&(e.name=y),vi(e)}function xi(e,t,a){t==="number"&&yl(e.ownerDocument)===e||e.defaultValue===""+a||(e.defaultValue=""+a)}function ea(e,t,a,i){if(e=e.options,t){t={};for(var s=0;s<a.length;s++)t["$"+a[s]]=!0;for(a=0;a<e.length;a++)s=t.hasOwnProperty("$"+e[a].value),e[a].selected!==s&&(e[a].selected=s),s&&i&&(e[a].defaultSelected=!0)}else{for(a=""+St(a),t=null,s=0;s<e.length;s++){if(e[s].value===a){e[s].selected=!0,i&&(e[s].defaultSelected=!0);return}t!==null||e[s].disabled||(t=e[s])}t!==null&&(t.selected=!0)}}function _i(e,t,a){if(t!=null&&(t=""+St(t),t!==e.value&&(e.value=t),a==null)){e.defaultValue!==t&&(e.defaultValue=t);return}e.defaultValue=a!=null?""+St(a):""}function Td(e,t,a,i){if(t==null){if(i!=null){if(a!=null)throw Error(r(92));if(V(i)){if(1<i.length)throw Error(r(93));i=i[0]}a=i}a==null&&(a=""),t=a}a=St(t),e.defaultValue=a,i=e.textContent,i===a&&i!==""&&i!==null&&(e.value=i),vi(e)}function vl(e,t){if(t){var a=e.firstChild;if(a&&a===e.lastChild&&a.nodeType===3){a.nodeValue=t;return}}e.textContent=t}var Ov=new Set("animationIterationCount aspectRatio borderImageOutset borderImageSlice borderImageWidth boxFlex boxFlexGroup boxOrdinalGroup columnCount columns flex flexGrow flexPositive flexShrink flexNegative flexOrder gridArea gridRow gridRowEnd gridRowSpan gridRowStart gridColumn gridColumnEnd gridColumnSpan gridColumnStart fontWeight lineClamp lineHeight opacity order orphans scale tabSize widows zIndex zoom fillOpacity floodOpacity stopOpacity strokeDasharray strokeDashoffset strokeMiterlimit strokeOpacity strokeWidth MozAnimationIterationCount MozBoxFlex MozBoxFlexGroup MozLineClamp msAnimationIterationCount msFlex msZoom msFlexGrow msFlexNegative msFlexOrder msFlexPositive msFlexShrink msGridColumn msGridColumnSpan msGridRow msGridRowSpan WebkitAnimationIterationCount WebkitBoxFlex WebKitBoxFlexGroup WebkitBoxOrdinalGroup WebkitColumnCount WebkitColumns WebkitFlex WebkitFlexGrow WebkitFlexPositive WebkitFlexShrink WebkitLineClamp".split(" "));function Ad(e,t,a){var i=t.indexOf("--")===0;a==null||typeof a=="boolean"||a===""?i?e.setProperty(t,""):t==="float"?e.cssFloat="":e[t]="":i?e.setProperty(t,a):typeof a!="number"||a===0||Ov.has(t)?t==="float"?e.cssFloat=a:e[t]=(""+a).trim():e[t]=a+"px"}function Md(e,t,a){if(t!=null&&typeof t!="object")throw Error(r(62));if(e=e.style,a!=null){for(var i in a)!a.hasOwnProperty(i)||t!=null&&t.hasOwnProperty(i)||(i.indexOf("--")===0?e.setProperty(i,""):i==="float"?e.cssFloat="":e[i]="");for(var s in t)i=t[s],t.hasOwnProperty(s)&&a[s]!==i&&Ad(e,s,i)}else for(var c in t)t.hasOwnProperty(c)&&Ad(e,c,t[c])}function os(e){if(e.indexOf("-")===-1)return!1;switch(e){case"annotation-xml":case"color-profile":case"font-face":case"font-face-src":case"font-face-uri":case"font-face-format":case"font-face-name":case"missing-glyph":return!1;default:return!0}}var Hv=new Map([["acceptCharset","accept-charset"],["htmlFor","for"],["httpEquiv","http-equiv"],["crossOrigin","crossorigin"],["accentHeight","accent-height"],["alignmentBaseline","alignment-baseline"],["arabicForm","arabic-form"],["baselineShift","baseline-shift"],["capHeight","cap-height"],["clipPath","clip-path"],["clipRule","clip-rule"],["colorInterpolation","color-interpolation"],["colorInterpolationFilters","color-interpolation-filters"],["colorProfile","color-profile"],["colorRendering","color-rendering"],["dominantBaseline","dominant-baseline"],["enableBackground","enable-background"],["fillOpacity","fill-opacity"],["fillRule","fill-rule"],["floodColor","flood-color"],["floodOpacity","flood-opacity"],["fontFamily","font-family"],["fontSize","font-size"],["fontSizeAdjust","font-size-adjust"],["fontStretch","font-stretch"],["fontStyle","font-style"],["fontVariant","font-variant"],["fontWeight","font-weight"],["glyphName","glyph-name"],["glyphOrientationHorizontal","glyph-orientation-horizontal"],["glyphOrientationVertical","glyph-orientation-vertical"],["horizAdvX","horiz-adv-x"],["horizOriginX","horiz-origin-x"],["imageRendering","image-rendering"],["letterSpacing","letter-spacing"],["lightingColor","lighting-color"],["markerEnd","marker-end"],["markerMid","marker-mid"],["markerStart","marker-start"],["overlinePosition","overline-position"],["overlineThickness","overline-thickness"],["paintOrder","paint-order"],["panose-1","panose-1"],["pointerEvents","pointer-events"],["renderingIntent","rendering-intent"],["shapeRendering","shape-rendering"],["stopColor","stop-color"],["stopOpacity","stop-opacity"],["strikethroughPosition","strikethrough-position"],["strikethroughThickness","strikethrough-thickness"],["strokeDasharray","stroke-dasharray"],["strokeDashoffset","stroke-dashoffset"],["strokeLinecap","stroke-linecap"],["strokeLinejoin","stroke-linejoin"],["strokeMiterlimit","stroke-miterlimit"],["strokeOpacity","stroke-opacity"],["strokeWidth","stroke-width"],["textAnchor","text-anchor"],["textDecoration","text-decoration"],["textRendering","text-rendering"],["transformOrigin","transform-origin"],["underlinePosition","underline-position"],["underlineThickness","underline-thickness"],["unicodeBidi","unicode-bidi"],["unicodeRange","unicode-range"],["unitsPerEm","units-per-em"],["vAlphabetic","v-alphabetic"],["vHanging","v-hanging"],["vIdeographic","v-ideographic"],["vMathematical","v-mathematical"],["vectorEffect","vector-effect"],["vertAdvY","vert-adv-y"],["vertOriginX","vert-origin-x"],["vertOriginY","vert-origin-y"],["wordSpacing","word-spacing"],["writingMode","writing-mode"],["xmlnsXlink","xmlns:xlink"],["xHeight","x-height"]]),Bv=/^[\u0000-\u001F ]*j[\r\n\t]*a[\r\n\t]*v[\r\n\t]*a[\r\n\t]*s[\r\n\t]*c[\r\n\t]*r[\r\n\t]*i[\r\n\t]*p[\r\n\t]*t[\r\n\t]*:/i;function Po(e){return Bv.test(""+e)?"javascript:throw new Error('React has blocked a javascript: URL as a security precaution.')":e}function zn(){}var rs=null;function us(e){return e=e.target||e.srcElement||window,e.correspondingUseElement&&(e=e.correspondingUseElement),e.nodeType===3?e.parentNode:e}var bl=null,xl=null;function zd(e){var t=Jn(e);if(t&&(e=t.stateNode)){var a=e[pt]||null;e:switch(e=t.stateNode,t.type){case"input":if(bi(e,a.value,a.defaultValue,a.defaultValue,a.checked,a.defaultChecked,a.type,a.name),t=a.name,a.type==="radio"&&t!=null){for(a=e;a.parentNode;)a=a.parentNode;for(a=a.querySelectorAll('input[name="'+Et(""+t)+'"][type="radio"]'),t=0;t<a.length;t++){var i=a[t];if(i!==e&&i.form===e.form){var s=i[pt]||null;if(!s)throw Error(r(90));bi(i,s.value,s.defaultValue,s.defaultValue,s.checked,s.defaultChecked,s.type,s.name)}}for(t=0;t<a.length;t++)i=a[t],i.form===e.form&&ja(i)}break e;case"textarea":_i(e,a.value,a.defaultValue);break e;case"select":t=a.value,t!=null&&ea(e,!!a.multiple,t,!1)}}}var ss=!1;function Cd(e,t,a){if(ss)return e(t,a);ss=!0;try{var i=e(t);return i}finally{if(ss=!1,(bl!==null||xl!==null)&&(Gr(),bl&&(t=bl,e=xl,xl=bl=null,zd(t),e)))for(t=0;t<e.length;t++)zd(e[t])}}function wi(e,t){var a=e.stateNode;if(a===null)return null;var i=a[pt]||null;if(i===null)return null;a=i[t];e:switch(t){case"onClick":case"onClickCapture":case"onDoubleClick":case"onDoubleClickCapture":case"onMouseDown":case"onMouseDownCapture":case"onMouseMove":case"onMouseMoveCapture":case"onMouseUp":case"onMouseUpCapture":case"onMouseEnter":(i=!i.disabled)||(e=e.type,i=!(e==="button"||e==="input"||e==="select"||e==="textarea")),e=!i;break e;default:e=!1}if(e)return null;if(a&&typeof a!="function")throw Error(r(231,t,typeof a));return a}var Cn=!(typeof window>"u"||typeof window.document>"u"||typeof window.document.createElement>"u"),cs=!1;if(Cn)try{var Si={};Object.defineProperty(Si,"passive",{get:function(){cs=!0}}),window.addEventListener("test",Si,Si),window.removeEventListener("test",Si,Si)}catch{cs=!1}var ta=null,fs=null,er=null;function Dd(){if(er)return er;var e,t=fs,a=t.length,i,s="value"in ta?ta.value:ta.textContent,c=s.length;for(e=0;e<a&&t[e]===s[e];e++);var y=a-e;for(i=1;i<=y&&t[a-i]===s[c-i];i++);return er=s.slice(e,1<i?1-i:void 0)}function tr(e){var t=e.keyCode;return"charCode"in e?(e=e.charCode,e===0&&t===13&&(e=13)):e=t,e===10&&(e=13),32<=e||e===13?e:0}function nr(){return!0}function kd(){return!1}function Nt(e){function t(a,i,s,c,y){this._reactName=a,this._targetInst=s,this.type=i,this.nativeEvent=c,this.target=y,this.currentTarget=null;for(var w in e)e.hasOwnProperty(w)&&(a=e[w],this[w]=a?a(c):c[w]);return this.isDefaultPrevented=(c.defaultPrevented!=null?c.defaultPrevented:c.returnValue===!1)?nr:kd,this.isPropagationStopped=kd,this}return p(t.prototype,{preventDefault:function(){this.defaultPrevented=!0;var a=this.nativeEvent;a&&(a.preventDefault?a.preventDefault():typeof a.returnValue!="unknown"&&(a.returnValue=!1),this.isDefaultPrevented=nr)},stopPropagation:function(){var a=this.nativeEvent;a&&(a.stopPropagation?a.stopPropagation():typeof a.cancelBubble!="unknown"&&(a.cancelBubble=!0),this.isPropagationStopped=nr)},persist:function(){},isPersistent:nr}),t}var Oa={eventPhase:0,bubbles:0,cancelable:0,timeStamp:function(e){return e.timeStamp||Date.now()},defaultPrevented:0,isTrusted:0},ar=Nt(Oa),Ei=p({},Oa,{view:0,detail:0}),Lv=Nt(Ei),ds,hs,Ni,lr=p({},Ei,{screenX:0,screenY:0,clientX:0,clientY:0,pageX:0,pageY:0,ctrlKey:0,shiftKey:0,altKey:0,metaKey:0,getModifierState:ms,button:0,buttons:0,relatedTarget:function(e){return e.relatedTarget===void 0?e.fromElement===e.srcElement?e.toElement:e.fromElement:e.relatedTarget},movementX:function(e){return"movementX"in e?e.movementX:(e!==Ni&&(Ni&&e.type==="mousemove"?(ds=e.screenX-Ni.screenX,hs=e.screenY-Ni.screenY):hs=ds=0,Ni=e),ds)},movementY:function(e){return"movementY"in e?e.movementY:hs}}),Rd=Nt(lr),Uv=p({},lr,{dataTransfer:0}),Gv=Nt(Uv),qv=p({},Ei,{relatedTarget:0}),gs=Nt(qv),Yv=p({},Oa,{animationName:0,elapsedTime:0,pseudoElement:0}),Vv=Nt(Yv),Xv=p({},Oa,{clipboardData:function(e){return"clipboardData"in e?e.clipboardData:window.clipboardData}}),Qv=Nt(Xv),$v=p({},Oa,{data:0}),jd=Nt($v),Zv={Esc:"Escape",Spacebar:" ",Left:"ArrowLeft",Up:"ArrowUp",Right:"ArrowRight",Down:"ArrowDown",Del:"Delete",Win:"OS",Menu:"ContextMenu",Apps:"ContextMenu",Scroll:"ScrollLock",MozPrintableKey:"Unidentified"},Kv={8:"Backspace",9:"Tab",12:"Clear",13:"Enter",16:"Shift",17:"Control",18:"Alt",19:"Pause",20:"CapsLock",27:"Escape",32:" ",33:"PageUp",34:"PageDown",35:"End",36:"Home",37:"ArrowLeft",38:"ArrowUp",39:"ArrowRight",40:"ArrowDown",45:"Insert",46:"Delete",112:"F1",113:"F2",114:"F3",115:"F4",116:"F5",117:"F6",118:"F7",119:"F8",120:"F9",121:"F10",122:"F11",123:"F12",144:"NumLock",145:"ScrollLock",224:"Meta"},Iv={Alt:"altKey",Control:"ctrlKey",Meta:"metaKey",Shift:"shiftKey"};function Jv(e){var t=this.nativeEvent;return t.getModifierState?t.getModifierState(e):(e=Iv[e])?!!t[e]:!1}function ms(){return Jv}var Wv=p({},Ei,{key:function(e){if(e.key){var t=Zv[e.key]||e.key;if(t!=="Unidentified")return t}return e.type==="keypress"?(e=tr(e),e===13?"Enter":String.fromCharCode(e)):e.type==="keydown"||e.type==="keyup"?Kv[e.keyCode]||"Unidentified":""},code:0,location:0,ctrlKey:0,shiftKey:0,altKey:0,metaKey:0,repeat:0,locale:0,getModifierState:ms,charCode:function(e){return e.type==="keypress"?tr(e):0},keyCode:function(e){return e.type==="keydown"||e.type==="keyup"?e.keyCode:0},which:function(e){return e.type==="keypress"?tr(e):e.type==="keydown"||e.type==="keyup"?e.keyCode:0}}),Fv=Nt(Wv),Pv=p({},lr,{pointerId:0,width:0,height:0,pressure:0,tangentialPressure:0,tiltX:0,tiltY:0,twist:0,pointerType:0,isPrimary:0}),Od=Nt(Pv),eb=p({},Ei,{touches:0,targetTouches:0,changedTouches:0,altKey:0,metaKey:0,ctrlKey:0,shiftKey:0,getModifierState:ms}),tb=Nt(eb),nb=p({},Oa,{propertyName:0,elapsedTime:0,pseudoElement:0}),ab=Nt(nb),lb=p({},lr,{deltaX:function(e){return"deltaX"in e?e.deltaX:"wheelDeltaX"in e?-e.wheelDeltaX:0},deltaY:function(e){return"deltaY"in e?e.deltaY:"wheelDeltaY"in e?-e.wheelDeltaY:"wheelDelta"in e?-e.wheelDelta:0},deltaZ:0,deltaMode:0}),ib=Nt(lb),ob=p({},Oa,{newState:0,oldState:0}),rb=Nt(ob),ub=[9,13,27,32],ys=Cn&&"CompositionEvent"in window,Ti=null;Cn&&"documentMode"in document&&(Ti=document.documentMode);var sb=Cn&&"TextEvent"in window&&!Ti,Hd=Cn&&(!ys||Ti&&8<Ti&&11>=Ti),Bd=" ",Ld=!1;function Ud(e,t){switch(e){case"keyup":return ub.indexOf(t.keyCode)!==-1;case"keydown":return t.keyCode!==229;case"keypress":case"mousedown":case"focusout":return!0;default:return!1}}function Gd(e){return e=e.detail,typeof e=="object"&&"data"in e?e.data:null}var _l=!1;function cb(e,t){switch(e){case"compositionend":return Gd(t);case"keypress":return t.which!==32?null:(Ld=!0,Bd);case"textInput":return e=t.data,e===Bd&&Ld?null:e;default:return null}}function fb(e,t){if(_l)return e==="compositionend"||!ys&&Ud(e,t)?(e=Dd(),er=fs=ta=null,_l=!1,e):null;switch(e){case"paste":return null;case"keypress":if(!(t.ctrlKey||t.altKey||t.metaKey)||t.ctrlKey&&t.altKey){if(t.char&&1<t.char.length)return t.char;if(t.which)return String.fromCharCode(t.which)}return null;case"compositionend":return Hd&&t.locale!=="ko"?null:t.data;default:return null}}var db={color:!0,date:!0,datetime:!0,"datetime-local":!0,email:!0,month:!0,number:!0,password:!0,range:!0,search:!0,tel:!0,text:!0,time:!0,url:!0,week:!0};function qd(e){var t=e&&e.nodeName&&e.nodeName.toLowerCase();return t==="input"?!!db[e.type]:t==="textarea"}function Yd(e,t,a,i){bl?xl?xl.push(i):xl=[i]:bl=i,t=Zr(t,"onChange"),0<t.length&&(a=new ar("onChange","change",null,a,i),e.push({event:a,listeners:t}))}var Ai=null,Mi=null;function hb(e){E0(e,0)}function ir(e){var t=Wn(e);if(ja(t))return e}function Vd(e,t){if(e==="change")return t}var Xd=!1;if(Cn){var ps;if(Cn){var vs="oninput"in document;if(!vs){var Qd=document.createElement("div");Qd.setAttribute("oninput","return;"),vs=typeof Qd.oninput=="function"}ps=vs}else ps=!1;Xd=ps&&(!document.documentMode||9<document.documentMode)}function $d(){Ai&&(Ai.detachEvent("onpropertychange",Zd),Mi=Ai=null)}function Zd(e){if(e.propertyName==="value"&&ir(Mi)){var t=[];Yd(t,Mi,e,us(e)),Cd(hb,t)}}function gb(e,t,a){e==="focusin"?($d(),Ai=t,Mi=a,Ai.attachEvent("onpropertychange",Zd)):e==="focusout"&&$d()}function mb(e){if(e==="selectionchange"||e==="keyup"||e==="keydown")return ir(Mi)}function yb(e,t){if(e==="click")return ir(t)}function pb(e,t){if(e==="input"||e==="change")return ir(t)}function vb(e,t){return e===t&&(e!==0||1/e===1/t)||e!==e&&t!==t}var jt=typeof Object.is=="function"?Object.is:vb;function zi(e,t){if(jt(e,t))return!0;if(typeof e!="object"||e===null||typeof t!="object"||t===null)return!1;var a=Object.keys(e),i=Object.keys(t);if(a.length!==i.length)return!1;for(i=0;i<a.length;i++){var s=a[i];if(!ft.call(t,s)||!jt(e[s],t[s]))return!1}return!0}function Kd(e){for(;e&&e.firstChild;)e=e.firstChild;return e}function Id(e,t){var a=Kd(e);e=0;for(var i;a;){if(a.nodeType===3){if(i=e+a.textContent.length,e<=t&&i>=t)return{node:a,offset:t-e};e=i}e:{for(;a;){if(a.nextSibling){a=a.nextSibling;break e}a=a.parentNode}a=void 0}a=Kd(a)}}function Jd(e,t){return e&&t?e===t?!0:e&&e.nodeType===3?!1:t&&t.nodeType===3?Jd(e,t.parentNode):"contains"in e?e.contains(t):e.compareDocumentPosition?!!(e.compareDocumentPosition(t)&16):!1:!1}function Wd(e){e=e!=null&&e.ownerDocument!=null&&e.ownerDocument.defaultView!=null?e.ownerDocument.defaultView:window;for(var t=yl(e.document);t instanceof e.HTMLIFrameElement;){try{var a=typeof t.contentWindow.location.href=="string"}catch{a=!1}if(a)e=t.contentWindow;else break;t=yl(e.document)}return t}function bs(e){var t=e&&e.nodeName&&e.nodeName.toLowerCase();return t&&(t==="input"&&(e.type==="text"||e.type==="search"||e.type==="tel"||e.type==="url"||e.type==="password")||t==="textarea"||e.contentEditable==="true")}var bb=Cn&&"documentMode"in document&&11>=document.documentMode,wl=null,xs=null,Ci=null,_s=!1;function Fd(e,t,a){var i=a.window===a?a.document:a.nodeType===9?a:a.ownerDocument;_s||wl==null||wl!==yl(i)||(i=wl,"selectionStart"in i&&bs(i)?i={start:i.selectionStart,end:i.selectionEnd}:(i=(i.ownerDocument&&i.ownerDocument.defaultView||window).getSelection(),i={anchorNode:i.anchorNode,anchorOffset:i.anchorOffset,focusNode:i.focusNode,focusOffset:i.focusOffset}),Ci&&zi(Ci,i)||(Ci=i,i=Zr(xs,"onSelect"),0<i.length&&(t=new ar("onSelect","select",null,t,a),e.push({event:t,listeners:i}),t.target=wl)))}function Ha(e,t){var a={};return a[e.toLowerCase()]=t.toLowerCase(),a["Webkit"+e]="webkit"+t,a["Moz"+e]="moz"+t,a}var Sl={animationend:Ha("Animation","AnimationEnd"),animationiteration:Ha("Animation","AnimationIteration"),animationstart:Ha("Animation","AnimationStart"),transitionrun:Ha("Transition","TransitionRun"),transitionstart:Ha("Transition","TransitionStart"),transitioncancel:Ha("Transition","TransitionCancel"),transitionend:Ha("Transition","TransitionEnd")},ws={},Pd={};Cn&&(Pd=document.createElement("div").style,"AnimationEvent"in window||(delete Sl.animationend.animation,delete Sl.animationiteration.animation,delete Sl.animationstart.animation),"TransitionEvent"in window||delete Sl.transitionend.transition);function Ba(e){if(ws[e])return ws[e];if(!Sl[e])return e;var t=Sl[e],a;for(a in t)if(t.hasOwnProperty(a)&&a in Pd)return ws[e]=t[a];return e}var eh=Ba("animationend"),th=Ba("animationiteration"),nh=Ba("animationstart"),xb=Ba("transitionrun"),_b=Ba("transitionstart"),wb=Ba("transitioncancel"),ah=Ba("transitionend"),lh=new Map,Ss="abort auxClick beforeToggle cancel canPlay canPlayThrough click close contextMenu copy cut drag dragEnd dragEnter dragExit dragLeave dragOver dragStart drop durationChange emptied encrypted ended error gotPointerCapture input invalid keyDown keyPress keyUp load loadedData loadedMetadata loadStart lostPointerCapture mouseDown mouseMove mouseOut mouseOver mouseUp paste pause play playing pointerCancel pointerDown pointerMove pointerOut pointerOver pointerUp progress rateChange reset resize seeked seeking stalled submit suspend timeUpdate touchCancel touchEnd touchStart volumeChange scroll toggle touchMove waiting wheel".split(" ");Ss.push("scrollEnd");function nn(e,t){lh.set(e,t),Mn(t,[e])}var or=typeof reportError=="function"?reportError:function(e){if(typeof window=="object"&&typeof window.ErrorEvent=="function"){var t=new window.ErrorEvent("error",{bubbles:!0,cancelable:!0,message:typeof e=="object"&&e!==null&&typeof e.message=="string"?String(e.message):String(e),error:e});if(!window.dispatchEvent(t))return}else if(typeof process=="object"&&typeof process.emit=="function"){process.emit("uncaughtException",e);return}console.error(e)},Zt=[],El=0,Es=0;function rr(){for(var e=El,t=Es=El=0;t<e;){var a=Zt[t];Zt[t++]=null;var i=Zt[t];Zt[t++]=null;var s=Zt[t];Zt[t++]=null;var c=Zt[t];if(Zt[t++]=null,i!==null&&s!==null){var y=i.pending;y===null?s.next=s:(s.next=y.next,y.next=s),i.pending=s}c!==0&&ih(a,s,c)}}function ur(e,t,a,i){Zt[El++]=e,Zt[El++]=t,Zt[El++]=a,Zt[El++]=i,Es|=i,e.lanes|=i,e=e.alternate,e!==null&&(e.lanes|=i)}function Ns(e,t,a,i){return ur(e,t,a,i),sr(e)}function La(e,t){return ur(e,null,null,t),sr(e)}function ih(e,t,a){e.lanes|=a;var i=e.alternate;i!==null&&(i.lanes|=a);for(var s=!1,c=e.return;c!==null;)c.childLanes|=a,i=c.alternate,i!==null&&(i.childLanes|=a),c.tag===22&&(e=c.stateNode,e===null||e._visibility&1||(s=!0)),e=c,c=c.return;return e.tag===3?(c=e.stateNode,s&&t!==null&&(s=31-xt(a),e=c.hiddenUpdates,i=e[s],i===null?e[s]=[t]:i.push(t),t.lane=a|536870912),c):null}function sr(e){if(50<Fi)throw Fi=0,jc=null,Error(r(185));for(var t=e.return;t!==null;)e=t,t=e.return;return e.tag===3?e.stateNode:null}var Nl={};function Sb(e,t,a,i){this.tag=e,this.key=a,this.sibling=this.child=this.return=this.stateNode=this.type=this.elementType=null,this.index=0,this.refCleanup=this.ref=null,this.pendingProps=t,this.dependencies=this.memoizedState=this.updateQueue=this.memoizedProps=null,this.mode=i,this.subtreeFlags=this.flags=0,this.deletions=null,this.childLanes=this.lanes=0,this.alternate=null}function Ot(e,t,a,i){return new Sb(e,t,a,i)}function Ts(e){return e=e.prototype,!(!e||!e.isReactComponent)}function Dn(e,t){var a=e.alternate;return a===null?(a=Ot(e.tag,t,e.key,e.mode),a.elementType=e.elementType,a.type=e.type,a.stateNode=e.stateNode,a.alternate=e,e.alternate=a):(a.pendingProps=t,a.type=e.type,a.flags=0,a.subtreeFlags=0,a.deletions=null),a.flags=e.flags&65011712,a.childLanes=e.childLanes,a.lanes=e.lanes,a.child=e.child,a.memoizedProps=e.memoizedProps,a.memoizedState=e.memoizedState,a.updateQueue=e.updateQueue,t=e.dependencies,a.dependencies=t===null?null:{lanes:t.lanes,firstContext:t.firstContext},a.sibling=e.sibling,a.index=e.index,a.ref=e.ref,a.refCleanup=e.refCleanup,a}function oh(e,t){e.flags&=65011714;var a=e.alternate;return a===null?(e.childLanes=0,e.lanes=t,e.child=null,e.subtreeFlags=0,e.memoizedProps=null,e.memoizedState=null,e.updateQueue=null,e.dependencies=null,e.stateNode=null):(e.childLanes=a.childLanes,e.lanes=a.lanes,e.child=a.child,e.subtreeFlags=0,e.deletions=null,e.memoizedProps=a.memoizedProps,e.memoizedState=a.memoizedState,e.updateQueue=a.updateQueue,e.type=a.type,t=a.dependencies,e.dependencies=t===null?null:{lanes:t.lanes,firstContext:t.firstContext}),e}function cr(e,t,a,i,s,c){var y=0;if(i=e,typeof e=="function")Ts(e)&&(y=1);else if(typeof e=="string")y=Mx(e,a,le.current)?26:e==="html"||e==="head"||e==="body"?27:5;else e:switch(e){case Z:return e=Ot(31,a,t,s),e.elementType=Z,e.lanes=c,e;case T:return Ua(a.children,s,c,t);case z:y=8,s|=24;break;case A:return e=Ot(12,a,t,s|2),e.elementType=A,e.lanes=c,e;case H:return e=Ot(13,a,t,s),e.elementType=H,e.lanes=c,e;case j:return e=Ot(19,a,t,s),e.elementType=j,e.lanes=c,e;default:if(typeof e=="object"&&e!==null)switch(e.$$typeof){case S:y=10;break e;case R:y=9;break e;case D:y=11;break e;case k:y=14;break e;case q:y=16,i=null;break e}y=29,a=Error(r(130,e===null?"null":typeof e,"")),i=null}return t=Ot(y,a,t,s),t.elementType=e,t.type=i,t.lanes=c,t}function Ua(e,t,a,i){return e=Ot(7,e,i,t),e.lanes=a,e}function As(e,t,a){return e=Ot(6,e,null,t),e.lanes=a,e}function rh(e){var t=Ot(18,null,null,0);return t.stateNode=e,t}function Ms(e,t,a){return t=Ot(4,e.children!==null?e.children:[],e.key,t),t.lanes=a,t.stateNode={containerInfo:e.containerInfo,pendingChildren:null,implementation:e.implementation},t}var uh=new WeakMap;function Kt(e,t){if(typeof e=="object"&&e!==null){var a=uh.get(e);return a!==void 0?a:(t={value:e,source:t,stack:Ke(t)},uh.set(e,t),t)}return{value:e,source:t,stack:Ke(t)}}var Tl=[],Al=0,fr=null,Di=0,It=[],Jt=0,na=null,mn=1,yn="";function kn(e,t){Tl[Al++]=Di,Tl[Al++]=fr,fr=e,Di=t}function sh(e,t,a){It[Jt++]=mn,It[Jt++]=yn,It[Jt++]=na,na=e;var i=mn;e=yn;var s=32-xt(i)-1;i&=~(1<<s),a+=1;var c=32-xt(t)+s;if(30<c){var y=s-s%5;c=(i&(1<<y)-1).toString(32),i>>=y,s-=y,mn=1<<32-xt(t)+s|a<<s|i,yn=c+e}else mn=1<<c|a<<s|i,yn=e}function zs(e){e.return!==null&&(kn(e,1),sh(e,1,0))}function Cs(e){for(;e===fr;)fr=Tl[--Al],Tl[Al]=null,Di=Tl[--Al],Tl[Al]=null;for(;e===na;)na=It[--Jt],It[Jt]=null,yn=It[--Jt],It[Jt]=null,mn=It[--Jt],It[Jt]=null}function ch(e,t){It[Jt++]=mn,It[Jt++]=yn,It[Jt++]=na,mn=t.id,yn=t.overflow,na=e}var dt=null,Xe=null,Re=!1,aa=null,Wt=!1,Ds=Error(r(519));function la(e){var t=Error(r(418,1<arguments.length&&arguments[1]!==void 0&&arguments[1]?"text":"HTML",""));throw ki(Kt(t,e)),Ds}function fh(e){var t=e.stateNode,a=e.type,i=e.memoizedProps;switch(t[rt]=e,t[pt]=i,a){case"dialog":Ce("cancel",t),Ce("close",t);break;case"iframe":case"object":case"embed":Ce("load",t);break;case"video":case"audio":for(a=0;a<eo.length;a++)Ce(eo[a],t);break;case"source":Ce("error",t);break;case"img":case"image":case"link":Ce("error",t),Ce("load",t);break;case"details":Ce("toggle",t);break;case"input":Ce("invalid",t),pl(t,i.value,i.defaultValue,i.checked,i.defaultChecked,i.type,i.name,!0);break;case"select":Ce("invalid",t);break;case"textarea":Ce("invalid",t),Td(t,i.value,i.defaultValue,i.children)}a=i.children,typeof a!="string"&&typeof a!="number"&&typeof a!="bigint"||t.textContent===""+a||i.suppressHydrationWarning===!0||M0(t.textContent,a)?(i.popover!=null&&(Ce("beforetoggle",t),Ce("toggle",t)),i.onScroll!=null&&Ce("scroll",t),i.onScrollEnd!=null&&Ce("scrollend",t),i.onClick!=null&&(t.onclick=zn),t=!0):t=!1,t||la(e,!0)}function dh(e){for(dt=e.return;dt;)switch(dt.tag){case 5:case 31:case 13:Wt=!1;return;case 27:case 3:Wt=!0;return;default:dt=dt.return}}function Ml(e){if(e!==dt)return!1;if(!Re)return dh(e),Re=!0,!1;var t=e.tag,a;if((a=t!==3&&t!==27)&&((a=t===5)&&(a=e.type,a=!(a!=="form"&&a!=="button")||Ic(e.type,e.memoizedProps)),a=!a),a&&Xe&&la(e),dh(e),t===13){if(e=e.memoizedState,e=e!==null?e.dehydrated:null,!e)throw Error(r(317));Xe=B0(e)}else if(t===31){if(e=e.memoizedState,e=e!==null?e.dehydrated:null,!e)throw Error(r(317));Xe=B0(e)}else t===27?(t=Xe,va(e.type)?(e=ef,ef=null,Xe=e):Xe=t):Xe=dt?Pt(e.stateNode.nextSibling):null;return!0}function Ga(){Xe=dt=null,Re=!1}function ks(){var e=aa;return e!==null&&(zt===null?zt=e:zt.push.apply(zt,e),aa=null),e}function ki(e){aa===null?aa=[e]:aa.push(e)}var Rs=E(null),qa=null,Rn=null;function ia(e,t,a){W(Rs,t._currentValue),t._currentValue=a}function jn(e){e._currentValue=Rs.current,O(Rs)}function js(e,t,a){for(;e!==null;){var i=e.alternate;if((e.childLanes&t)!==t?(e.childLanes|=t,i!==null&&(i.childLanes|=t)):i!==null&&(i.childLanes&t)!==t&&(i.childLanes|=t),e===a)break;e=e.return}}function Os(e,t,a,i){var s=e.child;for(s!==null&&(s.return=e);s!==null;){var c=s.dependencies;if(c!==null){var y=s.child;c=c.firstContext;e:for(;c!==null;){var w=c;c=s;for(var L=0;L<t.length;L++)if(w.context===t[L]){c.lanes|=a,w=c.alternate,w!==null&&(w.lanes|=a),js(c.return,a,e),i||(y=null);break e}c=w.next}}else if(s.tag===18){if(y=s.return,y===null)throw Error(r(341));y.lanes|=a,c=y.alternate,c!==null&&(c.lanes|=a),js(y,a,e),y=null}else y=s.child;if(y!==null)y.return=s;else for(y=s;y!==null;){if(y===e){y=null;break}if(s=y.sibling,s!==null){s.return=y.return,y=s;break}y=y.return}s=y}}function zl(e,t,a,i){e=null;for(var s=t,c=!1;s!==null;){if(!c){if((s.flags&524288)!==0)c=!0;else if((s.flags&262144)!==0)break}if(s.tag===10){var y=s.alternate;if(y===null)throw Error(r(387));if(y=y.memoizedProps,y!==null){var w=s.type;jt(s.pendingProps.value,y.value)||(e!==null?e.push(w):e=[w])}}else if(s===ge.current){if(y=s.alternate,y===null)throw Error(r(387));y.memoizedState.memoizedState!==s.memoizedState.memoizedState&&(e!==null?e.push(io):e=[io])}s=s.return}e!==null&&Os(t,e,a,i),t.flags|=262144}function dr(e){for(e=e.firstContext;e!==null;){if(!jt(e.context._currentValue,e.memoizedValue))return!0;e=e.next}return!1}function Ya(e){qa=e,Rn=null,e=e.dependencies,e!==null&&(e.firstContext=null)}function ht(e){return hh(qa,e)}function hr(e,t){return qa===null&&Ya(e),hh(e,t)}function hh(e,t){var a=t._currentValue;if(t={context:t,memoizedValue:a,next:null},Rn===null){if(e===null)throw Error(r(308));Rn=t,e.dependencies={lanes:0,firstContext:t},e.flags|=524288}else Rn=Rn.next=t;return a}var Eb=typeof AbortController<"u"?AbortController:function(){var e=[],t=this.signal={aborted:!1,addEventListener:function(a,i){e.push(i)}};this.abort=function(){t.aborted=!0,e.forEach(function(a){return a()})}},Nb=n.unstable_scheduleCallback,Tb=n.unstable_NormalPriority,nt={$$typeof:S,Consumer:null,Provider:null,_currentValue:null,_currentValue2:null,_threadCount:0};function Hs(){return{controller:new Eb,data:new Map,refCount:0}}function Ri(e){e.refCount--,e.refCount===0&&Nb(Tb,function(){e.controller.abort()})}var ji=null,Bs=0,Cl=0,Dl=null;function Ab(e,t){if(ji===null){var a=ji=[];Bs=0,Cl=Gc(),Dl={status:"pending",value:void 0,then:function(i){a.push(i)}}}return Bs++,t.then(gh,gh),t}function gh(){if(--Bs===0&&ji!==null){Dl!==null&&(Dl.status="fulfilled");var e=ji;ji=null,Cl=0,Dl=null;for(var t=0;t<e.length;t++)(0,e[t])()}}function Mb(e,t){var a=[],i={status:"pending",value:null,reason:null,then:function(s){a.push(s)}};return e.then(function(){i.status="fulfilled",i.value=t;for(var s=0;s<a.length;s++)(0,a[s])(t)},function(s){for(i.status="rejected",i.reason=s,s=0;s<a.length;s++)(0,a[s])(void 0)}),i}var mh=M.S;M.S=function(e,t){Fg=Fe(),typeof t=="object"&&t!==null&&typeof t.then=="function"&&Ab(e,t),mh!==null&&mh(e,t)};var Va=E(null);function Ls(){var e=Va.current;return e!==null?e:Ve.pooledCache}function gr(e,t){t===null?W(Va,Va.current):W(Va,t.pool)}function yh(){var e=Ls();return e===null?null:{parent:nt._currentValue,pool:e}}var kl=Error(r(460)),Us=Error(r(474)),mr=Error(r(542)),yr={then:function(){}};function ph(e){return e=e.status,e==="fulfilled"||e==="rejected"}function vh(e,t,a){switch(a=e[a],a===void 0?e.push(t):a!==t&&(t.then(zn,zn),t=a),t.status){case"fulfilled":return t.value;case"rejected":throw e=t.reason,xh(e),e;default:if(typeof t.status=="string")t.then(zn,zn);else{if(e=Ve,e!==null&&100<e.shellSuspendCounter)throw Error(r(482));e=t,e.status="pending",e.then(function(i){if(t.status==="pending"){var s=t;s.status="fulfilled",s.value=i}},function(i){if(t.status==="pending"){var s=t;s.status="rejected",s.reason=i}})}switch(t.status){case"fulfilled":return t.value;case"rejected":throw e=t.reason,xh(e),e}throw Qa=t,kl}}function Xa(e){try{var t=e._init;return t(e._payload)}catch(a){throw a!==null&&typeof a=="object"&&typeof a.then=="function"?(Qa=a,kl):a}}var Qa=null;function bh(){if(Qa===null)throw Error(r(459));var e=Qa;return Qa=null,e}function xh(e){if(e===kl||e===mr)throw Error(r(483))}var Rl=null,Oi=0;function pr(e){var t=Oi;return Oi+=1,Rl===null&&(Rl=[]),vh(Rl,e,t)}function Hi(e,t){t=t.props.ref,e.ref=t!==void 0?t:null}function vr(e,t){throw t.$$typeof===b?Error(r(525)):(e=Object.prototype.toString.call(t),Error(r(31,e==="[object Object]"?"object with keys {"+Object.keys(t).join(", ")+"}":e)))}function _h(e){function t(Q,G){if(e){var K=Q.deletions;K===null?(Q.deletions=[G],Q.flags|=16):K.push(G)}}function a(Q,G){if(!e)return null;for(;G!==null;)t(Q,G),G=G.sibling;return null}function i(Q){for(var G=new Map;Q!==null;)Q.key!==null?G.set(Q.key,Q):G.set(Q.index,Q),Q=Q.sibling;return G}function s(Q,G){return Q=Dn(Q,G),Q.index=0,Q.sibling=null,Q}function c(Q,G,K){return Q.index=K,e?(K=Q.alternate,K!==null?(K=K.index,K<G?(Q.flags|=67108866,G):K):(Q.flags|=67108866,G)):(Q.flags|=1048576,G)}function y(Q){return e&&Q.alternate===null&&(Q.flags|=67108866),Q}function w(Q,G,K,re){return G===null||G.tag!==6?(G=As(K,Q.mode,re),G.return=Q,G):(G=s(G,K),G.return=Q,G)}function L(Q,G,K,re){var _e=K.type;return _e===T?oe(Q,G,K.props.children,re,K.key):G!==null&&(G.elementType===_e||typeof _e=="object"&&_e!==null&&_e.$$typeof===q&&Xa(_e)===G.type)?(G=s(G,K.props),Hi(G,K),G.return=Q,G):(G=cr(K.type,K.key,K.props,null,Q.mode,re),Hi(G,K),G.return=Q,G)}function I(Q,G,K,re){return G===null||G.tag!==4||G.stateNode.containerInfo!==K.containerInfo||G.stateNode.implementation!==K.implementation?(G=Ms(K,Q.mode,re),G.return=Q,G):(G=s(G,K.children||[]),G.return=Q,G)}function oe(Q,G,K,re,_e){return G===null||G.tag!==7?(G=Ua(K,Q.mode,re,_e),G.return=Q,G):(G=s(G,K),G.return=Q,G)}function ue(Q,G,K){if(typeof G=="string"&&G!==""||typeof G=="number"||typeof G=="bigint")return G=As(""+G,Q.mode,K),G.return=Q,G;if(typeof G=="object"&&G!==null){switch(G.$$typeof){case x:return K=cr(G.type,G.key,G.props,null,Q.mode,K),Hi(K,G),K.return=Q,K;case _:return G=Ms(G,Q.mode,K),G.return=Q,G;case q:return G=Xa(G),ue(Q,G,K)}if(V(G)||ne(G))return G=Ua(G,Q.mode,K,null),G.return=Q,G;if(typeof G.then=="function")return ue(Q,pr(G),K);if(G.$$typeof===S)return ue(Q,hr(Q,G),K);vr(Q,G)}return null}function F(Q,G,K,re){var _e=G!==null?G.key:null;if(typeof K=="string"&&K!==""||typeof K=="number"||typeof K=="bigint")return _e!==null?null:w(Q,G,""+K,re);if(typeof K=="object"&&K!==null){switch(K.$$typeof){case x:return K.key===_e?L(Q,G,K,re):null;case _:return K.key===_e?I(Q,G,K,re):null;case q:return K=Xa(K),F(Q,G,K,re)}if(V(K)||ne(K))return _e!==null?null:oe(Q,G,K,re,null);if(typeof K.then=="function")return F(Q,G,pr(K),re);if(K.$$typeof===S)return F(Q,G,hr(Q,K),re);vr(Q,K)}return null}function te(Q,G,K,re,_e){if(typeof re=="string"&&re!==""||typeof re=="number"||typeof re=="bigint")return Q=Q.get(K)||null,w(G,Q,""+re,_e);if(typeof re=="object"&&re!==null){switch(re.$$typeof){case x:return Q=Q.get(re.key===null?K:re.key)||null,L(G,Q,re,_e);case _:return Q=Q.get(re.key===null?K:re.key)||null,I(G,Q,re,_e);case q:return re=Xa(re),te(Q,G,K,re,_e)}if(V(re)||ne(re))return Q=Q.get(K)||null,oe(G,Q,re,_e,null);if(typeof re.then=="function")return te(Q,G,K,pr(re),_e);if(re.$$typeof===S)return te(Q,G,K,hr(G,re),_e);vr(G,re)}return null}function ve(Q,G,K,re){for(var _e=null,Oe=null,be=G,Me=G=0,ke=null;be!==null&&Me<K.length;Me++){be.index>Me?(ke=be,be=null):ke=be.sibling;var He=F(Q,be,K[Me],re);if(He===null){be===null&&(be=ke);break}e&&be&&He.alternate===null&&t(Q,be),G=c(He,G,Me),Oe===null?_e=He:Oe.sibling=He,Oe=He,be=ke}if(Me===K.length)return a(Q,be),Re&&kn(Q,Me),_e;if(be===null){for(;Me<K.length;Me++)be=ue(Q,K[Me],re),be!==null&&(G=c(be,G,Me),Oe===null?_e=be:Oe.sibling=be,Oe=be);return Re&&kn(Q,Me),_e}for(be=i(be);Me<K.length;Me++)ke=te(be,Q,Me,K[Me],re),ke!==null&&(e&&ke.alternate!==null&&be.delete(ke.key===null?Me:ke.key),G=c(ke,G,Me),Oe===null?_e=ke:Oe.sibling=ke,Oe=ke);return e&&be.forEach(function(Sa){return t(Q,Sa)}),Re&&kn(Q,Me),_e}function Se(Q,G,K,re){if(K==null)throw Error(r(151));for(var _e=null,Oe=null,be=G,Me=G=0,ke=null,He=K.next();be!==null&&!He.done;Me++,He=K.next()){be.index>Me?(ke=be,be=null):ke=be.sibling;var Sa=F(Q,be,He.value,re);if(Sa===null){be===null&&(be=ke);break}e&&be&&Sa.alternate===null&&t(Q,be),G=c(Sa,G,Me),Oe===null?_e=Sa:Oe.sibling=Sa,Oe=Sa,be=ke}if(He.done)return a(Q,be),Re&&kn(Q,Me),_e;if(be===null){for(;!He.done;Me++,He=K.next())He=ue(Q,He.value,re),He!==null&&(G=c(He,G,Me),Oe===null?_e=He:Oe.sibling=He,Oe=He);return Re&&kn(Q,Me),_e}for(be=i(be);!He.done;Me++,He=K.next())He=te(be,Q,Me,He.value,re),He!==null&&(e&&He.alternate!==null&&be.delete(He.key===null?Me:He.key),G=c(He,G,Me),Oe===null?_e=He:Oe.sibling=He,Oe=He);return e&&be.forEach(function(Ux){return t(Q,Ux)}),Re&&kn(Q,Me),_e}function Ye(Q,G,K,re){if(typeof K=="object"&&K!==null&&K.type===T&&K.key===null&&(K=K.props.children),typeof K=="object"&&K!==null){switch(K.$$typeof){case x:e:{for(var _e=K.key;G!==null;){if(G.key===_e){if(_e=K.type,_e===T){if(G.tag===7){a(Q,G.sibling),re=s(G,K.props.children),re.return=Q,Q=re;break e}}else if(G.elementType===_e||typeof _e=="object"&&_e!==null&&_e.$$typeof===q&&Xa(_e)===G.type){a(Q,G.sibling),re=s(G,K.props),Hi(re,K),re.return=Q,Q=re;break e}a(Q,G);break}else t(Q,G);G=G.sibling}K.type===T?(re=Ua(K.props.children,Q.mode,re,K.key),re.return=Q,Q=re):(re=cr(K.type,K.key,K.props,null,Q.mode,re),Hi(re,K),re.return=Q,Q=re)}return y(Q);case _:e:{for(_e=K.key;G!==null;){if(G.key===_e)if(G.tag===4&&G.stateNode.containerInfo===K.containerInfo&&G.stateNode.implementation===K.implementation){a(Q,G.sibling),re=s(G,K.children||[]),re.return=Q,Q=re;break e}else{a(Q,G);break}else t(Q,G);G=G.sibling}re=Ms(K,Q.mode,re),re.return=Q,Q=re}return y(Q);case q:return K=Xa(K),Ye(Q,G,K,re)}if(V(K))return ve(Q,G,K,re);if(ne(K)){if(_e=ne(K),typeof _e!="function")throw Error(r(150));return K=_e.call(K),Se(Q,G,K,re)}if(typeof K.then=="function")return Ye(Q,G,pr(K),re);if(K.$$typeof===S)return Ye(Q,G,hr(Q,K),re);vr(Q,K)}return typeof K=="string"&&K!==""||typeof K=="number"||typeof K=="bigint"?(K=""+K,G!==null&&G.tag===6?(a(Q,G.sibling),re=s(G,K),re.return=Q,Q=re):(a(Q,G),re=As(K,Q.mode,re),re.return=Q,Q=re),y(Q)):a(Q,G)}return function(Q,G,K,re){try{Oi=0;var _e=Ye(Q,G,K,re);return Rl=null,_e}catch(be){if(be===kl||be===mr)throw be;var Oe=Ot(29,be,null,Q.mode);return Oe.lanes=re,Oe.return=Q,Oe}finally{}}}var $a=_h(!0),wh=_h(!1),oa=!1;function Gs(e){e.updateQueue={baseState:e.memoizedState,firstBaseUpdate:null,lastBaseUpdate:null,shared:{pending:null,lanes:0,hiddenCallbacks:null},callbacks:null}}function qs(e,t){e=e.updateQueue,t.updateQueue===e&&(t.updateQueue={baseState:e.baseState,firstBaseUpdate:e.firstBaseUpdate,lastBaseUpdate:e.lastBaseUpdate,shared:e.shared,callbacks:null})}function ra(e){return{lane:e,tag:0,payload:null,callback:null,next:null}}function ua(e,t,a){var i=e.updateQueue;if(i===null)return null;if(i=i.shared,(Be&2)!==0){var s=i.pending;return s===null?t.next=t:(t.next=s.next,s.next=t),i.pending=t,t=sr(e),ih(e,null,a),t}return ur(e,i,t,a),sr(e)}function Bi(e,t,a){if(t=t.updateQueue,t!==null&&(t=t.shared,(a&4194048)!==0)){var i=t.lanes;i&=e.pendingLanes,a|=i,t.lanes=a,Yo(e,a)}}function Ys(e,t){var a=e.updateQueue,i=e.alternate;if(i!==null&&(i=i.updateQueue,a===i)){var s=null,c=null;if(a=a.firstBaseUpdate,a!==null){do{var y={lane:a.lane,tag:a.tag,payload:a.payload,callback:null,next:null};c===null?s=c=y:c=c.next=y,a=a.next}while(a!==null);c===null?s=c=t:c=c.next=t}else s=c=t;a={baseState:i.baseState,firstBaseUpdate:s,lastBaseUpdate:c,shared:i.shared,callbacks:i.callbacks},e.updateQueue=a;return}e=a.lastBaseUpdate,e===null?a.firstBaseUpdate=t:e.next=t,a.lastBaseUpdate=t}var Vs=!1;function Li(){if(Vs){var e=Dl;if(e!==null)throw e}}function Ui(e,t,a,i){Vs=!1;var s=e.updateQueue;oa=!1;var c=s.firstBaseUpdate,y=s.lastBaseUpdate,w=s.shared.pending;if(w!==null){s.shared.pending=null;var L=w,I=L.next;L.next=null,y===null?c=I:y.next=I,y=L;var oe=e.alternate;oe!==null&&(oe=oe.updateQueue,w=oe.lastBaseUpdate,w!==y&&(w===null?oe.firstBaseUpdate=I:w.next=I,oe.lastBaseUpdate=L))}if(c!==null){var ue=s.baseState;y=0,oe=I=L=null,w=c;do{var F=w.lane&-536870913,te=F!==w.lane;if(te?(De&F)===F:(i&F)===F){F!==0&&F===Cl&&(Vs=!0),oe!==null&&(oe=oe.next={lane:0,tag:w.tag,payload:w.payload,callback:null,next:null});e:{var ve=e,Se=w;F=t;var Ye=a;switch(Se.tag){case 1:if(ve=Se.payload,typeof ve=="function"){ue=ve.call(Ye,ue,F);break e}ue=ve;break e;case 3:ve.flags=ve.flags&-65537|128;case 0:if(ve=Se.payload,F=typeof ve=="function"?ve.call(Ye,ue,F):ve,F==null)break e;ue=p({},ue,F);break e;case 2:oa=!0}}F=w.callback,F!==null&&(e.flags|=64,te&&(e.flags|=8192),te=s.callbacks,te===null?s.callbacks=[F]:te.push(F))}else te={lane:F,tag:w.tag,payload:w.payload,callback:w.callback,next:null},oe===null?(I=oe=te,L=ue):oe=oe.next=te,y|=F;if(w=w.next,w===null){if(w=s.shared.pending,w===null)break;te=w,w=te.next,te.next=null,s.lastBaseUpdate=te,s.shared.pending=null}}while(!0);oe===null&&(L=ue),s.baseState=L,s.firstBaseUpdate=I,s.lastBaseUpdate=oe,c===null&&(s.shared.lanes=0),ha|=y,e.lanes=y,e.memoizedState=ue}}function Sh(e,t){if(typeof e!="function")throw Error(r(191,e));e.call(t)}function Eh(e,t){var a=e.callbacks;if(a!==null)for(e.callbacks=null,e=0;e<a.length;e++)Sh(a[e],t)}var jl=E(null),br=E(0);function Nh(e,t){e=Vn,W(br,e),W(jl,t),Vn=e|t.baseLanes}function Xs(){W(br,Vn),W(jl,jl.current)}function Qs(){Vn=br.current,O(jl),O(br)}var Ht=E(null),Ft=null;function sa(e){var t=e.alternate;W(Pe,Pe.current&1),W(Ht,e),Ft===null&&(t===null||jl.current!==null||t.memoizedState!==null)&&(Ft=e)}function $s(e){W(Pe,Pe.current),W(Ht,e),Ft===null&&(Ft=e)}function Th(e){e.tag===22?(W(Pe,Pe.current),W(Ht,e),Ft===null&&(Ft=e)):ca()}function ca(){W(Pe,Pe.current),W(Ht,Ht.current)}function Bt(e){O(Ht),Ft===e&&(Ft=null),O(Pe)}var Pe=E(0);function xr(e){for(var t=e;t!==null;){if(t.tag===13){var a=t.memoizedState;if(a!==null&&(a=a.dehydrated,a===null||Fc(a)||Pc(a)))return t}else if(t.tag===19&&(t.memoizedProps.revealOrder==="forwards"||t.memoizedProps.revealOrder==="backwards"||t.memoizedProps.revealOrder==="unstable_legacy-backwards"||t.memoizedProps.revealOrder==="together")){if((t.flags&128)!==0)return t}else if(t.child!==null){t.child.return=t,t=t.child;continue}if(t===e)break;for(;t.sibling===null;){if(t.return===null||t.return===e)return null;t=t.return}t.sibling.return=t.return,t=t.sibling}return null}var On=0,Te=null,Ge=null,at=null,_r=!1,Ol=!1,Za=!1,wr=0,Gi=0,Hl=null,zb=0;function Je(){throw Error(r(321))}function Zs(e,t){if(t===null)return!1;for(var a=0;a<t.length&&a<e.length;a++)if(!jt(e[a],t[a]))return!1;return!0}function Ks(e,t,a,i,s,c){return On=c,Te=t,t.memoizedState=null,t.updateQueue=null,t.lanes=0,M.H=e===null||e.memoizedState===null?sg:sc,Za=!1,c=a(i,s),Za=!1,Ol&&(c=Mh(t,a,i,s)),Ah(e),c}function Ah(e){M.H=Vi;var t=Ge!==null&&Ge.next!==null;if(On=0,at=Ge=Te=null,_r=!1,Gi=0,Hl=null,t)throw Error(r(300));e===null||lt||(e=e.dependencies,e!==null&&dr(e)&&(lt=!0))}function Mh(e,t,a,i){Te=e;var s=0;do{if(Ol&&(Hl=null),Gi=0,Ol=!1,25<=s)throw Error(r(301));if(s+=1,at=Ge=null,e.updateQueue!=null){var c=e.updateQueue;c.lastEffect=null,c.events=null,c.stores=null,c.memoCache!=null&&(c.memoCache.index=0)}M.H=cg,c=t(a,i)}while(Ol);return c}function Cb(){var e=M.H,t=e.useState()[0];return t=typeof t.then=="function"?qi(t):t,e=e.useState()[0],(Ge!==null?Ge.memoizedState:null)!==e&&(Te.flags|=1024),t}function Is(){var e=wr!==0;return wr=0,e}function Js(e,t,a){t.updateQueue=e.updateQueue,t.flags&=-2053,e.lanes&=~a}function Ws(e){if(_r){for(e=e.memoizedState;e!==null;){var t=e.queue;t!==null&&(t.pending=null),e=e.next}_r=!1}On=0,at=Ge=Te=null,Ol=!1,Gi=wr=0,Hl=null}function _t(){var e={memoizedState:null,baseState:null,baseQueue:null,queue:null,next:null};return at===null?Te.memoizedState=at=e:at=at.next=e,at}function et(){if(Ge===null){var e=Te.alternate;e=e!==null?e.memoizedState:null}else e=Ge.next;var t=at===null?Te.memoizedState:at.next;if(t!==null)at=t,Ge=e;else{if(e===null)throw Te.alternate===null?Error(r(467)):Error(r(310));Ge=e,e={memoizedState:Ge.memoizedState,baseState:Ge.baseState,baseQueue:Ge.baseQueue,queue:Ge.queue,next:null},at===null?Te.memoizedState=at=e:at=at.next=e}return at}function Sr(){return{lastEffect:null,events:null,stores:null,memoCache:null}}function qi(e){var t=Gi;return Gi+=1,Hl===null&&(Hl=[]),e=vh(Hl,e,t),t=Te,(at===null?t.memoizedState:at.next)===null&&(t=t.alternate,M.H=t===null||t.memoizedState===null?sg:sc),e}function Er(e){if(e!==null&&typeof e=="object"){if(typeof e.then=="function")return qi(e);if(e.$$typeof===S)return ht(e)}throw Error(r(438,String(e)))}function Fs(e){var t=null,a=Te.updateQueue;if(a!==null&&(t=a.memoCache),t==null){var i=Te.alternate;i!==null&&(i=i.updateQueue,i!==null&&(i=i.memoCache,i!=null&&(t={data:i.data.map(function(s){return s.slice()}),index:0})))}if(t==null&&(t={data:[],index:0}),a===null&&(a=Sr(),Te.updateQueue=a),a.memoCache=t,a=t.data[t.index],a===void 0)for(a=t.data[t.index]=Array(e),i=0;i<e;i++)a[i]=ie;return t.index++,a}function Hn(e,t){return typeof t=="function"?t(e):t}function Nr(e){var t=et();return Ps(t,Ge,e)}function Ps(e,t,a){var i=e.queue;if(i===null)throw Error(r(311));i.lastRenderedReducer=a;var s=e.baseQueue,c=i.pending;if(c!==null){if(s!==null){var y=s.next;s.next=c.next,c.next=y}t.baseQueue=s=c,i.pending=null}if(c=e.baseState,s===null)e.memoizedState=c;else{t=s.next;var w=y=null,L=null,I=t,oe=!1;do{var ue=I.lane&-536870913;if(ue!==I.lane?(De&ue)===ue:(On&ue)===ue){var F=I.revertLane;if(F===0)L!==null&&(L=L.next={lane:0,revertLane:0,gesture:null,action:I.action,hasEagerState:I.hasEagerState,eagerState:I.eagerState,next:null}),ue===Cl&&(oe=!0);else if((On&F)===F){I=I.next,F===Cl&&(oe=!0);continue}else ue={lane:0,revertLane:I.revertLane,gesture:null,action:I.action,hasEagerState:I.hasEagerState,eagerState:I.eagerState,next:null},L===null?(w=L=ue,y=c):L=L.next=ue,Te.lanes|=F,ha|=F;ue=I.action,Za&&a(c,ue),c=I.hasEagerState?I.eagerState:a(c,ue)}else F={lane:ue,revertLane:I.revertLane,gesture:I.gesture,action:I.action,hasEagerState:I.hasEagerState,eagerState:I.eagerState,next:null},L===null?(w=L=F,y=c):L=L.next=F,Te.lanes|=ue,ha|=ue;I=I.next}while(I!==null&&I!==t);if(L===null?y=c:L.next=w,!jt(c,e.memoizedState)&&(lt=!0,oe&&(a=Dl,a!==null)))throw a;e.memoizedState=c,e.baseState=y,e.baseQueue=L,i.lastRenderedState=c}return s===null&&(i.lanes=0),[e.memoizedState,i.dispatch]}function ec(e){var t=et(),a=t.queue;if(a===null)throw Error(r(311));a.lastRenderedReducer=e;var i=a.dispatch,s=a.pending,c=t.memoizedState;if(s!==null){a.pending=null;var y=s=s.next;do c=e(c,y.action),y=y.next;while(y!==s);jt(c,t.memoizedState)||(lt=!0),t.memoizedState=c,t.baseQueue===null&&(t.baseState=c),a.lastRenderedState=c}return[c,i]}function zh(e,t,a){var i=Te,s=et(),c=Re;if(c){if(a===void 0)throw Error(r(407));a=a()}else a=t();var y=!jt((Ge||s).memoizedState,a);if(y&&(s.memoizedState=a,lt=!0),s=s.queue,ac(kh.bind(null,i,s,e),[e]),s.getSnapshot!==t||y||at!==null&&at.memoizedState.tag&1){if(i.flags|=2048,Bl(9,{destroy:void 0},Dh.bind(null,i,s,a,t),null),Ve===null)throw Error(r(349));c||(On&127)!==0||Ch(i,t,a)}return a}function Ch(e,t,a){e.flags|=16384,e={getSnapshot:t,value:a},t=Te.updateQueue,t===null?(t=Sr(),Te.updateQueue=t,t.stores=[e]):(a=t.stores,a===null?t.stores=[e]:a.push(e))}function Dh(e,t,a,i){t.value=a,t.getSnapshot=i,Rh(t)&&jh(e)}function kh(e,t,a){return a(function(){Rh(t)&&jh(e)})}function Rh(e){var t=e.getSnapshot;e=e.value;try{var a=t();return!jt(e,a)}catch{return!0}}function jh(e){var t=La(e,2);t!==null&&Ct(t,e,2)}function tc(e){var t=_t();if(typeof e=="function"){var a=e;if(e=a(),Za){hn(!0);try{a()}finally{hn(!1)}}}return t.memoizedState=t.baseState=e,t.queue={pending:null,lanes:0,dispatch:null,lastRenderedReducer:Hn,lastRenderedState:e},t}function Oh(e,t,a,i){return e.baseState=a,Ps(e,Ge,typeof i=="function"?i:Hn)}function Db(e,t,a,i,s){if(Mr(e))throw Error(r(485));if(e=t.action,e!==null){var c={payload:s,action:e,next:null,isTransition:!0,status:"pending",value:null,reason:null,listeners:[],then:function(y){c.listeners.push(y)}};M.T!==null?a(!0):c.isTransition=!1,i(c),a=t.pending,a===null?(c.next=t.pending=c,Hh(t,c)):(c.next=a.next,t.pending=a.next=c)}}function Hh(e,t){var a=t.action,i=t.payload,s=e.state;if(t.isTransition){var c=M.T,y={};M.T=y;try{var w=a(s,i),L=M.S;L!==null&&L(y,w),Bh(e,t,w)}catch(I){nc(e,t,I)}finally{c!==null&&y.types!==null&&(c.types=y.types),M.T=c}}else try{c=a(s,i),Bh(e,t,c)}catch(I){nc(e,t,I)}}function Bh(e,t,a){a!==null&&typeof a=="object"&&typeof a.then=="function"?a.then(function(i){Lh(e,t,i)},function(i){return nc(e,t,i)}):Lh(e,t,a)}function Lh(e,t,a){t.status="fulfilled",t.value=a,Uh(t),e.state=a,t=e.pending,t!==null&&(a=t.next,a===t?e.pending=null:(a=a.next,t.next=a,Hh(e,a)))}function nc(e,t,a){var i=e.pending;if(e.pending=null,i!==null){i=i.next;do t.status="rejected",t.reason=a,Uh(t),t=t.next;while(t!==i)}e.action=null}function Uh(e){e=e.listeners;for(var t=0;t<e.length;t++)(0,e[t])()}function Gh(e,t){return t}function qh(e,t){if(Re){var a=Ve.formState;if(a!==null){e:{var i=Te;if(Re){if(Xe){t:{for(var s=Xe,c=Wt;s.nodeType!==8;){if(!c){s=null;break t}if(s=Pt(s.nextSibling),s===null){s=null;break t}}c=s.data,s=c==="F!"||c==="F"?s:null}if(s){Xe=Pt(s.nextSibling),i=s.data==="F!";break e}}la(i)}i=!1}i&&(t=a[0])}}return a=_t(),a.memoizedState=a.baseState=t,i={pending:null,lanes:0,dispatch:null,lastRenderedReducer:Gh,lastRenderedState:t},a.queue=i,a=og.bind(null,Te,i),i.dispatch=a,i=tc(!1),c=uc.bind(null,Te,!1,i.queue),i=_t(),s={state:t,dispatch:null,action:e,pending:null},i.queue=s,a=Db.bind(null,Te,s,c,a),s.dispatch=a,i.memoizedState=e,[t,a,!1]}function Yh(e){var t=et();return Vh(t,Ge,e)}function Vh(e,t,a){if(t=Ps(e,t,Gh)[0],e=Nr(Hn)[0],typeof t=="object"&&t!==null&&typeof t.then=="function")try{var i=qi(t)}catch(y){throw y===kl?mr:y}else i=t;t=et();var s=t.queue,c=s.dispatch;return a!==t.memoizedState&&(Te.flags|=2048,Bl(9,{destroy:void 0},kb.bind(null,s,a),null)),[i,c,e]}function kb(e,t){e.action=t}function Xh(e){var t=et(),a=Ge;if(a!==null)return Vh(t,a,e);et(),t=t.memoizedState,a=et();var i=a.queue.dispatch;return a.memoizedState=e,[t,i,!1]}function Bl(e,t,a,i){return e={tag:e,create:a,deps:i,inst:t,next:null},t=Te.updateQueue,t===null&&(t=Sr(),Te.updateQueue=t),a=t.lastEffect,a===null?t.lastEffect=e.next=e:(i=a.next,a.next=e,e.next=i,t.lastEffect=e),e}function Qh(){return et().memoizedState}function Tr(e,t,a,i){var s=_t();Te.flags|=e,s.memoizedState=Bl(1|t,{destroy:void 0},a,i===void 0?null:i)}function Ar(e,t,a,i){var s=et();i=i===void 0?null:i;var c=s.memoizedState.inst;Ge!==null&&i!==null&&Zs(i,Ge.memoizedState.deps)?s.memoizedState=Bl(t,c,a,i):(Te.flags|=e,s.memoizedState=Bl(1|t,c,a,i))}function $h(e,t){Tr(8390656,8,e,t)}function ac(e,t){Ar(2048,8,e,t)}function Rb(e){Te.flags|=4;var t=Te.updateQueue;if(t===null)t=Sr(),Te.updateQueue=t,t.events=[e];else{var a=t.events;a===null?t.events=[e]:a.push(e)}}function Zh(e){var t=et().memoizedState;return Rb({ref:t,nextImpl:e}),function(){if((Be&2)!==0)throw Error(r(440));return t.impl.apply(void 0,arguments)}}function Kh(e,t){return Ar(4,2,e,t)}function Ih(e,t){return Ar(4,4,e,t)}function Jh(e,t){if(typeof t=="function"){e=e();var a=t(e);return function(){typeof a=="function"?a():t(null)}}if(t!=null)return e=e(),t.current=e,function(){t.current=null}}function Wh(e,t,a){a=a!=null?a.concat([e]):null,Ar(4,4,Jh.bind(null,t,e),a)}function lc(){}function Fh(e,t){var a=et();t=t===void 0?null:t;var i=a.memoizedState;return t!==null&&Zs(t,i[1])?i[0]:(a.memoizedState=[e,t],e)}function Ph(e,t){var a=et();t=t===void 0?null:t;var i=a.memoizedState;if(t!==null&&Zs(t,i[1]))return i[0];if(i=e(),Za){hn(!0);try{e()}finally{hn(!1)}}return a.memoizedState=[i,t],i}function ic(e,t,a){return a===void 0||(On&1073741824)!==0&&(De&261930)===0?e.memoizedState=t:(e.memoizedState=a,e=e0(),Te.lanes|=e,ha|=e,a)}function eg(e,t,a,i){return jt(a,t)?a:jl.current!==null?(e=ic(e,a,i),jt(e,t)||(lt=!0),e):(On&42)===0||(On&1073741824)!==0&&(De&261930)===0?(lt=!0,e.memoizedState=a):(e=e0(),Te.lanes|=e,ha|=e,t)}function tg(e,t,a,i,s){var c=B.p;B.p=c!==0&&8>c?c:8;var y=M.T,w={};M.T=w,uc(e,!1,t,a);try{var L=s(),I=M.S;if(I!==null&&I(w,L),L!==null&&typeof L=="object"&&typeof L.then=="function"){var oe=Mb(L,i);Yi(e,t,oe,Gt(e))}else Yi(e,t,i,Gt(e))}catch(ue){Yi(e,t,{then:function(){},status:"rejected",reason:ue},Gt())}finally{B.p=c,y!==null&&w.types!==null&&(y.types=w.types),M.T=y}}function jb(){}function oc(e,t,a,i){if(e.tag!==5)throw Error(r(476));var s=ng(e).queue;tg(e,s,t,X,a===null?jb:function(){return ag(e),a(i)})}function ng(e){var t=e.memoizedState;if(t!==null)return t;t={memoizedState:X,baseState:X,baseQueue:null,queue:{pending:null,lanes:0,dispatch:null,lastRenderedReducer:Hn,lastRenderedState:X},next:null};var a={};return t.next={memoizedState:a,baseState:a,baseQueue:null,queue:{pending:null,lanes:0,dispatch:null,lastRenderedReducer:Hn,lastRenderedState:a},next:null},e.memoizedState=t,e=e.alternate,e!==null&&(e.memoizedState=t),t}function ag(e){var t=ng(e);t.next===null&&(t=e.alternate.memoizedState),Yi(e,t.next.queue,{},Gt())}function rc(){return ht(io)}function lg(){return et().memoizedState}function ig(){return et().memoizedState}function Ob(e){for(var t=e.return;t!==null;){switch(t.tag){case 24:case 3:var a=Gt();e=ra(a);var i=ua(t,e,a);i!==null&&(Ct(i,t,a),Bi(i,t,a)),t={cache:Hs()},e.payload=t;return}t=t.return}}function Hb(e,t,a){var i=Gt();a={lane:i,revertLane:0,gesture:null,action:a,hasEagerState:!1,eagerState:null,next:null},Mr(e)?rg(t,a):(a=Ns(e,t,a,i),a!==null&&(Ct(a,e,i),ug(a,t,i)))}function og(e,t,a){var i=Gt();Yi(e,t,a,i)}function Yi(e,t,a,i){var s={lane:i,revertLane:0,gesture:null,action:a,hasEagerState:!1,eagerState:null,next:null};if(Mr(e))rg(t,s);else{var c=e.alternate;if(e.lanes===0&&(c===null||c.lanes===0)&&(c=t.lastRenderedReducer,c!==null))try{var y=t.lastRenderedState,w=c(y,a);if(s.hasEagerState=!0,s.eagerState=w,jt(w,y))return ur(e,t,s,0),Ve===null&&rr(),!1}catch{}finally{}if(a=Ns(e,t,s,i),a!==null)return Ct(a,e,i),ug(a,t,i),!0}return!1}function uc(e,t,a,i){if(i={lane:2,revertLane:Gc(),gesture:null,action:i,hasEagerState:!1,eagerState:null,next:null},Mr(e)){if(t)throw Error(r(479))}else t=Ns(e,a,i,2),t!==null&&Ct(t,e,2)}function Mr(e){var t=e.alternate;return e===Te||t!==null&&t===Te}function rg(e,t){Ol=_r=!0;var a=e.pending;a===null?t.next=t:(t.next=a.next,a.next=t),e.pending=t}function ug(e,t,a){if((a&4194048)!==0){var i=t.lanes;i&=e.pendingLanes,a|=i,t.lanes=a,Yo(e,a)}}var Vi={readContext:ht,use:Er,useCallback:Je,useContext:Je,useEffect:Je,useImperativeHandle:Je,useLayoutEffect:Je,useInsertionEffect:Je,useMemo:Je,useReducer:Je,useRef:Je,useState:Je,useDebugValue:Je,useDeferredValue:Je,useTransition:Je,useSyncExternalStore:Je,useId:Je,useHostTransitionStatus:Je,useFormState:Je,useActionState:Je,useOptimistic:Je,useMemoCache:Je,useCacheRefresh:Je};Vi.useEffectEvent=Je;var sg={readContext:ht,use:Er,useCallback:function(e,t){return _t().memoizedState=[e,t===void 0?null:t],e},useContext:ht,useEffect:$h,useImperativeHandle:function(e,t,a){a=a!=null?a.concat([e]):null,Tr(4194308,4,Jh.bind(null,t,e),a)},useLayoutEffect:function(e,t){return Tr(4194308,4,e,t)},useInsertionEffect:function(e,t){Tr(4,2,e,t)},useMemo:function(e,t){var a=_t();t=t===void 0?null:t;var i=e();if(Za){hn(!0);try{e()}finally{hn(!1)}}return a.memoizedState=[i,t],i},useReducer:function(e,t,a){var i=_t();if(a!==void 0){var s=a(t);if(Za){hn(!0);try{a(t)}finally{hn(!1)}}}else s=t;return i.memoizedState=i.baseState=s,e={pending:null,lanes:0,dispatch:null,lastRenderedReducer:e,lastRenderedState:s},i.queue=e,e=e.dispatch=Hb.bind(null,Te,e),[i.memoizedState,e]},useRef:function(e){var t=_t();return e={current:e},t.memoizedState=e},useState:function(e){e=tc(e);var t=e.queue,a=og.bind(null,Te,t);return t.dispatch=a,[e.memoizedState,a]},useDebugValue:lc,useDeferredValue:function(e,t){var a=_t();return ic(a,e,t)},useTransition:function(){var e=tc(!1);return e=tg.bind(null,Te,e.queue,!0,!1),_t().memoizedState=e,[!1,e]},useSyncExternalStore:function(e,t,a){var i=Te,s=_t();if(Re){if(a===void 0)throw Error(r(407));a=a()}else{if(a=t(),Ve===null)throw Error(r(349));(De&127)!==0||Ch(i,t,a)}s.memoizedState=a;var c={value:a,getSnapshot:t};return s.queue=c,$h(kh.bind(null,i,c,e),[e]),i.flags|=2048,Bl(9,{destroy:void 0},Dh.bind(null,i,c,a,t),null),a},useId:function(){var e=_t(),t=Ve.identifierPrefix;if(Re){var a=yn,i=mn;a=(i&~(1<<32-xt(i)-1)).toString(32)+a,t="_"+t+"R_"+a,a=wr++,0<a&&(t+="H"+a.toString(32)),t+="_"}else a=zb++,t="_"+t+"r_"+a.toString(32)+"_";return e.memoizedState=t},useHostTransitionStatus:rc,useFormState:qh,useActionState:qh,useOptimistic:function(e){var t=_t();t.memoizedState=t.baseState=e;var a={pending:null,lanes:0,dispatch:null,lastRenderedReducer:null,lastRenderedState:null};return t.queue=a,t=uc.bind(null,Te,!0,a),a.dispatch=t,[e,t]},useMemoCache:Fs,useCacheRefresh:function(){return _t().memoizedState=Ob.bind(null,Te)},useEffectEvent:function(e){var t=_t(),a={impl:e};return t.memoizedState=a,function(){if((Be&2)!==0)throw Error(r(440));return a.impl.apply(void 0,arguments)}}},sc={readContext:ht,use:Er,useCallback:Fh,useContext:ht,useEffect:ac,useImperativeHandle:Wh,useInsertionEffect:Kh,useLayoutEffect:Ih,useMemo:Ph,useReducer:Nr,useRef:Qh,useState:function(){return Nr(Hn)},useDebugValue:lc,useDeferredValue:function(e,t){var a=et();return eg(a,Ge.memoizedState,e,t)},useTransition:function(){var e=Nr(Hn)[0],t=et().memoizedState;return[typeof e=="boolean"?e:qi(e),t]},useSyncExternalStore:zh,useId:lg,useHostTransitionStatus:rc,useFormState:Yh,useActionState:Yh,useOptimistic:function(e,t){var a=et();return Oh(a,Ge,e,t)},useMemoCache:Fs,useCacheRefresh:ig};sc.useEffectEvent=Zh;var cg={readContext:ht,use:Er,useCallback:Fh,useContext:ht,useEffect:ac,useImperativeHandle:Wh,useInsertionEffect:Kh,useLayoutEffect:Ih,useMemo:Ph,useReducer:ec,useRef:Qh,useState:function(){return ec(Hn)},useDebugValue:lc,useDeferredValue:function(e,t){var a=et();return Ge===null?ic(a,e,t):eg(a,Ge.memoizedState,e,t)},useTransition:function(){var e=ec(Hn)[0],t=et().memoizedState;return[typeof e=="boolean"?e:qi(e),t]},useSyncExternalStore:zh,useId:lg,useHostTransitionStatus:rc,useFormState:Xh,useActionState:Xh,useOptimistic:function(e,t){var a=et();return Ge!==null?Oh(a,Ge,e,t):(a.baseState=e,[e,a.queue.dispatch])},useMemoCache:Fs,useCacheRefresh:ig};cg.useEffectEvent=Zh;function cc(e,t,a,i){t=e.memoizedState,a=a(i,t),a=a==null?t:p({},t,a),e.memoizedState=a,e.lanes===0&&(e.updateQueue.baseState=a)}var fc={enqueueSetState:function(e,t,a){e=e._reactInternals;var i=Gt(),s=ra(i);s.payload=t,a!=null&&(s.callback=a),t=ua(e,s,i),t!==null&&(Ct(t,e,i),Bi(t,e,i))},enqueueReplaceState:function(e,t,a){e=e._reactInternals;var i=Gt(),s=ra(i);s.tag=1,s.payload=t,a!=null&&(s.callback=a),t=ua(e,s,i),t!==null&&(Ct(t,e,i),Bi(t,e,i))},enqueueForceUpdate:function(e,t){e=e._reactInternals;var a=Gt(),i=ra(a);i.tag=2,t!=null&&(i.callback=t),t=ua(e,i,a),t!==null&&(Ct(t,e,a),Bi(t,e,a))}};function fg(e,t,a,i,s,c,y){return e=e.stateNode,typeof e.shouldComponentUpdate=="function"?e.shouldComponentUpdate(i,c,y):t.prototype&&t.prototype.isPureReactComponent?!zi(a,i)||!zi(s,c):!0}function dg(e,t,a,i){e=t.state,typeof t.componentWillReceiveProps=="function"&&t.componentWillReceiveProps(a,i),typeof t.UNSAFE_componentWillReceiveProps=="function"&&t.UNSAFE_componentWillReceiveProps(a,i),t.state!==e&&fc.enqueueReplaceState(t,t.state,null)}function Ka(e,t){var a=t;if("ref"in t){a={};for(var i in t)i!=="ref"&&(a[i]=t[i])}if(e=e.defaultProps){a===t&&(a=p({},a));for(var s in e)a[s]===void 0&&(a[s]=e[s])}return a}function hg(e){or(e)}function gg(e){console.error(e)}function mg(e){or(e)}function zr(e,t){try{var a=e.onUncaughtError;a(t.value,{componentStack:t.stack})}catch(i){setTimeout(function(){throw i})}}function yg(e,t,a){try{var i=e.onCaughtError;i(a.value,{componentStack:a.stack,errorBoundary:t.tag===1?t.stateNode:null})}catch(s){setTimeout(function(){throw s})}}function dc(e,t,a){return a=ra(a),a.tag=3,a.payload={element:null},a.callback=function(){zr(e,t)},a}function pg(e){return e=ra(e),e.tag=3,e}function vg(e,t,a,i){var s=a.type.getDerivedStateFromError;if(typeof s=="function"){var c=i.value;e.payload=function(){return s(c)},e.callback=function(){yg(t,a,i)}}var y=a.stateNode;y!==null&&typeof y.componentDidCatch=="function"&&(e.callback=function(){yg(t,a,i),typeof s!="function"&&(ga===null?ga=new Set([this]):ga.add(this));var w=i.stack;this.componentDidCatch(i.value,{componentStack:w!==null?w:""})})}function Bb(e,t,a,i,s){if(a.flags|=32768,i!==null&&typeof i=="object"&&typeof i.then=="function"){if(t=a.alternate,t!==null&&zl(t,a,s,!0),a=Ht.current,a!==null){switch(a.tag){case 31:case 13:return Ft===null?qr():a.alternate===null&&We===0&&(We=3),a.flags&=-257,a.flags|=65536,a.lanes=s,i===yr?a.flags|=16384:(t=a.updateQueue,t===null?a.updateQueue=new Set([i]):t.add(i),Bc(e,i,s)),!1;case 22:return a.flags|=65536,i===yr?a.flags|=16384:(t=a.updateQueue,t===null?(t={transitions:null,markerInstances:null,retryQueue:new Set([i])},a.updateQueue=t):(a=t.retryQueue,a===null?t.retryQueue=new Set([i]):a.add(i)),Bc(e,i,s)),!1}throw Error(r(435,a.tag))}return Bc(e,i,s),qr(),!1}if(Re)return t=Ht.current,t!==null?((t.flags&65536)===0&&(t.flags|=256),t.flags|=65536,t.lanes=s,i!==Ds&&(e=Error(r(422),{cause:i}),ki(Kt(e,a)))):(i!==Ds&&(t=Error(r(423),{cause:i}),ki(Kt(t,a))),e=e.current.alternate,e.flags|=65536,s&=-s,e.lanes|=s,i=Kt(i,a),s=dc(e.stateNode,i,s),Ys(e,s),We!==4&&(We=2)),!1;var c=Error(r(520),{cause:i});if(c=Kt(c,a),Wi===null?Wi=[c]:Wi.push(c),We!==4&&(We=2),t===null)return!0;i=Kt(i,a),a=t;do{switch(a.tag){case 3:return a.flags|=65536,e=s&-s,a.lanes|=e,e=dc(a.stateNode,i,e),Ys(a,e),!1;case 1:if(t=a.type,c=a.stateNode,(a.flags&128)===0&&(typeof t.getDerivedStateFromError=="function"||c!==null&&typeof c.componentDidCatch=="function"&&(ga===null||!ga.has(c))))return a.flags|=65536,s&=-s,a.lanes|=s,s=pg(s),vg(s,e,a,i),Ys(a,s),!1}a=a.return}while(a!==null);return!1}var hc=Error(r(461)),lt=!1;function gt(e,t,a,i){t.child=e===null?wh(t,null,a,i):$a(t,e.child,a,i)}function bg(e,t,a,i,s){a=a.render;var c=t.ref;if("ref"in i){var y={};for(var w in i)w!=="ref"&&(y[w]=i[w])}else y=i;return Ya(t),i=Ks(e,t,a,y,c,s),w=Is(),e!==null&&!lt?(Js(e,t,s),Bn(e,t,s)):(Re&&w&&zs(t),t.flags|=1,gt(e,t,i,s),t.child)}function xg(e,t,a,i,s){if(e===null){var c=a.type;return typeof c=="function"&&!Ts(c)&&c.defaultProps===void 0&&a.compare===null?(t.tag=15,t.type=c,_g(e,t,c,i,s)):(e=cr(a.type,null,i,t,t.mode,s),e.ref=t.ref,e.return=t,t.child=e)}if(c=e.child,!_c(e,s)){var y=c.memoizedProps;if(a=a.compare,a=a!==null?a:zi,a(y,i)&&e.ref===t.ref)return Bn(e,t,s)}return t.flags|=1,e=Dn(c,i),e.ref=t.ref,e.return=t,t.child=e}function _g(e,t,a,i,s){if(e!==null){var c=e.memoizedProps;if(zi(c,i)&&e.ref===t.ref)if(lt=!1,t.pendingProps=i=c,_c(e,s))(e.flags&131072)!==0&&(lt=!0);else return t.lanes=e.lanes,Bn(e,t,s)}return gc(e,t,a,i,s)}function wg(e,t,a,i){var s=i.children,c=e!==null?e.memoizedState:null;if(e===null&&t.stateNode===null&&(t.stateNode={_visibility:1,_pendingMarkers:null,_retryCache:null,_transitions:null}),i.mode==="hidden"){if((t.flags&128)!==0){if(c=c!==null?c.baseLanes|a:a,e!==null){for(i=t.child=e.child,s=0;i!==null;)s=s|i.lanes|i.childLanes,i=i.sibling;i=s&~c}else i=0,t.child=null;return Sg(e,t,c,a,i)}if((a&536870912)!==0)t.memoizedState={baseLanes:0,cachePool:null},e!==null&&gr(t,c!==null?c.cachePool:null),c!==null?Nh(t,c):Xs(),Th(t);else return i=t.lanes=536870912,Sg(e,t,c!==null?c.baseLanes|a:a,a,i)}else c!==null?(gr(t,c.cachePool),Nh(t,c),ca(),t.memoizedState=null):(e!==null&&gr(t,null),Xs(),ca());return gt(e,t,s,a),t.child}function Xi(e,t){return e!==null&&e.tag===22||t.stateNode!==null||(t.stateNode={_visibility:1,_pendingMarkers:null,_retryCache:null,_transitions:null}),t.sibling}function Sg(e,t,a,i,s){var c=Ls();return c=c===null?null:{parent:nt._currentValue,pool:c},t.memoizedState={baseLanes:a,cachePool:c},e!==null&&gr(t,null),Xs(),Th(t),e!==null&&zl(e,t,i,!0),t.childLanes=s,null}function Cr(e,t){return t=kr({mode:t.mode,children:t.children},e.mode),t.ref=e.ref,e.child=t,t.return=e,t}function Eg(e,t,a){return $a(t,e.child,null,a),e=Cr(t,t.pendingProps),e.flags|=2,Bt(t),t.memoizedState=null,e}function Lb(e,t,a){var i=t.pendingProps,s=(t.flags&128)!==0;if(t.flags&=-129,e===null){if(Re){if(i.mode==="hidden")return e=Cr(t,i),t.lanes=536870912,Xi(null,e);if($s(t),(e=Xe)?(e=H0(e,Wt),e=e!==null&&e.data==="&"?e:null,e!==null&&(t.memoizedState={dehydrated:e,treeContext:na!==null?{id:mn,overflow:yn}:null,retryLane:536870912,hydrationErrors:null},a=rh(e),a.return=t,t.child=a,dt=t,Xe=null)):e=null,e===null)throw la(t);return t.lanes=536870912,null}return Cr(t,i)}var c=e.memoizedState;if(c!==null){var y=c.dehydrated;if($s(t),s)if(t.flags&256)t.flags&=-257,t=Eg(e,t,a);else if(t.memoizedState!==null)t.child=e.child,t.flags|=128,t=null;else throw Error(r(558));else if(lt||zl(e,t,a,!1),s=(a&e.childLanes)!==0,lt||s){if(i=Ve,i!==null&&(y=Vo(i,a),y!==0&&y!==c.retryLane))throw c.retryLane=y,La(e,y),Ct(i,e,y),hc;qr(),t=Eg(e,t,a)}else e=c.treeContext,Xe=Pt(y.nextSibling),dt=t,Re=!0,aa=null,Wt=!1,e!==null&&ch(t,e),t=Cr(t,i),t.flags|=4096;return t}return e=Dn(e.child,{mode:i.mode,children:i.children}),e.ref=t.ref,t.child=e,e.return=t,e}function Dr(e,t){var a=t.ref;if(a===null)e!==null&&e.ref!==null&&(t.flags|=4194816);else{if(typeof a!="function"&&typeof a!="object")throw Error(r(284));(e===null||e.ref!==a)&&(t.flags|=4194816)}}function gc(e,t,a,i,s){return Ya(t),a=Ks(e,t,a,i,void 0,s),i=Is(),e!==null&&!lt?(Js(e,t,s),Bn(e,t,s)):(Re&&i&&zs(t),t.flags|=1,gt(e,t,a,s),t.child)}function Ng(e,t,a,i,s,c){return Ya(t),t.updateQueue=null,a=Mh(t,i,a,s),Ah(e),i=Is(),e!==null&&!lt?(Js(e,t,c),Bn(e,t,c)):(Re&&i&&zs(t),t.flags|=1,gt(e,t,a,c),t.child)}function Tg(e,t,a,i,s){if(Ya(t),t.stateNode===null){var c=Nl,y=a.contextType;typeof y=="object"&&y!==null&&(c=ht(y)),c=new a(i,c),t.memoizedState=c.state!==null&&c.state!==void 0?c.state:null,c.updater=fc,t.stateNode=c,c._reactInternals=t,c=t.stateNode,c.props=i,c.state=t.memoizedState,c.refs={},Gs(t),y=a.contextType,c.context=typeof y=="object"&&y!==null?ht(y):Nl,c.state=t.memoizedState,y=a.getDerivedStateFromProps,typeof y=="function"&&(cc(t,a,y,i),c.state=t.memoizedState),typeof a.getDerivedStateFromProps=="function"||typeof c.getSnapshotBeforeUpdate=="function"||typeof c.UNSAFE_componentWillMount!="function"&&typeof c.componentWillMount!="function"||(y=c.state,typeof c.componentWillMount=="function"&&c.componentWillMount(),typeof c.UNSAFE_componentWillMount=="function"&&c.UNSAFE_componentWillMount(),y!==c.state&&fc.enqueueReplaceState(c,c.state,null),Ui(t,i,c,s),Li(),c.state=t.memoizedState),typeof c.componentDidMount=="function"&&(t.flags|=4194308),i=!0}else if(e===null){c=t.stateNode;var w=t.memoizedProps,L=Ka(a,w);c.props=L;var I=c.context,oe=a.contextType;y=Nl,typeof oe=="object"&&oe!==null&&(y=ht(oe));var ue=a.getDerivedStateFromProps;oe=typeof ue=="function"||typeof c.getSnapshotBeforeUpdate=="function",w=t.pendingProps!==w,oe||typeof c.UNSAFE_componentWillReceiveProps!="function"&&typeof c.componentWillReceiveProps!="function"||(w||I!==y)&&dg(t,c,i,y),oa=!1;var F=t.memoizedState;c.state=F,Ui(t,i,c,s),Li(),I=t.memoizedState,w||F!==I||oa?(typeof ue=="function"&&(cc(t,a,ue,i),I=t.memoizedState),(L=oa||fg(t,a,L,i,F,I,y))?(oe||typeof c.UNSAFE_componentWillMount!="function"&&typeof c.componentWillMount!="function"||(typeof c.componentWillMount=="function"&&c.componentWillMount(),typeof c.UNSAFE_componentWillMount=="function"&&c.UNSAFE_componentWillMount()),typeof c.componentDidMount=="function"&&(t.flags|=4194308)):(typeof c.componentDidMount=="function"&&(t.flags|=4194308),t.memoizedProps=i,t.memoizedState=I),c.props=i,c.state=I,c.context=y,i=L):(typeof c.componentDidMount=="function"&&(t.flags|=4194308),i=!1)}else{c=t.stateNode,qs(e,t),y=t.memoizedProps,oe=Ka(a,y),c.props=oe,ue=t.pendingProps,F=c.context,I=a.contextType,L=Nl,typeof I=="object"&&I!==null&&(L=ht(I)),w=a.getDerivedStateFromProps,(I=typeof w=="function"||typeof c.getSnapshotBeforeUpdate=="function")||typeof c.UNSAFE_componentWillReceiveProps!="function"&&typeof c.componentWillReceiveProps!="function"||(y!==ue||F!==L)&&dg(t,c,i,L),oa=!1,F=t.memoizedState,c.state=F,Ui(t,i,c,s),Li();var te=t.memoizedState;y!==ue||F!==te||oa||e!==null&&e.dependencies!==null&&dr(e.dependencies)?(typeof w=="function"&&(cc(t,a,w,i),te=t.memoizedState),(oe=oa||fg(t,a,oe,i,F,te,L)||e!==null&&e.dependencies!==null&&dr(e.dependencies))?(I||typeof c.UNSAFE_componentWillUpdate!="function"&&typeof c.componentWillUpdate!="function"||(typeof c.componentWillUpdate=="function"&&c.componentWillUpdate(i,te,L),typeof c.UNSAFE_componentWillUpdate=="function"&&c.UNSAFE_componentWillUpdate(i,te,L)),typeof c.componentDidUpdate=="function"&&(t.flags|=4),typeof c.getSnapshotBeforeUpdate=="function"&&(t.flags|=1024)):(typeof c.componentDidUpdate!="function"||y===e.memoizedProps&&F===e.memoizedState||(t.flags|=4),typeof c.getSnapshotBeforeUpdate!="function"||y===e.memoizedProps&&F===e.memoizedState||(t.flags|=1024),t.memoizedProps=i,t.memoizedState=te),c.props=i,c.state=te,c.context=L,i=oe):(typeof c.componentDidUpdate!="function"||y===e.memoizedProps&&F===e.memoizedState||(t.flags|=4),typeof c.getSnapshotBeforeUpdate!="function"||y===e.memoizedProps&&F===e.memoizedState||(t.flags|=1024),i=!1)}return c=i,Dr(e,t),i=(t.flags&128)!==0,c||i?(c=t.stateNode,a=i&&typeof a.getDerivedStateFromError!="function"?null:c.render(),t.flags|=1,e!==null&&i?(t.child=$a(t,e.child,null,s),t.child=$a(t,null,a,s)):gt(e,t,a,s),t.memoizedState=c.state,e=t.child):e=Bn(e,t,s),e}function Ag(e,t,a,i){return Ga(),t.flags|=256,gt(e,t,a,i),t.child}var mc={dehydrated:null,treeContext:null,retryLane:0,hydrationErrors:null};function yc(e){return{baseLanes:e,cachePool:yh()}}function pc(e,t,a){return e=e!==null?e.childLanes&~a:0,t&&(e|=Ut),e}function Mg(e,t,a){var i=t.pendingProps,s=!1,c=(t.flags&128)!==0,y;if((y=c)||(y=e!==null&&e.memoizedState===null?!1:(Pe.current&2)!==0),y&&(s=!0,t.flags&=-129),y=(t.flags&32)!==0,t.flags&=-33,e===null){if(Re){if(s?sa(t):ca(),(e=Xe)?(e=H0(e,Wt),e=e!==null&&e.data!=="&"?e:null,e!==null&&(t.memoizedState={dehydrated:e,treeContext:na!==null?{id:mn,overflow:yn}:null,retryLane:536870912,hydrationErrors:null},a=rh(e),a.return=t,t.child=a,dt=t,Xe=null)):e=null,e===null)throw la(t);return Pc(e)?t.lanes=32:t.lanes=536870912,null}var w=i.children;return i=i.fallback,s?(ca(),s=t.mode,w=kr({mode:"hidden",children:w},s),i=Ua(i,s,a,null),w.return=t,i.return=t,w.sibling=i,t.child=w,i=t.child,i.memoizedState=yc(a),i.childLanes=pc(e,y,a),t.memoizedState=mc,Xi(null,i)):(sa(t),vc(t,w))}var L=e.memoizedState;if(L!==null&&(w=L.dehydrated,w!==null)){if(c)t.flags&256?(sa(t),t.flags&=-257,t=bc(e,t,a)):t.memoizedState!==null?(ca(),t.child=e.child,t.flags|=128,t=null):(ca(),w=i.fallback,s=t.mode,i=kr({mode:"visible",children:i.children},s),w=Ua(w,s,a,null),w.flags|=2,i.return=t,w.return=t,i.sibling=w,t.child=i,$a(t,e.child,null,a),i=t.child,i.memoizedState=yc(a),i.childLanes=pc(e,y,a),t.memoizedState=mc,t=Xi(null,i));else if(sa(t),Pc(w)){if(y=w.nextSibling&&w.nextSibling.dataset,y)var I=y.dgst;y=I,i=Error(r(419)),i.stack="",i.digest=y,ki({value:i,source:null,stack:null}),t=bc(e,t,a)}else if(lt||zl(e,t,a,!1),y=(a&e.childLanes)!==0,lt||y){if(y=Ve,y!==null&&(i=Vo(y,a),i!==0&&i!==L.retryLane))throw L.retryLane=i,La(e,i),Ct(y,e,i),hc;Fc(w)||qr(),t=bc(e,t,a)}else Fc(w)?(t.flags|=192,t.child=e.child,t=null):(e=L.treeContext,Xe=Pt(w.nextSibling),dt=t,Re=!0,aa=null,Wt=!1,e!==null&&ch(t,e),t=vc(t,i.children),t.flags|=4096);return t}return s?(ca(),w=i.fallback,s=t.mode,L=e.child,I=L.sibling,i=Dn(L,{mode:"hidden",children:i.children}),i.subtreeFlags=L.subtreeFlags&65011712,I!==null?w=Dn(I,w):(w=Ua(w,s,a,null),w.flags|=2),w.return=t,i.return=t,i.sibling=w,t.child=i,Xi(null,i),i=t.child,w=e.child.memoizedState,w===null?w=yc(a):(s=w.cachePool,s!==null?(L=nt._currentValue,s=s.parent!==L?{parent:L,pool:L}:s):s=yh(),w={baseLanes:w.baseLanes|a,cachePool:s}),i.memoizedState=w,i.childLanes=pc(e,y,a),t.memoizedState=mc,Xi(e.child,i)):(sa(t),a=e.child,e=a.sibling,a=Dn(a,{mode:"visible",children:i.children}),a.return=t,a.sibling=null,e!==null&&(y=t.deletions,y===null?(t.deletions=[e],t.flags|=16):y.push(e)),t.child=a,t.memoizedState=null,a)}function vc(e,t){return t=kr({mode:"visible",children:t},e.mode),t.return=e,e.child=t}function kr(e,t){return e=Ot(22,e,null,t),e.lanes=0,e}function bc(e,t,a){return $a(t,e.child,null,a),e=vc(t,t.pendingProps.children),e.flags|=2,t.memoizedState=null,e}function zg(e,t,a){e.lanes|=t;var i=e.alternate;i!==null&&(i.lanes|=t),js(e.return,t,a)}function xc(e,t,a,i,s,c){var y=e.memoizedState;y===null?e.memoizedState={isBackwards:t,rendering:null,renderingStartTime:0,last:i,tail:a,tailMode:s,treeForkCount:c}:(y.isBackwards=t,y.rendering=null,y.renderingStartTime=0,y.last=i,y.tail=a,y.tailMode=s,y.treeForkCount=c)}function Cg(e,t,a){var i=t.pendingProps,s=i.revealOrder,c=i.tail;i=i.children;var y=Pe.current,w=(y&2)!==0;if(w?(y=y&1|2,t.flags|=128):y&=1,W(Pe,y),gt(e,t,i,a),i=Re?Di:0,!w&&e!==null&&(e.flags&128)!==0)e:for(e=t.child;e!==null;){if(e.tag===13)e.memoizedState!==null&&zg(e,a,t);else if(e.tag===19)zg(e,a,t);else if(e.child!==null){e.child.return=e,e=e.child;continue}if(e===t)break e;for(;e.sibling===null;){if(e.return===null||e.return===t)break e;e=e.return}e.sibling.return=e.return,e=e.sibling}switch(s){case"forwards":for(a=t.child,s=null;a!==null;)e=a.alternate,e!==null&&xr(e)===null&&(s=a),a=a.sibling;a=s,a===null?(s=t.child,t.child=null):(s=a.sibling,a.sibling=null),xc(t,!1,s,a,c,i);break;case"backwards":case"unstable_legacy-backwards":for(a=null,s=t.child,t.child=null;s!==null;){if(e=s.alternate,e!==null&&xr(e)===null){t.child=s;break}e=s.sibling,s.sibling=a,a=s,s=e}xc(t,!0,a,null,c,i);break;case"together":xc(t,!1,null,null,void 0,i);break;default:t.memoizedState=null}return t.child}function Bn(e,t,a){if(e!==null&&(t.dependencies=e.dependencies),ha|=t.lanes,(a&t.childLanes)===0)if(e!==null){if(zl(e,t,a,!1),(a&t.childLanes)===0)return null}else return null;if(e!==null&&t.child!==e.child)throw Error(r(153));if(t.child!==null){for(e=t.child,a=Dn(e,e.pendingProps),t.child=a,a.return=t;e.sibling!==null;)e=e.sibling,a=a.sibling=Dn(e,e.pendingProps),a.return=t;a.sibling=null}return t.child}function _c(e,t){return(e.lanes&t)!==0?!0:(e=e.dependencies,!!(e!==null&&dr(e)))}function Ub(e,t,a){switch(t.tag){case 3:ae(t,t.stateNode.containerInfo),ia(t,nt,e.memoizedState.cache),Ga();break;case 27:case 5:ee(t);break;case 4:ae(t,t.stateNode.containerInfo);break;case 10:ia(t,t.type,t.memoizedProps.value);break;case 31:if(t.memoizedState!==null)return t.flags|=128,$s(t),null;break;case 13:var i=t.memoizedState;if(i!==null)return i.dehydrated!==null?(sa(t),t.flags|=128,null):(a&t.child.childLanes)!==0?Mg(e,t,a):(sa(t),e=Bn(e,t,a),e!==null?e.sibling:null);sa(t);break;case 19:var s=(e.flags&128)!==0;if(i=(a&t.childLanes)!==0,i||(zl(e,t,a,!1),i=(a&t.childLanes)!==0),s){if(i)return Cg(e,t,a);t.flags|=128}if(s=t.memoizedState,s!==null&&(s.rendering=null,s.tail=null,s.lastEffect=null),W(Pe,Pe.current),i)break;return null;case 22:return t.lanes=0,wg(e,t,a,t.pendingProps);case 24:ia(t,nt,e.memoizedState.cache)}return Bn(e,t,a)}function Dg(e,t,a){if(e!==null)if(e.memoizedProps!==t.pendingProps)lt=!0;else{if(!_c(e,a)&&(t.flags&128)===0)return lt=!1,Ub(e,t,a);lt=(e.flags&131072)!==0}else lt=!1,Re&&(t.flags&1048576)!==0&&sh(t,Di,t.index);switch(t.lanes=0,t.tag){case 16:e:{var i=t.pendingProps;if(e=Xa(t.elementType),t.type=e,typeof e=="function")Ts(e)?(i=Ka(e,i),t.tag=1,t=Tg(null,t,e,i,a)):(t.tag=0,t=gc(null,t,e,i,a));else{if(e!=null){var s=e.$$typeof;if(s===D){t.tag=11,t=bg(null,t,e,i,a);break e}else if(s===k){t.tag=14,t=xg(null,t,e,i,a);break e}}throw t=C(e)||e,Error(r(306,t,""))}}return t;case 0:return gc(e,t,t.type,t.pendingProps,a);case 1:return i=t.type,s=Ka(i,t.pendingProps),Tg(e,t,i,s,a);case 3:e:{if(ae(t,t.stateNode.containerInfo),e===null)throw Error(r(387));i=t.pendingProps;var c=t.memoizedState;s=c.element,qs(e,t),Ui(t,i,null,a);var y=t.memoizedState;if(i=y.cache,ia(t,nt,i),i!==c.cache&&Os(t,[nt],a,!0),Li(),i=y.element,c.isDehydrated)if(c={element:i,isDehydrated:!1,cache:y.cache},t.updateQueue.baseState=c,t.memoizedState=c,t.flags&256){t=Ag(e,t,i,a);break e}else if(i!==s){s=Kt(Error(r(424)),t),ki(s),t=Ag(e,t,i,a);break e}else{switch(e=t.stateNode.containerInfo,e.nodeType){case 9:e=e.body;break;default:e=e.nodeName==="HTML"?e.ownerDocument.body:e}for(Xe=Pt(e.firstChild),dt=t,Re=!0,aa=null,Wt=!0,a=wh(t,null,i,a),t.child=a;a;)a.flags=a.flags&-3|4096,a=a.sibling}else{if(Ga(),i===s){t=Bn(e,t,a);break e}gt(e,t,i,a)}t=t.child}return t;case 26:return Dr(e,t),e===null?(a=Y0(t.type,null,t.pendingProps,null))?t.memoizedState=a:Re||(a=t.type,e=t.pendingProps,i=Kr(me.current).createElement(a),i[rt]=t,i[pt]=e,mt(i,a,e),tt(i),t.stateNode=i):t.memoizedState=Y0(t.type,e.memoizedProps,t.pendingProps,e.memoizedState),null;case 27:return ee(t),e===null&&Re&&(i=t.stateNode=U0(t.type,t.pendingProps,me.current),dt=t,Wt=!0,s=Xe,va(t.type)?(ef=s,Xe=Pt(i.firstChild)):Xe=s),gt(e,t,t.pendingProps.children,a),Dr(e,t),e===null&&(t.flags|=4194304),t.child;case 5:return e===null&&Re&&((s=i=Xe)&&(i=mx(i,t.type,t.pendingProps,Wt),i!==null?(t.stateNode=i,dt=t,Xe=Pt(i.firstChild),Wt=!1,s=!0):s=!1),s||la(t)),ee(t),s=t.type,c=t.pendingProps,y=e!==null?e.memoizedProps:null,i=c.children,Ic(s,c)?i=null:y!==null&&Ic(s,y)&&(t.flags|=32),t.memoizedState!==null&&(s=Ks(e,t,Cb,null,null,a),io._currentValue=s),Dr(e,t),gt(e,t,i,a),t.child;case 6:return e===null&&Re&&((e=a=Xe)&&(a=yx(a,t.pendingProps,Wt),a!==null?(t.stateNode=a,dt=t,Xe=null,e=!0):e=!1),e||la(t)),null;case 13:return Mg(e,t,a);case 4:return ae(t,t.stateNode.containerInfo),i=t.pendingProps,e===null?t.child=$a(t,null,i,a):gt(e,t,i,a),t.child;case 11:return bg(e,t,t.type,t.pendingProps,a);case 7:return gt(e,t,t.pendingProps,a),t.child;case 8:return gt(e,t,t.pendingProps.children,a),t.child;case 12:return gt(e,t,t.pendingProps.children,a),t.child;case 10:return i=t.pendingProps,ia(t,t.type,i.value),gt(e,t,i.children,a),t.child;case 9:return s=t.type._context,i=t.pendingProps.children,Ya(t),s=ht(s),i=i(s),t.flags|=1,gt(e,t,i,a),t.child;case 14:return xg(e,t,t.type,t.pendingProps,a);case 15:return _g(e,t,t.type,t.pendingProps,a);case 19:return Cg(e,t,a);case 31:return Lb(e,t,a);case 22:return wg(e,t,a,t.pendingProps);case 24:return Ya(t),i=ht(nt),e===null?(s=Ls(),s===null&&(s=Ve,c=Hs(),s.pooledCache=c,c.refCount++,c!==null&&(s.pooledCacheLanes|=a),s=c),t.memoizedState={parent:i,cache:s},Gs(t),ia(t,nt,s)):((e.lanes&a)!==0&&(qs(e,t),Ui(t,null,null,a),Li()),s=e.memoizedState,c=t.memoizedState,s.parent!==i?(s={parent:i,cache:i},t.memoizedState=s,t.lanes===0&&(t.memoizedState=t.updateQueue.baseState=s),ia(t,nt,i)):(i=c.cache,ia(t,nt,i),i!==s.cache&&Os(t,[nt],a,!0))),gt(e,t,t.pendingProps.children,a),t.child;case 29:throw t.pendingProps}throw Error(r(156,t.tag))}function Ln(e){e.flags|=4}function wc(e,t,a,i,s){if((t=(e.mode&32)!==0)&&(t=!1),t){if(e.flags|=16777216,(s&335544128)===s)if(e.stateNode.complete)e.flags|=8192;else if(l0())e.flags|=8192;else throw Qa=yr,Us}else e.flags&=-16777217}function kg(e,t){if(t.type!=="stylesheet"||(t.state.loading&4)!==0)e.flags&=-16777217;else if(e.flags|=16777216,!Z0(t))if(l0())e.flags|=8192;else throw Qa=yr,Us}function Rr(e,t){t!==null&&(e.flags|=4),e.flags&16384&&(t=e.tag!==22?Go():536870912,e.lanes|=t,ql|=t)}function Qi(e,t){if(!Re)switch(e.tailMode){case"hidden":t=e.tail;for(var a=null;t!==null;)t.alternate!==null&&(a=t),t=t.sibling;a===null?e.tail=null:a.sibling=null;break;case"collapsed":a=e.tail;for(var i=null;a!==null;)a.alternate!==null&&(i=a),a=a.sibling;i===null?t||e.tail===null?e.tail=null:e.tail.sibling=null:i.sibling=null}}function Qe(e){var t=e.alternate!==null&&e.alternate.child===e.child,a=0,i=0;if(t)for(var s=e.child;s!==null;)a|=s.lanes|s.childLanes,i|=s.subtreeFlags&65011712,i|=s.flags&65011712,s.return=e,s=s.sibling;else for(s=e.child;s!==null;)a|=s.lanes|s.childLanes,i|=s.subtreeFlags,i|=s.flags,s.return=e,s=s.sibling;return e.subtreeFlags|=i,e.childLanes=a,t}function Gb(e,t,a){var i=t.pendingProps;switch(Cs(t),t.tag){case 16:case 15:case 0:case 11:case 7:case 8:case 12:case 9:case 14:return Qe(t),null;case 1:return Qe(t),null;case 3:return a=t.stateNode,i=null,e!==null&&(i=e.memoizedState.cache),t.memoizedState.cache!==i&&(t.flags|=2048),jn(nt),fe(),a.pendingContext&&(a.context=a.pendingContext,a.pendingContext=null),(e===null||e.child===null)&&(Ml(t)?Ln(t):e===null||e.memoizedState.isDehydrated&&(t.flags&256)===0||(t.flags|=1024,ks())),Qe(t),null;case 26:var s=t.type,c=t.memoizedState;return e===null?(Ln(t),c!==null?(Qe(t),kg(t,c)):(Qe(t),wc(t,s,null,i,a))):c?c!==e.memoizedState?(Ln(t),Qe(t),kg(t,c)):(Qe(t),t.flags&=-16777217):(e=e.memoizedProps,e!==i&&Ln(t),Qe(t),wc(t,s,e,i,a)),null;case 27:if(se(t),a=me.current,s=t.type,e!==null&&t.stateNode!=null)e.memoizedProps!==i&&Ln(t);else{if(!i){if(t.stateNode===null)throw Error(r(166));return Qe(t),null}e=le.current,Ml(t)?fh(t):(e=U0(s,i,a),t.stateNode=e,Ln(t))}return Qe(t),null;case 5:if(se(t),s=t.type,e!==null&&t.stateNode!=null)e.memoizedProps!==i&&Ln(t);else{if(!i){if(t.stateNode===null)throw Error(r(166));return Qe(t),null}if(c=le.current,Ml(t))fh(t);else{var y=Kr(me.current);switch(c){case 1:c=y.createElementNS("http://www.w3.org/2000/svg",s);break;case 2:c=y.createElementNS("http://www.w3.org/1998/Math/MathML",s);break;default:switch(s){case"svg":c=y.createElementNS("http://www.w3.org/2000/svg",s);break;case"math":c=y.createElementNS("http://www.w3.org/1998/Math/MathML",s);break;case"script":c=y.createElement("div"),c.innerHTML="<script><\/script>",c=c.removeChild(c.firstChild);break;case"select":c=typeof i.is=="string"?y.createElement("select",{is:i.is}):y.createElement("select"),i.multiple?c.multiple=!0:i.size&&(c.size=i.size);break;default:c=typeof i.is=="string"?y.createElement(s,{is:i.is}):y.createElement(s)}}c[rt]=t,c[pt]=i;e:for(y=t.child;y!==null;){if(y.tag===5||y.tag===6)c.appendChild(y.stateNode);else if(y.tag!==4&&y.tag!==27&&y.child!==null){y.child.return=y,y=y.child;continue}if(y===t)break e;for(;y.sibling===null;){if(y.return===null||y.return===t)break e;y=y.return}y.sibling.return=y.return,y=y.sibling}t.stateNode=c;e:switch(mt(c,s,i),s){case"button":case"input":case"select":case"textarea":i=!!i.autoFocus;break e;case"img":i=!0;break e;default:i=!1}i&&Ln(t)}}return Qe(t),wc(t,t.type,e===null?null:e.memoizedProps,t.pendingProps,a),null;case 6:if(e&&t.stateNode!=null)e.memoizedProps!==i&&Ln(t);else{if(typeof i!="string"&&t.stateNode===null)throw Error(r(166));if(e=me.current,Ml(t)){if(e=t.stateNode,a=t.memoizedProps,i=null,s=dt,s!==null)switch(s.tag){case 27:case 5:i=s.memoizedProps}e[rt]=t,e=!!(e.nodeValue===a||i!==null&&i.suppressHydrationWarning===!0||M0(e.nodeValue,a)),e||la(t,!0)}else e=Kr(e).createTextNode(i),e[rt]=t,t.stateNode=e}return Qe(t),null;case 31:if(a=t.memoizedState,e===null||e.memoizedState!==null){if(i=Ml(t),a!==null){if(e===null){if(!i)throw Error(r(318));if(e=t.memoizedState,e=e!==null?e.dehydrated:null,!e)throw Error(r(557));e[rt]=t}else Ga(),(t.flags&128)===0&&(t.memoizedState=null),t.flags|=4;Qe(t),e=!1}else a=ks(),e!==null&&e.memoizedState!==null&&(e.memoizedState.hydrationErrors=a),e=!0;if(!e)return t.flags&256?(Bt(t),t):(Bt(t),null);if((t.flags&128)!==0)throw Error(r(558))}return Qe(t),null;case 13:if(i=t.memoizedState,e===null||e.memoizedState!==null&&e.memoizedState.dehydrated!==null){if(s=Ml(t),i!==null&&i.dehydrated!==null){if(e===null){if(!s)throw Error(r(318));if(s=t.memoizedState,s=s!==null?s.dehydrated:null,!s)throw Error(r(317));s[rt]=t}else Ga(),(t.flags&128)===0&&(t.memoizedState=null),t.flags|=4;Qe(t),s=!1}else s=ks(),e!==null&&e.memoizedState!==null&&(e.memoizedState.hydrationErrors=s),s=!0;if(!s)return t.flags&256?(Bt(t),t):(Bt(t),null)}return Bt(t),(t.flags&128)!==0?(t.lanes=a,t):(a=i!==null,e=e!==null&&e.memoizedState!==null,a&&(i=t.child,s=null,i.alternate!==null&&i.alternate.memoizedState!==null&&i.alternate.memoizedState.cachePool!==null&&(s=i.alternate.memoizedState.cachePool.pool),c=null,i.memoizedState!==null&&i.memoizedState.cachePool!==null&&(c=i.memoizedState.cachePool.pool),c!==s&&(i.flags|=2048)),a!==e&&a&&(t.child.flags|=8192),Rr(t,t.updateQueue),Qe(t),null);case 4:return fe(),e===null&&Xc(t.stateNode.containerInfo),Qe(t),null;case 10:return jn(t.type),Qe(t),null;case 19:if(O(Pe),i=t.memoizedState,i===null)return Qe(t),null;if(s=(t.flags&128)!==0,c=i.rendering,c===null)if(s)Qi(i,!1);else{if(We!==0||e!==null&&(e.flags&128)!==0)for(e=t.child;e!==null;){if(c=xr(e),c!==null){for(t.flags|=128,Qi(i,!1),e=c.updateQueue,t.updateQueue=e,Rr(t,e),t.subtreeFlags=0,e=a,a=t.child;a!==null;)oh(a,e),a=a.sibling;return W(Pe,Pe.current&1|2),Re&&kn(t,i.treeForkCount),t.child}e=e.sibling}i.tail!==null&&Fe()>Lr&&(t.flags|=128,s=!0,Qi(i,!1),t.lanes=4194304)}else{if(!s)if(e=xr(c),e!==null){if(t.flags|=128,s=!0,e=e.updateQueue,t.updateQueue=e,Rr(t,e),Qi(i,!0),i.tail===null&&i.tailMode==="hidden"&&!c.alternate&&!Re)return Qe(t),null}else 2*Fe()-i.renderingStartTime>Lr&&a!==536870912&&(t.flags|=128,s=!0,Qi(i,!1),t.lanes=4194304);i.isBackwards?(c.sibling=t.child,t.child=c):(e=i.last,e!==null?e.sibling=c:t.child=c,i.last=c)}return i.tail!==null?(e=i.tail,i.rendering=e,i.tail=e.sibling,i.renderingStartTime=Fe(),e.sibling=null,a=Pe.current,W(Pe,s?a&1|2:a&1),Re&&kn(t,i.treeForkCount),e):(Qe(t),null);case 22:case 23:return Bt(t),Qs(),i=t.memoizedState!==null,e!==null?e.memoizedState!==null!==i&&(t.flags|=8192):i&&(t.flags|=8192),i?(a&536870912)!==0&&(t.flags&128)===0&&(Qe(t),t.subtreeFlags&6&&(t.flags|=8192)):Qe(t),a=t.updateQueue,a!==null&&Rr(t,a.retryQueue),a=null,e!==null&&e.memoizedState!==null&&e.memoizedState.cachePool!==null&&(a=e.memoizedState.cachePool.pool),i=null,t.memoizedState!==null&&t.memoizedState.cachePool!==null&&(i=t.memoizedState.cachePool.pool),i!==a&&(t.flags|=2048),e!==null&&O(Va),null;case 24:return a=null,e!==null&&(a=e.memoizedState.cache),t.memoizedState.cache!==a&&(t.flags|=2048),jn(nt),Qe(t),null;case 25:return null;case 30:return null}throw Error(r(156,t.tag))}function qb(e,t){switch(Cs(t),t.tag){case 1:return e=t.flags,e&65536?(t.flags=e&-65537|128,t):null;case 3:return jn(nt),fe(),e=t.flags,(e&65536)!==0&&(e&128)===0?(t.flags=e&-65537|128,t):null;case 26:case 27:case 5:return se(t),null;case 31:if(t.memoizedState!==null){if(Bt(t),t.alternate===null)throw Error(r(340));Ga()}return e=t.flags,e&65536?(t.flags=e&-65537|128,t):null;case 13:if(Bt(t),e=t.memoizedState,e!==null&&e.dehydrated!==null){if(t.alternate===null)throw Error(r(340));Ga()}return e=t.flags,e&65536?(t.flags=e&-65537|128,t):null;case 19:return O(Pe),null;case 4:return fe(),null;case 10:return jn(t.type),null;case 22:case 23:return Bt(t),Qs(),e!==null&&O(Va),e=t.flags,e&65536?(t.flags=e&-65537|128,t):null;case 24:return jn(nt),null;case 25:return null;default:return null}}function Rg(e,t){switch(Cs(t),t.tag){case 3:jn(nt),fe();break;case 26:case 27:case 5:se(t);break;case 4:fe();break;case 31:t.memoizedState!==null&&Bt(t);break;case 13:Bt(t);break;case 19:O(Pe);break;case 10:jn(t.type);break;case 22:case 23:Bt(t),Qs(),e!==null&&O(Va);break;case 24:jn(nt)}}function $i(e,t){try{var a=t.updateQueue,i=a!==null?a.lastEffect:null;if(i!==null){var s=i.next;a=s;do{if((a.tag&e)===e){i=void 0;var c=a.create,y=a.inst;i=c(),y.destroy=i}a=a.next}while(a!==s)}}catch(w){Ue(t,t.return,w)}}function fa(e,t,a){try{var i=t.updateQueue,s=i!==null?i.lastEffect:null;if(s!==null){var c=s.next;i=c;do{if((i.tag&e)===e){var y=i.inst,w=y.destroy;if(w!==void 0){y.destroy=void 0,s=t;var L=a,I=w;try{I()}catch(oe){Ue(s,L,oe)}}}i=i.next}while(i!==c)}}catch(oe){Ue(t,t.return,oe)}}function jg(e){var t=e.updateQueue;if(t!==null){var a=e.stateNode;try{Eh(t,a)}catch(i){Ue(e,e.return,i)}}}function Og(e,t,a){a.props=Ka(e.type,e.memoizedProps),a.state=e.memoizedState;try{a.componentWillUnmount()}catch(i){Ue(e,t,i)}}function Zi(e,t){try{var a=e.ref;if(a!==null){switch(e.tag){case 26:case 27:case 5:var i=e.stateNode;break;case 30:i=e.stateNode;break;default:i=e.stateNode}typeof a=="function"?e.refCleanup=a(i):a.current=i}}catch(s){Ue(e,t,s)}}function pn(e,t){var a=e.ref,i=e.refCleanup;if(a!==null)if(typeof i=="function")try{i()}catch(s){Ue(e,t,s)}finally{e.refCleanup=null,e=e.alternate,e!=null&&(e.refCleanup=null)}else if(typeof a=="function")try{a(null)}catch(s){Ue(e,t,s)}else a.current=null}function Hg(e){var t=e.type,a=e.memoizedProps,i=e.stateNode;try{e:switch(t){case"button":case"input":case"select":case"textarea":a.autoFocus&&i.focus();break e;case"img":a.src?i.src=a.src:a.srcSet&&(i.srcset=a.srcSet)}}catch(s){Ue(e,e.return,s)}}function Sc(e,t,a){try{var i=e.stateNode;sx(i,e.type,a,t),i[pt]=t}catch(s){Ue(e,e.return,s)}}function Bg(e){return e.tag===5||e.tag===3||e.tag===26||e.tag===27&&va(e.type)||e.tag===4}function Ec(e){e:for(;;){for(;e.sibling===null;){if(e.return===null||Bg(e.return))return null;e=e.return}for(e.sibling.return=e.return,e=e.sibling;e.tag!==5&&e.tag!==6&&e.tag!==18;){if(e.tag===27&&va(e.type)||e.flags&2||e.child===null||e.tag===4)continue e;e.child.return=e,e=e.child}if(!(e.flags&2))return e.stateNode}}function Nc(e,t,a){var i=e.tag;if(i===5||i===6)e=e.stateNode,t?(a.nodeType===9?a.body:a.nodeName==="HTML"?a.ownerDocument.body:a).insertBefore(e,t):(t=a.nodeType===9?a.body:a.nodeName==="HTML"?a.ownerDocument.body:a,t.appendChild(e),a=a._reactRootContainer,a!=null||t.onclick!==null||(t.onclick=zn));else if(i!==4&&(i===27&&va(e.type)&&(a=e.stateNode,t=null),e=e.child,e!==null))for(Nc(e,t,a),e=e.sibling;e!==null;)Nc(e,t,a),e=e.sibling}function jr(e,t,a){var i=e.tag;if(i===5||i===6)e=e.stateNode,t?a.insertBefore(e,t):a.appendChild(e);else if(i!==4&&(i===27&&va(e.type)&&(a=e.stateNode),e=e.child,e!==null))for(jr(e,t,a),e=e.sibling;e!==null;)jr(e,t,a),e=e.sibling}function Lg(e){var t=e.stateNode,a=e.memoizedProps;try{for(var i=e.type,s=t.attributes;s.length;)t.removeAttributeNode(s[0]);mt(t,i,a),t[rt]=e,t[pt]=a}catch(c){Ue(e,e.return,c)}}var Un=!1,it=!1,Tc=!1,Ug=typeof WeakSet=="function"?WeakSet:Set,ct=null;function Yb(e,t){if(e=e.containerInfo,Zc=tu,e=Wd(e),bs(e)){if("selectionStart"in e)var a={start:e.selectionStart,end:e.selectionEnd};else e:{a=(a=e.ownerDocument)&&a.defaultView||window;var i=a.getSelection&&a.getSelection();if(i&&i.rangeCount!==0){a=i.anchorNode;var s=i.anchorOffset,c=i.focusNode;i=i.focusOffset;try{a.nodeType,c.nodeType}catch{a=null;break e}var y=0,w=-1,L=-1,I=0,oe=0,ue=e,F=null;t:for(;;){for(var te;ue!==a||s!==0&&ue.nodeType!==3||(w=y+s),ue!==c||i!==0&&ue.nodeType!==3||(L=y+i),ue.nodeType===3&&(y+=ue.nodeValue.length),(te=ue.firstChild)!==null;)F=ue,ue=te;for(;;){if(ue===e)break t;if(F===a&&++I===s&&(w=y),F===c&&++oe===i&&(L=y),(te=ue.nextSibling)!==null)break;ue=F,F=ue.parentNode}ue=te}a=w===-1||L===-1?null:{start:w,end:L}}else a=null}a=a||{start:0,end:0}}else a=null;for(Kc={focusedElem:e,selectionRange:a},tu=!1,ct=t;ct!==null;)if(t=ct,e=t.child,(t.subtreeFlags&1028)!==0&&e!==null)e.return=t,ct=e;else for(;ct!==null;){switch(t=ct,c=t.alternate,e=t.flags,t.tag){case 0:if((e&4)!==0&&(e=t.updateQueue,e=e!==null?e.events:null,e!==null))for(a=0;a<e.length;a++)s=e[a],s.ref.impl=s.nextImpl;break;case 11:case 15:break;case 1:if((e&1024)!==0&&c!==null){e=void 0,a=t,s=c.memoizedProps,c=c.memoizedState,i=a.stateNode;try{var ve=Ka(a.type,s);e=i.getSnapshotBeforeUpdate(ve,c),i.__reactInternalSnapshotBeforeUpdate=e}catch(Se){Ue(a,a.return,Se)}}break;case 3:if((e&1024)!==0){if(e=t.stateNode.containerInfo,a=e.nodeType,a===9)Wc(e);else if(a===1)switch(e.nodeName){case"HEAD":case"HTML":case"BODY":Wc(e);break;default:e.textContent=""}}break;case 5:case 26:case 27:case 6:case 4:case 17:break;default:if((e&1024)!==0)throw Error(r(163))}if(e=t.sibling,e!==null){e.return=t.return,ct=e;break}ct=t.return}}function Gg(e,t,a){var i=a.flags;switch(a.tag){case 0:case 11:case 15:qn(e,a),i&4&&$i(5,a);break;case 1:if(qn(e,a),i&4)if(e=a.stateNode,t===null)try{e.componentDidMount()}catch(y){Ue(a,a.return,y)}else{var s=Ka(a.type,t.memoizedProps);t=t.memoizedState;try{e.componentDidUpdate(s,t,e.__reactInternalSnapshotBeforeUpdate)}catch(y){Ue(a,a.return,y)}}i&64&&jg(a),i&512&&Zi(a,a.return);break;case 3:if(qn(e,a),i&64&&(e=a.updateQueue,e!==null)){if(t=null,a.child!==null)switch(a.child.tag){case 27:case 5:t=a.child.stateNode;break;case 1:t=a.child.stateNode}try{Eh(e,t)}catch(y){Ue(a,a.return,y)}}break;case 27:t===null&&i&4&&Lg(a);case 26:case 5:qn(e,a),t===null&&i&4&&Hg(a),i&512&&Zi(a,a.return);break;case 12:qn(e,a);break;case 31:qn(e,a),i&4&&Vg(e,a);break;case 13:qn(e,a),i&4&&Xg(e,a),i&64&&(e=a.memoizedState,e!==null&&(e=e.dehydrated,e!==null&&(a=Wb.bind(null,a),px(e,a))));break;case 22:if(i=a.memoizedState!==null||Un,!i){t=t!==null&&t.memoizedState!==null||it,s=Un;var c=it;Un=i,(it=t)&&!c?Yn(e,a,(a.subtreeFlags&8772)!==0):qn(e,a),Un=s,it=c}break;case 30:break;default:qn(e,a)}}function qg(e){var t=e.alternate;t!==null&&(e.alternate=null,qg(t)),e.child=null,e.deletions=null,e.sibling=null,e.tag===5&&(t=e.stateNode,t!==null&&yi(t)),e.stateNode=null,e.return=null,e.dependencies=null,e.memoizedProps=null,e.memoizedState=null,e.pendingProps=null,e.stateNode=null,e.updateQueue=null}var Ze=null,Tt=!1;function Gn(e,t,a){for(a=a.child;a!==null;)Yg(e,t,a),a=a.sibling}function Yg(e,t,a){if(bt&&typeof bt.onCommitFiberUnmount=="function")try{bt.onCommitFiberUnmount(Ca,a)}catch{}switch(a.tag){case 26:it||pn(a,t),Gn(e,t,a),a.memoizedState?a.memoizedState.count--:a.stateNode&&(a=a.stateNode,a.parentNode.removeChild(a));break;case 27:it||pn(a,t);var i=Ze,s=Tt;va(a.type)&&(Ze=a.stateNode,Tt=!1),Gn(e,t,a),no(a.stateNode),Ze=i,Tt=s;break;case 5:it||pn(a,t);case 6:if(i=Ze,s=Tt,Ze=null,Gn(e,t,a),Ze=i,Tt=s,Ze!==null)if(Tt)try{(Ze.nodeType===9?Ze.body:Ze.nodeName==="HTML"?Ze.ownerDocument.body:Ze).removeChild(a.stateNode)}catch(c){Ue(a,t,c)}else try{Ze.removeChild(a.stateNode)}catch(c){Ue(a,t,c)}break;case 18:Ze!==null&&(Tt?(e=Ze,j0(e.nodeType===9?e.body:e.nodeName==="HTML"?e.ownerDocument.body:e,a.stateNode),Il(e)):j0(Ze,a.stateNode));break;case 4:i=Ze,s=Tt,Ze=a.stateNode.containerInfo,Tt=!0,Gn(e,t,a),Ze=i,Tt=s;break;case 0:case 11:case 14:case 15:fa(2,a,t),it||fa(4,a,t),Gn(e,t,a);break;case 1:it||(pn(a,t),i=a.stateNode,typeof i.componentWillUnmount=="function"&&Og(a,t,i)),Gn(e,t,a);break;case 21:Gn(e,t,a);break;case 22:it=(i=it)||a.memoizedState!==null,Gn(e,t,a),it=i;break;default:Gn(e,t,a)}}function Vg(e,t){if(t.memoizedState===null&&(e=t.alternate,e!==null&&(e=e.memoizedState,e!==null))){e=e.dehydrated;try{Il(e)}catch(a){Ue(t,t.return,a)}}}function Xg(e,t){if(t.memoizedState===null&&(e=t.alternate,e!==null&&(e=e.memoizedState,e!==null&&(e=e.dehydrated,e!==null))))try{Il(e)}catch(a){Ue(t,t.return,a)}}function Vb(e){switch(e.tag){case 31:case 13:case 19:var t=e.stateNode;return t===null&&(t=e.stateNode=new Ug),t;case 22:return e=e.stateNode,t=e._retryCache,t===null&&(t=e._retryCache=new Ug),t;default:throw Error(r(435,e.tag))}}function Or(e,t){var a=Vb(e);t.forEach(function(i){if(!a.has(i)){a.add(i);var s=Fb.bind(null,e,i);i.then(s,s)}})}function At(e,t){var a=t.deletions;if(a!==null)for(var i=0;i<a.length;i++){var s=a[i],c=e,y=t,w=y;e:for(;w!==null;){switch(w.tag){case 27:if(va(w.type)){Ze=w.stateNode,Tt=!1;break e}break;case 5:Ze=w.stateNode,Tt=!1;break e;case 3:case 4:Ze=w.stateNode.containerInfo,Tt=!0;break e}w=w.return}if(Ze===null)throw Error(r(160));Yg(c,y,s),Ze=null,Tt=!1,c=s.alternate,c!==null&&(c.return=null),s.return=null}if(t.subtreeFlags&13886)for(t=t.child;t!==null;)Qg(t,e),t=t.sibling}var an=null;function Qg(e,t){var a=e.alternate,i=e.flags;switch(e.tag){case 0:case 11:case 14:case 15:At(t,e),Mt(e),i&4&&(fa(3,e,e.return),$i(3,e),fa(5,e,e.return));break;case 1:At(t,e),Mt(e),i&512&&(it||a===null||pn(a,a.return)),i&64&&Un&&(e=e.updateQueue,e!==null&&(i=e.callbacks,i!==null&&(a=e.shared.hiddenCallbacks,e.shared.hiddenCallbacks=a===null?i:a.concat(i))));break;case 26:var s=an;if(At(t,e),Mt(e),i&512&&(it||a===null||pn(a,a.return)),i&4){var c=a!==null?a.memoizedState:null;if(i=e.memoizedState,a===null)if(i===null)if(e.stateNode===null){e:{i=e.type,a=e.memoizedProps,s=s.ownerDocument||s;t:switch(i){case"title":c=s.getElementsByTagName("title")[0],(!c||c[Ra]||c[rt]||c.namespaceURI==="http://www.w3.org/2000/svg"||c.hasAttribute("itemprop"))&&(c=s.createElement(i),s.head.insertBefore(c,s.querySelector("head > title"))),mt(c,i,a),c[rt]=e,tt(c),i=c;break e;case"link":var y=Q0("link","href",s).get(i+(a.href||""));if(y){for(var w=0;w<y.length;w++)if(c=y[w],c.getAttribute("href")===(a.href==null||a.href===""?null:a.href)&&c.getAttribute("rel")===(a.rel==null?null:a.rel)&&c.getAttribute("title")===(a.title==null?null:a.title)&&c.getAttribute("crossorigin")===(a.crossOrigin==null?null:a.crossOrigin)){y.splice(w,1);break t}}c=s.createElement(i),mt(c,i,a),s.head.appendChild(c);break;case"meta":if(y=Q0("meta","content",s).get(i+(a.content||""))){for(w=0;w<y.length;w++)if(c=y[w],c.getAttribute("content")===(a.content==null?null:""+a.content)&&c.getAttribute("name")===(a.name==null?null:a.name)&&c.getAttribute("property")===(a.property==null?null:a.property)&&c.getAttribute("http-equiv")===(a.httpEquiv==null?null:a.httpEquiv)&&c.getAttribute("charset")===(a.charSet==null?null:a.charSet)){y.splice(w,1);break t}}c=s.createElement(i),mt(c,i,a),s.head.appendChild(c);break;default:throw Error(r(468,i))}c[rt]=e,tt(c),i=c}e.stateNode=i}else $0(s,e.type,e.stateNode);else e.stateNode=X0(s,i,e.memoizedProps);else c!==i?(c===null?a.stateNode!==null&&(a=a.stateNode,a.parentNode.removeChild(a)):c.count--,i===null?$0(s,e.type,e.stateNode):X0(s,i,e.memoizedProps)):i===null&&e.stateNode!==null&&Sc(e,e.memoizedProps,a.memoizedProps)}break;case 27:At(t,e),Mt(e),i&512&&(it||a===null||pn(a,a.return)),a!==null&&i&4&&Sc(e,e.memoizedProps,a.memoizedProps);break;case 5:if(At(t,e),Mt(e),i&512&&(it||a===null||pn(a,a.return)),e.flags&32){s=e.stateNode;try{vl(s,"")}catch(ve){Ue(e,e.return,ve)}}i&4&&e.stateNode!=null&&(s=e.memoizedProps,Sc(e,s,a!==null?a.memoizedProps:s)),i&1024&&(Tc=!0);break;case 6:if(At(t,e),Mt(e),i&4){if(e.stateNode===null)throw Error(r(162));i=e.memoizedProps,a=e.stateNode;try{a.nodeValue=i}catch(ve){Ue(e,e.return,ve)}}break;case 3:if(Wr=null,s=an,an=Ir(t.containerInfo),At(t,e),an=s,Mt(e),i&4&&a!==null&&a.memoizedState.isDehydrated)try{Il(t.containerInfo)}catch(ve){Ue(e,e.return,ve)}Tc&&(Tc=!1,$g(e));break;case 4:i=an,an=Ir(e.stateNode.containerInfo),At(t,e),Mt(e),an=i;break;case 12:At(t,e),Mt(e);break;case 31:At(t,e),Mt(e),i&4&&(i=e.updateQueue,i!==null&&(e.updateQueue=null,Or(e,i)));break;case 13:At(t,e),Mt(e),e.child.flags&8192&&e.memoizedState!==null!=(a!==null&&a.memoizedState!==null)&&(Br=Fe()),i&4&&(i=e.updateQueue,i!==null&&(e.updateQueue=null,Or(e,i)));break;case 22:s=e.memoizedState!==null;var L=a!==null&&a.memoizedState!==null,I=Un,oe=it;if(Un=I||s,it=oe||L,At(t,e),it=oe,Un=I,Mt(e),i&8192)e:for(t=e.stateNode,t._visibility=s?t._visibility&-2:t._visibility|1,s&&(a===null||L||Un||it||Ia(e)),a=null,t=e;;){if(t.tag===5||t.tag===26){if(a===null){L=a=t;try{if(c=L.stateNode,s)y=c.style,typeof y.setProperty=="function"?y.setProperty("display","none","important"):y.display="none";else{w=L.stateNode;var ue=L.memoizedProps.style,F=ue!=null&&ue.hasOwnProperty("display")?ue.display:null;w.style.display=F==null||typeof F=="boolean"?"":(""+F).trim()}}catch(ve){Ue(L,L.return,ve)}}}else if(t.tag===6){if(a===null){L=t;try{L.stateNode.nodeValue=s?"":L.memoizedProps}catch(ve){Ue(L,L.return,ve)}}}else if(t.tag===18){if(a===null){L=t;try{var te=L.stateNode;s?O0(te,!0):O0(L.stateNode,!1)}catch(ve){Ue(L,L.return,ve)}}}else if((t.tag!==22&&t.tag!==23||t.memoizedState===null||t===e)&&t.child!==null){t.child.return=t,t=t.child;continue}if(t===e)break e;for(;t.sibling===null;){if(t.return===null||t.return===e)break e;a===t&&(a=null),t=t.return}a===t&&(a=null),t.sibling.return=t.return,t=t.sibling}i&4&&(i=e.updateQueue,i!==null&&(a=i.retryQueue,a!==null&&(i.retryQueue=null,Or(e,a))));break;case 19:At(t,e),Mt(e),i&4&&(i=e.updateQueue,i!==null&&(e.updateQueue=null,Or(e,i)));break;case 30:break;case 21:break;default:At(t,e),Mt(e)}}function Mt(e){var t=e.flags;if(t&2){try{for(var a,i=e.return;i!==null;){if(Bg(i)){a=i;break}i=i.return}if(a==null)throw Error(r(160));switch(a.tag){case 27:var s=a.stateNode,c=Ec(e);jr(e,c,s);break;case 5:var y=a.stateNode;a.flags&32&&(vl(y,""),a.flags&=-33);var w=Ec(e);jr(e,w,y);break;case 3:case 4:var L=a.stateNode.containerInfo,I=Ec(e);Nc(e,I,L);break;default:throw Error(r(161))}}catch(oe){Ue(e,e.return,oe)}e.flags&=-3}t&4096&&(e.flags&=-4097)}function $g(e){if(e.subtreeFlags&1024)for(e=e.child;e!==null;){var t=e;$g(t),t.tag===5&&t.flags&1024&&t.stateNode.reset(),e=e.sibling}}function qn(e,t){if(t.subtreeFlags&8772)for(t=t.child;t!==null;)Gg(e,t.alternate,t),t=t.sibling}function Ia(e){for(e=e.child;e!==null;){var t=e;switch(t.tag){case 0:case 11:case 14:case 15:fa(4,t,t.return),Ia(t);break;case 1:pn(t,t.return);var a=t.stateNode;typeof a.componentWillUnmount=="function"&&Og(t,t.return,a),Ia(t);break;case 27:no(t.stateNode);case 26:case 5:pn(t,t.return),Ia(t);break;case 22:t.memoizedState===null&&Ia(t);break;case 30:Ia(t);break;default:Ia(t)}e=e.sibling}}function Yn(e,t,a){for(a=a&&(t.subtreeFlags&8772)!==0,t=t.child;t!==null;){var i=t.alternate,s=e,c=t,y=c.flags;switch(c.tag){case 0:case 11:case 15:Yn(s,c,a),$i(4,c);break;case 1:if(Yn(s,c,a),i=c,s=i.stateNode,typeof s.componentDidMount=="function")try{s.componentDidMount()}catch(I){Ue(i,i.return,I)}if(i=c,s=i.updateQueue,s!==null){var w=i.stateNode;try{var L=s.shared.hiddenCallbacks;if(L!==null)for(s.shared.hiddenCallbacks=null,s=0;s<L.length;s++)Sh(L[s],w)}catch(I){Ue(i,i.return,I)}}a&&y&64&&jg(c),Zi(c,c.return);break;case 27:Lg(c);case 26:case 5:Yn(s,c,a),a&&i===null&&y&4&&Hg(c),Zi(c,c.return);break;case 12:Yn(s,c,a);break;case 31:Yn(s,c,a),a&&y&4&&Vg(s,c);break;case 13:Yn(s,c,a),a&&y&4&&Xg(s,c);break;case 22:c.memoizedState===null&&Yn(s,c,a),Zi(c,c.return);break;case 30:break;default:Yn(s,c,a)}t=t.sibling}}function Ac(e,t){var a=null;e!==null&&e.memoizedState!==null&&e.memoizedState.cachePool!==null&&(a=e.memoizedState.cachePool.pool),e=null,t.memoizedState!==null&&t.memoizedState.cachePool!==null&&(e=t.memoizedState.cachePool.pool),e!==a&&(e!=null&&e.refCount++,a!=null&&Ri(a))}function Mc(e,t){e=null,t.alternate!==null&&(e=t.alternate.memoizedState.cache),t=t.memoizedState.cache,t!==e&&(t.refCount++,e!=null&&Ri(e))}function ln(e,t,a,i){if(t.subtreeFlags&10256)for(t=t.child;t!==null;)Zg(e,t,a,i),t=t.sibling}function Zg(e,t,a,i){var s=t.flags;switch(t.tag){case 0:case 11:case 15:ln(e,t,a,i),s&2048&&$i(9,t);break;case 1:ln(e,t,a,i);break;case 3:ln(e,t,a,i),s&2048&&(e=null,t.alternate!==null&&(e=t.alternate.memoizedState.cache),t=t.memoizedState.cache,t!==e&&(t.refCount++,e!=null&&Ri(e)));break;case 12:if(s&2048){ln(e,t,a,i),e=t.stateNode;try{var c=t.memoizedProps,y=c.id,w=c.onPostCommit;typeof w=="function"&&w(y,t.alternate===null?"mount":"update",e.passiveEffectDuration,-0)}catch(L){Ue(t,t.return,L)}}else ln(e,t,a,i);break;case 31:ln(e,t,a,i);break;case 13:ln(e,t,a,i);break;case 23:break;case 22:c=t.stateNode,y=t.alternate,t.memoizedState!==null?c._visibility&2?ln(e,t,a,i):Ki(e,t):c._visibility&2?ln(e,t,a,i):(c._visibility|=2,Ll(e,t,a,i,(t.subtreeFlags&10256)!==0||!1)),s&2048&&Ac(y,t);break;case 24:ln(e,t,a,i),s&2048&&Mc(t.alternate,t);break;default:ln(e,t,a,i)}}function Ll(e,t,a,i,s){for(s=s&&((t.subtreeFlags&10256)!==0||!1),t=t.child;t!==null;){var c=e,y=t,w=a,L=i,I=y.flags;switch(y.tag){case 0:case 11:case 15:Ll(c,y,w,L,s),$i(8,y);break;case 23:break;case 22:var oe=y.stateNode;y.memoizedState!==null?oe._visibility&2?Ll(c,y,w,L,s):Ki(c,y):(oe._visibility|=2,Ll(c,y,w,L,s)),s&&I&2048&&Ac(y.alternate,y);break;case 24:Ll(c,y,w,L,s),s&&I&2048&&Mc(y.alternate,y);break;default:Ll(c,y,w,L,s)}t=t.sibling}}function Ki(e,t){if(t.subtreeFlags&10256)for(t=t.child;t!==null;){var a=e,i=t,s=i.flags;switch(i.tag){case 22:Ki(a,i),s&2048&&Ac(i.alternate,i);break;case 24:Ki(a,i),s&2048&&Mc(i.alternate,i);break;default:Ki(a,i)}t=t.sibling}}var Ii=8192;function Ul(e,t,a){if(e.subtreeFlags&Ii)for(e=e.child;e!==null;)Kg(e,t,a),e=e.sibling}function Kg(e,t,a){switch(e.tag){case 26:Ul(e,t,a),e.flags&Ii&&e.memoizedState!==null&&zx(a,an,e.memoizedState,e.memoizedProps);break;case 5:Ul(e,t,a);break;case 3:case 4:var i=an;an=Ir(e.stateNode.containerInfo),Ul(e,t,a),an=i;break;case 22:e.memoizedState===null&&(i=e.alternate,i!==null&&i.memoizedState!==null?(i=Ii,Ii=16777216,Ul(e,t,a),Ii=i):Ul(e,t,a));break;default:Ul(e,t,a)}}function Ig(e){var t=e.alternate;if(t!==null&&(e=t.child,e!==null)){t.child=null;do t=e.sibling,e.sibling=null,e=t;while(e!==null)}}function Ji(e){var t=e.deletions;if((e.flags&16)!==0){if(t!==null)for(var a=0;a<t.length;a++){var i=t[a];ct=i,Wg(i,e)}Ig(e)}if(e.subtreeFlags&10256)for(e=e.child;e!==null;)Jg(e),e=e.sibling}function Jg(e){switch(e.tag){case 0:case 11:case 15:Ji(e),e.flags&2048&&fa(9,e,e.return);break;case 3:Ji(e);break;case 12:Ji(e);break;case 22:var t=e.stateNode;e.memoizedState!==null&&t._visibility&2&&(e.return===null||e.return.tag!==13)?(t._visibility&=-3,Hr(e)):Ji(e);break;default:Ji(e)}}function Hr(e){var t=e.deletions;if((e.flags&16)!==0){if(t!==null)for(var a=0;a<t.length;a++){var i=t[a];ct=i,Wg(i,e)}Ig(e)}for(e=e.child;e!==null;){switch(t=e,t.tag){case 0:case 11:case 15:fa(8,t,t.return),Hr(t);break;case 22:a=t.stateNode,a._visibility&2&&(a._visibility&=-3,Hr(t));break;default:Hr(t)}e=e.sibling}}function Wg(e,t){for(;ct!==null;){var a=ct;switch(a.tag){case 0:case 11:case 15:fa(8,a,t);break;case 23:case 22:if(a.memoizedState!==null&&a.memoizedState.cachePool!==null){var i=a.memoizedState.cachePool.pool;i!=null&&i.refCount++}break;case 24:Ri(a.memoizedState.cache)}if(i=a.child,i!==null)i.return=a,ct=i;else e:for(a=e;ct!==null;){i=ct;var s=i.sibling,c=i.return;if(qg(i),i===a){ct=null;break e}if(s!==null){s.return=c,ct=s;break e}ct=c}}}var Xb={getCacheForType:function(e){var t=ht(nt),a=t.data.get(e);return a===void 0&&(a=e(),t.data.set(e,a)),a},cacheSignal:function(){return ht(nt).controller.signal}},Qb=typeof WeakMap=="function"?WeakMap:Map,Be=0,Ve=null,ze=null,De=0,Le=0,Lt=null,da=!1,Gl=!1,zc=!1,Vn=0,We=0,ha=0,Ja=0,Cc=0,Ut=0,ql=0,Wi=null,zt=null,Dc=!1,Br=0,Fg=0,Lr=1/0,Ur=null,ga=null,ut=0,ma=null,Yl=null,Xn=0,kc=0,Rc=null,Pg=null,Fi=0,jc=null;function Gt(){return(Be&2)!==0&&De!==0?De&-De:M.T!==null?Gc():Xo()}function e0(){if(Ut===0)if((De&536870912)===0||Re){var e=cl;cl<<=1,(cl&3932160)===0&&(cl=262144),Ut=e}else Ut=536870912;return e=Ht.current,e!==null&&(e.flags|=32),Ut}function Ct(e,t,a){(e===Ve&&(Le===2||Le===9)||e.cancelPendingCommit!==null)&&(Vl(e,0),ya(e,De,Ut,!1)),ka(e,a),((Be&2)===0||e!==Ve)&&(e===Ve&&((Be&2)===0&&(Ja|=a),We===4&&ya(e,De,Ut,!1)),vn(e))}function t0(e,t,a){if((Be&6)!==0)throw Error(r(327));var i=!a&&(t&127)===0&&(t&e.expiredLanes)===0||Da(e,t),s=i?Kb(e,t):Hc(e,t,!0),c=i;do{if(s===0){Gl&&!i&&ya(e,t,0,!1);break}else{if(a=e.current.alternate,c&&!$b(a)){s=Hc(e,t,!1),c=!1;continue}if(s===2){if(c=t,e.errorRecoveryDisabledLanes&c)var y=0;else y=e.pendingLanes&-536870913,y=y!==0?y:y&536870912?536870912:0;if(y!==0){t=y;e:{var w=e;s=Wi;var L=w.current.memoizedState.isDehydrated;if(L&&(Vl(w,y).flags|=256),y=Hc(w,y,!1),y!==2){if(zc&&!L){w.errorRecoveryDisabledLanes|=c,Ja|=c,s=4;break e}c=zt,zt=s,c!==null&&(zt===null?zt=c:zt.push.apply(zt,c))}s=y}if(c=!1,s!==2)continue}}if(s===1){Vl(e,0),ya(e,t,0,!0);break}e:{switch(i=e,c=s,c){case 0:case 1:throw Error(r(345));case 4:if((t&4194048)!==t)break;case 6:ya(i,t,Ut,!da);break e;case 2:zt=null;break;case 3:case 5:break;default:throw Error(r(329))}if((t&62914560)===t&&(s=Br+300-Fe(),10<s)){if(ya(i,t,Ut,!da),dl(i,0,!0)!==0)break e;Xn=t,i.timeoutHandle=k0(n0.bind(null,i,a,zt,Ur,Dc,t,Ut,Ja,ql,da,c,"Throttled",-0,0),s);break e}n0(i,a,zt,Ur,Dc,t,Ut,Ja,ql,da,c,null,-0,0)}}break}while(!0);vn(e)}function n0(e,t,a,i,s,c,y,w,L,I,oe,ue,F,te){if(e.timeoutHandle=-1,ue=t.subtreeFlags,ue&8192||(ue&16785408)===16785408){ue={stylesheets:null,count:0,imgCount:0,imgBytes:0,suspenseyImages:[],waitingForImages:!0,waitingForViewTransition:!1,unsuspend:zn},Kg(t,c,ue);var ve=(c&62914560)===c?Br-Fe():(c&4194048)===c?Fg-Fe():0;if(ve=Cx(ue,ve),ve!==null){Xn=c,e.cancelPendingCommit=ve(c0.bind(null,e,t,c,a,i,s,y,w,L,oe,ue,null,F,te)),ya(e,c,y,!I);return}}c0(e,t,c,a,i,s,y,w,L)}function $b(e){for(var t=e;;){var a=t.tag;if((a===0||a===11||a===15)&&t.flags&16384&&(a=t.updateQueue,a!==null&&(a=a.stores,a!==null)))for(var i=0;i<a.length;i++){var s=a[i],c=s.getSnapshot;s=s.value;try{if(!jt(c(),s))return!1}catch{return!1}}if(a=t.child,t.subtreeFlags&16384&&a!==null)a.return=t,t=a;else{if(t===e)break;for(;t.sibling===null;){if(t.return===null||t.return===e)return!0;t=t.return}t.sibling.return=t.return,t=t.sibling}}return!0}function ya(e,t,a,i){t&=~Cc,t&=~Ja,e.suspendedLanes|=t,e.pingedLanes&=~t,i&&(e.warmLanes|=t),i=e.expirationTimes;for(var s=t;0<s;){var c=31-xt(s),y=1<<c;i[c]=-1,s&=~y}a!==0&&qo(e,a,t)}function Gr(){return(Be&6)===0?(Pi(0),!1):!0}function Oc(){if(ze!==null){if(Le===0)var e=ze.return;else e=ze,Rn=qa=null,Ws(e),Rl=null,Oi=0,e=ze;for(;e!==null;)Rg(e.alternate,e),e=e.return;ze=null}}function Vl(e,t){var a=e.timeoutHandle;a!==-1&&(e.timeoutHandle=-1,dx(a)),a=e.cancelPendingCommit,a!==null&&(e.cancelPendingCommit=null,a()),Xn=0,Oc(),Ve=e,ze=a=Dn(e.current,null),De=t,Le=0,Lt=null,da=!1,Gl=Da(e,t),zc=!1,ql=Ut=Cc=Ja=ha=We=0,zt=Wi=null,Dc=!1,(t&8)!==0&&(t|=t&32);var i=e.entangledLanes;if(i!==0)for(e=e.entanglements,i&=t;0<i;){var s=31-xt(i),c=1<<s;t|=e[s],i&=~c}return Vn=t,rr(),a}function a0(e,t){Te=null,M.H=Vi,t===kl||t===mr?(t=bh(),Le=3):t===Us?(t=bh(),Le=4):Le=t===hc?8:t!==null&&typeof t=="object"&&typeof t.then=="function"?6:1,Lt=t,ze===null&&(We=1,zr(e,Kt(t,e.current)))}function l0(){var e=Ht.current;return e===null?!0:(De&4194048)===De?Ft===null:(De&62914560)===De||(De&536870912)!==0?e===Ft:!1}function i0(){var e=M.H;return M.H=Vi,e===null?Vi:e}function o0(){var e=M.A;return M.A=Xb,e}function qr(){We=4,da||(De&4194048)!==De&&Ht.current!==null||(Gl=!0),(ha&134217727)===0&&(Ja&134217727)===0||Ve===null||ya(Ve,De,Ut,!1)}function Hc(e,t,a){var i=Be;Be|=2;var s=i0(),c=o0();(Ve!==e||De!==t)&&(Ur=null,Vl(e,t)),t=!1;var y=We;e:do try{if(Le!==0&&ze!==null){var w=ze,L=Lt;switch(Le){case 8:Oc(),y=6;break e;case 3:case 2:case 9:case 6:Ht.current===null&&(t=!0);var I=Le;if(Le=0,Lt=null,Xl(e,w,L,I),a&&Gl){y=0;break e}break;default:I=Le,Le=0,Lt=null,Xl(e,w,L,I)}}Zb(),y=We;break}catch(oe){a0(e,oe)}while(!0);return t&&e.shellSuspendCounter++,Rn=qa=null,Be=i,M.H=s,M.A=c,ze===null&&(Ve=null,De=0,rr()),y}function Zb(){for(;ze!==null;)r0(ze)}function Kb(e,t){var a=Be;Be|=2;var i=i0(),s=o0();Ve!==e||De!==t?(Ur=null,Lr=Fe()+500,Vl(e,t)):Gl=Da(e,t);e:do try{if(Le!==0&&ze!==null){t=ze;var c=Lt;t:switch(Le){case 1:Le=0,Lt=null,Xl(e,t,c,1);break;case 2:case 9:if(ph(c)){Le=0,Lt=null,u0(t);break}t=function(){Le!==2&&Le!==9||Ve!==e||(Le=7),vn(e)},c.then(t,t);break e;case 3:Le=7;break e;case 4:Le=5;break e;case 7:ph(c)?(Le=0,Lt=null,u0(t)):(Le=0,Lt=null,Xl(e,t,c,7));break;case 5:var y=null;switch(ze.tag){case 26:y=ze.memoizedState;case 5:case 27:var w=ze;if(y?Z0(y):w.stateNode.complete){Le=0,Lt=null;var L=w.sibling;if(L!==null)ze=L;else{var I=w.return;I!==null?(ze=I,Yr(I)):ze=null}break t}}Le=0,Lt=null,Xl(e,t,c,5);break;case 6:Le=0,Lt=null,Xl(e,t,c,6);break;case 8:Oc(),We=6;break e;default:throw Error(r(462))}}Ib();break}catch(oe){a0(e,oe)}while(!0);return Rn=qa=null,M.H=i,M.A=s,Be=a,ze!==null?0:(Ve=null,De=0,rr(),We)}function Ib(){for(;ze!==null&&!za();)r0(ze)}function r0(e){var t=Dg(e.alternate,e,Vn);e.memoizedProps=e.pendingProps,t===null?Yr(e):ze=t}function u0(e){var t=e,a=t.alternate;switch(t.tag){case 15:case 0:t=Ng(a,t,t.pendingProps,t.type,void 0,De);break;case 11:t=Ng(a,t,t.pendingProps,t.type.render,t.ref,De);break;case 5:Ws(t);default:Rg(a,t),t=ze=oh(t,Vn),t=Dg(a,t,Vn)}e.memoizedProps=e.pendingProps,t===null?Yr(e):ze=t}function Xl(e,t,a,i){Rn=qa=null,Ws(t),Rl=null,Oi=0;var s=t.return;try{if(Bb(e,s,t,a,De)){We=1,zr(e,Kt(a,e.current)),ze=null;return}}catch(c){if(s!==null)throw ze=s,c;We=1,zr(e,Kt(a,e.current)),ze=null;return}t.flags&32768?(Re||i===1?e=!0:Gl||(De&536870912)!==0?e=!1:(da=e=!0,(i===2||i===9||i===3||i===6)&&(i=Ht.current,i!==null&&i.tag===13&&(i.flags|=16384))),s0(t,e)):Yr(t)}function Yr(e){var t=e;do{if((t.flags&32768)!==0){s0(t,da);return}e=t.return;var a=Gb(t.alternate,t,Vn);if(a!==null){ze=a;return}if(t=t.sibling,t!==null){ze=t;return}ze=t=e}while(t!==null);We===0&&(We=5)}function s0(e,t){do{var a=qb(e.alternate,e);if(a!==null){a.flags&=32767,ze=a;return}if(a=e.return,a!==null&&(a.flags|=32768,a.subtreeFlags=0,a.deletions=null),!t&&(e=e.sibling,e!==null)){ze=e;return}ze=e=a}while(e!==null);We=6,ze=null}function c0(e,t,a,i,s,c,y,w,L){e.cancelPendingCommit=null;do Vr();while(ut!==0);if((Be&6)!==0)throw Error(r(327));if(t!==null){if(t===e.current)throw Error(r(177));if(c=t.lanes|t.childLanes,c|=Es,ts(e,a,c,y,w,L),e===Ve&&(ze=Ve=null,De=0),Yl=t,ma=e,Xn=a,kc=c,Rc=s,Pg=i,(t.subtreeFlags&10256)!==0||(t.flags&10256)!==0?(e.callbackNode=null,e.callbackPriority=0,Pb($t,function(){return m0(),null})):(e.callbackNode=null,e.callbackPriority=0),i=(t.flags&13878)!==0,(t.subtreeFlags&13878)!==0||i){i=M.T,M.T=null,s=B.p,B.p=2,y=Be,Be|=4;try{Yb(e,t,a)}finally{Be=y,B.p=s,M.T=i}}ut=1,f0(),d0(),h0()}}function f0(){if(ut===1){ut=0;var e=ma,t=Yl,a=(t.flags&13878)!==0;if((t.subtreeFlags&13878)!==0||a){a=M.T,M.T=null;var i=B.p;B.p=2;var s=Be;Be|=4;try{Qg(t,e);var c=Kc,y=Wd(e.containerInfo),w=c.focusedElem,L=c.selectionRange;if(y!==w&&w&&w.ownerDocument&&Jd(w.ownerDocument.documentElement,w)){if(L!==null&&bs(w)){var I=L.start,oe=L.end;if(oe===void 0&&(oe=I),"selectionStart"in w)w.selectionStart=I,w.selectionEnd=Math.min(oe,w.value.length);else{var ue=w.ownerDocument||document,F=ue&&ue.defaultView||window;if(F.getSelection){var te=F.getSelection(),ve=w.textContent.length,Se=Math.min(L.start,ve),Ye=L.end===void 0?Se:Math.min(L.end,ve);!te.extend&&Se>Ye&&(y=Ye,Ye=Se,Se=y);var Q=Id(w,Se),G=Id(w,Ye);if(Q&&G&&(te.rangeCount!==1||te.anchorNode!==Q.node||te.anchorOffset!==Q.offset||te.focusNode!==G.node||te.focusOffset!==G.offset)){var K=ue.createRange();K.setStart(Q.node,Q.offset),te.removeAllRanges(),Se>Ye?(te.addRange(K),te.extend(G.node,G.offset)):(K.setEnd(G.node,G.offset),te.addRange(K))}}}}for(ue=[],te=w;te=te.parentNode;)te.nodeType===1&&ue.push({element:te,left:te.scrollLeft,top:te.scrollTop});for(typeof w.focus=="function"&&w.focus(),w=0;w<ue.length;w++){var re=ue[w];re.element.scrollLeft=re.left,re.element.scrollTop=re.top}}tu=!!Zc,Kc=Zc=null}finally{Be=s,B.p=i,M.T=a}}e.current=t,ut=2}}function d0(){if(ut===2){ut=0;var e=ma,t=Yl,a=(t.flags&8772)!==0;if((t.subtreeFlags&8772)!==0||a){a=M.T,M.T=null;var i=B.p;B.p=2;var s=Be;Be|=4;try{Gg(e,t.alternate,t)}finally{Be=s,B.p=i,M.T=a}}ut=3}}function h0(){if(ut===4||ut===3){ut=0,Nn();var e=ma,t=Yl,a=Xn,i=Pg;(t.subtreeFlags&10256)!==0||(t.flags&10256)!==0?ut=5:(ut=0,Yl=ma=null,g0(e,e.pendingLanes));var s=e.pendingLanes;if(s===0&&(ga=null),mi(a),t=t.stateNode,bt&&typeof bt.onCommitFiberRoot=="function")try{bt.onCommitFiberRoot(Ca,t,void 0,(t.current.flags&128)===128)}catch{}if(i!==null){t=M.T,s=B.p,B.p=2,M.T=null;try{for(var c=e.onRecoverableError,y=0;y<i.length;y++){var w=i[y];c(w.value,{componentStack:w.stack})}}finally{M.T=t,B.p=s}}(Xn&3)!==0&&Vr(),vn(e),s=e.pendingLanes,(a&261930)!==0&&(s&42)!==0?e===jc?Fi++:(Fi=0,jc=e):Fi=0,Pi(0)}}function g0(e,t){(e.pooledCacheLanes&=t)===0&&(t=e.pooledCache,t!=null&&(e.pooledCache=null,Ri(t)))}function Vr(){return f0(),d0(),h0(),m0()}function m0(){if(ut!==5)return!1;var e=ma,t=kc;kc=0;var a=mi(Xn),i=M.T,s=B.p;try{B.p=32>a?32:a,M.T=null,a=Rc,Rc=null;var c=ma,y=Xn;if(ut=0,Yl=ma=null,Xn=0,(Be&6)!==0)throw Error(r(331));var w=Be;if(Be|=4,Jg(c.current),Zg(c,c.current,y,a),Be=w,Pi(0,!1),bt&&typeof bt.onPostCommitFiberRoot=="function")try{bt.onPostCommitFiberRoot(Ca,c)}catch{}return!0}finally{B.p=s,M.T=i,g0(e,t)}}function y0(e,t,a){t=Kt(a,t),t=dc(e.stateNode,t,2),e=ua(e,t,2),e!==null&&(ka(e,2),vn(e))}function Ue(e,t,a){if(e.tag===3)y0(e,e,a);else for(;t!==null;){if(t.tag===3){y0(t,e,a);break}else if(t.tag===1){var i=t.stateNode;if(typeof t.type.getDerivedStateFromError=="function"||typeof i.componentDidCatch=="function"&&(ga===null||!ga.has(i))){e=Kt(a,e),a=pg(2),i=ua(t,a,2),i!==null&&(vg(a,i,t,e),ka(i,2),vn(i));break}}t=t.return}}function Bc(e,t,a){var i=e.pingCache;if(i===null){i=e.pingCache=new Qb;var s=new Set;i.set(t,s)}else s=i.get(t),s===void 0&&(s=new Set,i.set(t,s));s.has(a)||(zc=!0,s.add(a),e=Jb.bind(null,e,t,a),t.then(e,e))}function Jb(e,t,a){var i=e.pingCache;i!==null&&i.delete(t),e.pingedLanes|=e.suspendedLanes&a,e.warmLanes&=~a,Ve===e&&(De&a)===a&&(We===4||We===3&&(De&62914560)===De&&300>Fe()-Br?(Be&2)===0&&Vl(e,0):Cc|=a,ql===De&&(ql=0)),vn(e)}function p0(e,t){t===0&&(t=Go()),e=La(e,t),e!==null&&(ka(e,t),vn(e))}function Wb(e){var t=e.memoizedState,a=0;t!==null&&(a=t.retryLane),p0(e,a)}function Fb(e,t){var a=0;switch(e.tag){case 31:case 13:var i=e.stateNode,s=e.memoizedState;s!==null&&(a=s.retryLane);break;case 19:i=e.stateNode;break;case 22:i=e.stateNode._retryCache;break;default:throw Error(r(314))}i!==null&&i.delete(t),p0(e,a)}function Pb(e,t){return yt(e,t)}var Xr=null,Ql=null,Lc=!1,Qr=!1,Uc=!1,pa=0;function vn(e){e!==Ql&&e.next===null&&(Ql===null?Xr=Ql=e:Ql=Ql.next=e),Qr=!0,Lc||(Lc=!0,tx())}function Pi(e,t){if(!Uc&&Qr){Uc=!0;do for(var a=!1,i=Xr;i!==null;){if(e!==0){var s=i.pendingLanes;if(s===0)var c=0;else{var y=i.suspendedLanes,w=i.pingedLanes;c=(1<<31-xt(42|e)+1)-1,c&=s&~(y&~w),c=c&201326741?c&201326741|1:c?c|2:0}c!==0&&(a=!0,_0(i,c))}else c=De,c=dl(i,i===Ve?c:0,i.cancelPendingCommit!==null||i.timeoutHandle!==-1),(c&3)===0||Da(i,c)||(a=!0,_0(i,c));i=i.next}while(a);Uc=!1}}function ex(){v0()}function v0(){Qr=Lc=!1;var e=0;pa!==0&&fx()&&(e=pa);for(var t=Fe(),a=null,i=Xr;i!==null;){var s=i.next,c=b0(i,t);c===0?(i.next=null,a===null?Xr=s:a.next=s,s===null&&(Ql=a)):(a=i,(e!==0||(c&3)!==0)&&(Qr=!0)),i=s}ut!==0&&ut!==5||Pi(e),pa!==0&&(pa=0)}function b0(e,t){for(var a=e.suspendedLanes,i=e.pingedLanes,s=e.expirationTimes,c=e.pendingLanes&-62914561;0<c;){var y=31-xt(c),w=1<<y,L=s[y];L===-1?((w&a)===0||(w&i)!==0)&&(s[y]=es(w,t)):L<=t&&(e.expiredLanes|=w),c&=~w}if(t=Ve,a=De,a=dl(e,e===t?a:0,e.cancelPendingCommit!==null||e.timeoutHandle!==-1),i=e.callbackNode,a===0||e===t&&(Le===2||Le===9)||e.cancelPendingCommit!==null)return i!==null&&i!==null&&kt(i),e.callbackNode=null,e.callbackPriority=0;if((a&3)===0||Da(e,a)){if(t=a&-a,t===e.callbackPriority)return t;switch(i!==null&&kt(i),mi(a)){case 2:case 8:a=Qt;break;case 32:a=$t;break;case 268435456:a=ul;break;default:a=$t}return i=x0.bind(null,e),a=yt(a,i),e.callbackPriority=t,e.callbackNode=a,t}return i!==null&&i!==null&&kt(i),e.callbackPriority=2,e.callbackNode=null,2}function x0(e,t){if(ut!==0&&ut!==5)return e.callbackNode=null,e.callbackPriority=0,null;var a=e.callbackNode;if(Vr()&&e.callbackNode!==a)return null;var i=De;return i=dl(e,e===Ve?i:0,e.cancelPendingCommit!==null||e.timeoutHandle!==-1),i===0?null:(t0(e,i,t),b0(e,Fe()),e.callbackNode!=null&&e.callbackNode===a?x0.bind(null,e):null)}function _0(e,t){if(Vr())return null;t0(e,t,!0)}function tx(){hx(function(){(Be&6)!==0?yt(Xt,ex):v0()})}function Gc(){if(pa===0){var e=Cl;e===0&&(e=sl,sl<<=1,(sl&261888)===0&&(sl=256)),pa=e}return pa}function w0(e){return e==null||typeof e=="symbol"||typeof e=="boolean"?null:typeof e=="function"?e:Po(""+e)}function S0(e,t){var a=t.ownerDocument.createElement("input");return a.name=t.name,a.value=t.value,e.id&&a.setAttribute("form",e.id),t.parentNode.insertBefore(a,t),e=new FormData(e),a.parentNode.removeChild(a),e}function nx(e,t,a,i,s){if(t==="submit"&&a&&a.stateNode===s){var c=w0((s[pt]||null).action),y=i.submitter;y&&(t=(t=y[pt]||null)?w0(t.formAction):y.getAttribute("formAction"),t!==null&&(c=t,y=null));var w=new ar("action","action",null,i,s);e.push({event:w,listeners:[{instance:null,listener:function(){if(i.defaultPrevented){if(pa!==0){var L=y?S0(s,y):new FormData(s);oc(a,{pending:!0,data:L,method:s.method,action:c},null,L)}}else typeof c=="function"&&(w.preventDefault(),L=y?S0(s,y):new FormData(s),oc(a,{pending:!0,data:L,method:s.method,action:c},c,L))},currentTarget:s}]})}}for(var qc=0;qc<Ss.length;qc++){var Yc=Ss[qc],ax=Yc.toLowerCase(),lx=Yc[0].toUpperCase()+Yc.slice(1);nn(ax,"on"+lx)}nn(eh,"onAnimationEnd"),nn(th,"onAnimationIteration"),nn(nh,"onAnimationStart"),nn("dblclick","onDoubleClick"),nn("focusin","onFocus"),nn("focusout","onBlur"),nn(xb,"onTransitionRun"),nn(_b,"onTransitionStart"),nn(wb,"onTransitionCancel"),nn(ah,"onTransitionEnd"),Pn("onMouseEnter",["mouseout","mouseover"]),Pn("onMouseLeave",["mouseout","mouseover"]),Pn("onPointerEnter",["pointerout","pointerover"]),Pn("onPointerLeave",["pointerout","pointerover"]),Mn("onChange","change click focusin focusout input keydown keyup selectionchange".split(" ")),Mn("onSelect","focusout contextmenu dragend focusin keydown keyup mousedown mouseup selectionchange".split(" ")),Mn("onBeforeInput",["compositionend","keypress","textInput","paste"]),Mn("onCompositionEnd","compositionend focusout keydown keypress keyup mousedown".split(" ")),Mn("onCompositionStart","compositionstart focusout keydown keypress keyup mousedown".split(" ")),Mn("onCompositionUpdate","compositionupdate focusout keydown keypress keyup mousedown".split(" "));var eo="abort canplay canplaythrough durationchange emptied encrypted ended error loadeddata loadedmetadata loadstart pause play playing progress ratechange resize seeked seeking stalled suspend timeupdate volumechange waiting".split(" "),ix=new Set("beforetoggle cancel close invalid load scroll scrollend toggle".split(" ").concat(eo));function E0(e,t){t=(t&4)!==0;for(var a=0;a<e.length;a++){var i=e[a],s=i.event;i=i.listeners;e:{var c=void 0;if(t)for(var y=i.length-1;0<=y;y--){var w=i[y],L=w.instance,I=w.currentTarget;if(w=w.listener,L!==c&&s.isPropagationStopped())break e;c=w,s.currentTarget=I;try{c(s)}catch(oe){or(oe)}s.currentTarget=null,c=L}else for(y=0;y<i.length;y++){if(w=i[y],L=w.instance,I=w.currentTarget,w=w.listener,L!==c&&s.isPropagationStopped())break e;c=w,s.currentTarget=I;try{c(s)}catch(oe){or(oe)}s.currentTarget=null,c=L}}}}function Ce(e,t){var a=t[hl];a===void 0&&(a=t[hl]=new Set);var i=e+"__bubble";a.has(i)||(N0(t,e,2,!1),a.add(i))}function Vc(e,t,a){var i=0;t&&(i|=4),N0(a,e,i,t)}var $r="_reactListening"+Math.random().toString(36).slice(2);function Xc(e){if(!e[$r]){e[$r]=!0,Ko.forEach(function(a){a!=="selectionchange"&&(ix.has(a)||Vc(a,!1,e),Vc(a,!0,e))});var t=e.nodeType===9?e:e.ownerDocument;t===null||t[$r]||(t[$r]=!0,Vc("selectionchange",!1,t))}}function N0(e,t,a,i){switch(em(t)){case 2:var s=Rx;break;case 8:s=jx;break;default:s=of}a=s.bind(null,t,a,e),s=void 0,!cs||t!=="touchstart"&&t!=="touchmove"&&t!=="wheel"||(s=!0),i?s!==void 0?e.addEventListener(t,a,{capture:!0,passive:s}):e.addEventListener(t,a,!0):s!==void 0?e.addEventListener(t,a,{passive:s}):e.addEventListener(t,a,!1)}function Qc(e,t,a,i,s){var c=i;if((t&1)===0&&(t&2)===0&&i!==null)e:for(;;){if(i===null)return;var y=i.tag;if(y===3||y===4){var w=i.stateNode.containerInfo;if(w===s)break;if(y===4)for(y=i.return;y!==null;){var L=y.tag;if((L===3||L===4)&&y.stateNode.containerInfo===s)return;y=y.return}for(;w!==null;){if(y=In(w),y===null)return;if(L=y.tag,L===5||L===6||L===26||L===27){i=c=y;continue e}w=w.parentNode}}i=i.return}Cd(function(){var I=c,oe=us(a),ue=[];e:{var F=lh.get(e);if(F!==void 0){var te=ar,ve=e;switch(e){case"keypress":if(tr(a)===0)break e;case"keydown":case"keyup":te=Fv;break;case"focusin":ve="focus",te=gs;break;case"focusout":ve="blur",te=gs;break;case"beforeblur":case"afterblur":te=gs;break;case"click":if(a.button===2)break e;case"auxclick":case"dblclick":case"mousedown":case"mousemove":case"mouseup":case"mouseout":case"mouseover":case"contextmenu":te=Rd;break;case"drag":case"dragend":case"dragenter":case"dragexit":case"dragleave":case"dragover":case"dragstart":case"drop":te=Gv;break;case"touchcancel":case"touchend":case"touchmove":case"touchstart":te=tb;break;case eh:case th:case nh:te=Vv;break;case ah:te=ab;break;case"scroll":case"scrollend":te=Lv;break;case"wheel":te=ib;break;case"copy":case"cut":case"paste":te=Qv;break;case"gotpointercapture":case"lostpointercapture":case"pointercancel":case"pointerdown":case"pointermove":case"pointerout":case"pointerover":case"pointerup":te=Od;break;case"toggle":case"beforetoggle":te=rb}var Se=(t&4)!==0,Ye=!Se&&(e==="scroll"||e==="scrollend"),Q=Se?F!==null?F+"Capture":null:F;Se=[];for(var G=I,K;G!==null;){var re=G;if(K=re.stateNode,re=re.tag,re!==5&&re!==26&&re!==27||K===null||Q===null||(re=wi(G,Q),re!=null&&Se.push(to(G,re,K))),Ye)break;G=G.return}0<Se.length&&(F=new te(F,ve,null,a,oe),ue.push({event:F,listeners:Se}))}}if((t&7)===0){e:{if(F=e==="mouseover"||e==="pointerover",te=e==="mouseout"||e==="pointerout",F&&a!==rs&&(ve=a.relatedTarget||a.fromElement)&&(In(ve)||ve[An]))break e;if((te||F)&&(F=oe.window===oe?oe:(F=oe.ownerDocument)?F.defaultView||F.parentWindow:window,te?(ve=a.relatedTarget||a.toElement,te=I,ve=ve?In(ve):null,ve!==null&&(Ye=f(ve),Se=ve.tag,ve!==Ye||Se!==5&&Se!==27&&Se!==6)&&(ve=null)):(te=null,ve=I),te!==ve)){if(Se=Rd,re="onMouseLeave",Q="onMouseEnter",G="mouse",(e==="pointerout"||e==="pointerover")&&(Se=Od,re="onPointerLeave",Q="onPointerEnter",G="pointer"),Ye=te==null?F:Wn(te),K=ve==null?F:Wn(ve),F=new Se(re,G+"leave",te,a,oe),F.target=Ye,F.relatedTarget=K,re=null,In(oe)===I&&(Se=new Se(Q,G+"enter",ve,a,oe),Se.target=K,Se.relatedTarget=Ye,re=Se),Ye=re,te&&ve)t:{for(Se=ox,Q=te,G=ve,K=0,re=Q;re;re=Se(re))K++;re=0;for(var _e=G;_e;_e=Se(_e))re++;for(;0<K-re;)Q=Se(Q),K--;for(;0<re-K;)G=Se(G),re--;for(;K--;){if(Q===G||G!==null&&Q===G.alternate){Se=Q;break t}Q=Se(Q),G=Se(G)}Se=null}else Se=null;te!==null&&T0(ue,F,te,Se,!1),ve!==null&&Ye!==null&&T0(ue,Ye,ve,Se,!0)}}e:{if(F=I?Wn(I):window,te=F.nodeName&&F.nodeName.toLowerCase(),te==="select"||te==="input"&&F.type==="file")var Oe=Vd;else if(qd(F))if(Xd)Oe=pb;else{Oe=mb;var be=gb}else te=F.nodeName,!te||te.toLowerCase()!=="input"||F.type!=="checkbox"&&F.type!=="radio"?I&&os(I.elementType)&&(Oe=Vd):Oe=yb;if(Oe&&(Oe=Oe(e,I))){Yd(ue,Oe,a,oe);break e}be&&be(e,F,I),e==="focusout"&&I&&F.type==="number"&&I.memoizedProps.value!=null&&xi(F,"number",F.value)}switch(be=I?Wn(I):window,e){case"focusin":(qd(be)||be.contentEditable==="true")&&(wl=be,xs=I,Ci=null);break;case"focusout":Ci=xs=wl=null;break;case"mousedown":_s=!0;break;case"contextmenu":case"mouseup":case"dragend":_s=!1,Fd(ue,a,oe);break;case"selectionchange":if(bb)break;case"keydown":case"keyup":Fd(ue,a,oe)}var Me;if(ys)e:{switch(e){case"compositionstart":var ke="onCompositionStart";break e;case"compositionend":ke="onCompositionEnd";break e;case"compositionupdate":ke="onCompositionUpdate";break e}ke=void 0}else _l?Ud(e,a)&&(ke="onCompositionEnd"):e==="keydown"&&a.keyCode===229&&(ke="onCompositionStart");ke&&(Hd&&a.locale!=="ko"&&(_l||ke!=="onCompositionStart"?ke==="onCompositionEnd"&&_l&&(Me=Dd()):(ta=oe,fs="value"in ta?ta.value:ta.textContent,_l=!0)),be=Zr(I,ke),0<be.length&&(ke=new jd(ke,e,null,a,oe),ue.push({event:ke,listeners:be}),Me?ke.data=Me:(Me=Gd(a),Me!==null&&(ke.data=Me)))),(Me=sb?cb(e,a):fb(e,a))&&(ke=Zr(I,"onBeforeInput"),0<ke.length&&(be=new jd("onBeforeInput","beforeinput",null,a,oe),ue.push({event:be,listeners:ke}),be.data=Me)),nx(ue,e,I,a,oe)}E0(ue,t)})}function to(e,t,a){return{instance:e,listener:t,currentTarget:a}}function Zr(e,t){for(var a=t+"Capture",i=[];e!==null;){var s=e,c=s.stateNode;if(s=s.tag,s!==5&&s!==26&&s!==27||c===null||(s=wi(e,a),s!=null&&i.unshift(to(e,s,c)),s=wi(e,t),s!=null&&i.push(to(e,s,c))),e.tag===3)return i;e=e.return}return[]}function ox(e){if(e===null)return null;do e=e.return;while(e&&e.tag!==5&&e.tag!==27);return e||null}function T0(e,t,a,i,s){for(var c=t._reactName,y=[];a!==null&&a!==i;){var w=a,L=w.alternate,I=w.stateNode;if(w=w.tag,L!==null&&L===i)break;w!==5&&w!==26&&w!==27||I===null||(L=I,s?(I=wi(a,c),I!=null&&y.unshift(to(a,I,L))):s||(I=wi(a,c),I!=null&&y.push(to(a,I,L)))),a=a.return}y.length!==0&&e.push({event:t,listeners:y})}var rx=/\r\n?/g,ux=/\u0000|\uFFFD/g;function A0(e){return(typeof e=="string"?e:""+e).replace(rx,`
+`).replace(ux,"")}function M0(e,t){return t=A0(t),A0(e)===t}function qe(e,t,a,i,s,c){switch(a){case"children":typeof i=="string"?t==="body"||t==="textarea"&&i===""||vl(e,i):(typeof i=="number"||typeof i=="bigint")&&t!=="body"&&vl(e,""+i);break;case"className":ml(e,"class",i);break;case"tabIndex":ml(e,"tabindex",i);break;case"dir":case"role":case"viewBox":case"width":case"height":ml(e,a,i);break;case"style":Md(e,i,c);break;case"data":if(t!=="object"){ml(e,"data",i);break}case"src":case"href":if(i===""&&(t!=="a"||a!=="href")){e.removeAttribute(a);break}if(i==null||typeof i=="function"||typeof i=="symbol"||typeof i=="boolean"){e.removeAttribute(a);break}i=Po(""+i),e.setAttribute(a,i);break;case"action":case"formAction":if(typeof i=="function"){e.setAttribute(a,"javascript:throw new Error('A React form was unexpectedly submitted. If you called form.submit() manually, consider using form.requestSubmit() instead. If you\\'re trying to use event.stopPropagation() in a submit event handler, consider also calling event.preventDefault().')");break}else typeof c=="function"&&(a==="formAction"?(t!=="input"&&qe(e,t,"name",s.name,s,null),qe(e,t,"formEncType",s.formEncType,s,null),qe(e,t,"formMethod",s.formMethod,s,null),qe(e,t,"formTarget",s.formTarget,s,null)):(qe(e,t,"encType",s.encType,s,null),qe(e,t,"method",s.method,s,null),qe(e,t,"target",s.target,s,null)));if(i==null||typeof i=="symbol"||typeof i=="boolean"){e.removeAttribute(a);break}i=Po(""+i),e.setAttribute(a,i);break;case"onClick":i!=null&&(e.onclick=zn);break;case"onScroll":i!=null&&Ce("scroll",e);break;case"onScrollEnd":i!=null&&Ce("scrollend",e);break;case"dangerouslySetInnerHTML":if(i!=null){if(typeof i!="object"||!("__html"in i))throw Error(r(61));if(a=i.__html,a!=null){if(s.children!=null)throw Error(r(60));e.innerHTML=a}}break;case"multiple":e.multiple=i&&typeof i!="function"&&typeof i!="symbol";break;case"muted":e.muted=i&&typeof i!="function"&&typeof i!="symbol";break;case"suppressContentEditableWarning":case"suppressHydrationWarning":case"defaultValue":case"defaultChecked":case"innerHTML":case"ref":break;case"autoFocus":break;case"xlinkHref":if(i==null||typeof i=="function"||typeof i=="boolean"||typeof i=="symbol"){e.removeAttribute("xlink:href");break}a=Po(""+i),e.setAttributeNS("http://www.w3.org/1999/xlink","xlink:href",a);break;case"contentEditable":case"spellCheck":case"draggable":case"value":case"autoReverse":case"externalResourcesRequired":case"focusable":case"preserveAlpha":i!=null&&typeof i!="function"&&typeof i!="symbol"?e.setAttribute(a,""+i):e.removeAttribute(a);break;case"inert":case"allowFullScreen":case"async":case"autoPlay":case"controls":case"default":case"defer":case"disabled":case"disablePictureInPicture":case"disableRemotePlayback":case"formNoValidate":case"hidden":case"loop":case"noModule":case"noValidate":case"open":case"playsInline":case"readOnly":case"required":case"reversed":case"scoped":case"seamless":case"itemScope":i&&typeof i!="function"&&typeof i!="symbol"?e.setAttribute(a,""):e.removeAttribute(a);break;case"capture":case"download":i===!0?e.setAttribute(a,""):i!==!1&&i!=null&&typeof i!="function"&&typeof i!="symbol"?e.setAttribute(a,i):e.removeAttribute(a);break;case"cols":case"rows":case"size":case"span":i!=null&&typeof i!="function"&&typeof i!="symbol"&&!isNaN(i)&&1<=i?e.setAttribute(a,i):e.removeAttribute(a);break;case"rowSpan":case"start":i==null||typeof i=="function"||typeof i=="symbol"||isNaN(i)?e.removeAttribute(a):e.setAttribute(a,i);break;case"popover":Ce("beforetoggle",e),Ce("toggle",e),gl(e,"popover",i);break;case"xlinkActuate":tn(e,"http://www.w3.org/1999/xlink","xlink:actuate",i);break;case"xlinkArcrole":tn(e,"http://www.w3.org/1999/xlink","xlink:arcrole",i);break;case"xlinkRole":tn(e,"http://www.w3.org/1999/xlink","xlink:role",i);break;case"xlinkShow":tn(e,"http://www.w3.org/1999/xlink","xlink:show",i);break;case"xlinkTitle":tn(e,"http://www.w3.org/1999/xlink","xlink:title",i);break;case"xlinkType":tn(e,"http://www.w3.org/1999/xlink","xlink:type",i);break;case"xmlBase":tn(e,"http://www.w3.org/XML/1998/namespace","xml:base",i);break;case"xmlLang":tn(e,"http://www.w3.org/XML/1998/namespace","xml:lang",i);break;case"xmlSpace":tn(e,"http://www.w3.org/XML/1998/namespace","xml:space",i);break;case"is":gl(e,"is",i);break;case"innerText":case"textContent":break;default:(!(2<a.length)||a[0]!=="o"&&a[0]!=="O"||a[1]!=="n"&&a[1]!=="N")&&(a=Hv.get(a)||a,gl(e,a,i))}}function $c(e,t,a,i,s,c){switch(a){case"style":Md(e,i,c);break;case"dangerouslySetInnerHTML":if(i!=null){if(typeof i!="object"||!("__html"in i))throw Error(r(61));if(a=i.__html,a!=null){if(s.children!=null)throw Error(r(60));e.innerHTML=a}}break;case"children":typeof i=="string"?vl(e,i):(typeof i=="number"||typeof i=="bigint")&&vl(e,""+i);break;case"onScroll":i!=null&&Ce("scroll",e);break;case"onScrollEnd":i!=null&&Ce("scrollend",e);break;case"onClick":i!=null&&(e.onclick=zn);break;case"suppressContentEditableWarning":case"suppressHydrationWarning":case"innerHTML":case"ref":break;case"innerText":case"textContent":break;default:if(!Io.hasOwnProperty(a))e:{if(a[0]==="o"&&a[1]==="n"&&(s=a.endsWith("Capture"),t=a.slice(2,s?a.length-7:void 0),c=e[pt]||null,c=c!=null?c[a]:null,typeof c=="function"&&e.removeEventListener(t,c,s),typeof i=="function")){typeof c!="function"&&c!==null&&(a in e?e[a]=null:e.hasAttribute(a)&&e.removeAttribute(a)),e.addEventListener(t,i,s);break e}a in e?e[a]=i:i===!0?e.setAttribute(a,""):gl(e,a,i)}}}function mt(e,t,a){switch(t){case"div":case"span":case"svg":case"path":case"a":case"g":case"p":case"li":break;case"img":Ce("error",e),Ce("load",e);var i=!1,s=!1,c;for(c in a)if(a.hasOwnProperty(c)){var y=a[c];if(y!=null)switch(c){case"src":i=!0;break;case"srcSet":s=!0;break;case"children":case"dangerouslySetInnerHTML":throw Error(r(137,t));default:qe(e,t,c,y,a,null)}}s&&qe(e,t,"srcSet",a.srcSet,a,null),i&&qe(e,t,"src",a.src,a,null);return;case"input":Ce("invalid",e);var w=c=y=s=null,L=null,I=null;for(i in a)if(a.hasOwnProperty(i)){var oe=a[i];if(oe!=null)switch(i){case"name":s=oe;break;case"type":y=oe;break;case"checked":L=oe;break;case"defaultChecked":I=oe;break;case"value":c=oe;break;case"defaultValue":w=oe;break;case"children":case"dangerouslySetInnerHTML":if(oe!=null)throw Error(r(137,t));break;default:qe(e,t,i,oe,a,null)}}pl(e,c,w,L,I,y,s,!1);return;case"select":Ce("invalid",e),i=y=c=null;for(s in a)if(a.hasOwnProperty(s)&&(w=a[s],w!=null))switch(s){case"value":c=w;break;case"defaultValue":y=w;break;case"multiple":i=w;default:qe(e,t,s,w,a,null)}t=c,a=y,e.multiple=!!i,t!=null?ea(e,!!i,t,!1):a!=null&&ea(e,!!i,a,!0);return;case"textarea":Ce("invalid",e),c=s=i=null;for(y in a)if(a.hasOwnProperty(y)&&(w=a[y],w!=null))switch(y){case"value":i=w;break;case"defaultValue":s=w;break;case"children":c=w;break;case"dangerouslySetInnerHTML":if(w!=null)throw Error(r(91));break;default:qe(e,t,y,w,a,null)}Td(e,i,s,c);return;case"option":for(L in a)if(a.hasOwnProperty(L)&&(i=a[L],i!=null))switch(L){case"selected":e.selected=i&&typeof i!="function"&&typeof i!="symbol";break;default:qe(e,t,L,i,a,null)}return;case"dialog":Ce("beforetoggle",e),Ce("toggle",e),Ce("cancel",e),Ce("close",e);break;case"iframe":case"object":Ce("load",e);break;case"video":case"audio":for(i=0;i<eo.length;i++)Ce(eo[i],e);break;case"image":Ce("error",e),Ce("load",e);break;case"details":Ce("toggle",e);break;case"embed":case"source":case"link":Ce("error",e),Ce("load",e);case"area":case"base":case"br":case"col":case"hr":case"keygen":case"meta":case"param":case"track":case"wbr":case"menuitem":for(I in a)if(a.hasOwnProperty(I)&&(i=a[I],i!=null))switch(I){case"children":case"dangerouslySetInnerHTML":throw Error(r(137,t));default:qe(e,t,I,i,a,null)}return;default:if(os(t)){for(oe in a)a.hasOwnProperty(oe)&&(i=a[oe],i!==void 0&&$c(e,t,oe,i,a,void 0));return}}for(w in a)a.hasOwnProperty(w)&&(i=a[w],i!=null&&qe(e,t,w,i,a,null))}function sx(e,t,a,i){switch(t){case"div":case"span":case"svg":case"path":case"a":case"g":case"p":case"li":break;case"input":var s=null,c=null,y=null,w=null,L=null,I=null,oe=null;for(te in a){var ue=a[te];if(a.hasOwnProperty(te)&&ue!=null)switch(te){case"checked":break;case"value":break;case"defaultValue":L=ue;default:i.hasOwnProperty(te)||qe(e,t,te,null,i,ue)}}for(var F in i){var te=i[F];if(ue=a[F],i.hasOwnProperty(F)&&(te!=null||ue!=null))switch(F){case"type":c=te;break;case"name":s=te;break;case"checked":I=te;break;case"defaultChecked":oe=te;break;case"value":y=te;break;case"defaultValue":w=te;break;case"children":case"dangerouslySetInnerHTML":if(te!=null)throw Error(r(137,t));break;default:te!==ue&&qe(e,t,F,te,i,ue)}}bi(e,y,w,L,I,oe,c,s);return;case"select":te=y=w=F=null;for(c in a)if(L=a[c],a.hasOwnProperty(c)&&L!=null)switch(c){case"value":break;case"multiple":te=L;default:i.hasOwnProperty(c)||qe(e,t,c,null,i,L)}for(s in i)if(c=i[s],L=a[s],i.hasOwnProperty(s)&&(c!=null||L!=null))switch(s){case"value":F=c;break;case"defaultValue":w=c;break;case"multiple":y=c;default:c!==L&&qe(e,t,s,c,i,L)}t=w,a=y,i=te,F!=null?ea(e,!!a,F,!1):!!i!=!!a&&(t!=null?ea(e,!!a,t,!0):ea(e,!!a,a?[]:"",!1));return;case"textarea":te=F=null;for(w in a)if(s=a[w],a.hasOwnProperty(w)&&s!=null&&!i.hasOwnProperty(w))switch(w){case"value":break;case"children":break;default:qe(e,t,w,null,i,s)}for(y in i)if(s=i[y],c=a[y],i.hasOwnProperty(y)&&(s!=null||c!=null))switch(y){case"value":F=s;break;case"defaultValue":te=s;break;case"children":break;case"dangerouslySetInnerHTML":if(s!=null)throw Error(r(91));break;default:s!==c&&qe(e,t,y,s,i,c)}_i(e,F,te);return;case"option":for(var ve in a)if(F=a[ve],a.hasOwnProperty(ve)&&F!=null&&!i.hasOwnProperty(ve))switch(ve){case"selected":e.selected=!1;break;default:qe(e,t,ve,null,i,F)}for(L in i)if(F=i[L],te=a[L],i.hasOwnProperty(L)&&F!==te&&(F!=null||te!=null))switch(L){case"selected":e.selected=F&&typeof F!="function"&&typeof F!="symbol";break;default:qe(e,t,L,F,i,te)}return;case"img":case"link":case"area":case"base":case"br":case"col":case"embed":case"hr":case"keygen":case"meta":case"param":case"source":case"track":case"wbr":case"menuitem":for(var Se in a)F=a[Se],a.hasOwnProperty(Se)&&F!=null&&!i.hasOwnProperty(Se)&&qe(e,t,Se,null,i,F);for(I in i)if(F=i[I],te=a[I],i.hasOwnProperty(I)&&F!==te&&(F!=null||te!=null))switch(I){case"children":case"dangerouslySetInnerHTML":if(F!=null)throw Error(r(137,t));break;default:qe(e,t,I,F,i,te)}return;default:if(os(t)){for(var Ye in a)F=a[Ye],a.hasOwnProperty(Ye)&&F!==void 0&&!i.hasOwnProperty(Ye)&&$c(e,t,Ye,void 0,i,F);for(oe in i)F=i[oe],te=a[oe],!i.hasOwnProperty(oe)||F===te||F===void 0&&te===void 0||$c(e,t,oe,F,i,te);return}}for(var Q in a)F=a[Q],a.hasOwnProperty(Q)&&F!=null&&!i.hasOwnProperty(Q)&&qe(e,t,Q,null,i,F);for(ue in i)F=i[ue],te=a[ue],!i.hasOwnProperty(ue)||F===te||F==null&&te==null||qe(e,t,ue,F,i,te)}function z0(e){switch(e){case"css":case"script":case"font":case"img":case"image":case"input":case"link":return!0;default:return!1}}function cx(){if(typeof performance.getEntriesByType=="function"){for(var e=0,t=0,a=performance.getEntriesByType("resource"),i=0;i<a.length;i++){var s=a[i],c=s.transferSize,y=s.initiatorType,w=s.duration;if(c&&w&&z0(y)){for(y=0,w=s.responseEnd,i+=1;i<a.length;i++){var L=a[i],I=L.startTime;if(I>w)break;var oe=L.transferSize,ue=L.initiatorType;oe&&z0(ue)&&(L=L.responseEnd,y+=oe*(L<w?1:(w-I)/(L-I)))}if(--i,t+=8*(c+y)/(s.duration/1e3),e++,10<e)break}}if(0<e)return t/e/1e6}return navigator.connection&&(e=navigator.connection.downlink,typeof e=="number")?e:5}var Zc=null,Kc=null;function Kr(e){return e.nodeType===9?e:e.ownerDocument}function C0(e){switch(e){case"http://www.w3.org/2000/svg":return 1;case"http://www.w3.org/1998/Math/MathML":return 2;default:return 0}}function D0(e,t){if(e===0)switch(t){case"svg":return 1;case"math":return 2;default:return 0}return e===1&&t==="foreignObject"?0:e}function Ic(e,t){return e==="textarea"||e==="noscript"||typeof t.children=="string"||typeof t.children=="number"||typeof t.children=="bigint"||typeof t.dangerouslySetInnerHTML=="object"&&t.dangerouslySetInnerHTML!==null&&t.dangerouslySetInnerHTML.__html!=null}var Jc=null;function fx(){var e=window.event;return e&&e.type==="popstate"?e===Jc?!1:(Jc=e,!0):(Jc=null,!1)}var k0=typeof setTimeout=="function"?setTimeout:void 0,dx=typeof clearTimeout=="function"?clearTimeout:void 0,R0=typeof Promise=="function"?Promise:void 0,hx=typeof queueMicrotask=="function"?queueMicrotask:typeof R0<"u"?function(e){return R0.resolve(null).then(e).catch(gx)}:k0;function gx(e){setTimeout(function(){throw e})}function va(e){return e==="head"}function j0(e,t){var a=t,i=0;do{var s=a.nextSibling;if(e.removeChild(a),s&&s.nodeType===8)if(a=s.data,a==="/$"||a==="/&"){if(i===0){e.removeChild(s),Il(t);return}i--}else if(a==="$"||a==="$?"||a==="$~"||a==="$!"||a==="&")i++;else if(a==="html")no(e.ownerDocument.documentElement);else if(a==="head"){a=e.ownerDocument.head,no(a);for(var c=a.firstChild;c;){var y=c.nextSibling,w=c.nodeName;c[Ra]||w==="SCRIPT"||w==="STYLE"||w==="LINK"&&c.rel.toLowerCase()==="stylesheet"||a.removeChild(c),c=y}}else a==="body"&&no(e.ownerDocument.body);a=s}while(a);Il(t)}function O0(e,t){var a=e;e=0;do{var i=a.nextSibling;if(a.nodeType===1?t?(a._stashedDisplay=a.style.display,a.style.display="none"):(a.style.display=a._stashedDisplay||"",a.getAttribute("style")===""&&a.removeAttribute("style")):a.nodeType===3&&(t?(a._stashedText=a.nodeValue,a.nodeValue=""):a.nodeValue=a._stashedText||""),i&&i.nodeType===8)if(a=i.data,a==="/$"){if(e===0)break;e--}else a!=="$"&&a!=="$?"&&a!=="$~"&&a!=="$!"||e++;a=i}while(a)}function Wc(e){var t=e.firstChild;for(t&&t.nodeType===10&&(t=t.nextSibling);t;){var a=t;switch(t=t.nextSibling,a.nodeName){case"HTML":case"HEAD":case"BODY":Wc(a),yi(a);continue;case"SCRIPT":case"STYLE":continue;case"LINK":if(a.rel.toLowerCase()==="stylesheet")continue}e.removeChild(a)}}function mx(e,t,a,i){for(;e.nodeType===1;){var s=a;if(e.nodeName.toLowerCase()!==t.toLowerCase()){if(!i&&(e.nodeName!=="INPUT"||e.type!=="hidden"))break}else if(i){if(!e[Ra])switch(t){case"meta":if(!e.hasAttribute("itemprop"))break;return e;case"link":if(c=e.getAttribute("rel"),c==="stylesheet"&&e.hasAttribute("data-precedence"))break;if(c!==s.rel||e.getAttribute("href")!==(s.href==null||s.href===""?null:s.href)||e.getAttribute("crossorigin")!==(s.crossOrigin==null?null:s.crossOrigin)||e.getAttribute("title")!==(s.title==null?null:s.title))break;return e;case"style":if(e.hasAttribute("data-precedence"))break;return e;case"script":if(c=e.getAttribute("src"),(c!==(s.src==null?null:s.src)||e.getAttribute("type")!==(s.type==null?null:s.type)||e.getAttribute("crossorigin")!==(s.crossOrigin==null?null:s.crossOrigin))&&c&&e.hasAttribute("async")&&!e.hasAttribute("itemprop"))break;return e;default:return e}}else if(t==="input"&&e.type==="hidden"){var c=s.name==null?null:""+s.name;if(s.type==="hidden"&&e.getAttribute("name")===c)return e}else return e;if(e=Pt(e.nextSibling),e===null)break}return null}function yx(e,t,a){if(t==="")return null;for(;e.nodeType!==3;)if((e.nodeType!==1||e.nodeName!=="INPUT"||e.type!=="hidden")&&!a||(e=Pt(e.nextSibling),e===null))return null;return e}function H0(e,t){for(;e.nodeType!==8;)if((e.nodeType!==1||e.nodeName!=="INPUT"||e.type!=="hidden")&&!t||(e=Pt(e.nextSibling),e===null))return null;return e}function Fc(e){return e.data==="$?"||e.data==="$~"}function Pc(e){return e.data==="$!"||e.data==="$?"&&e.ownerDocument.readyState!=="loading"}function px(e,t){var a=e.ownerDocument;if(e.data==="$~")e._reactRetry=t;else if(e.data!=="$?"||a.readyState!=="loading")t();else{var i=function(){t(),a.removeEventListener("DOMContentLoaded",i)};a.addEventListener("DOMContentLoaded",i),e._reactRetry=i}}function Pt(e){for(;e!=null;e=e.nextSibling){var t=e.nodeType;if(t===1||t===3)break;if(t===8){if(t=e.data,t==="$"||t==="$!"||t==="$?"||t==="$~"||t==="&"||t==="F!"||t==="F")break;if(t==="/$"||t==="/&")return null}}return e}var ef=null;function B0(e){e=e.nextSibling;for(var t=0;e;){if(e.nodeType===8){var a=e.data;if(a==="/$"||a==="/&"){if(t===0)return Pt(e.nextSibling);t--}else a!=="$"&&a!=="$!"&&a!=="$?"&&a!=="$~"&&a!=="&"||t++}e=e.nextSibling}return null}function L0(e){e=e.previousSibling;for(var t=0;e;){if(e.nodeType===8){var a=e.data;if(a==="$"||a==="$!"||a==="$?"||a==="$~"||a==="&"){if(t===0)return e;t--}else a!=="/$"&&a!=="/&"||t++}e=e.previousSibling}return null}function U0(e,t,a){switch(t=Kr(a),e){case"html":if(e=t.documentElement,!e)throw Error(r(452));return e;case"head":if(e=t.head,!e)throw Error(r(453));return e;case"body":if(e=t.body,!e)throw Error(r(454));return e;default:throw Error(r(451))}}function no(e){for(var t=e.attributes;t.length;)e.removeAttributeNode(t[0]);yi(e)}var en=new Map,G0=new Set;function Ir(e){return typeof e.getRootNode=="function"?e.getRootNode():e.nodeType===9?e:e.ownerDocument}var Qn=B.d;B.d={f:vx,r:bx,D:xx,C:_x,L:wx,m:Sx,X:Nx,S:Ex,M:Tx};function vx(){var e=Qn.f(),t=Gr();return e||t}function bx(e){var t=Jn(e);t!==null&&t.tag===5&&t.type==="form"?ag(t):Qn.r(e)}var $l=typeof document>"u"?null:document;function q0(e,t,a){var i=$l;if(i&&typeof t=="string"&&t){var s=Et(t);s='link[rel="'+e+'"][href="'+s+'"]',typeof a=="string"&&(s+='[crossorigin="'+a+'"]'),G0.has(s)||(G0.add(s),e={rel:e,crossOrigin:a,href:t},i.querySelector(s)===null&&(t=i.createElement("link"),mt(t,"link",e),tt(t),i.head.appendChild(t)))}}function xx(e){Qn.D(e),q0("dns-prefetch",e,null)}function _x(e,t){Qn.C(e,t),q0("preconnect",e,t)}function wx(e,t,a){Qn.L(e,t,a);var i=$l;if(i&&e&&t){var s='link[rel="preload"][as="'+Et(t)+'"]';t==="image"&&a&&a.imageSrcSet?(s+='[imagesrcset="'+Et(a.imageSrcSet)+'"]',typeof a.imageSizes=="string"&&(s+='[imagesizes="'+Et(a.imageSizes)+'"]')):s+='[href="'+Et(e)+'"]';var c=s;switch(t){case"style":c=Zl(e);break;case"script":c=Kl(e)}en.has(c)||(e=p({rel:"preload",href:t==="image"&&a&&a.imageSrcSet?void 0:e,as:t},a),en.set(c,e),i.querySelector(s)!==null||t==="style"&&i.querySelector(ao(c))||t==="script"&&i.querySelector(lo(c))||(t=i.createElement("link"),mt(t,"link",e),tt(t),i.head.appendChild(t)))}}function Sx(e,t){Qn.m(e,t);var a=$l;if(a&&e){var i=t&&typeof t.as=="string"?t.as:"script",s='link[rel="modulepreload"][as="'+Et(i)+'"][href="'+Et(e)+'"]',c=s;switch(i){case"audioworklet":case"paintworklet":case"serviceworker":case"sharedworker":case"worker":case"script":c=Kl(e)}if(!en.has(c)&&(e=p({rel:"modulepreload",href:e},t),en.set(c,e),a.querySelector(s)===null)){switch(i){case"audioworklet":case"paintworklet":case"serviceworker":case"sharedworker":case"worker":case"script":if(a.querySelector(lo(c)))return}i=a.createElement("link"),mt(i,"link",e),tt(i),a.head.appendChild(i)}}}function Ex(e,t,a){Qn.S(e,t,a);var i=$l;if(i&&e){var s=Fn(i).hoistableStyles,c=Zl(e);t=t||"default";var y=s.get(c);if(!y){var w={loading:0,preload:null};if(y=i.querySelector(ao(c)))w.loading=5;else{e=p({rel:"stylesheet",href:e,"data-precedence":t},a),(a=en.get(c))&&tf(e,a);var L=y=i.createElement("link");tt(L),mt(L,"link",e),L._p=new Promise(function(I,oe){L.onload=I,L.onerror=oe}),L.addEventListener("load",function(){w.loading|=1}),L.addEventListener("error",function(){w.loading|=2}),w.loading|=4,Jr(y,t,i)}y={type:"stylesheet",instance:y,count:1,state:w},s.set(c,y)}}}function Nx(e,t){Qn.X(e,t);var a=$l;if(a&&e){var i=Fn(a).hoistableScripts,s=Kl(e),c=i.get(s);c||(c=a.querySelector(lo(s)),c||(e=p({src:e,async:!0},t),(t=en.get(s))&&nf(e,t),c=a.createElement("script"),tt(c),mt(c,"link",e),a.head.appendChild(c)),c={type:"script",instance:c,count:1,state:null},i.set(s,c))}}function Tx(e,t){Qn.M(e,t);var a=$l;if(a&&e){var i=Fn(a).hoistableScripts,s=Kl(e),c=i.get(s);c||(c=a.querySelector(lo(s)),c||(e=p({src:e,async:!0,type:"module"},t),(t=en.get(s))&&nf(e,t),c=a.createElement("script"),tt(c),mt(c,"link",e),a.head.appendChild(c)),c={type:"script",instance:c,count:1,state:null},i.set(s,c))}}function Y0(e,t,a,i){var s=(s=me.current)?Ir(s):null;if(!s)throw Error(r(446));switch(e){case"meta":case"title":return null;case"style":return typeof a.precedence=="string"&&typeof a.href=="string"?(t=Zl(a.href),a=Fn(s).hoistableStyles,i=a.get(t),i||(i={type:"style",instance:null,count:0,state:null},a.set(t,i)),i):{type:"void",instance:null,count:0,state:null};case"link":if(a.rel==="stylesheet"&&typeof a.href=="string"&&typeof a.precedence=="string"){e=Zl(a.href);var c=Fn(s).hoistableStyles,y=c.get(e);if(y||(s=s.ownerDocument||s,y={type:"stylesheet",instance:null,count:0,state:{loading:0,preload:null}},c.set(e,y),(c=s.querySelector(ao(e)))&&!c._p&&(y.instance=c,y.state.loading=5),en.has(e)||(a={rel:"preload",as:"style",href:a.href,crossOrigin:a.crossOrigin,integrity:a.integrity,media:a.media,hrefLang:a.hrefLang,referrerPolicy:a.referrerPolicy},en.set(e,a),c||Ax(s,e,a,y.state))),t&&i===null)throw Error(r(528,""));return y}if(t&&i!==null)throw Error(r(529,""));return null;case"script":return t=a.async,a=a.src,typeof a=="string"&&t&&typeof t!="function"&&typeof t!="symbol"?(t=Kl(a),a=Fn(s).hoistableScripts,i=a.get(t),i||(i={type:"script",instance:null,count:0,state:null},a.set(t,i)),i):{type:"void",instance:null,count:0,state:null};default:throw Error(r(444,e))}}function Zl(e){return'href="'+Et(e)+'"'}function ao(e){return'link[rel="stylesheet"]['+e+"]"}function V0(e){return p({},e,{"data-precedence":e.precedence,precedence:null})}function Ax(e,t,a,i){e.querySelector('link[rel="preload"][as="style"]['+t+"]")?i.loading=1:(t=e.createElement("link"),i.preload=t,t.addEventListener("load",function(){return i.loading|=1}),t.addEventListener("error",function(){return i.loading|=2}),mt(t,"link",a),tt(t),e.head.appendChild(t))}function Kl(e){return'[src="'+Et(e)+'"]'}function lo(e){return"script[async]"+e}function X0(e,t,a){if(t.count++,t.instance===null)switch(t.type){case"style":var i=e.querySelector('style[data-href~="'+Et(a.href)+'"]');if(i)return t.instance=i,tt(i),i;var s=p({},a,{"data-href":a.href,"data-precedence":a.precedence,href:null,precedence:null});return i=(e.ownerDocument||e).createElement("style"),tt(i),mt(i,"style",s),Jr(i,a.precedence,e),t.instance=i;case"stylesheet":s=Zl(a.href);var c=e.querySelector(ao(s));if(c)return t.state.loading|=4,t.instance=c,tt(c),c;i=V0(a),(s=en.get(s))&&tf(i,s),c=(e.ownerDocument||e).createElement("link"),tt(c);var y=c;return y._p=new Promise(function(w,L){y.onload=w,y.onerror=L}),mt(c,"link",i),t.state.loading|=4,Jr(c,a.precedence,e),t.instance=c;case"script":return c=Kl(a.src),(s=e.querySelector(lo(c)))?(t.instance=s,tt(s),s):(i=a,(s=en.get(c))&&(i=p({},a),nf(i,s)),e=e.ownerDocument||e,s=e.createElement("script"),tt(s),mt(s,"link",i),e.head.appendChild(s),t.instance=s);case"void":return null;default:throw Error(r(443,t.type))}else t.type==="stylesheet"&&(t.state.loading&4)===0&&(i=t.instance,t.state.loading|=4,Jr(i,a.precedence,e));return t.instance}function Jr(e,t,a){for(var i=a.querySelectorAll('link[rel="stylesheet"][data-precedence],style[data-precedence]'),s=i.length?i[i.length-1]:null,c=s,y=0;y<i.length;y++){var w=i[y];if(w.dataset.precedence===t)c=w;else if(c!==s)break}c?c.parentNode.insertBefore(e,c.nextSibling):(t=a.nodeType===9?a.head:a,t.insertBefore(e,t.firstChild))}function tf(e,t){e.crossOrigin==null&&(e.crossOrigin=t.crossOrigin),e.referrerPolicy==null&&(e.referrerPolicy=t.referrerPolicy),e.title==null&&(e.title=t.title)}function nf(e,t){e.crossOrigin==null&&(e.crossOrigin=t.crossOrigin),e.referrerPolicy==null&&(e.referrerPolicy=t.referrerPolicy),e.integrity==null&&(e.integrity=t.integrity)}var Wr=null;function Q0(e,t,a){if(Wr===null){var i=new Map,s=Wr=new Map;s.set(a,i)}else s=Wr,i=s.get(a),i||(i=new Map,s.set(a,i));if(i.has(e))return i;for(i.set(e,null),a=a.getElementsByTagName(e),s=0;s<a.length;s++){var c=a[s];if(!(c[Ra]||c[rt]||e==="link"&&c.getAttribute("rel")==="stylesheet")&&c.namespaceURI!=="http://www.w3.org/2000/svg"){var y=c.getAttribute(t)||"";y=e+y;var w=i.get(y);w?w.push(c):i.set(y,[c])}}return i}function $0(e,t,a){e=e.ownerDocument||e,e.head.insertBefore(a,t==="title"?e.querySelector("head > title"):null)}function Mx(e,t,a){if(a===1||t.itemProp!=null)return!1;switch(e){case"meta":case"title":return!0;case"style":if(typeof t.precedence!="string"||typeof t.href!="string"||t.href==="")break;return!0;case"link":if(typeof t.rel!="string"||typeof t.href!="string"||t.href===""||t.onLoad||t.onError)break;switch(t.rel){case"stylesheet":return e=t.disabled,typeof t.precedence=="string"&&e==null;default:return!0}case"script":if(t.async&&typeof t.async!="function"&&typeof t.async!="symbol"&&!t.onLoad&&!t.onError&&t.src&&typeof t.src=="string")return!0}return!1}function Z0(e){return!(e.type==="stylesheet"&&(e.state.loading&3)===0)}function zx(e,t,a,i){if(a.type==="stylesheet"&&(typeof i.media!="string"||matchMedia(i.media).matches!==!1)&&(a.state.loading&4)===0){if(a.instance===null){var s=Zl(i.href),c=t.querySelector(ao(s));if(c){t=c._p,t!==null&&typeof t=="object"&&typeof t.then=="function"&&(e.count++,e=Fr.bind(e),t.then(e,e)),a.state.loading|=4,a.instance=c,tt(c);return}c=t.ownerDocument||t,i=V0(i),(s=en.get(s))&&tf(i,s),c=c.createElement("link"),tt(c);var y=c;y._p=new Promise(function(w,L){y.onload=w,y.onerror=L}),mt(c,"link",i),a.instance=c}e.stylesheets===null&&(e.stylesheets=new Map),e.stylesheets.set(a,t),(t=a.state.preload)&&(a.state.loading&3)===0&&(e.count++,a=Fr.bind(e),t.addEventListener("load",a),t.addEventListener("error",a))}}var af=0;function Cx(e,t){return e.stylesheets&&e.count===0&&eu(e,e.stylesheets),0<e.count||0<e.imgCount?function(a){var i=setTimeout(function(){if(e.stylesheets&&eu(e,e.stylesheets),e.unsuspend){var c=e.unsuspend;e.unsuspend=null,c()}},6e4+t);0<e.imgBytes&&af===0&&(af=62500*cx());var s=setTimeout(function(){if(e.waitingForImages=!1,e.count===0&&(e.stylesheets&&eu(e,e.stylesheets),e.unsuspend)){var c=e.unsuspend;e.unsuspend=null,c()}},(e.imgBytes>af?50:800)+t);return e.unsuspend=a,function(){e.unsuspend=null,clearTimeout(i),clearTimeout(s)}}:null}function Fr(){if(this.count--,this.count===0&&(this.imgCount===0||!this.waitingForImages)){if(this.stylesheets)eu(this,this.stylesheets);else if(this.unsuspend){var e=this.unsuspend;this.unsuspend=null,e()}}}var Pr=null;function eu(e,t){e.stylesheets=null,e.unsuspend!==null&&(e.count++,Pr=new Map,t.forEach(Dx,e),Pr=null,Fr.call(e))}function Dx(e,t){if(!(t.state.loading&4)){var a=Pr.get(e);if(a)var i=a.get(null);else{a=new Map,Pr.set(e,a);for(var s=e.querySelectorAll("link[data-precedence],style[data-precedence]"),c=0;c<s.length;c++){var y=s[c];(y.nodeName==="LINK"||y.getAttribute("media")!=="not all")&&(a.set(y.dataset.precedence,y),i=y)}i&&a.set(null,i)}s=t.instance,y=s.getAttribute("data-precedence"),c=a.get(y)||i,c===i&&a.set(null,s),a.set(y,s),this.count++,i=Fr.bind(this),s.addEventListener("load",i),s.addEventListener("error",i),c?c.parentNode.insertBefore(s,c.nextSibling):(e=e.nodeType===9?e.head:e,e.insertBefore(s,e.firstChild)),t.state.loading|=4}}var io={$$typeof:S,Provider:null,Consumer:null,_currentValue:X,_currentValue2:X,_threadCount:0};function kx(e,t,a,i,s,c,y,w,L){this.tag=1,this.containerInfo=e,this.pingCache=this.current=this.pendingChildren=null,this.timeoutHandle=-1,this.callbackNode=this.next=this.pendingContext=this.context=this.cancelPendingCommit=null,this.callbackPriority=0,this.expirationTimes=hi(-1),this.entangledLanes=this.shellSuspendCounter=this.errorRecoveryDisabledLanes=this.expiredLanes=this.warmLanes=this.pingedLanes=this.suspendedLanes=this.pendingLanes=0,this.entanglements=hi(0),this.hiddenUpdates=hi(null),this.identifierPrefix=i,this.onUncaughtError=s,this.onCaughtError=c,this.onRecoverableError=y,this.pooledCache=null,this.pooledCacheLanes=0,this.formState=L,this.incompleteTransitions=new Map}function K0(e,t,a,i,s,c,y,w,L,I,oe,ue){return e=new kx(e,t,a,y,L,I,oe,ue,w),t=1,c===!0&&(t|=24),c=Ot(3,null,null,t),e.current=c,c.stateNode=e,t=Hs(),t.refCount++,e.pooledCache=t,t.refCount++,c.memoizedState={element:i,isDehydrated:a,cache:t},Gs(c),e}function I0(e){return e?(e=Nl,e):Nl}function J0(e,t,a,i,s,c){s=I0(s),i.context===null?i.context=s:i.pendingContext=s,i=ra(t),i.payload={element:a},c=c===void 0?null:c,c!==null&&(i.callback=c),a=ua(e,i,t),a!==null&&(Ct(a,e,t),Bi(a,e,t))}function W0(e,t){if(e=e.memoizedState,e!==null&&e.dehydrated!==null){var a=e.retryLane;e.retryLane=a!==0&&a<t?a:t}}function lf(e,t){W0(e,t),(e=e.alternate)&&W0(e,t)}function F0(e){if(e.tag===13||e.tag===31){var t=La(e,67108864);t!==null&&Ct(t,e,67108864),lf(e,67108864)}}function P0(e){if(e.tag===13||e.tag===31){var t=Gt();t=gi(t);var a=La(e,t);a!==null&&Ct(a,e,t),lf(e,t)}}var tu=!0;function Rx(e,t,a,i){var s=M.T;M.T=null;var c=B.p;try{B.p=2,of(e,t,a,i)}finally{B.p=c,M.T=s}}function jx(e,t,a,i){var s=M.T;M.T=null;var c=B.p;try{B.p=8,of(e,t,a,i)}finally{B.p=c,M.T=s}}function of(e,t,a,i){if(tu){var s=rf(i);if(s===null)Qc(e,t,i,nu,a),tm(e,i);else if(Hx(s,e,t,a,i))i.stopPropagation();else if(tm(e,i),t&4&&-1<Ox.indexOf(e)){for(;s!==null;){var c=Jn(s);if(c!==null)switch(c.tag){case 3:if(c=c.stateNode,c.current.memoizedState.isDehydrated){var y=Tn(c.pendingLanes);if(y!==0){var w=c;for(w.pendingLanes|=2,w.entangledLanes|=2;y;){var L=1<<31-xt(y);w.entanglements[1]|=L,y&=~L}vn(c),(Be&6)===0&&(Lr=Fe()+500,Pi(0))}}break;case 31:case 13:w=La(c,2),w!==null&&Ct(w,c,2),Gr(),lf(c,2)}if(c=rf(i),c===null&&Qc(e,t,i,nu,a),c===s)break;s=c}s!==null&&i.stopPropagation()}else Qc(e,t,i,null,a)}}function rf(e){return e=us(e),uf(e)}var nu=null;function uf(e){if(nu=null,e=In(e),e!==null){var t=f(e);if(t===null)e=null;else{var a=t.tag;if(a===13){if(e=d(t),e!==null)return e;e=null}else if(a===31){if(e=h(t),e!==null)return e;e=null}else if(a===3){if(t.stateNode.current.memoizedState.isDehydrated)return t.tag===3?t.stateNode.containerInfo:null;e=null}else t!==e&&(e=null)}}return nu=e,null}function em(e){switch(e){case"beforetoggle":case"cancel":case"click":case"close":case"contextmenu":case"copy":case"cut":case"auxclick":case"dblclick":case"dragend":case"dragstart":case"drop":case"focusin":case"focusout":case"input":case"invalid":case"keydown":case"keypress":case"keyup":case"mousedown":case"mouseup":case"paste":case"pause":case"play":case"pointercancel":case"pointerdown":case"pointerup":case"ratechange":case"reset":case"resize":case"seeked":case"submit":case"toggle":case"touchcancel":case"touchend":case"touchstart":case"volumechange":case"change":case"selectionchange":case"textInput":case"compositionstart":case"compositionend":case"compositionupdate":case"beforeblur":case"afterblur":case"beforeinput":case"blur":case"fullscreenchange":case"focus":case"hashchange":case"popstate":case"select":case"selectstart":return 2;case"drag":case"dragenter":case"dragexit":case"dragleave":case"dragover":case"mousemove":case"mouseout":case"mouseover":case"pointermove":case"pointerout":case"pointerover":case"scroll":case"touchmove":case"wheel":case"mouseenter":case"mouseleave":case"pointerenter":case"pointerleave":return 8;case"message":switch(Rt()){case Xt:return 2;case Qt:return 8;case $t:case di:return 32;case ul:return 268435456;default:return 32}default:return 32}}var sf=!1,ba=null,xa=null,_a=null,oo=new Map,ro=new Map,wa=[],Ox="mousedown mouseup touchcancel touchend touchstart auxclick dblclick pointercancel pointerdown pointerup dragend dragstart drop compositionend compositionstart keydown keypress keyup input textInput copy cut paste click change contextmenu reset".split(" ");function tm(e,t){switch(e){case"focusin":case"focusout":ba=null;break;case"dragenter":case"dragleave":xa=null;break;case"mouseover":case"mouseout":_a=null;break;case"pointerover":case"pointerout":oo.delete(t.pointerId);break;case"gotpointercapture":case"lostpointercapture":ro.delete(t.pointerId)}}function uo(e,t,a,i,s,c){return e===null||e.nativeEvent!==c?(e={blockedOn:t,domEventName:a,eventSystemFlags:i,nativeEvent:c,targetContainers:[s]},t!==null&&(t=Jn(t),t!==null&&F0(t)),e):(e.eventSystemFlags|=i,t=e.targetContainers,s!==null&&t.indexOf(s)===-1&&t.push(s),e)}function Hx(e,t,a,i,s){switch(t){case"focusin":return ba=uo(ba,e,t,a,i,s),!0;case"dragenter":return xa=uo(xa,e,t,a,i,s),!0;case"mouseover":return _a=uo(_a,e,t,a,i,s),!0;case"pointerover":var c=s.pointerId;return oo.set(c,uo(oo.get(c)||null,e,t,a,i,s)),!0;case"gotpointercapture":return c=s.pointerId,ro.set(c,uo(ro.get(c)||null,e,t,a,i,s)),!0}return!1}function nm(e){var t=In(e.target);if(t!==null){var a=f(t);if(a!==null){if(t=a.tag,t===13){if(t=d(a),t!==null){e.blockedOn=t,Qo(e.priority,function(){P0(a)});return}}else if(t===31){if(t=h(a),t!==null){e.blockedOn=t,Qo(e.priority,function(){P0(a)});return}}else if(t===3&&a.stateNode.current.memoizedState.isDehydrated){e.blockedOn=a.tag===3?a.stateNode.containerInfo:null;return}}}e.blockedOn=null}function au(e){if(e.blockedOn!==null)return!1;for(var t=e.targetContainers;0<t.length;){var a=rf(e.nativeEvent);if(a===null){a=e.nativeEvent;var i=new a.constructor(a.type,a);rs=i,a.target.dispatchEvent(i),rs=null}else return t=Jn(a),t!==null&&F0(t),e.blockedOn=a,!1;t.shift()}return!0}function am(e,t,a){au(e)&&a.delete(t)}function Bx(){sf=!1,ba!==null&&au(ba)&&(ba=null),xa!==null&&au(xa)&&(xa=null),_a!==null&&au(_a)&&(_a=null),oo.forEach(am),ro.forEach(am)}function lu(e,t){e.blockedOn===t&&(e.blockedOn=null,sf||(sf=!0,n.unstable_scheduleCallback(n.unstable_NormalPriority,Bx)))}var iu=null;function lm(e){iu!==e&&(iu=e,n.unstable_scheduleCallback(n.unstable_NormalPriority,function(){iu===e&&(iu=null);for(var t=0;t<e.length;t+=3){var a=e[t],i=e[t+1],s=e[t+2];if(typeof i!="function"){if(uf(i||a)===null)continue;break}var c=Jn(a);c!==null&&(e.splice(t,3),t-=3,oc(c,{pending:!0,data:s,method:a.method,action:i},i,s))}}))}function Il(e){function t(L){return lu(L,e)}ba!==null&&lu(ba,e),xa!==null&&lu(xa,e),_a!==null&&lu(_a,e),oo.forEach(t),ro.forEach(t);for(var a=0;a<wa.length;a++){var i=wa[a];i.blockedOn===e&&(i.blockedOn=null)}for(;0<wa.length&&(a=wa[0],a.blockedOn===null);)nm(a),a.blockedOn===null&&wa.shift();if(a=(e.ownerDocument||e).$$reactFormReplay,a!=null)for(i=0;i<a.length;i+=3){var s=a[i],c=a[i+1],y=s[pt]||null;if(typeof c=="function")y||lm(a);else if(y){var w=null;if(c&&c.hasAttribute("formAction")){if(s=c,y=c[pt]||null)w=y.formAction;else if(uf(s)!==null)continue}else w=y.action;typeof w=="function"?a[i+1]=w:(a.splice(i,3),i-=3),lm(a)}}}function im(){function e(c){c.canIntercept&&c.info==="react-transition"&&c.intercept({handler:function(){return new Promise(function(y){return s=y})},focusReset:"manual",scroll:"manual"})}function t(){s!==null&&(s(),s=null),i||setTimeout(a,20)}function a(){if(!i&&!navigation.transition){var c=navigation.currentEntry;c&&c.url!=null&&navigation.navigate(c.url,{state:c.getState(),info:"react-transition",history:"replace"})}}if(typeof navigation=="object"){var i=!1,s=null;return navigation.addEventListener("navigate",e),navigation.addEventListener("navigatesuccess",t),navigation.addEventListener("navigateerror",t),setTimeout(a,100),function(){i=!0,navigation.removeEventListener("navigate",e),navigation.removeEventListener("navigatesuccess",t),navigation.removeEventListener("navigateerror",t),s!==null&&(s(),s=null)}}}function cf(e){this._internalRoot=e}ou.prototype.render=cf.prototype.render=function(e){var t=this._internalRoot;if(t===null)throw Error(r(409));var a=t.current,i=Gt();J0(a,i,e,t,null,null)},ou.prototype.unmount=cf.prototype.unmount=function(){var e=this._internalRoot;if(e!==null){this._internalRoot=null;var t=e.containerInfo;J0(e.current,2,null,e,null,null),Gr(),t[An]=null}};function ou(e){this._internalRoot=e}ou.prototype.unstable_scheduleHydration=function(e){if(e){var t=Xo();e={blockedOn:null,target:e,priority:t};for(var a=0;a<wa.length&&t!==0&&t<wa[a].priority;a++);wa.splice(a,0,e),a===0&&nm(e)}};var om=l.version;if(om!=="19.2.8")throw Error(r(527,om,"19.2.8"));B.findDOMNode=function(e){var t=e._reactInternals;if(t===void 0)throw typeof e.render=="function"?Error(r(188)):(e=Object.keys(e).join(","),Error(r(268,e)));return e=g(t),e=e!==null?v(e):null,e=e===null?null:e.stateNode,e};var Lx={bundleType:0,version:"19.2.8",rendererPackageName:"react-dom",currentDispatcherRef:M,reconcilerVersion:"19.2.8"};if(typeof __REACT_DEVTOOLS_GLOBAL_HOOK__<"u"){var ru=__REACT_DEVTOOLS_GLOBAL_HOOK__;if(!ru.isDisabled&&ru.supportsFiber)try{Ca=ru.inject(Lx),bt=ru}catch{}}return co.createRoot=function(e,t){if(!u(e))throw Error(r(299));var a=!1,i="",s=hg,c=gg,y=mg;return t!=null&&(t.unstable_strictMode===!0&&(a=!0),t.identifierPrefix!==void 0&&(i=t.identifierPrefix),t.onUncaughtError!==void 0&&(s=t.onUncaughtError),t.onCaughtError!==void 0&&(c=t.onCaughtError),t.onRecoverableError!==void 0&&(y=t.onRecoverableError)),t=K0(e,1,!1,null,null,a,i,null,s,c,y,im),e[An]=t.current,Xc(e),new cf(t)},co.hydrateRoot=function(e,t,a){if(!u(e))throw Error(r(299));var i=!1,s="",c=hg,y=gg,w=mg,L=null;return a!=null&&(a.unstable_strictMode===!0&&(i=!0),a.identifierPrefix!==void 0&&(s=a.identifierPrefix),a.onUncaughtError!==void 0&&(c=a.onUncaughtError),a.onCaughtError!==void 0&&(y=a.onCaughtError),a.onRecoverableError!==void 0&&(w=a.onRecoverableError),a.formState!==void 0&&(L=a.formState)),t=K0(e,1,!0,t,a??null,i,s,L,c,y,w,im),t.context=I0(null),a=t.current,i=Gt(),i=gi(i),s=ra(i),s.callback=null,ua(a,s,i),a=i,t.current.lanes=a,ka(t,a),vn(t),e[An]=t.current,Xc(e),new ou(t)},co.version="19.2.8",co}var ym;function Zx(){if(ym)return hf.exports;ym=1;function n(){if(!(typeof __REACT_DEVTOOLS_GLOBAL_HOOK__>"u"||typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE!="function"))try{__REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(n)}catch(l){console.error(l)}}return n(),hf.exports=$x(),hf.exports}var Kx=Zx();function ot(n){if(typeof n=="string"||typeof n=="number")return""+n;let l="";if(Array.isArray(n))for(let o=0,r;o<n.length;o++)(r=ot(n[o]))!==""&&(l+=(l&&" ")+r);else for(let o in n)n[o]&&(l+=(l&&" ")+o);return l}var Ix={value:()=>{}};function Bu(){for(var n=0,l=arguments.length,o={},r;n<l;++n){if(!(r=arguments[n]+"")||r in o||/[\s.]/.test(r))throw new Error("illegal type: "+r);o[r]=[]}return new vu(o)}function vu(n){this._=n}function Jx(n,l){return n.trim().split(/^|\s+/).map(function(o){var r="",u=o.indexOf(".");if(u>=0&&(r=o.slice(u+1),o=o.slice(0,u)),o&&!l.hasOwnProperty(o))throw new Error("unknown type: "+o);return{type:o,name:r}})}vu.prototype=Bu.prototype={constructor:vu,on:function(n,l){var o=this._,r=Jx(n+"",o),u,f=-1,d=r.length;if(arguments.length<2){for(;++f<d;)if((u=(n=r[f]).type)&&(u=Wx(o[u],n.name)))return u;return}if(l!=null&&typeof l!="function")throw new Error("invalid callback: "+l);for(;++f<d;)if(u=(n=r[f]).type)o[u]=pm(o[u],n.name,l);else if(l==null)for(u in o)o[u]=pm(o[u],n.name,null);return this},copy:function(){var n={},l=this._;for(var o in l)n[o]=l[o].slice();return new vu(n)},call:function(n,l){if((u=arguments.length-2)>0)for(var o=new Array(u),r=0,u,f;r<u;++r)o[r]=arguments[r+2];if(!this._.hasOwnProperty(n))throw new Error("unknown type: "+n);for(f=this._[n],r=0,u=f.length;r<u;++r)f[r].value.apply(l,o)},apply:function(n,l,o){if(!this._.hasOwnProperty(n))throw new Error("unknown type: "+n);for(var r=this._[n],u=0,f=r.length;u<f;++u)r[u].value.apply(l,o)}};function Wx(n,l){for(var o=0,r=n.length,u;o<r;++o)if((u=n[o]).name===l)return u.value}function pm(n,l,o){for(var r=0,u=n.length;r<u;++r)if(n[r].name===l){n[r]=Ix,n=n.slice(0,r).concat(n.slice(r+1));break}return o!=null&&n.push({name:l,value:o}),n}var Of="http://www.w3.org/1999/xhtml";const vm={svg:"http://www.w3.org/2000/svg",xhtml:Of,xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"};function Lu(n){var l=n+="",o=l.indexOf(":");return o>=0&&(l=n.slice(0,o))!=="xmlns"&&(n=n.slice(o+1)),vm.hasOwnProperty(l)?{space:vm[l],local:n}:n}function Fx(n){return function(){var l=this.ownerDocument,o=this.namespaceURI;return o===Of&&l.documentElement.namespaceURI===Of?l.createElement(n):l.createElementNS(o,n)}}function Px(n){return function(){return this.ownerDocument.createElementNS(n.space,n.local)}}function By(n){var l=Lu(n);return(l.local?Px:Fx)(l)}function e_(){}function od(n){return n==null?e_:function(){return this.querySelector(n)}}function t_(n){typeof n!="function"&&(n=od(n));for(var l=this._groups,o=l.length,r=new Array(o),u=0;u<o;++u)for(var f=l[u],d=f.length,h=r[u]=new Array(d),m,g,v=0;v<d;++v)(m=f[v])&&(g=n.call(m,m.__data__,v,f))&&("__data__"in m&&(g.__data__=m.__data__),h[v]=g);return new Yt(r,this._parents)}function n_(n){return n==null?[]:Array.isArray(n)?n:Array.from(n)}function a_(){return[]}function Ly(n){return n==null?a_:function(){return this.querySelectorAll(n)}}function l_(n){return function(){return n_(n.apply(this,arguments))}}function i_(n){typeof n=="function"?n=l_(n):n=Ly(n);for(var l=this._groups,o=l.length,r=[],u=[],f=0;f<o;++f)for(var d=l[f],h=d.length,m,g=0;g<h;++g)(m=d[g])&&(r.push(n.call(m,m.__data__,g,d)),u.push(m));return new Yt(r,u)}function Uy(n){return function(){return this.matches(n)}}function Gy(n){return function(l){return l.matches(n)}}var o_=Array.prototype.find;function r_(n){return function(){return o_.call(this.children,n)}}function u_(){return this.firstElementChild}function s_(n){return this.select(n==null?u_:r_(typeof n=="function"?n:Gy(n)))}var c_=Array.prototype.filter;function f_(){return Array.from(this.children)}function d_(n){return function(){return c_.call(this.children,n)}}function h_(n){return this.selectAll(n==null?f_:d_(typeof n=="function"?n:Gy(n)))}function g_(n){typeof n!="function"&&(n=Uy(n));for(var l=this._groups,o=l.length,r=new Array(o),u=0;u<o;++u)for(var f=l[u],d=f.length,h=r[u]=[],m,g=0;g<d;++g)(m=f[g])&&n.call(m,m.__data__,g,f)&&h.push(m);return new Yt(r,this._parents)}function qy(n){return new Array(n.length)}function m_(){return new Yt(this._enter||this._groups.map(qy),this._parents)}function Eu(n,l){this.ownerDocument=n.ownerDocument,this.namespaceURI=n.namespaceURI,this._next=null,this._parent=n,this.__data__=l}Eu.prototype={constructor:Eu,appendChild:function(n){return this._parent.insertBefore(n,this._next)},insertBefore:function(n,l){return this._parent.insertBefore(n,l)},querySelector:function(n){return this._parent.querySelector(n)},querySelectorAll:function(n){return this._parent.querySelectorAll(n)}};function y_(n){return function(){return n}}function p_(n,l,o,r,u,f){for(var d=0,h,m=l.length,g=f.length;d<g;++d)(h=l[d])?(h.__data__=f[d],r[d]=h):o[d]=new Eu(n,f[d]);for(;d<m;++d)(h=l[d])&&(u[d]=h)}function v_(n,l,o,r,u,f,d){var h,m,g=new Map,v=l.length,p=f.length,b=new Array(v),x;for(h=0;h<v;++h)(m=l[h])&&(b[h]=x=d.call(m,m.__data__,h,l)+"",g.has(x)?u[h]=m:g.set(x,m));for(h=0;h<p;++h)x=d.call(n,f[h],h,f)+"",(m=g.get(x))?(r[h]=m,m.__data__=f[h],g.delete(x)):o[h]=new Eu(n,f[h]);for(h=0;h<v;++h)(m=l[h])&&g.get(b[h])===m&&(u[h]=m)}function b_(n){return n.__data__}function x_(n,l){if(!arguments.length)return Array.from(this,b_);var o=l?v_:p_,r=this._parents,u=this._groups;typeof n!="function"&&(n=y_(n));for(var f=u.length,d=new Array(f),h=new Array(f),m=new Array(f),g=0;g<f;++g){var v=r[g],p=u[g],b=p.length,x=__(n.call(v,v&&v.__data__,g,r)),_=x.length,T=h[g]=new Array(_),z=d[g]=new Array(_),A=m[g]=new Array(b);o(v,p,T,z,A,x,l);for(var R=0,S=0,D,H;R<_;++R)if(D=T[R]){for(R>=S&&(S=R+1);!(H=z[S])&&++S<_;);D._next=H||null}}return d=new Yt(d,r),d._enter=h,d._exit=m,d}function __(n){return typeof n=="object"&&"length"in n?n:Array.from(n)}function w_(){return new Yt(this._exit||this._groups.map(qy),this._parents)}function S_(n,l,o){var r=this.enter(),u=this,f=this.exit();return typeof n=="function"?(r=n(r),r&&(r=r.selection())):r=r.append(n+""),l!=null&&(u=l(u),u&&(u=u.selection())),o==null?f.remove():o(f),r&&u?r.merge(u).order():u}function E_(n){for(var l=n.selection?n.selection():n,o=this._groups,r=l._groups,u=o.length,f=r.length,d=Math.min(u,f),h=new Array(u),m=0;m<d;++m)for(var g=o[m],v=r[m],p=g.length,b=h[m]=new Array(p),x,_=0;_<p;++_)(x=g[_]||v[_])&&(b[_]=x);for(;m<u;++m)h[m]=o[m];return new Yt(h,this._parents)}function N_(){for(var n=this._groups,l=-1,o=n.length;++l<o;)for(var r=n[l],u=r.length-1,f=r[u],d;--u>=0;)(d=r[u])&&(f&&d.compareDocumentPosition(f)^4&&f.parentNode.insertBefore(d,f),f=d);return this}function T_(n){n||(n=A_);function l(p,b){return p&&b?n(p.__data__,b.__data__):!p-!b}for(var o=this._groups,r=o.length,u=new Array(r),f=0;f<r;++f){for(var d=o[f],h=d.length,m=u[f]=new Array(h),g,v=0;v<h;++v)(g=d[v])&&(m[v]=g);m.sort(l)}return new Yt(u,this._parents).order()}function A_(n,l){return n<l?-1:n>l?1:n>=l?0:NaN}function M_(){var n=arguments[0];return arguments[0]=this,n.apply(null,arguments),this}function z_(){return Array.from(this)}function C_(){for(var n=this._groups,l=0,o=n.length;l<o;++l)for(var r=n[l],u=0,f=r.length;u<f;++u){var d=r[u];if(d)return d}return null}function D_(){let n=0;for(const l of this)++n;return n}function k_(){return!this.node()}function R_(n){for(var l=this._groups,o=0,r=l.length;o<r;++o)for(var u=l[o],f=0,d=u.length,h;f<d;++f)(h=u[f])&&n.call(h,h.__data__,f,u);return this}function j_(n){return function(){this.removeAttribute(n)}}function O_(n){return function(){this.removeAttributeNS(n.space,n.local)}}function H_(n,l){return function(){this.setAttribute(n,l)}}function B_(n,l){return function(){this.setAttributeNS(n.space,n.local,l)}}function L_(n,l){return function(){var o=l.apply(this,arguments);o==null?this.removeAttribute(n):this.setAttribute(n,o)}}function U_(n,l){return function(){var o=l.apply(this,arguments);o==null?this.removeAttributeNS(n.space,n.local):this.setAttributeNS(n.space,n.local,o)}}function G_(n,l){var o=Lu(n);if(arguments.length<2){var r=this.node();return o.local?r.getAttributeNS(o.space,o.local):r.getAttribute(o)}return this.each((l==null?o.local?O_:j_:typeof l=="function"?o.local?U_:L_:o.local?B_:H_)(o,l))}function Yy(n){return n.ownerDocument&&n.ownerDocument.defaultView||n.document&&n||n.defaultView}function q_(n){return function(){this.style.removeProperty(n)}}function Y_(n,l,o){return function(){this.style.setProperty(n,l,o)}}function V_(n,l,o){return function(){var r=l.apply(this,arguments);r==null?this.style.removeProperty(n):this.style.setProperty(n,r,o)}}function X_(n,l,o){return arguments.length>1?this.each((l==null?q_:typeof l=="function"?V_:Y_)(n,l,o??"")):ai(this.node(),n)}function ai(n,l){return n.style.getPropertyValue(l)||Yy(n).getComputedStyle(n,null).getPropertyValue(l)}function Q_(n){return function(){delete this[n]}}function $_(n,l){return function(){this[n]=l}}function Z_(n,l){return function(){var o=l.apply(this,arguments);o==null?delete this[n]:this[n]=o}}function K_(n,l){return arguments.length>1?this.each((l==null?Q_:typeof l=="function"?Z_:$_)(n,l)):this.node()[n]}function Vy(n){return n.trim().split(/^|\s+/)}function rd(n){return n.classList||new Xy(n)}function Xy(n){this._node=n,this._names=Vy(n.getAttribute("class")||"")}Xy.prototype={add:function(n){var l=this._names.indexOf(n);l<0&&(this._names.push(n),this._node.setAttribute("class",this._names.join(" ")))},remove:function(n){var l=this._names.indexOf(n);l>=0&&(this._names.splice(l,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(n){return this._names.indexOf(n)>=0}};function Qy(n,l){for(var o=rd(n),r=-1,u=l.length;++r<u;)o.add(l[r])}function $y(n,l){for(var o=rd(n),r=-1,u=l.length;++r<u;)o.remove(l[r])}function I_(n){return function(){Qy(this,n)}}function J_(n){return function(){$y(this,n)}}function W_(n,l){return function(){(l.apply(this,arguments)?Qy:$y)(this,n)}}function F_(n,l){var o=Vy(n+"");if(arguments.length<2){for(var r=rd(this.node()),u=-1,f=o.length;++u<f;)if(!r.contains(o[u]))return!1;return!0}return this.each((typeof l=="function"?W_:l?I_:J_)(o,l))}function P_(){this.textContent=""}function e1(n){return function(){this.textContent=n}}function t1(n){return function(){var l=n.apply(this,arguments);this.textContent=l??""}}function n1(n){return arguments.length?this.each(n==null?P_:(typeof n=="function"?t1:e1)(n)):this.node().textContent}function a1(){this.innerHTML=""}function l1(n){return function(){this.innerHTML=n}}function i1(n){return function(){var l=n.apply(this,arguments);this.innerHTML=l??""}}function o1(n){return arguments.length?this.each(n==null?a1:(typeof n=="function"?i1:l1)(n)):this.node().innerHTML}function r1(){this.nextSibling&&this.parentNode.appendChild(this)}function u1(){return this.each(r1)}function s1(){this.previousSibling&&this.parentNode.insertBefore(this,this.parentNode.firstChild)}function c1(){return this.each(s1)}function f1(n){var l=typeof n=="function"?n:By(n);return this.select(function(){return this.appendChild(l.apply(this,arguments))})}function d1(){return null}function h1(n,l){var o=typeof n=="function"?n:By(n),r=l==null?d1:typeof l=="function"?l:od(l);return this.select(function(){return this.insertBefore(o.apply(this,arguments),r.apply(this,arguments)||null)})}function g1(){var n=this.parentNode;n&&n.removeChild(this)}function m1(){return this.each(g1)}function y1(){var n=this.cloneNode(!1),l=this.parentNode;return l?l.insertBefore(n,this.nextSibling):n}function p1(){var n=this.cloneNode(!0),l=this.parentNode;return l?l.insertBefore(n,this.nextSibling):n}function v1(n){return this.select(n?p1:y1)}function b1(n){return arguments.length?this.property("__data__",n):this.node().__data__}function x1(n){return function(l){n.call(this,l,this.__data__)}}function _1(n){return n.trim().split(/^|\s+/).map(function(l){var o="",r=l.indexOf(".");return r>=0&&(o=l.slice(r+1),l=l.slice(0,r)),{type:l,name:o}})}function w1(n){return function(){var l=this.__on;if(l){for(var o=0,r=-1,u=l.length,f;o<u;++o)f=l[o],(!n.type||f.type===n.type)&&f.name===n.name?this.removeEventListener(f.type,f.listener,f.options):l[++r]=f;++r?l.length=r:delete this.__on}}}function S1(n,l,o){return function(){var r=this.__on,u,f=x1(l);if(r){for(var d=0,h=r.length;d<h;++d)if((u=r[d]).type===n.type&&u.name===n.name){this.removeEventListener(u.type,u.listener,u.options),this.addEventListener(u.type,u.listener=f,u.options=o),u.value=l;return}}this.addEventListener(n.type,f,o),u={type:n.type,name:n.name,value:l,listener:f,options:o},r?r.push(u):this.__on=[u]}}function E1(n,l,o){var r=_1(n+""),u,f=r.length,d;if(arguments.length<2){var h=this.node().__on;if(h){for(var m=0,g=h.length,v;m<g;++m)for(u=0,v=h[m];u<f;++u)if((d=r[u]).type===v.type&&d.name===v.name)return v.value}return}for(h=l?S1:w1,u=0;u<f;++u)this.each(h(r[u],l,o));return this}function Zy(n,l,o){var r=Yy(n),u=r.CustomEvent;typeof u=="function"?u=new u(l,o):(u=r.document.createEvent("Event"),o?(u.initEvent(l,o.bubbles,o.cancelable),u.detail=o.detail):u.initEvent(l,!1,!1)),n.dispatchEvent(u)}function N1(n,l){return function(){return Zy(this,n,l)}}function T1(n,l){return function(){return Zy(this,n,l.apply(this,arguments))}}function A1(n,l){return this.each((typeof l=="function"?T1:N1)(n,l))}function*M1(){for(var n=this._groups,l=0,o=n.length;l<o;++l)for(var r=n[l],u=0,f=r.length,d;u<f;++u)(d=r[u])&&(yield d)}var Ky=[null];function Yt(n,l){this._groups=n,this._parents=l}function ko(){return new Yt([[document.documentElement]],Ky)}function z1(){return this}Yt.prototype=ko.prototype={constructor:Yt,select:t_,selectAll:i_,selectChild:s_,selectChildren:h_,filter:g_,data:x_,enter:m_,exit:w_,join:S_,merge:E_,selection:z1,order:N_,sort:T_,call:M_,nodes:z_,node:C_,size:D_,empty:k_,each:R_,attr:G_,style:X_,property:K_,classed:F_,text:n1,html:o1,raise:u1,lower:c1,append:f1,insert:h1,remove:m1,clone:v1,datum:b1,on:E1,dispatch:A1,[Symbol.iterator]:M1};function qt(n){return typeof n=="string"?new Yt([[document.querySelector(n)]],[document.documentElement]):new Yt([[n]],Ky)}function C1(n){let l;for(;l=n.sourceEvent;)n=l;return n}function rn(n,l){if(n=C1(n),l===void 0&&(l=n.currentTarget),l){var o=l.ownerSVGElement||l;if(o.createSVGPoint){var r=o.createSVGPoint();return r.x=n.clientX,r.y=n.clientY,r=r.matrixTransform(l.getScreenCTM().inverse()),[r.x,r.y]}if(l.getBoundingClientRect){var u=l.getBoundingClientRect();return[n.clientX-u.left-l.clientLeft,n.clientY-u.top-l.clientTop]}}return[n.pageX,n.pageY]}const D1={passive:!1},xo={capture:!0,passive:!1};function pf(n){n.stopImmediatePropagation()}function ti(n){n.preventDefault(),n.stopImmediatePropagation()}function Iy(n){var l=n.document.documentElement,o=qt(n).on("dragstart.drag",ti,xo);"onselectstart"in l?o.on("selectstart.drag",ti,xo):(l.__noselect=l.style.MozUserSelect,l.style.MozUserSelect="none")}function Jy(n,l){var o=n.document.documentElement,r=qt(n).on("dragstart.drag",null);l&&(r.on("click.drag",ti,xo),setTimeout(function(){r.on("click.drag",null)},0)),"onselectstart"in o?r.on("selectstart.drag",null):(o.style.MozUserSelect=o.__noselect,delete o.__noselect)}const uu=n=>()=>n;function Hf(n,{sourceEvent:l,subject:o,target:r,identifier:u,active:f,x:d,y:h,dx:m,dy:g,dispatch:v}){Object.defineProperties(this,{type:{value:n,enumerable:!0,configurable:!0},sourceEvent:{value:l,enumerable:!0,configurable:!0},subject:{value:o,enumerable:!0,configurable:!0},target:{value:r,enumerable:!0,configurable:!0},identifier:{value:u,enumerable:!0,configurable:!0},active:{value:f,enumerable:!0,configurable:!0},x:{value:d,enumerable:!0,configurable:!0},y:{value:h,enumerable:!0,configurable:!0},dx:{value:m,enumerable:!0,configurable:!0},dy:{value:g,enumerable:!0,configurable:!0},_:{value:v}})}Hf.prototype.on=function(){var n=this._.on.apply(this._,arguments);return n===this._?this:n};function k1(n){return!n.ctrlKey&&!n.button}function R1(){return this.parentNode}function j1(n,l){return l??{x:n.x,y:n.y}}function O1(){return navigator.maxTouchPoints||"ontouchstart"in this}function Wy(){var n=k1,l=R1,o=j1,r=O1,u={},f=Bu("start","drag","end"),d=0,h,m,g,v,p=0;function b(D){D.on("mousedown.drag",x).filter(r).on("touchstart.drag",z).on("touchmove.drag",A,D1).on("touchend.drag touchcancel.drag",R).style("touch-action","none").style("-webkit-tap-highlight-color","rgba(0,0,0,0)")}function x(D,H){if(!(v||!n.call(this,D,H))){var j=S(this,l.call(this,D,H),D,H,"mouse");j&&(qt(D.view).on("mousemove.drag",_,xo).on("mouseup.drag",T,xo),Iy(D.view),pf(D),g=!1,h=D.clientX,m=D.clientY,j("start",D))}}function _(D){if(ti(D),!g){var H=D.clientX-h,j=D.clientY-m;g=H*H+j*j>p}u.mouse("drag",D)}function T(D){qt(D.view).on("mousemove.drag mouseup.drag",null),Jy(D.view,g),ti(D),u.mouse("end",D)}function z(D,H){if(n.call(this,D,H)){var j=D.changedTouches,k=l.call(this,D,H),q=j.length,Z,ie;for(Z=0;Z<q;++Z)(ie=S(this,k,D,H,j[Z].identifier,j[Z]))&&(pf(D),ie("start",D,j[Z]))}}function A(D){var H=D.changedTouches,j=H.length,k,q;for(k=0;k<j;++k)(q=u[H[k].identifier])&&(ti(D),q("drag",D,H[k]))}function R(D){var H=D.changedTouches,j=H.length,k,q;for(v&&clearTimeout(v),v=setTimeout(function(){v=null},500),k=0;k<j;++k)(q=u[H[k].identifier])&&(pf(D),q("end",D,H[k]))}function S(D,H,j,k,q,Z){var ie=f.copy(),J=rn(Z||j,H),ne,P,C;if((C=o.call(D,new Hf("beforestart",{sourceEvent:j,target:b,identifier:q,active:d,x:J[0],y:J[1],dx:0,dy:0,dispatch:ie}),k))!=null)return ne=C.x-J[0]||0,P=C.y-J[1]||0,function V(M,B,X){var Y=J,U;switch(M){case"start":u[q]=V,U=d++;break;case"end":delete u[q],--d;case"drag":J=rn(X||B,H),U=d;break}ie.call(M,D,new Hf(M,{sourceEvent:B,subject:C,target:b,identifier:q,active:U,x:J[0]+ne,y:J[1]+P,dx:J[0]-Y[0],dy:J[1]-Y[1],dispatch:ie}),k)}}return b.filter=function(D){return arguments.length?(n=typeof D=="function"?D:uu(!!D),b):n},b.container=function(D){return arguments.length?(l=typeof D=="function"?D:uu(D),b):l},b.subject=function(D){return arguments.length?(o=typeof D=="function"?D:uu(D),b):o},b.touchable=function(D){return arguments.length?(r=typeof D=="function"?D:uu(!!D),b):r},b.on=function(){var D=f.on.apply(f,arguments);return D===f?b:D},b.clickDistance=function(D){return arguments.length?(p=(D=+D)*D,b):Math.sqrt(p)},b}function ud(n,l,o){n.prototype=l.prototype=o,o.constructor=n}function Fy(n,l){var o=Object.create(n.prototype);for(var r in l)o[r]=l[r];return o}function Ro(){}var _o=.7,Nu=1/_o,ni="\\s*([+-]?\\d+)\\s*",wo="\\s*([+-]?(?:\\d*\\.)?\\d+(?:[eE][+-]?\\d+)?)\\s*",_n="\\s*([+-]?(?:\\d*\\.)?\\d+(?:[eE][+-]?\\d+)?)%\\s*",H1=/^#([0-9a-f]{3,8})$/,B1=new RegExp(`^rgb\\(${ni},${ni},${ni}\\)$`),L1=new RegExp(`^rgb\\(${_n},${_n},${_n}\\)$`),U1=new RegExp(`^rgba\\(${ni},${ni},${ni},${wo}\\)$`),G1=new RegExp(`^rgba\\(${_n},${_n},${_n},${wo}\\)$`),q1=new RegExp(`^hsl\\(${wo},${_n},${_n}\\)$`),Y1=new RegExp(`^hsla\\(${wo},${_n},${_n},${wo}\\)$`),bm={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};ud(Ro,tl,{copy(n){return Object.assign(new this.constructor,this,n)},displayable(){return this.rgb().displayable()},hex:xm,formatHex:xm,formatHex8:V1,formatHsl:X1,formatRgb:_m,toString:_m});function xm(){return this.rgb().formatHex()}function V1(){return this.rgb().formatHex8()}function X1(){return Py(this).formatHsl()}function _m(){return this.rgb().formatRgb()}function tl(n){var l,o;return n=(n+"").trim().toLowerCase(),(l=H1.exec(n))?(o=l[1].length,l=parseInt(l[1],16),o===6?wm(l):o===3?new Dt(l>>8&15|l>>4&240,l>>4&15|l&240,(l&15)<<4|l&15,1):o===8?su(l>>24&255,l>>16&255,l>>8&255,(l&255)/255):o===4?su(l>>12&15|l>>8&240,l>>8&15|l>>4&240,l>>4&15|l&240,((l&15)<<4|l&15)/255):null):(l=B1.exec(n))?new Dt(l[1],l[2],l[3],1):(l=L1.exec(n))?new Dt(l[1]*255/100,l[2]*255/100,l[3]*255/100,1):(l=U1.exec(n))?su(l[1],l[2],l[3],l[4]):(l=G1.exec(n))?su(l[1]*255/100,l[2]*255/100,l[3]*255/100,l[4]):(l=q1.exec(n))?Nm(l[1],l[2]/100,l[3]/100,1):(l=Y1.exec(n))?Nm(l[1],l[2]/100,l[3]/100,l[4]):bm.hasOwnProperty(n)?wm(bm[n]):n==="transparent"?new Dt(NaN,NaN,NaN,0):null}function wm(n){return new Dt(n>>16&255,n>>8&255,n&255,1)}function su(n,l,o,r){return r<=0&&(n=l=o=NaN),new Dt(n,l,o,r)}function Q1(n){return n instanceof Ro||(n=tl(n)),n?(n=n.rgb(),new Dt(n.r,n.g,n.b,n.opacity)):new Dt}function Bf(n,l,o,r){return arguments.length===1?Q1(n):new Dt(n,l,o,r??1)}function Dt(n,l,o,r){this.r=+n,this.g=+l,this.b=+o,this.opacity=+r}ud(Dt,Bf,Fy(Ro,{brighter(n){return n=n==null?Nu:Math.pow(Nu,n),new Dt(this.r*n,this.g*n,this.b*n,this.opacity)},darker(n){return n=n==null?_o:Math.pow(_o,n),new Dt(this.r*n,this.g*n,this.b*n,this.opacity)},rgb(){return this},clamp(){return new Dt(Pa(this.r),Pa(this.g),Pa(this.b),Tu(this.opacity))},displayable(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:Sm,formatHex:Sm,formatHex8:$1,formatRgb:Em,toString:Em}));function Sm(){return`#${Fa(this.r)}${Fa(this.g)}${Fa(this.b)}`}function $1(){return`#${Fa(this.r)}${Fa(this.g)}${Fa(this.b)}${Fa((isNaN(this.opacity)?1:this.opacity)*255)}`}function Em(){const n=Tu(this.opacity);return`${n===1?"rgb(":"rgba("}${Pa(this.r)}, ${Pa(this.g)}, ${Pa(this.b)}${n===1?")":`, ${n})`}`}function Tu(n){return isNaN(n)?1:Math.max(0,Math.min(1,n))}function Pa(n){return Math.max(0,Math.min(255,Math.round(n)||0))}function Fa(n){return n=Pa(n),(n<16?"0":"")+n.toString(16)}function Nm(n,l,o,r){return r<=0?n=l=o=NaN:o<=0||o>=1?n=l=NaN:l<=0&&(n=NaN),new un(n,l,o,r)}function Py(n){if(n instanceof un)return new un(n.h,n.s,n.l,n.opacity);if(n instanceof Ro||(n=tl(n)),!n)return new un;if(n instanceof un)return n;n=n.rgb();var l=n.r/255,o=n.g/255,r=n.b/255,u=Math.min(l,o,r),f=Math.max(l,o,r),d=NaN,h=f-u,m=(f+u)/2;return h?(l===f?d=(o-r)/h+(o<r)*6:o===f?d=(r-l)/h+2:d=(l-o)/h+4,h/=m<.5?f+u:2-f-u,d*=60):h=m>0&&m<1?0:d,new un(d,h,m,n.opacity)}function Z1(n,l,o,r){return arguments.length===1?Py(n):new un(n,l,o,r??1)}function un(n,l,o,r){this.h=+n,this.s=+l,this.l=+o,this.opacity=+r}ud(un,Z1,Fy(Ro,{brighter(n){return n=n==null?Nu:Math.pow(Nu,n),new un(this.h,this.s,this.l*n,this.opacity)},darker(n){return n=n==null?_o:Math.pow(_o,n),new un(this.h,this.s,this.l*n,this.opacity)},rgb(){var n=this.h%360+(this.h<0)*360,l=isNaN(n)||isNaN(this.s)?0:this.s,o=this.l,r=o+(o<.5?o:1-o)*l,u=2*o-r;return new Dt(vf(n>=240?n-240:n+120,u,r),vf(n,u,r),vf(n<120?n+240:n-120,u,r),this.opacity)},clamp(){return new un(Tm(this.h),cu(this.s),cu(this.l),Tu(this.opacity))},displayable(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl(){const n=Tu(this.opacity);return`${n===1?"hsl(":"hsla("}${Tm(this.h)}, ${cu(this.s)*100}%, ${cu(this.l)*100}%${n===1?")":`, ${n})`}`}}));function Tm(n){return n=(n||0)%360,n<0?n+360:n}function cu(n){return Math.max(0,Math.min(1,n||0))}function vf(n,l,o){return(n<60?l+(o-l)*n/60:n<180?o:n<240?l+(o-l)*(240-n)/60:l)*255}const sd=n=>()=>n;function K1(n,l){return function(o){return n+o*l}}function I1(n,l,o){return n=Math.pow(n,o),l=Math.pow(l,o)-n,o=1/o,function(r){return Math.pow(n+r*l,o)}}function J1(n){return(n=+n)==1?ep:function(l,o){return o-l?I1(l,o,n):sd(isNaN(l)?o:l)}}function ep(n,l){var o=l-n;return o?K1(n,o):sd(isNaN(n)?l:n)}const Au=(function n(l){var o=J1(l);function r(u,f){var d=o((u=Bf(u)).r,(f=Bf(f)).r),h=o(u.g,f.g),m=o(u.b,f.b),g=ep(u.opacity,f.opacity);return function(v){return u.r=d(v),u.g=h(v),u.b=m(v),u.opacity=g(v),u+""}}return r.gamma=n,r})(1);function W1(n,l){l||(l=[]);var o=n?Math.min(l.length,n.length):0,r=l.slice(),u;return function(f){for(u=0;u<o;++u)r[u]=n[u]*(1-f)+l[u]*f;return r}}function F1(n){return ArrayBuffer.isView(n)&&!(n instanceof DataView)}function P1(n,l){var o=l?l.length:0,r=n?Math.min(o,n.length):0,u=new Array(r),f=new Array(o),d;for(d=0;d<r;++d)u[d]=po(n[d],l[d]);for(;d<o;++d)f[d]=l[d];return function(h){for(d=0;d<r;++d)f[d]=u[d](h);return f}}function ew(n,l){var o=new Date;return n=+n,l=+l,function(r){return o.setTime(n*(1-r)+l*r),o}}function xn(n,l){return n=+n,l=+l,function(o){return n*(1-o)+l*o}}function tw(n,l){var o={},r={},u;(n===null||typeof n!="object")&&(n={}),(l===null||typeof l!="object")&&(l={});for(u in l)u in n?o[u]=po(n[u],l[u]):r[u]=l[u];return function(f){for(u in o)r[u]=o[u](f);return r}}var Lf=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,bf=new RegExp(Lf.source,"g");function nw(n){return function(){return n}}function aw(n){return function(l){return n(l)+""}}function tp(n,l){var o=Lf.lastIndex=bf.lastIndex=0,r,u,f,d=-1,h=[],m=[];for(n=n+"",l=l+"";(r=Lf.exec(n))&&(u=bf.exec(l));)(f=u.index)>o&&(f=l.slice(o,f),h[d]?h[d]+=f:h[++d]=f),(r=r[0])===(u=u[0])?h[d]?h[d]+=u:h[++d]=u:(h[++d]=null,m.push({i:d,x:xn(r,u)})),o=bf.lastIndex;return o<l.length&&(f=l.slice(o),h[d]?h[d]+=f:h[++d]=f),h.length<2?m[0]?aw(m[0].x):nw(l):(l=m.length,function(g){for(var v=0,p;v<l;++v)h[(p=m[v]).i]=p.x(g);return h.join("")})}function po(n,l){var o=typeof l,r;return l==null||o==="boolean"?sd(l):(o==="number"?xn:o==="string"?(r=tl(l))?(l=r,Au):tp:l instanceof tl?Au:l instanceof Date?ew:F1(l)?W1:Array.isArray(l)?P1:typeof l.valueOf!="function"&&typeof l.toString!="function"||isNaN(l)?tw:xn)(n,l)}var Am=180/Math.PI,Uf={translateX:0,translateY:0,rotate:0,skewX:0,scaleX:1,scaleY:1};function np(n,l,o,r,u,f){var d,h,m;return(d=Math.sqrt(n*n+l*l))&&(n/=d,l/=d),(m=n*o+l*r)&&(o-=n*m,r-=l*m),(h=Math.sqrt(o*o+r*r))&&(o/=h,r/=h,m/=h),n*r<l*o&&(n=-n,l=-l,m=-m,d=-d),{translateX:u,translateY:f,rotate:Math.atan2(l,n)*Am,skewX:Math.atan(m)*Am,scaleX:d,scaleY:h}}var fu;function lw(n){const l=new(typeof DOMMatrix=="function"?DOMMatrix:WebKitCSSMatrix)(n+"");return l.isIdentity?Uf:np(l.a,l.b,l.c,l.d,l.e,l.f)}function iw(n){return n==null||(fu||(fu=document.createElementNS("http://www.w3.org/2000/svg","g")),fu.setAttribute("transform",n),!(n=fu.transform.baseVal.consolidate()))?Uf:(n=n.matrix,np(n.a,n.b,n.c,n.d,n.e,n.f))}function ap(n,l,o,r){function u(g){return g.length?g.pop()+" ":""}function f(g,v,p,b,x,_){if(g!==p||v!==b){var T=x.push("translate(",null,l,null,o);_.push({i:T-4,x:xn(g,p)},{i:T-2,x:xn(v,b)})}else(p||b)&&x.push("translate("+p+l+b+o)}function d(g,v,p,b){g!==v?(g-v>180?v+=360:v-g>180&&(g+=360),b.push({i:p.push(u(p)+"rotate(",null,r)-2,x:xn(g,v)})):v&&p.push(u(p)+"rotate("+v+r)}function h(g,v,p,b){g!==v?b.push({i:p.push(u(p)+"skewX(",null,r)-2,x:xn(g,v)}):v&&p.push(u(p)+"skewX("+v+r)}function m(g,v,p,b,x,_){if(g!==p||v!==b){var T=x.push(u(x)+"scale(",null,",",null,")");_.push({i:T-4,x:xn(g,p)},{i:T-2,x:xn(v,b)})}else(p!==1||b!==1)&&x.push(u(x)+"scale("+p+","+b+")")}return function(g,v){var p=[],b=[];return g=n(g),v=n(v),f(g.translateX,g.translateY,v.translateX,v.translateY,p,b),d(g.rotate,v.rotate,p,b),h(g.skewX,v.skewX,p,b),m(g.scaleX,g.scaleY,v.scaleX,v.scaleY,p,b),g=v=null,function(x){for(var _=-1,T=b.length,z;++_<T;)p[(z=b[_]).i]=z.x(x);return p.join("")}}}var ow=ap(lw,"px, ","px)","deg)"),rw=ap(iw,", ",")",")"),uw=1e-12;function Mm(n){return((n=Math.exp(n))+1/n)/2}function sw(n){return((n=Math.exp(n))-1/n)/2}function cw(n){return((n=Math.exp(2*n))-1)/(n+1)}const bu=(function n(l,o,r){function u(f,d){var h=f[0],m=f[1],g=f[2],v=d[0],p=d[1],b=d[2],x=v-h,_=p-m,T=x*x+_*_,z,A;if(T<uw)A=Math.log(b/g)/l,z=function(k){return[h+k*x,m+k*_,g*Math.exp(l*k*A)]};else{var R=Math.sqrt(T),S=(b*b-g*g+r*T)/(2*g*o*R),D=(b*b-g*g-r*T)/(2*b*o*R),H=Math.log(Math.sqrt(S*S+1)-S),j=Math.log(Math.sqrt(D*D+1)-D);A=(j-H)/l,z=function(k){var q=k*A,Z=Mm(H),ie=g/(o*R)*(Z*cw(l*q+H)-sw(H));return[h+ie*x,m+ie*_,g*Z/Mm(l*q+H)]}}return z.duration=A*1e3*l/Math.SQRT2,z}return u.rho=function(f){var d=Math.max(.001,+f),h=d*d,m=h*h;return n(d,h,m)},u})(Math.SQRT2,2,4);var li=0,mo=0,fo=0,lp=1e3,Mu,yo,zu=0,nl=0,Uu=0,So=typeof performance=="object"&&performance.now?performance:Date,ip=typeof window=="object"&&window.requestAnimationFrame?window.requestAnimationFrame.bind(window):function(n){setTimeout(n,17)};function cd(){return nl||(ip(fw),nl=So.now()+Uu)}function fw(){nl=0}function Cu(){this._call=this._time=this._next=null}Cu.prototype=op.prototype={constructor:Cu,restart:function(n,l,o){if(typeof n!="function")throw new TypeError("callback is not a function");o=(o==null?cd():+o)+(l==null?0:+l),!this._next&&yo!==this&&(yo?yo._next=this:Mu=this,yo=this),this._call=n,this._time=o,Gf()},stop:function(){this._call&&(this._call=null,this._time=1/0,Gf())}};function op(n,l,o){var r=new Cu;return r.restart(n,l,o),r}function dw(){cd(),++li;for(var n=Mu,l;n;)(l=nl-n._time)>=0&&n._call.call(void 0,l),n=n._next;--li}function zm(){nl=(zu=So.now())+Uu,li=mo=0;try{dw()}finally{li=0,gw(),nl=0}}function hw(){var n=So.now(),l=n-zu;l>lp&&(Uu-=l,zu=n)}function gw(){for(var n,l=Mu,o,r=1/0;l;)l._call?(r>l._time&&(r=l._time),n=l,l=l._next):(o=l._next,l._next=null,l=n?n._next=o:Mu=o);yo=n,Gf(r)}function Gf(n){if(!li){mo&&(mo=clearTimeout(mo));var l=n-nl;l>24?(n<1/0&&(mo=setTimeout(zm,n-So.now()-Uu)),fo&&(fo=clearInterval(fo))):(fo||(zu=So.now(),fo=setInterval(hw,lp)),li=1,ip(zm))}}function Cm(n,l,o){var r=new Cu;return l=l==null?0:+l,r.restart(u=>{r.stop(),n(u+l)},l,o),r}var mw=Bu("start","end","cancel","interrupt"),yw=[],rp=0,Dm=1,qf=2,xu=3,km=4,Yf=5,_u=6;function Gu(n,l,o,r,u,f){var d=n.__transition;if(!d)n.__transition={};else if(o in d)return;pw(n,o,{name:l,index:r,group:u,on:mw,tween:yw,time:f.time,delay:f.delay,duration:f.duration,ease:f.ease,timer:null,state:rp})}function fd(n,l){var o=dn(n,l);if(o.state>rp)throw new Error("too late; already scheduled");return o}function Sn(n,l){var o=dn(n,l);if(o.state>xu)throw new Error("too late; already running");return o}function dn(n,l){var o=n.__transition;if(!o||!(o=o[l]))throw new Error("transition not found");return o}function pw(n,l,o){var r=n.__transition,u;r[l]=o,o.timer=op(f,0,o.time);function f(g){o.state=Dm,o.timer.restart(d,o.delay,o.time),o.delay<=g&&d(g-o.delay)}function d(g){var v,p,b,x;if(o.state!==Dm)return m();for(v in r)if(x=r[v],x.name===o.name){if(x.state===xu)return Cm(d);x.state===km?(x.state=_u,x.timer.stop(),x.on.call("interrupt",n,n.__data__,x.index,x.group),delete r[v]):+v<l&&(x.state=_u,x.timer.stop(),x.on.call("cancel",n,n.__data__,x.index,x.group),delete r[v])}if(Cm(function(){o.state===xu&&(o.state=km,o.timer.restart(h,o.delay,o.time),h(g))}),o.state=qf,o.on.call("start",n,n.__data__,o.index,o.group),o.state===qf){for(o.state=xu,u=new Array(b=o.tween.length),v=0,p=-1;v<b;++v)(x=o.tween[v].value.call(n,n.__data__,o.index,o.group))&&(u[++p]=x);u.length=p+1}}function h(g){for(var v=g<o.duration?o.ease.call(null,g/o.duration):(o.timer.restart(m),o.state=Yf,1),p=-1,b=u.length;++p<b;)u[p].call(n,v);o.state===Yf&&(o.on.call("end",n,n.__data__,o.index,o.group),m())}function m(){o.state=_u,o.timer.stop(),delete r[l];for(var g in r)return;delete n.__transition}}function wu(n,l){var o=n.__transition,r,u,f=!0,d;if(o){l=l==null?null:l+"";for(d in o){if((r=o[d]).name!==l){f=!1;continue}u=r.state>qf&&r.state<Yf,r.state=_u,r.timer.stop(),r.on.call(u?"interrupt":"cancel",n,n.__data__,r.index,r.group),delete o[d]}f&&delete n.__transition}}function vw(n){return this.each(function(){wu(this,n)})}function bw(n,l){var o,r;return function(){var u=Sn(this,n),f=u.tween;if(f!==o){r=o=f;for(var d=0,h=r.length;d<h;++d)if(r[d].name===l){r=r.slice(),r.splice(d,1);break}}u.tween=r}}function xw(n,l,o){var r,u;if(typeof o!="function")throw new Error;return function(){var f=Sn(this,n),d=f.tween;if(d!==r){u=(r=d).slice();for(var h={name:l,value:o},m=0,g=u.length;m<g;++m)if(u[m].name===l){u[m]=h;break}m===g&&u.push(h)}f.tween=u}}function _w(n,l){var o=this._id;if(n+="",arguments.length<2){for(var r=dn(this.node(),o).tween,u=0,f=r.length,d;u<f;++u)if((d=r[u]).name===n)return d.value;return null}return this.each((l==null?bw:xw)(o,n,l))}function dd(n,l,o){var r=n._id;return n.each(function(){var u=Sn(this,r);(u.value||(u.value={}))[l]=o.apply(this,arguments)}),function(u){return dn(u,r).value[l]}}function up(n,l){var o;return(typeof l=="number"?xn:l instanceof tl?Au:(o=tl(l))?(l=o,Au):tp)(n,l)}function ww(n){return function(){this.removeAttribute(n)}}function Sw(n){return function(){this.removeAttributeNS(n.space,n.local)}}function Ew(n,l,o){var r,u=o+"",f;return function(){var d=this.getAttribute(n);return d===u?null:d===r?f:f=l(r=d,o)}}function Nw(n,l,o){var r,u=o+"",f;return function(){var d=this.getAttributeNS(n.space,n.local);return d===u?null:d===r?f:f=l(r=d,o)}}function Tw(n,l,o){var r,u,f;return function(){var d,h=o(this),m;return h==null?void this.removeAttribute(n):(d=this.getAttribute(n),m=h+"",d===m?null:d===r&&m===u?f:(u=m,f=l(r=d,h)))}}function Aw(n,l,o){var r,u,f;return function(){var d,h=o(this),m;return h==null?void this.removeAttributeNS(n.space,n.local):(d=this.getAttributeNS(n.space,n.local),m=h+"",d===m?null:d===r&&m===u?f:(u=m,f=l(r=d,h)))}}function Mw(n,l){var o=Lu(n),r=o==="transform"?rw:up;return this.attrTween(n,typeof l=="function"?(o.local?Aw:Tw)(o,r,dd(this,"attr."+n,l)):l==null?(o.local?Sw:ww)(o):(o.local?Nw:Ew)(o,r,l))}function zw(n,l){return function(o){this.setAttribute(n,l.call(this,o))}}function Cw(n,l){return function(o){this.setAttributeNS(n.space,n.local,l.call(this,o))}}function Dw(n,l){var o,r;function u(){var f=l.apply(this,arguments);return f!==r&&(o=(r=f)&&Cw(n,f)),o}return u._value=l,u}function kw(n,l){var o,r;function u(){var f=l.apply(this,arguments);return f!==r&&(o=(r=f)&&zw(n,f)),o}return u._value=l,u}function Rw(n,l){var o="attr."+n;if(arguments.length<2)return(o=this.tween(o))&&o._value;if(l==null)return this.tween(o,null);if(typeof l!="function")throw new Error;var r=Lu(n);return this.tween(o,(r.local?Dw:kw)(r,l))}function jw(n,l){return function(){fd(this,n).delay=+l.apply(this,arguments)}}function Ow(n,l){return l=+l,function(){fd(this,n).delay=l}}function Hw(n){var l=this._id;return arguments.length?this.each((typeof n=="function"?jw:Ow)(l,n)):dn(this.node(),l).delay}function Bw(n,l){return function(){Sn(this,n).duration=+l.apply(this,arguments)}}function Lw(n,l){return l=+l,function(){Sn(this,n).duration=l}}function Uw(n){var l=this._id;return arguments.length?this.each((typeof n=="function"?Bw:Lw)(l,n)):dn(this.node(),l).duration}function Gw(n,l){if(typeof l!="function")throw new Error;return function(){Sn(this,n).ease=l}}function qw(n){var l=this._id;return arguments.length?this.each(Gw(l,n)):dn(this.node(),l).ease}function Yw(n,l){return function(){var o=l.apply(this,arguments);if(typeof o!="function")throw new Error;Sn(this,n).ease=o}}function Vw(n){if(typeof n!="function")throw new Error;return this.each(Yw(this._id,n))}function Xw(n){typeof n!="function"&&(n=Uy(n));for(var l=this._groups,o=l.length,r=new Array(o),u=0;u<o;++u)for(var f=l[u],d=f.length,h=r[u]=[],m,g=0;g<d;++g)(m=f[g])&&n.call(m,m.__data__,g,f)&&h.push(m);return new Kn(r,this._parents,this._name,this._id)}function Qw(n){if(n._id!==this._id)throw new Error;for(var l=this._groups,o=n._groups,r=l.length,u=o.length,f=Math.min(r,u),d=new Array(r),h=0;h<f;++h)for(var m=l[h],g=o[h],v=m.length,p=d[h]=new Array(v),b,x=0;x<v;++x)(b=m[x]||g[x])&&(p[x]=b);for(;h<r;++h)d[h]=l[h];return new Kn(d,this._parents,this._name,this._id)}function $w(n){return(n+"").trim().split(/^|\s+/).every(function(l){var o=l.indexOf(".");return o>=0&&(l=l.slice(0,o)),!l||l==="start"})}function Zw(n,l,o){var r,u,f=$w(l)?fd:Sn;return function(){var d=f(this,n),h=d.on;h!==r&&(u=(r=h).copy()).on(l,o),d.on=u}}function Kw(n,l){var o=this._id;return arguments.length<2?dn(this.node(),o).on.on(n):this.each(Zw(o,n,l))}function Iw(n){return function(){var l=this.parentNode;for(var o in this.__transition)if(+o!==n)return;l&&l.removeChild(this)}}function Jw(){return this.on("end.remove",Iw(this._id))}function Ww(n){var l=this._name,o=this._id;typeof n!="function"&&(n=od(n));for(var r=this._groups,u=r.length,f=new Array(u),d=0;d<u;++d)for(var h=r[d],m=h.length,g=f[d]=new Array(m),v,p,b=0;b<m;++b)(v=h[b])&&(p=n.call(v,v.__data__,b,h))&&("__data__"in v&&(p.__data__=v.__data__),g[b]=p,Gu(g[b],l,o,b,g,dn(v,o)));return new Kn(f,this._parents,l,o)}function Fw(n){var l=this._name,o=this._id;typeof n!="function"&&(n=Ly(n));for(var r=this._groups,u=r.length,f=[],d=[],h=0;h<u;++h)for(var m=r[h],g=m.length,v,p=0;p<g;++p)if(v=m[p]){for(var b=n.call(v,v.__data__,p,m),x,_=dn(v,o),T=0,z=b.length;T<z;++T)(x=b[T])&&Gu(x,l,o,T,b,_);f.push(b),d.push(v)}return new Kn(f,d,l,o)}var Pw=ko.prototype.constructor;function eS(){return new Pw(this._groups,this._parents)}function tS(n,l){var o,r,u;return function(){var f=ai(this,n),d=(this.style.removeProperty(n),ai(this,n));return f===d?null:f===o&&d===r?u:u=l(o=f,r=d)}}function sp(n){return function(){this.style.removeProperty(n)}}function nS(n,l,o){var r,u=o+"",f;return function(){var d=ai(this,n);return d===u?null:d===r?f:f=l(r=d,o)}}function aS(n,l,o){var r,u,f;return function(){var d=ai(this,n),h=o(this),m=h+"";return h==null&&(m=h=(this.style.removeProperty(n),ai(this,n))),d===m?null:d===r&&m===u?f:(u=m,f=l(r=d,h))}}function lS(n,l){var o,r,u,f="style."+l,d="end."+f,h;return function(){var m=Sn(this,n),g=m.on,v=m.value[f]==null?h||(h=sp(l)):void 0;(g!==o||u!==v)&&(r=(o=g).copy()).on(d,u=v),m.on=r}}function iS(n,l,o){var r=(n+="")=="transform"?ow:up;return l==null?this.styleTween(n,tS(n,r)).on("end.style."+n,sp(n)):typeof l=="function"?this.styleTween(n,aS(n,r,dd(this,"style."+n,l))).each(lS(this._id,n)):this.styleTween(n,nS(n,r,l),o).on("end.style."+n,null)}function oS(n,l,o){return function(r){this.style.setProperty(n,l.call(this,r),o)}}function rS(n,l,o){var r,u;function f(){var d=l.apply(this,arguments);return d!==u&&(r=(u=d)&&oS(n,d,o)),r}return f._value=l,f}function uS(n,l,o){var r="style."+(n+="");if(arguments.length<2)return(r=this.tween(r))&&r._value;if(l==null)return this.tween(r,null);if(typeof l!="function")throw new Error;return this.tween(r,rS(n,l,o??""))}function sS(n){return function(){this.textContent=n}}function cS(n){return function(){var l=n(this);this.textContent=l??""}}function fS(n){return this.tween("text",typeof n=="function"?cS(dd(this,"text",n)):sS(n==null?"":n+""))}function dS(n){return function(l){this.textContent=n.call(this,l)}}function hS(n){var l,o;function r(){var u=n.apply(this,arguments);return u!==o&&(l=(o=u)&&dS(u)),l}return r._value=n,r}function gS(n){var l="text";if(arguments.length<1)return(l=this.tween(l))&&l._value;if(n==null)return this.tween(l,null);if(typeof n!="function")throw new Error;return this.tween(l,hS(n))}function mS(){for(var n=this._name,l=this._id,o=cp(),r=this._groups,u=r.length,f=0;f<u;++f)for(var d=r[f],h=d.length,m,g=0;g<h;++g)if(m=d[g]){var v=dn(m,l);Gu(m,n,o,g,d,{time:v.time+v.delay+v.duration,delay:0,duration:v.duration,ease:v.ease})}return new Kn(r,this._parents,n,o)}function yS(){var n,l,o=this,r=o._id,u=o.size();return new Promise(function(f,d){var h={value:d},m={value:function(){--u===0&&f()}};o.each(function(){var g=Sn(this,r),v=g.on;v!==n&&(l=(n=v).copy(),l._.cancel.push(h),l._.interrupt.push(h),l._.end.push(m)),g.on=l}),u===0&&f()})}var pS=0;function Kn(n,l,o,r){this._groups=n,this._parents=l,this._name=o,this._id=r}function cp(){return++pS}var $n=ko.prototype;Kn.prototype={constructor:Kn,select:Ww,selectAll:Fw,selectChild:$n.selectChild,selectChildren:$n.selectChildren,filter:Xw,merge:Qw,selection:eS,transition:mS,call:$n.call,nodes:$n.nodes,node:$n.node,size:$n.size,empty:$n.empty,each:$n.each,on:Kw,attr:Mw,attrTween:Rw,style:iS,styleTween:uS,text:fS,textTween:gS,remove:Jw,tween:_w,delay:Hw,duration:Uw,ease:qw,easeVarying:Vw,end:yS,[Symbol.iterator]:$n[Symbol.iterator]};function vS(n){return((n*=2)<=1?n*n*n:(n-=2)*n*n+2)/2}var bS={time:null,delay:0,duration:250,ease:vS};function xS(n,l){for(var o;!(o=n.__transition)||!(o=o[l]);)if(!(n=n.parentNode))throw new Error(`transition ${l} not found`);return o}function _S(n){var l,o;n instanceof Kn?(l=n._id,n=n._name):(l=cp(),(o=bS).time=cd(),n=n==null?null:n+"");for(var r=this._groups,u=r.length,f=0;f<u;++f)for(var d=r[f],h=d.length,m,g=0;g<h;++g)(m=d[g])&&Gu(m,n,l,g,d,o||xS(m,l));return new Kn(r,this._parents,n,l)}ko.prototype.interrupt=vw;ko.prototype.transition=_S;const du=n=>()=>n;function wS(n,{sourceEvent:l,target:o,transform:r,dispatch:u}){Object.defineProperties(this,{type:{value:n,enumerable:!0,configurable:!0},sourceEvent:{value:l,enumerable:!0,configurable:!0},target:{value:o,enumerable:!0,configurable:!0},transform:{value:r,enumerable:!0,configurable:!0},_:{value:u}})}function Zn(n,l,o){this.k=n,this.x=l,this.y=o}Zn.prototype={constructor:Zn,scale:function(n){return n===1?this:new Zn(this.k*n,this.x,this.y)},translate:function(n,l){return n===0&l===0?this:new Zn(this.k,this.x+this.k*n,this.y+this.k*l)},apply:function(n){return[n[0]*this.k+this.x,n[1]*this.k+this.y]},applyX:function(n){return n*this.k+this.x},applyY:function(n){return n*this.k+this.y},invert:function(n){return[(n[0]-this.x)/this.k,(n[1]-this.y)/this.k]},invertX:function(n){return(n-this.x)/this.k},invertY:function(n){return(n-this.y)/this.k},rescaleX:function(n){return n.copy().domain(n.range().map(this.invertX,this).map(n.invert,n))},rescaleY:function(n){return n.copy().domain(n.range().map(this.invertY,this).map(n.invert,n))},toString:function(){return"translate("+this.x+","+this.y+") scale("+this.k+")"}};var qu=new Zn(1,0,0);fp.prototype=Zn.prototype;function fp(n){for(;!n.__zoom;)if(!(n=n.parentNode))return qu;return n.__zoom}function xf(n){n.stopImmediatePropagation()}function ho(n){n.preventDefault(),n.stopImmediatePropagation()}function SS(n){return(!n.ctrlKey||n.type==="wheel")&&!n.button}function ES(){var n=this;return n instanceof SVGElement?(n=n.ownerSVGElement||n,n.hasAttribute("viewBox")?(n=n.viewBox.baseVal,[[n.x,n.y],[n.x+n.width,n.y+n.height]]):[[0,0],[n.width.baseVal.value,n.height.baseVal.value]]):[[0,0],[n.clientWidth,n.clientHeight]]}function Rm(){return this.__zoom||qu}function NS(n){return-n.deltaY*(n.deltaMode===1?.05:n.deltaMode?1:.002)*(n.ctrlKey?10:1)}function TS(){return navigator.maxTouchPoints||"ontouchstart"in this}function AS(n,l,o){var r=n.invertX(l[0][0])-o[0][0],u=n.invertX(l[1][0])-o[1][0],f=n.invertY(l[0][1])-o[0][1],d=n.invertY(l[1][1])-o[1][1];return n.translate(u>r?(r+u)/2:Math.min(0,r)||Math.max(0,u),d>f?(f+d)/2:Math.min(0,f)||Math.max(0,d))}function dp(){var n=SS,l=ES,o=AS,r=NS,u=TS,f=[0,1/0],d=[[-1/0,-1/0],[1/0,1/0]],h=250,m=bu,g=Bu("start","zoom","end"),v,p,b,x=500,_=150,T=0,z=10;function A(C){C.property("__zoom",Rm).on("wheel.zoom",q,{passive:!1}).on("mousedown.zoom",Z).on("dblclick.zoom",ie).filter(u).on("touchstart.zoom",J).on("touchmove.zoom",ne).on("touchend.zoom touchcancel.zoom",P).style("-webkit-tap-highlight-color","rgba(0,0,0,0)")}A.transform=function(C,V,M,B){var X=C.selection?C.selection():C;X.property("__zoom",Rm),C!==X?H(C,V,M,B):X.interrupt().each(function(){j(this,arguments).event(B).start().zoom(null,typeof V=="function"?V.apply(this,arguments):V).end()})},A.scaleBy=function(C,V,M,B){A.scaleTo(C,function(){var X=this.__zoom.k,Y=typeof V=="function"?V.apply(this,arguments):V;return X*Y},M,B)},A.scaleTo=function(C,V,M,B){A.transform(C,function(){var X=l.apply(this,arguments),Y=this.__zoom,U=M==null?D(X):typeof M=="function"?M.apply(this,arguments):M,E=Y.invert(U),O=typeof V=="function"?V.apply(this,arguments):V;return o(S(R(Y,O),U,E),X,d)},M,B)},A.translateBy=function(C,V,M,B){A.transform(C,function(){return o(this.__zoom.translate(typeof V=="function"?V.apply(this,arguments):V,typeof M=="function"?M.apply(this,arguments):M),l.apply(this,arguments),d)},null,B)},A.translateTo=function(C,V,M,B,X){A.transform(C,function(){var Y=l.apply(this,arguments),U=this.__zoom,E=B==null?D(Y):typeof B=="function"?B.apply(this,arguments):B;return o(qu.translate(E[0],E[1]).scale(U.k).translate(typeof V=="function"?-V.apply(this,arguments):-V,typeof M=="function"?-M.apply(this,arguments):-M),Y,d)},B,X)};function R(C,V){return V=Math.max(f[0],Math.min(f[1],V)),V===C.k?C:new Zn(V,C.x,C.y)}function S(C,V,M){var B=V[0]-M[0]*C.k,X=V[1]-M[1]*C.k;return B===C.x&&X===C.y?C:new Zn(C.k,B,X)}function D(C){return[(+C[0][0]+ +C[1][0])/2,(+C[0][1]+ +C[1][1])/2]}function H(C,V,M,B){C.on("start.zoom",function(){j(this,arguments).event(B).start()}).on("interrupt.zoom end.zoom",function(){j(this,arguments).event(B).end()}).tween("zoom",function(){var X=this,Y=arguments,U=j(X,Y).event(B),E=l.apply(X,Y),O=M==null?D(E):typeof M=="function"?M.apply(X,Y):M,W=Math.max(E[1][0]-E[0][0],E[1][1]-E[0][1]),le=X.__zoom,ce=typeof V=="function"?V.apply(X,Y):V,me=m(le.invert(O).concat(W/le.k),ce.invert(O).concat(W/ce.k));return function(ge){if(ge===1)ge=ce;else{var ae=me(ge),fe=W/ae[2];ge=new Zn(fe,O[0]-ae[0]*fe,O[1]-ae[1]*fe)}U.zoom(null,ge)}})}function j(C,V,M){return!M&&C.__zooming||new k(C,V)}function k(C,V){this.that=C,this.args=V,this.active=0,this.sourceEvent=null,this.extent=l.apply(C,V),this.taps=0}k.prototype={event:function(C){return C&&(this.sourceEvent=C),this},start:function(){return++this.active===1&&(this.that.__zooming=this,this.emit("start")),this},zoom:function(C,V){return this.mouse&&C!=="mouse"&&(this.mouse[1]=V.invert(this.mouse[0])),this.touch0&&C!=="touch"&&(this.touch0[1]=V.invert(this.touch0[0])),this.touch1&&C!=="touch"&&(this.touch1[1]=V.invert(this.touch1[0])),this.that.__zoom=V,this.emit("zoom"),this},end:function(){return--this.active===0&&(delete this.that.__zooming,this.emit("end")),this},emit:function(C){var V=qt(this.that).datum();g.call(C,this.that,new wS(C,{sourceEvent:this.sourceEvent,target:A,transform:this.that.__zoom,dispatch:g}),V)}};function q(C,...V){if(!n.apply(this,arguments))return;var M=j(this,V).event(C),B=this.__zoom,X=Math.max(f[0],Math.min(f[1],B.k*Math.pow(2,r.apply(this,arguments)))),Y=rn(C);if(M.wheel)(M.mouse[0][0]!==Y[0]||M.mouse[0][1]!==Y[1])&&(M.mouse[1]=B.invert(M.mouse[0]=Y)),clearTimeout(M.wheel);else{if(B.k===X)return;M.mouse=[Y,B.invert(Y)],wu(this),M.start()}ho(C),M.wheel=setTimeout(U,_),M.zoom("mouse",o(S(R(B,X),M.mouse[0],M.mouse[1]),M.extent,d));function U(){M.wheel=null,M.end()}}function Z(C,...V){if(b||!n.apply(this,arguments))return;var M=C.currentTarget,B=j(this,V,!0).event(C),X=qt(C.view).on("mousemove.zoom",O,!0).on("mouseup.zoom",W,!0),Y=rn(C,M),U=C.clientX,E=C.clientY;Iy(C.view),xf(C),B.mouse=[Y,this.__zoom.invert(Y)],wu(this),B.start();function O(le){if(ho(le),!B.moved){var ce=le.clientX-U,me=le.clientY-E;B.moved=ce*ce+me*me>T}B.event(le).zoom("mouse",o(S(B.that.__zoom,B.mouse[0]=rn(le,M),B.mouse[1]),B.extent,d))}function W(le){X.on("mousemove.zoom mouseup.zoom",null),Jy(le.view,B.moved),ho(le),B.event(le).end()}}function ie(C,...V){if(n.apply(this,arguments)){var M=this.__zoom,B=rn(C.changedTouches?C.changedTouches[0]:C,this),X=M.invert(B),Y=M.k*(C.shiftKey?.5:2),U=o(S(R(M,Y),B,X),l.apply(this,V),d);ho(C),h>0?qt(this).transition().duration(h).call(H,U,B,C):qt(this).call(A.transform,U,B,C)}}function J(C,...V){if(n.apply(this,arguments)){var M=C.touches,B=M.length,X=j(this,V,C.changedTouches.length===B).event(C),Y,U,E,O;for(xf(C),U=0;U<B;++U)E=M[U],O=rn(E,this),O=[O,this.__zoom.invert(O),E.identifier],X.touch0?!X.touch1&&X.touch0[2]!==O[2]&&(X.touch1=O,X.taps=0):(X.touch0=O,Y=!0,X.taps=1+!!v);v&&(v=clearTimeout(v)),Y&&(X.taps<2&&(p=O[0],v=setTimeout(function(){v=null},x)),wu(this),X.start())}}function ne(C,...V){if(this.__zooming){var M=j(this,V).event(C),B=C.changedTouches,X=B.length,Y,U,E,O;for(ho(C),Y=0;Y<X;++Y)U=B[Y],E=rn(U,this),M.touch0&&M.touch0[2]===U.identifier?M.touch0[0]=E:M.touch1&&M.touch1[2]===U.identifier&&(M.touch1[0]=E);if(U=M.that.__zoom,M.touch1){var W=M.touch0[0],le=M.touch0[1],ce=M.touch1[0],me=M.touch1[1],ge=(ge=ce[0]-W[0])*ge+(ge=ce[1]-W[1])*ge,ae=(ae=me[0]-le[0])*ae+(ae=me[1]-le[1])*ae;U=R(U,Math.sqrt(ge/ae)),E=[(W[0]+ce[0])/2,(W[1]+ce[1])/2],O=[(le[0]+me[0])/2,(le[1]+me[1])/2]}else if(M.touch0)E=M.touch0[0],O=M.touch0[1];else return;M.zoom("touch",o(S(U,E,O),M.extent,d))}}function P(C,...V){if(this.__zooming){var M=j(this,V).event(C),B=C.changedTouches,X=B.length,Y,U;for(xf(C),b&&clearTimeout(b),b=setTimeout(function(){b=null},x),Y=0;Y<X;++Y)U=B[Y],M.touch0&&M.touch0[2]===U.identifier?delete M.touch0:M.touch1&&M.touch1[2]===U.identifier&&delete M.touch1;if(M.touch1&&!M.touch0&&(M.touch0=M.touch1,delete M.touch1),M.touch0)M.touch0[1]=this.__zoom.invert(M.touch0[0]);else if(M.end(),M.taps===2&&(U=rn(U,this),Math.hypot(p[0]-U[0],p[1]-U[1])<z)){var E=qt(this).on("dblclick.zoom");E&&E.apply(this,arguments)}}}return A.wheelDelta=function(C){return arguments.length?(r=typeof C=="function"?C:du(+C),A):r},A.filter=function(C){return arguments.length?(n=typeof C=="function"?C:du(!!C),A):n},A.touchable=function(C){return arguments.length?(u=typeof C=="function"?C:du(!!C),A):u},A.extent=function(C){return arguments.length?(l=typeof C=="function"?C:du([[+C[0][0],+C[0][1]],[+C[1][0],+C[1][1]]]),A):l},A.scaleExtent=function(C){return arguments.length?(f[0]=+C[0],f[1]=+C[1],A):[f[0],f[1]]},A.translateExtent=function(C){return arguments.length?(d[0][0]=+C[0][0],d[1][0]=+C[1][0],d[0][1]=+C[0][1],d[1][1]=+C[1][1],A):[[d[0][0],d[0][1]],[d[1][0],d[1][1]]]},A.constrain=function(C){return arguments.length?(o=C,A):o},A.duration=function(C){return arguments.length?(h=+C,A):h},A.interpolate=function(C){return arguments.length?(m=C,A):m},A.on=function(){var C=g.on.apply(g,arguments);return C===g?A:C},A.clickDistance=function(C){return arguments.length?(T=(C=+C)*C,A):Math.sqrt(T)},A.tapDistance=function(C){return arguments.length?(z=+C,A):z},A}const fn={error001:(n="react")=>`Seems like you have not used ${n==="svelte"?"SvelteFlowProvider":"ReactFlowProvider"} as an ancestor. Help: https://${n}flow.dev/error#001`,error002:()=>"It looks like you've created a new nodeTypes or edgeTypes object. If this wasn't on purpose please define the nodeTypes/edgeTypes outside of the component or memoize them.",error003:n=>`Node type "${n}" not found. Using fallback type "default".`,error004:()=>"The parent container needs a width and a height to render the graph.",error005:()=>"Only child nodes can use a parent extent.",error006:()=>"Can't create edge. An edge needs a source and a target.",error007:n=>`The old edge with id=${n} does not exist.`,error009:n=>`Marker type "${n}" doesn't exist.`,error008:(n,{id:l,sourceHandle:o,targetHandle:r})=>`Couldn't create edge for ${n} handle id: "${n==="source"?o:r}", edge id: ${l}.`,error010:()=>"Handle: No node id found. Make sure to only use a Handle inside a custom Node.",error011:n=>`Edge type "${n}" not found. Using fallback type "default".`,error012:n=>`Node with id "${n}" does not exist, it may have been removed. This can happen when a node is deleted before the "onNodeClick" handler is called.`,error013:(n="react")=>`It seems that you haven't loaded the styles. Please import '@xyflow/${n}/dist/style.css' or base.css to make sure everything is working properly.`,error014:()=>"useNodeConnections: No node ID found. Call useNodeConnections inside a custom Node or provide a node ID.",error015:()=>"It seems that you are trying to drag a node that is not initialized. Please use onNodesChange as explained in the docs.",error016:n=>`Edge with id "${n}" does not exist, it may have been removed. This can happen when an edge is deleted before the "onEdgeClick" handler is called.`},Eo=[[Number.NEGATIVE_INFINITY,Number.NEGATIVE_INFINITY],[Number.POSITIVE_INFINITY,Number.POSITIVE_INFINITY]],hp=["Enter"," ","Escape"],gp={"node.a11yDescription.default":"Press enter or space to select a node. Press delete to remove it and escape to cancel.","node.a11yDescription.keyboardDisabled":"Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.","node.a11yDescription.ariaLiveMessage":({direction:n,x:l,y:o})=>`Moved selected node ${n}. New position, x: ${l}, y: ${o}`,"edge.a11yDescription.default":"Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.","controls.ariaLabel":"Control Panel","controls.zoomIn.ariaLabel":"Zoom In","controls.zoomOut.ariaLabel":"Zoom Out","controls.fitView.ariaLabel":"Fit View","controls.interactive.ariaLabel":"Toggle Interactivity","minimap.ariaLabel":"Mini Map","handle.ariaLabel":"Handle"};var ii;(function(n){n.Strict="strict",n.Loose="loose"})(ii||(ii={}));var el;(function(n){n.Free="free",n.Vertical="vertical",n.Horizontal="horizontal"})(el||(el={}));var No;(function(n){n.Partial="partial",n.Full="full"})(No||(No={}));const mp={inProgress:!1,isValid:null,from:null,fromHandle:null,fromPosition:null,fromNode:null,to:null,toHandle:null,toPosition:null,toNode:null,pointer:null};var Aa;(function(n){n.Bezier="default",n.Straight="straight",n.Step="step",n.SmoothStep="smoothstep",n.SimpleBezier="simplebezier"})(Aa||(Aa={}));var Du;(function(n){n.Arrow="arrow",n.ArrowClosed="arrowclosed"})(Du||(Du={}));var xe;(function(n){n.Left="left",n.Top="top",n.Right="right",n.Bottom="bottom"})(xe||(xe={}));const jm={[xe.Left]:xe.Right,[xe.Right]:xe.Left,[xe.Top]:xe.Bottom,[xe.Bottom]:xe.Top};function yp(n){return n===null?null:n?"valid":"invalid"}const pp=n=>!!n&&typeof n=="object"&&"id"in n&&"source"in n&&"target"in n,MS=n=>!!n&&typeof n=="object"&&"id"in n&&"position"in n&&!("source"in n)&&!("target"in n),hd=n=>!!n&&typeof n=="object"&&"id"in n&&"internals"in n&&!("source"in n)&&!("target"in n),jo=(n,l=[0,0])=>{const{width:o,height:r}=En(n),u=n.origin??l,f=o*u[0],d=r*u[1];return{x:n.position.x-f,y:n.position.y-d}},zS=(n,l={nodeOrigin:[0,0]})=>{if(n.length===0)return{x:0,y:0,width:0,height:0};const o=n.reduce((r,u)=>{const f=typeof u=="string";let d=!l.nodeLookup&&!f?u:void 0;l.nodeLookup&&(d=f?l.nodeLookup.get(u):hd(u)?u:l.nodeLookup.get(u.id));const h=d?ku(d,l.nodeOrigin):{x:0,y:0,x2:0,y2:0};return Yu(r,h)},{x:1/0,y:1/0,x2:-1/0,y2:-1/0});return Vu(o)},Oo=(n,l={})=>{let o={x:1/0,y:1/0,x2:-1/0,y2:-1/0},r=!1;return n.forEach(u=>{(l.filter===void 0||l.filter(u))&&(o=Yu(o,ku(u)),r=!0)}),r?Vu(o):{x:0,y:0,width:0,height:0}},gd=(n,l,[o,r,u]=[0,0,1],f=!1,d=!1)=>{const h=(l.x-o)/u,m=(l.y-r)/u,g=l.width/u,v=l.height/u,p=[];for(const b of n.values()){const{measured:x,selectable:_=!0,hidden:T=!1}=b;if(d&&!_||T)continue;const z=x.width??b.width??b.initialWidth??0,A=x.height??b.height??b.initialHeight??0,{x:R,y:S}=b.internals.positionAbsolute,D=_p(h,m,g,v,R,S,z,A),H=z*A,j=f&&D>0;(!b.internals.handleBounds||j||D>=H||b.dragging)&&p.push(b)}return p},CS=(n,l)=>{const o=new Set;return n.forEach(r=>{o.add(r.id)}),l.filter(r=>o.has(r.source)||o.has(r.target))};function DS(n,l){const o=new Map,r=l!=null&&l.nodes?new Set(l.nodes.map(u=>u.id)):null;return n.forEach(u=>{let f;if(l!=null&&l.includeHiddenNodes){const{width:d,height:h}=En(u);f=d>0&&h>0}else f=!!(u.measured.width&&u.measured.height&&!u.hidden);f&&(!r||r.has(u.id))&&o.set(u.id,u)}),o}async function kS({nodes:n,width:l,height:o,panZoom:r,minZoom:u,maxZoom:f},d){if(n.size===0)return!0;const h=DS(n,d),m=Oo(h),g=yd(m,l,o,(d==null?void 0:d.minZoom)??u,(d==null?void 0:d.maxZoom)??f,(d==null?void 0:d.padding)??.1);return await r.setViewport(g,{duration:d==null?void 0:d.duration,ease:d==null?void 0:d.ease,interpolate:d==null?void 0:d.interpolate}),!0}function vp({nodeId:n,nextPosition:l,nodeLookup:o,nodeOrigin:r=[0,0],nodeExtent:u,onError:f}){const d=o.get(n),h=d.parentId?o.get(d.parentId):void 0,{x:m,y:g}=h?h.internals.positionAbsolute:{x:0,y:0},v=d.origin??r;let p=d.extent||u;if(d.extent==="parent"&&!d.expandParent)if(!h)f==null||f("005",fn.error005());else{const x=h.measured.width,_=h.measured.height;x&&_&&(p=[[m,g],[m+x,g+_]])}else h&&ll(d.extent)&&(p=[[d.extent[0][0]+m,d.extent[0][1]+g],[d.extent[1][0]+m,d.extent[1][1]+g]]);const b=ll(p)?al(l,p,d.measured):l;return(d.measured.width===void 0||d.measured.height===void 0)&&(f==null||f("015",fn.error015())),{position:{x:b.x-m+(d.measured.width??0)*v[0],y:b.y-g+(d.measured.height??0)*v[1]},positionAbsolute:b}}async function RS({nodesToRemove:n=[],edgesToRemove:l=[],nodes:o,edges:r,onBeforeDelete:u}){const f=new Set(n.map(b=>b.id)),d=[];for(const b of o){if(b.deletable===!1)continue;const x=f.has(b.id),_=!x&&b.parentId&&d.find(T=>T.id===b.parentId);(x||_)&&d.push(b)}const h=new Set(l.map(b=>b.id)),m=r.filter(b=>b.deletable!==!1),v=CS(d,m);for(const b of m)h.has(b.id)&&!v.find(_=>_.id===b.id)&&v.push(b);if(!u)return{edges:v,nodes:d};const p=await u({nodes:d,edges:v});return typeof p=="boolean"?p?{edges:v,nodes:d}:{edges:[],nodes:[]}:p}const oi=(n,l=0,o=1)=>Math.min(Math.max(n,l),o),al=(n={x:0,y:0},l,o)=>({x:oi(n.x,l[0][0],l[1][0]-((o==null?void 0:o.width)??0)),y:oi(n.y,l[0][1],l[1][1]-((o==null?void 0:o.height)??0))});function bp(n,l,o){const{width:r,height:u}=En(o),{x:f,y:d}=o.internals.positionAbsolute;return al(n,[[f,d],[f+r,d+u]],l)}const Om=(n,l,o)=>n<l?oi(Math.abs(n-l),1,l)/l:n>o?-oi(Math.abs(n-o),1,l)/l:0,md=(n,l,o=15,r=40)=>{const u=Om(n.x,r,l.width-r)*o,f=Om(n.y,r,l.height-r)*o;return[u,f]},Yu=(n,l)=>({x:Math.min(n.x,l.x),y:Math.min(n.y,l.y),x2:Math.max(n.x2,l.x2),y2:Math.max(n.y2,l.y2)}),Vf=({x:n,y:l,width:o,height:r})=>({x:n,y:l,x2:n+o,y2:l+r}),Vu=({x:n,y:l,x2:o,y2:r})=>({x:n,y:l,width:o-n,height:r-l}),To=(n,l=[0,0])=>{var u,f;const{x:o,y:r}=hd(n)?n.internals.positionAbsolute:jo(n,l);return{x:o,y:r,width:((u=n.measured)==null?void 0:u.width)??n.width??n.initialWidth??0,height:((f=n.measured)==null?void 0:f.height)??n.height??n.initialHeight??0}},ku=(n,l=[0,0])=>{var u,f;const{x:o,y:r}=hd(n)?n.internals.positionAbsolute:jo(n,l);return{x:o,y:r,x2:o+(((u=n.measured)==null?void 0:u.width)??n.width??n.initialWidth??0),y2:r+(((f=n.measured)==null?void 0:f.height)??n.height??n.initialHeight??0)}},xp=(n,l)=>Vu(Yu(Vf(n),Vf(l))),_p=(n,l,o,r,u,f,d,h)=>{const m=Math.max(0,Math.min(n+o,u+d)-Math.max(n,u)),g=Math.max(0,Math.min(l+r,f+h)-Math.max(l,f));return Math.ceil(m*g)},Ru=(n,l)=>_p(n.x,n.y,n.width,n.height,l.x,l.y,l.width,l.height),Hm=n=>sn(n.width)&&sn(n.height)&&sn(n.x)&&sn(n.y),sn=n=>!isNaN(n)&&isFinite(n),wp=(n,l)=>(o,r)=>{},Ho=(n,l=[1,1])=>({x:l[0]*Math.round(n.x/l[0]),y:l[1]*Math.round(n.y/l[1])}),Bo=({x:n,y:l},[o,r,u],f=!1,d=[1,1])=>{const h={x:(n-o)/u,y:(l-r)/u};return f?Ho(h,d):h},ri=({x:n,y:l},[o,r,u])=>({x:n*u+o,y:l*u+r});function Jl(n,l){if(typeof n=="number")return Math.floor((l-l/(1+n))*.5);if(typeof n=="string"&&n.endsWith("px")){const o=parseFloat(n);if(!Number.isNaN(o))return Math.floor(o)}if(typeof n=="string"&&n.endsWith("%")){const o=parseFloat(n);if(!Number.isNaN(o))return Math.floor(l*o*.01)}return console.error(`The padding value "${n}" is invalid. Please provide a number or a string with a valid unit (px or %).`),0}function jS(n,l,o){if(typeof n=="string"||typeof n=="number"){const r=Jl(n,o),u=Jl(n,l);return{top:r,right:u,bottom:r,left:u,x:u*2,y:r*2}}if(typeof n=="object"){const r=Jl(n.top??n.y??0,o),u=Jl(n.bottom??n.y??0,o),f=Jl(n.left??n.x??0,l),d=Jl(n.right??n.x??0,l);return{top:r,right:d,bottom:u,left:f,x:f+d,y:r+u}}return{top:0,right:0,bottom:0,left:0,x:0,y:0}}function OS(n,l,o,r,u,f){const{x:d,y:h}=ri(n,[l,o,r]),{x:m,y:g}=ri({x:n.x+n.width,y:n.y+n.height},[l,o,r]),v=u-m,p=f-g;return{left:Math.floor(d),top:Math.floor(h),right:Math.floor(v),bottom:Math.floor(p)}}const yd=(n,l,o,r,u,f)=>{const d=jS(f,l,o),h=(l-d.x)/n.width,m=(o-d.y)/n.height,g=Math.min(h,m),v=oi(g,r,u),p=n.x+n.width/2,b=n.y+n.height/2,x=l/2-p*v,_=o/2-b*v,T=OS(n,x,_,v,l,o),z={left:Math.min(T.left-d.left,0),top:Math.min(T.top-d.top,0),right:Math.min(T.right-d.right,0),bottom:Math.min(T.bottom-d.bottom,0)};return{x:x-z.left+z.right,y:_-z.top+z.bottom,zoom:v}},Ao=()=>{var n;return typeof navigator<"u"&&((n=navigator==null?void 0:navigator.userAgent)==null?void 0:n.indexOf("Mac"))>=0};function ll(n){return n!=null&&n!=="parent"}function En(n){var l,o;return{width:((l=n.measured)==null?void 0:l.width)??n.width??n.initialWidth??0,height:((o=n.measured)==null?void 0:o.height)??n.height??n.initialHeight??0}}function Sp(n){var l,o;return(((l=n.measured)==null?void 0:l.width)??n.width??n.initialWidth)!==void 0&&(((o=n.measured)==null?void 0:o.height)??n.height??n.initialHeight)!==void 0}function Ep(n,l={width:0,height:0},o,r,u){const f={...n},d=r.get(o);if(d){const h=d.origin||u;f.x+=d.internals.positionAbsolute.x-(l.width??0)*h[0],f.y+=d.internals.positionAbsolute.y-(l.height??0)*h[1]}return f}function Bm(n,l){if(n.size!==l.size)return!1;for(const o of n)if(!l.has(o))return!1;return!0}function HS(){let n,l;return{promise:new Promise((r,u)=>{n=r,l=u}),resolve:n,reject:l}}function BS(n){return{...gp,...n||{}}}function vo(n,{snapGrid:l=[0,0],snapToGrid:o=!1,transform:r,containerBounds:u}){const{x:f,y:d}=cn(n),h=Bo({x:f-((u==null?void 0:u.left)??0),y:d-((u==null?void 0:u.top)??0)},r),{x:m,y:g}=o?Ho(h,l):h;return{xSnapped:m,ySnapped:g,...h}}const pd=n=>({width:n.offsetWidth,height:n.offsetHeight}),Np=n=>{var l;return((l=n==null?void 0:n.getRootNode)==null?void 0:l.call(n))||(window==null?void 0:window.document)},LS=["INPUT","SELECT","TEXTAREA"];function Tp(n){var r,u;const l=((u=(r=n.composedPath)==null?void 0:r.call(n))==null?void 0:u[0])||n.target;return(l==null?void 0:l.nodeType)!==1?!1:LS.includes(l.nodeName)||l.hasAttribute("contenteditable")||!!l.closest(".nokey")}const Ap=n=>"clientX"in n,cn=(n,l)=>{var f,d;const o=Ap(n),r=o?n.clientX:(f=n.touches)==null?void 0:f[0].clientX,u=o?n.clientY:(d=n.touches)==null?void 0:d[0].clientY;return{x:r-((l==null?void 0:l.left)??0),y:u-((l==null?void 0:l.top)??0)}},Lm=(n,l,o,r,u)=>{const f=l.querySelectorAll(`.${n}`);return!f||!f.length?null:Array.from(f).map(d=>{const h=d.getBoundingClientRect();return{id:d.getAttribute("data-handleid"),type:n,nodeId:u,position:d.getAttribute("data-handlepos"),x:(h.left-o.left)/r,y:(h.top-o.top)/r,...pd(d)}})};function Mp({sourceX:n,sourceY:l,targetX:o,targetY:r,sourceControlX:u,sourceControlY:f,targetControlX:d,targetControlY:h}){const m=n*.125+u*.375+d*.375+o*.125,g=l*.125+f*.375+h*.375+r*.125,v=Math.abs(m-n),p=Math.abs(g-l);return[m,g,v,p]}function hu(n,l){return n>=0?.5*n:l*25*Math.sqrt(-n)}function Um({pos:n,x1:l,y1:o,x2:r,y2:u,c:f}){switch(n){case xe.Left:return[l-hu(l-r,f),o];case xe.Right:return[l+hu(r-l,f),o];case xe.Top:return[l,o-hu(o-u,f)];case xe.Bottom:return[l,o+hu(u-o,f)]}}function vd({sourceX:n,sourceY:l,sourcePosition:o=xe.Bottom,targetX:r,targetY:u,targetPosition:f=xe.Top,curvature:d=.25}){const[h,m]=Um({pos:o,x1:n,y1:l,x2:r,y2:u,c:d}),[g,v]=Um({pos:f,x1:r,y1:u,x2:n,y2:l,c:d}),[p,b,x,_]=Mp({sourceX:n,sourceY:l,targetX:r,targetY:u,sourceControlX:h,sourceControlY:m,targetControlX:g,targetControlY:v});return[`M${n},${l} C${h},${m} ${g},${v} ${r},${u}`,p,b,x,_]}function zp({sourceX:n,sourceY:l,targetX:o,targetY:r}){const u=Math.abs(o-n)/2,f=o<n?o+u:o-u,d=Math.abs(r-l)/2,h=r<l?r+d:r-d;return[f,h,u,d]}function US({sourceNode:n,targetNode:l,selected:o=!1,zIndex:r=0,elevateOnSelect:u=!1,zIndexMode:f="basic"}){if(f==="manual")return r;const d=u&&o?r+1e3:r,h=Math.max(n.parentId||u&&n.selected?n.internals.z:0,l.parentId||u&&l.selected?l.internals.z:0);return d+h}function GS({sourceNode:n,targetNode:l,width:o,height:r,transform:u}){const f=Yu(ku(n),ku(l));f.x===f.x2&&(f.x2+=1),f.y===f.y2&&(f.y2+=1);const d={x:-u[0]/u[2],y:-u[1]/u[2],width:o/u[2],height:r/u[2]};return Ru(d,Vu(f))>0}const qS=({source:n,sourceHandle:l,target:o,targetHandle:r})=>`xy-edge__${n}${l||""}-${o}${r||""}`,YS=(n,l)=>l.some(o=>o.source===n.source&&o.target===n.target&&(o.sourceHandle===n.sourceHandle||!o.sourceHandle&&!n.sourceHandle)&&(o.targetHandle===n.targetHandle||!o.targetHandle&&!n.targetHandle)),VS=(n,l,o={})=>{var f;if(!n.source||!n.target)return(f=o.onError)==null||f.call(o,"006",fn.error006()),l;const r=o.getEdgeId||qS;let u;return pp(n)?u={...n}:u={...n,id:r(n)},YS(u,l)?l:(u.sourceHandle===null&&delete u.sourceHandle,u.targetHandle===null&&delete u.targetHandle,l.concat(u))};function Cp({sourceX:n,sourceY:l,targetX:o,targetY:r}){const[u,f,d,h]=zp({sourceX:n,sourceY:l,targetX:o,targetY:r});return[`M ${n},${l}L ${o},${r}`,u,f,d,h]}const Gm={[xe.Left]:{x:-1,y:0},[xe.Right]:{x:1,y:0},[xe.Top]:{x:0,y:-1},[xe.Bottom]:{x:0,y:1}},XS=({source:n,sourcePosition:l=xe.Bottom,target:o})=>l===xe.Left||l===xe.Right?n.x<o.x?{x:1,y:0}:{x:-1,y:0}:n.y<o.y?{x:0,y:1}:{x:0,y:-1},qm=(n,l)=>Math.sqrt(Math.pow(l.x-n.x,2)+Math.pow(l.y-n.y,2));function QS({source:n,sourcePosition:l=xe.Bottom,target:o,targetPosition:r=xe.Top,center:u,offset:f,stepPosition:d}){const h=Gm[l],m=Gm[r],g={x:n.x+h.x*f,y:n.y+h.y*f},v={x:o.x+m.x*f,y:o.y+m.y*f},p=XS({source:g,sourcePosition:l,target:v}),b=p.x!==0?"x":"y",x=p[b];let _=[],T,z;const A={x:0,y:0},R={x:0,y:0},[,,S,D]=zp({sourceX:n.x,sourceY:n.y,targetX:o.x,targetY:o.y});if(h[b]*m[b]===-1){b==="x"?(T=u.x??g.x+(v.x-g.x)*d,z=u.y??(g.y+v.y)/2):(T=u.x??(g.x+v.x)/2,z=u.y??g.y+(v.y-g.y)*d);const q=[{x:T,y:g.y},{x:T,y:v.y}],Z=[{x:g.x,y:z},{x:v.x,y:z}];h[b]===x?_=b==="x"?q:Z:_=b==="x"?Z:q}else{const q=[{x:g.x,y:v.y}],Z=[{x:v.x,y:g.y}];if(b==="x"?_=h.x===x?Z:q:_=h.y===x?q:Z,l===r){const C=Math.abs(n[b]-o[b]);if(C<=f){const V=Math.min(f-1,f-C);h[b]===x?A[b]=(g[b]>n[b]?-1:1)*V:R[b]=(v[b]>o[b]?-1:1)*V}}if(l!==r){const C=b==="x"?"y":"x",V=h[b]===m[C],M=g[C]>v[C],B=g[C]<v[C];(h[b]===1&&(!V&&M||V&&B)||h[b]!==1&&(!V&&B||V&&M))&&(_=b==="x"?q:Z)}const ie={x:g.x+A.x,y:g.y+A.y},J={x:v.x+R.x,y:v.y+R.y},ne=Math.max(Math.abs(ie.x-_[0].x),Math.abs(J.x-_[0].x)),P=Math.max(Math.abs(ie.y-_[0].y),Math.abs(J.y-_[0].y));ne>=P?(T=(ie.x+J.x)/2,z=_[0].y):(T=_[0].x,z=(ie.y+J.y)/2)}const H={x:g.x+A.x,y:g.y+A.y},j={x:v.x+R.x,y:v.y+R.y};return[[n,...H.x!==_[0].x||H.y!==_[0].y?[H]:[],..._,...j.x!==_[_.length-1].x||j.y!==_[_.length-1].y?[j]:[],o],T,z,S,D]}function $S(n,l,o,r){const u=Math.min(qm(n,l)/2,qm(l,o)/2,r),{x:f,y:d}=l;if(n.x===f&&f===o.x||n.y===d&&d===o.y)return`L${f} ${d}`;if(n.y===d){const g=n.x<o.x?-1:1,v=n.y<o.y?1:-1;return`L ${f+u*g},${d}Q ${f},${d} ${f},${d+u*v}`}const h=n.x<o.x?1:-1,m=n.y<o.y?-1:1;return`L ${f},${d+u*m}Q ${f},${d} ${f+u*h},${d}`}function Xf({sourceX:n,sourceY:l,sourcePosition:o=xe.Bottom,targetX:r,targetY:u,targetPosition:f=xe.Top,borderRadius:d=5,centerX:h,centerY:m,offset:g=20,stepPosition:v=.5}){const[p,b,x,_,T]=QS({source:{x:n,y:l},sourcePosition:o,target:{x:r,y:u},targetPosition:f,center:{x:h,y:m},offset:g,stepPosition:v});let z=`M${p[0].x} ${p[0].y}`;for(let A=1;A<p.length-1;A++)z+=$S(p[A-1],p[A],p[A+1],d);return z+=`L${p[p.length-1].x} ${p[p.length-1].y}`,[z,b,x,_,T]}function Ym(n){var l;return n&&!!(n.internals.handleBounds||(l=n.handles)!=null&&l.length)&&!!(n.measured.width||n.width||n.initialWidth)}function ZS(n){var p;const{sourceNode:l,targetNode:o}=n;if(!Ym(l)||!Ym(o))return null;const r=l.internals.handleBounds||Vm(l.handles),u=o.internals.handleBounds||Vm(o.handles),f=Xm((r==null?void 0:r.source)??[],n.sourceHandle),d=Xm(n.connectionMode===ii.Strict?(u==null?void 0:u.target)??[]:((u==null?void 0:u.target)??[]).concat((u==null?void 0:u.source)??[]),n.targetHandle);if(!f||!d)return(p=n.onError)==null||p.call(n,"008",fn.error008(f?"target":"source",{id:n.id,sourceHandle:n.sourceHandle,targetHandle:n.targetHandle})),null;const h=(f==null?void 0:f.position)||xe.Bottom,m=(d==null?void 0:d.position)||xe.Top,g=il(l,f,h),v=il(o,d,m);return{sourceX:g.x,sourceY:g.y,targetX:v.x,targetY:v.y,sourcePosition:h,targetPosition:m}}function Vm(n){if(!n)return null;const l=[],o=[];for(const r of n)r.width=r.width??1,r.height=r.height??1,r.type==="source"?l.push(r):r.type==="target"&&o.push(r);return{source:l,target:o}}function il(n,l,o=xe.Left,r=!1){const u=((l==null?void 0:l.x)??0)+n.internals.positionAbsolute.x,f=((l==null?void 0:l.y)??0)+n.internals.positionAbsolute.y,{width:d,height:h}=l??En(n);if(r)return{x:u+d/2,y:f+h/2};switch((l==null?void 0:l.position)??o){case xe.Top:return{x:u+d/2,y:f};case xe.Right:return{x:u+d,y:f+h/2};case xe.Bottom:return{x:u+d/2,y:f+h};case xe.Left:return{x:u,y:f+h/2}}}function Xm(n,l){return n&&(l?n.find(o=>o.id===l):n[0])||null}function Qf(n,l){return n?typeof n=="string"?n:`${l?`${l}__`:""}${Object.keys(n).sort().map(r=>`${r}=${n[r]}`).join("&")}`:""}function KS(n,{id:l,defaultColor:o,defaultMarkerStart:r,defaultMarkerEnd:u}){const f=new Set;return n.reduce((d,h)=>([h.markerStart||r,h.markerEnd||u].forEach(m=>{if(m&&typeof m=="object"){const g=Qf(m,l);f.has(g)||(d.push({id:g,color:m.color||o,...m}),f.add(g))}}),d),[]).sort((d,h)=>d.id.localeCompare(h.id))}const Dp=1e3,IS=10,bd={nodeOrigin:[0,0],nodeExtent:Eo,elevateNodesOnSelect:!0,zIndexMode:"basic",defaults:{}},JS={...bd,checkEquality:!0};function xd(n,l){const o={...n};for(const r in l)l[r]!==void 0&&(o[r]=l[r]);return o}function WS(n,l,o){const r=xd(bd,o);for(const u of n.values())if(u.parentId)wd(u,n,l,r);else{const f=jo(u,r.nodeOrigin),d=ll(u.extent)?u.extent:r.nodeExtent,h=al(f,d,En(u));u.internals.positionAbsolute=h}}function FS(n,l){if(!n.handles)return n.measured?l==null?void 0:l.internals.handleBounds:void 0;const o=[],r=[];for(const u of n.handles){const f={id:u.id,width:u.width??1,height:u.height??1,nodeId:n.id,x:u.x,y:u.y,position:u.position,type:u.type};u.type==="source"?o.push(f):u.type==="target"&&r.push(f)}return{source:o,target:r}}function _d(n){return n==="manual"}function $f(n,l,o,r={}){var v,p;const u=xd(JS,r),f={i:0},d=new Map(l),h=u!=null&&u.elevateNodesOnSelect&&!_d(u.zIndexMode)?Dp:0;let m=n.length>0,g=!1;l.clear(),o.clear();for(const b of n){let x=d.get(b.id);if(u.checkEquality&&b===(x==null?void 0:x.internals.userNode))l.set(b.id,x);else{const _=jo(b,u.nodeOrigin),T=ll(b.extent)?b.extent:u.nodeExtent,z=al(_,T,En(b));x={...u.defaults,...b,measured:{width:(v=b.measured)==null?void 0:v.width,height:(p=b.measured)==null?void 0:p.height},internals:{positionAbsolute:z,handleBounds:FS(b,x),z:kp(b,h,u.zIndexMode),userNode:b}},l.set(b.id,x)}(x.measured===void 0||x.measured.width===void 0||x.measured.height===void 0)&&!x.hidden&&(m=!1),b.parentId&&wd(x,l,o,r,f),g||(g=b.selected??!1)}return{nodesInitialized:m,hasSelectedNodes:g}}function PS(n,l){if(!n.parentId)return;const o=l.get(n.parentId);o?o.set(n.id,n):l.set(n.parentId,new Map([[n.id,n]]))}function wd(n,l,o,r,u){const{elevateNodesOnSelect:f,nodeOrigin:d,nodeExtent:h,zIndexMode:m}=xd(bd,r),g=n.parentId,v=l.get(g);if(!v){console.warn(`Parent node ${g} not found. Please make sure that parent nodes are in front of their child nodes in the nodes array.`);return}PS(n,o),u&&!v.parentId&&v.internals.rootParentIndex===void 0&&m==="auto"&&(v.internals.rootParentIndex=++u.i,v.internals.z=v.internals.z+u.i*IS),u&&v.internals.rootParentIndex!==void 0&&(u.i=v.internals.rootParentIndex);const p=f&&!_d(m)?Dp:0,{x:b,y:x,z:_}=e2(n,v,d,h,p,m),{positionAbsolute:T}=n.internals,z=b!==T.x||x!==T.y;(z||_!==n.internals.z)&&l.set(n.id,{...n,internals:{...n.internals,positionAbsolute:z?{x:b,y:x}:T,z:_}})}function kp(n,l,o){const r=sn(n.zIndex)?n.zIndex:0;return _d(o)?r:r+(n.selected?l:0)}function e2(n,l,o,r,u,f){const{x:d,y:h}=l.internals.positionAbsolute,m=En(n),g=jo(n,o),v=ll(n.extent)?al(g,n.extent,m):g;let p=al({x:d+v.x,y:h+v.y},r,m);n.extent==="parent"&&(p=bp(p,m,l));const b=kp(n,u,f),x=l.internals.z??0;return{x:p.x,y:p.y,z:x>=b?x+1:b}}function Sd(n,l,o,r=[0,0]){var d;const u=[],f=new Map;for(const h of n){const m=l.get(h.parentId);if(!m)continue;const g=((d=f.get(h.parentId))==null?void 0:d.expandedRect)??To(m),v=xp(g,h.rect);f.set(h.parentId,{expandedRect:v,parent:m})}return f.size>0&&f.forEach(({expandedRect:h,parent:m},g)=>{var S;const v=m.internals.positionAbsolute,p=En(m),b=m.origin??r,x=h.x<v.x?Math.round(Math.abs(v.x-h.x)):0,_=h.y<v.y?Math.round(Math.abs(v.y-h.y)):0,T=Math.max(p.width,Math.round(h.width)),z=Math.max(p.height,Math.round(h.height)),A=(T-p.width)*b[0],R=(z-p.height)*b[1];(x>0||_>0||A||R)&&(u.push({id:g,type:"position",position:{x:m.position.x-x+A,y:m.position.y-_+R}}),(S=o.get(g))==null||S.forEach(D=>{n.some(H=>H.id===D.id)||u.push({id:D.id,type:"position",position:{x:D.position.x+x,y:D.position.y+_}})})),(p.width<h.width||p.height<h.height||x||_)&&u.push({id:g,type:"dimensions",setAttributes:!0,dimensions:{width:T+(x?b[0]*x-A:0),height:z+(_?b[1]*_-R:0)}})}),u}function t2(n,l,o,r,u,f,d){const h=r==null?void 0:r.querySelector(".xyflow__viewport");let m=!1;if(!h)return{changes:[],updatedInternals:m};const g=[],v=window.getComputedStyle(h),{m22:p}=new window.DOMMatrixReadOnly(v.transform),b=[];for(const x of n.values()){const _=l.get(x.id);if(!_)continue;if(_.hidden){l.set(_.id,{..._,internals:{..._.internals,handleBounds:void 0}}),m=!0;continue}const T=pd(x.nodeElement),z=_.measured.width!==T.width||_.measured.height!==T.height;if(!!(T.width&&T.height&&(z||!_.internals.handleBounds||x.force))){const R=x.nodeElement.getBoundingClientRect(),S=ll(_.extent)?_.extent:f;let{positionAbsolute:D}=_.internals;if(_.parentId&&_.extent==="parent"){const j=l.get(_.parentId);j&&(D=bp(D,T,j))}else S&&(D=al(D,S,T));const H={..._,measured:T,internals:{..._.internals,positionAbsolute:D,handleBounds:{source:Lm("source",x.nodeElement,R,p,_.id),target:Lm("target",x.nodeElement,R,p,_.id)}}};l.set(_.id,H),_.parentId&&wd(H,l,o,{nodeOrigin:u,zIndexMode:d}),m=!0,z&&(g.push({id:_.id,type:"dimensions",dimensions:T}),_.expandParent&&_.parentId&&b.push({id:_.id,parentId:_.parentId,rect:To(H,u)}))}}if(b.length>0){const x=Sd(b,l,o,u);g.push(...x)}return{changes:g,updatedInternals:m}}async function n2({delta:n,panZoom:l,transform:o,translateExtent:r,width:u,height:f}){if(!l||!n.x&&!n.y)return!1;const d=await l.setViewportConstrained({x:o[0]+n.x,y:o[1]+n.y,zoom:o[2]},[[0,0],[u,f]],r);return!!d&&(d.x!==o[0]||d.y!==o[1]||d.k!==o[2])}function Qm(n,l,o,r,u,f){let d=u;const h=r.get(d)||new Map;r.set(d,h.set(o,l)),d=`${u}-${n}`;const m=r.get(d)||new Map;if(r.set(d,m.set(o,l)),f){d=`${u}-${n}-${f}`;const g=r.get(d)||new Map;r.set(d,g.set(o,l))}}function Rp(n,l,o){n.clear(),l.clear();for(const r of o){const{source:u,target:f,sourceHandle:d=null,targetHandle:h=null}=r,m={edgeId:r.id,source:u,target:f,sourceHandle:d,targetHandle:h},g=`${u}-${d}--${f}-${h}`,v=`${f}-${h}--${u}-${d}`;Qm("source",m,v,n,u,d),Qm("target",m,g,n,f,h),l.set(r.id,r)}}function jp(n,l){if(!n.parentId)return!1;const o=l.get(n.parentId);return o?o.selected?!0:jp(o,l):!1}function $m(n,l,o){var u;let r=n;do{if((u=r==null?void 0:r.matches)!=null&&u.call(r,l))return!0;if(r===o)return!1;r=r==null?void 0:r.parentElement}while(r);return!1}function a2(n,l,o,r){const u=new Map;for(const[f,d]of n)if((d.selected||d.id===r)&&(!d.parentId||!jp(d,n))&&(d.draggable||l&&typeof d.draggable>"u")){const h=n.get(f);h&&u.set(f,{id:f,position:h.position||{x:0,y:0},distance:{x:o.x-h.internals.positionAbsolute.x,y:o.y-h.internals.positionAbsolute.y},extent:h.extent,parentId:h.parentId,origin:h.origin,expandParent:h.expandParent,internals:{positionAbsolute:h.internals.positionAbsolute||{x:0,y:0}},measured:{width:h.measured.width??0,height:h.measured.height??0}})}return u}function _f({nodeId:n,dragItems:l,nodeLookup:o,dragging:r=!0}){var d,h,m;const u=[];for(const[g,v]of l){const p=(d=o.get(g))==null?void 0:d.internals.userNode;p&&u.push({...p,position:v.position,dragging:r})}if(!n)return[u[0],u];const f=(h=o.get(n))==null?void 0:h.internals.userNode;return[f?{...f,position:((m=l.get(n))==null?void 0:m.position)||f.position,dragging:r}:u[0],u]}function l2({dragItems:n,snapGrid:l,x:o,y:r}){const u=n.values().next().value;if(!u)return null;const f={x:o-u.distance.x,y:r-u.distance.y},d=Ho(f,l);return{x:d.x-f.x,y:d.y-f.y}}function i2({onNodeMouseDown:n,getStoreItems:l,onDragStart:o,onDrag:r,onDragStop:u}){let f={x:null,y:null},d=0,h=new Map,m=!1,g={x:0,y:0},v=null,p=!1,b=null,x=!1,_=!1,T=null;function z({noDragClassName:R,handleSelector:S,domNode:D,isSelectable:H,nodeId:j,nodeClickDistance:k=0}){b=qt(D);function q({x:ne,y:P}){const{nodeLookup:C,nodeExtent:V,snapGrid:M,snapToGrid:B,nodeOrigin:X,onNodeDrag:Y,onSelectionDrag:U,onError:E,updateNodePositions:O}=l();f={x:ne,y:P};let W=!1;const le=h.size>1,ce=le&&V?Vf(Oo(h)):null,me=le&&B?l2({dragItems:h,snapGrid:M,x:ne,y:P}):null;for(const[ge,ae]of h){if(!C.has(ge))continue;let fe={x:ne-ae.distance.x,y:P-ae.distance.y};B&&(fe=me?{x:Math.round(fe.x+me.x),y:Math.round(fe.y+me.y)}:Ho(fe,M));let ee=null;if(le&&V&&!ae.extent&&ce){const{positionAbsolute:pe}=ae.internals,we=pe.x-ce.x+V[0][0],he=pe.x+ae.measured.width-ce.x2+V[1][0],ye=pe.y-ce.y+V[0][1],Ae=pe.y+ae.measured.height-ce.y2+V[1][1];ee=[[we,ye],[he,Ae]]}const{position:se,positionAbsolute:de}=vp({nodeId:ge,nextPosition:fe,nodeLookup:C,nodeExtent:ee||V,nodeOrigin:X,onError:E});W=W||ae.position.x!==se.x||ae.position.y!==se.y,ae.position=se,ae.internals.positionAbsolute=de}if(_=_||W,!!W&&(O(h,!0),T&&(r||Y||!j&&U))){const[ge,ae]=_f({nodeId:j,dragItems:h,nodeLookup:C});r==null||r(T,h,ge,ae),Y==null||Y(T,ge,ae),j||U==null||U(T,ae)}}async function Z(){if(!v)return;const{transform:ne,panBy:P,autoPanSpeed:C,autoPanOnNodeDrag:V}=l();if(!V){m=!1,cancelAnimationFrame(d);return}const[M,B]=md(g,v,C);(M!==0||B!==0)&&(f.x=(f.x??0)-M/ne[2],f.y=(f.y??0)-B/ne[2],await P({x:M,y:B})&&q(f)),d=requestAnimationFrame(Z)}function ie(ne){var le;const{nodeLookup:P,multiSelectionActive:C,nodesDraggable:V,transform:M,snapGrid:B,snapToGrid:X,selectNodesOnDrag:Y,onNodeDragStart:U,onSelectionDragStart:E,unselectNodesAndEdges:O}=l();p=!0,(!Y||!H)&&!C&&j&&((le=P.get(j))!=null&&le.selected||O()),H&&Y&&j&&(n==null||n(j));const W=vo(ne.sourceEvent,{transform:M,snapGrid:B,snapToGrid:X,containerBounds:v});if(f=W,h=a2(P,V,W,j),h.size>0&&(o||U||!j&&E)){const[ce,me]=_f({nodeId:j,dragItems:h,nodeLookup:P});o==null||o(ne.sourceEvent,h,ce,me),U==null||U(ne.sourceEvent,ce,me),j||E==null||E(ne.sourceEvent,me)}}const J=Wy().clickDistance(k).on("start",ne=>{const{domNode:P,nodeDragThreshold:C,transform:V,snapGrid:M,snapToGrid:B}=l();v=(P==null?void 0:P.getBoundingClientRect())||null,x=!1,_=!1,T=ne.sourceEvent,C===0&&ie(ne),f=vo(ne.sourceEvent,{transform:V,snapGrid:M,snapToGrid:B,containerBounds:v}),g=cn(ne.sourceEvent,v)}).on("drag",ne=>{const{autoPanOnNodeDrag:P,transform:C,snapGrid:V,snapToGrid:M,nodeDragThreshold:B,nodeLookup:X}=l(),Y=vo(ne.sourceEvent,{transform:C,snapGrid:V,snapToGrid:M,containerBounds:v});if(T=ne.sourceEvent,(ne.sourceEvent.type==="touchmove"&&ne.sourceEvent.touches.length>1||j&&!X.has(j))&&(x=!0),!x){if(!m&&P&&p&&(m=!0,Z()),!p){const U=cn(ne.sourceEvent,v),E=U.x-g.x,O=U.y-g.y;Math.sqrt(E*E+O*O)>B&&ie(ne)}(f.x!==Y.xSnapped||f.y!==Y.ySnapped)&&h&&p&&(g=cn(ne.sourceEvent,v),q(Y))}}).on("end",ne=>{if(!p||x){x&&h.size>0&&l().updateNodePositions(h,!1);return}if(m=!1,p=!1,cancelAnimationFrame(d),h.size>0){const{nodeLookup:P,updateNodePositions:C,onNodeDragStop:V,onSelectionDragStop:M}=l();if(_&&(C(h,!1),_=!1),u||V||!j&&M){const[B,X]=_f({nodeId:j,dragItems:h,nodeLookup:P,dragging:!1});u==null||u(ne.sourceEvent,h,B,X),V==null||V(ne.sourceEvent,B,X),j||M==null||M(ne.sourceEvent,X)}}}).filter(ne=>{const P=ne.target;return!ne.button&&(!R||!$m(P,`.${R}`,D))&&(!S||$m(P,S,D))});b.call(J)}function A(){b==null||b.on(".drag",null)}return{update:z,destroy:A}}function o2(n,l,o){const r=[],u={x:n.x-o,y:n.y-o,width:o*2,height:o*2};for(const f of l.values())Ru(u,To(f))>0&&r.push(f);return r}const r2=250;function u2(n,l,o,r){var h,m;let u=[],f=1/0;const d=o2(n,o,l+r2);for(const g of d){const v=[...((h=g.internals.handleBounds)==null?void 0:h.source)??[],...((m=g.internals.handleBounds)==null?void 0:m.target)??[]];for(const p of v){if(r.nodeId===p.nodeId&&r.type===p.type&&r.id===p.id)continue;const{x:b,y:x}=il(g,p,p.position,!0),_=Math.sqrt(Math.pow(b-n.x,2)+Math.pow(x-n.y,2));_>l||(_<f?(u=[{...p,x:b,y:x}],f=_):_===f&&u.push({...p,x:b,y:x}))}}if(!u.length)return null;if(u.length>1){const g=r.type==="source"?"target":"source";return u.find(v=>v.type===g)??u[0]}return u[0]}function Op(n,l,o,r,u,f=!1){var g,v,p;const d=r.get(n);if(!d)return null;const h=u==="strict"?(g=d.internals.handleBounds)==null?void 0:g[l]:[...((v=d.internals.handleBounds)==null?void 0:v.source)??[],...((p=d.internals.handleBounds)==null?void 0:p.target)??[]],m=(o?h==null?void 0:h.find(b=>b.id===o):h==null?void 0:h[0])??null;return m&&f?{...m,...il(d,m,m.position,!0)}:m}function Hp(n,l){return n||(l!=null&&l.classList.contains("target")?"target":l!=null&&l.classList.contains("source")?"source":null)}function s2(n,l){let o=null;return l?o=!0:n&&!l&&(o=!1),o}const Bp=()=>!0;function c2(n,{connectionMode:l,connectionRadius:o,handleId:r,nodeId:u,edgeUpdaterType:f,isTarget:d,domNode:h,nodeLookup:m,lib:g,autoPanOnConnect:v,flowId:p,panBy:b,cancelConnection:x,onConnectStart:_,onConnect:T,onConnectEnd:z,isValidConnection:A=Bp,onReconnectEnd:R,updateConnection:S,getTransform:D,getFromHandle:H,autoPanSpeed:j,dragThreshold:k=1,handleDomNode:q}){const Z=Np(n.target);let ie=0,J;const{x:ne,y:P}=cn(n),C=Hp(f,q),V=h==null?void 0:h.getBoundingClientRect();let M=!1;if(!V||!C)return;const B=Op(u,C,r,m,l);if(!B)return;let X=cn(n,V),Y=!1,U=null,E=!1,O=null;function W(){if(!v||!V)return;const[se,de]=md(X,V,j);b({x:se,y:de}),ie=requestAnimationFrame(W)}const le={...B,nodeId:u,type:C,position:B.position},ce=m.get(u);let ge={inProgress:!0,isValid:null,from:il(ce,le,xe.Left,!0),fromHandle:le,fromPosition:le.position,fromNode:ce,to:X,toHandle:null,toPosition:jm[le.position],toNode:null,pointer:X};function ae(){M=!0,S(ge),_==null||_(n,{nodeId:u,handleId:r,handleType:C})}k===0&&ae();function fe(se){if(!M){const{x:Ae,y:Ke}=cn(se),ft=Ae-ne,yt=Ke-P;if(!(ft*ft+yt*yt>k*k))return;ae()}if(!H()||!le){ee(se);return}const de=D();X=cn(se,V),J=u2(Bo(X,de,!1,[1,1]),o,m,le),Y||(W(),Y=!0);const pe=Lp(se,{handle:J,connectionMode:l,fromNodeId:u,fromHandleId:r,fromType:d?"target":"source",isValidConnection:A,doc:Z,lib:g,flowId:p,nodeLookup:m});O=pe.handleDomNode,U=pe.connection,E=s2(!!J,pe.isValid);const we=m.get(u),he=we?il(we,le,xe.Left,!0):ge.from,ye={...ge,from:he,isValid:E,to:pe.toHandle&&E?ri({x:pe.toHandle.x,y:pe.toHandle.y},de):X,toHandle:pe.toHandle,toPosition:E&&pe.toHandle?pe.toHandle.position:jm[le.position],toNode:pe.toHandle?m.get(pe.toHandle.nodeId):null,pointer:X};S(ye),ge=ye}function ee(se){if(!("touches"in se&&se.touches.length>0)){if(M){(J||O)&&U&&E&&(T==null||T(U));const{inProgress:de,...pe}=ge,we={...pe,toPosition:ge.toHandle?ge.toPosition:null};z==null||z(se,we),f&&(R==null||R(se,we))}x(),cancelAnimationFrame(ie),Y=!1,E=!1,U=null,O=null,Z.removeEventListener("mousemove",fe),Z.removeEventListener("mouseup",ee),Z.removeEventListener("touchmove",fe),Z.removeEventListener("touchend",ee)}}Z.addEventListener("mousemove",fe),Z.addEventListener("mouseup",ee),Z.addEventListener("touchmove",fe),Z.addEventListener("touchend",ee)}function Lp(n,{handle:l,connectionMode:o,fromNodeId:r,fromHandleId:u,fromType:f,doc:d,lib:h,flowId:m,isValidConnection:g=Bp,nodeLookup:v}){const p=f==="target",b=l?d.querySelector(`.${h}-flow__handle[data-id="${m}-${l==null?void 0:l.nodeId}-${l==null?void 0:l.id}-${l==null?void 0:l.type}"]`):null,{x,y:_}=cn(n),T=d.elementFromPoint(x,_),z=T!=null&&T.classList.contains(`${h}-flow__handle`)?T:b,A={handleDomNode:z,isValid:!1,connection:null,toHandle:null};if(z){const R=Hp(void 0,z),S=z.getAttribute("data-nodeid"),D=z.getAttribute("data-handleid"),H=z.classList.contains("connectable"),j=z.classList.contains("connectableend");if(!S||!R)return A;const k={source:p?S:r,sourceHandle:p?D:u,target:p?r:S,targetHandle:p?u:D};A.connection=k;const Z=H&&j&&(o===ii.Strict?p&&R==="source"||!p&&R==="target":S!==r||D!==u);A.isValid=Z&&g(k),A.toHandle=Op(S,R,D,v,o,!0)}return A}const Zf={onPointerDown:c2,isValid:Lp};function f2({domNode:n,panZoom:l,getTransform:o,getViewScale:r}){const u=qt(n);function f({translateExtent:h,width:m,height:g,zoomStep:v=1,pannable:p=!0,zoomable:b=!0,inversePan:x=!1}){const _=S=>{if(S.sourceEvent.type!=="wheel"||!l)return;const D=o(),H=S.sourceEvent.ctrlKey&&Ao()?10:1,j=-S.sourceEvent.deltaY*(S.sourceEvent.deltaMode===1?.05:S.sourceEvent.deltaMode?1:.002)*v,k=D[2]*Math.pow(2,j*H);l.scaleTo(k)};let T=[0,0];const z=S=>{(S.sourceEvent.type==="mousedown"||S.sourceEvent.type==="touchstart")&&(T=[S.sourceEvent.clientX??S.sourceEvent.touches[0].clientX,S.sourceEvent.clientY??S.sourceEvent.touches[0].clientY])},A=S=>{const D=o();if(S.sourceEvent.type!=="mousemove"&&S.sourceEvent.type!=="touchmove"||!l)return;const H=[S.sourceEvent.clientX??S.sourceEvent.touches[0].clientX,S.sourceEvent.clientY??S.sourceEvent.touches[0].clientY],j=[H[0]-T[0],H[1]-T[1]];T=H;const k=r()*Math.max(D[2],Math.log(D[2]))*(x?-1:1),q={x:D[0]-j[0]*k,y:D[1]-j[1]*k},Z=[[0,0],[m,g]];l.setViewportConstrained({x:q.x,y:q.y,zoom:D[2]},Z,h)},R=dp().on("start",z).on("zoom",p?A:null).on("zoom.wheel",b?_:null);u.call(R,{})}function d(){u.on("zoom",null)}return{update:f,destroy:d,pointer:rn}}const Xu=n=>({x:n.x,y:n.y,zoom:n.k}),wf=({x:n,y:l,zoom:o})=>qu.translate(n,l).scale(o),Pl=(n,l)=>n.target.closest(`.${l}`),Up=(n,l)=>l===2&&Array.isArray(n)&&n.includes(2),d2=n=>((n*=2)<=1?n*n*n:(n-=2)*n*n+2)/2,Sf=(n,l=0,o=d2,r=()=>{})=>{const u=typeof l=="number"&&l>0;return u||r(),u?n.transition().duration(l).ease(o).on("end",r):n},Gp=n=>{const l=n.ctrlKey&&Ao()?10:1;return-n.deltaY*(n.deltaMode===1?.05:n.deltaMode?1:.002)*l};function h2({zoomPanValues:n,noWheelClassName:l,d3Selection:o,d3Zoom:r,panOnScrollMode:u,panOnScrollSpeed:f,zoomOnPinch:d,onPanZoomStart:h,onPanZoom:m,onPanZoomEnd:g}){return v=>{if(Pl(v,l))return v.ctrlKey&&v.preventDefault(),!1;v.preventDefault(),v.stopImmediatePropagation();const p=o.property("__zoom").k||1;if(v.ctrlKey&&d){const z=rn(v),A=Gp(v),R=p*Math.pow(2,A);r.scaleTo(o,R,z,v);return}const b=v.deltaMode===1?20:1;let x=u===el.Vertical?0:v.deltaX*b,_=u===el.Horizontal?0:v.deltaY*b;!Ao()&&v.shiftKey&&u!==el.Vertical&&(x=v.deltaY*b,_=0),r.translateBy(o,-(x/p)*f,-(_/p)*f,{internal:!0});const T=Xu(o.property("__zoom"));clearTimeout(n.panScrollTimeout),n.isPanScrolling?m==null||m(v,T):(n.isPanScrolling=!0,h==null||h(v,T)),n.panScrollTimeout=setTimeout(()=>{g==null||g(v,T),n.isPanScrolling=!1},150)}}function g2({noWheelClassName:n,preventScrolling:l,d3ZoomHandler:o}){return function(r,u){const f=r.type==="wheel",d=!l&&f&&!r.ctrlKey,h=Pl(r,n);if(r.ctrlKey&&f&&h&&r.preventDefault(),d||h)return null;r.preventDefault(),o.call(this,r,u)}}function m2({zoomPanValues:n,onDraggingChange:l,onPanZoomStart:o}){return r=>{var f,d,h;if((f=r.sourceEvent)!=null&&f.internal)return;const u=Xu(r.transform);n.mouseButton=((d=r.sourceEvent)==null?void 0:d.button)||0,n.isZoomingOrPanning=!0,n.prevViewport=u,((h=r.sourceEvent)==null?void 0:h.type)==="mousedown"&&l(!0),o&&(o==null||o(r.sourceEvent,u))}}function y2({zoomPanValues:n,panOnDrag:l,onPaneContextMenu:o,onTransformChange:r,onPanZoom:u}){return f=>{var d,h;n.usedRightMouseButton=!!(o&&Up(l,n.mouseButton??0)),(d=f.sourceEvent)!=null&&d.sync||r([f.transform.x,f.transform.y,f.transform.k]),u&&!((h=f.sourceEvent)!=null&&h.internal)&&(u==null||u(f.sourceEvent,Xu(f.transform)))}}function p2({zoomPanValues:n,panOnDrag:l,panOnScroll:o,onDraggingChange:r,onPanZoomEnd:u,onPaneContextMenu:f}){return d=>{var h;if(!((h=d.sourceEvent)!=null&&h.internal)&&(n.isZoomingOrPanning=!1,f&&Up(l,n.mouseButton??0)&&!n.usedRightMouseButton&&d.sourceEvent&&f(d.sourceEvent),n.usedRightMouseButton=!1,r(!1),u)){const m=Xu(d.transform);n.prevViewport=m,clearTimeout(n.timerId),n.timerId=setTimeout(()=>{u==null||u(d.sourceEvent,m)},o?150:0)}}}function v2({zoomActivationKeyPressed:n,zoomOnScroll:l,zoomOnPinch:o,panOnDrag:r,panOnScroll:u,zoomOnDoubleClick:f,userSelectionActive:d,noWheelClassName:h,noPanClassName:m,lib:g,connectionInProgress:v}){return p=>{var z;const b=n||l,x=o&&p.ctrlKey,_=p.type==="wheel";if(p.button===1&&p.type==="mousedown"&&(Pl(p,`${g}-flow__node`)||Pl(p,`${g}-flow__edge`)))return!0;if(!r&&!b&&!u&&!f&&!o||d||v&&!_||Pl(p,h)&&_||Pl(p,m)&&(!_||u&&_&&!n)||!o&&p.ctrlKey&&_)return!1;if(!o&&p.type==="touchstart"&&((z=p.touches)==null?void 0:z.length)>1)return p.preventDefault(),!1;if(!b&&!u&&!x&&_||!r&&(p.type==="mousedown"||p.type==="touchstart")||Array.isArray(r)&&!r.includes(p.button)&&p.type==="mousedown")return!1;const T=Array.isArray(r)&&r.includes(p.button)||!p.button||p.button<=1;return(!p.ctrlKey||_)&&T}}function b2({domNode:n,minZoom:l,maxZoom:o,translateExtent:r,viewport:u,onPanZoom:f,onPanZoomStart:d,onPanZoomEnd:h,onDraggingChange:m}){const g={isZoomingOrPanning:!1,usedRightMouseButton:!1,prevViewport:{},mouseButton:0,timerId:void 0,panScrollTimeout:void 0,isPanScrolling:!1},v=n.getBoundingClientRect();let p=[[0,0],[v.width,v.height]];const b=typeof ResizeObserver<"u"?new ResizeObserver(P=>{const C=P[0];C&&(p=[[0,0],[C.contentRect.width,C.contentRect.height]])}):null;b==null||b.observe(n);const x=dp().extent(()=>p).scaleExtent([l,o]).translateExtent(r),_=qt(n).call(x);D({x:u.x,y:u.y,zoom:oi(u.zoom,l,o)},[[0,0],[v.width,v.height]],r);const T=_.on("wheel.zoom"),z=_.on("dblclick.zoom");x.wheelDelta(Gp);async function A(P,C){return _?new Promise(V=>{x==null||x.interpolate((C==null?void 0:C.interpolate)==="linear"?po:bu).transform(Sf(_,C==null?void 0:C.duration,C==null?void 0:C.ease,()=>V(!0)),P)}):!1}function R({noWheelClassName:P,noPanClassName:C,onPaneContextMenu:V,userSelectionActive:M,panOnScroll:B,panOnDrag:X,panOnScrollMode:Y,panOnScrollSpeed:U,preventScrolling:E,zoomOnPinch:O,zoomOnScroll:W,zoomOnDoubleClick:le,zoomActivationKeyPressed:ce,lib:me,onTransformChange:ge,connectionInProgress:ae,paneClickDistance:fe,selectionOnDrag:ee}){M&&!g.isZoomingOrPanning&&S();const se=B&&!ce&&!M;x.clickDistance(ee?1/0:!sn(fe)||fe<0?0:fe);const de=se?h2({zoomPanValues:g,noWheelClassName:P,d3Selection:_,d3Zoom:x,panOnScrollMode:Y,panOnScrollSpeed:U,zoomOnPinch:O,onPanZoomStart:d,onPanZoom:f,onPanZoomEnd:h}):g2({noWheelClassName:P,preventScrolling:E,d3ZoomHandler:T});_.on("wheel.zoom",de,{passive:!1});const pe=m2({zoomPanValues:g,onDraggingChange:m,onPanZoomStart:d});x.on("start",pe);const we=y2({zoomPanValues:g,panOnDrag:X,onPaneContextMenu:!!V,onPanZoom:f,onTransformChange:ge});x.on("zoom",we);const he=p2({zoomPanValues:g,panOnDrag:X,panOnScroll:B,onPaneContextMenu:V,onPanZoomEnd:h,onDraggingChange:m});x.on("end",he);const ye=v2({zoomActivationKeyPressed:ce,panOnDrag:X,zoomOnScroll:W,panOnScroll:B,zoomOnDoubleClick:le,zoomOnPinch:O,userSelectionActive:M,noPanClassName:C,noWheelClassName:P,lib:me,connectionInProgress:ae});x.filter(ye),le?_.on("dblclick.zoom",z):_.on("dblclick.zoom",null)}function S(){x.on("zoom",null)}async function D(P,C,V){const M=wf(P),B=x==null?void 0:x.constrain()(M,C,V);return B&&await A(B),B}async function H(P,C){const V=wf(P);return await A(V,C),V}function j(P){if(_){const C=wf(P),V=_.property("__zoom");(V.k!==P.zoom||V.x!==P.x||V.y!==P.y)&&(x==null||x.transform(_,C,null,{sync:!0}))}}function k(){const P=_?fp(_.node()):{x:0,y:0,k:1};return{x:P.x,y:P.y,zoom:P.k}}async function q(P,C){return _?new Promise(V=>{x==null||x.interpolate((C==null?void 0:C.interpolate)==="linear"?po:bu).scaleTo(Sf(_,C==null?void 0:C.duration,C==null?void 0:C.ease,()=>V(!0)),P)}):!1}async function Z(P,C){return _?new Promise(V=>{x==null||x.interpolate((C==null?void 0:C.interpolate)==="linear"?po:bu).scaleBy(Sf(_,C==null?void 0:C.duration,C==null?void 0:C.ease,()=>V(!0)),P)}):!1}function ie(P){x==null||x.scaleExtent(P)}function J(P){x==null||x.translateExtent(P)}function ne(P){const C=!sn(P)||P<0?0:P;x==null||x.clickDistance(C)}return{update:R,destroy:S,setViewport:H,setViewportConstrained:D,getViewport:k,scaleTo:q,scaleBy:Z,setScaleExtent:ie,setTranslateExtent:J,syncViewport:j,setClickDistance:ne}}var ui;(function(n){n.Line="line",n.Handle="handle"})(ui||(ui={}));function x2({width:n,prevWidth:l,height:o,prevHeight:r,affectsX:u,affectsY:f}){const d=n-l,h=o-r,m=[d>0?1:d<0?-1:0,h>0?1:h<0?-1:0];return d&&u&&(m[0]=m[0]*-1),h&&f&&(m[1]=m[1]*-1),m}function Zm(n){const l=n.includes("right")||n.includes("left"),o=n.includes("bottom")||n.includes("top"),r=n.includes("left"),u=n.includes("top");return{isHorizontal:l,isVertical:o,affectsX:r,affectsY:u}}function Ea(n,l){return Math.max(0,l-n)}function Na(n,l){return Math.max(0,n-l)}function gu(n,l,o){return Math.max(0,l-n,n-o)}function Km(n,l){return n?!l:l}function _2(n,l,o,r,u,f,d,h){let{affectsX:m,affectsY:g}=l;const{isHorizontal:v,isVertical:p}=l,b=v&&p,{xSnapped:x,ySnapped:_}=o,{minWidth:T,maxWidth:z,minHeight:A,maxHeight:R}=r,{x:S,y:D,width:H,height:j,aspectRatio:k}=n;let q=Math.floor(v?x-n.pointerX:0),Z=Math.floor(p?_-n.pointerY:0);const ie=H+(m?-q:q),J=j+(g?-Z:Z),ne=-f[0]*H,P=-f[1]*j;let C=gu(ie,T,z),V=gu(J,A,R);if(d){let X=0,Y=0;m&&q<0?X=Ea(S+q+ne,d[0][0]):!m&&q>0&&(X=Na(S+ie+ne,d[1][0])),g&&Z<0?Y=Ea(D+Z+P,d[0][1]):!g&&Z>0&&(Y=Na(D+J+P,d[1][1])),C=Math.max(C,X),V=Math.max(V,Y)}if(h){let X=0,Y=0;m&&q>0?X=Na(S+q,h[0][0]):!m&&q<0&&(X=Ea(S+ie,h[1][0])),g&&Z>0?Y=Na(D+Z,h[0][1]):!g&&Z<0&&(Y=Ea(D+J,h[1][1])),C=Math.max(C,X),V=Math.max(V,Y)}if(u){if(v){const X=gu(ie/k,A,R)*k;if(C=Math.max(C,X),d){let Y=0;!m&&!g||m&&!g&&b?Y=Na(D+P+ie/k,d[1][1])*k:Y=Ea(D+P+(m?q:-q)/k,d[0][1])*k,C=Math.max(C,Y)}if(h){let Y=0;!m&&!g||m&&!g&&b?Y=Ea(D+ie/k,h[1][1])*k:Y=Na(D+(m?q:-q)/k,h[0][1])*k,C=Math.max(C,Y)}}if(p){const X=gu(J*k,T,z)/k;if(V=Math.max(V,X),d){let Y=0;!m&&!g||g&&!m&&b?Y=Na(S+J*k+ne,d[1][0])/k:Y=Ea(S+(g?Z:-Z)*k+ne,d[0][0])/k,V=Math.max(V,Y)}if(h){let Y=0;!m&&!g||g&&!m&&b?Y=Ea(S+J*k,h[1][0])/k:Y=Na(S+(g?Z:-Z)*k,h[0][0])/k,V=Math.max(V,Y)}}}Z=Z+(Z<0?V:-V),q=q+(q<0?C:-C),u&&(b?ie>J*k?Z=(Km(m,g)?-q:q)/k:q=(Km(m,g)?-Z:Z)*k:v?(Z=q/k,g=m):(q=Z*k,m=g));const M=m?S+q:S,B=g?D+Z:D;return{width:H+(m?-q:q),height:j+(g?-Z:Z),x:f[0]*q*(m?-1:1)+M,y:f[1]*Z*(g?-1:1)+B}}const qp={width:0,height:0,x:0,y:0},w2={...qp,pointerX:0,pointerY:0,aspectRatio:1};function S2(n,l,o){const r=l.position.x+n.position.x,u=l.position.y+n.position.y,f=n.measured.width??0,d=n.measured.height??0,h=o[0]*f,m=o[1]*d;return[[r-h,u-m],[r+f-h,u+d-m]]}function E2({domNode:n,nodeId:l,getStoreItems:o,onChange:r,onEnd:u}){const f=qt(n);let d={controlDirection:Zm("bottom-right"),boundaries:{minWidth:0,minHeight:0,maxWidth:Number.MAX_VALUE,maxHeight:Number.MAX_VALUE},resizeDirection:void 0,keepAspectRatio:!1};function h({controlPosition:g,boundaries:v,keepAspectRatio:p,resizeDirection:b,onResizeStart:x,onResize:_,onResizeEnd:T,shouldResize:z}){let A={...qp},R={...w2};d={boundaries:v,resizeDirection:b,keepAspectRatio:p,controlDirection:Zm(g)};let S,D=null,H=[],j,k,q,Z=!1;const ie=Wy().on("start",J=>{const{nodeLookup:ne,transform:P,snapGrid:C,snapToGrid:V,nodeOrigin:M,paneDomNode:B}=o();if(S=ne.get(l),!S)return;D=(B==null?void 0:B.getBoundingClientRect())??null;const{xSnapped:X,ySnapped:Y}=vo(J.sourceEvent,{transform:P,snapGrid:C,snapToGrid:V,containerBounds:D});A={width:S.measured.width??0,height:S.measured.height??0,x:S.position.x??0,y:S.position.y??0},R={...A,pointerX:X,pointerY:Y,aspectRatio:A.width/A.height},j=void 0,k=ll(S.extent)?S.extent:void 0,S.parentId&&(S.extent==="parent"||S.expandParent)&&(j=ne.get(S.parentId)),j&&S.extent==="parent"&&(k=[[0,0],[j.measured.width,j.measured.height]]),H=[],q=void 0;for(const[U,E]of ne)if(E.parentId===l&&(H.push({id:U,position:{...E.position},extent:E.extent}),E.extent==="parent"||E.expandParent)){const O=S2(E,S,E.origin??M);q?q=[[Math.min(O[0][0],q[0][0]),Math.min(O[0][1],q[0][1])],[Math.max(O[1][0],q[1][0]),Math.max(O[1][1],q[1][1])]]:q=O}x==null||x(J,{...A})}).on("drag",J=>{const{transform:ne,snapGrid:P,snapToGrid:C,nodeOrigin:V}=o(),M=vo(J.sourceEvent,{transform:ne,snapGrid:P,snapToGrid:C,containerBounds:D}),B=[];if(!S)return;const{x:X,y:Y,width:U,height:E}=A,O={},W=S.origin??V,{width:le,height:ce,x:me,y:ge}=_2(R,d.controlDirection,M,d.boundaries,d.keepAspectRatio,W,k,q),ae=le!==U,fe=ce!==E,ee=me!==X&&ae,se=ge!==Y&&fe;if(!ee&&!se&&!ae&&!fe)return;if((ee||se||W[0]===1||W[1]===1)&&(O.x=ee?me:A.x,O.y=se?ge:A.y,A.x=O.x,A.y=O.y,H.length>0)){const he=me-X,ye=ge-Y;for(const Ae of H)Ae.position={x:Ae.position.x-he+W[0]*(le-U),y:Ae.position.y-ye+W[1]*(ce-E)},B.push(Ae)}if((ae||fe)&&(O.width=ae&&(!d.resizeDirection||d.resizeDirection==="horizontal")?le:A.width,O.height=fe&&(!d.resizeDirection||d.resizeDirection==="vertical")?ce:A.height,A.width=O.width,A.height=O.height),j&&S.expandParent){const he=W[0]*(O.width??0);O.x&&O.x<he&&(A.x=he,R.x=R.x-(O.x-he));const ye=W[1]*(O.height??0);O.y&&O.y<ye&&(A.y=ye,R.y=R.y-(O.y-ye))}const de=x2({width:A.width,prevWidth:U,height:A.height,prevHeight:E,affectsX:d.controlDirection.affectsX,affectsY:d.controlDirection.affectsY}),pe={...A,direction:de};(z==null?void 0:z(J,pe))!==!1&&(Z=!0,_==null||_(J,pe),r(O,B))}).on("end",J=>{Z&&(T==null||T(J,{...A}),u==null||u({...A}),Z=!1)});f.call(ie)}function m(){f.on(".drag",null)}return{update:h,destroy:m}}var Ef={exports:{}},Nf={},Tf={exports:{}},Af={};/**
+ * @license React
+ * use-sync-external-store-shim.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */var Im;function N2(){if(Im)return Af;Im=1;var n=Do();function l(p,b){return p===b&&(p!==0||1/p===1/b)||p!==p&&b!==b}var o=typeof Object.is=="function"?Object.is:l,r=n.useState,u=n.useEffect,f=n.useLayoutEffect,d=n.useDebugValue;function h(p,b){var x=b(),_=r({inst:{value:x,getSnapshot:b}}),T=_[0].inst,z=_[1];return f(function(){T.value=x,T.getSnapshot=b,m(T)&&z({inst:T})},[p,x,b]),u(function(){return m(T)&&z({inst:T}),p(function(){m(T)&&z({inst:T})})},[p]),d(x),x}function m(p){var b=p.getSnapshot;p=p.value;try{var x=b();return!o(p,x)}catch{return!0}}function g(p,b){return b()}var v=typeof window>"u"||typeof window.document>"u"||typeof window.document.createElement>"u"?g:h;return Af.useSyncExternalStore=n.useSyncExternalStore!==void 0?n.useSyncExternalStore:v,Af}var Jm;function T2(){return Jm||(Jm=1,Tf.exports=N2()),Tf.exports}/**
+ * @license React
+ * use-sync-external-store-shim/with-selector.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */var Wm;function A2(){if(Wm)return Nf;Wm=1;var n=Do(),l=T2();function o(g,v){return g===v&&(g!==0||1/g===1/v)||g!==g&&v!==v}var r=typeof Object.is=="function"?Object.is:o,u=l.useSyncExternalStore,f=n.useRef,d=n.useEffect,h=n.useMemo,m=n.useDebugValue;return Nf.useSyncExternalStoreWithSelector=function(g,v,p,b,x){var _=f(null);if(_.current===null){var T={hasValue:!1,value:null};_.current=T}else T=_.current;_=h(function(){function A(j){if(!R){if(R=!0,S=j,j=b(j),x!==void 0&&T.hasValue){var k=T.value;if(x(k,j))return D=k}return D=j}if(k=D,r(S,j))return k;var q=b(j);return x!==void 0&&x(k,q)?(S=j,k):(S=j,D=q)}var R=!1,S,D,H=p===void 0?null:p;return[function(){return A(v())},H===null?void 0:function(){return A(H())}]},[v,p,b,x]);var z=u(g,_[0],_[1]);return d(function(){T.hasValue=!0,T.value=z},[z]),m(z),z},Nf}var Fm;function M2(){return Fm||(Fm=1,Ef.exports=A2()),Ef.exports}var z2=M2();const C2=Oy(z2),D2={},Pm=n=>{let l;const o=new Set,r=(v,p)=>{const b=typeof v=="function"?v(l):v;if(!Object.is(b,l)){const x=l;l=p??(typeof b!="object"||b===null)?b:Object.assign({},l,b),o.forEach(_=>_(l,x))}},u=()=>l,m={setState:r,getState:u,getInitialState:()=>g,subscribe:v=>(o.add(v),()=>o.delete(v)),destroy:()=>{(D2?"production":void 0)!=="production"&&console.warn("[DEPRECATED] The `destroy` method will be unsupported in a future version. Instead use unsubscribe function returned by subscribe. Everything will be garbage-collected if store is garbage-collected."),o.clear()}},g=l=n(r,u,m);return m},k2=n=>n?Pm(n):Pm,{useDebugValue:R2}=go,{useSyncExternalStoreWithSelector:j2}=C2,O2=n=>n;function Yp(n,l=O2,o){const r=j2(n.subscribe,n.getState,n.getServerState||n.getInitialState,l,o);return R2(r),r}const ey=(n,l)=>{const o=k2(n),r=(u,f=l)=>Yp(o,u,f);return Object.assign(r,o),r},H2=(n,l)=>n?ey(n,l):ey;function Ie(n,l){if(Object.is(n,l))return!0;if(typeof n!="object"||n===null||typeof l!="object"||l===null)return!1;if(n instanceof Map&&l instanceof Map){if(n.size!==l.size)return!1;for(const[r,u]of n)if(!Object.is(u,l.get(r)))return!1;return!0}if(n instanceof Set&&l instanceof Set){if(n.size!==l.size)return!1;for(const r of n)if(!l.has(r))return!1;return!0}const o=Object.keys(n);if(o.length!==Object.keys(l).length)return!1;for(const r of o)if(!Object.prototype.hasOwnProperty.call(l,r)||!Object.is(n[r],l[r]))return!1;return!0}var Ed=Hy();const Qu=$.createContext(null),B2=Qu.Provider,Vp=fn.error001("react");function je(n,l){const o=$.useContext(Qu);if(o===null)throw new Error(Vp);return Yp(o,n,l)}function $e(){const n=$.useContext(Qu);if(n===null)throw new Error(Vp);return $.useMemo(()=>({getState:n.getState,setState:n.setState,subscribe:n.subscribe}),[n])}const ty={display:"none"},L2={position:"absolute",width:1,height:1,margin:-1,border:0,padding:0,overflow:"hidden",clip:"rect(0px, 0px, 0px, 0px)",clipPath:"inset(100%)"},Xp="react-flow__node-desc",Qp="react-flow__edge-desc",U2="react-flow__aria-live",G2=n=>n.ariaLiveMessage,q2=n=>n.ariaLabelConfig;function Y2({rfId:n}){const l=je(G2);return N.jsx("div",{id:`${U2}-${n}`,"aria-live":"assertive","aria-atomic":"true",style:L2,children:l})}function V2({rfId:n,disableKeyboardA11y:l}){const o=je(q2);return N.jsxs(N.Fragment,{children:[N.jsx("div",{id:`${Xp}-${n}`,style:ty,children:l?o["node.a11yDescription.default"]:o["node.a11yDescription.keyboardDisabled"]}),N.jsx("div",{id:`${Qp}-${n}`,style:ty,children:o["edge.a11yDescription.default"]}),!l&&N.jsx(Y2,{rfId:n})]})}const $u=$.forwardRef(({position:n="top-left",children:l,className:o,style:r,...u},f)=>{const d=`${n}`.split("-");return N.jsx("div",{className:ot(["react-flow__panel",o,...d]),style:r,ref:f,...u,children:l})});$u.displayName="Panel";const ny="https://reactflow.dev?utm_source=attribution";function X2({proOptions:n,position:l="bottom-right"}){return n!=null&&n.hideAttribution?null:N.jsx($u,{position:l,className:"react-flow__attribution","data-message":`Please only hide this attribution when you are subscribed to React Flow Pro: ${ny}`,children:N.jsx("a",{href:ny,target:"_blank",rel:"noopener noreferrer","aria-label":"React Flow attribution",children:"React Flow"})})}const Q2=n=>{const l=[],o=[];for(const[,r]of n.nodeLookup)r.selected&&l.push(r.internals.userNode);for(const[,r]of n.edgeLookup)r.selected&&o.push(r);return{selectedNodes:l,selectedEdges:o}},mu=n=>n.id;function $2(n,l){return Ie(n.selectedNodes.map(mu),l.selectedNodes.map(mu))&&Ie(n.selectedEdges.map(mu),l.selectedEdges.map(mu))}function Z2({onSelectionChange:n}){const l=$e(),{selectedNodes:o,selectedEdges:r}=je(Q2,$2);return $.useEffect(()=>{const u={nodes:o,edges:r};n==null||n(u),l.getState().onSelectionChangeHandlers.forEach(f=>f(u))},[o,r,n]),null}const K2=n=>!!n.onSelectionChangeHandlers;function I2({onSelectionChange:n}){const l=je(K2);return n||l?N.jsx(Z2,{onSelectionChange:n}):null}const $p=[0,0],J2={x:0,y:0,zoom:1},W2=["nodes","edges","defaultNodes","defaultEdges","onConnect","onConnectStart","onConnectEnd","onClickConnectStart","onClickConnectEnd","nodesDraggable","autoPanOnNodeFocus","nodesConnectable","nodesFocusable","edgesFocusable","edgesReconnectable","elevateNodesOnSelect","elevateEdgesOnSelect","minZoom","maxZoom","nodeExtent","onNodesChange","onEdgesChange","elementsSelectable","connectionMode","snapGrid","snapToGrid","translateExtent","connectOnClick","defaultEdgeOptions","fitView","fitViewOptions","onNodesDelete","onEdgesDelete","onDelete","onNodeDrag","onNodeDragStart","onNodeDragStop","onSelectionDrag","onSelectionDragStart","onSelectionDragStop","onMoveStart","onMove","onMoveEnd","noPanClassName","nodeOrigin","autoPanOnConnect","autoPanOnNodeDrag","onError","connectionRadius","isValidConnection","selectNodesOnDrag","nodeDragThreshold","connectionDragThreshold","onBeforeDelete","debug","autoPanSpeed","ariaLabelConfig","zIndexMode"],ay=[...W2,"rfId"],F2=n=>({setNodes:n.setNodes,setEdges:n.setEdges,setMinZoom:n.setMinZoom,setMaxZoom:n.setMaxZoom,setTranslateExtent:n.setTranslateExtent,setNodeExtent:n.setNodeExtent,reset:n.reset,setDefaultNodesAndEdges:n.setDefaultNodesAndEdges}),ly={translateExtent:Eo,nodeOrigin:$p,minZoom:.5,maxZoom:2,elementsSelectable:!0,noPanClassName:"nopan",rfId:"1"};function P2(n){const{setNodes:l,setEdges:o,setMinZoom:r,setMaxZoom:u,setTranslateExtent:f,setNodeExtent:d,reset:h,setDefaultNodesAndEdges:m}=je(F2,Ie),g=$e();$.useEffect(()=>(m(n.defaultNodes,n.defaultEdges),()=>{v.current=ly,h()}),[]);const v=$.useRef(ly);return $.useEffect(()=>{for(const p of ay){const b=n[p],x=v.current[p];b!==x&&(typeof n[p]>"u"||(p==="nodes"?l(b):p==="edges"?o(b):p==="minZoom"?r(b):p==="maxZoom"?u(b):p==="translateExtent"?f(b):p==="nodeExtent"?d(b):p==="ariaLabelConfig"?g.setState({ariaLabelConfig:BS(b)}):p==="fitView"?g.setState({fitViewQueued:b}):p==="fitViewOptions"?g.setState({fitViewOptions:b}):g.setState({[p]:b})))}v.current=n},ay.map(p=>n[p])),null}function iy(){return typeof window>"u"||!window.matchMedia?null:window.matchMedia("(prefers-color-scheme: dark)")}function eE(n){var r;const[l,o]=$.useState(n==="system"?null:n);return $.useEffect(()=>{if(n!=="system"){o(n);return}const u=iy(),f=()=>o(u!=null&&u.matches?"dark":"light");return f(),u==null||u.addEventListener("change",f),()=>{u==null||u.removeEventListener("change",f)}},[n]),l!==null?l:(r=iy())!=null&&r.matches?"dark":"light"}const oy=typeof document<"u"?document:null;function Mo(n=null,l={target:oy,actInsideInputWithModifier:!0}){const[o,r]=$.useState(!1),u=$.useRef(!1),f=$.useRef(new Set([])),[d,h]=$.useMemo(()=>{if(n!==null){const g=(Array.isArray(n)?n:[n]).filter(p=>typeof p=="string").map(p=>p.replace("+",`
+`).replace(`
+
+`,`
++`).split(`
+`)),v=g.reduce((p,b)=>p.concat(...b),[]);return[g,v]}return[[],[]]},[n]);return $.useEffect(()=>{const m=(l==null?void 0:l.target)??oy,g=(l==null?void 0:l.actInsideInputWithModifier)??!0;if(n!==null){const v=x=>{var z,A;if(u.current=x.ctrlKey||x.metaKey||x.shiftKey||x.altKey,(!u.current||u.current&&!g)&&Tp(x))return!1;const T=uy(x.code,h);if(f.current.add(x[T]),ry(d,f.current,!1)){const R=((A=(z=x.composedPath)==null?void 0:z.call(x))==null?void 0:A[0])||x.target,S=(R==null?void 0:R.nodeName)==="BUTTON"||(R==null?void 0:R.nodeName)==="A";l.preventDefault!==!1&&(u.current||!S)&&x.preventDefault(),r(!0)}},p=x=>{const _=uy(x.code,h);ry(d,f.current,!0)?(r(!1),f.current.clear()):f.current.delete(x[_]),x.key==="Meta"&&f.current.clear(),u.current=!1},b=()=>{f.current.clear(),r(!1)};return m==null||m.addEventListener("keydown",v),m==null||m.addEventListener("keyup",p),window.addEventListener("blur",b),window.addEventListener("contextmenu",b),()=>{m==null||m.removeEventListener("keydown",v),m==null||m.removeEventListener("keyup",p),window.removeEventListener("blur",b),window.removeEventListener("contextmenu",b)}}},[n,r]),o}function ry(n,l,o){return n.filter(r=>o||r.length===l.size).some(r=>r.every(u=>l.has(u)))}function uy(n,l){return l.includes(n)?"code":"key"}const tE=()=>{const n=$e();return $.useMemo(()=>({zoomIn:async l=>{const{panZoom:o}=n.getState();return o?o.scaleBy(1.2,l):!1},zoomOut:async l=>{const{panZoom:o}=n.getState();return o?o.scaleBy(1/1.2,l):!1},zoomTo:async(l,o)=>{const{panZoom:r}=n.getState();return r?r.scaleTo(l,o):!1},getZoom:()=>n.getState().transform[2],setViewport:async(l,o)=>{const{transform:[r,u,f],panZoom:d}=n.getState();return d?(await d.setViewport({x:l.x??r,y:l.y??u,zoom:l.zoom??f},o),!0):!1},getViewport:()=>{const[l,o,r]=n.getState().transform;return{x:l,y:o,zoom:r}},setCenter:async(l,o,r)=>n.getState().setCenter(l,o,r),fitBounds:async(l,o)=>{const{width:r,height:u,minZoom:f,maxZoom:d,panZoom:h}=n.getState(),m=yd(l,r,u,f,d,(o==null?void 0:o.padding)??.1);return h?(await h.setViewport(m,{duration:o==null?void 0:o.duration,ease:o==null?void 0:o.ease,interpolate:o==null?void 0:o.interpolate}),!0):!1},screenToFlowPosition:(l,o={})=>{const{transform:r,snapGrid:u,snapToGrid:f,domNode:d}=n.getState();if(!d)return l;const{x:h,y:m}=d.getBoundingClientRect(),g={x:l.x-h,y:l.y-m},v=o.snapGrid??u,p=o.snapToGrid??f;return Bo(g,r,p,v)},flowToScreenPosition:l=>{const{transform:o,domNode:r}=n.getState();if(!r)return l;const{x:u,y:f}=r.getBoundingClientRect(),d=ri(l,o);return{x:d.x+u,y:d.y+f}}}),[])};function Zp(n,l){const o=[],r=new Map,u=[];for(const f of n)if(f.type==="add"){u.push(f);continue}else if(f.type==="remove"||f.type==="replace")r.set(f.id,[f]);else{const d=r.get(f.id);d?d.push(f):r.set(f.id,[f])}for(const f of l){const d=r.get(f.id);if(!d){o.push(f);continue}if(d[0].type==="remove")continue;if(d[0].type==="replace"){o.push({...d[0].item});continue}const h={...f};for(const m of d)nE(m,h);o.push(h)}return u.length&&u.forEach(f=>{f.index!==void 0?o.splice(f.index,0,{...f.item}):o.push({...f.item})}),o}function nE(n,l){switch(n.type){case"select":{l.selected=n.selected;break}case"position":{typeof n.position<"u"&&(l.position=n.position),typeof n.dragging<"u"&&(l.dragging=n.dragging);break}case"dimensions":{typeof n.dimensions<"u"&&(l.measured={...n.dimensions},n.setAttributes&&((n.setAttributes===!0||n.setAttributes==="width")&&(l.width=n.dimensions.width),(n.setAttributes===!0||n.setAttributes==="height")&&(l.height=n.dimensions.height))),typeof n.resizing=="boolean"&&(l.resizing=n.resizing);break}}}function Kf(n,l){return Zp(n,l)}function If(n,l){return Zp(n,l)}function Wa(n,l){return{id:n,type:"select",selected:l}}function ei(n,l=new Set,o=!1){const r=[];for(const[u,f]of n){const d=l.has(u);!(f.selected===void 0&&!d)&&f.selected!==d&&(o&&(f.selected=d),r.push(Wa(f.id,d)))}return r}function sy({items:n=[],lookup:l}){var u;const o=[],r=new Map(n.map(f=>[f.id,f]));for(const[f,d]of n.entries()){const h=l.get(d.id),m=((u=h==null?void 0:h.internals)==null?void 0:u.userNode)??h;m!==void 0&&m!==d&&o.push({id:d.id,item:d,type:"replace"}),m===void 0&&o.push({item:d,type:"add",index:f})}for(const[f]of l)r.get(f)===void 0&&o.push({id:f,type:"remove"});return o}function cy(n){return{id:n.id,type:"remove"}}const aE=wp();function Jf(n,l,o={}){return VS(n,l,{...o,onError:o.onError??aE})}const fy=n=>MS(n),lE=n=>pp(n);function Kp(n){return $.forwardRef(n)}const Ip=typeof window<"u"?$.useLayoutEffect:$.useEffect;function dy(n){const[l,o]=$.useState(BigInt(0)),[r]=$.useState(()=>iE(()=>o(u=>u+BigInt(1))));return Ip(()=>{const u=r.get();u.length&&(n(u),r.reset())},[l]),r}function iE(n){let l=[];return{get:()=>l,reset:()=>{l=[]},push:o=>{l.push(o),n()}}}const Jp=$.createContext(null);function oE({children:n}){const l=$e(),o=$.useCallback(h=>{const{nodes:m=[],setNodes:g,hasDefaultNodes:v,onNodesChange:p,nodeLookup:b,fitViewQueued:x,onNodesChangeMiddlewareMap:_}=l.getState();let T=m;for(const A of h)T=typeof A=="function"?A(T):A;let z=sy({items:T,lookup:b});for(const A of _.values())z=A(z);v&&g(T),z.length>0?p==null||p(z):x&&window.requestAnimationFrame(()=>{const{fitViewQueued:A,nodes:R,setNodes:S}=l.getState();A&&S(R)})},[]),r=dy(o),u=$.useCallback(h=>{const{edges:m=[],setEdges:g,hasDefaultEdges:v,onEdgesChange:p,edgeLookup:b}=l.getState();let x=m;for(const _ of h)x=typeof _=="function"?_(x):_;v?g(x):p&&p(sy({items:x,lookup:b}))},[]),f=dy(u),d=$.useMemo(()=>({nodeQueue:r,edgeQueue:f}),[]);return N.jsx(Jp.Provider,{value:d,children:n})}function rE(){const n=$.useContext(Jp);if(!n)throw new Error("useBatchContext must be used within a BatchProvider");return n}const uE=n=>!!n.panZoom;function Lo(){const n=tE(),l=$e(),o=rE(),r=je(uE),u=$.useMemo(()=>{const f=p=>l.getState().nodeLookup.get(p),d=p=>{o.nodeQueue.push(p)},h=p=>{o.edgeQueue.push(p)},m=p=>{var A,R;const{nodeLookup:b,nodeOrigin:x}=l.getState(),_=fy(p)?p:b.get(p.id),T=_.parentId?Ep(_.position,_.measured,_.parentId,b,x):_.position,z={..._,position:T,width:((A=_.measured)==null?void 0:A.width)??_.width,height:((R=_.measured)==null?void 0:R.height)??_.height};return To(z)},g=(p,b,x={replace:!1})=>{d(_=>_.map(T=>{if(T.id===p){const z=typeof b=="function"?b(T):b;return x.replace&&fy(z)?z:{...T,...z}}return T}))},v=(p,b,x={replace:!1})=>{h(_=>_.map(T=>{if(T.id===p){const z=typeof b=="function"?b(T):b;return x.replace&&lE(z)?z:{...T,...z}}return T}))};return{getNodes:()=>l.getState().nodes.map(p=>({...p})),getNode:p=>{var b;return(b=f(p))==null?void 0:b.internals.userNode},getInternalNode:f,getEdges:()=>{const{edges:p=[]}=l.getState();return p.map(b=>({...b}))},getEdge:p=>l.getState().edgeLookup.get(p),setNodes:d,setEdges:h,addNodes:p=>{const b=Array.isArray(p)?p:[p];o.nodeQueue.push(x=>[...x,...b])},addEdges:p=>{const b=Array.isArray(p)?p:[p];o.edgeQueue.push(x=>[...x,...b])},toObject:()=>{const{nodes:p=[],edges:b=[],transform:x}=l.getState(),[_,T,z]=x;return{nodes:p.map(A=>({...A})),edges:b.map(A=>({...A})),viewport:{x:_,y:T,zoom:z}}},deleteElements:async({nodes:p=[],edges:b=[]})=>{const{nodes:x,edges:_,onNodesDelete:T,onEdgesDelete:z,triggerNodeChanges:A,triggerEdgeChanges:R,onDelete:S,onBeforeDelete:D}=l.getState(),{nodes:H,edges:j}=await RS({nodesToRemove:p,edgesToRemove:b,nodes:x,edges:_,onBeforeDelete:D}),k=j.length>0,q=H.length>0;if(k){const Z=j.map(cy);z==null||z(j),R(Z)}if(q){const Z=H.map(cy);T==null||T(H),A(Z)}return(q||k)&&(S==null||S({nodes:H,edges:j})),{deletedNodes:H,deletedEdges:j}},getIntersectingNodes:(p,b=!0,x)=>{const _=Hm(p),T=_?p:m(p),z=x!==void 0;return T?(x||l.getState().nodes).filter(A=>{const R=l.getState().nodeLookup.get(A.id);if(R&&!_&&(A.id===p.id||!R.internals.positionAbsolute))return!1;const S=To(z?A:R),D=Ru(S,T);return b&&D>0||D>=S.width*S.height||D>=T.width*T.height}):[]},isNodeIntersecting:(p,b,x=!0)=>{const T=Hm(p)?p:m(p);if(!T)return!1;const z=Ru(T,b);return x&&z>0||z>=b.width*b.height||z>=T.width*T.height},updateNode:g,updateNodeData:(p,b,x={replace:!1})=>{g(p,_=>{const T=typeof b=="function"?b(_):b;return x.replace?{..._,data:T}:{..._,data:{..._.data,...T}}},x)},updateEdge:v,updateEdgeData:(p,b,x={replace:!1})=>{v(p,_=>{const T=typeof b=="function"?b(_):b;return x.replace?{..._,data:T}:{..._,data:{..._.data,...T}}},x)},getNodesBounds:p=>{const{nodeLookup:b,nodeOrigin:x}=l.getState();return zS(p,{nodeLookup:b,nodeOrigin:x})},getHandleConnections:({type:p,id:b,nodeId:x})=>{var _;return Array.from(((_=l.getState().connectionLookup.get(`${x}-${p}${b?`-${b}`:""}`))==null?void 0:_.values())??[])},getNodeConnections:({type:p,handleId:b,nodeId:x})=>{var _;return Array.from(((_=l.getState().connectionLookup.get(`${x}${p?b?`-${p}-${b}`:`-${p}`:""}`))==null?void 0:_.values())??[])},fitView:async p=>{const b=l.getState().fitViewResolver??HS();return l.setState({fitViewQueued:!0,fitViewOptions:p,fitViewResolver:b}),o.nodeQueue.push(x=>[...x]),b.promise}}},[]);return $.useMemo(()=>({...u,...n,viewportInitialized:r}),[r])}const hy=n=>n.selected,sE=typeof window<"u"?window:void 0;function cE({deleteKeyCode:n,multiSelectionKeyCode:l}){const o=$e(),{deleteElements:r}=Lo(),u=Mo(n,{actInsideInputWithModifier:!1}),f=Mo(l,{target:sE});$.useEffect(()=>{if(u){const{edges:d,nodes:h}=o.getState();r({nodes:h.filter(hy),edges:d.filter(hy)}),o.setState({nodesSelectionActive:!1})}},[u]),$.useEffect(()=>{o.setState({multiSelectionActive:f})},[f])}function fE(n){const l=$e();$.useEffect(()=>{const o=()=>{var u,f,d,h;if(!n.current||!(((f=(u=n.current).checkVisibility)==null?void 0:f.call(u))??!0))return!1;const r=pd(n.current);(r.height===0||r.width===0)&&((h=(d=l.getState()).onError)==null||h.call(d,"004",fn.error004())),l.setState({width:r.width||500,height:r.height||500})};if(n.current){o(),window.addEventListener("resize",o);const r=new ResizeObserver(()=>o());return r.observe(n.current),()=>{window.removeEventListener("resize",o),r&&n.current&&r.unobserve(n.current)}}},[])}const Zu={position:"absolute",width:"100%",height:"100%",top:0,left:0},dE=n=>({userSelectionActive:n.userSelectionActive,lib:n.lib,connectionInProgress:n.connection.inProgress});function hE({onPaneContextMenu:n,zoomOnScroll:l=!0,zoomOnPinch:o=!0,panOnScroll:r=!1,panOnScrollSpeed:u=.5,panOnScrollMode:f=el.Free,zoomOnDoubleClick:d=!0,panOnDrag:h=!0,defaultViewport:m,translateExtent:g,minZoom:v,maxZoom:p,zoomActivationKeyCode:b,preventScrolling:x=!0,children:_,noWheelClassName:T,noPanClassName:z,onViewportChange:A,isControlledViewport:R,paneClickDistance:S,selectionOnDrag:D}){const H=$e(),j=$.useRef(null),{userSelectionActive:k,lib:q,connectionInProgress:Z}=je(dE,Ie),ie=Mo(b),J=$.useRef();fE(j);const ne=$.useCallback(P=>{A==null||A({x:P[0],y:P[1],zoom:P[2]}),R||H.setState({transform:P})},[A,R]);return $.useEffect(()=>{if(j.current){J.current=b2({domNode:j.current,minZoom:v,maxZoom:p,translateExtent:g,viewport:m,onDraggingChange:M=>H.setState(B=>B.paneDragging===M?B:{paneDragging:M}),onPanZoomStart:(M,B)=>{const{onViewportChangeStart:X,onMoveStart:Y}=H.getState();Y==null||Y(M,B),X==null||X(B)},onPanZoom:(M,B)=>{const{onViewportChange:X,onMove:Y}=H.getState();Y==null||Y(M,B),X==null||X(B)},onPanZoomEnd:(M,B)=>{const{onViewportChangeEnd:X,onMoveEnd:Y}=H.getState();Y==null||Y(M,B),X==null||X(B)}});const{x:P,y:C,zoom:V}=J.current.getViewport();return H.setState({panZoom:J.current,transform:[P,C,V],domNode:j.current.closest(".react-flow")}),()=>{var M;(M=J.current)==null||M.destroy()}}},[]),$.useEffect(()=>{var P;(P=J.current)==null||P.update({onPaneContextMenu:n,zoomOnScroll:l,zoomOnPinch:o,panOnScroll:r,panOnScrollSpeed:u,panOnScrollMode:f,zoomOnDoubleClick:d,panOnDrag:h,zoomActivationKeyPressed:ie,preventScrolling:x,noPanClassName:z,userSelectionActive:k,noWheelClassName:T,lib:q,onTransformChange:ne,connectionInProgress:Z,selectionOnDrag:D,paneClickDistance:S})},[n,l,o,r,u,f,d,h,ie,x,z,k,T,q,ne,Z,D,S]),N.jsx("div",{className:"react-flow__renderer",ref:j,style:Zu,children:_})}const gE=n=>({userSelectionActive:n.userSelectionActive,userSelectionRect:n.userSelectionRect});function mE(){const{userSelectionActive:n,userSelectionRect:l}=je(gE,Ie);return n&&l?N.jsx("div",{className:"react-flow__selection react-flow__container",style:{width:l.width,height:l.height,transform:`translate(${l.x}px, ${l.y}px)`}}):null}const Mf=(n,l)=>o=>{o.target===l.current&&(n==null||n(o))},yE=n=>({userSelectionActive:n.userSelectionActive,elementsSelectable:n.elementsSelectable,dragging:n.paneDragging,panBy:n.panBy,autoPanSpeed:n.autoPanSpeed});function pE({isSelecting:n,selectionKeyPressed:l,selectionMode:o=No.Full,panOnDrag:r,autoPanOnSelection:u,paneClickDistance:f,selectionOnDrag:d,onSelectionStart:h,onSelectionEnd:m,onPaneClick:g,onPaneContextMenu:v,onPaneScroll:p,onPaneMouseEnter:b,onPaneMouseMove:x,onPaneMouseLeave:_,children:T}){const z=$.useRef(0),A=$e(),{userSelectionActive:R,elementsSelectable:S,dragging:D,panBy:H,autoPanSpeed:j}=je(yE,Ie),k=S&&(n||R),q=$.useRef(null),Z=$.useRef(),ie=$.useRef(new Set),J=$.useRef(new Set),ne=$.useRef(!1),P=$.useRef(!1),C=$.useRef({x:0,y:0}),V=$.useRef(!1),M=ae=>{if(P.current||ne.current||A.getState().connection.inProgress){P.current=!1,ne.current=!1;return}g==null||g(ae),A.getState().resetSelectedElements(),A.setState({nodesSelectionActive:!1})},B=ae=>{if(Array.isArray(r)&&(r!=null&&r.includes(2))){ae.preventDefault();return}v==null||v(ae)},X=p?ae=>p(ae):void 0,Y=ae=>{P.current&&(ae.stopPropagation(),P.current=!1)},U=ae=>{var Ae,Ke;const{domNode:fe,transform:ee}=A.getState();if(Z.current=fe==null?void 0:fe.getBoundingClientRect(),!Z.current)return;const se=ae.target===q.current;if(!se&&!!ae.target.closest(".nokey")||!n||!(d&&se||l)||ae.button!==0||!ae.isPrimary)return;(Ke=(Ae=ae.target)==null?void 0:Ae.setPointerCapture)==null||Ke.call(Ae,ae.pointerId),P.current=!1;const{x:we,y:he}=cn(ae.nativeEvent,Z.current),ye=Bo({x:we,y:he},ee);A.setState({userSelectionRect:{width:0,height:0,startX:ye.x,startY:ye.y,x:we,y:he}}),se||(ae.stopPropagation(),ae.preventDefault())};function E(ae,fe){const{userSelectionRect:ee}=A.getState();if(!ee)return;const{transform:se,nodeLookup:de,edgeLookup:pe,connectionLookup:we,triggerNodeChanges:he,triggerEdgeChanges:ye,defaultEdgeOptions:Ae}=A.getState(),Ke={x:ee.startX,y:ee.startY},{x:ft,y:yt}=ri(Ke,se),kt={startX:Ke.x,startY:Ke.y,x:ae<ft?ae:ft,y:fe<yt?fe:yt,width:Math.abs(ae-ft),height:Math.abs(fe-yt)},za=ie.current,Nn=J.current;ie.current=new Set(gd(de,kt,se,o===No.Partial,!0).map(Rt=>Rt.id)),J.current=new Set;const Fe=(Ae==null?void 0:Ae.selectable)??!0;for(const Rt of ie.current){const Xt=we.get(Rt);if(Xt)for(const{edgeId:Qt}of Xt.values()){const $t=pe.get(Qt);$t&&($t.selectable??Fe)&&J.current.add(Qt)}}if(!Bm(za,ie.current)){const Rt=ei(de,ie.current,!0);he(Rt)}if(!Bm(Nn,J.current)){const Rt=ei(pe,J.current);ye(Rt)}A.setState({userSelectionRect:kt,userSelectionActive:!0,nodesSelectionActive:!1})}function O(){if(!u||!Z.current)return;const[ae,fe]=md(C.current,Z.current,j);H({x:ae,y:fe}).then(ee=>{if(!P.current||!ee){z.current=requestAnimationFrame(O);return}const{x:se,y:de}=C.current;E(se,de),z.current=requestAnimationFrame(O)})}const W=()=>{cancelAnimationFrame(z.current),z.current=0,V.current=!1};$.useEffect(()=>()=>W(),[]);const le=ae=>{const{userSelectionRect:fe,transform:ee,resetSelectedElements:se}=A.getState();if(!Z.current||!fe)return;const{x:de,y:pe}=cn(ae.nativeEvent,Z.current);C.current={x:de,y:pe};const we=ri({x:fe.startX,y:fe.startY},ee);if(!P.current){const he=l?0:f;if(Math.hypot(de-we.x,pe-we.y)<=he)return;se(),h==null||h(ae)}P.current=!0,V.current||(O(),V.current=!0),E(de,pe)},ce=ae=>{var fe,ee;if(!k){ae.target===q.current&&A.getState().connection.inProgress&&(ne.current=!0);return}ae.button===0&&((ee=(fe=ae.target)==null?void 0:fe.releasePointerCapture)==null||ee.call(fe,ae.pointerId),!R&&ae.target===q.current&&A.getState().userSelectionRect&&(M==null||M(ae)),A.setState({userSelectionActive:!1,userSelectionRect:null}),P.current&&(m==null||m(ae),A.setState({nodesSelectionActive:ie.current.size>0})),W())},me=ae=>{var fe,ee;(ee=(fe=ae.target)==null?void 0:fe.releasePointerCapture)==null||ee.call(fe,ae.pointerId),W()},ge=r===!0||Array.isArray(r)&&r.includes(0);return N.jsxs("div",{className:ot(["react-flow__pane",{draggable:ge,dragging:D,selection:n}]),onClick:k?void 0:Mf(M,q),onContextMenu:Mf(B,q),onWheel:Mf(X,q),onPointerEnter:k?void 0:b,onPointerMove:k?le:x,onPointerUp:ce,onPointerCancel:k?me:void 0,onPointerDownCapture:k?U:void 0,onClickCapture:k?Y:void 0,onPointerLeave:_,ref:q,style:Zu,children:[T,N.jsx(mE,{})]})}function Wf({id:n,store:l,unselect:o=!1,nodeRef:r}){const{addSelectedNodes:u,unselectNodesAndEdges:f,multiSelectionActive:d,nodeLookup:h,onError:m}=l.getState(),g=h.get(n);if(!g){m==null||m("012",fn.error012(n));return}l.setState({nodesSelectionActive:!1}),g.selected?(o||g.selected&&d)&&(f({nodes:[g],edges:[]}),requestAnimationFrame(()=>{var v;return(v=r==null?void 0:r.current)==null?void 0:v.blur()})):u([n])}function Wp({nodeRef:n,disabled:l=!1,noDragClassName:o,handleSelector:r,nodeId:u,isSelectable:f,nodeClickDistance:d}){const h=$e(),[m,g]=$.useState(!1),v=$.useRef();return $.useEffect(()=>{if(!l)return v.current=i2({getStoreItems:()=>h.getState(),onNodeMouseDown:p=>{Wf({id:p,store:h,nodeRef:n})},onDragStart:()=>{g(!0)},onDragStop:()=>{g(!1)}}),()=>{var p;(p=v.current)==null||p.destroy(),v.current=void 0}},[l,h,n]),$.useEffect(()=>{l||!n.current||!v.current||v.current.update({noDragClassName:o,handleSelector:r,domNode:n.current,isSelectable:f,nodeId:u,nodeClickDistance:d})},[o,r,l,f,n,u,d]),m}const vE=n=>l=>l.selected&&(l.draggable||n&&typeof l.draggable>"u");function Fp(){const n=$e();return $.useCallback(o=>{const{nodeExtent:r,snapToGrid:u,snapGrid:f,nodesDraggable:d,onError:h,updateNodePositions:m,nodeLookup:g,nodeOrigin:v}=n.getState(),p=new Map,b=vE(d),x=u?f[0]:5,_=u?f[1]:5,T=o.direction.x*x*o.factor,z=o.direction.y*_*o.factor;for(const[,A]of g){if(!b(A))continue;let R={x:A.internals.positionAbsolute.x+T,y:A.internals.positionAbsolute.y+z};u&&(R=Ho(R,f));const{position:S,positionAbsolute:D}=vp({nodeId:A.id,nextPosition:R,nodeLookup:g,nodeExtent:r,nodeOrigin:v,onError:h});A.position=S,A.internals.positionAbsolute=D,p.set(A.id,A)}m(p)},[])}const Nd=$.createContext(null),bE=Nd.Provider;Nd.Consumer;const Pp=()=>$.useContext(Nd),xE=n=>({connectOnClick:n.connectOnClick,noPanClassName:n.noPanClassName,rfId:n.rfId}),ev=$.createContext(null);function _E({children:n}){const l=je(xE,Ie);return N.jsx(ev.Provider,{value:l,children:n})}function wE(){const n=$.useContext(ev);if(!n)throw new Error("useHandleConfig must be used within a HandleConfigProvider");return n}const SE={connectingFrom:!1,connectingTo:!1,clickConnecting:!1,isPossibleEndHandle:!0,connectionInProcess:!1,clickConnectionInProcess:!1,valid:!1},EE=(n,l,o)=>r=>{const{connectionClickStartHandle:u,connectionMode:f,connection:d}=r,{fromHandle:h,toHandle:m,isValid:g}=d;if(!h&&!u)return SE;const v=(m==null?void 0:m.nodeId)===n&&(m==null?void 0:m.id)===l&&(m==null?void 0:m.type)===o;return{connectingFrom:(h==null?void 0:h.nodeId)===n&&(h==null?void 0:h.id)===l&&(h==null?void 0:h.type)===o,connectingTo:v,clickConnecting:(u==null?void 0:u.nodeId)===n&&(u==null?void 0:u.id)===l&&(u==null?void 0:u.type)===o,isPossibleEndHandle:f===ii.Strict?(h==null?void 0:h.type)!==o:n!==(h==null?void 0:h.nodeId)||l!==(h==null?void 0:h.id),connectionInProcess:!!h,clickConnectionInProcess:!!u,valid:v&&g}};function NE({type:n="source",position:l=xe.Top,isValidConnection:o,isConnectable:r=!0,isConnectableStart:u=!0,isConnectableEnd:f=!0,id:d,onConnect:h,children:m,className:g,onMouseDown:v,onTouchStart:p,...b},x){var V,M;const _=d||null,T=n==="target",z=$e(),A=Pp(),{connectOnClick:R,noPanClassName:S,rfId:D}=wE(),{connectingFrom:H,connectingTo:j,clickConnecting:k,isPossibleEndHandle:q,connectionInProcess:Z,clickConnectionInProcess:ie,valid:J}=je(EE(A,_,n),Ie);A||(M=(V=z.getState()).onError)==null||M.call(V,"010",fn.error010());const ne=B=>{const{defaultEdgeOptions:X,onConnect:Y,hasDefaultEdges:U}=z.getState(),E={...X,...B};if(U){const{edges:O,setEdges:W,onError:le}=z.getState();W(Jf(E,O,{onError:le}))}Y==null||Y(E),h==null||h(E)},P=B=>{if(!A)return;const X=Ap(B.nativeEvent);if(u&&(X&&B.button===0||!X)){const Y=z.getState();Zf.onPointerDown(B.nativeEvent,{handleDomNode:B.currentTarget,autoPanOnConnect:Y.autoPanOnConnect,connectionMode:Y.connectionMode,connectionRadius:Y.connectionRadius,domNode:Y.domNode,nodeLookup:Y.nodeLookup,lib:Y.lib,isTarget:T,handleId:_,nodeId:A,flowId:Y.rfId,panBy:Y.panBy,cancelConnection:Y.cancelConnection,onConnectStart:Y.onConnectStart,onConnectEnd:(...U)=>{var E,O;return(O=(E=z.getState()).onConnectEnd)==null?void 0:O.call(E,...U)},updateConnection:Y.updateConnection,onConnect:ne,isValidConnection:o||((...U)=>{var E,O;return((O=(E=z.getState()).isValidConnection)==null?void 0:O.call(E,...U))??!0}),getTransform:()=>z.getState().transform,getFromHandle:()=>z.getState().connection.fromHandle,autoPanSpeed:Y.autoPanSpeed,dragThreshold:Y.connectionDragThreshold})}X?v==null||v(B):p==null||p(B)},C=B=>{const{onClickConnectStart:X,onClickConnectEnd:Y,connectionClickStartHandle:U,connectionMode:E,isValidConnection:O,lib:W,rfId:le,nodeLookup:ce,connection:me}=z.getState();if(!A||!U&&!u)return;if(!U){X==null||X(B.nativeEvent,{nodeId:A,handleId:_,handleType:n}),z.setState({connectionClickStartHandle:{nodeId:A,type:n,id:_}});return}const ge=Np(B.target),ae=o||O,{connection:fe,isValid:ee}=Zf.isValid(B.nativeEvent,{handle:{nodeId:A,id:_,type:n},connectionMode:E,fromNodeId:U.nodeId,fromHandleId:U.id||null,fromType:U.type,isValidConnection:ae,flowId:le,doc:ge,lib:W,nodeLookup:ce});ee&&fe&&ne(fe);const se=structuredClone(me);delete se.inProgress,se.toPosition=se.toHandle?se.toHandle.position:null,Y==null||Y(B,se),z.setState({connectionClickStartHandle:null})};return N.jsx("div",{"data-handleid":_,"data-nodeid":A,"data-handlepos":l,"data-id":`${D}-${A}-${_}-${n}`,className:ot(["react-flow__handle",`react-flow__handle-${l}`,"nodrag",S,g,{source:!T,target:T,connectable:r,connectablestart:u,connectableend:f,clickconnecting:k,connectingfrom:H,connectingto:j,valid:J,connectionindicator:r&&(!Z||q)&&(Z||ie?f:u)}]),onMouseDown:P,onTouchStart:P,onClick:R?C:void 0,ref:x,...b,children:m})}const si=$.memo(Kp(NE));function TE({data:n,isConnectable:l,sourcePosition:o=xe.Bottom}){return N.jsxs(N.Fragment,{children:[n==null?void 0:n.label,N.jsx(si,{type:"source",position:o,isConnectable:l})]})}function AE({data:n,isConnectable:l,targetPosition:o=xe.Top,sourcePosition:r=xe.Bottom}){return N.jsxs(N.Fragment,{children:[N.jsx(si,{type:"target",position:o,isConnectable:l}),n==null?void 0:n.label,N.jsx(si,{type:"source",position:r,isConnectable:l})]})}function ME(){return null}function zE({data:n,isConnectable:l,targetPosition:o=xe.Top}){return N.jsxs(N.Fragment,{children:[N.jsx(si,{type:"target",position:o,isConnectable:l}),n==null?void 0:n.label]})}const ju={ArrowUp:{x:0,y:-1},ArrowDown:{x:0,y:1},ArrowLeft:{x:-1,y:0},ArrowRight:{x:1,y:0}},gy={input:TE,default:AE,output:zE,group:ME};function CE(n){var l,o,r,u;return n.internals.handleBounds===void 0?{width:n.width??n.initialWidth??((l=n.style)==null?void 0:l.width),height:n.height??n.initialHeight??((o=n.style)==null?void 0:o.height)}:{width:n.width??((r=n.style)==null?void 0:r.width),height:n.height??((u=n.style)==null?void 0:u.height)}}const DE=n=>{const{width:l,height:o,x:r,y:u}=Oo(n.nodeLookup,{filter:f=>!!f.selected});return{width:sn(l)?l:null,height:sn(o)?o:null,userSelectionActive:n.userSelectionActive,transformString:`translate(${n.transform[0]}px,${n.transform[1]}px) scale(${n.transform[2]}) translate(${r}px,${u}px)`}};function kE({onSelectionContextMenu:n,noPanClassName:l,disableKeyboardA11y:o}){const r=$e(),{width:u,height:f,transformString:d,userSelectionActive:h}=je(DE,Ie),m=Fp(),g=$.useRef(null);$.useEffect(()=>{var x;o||(x=g.current)==null||x.focus({preventScroll:!0})},[o]);const v=!h&&u!==null&&f!==null;if(Wp({nodeRef:g,disabled:!v}),!v)return null;const p=n?x=>{const _=r.getState().nodes.filter(T=>T.selected);n(x,_)}:void 0,b=x=>{Object.prototype.hasOwnProperty.call(ju,x.key)&&(x.preventDefault(),m({direction:ju[x.key],factor:x.shiftKey?4:1}))};return N.jsx("div",{className:ot(["react-flow__nodesselection","react-flow__container",l]),style:{transform:d},children:N.jsx("div",{ref:g,className:"react-flow__nodesselection-rect",onContextMenu:p,tabIndex:o?void 0:-1,onKeyDown:o?void 0:b,style:{width:u,height:f}})})}const my=typeof window<"u"?window:void 0,RE=n=>({nodesSelectionActive:n.nodesSelectionActive,userSelectionActive:n.userSelectionActive});function tv({children:n,onPaneClick:l,onPaneMouseEnter:o,onPaneMouseMove:r,onPaneMouseLeave:u,onPaneContextMenu:f,onPaneScroll:d,paneClickDistance:h,deleteKeyCode:m,selectionKeyCode:g,selectionOnDrag:v,selectionMode:p,onSelectionStart:b,onSelectionEnd:x,multiSelectionKeyCode:_,panActivationKeyCode:T,zoomActivationKeyCode:z,elementsSelectable:A,zoomOnScroll:R,zoomOnPinch:S,panOnScroll:D,panOnScrollSpeed:H,panOnScrollMode:j,zoomOnDoubleClick:k,panOnDrag:q,autoPanOnSelection:Z,defaultViewport:ie,translateExtent:J,minZoom:ne,maxZoom:P,preventScrolling:C,onSelectionContextMenu:V,noWheelClassName:M,noPanClassName:B,disableKeyboardA11y:X,onViewportChange:Y,isControlledViewport:U}){const{nodesSelectionActive:E,userSelectionActive:O}=je(RE,Ie),W=Mo(g,{target:my}),le=Mo(T,{target:my}),ce=le||q,me=le||D,ge=v&&ce!==!0,ae=W||O||ge;return cE({deleteKeyCode:m,multiSelectionKeyCode:_}),N.jsx(hE,{onPaneContextMenu:f,elementsSelectable:A,zoomOnScroll:R,zoomOnPinch:S,panOnScroll:me,panOnScrollSpeed:H,panOnScrollMode:j,zoomOnDoubleClick:k,panOnDrag:!W&&ce,defaultViewport:ie,translateExtent:J,minZoom:ne,maxZoom:P,zoomActivationKeyCode:z,preventScrolling:C,noWheelClassName:M,noPanClassName:B,onViewportChange:Y,isControlledViewport:U,paneClickDistance:h,selectionOnDrag:ge,children:N.jsxs(pE,{onSelectionStart:b,onSelectionEnd:x,onPaneClick:l,onPaneMouseEnter:o,onPaneMouseMove:r,onPaneMouseLeave:u,onPaneContextMenu:f,onPaneScroll:d,panOnDrag:ce,autoPanOnSelection:Z,isSelecting:!!ae,selectionMode:p,selectionKeyPressed:W,paneClickDistance:h,selectionOnDrag:ge,children:[n,E&&N.jsx(kE,{onSelectionContextMenu:V,noPanClassName:B,disableKeyboardA11y:X})]})})}tv.displayName="FlowRenderer";const jE=$.memo(tv),OE=n=>l=>n?gd(l.nodeLookup,{x:0,y:0,width:l.width,height:l.height},l.transform,!0).map(o=>o.id):Array.from(l.nodeLookup.keys());function HE(n){return je($.useCallback(OE(n),[n]),Ie)}const BE=n=>n.updateNodeInternals;function LE(){const n=je(BE),[l]=$.useState(()=>typeof ResizeObserver>"u"?null:new ResizeObserver(o=>{const r=new Map;o.forEach(u=>{const f=u.target.getAttribute("data-id");r.set(f,{id:f,nodeElement:u.target,force:!0})}),n(r)}));return $.useEffect(()=>()=>{l==null||l.disconnect()},[l]),l}function UE({node:n,nodeType:l,hasDimensions:o,resizeObserver:r}){const u=$e(),f=$.useRef(null),d=$.useRef(null),h=$.useRef(n.sourcePosition),m=$.useRef(n.targetPosition),g=$.useRef(l),v=o&&!!n.internals.handleBounds;return $.useEffect(()=>{f.current&&!n.hidden&&(!v||d.current!==f.current)&&(d.current&&(r==null||r.unobserve(d.current)),r==null||r.observe(f.current),d.current=f.current)},[v,n.hidden]),$.useEffect(()=>()=>{d.current&&(r==null||r.unobserve(d.current),d.current=null)},[]),$.useEffect(()=>{if(f.current){const p=g.current!==l,b=h.current!==n.sourcePosition,x=m.current!==n.targetPosition;(p||b||x)&&(g.current=l,h.current=n.sourcePosition,m.current=n.targetPosition,u.getState().updateNodeInternals(new Map([[n.id,{id:n.id,nodeElement:f.current,force:!0}]])))}},[n.id,l,n.sourcePosition,n.targetPosition]),f}function GE({id:n,onClick:l,onMouseEnter:o,onMouseMove:r,onMouseLeave:u,onContextMenu:f,onDoubleClick:d,nodesDraggable:h,elementsSelectable:m,nodesConnectable:g,nodesFocusable:v,resizeObserver:p,noDragClassName:b,noPanClassName:x,disableKeyboardA11y:_,rfId:T,nodeTypes:z,nodeClickDistance:A,onError:R}){const{node:S,internals:D,isParent:H}=je(ae=>{const fe=ae.nodeLookup.get(n),ee=ae.parentLookup.has(n);return{node:fe,internals:fe.internals,isParent:ee}},Ie);let j=S.type||"default",k=(z==null?void 0:z[j])||gy[j];k===void 0&&(R==null||R("003",fn.error003(j)),j="default",k=(z==null?void 0:z.default)||gy.default);const q=!!(S.draggable||h&&typeof S.draggable>"u"),Z=!!(S.selectable||m&&typeof S.selectable>"u"),ie=!!(S.connectable||g&&typeof S.connectable>"u"),J=!!(S.focusable||v&&typeof S.focusable>"u"),ne=$e(),P=Sp(S),C=UE({node:S,nodeType:j,hasDimensions:P,resizeObserver:p}),V=Wp({nodeRef:C,disabled:S.hidden||!q,noDragClassName:b,handleSelector:S.dragHandle,nodeId:n,isSelectable:Z,nodeClickDistance:A}),M=Fp();if(S.hidden)return null;const B=En(S),X=CE(S),Y=Z||q||l||o||r||u,U=o?ae=>o(ae,{...D.userNode}):void 0,E=r?ae=>r(ae,{...D.userNode}):void 0,O=u?ae=>u(ae,{...D.userNode}):void 0,W=f?ae=>f(ae,{...D.userNode}):void 0,le=d?ae=>d(ae,{...D.userNode}):void 0,ce=ae=>{const{selectNodesOnDrag:fe,nodeDragThreshold:ee}=ne.getState();Z&&(!fe||!q||ee>0)&&Wf({id:n,store:ne,nodeRef:C}),l&&l(ae,{...D.userNode})},me=ae=>{if(!(Tp(ae.nativeEvent)||_)){if(hp.includes(ae.key)&&Z){const fe=ae.key==="Escape";Wf({id:n,store:ne,unselect:fe,nodeRef:C})}else if(q&&S.selected&&Object.prototype.hasOwnProperty.call(ju,ae.key)){ae.preventDefault();const{ariaLabelConfig:fe}=ne.getState();ne.setState({ariaLiveMessage:fe["node.a11yDescription.ariaLiveMessage"]({direction:ae.key.replace("Arrow","").toLowerCase(),x:~~D.positionAbsolute.x,y:~~D.positionAbsolute.y})}),M({direction:ju[ae.key],factor:ae.shiftKey?4:1})}}},ge=()=>{var we;if(_||!((we=C.current)!=null&&we.matches(":focus-visible")))return;const{transform:ae,width:fe,height:ee,autoPanOnNodeFocus:se,setCenter:de}=ne.getState();if(!se)return;gd(new Map([[n,S]]),{x:0,y:0,width:fe,height:ee},ae,!0).length>0||de(S.position.x+B.width/2,S.position.y+B.height/2,{zoom:ae[2]})};return N.jsx("div",{className:ot(["react-flow__node",`react-flow__node-${j}`,{[x]:q},S.className,{selected:S.selected,selectable:Z,parent:H,draggable:q,dragging:V}]),ref:C,style:{zIndex:D.z,transform:`translate(${D.positionAbsolute.x}px,${D.positionAbsolute.y}px)`,pointerEvents:Y?"all":"none",visibility:P?"visible":"hidden",...S.style,...X},"data-id":n,"data-testid":`rf__node-${n}`,onMouseEnter:U,onMouseMove:E,onMouseLeave:O,onContextMenu:W,onClick:ce,onDoubleClick:le,onKeyDown:J?me:void 0,tabIndex:J?0:void 0,onFocus:J?ge:void 0,role:S.ariaRole??(J?"group":void 0),"aria-roledescription":"node","aria-describedby":_?void 0:`${Xp}-${T}`,"aria-label":S.ariaLabel,...S.domAttributes,children:N.jsx(bE,{value:n,children:N.jsx(k,{id:n,data:S.data,type:j,positionAbsoluteX:D.positionAbsolute.x,positionAbsoluteY:D.positionAbsolute.y,selected:S.selected??!1,selectable:Z,draggable:q,deletable:S.deletable??!0,isConnectable:ie,sourcePosition:S.sourcePosition,targetPosition:S.targetPosition,dragging:V,dragHandle:S.dragHandle,zIndex:D.z,parentId:S.parentId,...B})})})}var qE=$.memo(GE);const YE=n=>({nodesConnectable:n.nodesConnectable,nodesFocusable:n.nodesFocusable,elementsSelectable:n.elementsSelectable,onError:n.onError});function nv(n){const{nodesConnectable:l,nodesFocusable:o,elementsSelectable:r,onError:u}=je(YE,Ie),f=HE(n.onlyRenderVisibleElements),d=LE();return N.jsx("div",{className:"react-flow__nodes",style:Zu,children:f.map(h=>N.jsx(qE,{id:h,nodeTypes:n.nodeTypes,nodeExtent:n.nodeExtent,onClick:n.onNodeClick,onMouseEnter:n.onNodeMouseEnter,onMouseMove:n.onNodeMouseMove,onMouseLeave:n.onNodeMouseLeave,onContextMenu:n.onNodeContextMenu,onDoubleClick:n.onNodeDoubleClick,noDragClassName:n.noDragClassName,noPanClassName:n.noPanClassName,rfId:n.rfId,disableKeyboardA11y:n.disableKeyboardA11y,resizeObserver:d,nodesDraggable:n.nodesDraggable??!0,nodesConnectable:l,nodesFocusable:o,elementsSelectable:r,nodeClickDistance:n.nodeClickDistance,onError:u},h))})}nv.displayName="NodeRenderer";const VE=$.memo(nv);function XE(n){return je($.useCallback(o=>{if(!n)return o.edges.map(u=>u.id);const r=[];if(o.width&&o.height)for(const u of o.edges){const f=o.nodeLookup.get(u.source),d=o.nodeLookup.get(u.target);f&&d&&GS({sourceNode:f,targetNode:d,width:o.width,height:o.height,transform:o.transform})&&r.push(u.id)}return r},[n]),Ie)}const QE=({color:n="none",strokeWidth:l=1})=>{const o={strokeWidth:l,...n&&{stroke:n}};return N.jsx("polyline",{className:"arrow",style:o,strokeLinecap:"round",fill:"none",strokeLinejoin:"round",points:"-5,-4 0,0 -5,4"})},$E=({color:n="none",strokeWidth:l=1})=>{const o={strokeWidth:l,...n&&{stroke:n,fill:n}};return N.jsx("polyline",{className:"arrowclosed",style:o,strokeLinecap:"round",strokeLinejoin:"round",points:"-5,-4 0,0 -5,4 -5,-4"})},yy={[Du.Arrow]:QE,[Du.ArrowClosed]:$E};function ZE(n){const l=$e();return $.useMemo(()=>{var u,f;return Object.prototype.hasOwnProperty.call(yy,n)?yy[n]:((f=(u=l.getState()).onError)==null||f.call(u,"009",fn.error009(n)),null)},[n])}const KE=({id:n,type:l,color:o,width:r=12.5,height:u=12.5,markerUnits:f="strokeWidth",strokeWidth:d,orient:h="auto-start-reverse"})=>{const m=ZE(l);return m?N.jsx("marker",{className:"react-flow__arrowhead",id:n,markerWidth:`${r}`,markerHeight:`${u}`,viewBox:"-10 -10 20 20",markerUnits:f,orient:h,refX:"0",refY:"0",children:N.jsx(m,{color:o,strokeWidth:d})}):null},av=({defaultColor:n,rfId:l})=>{const o=je(f=>f.edges),r=je(f=>f.defaultEdgeOptions),u=$.useMemo(()=>KS(o,{id:l,defaultColor:n,defaultMarkerStart:r==null?void 0:r.markerStart,defaultMarkerEnd:r==null?void 0:r.markerEnd}),[o,r,l,n]);return u.length?N.jsx("svg",{className:"react-flow__marker","aria-hidden":"true",children:N.jsx("defs",{children:u.map(f=>N.jsx(KE,{id:f.id,type:f.type,color:f.color,width:f.width,height:f.height,markerUnits:f.markerUnits,strokeWidth:f.strokeWidth,orient:f.orient},f.id))})}):null};av.displayName="MarkerDefinitions";var IE=$.memo(av);function lv({x:n,y:l,label:o,labelStyle:r,labelShowBg:u=!0,labelBgStyle:f,labelBgPadding:d=[2,4],labelBgBorderRadius:h=2,children:m,className:g,...v}){const[p,b]=$.useState({x:1,y:0,width:0,height:0}),x=ot(["react-flow__edge-textwrapper",g]),_=$.useRef(null);return $.useEffect(()=>{if(_.current){const T=_.current.getBBox();b({x:T.x,y:T.y,width:T.width,height:T.height})}},[o]),o?N.jsxs("g",{transform:`translate(${n-p.width/2} ${l-p.height/2})`,className:x,visibility:p.width?"visible":"hidden",...v,children:[u&&N.jsx("rect",{width:p.width+2*d[0],x:-d[0],y:-d[1],height:p.height+2*d[1],className:"react-flow__edge-textbg",style:f,rx:h,ry:h}),N.jsx("text",{className:"react-flow__edge-text",y:p.height/2,dy:"0.3em",ref:_,style:r,children:o}),m]}):null}lv.displayName="EdgeText";const JE=$.memo(lv);function Uo({path:n,labelX:l,labelY:o,label:r,labelStyle:u,labelShowBg:f,labelBgStyle:d,labelBgPadding:h,labelBgBorderRadius:m,interactionWidth:g=20,...v}){return N.jsxs(N.Fragment,{children:[N.jsx("path",{...v,d:n,fill:"none",className:ot(["react-flow__edge-path",v.className])}),g?N.jsx("path",{d:n,fill:"none",strokeOpacity:0,strokeWidth:g,className:"react-flow__edge-interaction"}):null,r&&sn(l)&&sn(o)?N.jsx(JE,{x:l,y:o,label:r,labelStyle:u,labelShowBg:f,labelBgStyle:d,labelBgPadding:h,labelBgBorderRadius:m}):null]})}function py({pos:n,x1:l,y1:o,x2:r,y2:u}){return n===xe.Left||n===xe.Right?[.5*(l+r),o]:[l,.5*(o+u)]}function iv({sourceX:n,sourceY:l,sourcePosition:o=xe.Bottom,targetX:r,targetY:u,targetPosition:f=xe.Top}){const[d,h]=py({pos:o,x1:n,y1:l,x2:r,y2:u}),[m,g]=py({pos:f,x1:r,y1:u,x2:n,y2:l}),[v,p,b,x]=Mp({sourceX:n,sourceY:l,targetX:r,targetY:u,sourceControlX:d,sourceControlY:h,targetControlX:m,targetControlY:g});return[`M${n},${l} C${d},${h} ${m},${g} ${r},${u}`,v,p,b,x]}function ov(n){return $.memo(({id:l,sourceX:o,sourceY:r,targetX:u,targetY:f,sourcePosition:d,targetPosition:h,label:m,labelStyle:g,labelShowBg:v,labelBgStyle:p,labelBgPadding:b,labelBgBorderRadius:x,style:_,markerEnd:T,markerStart:z,interactionWidth:A})=>{const[R,S,D]=iv({sourceX:o,sourceY:r,sourcePosition:d,targetX:u,targetY:f,targetPosition:h}),H=n.isInternal?void 0:l;return N.jsx(Uo,{id:H,path:R,labelX:S,labelY:D,label:m,labelStyle:g,labelShowBg:v,labelBgStyle:p,labelBgPadding:b,labelBgBorderRadius:x,style:_,markerEnd:T,markerStart:z,interactionWidth:A})})}const WE=ov({isInternal:!1}),rv=ov({isInternal:!0});WE.displayName="SimpleBezierEdge";rv.displayName="SimpleBezierEdgeInternal";function uv(n){return $.memo(({id:l,sourceX:o,sourceY:r,targetX:u,targetY:f,label:d,labelStyle:h,labelShowBg:m,labelBgStyle:g,labelBgPadding:v,labelBgBorderRadius:p,style:b,sourcePosition:x=xe.Bottom,targetPosition:_=xe.Top,markerEnd:T,markerStart:z,pathOptions:A,interactionWidth:R})=>{const[S,D,H]=Xf({sourceX:o,sourceY:r,sourcePosition:x,targetX:u,targetY:f,targetPosition:_,borderRadius:A==null?void 0:A.borderRadius,offset:A==null?void 0:A.offset,stepPosition:A==null?void 0:A.stepPosition}),j=n.isInternal?void 0:l;return N.jsx(Uo,{id:j,path:S,labelX:D,labelY:H,label:d,labelStyle:h,labelShowBg:m,labelBgStyle:g,labelBgPadding:v,labelBgBorderRadius:p,style:b,markerEnd:T,markerStart:z,interactionWidth:R})})}const sv=uv({isInternal:!1}),cv=uv({isInternal:!0});sv.displayName="SmoothStepEdge";cv.displayName="SmoothStepEdgeInternal";function fv(n){return $.memo(({id:l,...o})=>{var u;const r=n.isInternal?void 0:l;return N.jsx(sv,{...o,id:r,pathOptions:$.useMemo(()=>{var f;return{borderRadius:0,offset:(f=o.pathOptions)==null?void 0:f.offset}},[(u=o.pathOptions)==null?void 0:u.offset])})})}const FE=fv({isInternal:!1}),dv=fv({isInternal:!0});FE.displayName="StepEdge";dv.displayName="StepEdgeInternal";function hv(n){return $.memo(({id:l,sourceX:o,sourceY:r,targetX:u,targetY:f,label:d,labelStyle:h,labelShowBg:m,labelBgStyle:g,labelBgPadding:v,labelBgBorderRadius:p,style:b,markerEnd:x,markerStart:_,interactionWidth:T})=>{const[z,A,R]=Cp({sourceX:o,sourceY:r,targetX:u,targetY:f}),S=n.isInternal?void 0:l;return N.jsx(Uo,{id:S,path:z,labelX:A,labelY:R,label:d,labelStyle:h,labelShowBg:m,labelBgStyle:g,labelBgPadding:v,labelBgBorderRadius:p,style:b,markerEnd:x,markerStart:_,interactionWidth:T})})}const PE=hv({isInternal:!1}),gv=hv({isInternal:!0});PE.displayName="StraightEdge";gv.displayName="StraightEdgeInternal";function mv(n){return $.memo(({id:l,sourceX:o,sourceY:r,targetX:u,targetY:f,sourcePosition:d=xe.Bottom,targetPosition:h=xe.Top,label:m,labelStyle:g,labelShowBg:v,labelBgStyle:p,labelBgPadding:b,labelBgBorderRadius:x,style:_,markerEnd:T,markerStart:z,pathOptions:A,interactionWidth:R})=>{const[S,D,H]=vd({sourceX:o,sourceY:r,sourcePosition:d,targetX:u,targetY:f,targetPosition:h,curvature:A==null?void 0:A.curvature}),j=n.isInternal?void 0:l;return N.jsx(Uo,{id:j,path:S,labelX:D,labelY:H,label:m,labelStyle:g,labelShowBg:v,labelBgStyle:p,labelBgPadding:b,labelBgBorderRadius:x,style:_,markerEnd:T,markerStart:z,interactionWidth:R})})}const e3=mv({isInternal:!1}),yv=mv({isInternal:!0});e3.displayName="BezierEdge";yv.displayName="BezierEdgeInternal";const vy={default:yv,straight:gv,step:dv,smoothstep:cv,simplebezier:rv},by={sourceX:null,sourceY:null,targetX:null,targetY:null,sourcePosition:null,targetPosition:null,zIndex:void 0},t3=(n,l,o)=>o===xe.Left?n-l:o===xe.Right?n+l:n,n3=(n,l,o)=>o===xe.Top?n-l:o===xe.Bottom?n+l:n,xy="react-flow__edgeupdater";function _y({position:n,centerX:l,centerY:o,radius:r=10,onMouseDown:u,onMouseEnter:f,onMouseOut:d,type:h}){return N.jsx("circle",{onMouseDown:u,onMouseEnter:f,onMouseOut:d,className:ot([xy,`${xy}-${h}`]),cx:t3(l,r,n),cy:n3(o,r,n),r,stroke:"transparent",fill:"transparent"})}function a3({isReconnectable:n,reconnectRadius:l,edge:o,sourceX:r,sourceY:u,targetX:f,targetY:d,sourcePosition:h,targetPosition:m,onReconnect:g,onReconnectStart:v,onReconnectEnd:p,setReconnecting:b,setUpdateHover:x}){const _=$e(),T=(D,H)=>{if(D.button!==0)return;const{autoPanOnConnect:j,domNode:k,connectionMode:q,connectionRadius:Z,lib:ie,onConnectStart:J,cancelConnection:ne,nodeLookup:P,rfId:C,panBy:V,updateConnection:M}=_.getState(),B=H.type==="target",X=(E,O)=>{b(!1),p==null||p(E,o,H.type,O)},Y=E=>g==null?void 0:g(o,E),U=(E,O)=>{b(!0),v==null||v(D,o,H.type),J==null||J(E,O)};Zf.onPointerDown(D.nativeEvent,{autoPanOnConnect:j,connectionMode:q,connectionRadius:Z,domNode:k,handleId:H.id,nodeId:H.nodeId,nodeLookup:P,isTarget:B,edgeUpdaterType:H.type,lib:ie,flowId:C,cancelConnection:ne,panBy:V,isValidConnection:(...E)=>{var O,W;return((W=(O=_.getState()).isValidConnection)==null?void 0:W.call(O,...E))??!0},onConnect:Y,onConnectStart:U,onConnectEnd:(...E)=>{var O,W;return(W=(O=_.getState()).onConnectEnd)==null?void 0:W.call(O,...E)},onReconnectEnd:X,updateConnection:M,getTransform:()=>_.getState().transform,getFromHandle:()=>_.getState().connection.fromHandle,dragThreshold:_.getState().connectionDragThreshold,handleDomNode:D.currentTarget})},z=D=>T(D,{nodeId:o.target,id:o.targetHandle??null,type:"target"}),A=D=>T(D,{nodeId:o.source,id:o.sourceHandle??null,type:"source"}),R=()=>x(!0),S=()=>x(!1);return N.jsxs(N.Fragment,{children:[(n===!0||n==="source")&&N.jsx(_y,{position:h,centerX:r,centerY:u,radius:l,onMouseDown:z,onMouseEnter:R,onMouseOut:S,type:"source"}),(n===!0||n==="target")&&N.jsx(_y,{position:m,centerX:f,centerY:d,radius:l,onMouseDown:A,onMouseEnter:R,onMouseOut:S,type:"target"})]})}function l3({id:n,edgesFocusable:l,edgesReconnectable:o,elementsSelectable:r,onClick:u,onDoubleClick:f,onContextMenu:d,onMouseEnter:h,onMouseMove:m,onMouseLeave:g,reconnectRadius:v,onReconnect:p,onReconnectStart:b,onReconnectEnd:x,rfId:_,edgeTypes:T,noPanClassName:z,onError:A,disableKeyboardA11y:R}){let S=je(de=>de.edgeLookup.get(n));const D=je(de=>de.defaultEdgeOptions);S=D?{...D,...S}:S;let H=S.type||"default",j=(T==null?void 0:T[H])||vy[H];j===void 0&&(A==null||A("011",fn.error011(H)),H="default",j=(T==null?void 0:T.default)||vy.default);const k=!!(S.focusable||l&&typeof S.focusable>"u"),q=typeof p<"u"&&(S.reconnectable||o&&typeof S.reconnectable>"u"),Z=!!(S.selectable||r&&typeof S.selectable>"u"),ie=$.useRef(null),[J,ne]=$.useState(!1),[P,C]=$.useState(!1),V=$e(),{zIndex:M=S.zIndex,sourceX:B,sourceY:X,targetX:Y,targetY:U,sourcePosition:E,targetPosition:O}=je($.useCallback(de=>{const pe=de.nodeLookup.get(S.source),we=de.nodeLookup.get(S.target);if(!pe||!we)return by;const he=ZS({id:n,sourceNode:pe,targetNode:we,sourceHandle:S.sourceHandle||null,targetHandle:S.targetHandle||null,connectionMode:de.connectionMode,onError:A}),ye=US({selected:S.selected,zIndex:S.zIndex,sourceNode:pe,targetNode:we,elevateOnSelect:de.elevateEdgesOnSelect,zIndexMode:de.zIndexMode});return{...he||by,zIndex:ye}},[S.source,S.target,S.sourceHandle,S.targetHandle,S.selected,S.zIndex]),Ie),W=$.useMemo(()=>S.markerStart?`url('#${Qf(S.markerStart,_)}')`:void 0,[S.markerStart,_]),le=$.useMemo(()=>S.markerEnd?`url('#${Qf(S.markerEnd,_)}')`:void 0,[S.markerEnd,_]);if(S.hidden||B===null||X===null||Y===null||U===null)return null;const ce=de=>{var ye;const{addSelectedEdges:pe,unselectNodesAndEdges:we,multiSelectionActive:he}=V.getState();Z&&(V.setState({nodesSelectionActive:!1}),S.selected&&he?(we({nodes:[],edges:[S]}),(ye=ie.current)==null||ye.blur()):pe([n])),u&&u(de,S)},me=f?de=>{f(de,{...S})}:void 0,ge=d?de=>{d(de,{...S})}:void 0,ae=h?de=>{h(de,{...S})}:void 0,fe=m?de=>{m(de,{...S})}:void 0,ee=g?de=>{g(de,{...S})}:void 0,se=de=>{var pe;if(!R&&hp.includes(de.key)&&Z){const{unselectNodesAndEdges:we,addSelectedEdges:he}=V.getState();de.key==="Escape"?((pe=ie.current)==null||pe.blur(),we({edges:[S]})):he([n])}};return N.jsx("svg",{style:{zIndex:M},children:N.jsxs("g",{className:ot(["react-flow__edge",`react-flow__edge-${H}`,S.className,z,{selected:S.selected,animated:S.animated,inactive:!Z&&!u,updating:J,selectable:Z}]),onClick:ce,onDoubleClick:me,onContextMenu:ge,onMouseEnter:ae,onMouseMove:fe,onMouseLeave:ee,onKeyDown:k?se:void 0,tabIndex:k?0:void 0,role:S.ariaRole??(k?"group":"img"),"aria-roledescription":"edge","data-id":n,"data-testid":`rf__edge-${n}`,"aria-label":S.ariaLabel===null?void 0:S.ariaLabel||`Edge from ${S.source} to ${S.target}`,"aria-describedby":k?`${Qp}-${_}`:void 0,ref:ie,...S.domAttributes,children:[!P&&N.jsx(j,{id:n,source:S.source,target:S.target,type:S.type,selected:S.selected,animated:S.animated,selectable:Z,deletable:S.deletable??!0,label:S.label,labelStyle:S.labelStyle,labelShowBg:S.labelShowBg,labelBgStyle:S.labelBgStyle,labelBgPadding:S.labelBgPadding,labelBgBorderRadius:S.labelBgBorderRadius,sourceX:B,sourceY:X,targetX:Y,targetY:U,sourcePosition:E,targetPosition:O,data:S.data,style:S.style,sourceHandleId:S.sourceHandle,targetHandleId:S.targetHandle,markerStart:W,markerEnd:le,pathOptions:"pathOptions"in S?S.pathOptions:void 0,interactionWidth:S.interactionWidth}),q&&N.jsx(a3,{edge:S,isReconnectable:q,reconnectRadius:v,onReconnect:p,onReconnectStart:b,onReconnectEnd:x,sourceX:B,sourceY:X,targetX:Y,targetY:U,sourcePosition:E,targetPosition:O,setUpdateHover:ne,setReconnecting:C})]})})}var i3=$.memo(l3);const o3=n=>({edgesFocusable:n.edgesFocusable,edgesReconnectable:n.edgesReconnectable,elementsSelectable:n.elementsSelectable,connectionMode:n.connectionMode,onError:n.onError});function pv({defaultMarkerColor:n,onlyRenderVisibleElements:l,rfId:o,edgeTypes:r,noPanClassName:u,onReconnect:f,onEdgeContextMenu:d,onEdgeMouseEnter:h,onEdgeMouseMove:m,onEdgeMouseLeave:g,onEdgeClick:v,reconnectRadius:p,onEdgeDoubleClick:b,onReconnectStart:x,onReconnectEnd:_,disableKeyboardA11y:T}){const{edgesFocusable:z,edgesReconnectable:A,elementsSelectable:R,onError:S}=je(o3,Ie),D=XE(l);return N.jsxs("div",{className:"react-flow__edges",children:[N.jsx(IE,{defaultColor:n,rfId:o}),D.map(H=>N.jsx(i3,{id:H,edgesFocusable:z,edgesReconnectable:A,elementsSelectable:R,noPanClassName:u,onReconnect:f,onContextMenu:d,onMouseEnter:h,onMouseMove:m,onMouseLeave:g,onClick:v,reconnectRadius:p,onDoubleClick:b,onReconnectStart:x,onReconnectEnd:_,rfId:o,onError:S,edgeTypes:r,disableKeyboardA11y:T},H))]})}pv.displayName="EdgeRenderer";const r3=$.memo(pv),wy=n=>`translate(${n[0]}px,${n[1]}px) scale(${n[2]})`;function u3({children:n}){const l=$e(),o=$.useRef(null),[r]=$.useState(()=>l.getState().transform);return Ip(()=>{let u=null;const f=()=>{const d=l.getState().transform;u&&d[0]===u[0]&&d[1]===u[1]&&d[2]===u[2]||(u=d,o.current&&(o.current.style.transform=wy(d)))};return f(),l.subscribe(f)},[l]),N.jsx("div",{ref:o,className:"react-flow__viewport xyflow__viewport react-flow__container",style:{transform:wy(r)},children:n})}function s3(n){const l=Lo(),o=$.useRef(!1);$.useEffect(()=>{!o.current&&l.viewportInitialized&&n&&(setTimeout(()=>n(l),1),o.current=!0)},[n,l.viewportInitialized])}const c3=n=>{var l;return(l=n.panZoom)==null?void 0:l.syncViewport};function f3(n){const l=je(c3),o=$e();return $.useEffect(()=>{n&&(l==null||l(n),o.setState({transform:[n.x,n.y,n.zoom]}))},[n,l]),null}function d3(n){return n.connection.inProgress?{...n.connection,to:Bo(n.connection.to,n.transform)}:{...n.connection}}function h3(n){return d3}function g3(n){const l=h3();return je(l,Ie)}const m3=n=>({nodesConnectable:n.nodesConnectable,isValid:n.connection.isValid,inProgress:n.connection.inProgress,width:n.width,height:n.height});function y3({containerStyle:n,style:l,type:o,component:r}){const{nodesConnectable:u,width:f,height:d,isValid:h,inProgress:m}=je(m3,Ie);return!(f&&u&&m)?null:N.jsx("svg",{style:n,width:f,height:d,className:"react-flow__connectionline react-flow__container",children:N.jsx("g",{className:ot(["react-flow__connection",yp(h)]),children:N.jsx(vv,{style:l,type:o,CustomComponent:r,isValid:h})})})}const vv=({style:n,type:l=Aa.Bezier,CustomComponent:o,isValid:r})=>{const{inProgress:u,from:f,fromNode:d,fromHandle:h,fromPosition:m,to:g,toNode:v,toHandle:p,toPosition:b,pointer:x}=g3();if(!u)return;if(o)return N.jsx(o,{connectionLineType:l,connectionLineStyle:n,fromNode:d,fromHandle:h,fromX:f.x,fromY:f.y,toX:g.x,toY:g.y,fromPosition:m,toPosition:b,connectionStatus:yp(r),toNode:v,toHandle:p,pointer:x});let _="";const T={sourceX:f.x,sourceY:f.y,sourcePosition:m,targetX:g.x,targetY:g.y,targetPosition:b};switch(l){case Aa.Bezier:[_]=vd(T);break;case Aa.SimpleBezier:[_]=iv(T);break;case Aa.Step:[_]=Xf({...T,borderRadius:0});break;case Aa.SmoothStep:[_]=Xf(T);break;default:[_]=Cp(T)}return N.jsx("path",{d:_,fill:"none",className:"react-flow__connection-path",style:n})};vv.displayName="ConnectionLine";const p3={};function Sy(n=p3){$.useRef(n),$e(),$.useEffect(()=>{},[n])}function v3(){$e(),$.useRef(!1),$.useEffect(()=>{},[])}function bv({nodeTypes:n,edgeTypes:l,onInit:o,onNodeClick:r,onEdgeClick:u,onNodeDoubleClick:f,onEdgeDoubleClick:d,onNodeMouseEnter:h,onNodeMouseMove:m,onNodeMouseLeave:g,onNodeContextMenu:v,onSelectionContextMenu:p,onSelectionStart:b,onSelectionEnd:x,connectionLineType:_,connectionLineStyle:T,connectionLineComponent:z,connectionLineContainerStyle:A,selectionKeyCode:R,selectionOnDrag:S,selectionMode:D,multiSelectionKeyCode:H,panActivationKeyCode:j,zoomActivationKeyCode:k,deleteKeyCode:q,onlyRenderVisibleElements:Z,elementsSelectable:ie,defaultViewport:J,translateExtent:ne,minZoom:P,maxZoom:C,preventScrolling:V,defaultMarkerColor:M,zoomOnScroll:B,zoomOnPinch:X,panOnScroll:Y,panOnScrollSpeed:U,panOnScrollMode:E,zoomOnDoubleClick:O,panOnDrag:W,autoPanOnSelection:le,onPaneClick:ce,onPaneMouseEnter:me,onPaneMouseMove:ge,onPaneMouseLeave:ae,onPaneScroll:fe,onPaneContextMenu:ee,paneClickDistance:se,nodeClickDistance:de,onEdgeContextMenu:pe,onEdgeMouseEnter:we,onEdgeMouseMove:he,onEdgeMouseLeave:ye,reconnectRadius:Ae,onReconnect:Ke,onReconnectStart:ft,onReconnectEnd:yt,noDragClassName:kt,noWheelClassName:za,noPanClassName:Nn,disableKeyboardA11y:Fe,nodeExtent:Rt,rfId:Xt,viewport:Qt,onViewportChange:$t,nodesDraggable:di}){return Sy(n),Sy(l),v3(),s3(o),f3(Qt),N.jsx(jE,{onPaneClick:ce,onPaneMouseEnter:me,onPaneMouseMove:ge,onPaneMouseLeave:ae,onPaneContextMenu:ee,onPaneScroll:fe,paneClickDistance:se,deleteKeyCode:q,selectionKeyCode:R,selectionOnDrag:S,selectionMode:D,onSelectionStart:b,onSelectionEnd:x,multiSelectionKeyCode:H,panActivationKeyCode:j,zoomActivationKeyCode:k,elementsSelectable:ie,zoomOnScroll:B,zoomOnPinch:X,zoomOnDoubleClick:O,panOnScroll:Y,panOnScrollSpeed:U,panOnScrollMode:E,panOnDrag:W,autoPanOnSelection:le,defaultViewport:J,translateExtent:ne,minZoom:P,maxZoom:C,onSelectionContextMenu:p,preventScrolling:V,noDragClassName:kt,noWheelClassName:za,noPanClassName:Nn,disableKeyboardA11y:Fe,onViewportChange:$t,isControlledViewport:!!Qt,children:N.jsxs(u3,{children:[N.jsx(r3,{edgeTypes:l,onEdgeClick:u,onEdgeDoubleClick:d,onReconnect:Ke,onReconnectStart:ft,onReconnectEnd:yt,onlyRenderVisibleElements:Z,onEdgeContextMenu:pe,onEdgeMouseEnter:we,onEdgeMouseMove:he,onEdgeMouseLeave:ye,reconnectRadius:Ae,defaultMarkerColor:M,noPanClassName:Nn,disableKeyboardA11y:Fe,rfId:Xt}),N.jsx(y3,{style:T,type:_,component:z,containerStyle:A}),N.jsx("div",{className:"react-flow__edgelabel-renderer"}),N.jsx(VE,{nodeTypes:n,onNodeClick:r,onNodeDoubleClick:f,onNodeMouseEnter:h,onNodeMouseMove:m,onNodeMouseLeave:g,onNodeContextMenu:v,nodeClickDistance:de,onlyRenderVisibleElements:Z,noPanClassName:Nn,noDragClassName:kt,disableKeyboardA11y:Fe,nodeExtent:Rt,rfId:Xt,nodesDraggable:di}),N.jsx("div",{className:"react-flow__viewport-portal"})]})})}bv.displayName="GraphView";const b3=$.memo(bv),x3=wp(),Ey=({nodes:n,edges:l,defaultNodes:o,defaultEdges:r,width:u,height:f,fitView:d,fitViewOptions:h,minZoom:m=.5,maxZoom:g=2,nodeOrigin:v,nodeExtent:p,zIndexMode:b="basic"}={})=>{const x=new Map,_=new Map,T=new Map,z=new Map,A=r??l??[],R=o??n??[],S=v??[0,0],D=p??Eo;Rp(T,z,A);const{nodesInitialized:H}=$f(R,x,_,{nodeOrigin:S,nodeExtent:D,zIndexMode:b});let j=[0,0,1];if(d&&u&&f){const k=Oo(x,{filter:J=>!!((J.width||J.initialWidth)&&(J.height||J.initialHeight))}),{x:q,y:Z,zoom:ie}=yd(k,u,f,m,g,(h==null?void 0:h.padding)??.1);j=[q,Z,ie]}return{rfId:"1",width:u??0,height:f??0,transform:j,nodes:R,nodesInitialized:H,nodeLookup:x,parentLookup:_,edges:A,edgeLookup:z,connectionLookup:T,onNodesChange:null,onEdgesChange:null,hasDefaultNodes:o!==void 0,hasDefaultEdges:r!==void 0,panZoom:null,minZoom:m,maxZoom:g,translateExtent:Eo,nodeExtent:D,nodesSelectionActive:!1,userSelectionActive:!1,userSelectionRect:null,connectionMode:ii.Strict,domNode:null,paneDragging:!1,noPanClassName:"nopan",nodeOrigin:S,nodeDragThreshold:1,connectionDragThreshold:1,snapGrid:[15,15],snapToGrid:!1,nodesDraggable:!0,nodesConnectable:!0,nodesFocusable:!0,edgesFocusable:!0,edgesReconnectable:!0,elementsSelectable:!0,elevateNodesOnSelect:!0,elevateEdgesOnSelect:!0,selectNodesOnDrag:!0,multiSelectionActive:!1,fitViewQueued:d??!1,fitViewOptions:h,fitViewResolver:null,connection:{...mp},connectionClickStartHandle:null,connectOnClick:!0,ariaLiveMessage:"",autoPanOnConnect:!0,autoPanOnNodeDrag:!0,autoPanOnNodeFocus:!0,autoPanSpeed:15,connectionRadius:20,onError:x3,isValidConnection:void 0,onSelectionChangeHandlers:[],lib:"react",debug:!1,ariaLabelConfig:gp,zIndexMode:b,onNodesChangeMiddlewareMap:new Map,onEdgesChangeMiddlewareMap:new Map}},_3=({nodes:n,edges:l,defaultNodes:o,defaultEdges:r,width:u,height:f,fitView:d,fitViewOptions:h,minZoom:m,maxZoom:g,nodeOrigin:v,nodeExtent:p,zIndexMode:b})=>H2((x,_)=>{async function T(){const{nodeLookup:z,panZoom:A,fitViewOptions:R,fitViewResolver:S,width:D,height:H,minZoom:j,maxZoom:k}=_();A&&(await kS({nodes:z,width:D,height:H,panZoom:A,minZoom:j,maxZoom:k},R),S==null||S.resolve(!0),x({fitViewResolver:null}))}return{...Ey({nodes:n,edges:l,width:u,height:f,fitView:d,fitViewOptions:h,minZoom:m,maxZoom:g,nodeOrigin:v,nodeExtent:p,defaultNodes:o,defaultEdges:r,zIndexMode:b}),setNodes:z=>{const{nodeLookup:A,parentLookup:R,nodeOrigin:S,elevateNodesOnSelect:D,fitViewQueued:H,zIndexMode:j,nodesSelectionActive:k}=_(),{nodesInitialized:q,hasSelectedNodes:Z}=$f(z,A,R,{nodeOrigin:S,nodeExtent:p,elevateNodesOnSelect:D,checkEquality:!0,zIndexMode:j}),ie=k&&Z;H&&q?(T(),x({nodes:z,nodesInitialized:q,fitViewQueued:!1,fitViewOptions:void 0,nodesSelectionActive:ie})):x({nodes:z,nodesInitialized:q,nodesSelectionActive:ie})},setEdges:z=>{const{connectionLookup:A,edgeLookup:R}=_();Rp(A,R,z),x({edges:z})},setDefaultNodesAndEdges:(z,A)=>{if(z){const{setNodes:R}=_();R(z),x({hasDefaultNodes:!0})}if(A){const{setEdges:R}=_();R(A),x({hasDefaultEdges:!0})}},updateNodeInternals:z=>{const{triggerNodeChanges:A,nodeLookup:R,parentLookup:S,domNode:D,nodeOrigin:H,nodeExtent:j,debug:k,fitViewQueued:q,zIndexMode:Z}=_(),{changes:ie,updatedInternals:J}=t2(z,R,S,D,H,j,Z);J&&(WS(R,S,{nodeOrigin:H,nodeExtent:j,zIndexMode:Z}),q?(T(),x({fitViewQueued:!1,fitViewOptions:void 0})):x({}),(ie==null?void 0:ie.length)>0&&(k&&console.log("React Flow: trigger node changes",ie),A==null||A(ie)))},updateNodePositions:(z,A=!1)=>{const R=[];let S=[];const{nodeLookup:D,triggerNodeChanges:H,connection:j,updateConnection:k,onNodesChangeMiddlewareMap:q}=_();for(const[Z,ie]of z){const J=D.get(Z),ne=!!(J!=null&&J.expandParent&&(J!=null&&J.parentId)&&(ie!=null&&ie.position)),P={id:Z,type:"position",position:ne?{x:Math.max(0,ie.position.x),y:Math.max(0,ie.position.y)}:ie.position,dragging:A};if(J&&j.inProgress&&j.fromNode.id===J.id){const C=il(J,j.fromHandle,xe.Left,!0);k({...j,from:C})}ne&&J.parentId&&R.push({id:Z,parentId:J.parentId,rect:{...ie.internals.positionAbsolute,width:ie.measured.width??0,height:ie.measured.height??0}}),S.push(P)}if(R.length>0){const{parentLookup:Z,nodeOrigin:ie}=_(),J=Sd(R,D,Z,ie);S.push(...J)}for(const Z of q.values())S=Z(S);H(S)},triggerNodeChanges:z=>{const{onNodesChange:A,setNodes:R,nodes:S,hasDefaultNodes:D,debug:H}=_();if(z!=null&&z.length){if(D){const j=Kf(z,S);R(j)}H&&console.log("React Flow: trigger node changes",z),A==null||A(z)}},triggerEdgeChanges:z=>{const{onEdgesChange:A,setEdges:R,edges:S,hasDefaultEdges:D,debug:H}=_();if(z!=null&&z.length){if(D){const j=If(z,S);R(j)}H&&console.log("React Flow: trigger edge changes",z),A==null||A(z)}},addSelectedNodes:z=>{const{multiSelectionActive:A,edgeLookup:R,nodeLookup:S,triggerNodeChanges:D,triggerEdgeChanges:H}=_();if(A){const j=z.map(k=>Wa(k,!0));D(j);return}D(ei(S,new Set([...z]),!0)),H(ei(R))},addSelectedEdges:z=>{const{multiSelectionActive:A,edgeLookup:R,nodeLookup:S,triggerNodeChanges:D,triggerEdgeChanges:H}=_();if(A){const j=z.map(k=>Wa(k,!0));H(j);return}H(ei(R,new Set([...z]))),D(ei(S,new Set,!0))},unselectNodesAndEdges:({nodes:z,edges:A}={})=>{const{edges:R,nodes:S,nodeLookup:D,triggerNodeChanges:H,triggerEdgeChanges:j}=_(),k=z||S,q=A||R,Z=[];for(const J of k){if(!J.selected)continue;const ne=D.get(J.id);ne&&(ne.selected=!1),Z.push(Wa(J.id,!1))}const ie=[];for(const J of q)J.selected&&ie.push(Wa(J.id,!1));H(Z),j(ie)},setMinZoom:z=>{const{panZoom:A,maxZoom:R}=_();A==null||A.setScaleExtent([z,R]),x({minZoom:z})},setMaxZoom:z=>{const{panZoom:A,minZoom:R}=_();A==null||A.setScaleExtent([R,z]),x({maxZoom:z})},setTranslateExtent:z=>{var A;(A=_().panZoom)==null||A.setTranslateExtent(z),x({translateExtent:z})},resetSelectedElements:()=>{const{edges:z,nodes:A,triggerNodeChanges:R,triggerEdgeChanges:S,elementsSelectable:D}=_();if(!D)return;const H=A.reduce((k,q)=>q.selected?[...k,Wa(q.id,!1)]:k,[]),j=z.reduce((k,q)=>q.selected?[...k,Wa(q.id,!1)]:k,[]);R(H),S(j)},setNodeExtent:z=>{const{nodes:A,nodeLookup:R,parentLookup:S,nodeOrigin:D,elevateNodesOnSelect:H,nodeExtent:j,zIndexMode:k}=_();z[0][0]===j[0][0]&&z[0][1]===j[0][1]&&z[1][0]===j[1][0]&&z[1][1]===j[1][1]||($f(A,R,S,{nodeOrigin:D,nodeExtent:z,elevateNodesOnSelect:H,checkEquality:!1,zIndexMode:k}),x({nodeExtent:z}))},panBy:z=>{const{transform:A,width:R,height:S,panZoom:D,translateExtent:H}=_();return n2({delta:z,panZoom:D,transform:A,translateExtent:H,width:R,height:S})},setCenter:async(z,A,R)=>{const{width:S,height:D,maxZoom:H,panZoom:j}=_();if(!j)return!1;const k=typeof(R==null?void 0:R.zoom)<"u"?R.zoom:H;return await j.setViewport({x:S/2-z*k,y:D/2-A*k,zoom:k},{duration:R==null?void 0:R.duration,ease:R==null?void 0:R.ease,interpolate:R==null?void 0:R.interpolate}),!0},cancelConnection:()=>{x({connection:{...mp}})},updateConnection:z=>{x({connection:z})},reset:()=>x({...Ey()})}},Object.is);function xv({initialNodes:n,initialEdges:l,defaultNodes:o,defaultEdges:r,initialWidth:u,initialHeight:f,initialMinZoom:d,initialMaxZoom:h,initialFitViewOptions:m,fitView:g,nodeOrigin:v,nodeExtent:p,zIndexMode:b,children:x}){const[_]=$.useState(()=>_3({nodes:n,edges:l,defaultNodes:o,defaultEdges:r,width:u,height:f,fitView:g,minZoom:d,maxZoom:h,fitViewOptions:m,nodeOrigin:v,nodeExtent:p,zIndexMode:b}));return N.jsx(B2,{value:_,children:N.jsx(oE,{children:N.jsx(_E,{children:x})})})}function w3({children:n,nodes:l,edges:o,defaultNodes:r,defaultEdges:u,width:f,height:d,fitView:h,fitViewOptions:m,minZoom:g,maxZoom:v,nodeOrigin:p,nodeExtent:b,zIndexMode:x}){return $.useContext(Qu)?N.jsx(N.Fragment,{children:n}):N.jsx(xv,{initialNodes:l,initialEdges:o,defaultNodes:r,defaultEdges:u,initialWidth:f,initialHeight:d,fitView:h,initialFitViewOptions:m,initialMinZoom:g,initialMaxZoom:v,nodeOrigin:p,nodeExtent:b,zIndexMode:x,children:n})}const S3={width:"100%",height:"100%",overflow:"hidden",position:"relative",zIndex:0};function E3({nodes:n,edges:l,defaultNodes:o,defaultEdges:r,className:u,nodeTypes:f,edgeTypes:d,onNodeClick:h,onEdgeClick:m,onInit:g,onMove:v,onMoveStart:p,onMoveEnd:b,onConnect:x,onConnectStart:_,onConnectEnd:T,onClickConnectStart:z,onClickConnectEnd:A,onNodeMouseEnter:R,onNodeMouseMove:S,onNodeMouseLeave:D,onNodeContextMenu:H,onNodeDoubleClick:j,onNodeDragStart:k,onNodeDrag:q,onNodeDragStop:Z,onNodesDelete:ie,onEdgesDelete:J,onDelete:ne,onSelectionChange:P,onSelectionDragStart:C,onSelectionDrag:V,onSelectionDragStop:M,onSelectionContextMenu:B,onSelectionStart:X,onSelectionEnd:Y,onBeforeDelete:U,connectionMode:E,connectionLineType:O=Aa.Bezier,connectionLineStyle:W,connectionLineComponent:le,connectionLineContainerStyle:ce,deleteKeyCode:me="Backspace",selectionKeyCode:ge="Shift",selectionOnDrag:ae=!1,selectionMode:fe=No.Full,panActivationKeyCode:ee="Space",multiSelectionKeyCode:se=Ao()?"Meta":"Control",zoomActivationKeyCode:de=Ao()?"Meta":"Control",snapToGrid:pe,snapGrid:we,onlyRenderVisibleElements:he=!1,selectNodesOnDrag:ye,nodesDraggable:Ae,autoPanOnNodeFocus:Ke,nodesConnectable:ft,nodesFocusable:yt,nodeOrigin:kt=$p,edgesFocusable:za,edgesReconnectable:Nn,elementsSelectable:Fe=!0,defaultViewport:Rt=J2,minZoom:Xt=.5,maxZoom:Qt=2,translateExtent:$t=Eo,preventScrolling:di=!0,nodeExtent:ul,defaultMarkerColor:Iu="#b1b1b7",zoomOnScroll:Ju=!0,zoomOnPinch:Ca=!0,panOnScroll:bt=!1,panOnScrollSpeed:hn=.5,panOnScrollMode:xt=el.Free,zoomOnDoubleClick:Wu=!0,panOnDrag:Fu=!0,onPaneClick:Pu,onPaneMouseEnter:sl,onPaneMouseMove:cl,onPaneMouseLeave:fl,onPaneScroll:Tn,onPaneContextMenu:dl,paneClickDistance:Da=1,nodeClickDistance:es=0,children:Go,onReconnect:hi,onReconnectStart:ka,onReconnectEnd:ts,onEdgeContextMenu:qo,onEdgeDoubleClick:Yo,onEdgeMouseEnter:Vo,onEdgeMouseMove:gi,onEdgeMouseLeave:mi,reconnectRadius:Xo=10,onNodesChange:Qo,onEdgesChange:gn,noDragClassName:rt="nodrag",noWheelClassName:pt="nowheel",noPanClassName:An="nopan",fitView:hl,fitViewOptions:$o,connectOnClick:ns,attributionPosition:Zo,proOptions:Ra,defaultEdgeOptions:yi,elevateNodesOnSelect:In=!0,elevateEdgesOnSelect:Jn=!1,disableKeyboardA11y:Wn=!1,autoPanOnConnect:Fn,autoPanOnNodeDrag:tt,autoPanOnSelection:Ko=!0,autoPanSpeed:Io,connectionRadius:Mn,isValidConnection:Pn,onError:as,style:Jo,id:pi,nodeDragThreshold:ls,connectionDragThreshold:gl,viewport:ml,onViewportChange:tn,width:St,height:Wo,colorMode:is="light",debug:vi,onScroll:ja,ariaLabelConfig:yl,zIndexMode:Fo="basic",...Et},bi){const pl=pi||"1",xi=eE(is),ea=$.useCallback(_i=>{_i.currentTarget.scrollTo({top:0,left:0,behavior:"instant"}),ja==null||ja(_i)},[ja]);return N.jsx("div",{"data-testid":"rf__wrapper",...Et,onScroll:ea,style:{...Jo,...S3},ref:bi,className:ot(["react-flow",u,xi]),id:pi,role:"application",children:N.jsxs(w3,{nodes:n,edges:l,width:St,height:Wo,fitView:hl,fitViewOptions:$o,minZoom:Xt,maxZoom:Qt,nodeOrigin:kt,nodeExtent:ul,zIndexMode:Fo,children:[N.jsx(P2,{nodes:n,edges:l,defaultNodes:o,defaultEdges:r,onConnect:x,onConnectStart:_,onConnectEnd:T,onClickConnectStart:z,onClickConnectEnd:A,nodesDraggable:Ae,autoPanOnNodeFocus:Ke,nodesConnectable:ft,nodesFocusable:yt,edgesFocusable:za,edgesReconnectable:Nn,elementsSelectable:Fe,elevateNodesOnSelect:In,elevateEdgesOnSelect:Jn,minZoom:Xt,maxZoom:Qt,nodeExtent:ul,onNodesChange:Qo,onEdgesChange:gn,snapToGrid:pe,snapGrid:we,connectionMode:E,translateExtent:$t,connectOnClick:ns,defaultEdgeOptions:yi,fitView:hl,fitViewOptions:$o,onNodesDelete:ie,onEdgesDelete:J,onDelete:ne,onNodeDragStart:k,onNodeDrag:q,onNodeDragStop:Z,onSelectionDrag:V,onSelectionDragStart:C,onSelectionDragStop:M,onMove:v,onMoveStart:p,onMoveEnd:b,noPanClassName:An,nodeOrigin:kt,rfId:pl,autoPanOnConnect:Fn,autoPanOnNodeDrag:tt,autoPanSpeed:Io,onError:as,connectionRadius:Mn,isValidConnection:Pn,selectNodesOnDrag:ye,nodeDragThreshold:ls,connectionDragThreshold:gl,onBeforeDelete:U,debug:vi,ariaLabelConfig:yl,zIndexMode:Fo}),N.jsx(b3,{onInit:g,onNodeClick:h,onEdgeClick:m,onNodeMouseEnter:R,onNodeMouseMove:S,onNodeMouseLeave:D,onNodeContextMenu:H,onNodeDoubleClick:j,nodeTypes:f,edgeTypes:d,connectionLineType:O,connectionLineStyle:W,connectionLineComponent:le,connectionLineContainerStyle:ce,selectionKeyCode:ge,selectionOnDrag:ae,selectionMode:fe,deleteKeyCode:me,multiSelectionKeyCode:se,panActivationKeyCode:ee,zoomActivationKeyCode:de,onlyRenderVisibleElements:he,defaultViewport:Rt,translateExtent:$t,minZoom:Xt,maxZoom:Qt,preventScrolling:di,zoomOnScroll:Ju,zoomOnPinch:Ca,zoomOnDoubleClick:Wu,panOnScroll:bt,panOnScrollSpeed:hn,panOnScrollMode:xt,panOnDrag:Fu,autoPanOnSelection:Ko,onPaneClick:Pu,onPaneMouseEnter:sl,onPaneMouseMove:cl,onPaneMouseLeave:fl,onPaneScroll:Tn,onPaneContextMenu:dl,paneClickDistance:Da,nodeClickDistance:es,onSelectionContextMenu:B,onSelectionStart:X,onSelectionEnd:Y,onReconnect:hi,onReconnectStart:ka,onReconnectEnd:ts,onEdgeContextMenu:qo,onEdgeDoubleClick:Yo,onEdgeMouseEnter:Vo,onEdgeMouseMove:gi,onEdgeMouseLeave:mi,reconnectRadius:Xo,defaultMarkerColor:Iu,noDragClassName:rt,noWheelClassName:pt,noPanClassName:An,rfId:pl,disableKeyboardA11y:Wn,nodeExtent:ul,viewport:ml,onViewportChange:tn,nodesDraggable:Ae}),N.jsx(I2,{onSelectionChange:P}),Go,N.jsx(X2,{proOptions:Ra,position:Zo}),N.jsx(V2,{rfId:pl,disableKeyboardA11y:Wn})]})})}var N3=Kp(E3);const T3=n=>{var l;return(l=n.domNode)==null?void 0:l.querySelector(".react-flow__edgelabel-renderer")};function A3({children:n}){const l=je(T3);return l?Ed.createPortal(n,l):null}function M3({dimensions:n,lineWidth:l,variant:o,className:r}){return N.jsx("path",{strokeWidth:l,d:`M${n[0]/2} 0 V${n[1]} M0 ${n[1]/2} H${n[0]}`,className:ot(["react-flow__background-pattern",o,r])})}function z3({radius:n,className:l}){return N.jsx("circle",{cx:n,cy:n,r:n,className:ot(["react-flow__background-pattern","dots",l])})}var Ma;(function(n){n.Lines="lines",n.Dots="dots",n.Cross="cross"})(Ma||(Ma={}));const C3={[Ma.Dots]:1,[Ma.Lines]:1,[Ma.Cross]:6},D3=n=>({transform:n.transform,patternId:`pattern-${n.rfId}`});function _v({id:n,variant:l=Ma.Dots,gap:o=20,size:r,lineWidth:u=1,offset:f=0,color:d,bgColor:h,style:m,className:g,patternClassName:v}){const p=$.useRef(null),{transform:b,patternId:x}=je(D3,Ie),_=r||C3[l],T=l===Ma.Dots,z=l===Ma.Cross,A=Array.isArray(o)?o:[o,o],R=[A[0]*b[2]||1,A[1]*b[2]||1],S=_*b[2],D=Array.isArray(f)?f:[f,f],H=z?[S,S]:R,j=[D[0]*b[2]||1+H[0]/2,D[1]*b[2]||1+H[1]/2],k=`${x}${n||""}`;return N.jsxs("svg",{className:ot(["react-flow__background",g]),style:{...m,...Zu,"--xy-background-color-props":h,"--xy-background-pattern-color-props":d},ref:p,"data-testid":"rf__background",children:[N.jsx("pattern",{id:k,x:b[0]%R[0],y:b[1]%R[1],width:R[0],height:R[1],patternUnits:"userSpaceOnUse",patternTransform:`translate(-${j[0]},-${j[1]})`,children:T?N.jsx(z3,{radius:S/2,className:v}):N.jsx(M3,{dimensions:H,lineWidth:u,variant:l,className:v})}),N.jsx("rect",{x:"0",y:"0",width:"100%",height:"100%",fill:`url(#${k})`})]})}_v.displayName="Background";const k3=$.memo(_v);function R3(){return N.jsx("svg",{xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 32 32",children:N.jsx("path",{d:"M32 18.133H18.133V32h-4.266V18.133H0v-4.266h13.867V0h4.266v13.867H32z"})})}function j3(){return N.jsx("svg",{xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 32 5",children:N.jsx("path",{d:"M0 0h32v4.2H0z"})})}function O3(){return N.jsx("svg",{xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 32 30",children:N.jsx("path",{d:"M3.692 4.63c0-.53.4-.938.939-.938h5.215V0H4.708C2.13 0 0 2.054 0 4.63v5.216h3.692V4.631zM27.354 0h-5.2v3.692h5.17c.53 0 .984.4.984.939v5.215H32V4.631A4.624 4.624 0 0027.354 0zm.954 24.83c0 .532-.4.94-.939.94h-5.215v3.768h5.215c2.577 0 4.631-2.13 4.631-4.707v-5.139h-3.692v5.139zm-23.677.94c-.531 0-.939-.4-.939-.94v-5.138H0v5.139c0 2.577 2.13 4.707 4.708 4.707h5.138V25.77H4.631z"})})}function H3(){return N.jsx("svg",{xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 25 32",children:N.jsx("path",{d:"M21.333 10.667H19.81V7.619C19.81 3.429 16.38 0 12.19 0 8 0 4.571 3.429 4.571 7.619v3.048H3.048A3.056 3.056 0 000 13.714v15.238A3.056 3.056 0 003.048 32h18.285a3.056 3.056 0 003.048-3.048V13.714a3.056 3.056 0 00-3.048-3.047zM12.19 24.533a3.056 3.056 0 01-3.047-3.047 3.056 3.056 0 013.047-3.048 3.056 3.056 0 013.048 3.048 3.056 3.056 0 01-3.048 3.047zm4.724-13.866H7.467V7.619c0-2.59 2.133-4.724 4.723-4.724 2.591 0 4.724 2.133 4.724 4.724v3.048z"})})}function B3(){return N.jsx("svg",{xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 25 32",children:N.jsx("path",{d:"M21.333 10.667H19.81V7.619C19.81 3.429 16.38 0 12.19 0c-4.114 1.828-1.37 2.133.305 2.438 1.676.305 4.42 2.59 4.42 5.181v3.048H3.047A3.056 3.056 0 000 13.714v15.238A3.056 3.056 0 003.048 32h18.285a3.056 3.056 0 003.048-3.048V13.714a3.056 3.056 0 00-3.048-3.047zM12.19 24.533a3.056 3.056 0 01-3.047-3.047 3.056 3.056 0 013.047-3.048 3.056 3.056 0 013.048 3.048 3.056 3.056 0 01-3.048 3.047z"})})}function yu({children:n,className:l,...o}){return N.jsx("button",{type:"button",className:ot(["react-flow__controls-button",l]),...o,children:n})}const L3=n=>({isInteractive:n.nodesDraggable||n.nodesConnectable||n.elementsSelectable,minZoomReached:n.transform[2]<=n.minZoom,maxZoomReached:n.transform[2]>=n.maxZoom,ariaLabelConfig:n.ariaLabelConfig});function wv({style:n,showZoom:l=!0,showFitView:o=!0,showInteractive:r=!0,fitViewOptions:u,onZoomIn:f,onZoomOut:d,onFitView:h,onInteractiveChange:m,className:g,children:v,position:p="bottom-left",orientation:b="vertical","aria-label":x}){const _=$e(),{isInteractive:T,minZoomReached:z,maxZoomReached:A,ariaLabelConfig:R}=je(L3,Ie),{zoomIn:S,zoomOut:D,fitView:H}=Lo(),j=()=>{S(),f==null||f()},k=()=>{D(),d==null||d()},q=()=>{H(u),h==null||h()},Z=()=>{_.setState({nodesDraggable:!T,nodesConnectable:!T,elementsSelectable:!T}),m==null||m(!T)},ie=b==="horizontal"?"horizontal":"vertical";return N.jsxs($u,{className:ot(["react-flow__controls",ie,g]),position:p,style:n,"data-testid":"rf__controls","aria-label":x??R["controls.ariaLabel"],children:[l&&N.jsxs(N.Fragment,{children:[N.jsx(yu,{onClick:j,className:"react-flow__controls-zoomin",title:R["controls.zoomIn.ariaLabel"],"aria-label":R["controls.zoomIn.ariaLabel"],disabled:A,children:N.jsx(R3,{})}),N.jsx(yu,{onClick:k,className:"react-flow__controls-zoomout",title:R["controls.zoomOut.ariaLabel"],"aria-label":R["controls.zoomOut.ariaLabel"],disabled:z,children:N.jsx(j3,{})})]}),o&&N.jsx(yu,{className:"react-flow__controls-fitview",onClick:q,title:R["controls.fitView.ariaLabel"],"aria-label":R["controls.fitView.ariaLabel"],children:N.jsx(O3,{})}),r&&N.jsx(yu,{className:"react-flow__controls-interactive",onClick:Z,title:R["controls.interactive.ariaLabel"],"aria-label":R["controls.interactive.ariaLabel"],children:T?N.jsx(B3,{}):N.jsx(H3,{})}),v]})}wv.displayName="Controls";const U3=$.memo(wv);function G3({id:n,x:l,y:o,width:r,height:u,style:f,color:d,strokeColor:h,strokeWidth:m,className:g,borderRadius:v,shapeRendering:p,selected:b,onClick:x}){const{background:_,backgroundColor:T}=f||{},z=d||_||T;return N.jsx("rect",{className:ot(["react-flow__minimap-node",{selected:b},g]),x:l,y:o,rx:v,ry:v,width:r,height:u,style:{fill:z,stroke:h,strokeWidth:m},shapeRendering:p,onClick:x?A=>x(A,n):void 0})}const q3=$.memo(G3),Y3=n=>n.nodes.map(l=>l.id),zf=n=>n instanceof Function?n:()=>n;function V3({nodeStrokeColor:n,nodeColor:l,nodeClassName:o="",nodeBorderRadius:r=5,nodeStrokeWidth:u,nodeComponent:f=q3,onClick:d}){const h=je(Y3,Ie),m=zf(l),g=zf(n),v=zf(o),p=typeof window>"u"||window.chrome?"crispEdges":"geometricPrecision";return N.jsx(N.Fragment,{children:h.map(b=>N.jsx(Q3,{id:b,nodeColorFunc:m,nodeStrokeColorFunc:g,nodeClassNameFunc:v,nodeBorderRadius:r,nodeStrokeWidth:u,NodeComponent:f,onClick:d,shapeRendering:p},b))})}function X3({id:n,nodeColorFunc:l,nodeStrokeColorFunc:o,nodeClassNameFunc:r,nodeBorderRadius:u,nodeStrokeWidth:f,shapeRendering:d,NodeComponent:h,onClick:m}){const{node:g,x:v,y:p,width:b,height:x}=je(_=>{const T=_.nodeLookup.get(n);if(!T)return{node:void 0,x:0,y:0,width:0,height:0};const z=T.internals.userNode,{x:A,y:R}=T.internals.positionAbsolute,{width:S,height:D}=En(z);return{node:z,x:A,y:R,width:S,height:D}},Ie);return!g||g.hidden||!Sp(g)?null:N.jsx(h,{x:v,y:p,width:b,height:x,style:g.style,selected:!!g.selected,className:r(g),color:l(g),borderRadius:u,strokeColor:o(g),strokeWidth:f,shapeRendering:d,onClick:m,id:g.id})}const Q3=$.memo(X3);var $3=$.memo(V3);const Z3=200,K3=150,I3=n=>!n.hidden,J3=n=>{const l={x:-n.transform[0]/n.transform[2],y:-n.transform[1]/n.transform[2],width:n.width/n.transform[2],height:n.height/n.transform[2]};return{viewBB:l,boundingRect:n.nodeLookup.size>0?xp(Oo(n.nodeLookup,{filter:I3}),l):l,rfId:n.rfId,panZoom:n.panZoom,translateExtent:n.translateExtent,flowWidth:n.width,flowHeight:n.height,ariaLabelConfig:n.ariaLabelConfig}},Ny=(n,l)=>n.x===l.x&&n.y===l.y&&n.width===l.width&&n.height===l.height,W3=(n,l)=>Ny(n.viewBB,l.viewBB)&&Ny(n.boundingRect,l.boundingRect)&&n.rfId===l.rfId&&n.panZoom===l.panZoom&&n.translateExtent===l.translateExtent&&n.flowWidth===l.flowWidth&&n.flowHeight===l.flowHeight&&n.ariaLabelConfig===l.ariaLabelConfig,F3="react-flow__minimap-desc";function Sv({style:n,className:l,nodeStrokeColor:o,nodeColor:r,nodeClassName:u="",nodeBorderRadius:f=5,nodeStrokeWidth:d,nodeComponent:h,bgColor:m,maskColor:g,maskStrokeColor:v,maskStrokeWidth:p,position:b="bottom-right",onClick:x,onNodeClick:_,pannable:T=!1,zoomable:z=!1,ariaLabel:A,inversePan:R,zoomStep:S=1,offsetScale:D=5}){const H=$e(),j=$.useRef(null),{boundingRect:k,viewBB:q,rfId:Z,panZoom:ie,translateExtent:J,flowWidth:ne,flowHeight:P,ariaLabelConfig:C}=je(J3,W3),V=(n==null?void 0:n.width)??Z3,M=(n==null?void 0:n.height)??K3,B=k.width/V,X=k.height/M,Y=Math.max(B,X),U=Y*V,E=Y*M,O=D*Y,W=k.x-(U-k.width)/2-O,le=k.y-(E-k.height)/2-O,ce=U+O*2,me=E+O*2,ge=`${F3}-${Z}`,ae=$.useRef(0),fe=$.useRef();ae.current=Y,$.useEffect(()=>{if(j.current&&ie)return fe.current=f2({domNode:j.current,panZoom:ie,getTransform:()=>H.getState().transform,getViewScale:()=>ae.current}),()=>{var pe;(pe=fe.current)==null||pe.destroy()}},[ie]),$.useEffect(()=>{var pe;(pe=fe.current)==null||pe.update({translateExtent:J,width:ne,height:P,inversePan:R,pannable:T,zoomStep:S,zoomable:z})},[T,z,R,S,J,ne,P]);const ee=x?pe=>{var ye;const[we,he]=((ye=fe.current)==null?void 0:ye.pointer(pe))||[0,0];x(pe,{x:we,y:he})}:void 0,se=_?$.useCallback((pe,we)=>{const he=H.getState().nodeLookup.get(we).internals.userNode;_(pe,he)},[]):void 0,de=A??C["minimap.ariaLabel"];return N.jsx($u,{position:b,style:{...n,"--xy-minimap-background-color-props":typeof m=="string"?m:void 0,"--xy-minimap-mask-background-color-props":typeof g=="string"?g:void 0,"--xy-minimap-mask-stroke-color-props":typeof v=="string"?v:void 0,"--xy-minimap-mask-stroke-width-props":typeof p=="number"?p*Y:void 0,"--xy-minimap-node-background-color-props":typeof r=="string"?r:void 0,"--xy-minimap-node-stroke-color-props":typeof o=="string"?o:void 0,"--xy-minimap-node-stroke-width-props":typeof d=="number"?d:void 0},className:ot(["react-flow__minimap",l]),"data-testid":"rf__minimap",children:N.jsxs("svg",{width:V,height:M,viewBox:`${W} ${le} ${ce} ${me}`,className:"react-flow__minimap-svg",role:"img","aria-labelledby":ge,ref:j,onClick:ee,children:[de&&N.jsx("title",{id:ge,children:de}),N.jsx($3,{onClick:se,nodeColor:r,nodeStrokeColor:o,nodeBorderRadius:f,nodeClassName:u,nodeStrokeWidth:d,nodeComponent:h}),N.jsx("path",{className:"react-flow__minimap-mask",d:`M${W-O},${le-O}h${ce+O*2}v${me+O*2}h${-ce-O*2}z
+        M${q.x},${q.y}h${q.width}v${q.height}h${-q.width}z`,fillRule:"evenodd",pointerEvents:"none"})]})})}Sv.displayName="MiniMap";const P3=$.memo(Sv),eN=n=>l=>n?`${Math.max(1/l.transform[2],1)}`:void 0,tN={[ui.Line]:"right",[ui.Handle]:"bottom-right"};function nN({nodeId:n,position:l,variant:o=ui.Handle,className:r,style:u=void 0,children:f,color:d,minWidth:h=10,minHeight:m=10,maxWidth:g=Number.MAX_VALUE,maxHeight:v=Number.MAX_VALUE,keepAspectRatio:p=!1,resizeDirection:b,autoScale:x=!0,shouldResize:_,onResizeStart:T,onResize:z,onResizeEnd:A}){const R=Pp(),S=typeof n=="string"?n:R,D=$e(),H=$.useRef(null),j=o===ui.Handle,k=je($.useCallback(eN(j&&x),[j,x]),Ie),q=$.useRef(null),Z=l??tN[o];$.useEffect(()=>{if(!(!H.current||!S))return q.current||(q.current=E2({domNode:H.current,nodeId:S,getStoreItems:()=>{const{nodeLookup:J,transform:ne,snapGrid:P,snapToGrid:C,nodeOrigin:V,domNode:M}=D.getState();return{nodeLookup:J,transform:ne,snapGrid:P,snapToGrid:C,nodeOrigin:V,paneDomNode:M}},onChange:(J,ne)=>{const{triggerNodeChanges:P,nodeLookup:C,parentLookup:V,nodeOrigin:M}=D.getState(),B=[],X={x:J.x,y:J.y},Y=C.get(S);if(Y&&Y.expandParent&&Y.parentId){const U=Y.origin??M,E=J.width??Y.measured.width??0,O=J.height??Y.measured.height??0,W={id:Y.id,parentId:Y.parentId,rect:{width:E,height:O,...Ep({x:J.x??Y.position.x,y:J.y??Y.position.y},{width:E,height:O},Y.parentId,C,U)}},le=Sd([W],C,V,M);B.push(...le),X.x=J.x?Math.max(U[0]*E,J.x):void 0,X.y=J.y?Math.max(U[1]*O,J.y):void 0}if(X.x!==void 0&&X.y!==void 0){const U={id:S,type:"position",position:{...X}};B.push(U)}if(J.width!==void 0&&J.height!==void 0){const E={id:S,type:"dimensions",resizing:!0,setAttributes:b?b==="horizontal"?"width":"height":!0,dimensions:{width:J.width,height:J.height}};B.push(E)}for(const U of ne){const E={...U,type:"position"};B.push(E)}P(B)},onEnd:({width:J,height:ne})=>{const P={id:S,type:"dimensions",resizing:!1,dimensions:{width:J,height:ne}};D.getState().triggerNodeChanges([P])}})),q.current.update({controlPosition:Z,boundaries:{minWidth:h,minHeight:m,maxWidth:g,maxHeight:v},keepAspectRatio:p,resizeDirection:b,onResizeStart:T,onResize:z,onResizeEnd:A,shouldResize:_}),()=>{var J;(J=q.current)==null||J.destroy()}},[Z,h,m,g,v,p,T,z,A,_]);const ie=Z.split("-");return N.jsx("div",{className:ot(["react-flow__resize-control","nodrag",...ie,o,r]),ref:H,style:{...u,scale:k,...d&&{[j?"backgroundColor":"borderColor"]:d}},children:f})}$.memo(nN);const Ty=n=>{let l;const o=new Set,r=(g,v)=>{const p=typeof g=="function"?g(l):g;if(!Object.is(p,l)){const b=l;l=v??(typeof p!="object"||p===null)?p:Object.assign({},l,p),o.forEach(x=>x(l,b))}},u=()=>l,h={setState:r,getState:u,getInitialState:()=>m,subscribe:g=>(o.add(g),()=>o.delete(g))},m=l=n(r,u,h);return h},aN=(n=>n?Ty(n):Ty),lN=n=>n;function iN(n,l=lN){const o=go.useSyncExternalStore(n.subscribe,go.useCallback(()=>l(n.getState()),[n,l]),go.useCallback(()=>l(n.getInitialState()),[n,l]));return go.useDebugValue(o),o}const Ay=n=>{const l=aN(n),o=r=>iN(l,r);return Object.assign(o,l),o},Ev=(n=>n?Ay(n):Ay),ol="/api/v1/workflows";async function Vt(n,l){const o=await fetch(n,{credentials:"include",headers:{"Content-Type":"application/json",...l==null?void 0:l.headers},...l});if(!o.ok){const r=await o.json().catch(()=>({detail:o.statusText}));throw new Error(r.detail||`HTTP ${o.status}`)}if(o.status!==204)return o.json()}function oN(n=50,l=0,o){const r=new URLSearchParams({limit:String(n),offset:String(l)});return Vt(`${ol}?${r}`)}function Ff(n){return Vt(`${ol}/${n}`)}function Cf(n){return Vt(ol,{method:"POST",body:JSON.stringify(n)})}function Pf(n,l){return Vt(`${ol}/${n}`,{method:"PUT",body:JSON.stringify(l)})}function rN(n){return Vt(`${ol}/${n}`,{method:"DELETE"})}function uN(){return Vt(`${ol}/modules`)}function sN(n){return Vt(`${ol}/${n}/usage`)}function cN(n){return Vt(`/api/v1/projects/${n}/input-sources`)}function fN(n){return Vt(`/api/v1/projects/${n}/bindings`)}function dN(n,l){return Vt(`/api/v1/projects/${n}/bindings`,{method:"PUT",body:JSON.stringify(l)})}function hN(){return Vt("/api/v1/devices/input-sources")}const st={input:"#3b82f6",hand3d:"#06b6d4",annotation:"#f97316",review:"#f59e0b",export:"#22c55e"},ci=new Map,gN={rgb_hand_3d:"rgb_to_2d_bare_hand",black_hand_rgb_3d:"rgb_to_2d_black_glove",stereo_triangulate:"rgbd_to_3d_bare_hand",black_glove_hand:"rgbd_to_3d_black_glove",ai_quality_review:"data_quality",data_cleaning:"data_quality"},ed={annotation:"Human Annotation",human_review:"Human Review",rgb_to_2d_bare_hand:"RGB_TO_2D_BareHand",rgb_to_2d_black_glove:"RGB_TO_2D_BlackGlove",rgbd_to_3d_bare_hand:"RGB-D_3D_BareHand",rgbd_to_3d_black_glove:"RGB-D_3D_BlackGlove"},mN={rgb_camera:{inputs:[],outputs:[{key:"video",label:"RGB Video"}]},mono_camera:{inputs:[],outputs:[{key:"video",label:"RGB Video"}]},fisheye_camera:{inputs:[],outputs:[{key:"video",label:"RGB Video"}]},rgbd_camera:{inputs:[],outputs:[{key:"video",label:"RGB Video"},{key:"depth",label:"Depth"}]},stereo_camera:{inputs:[],outputs:[{key:"video_left",label:"Left RGB Video"},{key:"video_right",label:"Right RGB Video"}]},stereo_rgbd_camera:{inputs:[],outputs:[{key:"video_left",label:"Left RGB Video"},{key:"video_right",label:"Right RGB Video"},{key:"depth",label:"Depth"}]},glove_sensor:{inputs:[],outputs:[{key:"sensor_data",label:"Glove Sensor Data"}]},gripper_device:{inputs:[],outputs:[{key:"rgb_video",label:"RGB Video"},{key:"gripper_state",label:"ESP Gripper State"},{key:"slam_trajectory",label:"SLAM Trajectory"},{key:"tactile_force_matrices",label:"Left and Right Force Matrices"}]},mediapipe_hand:{inputs:[{key:"video",label:"RGB Video"}],outputs:[{key:"hand_keypoints",label:"Hand 2D"}]},annotation:{inputs:[{key:"data",label:"RGB Video"}],outputs:[{key:"annotation",label:"Annotation"}]},ai_annotation:{inputs:[{key:"data",label:"RGB Video"}],outputs:[{key:"annotation",label:"Annotation"}]},rgb_to_2d_bare_hand:{inputs:[{key:"video",label:"RGB Video"}],outputs:[{key:"hand_keypoints",label:"Hand 2D"}]},rgb_to_2d_black_glove:{inputs:[{key:"video",label:"RGB Video"}],outputs:[{key:"hand_keypoints",label:"Hand 2D"}]},rgbd_to_3d_bare_hand:{inputs:[{key:"video",label:"RGB Video"},{key:"depth",label:"Depth"}],outputs:[{key:"hand_3d",label:"Hand 3D"}]},rgbd_to_3d_black_glove:{inputs:[{key:"video",label:"RGB Video"},{key:"depth",label:"Depth"}],outputs:[{key:"hand_3d",label:"Hand 3D"}]},human_review:{inputs:[{key:"data",label:"Review Target"}],outputs:[{key:"reviewed",label:"Reviewed Data"}]},lerobot_export:{inputs:[{key:"data",label:"Exportable Data"}],outputs:[{key:"dataset",label:"Dataset"}]},hdf5_export:{inputs:[{key:"data",label:"Exportable Data"}],outputs:[{key:"dataset",label:"Dataset"}]}};function wn(n){const l=String(n||"").trim();return gN[l.toLowerCase()]||l}let Nv=0;const td=new Set;function yN(n){return td.add(n),()=>{td.delete(n)}}function pN(){return Nv}function Tv(){Nv+=1,td.forEach(n=>n())}function vN(n){const l=wn(n.type),o=l===n.type?n:{...n,type:l,slug:l};ci.set(l,ed[l]?{...o,label:ed[l]}:o),Tv()}function Av(n){return ci.get(wn(n))}function Mv(){return Array.from(ci.values())}function bN(n){const l=n==="process"?["annotation","ai_annotation","rgb_to_2d_bare_hand","rgb_to_2d_black_glove","rgbd_to_3d_bare_hand","rgbd_to_3d_black_glove","mediapipe_hand"]:[];return Array.from(ci.values()).filter(o=>o.category===n).sort((o,r)=>{const u=l.indexOf(o.type),f=l.indexOf(r.type);return u<0&&f<0?0:u<0?1:f<0?-1:u-f})}function xN(n,l){if(!(n!=null&&n.length))return l||[];if(!(l!=null&&l.length))return n;const o=new Set(n.map(r=>r.name));return[...n,...l.filter(r=>!o.has(r.name))]}function _N(n){for(const l of n){const o=wn(l.type||l.slug||"");if(!o||!l.category||!l.label)continue;const r=ci.get(o),u=mN[o];ci.set(o,{type:o,slug:o,version:l.version||"1.0",category:l.category,label:ed[o]||l.label,icon:l.icon||"ant-design:appstore-outlined",color:l.color||"#64748b",description:l.description??(r==null?void 0:r.description),inputs:(u==null?void 0:u.inputs)||l.inputs||(r==null?void 0:r.inputs)||[],outputs:(u==null?void 0:u.outputs)||l.outputs||(r==null?void 0:r.outputs)||[],defaultConfig:l.defaultConfig||l.default_config||{},configSchema:xN(l.configSchema,r==null?void 0:r.configSchema),executionTarget:l.executionTarget,capabilities:l.capabilities||[]})}Tv()}const wN=[{type:"rgb_camera",category:"input",label:"RGB Camera",icon:"ant-design:video-camera-outlined",color:st.input,description:"Single-view RGB camera input. Fisheye and other lens variants use this same device category.",inputs:[],outputs:[{key:"video",label:"RGB Video"}],defaultConfig:{position:"",source_key:"",fps:30}},{type:"mono_camera",category:"input",label:"RGB Camera",icon:"ant-design:video-camera-outlined",color:st.input,description:"Single-view RGB input (including fisheye and RGB-D color streams). Device name is optional; blank auto-detects the batch video.",inputs:[],outputs:[{key:"video",label:"RGB Video"}],defaultConfig:{source_key:"",fps:30}},{type:"rgbd_camera",category:"input",label:"RGB-D Camera",icon:"ant-design:video-camera-outlined",color:st.input,description:"RGB-D camera input. Select the physical device after its uploaded metadata is available; the depth stream is paired by the backend.",inputs:[],outputs:[{key:"video",label:"RGB Video"},{key:"depth",label:"Depth"}],defaultConfig:{source_key:"",fps:30}},{type:"fisheye_camera",category:"input",label:"RGB Camera",icon:"ant-design:video-camera-outlined",color:st.input,description:"Historical fisheye input alias. New workflows use Mono RGB with lens=fisheye.",inputs:[],outputs:[{key:"video",label:"RGB Video"}],defaultConfig:{position:"",source_key:"",fps:30}},{type:"stereo_camera",category:"input",label:"Stereo RGB Camera",icon:"ant-design:video-camera-outlined",color:st.input,description:"Stereo video capture (left + right). Device names optional — blank auto-detects the stereo pair. Connect either port once: both Left and Right edges are created together.",inputs:[],outputs:[{key:"video_left",label:"Left RGB Video"},{key:"video_right",label:"Right RGB Video"}],defaultConfig:{source_keys:"",source_key:"",fps:30}},{type:"stereo_rgbd_camera",category:"input",label:"Stereo RGB-D Camera",icon:"ant-design:video-camera-outlined",color:st.input,description:"Stereo RGB-D input with left/right RGB video and a real depth stream. Connect Depth to RGB-D 3D processing when metric 3D is required.",inputs:[],outputs:[{key:"video_left",label:"Left RGB Video"},{key:"video_right",label:"Right RGB Video"},{key:"depth",label:"Depth"}],defaultConfig:{source_keys:"",source_key:"",fps:30}},{type:"glove_sensor",category:"input",label:"Glove Sensor",icon:"ant-design:edit-outlined",color:st.input,description:"Glove sensor (pressure/joint data, no video). Connect its sensor data directly to AI Quality Review for sensor checks.",inputs:[],outputs:[{key:"sensor_data",label:"Glove Sensor Data"}],defaultConfig:{source_key:"",device:"SenseGlove",hand:"both",fps:60}},{type:"gripper_device",category:"input",label:"UMI Gripper",icon:"ant-design:robot-outlined",color:st.input,description:"Composite acquisition source. Publishes one gripper RGB video, ESP32 grip state, SLAM trajectory, and paired left/right 250×250×3 force matrices to downstream workflow nodes.",inputs:[],outputs:[{key:"rgb_video",label:"RGB Video"},{key:"gripper_state",label:"ESP Gripper State"},{key:"slam_trajectory",label:"SLAM Trajectory"},{key:"tactile_force_matrices",label:"Left and Right Force Matrices"}],defaultConfig:{source_key:"",fps:30}},{type:"mediapipe_hand",category:"process",label:"MediaPipe Hand",icon:"ant-design:aim-outlined",color:st.hand3d,description:"Skeleton detection. Accepts VIDEO input only (mono or stereo camera); glove sensor data cannot connect here.",inputs:[{key:"video",label:"RGB Video"}],outputs:[{key:"hand_keypoints",label:"Hand 2D"}],defaultConfig:{model_complexity:1,min_detection_conf:.5,min_tracking_conf:.5,max_hands:2}},{type:"annotation",category:"process",label:"Human Annotation",icon:"ant-design:field-time-outlined",color:st.annotation,description:"Frame-level annotation on RGB video. Glove sensor data is not an annotation input.",inputs:[{key:"data",label:"RGB Video"}],outputs:[{key:"annotation",label:"Annotation"}],defaultConfig:{type:"frame_level",auto_label:!0}},{type:"ai_annotation",category:"process",label:"AI Annotation",icon:"ant-design:robot-outlined",color:st.annotation,description:"AI-assisted annotation on RGB video. Glove sensor data is not an annotation input.",inputs:[{key:"data",label:"RGB Video"}],outputs:[{key:"annotation",label:"Annotation"}],defaultConfig:{mode:"signal_vlm",min_confidence:.7,prompt_language:"zh",max_segments:50,vlm_provider:"local",api_vendor:"kimi",api_model:"kimi-k3",api_key:"",api_base_url:""},configSchema:[{name:"prompt_language",type:"select",label:"Label language",default:"zh",options:["zh","en"]},{name:"vlm_provider",type:"select",label:"VLM provider",default:"local",options:["local","api"]},{name:"api_vendor",type:"select",label:"API vendor",default:"kimi",options:["kimi","qwen","siliconflow"]},{name:"api_model",type:"string",label:"API model",default:"kimi-k3"},{name:"api_base_url",type:"string",label:"API base URL",default:""}]},{type:"rgbd_to_3d_bare_hand",category:"process",label:"RGB-D_3D_BareHand",icon:"ant-design:deployment-unit-outlined",color:st.hand3d,description:"Metric 3D bare-hand keypoints from RGB video plus a matched depth stream.",inputs:[{key:"video",label:"RGB Video"},{key:"depth",label:"Depth"}],outputs:[{key:"hand_3d",label:"Hand 3D"}],defaultConfig:{mode:"auto"}},{type:"rgb_to_2d_bare_hand",category:"process",label:"RGB_TO_2D_BareHand",icon:"ant-design:deployment-unit-outlined",color:st.hand3d,description:"2D bare-hand keypoints from RGB video. The optional 3D view is display-only and is not exported as metric 3D.",inputs:[{key:"video",label:"RGB Video"}],outputs:[{key:"hand_keypoints",label:"Hand 2D"}],defaultConfig:{max_hands:2,min_detection_conf:.1,min_presence_conf:.1,min_tracking_conf:.5,device:"auto",smooth:!0,preview_3d:!0,freq_min:5,beta:.05}},{type:"rgbd_to_3d_black_glove",category:"process",label:"RGB-D_3D_BlackGlove",icon:"ant-design:aim-outlined",color:st.hand3d,description:"Metric 3D black-glove keypoints from RGB video plus a matched depth stream.",inputs:[{key:"video",label:"RGB Video"},{key:"depth",label:"Depth"}],outputs:[{key:"hand_3d",label:"Hand 3D"}],defaultConfig:{mode:"auto",max_hands:2,det_conf:.05,device:"auto",pose_device:"auto",imgsz:640,smooth:!0,preview_3d:!0,freq_min:5,beta:.05,movement_thresh:1.5,skip_timeout:3,box_alpha:.7,pose_conf_thr:.15,new_track_conf:.1,lost_timeout:8,hold_max:12,spawn_confirm:2,match_contain_thr:.7}},{type:"rgb_to_2d_black_glove",category:"process",label:"RGB_TO_2D_BlackGlove",icon:"ant-design:deployment-unit-outlined",color:st.hand3d,description:"2D black-glove keypoints from RGB video. The optional 3D view is display-only and is not exported as metric 3D.",inputs:[{key:"video",label:"RGB Video"}],outputs:[{key:"hand_keypoints",label:"Hand 2D"}],defaultConfig:{mode:"auto",max_hands:2,det_conf:.05,device:"auto",pose_device:"auto",imgsz:640,smooth:!0,preview_3d:!0,freq_min:5,beta:.05,movement_thresh:1.5,skip_timeout:3,box_alpha:.7,pose_conf_thr:.15,new_track_conf:.1,lost_timeout:8,hold_max:12,spawn_confirm:2,match_contain_thr:.7}},{type:"human_review",category:"review",label:"Human Review",icon:"ant-design:eye-outlined",color:st.review,description:"Human review gate. Accepts any upstream data; required review before export.",inputs:[{key:"data",label:"Review Target"}],outputs:[{key:"reviewed",label:"Reviewed Data"}],defaultConfig:{required:!0,reviewers:1}},{type:"data_quality",category:"review",label:"Data Cleaning",icon:"ant-design:check-circle-outlined",color:st.review,description:"Runs deterministic quality checks (video, UMI gripper, tactile glove) and sends failed batches back to manual review.",inputs:[{key:"data",label:"Data"}],outputs:[{key:"reviewed",label:"Reviewed Data"}],defaultConfig:{mode:"gate"}},{type:"lerobot_export",category:"export",label:"LeRobot Export",icon:"ant-design:cloud-server-outlined",color:st.export,description:"Export to LeRobot dataset format (v3.0 / v2.1). Accepts any upstream data.",inputs:[{key:"data",label:"Exportable Data"}],outputs:[{key:"dataset",label:"Dataset"}],defaultConfig:{version:"v3.0",split_ratio:.9,shard_size:1e5}},{type:"hdf5_export",category:"export",label:"HDF5 Export",icon:"ant-design:cloud-server-outlined",color:st.export,description:"Export to HDF5 dataset format. Accepts any upstream data.",inputs:[{key:"data",label:"Exportable Data"}],outputs:[{key:"dataset",label:"Dataset"}],defaultConfig:{compression:"gzip",level:4}}];wN.forEach(vN);const SN="lang",My="egodata:lang";function bo(){try{return localStorage.getItem(SN)==="zh"?"zh":"en"}catch{return"en"}}const EN={"palette.input":{en:"Input",zh:"输入"},"palette.review":{en:"Review",zh:"审核"},"palette.process":{en:"Process",zh:"处理"},"palette.export":{en:"Export",zh:"导出"},"palette.search":{en:"Search nodes...",zh:"搜索节点..."},"palette.hint":{en:"Drag nodes onto canvas",zh:"拖拽节点到画布"},"toolbar.new":{en:"New",zh:"新建"},"toolbar.save":{en:"Save",zh:"保存"},"toolbar.saveAs":{en:"Save As",zh:"另存为"},"toolbar.export":{en:"Export",zh:"导出"},"toolbar.workflowList":{en:"Workflow list",zh:"工作流列表"},"toolbar.run":{en:"Run",zh:"运行"},"common.cancel":{en:"Cancel",zh:"取消"},"common.save":{en:"Save",zh:"保存"},"common.loading":{en:"Loading...",zh:"加载中..."},"ai.vendor":{en:"API vendor",zh:"API 供应商"},"ai.model":{en:"API model",zh:"API 模型"},"ai.key":{en:"API key (stored with this workflow)",zh:"API Key（随本工作流保存）"},"ai.labelLanguage":{en:"Label language",zh:"标注语言"},"drawer.workflows":{en:"Workflows",zh:"工作流"},"drawer.noWorkflows":{en:"No workflows yet",zh:"暂无工作流"},"edge.delete":{en:"Delete connection",zh:"删除连线"},"node.projectOverride":{en:"Project override",zh:"项目级覆盖"},"node.saveForProject":{en:"Save for this project",zh:"仅保存到本项目"},"node.clearOverride":{en:"Clear project override",zh:"清除项目级覆盖"},"node.clear":{en:"Clear",zh:"清除"},"node.clearOverrideHint":{en:"Project override — click to clear",zh:"项目级覆盖 —— 点击清除"},"node.aiSettings":{en:"AI annotation settings",zh:"AI 标注设置"},"node.aiSettingsShort":{en:"Data quality settings",zh:"数据质检设置"},"ai.modelRequired":{en:"Model required",zh:"请先填写模型"},"ai.keyRequired":{en:"API key required",zh:"请先填写 API Key"},"ai.testFailed":{en:"Test failed",zh:"测试失败"},"ai.requestFailed":{en:"Request failed",zh:"请求失败"},"ai.networkError":{en:"network error",zh:"网络错误"},"ai.appliesNextRun":{en:"Applies to the next AI annotation run.",zh:"对下一次 AI 标注生效。"},"common.close":{en:"Close",zh:"关闭"},"toast.dupEdge":{en:"Already connected: this port pair is already linked.",zh:"已连接：这条端口对已经连过了。"},"toast.selfEdge":{en:"Self-connection is not allowed",zh:"不能连接到自身"},"toast.cannotConnect":{en:"Cannot connect: ",zh:"无法连接："},"toast.portMismatch":{en:"Port mismatch: this input expects different data.",zh:"端口类型不匹配：这个输入要的数据类型与上游输出不同。"},"toast.stereoPair":{en:"Stereo pair connected",zh:"双目已配对连接"},"quality.title":{en:"Data Cleaning · Settings",zh:"数据清洗 · 设置"},"quality.loadFailed":{en:"Failed to load the check catalog: ",zh:"加载检查项目录失败："},"quality.noDevice":{en:"This node has no device connected yet",zh:"该节点还没有连接任何设备"},"quality.noChecks":{en:"has no checks available yet",zh:"暂时没有可用的检查项"},"app.template":{en:"Template",zh:"模板"},"app.makeTemplate":{en:"Make Template",zh:"设为模板"},"app.save":{en:"Save",zh:"保存"},"app.del":{en:"Del",zh:"删除"},"app.cancel":{en:"Cancel",zh:"取消"},"app.newWorkflow":{en:"New Workflow",zh:"新建工作流"},"app.startFromTemplate":{en:"Start from Template",zh:"从模板开始"},"app.unsetTemplate":{en:"Unset Template",zh:"取消模板"},"app.noTemplates":{en:"No templates available — an admin can mark workflows as templates.",zh:"暂无模板 —— 管理员可将工作流标记为模板。"},"app.templateHint":{en:"Applying a template replaces the current canvas — your workflow name and ID stay the same.",zh:"应用模板会替换当前画布 —— 工作流名称与 ID 保持不变。"}};function Su(n,l){const o=EN[n];return o?o[l]||o.en:n}const NN={mono_camera:"RGB 相机",rgb_camera:"RGB 相机",fisheye_camera:"RGB 相机",rgbd_camera:"RGB-D 相机",stereo_camera:"双目 RGB 相机",stereo_rgbd_camera:"双目 RGB-D 相机",glove_sensor:"触觉手套",gripper_device:"UMI 夹爪",ai_annotation:"AI 标注",annotation:"人工标注",mediapipe_hand:"MediaPipe 手部",rgb_to_2d_bare_hand:"RGB_2D_裸手",rgb_to_2d_black_glove:"RGB_2D_黑手套",rgbd_to_3d_bare_hand:"RGB-D_3D_裸手",rgbd_to_3d_black_glove:"RGB-D_3D_黑手套",umi_slam_action:"UMI SLAM 动作",data_quality:"数据清洗",human_review:"人工审核",lerobot_export:"LeRobot 导出",hdf5_export:"HDF5 导出"},TN={"RGB Camera":"RGB 相机","Stereo RGB Camera":"双目 RGB 相机","RGB-D Camera":"RGB-D 相机","Stereo RGB-D Camera":"双目 RGB-D 相机","Glove Sensor":"触觉手套","UMI Gripper":"UMI 夹爪"};function nd(n,l,o){return o!=="zh"?l:NN[n]||TN[l]||l}const zy={"*:video":"RGB 视频","*:depth":"深度","*:video_left":"左目 RGB 视频","*:video_right":"右目 RGB 视频","*:rgb_video":"RGB 视频","*:gripper_state":"ESP 夹爪状态","*:slam_trajectory":"SLAM 轨迹","*:tactile_force_matrices":"左右力矩阵","*:sensor_data":"手套传感器数据","*:annotation":"标注","*:hand_keypoints":"手部 2D","*:hand_3d":"手部 3D","*:action":"动作","*:reviewed":"已审核数据","*:dataset":"数据集","data_quality:data":"数据","human_review:data":"待审核数据","lerobot_export:data":"可导出数据","hdf5_export:data":"可导出数据","ai_annotation:data":"RGB 视频","annotation:data":"RGB 视频"};function Ou(n,l,o,r){return r!=="zh"?o:zy[`${n}:${l}`]||zy[`*:${l}`]||o}function Ku(){const[n,l]=$.useState(bo);return $.useEffect(()=>{const o=()=>l(bo());return window.addEventListener(My,o),window.addEventListener("storage",o),()=>{window.removeEventListener(My,o),window.removeEventListener("storage",o)}},[]),n}function rl(){const n=Ku();return $.useMemo(()=>l=>Su(l,n),[n])}let AN=0;const wt=Ev((n,l)=>({toasts:[],pushToast:(o,r="info")=>{const u=++AN;n(f=>({toasts:[...f.toasts,{id:u,msg:o,type:r}]})),setTimeout(()=>l().removeToast(u),4e3)},removeToast:o=>n(r=>({toasts:r.toasts.filter(u=>u.id!==o)})),dialog:null,confirm:(o,r)=>new Promise(u=>{n({dialog:{kind:"confirm",title:(r==null?void 0:r.title)||"Confirm",message:o,confirmLabel:r==null?void 0:r.confirmLabel,danger:r==null?void 0:r.danger,resolve:f=>u(f)}})}),prompt:(o,r)=>new Promise(u=>{n({dialog:{kind:"prompt",title:(r==null?void 0:r.title)||"Input",message:o,defaultValue:r==null?void 0:r.defaultValue,confirmLabel:r==null?void 0:r.confirmLabel,resolve:f=>u(f)}})}),resolveDialog:o=>{const r=l().dialog;r&&(r.resolve(o),n({dialog:null}))}})),Df=30;let ad=1,pu=0,on=0;const zv="workflow_draft",Cv="egodata.workflow-list.v1",MN=60*1e3;function zN(){try{const n=JSON.parse(sessionStorage.getItem(Cv)||"null");return!n||!Array.isArray(n.workflows)||Date.now()-Number(n.savedAt||0)>MN?null:n.workflows}catch{return null}}function CN(n){try{sessionStorage.setItem(Cv,JSON.stringify({savedAt:Date.now(),workflows:n}))}catch{}}const Cy={rgbd_camera:"RGB-D Camera",stereo_rgbd_camera:"Stereo RGB-D Camera",mono_rgb:"RGB Camera",stereo_rgb:"Stereo RGB Camera",glove_sensor:"Glove Sensor",gripper_device:"UMI Gripper"},DN=new Set(["mono_camera","rgbd_camera","rgb_camera","fisheye_camera","stereo_camera","stereo_rgbd_camera","gripper_device"]);function kN(n){var o;const l=((o=n.data)==null?void 0:o.config)||{};return[l.source_key,l.source_keys,l.position].flatMap(r=>String(r||"").split(",")).map(r=>r.trim().toLowerCase()).filter(Boolean)}function RN(n,l){const o=kN(n);if(!o.length)return!1;const r=[l.name,l.display_name,l.source_key,...l.source_keys||[],...l.depth_keys||[]].map(u=>String(u||"").trim().toLowerCase()).filter(Boolean);return o.some(u=>r.includes(u))}function Dy(n,l){const o=l.device_sources||[];return o.length?n.map(r=>{var m;if(!DN.has((m=r.data)==null?void 0:m.nodeType))return r;const u=r.data;if(u.device_type&&Cy[String(u.device_type)])return r;const f=o.find(g=>RN(r,g)),d=(f==null?void 0:f.device_type)||(u.nodeType==="stereo_rgbd_camera"?"stereo_rgbd_camera":u.nodeType==="stereo_camera"?"stereo_rgb":u.nodeType==="rgbd_camera"?"rgbd_camera":"mono_rgb"),h=(f==null?void 0:f.display_name)||Cy[String(d)]||u.device_display_name;return{...r,data:{...u,device_type:d,device_display_name:h}}}):n}function Wl(n){try{const l={nodes:n.nodes,edges:n.edges,workflowId:n.workflowId,workflowProjectId:n.workflowProjectId,workflowName:n.workflowName,savedAt:Date.now()};localStorage.setItem(zv,JSON.stringify(l))}catch{}}function Fl(){try{localStorage.removeItem(zv)}catch{}}function bn(n){return JSON.parse(JSON.stringify(n))}function jN(n,l){if(!(n!=null&&n.length))return l||[];if(!(l!=null&&l.length))return n;const o=new Map(n.map(u=>[u.name,u])),r=l.filter(u=>!o.has(u.name));return r.length?[...n,...r]:n}function Dv(n){const l=new Map,o=(n.nodes||[]).map(h=>{var p;const m=((p=h.data)==null?void 0:p.nodeType)||"",g=wn(m);l.set(h.id,g);const v={...h.data,nodeType:g};return g==="rgbd_camera"?v.outputs=[{key:"video",label:"RGB Video"},{key:"depth",label:"Depth"}]:g==="stereo_rgbd_camera"?v.outputs=[{key:"video_left",label:"Left RGB Video"},{key:"video_right",label:"Right RGB Video"},{key:"depth",label:"Depth"}]:g==="gripper_device"?(v.inputs=[],v.outputs=[{key:"rgb_video",label:"RGB Video"},{key:"gripper_state",label:"ESP Gripper State"},{key:"slam_trajectory",label:"SLAM Trajectory"},{key:"tactile_force_matrices",label:"Left and Right Force Matrices"}]):g==="rgb_to_2d_bare_hand"||g==="rgb_to_2d_black_glove"?(v.inputs=[{key:"video",label:"RGB Video"}],v.outputs=[{key:"hand_keypoints",label:"Hand 2D"}]):(g==="rgbd_to_3d_bare_hand"||g==="rgbd_to_3d_black_glove")&&(v.inputs=[{key:"video",label:"RGB Video"},{key:"depth",label:"Depth"}],v.outputs=[{key:"hand_3d",label:"Hand 3D"}]),{...h,data:v}}),r=(n.edges||[]).map(h=>{const m=l.get(h.source)||"",g=String(h.sourceHandle||"");let v=g;const p=m==="annotation"||m==="ai_annotation"?"annotation":m==="human_review"||m==="data_quality"?"reviewed":"";return p&&g==="result"?v=p:m==="gripper_device"&&["tactile_left","tactile_right"].includes(g)?v="tactile_force_matrices":["rgb_to_2d_bare_hand","rgb_to_2d_black_glove"].includes(m)&&g.startsWith("hand_3d")?v=g.replace(/^hand_3d/,"hand_keypoints"):["rgbd_to_3d_bare_hand","rgbd_to_3d_black_glove"].includes(m)&&g.startsWith("hand_keypoints")&&(v=g.replace(/^hand_keypoints/,"hand_3d")),v===g?h:{...h,sourceHandle:v,id:h.id?String(h.id).replace(g,v):h.id}}),u=new Set,f=r.filter(h=>{if(l.get(h.source)!=="gripper_device"||h.sourceHandle!=="tactile_force_matrices")return!0;const m=`${h.source}|${h.sourceHandle}|${h.target}|${h.targetHandle||""}`;return u.has(m)?!1:(u.add(m),!0)}),d=new Set(f.map(h=>`${h.source}|${h.target}|${h.targetHandle||""}`));for(const h of[...f]){if(h.targetHandle!=="video"||!["rgbd_camera","stereo_rgbd_camera"].includes(l.get(h.source)||"")||!["rgbd_to_3d_bare_hand","rgbd_to_3d_black_glove"].includes(l.get(h.target)||""))continue;const m=`${h.source}|${h.target}|depth`;d.has(m)||(f.push({...h,id:`xy-edge__${h.source}depth-${h.target}depth`,sourceHandle:"depth",targetHandle:"depth"}),d.add(m))}return{nodes:o,edges:f}}function kv(n){var f,d;const l=wn(n.data.nodeType),o=Av(l);if(!o)return n;const r=new Set(["rgb_camera","mono_camera","rgbd_camera","fisheye_camera","stereo_camera","stereo_rgbd_camera","rgbd_to_3d_bare_hand","rgb_to_2d_bare_hand","rgbd_to_3d_black_glove","rgb_to_2d_black_glove","annotation","ai_annotation","human_review","lerobot_export","hdf5_export","gripper_device","data_quality"]),u=new Set(["rgb_camera","mono_camera","fisheye_camera","rgbd_camera","stereo_camera","stereo_rgbd_camera","glove_sensor","gripper_device","mediapipe_hand","annotation","ai_annotation","human_review","lerobot_export","hdf5_export","data_quality","rgbd_to_3d_bare_hand","rgb_to_2d_bare_hand","rgbd_to_3d_black_glove","rgb_to_2d_black_glove"]);return{...n,data:{...n.data,nodeType:l,label:r.has(l)?o.label:n.data.label||o.label,icon:n.data.icon||o.icon,color:r.has(l)?o.color:n.data.color||o.color,inputs:u.has(l)?o.inputs:(f=n.data.inputs)!=null&&f.length?n.data.inputs:o.inputs,outputs:u.has(l)?o.outputs:(d=n.data.outputs)!=null&&d.length?n.data.outputs:o.outputs,configSchema:jN(n.data.configSchema,o.configSchema),executionTarget:n.data.executionTarget||o.executionTarget}}}const fi=new Set(["data_quality"]);function zo(n,l){return`${n}:${l||""}`}function ON(n,l){const o=new Map((n||[]).map(r=>{var u;return[String(r.id),wn((u=r.data)==null?void 0:u.nodeType)]}));return(l||[]).map(r=>{if(!fi.has(o.get(String(r.target))||""))return r;const u=zo(String(r.source),r.sourceHandle);return r.targetHandle===u?r:{...r,targetHandle:u}})}function HN(n,l){var f;const o=l||[],r=new Map;for(const d of n||[])fi.has(wn((f=d.data)==null?void 0:f.nodeType))&&r.set(String(d.id),[]);if(!r.size)return o;for(const d of o){const h=r.get(String(d.target));if(!h)continue;const m=zo(String(d.source),d.sourceHandle);h.includes(m)||h.push(m)}const u=[];for(const d of o){const h=r.get(String(d.source));if(!h||h.length===0){u.push(d);continue}if(h.includes(String(d.sourceHandle??""))){u.push(d);continue}for(const m of h)u.push({...d,id:`${d.id}__${m}`,sourceHandle:m})}return u}function ld(n){const l=Dv(n);return{nodes:(l.nodes||[]).map(kv),edges:HN(l.nodes,ON(l.nodes,l.edges))}}function ky(n,l){const o=l.find(b=>b.id===n.source),r=l.find(b=>b.id===n.target);if(!o||!r)return!1;const u=o.data.outputs||[],f=r.data.inputs||[];if(!u.length||!f.length)return!0;const d=u.find(b=>b.key===(n.sourceHandle??u[0].key))||(u.length===1?u[0]:null),h=f.find(b=>b.key===(n.targetHandle??f[0].key))||(f.length===1?f[0]:null);if(!d||!h)return!0;const m=wn(r.data.nodeType),g=wn(o.data.nodeType);if((m==="annotation"||m==="ai_annotation")&&h.key==="data")return["video","video_left","video_right"].includes(d.key)&&g!=="glove_sensor";if(h.key==="data")return!0;if((m==="rgbd_to_3d_bare_hand"||m==="rgbd_to_3d_black_glove")&&h.key==="depth")return(g==="rgbd_camera"||g==="stereo_rgbd_camera")&&d.key==="depth";const p=["video","rgb_video","video_left","video_right"];return p.includes(h.key)&&p.includes(d.key)?!0:d.key===h.key}const Ee=Ev((n,l)=>({nodes:[],edges:[],workflowId:null,workflowProjectId:null,workflowName:"Untitled",workflowStatus:"draft",isDirty:!1,isSaving:!1,userRole:null,isPresetWorkflow:!1,referenceProjectId:null,referenceInputs:null,projectBindings:null,currentWorkflowBindings:{},globalInputs:null,inputsLoading:!1,inputsError:null,workflows:[],listLoading:!1,history:[],historyIndex:-1,pushHistory:()=>{const o=l(),r=[...o.history.slice(0,o.historyIndex+1)];r.push({nodes:bn(o.nodes),edges:bn(o.edges)}),r.length>Df&&r.shift(),n({history:r,historyIndex:r.length-1})},undo:()=>{const o=l();if(o.historyIndex<0)return;const r=o.history[o.historyIndex];r&&n({nodes:bn(r.nodes),edges:bn(r.edges),historyIndex:o.historyIndex-1,isDirty:!0})},redo:()=>{const o=l();if(o.historyIndex>=o.history.length-1)return;const r=o.history[o.historyIndex+1];r&&n({nodes:bn(r.nodes),edges:bn(r.edges),historyIndex:o.historyIndex+1,isDirty:!0})},onNodesChange:o=>n(r=>{if(o.some(d=>d.type==="remove"||d.type==="position"&&d.dragging===!0)){const d=[...r.history.slice(0,r.historyIndex+1)];d.push({nodes:bn(r.nodes),edges:bn(r.edges)}),d.length>Df&&d.shift();const h=Kf(o,r.nodes);return Wl({...r,nodes:h}),{nodes:h,isDirty:!0,history:d,historyIndex:d.length-1}}return{nodes:Kf(o,r.nodes),isDirty:r.isDirty}}),onEdgesChange:o=>n(r=>{if(o.some(d=>d.type==="remove"||d.type==="add")){const d=[...r.history.slice(0,r.historyIndex+1)];d.push({nodes:bn(r.nodes),edges:bn(r.edges)}),d.length>Df&&d.shift();const h=If(o,r.edges);return Wl({...r,edges:h}),{edges:h,isDirty:!0,history:d,historyIndex:d.length-1}}return{edges:If(o,r.edges),isDirty:r.isDirty}}),onConnect:o=>n(r=>{var p,b,x,_,T,z,A,R,S,D,H,j;if(o.source===o.target||!ky(o,r.nodes)){const k=r.nodes.find(P=>P.id===o.source),q=r.nodes.find(P=>P.id===o.target),Z=((x=(b=(p=q==null?void 0:q.data)==null?void 0:p.inputs)==null?void 0:b.find(P=>{var C,V,M;return P.key===(o.targetHandle||((M=(V=(C=q==null?void 0:q.data)==null?void 0:C.inputs)==null?void 0:V[0])==null?void 0:M.key))}))==null?void 0:x.label)||((z=(T=(_=q==null?void 0:q.data)==null?void 0:_.inputs)==null?void 0:T[0])==null?void 0:z.label)||"input",ie=(R=(A=k==null?void 0:k.data)==null?void 0:A.outputs)==null?void 0:R.find(P=>{var C,V,M;return P.key===(o.sourceHandle||((M=(V=(C=k==null?void 0:k.data)==null?void 0:C.outputs)==null?void 0:V[0])==null?void 0:M.key))}),J=P=>Su(P,bo()),ne=ie&&ie.key!=="data"?`${J("toast.portMismatch")} (${Z} ← ${ie.label||ie.key})`:J("toast.selfEdge");return wt.getState().pushToast(`${J("toast.cannotConnect")}${ne}`,"error"),r}const u=wn(((D=(S=r.nodes.find(k=>k.id===o.target))==null?void 0:S.data)==null?void 0:D.nodeType)??""),f=fi.has(u)?{...o,targetHandle:zo(o.source,o.sourceHandle)}:o,d=k=>r.edges.some(q=>q.source===k.source&&q.target===k.target&&(q.sourceHandle||null)===(k.sourceHandle||null)&&(q.targetHandle||null)===(k.targetHandle||null));if(d(f))return wt.getState().pushToast(Su("toast.dupEdge",bo()),"error"),r;let h=Jf(f,r.edges);const m=r.nodes.find(k=>k.id===o.source),g=((H=m==null?void 0:m.data)==null?void 0:H.outputs)||[];if(((j=m==null?void 0:m.data)==null?void 0:j.nodeType)==="stereo_camera"||g.some(k=>k.key==="video_left")&&g.some(k=>k.key==="video_right")){const k=o.sourceHandle||"video_left",q=k==="video_left"?"video_right":"video_left",Z={...f,sourceHandle:q,...fi.has(u)?{targetHandle:zo(o.source,q)}:{}};!d(Z)&&ky(Z,r.nodes)&&(h=Jf(Z,h),wt.getState().pushToast(`${Su("toast.stereoPair",bo())}: ${k} + ${q}`,"info"))}return Wl({...r,edges:h}),{edges:h,isDirty:!0}}),setNodes:o=>{const r=l();Wl({...r,nodes:o}),n({nodes:o,isDirty:!0})},setEdges:o=>{const r=l();Wl({...r,edges:o}),n({edges:o,isDirty:!0})},setUserRole:o=>n({userRole:o}),loadReferenceInputs:async o=>{const r=++on;n({inputsLoading:!0,inputsError:null});const u=fN(o).catch(()=>null);try{const f=await cN(o);if(r!==on)return;const d=Dy(l().nodes,f);n({nodes:d,workflowProjectId:o,referenceProjectId:o,referenceInputs:f,globalInputs:null,inputsLoading:!1,inputsError:null})}catch(f){if(r!==on)return;n({referenceInputs:null,referenceProjectId:null,globalInputs:null,inputsLoading:!1,inputsError:f instanceof Error?f.message:"Failed to load project inputs"});return}if(r===on)try{const f=await u;if(r!==on||!f)return;const d=l(),h=f.workflow_bindings||null;n({projectBindings:h,currentWorkflowBindings:(h||{})[d.workflowId||""]||{}})}catch{}},loadInputsForWorkflow:async o=>{const r=l(),u=o||r.workflowProjectId;u?(n({workflowProjectId:u}),await l().loadReferenceInputs(u)):(++on,n({referenceInputs:{has_episodes:!1,camera_names:[],devices:[],device_sources:[],sensors:[],modules:[]},globalInputs:null,referenceProjectId:null,inputsLoading:!1,inputsError:null}))},setProjectBinding:async(o,r)=>{const u=l(),f=u.referenceProjectId,d=u.workflowId;if(!(!f||!d))try{const m=(await dN(f,{workflow_id:d,node_id:o,source_key:r})).workflow_bindings||null;n({projectBindings:m,currentWorkflowBindings:(m||{})[d]||{}})}catch(h){throw console.error("set binding failed",h),h}},loadGlobalInputs:async()=>{const o=++on;n({inputsLoading:!0,inputsError:null});try{const r=await hN();if(o!==on)return;const u=Dy(l().nodes,r);n({nodes:u,globalInputs:r,referenceInputs:null,referenceProjectId:null,inputsLoading:!1,inputsError:null})}catch(r){if(o!==on)return;n({globalInputs:null,referenceInputs:null,referenceProjectId:null,inputsLoading:!1,inputsError:r instanceof Error?r.message:"Failed to load device inputs"})}},newWorkflow:()=>{++pu,++on,Fl(),n({nodes:[],edges:[],workflowId:null,workflowProjectId:null,workflowName:"Untitled",workflowStatus:"draft",isDirty:!1,isPresetWorkflow:!1,currentWorkflowBindings:{},referenceProjectId:null,referenceInputs:null,globalInputs:null,projectBindings:null,inputsLoading:!1,inputsError:null,history:[],historyIndex:-1})},newWorkflowFromTemplate:async o=>{const u=(await Ff(o.id)).graph||{nodes:[],edges:[]},f=Dv(u),d=(f.nodes||[]).map(kv).map(g=>({...g,selected:!1,dragging:!1})),h=f.edges||[],m=l();n({nodes:d,edges:h,workflowId:m.workflowId,workflowName:m.workflowId?m.workflowName:o.name||"Workflow",workflowStatus:m.workflowStatus,isDirty:!0,isPresetWorkflow:!1,currentWorkflowBindings:{}}),Wl(l())},loadWorkflowList:async()=>{n({listLoading:!0});const o=zN();o&&n({workflows:o});try{const r=await oN(100);CN(r.workflows),n({workflows:r.workflows})}catch{}n({listLoading:!1})},loadWorkflow:async o=>{const r=++pu;++on,n({inputsLoading:!0,inputsError:null});let u;try{u=await Ff(o)}catch(h){throw r===pu&&n({inputsLoading:!1,inputsError:h instanceof Error?h.message:"Failed to load workflow"}),h}if(r!==pu)return;const f=ld(u.graph||{nodes:[],edges:[]}),d=f.nodes;if(d.length>0){let h=0;for(const m of d){const g=m.id.match(/^node_(\d+)$/);g&&(h=Math.max(h,parseInt(g[1],10)))}h>=ad&&(ad=h+1)}Fl(),n({nodes:d,edges:f.edges,workflowId:u.id,workflowProjectId:u.project_id||null,workflowName:u.name,workflowStatus:u.status,isDirty:!1,isPresetWorkflow:!!u.is_preset,referenceProjectId:null,referenceInputs:null,globalInputs:null,projectBindings:null,currentWorkflowBindings:{},inputsLoading:!0,inputsError:null,history:[],historyIndex:-1})},saveWorkflow:async()=>{const o=l();if(o.isSaving)return;n({isSaving:!0});const r={nodes:o.nodes,edges:o.edges};try{if(o.workflowId)await Pf(o.workflowId,{name:o.workflowName,project_id:o.workflowProjectId,graph:r,status:"active"}),n({workflowStatus:"active"});else{const u=await Cf({name:o.workflowName,project_id:o.workflowProjectId,graph:r,status:"active"});n({workflowId:u.id,workflowProjectId:u.project_id||o.workflowProjectId,workflowStatus:u.status})}Fl(),n({isSaving:!1,isDirty:!1})}catch(u){console.error(u),n({isSaving:!1})}},saveWorkflowSafe:async()=>{const o=l();if(o.isPresetWorkflow&&o.userRole!=="admin")return"needs-save-as";if(o.isSaving)return"saved";n({isSaving:!0});const r={nodes:o.nodes,edges:o.edges};try{if(o.workflowId)await Pf(o.workflowId,{name:o.workflowName,project_id:o.workflowProjectId,graph:r,status:"active"}),n({workflowStatus:"active"});else{const u=await Cf({name:o.workflowName,project_id:o.workflowProjectId,graph:r,status:"active"});n({workflowId:u.id,workflowProjectId:u.project_id||o.workflowProjectId,workflowStatus:u.status})}return Fl(),n({isSaving:!1,isDirty:!1}),"saved"}catch(u){n({isSaving:!1});const f=u instanceof Error?u.message:String(u);if(/preset/i.test(f)||/403/.test(f))return"needs-save-as";throw u}},saveWorkflowAs:async o=>{const r=l();n({isSaving:!0,workflowName:o,workflowId:null});const u={nodes:r.nodes,edges:r.edges};try{const f=await Cf({name:o,project_id:null,graph:u,status:"active"});Fl(),n({workflowId:f.id,workflowProjectId:f.project_id||null,workflowStatus:f.status,isSaving:!1,isDirty:!1,isPresetWorkflow:!1})}catch(f){console.error(f),n({isSaving:!1})}}}));function BN(){const n=Ee.getState().nodes;let l;do l=`node_${ad++}`;while(n.some(o=>o.id===l));return l}function Co({icon:n,className:l,style:o}){return $.createElement("iconify-icon",{icon:n,class:l,style:o})}const kf={kimi:["kimi-k3"],qwen:["qwen3.8-max","qwen3.7-plus","qwen3.7-flash","qwen3-vl-plus","qwen3-vl-32b-thinking","qwen3.5-flash","qwen3.5-omni-flash","kimi-k2.6"],siliconflow:["Qwen/Qwen3-VL-30B-A3B-Instruct","Qwen/Qwen3-VL-30B-A3B-Thinking","Qwen/Qwen3.5-397B-A17B","Qwen/Qwen3.5-122B-A10B","Qwen/Qwen3.6-35B-A3B","Qwen/Qwen3.6-27B","Qwen/Qwen3-Omni-30B-A3B-Instruct","Qwen/Qwen3-Omni-30B-A3B-Thinking","zai-org/GLM-4.5V","Pro/moonshotai/Kimi-K2.6","MiniMaxAI/MiniMax-M2.5"]},Rf={kimi:"https://api.moonshot.ai/v1",qwen:"https://dashscope.aliyuncs.com/compatible-mode/v1",siliconflow:"https://api.siliconflow.cn/v1"};let LN=0;const id=()=>++LN;function UN(n){const l=n||{},o=l.api_providers;return Array.isArray(o)&&o.length?o.map(r=>{const u=r||{};return{id:id(),vendor:String(u.vendor||"kimi"),model:String(u.model||""),key:String(u.key||""),baseUrl:String(u.base_url||"")}}):[{id:id(),vendor:String(l.api_vendor||"kimi"),model:String(l.api_model||""),key:String(l.api_key||""),baseUrl:String(l.api_base_url||"")}]}function GN({nodeId:n,onClose:l}){var Y;const o=rl(),r=Ee(U=>U.nodes.find(E=>E.id===n)),u=r==null?void 0:r.data,f=(u==null?void 0:u.configSchema)||[],d=f.find(U=>U.name==="api_vendor"),h=f.find(U=>U.name==="api_model"),m=f.find(U=>U.name==="api_base_url"),g=f.find(U=>U.name==="prompt_language"),[v,p]=$.useState(()=>UN(u==null?void 0:u.config)),[b,x]=$.useState(()=>{var U;return((U=v[0])==null?void 0:U.id)??0}),[_,T]=$.useState(!1),[z,A]=$.useState(null),[R,S]=$.useState(()=>{var E;return String(((E=u==null?void 0:u.config)==null?void 0:E.prompt_language)||(g==null?void 0:g.default)||"zh").toLowerCase()==="en"?"en":"zh"});$.useEffect(()=>{const U=E=>{E.key==="Escape"&&(E.stopPropagation(),E.preventDefault(),l())};return window.addEventListener("keydown",U,!0),()=>window.removeEventListener("keydown",U,!0)},[l]);const D=v.find(U=>U.id===b)||v[0],H=(D==null?void 0:D.vendor)??"kimi",j=(D==null?void 0:D.model)??"",k=(D==null?void 0:D.key)??"",q=(D==null?void 0:D.baseUrl)??"",Z=Array.from(new Set([...(d==null?void 0:d.options)||[],"kimi","qwen","siliconflow"])),ie=U=>{p(E=>E.map(O=>O.id===b?{...O,...U}:O)),A(null)},J=U=>{const E=kf[U]||[],O=new Set(Object.values(Rf)),W={vendor:U};E.length&&!E.includes(j)&&(W.model=E[0]),(!q||O.has(q))&&(W.baseUrl=Rf[U]||""),ie(W)},ne=()=>{const U={id:id(),vendor:"kimi",model:kf.kimi[0]||"",key:"",baseUrl:""};p(E=>[...E,U]),x(U.id),A(null)},P=()=>{if(v.length<=1)return;const U=v.filter(E=>E.id!==b);p(U),x(U[0].id),A(null)},C=()=>A(null),V=async()=>{if(!_){if(!j.trim()){A({ok:!1,message:o("ai.modelRequired")});return}if(!k.trim()){A({ok:!1,message:o("ai.keyRequired")});return}T(!0),A(null);try{const U=await fetch("/api/v1/ai-annotation/test-connection",{method:"POST",credentials:"include",headers:{"Content-Type":"application/json"},body:JSON.stringify({api_vendor:H.trim()||"kimi",api_model:j.trim(),api_key:k.trim(),api_base_url:q.trim()})}),E=await U.json().catch(()=>({}));A({ok:U.ok&&E.ok===!0,message:String(E.message||(U.ok?o("ai.testFailed"):`${o("ai.requestFailed")} (${U.status})`))})}catch(U){A({ok:!1,message:`Request failed: ${U instanceof Error?U.message:o("ai.networkError")}`})}finally{T(!1)}}},M=()=>{const U=v.map(O=>({vendor:O.vendor.trim()||"kimi",model:O.model.trim(),key:O.key.trim(),base_url:O.baseUrl.trim()})),E=U[0]||{vendor:"kimi",model:"",key:"",base_url:""};Ee.setState(O=>({nodes:O.nodes.map(W=>W.id===n?{...W,data:{...W.data,config:{...W.data.config||{},api_providers:U,api_vendor:E.vendor,api_model:E.model,api_key:E.key,api_base_url:E.base_url,prompt_language:R==="en"?"en":"zh"}}}:W),isDirty:!0})),l()},B=kf[H]||(h==null?void 0:h.options)||[],X=j&&!B.includes(j)?[j,...B]:B;return Ed.createPortal(N.jsxs("div",{className:"modal-portal flex items-center justify-center",children:[N.jsx("div",{className:"absolute inset-0 bg-black/60",onClick:l}),N.jsxs("div",{className:"relative w-96 bg-gray-900 border border-gray-700 rounded-lg shadow-2xl",children:[N.jsxs("div",{className:"flex items-center justify-between px-4 py-3 border-b border-gray-800",children:[N.jsx("h3",{className:"text-sm font-semibold text-gray-200",children:"AI Annotation · Settings"}),N.jsx("button",{onClick:l,"aria-label":"Close",className:"text-gray-500 hover:text-gray-300 text-base leading-none",children:"✕"})]}),N.jsxs("div",{className:"p-4 space-y-3",children:[N.jsxs("label",{className:"block",children:[N.jsx("span",{className:"text-xs text-gray-400",children:o("ai.labelLanguage")}),N.jsxs("select",{"aria-label":"Label language",value:R,onChange:U=>S(U.target.value==="en"?"en":"zh"),className:"mt-1 w-full bg-gray-800 border border-gray-700 rounded px-2 py-1.5 text-sm text-gray-200",children:[N.jsx("option",{value:"zh",children:"中文"}),N.jsx("option",{value:"en",children:"English"})]}),N.jsx("span",{className:"mt-1 block text-[10px] text-gray-500",children:o("ai.appliesNextRun")})]}),String(((Y=u==null?void 0:u.config)==null?void 0:Y.vlm_provider)||"local")==="local"&&N.jsx("div",{className:"rounded border border-gray-800 bg-gray-950/50 px-2.5 py-2 text-[10px] text-gray-500",children:"Local VLM selected. Language setting is shared with API mode."}),N.jsxs("div",{className:"flex items-center gap-1.5",children:[N.jsx("select",{value:b,onChange:U=>{x(Number(U.target.value)),C()},className:"flex-1 min-w-0 bg-gray-800 border border-gray-700 rounded px-2 py-1.5 text-sm text-gray-200",children:v.map((U,E)=>N.jsx("option",{value:U.id,children:`#${E+1} · ${U.vendor}${U.model?` · ${U.model}`:""}`},U.id))}),N.jsx("button",{onClick:ne,title:"Add API",className:"shrink-0 text-xs px-2 py-1.5 rounded border border-dashed border-gray-600 text-gray-400 hover:text-gray-200 hover:border-gray-400",children:"+"}),N.jsx("button",{onClick:P,disabled:v.length<=1,title:"Remove this API",className:"shrink-0 text-xs px-2 py-1.5 rounded border border-gray-700 text-gray-500 hover:text-red-400 hover:border-red-800 disabled:opacity-30",children:"✕"})]}),N.jsxs("label",{className:"block",children:[N.jsx("span",{className:"text-xs text-gray-400",children:o("ai.vendor")}),N.jsx("select",{value:H,onChange:U=>J(U.target.value),className:"mt-1 w-full bg-gray-800 border border-gray-700 rounded px-2 py-1.5 text-sm text-gray-200",children:Z.map(U=>N.jsx("option",{value:U,children:U},U))})]}),N.jsxs("label",{className:"block",children:[N.jsx("span",{className:"text-xs text-gray-400",children:o("ai.model")}),N.jsx("select",{value:j,onChange:U=>{ie({model:U.target.value})},className:"mt-1 w-full bg-gray-800 border border-gray-700 rounded px-2 py-1.5 text-sm text-gray-200",children:X.length?X.map(U=>N.jsx("option",{value:U,children:U},U)):N.jsx("option",{value:j,children:j})})]}),N.jsxs("label",{className:"block",children:[N.jsx("span",{className:"text-xs text-gray-400",children:o("ai.key")}),N.jsx("input",{type:"password",value:k,onChange:U=>ie({key:U.target.value}),autoComplete:"new-password",placeholder:"sk-...",className:"mt-1 w-full bg-gray-800 border border-gray-700 rounded px-2 py-1.5 text-sm text-gray-200"})]}),N.jsxs("label",{className:"block",children:[N.jsx("span",{className:"text-xs text-gray-400",children:"API base URL (blank = official default)"}),N.jsx("input",{type:"text",value:q,onChange:U=>ie({baseUrl:U.target.value}),placeholder:String((m==null?void 0:m.default)||Rf[H]||""),className:"mt-1 w-full bg-gray-800 border border-gray-700 rounded px-2 py-1.5 text-sm text-gray-200"})]}),z&&N.jsxs("div",{className:`rounded px-2.5 py-2 text-xs ${z.ok?"border border-green-800 bg-green-950/40 text-green-300":"border border-red-800 bg-red-950/40 text-red-300"}`,children:[N.jsx("span",{className:"mr-1",children:z.ok?"✓":"✕"}),z.message]})]}),N.jsxs("div",{className:"flex justify-end gap-2 px-4 py-3 border-t border-gray-800",children:[N.jsx("button",{onClick:l,className:"text-xs px-3 py-1.5 rounded bg-gray-800 hover:bg-gray-700 text-gray-300",children:o("common.cancel")}),N.jsx("button",{onClick:V,disabled:_,className:"text-xs px-3 py-1.5 rounded border border-cyan-700 bg-cyan-950/40 hover:bg-cyan-900/60 text-cyan-300 disabled:opacity-50",children:_?"Testing…":"Test Connection"}),N.jsx("button",{onClick:M,className:"text-xs px-3 py-1.5 rounded bg-blue-600 hover:bg-blue-500 text-white",children:o("common.save")})]})]})]}),document.body)}const qN="/api/v1/quality";function YN(){return Vt(`${qN}/checks`)}const VN={tolerance_ratio:{label:"Tolerance ratio",zh:"容差比例",step:.001},tolerance_min:{label:"Tolerance floor",zh:"容差下限",unit:"frames"},min_sec:{label:"Min duration",zh:"最短时长",unit:"s",step:.1},fail_sec:{label:"Fail duration",zh:"判失败时长",unit:"s",step:.5},fail_ratio:{label:"Fail ratio",zh:"失败占比阈值",step:.01},max_errors:{label:"Allowed error frames",zh:"允许错误帧数"},max_linear_mps:{label:"Max linear speed",zh:"线速度上限",unit:"m/s",step:.1},max_angular_rps:{label:"Max angular speed",zh:"角速度上限",unit:"rad/s",step:1},warn_jumps:{label:"Warn jump count",zh:"警告跳变数",unit:"jumps"},fail_jumps:{label:"Fail jump count",zh:"失败跳变数",unit:"jumps"},warn_ratio:{label:"Warn ratio",zh:"警告占比",step:.01},fail_ratio_ratio:{label:"Fail ratio",zh:"失败占比",step:.01},max_out_of_range_ratio:{label:"Max out-of-range ratio",zh:"越界占比上限",step:.01},max_force_drift:{label:"Force drift limit",zh:"力漂移阈值",unit:"mN",step:10},min_coverage:{label:"Min coverage",zh:"覆盖率下限",step:.01},zero_epsilon:{label:"Zero epsilon",zh:"零判定容差"},tolerance:{label:"Tolerance",zh:"容差",unit:"frames"},expected_size:{label:"Array width",zh:"阵列维度"},max_bad_ratio:{label:"Max malformed ratio",zh:"不合格帧占比",step:.01},min_contact_value:{label:"Contact floor",zh:"接触门限",step:50},warn_frames:{label:"Warn frozen frames",zh:"警告静止帧数",unit:"frames",step:10},fail_frames:{label:"Fail frozen frames",zh:"失败静止帧数",unit:"frames",step:50},min_active_ratio:{label:"Min active ratio",zh:"最低活跃占比",step:.01}},XN={frames:"帧",s:"秒",jumps:"处"};function QN(n,l){const o=VN[n];return o?{...o,label:l==="zh"?o.zh??o.label:o.label,unit:o.unit&&l==="zh"?XN[o.unit]??o.unit:o.unit}:{label:n,unit:void 0,step:void 0}}function $N(n,l,o){var h;const r=new Map(l.map(m=>[m.id,m])),u=new Set,f=[],d=o.filter(m=>m.target===n).map(m=>m.source);for(;d.length;){const m=d.shift();if(!m||u.has(m))continue;u.add(m);const g=r.get(m);if(!g)continue;const v=String(((h=g.data)==null?void 0:h.nodeType)??"");if(["mono_camera","stereo_camera","rgb_camera","rgbd_camera","stereo_rgbd_camera","glove_sensor","gripper_device","fisheye_camera"].includes(v)){f.push(v);continue}for(const p of o)p.target===m&&d.push(p.source)}return f}const ZN={mono_camera:"mono_rgb",stereo_camera:"stereo_rgb",rgb_camera:"mono_rgb",fisheye_camera:"mono_rgb"};function KN({nodeId:n,onClose:l}){const o=rl(),r=Ku(),u=Ee(H=>H.nodes),f=Ee(H=>H.edges),d=u.find(H=>H.id===n),[h,m]=$.useState(null),[g,v]=$.useState(null),[p,b]=$.useState(()=>{var H;return((H=d==null?void 0:d.data)==null?void 0:H.config)??{}}),[x,_]=$.useState(""),T=$.useMemo(()=>{const j=$N(n,u,f).map(k=>ZN[k]??k);return Array.from(new Set(j))},[n,u,f]);$.useEffect(()=>{YN().then(H=>{m(H);const j=T.find(k=>(H.by_device[k]??[]).length);_(k=>k||j||T[0]||"")}).catch(H=>v(String((H==null?void 0:H.message)??H)))},[T]),$.useEffect(()=>{const H=j=>{j.key==="Escape"&&(j.stopPropagation(),j.preventDefault(),l())};return window.addEventListener("keydown",H,!0),()=>window.removeEventListener("keydown",H,!0)},[l]);const z=H=>{if(!h)return[];const j=h.by_device[H]??[];return h.checks.filter(k=>j.includes(k.slug))},A=(H,j)=>{var k,q,Z;return((Z=(q=(k=p.devices)==null?void 0:k[H])==null?void 0:q.checks)==null?void 0:Z[j])??{}},R=(H,j,k)=>{b(q=>{var Z,ie,J;return{devices:{...q.devices??{},[H]:{...((Z=q.devices)==null?void 0:Z[H])??{},checks:{...((J=(ie=q.devices)==null?void 0:ie[H])==null?void 0:J.checks)??{},[j]:{...A(H,j),...k}}}}}})},S=()=>{Ee.setState(H=>({nodes:H.nodes.map(j=>j.id===n?{...j,data:{...j.data,config:{...j.data.config,...p}}}:j)})),l()},D=H=>{var k;const j={};for(const q of H)(j[k=q.category]??(j[k]=[])).push(q);return j};return Ed.createPortal(N.jsx("div",{className:"modal-portal flex items-center justify-center bg-black/60",onClick:l,children:N.jsxs("div",{className:`w-[min(880px,92vw)] max-h-[85vh] overflow-hidden rounded-lg border border-gray-700
+                      bg-[#0f172a] text-gray-200 shadow-2xl flex flex-col`,onClick:H=>H.stopPropagation(),children:[N.jsxs("div",{className:"flex items-center justify-between border-b border-gray-700 px-4 py-2",children:[N.jsx("span",{className:"text-sm font-medium",children:o("quality.title")}),N.jsx("button",{onClick:l,className:"text-gray-400 hover:text-gray-200",children:"✕"})]}),N.jsxs("div",{className:"flex gap-1 border-b border-gray-700 px-3 pt-2",children:[T.length===0&&N.jsx("span",{className:"px-2 py-1 text-xs text-gray-500",children:o("quality.noDevice")}),T.map(H=>{const j=z(H).length,k=H===x;return N.jsxs("button",{onClick:()=>_(H),className:`rounded-t border-b-2 px-3 py-1.5 text-xs transition-colors ${k?"border-cyan-400 bg-cyan-900/20 text-cyan-300":"border-transparent text-gray-400 hover:text-gray-200"}`,children:[(h==null?void 0:h.device_labels[H])??H,j>0&&N.jsx("span",{className:"ml-1 text-[10px] opacity-60",children:j})]},H)})]}),N.jsxs("div",{className:"dark-scroll min-h-0 flex-1 overflow-y-auto px-3 py-2",children:[g&&N.jsxs("div",{className:"text-xs text-red-400",children:[o("quality.loadFailed"),g]}),!h&&!g&&N.jsx("div",{className:"text-xs text-gray-500",children:o("common.loading")}),h&&x&&N.jsxs(N.Fragment,{children:[z(x).length===0&&N.jsxs("div",{className:"text-xs text-gray-500",children:[h.device_labels[x]??x," ",o("quality.noChecks")]}),Object.entries(D(z(x))).map(([H,j])=>N.jsxs("div",{className:"mb-1.5",children:[N.jsx("div",{className:"px-1 pb-0.5 pt-1.5 text-[10px] uppercase tracking-wider text-gray-500",children:H}),j.map(k=>{const q=A(x,k.slug),Z=q.enabled!==!1;return N.jsxs("div",{className:"flex items-center gap-2 rounded px-1 py-[3px] hover:bg-white/[0.04]",children:[N.jsx("input",{type:"checkbox",checked:Z,className:"shrink-0",onChange:ie=>R(x,k.slug,{enabled:ie.target.checked})}),N.jsx("span",{className:"w-[104px] shrink-0 truncate text-xs text-gray-200",title:k.description?`${k.label} — ${k.description}`:k.label,children:k.label}),N.jsx("div",{className:"flex min-w-0 flex-1 flex-wrap items-center gap-x-2.5 gap-y-1",children:Z&&Object.entries(k.default_params).map(([ie,J])=>{var C;const ne=QN(ie,r),P=((C=q.params)==null?void 0:C[ie])??J;return N.jsxs("label",{title:ie,className:"flex items-center gap-1 text-[10px] text-gray-400",children:[ne.label,N.jsx("input",{type:"number",className:"w-[68px] rounded border border-gray-700 bg-gray-900 px-1 py-0.5 text-right text-gray-200",value:P,step:ne.step??1,onChange:V=>R(x,k.slug,{params:{...q.params??{},[ie]:Number(V.target.value)}})}),ne.unit&&N.jsx("span",{className:"text-gray-600",children:ne.unit})]},ie)})}),N.jsx("span",{className:"w-[104px] shrink-0 truncate text-right text-[10px] text-gray-600",title:k.slug,children:k.slug})]},k.slug)})]},H))]})]}),N.jsxs("div",{className:"flex justify-end gap-2 border-t border-gray-700 px-4 py-2",children:[N.jsx("button",{onClick:l,className:"rounded border border-gray-700 px-3 py-1 text-xs text-gray-300",children:o("common.cancel")}),N.jsx("button",{onClick:S,className:"rounded border border-cyan-700 bg-cyan-900/40 px-3 py-1 text-xs text-cyan-200",children:o("common.save")})]})]})}),document.body)}const IN=["mono_camera","rgbd_camera","rgb_camera","fisheye_camera","stereo_camera","stereo_rgbd_camera"],Rv=[...IN,"gripper_device"],JN=["rgbd_to_3d_bare_hand","rgbd_to_3d_black_glove"],Ta={rgbd_camera:"RGB-D Camera",stereo_rgbd_camera:"Stereo RGB-D Camera",mono_rgb:"RGB Camera",stereo_rgb:"Stereo RGB Camera",glove_sensor:"Glove Sensor",gripper_device:"UMI Gripper"};function WN(n){if(n.nodeType==="stereo_rgbd_camera")return Ta.stereo_rgbd_camera;if(n.nodeType==="stereo_camera")return Ta.stereo_rgb;if(n.nodeType==="rgbd_camera")return Ta.rgbd_camera;if(n.nodeType==="mono_camera"||n.nodeType==="rgb_camera"||n.nodeType==="fisheye_camera")return Ta.mono_rgb;if(n.nodeType==="gripper_device")return Ta.gripper_device;const l=n.device_type?Ta[String(n.device_type)]:"";if(l)return l;const o=String(n.device_display_name||"");return Object.values(Ta).includes(o)?o:Ta.mono_rgb}function jv(n,l,o,r,u=0){var p,b;const f=String(o??""),d=n.get(l);if(!d||u>8)return f;const h=String(((p=d.data)==null?void 0:p.nodeType)??""),m=((b=d.data)==null?void 0:b.outputs)||[],g=m.find(x=>x.key===f);if(g)return Ou(h,g.key,g.label,r);if(fi.has(h)&&f.includes(":")){const x=f.indexOf(":");if(n.has(f.slice(0,x)))return jv(n,f.slice(0,x),f.slice(x+1),r,u+1)}const v=m.length===1?m[0]:null;return Ou(h,(v==null?void 0:v.key)||f,(v==null?void 0:v.label)||f,r)}function FN(n,l,o){const r=Ee(u=>{if(!l)return"";const f=u.edges.filter(g=>g.target===n);if(!f.length)return"";const d=new Set,h=[],m=new Map(u.nodes.map(g=>[String(g.id),g]));for(const g of f){const v=zo(String(g.source),g.sourceHandle);if(d.has(v))continue;d.add(v);const p=String(g.source);h.push([v,m.has(p)?jv(m,p,g.sourceHandle,o):v])}return JSON.stringify(h)});return $.useMemo(()=>r?JSON.parse(r):[],[r])}const PN=$.memo(function({data:l,selected:o,id:r}){var ee,se,de,pe,we;const u=l,f=fi.has(String(u.nodeType)),d=rl(),h=Ku(),m=FN(r,f,h),g=u.color||"#475569",v=Rv.includes(u.nodeType),p=(ee=Av(u.nodeType))==null?void 0:ee.description,b=aT(u),x=Ee(he=>he.currentWorkflowBindings[r]),T=Ee(he=>he.referenceInputs),z=T!==null,A=JN.includes(u.nodeType),R=!!x&&(!!x.source_key||!!x.source_keys),S=R?x.source_key??x.source_keys??"":"",D=(b==null?void 0:b.name)==="source_key"?R?S:((se=u.config)==null?void 0:se.source_key)??((de=u.config)==null?void 0:de.position)??b.default??"":((pe=u.config)==null?void 0:pe[(b==null?void 0:b.name)||""])??(b==null?void 0:b.default)??"",[H,j]=$.useState(null),k=R?H??S:D,q=nd(String(u.nodeType),v?WN(u):u.label,h),Z=v&&z?eT(k,T,u.nodeType,u.device_type):"",ie=v&&z?tT(T,u.nodeType,u.device_type):[],J=A&&z?nT(T):[],ne=String(((we=u.config)==null?void 0:we.depth_camera)||"");J.includes(ne);const P=v?Z:k,C=$.useMemo(()=>[...m.length?[]:(u.inputs||[]).map(he=>({key:he.key,originalLabel:he.label,label:Ou(String(u.nodeType),he.key,he.label,h)})),...m.map(([he,ye])=>({key:he,originalLabel:ye,label:ye}))],[u.inputs,m,u.nodeType,h]),V=$.useMemo(()=>m.length?m.map(([he,ye])=>({key:he,label:ye})):(u.outputs||[]).map(he=>({key:he.key,label:Ou(String(u.nodeType),he.key,he.label,h)})),[u.outputs,m,u.nodeType,h]),M=he=>{const ye=he.trim().toLowerCase();return ye&&((T==null?void 0:T.device_sources)||[]).find(Ae=>{var Ke,ft;return Hu(Ae,u.nodeType,u.device_type)&&(Ae.name.toLowerCase()===ye||((Ke=Ae.display_name)==null?void 0:Ke.toLowerCase())===ye||Ae.source_keys.some(yt=>yt.toLowerCase()===ye)||((ft=Ae.source_key)==null?void 0:ft.toLowerCase())===ye)})||null},B=he=>{const ye=M(he);return ye?ye.input_type==="stereo_camera"||ye.input_type==="stereo_rgbd_camera"?ye.source_keys.join(","):ye.source_key||ye.source_keys[0]||ye.name:he.trim()},X=he=>{const ye=String(he??""),Ae=v?B(ye):ye;if(R){j(Ae);return}ae(Ae,v?M(ye):null)},Y=async he=>{if(j(null),!b||!R)return;const ye=v?B(he):he.trim();ye===S||!await wt.getState().confirm(`"${b.label}" is overridden for this project ("${S}"). Save "${ye}" for this project only?`,{title:d("node.projectOverride"),confirmLabel:d("node.saveForProject")})||Ee.getState().setProjectBinding(r,ye||null).catch(Ke=>wt.getState().pushToast(`Failed to save project binding: ${(Ke==null?void 0:Ke.message)||Ke}`,"error"))},U=he=>{R&&Y(he.target.value)},E=he=>{R&&(he.key==="Enter"&&Y(he.target.value),he.key==="Escape"&&j(null))},[O,W]=$.useState(!1),le=u.nodeType==="ai_annotation",[ce,me]=$.useState(!1),ge=u.nodeType==="data_quality",ae=(he,ye=null)=>{if(!b)return;const Ae={...u.config,[b.name]:he};v&&b.name==="source_key"&&(Ae.position=he,ye&&(Ae.device_name=ye.name,ye.input_type==="gripper_device"||ye.input_type==="stereo_camera"||ye.input_type==="stereo_rgbd_camera"?Ae.source_keys=ye.source_keys.join(","):delete Ae.source_keys)),iT(r,{config:Ae})},fe=async()=>{!R||!await wt.getState().confirm("Clear this project override? The workflow default will be used again.",{title:d("node.clearOverride"),confirmLabel:d("node.clear")})||Ee.getState().setProjectBinding(r,null).catch(ye=>wt.getState().pushToast(`Failed to clear binding: ${(ye==null?void 0:ye.message)||ye}`,"error"))};return N.jsxs("div",{className:"workflow-node",title:p,style:{borderColor:o?"#3b82f6":u.color||"#334155",boxShadow:o?`0 0 0 2px ${u.color}33`:void 0},children:[N.jsxs("div",{className:"node-header",style:{backgroundColor:`${g}22`,borderBottom:`1px solid ${g}44`},children:[N.jsxs("div",{className:"node-title-row",children:[N.jsx(Co,{icon:u.icon,className:"text-[18px]"}),N.jsx("span",{className:"text-xs font-semibold",title:q,children:q})]}),N.jsxs("div",{className:"node-header-control",onClick:he=>he.stopPropagation(),children:[b&&N.jsx(lT,{field:b,value:P,onChange:X,onBlur:U,onKeyDown:E,suggestions:ie,listId:`device-options-${r}`,placeholder:v?"Auto-match / enter source":void 0}),le&&N.jsx("button",{title:d("node.aiSettings"),onClick:he=>{he.stopPropagation(),W(!0)},className:"ml-1 text-[11px] text-cyan-400 border border-cyan-900 rounded px-1 cursor-pointer hover:bg-cyan-900/40 select-none",children:"⚙"}),ge&&N.jsx("button",{title:"质检设置(按设备配置检查项)",onClick:he=>{he.stopPropagation(),me(!0)},className:"ml-1 text-[11px] text-cyan-400 border border-cyan-900 rounded px-1 cursor-pointer hover:bg-cyan-900/40 select-none",children:"⚙"}),R&&N.jsx("span",{onClick:fe,title:d("node.clearOverrideHint"),className:"ml-1 text-[9px] text-blue-400 border border-blue-800 rounded px-1 cursor-pointer hover:bg-blue-900/40 align-middle select-none",children:"P"})]})]}),N.jsxs("div",{className:"node-body",children:[C.map(he=>N.jsxs("div",{className:"node-port",style:{justifyContent:"flex-start",paddingLeft:0},children:[N.jsx(si,{type:"target",position:xe.Left,id:he.key,style:{position:"relative",left:-6,transform:"none",flexShrink:0}}),N.jsx("span",{title:he.originalLabel,children:he.label})]},he.key)),V.map(he=>N.jsxs("div",{className:"node-port",style:{justifyContent:"flex-end",paddingRight:0},children:[N.jsx("span",{children:he.label}),N.jsx(si,{type:"source",position:xe.Right,id:he.key,style:{position:"relative",right:-6,transform:"none",flexShrink:0}})]},he.key))]}),O&&N.jsx(GN,{nodeId:r,onClose:()=>W(!1)}),ce&&N.jsx(KN,{nodeId:r,onClose:()=>me(!1)})]})});function eT(n,l,o,r){var d;const u=String(n||"").split(",").map(h=>h.trim()).filter(Boolean);if(!l)return"";const f=u.map(h=>{const m=(l.device_sources||[]).find(g=>{var v;return Hu(g,o||"",r)&&(((v=g.source_key)==null?void 0:v.toLowerCase())===h.toLowerCase()||g.source_keys.some(p=>p.toLowerCase()===h.toLowerCase()))});return(m==null?void 0:m.name)||(m==null?void 0:m.display_name)||(m==null?void 0:m.source_key)||""});if(!f.length){const h=(l.device_sources||[]).filter(v=>!o||Hu(v,o,r)),m=h.length||(d=l.device_sources)!=null&&d.length?h.map(v=>String(v.name||v.display_name||v.source_key||"")):(l.devices||[]).map(v=>String(v.name||v.display_name||"")),g=Array.from(new Set(m.filter(Boolean)));g.length===1&&f.push(g[0])}return Array.from(new Set(f)).join(", ")}function tT(n,l,o){if(!n)return[];const r=(n.device_sources||[]).filter(u=>Hu(u,l,o)).map(u=>u.name||u.source_key).filter(u=>!!u);return Array.from(new Set(r))}function nT(n){return n?Array.from(new Set((n.device_sources||[]).flatMap(l=>l.depth_keys||[]).map(l=>String(l||"").trim()).filter(Boolean))):[]}function Hu(n,l,o){var h;const r=String(n.device_type||"").toLowerCase(),u=String(n.input_type||"").toLowerCase(),f=!!((h=n.depth_keys)!=null&&h.length),d=r||(u==="glove_sensor"?"glove_sensor":u==="stereo_rgbd_camera"?"stereo_rgbd_camera":u==="stereo_camera"?"stereo_rgb":f||u==="rgbd_camera"?"rgbd_camera":"mono_rgb");return l==="stereo_rgbd_camera"?d==="stereo_rgbd_camera":l==="rgbd_camera"?d==="rgbd_camera":l==="stereo_camera"?d==="stereo_rgb":l==="glove_sensor"?d==="glove_sensor":l==="gripper_device"?d==="gripper_device":o&&String(o)==="rgbd_camera"?d==="rgbd_camera":d==="mono_rgb"}function aT(n){var o,r;const l=n.configSchema||[];return Rv.includes(n.nodeType)?l.find(u=>u.name==="source_key")||{name:"source_key",type:"string",label:"Source key",default:((o=n.config)==null?void 0:o.source_key)||((r=n.config)==null?void 0:r.position)||""}:n.nodeType==="lerobot_export"?l.find(u=>u.name==="version")||{name:"version",type:"select",label:"Version",default:"v3.0",options:["v2.1","v3.0"]}:n.nodeType==="mediapipe_hand"?l.find(f=>f.name==="device")||{name:"device",type:"select",label:"Device",default:"auto",options:["auto","cpu","cuda:0"]}:n.nodeType==="ai_annotation"?l.find(u=>u.name==="vlm_provider")||{name:"vlm_provider",type:"select",label:"VLM provider",default:"local",options:["local","api"]}:n.nodeType==="data_cleaning"?l.find(u=>u.name==="on_failure")||{name:"on_failure",type:"select",label:"On failure",default:"review",options:["review","warn","block"]}:null}function lT({field:n,value:l,onChange:o,onBlur:r,onKeyDown:u,suggestions:f=[],listId:d,placeholder:h}){const m=l??n.default??"";if(n.type==="boolean")return N.jsx("input",{type:"checkbox",checked:!!m,onChange:g=>o(g.target.checked)});if(n.type==="select"){const g=n.options||[],v=g.includes(String(m))?String(m):g[0]||"";return N.jsx("select",{"aria-label":n.label,value:v,onChange:p=>o(p.target.value),className:"node-header-select",children:g.map(p=>{const b=n.name==="prompt_language"?{zh:"中文",en:"English"}[p]||p:p==="cuda:0"?"GPU":p.toUpperCase();return N.jsx("option",{value:p,children:b},p)})})}return N.jsxs(N.Fragment,{children:[N.jsx("input",{"aria-label":n.label,type:n.type==="number"?"number":"text",value:String(m),list:f.length?d:void 0,placeholder:h,min:n.min,max:n.max,step:n.step,onClick:g=>{var v,p;f.length&&((p=(v=g.currentTarget).showPicker)==null||p.call(v))},onChange:g=>o(n.type==="number"?Number(g.target.value):g.target.value),onBlur:r,onKeyDown:u,className:"node-header-input"}),f.length>0&&d&&N.jsx("datalist",{id:d,children:f.map(g=>N.jsx("option",{value:g},g))})]})}function iT(n,l){Ee.setState(o=>({nodes:o.nodes.map(r=>r.id===n?{...r,data:{...r.data,...l}}:r),isDirty:!0}))}function oT(n){const l=rl(),{id:o,sourceX:r,sourceY:u,targetX:f,targetY:d,sourcePosition:h,targetPosition:m,selected:g,style:v,markerEnd:p}=n,[b,x,_]=vd({sourceX:r,sourceY:u,sourcePosition:h,targetX:f,targetY:d,targetPosition:m}),{deleteElements:T}=Lo();return N.jsxs(N.Fragment,{children:[N.jsx(Uo,{id:o,path:b,markerEnd:p,style:v}),g&&N.jsx(A3,{children:N.jsx("button",{type:"button",className:"nodrag nopan",title:l("edge.delete"),onClick:()=>T({edges:[{id:o}]}),style:{position:"absolute",transform:`translate(-50%, -50%) translate(${x}px, ${_}px)`,width:20,height:20,borderRadius:10,background:"#dc2626",color:"#fff",border:"none",cursor:"pointer",fontSize:13,lineHeight:"18px",textAlign:"center",boxShadow:"0 1px 4px rgba(0,0,0,.5)",zIndex:10},children:"×"})})]})}const rT={workflowNode:PN},uT={default:oT};function sT(){const{nodes:n,edges:l,onNodesChange:o,onEdgesChange:r,onConnect:u}=Ee(),f=Ee(v=>v.workflowId),d=Lo(),h=$.useRef(null),m=$.useCallback(v=>{v.preventDefault(),v.dataTransfer.dropEffect="move"},[]),g=$.useCallback(v=>{v.preventDefault();const p=v.dataTransfer.getData("application/reactflow-type");if(!p||!h.current)return;const b=Mv().find(S=>S.type===p);if(!b)return;let x=null;const _=v.dataTransfer.getData("application/reactflow-device");if(_)try{x=JSON.parse(_)}catch{x=null}const T=(x==null?void 0:x.source_keys)||[],z=x?(x.input_type==="gripper_device"?{source_keys:T.join(","),source_key:x.source_key||T[0]||"",position:x.source_key||T[0]||""}:x.input_type==="stereo_camera"||x.input_type==="stereo_rgbd_camera")?{source_keys:T.join(","),source_key:T[0]||"",position:T[0]||""}:{source_key:x.source_key||T[0]||"",position:x.source_key||T[0]||""}:{},A={label:b.label,category:b.category,icon:b.icon,color:b.color,config:{...b.defaultConfig,...z},nodeType:b.type,inputs:b.inputs,outputs:b.outputs,configSchema:b.configSchema,executionTarget:b.executionTarget,...x?{device_name:x.name,device_id:x.id,device_display_name:x.display_name,device_type:x.device_type,depth_keys:x.depth_keys}:{}},R=d.screenToFlowPosition({x:v.clientX-100,y:v.clientY-40});Ee.setState(S=>({nodes:[...S.nodes,{id:BN(),type:"workflowNode",position:R,data:A}],isDirty:!0}))},[d]);return N.jsx("div",{ref:h,className:"flex-1 h-full",onDragOver:m,onDrop:g,children:N.jsxs(N3,{nodes:n,edges:l,onNodesChange:o,onEdgesChange:r,onConnect:u,nodeTypes:rT,edgeTypes:uT,fitView:!0,deleteKeyCode:["Delete","Backspace"],multiSelectionKeyCode:"Shift",snapToGrid:!0,snapGrid:[16,16],defaultEdgeOptions:{style:{stroke:"#475569",strokeWidth:2}},style:{background:"#0f172a"},children:[N.jsx(k3,{color:"#1e293b",gap:32,size:1}),N.jsx(P3,{style:{background:"#1e293b"},maskColor:"rgba(0,0,0,0.5)",nodeColor:v=>{var p;return((p=v.data)==null?void 0:p.color)||"#475569"}}),N.jsx(U3,{className:"!bg-gray-800 !border-gray-700"})]},f||"blank")})}const cT=["rgb_camera","fisheye_camera"],jf=["gripper_device","glove_sensor","mono_camera","rgbd_camera","stereo_camera","stereo_rgbd_camera"],fT=["mediapipe_hand"],dT=["human_review"],hT=[{key:"input",labelKey:"palette.input",icon:"ant-design:video-camera-outlined"},{key:"review",labelKey:"palette.review",icon:"ant-design:eye-outlined"},{key:"process",labelKey:"palette.process",icon:"ant-design:desktop-outlined"},{key:"export",labelKey:"palette.export",icon:"ant-design:download-outlined"}];function gT(){const[n,l]=$.useState(""),[o,r]=$.useState({}),[u,f]=$.useState(null),d=(T,z)=>{T.dataTransfer.setData("application/reactflow-type",z.type),T.dataTransfer.effectAllowed="move"},h=(T,z)=>{f({text:T,x:Math.min(z.clientX+14,window.innerWidth-256),y:Math.min(z.clientY+12,window.innerHeight-100)})},m=()=>f(null),g=$.useSyncExternalStore(yN,pN),v=rl(),p=Ku(),b=$.useMemo(()=>{const T=n.trim().toLowerCase();return T?Mv().filter(z=>z.label.toLowerCase().includes(T)||nd(z.type,z.label,p).toLowerCase().includes(T)):null},[n,g,p]),x=T=>cT.includes(T.type)||fT.includes(T.type)||dT.includes(T.type)?!1:T.category==="input"?jf.includes(T.type):!0,_=T=>N.jsx("div",{onMouseEnter:A=>T.description&&h(T.description,A),onMouseMove:A=>T.description&&h(T.description,A),onMouseLeave:m,children:N.jsxs("div",{draggable:!0,onDragStart:A=>d(A,T),className:"flex items-center gap-2 px-2 py-1.5 mx-1 mb-0.5 rounded cursor-grab hover:bg-gray-800 active:cursor-grabbing border border-transparent hover:border-gray-700 transition-colors",children:[N.jsx("span",{className:"w-2.5 h-2.5 rounded-full shrink-0",style:{backgroundColor:T.color}}),N.jsx("span",{className:"text-xs text-gray-300 truncate",children:nd(T.type,T.label,p)})]})},T.type);return N.jsxs("div",{className:"w-[220px] bg-gray-900 border-r border-gray-800 flex flex-col shrink-0 overflow-hidden relative",children:[N.jsx("div",{className:"p-2",children:N.jsx("input",{type:"text",placeholder:v("palette.search"),value:n,onChange:T=>l(T.target.value),className:"w-full bg-gray-800 border border-gray-700 rounded px-2 py-1.5 text-xs text-gray-200 placeholder-gray-500 focus:outline-none focus:border-blue-500"})}),N.jsx("div",{className:"flex-1 overflow-y-auto px-1 pb-2",children:b?b.filter(x).map(_):hT.map(T=>{const z=bN(T.key).filter(x).sort((R,S)=>T.key!=="input"?0:jf.indexOf(R.type)-jf.indexOf(S.type)),A=!o[T.key];return N.jsxs("div",{children:[N.jsxs("button",{onClick:()=>r(R=>({...R,[T.key]:!R[T.key]})),className:"w-full flex items-center gap-1.5 px-2 py-1.5 text-[11px] font-semibold text-gray-500 uppercase tracking-wider hover:text-gray-300",children:[N.jsx(Co,{icon:T.icon,className:"text-[14px]"}),N.jsx("span",{children:v(T.labelKey)}),N.jsx(Co,{icon:A?"ant-design:caret-down-filled":"ant-design:caret-right-outlined",className:"ml-auto text-[10px]"})]}),A&&z.map(_)]},T.key)})}),N.jsx("div",{className:"px-2 py-2 border-t border-gray-800 text-[10px] text-gray-600 text-center",children:v("palette.hint")}),u&&N.jsx("div",{className:"pointer-events-none fixed z-[200] w-60 rounded border border-gray-700 bg-gray-950/95 p-2 shadow-xl",style:{left:u.x,top:u.y},children:N.jsx("p",{className:"text-[11px] leading-snug text-gray-300",children:u.text})})]})}function mT(){const n=wt(o=>o.toasts),l=wt(o=>o.removeToast);return n.length===0?null:N.jsx("div",{className:"fixed top-3 right-3 z-[300] flex flex-col gap-2 max-w-xs pointer-events-none",children:n.map(o=>N.jsx("div",{className:`pointer-events-auto rounded border px-3 py-2 text-xs shadow-lg ${o.type==="error"?"border-red-800 bg-red-950/95 text-red-200":"border-gray-700 bg-gray-900/95 text-gray-200"}`,children:N.jsxs("div",{className:"flex items-start gap-2",children:[N.jsx("span",{className:"flex-1 leading-snug break-words",children:o.msg}),N.jsx("button",{type:"button",onClick:()=>l(o.id),className:"text-gray-500 hover:text-gray-300 shrink-0",children:"×"})]})},o.id))})}function yT(){const n=wt(f=>f.dialog),l=wt(f=>f.resolveDialog),[o,r]=$.useState("");if($.useEffect(()=>{n&&r(n.defaultValue||"")},[n]),!n)return null;const u=n.kind==="prompt";return N.jsx("div",{className:"fixed inset-0 z-[200] flex items-center justify-center bg-black/60 p-4",role:"presentation",children:N.jsxs("div",{className:"w-full max-w-sm rounded-lg border border-gray-700 bg-gray-900 shadow-2xl",role:"dialog","aria-modal":"true",children:[N.jsxs("div",{className:"flex items-start gap-3 border-b border-gray-800 px-4 py-3",children:[N.jsx("span",{className:`mt-0.5 flex h-7 w-7 shrink-0 items-center justify-center rounded-full ${n.danger?"bg-red-900/50 text-red-300":"bg-blue-900/50 text-blue-300"}`,children:N.jsx("span",{className:"text-sm font-bold",children:n.danger?"!":"?"})}),N.jsxs("div",{className:"min-w-0 flex-1",children:[N.jsx("h2",{className:"text-sm font-semibold text-gray-100",children:n.title}),N.jsx("p",{className:"mt-1 text-xs leading-5 text-gray-400",children:n.message}),u&&N.jsx("input",{autoFocus:!0,value:o,onChange:f=>r(f.target.value),onKeyDown:f=>{f.key==="Enter"&&l(o.trim()),f.key==="Escape"&&l(null)},className:"mt-2 w-full bg-gray-800 border border-gray-600 rounded px-2 py-1.5 text-xs text-white focus:outline-none focus:border-blue-500"})]})]}),N.jsxs("div",{className:"flex justify-end gap-2 px-4 py-3",children:[N.jsx("button",{type:"button",onClick:()=>l(null),className:"rounded border border-gray-700 px-3 py-1.5 text-xs text-gray-300 hover:bg-gray-800",children:"Cancel"}),N.jsx("button",{type:"button",onClick:()=>l(u?o.trim():!0),className:`rounded px-3 py-1.5 text-xs text-white ${n.danger?"bg-red-700 hover:bg-red-600":"bg-blue-600 hover:bg-blue-500"}`,children:n.confirmLabel||(u?"OK":"Confirm")})]})]})})}function pT(){const n=window.__EGO_USER__;return n!=null&&n.role?Promise.resolve(n):Vt("/api/v1/auth/me")}function Ry(n){const l=u=>!u||typeof u!="object"?u:Array.isArray(u)?u.map(l):Object.keys(u).sort().reduce((f,d)=>(f[d]=l(u[d]),f),{}),o=((n==null?void 0:n.nodes)||[]).map(u=>{var f,d,h,m;return{id:u.id,type:u.type||"workflowNode",position:{x:Number(((f=u.position)==null?void 0:f.x)||0),y:Number(((d=u.position)==null?void 0:d.y)||0)},parentId:u.parentId||null,data:{nodeType:((h=u.data)==null?void 0:h.nodeType)||null,config:l(((m=u.data)==null?void 0:m.config)||{})}}}).sort((u,f)=>String(u.id).localeCompare(String(f.id))),r=((n==null?void 0:n.edges)||[]).map(u=>({id:u.id||null,source:u.source,target:u.target,sourceHandle:u.sourceHandle||null,targetHandle:u.targetHandle||null,type:u.type||null})).sort((u,f)=>String(u.id).localeCompare(String(f.id)));return JSON.stringify({nodes:o,edges:r})}function vT(n,l){return Ry(n)===Ry(l)}function bT(){return rl(),$.useEffect(()=>{uN().then(n=>_N(n)).catch(()=>{})},[]),$.useEffect(()=>{const n=l=>{const o=l.ctrlKey||l.metaKey;o&&l.key==="z"&&!l.shiftKey&&(l.preventDefault(),Ee.getState().undo()),o&&(l.key==="y"||l.key==="z"&&l.shiftKey)&&(l.preventDefault(),Ee.getState().redo())};return window.addEventListener("keydown",n),()=>window.removeEventListener("keydown",n)},[]),$.useEffect(()=>{const n=Ee.getState(),l=new URLSearchParams(window.location.search),o=l.get("workflow"),r=l.get("project");pT().then(f=>Ee.setState({userRole:f.role})).catch(()=>{}),r&&Ee.setState({workflowProjectId:r});const u=async()=>{try{const f=localStorage.getItem("workflow_draft");if(f){let d=JSON.parse(f);const h=d!=null&&d.nodes&&Array.isArray(d.nodes)?ld({nodes:d.nodes,edges:d.edges||[]}):null;if(d.workflowId)try{const m=await Ff(String(d.workflowId));h&&vT(h,m.graph)&&(Fl(),d=null)}catch{}if(d&&d.nodes&&Array.isArray(d.nodes)&&d.nodes.length>0){const m=h||ld(d);Ee.setState({nodes:m.nodes,edges:m.edges,workflowId:d.workflowId||null,workflowProjectId:r||d.workflowProjectId||null,workflowName:d.workflowName||"Untitled",isDirty:!0}),n.loadWorkflowList();const g=r||d.workflowProjectId;n.loadInputsForWorkflow(g);return}}}catch{}n.loadWorkflowList().then(()=>{const{workflows:f}=Ee.getState();f.length>0?n.loadWorkflow(f[f.length-1].id).then(()=>{const d=Ee.getState();return d.loadInputsForWorkflow(d.workflowProjectId||r)}):r?n.loadInputsForWorkflow(r):n.loadInputsForWorkflow(null)})};if(o){n.loadWorkflowList(),n.loadWorkflow(o).then(()=>{const f=Ee.getState();return f.loadInputsForWorkflow(f.workflowProjectId||r)}).catch(()=>{u()});return}u()},[]),N.jsxs(xv,{children:[N.jsxs("div",{className:"h-full w-full flex flex-col",children:[N.jsx(xT,{}),N.jsxs("div",{className:"flex-1 flex min-h-0",children:[N.jsx(sT,{}),N.jsx(gT,{})]})]}),N.jsx(mT,{}),N.jsx(yT,{})]})}function xT(){const n=rl(),{workflowName:l,workflowId:o,isDirty:r,isSaving:u,workflows:f,userRole:d,isPresetWorkflow:h,saveWorkflowSafe:m,saveWorkflowAs:g,loadWorkflow:v,loadWorkflowList:p}=Ee(),[b,x]=$.useState(!1),[_,T]=$.useState(l),[z,A]=$.useState(""),[R,S]=$.useState(null),[D,H]=$.useState(!1),[j,k]=$.useState(!1),[q,Z]=$.useState(!1),ie=d==="admin",J=h&&!ie,ne=ee=>{A(ee),setTimeout(()=>A(""),2e3)},P=()=>{const ee=Ee.getState();if(!ee.workflowId)return;const se=new URLSearchParams(window.location.search);se.set("workflow",ee.workflowId),ee.workflowProjectId?se.set("project",ee.workflowProjectId):se.delete("project");const de=se.toString();window.history.replaceState(null,"",`/workflow-studio${de?`?${de}`:""}`)},C=async(ee=Ee.getState())=>{const se=await wt.getState().prompt("This is a template workflow and cannot be overwritten. Save a copy as:",{title:"Save a copy",defaultValue:(ee.workflowName||"Untitled")+" (copy)",confirmLabel:"Save"});if(!(!se||!se.trim()))try{await ee.saveWorkflowAs(se.trim()),await ee.loadWorkflowList(),P(),ne("Saved as copy")}catch(de){wt.getState().pushToast(de.message||"Save failed","error")}},V=async()=>{const ee=Ee.getState(),se=await ee.saveWorkflowSafe();if(se==="needs-save-as"){await C(ee);return}se==="saved"&&ne("Saved")},M=async()=>{const ee=Ee.getState();if(ee.workflowId)try{const se=await sN(ee.workflowId);if(se.project_count>=2){const de=se.projects.map(pe=>pe.name).join(", ");S({title:"Shared workflow",message:`This workflow is used by ${se.project_count} projects (${de}). Saving directly will affect all of them.`,confirmLabel:"Save directly",secondaryLabel:"Save as copy",onConfirm:()=>V(),onSecondary:()=>B()});return}}catch(se){console.warn("usage check failed, saving directly",se)}await V()},B=async()=>{const ee=Ee.getState(),se=await wt.getState().prompt("Save a copy as:",{title:"Save a copy",defaultValue:(ee.workflowName||"Untitled")+" (copy)",confirmLabel:"Save"});if(!(!se||!se.trim()))try{await ee.saveWorkflowAs(se.trim()),await ee.loadWorkflowList(),P(),ne("Saved as copy")}catch(de){wt.getState().pushToast(de.message||"Save failed","error")}},X=async()=>{const ee=Ee.getState();if(!ee.workflowId){T(ee.workflowName),x(!0);return}if(J){await C(ee);return}if(ee.workflowId&&ee.nodes.length===0){S({title:"Save empty workflow?",message:"This workflow has no nodes, so it will not process any uploaded data. Save anyway?",confirmLabel:"Save anyway",onConfirm:()=>M()});return}await M()},Y=async()=>{const ee=_.trim();if(x(!1),!ee){T(l);return}if(ee!==l){if(J){ne("Template workflows can only be renamed by admin. Save a copy instead.");return}if(o){Ee.setState({workflowName:ee});try{await m(),await p(),ne("Renamed")}catch{}}else await g(ee),await p(),ne("Saved")}},U=async ee=>{const se=Ee.getState();if(ee==="__new__"){se.newWorkflow();const de=new URLSearchParams(window.location.search),pe=de.get("project");pe?(Ee.setState({workflowProjectId:pe}),await Ee.getState().loadInputsForWorkflow(pe)):await Ee.getState().loadInputsForWorkflow(null),de.delete("workflow");const we=de.toString();window.history.replaceState(null,"",`/workflow-studio${we?`?${we}`:""}`)}else if(ee){await v(ee);const de=Ee.getState();if(de.workflowId!==ee)return;const pe=new URLSearchParams(window.location.search).get("project"),we=de.workflowProjectId||pe;if(await de.loadInputsForWorkflow(we),Ee.getState().workflowId!==ee)return;P()}},E=async ee=>{Z(!0);try{const se=Ee.getState();ee&&await se.newWorkflowFromTemplate(ee);const de=new URLSearchParams(window.location.search);de.delete("workflow");const pe=de.toString();window.history.replaceState(null,"",`/workflow-studio${pe?`?${pe}`:""}`)}catch(se){ne((se==null?void 0:se.message)||"Failed to load template")}finally{Z(!1),k(!1)}},O=async ee=>{const se=ee.target.value;if(Ee.getState().isDirty){S({title:"Discard unsaved changes?",message:"Your current workflow has unsaved changes. Switching workflows will discard them.",confirmLabel:"Discard and switch",danger:!0,onConfirm:()=>U(se)});return}await U(se)},W=()=>{if(Ee.getState().isDirty){S({title:"Discard unsaved changes?",message:"Your current workflow has unsaved changes. Starting from a template or a blank workflow will discard them.",confirmLabel:"Discard and continue",danger:!0,onConfirm:()=>k(!0)});return}k(!0)},le=()=>{const ee=Ee.getState();if(!ee.workflowId)return;const se=!h;S({title:se?"Make this a template workflow?":"Remove template status?",message:se?"This workflow will become a shared template for all users.":"This workflow will become a regular workflow. Its nodes and connections will not change.",confirmLabel:se?"Make Template":"Remove template status",onConfirm:async()=>{try{await Pf(ee.workflowId,{is_preset:se}),await p(),Ee.setState({isPresetWorkflow:se}),ne(se?"Template created":"Template removed")}catch(de){ne(de.message||"Failed")}}})},ce=ee=>{H(!1),S(se=>se===ee?null:se)},me=async()=>{const ee=R;if(!(!ee||D)){H(!0);try{await ee.onConfirm()}catch(se){ne((se==null?void 0:se.message)||"Operation failed")}finally{ce(ee)}}},ge=async()=>{var se;const ee=R;if(!(!ee||D)){H(!0);try{await((se=ee.onSecondary)==null?void 0:se.call(ee))}catch(de){ne((de==null?void 0:de.message)||"Operation failed")}finally{ce(ee)}}},ae=$.useRef(X);$.useEffect(()=>{ae.current=X}),$.useEffect(()=>{const ee=se=>{(se.ctrlKey||se.metaKey)&&se.key==="s"&&(se.preventDefault(),ae.current())};return window.addEventListener("keydown",ee),()=>window.removeEventListener("keydown",ee)},[]);const fe=r?"bg-yellow-500":z?"bg-green-500":"bg-gray-600";return N.jsxs("div",{className:"relative flex items-center gap-2 px-4 py-1.5 bg-gray-900 border-b border-gray-800 shrink-0",children:[N.jsx("span",{className:`w-2 h-2 rounded-full shrink-0 ${fe}`}),N.jsxs("select",{value:o||"",onChange:O,onClick:()=>p(),className:"bg-transparent border border-gray-700 rounded px-1.5 py-0.5 text-xs font-semibold text-gray-200 focus:outline-none focus:border-blue-500 cursor-pointer max-w-[200px]",children:[!o&&N.jsx("option",{value:"",disabled:!0,hidden:!0,children:n("app.newWorkflow")}),f.map(ee=>N.jsxs("option",{value:ee.id,className:"bg-gray-800 text-gray-200",children:[ee.name,ee.is_preset?" (Template)":""]},ee.id)),o&&!f.find(ee=>ee.id===o)&&N.jsx("option",{value:o,className:"bg-gray-800 text-gray-200",children:l}),N.jsx("option",{value:"__new__",className:"bg-gray-800 text-gray-400",children:"+ New Workflow"})]}),b?N.jsx(N.Fragment,{children:N.jsx("input",{autoFocus:!0,value:_,onChange:ee=>T(ee.target.value),onKeyDown:ee=>{ee.key==="Enter"&&Y(),ee.key==="Escape"&&(T(l),x(!1))},onBlur:Y,className:"bg-gray-800 border border-gray-600 rounded px-1.5 py-0.5 text-xs text-white w-48 focus:outline-none focus:border-blue-500",title:"Press Enter to save"})}):N.jsxs("span",{onClick:()=>{if(J){ne("Template workflows can only be renamed by admin. Save a copy instead.");return}T(l),x(!0)},title:"Click to rename workflow",className:"text-xs font-semibold text-gray-200 hover:text-blue-400 hover:underline cursor-pointer whitespace-nowrap",children:[l," ",h&&N.jsx("span",{className:"text-[9px] text-yellow-400 border border-yellow-700 rounded px-1 ml-1 align-middle",children:n("app.template")}),!J&&N.jsx("span",{className:"text-[10px] text-gray-500 ml-1",children:"✎"})]}),z&&N.jsx("span",{className:"text-[11px] text-green-400",children:z}),N.jsx("div",{className:"flex-1"}),N.jsxs("button",{onClick:()=>{p(),W()},title:"Start a new workflow from a template (processing chain) or a blank canvas",className:"text-[11px] text-blue-400 hover:text-blue-300 hover:bg-blue-900/30 border border-blue-900/60 px-1.5 py-0.5 rounded",children:[N.jsx(Co,{icon:"ant-design:project-outlined",className:"text-[12px] align-[-2px] mr-0.5"})," ",n("app.template")]}),ie&&o&&N.jsx("button",{onClick:le,className:"text-[11px] text-yellow-400 hover:text-yellow-300 hover:bg-yellow-900/30 px-1.5 py-0.5 rounded",children:n(h?"app.unsetTemplate":"app.makeTemplate")}),N.jsx("button",{onClick:X,disabled:u,className:"text-[11px] bg-blue-600 hover:bg-blue-500 text-white px-2 py-0.5 rounded disabled:opacity-50",children:u?"...":n("app.save")}),o&&!J&&N.jsx("button",{onClick:()=>S({title:"Delete this workflow?",message:"This action cannot be undone. The workflow definition will be removed.",confirmLabel:"Delete workflow",danger:!0,onConfirm:async()=>{await rN(o),await p();const{workflows:ee}=Ee.getState();ee.length>0?await v(ee[0].id):Ee.getState().newWorkflow(),P()}}),className:"text-[11px] text-red-400 hover:text-red-300 hover:bg-red-900/30 px-1.5 py-0.5 rounded",children:n("app.del")}),R&&N.jsx("div",{className:"fixed inset-0 z-[100] flex items-center justify-center bg-black/60 p-4",role:"presentation",children:N.jsxs("div",{className:"w-full max-w-sm rounded-lg border border-gray-700 bg-gray-900 shadow-2xl",role:"dialog","aria-modal":"true","aria-labelledby":"workflow-dialog-title",children:[N.jsxs("div",{className:"flex items-start gap-3 border-b border-gray-800 px-4 py-3",children:[N.jsx("span",{className:`mt-0.5 flex h-7 w-7 shrink-0 items-center justify-center rounded-full ${R.danger?"bg-red-900/50 text-red-300":"bg-blue-900/50 text-blue-300"}`,children:N.jsx("span",{className:"text-sm font-bold",children:R.danger?"!":"?"})}),N.jsxs("div",{className:"min-w-0",children:[N.jsx("h2",{id:"workflow-dialog-title",className:"text-sm font-semibold text-gray-100",children:R.title}),N.jsx("p",{className:"mt-1 text-xs leading-5 text-gray-400",children:R.message})]})]}),N.jsxs("div",{className:"flex justify-end gap-2 px-4 py-3",children:[N.jsx("button",{type:"button",disabled:D,onClick:()=>S(null),className:"rounded border border-gray-700 px-3 py-1.5 text-xs text-gray-300 hover:bg-gray-800 disabled:opacity-50",children:n("app.cancel")}),R.secondaryLabel&&N.jsx("button",{type:"button",disabled:D,onClick:ge,className:"rounded border border-gray-700 px-3 py-1.5 text-xs text-gray-300 hover:bg-gray-800 disabled:opacity-50",children:D?"Working...":R.secondaryLabel}),N.jsx("button",{type:"button",disabled:D,onClick:me,className:`rounded px-3 py-1.5 text-xs text-white disabled:opacity-50 ${R.danger?"bg-red-700 hover:bg-red-600":"bg-blue-600 hover:bg-blue-500"}`,children:D?"Working...":R.confirmLabel})]})]})}),j&&N.jsx("div",{className:"fixed inset-0 z-[100] flex items-center justify-center bg-black/60 p-4",role:"presentation",children:N.jsxs("div",{className:"w-full max-w-sm rounded-lg border border-gray-700 bg-gray-900 shadow-2xl",role:"dialog","aria-modal":"true","aria-labelledby":"template-dialog-title",children:[N.jsxs("div",{className:"border-b border-gray-800 px-4 py-3",children:[N.jsx("h2",{id:"template-dialog-title",className:"text-sm font-semibold text-gray-100",children:n("app.startFromTemplate")}),N.jsx("p",{className:"mt-1 text-xs leading-5 text-gray-400",children:"Templates contain the processing chain only — input device cards appear as your collectors report data. Applying a template replaces the current canvas."})]}),N.jsxs("div",{className:"px-4 py-3 space-y-1.5",children:[f.filter(ee=>ee.is_preset).map(ee=>N.jsx("button",{type:"button",disabled:q,onClick:()=>E(ee),className:"w-full text-left rounded border border-gray-700 px-3 py-2 hover:border-blue-600 hover:bg-gray-800 disabled:opacity-50",children:N.jsxs("div",{className:"flex items-center gap-2",children:[N.jsx(Co,{icon:"ant-design:database-outlined",className:"text-[14px] text-gray-500 shrink-0"}),N.jsxs("div",{className:"min-w-0",children:[N.jsx("div",{className:"text-xs text-gray-200 truncate",children:ee.name}),N.jsxs("div",{className:"text-[10px] text-gray-500 mt-0.5",children:["Template · ",ee.node_count??0," nodes · processing chain only"]})]})]})},ee.id)),!f.some(ee=>ee.is_preset)&&N.jsx("div",{className:"text-[11px] text-gray-600 px-1 pt-1",children:n("app.noTemplates")}),N.jsx("div",{className:"text-[10px] text-gray-600 pt-1",children:n("app.templateHint")})]}),N.jsx("div",{className:"flex justify-end gap-2 px-4 py-3",children:N.jsx("button",{type:"button",disabled:q,onClick:()=>k(!1),className:"rounded border border-gray-700 px-3 py-1.5 text-xs text-gray-300 hover:bg-gray-800 disabled:opacity-50",children:n("app.cancel")})})]})})]})}const jy=document.getElementById("workflow-root")||document.getElementById("root");jy&&Kx.createRoot(jy).render(N.jsx($.StrictMode,{children:N.jsx(bT,{})}));
diff --git a/processor/web/static/workflow-studio/assets/index-CcWpS4e6.js b/processor/web/static/workflow-studio/assets/index-CcWpS4e6.js
deleted file mode 100644
index 6961d8f029b0987be30e1ba24f4311f00cd77736..0000000000000000000000000000000000000000
--- a/processor/web/static/workflow-studio/assets/index-CcWpS4e6.js
+++ /dev/null
@@ -1,71 +0,0 @@
-(function(){const l=document.createElement("link").relList;if(l&&l.supports&&l.supports("modulepreload"))return;for(const u of document.querySelectorAll('link[rel="modulepreload"]'))r(u);new MutationObserver(u=>{for(const f of u)if(f.type==="childList")for(const d of f.addedNodes)d.tagName==="LINK"&&d.rel==="modulepreload"&&r(d)}).observe(document,{childList:!0,subtree:!0});function o(u){const f={};return u.integrity&&(f.integrity=u.integrity),u.referrerPolicy&&(f.referrerPolicy=u.referrerPolicy),u.crossOrigin==="use-credentials"?f.credentials="include":u.crossOrigin==="anonymous"?f.credentials="omit":f.credentials="same-origin",f}function r(u){if(u.ep)return;u.ep=!0;const f=o(u);fetch(u.href,f)}})();function Sm(n){return n&&n.__esModule&&Object.prototype.hasOwnProperty.call(n,"default")?n.default:n}var af={exports:{}},ro={};/**
- * @license React
- * react-jsx-runtime.production.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */var W0;function Nx(){if(W0)return ro;W0=1;var n=Symbol.for("react.transitional.element"),l=Symbol.for("react.fragment");function o(r,u,f){var d=null;if(f!==void 0&&(d=""+f),u.key!==void 0&&(d=""+u.key),"key"in u){f={};for(var h in u)h!=="key"&&(f[h]=u[h])}else f=u;return u=f.ref,{$$typeof:n,type:r,key:d,ref:u!==void 0?u:null,props:f}}return ro.Fragment=l,ro.jsx=o,ro.jsxs=o,ro}var F0;function Tx(){return F0||(F0=1,af.exports=Nx()),af.exports}var T=Tx(),lf={exports:{}},we={};/**
- * @license React
- * react.production.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */var P0;function Ax(){if(P0)return we;P0=1;var n=Symbol.for("react.transitional.element"),l=Symbol.for("react.portal"),o=Symbol.for("react.fragment"),r=Symbol.for("react.strict_mode"),u=Symbol.for("react.profiler"),f=Symbol.for("react.consumer"),d=Symbol.for("react.context"),h=Symbol.for("react.forward_ref"),y=Symbol.for("react.suspense"),g=Symbol.for("react.memo"),b=Symbol.for("react.lazy"),p=Symbol.for("react.activity"),v=Symbol.iterator;function x(N){return N===null||typeof N!="object"?null:(N=v&&N[v]||N["@@iterator"],typeof N=="function"?N:null)}var _={isMounted:function(){return!1},enqueueForceUpdate:function(){},enqueueReplaceState:function(){},enqueueSetState:function(){}},C=Object.assign,M={};function E(N,R,ee){this.props=N,this.context=R,this.refs=M,this.updater=ee||_}E.prototype.isReactComponent={},E.prototype.setState=function(N,R){if(typeof N!="object"&&typeof N!="function"&&N!=null)throw Error("takes an object of state variables to update or a function which returns an object of state variables.");this.updater.enqueueSetState(this,N,R,"setState")},E.prototype.forceUpdate=function(N){this.updater.enqueueForceUpdate(this,N,"forceUpdate")};function H(){}H.prototype=E.prototype;function w(N,R,ee){this.props=N,this.context=R,this.refs=M,this.updater=ee||_}var z=w.prototype=new H;z.constructor=w,C(z,E.prototype),z.isPureReactComponent=!0;var G=Array.isArray;function B(){}var L={H:null,A:null,T:null,S:null},Q=Object.prototype.hasOwnProperty;function K(N,R,ee){var ae=ee.ref;return{$$typeof:n,type:N,key:R,ref:ae!==void 0?ae:null,props:ee}}function ue(N,R){return K(N.type,R,N.props)}function $(N){return typeof N=="object"&&N!==null&&N.$$typeof===n}function ie(N){var R={"=":"=0",":":"=2"};return"$"+N.replace(/[=:]/g,function(ee){return R[ee]})}var ne=/\/+/g;function D(N,R){return typeof N=="object"&&N!==null&&N.key!=null?ie(""+N.key):R.toString(36)}function q(N){switch(N.status){case"fulfilled":return N.value;case"rejected":throw N.reason;default:switch(typeof N.status=="string"?N.then(B,B):(N.status="pending",N.then(function(R){N.status==="pending"&&(N.status="fulfilled",N.value=R)},function(R){N.status==="pending"&&(N.status="rejected",N.reason=R)})),N.status){case"fulfilled":return N.value;case"rejected":throw N.reason}}throw N}function A(N,R,ee,ae,de){var se=typeof N;(se==="undefined"||se==="boolean")&&(N=null);var oe=!1;if(N===null)oe=!0;else switch(se){case"bigint":case"string":case"number":oe=!0;break;case"object":switch(N.$$typeof){case n:case l:oe=!0;break;case b:return oe=N._init,A(oe(N._payload),R,ee,ae,de)}}if(oe)return de=de(N),oe=ae===""?"."+D(N,0):ae,G(de)?(ee="",oe!=null&&(ee=oe.replace(ne,"$&/")+"/"),A(de,R,ee,"",function(fe){return fe})):de!=null&&($(de)&&(de=ue(de,ee+(de.key==null||N&&N.key===de.key?"":(""+de.key).replace(ne,"$&/")+"/")+oe)),R.push(de)),1;oe=0;var P=ae===""?".":ae+":";if(G(N))for(var Y=0;Y<N.length;Y++)ae=N[Y],se=P+D(ae,Y),oe+=A(ae,R,ee,se,de);else if(Y=x(N),typeof Y=="function")for(N=Y.call(N),Y=0;!(ae=N.next()).done;)ae=ae.value,se=P+D(ae,Y++),oe+=A(ae,R,ee,se,de);else if(se==="object"){if(typeof N.then=="function")return A(q(N),R,ee,ae,de);throw R=String(N),Error("Objects are not valid as a React child (found: "+(R==="[object Object]"?"object with keys {"+Object.keys(N).join(", ")+"}":R)+"). If you meant to render a collection of children, use an array instead.")}return oe}function j(N,R,ee){if(N==null)return N;var ae=[],de=0;return A(N,ae,"","",function(se){return R.call(ee,se,de++)}),ae}function V(N){if(N._status===-1){var R=N._result;R=R(),R.then(function(ee){(N._status===0||N._status===-1)&&(N._status=1,N._result=ee)},function(ee){(N._status===0||N._status===-1)&&(N._status=2,N._result=ee)}),N._status===-1&&(N._status=0,N._result=R)}if(N._status===1)return N._result.default;throw N._result}var k=typeof reportError=="function"?reportError:function(N){if(typeof window=="object"&&typeof window.ErrorEvent=="function"){var R=new window.ErrorEvent("error",{bubbles:!0,cancelable:!0,message:typeof N=="object"&&N!==null&&typeof N.message=="string"?String(N.message):String(N),error:N});if(!window.dispatchEvent(R))return}else if(typeof process=="object"&&typeof process.emit=="function"){process.emit("uncaughtException",N);return}console.error(N)},Z={map:j,forEach:function(N,R,ee){j(N,function(){R.apply(this,arguments)},ee)},count:function(N){var R=0;return j(N,function(){R++}),R},toArray:function(N){return j(N,function(R){return R})||[]},only:function(N){if(!$(N))throw Error("React.Children.only expected to receive a single React element child.");return N}};return we.Activity=p,we.Children=Z,we.Component=E,we.Fragment=o,we.Profiler=u,we.PureComponent=w,we.StrictMode=r,we.Suspense=y,we.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE=L,we.__COMPILER_RUNTIME={__proto__:null,c:function(N){return L.H.useMemoCache(N)}},we.cache=function(N){return function(){return N.apply(null,arguments)}},we.cacheSignal=function(){return null},we.cloneElement=function(N,R,ee){if(N==null)throw Error("The argument must be a React element, but you passed "+N+".");var ae=C({},N.props),de=N.key;if(R!=null)for(se in R.key!==void 0&&(de=""+R.key),R)!Q.call(R,se)||se==="key"||se==="__self"||se==="__source"||se==="ref"&&R.ref===void 0||(ae[se]=R[se]);var se=arguments.length-2;if(se===1)ae.children=ee;else if(1<se){for(var oe=Array(se),P=0;P<se;P++)oe[P]=arguments[P+2];ae.children=oe}return K(N.type,de,ae)},we.createContext=function(N){return N={$$typeof:d,_currentValue:N,_currentValue2:N,_threadCount:0,Provider:null,Consumer:null},N.Provider=N,N.Consumer={$$typeof:f,_context:N},N},we.createElement=function(N,R,ee){var ae,de={},se=null;if(R!=null)for(ae in R.key!==void 0&&(se=""+R.key),R)Q.call(R,ae)&&ae!=="key"&&ae!=="__self"&&ae!=="__source"&&(de[ae]=R[ae]);var oe=arguments.length-2;if(oe===1)de.children=ee;else if(1<oe){for(var P=Array(oe),Y=0;Y<oe;Y++)P[Y]=arguments[Y+2];de.children=P}if(N&&N.defaultProps)for(ae in oe=N.defaultProps,oe)de[ae]===void 0&&(de[ae]=oe[ae]);return K(N,se,de)},we.createRef=function(){return{current:null}},we.forwardRef=function(N){return{$$typeof:h,render:N}},we.isValidElement=$,we.lazy=function(N){return{$$typeof:b,_payload:{_status:-1,_result:N},_init:V}},we.memo=function(N,R){return{$$typeof:g,type:N,compare:R===void 0?null:R}},we.startTransition=function(N){var R=L.T,ee={};L.T=ee;try{var ae=N(),de=L.S;de!==null&&de(ee,ae),typeof ae=="object"&&ae!==null&&typeof ae.then=="function"&&ae.then(B,k)}catch(se){k(se)}finally{R!==null&&ee.types!==null&&(R.types=ee.types),L.T=R}},we.unstable_useCacheRefresh=function(){return L.H.useCacheRefresh()},we.use=function(N){return L.H.use(N)},we.useActionState=function(N,R,ee){return L.H.useActionState(N,R,ee)},we.useCallback=function(N,R){return L.H.useCallback(N,R)},we.useContext=function(N){return L.H.useContext(N)},we.useDebugValue=function(){},we.useDeferredValue=function(N,R){return L.H.useDeferredValue(N,R)},we.useEffect=function(N,R){return L.H.useEffect(N,R)},we.useEffectEvent=function(N){return L.H.useEffectEvent(N)},we.useId=function(){return L.H.useId()},we.useImperativeHandle=function(N,R,ee){return L.H.useImperativeHandle(N,R,ee)},we.useInsertionEffect=function(N,R){return L.H.useInsertionEffect(N,R)},we.useLayoutEffect=function(N,R){return L.H.useLayoutEffect(N,R)},we.useMemo=function(N,R){return L.H.useMemo(N,R)},we.useOptimistic=function(N,R){return L.H.useOptimistic(N,R)},we.useReducer=function(N,R,ee){return L.H.useReducer(N,R,ee)},we.useRef=function(N){return L.H.useRef(N)},we.useState=function(N){return L.H.useState(N)},we.useSyncExternalStore=function(N,R,ee){return L.H.useSyncExternalStore(N,R,ee)},we.useTransition=function(){return L.H.useTransition()},we.version="19.2.8",we}var ey;function Ao(){return ey||(ey=1,lf.exports=Ax()),lf.exports}var I=Ao();const fo=Sm(I);var of={exports:{}},uo={},rf={exports:{}},uf={};/**
- * @license React
- * scheduler.production.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */var ty;function Cx(){return ty||(ty=1,(function(n){function l(A,j){var V=A.length;A.push(j);e:for(;0<V;){var k=V-1>>>1,Z=A[k];if(0<u(Z,j))A[k]=j,A[V]=Z,V=k;else break e}}function o(A){return A.length===0?null:A[0]}function r(A){if(A.length===0)return null;var j=A[0],V=A.pop();if(V!==j){A[0]=V;e:for(var k=0,Z=A.length,N=Z>>>1;k<N;){var R=2*(k+1)-1,ee=A[R],ae=R+1,de=A[ae];if(0>u(ee,V))ae<Z&&0>u(de,ee)?(A[k]=de,A[ae]=V,k=ae):(A[k]=ee,A[R]=V,k=R);else if(ae<Z&&0>u(de,V))A[k]=de,A[ae]=V,k=ae;else break e}}return j}function u(A,j){var V=A.sortIndex-j.sortIndex;return V!==0?V:A.id-j.id}if(n.unstable_now=void 0,typeof performance=="object"&&typeof performance.now=="function"){var f=performance;n.unstable_now=function(){return f.now()}}else{var d=Date,h=d.now();n.unstable_now=function(){return d.now()-h}}var y=[],g=[],b=1,p=null,v=3,x=!1,_=!1,C=!1,M=!1,E=typeof setTimeout=="function"?setTimeout:null,H=typeof clearTimeout=="function"?clearTimeout:null,w=typeof setImmediate<"u"?setImmediate:null;function z(A){for(var j=o(g);j!==null;){if(j.callback===null)r(g);else if(j.startTime<=A)r(g),j.sortIndex=j.expirationTime,l(y,j);else break;j=o(g)}}function G(A){if(C=!1,z(A),!_)if(o(y)!==null)_=!0,B||(B=!0,ie());else{var j=o(g);j!==null&&q(G,j.startTime-A)}}var B=!1,L=-1,Q=5,K=-1;function ue(){return M?!0:!(n.unstable_now()-K<Q)}function $(){if(M=!1,B){var A=n.unstable_now();K=A;var j=!0;try{e:{_=!1,C&&(C=!1,H(L),L=-1),x=!0;var V=v;try{t:{for(z(A),p=o(y);p!==null&&!(p.expirationTime>A&&ue());){var k=p.callback;if(typeof k=="function"){p.callback=null,v=p.priorityLevel;var Z=k(p.expirationTime<=A);if(A=n.unstable_now(),typeof Z=="function"){p.callback=Z,z(A),j=!0;break t}p===o(y)&&r(y),z(A)}else r(y);p=o(y)}if(p!==null)j=!0;else{var N=o(g);N!==null&&q(G,N.startTime-A),j=!1}}break e}finally{p=null,v=V,x=!1}j=void 0}}finally{j?ie():B=!1}}}var ie;if(typeof w=="function")ie=function(){w($)};else if(typeof MessageChannel<"u"){var ne=new MessageChannel,D=ne.port2;ne.port1.onmessage=$,ie=function(){D.postMessage(null)}}else ie=function(){E($,0)};function q(A,j){L=E(function(){A(n.unstable_now())},j)}n.unstable_IdlePriority=5,n.unstable_ImmediatePriority=1,n.unstable_LowPriority=4,n.unstable_NormalPriority=3,n.unstable_Profiling=null,n.unstable_UserBlockingPriority=2,n.unstable_cancelCallback=function(A){A.callback=null},n.unstable_forceFrameRate=function(A){0>A||125<A?console.error("forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported"):Q=0<A?Math.floor(1e3/A):5},n.unstable_getCurrentPriorityLevel=function(){return v},n.unstable_next=function(A){switch(v){case 1:case 2:case 3:var j=3;break;default:j=v}var V=v;v=j;try{return A()}finally{v=V}},n.unstable_requestPaint=function(){M=!0},n.unstable_runWithPriority=function(A,j){switch(A){case 1:case 2:case 3:case 4:case 5:break;default:A=3}var V=v;v=A;try{return j()}finally{v=V}},n.unstable_scheduleCallback=function(A,j,V){var k=n.unstable_now();switch(typeof V=="object"&&V!==null?(V=V.delay,V=typeof V=="number"&&0<V?k+V:k):V=k,A){case 1:var Z=-1;break;case 2:Z=250;break;case 5:Z=1073741823;break;case 4:Z=1e4;break;default:Z=5e3}return Z=V+Z,A={id:b++,callback:j,priorityLevel:A,startTime:V,expirationTime:Z,sortIndex:-1},V>k?(A.sortIndex=V,l(g,A),o(y)===null&&A===o(g)&&(C?(H(L),L=-1):C=!0,q(G,V-k))):(A.sortIndex=Z,l(y,A),_||x||(_=!0,B||(B=!0,ie()))),A},n.unstable_shouldYield=ue,n.unstable_wrapCallback=function(A){var j=v;return function(){var V=v;v=j;try{return A.apply(this,arguments)}finally{v=V}}}})(uf)),uf}var ny;function Mx(){return ny||(ny=1,rf.exports=Cx()),rf.exports}var sf={exports:{}},yt={};/**
- * @license React
- * react-dom.production.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */var ay;function zx(){if(ay)return yt;ay=1;var n=Ao();function l(y){var g="https://react.dev/errors/"+y;if(1<arguments.length){g+="?args[]="+encodeURIComponent(arguments[1]);for(var b=2;b<arguments.length;b++)g+="&args[]="+encodeURIComponent(arguments[b])}return"Minified React error #"+y+"; visit "+g+" for the full message or use the non-minified dev environment for full errors and additional helpful warnings."}function o(){}var r={d:{f:o,r:function(){throw Error(l(522))},D:o,C:o,L:o,m:o,X:o,S:o,M:o},p:0,findDOMNode:null},u=Symbol.for("react.portal");function f(y,g,b){var p=3<arguments.length&&arguments[3]!==void 0?arguments[3]:null;return{$$typeof:u,key:p==null?null:""+p,children:y,containerInfo:g,implementation:b}}var d=n.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;function h(y,g){if(y==="font")return"";if(typeof g=="string")return g==="use-credentials"?g:""}return yt.__DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE=r,yt.createPortal=function(y,g){var b=2<arguments.length&&arguments[2]!==void 0?arguments[2]:null;if(!g||g.nodeType!==1&&g.nodeType!==9&&g.nodeType!==11)throw Error(l(299));return f(y,g,null,b)},yt.flushSync=function(y){var g=d.T,b=r.p;try{if(d.T=null,r.p=2,y)return y()}finally{d.T=g,r.p=b,r.d.f()}},yt.preconnect=function(y,g){typeof y=="string"&&(g?(g=g.crossOrigin,g=typeof g=="string"?g==="use-credentials"?g:"":void 0):g=null,r.d.C(y,g))},yt.prefetchDNS=function(y){typeof y=="string"&&r.d.D(y)},yt.preinit=function(y,g){if(typeof y=="string"&&g&&typeof g.as=="string"){var b=g.as,p=h(b,g.crossOrigin),v=typeof g.integrity=="string"?g.integrity:void 0,x=typeof g.fetchPriority=="string"?g.fetchPriority:void 0;b==="style"?r.d.S(y,typeof g.precedence=="string"?g.precedence:void 0,{crossOrigin:p,integrity:v,fetchPriority:x}):b==="script"&&r.d.X(y,{crossOrigin:p,integrity:v,fetchPriority:x,nonce:typeof g.nonce=="string"?g.nonce:void 0})}},yt.preinitModule=function(y,g){if(typeof y=="string")if(typeof g=="object"&&g!==null){if(g.as==null||g.as==="script"){var b=h(g.as,g.crossOrigin);r.d.M(y,{crossOrigin:b,integrity:typeof g.integrity=="string"?g.integrity:void 0,nonce:typeof g.nonce=="string"?g.nonce:void 0})}}else g==null&&r.d.M(y)},yt.preload=function(y,g){if(typeof y=="string"&&typeof g=="object"&&g!==null&&typeof g.as=="string"){var b=g.as,p=h(b,g.crossOrigin);r.d.L(y,b,{crossOrigin:p,integrity:typeof g.integrity=="string"?g.integrity:void 0,nonce:typeof g.nonce=="string"?g.nonce:void 0,type:typeof g.type=="string"?g.type:void 0,fetchPriority:typeof g.fetchPriority=="string"?g.fetchPriority:void 0,referrerPolicy:typeof g.referrerPolicy=="string"?g.referrerPolicy:void 0,imageSrcSet:typeof g.imageSrcSet=="string"?g.imageSrcSet:void 0,imageSizes:typeof g.imageSizes=="string"?g.imageSizes:void 0,media:typeof g.media=="string"?g.media:void 0})}},yt.preloadModule=function(y,g){if(typeof y=="string")if(g){var b=h(g.as,g.crossOrigin);r.d.m(y,{as:typeof g.as=="string"&&g.as!=="script"?g.as:void 0,crossOrigin:b,integrity:typeof g.integrity=="string"?g.integrity:void 0})}else r.d.m(y)},yt.requestFormReset=function(y){r.d.r(y)},yt.unstable_batchedUpdates=function(y,g){return y(g)},yt.useFormState=function(y,g,b){return d.H.useFormState(y,g,b)},yt.useFormStatus=function(){return d.H.useHostTransitionStatus()},yt.version="19.2.8",yt}var ly;function Em(){if(ly)return sf.exports;ly=1;function n(){if(!(typeof __REACT_DEVTOOLS_GLOBAL_HOOK__>"u"||typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE!="function"))try{__REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(n)}catch(l){console.error(l)}}return n(),sf.exports=zx(),sf.exports}/**
- * @license React
- * react-dom-client.production.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */var iy;function Dx(){if(iy)return uo;iy=1;var n=Mx(),l=Ao(),o=Em();function r(e){var t="https://react.dev/errors/"+e;if(1<arguments.length){t+="?args[]="+encodeURIComponent(arguments[1]);for(var a=2;a<arguments.length;a++)t+="&args[]="+encodeURIComponent(arguments[a])}return"Minified React error #"+e+"; visit "+t+" for the full message or use the non-minified dev environment for full errors and additional helpful warnings."}function u(e){return!(!e||e.nodeType!==1&&e.nodeType!==9&&e.nodeType!==11)}function f(e){var t=e,a=e;if(e.alternate)for(;t.return;)t=t.return;else{e=t;do t=e,(t.flags&4098)!==0&&(a=t.return),e=t.return;while(e)}return t.tag===3?a:null}function d(e){if(e.tag===13){var t=e.memoizedState;if(t===null&&(e=e.alternate,e!==null&&(t=e.memoizedState)),t!==null)return t.dehydrated}return null}function h(e){if(e.tag===31){var t=e.memoizedState;if(t===null&&(e=e.alternate,e!==null&&(t=e.memoizedState)),t!==null)return t.dehydrated}return null}function y(e){if(f(e)!==e)throw Error(r(188))}function g(e){var t=e.alternate;if(!t){if(t=f(e),t===null)throw Error(r(188));return t!==e?null:e}for(var a=e,i=t;;){var s=a.return;if(s===null)break;var c=s.alternate;if(c===null){if(i=s.return,i!==null){a=i;continue}break}if(s.child===c.child){for(c=s.child;c;){if(c===a)return y(s),e;if(c===i)return y(s),t;c=c.sibling}throw Error(r(188))}if(a.return!==i.return)a=s,i=c;else{for(var m=!1,S=s.child;S;){if(S===a){m=!0,a=s,i=c;break}if(S===i){m=!0,i=s,a=c;break}S=S.sibling}if(!m){for(S=c.child;S;){if(S===a){m=!0,a=c,i=s;break}if(S===i){m=!0,i=c,a=s;break}S=S.sibling}if(!m)throw Error(r(189))}}if(a.alternate!==i)throw Error(r(190))}if(a.tag!==3)throw Error(r(188));return a.stateNode.current===a?e:t}function b(e){var t=e.tag;if(t===5||t===26||t===27||t===6)return e;for(e=e.child;e!==null;){if(t=b(e),t!==null)return t;e=e.sibling}return null}var p=Object.assign,v=Symbol.for("react.element"),x=Symbol.for("react.transitional.element"),_=Symbol.for("react.portal"),C=Symbol.for("react.fragment"),M=Symbol.for("react.strict_mode"),E=Symbol.for("react.profiler"),H=Symbol.for("react.consumer"),w=Symbol.for("react.context"),z=Symbol.for("react.forward_ref"),G=Symbol.for("react.suspense"),B=Symbol.for("react.suspense_list"),L=Symbol.for("react.memo"),Q=Symbol.for("react.lazy"),K=Symbol.for("react.activity"),ue=Symbol.for("react.memo_cache_sentinel"),$=Symbol.iterator;function ie(e){return e===null||typeof e!="object"?null:(e=$&&e[$]||e["@@iterator"],typeof e=="function"?e:null)}var ne=Symbol.for("react.client.reference");function D(e){if(e==null)return null;if(typeof e=="function")return e.$$typeof===ne?null:e.displayName||e.name||null;if(typeof e=="string")return e;switch(e){case C:return"Fragment";case E:return"Profiler";case M:return"StrictMode";case G:return"Suspense";case B:return"SuspenseList";case K:return"Activity"}if(typeof e=="object")switch(e.$$typeof){case _:return"Portal";case w:return e.displayName||"Context";case H:return(e._context.displayName||"Context")+".Consumer";case z:var t=e.render;return e=e.displayName,e||(e=t.displayName||t.name||"",e=e!==""?"ForwardRef("+e+")":"ForwardRef"),e;case L:return t=e.displayName||null,t!==null?t:D(e.type)||"Memo";case Q:t=e._payload,e=e._init;try{return D(e(t))}catch{}}return null}var q=Array.isArray,A=l.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE,j=o.__DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE,V={pending:!1,data:null,method:null,action:null},k=[],Z=-1;function N(e){return{current:e}}function R(e){0>Z||(e.current=k[Z],k[Z]=null,Z--)}function ee(e,t){Z++,k[Z]=e.current,e.current=t}var ae=N(null),de=N(null),se=N(null),oe=N(null);function P(e,t){switch(ee(se,t),ee(de,e),ee(ae,null),t.nodeType){case 9:case 11:e=(e=t.documentElement)&&(e=e.namespaceURI)?x0(e):0;break;default:if(e=t.tagName,t=t.namespaceURI)t=x0(t),e=_0(t,e);else switch(e){case"svg":e=1;break;case"math":e=2;break;default:e=0}}R(ae),ee(ae,e)}function Y(){R(ae),R(de),R(se)}function fe(e){e.memoizedState!==null&&ee(oe,e);var t=ae.current,a=_0(t,e.type);t!==a&&(ee(de,e),ee(ae,a))}function he(e){de.current===e&&(R(ae),R(de)),oe.current===e&&(R(oe),ao._currentValue=V)}var ge,me;function _e(e){if(ge===void 0)try{throw Error()}catch(a){var t=a.stack.trim().match(/\n( *(at )?)/);ge=t&&t[1]||"",me=-1<a.stack.indexOf(`
-    at`)?" (<anonymous>)":-1<a.stack.indexOf("@")?"@unknown:0:0":""}return`
-`+ge+e+me}var Ce=!1;function De(e,t){if(!e||Ce)return"";Ce=!0;var a=Error.prepareStackTrace;Error.prepareStackTrace=void 0;try{var i={DetermineComponentFrameRoot:function(){try{if(t){var ce=function(){throw Error()};if(Object.defineProperty(ce.prototype,"props",{set:function(){throw Error()}}),typeof Reflect=="object"&&Reflect.construct){try{Reflect.construct(ce,[])}catch(te){var F=te}Reflect.construct(e,[],ce)}else{try{ce.call()}catch(te){F=te}e.call(ce.prototype)}}else{try{throw Error()}catch(te){F=te}(ce=e())&&typeof ce.catch=="function"&&ce.catch(function(){})}}catch(te){if(te&&F&&typeof te.stack=="string")return[te.stack,F.stack]}return[null,null]}};i.DetermineComponentFrameRoot.displayName="DetermineComponentFrameRoot";var s=Object.getOwnPropertyDescriptor(i.DetermineComponentFrameRoot,"name");s&&s.configurable&&Object.defineProperty(i.DetermineComponentFrameRoot,"name",{value:"DetermineComponentFrameRoot"});var c=i.DetermineComponentFrameRoot(),m=c[0],S=c[1];if(m&&S){var O=m.split(`
-`),W=S.split(`
-`);for(s=i=0;i<O.length&&!O[i].includes("DetermineComponentFrameRoot");)i++;for(;s<W.length&&!W[s].includes("DetermineComponentFrameRoot");)s++;if(i===O.length||s===W.length)for(i=O.length-1,s=W.length-1;1<=i&&0<=s&&O[i]!==W[s];)s--;for(;1<=i&&0<=s;i--,s--)if(O[i]!==W[s]){if(i!==1||s!==1)do if(i--,s--,0>s||O[i]!==W[s]){var le=`
-`+O[i].replace(" at new "," at ");return e.displayName&&le.includes("<anonymous>")&&(le=le.replace("<anonymous>",e.displayName)),le}while(1<=i&&0<=s);break}}}finally{Ce=!1,Error.prepareStackTrace=a}return(a=e?e.displayName||e.name:"")?_e(a):""}function $e(e,t){switch(e.tag){case 26:case 27:case 5:return _e(e.type);case 16:return _e("Lazy");case 13:return e.child!==t&&t!==null?_e("Suspense Fallback"):_e("Suspense");case 19:return _e("SuspenseList");case 0:case 15:return De(e.type,!1);case 11:return De(e.type.render,!1);case 1:return De(e.type,!0);case 31:return _e("Activity");default:return""}}function mt(e){try{var t="",a=null;do t+=$e(e,a),a=e,e=e.return;while(e);return t}catch(i){return`
-Error generating stack: `+i.message+`
-`+i.stack}}var _t=Object.prototype.hasOwnProperty,wt=n.unstable_scheduleCallback,kt=n.unstable_cancelCallback,Ca=n.unstable_shouldYield,En=n.unstable_requestPaint,We=n.unstable_now,Rt=n.unstable_getCurrentPriorityLevel,qt=n.unstable_ImmediatePriority,Xt=n.unstable_UserBlockingPriority,Qt=n.unstable_NormalPriority,ci=n.unstable_LowPriority,ul=n.unstable_IdlePriority,Vu=n.log,qu=n.unstable_setDisableYieldValue,Ma=null,pt=null;function hn(e){if(typeof Vu=="function"&&qu(e),pt&&typeof pt.setStrictMode=="function")try{pt.setStrictMode(Ma,e)}catch{}}var vt=Math.clz32?Math.clz32:$u,Xu=Math.log,Qu=Math.LN2;function $u(e){return e>>>=0,e===0?32:31-(Xu(e)/Qu|0)|0}var sl=256,cl=262144,fl=4194304;function Nn(e){var t=e&42;if(t!==0)return t;switch(e&-e){case 1:return 1;case 2:return 2;case 4:return 4;case 8:return 8;case 16:return 16;case 32:return 32;case 64:return 64;case 128:return 128;case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:return e&261888;case 262144:case 524288:case 1048576:case 2097152:return e&3932160;case 4194304:case 8388608:case 16777216:case 33554432:return e&62914560;case 67108864:return 67108864;case 134217728:return 134217728;case 268435456:return 268435456;case 536870912:return 536870912;case 1073741824:return 0;default:return e}}function dl(e,t,a){var i=e.pendingLanes;if(i===0)return 0;var s=0,c=e.suspendedLanes,m=e.pingedLanes;e=e.warmLanes;var S=i&134217727;return S!==0?(i=S&~c,i!==0?s=Nn(i):(m&=S,m!==0?s=Nn(m):a||(a=S&~e,a!==0&&(s=Nn(a))))):(S=i&~c,S!==0?s=Nn(S):m!==0?s=Nn(m):a||(a=i&~e,a!==0&&(s=Nn(a)))),s===0?0:t!==0&&t!==s&&(t&c)===0&&(c=s&-s,a=t&-t,c>=a||c===32&&(a&4194048)!==0)?t:s}function za(e,t){return(e.pendingLanes&~(e.suspendedLanes&~e.pingedLanes)&t)===0}function Zu(e,t){switch(e){case 1:case 2:case 4:case 8:case 64:return t+250;case 16:case 32:case 128:case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:case 262144:case 524288:case 1048576:case 2097152:return t+5e3;case 4194304:case 8388608:case 16777216:case 33554432:return-1;case 67108864:case 134217728:case 268435456:case 536870912:case 1073741824:return-1;default:return-1}}function Ho(){var e=fl;return fl<<=1,(fl&62914560)===0&&(fl=4194304),e}function fi(e){for(var t=[],a=0;31>a;a++)t.push(e);return t}function Da(e,t){e.pendingLanes|=t,t!==268435456&&(e.suspendedLanes=0,e.pingedLanes=0,e.warmLanes=0)}function Ku(e,t,a,i,s,c){var m=e.pendingLanes;e.pendingLanes=a,e.suspendedLanes=0,e.pingedLanes=0,e.warmLanes=0,e.expiredLanes&=a,e.entangledLanes&=a,e.errorRecoveryDisabledLanes&=a,e.shellSuspendCounter=0;var S=e.entanglements,O=e.expirationTimes,W=e.hiddenUpdates;for(a=m&~a;0<a;){var le=31-vt(a),ce=1<<le;S[le]=0,O[le]=-1;var F=W[le];if(F!==null)for(W[le]=null,le=0;le<F.length;le++){var te=F[le];te!==null&&(te.lane&=-536870913)}a&=~ce}i!==0&&Bo(e,i,0),c!==0&&s===0&&e.tag!==0&&(e.suspendedLanes|=c&~(m&~t))}function Bo(e,t,a){e.pendingLanes|=t,e.suspendedLanes&=~t;var i=31-vt(t);e.entangledLanes|=t,e.entanglements[i]=e.entanglements[i]|1073741824|a&261930}function Lo(e,t){var a=e.entangledLanes|=t;for(e=e.entanglements;a;){var i=31-vt(a),s=1<<i;s&t|e[i]&t&&(e[i]|=t),a&=~s}}function Uo(e,t){var a=t&-t;return a=(a&42)!==0?1:di(a),(a&(e.suspendedLanes|t))!==0?0:a}function di(e){switch(e){case 2:e=1;break;case 8:e=4;break;case 32:e=16;break;case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:case 262144:case 524288:case 1048576:case 2097152:case 4194304:case 8388608:case 16777216:case 33554432:e=128;break;case 268435456:e=134217728;break;default:e=0}return e}function hi(e){return e&=-e,2<e?8<e?(e&134217727)!==0?32:268435456:8:2}function Go(){var e=j.p;return e!==0?e:(e=window.event,e===void 0?32:X0(e.type))}function Yo(e,t){var a=j.p;try{return j.p=e,t()}finally{j.p=a}}var gn=Math.random().toString(36).slice(2),ot="__reactFiber$"+gn,gt="__reactProps$"+gn,Tn="__reactContainer$"+gn,hl="__reactEvents$"+gn,Vo="__reactListeners$"+gn,Ju="__reactHandles$"+gn,qo="__reactResources$"+gn,ka="__reactMarker$"+gn;function gi(e){delete e[ot],delete e[gt],delete e[hl],delete e[Vo],delete e[Ju]}function Kn(e){var t=e[ot];if(t)return t;for(var a=e.parentNode;a;){if(t=a[Tn]||a[ot]){if(a=t.alternate,t.child!==null||a!==null&&a.child!==null)for(e=C0(e);e!==null;){if(a=e[ot])return a;e=C0(e)}return t}e=a,a=e.parentNode}return null}function Jn(e){if(e=e[ot]||e[Tn]){var t=e.tag;if(t===5||t===6||t===13||t===31||t===26||t===27||t===3)return e}return null}function In(e){var t=e.tag;if(t===5||t===26||t===27||t===6)return e.stateNode;throw Error(r(33))}function Wn(e){var t=e[qo];return t||(t=e[qo]={hoistableStyles:new Map,hoistableScripts:new Map}),t}function et(e){e[ka]=!0}var Xo=new Set,Qo={};function An(e,t){Fn(e,t),Fn(e+"Capture",t)}function Fn(e,t){for(Qo[e]=t,e=0;e<t.length;e++)Xo.add(t[e])}var Iu=RegExp("^[:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD][:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$"),$o={},yi={};function Wu(e){return _t.call(yi,e)?!0:_t.call($o,e)?!1:Iu.test(e)?yi[e]=!0:($o[e]=!0,!1)}function gl(e,t,a){if(Wu(t))if(a===null)e.removeAttribute(t);else{switch(typeof a){case"undefined":case"function":case"symbol":e.removeAttribute(t);return;case"boolean":var i=t.toLowerCase().slice(0,5);if(i!=="data-"&&i!=="aria-"){e.removeAttribute(t);return}}e.setAttribute(t,""+a)}}function yl(e,t,a){if(a===null)e.removeAttribute(t);else{switch(typeof a){case"undefined":case"function":case"symbol":case"boolean":e.removeAttribute(t);return}e.setAttribute(t,""+a)}}function tn(e,t,a,i){if(i===null)e.removeAttribute(a);else{switch(typeof i){case"undefined":case"function":case"symbol":case"boolean":e.removeAttribute(a);return}e.setAttributeNS(t,a,""+i)}}function St(e){switch(typeof e){case"bigint":case"boolean":case"number":case"string":case"undefined":return e;case"object":return e;default:return""}}function Zo(e){var t=e.type;return(e=e.nodeName)&&e.toLowerCase()==="input"&&(t==="checkbox"||t==="radio")}function Fu(e,t,a){var i=Object.getOwnPropertyDescriptor(e.constructor.prototype,t);if(!e.hasOwnProperty(t)&&typeof i<"u"&&typeof i.get=="function"&&typeof i.set=="function"){var s=i.get,c=i.set;return Object.defineProperty(e,t,{configurable:!0,get:function(){return s.call(this)},set:function(m){a=""+m,c.call(this,m)}}),Object.defineProperty(e,t,{enumerable:i.enumerable}),{getValue:function(){return a},setValue:function(m){a=""+m},stopTracking:function(){e._valueTracker=null,delete e[t]}}}}function mi(e){if(!e._valueTracker){var t=Zo(e)?"checked":"value";e._valueTracker=Fu(e,t,""+e[t])}}function Ra(e){if(!e)return!1;var t=e._valueTracker;if(!t)return!0;var a=t.getValue(),i="";return e&&(i=Zo(e)?e.checked?"true":"false":e.value),e=i,e!==a?(t.setValue(e),!0):!1}function ml(e){if(e=e||(typeof document<"u"?document:void 0),typeof e>"u")return null;try{return e.activeElement||e.body}catch{return e.body}}var Ko=/[\n"\\]/g;function Et(e){return e.replace(Ko,function(t){return"\\"+t.charCodeAt(0).toString(16)+" "})}function pi(e,t,a,i,s,c,m,S){e.name="",m!=null&&typeof m!="function"&&typeof m!="symbol"&&typeof m!="boolean"?e.type=m:e.removeAttribute("type"),t!=null?m==="number"?(t===0&&e.value===""||e.value!=t)&&(e.value=""+St(t)):e.value!==""+St(t)&&(e.value=""+St(t)):m!=="submit"&&m!=="reset"||e.removeAttribute("value"),t!=null?vi(e,m,St(t)):a!=null?vi(e,m,St(a)):i!=null&&e.removeAttribute("value"),s==null&&c!=null&&(e.defaultChecked=!!c),s!=null&&(e.checked=s&&typeof s!="function"&&typeof s!="symbol"),S!=null&&typeof S!="function"&&typeof S!="symbol"&&typeof S!="boolean"?e.name=""+St(S):e.removeAttribute("name")}function pl(e,t,a,i,s,c,m,S){if(c!=null&&typeof c!="function"&&typeof c!="symbol"&&typeof c!="boolean"&&(e.type=c),t!=null||a!=null){if(!(c!=="submit"&&c!=="reset"||t!=null)){mi(e);return}a=a!=null?""+St(a):"",t=t!=null?""+St(t):a,S||t===e.value||(e.value=t),e.defaultValue=t}i=i??s,i=typeof i!="function"&&typeof i!="symbol"&&!!i,e.checked=S?e.checked:!!i,e.defaultChecked=!!i,m!=null&&typeof m!="function"&&typeof m!="symbol"&&typeof m!="boolean"&&(e.name=m),mi(e)}function vi(e,t,a){t==="number"&&ml(e.ownerDocument)===e||e.defaultValue===""+a||(e.defaultValue=""+a)}function Pn(e,t,a,i){if(e=e.options,t){t={};for(var s=0;s<a.length;s++)t["$"+a[s]]=!0;for(a=0;a<e.length;a++)s=t.hasOwnProperty("$"+e[a].value),e[a].selected!==s&&(e[a].selected=s),s&&i&&(e[a].defaultSelected=!0)}else{for(a=""+St(a),t=null,s=0;s<e.length;s++){if(e[s].value===a){e[s].selected=!0,i&&(e[s].defaultSelected=!0);return}t!==null||e[s].disabled||(t=e[s])}t!==null&&(t.selected=!0)}}function bi(e,t,a){if(t!=null&&(t=""+St(t),t!==e.value&&(e.value=t),a==null)){e.defaultValue!==t&&(e.defaultValue=t);return}e.defaultValue=a!=null?""+St(a):""}function md(e,t,a,i){if(t==null){if(i!=null){if(a!=null)throw Error(r(92));if(q(i)){if(1<i.length)throw Error(r(93));i=i[0]}a=i}a==null&&(a=""),t=a}a=St(t),e.defaultValue=a,i=e.textContent,i===a&&i!==""&&i!==null&&(e.value=i),mi(e)}function vl(e,t){if(t){var a=e.firstChild;if(a&&a===e.lastChild&&a.nodeType===3){a.nodeValue=t;return}}e.textContent=t}var xv=new Set("animationIterationCount aspectRatio borderImageOutset borderImageSlice borderImageWidth boxFlex boxFlexGroup boxOrdinalGroup columnCount columns flex flexGrow flexPositive flexShrink flexNegative flexOrder gridArea gridRow gridRowEnd gridRowSpan gridRowStart gridColumn gridColumnEnd gridColumnSpan gridColumnStart fontWeight lineClamp lineHeight opacity order orphans scale tabSize widows zIndex zoom fillOpacity floodOpacity stopOpacity strokeDasharray strokeDashoffset strokeMiterlimit strokeOpacity strokeWidth MozAnimationIterationCount MozBoxFlex MozBoxFlexGroup MozLineClamp msAnimationIterationCount msFlex msZoom msFlexGrow msFlexNegative msFlexOrder msFlexPositive msFlexShrink msGridColumn msGridColumnSpan msGridRow msGridRowSpan WebkitAnimationIterationCount WebkitBoxFlex WebKitBoxFlexGroup WebkitBoxOrdinalGroup WebkitColumnCount WebkitColumns WebkitFlex WebkitFlexGrow WebkitFlexPositive WebkitFlexShrink WebkitLineClamp".split(" "));function pd(e,t,a){var i=t.indexOf("--")===0;a==null||typeof a=="boolean"||a===""?i?e.setProperty(t,""):t==="float"?e.cssFloat="":e[t]="":i?e.setProperty(t,a):typeof a!="number"||a===0||xv.has(t)?t==="float"?e.cssFloat=a:e[t]=(""+a).trim():e[t]=a+"px"}function vd(e,t,a){if(t!=null&&typeof t!="object")throw Error(r(62));if(e=e.style,a!=null){for(var i in a)!a.hasOwnProperty(i)||t!=null&&t.hasOwnProperty(i)||(i.indexOf("--")===0?e.setProperty(i,""):i==="float"?e.cssFloat="":e[i]="");for(var s in t)i=t[s],t.hasOwnProperty(s)&&a[s]!==i&&pd(e,s,i)}else for(var c in t)t.hasOwnProperty(c)&&pd(e,c,t[c])}function Pu(e){if(e.indexOf("-")===-1)return!1;switch(e){case"annotation-xml":case"color-profile":case"font-face":case"font-face-src":case"font-face-uri":case"font-face-format":case"font-face-name":case"missing-glyph":return!1;default:return!0}}var _v=new Map([["acceptCharset","accept-charset"],["htmlFor","for"],["httpEquiv","http-equiv"],["crossOrigin","crossorigin"],["accentHeight","accent-height"],["alignmentBaseline","alignment-baseline"],["arabicForm","arabic-form"],["baselineShift","baseline-shift"],["capHeight","cap-height"],["clipPath","clip-path"],["clipRule","clip-rule"],["colorInterpolation","color-interpolation"],["colorInterpolationFilters","color-interpolation-filters"],["colorProfile","color-profile"],["colorRendering","color-rendering"],["dominantBaseline","dominant-baseline"],["enableBackground","enable-background"],["fillOpacity","fill-opacity"],["fillRule","fill-rule"],["floodColor","flood-color"],["floodOpacity","flood-opacity"],["fontFamily","font-family"],["fontSize","font-size"],["fontSizeAdjust","font-size-adjust"],["fontStretch","font-stretch"],["fontStyle","font-style"],["fontVariant","font-variant"],["fontWeight","font-weight"],["glyphName","glyph-name"],["glyphOrientationHorizontal","glyph-orientation-horizontal"],["glyphOrientationVertical","glyph-orientation-vertical"],["horizAdvX","horiz-adv-x"],["horizOriginX","horiz-origin-x"],["imageRendering","image-rendering"],["letterSpacing","letter-spacing"],["lightingColor","lighting-color"],["markerEnd","marker-end"],["markerMid","marker-mid"],["markerStart","marker-start"],["overlinePosition","overline-position"],["overlineThickness","overline-thickness"],["paintOrder","paint-order"],["panose-1","panose-1"],["pointerEvents","pointer-events"],["renderingIntent","rendering-intent"],["shapeRendering","shape-rendering"],["stopColor","stop-color"],["stopOpacity","stop-opacity"],["strikethroughPosition","strikethrough-position"],["strikethroughThickness","strikethrough-thickness"],["strokeDasharray","stroke-dasharray"],["strokeDashoffset","stroke-dashoffset"],["strokeLinecap","stroke-linecap"],["strokeLinejoin","stroke-linejoin"],["strokeMiterlimit","stroke-miterlimit"],["strokeOpacity","stroke-opacity"],["strokeWidth","stroke-width"],["textAnchor","text-anchor"],["textDecoration","text-decoration"],["textRendering","text-rendering"],["transformOrigin","transform-origin"],["underlinePosition","underline-position"],["underlineThickness","underline-thickness"],["unicodeBidi","unicode-bidi"],["unicodeRange","unicode-range"],["unitsPerEm","units-per-em"],["vAlphabetic","v-alphabetic"],["vHanging","v-hanging"],["vIdeographic","v-ideographic"],["vMathematical","v-mathematical"],["vectorEffect","vector-effect"],["vertAdvY","vert-adv-y"],["vertOriginX","vert-origin-x"],["vertOriginY","vert-origin-y"],["wordSpacing","word-spacing"],["writingMode","writing-mode"],["xmlnsXlink","xmlns:xlink"],["xHeight","x-height"]]),wv=/^[\u0000-\u001F ]*j[\r\n\t]*a[\r\n\t]*v[\r\n\t]*a[\r\n\t]*s[\r\n\t]*c[\r\n\t]*r[\r\n\t]*i[\r\n\t]*p[\r\n\t]*t[\r\n\t]*:/i;function Jo(e){return wv.test(""+e)?"javascript:throw new Error('React has blocked a javascript: URL as a security precaution.')":e}function Cn(){}var es=null;function ts(e){return e=e.target||e.srcElement||window,e.correspondingUseElement&&(e=e.correspondingUseElement),e.nodeType===3?e.parentNode:e}var bl=null,xl=null;function bd(e){var t=Jn(e);if(t&&(e=t.stateNode)){var a=e[gt]||null;e:switch(e=t.stateNode,t.type){case"input":if(pi(e,a.value,a.defaultValue,a.defaultValue,a.checked,a.defaultChecked,a.type,a.name),t=a.name,a.type==="radio"&&t!=null){for(a=e;a.parentNode;)a=a.parentNode;for(a=a.querySelectorAll('input[name="'+Et(""+t)+'"][type="radio"]'),t=0;t<a.length;t++){var i=a[t];if(i!==e&&i.form===e.form){var s=i[gt]||null;if(!s)throw Error(r(90));pi(i,s.value,s.defaultValue,s.defaultValue,s.checked,s.defaultChecked,s.type,s.name)}}for(t=0;t<a.length;t++)i=a[t],i.form===e.form&&Ra(i)}break e;case"textarea":bi(e,a.value,a.defaultValue);break e;case"select":t=a.value,t!=null&&Pn(e,!!a.multiple,t,!1)}}}var ns=!1;function xd(e,t,a){if(ns)return e(t,a);ns=!0;try{var i=e(t);return i}finally{if(ns=!1,(bl!==null||xl!==null)&&(Hr(),bl&&(t=bl,e=xl,xl=bl=null,bd(t),e)))for(t=0;t<e.length;t++)bd(e[t])}}function xi(e,t){var a=e.stateNode;if(a===null)return null;var i=a[gt]||null;if(i===null)return null;a=i[t];e:switch(t){case"onClick":case"onClickCapture":case"onDoubleClick":case"onDoubleClickCapture":case"onMouseDown":case"onMouseDownCapture":case"onMouseMove":case"onMouseMoveCapture":case"onMouseUp":case"onMouseUpCapture":case"onMouseEnter":(i=!i.disabled)||(e=e.type,i=!(e==="button"||e==="input"||e==="select"||e==="textarea")),e=!i;break e;default:e=!1}if(e)return null;if(a&&typeof a!="function")throw Error(r(231,t,typeof a));return a}var Mn=!(typeof window>"u"||typeof window.document>"u"||typeof window.document.createElement>"u"),as=!1;if(Mn)try{var _i={};Object.defineProperty(_i,"passive",{get:function(){as=!0}}),window.addEventListener("test",_i,_i),window.removeEventListener("test",_i,_i)}catch{as=!1}var ea=null,ls=null,Io=null;function _d(){if(Io)return Io;var e,t=ls,a=t.length,i,s="value"in ea?ea.value:ea.textContent,c=s.length;for(e=0;e<a&&t[e]===s[e];e++);var m=a-e;for(i=1;i<=m&&t[a-i]===s[c-i];i++);return Io=s.slice(e,1<i?1-i:void 0)}function Wo(e){var t=e.keyCode;return"charCode"in e?(e=e.charCode,e===0&&t===13&&(e=13)):e=t,e===10&&(e=13),32<=e||e===13?e:0}function Fo(){return!0}function wd(){return!1}function Nt(e){function t(a,i,s,c,m){this._reactName=a,this._targetInst=s,this.type=i,this.nativeEvent=c,this.target=m,this.currentTarget=null;for(var S in e)e.hasOwnProperty(S)&&(a=e[S],this[S]=a?a(c):c[S]);return this.isDefaultPrevented=(c.defaultPrevented!=null?c.defaultPrevented:c.returnValue===!1)?Fo:wd,this.isPropagationStopped=wd,this}return p(t.prototype,{preventDefault:function(){this.defaultPrevented=!0;var a=this.nativeEvent;a&&(a.preventDefault?a.preventDefault():typeof a.returnValue!="unknown"&&(a.returnValue=!1),this.isDefaultPrevented=Fo)},stopPropagation:function(){var a=this.nativeEvent;a&&(a.stopPropagation?a.stopPropagation():typeof a.cancelBubble!="unknown"&&(a.cancelBubble=!0),this.isPropagationStopped=Fo)},persist:function(){},isPersistent:Fo}),t}var ja={eventPhase:0,bubbles:0,cancelable:0,timeStamp:function(e){return e.timeStamp||Date.now()},defaultPrevented:0,isTrusted:0},Po=Nt(ja),wi=p({},ja,{view:0,detail:0}),Sv=Nt(wi),is,os,Si,er=p({},wi,{screenX:0,screenY:0,clientX:0,clientY:0,pageX:0,pageY:0,ctrlKey:0,shiftKey:0,altKey:0,metaKey:0,getModifierState:us,button:0,buttons:0,relatedTarget:function(e){return e.relatedTarget===void 0?e.fromElement===e.srcElement?e.toElement:e.fromElement:e.relatedTarget},movementX:function(e){return"movementX"in e?e.movementX:(e!==Si&&(Si&&e.type==="mousemove"?(is=e.screenX-Si.screenX,os=e.screenY-Si.screenY):os=is=0,Si=e),is)},movementY:function(e){return"movementY"in e?e.movementY:os}}),Sd=Nt(er),Ev=p({},er,{dataTransfer:0}),Nv=Nt(Ev),Tv=p({},wi,{relatedTarget:0}),rs=Nt(Tv),Av=p({},ja,{animationName:0,elapsedTime:0,pseudoElement:0}),Cv=Nt(Av),Mv=p({},ja,{clipboardData:function(e){return"clipboardData"in e?e.clipboardData:window.clipboardData}}),zv=Nt(Mv),Dv=p({},ja,{data:0}),Ed=Nt(Dv),kv={Esc:"Escape",Spacebar:" ",Left:"ArrowLeft",Up:"ArrowUp",Right:"ArrowRight",Down:"ArrowDown",Del:"Delete",Win:"OS",Menu:"ContextMenu",Apps:"ContextMenu",Scroll:"ScrollLock",MozPrintableKey:"Unidentified"},Rv={8:"Backspace",9:"Tab",12:"Clear",13:"Enter",16:"Shift",17:"Control",18:"Alt",19:"Pause",20:"CapsLock",27:"Escape",32:" ",33:"PageUp",34:"PageDown",35:"End",36:"Home",37:"ArrowLeft",38:"ArrowUp",39:"ArrowRight",40:"ArrowDown",45:"Insert",46:"Delete",112:"F1",113:"F2",114:"F3",115:"F4",116:"F5",117:"F6",118:"F7",119:"F8",120:"F9",121:"F10",122:"F11",123:"F12",144:"NumLock",145:"ScrollLock",224:"Meta"},jv={Alt:"altKey",Control:"ctrlKey",Meta:"metaKey",Shift:"shiftKey"};function Ov(e){var t=this.nativeEvent;return t.getModifierState?t.getModifierState(e):(e=jv[e])?!!t[e]:!1}function us(){return Ov}var Hv=p({},wi,{key:function(e){if(e.key){var t=kv[e.key]||e.key;if(t!=="Unidentified")return t}return e.type==="keypress"?(e=Wo(e),e===13?"Enter":String.fromCharCode(e)):e.type==="keydown"||e.type==="keyup"?Rv[e.keyCode]||"Unidentified":""},code:0,location:0,ctrlKey:0,shiftKey:0,altKey:0,metaKey:0,repeat:0,locale:0,getModifierState:us,charCode:function(e){return e.type==="keypress"?Wo(e):0},keyCode:function(e){return e.type==="keydown"||e.type==="keyup"?e.keyCode:0},which:function(e){return e.type==="keypress"?Wo(e):e.type==="keydown"||e.type==="keyup"?e.keyCode:0}}),Bv=Nt(Hv),Lv=p({},er,{pointerId:0,width:0,height:0,pressure:0,tangentialPressure:0,tiltX:0,tiltY:0,twist:0,pointerType:0,isPrimary:0}),Nd=Nt(Lv),Uv=p({},wi,{touches:0,targetTouches:0,changedTouches:0,altKey:0,metaKey:0,ctrlKey:0,shiftKey:0,getModifierState:us}),Gv=Nt(Uv),Yv=p({},ja,{propertyName:0,elapsedTime:0,pseudoElement:0}),Vv=Nt(Yv),qv=p({},er,{deltaX:function(e){return"deltaX"in e?e.deltaX:"wheelDeltaX"in e?-e.wheelDeltaX:0},deltaY:function(e){return"deltaY"in e?e.deltaY:"wheelDeltaY"in e?-e.wheelDeltaY:"wheelDelta"in e?-e.wheelDelta:0},deltaZ:0,deltaMode:0}),Xv=Nt(qv),Qv=p({},ja,{newState:0,oldState:0}),$v=Nt(Qv),Zv=[9,13,27,32],ss=Mn&&"CompositionEvent"in window,Ei=null;Mn&&"documentMode"in document&&(Ei=document.documentMode);var Kv=Mn&&"TextEvent"in window&&!Ei,Td=Mn&&(!ss||Ei&&8<Ei&&11>=Ei),Ad=" ",Cd=!1;function Md(e,t){switch(e){case"keyup":return Zv.indexOf(t.keyCode)!==-1;case"keydown":return t.keyCode!==229;case"keypress":case"mousedown":case"focusout":return!0;default:return!1}}function zd(e){return e=e.detail,typeof e=="object"&&"data"in e?e.data:null}var _l=!1;function Jv(e,t){switch(e){case"compositionend":return zd(t);case"keypress":return t.which!==32?null:(Cd=!0,Ad);case"textInput":return e=t.data,e===Ad&&Cd?null:e;default:return null}}function Iv(e,t){if(_l)return e==="compositionend"||!ss&&Md(e,t)?(e=_d(),Io=ls=ea=null,_l=!1,e):null;switch(e){case"paste":return null;case"keypress":if(!(t.ctrlKey||t.altKey||t.metaKey)||t.ctrlKey&&t.altKey){if(t.char&&1<t.char.length)return t.char;if(t.which)return String.fromCharCode(t.which)}return null;case"compositionend":return Td&&t.locale!=="ko"?null:t.data;default:return null}}var Wv={color:!0,date:!0,datetime:!0,"datetime-local":!0,email:!0,month:!0,number:!0,password:!0,range:!0,search:!0,tel:!0,text:!0,time:!0,url:!0,week:!0};function Dd(e){var t=e&&e.nodeName&&e.nodeName.toLowerCase();return t==="input"?!!Wv[e.type]:t==="textarea"}function kd(e,t,a,i){bl?xl?xl.push(i):xl=[i]:bl=i,t=qr(t,"onChange"),0<t.length&&(a=new Po("onChange","change",null,a,i),e.push({event:a,listeners:t}))}var Ni=null,Ti=null;function Fv(e){g0(e,0)}function tr(e){var t=In(e);if(Ra(t))return e}function Rd(e,t){if(e==="change")return t}var jd=!1;if(Mn){var cs;if(Mn){var fs="oninput"in document;if(!fs){var Od=document.createElement("div");Od.setAttribute("oninput","return;"),fs=typeof Od.oninput=="function"}cs=fs}else cs=!1;jd=cs&&(!document.documentMode||9<document.documentMode)}function Hd(){Ni&&(Ni.detachEvent("onpropertychange",Bd),Ti=Ni=null)}function Bd(e){if(e.propertyName==="value"&&tr(Ti)){var t=[];kd(t,Ti,e,ts(e)),xd(Fv,t)}}function Pv(e,t,a){e==="focusin"?(Hd(),Ni=t,Ti=a,Ni.attachEvent("onpropertychange",Bd)):e==="focusout"&&Hd()}function eb(e){if(e==="selectionchange"||e==="keyup"||e==="keydown")return tr(Ti)}function tb(e,t){if(e==="click")return tr(t)}function nb(e,t){if(e==="input"||e==="change")return tr(t)}function ab(e,t){return e===t&&(e!==0||1/e===1/t)||e!==e&&t!==t}var jt=typeof Object.is=="function"?Object.is:ab;function Ai(e,t){if(jt(e,t))return!0;if(typeof e!="object"||e===null||typeof t!="object"||t===null)return!1;var a=Object.keys(e),i=Object.keys(t);if(a.length!==i.length)return!1;for(i=0;i<a.length;i++){var s=a[i];if(!_t.call(t,s)||!jt(e[s],t[s]))return!1}return!0}function Ld(e){for(;e&&e.firstChild;)e=e.firstChild;return e}function Ud(e,t){var a=Ld(e);e=0;for(var i;a;){if(a.nodeType===3){if(i=e+a.textContent.length,e<=t&&i>=t)return{node:a,offset:t-e};e=i}e:{for(;a;){if(a.nextSibling){a=a.nextSibling;break e}a=a.parentNode}a=void 0}a=Ld(a)}}function Gd(e,t){return e&&t?e===t?!0:e&&e.nodeType===3?!1:t&&t.nodeType===3?Gd(e,t.parentNode):"contains"in e?e.contains(t):e.compareDocumentPosition?!!(e.compareDocumentPosition(t)&16):!1:!1}function Yd(e){e=e!=null&&e.ownerDocument!=null&&e.ownerDocument.defaultView!=null?e.ownerDocument.defaultView:window;for(var t=ml(e.document);t instanceof e.HTMLIFrameElement;){try{var a=typeof t.contentWindow.location.href=="string"}catch{a=!1}if(a)e=t.contentWindow;else break;t=ml(e.document)}return t}function ds(e){var t=e&&e.nodeName&&e.nodeName.toLowerCase();return t&&(t==="input"&&(e.type==="text"||e.type==="search"||e.type==="tel"||e.type==="url"||e.type==="password")||t==="textarea"||e.contentEditable==="true")}var lb=Mn&&"documentMode"in document&&11>=document.documentMode,wl=null,hs=null,Ci=null,gs=!1;function Vd(e,t,a){var i=a.window===a?a.document:a.nodeType===9?a:a.ownerDocument;gs||wl==null||wl!==ml(i)||(i=wl,"selectionStart"in i&&ds(i)?i={start:i.selectionStart,end:i.selectionEnd}:(i=(i.ownerDocument&&i.ownerDocument.defaultView||window).getSelection(),i={anchorNode:i.anchorNode,anchorOffset:i.anchorOffset,focusNode:i.focusNode,focusOffset:i.focusOffset}),Ci&&Ai(Ci,i)||(Ci=i,i=qr(hs,"onSelect"),0<i.length&&(t=new Po("onSelect","select",null,t,a),e.push({event:t,listeners:i}),t.target=wl)))}function Oa(e,t){var a={};return a[e.toLowerCase()]=t.toLowerCase(),a["Webkit"+e]="webkit"+t,a["Moz"+e]="moz"+t,a}var Sl={animationend:Oa("Animation","AnimationEnd"),animationiteration:Oa("Animation","AnimationIteration"),animationstart:Oa("Animation","AnimationStart"),transitionrun:Oa("Transition","TransitionRun"),transitionstart:Oa("Transition","TransitionStart"),transitioncancel:Oa("Transition","TransitionCancel"),transitionend:Oa("Transition","TransitionEnd")},ys={},qd={};Mn&&(qd=document.createElement("div").style,"AnimationEvent"in window||(delete Sl.animationend.animation,delete Sl.animationiteration.animation,delete Sl.animationstart.animation),"TransitionEvent"in window||delete Sl.transitionend.transition);function Ha(e){if(ys[e])return ys[e];if(!Sl[e])return e;var t=Sl[e],a;for(a in t)if(t.hasOwnProperty(a)&&a in qd)return ys[e]=t[a];return e}var Xd=Ha("animationend"),Qd=Ha("animationiteration"),$d=Ha("animationstart"),ib=Ha("transitionrun"),ob=Ha("transitionstart"),rb=Ha("transitioncancel"),Zd=Ha("transitionend"),Kd=new Map,ms="abort auxClick beforeToggle cancel canPlay canPlayThrough click close contextMenu copy cut drag dragEnd dragEnter dragExit dragLeave dragOver dragStart drop durationChange emptied encrypted ended error gotPointerCapture input invalid keyDown keyPress keyUp load loadedData loadedMetadata loadStart lostPointerCapture mouseDown mouseMove mouseOut mouseOver mouseUp paste pause play playing pointerCancel pointerDown pointerMove pointerOut pointerOver pointerUp progress rateChange reset resize seeked seeking stalled submit suspend timeUpdate touchCancel touchEnd touchStart volumeChange scroll toggle touchMove waiting wheel".split(" ");ms.push("scrollEnd");function nn(e,t){Kd.set(e,t),An(t,[e])}var nr=typeof reportError=="function"?reportError:function(e){if(typeof window=="object"&&typeof window.ErrorEvent=="function"){var t=new window.ErrorEvent("error",{bubbles:!0,cancelable:!0,message:typeof e=="object"&&e!==null&&typeof e.message=="string"?String(e.message):String(e),error:e});if(!window.dispatchEvent(t))return}else if(typeof process=="object"&&typeof process.emit=="function"){process.emit("uncaughtException",e);return}console.error(e)},$t=[],El=0,ps=0;function ar(){for(var e=El,t=ps=El=0;t<e;){var a=$t[t];$t[t++]=null;var i=$t[t];$t[t++]=null;var s=$t[t];$t[t++]=null;var c=$t[t];if($t[t++]=null,i!==null&&s!==null){var m=i.pending;m===null?s.next=s:(s.next=m.next,m.next=s),i.pending=s}c!==0&&Jd(a,s,c)}}function lr(e,t,a,i){$t[El++]=e,$t[El++]=t,$t[El++]=a,$t[El++]=i,ps|=i,e.lanes|=i,e=e.alternate,e!==null&&(e.lanes|=i)}function vs(e,t,a,i){return lr(e,t,a,i),ir(e)}function Ba(e,t){return lr(e,null,null,t),ir(e)}function Jd(e,t,a){e.lanes|=a;var i=e.alternate;i!==null&&(i.lanes|=a);for(var s=!1,c=e.return;c!==null;)c.childLanes|=a,i=c.alternate,i!==null&&(i.childLanes|=a),c.tag===22&&(e=c.stateNode,e===null||e._visibility&1||(s=!0)),e=c,c=c.return;return e.tag===3?(c=e.stateNode,s&&t!==null&&(s=31-vt(a),e=c.hiddenUpdates,i=e[s],i===null?e[s]=[t]:i.push(t),t.lane=a|536870912),c):null}function ir(e){if(50<Ii)throw Ii=0,Ac=null,Error(r(185));for(var t=e.return;t!==null;)e=t,t=e.return;return e.tag===3?e.stateNode:null}var Nl={};function ub(e,t,a,i){this.tag=e,this.key=a,this.sibling=this.child=this.return=this.stateNode=this.type=this.elementType=null,this.index=0,this.refCleanup=this.ref=null,this.pendingProps=t,this.dependencies=this.memoizedState=this.updateQueue=this.memoizedProps=null,this.mode=i,this.subtreeFlags=this.flags=0,this.deletions=null,this.childLanes=this.lanes=0,this.alternate=null}function Ot(e,t,a,i){return new ub(e,t,a,i)}function bs(e){return e=e.prototype,!(!e||!e.isReactComponent)}function zn(e,t){var a=e.alternate;return a===null?(a=Ot(e.tag,t,e.key,e.mode),a.elementType=e.elementType,a.type=e.type,a.stateNode=e.stateNode,a.alternate=e,e.alternate=a):(a.pendingProps=t,a.type=e.type,a.flags=0,a.subtreeFlags=0,a.deletions=null),a.flags=e.flags&65011712,a.childLanes=e.childLanes,a.lanes=e.lanes,a.child=e.child,a.memoizedProps=e.memoizedProps,a.memoizedState=e.memoizedState,a.updateQueue=e.updateQueue,t=e.dependencies,a.dependencies=t===null?null:{lanes:t.lanes,firstContext:t.firstContext},a.sibling=e.sibling,a.index=e.index,a.ref=e.ref,a.refCleanup=e.refCleanup,a}function Id(e,t){e.flags&=65011714;var a=e.alternate;return a===null?(e.childLanes=0,e.lanes=t,e.child=null,e.subtreeFlags=0,e.memoizedProps=null,e.memoizedState=null,e.updateQueue=null,e.dependencies=null,e.stateNode=null):(e.childLanes=a.childLanes,e.lanes=a.lanes,e.child=a.child,e.subtreeFlags=0,e.deletions=null,e.memoizedProps=a.memoizedProps,e.memoizedState=a.memoizedState,e.updateQueue=a.updateQueue,e.type=a.type,t=a.dependencies,e.dependencies=t===null?null:{lanes:t.lanes,firstContext:t.firstContext}),e}function or(e,t,a,i,s,c){var m=0;if(i=e,typeof e=="function")bs(e)&&(m=1);else if(typeof e=="string")m=hx(e,a,ae.current)?26:e==="html"||e==="head"||e==="body"?27:5;else e:switch(e){case K:return e=Ot(31,a,t,s),e.elementType=K,e.lanes=c,e;case C:return La(a.children,s,c,t);case M:m=8,s|=24;break;case E:return e=Ot(12,a,t,s|2),e.elementType=E,e.lanes=c,e;case G:return e=Ot(13,a,t,s),e.elementType=G,e.lanes=c,e;case B:return e=Ot(19,a,t,s),e.elementType=B,e.lanes=c,e;default:if(typeof e=="object"&&e!==null)switch(e.$$typeof){case w:m=10;break e;case H:m=9;break e;case z:m=11;break e;case L:m=14;break e;case Q:m=16,i=null;break e}m=29,a=Error(r(130,e===null?"null":typeof e,"")),i=null}return t=Ot(m,a,t,s),t.elementType=e,t.type=i,t.lanes=c,t}function La(e,t,a,i){return e=Ot(7,e,i,t),e.lanes=a,e}function xs(e,t,a){return e=Ot(6,e,null,t),e.lanes=a,e}function Wd(e){var t=Ot(18,null,null,0);return t.stateNode=e,t}function _s(e,t,a){return t=Ot(4,e.children!==null?e.children:[],e.key,t),t.lanes=a,t.stateNode={containerInfo:e.containerInfo,pendingChildren:null,implementation:e.implementation},t}var Fd=new WeakMap;function Zt(e,t){if(typeof e=="object"&&e!==null){var a=Fd.get(e);return a!==void 0?a:(t={value:e,source:t,stack:mt(t)},Fd.set(e,t),t)}return{value:e,source:t,stack:mt(t)}}var Tl=[],Al=0,rr=null,Mi=0,Kt=[],Jt=0,ta=null,yn=1,mn="";function Dn(e,t){Tl[Al++]=Mi,Tl[Al++]=rr,rr=e,Mi=t}function Pd(e,t,a){Kt[Jt++]=yn,Kt[Jt++]=mn,Kt[Jt++]=ta,ta=e;var i=yn;e=mn;var s=32-vt(i)-1;i&=~(1<<s),a+=1;var c=32-vt(t)+s;if(30<c){var m=s-s%5;c=(i&(1<<m)-1).toString(32),i>>=m,s-=m,yn=1<<32-vt(t)+s|a<<s|i,mn=c+e}else yn=1<<c|a<<s|i,mn=e}function ws(e){e.return!==null&&(Dn(e,1),Pd(e,1,0))}function Ss(e){for(;e===rr;)rr=Tl[--Al],Tl[Al]=null,Mi=Tl[--Al],Tl[Al]=null;for(;e===ta;)ta=Kt[--Jt],Kt[Jt]=null,mn=Kt[--Jt],Kt[Jt]=null,yn=Kt[--Jt],Kt[Jt]=null}function eh(e,t){Kt[Jt++]=yn,Kt[Jt++]=mn,Kt[Jt++]=ta,yn=t.id,mn=t.overflow,ta=e}var ct=null,qe=null,ke=!1,na=null,It=!1,Es=Error(r(519));function aa(e){var t=Error(r(418,1<arguments.length&&arguments[1]!==void 0&&arguments[1]?"text":"HTML",""));throw zi(Zt(t,e)),Es}function th(e){var t=e.stateNode,a=e.type,i=e.memoizedProps;switch(t[ot]=e,t[gt]=i,a){case"dialog":Ae("cancel",t),Ae("close",t);break;case"iframe":case"object":case"embed":Ae("load",t);break;case"video":case"audio":for(a=0;a<Fi.length;a++)Ae(Fi[a],t);break;case"source":Ae("error",t);break;case"img":case"image":case"link":Ae("error",t),Ae("load",t);break;case"details":Ae("toggle",t);break;case"input":Ae("invalid",t),pl(t,i.value,i.defaultValue,i.checked,i.defaultChecked,i.type,i.name,!0);break;case"select":Ae("invalid",t);break;case"textarea":Ae("invalid",t),md(t,i.value,i.defaultValue,i.children)}a=i.children,typeof a!="string"&&typeof a!="number"&&typeof a!="bigint"||t.textContent===""+a||i.suppressHydrationWarning===!0||v0(t.textContent,a)?(i.popover!=null&&(Ae("beforetoggle",t),Ae("toggle",t)),i.onScroll!=null&&Ae("scroll",t),i.onScrollEnd!=null&&Ae("scrollend",t),i.onClick!=null&&(t.onclick=Cn),t=!0):t=!1,t||aa(e,!0)}function nh(e){for(ct=e.return;ct;)switch(ct.tag){case 5:case 31:case 13:It=!1;return;case 27:case 3:It=!0;return;default:ct=ct.return}}function Cl(e){if(e!==ct)return!1;if(!ke)return nh(e),ke=!0,!1;var t=e.tag,a;if((a=t!==3&&t!==27)&&((a=t===5)&&(a=e.type,a=!(a!=="form"&&a!=="button")||Vc(e.type,e.memoizedProps)),a=!a),a&&qe&&aa(e),nh(e),t===13){if(e=e.memoizedState,e=e!==null?e.dehydrated:null,!e)throw Error(r(317));qe=A0(e)}else if(t===31){if(e=e.memoizedState,e=e!==null?e.dehydrated:null,!e)throw Error(r(317));qe=A0(e)}else t===27?(t=qe,pa(e.type)?(e=Zc,Zc=null,qe=e):qe=t):qe=ct?Ft(e.stateNode.nextSibling):null;return!0}function Ua(){qe=ct=null,ke=!1}function Ns(){var e=na;return e!==null&&(Mt===null?Mt=e:Mt.push.apply(Mt,e),na=null),e}function zi(e){na===null?na=[e]:na.push(e)}var Ts=N(null),Ga=null,kn=null;function la(e,t,a){ee(Ts,t._currentValue),t._currentValue=a}function Rn(e){e._currentValue=Ts.current,R(Ts)}function As(e,t,a){for(;e!==null;){var i=e.alternate;if((e.childLanes&t)!==t?(e.childLanes|=t,i!==null&&(i.childLanes|=t)):i!==null&&(i.childLanes&t)!==t&&(i.childLanes|=t),e===a)break;e=e.return}}function Cs(e,t,a,i){var s=e.child;for(s!==null&&(s.return=e);s!==null;){var c=s.dependencies;if(c!==null){var m=s.child;c=c.firstContext;e:for(;c!==null;){var S=c;c=s;for(var O=0;O<t.length;O++)if(S.context===t[O]){c.lanes|=a,S=c.alternate,S!==null&&(S.lanes|=a),As(c.return,a,e),i||(m=null);break e}c=S.next}}else if(s.tag===18){if(m=s.return,m===null)throw Error(r(341));m.lanes|=a,c=m.alternate,c!==null&&(c.lanes|=a),As(m,a,e),m=null}else m=s.child;if(m!==null)m.return=s;else for(m=s;m!==null;){if(m===e){m=null;break}if(s=m.sibling,s!==null){s.return=m.return,m=s;break}m=m.return}s=m}}function Ml(e,t,a,i){e=null;for(var s=t,c=!1;s!==null;){if(!c){if((s.flags&524288)!==0)c=!0;else if((s.flags&262144)!==0)break}if(s.tag===10){var m=s.alternate;if(m===null)throw Error(r(387));if(m=m.memoizedProps,m!==null){var S=s.type;jt(s.pendingProps.value,m.value)||(e!==null?e.push(S):e=[S])}}else if(s===oe.current){if(m=s.alternate,m===null)throw Error(r(387));m.memoizedState.memoizedState!==s.memoizedState.memoizedState&&(e!==null?e.push(ao):e=[ao])}s=s.return}e!==null&&Cs(t,e,a,i),t.flags|=262144}function ur(e){for(e=e.firstContext;e!==null;){if(!jt(e.context._currentValue,e.memoizedValue))return!0;e=e.next}return!1}function Ya(e){Ga=e,kn=null,e=e.dependencies,e!==null&&(e.firstContext=null)}function ft(e){return ah(Ga,e)}function sr(e,t){return Ga===null&&Ya(e),ah(e,t)}function ah(e,t){var a=t._currentValue;if(t={context:t,memoizedValue:a,next:null},kn===null){if(e===null)throw Error(r(308));kn=t,e.dependencies={lanes:0,firstContext:t},e.flags|=524288}else kn=kn.next=t;return a}var sb=typeof AbortController<"u"?AbortController:function(){var e=[],t=this.signal={aborted:!1,addEventListener:function(a,i){e.push(i)}};this.abort=function(){t.aborted=!0,e.forEach(function(a){return a()})}},cb=n.unstable_scheduleCallback,fb=n.unstable_NormalPriority,tt={$$typeof:w,Consumer:null,Provider:null,_currentValue:null,_currentValue2:null,_threadCount:0};function Ms(){return{controller:new sb,data:new Map,refCount:0}}function Di(e){e.refCount--,e.refCount===0&&cb(fb,function(){e.controller.abort()})}var ki=null,zs=0,zl=0,Dl=null;function db(e,t){if(ki===null){var a=ki=[];zs=0,zl=Rc(),Dl={status:"pending",value:void 0,then:function(i){a.push(i)}}}return zs++,t.then(lh,lh),t}function lh(){if(--zs===0&&ki!==null){Dl!==null&&(Dl.status="fulfilled");var e=ki;ki=null,zl=0,Dl=null;for(var t=0;t<e.length;t++)(0,e[t])()}}function hb(e,t){var a=[],i={status:"pending",value:null,reason:null,then:function(s){a.push(s)}};return e.then(function(){i.status="fulfilled",i.value=t;for(var s=0;s<a.length;s++)(0,a[s])(t)},function(s){for(i.status="rejected",i.reason=s,s=0;s<a.length;s++)(0,a[s])(void 0)}),i}var ih=A.S;A.S=function(e,t){Vg=We(),typeof t=="object"&&t!==null&&typeof t.then=="function"&&db(e,t),ih!==null&&ih(e,t)};var Va=N(null);function Ds(){var e=Va.current;return e!==null?e:Ve.pooledCache}function cr(e,t){t===null?ee(Va,Va.current):ee(Va,t.pool)}function oh(){var e=Ds();return e===null?null:{parent:tt._currentValue,pool:e}}var kl=Error(r(460)),ks=Error(r(474)),fr=Error(r(542)),dr={then:function(){}};function rh(e){return e=e.status,e==="fulfilled"||e==="rejected"}function uh(e,t,a){switch(a=e[a],a===void 0?e.push(t):a!==t&&(t.then(Cn,Cn),t=a),t.status){case"fulfilled":return t.value;case"rejected":throw e=t.reason,ch(e),e;default:if(typeof t.status=="string")t.then(Cn,Cn);else{if(e=Ve,e!==null&&100<e.shellSuspendCounter)throw Error(r(482));e=t,e.status="pending",e.then(function(i){if(t.status==="pending"){var s=t;s.status="fulfilled",s.value=i}},function(i){if(t.status==="pending"){var s=t;s.status="rejected",s.reason=i}})}switch(t.status){case"fulfilled":return t.value;case"rejected":throw e=t.reason,ch(e),e}throw Xa=t,kl}}function qa(e){try{var t=e._init;return t(e._payload)}catch(a){throw a!==null&&typeof a=="object"&&typeof a.then=="function"?(Xa=a,kl):a}}var Xa=null;function sh(){if(Xa===null)throw Error(r(459));var e=Xa;return Xa=null,e}function ch(e){if(e===kl||e===fr)throw Error(r(483))}var Rl=null,Ri=0;function hr(e){var t=Ri;return Ri+=1,Rl===null&&(Rl=[]),uh(Rl,e,t)}function ji(e,t){t=t.props.ref,e.ref=t!==void 0?t:null}function gr(e,t){throw t.$$typeof===v?Error(r(525)):(e=Object.prototype.toString.call(t),Error(r(31,e==="[object Object]"?"object with keys {"+Object.keys(t).join(", ")+"}":e)))}function fh(e){function t(X,U){if(e){var J=X.deletions;J===null?(X.deletions=[U],X.flags|=16):J.push(U)}}function a(X,U){if(!e)return null;for(;U!==null;)t(X,U),U=U.sibling;return null}function i(X){for(var U=new Map;X!==null;)X.key!==null?U.set(X.key,X):U.set(X.index,X),X=X.sibling;return U}function s(X,U){return X=zn(X,U),X.index=0,X.sibling=null,X}function c(X,U,J){return X.index=J,e?(J=X.alternate,J!==null?(J=J.index,J<U?(X.flags|=67108866,U):J):(X.flags|=67108866,U)):(X.flags|=1048576,U)}function m(X){return e&&X.alternate===null&&(X.flags|=67108866),X}function S(X,U,J,re){return U===null||U.tag!==6?(U=xs(J,X.mode,re),U.return=X,U):(U=s(U,J),U.return=X,U)}function O(X,U,J,re){var be=J.type;return be===C?le(X,U,J.props.children,re,J.key):U!==null&&(U.elementType===be||typeof be=="object"&&be!==null&&be.$$typeof===Q&&qa(be)===U.type)?(U=s(U,J.props),ji(U,J),U.return=X,U):(U=or(J.type,J.key,J.props,null,X.mode,re),ji(U,J),U.return=X,U)}function W(X,U,J,re){return U===null||U.tag!==4||U.stateNode.containerInfo!==J.containerInfo||U.stateNode.implementation!==J.implementation?(U=_s(J,X.mode,re),U.return=X,U):(U=s(U,J.children||[]),U.return=X,U)}function le(X,U,J,re,be){return U===null||U.tag!==7?(U=La(J,X.mode,re,be),U.return=X,U):(U=s(U,J),U.return=X,U)}function ce(X,U,J){if(typeof U=="string"&&U!==""||typeof U=="number"||typeof U=="bigint")return U=xs(""+U,X.mode,J),U.return=X,U;if(typeof U=="object"&&U!==null){switch(U.$$typeof){case x:return J=or(U.type,U.key,U.props,null,X.mode,J),ji(J,U),J.return=X,J;case _:return U=_s(U,X.mode,J),U.return=X,U;case Q:return U=qa(U),ce(X,U,J)}if(q(U)||ie(U))return U=La(U,X.mode,J,null),U.return=X,U;if(typeof U.then=="function")return ce(X,hr(U),J);if(U.$$typeof===w)return ce(X,sr(X,U),J);gr(X,U)}return null}function F(X,U,J,re){var be=U!==null?U.key:null;if(typeof J=="string"&&J!==""||typeof J=="number"||typeof J=="bigint")return be!==null?null:S(X,U,""+J,re);if(typeof J=="object"&&J!==null){switch(J.$$typeof){case x:return J.key===be?O(X,U,J,re):null;case _:return J.key===be?W(X,U,J,re):null;case Q:return J=qa(J),F(X,U,J,re)}if(q(J)||ie(J))return be!==null?null:le(X,U,J,re,null);if(typeof J.then=="function")return F(X,U,hr(J),re);if(J.$$typeof===w)return F(X,U,sr(X,J),re);gr(X,J)}return null}function te(X,U,J,re,be){if(typeof re=="string"&&re!==""||typeof re=="number"||typeof re=="bigint")return X=X.get(J)||null,S(U,X,""+re,be);if(typeof re=="object"&&re!==null){switch(re.$$typeof){case x:return X=X.get(re.key===null?J:re.key)||null,O(U,X,re,be);case _:return X=X.get(re.key===null?J:re.key)||null,W(U,X,re,be);case Q:return re=qa(re),te(X,U,J,re,be)}if(q(re)||ie(re))return X=X.get(J)||null,le(U,X,re,be,null);if(typeof re.then=="function")return te(X,U,J,hr(re),be);if(re.$$typeof===w)return te(X,U,J,sr(U,re),be);gr(U,re)}return null}function ye(X,U,J,re){for(var be=null,je=null,pe=U,Ee=U=0,ze=null;pe!==null&&Ee<J.length;Ee++){pe.index>Ee?(ze=pe,pe=null):ze=pe.sibling;var Oe=F(X,pe,J[Ee],re);if(Oe===null){pe===null&&(pe=ze);break}e&&pe&&Oe.alternate===null&&t(X,pe),U=c(Oe,U,Ee),je===null?be=Oe:je.sibling=Oe,je=Oe,pe=ze}if(Ee===J.length)return a(X,pe),ke&&Dn(X,Ee),be;if(pe===null){for(;Ee<J.length;Ee++)pe=ce(X,J[Ee],re),pe!==null&&(U=c(pe,U,Ee),je===null?be=pe:je.sibling=pe,je=pe);return ke&&Dn(X,Ee),be}for(pe=i(pe);Ee<J.length;Ee++)ze=te(pe,X,Ee,J[Ee],re),ze!==null&&(e&&ze.alternate!==null&&pe.delete(ze.key===null?Ee:ze.key),U=c(ze,U,Ee),je===null?be=ze:je.sibling=ze,je=ze);return e&&pe.forEach(function(wa){return t(X,wa)}),ke&&Dn(X,Ee),be}function xe(X,U,J,re){if(J==null)throw Error(r(151));for(var be=null,je=null,pe=U,Ee=U=0,ze=null,Oe=J.next();pe!==null&&!Oe.done;Ee++,Oe=J.next()){pe.index>Ee?(ze=pe,pe=null):ze=pe.sibling;var wa=F(X,pe,Oe.value,re);if(wa===null){pe===null&&(pe=ze);break}e&&pe&&wa.alternate===null&&t(X,pe),U=c(wa,U,Ee),je===null?be=wa:je.sibling=wa,je=wa,pe=ze}if(Oe.done)return a(X,pe),ke&&Dn(X,Ee),be;if(pe===null){for(;!Oe.done;Ee++,Oe=J.next())Oe=ce(X,Oe.value,re),Oe!==null&&(U=c(Oe,U,Ee),je===null?be=Oe:je.sibling=Oe,je=Oe);return ke&&Dn(X,Ee),be}for(pe=i(pe);!Oe.done;Ee++,Oe=J.next())Oe=te(pe,X,Ee,Oe.value,re),Oe!==null&&(e&&Oe.alternate!==null&&pe.delete(Oe.key===null?Ee:Oe.key),U=c(Oe,U,Ee),je===null?be=Oe:je.sibling=Oe,je=Oe);return e&&pe.forEach(function(Ex){return t(X,Ex)}),ke&&Dn(X,Ee),be}function Ye(X,U,J,re){if(typeof J=="object"&&J!==null&&J.type===C&&J.key===null&&(J=J.props.children),typeof J=="object"&&J!==null){switch(J.$$typeof){case x:e:{for(var be=J.key;U!==null;){if(U.key===be){if(be=J.type,be===C){if(U.tag===7){a(X,U.sibling),re=s(U,J.props.children),re.return=X,X=re;break e}}else if(U.elementType===be||typeof be=="object"&&be!==null&&be.$$typeof===Q&&qa(be)===U.type){a(X,U.sibling),re=s(U,J.props),ji(re,J),re.return=X,X=re;break e}a(X,U);break}else t(X,U);U=U.sibling}J.type===C?(re=La(J.props.children,X.mode,re,J.key),re.return=X,X=re):(re=or(J.type,J.key,J.props,null,X.mode,re),ji(re,J),re.return=X,X=re)}return m(X);case _:e:{for(be=J.key;U!==null;){if(U.key===be)if(U.tag===4&&U.stateNode.containerInfo===J.containerInfo&&U.stateNode.implementation===J.implementation){a(X,U.sibling),re=s(U,J.children||[]),re.return=X,X=re;break e}else{a(X,U);break}else t(X,U);U=U.sibling}re=_s(J,X.mode,re),re.return=X,X=re}return m(X);case Q:return J=qa(J),Ye(X,U,J,re)}if(q(J))return ye(X,U,J,re);if(ie(J)){if(be=ie(J),typeof be!="function")throw Error(r(150));return J=be.call(J),xe(X,U,J,re)}if(typeof J.then=="function")return Ye(X,U,hr(J),re);if(J.$$typeof===w)return Ye(X,U,sr(X,J),re);gr(X,J)}return typeof J=="string"&&J!==""||typeof J=="number"||typeof J=="bigint"?(J=""+J,U!==null&&U.tag===6?(a(X,U.sibling),re=s(U,J),re.return=X,X=re):(a(X,U),re=xs(J,X.mode,re),re.return=X,X=re),m(X)):a(X,U)}return function(X,U,J,re){try{Ri=0;var be=Ye(X,U,J,re);return Rl=null,be}catch(pe){if(pe===kl||pe===fr)throw pe;var je=Ot(29,pe,null,X.mode);return je.lanes=re,je.return=X,je}finally{}}}var Qa=fh(!0),dh=fh(!1),ia=!1;function Rs(e){e.updateQueue={baseState:e.memoizedState,firstBaseUpdate:null,lastBaseUpdate:null,shared:{pending:null,lanes:0,hiddenCallbacks:null},callbacks:null}}function js(e,t){e=e.updateQueue,t.updateQueue===e&&(t.updateQueue={baseState:e.baseState,firstBaseUpdate:e.firstBaseUpdate,lastBaseUpdate:e.lastBaseUpdate,shared:e.shared,callbacks:null})}function oa(e){return{lane:e,tag:0,payload:null,callback:null,next:null}}function ra(e,t,a){var i=e.updateQueue;if(i===null)return null;if(i=i.shared,(He&2)!==0){var s=i.pending;return s===null?t.next=t:(t.next=s.next,s.next=t),i.pending=t,t=ir(e),Jd(e,null,a),t}return lr(e,i,t,a),ir(e)}function Oi(e,t,a){if(t=t.updateQueue,t!==null&&(t=t.shared,(a&4194048)!==0)){var i=t.lanes;i&=e.pendingLanes,a|=i,t.lanes=a,Lo(e,a)}}function Os(e,t){var a=e.updateQueue,i=e.alternate;if(i!==null&&(i=i.updateQueue,a===i)){var s=null,c=null;if(a=a.firstBaseUpdate,a!==null){do{var m={lane:a.lane,tag:a.tag,payload:a.payload,callback:null,next:null};c===null?s=c=m:c=c.next=m,a=a.next}while(a!==null);c===null?s=c=t:c=c.next=t}else s=c=t;a={baseState:i.baseState,firstBaseUpdate:s,lastBaseUpdate:c,shared:i.shared,callbacks:i.callbacks},e.updateQueue=a;return}e=a.lastBaseUpdate,e===null?a.firstBaseUpdate=t:e.next=t,a.lastBaseUpdate=t}var Hs=!1;function Hi(){if(Hs){var e=Dl;if(e!==null)throw e}}function Bi(e,t,a,i){Hs=!1;var s=e.updateQueue;ia=!1;var c=s.firstBaseUpdate,m=s.lastBaseUpdate,S=s.shared.pending;if(S!==null){s.shared.pending=null;var O=S,W=O.next;O.next=null,m===null?c=W:m.next=W,m=O;var le=e.alternate;le!==null&&(le=le.updateQueue,S=le.lastBaseUpdate,S!==m&&(S===null?le.firstBaseUpdate=W:S.next=W,le.lastBaseUpdate=O))}if(c!==null){var ce=s.baseState;m=0,le=W=O=null,S=c;do{var F=S.lane&-536870913,te=F!==S.lane;if(te?(Me&F)===F:(i&F)===F){F!==0&&F===zl&&(Hs=!0),le!==null&&(le=le.next={lane:0,tag:S.tag,payload:S.payload,callback:null,next:null});e:{var ye=e,xe=S;F=t;var Ye=a;switch(xe.tag){case 1:if(ye=xe.payload,typeof ye=="function"){ce=ye.call(Ye,ce,F);break e}ce=ye;break e;case 3:ye.flags=ye.flags&-65537|128;case 0:if(ye=xe.payload,F=typeof ye=="function"?ye.call(Ye,ce,F):ye,F==null)break e;ce=p({},ce,F);break e;case 2:ia=!0}}F=S.callback,F!==null&&(e.flags|=64,te&&(e.flags|=8192),te=s.callbacks,te===null?s.callbacks=[F]:te.push(F))}else te={lane:F,tag:S.tag,payload:S.payload,callback:S.callback,next:null},le===null?(W=le=te,O=ce):le=le.next=te,m|=F;if(S=S.next,S===null){if(S=s.shared.pending,S===null)break;te=S,S=te.next,te.next=null,s.lastBaseUpdate=te,s.shared.pending=null}}while(!0);le===null&&(O=ce),s.baseState=O,s.firstBaseUpdate=W,s.lastBaseUpdate=le,c===null&&(s.shared.lanes=0),da|=m,e.lanes=m,e.memoizedState=ce}}function hh(e,t){if(typeof e!="function")throw Error(r(191,e));e.call(t)}function gh(e,t){var a=e.callbacks;if(a!==null)for(e.callbacks=null,e=0;e<a.length;e++)hh(a[e],t)}var jl=N(null),yr=N(0);function yh(e,t){e=Vn,ee(yr,e),ee(jl,t),Vn=e|t.baseLanes}function Bs(){ee(yr,Vn),ee(jl,jl.current)}function Ls(){Vn=yr.current,R(jl),R(yr)}var Ht=N(null),Wt=null;function ua(e){var t=e.alternate;ee(Fe,Fe.current&1),ee(Ht,e),Wt===null&&(t===null||jl.current!==null||t.memoizedState!==null)&&(Wt=e)}function Us(e){ee(Fe,Fe.current),ee(Ht,e),Wt===null&&(Wt=e)}function mh(e){e.tag===22?(ee(Fe,Fe.current),ee(Ht,e),Wt===null&&(Wt=e)):sa()}function sa(){ee(Fe,Fe.current),ee(Ht,Ht.current)}function Bt(e){R(Ht),Wt===e&&(Wt=null),R(Fe)}var Fe=N(0);function mr(e){for(var t=e;t!==null;){if(t.tag===13){var a=t.memoizedState;if(a!==null&&(a=a.dehydrated,a===null||Qc(a)||$c(a)))return t}else if(t.tag===19&&(t.memoizedProps.revealOrder==="forwards"||t.memoizedProps.revealOrder==="backwards"||t.memoizedProps.revealOrder==="unstable_legacy-backwards"||t.memoizedProps.revealOrder==="together")){if((t.flags&128)!==0)return t}else if(t.child!==null){t.child.return=t,t=t.child;continue}if(t===e)break;for(;t.sibling===null;){if(t.return===null||t.return===e)return null;t=t.return}t.sibling.return=t.return,t=t.sibling}return null}var jn=0,Se=null,Ue=null,nt=null,pr=!1,Ol=!1,$a=!1,vr=0,Li=0,Hl=null,gb=0;function Je(){throw Error(r(321))}function Gs(e,t){if(t===null)return!1;for(var a=0;a<t.length&&a<e.length;a++)if(!jt(e[a],t[a]))return!1;return!0}function Ys(e,t,a,i,s,c){return jn=c,Se=t,t.memoizedState=null,t.updateQueue=null,t.lanes=0,A.H=e===null||e.memoizedState===null?Ph:nc,$a=!1,c=a(i,s),$a=!1,Ol&&(c=vh(t,a,i,s)),ph(e),c}function ph(e){A.H=Yi;var t=Ue!==null&&Ue.next!==null;if(jn=0,nt=Ue=Se=null,pr=!1,Li=0,Hl=null,t)throw Error(r(300));e===null||at||(e=e.dependencies,e!==null&&ur(e)&&(at=!0))}function vh(e,t,a,i){Se=e;var s=0;do{if(Ol&&(Hl=null),Li=0,Ol=!1,25<=s)throw Error(r(301));if(s+=1,nt=Ue=null,e.updateQueue!=null){var c=e.updateQueue;c.lastEffect=null,c.events=null,c.stores=null,c.memoCache!=null&&(c.memoCache.index=0)}A.H=eg,c=t(a,i)}while(Ol);return c}function yb(){var e=A.H,t=e.useState()[0];return t=typeof t.then=="function"?Ui(t):t,e=e.useState()[0],(Ue!==null?Ue.memoizedState:null)!==e&&(Se.flags|=1024),t}function Vs(){var e=vr!==0;return vr=0,e}function qs(e,t,a){t.updateQueue=e.updateQueue,t.flags&=-2053,e.lanes&=~a}function Xs(e){if(pr){for(e=e.memoizedState;e!==null;){var t=e.queue;t!==null&&(t.pending=null),e=e.next}pr=!1}jn=0,nt=Ue=Se=null,Ol=!1,Li=vr=0,Hl=null}function bt(){var e={memoizedState:null,baseState:null,baseQueue:null,queue:null,next:null};return nt===null?Se.memoizedState=nt=e:nt=nt.next=e,nt}function Pe(){if(Ue===null){var e=Se.alternate;e=e!==null?e.memoizedState:null}else e=Ue.next;var t=nt===null?Se.memoizedState:nt.next;if(t!==null)nt=t,Ue=e;else{if(e===null)throw Se.alternate===null?Error(r(467)):Error(r(310));Ue=e,e={memoizedState:Ue.memoizedState,baseState:Ue.baseState,baseQueue:Ue.baseQueue,queue:Ue.queue,next:null},nt===null?Se.memoizedState=nt=e:nt=nt.next=e}return nt}function br(){return{lastEffect:null,events:null,stores:null,memoCache:null}}function Ui(e){var t=Li;return Li+=1,Hl===null&&(Hl=[]),e=uh(Hl,e,t),t=Se,(nt===null?t.memoizedState:nt.next)===null&&(t=t.alternate,A.H=t===null||t.memoizedState===null?Ph:nc),e}function xr(e){if(e!==null&&typeof e=="object"){if(typeof e.then=="function")return Ui(e);if(e.$$typeof===w)return ft(e)}throw Error(r(438,String(e)))}function Qs(e){var t=null,a=Se.updateQueue;if(a!==null&&(t=a.memoCache),t==null){var i=Se.alternate;i!==null&&(i=i.updateQueue,i!==null&&(i=i.memoCache,i!=null&&(t={data:i.data.map(function(s){return s.slice()}),index:0})))}if(t==null&&(t={data:[],index:0}),a===null&&(a=br(),Se.updateQueue=a),a.memoCache=t,a=t.data[t.index],a===void 0)for(a=t.data[t.index]=Array(e),i=0;i<e;i++)a[i]=ue;return t.index++,a}function On(e,t){return typeof t=="function"?t(e):t}function _r(e){var t=Pe();return $s(t,Ue,e)}function $s(e,t,a){var i=e.queue;if(i===null)throw Error(r(311));i.lastRenderedReducer=a;var s=e.baseQueue,c=i.pending;if(c!==null){if(s!==null){var m=s.next;s.next=c.next,c.next=m}t.baseQueue=s=c,i.pending=null}if(c=e.baseState,s===null)e.memoizedState=c;else{t=s.next;var S=m=null,O=null,W=t,le=!1;do{var ce=W.lane&-536870913;if(ce!==W.lane?(Me&ce)===ce:(jn&ce)===ce){var F=W.revertLane;if(F===0)O!==null&&(O=O.next={lane:0,revertLane:0,gesture:null,action:W.action,hasEagerState:W.hasEagerState,eagerState:W.eagerState,next:null}),ce===zl&&(le=!0);else if((jn&F)===F){W=W.next,F===zl&&(le=!0);continue}else ce={lane:0,revertLane:W.revertLane,gesture:null,action:W.action,hasEagerState:W.hasEagerState,eagerState:W.eagerState,next:null},O===null?(S=O=ce,m=c):O=O.next=ce,Se.lanes|=F,da|=F;ce=W.action,$a&&a(c,ce),c=W.hasEagerState?W.eagerState:a(c,ce)}else F={lane:ce,revertLane:W.revertLane,gesture:W.gesture,action:W.action,hasEagerState:W.hasEagerState,eagerState:W.eagerState,next:null},O===null?(S=O=F,m=c):O=O.next=F,Se.lanes|=ce,da|=ce;W=W.next}while(W!==null&&W!==t);if(O===null?m=c:O.next=S,!jt(c,e.memoizedState)&&(at=!0,le&&(a=Dl,a!==null)))throw a;e.memoizedState=c,e.baseState=m,e.baseQueue=O,i.lastRenderedState=c}return s===null&&(i.lanes=0),[e.memoizedState,i.dispatch]}function Zs(e){var t=Pe(),a=t.queue;if(a===null)throw Error(r(311));a.lastRenderedReducer=e;var i=a.dispatch,s=a.pending,c=t.memoizedState;if(s!==null){a.pending=null;var m=s=s.next;do c=e(c,m.action),m=m.next;while(m!==s);jt(c,t.memoizedState)||(at=!0),t.memoizedState=c,t.baseQueue===null&&(t.baseState=c),a.lastRenderedState=c}return[c,i]}function bh(e,t,a){var i=Se,s=Pe(),c=ke;if(c){if(a===void 0)throw Error(r(407));a=a()}else a=t();var m=!jt((Ue||s).memoizedState,a);if(m&&(s.memoizedState=a,at=!0),s=s.queue,Is(wh.bind(null,i,s,e),[e]),s.getSnapshot!==t||m||nt!==null&&nt.memoizedState.tag&1){if(i.flags|=2048,Bl(9,{destroy:void 0},_h.bind(null,i,s,a,t),null),Ve===null)throw Error(r(349));c||(jn&127)!==0||xh(i,t,a)}return a}function xh(e,t,a){e.flags|=16384,e={getSnapshot:t,value:a},t=Se.updateQueue,t===null?(t=br(),Se.updateQueue=t,t.stores=[e]):(a=t.stores,a===null?t.stores=[e]:a.push(e))}function _h(e,t,a,i){t.value=a,t.getSnapshot=i,Sh(t)&&Eh(e)}function wh(e,t,a){return a(function(){Sh(t)&&Eh(e)})}function Sh(e){var t=e.getSnapshot;e=e.value;try{var a=t();return!jt(e,a)}catch{return!0}}function Eh(e){var t=Ba(e,2);t!==null&&zt(t,e,2)}function Ks(e){var t=bt();if(typeof e=="function"){var a=e;if(e=a(),$a){hn(!0);try{a()}finally{hn(!1)}}}return t.memoizedState=t.baseState=e,t.queue={pending:null,lanes:0,dispatch:null,lastRenderedReducer:On,lastRenderedState:e},t}function Nh(e,t,a,i){return e.baseState=a,$s(e,Ue,typeof i=="function"?i:On)}function mb(e,t,a,i,s){if(Er(e))throw Error(r(485));if(e=t.action,e!==null){var c={payload:s,action:e,next:null,isTransition:!0,status:"pending",value:null,reason:null,listeners:[],then:function(m){c.listeners.push(m)}};A.T!==null?a(!0):c.isTransition=!1,i(c),a=t.pending,a===null?(c.next=t.pending=c,Th(t,c)):(c.next=a.next,t.pending=a.next=c)}}function Th(e,t){var a=t.action,i=t.payload,s=e.state;if(t.isTransition){var c=A.T,m={};A.T=m;try{var S=a(s,i),O=A.S;O!==null&&O(m,S),Ah(e,t,S)}catch(W){Js(e,t,W)}finally{c!==null&&m.types!==null&&(c.types=m.types),A.T=c}}else try{c=a(s,i),Ah(e,t,c)}catch(W){Js(e,t,W)}}function Ah(e,t,a){a!==null&&typeof a=="object"&&typeof a.then=="function"?a.then(function(i){Ch(e,t,i)},function(i){return Js(e,t,i)}):Ch(e,t,a)}function Ch(e,t,a){t.status="fulfilled",t.value=a,Mh(t),e.state=a,t=e.pending,t!==null&&(a=t.next,a===t?e.pending=null:(a=a.next,t.next=a,Th(e,a)))}function Js(e,t,a){var i=e.pending;if(e.pending=null,i!==null){i=i.next;do t.status="rejected",t.reason=a,Mh(t),t=t.next;while(t!==i)}e.action=null}function Mh(e){e=e.listeners;for(var t=0;t<e.length;t++)(0,e[t])()}function zh(e,t){return t}function Dh(e,t){if(ke){var a=Ve.formState;if(a!==null){e:{var i=Se;if(ke){if(qe){t:{for(var s=qe,c=It;s.nodeType!==8;){if(!c){s=null;break t}if(s=Ft(s.nextSibling),s===null){s=null;break t}}c=s.data,s=c==="F!"||c==="F"?s:null}if(s){qe=Ft(s.nextSibling),i=s.data==="F!";break e}}aa(i)}i=!1}i&&(t=a[0])}}return a=bt(),a.memoizedState=a.baseState=t,i={pending:null,lanes:0,dispatch:null,lastRenderedReducer:zh,lastRenderedState:t},a.queue=i,a=Ih.bind(null,Se,i),i.dispatch=a,i=Ks(!1),c=tc.bind(null,Se,!1,i.queue),i=bt(),s={state:t,dispatch:null,action:e,pending:null},i.queue=s,a=mb.bind(null,Se,s,c,a),s.dispatch=a,i.memoizedState=e,[t,a,!1]}function kh(e){var t=Pe();return Rh(t,Ue,e)}function Rh(e,t,a){if(t=$s(e,t,zh)[0],e=_r(On)[0],typeof t=="object"&&t!==null&&typeof t.then=="function")try{var i=Ui(t)}catch(m){throw m===kl?fr:m}else i=t;t=Pe();var s=t.queue,c=s.dispatch;return a!==t.memoizedState&&(Se.flags|=2048,Bl(9,{destroy:void 0},pb.bind(null,s,a),null)),[i,c,e]}function pb(e,t){e.action=t}function jh(e){var t=Pe(),a=Ue;if(a!==null)return Rh(t,a,e);Pe(),t=t.memoizedState,a=Pe();var i=a.queue.dispatch;return a.memoizedState=e,[t,i,!1]}function Bl(e,t,a,i){return e={tag:e,create:a,deps:i,inst:t,next:null},t=Se.updateQueue,t===null&&(t=br(),Se.updateQueue=t),a=t.lastEffect,a===null?t.lastEffect=e.next=e:(i=a.next,a.next=e,e.next=i,t.lastEffect=e),e}function Oh(){return Pe().memoizedState}function wr(e,t,a,i){var s=bt();Se.flags|=e,s.memoizedState=Bl(1|t,{destroy:void 0},a,i===void 0?null:i)}function Sr(e,t,a,i){var s=Pe();i=i===void 0?null:i;var c=s.memoizedState.inst;Ue!==null&&i!==null&&Gs(i,Ue.memoizedState.deps)?s.memoizedState=Bl(t,c,a,i):(Se.flags|=e,s.memoizedState=Bl(1|t,c,a,i))}function Hh(e,t){wr(8390656,8,e,t)}function Is(e,t){Sr(2048,8,e,t)}function vb(e){Se.flags|=4;var t=Se.updateQueue;if(t===null)t=br(),Se.updateQueue=t,t.events=[e];else{var a=t.events;a===null?t.events=[e]:a.push(e)}}function Bh(e){var t=Pe().memoizedState;return vb({ref:t,nextImpl:e}),function(){if((He&2)!==0)throw Error(r(440));return t.impl.apply(void 0,arguments)}}function Lh(e,t){return Sr(4,2,e,t)}function Uh(e,t){return Sr(4,4,e,t)}function Gh(e,t){if(typeof t=="function"){e=e();var a=t(e);return function(){typeof a=="function"?a():t(null)}}if(t!=null)return e=e(),t.current=e,function(){t.current=null}}function Yh(e,t,a){a=a!=null?a.concat([e]):null,Sr(4,4,Gh.bind(null,t,e),a)}function Ws(){}function Vh(e,t){var a=Pe();t=t===void 0?null:t;var i=a.memoizedState;return t!==null&&Gs(t,i[1])?i[0]:(a.memoizedState=[e,t],e)}function qh(e,t){var a=Pe();t=t===void 0?null:t;var i=a.memoizedState;if(t!==null&&Gs(t,i[1]))return i[0];if(i=e(),$a){hn(!0);try{e()}finally{hn(!1)}}return a.memoizedState=[i,t],i}function Fs(e,t,a){return a===void 0||(jn&1073741824)!==0&&(Me&261930)===0?e.memoizedState=t:(e.memoizedState=a,e=Xg(),Se.lanes|=e,da|=e,a)}function Xh(e,t,a,i){return jt(a,t)?a:jl.current!==null?(e=Fs(e,a,i),jt(e,t)||(at=!0),e):(jn&42)===0||(jn&1073741824)!==0&&(Me&261930)===0?(at=!0,e.memoizedState=a):(e=Xg(),Se.lanes|=e,da|=e,t)}function Qh(e,t,a,i,s){var c=j.p;j.p=c!==0&&8>c?c:8;var m=A.T,S={};A.T=S,tc(e,!1,t,a);try{var O=s(),W=A.S;if(W!==null&&W(S,O),O!==null&&typeof O=="object"&&typeof O.then=="function"){var le=hb(O,i);Gi(e,t,le,Gt(e))}else Gi(e,t,i,Gt(e))}catch(ce){Gi(e,t,{then:function(){},status:"rejected",reason:ce},Gt())}finally{j.p=c,m!==null&&S.types!==null&&(m.types=S.types),A.T=m}}function bb(){}function Ps(e,t,a,i){if(e.tag!==5)throw Error(r(476));var s=$h(e).queue;Qh(e,s,t,V,a===null?bb:function(){return Zh(e),a(i)})}function $h(e){var t=e.memoizedState;if(t!==null)return t;t={memoizedState:V,baseState:V,baseQueue:null,queue:{pending:null,lanes:0,dispatch:null,lastRenderedReducer:On,lastRenderedState:V},next:null};var a={};return t.next={memoizedState:a,baseState:a,baseQueue:null,queue:{pending:null,lanes:0,dispatch:null,lastRenderedReducer:On,lastRenderedState:a},next:null},e.memoizedState=t,e=e.alternate,e!==null&&(e.memoizedState=t),t}function Zh(e){var t=$h(e);t.next===null&&(t=e.alternate.memoizedState),Gi(e,t.next.queue,{},Gt())}function ec(){return ft(ao)}function Kh(){return Pe().memoizedState}function Jh(){return Pe().memoizedState}function xb(e){for(var t=e.return;t!==null;){switch(t.tag){case 24:case 3:var a=Gt();e=oa(a);var i=ra(t,e,a);i!==null&&(zt(i,t,a),Oi(i,t,a)),t={cache:Ms()},e.payload=t;return}t=t.return}}function _b(e,t,a){var i=Gt();a={lane:i,revertLane:0,gesture:null,action:a,hasEagerState:!1,eagerState:null,next:null},Er(e)?Wh(t,a):(a=vs(e,t,a,i),a!==null&&(zt(a,e,i),Fh(a,t,i)))}function Ih(e,t,a){var i=Gt();Gi(e,t,a,i)}function Gi(e,t,a,i){var s={lane:i,revertLane:0,gesture:null,action:a,hasEagerState:!1,eagerState:null,next:null};if(Er(e))Wh(t,s);else{var c=e.alternate;if(e.lanes===0&&(c===null||c.lanes===0)&&(c=t.lastRenderedReducer,c!==null))try{var m=t.lastRenderedState,S=c(m,a);if(s.hasEagerState=!0,s.eagerState=S,jt(S,m))return lr(e,t,s,0),Ve===null&&ar(),!1}catch{}finally{}if(a=vs(e,t,s,i),a!==null)return zt(a,e,i),Fh(a,t,i),!0}return!1}function tc(e,t,a,i){if(i={lane:2,revertLane:Rc(),gesture:null,action:i,hasEagerState:!1,eagerState:null,next:null},Er(e)){if(t)throw Error(r(479))}else t=vs(e,a,i,2),t!==null&&zt(t,e,2)}function Er(e){var t=e.alternate;return e===Se||t!==null&&t===Se}function Wh(e,t){Ol=pr=!0;var a=e.pending;a===null?t.next=t:(t.next=a.next,a.next=t),e.pending=t}function Fh(e,t,a){if((a&4194048)!==0){var i=t.lanes;i&=e.pendingLanes,a|=i,t.lanes=a,Lo(e,a)}}var Yi={readContext:ft,use:xr,useCallback:Je,useContext:Je,useEffect:Je,useImperativeHandle:Je,useLayoutEffect:Je,useInsertionEffect:Je,useMemo:Je,useReducer:Je,useRef:Je,useState:Je,useDebugValue:Je,useDeferredValue:Je,useTransition:Je,useSyncExternalStore:Je,useId:Je,useHostTransitionStatus:Je,useFormState:Je,useActionState:Je,useOptimistic:Je,useMemoCache:Je,useCacheRefresh:Je};Yi.useEffectEvent=Je;var Ph={readContext:ft,use:xr,useCallback:function(e,t){return bt().memoizedState=[e,t===void 0?null:t],e},useContext:ft,useEffect:Hh,useImperativeHandle:function(e,t,a){a=a!=null?a.concat([e]):null,wr(4194308,4,Gh.bind(null,t,e),a)},useLayoutEffect:function(e,t){return wr(4194308,4,e,t)},useInsertionEffect:function(e,t){wr(4,2,e,t)},useMemo:function(e,t){var a=bt();t=t===void 0?null:t;var i=e();if($a){hn(!0);try{e()}finally{hn(!1)}}return a.memoizedState=[i,t],i},useReducer:function(e,t,a){var i=bt();if(a!==void 0){var s=a(t);if($a){hn(!0);try{a(t)}finally{hn(!1)}}}else s=t;return i.memoizedState=i.baseState=s,e={pending:null,lanes:0,dispatch:null,lastRenderedReducer:e,lastRenderedState:s},i.queue=e,e=e.dispatch=_b.bind(null,Se,e),[i.memoizedState,e]},useRef:function(e){var t=bt();return e={current:e},t.memoizedState=e},useState:function(e){e=Ks(e);var t=e.queue,a=Ih.bind(null,Se,t);return t.dispatch=a,[e.memoizedState,a]},useDebugValue:Ws,useDeferredValue:function(e,t){var a=bt();return Fs(a,e,t)},useTransition:function(){var e=Ks(!1);return e=Qh.bind(null,Se,e.queue,!0,!1),bt().memoizedState=e,[!1,e]},useSyncExternalStore:function(e,t,a){var i=Se,s=bt();if(ke){if(a===void 0)throw Error(r(407));a=a()}else{if(a=t(),Ve===null)throw Error(r(349));(Me&127)!==0||xh(i,t,a)}s.memoizedState=a;var c={value:a,getSnapshot:t};return s.queue=c,Hh(wh.bind(null,i,c,e),[e]),i.flags|=2048,Bl(9,{destroy:void 0},_h.bind(null,i,c,a,t),null),a},useId:function(){var e=bt(),t=Ve.identifierPrefix;if(ke){var a=mn,i=yn;a=(i&~(1<<32-vt(i)-1)).toString(32)+a,t="_"+t+"R_"+a,a=vr++,0<a&&(t+="H"+a.toString(32)),t+="_"}else a=gb++,t="_"+t+"r_"+a.toString(32)+"_";return e.memoizedState=t},useHostTransitionStatus:ec,useFormState:Dh,useActionState:Dh,useOptimistic:function(e){var t=bt();t.memoizedState=t.baseState=e;var a={pending:null,lanes:0,dispatch:null,lastRenderedReducer:null,lastRenderedState:null};return t.queue=a,t=tc.bind(null,Se,!0,a),a.dispatch=t,[e,t]},useMemoCache:Qs,useCacheRefresh:function(){return bt().memoizedState=xb.bind(null,Se)},useEffectEvent:function(e){var t=bt(),a={impl:e};return t.memoizedState=a,function(){if((He&2)!==0)throw Error(r(440));return a.impl.apply(void 0,arguments)}}},nc={readContext:ft,use:xr,useCallback:Vh,useContext:ft,useEffect:Is,useImperativeHandle:Yh,useInsertionEffect:Lh,useLayoutEffect:Uh,useMemo:qh,useReducer:_r,useRef:Oh,useState:function(){return _r(On)},useDebugValue:Ws,useDeferredValue:function(e,t){var a=Pe();return Xh(a,Ue.memoizedState,e,t)},useTransition:function(){var e=_r(On)[0],t=Pe().memoizedState;return[typeof e=="boolean"?e:Ui(e),t]},useSyncExternalStore:bh,useId:Kh,useHostTransitionStatus:ec,useFormState:kh,useActionState:kh,useOptimistic:function(e,t){var a=Pe();return Nh(a,Ue,e,t)},useMemoCache:Qs,useCacheRefresh:Jh};nc.useEffectEvent=Bh;var eg={readContext:ft,use:xr,useCallback:Vh,useContext:ft,useEffect:Is,useImperativeHandle:Yh,useInsertionEffect:Lh,useLayoutEffect:Uh,useMemo:qh,useReducer:Zs,useRef:Oh,useState:function(){return Zs(On)},useDebugValue:Ws,useDeferredValue:function(e,t){var a=Pe();return Ue===null?Fs(a,e,t):Xh(a,Ue.memoizedState,e,t)},useTransition:function(){var e=Zs(On)[0],t=Pe().memoizedState;return[typeof e=="boolean"?e:Ui(e),t]},useSyncExternalStore:bh,useId:Kh,useHostTransitionStatus:ec,useFormState:jh,useActionState:jh,useOptimistic:function(e,t){var a=Pe();return Ue!==null?Nh(a,Ue,e,t):(a.baseState=e,[e,a.queue.dispatch])},useMemoCache:Qs,useCacheRefresh:Jh};eg.useEffectEvent=Bh;function ac(e,t,a,i){t=e.memoizedState,a=a(i,t),a=a==null?t:p({},t,a),e.memoizedState=a,e.lanes===0&&(e.updateQueue.baseState=a)}var lc={enqueueSetState:function(e,t,a){e=e._reactInternals;var i=Gt(),s=oa(i);s.payload=t,a!=null&&(s.callback=a),t=ra(e,s,i),t!==null&&(zt(t,e,i),Oi(t,e,i))},enqueueReplaceState:function(e,t,a){e=e._reactInternals;var i=Gt(),s=oa(i);s.tag=1,s.payload=t,a!=null&&(s.callback=a),t=ra(e,s,i),t!==null&&(zt(t,e,i),Oi(t,e,i))},enqueueForceUpdate:function(e,t){e=e._reactInternals;var a=Gt(),i=oa(a);i.tag=2,t!=null&&(i.callback=t),t=ra(e,i,a),t!==null&&(zt(t,e,a),Oi(t,e,a))}};function tg(e,t,a,i,s,c,m){return e=e.stateNode,typeof e.shouldComponentUpdate=="function"?e.shouldComponentUpdate(i,c,m):t.prototype&&t.prototype.isPureReactComponent?!Ai(a,i)||!Ai(s,c):!0}function ng(e,t,a,i){e=t.state,typeof t.componentWillReceiveProps=="function"&&t.componentWillReceiveProps(a,i),typeof t.UNSAFE_componentWillReceiveProps=="function"&&t.UNSAFE_componentWillReceiveProps(a,i),t.state!==e&&lc.enqueueReplaceState(t,t.state,null)}function Za(e,t){var a=t;if("ref"in t){a={};for(var i in t)i!=="ref"&&(a[i]=t[i])}if(e=e.defaultProps){a===t&&(a=p({},a));for(var s in e)a[s]===void 0&&(a[s]=e[s])}return a}function ag(e){nr(e)}function lg(e){console.error(e)}function ig(e){nr(e)}function Nr(e,t){try{var a=e.onUncaughtError;a(t.value,{componentStack:t.stack})}catch(i){setTimeout(function(){throw i})}}function og(e,t,a){try{var i=e.onCaughtError;i(a.value,{componentStack:a.stack,errorBoundary:t.tag===1?t.stateNode:null})}catch(s){setTimeout(function(){throw s})}}function ic(e,t,a){return a=oa(a),a.tag=3,a.payload={element:null},a.callback=function(){Nr(e,t)},a}function rg(e){return e=oa(e),e.tag=3,e}function ug(e,t,a,i){var s=a.type.getDerivedStateFromError;if(typeof s=="function"){var c=i.value;e.payload=function(){return s(c)},e.callback=function(){og(t,a,i)}}var m=a.stateNode;m!==null&&typeof m.componentDidCatch=="function"&&(e.callback=function(){og(t,a,i),typeof s!="function"&&(ha===null?ha=new Set([this]):ha.add(this));var S=i.stack;this.componentDidCatch(i.value,{componentStack:S!==null?S:""})})}function wb(e,t,a,i,s){if(a.flags|=32768,i!==null&&typeof i=="object"&&typeof i.then=="function"){if(t=a.alternate,t!==null&&Ml(t,a,s,!0),a=Ht.current,a!==null){switch(a.tag){case 31:case 13:return Wt===null?Br():a.alternate===null&&Ie===0&&(Ie=3),a.flags&=-257,a.flags|=65536,a.lanes=s,i===dr?a.flags|=16384:(t=a.updateQueue,t===null?a.updateQueue=new Set([i]):t.add(i),zc(e,i,s)),!1;case 22:return a.flags|=65536,i===dr?a.flags|=16384:(t=a.updateQueue,t===null?(t={transitions:null,markerInstances:null,retryQueue:new Set([i])},a.updateQueue=t):(a=t.retryQueue,a===null?t.retryQueue=new Set([i]):a.add(i)),zc(e,i,s)),!1}throw Error(r(435,a.tag))}return zc(e,i,s),Br(),!1}if(ke)return t=Ht.current,t!==null?((t.flags&65536)===0&&(t.flags|=256),t.flags|=65536,t.lanes=s,i!==Es&&(e=Error(r(422),{cause:i}),zi(Zt(e,a)))):(i!==Es&&(t=Error(r(423),{cause:i}),zi(Zt(t,a))),e=e.current.alternate,e.flags|=65536,s&=-s,e.lanes|=s,i=Zt(i,a),s=ic(e.stateNode,i,s),Os(e,s),Ie!==4&&(Ie=2)),!1;var c=Error(r(520),{cause:i});if(c=Zt(c,a),Ji===null?Ji=[c]:Ji.push(c),Ie!==4&&(Ie=2),t===null)return!0;i=Zt(i,a),a=t;do{switch(a.tag){case 3:return a.flags|=65536,e=s&-s,a.lanes|=e,e=ic(a.stateNode,i,e),Os(a,e),!1;case 1:if(t=a.type,c=a.stateNode,(a.flags&128)===0&&(typeof t.getDerivedStateFromError=="function"||c!==null&&typeof c.componentDidCatch=="function"&&(ha===null||!ha.has(c))))return a.flags|=65536,s&=-s,a.lanes|=s,s=rg(s),ug(s,e,a,i),Os(a,s),!1}a=a.return}while(a!==null);return!1}var oc=Error(r(461)),at=!1;function dt(e,t,a,i){t.child=e===null?dh(t,null,a,i):Qa(t,e.child,a,i)}function sg(e,t,a,i,s){a=a.render;var c=t.ref;if("ref"in i){var m={};for(var S in i)S!=="ref"&&(m[S]=i[S])}else m=i;return Ya(t),i=Ys(e,t,a,m,c,s),S=Vs(),e!==null&&!at?(qs(e,t,s),Hn(e,t,s)):(ke&&S&&ws(t),t.flags|=1,dt(e,t,i,s),t.child)}function cg(e,t,a,i,s){if(e===null){var c=a.type;return typeof c=="function"&&!bs(c)&&c.defaultProps===void 0&&a.compare===null?(t.tag=15,t.type=c,fg(e,t,c,i,s)):(e=or(a.type,null,i,t,t.mode,s),e.ref=t.ref,e.return=t,t.child=e)}if(c=e.child,!gc(e,s)){var m=c.memoizedProps;if(a=a.compare,a=a!==null?a:Ai,a(m,i)&&e.ref===t.ref)return Hn(e,t,s)}return t.flags|=1,e=zn(c,i),e.ref=t.ref,e.return=t,t.child=e}function fg(e,t,a,i,s){if(e!==null){var c=e.memoizedProps;if(Ai(c,i)&&e.ref===t.ref)if(at=!1,t.pendingProps=i=c,gc(e,s))(e.flags&131072)!==0&&(at=!0);else return t.lanes=e.lanes,Hn(e,t,s)}return rc(e,t,a,i,s)}function dg(e,t,a,i){var s=i.children,c=e!==null?e.memoizedState:null;if(e===null&&t.stateNode===null&&(t.stateNode={_visibility:1,_pendingMarkers:null,_retryCache:null,_transitions:null}),i.mode==="hidden"){if((t.flags&128)!==0){if(c=c!==null?c.baseLanes|a:a,e!==null){for(i=t.child=e.child,s=0;i!==null;)s=s|i.lanes|i.childLanes,i=i.sibling;i=s&~c}else i=0,t.child=null;return hg(e,t,c,a,i)}if((a&536870912)!==0)t.memoizedState={baseLanes:0,cachePool:null},e!==null&&cr(t,c!==null?c.cachePool:null),c!==null?yh(t,c):Bs(),mh(t);else return i=t.lanes=536870912,hg(e,t,c!==null?c.baseLanes|a:a,a,i)}else c!==null?(cr(t,c.cachePool),yh(t,c),sa(),t.memoizedState=null):(e!==null&&cr(t,null),Bs(),sa());return dt(e,t,s,a),t.child}function Vi(e,t){return e!==null&&e.tag===22||t.stateNode!==null||(t.stateNode={_visibility:1,_pendingMarkers:null,_retryCache:null,_transitions:null}),t.sibling}function hg(e,t,a,i,s){var c=Ds();return c=c===null?null:{parent:tt._currentValue,pool:c},t.memoizedState={baseLanes:a,cachePool:c},e!==null&&cr(t,null),Bs(),mh(t),e!==null&&Ml(e,t,i,!0),t.childLanes=s,null}function Tr(e,t){return t=Cr({mode:t.mode,children:t.children},e.mode),t.ref=e.ref,e.child=t,t.return=e,t}function gg(e,t,a){return Qa(t,e.child,null,a),e=Tr(t,t.pendingProps),e.flags|=2,Bt(t),t.memoizedState=null,e}function Sb(e,t,a){var i=t.pendingProps,s=(t.flags&128)!==0;if(t.flags&=-129,e===null){if(ke){if(i.mode==="hidden")return e=Tr(t,i),t.lanes=536870912,Vi(null,e);if(Us(t),(e=qe)?(e=T0(e,It),e=e!==null&&e.data==="&"?e:null,e!==null&&(t.memoizedState={dehydrated:e,treeContext:ta!==null?{id:yn,overflow:mn}:null,retryLane:536870912,hydrationErrors:null},a=Wd(e),a.return=t,t.child=a,ct=t,qe=null)):e=null,e===null)throw aa(t);return t.lanes=536870912,null}return Tr(t,i)}var c=e.memoizedState;if(c!==null){var m=c.dehydrated;if(Us(t),s)if(t.flags&256)t.flags&=-257,t=gg(e,t,a);else if(t.memoizedState!==null)t.child=e.child,t.flags|=128,t=null;else throw Error(r(558));else if(at||Ml(e,t,a,!1),s=(a&e.childLanes)!==0,at||s){if(i=Ve,i!==null&&(m=Uo(i,a),m!==0&&m!==c.retryLane))throw c.retryLane=m,Ba(e,m),zt(i,e,m),oc;Br(),t=gg(e,t,a)}else e=c.treeContext,qe=Ft(m.nextSibling),ct=t,ke=!0,na=null,It=!1,e!==null&&eh(t,e),t=Tr(t,i),t.flags|=4096;return t}return e=zn(e.child,{mode:i.mode,children:i.children}),e.ref=t.ref,t.child=e,e.return=t,e}function Ar(e,t){var a=t.ref;if(a===null)e!==null&&e.ref!==null&&(t.flags|=4194816);else{if(typeof a!="function"&&typeof a!="object")throw Error(r(284));(e===null||e.ref!==a)&&(t.flags|=4194816)}}function rc(e,t,a,i,s){return Ya(t),a=Ys(e,t,a,i,void 0,s),i=Vs(),e!==null&&!at?(qs(e,t,s),Hn(e,t,s)):(ke&&i&&ws(t),t.flags|=1,dt(e,t,a,s),t.child)}function yg(e,t,a,i,s,c){return Ya(t),t.updateQueue=null,a=vh(t,i,a,s),ph(e),i=Vs(),e!==null&&!at?(qs(e,t,c),Hn(e,t,c)):(ke&&i&&ws(t),t.flags|=1,dt(e,t,a,c),t.child)}function mg(e,t,a,i,s){if(Ya(t),t.stateNode===null){var c=Nl,m=a.contextType;typeof m=="object"&&m!==null&&(c=ft(m)),c=new a(i,c),t.memoizedState=c.state!==null&&c.state!==void 0?c.state:null,c.updater=lc,t.stateNode=c,c._reactInternals=t,c=t.stateNode,c.props=i,c.state=t.memoizedState,c.refs={},Rs(t),m=a.contextType,c.context=typeof m=="object"&&m!==null?ft(m):Nl,c.state=t.memoizedState,m=a.getDerivedStateFromProps,typeof m=="function"&&(ac(t,a,m,i),c.state=t.memoizedState),typeof a.getDerivedStateFromProps=="function"||typeof c.getSnapshotBeforeUpdate=="function"||typeof c.UNSAFE_componentWillMount!="function"&&typeof c.componentWillMount!="function"||(m=c.state,typeof c.componentWillMount=="function"&&c.componentWillMount(),typeof c.UNSAFE_componentWillMount=="function"&&c.UNSAFE_componentWillMount(),m!==c.state&&lc.enqueueReplaceState(c,c.state,null),Bi(t,i,c,s),Hi(),c.state=t.memoizedState),typeof c.componentDidMount=="function"&&(t.flags|=4194308),i=!0}else if(e===null){c=t.stateNode;var S=t.memoizedProps,O=Za(a,S);c.props=O;var W=c.context,le=a.contextType;m=Nl,typeof le=="object"&&le!==null&&(m=ft(le));var ce=a.getDerivedStateFromProps;le=typeof ce=="function"||typeof c.getSnapshotBeforeUpdate=="function",S=t.pendingProps!==S,le||typeof c.UNSAFE_componentWillReceiveProps!="function"&&typeof c.componentWillReceiveProps!="function"||(S||W!==m)&&ng(t,c,i,m),ia=!1;var F=t.memoizedState;c.state=F,Bi(t,i,c,s),Hi(),W=t.memoizedState,S||F!==W||ia?(typeof ce=="function"&&(ac(t,a,ce,i),W=t.memoizedState),(O=ia||tg(t,a,O,i,F,W,m))?(le||typeof c.UNSAFE_componentWillMount!="function"&&typeof c.componentWillMount!="function"||(typeof c.componentWillMount=="function"&&c.componentWillMount(),typeof c.UNSAFE_componentWillMount=="function"&&c.UNSAFE_componentWillMount()),typeof c.componentDidMount=="function"&&(t.flags|=4194308)):(typeof c.componentDidMount=="function"&&(t.flags|=4194308),t.memoizedProps=i,t.memoizedState=W),c.props=i,c.state=W,c.context=m,i=O):(typeof c.componentDidMount=="function"&&(t.flags|=4194308),i=!1)}else{c=t.stateNode,js(e,t),m=t.memoizedProps,le=Za(a,m),c.props=le,ce=t.pendingProps,F=c.context,W=a.contextType,O=Nl,typeof W=="object"&&W!==null&&(O=ft(W)),S=a.getDerivedStateFromProps,(W=typeof S=="function"||typeof c.getSnapshotBeforeUpdate=="function")||typeof c.UNSAFE_componentWillReceiveProps!="function"&&typeof c.componentWillReceiveProps!="function"||(m!==ce||F!==O)&&ng(t,c,i,O),ia=!1,F=t.memoizedState,c.state=F,Bi(t,i,c,s),Hi();var te=t.memoizedState;m!==ce||F!==te||ia||e!==null&&e.dependencies!==null&&ur(e.dependencies)?(typeof S=="function"&&(ac(t,a,S,i),te=t.memoizedState),(le=ia||tg(t,a,le,i,F,te,O)||e!==null&&e.dependencies!==null&&ur(e.dependencies))?(W||typeof c.UNSAFE_componentWillUpdate!="function"&&typeof c.componentWillUpdate!="function"||(typeof c.componentWillUpdate=="function"&&c.componentWillUpdate(i,te,O),typeof c.UNSAFE_componentWillUpdate=="function"&&c.UNSAFE_componentWillUpdate(i,te,O)),typeof c.componentDidUpdate=="function"&&(t.flags|=4),typeof c.getSnapshotBeforeUpdate=="function"&&(t.flags|=1024)):(typeof c.componentDidUpdate!="function"||m===e.memoizedProps&&F===e.memoizedState||(t.flags|=4),typeof c.getSnapshotBeforeUpdate!="function"||m===e.memoizedProps&&F===e.memoizedState||(t.flags|=1024),t.memoizedProps=i,t.memoizedState=te),c.props=i,c.state=te,c.context=O,i=le):(typeof c.componentDidUpdate!="function"||m===e.memoizedProps&&F===e.memoizedState||(t.flags|=4),typeof c.getSnapshotBeforeUpdate!="function"||m===e.memoizedProps&&F===e.memoizedState||(t.flags|=1024),i=!1)}return c=i,Ar(e,t),i=(t.flags&128)!==0,c||i?(c=t.stateNode,a=i&&typeof a.getDerivedStateFromError!="function"?null:c.render(),t.flags|=1,e!==null&&i?(t.child=Qa(t,e.child,null,s),t.child=Qa(t,null,a,s)):dt(e,t,a,s),t.memoizedState=c.state,e=t.child):e=Hn(e,t,s),e}function pg(e,t,a,i){return Ua(),t.flags|=256,dt(e,t,a,i),t.child}var uc={dehydrated:null,treeContext:null,retryLane:0,hydrationErrors:null};function sc(e){return{baseLanes:e,cachePool:oh()}}function cc(e,t,a){return e=e!==null?e.childLanes&~a:0,t&&(e|=Ut),e}function vg(e,t,a){var i=t.pendingProps,s=!1,c=(t.flags&128)!==0,m;if((m=c)||(m=e!==null&&e.memoizedState===null?!1:(Fe.current&2)!==0),m&&(s=!0,t.flags&=-129),m=(t.flags&32)!==0,t.flags&=-33,e===null){if(ke){if(s?ua(t):sa(),(e=qe)?(e=T0(e,It),e=e!==null&&e.data!=="&"?e:null,e!==null&&(t.memoizedState={dehydrated:e,treeContext:ta!==null?{id:yn,overflow:mn}:null,retryLane:536870912,hydrationErrors:null},a=Wd(e),a.return=t,t.child=a,ct=t,qe=null)):e=null,e===null)throw aa(t);return $c(e)?t.lanes=32:t.lanes=536870912,null}var S=i.children;return i=i.fallback,s?(sa(),s=t.mode,S=Cr({mode:"hidden",children:S},s),i=La(i,s,a,null),S.return=t,i.return=t,S.sibling=i,t.child=S,i=t.child,i.memoizedState=sc(a),i.childLanes=cc(e,m,a),t.memoizedState=uc,Vi(null,i)):(ua(t),fc(t,S))}var O=e.memoizedState;if(O!==null&&(S=O.dehydrated,S!==null)){if(c)t.flags&256?(ua(t),t.flags&=-257,t=dc(e,t,a)):t.memoizedState!==null?(sa(),t.child=e.child,t.flags|=128,t=null):(sa(),S=i.fallback,s=t.mode,i=Cr({mode:"visible",children:i.children},s),S=La(S,s,a,null),S.flags|=2,i.return=t,S.return=t,i.sibling=S,t.child=i,Qa(t,e.child,null,a),i=t.child,i.memoizedState=sc(a),i.childLanes=cc(e,m,a),t.memoizedState=uc,t=Vi(null,i));else if(ua(t),$c(S)){if(m=S.nextSibling&&S.nextSibling.dataset,m)var W=m.dgst;m=W,i=Error(r(419)),i.stack="",i.digest=m,zi({value:i,source:null,stack:null}),t=dc(e,t,a)}else if(at||Ml(e,t,a,!1),m=(a&e.childLanes)!==0,at||m){if(m=Ve,m!==null&&(i=Uo(m,a),i!==0&&i!==O.retryLane))throw O.retryLane=i,Ba(e,i),zt(m,e,i),oc;Qc(S)||Br(),t=dc(e,t,a)}else Qc(S)?(t.flags|=192,t.child=e.child,t=null):(e=O.treeContext,qe=Ft(S.nextSibling),ct=t,ke=!0,na=null,It=!1,e!==null&&eh(t,e),t=fc(t,i.children),t.flags|=4096);return t}return s?(sa(),S=i.fallback,s=t.mode,O=e.child,W=O.sibling,i=zn(O,{mode:"hidden",children:i.children}),i.subtreeFlags=O.subtreeFlags&65011712,W!==null?S=zn(W,S):(S=La(S,s,a,null),S.flags|=2),S.return=t,i.return=t,i.sibling=S,t.child=i,Vi(null,i),i=t.child,S=e.child.memoizedState,S===null?S=sc(a):(s=S.cachePool,s!==null?(O=tt._currentValue,s=s.parent!==O?{parent:O,pool:O}:s):s=oh(),S={baseLanes:S.baseLanes|a,cachePool:s}),i.memoizedState=S,i.childLanes=cc(e,m,a),t.memoizedState=uc,Vi(e.child,i)):(ua(t),a=e.child,e=a.sibling,a=zn(a,{mode:"visible",children:i.children}),a.return=t,a.sibling=null,e!==null&&(m=t.deletions,m===null?(t.deletions=[e],t.flags|=16):m.push(e)),t.child=a,t.memoizedState=null,a)}function fc(e,t){return t=Cr({mode:"visible",children:t},e.mode),t.return=e,e.child=t}function Cr(e,t){return e=Ot(22,e,null,t),e.lanes=0,e}function dc(e,t,a){return Qa(t,e.child,null,a),e=fc(t,t.pendingProps.children),e.flags|=2,t.memoizedState=null,e}function bg(e,t,a){e.lanes|=t;var i=e.alternate;i!==null&&(i.lanes|=t),As(e.return,t,a)}function hc(e,t,a,i,s,c){var m=e.memoizedState;m===null?e.memoizedState={isBackwards:t,rendering:null,renderingStartTime:0,last:i,tail:a,tailMode:s,treeForkCount:c}:(m.isBackwards=t,m.rendering=null,m.renderingStartTime=0,m.last=i,m.tail=a,m.tailMode=s,m.treeForkCount=c)}function xg(e,t,a){var i=t.pendingProps,s=i.revealOrder,c=i.tail;i=i.children;var m=Fe.current,S=(m&2)!==0;if(S?(m=m&1|2,t.flags|=128):m&=1,ee(Fe,m),dt(e,t,i,a),i=ke?Mi:0,!S&&e!==null&&(e.flags&128)!==0)e:for(e=t.child;e!==null;){if(e.tag===13)e.memoizedState!==null&&bg(e,a,t);else if(e.tag===19)bg(e,a,t);else if(e.child!==null){e.child.return=e,e=e.child;continue}if(e===t)break e;for(;e.sibling===null;){if(e.return===null||e.return===t)break e;e=e.return}e.sibling.return=e.return,e=e.sibling}switch(s){case"forwards":for(a=t.child,s=null;a!==null;)e=a.alternate,e!==null&&mr(e)===null&&(s=a),a=a.sibling;a=s,a===null?(s=t.child,t.child=null):(s=a.sibling,a.sibling=null),hc(t,!1,s,a,c,i);break;case"backwards":case"unstable_legacy-backwards":for(a=null,s=t.child,t.child=null;s!==null;){if(e=s.alternate,e!==null&&mr(e)===null){t.child=s;break}e=s.sibling,s.sibling=a,a=s,s=e}hc(t,!0,a,null,c,i);break;case"together":hc(t,!1,null,null,void 0,i);break;default:t.memoizedState=null}return t.child}function Hn(e,t,a){if(e!==null&&(t.dependencies=e.dependencies),da|=t.lanes,(a&t.childLanes)===0)if(e!==null){if(Ml(e,t,a,!1),(a&t.childLanes)===0)return null}else return null;if(e!==null&&t.child!==e.child)throw Error(r(153));if(t.child!==null){for(e=t.child,a=zn(e,e.pendingProps),t.child=a,a.return=t;e.sibling!==null;)e=e.sibling,a=a.sibling=zn(e,e.pendingProps),a.return=t;a.sibling=null}return t.child}function gc(e,t){return(e.lanes&t)!==0?!0:(e=e.dependencies,!!(e!==null&&ur(e)))}function Eb(e,t,a){switch(t.tag){case 3:P(t,t.stateNode.containerInfo),la(t,tt,e.memoizedState.cache),Ua();break;case 27:case 5:fe(t);break;case 4:P(t,t.stateNode.containerInfo);break;case 10:la(t,t.type,t.memoizedProps.value);break;case 31:if(t.memoizedState!==null)return t.flags|=128,Us(t),null;break;case 13:var i=t.memoizedState;if(i!==null)return i.dehydrated!==null?(ua(t),t.flags|=128,null):(a&t.child.childLanes)!==0?vg(e,t,a):(ua(t),e=Hn(e,t,a),e!==null?e.sibling:null);ua(t);break;case 19:var s=(e.flags&128)!==0;if(i=(a&t.childLanes)!==0,i||(Ml(e,t,a,!1),i=(a&t.childLanes)!==0),s){if(i)return xg(e,t,a);t.flags|=128}if(s=t.memoizedState,s!==null&&(s.rendering=null,s.tail=null,s.lastEffect=null),ee(Fe,Fe.current),i)break;return null;case 22:return t.lanes=0,dg(e,t,a,t.pendingProps);case 24:la(t,tt,e.memoizedState.cache)}return Hn(e,t,a)}function _g(e,t,a){if(e!==null)if(e.memoizedProps!==t.pendingProps)at=!0;else{if(!gc(e,a)&&(t.flags&128)===0)return at=!1,Eb(e,t,a);at=(e.flags&131072)!==0}else at=!1,ke&&(t.flags&1048576)!==0&&Pd(t,Mi,t.index);switch(t.lanes=0,t.tag){case 16:e:{var i=t.pendingProps;if(e=qa(t.elementType),t.type=e,typeof e=="function")bs(e)?(i=Za(e,i),t.tag=1,t=mg(null,t,e,i,a)):(t.tag=0,t=rc(null,t,e,i,a));else{if(e!=null){var s=e.$$typeof;if(s===z){t.tag=11,t=sg(null,t,e,i,a);break e}else if(s===L){t.tag=14,t=cg(null,t,e,i,a);break e}}throw t=D(e)||e,Error(r(306,t,""))}}return t;case 0:return rc(e,t,t.type,t.pendingProps,a);case 1:return i=t.type,s=Za(i,t.pendingProps),mg(e,t,i,s,a);case 3:e:{if(P(t,t.stateNode.containerInfo),e===null)throw Error(r(387));i=t.pendingProps;var c=t.memoizedState;s=c.element,js(e,t),Bi(t,i,null,a);var m=t.memoizedState;if(i=m.cache,la(t,tt,i),i!==c.cache&&Cs(t,[tt],a,!0),Hi(),i=m.element,c.isDehydrated)if(c={element:i,isDehydrated:!1,cache:m.cache},t.updateQueue.baseState=c,t.memoizedState=c,t.flags&256){t=pg(e,t,i,a);break e}else if(i!==s){s=Zt(Error(r(424)),t),zi(s),t=pg(e,t,i,a);break e}else{switch(e=t.stateNode.containerInfo,e.nodeType){case 9:e=e.body;break;default:e=e.nodeName==="HTML"?e.ownerDocument.body:e}for(qe=Ft(e.firstChild),ct=t,ke=!0,na=null,It=!0,a=dh(t,null,i,a),t.child=a;a;)a.flags=a.flags&-3|4096,a=a.sibling}else{if(Ua(),i===s){t=Hn(e,t,a);break e}dt(e,t,i,a)}t=t.child}return t;case 26:return Ar(e,t),e===null?(a=k0(t.type,null,t.pendingProps,null))?t.memoizedState=a:ke||(a=t.type,e=t.pendingProps,i=Xr(se.current).createElement(a),i[ot]=t,i[gt]=e,ht(i,a,e),et(i),t.stateNode=i):t.memoizedState=k0(t.type,e.memoizedProps,t.pendingProps,e.memoizedState),null;case 27:return fe(t),e===null&&ke&&(i=t.stateNode=M0(t.type,t.pendingProps,se.current),ct=t,It=!0,s=qe,pa(t.type)?(Zc=s,qe=Ft(i.firstChild)):qe=s),dt(e,t,t.pendingProps.children,a),Ar(e,t),e===null&&(t.flags|=4194304),t.child;case 5:return e===null&&ke&&((s=i=qe)&&(i=ex(i,t.type,t.pendingProps,It),i!==null?(t.stateNode=i,ct=t,qe=Ft(i.firstChild),It=!1,s=!0):s=!1),s||aa(t)),fe(t),s=t.type,c=t.pendingProps,m=e!==null?e.memoizedProps:null,i=c.children,Vc(s,c)?i=null:m!==null&&Vc(s,m)&&(t.flags|=32),t.memoizedState!==null&&(s=Ys(e,t,yb,null,null,a),ao._currentValue=s),Ar(e,t),dt(e,t,i,a),t.child;case 6:return e===null&&ke&&((e=a=qe)&&(a=tx(a,t.pendingProps,It),a!==null?(t.stateNode=a,ct=t,qe=null,e=!0):e=!1),e||aa(t)),null;case 13:return vg(e,t,a);case 4:return P(t,t.stateNode.containerInfo),i=t.pendingProps,e===null?t.child=Qa(t,null,i,a):dt(e,t,i,a),t.child;case 11:return sg(e,t,t.type,t.pendingProps,a);case 7:return dt(e,t,t.pendingProps,a),t.child;case 8:return dt(e,t,t.pendingProps.children,a),t.child;case 12:return dt(e,t,t.pendingProps.children,a),t.child;case 10:return i=t.pendingProps,la(t,t.type,i.value),dt(e,t,i.children,a),t.child;case 9:return s=t.type._context,i=t.pendingProps.children,Ya(t),s=ft(s),i=i(s),t.flags|=1,dt(e,t,i,a),t.child;case 14:return cg(e,t,t.type,t.pendingProps,a);case 15:return fg(e,t,t.type,t.pendingProps,a);case 19:return xg(e,t,a);case 31:return Sb(e,t,a);case 22:return dg(e,t,a,t.pendingProps);case 24:return Ya(t),i=ft(tt),e===null?(s=Ds(),s===null&&(s=Ve,c=Ms(),s.pooledCache=c,c.refCount++,c!==null&&(s.pooledCacheLanes|=a),s=c),t.memoizedState={parent:i,cache:s},Rs(t),la(t,tt,s)):((e.lanes&a)!==0&&(js(e,t),Bi(t,null,null,a),Hi()),s=e.memoizedState,c=t.memoizedState,s.parent!==i?(s={parent:i,cache:i},t.memoizedState=s,t.lanes===0&&(t.memoizedState=t.updateQueue.baseState=s),la(t,tt,i)):(i=c.cache,la(t,tt,i),i!==s.cache&&Cs(t,[tt],a,!0))),dt(e,t,t.pendingProps.children,a),t.child;case 29:throw t.pendingProps}throw Error(r(156,t.tag))}function Bn(e){e.flags|=4}function yc(e,t,a,i,s){if((t=(e.mode&32)!==0)&&(t=!1),t){if(e.flags|=16777216,(s&335544128)===s)if(e.stateNode.complete)e.flags|=8192;else if(Kg())e.flags|=8192;else throw Xa=dr,ks}else e.flags&=-16777217}function wg(e,t){if(t.type!=="stylesheet"||(t.state.loading&4)!==0)e.flags&=-16777217;else if(e.flags|=16777216,!B0(t))if(Kg())e.flags|=8192;else throw Xa=dr,ks}function Mr(e,t){t!==null&&(e.flags|=4),e.flags&16384&&(t=e.tag!==22?Ho():536870912,e.lanes|=t,Yl|=t)}function qi(e,t){if(!ke)switch(e.tailMode){case"hidden":t=e.tail;for(var a=null;t!==null;)t.alternate!==null&&(a=t),t=t.sibling;a===null?e.tail=null:a.sibling=null;break;case"collapsed":a=e.tail;for(var i=null;a!==null;)a.alternate!==null&&(i=a),a=a.sibling;i===null?t||e.tail===null?e.tail=null:e.tail.sibling=null:i.sibling=null}}function Xe(e){var t=e.alternate!==null&&e.alternate.child===e.child,a=0,i=0;if(t)for(var s=e.child;s!==null;)a|=s.lanes|s.childLanes,i|=s.subtreeFlags&65011712,i|=s.flags&65011712,s.return=e,s=s.sibling;else for(s=e.child;s!==null;)a|=s.lanes|s.childLanes,i|=s.subtreeFlags,i|=s.flags,s.return=e,s=s.sibling;return e.subtreeFlags|=i,e.childLanes=a,t}function Nb(e,t,a){var i=t.pendingProps;switch(Ss(t),t.tag){case 16:case 15:case 0:case 11:case 7:case 8:case 12:case 9:case 14:return Xe(t),null;case 1:return Xe(t),null;case 3:return a=t.stateNode,i=null,e!==null&&(i=e.memoizedState.cache),t.memoizedState.cache!==i&&(t.flags|=2048),Rn(tt),Y(),a.pendingContext&&(a.context=a.pendingContext,a.pendingContext=null),(e===null||e.child===null)&&(Cl(t)?Bn(t):e===null||e.memoizedState.isDehydrated&&(t.flags&256)===0||(t.flags|=1024,Ns())),Xe(t),null;case 26:var s=t.type,c=t.memoizedState;return e===null?(Bn(t),c!==null?(Xe(t),wg(t,c)):(Xe(t),yc(t,s,null,i,a))):c?c!==e.memoizedState?(Bn(t),Xe(t),wg(t,c)):(Xe(t),t.flags&=-16777217):(e=e.memoizedProps,e!==i&&Bn(t),Xe(t),yc(t,s,e,i,a)),null;case 27:if(he(t),a=se.current,s=t.type,e!==null&&t.stateNode!=null)e.memoizedProps!==i&&Bn(t);else{if(!i){if(t.stateNode===null)throw Error(r(166));return Xe(t),null}e=ae.current,Cl(t)?th(t):(e=M0(s,i,a),t.stateNode=e,Bn(t))}return Xe(t),null;case 5:if(he(t),s=t.type,e!==null&&t.stateNode!=null)e.memoizedProps!==i&&Bn(t);else{if(!i){if(t.stateNode===null)throw Error(r(166));return Xe(t),null}if(c=ae.current,Cl(t))th(t);else{var m=Xr(se.current);switch(c){case 1:c=m.createElementNS("http://www.w3.org/2000/svg",s);break;case 2:c=m.createElementNS("http://www.w3.org/1998/Math/MathML",s);break;default:switch(s){case"svg":c=m.createElementNS("http://www.w3.org/2000/svg",s);break;case"math":c=m.createElementNS("http://www.w3.org/1998/Math/MathML",s);break;case"script":c=m.createElement("div"),c.innerHTML="<script><\/script>",c=c.removeChild(c.firstChild);break;case"select":c=typeof i.is=="string"?m.createElement("select",{is:i.is}):m.createElement("select"),i.multiple?c.multiple=!0:i.size&&(c.size=i.size);break;default:c=typeof i.is=="string"?m.createElement(s,{is:i.is}):m.createElement(s)}}c[ot]=t,c[gt]=i;e:for(m=t.child;m!==null;){if(m.tag===5||m.tag===6)c.appendChild(m.stateNode);else if(m.tag!==4&&m.tag!==27&&m.child!==null){m.child.return=m,m=m.child;continue}if(m===t)break e;for(;m.sibling===null;){if(m.return===null||m.return===t)break e;m=m.return}m.sibling.return=m.return,m=m.sibling}t.stateNode=c;e:switch(ht(c,s,i),s){case"button":case"input":case"select":case"textarea":i=!!i.autoFocus;break e;case"img":i=!0;break e;default:i=!1}i&&Bn(t)}}return Xe(t),yc(t,t.type,e===null?null:e.memoizedProps,t.pendingProps,a),null;case 6:if(e&&t.stateNode!=null)e.memoizedProps!==i&&Bn(t);else{if(typeof i!="string"&&t.stateNode===null)throw Error(r(166));if(e=se.current,Cl(t)){if(e=t.stateNode,a=t.memoizedProps,i=null,s=ct,s!==null)switch(s.tag){case 27:case 5:i=s.memoizedProps}e[ot]=t,e=!!(e.nodeValue===a||i!==null&&i.suppressHydrationWarning===!0||v0(e.nodeValue,a)),e||aa(t,!0)}else e=Xr(e).createTextNode(i),e[ot]=t,t.stateNode=e}return Xe(t),null;case 31:if(a=t.memoizedState,e===null||e.memoizedState!==null){if(i=Cl(t),a!==null){if(e===null){if(!i)throw Error(r(318));if(e=t.memoizedState,e=e!==null?e.dehydrated:null,!e)throw Error(r(557));e[ot]=t}else Ua(),(t.flags&128)===0&&(t.memoizedState=null),t.flags|=4;Xe(t),e=!1}else a=Ns(),e!==null&&e.memoizedState!==null&&(e.memoizedState.hydrationErrors=a),e=!0;if(!e)return t.flags&256?(Bt(t),t):(Bt(t),null);if((t.flags&128)!==0)throw Error(r(558))}return Xe(t),null;case 13:if(i=t.memoizedState,e===null||e.memoizedState!==null&&e.memoizedState.dehydrated!==null){if(s=Cl(t),i!==null&&i.dehydrated!==null){if(e===null){if(!s)throw Error(r(318));if(s=t.memoizedState,s=s!==null?s.dehydrated:null,!s)throw Error(r(317));s[ot]=t}else Ua(),(t.flags&128)===0&&(t.memoizedState=null),t.flags|=4;Xe(t),s=!1}else s=Ns(),e!==null&&e.memoizedState!==null&&(e.memoizedState.hydrationErrors=s),s=!0;if(!s)return t.flags&256?(Bt(t),t):(Bt(t),null)}return Bt(t),(t.flags&128)!==0?(t.lanes=a,t):(a=i!==null,e=e!==null&&e.memoizedState!==null,a&&(i=t.child,s=null,i.alternate!==null&&i.alternate.memoizedState!==null&&i.alternate.memoizedState.cachePool!==null&&(s=i.alternate.memoizedState.cachePool.pool),c=null,i.memoizedState!==null&&i.memoizedState.cachePool!==null&&(c=i.memoizedState.cachePool.pool),c!==s&&(i.flags|=2048)),a!==e&&a&&(t.child.flags|=8192),Mr(t,t.updateQueue),Xe(t),null);case 4:return Y(),e===null&&Bc(t.stateNode.containerInfo),Xe(t),null;case 10:return Rn(t.type),Xe(t),null;case 19:if(R(Fe),i=t.memoizedState,i===null)return Xe(t),null;if(s=(t.flags&128)!==0,c=i.rendering,c===null)if(s)qi(i,!1);else{if(Ie!==0||e!==null&&(e.flags&128)!==0)for(e=t.child;e!==null;){if(c=mr(e),c!==null){for(t.flags|=128,qi(i,!1),e=c.updateQueue,t.updateQueue=e,Mr(t,e),t.subtreeFlags=0,e=a,a=t.child;a!==null;)Id(a,e),a=a.sibling;return ee(Fe,Fe.current&1|2),ke&&Dn(t,i.treeForkCount),t.child}e=e.sibling}i.tail!==null&&We()>jr&&(t.flags|=128,s=!0,qi(i,!1),t.lanes=4194304)}else{if(!s)if(e=mr(c),e!==null){if(t.flags|=128,s=!0,e=e.updateQueue,t.updateQueue=e,Mr(t,e),qi(i,!0),i.tail===null&&i.tailMode==="hidden"&&!c.alternate&&!ke)return Xe(t),null}else 2*We()-i.renderingStartTime>jr&&a!==536870912&&(t.flags|=128,s=!0,qi(i,!1),t.lanes=4194304);i.isBackwards?(c.sibling=t.child,t.child=c):(e=i.last,e!==null?e.sibling=c:t.child=c,i.last=c)}return i.tail!==null?(e=i.tail,i.rendering=e,i.tail=e.sibling,i.renderingStartTime=We(),e.sibling=null,a=Fe.current,ee(Fe,s?a&1|2:a&1),ke&&Dn(t,i.treeForkCount),e):(Xe(t),null);case 22:case 23:return Bt(t),Ls(),i=t.memoizedState!==null,e!==null?e.memoizedState!==null!==i&&(t.flags|=8192):i&&(t.flags|=8192),i?(a&536870912)!==0&&(t.flags&128)===0&&(Xe(t),t.subtreeFlags&6&&(t.flags|=8192)):Xe(t),a=t.updateQueue,a!==null&&Mr(t,a.retryQueue),a=null,e!==null&&e.memoizedState!==null&&e.memoizedState.cachePool!==null&&(a=e.memoizedState.cachePool.pool),i=null,t.memoizedState!==null&&t.memoizedState.cachePool!==null&&(i=t.memoizedState.cachePool.pool),i!==a&&(t.flags|=2048),e!==null&&R(Va),null;case 24:return a=null,e!==null&&(a=e.memoizedState.cache),t.memoizedState.cache!==a&&(t.flags|=2048),Rn(tt),Xe(t),null;case 25:return null;case 30:return null}throw Error(r(156,t.tag))}function Tb(e,t){switch(Ss(t),t.tag){case 1:return e=t.flags,e&65536?(t.flags=e&-65537|128,t):null;case 3:return Rn(tt),Y(),e=t.flags,(e&65536)!==0&&(e&128)===0?(t.flags=e&-65537|128,t):null;case 26:case 27:case 5:return he(t),null;case 31:if(t.memoizedState!==null){if(Bt(t),t.alternate===null)throw Error(r(340));Ua()}return e=t.flags,e&65536?(t.flags=e&-65537|128,t):null;case 13:if(Bt(t),e=t.memoizedState,e!==null&&e.dehydrated!==null){if(t.alternate===null)throw Error(r(340));Ua()}return e=t.flags,e&65536?(t.flags=e&-65537|128,t):null;case 19:return R(Fe),null;case 4:return Y(),null;case 10:return Rn(t.type),null;case 22:case 23:return Bt(t),Ls(),e!==null&&R(Va),e=t.flags,e&65536?(t.flags=e&-65537|128,t):null;case 24:return Rn(tt),null;case 25:return null;default:return null}}function Sg(e,t){switch(Ss(t),t.tag){case 3:Rn(tt),Y();break;case 26:case 27:case 5:he(t);break;case 4:Y();break;case 31:t.memoizedState!==null&&Bt(t);break;case 13:Bt(t);break;case 19:R(Fe);break;case 10:Rn(t.type);break;case 22:case 23:Bt(t),Ls(),e!==null&&R(Va);break;case 24:Rn(tt)}}function Xi(e,t){try{var a=t.updateQueue,i=a!==null?a.lastEffect:null;if(i!==null){var s=i.next;a=s;do{if((a.tag&e)===e){i=void 0;var c=a.create,m=a.inst;i=c(),m.destroy=i}a=a.next}while(a!==s)}}catch(S){Le(t,t.return,S)}}function ca(e,t,a){try{var i=t.updateQueue,s=i!==null?i.lastEffect:null;if(s!==null){var c=s.next;i=c;do{if((i.tag&e)===e){var m=i.inst,S=m.destroy;if(S!==void 0){m.destroy=void 0,s=t;var O=a,W=S;try{W()}catch(le){Le(s,O,le)}}}i=i.next}while(i!==c)}}catch(le){Le(t,t.return,le)}}function Eg(e){var t=e.updateQueue;if(t!==null){var a=e.stateNode;try{gh(t,a)}catch(i){Le(e,e.return,i)}}}function Ng(e,t,a){a.props=Za(e.type,e.memoizedProps),a.state=e.memoizedState;try{a.componentWillUnmount()}catch(i){Le(e,t,i)}}function Qi(e,t){try{var a=e.ref;if(a!==null){switch(e.tag){case 26:case 27:case 5:var i=e.stateNode;break;case 30:i=e.stateNode;break;default:i=e.stateNode}typeof a=="function"?e.refCleanup=a(i):a.current=i}}catch(s){Le(e,t,s)}}function pn(e,t){var a=e.ref,i=e.refCleanup;if(a!==null)if(typeof i=="function")try{i()}catch(s){Le(e,t,s)}finally{e.refCleanup=null,e=e.alternate,e!=null&&(e.refCleanup=null)}else if(typeof a=="function")try{a(null)}catch(s){Le(e,t,s)}else a.current=null}function Tg(e){var t=e.type,a=e.memoizedProps,i=e.stateNode;try{e:switch(t){case"button":case"input":case"select":case"textarea":a.autoFocus&&i.focus();break e;case"img":a.src?i.src=a.src:a.srcSet&&(i.srcset=a.srcSet)}}catch(s){Le(e,e.return,s)}}function mc(e,t,a){try{var i=e.stateNode;Kb(i,e.type,a,t),i[gt]=t}catch(s){Le(e,e.return,s)}}function Ag(e){return e.tag===5||e.tag===3||e.tag===26||e.tag===27&&pa(e.type)||e.tag===4}function pc(e){e:for(;;){for(;e.sibling===null;){if(e.return===null||Ag(e.return))return null;e=e.return}for(e.sibling.return=e.return,e=e.sibling;e.tag!==5&&e.tag!==6&&e.tag!==18;){if(e.tag===27&&pa(e.type)||e.flags&2||e.child===null||e.tag===4)continue e;e.child.return=e,e=e.child}if(!(e.flags&2))return e.stateNode}}function vc(e,t,a){var i=e.tag;if(i===5||i===6)e=e.stateNode,t?(a.nodeType===9?a.body:a.nodeName==="HTML"?a.ownerDocument.body:a).insertBefore(e,t):(t=a.nodeType===9?a.body:a.nodeName==="HTML"?a.ownerDocument.body:a,t.appendChild(e),a=a._reactRootContainer,a!=null||t.onclick!==null||(t.onclick=Cn));else if(i!==4&&(i===27&&pa(e.type)&&(a=e.stateNode,t=null),e=e.child,e!==null))for(vc(e,t,a),e=e.sibling;e!==null;)vc(e,t,a),e=e.sibling}function zr(e,t,a){var i=e.tag;if(i===5||i===6)e=e.stateNode,t?a.insertBefore(e,t):a.appendChild(e);else if(i!==4&&(i===27&&pa(e.type)&&(a=e.stateNode),e=e.child,e!==null))for(zr(e,t,a),e=e.sibling;e!==null;)zr(e,t,a),e=e.sibling}function Cg(e){var t=e.stateNode,a=e.memoizedProps;try{for(var i=e.type,s=t.attributes;s.length;)t.removeAttributeNode(s[0]);ht(t,i,a),t[ot]=e,t[gt]=a}catch(c){Le(e,e.return,c)}}var Ln=!1,lt=!1,bc=!1,Mg=typeof WeakSet=="function"?WeakSet:Set,st=null;function Ab(e,t){if(e=e.containerInfo,Gc=Wr,e=Yd(e),ds(e)){if("selectionStart"in e)var a={start:e.selectionStart,end:e.selectionEnd};else e:{a=(a=e.ownerDocument)&&a.defaultView||window;var i=a.getSelection&&a.getSelection();if(i&&i.rangeCount!==0){a=i.anchorNode;var s=i.anchorOffset,c=i.focusNode;i=i.focusOffset;try{a.nodeType,c.nodeType}catch{a=null;break e}var m=0,S=-1,O=-1,W=0,le=0,ce=e,F=null;t:for(;;){for(var te;ce!==a||s!==0&&ce.nodeType!==3||(S=m+s),ce!==c||i!==0&&ce.nodeType!==3||(O=m+i),ce.nodeType===3&&(m+=ce.nodeValue.length),(te=ce.firstChild)!==null;)F=ce,ce=te;for(;;){if(ce===e)break t;if(F===a&&++W===s&&(S=m),F===c&&++le===i&&(O=m),(te=ce.nextSibling)!==null)break;ce=F,F=ce.parentNode}ce=te}a=S===-1||O===-1?null:{start:S,end:O}}else a=null}a=a||{start:0,end:0}}else a=null;for(Yc={focusedElem:e,selectionRange:a},Wr=!1,st=t;st!==null;)if(t=st,e=t.child,(t.subtreeFlags&1028)!==0&&e!==null)e.return=t,st=e;else for(;st!==null;){switch(t=st,c=t.alternate,e=t.flags,t.tag){case 0:if((e&4)!==0&&(e=t.updateQueue,e=e!==null?e.events:null,e!==null))for(a=0;a<e.length;a++)s=e[a],s.ref.impl=s.nextImpl;break;case 11:case 15:break;case 1:if((e&1024)!==0&&c!==null){e=void 0,a=t,s=c.memoizedProps,c=c.memoizedState,i=a.stateNode;try{var ye=Za(a.type,s);e=i.getSnapshotBeforeUpdate(ye,c),i.__reactInternalSnapshotBeforeUpdate=e}catch(xe){Le(a,a.return,xe)}}break;case 3:if((e&1024)!==0){if(e=t.stateNode.containerInfo,a=e.nodeType,a===9)Xc(e);else if(a===1)switch(e.nodeName){case"HEAD":case"HTML":case"BODY":Xc(e);break;default:e.textContent=""}}break;case 5:case 26:case 27:case 6:case 4:case 17:break;default:if((e&1024)!==0)throw Error(r(163))}if(e=t.sibling,e!==null){e.return=t.return,st=e;break}st=t.return}}function zg(e,t,a){var i=a.flags;switch(a.tag){case 0:case 11:case 15:Gn(e,a),i&4&&Xi(5,a);break;case 1:if(Gn(e,a),i&4)if(e=a.stateNode,t===null)try{e.componentDidMount()}catch(m){Le(a,a.return,m)}else{var s=Za(a.type,t.memoizedProps);t=t.memoizedState;try{e.componentDidUpdate(s,t,e.__reactInternalSnapshotBeforeUpdate)}catch(m){Le(a,a.return,m)}}i&64&&Eg(a),i&512&&Qi(a,a.return);break;case 3:if(Gn(e,a),i&64&&(e=a.updateQueue,e!==null)){if(t=null,a.child!==null)switch(a.child.tag){case 27:case 5:t=a.child.stateNode;break;case 1:t=a.child.stateNode}try{gh(e,t)}catch(m){Le(a,a.return,m)}}break;case 27:t===null&&i&4&&Cg(a);case 26:case 5:Gn(e,a),t===null&&i&4&&Tg(a),i&512&&Qi(a,a.return);break;case 12:Gn(e,a);break;case 31:Gn(e,a),i&4&&Rg(e,a);break;case 13:Gn(e,a),i&4&&jg(e,a),i&64&&(e=a.memoizedState,e!==null&&(e=e.dehydrated,e!==null&&(a=Hb.bind(null,a),nx(e,a))));break;case 22:if(i=a.memoizedState!==null||Ln,!i){t=t!==null&&t.memoizedState!==null||lt,s=Ln;var c=lt;Ln=i,(lt=t)&&!c?Yn(e,a,(a.subtreeFlags&8772)!==0):Gn(e,a),Ln=s,lt=c}break;case 30:break;default:Gn(e,a)}}function Dg(e){var t=e.alternate;t!==null&&(e.alternate=null,Dg(t)),e.child=null,e.deletions=null,e.sibling=null,e.tag===5&&(t=e.stateNode,t!==null&&gi(t)),e.stateNode=null,e.return=null,e.dependencies=null,e.memoizedProps=null,e.memoizedState=null,e.pendingProps=null,e.stateNode=null,e.updateQueue=null}var Ze=null,Tt=!1;function Un(e,t,a){for(a=a.child;a!==null;)kg(e,t,a),a=a.sibling}function kg(e,t,a){if(pt&&typeof pt.onCommitFiberUnmount=="function")try{pt.onCommitFiberUnmount(Ma,a)}catch{}switch(a.tag){case 26:lt||pn(a,t),Un(e,t,a),a.memoizedState?a.memoizedState.count--:a.stateNode&&(a=a.stateNode,a.parentNode.removeChild(a));break;case 27:lt||pn(a,t);var i=Ze,s=Tt;pa(a.type)&&(Ze=a.stateNode,Tt=!1),Un(e,t,a),eo(a.stateNode),Ze=i,Tt=s;break;case 5:lt||pn(a,t);case 6:if(i=Ze,s=Tt,Ze=null,Un(e,t,a),Ze=i,Tt=s,Ze!==null)if(Tt)try{(Ze.nodeType===9?Ze.body:Ze.nodeName==="HTML"?Ze.ownerDocument.body:Ze).removeChild(a.stateNode)}catch(c){Le(a,t,c)}else try{Ze.removeChild(a.stateNode)}catch(c){Le(a,t,c)}break;case 18:Ze!==null&&(Tt?(e=Ze,E0(e.nodeType===9?e.body:e.nodeName==="HTML"?e.ownerDocument.body:e,a.stateNode),Jl(e)):E0(Ze,a.stateNode));break;case 4:i=Ze,s=Tt,Ze=a.stateNode.containerInfo,Tt=!0,Un(e,t,a),Ze=i,Tt=s;break;case 0:case 11:case 14:case 15:ca(2,a,t),lt||ca(4,a,t),Un(e,t,a);break;case 1:lt||(pn(a,t),i=a.stateNode,typeof i.componentWillUnmount=="function"&&Ng(a,t,i)),Un(e,t,a);break;case 21:Un(e,t,a);break;case 22:lt=(i=lt)||a.memoizedState!==null,Un(e,t,a),lt=i;break;default:Un(e,t,a)}}function Rg(e,t){if(t.memoizedState===null&&(e=t.alternate,e!==null&&(e=e.memoizedState,e!==null))){e=e.dehydrated;try{Jl(e)}catch(a){Le(t,t.return,a)}}}function jg(e,t){if(t.memoizedState===null&&(e=t.alternate,e!==null&&(e=e.memoizedState,e!==null&&(e=e.dehydrated,e!==null))))try{Jl(e)}catch(a){Le(t,t.return,a)}}function Cb(e){switch(e.tag){case 31:case 13:case 19:var t=e.stateNode;return t===null&&(t=e.stateNode=new Mg),t;case 22:return e=e.stateNode,t=e._retryCache,t===null&&(t=e._retryCache=new Mg),t;default:throw Error(r(435,e.tag))}}function Dr(e,t){var a=Cb(e);t.forEach(function(i){if(!a.has(i)){a.add(i);var s=Bb.bind(null,e,i);i.then(s,s)}})}function At(e,t){var a=t.deletions;if(a!==null)for(var i=0;i<a.length;i++){var s=a[i],c=e,m=t,S=m;e:for(;S!==null;){switch(S.tag){case 27:if(pa(S.type)){Ze=S.stateNode,Tt=!1;break e}break;case 5:Ze=S.stateNode,Tt=!1;break e;case 3:case 4:Ze=S.stateNode.containerInfo,Tt=!0;break e}S=S.return}if(Ze===null)throw Error(r(160));kg(c,m,s),Ze=null,Tt=!1,c=s.alternate,c!==null&&(c.return=null),s.return=null}if(t.subtreeFlags&13886)for(t=t.child;t!==null;)Og(t,e),t=t.sibling}var an=null;function Og(e,t){var a=e.alternate,i=e.flags;switch(e.tag){case 0:case 11:case 14:case 15:At(t,e),Ct(e),i&4&&(ca(3,e,e.return),Xi(3,e),ca(5,e,e.return));break;case 1:At(t,e),Ct(e),i&512&&(lt||a===null||pn(a,a.return)),i&64&&Ln&&(e=e.updateQueue,e!==null&&(i=e.callbacks,i!==null&&(a=e.shared.hiddenCallbacks,e.shared.hiddenCallbacks=a===null?i:a.concat(i))));break;case 26:var s=an;if(At(t,e),Ct(e),i&512&&(lt||a===null||pn(a,a.return)),i&4){var c=a!==null?a.memoizedState:null;if(i=e.memoizedState,a===null)if(i===null)if(e.stateNode===null){e:{i=e.type,a=e.memoizedProps,s=s.ownerDocument||s;t:switch(i){case"title":c=s.getElementsByTagName("title")[0],(!c||c[ka]||c[ot]||c.namespaceURI==="http://www.w3.org/2000/svg"||c.hasAttribute("itemprop"))&&(c=s.createElement(i),s.head.insertBefore(c,s.querySelector("head > title"))),ht(c,i,a),c[ot]=e,et(c),i=c;break e;case"link":var m=O0("link","href",s).get(i+(a.href||""));if(m){for(var S=0;S<m.length;S++)if(c=m[S],c.getAttribute("href")===(a.href==null||a.href===""?null:a.href)&&c.getAttribute("rel")===(a.rel==null?null:a.rel)&&c.getAttribute("title")===(a.title==null?null:a.title)&&c.getAttribute("crossorigin")===(a.crossOrigin==null?null:a.crossOrigin)){m.splice(S,1);break t}}c=s.createElement(i),ht(c,i,a),s.head.appendChild(c);break;case"meta":if(m=O0("meta","content",s).get(i+(a.content||""))){for(S=0;S<m.length;S++)if(c=m[S],c.getAttribute("content")===(a.content==null?null:""+a.content)&&c.getAttribute("name")===(a.name==null?null:a.name)&&c.getAttribute("property")===(a.property==null?null:a.property)&&c.getAttribute("http-equiv")===(a.httpEquiv==null?null:a.httpEquiv)&&c.getAttribute("charset")===(a.charSet==null?null:a.charSet)){m.splice(S,1);break t}}c=s.createElement(i),ht(c,i,a),s.head.appendChild(c);break;default:throw Error(r(468,i))}c[ot]=e,et(c),i=c}e.stateNode=i}else H0(s,e.type,e.stateNode);else e.stateNode=j0(s,i,e.memoizedProps);else c!==i?(c===null?a.stateNode!==null&&(a=a.stateNode,a.parentNode.removeChild(a)):c.count--,i===null?H0(s,e.type,e.stateNode):j0(s,i,e.memoizedProps)):i===null&&e.stateNode!==null&&mc(e,e.memoizedProps,a.memoizedProps)}break;case 27:At(t,e),Ct(e),i&512&&(lt||a===null||pn(a,a.return)),a!==null&&i&4&&mc(e,e.memoizedProps,a.memoizedProps);break;case 5:if(At(t,e),Ct(e),i&512&&(lt||a===null||pn(a,a.return)),e.flags&32){s=e.stateNode;try{vl(s,"")}catch(ye){Le(e,e.return,ye)}}i&4&&e.stateNode!=null&&(s=e.memoizedProps,mc(e,s,a!==null?a.memoizedProps:s)),i&1024&&(bc=!0);break;case 6:if(At(t,e),Ct(e),i&4){if(e.stateNode===null)throw Error(r(162));i=e.memoizedProps,a=e.stateNode;try{a.nodeValue=i}catch(ye){Le(e,e.return,ye)}}break;case 3:if(Zr=null,s=an,an=Qr(t.containerInfo),At(t,e),an=s,Ct(e),i&4&&a!==null&&a.memoizedState.isDehydrated)try{Jl(t.containerInfo)}catch(ye){Le(e,e.return,ye)}bc&&(bc=!1,Hg(e));break;case 4:i=an,an=Qr(e.stateNode.containerInfo),At(t,e),Ct(e),an=i;break;case 12:At(t,e),Ct(e);break;case 31:At(t,e),Ct(e),i&4&&(i=e.updateQueue,i!==null&&(e.updateQueue=null,Dr(e,i)));break;case 13:At(t,e),Ct(e),e.child.flags&8192&&e.memoizedState!==null!=(a!==null&&a.memoizedState!==null)&&(Rr=We()),i&4&&(i=e.updateQueue,i!==null&&(e.updateQueue=null,Dr(e,i)));break;case 22:s=e.memoizedState!==null;var O=a!==null&&a.memoizedState!==null,W=Ln,le=lt;if(Ln=W||s,lt=le||O,At(t,e),lt=le,Ln=W,Ct(e),i&8192)e:for(t=e.stateNode,t._visibility=s?t._visibility&-2:t._visibility|1,s&&(a===null||O||Ln||lt||Ka(e)),a=null,t=e;;){if(t.tag===5||t.tag===26){if(a===null){O=a=t;try{if(c=O.stateNode,s)m=c.style,typeof m.setProperty=="function"?m.setProperty("display","none","important"):m.display="none";else{S=O.stateNode;var ce=O.memoizedProps.style,F=ce!=null&&ce.hasOwnProperty("display")?ce.display:null;S.style.display=F==null||typeof F=="boolean"?"":(""+F).trim()}}catch(ye){Le(O,O.return,ye)}}}else if(t.tag===6){if(a===null){O=t;try{O.stateNode.nodeValue=s?"":O.memoizedProps}catch(ye){Le(O,O.return,ye)}}}else if(t.tag===18){if(a===null){O=t;try{var te=O.stateNode;s?N0(te,!0):N0(O.stateNode,!1)}catch(ye){Le(O,O.return,ye)}}}else if((t.tag!==22&&t.tag!==23||t.memoizedState===null||t===e)&&t.child!==null){t.child.return=t,t=t.child;continue}if(t===e)break e;for(;t.sibling===null;){if(t.return===null||t.return===e)break e;a===t&&(a=null),t=t.return}a===t&&(a=null),t.sibling.return=t.return,t=t.sibling}i&4&&(i=e.updateQueue,i!==null&&(a=i.retryQueue,a!==null&&(i.retryQueue=null,Dr(e,a))));break;case 19:At(t,e),Ct(e),i&4&&(i=e.updateQueue,i!==null&&(e.updateQueue=null,Dr(e,i)));break;case 30:break;case 21:break;default:At(t,e),Ct(e)}}function Ct(e){var t=e.flags;if(t&2){try{for(var a,i=e.return;i!==null;){if(Ag(i)){a=i;break}i=i.return}if(a==null)throw Error(r(160));switch(a.tag){case 27:var s=a.stateNode,c=pc(e);zr(e,c,s);break;case 5:var m=a.stateNode;a.flags&32&&(vl(m,""),a.flags&=-33);var S=pc(e);zr(e,S,m);break;case 3:case 4:var O=a.stateNode.containerInfo,W=pc(e);vc(e,W,O);break;default:throw Error(r(161))}}catch(le){Le(e,e.return,le)}e.flags&=-3}t&4096&&(e.flags&=-4097)}function Hg(e){if(e.subtreeFlags&1024)for(e=e.child;e!==null;){var t=e;Hg(t),t.tag===5&&t.flags&1024&&t.stateNode.reset(),e=e.sibling}}function Gn(e,t){if(t.subtreeFlags&8772)for(t=t.child;t!==null;)zg(e,t.alternate,t),t=t.sibling}function Ka(e){for(e=e.child;e!==null;){var t=e;switch(t.tag){case 0:case 11:case 14:case 15:ca(4,t,t.return),Ka(t);break;case 1:pn(t,t.return);var a=t.stateNode;typeof a.componentWillUnmount=="function"&&Ng(t,t.return,a),Ka(t);break;case 27:eo(t.stateNode);case 26:case 5:pn(t,t.return),Ka(t);break;case 22:t.memoizedState===null&&Ka(t);break;case 30:Ka(t);break;default:Ka(t)}e=e.sibling}}function Yn(e,t,a){for(a=a&&(t.subtreeFlags&8772)!==0,t=t.child;t!==null;){var i=t.alternate,s=e,c=t,m=c.flags;switch(c.tag){case 0:case 11:case 15:Yn(s,c,a),Xi(4,c);break;case 1:if(Yn(s,c,a),i=c,s=i.stateNode,typeof s.componentDidMount=="function")try{s.componentDidMount()}catch(W){Le(i,i.return,W)}if(i=c,s=i.updateQueue,s!==null){var S=i.stateNode;try{var O=s.shared.hiddenCallbacks;if(O!==null)for(s.shared.hiddenCallbacks=null,s=0;s<O.length;s++)hh(O[s],S)}catch(W){Le(i,i.return,W)}}a&&m&64&&Eg(c),Qi(c,c.return);break;case 27:Cg(c);case 26:case 5:Yn(s,c,a),a&&i===null&&m&4&&Tg(c),Qi(c,c.return);break;case 12:Yn(s,c,a);break;case 31:Yn(s,c,a),a&&m&4&&Rg(s,c);break;case 13:Yn(s,c,a),a&&m&4&&jg(s,c);break;case 22:c.memoizedState===null&&Yn(s,c,a),Qi(c,c.return);break;case 30:break;default:Yn(s,c,a)}t=t.sibling}}function xc(e,t){var a=null;e!==null&&e.memoizedState!==null&&e.memoizedState.cachePool!==null&&(a=e.memoizedState.cachePool.pool),e=null,t.memoizedState!==null&&t.memoizedState.cachePool!==null&&(e=t.memoizedState.cachePool.pool),e!==a&&(e!=null&&e.refCount++,a!=null&&Di(a))}function _c(e,t){e=null,t.alternate!==null&&(e=t.alternate.memoizedState.cache),t=t.memoizedState.cache,t!==e&&(t.refCount++,e!=null&&Di(e))}function ln(e,t,a,i){if(t.subtreeFlags&10256)for(t=t.child;t!==null;)Bg(e,t,a,i),t=t.sibling}function Bg(e,t,a,i){var s=t.flags;switch(t.tag){case 0:case 11:case 15:ln(e,t,a,i),s&2048&&Xi(9,t);break;case 1:ln(e,t,a,i);break;case 3:ln(e,t,a,i),s&2048&&(e=null,t.alternate!==null&&(e=t.alternate.memoizedState.cache),t=t.memoizedState.cache,t!==e&&(t.refCount++,e!=null&&Di(e)));break;case 12:if(s&2048){ln(e,t,a,i),e=t.stateNode;try{var c=t.memoizedProps,m=c.id,S=c.onPostCommit;typeof S=="function"&&S(m,t.alternate===null?"mount":"update",e.passiveEffectDuration,-0)}catch(O){Le(t,t.return,O)}}else ln(e,t,a,i);break;case 31:ln(e,t,a,i);break;case 13:ln(e,t,a,i);break;case 23:break;case 22:c=t.stateNode,m=t.alternate,t.memoizedState!==null?c._visibility&2?ln(e,t,a,i):$i(e,t):c._visibility&2?ln(e,t,a,i):(c._visibility|=2,Ll(e,t,a,i,(t.subtreeFlags&10256)!==0||!1)),s&2048&&xc(m,t);break;case 24:ln(e,t,a,i),s&2048&&_c(t.alternate,t);break;default:ln(e,t,a,i)}}function Ll(e,t,a,i,s){for(s=s&&((t.subtreeFlags&10256)!==0||!1),t=t.child;t!==null;){var c=e,m=t,S=a,O=i,W=m.flags;switch(m.tag){case 0:case 11:case 15:Ll(c,m,S,O,s),Xi(8,m);break;case 23:break;case 22:var le=m.stateNode;m.memoizedState!==null?le._visibility&2?Ll(c,m,S,O,s):$i(c,m):(le._visibility|=2,Ll(c,m,S,O,s)),s&&W&2048&&xc(m.alternate,m);break;case 24:Ll(c,m,S,O,s),s&&W&2048&&_c(m.alternate,m);break;default:Ll(c,m,S,O,s)}t=t.sibling}}function $i(e,t){if(t.subtreeFlags&10256)for(t=t.child;t!==null;){var a=e,i=t,s=i.flags;switch(i.tag){case 22:$i(a,i),s&2048&&xc(i.alternate,i);break;case 24:$i(a,i),s&2048&&_c(i.alternate,i);break;default:$i(a,i)}t=t.sibling}}var Zi=8192;function Ul(e,t,a){if(e.subtreeFlags&Zi)for(e=e.child;e!==null;)Lg(e,t,a),e=e.sibling}function Lg(e,t,a){switch(e.tag){case 26:Ul(e,t,a),e.flags&Zi&&e.memoizedState!==null&&gx(a,an,e.memoizedState,e.memoizedProps);break;case 5:Ul(e,t,a);break;case 3:case 4:var i=an;an=Qr(e.stateNode.containerInfo),Ul(e,t,a),an=i;break;case 22:e.memoizedState===null&&(i=e.alternate,i!==null&&i.memoizedState!==null?(i=Zi,Zi=16777216,Ul(e,t,a),Zi=i):Ul(e,t,a));break;default:Ul(e,t,a)}}function Ug(e){var t=e.alternate;if(t!==null&&(e=t.child,e!==null)){t.child=null;do t=e.sibling,e.sibling=null,e=t;while(e!==null)}}function Ki(e){var t=e.deletions;if((e.flags&16)!==0){if(t!==null)for(var a=0;a<t.length;a++){var i=t[a];st=i,Yg(i,e)}Ug(e)}if(e.subtreeFlags&10256)for(e=e.child;e!==null;)Gg(e),e=e.sibling}function Gg(e){switch(e.tag){case 0:case 11:case 15:Ki(e),e.flags&2048&&ca(9,e,e.return);break;case 3:Ki(e);break;case 12:Ki(e);break;case 22:var t=e.stateNode;e.memoizedState!==null&&t._visibility&2&&(e.return===null||e.return.tag!==13)?(t._visibility&=-3,kr(e)):Ki(e);break;default:Ki(e)}}function kr(e){var t=e.deletions;if((e.flags&16)!==0){if(t!==null)for(var a=0;a<t.length;a++){var i=t[a];st=i,Yg(i,e)}Ug(e)}for(e=e.child;e!==null;){switch(t=e,t.tag){case 0:case 11:case 15:ca(8,t,t.return),kr(t);break;case 22:a=t.stateNode,a._visibility&2&&(a._visibility&=-3,kr(t));break;default:kr(t)}e=e.sibling}}function Yg(e,t){for(;st!==null;){var a=st;switch(a.tag){case 0:case 11:case 15:ca(8,a,t);break;case 23:case 22:if(a.memoizedState!==null&&a.memoizedState.cachePool!==null){var i=a.memoizedState.cachePool.pool;i!=null&&i.refCount++}break;case 24:Di(a.memoizedState.cache)}if(i=a.child,i!==null)i.return=a,st=i;else e:for(a=e;st!==null;){i=st;var s=i.sibling,c=i.return;if(Dg(i),i===a){st=null;break e}if(s!==null){s.return=c,st=s;break e}st=c}}}var Mb={getCacheForType:function(e){var t=ft(tt),a=t.data.get(e);return a===void 0&&(a=e(),t.data.set(e,a)),a},cacheSignal:function(){return ft(tt).controller.signal}},zb=typeof WeakMap=="function"?WeakMap:Map,He=0,Ve=null,Te=null,Me=0,Be=0,Lt=null,fa=!1,Gl=!1,wc=!1,Vn=0,Ie=0,da=0,Ja=0,Sc=0,Ut=0,Yl=0,Ji=null,Mt=null,Ec=!1,Rr=0,Vg=0,jr=1/0,Or=null,ha=null,rt=0,ga=null,Vl=null,qn=0,Nc=0,Tc=null,qg=null,Ii=0,Ac=null;function Gt(){return(He&2)!==0&&Me!==0?Me&-Me:A.T!==null?Rc():Go()}function Xg(){if(Ut===0)if((Me&536870912)===0||ke){var e=cl;cl<<=1,(cl&3932160)===0&&(cl=262144),Ut=e}else Ut=536870912;return e=Ht.current,e!==null&&(e.flags|=32),Ut}function zt(e,t,a){(e===Ve&&(Be===2||Be===9)||e.cancelPendingCommit!==null)&&(ql(e,0),ya(e,Me,Ut,!1)),Da(e,a),((He&2)===0||e!==Ve)&&(e===Ve&&((He&2)===0&&(Ja|=a),Ie===4&&ya(e,Me,Ut,!1)),vn(e))}function Qg(e,t,a){if((He&6)!==0)throw Error(r(327));var i=!a&&(t&127)===0&&(t&e.expiredLanes)===0||za(e,t),s=i?Rb(e,t):Mc(e,t,!0),c=i;do{if(s===0){Gl&&!i&&ya(e,t,0,!1);break}else{if(a=e.current.alternate,c&&!Db(a)){s=Mc(e,t,!1),c=!1;continue}if(s===2){if(c=t,e.errorRecoveryDisabledLanes&c)var m=0;else m=e.pendingLanes&-536870913,m=m!==0?m:m&536870912?536870912:0;if(m!==0){t=m;e:{var S=e;s=Ji;var O=S.current.memoizedState.isDehydrated;if(O&&(ql(S,m).flags|=256),m=Mc(S,m,!1),m!==2){if(wc&&!O){S.errorRecoveryDisabledLanes|=c,Ja|=c,s=4;break e}c=Mt,Mt=s,c!==null&&(Mt===null?Mt=c:Mt.push.apply(Mt,c))}s=m}if(c=!1,s!==2)continue}}if(s===1){ql(e,0),ya(e,t,0,!0);break}e:{switch(i=e,c=s,c){case 0:case 1:throw Error(r(345));case 4:if((t&4194048)!==t)break;case 6:ya(i,t,Ut,!fa);break e;case 2:Mt=null;break;case 3:case 5:break;default:throw Error(r(329))}if((t&62914560)===t&&(s=Rr+300-We(),10<s)){if(ya(i,t,Ut,!fa),dl(i,0,!0)!==0)break e;qn=t,i.timeoutHandle=w0($g.bind(null,i,a,Mt,Or,Ec,t,Ut,Ja,Yl,fa,c,"Throttled",-0,0),s);break e}$g(i,a,Mt,Or,Ec,t,Ut,Ja,Yl,fa,c,null,-0,0)}}break}while(!0);vn(e)}function $g(e,t,a,i,s,c,m,S,O,W,le,ce,F,te){if(e.timeoutHandle=-1,ce=t.subtreeFlags,ce&8192||(ce&16785408)===16785408){ce={stylesheets:null,count:0,imgCount:0,imgBytes:0,suspenseyImages:[],waitingForImages:!0,waitingForViewTransition:!1,unsuspend:Cn},Lg(t,c,ce);var ye=(c&62914560)===c?Rr-We():(c&4194048)===c?Vg-We():0;if(ye=yx(ce,ye),ye!==null){qn=c,e.cancelPendingCommit=ye(e0.bind(null,e,t,c,a,i,s,m,S,O,le,ce,null,F,te)),ya(e,c,m,!W);return}}e0(e,t,c,a,i,s,m,S,O)}function Db(e){for(var t=e;;){var a=t.tag;if((a===0||a===11||a===15)&&t.flags&16384&&(a=t.updateQueue,a!==null&&(a=a.stores,a!==null)))for(var i=0;i<a.length;i++){var s=a[i],c=s.getSnapshot;s=s.value;try{if(!jt(c(),s))return!1}catch{return!1}}if(a=t.child,t.subtreeFlags&16384&&a!==null)a.return=t,t=a;else{if(t===e)break;for(;t.sibling===null;){if(t.return===null||t.return===e)return!0;t=t.return}t.sibling.return=t.return,t=t.sibling}}return!0}function ya(e,t,a,i){t&=~Sc,t&=~Ja,e.suspendedLanes|=t,e.pingedLanes&=~t,i&&(e.warmLanes|=t),i=e.expirationTimes;for(var s=t;0<s;){var c=31-vt(s),m=1<<c;i[c]=-1,s&=~m}a!==0&&Bo(e,a,t)}function Hr(){return(He&6)===0?(Wi(0),!1):!0}function Cc(){if(Te!==null){if(Be===0)var e=Te.return;else e=Te,kn=Ga=null,Xs(e),Rl=null,Ri=0,e=Te;for(;e!==null;)Sg(e.alternate,e),e=e.return;Te=null}}function ql(e,t){var a=e.timeoutHandle;a!==-1&&(e.timeoutHandle=-1,Wb(a)),a=e.cancelPendingCommit,a!==null&&(e.cancelPendingCommit=null,a()),qn=0,Cc(),Ve=e,Te=a=zn(e.current,null),Me=t,Be=0,Lt=null,fa=!1,Gl=za(e,t),wc=!1,Yl=Ut=Sc=Ja=da=Ie=0,Mt=Ji=null,Ec=!1,(t&8)!==0&&(t|=t&32);var i=e.entangledLanes;if(i!==0)for(e=e.entanglements,i&=t;0<i;){var s=31-vt(i),c=1<<s;t|=e[s],i&=~c}return Vn=t,ar(),a}function Zg(e,t){Se=null,A.H=Yi,t===kl||t===fr?(t=sh(),Be=3):t===ks?(t=sh(),Be=4):Be=t===oc?8:t!==null&&typeof t=="object"&&typeof t.then=="function"?6:1,Lt=t,Te===null&&(Ie=1,Nr(e,Zt(t,e.current)))}function Kg(){var e=Ht.current;return e===null?!0:(Me&4194048)===Me?Wt===null:(Me&62914560)===Me||(Me&536870912)!==0?e===Wt:!1}function Jg(){var e=A.H;return A.H=Yi,e===null?Yi:e}function Ig(){var e=A.A;return A.A=Mb,e}function Br(){Ie=4,fa||(Me&4194048)!==Me&&Ht.current!==null||(Gl=!0),(da&134217727)===0&&(Ja&134217727)===0||Ve===null||ya(Ve,Me,Ut,!1)}function Mc(e,t,a){var i=He;He|=2;var s=Jg(),c=Ig();(Ve!==e||Me!==t)&&(Or=null,ql(e,t)),t=!1;var m=Ie;e:do try{if(Be!==0&&Te!==null){var S=Te,O=Lt;switch(Be){case 8:Cc(),m=6;break e;case 3:case 2:case 9:case 6:Ht.current===null&&(t=!0);var W=Be;if(Be=0,Lt=null,Xl(e,S,O,W),a&&Gl){m=0;break e}break;default:W=Be,Be=0,Lt=null,Xl(e,S,O,W)}}kb(),m=Ie;break}catch(le){Zg(e,le)}while(!0);return t&&e.shellSuspendCounter++,kn=Ga=null,He=i,A.H=s,A.A=c,Te===null&&(Ve=null,Me=0,ar()),m}function kb(){for(;Te!==null;)Wg(Te)}function Rb(e,t){var a=He;He|=2;var i=Jg(),s=Ig();Ve!==e||Me!==t?(Or=null,jr=We()+500,ql(e,t)):Gl=za(e,t);e:do try{if(Be!==0&&Te!==null){t=Te;var c=Lt;t:switch(Be){case 1:Be=0,Lt=null,Xl(e,t,c,1);break;case 2:case 9:if(rh(c)){Be=0,Lt=null,Fg(t);break}t=function(){Be!==2&&Be!==9||Ve!==e||(Be=7),vn(e)},c.then(t,t);break e;case 3:Be=7;break e;case 4:Be=5;break e;case 7:rh(c)?(Be=0,Lt=null,Fg(t)):(Be=0,Lt=null,Xl(e,t,c,7));break;case 5:var m=null;switch(Te.tag){case 26:m=Te.memoizedState;case 5:case 27:var S=Te;if(m?B0(m):S.stateNode.complete){Be=0,Lt=null;var O=S.sibling;if(O!==null)Te=O;else{var W=S.return;W!==null?(Te=W,Lr(W)):Te=null}break t}}Be=0,Lt=null,Xl(e,t,c,5);break;case 6:Be=0,Lt=null,Xl(e,t,c,6);break;case 8:Cc(),Ie=6;break e;default:throw Error(r(462))}}jb();break}catch(le){Zg(e,le)}while(!0);return kn=Ga=null,A.H=i,A.A=s,He=a,Te!==null?0:(Ve=null,Me=0,ar(),Ie)}function jb(){for(;Te!==null&&!Ca();)Wg(Te)}function Wg(e){var t=_g(e.alternate,e,Vn);e.memoizedProps=e.pendingProps,t===null?Lr(e):Te=t}function Fg(e){var t=e,a=t.alternate;switch(t.tag){case 15:case 0:t=yg(a,t,t.pendingProps,t.type,void 0,Me);break;case 11:t=yg(a,t,t.pendingProps,t.type.render,t.ref,Me);break;case 5:Xs(t);default:Sg(a,t),t=Te=Id(t,Vn),t=_g(a,t,Vn)}e.memoizedProps=e.pendingProps,t===null?Lr(e):Te=t}function Xl(e,t,a,i){kn=Ga=null,Xs(t),Rl=null,Ri=0;var s=t.return;try{if(wb(e,s,t,a,Me)){Ie=1,Nr(e,Zt(a,e.current)),Te=null;return}}catch(c){if(s!==null)throw Te=s,c;Ie=1,Nr(e,Zt(a,e.current)),Te=null;return}t.flags&32768?(ke||i===1?e=!0:Gl||(Me&536870912)!==0?e=!1:(fa=e=!0,(i===2||i===9||i===3||i===6)&&(i=Ht.current,i!==null&&i.tag===13&&(i.flags|=16384))),Pg(t,e)):Lr(t)}function Lr(e){var t=e;do{if((t.flags&32768)!==0){Pg(t,fa);return}e=t.return;var a=Nb(t.alternate,t,Vn);if(a!==null){Te=a;return}if(t=t.sibling,t!==null){Te=t;return}Te=t=e}while(t!==null);Ie===0&&(Ie=5)}function Pg(e,t){do{var a=Tb(e.alternate,e);if(a!==null){a.flags&=32767,Te=a;return}if(a=e.return,a!==null&&(a.flags|=32768,a.subtreeFlags=0,a.deletions=null),!t&&(e=e.sibling,e!==null)){Te=e;return}Te=e=a}while(e!==null);Ie=6,Te=null}function e0(e,t,a,i,s,c,m,S,O){e.cancelPendingCommit=null;do Ur();while(rt!==0);if((He&6)!==0)throw Error(r(327));if(t!==null){if(t===e.current)throw Error(r(177));if(c=t.lanes|t.childLanes,c|=ps,Ku(e,a,c,m,S,O),e===Ve&&(Te=Ve=null,Me=0),Vl=t,ga=e,qn=a,Nc=c,Tc=s,qg=i,(t.subtreeFlags&10256)!==0||(t.flags&10256)!==0?(e.callbackNode=null,e.callbackPriority=0,Lb(Qt,function(){return i0(),null})):(e.callbackNode=null,e.callbackPriority=0),i=(t.flags&13878)!==0,(t.subtreeFlags&13878)!==0||i){i=A.T,A.T=null,s=j.p,j.p=2,m=He,He|=4;try{Ab(e,t,a)}finally{He=m,j.p=s,A.T=i}}rt=1,t0(),n0(),a0()}}function t0(){if(rt===1){rt=0;var e=ga,t=Vl,a=(t.flags&13878)!==0;if((t.subtreeFlags&13878)!==0||a){a=A.T,A.T=null;var i=j.p;j.p=2;var s=He;He|=4;try{Og(t,e);var c=Yc,m=Yd(e.containerInfo),S=c.focusedElem,O=c.selectionRange;if(m!==S&&S&&S.ownerDocument&&Gd(S.ownerDocument.documentElement,S)){if(O!==null&&ds(S)){var W=O.start,le=O.end;if(le===void 0&&(le=W),"selectionStart"in S)S.selectionStart=W,S.selectionEnd=Math.min(le,S.value.length);else{var ce=S.ownerDocument||document,F=ce&&ce.defaultView||window;if(F.getSelection){var te=F.getSelection(),ye=S.textContent.length,xe=Math.min(O.start,ye),Ye=O.end===void 0?xe:Math.min(O.end,ye);!te.extend&&xe>Ye&&(m=Ye,Ye=xe,xe=m);var X=Ud(S,xe),U=Ud(S,Ye);if(X&&U&&(te.rangeCount!==1||te.anchorNode!==X.node||te.anchorOffset!==X.offset||te.focusNode!==U.node||te.focusOffset!==U.offset)){var J=ce.createRange();J.setStart(X.node,X.offset),te.removeAllRanges(),xe>Ye?(te.addRange(J),te.extend(U.node,U.offset)):(J.setEnd(U.node,U.offset),te.addRange(J))}}}}for(ce=[],te=S;te=te.parentNode;)te.nodeType===1&&ce.push({element:te,left:te.scrollLeft,top:te.scrollTop});for(typeof S.focus=="function"&&S.focus(),S=0;S<ce.length;S++){var re=ce[S];re.element.scrollLeft=re.left,re.element.scrollTop=re.top}}Wr=!!Gc,Yc=Gc=null}finally{He=s,j.p=i,A.T=a}}e.current=t,rt=2}}function n0(){if(rt===2){rt=0;var e=ga,t=Vl,a=(t.flags&8772)!==0;if((t.subtreeFlags&8772)!==0||a){a=A.T,A.T=null;var i=j.p;j.p=2;var s=He;He|=4;try{zg(e,t.alternate,t)}finally{He=s,j.p=i,A.T=a}}rt=3}}function a0(){if(rt===4||rt===3){rt=0,En();var e=ga,t=Vl,a=qn,i=qg;(t.subtreeFlags&10256)!==0||(t.flags&10256)!==0?rt=5:(rt=0,Vl=ga=null,l0(e,e.pendingLanes));var s=e.pendingLanes;if(s===0&&(ha=null),hi(a),t=t.stateNode,pt&&typeof pt.onCommitFiberRoot=="function")try{pt.onCommitFiberRoot(Ma,t,void 0,(t.current.flags&128)===128)}catch{}if(i!==null){t=A.T,s=j.p,j.p=2,A.T=null;try{for(var c=e.onRecoverableError,m=0;m<i.length;m++){var S=i[m];c(S.value,{componentStack:S.stack})}}finally{A.T=t,j.p=s}}(qn&3)!==0&&Ur(),vn(e),s=e.pendingLanes,(a&261930)!==0&&(s&42)!==0?e===Ac?Ii++:(Ii=0,Ac=e):Ii=0,Wi(0)}}function l0(e,t){(e.pooledCacheLanes&=t)===0&&(t=e.pooledCache,t!=null&&(e.pooledCache=null,Di(t)))}function Ur(){return t0(),n0(),a0(),i0()}function i0(){if(rt!==5)return!1;var e=ga,t=Nc;Nc=0;var a=hi(qn),i=A.T,s=j.p;try{j.p=32>a?32:a,A.T=null,a=Tc,Tc=null;var c=ga,m=qn;if(rt=0,Vl=ga=null,qn=0,(He&6)!==0)throw Error(r(331));var S=He;if(He|=4,Gg(c.current),Bg(c,c.current,m,a),He=S,Wi(0,!1),pt&&typeof pt.onPostCommitFiberRoot=="function")try{pt.onPostCommitFiberRoot(Ma,c)}catch{}return!0}finally{j.p=s,A.T=i,l0(e,t)}}function o0(e,t,a){t=Zt(a,t),t=ic(e.stateNode,t,2),e=ra(e,t,2),e!==null&&(Da(e,2),vn(e))}function Le(e,t,a){if(e.tag===3)o0(e,e,a);else for(;t!==null;){if(t.tag===3){o0(t,e,a);break}else if(t.tag===1){var i=t.stateNode;if(typeof t.type.getDerivedStateFromError=="function"||typeof i.componentDidCatch=="function"&&(ha===null||!ha.has(i))){e=Zt(a,e),a=rg(2),i=ra(t,a,2),i!==null&&(ug(a,i,t,e),Da(i,2),vn(i));break}}t=t.return}}function zc(e,t,a){var i=e.pingCache;if(i===null){i=e.pingCache=new zb;var s=new Set;i.set(t,s)}else s=i.get(t),s===void 0&&(s=new Set,i.set(t,s));s.has(a)||(wc=!0,s.add(a),e=Ob.bind(null,e,t,a),t.then(e,e))}function Ob(e,t,a){var i=e.pingCache;i!==null&&i.delete(t),e.pingedLanes|=e.suspendedLanes&a,e.warmLanes&=~a,Ve===e&&(Me&a)===a&&(Ie===4||Ie===3&&(Me&62914560)===Me&&300>We()-Rr?(He&2)===0&&ql(e,0):Sc|=a,Yl===Me&&(Yl=0)),vn(e)}function r0(e,t){t===0&&(t=Ho()),e=Ba(e,t),e!==null&&(Da(e,t),vn(e))}function Hb(e){var t=e.memoizedState,a=0;t!==null&&(a=t.retryLane),r0(e,a)}function Bb(e,t){var a=0;switch(e.tag){case 31:case 13:var i=e.stateNode,s=e.memoizedState;s!==null&&(a=s.retryLane);break;case 19:i=e.stateNode;break;case 22:i=e.stateNode._retryCache;break;default:throw Error(r(314))}i!==null&&i.delete(t),r0(e,a)}function Lb(e,t){return wt(e,t)}var Gr=null,Ql=null,Dc=!1,Yr=!1,kc=!1,ma=0;function vn(e){e!==Ql&&e.next===null&&(Ql===null?Gr=Ql=e:Ql=Ql.next=e),Yr=!0,Dc||(Dc=!0,Gb())}function Wi(e,t){if(!kc&&Yr){kc=!0;do for(var a=!1,i=Gr;i!==null;){if(e!==0){var s=i.pendingLanes;if(s===0)var c=0;else{var m=i.suspendedLanes,S=i.pingedLanes;c=(1<<31-vt(42|e)+1)-1,c&=s&~(m&~S),c=c&201326741?c&201326741|1:c?c|2:0}c!==0&&(a=!0,f0(i,c))}else c=Me,c=dl(i,i===Ve?c:0,i.cancelPendingCommit!==null||i.timeoutHandle!==-1),(c&3)===0||za(i,c)||(a=!0,f0(i,c));i=i.next}while(a);kc=!1}}function Ub(){u0()}function u0(){Yr=Dc=!1;var e=0;ma!==0&&Ib()&&(e=ma);for(var t=We(),a=null,i=Gr;i!==null;){var s=i.next,c=s0(i,t);c===0?(i.next=null,a===null?Gr=s:a.next=s,s===null&&(Ql=a)):(a=i,(e!==0||(c&3)!==0)&&(Yr=!0)),i=s}rt!==0&&rt!==5||Wi(e),ma!==0&&(ma=0)}function s0(e,t){for(var a=e.suspendedLanes,i=e.pingedLanes,s=e.expirationTimes,c=e.pendingLanes&-62914561;0<c;){var m=31-vt(c),S=1<<m,O=s[m];O===-1?((S&a)===0||(S&i)!==0)&&(s[m]=Zu(S,t)):O<=t&&(e.expiredLanes|=S),c&=~S}if(t=Ve,a=Me,a=dl(e,e===t?a:0,e.cancelPendingCommit!==null||e.timeoutHandle!==-1),i=e.callbackNode,a===0||e===t&&(Be===2||Be===9)||e.cancelPendingCommit!==null)return i!==null&&i!==null&&kt(i),e.callbackNode=null,e.callbackPriority=0;if((a&3)===0||za(e,a)){if(t=a&-a,t===e.callbackPriority)return t;switch(i!==null&&kt(i),hi(a)){case 2:case 8:a=Xt;break;case 32:a=Qt;break;case 268435456:a=ul;break;default:a=Qt}return i=c0.bind(null,e),a=wt(a,i),e.callbackPriority=t,e.callbackNode=a,t}return i!==null&&i!==null&&kt(i),e.callbackPriority=2,e.callbackNode=null,2}function c0(e,t){if(rt!==0&&rt!==5)return e.callbackNode=null,e.callbackPriority=0,null;var a=e.callbackNode;if(Ur()&&e.callbackNode!==a)return null;var i=Me;return i=dl(e,e===Ve?i:0,e.cancelPendingCommit!==null||e.timeoutHandle!==-1),i===0?null:(Qg(e,i,t),s0(e,We()),e.callbackNode!=null&&e.callbackNode===a?c0.bind(null,e):null)}function f0(e,t){if(Ur())return null;Qg(e,t,!0)}function Gb(){Fb(function(){(He&6)!==0?wt(qt,Ub):u0()})}function Rc(){if(ma===0){var e=zl;e===0&&(e=sl,sl<<=1,(sl&261888)===0&&(sl=256)),ma=e}return ma}function d0(e){return e==null||typeof e=="symbol"||typeof e=="boolean"?null:typeof e=="function"?e:Jo(""+e)}function h0(e,t){var a=t.ownerDocument.createElement("input");return a.name=t.name,a.value=t.value,e.id&&a.setAttribute("form",e.id),t.parentNode.insertBefore(a,t),e=new FormData(e),a.parentNode.removeChild(a),e}function Yb(e,t,a,i,s){if(t==="submit"&&a&&a.stateNode===s){var c=d0((s[gt]||null).action),m=i.submitter;m&&(t=(t=m[gt]||null)?d0(t.formAction):m.getAttribute("formAction"),t!==null&&(c=t,m=null));var S=new Po("action","action",null,i,s);e.push({event:S,listeners:[{instance:null,listener:function(){if(i.defaultPrevented){if(ma!==0){var O=m?h0(s,m):new FormData(s);Ps(a,{pending:!0,data:O,method:s.method,action:c},null,O)}}else typeof c=="function"&&(S.preventDefault(),O=m?h0(s,m):new FormData(s),Ps(a,{pending:!0,data:O,method:s.method,action:c},c,O))},currentTarget:s}]})}}for(var jc=0;jc<ms.length;jc++){var Oc=ms[jc],Vb=Oc.toLowerCase(),qb=Oc[0].toUpperCase()+Oc.slice(1);nn(Vb,"on"+qb)}nn(Xd,"onAnimationEnd"),nn(Qd,"onAnimationIteration"),nn($d,"onAnimationStart"),nn("dblclick","onDoubleClick"),nn("focusin","onFocus"),nn("focusout","onBlur"),nn(ib,"onTransitionRun"),nn(ob,"onTransitionStart"),nn(rb,"onTransitionCancel"),nn(Zd,"onTransitionEnd"),Fn("onMouseEnter",["mouseout","mouseover"]),Fn("onMouseLeave",["mouseout","mouseover"]),Fn("onPointerEnter",["pointerout","pointerover"]),Fn("onPointerLeave",["pointerout","pointerover"]),An("onChange","change click focusin focusout input keydown keyup selectionchange".split(" ")),An("onSelect","focusout contextmenu dragend focusin keydown keyup mousedown mouseup selectionchange".split(" ")),An("onBeforeInput",["compositionend","keypress","textInput","paste"]),An("onCompositionEnd","compositionend focusout keydown keypress keyup mousedown".split(" ")),An("onCompositionStart","compositionstart focusout keydown keypress keyup mousedown".split(" ")),An("onCompositionUpdate","compositionupdate focusout keydown keypress keyup mousedown".split(" "));var Fi="abort canplay canplaythrough durationchange emptied encrypted ended error loadeddata loadedmetadata loadstart pause play playing progress ratechange resize seeked seeking stalled suspend timeupdate volumechange waiting".split(" "),Xb=new Set("beforetoggle cancel close invalid load scroll scrollend toggle".split(" ").concat(Fi));function g0(e,t){t=(t&4)!==0;for(var a=0;a<e.length;a++){var i=e[a],s=i.event;i=i.listeners;e:{var c=void 0;if(t)for(var m=i.length-1;0<=m;m--){var S=i[m],O=S.instance,W=S.currentTarget;if(S=S.listener,O!==c&&s.isPropagationStopped())break e;c=S,s.currentTarget=W;try{c(s)}catch(le){nr(le)}s.currentTarget=null,c=O}else for(m=0;m<i.length;m++){if(S=i[m],O=S.instance,W=S.currentTarget,S=S.listener,O!==c&&s.isPropagationStopped())break e;c=S,s.currentTarget=W;try{c(s)}catch(le){nr(le)}s.currentTarget=null,c=O}}}}function Ae(e,t){var a=t[hl];a===void 0&&(a=t[hl]=new Set);var i=e+"__bubble";a.has(i)||(y0(t,e,2,!1),a.add(i))}function Hc(e,t,a){var i=0;t&&(i|=4),y0(a,e,i,t)}var Vr="_reactListening"+Math.random().toString(36).slice(2);function Bc(e){if(!e[Vr]){e[Vr]=!0,Xo.forEach(function(a){a!=="selectionchange"&&(Xb.has(a)||Hc(a,!1,e),Hc(a,!0,e))});var t=e.nodeType===9?e:e.ownerDocument;t===null||t[Vr]||(t[Vr]=!0,Hc("selectionchange",!1,t))}}function y0(e,t,a,i){switch(X0(t)){case 2:var s=vx;break;case 8:s=bx;break;default:s=Fc}a=s.bind(null,t,a,e),s=void 0,!as||t!=="touchstart"&&t!=="touchmove"&&t!=="wheel"||(s=!0),i?s!==void 0?e.addEventListener(t,a,{capture:!0,passive:s}):e.addEventListener(t,a,!0):s!==void 0?e.addEventListener(t,a,{passive:s}):e.addEventListener(t,a,!1)}function Lc(e,t,a,i,s){var c=i;if((t&1)===0&&(t&2)===0&&i!==null)e:for(;;){if(i===null)return;var m=i.tag;if(m===3||m===4){var S=i.stateNode.containerInfo;if(S===s)break;if(m===4)for(m=i.return;m!==null;){var O=m.tag;if((O===3||O===4)&&m.stateNode.containerInfo===s)return;m=m.return}for(;S!==null;){if(m=Kn(S),m===null)return;if(O=m.tag,O===5||O===6||O===26||O===27){i=c=m;continue e}S=S.parentNode}}i=i.return}xd(function(){var W=c,le=ts(a),ce=[];e:{var F=Kd.get(e);if(F!==void 0){var te=Po,ye=e;switch(e){case"keypress":if(Wo(a)===0)break e;case"keydown":case"keyup":te=Bv;break;case"focusin":ye="focus",te=rs;break;case"focusout":ye="blur",te=rs;break;case"beforeblur":case"afterblur":te=rs;break;case"click":if(a.button===2)break e;case"auxclick":case"dblclick":case"mousedown":case"mousemove":case"mouseup":case"mouseout":case"mouseover":case"contextmenu":te=Sd;break;case"drag":case"dragend":case"dragenter":case"dragexit":case"dragleave":case"dragover":case"dragstart":case"drop":te=Nv;break;case"touchcancel":case"touchend":case"touchmove":case"touchstart":te=Gv;break;case Xd:case Qd:case $d:te=Cv;break;case Zd:te=Vv;break;case"scroll":case"scrollend":te=Sv;break;case"wheel":te=Xv;break;case"copy":case"cut":case"paste":te=zv;break;case"gotpointercapture":case"lostpointercapture":case"pointercancel":case"pointerdown":case"pointermove":case"pointerout":case"pointerover":case"pointerup":te=Nd;break;case"toggle":case"beforetoggle":te=$v}var xe=(t&4)!==0,Ye=!xe&&(e==="scroll"||e==="scrollend"),X=xe?F!==null?F+"Capture":null:F;xe=[];for(var U=W,J;U!==null;){var re=U;if(J=re.stateNode,re=re.tag,re!==5&&re!==26&&re!==27||J===null||X===null||(re=xi(U,X),re!=null&&xe.push(Pi(U,re,J))),Ye)break;U=U.return}0<xe.length&&(F=new te(F,ye,null,a,le),ce.push({event:F,listeners:xe}))}}if((t&7)===0){e:{if(F=e==="mouseover"||e==="pointerover",te=e==="mouseout"||e==="pointerout",F&&a!==es&&(ye=a.relatedTarget||a.fromElement)&&(Kn(ye)||ye[Tn]))break e;if((te||F)&&(F=le.window===le?le:(F=le.ownerDocument)?F.defaultView||F.parentWindow:window,te?(ye=a.relatedTarget||a.toElement,te=W,ye=ye?Kn(ye):null,ye!==null&&(Ye=f(ye),xe=ye.tag,ye!==Ye||xe!==5&&xe!==27&&xe!==6)&&(ye=null)):(te=null,ye=W),te!==ye)){if(xe=Sd,re="onMouseLeave",X="onMouseEnter",U="mouse",(e==="pointerout"||e==="pointerover")&&(xe=Nd,re="onPointerLeave",X="onPointerEnter",U="pointer"),Ye=te==null?F:In(te),J=ye==null?F:In(ye),F=new xe(re,U+"leave",te,a,le),F.target=Ye,F.relatedTarget=J,re=null,Kn(le)===W&&(xe=new xe(X,U+"enter",ye,a,le),xe.target=J,xe.relatedTarget=Ye,re=xe),Ye=re,te&&ye)t:{for(xe=Qb,X=te,U=ye,J=0,re=X;re;re=xe(re))J++;re=0;for(var be=U;be;be=xe(be))re++;for(;0<J-re;)X=xe(X),J--;for(;0<re-J;)U=xe(U),re--;for(;J--;){if(X===U||U!==null&&X===U.alternate){xe=X;break t}X=xe(X),U=xe(U)}xe=null}else xe=null;te!==null&&m0(ce,F,te,xe,!1),ye!==null&&Ye!==null&&m0(ce,Ye,ye,xe,!0)}}e:{if(F=W?In(W):window,te=F.nodeName&&F.nodeName.toLowerCase(),te==="select"||te==="input"&&F.type==="file")var je=Rd;else if(Dd(F))if(jd)je=nb;else{je=eb;var pe=Pv}else te=F.nodeName,!te||te.toLowerCase()!=="input"||F.type!=="checkbox"&&F.type!=="radio"?W&&Pu(W.elementType)&&(je=Rd):je=tb;if(je&&(je=je(e,W))){kd(ce,je,a,le);break e}pe&&pe(e,F,W),e==="focusout"&&W&&F.type==="number"&&W.memoizedProps.value!=null&&vi(F,"number",F.value)}switch(pe=W?In(W):window,e){case"focusin":(Dd(pe)||pe.contentEditable==="true")&&(wl=pe,hs=W,Ci=null);break;case"focusout":Ci=hs=wl=null;break;case"mousedown":gs=!0;break;case"contextmenu":case"mouseup":case"dragend":gs=!1,Vd(ce,a,le);break;case"selectionchange":if(lb)break;case"keydown":case"keyup":Vd(ce,a,le)}var Ee;if(ss)e:{switch(e){case"compositionstart":var ze="onCompositionStart";break e;case"compositionend":ze="onCompositionEnd";break e;case"compositionupdate":ze="onCompositionUpdate";break e}ze=void 0}else _l?Md(e,a)&&(ze="onCompositionEnd"):e==="keydown"&&a.keyCode===229&&(ze="onCompositionStart");ze&&(Td&&a.locale!=="ko"&&(_l||ze!=="onCompositionStart"?ze==="onCompositionEnd"&&_l&&(Ee=_d()):(ea=le,ls="value"in ea?ea.value:ea.textContent,_l=!0)),pe=qr(W,ze),0<pe.length&&(ze=new Ed(ze,e,null,a,le),ce.push({event:ze,listeners:pe}),Ee?ze.data=Ee:(Ee=zd(a),Ee!==null&&(ze.data=Ee)))),(Ee=Kv?Jv(e,a):Iv(e,a))&&(ze=qr(W,"onBeforeInput"),0<ze.length&&(pe=new Ed("onBeforeInput","beforeinput",null,a,le),ce.push({event:pe,listeners:ze}),pe.data=Ee)),Yb(ce,e,W,a,le)}g0(ce,t)})}function Pi(e,t,a){return{instance:e,listener:t,currentTarget:a}}function qr(e,t){for(var a=t+"Capture",i=[];e!==null;){var s=e,c=s.stateNode;if(s=s.tag,s!==5&&s!==26&&s!==27||c===null||(s=xi(e,a),s!=null&&i.unshift(Pi(e,s,c)),s=xi(e,t),s!=null&&i.push(Pi(e,s,c))),e.tag===3)return i;e=e.return}return[]}function Qb(e){if(e===null)return null;do e=e.return;while(e&&e.tag!==5&&e.tag!==27);return e||null}function m0(e,t,a,i,s){for(var c=t._reactName,m=[];a!==null&&a!==i;){var S=a,O=S.alternate,W=S.stateNode;if(S=S.tag,O!==null&&O===i)break;S!==5&&S!==26&&S!==27||W===null||(O=W,s?(W=xi(a,c),W!=null&&m.unshift(Pi(a,W,O))):s||(W=xi(a,c),W!=null&&m.push(Pi(a,W,O)))),a=a.return}m.length!==0&&e.push({event:t,listeners:m})}var $b=/\r\n?/g,Zb=/\u0000|\uFFFD/g;function p0(e){return(typeof e=="string"?e:""+e).replace($b,`
-`).replace(Zb,"")}function v0(e,t){return t=p0(t),p0(e)===t}function Ge(e,t,a,i,s,c){switch(a){case"children":typeof i=="string"?t==="body"||t==="textarea"&&i===""||vl(e,i):(typeof i=="number"||typeof i=="bigint")&&t!=="body"&&vl(e,""+i);break;case"className":yl(e,"class",i);break;case"tabIndex":yl(e,"tabindex",i);break;case"dir":case"role":case"viewBox":case"width":case"height":yl(e,a,i);break;case"style":vd(e,i,c);break;case"data":if(t!=="object"){yl(e,"data",i);break}case"src":case"href":if(i===""&&(t!=="a"||a!=="href")){e.removeAttribute(a);break}if(i==null||typeof i=="function"||typeof i=="symbol"||typeof i=="boolean"){e.removeAttribute(a);break}i=Jo(""+i),e.setAttribute(a,i);break;case"action":case"formAction":if(typeof i=="function"){e.setAttribute(a,"javascript:throw new Error('A React form was unexpectedly submitted. If you called form.submit() manually, consider using form.requestSubmit() instead. If you\\'re trying to use event.stopPropagation() in a submit event handler, consider also calling event.preventDefault().')");break}else typeof c=="function"&&(a==="formAction"?(t!=="input"&&Ge(e,t,"name",s.name,s,null),Ge(e,t,"formEncType",s.formEncType,s,null),Ge(e,t,"formMethod",s.formMethod,s,null),Ge(e,t,"formTarget",s.formTarget,s,null)):(Ge(e,t,"encType",s.encType,s,null),Ge(e,t,"method",s.method,s,null),Ge(e,t,"target",s.target,s,null)));if(i==null||typeof i=="symbol"||typeof i=="boolean"){e.removeAttribute(a);break}i=Jo(""+i),e.setAttribute(a,i);break;case"onClick":i!=null&&(e.onclick=Cn);break;case"onScroll":i!=null&&Ae("scroll",e);break;case"onScrollEnd":i!=null&&Ae("scrollend",e);break;case"dangerouslySetInnerHTML":if(i!=null){if(typeof i!="object"||!("__html"in i))throw Error(r(61));if(a=i.__html,a!=null){if(s.children!=null)throw Error(r(60));e.innerHTML=a}}break;case"multiple":e.multiple=i&&typeof i!="function"&&typeof i!="symbol";break;case"muted":e.muted=i&&typeof i!="function"&&typeof i!="symbol";break;case"suppressContentEditableWarning":case"suppressHydrationWarning":case"defaultValue":case"defaultChecked":case"innerHTML":case"ref":break;case"autoFocus":break;case"xlinkHref":if(i==null||typeof i=="function"||typeof i=="boolean"||typeof i=="symbol"){e.removeAttribute("xlink:href");break}a=Jo(""+i),e.setAttributeNS("http://www.w3.org/1999/xlink","xlink:href",a);break;case"contentEditable":case"spellCheck":case"draggable":case"value":case"autoReverse":case"externalResourcesRequired":case"focusable":case"preserveAlpha":i!=null&&typeof i!="function"&&typeof i!="symbol"?e.setAttribute(a,""+i):e.removeAttribute(a);break;case"inert":case"allowFullScreen":case"async":case"autoPlay":case"controls":case"default":case"defer":case"disabled":case"disablePictureInPicture":case"disableRemotePlayback":case"formNoValidate":case"hidden":case"loop":case"noModule":case"noValidate":case"open":case"playsInline":case"readOnly":case"required":case"reversed":case"scoped":case"seamless":case"itemScope":i&&typeof i!="function"&&typeof i!="symbol"?e.setAttribute(a,""):e.removeAttribute(a);break;case"capture":case"download":i===!0?e.setAttribute(a,""):i!==!1&&i!=null&&typeof i!="function"&&typeof i!="symbol"?e.setAttribute(a,i):e.removeAttribute(a);break;case"cols":case"rows":case"size":case"span":i!=null&&typeof i!="function"&&typeof i!="symbol"&&!isNaN(i)&&1<=i?e.setAttribute(a,i):e.removeAttribute(a);break;case"rowSpan":case"start":i==null||typeof i=="function"||typeof i=="symbol"||isNaN(i)?e.removeAttribute(a):e.setAttribute(a,i);break;case"popover":Ae("beforetoggle",e),Ae("toggle",e),gl(e,"popover",i);break;case"xlinkActuate":tn(e,"http://www.w3.org/1999/xlink","xlink:actuate",i);break;case"xlinkArcrole":tn(e,"http://www.w3.org/1999/xlink","xlink:arcrole",i);break;case"xlinkRole":tn(e,"http://www.w3.org/1999/xlink","xlink:role",i);break;case"xlinkShow":tn(e,"http://www.w3.org/1999/xlink","xlink:show",i);break;case"xlinkTitle":tn(e,"http://www.w3.org/1999/xlink","xlink:title",i);break;case"xlinkType":tn(e,"http://www.w3.org/1999/xlink","xlink:type",i);break;case"xmlBase":tn(e,"http://www.w3.org/XML/1998/namespace","xml:base",i);break;case"xmlLang":tn(e,"http://www.w3.org/XML/1998/namespace","xml:lang",i);break;case"xmlSpace":tn(e,"http://www.w3.org/XML/1998/namespace","xml:space",i);break;case"is":gl(e,"is",i);break;case"innerText":case"textContent":break;default:(!(2<a.length)||a[0]!=="o"&&a[0]!=="O"||a[1]!=="n"&&a[1]!=="N")&&(a=_v.get(a)||a,gl(e,a,i))}}function Uc(e,t,a,i,s,c){switch(a){case"style":vd(e,i,c);break;case"dangerouslySetInnerHTML":if(i!=null){if(typeof i!="object"||!("__html"in i))throw Error(r(61));if(a=i.__html,a!=null){if(s.children!=null)throw Error(r(60));e.innerHTML=a}}break;case"children":typeof i=="string"?vl(e,i):(typeof i=="number"||typeof i=="bigint")&&vl(e,""+i);break;case"onScroll":i!=null&&Ae("scroll",e);break;case"onScrollEnd":i!=null&&Ae("scrollend",e);break;case"onClick":i!=null&&(e.onclick=Cn);break;case"suppressContentEditableWarning":case"suppressHydrationWarning":case"innerHTML":case"ref":break;case"innerText":case"textContent":break;default:if(!Qo.hasOwnProperty(a))e:{if(a[0]==="o"&&a[1]==="n"&&(s=a.endsWith("Capture"),t=a.slice(2,s?a.length-7:void 0),c=e[gt]||null,c=c!=null?c[a]:null,typeof c=="function"&&e.removeEventListener(t,c,s),typeof i=="function")){typeof c!="function"&&c!==null&&(a in e?e[a]=null:e.hasAttribute(a)&&e.removeAttribute(a)),e.addEventListener(t,i,s);break e}a in e?e[a]=i:i===!0?e.setAttribute(a,""):gl(e,a,i)}}}function ht(e,t,a){switch(t){case"div":case"span":case"svg":case"path":case"a":case"g":case"p":case"li":break;case"img":Ae("error",e),Ae("load",e);var i=!1,s=!1,c;for(c in a)if(a.hasOwnProperty(c)){var m=a[c];if(m!=null)switch(c){case"src":i=!0;break;case"srcSet":s=!0;break;case"children":case"dangerouslySetInnerHTML":throw Error(r(137,t));default:Ge(e,t,c,m,a,null)}}s&&Ge(e,t,"srcSet",a.srcSet,a,null),i&&Ge(e,t,"src",a.src,a,null);return;case"input":Ae("invalid",e);var S=c=m=s=null,O=null,W=null;for(i in a)if(a.hasOwnProperty(i)){var le=a[i];if(le!=null)switch(i){case"name":s=le;break;case"type":m=le;break;case"checked":O=le;break;case"defaultChecked":W=le;break;case"value":c=le;break;case"defaultValue":S=le;break;case"children":case"dangerouslySetInnerHTML":if(le!=null)throw Error(r(137,t));break;default:Ge(e,t,i,le,a,null)}}pl(e,c,S,O,W,m,s,!1);return;case"select":Ae("invalid",e),i=m=c=null;for(s in a)if(a.hasOwnProperty(s)&&(S=a[s],S!=null))switch(s){case"value":c=S;break;case"defaultValue":m=S;break;case"multiple":i=S;default:Ge(e,t,s,S,a,null)}t=c,a=m,e.multiple=!!i,t!=null?Pn(e,!!i,t,!1):a!=null&&Pn(e,!!i,a,!0);return;case"textarea":Ae("invalid",e),c=s=i=null;for(m in a)if(a.hasOwnProperty(m)&&(S=a[m],S!=null))switch(m){case"value":i=S;break;case"defaultValue":s=S;break;case"children":c=S;break;case"dangerouslySetInnerHTML":if(S!=null)throw Error(r(91));break;default:Ge(e,t,m,S,a,null)}md(e,i,s,c);return;case"option":for(O in a)if(a.hasOwnProperty(O)&&(i=a[O],i!=null))switch(O){case"selected":e.selected=i&&typeof i!="function"&&typeof i!="symbol";break;default:Ge(e,t,O,i,a,null)}return;case"dialog":Ae("beforetoggle",e),Ae("toggle",e),Ae("cancel",e),Ae("close",e);break;case"iframe":case"object":Ae("load",e);break;case"video":case"audio":for(i=0;i<Fi.length;i++)Ae(Fi[i],e);break;case"image":Ae("error",e),Ae("load",e);break;case"details":Ae("toggle",e);break;case"embed":case"source":case"link":Ae("error",e),Ae("load",e);case"area":case"base":case"br":case"col":case"hr":case"keygen":case"meta":case"param":case"track":case"wbr":case"menuitem":for(W in a)if(a.hasOwnProperty(W)&&(i=a[W],i!=null))switch(W){case"children":case"dangerouslySetInnerHTML":throw Error(r(137,t));default:Ge(e,t,W,i,a,null)}return;default:if(Pu(t)){for(le in a)a.hasOwnProperty(le)&&(i=a[le],i!==void 0&&Uc(e,t,le,i,a,void 0));return}}for(S in a)a.hasOwnProperty(S)&&(i=a[S],i!=null&&Ge(e,t,S,i,a,null))}function Kb(e,t,a,i){switch(t){case"div":case"span":case"svg":case"path":case"a":case"g":case"p":case"li":break;case"input":var s=null,c=null,m=null,S=null,O=null,W=null,le=null;for(te in a){var ce=a[te];if(a.hasOwnProperty(te)&&ce!=null)switch(te){case"checked":break;case"value":break;case"defaultValue":O=ce;default:i.hasOwnProperty(te)||Ge(e,t,te,null,i,ce)}}for(var F in i){var te=i[F];if(ce=a[F],i.hasOwnProperty(F)&&(te!=null||ce!=null))switch(F){case"type":c=te;break;case"name":s=te;break;case"checked":W=te;break;case"defaultChecked":le=te;break;case"value":m=te;break;case"defaultValue":S=te;break;case"children":case"dangerouslySetInnerHTML":if(te!=null)throw Error(r(137,t));break;default:te!==ce&&Ge(e,t,F,te,i,ce)}}pi(e,m,S,O,W,le,c,s);return;case"select":te=m=S=F=null;for(c in a)if(O=a[c],a.hasOwnProperty(c)&&O!=null)switch(c){case"value":break;case"multiple":te=O;default:i.hasOwnProperty(c)||Ge(e,t,c,null,i,O)}for(s in i)if(c=i[s],O=a[s],i.hasOwnProperty(s)&&(c!=null||O!=null))switch(s){case"value":F=c;break;case"defaultValue":S=c;break;case"multiple":m=c;default:c!==O&&Ge(e,t,s,c,i,O)}t=S,a=m,i=te,F!=null?Pn(e,!!a,F,!1):!!i!=!!a&&(t!=null?Pn(e,!!a,t,!0):Pn(e,!!a,a?[]:"",!1));return;case"textarea":te=F=null;for(S in a)if(s=a[S],a.hasOwnProperty(S)&&s!=null&&!i.hasOwnProperty(S))switch(S){case"value":break;case"children":break;default:Ge(e,t,S,null,i,s)}for(m in i)if(s=i[m],c=a[m],i.hasOwnProperty(m)&&(s!=null||c!=null))switch(m){case"value":F=s;break;case"defaultValue":te=s;break;case"children":break;case"dangerouslySetInnerHTML":if(s!=null)throw Error(r(91));break;default:s!==c&&Ge(e,t,m,s,i,c)}bi(e,F,te);return;case"option":for(var ye in a)if(F=a[ye],a.hasOwnProperty(ye)&&F!=null&&!i.hasOwnProperty(ye))switch(ye){case"selected":e.selected=!1;break;default:Ge(e,t,ye,null,i,F)}for(O in i)if(F=i[O],te=a[O],i.hasOwnProperty(O)&&F!==te&&(F!=null||te!=null))switch(O){case"selected":e.selected=F&&typeof F!="function"&&typeof F!="symbol";break;default:Ge(e,t,O,F,i,te)}return;case"img":case"link":case"area":case"base":case"br":case"col":case"embed":case"hr":case"keygen":case"meta":case"param":case"source":case"track":case"wbr":case"menuitem":for(var xe in a)F=a[xe],a.hasOwnProperty(xe)&&F!=null&&!i.hasOwnProperty(xe)&&Ge(e,t,xe,null,i,F);for(W in i)if(F=i[W],te=a[W],i.hasOwnProperty(W)&&F!==te&&(F!=null||te!=null))switch(W){case"children":case"dangerouslySetInnerHTML":if(F!=null)throw Error(r(137,t));break;default:Ge(e,t,W,F,i,te)}return;default:if(Pu(t)){for(var Ye in a)F=a[Ye],a.hasOwnProperty(Ye)&&F!==void 0&&!i.hasOwnProperty(Ye)&&Uc(e,t,Ye,void 0,i,F);for(le in i)F=i[le],te=a[le],!i.hasOwnProperty(le)||F===te||F===void 0&&te===void 0||Uc(e,t,le,F,i,te);return}}for(var X in a)F=a[X],a.hasOwnProperty(X)&&F!=null&&!i.hasOwnProperty(X)&&Ge(e,t,X,null,i,F);for(ce in i)F=i[ce],te=a[ce],!i.hasOwnProperty(ce)||F===te||F==null&&te==null||Ge(e,t,ce,F,i,te)}function b0(e){switch(e){case"css":case"script":case"font":case"img":case"image":case"input":case"link":return!0;default:return!1}}function Jb(){if(typeof performance.getEntriesByType=="function"){for(var e=0,t=0,a=performance.getEntriesByType("resource"),i=0;i<a.length;i++){var s=a[i],c=s.transferSize,m=s.initiatorType,S=s.duration;if(c&&S&&b0(m)){for(m=0,S=s.responseEnd,i+=1;i<a.length;i++){var O=a[i],W=O.startTime;if(W>S)break;var le=O.transferSize,ce=O.initiatorType;le&&b0(ce)&&(O=O.responseEnd,m+=le*(O<S?1:(S-W)/(O-W)))}if(--i,t+=8*(c+m)/(s.duration/1e3),e++,10<e)break}}if(0<e)return t/e/1e6}return navigator.connection&&(e=navigator.connection.downlink,typeof e=="number")?e:5}var Gc=null,Yc=null;function Xr(e){return e.nodeType===9?e:e.ownerDocument}function x0(e){switch(e){case"http://www.w3.org/2000/svg":return 1;case"http://www.w3.org/1998/Math/MathML":return 2;default:return 0}}function _0(e,t){if(e===0)switch(t){case"svg":return 1;case"math":return 2;default:return 0}return e===1&&t==="foreignObject"?0:e}function Vc(e,t){return e==="textarea"||e==="noscript"||typeof t.children=="string"||typeof t.children=="number"||typeof t.children=="bigint"||typeof t.dangerouslySetInnerHTML=="object"&&t.dangerouslySetInnerHTML!==null&&t.dangerouslySetInnerHTML.__html!=null}var qc=null;function Ib(){var e=window.event;return e&&e.type==="popstate"?e===qc?!1:(qc=e,!0):(qc=null,!1)}var w0=typeof setTimeout=="function"?setTimeout:void 0,Wb=typeof clearTimeout=="function"?clearTimeout:void 0,S0=typeof Promise=="function"?Promise:void 0,Fb=typeof queueMicrotask=="function"?queueMicrotask:typeof S0<"u"?function(e){return S0.resolve(null).then(e).catch(Pb)}:w0;function Pb(e){setTimeout(function(){throw e})}function pa(e){return e==="head"}function E0(e,t){var a=t,i=0;do{var s=a.nextSibling;if(e.removeChild(a),s&&s.nodeType===8)if(a=s.data,a==="/$"||a==="/&"){if(i===0){e.removeChild(s),Jl(t);return}i--}else if(a==="$"||a==="$?"||a==="$~"||a==="$!"||a==="&")i++;else if(a==="html")eo(e.ownerDocument.documentElement);else if(a==="head"){a=e.ownerDocument.head,eo(a);for(var c=a.firstChild;c;){var m=c.nextSibling,S=c.nodeName;c[ka]||S==="SCRIPT"||S==="STYLE"||S==="LINK"&&c.rel.toLowerCase()==="stylesheet"||a.removeChild(c),c=m}}else a==="body"&&eo(e.ownerDocument.body);a=s}while(a);Jl(t)}function N0(e,t){var a=e;e=0;do{var i=a.nextSibling;if(a.nodeType===1?t?(a._stashedDisplay=a.style.display,a.style.display="none"):(a.style.display=a._stashedDisplay||"",a.getAttribute("style")===""&&a.removeAttribute("style")):a.nodeType===3&&(t?(a._stashedText=a.nodeValue,a.nodeValue=""):a.nodeValue=a._stashedText||""),i&&i.nodeType===8)if(a=i.data,a==="/$"){if(e===0)break;e--}else a!=="$"&&a!=="$?"&&a!=="$~"&&a!=="$!"||e++;a=i}while(a)}function Xc(e){var t=e.firstChild;for(t&&t.nodeType===10&&(t=t.nextSibling);t;){var a=t;switch(t=t.nextSibling,a.nodeName){case"HTML":case"HEAD":case"BODY":Xc(a),gi(a);continue;case"SCRIPT":case"STYLE":continue;case"LINK":if(a.rel.toLowerCase()==="stylesheet")continue}e.removeChild(a)}}function ex(e,t,a,i){for(;e.nodeType===1;){var s=a;if(e.nodeName.toLowerCase()!==t.toLowerCase()){if(!i&&(e.nodeName!=="INPUT"||e.type!=="hidden"))break}else if(i){if(!e[ka])switch(t){case"meta":if(!e.hasAttribute("itemprop"))break;return e;case"link":if(c=e.getAttribute("rel"),c==="stylesheet"&&e.hasAttribute("data-precedence"))break;if(c!==s.rel||e.getAttribute("href")!==(s.href==null||s.href===""?null:s.href)||e.getAttribute("crossorigin")!==(s.crossOrigin==null?null:s.crossOrigin)||e.getAttribute("title")!==(s.title==null?null:s.title))break;return e;case"style":if(e.hasAttribute("data-precedence"))break;return e;case"script":if(c=e.getAttribute("src"),(c!==(s.src==null?null:s.src)||e.getAttribute("type")!==(s.type==null?null:s.type)||e.getAttribute("crossorigin")!==(s.crossOrigin==null?null:s.crossOrigin))&&c&&e.hasAttribute("async")&&!e.hasAttribute("itemprop"))break;return e;default:return e}}else if(t==="input"&&e.type==="hidden"){var c=s.name==null?null:""+s.name;if(s.type==="hidden"&&e.getAttribute("name")===c)return e}else return e;if(e=Ft(e.nextSibling),e===null)break}return null}function tx(e,t,a){if(t==="")return null;for(;e.nodeType!==3;)if((e.nodeType!==1||e.nodeName!=="INPUT"||e.type!=="hidden")&&!a||(e=Ft(e.nextSibling),e===null))return null;return e}function T0(e,t){for(;e.nodeType!==8;)if((e.nodeType!==1||e.nodeName!=="INPUT"||e.type!=="hidden")&&!t||(e=Ft(e.nextSibling),e===null))return null;return e}function Qc(e){return e.data==="$?"||e.data==="$~"}function $c(e){return e.data==="$!"||e.data==="$?"&&e.ownerDocument.readyState!=="loading"}function nx(e,t){var a=e.ownerDocument;if(e.data==="$~")e._reactRetry=t;else if(e.data!=="$?"||a.readyState!=="loading")t();else{var i=function(){t(),a.removeEventListener("DOMContentLoaded",i)};a.addEventListener("DOMContentLoaded",i),e._reactRetry=i}}function Ft(e){for(;e!=null;e=e.nextSibling){var t=e.nodeType;if(t===1||t===3)break;if(t===8){if(t=e.data,t==="$"||t==="$!"||t==="$?"||t==="$~"||t==="&"||t==="F!"||t==="F")break;if(t==="/$"||t==="/&")return null}}return e}var Zc=null;function A0(e){e=e.nextSibling;for(var t=0;e;){if(e.nodeType===8){var a=e.data;if(a==="/$"||a==="/&"){if(t===0)return Ft(e.nextSibling);t--}else a!=="$"&&a!=="$!"&&a!=="$?"&&a!=="$~"&&a!=="&"||t++}e=e.nextSibling}return null}function C0(e){e=e.previousSibling;for(var t=0;e;){if(e.nodeType===8){var a=e.data;if(a==="$"||a==="$!"||a==="$?"||a==="$~"||a==="&"){if(t===0)return e;t--}else a!=="/$"&&a!=="/&"||t++}e=e.previousSibling}return null}function M0(e,t,a){switch(t=Xr(a),e){case"html":if(e=t.documentElement,!e)throw Error(r(452));return e;case"head":if(e=t.head,!e)throw Error(r(453));return e;case"body":if(e=t.body,!e)throw Error(r(454));return e;default:throw Error(r(451))}}function eo(e){for(var t=e.attributes;t.length;)e.removeAttributeNode(t[0]);gi(e)}var Pt=new Map,z0=new Set;function Qr(e){return typeof e.getRootNode=="function"?e.getRootNode():e.nodeType===9?e:e.ownerDocument}var Xn=j.d;j.d={f:ax,r:lx,D:ix,C:ox,L:rx,m:ux,X:cx,S:sx,M:fx};function ax(){var e=Xn.f(),t=Hr();return e||t}function lx(e){var t=Jn(e);t!==null&&t.tag===5&&t.type==="form"?Zh(t):Xn.r(e)}var $l=typeof document>"u"?null:document;function D0(e,t,a){var i=$l;if(i&&typeof t=="string"&&t){var s=Et(t);s='link[rel="'+e+'"][href="'+s+'"]',typeof a=="string"&&(s+='[crossorigin="'+a+'"]'),z0.has(s)||(z0.add(s),e={rel:e,crossOrigin:a,href:t},i.querySelector(s)===null&&(t=i.createElement("link"),ht(t,"link",e),et(t),i.head.appendChild(t)))}}function ix(e){Xn.D(e),D0("dns-prefetch",e,null)}function ox(e,t){Xn.C(e,t),D0("preconnect",e,t)}function rx(e,t,a){Xn.L(e,t,a);var i=$l;if(i&&e&&t){var s='link[rel="preload"][as="'+Et(t)+'"]';t==="image"&&a&&a.imageSrcSet?(s+='[imagesrcset="'+Et(a.imageSrcSet)+'"]',typeof a.imageSizes=="string"&&(s+='[imagesizes="'+Et(a.imageSizes)+'"]')):s+='[href="'+Et(e)+'"]';var c=s;switch(t){case"style":c=Zl(e);break;case"script":c=Kl(e)}Pt.has(c)||(e=p({rel:"preload",href:t==="image"&&a&&a.imageSrcSet?void 0:e,as:t},a),Pt.set(c,e),i.querySelector(s)!==null||t==="style"&&i.querySelector(to(c))||t==="script"&&i.querySelector(no(c))||(t=i.createElement("link"),ht(t,"link",e),et(t),i.head.appendChild(t)))}}function ux(e,t){Xn.m(e,t);var a=$l;if(a&&e){var i=t&&typeof t.as=="string"?t.as:"script",s='link[rel="modulepreload"][as="'+Et(i)+'"][href="'+Et(e)+'"]',c=s;switch(i){case"audioworklet":case"paintworklet":case"serviceworker":case"sharedworker":case"worker":case"script":c=Kl(e)}if(!Pt.has(c)&&(e=p({rel:"modulepreload",href:e},t),Pt.set(c,e),a.querySelector(s)===null)){switch(i){case"audioworklet":case"paintworklet":case"serviceworker":case"sharedworker":case"worker":case"script":if(a.querySelector(no(c)))return}i=a.createElement("link"),ht(i,"link",e),et(i),a.head.appendChild(i)}}}function sx(e,t,a){Xn.S(e,t,a);var i=$l;if(i&&e){var s=Wn(i).hoistableStyles,c=Zl(e);t=t||"default";var m=s.get(c);if(!m){var S={loading:0,preload:null};if(m=i.querySelector(to(c)))S.loading=5;else{e=p({rel:"stylesheet",href:e,"data-precedence":t},a),(a=Pt.get(c))&&Kc(e,a);var O=m=i.createElement("link");et(O),ht(O,"link",e),O._p=new Promise(function(W,le){O.onload=W,O.onerror=le}),O.addEventListener("load",function(){S.loading|=1}),O.addEventListener("error",function(){S.loading|=2}),S.loading|=4,$r(m,t,i)}m={type:"stylesheet",instance:m,count:1,state:S},s.set(c,m)}}}function cx(e,t){Xn.X(e,t);var a=$l;if(a&&e){var i=Wn(a).hoistableScripts,s=Kl(e),c=i.get(s);c||(c=a.querySelector(no(s)),c||(e=p({src:e,async:!0},t),(t=Pt.get(s))&&Jc(e,t),c=a.createElement("script"),et(c),ht(c,"link",e),a.head.appendChild(c)),c={type:"script",instance:c,count:1,state:null},i.set(s,c))}}function fx(e,t){Xn.M(e,t);var a=$l;if(a&&e){var i=Wn(a).hoistableScripts,s=Kl(e),c=i.get(s);c||(c=a.querySelector(no(s)),c||(e=p({src:e,async:!0,type:"module"},t),(t=Pt.get(s))&&Jc(e,t),c=a.createElement("script"),et(c),ht(c,"link",e),a.head.appendChild(c)),c={type:"script",instance:c,count:1,state:null},i.set(s,c))}}function k0(e,t,a,i){var s=(s=se.current)?Qr(s):null;if(!s)throw Error(r(446));switch(e){case"meta":case"title":return null;case"style":return typeof a.precedence=="string"&&typeof a.href=="string"?(t=Zl(a.href),a=Wn(s).hoistableStyles,i=a.get(t),i||(i={type:"style",instance:null,count:0,state:null},a.set(t,i)),i):{type:"void",instance:null,count:0,state:null};case"link":if(a.rel==="stylesheet"&&typeof a.href=="string"&&typeof a.precedence=="string"){e=Zl(a.href);var c=Wn(s).hoistableStyles,m=c.get(e);if(m||(s=s.ownerDocument||s,m={type:"stylesheet",instance:null,count:0,state:{loading:0,preload:null}},c.set(e,m),(c=s.querySelector(to(e)))&&!c._p&&(m.instance=c,m.state.loading=5),Pt.has(e)||(a={rel:"preload",as:"style",href:a.href,crossOrigin:a.crossOrigin,integrity:a.integrity,media:a.media,hrefLang:a.hrefLang,referrerPolicy:a.referrerPolicy},Pt.set(e,a),c||dx(s,e,a,m.state))),t&&i===null)throw Error(r(528,""));return m}if(t&&i!==null)throw Error(r(529,""));return null;case"script":return t=a.async,a=a.src,typeof a=="string"&&t&&typeof t!="function"&&typeof t!="symbol"?(t=Kl(a),a=Wn(s).hoistableScripts,i=a.get(t),i||(i={type:"script",instance:null,count:0,state:null},a.set(t,i)),i):{type:"void",instance:null,count:0,state:null};default:throw Error(r(444,e))}}function Zl(e){return'href="'+Et(e)+'"'}function to(e){return'link[rel="stylesheet"]['+e+"]"}function R0(e){return p({},e,{"data-precedence":e.precedence,precedence:null})}function dx(e,t,a,i){e.querySelector('link[rel="preload"][as="style"]['+t+"]")?i.loading=1:(t=e.createElement("link"),i.preload=t,t.addEventListener("load",function(){return i.loading|=1}),t.addEventListener("error",function(){return i.loading|=2}),ht(t,"link",a),et(t),e.head.appendChild(t))}function Kl(e){return'[src="'+Et(e)+'"]'}function no(e){return"script[async]"+e}function j0(e,t,a){if(t.count++,t.instance===null)switch(t.type){case"style":var i=e.querySelector('style[data-href~="'+Et(a.href)+'"]');if(i)return t.instance=i,et(i),i;var s=p({},a,{"data-href":a.href,"data-precedence":a.precedence,href:null,precedence:null});return i=(e.ownerDocument||e).createElement("style"),et(i),ht(i,"style",s),$r(i,a.precedence,e),t.instance=i;case"stylesheet":s=Zl(a.href);var c=e.querySelector(to(s));if(c)return t.state.loading|=4,t.instance=c,et(c),c;i=R0(a),(s=Pt.get(s))&&Kc(i,s),c=(e.ownerDocument||e).createElement("link"),et(c);var m=c;return m._p=new Promise(function(S,O){m.onload=S,m.onerror=O}),ht(c,"link",i),t.state.loading|=4,$r(c,a.precedence,e),t.instance=c;case"script":return c=Kl(a.src),(s=e.querySelector(no(c)))?(t.instance=s,et(s),s):(i=a,(s=Pt.get(c))&&(i=p({},a),Jc(i,s)),e=e.ownerDocument||e,s=e.createElement("script"),et(s),ht(s,"link",i),e.head.appendChild(s),t.instance=s);case"void":return null;default:throw Error(r(443,t.type))}else t.type==="stylesheet"&&(t.state.loading&4)===0&&(i=t.instance,t.state.loading|=4,$r(i,a.precedence,e));return t.instance}function $r(e,t,a){for(var i=a.querySelectorAll('link[rel="stylesheet"][data-precedence],style[data-precedence]'),s=i.length?i[i.length-1]:null,c=s,m=0;m<i.length;m++){var S=i[m];if(S.dataset.precedence===t)c=S;else if(c!==s)break}c?c.parentNode.insertBefore(e,c.nextSibling):(t=a.nodeType===9?a.head:a,t.insertBefore(e,t.firstChild))}function Kc(e,t){e.crossOrigin==null&&(e.crossOrigin=t.crossOrigin),e.referrerPolicy==null&&(e.referrerPolicy=t.referrerPolicy),e.title==null&&(e.title=t.title)}function Jc(e,t){e.crossOrigin==null&&(e.crossOrigin=t.crossOrigin),e.referrerPolicy==null&&(e.referrerPolicy=t.referrerPolicy),e.integrity==null&&(e.integrity=t.integrity)}var Zr=null;function O0(e,t,a){if(Zr===null){var i=new Map,s=Zr=new Map;s.set(a,i)}else s=Zr,i=s.get(a),i||(i=new Map,s.set(a,i));if(i.has(e))return i;for(i.set(e,null),a=a.getElementsByTagName(e),s=0;s<a.length;s++){var c=a[s];if(!(c[ka]||c[ot]||e==="link"&&c.getAttribute("rel")==="stylesheet")&&c.namespaceURI!=="http://www.w3.org/2000/svg"){var m=c.getAttribute(t)||"";m=e+m;var S=i.get(m);S?S.push(c):i.set(m,[c])}}return i}function H0(e,t,a){e=e.ownerDocument||e,e.head.insertBefore(a,t==="title"?e.querySelector("head > title"):null)}function hx(e,t,a){if(a===1||t.itemProp!=null)return!1;switch(e){case"meta":case"title":return!0;case"style":if(typeof t.precedence!="string"||typeof t.href!="string"||t.href==="")break;return!0;case"link":if(typeof t.rel!="string"||typeof t.href!="string"||t.href===""||t.onLoad||t.onError)break;switch(t.rel){case"stylesheet":return e=t.disabled,typeof t.precedence=="string"&&e==null;default:return!0}case"script":if(t.async&&typeof t.async!="function"&&typeof t.async!="symbol"&&!t.onLoad&&!t.onError&&t.src&&typeof t.src=="string")return!0}return!1}function B0(e){return!(e.type==="stylesheet"&&(e.state.loading&3)===0)}function gx(e,t,a,i){if(a.type==="stylesheet"&&(typeof i.media!="string"||matchMedia(i.media).matches!==!1)&&(a.state.loading&4)===0){if(a.instance===null){var s=Zl(i.href),c=t.querySelector(to(s));if(c){t=c._p,t!==null&&typeof t=="object"&&typeof t.then=="function"&&(e.count++,e=Kr.bind(e),t.then(e,e)),a.state.loading|=4,a.instance=c,et(c);return}c=t.ownerDocument||t,i=R0(i),(s=Pt.get(s))&&Kc(i,s),c=c.createElement("link"),et(c);var m=c;m._p=new Promise(function(S,O){m.onload=S,m.onerror=O}),ht(c,"link",i),a.instance=c}e.stylesheets===null&&(e.stylesheets=new Map),e.stylesheets.set(a,t),(t=a.state.preload)&&(a.state.loading&3)===0&&(e.count++,a=Kr.bind(e),t.addEventListener("load",a),t.addEventListener("error",a))}}var Ic=0;function yx(e,t){return e.stylesheets&&e.count===0&&Ir(e,e.stylesheets),0<e.count||0<e.imgCount?function(a){var i=setTimeout(function(){if(e.stylesheets&&Ir(e,e.stylesheets),e.unsuspend){var c=e.unsuspend;e.unsuspend=null,c()}},6e4+t);0<e.imgBytes&&Ic===0&&(Ic=62500*Jb());var s=setTimeout(function(){if(e.waitingForImages=!1,e.count===0&&(e.stylesheets&&Ir(e,e.stylesheets),e.unsuspend)){var c=e.unsuspend;e.unsuspend=null,c()}},(e.imgBytes>Ic?50:800)+t);return e.unsuspend=a,function(){e.unsuspend=null,clearTimeout(i),clearTimeout(s)}}:null}function Kr(){if(this.count--,this.count===0&&(this.imgCount===0||!this.waitingForImages)){if(this.stylesheets)Ir(this,this.stylesheets);else if(this.unsuspend){var e=this.unsuspend;this.unsuspend=null,e()}}}var Jr=null;function Ir(e,t){e.stylesheets=null,e.unsuspend!==null&&(e.count++,Jr=new Map,t.forEach(mx,e),Jr=null,Kr.call(e))}function mx(e,t){if(!(t.state.loading&4)){var a=Jr.get(e);if(a)var i=a.get(null);else{a=new Map,Jr.set(e,a);for(var s=e.querySelectorAll("link[data-precedence],style[data-precedence]"),c=0;c<s.length;c++){var m=s[c];(m.nodeName==="LINK"||m.getAttribute("media")!=="not all")&&(a.set(m.dataset.precedence,m),i=m)}i&&a.set(null,i)}s=t.instance,m=s.getAttribute("data-precedence"),c=a.get(m)||i,c===i&&a.set(null,s),a.set(m,s),this.count++,i=Kr.bind(this),s.addEventListener("load",i),s.addEventListener("error",i),c?c.parentNode.insertBefore(s,c.nextSibling):(e=e.nodeType===9?e.head:e,e.insertBefore(s,e.firstChild)),t.state.loading|=4}}var ao={$$typeof:w,Provider:null,Consumer:null,_currentValue:V,_currentValue2:V,_threadCount:0};function px(e,t,a,i,s,c,m,S,O){this.tag=1,this.containerInfo=e,this.pingCache=this.current=this.pendingChildren=null,this.timeoutHandle=-1,this.callbackNode=this.next=this.pendingContext=this.context=this.cancelPendingCommit=null,this.callbackPriority=0,this.expirationTimes=fi(-1),this.entangledLanes=this.shellSuspendCounter=this.errorRecoveryDisabledLanes=this.expiredLanes=this.warmLanes=this.pingedLanes=this.suspendedLanes=this.pendingLanes=0,this.entanglements=fi(0),this.hiddenUpdates=fi(null),this.identifierPrefix=i,this.onUncaughtError=s,this.onCaughtError=c,this.onRecoverableError=m,this.pooledCache=null,this.pooledCacheLanes=0,this.formState=O,this.incompleteTransitions=new Map}function L0(e,t,a,i,s,c,m,S,O,W,le,ce){return e=new px(e,t,a,m,O,W,le,ce,S),t=1,c===!0&&(t|=24),c=Ot(3,null,null,t),e.current=c,c.stateNode=e,t=Ms(),t.refCount++,e.pooledCache=t,t.refCount++,c.memoizedState={element:i,isDehydrated:a,cache:t},Rs(c),e}function U0(e){return e?(e=Nl,e):Nl}function G0(e,t,a,i,s,c){s=U0(s),i.context===null?i.context=s:i.pendingContext=s,i=oa(t),i.payload={element:a},c=c===void 0?null:c,c!==null&&(i.callback=c),a=ra(e,i,t),a!==null&&(zt(a,e,t),Oi(a,e,t))}function Y0(e,t){if(e=e.memoizedState,e!==null&&e.dehydrated!==null){var a=e.retryLane;e.retryLane=a!==0&&a<t?a:t}}function Wc(e,t){Y0(e,t),(e=e.alternate)&&Y0(e,t)}function V0(e){if(e.tag===13||e.tag===31){var t=Ba(e,67108864);t!==null&&zt(t,e,67108864),Wc(e,67108864)}}function q0(e){if(e.tag===13||e.tag===31){var t=Gt();t=di(t);var a=Ba(e,t);a!==null&&zt(a,e,t),Wc(e,t)}}var Wr=!0;function vx(e,t,a,i){var s=A.T;A.T=null;var c=j.p;try{j.p=2,Fc(e,t,a,i)}finally{j.p=c,A.T=s}}function bx(e,t,a,i){var s=A.T;A.T=null;var c=j.p;try{j.p=8,Fc(e,t,a,i)}finally{j.p=c,A.T=s}}function Fc(e,t,a,i){if(Wr){var s=Pc(i);if(s===null)Lc(e,t,i,Fr,a),Q0(e,i);else if(_x(s,e,t,a,i))i.stopPropagation();else if(Q0(e,i),t&4&&-1<xx.indexOf(e)){for(;s!==null;){var c=Jn(s);if(c!==null)switch(c.tag){case 3:if(c=c.stateNode,c.current.memoizedState.isDehydrated){var m=Nn(c.pendingLanes);if(m!==0){var S=c;for(S.pendingLanes|=2,S.entangledLanes|=2;m;){var O=1<<31-vt(m);S.entanglements[1]|=O,m&=~O}vn(c),(He&6)===0&&(jr=We()+500,Wi(0))}}break;case 31:case 13:S=Ba(c,2),S!==null&&zt(S,c,2),Hr(),Wc(c,2)}if(c=Pc(i),c===null&&Lc(e,t,i,Fr,a),c===s)break;s=c}s!==null&&i.stopPropagation()}else Lc(e,t,i,null,a)}}function Pc(e){return e=ts(e),ef(e)}var Fr=null;function ef(e){if(Fr=null,e=Kn(e),e!==null){var t=f(e);if(t===null)e=null;else{var a=t.tag;if(a===13){if(e=d(t),e!==null)return e;e=null}else if(a===31){if(e=h(t),e!==null)return e;e=null}else if(a===3){if(t.stateNode.current.memoizedState.isDehydrated)return t.tag===3?t.stateNode.containerInfo:null;e=null}else t!==e&&(e=null)}}return Fr=e,null}function X0(e){switch(e){case"beforetoggle":case"cancel":case"click":case"close":case"contextmenu":case"copy":case"cut":case"auxclick":case"dblclick":case"dragend":case"dragstart":case"drop":case"focusin":case"focusout":case"input":case"invalid":case"keydown":case"keypress":case"keyup":case"mousedown":case"mouseup":case"paste":case"pause":case"play":case"pointercancel":case"pointerdown":case"pointerup":case"ratechange":case"reset":case"resize":case"seeked":case"submit":case"toggle":case"touchcancel":case"touchend":case"touchstart":case"volumechange":case"change":case"selectionchange":case"textInput":case"compositionstart":case"compositionend":case"compositionupdate":case"beforeblur":case"afterblur":case"beforeinput":case"blur":case"fullscreenchange":case"focus":case"hashchange":case"popstate":case"select":case"selectstart":return 2;case"drag":case"dragenter":case"dragexit":case"dragleave":case"dragover":case"mousemove":case"mouseout":case"mouseover":case"pointermove":case"pointerout":case"pointerover":case"scroll":case"touchmove":case"wheel":case"mouseenter":case"mouseleave":case"pointerenter":case"pointerleave":return 8;case"message":switch(Rt()){case qt:return 2;case Xt:return 8;case Qt:case ci:return 32;case ul:return 268435456;default:return 32}default:return 32}}var tf=!1,va=null,ba=null,xa=null,lo=new Map,io=new Map,_a=[],xx="mousedown mouseup touchcancel touchend touchstart auxclick dblclick pointercancel pointerdown pointerup dragend dragstart drop compositionend compositionstart keydown keypress keyup input textInput copy cut paste click change contextmenu reset".split(" ");function Q0(e,t){switch(e){case"focusin":case"focusout":va=null;break;case"dragenter":case"dragleave":ba=null;break;case"mouseover":case"mouseout":xa=null;break;case"pointerover":case"pointerout":lo.delete(t.pointerId);break;case"gotpointercapture":case"lostpointercapture":io.delete(t.pointerId)}}function oo(e,t,a,i,s,c){return e===null||e.nativeEvent!==c?(e={blockedOn:t,domEventName:a,eventSystemFlags:i,nativeEvent:c,targetContainers:[s]},t!==null&&(t=Jn(t),t!==null&&V0(t)),e):(e.eventSystemFlags|=i,t=e.targetContainers,s!==null&&t.indexOf(s)===-1&&t.push(s),e)}function _x(e,t,a,i,s){switch(t){case"focusin":return va=oo(va,e,t,a,i,s),!0;case"dragenter":return ba=oo(ba,e,t,a,i,s),!0;case"mouseover":return xa=oo(xa,e,t,a,i,s),!0;case"pointerover":var c=s.pointerId;return lo.set(c,oo(lo.get(c)||null,e,t,a,i,s)),!0;case"gotpointercapture":return c=s.pointerId,io.set(c,oo(io.get(c)||null,e,t,a,i,s)),!0}return!1}function $0(e){var t=Kn(e.target);if(t!==null){var a=f(t);if(a!==null){if(t=a.tag,t===13){if(t=d(a),t!==null){e.blockedOn=t,Yo(e.priority,function(){q0(a)});return}}else if(t===31){if(t=h(a),t!==null){e.blockedOn=t,Yo(e.priority,function(){q0(a)});return}}else if(t===3&&a.stateNode.current.memoizedState.isDehydrated){e.blockedOn=a.tag===3?a.stateNode.containerInfo:null;return}}}e.blockedOn=null}function Pr(e){if(e.blockedOn!==null)return!1;for(var t=e.targetContainers;0<t.length;){var a=Pc(e.nativeEvent);if(a===null){a=e.nativeEvent;var i=new a.constructor(a.type,a);es=i,a.target.dispatchEvent(i),es=null}else return t=Jn(a),t!==null&&V0(t),e.blockedOn=a,!1;t.shift()}return!0}function Z0(e,t,a){Pr(e)&&a.delete(t)}function wx(){tf=!1,va!==null&&Pr(va)&&(va=null),ba!==null&&Pr(ba)&&(ba=null),xa!==null&&Pr(xa)&&(xa=null),lo.forEach(Z0),io.forEach(Z0)}function eu(e,t){e.blockedOn===t&&(e.blockedOn=null,tf||(tf=!0,n.unstable_scheduleCallback(n.unstable_NormalPriority,wx)))}var tu=null;function K0(e){tu!==e&&(tu=e,n.unstable_scheduleCallback(n.unstable_NormalPriority,function(){tu===e&&(tu=null);for(var t=0;t<e.length;t+=3){var a=e[t],i=e[t+1],s=e[t+2];if(typeof i!="function"){if(ef(i||a)===null)continue;break}var c=Jn(a);c!==null&&(e.splice(t,3),t-=3,Ps(c,{pending:!0,data:s,method:a.method,action:i},i,s))}}))}function Jl(e){function t(O){return eu(O,e)}va!==null&&eu(va,e),ba!==null&&eu(ba,e),xa!==null&&eu(xa,e),lo.forEach(t),io.forEach(t);for(var a=0;a<_a.length;a++){var i=_a[a];i.blockedOn===e&&(i.blockedOn=null)}for(;0<_a.length&&(a=_a[0],a.blockedOn===null);)$0(a),a.blockedOn===null&&_a.shift();if(a=(e.ownerDocument||e).$$reactFormReplay,a!=null)for(i=0;i<a.length;i+=3){var s=a[i],c=a[i+1],m=s[gt]||null;if(typeof c=="function")m||K0(a);else if(m){var S=null;if(c&&c.hasAttribute("formAction")){if(s=c,m=c[gt]||null)S=m.formAction;else if(ef(s)!==null)continue}else S=m.action;typeof S=="function"?a[i+1]=S:(a.splice(i,3),i-=3),K0(a)}}}function J0(){function e(c){c.canIntercept&&c.info==="react-transition"&&c.intercept({handler:function(){return new Promise(function(m){return s=m})},focusReset:"manual",scroll:"manual"})}function t(){s!==null&&(s(),s=null),i||setTimeout(a,20)}function a(){if(!i&&!navigation.transition){var c=navigation.currentEntry;c&&c.url!=null&&navigation.navigate(c.url,{state:c.getState(),info:"react-transition",history:"replace"})}}if(typeof navigation=="object"){var i=!1,s=null;return navigation.addEventListener("navigate",e),navigation.addEventListener("navigatesuccess",t),navigation.addEventListener("navigateerror",t),setTimeout(a,100),function(){i=!0,navigation.removeEventListener("navigate",e),navigation.removeEventListener("navigatesuccess",t),navigation.removeEventListener("navigateerror",t),s!==null&&(s(),s=null)}}}function nf(e){this._internalRoot=e}nu.prototype.render=nf.prototype.render=function(e){var t=this._internalRoot;if(t===null)throw Error(r(409));var a=t.current,i=Gt();G0(a,i,e,t,null,null)},nu.prototype.unmount=nf.prototype.unmount=function(){var e=this._internalRoot;if(e!==null){this._internalRoot=null;var t=e.containerInfo;G0(e.current,2,null,e,null,null),Hr(),t[Tn]=null}};function nu(e){this._internalRoot=e}nu.prototype.unstable_scheduleHydration=function(e){if(e){var t=Go();e={blockedOn:null,target:e,priority:t};for(var a=0;a<_a.length&&t!==0&&t<_a[a].priority;a++);_a.splice(a,0,e),a===0&&$0(e)}};var I0=l.version;if(I0!=="19.2.8")throw Error(r(527,I0,"19.2.8"));j.findDOMNode=function(e){var t=e._reactInternals;if(t===void 0)throw typeof e.render=="function"?Error(r(188)):(e=Object.keys(e).join(","),Error(r(268,e)));return e=g(t),e=e!==null?b(e):null,e=e===null?null:e.stateNode,e};var Sx={bundleType:0,version:"19.2.8",rendererPackageName:"react-dom",currentDispatcherRef:A,reconcilerVersion:"19.2.8"};if(typeof __REACT_DEVTOOLS_GLOBAL_HOOK__<"u"){var au=__REACT_DEVTOOLS_GLOBAL_HOOK__;if(!au.isDisabled&&au.supportsFiber)try{Ma=au.inject(Sx),pt=au}catch{}}return uo.createRoot=function(e,t){if(!u(e))throw Error(r(299));var a=!1,i="",s=ag,c=lg,m=ig;return t!=null&&(t.unstable_strictMode===!0&&(a=!0),t.identifierPrefix!==void 0&&(i=t.identifierPrefix),t.onUncaughtError!==void 0&&(s=t.onUncaughtError),t.onCaughtError!==void 0&&(c=t.onCaughtError),t.onRecoverableError!==void 0&&(m=t.onRecoverableError)),t=L0(e,1,!1,null,null,a,i,null,s,c,m,J0),e[Tn]=t.current,Bc(e),new nf(t)},uo.hydrateRoot=function(e,t,a){if(!u(e))throw Error(r(299));var i=!1,s="",c=ag,m=lg,S=ig,O=null;return a!=null&&(a.unstable_strictMode===!0&&(i=!0),a.identifierPrefix!==void 0&&(s=a.identifierPrefix),a.onUncaughtError!==void 0&&(c=a.onUncaughtError),a.onCaughtError!==void 0&&(m=a.onCaughtError),a.onRecoverableError!==void 0&&(S=a.onRecoverableError),a.formState!==void 0&&(O=a.formState)),t=L0(e,1,!0,t,a??null,i,s,O,c,m,S,J0),t.context=U0(null),a=t.current,i=Gt(),i=di(i),s=oa(i),s.callback=null,ra(a,s,i),a=i,t.current.lanes=a,Da(t,a),vn(t),e[Tn]=t.current,Bc(e),new nu(t)},uo.version="19.2.8",uo}var oy;function kx(){if(oy)return of.exports;oy=1;function n(){if(!(typeof __REACT_DEVTOOLS_GLOBAL_HOOK__>"u"||typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE!="function"))try{__REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(n)}catch(l){console.error(l)}}return n(),of.exports=Dx(),of.exports}var Rx=kx();function it(n){if(typeof n=="string"||typeof n=="number")return""+n;let l="";if(Array.isArray(n))for(let o=0,r;o<n.length;o++)(r=it(n[o]))!==""&&(l+=(l&&" ")+r);else for(let o in n)n[o]&&(l+=(l&&" ")+o);return l}var jx={value:()=>{}};function Du(){for(var n=0,l=arguments.length,o={},r;n<l;++n){if(!(r=arguments[n]+"")||r in o||/[\s.]/.test(r))throw new Error("illegal type: "+r);o[r]=[]}return new gu(o)}function gu(n){this._=n}function Ox(n,l){return n.trim().split(/^|\s+/).map(function(o){var r="",u=o.indexOf(".");if(u>=0&&(r=o.slice(u+1),o=o.slice(0,u)),o&&!l.hasOwnProperty(o))throw new Error("unknown type: "+o);return{type:o,name:r}})}gu.prototype=Du.prototype={constructor:gu,on:function(n,l){var o=this._,r=Ox(n+"",o),u,f=-1,d=r.length;if(arguments.length<2){for(;++f<d;)if((u=(n=r[f]).type)&&(u=Hx(o[u],n.name)))return u;return}if(l!=null&&typeof l!="function")throw new Error("invalid callback: "+l);for(;++f<d;)if(u=(n=r[f]).type)o[u]=ry(o[u],n.name,l);else if(l==null)for(u in o)o[u]=ry(o[u],n.name,null);return this},copy:function(){var n={},l=this._;for(var o in l)n[o]=l[o].slice();return new gu(n)},call:function(n,l){if((u=arguments.length-2)>0)for(var o=new Array(u),r=0,u,f;r<u;++r)o[r]=arguments[r+2];if(!this._.hasOwnProperty(n))throw new Error("unknown type: "+n);for(f=this._[n],r=0,u=f.length;r<u;++r)f[r].value.apply(l,o)},apply:function(n,l,o){if(!this._.hasOwnProperty(n))throw new Error("unknown type: "+n);for(var r=this._[n],u=0,f=r.length;u<f;++u)r[u].value.apply(l,o)}};function Hx(n,l){for(var o=0,r=n.length,u;o<r;++o)if((u=n[o]).name===l)return u.value}function ry(n,l,o){for(var r=0,u=n.length;r<u;++r)if(n[r].name===l){n[r]=jx,n=n.slice(0,r).concat(n.slice(r+1));break}return o!=null&&n.push({name:l,value:o}),n}var Cf="http://www.w3.org/1999/xhtml";const uy={svg:"http://www.w3.org/2000/svg",xhtml:Cf,xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"};function ku(n){var l=n+="",o=l.indexOf(":");return o>=0&&(l=n.slice(0,o))!=="xmlns"&&(n=n.slice(o+1)),uy.hasOwnProperty(l)?{space:uy[l],local:n}:n}function Bx(n){return function(){var l=this.ownerDocument,o=this.namespaceURI;return o===Cf&&l.documentElement.namespaceURI===Cf?l.createElement(n):l.createElementNS(o,n)}}function Lx(n){return function(){return this.ownerDocument.createElementNS(n.space,n.local)}}function Nm(n){var l=ku(n);return(l.local?Lx:Bx)(l)}function Ux(){}function Wf(n){return n==null?Ux:function(){return this.querySelector(n)}}function Gx(n){typeof n!="function"&&(n=Wf(n));for(var l=this._groups,o=l.length,r=new Array(o),u=0;u<o;++u)for(var f=l[u],d=f.length,h=r[u]=new Array(d),y,g,b=0;b<d;++b)(y=f[b])&&(g=n.call(y,y.__data__,b,f))&&("__data__"in y&&(g.__data__=y.__data__),h[b]=g);return new Vt(r,this._parents)}function Yx(n){return n==null?[]:Array.isArray(n)?n:Array.from(n)}function Vx(){return[]}function Tm(n){return n==null?Vx:function(){return this.querySelectorAll(n)}}function qx(n){return function(){return Yx(n.apply(this,arguments))}}function Xx(n){typeof n=="function"?n=qx(n):n=Tm(n);for(var l=this._groups,o=l.length,r=[],u=[],f=0;f<o;++f)for(var d=l[f],h=d.length,y,g=0;g<h;++g)(y=d[g])&&(r.push(n.call(y,y.__data__,g,d)),u.push(y));return new Vt(r,u)}function Am(n){return function(){return this.matches(n)}}function Cm(n){return function(l){return l.matches(n)}}var Qx=Array.prototype.find;function $x(n){return function(){return Qx.call(this.children,n)}}function Zx(){return this.firstElementChild}function Kx(n){return this.select(n==null?Zx:$x(typeof n=="function"?n:Cm(n)))}var Jx=Array.prototype.filter;function Ix(){return Array.from(this.children)}function Wx(n){return function(){return Jx.call(this.children,n)}}function Fx(n){return this.selectAll(n==null?Ix:Wx(typeof n=="function"?n:Cm(n)))}function Px(n){typeof n!="function"&&(n=Am(n));for(var l=this._groups,o=l.length,r=new Array(o),u=0;u<o;++u)for(var f=l[u],d=f.length,h=r[u]=[],y,g=0;g<d;++g)(y=f[g])&&n.call(y,y.__data__,g,f)&&h.push(y);return new Vt(r,this._parents)}function Mm(n){return new Array(n.length)}function e1(){return new Vt(this._enter||this._groups.map(Mm),this._parents)}function bu(n,l){this.ownerDocument=n.ownerDocument,this.namespaceURI=n.namespaceURI,this._next=null,this._parent=n,this.__data__=l}bu.prototype={constructor:bu,appendChild:function(n){return this._parent.insertBefore(n,this._next)},insertBefore:function(n,l){return this._parent.insertBefore(n,l)},querySelector:function(n){return this._parent.querySelector(n)},querySelectorAll:function(n){return this._parent.querySelectorAll(n)}};function t1(n){return function(){return n}}function n1(n,l,o,r,u,f){for(var d=0,h,y=l.length,g=f.length;d<g;++d)(h=l[d])?(h.__data__=f[d],r[d]=h):o[d]=new bu(n,f[d]);for(;d<y;++d)(h=l[d])&&(u[d]=h)}function a1(n,l,o,r,u,f,d){var h,y,g=new Map,b=l.length,p=f.length,v=new Array(b),x;for(h=0;h<b;++h)(y=l[h])&&(v[h]=x=d.call(y,y.__data__,h,l)+"",g.has(x)?u[h]=y:g.set(x,y));for(h=0;h<p;++h)x=d.call(n,f[h],h,f)+"",(y=g.get(x))?(r[h]=y,y.__data__=f[h],g.delete(x)):o[h]=new bu(n,f[h]);for(h=0;h<b;++h)(y=l[h])&&g.get(v[h])===y&&(u[h]=y)}function l1(n){return n.__data__}function i1(n,l){if(!arguments.length)return Array.from(this,l1);var o=l?a1:n1,r=this._parents,u=this._groups;typeof n!="function"&&(n=t1(n));for(var f=u.length,d=new Array(f),h=new Array(f),y=new Array(f),g=0;g<f;++g){var b=r[g],p=u[g],v=p.length,x=o1(n.call(b,b&&b.__data__,g,r)),_=x.length,C=h[g]=new Array(_),M=d[g]=new Array(_),E=y[g]=new Array(v);o(b,p,C,M,E,x,l);for(var H=0,w=0,z,G;H<_;++H)if(z=C[H]){for(H>=w&&(w=H+1);!(G=M[w])&&++w<_;);z._next=G||null}}return d=new Vt(d,r),d._enter=h,d._exit=y,d}function o1(n){return typeof n=="object"&&"length"in n?n:Array.from(n)}function r1(){return new Vt(this._exit||this._groups.map(Mm),this._parents)}function u1(n,l,o){var r=this.enter(),u=this,f=this.exit();return typeof n=="function"?(r=n(r),r&&(r=r.selection())):r=r.append(n+""),l!=null&&(u=l(u),u&&(u=u.selection())),o==null?f.remove():o(f),r&&u?r.merge(u).order():u}function s1(n){for(var l=n.selection?n.selection():n,o=this._groups,r=l._groups,u=o.length,f=r.length,d=Math.min(u,f),h=new Array(u),y=0;y<d;++y)for(var g=o[y],b=r[y],p=g.length,v=h[y]=new Array(p),x,_=0;_<p;++_)(x=g[_]||b[_])&&(v[_]=x);for(;y<u;++y)h[y]=o[y];return new Vt(h,this._parents)}function c1(){for(var n=this._groups,l=-1,o=n.length;++l<o;)for(var r=n[l],u=r.length-1,f=r[u],d;--u>=0;)(d=r[u])&&(f&&d.compareDocumentPosition(f)^4&&f.parentNode.insertBefore(d,f),f=d);return this}function f1(n){n||(n=d1);function l(p,v){return p&&v?n(p.__data__,v.__data__):!p-!v}for(var o=this._groups,r=o.length,u=new Array(r),f=0;f<r;++f){for(var d=o[f],h=d.length,y=u[f]=new Array(h),g,b=0;b<h;++b)(g=d[b])&&(y[b]=g);y.sort(l)}return new Vt(u,this._parents).order()}function d1(n,l){return n<l?-1:n>l?1:n>=l?0:NaN}function h1(){var n=arguments[0];return arguments[0]=this,n.apply(null,arguments),this}function g1(){return Array.from(this)}function y1(){for(var n=this._groups,l=0,o=n.length;l<o;++l)for(var r=n[l],u=0,f=r.length;u<f;++u){var d=r[u];if(d)return d}return null}function m1(){let n=0;for(const l of this)++n;return n}function p1(){return!this.node()}function v1(n){for(var l=this._groups,o=0,r=l.length;o<r;++o)for(var u=l[o],f=0,d=u.length,h;f<d;++f)(h=u[f])&&n.call(h,h.__data__,f,u);return this}function b1(n){return function(){this.removeAttribute(n)}}function x1(n){return function(){this.removeAttributeNS(n.space,n.local)}}function _1(n,l){return function(){this.setAttribute(n,l)}}function w1(n,l){return function(){this.setAttributeNS(n.space,n.local,l)}}function S1(n,l){return function(){var o=l.apply(this,arguments);o==null?this.removeAttribute(n):this.setAttribute(n,o)}}function E1(n,l){return function(){var o=l.apply(this,arguments);o==null?this.removeAttributeNS(n.space,n.local):this.setAttributeNS(n.space,n.local,o)}}function N1(n,l){var o=ku(n);if(arguments.length<2){var r=this.node();return o.local?r.getAttributeNS(o.space,o.local):r.getAttribute(o)}return this.each((l==null?o.local?x1:b1:typeof l=="function"?o.local?E1:S1:o.local?w1:_1)(o,l))}function zm(n){return n.ownerDocument&&n.ownerDocument.defaultView||n.document&&n||n.defaultView}function T1(n){return function(){this.style.removeProperty(n)}}function A1(n,l,o){return function(){this.style.setProperty(n,l,o)}}function C1(n,l,o){return function(){var r=l.apply(this,arguments);r==null?this.style.removeProperty(n):this.style.setProperty(n,r,o)}}function M1(n,l,o){return arguments.length>1?this.each((l==null?T1:typeof l=="function"?C1:A1)(n,l,o??"")):ai(this.node(),n)}function ai(n,l){return n.style.getPropertyValue(l)||zm(n).getComputedStyle(n,null).getPropertyValue(l)}function z1(n){return function(){delete this[n]}}function D1(n,l){return function(){this[n]=l}}function k1(n,l){return function(){var o=l.apply(this,arguments);o==null?delete this[n]:this[n]=o}}function R1(n,l){return arguments.length>1?this.each((l==null?z1:typeof l=="function"?k1:D1)(n,l)):this.node()[n]}function Dm(n){return n.trim().split(/^|\s+/)}function Ff(n){return n.classList||new km(n)}function km(n){this._node=n,this._names=Dm(n.getAttribute("class")||"")}km.prototype={add:function(n){var l=this._names.indexOf(n);l<0&&(this._names.push(n),this._node.setAttribute("class",this._names.join(" ")))},remove:function(n){var l=this._names.indexOf(n);l>=0&&(this._names.splice(l,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(n){return this._names.indexOf(n)>=0}};function Rm(n,l){for(var o=Ff(n),r=-1,u=l.length;++r<u;)o.add(l[r])}function jm(n,l){for(var o=Ff(n),r=-1,u=l.length;++r<u;)o.remove(l[r])}function j1(n){return function(){Rm(this,n)}}function O1(n){return function(){jm(this,n)}}function H1(n,l){return function(){(l.apply(this,arguments)?Rm:jm)(this,n)}}function B1(n,l){var o=Dm(n+"");if(arguments.length<2){for(var r=Ff(this.node()),u=-1,f=o.length;++u<f;)if(!r.contains(o[u]))return!1;return!0}return this.each((typeof l=="function"?H1:l?j1:O1)(o,l))}function L1(){this.textContent=""}function U1(n){return function(){this.textContent=n}}function G1(n){return function(){var l=n.apply(this,arguments);this.textContent=l??""}}function Y1(n){return arguments.length?this.each(n==null?L1:(typeof n=="function"?G1:U1)(n)):this.node().textContent}function V1(){this.innerHTML=""}function q1(n){return function(){this.innerHTML=n}}function X1(n){return function(){var l=n.apply(this,arguments);this.innerHTML=l??""}}function Q1(n){return arguments.length?this.each(n==null?V1:(typeof n=="function"?X1:q1)(n)):this.node().innerHTML}function $1(){this.nextSibling&&this.parentNode.appendChild(this)}function Z1(){return this.each($1)}function K1(){this.previousSibling&&this.parentNode.insertBefore(this,this.parentNode.firstChild)}function J1(){return this.each(K1)}function I1(n){var l=typeof n=="function"?n:Nm(n);return this.select(function(){return this.appendChild(l.apply(this,arguments))})}function W1(){return null}function F1(n,l){var o=typeof n=="function"?n:Nm(n),r=l==null?W1:typeof l=="function"?l:Wf(l);return this.select(function(){return this.insertBefore(o.apply(this,arguments),r.apply(this,arguments)||null)})}function P1(){var n=this.parentNode;n&&n.removeChild(this)}function e_(){return this.each(P1)}function t_(){var n=this.cloneNode(!1),l=this.parentNode;return l?l.insertBefore(n,this.nextSibling):n}function n_(){var n=this.cloneNode(!0),l=this.parentNode;return l?l.insertBefore(n,this.nextSibling):n}function a_(n){return this.select(n?n_:t_)}function l_(n){return arguments.length?this.property("__data__",n):this.node().__data__}function i_(n){return function(l){n.call(this,l,this.__data__)}}function o_(n){return n.trim().split(/^|\s+/).map(function(l){var o="",r=l.indexOf(".");return r>=0&&(o=l.slice(r+1),l=l.slice(0,r)),{type:l,name:o}})}function r_(n){return function(){var l=this.__on;if(l){for(var o=0,r=-1,u=l.length,f;o<u;++o)f=l[o],(!n.type||f.type===n.type)&&f.name===n.name?this.removeEventListener(f.type,f.listener,f.options):l[++r]=f;++r?l.length=r:delete this.__on}}}function u_(n,l,o){return function(){var r=this.__on,u,f=i_(l);if(r){for(var d=0,h=r.length;d<h;++d)if((u=r[d]).type===n.type&&u.name===n.name){this.removeEventListener(u.type,u.listener,u.options),this.addEventListener(u.type,u.listener=f,u.options=o),u.value=l;return}}this.addEventListener(n.type,f,o),u={type:n.type,name:n.name,value:l,listener:f,options:o},r?r.push(u):this.__on=[u]}}function s_(n,l,o){var r=o_(n+""),u,f=r.length,d;if(arguments.length<2){var h=this.node().__on;if(h){for(var y=0,g=h.length,b;y<g;++y)for(u=0,b=h[y];u<f;++u)if((d=r[u]).type===b.type&&d.name===b.name)return b.value}return}for(h=l?u_:r_,u=0;u<f;++u)this.each(h(r[u],l,o));return this}function Om(n,l,o){var r=zm(n),u=r.CustomEvent;typeof u=="function"?u=new u(l,o):(u=r.document.createEvent("Event"),o?(u.initEvent(l,o.bubbles,o.cancelable),u.detail=o.detail):u.initEvent(l,!1,!1)),n.dispatchEvent(u)}function c_(n,l){return function(){return Om(this,n,l)}}function f_(n,l){return function(){return Om(this,n,l.apply(this,arguments))}}function d_(n,l){return this.each((typeof l=="function"?f_:c_)(n,l))}function*h_(){for(var n=this._groups,l=0,o=n.length;l<o;++l)for(var r=n[l],u=0,f=r.length,d;u<f;++u)(d=r[u])&&(yield d)}var Hm=[null];function Vt(n,l){this._groups=n,this._parents=l}function Co(){return new Vt([[document.documentElement]],Hm)}function g_(){return this}Vt.prototype=Co.prototype={constructor:Vt,select:Gx,selectAll:Xx,selectChild:Kx,selectChildren:Fx,filter:Px,data:i1,enter:e1,exit:r1,join:u1,merge:s1,selection:g_,order:c1,sort:f1,call:h1,nodes:g1,node:y1,size:m1,empty:p1,each:v1,attr:N1,style:M1,property:R1,classed:B1,text:Y1,html:Q1,raise:Z1,lower:J1,append:I1,insert:F1,remove:e_,clone:a_,datum:l_,on:s_,dispatch:d_,[Symbol.iterator]:h_};function Yt(n){return typeof n=="string"?new Vt([[document.querySelector(n)]],[document.documentElement]):new Vt([[n]],Hm)}function y_(n){let l;for(;l=n.sourceEvent;)n=l;return n}function rn(n,l){if(n=y_(n),l===void 0&&(l=n.currentTarget),l){var o=l.ownerSVGElement||l;if(o.createSVGPoint){var r=o.createSVGPoint();return r.x=n.clientX,r.y=n.clientY,r=r.matrixTransform(l.getScreenCTM().inverse()),[r.x,r.y]}if(l.getBoundingClientRect){var u=l.getBoundingClientRect();return[n.clientX-u.left-l.clientLeft,n.clientY-u.top-l.clientTop]}}return[n.pageX,n.pageY]}const m_={passive:!1},po={capture:!0,passive:!1};function cf(n){n.stopImmediatePropagation()}function ti(n){n.preventDefault(),n.stopImmediatePropagation()}function Bm(n){var l=n.document.documentElement,o=Yt(n).on("dragstart.drag",ti,po);"onselectstart"in l?o.on("selectstart.drag",ti,po):(l.__noselect=l.style.MozUserSelect,l.style.MozUserSelect="none")}function Lm(n,l){var o=n.document.documentElement,r=Yt(n).on("dragstart.drag",null);l&&(r.on("click.drag",ti,po),setTimeout(function(){r.on("click.drag",null)},0)),"onselectstart"in o?r.on("selectstart.drag",null):(o.style.MozUserSelect=o.__noselect,delete o.__noselect)}const lu=n=>()=>n;function Mf(n,{sourceEvent:l,subject:o,target:r,identifier:u,active:f,x:d,y:h,dx:y,dy:g,dispatch:b}){Object.defineProperties(this,{type:{value:n,enumerable:!0,configurable:!0},sourceEvent:{value:l,enumerable:!0,configurable:!0},subject:{value:o,enumerable:!0,configurable:!0},target:{value:r,enumerable:!0,configurable:!0},identifier:{value:u,enumerable:!0,configurable:!0},active:{value:f,enumerable:!0,configurable:!0},x:{value:d,enumerable:!0,configurable:!0},y:{value:h,enumerable:!0,configurable:!0},dx:{value:y,enumerable:!0,configurable:!0},dy:{value:g,enumerable:!0,configurable:!0},_:{value:b}})}Mf.prototype.on=function(){var n=this._.on.apply(this._,arguments);return n===this._?this:n};function p_(n){return!n.ctrlKey&&!n.button}function v_(){return this.parentNode}function b_(n,l){return l??{x:n.x,y:n.y}}function x_(){return navigator.maxTouchPoints||"ontouchstart"in this}function Um(){var n=p_,l=v_,o=b_,r=x_,u={},f=Du("start","drag","end"),d=0,h,y,g,b,p=0;function v(z){z.on("mousedown.drag",x).filter(r).on("touchstart.drag",M).on("touchmove.drag",E,m_).on("touchend.drag touchcancel.drag",H).style("touch-action","none").style("-webkit-tap-highlight-color","rgba(0,0,0,0)")}function x(z,G){if(!(b||!n.call(this,z,G))){var B=w(this,l.call(this,z,G),z,G,"mouse");B&&(Yt(z.view).on("mousemove.drag",_,po).on("mouseup.drag",C,po),Bm(z.view),cf(z),g=!1,h=z.clientX,y=z.clientY,B("start",z))}}function _(z){if(ti(z),!g){var G=z.clientX-h,B=z.clientY-y;g=G*G+B*B>p}u.mouse("drag",z)}function C(z){Yt(z.view).on("mousemove.drag mouseup.drag",null),Lm(z.view,g),ti(z),u.mouse("end",z)}function M(z,G){if(n.call(this,z,G)){var B=z.changedTouches,L=l.call(this,z,G),Q=B.length,K,ue;for(K=0;K<Q;++K)(ue=w(this,L,z,G,B[K].identifier,B[K]))&&(cf(z),ue("start",z,B[K]))}}function E(z){var G=z.changedTouches,B=G.length,L,Q;for(L=0;L<B;++L)(Q=u[G[L].identifier])&&(ti(z),Q("drag",z,G[L]))}function H(z){var G=z.changedTouches,B=G.length,L,Q;for(b&&clearTimeout(b),b=setTimeout(function(){b=null},500),L=0;L<B;++L)(Q=u[G[L].identifier])&&(cf(z),Q("end",z,G[L]))}function w(z,G,B,L,Q,K){var ue=f.copy(),$=rn(K||B,G),ie,ne,D;if((D=o.call(z,new Mf("beforestart",{sourceEvent:B,target:v,identifier:Q,active:d,x:$[0],y:$[1],dx:0,dy:0,dispatch:ue}),L))!=null)return ie=D.x-$[0]||0,ne=D.y-$[1]||0,function q(A,j,V){var k=$,Z;switch(A){case"start":u[Q]=q,Z=d++;break;case"end":delete u[Q],--d;case"drag":$=rn(V||j,G),Z=d;break}ue.call(A,z,new Mf(A,{sourceEvent:j,subject:D,target:v,identifier:Q,active:Z,x:$[0]+ie,y:$[1]+ne,dx:$[0]-k[0],dy:$[1]-k[1],dispatch:ue}),L)}}return v.filter=function(z){return arguments.length?(n=typeof z=="function"?z:lu(!!z),v):n},v.container=function(z){return arguments.length?(l=typeof z=="function"?z:lu(z),v):l},v.subject=function(z){return arguments.length?(o=typeof z=="function"?z:lu(z),v):o},v.touchable=function(z){return arguments.length?(r=typeof z=="function"?z:lu(!!z),v):r},v.on=function(){var z=f.on.apply(f,arguments);return z===f?v:z},v.clickDistance=function(z){return arguments.length?(p=(z=+z)*z,v):Math.sqrt(p)},v}function Pf(n,l,o){n.prototype=l.prototype=o,o.constructor=n}function Gm(n,l){var o=Object.create(n.prototype);for(var r in l)o[r]=l[r];return o}function Mo(){}var vo=.7,xu=1/vo,ni="\\s*([+-]?\\d+)\\s*",bo="\\s*([+-]?(?:\\d*\\.)?\\d+(?:[eE][+-]?\\d+)?)\\s*",_n="\\s*([+-]?(?:\\d*\\.)?\\d+(?:[eE][+-]?\\d+)?)%\\s*",__=/^#([0-9a-f]{3,8})$/,w_=new RegExp(`^rgb\\(${ni},${ni},${ni}\\)$`),S_=new RegExp(`^rgb\\(${_n},${_n},${_n}\\)$`),E_=new RegExp(`^rgba\\(${ni},${ni},${ni},${bo}\\)$`),N_=new RegExp(`^rgba\\(${_n},${_n},${_n},${bo}\\)$`),T_=new RegExp(`^hsl\\(${bo},${_n},${_n}\\)$`),A_=new RegExp(`^hsla\\(${bo},${_n},${_n},${bo}\\)$`),sy={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};Pf(Mo,el,{copy(n){return Object.assign(new this.constructor,this,n)},displayable(){return this.rgb().displayable()},hex:cy,formatHex:cy,formatHex8:C_,formatHsl:M_,formatRgb:fy,toString:fy});function cy(){return this.rgb().formatHex()}function C_(){return this.rgb().formatHex8()}function M_(){return Ym(this).formatHsl()}function fy(){return this.rgb().formatRgb()}function el(n){var l,o;return n=(n+"").trim().toLowerCase(),(l=__.exec(n))?(o=l[1].length,l=parseInt(l[1],16),o===6?dy(l):o===3?new Dt(l>>8&15|l>>4&240,l>>4&15|l&240,(l&15)<<4|l&15,1):o===8?iu(l>>24&255,l>>16&255,l>>8&255,(l&255)/255):o===4?iu(l>>12&15|l>>8&240,l>>8&15|l>>4&240,l>>4&15|l&240,((l&15)<<4|l&15)/255):null):(l=w_.exec(n))?new Dt(l[1],l[2],l[3],1):(l=S_.exec(n))?new Dt(l[1]*255/100,l[2]*255/100,l[3]*255/100,1):(l=E_.exec(n))?iu(l[1],l[2],l[3],l[4]):(l=N_.exec(n))?iu(l[1]*255/100,l[2]*255/100,l[3]*255/100,l[4]):(l=T_.exec(n))?yy(l[1],l[2]/100,l[3]/100,1):(l=A_.exec(n))?yy(l[1],l[2]/100,l[3]/100,l[4]):sy.hasOwnProperty(n)?dy(sy[n]):n==="transparent"?new Dt(NaN,NaN,NaN,0):null}function dy(n){return new Dt(n>>16&255,n>>8&255,n&255,1)}function iu(n,l,o,r){return r<=0&&(n=l=o=NaN),new Dt(n,l,o,r)}function z_(n){return n instanceof Mo||(n=el(n)),n?(n=n.rgb(),new Dt(n.r,n.g,n.b,n.opacity)):new Dt}function zf(n,l,o,r){return arguments.length===1?z_(n):new Dt(n,l,o,r??1)}function Dt(n,l,o,r){this.r=+n,this.g=+l,this.b=+o,this.opacity=+r}Pf(Dt,zf,Gm(Mo,{brighter(n){return n=n==null?xu:Math.pow(xu,n),new Dt(this.r*n,this.g*n,this.b*n,this.opacity)},darker(n){return n=n==null?vo:Math.pow(vo,n),new Dt(this.r*n,this.g*n,this.b*n,this.opacity)},rgb(){return this},clamp(){return new Dt(Fa(this.r),Fa(this.g),Fa(this.b),_u(this.opacity))},displayable(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:hy,formatHex:hy,formatHex8:D_,formatRgb:gy,toString:gy}));function hy(){return`#${Wa(this.r)}${Wa(this.g)}${Wa(this.b)}`}function D_(){return`#${Wa(this.r)}${Wa(this.g)}${Wa(this.b)}${Wa((isNaN(this.opacity)?1:this.opacity)*255)}`}function gy(){const n=_u(this.opacity);return`${n===1?"rgb(":"rgba("}${Fa(this.r)}, ${Fa(this.g)}, ${Fa(this.b)}${n===1?")":`, ${n})`}`}function _u(n){return isNaN(n)?1:Math.max(0,Math.min(1,n))}function Fa(n){return Math.max(0,Math.min(255,Math.round(n)||0))}function Wa(n){return n=Fa(n),(n<16?"0":"")+n.toString(16)}function yy(n,l,o,r){return r<=0?n=l=o=NaN:o<=0||o>=1?n=l=NaN:l<=0&&(n=NaN),new un(n,l,o,r)}function Ym(n){if(n instanceof un)return new un(n.h,n.s,n.l,n.opacity);if(n instanceof Mo||(n=el(n)),!n)return new un;if(n instanceof un)return n;n=n.rgb();var l=n.r/255,o=n.g/255,r=n.b/255,u=Math.min(l,o,r),f=Math.max(l,o,r),d=NaN,h=f-u,y=(f+u)/2;return h?(l===f?d=(o-r)/h+(o<r)*6:o===f?d=(r-l)/h+2:d=(l-o)/h+4,h/=y<.5?f+u:2-f-u,d*=60):h=y>0&&y<1?0:d,new un(d,h,y,n.opacity)}function k_(n,l,o,r){return arguments.length===1?Ym(n):new un(n,l,o,r??1)}function un(n,l,o,r){this.h=+n,this.s=+l,this.l=+o,this.opacity=+r}Pf(un,k_,Gm(Mo,{brighter(n){return n=n==null?xu:Math.pow(xu,n),new un(this.h,this.s,this.l*n,this.opacity)},darker(n){return n=n==null?vo:Math.pow(vo,n),new un(this.h,this.s,this.l*n,this.opacity)},rgb(){var n=this.h%360+(this.h<0)*360,l=isNaN(n)||isNaN(this.s)?0:this.s,o=this.l,r=o+(o<.5?o:1-o)*l,u=2*o-r;return new Dt(ff(n>=240?n-240:n+120,u,r),ff(n,u,r),ff(n<120?n+240:n-120,u,r),this.opacity)},clamp(){return new un(my(this.h),ou(this.s),ou(this.l),_u(this.opacity))},displayable(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl(){const n=_u(this.opacity);return`${n===1?"hsl(":"hsla("}${my(this.h)}, ${ou(this.s)*100}%, ${ou(this.l)*100}%${n===1?")":`, ${n})`}`}}));function my(n){return n=(n||0)%360,n<0?n+360:n}function ou(n){return Math.max(0,Math.min(1,n||0))}function ff(n,l,o){return(n<60?l+(o-l)*n/60:n<180?o:n<240?l+(o-l)*(240-n)/60:l)*255}const ed=n=>()=>n;function R_(n,l){return function(o){return n+o*l}}function j_(n,l,o){return n=Math.pow(n,o),l=Math.pow(l,o)-n,o=1/o,function(r){return Math.pow(n+r*l,o)}}function O_(n){return(n=+n)==1?Vm:function(l,o){return o-l?j_(l,o,n):ed(isNaN(l)?o:l)}}function Vm(n,l){var o=l-n;return o?R_(n,o):ed(isNaN(n)?l:n)}const wu=(function n(l){var o=O_(l);function r(u,f){var d=o((u=zf(u)).r,(f=zf(f)).r),h=o(u.g,f.g),y=o(u.b,f.b),g=Vm(u.opacity,f.opacity);return function(b){return u.r=d(b),u.g=h(b),u.b=y(b),u.opacity=g(b),u+""}}return r.gamma=n,r})(1);function H_(n,l){l||(l=[]);var o=n?Math.min(l.length,n.length):0,r=l.slice(),u;return function(f){for(u=0;u<o;++u)r[u]=n[u]*(1-f)+l[u]*f;return r}}function B_(n){return ArrayBuffer.isView(n)&&!(n instanceof DataView)}function L_(n,l){var o=l?l.length:0,r=n?Math.min(o,n.length):0,u=new Array(r),f=new Array(o),d;for(d=0;d<r;++d)u[d]=yo(n[d],l[d]);for(;d<o;++d)f[d]=l[d];return function(h){for(d=0;d<r;++d)f[d]=u[d](h);return f}}function U_(n,l){var o=new Date;return n=+n,l=+l,function(r){return o.setTime(n*(1-r)+l*r),o}}function xn(n,l){return n=+n,l=+l,function(o){return n*(1-o)+l*o}}function G_(n,l){var o={},r={},u;(n===null||typeof n!="object")&&(n={}),(l===null||typeof l!="object")&&(l={});for(u in l)u in n?o[u]=yo(n[u],l[u]):r[u]=l[u];return function(f){for(u in o)r[u]=o[u](f);return r}}var Df=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,df=new RegExp(Df.source,"g");function Y_(n){return function(){return n}}function V_(n){return function(l){return n(l)+""}}function qm(n,l){var o=Df.lastIndex=df.lastIndex=0,r,u,f,d=-1,h=[],y=[];for(n=n+"",l=l+"";(r=Df.exec(n))&&(u=df.exec(l));)(f=u.index)>o&&(f=l.slice(o,f),h[d]?h[d]+=f:h[++d]=f),(r=r[0])===(u=u[0])?h[d]?h[d]+=u:h[++d]=u:(h[++d]=null,y.push({i:d,x:xn(r,u)})),o=df.lastIndex;return o<l.length&&(f=l.slice(o),h[d]?h[d]+=f:h[++d]=f),h.length<2?y[0]?V_(y[0].x):Y_(l):(l=y.length,function(g){for(var b=0,p;b<l;++b)h[(p=y[b]).i]=p.x(g);return h.join("")})}function yo(n,l){var o=typeof l,r;return l==null||o==="boolean"?ed(l):(o==="number"?xn:o==="string"?(r=el(l))?(l=r,wu):qm:l instanceof el?wu:l instanceof Date?U_:B_(l)?H_:Array.isArray(l)?L_:typeof l.valueOf!="function"&&typeof l.toString!="function"||isNaN(l)?G_:xn)(n,l)}var py=180/Math.PI,kf={translateX:0,translateY:0,rotate:0,skewX:0,scaleX:1,scaleY:1};function Xm(n,l,o,r,u,f){var d,h,y;return(d=Math.sqrt(n*n+l*l))&&(n/=d,l/=d),(y=n*o+l*r)&&(o-=n*y,r-=l*y),(h=Math.sqrt(o*o+r*r))&&(o/=h,r/=h,y/=h),n*r<l*o&&(n=-n,l=-l,y=-y,d=-d),{translateX:u,translateY:f,rotate:Math.atan2(l,n)*py,skewX:Math.atan(y)*py,scaleX:d,scaleY:h}}var ru;function q_(n){const l=new(typeof DOMMatrix=="function"?DOMMatrix:WebKitCSSMatrix)(n+"");return l.isIdentity?kf:Xm(l.a,l.b,l.c,l.d,l.e,l.f)}function X_(n){return n==null||(ru||(ru=document.createElementNS("http://www.w3.org/2000/svg","g")),ru.setAttribute("transform",n),!(n=ru.transform.baseVal.consolidate()))?kf:(n=n.matrix,Xm(n.a,n.b,n.c,n.d,n.e,n.f))}function Qm(n,l,o,r){function u(g){return g.length?g.pop()+" ":""}function f(g,b,p,v,x,_){if(g!==p||b!==v){var C=x.push("translate(",null,l,null,o);_.push({i:C-4,x:xn(g,p)},{i:C-2,x:xn(b,v)})}else(p||v)&&x.push("translate("+p+l+v+o)}function d(g,b,p,v){g!==b?(g-b>180?b+=360:b-g>180&&(g+=360),v.push({i:p.push(u(p)+"rotate(",null,r)-2,x:xn(g,b)})):b&&p.push(u(p)+"rotate("+b+r)}function h(g,b,p,v){g!==b?v.push({i:p.push(u(p)+"skewX(",null,r)-2,x:xn(g,b)}):b&&p.push(u(p)+"skewX("+b+r)}function y(g,b,p,v,x,_){if(g!==p||b!==v){var C=x.push(u(x)+"scale(",null,",",null,")");_.push({i:C-4,x:xn(g,p)},{i:C-2,x:xn(b,v)})}else(p!==1||v!==1)&&x.push(u(x)+"scale("+p+","+v+")")}return function(g,b){var p=[],v=[];return g=n(g),b=n(b),f(g.translateX,g.translateY,b.translateX,b.translateY,p,v),d(g.rotate,b.rotate,p,v),h(g.skewX,b.skewX,p,v),y(g.scaleX,g.scaleY,b.scaleX,b.scaleY,p,v),g=b=null,function(x){for(var _=-1,C=v.length,M;++_<C;)p[(M=v[_]).i]=M.x(x);return p.join("")}}}var Q_=Qm(q_,"px, ","px)","deg)"),$_=Qm(X_,", ",")",")"),Z_=1e-12;function vy(n){return((n=Math.exp(n))+1/n)/2}function K_(n){return((n=Math.exp(n))-1/n)/2}function J_(n){return((n=Math.exp(2*n))-1)/(n+1)}const yu=(function n(l,o,r){function u(f,d){var h=f[0],y=f[1],g=f[2],b=d[0],p=d[1],v=d[2],x=b-h,_=p-y,C=x*x+_*_,M,E;if(C<Z_)E=Math.log(v/g)/l,M=function(L){return[h+L*x,y+L*_,g*Math.exp(l*L*E)]};else{var H=Math.sqrt(C),w=(v*v-g*g+r*C)/(2*g*o*H),z=(v*v-g*g-r*C)/(2*v*o*H),G=Math.log(Math.sqrt(w*w+1)-w),B=Math.log(Math.sqrt(z*z+1)-z);E=(B-G)/l,M=function(L){var Q=L*E,K=vy(G),ue=g/(o*H)*(K*J_(l*Q+G)-K_(G));return[h+ue*x,y+ue*_,g*K/vy(l*Q+G)]}}return M.duration=E*1e3*l/Math.SQRT2,M}return u.rho=function(f){var d=Math.max(.001,+f),h=d*d,y=h*h;return n(d,h,y)},u})(Math.SQRT2,2,4);var li=0,ho=0,so=0,$m=1e3,Su,go,Eu=0,tl=0,Ru=0,xo=typeof performance=="object"&&performance.now?performance:Date,Zm=typeof window=="object"&&window.requestAnimationFrame?window.requestAnimationFrame.bind(window):function(n){setTimeout(n,17)};function td(){return tl||(Zm(I_),tl=xo.now()+Ru)}function I_(){tl=0}function Nu(){this._call=this._time=this._next=null}Nu.prototype=Km.prototype={constructor:Nu,restart:function(n,l,o){if(typeof n!="function")throw new TypeError("callback is not a function");o=(o==null?td():+o)+(l==null?0:+l),!this._next&&go!==this&&(go?go._next=this:Su=this,go=this),this._call=n,this._time=o,Rf()},stop:function(){this._call&&(this._call=null,this._time=1/0,Rf())}};function Km(n,l,o){var r=new Nu;return r.restart(n,l,o),r}function W_(){td(),++li;for(var n=Su,l;n;)(l=tl-n._time)>=0&&n._call.call(void 0,l),n=n._next;--li}function by(){tl=(Eu=xo.now())+Ru,li=ho=0;try{W_()}finally{li=0,P_(),tl=0}}function F_(){var n=xo.now(),l=n-Eu;l>$m&&(Ru-=l,Eu=n)}function P_(){for(var n,l=Su,o,r=1/0;l;)l._call?(r>l._time&&(r=l._time),n=l,l=l._next):(o=l._next,l._next=null,l=n?n._next=o:Su=o);go=n,Rf(r)}function Rf(n){if(!li){ho&&(ho=clearTimeout(ho));var l=n-tl;l>24?(n<1/0&&(ho=setTimeout(by,n-xo.now()-Ru)),so&&(so=clearInterval(so))):(so||(Eu=xo.now(),so=setInterval(F_,$m)),li=1,Zm(by))}}function xy(n,l,o){var r=new Nu;return l=l==null?0:+l,r.restart(u=>{r.stop(),n(u+l)},l,o),r}var ew=Du("start","end","cancel","interrupt"),tw=[],Jm=0,_y=1,jf=2,mu=3,wy=4,Of=5,pu=6;function ju(n,l,o,r,u,f){var d=n.__transition;if(!d)n.__transition={};else if(o in d)return;nw(n,o,{name:l,index:r,group:u,on:ew,tween:tw,time:f.time,delay:f.delay,duration:f.duration,ease:f.ease,timer:null,state:Jm})}function nd(n,l){var o=dn(n,l);if(o.state>Jm)throw new Error("too late; already scheduled");return o}function wn(n,l){var o=dn(n,l);if(o.state>mu)throw new Error("too late; already running");return o}function dn(n,l){var o=n.__transition;if(!o||!(o=o[l]))throw new Error("transition not found");return o}function nw(n,l,o){var r=n.__transition,u;r[l]=o,o.timer=Km(f,0,o.time);function f(g){o.state=_y,o.timer.restart(d,o.delay,o.time),o.delay<=g&&d(g-o.delay)}function d(g){var b,p,v,x;if(o.state!==_y)return y();for(b in r)if(x=r[b],x.name===o.name){if(x.state===mu)return xy(d);x.state===wy?(x.state=pu,x.timer.stop(),x.on.call("interrupt",n,n.__data__,x.index,x.group),delete r[b]):+b<l&&(x.state=pu,x.timer.stop(),x.on.call("cancel",n,n.__data__,x.index,x.group),delete r[b])}if(xy(function(){o.state===mu&&(o.state=wy,o.timer.restart(h,o.delay,o.time),h(g))}),o.state=jf,o.on.call("start",n,n.__data__,o.index,o.group),o.state===jf){for(o.state=mu,u=new Array(v=o.tween.length),b=0,p=-1;b<v;++b)(x=o.tween[b].value.call(n,n.__data__,o.index,o.group))&&(u[++p]=x);u.length=p+1}}function h(g){for(var b=g<o.duration?o.ease.call(null,g/o.duration):(o.timer.restart(y),o.state=Of,1),p=-1,v=u.length;++p<v;)u[p].call(n,b);o.state===Of&&(o.on.call("end",n,n.__data__,o.index,o.group),y())}function y(){o.state=pu,o.timer.stop(),delete r[l];for(var g in r)return;delete n.__transition}}function vu(n,l){var o=n.__transition,r,u,f=!0,d;if(o){l=l==null?null:l+"";for(d in o){if((r=o[d]).name!==l){f=!1;continue}u=r.state>jf&&r.state<Of,r.state=pu,r.timer.stop(),r.on.call(u?"interrupt":"cancel",n,n.__data__,r.index,r.group),delete o[d]}f&&delete n.__transition}}function aw(n){return this.each(function(){vu(this,n)})}function lw(n,l){var o,r;return function(){var u=wn(this,n),f=u.tween;if(f!==o){r=o=f;for(var d=0,h=r.length;d<h;++d)if(r[d].name===l){r=r.slice(),r.splice(d,1);break}}u.tween=r}}function iw(n,l,o){var r,u;if(typeof o!="function")throw new Error;return function(){var f=wn(this,n),d=f.tween;if(d!==r){u=(r=d).slice();for(var h={name:l,value:o},y=0,g=u.length;y<g;++y)if(u[y].name===l){u[y]=h;break}y===g&&u.push(h)}f.tween=u}}function ow(n,l){var o=this._id;if(n+="",arguments.length<2){for(var r=dn(this.node(),o).tween,u=0,f=r.length,d;u<f;++u)if((d=r[u]).name===n)return d.value;return null}return this.each((l==null?lw:iw)(o,n,l))}function ad(n,l,o){var r=n._id;return n.each(function(){var u=wn(this,r);(u.value||(u.value={}))[l]=o.apply(this,arguments)}),function(u){return dn(u,r).value[l]}}function Im(n,l){var o;return(typeof l=="number"?xn:l instanceof el?wu:(o=el(l))?(l=o,wu):qm)(n,l)}function rw(n){return function(){this.removeAttribute(n)}}function uw(n){return function(){this.removeAttributeNS(n.space,n.local)}}function sw(n,l,o){var r,u=o+"",f;return function(){var d=this.getAttribute(n);return d===u?null:d===r?f:f=l(r=d,o)}}function cw(n,l,o){var r,u=o+"",f;return function(){var d=this.getAttributeNS(n.space,n.local);return d===u?null:d===r?f:f=l(r=d,o)}}function fw(n,l,o){var r,u,f;return function(){var d,h=o(this),y;return h==null?void this.removeAttribute(n):(d=this.getAttribute(n),y=h+"",d===y?null:d===r&&y===u?f:(u=y,f=l(r=d,h)))}}function dw(n,l,o){var r,u,f;return function(){var d,h=o(this),y;return h==null?void this.removeAttributeNS(n.space,n.local):(d=this.getAttributeNS(n.space,n.local),y=h+"",d===y?null:d===r&&y===u?f:(u=y,f=l(r=d,h)))}}function hw(n,l){var o=ku(n),r=o==="transform"?$_:Im;return this.attrTween(n,typeof l=="function"?(o.local?dw:fw)(o,r,ad(this,"attr."+n,l)):l==null?(o.local?uw:rw)(o):(o.local?cw:sw)(o,r,l))}function gw(n,l){return function(o){this.setAttribute(n,l.call(this,o))}}function yw(n,l){return function(o){this.setAttributeNS(n.space,n.local,l.call(this,o))}}function mw(n,l){var o,r;function u(){var f=l.apply(this,arguments);return f!==r&&(o=(r=f)&&yw(n,f)),o}return u._value=l,u}function pw(n,l){var o,r;function u(){var f=l.apply(this,arguments);return f!==r&&(o=(r=f)&&gw(n,f)),o}return u._value=l,u}function vw(n,l){var o="attr."+n;if(arguments.length<2)return(o=this.tween(o))&&o._value;if(l==null)return this.tween(o,null);if(typeof l!="function")throw new Error;var r=ku(n);return this.tween(o,(r.local?mw:pw)(r,l))}function bw(n,l){return function(){nd(this,n).delay=+l.apply(this,arguments)}}function xw(n,l){return l=+l,function(){nd(this,n).delay=l}}function _w(n){var l=this._id;return arguments.length?this.each((typeof n=="function"?bw:xw)(l,n)):dn(this.node(),l).delay}function ww(n,l){return function(){wn(this,n).duration=+l.apply(this,arguments)}}function Sw(n,l){return l=+l,function(){wn(this,n).duration=l}}function Ew(n){var l=this._id;return arguments.length?this.each((typeof n=="function"?ww:Sw)(l,n)):dn(this.node(),l).duration}function Nw(n,l){if(typeof l!="function")throw new Error;return function(){wn(this,n).ease=l}}function Tw(n){var l=this._id;return arguments.length?this.each(Nw(l,n)):dn(this.node(),l).ease}function Aw(n,l){return function(){var o=l.apply(this,arguments);if(typeof o!="function")throw new Error;wn(this,n).ease=o}}function Cw(n){if(typeof n!="function")throw new Error;return this.each(Aw(this._id,n))}function Mw(n){typeof n!="function"&&(n=Am(n));for(var l=this._groups,o=l.length,r=new Array(o),u=0;u<o;++u)for(var f=l[u],d=f.length,h=r[u]=[],y,g=0;g<d;++g)(y=f[g])&&n.call(y,y.__data__,g,f)&&h.push(y);return new Zn(r,this._parents,this._name,this._id)}function zw(n){if(n._id!==this._id)throw new Error;for(var l=this._groups,o=n._groups,r=l.length,u=o.length,f=Math.min(r,u),d=new Array(r),h=0;h<f;++h)for(var y=l[h],g=o[h],b=y.length,p=d[h]=new Array(b),v,x=0;x<b;++x)(v=y[x]||g[x])&&(p[x]=v);for(;h<r;++h)d[h]=l[h];return new Zn(d,this._parents,this._name,this._id)}function Dw(n){return(n+"").trim().split(/^|\s+/).every(function(l){var o=l.indexOf(".");return o>=0&&(l=l.slice(0,o)),!l||l==="start"})}function kw(n,l,o){var r,u,f=Dw(l)?nd:wn;return function(){var d=f(this,n),h=d.on;h!==r&&(u=(r=h).copy()).on(l,o),d.on=u}}function Rw(n,l){var o=this._id;return arguments.length<2?dn(this.node(),o).on.on(n):this.each(kw(o,n,l))}function jw(n){return function(){var l=this.parentNode;for(var o in this.__transition)if(+o!==n)return;l&&l.removeChild(this)}}function Ow(){return this.on("end.remove",jw(this._id))}function Hw(n){var l=this._name,o=this._id;typeof n!="function"&&(n=Wf(n));for(var r=this._groups,u=r.length,f=new Array(u),d=0;d<u;++d)for(var h=r[d],y=h.length,g=f[d]=new Array(y),b,p,v=0;v<y;++v)(b=h[v])&&(p=n.call(b,b.__data__,v,h))&&("__data__"in b&&(p.__data__=b.__data__),g[v]=p,ju(g[v],l,o,v,g,dn(b,o)));return new Zn(f,this._parents,l,o)}function Bw(n){var l=this._name,o=this._id;typeof n!="function"&&(n=Tm(n));for(var r=this._groups,u=r.length,f=[],d=[],h=0;h<u;++h)for(var y=r[h],g=y.length,b,p=0;p<g;++p)if(b=y[p]){for(var v=n.call(b,b.__data__,p,y),x,_=dn(b,o),C=0,M=v.length;C<M;++C)(x=v[C])&&ju(x,l,o,C,v,_);f.push(v),d.push(b)}return new Zn(f,d,l,o)}var Lw=Co.prototype.constructor;function Uw(){return new Lw(this._groups,this._parents)}function Gw(n,l){var o,r,u;return function(){var f=ai(this,n),d=(this.style.removeProperty(n),ai(this,n));return f===d?null:f===o&&d===r?u:u=l(o=f,r=d)}}function Wm(n){return function(){this.style.removeProperty(n)}}function Yw(n,l,o){var r,u=o+"",f;return function(){var d=ai(this,n);return d===u?null:d===r?f:f=l(r=d,o)}}function Vw(n,l,o){var r,u,f;return function(){var d=ai(this,n),h=o(this),y=h+"";return h==null&&(y=h=(this.style.removeProperty(n),ai(this,n))),d===y?null:d===r&&y===u?f:(u=y,f=l(r=d,h))}}function qw(n,l){var o,r,u,f="style."+l,d="end."+f,h;return function(){var y=wn(this,n),g=y.on,b=y.value[f]==null?h||(h=Wm(l)):void 0;(g!==o||u!==b)&&(r=(o=g).copy()).on(d,u=b),y.on=r}}function Xw(n,l,o){var r=(n+="")=="transform"?Q_:Im;return l==null?this.styleTween(n,Gw(n,r)).on("end.style."+n,Wm(n)):typeof l=="function"?this.styleTween(n,Vw(n,r,ad(this,"style."+n,l))).each(qw(this._id,n)):this.styleTween(n,Yw(n,r,l),o).on("end.style."+n,null)}function Qw(n,l,o){return function(r){this.style.setProperty(n,l.call(this,r),o)}}function $w(n,l,o){var r,u;function f(){var d=l.apply(this,arguments);return d!==u&&(r=(u=d)&&Qw(n,d,o)),r}return f._value=l,f}function Zw(n,l,o){var r="style."+(n+="");if(arguments.length<2)return(r=this.tween(r))&&r._value;if(l==null)return this.tween(r,null);if(typeof l!="function")throw new Error;return this.tween(r,$w(n,l,o??""))}function Kw(n){return function(){this.textContent=n}}function Jw(n){return function(){var l=n(this);this.textContent=l??""}}function Iw(n){return this.tween("text",typeof n=="function"?Jw(ad(this,"text",n)):Kw(n==null?"":n+""))}function Ww(n){return function(l){this.textContent=n.call(this,l)}}function Fw(n){var l,o;function r(){var u=n.apply(this,arguments);return u!==o&&(l=(o=u)&&Ww(u)),l}return r._value=n,r}function Pw(n){var l="text";if(arguments.length<1)return(l=this.tween(l))&&l._value;if(n==null)return this.tween(l,null);if(typeof n!="function")throw new Error;return this.tween(l,Fw(n))}function eS(){for(var n=this._name,l=this._id,o=Fm(),r=this._groups,u=r.length,f=0;f<u;++f)for(var d=r[f],h=d.length,y,g=0;g<h;++g)if(y=d[g]){var b=dn(y,l);ju(y,n,o,g,d,{time:b.time+b.delay+b.duration,delay:0,duration:b.duration,ease:b.ease})}return new Zn(r,this._parents,n,o)}function tS(){var n,l,o=this,r=o._id,u=o.size();return new Promise(function(f,d){var h={value:d},y={value:function(){--u===0&&f()}};o.each(function(){var g=wn(this,r),b=g.on;b!==n&&(l=(n=b).copy(),l._.cancel.push(h),l._.interrupt.push(h),l._.end.push(y)),g.on=l}),u===0&&f()})}var nS=0;function Zn(n,l,o,r){this._groups=n,this._parents=l,this._name=o,this._id=r}function Fm(){return++nS}var Qn=Co.prototype;Zn.prototype={constructor:Zn,select:Hw,selectAll:Bw,selectChild:Qn.selectChild,selectChildren:Qn.selectChildren,filter:Mw,merge:zw,selection:Uw,transition:eS,call:Qn.call,nodes:Qn.nodes,node:Qn.node,size:Qn.size,empty:Qn.empty,each:Qn.each,on:Rw,attr:hw,attrTween:vw,style:Xw,styleTween:Zw,text:Iw,textTween:Pw,remove:Ow,tween:ow,delay:_w,duration:Ew,ease:Tw,easeVarying:Cw,end:tS,[Symbol.iterator]:Qn[Symbol.iterator]};function aS(n){return((n*=2)<=1?n*n*n:(n-=2)*n*n+2)/2}var lS={time:null,delay:0,duration:250,ease:aS};function iS(n,l){for(var o;!(o=n.__transition)||!(o=o[l]);)if(!(n=n.parentNode))throw new Error(`transition ${l} not found`);return o}function oS(n){var l,o;n instanceof Zn?(l=n._id,n=n._name):(l=Fm(),(o=lS).time=td(),n=n==null?null:n+"");for(var r=this._groups,u=r.length,f=0;f<u;++f)for(var d=r[f],h=d.length,y,g=0;g<h;++g)(y=d[g])&&ju(y,n,l,g,d,o||iS(y,l));return new Zn(r,this._parents,n,l)}Co.prototype.interrupt=aw;Co.prototype.transition=oS;const uu=n=>()=>n;function rS(n,{sourceEvent:l,target:o,transform:r,dispatch:u}){Object.defineProperties(this,{type:{value:n,enumerable:!0,configurable:!0},sourceEvent:{value:l,enumerable:!0,configurable:!0},target:{value:o,enumerable:!0,configurable:!0},transform:{value:r,enumerable:!0,configurable:!0},_:{value:u}})}function $n(n,l,o){this.k=n,this.x=l,this.y=o}$n.prototype={constructor:$n,scale:function(n){return n===1?this:new $n(this.k*n,this.x,this.y)},translate:function(n,l){return n===0&l===0?this:new $n(this.k,this.x+this.k*n,this.y+this.k*l)},apply:function(n){return[n[0]*this.k+this.x,n[1]*this.k+this.y]},applyX:function(n){return n*this.k+this.x},applyY:function(n){return n*this.k+this.y},invert:function(n){return[(n[0]-this.x)/this.k,(n[1]-this.y)/this.k]},invertX:function(n){return(n-this.x)/this.k},invertY:function(n){return(n-this.y)/this.k},rescaleX:function(n){return n.copy().domain(n.range().map(this.invertX,this).map(n.invert,n))},rescaleY:function(n){return n.copy().domain(n.range().map(this.invertY,this).map(n.invert,n))},toString:function(){return"translate("+this.x+","+this.y+") scale("+this.k+")"}};var Ou=new $n(1,0,0);Pm.prototype=$n.prototype;function Pm(n){for(;!n.__zoom;)if(!(n=n.parentNode))return Ou;return n.__zoom}function hf(n){n.stopImmediatePropagation()}function co(n){n.preventDefault(),n.stopImmediatePropagation()}function uS(n){return(!n.ctrlKey||n.type==="wheel")&&!n.button}function sS(){var n=this;return n instanceof SVGElement?(n=n.ownerSVGElement||n,n.hasAttribute("viewBox")?(n=n.viewBox.baseVal,[[n.x,n.y],[n.x+n.width,n.y+n.height]]):[[0,0],[n.width.baseVal.value,n.height.baseVal.value]]):[[0,0],[n.clientWidth,n.clientHeight]]}function Sy(){return this.__zoom||Ou}function cS(n){return-n.deltaY*(n.deltaMode===1?.05:n.deltaMode?1:.002)*(n.ctrlKey?10:1)}function fS(){return navigator.maxTouchPoints||"ontouchstart"in this}function dS(n,l,o){var r=n.invertX(l[0][0])-o[0][0],u=n.invertX(l[1][0])-o[1][0],f=n.invertY(l[0][1])-o[0][1],d=n.invertY(l[1][1])-o[1][1];return n.translate(u>r?(r+u)/2:Math.min(0,r)||Math.max(0,u),d>f?(f+d)/2:Math.min(0,f)||Math.max(0,d))}function ep(){var n=uS,l=sS,o=dS,r=cS,u=fS,f=[0,1/0],d=[[-1/0,-1/0],[1/0,1/0]],h=250,y=yu,g=Du("start","zoom","end"),b,p,v,x=500,_=150,C=0,M=10;function E(D){D.property("__zoom",Sy).on("wheel.zoom",Q,{passive:!1}).on("mousedown.zoom",K).on("dblclick.zoom",ue).filter(u).on("touchstart.zoom",$).on("touchmove.zoom",ie).on("touchend.zoom touchcancel.zoom",ne).style("-webkit-tap-highlight-color","rgba(0,0,0,0)")}E.transform=function(D,q,A,j){var V=D.selection?D.selection():D;V.property("__zoom",Sy),D!==V?G(D,q,A,j):V.interrupt().each(function(){B(this,arguments).event(j).start().zoom(null,typeof q=="function"?q.apply(this,arguments):q).end()})},E.scaleBy=function(D,q,A,j){E.scaleTo(D,function(){var V=this.__zoom.k,k=typeof q=="function"?q.apply(this,arguments):q;return V*k},A,j)},E.scaleTo=function(D,q,A,j){E.transform(D,function(){var V=l.apply(this,arguments),k=this.__zoom,Z=A==null?z(V):typeof A=="function"?A.apply(this,arguments):A,N=k.invert(Z),R=typeof q=="function"?q.apply(this,arguments):q;return o(w(H(k,R),Z,N),V,d)},A,j)},E.translateBy=function(D,q,A,j){E.transform(D,function(){return o(this.__zoom.translate(typeof q=="function"?q.apply(this,arguments):q,typeof A=="function"?A.apply(this,arguments):A),l.apply(this,arguments),d)},null,j)},E.translateTo=function(D,q,A,j,V){E.transform(D,function(){var k=l.apply(this,arguments),Z=this.__zoom,N=j==null?z(k):typeof j=="function"?j.apply(this,arguments):j;return o(Ou.translate(N[0],N[1]).scale(Z.k).translate(typeof q=="function"?-q.apply(this,arguments):-q,typeof A=="function"?-A.apply(this,arguments):-A),k,d)},j,V)};function H(D,q){return q=Math.max(f[0],Math.min(f[1],q)),q===D.k?D:new $n(q,D.x,D.y)}function w(D,q,A){var j=q[0]-A[0]*D.k,V=q[1]-A[1]*D.k;return j===D.x&&V===D.y?D:new $n(D.k,j,V)}function z(D){return[(+D[0][0]+ +D[1][0])/2,(+D[0][1]+ +D[1][1])/2]}function G(D,q,A,j){D.on("start.zoom",function(){B(this,arguments).event(j).start()}).on("interrupt.zoom end.zoom",function(){B(this,arguments).event(j).end()}).tween("zoom",function(){var V=this,k=arguments,Z=B(V,k).event(j),N=l.apply(V,k),R=A==null?z(N):typeof A=="function"?A.apply(V,k):A,ee=Math.max(N[1][0]-N[0][0],N[1][1]-N[0][1]),ae=V.__zoom,de=typeof q=="function"?q.apply(V,k):q,se=y(ae.invert(R).concat(ee/ae.k),de.invert(R).concat(ee/de.k));return function(oe){if(oe===1)oe=de;else{var P=se(oe),Y=ee/P[2];oe=new $n(Y,R[0]-P[0]*Y,R[1]-P[1]*Y)}Z.zoom(null,oe)}})}function B(D,q,A){return!A&&D.__zooming||new L(D,q)}function L(D,q){this.that=D,this.args=q,this.active=0,this.sourceEvent=null,this.extent=l.apply(D,q),this.taps=0}L.prototype={event:function(D){return D&&(this.sourceEvent=D),this},start:function(){return++this.active===1&&(this.that.__zooming=this,this.emit("start")),this},zoom:function(D,q){return this.mouse&&D!=="mouse"&&(this.mouse[1]=q.invert(this.mouse[0])),this.touch0&&D!=="touch"&&(this.touch0[1]=q.invert(this.touch0[0])),this.touch1&&D!=="touch"&&(this.touch1[1]=q.invert(this.touch1[0])),this.that.__zoom=q,this.emit("zoom"),this},end:function(){return--this.active===0&&(delete this.that.__zooming,this.emit("end")),this},emit:function(D){var q=Yt(this.that).datum();g.call(D,this.that,new rS(D,{sourceEvent:this.sourceEvent,target:E,transform:this.that.__zoom,dispatch:g}),q)}};function Q(D,...q){if(!n.apply(this,arguments))return;var A=B(this,q).event(D),j=this.__zoom,V=Math.max(f[0],Math.min(f[1],j.k*Math.pow(2,r.apply(this,arguments)))),k=rn(D);if(A.wheel)(A.mouse[0][0]!==k[0]||A.mouse[0][1]!==k[1])&&(A.mouse[1]=j.invert(A.mouse[0]=k)),clearTimeout(A.wheel);else{if(j.k===V)return;A.mouse=[k,j.invert(k)],vu(this),A.start()}co(D),A.wheel=setTimeout(Z,_),A.zoom("mouse",o(w(H(j,V),A.mouse[0],A.mouse[1]),A.extent,d));function Z(){A.wheel=null,A.end()}}function K(D,...q){if(v||!n.apply(this,arguments))return;var A=D.currentTarget,j=B(this,q,!0).event(D),V=Yt(D.view).on("mousemove.zoom",R,!0).on("mouseup.zoom",ee,!0),k=rn(D,A),Z=D.clientX,N=D.clientY;Bm(D.view),hf(D),j.mouse=[k,this.__zoom.invert(k)],vu(this),j.start();function R(ae){if(co(ae),!j.moved){var de=ae.clientX-Z,se=ae.clientY-N;j.moved=de*de+se*se>C}j.event(ae).zoom("mouse",o(w(j.that.__zoom,j.mouse[0]=rn(ae,A),j.mouse[1]),j.extent,d))}function ee(ae){V.on("mousemove.zoom mouseup.zoom",null),Lm(ae.view,j.moved),co(ae),j.event(ae).end()}}function ue(D,...q){if(n.apply(this,arguments)){var A=this.__zoom,j=rn(D.changedTouches?D.changedTouches[0]:D,this),V=A.invert(j),k=A.k*(D.shiftKey?.5:2),Z=o(w(H(A,k),j,V),l.apply(this,q),d);co(D),h>0?Yt(this).transition().duration(h).call(G,Z,j,D):Yt(this).call(E.transform,Z,j,D)}}function $(D,...q){if(n.apply(this,arguments)){var A=D.touches,j=A.length,V=B(this,q,D.changedTouches.length===j).event(D),k,Z,N,R;for(hf(D),Z=0;Z<j;++Z)N=A[Z],R=rn(N,this),R=[R,this.__zoom.invert(R),N.identifier],V.touch0?!V.touch1&&V.touch0[2]!==R[2]&&(V.touch1=R,V.taps=0):(V.touch0=R,k=!0,V.taps=1+!!b);b&&(b=clearTimeout(b)),k&&(V.taps<2&&(p=R[0],b=setTimeout(function(){b=null},x)),vu(this),V.start())}}function ie(D,...q){if(this.__zooming){var A=B(this,q).event(D),j=D.changedTouches,V=j.length,k,Z,N,R;for(co(D),k=0;k<V;++k)Z=j[k],N=rn(Z,this),A.touch0&&A.touch0[2]===Z.identifier?A.touch0[0]=N:A.touch1&&A.touch1[2]===Z.identifier&&(A.touch1[0]=N);if(Z=A.that.__zoom,A.touch1){var ee=A.touch0[0],ae=A.touch0[1],de=A.touch1[0],se=A.touch1[1],oe=(oe=de[0]-ee[0])*oe+(oe=de[1]-ee[1])*oe,P=(P=se[0]-ae[0])*P+(P=se[1]-ae[1])*P;Z=H(Z,Math.sqrt(oe/P)),N=[(ee[0]+de[0])/2,(ee[1]+de[1])/2],R=[(ae[0]+se[0])/2,(ae[1]+se[1])/2]}else if(A.touch0)N=A.touch0[0],R=A.touch0[1];else return;A.zoom("touch",o(w(Z,N,R),A.extent,d))}}function ne(D,...q){if(this.__zooming){var A=B(this,q).event(D),j=D.changedTouches,V=j.length,k,Z;for(hf(D),v&&clearTimeout(v),v=setTimeout(function(){v=null},x),k=0;k<V;++k)Z=j[k],A.touch0&&A.touch0[2]===Z.identifier?delete A.touch0:A.touch1&&A.touch1[2]===Z.identifier&&delete A.touch1;if(A.touch1&&!A.touch0&&(A.touch0=A.touch1,delete A.touch1),A.touch0)A.touch0[1]=this.__zoom.invert(A.touch0[0]);else if(A.end(),A.taps===2&&(Z=rn(Z,this),Math.hypot(p[0]-Z[0],p[1]-Z[1])<M)){var N=Yt(this).on("dblclick.zoom");N&&N.apply(this,arguments)}}}return E.wheelDelta=function(D){return arguments.length?(r=typeof D=="function"?D:uu(+D),E):r},E.filter=function(D){return arguments.length?(n=typeof D=="function"?D:uu(!!D),E):n},E.touchable=function(D){return arguments.length?(u=typeof D=="function"?D:uu(!!D),E):u},E.extent=function(D){return arguments.length?(l=typeof D=="function"?D:uu([[+D[0][0],+D[0][1]],[+D[1][0],+D[1][1]]]),E):l},E.scaleExtent=function(D){return arguments.length?(f[0]=+D[0],f[1]=+D[1],E):[f[0],f[1]]},E.translateExtent=function(D){return arguments.length?(d[0][0]=+D[0][0],d[1][0]=+D[1][0],d[0][1]=+D[0][1],d[1][1]=+D[1][1],E):[[d[0][0],d[0][1]],[d[1][0],d[1][1]]]},E.constrain=function(D){return arguments.length?(o=D,E):o},E.duration=function(D){return arguments.length?(h=+D,E):h},E.interpolate=function(D){return arguments.length?(y=D,E):y},E.on=function(){var D=g.on.apply(g,arguments);return D===g?E:D},E.clickDistance=function(D){return arguments.length?(C=(D=+D)*D,E):Math.sqrt(C)},E.tapDistance=function(D){return arguments.length?(M=+D,E):M},E}const fn={error001:(n="react")=>`Seems like you have not used ${n==="svelte"?"SvelteFlowProvider":"ReactFlowProvider"} as an ancestor. Help: https://${n}flow.dev/error#001`,error002:()=>"It looks like you've created a new nodeTypes or edgeTypes object. If this wasn't on purpose please define the nodeTypes/edgeTypes outside of the component or memoize them.",error003:n=>`Node type "${n}" not found. Using fallback type "default".`,error004:()=>"The parent container needs a width and a height to render the graph.",error005:()=>"Only child nodes can use a parent extent.",error006:()=>"Can't create edge. An edge needs a source and a target.",error007:n=>`The old edge with id=${n} does not exist.`,error009:n=>`Marker type "${n}" doesn't exist.`,error008:(n,{id:l,sourceHandle:o,targetHandle:r})=>`Couldn't create edge for ${n} handle id: "${n==="source"?o:r}", edge id: ${l}.`,error010:()=>"Handle: No node id found. Make sure to only use a Handle inside a custom Node.",error011:n=>`Edge type "${n}" not found. Using fallback type "default".`,error012:n=>`Node with id "${n}" does not exist, it may have been removed. This can happen when a node is deleted before the "onNodeClick" handler is called.`,error013:(n="react")=>`It seems that you haven't loaded the styles. Please import '@xyflow/${n}/dist/style.css' or base.css to make sure everything is working properly.`,error014:()=>"useNodeConnections: No node ID found. Call useNodeConnections inside a custom Node or provide a node ID.",error015:()=>"It seems that you are trying to drag a node that is not initialized. Please use onNodesChange as explained in the docs.",error016:n=>`Edge with id "${n}" does not exist, it may have been removed. This can happen when an edge is deleted before the "onEdgeClick" handler is called.`},_o=[[Number.NEGATIVE_INFINITY,Number.NEGATIVE_INFINITY],[Number.POSITIVE_INFINITY,Number.POSITIVE_INFINITY]],tp=["Enter"," ","Escape"],np={"node.a11yDescription.default":"Press enter or space to select a node. Press delete to remove it and escape to cancel.","node.a11yDescription.keyboardDisabled":"Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.","node.a11yDescription.ariaLiveMessage":({direction:n,x:l,y:o})=>`Moved selected node ${n}. New position, x: ${l}, y: ${o}`,"edge.a11yDescription.default":"Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.","controls.ariaLabel":"Control Panel","controls.zoomIn.ariaLabel":"Zoom In","controls.zoomOut.ariaLabel":"Zoom Out","controls.fitView.ariaLabel":"Fit View","controls.interactive.ariaLabel":"Toggle Interactivity","minimap.ariaLabel":"Mini Map","handle.ariaLabel":"Handle"};var ii;(function(n){n.Strict="strict",n.Loose="loose"})(ii||(ii={}));var Pa;(function(n){n.Free="free",n.Vertical="vertical",n.Horizontal="horizontal"})(Pa||(Pa={}));var wo;(function(n){n.Partial="partial",n.Full="full"})(wo||(wo={}));const ap={inProgress:!1,isValid:null,from:null,fromHandle:null,fromPosition:null,fromNode:null,to:null,toHandle:null,toPosition:null,toNode:null,pointer:null};var Ta;(function(n){n.Bezier="default",n.Straight="straight",n.Step="step",n.SmoothStep="smoothstep",n.SimpleBezier="simplebezier"})(Ta||(Ta={}));var Tu;(function(n){n.Arrow="arrow",n.ArrowClosed="arrowclosed"})(Tu||(Tu={}));var ve;(function(n){n.Left="left",n.Top="top",n.Right="right",n.Bottom="bottom"})(ve||(ve={}));const Ey={[ve.Left]:ve.Right,[ve.Right]:ve.Left,[ve.Top]:ve.Bottom,[ve.Bottom]:ve.Top};function lp(n){return n===null?null:n?"valid":"invalid"}const ip=n=>!!n&&typeof n=="object"&&"id"in n&&"source"in n&&"target"in n,hS=n=>!!n&&typeof n=="object"&&"id"in n&&"position"in n&&!("source"in n)&&!("target"in n),ld=n=>!!n&&typeof n=="object"&&"id"in n&&"internals"in n&&!("source"in n)&&!("target"in n),zo=(n,l=[0,0])=>{const{width:o,height:r}=Sn(n),u=n.origin??l,f=o*u[0],d=r*u[1];return{x:n.position.x-f,y:n.position.y-d}},gS=(n,l={nodeOrigin:[0,0]})=>{if(n.length===0)return{x:0,y:0,width:0,height:0};const o=n.reduce((r,u)=>{const f=typeof u=="string";let d=!l.nodeLookup&&!f?u:void 0;l.nodeLookup&&(d=f?l.nodeLookup.get(u):ld(u)?u:l.nodeLookup.get(u.id));const h=d?Au(d,l.nodeOrigin):{x:0,y:0,x2:0,y2:0};return Hu(r,h)},{x:1/0,y:1/0,x2:-1/0,y2:-1/0});return Bu(o)},Do=(n,l={})=>{let o={x:1/0,y:1/0,x2:-1/0,y2:-1/0},r=!1;return n.forEach(u=>{(l.filter===void 0||l.filter(u))&&(o=Hu(o,Au(u)),r=!0)}),r?Bu(o):{x:0,y:0,width:0,height:0}},id=(n,l,[o,r,u]=[0,0,1],f=!1,d=!1)=>{const h=(l.x-o)/u,y=(l.y-r)/u,g=l.width/u,b=l.height/u,p=[];for(const v of n.values()){const{measured:x,selectable:_=!0,hidden:C=!1}=v;if(d&&!_||C)continue;const M=x.width??v.width??v.initialWidth??0,E=x.height??v.height??v.initialHeight??0,{x:H,y:w}=v.internals.positionAbsolute,z=sp(h,y,g,b,H,w,M,E),G=M*E,B=f&&z>0;(!v.internals.handleBounds||B||z>=G||v.dragging)&&p.push(v)}return p},yS=(n,l)=>{const o=new Set;return n.forEach(r=>{o.add(r.id)}),l.filter(r=>o.has(r.source)||o.has(r.target))};function mS(n,l){const o=new Map,r=l!=null&&l.nodes?new Set(l.nodes.map(u=>u.id)):null;return n.forEach(u=>{let f;if(l!=null&&l.includeHiddenNodes){const{width:d,height:h}=Sn(u);f=d>0&&h>0}else f=!!(u.measured.width&&u.measured.height&&!u.hidden);f&&(!r||r.has(u.id))&&o.set(u.id,u)}),o}async function pS({nodes:n,width:l,height:o,panZoom:r,minZoom:u,maxZoom:f},d){if(n.size===0)return!0;const h=mS(n,d),y=Do(h),g=rd(y,l,o,(d==null?void 0:d.minZoom)??u,(d==null?void 0:d.maxZoom)??f,(d==null?void 0:d.padding)??.1);return await r.setViewport(g,{duration:d==null?void 0:d.duration,ease:d==null?void 0:d.ease,interpolate:d==null?void 0:d.interpolate}),!0}function op({nodeId:n,nextPosition:l,nodeLookup:o,nodeOrigin:r=[0,0],nodeExtent:u,onError:f}){const d=o.get(n),h=d.parentId?o.get(d.parentId):void 0,{x:y,y:g}=h?h.internals.positionAbsolute:{x:0,y:0},b=d.origin??r;let p=d.extent||u;if(d.extent==="parent"&&!d.expandParent)if(!h)f==null||f("005",fn.error005());else{const x=h.measured.width,_=h.measured.height;x&&_&&(p=[[y,g],[y+x,g+_]])}else h&&al(d.extent)&&(p=[[d.extent[0][0]+y,d.extent[0][1]+g],[d.extent[1][0]+y,d.extent[1][1]+g]]);const v=al(p)?nl(l,p,d.measured):l;return(d.measured.width===void 0||d.measured.height===void 0)&&(f==null||f("015",fn.error015())),{position:{x:v.x-y+(d.measured.width??0)*b[0],y:v.y-g+(d.measured.height??0)*b[1]},positionAbsolute:v}}async function vS({nodesToRemove:n=[],edgesToRemove:l=[],nodes:o,edges:r,onBeforeDelete:u}){const f=new Set(n.map(v=>v.id)),d=[];for(const v of o){if(v.deletable===!1)continue;const x=f.has(v.id),_=!x&&v.parentId&&d.find(C=>C.id===v.parentId);(x||_)&&d.push(v)}const h=new Set(l.map(v=>v.id)),y=r.filter(v=>v.deletable!==!1),b=yS(d,y);for(const v of y)h.has(v.id)&&!b.find(_=>_.id===v.id)&&b.push(v);if(!u)return{edges:b,nodes:d};const p=await u({nodes:d,edges:b});return typeof p=="boolean"?p?{edges:b,nodes:d}:{edges:[],nodes:[]}:p}const oi=(n,l=0,o=1)=>Math.min(Math.max(n,l),o),nl=(n={x:0,y:0},l,o)=>({x:oi(n.x,l[0][0],l[1][0]-((o==null?void 0:o.width)??0)),y:oi(n.y,l[0][1],l[1][1]-((o==null?void 0:o.height)??0))});function rp(n,l,o){const{width:r,height:u}=Sn(o),{x:f,y:d}=o.internals.positionAbsolute;return nl(n,[[f,d],[f+r,d+u]],l)}const Ny=(n,l,o)=>n<l?oi(Math.abs(n-l),1,l)/l:n>o?-oi(Math.abs(n-o),1,l)/l:0,od=(n,l,o=15,r=40)=>{const u=Ny(n.x,r,l.width-r)*o,f=Ny(n.y,r,l.height-r)*o;return[u,f]},Hu=(n,l)=>({x:Math.min(n.x,l.x),y:Math.min(n.y,l.y),x2:Math.max(n.x2,l.x2),y2:Math.max(n.y2,l.y2)}),Hf=({x:n,y:l,width:o,height:r})=>({x:n,y:l,x2:n+o,y2:l+r}),Bu=({x:n,y:l,x2:o,y2:r})=>({x:n,y:l,width:o-n,height:r-l}),So=(n,l=[0,0])=>{var u,f;const{x:o,y:r}=ld(n)?n.internals.positionAbsolute:zo(n,l);return{x:o,y:r,width:((u=n.measured)==null?void 0:u.width)??n.width??n.initialWidth??0,height:((f=n.measured)==null?void 0:f.height)??n.height??n.initialHeight??0}},Au=(n,l=[0,0])=>{var u,f;const{x:o,y:r}=ld(n)?n.internals.positionAbsolute:zo(n,l);return{x:o,y:r,x2:o+(((u=n.measured)==null?void 0:u.width)??n.width??n.initialWidth??0),y2:r+(((f=n.measured)==null?void 0:f.height)??n.height??n.initialHeight??0)}},up=(n,l)=>Bu(Hu(Hf(n),Hf(l))),sp=(n,l,o,r,u,f,d,h)=>{const y=Math.max(0,Math.min(n+o,u+d)-Math.max(n,u)),g=Math.max(0,Math.min(l+r,f+h)-Math.max(l,f));return Math.ceil(y*g)},Cu=(n,l)=>sp(n.x,n.y,n.width,n.height,l.x,l.y,l.width,l.height),Ty=n=>sn(n.width)&&sn(n.height)&&sn(n.x)&&sn(n.y),sn=n=>!isNaN(n)&&isFinite(n),cp=(n,l)=>(o,r)=>{},ko=(n,l=[1,1])=>({x:l[0]*Math.round(n.x/l[0]),y:l[1]*Math.round(n.y/l[1])}),Ro=({x:n,y:l},[o,r,u],f=!1,d=[1,1])=>{const h={x:(n-o)/u,y:(l-r)/u};return f?ko(h,d):h},ri=({x:n,y:l},[o,r,u])=>({x:n*u+o,y:l*u+r});function Il(n,l){if(typeof n=="number")return Math.floor((l-l/(1+n))*.5);if(typeof n=="string"&&n.endsWith("px")){const o=parseFloat(n);if(!Number.isNaN(o))return Math.floor(o)}if(typeof n=="string"&&n.endsWith("%")){const o=parseFloat(n);if(!Number.isNaN(o))return Math.floor(l*o*.01)}return console.error(`The padding value "${n}" is invalid. Please provide a number or a string with a valid unit (px or %).`),0}function bS(n,l,o){if(typeof n=="string"||typeof n=="number"){const r=Il(n,o),u=Il(n,l);return{top:r,right:u,bottom:r,left:u,x:u*2,y:r*2}}if(typeof n=="object"){const r=Il(n.top??n.y??0,o),u=Il(n.bottom??n.y??0,o),f=Il(n.left??n.x??0,l),d=Il(n.right??n.x??0,l);return{top:r,right:d,bottom:u,left:f,x:f+d,y:r+u}}return{top:0,right:0,bottom:0,left:0,x:0,y:0}}function xS(n,l,o,r,u,f){const{x:d,y:h}=ri(n,[l,o,r]),{x:y,y:g}=ri({x:n.x+n.width,y:n.y+n.height},[l,o,r]),b=u-y,p=f-g;return{left:Math.floor(d),top:Math.floor(h),right:Math.floor(b),bottom:Math.floor(p)}}const rd=(n,l,o,r,u,f)=>{const d=bS(f,l,o),h=(l-d.x)/n.width,y=(o-d.y)/n.height,g=Math.min(h,y),b=oi(g,r,u),p=n.x+n.width/2,v=n.y+n.height/2,x=l/2-p*b,_=o/2-v*b,C=xS(n,x,_,b,l,o),M={left:Math.min(C.left-d.left,0),top:Math.min(C.top-d.top,0),right:Math.min(C.right-d.right,0),bottom:Math.min(C.bottom-d.bottom,0)};return{x:x-M.left+M.right,y:_-M.top+M.bottom,zoom:b}},Eo=()=>{var n;return typeof navigator<"u"&&((n=navigator==null?void 0:navigator.userAgent)==null?void 0:n.indexOf("Mac"))>=0};function al(n){return n!=null&&n!=="parent"}function Sn(n){var l,o;return{width:((l=n.measured)==null?void 0:l.width)??n.width??n.initialWidth??0,height:((o=n.measured)==null?void 0:o.height)??n.height??n.initialHeight??0}}function fp(n){var l,o;return(((l=n.measured)==null?void 0:l.width)??n.width??n.initialWidth)!==void 0&&(((o=n.measured)==null?void 0:o.height)??n.height??n.initialHeight)!==void 0}function dp(n,l={width:0,height:0},o,r,u){const f={...n},d=r.get(o);if(d){const h=d.origin||u;f.x+=d.internals.positionAbsolute.x-(l.width??0)*h[0],f.y+=d.internals.positionAbsolute.y-(l.height??0)*h[1]}return f}function Ay(n,l){if(n.size!==l.size)return!1;for(const o of n)if(!l.has(o))return!1;return!0}function _S(){let n,l;return{promise:new Promise((r,u)=>{n=r,l=u}),resolve:n,reject:l}}function wS(n){return{...np,...n||{}}}function mo(n,{snapGrid:l=[0,0],snapToGrid:o=!1,transform:r,containerBounds:u}){const{x:f,y:d}=cn(n),h=Ro({x:f-((u==null?void 0:u.left)??0),y:d-((u==null?void 0:u.top)??0)},r),{x:y,y:g}=o?ko(h,l):h;return{xSnapped:y,ySnapped:g,...h}}const ud=n=>({width:n.offsetWidth,height:n.offsetHeight}),hp=n=>{var l;return((l=n==null?void 0:n.getRootNode)==null?void 0:l.call(n))||(window==null?void 0:window.document)},SS=["INPUT","SELECT","TEXTAREA"];function gp(n){var r,u;const l=((u=(r=n.composedPath)==null?void 0:r.call(n))==null?void 0:u[0])||n.target;return(l==null?void 0:l.nodeType)!==1?!1:SS.includes(l.nodeName)||l.hasAttribute("contenteditable")||!!l.closest(".nokey")}const yp=n=>"clientX"in n,cn=(n,l)=>{var f,d;const o=yp(n),r=o?n.clientX:(f=n.touches)==null?void 0:f[0].clientX,u=o?n.clientY:(d=n.touches)==null?void 0:d[0].clientY;return{x:r-((l==null?void 0:l.left)??0),y:u-((l==null?void 0:l.top)??0)}},Cy=(n,l,o,r,u)=>{const f=l.querySelectorAll(`.${n}`);return!f||!f.length?null:Array.from(f).map(d=>{const h=d.getBoundingClientRect();return{id:d.getAttribute("data-handleid"),type:n,nodeId:u,position:d.getAttribute("data-handlepos"),x:(h.left-o.left)/r,y:(h.top-o.top)/r,...ud(d)}})};function mp({sourceX:n,sourceY:l,targetX:o,targetY:r,sourceControlX:u,sourceControlY:f,targetControlX:d,targetControlY:h}){const y=n*.125+u*.375+d*.375+o*.125,g=l*.125+f*.375+h*.375+r*.125,b=Math.abs(y-n),p=Math.abs(g-l);return[y,g,b,p]}function su(n,l){return n>=0?.5*n:l*25*Math.sqrt(-n)}function My({pos:n,x1:l,y1:o,x2:r,y2:u,c:f}){switch(n){case ve.Left:return[l-su(l-r,f),o];case ve.Right:return[l+su(r-l,f),o];case ve.Top:return[l,o-su(o-u,f)];case ve.Bottom:return[l,o+su(u-o,f)]}}function sd({sourceX:n,sourceY:l,sourcePosition:o=ve.Bottom,targetX:r,targetY:u,targetPosition:f=ve.Top,curvature:d=.25}){const[h,y]=My({pos:o,x1:n,y1:l,x2:r,y2:u,c:d}),[g,b]=My({pos:f,x1:r,y1:u,x2:n,y2:l,c:d}),[p,v,x,_]=mp({sourceX:n,sourceY:l,targetX:r,targetY:u,sourceControlX:h,sourceControlY:y,targetControlX:g,targetControlY:b});return[`M${n},${l} C${h},${y} ${g},${b} ${r},${u}`,p,v,x,_]}function pp({sourceX:n,sourceY:l,targetX:o,targetY:r}){const u=Math.abs(o-n)/2,f=o<n?o+u:o-u,d=Math.abs(r-l)/2,h=r<l?r+d:r-d;return[f,h,u,d]}function ES({sourceNode:n,targetNode:l,selected:o=!1,zIndex:r=0,elevateOnSelect:u=!1,zIndexMode:f="basic"}){if(f==="manual")return r;const d=u&&o?r+1e3:r,h=Math.max(n.parentId||u&&n.selected?n.internals.z:0,l.parentId||u&&l.selected?l.internals.z:0);return d+h}function NS({sourceNode:n,targetNode:l,width:o,height:r,transform:u}){const f=Hu(Au(n),Au(l));f.x===f.x2&&(f.x2+=1),f.y===f.y2&&(f.y2+=1);const d={x:-u[0]/u[2],y:-u[1]/u[2],width:o/u[2],height:r/u[2]};return Cu(d,Bu(f))>0}const TS=({source:n,sourceHandle:l,target:o,targetHandle:r})=>`xy-edge__${n}${l||""}-${o}${r||""}`,AS=(n,l)=>l.some(o=>o.source===n.source&&o.target===n.target&&(o.sourceHandle===n.sourceHandle||!o.sourceHandle&&!n.sourceHandle)&&(o.targetHandle===n.targetHandle||!o.targetHandle&&!n.targetHandle)),CS=(n,l,o={})=>{var f;if(!n.source||!n.target)return(f=o.onError)==null||f.call(o,"006",fn.error006()),l;const r=o.getEdgeId||TS;let u;return ip(n)?u={...n}:u={...n,id:r(n)},AS(u,l)?l:(u.sourceHandle===null&&delete u.sourceHandle,u.targetHandle===null&&delete u.targetHandle,l.concat(u))};function vp({sourceX:n,sourceY:l,targetX:o,targetY:r}){const[u,f,d,h]=pp({sourceX:n,sourceY:l,targetX:o,targetY:r});return[`M ${n},${l}L ${o},${r}`,u,f,d,h]}const zy={[ve.Left]:{x:-1,y:0},[ve.Right]:{x:1,y:0},[ve.Top]:{x:0,y:-1},[ve.Bottom]:{x:0,y:1}},MS=({source:n,sourcePosition:l=ve.Bottom,target:o})=>l===ve.Left||l===ve.Right?n.x<o.x?{x:1,y:0}:{x:-1,y:0}:n.y<o.y?{x:0,y:1}:{x:0,y:-1},Dy=(n,l)=>Math.sqrt(Math.pow(l.x-n.x,2)+Math.pow(l.y-n.y,2));function zS({source:n,sourcePosition:l=ve.Bottom,target:o,targetPosition:r=ve.Top,center:u,offset:f,stepPosition:d}){const h=zy[l],y=zy[r],g={x:n.x+h.x*f,y:n.y+h.y*f},b={x:o.x+y.x*f,y:o.y+y.y*f},p=MS({source:g,sourcePosition:l,target:b}),v=p.x!==0?"x":"y",x=p[v];let _=[],C,M;const E={x:0,y:0},H={x:0,y:0},[,,w,z]=pp({sourceX:n.x,sourceY:n.y,targetX:o.x,targetY:o.y});if(h[v]*y[v]===-1){v==="x"?(C=u.x??g.x+(b.x-g.x)*d,M=u.y??(g.y+b.y)/2):(C=u.x??(g.x+b.x)/2,M=u.y??g.y+(b.y-g.y)*d);const Q=[{x:C,y:g.y},{x:C,y:b.y}],K=[{x:g.x,y:M},{x:b.x,y:M}];h[v]===x?_=v==="x"?Q:K:_=v==="x"?K:Q}else{const Q=[{x:g.x,y:b.y}],K=[{x:b.x,y:g.y}];if(v==="x"?_=h.x===x?K:Q:_=h.y===x?Q:K,l===r){const D=Math.abs(n[v]-o[v]);if(D<=f){const q=Math.min(f-1,f-D);h[v]===x?E[v]=(g[v]>n[v]?-1:1)*q:H[v]=(b[v]>o[v]?-1:1)*q}}if(l!==r){const D=v==="x"?"y":"x",q=h[v]===y[D],A=g[D]>b[D],j=g[D]<b[D];(h[v]===1&&(!q&&A||q&&j)||h[v]!==1&&(!q&&j||q&&A))&&(_=v==="x"?Q:K)}const ue={x:g.x+E.x,y:g.y+E.y},$={x:b.x+H.x,y:b.y+H.y},ie=Math.max(Math.abs(ue.x-_[0].x),Math.abs($.x-_[0].x)),ne=Math.max(Math.abs(ue.y-_[0].y),Math.abs($.y-_[0].y));ie>=ne?(C=(ue.x+$.x)/2,M=_[0].y):(C=_[0].x,M=(ue.y+$.y)/2)}const G={x:g.x+E.x,y:g.y+E.y},B={x:b.x+H.x,y:b.y+H.y};return[[n,...G.x!==_[0].x||G.y!==_[0].y?[G]:[],..._,...B.x!==_[_.length-1].x||B.y!==_[_.length-1].y?[B]:[],o],C,M,w,z]}function DS(n,l,o,r){const u=Math.min(Dy(n,l)/2,Dy(l,o)/2,r),{x:f,y:d}=l;if(n.x===f&&f===o.x||n.y===d&&d===o.y)return`L${f} ${d}`;if(n.y===d){const g=n.x<o.x?-1:1,b=n.y<o.y?1:-1;return`L ${f+u*g},${d}Q ${f},${d} ${f},${d+u*b}`}const h=n.x<o.x?1:-1,y=n.y<o.y?-1:1;return`L ${f},${d+u*y}Q ${f},${d} ${f+u*h},${d}`}function Bf({sourceX:n,sourceY:l,sourcePosition:o=ve.Bottom,targetX:r,targetY:u,targetPosition:f=ve.Top,borderRadius:d=5,centerX:h,centerY:y,offset:g=20,stepPosition:b=.5}){const[p,v,x,_,C]=zS({source:{x:n,y:l},sourcePosition:o,target:{x:r,y:u},targetPosition:f,center:{x:h,y},offset:g,stepPosition:b});let M=`M${p[0].x} ${p[0].y}`;for(let E=1;E<p.length-1;E++)M+=DS(p[E-1],p[E],p[E+1],d);return M+=`L${p[p.length-1].x} ${p[p.length-1].y}`,[M,v,x,_,C]}function ky(n){var l;return n&&!!(n.internals.handleBounds||(l=n.handles)!=null&&l.length)&&!!(n.measured.width||n.width||n.initialWidth)}function kS(n){var p;const{sourceNode:l,targetNode:o}=n;if(!ky(l)||!ky(o))return null;const r=l.internals.handleBounds||Ry(l.handles),u=o.internals.handleBounds||Ry(o.handles),f=jy((r==null?void 0:r.source)??[],n.sourceHandle),d=jy(n.connectionMode===ii.Strict?(u==null?void 0:u.target)??[]:((u==null?void 0:u.target)??[]).concat((u==null?void 0:u.source)??[]),n.targetHandle);if(!f||!d)return(p=n.onError)==null||p.call(n,"008",fn.error008(f?"target":"source",{id:n.id,sourceHandle:n.sourceHandle,targetHandle:n.targetHandle})),null;const h=(f==null?void 0:f.position)||ve.Bottom,y=(d==null?void 0:d.position)||ve.Top,g=ll(l,f,h),b=ll(o,d,y);return{sourceX:g.x,sourceY:g.y,targetX:b.x,targetY:b.y,sourcePosition:h,targetPosition:y}}function Ry(n){if(!n)return null;const l=[],o=[];for(const r of n)r.width=r.width??1,r.height=r.height??1,r.type==="source"?l.push(r):r.type==="target"&&o.push(r);return{source:l,target:o}}function ll(n,l,o=ve.Left,r=!1){const u=((l==null?void 0:l.x)??0)+n.internals.positionAbsolute.x,f=((l==null?void 0:l.y)??0)+n.internals.positionAbsolute.y,{width:d,height:h}=l??Sn(n);if(r)return{x:u+d/2,y:f+h/2};switch((l==null?void 0:l.position)??o){case ve.Top:return{x:u+d/2,y:f};case ve.Right:return{x:u+d,y:f+h/2};case ve.Bottom:return{x:u+d/2,y:f+h};case ve.Left:return{x:u,y:f+h/2}}}function jy(n,l){return n&&(l?n.find(o=>o.id===l):n[0])||null}function Lf(n,l){return n?typeof n=="string"?n:`${l?`${l}__`:""}${Object.keys(n).sort().map(r=>`${r}=${n[r]}`).join("&")}`:""}function RS(n,{id:l,defaultColor:o,defaultMarkerStart:r,defaultMarkerEnd:u}){const f=new Set;return n.reduce((d,h)=>([h.markerStart||r,h.markerEnd||u].forEach(y=>{if(y&&typeof y=="object"){const g=Lf(y,l);f.has(g)||(d.push({id:g,color:y.color||o,...y}),f.add(g))}}),d),[]).sort((d,h)=>d.id.localeCompare(h.id))}const bp=1e3,jS=10,cd={nodeOrigin:[0,0],nodeExtent:_o,elevateNodesOnSelect:!0,zIndexMode:"basic",defaults:{}},OS={...cd,checkEquality:!0};function fd(n,l){const o={...n};for(const r in l)l[r]!==void 0&&(o[r]=l[r]);return o}function HS(n,l,o){const r=fd(cd,o);for(const u of n.values())if(u.parentId)hd(u,n,l,r);else{const f=zo(u,r.nodeOrigin),d=al(u.extent)?u.extent:r.nodeExtent,h=nl(f,d,Sn(u));u.internals.positionAbsolute=h}}function BS(n,l){if(!n.handles)return n.measured?l==null?void 0:l.internals.handleBounds:void 0;const o=[],r=[];for(const u of n.handles){const f={id:u.id,width:u.width??1,height:u.height??1,nodeId:n.id,x:u.x,y:u.y,position:u.position,type:u.type};u.type==="source"?o.push(f):u.type==="target"&&r.push(f)}return{source:o,target:r}}function dd(n){return n==="manual"}function Uf(n,l,o,r={}){var b,p;const u=fd(OS,r),f={i:0},d=new Map(l),h=u!=null&&u.elevateNodesOnSelect&&!dd(u.zIndexMode)?bp:0;let y=n.length>0,g=!1;l.clear(),o.clear();for(const v of n){let x=d.get(v.id);if(u.checkEquality&&v===(x==null?void 0:x.internals.userNode))l.set(v.id,x);else{const _=zo(v,u.nodeOrigin),C=al(v.extent)?v.extent:u.nodeExtent,M=nl(_,C,Sn(v));x={...u.defaults,...v,measured:{width:(b=v.measured)==null?void 0:b.width,height:(p=v.measured)==null?void 0:p.height},internals:{positionAbsolute:M,handleBounds:BS(v,x),z:xp(v,h,u.zIndexMode),userNode:v}},l.set(v.id,x)}(x.measured===void 0||x.measured.width===void 0||x.measured.height===void 0)&&!x.hidden&&(y=!1),v.parentId&&hd(x,l,o,r,f),g||(g=v.selected??!1)}return{nodesInitialized:y,hasSelectedNodes:g}}function LS(n,l){if(!n.parentId)return;const o=l.get(n.parentId);o?o.set(n.id,n):l.set(n.parentId,new Map([[n.id,n]]))}function hd(n,l,o,r,u){const{elevateNodesOnSelect:f,nodeOrigin:d,nodeExtent:h,zIndexMode:y}=fd(cd,r),g=n.parentId,b=l.get(g);if(!b){console.warn(`Parent node ${g} not found. Please make sure that parent nodes are in front of their child nodes in the nodes array.`);return}LS(n,o),u&&!b.parentId&&b.internals.rootParentIndex===void 0&&y==="auto"&&(b.internals.rootParentIndex=++u.i,b.internals.z=b.internals.z+u.i*jS),u&&b.internals.rootParentIndex!==void 0&&(u.i=b.internals.rootParentIndex);const p=f&&!dd(y)?bp:0,{x:v,y:x,z:_}=US(n,b,d,h,p,y),{positionAbsolute:C}=n.internals,M=v!==C.x||x!==C.y;(M||_!==n.internals.z)&&l.set(n.id,{...n,internals:{...n.internals,positionAbsolute:M?{x:v,y:x}:C,z:_}})}function xp(n,l,o){const r=sn(n.zIndex)?n.zIndex:0;return dd(o)?r:r+(n.selected?l:0)}function US(n,l,o,r,u,f){const{x:d,y:h}=l.internals.positionAbsolute,y=Sn(n),g=zo(n,o),b=al(n.extent)?nl(g,n.extent,y):g;let p=nl({x:d+b.x,y:h+b.y},r,y);n.extent==="parent"&&(p=rp(p,y,l));const v=xp(n,u,f),x=l.internals.z??0;return{x:p.x,y:p.y,z:x>=v?x+1:v}}function gd(n,l,o,r=[0,0]){var d;const u=[],f=new Map;for(const h of n){const y=l.get(h.parentId);if(!y)continue;const g=((d=f.get(h.parentId))==null?void 0:d.expandedRect)??So(y),b=up(g,h.rect);f.set(h.parentId,{expandedRect:b,parent:y})}return f.size>0&&f.forEach(({expandedRect:h,parent:y},g)=>{var w;const b=y.internals.positionAbsolute,p=Sn(y),v=y.origin??r,x=h.x<b.x?Math.round(Math.abs(b.x-h.x)):0,_=h.y<b.y?Math.round(Math.abs(b.y-h.y)):0,C=Math.max(p.width,Math.round(h.width)),M=Math.max(p.height,Math.round(h.height)),E=(C-p.width)*v[0],H=(M-p.height)*v[1];(x>0||_>0||E||H)&&(u.push({id:g,type:"position",position:{x:y.position.x-x+E,y:y.position.y-_+H}}),(w=o.get(g))==null||w.forEach(z=>{n.some(G=>G.id===z.id)||u.push({id:z.id,type:"position",position:{x:z.position.x+x,y:z.position.y+_}})})),(p.width<h.width||p.height<h.height||x||_)&&u.push({id:g,type:"dimensions",setAttributes:!0,dimensions:{width:C+(x?v[0]*x-E:0),height:M+(_?v[1]*_-H:0)}})}),u}function GS(n,l,o,r,u,f,d){const h=r==null?void 0:r.querySelector(".xyflow__viewport");let y=!1;if(!h)return{changes:[],updatedInternals:y};const g=[],b=window.getComputedStyle(h),{m22:p}=new window.DOMMatrixReadOnly(b.transform),v=[];for(const x of n.values()){const _=l.get(x.id);if(!_)continue;if(_.hidden){l.set(_.id,{..._,internals:{..._.internals,handleBounds:void 0}}),y=!0;continue}const C=ud(x.nodeElement),M=_.measured.width!==C.width||_.measured.height!==C.height;if(!!(C.width&&C.height&&(M||!_.internals.handleBounds||x.force))){const H=x.nodeElement.getBoundingClientRect(),w=al(_.extent)?_.extent:f;let{positionAbsolute:z}=_.internals;if(_.parentId&&_.extent==="parent"){const B=l.get(_.parentId);B&&(z=rp(z,C,B))}else w&&(z=nl(z,w,C));const G={..._,measured:C,internals:{..._.internals,positionAbsolute:z,handleBounds:{source:Cy("source",x.nodeElement,H,p,_.id),target:Cy("target",x.nodeElement,H,p,_.id)}}};l.set(_.id,G),_.parentId&&hd(G,l,o,{nodeOrigin:u,zIndexMode:d}),y=!0,M&&(g.push({id:_.id,type:"dimensions",dimensions:C}),_.expandParent&&_.parentId&&v.push({id:_.id,parentId:_.parentId,rect:So(G,u)}))}}if(v.length>0){const x=gd(v,l,o,u);g.push(...x)}return{changes:g,updatedInternals:y}}async function YS({delta:n,panZoom:l,transform:o,translateExtent:r,width:u,height:f}){if(!l||!n.x&&!n.y)return!1;const d=await l.setViewportConstrained({x:o[0]+n.x,y:o[1]+n.y,zoom:o[2]},[[0,0],[u,f]],r);return!!d&&(d.x!==o[0]||d.y!==o[1]||d.k!==o[2])}function Oy(n,l,o,r,u,f){let d=u;const h=r.get(d)||new Map;r.set(d,h.set(o,l)),d=`${u}-${n}`;const y=r.get(d)||new Map;if(r.set(d,y.set(o,l)),f){d=`${u}-${n}-${f}`;const g=r.get(d)||new Map;r.set(d,g.set(o,l))}}function _p(n,l,o){n.clear(),l.clear();for(const r of o){const{source:u,target:f,sourceHandle:d=null,targetHandle:h=null}=r,y={edgeId:r.id,source:u,target:f,sourceHandle:d,targetHandle:h},g=`${u}-${d}--${f}-${h}`,b=`${f}-${h}--${u}-${d}`;Oy("source",y,b,n,u,d),Oy("target",y,g,n,f,h),l.set(r.id,r)}}function wp(n,l){if(!n.parentId)return!1;const o=l.get(n.parentId);return o?o.selected?!0:wp(o,l):!1}function Hy(n,l,o){var u;let r=n;do{if((u=r==null?void 0:r.matches)!=null&&u.call(r,l))return!0;if(r===o)return!1;r=r==null?void 0:r.parentElement}while(r);return!1}function VS(n,l,o,r){const u=new Map;for(const[f,d]of n)if((d.selected||d.id===r)&&(!d.parentId||!wp(d,n))&&(d.draggable||l&&typeof d.draggable>"u")){const h=n.get(f);h&&u.set(f,{id:f,position:h.position||{x:0,y:0},distance:{x:o.x-h.internals.positionAbsolute.x,y:o.y-h.internals.positionAbsolute.y},extent:h.extent,parentId:h.parentId,origin:h.origin,expandParent:h.expandParent,internals:{positionAbsolute:h.internals.positionAbsolute||{x:0,y:0}},measured:{width:h.measured.width??0,height:h.measured.height??0}})}return u}function gf({nodeId:n,dragItems:l,nodeLookup:o,dragging:r=!0}){var d,h,y;const u=[];for(const[g,b]of l){const p=(d=o.get(g))==null?void 0:d.internals.userNode;p&&u.push({...p,position:b.position,dragging:r})}if(!n)return[u[0],u];const f=(h=o.get(n))==null?void 0:h.internals.userNode;return[f?{...f,position:((y=l.get(n))==null?void 0:y.position)||f.position,dragging:r}:u[0],u]}function qS({dragItems:n,snapGrid:l,x:o,y:r}){const u=n.values().next().value;if(!u)return null;const f={x:o-u.distance.x,y:r-u.distance.y},d=ko(f,l);return{x:d.x-f.x,y:d.y-f.y}}function XS({onNodeMouseDown:n,getStoreItems:l,onDragStart:o,onDrag:r,onDragStop:u}){let f={x:null,y:null},d=0,h=new Map,y=!1,g={x:0,y:0},b=null,p=!1,v=null,x=!1,_=!1,C=null;function M({noDragClassName:H,handleSelector:w,domNode:z,isSelectable:G,nodeId:B,nodeClickDistance:L=0}){v=Yt(z);function Q({x:ie,y:ne}){const{nodeLookup:D,nodeExtent:q,snapGrid:A,snapToGrid:j,nodeOrigin:V,onNodeDrag:k,onSelectionDrag:Z,onError:N,updateNodePositions:R}=l();f={x:ie,y:ne};let ee=!1;const ae=h.size>1,de=ae&&q?Hf(Do(h)):null,se=ae&&j?qS({dragItems:h,snapGrid:A,x:ie,y:ne}):null;for(const[oe,P]of h){if(!D.has(oe))continue;let Y={x:ie-P.distance.x,y:ne-P.distance.y};j&&(Y=se?{x:Math.round(Y.x+se.x),y:Math.round(Y.y+se.y)}:ko(Y,A));let fe=null;if(ae&&q&&!P.extent&&de){const{positionAbsolute:me}=P.internals,_e=me.x-de.x+q[0][0],Ce=me.x+P.measured.width-de.x2+q[1][0],De=me.y-de.y+q[0][1],$e=me.y+P.measured.height-de.y2+q[1][1];fe=[[_e,De],[Ce,$e]]}const{position:he,positionAbsolute:ge}=op({nodeId:oe,nextPosition:Y,nodeLookup:D,nodeExtent:fe||q,nodeOrigin:V,onError:N});ee=ee||P.position.x!==he.x||P.position.y!==he.y,P.position=he,P.internals.positionAbsolute=ge}if(_=_||ee,!!ee&&(R(h,!0),C&&(r||k||!B&&Z))){const[oe,P]=gf({nodeId:B,dragItems:h,nodeLookup:D});r==null||r(C,h,oe,P),k==null||k(C,oe,P),B||Z==null||Z(C,P)}}async function K(){if(!b)return;const{transform:ie,panBy:ne,autoPanSpeed:D,autoPanOnNodeDrag:q}=l();if(!q){y=!1,cancelAnimationFrame(d);return}const[A,j]=od(g,b,D);(A!==0||j!==0)&&(f.x=(f.x??0)-A/ie[2],f.y=(f.y??0)-j/ie[2],await ne({x:A,y:j})&&Q(f)),d=requestAnimationFrame(K)}function ue(ie){var ae;const{nodeLookup:ne,multiSelectionActive:D,nodesDraggable:q,transform:A,snapGrid:j,snapToGrid:V,selectNodesOnDrag:k,onNodeDragStart:Z,onSelectionDragStart:N,unselectNodesAndEdges:R}=l();p=!0,(!k||!G)&&!D&&B&&((ae=ne.get(B))!=null&&ae.selected||R()),G&&k&&B&&(n==null||n(B));const ee=mo(ie.sourceEvent,{transform:A,snapGrid:j,snapToGrid:V,containerBounds:b});if(f=ee,h=VS(ne,q,ee,B),h.size>0&&(o||Z||!B&&N)){const[de,se]=gf({nodeId:B,dragItems:h,nodeLookup:ne});o==null||o(ie.sourceEvent,h,de,se),Z==null||Z(ie.sourceEvent,de,se),B||N==null||N(ie.sourceEvent,se)}}const $=Um().clickDistance(L).on("start",ie=>{const{domNode:ne,nodeDragThreshold:D,transform:q,snapGrid:A,snapToGrid:j}=l();b=(ne==null?void 0:ne.getBoundingClientRect())||null,x=!1,_=!1,C=ie.sourceEvent,D===0&&ue(ie),f=mo(ie.sourceEvent,{transform:q,snapGrid:A,snapToGrid:j,containerBounds:b}),g=cn(ie.sourceEvent,b)}).on("drag",ie=>{const{autoPanOnNodeDrag:ne,transform:D,snapGrid:q,snapToGrid:A,nodeDragThreshold:j,nodeLookup:V}=l(),k=mo(ie.sourceEvent,{transform:D,snapGrid:q,snapToGrid:A,containerBounds:b});if(C=ie.sourceEvent,(ie.sourceEvent.type==="touchmove"&&ie.sourceEvent.touches.length>1||B&&!V.has(B))&&(x=!0),!x){if(!y&&ne&&p&&(y=!0,K()),!p){const Z=cn(ie.sourceEvent,b),N=Z.x-g.x,R=Z.y-g.y;Math.sqrt(N*N+R*R)>j&&ue(ie)}(f.x!==k.xSnapped||f.y!==k.ySnapped)&&h&&p&&(g=cn(ie.sourceEvent,b),Q(k))}}).on("end",ie=>{if(!p||x){x&&h.size>0&&l().updateNodePositions(h,!1);return}if(y=!1,p=!1,cancelAnimationFrame(d),h.size>0){const{nodeLookup:ne,updateNodePositions:D,onNodeDragStop:q,onSelectionDragStop:A}=l();if(_&&(D(h,!1),_=!1),u||q||!B&&A){const[j,V]=gf({nodeId:B,dragItems:h,nodeLookup:ne,dragging:!1});u==null||u(ie.sourceEvent,h,j,V),q==null||q(ie.sourceEvent,j,V),B||A==null||A(ie.sourceEvent,V)}}}).filter(ie=>{const ne=ie.target;return!ie.button&&(!H||!Hy(ne,`.${H}`,z))&&(!w||Hy(ne,w,z))});v.call($)}function E(){v==null||v.on(".drag",null)}return{update:M,destroy:E}}function QS(n,l,o){const r=[],u={x:n.x-o,y:n.y-o,width:o*2,height:o*2};for(const f of l.values())Cu(u,So(f))>0&&r.push(f);return r}const $S=250;function ZS(n,l,o,r){var h,y;let u=[],f=1/0;const d=QS(n,o,l+$S);for(const g of d){const b=[...((h=g.internals.handleBounds)==null?void 0:h.source)??[],...((y=g.internals.handleBounds)==null?void 0:y.target)??[]];for(const p of b){if(r.nodeId===p.nodeId&&r.type===p.type&&r.id===p.id)continue;const{x:v,y:x}=ll(g,p,p.position,!0),_=Math.sqrt(Math.pow(v-n.x,2)+Math.pow(x-n.y,2));_>l||(_<f?(u=[{...p,x:v,y:x}],f=_):_===f&&u.push({...p,x:v,y:x}))}}if(!u.length)return null;if(u.length>1){const g=r.type==="source"?"target":"source";return u.find(b=>b.type===g)??u[0]}return u[0]}function Sp(n,l,o,r,u,f=!1){var g,b,p;const d=r.get(n);if(!d)return null;const h=u==="strict"?(g=d.internals.handleBounds)==null?void 0:g[l]:[...((b=d.internals.handleBounds)==null?void 0:b.source)??[],...((p=d.internals.handleBounds)==null?void 0:p.target)??[]],y=(o?h==null?void 0:h.find(v=>v.id===o):h==null?void 0:h[0])??null;return y&&f?{...y,...ll(d,y,y.position,!0)}:y}function Ep(n,l){return n||(l!=null&&l.classList.contains("target")?"target":l!=null&&l.classList.contains("source")?"source":null)}function KS(n,l){let o=null;return l?o=!0:n&&!l&&(o=!1),o}const Np=()=>!0;function JS(n,{connectionMode:l,connectionRadius:o,handleId:r,nodeId:u,edgeUpdaterType:f,isTarget:d,domNode:h,nodeLookup:y,lib:g,autoPanOnConnect:b,flowId:p,panBy:v,cancelConnection:x,onConnectStart:_,onConnect:C,onConnectEnd:M,isValidConnection:E=Np,onReconnectEnd:H,updateConnection:w,getTransform:z,getFromHandle:G,autoPanSpeed:B,dragThreshold:L=1,handleDomNode:Q}){const K=hp(n.target);let ue=0,$;const{x:ie,y:ne}=cn(n),D=Ep(f,Q),q=h==null?void 0:h.getBoundingClientRect();let A=!1;if(!q||!D)return;const j=Sp(u,D,r,y,l);if(!j)return;let V=cn(n,q),k=!1,Z=null,N=!1,R=null;function ee(){if(!b||!q)return;const[he,ge]=od(V,q,B);v({x:he,y:ge}),ue=requestAnimationFrame(ee)}const ae={...j,nodeId:u,type:D,position:j.position},de=y.get(u);let oe={inProgress:!0,isValid:null,from:ll(de,ae,ve.Left,!0),fromHandle:ae,fromPosition:ae.position,fromNode:de,to:V,toHandle:null,toPosition:Ey[ae.position],toNode:null,pointer:V};function P(){A=!0,w(oe),_==null||_(n,{nodeId:u,handleId:r,handleType:D})}L===0&&P();function Y(he){if(!A){const{x:$e,y:mt}=cn(he),_t=$e-ie,wt=mt-ne;if(!(_t*_t+wt*wt>L*L))return;P()}if(!G()||!ae){fe(he);return}const ge=z();V=cn(he,q),$=ZS(Ro(V,ge,!1,[1,1]),o,y,ae),k||(ee(),k=!0);const me=Tp(he,{handle:$,connectionMode:l,fromNodeId:u,fromHandleId:r,fromType:d?"target":"source",isValidConnection:E,doc:K,lib:g,flowId:p,nodeLookup:y});R=me.handleDomNode,Z=me.connection,N=KS(!!$,me.isValid);const _e=y.get(u),Ce=_e?ll(_e,ae,ve.Left,!0):oe.from,De={...oe,from:Ce,isValid:N,to:me.toHandle&&N?ri({x:me.toHandle.x,y:me.toHandle.y},ge):V,toHandle:me.toHandle,toPosition:N&&me.toHandle?me.toHandle.position:Ey[ae.position],toNode:me.toHandle?y.get(me.toHandle.nodeId):null,pointer:V};w(De),oe=De}function fe(he){if(!("touches"in he&&he.touches.length>0)){if(A){($||R)&&Z&&N&&(C==null||C(Z));const{inProgress:ge,...me}=oe,_e={...me,toPosition:oe.toHandle?oe.toPosition:null};M==null||M(he,_e),f&&(H==null||H(he,_e))}x(),cancelAnimationFrame(ue),k=!1,N=!1,Z=null,R=null,K.removeEventListener("mousemove",Y),K.removeEventListener("mouseup",fe),K.removeEventListener("touchmove",Y),K.removeEventListener("touchend",fe)}}K.addEventListener("mousemove",Y),K.addEventListener("mouseup",fe),K.addEventListener("touchmove",Y),K.addEventListener("touchend",fe)}function Tp(n,{handle:l,connectionMode:o,fromNodeId:r,fromHandleId:u,fromType:f,doc:d,lib:h,flowId:y,isValidConnection:g=Np,nodeLookup:b}){const p=f==="target",v=l?d.querySelector(`.${h}-flow__handle[data-id="${y}-${l==null?void 0:l.nodeId}-${l==null?void 0:l.id}-${l==null?void 0:l.type}"]`):null,{x,y:_}=cn(n),C=d.elementFromPoint(x,_),M=C!=null&&C.classList.contains(`${h}-flow__handle`)?C:v,E={handleDomNode:M,isValid:!1,connection:null,toHandle:null};if(M){const H=Ep(void 0,M),w=M.getAttribute("data-nodeid"),z=M.getAttribute("data-handleid"),G=M.classList.contains("connectable"),B=M.classList.contains("connectableend");if(!w||!H)return E;const L={source:p?w:r,sourceHandle:p?z:u,target:p?r:w,targetHandle:p?u:z};E.connection=L;const K=G&&B&&(o===ii.Strict?p&&H==="source"||!p&&H==="target":w!==r||z!==u);E.isValid=K&&g(L),E.toHandle=Sp(w,H,z,b,o,!0)}return E}const Gf={onPointerDown:JS,isValid:Tp};function IS({domNode:n,panZoom:l,getTransform:o,getViewScale:r}){const u=Yt(n);function f({translateExtent:h,width:y,height:g,zoomStep:b=1,pannable:p=!0,zoomable:v=!0,inversePan:x=!1}){const _=w=>{if(w.sourceEvent.type!=="wheel"||!l)return;const z=o(),G=w.sourceEvent.ctrlKey&&Eo()?10:1,B=-w.sourceEvent.deltaY*(w.sourceEvent.deltaMode===1?.05:w.sourceEvent.deltaMode?1:.002)*b,L=z[2]*Math.pow(2,B*G);l.scaleTo(L)};let C=[0,0];const M=w=>{(w.sourceEvent.type==="mousedown"||w.sourceEvent.type==="touchstart")&&(C=[w.sourceEvent.clientX??w.sourceEvent.touches[0].clientX,w.sourceEvent.clientY??w.sourceEvent.touches[0].clientY])},E=w=>{const z=o();if(w.sourceEvent.type!=="mousemove"&&w.sourceEvent.type!=="touchmove"||!l)return;const G=[w.sourceEvent.clientX??w.sourceEvent.touches[0].clientX,w.sourceEvent.clientY??w.sourceEvent.touches[0].clientY],B=[G[0]-C[0],G[1]-C[1]];C=G;const L=r()*Math.max(z[2],Math.log(z[2]))*(x?-1:1),Q={x:z[0]-B[0]*L,y:z[1]-B[1]*L},K=[[0,0],[y,g]];l.setViewportConstrained({x:Q.x,y:Q.y,zoom:z[2]},K,h)},H=ep().on("start",M).on("zoom",p?E:null).on("zoom.wheel",v?_:null);u.call(H,{})}function d(){u.on("zoom",null)}return{update:f,destroy:d,pointer:rn}}const Lu=n=>({x:n.x,y:n.y,zoom:n.k}),yf=({x:n,y:l,zoom:o})=>Ou.translate(n,l).scale(o),Pl=(n,l)=>n.target.closest(`.${l}`),Ap=(n,l)=>l===2&&Array.isArray(n)&&n.includes(2),WS=n=>((n*=2)<=1?n*n*n:(n-=2)*n*n+2)/2,mf=(n,l=0,o=WS,r=()=>{})=>{const u=typeof l=="number"&&l>0;return u||r(),u?n.transition().duration(l).ease(o).on("end",r):n},Cp=n=>{const l=n.ctrlKey&&Eo()?10:1;return-n.deltaY*(n.deltaMode===1?.05:n.deltaMode?1:.002)*l};function FS({zoomPanValues:n,noWheelClassName:l,d3Selection:o,d3Zoom:r,panOnScrollMode:u,panOnScrollSpeed:f,zoomOnPinch:d,onPanZoomStart:h,onPanZoom:y,onPanZoomEnd:g}){return b=>{if(Pl(b,l))return b.ctrlKey&&b.preventDefault(),!1;b.preventDefault(),b.stopImmediatePropagation();const p=o.property("__zoom").k||1;if(b.ctrlKey&&d){const M=rn(b),E=Cp(b),H=p*Math.pow(2,E);r.scaleTo(o,H,M,b);return}const v=b.deltaMode===1?20:1;let x=u===Pa.Vertical?0:b.deltaX*v,_=u===Pa.Horizontal?0:b.deltaY*v;!Eo()&&b.shiftKey&&u!==Pa.Vertical&&(x=b.deltaY*v,_=0),r.translateBy(o,-(x/p)*f,-(_/p)*f,{internal:!0});const C=Lu(o.property("__zoom"));clearTimeout(n.panScrollTimeout),n.isPanScrolling?y==null||y(b,C):(n.isPanScrolling=!0,h==null||h(b,C)),n.panScrollTimeout=setTimeout(()=>{g==null||g(b,C),n.isPanScrolling=!1},150)}}function PS({noWheelClassName:n,preventScrolling:l,d3ZoomHandler:o}){return function(r,u){const f=r.type==="wheel",d=!l&&f&&!r.ctrlKey,h=Pl(r,n);if(r.ctrlKey&&f&&h&&r.preventDefault(),d||h)return null;r.preventDefault(),o.call(this,r,u)}}function e2({zoomPanValues:n,onDraggingChange:l,onPanZoomStart:o}){return r=>{var f,d,h;if((f=r.sourceEvent)!=null&&f.internal)return;const u=Lu(r.transform);n.mouseButton=((d=r.sourceEvent)==null?void 0:d.button)||0,n.isZoomingOrPanning=!0,n.prevViewport=u,((h=r.sourceEvent)==null?void 0:h.type)==="mousedown"&&l(!0),o&&(o==null||o(r.sourceEvent,u))}}function t2({zoomPanValues:n,panOnDrag:l,onPaneContextMenu:o,onTransformChange:r,onPanZoom:u}){return f=>{var d,h;n.usedRightMouseButton=!!(o&&Ap(l,n.mouseButton??0)),(d=f.sourceEvent)!=null&&d.sync||r([f.transform.x,f.transform.y,f.transform.k]),u&&!((h=f.sourceEvent)!=null&&h.internal)&&(u==null||u(f.sourceEvent,Lu(f.transform)))}}function n2({zoomPanValues:n,panOnDrag:l,panOnScroll:o,onDraggingChange:r,onPanZoomEnd:u,onPaneContextMenu:f}){return d=>{var h;if(!((h=d.sourceEvent)!=null&&h.internal)&&(n.isZoomingOrPanning=!1,f&&Ap(l,n.mouseButton??0)&&!n.usedRightMouseButton&&d.sourceEvent&&f(d.sourceEvent),n.usedRightMouseButton=!1,r(!1),u)){const y=Lu(d.transform);n.prevViewport=y,clearTimeout(n.timerId),n.timerId=setTimeout(()=>{u==null||u(d.sourceEvent,y)},o?150:0)}}}function a2({zoomActivationKeyPressed:n,zoomOnScroll:l,zoomOnPinch:o,panOnDrag:r,panOnScroll:u,zoomOnDoubleClick:f,userSelectionActive:d,noWheelClassName:h,noPanClassName:y,lib:g,connectionInProgress:b}){return p=>{var M;const v=n||l,x=o&&p.ctrlKey,_=p.type==="wheel";if(p.button===1&&p.type==="mousedown"&&(Pl(p,`${g}-flow__node`)||Pl(p,`${g}-flow__edge`)))return!0;if(!r&&!v&&!u&&!f&&!o||d||b&&!_||Pl(p,h)&&_||Pl(p,y)&&(!_||u&&_&&!n)||!o&&p.ctrlKey&&_)return!1;if(!o&&p.type==="touchstart"&&((M=p.touches)==null?void 0:M.length)>1)return p.preventDefault(),!1;if(!v&&!u&&!x&&_||!r&&(p.type==="mousedown"||p.type==="touchstart")||Array.isArray(r)&&!r.includes(p.button)&&p.type==="mousedown")return!1;const C=Array.isArray(r)&&r.includes(p.button)||!p.button||p.button<=1;return(!p.ctrlKey||_)&&C}}function l2({domNode:n,minZoom:l,maxZoom:o,translateExtent:r,viewport:u,onPanZoom:f,onPanZoomStart:d,onPanZoomEnd:h,onDraggingChange:y}){const g={isZoomingOrPanning:!1,usedRightMouseButton:!1,prevViewport:{},mouseButton:0,timerId:void 0,panScrollTimeout:void 0,isPanScrolling:!1},b=n.getBoundingClientRect();let p=[[0,0],[b.width,b.height]];const v=typeof ResizeObserver<"u"?new ResizeObserver(ne=>{const D=ne[0];D&&(p=[[0,0],[D.contentRect.width,D.contentRect.height]])}):null;v==null||v.observe(n);const x=ep().extent(()=>p).scaleExtent([l,o]).translateExtent(r),_=Yt(n).call(x);z({x:u.x,y:u.y,zoom:oi(u.zoom,l,o)},[[0,0],[b.width,b.height]],r);const C=_.on("wheel.zoom"),M=_.on("dblclick.zoom");x.wheelDelta(Cp);async function E(ne,D){return _?new Promise(q=>{x==null||x.interpolate((D==null?void 0:D.interpolate)==="linear"?yo:yu).transform(mf(_,D==null?void 0:D.duration,D==null?void 0:D.ease,()=>q(!0)),ne)}):!1}function H({noWheelClassName:ne,noPanClassName:D,onPaneContextMenu:q,userSelectionActive:A,panOnScroll:j,panOnDrag:V,panOnScrollMode:k,panOnScrollSpeed:Z,preventScrolling:N,zoomOnPinch:R,zoomOnScroll:ee,zoomOnDoubleClick:ae,zoomActivationKeyPressed:de,lib:se,onTransformChange:oe,connectionInProgress:P,paneClickDistance:Y,selectionOnDrag:fe}){A&&!g.isZoomingOrPanning&&w();const he=j&&!de&&!A;x.clickDistance(fe?1/0:!sn(Y)||Y<0?0:Y);const ge=he?FS({zoomPanValues:g,noWheelClassName:ne,d3Selection:_,d3Zoom:x,panOnScrollMode:k,panOnScrollSpeed:Z,zoomOnPinch:R,onPanZoomStart:d,onPanZoom:f,onPanZoomEnd:h}):PS({noWheelClassName:ne,preventScrolling:N,d3ZoomHandler:C});_.on("wheel.zoom",ge,{passive:!1});const me=e2({zoomPanValues:g,onDraggingChange:y,onPanZoomStart:d});x.on("start",me);const _e=t2({zoomPanValues:g,panOnDrag:V,onPaneContextMenu:!!q,onPanZoom:f,onTransformChange:oe});x.on("zoom",_e);const Ce=n2({zoomPanValues:g,panOnDrag:V,panOnScroll:j,onPaneContextMenu:q,onPanZoomEnd:h,onDraggingChange:y});x.on("end",Ce);const De=a2({zoomActivationKeyPressed:de,panOnDrag:V,zoomOnScroll:ee,panOnScroll:j,zoomOnDoubleClick:ae,zoomOnPinch:R,userSelectionActive:A,noPanClassName:D,noWheelClassName:ne,lib:se,connectionInProgress:P});x.filter(De),ae?_.on("dblclick.zoom",M):_.on("dblclick.zoom",null)}function w(){x.on("zoom",null)}async function z(ne,D,q){const A=yf(ne),j=x==null?void 0:x.constrain()(A,D,q);return j&&await E(j),j}async function G(ne,D){const q=yf(ne);return await E(q,D),q}function B(ne){if(_){const D=yf(ne),q=_.property("__zoom");(q.k!==ne.zoom||q.x!==ne.x||q.y!==ne.y)&&(x==null||x.transform(_,D,null,{sync:!0}))}}function L(){const ne=_?Pm(_.node()):{x:0,y:0,k:1};return{x:ne.x,y:ne.y,zoom:ne.k}}async function Q(ne,D){return _?new Promise(q=>{x==null||x.interpolate((D==null?void 0:D.interpolate)==="linear"?yo:yu).scaleTo(mf(_,D==null?void 0:D.duration,D==null?void 0:D.ease,()=>q(!0)),ne)}):!1}async function K(ne,D){return _?new Promise(q=>{x==null||x.interpolate((D==null?void 0:D.interpolate)==="linear"?yo:yu).scaleBy(mf(_,D==null?void 0:D.duration,D==null?void 0:D.ease,()=>q(!0)),ne)}):!1}function ue(ne){x==null||x.scaleExtent(ne)}function $(ne){x==null||x.translateExtent(ne)}function ie(ne){const D=!sn(ne)||ne<0?0:ne;x==null||x.clickDistance(D)}return{update:H,destroy:w,setViewport:G,setViewportConstrained:z,getViewport:L,scaleTo:Q,scaleBy:K,setScaleExtent:ue,setTranslateExtent:$,syncViewport:B,setClickDistance:ie}}var ui;(function(n){n.Line="line",n.Handle="handle"})(ui||(ui={}));function i2({width:n,prevWidth:l,height:o,prevHeight:r,affectsX:u,affectsY:f}){const d=n-l,h=o-r,y=[d>0?1:d<0?-1:0,h>0?1:h<0?-1:0];return d&&u&&(y[0]=y[0]*-1),h&&f&&(y[1]=y[1]*-1),y}function By(n){const l=n.includes("right")||n.includes("left"),o=n.includes("bottom")||n.includes("top"),r=n.includes("left"),u=n.includes("top");return{isHorizontal:l,isVertical:o,affectsX:r,affectsY:u}}function Sa(n,l){return Math.max(0,l-n)}function Ea(n,l){return Math.max(0,n-l)}function cu(n,l,o){return Math.max(0,l-n,n-o)}function Ly(n,l){return n?!l:l}function o2(n,l,o,r,u,f,d,h){let{affectsX:y,affectsY:g}=l;const{isHorizontal:b,isVertical:p}=l,v=b&&p,{xSnapped:x,ySnapped:_}=o,{minWidth:C,maxWidth:M,minHeight:E,maxHeight:H}=r,{x:w,y:z,width:G,height:B,aspectRatio:L}=n;let Q=Math.floor(b?x-n.pointerX:0),K=Math.floor(p?_-n.pointerY:0);const ue=G+(y?-Q:Q),$=B+(g?-K:K),ie=-f[0]*G,ne=-f[1]*B;let D=cu(ue,C,M),q=cu($,E,H);if(d){let V=0,k=0;y&&Q<0?V=Sa(w+Q+ie,d[0][0]):!y&&Q>0&&(V=Ea(w+ue+ie,d[1][0])),g&&K<0?k=Sa(z+K+ne,d[0][1]):!g&&K>0&&(k=Ea(z+$+ne,d[1][1])),D=Math.max(D,V),q=Math.max(q,k)}if(h){let V=0,k=0;y&&Q>0?V=Ea(w+Q,h[0][0]):!y&&Q<0&&(V=Sa(w+ue,h[1][0])),g&&K>0?k=Ea(z+K,h[0][1]):!g&&K<0&&(k=Sa(z+$,h[1][1])),D=Math.max(D,V),q=Math.max(q,k)}if(u){if(b){const V=cu(ue/L,E,H)*L;if(D=Math.max(D,V),d){let k=0;!y&&!g||y&&!g&&v?k=Ea(z+ne+ue/L,d[1][1])*L:k=Sa(z+ne+(y?Q:-Q)/L,d[0][1])*L,D=Math.max(D,k)}if(h){let k=0;!y&&!g||y&&!g&&v?k=Sa(z+ue/L,h[1][1])*L:k=Ea(z+(y?Q:-Q)/L,h[0][1])*L,D=Math.max(D,k)}}if(p){const V=cu($*L,C,M)/L;if(q=Math.max(q,V),d){let k=0;!y&&!g||g&&!y&&v?k=Ea(w+$*L+ie,d[1][0])/L:k=Sa(w+(g?K:-K)*L+ie,d[0][0])/L,q=Math.max(q,k)}if(h){let k=0;!y&&!g||g&&!y&&v?k=Sa(w+$*L,h[1][0])/L:k=Ea(w+(g?K:-K)*L,h[0][0])/L,q=Math.max(q,k)}}}K=K+(K<0?q:-q),Q=Q+(Q<0?D:-D),u&&(v?ue>$*L?K=(Ly(y,g)?-Q:Q)/L:Q=(Ly(y,g)?-K:K)*L:b?(K=Q/L,g=y):(Q=K*L,y=g));const A=y?w+Q:w,j=g?z+K:z;return{width:G+(y?-Q:Q),height:B+(g?-K:K),x:f[0]*Q*(y?-1:1)+A,y:f[1]*K*(g?-1:1)+j}}const Mp={width:0,height:0,x:0,y:0},r2={...Mp,pointerX:0,pointerY:0,aspectRatio:1};function u2(n,l,o){const r=l.position.x+n.position.x,u=l.position.y+n.position.y,f=n.measured.width??0,d=n.measured.height??0,h=o[0]*f,y=o[1]*d;return[[r-h,u-y],[r+f-h,u+d-y]]}function s2({domNode:n,nodeId:l,getStoreItems:o,onChange:r,onEnd:u}){const f=Yt(n);let d={controlDirection:By("bottom-right"),boundaries:{minWidth:0,minHeight:0,maxWidth:Number.MAX_VALUE,maxHeight:Number.MAX_VALUE},resizeDirection:void 0,keepAspectRatio:!1};function h({controlPosition:g,boundaries:b,keepAspectRatio:p,resizeDirection:v,onResizeStart:x,onResize:_,onResizeEnd:C,shouldResize:M}){let E={...Mp},H={...r2};d={boundaries:b,resizeDirection:v,keepAspectRatio:p,controlDirection:By(g)};let w,z=null,G=[],B,L,Q,K=!1;const ue=Um().on("start",$=>{const{nodeLookup:ie,transform:ne,snapGrid:D,snapToGrid:q,nodeOrigin:A,paneDomNode:j}=o();if(w=ie.get(l),!w)return;z=(j==null?void 0:j.getBoundingClientRect())??null;const{xSnapped:V,ySnapped:k}=mo($.sourceEvent,{transform:ne,snapGrid:D,snapToGrid:q,containerBounds:z});E={width:w.measured.width??0,height:w.measured.height??0,x:w.position.x??0,y:w.position.y??0},H={...E,pointerX:V,pointerY:k,aspectRatio:E.width/E.height},B=void 0,L=al(w.extent)?w.extent:void 0,w.parentId&&(w.extent==="parent"||w.expandParent)&&(B=ie.get(w.parentId)),B&&w.extent==="parent"&&(L=[[0,0],[B.measured.width,B.measured.height]]),G=[],Q=void 0;for(const[Z,N]of ie)if(N.parentId===l&&(G.push({id:Z,position:{...N.position},extent:N.extent}),N.extent==="parent"||N.expandParent)){const R=u2(N,w,N.origin??A);Q?Q=[[Math.min(R[0][0],Q[0][0]),Math.min(R[0][1],Q[0][1])],[Math.max(R[1][0],Q[1][0]),Math.max(R[1][1],Q[1][1])]]:Q=R}x==null||x($,{...E})}).on("drag",$=>{const{transform:ie,snapGrid:ne,snapToGrid:D,nodeOrigin:q}=o(),A=mo($.sourceEvent,{transform:ie,snapGrid:ne,snapToGrid:D,containerBounds:z}),j=[];if(!w)return;const{x:V,y:k,width:Z,height:N}=E,R={},ee=w.origin??q,{width:ae,height:de,x:se,y:oe}=o2(H,d.controlDirection,A,d.boundaries,d.keepAspectRatio,ee,L,Q),P=ae!==Z,Y=de!==N,fe=se!==V&&P,he=oe!==k&&Y;if(!fe&&!he&&!P&&!Y)return;if((fe||he||ee[0]===1||ee[1]===1)&&(R.x=fe?se:E.x,R.y=he?oe:E.y,E.x=R.x,E.y=R.y,G.length>0)){const Ce=se-V,De=oe-k;for(const $e of G)$e.position={x:$e.position.x-Ce+ee[0]*(ae-Z),y:$e.position.y-De+ee[1]*(de-N)},j.push($e)}if((P||Y)&&(R.width=P&&(!d.resizeDirection||d.resizeDirection==="horizontal")?ae:E.width,R.height=Y&&(!d.resizeDirection||d.resizeDirection==="vertical")?de:E.height,E.width=R.width,E.height=R.height),B&&w.expandParent){const Ce=ee[0]*(R.width??0);R.x&&R.x<Ce&&(E.x=Ce,H.x=H.x-(R.x-Ce));const De=ee[1]*(R.height??0);R.y&&R.y<De&&(E.y=De,H.y=H.y-(R.y-De))}const ge=i2({width:E.width,prevWidth:Z,height:E.height,prevHeight:N,affectsX:d.controlDirection.affectsX,affectsY:d.controlDirection.affectsY}),me={...E,direction:ge};(M==null?void 0:M($,me))!==!1&&(K=!0,_==null||_($,me),r(R,j))}).on("end",$=>{K&&(C==null||C($,{...E}),u==null||u({...E}),K=!1)});f.call(ue)}function y(){f.on(".drag",null)}return{update:h,destroy:y}}var pf={exports:{}},vf={},bf={exports:{}},xf={};/**
- * @license React
- * use-sync-external-store-shim.production.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */var Uy;function c2(){if(Uy)return xf;Uy=1;var n=Ao();function l(p,v){return p===v&&(p!==0||1/p===1/v)||p!==p&&v!==v}var o=typeof Object.is=="function"?Object.is:l,r=n.useState,u=n.useEffect,f=n.useLayoutEffect,d=n.useDebugValue;function h(p,v){var x=v(),_=r({inst:{value:x,getSnapshot:v}}),C=_[0].inst,M=_[1];return f(function(){C.value=x,C.getSnapshot=v,y(C)&&M({inst:C})},[p,x,v]),u(function(){return y(C)&&M({inst:C}),p(function(){y(C)&&M({inst:C})})},[p]),d(x),x}function y(p){var v=p.getSnapshot;p=p.value;try{var x=v();return!o(p,x)}catch{return!0}}function g(p,v){return v()}var b=typeof window>"u"||typeof window.document>"u"||typeof window.document.createElement>"u"?g:h;return xf.useSyncExternalStore=n.useSyncExternalStore!==void 0?n.useSyncExternalStore:b,xf}var Gy;function f2(){return Gy||(Gy=1,bf.exports=c2()),bf.exports}/**
- * @license React
- * use-sync-external-store-shim/with-selector.production.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */var Yy;function d2(){if(Yy)return vf;Yy=1;var n=Ao(),l=f2();function o(g,b){return g===b&&(g!==0||1/g===1/b)||g!==g&&b!==b}var r=typeof Object.is=="function"?Object.is:o,u=l.useSyncExternalStore,f=n.useRef,d=n.useEffect,h=n.useMemo,y=n.useDebugValue;return vf.useSyncExternalStoreWithSelector=function(g,b,p,v,x){var _=f(null);if(_.current===null){var C={hasValue:!1,value:null};_.current=C}else C=_.current;_=h(function(){function E(B){if(!H){if(H=!0,w=B,B=v(B),x!==void 0&&C.hasValue){var L=C.value;if(x(L,B))return z=L}return z=B}if(L=z,r(w,B))return L;var Q=v(B);return x!==void 0&&x(L,Q)?(w=B,L):(w=B,z=Q)}var H=!1,w,z,G=p===void 0?null:p;return[function(){return E(b())},G===null?void 0:function(){return E(G())}]},[b,p,v,x]);var M=u(g,_[0],_[1]);return d(function(){C.hasValue=!0,C.value=M},[M]),y(M),M},vf}var Vy;function h2(){return Vy||(Vy=1,pf.exports=d2()),pf.exports}var g2=h2();const y2=Sm(g2),m2={},qy=n=>{let l;const o=new Set,r=(b,p)=>{const v=typeof b=="function"?b(l):b;if(!Object.is(v,l)){const x=l;l=p??(typeof v!="object"||v===null)?v:Object.assign({},l,v),o.forEach(_=>_(l,x))}},u=()=>l,y={setState:r,getState:u,getInitialState:()=>g,subscribe:b=>(o.add(b),()=>o.delete(b)),destroy:()=>{(m2?"production":void 0)!=="production"&&console.warn("[DEPRECATED] The `destroy` method will be unsupported in a future version. Instead use unsubscribe function returned by subscribe. Everything will be garbage-collected if store is garbage-collected."),o.clear()}},g=l=n(r,u,y);return y},p2=n=>n?qy(n):qy,{useDebugValue:v2}=fo,{useSyncExternalStoreWithSelector:b2}=y2,x2=n=>n;function zp(n,l=x2,o){const r=b2(n.subscribe,n.getState,n.getServerState||n.getInitialState,l,o);return v2(r),r}const Xy=(n,l)=>{const o=p2(n),r=(u,f=l)=>zp(o,u,f);return Object.assign(r,o),r},_2=(n,l)=>n?Xy(n,l):Xy;function Ke(n,l){if(Object.is(n,l))return!0;if(typeof n!="object"||n===null||typeof l!="object"||l===null)return!1;if(n instanceof Map&&l instanceof Map){if(n.size!==l.size)return!1;for(const[r,u]of n)if(!Object.is(u,l.get(r)))return!1;return!0}if(n instanceof Set&&l instanceof Set){if(n.size!==l.size)return!1;for(const r of n)if(!l.has(r))return!1;return!0}const o=Object.keys(n);if(o.length!==Object.keys(l).length)return!1;for(const r of o)if(!Object.prototype.hasOwnProperty.call(l,r)||!Object.is(n[r],l[r]))return!1;return!0}var w2=Em();const Uu=I.createContext(null),S2=Uu.Provider,Dp=fn.error001("react");function Re(n,l){const o=I.useContext(Uu);if(o===null)throw new Error(Dp);return zp(o,n,l)}function Qe(){const n=I.useContext(Uu);if(n===null)throw new Error(Dp);return I.useMemo(()=>({getState:n.getState,setState:n.setState,subscribe:n.subscribe}),[n])}const Qy={display:"none"},E2={position:"absolute",width:1,height:1,margin:-1,border:0,padding:0,overflow:"hidden",clip:"rect(0px, 0px, 0px, 0px)",clipPath:"inset(100%)"},kp="react-flow__node-desc",Rp="react-flow__edge-desc",N2="react-flow__aria-live",T2=n=>n.ariaLiveMessage,A2=n=>n.ariaLabelConfig;function C2({rfId:n}){const l=Re(T2);return T.jsx("div",{id:`${N2}-${n}`,"aria-live":"assertive","aria-atomic":"true",style:E2,children:l})}function M2({rfId:n,disableKeyboardA11y:l}){const o=Re(A2);return T.jsxs(T.Fragment,{children:[T.jsx("div",{id:`${kp}-${n}`,style:Qy,children:l?o["node.a11yDescription.default"]:o["node.a11yDescription.keyboardDisabled"]}),T.jsx("div",{id:`${Rp}-${n}`,style:Qy,children:o["edge.a11yDescription.default"]}),!l&&T.jsx(C2,{rfId:n})]})}const Gu=I.forwardRef(({position:n="top-left",children:l,className:o,style:r,...u},f)=>{const d=`${n}`.split("-");return T.jsx("div",{className:it(["react-flow__panel",o,...d]),style:r,ref:f,...u,children:l})});Gu.displayName="Panel";const $y="https://reactflow.dev?utm_source=attribution";function z2({proOptions:n,position:l="bottom-right"}){return n!=null&&n.hideAttribution?null:T.jsx(Gu,{position:l,className:"react-flow__attribution","data-message":`Please only hide this attribution when you are subscribed to React Flow Pro: ${$y}`,children:T.jsx("a",{href:$y,target:"_blank",rel:"noopener noreferrer","aria-label":"React Flow attribution",children:"React Flow"})})}const D2=n=>{const l=[],o=[];for(const[,r]of n.nodeLookup)r.selected&&l.push(r.internals.userNode);for(const[,r]of n.edgeLookup)r.selected&&o.push(r);return{selectedNodes:l,selectedEdges:o}},fu=n=>n.id;function k2(n,l){return Ke(n.selectedNodes.map(fu),l.selectedNodes.map(fu))&&Ke(n.selectedEdges.map(fu),l.selectedEdges.map(fu))}function R2({onSelectionChange:n}){const l=Qe(),{selectedNodes:o,selectedEdges:r}=Re(D2,k2);return I.useEffect(()=>{const u={nodes:o,edges:r};n==null||n(u),l.getState().onSelectionChangeHandlers.forEach(f=>f(u))},[o,r,n]),null}const j2=n=>!!n.onSelectionChangeHandlers;function O2({onSelectionChange:n}){const l=Re(j2);return n||l?T.jsx(R2,{onSelectionChange:n}):null}const jp=[0,0],H2={x:0,y:0,zoom:1},B2=["nodes","edges","defaultNodes","defaultEdges","onConnect","onConnectStart","onConnectEnd","onClickConnectStart","onClickConnectEnd","nodesDraggable","autoPanOnNodeFocus","nodesConnectable","nodesFocusable","edgesFocusable","edgesReconnectable","elevateNodesOnSelect","elevateEdgesOnSelect","minZoom","maxZoom","nodeExtent","onNodesChange","onEdgesChange","elementsSelectable","connectionMode","snapGrid","snapToGrid","translateExtent","connectOnClick","defaultEdgeOptions","fitView","fitViewOptions","onNodesDelete","onEdgesDelete","onDelete","onNodeDrag","onNodeDragStart","onNodeDragStop","onSelectionDrag","onSelectionDragStart","onSelectionDragStop","onMoveStart","onMove","onMoveEnd","noPanClassName","nodeOrigin","autoPanOnConnect","autoPanOnNodeDrag","onError","connectionRadius","isValidConnection","selectNodesOnDrag","nodeDragThreshold","connectionDragThreshold","onBeforeDelete","debug","autoPanSpeed","ariaLabelConfig","zIndexMode"],Zy=[...B2,"rfId"],L2=n=>({setNodes:n.setNodes,setEdges:n.setEdges,setMinZoom:n.setMinZoom,setMaxZoom:n.setMaxZoom,setTranslateExtent:n.setTranslateExtent,setNodeExtent:n.setNodeExtent,reset:n.reset,setDefaultNodesAndEdges:n.setDefaultNodesAndEdges}),Ky={translateExtent:_o,nodeOrigin:jp,minZoom:.5,maxZoom:2,elementsSelectable:!0,noPanClassName:"nopan",rfId:"1"};function U2(n){const{setNodes:l,setEdges:o,setMinZoom:r,setMaxZoom:u,setTranslateExtent:f,setNodeExtent:d,reset:h,setDefaultNodesAndEdges:y}=Re(L2,Ke),g=Qe();I.useEffect(()=>(y(n.defaultNodes,n.defaultEdges),()=>{b.current=Ky,h()}),[]);const b=I.useRef(Ky);return I.useEffect(()=>{for(const p of Zy){const v=n[p],x=b.current[p];v!==x&&(typeof n[p]>"u"||(p==="nodes"?l(v):p==="edges"?o(v):p==="minZoom"?r(v):p==="maxZoom"?u(v):p==="translateExtent"?f(v):p==="nodeExtent"?d(v):p==="ariaLabelConfig"?g.setState({ariaLabelConfig:wS(v)}):p==="fitView"?g.setState({fitViewQueued:v}):p==="fitViewOptions"?g.setState({fitViewOptions:v}):g.setState({[p]:v})))}b.current=n},Zy.map(p=>n[p])),null}function Jy(){return typeof window>"u"||!window.matchMedia?null:window.matchMedia("(prefers-color-scheme: dark)")}function G2(n){var r;const[l,o]=I.useState(n==="system"?null:n);return I.useEffect(()=>{if(n!=="system"){o(n);return}const u=Jy(),f=()=>o(u!=null&&u.matches?"dark":"light");return f(),u==null||u.addEventListener("change",f),()=>{u==null||u.removeEventListener("change",f)}},[n]),l!==null?l:(r=Jy())!=null&&r.matches?"dark":"light"}const Iy=typeof document<"u"?document:null;function No(n=null,l={target:Iy,actInsideInputWithModifier:!0}){const[o,r]=I.useState(!1),u=I.useRef(!1),f=I.useRef(new Set([])),[d,h]=I.useMemo(()=>{if(n!==null){const g=(Array.isArray(n)?n:[n]).filter(p=>typeof p=="string").map(p=>p.replace("+",`
-`).replace(`
-
-`,`
-+`).split(`
-`)),b=g.reduce((p,v)=>p.concat(...v),[]);return[g,b]}return[[],[]]},[n]);return I.useEffect(()=>{const y=(l==null?void 0:l.target)??Iy,g=(l==null?void 0:l.actInsideInputWithModifier)??!0;if(n!==null){const b=x=>{var M,E;if(u.current=x.ctrlKey||x.metaKey||x.shiftKey||x.altKey,(!u.current||u.current&&!g)&&gp(x))return!1;const C=Fy(x.code,h);if(f.current.add(x[C]),Wy(d,f.current,!1)){const H=((E=(M=x.composedPath)==null?void 0:M.call(x))==null?void 0:E[0])||x.target,w=(H==null?void 0:H.nodeName)==="BUTTON"||(H==null?void 0:H.nodeName)==="A";l.preventDefault!==!1&&(u.current||!w)&&x.preventDefault(),r(!0)}},p=x=>{const _=Fy(x.code,h);Wy(d,f.current,!0)?(r(!1),f.current.clear()):f.current.delete(x[_]),x.key==="Meta"&&f.current.clear(),u.current=!1},v=()=>{f.current.clear(),r(!1)};return y==null||y.addEventListener("keydown",b),y==null||y.addEventListener("keyup",p),window.addEventListener("blur",v),window.addEventListener("contextmenu",v),()=>{y==null||y.removeEventListener("keydown",b),y==null||y.removeEventListener("keyup",p),window.removeEventListener("blur",v),window.removeEventListener("contextmenu",v)}}},[n,r]),o}function Wy(n,l,o){return n.filter(r=>o||r.length===l.size).some(r=>r.every(u=>l.has(u)))}function Fy(n,l){return l.includes(n)?"code":"key"}const Y2=()=>{const n=Qe();return I.useMemo(()=>({zoomIn:async l=>{const{panZoom:o}=n.getState();return o?o.scaleBy(1.2,l):!1},zoomOut:async l=>{const{panZoom:o}=n.getState();return o?o.scaleBy(1/1.2,l):!1},zoomTo:async(l,o)=>{const{panZoom:r}=n.getState();return r?r.scaleTo(l,o):!1},getZoom:()=>n.getState().transform[2],setViewport:async(l,o)=>{const{transform:[r,u,f],panZoom:d}=n.getState();return d?(await d.setViewport({x:l.x??r,y:l.y??u,zoom:l.zoom??f},o),!0):!1},getViewport:()=>{const[l,o,r]=n.getState().transform;return{x:l,y:o,zoom:r}},setCenter:async(l,o,r)=>n.getState().setCenter(l,o,r),fitBounds:async(l,o)=>{const{width:r,height:u,minZoom:f,maxZoom:d,panZoom:h}=n.getState(),y=rd(l,r,u,f,d,(o==null?void 0:o.padding)??.1);return h?(await h.setViewport(y,{duration:o==null?void 0:o.duration,ease:o==null?void 0:o.ease,interpolate:o==null?void 0:o.interpolate}),!0):!1},screenToFlowPosition:(l,o={})=>{const{transform:r,snapGrid:u,snapToGrid:f,domNode:d}=n.getState();if(!d)return l;const{x:h,y}=d.getBoundingClientRect(),g={x:l.x-h,y:l.y-y},b=o.snapGrid??u,p=o.snapToGrid??f;return Ro(g,r,p,b)},flowToScreenPosition:l=>{const{transform:o,domNode:r}=n.getState();if(!r)return l;const{x:u,y:f}=r.getBoundingClientRect(),d=ri(l,o);return{x:d.x+u,y:d.y+f}}}),[])};function Op(n,l){const o=[],r=new Map,u=[];for(const f of n)if(f.type==="add"){u.push(f);continue}else if(f.type==="remove"||f.type==="replace")r.set(f.id,[f]);else{const d=r.get(f.id);d?d.push(f):r.set(f.id,[f])}for(const f of l){const d=r.get(f.id);if(!d){o.push(f);continue}if(d[0].type==="remove")continue;if(d[0].type==="replace"){o.push({...d[0].item});continue}const h={...f};for(const y of d)V2(y,h);o.push(h)}return u.length&&u.forEach(f=>{f.index!==void 0?o.splice(f.index,0,{...f.item}):o.push({...f.item})}),o}function V2(n,l){switch(n.type){case"select":{l.selected=n.selected;break}case"position":{typeof n.position<"u"&&(l.position=n.position),typeof n.dragging<"u"&&(l.dragging=n.dragging);break}case"dimensions":{typeof n.dimensions<"u"&&(l.measured={...n.dimensions},n.setAttributes&&((n.setAttributes===!0||n.setAttributes==="width")&&(l.width=n.dimensions.width),(n.setAttributes===!0||n.setAttributes==="height")&&(l.height=n.dimensions.height))),typeof n.resizing=="boolean"&&(l.resizing=n.resizing);break}}}function Yf(n,l){return Op(n,l)}function Vf(n,l){return Op(n,l)}function Ia(n,l){return{id:n,type:"select",selected:l}}function ei(n,l=new Set,o=!1){const r=[];for(const[u,f]of n){const d=l.has(u);!(f.selected===void 0&&!d)&&f.selected!==d&&(o&&(f.selected=d),r.push(Ia(f.id,d)))}return r}function Py({items:n=[],lookup:l}){var u;const o=[],r=new Map(n.map(f=>[f.id,f]));for(const[f,d]of n.entries()){const h=l.get(d.id),y=((u=h==null?void 0:h.internals)==null?void 0:u.userNode)??h;y!==void 0&&y!==d&&o.push({id:d.id,item:d,type:"replace"}),y===void 0&&o.push({item:d,type:"add",index:f})}for(const[f]of l)r.get(f)===void 0&&o.push({id:f,type:"remove"});return o}function em(n){return{id:n.id,type:"remove"}}const q2=cp();function qf(n,l,o={}){return CS(n,l,{...o,onError:o.onError??q2})}const tm=n=>hS(n),X2=n=>ip(n);function Hp(n){return I.forwardRef(n)}const Bp=typeof window<"u"?I.useLayoutEffect:I.useEffect;function nm(n){const[l,o]=I.useState(BigInt(0)),[r]=I.useState(()=>Q2(()=>o(u=>u+BigInt(1))));return Bp(()=>{const u=r.get();u.length&&(n(u),r.reset())},[l]),r}function Q2(n){let l=[];return{get:()=>l,reset:()=>{l=[]},push:o=>{l.push(o),n()}}}const Lp=I.createContext(null);function $2({children:n}){const l=Qe(),o=I.useCallback(h=>{const{nodes:y=[],setNodes:g,hasDefaultNodes:b,onNodesChange:p,nodeLookup:v,fitViewQueued:x,onNodesChangeMiddlewareMap:_}=l.getState();let C=y;for(const E of h)C=typeof E=="function"?E(C):E;let M=Py({items:C,lookup:v});for(const E of _.values())M=E(M);b&&g(C),M.length>0?p==null||p(M):x&&window.requestAnimationFrame(()=>{const{fitViewQueued:E,nodes:H,setNodes:w}=l.getState();E&&w(H)})},[]),r=nm(o),u=I.useCallback(h=>{const{edges:y=[],setEdges:g,hasDefaultEdges:b,onEdgesChange:p,edgeLookup:v}=l.getState();let x=y;for(const _ of h)x=typeof _=="function"?_(x):_;b?g(x):p&&p(Py({items:x,lookup:v}))},[]),f=nm(u),d=I.useMemo(()=>({nodeQueue:r,edgeQueue:f}),[]);return T.jsx(Lp.Provider,{value:d,children:n})}function Z2(){const n=I.useContext(Lp);if(!n)throw new Error("useBatchContext must be used within a BatchProvider");return n}const K2=n=>!!n.panZoom;function jo(){const n=Y2(),l=Qe(),o=Z2(),r=Re(K2),u=I.useMemo(()=>{const f=p=>l.getState().nodeLookup.get(p),d=p=>{o.nodeQueue.push(p)},h=p=>{o.edgeQueue.push(p)},y=p=>{var E,H;const{nodeLookup:v,nodeOrigin:x}=l.getState(),_=tm(p)?p:v.get(p.id),C=_.parentId?dp(_.position,_.measured,_.parentId,v,x):_.position,M={..._,position:C,width:((E=_.measured)==null?void 0:E.width)??_.width,height:((H=_.measured)==null?void 0:H.height)??_.height};return So(M)},g=(p,v,x={replace:!1})=>{d(_=>_.map(C=>{if(C.id===p){const M=typeof v=="function"?v(C):v;return x.replace&&tm(M)?M:{...C,...M}}return C}))},b=(p,v,x={replace:!1})=>{h(_=>_.map(C=>{if(C.id===p){const M=typeof v=="function"?v(C):v;return x.replace&&X2(M)?M:{...C,...M}}return C}))};return{getNodes:()=>l.getState().nodes.map(p=>({...p})),getNode:p=>{var v;return(v=f(p))==null?void 0:v.internals.userNode},getInternalNode:f,getEdges:()=>{const{edges:p=[]}=l.getState();return p.map(v=>({...v}))},getEdge:p=>l.getState().edgeLookup.get(p),setNodes:d,setEdges:h,addNodes:p=>{const v=Array.isArray(p)?p:[p];o.nodeQueue.push(x=>[...x,...v])},addEdges:p=>{const v=Array.isArray(p)?p:[p];o.edgeQueue.push(x=>[...x,...v])},toObject:()=>{const{nodes:p=[],edges:v=[],transform:x}=l.getState(),[_,C,M]=x;return{nodes:p.map(E=>({...E})),edges:v.map(E=>({...E})),viewport:{x:_,y:C,zoom:M}}},deleteElements:async({nodes:p=[],edges:v=[]})=>{const{nodes:x,edges:_,onNodesDelete:C,onEdgesDelete:M,triggerNodeChanges:E,triggerEdgeChanges:H,onDelete:w,onBeforeDelete:z}=l.getState(),{nodes:G,edges:B}=await vS({nodesToRemove:p,edgesToRemove:v,nodes:x,edges:_,onBeforeDelete:z}),L=B.length>0,Q=G.length>0;if(L){const K=B.map(em);M==null||M(B),H(K)}if(Q){const K=G.map(em);C==null||C(G),E(K)}return(Q||L)&&(w==null||w({nodes:G,edges:B})),{deletedNodes:G,deletedEdges:B}},getIntersectingNodes:(p,v=!0,x)=>{const _=Ty(p),C=_?p:y(p),M=x!==void 0;return C?(x||l.getState().nodes).filter(E=>{const H=l.getState().nodeLookup.get(E.id);if(H&&!_&&(E.id===p.id||!H.internals.positionAbsolute))return!1;const w=So(M?E:H),z=Cu(w,C);return v&&z>0||z>=w.width*w.height||z>=C.width*C.height}):[]},isNodeIntersecting:(p,v,x=!0)=>{const C=Ty(p)?p:y(p);if(!C)return!1;const M=Cu(C,v);return x&&M>0||M>=v.width*v.height||M>=C.width*C.height},updateNode:g,updateNodeData:(p,v,x={replace:!1})=>{g(p,_=>{const C=typeof v=="function"?v(_):v;return x.replace?{..._,data:C}:{..._,data:{..._.data,...C}}},x)},updateEdge:b,updateEdgeData:(p,v,x={replace:!1})=>{b(p,_=>{const C=typeof v=="function"?v(_):v;return x.replace?{..._,data:C}:{..._,data:{..._.data,...C}}},x)},getNodesBounds:p=>{const{nodeLookup:v,nodeOrigin:x}=l.getState();return gS(p,{nodeLookup:v,nodeOrigin:x})},getHandleConnections:({type:p,id:v,nodeId:x})=>{var _;return Array.from(((_=l.getState().connectionLookup.get(`${x}-${p}${v?`-${v}`:""}`))==null?void 0:_.values())??[])},getNodeConnections:({type:p,handleId:v,nodeId:x})=>{var _;return Array.from(((_=l.getState().connectionLookup.get(`${x}${p?v?`-${p}-${v}`:`-${p}`:""}`))==null?void 0:_.values())??[])},fitView:async p=>{const v=l.getState().fitViewResolver??_S();return l.setState({fitViewQueued:!0,fitViewOptions:p,fitViewResolver:v}),o.nodeQueue.push(x=>[...x]),v.promise}}},[]);return I.useMemo(()=>({...u,...n,viewportInitialized:r}),[r])}const am=n=>n.selected,J2=typeof window<"u"?window:void 0;function I2({deleteKeyCode:n,multiSelectionKeyCode:l}){const o=Qe(),{deleteElements:r}=jo(),u=No(n,{actInsideInputWithModifier:!1}),f=No(l,{target:J2});I.useEffect(()=>{if(u){const{edges:d,nodes:h}=o.getState();r({nodes:h.filter(am),edges:d.filter(am)}),o.setState({nodesSelectionActive:!1})}},[u]),I.useEffect(()=>{o.setState({multiSelectionActive:f})},[f])}function W2(n){const l=Qe();I.useEffect(()=>{const o=()=>{var u,f,d,h;if(!n.current||!(((f=(u=n.current).checkVisibility)==null?void 0:f.call(u))??!0))return!1;const r=ud(n.current);(r.height===0||r.width===0)&&((h=(d=l.getState()).onError)==null||h.call(d,"004",fn.error004())),l.setState({width:r.width||500,height:r.height||500})};if(n.current){o(),window.addEventListener("resize",o);const r=new ResizeObserver(()=>o());return r.observe(n.current),()=>{window.removeEventListener("resize",o),r&&n.current&&r.unobserve(n.current)}}},[])}const Yu={position:"absolute",width:"100%",height:"100%",top:0,left:0},F2=n=>({userSelectionActive:n.userSelectionActive,lib:n.lib,connectionInProgress:n.connection.inProgress});function P2({onPaneContextMenu:n,zoomOnScroll:l=!0,zoomOnPinch:o=!0,panOnScroll:r=!1,panOnScrollSpeed:u=.5,panOnScrollMode:f=Pa.Free,zoomOnDoubleClick:d=!0,panOnDrag:h=!0,defaultViewport:y,translateExtent:g,minZoom:b,maxZoom:p,zoomActivationKeyCode:v,preventScrolling:x=!0,children:_,noWheelClassName:C,noPanClassName:M,onViewportChange:E,isControlledViewport:H,paneClickDistance:w,selectionOnDrag:z}){const G=Qe(),B=I.useRef(null),{userSelectionActive:L,lib:Q,connectionInProgress:K}=Re(F2,Ke),ue=No(v),$=I.useRef();W2(B);const ie=I.useCallback(ne=>{E==null||E({x:ne[0],y:ne[1],zoom:ne[2]}),H||G.setState({transform:ne})},[E,H]);return I.useEffect(()=>{if(B.current){$.current=l2({domNode:B.current,minZoom:b,maxZoom:p,translateExtent:g,viewport:y,onDraggingChange:A=>G.setState(j=>j.paneDragging===A?j:{paneDragging:A}),onPanZoomStart:(A,j)=>{const{onViewportChangeStart:V,onMoveStart:k}=G.getState();k==null||k(A,j),V==null||V(j)},onPanZoom:(A,j)=>{const{onViewportChange:V,onMove:k}=G.getState();k==null||k(A,j),V==null||V(j)},onPanZoomEnd:(A,j)=>{const{onViewportChangeEnd:V,onMoveEnd:k}=G.getState();k==null||k(A,j),V==null||V(j)}});const{x:ne,y:D,zoom:q}=$.current.getViewport();return G.setState({panZoom:$.current,transform:[ne,D,q],domNode:B.current.closest(".react-flow")}),()=>{var A;(A=$.current)==null||A.destroy()}}},[]),I.useEffect(()=>{var ne;(ne=$.current)==null||ne.update({onPaneContextMenu:n,zoomOnScroll:l,zoomOnPinch:o,panOnScroll:r,panOnScrollSpeed:u,panOnScrollMode:f,zoomOnDoubleClick:d,panOnDrag:h,zoomActivationKeyPressed:ue,preventScrolling:x,noPanClassName:M,userSelectionActive:L,noWheelClassName:C,lib:Q,onTransformChange:ie,connectionInProgress:K,selectionOnDrag:z,paneClickDistance:w})},[n,l,o,r,u,f,d,h,ue,x,M,L,C,Q,ie,K,z,w]),T.jsx("div",{className:"react-flow__renderer",ref:B,style:Yu,children:_})}const eE=n=>({userSelectionActive:n.userSelectionActive,userSelectionRect:n.userSelectionRect});function tE(){const{userSelectionActive:n,userSelectionRect:l}=Re(eE,Ke);return n&&l?T.jsx("div",{className:"react-flow__selection react-flow__container",style:{width:l.width,height:l.height,transform:`translate(${l.x}px, ${l.y}px)`}}):null}const _f=(n,l)=>o=>{o.target===l.current&&(n==null||n(o))},nE=n=>({userSelectionActive:n.userSelectionActive,elementsSelectable:n.elementsSelectable,dragging:n.paneDragging,panBy:n.panBy,autoPanSpeed:n.autoPanSpeed});function aE({isSelecting:n,selectionKeyPressed:l,selectionMode:o=wo.Full,panOnDrag:r,autoPanOnSelection:u,paneClickDistance:f,selectionOnDrag:d,onSelectionStart:h,onSelectionEnd:y,onPaneClick:g,onPaneContextMenu:b,onPaneScroll:p,onPaneMouseEnter:v,onPaneMouseMove:x,onPaneMouseLeave:_,children:C}){const M=I.useRef(0),E=Qe(),{userSelectionActive:H,elementsSelectable:w,dragging:z,panBy:G,autoPanSpeed:B}=Re(nE,Ke),L=w&&(n||H),Q=I.useRef(null),K=I.useRef(),ue=I.useRef(new Set),$=I.useRef(new Set),ie=I.useRef(!1),ne=I.useRef(!1),D=I.useRef({x:0,y:0}),q=I.useRef(!1),A=P=>{if(ne.current||ie.current||E.getState().connection.inProgress){ne.current=!1,ie.current=!1;return}g==null||g(P),E.getState().resetSelectedElements(),E.setState({nodesSelectionActive:!1})},j=P=>{if(Array.isArray(r)&&(r!=null&&r.includes(2))){P.preventDefault();return}b==null||b(P)},V=p?P=>p(P):void 0,k=P=>{ne.current&&(P.stopPropagation(),ne.current=!1)},Z=P=>{var $e,mt;const{domNode:Y,transform:fe}=E.getState();if(K.current=Y==null?void 0:Y.getBoundingClientRect(),!K.current)return;const he=P.target===Q.current;if(!he&&!!P.target.closest(".nokey")||!n||!(d&&he||l)||P.button!==0||!P.isPrimary)return;(mt=($e=P.target)==null?void 0:$e.setPointerCapture)==null||mt.call($e,P.pointerId),ne.current=!1;const{x:_e,y:Ce}=cn(P.nativeEvent,K.current),De=Ro({x:_e,y:Ce},fe);E.setState({userSelectionRect:{width:0,height:0,startX:De.x,startY:De.y,x:_e,y:Ce}}),he||(P.stopPropagation(),P.preventDefault())};function N(P,Y){const{userSelectionRect:fe}=E.getState();if(!fe)return;const{transform:he,nodeLookup:ge,edgeLookup:me,connectionLookup:_e,triggerNodeChanges:Ce,triggerEdgeChanges:De,defaultEdgeOptions:$e}=E.getState(),mt={x:fe.startX,y:fe.startY},{x:_t,y:wt}=ri(mt,he),kt={startX:mt.x,startY:mt.y,x:P<_t?P:_t,y:Y<wt?Y:wt,width:Math.abs(P-_t),height:Math.abs(Y-wt)},Ca=ue.current,En=$.current;ue.current=new Set(id(ge,kt,he,o===wo.Partial,!0).map(Rt=>Rt.id)),$.current=new Set;const We=($e==null?void 0:$e.selectable)??!0;for(const Rt of ue.current){const qt=_e.get(Rt);if(qt)for(const{edgeId:Xt}of qt.values()){const Qt=me.get(Xt);Qt&&(Qt.selectable??We)&&$.current.add(Xt)}}if(!Ay(Ca,ue.current)){const Rt=ei(ge,ue.current,!0);Ce(Rt)}if(!Ay(En,$.current)){const Rt=ei(me,$.current);De(Rt)}E.setState({userSelectionRect:kt,userSelectionActive:!0,nodesSelectionActive:!1})}function R(){if(!u||!K.current)return;const[P,Y]=od(D.current,K.current,B);G({x:P,y:Y}).then(fe=>{if(!ne.current||!fe){M.current=requestAnimationFrame(R);return}const{x:he,y:ge}=D.current;N(he,ge),M.current=requestAnimationFrame(R)})}const ee=()=>{cancelAnimationFrame(M.current),M.current=0,q.current=!1};I.useEffect(()=>()=>ee(),[]);const ae=P=>{const{userSelectionRect:Y,transform:fe,resetSelectedElements:he}=E.getState();if(!K.current||!Y)return;const{x:ge,y:me}=cn(P.nativeEvent,K.current);D.current={x:ge,y:me};const _e=ri({x:Y.startX,y:Y.startY},fe);if(!ne.current){const Ce=l?0:f;if(Math.hypot(ge-_e.x,me-_e.y)<=Ce)return;he(),h==null||h(P)}ne.current=!0,q.current||(R(),q.current=!0),N(ge,me)},de=P=>{var Y,fe;if(!L){P.target===Q.current&&E.getState().connection.inProgress&&(ie.current=!0);return}P.button===0&&((fe=(Y=P.target)==null?void 0:Y.releasePointerCapture)==null||fe.call(Y,P.pointerId),!H&&P.target===Q.current&&E.getState().userSelectionRect&&(A==null||A(P)),E.setState({userSelectionActive:!1,userSelectionRect:null}),ne.current&&(y==null||y(P),E.setState({nodesSelectionActive:ue.current.size>0})),ee())},se=P=>{var Y,fe;(fe=(Y=P.target)==null?void 0:Y.releasePointerCapture)==null||fe.call(Y,P.pointerId),ee()},oe=r===!0||Array.isArray(r)&&r.includes(0);return T.jsxs("div",{className:it(["react-flow__pane",{draggable:oe,dragging:z,selection:n}]),onClick:L?void 0:_f(A,Q),onContextMenu:_f(j,Q),onWheel:_f(V,Q),onPointerEnter:L?void 0:v,onPointerMove:L?ae:x,onPointerUp:de,onPointerCancel:L?se:void 0,onPointerDownCapture:L?Z:void 0,onClickCapture:L?k:void 0,onPointerLeave:_,ref:Q,style:Yu,children:[C,T.jsx(tE,{})]})}function Xf({id:n,store:l,unselect:o=!1,nodeRef:r}){const{addSelectedNodes:u,unselectNodesAndEdges:f,multiSelectionActive:d,nodeLookup:h,onError:y}=l.getState(),g=h.get(n);if(!g){y==null||y("012",fn.error012(n));return}l.setState({nodesSelectionActive:!1}),g.selected?(o||g.selected&&d)&&(f({nodes:[g],edges:[]}),requestAnimationFrame(()=>{var b;return(b=r==null?void 0:r.current)==null?void 0:b.blur()})):u([n])}function Up({nodeRef:n,disabled:l=!1,noDragClassName:o,handleSelector:r,nodeId:u,isSelectable:f,nodeClickDistance:d}){const h=Qe(),[y,g]=I.useState(!1),b=I.useRef();return I.useEffect(()=>{if(!l)return b.current=XS({getStoreItems:()=>h.getState(),onNodeMouseDown:p=>{Xf({id:p,store:h,nodeRef:n})},onDragStart:()=>{g(!0)},onDragStop:()=>{g(!1)}}),()=>{var p;(p=b.current)==null||p.destroy(),b.current=void 0}},[l,h,n]),I.useEffect(()=>{l||!n.current||!b.current||b.current.update({noDragClassName:o,handleSelector:r,domNode:n.current,isSelectable:f,nodeId:u,nodeClickDistance:d})},[o,r,l,f,n,u,d]),y}const lE=n=>l=>l.selected&&(l.draggable||n&&typeof l.draggable>"u");function Gp(){const n=Qe();return I.useCallback(o=>{const{nodeExtent:r,snapToGrid:u,snapGrid:f,nodesDraggable:d,onError:h,updateNodePositions:y,nodeLookup:g,nodeOrigin:b}=n.getState(),p=new Map,v=lE(d),x=u?f[0]:5,_=u?f[1]:5,C=o.direction.x*x*o.factor,M=o.direction.y*_*o.factor;for(const[,E]of g){if(!v(E))continue;let H={x:E.internals.positionAbsolute.x+C,y:E.internals.positionAbsolute.y+M};u&&(H=ko(H,f));const{position:w,positionAbsolute:z}=op({nodeId:E.id,nextPosition:H,nodeLookup:g,nodeExtent:r,nodeOrigin:b,onError:h});E.position=w,E.internals.positionAbsolute=z,p.set(E.id,E)}y(p)},[])}const yd=I.createContext(null),iE=yd.Provider;yd.Consumer;const Yp=()=>I.useContext(yd),oE=n=>({connectOnClick:n.connectOnClick,noPanClassName:n.noPanClassName,rfId:n.rfId}),Vp=I.createContext(null);function rE({children:n}){const l=Re(oE,Ke);return T.jsx(Vp.Provider,{value:l,children:n})}function uE(){const n=I.useContext(Vp);if(!n)throw new Error("useHandleConfig must be used within a HandleConfigProvider");return n}const sE={connectingFrom:!1,connectingTo:!1,clickConnecting:!1,isPossibleEndHandle:!0,connectionInProcess:!1,clickConnectionInProcess:!1,valid:!1},cE=(n,l,o)=>r=>{const{connectionClickStartHandle:u,connectionMode:f,connection:d}=r,{fromHandle:h,toHandle:y,isValid:g}=d;if(!h&&!u)return sE;const b=(y==null?void 0:y.nodeId)===n&&(y==null?void 0:y.id)===l&&(y==null?void 0:y.type)===o;return{connectingFrom:(h==null?void 0:h.nodeId)===n&&(h==null?void 0:h.id)===l&&(h==null?void 0:h.type)===o,connectingTo:b,clickConnecting:(u==null?void 0:u.nodeId)===n&&(u==null?void 0:u.id)===l&&(u==null?void 0:u.type)===o,isPossibleEndHandle:f===ii.Strict?(h==null?void 0:h.type)!==o:n!==(h==null?void 0:h.nodeId)||l!==(h==null?void 0:h.id),connectionInProcess:!!h,clickConnectionInProcess:!!u,valid:b&&g}};function fE({type:n="source",position:l=ve.Top,isValidConnection:o,isConnectable:r=!0,isConnectableStart:u=!0,isConnectableEnd:f=!0,id:d,onConnect:h,children:y,className:g,onMouseDown:b,onTouchStart:p,...v},x){var q,A;const _=d||null,C=n==="target",M=Qe(),E=Yp(),{connectOnClick:H,noPanClassName:w,rfId:z}=uE(),{connectingFrom:G,connectingTo:B,clickConnecting:L,isPossibleEndHandle:Q,connectionInProcess:K,clickConnectionInProcess:ue,valid:$}=Re(cE(E,_,n),Ke);E||(A=(q=M.getState()).onError)==null||A.call(q,"010",fn.error010());const ie=j=>{const{defaultEdgeOptions:V,onConnect:k,hasDefaultEdges:Z}=M.getState(),N={...V,...j};if(Z){const{edges:R,setEdges:ee,onError:ae}=M.getState();ee(qf(N,R,{onError:ae}))}k==null||k(N),h==null||h(N)},ne=j=>{if(!E)return;const V=yp(j.nativeEvent);if(u&&(V&&j.button===0||!V)){const k=M.getState();Gf.onPointerDown(j.nativeEvent,{handleDomNode:j.currentTarget,autoPanOnConnect:k.autoPanOnConnect,connectionMode:k.connectionMode,connectionRadius:k.connectionRadius,domNode:k.domNode,nodeLookup:k.nodeLookup,lib:k.lib,isTarget:C,handleId:_,nodeId:E,flowId:k.rfId,panBy:k.panBy,cancelConnection:k.cancelConnection,onConnectStart:k.onConnectStart,onConnectEnd:(...Z)=>{var N,R;return(R=(N=M.getState()).onConnectEnd)==null?void 0:R.call(N,...Z)},updateConnection:k.updateConnection,onConnect:ie,isValidConnection:o||((...Z)=>{var N,R;return((R=(N=M.getState()).isValidConnection)==null?void 0:R.call(N,...Z))??!0}),getTransform:()=>M.getState().transform,getFromHandle:()=>M.getState().connection.fromHandle,autoPanSpeed:k.autoPanSpeed,dragThreshold:k.connectionDragThreshold})}V?b==null||b(j):p==null||p(j)},D=j=>{const{onClickConnectStart:V,onClickConnectEnd:k,connectionClickStartHandle:Z,connectionMode:N,isValidConnection:R,lib:ee,rfId:ae,nodeLookup:de,connection:se}=M.getState();if(!E||!Z&&!u)return;if(!Z){V==null||V(j.nativeEvent,{nodeId:E,handleId:_,handleType:n}),M.setState({connectionClickStartHandle:{nodeId:E,type:n,id:_}});return}const oe=hp(j.target),P=o||R,{connection:Y,isValid:fe}=Gf.isValid(j.nativeEvent,{handle:{nodeId:E,id:_,type:n},connectionMode:N,fromNodeId:Z.nodeId,fromHandleId:Z.id||null,fromType:Z.type,isValidConnection:P,flowId:ae,doc:oe,lib:ee,nodeLookup:de});fe&&Y&&ie(Y);const he=structuredClone(se);delete he.inProgress,he.toPosition=he.toHandle?he.toHandle.position:null,k==null||k(j,he),M.setState({connectionClickStartHandle:null})};return T.jsx("div",{"data-handleid":_,"data-nodeid":E,"data-handlepos":l,"data-id":`${z}-${E}-${_}-${n}`,className:it(["react-flow__handle",`react-flow__handle-${l}`,"nodrag",w,g,{source:!C,target:C,connectable:r,connectablestart:u,connectableend:f,clickconnecting:L,connectingfrom:G,connectingto:B,valid:$,connectionindicator:r&&(!K||Q)&&(K||ue?f:u)}]),onMouseDown:ne,onTouchStart:ne,onClick:H?D:void 0,ref:x,...v,children:y})}const si=I.memo(Hp(fE));function dE({data:n,isConnectable:l,sourcePosition:o=ve.Bottom}){return T.jsxs(T.Fragment,{children:[n==null?void 0:n.label,T.jsx(si,{type:"source",position:o,isConnectable:l})]})}function hE({data:n,isConnectable:l,targetPosition:o=ve.Top,sourcePosition:r=ve.Bottom}){return T.jsxs(T.Fragment,{children:[T.jsx(si,{type:"target",position:o,isConnectable:l}),n==null?void 0:n.label,T.jsx(si,{type:"source",position:r,isConnectable:l})]})}function gE(){return null}function yE({data:n,isConnectable:l,targetPosition:o=ve.Top}){return T.jsxs(T.Fragment,{children:[T.jsx(si,{type:"target",position:o,isConnectable:l}),n==null?void 0:n.label]})}const Mu={ArrowUp:{x:0,y:-1},ArrowDown:{x:0,y:1},ArrowLeft:{x:-1,y:0},ArrowRight:{x:1,y:0}},lm={input:dE,default:hE,output:yE,group:gE};function mE(n){var l,o,r,u;return n.internals.handleBounds===void 0?{width:n.width??n.initialWidth??((l=n.style)==null?void 0:l.width),height:n.height??n.initialHeight??((o=n.style)==null?void 0:o.height)}:{width:n.width??((r=n.style)==null?void 0:r.width),height:n.height??((u=n.style)==null?void 0:u.height)}}const pE=n=>{const{width:l,height:o,x:r,y:u}=Do(n.nodeLookup,{filter:f=>!!f.selected});return{width:sn(l)?l:null,height:sn(o)?o:null,userSelectionActive:n.userSelectionActive,transformString:`translate(${n.transform[0]}px,${n.transform[1]}px) scale(${n.transform[2]}) translate(${r}px,${u}px)`}};function vE({onSelectionContextMenu:n,noPanClassName:l,disableKeyboardA11y:o}){const r=Qe(),{width:u,height:f,transformString:d,userSelectionActive:h}=Re(pE,Ke),y=Gp(),g=I.useRef(null);I.useEffect(()=>{var x;o||(x=g.current)==null||x.focus({preventScroll:!0})},[o]);const b=!h&&u!==null&&f!==null;if(Up({nodeRef:g,disabled:!b}),!b)return null;const p=n?x=>{const _=r.getState().nodes.filter(C=>C.selected);n(x,_)}:void 0,v=x=>{Object.prototype.hasOwnProperty.call(Mu,x.key)&&(x.preventDefault(),y({direction:Mu[x.key],factor:x.shiftKey?4:1}))};return T.jsx("div",{className:it(["react-flow__nodesselection","react-flow__container",l]),style:{transform:d},children:T.jsx("div",{ref:g,className:"react-flow__nodesselection-rect",onContextMenu:p,tabIndex:o?void 0:-1,onKeyDown:o?void 0:v,style:{width:u,height:f}})})}const im=typeof window<"u"?window:void 0,bE=n=>({nodesSelectionActive:n.nodesSelectionActive,userSelectionActive:n.userSelectionActive});function qp({children:n,onPaneClick:l,onPaneMouseEnter:o,onPaneMouseMove:r,onPaneMouseLeave:u,onPaneContextMenu:f,onPaneScroll:d,paneClickDistance:h,deleteKeyCode:y,selectionKeyCode:g,selectionOnDrag:b,selectionMode:p,onSelectionStart:v,onSelectionEnd:x,multiSelectionKeyCode:_,panActivationKeyCode:C,zoomActivationKeyCode:M,elementsSelectable:E,zoomOnScroll:H,zoomOnPinch:w,panOnScroll:z,panOnScrollSpeed:G,panOnScrollMode:B,zoomOnDoubleClick:L,panOnDrag:Q,autoPanOnSelection:K,defaultViewport:ue,translateExtent:$,minZoom:ie,maxZoom:ne,preventScrolling:D,onSelectionContextMenu:q,noWheelClassName:A,noPanClassName:j,disableKeyboardA11y:V,onViewportChange:k,isControlledViewport:Z}){const{nodesSelectionActive:N,userSelectionActive:R}=Re(bE,Ke),ee=No(g,{target:im}),ae=No(C,{target:im}),de=ae||Q,se=ae||z,oe=b&&de!==!0,P=ee||R||oe;return I2({deleteKeyCode:y,multiSelectionKeyCode:_}),T.jsx(P2,{onPaneContextMenu:f,elementsSelectable:E,zoomOnScroll:H,zoomOnPinch:w,panOnScroll:se,panOnScrollSpeed:G,panOnScrollMode:B,zoomOnDoubleClick:L,panOnDrag:!ee&&de,defaultViewport:ue,translateExtent:$,minZoom:ie,maxZoom:ne,zoomActivationKeyCode:M,preventScrolling:D,noWheelClassName:A,noPanClassName:j,onViewportChange:k,isControlledViewport:Z,paneClickDistance:h,selectionOnDrag:oe,children:T.jsxs(aE,{onSelectionStart:v,onSelectionEnd:x,onPaneClick:l,onPaneMouseEnter:o,onPaneMouseMove:r,onPaneMouseLeave:u,onPaneContextMenu:f,onPaneScroll:d,panOnDrag:de,autoPanOnSelection:K,isSelecting:!!P,selectionMode:p,selectionKeyPressed:ee,paneClickDistance:h,selectionOnDrag:oe,children:[n,N&&T.jsx(vE,{onSelectionContextMenu:q,noPanClassName:j,disableKeyboardA11y:V})]})})}qp.displayName="FlowRenderer";const xE=I.memo(qp),_E=n=>l=>n?id(l.nodeLookup,{x:0,y:0,width:l.width,height:l.height},l.transform,!0).map(o=>o.id):Array.from(l.nodeLookup.keys());function wE(n){return Re(I.useCallback(_E(n),[n]),Ke)}const SE=n=>n.updateNodeInternals;function EE(){const n=Re(SE),[l]=I.useState(()=>typeof ResizeObserver>"u"?null:new ResizeObserver(o=>{const r=new Map;o.forEach(u=>{const f=u.target.getAttribute("data-id");r.set(f,{id:f,nodeElement:u.target,force:!0})}),n(r)}));return I.useEffect(()=>()=>{l==null||l.disconnect()},[l]),l}function NE({node:n,nodeType:l,hasDimensions:o,resizeObserver:r}){const u=Qe(),f=I.useRef(null),d=I.useRef(null),h=I.useRef(n.sourcePosition),y=I.useRef(n.targetPosition),g=I.useRef(l),b=o&&!!n.internals.handleBounds;return I.useEffect(()=>{f.current&&!n.hidden&&(!b||d.current!==f.current)&&(d.current&&(r==null||r.unobserve(d.current)),r==null||r.observe(f.current),d.current=f.current)},[b,n.hidden]),I.useEffect(()=>()=>{d.current&&(r==null||r.unobserve(d.current),d.current=null)},[]),I.useEffect(()=>{if(f.current){const p=g.current!==l,v=h.current!==n.sourcePosition,x=y.current!==n.targetPosition;(p||v||x)&&(g.current=l,h.current=n.sourcePosition,y.current=n.targetPosition,u.getState().updateNodeInternals(new Map([[n.id,{id:n.id,nodeElement:f.current,force:!0}]])))}},[n.id,l,n.sourcePosition,n.targetPosition]),f}function TE({id:n,onClick:l,onMouseEnter:o,onMouseMove:r,onMouseLeave:u,onContextMenu:f,onDoubleClick:d,nodesDraggable:h,elementsSelectable:y,nodesConnectable:g,nodesFocusable:b,resizeObserver:p,noDragClassName:v,noPanClassName:x,disableKeyboardA11y:_,rfId:C,nodeTypes:M,nodeClickDistance:E,onError:H}){const{node:w,internals:z,isParent:G}=Re(P=>{const Y=P.nodeLookup.get(n),fe=P.parentLookup.has(n);return{node:Y,internals:Y.internals,isParent:fe}},Ke);let B=w.type||"default",L=(M==null?void 0:M[B])||lm[B];L===void 0&&(H==null||H("003",fn.error003(B)),B="default",L=(M==null?void 0:M.default)||lm.default);const Q=!!(w.draggable||h&&typeof w.draggable>"u"),K=!!(w.selectable||y&&typeof w.selectable>"u"),ue=!!(w.connectable||g&&typeof w.connectable>"u"),$=!!(w.focusable||b&&typeof w.focusable>"u"),ie=Qe(),ne=fp(w),D=NE({node:w,nodeType:B,hasDimensions:ne,resizeObserver:p}),q=Up({nodeRef:D,disabled:w.hidden||!Q,noDragClassName:v,handleSelector:w.dragHandle,nodeId:n,isSelectable:K,nodeClickDistance:E}),A=Gp();if(w.hidden)return null;const j=Sn(w),V=mE(w),k=K||Q||l||o||r||u,Z=o?P=>o(P,{...z.userNode}):void 0,N=r?P=>r(P,{...z.userNode}):void 0,R=u?P=>u(P,{...z.userNode}):void 0,ee=f?P=>f(P,{...z.userNode}):void 0,ae=d?P=>d(P,{...z.userNode}):void 0,de=P=>{const{selectNodesOnDrag:Y,nodeDragThreshold:fe}=ie.getState();K&&(!Y||!Q||fe>0)&&Xf({id:n,store:ie,nodeRef:D}),l&&l(P,{...z.userNode})},se=P=>{if(!(gp(P.nativeEvent)||_)){if(tp.includes(P.key)&&K){const Y=P.key==="Escape";Xf({id:n,store:ie,unselect:Y,nodeRef:D})}else if(Q&&w.selected&&Object.prototype.hasOwnProperty.call(Mu,P.key)){P.preventDefault();const{ariaLabelConfig:Y}=ie.getState();ie.setState({ariaLiveMessage:Y["node.a11yDescription.ariaLiveMessage"]({direction:P.key.replace("Arrow","").toLowerCase(),x:~~z.positionAbsolute.x,y:~~z.positionAbsolute.y})}),A({direction:Mu[P.key],factor:P.shiftKey?4:1})}}},oe=()=>{var _e;if(_||!((_e=D.current)!=null&&_e.matches(":focus-visible")))return;const{transform:P,width:Y,height:fe,autoPanOnNodeFocus:he,setCenter:ge}=ie.getState();if(!he)return;id(new Map([[n,w]]),{x:0,y:0,width:Y,height:fe},P,!0).length>0||ge(w.position.x+j.width/2,w.position.y+j.height/2,{zoom:P[2]})};return T.jsx("div",{className:it(["react-flow__node",`react-flow__node-${B}`,{[x]:Q},w.className,{selected:w.selected,selectable:K,parent:G,draggable:Q,dragging:q}]),ref:D,style:{zIndex:z.z,transform:`translate(${z.positionAbsolute.x}px,${z.positionAbsolute.y}px)`,pointerEvents:k?"all":"none",visibility:ne?"visible":"hidden",...w.style,...V},"data-id":n,"data-testid":`rf__node-${n}`,onMouseEnter:Z,onMouseMove:N,onMouseLeave:R,onContextMenu:ee,onClick:de,onDoubleClick:ae,onKeyDown:$?se:void 0,tabIndex:$?0:void 0,onFocus:$?oe:void 0,role:w.ariaRole??($?"group":void 0),"aria-roledescription":"node","aria-describedby":_?void 0:`${kp}-${C}`,"aria-label":w.ariaLabel,...w.domAttributes,children:T.jsx(iE,{value:n,children:T.jsx(L,{id:n,data:w.data,type:B,positionAbsoluteX:z.positionAbsolute.x,positionAbsoluteY:z.positionAbsolute.y,selected:w.selected??!1,selectable:K,draggable:Q,deletable:w.deletable??!0,isConnectable:ue,sourcePosition:w.sourcePosition,targetPosition:w.targetPosition,dragging:q,dragHandle:w.dragHandle,zIndex:z.z,parentId:w.parentId,...j})})})}var AE=I.memo(TE);const CE=n=>({nodesConnectable:n.nodesConnectable,nodesFocusable:n.nodesFocusable,elementsSelectable:n.elementsSelectable,onError:n.onError});function Xp(n){const{nodesConnectable:l,nodesFocusable:o,elementsSelectable:r,onError:u}=Re(CE,Ke),f=wE(n.onlyRenderVisibleElements),d=EE();return T.jsx("div",{className:"react-flow__nodes",style:Yu,children:f.map(h=>T.jsx(AE,{id:h,nodeTypes:n.nodeTypes,nodeExtent:n.nodeExtent,onClick:n.onNodeClick,onMouseEnter:n.onNodeMouseEnter,onMouseMove:n.onNodeMouseMove,onMouseLeave:n.onNodeMouseLeave,onContextMenu:n.onNodeContextMenu,onDoubleClick:n.onNodeDoubleClick,noDragClassName:n.noDragClassName,noPanClassName:n.noPanClassName,rfId:n.rfId,disableKeyboardA11y:n.disableKeyboardA11y,resizeObserver:d,nodesDraggable:n.nodesDraggable??!0,nodesConnectable:l,nodesFocusable:o,elementsSelectable:r,nodeClickDistance:n.nodeClickDistance,onError:u},h))})}Xp.displayName="NodeRenderer";const ME=I.memo(Xp);function zE(n){return Re(I.useCallback(o=>{if(!n)return o.edges.map(u=>u.id);const r=[];if(o.width&&o.height)for(const u of o.edges){const f=o.nodeLookup.get(u.source),d=o.nodeLookup.get(u.target);f&&d&&NS({sourceNode:f,targetNode:d,width:o.width,height:o.height,transform:o.transform})&&r.push(u.id)}return r},[n]),Ke)}const DE=({color:n="none",strokeWidth:l=1})=>{const o={strokeWidth:l,...n&&{stroke:n}};return T.jsx("polyline",{className:"arrow",style:o,strokeLinecap:"round",fill:"none",strokeLinejoin:"round",points:"-5,-4 0,0 -5,4"})},kE=({color:n="none",strokeWidth:l=1})=>{const o={strokeWidth:l,...n&&{stroke:n,fill:n}};return T.jsx("polyline",{className:"arrowclosed",style:o,strokeLinecap:"round",strokeLinejoin:"round",points:"-5,-4 0,0 -5,4 -5,-4"})},om={[Tu.Arrow]:DE,[Tu.ArrowClosed]:kE};function RE(n){const l=Qe();return I.useMemo(()=>{var u,f;return Object.prototype.hasOwnProperty.call(om,n)?om[n]:((f=(u=l.getState()).onError)==null||f.call(u,"009",fn.error009(n)),null)},[n])}const jE=({id:n,type:l,color:o,width:r=12.5,height:u=12.5,markerUnits:f="strokeWidth",strokeWidth:d,orient:h="auto-start-reverse"})=>{const y=RE(l);return y?T.jsx("marker",{className:"react-flow__arrowhead",id:n,markerWidth:`${r}`,markerHeight:`${u}`,viewBox:"-10 -10 20 20",markerUnits:f,orient:h,refX:"0",refY:"0",children:T.jsx(y,{color:o,strokeWidth:d})}):null},Qp=({defaultColor:n,rfId:l})=>{const o=Re(f=>f.edges),r=Re(f=>f.defaultEdgeOptions),u=I.useMemo(()=>RS(o,{id:l,defaultColor:n,defaultMarkerStart:r==null?void 0:r.markerStart,defaultMarkerEnd:r==null?void 0:r.markerEnd}),[o,r,l,n]);return u.length?T.jsx("svg",{className:"react-flow__marker","aria-hidden":"true",children:T.jsx("defs",{children:u.map(f=>T.jsx(jE,{id:f.id,type:f.type,color:f.color,width:f.width,height:f.height,markerUnits:f.markerUnits,strokeWidth:f.strokeWidth,orient:f.orient},f.id))})}):null};Qp.displayName="MarkerDefinitions";var OE=I.memo(Qp);function $p({x:n,y:l,label:o,labelStyle:r,labelShowBg:u=!0,labelBgStyle:f,labelBgPadding:d=[2,4],labelBgBorderRadius:h=2,children:y,className:g,...b}){const[p,v]=I.useState({x:1,y:0,width:0,height:0}),x=it(["react-flow__edge-textwrapper",g]),_=I.useRef(null);return I.useEffect(()=>{if(_.current){const C=_.current.getBBox();v({x:C.x,y:C.y,width:C.width,height:C.height})}},[o]),o?T.jsxs("g",{transform:`translate(${n-p.width/2} ${l-p.height/2})`,className:x,visibility:p.width?"visible":"hidden",...b,children:[u&&T.jsx("rect",{width:p.width+2*d[0],x:-d[0],y:-d[1],height:p.height+2*d[1],className:"react-flow__edge-textbg",style:f,rx:h,ry:h}),T.jsx("text",{className:"react-flow__edge-text",y:p.height/2,dy:"0.3em",ref:_,style:r,children:o}),y]}):null}$p.displayName="EdgeText";const HE=I.memo($p);function Oo({path:n,labelX:l,labelY:o,label:r,labelStyle:u,labelShowBg:f,labelBgStyle:d,labelBgPadding:h,labelBgBorderRadius:y,interactionWidth:g=20,...b}){return T.jsxs(T.Fragment,{children:[T.jsx("path",{...b,d:n,fill:"none",className:it(["react-flow__edge-path",b.className])}),g?T.jsx("path",{d:n,fill:"none",strokeOpacity:0,strokeWidth:g,className:"react-flow__edge-interaction"}):null,r&&sn(l)&&sn(o)?T.jsx(HE,{x:l,y:o,label:r,labelStyle:u,labelShowBg:f,labelBgStyle:d,labelBgPadding:h,labelBgBorderRadius:y}):null]})}function rm({pos:n,x1:l,y1:o,x2:r,y2:u}){return n===ve.Left||n===ve.Right?[.5*(l+r),o]:[l,.5*(o+u)]}function Zp({sourceX:n,sourceY:l,sourcePosition:o=ve.Bottom,targetX:r,targetY:u,targetPosition:f=ve.Top}){const[d,h]=rm({pos:o,x1:n,y1:l,x2:r,y2:u}),[y,g]=rm({pos:f,x1:r,y1:u,x2:n,y2:l}),[b,p,v,x]=mp({sourceX:n,sourceY:l,targetX:r,targetY:u,sourceControlX:d,sourceControlY:h,targetControlX:y,targetControlY:g});return[`M${n},${l} C${d},${h} ${y},${g} ${r},${u}`,b,p,v,x]}function Kp(n){return I.memo(({id:l,sourceX:o,sourceY:r,targetX:u,targetY:f,sourcePosition:d,targetPosition:h,label:y,labelStyle:g,labelShowBg:b,labelBgStyle:p,labelBgPadding:v,labelBgBorderRadius:x,style:_,markerEnd:C,markerStart:M,interactionWidth:E})=>{const[H,w,z]=Zp({sourceX:o,sourceY:r,sourcePosition:d,targetX:u,targetY:f,targetPosition:h}),G=n.isInternal?void 0:l;return T.jsx(Oo,{id:G,path:H,labelX:w,labelY:z,label:y,labelStyle:g,labelShowBg:b,labelBgStyle:p,labelBgPadding:v,labelBgBorderRadius:x,style:_,markerEnd:C,markerStart:M,interactionWidth:E})})}const BE=Kp({isInternal:!1}),Jp=Kp({isInternal:!0});BE.displayName="SimpleBezierEdge";Jp.displayName="SimpleBezierEdgeInternal";function Ip(n){return I.memo(({id:l,sourceX:o,sourceY:r,targetX:u,targetY:f,label:d,labelStyle:h,labelShowBg:y,labelBgStyle:g,labelBgPadding:b,labelBgBorderRadius:p,style:v,sourcePosition:x=ve.Bottom,targetPosition:_=ve.Top,markerEnd:C,markerStart:M,pathOptions:E,interactionWidth:H})=>{const[w,z,G]=Bf({sourceX:o,sourceY:r,sourcePosition:x,targetX:u,targetY:f,targetPosition:_,borderRadius:E==null?void 0:E.borderRadius,offset:E==null?void 0:E.offset,stepPosition:E==null?void 0:E.stepPosition}),B=n.isInternal?void 0:l;return T.jsx(Oo,{id:B,path:w,labelX:z,labelY:G,label:d,labelStyle:h,labelShowBg:y,labelBgStyle:g,labelBgPadding:b,labelBgBorderRadius:p,style:v,markerEnd:C,markerStart:M,interactionWidth:H})})}const Wp=Ip({isInternal:!1}),Fp=Ip({isInternal:!0});Wp.displayName="SmoothStepEdge";Fp.displayName="SmoothStepEdgeInternal";function Pp(n){return I.memo(({id:l,...o})=>{var u;const r=n.isInternal?void 0:l;return T.jsx(Wp,{...o,id:r,pathOptions:I.useMemo(()=>{var f;return{borderRadius:0,offset:(f=o.pathOptions)==null?void 0:f.offset}},[(u=o.pathOptions)==null?void 0:u.offset])})})}const LE=Pp({isInternal:!1}),ev=Pp({isInternal:!0});LE.displayName="StepEdge";ev.displayName="StepEdgeInternal";function tv(n){return I.memo(({id:l,sourceX:o,sourceY:r,targetX:u,targetY:f,label:d,labelStyle:h,labelShowBg:y,labelBgStyle:g,labelBgPadding:b,labelBgBorderRadius:p,style:v,markerEnd:x,markerStart:_,interactionWidth:C})=>{const[M,E,H]=vp({sourceX:o,sourceY:r,targetX:u,targetY:f}),w=n.isInternal?void 0:l;return T.jsx(Oo,{id:w,path:M,labelX:E,labelY:H,label:d,labelStyle:h,labelShowBg:y,labelBgStyle:g,labelBgPadding:b,labelBgBorderRadius:p,style:v,markerEnd:x,markerStart:_,interactionWidth:C})})}const UE=tv({isInternal:!1}),nv=tv({isInternal:!0});UE.displayName="StraightEdge";nv.displayName="StraightEdgeInternal";function av(n){return I.memo(({id:l,sourceX:o,sourceY:r,targetX:u,targetY:f,sourcePosition:d=ve.Bottom,targetPosition:h=ve.Top,label:y,labelStyle:g,labelShowBg:b,labelBgStyle:p,labelBgPadding:v,labelBgBorderRadius:x,style:_,markerEnd:C,markerStart:M,pathOptions:E,interactionWidth:H})=>{const[w,z,G]=sd({sourceX:o,sourceY:r,sourcePosition:d,targetX:u,targetY:f,targetPosition:h,curvature:E==null?void 0:E.curvature}),B=n.isInternal?void 0:l;return T.jsx(Oo,{id:B,path:w,labelX:z,labelY:G,label:y,labelStyle:g,labelShowBg:b,labelBgStyle:p,labelBgPadding:v,labelBgBorderRadius:x,style:_,markerEnd:C,markerStart:M,interactionWidth:H})})}const GE=av({isInternal:!1}),lv=av({isInternal:!0});GE.displayName="BezierEdge";lv.displayName="BezierEdgeInternal";const um={default:lv,straight:nv,step:ev,smoothstep:Fp,simplebezier:Jp},sm={sourceX:null,sourceY:null,targetX:null,targetY:null,sourcePosition:null,targetPosition:null,zIndex:void 0},YE=(n,l,o)=>o===ve.Left?n-l:o===ve.Right?n+l:n,VE=(n,l,o)=>o===ve.Top?n-l:o===ve.Bottom?n+l:n,cm="react-flow__edgeupdater";function fm({position:n,centerX:l,centerY:o,radius:r=10,onMouseDown:u,onMouseEnter:f,onMouseOut:d,type:h}){return T.jsx("circle",{onMouseDown:u,onMouseEnter:f,onMouseOut:d,className:it([cm,`${cm}-${h}`]),cx:YE(l,r,n),cy:VE(o,r,n),r,stroke:"transparent",fill:"transparent"})}function qE({isReconnectable:n,reconnectRadius:l,edge:o,sourceX:r,sourceY:u,targetX:f,targetY:d,sourcePosition:h,targetPosition:y,onReconnect:g,onReconnectStart:b,onReconnectEnd:p,setReconnecting:v,setUpdateHover:x}){const _=Qe(),C=(z,G)=>{if(z.button!==0)return;const{autoPanOnConnect:B,domNode:L,connectionMode:Q,connectionRadius:K,lib:ue,onConnectStart:$,cancelConnection:ie,nodeLookup:ne,rfId:D,panBy:q,updateConnection:A}=_.getState(),j=G.type==="target",V=(N,R)=>{v(!1),p==null||p(N,o,G.type,R)},k=N=>g==null?void 0:g(o,N),Z=(N,R)=>{v(!0),b==null||b(z,o,G.type),$==null||$(N,R)};Gf.onPointerDown(z.nativeEvent,{autoPanOnConnect:B,connectionMode:Q,connectionRadius:K,domNode:L,handleId:G.id,nodeId:G.nodeId,nodeLookup:ne,isTarget:j,edgeUpdaterType:G.type,lib:ue,flowId:D,cancelConnection:ie,panBy:q,isValidConnection:(...N)=>{var R,ee;return((ee=(R=_.getState()).isValidConnection)==null?void 0:ee.call(R,...N))??!0},onConnect:k,onConnectStart:Z,onConnectEnd:(...N)=>{var R,ee;return(ee=(R=_.getState()).onConnectEnd)==null?void 0:ee.call(R,...N)},onReconnectEnd:V,updateConnection:A,getTransform:()=>_.getState().transform,getFromHandle:()=>_.getState().connection.fromHandle,dragThreshold:_.getState().connectionDragThreshold,handleDomNode:z.currentTarget})},M=z=>C(z,{nodeId:o.target,id:o.targetHandle??null,type:"target"}),E=z=>C(z,{nodeId:o.source,id:o.sourceHandle??null,type:"source"}),H=()=>x(!0),w=()=>x(!1);return T.jsxs(T.Fragment,{children:[(n===!0||n==="source")&&T.jsx(fm,{position:h,centerX:r,centerY:u,radius:l,onMouseDown:M,onMouseEnter:H,onMouseOut:w,type:"source"}),(n===!0||n==="target")&&T.jsx(fm,{position:y,centerX:f,centerY:d,radius:l,onMouseDown:E,onMouseEnter:H,onMouseOut:w,type:"target"})]})}function XE({id:n,edgesFocusable:l,edgesReconnectable:o,elementsSelectable:r,onClick:u,onDoubleClick:f,onContextMenu:d,onMouseEnter:h,onMouseMove:y,onMouseLeave:g,reconnectRadius:b,onReconnect:p,onReconnectStart:v,onReconnectEnd:x,rfId:_,edgeTypes:C,noPanClassName:M,onError:E,disableKeyboardA11y:H}){let w=Re(ge=>ge.edgeLookup.get(n));const z=Re(ge=>ge.defaultEdgeOptions);w=z?{...z,...w}:w;let G=w.type||"default",B=(C==null?void 0:C[G])||um[G];B===void 0&&(E==null||E("011",fn.error011(G)),G="default",B=(C==null?void 0:C.default)||um.default);const L=!!(w.focusable||l&&typeof w.focusable>"u"),Q=typeof p<"u"&&(w.reconnectable||o&&typeof w.reconnectable>"u"),K=!!(w.selectable||r&&typeof w.selectable>"u"),ue=I.useRef(null),[$,ie]=I.useState(!1),[ne,D]=I.useState(!1),q=Qe(),{zIndex:A=w.zIndex,sourceX:j,sourceY:V,targetX:k,targetY:Z,sourcePosition:N,targetPosition:R}=Re(I.useCallback(ge=>{const me=ge.nodeLookup.get(w.source),_e=ge.nodeLookup.get(w.target);if(!me||!_e)return sm;const Ce=kS({id:n,sourceNode:me,targetNode:_e,sourceHandle:w.sourceHandle||null,targetHandle:w.targetHandle||null,connectionMode:ge.connectionMode,onError:E}),De=ES({selected:w.selected,zIndex:w.zIndex,sourceNode:me,targetNode:_e,elevateOnSelect:ge.elevateEdgesOnSelect,zIndexMode:ge.zIndexMode});return{...Ce||sm,zIndex:De}},[w.source,w.target,w.sourceHandle,w.targetHandle,w.selected,w.zIndex]),Ke),ee=I.useMemo(()=>w.markerStart?`url('#${Lf(w.markerStart,_)}')`:void 0,[w.markerStart,_]),ae=I.useMemo(()=>w.markerEnd?`url('#${Lf(w.markerEnd,_)}')`:void 0,[w.markerEnd,_]);if(w.hidden||j===null||V===null||k===null||Z===null)return null;const de=ge=>{var De;const{addSelectedEdges:me,unselectNodesAndEdges:_e,multiSelectionActive:Ce}=q.getState();K&&(q.setState({nodesSelectionActive:!1}),w.selected&&Ce?(_e({nodes:[],edges:[w]}),(De=ue.current)==null||De.blur()):me([n])),u&&u(ge,w)},se=f?ge=>{f(ge,{...w})}:void 0,oe=d?ge=>{d(ge,{...w})}:void 0,P=h?ge=>{h(ge,{...w})}:void 0,Y=y?ge=>{y(ge,{...w})}:void 0,fe=g?ge=>{g(ge,{...w})}:void 0,he=ge=>{var me;if(!H&&tp.includes(ge.key)&&K){const{unselectNodesAndEdges:_e,addSelectedEdges:Ce}=q.getState();ge.key==="Escape"?((me=ue.current)==null||me.blur(),_e({edges:[w]})):Ce([n])}};return T.jsx("svg",{style:{zIndex:A},children:T.jsxs("g",{className:it(["react-flow__edge",`react-flow__edge-${G}`,w.className,M,{selected:w.selected,animated:w.animated,inactive:!K&&!u,updating:$,selectable:K}]),onClick:de,onDoubleClick:se,onContextMenu:oe,onMouseEnter:P,onMouseMove:Y,onMouseLeave:fe,onKeyDown:L?he:void 0,tabIndex:L?0:void 0,role:w.ariaRole??(L?"group":"img"),"aria-roledescription":"edge","data-id":n,"data-testid":`rf__edge-${n}`,"aria-label":w.ariaLabel===null?void 0:w.ariaLabel||`Edge from ${w.source} to ${w.target}`,"aria-describedby":L?`${Rp}-${_}`:void 0,ref:ue,...w.domAttributes,children:[!ne&&T.jsx(B,{id:n,source:w.source,target:w.target,type:w.type,selected:w.selected,animated:w.animated,selectable:K,deletable:w.deletable??!0,label:w.label,labelStyle:w.labelStyle,labelShowBg:w.labelShowBg,labelBgStyle:w.labelBgStyle,labelBgPadding:w.labelBgPadding,labelBgBorderRadius:w.labelBgBorderRadius,sourceX:j,sourceY:V,targetX:k,targetY:Z,sourcePosition:N,targetPosition:R,data:w.data,style:w.style,sourceHandleId:w.sourceHandle,targetHandleId:w.targetHandle,markerStart:ee,markerEnd:ae,pathOptions:"pathOptions"in w?w.pathOptions:void 0,interactionWidth:w.interactionWidth}),Q&&T.jsx(qE,{edge:w,isReconnectable:Q,reconnectRadius:b,onReconnect:p,onReconnectStart:v,onReconnectEnd:x,sourceX:j,sourceY:V,targetX:k,targetY:Z,sourcePosition:N,targetPosition:R,setUpdateHover:ie,setReconnecting:D})]})})}var QE=I.memo(XE);const $E=n=>({edgesFocusable:n.edgesFocusable,edgesReconnectable:n.edgesReconnectable,elementsSelectable:n.elementsSelectable,connectionMode:n.connectionMode,onError:n.onError});function iv({defaultMarkerColor:n,onlyRenderVisibleElements:l,rfId:o,edgeTypes:r,noPanClassName:u,onReconnect:f,onEdgeContextMenu:d,onEdgeMouseEnter:h,onEdgeMouseMove:y,onEdgeMouseLeave:g,onEdgeClick:b,reconnectRadius:p,onEdgeDoubleClick:v,onReconnectStart:x,onReconnectEnd:_,disableKeyboardA11y:C}){const{edgesFocusable:M,edgesReconnectable:E,elementsSelectable:H,onError:w}=Re($E,Ke),z=zE(l);return T.jsxs("div",{className:"react-flow__edges",children:[T.jsx(OE,{defaultColor:n,rfId:o}),z.map(G=>T.jsx(QE,{id:G,edgesFocusable:M,edgesReconnectable:E,elementsSelectable:H,noPanClassName:u,onReconnect:f,onContextMenu:d,onMouseEnter:h,onMouseMove:y,onMouseLeave:g,onClick:b,reconnectRadius:p,onDoubleClick:v,onReconnectStart:x,onReconnectEnd:_,rfId:o,onError:w,edgeTypes:r,disableKeyboardA11y:C},G))]})}iv.displayName="EdgeRenderer";const ZE=I.memo(iv),dm=n=>`translate(${n[0]}px,${n[1]}px) scale(${n[2]})`;function KE({children:n}){const l=Qe(),o=I.useRef(null),[r]=I.useState(()=>l.getState().transform);return Bp(()=>{let u=null;const f=()=>{const d=l.getState().transform;u&&d[0]===u[0]&&d[1]===u[1]&&d[2]===u[2]||(u=d,o.current&&(o.current.style.transform=dm(d)))};return f(),l.subscribe(f)},[l]),T.jsx("div",{ref:o,className:"react-flow__viewport xyflow__viewport react-flow__container",style:{transform:dm(r)},children:n})}function JE(n){const l=jo(),o=I.useRef(!1);I.useEffect(()=>{!o.current&&l.viewportInitialized&&n&&(setTimeout(()=>n(l),1),o.current=!0)},[n,l.viewportInitialized])}const IE=n=>{var l;return(l=n.panZoom)==null?void 0:l.syncViewport};function WE(n){const l=Re(IE),o=Qe();return I.useEffect(()=>{n&&(l==null||l(n),o.setState({transform:[n.x,n.y,n.zoom]}))},[n,l]),null}function FE(n){return n.connection.inProgress?{...n.connection,to:Ro(n.connection.to,n.transform)}:{...n.connection}}function PE(n){return FE}function e3(n){const l=PE();return Re(l,Ke)}const t3=n=>({nodesConnectable:n.nodesConnectable,isValid:n.connection.isValid,inProgress:n.connection.inProgress,width:n.width,height:n.height});function n3({containerStyle:n,style:l,type:o,component:r}){const{nodesConnectable:u,width:f,height:d,isValid:h,inProgress:y}=Re(t3,Ke);return!(f&&u&&y)?null:T.jsx("svg",{style:n,width:f,height:d,className:"react-flow__connectionline react-flow__container",children:T.jsx("g",{className:it(["react-flow__connection",lp(h)]),children:T.jsx(ov,{style:l,type:o,CustomComponent:r,isValid:h})})})}const ov=({style:n,type:l=Ta.Bezier,CustomComponent:o,isValid:r})=>{const{inProgress:u,from:f,fromNode:d,fromHandle:h,fromPosition:y,to:g,toNode:b,toHandle:p,toPosition:v,pointer:x}=e3();if(!u)return;if(o)return T.jsx(o,{connectionLineType:l,connectionLineStyle:n,fromNode:d,fromHandle:h,fromX:f.x,fromY:f.y,toX:g.x,toY:g.y,fromPosition:y,toPosition:v,connectionStatus:lp(r),toNode:b,toHandle:p,pointer:x});let _="";const C={sourceX:f.x,sourceY:f.y,sourcePosition:y,targetX:g.x,targetY:g.y,targetPosition:v};switch(l){case Ta.Bezier:[_]=sd(C);break;case Ta.SimpleBezier:[_]=Zp(C);break;case Ta.Step:[_]=Bf({...C,borderRadius:0});break;case Ta.SmoothStep:[_]=Bf(C);break;default:[_]=vp(C)}return T.jsx("path",{d:_,fill:"none",className:"react-flow__connection-path",style:n})};ov.displayName="ConnectionLine";const a3={};function hm(n=a3){I.useRef(n),Qe(),I.useEffect(()=>{},[n])}function l3(){Qe(),I.useRef(!1),I.useEffect(()=>{},[])}function rv({nodeTypes:n,edgeTypes:l,onInit:o,onNodeClick:r,onEdgeClick:u,onNodeDoubleClick:f,onEdgeDoubleClick:d,onNodeMouseEnter:h,onNodeMouseMove:y,onNodeMouseLeave:g,onNodeContextMenu:b,onSelectionContextMenu:p,onSelectionStart:v,onSelectionEnd:x,connectionLineType:_,connectionLineStyle:C,connectionLineComponent:M,connectionLineContainerStyle:E,selectionKeyCode:H,selectionOnDrag:w,selectionMode:z,multiSelectionKeyCode:G,panActivationKeyCode:B,zoomActivationKeyCode:L,deleteKeyCode:Q,onlyRenderVisibleElements:K,elementsSelectable:ue,defaultViewport:$,translateExtent:ie,minZoom:ne,maxZoom:D,preventScrolling:q,defaultMarkerColor:A,zoomOnScroll:j,zoomOnPinch:V,panOnScroll:k,panOnScrollSpeed:Z,panOnScrollMode:N,zoomOnDoubleClick:R,panOnDrag:ee,autoPanOnSelection:ae,onPaneClick:de,onPaneMouseEnter:se,onPaneMouseMove:oe,onPaneMouseLeave:P,onPaneScroll:Y,onPaneContextMenu:fe,paneClickDistance:he,nodeClickDistance:ge,onEdgeContextMenu:me,onEdgeMouseEnter:_e,onEdgeMouseMove:Ce,onEdgeMouseLeave:De,reconnectRadius:$e,onReconnect:mt,onReconnectStart:_t,onReconnectEnd:wt,noDragClassName:kt,noWheelClassName:Ca,noPanClassName:En,disableKeyboardA11y:We,nodeExtent:Rt,rfId:qt,viewport:Xt,onViewportChange:Qt,nodesDraggable:ci}){return hm(n),hm(l),l3(),JE(o),WE(Xt),T.jsx(xE,{onPaneClick:de,onPaneMouseEnter:se,onPaneMouseMove:oe,onPaneMouseLeave:P,onPaneContextMenu:fe,onPaneScroll:Y,paneClickDistance:he,deleteKeyCode:Q,selectionKeyCode:H,selectionOnDrag:w,selectionMode:z,onSelectionStart:v,onSelectionEnd:x,multiSelectionKeyCode:G,panActivationKeyCode:B,zoomActivationKeyCode:L,elementsSelectable:ue,zoomOnScroll:j,zoomOnPinch:V,zoomOnDoubleClick:R,panOnScroll:k,panOnScrollSpeed:Z,panOnScrollMode:N,panOnDrag:ee,autoPanOnSelection:ae,defaultViewport:$,translateExtent:ie,minZoom:ne,maxZoom:D,onSelectionContextMenu:p,preventScrolling:q,noDragClassName:kt,noWheelClassName:Ca,noPanClassName:En,disableKeyboardA11y:We,onViewportChange:Qt,isControlledViewport:!!Xt,children:T.jsxs(KE,{children:[T.jsx(ZE,{edgeTypes:l,onEdgeClick:u,onEdgeDoubleClick:d,onReconnect:mt,onReconnectStart:_t,onReconnectEnd:wt,onlyRenderVisibleElements:K,onEdgeContextMenu:me,onEdgeMouseEnter:_e,onEdgeMouseMove:Ce,onEdgeMouseLeave:De,reconnectRadius:$e,defaultMarkerColor:A,noPanClassName:En,disableKeyboardA11y:We,rfId:qt}),T.jsx(n3,{style:C,type:_,component:M,containerStyle:E}),T.jsx("div",{className:"react-flow__edgelabel-renderer"}),T.jsx(ME,{nodeTypes:n,onNodeClick:r,onNodeDoubleClick:f,onNodeMouseEnter:h,onNodeMouseMove:y,onNodeMouseLeave:g,onNodeContextMenu:b,nodeClickDistance:ge,onlyRenderVisibleElements:K,noPanClassName:En,noDragClassName:kt,disableKeyboardA11y:We,nodeExtent:Rt,rfId:qt,nodesDraggable:ci}),T.jsx("div",{className:"react-flow__viewport-portal"})]})})}rv.displayName="GraphView";const i3=I.memo(rv),o3=cp(),gm=({nodes:n,edges:l,defaultNodes:o,defaultEdges:r,width:u,height:f,fitView:d,fitViewOptions:h,minZoom:y=.5,maxZoom:g=2,nodeOrigin:b,nodeExtent:p,zIndexMode:v="basic"}={})=>{const x=new Map,_=new Map,C=new Map,M=new Map,E=r??l??[],H=o??n??[],w=b??[0,0],z=p??_o;_p(C,M,E);const{nodesInitialized:G}=Uf(H,x,_,{nodeOrigin:w,nodeExtent:z,zIndexMode:v});let B=[0,0,1];if(d&&u&&f){const L=Do(x,{filter:$=>!!(($.width||$.initialWidth)&&($.height||$.initialHeight))}),{x:Q,y:K,zoom:ue}=rd(L,u,f,y,g,(h==null?void 0:h.padding)??.1);B=[Q,K,ue]}return{rfId:"1",width:u??0,height:f??0,transform:B,nodes:H,nodesInitialized:G,nodeLookup:x,parentLookup:_,edges:E,edgeLookup:M,connectionLookup:C,onNodesChange:null,onEdgesChange:null,hasDefaultNodes:o!==void 0,hasDefaultEdges:r!==void 0,panZoom:null,minZoom:y,maxZoom:g,translateExtent:_o,nodeExtent:z,nodesSelectionActive:!1,userSelectionActive:!1,userSelectionRect:null,connectionMode:ii.Strict,domNode:null,paneDragging:!1,noPanClassName:"nopan",nodeOrigin:w,nodeDragThreshold:1,connectionDragThreshold:1,snapGrid:[15,15],snapToGrid:!1,nodesDraggable:!0,nodesConnectable:!0,nodesFocusable:!0,edgesFocusable:!0,edgesReconnectable:!0,elementsSelectable:!0,elevateNodesOnSelect:!0,elevateEdgesOnSelect:!0,selectNodesOnDrag:!0,multiSelectionActive:!1,fitViewQueued:d??!1,fitViewOptions:h,fitViewResolver:null,connection:{...ap},connectionClickStartHandle:null,connectOnClick:!0,ariaLiveMessage:"",autoPanOnConnect:!0,autoPanOnNodeDrag:!0,autoPanOnNodeFocus:!0,autoPanSpeed:15,connectionRadius:20,onError:o3,isValidConnection:void 0,onSelectionChangeHandlers:[],lib:"react",debug:!1,ariaLabelConfig:np,zIndexMode:v,onNodesChangeMiddlewareMap:new Map,onEdgesChangeMiddlewareMap:new Map}},r3=({nodes:n,edges:l,defaultNodes:o,defaultEdges:r,width:u,height:f,fitView:d,fitViewOptions:h,minZoom:y,maxZoom:g,nodeOrigin:b,nodeExtent:p,zIndexMode:v})=>_2((x,_)=>{async function C(){const{nodeLookup:M,panZoom:E,fitViewOptions:H,fitViewResolver:w,width:z,height:G,minZoom:B,maxZoom:L}=_();E&&(await pS({nodes:M,width:z,height:G,panZoom:E,minZoom:B,maxZoom:L},H),w==null||w.resolve(!0),x({fitViewResolver:null}))}return{...gm({nodes:n,edges:l,width:u,height:f,fitView:d,fitViewOptions:h,minZoom:y,maxZoom:g,nodeOrigin:b,nodeExtent:p,defaultNodes:o,defaultEdges:r,zIndexMode:v}),setNodes:M=>{const{nodeLookup:E,parentLookup:H,nodeOrigin:w,elevateNodesOnSelect:z,fitViewQueued:G,zIndexMode:B,nodesSelectionActive:L}=_(),{nodesInitialized:Q,hasSelectedNodes:K}=Uf(M,E,H,{nodeOrigin:w,nodeExtent:p,elevateNodesOnSelect:z,checkEquality:!0,zIndexMode:B}),ue=L&&K;G&&Q?(C(),x({nodes:M,nodesInitialized:Q,fitViewQueued:!1,fitViewOptions:void 0,nodesSelectionActive:ue})):x({nodes:M,nodesInitialized:Q,nodesSelectionActive:ue})},setEdges:M=>{const{connectionLookup:E,edgeLookup:H}=_();_p(E,H,M),x({edges:M})},setDefaultNodesAndEdges:(M,E)=>{if(M){const{setNodes:H}=_();H(M),x({hasDefaultNodes:!0})}if(E){const{setEdges:H}=_();H(E),x({hasDefaultEdges:!0})}},updateNodeInternals:M=>{const{triggerNodeChanges:E,nodeLookup:H,parentLookup:w,domNode:z,nodeOrigin:G,nodeExtent:B,debug:L,fitViewQueued:Q,zIndexMode:K}=_(),{changes:ue,updatedInternals:$}=GS(M,H,w,z,G,B,K);$&&(HS(H,w,{nodeOrigin:G,nodeExtent:B,zIndexMode:K}),Q?(C(),x({fitViewQueued:!1,fitViewOptions:void 0})):x({}),(ue==null?void 0:ue.length)>0&&(L&&console.log("React Flow: trigger node changes",ue),E==null||E(ue)))},updateNodePositions:(M,E=!1)=>{const H=[];let w=[];const{nodeLookup:z,triggerNodeChanges:G,connection:B,updateConnection:L,onNodesChangeMiddlewareMap:Q}=_();for(const[K,ue]of M){const $=z.get(K),ie=!!($!=null&&$.expandParent&&($!=null&&$.parentId)&&(ue!=null&&ue.position)),ne={id:K,type:"position",position:ie?{x:Math.max(0,ue.position.x),y:Math.max(0,ue.position.y)}:ue.position,dragging:E};if($&&B.inProgress&&B.fromNode.id===$.id){const D=ll($,B.fromHandle,ve.Left,!0);L({...B,from:D})}ie&&$.parentId&&H.push({id:K,parentId:$.parentId,rect:{...ue.internals.positionAbsolute,width:ue.measured.width??0,height:ue.measured.height??0}}),w.push(ne)}if(H.length>0){const{parentLookup:K,nodeOrigin:ue}=_(),$=gd(H,z,K,ue);w.push(...$)}for(const K of Q.values())w=K(w);G(w)},triggerNodeChanges:M=>{const{onNodesChange:E,setNodes:H,nodes:w,hasDefaultNodes:z,debug:G}=_();if(M!=null&&M.length){if(z){const B=Yf(M,w);H(B)}G&&console.log("React Flow: trigger node changes",M),E==null||E(M)}},triggerEdgeChanges:M=>{const{onEdgesChange:E,setEdges:H,edges:w,hasDefaultEdges:z,debug:G}=_();if(M!=null&&M.length){if(z){const B=Vf(M,w);H(B)}G&&console.log("React Flow: trigger edge changes",M),E==null||E(M)}},addSelectedNodes:M=>{const{multiSelectionActive:E,edgeLookup:H,nodeLookup:w,triggerNodeChanges:z,triggerEdgeChanges:G}=_();if(E){const B=M.map(L=>Ia(L,!0));z(B);return}z(ei(w,new Set([...M]),!0)),G(ei(H))},addSelectedEdges:M=>{const{multiSelectionActive:E,edgeLookup:H,nodeLookup:w,triggerNodeChanges:z,triggerEdgeChanges:G}=_();if(E){const B=M.map(L=>Ia(L,!0));G(B);return}G(ei(H,new Set([...M]))),z(ei(w,new Set,!0))},unselectNodesAndEdges:({nodes:M,edges:E}={})=>{const{edges:H,nodes:w,nodeLookup:z,triggerNodeChanges:G,triggerEdgeChanges:B}=_(),L=M||w,Q=E||H,K=[];for(const $ of L){if(!$.selected)continue;const ie=z.get($.id);ie&&(ie.selected=!1),K.push(Ia($.id,!1))}const ue=[];for(const $ of Q)$.selected&&ue.push(Ia($.id,!1));G(K),B(ue)},setMinZoom:M=>{const{panZoom:E,maxZoom:H}=_();E==null||E.setScaleExtent([M,H]),x({minZoom:M})},setMaxZoom:M=>{const{panZoom:E,minZoom:H}=_();E==null||E.setScaleExtent([H,M]),x({maxZoom:M})},setTranslateExtent:M=>{var E;(E=_().panZoom)==null||E.setTranslateExtent(M),x({translateExtent:M})},resetSelectedElements:()=>{const{edges:M,nodes:E,triggerNodeChanges:H,triggerEdgeChanges:w,elementsSelectable:z}=_();if(!z)return;const G=E.reduce((L,Q)=>Q.selected?[...L,Ia(Q.id,!1)]:L,[]),B=M.reduce((L,Q)=>Q.selected?[...L,Ia(Q.id,!1)]:L,[]);H(G),w(B)},setNodeExtent:M=>{const{nodes:E,nodeLookup:H,parentLookup:w,nodeOrigin:z,elevateNodesOnSelect:G,nodeExtent:B,zIndexMode:L}=_();M[0][0]===B[0][0]&&M[0][1]===B[0][1]&&M[1][0]===B[1][0]&&M[1][1]===B[1][1]||(Uf(E,H,w,{nodeOrigin:z,nodeExtent:M,elevateNodesOnSelect:G,checkEquality:!1,zIndexMode:L}),x({nodeExtent:M}))},panBy:M=>{const{transform:E,width:H,height:w,panZoom:z,translateExtent:G}=_();return YS({delta:M,panZoom:z,transform:E,translateExtent:G,width:H,height:w})},setCenter:async(M,E,H)=>{const{width:w,height:z,maxZoom:G,panZoom:B}=_();if(!B)return!1;const L=typeof(H==null?void 0:H.zoom)<"u"?H.zoom:G;return await B.setViewport({x:w/2-M*L,y:z/2-E*L,zoom:L},{duration:H==null?void 0:H.duration,ease:H==null?void 0:H.ease,interpolate:H==null?void 0:H.interpolate}),!0},cancelConnection:()=>{x({connection:{...ap}})},updateConnection:M=>{x({connection:M})},reset:()=>x({...gm()})}},Object.is);function uv({initialNodes:n,initialEdges:l,defaultNodes:o,defaultEdges:r,initialWidth:u,initialHeight:f,initialMinZoom:d,initialMaxZoom:h,initialFitViewOptions:y,fitView:g,nodeOrigin:b,nodeExtent:p,zIndexMode:v,children:x}){const[_]=I.useState(()=>r3({nodes:n,edges:l,defaultNodes:o,defaultEdges:r,width:u,height:f,fitView:g,minZoom:d,maxZoom:h,fitViewOptions:y,nodeOrigin:b,nodeExtent:p,zIndexMode:v}));return T.jsx(S2,{value:_,children:T.jsx($2,{children:T.jsx(rE,{children:x})})})}function u3({children:n,nodes:l,edges:o,defaultNodes:r,defaultEdges:u,width:f,height:d,fitView:h,fitViewOptions:y,minZoom:g,maxZoom:b,nodeOrigin:p,nodeExtent:v,zIndexMode:x}){return I.useContext(Uu)?T.jsx(T.Fragment,{children:n}):T.jsx(uv,{initialNodes:l,initialEdges:o,defaultNodes:r,defaultEdges:u,initialWidth:f,initialHeight:d,fitView:h,initialFitViewOptions:y,initialMinZoom:g,initialMaxZoom:b,nodeOrigin:p,nodeExtent:v,zIndexMode:x,children:n})}const s3={width:"100%",height:"100%",overflow:"hidden",position:"relative",zIndex:0};function c3({nodes:n,edges:l,defaultNodes:o,defaultEdges:r,className:u,nodeTypes:f,edgeTypes:d,onNodeClick:h,onEdgeClick:y,onInit:g,onMove:b,onMoveStart:p,onMoveEnd:v,onConnect:x,onConnectStart:_,onConnectEnd:C,onClickConnectStart:M,onClickConnectEnd:E,onNodeMouseEnter:H,onNodeMouseMove:w,onNodeMouseLeave:z,onNodeContextMenu:G,onNodeDoubleClick:B,onNodeDragStart:L,onNodeDrag:Q,onNodeDragStop:K,onNodesDelete:ue,onEdgesDelete:$,onDelete:ie,onSelectionChange:ne,onSelectionDragStart:D,onSelectionDrag:q,onSelectionDragStop:A,onSelectionContextMenu:j,onSelectionStart:V,onSelectionEnd:k,onBeforeDelete:Z,connectionMode:N,connectionLineType:R=Ta.Bezier,connectionLineStyle:ee,connectionLineComponent:ae,connectionLineContainerStyle:de,deleteKeyCode:se="Backspace",selectionKeyCode:oe="Shift",selectionOnDrag:P=!1,selectionMode:Y=wo.Full,panActivationKeyCode:fe="Space",multiSelectionKeyCode:he=Eo()?"Meta":"Control",zoomActivationKeyCode:ge=Eo()?"Meta":"Control",snapToGrid:me,snapGrid:_e,onlyRenderVisibleElements:Ce=!1,selectNodesOnDrag:De,nodesDraggable:$e,autoPanOnNodeFocus:mt,nodesConnectable:_t,nodesFocusable:wt,nodeOrigin:kt=jp,edgesFocusable:Ca,edgesReconnectable:En,elementsSelectable:We=!0,defaultViewport:Rt=H2,minZoom:qt=.5,maxZoom:Xt=2,translateExtent:Qt=_o,preventScrolling:ci=!0,nodeExtent:ul,defaultMarkerColor:Vu="#b1b1b7",zoomOnScroll:qu=!0,zoomOnPinch:Ma=!0,panOnScroll:pt=!1,panOnScrollSpeed:hn=.5,panOnScrollMode:vt=Pa.Free,zoomOnDoubleClick:Xu=!0,panOnDrag:Qu=!0,onPaneClick:$u,onPaneMouseEnter:sl,onPaneMouseMove:cl,onPaneMouseLeave:fl,onPaneScroll:Nn,onPaneContextMenu:dl,paneClickDistance:za=1,nodeClickDistance:Zu=0,children:Ho,onReconnect:fi,onReconnectStart:Da,onReconnectEnd:Ku,onEdgeContextMenu:Bo,onEdgeDoubleClick:Lo,onEdgeMouseEnter:Uo,onEdgeMouseMove:di,onEdgeMouseLeave:hi,reconnectRadius:Go=10,onNodesChange:Yo,onEdgesChange:gn,noDragClassName:ot="nodrag",noWheelClassName:gt="nowheel",noPanClassName:Tn="nopan",fitView:hl,fitViewOptions:Vo,connectOnClick:Ju,attributionPosition:qo,proOptions:ka,defaultEdgeOptions:gi,elevateNodesOnSelect:Kn=!0,elevateEdgesOnSelect:Jn=!1,disableKeyboardA11y:In=!1,autoPanOnConnect:Wn,autoPanOnNodeDrag:et,autoPanOnSelection:Xo=!0,autoPanSpeed:Qo,connectionRadius:An,isValidConnection:Fn,onError:Iu,style:$o,id:yi,nodeDragThreshold:Wu,connectionDragThreshold:gl,viewport:yl,onViewportChange:tn,width:St,height:Zo,colorMode:Fu="light",debug:mi,onScroll:Ra,ariaLabelConfig:ml,zIndexMode:Ko="basic",...Et},pi){const pl=yi||"1",vi=G2(Fu),Pn=I.useCallback(bi=>{bi.currentTarget.scrollTo({top:0,left:0,behavior:"instant"}),Ra==null||Ra(bi)},[Ra]);return T.jsx("div",{"data-testid":"rf__wrapper",...Et,onScroll:Pn,style:{...$o,...s3},ref:pi,className:it(["react-flow",u,vi]),id:yi,role:"application",children:T.jsxs(u3,{nodes:n,edges:l,width:St,height:Zo,fitView:hl,fitViewOptions:Vo,minZoom:qt,maxZoom:Xt,nodeOrigin:kt,nodeExtent:ul,zIndexMode:Ko,children:[T.jsx(U2,{nodes:n,edges:l,defaultNodes:o,defaultEdges:r,onConnect:x,onConnectStart:_,onConnectEnd:C,onClickConnectStart:M,onClickConnectEnd:E,nodesDraggable:$e,autoPanOnNodeFocus:mt,nodesConnectable:_t,nodesFocusable:wt,edgesFocusable:Ca,edgesReconnectable:En,elementsSelectable:We,elevateNodesOnSelect:Kn,elevateEdgesOnSelect:Jn,minZoom:qt,maxZoom:Xt,nodeExtent:ul,onNodesChange:Yo,onEdgesChange:gn,snapToGrid:me,snapGrid:_e,connectionMode:N,translateExtent:Qt,connectOnClick:Ju,defaultEdgeOptions:gi,fitView:hl,fitViewOptions:Vo,onNodesDelete:ue,onEdgesDelete:$,onDelete:ie,onNodeDragStart:L,onNodeDrag:Q,onNodeDragStop:K,onSelectionDrag:q,onSelectionDragStart:D,onSelectionDragStop:A,onMove:b,onMoveStart:p,onMoveEnd:v,noPanClassName:Tn,nodeOrigin:kt,rfId:pl,autoPanOnConnect:Wn,autoPanOnNodeDrag:et,autoPanSpeed:Qo,onError:Iu,connectionRadius:An,isValidConnection:Fn,selectNodesOnDrag:De,nodeDragThreshold:Wu,connectionDragThreshold:gl,onBeforeDelete:Z,debug:mi,ariaLabelConfig:ml,zIndexMode:Ko}),T.jsx(i3,{onInit:g,onNodeClick:h,onEdgeClick:y,onNodeMouseEnter:H,onNodeMouseMove:w,onNodeMouseLeave:z,onNodeContextMenu:G,onNodeDoubleClick:B,nodeTypes:f,edgeTypes:d,connectionLineType:R,connectionLineStyle:ee,connectionLineComponent:ae,connectionLineContainerStyle:de,selectionKeyCode:oe,selectionOnDrag:P,selectionMode:Y,deleteKeyCode:se,multiSelectionKeyCode:he,panActivationKeyCode:fe,zoomActivationKeyCode:ge,onlyRenderVisibleElements:Ce,defaultViewport:Rt,translateExtent:Qt,minZoom:qt,maxZoom:Xt,preventScrolling:ci,zoomOnScroll:qu,zoomOnPinch:Ma,zoomOnDoubleClick:Xu,panOnScroll:pt,panOnScrollSpeed:hn,panOnScrollMode:vt,panOnDrag:Qu,autoPanOnSelection:Xo,onPaneClick:$u,onPaneMouseEnter:sl,onPaneMouseMove:cl,onPaneMouseLeave:fl,onPaneScroll:Nn,onPaneContextMenu:dl,paneClickDistance:za,nodeClickDistance:Zu,onSelectionContextMenu:j,onSelectionStart:V,onSelectionEnd:k,onReconnect:fi,onReconnectStart:Da,onReconnectEnd:Ku,onEdgeContextMenu:Bo,onEdgeDoubleClick:Lo,onEdgeMouseEnter:Uo,onEdgeMouseMove:di,onEdgeMouseLeave:hi,reconnectRadius:Go,defaultMarkerColor:Vu,noDragClassName:ot,noWheelClassName:gt,noPanClassName:Tn,rfId:pl,disableKeyboardA11y:In,nodeExtent:ul,viewport:yl,onViewportChange:tn,nodesDraggable:$e}),T.jsx(O2,{onSelectionChange:ne}),Ho,T.jsx(z2,{proOptions:ka,position:qo}),T.jsx(M2,{rfId:pl,disableKeyboardA11y:In})]})})}var f3=Hp(c3);const d3=n=>{var l;return(l=n.domNode)==null?void 0:l.querySelector(".react-flow__edgelabel-renderer")};function h3({children:n}){const l=Re(d3);return l?w2.createPortal(n,l):null}function g3({dimensions:n,lineWidth:l,variant:o,className:r}){return T.jsx("path",{strokeWidth:l,d:`M${n[0]/2} 0 V${n[1]} M0 ${n[1]/2} H${n[0]}`,className:it(["react-flow__background-pattern",o,r])})}function y3({radius:n,className:l}){return T.jsx("circle",{cx:n,cy:n,r:n,className:it(["react-flow__background-pattern","dots",l])})}var Aa;(function(n){n.Lines="lines",n.Dots="dots",n.Cross="cross"})(Aa||(Aa={}));const m3={[Aa.Dots]:1,[Aa.Lines]:1,[Aa.Cross]:6},p3=n=>({transform:n.transform,patternId:`pattern-${n.rfId}`});function sv({id:n,variant:l=Aa.Dots,gap:o=20,size:r,lineWidth:u=1,offset:f=0,color:d,bgColor:h,style:y,className:g,patternClassName:b}){const p=I.useRef(null),{transform:v,patternId:x}=Re(p3,Ke),_=r||m3[l],C=l===Aa.Dots,M=l===Aa.Cross,E=Array.isArray(o)?o:[o,o],H=[E[0]*v[2]||1,E[1]*v[2]||1],w=_*v[2],z=Array.isArray(f)?f:[f,f],G=M?[w,w]:H,B=[z[0]*v[2]||1+G[0]/2,z[1]*v[2]||1+G[1]/2],L=`${x}${n||""}`;return T.jsxs("svg",{className:it(["react-flow__background",g]),style:{...y,...Yu,"--xy-background-color-props":h,"--xy-background-pattern-color-props":d},ref:p,"data-testid":"rf__background",children:[T.jsx("pattern",{id:L,x:v[0]%H[0],y:v[1]%H[1],width:H[0],height:H[1],patternUnits:"userSpaceOnUse",patternTransform:`translate(-${B[0]},-${B[1]})`,children:C?T.jsx(y3,{radius:w/2,className:b}):T.jsx(g3,{dimensions:G,lineWidth:u,variant:l,className:b})}),T.jsx("rect",{x:"0",y:"0",width:"100%",height:"100%",fill:`url(#${L})`})]})}sv.displayName="Background";const v3=I.memo(sv);function b3(){return T.jsx("svg",{xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 32 32",children:T.jsx("path",{d:"M32 18.133H18.133V32h-4.266V18.133H0v-4.266h13.867V0h4.266v13.867H32z"})})}function x3(){return T.jsx("svg",{xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 32 5",children:T.jsx("path",{d:"M0 0h32v4.2H0z"})})}function _3(){return T.jsx("svg",{xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 32 30",children:T.jsx("path",{d:"M3.692 4.63c0-.53.4-.938.939-.938h5.215V0H4.708C2.13 0 0 2.054 0 4.63v5.216h3.692V4.631zM27.354 0h-5.2v3.692h5.17c.53 0 .984.4.984.939v5.215H32V4.631A4.624 4.624 0 0027.354 0zm.954 24.83c0 .532-.4.94-.939.94h-5.215v3.768h5.215c2.577 0 4.631-2.13 4.631-4.707v-5.139h-3.692v5.139zm-23.677.94c-.531 0-.939-.4-.939-.94v-5.138H0v5.139c0 2.577 2.13 4.707 4.708 4.707h5.138V25.77H4.631z"})})}function w3(){return T.jsx("svg",{xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 25 32",children:T.jsx("path",{d:"M21.333 10.667H19.81V7.619C19.81 3.429 16.38 0 12.19 0 8 0 4.571 3.429 4.571 7.619v3.048H3.048A3.056 3.056 0 000 13.714v15.238A3.056 3.056 0 003.048 32h18.285a3.056 3.056 0 003.048-3.048V13.714a3.056 3.056 0 00-3.048-3.047zM12.19 24.533a3.056 3.056 0 01-3.047-3.047 3.056 3.056 0 013.047-3.048 3.056 3.056 0 013.048 3.048 3.056 3.056 0 01-3.048 3.047zm4.724-13.866H7.467V7.619c0-2.59 2.133-4.724 4.723-4.724 2.591 0 4.724 2.133 4.724 4.724v3.048z"})})}function S3(){return T.jsx("svg",{xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 25 32",children:T.jsx("path",{d:"M21.333 10.667H19.81V7.619C19.81 3.429 16.38 0 12.19 0c-4.114 1.828-1.37 2.133.305 2.438 1.676.305 4.42 2.59 4.42 5.181v3.048H3.047A3.056 3.056 0 000 13.714v15.238A3.056 3.056 0 003.048 32h18.285a3.056 3.056 0 003.048-3.048V13.714a3.056 3.056 0 00-3.048-3.047zM12.19 24.533a3.056 3.056 0 01-3.047-3.047 3.056 3.056 0 013.047-3.048 3.056 3.056 0 013.048 3.048 3.056 3.056 0 01-3.048 3.047z"})})}function du({children:n,className:l,...o}){return T.jsx("button",{type:"button",className:it(["react-flow__controls-button",l]),...o,children:n})}const E3=n=>({isInteractive:n.nodesDraggable||n.nodesConnectable||n.elementsSelectable,minZoomReached:n.transform[2]<=n.minZoom,maxZoomReached:n.transform[2]>=n.maxZoom,ariaLabelConfig:n.ariaLabelConfig});function cv({style:n,showZoom:l=!0,showFitView:o=!0,showInteractive:r=!0,fitViewOptions:u,onZoomIn:f,onZoomOut:d,onFitView:h,onInteractiveChange:y,className:g,children:b,position:p="bottom-left",orientation:v="vertical","aria-label":x}){const _=Qe(),{isInteractive:C,minZoomReached:M,maxZoomReached:E,ariaLabelConfig:H}=Re(E3,Ke),{zoomIn:w,zoomOut:z,fitView:G}=jo(),B=()=>{w(),f==null||f()},L=()=>{z(),d==null||d()},Q=()=>{G(u),h==null||h()},K=()=>{_.setState({nodesDraggable:!C,nodesConnectable:!C,elementsSelectable:!C}),y==null||y(!C)},ue=v==="horizontal"?"horizontal":"vertical";return T.jsxs(Gu,{className:it(["react-flow__controls",ue,g]),position:p,style:n,"data-testid":"rf__controls","aria-label":x??H["controls.ariaLabel"],children:[l&&T.jsxs(T.Fragment,{children:[T.jsx(du,{onClick:B,className:"react-flow__controls-zoomin",title:H["controls.zoomIn.ariaLabel"],"aria-label":H["controls.zoomIn.ariaLabel"],disabled:E,children:T.jsx(b3,{})}),T.jsx(du,{onClick:L,className:"react-flow__controls-zoomout",title:H["controls.zoomOut.ariaLabel"],"aria-label":H["controls.zoomOut.ariaLabel"],disabled:M,children:T.jsx(x3,{})})]}),o&&T.jsx(du,{className:"react-flow__controls-fitview",onClick:Q,title:H["controls.fitView.ariaLabel"],"aria-label":H["controls.fitView.ariaLabel"],children:T.jsx(_3,{})}),r&&T.jsx(du,{className:"react-flow__controls-interactive",onClick:K,title:H["controls.interactive.ariaLabel"],"aria-label":H["controls.interactive.ariaLabel"],children:C?T.jsx(S3,{}):T.jsx(w3,{})}),b]})}cv.displayName="Controls";const N3=I.memo(cv);function T3({id:n,x:l,y:o,width:r,height:u,style:f,color:d,strokeColor:h,strokeWidth:y,className:g,borderRadius:b,shapeRendering:p,selected:v,onClick:x}){const{background:_,backgroundColor:C}=f||{},M=d||_||C;return T.jsx("rect",{className:it(["react-flow__minimap-node",{selected:v},g]),x:l,y:o,rx:b,ry:b,width:r,height:u,style:{fill:M,stroke:h,strokeWidth:y},shapeRendering:p,onClick:x?E=>x(E,n):void 0})}const A3=I.memo(T3),C3=n=>n.nodes.map(l=>l.id),wf=n=>n instanceof Function?n:()=>n;function M3({nodeStrokeColor:n,nodeColor:l,nodeClassName:o="",nodeBorderRadius:r=5,nodeStrokeWidth:u,nodeComponent:f=A3,onClick:d}){const h=Re(C3,Ke),y=wf(l),g=wf(n),b=wf(o),p=typeof window>"u"||window.chrome?"crispEdges":"geometricPrecision";return T.jsx(T.Fragment,{children:h.map(v=>T.jsx(D3,{id:v,nodeColorFunc:y,nodeStrokeColorFunc:g,nodeClassNameFunc:b,nodeBorderRadius:r,nodeStrokeWidth:u,NodeComponent:f,onClick:d,shapeRendering:p},v))})}function z3({id:n,nodeColorFunc:l,nodeStrokeColorFunc:o,nodeClassNameFunc:r,nodeBorderRadius:u,nodeStrokeWidth:f,shapeRendering:d,NodeComponent:h,onClick:y}){const{node:g,x:b,y:p,width:v,height:x}=Re(_=>{const C=_.nodeLookup.get(n);if(!C)return{node:void 0,x:0,y:0,width:0,height:0};const M=C.internals.userNode,{x:E,y:H}=C.internals.positionAbsolute,{width:w,height:z}=Sn(M);return{node:M,x:E,y:H,width:w,height:z}},Ke);return!g||g.hidden||!fp(g)?null:T.jsx(h,{x:b,y:p,width:v,height:x,style:g.style,selected:!!g.selected,className:r(g),color:l(g),borderRadius:u,strokeColor:o(g),strokeWidth:f,shapeRendering:d,onClick:y,id:g.id})}const D3=I.memo(z3);var k3=I.memo(M3);const R3=200,j3=150,O3=n=>!n.hidden,H3=n=>{const l={x:-n.transform[0]/n.transform[2],y:-n.transform[1]/n.transform[2],width:n.width/n.transform[2],height:n.height/n.transform[2]};return{viewBB:l,boundingRect:n.nodeLookup.size>0?up(Do(n.nodeLookup,{filter:O3}),l):l,rfId:n.rfId,panZoom:n.panZoom,translateExtent:n.translateExtent,flowWidth:n.width,flowHeight:n.height,ariaLabelConfig:n.ariaLabelConfig}},ym=(n,l)=>n.x===l.x&&n.y===l.y&&n.width===l.width&&n.height===l.height,B3=(n,l)=>ym(n.viewBB,l.viewBB)&&ym(n.boundingRect,l.boundingRect)&&n.rfId===l.rfId&&n.panZoom===l.panZoom&&n.translateExtent===l.translateExtent&&n.flowWidth===l.flowWidth&&n.flowHeight===l.flowHeight&&n.ariaLabelConfig===l.ariaLabelConfig,L3="react-flow__minimap-desc";function fv({style:n,className:l,nodeStrokeColor:o,nodeColor:r,nodeClassName:u="",nodeBorderRadius:f=5,nodeStrokeWidth:d,nodeComponent:h,bgColor:y,maskColor:g,maskStrokeColor:b,maskStrokeWidth:p,position:v="bottom-right",onClick:x,onNodeClick:_,pannable:C=!1,zoomable:M=!1,ariaLabel:E,inversePan:H,zoomStep:w=1,offsetScale:z=5}){const G=Qe(),B=I.useRef(null),{boundingRect:L,viewBB:Q,rfId:K,panZoom:ue,translateExtent:$,flowWidth:ie,flowHeight:ne,ariaLabelConfig:D}=Re(H3,B3),q=(n==null?void 0:n.width)??R3,A=(n==null?void 0:n.height)??j3,j=L.width/q,V=L.height/A,k=Math.max(j,V),Z=k*q,N=k*A,R=z*k,ee=L.x-(Z-L.width)/2-R,ae=L.y-(N-L.height)/2-R,de=Z+R*2,se=N+R*2,oe=`${L3}-${K}`,P=I.useRef(0),Y=I.useRef();P.current=k,I.useEffect(()=>{if(B.current&&ue)return Y.current=IS({domNode:B.current,panZoom:ue,getTransform:()=>G.getState().transform,getViewScale:()=>P.current}),()=>{var me;(me=Y.current)==null||me.destroy()}},[ue]),I.useEffect(()=>{var me;(me=Y.current)==null||me.update({translateExtent:$,width:ie,height:ne,inversePan:H,pannable:C,zoomStep:w,zoomable:M})},[C,M,H,w,$,ie,ne]);const fe=x?me=>{var De;const[_e,Ce]=((De=Y.current)==null?void 0:De.pointer(me))||[0,0];x(me,{x:_e,y:Ce})}:void 0,he=_?I.useCallback((me,_e)=>{const Ce=G.getState().nodeLookup.get(_e).internals.userNode;_(me,Ce)},[]):void 0,ge=E??D["minimap.ariaLabel"];return T.jsx(Gu,{position:v,style:{...n,"--xy-minimap-background-color-props":typeof y=="string"?y:void 0,"--xy-minimap-mask-background-color-props":typeof g=="string"?g:void 0,"--xy-minimap-mask-stroke-color-props":typeof b=="string"?b:void 0,"--xy-minimap-mask-stroke-width-props":typeof p=="number"?p*k:void 0,"--xy-minimap-node-background-color-props":typeof r=="string"?r:void 0,"--xy-minimap-node-stroke-color-props":typeof o=="string"?o:void 0,"--xy-minimap-node-stroke-width-props":typeof d=="number"?d:void 0},className:it(["react-flow__minimap",l]),"data-testid":"rf__minimap",children:T.jsxs("svg",{width:q,height:A,viewBox:`${ee} ${ae} ${de} ${se}`,className:"react-flow__minimap-svg",role:"img","aria-labelledby":oe,ref:B,onClick:fe,children:[ge&&T.jsx("title",{id:oe,children:ge}),T.jsx(k3,{onClick:he,nodeColor:r,nodeStrokeColor:o,nodeBorderRadius:f,nodeClassName:u,nodeStrokeWidth:d,nodeComponent:h}),T.jsx("path",{className:"react-flow__minimap-mask",d:`M${ee-R},${ae-R}h${de+R*2}v${se+R*2}h${-de-R*2}z
-        M${Q.x},${Q.y}h${Q.width}v${Q.height}h${-Q.width}z`,fillRule:"evenodd",pointerEvents:"none"})]})})}fv.displayName="MiniMap";const U3=I.memo(fv),G3=n=>l=>n?`${Math.max(1/l.transform[2],1)}`:void 0,Y3={[ui.Line]:"right",[ui.Handle]:"bottom-right"};function V3({nodeId:n,position:l,variant:o=ui.Handle,className:r,style:u=void 0,children:f,color:d,minWidth:h=10,minHeight:y=10,maxWidth:g=Number.MAX_VALUE,maxHeight:b=Number.MAX_VALUE,keepAspectRatio:p=!1,resizeDirection:v,autoScale:x=!0,shouldResize:_,onResizeStart:C,onResize:M,onResizeEnd:E}){const H=Yp(),w=typeof n=="string"?n:H,z=Qe(),G=I.useRef(null),B=o===ui.Handle,L=Re(I.useCallback(G3(B&&x),[B,x]),Ke),Q=I.useRef(null),K=l??Y3[o];I.useEffect(()=>{if(!(!G.current||!w))return Q.current||(Q.current=s2({domNode:G.current,nodeId:w,getStoreItems:()=>{const{nodeLookup:$,transform:ie,snapGrid:ne,snapToGrid:D,nodeOrigin:q,domNode:A}=z.getState();return{nodeLookup:$,transform:ie,snapGrid:ne,snapToGrid:D,nodeOrigin:q,paneDomNode:A}},onChange:($,ie)=>{const{triggerNodeChanges:ne,nodeLookup:D,parentLookup:q,nodeOrigin:A}=z.getState(),j=[],V={x:$.x,y:$.y},k=D.get(w);if(k&&k.expandParent&&k.parentId){const Z=k.origin??A,N=$.width??k.measured.width??0,R=$.height??k.measured.height??0,ee={id:k.id,parentId:k.parentId,rect:{width:N,height:R,...dp({x:$.x??k.position.x,y:$.y??k.position.y},{width:N,height:R},k.parentId,D,Z)}},ae=gd([ee],D,q,A);j.push(...ae),V.x=$.x?Math.max(Z[0]*N,$.x):void 0,V.y=$.y?Math.max(Z[1]*R,$.y):void 0}if(V.x!==void 0&&V.y!==void 0){const Z={id:w,type:"position",position:{...V}};j.push(Z)}if($.width!==void 0&&$.height!==void 0){const N={id:w,type:"dimensions",resizing:!0,setAttributes:v?v==="horizontal"?"width":"height":!0,dimensions:{width:$.width,height:$.height}};j.push(N)}for(const Z of ie){const N={...Z,type:"position"};j.push(N)}ne(j)},onEnd:({width:$,height:ie})=>{const ne={id:w,type:"dimensions",resizing:!1,dimensions:{width:$,height:ie}};z.getState().triggerNodeChanges([ne])}})),Q.current.update({controlPosition:K,boundaries:{minWidth:h,minHeight:y,maxWidth:g,maxHeight:b},keepAspectRatio:p,resizeDirection:v,onResizeStart:C,onResize:M,onResizeEnd:E,shouldResize:_}),()=>{var $;($=Q.current)==null||$.destroy()}},[K,h,y,g,b,p,C,M,E,_]);const ue=K.split("-");return T.jsx("div",{className:it(["react-flow__resize-control","nodrag",...ue,o,r]),ref:G,style:{...u,scale:L,...d&&{[B?"backgroundColor":"borderColor"]:d}},children:f})}I.memo(V3);const mm=n=>{let l;const o=new Set,r=(g,b)=>{const p=typeof g=="function"?g(l):g;if(!Object.is(p,l)){const v=l;l=b??(typeof p!="object"||p===null)?p:Object.assign({},l,p),o.forEach(x=>x(l,v))}},u=()=>l,h={setState:r,getState:u,getInitialState:()=>y,subscribe:g=>(o.add(g),()=>o.delete(g))},y=l=n(r,u,h);return h},q3=(n=>n?mm(n):mm),X3=n=>n;function Q3(n,l=X3){const o=fo.useSyncExternalStore(n.subscribe,fo.useCallback(()=>l(n.getState()),[n,l]),fo.useCallback(()=>l(n.getInitialState()),[n,l]));return fo.useDebugValue(o),o}const pm=n=>{const l=q3(n),o=r=>Q3(l,r);return Object.assign(o,l),o},dv=(n=>n?pm(n):pm),rl="/api/v1/workflows";async function en(n,l){const o=await fetch(n,{credentials:"include",headers:{"Content-Type":"application/json",...l==null?void 0:l.headers},...l});if(!o.ok){const r=await o.json().catch(()=>({detail:o.statusText}));throw new Error(r.detail||`HTTP ${o.status}`)}if(o.status!==204)return o.json()}function $3(n=50,l=0,o){const r=new URLSearchParams({limit:String(n),offset:String(l)});return en(`${rl}?${r}`)}function Qf(n){return en(`${rl}/${n}`)}function Sf(n){return en(rl,{method:"POST",body:JSON.stringify(n)})}function $f(n,l){return en(`${rl}/${n}`,{method:"PUT",body:JSON.stringify(l)})}function Z3(n){return en(`${rl}/${n}`,{method:"DELETE"})}function K3(){return en(`${rl}/modules`)}function J3(n){return en(`${rl}/${n}/usage`)}function I3(n){return en(`/api/v1/projects/${n}/input-sources`)}function W3(n){return en(`/api/v1/projects/${n}/bindings`)}function F3(n,l){return en(`/api/v1/projects/${n}/bindings`,{method:"PUT",body:JSON.stringify(l)})}function P3(){return en("/api/v1/devices/input-sources")}const ut={input:"#3b82f6",hand3d:"#06b6d4",annotation:"#f97316",review:"#f59e0b",export:"#22c55e"},il=new Map,eN={rgb_hand_3d:"rgb_to_2d_bare_hand",black_hand_rgb_3d:"rgb_to_2d_black_glove",stereo_triangulate:"rgbd_to_3d_bare_hand",black_glove_hand:"rgbd_to_3d_black_glove"},Zf={annotation:"Human Annotation",human_review:"Human Review",rgb_to_2d_bare_hand:"RGB_TO_2D_BareHand",rgb_to_2d_black_glove:"RGB_TO_2D_BlackGlove",rgbd_to_3d_bare_hand:"RGB-D_3D_BareHand",rgbd_to_3d_black_glove:"RGB-D_3D_BlackGlove"},tN={rgb_camera:{inputs:[],outputs:[{key:"video",label:"RGB Video"}]},mono_camera:{inputs:[],outputs:[{key:"video",label:"RGB Video"}]},fisheye_camera:{inputs:[],outputs:[{key:"video",label:"RGB Video"}]},rgbd_camera:{inputs:[],outputs:[{key:"video",label:"RGB Video"},{key:"depth",label:"Depth"}]},stereo_camera:{inputs:[],outputs:[{key:"video_left",label:"Left RGB Video"},{key:"video_right",label:"Right RGB Video"}]},stereo_rgbd_camera:{inputs:[],outputs:[{key:"video_left",label:"Left RGB Video"},{key:"video_right",label:"Right RGB Video"},{key:"depth",label:"Depth"}]},glove_sensor:{inputs:[],outputs:[{key:"sensor_data",label:"Glove Sensor Data"}]},gripper_device:{inputs:[],outputs:[{key:"rgb_video",label:"RGB Video"},{key:"gripper_state",label:"ESP Gripper State"},{key:"slam_trajectory",label:"SLAM Trajectory"},{key:"tactile_force_matrices",label:"Left and Right Force Matrices"}]},mediapipe_hand:{inputs:[{key:"video",label:"RGB Video"}],outputs:[{key:"hand_keypoints",label:"Hand 2D"}]},annotation:{inputs:[{key:"data",label:"RGB Video"}],outputs:[{key:"annotation",label:"Annotation"}]},ai_annotation:{inputs:[{key:"data",label:"RGB Video"}],outputs:[{key:"annotation",label:"Annotation"}]},rgb_to_2d_bare_hand:{inputs:[{key:"video",label:"RGB Video"}],outputs:[{key:"hand_keypoints",label:"Hand 2D"}]},rgb_to_2d_black_glove:{inputs:[{key:"video",label:"RGB Video"}],outputs:[{key:"hand_keypoints",label:"Hand 2D"}]},rgbd_to_3d_bare_hand:{inputs:[{key:"video",label:"RGB Video"},{key:"depth",label:"Depth"}],outputs:[{key:"hand_3d",label:"Hand 3D"}]},rgbd_to_3d_black_glove:{inputs:[{key:"video",label:"RGB Video"},{key:"depth",label:"Depth"}],outputs:[{key:"hand_3d",label:"Hand 3D"}]},human_review:{inputs:[{key:"data",label:"Review Target"}],outputs:[{key:"reviewed",label:"Reviewed Data"}]},ai_quality_review:{inputs:[{key:"data",label:"Quality Review Target"}],outputs:[{key:"reviewed",label:"Reviewed Data"}]},lerobot_export:{inputs:[{key:"data",label:"Exportable Data"}],outputs:[{key:"dataset",label:"Dataset"}]},hdf5_export:{inputs:[{key:"data",label:"Exportable Data"}],outputs:[{key:"dataset",label:"Dataset"}]}};function ol(n){const l=String(n||"").trim();return eN[l.toLowerCase()]||l}function nN(n){const l=ol(n.type),o=l===n.type?n:{...n,type:l,slug:l};il.set(l,Zf[l]?{...o,label:Zf[l]}:o)}function hv(n){return il.get(ol(n))}function gv(){return Array.from(il.values())}function aN(n){const l=n==="process"?["annotation","ai_annotation","rgb_to_2d_bare_hand","rgb_to_2d_black_glove","rgbd_to_3d_bare_hand","rgbd_to_3d_black_glove","mediapipe_hand"]:[];return Array.from(il.values()).filter(o=>o.category===n).sort((o,r)=>{const u=l.indexOf(o.type),f=l.indexOf(r.type);return u<0&&f<0?0:u<0?1:f<0?-1:u-f})}function lN(n,l){if(!(n!=null&&n.length))return l||[];if(!(l!=null&&l.length))return n;const o=new Set(n.map(r=>r.name));return[...n,...l.filter(r=>!o.has(r.name))]}function iN(n){for(const l of n){const o=ol(l.type||l.slug||"");if(!o||!l.category||!l.label)continue;const r=il.get(o),u=tN[o];il.set(o,{type:o,slug:o,version:l.version||"1.0",category:l.category,label:Zf[o]||l.label,icon:l.icon||"ant-design:appstore-outlined",color:l.color||"#64748b",description:l.description??(r==null?void 0:r.description),inputs:(u==null?void 0:u.inputs)||l.inputs||(r==null?void 0:r.inputs)||[],outputs:(u==null?void 0:u.outputs)||l.outputs||(r==null?void 0:r.outputs)||[],defaultConfig:l.defaultConfig||l.default_config||{},configSchema:lN(l.configSchema,r==null?void 0:r.configSchema),executionTarget:l.executionTarget,capabilities:l.capabilities||[]})}}function oN(){var l,o;let n=1;for(const r of il.values()){const u=(((l=r.inputs)==null?void 0:l.length)||0)+(((o=r.outputs)==null?void 0:o.length)||0);u>n&&(n=u)}return n}const rN=[{type:"rgb_camera",category:"input",label:"RGB Camera",icon:"ant-design:video-camera-outlined",color:ut.input,description:"Single-view RGB camera input. Fisheye and other lens variants use this same device category.",inputs:[],outputs:[{key:"video",label:"RGB Video"}],defaultConfig:{position:"",source_key:"",fps:30}},{type:"mono_camera",category:"input",label:"RGB Camera",icon:"ant-design:video-camera-outlined",color:ut.input,description:"Single-view RGB input (including fisheye and RGB-D color streams). Device name is optional; blank auto-detects the batch video.",inputs:[],outputs:[{key:"video",label:"RGB Video"}],defaultConfig:{source_key:"",fps:30}},{type:"rgbd_camera",category:"input",label:"RGB-D Camera",icon:"ant-design:video-camera-outlined",color:ut.input,description:"RGB-D camera input. Select the physical device after its uploaded metadata is available; the depth stream is paired by the backend.",inputs:[],outputs:[{key:"video",label:"RGB Video"},{key:"depth",label:"Depth"}],defaultConfig:{source_key:"",fps:30}},{type:"fisheye_camera",category:"input",label:"RGB Camera",icon:"ant-design:video-camera-outlined",color:ut.input,description:"Historical fisheye input alias. New workflows use Mono RGB with lens=fisheye.",inputs:[],outputs:[{key:"video",label:"RGB Video"}],defaultConfig:{position:"",source_key:"",fps:30}},{type:"stereo_camera",category:"input",label:"Stereo RGB Camera",icon:"ant-design:video-camera-outlined",color:ut.input,description:"Stereo video capture (left + right). Device names optional — blank auto-detects the stereo pair. Connect either port once: both Left and Right edges are created together.",inputs:[],outputs:[{key:"video_left",label:"Left RGB Video"},{key:"video_right",label:"Right RGB Video"}],defaultConfig:{source_keys:"",source_key:"",fps:30}},{type:"stereo_rgbd_camera",category:"input",label:"Stereo RGB-D Camera",icon:"ant-design:video-camera-outlined",color:ut.input,description:"Stereo RGB-D input with left/right RGB video and a real depth stream. Connect Depth to RGB-D 3D processing when metric 3D is required.",inputs:[],outputs:[{key:"video_left",label:"Left RGB Video"},{key:"video_right",label:"Right RGB Video"},{key:"depth",label:"Depth"}],defaultConfig:{source_keys:"",source_key:"",fps:30}},{type:"glove_sensor",category:"input",label:"Glove Sensor",icon:"ant-design:edit-outlined",color:ut.input,description:"Glove sensor (pressure/joint data, no video). Connect its sensor data directly to AI Quality Review for sensor checks.",inputs:[],outputs:[{key:"sensor_data",label:"Glove Sensor Data"}],defaultConfig:{source_key:"",device:"SenseGlove",hand:"both",fps:60}},{type:"gripper_device",category:"input",label:"UMI Gripper",icon:"ant-design:robot-outlined",color:ut.input,description:"Composite acquisition source. Publishes one gripper RGB video, ESP32 grip state, SLAM trajectory, and paired left/right 250×250×3 force matrices to downstream workflow nodes.",inputs:[],outputs:[{key:"rgb_video",label:"RGB Video"},{key:"gripper_state",label:"ESP Gripper State"},{key:"slam_trajectory",label:"SLAM Trajectory"},{key:"tactile_force_matrices",label:"Left and Right Force Matrices"}],defaultConfig:{source_key:"",fps:30}},{type:"mediapipe_hand",category:"process",label:"MediaPipe Hand",icon:"ant-design:aim-outlined",color:ut.hand3d,description:"Skeleton detection. Accepts VIDEO input only (mono or stereo camera); glove sensor data cannot connect here.",inputs:[{key:"video",label:"RGB Video"}],outputs:[{key:"hand_keypoints",label:"Hand 2D"}],defaultConfig:{model_complexity:1,min_detection_conf:.5,min_tracking_conf:.5,max_hands:2}},{type:"annotation",category:"process",label:"Human Annotation",icon:"ant-design:field-time-outlined",color:ut.annotation,description:"Frame-level annotation on RGB video. Glove sensor data is not an annotation input.",inputs:[{key:"data",label:"RGB Video"}],outputs:[{key:"annotation",label:"Annotation"}],defaultConfig:{type:"frame_level",auto_label:!0}},{type:"ai_annotation",category:"process",label:"AI Annotation",icon:"ant-design:robot-outlined",color:ut.annotation,description:"AI-assisted annotation on RGB video. Glove sensor data is not an annotation input.",inputs:[{key:"data",label:"RGB Video"}],outputs:[{key:"annotation",label:"Annotation"}],defaultConfig:{mode:"signal_vlm",min_confidence:.7,prompt_language:"zh",max_segments:50,vlm_provider:"local",api_vendor:"kimi",api_model:"kimi-k3",api_key:"",api_base_url:""},configSchema:[{name:"prompt_language",type:"select",label:"Label language",default:"zh",options:["zh","en"]},{name:"vlm_provider",type:"select",label:"VLM provider",default:"local",options:["local","api"]},{name:"api_vendor",type:"select",label:"API vendor",default:"kimi",options:["kimi","qwen","siliconflow"]},{name:"api_model",type:"string",label:"API model",default:"kimi-k3"},{name:"api_base_url",type:"string",label:"API base URL",default:""}]},{type:"rgbd_to_3d_bare_hand",category:"process",label:"RGB-D_3D_BareHand",icon:"ant-design:deployment-unit-outlined",color:ut.hand3d,description:"Metric 3D bare-hand keypoints from RGB video plus a matched depth stream.",inputs:[{key:"video",label:"RGB Video"},{key:"depth",label:"Depth"}],outputs:[{key:"hand_3d",label:"Hand 3D"}],defaultConfig:{mode:"auto"}},{type:"rgb_to_2d_bare_hand",category:"process",label:"RGB_TO_2D_BareHand",icon:"ant-design:deployment-unit-outlined",color:ut.hand3d,description:"2D bare-hand keypoints from RGB video. The optional 3D view is display-only and is not exported as metric 3D.",inputs:[{key:"video",label:"RGB Video"}],outputs:[{key:"hand_keypoints",label:"Hand 2D"}],defaultConfig:{max_hands:2,min_detection_conf:.1,min_presence_conf:.1,min_tracking_conf:.5,device:"auto",smooth:!0,preview_3d:!0,freq_min:5,beta:.05}},{type:"rgbd_to_3d_black_glove",category:"process",label:"RGB-D_3D_BlackGlove",icon:"ant-design:aim-outlined",color:ut.hand3d,description:"Metric 3D black-glove keypoints from RGB video plus a matched depth stream.",inputs:[{key:"video",label:"RGB Video"},{key:"depth",label:"Depth"}],outputs:[{key:"hand_3d",label:"Hand 3D"}],defaultConfig:{mode:"auto",max_hands:2,det_conf:.05,device:"auto",pose_device:"auto",imgsz:640,smooth:!0,preview_3d:!0,freq_min:5,beta:.05,movement_thresh:1.5,skip_timeout:3,box_alpha:.7,pose_conf_thr:.15,new_track_conf:.1,lost_timeout:8,hold_max:12,spawn_confirm:2,match_contain_thr:.7}},{type:"rgb_to_2d_black_glove",category:"process",label:"RGB_TO_2D_BlackGlove",icon:"ant-design:deployment-unit-outlined",color:ut.hand3d,description:"2D black-glove keypoints from RGB video. The optional 3D view is display-only and is not exported as metric 3D.",inputs:[{key:"video",label:"RGB Video"}],outputs:[{key:"hand_keypoints",label:"Hand 2D"}],defaultConfig:{mode:"auto",max_hands:2,det_conf:.05,device:"auto",pose_device:"auto",imgsz:640,smooth:!0,preview_3d:!0,freq_min:5,beta:.05,movement_thresh:1.5,skip_timeout:3,box_alpha:.7,pose_conf_thr:.15,new_track_conf:.1,lost_timeout:8,hold_max:12,spawn_confirm:2,match_contain_thr:.7}},{type:"human_review",category:"review",label:"Human Review",icon:"ant-design:eye-outlined",color:ut.review,description:"Human review gate. Accepts any upstream data; required review before export.",inputs:[{key:"data",label:"Review Target"}],outputs:[{key:"reviewed",label:"Reviewed Data"}],defaultConfig:{required:!0,reviewers:1}},{type:"ai_quality_review",category:"review",label:"AI Quality Review",icon:"ant-design:robot-outlined",color:ut.review,description:"Checks video decode, frame continuity, black screens, freezes, and AI annotation coverage before automatic approval and export.",inputs:[{key:"data",label:"Quality Review Target"}],outputs:[{key:"reviewed",label:"Reviewed Data"}],defaultConfig:{mode:"gate"}},{type:"lerobot_export",category:"export",label:"LeRobot Export",icon:"ant-design:cloud-server-outlined",color:ut.export,description:"Export to LeRobot dataset format (v3.0 / v2.1). Accepts any upstream data.",inputs:[{key:"data",label:"Exportable Data"}],outputs:[{key:"dataset",label:"Dataset"}],defaultConfig:{version:"v3.0",split_ratio:.9,shard_size:1e5}},{type:"hdf5_export",category:"export",label:"HDF5 Export",icon:"ant-design:cloud-server-outlined",color:ut.export,description:"Export to HDF5 dataset format. Accepts any upstream data.",inputs:[{key:"data",label:"Exportable Data"}],outputs:[{key:"dataset",label:"Dataset"}],defaultConfig:{compression:"gzip",level:4}}];rN.forEach(nN);let uN=0;const xt=dv((n,l)=>({toasts:[],pushToast:(o,r="info")=>{const u=++uN;n(f=>({toasts:[...f.toasts,{id:u,msg:o,type:r}]})),setTimeout(()=>l().removeToast(u),4e3)},removeToast:o=>n(r=>({toasts:r.toasts.filter(u=>u.id!==o)})),dialog:null,confirm:(o,r)=>new Promise(u=>{n({dialog:{kind:"confirm",title:(r==null?void 0:r.title)||"Confirm",message:o,confirmLabel:r==null?void 0:r.confirmLabel,danger:r==null?void 0:r.danger,resolve:f=>u(f)}})}),prompt:(o,r)=>new Promise(u=>{n({dialog:{kind:"prompt",title:(r==null?void 0:r.title)||"Input",message:o,defaultValue:r==null?void 0:r.defaultValue,confirmLabel:r==null?void 0:r.confirmLabel,resolve:f=>u(f)}})}),resolveDialog:o=>{const r=l().dialog;r&&(r.resolve(o),n({dialog:null}))}})),Ef=30;let Kf=1,hu=0,on=0;const yv="workflow_draft",mv="egodata.workflow-list.v1",sN=60*1e3;function cN(){try{const n=JSON.parse(sessionStorage.getItem(mv)||"null");return!n||!Array.isArray(n.workflows)||Date.now()-Number(n.savedAt||0)>sN?null:n.workflows}catch{return null}}function fN(n){try{sessionStorage.setItem(mv,JSON.stringify({savedAt:Date.now(),workflows:n}))}catch{}}const vm={rgbd_camera:"RGB-D Camera",stereo_rgbd_camera:"Stereo RGB-D Camera",mono_rgb:"RGB Camera",stereo_rgb:"Stereo RGB Camera",glove_sensor:"Glove Sensor",gripper_device:"UMI Gripper"},dN=new Set(["mono_camera","rgbd_camera","rgb_camera","fisheye_camera","stereo_camera","stereo_rgbd_camera","gripper_device"]);function hN(n){var o;const l=((o=n.data)==null?void 0:o.config)||{};return[l.source_key,l.source_keys,l.position].flatMap(r=>String(r||"").split(",")).map(r=>r.trim().toLowerCase()).filter(Boolean)}function gN(n,l){const o=hN(n);if(!o.length)return!1;const r=[l.name,l.display_name,l.source_key,...l.source_keys||[],...l.depth_keys||[]].map(u=>String(u||"").trim().toLowerCase()).filter(Boolean);return o.some(u=>r.includes(u))}function bm(n,l){const o=l.device_sources||[];return o.length?n.map(r=>{var y;if(!dN.has((y=r.data)==null?void 0:y.nodeType))return r;const u=r.data;if(u.device_type&&vm[String(u.device_type)])return r;const f=o.find(g=>gN(r,g)),d=(f==null?void 0:f.device_type)||(u.nodeType==="stereo_rgbd_camera"?"stereo_rgbd_camera":u.nodeType==="stereo_camera"?"stereo_rgb":u.nodeType==="rgbd_camera"?"rgbd_camera":"mono_rgb"),h=(f==null?void 0:f.display_name)||vm[String(d)]||u.device_display_name;return{...r,data:{...u,device_type:d,device_display_name:h}}}):n}function Wl(n){try{const l={nodes:n.nodes,edges:n.edges,workflowId:n.workflowId,workflowProjectId:n.workflowProjectId,workflowName:n.workflowName,savedAt:Date.now()};localStorage.setItem(yv,JSON.stringify(l))}catch{}}function Fl(){try{localStorage.removeItem(yv)}catch{}}function bn(n){return JSON.parse(JSON.stringify(n))}function yN(n,l){if(!(n!=null&&n.length))return l||[];if(!(l!=null&&l.length))return n;const o=new Map(n.map(u=>[u.name,u])),r=l.filter(u=>!o.has(u.name));return r.length?[...n,...r]:n}function pv(n){const l=new Map,o=(n.nodes||[]).map(h=>{var p;const y=((p=h.data)==null?void 0:p.nodeType)||"",g=ol(y);l.set(h.id,g);const b={...h.data,nodeType:g};return g==="rgbd_camera"?b.outputs=[{key:"video",label:"RGB Video"},{key:"depth",label:"Depth"}]:g==="stereo_rgbd_camera"?b.outputs=[{key:"video_left",label:"Left RGB Video"},{key:"video_right",label:"Right RGB Video"},{key:"depth",label:"Depth"}]:g==="gripper_device"?(b.inputs=[],b.outputs=[{key:"rgb_video",label:"RGB Video"},{key:"gripper_state",label:"ESP Gripper State"},{key:"slam_trajectory",label:"SLAM Trajectory"},{key:"tactile_force_matrices",label:"Left and Right Force Matrices"}]):g==="rgb_to_2d_bare_hand"||g==="rgb_to_2d_black_glove"?(b.inputs=[{key:"video",label:"RGB Video"}],b.outputs=[{key:"hand_keypoints",label:"Hand 2D"}]):(g==="rgbd_to_3d_bare_hand"||g==="rgbd_to_3d_black_glove")&&(b.inputs=[{key:"video",label:"RGB Video"},{key:"depth",label:"Depth"}],b.outputs=[{key:"hand_3d",label:"Hand 3D"}]),{...h,data:b}}),r=(n.edges||[]).map(h=>{const y=l.get(h.source)||"",g=String(h.sourceHandle||"");let b=g;const p=y==="annotation"||y==="ai_annotation"?"annotation":y==="human_review"||y==="ai_quality_review"?"reviewed":"";return p&&g==="result"?b=p:y==="gripper_device"&&["tactile_left","tactile_right"].includes(g)?b="tactile_force_matrices":["rgb_to_2d_bare_hand","rgb_to_2d_black_glove"].includes(y)&&g.startsWith("hand_3d")?b=g.replace(/^hand_3d/,"hand_keypoints"):["rgbd_to_3d_bare_hand","rgbd_to_3d_black_glove"].includes(y)&&g.startsWith("hand_keypoints")&&(b=g.replace(/^hand_keypoints/,"hand_3d")),b===g?h:{...h,sourceHandle:b,id:h.id?String(h.id).replace(g,b):h.id}}),u=new Set,f=r.filter(h=>{if(l.get(h.source)!=="gripper_device"||h.sourceHandle!=="tactile_force_matrices")return!0;const y=`${h.source}|${h.sourceHandle}|${h.target}|${h.targetHandle||""}`;return u.has(y)?!1:(u.add(y),!0)}),d=new Set(f.map(h=>`${h.source}|${h.target}|${h.targetHandle||""}`));for(const h of[...f]){if(h.targetHandle!=="video"||!["rgbd_camera","stereo_rgbd_camera"].includes(l.get(h.source)||"")||!["rgbd_to_3d_bare_hand","rgbd_to_3d_black_glove"].includes(l.get(h.target)||""))continue;const y=`${h.source}|${h.target}|depth`;d.has(y)||(f.push({...h,id:`xy-edge__${h.source}depth-${h.target}depth`,sourceHandle:"depth",targetHandle:"depth"}),d.add(y))}return{nodes:o,edges:f}}function vv(n){var f,d;const l=ol(n.data.nodeType),o=hv(l);if(!o)return n;const r=new Set(["rgb_camera","mono_camera","rgbd_camera","fisheye_camera","stereo_camera","stereo_rgbd_camera","rgbd_to_3d_bare_hand","rgb_to_2d_bare_hand","rgbd_to_3d_black_glove","rgb_to_2d_black_glove","annotation","ai_annotation","human_review","ai_quality_review","lerobot_export","hdf5_export","gripper_device"]),u=new Set(["rgb_camera","mono_camera","fisheye_camera","rgbd_camera","stereo_camera","stereo_rgbd_camera","glove_sensor","gripper_device","mediapipe_hand","annotation","ai_annotation","human_review","ai_quality_review","lerobot_export","hdf5_export","rgbd_to_3d_bare_hand","rgb_to_2d_bare_hand","rgbd_to_3d_black_glove","rgb_to_2d_black_glove"]);return{...n,data:{...n.data,nodeType:l,label:r.has(l)?o.label:n.data.label||o.label,icon:n.data.icon||o.icon,color:r.has(l)?o.color:n.data.color||o.color,inputs:u.has(l)?o.inputs:(f=n.data.inputs)!=null&&f.length?n.data.inputs:o.inputs,outputs:u.has(l)?o.outputs:(d=n.data.outputs)!=null&&d.length?n.data.outputs:o.outputs,configSchema:yN(n.data.configSchema,o.configSchema),executionTarget:n.data.executionTarget||o.executionTarget}}}function Jf(n){const l=pv(n);return{nodes:(l.nodes||[]).map(vv),edges:l.edges||[]}}function xm(n,l){const o=l.find(v=>v.id===n.source),r=l.find(v=>v.id===n.target);if(!o||!r)return!1;const u=o.data.outputs||[],f=r.data.inputs||[];if(!u.length||!f.length)return!0;const d=u.find(v=>v.key===(n.sourceHandle??u[0].key))||(u.length===1?u[0]:null),h=f.find(v=>v.key===(n.targetHandle??f[0].key))||(f.length===1?f[0]:null);if(!d||!h)return!0;const y=ol(r.data.nodeType),g=ol(o.data.nodeType);if((y==="annotation"||y==="ai_annotation")&&h.key==="data")return["video","video_left","video_right"].includes(d.key)&&g!=="glove_sensor";if(h.key==="data")return!0;if((y==="rgbd_to_3d_bare_hand"||y==="rgbd_to_3d_black_glove")&&h.key==="depth")return(g==="rgbd_camera"||g==="stereo_rgbd_camera")&&d.key==="depth";const p=["video","rgb_video","video_left","video_right"];return p.includes(h.key)&&p.includes(d.key)?!0:d.key===h.key}const Ne=dv((n,l)=>({nodes:[],edges:[],workflowId:null,workflowProjectId:null,workflowName:"Untitled",workflowStatus:"draft",isDirty:!1,isSaving:!1,userRole:null,isPresetWorkflow:!1,referenceProjectId:null,referenceInputs:null,projectBindings:null,currentWorkflowBindings:{},globalInputs:null,inputsLoading:!1,inputsError:null,workflows:[],listLoading:!1,history:[],historyIndex:-1,pushHistory:()=>{const o=l(),r=[...o.history.slice(0,o.historyIndex+1)];r.push({nodes:bn(o.nodes),edges:bn(o.edges)}),r.length>Ef&&r.shift(),n({history:r,historyIndex:r.length-1})},undo:()=>{const o=l();if(o.historyIndex<0)return;const r=o.history[o.historyIndex];r&&n({nodes:bn(r.nodes),edges:bn(r.edges),historyIndex:o.historyIndex-1,isDirty:!0})},redo:()=>{const o=l();if(o.historyIndex>=o.history.length-1)return;const r=o.history[o.historyIndex+1];r&&n({nodes:bn(r.nodes),edges:bn(r.edges),historyIndex:o.historyIndex+1,isDirty:!0})},onNodesChange:o=>n(r=>{if(o.some(d=>d.type==="remove"||d.type==="position"&&d.dragging===!0)){const d=[...r.history.slice(0,r.historyIndex+1)];d.push({nodes:bn(r.nodes),edges:bn(r.edges)}),d.length>Ef&&d.shift();const h=Yf(o,r.nodes);return Wl({...r,nodes:h}),{nodes:h,isDirty:!0,history:d,historyIndex:d.length-1}}return{nodes:Yf(o,r.nodes),isDirty:r.isDirty}}),onEdgesChange:o=>n(r=>{if(o.some(d=>d.type==="remove"||d.type==="add")){const d=[...r.history.slice(0,r.historyIndex+1)];d.push({nodes:bn(r.nodes),edges:bn(r.edges)}),d.length>Ef&&d.shift();const h=Vf(o,r.edges);return Wl({...r,edges:h}),{edges:h,isDirty:!0,history:d,historyIndex:d.length-1}}return{edges:Vf(o,r.edges),isDirty:r.isDirty}}),onConnect:o=>n(r=>{var g,b,p,v,x,_,C,M,E,H;if(o.source===o.target||!xm(o,r.nodes)){const w=r.nodes.find(Q=>Q.id===o.source),z=r.nodes.find(Q=>Q.id===o.target),G=((p=(b=(g=z==null?void 0:z.data)==null?void 0:g.inputs)==null?void 0:b.find(Q=>{var K,ue,$;return Q.key===(o.targetHandle||(($=(ue=(K=z==null?void 0:z.data)==null?void 0:K.inputs)==null?void 0:ue[0])==null?void 0:$.key))}))==null?void 0:p.label)||((_=(x=(v=z==null?void 0:z.data)==null?void 0:v.inputs)==null?void 0:x[0])==null?void 0:_.label)||"input",B=(M=(C=w==null?void 0:w.data)==null?void 0:C.outputs)==null?void 0:M.find(Q=>{var K,ue,$;return Q.key===(o.sourceHandle||(($=(ue=(K=w==null?void 0:w.data)==null?void 0:K.outputs)==null?void 0:ue[0])==null?void 0:$.key))}),L=B&&B.key!=="data"?`Port mismatch: this input only accepts "${G}" data, but "${B.label||B.key}" outputs "${B.key}"`:"Self-connection is not allowed";return xt.getState().pushToast(`Cannot connect: ${L}`,"error"),r}const u=w=>r.edges.some(z=>z.source===w.source&&z.target===w.target&&(z.sourceHandle||null)===(w.sourceHandle||null)&&(z.targetHandle||null)===(w.targetHandle||null));if(u(o))return xt.getState().pushToast("Already connected: this port pair is already linked.","error"),r;let f=qf(o,r.edges);const d=r.nodes.find(w=>w.id===o.source),h=((E=d==null?void 0:d.data)==null?void 0:E.outputs)||[];if(((H=d==null?void 0:d.data)==null?void 0:H.nodeType)==="stereo_camera"||h.some(w=>w.key==="video_left")&&h.some(w=>w.key==="video_right")){const w=o.sourceHandle||"video_left",z=w==="video_left"?"video_right":"video_left",G={...o,sourceHandle:z};!u(G)&&xm(G,r.nodes)&&(f=qf(G,f),xt.getState().pushToast(`Stereo pair connected: ${w} + ${z} both linked.`,"info"))}return Wl({...r,edges:f}),{edges:f,isDirty:!0}}),setNodes:o=>{const r=l();Wl({...r,nodes:o}),n({nodes:o,isDirty:!0})},setEdges:o=>{const r=l();Wl({...r,edges:o}),n({edges:o,isDirty:!0})},setUserRole:o=>n({userRole:o}),loadReferenceInputs:async o=>{const r=++on;n({inputsLoading:!0,inputsError:null});const u=W3(o).catch(()=>null);try{const f=await I3(o);if(r!==on)return;const d=bm(l().nodes,f);n({nodes:d,workflowProjectId:o,referenceProjectId:o,referenceInputs:f,globalInputs:null,inputsLoading:!1,inputsError:null})}catch(f){if(r!==on)return;n({referenceInputs:null,referenceProjectId:null,globalInputs:null,inputsLoading:!1,inputsError:f instanceof Error?f.message:"Failed to load project inputs"});return}if(r===on)try{const f=await u;if(r!==on||!f)return;const d=l(),h=f.workflow_bindings||null;n({projectBindings:h,currentWorkflowBindings:(h||{})[d.workflowId||""]||{}})}catch{}},loadInputsForWorkflow:async o=>{const r=l(),u=o||r.workflowProjectId;u?(n({workflowProjectId:u}),await l().loadReferenceInputs(u)):(++on,n({referenceInputs:{has_episodes:!1,camera_names:[],devices:[],device_sources:[],sensors:[],modules:[]},globalInputs:null,referenceProjectId:null,inputsLoading:!1,inputsError:null}))},setProjectBinding:async(o,r)=>{const u=l(),f=u.referenceProjectId,d=u.workflowId;if(!(!f||!d))try{const y=(await F3(f,{workflow_id:d,node_id:o,source_key:r})).workflow_bindings||null;n({projectBindings:y,currentWorkflowBindings:(y||{})[d]||{}})}catch(h){throw console.error("set binding failed",h),h}},loadGlobalInputs:async()=>{const o=++on;n({inputsLoading:!0,inputsError:null});try{const r=await P3();if(o!==on)return;const u=bm(l().nodes,r);n({nodes:u,globalInputs:r,referenceInputs:null,referenceProjectId:null,inputsLoading:!1,inputsError:null})}catch(r){if(o!==on)return;n({globalInputs:null,referenceInputs:null,referenceProjectId:null,inputsLoading:!1,inputsError:r instanceof Error?r.message:"Failed to load device inputs"})}},newWorkflow:()=>{++hu,++on,Fl(),n({nodes:[],edges:[],workflowId:null,workflowProjectId:null,workflowName:"Untitled",workflowStatus:"draft",isDirty:!1,isPresetWorkflow:!1,currentWorkflowBindings:{},referenceProjectId:null,referenceInputs:null,globalInputs:null,projectBindings:null,inputsLoading:!1,inputsError:null,history:[],historyIndex:-1})},newWorkflowFromTemplate:async o=>{const u=(await Qf(o.id)).graph||{nodes:[],edges:[]},f=pv(u),d=(f.nodes||[]).map(vv).map(g=>({...g,selected:!1,dragging:!1})),h=f.edges||[],y=l();n({nodes:d,edges:h,workflowId:y.workflowId,workflowName:y.workflowId?y.workflowName:o.name||"Workflow",workflowStatus:y.workflowStatus,isDirty:!0,isPresetWorkflow:!1,currentWorkflowBindings:{}}),Wl(l())},loadWorkflowList:async()=>{n({listLoading:!0});const o=cN();o&&n({workflows:o});try{const r=await $3(100);fN(r.workflows),n({workflows:r.workflows})}catch{}n({listLoading:!1})},loadWorkflow:async o=>{const r=++hu;++on,n({inputsLoading:!0,inputsError:null});let u;try{u=await Qf(o)}catch(h){throw r===hu&&n({inputsLoading:!1,inputsError:h instanceof Error?h.message:"Failed to load workflow"}),h}if(r!==hu)return;const f=Jf(u.graph||{nodes:[],edges:[]}),d=f.nodes;if(d.length>0){let h=0;for(const y of d){const g=y.id.match(/^node_(\d+)$/);g&&(h=Math.max(h,parseInt(g[1],10)))}h>=Kf&&(Kf=h+1)}Fl(),n({nodes:d,edges:f.edges,workflowId:u.id,workflowProjectId:u.project_id||null,workflowName:u.name,workflowStatus:u.status,isDirty:!1,isPresetWorkflow:!!u.is_preset,referenceProjectId:null,referenceInputs:null,globalInputs:null,projectBindings:null,currentWorkflowBindings:{},inputsLoading:!0,inputsError:null,history:[],historyIndex:-1})},saveWorkflow:async()=>{const o=l();if(o.isSaving)return;n({isSaving:!0});const r={nodes:o.nodes,edges:o.edges};try{if(o.workflowId)await $f(o.workflowId,{name:o.workflowName,project_id:o.workflowProjectId,graph:r,status:"active"}),n({workflowStatus:"active"});else{const u=await Sf({name:o.workflowName,project_id:o.workflowProjectId,graph:r,status:"active"});n({workflowId:u.id,workflowProjectId:u.project_id||o.workflowProjectId,workflowStatus:u.status})}Fl(),n({isSaving:!1,isDirty:!1})}catch(u){console.error(u),n({isSaving:!1})}},saveWorkflowSafe:async()=>{const o=l();if(o.isPresetWorkflow&&o.userRole!=="admin")return"needs-save-as";if(o.isSaving)return"saved";n({isSaving:!0});const r={nodes:o.nodes,edges:o.edges};try{if(o.workflowId)await $f(o.workflowId,{name:o.workflowName,project_id:o.workflowProjectId,graph:r,status:"active"}),n({workflowStatus:"active"});else{const u=await Sf({name:o.workflowName,project_id:o.workflowProjectId,graph:r,status:"active"});n({workflowId:u.id,workflowProjectId:u.project_id||o.workflowProjectId,workflowStatus:u.status})}return Fl(),n({isSaving:!1,isDirty:!1}),"saved"}catch(u){n({isSaving:!1});const f=u instanceof Error?u.message:String(u);if(/preset/i.test(f)||/403/.test(f))return"needs-save-as";throw u}},saveWorkflowAs:async o=>{const r=l();n({isSaving:!0,workflowName:o,workflowId:null});const u={nodes:r.nodes,edges:r.edges};try{const f=await Sf({name:o,project_id:null,graph:u,status:"active"});Fl(),n({workflowId:f.id,workflowProjectId:f.project_id||null,workflowStatus:f.status,isSaving:!1,isDirty:!1,isPresetWorkflow:!1})}catch(f){console.error(f),n({isSaving:!1})}}}));function mN(){const n=Ne.getState().nodes;let l;do l=`node_${Kf++}`;while(n.some(o=>o.id===l));return l}function To({icon:n,className:l,style:o}){return I.createElement("iconify-icon",{icon:n,class:l,style:o})}const Nf={kimi:["kimi-k3"],qwen:["qwen3.8-max","qwen3.7-plus","qwen3.7-flash","qwen3-vl-plus","qwen3-vl-32b-thinking","qwen3.5-flash","qwen3.5-omni-flash","kimi-k2.6"],siliconflow:["Qwen/Qwen3-VL-30B-A3B-Instruct","Qwen/Qwen3-VL-30B-A3B-Thinking","Qwen/Qwen3.5-397B-A17B","Qwen/Qwen3.5-122B-A10B","Qwen/Qwen3.6-35B-A3B","Qwen/Qwen3.6-27B","Qwen/Qwen3-Omni-30B-A3B-Instruct","Qwen/Qwen3-Omni-30B-A3B-Thinking","zai-org/GLM-4.5V","Pro/moonshotai/Kimi-K2.6","MiniMaxAI/MiniMax-M2.5"]},Tf={kimi:"https://api.moonshot.ai/v1",qwen:"https://dashscope.aliyuncs.com/compatible-mode/v1",siliconflow:"https://api.siliconflow.cn/v1"};let pN=0;const If=()=>++pN;function vN(n){const l=n||{},o=l.api_providers;return Array.isArray(o)&&o.length?o.map(r=>{const u=r||{};return{id:If(),vendor:String(u.vendor||"kimi"),model:String(u.model||""),key:String(u.key||""),baseUrl:String(u.base_url||"")}}):[{id:If(),vendor:String(l.api_vendor||"kimi"),model:String(l.api_model||""),key:String(l.api_key||""),baseUrl:String(l.api_base_url||"")}]}function bN({nodeId:n,onClose:l}){var V;const o=Ne(k=>k.nodes.find(Z=>Z.id===n)),r=o==null?void 0:o.data,u=(r==null?void 0:r.configSchema)||[],f=u.find(k=>k.name==="api_vendor"),d=u.find(k=>k.name==="api_model"),h=u.find(k=>k.name==="api_base_url"),y=u.find(k=>k.name==="prompt_language"),[g,b]=I.useState(()=>vN(r==null?void 0:r.config)),[p,v]=I.useState(()=>{var k;return((k=g[0])==null?void 0:k.id)??0}),[x,_]=I.useState(!1),[C,M]=I.useState(null),[E,H]=I.useState(()=>{var Z;return String(((Z=r==null?void 0:r.config)==null?void 0:Z.prompt_language)||(y==null?void 0:y.default)||"zh").toLowerCase()==="en"?"en":"zh"}),w=g.find(k=>k.id===p)||g[0],z=(w==null?void 0:w.vendor)??"kimi",G=(w==null?void 0:w.model)??"",B=(w==null?void 0:w.key)??"",L=(w==null?void 0:w.baseUrl)??"",Q=Array.from(new Set([...(f==null?void 0:f.options)||[],"kimi","qwen","siliconflow"])),K=k=>{b(Z=>Z.map(N=>N.id===p?{...N,...k}:N)),M(null)},ue=k=>{const Z=Nf[k]||[],N=new Set(Object.values(Tf)),R={vendor:k};Z.length&&!Z.includes(G)&&(R.model=Z[0]),(!L||N.has(L))&&(R.baseUrl=Tf[k]||""),K(R)},$=()=>{const k={id:If(),vendor:"kimi",model:Nf.kimi[0]||"",key:"",baseUrl:""};b(Z=>[...Z,k]),v(k.id),M(null)},ie=()=>{if(g.length<=1)return;const k=g.filter(Z=>Z.id!==p);b(k),v(k[0].id),M(null)},ne=()=>M(null),D=async()=>{if(!x){if(!G.trim()){M({ok:!1,message:"Model required"});return}if(!B.trim()){M({ok:!1,message:"API key required"});return}_(!0),M(null);try{const k=await fetch("/api/v1/ai-annotation/test-connection",{method:"POST",credentials:"include",headers:{"Content-Type":"application/json"},body:JSON.stringify({api_vendor:z.trim()||"kimi",api_model:G.trim(),api_key:B.trim(),api_base_url:L.trim()})}),Z=await k.json().catch(()=>({}));M({ok:k.ok&&Z.ok===!0,message:String(Z.message||(k.ok?"Test failed":`Request failed (${k.status})`))})}catch(k){M({ok:!1,message:`Request failed: ${k instanceof Error?k.message:"network error"}`})}finally{_(!1)}}},q=()=>{const k=g.map(N=>({vendor:N.vendor.trim()||"kimi",model:N.model.trim(),key:N.key.trim(),base_url:N.baseUrl.trim()})),Z=k[0]||{vendor:"kimi",model:"",key:"",base_url:""};Ne.setState(N=>({nodes:N.nodes.map(R=>R.id===n?{...R,data:{...R.data,config:{...R.data.config||{},api_providers:k,api_vendor:Z.vendor,api_model:Z.model,api_key:Z.key,api_base_url:Z.base_url,prompt_language:E==="en"?"en":"zh"}}}:R),isDirty:!0})),l()},A=Nf[z]||(d==null?void 0:d.options)||[],j=G&&!A.includes(G)?[G,...A]:A;return T.jsxs("div",{className:"fixed inset-0 z-50 flex items-center justify-center",children:[T.jsx("div",{className:"absolute inset-0 bg-black/60",onClick:l}),T.jsxs("div",{className:"relative w-96 bg-gray-900 border border-gray-700 rounded-lg shadow-2xl",children:[T.jsxs("div",{className:"flex items-center justify-between px-4 py-3 border-b border-gray-800",children:[T.jsx("h3",{className:"text-sm font-semibold text-gray-200",children:"AI Annotation · Settings"}),T.jsx("button",{onClick:l,"aria-label":"Close",className:"text-gray-500 hover:text-gray-300 text-base leading-none",children:"✕"})]}),T.jsxs("div",{className:"p-4 space-y-3",children:[T.jsxs("label",{className:"block",children:[T.jsx("span",{className:"text-xs text-gray-400",children:"Label language"}),T.jsxs("select",{"aria-label":"Label language",value:E,onChange:k=>H(k.target.value==="en"?"en":"zh"),className:"mt-1 w-full bg-gray-800 border border-gray-700 rounded px-2 py-1.5 text-sm text-gray-200",children:[T.jsx("option",{value:"zh",children:"中文"}),T.jsx("option",{value:"en",children:"English"})]}),T.jsx("span",{className:"mt-1 block text-[10px] text-gray-500",children:"Applies to the next AI annotation run."})]}),String(((V=r==null?void 0:r.config)==null?void 0:V.vlm_provider)||"local")==="local"&&T.jsx("div",{className:"rounded border border-gray-800 bg-gray-950/50 px-2.5 py-2 text-[10px] text-gray-500",children:"Local VLM selected. Language setting is shared with API mode."}),T.jsxs("div",{className:"flex items-center gap-1.5",children:[T.jsx("select",{value:p,onChange:k=>{v(Number(k.target.value)),ne()},className:"flex-1 min-w-0 bg-gray-800 border border-gray-700 rounded px-2 py-1.5 text-sm text-gray-200",children:g.map((k,Z)=>T.jsx("option",{value:k.id,children:`#${Z+1} · ${k.vendor}${k.model?` · ${k.model}`:""}`},k.id))}),T.jsx("button",{onClick:$,title:"Add API",className:"shrink-0 text-xs px-2 py-1.5 rounded border border-dashed border-gray-600 text-gray-400 hover:text-gray-200 hover:border-gray-400",children:"+"}),T.jsx("button",{onClick:ie,disabled:g.length<=1,title:"Remove this API",className:"shrink-0 text-xs px-2 py-1.5 rounded border border-gray-700 text-gray-500 hover:text-red-400 hover:border-red-800 disabled:opacity-30",children:"✕"})]}),T.jsxs("label",{className:"block",children:[T.jsx("span",{className:"text-xs text-gray-400",children:"API vendor"}),T.jsx("select",{value:z,onChange:k=>ue(k.target.value),className:"mt-1 w-full bg-gray-800 border border-gray-700 rounded px-2 py-1.5 text-sm text-gray-200",children:Q.map(k=>T.jsx("option",{value:k,children:k},k))})]}),T.jsxs("label",{className:"block",children:[T.jsx("span",{className:"text-xs text-gray-400",children:"API model"}),T.jsx("select",{value:G,onChange:k=>{K({model:k.target.value})},className:"mt-1 w-full bg-gray-800 border border-gray-700 rounded px-2 py-1.5 text-sm text-gray-200",children:j.length?j.map(k=>T.jsx("option",{value:k,children:k},k)):T.jsx("option",{value:G,children:G})})]}),T.jsxs("label",{className:"block",children:[T.jsx("span",{className:"text-xs text-gray-400",children:"API key (stored with this workflow)"}),T.jsx("input",{type:"password",value:B,onChange:k=>K({key:k.target.value}),autoComplete:"new-password",placeholder:"sk-...",className:"mt-1 w-full bg-gray-800 border border-gray-700 rounded px-2 py-1.5 text-sm text-gray-200"})]}),T.jsxs("label",{className:"block",children:[T.jsx("span",{className:"text-xs text-gray-400",children:"API base URL (blank = official default)"}),T.jsx("input",{type:"text",value:L,onChange:k=>K({baseUrl:k.target.value}),placeholder:String((h==null?void 0:h.default)||Tf[z]||""),className:"mt-1 w-full bg-gray-800 border border-gray-700 rounded px-2 py-1.5 text-sm text-gray-200"})]}),C&&T.jsxs("div",{className:`rounded px-2.5 py-2 text-xs ${C.ok?"border border-green-800 bg-green-950/40 text-green-300":"border border-red-800 bg-red-950/40 text-red-300"}`,children:[T.jsx("span",{className:"mr-1",children:C.ok?"✓":"✕"}),C.message]})]}),T.jsxs("div",{className:"flex justify-end gap-2 px-4 py-3 border-t border-gray-800",children:[T.jsx("button",{onClick:l,className:"text-xs px-3 py-1.5 rounded bg-gray-800 hover:bg-gray-700 text-gray-300",children:"Cancel"}),T.jsx("button",{onClick:D,disabled:x,className:"text-xs px-3 py-1.5 rounded border border-cyan-700 bg-cyan-950/40 hover:bg-cyan-900/60 text-cyan-300 disabled:opacity-50",children:x?"Testing…":"Test Connection"}),T.jsx("button",{onClick:q,className:"text-xs px-3 py-1.5 rounded bg-blue-600 hover:bg-blue-500 text-white",children:"Save"})]})]})]})}const xN=["mono_camera","rgbd_camera","rgb_camera","fisheye_camera","stereo_camera","stereo_rgbd_camera"],bv=[...xN,"gripper_device"],_N=["rgbd_to_3d_bare_hand","rgbd_to_3d_black_glove"],Na={rgbd_camera:"RGB-D Camera",stereo_rgbd_camera:"Stereo RGB-D Camera",mono_rgb:"RGB Camera",stereo_rgb:"Stereo RGB Camera",glove_sensor:"Glove Sensor",gripper_device:"UMI Gripper"};function wN(n){if(n.nodeType==="stereo_rgbd_camera")return Na.stereo_rgbd_camera;if(n.nodeType==="stereo_camera")return Na.stereo_rgb;if(n.nodeType==="rgbd_camera")return Na.rgbd_camera;if(n.nodeType==="mono_camera"||n.nodeType==="rgb_camera"||n.nodeType==="fisheye_camera")return Na.mono_rgb;if(n.nodeType==="gripper_device")return Na.gripper_device;const l=n.device_type?Na[String(n.device_type)]:"";if(l)return l;const o=String(n.device_display_name||"");return Object.values(Na).includes(o)?o:Na.mono_rgb}const SN=I.memo(function({data:l,selected:o,id:r}){var N,R,ee,ae,de;const u=l,f=u.color||"#475569",d=bv.includes(u.nodeType),h=(N=hv(u.nodeType))==null?void 0:N.description,y=AN(u),g=Ne(se=>se.currentWorkflowBindings[r]),p=Ne(se=>se.referenceInputs),v=p!==null,x=_N.includes(u.nodeType),_=!!g&&(!!g.source_key||!!g.source_keys),C=_?g.source_key??g.source_keys??"":"",M=(y==null?void 0:y.name)==="source_key"?_?C:((R=u.config)==null?void 0:R.source_key)??((ee=u.config)==null?void 0:ee.position)??y.default??"":((ae=u.config)==null?void 0:ae[(y==null?void 0:y.name)||""])??(y==null?void 0:y.default)??"",[E,H]=I.useState(null),w=_?E??C:M,z=d?wN(u):u.label,G=d&&v?EN(w,p,u.nodeType,u.device_type):"",B=d&&v?NN(p,u.nodeType,u.device_type):[],L=x&&v?TN(p):[],Q=String(((de=u.config)==null?void 0:de.depth_camera)||"");L.includes(Q);const K=d?G:w,ue=se=>{const oe=se.trim().toLowerCase();return oe&&((p==null?void 0:p.device_sources)||[]).find(P=>{var Y,fe;return zu(P,u.nodeType,u.device_type)&&(P.name.toLowerCase()===oe||((Y=P.display_name)==null?void 0:Y.toLowerCase())===oe||P.source_keys.some(he=>he.toLowerCase()===oe)||((fe=P.source_key)==null?void 0:fe.toLowerCase())===oe)})||null},$=se=>{const oe=ue(se);return oe?oe.input_type==="stereo_camera"||oe.input_type==="stereo_rgbd_camera"?oe.source_keys.join(","):oe.source_key||oe.source_keys[0]||oe.name:se.trim()},ie=se=>{const oe=String(se??""),P=d?$(oe):oe;if(_){H(P);return}k(P,d?ue(oe):null)},ne=async se=>{if(H(null),!y||!_)return;const oe=d?$(se):se.trim();oe===C||!await xt.getState().confirm(`"${y.label}" is overridden for this project ("${C}"). Save "${oe}" for this project only?`,{title:"Project override",confirmLabel:"Save for this project"})||Ne.getState().setProjectBinding(r,oe||null).catch(Y=>xt.getState().pushToast(`Failed to save project binding: ${(Y==null?void 0:Y.message)||Y}`,"error"))},D=se=>{_&&ne(se.target.value)},q=se=>{_&&(se.key==="Enter"&&ne(se.target.value),se.key==="Escape"&&H(null))},[A,j]=I.useState(!1),V=u.nodeType==="ai_annotation",k=(se,oe=null)=>{if(!y)return;const P={...u.config,[y.name]:se};d&&y.name==="source_key"&&(P.position=se,oe&&(P.device_name=oe.name,oe.input_type==="gripper_device"||oe.input_type==="stereo_camera"||oe.input_type==="stereo_rgbd_camera"?P.source_keys=oe.source_keys.join(","):delete P.source_keys)),MN(r,{config:P})},Z=async()=>{!_||!await xt.getState().confirm("Clear this project override? The workflow default will be used again.",{title:"Clear project override",confirmLabel:"Clear"})||Ne.getState().setProjectBinding(r,null).catch(oe=>xt.getState().pushToast(`Failed to clear binding: ${(oe==null?void 0:oe.message)||oe}`,"error"))};return T.jsxs("div",{className:"workflow-node",title:h,style:{borderColor:o?"#3b82f6":u.color||"#334155",boxShadow:o?`0 0 0 2px ${u.color}33`:void 0},children:[T.jsxs("div",{className:"node-header",style:{backgroundColor:`${f}22`,borderBottom:`1px solid ${f}44`},children:[T.jsxs("div",{className:"node-title-row",children:[T.jsx(To,{icon:u.icon,className:"text-[18px]"}),T.jsx("span",{className:"text-xs font-semibold",title:z,children:z})]}),T.jsxs("div",{className:"node-header-control",onClick:se=>se.stopPropagation(),children:[y&&T.jsx(CN,{field:y,value:K,onChange:ie,onBlur:D,onKeyDown:q,suggestions:B,listId:`device-options-${r}`,placeholder:d?"Auto-match / enter source":void 0}),V&&T.jsx("button",{title:"AI annotation settings",onClick:se=>{se.stopPropagation(),j(!0)},className:"ml-1 text-[11px] text-cyan-400 border border-cyan-900 rounded px-1 cursor-pointer hover:bg-cyan-900/40 select-none",children:"⚙"}),_&&T.jsx("span",{onClick:Z,title:"Project override — click to clear",className:"ml-1 text-[9px] text-blue-400 border border-blue-800 rounded px-1 cursor-pointer hover:bg-blue-900/40 align-middle select-none",children:"P"})]})]}),T.jsxs("div",{className:"node-body",children:[(u.inputs||[]).map(se=>T.jsxs("div",{className:"node-port",style:{justifyContent:"flex-start",paddingLeft:0},children:[T.jsx(si,{type:"target",position:ve.Left,id:se.key,style:{position:"relative",left:-6,transform:"none",flexShrink:0}}),T.jsx("span",{children:se.label})]},se.key)),(u.outputs||[]).map(se=>T.jsxs("div",{className:"node-port",style:{justifyContent:"flex-end",paddingRight:0},children:[T.jsx("span",{children:se.label}),T.jsx(si,{type:"source",position:ve.Right,id:se.key,style:{position:"relative",right:-6,transform:"none",flexShrink:0}})]},se.key))]}),A&&T.jsx(bN,{nodeId:r,onClose:()=>j(!1)})]})});function EN(n,l,o,r){var d;const u=String(n||"").split(",").map(h=>h.trim()).filter(Boolean);if(!l)return"";const f=u.map(h=>{const y=(l.device_sources||[]).find(g=>{var b;return zu(g,o||"",r)&&(((b=g.source_key)==null?void 0:b.toLowerCase())===h.toLowerCase()||g.source_keys.some(p=>p.toLowerCase()===h.toLowerCase()))});return(y==null?void 0:y.name)||(y==null?void 0:y.display_name)||(y==null?void 0:y.source_key)||""});if(!f.length){const h=(l.device_sources||[]).filter(b=>!o||zu(b,o,r)),y=h.length||(d=l.device_sources)!=null&&d.length?h.map(b=>String(b.name||b.display_name||b.source_key||"")):(l.devices||[]).map(b=>String(b.name||b.display_name||"")),g=Array.from(new Set(y.filter(Boolean)));g.length===1&&f.push(g[0])}return Array.from(new Set(f)).join(", ")}function NN(n,l,o){if(!n)return[];const r=(n.device_sources||[]).filter(u=>zu(u,l,o)).map(u=>u.name||u.source_key).filter(u=>!!u);return Array.from(new Set(r))}function TN(n){return n?Array.from(new Set((n.device_sources||[]).flatMap(l=>l.depth_keys||[]).map(l=>String(l||"").trim()).filter(Boolean))):[]}function zu(n,l,o){var h;const r=String(n.device_type||"").toLowerCase(),u=String(n.input_type||"").toLowerCase(),f=!!((h=n.depth_keys)!=null&&h.length),d=r||(u==="glove_sensor"?"glove_sensor":u==="stereo_rgbd_camera"?"stereo_rgbd_camera":u==="stereo_camera"?"stereo_rgb":f||u==="rgbd_camera"?"rgbd_camera":"mono_rgb");return l==="stereo_rgbd_camera"?d==="stereo_rgbd_camera":l==="rgbd_camera"?d==="rgbd_camera":l==="stereo_camera"?d==="stereo_rgb":l==="glove_sensor"?d==="glove_sensor":l==="gripper_device"?d==="gripper_device":o&&String(o)==="rgbd_camera"?d==="rgbd_camera":d==="mono_rgb"}function AN(n){var o,r;const l=n.configSchema||[];return bv.includes(n.nodeType)?l.find(u=>u.name==="source_key")||{name:"source_key",type:"string",label:"Source key",default:((o=n.config)==null?void 0:o.source_key)||((r=n.config)==null?void 0:r.position)||""}:n.nodeType==="lerobot_export"?l.find(u=>u.name==="version")||{name:"version",type:"select",label:"Version",default:"v3.0",options:["v2.1","v3.0"]}:n.nodeType==="mediapipe_hand"?l.find(f=>f.name==="device")||{name:"device",type:"select",label:"Device",default:"auto",options:["auto","cpu","cuda:0"]}:n.nodeType==="ai_annotation"?l.find(u=>u.name==="vlm_provider")||{name:"vlm_provider",type:"select",label:"VLM provider",default:"local",options:["local","api"]}:null}function CN({field:n,value:l,onChange:o,onBlur:r,onKeyDown:u,suggestions:f=[],listId:d,placeholder:h}){const y=l??n.default??"";if(n.type==="boolean")return T.jsx("input",{type:"checkbox",checked:!!y,onChange:g=>o(g.target.checked)});if(n.type==="select"){const g=n.options||[],b=g.includes(String(y))?String(y):g[0]||"";return T.jsx("select",{"aria-label":n.label,value:b,onChange:p=>o(p.target.value),className:"node-header-select",children:g.map(p=>{const v=n.name==="prompt_language"?{zh:"中文",en:"English"}[p]||p:p==="cuda:0"?"GPU":p.toUpperCase();return T.jsx("option",{value:p,children:v},p)})})}return T.jsxs(T.Fragment,{children:[T.jsx("input",{"aria-label":n.label,type:n.type==="number"?"number":"text",value:String(y),list:f.length?d:void 0,placeholder:h,min:n.min,max:n.max,step:n.step,onClick:g=>{var b,p;f.length&&((p=(b=g.currentTarget).showPicker)==null||p.call(b))},onChange:g=>o(n.type==="number"?Number(g.target.value):g.target.value),onBlur:r,onKeyDown:u,className:"node-header-input"}),f.length>0&&d&&T.jsx("datalist",{id:d,children:f.map(g=>T.jsx("option",{value:g},g))})]})}function MN(n,l){Ne.setState(o=>({nodes:o.nodes.map(r=>r.id===n?{...r,data:{...r.data,...l}}:r),isDirty:!0}))}function zN(n){const{id:l,sourceX:o,sourceY:r,targetX:u,targetY:f,sourcePosition:d,targetPosition:h,selected:y,style:g,markerEnd:b}=n,[p,v,x]=sd({sourceX:o,sourceY:r,sourcePosition:d,targetX:u,targetY:f,targetPosition:h}),{deleteElements:_}=jo();return T.jsxs(T.Fragment,{children:[T.jsx(Oo,{id:l,path:p,markerEnd:b,style:g}),y&&T.jsx(h3,{children:T.jsx("button",{type:"button",className:"nodrag nopan",title:"Delete connection",onClick:()=>_({edges:[{id:l}]}),style:{position:"absolute",transform:`translate(-50%, -50%) translate(${v}px, ${x}px)`,width:20,height:20,borderRadius:10,background:"#dc2626",color:"#fff",border:"none",cursor:"pointer",fontSize:13,lineHeight:"18px",textAlign:"center",boxShadow:"0 1px 4px rgba(0,0,0,.5)",zIndex:10},children:"×"})})]})}const DN={workflowNode:SN},kN={default:zN};function RN(){const{nodes:n,edges:l,onNodesChange:o,onEdgesChange:r,onConnect:u}=Ne(),f=Ne(v=>v.workflowId),d=jo(),h=I.useRef(null),g=I.useMemo(()=>oN(),[])*22+42,b=I.useCallback(v=>{v.preventDefault(),v.dataTransfer.dropEffect="move"},[]),p=I.useCallback(v=>{v.preventDefault();const x=v.dataTransfer.getData("application/reactflow-type");if(!x||!h.current)return;const _=gv().find(G=>G.type===x);if(!_)return;let C=null;const M=v.dataTransfer.getData("application/reactflow-device");if(M)try{C=JSON.parse(M)}catch{C=null}const E=(C==null?void 0:C.source_keys)||[],H=C?(C.input_type==="gripper_device"?{source_keys:E.join(","),source_key:C.source_key||E[0]||"",position:C.source_key||E[0]||""}:C.input_type==="stereo_camera"||C.input_type==="stereo_rgbd_camera")?{source_keys:E.join(","),source_key:E[0]||"",position:E[0]||""}:{source_key:C.source_key||E[0]||"",position:C.source_key||E[0]||""}:{},w={label:_.label,category:_.category,icon:_.icon,color:_.color,config:{..._.defaultConfig,...H},nodeType:_.type,inputs:_.inputs,outputs:_.outputs,configSchema:_.configSchema,executionTarget:_.executionTarget,...C?{device_name:C.name,device_id:C.id,device_display_name:C.display_name,device_type:C.device_type,depth_keys:C.depth_keys}:{}},z=d.screenToFlowPosition({x:v.clientX-100,y:v.clientY-40});Ne.setState(G=>({nodes:[...G.nodes,{id:mN(),type:"workflowNode",position:z,data:w}],isDirty:!0}))},[d]);return T.jsx("div",{ref:h,className:"flex-1 h-full",onDragOver:b,onDrop:p,style:{"--node-card-height":`${g}px`},children:T.jsxs(f3,{nodes:n,edges:l,onNodesChange:o,onEdgesChange:r,onConnect:u,nodeTypes:DN,edgeTypes:kN,fitView:!0,deleteKeyCode:["Delete","Backspace"],multiSelectionKeyCode:"Shift",snapToGrid:!0,snapGrid:[16,16],defaultEdgeOptions:{style:{stroke:"#475569",strokeWidth:2}},style:{background:"#0f172a"},children:[T.jsx(v3,{color:"#1e293b",gap:32,size:1}),T.jsx(U3,{style:{background:"#1e293b"},maskColor:"rgba(0,0,0,0.5)",nodeColor:v=>{var x;return((x=v.data)==null?void 0:x.color)||"#475569"}}),T.jsx(N3,{className:"!bg-gray-800 !border-gray-700"})]},f||"blank")})}const jN=["rgb_camera","fisheye_camera"],Af=["gripper_device","glove_sensor","mono_camera","rgbd_camera","stereo_camera","stereo_rgbd_camera"],ON=["mediapipe_hand"],HN=[{key:"input",label:"Input",icon:"ant-design:video-camera-outlined"},{key:"process",label:"Process",icon:"ant-design:desktop-outlined"},{key:"review",label:"Review",icon:"ant-design:eye-outlined"},{key:"export",label:"Export",icon:"ant-design:download-outlined"}];function BN(){const[n,l]=I.useState(""),[o,r]=I.useState({}),[u,f]=I.useState(null),d=(v,x)=>{v.dataTransfer.setData("application/reactflow-type",x.type),v.dataTransfer.effectAllowed="move"},h=(v,x)=>{f({text:v,x:Math.min(x.clientX+14,window.innerWidth-256),y:Math.min(x.clientY+12,window.innerHeight-100)})},y=()=>f(null),g=n.trim()?gv().filter(v=>v.label.toLowerCase().includes(n.toLowerCase())):null,b=v=>jN.includes(v.type)||ON.includes(v.type)?!1:v.category==="input"?Af.includes(v.type):!0,p=v=>T.jsx("div",{onMouseEnter:_=>v.description&&h(v.description,_),onMouseMove:_=>v.description&&h(v.description,_),onMouseLeave:y,children:T.jsxs("div",{draggable:!0,onDragStart:_=>d(_,v),className:"flex items-center gap-2 px-2 py-1.5 mx-1 mb-0.5 rounded cursor-grab hover:bg-gray-800 active:cursor-grabbing border border-transparent hover:border-gray-700 transition-colors",children:[T.jsx("span",{className:"w-2.5 h-2.5 rounded-full shrink-0",style:{backgroundColor:v.color}}),T.jsx("span",{className:"text-xs text-gray-300 truncate",children:v.label})]})},v.type);return T.jsxs("div",{className:"w-[220px] bg-gray-900 border-r border-gray-800 flex flex-col shrink-0 overflow-hidden relative",children:[T.jsx("div",{className:"p-2",children:T.jsx("input",{type:"text",placeholder:"Search nodes...",value:n,onChange:v=>l(v.target.value),className:"w-full bg-gray-800 border border-gray-700 rounded px-2 py-1.5 text-xs text-gray-200 placeholder-gray-500 focus:outline-none focus:border-blue-500"})}),T.jsx("div",{className:"flex-1 overflow-y-auto px-1 pb-2",children:g?g.filter(b).map(p):HN.map(v=>{const x=aN(v.key).filter(b).sort((C,M)=>v.key!=="input"?0:Af.indexOf(C.type)-Af.indexOf(M.type)),_=!o[v.key];return T.jsxs("div",{children:[T.jsxs("button",{onClick:()=>r(C=>({...C,[v.key]:!C[v.key]})),className:"w-full flex items-center gap-1.5 px-2 py-1.5 text-[11px] font-semibold text-gray-500 uppercase tracking-wider hover:text-gray-300",children:[T.jsx(To,{icon:v.icon,className:"text-[14px]"}),T.jsx("span",{children:v.label}),T.jsx(To,{icon:_?"ant-design:caret-down-filled":"ant-design:caret-right-outlined",className:"ml-auto text-[10px]"})]}),_&&x.map(p)]},v.key)})}),T.jsx("div",{className:"px-2 py-2 border-t border-gray-800 text-[10px] text-gray-600 text-center",children:"Drag nodes onto canvas"}),u&&T.jsx("div",{className:"pointer-events-none fixed z-[200] w-60 rounded border border-gray-700 bg-gray-950/95 p-2 shadow-xl",style:{left:u.x,top:u.y},children:T.jsx("p",{className:"text-[11px] leading-snug text-gray-300",children:u.text})})]})}function LN(){const n=xt(o=>o.toasts),l=xt(o=>o.removeToast);return n.length===0?null:T.jsx("div",{className:"fixed top-3 right-3 z-[300] flex flex-col gap-2 max-w-xs pointer-events-none",children:n.map(o=>T.jsx("div",{className:`pointer-events-auto rounded border px-3 py-2 text-xs shadow-lg ${o.type==="error"?"border-red-800 bg-red-950/95 text-red-200":"border-gray-700 bg-gray-900/95 text-gray-200"}`,children:T.jsxs("div",{className:"flex items-start gap-2",children:[T.jsx("span",{className:"flex-1 leading-snug break-words",children:o.msg}),T.jsx("button",{type:"button",onClick:()=>l(o.id),className:"text-gray-500 hover:text-gray-300 shrink-0",children:"×"})]})},o.id))})}function UN(){const n=xt(f=>f.dialog),l=xt(f=>f.resolveDialog),[o,r]=I.useState("");if(I.useEffect(()=>{n&&r(n.defaultValue||"")},[n]),!n)return null;const u=n.kind==="prompt";return T.jsx("div",{className:"fixed inset-0 z-[200] flex items-center justify-center bg-black/60 p-4",role:"presentation",children:T.jsxs("div",{className:"w-full max-w-sm rounded-lg border border-gray-700 bg-gray-900 shadow-2xl",role:"dialog","aria-modal":"true",children:[T.jsxs("div",{className:"flex items-start gap-3 border-b border-gray-800 px-4 py-3",children:[T.jsx("span",{className:`mt-0.5 flex h-7 w-7 shrink-0 items-center justify-center rounded-full ${n.danger?"bg-red-900/50 text-red-300":"bg-blue-900/50 text-blue-300"}`,children:T.jsx("span",{className:"text-sm font-bold",children:n.danger?"!":"?"})}),T.jsxs("div",{className:"min-w-0 flex-1",children:[T.jsx("h2",{className:"text-sm font-semibold text-gray-100",children:n.title}),T.jsx("p",{className:"mt-1 text-xs leading-5 text-gray-400",children:n.message}),u&&T.jsx("input",{autoFocus:!0,value:o,onChange:f=>r(f.target.value),onKeyDown:f=>{f.key==="Enter"&&l(o.trim()),f.key==="Escape"&&l(null)},className:"mt-2 w-full bg-gray-800 border border-gray-600 rounded px-2 py-1.5 text-xs text-white focus:outline-none focus:border-blue-500"})]})]}),T.jsxs("div",{className:"flex justify-end gap-2 px-4 py-3",children:[T.jsx("button",{type:"button",onClick:()=>l(null),className:"rounded border border-gray-700 px-3 py-1.5 text-xs text-gray-300 hover:bg-gray-800",children:"Cancel"}),T.jsx("button",{type:"button",onClick:()=>l(u?o.trim():!0),className:`rounded px-3 py-1.5 text-xs text-white ${n.danger?"bg-red-700 hover:bg-red-600":"bg-blue-600 hover:bg-blue-500"}`,children:n.confirmLabel||(u?"OK":"Confirm")})]})]})})}function GN(){const n=window.__EGO_USER__;return n!=null&&n.role?Promise.resolve(n):en("/api/v1/auth/me")}function _m(n){const l=u=>!u||typeof u!="object"?u:Array.isArray(u)?u.map(l):Object.keys(u).sort().reduce((f,d)=>(f[d]=l(u[d]),f),{}),o=((n==null?void 0:n.nodes)||[]).map(u=>{var f,d,h,y;return{id:u.id,type:u.type||"workflowNode",position:{x:Number(((f=u.position)==null?void 0:f.x)||0),y:Number(((d=u.position)==null?void 0:d.y)||0)},parentId:u.parentId||null,data:{nodeType:((h=u.data)==null?void 0:h.nodeType)||null,config:l(((y=u.data)==null?void 0:y.config)||{})}}}).sort((u,f)=>String(u.id).localeCompare(String(f.id))),r=((n==null?void 0:n.edges)||[]).map(u=>({id:u.id||null,source:u.source,target:u.target,sourceHandle:u.sourceHandle||null,targetHandle:u.targetHandle||null,type:u.type||null})).sort((u,f)=>String(u.id).localeCompare(String(f.id)));return JSON.stringify({nodes:o,edges:r})}function YN(n,l){return _m(n)===_m(l)}function VN(){return I.useEffect(()=>{K3().then(n=>iN(n)).catch(()=>{})},[]),I.useEffect(()=>{const n=l=>{const o=l.ctrlKey||l.metaKey;o&&l.key==="z"&&!l.shiftKey&&(l.preventDefault(),Ne.getState().undo()),o&&(l.key==="y"||l.key==="z"&&l.shiftKey)&&(l.preventDefault(),Ne.getState().redo())};return window.addEventListener("keydown",n),()=>window.removeEventListener("keydown",n)},[]),I.useEffect(()=>{const n=Ne.getState(),l=new URLSearchParams(window.location.search),o=l.get("workflow"),r=l.get("project");GN().then(f=>Ne.setState({userRole:f.role})).catch(()=>{}),r&&Ne.setState({workflowProjectId:r});const u=async()=>{try{const f=localStorage.getItem("workflow_draft");if(f){let d=JSON.parse(f);const h=d!=null&&d.nodes&&Array.isArray(d.nodes)?Jf({nodes:d.nodes,edges:d.edges||[]}):null;if(d.workflowId)try{const y=await Qf(String(d.workflowId));h&&YN(h,y.graph)&&(Fl(),d=null)}catch{}if(d&&d.nodes&&Array.isArray(d.nodes)&&d.nodes.length>0){const y=h||Jf(d);Ne.setState({nodes:y.nodes,edges:y.edges,workflowId:d.workflowId||null,workflowProjectId:r||d.workflowProjectId||null,workflowName:d.workflowName||"Untitled",isDirty:!0}),n.loadWorkflowList();const g=r||d.workflowProjectId;n.loadInputsForWorkflow(g);return}}}catch{}n.loadWorkflowList().then(()=>{const{workflows:f}=Ne.getState();f.length>0?n.loadWorkflow(f[f.length-1].id).then(()=>{const d=Ne.getState();return d.loadInputsForWorkflow(d.workflowProjectId||r)}):r?n.loadInputsForWorkflow(r):n.loadInputsForWorkflow(null)})};if(o){n.loadWorkflowList(),n.loadWorkflow(o).then(()=>{const f=Ne.getState();return f.loadInputsForWorkflow(f.workflowProjectId||r)}).catch(()=>{u()});return}u()},[]),T.jsxs(uv,{children:[T.jsxs("div",{className:"h-full w-full flex flex-col",children:[T.jsx(qN,{}),T.jsxs("div",{className:"flex-1 flex min-h-0",children:[T.jsx(RN,{}),T.jsx(BN,{})]})]}),T.jsx(LN,{}),T.jsx(UN,{})]})}function qN(){const{workflowName:n,workflowId:l,isDirty:o,isSaving:r,workflows:u,userRole:f,isPresetWorkflow:d,saveWorkflowSafe:h,saveWorkflowAs:y,loadWorkflow:g,loadWorkflowList:b}=Ne(),[p,v]=I.useState(!1),[x,_]=I.useState(n),[C,M]=I.useState(""),[E,H]=I.useState(null),[w,z]=I.useState(!1),[G,B]=I.useState(!1),[L,Q]=I.useState(!1),K=f==="admin",ue=d&&!K,$=Y=>{M(Y),setTimeout(()=>M(""),2e3)},ie=()=>{const Y=Ne.getState();if(!Y.workflowId)return;const fe=new URLSearchParams(window.location.search);fe.set("workflow",Y.workflowId),Y.workflowProjectId?fe.set("project",Y.workflowProjectId):fe.delete("project");const he=fe.toString();window.history.replaceState(null,"",`/workflow-studio${he?`?${he}`:""}`)},ne=async(Y=Ne.getState())=>{const fe=await xt.getState().prompt("This is a template workflow and cannot be overwritten. Save a copy as:",{title:"Save a copy",defaultValue:(Y.workflowName||"Untitled")+" (copy)",confirmLabel:"Save"});if(!(!fe||!fe.trim()))try{await Y.saveWorkflowAs(fe.trim()),await Y.loadWorkflowList(),ie(),$("Saved as copy")}catch(he){xt.getState().pushToast(he.message||"Save failed","error")}},D=async()=>{const Y=Ne.getState(),fe=await Y.saveWorkflowSafe();if(fe==="needs-save-as"){await ne(Y);return}fe==="saved"&&$("Saved")},q=async()=>{const Y=Ne.getState();if(Y.workflowId)try{const fe=await J3(Y.workflowId);if(fe.project_count>=2){const he=fe.projects.map(ge=>ge.name).join(", ");H({title:"Shared workflow",message:`This workflow is used by ${fe.project_count} projects (${he}). Saving directly will affect all of them.`,confirmLabel:"Save directly",secondaryLabel:"Save as copy",onConfirm:()=>D(),onSecondary:()=>A()});return}}catch(fe){console.warn("usage check failed, saving directly",fe)}await D()},A=async()=>{const Y=Ne.getState(),fe=await xt.getState().prompt("Save a copy as:",{title:"Save a copy",defaultValue:(Y.workflowName||"Untitled")+" (copy)",confirmLabel:"Save"});if(!(!fe||!fe.trim()))try{await Y.saveWorkflowAs(fe.trim()),await Y.loadWorkflowList(),ie(),$("Saved as copy")}catch(he){xt.getState().pushToast(he.message||"Save failed","error")}},j=async()=>{const Y=Ne.getState();if(!Y.workflowId){_(Y.workflowName),v(!0);return}if(ue){await ne(Y);return}if(Y.workflowId&&Y.nodes.length===0){H({title:"Save empty workflow?",message:"This workflow has no nodes, so it will not process any uploaded data. Save anyway?",confirmLabel:"Save anyway",onConfirm:()=>q()});return}await q()},V=async()=>{const Y=x.trim();if(v(!1),!Y){_(n);return}if(Y!==n){if(ue){$("Template workflows can only be renamed by admin. Save a copy instead.");return}if(l){Ne.setState({workflowName:Y});try{await h(),await b(),$("Renamed")}catch{}}else await y(Y),await b(),$("Saved")}},k=async Y=>{const fe=Ne.getState();if(Y==="__new__"){fe.newWorkflow();const he=new URLSearchParams(window.location.search),ge=he.get("project");ge?(Ne.setState({workflowProjectId:ge}),await Ne.getState().loadInputsForWorkflow(ge)):await Ne.getState().loadInputsForWorkflow(null),he.delete("workflow");const me=he.toString();window.history.replaceState(null,"",`/workflow-studio${me?`?${me}`:""}`)}else if(Y){await g(Y);const he=Ne.getState();if(he.workflowId!==Y)return;const ge=new URLSearchParams(window.location.search).get("project"),me=he.workflowProjectId||ge;if(await he.loadInputsForWorkflow(me),Ne.getState().workflowId!==Y)return;ie()}},Z=async Y=>{Q(!0);try{const fe=Ne.getState();Y&&await fe.newWorkflowFromTemplate(Y);const he=new URLSearchParams(window.location.search);he.delete("workflow");const ge=he.toString();window.history.replaceState(null,"",`/workflow-studio${ge?`?${ge}`:""}`)}catch(fe){$((fe==null?void 0:fe.message)||"Failed to load template")}finally{Q(!1),B(!1)}},N=async Y=>{const fe=Y.target.value;if(Ne.getState().isDirty){H({title:"Discard unsaved changes?",message:"Your current workflow has unsaved changes. Switching workflows will discard them.",confirmLabel:"Discard and switch",danger:!0,onConfirm:()=>k(fe)});return}await k(fe)},R=()=>{if(Ne.getState().isDirty){H({title:"Discard unsaved changes?",message:"Your current workflow has unsaved changes. Starting from a template or a blank workflow will discard them.",confirmLabel:"Discard and continue",danger:!0,onConfirm:()=>B(!0)});return}B(!0)},ee=()=>{const Y=Ne.getState();if(!Y.workflowId)return;const fe=!d;H({title:fe?"Make this a template workflow?":"Remove template status?",message:fe?"This workflow will become a shared template for all users.":"This workflow will become a regular workflow. Its nodes and connections will not change.",confirmLabel:fe?"Make Template":"Remove template status",onConfirm:async()=>{try{await $f(Y.workflowId,{is_preset:fe}),await b(),Ne.setState({isPresetWorkflow:fe}),$(fe?"Template created":"Template removed")}catch(he){$(he.message||"Failed")}}})},ae=Y=>{z(!1),H(fe=>fe===Y?null:fe)},de=async()=>{const Y=E;if(!(!Y||w)){z(!0);try{await Y.onConfirm()}catch(fe){$((fe==null?void 0:fe.message)||"Operation failed")}finally{ae(Y)}}},se=async()=>{var fe;const Y=E;if(!(!Y||w)){z(!0);try{await((fe=Y.onSecondary)==null?void 0:fe.call(Y))}catch(he){$((he==null?void 0:he.message)||"Operation failed")}finally{ae(Y)}}},oe=I.useRef(j);I.useEffect(()=>{oe.current=j}),I.useEffect(()=>{const Y=fe=>{(fe.ctrlKey||fe.metaKey)&&fe.key==="s"&&(fe.preventDefault(),oe.current())};return window.addEventListener("keydown",Y),()=>window.removeEventListener("keydown",Y)},[]);const P=o?"bg-yellow-500":C?"bg-green-500":"bg-gray-600";return T.jsxs("div",{className:"relative flex items-center gap-2 px-4 py-1.5 bg-gray-900 border-b border-gray-800 shrink-0",children:[T.jsx("span",{className:`w-2 h-2 rounded-full shrink-0 ${P}`}),T.jsxs("select",{value:l||"",onChange:N,onClick:()=>b(),className:"bg-transparent border border-gray-700 rounded px-1.5 py-0.5 text-xs font-semibold text-gray-200 focus:outline-none focus:border-blue-500 cursor-pointer max-w-[200px]",children:[!l&&T.jsx("option",{value:"",disabled:!0,hidden:!0,children:"New Workflow"}),u.map(Y=>T.jsxs("option",{value:Y.id,className:"bg-gray-800 text-gray-200",children:[Y.name,Y.is_preset?" (Template)":""]},Y.id)),l&&!u.find(Y=>Y.id===l)&&T.jsx("option",{value:l,className:"bg-gray-800 text-gray-200",children:n}),T.jsx("option",{value:"__new__",className:"bg-gray-800 text-gray-400",children:"+ New Workflow"})]}),p?T.jsx(T.Fragment,{children:T.jsx("input",{autoFocus:!0,value:x,onChange:Y=>_(Y.target.value),onKeyDown:Y=>{Y.key==="Enter"&&V(),Y.key==="Escape"&&(_(n),v(!1))},onBlur:V,className:"bg-gray-800 border border-gray-600 rounded px-1.5 py-0.5 text-xs text-white w-48 focus:outline-none focus:border-blue-500",title:"Press Enter to save"})}):T.jsxs("span",{onClick:()=>{if(ue){$("Template workflows can only be renamed by admin. Save a copy instead.");return}_(n),v(!0)},title:"Click to rename workflow",className:"text-xs font-semibold text-gray-200 hover:text-blue-400 hover:underline cursor-pointer whitespace-nowrap",children:[n," ",d&&T.jsx("span",{className:"text-[9px] text-yellow-400 border border-yellow-700 rounded px-1 ml-1 align-middle",children:"Template"}),!ue&&T.jsx("span",{className:"text-[10px] text-gray-500 ml-1",children:"✎"})]}),C&&T.jsx("span",{className:"text-[11px] text-green-400",children:C}),T.jsx("div",{className:"flex-1"}),T.jsxs("button",{onClick:()=>{b(),R()},title:"Start a new workflow from a template (processing chain) or a blank canvas",className:"text-[11px] text-blue-400 hover:text-blue-300 hover:bg-blue-900/30 border border-blue-900/60 px-1.5 py-0.5 rounded",children:[T.jsx(To,{icon:"ant-design:project-outlined",className:"text-[12px] align-[-2px] mr-0.5"})," Template"]}),K&&l&&T.jsx("button",{onClick:ee,className:"text-[11px] text-yellow-400 hover:text-yellow-300 hover:bg-yellow-900/30 px-1.5 py-0.5 rounded",children:d?"Unset Template":"Make Template"}),T.jsx("button",{onClick:j,disabled:r,className:"text-[11px] bg-blue-600 hover:bg-blue-500 text-white px-2 py-0.5 rounded disabled:opacity-50",children:r?"...":"Save"}),l&&!ue&&T.jsx("button",{onClick:()=>H({title:"Delete this workflow?",message:"This action cannot be undone. The workflow definition will be removed.",confirmLabel:"Delete workflow",danger:!0,onConfirm:async()=>{await Z3(l),await b();const{workflows:Y}=Ne.getState();Y.length>0?await g(Y[0].id):Ne.getState().newWorkflow(),ie()}}),className:"text-[11px] text-red-400 hover:text-red-300 hover:bg-red-900/30 px-1.5 py-0.5 rounded",children:"Del"}),E&&T.jsx("div",{className:"fixed inset-0 z-[100] flex items-center justify-center bg-black/60 p-4",role:"presentation",children:T.jsxs("div",{className:"w-full max-w-sm rounded-lg border border-gray-700 bg-gray-900 shadow-2xl",role:"dialog","aria-modal":"true","aria-labelledby":"workflow-dialog-title",children:[T.jsxs("div",{className:"flex items-start gap-3 border-b border-gray-800 px-4 py-3",children:[T.jsx("span",{className:`mt-0.5 flex h-7 w-7 shrink-0 items-center justify-center rounded-full ${E.danger?"bg-red-900/50 text-red-300":"bg-blue-900/50 text-blue-300"}`,children:T.jsx("span",{className:"text-sm font-bold",children:E.danger?"!":"?"})}),T.jsxs("div",{className:"min-w-0",children:[T.jsx("h2",{id:"workflow-dialog-title",className:"text-sm font-semibold text-gray-100",children:E.title}),T.jsx("p",{className:"mt-1 text-xs leading-5 text-gray-400",children:E.message})]})]}),T.jsxs("div",{className:"flex justify-end gap-2 px-4 py-3",children:[T.jsx("button",{type:"button",disabled:w,onClick:()=>H(null),className:"rounded border border-gray-700 px-3 py-1.5 text-xs text-gray-300 hover:bg-gray-800 disabled:opacity-50",children:"Cancel"}),E.secondaryLabel&&T.jsx("button",{type:"button",disabled:w,onClick:se,className:"rounded border border-gray-700 px-3 py-1.5 text-xs text-gray-300 hover:bg-gray-800 disabled:opacity-50",children:w?"Working...":E.secondaryLabel}),T.jsx("button",{type:"button",disabled:w,onClick:de,className:`rounded px-3 py-1.5 text-xs text-white disabled:opacity-50 ${E.danger?"bg-red-700 hover:bg-red-600":"bg-blue-600 hover:bg-blue-500"}`,children:w?"Working...":E.confirmLabel})]})]})}),G&&T.jsx("div",{className:"fixed inset-0 z-[100] flex items-center justify-center bg-black/60 p-4",role:"presentation",children:T.jsxs("div",{className:"w-full max-w-sm rounded-lg border border-gray-700 bg-gray-900 shadow-2xl",role:"dialog","aria-modal":"true","aria-labelledby":"template-dialog-title",children:[T.jsxs("div",{className:"border-b border-gray-800 px-4 py-3",children:[T.jsx("h2",{id:"template-dialog-title",className:"text-sm font-semibold text-gray-100",children:"Start from Template"}),T.jsx("p",{className:"mt-1 text-xs leading-5 text-gray-400",children:"Templates contain the processing chain only — input device cards appear as your collectors report data. Applying a template replaces the current canvas."})]}),T.jsxs("div",{className:"px-4 py-3 space-y-1.5",children:[u.filter(Y=>Y.is_preset).map(Y=>T.jsx("button",{type:"button",disabled:L,onClick:()=>Z(Y),className:"w-full text-left rounded border border-gray-700 px-3 py-2 hover:border-blue-600 hover:bg-gray-800 disabled:opacity-50",children:T.jsxs("div",{className:"flex items-center gap-2",children:[T.jsx(To,{icon:"ant-design:database-outlined",className:"text-[14px] text-gray-500 shrink-0"}),T.jsxs("div",{className:"min-w-0",children:[T.jsx("div",{className:"text-xs text-gray-200 truncate",children:Y.name}),T.jsxs("div",{className:"text-[10px] text-gray-500 mt-0.5",children:["Template · ",Y.node_count??0," nodes · processing chain only"]})]})]})},Y.id)),!u.some(Y=>Y.is_preset)&&T.jsx("div",{className:"text-[11px] text-gray-600 px-1 pt-1",children:"No templates available — an admin can mark workflows as templates."}),T.jsx("div",{className:"text-[10px] text-gray-600 pt-1",children:"Applying a template replaces the current canvas — your workflow name and ID stay the same."})]}),T.jsx("div",{className:"flex justify-end gap-2 px-4 py-3",children:T.jsx("button",{type:"button",disabled:L,onClick:()=>B(!1),className:"rounded border border-gray-700 px-3 py-1.5 text-xs text-gray-300 hover:bg-gray-800 disabled:opacity-50",children:"Cancel"})})]})})]})}const wm=document.getElementById("workflow-root")||document.getElementById("root");wm&&Rx.createRoot(wm).render(T.jsx(I.StrictMode,{children:T.jsx(VN,{})}));
diff --git a/processor/web/static/workflow-studio/assets/index-Byx6G-Zk.css b/processor/web/static/workflow-studio/assets/index-ap1gwH28.css
similarity index 57%
rename from processor/web/static/workflow-studio/assets/index-Byx6G-Zk.css
rename to processor/web/static/workflow-studio/assets/index-ap1gwH28.css
index 928594d5c121f55451cf71e257df54568df81f67..ed890d1ecb3aa509a82de4fdc4ddd823ad353800 100644
--- a/processor/web/static/workflow-studio/assets/index-Byx6G-Zk.css
+++ b/processor/web/static/workflow-studio/assets/index-ap1gwH28.css
@@ -1 +1 @@
-.react-flow{direction:ltr;--xy-edge-stroke-default: #b1b1b7;--xy-edge-stroke-width-default: 1;--xy-edge-stroke-selected-default: #555;--xy-connectionline-stroke-default: #b1b1b7;--xy-connectionline-stroke-width-default: 1;--xy-attribution-background-color-default: rgba(255, 255, 255, .5);--xy-minimap-background-color-default: #fff;--xy-minimap-mask-background-color-default: rgba(240, 240, 240, .6);--xy-minimap-mask-stroke-color-default: transparent;--xy-minimap-mask-stroke-width-default: 1;--xy-minimap-node-background-color-default: #e2e2e2;--xy-minimap-node-stroke-color-default: transparent;--xy-minimap-node-stroke-width-default: 2;--xy-background-color-default: transparent;--xy-background-pattern-dots-color-default: #91919a;--xy-background-pattern-lines-color-default: #eee;--xy-background-pattern-cross-color-default: #e2e2e2;background-color:var(--xy-background-color, var(--xy-background-color-default));--xy-node-color-default: inherit;--xy-node-border-default: 1px solid #1a192b;--xy-node-background-color-default: #fff;--xy-node-group-background-color-default: rgba(240, 240, 240, .25);--xy-node-boxshadow-hover-default: 0 1px 4px 1px rgba(0, 0, 0, .08);--xy-node-boxshadow-selected-default: 0 0 0 .5px #1a192b;--xy-node-border-radius-default: 3px;--xy-handle-background-color-default: #1a192b;--xy-handle-border-color-default: #fff;--xy-selection-background-color-default: rgba(0, 89, 220, .08);--xy-selection-border-default: 1px dotted rgba(0, 89, 220, .8);--xy-controls-button-background-color-default: #fefefe;--xy-controls-button-background-color-hover-default: #f4f4f4;--xy-controls-button-color-default: inherit;--xy-controls-button-color-hover-default: inherit;--xy-controls-button-border-color-default: #eee;--xy-controls-box-shadow-default: 0 0 2px 1px rgba(0, 0, 0, .08);--xy-edge-label-background-color-default: #ffffff;--xy-edge-label-color-default: inherit;--xy-resize-background-color-default: #3367d9}.react-flow.dark{--xy-edge-stroke-default: #3e3e3e;--xy-edge-stroke-width-default: 1;--xy-edge-stroke-selected-default: #727272;--xy-connectionline-stroke-default: #b1b1b7;--xy-connectionline-stroke-width-default: 1;--xy-attribution-background-color-default: rgba(150, 150, 150, .25);--xy-minimap-background-color-default: #141414;--xy-minimap-mask-background-color-default: rgba(60, 60, 60, .6);--xy-minimap-mask-stroke-color-default: transparent;--xy-minimap-mask-stroke-width-default: 1;--xy-minimap-node-background-color-default: #2b2b2b;--xy-minimap-node-stroke-color-default: transparent;--xy-minimap-node-stroke-width-default: 2;--xy-background-color-default: #141414;--xy-background-pattern-dots-color-default: #555;--xy-background-pattern-lines-color-default: #333;--xy-background-pattern-cross-color-default: #333;--xy-node-color-default: #f8f8f8;--xy-node-border-default: 1px solid #3c3c3c;--xy-node-background-color-default: #1e1e1e;--xy-node-group-background-color-default: rgba(240, 240, 240, .25);--xy-node-boxshadow-hover-default: 0 1px 4px 1px rgba(255, 255, 255, .08);--xy-node-boxshadow-selected-default: 0 0 0 .5px #999;--xy-handle-background-color-default: #bebebe;--xy-handle-border-color-default: #1e1e1e;--xy-selection-background-color-default: rgba(200, 200, 220, .08);--xy-selection-border-default: 1px dotted rgba(200, 200, 220, .8);--xy-controls-button-background-color-default: #2b2b2b;--xy-controls-button-background-color-hover-default: #3e3e3e;--xy-controls-button-color-default: #f8f8f8;--xy-controls-button-color-hover-default: #fff;--xy-controls-button-border-color-default: #5b5b5b;--xy-controls-box-shadow-default: 0 0 2px 1px rgba(0, 0, 0, .08);--xy-edge-label-background-color-default: #141414;--xy-edge-label-color-default: #f8f8f8}.react-flow__background{background-color:var(--xy-background-color-props, var(--xy-background-color, var(--xy-background-color-default)));pointer-events:none;z-index:-1}.react-flow__container{position:absolute;width:100%;height:100%;top:0;left:0}.react-flow__pane{z-index:1;touch-action:none}.react-flow__pane.draggable{cursor:grab}.react-flow__pane.dragging{cursor:grabbing}.react-flow__pane.selection{cursor:pointer}.react-flow__viewport{transform-origin:0 0;z-index:2;pointer-events:none}.react-flow__renderer{z-index:4}.react-flow__selection{z-index:6}.react-flow__nodesselection-rect:focus,.react-flow__nodesselection-rect:focus-visible{outline:none}.react-flow__edge-path{stroke:var(--xy-edge-stroke, var(--xy-edge-stroke-default));stroke-width:var(--xy-edge-stroke-width, var(--xy-edge-stroke-width-default));fill:none}.react-flow__connection-path{stroke:var(--xy-connectionline-stroke, var(--xy-connectionline-stroke-default));stroke-width:var(--xy-connectionline-stroke-width, var(--xy-connectionline-stroke-width-default));fill:none}.react-flow .react-flow__edges{position:absolute}.react-flow .react-flow__edges svg{overflow:visible;position:absolute;pointer-events:none}.react-flow__edge{pointer-events:visibleStroke}.react-flow__edge.selectable{cursor:pointer}.react-flow__edge.animated path{stroke-dasharray:5;animation:dashdraw .5s linear infinite}.react-flow__edge.animated path.react-flow__edge-interaction{stroke-dasharray:none;animation:none}.react-flow__edge.inactive{pointer-events:none}.react-flow__edge.selected,.react-flow__edge:focus,.react-flow__edge:focus-visible{outline:none}.react-flow__edge.selected .react-flow__edge-path,.react-flow__edge.selectable:focus .react-flow__edge-path,.react-flow__edge.selectable:focus-visible .react-flow__edge-path{stroke:var(--xy-edge-stroke-selected, var(--xy-edge-stroke-selected-default))}.react-flow__edge-textwrapper{pointer-events:all}.react-flow__edge .react-flow__edge-text{pointer-events:none;-webkit-user-select:none;-moz-user-select:none;user-select:none}.react-flow__arrowhead polyline{stroke:var(--xy-edge-stroke, var(--xy-edge-stroke-default))}.react-flow__arrowhead polyline.arrowclosed{fill:var(--xy-edge-stroke, var(--xy-edge-stroke-default))}.react-flow__connection{pointer-events:none}.react-flow__connection .animated{stroke-dasharray:5;animation:dashdraw .5s linear infinite}svg.react-flow__connectionline{z-index:1001;overflow:visible;position:absolute}.react-flow__nodes{pointer-events:none;transform-origin:0 0}.react-flow__node{position:absolute;-webkit-user-select:none;-moz-user-select:none;user-select:none;pointer-events:all;transform-origin:0 0;box-sizing:border-box;cursor:default}.react-flow__node.selectable{cursor:pointer}.react-flow__node.draggable{cursor:grab;pointer-events:all}.react-flow__node.draggable.dragging{cursor:grabbing}.react-flow__nodesselection{z-index:3;transform-origin:left top;pointer-events:none}.react-flow__nodesselection-rect{position:absolute;pointer-events:all;cursor:grab}.react-flow__handle{position:absolute;pointer-events:none;min-width:5px;min-height:5px;width:6px;height:6px;background-color:var(--xy-handle-background-color, var(--xy-handle-background-color-default));border:1px solid var(--xy-handle-border-color, var(--xy-handle-border-color-default));border-radius:100%}.react-flow__handle.connectingfrom{pointer-events:all}.react-flow__handle.connectionindicator{pointer-events:all;cursor:crosshair}.react-flow__handle-bottom{top:auto;left:50%;bottom:0;transform:translate(-50%,50%)}.react-flow__handle-top{top:0;left:50%;transform:translate(-50%,-50%)}.react-flow__handle-left{top:50%;left:0;transform:translate(-50%,-50%)}.react-flow__handle-right{top:50%;right:0;transform:translate(50%,-50%)}.react-flow__edgeupdater{cursor:move;pointer-events:all}.react-flow__pane.selection .react-flow__panel{pointer-events:none}.react-flow__panel{position:absolute;z-index:5;margin:15px}.react-flow__panel.top{top:0}.react-flow__panel.bottom{bottom:0}.react-flow__panel.top.center,.react-flow__panel.bottom.center{left:50%;transform:translate(-15px) translate(-50%)}.react-flow__panel.left{left:0}.react-flow__panel.right{right:0}.react-flow__panel.left.center,.react-flow__panel.right.center{top:50%;transform:translateY(-15px) translateY(-50%)}.react-flow__attribution{font-size:10px;background:var(--xy-attribution-background-color, var(--xy-attribution-background-color-default));padding:2px 3px;margin:0}.react-flow__attribution a{text-decoration:none;color:#999}@keyframes dashdraw{0%{stroke-dashoffset:10}}.react-flow__edgelabel-renderer{position:absolute;width:100%;height:100%;pointer-events:none;-webkit-user-select:none;-moz-user-select:none;user-select:none;left:0;top:0}.react-flow__viewport-portal{position:absolute;width:100%;height:100%;left:0;top:0;-webkit-user-select:none;-moz-user-select:none;user-select:none}.react-flow__minimap{background:var( --xy-minimap-background-color-props, var(--xy-minimap-background-color, var(--xy-minimap-background-color-default)) )}.react-flow__minimap-svg{display:block}.react-flow__minimap-mask{fill:var( --xy-minimap-mask-background-color-props, var(--xy-minimap-mask-background-color, var(--xy-minimap-mask-background-color-default)) );stroke:var( --xy-minimap-mask-stroke-color-props, var(--xy-minimap-mask-stroke-color, var(--xy-minimap-mask-stroke-color-default)) );stroke-width:var( --xy-minimap-mask-stroke-width-props, var(--xy-minimap-mask-stroke-width, var(--xy-minimap-mask-stroke-width-default)) )}.react-flow__minimap-node{fill:var( --xy-minimap-node-background-color-props, var(--xy-minimap-node-background-color, var(--xy-minimap-node-background-color-default)) );stroke:var( --xy-minimap-node-stroke-color-props, var(--xy-minimap-node-stroke-color, var(--xy-minimap-node-stroke-color-default)) );stroke-width:var( --xy-minimap-node-stroke-width-props, var(--xy-minimap-node-stroke-width, var(--xy-minimap-node-stroke-width-default)) )}.react-flow__background-pattern.dots{fill:var( --xy-background-pattern-color-props, var(--xy-background-pattern-color, var(--xy-background-pattern-dots-color-default)) )}.react-flow__background-pattern.lines{stroke:var( --xy-background-pattern-color-props, var(--xy-background-pattern-color, var(--xy-background-pattern-lines-color-default)) )}.react-flow__background-pattern.cross{stroke:var( --xy-background-pattern-color-props, var(--xy-background-pattern-color, var(--xy-background-pattern-cross-color-default)) )}.react-flow__controls{display:flex;flex-direction:column;box-shadow:var(--xy-controls-box-shadow, var(--xy-controls-box-shadow-default))}.react-flow__controls.horizontal{flex-direction:row}.react-flow__controls-button{display:flex;justify-content:center;align-items:center;height:26px;width:26px;padding:4px;border:none;background:var(--xy-controls-button-background-color, var(--xy-controls-button-background-color-default));border-bottom:1px solid var( --xy-controls-button-border-color-props, var(--xy-controls-button-border-color, var(--xy-controls-button-border-color-default)) );color:var( --xy-controls-button-color-props, var(--xy-controls-button-color, var(--xy-controls-button-color-default)) );cursor:pointer;-webkit-user-select:none;-moz-user-select:none;user-select:none}.react-flow__controls-button svg{width:100%;max-width:12px;max-height:12px;fill:currentColor}.react-flow__edge.updating .react-flow__edge-path{stroke:#777}.react-flow__edge-text{font-size:10px}.react-flow__node.selectable:focus,.react-flow__node.selectable:focus-visible{outline:none}.react-flow__node-input,.react-flow__node-default,.react-flow__node-output,.react-flow__node-group{padding:10px;border-radius:var(--xy-node-border-radius, var(--xy-node-border-radius-default));width:150px;font-size:12px;color:var(--xy-node-color, var(--xy-node-color-default));text-align:center;border:var(--xy-node-border, var(--xy-node-border-default));background-color:var(--xy-node-background-color, var(--xy-node-background-color-default))}.react-flow__node-input.selectable:hover,.react-flow__node-default.selectable:hover,.react-flow__node-output.selectable:hover,.react-flow__node-group.selectable:hover{box-shadow:var(--xy-node-boxshadow-hover, var(--xy-node-boxshadow-hover-default))}.react-flow__node-input.selectable.selected,.react-flow__node-input.selectable:focus,.react-flow__node-input.selectable:focus-visible,.react-flow__node-default.selectable.selected,.react-flow__node-default.selectable:focus,.react-flow__node-default.selectable:focus-visible,.react-flow__node-output.selectable.selected,.react-flow__node-output.selectable:focus,.react-flow__node-output.selectable:focus-visible,.react-flow__node-group.selectable.selected,.react-flow__node-group.selectable:focus,.react-flow__node-group.selectable:focus-visible{box-shadow:var(--xy-node-boxshadow-selected, var(--xy-node-boxshadow-selected-default))}.react-flow__node-group{background-color:var(--xy-node-group-background-color, var(--xy-node-group-background-color-default))}.react-flow__nodesselection-rect,.react-flow__selection{background:var(--xy-selection-background-color, var(--xy-selection-background-color-default));border:var(--xy-selection-border, var(--xy-selection-border-default))}.react-flow__nodesselection-rect:focus,.react-flow__nodesselection-rect:focus-visible,.react-flow__selection:focus,.react-flow__selection:focus-visible{outline:none}.react-flow__controls-button:hover{background:var( --xy-controls-button-background-color-hover-props, var(--xy-controls-button-background-color-hover, var(--xy-controls-button-background-color-hover-default)) );color:var( --xy-controls-button-color-hover-props, var(--xy-controls-button-color-hover, var(--xy-controls-button-color-hover-default)) )}.react-flow__controls-button:disabled{pointer-events:none}.react-flow__controls-button:disabled svg{fill-opacity:.4}.react-flow__controls-button:last-child{border-bottom:none}.react-flow__controls.horizontal .react-flow__controls-button{border-bottom:none;border-right:1px solid var( --xy-controls-button-border-color-props, var(--xy-controls-button-border-color, var(--xy-controls-button-border-color-default)) )}.react-flow__controls.horizontal .react-flow__controls-button:last-child{border-right:none}.react-flow__resize-control{position:absolute}.react-flow__resize-control.left,.react-flow__resize-control.right{cursor:ew-resize}.react-flow__resize-control.top,.react-flow__resize-control.bottom{cursor:ns-resize}.react-flow__resize-control.top.left,.react-flow__resize-control.bottom.right{cursor:nwse-resize}.react-flow__resize-control.bottom.left,.react-flow__resize-control.top.right{cursor:nesw-resize}.react-flow__resize-control.handle{width:5px;height:5px;border:1px solid #fff;border-radius:1px;background-color:var(--xy-resize-background-color, var(--xy-resize-background-color-default));translate:-50% -50%}.react-flow__resize-control.handle.left{left:0;top:50%}.react-flow__resize-control.handle.right{left:100%;top:50%}.react-flow__resize-control.handle.top{left:50%;top:0}.react-flow__resize-control.handle.bottom{left:50%;top:100%}.react-flow__resize-control.handle.top.left,.react-flow__resize-control.handle.bottom.left{left:0}.react-flow__resize-control.handle.top.right,.react-flow__resize-control.handle.bottom.right{left:100%}.react-flow__resize-control.line{border-color:var(--xy-resize-background-color, var(--xy-resize-background-color-default));border-width:0;border-style:solid}.react-flow__resize-control.line.left,.react-flow__resize-control.line.right{width:1px;transform:translate(-50%);top:0;height:100%}.react-flow__resize-control.line.left{left:0;border-left-width:1px}.react-flow__resize-control.line.right{left:100%;border-right-width:1px}.react-flow__resize-control.line.top,.react-flow__resize-control.line.bottom{height:1px;transform:translateY(-50%);left:0;width:100%}.react-flow__resize-control.line.top{top:0;border-top-width:1px}.react-flow__resize-control.line.bottom{border-bottom-width:1px;top:100%}.react-flow__edge-textbg{fill:var(--xy-edge-label-background-color, var(--xy-edge-label-background-color-default))}.react-flow__edge-text{fill:var(--xy-edge-label-color, var(--xy-edge-label-color-default))}*,:before,:after{--tw-border-spacing-x: 0;--tw-border-spacing-y: 0;--tw-translate-x: 0;--tw-translate-y: 0;--tw-rotate: 0;--tw-skew-x: 0;--tw-skew-y: 0;--tw-scale-x: 1;--tw-scale-y: 1;--tw-pan-x: ;--tw-pan-y: ;--tw-pinch-zoom: ;--tw-scroll-snap-strictness: proximity;--tw-gradient-from-position: ;--tw-gradient-via-position: ;--tw-gradient-to-position: ;--tw-ordinal: ;--tw-slashed-zero: ;--tw-numeric-figure: ;--tw-numeric-spacing: ;--tw-numeric-fraction: ;--tw-ring-inset: ;--tw-ring-offset-width: 0px;--tw-ring-offset-color: #fff;--tw-ring-color: rgb(59 130 246 / .5);--tw-ring-offset-shadow: 0 0 #0000;--tw-ring-shadow: 0 0 #0000;--tw-shadow: 0 0 #0000;--tw-shadow-colored: 0 0 #0000;--tw-blur: ;--tw-brightness: ;--tw-contrast: ;--tw-grayscale: ;--tw-hue-rotate: ;--tw-invert: ;--tw-saturate: ;--tw-sepia: ;--tw-drop-shadow: ;--tw-backdrop-blur: ;--tw-backdrop-brightness: ;--tw-backdrop-contrast: ;--tw-backdrop-grayscale: ;--tw-backdrop-hue-rotate: ;--tw-backdrop-invert: ;--tw-backdrop-opacity: ;--tw-backdrop-saturate: ;--tw-backdrop-sepia: ;--tw-contain-size: ;--tw-contain-layout: ;--tw-contain-paint: ;--tw-contain-style: }::backdrop{--tw-border-spacing-x: 0;--tw-border-spacing-y: 0;--tw-translate-x: 0;--tw-translate-y: 0;--tw-rotate: 0;--tw-skew-x: 0;--tw-skew-y: 0;--tw-scale-x: 1;--tw-scale-y: 1;--tw-pan-x: ;--tw-pan-y: ;--tw-pinch-zoom: ;--tw-scroll-snap-strictness: proximity;--tw-gradient-from-position: ;--tw-gradient-via-position: ;--tw-gradient-to-position: ;--tw-ordinal: ;--tw-slashed-zero: ;--tw-numeric-figure: ;--tw-numeric-spacing: ;--tw-numeric-fraction: ;--tw-ring-inset: ;--tw-ring-offset-width: 0px;--tw-ring-offset-color: #fff;--tw-ring-color: rgb(59 130 246 / .5);--tw-ring-offset-shadow: 0 0 #0000;--tw-ring-shadow: 0 0 #0000;--tw-shadow: 0 0 #0000;--tw-shadow-colored: 0 0 #0000;--tw-blur: ;--tw-brightness: ;--tw-contrast: ;--tw-grayscale: ;--tw-hue-rotate: ;--tw-invert: ;--tw-saturate: ;--tw-sepia: ;--tw-drop-shadow: ;--tw-backdrop-blur: ;--tw-backdrop-brightness: ;--tw-backdrop-contrast: ;--tw-backdrop-grayscale: ;--tw-backdrop-hue-rotate: ;--tw-backdrop-invert: ;--tw-backdrop-opacity: ;--tw-backdrop-saturate: ;--tw-backdrop-sepia: ;--tw-contain-size: ;--tw-contain-layout: ;--tw-contain-paint: ;--tw-contain-style: }*,:before,:after{box-sizing:border-box;border-width:0;border-style:solid;border-color:#e5e7eb}:before,:after{--tw-content: ""}html,:host{line-height:1.5;-webkit-text-size-adjust:100%;-moz-tab-size:4;-o-tab-size:4;tab-size:4;font-family:ui-sans-serif,system-ui,sans-serif,"Apple Color Emoji","Segoe UI Emoji",Segoe UI Symbol,"Noto Color Emoji";font-feature-settings:normal;font-variation-settings:normal;-webkit-tap-highlight-color:transparent}body{margin:0;line-height:inherit}hr{height:0;color:inherit;border-top-width:1px}abbr:where([title]){-webkit-text-decoration:underline dotted;text-decoration:underline dotted}h1,h2,h3,h4,h5,h6{font-size:inherit;font-weight:inherit}a{color:inherit;text-decoration:inherit}b,strong{font-weight:bolder}code,kbd,samp,pre{font-family:ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,monospace;font-feature-settings:normal;font-variation-settings:normal;font-size:1em}small{font-size:80%}sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline}sub{bottom:-.25em}sup{top:-.5em}table{text-indent:0;border-color:inherit;border-collapse:collapse}button,input,optgroup,select,textarea{font-family:inherit;font-feature-settings:inherit;font-variation-settings:inherit;font-size:100%;font-weight:inherit;line-height:inherit;letter-spacing:inherit;color:inherit;margin:0;padding:0}button,select{text-transform:none}button,input:where([type=button]),input:where([type=reset]),input:where([type=submit]){-webkit-appearance:button;background-color:transparent;background-image:none}:-moz-focusring{outline:auto}:-moz-ui-invalid{box-shadow:none}progress{vertical-align:baseline}::-webkit-inner-spin-button,::-webkit-outer-spin-button{height:auto}[type=search]{-webkit-appearance:textfield;outline-offset:-2px}::-webkit-search-decoration{-webkit-appearance:none}::-webkit-file-upload-button{-webkit-appearance:button;font:inherit}summary{display:list-item}blockquote,dl,dd,h1,h2,h3,h4,h5,h6,hr,figure,p,pre{margin:0}fieldset{margin:0;padding:0}legend{padding:0}ol,ul,menu{list-style:none;margin:0;padding:0}dialog{padding:0}textarea{resize:vertical}input::-moz-placeholder,textarea::-moz-placeholder{opacity:1;color:#9ca3af}input::placeholder,textarea::placeholder{opacity:1;color:#9ca3af}button,[role=button]{cursor:pointer}:disabled{cursor:default}img,svg,video,canvas,audio,iframe,embed,object{display:block;vertical-align:middle}img,video{max-width:100%;height:auto}[hidden]:where(:not([hidden=until-found])){display:none}.pointer-events-none{pointer-events:none}.pointer-events-auto{pointer-events:auto}.visible{visibility:visible}.fixed{position:fixed}.absolute{position:absolute}.relative{position:relative}.inset-0{top:0;right:0;bottom:0;left:0}.right-3{right:.75rem}.top-3{top:.75rem}.z-50{z-index:50}.z-\[100\]{z-index:100}.z-\[200\]{z-index:200}.z-\[300\]{z-index:300}.mx-1{margin-left:.25rem;margin-right:.25rem}.mb-0\.5{margin-bottom:.125rem}.ml-1{margin-left:.25rem}.ml-auto{margin-left:auto}.mr-0\.5{margin-right:.125rem}.mr-1{margin-right:.25rem}.mt-0\.5{margin-top:.125rem}.mt-1{margin-top:.25rem}.mt-2{margin-top:.5rem}.block{display:block}.flex{display:flex}.hidden{display:none}.h-1\.5{height:.375rem}.h-2{height:.5rem}.h-2\.5{height:.625rem}.h-7{height:1.75rem}.h-full{height:100%}.min-h-0{min-height:0px}.w-1\.5{width:.375rem}.w-2{width:.5rem}.w-2\.5{width:.625rem}.w-48{width:12rem}.w-52{width:13rem}.w-60{width:15rem}.w-7{width:1.75rem}.w-80{width:20rem}.w-96{width:24rem}.w-\[220px\]{width:220px}.w-full{width:100%}.min-w-0{min-width:0px}.max-w-\[200px\]{max-width:200px}.max-w-sm{max-width:24rem}.max-w-xs{max-width:20rem}.flex-1{flex:1 1 0%}.shrink-0{flex-shrink:0}.transform{transform:translate(var(--tw-translate-x),var(--tw-translate-y)) rotate(var(--tw-rotate)) skew(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y))}.cursor-grab{cursor:grab}.cursor-pointer{cursor:pointer}.select-none{-webkit-user-select:none;-moz-user-select:none;user-select:none}.flex-col{flex-direction:column}.items-start{align-items:flex-start}.items-center{align-items:center}.justify-end{justify-content:flex-end}.justify-center{justify-content:center}.justify-between{justify-content:space-between}.gap-1\.5{gap:.375rem}.gap-2{gap:.5rem}.gap-3{gap:.75rem}.space-y-1\.5>:not([hidden])~:not([hidden]){--tw-space-y-reverse: 0;margin-top:calc(.375rem * calc(1 - var(--tw-space-y-reverse)));margin-bottom:calc(.375rem * var(--tw-space-y-reverse))}.space-y-3>:not([hidden])~:not([hidden]){--tw-space-y-reverse: 0;margin-top:calc(.75rem * calc(1 - var(--tw-space-y-reverse)));margin-bottom:calc(.75rem * var(--tw-space-y-reverse))}.overflow-hidden{overflow:hidden}.overflow-y-auto{overflow-y:auto}.truncate{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.whitespace-nowrap{white-space:nowrap}.break-words{overflow-wrap:break-word}.rounded{border-radius:.25rem}.rounded-full{border-radius:9999px}.rounded-lg{border-radius:.5rem}.border{border-width:1px}.border-b{border-bottom-width:1px}.border-r{border-right-width:1px}.border-t{border-top-width:1px}.border-dashed{border-style:dashed}.\!border-gray-700{--tw-border-opacity: 1 !important;border-color:rgb(55 65 81 / var(--tw-border-opacity, 1))!important}.border-blue-800{--tw-border-opacity: 1;border-color:rgb(30 64 175 / var(--tw-border-opacity, 1))}.border-blue-900\/60{border-color:#1e3a8a99}.border-cyan-700{--tw-border-opacity: 1;border-color:rgb(14 116 144 / var(--tw-border-opacity, 1))}.border-cyan-900{--tw-border-opacity: 1;border-color:rgb(22 78 99 / var(--tw-border-opacity, 1))}.border-gray-600{--tw-border-opacity: 1;border-color:rgb(75 85 99 / var(--tw-border-opacity, 1))}.border-gray-700{--tw-border-opacity: 1;border-color:rgb(55 65 81 / var(--tw-border-opacity, 1))}.border-gray-800{--tw-border-opacity: 1;border-color:rgb(31 41 55 / var(--tw-border-opacity, 1))}.border-gray-800\/50{border-color:#1f293780}.border-green-800{--tw-border-opacity: 1;border-color:rgb(22 101 52 / var(--tw-border-opacity, 1))}.border-red-800{--tw-border-opacity: 1;border-color:rgb(153 27 27 / var(--tw-border-opacity, 1))}.border-transparent{border-color:transparent}.border-yellow-700{--tw-border-opacity: 1;border-color:rgb(161 98 7 / var(--tw-border-opacity, 1))}.\!bg-gray-800{--tw-bg-opacity: 1 !important;background-color:rgb(31 41 55 / var(--tw-bg-opacity, 1))!important}.bg-black\/60{background-color:#0009}.bg-blue-600{--tw-bg-opacity: 1;background-color:rgb(37 99 235 / var(--tw-bg-opacity, 1))}.bg-blue-900\/50{background-color:#1e3a8a80}.bg-cyan-950\/40{background-color:#08334466}.bg-gray-600{--tw-bg-opacity: 1;background-color:rgb(75 85 99 / var(--tw-bg-opacity, 1))}.bg-gray-800{--tw-bg-opacity: 1;background-color:rgb(31 41 55 / var(--tw-bg-opacity, 1))}.bg-gray-900{--tw-bg-opacity: 1;background-color:rgb(17 24 39 / var(--tw-bg-opacity, 1))}.bg-gray-900\/95{background-color:#111827f2}.bg-gray-950{--tw-bg-opacity: 1;background-color:rgb(3 7 18 / var(--tw-bg-opacity, 1))}.bg-gray-950\/50{background-color:#03071280}.bg-gray-950\/95{background-color:#030712f2}.bg-green-500{--tw-bg-opacity: 1;background-color:rgb(34 197 94 / var(--tw-bg-opacity, 1))}.bg-green-700{--tw-bg-opacity: 1;background-color:rgb(21 128 61 / var(--tw-bg-opacity, 1))}.bg-green-950\/40{background-color:#052e1666}.bg-red-700{--tw-bg-opacity: 1;background-color:rgb(185 28 28 / var(--tw-bg-opacity, 1))}.bg-red-900\/50{background-color:#7f1d1d80}.bg-red-950\/40{background-color:#450a0a66}.bg-red-950\/95{background-color:#450a0af2}.bg-transparent{background-color:transparent}.bg-yellow-500{--tw-bg-opacity: 1;background-color:rgb(234 179 8 / var(--tw-bg-opacity, 1))}.p-1\.5{padding:.375rem}.p-2{padding:.5rem}.p-4{padding:1rem}.px-1{padding-left:.25rem;padding-right:.25rem}.px-1\.5{padding-left:.375rem;padding-right:.375rem}.px-2{padding-left:.5rem;padding-right:.5rem}.px-2\.5{padding-left:.625rem;padding-right:.625rem}.px-3{padding-left:.75rem;padding-right:.75rem}.px-4{padding-left:1rem;padding-right:1rem}.py-0\.5{padding-top:.125rem;padding-bottom:.125rem}.py-1{padding-top:.25rem;padding-bottom:.25rem}.py-1\.5{padding-top:.375rem;padding-bottom:.375rem}.py-12{padding-top:3rem;padding-bottom:3rem}.py-2{padding-top:.5rem;padding-bottom:.5rem}.py-3{padding-top:.75rem;padding-bottom:.75rem}.py-8{padding-top:2rem;padding-bottom:2rem}.pb-2{padding-bottom:.5rem}.pt-1{padding-top:.25rem}.text-left{text-align:left}.text-center{text-align:center}.align-middle{vertical-align:middle}.align-\[-2px\]{vertical-align:-2px}.text-3xl{font-size:1.875rem;line-height:2.25rem}.text-\[10px\]{font-size:10px}.text-\[11px\]{font-size:11px}.text-\[12px\]{font-size:12px}.text-\[14px\]{font-size:14px}.text-\[18px\]{font-size:18px}.text-\[9px\]{font-size:9px}.text-base{font-size:1rem;line-height:1.5rem}.text-sm{font-size:.875rem;line-height:1.25rem}.text-xs{font-size:.75rem;line-height:1rem}.font-bold{font-weight:700}.font-semibold{font-weight:600}.uppercase{text-transform:uppercase}.leading-5{line-height:1.25rem}.leading-none{line-height:1}.leading-snug{line-height:1.375}.tracking-wider{letter-spacing:.05em}.text-blue-300{--tw-text-opacity: 1;color:rgb(147 197 253 / var(--tw-text-opacity, 1))}.text-blue-400{--tw-text-opacity: 1;color:rgb(96 165 250 / var(--tw-text-opacity, 1))}.text-cyan-300{--tw-text-opacity: 1;color:rgb(103 232 249 / var(--tw-text-opacity, 1))}.text-cyan-400{--tw-text-opacity: 1;color:rgb(34 211 238 / var(--tw-text-opacity, 1))}.text-gray-100{--tw-text-opacity: 1;color:rgb(243 244 246 / var(--tw-text-opacity, 1))}.text-gray-200{--tw-text-opacity: 1;color:rgb(229 231 235 / var(--tw-text-opacity, 1))}.text-gray-300{--tw-text-opacity: 1;color:rgb(209 213 219 / var(--tw-text-opacity, 1))}.text-gray-400{--tw-text-opacity: 1;color:rgb(156 163 175 / var(--tw-text-opacity, 1))}.text-gray-500{--tw-text-opacity: 1;color:rgb(107 114 128 / var(--tw-text-opacity, 1))}.text-gray-600{--tw-text-opacity: 1;color:rgb(75 85 99 / var(--tw-text-opacity, 1))}.text-green-300{--tw-text-opacity: 1;color:rgb(134 239 172 / var(--tw-text-opacity, 1))}.text-green-400{--tw-text-opacity: 1;color:rgb(74 222 128 / var(--tw-text-opacity, 1))}.text-red-200{--tw-text-opacity: 1;color:rgb(254 202 202 / var(--tw-text-opacity, 1))}.text-red-300{--tw-text-opacity: 1;color:rgb(252 165 165 / var(--tw-text-opacity, 1))}.text-red-400{--tw-text-opacity: 1;color:rgb(248 113 113 / var(--tw-text-opacity, 1))}.text-white{--tw-text-opacity: 1;color:rgb(255 255 255 / var(--tw-text-opacity, 1))}.text-yellow-400{--tw-text-opacity: 1;color:rgb(250 204 21 / var(--tw-text-opacity, 1))}.placeholder-gray-500::-moz-placeholder{--tw-placeholder-opacity: 1;color:rgb(107 114 128 / var(--tw-placeholder-opacity, 1))}.placeholder-gray-500::placeholder{--tw-placeholder-opacity: 1;color:rgb(107 114 128 / var(--tw-placeholder-opacity, 1))}.shadow-2xl{--tw-shadow: 0 25px 50px -12px rgb(0 0 0 / .25);--tw-shadow-colored: 0 25px 50px -12px var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow, 0 0 #0000),var(--tw-ring-shadow, 0 0 #0000),var(--tw-shadow)}.shadow-lg{--tw-shadow: 0 10px 15px -3px rgb(0 0 0 / .1), 0 4px 6px -4px rgb(0 0 0 / .1);--tw-shadow-colored: 0 10px 15px -3px var(--tw-shadow-color), 0 4px 6px -4px var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow, 0 0 #0000),var(--tw-ring-shadow, 0 0 #0000),var(--tw-shadow)}.shadow-xl{--tw-shadow: 0 20px 25px -5px rgb(0 0 0 / .1), 0 8px 10px -6px rgb(0 0 0 / .1);--tw-shadow-colored: 0 20px 25px -5px var(--tw-shadow-color), 0 8px 10px -6px var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow, 0 0 #0000),var(--tw-ring-shadow, 0 0 #0000),var(--tw-shadow)}.filter{filter:var(--tw-blur) var(--tw-brightness) var(--tw-contrast) var(--tw-grayscale) var(--tw-hue-rotate) var(--tw-invert) var(--tw-saturate) var(--tw-sepia) var(--tw-drop-shadow)}.transition{transition-property:color,background-color,border-color,text-decoration-color,fill,stroke,opacity,box-shadow,transform,filter,backdrop-filter;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.15s}.transition-colors{transition-property:color,background-color,border-color,text-decoration-color,fill,stroke;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.15s}.react-flow__background{background-color:#0f172a!important}.react-flow__minimap{background-color:#111827!important;border:1px solid #374151!important;border-radius:8px!important}.react-flow__controls button{background-color:#111827!important;border:1px solid #374151!important;color:#9ca3af!important;fill:#9ca3af!important}.react-flow__controls button:hover{background-color:#1f2937!important}.react-flow__attribution{display:none!important}.workflow-node{background:#111827;border:2px solid #374151;border-radius:8px;width:280px!important;height:var(--node-card-height, 90px);box-sizing:border-box;font-size:13px;color:#e5e7eb;box-shadow:0 4px 12px #0006;transition:border-color .15s,box-shadow .15s}.workflow-node:hover{border-color:#4b5563;box-shadow:0 6px 20px #0009}.workflow-node.selected{border-color:#3b82f6;box-shadow:0 0 0 2px #3b82f64d}.node-header{display:flex;align-items:center;gap:6px;padding:6px 10px;border-radius:8px 8px 0 0;font-weight:600;font-size:12px}.node-title-row{display:flex;align-items:center;gap:6px;min-width:0;flex:1}.node-header-control{flex:0 0 auto;display:flex;align-items:center}.node-header-input,.node-header-select{width:112px;min-width:0;height:22px;padding:2px 6px;background:#374151;border:1px solid #4b5563;border-radius:5px;color:#e5e7eb;font:10px ui-monospace,SFMono-Regular,Consolas,monospace;outline:none}.node-header-input:focus,.node-header-select:focus{border-color:#60a5fa}.node-header-select{width:82px;font-family:ui-sans-serif,system-ui,sans-serif;cursor:pointer}.node-body{padding:5px 10px 8px;display:flex;flex-direction:column;justify-content:center;flex:1}.node-port{display:flex;align-items:center;gap:6px;font-size:11px;color:#94a3b8}.node-port span{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.react-flow__handle{width:10px!important;height:10px!important;border:2px solid #475569!important;background:#1e293b!important}.react-flow__handle:hover{background:#3b82f6!important;border-color:#3b82f6!important}.react-flow__handle-connecting{background:#f59e0b!important;border-color:#f59e0b!important}.react-flow__handle-valid{background:#22c55e!important;border-color:#22c55e!important}.hover\:border-blue-600:hover{--tw-border-opacity: 1;border-color:rgb(37 99 235 / var(--tw-border-opacity, 1))}.hover\:border-gray-400:hover{--tw-border-opacity: 1;border-color:rgb(156 163 175 / var(--tw-border-opacity, 1))}.hover\:border-gray-700:hover{--tw-border-opacity: 1;border-color:rgb(55 65 81 / var(--tw-border-opacity, 1))}.hover\:border-red-800:hover{--tw-border-opacity: 1;border-color:rgb(153 27 27 / var(--tw-border-opacity, 1))}.hover\:bg-blue-500:hover{--tw-bg-opacity: 1;background-color:rgb(59 130 246 / var(--tw-bg-opacity, 1))}.hover\:bg-blue-900\/30:hover{background-color:#1e3a8a4d}.hover\:bg-blue-900\/40:hover{background-color:#1e3a8a66}.hover\:bg-cyan-900\/40:hover{background-color:#164e6366}.hover\:bg-cyan-900\/60:hover{background-color:#164e6399}.hover\:bg-gray-700:hover{--tw-bg-opacity: 1;background-color:rgb(55 65 81 / var(--tw-bg-opacity, 1))}.hover\:bg-gray-800:hover{--tw-bg-opacity: 1;background-color:rgb(31 41 55 / var(--tw-bg-opacity, 1))}.hover\:bg-gray-800\/50:hover{background-color:#1f293780}.hover\:bg-green-600:hover{--tw-bg-opacity: 1;background-color:rgb(22 163 74 / var(--tw-bg-opacity, 1))}.hover\:bg-red-600:hover{--tw-bg-opacity: 1;background-color:rgb(220 38 38 / var(--tw-bg-opacity, 1))}.hover\:bg-red-900\/30:hover{background-color:#7f1d1d4d}.hover\:bg-yellow-900\/30:hover{background-color:#713f124d}.hover\:text-blue-300:hover{--tw-text-opacity: 1;color:rgb(147 197 253 / var(--tw-text-opacity, 1))}.hover\:text-blue-400:hover{--tw-text-opacity: 1;color:rgb(96 165 250 / var(--tw-text-opacity, 1))}.hover\:text-gray-200:hover{--tw-text-opacity: 1;color:rgb(229 231 235 / var(--tw-text-opacity, 1))}.hover\:text-gray-300:hover{--tw-text-opacity: 1;color:rgb(209 213 219 / var(--tw-text-opacity, 1))}.hover\:text-red-300:hover{--tw-text-opacity: 1;color:rgb(252 165 165 / var(--tw-text-opacity, 1))}.hover\:text-red-400:hover{--tw-text-opacity: 1;color:rgb(248 113 113 / var(--tw-text-opacity, 1))}.hover\:text-white:hover{--tw-text-opacity: 1;color:rgb(255 255 255 / var(--tw-text-opacity, 1))}.hover\:text-yellow-300:hover{--tw-text-opacity: 1;color:rgb(253 224 71 / var(--tw-text-opacity, 1))}.hover\:underline:hover{text-decoration-line:underline}.focus\:border-blue-500:focus{--tw-border-opacity: 1;border-color:rgb(59 130 246 / var(--tw-border-opacity, 1))}.focus\:outline-none:focus{outline:2px solid transparent;outline-offset:2px}.active\:cursor-grabbing:active{cursor:grabbing}.disabled\:opacity-30:disabled{opacity:.3}.disabled\:opacity-50:disabled{opacity:.5}
+.react-flow{direction:ltr;--xy-edge-stroke-default: #b1b1b7;--xy-edge-stroke-width-default: 1;--xy-edge-stroke-selected-default: #555;--xy-connectionline-stroke-default: #b1b1b7;--xy-connectionline-stroke-width-default: 1;--xy-attribution-background-color-default: rgba(255, 255, 255, .5);--xy-minimap-background-color-default: #fff;--xy-minimap-mask-background-color-default: rgba(240, 240, 240, .6);--xy-minimap-mask-stroke-color-default: transparent;--xy-minimap-mask-stroke-width-default: 1;--xy-minimap-node-background-color-default: #e2e2e2;--xy-minimap-node-stroke-color-default: transparent;--xy-minimap-node-stroke-width-default: 2;--xy-background-color-default: transparent;--xy-background-pattern-dots-color-default: #91919a;--xy-background-pattern-lines-color-default: #eee;--xy-background-pattern-cross-color-default: #e2e2e2;background-color:var(--xy-background-color, var(--xy-background-color-default));--xy-node-color-default: inherit;--xy-node-border-default: 1px solid #1a192b;--xy-node-background-color-default: #fff;--xy-node-group-background-color-default: rgba(240, 240, 240, .25);--xy-node-boxshadow-hover-default: 0 1px 4px 1px rgba(0, 0, 0, .08);--xy-node-boxshadow-selected-default: 0 0 0 .5px #1a192b;--xy-node-border-radius-default: 3px;--xy-handle-background-color-default: #1a192b;--xy-handle-border-color-default: #fff;--xy-selection-background-color-default: rgba(0, 89, 220, .08);--xy-selection-border-default: 1px dotted rgba(0, 89, 220, .8);--xy-controls-button-background-color-default: #fefefe;--xy-controls-button-background-color-hover-default: #f4f4f4;--xy-controls-button-color-default: inherit;--xy-controls-button-color-hover-default: inherit;--xy-controls-button-border-color-default: #eee;--xy-controls-box-shadow-default: 0 0 2px 1px rgba(0, 0, 0, .08);--xy-edge-label-background-color-default: #ffffff;--xy-edge-label-color-default: inherit;--xy-resize-background-color-default: #3367d9}.react-flow.dark{--xy-edge-stroke-default: #3e3e3e;--xy-edge-stroke-width-default: 1;--xy-edge-stroke-selected-default: #727272;--xy-connectionline-stroke-default: #b1b1b7;--xy-connectionline-stroke-width-default: 1;--xy-attribution-background-color-default: rgba(150, 150, 150, .25);--xy-minimap-background-color-default: #141414;--xy-minimap-mask-background-color-default: rgba(60, 60, 60, .6);--xy-minimap-mask-stroke-color-default: transparent;--xy-minimap-mask-stroke-width-default: 1;--xy-minimap-node-background-color-default: #2b2b2b;--xy-minimap-node-stroke-color-default: transparent;--xy-minimap-node-stroke-width-default: 2;--xy-background-color-default: #141414;--xy-background-pattern-dots-color-default: #555;--xy-background-pattern-lines-color-default: #333;--xy-background-pattern-cross-color-default: #333;--xy-node-color-default: #f8f8f8;--xy-node-border-default: 1px solid #3c3c3c;--xy-node-background-color-default: #1e1e1e;--xy-node-group-background-color-default: rgba(240, 240, 240, .25);--xy-node-boxshadow-hover-default: 0 1px 4px 1px rgba(255, 255, 255, .08);--xy-node-boxshadow-selected-default: 0 0 0 .5px #999;--xy-handle-background-color-default: #bebebe;--xy-handle-border-color-default: #1e1e1e;--xy-selection-background-color-default: rgba(200, 200, 220, .08);--xy-selection-border-default: 1px dotted rgba(200, 200, 220, .8);--xy-controls-button-background-color-default: #2b2b2b;--xy-controls-button-background-color-hover-default: #3e3e3e;--xy-controls-button-color-default: #f8f8f8;--xy-controls-button-color-hover-default: #fff;--xy-controls-button-border-color-default: #5b5b5b;--xy-controls-box-shadow-default: 0 0 2px 1px rgba(0, 0, 0, .08);--xy-edge-label-background-color-default: #141414;--xy-edge-label-color-default: #f8f8f8}.react-flow__background{background-color:var(--xy-background-color-props, var(--xy-background-color, var(--xy-background-color-default)));pointer-events:none;z-index:-1}.react-flow__container{position:absolute;width:100%;height:100%;top:0;left:0}.react-flow__pane{z-index:1;touch-action:none}.react-flow__pane.draggable{cursor:grab}.react-flow__pane.dragging{cursor:grabbing}.react-flow__pane.selection{cursor:pointer}.react-flow__viewport{transform-origin:0 0;z-index:2;pointer-events:none}.react-flow__renderer{z-index:4}.react-flow__selection{z-index:6}.react-flow__nodesselection-rect:focus,.react-flow__nodesselection-rect:focus-visible{outline:none}.react-flow__edge-path{stroke:var(--xy-edge-stroke, var(--xy-edge-stroke-default));stroke-width:var(--xy-edge-stroke-width, var(--xy-edge-stroke-width-default));fill:none}.react-flow__connection-path{stroke:var(--xy-connectionline-stroke, var(--xy-connectionline-stroke-default));stroke-width:var(--xy-connectionline-stroke-width, var(--xy-connectionline-stroke-width-default));fill:none}.react-flow .react-flow__edges{position:absolute}.react-flow .react-flow__edges svg{overflow:visible;position:absolute;pointer-events:none}.react-flow__edge{pointer-events:visibleStroke}.react-flow__edge.selectable{cursor:pointer}.react-flow__edge.animated path{stroke-dasharray:5;animation:dashdraw .5s linear infinite}.react-flow__edge.animated path.react-flow__edge-interaction{stroke-dasharray:none;animation:none}.react-flow__edge.inactive{pointer-events:none}.react-flow__edge.selected,.react-flow__edge:focus,.react-flow__edge:focus-visible{outline:none}.react-flow__edge.selected .react-flow__edge-path,.react-flow__edge.selectable:focus .react-flow__edge-path,.react-flow__edge.selectable:focus-visible .react-flow__edge-path{stroke:var(--xy-edge-stroke-selected, var(--xy-edge-stroke-selected-default))}.react-flow__edge-textwrapper{pointer-events:all}.react-flow__edge .react-flow__edge-text{pointer-events:none;-webkit-user-select:none;-moz-user-select:none;user-select:none}.react-flow__arrowhead polyline{stroke:var(--xy-edge-stroke, var(--xy-edge-stroke-default))}.react-flow__arrowhead polyline.arrowclosed{fill:var(--xy-edge-stroke, var(--xy-edge-stroke-default))}.react-flow__connection{pointer-events:none}.react-flow__connection .animated{stroke-dasharray:5;animation:dashdraw .5s linear infinite}svg.react-flow__connectionline{z-index:1001;overflow:visible;position:absolute}.react-flow__nodes{pointer-events:none;transform-origin:0 0}.react-flow__node{position:absolute;-webkit-user-select:none;-moz-user-select:none;user-select:none;pointer-events:all;transform-origin:0 0;box-sizing:border-box;cursor:default}.react-flow__node.selectable{cursor:pointer}.react-flow__node.draggable{cursor:grab;pointer-events:all}.react-flow__node.draggable.dragging{cursor:grabbing}.react-flow__nodesselection{z-index:3;transform-origin:left top;pointer-events:none}.react-flow__nodesselection-rect{position:absolute;pointer-events:all;cursor:grab}.react-flow__handle{position:absolute;pointer-events:none;min-width:5px;min-height:5px;width:6px;height:6px;background-color:var(--xy-handle-background-color, var(--xy-handle-background-color-default));border:1px solid var(--xy-handle-border-color, var(--xy-handle-border-color-default));border-radius:100%}.react-flow__handle.connectingfrom{pointer-events:all}.react-flow__handle.connectionindicator{pointer-events:all;cursor:crosshair}.react-flow__handle-bottom{top:auto;left:50%;bottom:0;transform:translate(-50%,50%)}.react-flow__handle-top{top:0;left:50%;transform:translate(-50%,-50%)}.react-flow__handle-left{top:50%;left:0;transform:translate(-50%,-50%)}.react-flow__handle-right{top:50%;right:0;transform:translate(50%,-50%)}.react-flow__edgeupdater{cursor:move;pointer-events:all}.react-flow__pane.selection .react-flow__panel{pointer-events:none}.react-flow__panel{position:absolute;z-index:5;margin:15px}.react-flow__panel.top{top:0}.react-flow__panel.bottom{bottom:0}.react-flow__panel.top.center,.react-flow__panel.bottom.center{left:50%;transform:translate(-15px) translate(-50%)}.react-flow__panel.left{left:0}.react-flow__panel.right{right:0}.react-flow__panel.left.center,.react-flow__panel.right.center{top:50%;transform:translateY(-15px) translateY(-50%)}.react-flow__attribution{font-size:10px;background:var(--xy-attribution-background-color, var(--xy-attribution-background-color-default));padding:2px 3px;margin:0}.react-flow__attribution a{text-decoration:none;color:#999}@keyframes dashdraw{0%{stroke-dashoffset:10}}.react-flow__edgelabel-renderer{position:absolute;width:100%;height:100%;pointer-events:none;-webkit-user-select:none;-moz-user-select:none;user-select:none;left:0;top:0}.react-flow__viewport-portal{position:absolute;width:100%;height:100%;left:0;top:0;-webkit-user-select:none;-moz-user-select:none;user-select:none}.react-flow__minimap{background:var( --xy-minimap-background-color-props, var(--xy-minimap-background-color, var(--xy-minimap-background-color-default)) )}.react-flow__minimap-svg{display:block}.react-flow__minimap-mask{fill:var( --xy-minimap-mask-background-color-props, var(--xy-minimap-mask-background-color, var(--xy-minimap-mask-background-color-default)) );stroke:var( --xy-minimap-mask-stroke-color-props, var(--xy-minimap-mask-stroke-color, var(--xy-minimap-mask-stroke-color-default)) );stroke-width:var( --xy-minimap-mask-stroke-width-props, var(--xy-minimap-mask-stroke-width, var(--xy-minimap-mask-stroke-width-default)) )}.react-flow__minimap-node{fill:var( --xy-minimap-node-background-color-props, var(--xy-minimap-node-background-color, var(--xy-minimap-node-background-color-default)) );stroke:var( --xy-minimap-node-stroke-color-props, var(--xy-minimap-node-stroke-color, var(--xy-minimap-node-stroke-color-default)) );stroke-width:var( --xy-minimap-node-stroke-width-props, var(--xy-minimap-node-stroke-width, var(--xy-minimap-node-stroke-width-default)) )}.react-flow__background-pattern.dots{fill:var( --xy-background-pattern-color-props, var(--xy-background-pattern-color, var(--xy-background-pattern-dots-color-default)) )}.react-flow__background-pattern.lines{stroke:var( --xy-background-pattern-color-props, var(--xy-background-pattern-color, var(--xy-background-pattern-lines-color-default)) )}.react-flow__background-pattern.cross{stroke:var( --xy-background-pattern-color-props, var(--xy-background-pattern-color, var(--xy-background-pattern-cross-color-default)) )}.react-flow__controls{display:flex;flex-direction:column;box-shadow:var(--xy-controls-box-shadow, var(--xy-controls-box-shadow-default))}.react-flow__controls.horizontal{flex-direction:row}.react-flow__controls-button{display:flex;justify-content:center;align-items:center;height:26px;width:26px;padding:4px;border:none;background:var(--xy-controls-button-background-color, var(--xy-controls-button-background-color-default));border-bottom:1px solid var( --xy-controls-button-border-color-props, var(--xy-controls-button-border-color, var(--xy-controls-button-border-color-default)) );color:var( --xy-controls-button-color-props, var(--xy-controls-button-color, var(--xy-controls-button-color-default)) );cursor:pointer;-webkit-user-select:none;-moz-user-select:none;user-select:none}.react-flow__controls-button svg{width:100%;max-width:12px;max-height:12px;fill:currentColor}.react-flow__edge.updating .react-flow__edge-path{stroke:#777}.react-flow__edge-text{font-size:10px}.react-flow__node.selectable:focus,.react-flow__node.selectable:focus-visible{outline:none}.react-flow__node-input,.react-flow__node-default,.react-flow__node-output,.react-flow__node-group{padding:10px;border-radius:var(--xy-node-border-radius, var(--xy-node-border-radius-default));width:150px;font-size:12px;color:var(--xy-node-color, var(--xy-node-color-default));text-align:center;border:var(--xy-node-border, var(--xy-node-border-default));background-color:var(--xy-node-background-color, var(--xy-node-background-color-default))}.react-flow__node-input.selectable:hover,.react-flow__node-default.selectable:hover,.react-flow__node-output.selectable:hover,.react-flow__node-group.selectable:hover{box-shadow:var(--xy-node-boxshadow-hover, var(--xy-node-boxshadow-hover-default))}.react-flow__node-input.selectable.selected,.react-flow__node-input.selectable:focus,.react-flow__node-input.selectable:focus-visible,.react-flow__node-default.selectable.selected,.react-flow__node-default.selectable:focus,.react-flow__node-default.selectable:focus-visible,.react-flow__node-output.selectable.selected,.react-flow__node-output.selectable:focus,.react-flow__node-output.selectable:focus-visible,.react-flow__node-group.selectable.selected,.react-flow__node-group.selectable:focus,.react-flow__node-group.selectable:focus-visible{box-shadow:var(--xy-node-boxshadow-selected, var(--xy-node-boxshadow-selected-default))}.react-flow__node-group{background-color:var(--xy-node-group-background-color, var(--xy-node-group-background-color-default))}.react-flow__nodesselection-rect,.react-flow__selection{background:var(--xy-selection-background-color, var(--xy-selection-background-color-default));border:var(--xy-selection-border, var(--xy-selection-border-default))}.react-flow__nodesselection-rect:focus,.react-flow__nodesselection-rect:focus-visible,.react-flow__selection:focus,.react-flow__selection:focus-visible{outline:none}.react-flow__controls-button:hover{background:var( --xy-controls-button-background-color-hover-props, var(--xy-controls-button-background-color-hover, var(--xy-controls-button-background-color-hover-default)) );color:var( --xy-controls-button-color-hover-props, var(--xy-controls-button-color-hover, var(--xy-controls-button-color-hover-default)) )}.react-flow__controls-button:disabled{pointer-events:none}.react-flow__controls-button:disabled svg{fill-opacity:.4}.react-flow__controls-button:last-child{border-bottom:none}.react-flow__controls.horizontal .react-flow__controls-button{border-bottom:none;border-right:1px solid var( --xy-controls-button-border-color-props, var(--xy-controls-button-border-color, var(--xy-controls-button-border-color-default)) )}.react-flow__controls.horizontal .react-flow__controls-button:last-child{border-right:none}.react-flow__resize-control{position:absolute}.react-flow__resize-control.left,.react-flow__resize-control.right{cursor:ew-resize}.react-flow__resize-control.top,.react-flow__resize-control.bottom{cursor:ns-resize}.react-flow__resize-control.top.left,.react-flow__resize-control.bottom.right{cursor:nwse-resize}.react-flow__resize-control.bottom.left,.react-flow__resize-control.top.right{cursor:nesw-resize}.react-flow__resize-control.handle{width:5px;height:5px;border:1px solid #fff;border-radius:1px;background-color:var(--xy-resize-background-color, var(--xy-resize-background-color-default));translate:-50% -50%}.react-flow__resize-control.handle.left{left:0;top:50%}.react-flow__resize-control.handle.right{left:100%;top:50%}.react-flow__resize-control.handle.top{left:50%;top:0}.react-flow__resize-control.handle.bottom{left:50%;top:100%}.react-flow__resize-control.handle.top.left,.react-flow__resize-control.handle.bottom.left{left:0}.react-flow__resize-control.handle.top.right,.react-flow__resize-control.handle.bottom.right{left:100%}.react-flow__resize-control.line{border-color:var(--xy-resize-background-color, var(--xy-resize-background-color-default));border-width:0;border-style:solid}.react-flow__resize-control.line.left,.react-flow__resize-control.line.right{width:1px;transform:translate(-50%);top:0;height:100%}.react-flow__resize-control.line.left{left:0;border-left-width:1px}.react-flow__resize-control.line.right{left:100%;border-right-width:1px}.react-flow__resize-control.line.top,.react-flow__resize-control.line.bottom{height:1px;transform:translateY(-50%);left:0;width:100%}.react-flow__resize-control.line.top{top:0;border-top-width:1px}.react-flow__resize-control.line.bottom{border-bottom-width:1px;top:100%}.react-flow__edge-textbg{fill:var(--xy-edge-label-background-color, var(--xy-edge-label-background-color-default))}.react-flow__edge-text{fill:var(--xy-edge-label-color, var(--xy-edge-label-color-default))}*,:before,:after{--tw-border-spacing-x: 0;--tw-border-spacing-y: 0;--tw-translate-x: 0;--tw-translate-y: 0;--tw-rotate: 0;--tw-skew-x: 0;--tw-skew-y: 0;--tw-scale-x: 1;--tw-scale-y: 1;--tw-pan-x: ;--tw-pan-y: ;--tw-pinch-zoom: ;--tw-scroll-snap-strictness: proximity;--tw-gradient-from-position: ;--tw-gradient-via-position: ;--tw-gradient-to-position: ;--tw-ordinal: ;--tw-slashed-zero: ;--tw-numeric-figure: ;--tw-numeric-spacing: ;--tw-numeric-fraction: ;--tw-ring-inset: ;--tw-ring-offset-width: 0px;--tw-ring-offset-color: #fff;--tw-ring-color: rgb(59 130 246 / .5);--tw-ring-offset-shadow: 0 0 #0000;--tw-ring-shadow: 0 0 #0000;--tw-shadow: 0 0 #0000;--tw-shadow-colored: 0 0 #0000;--tw-blur: ;--tw-brightness: ;--tw-contrast: ;--tw-grayscale: ;--tw-hue-rotate: ;--tw-invert: ;--tw-saturate: ;--tw-sepia: ;--tw-drop-shadow: ;--tw-backdrop-blur: ;--tw-backdrop-brightness: ;--tw-backdrop-contrast: ;--tw-backdrop-grayscale: ;--tw-backdrop-hue-rotate: ;--tw-backdrop-invert: ;--tw-backdrop-opacity: ;--tw-backdrop-saturate: ;--tw-backdrop-sepia: ;--tw-contain-size: ;--tw-contain-layout: ;--tw-contain-paint: ;--tw-contain-style: }::backdrop{--tw-border-spacing-x: 0;--tw-border-spacing-y: 0;--tw-translate-x: 0;--tw-translate-y: 0;--tw-rotate: 0;--tw-skew-x: 0;--tw-skew-y: 0;--tw-scale-x: 1;--tw-scale-y: 1;--tw-pan-x: ;--tw-pan-y: ;--tw-pinch-zoom: ;--tw-scroll-snap-strictness: proximity;--tw-gradient-from-position: ;--tw-gradient-via-position: ;--tw-gradient-to-position: ;--tw-ordinal: ;--tw-slashed-zero: ;--tw-numeric-figure: ;--tw-numeric-spacing: ;--tw-numeric-fraction: ;--tw-ring-inset: ;--tw-ring-offset-width: 0px;--tw-ring-offset-color: #fff;--tw-ring-color: rgb(59 130 246 / .5);--tw-ring-offset-shadow: 0 0 #0000;--tw-ring-shadow: 0 0 #0000;--tw-shadow: 0 0 #0000;--tw-shadow-colored: 0 0 #0000;--tw-blur: ;--tw-brightness: ;--tw-contrast: ;--tw-grayscale: ;--tw-hue-rotate: ;--tw-invert: ;--tw-saturate: ;--tw-sepia: ;--tw-drop-shadow: ;--tw-backdrop-blur: ;--tw-backdrop-brightness: ;--tw-backdrop-contrast: ;--tw-backdrop-grayscale: ;--tw-backdrop-hue-rotate: ;--tw-backdrop-invert: ;--tw-backdrop-opacity: ;--tw-backdrop-saturate: ;--tw-backdrop-sepia: ;--tw-contain-size: ;--tw-contain-layout: ;--tw-contain-paint: ;--tw-contain-style: }*,:before,:after{box-sizing:border-box;border-width:0;border-style:solid;border-color:#e5e7eb}:before,:after{--tw-content: ""}html,:host{line-height:1.5;-webkit-text-size-adjust:100%;-moz-tab-size:4;-o-tab-size:4;tab-size:4;font-family:ui-sans-serif,system-ui,sans-serif,"Apple Color Emoji","Segoe UI Emoji",Segoe UI Symbol,"Noto Color Emoji";font-feature-settings:normal;font-variation-settings:normal;-webkit-tap-highlight-color:transparent}body{margin:0;line-height:inherit}hr{height:0;color:inherit;border-top-width:1px}abbr:where([title]){-webkit-text-decoration:underline dotted;text-decoration:underline dotted}h1,h2,h3,h4,h5,h6{font-size:inherit;font-weight:inherit}a{color:inherit;text-decoration:inherit}b,strong{font-weight:bolder}code,kbd,samp,pre{font-family:ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,monospace;font-feature-settings:normal;font-variation-settings:normal;font-size:1em}small{font-size:80%}sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline}sub{bottom:-.25em}sup{top:-.5em}table{text-indent:0;border-color:inherit;border-collapse:collapse}button,input,optgroup,select,textarea{font-family:inherit;font-feature-settings:inherit;font-variation-settings:inherit;font-size:100%;font-weight:inherit;line-height:inherit;letter-spacing:inherit;color:inherit;margin:0;padding:0}button,select{text-transform:none}button,input:where([type=button]),input:where([type=reset]),input:where([type=submit]){-webkit-appearance:button;background-color:transparent;background-image:none}:-moz-focusring{outline:auto}:-moz-ui-invalid{box-shadow:none}progress{vertical-align:baseline}::-webkit-inner-spin-button,::-webkit-outer-spin-button{height:auto}[type=search]{-webkit-appearance:textfield;outline-offset:-2px}::-webkit-search-decoration{-webkit-appearance:none}::-webkit-file-upload-button{-webkit-appearance:button;font:inherit}summary{display:list-item}blockquote,dl,dd,h1,h2,h3,h4,h5,h6,hr,figure,p,pre{margin:0}fieldset{margin:0;padding:0}legend{padding:0}ol,ul,menu{list-style:none;margin:0;padding:0}dialog{padding:0}textarea{resize:vertical}input::-moz-placeholder,textarea::-moz-placeholder{opacity:1;color:#9ca3af}input::placeholder,textarea::placeholder{opacity:1;color:#9ca3af}button,[role=button]{cursor:pointer}:disabled{cursor:default}img,svg,video,canvas,audio,iframe,embed,object{display:block;vertical-align:middle}img,video{max-width:100%;height:auto}[hidden]:where(:not([hidden=until-found])){display:none}.pointer-events-none{pointer-events:none}.pointer-events-auto{pointer-events:auto}.visible{visibility:visible}.fixed{position:fixed}.absolute{position:absolute}.relative{position:relative}.inset-0{top:0;right:0;bottom:0;left:0}.right-3{right:.75rem}.top-3{top:.75rem}.z-50{z-index:50}.z-\[100\]{z-index:100}.z-\[200\]{z-index:200}.z-\[300\]{z-index:300}.mx-1{margin-left:.25rem;margin-right:.25rem}.mb-0\.5{margin-bottom:.125rem}.mb-1\.5{margin-bottom:.375rem}.ml-1{margin-left:.25rem}.ml-auto{margin-left:auto}.mr-0\.5{margin-right:.125rem}.mr-1{margin-right:.25rem}.mt-0\.5{margin-top:.125rem}.mt-1{margin-top:.25rem}.mt-2{margin-top:.5rem}.block{display:block}.flex{display:flex}.hidden{display:none}.h-1\.5{height:.375rem}.h-2{height:.5rem}.h-2\.5{height:.625rem}.h-7{height:1.75rem}.h-full{height:100%}.max-h-\[85vh\]{max-height:85vh}.min-h-0{min-height:0px}.w-1\.5{width:.375rem}.w-2{width:.5rem}.w-2\.5{width:.625rem}.w-48{width:12rem}.w-52{width:13rem}.w-60{width:15rem}.w-7{width:1.75rem}.w-80{width:20rem}.w-96{width:24rem}.w-\[104px\]{width:104px}.w-\[220px\]{width:220px}.w-\[68px\]{width:68px}.w-\[min\(880px\,92vw\)\]{width:min(880px,92vw)}.w-full{width:100%}.min-w-0{min-width:0px}.max-w-\[200px\]{max-width:200px}.max-w-sm{max-width:24rem}.max-w-xs{max-width:20rem}.flex-1{flex:1 1 0%}.shrink-0{flex-shrink:0}.transform{transform:translate(var(--tw-translate-x),var(--tw-translate-y)) rotate(var(--tw-rotate)) skew(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y))}.cursor-grab{cursor:grab}.cursor-pointer{cursor:pointer}.select-none{-webkit-user-select:none;-moz-user-select:none;user-select:none}.flex-col{flex-direction:column}.flex-wrap{flex-wrap:wrap}.items-start{align-items:flex-start}.items-center{align-items:center}.justify-end{justify-content:flex-end}.justify-center{justify-content:center}.justify-between{justify-content:space-between}.gap-1{gap:.25rem}.gap-1\.5{gap:.375rem}.gap-2{gap:.5rem}.gap-3{gap:.75rem}.gap-x-2\.5{-moz-column-gap:.625rem;column-gap:.625rem}.gap-y-1{row-gap:.25rem}.space-y-1\.5>:not([hidden])~:not([hidden]){--tw-space-y-reverse: 0;margin-top:calc(.375rem * calc(1 - var(--tw-space-y-reverse)));margin-bottom:calc(.375rem * var(--tw-space-y-reverse))}.space-y-3>:not([hidden])~:not([hidden]){--tw-space-y-reverse: 0;margin-top:calc(.75rem * calc(1 - var(--tw-space-y-reverse)));margin-bottom:calc(.75rem * var(--tw-space-y-reverse))}.overflow-hidden{overflow:hidden}.overflow-y-auto{overflow-y:auto}.truncate{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.whitespace-nowrap{white-space:nowrap}.break-words{overflow-wrap:break-word}.rounded{border-radius:.25rem}.rounded-full{border-radius:9999px}.rounded-lg{border-radius:.5rem}.rounded-t{border-top-left-radius:.25rem;border-top-right-radius:.25rem}.border{border-width:1px}.border-b{border-bottom-width:1px}.border-b-2{border-bottom-width:2px}.border-r{border-right-width:1px}.border-t{border-top-width:1px}.border-dashed{border-style:dashed}.\!border-gray-700{--tw-border-opacity: 1 !important;border-color:rgb(55 65 81 / var(--tw-border-opacity, 1))!important}.border-blue-800{--tw-border-opacity: 1;border-color:rgb(30 64 175 / var(--tw-border-opacity, 1))}.border-blue-900\/60{border-color:#1e3a8a99}.border-cyan-400{--tw-border-opacity: 1;border-color:rgb(34 211 238 / var(--tw-border-opacity, 1))}.border-cyan-700{--tw-border-opacity: 1;border-color:rgb(14 116 144 / var(--tw-border-opacity, 1))}.border-cyan-900{--tw-border-opacity: 1;border-color:rgb(22 78 99 / var(--tw-border-opacity, 1))}.border-gray-600{--tw-border-opacity: 1;border-color:rgb(75 85 99 / var(--tw-border-opacity, 1))}.border-gray-700{--tw-border-opacity: 1;border-color:rgb(55 65 81 / var(--tw-border-opacity, 1))}.border-gray-800{--tw-border-opacity: 1;border-color:rgb(31 41 55 / var(--tw-border-opacity, 1))}.border-gray-800\/50{border-color:#1f293780}.border-green-800{--tw-border-opacity: 1;border-color:rgb(22 101 52 / var(--tw-border-opacity, 1))}.border-red-800{--tw-border-opacity: 1;border-color:rgb(153 27 27 / var(--tw-border-opacity, 1))}.border-transparent{border-color:transparent}.border-yellow-700{--tw-border-opacity: 1;border-color:rgb(161 98 7 / var(--tw-border-opacity, 1))}.\!bg-gray-800{--tw-bg-opacity: 1 !important;background-color:rgb(31 41 55 / var(--tw-bg-opacity, 1))!important}.bg-\[\#0f172a\]{--tw-bg-opacity: 1;background-color:rgb(15 23 42 / var(--tw-bg-opacity, 1))}.bg-black\/60{background-color:#0009}.bg-blue-600{--tw-bg-opacity: 1;background-color:rgb(37 99 235 / var(--tw-bg-opacity, 1))}.bg-blue-900\/50{background-color:#1e3a8a80}.bg-cyan-900\/20{background-color:#164e6333}.bg-cyan-900\/40{background-color:#164e6366}.bg-cyan-950\/40{background-color:#08334466}.bg-gray-600{--tw-bg-opacity: 1;background-color:rgb(75 85 99 / var(--tw-bg-opacity, 1))}.bg-gray-800{--tw-bg-opacity: 1;background-color:rgb(31 41 55 / var(--tw-bg-opacity, 1))}.bg-gray-900{--tw-bg-opacity: 1;background-color:rgb(17 24 39 / var(--tw-bg-opacity, 1))}.bg-gray-900\/95{background-color:#111827f2}.bg-gray-950{--tw-bg-opacity: 1;background-color:rgb(3 7 18 / var(--tw-bg-opacity, 1))}.bg-gray-950\/50{background-color:#03071280}.bg-gray-950\/95{background-color:#030712f2}.bg-green-500{--tw-bg-opacity: 1;background-color:rgb(34 197 94 / var(--tw-bg-opacity, 1))}.bg-green-700{--tw-bg-opacity: 1;background-color:rgb(21 128 61 / var(--tw-bg-opacity, 1))}.bg-green-950\/40{background-color:#052e1666}.bg-red-700{--tw-bg-opacity: 1;background-color:rgb(185 28 28 / var(--tw-bg-opacity, 1))}.bg-red-900\/50{background-color:#7f1d1d80}.bg-red-950\/40{background-color:#450a0a66}.bg-red-950\/95{background-color:#450a0af2}.bg-transparent{background-color:transparent}.bg-yellow-500{--tw-bg-opacity: 1;background-color:rgb(234 179 8 / var(--tw-bg-opacity, 1))}.p-1\.5{padding:.375rem}.p-2{padding:.5rem}.p-4{padding:1rem}.px-1{padding-left:.25rem;padding-right:.25rem}.px-1\.5{padding-left:.375rem;padding-right:.375rem}.px-2{padding-left:.5rem;padding-right:.5rem}.px-2\.5{padding-left:.625rem;padding-right:.625rem}.px-3{padding-left:.75rem;padding-right:.75rem}.px-4{padding-left:1rem;padding-right:1rem}.py-0\.5{padding-top:.125rem;padding-bottom:.125rem}.py-1{padding-top:.25rem;padding-bottom:.25rem}.py-1\.5{padding-top:.375rem;padding-bottom:.375rem}.py-12{padding-top:3rem;padding-bottom:3rem}.py-2{padding-top:.5rem;padding-bottom:.5rem}.py-3{padding-top:.75rem;padding-bottom:.75rem}.py-8{padding-top:2rem;padding-bottom:2rem}.py-\[3px\]{padding-top:3px;padding-bottom:3px}.pb-0\.5{padding-bottom:.125rem}.pb-2{padding-bottom:.5rem}.pt-1{padding-top:.25rem}.pt-1\.5{padding-top:.375rem}.pt-2{padding-top:.5rem}.text-left{text-align:left}.text-center{text-align:center}.text-right{text-align:right}.align-middle{vertical-align:middle}.align-\[-2px\]{vertical-align:-2px}.text-3xl{font-size:1.875rem;line-height:2.25rem}.text-\[10px\]{font-size:10px}.text-\[11px\]{font-size:11px}.text-\[12px\]{font-size:12px}.text-\[14px\]{font-size:14px}.text-\[18px\]{font-size:18px}.text-\[9px\]{font-size:9px}.text-base{font-size:1rem;line-height:1.5rem}.text-sm{font-size:.875rem;line-height:1.25rem}.text-xs{font-size:.75rem;line-height:1rem}.font-bold{font-weight:700}.font-medium{font-weight:500}.font-semibold{font-weight:600}.uppercase{text-transform:uppercase}.leading-5{line-height:1.25rem}.leading-none{line-height:1}.leading-snug{line-height:1.375}.tracking-wider{letter-spacing:.05em}.text-blue-300{--tw-text-opacity: 1;color:rgb(147 197 253 / var(--tw-text-opacity, 1))}.text-blue-400{--tw-text-opacity: 1;color:rgb(96 165 250 / var(--tw-text-opacity, 1))}.text-cyan-200{--tw-text-opacity: 1;color:rgb(165 243 252 / var(--tw-text-opacity, 1))}.text-cyan-300{--tw-text-opacity: 1;color:rgb(103 232 249 / var(--tw-text-opacity, 1))}.text-cyan-400{--tw-text-opacity: 1;color:rgb(34 211 238 / var(--tw-text-opacity, 1))}.text-gray-100{--tw-text-opacity: 1;color:rgb(243 244 246 / var(--tw-text-opacity, 1))}.text-gray-200{--tw-text-opacity: 1;color:rgb(229 231 235 / var(--tw-text-opacity, 1))}.text-gray-300{--tw-text-opacity: 1;color:rgb(209 213 219 / var(--tw-text-opacity, 1))}.text-gray-400{--tw-text-opacity: 1;color:rgb(156 163 175 / var(--tw-text-opacity, 1))}.text-gray-500{--tw-text-opacity: 1;color:rgb(107 114 128 / var(--tw-text-opacity, 1))}.text-gray-600{--tw-text-opacity: 1;color:rgb(75 85 99 / var(--tw-text-opacity, 1))}.text-green-300{--tw-text-opacity: 1;color:rgb(134 239 172 / var(--tw-text-opacity, 1))}.text-green-400{--tw-text-opacity: 1;color:rgb(74 222 128 / var(--tw-text-opacity, 1))}.text-red-200{--tw-text-opacity: 1;color:rgb(254 202 202 / var(--tw-text-opacity, 1))}.text-red-300{--tw-text-opacity: 1;color:rgb(252 165 165 / var(--tw-text-opacity, 1))}.text-red-400{--tw-text-opacity: 1;color:rgb(248 113 113 / var(--tw-text-opacity, 1))}.text-white{--tw-text-opacity: 1;color:rgb(255 255 255 / var(--tw-text-opacity, 1))}.text-yellow-400{--tw-text-opacity: 1;color:rgb(250 204 21 / var(--tw-text-opacity, 1))}.placeholder-gray-500::-moz-placeholder{--tw-placeholder-opacity: 1;color:rgb(107 114 128 / var(--tw-placeholder-opacity, 1))}.placeholder-gray-500::placeholder{--tw-placeholder-opacity: 1;color:rgb(107 114 128 / var(--tw-placeholder-opacity, 1))}.opacity-60{opacity:.6}.shadow-2xl{--tw-shadow: 0 25px 50px -12px rgb(0 0 0 / .25);--tw-shadow-colored: 0 25px 50px -12px var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow, 0 0 #0000),var(--tw-ring-shadow, 0 0 #0000),var(--tw-shadow)}.shadow-lg{--tw-shadow: 0 10px 15px -3px rgb(0 0 0 / .1), 0 4px 6px -4px rgb(0 0 0 / .1);--tw-shadow-colored: 0 10px 15px -3px var(--tw-shadow-color), 0 4px 6px -4px var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow, 0 0 #0000),var(--tw-ring-shadow, 0 0 #0000),var(--tw-shadow)}.shadow-xl{--tw-shadow: 0 20px 25px -5px rgb(0 0 0 / .1), 0 8px 10px -6px rgb(0 0 0 / .1);--tw-shadow-colored: 0 20px 25px -5px var(--tw-shadow-color), 0 8px 10px -6px var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow, 0 0 #0000),var(--tw-ring-shadow, 0 0 #0000),var(--tw-shadow)}.filter{filter:var(--tw-blur) var(--tw-brightness) var(--tw-contrast) var(--tw-grayscale) var(--tw-hue-rotate) var(--tw-invert) var(--tw-saturate) var(--tw-sepia) var(--tw-drop-shadow)}.transition{transition-property:color,background-color,border-color,text-decoration-color,fill,stroke,opacity,box-shadow,transform,filter,backdrop-filter;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.15s}.transition-colors{transition-property:color,background-color,border-color,text-decoration-color,fill,stroke;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.15s}.react-flow__background{background-color:#0f172a!important}.react-flow__minimap{background-color:#111827!important;border:1px solid #374151!important;border-radius:8px!important}.react-flow__controls button{background-color:#111827!important;border:1px solid #374151!important;color:#9ca3af!important;fill:#9ca3af!important}.react-flow__controls button:hover{background-color:#1f2937!important}.react-flow__attribution{display:none!important}.workflow-node{background:#111827;border:2px solid #374151;border-radius:8px;width:280px!important;height:auto;min-height:90px;box-sizing:border-box;font-size:13px;color:#e5e7eb;box-shadow:0 4px 12px #0006;transition:border-color .15s,box-shadow .15s}.workflow-node:hover{border-color:#4b5563;box-shadow:0 6px 20px #0009}.workflow-node.selected{border-color:#3b82f6;box-shadow:0 0 0 2px #3b82f64d}.node-header{display:flex;align-items:center;gap:6px;padding:6px 10px;border-radius:8px 8px 0 0;font-weight:600;font-size:12px}.node-title-row{display:flex;align-items:center;gap:6px;min-width:0;flex:1}.node-header-control{flex:0 0 auto;display:flex;align-items:center}.node-header-input,.node-header-select{width:112px;min-width:0;height:22px;padding:2px 6px;background:#374151;border:1px solid #4b5563;border-radius:5px;color:#e5e7eb;font:10px ui-monospace,SFMono-Regular,Consolas,monospace;outline:none}.node-header-input:focus,.node-header-select:focus{border-color:#60a5fa}.node-header-select{width:82px;font-family:ui-sans-serif,system-ui,sans-serif;cursor:pointer}.node-body{padding:5px 10px 8px;display:flex;flex-direction:column;justify-content:center;flex:1}.node-port{display:flex;align-items:center;gap:6px;font-size:11px;color:#94a3b8}.node-port span{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.react-flow__handle{width:10px!important;height:10px!important;border:2px solid #475569!important;background:#1e293b!important}.react-flow__handle:hover{background:#3b82f6!important;border-color:#3b82f6!important}.react-flow__handle-connecting{background:#f59e0b!important;border-color:#f59e0b!important}.react-flow__handle-valid{background:#22c55e!important;border-color:#22c55e!important}.dark-scroll{scrollbar-width:thin;scrollbar-color:#334155 transparent}.dark-scroll::-webkit-scrollbar{width:8px;height:8px}.dark-scroll::-webkit-scrollbar-track{background:transparent}.dark-scroll::-webkit-scrollbar-thumb{background:#334155;border-radius:4px;border:2px solid transparent;background-clip:content-box}.dark-scroll::-webkit-scrollbar-thumb:hover{background:#475569;background-clip:content-box}.dark-scroll::-webkit-scrollbar-corner{background:transparent}.modal-portal{position:fixed;top:0;right:0;bottom:0;left:0;z-index:100}.hover\:border-blue-600:hover{--tw-border-opacity: 1;border-color:rgb(37 99 235 / var(--tw-border-opacity, 1))}.hover\:border-gray-400:hover{--tw-border-opacity: 1;border-color:rgb(156 163 175 / var(--tw-border-opacity, 1))}.hover\:border-gray-700:hover{--tw-border-opacity: 1;border-color:rgb(55 65 81 / var(--tw-border-opacity, 1))}.hover\:border-red-800:hover{--tw-border-opacity: 1;border-color:rgb(153 27 27 / var(--tw-border-opacity, 1))}.hover\:bg-blue-500:hover{--tw-bg-opacity: 1;background-color:rgb(59 130 246 / var(--tw-bg-opacity, 1))}.hover\:bg-blue-900\/30:hover{background-color:#1e3a8a4d}.hover\:bg-blue-900\/40:hover{background-color:#1e3a8a66}.hover\:bg-cyan-900\/40:hover{background-color:#164e6366}.hover\:bg-cyan-900\/60:hover{background-color:#164e6399}.hover\:bg-gray-700:hover{--tw-bg-opacity: 1;background-color:rgb(55 65 81 / var(--tw-bg-opacity, 1))}.hover\:bg-gray-800:hover{--tw-bg-opacity: 1;background-color:rgb(31 41 55 / var(--tw-bg-opacity, 1))}.hover\:bg-gray-800\/50:hover{background-color:#1f293780}.hover\:bg-green-600:hover{--tw-bg-opacity: 1;background-color:rgb(22 163 74 / var(--tw-bg-opacity, 1))}.hover\:bg-red-600:hover{--tw-bg-opacity: 1;background-color:rgb(220 38 38 / var(--tw-bg-opacity, 1))}.hover\:bg-red-900\/30:hover{background-color:#7f1d1d4d}.hover\:bg-white\/\[0\.04\]:hover{background-color:#ffffff0a}.hover\:bg-yellow-900\/30:hover{background-color:#713f124d}.hover\:text-blue-300:hover{--tw-text-opacity: 1;color:rgb(147 197 253 / var(--tw-text-opacity, 1))}.hover\:text-blue-400:hover{--tw-text-opacity: 1;color:rgb(96 165 250 / var(--tw-text-opacity, 1))}.hover\:text-gray-200:hover{--tw-text-opacity: 1;color:rgb(229 231 235 / var(--tw-text-opacity, 1))}.hover\:text-gray-300:hover{--tw-text-opacity: 1;color:rgb(209 213 219 / var(--tw-text-opacity, 1))}.hover\:text-red-300:hover{--tw-text-opacity: 1;color:rgb(252 165 165 / var(--tw-text-opacity, 1))}.hover\:text-red-400:hover{--tw-text-opacity: 1;color:rgb(248 113 113 / var(--tw-text-opacity, 1))}.hover\:text-white:hover{--tw-text-opacity: 1;color:rgb(255 255 255 / var(--tw-text-opacity, 1))}.hover\:text-yellow-300:hover{--tw-text-opacity: 1;color:rgb(253 224 71 / var(--tw-text-opacity, 1))}.hover\:underline:hover{text-decoration-line:underline}.focus\:border-blue-500:focus{--tw-border-opacity: 1;border-color:rgb(59 130 246 / var(--tw-border-opacity, 1))}.focus\:outline-none:focus{outline:2px solid transparent;outline-offset:2px}.active\:cursor-grabbing:active{cursor:grabbing}.disabled\:opacity-30:disabled{opacity:.3}.disabled\:opacity-50:disabled{opacity:.5}
diff --git a/processor/web/static/workflow-studio/index.html b/processor/web/static/workflow-studio/index.html
index 8e128451e5b78064904d2b2fe964352b671e8eec..8043dafe200fac22183829268d8598d46ec95583 100644
--- a/processor/web/static/workflow-studio/index.html
+++ b/processor/web/static/workflow-studio/index.html
@@ -6,8 +6,8 @@
     <title>Workflow Studio — EgoData</title>
     <script src="/static/iconify-preload.js"></script>
     <script src="/static/iconify-icon.min.js"></script>
-    <script type="module" crossorigin src="/static/workflow-studio/assets/index-CcWpS4e6.js"></script>
-    <link rel="stylesheet" crossorigin href="/static/workflow-studio/assets/index-Byx6G-Zk.css">
+    <script type="module" crossorigin src="/static/workflow-studio/assets/index-BxCEjQee.js"></script>
+    <link rel="stylesheet" crossorigin href="/static/workflow-studio/assets/index-ap1gwH28.css">
   </head>
   <body class="bg-gray-950 text-gray-200">
     <div id="workflow-root"></div>
diff --git a/processor/web/templates/base.html b/processor/web/templates/base.html
index f2bc03f32b4821465f87596cd104fe42552f5fe8..31341a6740f51b43436f1f3a8786093fab351e1b 100644
--- a/processor/web/templates/base.html
+++ b/processor/web/templates/base.html
@@ -1,323 +1,364 @@
-<!DOCTYPE html>
-<html lang="zh-CN">
+<!DOCTYPE html>
+<html lang="{{ current_lang() }}">
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     {% set boot_user = request.state.auth_user|default({}) %}
     <title>{% block title %}processor{% endblock %}</title>
-    <link rel="stylesheet" href="/static/plyr.css" />
-    <link rel="stylesheet" href="/static/tailwind-generated.css?v={{ asset_version }}">
-    <script src="/static/iconify-preload.js"></script>
-    <script src="/static/iconify-icon.min.js"></script>
-    <script src="/static/plyr.js"></script>
+    <link rel="stylesheet" href="/static/plyr.css" />
+    <link rel="stylesheet" href="/static/tailwind-generated.css?v={{ asset_version }}">
+    <script src="/static/iconify-preload.js"></script>
+    <script src="/static/iconify-icon.min.js"></script>
+    <script src="/static/plyr.js"></script>
+    <!-- 词典要**先于** i18n.js 加载:后者只带逻辑,语言表从这个文件取。
+         它同时被服务端读(app/i18n.py),两边读同一份才不会分叉。 -->
+    <script src="/static/js/i18n-data.js?v={{ asset_version }}"></script>
     <script src="/static/js/i18n.js?v={{ asset_version }}"></script>
-    <style>
-        :root {
-            --plyr-color-main: #3b82f6;
-        }
-        .episode-card { cursor: pointer; }
-        .episode-card.active { background-color: #1e3a5f; border-left: 3px solid #3b82f6; }
-        /* Plyr — fill aspect-video container */
-        #video-grid { min-width: 0; min-height: 0; overflow: hidden; }
-        #video-grid .plyr,
-        #video-grid .plyr__video-wrapper,
-        #video-grid .plyr video {
-            width: 100%; height: 100%; min-width: 0; min-height: 0;
-        }
-        #video-grid .plyr video { object-fit: contain; }
-        .hide-scrollbar {
-            scrollbar-width: none;
-            -ms-overflow-style: none;
-        }
-        .hide-scrollbar::-webkit-scrollbar {
-            display: none;
-        }
-        /* Iconify icons */
-        iconify-icon { display: inline-block; vertical-align: -0.125em; }
-        .icon-sm { font-size: 14px; }
-        .icon-md { font-size: 18px; }
-        /* Frame-aligned mode: Plyr falls back to its default control bar when
-           `controls: []` — hide it entirely. The central play button stays so
-           clicking any view plays the whole frame-aligned set. */
-        .plyr__controls { display: none !important; }
-        .plyr__control--overlaid { display: inline-flex !important; }
-        .plyr--video .plyr__control.plyr__tab-focus { box-shadow: none; }
-        /* Sidebar */
-        .sidebar-link {
-            display: flex; align-items: center; gap: 10px;
-            padding: 10px 16px; border-radius: 6px; margin: 2px 8px;
-            color: #9ca3af; font-size: 14px; transition: all 0.15s;
-            text-decoration: none; white-space: nowrap;
-        }
-        .sidebar-link:hover { background: #1f2937; color: #e5e7eb; }
-        .sidebar-link.active {
-            background: #1e3a5f; color: #93c5fd;
-            border-left: 3px solid #3b82f6; margin-left: 5px;
-            padding-left: 13px; border-radius: 0 6px 6px 0;
-        }
-        .sidebar-sub {
-            display: flex; align-items: center; gap: 8px;
-            padding: 7px 16px 7px 44px; margin: 1px 8px; border-radius: 6px;
-            color: #6b7280; font-size: 13px; transition: all 0.15s;
-            text-decoration: none; white-space: nowrap;
-        }
-        .sidebar-sub:hover { background: #1f2937; color: #d1d5db; }
-        .sidebar-sub.active {
-            color: #93c5fd; background: #111827;
-        }
-        .sidebar-group { overflow: hidden; transition: max-height 0.25s ease; }
-        .sidebar-group.collapsed { max-height: 0 !important; }
-        /* Toggle button — rounded square with triangle icon */
-        .sidebar-toggle {
-            display: inline-flex; align-items: center; justify-content: center;
-            width: 20px; height: 20px; border-radius: 6px; margin-left: auto; flex-shrink: 0;
-            background: #1f2937; color: #6b7280; font-size: 12px;
-            transition: background 0.15s, color 0.15s;
-        }
-        .sidebar-link:hover .sidebar-toggle { background: #374151; color: #9ca3af; }
-        .sidebar-link.active .sidebar-toggle { background: #1e3a5f; color: #93c5fd; }
-        .sidebar-toggle-icon { transition: transform 0.25s ease; display: inline-flex; }
-        .collapsed-toggle .sidebar-toggle-icon { transform: rotate(-90deg); }
-        /* L2 toggle — smaller */
-        .sidebar-toggle-sm {
-            display: inline-flex; align-items: center; justify-content: center;
-            width: 16px; height: 16px; border-radius: 4px; margin-left: auto; flex-shrink: 0;
-            background: #1f2937; color: #6b7280; font-size: 10px;
-            transition: background 0.15s, color 0.15s;
-        }
-        .sidebar-sub:hover .sidebar-toggle-sm { background: #374151; color: #9ca3af; }
-        .sidebar-sub.active .sidebar-toggle-sm { background: #1e3a5f; color: #93c5fd; }
-        .sidebar-toggle-icon-sm { transition: transform 0.25s ease; display: inline-flex; }
-        .collapsed-toggle .sidebar-toggle-icon-sm { transform: rotate(-90deg); }
-        .sidebar-leaf {
-            display: flex; align-items: center; gap: 6px;
-            padding: 3px 16px 3px 56px; margin: 1px 8px; border-radius: 4px;
-            color: #6b7280; font-size: 12px; transition: all 0.15s;
-            text-decoration: none; white-space: nowrap;
-        }
-        .sidebar-leaf:hover { background: #1f2937; color: #d1d5db; }
-        .sidebar-leaf.active { color: #93c5fd; background: #111827; }
-        .sidebar-sub-group { overflow: hidden; transition: max-height 0.25s ease; }
-        .sidebar-sub-group.collapsed { max-height: 0 !important; }
-        .sidebar-sub-chevron { transition: transform 0.2s; font-size: 10px; margin-left: auto; }
-        /* Skeleton pulse */
-        @keyframes skeleton-pulse {
-            0%, 100% { opacity: 1; }
-            50% { opacity: 0.4; }
-        }
-        .skeleton { animation: skeleton-pulse 1.5s ease-in-out infinite; }
-    </style>
-</head>
-<body class="bg-gray-950 text-gray-100 h-screen flex overflow-hidden">
-    <!-- Left Sidebar -->
-    <aside class="flex flex-col bg-gray-900 border-r border-gray-800 flex-shrink-0" style="width:220px">
-        <!-- Brand -->
-        <div class="px-4 py-3 border-b border-gray-800">
-            <div class="flex items-center gap-2">
-                <img src="/static/logo.png" alt="EgoData" class="w-8 h-auto flex-shrink-0">
-                <span class="text-sm font-semibold text-gray-200">EgoData</span>
-            </div>
-        </div>
-
-        <!-- Nav -->
-        <nav class="flex-1 py-3 flex flex-col gap-0.5">
-            <a href="/" class="sidebar-link" data-page="home">
-                <iconify-icon icon="ant-design:home-outlined" class="icon-sm"></iconify-icon>
-                <span data-i18n="nav_home">Home</span>
-            </a>
-            <a href="/tasks" class="sidebar-link" data-page="tasks">
-                <iconify-icon icon="ant-design:project-outlined" class="icon-sm"></iconify-icon>
-                <span data-i18n="nav_tasks">Projects</span>
-            </a>
+    <style>
+        :root {
+            --plyr-color-main: #3b82f6;
+        }
+        .episode-card { cursor: pointer; }
+        .episode-card.active { background-color: #1e3a5f; border-left: 3px solid #3b82f6; }
+        /* Plyr — fill aspect-video container */
+        #video-grid { min-width: 0; min-height: 0; overflow: hidden; }
+        #video-grid .plyr,
+        #video-grid .plyr__video-wrapper,
+        #video-grid .plyr video {
+            width: 100%; height: 100%; min-width: 0; min-height: 0;
+        }
+        #video-grid .plyr video { object-fit: contain; }
+        .hide-scrollbar {
+            scrollbar-width: none;
+            -ms-overflow-style: none;
+        }
+        .hide-scrollbar::-webkit-scrollbar {
+            display: none;
+        }
+        /* Iconify icons */
+        iconify-icon { display: inline-block; vertical-align: -0.125em; }
+        .icon-sm { font-size: 14px; }
+        .icon-md { font-size: 18px; }
+        /* Frame-aligned mode: Plyr falls back to its default control bar when
+           `controls: []` — hide it entirely. The central play button stays so
+           clicking any view plays the whole frame-aligned set. */
+        .plyr__controls { display: none !important; }
+        .plyr__control--overlaid { display: inline-flex !important; }
+        .plyr--video .plyr__control.plyr__tab-focus { box-shadow: none; }
+        /* Sidebar */
+        .sidebar-link {
+            display: flex; align-items: center; gap: 10px;
+            padding: 10px 16px; border-radius: 6px; margin: 2px 8px;
+            color: #9ca3af; font-size: 14px; transition: all 0.15s;
+            text-decoration: none; white-space: nowrap;
+        }
+        .sidebar-link:hover { background: #1f2937; color: #e5e7eb; }
+        .sidebar-link.active {
+            background: #1e3a5f; color: #93c5fd;
+            border-left: 3px solid #3b82f6; margin-left: 5px;
+            padding-left: 13px; border-radius: 0 6px 6px 0;
+        }
+        .sidebar-sub {
+            display: flex; align-items: center; gap: 8px;
+            padding: 7px 16px 7px 44px; margin: 1px 8px; border-radius: 6px;
+            color: #6b7280; font-size: 13px; transition: all 0.15s;
+            text-decoration: none; white-space: nowrap;
+        }
+        .sidebar-sub:hover { background: #1f2937; color: #d1d5db; }
+        .sidebar-sub.active {
+            color: #93c5fd; background: #111827;
+        }
+        .sidebar-group { overflow: hidden; transition: max-height 0.25s ease; }
+        .sidebar-group.collapsed { max-height: 0 !important; }
+        /* Toggle button — rounded square with triangle icon */
+        .sidebar-toggle {
+            display: inline-flex; align-items: center; justify-content: center;
+            width: 20px; height: 20px; border-radius: 6px; margin-left: auto; flex-shrink: 0;
+            background: #1f2937; color: #6b7280; font-size: 12px;
+            transition: background 0.15s, color 0.15s;
+        }
+        .sidebar-link:hover .sidebar-toggle { background: #374151; color: #9ca3af; }
+        .sidebar-link.active .sidebar-toggle { background: #1e3a5f; color: #93c5fd; }
+        .sidebar-toggle-icon { transition: transform 0.25s ease; display: inline-flex; }
+        .collapsed-toggle .sidebar-toggle-icon { transform: rotate(-90deg); }
+        /* L2 toggle — smaller */
+        .sidebar-toggle-sm {
+            display: inline-flex; align-items: center; justify-content: center;
+            width: 16px; height: 16px; border-radius: 4px; margin-left: auto; flex-shrink: 0;
+            background: #1f2937; color: #6b7280; font-size: 10px;
+            transition: background 0.15s, color 0.15s;
+        }
+        .sidebar-sub:hover .sidebar-toggle-sm { background: #374151; color: #9ca3af; }
+        .sidebar-sub.active .sidebar-toggle-sm { background: #1e3a5f; color: #93c5fd; }
+        .sidebar-toggle-icon-sm { transition: transform 0.25s ease; display: inline-flex; }
+        .collapsed-toggle .sidebar-toggle-icon-sm { transform: rotate(-90deg); }
+        .sidebar-leaf {
+            display: flex; align-items: center; gap: 6px;
+            padding: 3px 16px 3px 56px; margin: 1px 8px; border-radius: 4px;
+            color: #6b7280; font-size: 12px; transition: all 0.15s;
+            text-decoration: none; white-space: nowrap;
+        }
+        .sidebar-leaf:hover { background: #1f2937; color: #d1d5db; }
+        .sidebar-leaf.active { color: #93c5fd; background: #111827; }
+        .sidebar-sub-group { overflow: hidden; transition: max-height 0.25s ease; }
+        .sidebar-sub-group.collapsed { max-height: 0 !important; }
+        .sidebar-sub-chevron { transition: transform 0.2s; font-size: 10px; margin-left: auto; }
+        /* Skeleton pulse */
+        @keyframes skeleton-pulse {
+            0%, 100% { opacity: 1; }
+            50% { opacity: 0.4; }
+        }
+        .skeleton { animation: skeleton-pulse 1.5s ease-in-out infinite; }
+    </style>
+</head>
+<body class="bg-gray-950 text-gray-100 h-screen flex overflow-hidden">
+    <!-- Left Sidebar -->
+    <aside class="flex flex-col bg-gray-900 border-r border-gray-800 flex-shrink-0" style="width:220px">
+        <!-- Brand -->
+        <div class="px-4 py-3 border-b border-gray-800">
+            <div class="flex items-center gap-2">
+                <img src="/static/logo.png" alt="EgoData" class="w-8 h-auto flex-shrink-0">
+                <span class="text-sm font-semibold text-gray-200">EgoData</span>
+            </div>
+        </div>
+
+        <!-- Nav -->
+        <nav class="flex-1 py-3 flex flex-col gap-0.5">
+            <a href="/" class="sidebar-link" data-page="home">
+                <iconify-icon icon="ant-design:home-outlined" class="icon-sm"></iconify-icon>
+                <span data-i18n="nav_home">{{ t('nav_home') }}</span>
+            </a>
+            <a href="/tasks" class="sidebar-link" data-page="tasks">
+                <iconify-icon icon="ant-design:project-outlined" class="icon-sm"></iconify-icon>
+                <span data-i18n="nav_tasks">{{ t('nav_tasks') }}</span>
+            </a>
             <a href="/workflow-studio" class="sidebar-link" data-page="workflow-studio">
                 <iconify-icon icon="ant-design:apartment-outlined" class="icon-sm"></iconify-icon>
-                <span>Workflow</span>
+                <span data-i18n="nav_workflow">{{ t('nav_workflow') }}</span>
             </a>
             <a href="/users" id="users-nav" class="sidebar-link{% if boot_user.role|default('') != 'admin' %} hidden{% endif %}" data-page="users">
-                <iconify-icon icon="ant-design:team-outlined" class="icon-sm"></iconify-icon>
-                <span>Users</span>
+                {# 图标必须取自 iconify-preload.js 白名单 —— 此处在每个页面的侧边栏,
+                   用白名单外的名字会让每次翻页都去 api.iconify.design 拉一次。
+                   team-outlined 不在表内,改用同义的 user-outlined。 #}
+                <iconify-icon icon="ant-design:user-outlined" class="icon-sm"></iconify-icon>
+                <span data-i18n="nav_users">{{ t('nav_users') }}</span>
+            </a>
+            <a href="/annotation-studio" class="sidebar-link" data-page="annotation-studio">
+                <iconify-icon icon="ant-design:edit-outlined" class="icon-sm"></iconify-icon>
+                <span data-i18n="nav_annotation">{{ t('nav_annotation') }}</span>
+            </a>
+            <!-- Video Review — status shortcuts; the project→task→video
+                 hierarchy list renders on the right side of the page -->
+            <a href="/review" class="sidebar-link" data-page="review">
+                <iconify-icon icon="ant-design:video-camera-outlined" class="icon-sm"></iconify-icon>
+                <span data-i18n="nav_review">{{ t('nav_review') }}</span>
+            </a>
+            <a href="/review?status=completed" class="sidebar-sub" data-review-status="reviewing">
+                <iconify-icon icon="ant-design:eye-outlined" class="icon-sm"></iconify-icon>
+                <span data-i18n="stat_reviewing">{{ t('stat_reviewing') }}</span>
+            </a>
+            <a href="/review?status=reviewed" class="sidebar-sub" data-review-status="approved">
+                <iconify-icon icon="ant-design:check-circle-outlined" class="icon-sm"></iconify-icon>
+                <span data-i18n="stat_approved">{{ t('stat_approved') }}</span>
+            </a>
+            <a href="/review?status=failed" class="sidebar-sub" data-review-status="failed">
+                <iconify-icon icon="ant-design:warning-outlined" class="icon-sm"></iconify-icon>
+                <span data-i18n="stat_failed">{{ t('stat_failed') }}</span>
+            </a>
+
+            <!-- 模型 — 一级项,与 Video Review **同级同款**(图标 + 可点击 +
+                 选中蓝底高亮),下面挂训练/部署两个二级短名项。
+                 一级项暂时指向 /train:它目前是唯一的二级页。将来有了 /deploy,
+                 这里应该改成一个模型总览页(Video Review 指向 /review 的写法同理)。 -->
+            <!-- 「模型」是**一级项,点进去直接就是那一页** —— 页内三个页签
+                 (模型训练 / 新建训练 / 模型推理)自己分工。
+                 早先这里是两个二级项(训练 / 推理),但它们指向两个页面,而两者
+                 本来是同一批产物的上下游,分两个导航项反而要来回跳。 -->
+            <a href="/train" class="sidebar-link" data-page="model">
+                <iconify-icon icon="ant-design:robot-outlined" class="icon-sm"></iconify-icon>
+                <span data-i18n="nav_model">{{ t('nav_model') }}</span>
+            </a>
+        </nav>
+
+        <!-- Bottom links -->
+        <div class="py-3 border-t border-gray-800 flex flex-col gap-0.5">
+            <a href="/trash" class="sidebar-link" data-page="trash">
+                <iconify-icon icon="ant-design:delete-outlined" class="icon-sm"></iconify-icon>
+                <span data-i18n="nav_trash">{{ t('nav_trash') }}</span>
+                <span id="trash-badge" class="ml-auto text-xs text-gray-500"></span>
             </a>
-            <a href="/annotation-studio" class="sidebar-link" data-page="annotation-studio">
-                <iconify-icon icon="ant-design:edit-outlined" class="icon-sm"></iconify-icon>
-                <span>Annotation</span>
-            </a>
-            <!-- Video Review — status shortcuts; the project→task→video
-                 hierarchy list renders on the right side of the page -->
-            <a href="/review" class="sidebar-link" data-page="review">
-                <iconify-icon icon="ant-design:video-camera-outlined" class="icon-sm"></iconify-icon>
-                <span data-i18n="nav_review">Video Review</span>
-            </a>
-            <a href="/review?status=completed" class="sidebar-sub" data-review-status="reviewing">
-                <iconify-icon icon="ant-design:eye-outlined" class="icon-sm"></iconify-icon>
-                <span data-i18n="stat_reviewing">Reviewing</span>
-            </a>
-            <a href="/review?status=reviewed" class="sidebar-sub" data-review-status="approved">
-                <iconify-icon icon="ant-design:check-circle-outlined" class="icon-sm"></iconify-icon>
-                <span data-i18n="stat_approved">Approved</span>
-            </a>
-            <a href="/review?status=failed" class="sidebar-sub" data-review-status="failed">
-                <iconify-icon icon="ant-design:warning-outlined" class="icon-sm"></iconify-icon>
-                <span data-i18n="stat_failed">Failed</span>
-            </a>
-        </nav>
-
-        <!-- Bottom links -->
-        <div class="py-3 border-t border-gray-800 flex flex-col gap-0.5">
-            <a href="/trash" class="sidebar-link" data-page="trash">
-                <iconify-icon icon="ant-design:delete-outlined" class="icon-sm"></iconify-icon>
-                <span data-i18n="nav_trash">Trash</span>
-                <span id="trash-badge" class="ml-auto text-xs text-gray-500"></span>
-            </a>
-        </div>
-
-        <!-- User menu -->
-        <div class="border-t border-gray-800 px-3 py-2 relative" id="user-menu-container">
-            <button id="user-menu-btn" onclick="toggleUserMenu()"
-                    class="w-full flex items-center gap-2.5 px-2 py-2 rounded-lg hover:bg-gray-800/50 transition-colors text-left">
-                <img src="/static/logo.png" alt="" class="w-7 h-7 rounded-full flex-shrink-0">
-                <div class="flex-1 min-w-0">
+        </div>
+
+        <!-- User menu -->
+        <div class="border-t border-gray-800 px-3 py-2 relative" id="user-menu-container">
+            <button id="user-menu-btn" onclick="toggleUserMenu()"
+                    class="w-full flex items-center gap-2.5 px-2 py-2 rounded-lg hover:bg-gray-800/50 transition-colors text-left">
+                <img src="/static/logo.png" alt="" class="w-7 h-7 rounded-full flex-shrink-0">
+                <div class="flex-1 min-w-0">
                     <div id="user-name-display" class="text-xs text-gray-300 truncate">{{ boot_user.username|default('') }}</div>
                     <div id="user-role-display" class="text-xs text-gray-600">{{ boot_user.role|default('')|title }}</div>
-                </div>
-                <iconify-icon icon="ant-design:caret-up-outlined" id="user-caret" class="text-gray-600 text-xs transition-transform"></iconify-icon>
-            </button>
-
-            <!-- Dropdown -->
-            <div id="user-dropdown" class="hidden absolute bottom-full left-3 right-3 mb-1 bg-gray-800 border border-gray-700 rounded-lg shadow-xl overflow-hidden z-50">
-                <div class="px-3 py-2 border-b border-gray-700">
+                </div>
+                <iconify-icon icon="ant-design:caret-up-outlined" id="user-caret" class="text-gray-600 text-xs transition-transform"></iconify-icon>
+            </button>
+
+            <!-- Dropdown -->
+            <div id="user-dropdown" class="hidden absolute bottom-full left-3 right-3 mb-1 bg-gray-800 border border-gray-700 rounded-lg shadow-xl overflow-hidden z-50">
+                <div class="px-3 py-2 border-b border-gray-700">
                     <div id="dd-username" class="text-xs text-gray-300 font-medium">{{ boot_user.username|default('') }}</div>
                     <div id="dd-role" class="text-xs text-gray-500">{{ boot_user.role|default('')|title }}</div>
-                </div>
-                <a href="javascript:void(0)" class="block px-3 py-2 text-xs text-gray-400 hover:bg-gray-700 hover:text-gray-200 transition-colors">
-                    <iconify-icon icon="ant-design:user-outlined" class="icon-sm mr-2"></iconify-icon>Profile
-                </a>
-                <a href="javascript:void(0)" class="block px-3 py-2 text-xs text-gray-400 hover:bg-gray-700 hover:text-gray-200 transition-colors">
-                    <iconify-icon icon="ant-design:lock-outlined" class="icon-sm mr-2"></iconify-icon>Change Password
-                </a>
-                <a href="javascript:void(0)" onclick="handleLogout()" class="block px-3 py-2 text-xs text-red-400 hover:bg-gray-700 hover:text-red-300 transition-colors border-t border-gray-700">
-                    <iconify-icon icon="ant-design:logout-outlined" class="icon-sm mr-2"></iconify-icon>Logout
-                </a>
-            </div>
-        </div>
-    </aside>
-
-    <!-- Main content area -->
-    <main class="flex-1 flex min-w-0 overflow-hidden">
-        {% block content %}{% endblock %}
-    </main>
-
-    <!-- Sidebar active state -->
-    <script>
-        // ── Active state (static links only) ──────────
-        (function() {
-            const pathname = document.location.pathname.replace(/\/$/, '') || '/';
-            document.querySelectorAll('.sidebar-link').forEach(link => {
-                const linkPage = link.dataset.page;
-                const isActive = (pathname === '/' && linkPage === 'home')
-                    || (pathname === '/tasks' && linkPage === 'tasks')
+                </div>
+                <a href="javascript:void(0)" class="block px-3 py-2 text-xs text-gray-400 hover:bg-gray-700 hover:text-gray-200 transition-colors">
+                    <iconify-icon icon="ant-design:user-outlined" class="icon-sm mr-2"></iconify-icon><span data-i18n="menu_profile">{{ t('menu_profile') }}</span>
+                </a>
+                <a href="javascript:void(0)" class="block px-3 py-2 text-xs text-gray-400 hover:bg-gray-700 hover:text-gray-200 transition-colors">
+                    <iconify-icon icon="ant-design:lock-outlined" class="icon-sm mr-2"></iconify-icon><span data-i18n="menu_change_password">{{ t('menu_change_password') }}</span>
+                </a>
+                <!-- 界面语言。两个选项都写自己的文字（English / 中文 是自名，
+                     不随界面语言翻译），当前项由 updateLangToggle() 高亮。
+                     点这里不会关掉菜单：外部点击的判定用 container.contains(e.target)，
+                     而它在本容器内。 -->
+                <div class="px-3 py-2 border-t border-gray-700">
+                    <div class="mb-1.5 text-xs text-gray-500" data-i18n="language">{{ t('language') }}</div>
+                    <div class="flex gap-1">
+                        <button type="button" data-lang-option="en" onclick="setLang('en')"
+                                aria-pressed="false"
+                                class="flex-1 rounded border border-gray-700 px-2 py-1 text-xs text-gray-400 hover:bg-gray-700 hover:text-gray-200 transition-colors">English</button>
+                        <button type="button" data-lang-option="zh" onclick="setLang('zh')"
+                                aria-pressed="false"
+                                class="flex-1 rounded border border-gray-700 px-2 py-1 text-xs text-gray-400 hover:bg-gray-700 hover:text-gray-200 transition-colors">中文</button>
+                    </div>
+                </div>
+                <a href="javascript:void(0)" onclick="handleLogout()" class="block px-3 py-2 text-xs text-red-400 hover:bg-gray-700 hover:text-red-300 transition-colors border-t border-gray-700">
+                    <iconify-icon icon="ant-design:logout-outlined" class="icon-sm mr-2"></iconify-icon><span data-i18n="menu_logout">{{ t('menu_logout') }}</span>
+                </a>
+            </div>
+        </div>
+    </aside>
+
+    <!-- Main content area -->
+    <main class="flex-1 flex min-w-0 overflow-hidden">
+        {% block content %}{% endblock %}
+    </main>
+
+    <!-- Sidebar active state -->
+    <script>
+        // ── Active state (static links only) ──────────
+        (function() {
+            const pathname = document.location.pathname.replace(/\/$/, '') || '/';
+            // 同时遍历二级项 .sidebar-sub[data-page] —— 本块原本只认
+            // .sidebar-link,而「训练」挂在 sidebar-sub 上,不改这里它永远不会高亮。
+            // 带 [data-page] 限定是为了避开下面那批 review 状态快捷项:它们没有
+            // data-page,由紧跟着的另一段脚本按 URL 参数管。
+            document.querySelectorAll('.sidebar-link, .sidebar-sub[data-page]').forEach(link => {
+                const linkPage = link.dataset.page;
+                const isActive = (pathname === '/' && linkPage === 'home')
+                    || (pathname === '/tasks' && linkPage === 'tasks')
                     || (pathname === '/workflow-studio' && linkPage === 'workflow-studio')
                     || (pathname === '/users' && linkPage === 'users')
                     || (pathname === '/annotation-studio' && linkPage === 'annotation-studio')
-                    || (pathname === '/review' && linkPage === 'review')
-                    || (pathname === '/trash' && linkPage === 'trash');
-                if (isActive) link.classList.add('active');
-            });
-        })();
-
-        // ── Review status shortcut highlight (URL-driven) ──
-        (function() {
-            const pathname = document.location.pathname.replace(/\/$/, '') || '/';
-            if (pathname === '/review') {
-                const status = new URLSearchParams(document.location.search).get('status') || 'completed';
+                    || (pathname === '/review' && linkPage === 'review')
+                    || (pathname === '/trash' && linkPage === 'trash')
+                    // 一级项「模型」目前也指向 /train,所以它跟着一起亮 ——
+                    // 与 Video Review 在 /review 上「父项 + 某个状态子项同时亮」一致。
+                    || (pathname === '/train' && linkPage === 'model');
+                if (isActive) link.classList.add('active');
+            });
+        })();
+
+        // ── Review status shortcut highlight (URL-driven) ──
+        (function() {
+            const pathname = document.location.pathname.replace(/\/$/, '') || '/';
+            if (pathname === '/review') {
+                const status = new URLSearchParams(document.location.search).get('status') || 'completed';
                 const groupKey = status === 'reviewed' ? 'approved'
-                    : (status === 'failed' ? 'failed' : 'reviewing');
-                document.querySelectorAll('.sidebar-sub[data-review-status]').forEach(el => {
-                    if (el.dataset.reviewStatus === groupKey) el.classList.add('active');
-                });
-            }
-        })();
-
-        // No-op stubs kept for app.js compatibility (the sidebar status tree
-        // was removed — the hierarchy list lives on the review page itself).
-        function refreshReviewTree() {}
-        function highlightNavActive() {}
-        window.highlightNavActive = highlightNavActive;
-
-        function escHtml(s) {
-            if (!s) return '';
-            return s.replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;').replace(/"/g,'&quot;');
-        }
-
-        // ── Trash badge ──
-        async function updateTrashBadge() {
-            try {
-                const res = await fetch('/api/v1/episodes?status=deleted&limit=1');
-                const data = await res.json();
-                const badge = document.getElementById('trash-badge');
-                if (badge) {
-                    const count = data.total || 0;
-                    badge.textContent = count > 0 ? '(' + count + ')' : '';
-                    badge.className = count > 0 ? 'text-orange-400 ml-auto text-xs' : 'text-gray-500 ml-auto text-xs';
-                }
-            } catch(e) {}
-        }
-        updateTrashBadge();
-
+                    : (status === 'failed' ? 'failed' : 'reviewing');
+                document.querySelectorAll('.sidebar-sub[data-review-status]').forEach(el => {
+                    if (el.dataset.reviewStatus === groupKey) el.classList.add('active');
+                });
+            }
+        })();
+
+        // No-op stubs kept for app.js compatibility (the sidebar status tree
+        // was removed — the hierarchy list lives on the review page itself).
+        function refreshReviewTree() {}
+        function highlightNavActive() {}
+        window.highlightNavActive = highlightNavActive;
+
+        function escHtml(s) {
+            if (!s) return '';
+            return s.replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;').replace(/"/g,'&quot;');
+        }
+
+        // ── Trash badge ──
+        async function updateTrashBadge() {
+            try {
+                const res = await fetch('/api/v1/episodes?status=deleted&limit=1');
+                const data = await res.json();
+                const badge = document.getElementById('trash-badge');
+                if (badge) {
+                    const count = data.total || 0;
+                    badge.textContent = count > 0 ? '(' + count + ')' : '';
+                    badge.className = count > 0 ? 'text-orange-400 ml-auto text-xs' : 'text-gray-500 ml-auto text-xs';
+                }
+            } catch(e) {}
+        }
+        updateTrashBadge();
+
         // Bootstrap the shared layout from the signed-in token claims so the
         // real account is visible on first paint. /auth/me remains the
         // authoritative refresh for role changes and account expiry.
         window.__EGO_USER__ = {{ boot_user|default({})|tojson }};
 
         // ── User menu ──────────────────────────────────
-        let _userMenuLoaded = false;
-        async function loadUserInfo() {
-            if (_userMenuLoaded) return;
-            _userMenuLoaded = true;
-            try {
-                const res = await fetch('/api/v1/auth/me');
-                if (!res.ok) return;
-                const user = await res.json();
-                document.getElementById('user-name-display').textContent = user.username || '-';
-                document.getElementById('user-role-display').textContent = user.role || '-';
+        let _userMenuLoaded = false;
+        async function loadUserInfo() {
+            if (_userMenuLoaded) return;
+            _userMenuLoaded = true;
+            try {
+                const res = await fetch('/api/v1/auth/me');
+                if (!res.ok) return;
+                const user = await res.json();
+                document.getElementById('user-name-display').textContent = user.username || '-';
+                document.getElementById('user-role-display').textContent = user.role || '-';
                 document.getElementById('dd-username').textContent = user.username || '-';
                 document.getElementById('dd-role').textContent = user.role || '-';
                 const usersNav = document.getElementById('users-nav');
                 if (usersNav && user.role === 'admin') usersNav.classList.remove('hidden');
-            } catch(e) { /* silent */ }
-        }
+            } catch(e) { /* silent */ }
+        }
         loadUserInfo();
-
-        function toggleUserMenu() {
-            const dd = document.getElementById('user-dropdown');
-            const caret = document.getElementById('user-caret');
-            if (!dd) return;
-            const isOpen = !dd.classList.contains('hidden');
-            dd.classList.toggle('hidden');
-            if (isOpen) {
-                caret.style.transform = '';
-            } else {
-                caret.style.transform = 'rotate(180deg)';
-                if (!_userMenuLoaded) loadUserInfo();
-            }
-        }
-
-        // Close dropdown when clicking outside
-        document.addEventListener('click', function(e) {
-            const container = document.getElementById('user-menu-container');
-            const dd = document.getElementById('user-dropdown');
-            if (container && dd && !container.contains(e.target)) {
-                if (!dd.classList.contains('hidden')) {
-                    toggleUserMenu();
-                }
-            }
-        });
-
-        async function handleLogout() {
-            try {
-                await fetch('/api/v1/auth/logout', { method: 'POST' });
-            } catch(e) {}
-            window.location.href = '/login';
-        }
-    </script>
-</body>
-</html>
+
+        function toggleUserMenu() {
+            const dd = document.getElementById('user-dropdown');
+            const caret = document.getElementById('user-caret');
+            if (!dd) return;
+            const isOpen = !dd.classList.contains('hidden');
+            dd.classList.toggle('hidden');
+            if (isOpen) {
+                caret.style.transform = '';
+            } else {
+                caret.style.transform = 'rotate(180deg)';
+                if (!_userMenuLoaded) loadUserInfo();
+            }
+        }
+
+        // Close dropdown when clicking outside
+        document.addEventListener('click', function(e) {
+            const container = document.getElementById('user-menu-container');
+            const dd = document.getElementById('user-dropdown');
+            if (container && dd && !container.contains(e.target)) {
+                if (!dd.classList.contains('hidden')) {
+                    toggleUserMenu();
+                }
+            }
+        });
+
+        async function handleLogout() {
+            try {
+                await fetch('/api/v1/auth/logout', { method: 'POST' });
+            } catch(e) {}
+            window.location.href = '/login';
+        }
+    </script>
+</body>
+</html>
diff --git a/processor/web/templates/exports.html b/processor/web/templates/exports.html
index cca75ed27797f7e8d462252b426eb9e33408b3c4..6c48fa35a6819b28c1d9a8c3f36de70dcd17a76c 100644
--- a/processor/web/templates/exports.html
+++ b/processor/web/templates/exports.html
@@ -5,21 +5,21 @@
 <div class="flex-1 flex flex-col p-6 overflow-auto hide-scrollbar">
     <!-- New export form -->
     <div class="bg-gray-900 rounded-lg p-4 mb-6 max-w-2xl">
-        <h2 class="text-lg font-semibold mb-3">New Export</h2>
+        <h2 class="text-lg font-semibold mb-3" data-i18n="new_export">{{ t('new_export') }}</h2>
         <div class="flex gap-3 items-end flex-wrap">
             <div>
-                <label class="block text-xs text-gray-400 mb-1">Dataset Name</label>
+                <label class="block text-xs text-gray-400 mb-1" data-i18n="dataset_name">{{ t('dataset_name') }}</label>
                 <input id="new-dataset-name" type="text" placeholder="my_robot_dataset"
                        class="bg-gray-800 rounded px-3 py-2 border border-gray-700 w-48">
             </div>
             <div>
-                <label class="block text-xs text-gray-400 mb-1">Train Ratio</label>
+                <label class="block text-xs text-gray-400 mb-1" data-i18n="train_ratio">{{ t('train_ratio') }}</label>
                 <input id="new-split-ratio" type="number" value="0.9" min="0.5" max="1" step="0.05"
                        class="bg-gray-800 rounded px-3 py-2 border border-gray-700 w-24">
             </div>
             <button onclick="startExport()"
                     class="bg-blue-600 hover:bg-blue-500 text-white px-5 py-2 rounded font-medium">
-                Start Export
+                <span data-i18n="start_export">{{ t('start_export') }}</span>
             </button>
         </div>
         <p class="text-xs text-gray-500 mt-2">
@@ -32,15 +32,15 @@
         <table class="w-full text-sm">
             <thead class="bg-gray-800 text-gray-400 text-left">
                 <tr>
-                    <th class="px-4 py-2">Dataset</th>
-                    <th class="px-4 py-2">Status</th>
-                    <th class="px-4 py-2">Progress</th>
-                    <th class="px-4 py-2">Created</th>
-                    <th class="px-4 py-2">Actions</th>
+                    <th class="px-4 py-2" data-i18n="dataset">{{ t('dataset') }}</th>
+                    <th class="px-4 py-2" data-i18n="status">{{ t('status') }}</th>
+                    <th class="px-4 py-2" data-i18n="progress">{{ t('progress') }}</th>
+                    <th class="px-4 py-2" data-i18n="created">{{ t('created') }}</th>
+                    <th class="px-4 py-2" data-i18n="col_actions">{{ t('col_actions') }}</th>
                 </tr>
             </thead>
             <tbody id="export-list">
-                <tr><td colspan="5" class="text-center text-gray-500 py-8">Loading...</td></tr>
+                <tr><td colspan="5" class="text-center text-gray-500 py-8" data-i18n="loading">{{ t('loading') }}</td></tr>
             </tbody>
         </table>
     </div>
diff --git a/processor/web/templates/index.html b/processor/web/templates/index.html
index 2af79d0cca0cc12d6436f27eebd9608f74c101e5..012fa0f1d45ff18e2229704f8b6f1b4bf633b1a8 100644
--- a/processor/web/templates/index.html
+++ b/processor/web/templates/index.html
@@ -274,20 +274,20 @@
                 class="text-xs px-2.5 py-1.5 rounded-lg border border-gray-600/70 bg-gray-900/55 backdrop-blur-md text-gray-300 hover:border-blue-500 hover:text-white transition-colors flex items-center gap-1 shadow-lg"
                 style="cursor:move;user-select:none;">
             <iconify-icon icon="ant-design:menu-outlined" class="icon-sm"></iconify-icon>
-            <span>Preview Options</span>
+            <span data-i18n="preview_options">{{ t('preview_options') }}</span>
         </button>
         <div id="preview-options-menu"
              class="hidden absolute left-0 top-full mt-1 w-64 rounded-lg border border-gray-600/70 bg-gray-900/60 backdrop-blur-md shadow-xl z-40 p-1.5 text-xs">
             <div id="po-video-row" class="hidden px-2 py-1.5 rounded hover:bg-gray-800">
                 <div class="flex items-center justify-between gap-2">
-                    <span class="text-gray-200">Video Sources</span>
+                    <span class="text-gray-200" data-i18n="video_sources">{{ t('video_sources') }}</span>
                     <button id="po-video-all" type="button"
-                            class="text-[10px] text-cyan-300 hover:text-white">All</button>
+                            class="text-[10px] text-cyan-300 hover:text-white" data-i18n="all">{{ t('all') }}</button>
                 </div>
                 <div id="po-video-list" class="mt-1 space-y-1"></div>
             </div>
             <div class="flex items-center justify-between gap-2 px-2 py-1.5 rounded hover:bg-gray-800">
-                <span class="text-gray-200">Hand Skeleton</span>
+                <span class="text-gray-200" data-i18n="hand_skeleton">{{ t('hand_skeleton') }}</span>
                 <label class="relative inline-flex items-center cursor-pointer">
                     <input type="checkbox" id="toggle-hand-skeleton" class="sr-only peer" checked>
                     <div class="bg-gray-700 peer-checked:bg-cyan-600 rounded-full relative transition-colors"
@@ -298,7 +298,7 @@
                 </label>
             </div>
             <div class="flex items-center justify-between gap-2 px-2 py-1.5 rounded hover:bg-gray-800">
-                <span class="text-gray-200">Hand Trail</span>
+                <span class="text-gray-200" data-i18n="hand_trail">{{ t('hand_trail') }}</span>
                 <label class="relative inline-flex items-center cursor-pointer">
                     <input type="checkbox" id="toggle-hand-trail" class="sr-only peer">
                     <div class="bg-gray-700 peer-checked:bg-cyan-600 rounded-full relative transition-colors"
@@ -309,7 +309,7 @@
                 </label>
             </div>
             <div id="po-glove-row" class="hidden flex items-center justify-between gap-2 px-2 py-1.5 rounded hover:bg-gray-800">
-                <span class="text-gray-200">Glove Sensor</span>
+                <span class="text-gray-200" data-i18n="glove_sensor">{{ t('glove_sensor') }}</span>
                 <label class="relative inline-flex items-center cursor-pointer">
                     <input type="checkbox" id="toggle-glove-sensor" class="sr-only peer" checked>
                     <div class="bg-gray-700 peer-checked:bg-emerald-600 rounded-full relative transition-colors"
@@ -320,7 +320,7 @@
                 </label>
             </div>
             <div id="po-heatmap-row" class="hidden flex items-center justify-between gap-2 px-2 py-1.5 rounded hover:bg-gray-800">
-                <span class="text-gray-200" data-i18n="heatmap_toggle">Depth Heatmap</span>
+                <span class="text-gray-200" data-i18n="heatmap_toggle">{{ t('heatmap_toggle') }}</span>
                 <label class="relative inline-flex items-center cursor-pointer">
                     <input type="checkbox" id="toggle-heatmap" class="sr-only peer" checked>
                     <div class="bg-gray-700 peer-checked:bg-rose-600 rounded-full relative transition-colors"
@@ -331,7 +331,7 @@
                 </label>
             </div>
             <div id="po-hand3d-world-row" class="hidden flex items-center justify-between gap-2 px-2 py-1.5 rounded hover:bg-gray-800">
-                <span class="text-gray-200" data-i18n="hand3d_world">3D Hand World</span>
+                <span class="text-gray-200" data-i18n="hand3d_world">{{ t('hand3d_world') }}</span>
                 <label class="relative inline-flex items-center cursor-pointer">
                     <input type="checkbox" id="toggle-hand3d-world" class="sr-only peer" checked>
                     <div class="bg-gray-700 peer-checked:bg-cyan-600 rounded-full relative transition-colors"
@@ -351,7 +351,7 @@
     <div id="camera-tabs" class="hidden flex gap-2 px-4 pt-3 pb-0 border-b border-gray-800 items-center flex-shrink-0">
         <span id="episode-info" class="hidden text-xs text-gray-400 items-center gap-2 py-1.5"></span>
         <span id="frame-info-header" class="ml-auto text-xs font-mono text-gray-500 hidden">
-            Frame: <span id="detail-current-frame" class="text-green-400 font-bold">0</span>
+            <span data-i18n="frame_label">{{ t('frame_label') }}</span> <span id="detail-current-frame" class="text-green-400 font-bold">0</span>
             / <span id="detail-total-frames" class="text-gray-400">0</span>
         </span>
     </div>
@@ -365,7 +365,7 @@
     <div id="video-grid" class="flex-1 min-w-0 min-h-0 p-3 overflow-hidden flex items-center justify-center">
         <div class="text-gray-600 text-center">
             <div class="text-4xl mb-3"><iconify-icon icon="ant-design:video-camera-outlined"></iconify-icon></div>
-            <div data-i18n="select_episode">Select an episode to review →</div>
+            <div data-i18n="select_episode">{{ t('select_episode') }}</div>
         </div>
     </div>
     <!-- 批次加载遮罩:媒体组/全部播放器/帧数据/标注就绪前盖住画布,
@@ -374,7 +374,7 @@
          style="background:rgba(2,6,23,.55);backdrop-filter:blur(2px);">
         <div class="flex flex-col items-center gap-3">
             <div class="w-10 h-10 rounded-full border-4 border-blue-500 border-t-transparent animate-spin"></div>
-            <div class="text-sm text-gray-300" data-i18n="loading">Loading…</div>
+            <div class="text-sm text-gray-300" data-i18n="loading">{{ t('loading') }}</div>
         </div>
     </div>
 
@@ -405,7 +405,7 @@
             <button id="btn-skip-back-10" class="frame-control-button bg-gray-700 hover:bg-gray-600 text-white rounded flex items-center justify-center" title="Back 10 frames"><iconify-icon icon="ant-design:step-backward-outlined" class="icon-sm"></iconify-icon></button>
             <button id="btn-step-back" class="frame-control-button bg-gray-700 hover:bg-gray-600 text-white rounded flex items-center justify-center" title="Back 1 frame"><iconify-icon icon="ant-design:left-outlined" class="icon-sm"></iconify-icon></button>
             <button id="btn-play-all" onclick="togglePlayAll()" class="bg-blue-600 hover:bg-blue-500 text-white rounded text-xs flex items-center justify-center gap-1" title="Play all synchronized views" aria-pressed="false">
-                <iconify-icon data-play-icon icon="ant-design:caret-right-filled" class="icon-sm"></iconify-icon> <span class="play-label">Play</span>
+                <iconify-icon data-play-icon icon="ant-design:caret-right-filled" class="icon-sm"></iconify-icon> <span class="play-label" data-i18n="play">{{ t('play') }}</span>
             </button>
             <button id="btn-step-forward" class="frame-control-button bg-gray-700 hover:bg-gray-600 text-white rounded flex items-center justify-center" title="Forward 1 frame"><iconify-icon icon="ant-design:right-outlined" class="icon-sm"></iconify-icon></button>
             <button id="btn-skip-forward-10" class="frame-control-button bg-gray-700 hover:bg-gray-600 text-white rounded flex items-center justify-center" title="Forward 10 frames"><iconify-icon icon="ant-design:step-forward-outlined" class="icon-sm"></iconify-icon></button>
@@ -420,13 +420,13 @@
     <div id="heatmap-section" class="flex-shrink-0 border-t border-gray-800 px-4 py-2 hidden" style="display:none">
         <div class="flex gap-2">
             <div class="flex-1 text-center">
-                <div class="text-xs text-gray-500 mb-1" data-i18n="left_hand">Left Hand</div>
+                <div class="text-xs text-gray-500 mb-1" data-i18n="left_hand">{{ t('left_hand') }}</div>
                 <img id="hand-left" src="" alt="Left Hand"
                      class="rounded border border-gray-700 bg-gray-900"
                      style="width:100%;height:95px;object-fit:contain">
             </div>
             <div class="flex-1 text-center">
-                <div class="text-xs text-gray-500 mb-1" data-i18n="right_hand">Right Hand</div>
+                <div class="text-xs text-gray-500 mb-1" data-i18n="right_hand">{{ t('right_hand') }}</div>
                 <img id="hand-right" src="" alt="Right Hand"
                      class="rounded border border-gray-700 bg-gray-900"
                      style="width:100%;height:95px;object-fit:contain">
@@ -443,12 +443,12 @@
         <span id="episode-list-count" class="text-xs text-gray-500"></span>
         <button id="btn-toggle-select" title="Toggle selection mode"
                 class="bg-gray-800 hover:bg-gray-700 text-gray-400 hover:text-gray-200 text-xs px-2 py-0.5 rounded flex-shrink-0 transition-colors"
-                onclick="toggleSelectMode()">Select</button>
+                onclick="toggleSelectMode()"><span data-i18n="select">{{ t('select') }}</span></button>
         <button id="btn-sort-order" title="Toggle sort order"
                 class="bg-gray-800 hover:bg-gray-700 text-gray-400 hover:text-gray-200 text-xs px-2 py-0.5 rounded flex items-center gap-1 flex-shrink-0 transition-colors"
                 onclick="toggleSortOrder()">
             <iconify-icon id="sort-order-icon" icon="ant-design:ordered-list-outlined" class="icon-sm"></iconify-icon>
-            <span id="sort-order-label">Name 1→N</span>
+            <span id="sort-order-label" data-i18n="name_1_to_n">{{ t('name_1_to_n') }}</span>
         </button>
     </div>
     <!-- Hidden filter controls (programmatic access by nav tree / app.js) -->
@@ -460,7 +460,7 @@
     <div id="select-all-bar" class="px-3 py-1.5 border-b border-gray-800 flex items-center justify-between flex-shrink-0 hidden bg-gray-800/50">
         <label class="flex items-center gap-2 text-xs text-gray-300 cursor-pointer">
             <input type="checkbox" id="select-all-checkbox" onchange="toggleSelectAll(this.checked)" class="w-3.5 h-3.5 rounded accent-blue-600">
-            <span id="select-all-label" data-i18n="select_all">Select All</span>
+            <span id="select-all-label" data-i18n="select_all">{{ t('select_all') }}</span>
             <span id="select-count" class="text-gray-500">(0/0)</span>
         </label>
     </div>
@@ -469,26 +469,26 @@
          两个按钮是两条完全不同的路径:导出数据集要整库重建(约 30 秒/集),
          打包下载是原样 zip(秒级)。文案里直接标出快慢,用户才不会点错。 -->
     <div id="batch-bar" class="px-2 py-2 border-b border-gray-700 flex-shrink-0 hidden bg-gray-800">
-        <div id="batch-count" class="text-xs text-gray-300 mb-1.5">0 selected</div>
+        <div id="batch-count" class="text-xs text-gray-300 mb-1.5" data-i18n="n_selected">{{ t('n_selected') }}</div>
         <div class="flex gap-1.5">
             <button id="batch-export-btn" onclick="batchDownload(this)"
                     class="flex-1 bg-blue-600 hover:bg-blue-500 disabled:opacity-40 disabled:cursor-not-allowed text-white text-xs px-1.5 py-1.5 rounded font-medium whitespace-nowrap">
-                <span id="batch-export-label" data-i18n="batch_export_dataset">Export dataset</span>
+                <span id="batch-export-label" data-i18n="batch_export_dataset">{{ t('batch_export_dataset') }}</span>
             </button>
             <button id="batch-zip-btn" onclick="batchZipDownload(this)"
                     class="flex-1 bg-gray-700 hover:bg-gray-600 disabled:opacity-40 disabled:cursor-not-allowed text-gray-100 text-xs px-1.5 py-1.5 rounded font-medium whitespace-nowrap">
-                <span data-i18n="batch_zip_download">Zip download</span>
+                <span data-i18n="batch_zip_download">{{ t('batch_zip_download') }}</span>
             </button>
             <button id="batch-cancel-btn" onclick="toggleSelectMode()"
                     class="bg-gray-800 hover:bg-gray-700 text-gray-400 hover:text-gray-200 text-xs px-2 py-1.5 rounded font-medium whitespace-nowrap border border-gray-600"
-                    data-i18n="cancel">Cancel</button>
+                    data-i18n="cancel">{{ t('cancel') }}</button>
         </div>
     </div>
 
     <!-- 4. Episode list section (fills available space, independent scroll) -->
     <div id="episode-list-section" class="flex-1 min-h-0 overflow-y-auto hide-scrollbar">
         <div id="episode-list-inline">
-            <div class="p-4 text-center text-gray-500 text-sm" data-i18n="loading">Loading...</div>
+            <div class="p-4 text-center text-gray-500 text-sm" data-i18n="loading">{{ t('loading') }}</div>
         </div>
     </div>
 
@@ -510,23 +510,23 @@
              only Annotation Studio mounts the editing controls. -->
         <div class="px-3 py-2 border-t border-gray-800 flex items-center justify-between flex-shrink-0">
             <div class="flex items-center gap-1.5 text-xs font-medium text-gray-200">
-                <span data-i18n="slice_marker">Slice Markers</span>
+                <span data-i18n="slice_marker">{{ t('slice_marker') }}</span>
                 <span id="anno-count" class="text-[10px] text-gray-500 bg-gray-800 rounded-full px-1.5 py-0.5">0</span>
             </div>
             <div class="flex items-center gap-1">
-                <span class="{{ 'hidden' if page_mode == 'annotation' else '' }} text-[10px] text-gray-500 border border-gray-700 rounded px-1.5 py-0.5" data-i18n="annotation_readonly">只读</span>
+                <span class="{{ 'hidden' if page_mode == 'annotation' else '' }} text-[10px] text-gray-500 border border-gray-700 rounded px-1.5 py-0.5" data-i18n="annotation_readonly">{{ t('annotation_readonly') }}</span>
                 <div class="{{ 'hidden' if page_mode != 'annotation' else '' }} flex items-center gap-1">
                     <button id="btn-ai-annotate" type="button"
                             class="hidden text-[11px] px-2 py-1 rounded border border-cyan-600/60 bg-cyan-900/20 text-cyan-300 hover:bg-cyan-900/40 transition-colors"
-                            title="AI 自动切段并提案标注(模式由工作流 AI Annotation 卡片配置决定)">
+                            data-i18n-title='{{ t('anno_ai_mode_title') }}' title="AI 自动切段并提案标注(模式由工作流 AI Annotation 卡片配置决定)">
                         <iconify-icon icon="ant-design:thunderbolt-outlined" class="icon-sm"></iconify-icon>
-                        <span data-i18n="ai_annotate">AI Annotate</span>
+                        <span data-i18n="ai_annotate">{{ t('ai_annotate') }}</span>
                     </button>
                     <button id="btn-undo-annotation" type="button"
                             class="text-[11px] px-2 py-1 rounded border border-gray-600/70 bg-gray-800/40 text-gray-400 hover:bg-gray-800 transition-colors"
                             title="Undo (Ctrl+Z)">
                         <iconify-icon icon="ant-design:rollback-outlined" class="icon-sm"></iconify-icon>
-                        <span>Undo</span>
+                        <span data-i18n="undo">{{ t('undo') }}</span>
                     </button>
                 </div>
             </div>
@@ -535,8 +535,8 @@
         <div id="episode-detail-annos" class="flex-1 min-h-0 overflow-y-auto hide-scrollbar p-2 space-y-1.5">
             <div class="p-4 text-center text-gray-600 text-xs">
                 <iconify-icon icon="ant-design:scissor-outlined" class="text-lg mb-1"></iconify-icon>
-                <div data-i18n="no_slices">No slices yet</div>
-                <div class="text-[10px] text-gray-700 mt-1" data-i18n="no_slices_hint">Drag the timeline to create a marker range</div>
+                <div data-i18n="no_slices">{{ t('no_slices') }}</div>
+                <div class="text-[10px] text-gray-700 mt-1" data-i18n="no_slices_hint">{{ t('no_slices_hint') }}</div>
             </div>
         </div>
         {% if page_mode == 'annotation' %}
@@ -544,34 +544,34 @@
         <div id="anno-form" class="border-t border-gray-800 p-2 flex-shrink-0">
             <div class="bg-gray-800/90 border border-gray-700 rounded-lg p-2.5 space-y-2 text-xs">
                 <div class="flex items-center justify-between">
-                    <span id="anno-form-title" class="text-gray-200 font-medium" data-i18n="current_slice">Current Slice</span>
+                    <span id="anno-form-title" class="text-gray-200 font-medium" data-i18n="current_slice">{{ t('current_slice') }}</span>
                 </div>
                 <div class="grid grid-cols-2 gap-1.5">
-                    <label class="text-[10px] text-gray-500"><span data-i18n="start_frame">Start Frame</span>
+                    <label class="text-[10px] text-gray-500"><span data-i18n="start_frame">{{ t('start_frame') }}</span>
                         <input id="anno-start-frame-input" type="number" min="0"
                                class="mt-1 w-full bg-gray-900 border border-gray-700 rounded px-2 py-1.5 text-gray-200 font-mono focus:border-red-500 focus:outline-none">
                     </label>
-                    <label class="text-[10px] text-gray-500"><span data-i18n="end_frame">End Frame</span>
+                    <label class="text-[10px] text-gray-500"><span data-i18n="end_frame">{{ t('end_frame') }}</span>
                         <input id="anno-end-frame-input" type="number" min="0"
                                class="mt-1 w-full bg-gray-900 border border-gray-700 rounded px-2 py-1.5 text-gray-200 font-mono focus:border-blue-500 focus:outline-none">
                     </label>
                 </div>
                 <div class="grid grid-cols-2 gap-1.5">
-                    <button id="btn-anno-set-start" type="button" data-i18n="set_start_frame" class="text-[10px] text-red-300 bg-red-900/20 border border-red-800/60 hover:bg-red-900/40 rounded py-1.5">Set Start</button>
-                    <button id="btn-anno-set-end" type="button" data-i18n="set_end_frame" class="text-[10px] text-blue-300 bg-blue-900/20 border border-blue-800/60 hover:bg-blue-900/40 rounded py-1.5">Set End</button>
+                    <button id="btn-anno-set-start" type="button" data-i18n="set_start_frame" class="text-[10px] text-red-300 bg-red-900/20 border border-red-800/60 hover:bg-red-900/40 rounded py-1.5">{{ t('set_start_frame') }}</button>
+                    <button id="btn-anno-set-end" type="button" data-i18n="set_end_frame" class="text-[10px] text-blue-300 bg-blue-900/20 border border-blue-800/60 hover:bg-blue-900/40 rounded py-1.5">{{ t('set_end_frame') }}</button>
                 </div>
                 <input id="anno-label-input"
                        class="bg-gray-900 border border-gray-700 rounded px-2.5 py-2 w-full text-gray-200 text-xs focus:border-blue-500 focus:outline-none"
-                       data-i18n-placeholder="label_name" placeholder="Label name, e.g. pick up cup"
+                       data-i18n-placeholder='{{ t('label_name') }}' placeholder="Label name, e.g. pick up cup"
                        oninput="this.classList.remove('border-red-500');document.getElementById('anno-label-warn').classList.add('hidden')">
                 <div id="anno-label-warn" class="text-red-400 text-xs hidden">
-                    <iconify-icon icon="ant-design:warning-outlined" class="icon-sm"></iconify-icon> <span data-i18n="enter_slice_name">Enter a slice name</span>
+                    <iconify-icon icon="ant-design:warning-outlined" class="icon-sm"></iconify-icon> <span data-i18n="enter_slice_name">{{ t('enter_slice_name') }}</span>
                 </div>
                 <div id="anno-frame-preview" class="bg-gray-900 rounded px-2.5 py-1.5 text-center text-[11px]"></div>
                 <button id="btn-save-annotation" type="button"
                         class="w-full bg-gray-700 text-gray-500 py-2 rounded text-xs cursor-not-allowed font-medium transition-colors" disabled>
                     <iconify-icon icon="ant-design:check-outlined" class="icon-sm"></iconify-icon>
-                    <span data-i18n="add_slice">Add Slice</span>
+                    <span data-i18n="add_slice">{{ t('add_slice') }}</span>
                 </button>
             </div>
         </div>
diff --git a/processor/web/templates/login.html b/processor/web/templates/login.html
index e15d093f90bce4f4c81ae2ffad5189d164ec5ef6..a679051fb71e4c1645c05a24ecb70fdc79212762 100644
--- a/processor/web/templates/login.html
+++ b/processor/web/templates/login.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html>
-<html lang="zh-CN">
+<html lang="{{ current_lang() }}">
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
diff --git a/processor/web/templates/overview.html b/processor/web/templates/overview.html
index ea1cd23d2c1f28ec7b35191d7b1c7da8e8c86a69..eff5688afbf556f88a8550a0c1512a19d358360f 100644
--- a/processor/web/templates/overview.html
+++ b/processor/web/templates/overview.html
@@ -5,11 +5,11 @@
 <div class="flex-1 overflow-y-auto hide-scrollbar p-6">
     <!-- Header -->
     <div class="flex items-center justify-between mb-6">
-        <h2 class="text-lg font-semibold text-gray-200">Overview</h2>
+        <h2 class="text-lg font-semibold text-gray-200" data-i18n="overview_title">{{ t('overview_title') }}</h2>
         <button id="btn-refresh" onclick="refreshDashboard()"
                 class="bg-gray-800 hover:bg-gray-700 text-gray-300 text-xs px-3 py-1.5 rounded flex items-center gap-1.5 transition-colors">
             <iconify-icon icon="ant-design:reload-outlined" class="icon-sm"></iconify-icon>
-            Refresh
+            <span data-i18n="refresh">{{ t('refresh') }}</span>
         </button>
     </div>
 
@@ -26,7 +26,7 @@
         <div class="bg-gray-900 rounded-lg p-4 border border-gray-800 border-b-2 border-b-slate-500">
             <div class="flex items-center gap-2 text-slate-400 text-xs mb-2">
                 <iconify-icon icon="ant-design:database-outlined" class="icon-sm"></iconify-icon>
-                <span>All Episodes</span>
+                <span data-i18n="stat_total">{{ t('stat_total') }}</span>
             </div>
             <div class="text-2xl font-bold text-white" id="stat-total-total">-</div>
             <div class="text-xs text-slate-400 mt-1 hidden" id="stat-total-today"></div>
@@ -35,7 +35,7 @@
         <div class="bg-gray-900 rounded-lg p-4 border border-gray-800 border-b-2 border-b-yellow-500">
             <div class="flex items-center gap-2 text-yellow-400 text-xs mb-2">
                 <iconify-icon icon="ant-design:eye-outlined" class="icon-sm"></iconify-icon>
-                <span>To Review</span>
+                <span data-i18n="stat_to_review">{{ t('stat_to_review') }}</span>
             </div>
             <div class="text-2xl font-bold text-white" id="stat-reviewing-total">-</div>
             <div class="text-xs text-yellow-400 mt-1 hidden" id="stat-reviewing-today"></div>
@@ -44,7 +44,7 @@
         <div class="bg-gray-900 rounded-lg p-4 border border-gray-800 border-b-2 border-b-green-500">
             <div class="flex items-center gap-2 text-green-400 text-xs mb-2">
                 <iconify-icon icon="ant-design:check-circle-outlined" class="icon-sm"></iconify-icon>
-                <span>Approved</span>
+                <span data-i18n="stat_approved">{{ t('stat_approved') }}</span>
             </div>
             <div class="text-2xl font-bold text-white" id="stat-approved-total">-</div>
             <div class="text-xs text-green-400 mt-1 hidden" id="stat-approved-today"></div>
@@ -53,7 +53,7 @@
         <div class="bg-gray-900 rounded-lg p-4 border border-gray-800 border-b-2 border-b-red-500">
             <div class="flex items-center gap-2 text-red-400 text-xs mb-2">
                 <iconify-icon icon="ant-design:warning-outlined" class="icon-sm"></iconify-icon>
-                <span>Failed</span>
+                <span data-i18n="stat_failed">{{ t('stat_failed') }}</span>
             </div>
             <div class="text-2xl font-bold text-white" id="stat-failed-total">-</div>
         </div>
@@ -63,23 +63,23 @@
     <div id="stat-error" class="hidden bg-red-900/30 border border-red-800 rounded-lg p-4 mb-6 flex items-center justify-between">
         <div class="flex items-center gap-2 text-red-300 text-sm">
             <iconify-icon icon="ant-design:warning-outlined" class="icon-sm"></iconify-icon>
-            <span>Failed to load statistics</span>
+            <span data-i18n="load_failed_stats">{{ t('load_failed_stats') }}</span>
         </div>
-        <button onclick="refreshDashboard()" class="bg-red-800 hover:bg-red-700 text-red-200 text-xs px-3 py-1 rounded">Retry</button>
+        <button onclick="refreshDashboard()" class="bg-red-800 hover:bg-red-700 text-red-200 text-xs px-3 py-1 rounded"><span data-i18n="retry">{{ t('retry') }}</span></button>
     </div>
 
     <!-- ===== Row 2: Charts ===== -->
     <div class="grid grid-cols-2 gap-6 mb-6">
         <!-- Donut: Status Distribution -->
         <div class="bg-gray-900 rounded-lg border border-gray-800 p-5">
-            <h3 class="text-sm font-semibold text-gray-300 mb-4">Status Distribution</h3>
+            <h3 class="text-sm font-semibold text-gray-300 mb-4"><span data-i18n="stat_distribution">{{ t('stat_distribution') }}</span></h3>
             <div id="donut-chart" class="flex items-center justify-center">
                 <div class="skeleton w-48 h-48 bg-gray-800 rounded-full"></div>
             </div>
         </div>
         <!-- Bar: Daily Uploads -->
         <div class="bg-gray-900 rounded-lg border border-gray-800 p-5">
-            <h3 class="text-sm font-semibold text-gray-300 mb-4">Daily Uploads <span class="text-xs text-gray-600 font-normal">(last 30 days)</span></h3>
+            <h3 class="text-sm font-semibold text-gray-300 mb-4"><span data-i18n="daily_uploads">{{ t('daily_uploads') }}</span> <span class="text-xs text-gray-600 font-normal" data-i18n="last_30_days">{{ t('last_30_days') }}</span></h3>
             <div id="trend-chart">
                 <div class="flex items-end gap-0.5 h-40 skeleton">
                     <div class="flex-1 bg-gray-800 rounded-t h-full"></div>
@@ -93,8 +93,8 @@
         <!-- Projects -->
         <div class="bg-gray-900 rounded-lg border border-gray-800 p-5">
             <div class="flex items-center justify-between mb-4">
-                <h3 class="text-sm font-semibold text-gray-300">Projects</h3>
-                <a href="/tasks" class="text-xs text-blue-400 hover:text-blue-300">View All →</a>
+                <h3 class="text-sm font-semibold text-gray-300"><span data-i18n="projects_title">{{ t('projects_title') }}</span></h3>
+                <a href="/tasks" class="text-xs text-blue-400 hover:text-blue-300"><span data-i18n="view_all">{{ t('view_all') }}</span> →</a>
             </div>
             <div id="task-progress-list">
                 <div class="space-y-3 skeleton">
@@ -107,7 +107,7 @@
 
         <!-- Recent Episodes -->
         <div class="bg-gray-900 rounded-lg border border-gray-800 p-5">
-            <h3 class="text-sm font-semibold text-gray-300 mb-4">Recent Episodes</h3>
+            <h3 class="text-sm font-semibold text-gray-300 mb-4"><span data-i18n="recent_episodes">{{ t('recent_episodes') }}</span></h3>
             <div id="recent-list">
                 <div class="space-y-3 skeleton">
                     <div class="h-10 bg-gray-800 rounded"></div>
diff --git a/processor/web/templates/tasks.html b/processor/web/templates/tasks.html
index ce42981cdaa45d0626e58d3a83175cd5211a6432..86ea940a731ca2efcaa819db5d46cf93b451b866 100644
--- a/processor/web/templates/tasks.html
+++ b/processor/web/templates/tasks.html
@@ -1,79 +1,79 @@
-{% extends "base.html" %}
-{% block title %}Projects - Data Acquisition{% endblock %}
-
-{% block content %}
-<div class="flex-1 overflow-y-auto hide-scrollbar p-6">
-    <!-- Header -->
-    <div class="flex items-center justify-between mb-6">
-        <h2 class="text-lg font-semibold text-gray-200"><span data-i18n="projects_title">Projects</span></h2>
-        <div class="flex gap-3">
-            <input type="text" id="projects-search" data-i18n-placeholder="search_projects" placeholder="Search projects..." value=""
-                   class="bg-gray-800 text-sm rounded px-3 py-1.5 border border-gray-700 w-48"
-                   oninput="loadProjects()">
-            <button id="btn-new-project" onclick="showProjectForm()"
-                    class="bg-blue-600 hover:bg-blue-500 text-white text-xs px-3 py-1.5 rounded font-medium flex items-center gap-1.5">
-                <iconify-icon icon="ant-design:plus-outlined" class="icon-sm"></iconify-icon>
-                <span data-i18n="new_project">New Project</span>
-            </button>
-        </div>
-    </div>
-
-    <!-- Inline Project Form (hidden by default) -->
-    <div id="project-form" class="hidden mb-4 bg-gray-900 rounded-lg border border-gray-800 p-4 space-y-3">
-        <div class="flex items-center justify-between">
-            <span id="project-form-title" class="text-sm font-medium text-gray-200" data-i18n="new_project">New Project</span>
-            <button onclick="hideProjectForm()" class="text-gray-500 hover:text-gray-300">
-                <iconify-icon icon="ant-design:close-outlined" class="icon-sm"></iconify-icon>
-            </button>
-        </div>
-        <div class="grid grid-cols-2 gap-3 text-xs">
-            <div>
-                <label class="block text-gray-500 mb-1" data-i18n="project_name">Project Name</label>
-                <input id="pf-name" class="bg-gray-800 text-sm rounded px-3 py-1.5 border border-gray-700 w-full focus:border-blue-500 focus:outline-none"
-                       placeholder="e.g. fisheye_project" maxlength="128">
-            </div>
-            <div>
-                <label class="block text-gray-500 mb-1" data-i18n="bind_workflow">Workflows</label>
-                <div class="relative">
-                    <button type="button" id="wf-dropdown-toggle"
-                            class="w-full bg-gray-800 text-sm text-left rounded px-3 py-1.5 border border-gray-700 hover:border-gray-600 focus:border-blue-500 focus:outline-none flex items-center gap-2">
-                        <span id="wf-dropdown-label" class="truncate flex-1 text-gray-400" data-i18n="workflow_placeholder">— Select workflow —</span>
-                        <iconify-icon id="wf-dropdown-arrow" icon="ant-design:down-outlined" class="text-gray-500 icon-sm shrink-0 transition-transform duration-150"></iconify-icon>
-                    </button>
-                    <div id="wf-dropdown-panel" class="hidden absolute z-20 mt-1 w-full bg-gray-900 rounded border border-gray-700 shadow-xl max-h-56 overflow-y-auto"></div>
-                </div>
-            </div>
-            <div>
-                <label class="block text-gray-500 mb-1" data-i18n="status">Status</label>
-                <select id="pf-status" class="bg-gray-800 text-sm rounded px-3 py-1.5 border border-gray-700 w-full focus:border-blue-500 focus:outline-none">
-                    <option value="active">active</option>
-                    <option value="paused">paused</option>
-                </select>
-            </div>
-            <div>
-                <label class="block text-gray-500 mb-1" data-i18n="target_episodes">Target Episodes</label>
-                <input id="pf-target" type="number" min="0"
-                       class="bg-gray-800 text-sm rounded px-3 py-1.5 border border-gray-700 w-full focus:border-blue-500 focus:outline-none"
-                       placeholder="0 = unlimited" title="Planned episode count for this project; collector polls total_required / current_count">
-            </div>
-            <div class="col-span-2">
-                <label class="block text-gray-500 mb-1" data-i18n="task_description">Description</label>
-                <textarea id="pf-description" rows="2"
-                          class="bg-gray-800 text-sm rounded px-3 py-1.5 border border-gray-700 w-full focus:border-blue-500 focus:outline-none"
-                          maxlength="500"></textarea>
-            </div>
-        </div>
-        <div class="flex justify-end gap-2 pt-1">
-            <button onclick="hideProjectForm()" class="bg-gray-800 hover:bg-gray-700 text-gray-300 text-xs px-4 py-1.5 rounded" data-i18n="cancel">Cancel</button>
-            <button onclick="saveProject()" class="bg-blue-600 hover:bg-blue-500 text-white text-xs px-4 py-1.5 rounded font-medium" data-i18n="save">Save</button>
-        </div>
-    </div>
-
-    <!-- Project cards -->
-    <div id="projects-list" class="space-y-3">
-        <div class="text-center text-gray-600 text-sm py-8" data-i18n="loading">Loading...</div>
-    </div>
-</div>
-
+{% extends "base.html" %}
+{% block title %}Projects - Data Acquisition{% endblock %}
+
+{% block content %}
+<div class="flex-1 overflow-y-auto hide-scrollbar p-6">
+    <!-- Header -->
+    <div class="flex items-center justify-between mb-6">
+        <h2 class="text-lg font-semibold text-gray-200"><span data-i18n="projects_title">{{ t('projects_title') }}</span></h2>
+        <div class="flex gap-3">
+            <input type="text" id="projects-search" data-i18n-placeholder='{{ t('search_projects') }}' placeholder="Search projects..." value=""
+                   class="bg-gray-800 text-sm rounded px-3 py-1.5 border border-gray-700 w-48"
+                   oninput="loadProjects()">
+            <button id="btn-new-project" onclick="showProjectForm()"
+                    class="bg-blue-600 hover:bg-blue-500 text-white text-xs px-3 py-1.5 rounded font-medium flex items-center gap-1.5">
+                <iconify-icon icon="ant-design:plus-outlined" class="icon-sm"></iconify-icon>
+                <span data-i18n="new_project">{{ t('new_project') }}</span>
+            </button>
+        </div>
+    </div>
+
+    <!-- Inline Project Form (hidden by default) -->
+    <div id="project-form" class="hidden mb-4 bg-gray-900 rounded-lg border border-gray-800 p-4 space-y-3">
+        <div class="flex items-center justify-between">
+            <span id="project-form-title" class="text-sm font-medium text-gray-200" data-i18n="new_project">{{ t('new_project') }}</span>
+            <button onclick="hideProjectForm()" class="text-gray-500 hover:text-gray-300">
+                <iconify-icon icon="ant-design:close-outlined" class="icon-sm"></iconify-icon>
+            </button>
+        </div>
+        <div class="grid grid-cols-2 gap-3 text-xs">
+            <div>
+                <label class="block text-gray-500 mb-1" data-i18n="project_name">{{ t('project_name') }}</label>
+                <input id="pf-name" class="bg-gray-800 text-sm rounded px-3 py-1.5 border border-gray-700 w-full focus:border-blue-500 focus:outline-none"
+                       placeholder="e.g. fisheye_project" maxlength="128">
+            </div>
+            <div>
+                <label class="block text-gray-500 mb-1" data-i18n="bind_workflow">{{ t('bind_workflow') }}</label>
+                <div class="relative">
+                    <button type="button" id="wf-dropdown-toggle"
+                            class="w-full bg-gray-800 text-sm text-left rounded px-3 py-1.5 border border-gray-700 hover:border-gray-600 focus:border-blue-500 focus:outline-none flex items-center gap-2">
+                        <span id="wf-dropdown-label" class="truncate flex-1 text-gray-400" data-i18n="workflow_placeholder">{{ t('workflow_placeholder') }}</span>
+                        <iconify-icon id="wf-dropdown-arrow" icon="ant-design:down-outlined" class="text-gray-500 icon-sm shrink-0 transition-transform duration-150"></iconify-icon>
+                    </button>
+                    <div id="wf-dropdown-panel" class="hidden absolute z-20 mt-1 w-full bg-gray-900 rounded border border-gray-700 shadow-xl max-h-56 overflow-y-auto"></div>
+                </div>
+            </div>
+            <div>
+                <label class="block text-gray-500 mb-1" data-i18n="status">{{ t('status') }}</label>
+                <select id="pf-status" class="bg-gray-800 text-sm rounded px-3 py-1.5 border border-gray-700 w-full focus:border-blue-500 focus:outline-none">
+                    <option value="active" data-i18n="task_active">{{ t('task_active') }}</option>
+                    <option value="paused" data-i18n="task_paused">{{ t('task_paused') }}</option>
+                </select>
+            </div>
+            <div>
+                <label class="block text-gray-500 mb-1" data-i18n="target_episodes">{{ t('target_episodes') }}</label>
+                <input id="pf-target" type="number" min="0"
+                       class="bg-gray-800 text-sm rounded px-3 py-1.5 border border-gray-700 w-full focus:border-blue-500 focus:outline-none"
+                       placeholder="0 = unlimited" title="Planned episode count for this project; collector polls total_required / current_count">
+            </div>
+            <div class="col-span-2">
+                <label class="block text-gray-500 mb-1" data-i18n="task_description">{{ t('task_description') }}</label>
+                <textarea id="pf-description" rows="2"
+                          class="bg-gray-800 text-sm rounded px-3 py-1.5 border border-gray-700 w-full focus:border-blue-500 focus:outline-none"
+                          maxlength="500"></textarea>
+            </div>
+        </div>
+        <div class="flex justify-end gap-2 pt-1">
+            <button onclick="hideProjectForm()" class="bg-gray-800 hover:bg-gray-700 text-gray-300 text-xs px-4 py-1.5 rounded" data-i18n="cancel">{{ t('cancel') }}</button>
+            <button onclick="saveProject()" class="bg-blue-600 hover:bg-blue-500 text-white text-xs px-4 py-1.5 rounded font-medium" data-i18n="save">{{ t('save') }}</button>
+        </div>
+    </div>
+
+    <!-- Project cards -->
+    <div id="projects-list" class="space-y-3">
+        <div class="text-center text-gray-600 text-sm py-8" data-i18n="loading">{{ t('loading') }}</div>
+    </div>
+</div>
+
 <script src="/static/js/tasks.js?v={{ asset_version }}"></script>
-{% endblock %}
+{% endblock %}
diff --git a/processor/web/templates/train.html b/processor/web/templates/train.html
new file mode 100644
index 0000000000000000000000000000000000000000..480cb1da3109eef21c071078b88c9641b51a9955
--- /dev/null
+++ b/processor/web/templates/train.html
@@ -0,0 +1,17 @@
+{% extends "base.html" %}
+{% block title %}Model Training - Data Acquisition{% endblock %}
+
+{% block content %}
+<div class="flex-1 overflow-y-auto hide-scrollbar px-6 pt-3 pb-6">
+    <!-- 这一页没有大标题,也没有右上角的刷新按钮 —— 页签本身已经说明"你在哪一页",
+         再来一个大标题是重复;而刷新在浏览器里就有(F5 / Ctrl+R),自己做一个是多余的。
+         内容高度直接从顶部开始,不预留空行。 -->
+    <!-- 全部内容由 static/js/train/main.js 渲染。它是这一页唯一的入口;
+         train/ 下其余文件,以及 inference/view.js,都是被它 import 的模块。 -->
+    <div id="train-runs">
+        <div class="text-center text-gray-600 text-sm py-10" data-i18n="loading">{{ t('loading') }}</div>
+    </div>
+</div>
+
+<script type="module" src="/static/js/train/main.js?v={{ asset_version }}"></script>
+{% endblock %}
diff --git a/processor/web/templates/trash.html b/processor/web/templates/trash.html
index 0d964e3bb74618f9d59ae2997a2ea38797198562..ffdfadc14b7bf1827b0f2b6d1cf254f67dfa1fb8 100644
--- a/processor/web/templates/trash.html
+++ b/processor/web/templates/trash.html
@@ -4,31 +4,32 @@
 {% block content %}
 <div class="flex-1 flex flex-col p-6 overflow-auto hide-scrollbar max-w-3xl mx-auto w-full">
     <div class="flex items-center justify-between mb-4">
-        <h2 class="text-lg font-semibold"><iconify-icon icon="ant-design:delete-outlined" class="icon-md"></iconify-icon> <span id="trash-title" data-i18n="trash_title">Trash</span></h2>
+        <h2 class="text-lg font-semibold"><iconify-icon icon="ant-design:delete-outlined" class="icon-md"></iconify-icon> <span id="trash-title" data-i18n="trash_title">{{ t('trash_title') }}</span></h2>
         <button onclick="purgeTrash()"
                 class="bg-red-800 hover:bg-red-700 text-red-200 text-sm px-4 py-1.5 rounded">
-            <iconify-icon icon="ant-design:delete-outlined" class="icon-sm"></iconify-icon> <span id="trash-purge-btn" data-i18n="purge_all">Purge All</span>
+            <iconify-icon icon="ant-design:delete-outlined" class="icon-sm"></iconify-icon> <span id="trash-purge-btn" data-i18n="purge_all">{{ t('purge_all') }}</span>
         </button>
     </div>
     <div id="trash-list" class="space-y-2">
-        <div class="p-4 text-center text-gray-500 text-sm" data-i18n="loading">Loading...</div>
+        <div class="p-4 text-center text-gray-500 text-sm" data-i18n="loading">{{ t('loading') }}</div>
     </div>
 </div>
 
 <script src="/static/js/app.js?v={{ asset_version }}"></script>
 <script>
-// Update template static text when lang changes
-const _origSetLang = setLang;
-setLang = function(lang) {
-    _origSetLang(lang);
-    document.getElementById('nav-review').textContent = t('video_review');
-    document.getElementById('nav-trash').innerHTML = '<iconify-icon icon="ant-design:delete-outlined" class="icon-sm"></iconify-icon> ' + t('trash');
+// 本页只需要维护【页面标题】。
+//
+// ★ 这里原先还手动设 nav-review / nav-trash 的 textContent —— 但 base.html 里
+//   **从来没有这两个 id**（侧边栏的导航文案是 data-i18n 属性、由 i18n.js 翻的），于是
+//   getElementById 返回 null，每次 DOMContentLoaded 都抛
+//       TypeError: Cannot set properties of null (setting 'textContent')
+//   那两个导航文案现在由 i18n.js 的 applyTranslations() 按 data-i18n 处理，
+//   这段手写逻辑纯属多余 —— 删掉，只留标题。
+function _applyTrashTitle() {
     document.title = t('trash_title') + ' - Data Acquisition';
-};
-// Init
-document.addEventListener('DOMContentLoaded', () => {
-    document.getElementById('nav-review').textContent = t('video_review');
-    document.getElementById('nav-trash').innerHTML = '<iconify-icon icon="ant-design:delete-outlined" class="icon-sm"></iconify-icon> ' + t('trash');
-});
+}
+document.addEventListener('DOMContentLoaded', _applyTrashTitle);
+// 切语言时标题也跟着变（i18n.js 的 setLang 会派发这个事件）
+window.addEventListener('egodata:lang', _applyTrashTitle);
 </script>
 {% endblock %}
diff --git a/processor/web/templates/users.html b/processor/web/templates/users.html
index 78bdc42347e9364ab8d12feeb2029d2af01a4f4a..8ce89b90690ce51b6e049b18164330fc9fb1f71b 100644
--- a/processor/web/templates/users.html
+++ b/processor/web/templates/users.html
@@ -5,12 +5,12 @@
 <div class="flex-1 overflow-y-auto hide-scrollbar p-6">
     <div class="flex items-center justify-between mb-6">
         <div>
-            <h2 class="text-lg font-semibold text-gray-200">User management</h2>
-            <p class="text-xs text-gray-500 mt-1">Manage accounts, roles and account lifecycle.</p>
+            <h2 class="text-lg font-semibold text-gray-200"><span data-i18n="users_title">{{ t('users_title') }}</span></h2>
+            <p class="text-xs text-gray-500 mt-1"><span data-i18n="users_subtitle">{{ t('users_subtitle') }}</span></p>
         </div>
         <button onclick="openUserModal()" class="bg-blue-600 hover:bg-blue-500 text-white text-xs px-3 py-1.5 rounded font-medium flex items-center gap-1.5">
             <iconify-icon icon="ant-design:plus-outlined" class="icon-sm"></iconify-icon>
-            New user
+            <span data-i18n="users_new">{{ t('users_new') }}</span>
         </button>
     </div>
 
@@ -18,15 +18,15 @@
 
     <div class="grid grid-cols-3 gap-4 mb-6">
         <div class="bg-gray-900 rounded-lg p-4 border border-gray-800">
-            <div class="text-xs text-gray-500">Total users</div>
+            <div class="text-xs text-gray-500"><span data-i18n="users_total">{{ t('users_total') }}</span></div>
             <div id="count-total" class="text-2xl font-bold text-white mt-1">—</div>
         </div>
         <div class="bg-gray-900 rounded-lg p-4 border border-gray-800">
-            <div class="text-xs text-gray-500">Active users</div>
+            <div class="text-xs text-gray-500"><span data-i18n="users_active">{{ t('users_active') }}</span></div>
             <div id="count-active" class="text-2xl font-bold text-green-400 mt-1">—</div>
         </div>
         <div class="bg-gray-900 rounded-lg p-4 border border-gray-800">
-            <div class="text-xs text-gray-500">Disabled / expired</div>
+            <div class="text-xs text-gray-500"><span data-i18n="users_disabled_expired">{{ t('users_disabled_expired') }}</span></div>
             <div id="count-inactive" class="text-2xl font-bold text-yellow-400 mt-1">—</div>
         </div>
     </div>
@@ -36,15 +36,15 @@
             <input id="user-search" oninput="renderUsers()" placeholder="Search username or email..."
                    class="bg-gray-800 text-sm rounded px-3 py-1.5 border border-gray-700 w-64 focus:border-blue-500 focus:outline-none">
             <select id="user-role-filter" onchange="loadUsers()" class="bg-gray-800 text-sm rounded px-3 py-1.5 border border-gray-700 focus:border-blue-500 focus:outline-none">
-                <option value="">All roles</option>
-                <option value="admin">Admin</option>
-                <option value="engineer">Engineer</option>
-                <option value="reviewer">Reviewer</option>
+                <option value="" data-i18n="users_all_roles">{{ t('users_all_roles') }}</option>
+                <option value="admin" data-i18n="role_admin">{{ t('role_admin') }}</option>
+                <option value="engineer" data-i18n="role_engineer">{{ t('role_engineer') }}</option>
+                <option value="reviewer" data-i18n="role_reviewer">{{ t('role_reviewer') }}</option>
             </select>
             <select id="user-status-filter" onchange="loadUsers()" class="bg-gray-800 text-sm rounded px-3 py-1.5 border border-gray-700 focus:border-blue-500 focus:outline-none">
-                <option value="">All status</option>
-                <option value="active">Active</option>
-                <option value="disabled">Disabled</option>
+                <option value="" data-i18n="users_all_status">{{ t('users_all_status') }}</option>
+                <option value="active" data-i18n="status_active">{{ t('status_active') }}</option>
+                <option value="disabled" data-i18n="status_disabled">{{ t('status_disabled') }}</option>
             </select>
             <span id="user-list-count" class="text-xs text-gray-600 ml-auto"></span>
         </div>
@@ -52,32 +52,32 @@
             <table class="w-full text-sm" style="min-width: 900px">
                 <thead class="text-xs text-gray-500 bg-gray-950/40">
                     <tr>
-                        <th class="text-left font-medium px-4 py-3">User</th>
-                        <th class="text-left font-medium px-4 py-3">Role</th>
-                        <th class="text-left font-medium px-4 py-3">Status</th>
-                        <th class="text-left font-medium px-4 py-3">Last login</th>
-                        <th class="text-left font-medium px-4 py-3">Expires</th>
-                        <th class="text-right font-medium px-4 py-3">Actions</th>
+                        <th class="text-left font-medium px-4 py-3"><span data-i18n="col_user">{{ t('col_user') }}</span></th>
+                        <th class="text-left font-medium px-4 py-3"><span data-i18n="col_role">{{ t('col_role') }}</span></th>
+                        <th class="text-left font-medium px-4 py-3"><span data-i18n="col_status">{{ t('col_status') }}</span></th>
+                        <th class="text-left font-medium px-4 py-3"><span data-i18n="col_last_login">{{ t('col_last_login') }}</span></th>
+                        <th class="text-left font-medium px-4 py-3"><span data-i18n="col_expires">{{ t('col_expires') }}</span></th>
+                        <th class="text-right font-medium px-4 py-3"><span data-i18n="col_actions">{{ t('col_actions') }}</span></th>
                     </tr>
                 </thead>
                 <tbody id="users-body">
-                    <tr><td colspan="6" class="px-4 py-10 text-center text-gray-600">Loading...</td></tr>
+                    <tr><td colspan="6" class="px-4 py-10 text-center text-gray-600" data-i18n="loading">{{ t('loading') }}</td></tr>
                 </tbody>
             </table>
         </div>
     </div>
 
     <div class="mt-3 text-xs text-gray-600">
-        <span class="text-yellow-500">Disable</span> blocks login temporarily and keeps the account/data; it can be enabled later.
-        <span class="ml-3 text-red-400">Delete</span> permanently removes the account.
+        <span class="text-yellow-500" data-i18n="users_disable">{{ t('users_disable') }}</span> <span data-i18n="users_disable_warning">{{ t('users_disable_warning') }}</span>
+        <span class="ml-3 text-red-400" data-i18n="users_delete">{{ t('users_delete') }}</span> <span data-i18n="users_delete_warning">{{ t('users_delete_warning') }}</span>
     </div>
 
     <div class="mt-6 bg-gray-900 rounded-lg border border-gray-800 p-4">
-        <h3 class="text-sm font-semibold text-gray-300 mb-3">Role permissions</h3>
+        <h3 class="text-sm font-semibold text-gray-300 mb-3"><span data-i18n="users_role_perms">{{ t('users_role_perms') }}</span></h3>
         <div class="grid grid-cols-3 gap-4 text-xs">
-            <div><div class="text-blue-400 font-medium mb-1">Admin</div><div class="text-gray-500">Users, projects, workflows, processing, review and system settings</div></div>
-            <div><div class="text-purple-400 font-medium mb-1">Engineer</div><div class="text-gray-500">Projects, workflows, processing and review</div></div>
-            <div><div class="text-green-400 font-medium mb-1">Reviewer</div><div class="text-gray-500">View data, video review and annotation review</div></div>
+            <div><div class="text-blue-400 font-medium mb-1">Admin</div><div class="text-gray-500"><span data-i18n="users_perm_admin">{{ t('users_perm_admin') }}</span></div></div>
+            <div><div class="text-purple-400 font-medium mb-1">Engineer</div><div class="text-gray-500"><span data-i18n="users_perm_engineer">{{ t('users_perm_engineer') }}</span></div></div>
+            <div><div class="text-green-400 font-medium mb-1">Reviewer</div><div class="text-gray-500"><span data-i18n="users_perm_reviewer">{{ t('users_perm_reviewer') }}</span></div></div>
         </div>
     </div>
 </div>
@@ -85,7 +85,7 @@
 <div id="user-modal" class="hidden fixed inset-0 z-50 bg-black/60 flex items-center justify-center p-4">
     <div class="w-full max-w-lg bg-gray-900 border border-gray-700 rounded-lg shadow-2xl">
         <div class="flex items-center justify-between px-5 py-4 border-b border-gray-800">
-            <h3 id="user-modal-title" class="text-sm font-semibold text-gray-200">New user</h3>
+            <h3 id="user-modal-title" class="text-sm font-semibold text-gray-200"><span data-i18n="users_new">{{ t('users_new') }}</span></h3>
             <button onclick="closeUserModal()" class="text-gray-500 hover:text-gray-200"><iconify-icon icon="ant-design:close-outlined"></iconify-icon></button>
         </div>
         <form id="user-form" onsubmit="saveUser(event)" class="p-5 space-y-4 text-xs">
@@ -105,7 +105,7 @@
             <label class="block text-gray-500">Email
                 <input id="user-email" type="email" maxlength="128" class="mt-1 w-full bg-gray-800 text-sm rounded px-3 py-2 border border-gray-700 focus:border-blue-500 focus:outline-none">
             </label>
-            <label class="block text-gray-500">Password <span id="password-hint" class="text-gray-600">(at least 6 characters)</span>
+            <label class="block text-gray-500"><span data-i18n="field_password">{{ t('field_password') }}</span> <span id="password-hint" class="text-gray-600">(at least 6 characters)</span>
                 <input id="user-password" type="password" minlength="6" maxlength="128" class="mt-1 w-full bg-gray-800 text-sm rounded px-3 py-2 border border-gray-700 focus:border-blue-500 focus:outline-none">
             </label>
             <div class="grid grid-cols-2 gap-3">
@@ -115,13 +115,13 @@
                         <option value="disabled">Disabled</option>
                     </select>
                 </label>
-                <label class="block text-gray-500">Expires at <span class="text-gray-600">(optional)</span>
+                <label class="block text-gray-500"><span data-i18n="field_expires_at">{{ t('field_expires_at') }}</span> <span class="text-gray-600" data-i18n="users_optional">{{ t('users_optional') }}</span>
                     <input id="user-expires" type="datetime-local" class="mt-1 w-full bg-gray-800 text-sm rounded px-3 py-2 border border-gray-700 focus:border-blue-500 focus:outline-none">
                 </label>
             </div>
             <div class="flex justify-end gap-2 pt-2">
-                <button type="button" onclick="closeUserModal()" class="bg-gray-800 hover:bg-gray-700 text-gray-300 text-xs px-4 py-2 rounded">Cancel</button>
-                <button id="user-save-btn" type="submit" class="bg-blue-600 hover:bg-blue-500 text-white text-xs px-4 py-2 rounded font-medium">Create user</button>
+                <button type="button" onclick="closeUserModal()" class="bg-gray-800 hover:bg-gray-700 text-gray-300 text-xs px-4 py-2 rounded"><span data-i18n="cancel">{{ t('cancel') }}</span></button>
+                <button id="user-save-btn" type="submit" class="bg-blue-600 hover:bg-blue-500 text-white text-xs px-4 py-2 rounded font-medium"><span data-i18n="users_create">{{ t('users_create') }}</span></button>
             </div>
         </form>
     </div>
diff --git a/processor/web/workflow-studio/package-lock.json b/processor/web/workflow-studio/package-lock.json
index 67f4e1187f5f646d42303c45e7a008f9a76d9c52..833316c0bc09cdc4d2716ad81c909f81ebbe0f1b 100644
--- a/processor/web/workflow-studio/package-lock.json
+++ b/processor/web/workflow-studio/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "egodata-workflow-studio",
-  "version": "1.5.6",
+  "version": "1.8.5",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "egodata-workflow-studio",
-      "version": "1.5.6",
+      "version": "1.8.5",
       "dependencies": {
         "@xyflow/react": "^12.6.0",
         "react": "^19.0.0",
diff --git a/processor/web/workflow-studio/package.json b/processor/web/workflow-studio/package.json
index 57f57468f398930f6a01980be4f47ffbdb47a3a7..63c3b76d91e7c871c84f57d0621cf4a41f4fbd61 100644
--- a/processor/web/workflow-studio/package.json
+++ b/processor/web/workflow-studio/package.json
@@ -1,7 +1,7 @@
 {
   "name": "egodata-workflow-studio",
   "private": true,
-  "version": "1.6.0",
+  "version": "1.8.5",
   "type": "module",
   "scripts": {
     "dev": "vite",
diff --git a/processor/web/workflow-studio/src/App.tsx b/processor/web/workflow-studio/src/App.tsx
index 415a89adb6e2fd64c68233a704e21fcf9b325b88..aacd0e6c2c9980da1298d3c8ec28db759eacf7d2 100644
--- a/processor/web/workflow-studio/src/App.tsx
+++ b/processor/web/workflow-studio/src/App.tsx
@@ -9,6 +9,7 @@ import { ToastContainer, GlobalDialog } from './components/ui/AppDialogs';
 import { deleteWorkflow, getWorkflow, getWorkflowUsage, listModules, updateWorkflow } from './api/workflows';
 import { getCurrentUser } from './api/auth';
 import { hydrateNodeTypes } from './components/WorkflowCanvas/nodes/registry';
+import { useT } from './i18n';
 import type { WorkflowListItem } from './types/workflow';
 
 /**
@@ -55,6 +56,8 @@ function graphsMatch(left: any, right: any) {
 }
 
 export default function App() {
+  const t = useT();
+
   useEffect(() => {
     listModules().then((items) => hydrateNodeTypes(items as any)).catch(() => {
       // The built-in registry remains available when the API is offline.
@@ -200,6 +203,7 @@ interface ConfirmDialogState {
 }
 
 function WorkflowToolbar() {
+  const t = useT();
   const { workflowName, workflowId, isDirty, isSaving, workflows, userRole, isPresetWorkflow, saveWorkflowSafe, saveWorkflowAs, loadWorkflow, loadWorkflowList } =
     useWorkflowStore();
   const [editingName, setEditingName] = useState(false);
@@ -499,7 +503,7 @@ function WorkflowToolbar() {
         onClick={() => loadWorkflowList()}
         className="bg-transparent border border-gray-700 rounded px-1.5 py-0.5 text-xs font-semibold text-gray-200 focus:outline-none focus:border-blue-500 cursor-pointer max-w-[200px]"
       >
-        {!workflowId && <option value="" disabled hidden>New Workflow</option>}
+        {!workflowId && <option value="" disabled hidden>{t('app.newWorkflow')}</option>}
         {workflows.map((w) => (
           <option key={w.id} value={w.id} className="bg-gray-800 text-gray-200">{w.name}{w.is_preset ? ' (Template)' : ''}</option>
         ))}
@@ -524,7 +528,7 @@ function WorkflowToolbar() {
           }}
           title="Click to rename workflow"
           className="text-xs font-semibold text-gray-200 hover:text-blue-400 hover:underline cursor-pointer whitespace-nowrap">
-          {workflowName} {isPresetWorkflow && <span className="text-[9px] text-yellow-400 border border-yellow-700 rounded px-1 ml-1 align-middle">Template</span>}
+          {workflowName} {isPresetWorkflow && <span className="text-[9px] text-yellow-400 border border-yellow-700 rounded px-1 ml-1 align-middle">{t('app.template')}</span>}
           {!presetReadOnly && <span className="text-[10px] text-gray-500 ml-1">✎</span>}
         </span>
       )}
@@ -534,14 +538,14 @@ function WorkflowToolbar() {
         onClick={() => { loadWorkflowList(); openTemplateDialog(); }}
         title="Start a new workflow from a template (processing chain) or a blank canvas"
         className="text-[11px] text-blue-400 hover:text-blue-300 hover:bg-blue-900/30 border border-blue-900/60 px-1.5 py-0.5 rounded">
-        <IconifyIcon icon="ant-design:project-outlined" className="text-[12px] align-[-2px] mr-0.5" /> Template
+        <IconifyIcon icon="ant-design:project-outlined" className="text-[12px] align-[-2px] mr-0.5" />{' '}{t('app.template')}
       </button>
       {isAdmin && workflowId && (
         <button onClick={togglePreset} className="text-[11px] text-yellow-400 hover:text-yellow-300 hover:bg-yellow-900/30 px-1.5 py-0.5 rounded">
-          {isPresetWorkflow ? 'Unset Template' : 'Make Template'}
+          {isPresetWorkflow ? t('app.unsetTemplate') : t('app.makeTemplate')}
         </button>
       )}
-      <button onClick={saveSafe} disabled={isSaving} className="text-[11px] bg-blue-600 hover:bg-blue-500 text-white px-2 py-0.5 rounded disabled:opacity-50">{isSaving ? '...' : 'Save'}</button>
+      <button onClick={saveSafe} disabled={isSaving} className="text-[11px] bg-blue-600 hover:bg-blue-500 text-white px-2 py-0.5 rounded disabled:opacity-50">{isSaving ? '...' : t('app.save')}</button>
       {workflowId && !presetReadOnly && (
         <button onClick={() => setConfirmDialog({
           title: 'Delete this workflow?',
@@ -556,7 +560,7 @@ function WorkflowToolbar() {
             else useWorkflowStore.getState().newWorkflow();
             syncUrl();
           },
-        })} className="text-[11px] text-red-400 hover:text-red-300 hover:bg-red-900/30 px-1.5 py-0.5 rounded">Del</button>
+        })} className="text-[11px] text-red-400 hover:text-red-300 hover:bg-red-900/30 px-1.5 py-0.5 rounded">{t('app.del')}</button>
       )}
       {confirmDialog && (
         <div className="fixed inset-0 z-[100] flex items-center justify-center bg-black/60 p-4" role="presentation">
@@ -571,7 +575,7 @@ function WorkflowToolbar() {
               </div>
             </div>
             <div className="flex justify-end gap-2 px-4 py-3">
-              <button type="button" disabled={dialogBusy} onClick={() => setConfirmDialog(null)} className="rounded border border-gray-700 px-3 py-1.5 text-xs text-gray-300 hover:bg-gray-800 disabled:opacity-50">Cancel</button>
+              <button type="button" disabled={dialogBusy} onClick={() => setConfirmDialog(null)} className="rounded border border-gray-700 px-3 py-1.5 text-xs text-gray-300 hover:bg-gray-800 disabled:opacity-50">{t('app.cancel')}</button>
               {confirmDialog.secondaryLabel && (
                 <button type="button" disabled={dialogBusy} onClick={confirmDialogSecondary}
                         className="rounded border border-gray-700 px-3 py-1.5 text-xs text-gray-300 hover:bg-gray-800 disabled:opacity-50">
@@ -589,7 +593,7 @@ function WorkflowToolbar() {
         <div className="fixed inset-0 z-[100] flex items-center justify-center bg-black/60 p-4" role="presentation">
           <div className="w-full max-w-sm rounded-lg border border-gray-700 bg-gray-900 shadow-2xl" role="dialog" aria-modal="true" aria-labelledby="template-dialog-title">
             <div className="border-b border-gray-800 px-4 py-3">
-              <h2 id="template-dialog-title" className="text-sm font-semibold text-gray-100">Start from Template</h2>
+              <h2 id="template-dialog-title" className="text-sm font-semibold text-gray-100">{t('app.startFromTemplate')}</h2>
               <p className="mt-1 text-xs leading-5 text-gray-400">
                 Templates contain the processing chain only — input device cards appear as your
                 collectors report data. Applying a template replaces the current canvas.
@@ -609,15 +613,15 @@ function WorkflowToolbar() {
                 </button>
               ))}
               {!workflows.some((w) => w.is_preset) && (
-                <div className="text-[11px] text-gray-600 px-1 pt-1">No templates available — an admin can mark workflows as templates.</div>
+                <div className="text-[11px] text-gray-600 px-1 pt-1">{t('app.noTemplates')}</div>
               )}
               <div className="text-[10px] text-gray-600 pt-1">
-                Applying a template replaces the current canvas — your workflow name and ID stay the same.
+                {t('app.templateHint')}
               </div>
             </div>
             <div className="flex justify-end gap-2 px-4 py-3">
               <button type="button" disabled={templateBusy} onClick={() => setTemplateDialog(false)}
-                className="rounded border border-gray-700 px-3 py-1.5 text-xs text-gray-300 hover:bg-gray-800 disabled:opacity-50">Cancel</button>
+                className="rounded border border-gray-700 px-3 py-1.5 text-xs text-gray-300 hover:bg-gray-800 disabled:opacity-50">{t('app.cancel')}</button>
             </div>
           </div>
         </div>
diff --git a/processor/web/workflow-studio/src/api/quality.ts b/processor/web/workflow-studio/src/api/quality.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a320e513ec192b9b2eb5208e18ec35745fefa75a
--- /dev/null
+++ b/processor/web/workflow-studio/src/api/quality.ts
@@ -0,0 +1,78 @@
+/** 数据质检 API —— 检查项目录与报告。
+ *
+ * 检查项目录是设置面板的**唯一数据源**：面板不硬编码任何检查项，
+ * 全靠它渲染 tab、开关和阈值输入框。后端新增检查项前端零改动。
+ */
+import { req } from './workflows';
+
+const BASE = '/api/v1/quality';
+
+/** 单个检查项的目录条目 —— 对应后端 all_check_specs() 的一项。 */
+export interface CheckSpec {
+  slug: string;
+  category: string;
+  label: string;
+  version: string;
+  description: string;
+  requires_channels: string[];
+  requires_modality: string[];
+  cross_modal: boolean;
+  /** 属于哪些设备卡片 —— 设置面板按它分 tab */
+  device_cards: string[];
+  default_severity: string;
+  /** 阈值默认值；面板按它动态生成输入框 */
+  default_params: Record<string, number | string | boolean>;
+}
+
+export interface CheckCatalog {
+  ruleset_revision: string;
+  checks: CheckSpec[];
+  /** 设备卡片 → 该卡片下的检查项 slug 列表 */
+  by_device: Record<string, string[]>;
+  device_labels: Record<string, string>;
+  device_channels: Record<string, string[]>;
+  severity_labels: Record<string, string>;
+  total: number;
+}
+
+/** 一个检查项的节点配置 —— 存进 node.data.config.devices[卡片].checks[slug] */
+export interface CheckConfig {
+  enabled?: boolean;
+  params?: Record<string, number>;
+}
+
+/** 一张设备卡片的配置 */
+export interface DeviceConfig {
+  checks?: Record<string, CheckConfig>;
+}
+
+/** data_quality 节点的完整配置结构 */
+export interface QualityNodeConfig {
+  devices?: Record<string, DeviceConfig>;
+}
+
+export function getCheckCatalog(): Promise<CheckCatalog> {
+  return req<CheckCatalog>(`${BASE}/checks`);
+}
+
+export function listQualityReports(project?: string, status?: string) {
+  const p = new URLSearchParams();
+  if (project) p.set('project', project);
+  if (status) p.set('status', status);
+  return req<{ reports: unknown[]; total: number; counts: Record<string, number> }>(
+    `${BASE}/summary?${p.toString()}`,
+  );
+}
+
+export function getQualityReport(episodeId: string) {
+  return req<Record<string, unknown>>(
+    `${BASE}/episodes/${encodeURIComponent(episodeId)}`,
+  );
+}
+
+export function runQualityChecks(episodeId: string, probeVideo = false) {
+  return req<Record<string, unknown>>(
+    `${BASE}/episodes/${encodeURIComponent(episodeId)}/run?probe_video=${probeVideo}`,
+    { method: 'POST' },
+  );
+}
diff --git a/processor/web/workflow-studio/src/components/WorkflowCanvas/DeviceQualityModal.tsx b/processor/web/workflow-studio/src/components/WorkflowCanvas/DeviceQualityModal.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..f12bd1857cf45e8df1d0bf296a264df41d8387a0
--- /dev/null
+++ b/processor/web/workflow-studio/src/components/WorkflowCanvas/DeviceQualityModal.tsx
@@ -0,0 +1,342 @@
+/** 数据质检设置面板 —— 按设备卡片分 tab，每张卡片独立配置检查项与阈值。
+ *
+ * 为什么不用通用的 `NodeSettingsModal`（它渲染 `config_schema`）：
+ * 那套是平铺字段列表，表达不了"按设备分组 + 每项带参数"的嵌套结构。
+ * AI Annotation 也是同样的理由走了专用弹窗。
+ *
+ * 数据来源全是后端的 `GET /api/v1/quality/checks` —— 前端不硬编码任何检查项，
+ * 后端加一项这里就自动多一行。tab 只显示【工作流里实际连接的】设备卡片。
+ */
+import { useEffect, useMemo, useState } from 'react';
+import { useLang, useT, type Lang } from '../../i18n';
+import { createPortal } from 'react-dom';
+import type { Edge, Node } from '@xyflow/react';
+import { useWorkflowStore } from '../../store/workflowStore';
+import type { WorkflowNodeData } from '../../types/workflow';
+import {
+  getCheckCatalog,
+  type CheckCatalog,
+  type CheckSpec,
+  type QualityNodeConfig,
+} from '../../api/quality';
+
+interface Props {
+  nodeId: string;
+  onClose: () => void;
+}
+
+/** 参数名 → 显示用的标签与单位。后端只给 name，展示层补充。 */
+// zh 缺省时回落到英文 —— 新加参数忘了翻译只会显示英文，不会显示成空白。
+const PARAM_META: Record<string, { label: string; zh?: string; unit?: string; step?: number }> = {
+  tolerance_ratio: { label: 'Tolerance ratio', zh: '容差比例', step: 0.001 },
+  tolerance_min: { label: 'Tolerance floor', zh: '容差下限', unit: 'frames' },
+  min_sec: { label: 'Min duration', zh: '最短时长', unit: 's', step: 0.1 },
+  fail_sec: { label: 'Fail duration', zh: '判失败时长', unit: 's', step: 0.5 },
+  fail_ratio: { label: 'Fail ratio', zh: '失败占比阈值', step: 0.01 },
+  max_errors: { label: 'Allowed error frames', zh: '允许错误帧数' },
+  max_linear_mps: { label: 'Max linear speed', zh: '线速度上限', unit: 'm/s', step: 0.1 },
+  max_angular_rps: { label: 'Max angular speed', zh: '角速度上限', unit: 'rad/s', step: 1 },
+  warn_jumps: { label: 'Warn jump count', zh: '警告跳变数', unit: 'jumps' },
+  fail_jumps: { label: 'Fail jump count', zh: '失败跳变数', unit: 'jumps' },
+  warn_ratio: { label: 'Warn ratio', zh: '警告占比', step: 0.01 },
+  fail_ratio_ratio: { label: 'Fail ratio', zh: '失败占比', step: 0.01 },
+  max_out_of_range_ratio: { label: 'Max out-of-range ratio', zh: '越界占比上限', step: 0.01 },
+  max_force_drift: { label: 'Force drift limit', zh: '力漂移阈值', unit: 'mN', step: 10 },
+  min_coverage: { label: 'Min coverage', zh: '覆盖率下限', step: 0.01 },
+  zero_epsilon: { label: 'Zero epsilon', zh: '零判定容差' },
+  tolerance: { label: 'Tolerance', zh: '容差', unit: 'frames' },
+  // 手套 —— 阵列是 16×16，门限与帧数阈值都来自实测（见 checks/glove/ 各文件）
+  expected_size: { label: 'Array width', zh: '阵列维度' },
+  max_bad_ratio: { label: 'Max malformed ratio', zh: '不合格帧占比', step: 0.01 },
+  min_contact_value: { label: 'Contact floor', zh: '接触门限', step: 50 },
+  warn_frames: { label: 'Warn frozen frames', zh: '警告静止帧数', unit: 'frames', step: 10 },
+  fail_frames: { label: 'Fail frozen frames', zh: '失败静止帧数', unit: 'frames', step: 50 },
+  min_active_ratio: { label: 'Min active ratio', zh: '最低活跃占比', step: 0.01 },
+};
+
+/** 单位的中文对照。没有条目的原样显示（mN / rad/s 这类本来就是符号）。 */
+const UNIT_ZH: Record<string, string> = { frames: '帧', s: '秒', jumps: '处' };
+
+function paramMeta(name: string, lang: Lang) {
+  const meta = PARAM_META[name];
+  // 回落分支也要把 unit/step 显式写出来：否则返回的是 `{label}` 这个窄类型，
+  // 与有 unit/step 的分支构成联合后，调用处访问 meta.unit 会被 tsc 判为不存在。
+  if (!meta) return { label: name, unit: undefined, step: undefined };
+  return {
+    ...meta,
+    label: lang === 'zh' ? (meta.zh ?? meta.label) : meta.label,
+    unit: meta.unit && lang === 'zh' ? (UNIT_ZH[meta.unit] ?? meta.unit) : meta.unit,
+  };
+}
+
+/** 从连线反推这张节点上游连了哪些设备卡片。 */
+function connectedDevices(
+  nodeId: string, nodes: Node<WorkflowNodeData>[], edges: Edge[],
+): string[] {
+  const byId = new Map(nodes.map((n) => [n.id, n]));
+  const seen = new Set<string>();
+  const found: string[] = [];
+  const queue = edges.filter((e) => e.target === nodeId).map((e) => e.source);
+  while (queue.length) {
+    const id = queue.shift() as string;
+    if (!id || seen.has(id)) continue;
+    seen.add(id);
+    const node = byId.get(id);
+    if (!node) continue;
+    const type = String(node.data?.nodeType ?? '');
+    // 相机/手套/夹爪三类是"设备卡片"，其余（处理节点）继续往回找
+    if (['mono_camera', 'stereo_camera', 'rgb_camera', 'rgbd_camera',
+         'stereo_rgbd_camera', 'glove_sensor', 'gripper_device',
+         'fisheye_camera'].includes(type)) {
+      found.push(type);
+      continue;
+    }
+    for (const edge of edges) if (edge.target === id) queue.push(edge.source);
+  }
+  return found;
+}
+
+/** 前端设备卡片 slug（camera 后缀）→ 后端设备模态（rgb 后缀）。 */
+const DEVICE_ALIAS: Record<string, string> = {
+  mono_camera: 'mono_rgb',
+  stereo_camera: 'stereo_rgb',
+  rgb_camera: 'mono_rgb',
+  fisheye_camera: 'mono_rgb',
+};
+
+export function DeviceQualityModal({ nodeId, onClose }: Props) {
+  const t = useT();
+  const lang = useLang();
+  const nodes = useWorkflowStore((s) => s.nodes);
+  const edges = useWorkflowStore((s) => s.edges);
+  const node = nodes.find((n) => n.id === nodeId);
+
+  const [catalog, setCatalog] = useState<CheckCatalog | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const [draft, setDraft] = useState<QualityNodeConfig>(
+    () => ((node?.data?.config as QualityNodeConfig) ?? {}),
+  );
+  const [active, setActive] = useState<string>('');
+
+  // 只显示**画布上连到本节点**的设备卡片。
+  //
+  // 未连接的设备不出现在这里 —— 一个工作流只处理它接的那几类设备，把别的摆出来
+  // 只是噪音。
+  const devices = useMemo(() => {
+    const raw = connectedDevices(nodeId, nodes, edges);
+    const mapped = raw.map((t) => DEVICE_ALIAS[t] ?? t);
+    return Array.from(new Set(mapped));
+  }, [nodeId, nodes, edges]);
+
+  useEffect(() => {
+    getCheckCatalog()
+      .then((data) => {
+        setCatalog(data);
+        // 默认选中第一个"有检查项"的设备卡片
+        const first = devices.find((d) => (data.by_device[d] ?? []).length);
+        setActive((prev) => prev || first || devices[0] || '');
+      })
+      .catch((err) => setError(String(err?.message ?? err)));
+  }, [devices]);
+
+  // Esc 关闭。
+  //
+  // 必须用**捕获阶段** + stopPropagation：React Flow 自己也听 Esc（取消连线、
+  // 清空选择）。若在冒泡阶段挂，按一下会「既关弹窗、又顺手清掉画布选择」。
+  // window 是捕获路径的第一个节点，在这里拦下，画布收不到。
+  useEffect(() => {
+    const onKey = (e: KeyboardEvent) => {
+      if (e.key !== 'Escape') return;
+      e.stopPropagation();
+      e.preventDefault();
+      onClose();
+    };
+    window.addEventListener('keydown', onKey, true);
+    return () => window.removeEventListener('keydown', onKey, true);
+  }, [onClose]);
+
+  const checksOf = (device: string): CheckSpec[] => {
+    if (!catalog) return [];
+    const slugs = catalog.by_device[device] ?? [];
+    return catalog.checks.filter((c) => slugs.includes(c.slug));
+  };
+
+  const entryOf = (device: string, slug: string) =>
+    draft.devices?.[device]?.checks?.[slug] ?? {};
+
+  const setEntry = (device: string, slug: string, patch: Record<string, unknown>) => {
+    setDraft((prev) => ({
+      devices: {
+        ...(prev.devices ?? {}),
+        [device]: {
+          ...(prev.devices?.[device] ?? {}),
+          checks: {
+            ...(prev.devices?.[device]?.checks ?? {}),
+            [slug]: { ...entryOf(device, slug), ...patch },
+          },
+        },
+      },
+    }));
+  };
+
+  const save = () => {
+    useWorkflowStore.setState((state) => ({
+      nodes: state.nodes.map((n) =>
+        n.id === nodeId
+          ? { ...n, data: { ...n.data, config: { ...n.data.config, ...draft } } }
+          : n,
+      ),
+    }));
+    onClose();
+  };
+
+  const byCategory = (checks: CheckSpec[]) => {
+    const groups: Record<string, CheckSpec[]> = {};
+    for (const c of checks) (groups[c.category] ??= []).push(c);
+    return groups;
+  };
+
+  // ★ 必须走 portal 挂到 document.body。
+  //
+  // React Flow 的 viewport 带 ``transform: translate(...) scale(...)``，而 CSS
+  // 规范规定 transform 会为后代创建新的**包含块** —— 于是 position:fixed 是相对
+  // 那块被缩放平移过的画布定位的：弹窗跟着画布跑、跟着缩放变形、半透明背景也
+  // 只盖住画布区域而不是整个屏幕。挂到 body 才脱离这个容器。
+  return createPortal(
+    <div className="modal-portal flex items-center justify-center bg-black/60"
+         onClick={onClose}>
+      <div className="w-[min(880px,92vw)] max-h-[85vh] overflow-hidden rounded-lg border border-gray-700
+                      bg-[#0f172a] text-gray-200 shadow-2xl flex flex-col"
+           onClick={(e) => e.stopPropagation()}>
+
+        <div className="flex items-center justify-between border-b border-gray-700 px-4 py-2">
+          <span className="text-sm font-medium">{t('quality.title')}</span>
+          <button onClick={onClose} className="text-gray-400 hover:text-gray-200">✕</button>
+        </div>
+
+        {/* 设备 tab 栏 —— 只显示工作流里实际连接的卡片 */}
+        <div className="flex gap-1 border-b border-gray-700 px-3 pt-2">
+          {devices.length === 0 && (
+            <span className="px-2 py-1 text-xs text-gray-500">
+              {t('quality.noDevice')}
+            </span>
+          )}
+          {devices.map((device) => {
+            const count = checksOf(device).length;
+            const isActive = device === active;
+            return (
+              <button
+                key={device}
+                onClick={() => setActive(device)}
+                className={`rounded-t border-b-2 px-3 py-1.5 text-xs transition-colors ${
+                  isActive
+                    ? 'border-cyan-400 bg-cyan-900/20 text-cyan-300'
+                    : 'border-transparent text-gray-400 hover:text-gray-200'
+                }`}>
+                {catalog?.device_labels[device] ?? device}
+                {count > 0 && <span className="ml-1 text-[10px] opacity-60">{count}</span>}
+              </button>
+            );
+          })}
+        </div>
+
+        {/* 检查项列表 —— **紧凑行**，不是卡片。
+            之前每个检查项是一张卡（开关行 + 说明行 + 参数行 + 边框间距 ≈ 85px），
+            9 项就是 765px，加头/tab/底部超过 82vh，「必须滚动」是尺寸算出来的，
+            换滚动条样式治不了本。压成一行后每项 ~30px，整块约 320px，不再滚动。
+            说明文字移到 label 的 title（hover 出），参数原名移到输入框的 title。 */}
+        <div className="dark-scroll min-h-0 flex-1 overflow-y-auto px-3 py-2">
+          {error && <div className="text-xs text-red-400">{t('quality.loadFailed')}{error}</div>}
+          {!catalog && !error && <div className="text-xs text-gray-500">{t('common.loading')}</div>}
+
+          {catalog && active && (
+            <>
+              {checksOf(active).length === 0 && (
+                <div className="text-xs text-gray-500">
+                  {catalog.device_labels[active] ?? active} {t('quality.noChecks')}
+                </div>
+              )}
+              {Object.entries(byCategory(checksOf(active))).map(([category, items]) => (
+                <div key={category} className="mb-1.5">
+                  <div className="px-1 pb-0.5 pt-1.5 text-[10px] uppercase tracking-wider text-gray-500">
+                    {category}
+                  </div>
+                  {items.map((check) => {
+                    const entry = entryOf(active, check.slug);
+                    const enabled = entry.enabled !== false;
+                    return (
+                      <div key={check.slug}
+                           className="flex items-center gap-2 rounded px-1 py-[3px] hover:bg-white/[0.04]">
+                        <input type="checkbox" checked={enabled}
+                               className="shrink-0"
+                               onChange={(e) =>
+                                 setEntry(active, check.slug, { enabled: e.target.checked })} />
+
+                        {/* 固定宽 + truncate：名称长短不一，不固定的话右边的参数
+                            列会左右错开。截断的部分由 title 补全。 */}
+                        <span
+                          className="w-[104px] shrink-0 truncate text-xs text-gray-200"
+                          title={check.description
+                            ? `${check.label} — ${check.description}`
+                            : check.label}>
+                          {check.label}
+                        </span>
+
+                        {/* 参数区可伸缩 + 可换行：参数多的检查项（如 SLAM 连续性
+                            有线速/角速两个）超宽时换行，行高自动长一点，不会溢出。 */}
+                        <div className="flex min-w-0 flex-1 flex-wrap items-center gap-x-2.5 gap-y-1">
+                          {enabled && Object.entries(check.default_params).map(([name, fallback]) => {
+                            const meta = paramMeta(name, lang);
+                            const value = (entry.params?.[name] ?? fallback) as number;
+                            return (
+                              <label key={name} title={name}
+                                     className="flex items-center gap-1 text-[10px] text-gray-400">
+                                {meta.label}
+                                <input
+                                  type="number"
+                                  className="w-[68px] rounded border border-gray-700 bg-gray-900 px-1 py-0.5 text-right text-gray-200"
+                                  value={value}
+                                  step={meta.step ?? 1}
+                                  onChange={(e) =>
+                                    setEntry(active, check.slug, {
+                                      params: {
+                                        ...(entry.params ?? {}),
+                                        [name]: Number(e.target.value),
+                                      },
+                                    })} />
+                                {meta.unit && <span className="text-gray-600">{meta.unit}</span>}
+                              </label>
+                            );
+                          })}
+                        </div>
+
+                        {/* slug 固定宽右对齐 —— 它是报告里的键名，用来对账，
+                            最长 "umi.slam_continuity"(19 字符 @10px ≈ 95px)。 */}
+                        <span className="w-[104px] shrink-0 truncate text-right text-[10px] text-gray-600"
+                              title={check.slug}>
+                          {check.slug}
+                        </span>
+                      </div>
+                    );
+                  })}
+                </div>
+              ))}
+            </>
+          )}
+        </div>
+
+        <div className="flex justify-end gap-2 border-t border-gray-700 px-4 py-2">
+          <button onClick={onClose}
+                  className="rounded border border-gray-700 px-3 py-1 text-xs text-gray-300">
+            {t('common.cancel')}
+          </button>
+          <button onClick={save}
+                  className="rounded border border-cyan-700 bg-cyan-900/40 px-3 py-1 text-xs text-cyan-200">
+            {t('common.save')}
+          </button>
+        </div>
+      </div>
+    </div>,
+    document.body,
+  );
+}
diff --git a/processor/web/workflow-studio/src/components/WorkflowCanvas/NodePalette.tsx b/processor/web/workflow-studio/src/components/WorkflowCanvas/NodePalette.tsx
index d8d9a45b2c49ea5021ce1dc409adc2b4a718cb81..9f15e28a4d4e82394e2f19f3e8237669cda979df 100644
--- a/processor/web/workflow-studio/src/components/WorkflowCanvas/NodePalette.tsx
+++ b/processor/web/workflow-studio/src/components/WorkflowCanvas/NodePalette.tsx
@@ -1,6 +1,10 @@
-import { useState } from 'react';
+import { useMemo, useState, useSyncExternalStore } from 'react';
+import { nodeLabel, useLang, useT } from '../../i18n';
 import { IconifyIcon } from './IconifyIcon';
-import { getAllNodeTypes, getNodeTypesByCategory } from './nodes/registry';
+import {
+  getAllNodeTypes, getNodeTypesByCategory,
+  getNodeTypesRevision, subscribeNodeTypes,
+} from './nodes/registry';
 import type { NodeCategory, NodeTypeDescriptor } from '../../types/workflow';
 
 // 旧单目卡只保留给历史工作流渲染/执行,不再出现在新工作流调色板。
@@ -13,12 +17,26 @@ const FIXED_INPUT_TYPES = [
 // MediaPipe Hand is retained as a backend/old-workflow compatibility node;
 // the current hand modules are exposed through the canonical process cards.
 const LEGACY_PROCESS_TYPES = ['mediapipe_hand'];
+// Human Review 只做标注，不产生任何行为 —— 从调色板移除。
+//
+// 它的 run() 是纯透传，工作流**不会**在它那里停下等人：真正的审核门在状态层，
+// 而且是无条件的（worker 完成回调把每个 run 置 to_review，导出接口只接受
+// reviewed/approved）。所以它画在图上的位置是**误导性信息** —— 看图的人会以为
+// "数据在这儿被人审过才往下走"，实际那个位置没有关口。
+//
+// ★ 只是**不显示**，不是删：模块保留注册（worker/runner.py 用 get_module 解析
+//   nodeType，删了会让 8 个已保存工作流直接跑失败），老图也照常渲染与执行
+//   （label/icon 存在图的节点数据里，不依赖注册表）。与 mediapipe_hand 同款处理。
+const LEGACY_REVIEW_TYPES = ['human_review'];
 
-const CATEGORIES: { key: NodeCategory; label: string; icon: string }[] = [
-  { key: 'input', label: 'Input', icon: 'ant-design:video-camera-outlined' },
-  { key: 'process', label: 'Process', icon: 'ant-design:desktop-outlined' },
-  { key: 'review', label: 'Review', icon: 'ant-design:eye-outlined' },
-  { key: 'export', label: 'Export', icon: 'ant-design:download-outlined' },
+// 顺序 = 调色板里从上到下的分组顺序。
+// Review 排在 Process 前面（用户要求）：审核类节点是流程里的"关口"，
+// 摆在一起更好找，而 Process 卡片最多、占了面板大半屏。
+const CATEGORIES: { key: NodeCategory; labelKey: string; icon: string }[] = [
+  { key: 'input', labelKey: 'palette.input', icon: 'ant-design:video-camera-outlined' },
+  { key: 'review', labelKey: 'palette.review', icon: 'ant-design:eye-outlined' },
+  { key: 'process', labelKey: 'palette.process', icon: 'ant-design:desktop-outlined' },
+  { key: 'export', labelKey: 'palette.export', icon: 'ant-design:download-outlined' },
 ];
 
 export function NodePalette() {
@@ -37,13 +55,25 @@ export function NodePalette() {
   };
   const hideTip = () => setTip(null);
 
-  const filtered = search.trim()
-    ? getAllNodeTypes().filter((nd) => nd.label.toLowerCase().includes(search.toLowerCase()))
-    : null;
+  // 订阅注册表版本号 —— 否则 App 异步 hydrate 完（补上 UMI Slam Action 这类
+  // 不在 BUILTIN 里的节点）不会重渲染，要等别的状态变化才"顺带"刷新。
+  const revision = useSyncExternalStore(subscribeNodeTypes, getNodeTypesRevision);
+  const t = useT();
+  const lang = useLang();
+
+  // 搜索同时匹配英文原名与中文译名 —— 切到中文后输入"手套"要能找到 Glove Sensor
+  const filtered = useMemo(() => {
+    const q = search.trim().toLowerCase();
+    if (!q) return null;
+    return getAllNodeTypes().filter((nd) =>
+      nd.label.toLowerCase().includes(q)
+      || nodeLabel(nd.type, nd.label, lang).toLowerCase().includes(q));
+  }, [search, revision, lang]);
 
   const shouldShow = (nd: NodeTypeDescriptor): boolean => {
     if (LEGACY_INPUT_TYPES.includes(nd.type)) return false;
     if (LEGACY_PROCESS_TYPES.includes(nd.type)) return false;
+    if (LEGACY_REVIEW_TYPES.includes(nd.type)) return false;
     if (nd.category === 'input') return FIXED_INPUT_TYPES.includes(nd.type);
     return true;
   };
@@ -57,7 +87,7 @@ export function NodePalette() {
         onMouseLeave={hideTip}>
         <div draggable onDragStart={(e) => onDragStart(e, nd)} className={cls}>
           <span className="w-2.5 h-2.5 rounded-full shrink-0" style={{ backgroundColor: nd.color }} />
-          <span className="text-xs text-gray-300 truncate">{nd.label}</span>
+          <span className="text-xs text-gray-300 truncate">{nodeLabel(nd.type, nd.label, lang)}</span>
         </div>
       </div>
     );
@@ -66,7 +96,7 @@ export function NodePalette() {
   return (
     <div className="w-[220px] bg-gray-900 border-r border-gray-800 flex flex-col shrink-0 overflow-hidden relative">
       <div className="p-2">
-        <input type="text" placeholder="Search nodes..." value={search} onChange={(e) => setSearch(e.target.value)}
+        <input type="text" placeholder={t('palette.search')} value={search} onChange={(e) => setSearch(e.target.value)}
           className="w-full bg-gray-800 border border-gray-700 rounded px-2 py-1.5 text-xs text-gray-200 placeholder-gray-500 focus:outline-none focus:border-blue-500" />
       </div>
       <div className="flex-1 overflow-y-auto px-1 pb-2">
@@ -83,7 +113,7 @@ export function NodePalette() {
                   <button onClick={() => setCollapsed((p) => ({ ...p, [cat.key]: !p[cat.key] }))}
                     className="w-full flex items-center gap-1.5 px-2 py-1.5 text-[11px] font-semibold text-gray-500 uppercase tracking-wider hover:text-gray-300">
                     <IconifyIcon icon={cat.icon} className="text-[14px]" />
-                    <span>{cat.label}</span>
+                    <span>{t(cat.labelKey)}</span>
                     <IconifyIcon icon={open ? 'ant-design:caret-down-filled' : 'ant-design:caret-right-outlined'} className="ml-auto text-[10px]" />
                   </button>
                   {open && nodes.map(renderNode)}
@@ -91,7 +121,7 @@ export function NodePalette() {
               );
             })}
       </div>
-      <div className="px-2 py-2 border-t border-gray-800 text-[10px] text-gray-600 text-center">Drag nodes onto canvas</div>
+      <div className="px-2 py-2 border-t border-gray-800 text-[10px] text-gray-600 text-center">{t('palette.hint')}</div>
       {tip && (
         <div className="pointer-events-none fixed z-[200] w-60 rounded border border-gray-700 bg-gray-950/95 p-2 shadow-xl"
           style={{ left: tip.x, top: tip.y }}>
diff --git a/processor/web/workflow-studio/src/components/WorkflowCanvas/NodeSettingsModal.tsx b/processor/web/workflow-studio/src/components/WorkflowCanvas/NodeSettingsModal.tsx
index 40534da957983f8546d7341efb209929632f8350..2195584adafc3ef674782231cc0a69dc4ab130dd 100644
--- a/processor/web/workflow-studio/src/components/WorkflowCanvas/NodeSettingsModal.tsx
+++ b/processor/web/workflow-studio/src/components/WorkflowCanvas/NodeSettingsModal.tsx
@@ -1,4 +1,6 @@
-import { useState } from 'react';
+import { createPortal } from 'react-dom';
+import { useEffect, useState } from 'react';
+import { useT } from '../../i18n';
 import { useWorkflowStore } from '../../store/workflowStore';
 import type { WorkflowNodeData } from '../../types/workflow';
 
@@ -83,6 +85,7 @@ function entriesFromConfig(config: Record<string, unknown> | undefined): ApiEntr
  * `api_providers` 数组 + 首套同步写回旧字段(兼容旧运行链路)。
  */
 export function NodeSettingsModal({ nodeId, onClose }: Props) {
+  const t = useT();
   const node = useWorkflowStore((s) => s.nodes.find((n) => n.id === nodeId));
   const data = node?.data as unknown as WorkflowNodeData | undefined;
   const schema = data?.configSchema || [];
@@ -101,6 +104,19 @@ export function NodeSettingsModal({ nodeId, onClose }: Props) {
     return value === 'en' ? 'en' : 'zh';
   });
 
+  // Esc 关闭 —— 与 DeviceQualityModal 同一处理：捕获阶段拦下，别让 React Flow
+  // 同时清掉画布选择。两个弹窗都在同一块画布上，Esc 行为必须一致。
+  useEffect(() => {
+    const onKey = (e: KeyboardEvent) => {
+      if (e.key !== 'Escape') return;
+      e.stopPropagation();
+      e.preventDefault();
+      onClose();
+    };
+    window.addEventListener('keydown', onKey, true);
+    return () => window.removeEventListener('keydown', onKey, true);
+  }, [onClose]);
+
   const active = entries.find((e) => e.id === activeId) || entries[0];
   const vendor = active?.vendor ?? 'kimi';
   const model = active?.model ?? '';
@@ -156,11 +172,11 @@ export function NodeSettingsModal({ nodeId, onClose }: Props) {
   const handleTestConnection = async () => {
     if (testing) return;
     if (!model.trim()) {
-      setTestResult({ ok: false, message: 'Model required' });
+      setTestResult({ ok: false, message: t('ai.modelRequired') });
       return;
     }
     if (!key.trim()) {
-      setTestResult({ ok: false, message: 'API key required' });
+      setTestResult({ ok: false, message: t('ai.keyRequired') });
       return;
     }
     setTesting(true);
@@ -180,12 +196,12 @@ export function NodeSettingsModal({ nodeId, onClose }: Props) {
       const payload = await response.json().catch(() => ({}));
       setTestResult({
         ok: response.ok && payload.ok === true,
-        message: String(payload.message || (response.ok ? 'Test failed' : `Request failed (${response.status})`)),
+        message: String(payload.message || (response.ok ? t('ai.testFailed') : `${t('ai.requestFailed')} (${response.status})`)),
       });
     } catch (error) {
       setTestResult({
         ok: false,
-        message: `Request failed: ${error instanceof Error ? error.message : 'network error'}`,
+        message: `Request failed: ${error instanceof Error ? error.message : t('ai.networkError')}`,
       });
     } finally {
       setTesting(false);
@@ -232,8 +248,11 @@ export function NodeSettingsModal({ nodeId, onClose }: Props) {
     ? [model, ...modelOptions]
     : modelOptions;
 
-  return (
-    <div className="fixed inset-0 z-50 flex items-center justify-center">
+  // 必须走 portal 挂到 document.body —— React Flow 的 viewport 带 transform，
+  // 它会给后代创建新的包含块，导致 position:fixed 的弹窗跟着画布缩放平移。
+  // 详见 DeviceQualityModal 的同款注释。
+  return createPortal(
+    <div className="modal-portal flex items-center justify-center">
       <div className="absolute inset-0 bg-black/60" onClick={onClose} />
       <div className="relative w-96 bg-gray-900 border border-gray-700 rounded-lg shadow-2xl">
         <div className="flex items-center justify-between px-4 py-3 border-b border-gray-800">
@@ -243,7 +262,7 @@ export function NodeSettingsModal({ nodeId, onClose }: Props) {
         </div>
         <div className="p-4 space-y-3">
           <label className="block">
-            <span className="text-xs text-gray-400">Label language</span>
+            <span className="text-xs text-gray-400">{t('ai.labelLanguage')}</span>
             <select
               aria-label="Label language"
               value={language}
@@ -253,7 +272,7 @@ export function NodeSettingsModal({ nodeId, onClose }: Props) {
               <option value="en">English</option>
             </select>
             <span className="mt-1 block text-[10px] text-gray-500">
-              Applies to the next AI annotation run.
+              {t('ai.appliesNextRun')}
             </span>
           </label>
           {String(data?.config?.vlm_provider || 'local') === 'local' && (
@@ -280,7 +299,7 @@ export function NodeSettingsModal({ nodeId, onClose }: Props) {
               className="shrink-0 text-xs px-2 py-1.5 rounded border border-gray-700 text-gray-500 hover:text-red-400 hover:border-red-800 disabled:opacity-30">✕</button>
           </div>
           <label className="block">
-            <span className="text-xs text-gray-400">API vendor</span>
+            <span className="text-xs text-gray-400">{t('ai.vendor')}</span>
             <select value={vendor} onChange={(e) => handleVendorChange(e.target.value)}
               className="mt-1 w-full bg-gray-800 border border-gray-700 rounded px-2 py-1.5 text-sm text-gray-200">
               {vendorOptions.map((o) => (
@@ -289,7 +308,7 @@ export function NodeSettingsModal({ nodeId, onClose }: Props) {
             </select>
           </label>
           <label className="block">
-            <span className="text-xs text-gray-400">API model</span>
+            <span className="text-xs text-gray-400">{t('ai.model')}</span>
             <select value={model} onChange={(e) => { updateActive({ model: e.target.value }); }}
               className="mt-1 w-full bg-gray-800 border border-gray-700 rounded px-2 py-1.5 text-sm text-gray-200">
               {visibleModelOptions.length ? visibleModelOptions.map((option) => (
@@ -298,7 +317,7 @@ export function NodeSettingsModal({ nodeId, onClose }: Props) {
             </select>
           </label>
           <label className="block">
-            <span className="text-xs text-gray-400">API key (stored with this workflow)</span>
+            <span className="text-xs text-gray-400">{t('ai.key')}</span>
             <input type="password" value={key} onChange={(e) => updateActive({ key: e.target.value })}
               autoComplete="new-password"
               placeholder="sk-..."
@@ -321,15 +340,16 @@ export function NodeSettingsModal({ nodeId, onClose }: Props) {
         </div>
         <div className="flex justify-end gap-2 px-4 py-3 border-t border-gray-800">
           <button onClick={onClose}
-            className="text-xs px-3 py-1.5 rounded bg-gray-800 hover:bg-gray-700 text-gray-300">Cancel</button>
+            className="text-xs px-3 py-1.5 rounded bg-gray-800 hover:bg-gray-700 text-gray-300">{t('common.cancel')}</button>
           <button onClick={handleTestConnection} disabled={testing}
             className="text-xs px-3 py-1.5 rounded border border-cyan-700 bg-cyan-950/40 hover:bg-cyan-900/60 text-cyan-300 disabled:opacity-50">
             {testing ? 'Testing…' : 'Test Connection'}
           </button>
           <button onClick={handleSave}
-            className="text-xs px-3 py-1.5 rounded bg-blue-600 hover:bg-blue-500 text-white">Save</button>
+            className="text-xs px-3 py-1.5 rounded bg-blue-600 hover:bg-blue-500 text-white">{t('common.save')}</button>
         </div>
       </div>
-    </div>
+    </div>,
+    document.body,
   );
 }
diff --git a/processor/web/workflow-studio/src/components/WorkflowCanvas/PipelineToolbar.tsx b/processor/web/workflow-studio/src/components/WorkflowCanvas/PipelineToolbar.tsx
index f74dfd8886944e17d8a6fa391ea8a33d1d30dfc9..30b6003e44b9f2e90532cbccc99f310cb45fd929 100644
--- a/processor/web/workflow-studio/src/components/WorkflowCanvas/PipelineToolbar.tsx
+++ b/processor/web/workflow-studio/src/components/WorkflowCanvas/PipelineToolbar.tsx
@@ -1,3 +1,4 @@
+import { useT } from '../../i18n';
 import { useState, useCallback } from 'react';
 import { useWorkflowStore } from '../../store/workflowStore';
 import { useUiStore } from '../../store/uiStore';
@@ -6,6 +7,7 @@ import { runWorkflow } from '../../api/workflows';
 interface Props { onOpenDrawer: () => void }
 
 export function PipelineToolbar({ onOpenDrawer }: Props) {
+  const t = useT();
   const { workflowName, workflowId, isDirty, isSaving, saveWorkflow, saveWorkflowAs, newWorkflow } = useWorkflowStore();
   const [showNameInput, setShowNameInput] = useState(false);
   const [nameDraft, setNameDraft] = useState(workflowName);
@@ -46,7 +48,7 @@ export function PipelineToolbar({ onOpenDrawer }: Props) {
 
   return (
     <div className="flex items-center gap-3 px-4 py-2 bg-gray-900 border-b border-gray-800 shrink-0">
-      <button onClick={onOpenDrawer} className="text-gray-400 hover:text-white p-1.5 rounded hover:bg-gray-800" title="Workflow list">☰</button>
+      <button onClick={onOpenDrawer} className="text-gray-400 hover:text-white p-1.5 rounded hover:bg-gray-800" title={t('toolbar.workflowList')}>☰</button>
       <span className={`w-2 h-2 rounded-full shrink-0 ${statusDot}`} />
       {showNameInput ? (
         <>
@@ -54,18 +56,18 @@ export function PipelineToolbar({ onOpenDrawer }: Props) {
             onKeyDown={(e) => { if (e.key==='Enter') confirmSaveAs(); if (e.key==='Escape') setShowNameInput(false); }}
             onBlur={() => { if (!nameDraft.trim()) setShowNameInput(false); }}
             className="bg-gray-800 border border-gray-600 rounded px-2 py-1 text-sm text-white w-52 focus:outline-none focus:border-blue-500" />
-          <button onClick={confirmSaveAs} className="text-xs bg-blue-600 hover:bg-blue-500 text-white px-2 py-1 rounded">Save</button>
+          <button onClick={confirmSaveAs} className="text-xs bg-blue-600 hover:bg-blue-500 text-white px-2 py-1 rounded">{t('toolbar.save')}</button>
         </>
       ) : (
         <span className="text-sm font-semibold text-gray-200">{workflowName}</span>
       )}
       {feedback && <span className="text-xs text-green-400">{feedback}</span>}
       <div className="flex-1" />
-      <button onClick={newWorkflow} className="text-xs text-gray-400 hover:text-white px-2 py-1.5 rounded hover:bg-gray-800">New</button>
-      <button onClick={handleSave} disabled={isSaving} className="text-xs bg-blue-600 hover:bg-blue-500 text-white px-3 py-1.5 rounded disabled:opacity-50">{isSaving ? '...' : 'Save'}</button>
-      <button onClick={handleSaveAs} className="text-xs text-gray-400 hover:text-white px-2 py-1.5 rounded hover:bg-gray-800">Save As</button>
-      <button onClick={handleExport} className="text-xs text-gray-400 hover:text-white px-2 py-1.5 rounded hover:bg-gray-800">Export</button>
-      <button onClick={handleRun} className="text-xs bg-green-700 hover:bg-green-600 text-white px-3 py-1.5 rounded">▶ Run</button>
+      <button onClick={newWorkflow} className="text-xs text-gray-400 hover:text-white px-2 py-1.5 rounded hover:bg-gray-800">{t('toolbar.new')}</button>
+      <button onClick={handleSave} disabled={isSaving} className="text-xs bg-blue-600 hover:bg-blue-500 text-white px-3 py-1.5 rounded disabled:opacity-50">{isSaving ? '...' : t('toolbar.save')}</button>
+      <button onClick={handleSaveAs} className="text-xs text-gray-400 hover:text-white px-2 py-1.5 rounded hover:bg-gray-800">{t('toolbar.saveAs')}</button>
+      <button onClick={handleExport} className="text-xs text-gray-400 hover:text-white px-2 py-1.5 rounded hover:bg-gray-800">{t('toolbar.export')}</button>
+      <button onClick={handleRun} className="text-xs bg-green-700 hover:bg-green-600 text-white px-3 py-1.5 rounded">▶ {t('toolbar.run')}</button>
     </div>
   );
 }
diff --git a/processor/web/workflow-studio/src/components/WorkflowCanvas/WorkflowCanvas.tsx b/processor/web/workflow-studio/src/components/WorkflowCanvas/WorkflowCanvas.tsx
index 9a9ab612be40f23bade69b6d9c73d8e75a010b24..36a3770c5871295d7e3b816b2df4efc67b4fad97 100644
--- a/processor/web/workflow-studio/src/components/WorkflowCanvas/WorkflowCanvas.tsx
+++ b/processor/web/workflow-studio/src/components/WorkflowCanvas/WorkflowCanvas.tsx
@@ -2,7 +2,7 @@ import { useCallback, useMemo, useRef } from 'react';
 import { ReactFlow, Background, MiniMap, Controls, useReactFlow, type NodeTypes, type EdgeTypes } from '@xyflow/react';
 import '@xyflow/react/dist/style.css';
 import { useWorkflowStore, nextNodeId } from '../../store/workflowStore';
-import { getAllNodeTypes, getMaxPortRows } from './nodes/registry';
+import { getAllNodeTypes } from './nodes/registry';
 import { WorkflowNodeComponent } from './nodes/WorkflowNode';
 import { DeletableEdge } from './edges/DeletableEdge';
 import type { DeviceInputSource, WorkflowNodeData } from '../../types/workflow';
@@ -20,10 +20,6 @@ export function WorkflowCanvas() {
   const rf = useReactFlow();
   const wrapperRef = useRef<HTMLDivElement>(null);
 
-  // Uniform card height: compute from max port rows across all node types
-  const maxRows = useMemo(() => getMaxPortRows(), []);
-  const cardHeight = maxRows * 22 + 42; // 22px per row + header+padding
-
   const onDragOver = useCallback((e: React.DragEvent) => { e.preventDefault(); e.dataTransfer.dropEffect = 'move'; }, []);
 
   const onDrop = useCallback((e: React.DragEvent) => {
@@ -98,7 +94,7 @@ export function WorkflowCanvas() {
 
   return (
     <div ref={wrapperRef} className="flex-1 h-full" onDragOver={onDragOver} onDrop={onDrop}
-      style={{ '--node-card-height': `${cardHeight}px` } as React.CSSProperties}>
+>
       <ReactFlow
         key={workflowId || 'blank'}
         nodes={nodes} edges={edges}
diff --git a/processor/web/workflow-studio/src/components/WorkflowCanvas/WorkflowDrawer.tsx b/processor/web/workflow-studio/src/components/WorkflowCanvas/WorkflowDrawer.tsx
index 97b6a803bbc7e1dc67aca4d877f72101383f7ef9..d7569a35931d2188b8af84e19e3fcb307cec8046 100644
--- a/processor/web/workflow-studio/src/components/WorkflowCanvas/WorkflowDrawer.tsx
+++ b/processor/web/workflow-studio/src/components/WorkflowCanvas/WorkflowDrawer.tsx
@@ -1,3 +1,4 @@
+import { useT } from '../../i18n';
 import { useEffect } from 'react';
 import { useWorkflowStore } from '../../store/workflowStore';
 import type { WorkflowListItem } from '../../types/workflow';
@@ -5,6 +6,7 @@ import type { WorkflowListItem } from '../../types/workflow';
 interface Props { onClose: () => void }
 
 export function WorkflowDrawer({ onClose }: Props) {
+  const t = useT();
   const { workflows, listLoading, loadWorkflowList, loadWorkflow, loadInputsForWorkflow, newWorkflow } = useWorkflowStore();
 
   useEffect(() => { loadWorkflowList(); }, [loadWorkflowList]);
@@ -22,7 +24,7 @@ export function WorkflowDrawer({ onClose }: Props) {
       <div className="absolute inset-0 bg-black/60" onClick={onClose} />
       <div className="relative w-80 bg-gray-900 border-r border-gray-800 h-full flex flex-col shadow-2xl">
         <div className="flex items-center justify-between px-4 py-3 border-b border-gray-800">
-          <h3 className="text-sm font-semibold text-gray-200">Workflows</h3>
+          <h3 className="text-sm font-semibold text-gray-200">{t('drawer.workflows')}</h3>
           <button onClick={handleNew} className="text-xs bg-blue-600 hover:bg-blue-500 text-white px-2 py-1 rounded">+ New</button>
         </div>
         <div className="flex-1 overflow-y-auto">
@@ -31,7 +33,7 @@ export function WorkflowDrawer({ onClose }: Props) {
           ) : workflows.length === 0 ? (
             <div className="flex flex-col items-center py-12 text-gray-600 gap-2">
               <span className="text-3xl">📋</span>
-              <span className="text-xs">No workflows yet</span>
+              <span className="text-xs">{t('drawer.noWorkflows')}</span>
             </div>
           ) : workflows.map((wf) => (
             <button key={wf.id} onClick={() => handleSelect(wf)}
diff --git a/processor/web/workflow-studio/src/components/WorkflowCanvas/edges/DeletableEdge.tsx b/processor/web/workflow-studio/src/components/WorkflowCanvas/edges/DeletableEdge.tsx
index 45857a54e2927308c40a0b15214dc9d99483775e..b45652c96159552ca2ae8a51af0157538bfa985b 100644
--- a/processor/web/workflow-studio/src/components/WorkflowCanvas/edges/DeletableEdge.tsx
+++ b/processor/web/workflow-studio/src/components/WorkflowCanvas/edges/DeletableEdge.tsx
@@ -1,3 +1,4 @@
+import { useT } from '../../../i18n';
 import { BaseEdge, EdgeLabelRenderer, getBezierPath, useReactFlow, type EdgeProps } from '@xyflow/react';
 
 /** 可删除连线:默认渲染与现状一致的 BaseEdge(样式/箭头不变);
@@ -5,6 +6,7 @@ import { BaseEdge, EdgeLabelRenderer, getBezierPath, useReactFlow, type EdgeProp
  *  删除走 deleteElements → onEdgesChange(remove) → store 现有
  *  pushHistory + saveDraft 通道,与键盘 Delete 完全同一路径。 */
 export function DeletableEdge(props: EdgeProps) {
+  const t = useT();
   const {
     id, sourceX, sourceY, targetX, targetY,
     sourcePosition, targetPosition, selected, style, markerEnd,
@@ -22,7 +24,7 @@ export function DeletableEdge(props: EdgeProps) {
           <button
             type="button"
             className="nodrag nopan"
-            title="Delete connection"
+            title={t('edge.delete')}
             onClick={() => deleteElements({ edges: [{ id }] })}
             style={{
               position: 'absolute',
diff --git a/processor/web/workflow-studio/src/components/WorkflowCanvas/nodes/WorkflowNode.tsx b/processor/web/workflow-studio/src/components/WorkflowCanvas/nodes/WorkflowNode.tsx
index ff2511c499867453da42d3791e28a306eacb8d53..2a7141551f4228f1dfb920f4fcc74b365de7ad32 100644
--- a/processor/web/workflow-studio/src/components/WorkflowCanvas/nodes/WorkflowNode.tsx
+++ b/processor/web/workflow-studio/src/components/WorkflowCanvas/nodes/WorkflowNode.tsx
@@ -1,10 +1,12 @@
-import { memo, useState, type KeyboardEvent, type FocusEvent } from 'react';
-import { Handle, Position, type NodeProps } from '@xyflow/react';
+import { memo, useMemo, useState, type KeyboardEvent, type FocusEvent } from 'react';
+import { Handle, Position, type Node, type NodeProps } from '@xyflow/react';
 import { IconifyIcon } from '../IconifyIcon';
-import { useWorkflowStore } from '../../../store/workflowStore';
+import { DYNAMIC_INPUT_TYPES, dynamicInputKey, useWorkflowStore } from '../../../store/workflowStore';
+import { nodeLabel, portLabel, useLang, useT } from '../../../i18n';
 import { useUiStore } from '../../../store/uiStore';
 import { getNodeType } from './registry';
 import { NodeSettingsModal } from '../NodeSettingsModal';
+import { DeviceQualityModal } from '../DeviceQualityModal';
 import type { ConfigField, DeviceInputSource, WorkflowNodeData } from '../../../types/workflow';
 
 const CAMERA_TYPES = [
@@ -40,8 +42,94 @@ function cameraCategoryLabel(data: WorkflowNodeData): string {
   return DEVICE_CATEGORY_LABELS.mono_rgb;
 }
 
+/**
+ * 解析「节点 id + 端口 key」的端口名 —— 取不到就回落到 handle 本身。
+ *
+ * 动态端口节点（Data Quality）的**输出**口 key 是 ``dynamicInputKey`` 编出来的
+ * ``${上游节点 id}:${上游端口}``（见 workflowStore）。所以给下游算口名时不能只看
+ * 该节点自己的 ``outputs`` —— 那里只有声明的 ``reviewed``，四个口会全叫
+ * "Reviewed Data"。要顺着 key 往回找：dq → dq → … → 设备节点，一路解到真实
+ * 端口。节点 id 恒为 ``node_N``、不含冒号，按**首个**冒号切分安全；前缀若不是
+ * 已知节点（老图/异构来源），原样回落到 handle。
+ *
+ * depth 上限防环：正常链路的 key 由上游 id 构成不会成环，但图上若被手工造出
+ * dq → dq 的自指边，没有上限会栈溢出。
+ */
+function portLabelOf(
+  byId: Map<string, Node<WorkflowNodeData>>,
+  nodeId: string,
+  sourceHandle: string | null | undefined,
+  lang: 'en' | 'zh',
+  depth = 0,
+): string {
+  const handle = String(sourceHandle ?? '');
+  const node = byId.get(nodeId);
+  if (!node || depth > 8) return handle;
+  const type = String(node.data?.nodeType ?? '');
+  const outputs = node.data?.outputs || [];
+  // 显式声明的口优先 —— 非动态节点的行为与改动前逐字一致
+  const port = outputs.find((o) => o.key === handle);
+  if (port) return portLabel(type, port.key, port.label, lang);
+  // 动态 key：`${上游节点 id}:${上游端口}`，递归解到真正的端口名
+  if (DYNAMIC_INPUT_TYPES.has(type) && handle.includes(':')) {
+    const at = handle.indexOf(':');
+    if (byId.has(handle.slice(0, at))) {
+      return portLabelOf(byId, handle.slice(0, at), handle.slice(at + 1), lang, depth + 1);
+    }
+  }
+  const only = outputs.length === 1 ? outputs[0] : null;
+  // 用**上游**的类型翻译 —— data 这个 key 在不同卡上叫法不同
+  return portLabel(type, only?.key || handle, only?.label || handle, lang);
+}
+
+/**
+ * Data Quality 的输入端口是**按入边生成**的：每接一个设备就多一个口，口名就是
+ * 上游那个端口的名字。在此之前所有线都挤在同一个 ``data`` 口上，口名只能把几个
+ * 上游的名字拼起来（"Glove Sensor Data, RGB Video"），越长越读不出来。
+ *
+ * 端口 key 用 ``dynamicInputKey(源节点, 源端口)``——稳定且可重复，同一个上游
+ * 重连仍是同一个口。老图的边在 ``normalizeWorkflowGraphForEditor`` 里已经迁移过。
+ *
+ * 返回**字符串**（JSON）而不是数组：zustand 按 Object.is 比较，每次返回新数组会
+ * 让整块画布每个节点在任意 store 变动时都重渲染。
+ */
+function useDynamicInputs(nodeId: string, enabled: boolean, lang: 'en' | 'zh'): [string, string][] {
+  const encoded = useWorkflowStore((s) => {
+    if (!enabled) return '';
+    const incoming = s.edges.filter((e) => e.target === nodeId);
+    if (!incoming.length) return '';
+    // ★ 按 key 去重（保序）。端口 key 只由「源节点 + 源端口」决定，所以两条
+    //   同源同端口的边会算出同一个 key —— 不去重就会渲染出**两个同名口**。
+    //   这类重复边本不该存在（onConnect 有 isDup 拦），但历史上配对边写错了
+    //   targetHandle，isDup 判不出来（见 workflowStore 里 siblingConn 的注释）。
+    //   渲染层兜一道，保证"一个 key 一个口"。
+    const seen = new Set<string>();
+    const rows: [string, string][] = [];
+    // 每轮只建一次索引：原来是每条边一次 s.nodes.find（O(E·N)）
+    const byId = new Map(s.nodes.map((n) => [String(n.id), n]));
+    for (const edge of incoming) {
+      const key = dynamicInputKey(String(edge.source), edge.sourceHandle);
+      if (seen.has(key)) continue;
+      seen.add(key);
+      const sourceId = String(edge.source);
+      rows.push([key, byId.has(sourceId)
+        ? portLabelOf(byId, sourceId, edge.sourceHandle, lang)
+        : key]);
+    }
+    return JSON.stringify(rows);
+  });
+  return useMemo(
+    () => (encoded ? (JSON.parse(encoded) as [string, string][]) : []),
+    [encoded],
+  );
+}
+
 export const WorkflowNodeComponent = memo(function WorkflowNodeComponent({ data, selected, id }: NodeProps) {
   const d = data as unknown as WorkflowNodeData;
+  const isDynamicInputs = DYNAMIC_INPUT_TYPES.has(String(d.nodeType));
+  const t = useT();
+  const lang = useLang();
+  const dynamicInputs = useDynamicInputs(id, isDynamicInputs, lang);
   const hdrColor = d.color || '#475569';
   const isCamera = DEVICE_INPUT_TYPES.includes(d.nodeType);
   // 画布节点悬停说明:与侧边栏一致(功能 + 可连接性)
@@ -72,7 +160,8 @@ export const WorkflowNodeComponent = memo(function WorkflowNodeComponent({ data,
   // The node title is a fixed physical-device category (for example RGB-D
   // Camera). The editable field is kept independent and shows the concrete
   // source name/key; changing it must not rename the category.
-  const nodeTitle = isCamera ? cameraCategoryLabel(d) : d.label;
+  const nodeTitle = nodeLabel(String(d.nodeType),
+    isCamera ? cameraCategoryLabel(d) : d.label, lang);
   const deviceInputValue = isCamera && inputContextReady
     ? getDeviceInputValue(shownValue, availableInputs, d.nodeType, d.device_type)
     : '';
@@ -84,6 +173,41 @@ export const WorkflowNodeComponent = memo(function WorkflowNodeComponent({ data,
   const selectedDepth = depthOptions.includes(configuredDepth) ? configuredDepth : '';
   const controlValue = isCamera ? deviceInputValue : shownValue;
 
+  // 输入端口 = 声明的口 + 动态口（Data Quality 专有，一条入边一个）。
+  //
+  // **有动态口时不再渲染那个空的声明口** —— 它只是个连接落点，跟动态口并排
+  // 就是多一行噪音（"Data" 下面跟着 "Glove Sensor Data"）。
+  // 再加一个设备怎么办：往**任意已有的口**上拖即可，onConnect 会把 targetHandle
+  // 重写成新上游自己的 key，于是长出一个新口。
+  const inputPorts = useMemo(() => [
+    ...(dynamicInputs.length ? [] : (d.inputs || []).map((inp) => ({
+      key: inp.key,
+      originalLabel: inp.label,
+      label: portLabel(String(d.nodeType), inp.key, inp.label, lang),
+    }))),
+    ...dynamicInputs.map(([key, label]) => ({
+      key, originalLabel: label, label,
+    })),
+  ], [d.inputs, dynamicInputs, d.nodeType, lang]);
+
+  // 输出端口 = 动态口与输入口**一一对应**（同 key 同标签同顺序）；无入边时回落
+  // 到声明的口（reviewed）。
+  //
+  // 这正是 _migrateDynamicSourceHandles 已经写好的约定 —— 它会把指向下游的边
+  // 展开成 N 条、sourceHandle 设成动态 key（见 workflowStore）。渲染侧此前一直是
+  // 裸的 d.outputs，于是那些边指向了**从来不存在的 Handle**，功能只做了一半。
+  //
+  // ★ 动态口的 label **直接用**，不要再走 portLabel()：输入侧动态口就是不翻译的
+  //   裸 label，输出侧必须与它逐字一致（左右同名是明确要求）。
+  const outputPorts = useMemo(() => (
+    dynamicInputs.length
+      ? dynamicInputs.map(([key, label]) => ({ key, label }))
+      : (d.outputs || []).map((out) => ({
+          key: out.key,
+          label: portLabel(String(d.nodeType), out.key, out.label, lang),
+        }))
+  ), [d.outputs, dynamicInputs, d.nodeType, lang]);
+
   const resolveCameraSource = (value: string): DeviceInputSource | null => {
     const normalized = value.trim().toLowerCase();
     if (!normalized) return null;
@@ -119,7 +243,7 @@ export const WorkflowNodeComponent = memo(function WorkflowNodeComponent({ data,
     if (value === boundValue) return;  // 未改动 → 不弹窗
     const ok = await useUiStore.getState().confirm(
       `"${topField.label}" is overridden for this project ("${boundValue}"). Save "${value}" for this project only?`,
-      { title: 'Project override', confirmLabel: 'Save for this project' },
+      { title: t('node.projectOverride'), confirmLabel: t('node.saveForProject') },
     );
     if (!ok) return;
     useWorkflowStore.getState().setProjectBinding(id, value || null)
@@ -140,6 +264,11 @@ export const WorkflowNodeComponent = memo(function WorkflowNodeComponent({ data,
   const [showApiModal, setShowApiModal] = useState(false);
   const isAiAnnotation = d.nodeType === 'ai_annotation';
 
+  // Data Quality 走自己的设置弹窗 —— 按设备卡片分 tab,通用的 config_schema
+  // 那套平铺字段表达不了嵌套结构(见 DeviceQualityModal 的注释)。
+  const [showQualityModal, setShowQualityModal] = useState(false);
+  const isDataQuality = d.nodeType === 'data_quality';
+
   const updateTopConfig = (value: unknown, selectedSource: DeviceInputSource | null = null) => {
     if (!topField) return;
     const config = { ...d.config, [topField.name]: value };
@@ -165,18 +294,24 @@ export const WorkflowNodeComponent = memo(function WorkflowNodeComponent({ data,
     if (!isBound) return;
     const ok = await useUiStore.getState().confirm(
       'Clear this project override? The workflow default will be used again.',
-      { title: 'Clear project override', confirmLabel: 'Clear' },
+      { title: t('node.clearOverride'), confirmLabel: t('node.clear') },
     );
     if (!ok) return;
     useWorkflowStore.getState().setProjectBinding(id, null)
       .catch((e) => useUiStore.getState().pushToast(`Failed to clear binding: ${e?.message || e}`, 'error'));
   };
 
+  // 卡片高度**交给内容自己撑**（CSS: height:auto + min-height:90px），不再按端口数
+  // 估算。曾用过 ``端口数 * 22 + 42`` 的公式，但 22px/行 与实际行高对不上：估多了
+  // 卡片底部留一大片空白，估少了（比如只数了声明的 d.outputs、漏掉运行时才长出来的
+  // 动态输出口）内容就从底部溢出。让浏览器量实际内容，两种毛病都不会有 —— 端口多
+  // 卡片就高、端口少就矮，本来也就是想要的效果。
+
   return (
     <div className="workflow-node" title={desc} style={{
       borderColor: selected ? '#3b82f6' : d.color || '#334155',
       boxShadow: selected ? `0 0 0 2px ${d.color}33` : undefined,
-    }}>
+    } as React.CSSProperties}>
       <div className="node-header" style={{ backgroundColor: `${hdrColor}22`, borderBottom: `1px solid ${hdrColor}44` }}>
         <div className="node-title-row">
           <IconifyIcon icon={d.icon} className="text-[18px]" />
@@ -191,16 +326,24 @@ export const WorkflowNodeComponent = memo(function WorkflowNodeComponent({ data,
           )}
           {isAiAnnotation && (
             <button
-              title="AI annotation settings"
+              title={t('node.aiSettings')}
               onClick={(e) => { e.stopPropagation(); setShowApiModal(true); }}
               className="ml-1 text-[11px] text-cyan-400 border border-cyan-900 rounded px-1 cursor-pointer hover:bg-cyan-900/40 select-none">
               ⚙
             </button>
           )}
+          {isDataQuality && (
+            <button
+              title="质检设置(按设备配置检查项)"
+              onClick={(e) => { e.stopPropagation(); setShowQualityModal(true); }}
+              className="ml-1 text-[11px] text-cyan-400 border border-cyan-900 rounded px-1 cursor-pointer hover:bg-cyan-900/40 select-none">
+              ⚙
+            </button>
+          )}
           {isBound && (
             <span
               onClick={clearBinding}
-              title="Project override — click to clear"
+              title={t('node.clearOverrideHint')}
               className="ml-1 text-[9px] text-blue-400 border border-blue-800 rounded px-1 cursor-pointer hover:bg-blue-900/40 align-middle select-none">
               P
             </span>
@@ -209,15 +352,21 @@ export const WorkflowNodeComponent = memo(function WorkflowNodeComponent({ data,
       </div>
       <div className="node-body">
         {/* Input ports: handle on left edge, label next to it (left-aligned) */}
-        {(d.inputs || []).map((inp) => (
+        {inputPorts.map((inp) => (
           <div key={inp.key} className="node-port" style={{ justifyContent: 'flex-start', paddingLeft: 0 }}>
             <Handle type="target" position={Position.Left} id={inp.key} style={{ position: 'relative', left: -6, transform: 'none', flexShrink: 0 }} />
-            <span>{inp.label}</span>
+            {/* 泛化端口显示上游端口名；原文案留作 hover 提示。
+                动态端口每个口只对应一条边，标签就是那条边的上游端口名。 */}
+            <span title={inp.originalLabel}>{inp.label}</span>
           </div>
         ))}
         {/* Output ports: label next to handle, handle on right edge (right-aligned) */}
-        {(d.outputs || []).map((out) => (
+        {outputPorts.map((out) => (
           <div key={out.key} className="node-port" style={{ justifyContent: 'flex-end', paddingRight: 0 }}>
+            {/* 声明口仍用原文案 —— 之前让透传节点的输出也跟着显示数据种类，结果
+                同一张卡上下两行是同一串文字，看着很乱；输出是本节点产出的什么，
+                用声明文案更清楚。**动态口例外**：它与输入侧逐字一致，见 outputPorts
+                上方的注释。 */}
             <span>{out.label}</span>
             <Handle type="source" position={Position.Right} id={out.key} style={{ position: 'relative', right: -6, transform: 'none', flexShrink: 0 }} />
           </div>
@@ -226,6 +375,9 @@ export const WorkflowNodeComponent = memo(function WorkflowNodeComponent({ data,
       {showApiModal && (
         <NodeSettingsModal nodeId={id} onClose={() => setShowApiModal(false)} />
       )}
+      {showQualityModal && (
+        <DeviceQualityModal nodeId={id} onClose={() => setShowQualityModal(false)} />
+      )}
     </div>
   );
 });
@@ -358,6 +510,15 @@ function getTopConfigField(data: WorkflowNodeData): ConfigField | null {
       default: 'local', options: ['local', 'api'],
     };
   }
+  if (data.nodeType === 'data_cleaning') {
+    // 异常处理方式,直接放头部 —— 检查哪些类型、阈值多少在 configSchema 里,
+    // 由后端 catalog 提供(与 mediapipe_hand 的 device 同款:优先读后端 schema,
+    // 读不到才用这里的兜底),避免前端硬编码与后端不一致。
+    return schema.find((field) => field.name === 'on_failure') || {
+      name: 'on_failure', type: 'select', label: 'On failure', default: 'review',
+      options: ['review', 'warn', 'block'],
+    };
+  }
   return null;
 }
 
diff --git a/processor/web/workflow-studio/src/components/WorkflowCanvas/nodes/registry.ts b/processor/web/workflow-studio/src/components/WorkflowCanvas/nodes/registry.ts
index 987451018cf7a39f6e7a8e6985c511ea6373364e..c6d176bc9c03bcca695bbe96ca4fcc6c1dfd3eef 100644
--- a/processor/web/workflow-studio/src/components/WorkflowCanvas/nodes/registry.ts
+++ b/processor/web/workflow-studio/src/components/WorkflowCanvas/nodes/registry.ts
@@ -9,6 +9,9 @@ export const LEGACY_NODE_TYPE_ALIASES: Record<string, string> = {
   black_hand_rgb_3d: 'rgb_to_2d_black_glove',
   stereo_triangulate: 'rgbd_to_3d_bare_hand',
   black_glove_hand: 'rgbd_to_3d_black_glove',
+  // 质量门禁两个卡片合并为 data_quality，端口 key(data / reviewed)保持不变
+  ai_quality_review: 'data_quality',
+  data_cleaning: 'data_quality',
 };
 
 /** Canonical labels are part of the editor contract, not server-provided copy. */
@@ -91,10 +94,6 @@ const CANONICAL_PORTS: Record<string, Pick<NodeTypeDescriptor, 'inputs' | 'outpu
     inputs: [{ key: 'data', label: 'Review Target' }],
     outputs: [{ key: 'reviewed', label: 'Reviewed Data' }],
   },
-  ai_quality_review: {
-    inputs: [{ key: 'data', label: 'Quality Review Target' }],
-    outputs: [{ key: 'reviewed', label: 'Reviewed Data' }],
-  },
   lerobot_export: {
     inputs: [{ key: 'data', label: 'Exportable Data' }],
     outputs: [{ key: 'dataset', label: 'Dataset' }],
@@ -110,12 +109,40 @@ export function canonicalNodeType(type: string): string {
   return LEGACY_NODE_TYPE_ALIASES[raw.toLowerCase()] || raw;
 }
 
+// ── 变更订阅 ──────────────────────────────────────────────
+//
+// registry 是**模块级 Map**，不是 React state —— 往里塞节点不会触发重渲染。
+// 而 App 挂载后才会异步拉 /modules 并 hydrate 一次（见 App.tsx），
+// 「UMI Slam Action」这类**不在 BUILTIN 兜底清单里**的节点因此要等到
+// **别的无关状态变化**（输入搜索、折叠分类、鼠标悬停出提示……）才顺带出现，
+// 表现为"进入工作流页面后要等一会才刷新"。
+//
+// 这里给注册表配一个版本号 + 订阅，UI 用 useSyncExternalStore 订阅它，
+// hydrate 完立刻重渲染。
+let revision = 0;
+const listeners = new Set<() => void>();
+
+export function subscribeNodeTypes(listener: () => void): () => void {
+  listeners.add(listener);
+  return () => { listeners.delete(listener); };
+}
+
+export function getNodeTypesRevision(): number {
+  return revision;
+}
+
+function notifyNodeTypesChanged() {
+  revision += 1;
+  listeners.forEach((listener) => listener());
+}
+
 export function registerNodeType(n: NodeTypeDescriptor) {
   const type = canonicalNodeType(n.type);
   const normalized = type === n.type ? n : { ...n, type, slug: type };
   registry.set(type, CANONICAL_NODE_LABELS[type]
     ? { ...normalized, label: CANONICAL_NODE_LABELS[type] }
     : normalized);
+  notifyNodeTypesChanged();
 }
 export function getNodeType(type: string) {
   return registry.get(canonicalNodeType(type));
@@ -182,16 +209,8 @@ export function hydrateNodeTypes(items: Array<Partial<NodeTypeDescriptor> & { sl
       capabilities: item.capabilities || [],
     });
   }
-}
-
-/** Max port rows across all registered nodes — used for uniform card height. */
-export function getMaxPortRows(): number {
-  let max = 1;
-  for (const n of registry.values()) {
-    const rows = (n.inputs?.length || 0) + (n.outputs?.length || 0);
-    if (rows > max) max = rows;
-  }
-  return max;
+  // 一次性通知 —— 循环里逐条通知会让调色板重渲染 N 次
+  notifyNodeTypesChanged();
 }
 
 // ── Built-in nodes ────────────────────────────────────
@@ -352,10 +371,13 @@ const BUILTIN: NodeTypeDescriptor[] = [
     defaultConfig: { required: true, reviewers: 1 },
   },
   {
-    type: 'ai_quality_review', category: 'review', label: 'AI Quality Review',
-    icon: 'ant-design:robot-outlined', color: MODULE_COLORS.review,
-    description: 'Checks video decode, frame continuity, black screens, freezes, and AI annotation coverage before automatic approval and export.',
-    inputs: [{ key: 'data', label: 'Quality Review Target' }],
+    // type 必须写 canonical 名：registerNodeType 会 canonicalNodeType() 一次，
+    // 写成旧 slug 'ai_quality_review' 也只会注册到 'data_quality' 这个键上，
+    // 但 label 却留在兜底里 —— 水合完成前卡片会短暂显示旧名。
+    type: 'data_quality', category: 'review', label: 'Data Cleaning',
+    icon: 'ant-design:check-circle-outlined', color: MODULE_COLORS.review,
+    description: 'Runs deterministic quality checks (video, UMI gripper, tactile glove) and sends failed batches back to manual review.',
+    inputs: [{ key: 'data', label: 'Data' }],
     outputs: [{ key: 'reviewed', label: 'Reviewed Data' }],
     defaultConfig: { mode: 'gate' },
   },
diff --git a/processor/web/workflow-studio/src/i18n.ts b/processor/web/workflow-studio/src/i18n.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4c8153dd45744c4b4efd7b798bcedaf2b401d194
--- /dev/null
+++ b/processor/web/workflow-studio/src/i18n.ts
@@ -0,0 +1,223 @@
+/** Workflow Studio 的中英切换。
+ *
+ * 这是**独立的 React 应用**，不加载 `web/static/js/i18n.js`（那套是给 Jinja 模板
+ * 用的）。两边靠两个约定打通：
+ *
+ *   1. 同一个 localStorage 键 `lang` —— 模板侧 `setLang()` 写、这里读，刷新后一致
+ *   2. 自定义事件 `egodata:lang` —— 模板侧切换时派发，这里监听
+ *
+ * ★ 为什么不用 `storage` 事件：那个**只在别的标签页**触发，同一个标签页里
+ *   localStorage 变了它不会响。而语言切换按钮就在本页的侧边栏上，正好是同标签页。
+ *
+ * 缺词时回落 key 本身（如 `palette.search`）而不是静默显示英文 —— 漏翻译一眼看得见。
+ */
+import { useEffect, useMemo, useState } from 'react';
+
+export type Lang = 'en' | 'zh';
+
+const LANG_KEY = 'lang';
+const LANG_EVENT = 'egodata:lang';
+
+/** 当前语言。默认英文（与模板侧一致）。隐私模式禁 storage 时回落默认。 */
+export function currentLang(): Lang {
+  try {
+    return localStorage.getItem(LANG_KEY) === 'zh' ? 'zh' : 'en';
+  } catch {
+    return 'en';
+  }
+}
+
+const DICT: Record<string, { en: string; zh: string }> = {
+  // ── 调色板 ──
+  'palette.input': { en: 'Input', zh: '输入' },
+  'palette.review': { en: 'Review', zh: '审核' },
+  'palette.process': { en: 'Process', zh: '处理' },
+  'palette.export': { en: 'Export', zh: '导出' },
+  'palette.search': { en: 'Search nodes...', zh: '搜索节点...' },
+  'palette.hint': { en: 'Drag nodes onto canvas', zh: '拖拽节点到画布' },
+
+  // ── 工具栏 ──
+  'toolbar.new': { en: 'New', zh: '新建' },
+  'toolbar.save': { en: 'Save', zh: '保存' },
+  'toolbar.saveAs': { en: 'Save As', zh: '另存为' },
+  'toolbar.export': { en: 'Export', zh: '导出' },
+  'toolbar.workflowList': { en: 'Workflow list', zh: '工作流列表' },
+  'toolbar.run': { en: 'Run', zh: '运行' },
+
+  // ── 通用 ──
+  'common.cancel': { en: 'Cancel', zh: '取消' },
+  'common.save': { en: 'Save', zh: '保存' },
+  'common.loading': { en: 'Loading...', zh: '加载中...' },
+
+  // ── AI 标注设置弹窗 ──
+  'ai.vendor': { en: 'API vendor', zh: 'API 供应商' },
+  'ai.model': { en: 'API model', zh: 'API 模型' },
+  'ai.key': { en: 'API key (stored with this workflow)', zh: 'API Key（随本工作流保存）' },
+  'ai.labelLanguage': { en: 'Label language', zh: '标注语言' },
+
+  // ── 抽屉 / 连线 / 节点 ──
+  'drawer.workflows': { en: 'Workflows', zh: '工作流' },
+  'drawer.noWorkflows': { en: 'No workflows yet', zh: '暂无工作流' },
+  'edge.delete': { en: 'Delete connection', zh: '删除连线' },
+  'node.projectOverride': { en: 'Project override', zh: '项目级覆盖' },
+  'node.saveForProject': { en: 'Save for this project', zh: '仅保存到本项目' },
+  'node.clearOverride': { en: 'Clear project override', zh: '清除项目级覆盖' },
+  'node.clear': { en: 'Clear', zh: '清除' },
+  'node.clearOverrideHint': { en: 'Project override — click to clear', zh: '项目级覆盖 —— 点击清除' },
+  'node.aiSettings': { en: 'AI annotation settings', zh: 'AI 标注设置' },
+  'node.aiSettingsShort': { en: 'Data quality settings', zh: '数据质检设置' },
+
+  // ── AI 设置弹窗的测试结果 ──
+  'ai.modelRequired': { en: 'Model required', zh: '请先填写模型' },
+  'ai.keyRequired': { en: 'API key required', zh: '请先填写 API Key' },
+  'ai.testFailed': { en: 'Test failed', zh: '测试失败' },
+  'ai.requestFailed': { en: 'Request failed', zh: '请求失败' },
+  'ai.networkError': { en: 'network error', zh: '网络错误' },
+  'ai.appliesNextRun': { en: 'Applies to the next AI annotation run.', zh: '对下一次 AI 标注生效。' },
+  'common.close': { en: 'Close', zh: '关闭' },
+
+  // ── 画布提示 ──
+  'toast.dupEdge': { en: 'Already connected: this port pair is already linked.',
+                     zh: '已连接：这条端口对已经连过了。' },
+  'toast.selfEdge': { en: 'Self-connection is not allowed', zh: '不能连接到自身' },
+  'toast.cannotConnect': { en: 'Cannot connect: ', zh: '无法连接：' },
+  'toast.portMismatch': {
+    en: 'Port mismatch: this input expects different data.',
+    zh: '端口类型不匹配：这个输入要的数据类型与上游输出不同。' },
+  'toast.stereoPair': { en: 'Stereo pair connected', zh: '双目已配对连接' },
+
+  // ── 数据清洗设置弹窗 ──
+  'quality.title': { en: 'Data Cleaning · Settings', zh: '数据清洗 · 设置' },
+  'quality.loadFailed': { en: 'Failed to load the check catalog: ', zh: '加载检查项目录失败：' },
+  'quality.noDevice': { en: 'This node has no device connected yet', zh: '该节点还没有连接任何设备' },
+  'quality.noChecks': { en: 'has no checks available yet', zh: '暂时没有可用的检查项' },
+
+  // ── 顶栏 ──
+  'app.template': { en: 'Template', zh: '模板' },
+  'app.makeTemplate': { en: 'Make Template', zh: '设为模板' },
+  'app.save': { en: 'Save', zh: '保存' },
+  'app.del': { en: 'Del', zh: '删除' },
+  'app.cancel': { en: 'Cancel', zh: '取消' },
+  'app.newWorkflow': { en: 'New Workflow', zh: '新建工作流' },
+  'app.startFromTemplate': { en: 'Start from Template', zh: '从模板开始' },
+  'app.unsetTemplate': { en: 'Unset Template', zh: '取消模板' },
+  'app.noTemplates': { en: 'No templates available — an admin can mark workflows as templates.',
+                      zh: '暂无模板 —— 管理员可将工作流标记为模板。' },
+  'app.templateHint': { en: 'Applying a template replaces the current canvas — your workflow name and ID stay the same.',
+                       zh: '应用模板会替换当前画布 —— 工作流名称与 ID 保持不变。' },
+};
+
+export function translate(key: string, lang: Lang): string {
+  const entry = DICT[key];
+  if (!entry) return key;
+  return entry[lang] || entry.en;
+}
+
+// ── 节点卡片名 ──────────────────────────────────────────────
+//
+// 卡片名是**后端声明的**（module_catalog 的 label），前端只是显示。这里给中文
+// 对照，key = 模块 slug。查不到就回落到英文原文 —— 后端新增模块时不会显示成
+// 空白的 key。
+const NODE_LABELS_ZH: Record<string, string> = {
+  mono_camera: 'RGB 相机',
+  rgb_camera: 'RGB 相机',
+  fisheye_camera: 'RGB 相机',
+  rgbd_camera: 'RGB-D 相机',
+  stereo_camera: '双目 RGB 相机',
+  stereo_rgbd_camera: '双目 RGB-D 相机',
+  glove_sensor: '触觉手套',
+  gripper_device: 'UMI 夹爪',
+  ai_annotation: 'AI 标注',
+  annotation: '人工标注',
+  mediapipe_hand: 'MediaPipe 手部',
+  rgb_to_2d_bare_hand: 'RGB_2D_裸手',
+  rgb_to_2d_black_glove: 'RGB_2D_黑手套',
+  rgbd_to_3d_bare_hand: 'RGB-D_3D_裸手',
+  rgbd_to_3d_black_glove: 'RGB-D_3D_黑手套',
+  umi_slam_action: 'UMI SLAM 动作',
+  data_quality: '数据清洗',
+  human_review: '人工审核',
+  lerobot_export: 'LeRobot 导出',
+  hdf5_export: 'HDF5 导出',
+};
+
+/** 相机卡的分类名走的是另一条路（cameraCategoryLabel 直接返回展示串），
+ *  按英文原文再兜一层。 */
+const DISPLAY_LABELS_ZH: Record<string, string> = {
+  'RGB Camera': 'RGB 相机',
+  'Stereo RGB Camera': '双目 RGB 相机',
+  'RGB-D Camera': 'RGB-D 相机',
+  'Stereo RGB-D Camera': '双目 RGB-D 相机',
+  'Glove Sensor': '触觉手套',
+  'UMI Gripper': 'UMI 夹爪',
+};
+
+export function nodeLabel(type: string, fallback: string, lang: Lang): string {
+  if (lang !== 'zh') return fallback;
+  return NODE_LABELS_ZH[type] || DISPLAY_LABELS_ZH[fallback] || fallback;
+}
+
+// ── 端口名 ──────────────────────────────────────────────────
+//
+// key 用 ``*:端口key`` 表示"所有节点都这么叫"，``节点:端口key`` 用于同一个
+// 端口在不同卡上叫法不同的情况 —— 最典型的是 ``data``：导出卡上是"可导出数据"，
+// 质检卡上就是"数据"，审核卡上是"待审核数据"。只按端口 key 查会串味。
+const PORT_LABELS_ZH: Record<string, string> = {
+  '*:video': 'RGB 视频',
+  '*:depth': '深度',
+  '*:video_left': '左目 RGB 视频',
+  '*:video_right': '右目 RGB 视频',
+  '*:rgb_video': 'RGB 视频',
+  '*:gripper_state': 'ESP 夹爪状态',
+  '*:slam_trajectory': 'SLAM 轨迹',
+  '*:tactile_force_matrices': '左右力矩阵',
+  '*:sensor_data': '手套传感器数据',
+  '*:annotation': '标注',
+  '*:hand_keypoints': '手部 2D',
+  '*:hand_3d': '手部 3D',
+  '*:action': '动作',
+  '*:reviewed': '已审核数据',
+  '*:dataset': '数据集',
+  'data_quality:data': '数据',
+  'human_review:data': '待审核数据',
+  'lerobot_export:data': '可导出数据',
+  'hdf5_export:data': '可导出数据',
+  'ai_annotation:data': 'RGB 视频',
+  'annotation:data': 'RGB 视频',
+};
+
+export function portLabel(
+  nodeType: string, key: string, fallback: string, lang: Lang,
+): string {
+  if (lang !== 'zh') return fallback;
+  return PORT_LABELS_ZH[`${nodeType}:${key}`] || PORT_LABELS_ZH[`*:${key}`] || fallback;
+}
+
+/**
+ * 订阅当前语言，返回一个取词函数。
+ *
+ * 语言变化时**所有用到它的组件都会重渲染** —— 这正是需要的：调色板、工具栏、
+ * 节点卡片都要跟着换文字。
+ */
+export function useLang(): Lang {
+  const [lang, setLang] = useState<Lang>(currentLang);
+
+  useEffect(() => {
+    const onChange = () => setLang(currentLang());
+    window.addEventListener(LANG_EVENT, onChange);
+    // 兜底：万一别处（如 devtools）直接改了 localStorage 而没派发事件
+    window.addEventListener('storage', onChange);
+    return () => {
+      window.removeEventListener(LANG_EVENT, onChange);
+      window.removeEventListener('storage', onChange);
+    };
+  }, []);
+
+  return lang;
+}
+
+/** 取词函数。需要节点名/端口名的组件再单独调 useLang()。 */
+export function useT(): (key: string) => string {
+  const lang = useLang();
+  return useMemo(() => (key: string) => translate(key, lang), [lang]);
+}
diff --git a/processor/web/workflow-studio/src/index.css b/processor/web/workflow-studio/src/index.css
index e512d004d28245e667a99caf6f4492be131b840f..292e838b5984ef4f1f98748c7718de89f42c0cee 100644
--- a/processor/web/workflow-studio/src/index.css
+++ b/processor/web/workflow-studio/src/index.css
@@ -10,7 +10,7 @@
 
 .workflow-node {
   background: #111827; border: 2px solid #374151; border-radius: 8px;
-  width: 280px !important; height: var(--node-card-height, 90px);
+  width: 280px !important; height: auto; min-height: 90px;
   box-sizing: border-box;
   font-size: 13px; color: #e5e7eb;
   box-shadow: 0 4px 12px rgba(0,0,0,.4); transition: border-color .15s, box-shadow .15s;
@@ -32,3 +32,21 @@
 .react-flow__handle:hover { background: #3b82f6 !important; border-color: #3b82f6 !important; }
 .react-flow__handle-connecting { background: #f59e0b !important; border-color: #f59e0b !important; }
 .react-flow__handle-valid { background: #22c55e !important; border-color: #22c55e !important; }
+
+/* 深色界面的滚动条 —— 浏览器默认是浅色粗条，配深色面板非常突兀。
+   默认做成接近隐藏的细条，悬停/滚动时才明显一点。 */
+.dark-scroll { scrollbar-width: thin; scrollbar-color: #334155 transparent; }
+.dark-scroll::-webkit-scrollbar { width: 8px; height: 8px; }
+.dark-scroll::-webkit-scrollbar-track { background: transparent; }
+.dark-scroll::-webkit-scrollbar-thumb {
+  background: #334155; border-radius: 4px;
+  /* 用透明边框把滑块"缩"进去，视觉上更细，且不占额外宽度 */
+  border: 2px solid transparent; background-clip: content-box;
+}
+.dark-scroll::-webkit-scrollbar-thumb:hover { background: #475569; background-clip: content-box; }
+.dark-scroll::-webkit-scrollbar-corner { background: transparent; }
+
+/* 弹窗挂到 document.body —— 脱离 React Flow 的缩放/平移容器。
+   见 DeviceQualityModal 顶部注释：transform 会给后代创建新的包含块，
+   导致 position:fixed 的弹窗跟着画布缩放，在画布外还会偏出屏幕。 */
+.modal-portal { position: fixed; inset: 0; z-index: 100; }
diff --git a/processor/web/workflow-studio/src/store/workflowStore.ts b/processor/web/workflow-studio/src/store/workflowStore.ts
index 3bd4eed9406462aba7be4b43c9d26e518315a393..bcc689429b0b72149eac2352feb209d0930f298e 100644
--- a/processor/web/workflow-studio/src/store/workflowStore.ts
+++ b/processor/web/workflow-studio/src/store/workflowStore.ts
@@ -6,6 +6,7 @@ import * as api from '../api/workflows';
 import { getProjectInputSources, getProjectBindings, putProjectBinding } from '../api/projects';
 import { getDeviceInputSources } from '../api/devices';
 import { canonicalNodeType, getNodeType } from '../components/WorkflowCanvas/nodes/registry';
+import { currentLang, translate } from '../i18n';
 import { useUiStore } from './uiStore';
 
 interface HistoryEntry {
@@ -268,7 +269,10 @@ function _migrateWorkflowGraph(graph: { nodes?: Node<WorkflowNodeData>[]; edges?
     let nextHandle = sourceHandle;
     const resultOutput = sourceType === 'annotation' || sourceType === 'ai_annotation'
       ? 'annotation'
-      : sourceType === 'human_review' || sourceType === 'ai_quality_review'
+      // 判的是 canonicalNodeType() 之后的类型，所以写新名 —— 之前写旧 slug
+      // 'ai_quality_review' 永远匹配不上。后端 workflow_types.py 用的是
+      // {"human_review", "data_quality"}，这行本来就该与它一致。
+      : sourceType === 'human_review' || sourceType === 'data_quality'
         ? 'reviewed'
         : '';
     if (resultOutput && sourceHandle === 'result') {
@@ -343,14 +347,18 @@ function _hydrateNode(node: Node<WorkflowNodeData>): Node<WorkflowNodeData> {
     'stereo_rgbd_camera',
     'rgbd_to_3d_bare_hand', 'rgb_to_2d_bare_hand',
     'rgbd_to_3d_black_glove', 'rgb_to_2d_black_glove', 'annotation', 'ai_annotation',
-    'human_review', 'ai_quality_review', 'lerobot_export', 'hdf5_export',
-    'gripper_device',
+    'human_review', 'lerobot_export', 'hdf5_export', 'gripper_device',
+    // ★ 这里判的是 canonicalNodeType() **之后**的类型，所以必须写新名。
+    //   之前写的是旧 slug 'ai_quality_review' —— 永远匹配不上（nodeType 那时已经是
+    //   'data_quality'），于是老图一直显示存下来的旧标签 "AI Quality Review"。
+    'data_quality',
   ]);
   const controlledPorts = new Set([
     'rgb_camera', 'mono_camera', 'fisheye_camera', 'rgbd_camera',
     'stereo_camera', 'stereo_rgbd_camera', 'glove_sensor', 'gripper_device', 'mediapipe_hand', 'annotation',
-    'ai_annotation', 'human_review', 'ai_quality_review', 'lerobot_export',
-    'hdf5_export',
+    'ai_annotation', 'human_review', 'lerobot_export', 'hdf5_export',
+    // 同上：写 canonical 名，否则端口用的是图里存下来的旧值
+    'data_quality',
     'rgbd_to_3d_bare_hand', 'rgb_to_2d_bare_hand',
     'rgbd_to_3d_black_glove', 'rgb_to_2d_black_glove',
   ]);
@@ -379,13 +387,93 @@ function _hydrateNode(node: Node<WorkflowNodeData>): Node<WorkflowNodeData> {
 }
 
 /** Normalize a graph from either the API or an old localStorage draft. */
+/** 输入端口按**入边**动态生成的节点类型 —— 目前只有数据质检这一张卡。 */
+export const DYNAMIC_INPUT_TYPES = new Set(['data_quality']);
+
+/** 一条入边在动态端口节点上对应的输入 key。稳定可重复：同一个上游重连仍是同一个口。 */
+export function dynamicInputKey(sourceId: string, sourceHandle?: string | null): string {
+  return `${sourceId}:${sourceHandle || ''}`;
+}
+
+/**
+ * 把指向动态端口节点的边的 ``targetHandle`` 迁成动态 key。
+ *
+ * 老图里这些边全指向统一的 ``"data"``。不迁的话，节点改成按入边画口之后，
+ * 边会指着一个不存在的口 —— 画面上表现为**断线**。
+ *
+ * 幂等：已经是动态 key 的边原样返回。只在打开工作流时跑，保存后才落盘。
+ */
+function _migrateDynamicTargetHandles(
+  nodes: Node<WorkflowNodeData>[] | undefined,
+  edges: Edge[] | undefined,
+): Edge[] {
+  const types = new Map(
+    (nodes || []).map((n) => [String(n.id), canonicalNodeType(n.data?.nodeType)]),
+  );
+  return (edges || []).map((edge) => {
+    if (!DYNAMIC_INPUT_TYPES.has(types.get(String(edge.target)) || '')) return edge;
+    const wanted = dynamicInputKey(String(edge.source), edge.sourceHandle);
+    return edge.targetHandle === wanted ? edge : { ...edge, targetHandle: wanted };
+  });
+}
+
+/**
+ * 动态端口节点的**输出**口与输入一一对应（同 key 同标签），所以指向下游的边也要跟着改。
+ *
+ * 老图的边 sourceHandle 是 ``"reviewed"``（现在没有这个口了）。
+ *
+ * ★ 必须**展开成 N 条**，不能只把它改成某一个动态 key —— 实测对比：
+ *     1 条边 sourceHandle=reviewed              → 下游收到 3 项（规则 3 平铺全部输出）
+ *     1 条边 sourceHandle=node_cam:video_left   → 下游收到 **1 项**（规则 2 只取那一个）
+ *     3 条边，各一个动态 key                     → 下游收到 3 项，无重复
+ *   所以"改成第一个 key"会**静默丢掉其余几路**。展开成 N 条则每条命中规则 2，
+ *   各取一路、合起来正好是全部，且不会重复（规则 1 的 #N 后缀用不上）。
+ *
+ * 无入边时不出动态口，声明的 ``reviewed`` 仍在，边原样保留。幂等。
+ */
+function _migrateDynamicSourceHandles(
+  nodes: Node<WorkflowNodeData>[] | undefined,
+  edges: Edge[] | undefined,
+): Edge[] {
+  const list = edges || [];
+
+  // 每个动态端口节点的输出口 = 它的输入口（顺序即渲染顺序）
+  const keysByNode = new Map<string, string[]>();
+  for (const node of nodes || []) {
+    if (DYNAMIC_INPUT_TYPES.has(canonicalNodeType(node.data?.nodeType))) {
+      keysByNode.set(String(node.id), []);
+    }
+  }
+  if (!keysByNode.size) return list;
+  for (const edge of list) {
+    const keys = keysByNode.get(String(edge.target));
+    if (!keys) continue;
+    const key = dynamicInputKey(String(edge.source), edge.sourceHandle);
+    if (!keys.includes(key)) keys.push(key);
+  }
+
+  const out: Edge[] = [];
+  for (const edge of list) {
+    const keys = keysByNode.get(String(edge.source));
+    if (!keys || keys.length === 0) { out.push(edge); continue; }   // 无入边 → 保持 reviewed
+    if (keys.includes(String(edge.sourceHandle ?? ''))) { out.push(edge); continue; }
+    for (const key of keys) {
+      out.push({ ...edge, id: `${edge.id}__${key}`, sourceHandle: key });
+    }
+  }
+  return out;
+}
+
+
 export function normalizeWorkflowGraphForEditor(
   graph: { nodes?: Node<WorkflowNodeData>[]; edges?: Edge[] },
 ) {
   const migrated = _migrateWorkflowGraph(graph);
   return {
     nodes: (migrated.nodes || []).map(_hydrateNode),
-    edges: migrated.edges || [],
+    // 输入口先迁（边的 targetHandle 定下来），输出口才有所依据
+    edges: _migrateDynamicSourceHandles(
+      migrated.nodes, _migrateDynamicTargetHandles(migrated.nodes, migrated.edges)),
   };
 }
 
@@ -551,12 +639,25 @@ export const useWorkflowStore = create<WorkflowState>((set, get) => ({
       const inpLabel = tgt?.data?.inputs?.find((i) => i.key === (conn.targetHandle || tgt?.data?.inputs?.[0]?.key))?.label
         || tgt?.data?.inputs?.[0]?.label || 'input';
       const srcOut = src?.data?.outputs?.find((o) => o.key === (conn.sourceHandle || src?.data?.outputs?.[0]?.key));
+      // store 不是组件，不能调 hook —— 直接取当前语言翻译
+      const tt = (k: string) => translate(k, currentLang());
       const hint = srcOut && srcOut.key !== 'data'
-        ? `Port mismatch: this input only accepts "${inpLabel}" data, but "${srcOut.label || srcOut.key}" outputs "${srcOut.key}"`
-        : 'Self-connection is not allowed';
-      useUiStore.getState().pushToast(`Cannot connect: ${hint}`, 'error');
+        ? `${tt('toast.portMismatch')} (${inpLabel} ← ${srcOut.label || srcOut.key})`
+        : tt('toast.selfEdge');
+      useUiStore.getState().pushToast(`${tt('toast.cannotConnect')}${hint}`, 'error');
       return s;
     }
+    // Data Quality 的输入端口按**入边**动态生成（一条线一个口），所以落点要重写成
+    // 这条边专属的 key，而不是所有线共用的 "data"。
+    //
+    // 挂在有效性检查之后：isConnectionValid 读的是**声明的**端口（data），
+    // 换成动态 key 它找不到会回落到 inputs[0]，语义不变，但没必要多绕一层。
+    const targetNodeType = canonicalNodeType(
+      s.nodes.find((n) => n.id === conn.target)?.data?.nodeType ?? '');
+    const next = DYNAMIC_INPUT_TYPES.has(targetNodeType)
+      ? { ...conn, targetHandle: dynamicInputKey(conn.source, conn.sourceHandle) }
+      : conn;
+
     // 重复连线检查:同一 源端口→目标端口 已存在时阻止再次添加。
     // React Flow 同边 id 冲突会导致后加的连线不显示(看起来"没连上")。
     const isDup = (c: typeof conn) => s.edges.some((e) =>
@@ -564,11 +665,11 @@ export const useWorkflowStore = create<WorkflowState>((set, get) => ({
       && e.target === c.target
       && (e.sourceHandle || null) === (c.sourceHandle || null)
       && (e.targetHandle || null) === (c.targetHandle || null));
-    if (isDup(conn)) {
-      useUiStore.getState().pushToast('Already connected: this port pair is already linked.', 'error');
+    if (isDup(next)) {
+      useUiStore.getState().pushToast(translate('toast.dupEdge', currentLang()), 'error');
       return s;
     }
-    let edges = addEdge(conn, s.edges);
+    let edges = addEdge(next, s.edges);
 
     // 双目打包连线:Stereo Video 卡(输出 video_left + video_right 双端口)
     // 任一端口连到目标时,自动把另一端口也连到同一目标输入 ——
@@ -582,13 +683,27 @@ export const useWorkflowStore = create<WorkflowState>((set, get) => ({
       const mainHandle = conn.sourceHandle || 'video_left';
       const sibling = mainHandle === 'video_left' ? 'video_right' : 'video_left';
       const siblingConn = {
-        ...conn,
+        ...next,
         sourceHandle: sibling,
+        // ★ 动态端口节点的 targetHandle 是**按源端口算出来的**
+        //   （dynamicInputKey(源, 源端口)），换了源端口就必须重算。
+        //
+        //   不重算的后果：配对边指向的是主端口，而 isDup() 恰好按 targetHandle
+        //   判重 —— 于是用户再手动连"另一目"时判成"没连过"，加出**第二条同源
+        //   端口的边**；dynamicInputKey 对两条边算出同一个 key，画布上就出现
+        //   两个同名输入口（实测：Stereo RGB-D 的 3 个输出 → 4 个输入口，
+        //   其中 "Left RGB Video" 重复）。
+        //
+        //   普通节点（targetHandle 恒为 "video" 之类）主副相同，所以这个 bug
+        //   一直没暴露 —— 是动态端口把它揭出来的。
+        ...(DYNAMIC_INPUT_TYPES.has(targetNodeType)
+            ? { targetHandle: dynamicInputKey(conn.source, sibling) }
+            : {}),
       };
       if (!isDup(siblingConn) && isConnectionValid(siblingConn, s.nodes)) {
         edges = addEdge(siblingConn, edges);
         useUiStore.getState().pushToast(
-          `Stereo pair connected: ${mainHandle} + ${sibling} both linked.`, 'info');
+          `${translate('toast.stereoPair', currentLang())}: ${mainHandle} + ${sibling}`, 'info');
       }
     }
     saveDraft({ ...s, edges });