Initial HF Spaces deployment

.gitignore

@@ -0,0 +1,258 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+#poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+#pdm.lock
+#pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+#pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Abstra
+# Abstra is an AI-powered process automation framework.
+# Ignore directories containing user credentials, local state, and settings.
+# Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#  and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#  you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor
+#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+output
+
+videos
+
+datasets/images
+datasets/labels
+datasets/coco8
+.DS_store
+outputs
+yolo11n.pt
+yolo11s.pt
+best.pt
+**/best.pt
+
+.claude
+
+runs
+.idea
+working_dir
+data
+upload_to_huggingface.py
+resources/best.pt
+resources/model_version.json
+.web
+examples
+resources/checkpoint
+
+
+frontend/node_modules
+
+*.nsys-rep
+*.qdstrm
+# profile/profile_e2fgvi_hq.nsys-rep
+*.npy
+profiling/
+
+profile/*.qdrep
+profile/*.nsys-rep
+profile/*.qdstrm
+profile/*.sqlite
+profile/*.trace
+profile/*.trace.json
+profile/*.trace.json.gz
+profile/*.trace.json.gz.part
+profile/*.trace.json.gz.part.1
+profile/*.trace.json.gz.part.2
+profile/*.trace.json.gz.part.3
+profile/*.trace.json.gz.part.4
+profile/*.trace.json.gz.part.5assests/*.mp4
+resources/*.mp4
+resources/*.png

.python-version

@@ -0,0 +1 @@
+3.12

.streamlit/config.toml

@@ -0,0 +1,3 @@
+[server]
+maxUploadSize=4096 
+# 4GB as maximum

Dockerfile

@@ -0,0 +1,80 @@
+FROM python:3.12-slim
+
+# System dependencies
+RUN apt-get update && apt-get install -y \
+    ffmpeg \
+    git \
+    curl \
+    build-essential \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install uv
+RUN pip install uv
+
+WORKDIR /app
+
+# Copy project files
+COPY pyproject.toml .
+COPY sorawm/ sorawm/
+COPY app.py .
+COPY start_server.py .
+COPY .streamlit/ .streamlit/
+COPY model_version.json .
+
+# Create required directories
+RUN mkdir -p resources/checkpoint output working_dir logs data frontend/dist/assets
+
+# Install Python dependencies (skip mmcv-full which needs special build)
+RUN uv pip install --system --no-cache \
+    aiofiles \
+    aiosqlite \
+    diffusers \
+    einops \
+    "fastapi==0.108.0" \
+    ffmpeg-python \
+    fire \
+    greenlet \
+    httpx \
+    huggingface-hub \
+    loguru \
+    omegaconf \
+    opencv-python-headless \
+    pandas \
+    pydantic \
+    python-multipart \
+    requests \
+    rich \
+    ruptures \
+    scikit-learn \
+    sqlalchemy \
+    streamlit \
+    "torch>=2.5.0" \
+    "torchvision>=0.20.0" \
+    tqdm \
+    transformers \
+    ultralytics \
+    uvicorn
+
+# Download YOLO weights and E2FGVI checkpoint at build time
+RUN python -c "\
+import os, requests; \
+os.makedirs('resources/checkpoint', exist_ok=True); \
+print('Downloading YOLO weights...'); \
+import json; \
+mv = json.load(open('model_version.json')); \
+url = mv.get('url', 'https://github.com/linkedlist771/SoraWatermarkCleaner/releases/download/V0.0.1/best.pt'); \
+r = requests.get(url, stream=True); \
+open('resources/best.pt', 'wb').write(r.content); \
+print('YOLO weights downloaded.') \
+" || echo "YOLO download skipped, will download at runtime"
+
+# Expose ports: 8501 (Streamlit UI), 5344 (FastAPI)
+EXPOSE 8501 5344
+
+# Start both Streamlit and FastAPI
+COPY docker-entrypoint.sh .
+RUN chmod +x docker-entrypoint.sh
+
+CMD ["./docker-entrypoint.sh"]

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -0,0 +1,339 @@
+---
+title: Sora Watermark Cleaner
+emoji: 🎬
+colorFrom: purple
+colorTo: blue
+sdk: docker
+pinned: false
+app_port: 5344
+---
+
+# SoraWatermarkCleaner
+
+## IMPORTANT
+ **This project is being archived.** OpenAI has discontinued the Sora video generation model, so this project will no longer be maintained. However, check out [DeMark-World](https://github.com/linkedlist771/DeMark-World) — it provides a universal method to remove watermarks from videos generated by other models such as Veo, Runway, and more.
+
+
+> This project provides an elegant way to remove the sora watermark in the sora2 generated videos. 
+
+<table>
+  <tr>
+    <td width="20%">
+      <strong>Case1(25s)</strong>
+    </td>
+    <td width="80%">
+      <video src="https://github.com/user-attachments/assets/55f4e822-a356-4fab-a372-8910e4cb3c28" 
+             width="100%" controls></video>
+    </td>
+  </tr>
+  <tr>
+    <td>
+      <strong>Case2(10s)</strong>
+    </td>
+    <td>
+      <video src="https://github.com/user-attachments/assets/2773df41-62dc-4876-bd2f-4dd3ccac4b9e" 
+             width="100%" controls></video>
+    </td>
+  </tr>
+  <tr>
+    <td>
+      <strong>Case3(10s)</strong>
+    </td>
+    <td>
+      <video src="https://github.com/user-attachments/assets/2bdba310-6379-48f2-a93c-6de857c4df3d" 
+             width="100%" controls></video>
+    </td>
+  </tr>
+</table>
+
+**Commercial Hosted Service & Sponsorship**
+
+>  If you prefer a one-click online service instead of running everything locally, you can use the hosted Sora watermark remover here:
+> 
+> 👉 **https://www.sorawatermarkremover.ai/**
+> 
+> SoraWatermarkRemover runs **SoraWatermarkCleaner** under the hood and provides GPU-backed processing, credits-based pricing and an easy web UI. This service financially supports the ongoing development and maintenance of **SoraWatermarkCleaner**.
+
+⭐️: 
+
+- **I'm excited to release [DeMark-World](https://github.com/linkedlist771/DeMark-World) – to the best of my knowledge, the first model capable of removing any watermark from AI-generated videos.**
+
+- **We have provided another model which could preserve time consistency without flicker!**
+
+- **We support batch processing now.**
+
+- **For the new watermark with username,  the Yolo weights has been updated, try the new version watermark detect model, it should work better.**
+
+- **We have uploaded the labelled datasets into huggingface, check this [dataset](https://huggingface.co/datasets/LLinked/sora-watermark-dataset) out. Free free to train your custom detector model or improve our model!**
+
+- **One-click portable build is available** — [Download here](#3-one-click-portable-version) for Windows users! No installation required.
+
+- **Docker Compose deployment is now supported** — [Get started](#6-docker-compose-deployment) with a single command. Note: the image requires CUDA and is large (~20 GB) due to NVIDIA libraries and PyTorch.
+
+---
+
+💝 If you find this project helpful, please consider [buying me a coffee](mds/reward.md) to support the development!
+
+## 1. Method
+
+The SoraWatermarkCleaner(we call it `SoraWm` later) is composed of two parsts:
+
+- SoraWaterMarkDetector: We trained a yolov11s version to detect the sora watermark. (Thank you yolo!)
+
+- WaterMarkCleaner: We refer iopaint's implementation for watermark removal using the lama model.
+  
+  (This codebase is from https://github.com/Sanster/IOPaint#, thanks for their amazing work!)
+
+Our SoraWm is purely deeplearning driven and yields good results in many generated videos.
+
+## 2. Installation
+
+[FFmpeg](https://ffmpeg.org/) is needed for video processing, please install it first.  We highly recommend using the `uv` to install the environments:
+
+1. installation:
+
+```bash
+uv sync
+```
+
+> now the envs will be installed at the `.venv`, you can activate the env using:
+> 
+> ```bash
+> source .venv/bin/activate
+> ```
+
+2. Downloaded the pretrained models:
+
+The trained yolo weights will be stored in the `resources` dir as the `best.pt`.  And it will be automatically download from https://github.com/linkedlist771/SoraWatermarkCleaner/releases/download/V0.0.1/best.pt . The `Lama` model is downloaded from https://github.com/Sanster/models/releases/download/add_big_lama/big-lama.pt, and will be stored in the torch cache dir. Both downloads are automatic, if you fail, please check your internet status.
+
+3. Batch processing
+   Use the cli.py for batch processing
+
+```
+python cli.py [-h] -i INPUT -o OUTPUT [-p PATTERN] [-m MODEL] [--quiet]
+```
+
+examples:
+
+```
+# Process all .mp4 files in input folder
+python cli.py -i /path/to/input -o /path/to/output
+# Process all .mov files
+python cli.py -i /path/to/input -o /path/to/output --pattern "*.mov"
+# Process all video files (mp4, mov, avi)
+python cli.py -i /path/to/input -o /path/to/output --pattern "*.{mp4,mov,avi}"
+# Use e2fgvi_hq model for time-consistent results (slower, requires CUDA)
+python cli.py -i /path/to/input -o /path/to/output --model e2fgvi_hq
+# Without displaying the Tqdm bar inside sorawm procrssing.
+python cli.py -i /path/to/input -o /path/to/output --quiet
+```
+
+## 3. One-Click Portable Version
+
+For users who prefer a ready-to-use solution without manual installation, we provide a **one-click portable distribution** that includes all dependencies pre-configured.
+
+### Download Links
+
+**Google Drive:**
+
+- [Download from Google Drive](https://drive.google.com/file/d/1ujH28aHaCXGgB146g6kyfz3Qxd-wHR1c/view?usp=share_link)
+
+**Baidu Pan (百度网盘) - For users in China:**
+
+- Link: https://pan.baidu.com/s/1onMom81mvw2c6PFkCuYzdg?pwd=jusu
+- Extract Code (提取码): `jusu`
+
+### Features
+
+- ✅ No installation required
+- ✅ All dependencies included
+- ✅ Pre-configured environment
+- ✅ Ready to use out of the box
+
+Simply download, extract, and run!
+
+## 4. Performance Optimization
+
+We provide several options to speed up processing:
+
+| Detector | Batch | Cleaner | TorchCompile | Bf16 | Time (s) | Speedup |
+|:--------:|:-----:|:-------:|:------------:|:----:|:--------:|:-------:|
+| YOLO     | ×     | LAMA    | ×            | ×    | 44.33    | -       |
+| YOLO     | ×     | E2FGVI  | ×            | ×    | 142.42   | 1.00×   |
+| YOLO     | ×     | E2FGVI  | ✓            | ×    | 117.19   | 1.22×   |
+| YOLO     | 4     | E2FGVI  | ✓            | ×    | 82.63    | 1.72×   |
+| YOLO     | 4     | E2FGVI  | ✓            | ✓    | 58.60    | 2.43×   |
+
+> Speedup is calculated relative to the E2FGVI baseline. LAMA uses a different cleaning approach and is not directly comparable.
+
+- **YOLO Batch Detection**: Default batch size is 4 (`detect_batch_size=4`), enables batch inference for watermark detection, provides ~40% speedup
+- **TorchCompile** (E2FGVI only): Enabled by default (`enable_torch_compile=True`), provides ~22% speedup
+- **Bf16 Inference** (E2FGVI only): Enable with `use_bf16=True`(Default False), provides up to **2.43× speedup**. Note: quality may slightly decrease, and the first inference will be slow (~90s) due to compilation overhead; subsequent runs will be much faster (~58s) as artifacts are cached.
+
+You can customize these settings when initializing `SoraWM`:
+
+```python
+from sorawm.core import SoraWM
+from sorawm.schemas import CleanerType
+
+# LAMA with batch detection (fast)
+sora_wm = SoraWM(
+    cleaner_type=CleanerType.LAMA,
+    detect_batch_size=4  # default: 4
+)
+
+# E2FGVI_HQ with all optimizations (time-consistent)
+sora_wm = SoraWM(
+    cleaner_type=CleanerType.E2FGVI_HQ,
+    enable_torch_compile=True,  # default: True
+    detect_batch_size=8         # custom batch size
+)
+
+# E2FGVI_HQ with bf16 for maximum speed (may have slight quality loss)
+sora_wm = SoraWM(
+    cleaner_type=CleanerType.E2FGVI_HQ,
+    enable_torch_compile=True,
+    detect_batch_size=4,
+    use_bf16=True  # enables bfloat16 inference
+)
+```
+
+## 5.  Demo
+
+To have a basic usage, just try the `example.py`:
+
+> We provide two models to remove watermark. LAMA is fast but may have flicker on the cleaned area, which E2FGVI_HQ compromise this only requires cuda otherwise very slow on CPU or MPS.
+
+```python
+from pathlib import Path
+
+from sorawm.core import SoraWM
+from sorawm.schemas import CleanerType
+
+if __name__ == "__main__":
+    input_video_path = Path("resources/dog_vs_sam.mp4")
+    output_video_path = Path("outputs/sora_watermark_removed")
+
+    # 1. LAMA is fast and good quality, but not time consistent.
+    sora_wm = SoraWM(cleaner_type=CleanerType.LAMA)
+    sora_wm.run(input_video_path, Path(f"{output_video_path}_lama.mp4"))
+
+    # 2. E2FGVI_HQ ensures time consistency, but will be very slow on no-cuda device.
+    sora_wm = SoraWM(cleaner_type=CleanerType.E2FGVI_HQ)
+    sora_wm.run(input_video_path, Path(f"{output_video_path}_e2fgvi_hq.mp4"))
+```
+
+We also provide you with a `streamlit` based interactive web page, try it with:
+
+> We also provide the switch here.
+
+```bash
+streamlit run app.py
+```
+
+<img src="assests/model_switch.png" style="zoom: 25%;" />
+
+Batch processing is also supported, now you can drag a folder or select multiple files to process.
+<img src="assests/streamlit_batch.png" style="zoom: 50%;" />
+
+## 6. Docker Compose Deployment
+
+The easiest way to deploy SoraWatermarkCleaner is via Docker Compose.
+
+> **Note:** The Docker image (`llinkedlist/sorawm:latest`) requires CUDA and includes NVIDIA libraries and PyTorch, making it quite large (~20 GB). The initial pull may take a significant amount of time depending on your network speed.
+
+**Prerequisites:**
+
+- [Docker](https://docs.docker.com/get-docker/) with [NVIDIA Container Toolkit](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html) installed
+- A CUDA-capable GPU
+
+**Start the service:**
+
+```bash
+docker compose up -d
+```
+
+This will:
+
+- Pull the image from Docker Hub (first time only — be patient, ~20 GB)
+- Mount the current directory to `/workspace` inside the container
+- Cache model weights in `./.cache` to avoid re-downloading on restart
+- Expose the Streamlit UI on port **8501**
+
+Access the Streamlit UI at `http://localhost:8501`.
+
+## 7. WebServer
+
+Here, we provide a **FastAPI-based web server** that can quickly turn this watermark remover into a service.
+
+We also have a frontUI for the webserver, to try this:
+
+```bash
+cd frontend && bun install && bun run build
+```
+
+And then start the server, the frontend UI will be just ready in root route:
+
+> The task statuses are recoreded and can resume when server is down.
+
+![image](assests/frontend.png)
+
+Simply run:
+
+```
+python start_server.py
+```
+
+The web server will start on port **5344**.
+
+You can view the FastAPI [documentation](http://localhost:5344/docs) for more details.
+
+There are three routes available:
+
+1. **submit_remove_task**
+   
+   > After uploading a video, a task ID will be returned, and the video will begin processing immediately.
+
+<img src="resources/53abf3fd-11a9-4dd7-a348-34920775f8ad.png" alt="image" style="zoom: 25%;" />
+
+2. **get_results**
+
+You can use the task ID obtained above to check the task status.
+
+It will display the percentage of video processing completed.
+
+Once finished, the returned data will include a **download URL**.
+
+3. **download**
+
+You can use the **download URL** from step 2 to retrieve the cleaned video.
+
+## 8. Datasets
+
+We have uploaded the labelled datasets into huggingface, check this out https://huggingface.co/datasets/LLinked/sora-watermark-dataset. Free free to train your custom detector model or improve our model!
+
+## 9. API
+
+Packaged as a Cog and [published to Replicate](https://replicate.com/uglyrobot/sora2-watermark-remover) for simple API based usage.
+
+## 10. License
+
+ Apache License
+
+## 11. Citation
+
+If you use this project, please cite:
+
+```bibtex
+@misc{sorawatermarkcleaner2025,
+  author = {linkedlist771},
+  title = {SoraWatermarkCleaner},
+  year = {2025},
+  url = {https://github.com/linkedlist771/SoraWatermarkCleaner}
+}
+```
+
+## 12. Acknowledgments
+
+- [IOPaint](https://github.com/Sanster/IOPaint) for the LAMA implementation
+- [Ultralytics YOLO](https://github.com/ultralytics/ultralytics) for object detection

app.py

@@ -0,0 +1,387 @@
+import shutil
+import tempfile
+from pathlib import Path
+
+import streamlit as st
+
+from sorawm.core import SoraWM
+from sorawm.schemas import CleanerType
+
+
+def main():
+    st.set_page_config(
+        page_title="Sora Watermark Cleaner", page_icon="🎬", layout="centered"
+    )
+
+    # Header section with improved layout
+    st.markdown(
+        """
+        <div style='text-align: center; padding: 1rem 0;'>
+            <h1 style='margin-bottom: 0.5rem;'>
+                🎬 Sora Watermark Cleaner
+            </h1>
+            <p style='font-size: 1.2rem; color: #666; margin-bottom: 1rem;'>
+                Remove watermarks from Sora-generated videos with AI-powered precision
+            </p>
+        </div>
+        """,
+        unsafe_allow_html=True,
+    )
+
+    # # Feature badges
+    # col1, col2, col3 = st.columns(3)
+    # with col1:
+    #     st.markdown(
+    #         """
+    #         <div style='text-align: center; padding: 0.8rem; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    #                     border-radius: 10px; color: white;'>
+    #             <div style='font-size: 1.5rem;'>⚡</div>
+    #             <div style='font-weight: bold;'>Fast Processing</div>
+    #             <div style='font-size: 0.85rem; opacity: 0.9;'>GPU Accelerated</div>
+    #         </div>
+    #         """,
+    #         unsafe_allow_html=True,
+    #     )
+    # with col2:
+    #     st.markdown(
+    #         """
+    #         <div style='text-align: center; padding: 0.8rem; background: linear-gradient(135deg, #f093fb 0%, #f5576c 100%);
+    #                     border-radius: 10px; color: white;'>
+    #             <div style='font-size: 1.5rem;'>🎯</div>
+    #             <div style='font-weight: bold;'>High Precision</div>
+    #             <div style='font-size: 0.85rem; opacity: 0.9;'>AI-Powered</div>
+    #         </div>
+    #         """,
+    #         unsafe_allow_html=True,
+    #     )
+    # with col3:
+    #     st.markdown(
+    #         """
+    #         <div style='text-align: center; padding: 0.8rem; background: linear-gradient(135deg, #4facfe 0%, #00f2fe 100%);
+    #                     border-radius: 10px; color: white;'>
+    #             <div style='font-size: 1.5rem;'>📦</div>
+    #             <div style='font-weight: bold;'>Batch Support</div>
+    #             <div style='font-size: 0.85rem; opacity: 0.9;'>Process Multiple</div>
+    #         </div>
+    #         """,
+    #         unsafe_allow_html=True,
+    #     )
+
+    # Footer info
+    st.markdown(
+        """
+        <div style='text-align: center; padding: 1rem 0; margin-top: 1rem;'>
+            <p style='color: #888; font-size: 0.9rem;'>
+                Built with ❤️ using Streamlit and AI | 
+                <a href='https://github.com/linkedlist771/SoraWatermarkCleaner' 
+                   target='_blank' style='color: #667eea; text-decoration: none;'>
+                    ⭐ Star on GitHub
+                </a>
+            </p>
+        </div>
+        """,
+        unsafe_allow_html=True,
+    )
+    st.markdown("---")
+
+    # Model selection
+    st.markdown("### ⚙️ Model Settings")
+
+    col1, col2 = st.columns([2, 3])
+    with col1:
+        model_type = st.selectbox(
+            "Select Cleaner Model:",
+            options=[CleanerType.LAMA, CleanerType.E2FGVI_HQ],
+            format_func=lambda x: {
+                CleanerType.LAMA: "🚀 LAMA (Fast, Good Quality)",
+                CleanerType.E2FGVI_HQ: "💎 E2FGVI-HQ (Slower when not on GPU, Best Quality with time consistency)",
+            }[x],
+            help="LAMA: Fast processing with good quality. E2FGVI-HQ: Slower when not on GPU but highest quality results.",
+        )
+
+    with col2:
+        model_info = {
+            CleanerType.LAMA: "⚡ **Fast processing** - Recommended for most videos. Uses LaMa (Large Mask Inpainting) for quick watermark removal.",
+            CleanerType.E2FGVI_HQ: "🎯 **Highest quality** - Uses temporal flow-based video inpainting. Best for professional results. Slower when not on GPU. Time consistency is guaranteed.",
+        }
+        st.info(model_info[model_type])
+
+    # Initialize or reinitialize SoraWM if model changed
+    if (
+        "sora_wm" not in st.session_state
+        or st.session_state.get("current_model") != model_type
+    ):
+        with st.spinner(f"Loading {model_type.value.upper()} model..."):
+            st.session_state.sora_wm = SoraWM(cleaner_type=model_type)
+            st.session_state.current_model = model_type
+        st.success(f"✅ {model_type.value.upper()} model loaded!")
+
+    st.markdown("---")
+
+    # Mode selection
+    mode = st.radio(
+        "Select input mode:",
+        ["📁 Upload Video File", "🗂️ Process Folder"],
+        horizontal=True,
+    )
+
+    if mode == "📁 Upload Video File":
+        # File uploader
+        uploaded_file = st.file_uploader(
+            "Upload your video",
+            type=["mp4", "avi", "mov", "mkv"],
+            accept_multiple_files=False,
+            help="Select a video file to remove watermark",
+        )
+
+        if uploaded_file:
+            # Clear previous processed video if a new file is uploaded
+            if (
+                "current_file_name" not in st.session_state
+                or st.session_state.current_file_name != uploaded_file.name
+            ):
+                st.session_state.current_file_name = uploaded_file.name
+                if "processed_video_data" in st.session_state:
+                    del st.session_state.processed_video_data
+                if "processed_video_path" in st.session_state:
+                    del st.session_state.processed_video_path
+                if "processed_video_name" in st.session_state:
+                    del st.session_state.processed_video_name
+
+            # Display video info
+            st.success(f"✅ Uploaded: {uploaded_file.name}")
+
+            # Create two columns for before/after comparison
+            col_left, col_right = st.columns(2)
+
+            with col_left:
+                st.markdown("### 📥 Original Video")
+                st.video(uploaded_file)
+
+            with col_right:
+                st.markdown("### 🎬 Processed Video")
+                # Placeholder for processed video
+                if "processed_video_data" not in st.session_state:
+                    st.info("Click 'Remove Watermark' to process the video")
+                else:
+                    st.video(st.session_state.processed_video_data)
+
+            # Process button
+            if st.button(
+                "🚀 Remove Watermark", type="primary", use_container_width=True
+            ):
+                with tempfile.TemporaryDirectory() as tmp_dir:
+                    tmp_path = Path(tmp_dir)
+
+                    try:
+                        # Create progress bar and status text
+                        progress_bar = st.progress(0)
+                        status_text = st.empty()
+
+                        def update_progress(progress: int):
+                            progress_bar.progress(progress / 100)
+                            if progress < 50:
+                                status_text.text(
+                                    f"🔍 Detecting watermarks... {progress}%"
+                                )
+                            elif progress < 95:
+                                status_text.text(
+                                    f"🧹 Removing watermarks... {progress}%"
+                                )
+                            else:
+                                status_text.text(f"🎵 Merging audio... {progress}%")
+
+                        # Single file processing
+                        input_path = tmp_path / uploaded_file.name
+                        with open(input_path, "wb") as f:
+                            f.write(uploaded_file.read())
+
+                        output_path = tmp_path / f"cleaned_{uploaded_file.name}"
+
+                        st.session_state.sora_wm.run(
+                            input_path, output_path, progress_callback=update_progress
+                        )
+
+                        progress_bar.progress(100)
+                        status_text.text("✅ Processing complete!")
+                        st.success("✅ Watermark removed successfully!")
+
+                        # Store processed video path and read video data
+                        with open(output_path, "rb") as f:
+                            video_data = f.read()
+
+                        st.session_state.processed_video_path = output_path
+                        st.session_state.processed_video_data = video_data
+                        st.session_state.processed_video_name = (
+                            f"cleaned_{uploaded_file.name}"
+                        )
+
+                        # Rerun to show the video in the right column
+                        st.rerun()
+
+                    except Exception as e:
+                        st.error(f"❌ Error processing video: {str(e)}")
+
+            # Download button (show only if video is processed)
+            if "processed_video_data" in st.session_state:
+                st.download_button(
+                    label="⬇️ Download Cleaned Video",
+                    data=st.session_state.processed_video_data,
+                    file_name=st.session_state.processed_video_name,
+                    mime="video/mp4",
+                    use_container_width=True,
+                )
+
+    else:  # Folder mode
+        st.info(
+            "💡 Drag and drop your video folder here, or click to browse and select multiple video files"
+        )
+
+        # File uploader for multiple files (supports folder drag & drop)
+        uploaded_files = st.file_uploader(
+            "Upload videos from folder",
+            type=["mp4", "avi", "mov", "mkv"],
+            accept_multiple_files=True,
+            help="You can drag & drop an entire folder here, or select multiple video files",
+            key="folder_uploader",
+        )
+
+        if uploaded_files:
+            # Display uploaded files info
+            video_count = len(uploaded_files)
+            st.success(f"✅ {video_count} video file(s) uploaded")
+
+            # Show file list in an expander
+            with st.expander("📋 View uploaded files", expanded=False):
+                for i, file in enumerate(uploaded_files, 1):
+                    file_size_mb = file.size / (1024 * 1024)
+                    st.text(f"{i}. {file.name} ({file_size_mb:.2f} MB)")
+
+            # Process button
+            if st.button(
+                "🚀 Process All Videos", type="primary", use_container_width=True
+            ):
+                with tempfile.TemporaryDirectory() as tmp_dir:
+                    tmp_path = Path(tmp_dir)
+                    input_folder = tmp_path / "input"
+                    output_folder = tmp_path / "output"
+                    input_folder.mkdir(exist_ok=True)
+                    output_folder.mkdir(exist_ok=True)
+
+                    try:
+                        # Save all uploaded files to temp folder
+                        status_text = st.empty()
+                        status_text.text("📥 Saving uploaded files...")
+
+                        for uploaded_file in uploaded_files:
+                            # Preserve folder structure if file.name contains subdirectories
+                            file_path = input_folder / uploaded_file.name
+                            file_path.parent.mkdir(parents=True, exist_ok=True)
+                            with open(file_path, "wb") as f:
+                                f.write(uploaded_file.read())
+
+                        # Create progress tracking
+                        progress_bar = st.progress(0)
+                        current_file_text = st.empty()
+                        processed_count = 0
+
+                        def update_progress(progress: int):
+                            # Calculate overall progress
+                            overall_progress = (
+                                (processed_count * 100 + progress) / video_count / 100
+                            )
+                            progress_bar.progress(overall_progress)
+
+                            if progress < 50:
+                                current_file_text.text(
+                                    f"🔍 Processing file {processed_count + 1}/{video_count}: Detecting watermarks... {progress}%"
+                                )
+                            elif progress < 95:
+                                current_file_text.text(
+                                    f"🧹 Processing file {processed_count + 1}/{video_count}: Removing watermarks... {progress}%"
+                                )
+                            else:
+                                current_file_text.text(
+                                    f"🎵 Processing file {processed_count + 1}/{video_count}: Merging audio... {progress}%"
+                                )
+
+                        # Process each video file
+                        for video_file in input_folder.rglob("*"):
+                            if video_file.is_file() and video_file.suffix.lower() in [
+                                ".mp4",
+                                ".avi",
+                                ".mov",
+                                ".mkv",
+                            ]:
+                                # Determine output path maintaining folder structure
+                                rel_path = video_file.relative_to(input_folder)
+                                output_path = (
+                                    output_folder
+                                    / rel_path.parent
+                                    / f"cleaned_{rel_path.name}"
+                                )
+                                output_path.parent.mkdir(parents=True, exist_ok=True)
+
+                                # Process the video
+                                st.session_state.sora_wm.run(
+                                    video_file,
+                                    output_path,
+                                    progress_callback=update_progress,
+                                )
+                                processed_count += 1
+
+                        progress_bar.progress(100)
+                        current_file_text.text("✅ All videos processed!")
+                        st.success(f"✅ {video_count} video(s) processed successfully!")
+
+                        # Create download option for processed videos
+                        st.markdown("### 📦 Download Processed Videos")
+
+                        # Store processed files info in session state
+                        if "batch_processed_files" not in st.session_state:
+                            st.session_state.batch_processed_files = []
+
+                        st.session_state.batch_processed_files.clear()
+
+                        for processed_file in output_folder.rglob("*"):
+                            if processed_file.is_file():
+                                with open(processed_file, "rb") as f:
+                                    video_data = f.read()
+                                rel_path = processed_file.relative_to(output_folder)
+                                st.session_state.batch_processed_files.append(
+                                    {"name": str(rel_path), "data": video_data}
+                                )
+
+                        st.rerun()
+
+                    except Exception as e:
+                        st.error(f"❌ Error processing videos: {str(e)}")
+                        import traceback
+
+                        st.error(f"Details: {traceback.format_exc()}")
+
+            # Show download buttons for processed files
+            if (
+                "batch_processed_files" in st.session_state
+                and st.session_state.batch_processed_files
+            ):
+                st.markdown("---")
+                st.markdown("### ⬇️ Download Processed Videos")
+
+                for file_info in st.session_state.batch_processed_files:
+                    col1, col2 = st.columns([3, 1])
+                    with col1:
+                        st.text(f"📹 {file_info['name']}")
+                    with col2:
+                        st.download_button(
+                            label="⬇️ Download",
+                            data=file_info["data"],
+                            file_name=file_info["name"],
+                            mime="video/mp4",
+                            key=f"download_{file_info['name']}",
+                            use_container_width=True,
+                        )
+
+
+if __name__ == "__main__":
+    main()

benchmark/batch_bench_record.md

@@ -0,0 +1,16 @@
+# Batch Processing Benchmark Results
+
+## Ablation Study
+
+| Detector | Batch | Cleaner | TorchCompile | Bf16 | Time (s) | Speedup |
+|:--------:|:-----:|:-------:|:------------:|:----:|:--------:|:-------:|
+| YOLO     | ×     | LAMA    | ×            | ×    | 44.33    | -       |
+| YOLO     | ×     | E2FGVI  | ×            | ×    | 142.42   | 1.00×   |
+| YOLO     | ×     | E2FGVI  | ✓            | ×    | 117.19   | 1.22×   |
+| YOLO     | 4     | E2FGVI  | ✓            | ×    | 82.63    | 1.72×   |
+| YOLO     | 4     | E2FGVI  | ✓            | ✓    | 58.60    | 2.43×   |
+
+> **Note**: 
+> - Speedup is calculated relative to the E2FGVI baseline (142.42s).
+> - LAMA is a different cleaner and not directly comparable.
+> - When enabling both bf16 and torch.compile, the first inference may be very slow (~90s) due to compilation overhead. Subsequent inferences will be significantly faster (~58s) as the compiled artifacts are cached.

benchmark/benchmark_batch.py

@@ -0,0 +1,67 @@
+from contextlib import contextmanager
+from pathlib import Path
+from time import perf_counter
+
+from sorawm.core import SoraWM
+from sorawm.schemas import CleanerType
+
+
+@contextmanager
+def timer(name: str):
+    start = perf_counter()
+    yield
+    elapsed = perf_counter() - start
+    print(f"[{name}] Time elapsed: {elapsed:.2f}s")
+
+
+if __name__ == "__main__":
+    input_video_path = Path("resources/dog_vs_sam.mp4")
+    output_video_path = Path("outputs/sora_watermark_removed")
+
+    # # 1. LAMA is fast and good quality, but not time consistent.
+    # sora_wm = SoraWM(cleaner_type=CleanerType.LAMA)
+    # with timer("LAMA"):
+    #     sora_wm.run(input_video_path, Path(f"{output_video_path}_lama.mp4"))
+
+    # # 2. E2FGVI_HQ ensures time consistency, but will be very slow on no-cuda device.
+    # sora_wm = SoraWM(cleaner_type=CleanerType.E2FGVI_HQ, enable_torch_compile=False)
+    # with timer("E2FGVI_HQ"):
+    #     sora_wm.run(input_video_path, Path(f"{output_video_path}_e2fgvi_hq.mp4"))
+
+    # 3. E2FGVI_HQ with torch compile is fast and good quality, but not time consistent.
+    sora_wm = SoraWM(cleaner_type=CleanerType.E2FGVI_HQ, enable_torch_compile=True)
+    with timer("E2FGVI_HQ + torch.compile"):
+        sora_wm.run(
+            input_video_path, Path(f"{output_video_path}_e2fgvi_hq_torch_compile.mp4")
+        )
+
+    #  4. Enable batch detection
+    batch_size = 4
+    sora_wm = SoraWM(
+        cleaner_type=CleanerType.E2FGVI_HQ,
+        enable_torch_compile=True,
+        detect_batch_size=4,
+    )
+    with timer("E2FGVI_HQ + torch.compile + batch"):
+        sora_wm.run(
+            input_video_path,
+            Path(f"{output_video_path}_e2fgvi_hq_torch_compile_batch.mp4"),
+        )
+
+    # 5. Enable bf16 inference
+    sora_wm = SoraWM(
+        cleaner_type=CleanerType.E2FGVI_HQ,
+        enable_torch_compile=True,
+        detect_batch_size=4,
+        use_bf16=True,
+    )
+    with timer("E2FGVI_HQ + torch.compile + batch + bf16"):
+        sora_wm.run(
+            input_video_path,
+            Path(f"{output_video_path}_e2fgvi_hq_torch_compile_batch_bf16.mp4"),
+        )
+    with timer("E2FGVI_HQ + torch.compile + batch + bf16"):
+        sora_wm.run(
+            input_video_path,
+            Path(f"{output_video_path}_e2fgvi_hq_torch_compile_batch_bf16.mp4"),
+        )

cli.py

@@ -0,0 +1,430 @@
+import argparse
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, List
+
+
+def validate_args_and_show_help():
+    """
+    Parse CLI arguments, validate the input folder, and return resolved paths and parsed args.
+
+    Parses command-line options for input, output, pattern, quiet, and model; converts input and output to resolved Path objects and validates that the input path exists and is a directory. Exits the process with code 1 if the input path is missing or not a directory.
+
+    Returns:
+        (input_folder, output_folder, args):
+            input_folder (Path): Resolved Path to the input directory.
+            output_folder (Path): Resolved Path to the output directory.
+            args (argparse.Namespace): Parsed command-line arguments.
+    """
+    parser = argparse.ArgumentParser(
+        description="🎬 Batch process videos to remove Sora watermarks",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+    # Process all .mp4 files in input folder
+    python batch_process.py -i /path/to/input -o /path/to/output
+    # Process all .mov files
+    python batch_process.py -i /path/to/input -o /path/to/output --pattern "*.mov"
+    # Process all video files (mp4, mov, avi)
+    python batch_process.py -i /path/to/input -o /path/to/output --pattern "*.{mp4,mov,avi}"
+    # Without displaying the Tqdm bar inside sorawm procrssing.
+    python batch_process.py -i /path/to/input -o /path/to/output --quiet
+        """,
+    )
+
+    parser.add_argument(
+        "-i",
+        "--input",
+        type=str,
+        required=True,
+        help="📁 Input folder containing video files",
+    )
+
+    parser.add_argument(
+        "-o",
+        "--output",
+        type=str,
+        required=True,
+        help="📁 Output folder for cleaned videos",
+    )
+
+    parser.add_argument(
+        "-p",
+        "--pattern",
+        type=str,
+        default="*.mp4",
+        help="🔍 File pattern to match (default: *.mp4)",
+    )
+    parser.add_argument(
+        "--quiet",
+        action="store_true",
+        default=False,
+        help="Run in quiet mode (suppress tqdm and most logs).",
+    )
+    parser.add_argument(
+        "-m",
+        "--model",
+        type=str,
+        default="lama",
+        choices=["lama", "e2fgvi_hq"],
+        help="🔧 Model to use for watermark removal (default: lama). Options: lama (fast, may flicker), e2fgvi_hq (time consistent, slower)",
+    )
+
+    args = parser.parse_args()
+
+    # Convert to Path objects
+    input_folder = Path(args.input).expanduser().resolve()
+    output_folder = Path(args.output).expanduser().resolve()
+
+    # Validate input folder
+    if not input_folder.exists():
+        print(f"❌ Error: Input folder does not exist: {input_folder}", file=sys.stderr)
+        sys.exit(1)
+
+    if not input_folder.is_dir():
+        print(
+            f"❌ Error: Input path is not a directory: {input_folder}", file=sys.stderr
+        )
+        sys.exit(1)
+
+    return input_folder, output_folder, args
+
+
+# Classes are now defined inside main() after imports
+
+
+def main():
+    # Validate arguments BEFORE loading heavy dependencies (ffmpeg, torch, etc.)
+    """
+    Orchestrate CLI argument validation, lazy-load heavy dependencies, and run the batch video processing workflow.
+
+    Validates and processes command-line arguments, imports runtime-only dependencies, selects the watermark removal model, constructs and runs the batch processor, and handles termination: exits with code 130 on user interrupt and with code 1 on other fatal errors.
+    """
+    input_folder, output_folder, args = validate_args_and_show_help()
+
+    pattern = args.pattern
+
+    # Only NOW import heavy dependencies after validation passed
+    from rich import box
+    from rich.console import Console
+    from rich.panel import Panel
+    from rich.progress import (
+        BarColumn,
+        MofNCompleteColumn,
+        Progress,
+        ProgressColumn,
+        SpinnerColumn,
+        TaskProgressColumn,
+        TextColumn,
+        TimeElapsedColumn,
+        TimeRemainingColumn,
+    )
+    from rich.table import Table
+    from rich.text import Text
+    from rich.text import Text as RichText
+
+    from sorawm.core import SoraWM
+    from sorawm.schemas import CleanerType
+
+    # Initialize console after importing rich
+    console = Console()
+
+    # Make SpeedColumn a proper ProgressColumn subclass now that we've imported it
+    global SpeedColumn
+
+    class SpeedColumnImpl(ProgressColumn):
+        """Custom column to display processing speed in it/s format (only for video processing)"""
+
+        def render(self, task):
+            """Render the speed in it/s format, but only for video processing tasks"""
+            # Only show speed for video processing, not for overall batch progress
+            if "Overall Progress" in task.description:
+                return RichText("", style="")
+
+            speed = task.finished_speed or task.speed
+            if speed is None:
+                return RichText("-- it/s", style="progress.data.speed")
+            return RichText(f"{speed:.2f} it/s", style="cyan")
+
+    SpeedColumn = SpeedColumnImpl
+
+    # Define BatchProcessor here to have access to all imports
+    class BatchProcessorImpl:
+        """Batch video processor with progress tracking"""
+
+        def __init__(
+            self,
+            input_folder: Path,
+            output_folder: Path,
+            pattern: str = "*.mp4",
+            cleaner_type: CleanerType = CleanerType.LAMA,
+        ):
+            """
+            Initialize the batch processor with paths, file-matching pattern, and watermark cleaner selection.
+
+            Parameters:
+                input_folder (Path): Directory containing videos to process.
+                output_folder (Path): Directory where cleaned videos will be written.
+                pattern (str): Glob pattern used to find video files in the input folder (default: "*.mp4").
+                cleaner_type (CleanerType): Cleaner model to use for watermark removal (e.g., CleanerType.LAMA or CleanerType.E2FGVI_HQ).
+            """
+            self.input_folder = input_folder
+            self.output_folder = output_folder
+            self.pattern = pattern
+            self.sora_wm = SoraWM(cleaner_type=cleaner_type)
+            self.console = console
+
+            # Statistics
+            self.successful: List[str] = []
+            self.failed: Dict[str, str] = {}
+
+        def show_banner(self):
+            """Display a colorful welcome banner"""
+            banner_text = Text()
+            banner_text.append("🎬 ", style="bold yellow")
+            banner_text.append("Sora Watermark Remover", style="bold cyan")
+            banner_text.append(" - Batch Processor", style="bold magenta")
+
+            panel = Panel(
+                banner_text,
+                box=box.DOUBLE,
+                border_style="bright_blue",
+                padding=(1, 2),
+            )
+            console.print(panel)
+            console.print()
+
+        def find_videos(self) -> List[Path]:
+            """Find all video files matching the pattern"""
+            video_files = list(self.input_folder.glob(self.pattern))
+            return sorted(video_files)
+
+        def process_batch(self):
+            """Process all videos in the batch with progress tracking"""
+            # Show banner
+            self.show_banner()
+
+            # Find all videos
+            video_files = self.find_videos()
+
+            if not video_files:
+                console.print(
+                    f"[bold red]❌ No files matching '{self.pattern}' found in {self.input_folder}[/bold red]"
+                )
+                return
+
+            # Display configuration
+            config_table = Table(show_header=False, box=box.SIMPLE, padding=(0, 1))
+            config_table.add_row(
+                "📁 Input folder:", f"[cyan]{self.input_folder}[/cyan]"
+            )
+            config_table.add_row(
+                "📁 Output folder:", f"[green]{self.output_folder}[/green]"
+            )
+            config_table.add_row("🔍 Pattern:", f"[yellow]{self.pattern}[/yellow]")
+            config_table.add_row(
+                "🎬 Videos found:", f"[bold magenta]{len(video_files)}[/bold magenta]"
+            )
+            console.print(config_table)
+            console.print()
+
+            # Create output folder
+            self.output_folder.mkdir(parents=True, exist_ok=True)
+
+            # Process each video with batch-level progress bar
+            start_time = datetime.now()
+
+            # Create rich progress display
+            with Progress(
+                SpinnerColumn(),
+                TextColumn("[progress.description]{task.description}"),
+                BarColumn(bar_width=40),
+                TaskProgressColumn(),
+                MofNCompleteColumn(),
+                SpeedColumn(),
+                TimeElapsedColumn(),
+                TimeRemainingColumn(),
+                console=console,
+            ) as progress:
+                # Batch progress task
+                batch_task = progress.add_task(
+                    "[cyan]Overall Progress", total=len(video_files)
+                )
+
+                for idx, input_path in enumerate(video_files, 1):
+                    output_path = self.output_folder / f"cleaned_{input_path.name}"
+
+                    # Update batch task description
+                    progress.update(
+                        batch_task,
+                        description=f"[cyan]Overall Progress ({idx}/{len(video_files)})",
+                    )
+
+                    # Show current file being processed
+                    console.print(
+                        f"\n[bold blue]📹 [{idx}/{len(video_files)}][/bold blue] "
+                        f"[yellow]{input_path.name}[/yellow]"
+                    )
+
+                    try:
+                        # Video processing task
+                        video_task = progress.add_task(
+                            f"  [green]Processing video", total=100
+                        )
+
+                        last_progress = [0]
+
+                        def progress_callback(prog: int):
+                            """Update the video progress bar"""
+                            if prog > last_progress[0]:
+                                progress.update(
+                                    video_task, advance=prog - last_progress[0]
+                                )
+                                last_progress[0] = prog
+
+                        # Process the video (quiet=True suppresses internal tqdm bars if enabled)
+                        self.sora_wm.run(
+                            input_path, output_path, progress_callback, quiet=args.quiet
+                        )
+
+                        # Ensure video progress reaches 100%
+                        if last_progress[0] < 100:
+                            progress.update(video_task, advance=100 - last_progress[0])
+
+                        progress.remove_task(video_task)
+
+                        self.successful.append(input_path.name)
+                        console.print(
+                            f"  [bold green]✅ Completed:[/bold green] {output_path.name}"
+                        )
+
+                    except Exception as e:
+                        progress.remove_task(video_task)
+                        self.failed[input_path.name] = str(e)
+                        console.print(f"  [bold red]❌ Error:[/bold red] {e}")
+
+                    # Update batch progress
+                    progress.update(batch_task, advance=1)
+
+            # Print summary
+            self._print_summary(start_time)
+
+        def _print_summary(self, start_time: datetime):
+            """Print processing summary with rich formatting"""
+            end_time = datetime.now()
+            duration = end_time - start_time
+
+            console.print()
+
+            # Create summary statistics table
+            summary_table = Table(
+                show_header=False, box=box.ROUNDED, border_style="cyan"
+            )
+            summary_table.add_column("Metric", style="bold")
+            summary_table.add_column("Value")
+
+            summary_table.add_row("⏱️  Total Time", f"[yellow]{duration}[/yellow]")
+            summary_table.add_row(
+                "✅ Successful", f"[bold green]{len(self.successful)}[/bold green]"
+            )
+            summary_table.add_row(
+                "❌ Failed", f"[bold red]{len(self.failed)}[/bold red]"
+            )
+            summary_table.add_row(
+                "📊 Total",
+                f"[bold magenta]{len(self.successful) + len(self.failed)}[/bold magenta]",
+            )
+
+            # Success rate
+            total = len(self.successful) + len(self.failed)
+            success_rate = (len(self.successful) / total * 100) if total > 0 else 0
+            summary_table.add_row(
+                "📈 Success Rate", f"[bold cyan]{success_rate:.1f}%[/bold cyan]"
+            )
+
+            # Wrap in a panel
+            summary_panel = Panel(
+                summary_table,
+                title="[bold white]📋 BATCH PROCESSING SUMMARY[/bold white]",
+                border_style="bright_cyan",
+                box=box.DOUBLE,
+            )
+            console.print(summary_panel)
+
+            # Successful files
+            if self.successful:
+                console.print()
+                success_table = Table(
+                    title="[bold green]✅ Successfully Processed[/bold green]",
+                    box=box.SIMPLE,
+                    show_header=True,
+                    header_style="bold green",
+                )
+                success_table.add_column("#", style="dim", width=4)
+                success_table.add_column("Filename", style="green")
+
+                for idx, filename in enumerate(self.successful, 1):
+                    success_table.add_row(str(idx), filename)
+
+                console.print(success_table)
+
+            # Failed files
+            if self.failed:
+                console.print()
+                failed_table = Table(
+                    title="[bold red]❌ Failed to Process[/bold red]",
+                    box=box.SIMPLE,
+                    show_header=True,
+                    header_style="bold red",
+                )
+                failed_table.add_column("#", style="dim", width=4)
+                failed_table.add_column("Filename", style="red")
+                failed_table.add_column("Error", style="dim")
+
+                for idx, (filename, error) in enumerate(self.failed.items(), 1):
+                    # Truncate long error messages
+                    error_msg = error if len(error) < 60 else error[:57] + "..."
+                    failed_table.add_row(str(idx), filename, error_msg)
+
+                console.print(failed_table)
+
+            # Final message
+            console.print()
+            if len(self.failed) == 0:
+                console.print(
+                    "[bold green]🎉 All videos processed successfully![/bold green]",
+                    justify="center",
+                )
+            else:
+                console.print(
+                    "[bold yellow]⚠️  Some videos failed to process. Check errors above.[/bold yellow]",
+                    justify="center",
+                )
+            console.print()
+
+    # Create processor and run
+    try:
+        cleaner_type = (
+            CleanerType.LAMA if args.model == "lama" else CleanerType.E2FGVI_HQ
+        )
+        processor = BatchProcessorImpl(
+            input_folder, output_folder, pattern, cleaner_type
+        )
+        processor.process_batch()
+    except KeyboardInterrupt:
+        console.print()
+        console.print(
+            "[bold yellow]⚠️  Processing interrupted by user[/bold yellow]",
+            justify="center",
+        )
+        sys.exit(130)
+    except Exception as e:
+        console.print()
+        console.print(f"[bold red]❌ Fatal error:[/bold red] {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()
+1

datasets/make_yolo_images.py

@@ -0,0 +1,64 @@
+from pathlib import Path
+
+import cv2
+from tqdm import tqdm
+
+from sorawm.configs import ROOT
+from sorawm.watermark_detector import SoraWaterMarkDetector
+
+videos_dir = ROOT / "videos"
+datasets_dir = ROOT / "datasets"
+images_dir = datasets_dir / "images"
+images_dir.mkdir(exist_ok=True, parents=True)
+detector = SoraWaterMarkDetector()
+
+
+if __name__ == "__main__":
+    fps_save_interval = 1  # Save every 5th frame
+
+    video_idx = 0
+    image_idx = 0  # 全局图片索引
+    total_failed = 0  # 检测失败的总数
+
+    for video_path in tqdm(list(videos_dir.rglob("*.mp4"))):
+        # Open the video file
+        cap = cv2.VideoCapture(str(video_path))
+        video_name = video_path.name
+        if not cap.isOpened():
+            print(f"Error opening video: {video_path}")
+            continue
+
+        frame_count = 0
+
+        try:
+            while True:
+                ret, frame = cap.read()
+
+                # Break if no more frames
+                if not ret:
+                    break
+
+                # Save frame at the specified interval
+                if frame_count % fps_save_interval == 0:
+                    if not detector.detect(frame)["detected"]:
+                        # Create filename: image_idx_framecount.jpg
+                        image_filename = (
+                            f"{video_name}_failed_image_frame_{frame_count:06d}.jpg"
+                        )
+                        image_path = images_dir / image_filename
+                        # Save the frame
+                        cv2.imwrite(str(image_path), frame)
+                        image_idx += 1
+                        total_failed += 1
+
+                frame_count += 1
+
+        finally:
+            # Release the video capture object
+            cap.release()
+
+        video_idx += 1
+
+    print(
+        f"Processed {video_idx} videos, extracted {total_failed} failed detection frames to {images_dir}"
+    )

docker-compose.yaml

@@ -0,0 +1,26 @@
+version: '3'
+services:
+  cog-video:
+    image: llinkedlist/sorawm:latest #nvidia/cuda:12.1.1-cudnn8-devel-ubuntu22.04
+    container_name: sorawm_container
+    ports:
+      - 5344:5344
+      - 8501:8501
+    command: streamlit run app.py --server.port 8501 --server.address 0.0.0.0
+    volumes:
+      - ./:/workspace
+      - ./.cache:/root/.cache       
+    deploy:
+      resources:
+        reservations:
+          devices:
+            - driver: nvidia
+              count: all
+              capabilities: [gpu]
+    tty: true
+    stdin_open: true
+    working_dir: /workspace
+    shm_size: '16gb'
+
+volumes:
+  huggingface_cache:

docker-entrypoint.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+set -e
+
+# Start FastAPI server in background
+python start_server.py --host 0.0.0.0 --port 5344 &
+
+# Start Streamlit (primary app, HF Spaces routes to app_port 8501)
+streamlit run app.py \
+  --server.port 8501 \
+  --server.address 0.0.0.0 \
+  --server.headless true \
+  --server.enableCORS false \
+  --server.enableXsrfProtection false

example.py

@@ -0,0 +1,22 @@
+from pathlib import Path
+
+from sorawm.core import SoraWM
+from sorawm.schemas import CleanerType
+
+if __name__ == "__main__":
+    input_video_path = Path("resources/dog_vs_sam.mp4")
+    output_video_path = Path("outputs/sora_watermark_removed")
+
+    # 1. LAMA is fast and good quality, but not time consistent.
+    sora_wm = SoraWM(cleaner_type=CleanerType.LAMA)
+    sora_wm.run(input_video_path, Path(f"{output_video_path}_lama.mp4"))
+
+    # 2. E2FGVI_HQ ensures time consistency, but will be very slow on no-cuda device.
+    sora_wm = SoraWM(cleaner_type=CleanerType.E2FGVI_HQ, enable_torch_compile=False)
+    sora_wm.run(input_video_path, Path(f"{output_video_path}_e2fgvi_hq.mp4"))
+
+    # 3. E2FGVI_HQ with torch compile is fast and good quality, but not time consistent.
+    sora_wm = SoraWM(cleaner_type=CleanerType.E2FGVI_HQ, enable_torch_compile=True)
+    sora_wm.run(
+        input_video_path, Path(f"{output_video_path}_e2fgvi_hq_torch_compile.mp4")
+    )

ffmpeg/README.md

@@ -0,0 +1,69 @@
+# FFmpeg 可执行文件目录
+
+## 用途
+
+这个目录用于存放 FFmpeg 可执行文件，使项目成为真正的便携版（无需系统安装 FFmpeg）。
+
+## Windows 用户配置步骤
+
+### 1. 下载 FFmpeg
+
+访问 [FFmpeg-Builds Release](https://github.com/BtbN/FFmpeg-Builds/releases) 页面：
+
+- 下载最新的 `ffmpeg-master-latest-win64-gpl.zip`（约 120MB）
+- 或者下载特定版本，如 `ffmpeg-n6.1-latest-win64-gpl-6.1.zip`
+
+### 2. 解压并复制文件
+
+1. 解压下载的 zip 文件
+2. 在解压后的文件夹中找到 `bin` 目录
+3. 将以下两个文件复制到**当前目录**（`ffmpeg/`）：
+   - `ffmpeg.exe` - FFmpeg 主程序
+   - `ffprobe.exe` - FFmpeg 媒体信息探测工具
+
+### 3. 验证配置
+
+完成后，此目录应包含：
+
+```
+ffmpeg/
+├── .gitkeep
+├── README.md
+├── ffmpeg.exe    ← 你复制的文件
+└── ffprobe.exe   ← 你复制的文件
+```
+
+### 4. 测试
+
+运行项目中的测试脚本验证配置：
+
+```bash
+python test_ffmpeg_setup.py
+```
+
+如果配置正确，你将看到：`✓ 测试通过！FFmpeg已正确配置并可以使用`
+
+## macOS/Linux 用户
+
+如果需要便携版，请：
+
+1. 下载对应平台的 FFmpeg 二进制文件
+2. 将 `ffmpeg` 和 `ffprobe` 可执行文件放到此目录
+3. 确保文件有执行权限：`chmod +x ffmpeg ffprobe`
+
+## 注意事项
+
+- 这些可执行文件不会被 git 提交（已在 `.gitignore` 中配置）
+- 程序会自动检测并使用此目录下的 FFmpeg
+- 如果此目录没有 FFmpeg，程序会尝试使用系统安装的版本
+
+## 下载链接汇总
+
+- **Windows**: https://github.com/BtbN/FFmpeg-Builds/releases
+- **官方网站**: https://ffmpeg.org/download.html
+- **镜像站点**: https://www.gyan.dev/ffmpeg/builds/ (Windows)
+
+## 许可证
+
+FFmpeg 使用 GPL 许可证，请遵守相关条款。
+

frontend/README.md

@@ -0,0 +1,38 @@
+# sorawm
+
+This template should help get you started developing with Vue 3 in Vite.
+
+## Recommended IDE Setup
+
+[VS Code](https://code.visualstudio.com/) + [Vue (Official)](https://marketplace.visualstudio.com/items?itemName=Vue.volar) (and disable Vetur).
+
+## Recommended Browser Setup
+
+- Chromium-based browsers (Chrome, Edge, Brave, etc.):
+  - [Vue.js devtools](https://chromewebstore.google.com/detail/vuejs-devtools/nhdogjmejiglipccpnnnanhbledajbpd) 
+  - [Turn on Custom Object Formatter in Chrome DevTools](http://bit.ly/object-formatters)
+- Firefox:
+  - [Vue.js devtools](https://addons.mozilla.org/en-US/firefox/addon/vue-js-devtools/)
+  - [Turn on Custom Object Formatter in Firefox DevTools](https://fxdx.dev/firefox-devtools-custom-object-formatters/)
+
+## Customize configuration
+
+See [Vite Configuration Reference](https://vite.dev/config/).
+
+## Project Setup
+
+```sh
+npm install
+```
+
+### Compile and Hot-Reload for Development
+
+```sh
+npm run dev
+```
+
+### Compile and Minify for Production
+
+```sh
+npm run build
+```

frontend/bun.lock

@@ -0,0 +1,409 @@
+{
+  "lockfileVersion": 1,
+  "workspaces": {
+    "": {
+      "name": "sorawm",
+      "dependencies": {
+        "element-plus": "^2.11.8",
+        "pinia": "^3.0.4",
+        "vue": "^3.5.22",
+      },
+      "devDependencies": {
+        "@vitejs/plugin-vue": "^6.0.1",
+        "vite": "^7.1.11",
+        "vite-plugin-vue-devtools": "^8.0.3",
+      },
+    },
+  },
+  "packages": {
+    "@babel/code-frame": ["@babel/code-frame@7.27.1", "", { "dependencies": { "@babel/helper-validator-identifier": "^7.27.1", "js-tokens": "^4.0.0", "picocolors": "^1.1.1" } }, "sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg=="],
+
+    "@babel/compat-data": ["@babel/compat-data@7.28.5", "", {}, "sha512-6uFXyCayocRbqhZOB+6XcuZbkMNimwfVGFji8CTZnCzOHVGvDqzvitu1re2AU5LROliz7eQPhB8CpAMvnx9EjA=="],
+
+    "@babel/core": ["@babel/core@7.28.5", "", { "dependencies": { "@babel/code-frame": "^7.27.1", "@babel/generator": "^7.28.5", "@babel/helper-compilation-targets": "^7.27.2", "@babel/helper-module-transforms": "^7.28.3", "@babel/helpers": "^7.28.4", "@babel/parser": "^7.28.5", "@babel/template": "^7.27.2", "@babel/traverse": "^7.28.5", "@babel/types": "^7.28.5", "@jridgewell/remapping": "^2.3.5", "convert-source-map": "^2.0.0", "debug": "^4.1.0", "gensync": "^1.0.0-beta.2", "json5": "^2.2.3", "semver": "^6.3.1" } }, "sha512-e7jT4DxYvIDLk1ZHmU/m/mB19rex9sv0c2ftBtjSBv+kVM/902eh0fINUzD7UwLLNR+jU585GxUJ8/EBfAM5fw=="],
+
+    "@babel/generator": ["@babel/generator@7.28.5", "", { "dependencies": { "@babel/parser": "^7.28.5", "@babel/types": "^7.28.5", "@jridgewell/gen-mapping": "^0.3.12", "@jridgewell/trace-mapping": "^0.3.28", "jsesc": "^3.0.2" } }, "sha512-3EwLFhZ38J4VyIP6WNtt2kUdW9dokXA9Cr4IVIFHuCpZ3H8/YFOl5JjZHisrn1fATPBmKKqXzDFvh9fUwHz6CQ=="],
+
+    "@babel/helper-annotate-as-pure": ["@babel/helper-annotate-as-pure@7.27.3", "", { "dependencies": { "@babel/types": "^7.27.3" } }, "sha512-fXSwMQqitTGeHLBC08Eq5yXz2m37E4pJX1qAU1+2cNedz/ifv/bVXft90VeSav5nFO61EcNgwr0aJxbyPaWBPg=="],
+
+    "@babel/helper-compilation-targets": ["@babel/helper-compilation-targets@7.27.2", "", { "dependencies": { "@babel/compat-data": "^7.27.2", "@babel/helper-validator-option": "^7.27.1", "browserslist": "^4.24.0", "lru-cache": "^5.1.1", "semver": "^6.3.1" } }, "sha512-2+1thGUUWWjLTYTHZWK1n8Yga0ijBz1XAhUXcKy81rd5g6yh7hGqMp45v7cadSbEHc9G3OTv45SyneRN3ps4DQ=="],
+
+    "@babel/helper-create-class-features-plugin": ["@babel/helper-create-class-features-plugin@7.28.5", "", { "dependencies": { "@babel/helper-annotate-as-pure": "^7.27.3", "@babel/helper-member-expression-to-functions": "^7.28.5", "@babel/helper-optimise-call-expression": "^7.27.1", "@babel/helper-replace-supers": "^7.27.1", "@babel/helper-skip-transparent-expression-wrappers": "^7.27.1", "@babel/traverse": "^7.28.5", "semver": "^6.3.1" }, "peerDependencies": { "@babel/core": "^7.0.0" } }, "sha512-q3WC4JfdODypvxArsJQROfupPBq9+lMwjKq7C33GhbFYJsufD0yd/ziwD+hJucLeWsnFPWZjsU2DNFqBPE7jwQ=="],
+
+    "@babel/helper-globals": ["@babel/helper-globals@7.28.0", "", {}, "sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw=="],
+
+    "@babel/helper-member-expression-to-functions": ["@babel/helper-member-expression-to-functions@7.28.5", "", { "dependencies": { "@babel/traverse": "^7.28.5", "@babel/types": "^7.28.5" } }, "sha512-cwM7SBRZcPCLgl8a7cY0soT1SptSzAlMH39vwiRpOQkJlh53r5hdHwLSCZpQdVLT39sZt+CRpNwYG4Y2v77atg=="],
+
+    "@babel/helper-module-imports": ["@babel/helper-module-imports@7.27.1", "", { "dependencies": { "@babel/traverse": "^7.27.1", "@babel/types": "^7.27.1" } }, "sha512-0gSFWUPNXNopqtIPQvlD5WgXYI5GY2kP2cCvoT8kczjbfcfuIljTbcWrulD1CIPIX2gt1wghbDy08yE1p+/r3w=="],
+
+    "@babel/helper-module-transforms": ["@babel/helper-module-transforms@7.28.3", "", { "dependencies": { "@babel/helper-module-imports": "^7.27.1", "@babel/helper-validator-identifier": "^7.27.1", "@babel/traverse": "^7.28.3" }, "peerDependencies": { "@babel/core": "^7.0.0" } }, "sha512-gytXUbs8k2sXS9PnQptz5o0QnpLL51SwASIORY6XaBKF88nsOT0Zw9szLqlSGQDP/4TljBAD5y98p2U1fqkdsw=="],
+
+    "@babel/helper-optimise-call-expression": ["@babel/helper-optimise-call-expression@7.27.1", "", { "dependencies": { "@babel/types": "^7.27.1" } }, "sha512-URMGH08NzYFhubNSGJrpUEphGKQwMQYBySzat5cAByY1/YgIRkULnIy3tAMeszlL/so2HbeilYloUmSpd7GdVw=="],
+
+    "@babel/helper-plugin-utils": ["@babel/helper-plugin-utils@7.27.1", "", {}, "sha512-1gn1Up5YXka3YYAHGKpbideQ5Yjf1tDa9qYcgysz+cNCXukyLl6DjPXhD3VRwSb8c0J9tA4b2+rHEZtc6R0tlw=="],
+
+    "@babel/helper-replace-supers": ["@babel/helper-replace-supers@7.27.1", "", { "dependencies": { "@babel/helper-member-expression-to-functions": "^7.27.1", "@babel/helper-optimise-call-expression": "^7.27.1", "@babel/traverse": "^7.27.1" }, "peerDependencies": { "@babel/core": "^7.0.0" } }, "sha512-7EHz6qDZc8RYS5ElPoShMheWvEgERonFCs7IAonWLLUTXW59DP14bCZt89/GKyreYn8g3S83m21FelHKbeDCKA=="],
+
+    "@babel/helper-skip-transparent-expression-wrappers": ["@babel/helper-skip-transparent-expression-wrappers@7.27.1", "", { "dependencies": { "@babel/traverse": "^7.27.1", "@babel/types": "^7.27.1" } }, "sha512-Tub4ZKEXqbPjXgWLl2+3JpQAYBJ8+ikpQ2Ocj/q/r0LwE3UhENh7EUabyHjz2kCEsrRY83ew2DQdHluuiDQFzg=="],
+
+    "@babel/helper-string-parser": ["@babel/helper-string-parser@7.27.1", "", {}, "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA=="],
+
+    "@babel/helper-validator-identifier": ["@babel/helper-validator-identifier@7.28.5", "", {}, "sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q=="],
+
+    "@babel/helper-validator-option": ["@babel/helper-validator-option@7.27.1", "", {}, "sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg=="],
+
+    "@babel/helpers": ["@babel/helpers@7.28.4", "", { "dependencies": { "@babel/template": "^7.27.2", "@babel/types": "^7.28.4" } }, "sha512-HFN59MmQXGHVyYadKLVumYsA9dBFun/ldYxipEjzA4196jpLZd8UjEEBLkbEkvfYreDqJhZxYAWFPtrfhNpj4w=="],
+
+    "@babel/parser": ["@babel/parser@7.28.5", "", { "dependencies": { "@babel/types": "^7.28.5" }, "bin": "./bin/babel-parser.js" }, "sha512-KKBU1VGYR7ORr3At5HAtUQ+TV3SzRCXmA/8OdDZiLDBIZxVyzXuztPjfLd3BV1PRAQGCMWWSHYhL0F8d5uHBDQ=="],
+
+    "@babel/plugin-proposal-decorators": ["@babel/plugin-proposal-decorators@7.28.0", "", { "dependencies": { "@babel/helper-create-class-features-plugin": "^7.27.1", "@babel/helper-plugin-utils": "^7.27.1", "@babel/plugin-syntax-decorators": "^7.27.1" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "sha512-zOiZqvANjWDUaUS9xMxbMcK/Zccztbe/6ikvUXaG9nsPH3w6qh5UaPGAnirI/WhIbZ8m3OHU0ReyPrknG+ZKeg=="],
+
+    "@babel/plugin-syntax-decorators": ["@babel/plugin-syntax-decorators@7.27.1", "", { "dependencies": { "@babel/helper-plugin-utils": "^7.27.1" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "sha512-YMq8Z87Lhl8EGkmb0MwYkt36QnxC+fzCgrl66ereamPlYToRpIk5nUjKUY3QKLWq8mwUB1BgbeXcTJhZOCDg5A=="],
+
+    "@babel/plugin-syntax-import-attributes": ["@babel/plugin-syntax-import-attributes@7.27.1", "", { "dependencies": { "@babel/helper-plugin-utils": "^7.27.1" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "sha512-oFT0FrKHgF53f4vOsZGi2Hh3I35PfSmVs4IBFLFj4dnafP+hIWDLg3VyKmUHfLoLHlyxY4C7DGtmHuJgn+IGww=="],
+
+    "@babel/plugin-syntax-import-meta": ["@babel/plugin-syntax-import-meta@7.10.4", "", { "dependencies": { "@babel/helper-plugin-utils": "^7.10.4" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "sha512-Yqfm+XDx0+Prh3VSeEQCPU81yC+JWZ2pDPFSS4ZdpfZhp4MkFMaDC1UqseovEKwSUpnIL7+vK+Clp7bfh0iD7g=="],
+
+    "@babel/plugin-syntax-jsx": ["@babel/plugin-syntax-jsx@7.27.1", "", { "dependencies": { "@babel/helper-plugin-utils": "^7.27.1" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "sha512-y8YTNIeKoyhGd9O0Jiyzyyqk8gdjnumGTQPsz0xOZOQ2RmkVJeZ1vmmfIvFEKqucBG6axJGBZDE/7iI5suUI/w=="],
+
+    "@babel/plugin-syntax-typescript": ["@babel/plugin-syntax-typescript@7.27.1", "", { "dependencies": { "@babel/helper-plugin-utils": "^7.27.1" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "sha512-xfYCBMxveHrRMnAWl1ZlPXOZjzkN82THFvLhQhFXFt81Z5HnN+EtUkZhv/zcKpmT3fzmWZB0ywiBrbC3vogbwQ=="],
+
+    "@babel/plugin-transform-typescript": ["@babel/plugin-transform-typescript@7.28.5", "", { "dependencies": { "@babel/helper-annotate-as-pure": "^7.27.3", "@babel/helper-create-class-features-plugin": "^7.28.5", "@babel/helper-plugin-utils": "^7.27.1", "@babel/helper-skip-transparent-expression-wrappers": "^7.27.1", "@babel/plugin-syntax-typescript": "^7.27.1" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "sha512-x2Qa+v/CuEoX7Dr31iAfr0IhInrVOWZU/2vJMJ00FOR/2nM0BcBEclpaf9sWCDc+v5e9dMrhSH8/atq/kX7+bA=="],
+
+    "@babel/template": ["@babel/template@7.27.2", "", { "dependencies": { "@babel/code-frame": "^7.27.1", "@babel/parser": "^7.27.2", "@babel/types": "^7.27.1" } }, "sha512-LPDZ85aEJyYSd18/DkjNh4/y1ntkE5KwUHWTiqgRxruuZL2F1yuHligVHLvcHY2vMHXttKFpJn6LwfI7cw7ODw=="],
+
+    "@babel/traverse": ["@babel/traverse@7.28.5", "", { "dependencies": { "@babel/code-frame": "^7.27.1", "@babel/generator": "^7.28.5", "@babel/helper-globals": "^7.28.0", "@babel/parser": "^7.28.5", "@babel/template": "^7.27.2", "@babel/types": "^7.28.5", "debug": "^4.3.1" } }, "sha512-TCCj4t55U90khlYkVV/0TfkJkAkUg3jZFA3Neb7unZT8CPok7iiRfaX0F+WnqWqt7OxhOn0uBKXCw4lbL8W0aQ=="],
+
+    "@babel/types": ["@babel/types@7.28.5", "", { "dependencies": { "@babel/helper-string-parser": "^7.27.1", "@babel/helper-validator-identifier": "^7.28.5" } }, "sha512-qQ5m48eI/MFLQ5PxQj4PFaprjyCTLI37ElWMmNs0K8Lk3dVeOdNpB3ks8jc7yM5CDmVC73eMVk/trk3fgmrUpA=="],
+
+    "@ctrl/tinycolor": ["@ctrl/tinycolor@3.6.1", "", {}, "sha512-SITSV6aIXsuVNV3f3O0f2n/cgyEDWoSqtZMYiAmcsYHydcKrOz3gUxB/iXd/Qf08+IZX4KpgNbvUdMBmWz+kcA=="],
+
+    "@element-plus/icons-vue": ["@element-plus/icons-vue@2.3.2", "", { "peerDependencies": { "vue": "^3.2.0" } }, "sha512-OzIuTaIfC8QXEPmJvB4Y4kw34rSXdCJzxcD1kFStBvr8bK6X1zQAYDo0CNMjojnfTqRQCJ0I7prlErcoRiET2A=="],
+
+    "@esbuild/aix-ppc64": ["@esbuild/aix-ppc64@0.25.12", "", { "os": "aix", "cpu": "ppc64" }, "sha512-Hhmwd6CInZ3dwpuGTF8fJG6yoWmsToE+vYgD4nytZVxcu1ulHpUQRAB1UJ8+N1Am3Mz4+xOByoQoSZf4D+CpkA=="],
+
+    "@esbuild/android-arm": ["@esbuild/android-arm@0.25.12", "", { "os": "android", "cpu": "arm" }, "sha512-VJ+sKvNA/GE7Ccacc9Cha7bpS8nyzVv0jdVgwNDaR4gDMC/2TTRc33Ip8qrNYUcpkOHUT5OZ0bUcNNVZQ9RLlg=="],
+
+    "@esbuild/android-arm64": ["@esbuild/android-arm64@0.25.12", "", { "os": "android", "cpu": "arm64" }, "sha512-6AAmLG7zwD1Z159jCKPvAxZd4y/VTO0VkprYy+3N2FtJ8+BQWFXU+OxARIwA46c5tdD9SsKGZ/1ocqBS/gAKHg=="],
+
+    "@esbuild/android-x64": ["@esbuild/android-x64@0.25.12", "", { "os": "android", "cpu": "x64" }, "sha512-5jbb+2hhDHx5phYR2By8GTWEzn6I9UqR11Kwf22iKbNpYrsmRB18aX/9ivc5cabcUiAT/wM+YIZ6SG9QO6a8kg=="],
+
+    "@esbuild/darwin-arm64": ["@esbuild/darwin-arm64@0.25.12", "", { "os": "darwin", "cpu": "arm64" }, "sha512-N3zl+lxHCifgIlcMUP5016ESkeQjLj/959RxxNYIthIg+CQHInujFuXeWbWMgnTo4cp5XVHqFPmpyu9J65C1Yg=="],
+
+    "@esbuild/darwin-x64": ["@esbuild/darwin-x64@0.25.12", "", { "os": "darwin", "cpu": "x64" }, "sha512-HQ9ka4Kx21qHXwtlTUVbKJOAnmG1ipXhdWTmNXiPzPfWKpXqASVcWdnf2bnL73wgjNrFXAa3yYvBSd9pzfEIpA=="],
+
+    "@esbuild/freebsd-arm64": ["@esbuild/freebsd-arm64@0.25.12", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-gA0Bx759+7Jve03K1S0vkOu5Lg/85dou3EseOGUes8flVOGxbhDDh/iZaoek11Y8mtyKPGF3vP8XhnkDEAmzeg=="],
+
+    "@esbuild/freebsd-x64": ["@esbuild/freebsd-x64@0.25.12", "", { "os": "freebsd", "cpu": "x64" }, "sha512-TGbO26Yw2xsHzxtbVFGEXBFH0FRAP7gtcPE7P5yP7wGy7cXK2oO7RyOhL5NLiqTlBh47XhmIUXuGciXEqYFfBQ=="],
+
+    "@esbuild/linux-arm": ["@esbuild/linux-arm@0.25.12", "", { "os": "linux", "cpu": "arm" }, "sha512-lPDGyC1JPDou8kGcywY0YILzWlhhnRjdof3UlcoqYmS9El818LLfJJc3PXXgZHrHCAKs/Z2SeZtDJr5MrkxtOw=="],
+
+    "@esbuild/linux-arm64": ["@esbuild/linux-arm64@0.25.12", "", { "os": "linux", "cpu": "arm64" }, "sha512-8bwX7a8FghIgrupcxb4aUmYDLp8pX06rGh5HqDT7bB+8Rdells6mHvrFHHW2JAOPZUbnjUpKTLg6ECyzvas2AQ=="],
+
+    "@esbuild/linux-ia32": ["@esbuild/linux-ia32@0.25.12", "", { "os": "linux", "cpu": "ia32" }, "sha512-0y9KrdVnbMM2/vG8KfU0byhUN+EFCny9+8g202gYqSSVMonbsCfLjUO+rCci7pM0WBEtz+oK/PIwHkzxkyharA=="],
+
+    "@esbuild/linux-loong64": ["@esbuild/linux-loong64@0.25.12", "", { "os": "linux", "cpu": "none" }, "sha512-h///Lr5a9rib/v1GGqXVGzjL4TMvVTv+s1DPoxQdz7l/AYv6LDSxdIwzxkrPW438oUXiDtwM10o9PmwS/6Z0Ng=="],
+
+    "@esbuild/linux-mips64el": ["@esbuild/linux-mips64el@0.25.12", "", { "os": "linux", "cpu": "none" }, "sha512-iyRrM1Pzy9GFMDLsXn1iHUm18nhKnNMWscjmp4+hpafcZjrr2WbT//d20xaGljXDBYHqRcl8HnxbX6uaA/eGVw=="],
+
+    "@esbuild/linux-ppc64": ["@esbuild/linux-ppc64@0.25.12", "", { "os": "linux", "cpu": "ppc64" }, "sha512-9meM/lRXxMi5PSUqEXRCtVjEZBGwB7P/D4yT8UG/mwIdze2aV4Vo6U5gD3+RsoHXKkHCfSxZKzmDssVlRj1QQA=="],
+
+    "@esbuild/linux-riscv64": ["@esbuild/linux-riscv64@0.25.12", "", { "os": "linux", "cpu": "none" }, "sha512-Zr7KR4hgKUpWAwb1f3o5ygT04MzqVrGEGXGLnj15YQDJErYu/BGg+wmFlIDOdJp0PmB0lLvxFIOXZgFRrdjR0w=="],
+
+    "@esbuild/linux-s390x": ["@esbuild/linux-s390x@0.25.12", "", { "os": "linux", "cpu": "s390x" }, "sha512-MsKncOcgTNvdtiISc/jZs/Zf8d0cl/t3gYWX8J9ubBnVOwlk65UIEEvgBORTiljloIWnBzLs4qhzPkJcitIzIg=="],
+
+    "@esbuild/linux-x64": ["@esbuild/linux-x64@0.25.12", "", { "os": "linux", "cpu": "x64" }, "sha512-uqZMTLr/zR/ed4jIGnwSLkaHmPjOjJvnm6TVVitAa08SLS9Z0VM8wIRx7gWbJB5/J54YuIMInDquWyYvQLZkgw=="],
+
+    "@esbuild/netbsd-arm64": ["@esbuild/netbsd-arm64@0.25.12", "", { "os": "none", "cpu": "arm64" }, "sha512-xXwcTq4GhRM7J9A8Gv5boanHhRa/Q9KLVmcyXHCTaM4wKfIpWkdXiMog/KsnxzJ0A1+nD+zoecuzqPmCRyBGjg=="],
+
+    "@esbuild/netbsd-x64": ["@esbuild/netbsd-x64@0.25.12", "", { "os": "none", "cpu": "x64" }, "sha512-Ld5pTlzPy3YwGec4OuHh1aCVCRvOXdH8DgRjfDy/oumVovmuSzWfnSJg+VtakB9Cm0gxNO9BzWkj6mtO1FMXkQ=="],
+
+    "@esbuild/openbsd-arm64": ["@esbuild/openbsd-arm64@0.25.12", "", { "os": "openbsd", "cpu": "arm64" }, "sha512-fF96T6KsBo/pkQI950FARU9apGNTSlZGsv1jZBAlcLL1MLjLNIWPBkj5NlSz8aAzYKg+eNqknrUJ24QBybeR5A=="],
+
+    "@esbuild/openbsd-x64": ["@esbuild/openbsd-x64@0.25.12", "", { "os": "openbsd", "cpu": "x64" }, "sha512-MZyXUkZHjQxUvzK7rN8DJ3SRmrVrke8ZyRusHlP+kuwqTcfWLyqMOE3sScPPyeIXN/mDJIfGXvcMqCgYKekoQw=="],
+
+    "@esbuild/openharmony-arm64": ["@esbuild/openharmony-arm64@0.25.12", "", { "os": "none", "cpu": "arm64" }, "sha512-rm0YWsqUSRrjncSXGA7Zv78Nbnw4XL6/dzr20cyrQf7ZmRcsovpcRBdhD43Nuk3y7XIoW2OxMVvwuRvk9XdASg=="],
+
+    "@esbuild/sunos-x64": ["@esbuild/sunos-x64@0.25.12", "", { "os": "sunos", "cpu": "x64" }, "sha512-3wGSCDyuTHQUzt0nV7bocDy72r2lI33QL3gkDNGkod22EsYl04sMf0qLb8luNKTOmgF/eDEDP5BFNwoBKH441w=="],
+
+    "@esbuild/win32-arm64": ["@esbuild/win32-arm64@0.25.12", "", { "os": "win32", "cpu": "arm64" }, "sha512-rMmLrur64A7+DKlnSuwqUdRKyd3UE7oPJZmnljqEptesKM8wx9J8gx5u0+9Pq0fQQW8vqeKebwNXdfOyP+8Bsg=="],
+
+    "@esbuild/win32-ia32": ["@esbuild/win32-ia32@0.25.12", "", { "os": "win32", "cpu": "ia32" }, "sha512-HkqnmmBoCbCwxUKKNPBixiWDGCpQGVsrQfJoVGYLPT41XWF8lHuE5N6WhVia2n4o5QK5M4tYr21827fNhi4byQ=="],
+
+    "@esbuild/win32-x64": ["@esbuild/win32-x64@0.25.12", "", { "os": "win32", "cpu": "x64" }, "sha512-alJC0uCZpTFrSL0CCDjcgleBXPnCrEAhTBILpeAp7M/OFgoqtAetfBzX0xM00MUsVVPpVjlPuMbREqnZCXaTnA=="],
+
+    "@floating-ui/core": ["@floating-ui/core@1.7.3", "", { "dependencies": { "@floating-ui/utils": "^0.2.10" } }, "sha512-sGnvb5dmrJaKEZ+LDIpguvdX3bDlEllmv4/ClQ9awcmCZrlx5jQyyMWFM5kBI+EyNOCDDiKk8il0zeuX3Zlg/w=="],
+
+    "@floating-ui/dom": ["@floating-ui/dom@1.7.4", "", { "dependencies": { "@floating-ui/core": "^1.7.3", "@floating-ui/utils": "^0.2.10" } }, "sha512-OOchDgh4F2CchOX94cRVqhvy7b3AFb+/rQXyswmzmGakRfkMgoWVjfnLWkRirfLEfuD4ysVW16eXzwt3jHIzKA=="],
+
+    "@floating-ui/utils": ["@floating-ui/utils@0.2.10", "", {}, "sha512-aGTxbpbg8/b5JfU1HXSrbH3wXZuLPJcNEcZQFMxLs3oSzgtVu6nFPkbbGGUvBcUjKV2YyB9Wxxabo+HEH9tcRQ=="],
+
+    "@jridgewell/gen-mapping": ["@jridgewell/gen-mapping@0.3.13", "", { "dependencies": { "@jridgewell/sourcemap-codec": "^1.5.0", "@jridgewell/trace-mapping": "^0.3.24" } }, "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA=="],
+
+    "@jridgewell/remapping": ["@jridgewell/remapping@2.3.5", "", { "dependencies": { "@jridgewell/gen-mapping": "^0.3.5", "@jridgewell/trace-mapping": "^0.3.24" } }, "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ=="],
+
+    "@jridgewell/resolve-uri": ["@jridgewell/resolve-uri@3.1.2", "", {}, "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw=="],
+
+    "@jridgewell/sourcemap-codec": ["@jridgewell/sourcemap-codec@1.5.5", "", {}, "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og=="],
+
+    "@jridgewell/trace-mapping": ["@jridgewell/trace-mapping@0.3.31", "", { "dependencies": { "@jridgewell/resolve-uri": "^3.1.0", "@jridgewell/sourcemap-codec": "^1.4.14" } }, "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw=="],
+
+    "@polka/url": ["@polka/url@1.0.0-next.29", "", {}, "sha512-wwQAWhWSuHaag8c4q/KN/vCoeOJYshAIvMQwD4GpSb3OiZklFfvAgmj0VCBBImRpuF/aFgIRzllXlVX93Jevww=="],
+
+    "@popperjs/core": ["@sxzz/popperjs-es@2.11.7", "", {}, "sha512-Ccy0NlLkzr0Ex2FKvh2X+OyERHXJ88XJ1MXtsI9y9fGexlaXaVTPzBCRBwIxFkORuOb+uBqeu+RqnpgYTEZRUQ=="],
+
+    "@rolldown/pluginutils": ["@rolldown/pluginutils@1.0.0-beta.50", "", {}, "sha512-5e76wQiQVeL1ICOZVUg4LSOVYg9jyhGCin+icYozhsUzM+fHE7kddi1bdiE0jwVqTfkjba3jUFbEkoC9WkdvyA=="],
+
+    "@rollup/rollup-android-arm-eabi": ["@rollup/rollup-android-arm-eabi@4.53.3", "", { "os": "android", "cpu": "arm" }, "sha512-mRSi+4cBjrRLoaal2PnqH82Wqyb+d3HsPUN/W+WslCXsZsyHa9ZeQQX/pQsZaVIWDkPcpV6jJ+3KLbTbgnwv8w=="],
+
+    "@rollup/rollup-android-arm64": ["@rollup/rollup-android-arm64@4.53.3", "", { "os": "android", "cpu": "arm64" }, "sha512-CbDGaMpdE9sh7sCmTrTUyllhrg65t6SwhjlMJsLr+J8YjFuPmCEjbBSx4Z/e4SmDyH3aB5hGaJUP2ltV/vcs4w=="],
+
+    "@rollup/rollup-darwin-arm64": ["@rollup/rollup-darwin-arm64@4.53.3", "", { "os": "darwin", "cpu": "arm64" }, "sha512-Nr7SlQeqIBpOV6BHHGZgYBuSdanCXuw09hon14MGOLGmXAFYjx1wNvquVPmpZnl0tLjg25dEdr4IQ6GgyToCUA=="],
+
+    "@rollup/rollup-darwin-x64": ["@rollup/rollup-darwin-x64@4.53.3", "", { "os": "darwin", "cpu": "x64" }, "sha512-DZ8N4CSNfl965CmPktJ8oBnfYr3F8dTTNBQkRlffnUarJ2ohudQD17sZBa097J8xhQ26AwhHJ5mvUyQW8ddTsQ=="],
+
+    "@rollup/rollup-freebsd-arm64": ["@rollup/rollup-freebsd-arm64@4.53.3", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-yMTrCrK92aGyi7GuDNtGn2sNW+Gdb4vErx4t3Gv/Tr+1zRb8ax4z8GWVRfr3Jw8zJWvpGHNpss3vVlbF58DZ4w=="],
+
+    "@rollup/rollup-freebsd-x64": ["@rollup/rollup-freebsd-x64@4.53.3", "", { "os": "freebsd", "cpu": "x64" }, "sha512-lMfF8X7QhdQzseM6XaX0vbno2m3hlyZFhwcndRMw8fbAGUGL3WFMBdK0hbUBIUYcEcMhVLr1SIamDeuLBnXS+Q=="],
+
+    "@rollup/rollup-linux-arm-gnueabihf": ["@rollup/rollup-linux-arm-gnueabihf@4.53.3", "", { "os": "linux", "cpu": "arm" }, "sha512-k9oD15soC/Ln6d2Wv/JOFPzZXIAIFLp6B+i14KhxAfnq76ajt0EhYc5YPeX6W1xJkAdItcVT+JhKl1QZh44/qw=="],
+
+    "@rollup/rollup-linux-arm-musleabihf": ["@rollup/rollup-linux-arm-musleabihf@4.53.3", "", { "os": "linux", "cpu": "arm" }, "sha512-vTNlKq+N6CK/8UktsrFuc+/7NlEYVxgaEgRXVUVK258Z5ymho29skzW1sutgYjqNnquGwVUObAaxae8rZ6YMhg=="],
+
+    "@rollup/rollup-linux-arm64-gnu": ["@rollup/rollup-linux-arm64-gnu@4.53.3", "", { "os": "linux", "cpu": "arm64" }, "sha512-RGrFLWgMhSxRs/EWJMIFM1O5Mzuz3Xy3/mnxJp/5cVhZ2XoCAxJnmNsEyeMJtpK+wu0FJFWz+QF4mjCA7AUQ3w=="],
+
+    "@rollup/rollup-linux-arm64-musl": ["@rollup/rollup-linux-arm64-musl@4.53.3", "", { "os": "linux", "cpu": "arm64" }, "sha512-kASyvfBEWYPEwe0Qv4nfu6pNkITLTb32p4yTgzFCocHnJLAHs+9LjUu9ONIhvfT/5lv4YS5muBHyuV84epBo/A=="],
+
+    "@rollup/rollup-linux-loong64-gnu": ["@rollup/rollup-linux-loong64-gnu@4.53.3", "", { "os": "linux", "cpu": "none" }, "sha512-JiuKcp2teLJwQ7vkJ95EwESWkNRFJD7TQgYmCnrPtlu50b4XvT5MOmurWNrCj3IFdyjBQ5p9vnrX4JM6I8OE7g=="],
+
+    "@rollup/rollup-linux-ppc64-gnu": ["@rollup/rollup-linux-ppc64-gnu@4.53.3", "", { "os": "linux", "cpu": "ppc64" }, "sha512-EoGSa8nd6d3T7zLuqdojxC20oBfNT8nexBbB/rkxgKj5T5vhpAQKKnD+h3UkoMuTyXkP5jTjK/ccNRmQrPNDuw=="],
+
+    "@rollup/rollup-linux-riscv64-gnu": ["@rollup/rollup-linux-riscv64-gnu@4.53.3", "", { "os": "linux", "cpu": "none" }, "sha512-4s+Wped2IHXHPnAEbIB0YWBv7SDohqxobiiPA1FIWZpX+w9o2i4LezzH/NkFUl8LRci/8udci6cLq+jJQlh+0g=="],
+
+    "@rollup/rollup-linux-riscv64-musl": ["@rollup/rollup-linux-riscv64-musl@4.53.3", "", { "os": "linux", "cpu": "none" }, "sha512-68k2g7+0vs2u9CxDt5ktXTngsxOQkSEV/xBbwlqYcUrAVh6P9EgMZvFsnHy4SEiUl46Xf0IObWVbMvPrr2gw8A=="],
+
+    "@rollup/rollup-linux-s390x-gnu": ["@rollup/rollup-linux-s390x-gnu@4.53.3", "", { "os": "linux", "cpu": "s390x" }, "sha512-VYsFMpULAz87ZW6BVYw3I6sWesGpsP9OPcyKe8ofdg9LHxSbRMd7zrVrr5xi/3kMZtpWL/wC+UIJWJYVX5uTKg=="],
+
+    "@rollup/rollup-linux-x64-gnu": ["@rollup/rollup-linux-x64-gnu@4.53.3", "", { "os": "linux", "cpu": "x64" }, "sha512-3EhFi1FU6YL8HTUJZ51imGJWEX//ajQPfqWLI3BQq4TlvHy4X0MOr5q3D2Zof/ka0d5FNdPwZXm3Yyib/UEd+w=="],
+
+    "@rollup/rollup-linux-x64-musl": ["@rollup/rollup-linux-x64-musl@4.53.3", "", { "os": "linux", "cpu": "x64" }, "sha512-eoROhjcc6HbZCJr+tvVT8X4fW3/5g/WkGvvmwz/88sDtSJzO7r/blvoBDgISDiCjDRZmHpwud7h+6Q9JxFwq1Q=="],
+
+    "@rollup/rollup-openharmony-arm64": ["@rollup/rollup-openharmony-arm64@4.53.3", "", { "os": "none", "cpu": "arm64" }, "sha512-OueLAWgrNSPGAdUdIjSWXw+u/02BRTcnfw9PN41D2vq/JSEPnJnVuBgw18VkN8wcd4fjUs+jFHVM4t9+kBSNLw=="],
+
+    "@rollup/rollup-win32-arm64-msvc": ["@rollup/rollup-win32-arm64-msvc@4.53.3", "", { "os": "win32", "cpu": "arm64" }, "sha512-GOFuKpsxR/whszbF/bzydebLiXIHSgsEUp6M0JI8dWvi+fFa1TD6YQa4aSZHtpmh2/uAlj/Dy+nmby3TJ3pkTw=="],
+
+    "@rollup/rollup-win32-ia32-msvc": ["@rollup/rollup-win32-ia32-msvc@4.53.3", "", { "os": "win32", "cpu": "ia32" }, "sha512-iah+THLcBJdpfZ1TstDFbKNznlzoxa8fmnFYK4V67HvmuNYkVdAywJSoteUszvBQ9/HqN2+9AZghbajMsFT+oA=="],
+
+    "@rollup/rollup-win32-x64-gnu": ["@rollup/rollup-win32-x64-gnu@4.53.3", "", { "os": "win32", "cpu": "x64" }, "sha512-J9QDiOIZlZLdcot5NXEepDkstocktoVjkaKUtqzgzpt2yWjGlbYiKyp05rWwk4nypbYUNoFAztEgixoLaSETkg=="],
+
+    "@rollup/rollup-win32-x64-msvc": ["@rollup/rollup-win32-x64-msvc@4.53.3", "", { "os": "win32", "cpu": "x64" }, "sha512-UhTd8u31dXadv0MopwGgNOBpUVROFKWVQgAg5N1ESyCz8AuBcMqm4AuTjrwgQKGDfoFuz02EuMRHQIw/frmYKQ=="],
+
+    "@types/estree": ["@types/estree@1.0.8", "", {}, "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w=="],
+
+    "@types/lodash": ["@types/lodash@4.17.21", "", {}, "sha512-FOvQ0YPD5NOfPgMzJihoT+Za5pdkDJWcbpuj1DjaKZIr/gxodQjY/uWEFlTNqW2ugXHUiL8lRQgw63dzKHZdeQ=="],
+
+    "@types/lodash-es": ["@types/lodash-es@4.17.12", "", { "dependencies": { "@types/lodash": "*" } }, "sha512-0NgftHUcV4v34VhXm8QBSftKVXtbkBG3ViCjs6+eJ5a6y6Mi/jiFGPc1sC7QK+9BFhWrURE3EOggmWaSxL9OzQ=="],
+
+    "@types/web-bluetooth": ["@types/web-bluetooth@0.0.16", "", {}, "sha512-oh8q2Zc32S6gd/j50GowEjKLoOVOwHP/bWVjKJInBwQqdOYMdPrf1oVlelTlyfFK3CKxL1uahMDAr+vy8T7yMQ=="],
+
+    "@vitejs/plugin-vue": ["@vitejs/plugin-vue@6.0.2", "", { "dependencies": { "@rolldown/pluginutils": "1.0.0-beta.50" }, "peerDependencies": { "vite": "^5.0.0 || ^6.0.0 || ^7.0.0", "vue": "^3.2.25" } }, "sha512-iHmwV3QcVGGvSC1BG5bZ4z6iwa1SOpAPWmnjOErd4Ske+lZua5K9TtAVdx0gMBClJ28DViCbSmZitjWZsWO3LA=="],
+
+    "@vue/babel-helper-vue-transform-on": ["@vue/babel-helper-vue-transform-on@1.5.0", "", {}, "sha512-0dAYkerNhhHutHZ34JtTl2czVQHUNWv6xEbkdF5W+Yrv5pCWsqjeORdOgbtW2I9gWlt+wBmVn+ttqN9ZxR5tzA=="],
+
+    "@vue/babel-plugin-jsx": ["@vue/babel-plugin-jsx@1.5.0", "", { "dependencies": { "@babel/helper-module-imports": "^7.27.1", "@babel/helper-plugin-utils": "^7.27.1", "@babel/plugin-syntax-jsx": "^7.27.1", "@babel/template": "^7.27.2", "@babel/traverse": "^7.28.0", "@babel/types": "^7.28.2", "@vue/babel-helper-vue-transform-on": "1.5.0", "@vue/babel-plugin-resolve-type": "1.5.0", "@vue/shared": "^3.5.18" }, "peerDependencies": { "@babel/core": "^7.0.0-0" }, "optionalPeers": ["@babel/core"] }, "sha512-mneBhw1oOqCd2247O0Yw/mRwC9jIGACAJUlawkmMBiNmL4dGA2eMzuNZVNqOUfYTa6vqmND4CtOPzmEEEqLKFw=="],
+
+    "@vue/babel-plugin-resolve-type": ["@vue/babel-plugin-resolve-type@1.5.0", "", { "dependencies": { "@babel/code-frame": "^7.27.1", "@babel/helper-module-imports": "^7.27.1", "@babel/helper-plugin-utils": "^7.27.1", "@babel/parser": "^7.28.0", "@vue/compiler-sfc": "^3.5.18" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "sha512-Wm/60o+53JwJODm4Knz47dxJnLDJ9FnKnGZJbUUf8nQRAtt6P+undLUAVU3Ha33LxOJe6IPoifRQ6F/0RrU31w=="],
+
+    "@vue/compiler-core": ["@vue/compiler-core@3.5.24", "", { "dependencies": { "@babel/parser": "^7.28.5", "@vue/shared": "3.5.24", "entities": "^4.5.0", "estree-walker": "^2.0.2", "source-map-js": "^1.2.1" } }, "sha512-eDl5H57AOpNakGNAkFDH+y7kTqrQpJkZFXhWZQGyx/5Wh7B1uQYvcWkvZi11BDhscPgj8N7XV3oRwiPnx1Vrig=="],
+
+    "@vue/compiler-dom": ["@vue/compiler-dom@3.5.24", "", { "dependencies": { "@vue/compiler-core": "3.5.24", "@vue/shared": "3.5.24" } }, "sha512-1QHGAvs53gXkWdd3ZMGYuvQFXHW4ksKWPG8HP8/2BscrbZ0brw183q2oNWjMrSWImYLHxHrx1ItBQr50I/q2zw=="],
+
+    "@vue/compiler-sfc": ["@vue/compiler-sfc@3.5.24", "", { "dependencies": { "@babel/parser": "^7.28.5", "@vue/compiler-core": "3.5.24", "@vue/compiler-dom": "3.5.24", "@vue/compiler-ssr": "3.5.24", "@vue/shared": "3.5.24", "estree-walker": "^2.0.2", "magic-string": "^0.30.21", "postcss": "^8.5.6", "source-map-js": "^1.2.1" } }, "sha512-8EG5YPRgmTB+YxYBM3VXy8zHD9SWHUJLIGPhDovo3Z8VOgvP+O7UP5vl0J4BBPWYD9vxtBabzW1EuEZ+Cqs14g=="],
+
+    "@vue/compiler-ssr": ["@vue/compiler-ssr@3.5.24", "", { "dependencies": { "@vue/compiler-dom": "3.5.24", "@vue/shared": "3.5.24" } }, "sha512-trOvMWNBMQ/odMRHW7Ae1CdfYx+7MuiQu62Jtu36gMLXcaoqKvAyh+P73sYG9ll+6jLB6QPovqoKGGZROzkFFg=="],
+
+    "@vue/devtools-api": ["@vue/devtools-api@7.7.9", "", { "dependencies": { "@vue/devtools-kit": "^7.7.9" } }, "sha512-kIE8wvwlcZ6TJTbNeU2HQNtaxLx3a84aotTITUuL/4bzfPxzajGBOoqjMhwZJ8L9qFYDU/lAYMEEm11dnZOD6g=="],
+
+    "@vue/devtools-core": ["@vue/devtools-core@8.0.5", "", { "dependencies": { "@vue/devtools-kit": "^8.0.5", "@vue/devtools-shared": "^8.0.5", "mitt": "^3.0.1", "nanoid": "^5.1.5", "pathe": "^2.0.3", "vite-hot-client": "^2.1.0" }, "peerDependencies": { "vue": "^3.0.0" } }, "sha512-dpCw8nl0GDBuiL9SaY0mtDxoGIEmU38w+TQiYEPOLhW03VDC0lfNMYXS/qhl4I0YlysGp04NLY4UNn6xgD0VIQ=="],
+
+    "@vue/devtools-kit": ["@vue/devtools-kit@8.0.5", "", { "dependencies": { "@vue/devtools-shared": "^8.0.5", "birpc": "^2.6.1", "hookable": "^5.5.3", "mitt": "^3.0.1", "perfect-debounce": "^2.0.0", "speakingurl": "^14.0.1", "superjson": "^2.2.2" } }, "sha512-q2VV6x1U3KJMTQPUlRMyWEKVbcHuxhqJdSr6Jtjz5uAThAIrfJ6WVZdGZm5cuO63ZnSUz0RCsVwiUUb0mDV0Yg=="],
+
+    "@vue/devtools-shared": ["@vue/devtools-shared@8.0.5", "", { "dependencies": { "rfdc": "^1.4.1" } }, "sha512-bRLn6/spxpmgLk+iwOrR29KrYnJjG9DGpHGkDFG82UM21ZpJ39ztUT9OXX3g+usW7/b2z+h46I9ZiYyB07XMXg=="],
+
+    "@vue/reactivity": ["@vue/reactivity@3.5.24", "", { "dependencies": { "@vue/shared": "3.5.24" } }, "sha512-BM8kBhtlkkbnyl4q+HiF5R5BL0ycDPfihowulm02q3WYp2vxgPcJuZO866qa/0u3idbMntKEtVNuAUp5bw4teg=="],
+
+    "@vue/runtime-core": ["@vue/runtime-core@3.5.24", "", { "dependencies": { "@vue/reactivity": "3.5.24", "@vue/shared": "3.5.24" } }, "sha512-RYP/byyKDgNIqfX/gNb2PB55dJmM97jc9wyF3jK7QUInYKypK2exmZMNwnjueWwGceEkP6NChd3D2ZVEp9undQ=="],
+
+    "@vue/runtime-dom": ["@vue/runtime-dom@3.5.24", "", { "dependencies": { "@vue/reactivity": "3.5.24", "@vue/runtime-core": "3.5.24", "@vue/shared": "3.5.24", "csstype": "^3.1.3" } }, "sha512-Z8ANhr/i0XIluonHVjbUkjvn+CyrxbXRIxR7wn7+X7xlcb7dJsfITZbkVOeJZdP8VZwfrWRsWdShH6pngMxRjw=="],
+
+    "@vue/server-renderer": ["@vue/server-renderer@3.5.24", "", { "dependencies": { "@vue/compiler-ssr": "3.5.24", "@vue/shared": "3.5.24" }, "peerDependencies": { "vue": "3.5.24" } }, "sha512-Yh2j2Y4G/0/4z/xJ1Bad4mxaAk++C2v4kaa8oSYTMJBJ00/ndPuxCnWeot0/7/qafQFLh5pr6xeV6SdMcE/G1w=="],
+
+    "@vue/shared": ["@vue/shared@3.5.24", "", {}, "sha512-9cwHL2EsJBdi8NY22pngYYWzkTDhld6fAD6jlaeloNGciNSJL6bLpbxVgXl96X00Jtc6YWQv96YA/0sxex/k1A=="],
+
+    "@vueuse/core": ["@vueuse/core@9.13.0", "", { "dependencies": { "@types/web-bluetooth": "^0.0.16", "@vueuse/metadata": "9.13.0", "@vueuse/shared": "9.13.0", "vue-demi": "*" } }, "sha512-pujnclbeHWxxPRqXWmdkKV5OX4Wk4YeK7wusHqRwU0Q7EFusHoqNA/aPhB6KCh9hEqJkLAJo7bb0Lh9b+OIVzw=="],
+
+    "@vueuse/metadata": ["@vueuse/metadata@9.13.0", "", {}, "sha512-gdU7TKNAUVlXXLbaF+ZCfte8BjRJQWPCa2J55+7/h+yDtzw3vOoGQDRXzI6pyKyo6bXFT5/QoPE4hAknExjRLQ=="],
+
+    "@vueuse/shared": ["@vueuse/shared@9.13.0", "", { "dependencies": { "vue-demi": "*" } }, "sha512-UrnhU+Cnufu4S6JLCPZnkWh0WwZGUp72ktOF2DFptMlOs3TOdVv8xJN53zhHGARmVOsz5KqOls09+J1NR6sBKw=="],
+
+    "ansis": ["ansis@4.2.0", "", {}, "sha512-HqZ5rWlFjGiV0tDm3UxxgNRqsOTniqoKZu0pIAfh7TZQMGuZK+hH0drySty0si0QXj1ieop4+SkSfPZBPPkHig=="],
+
+    "async-validator": ["async-validator@4.2.5", "", {}, "sha512-7HhHjtERjqlNbZtqNqy2rckN/SpOOlmDliet+lP7k+eKZEjPk3DgyeU9lIXLdeLz0uBbbVp+9Qdow9wJWgwwfg=="],
+
+    "baseline-browser-mapping": ["baseline-browser-mapping@2.8.31", "", { "bin": { "baseline-browser-mapping": "dist/cli.js" } }, "sha512-a28v2eWrrRWPpJSzxc+mKwm0ZtVx/G8SepdQZDArnXYU/XS+IF6mp8aB/4E+hH1tyGCoDo3KlUCdlSxGDsRkAw=="],
+
+    "birpc": ["birpc@2.8.0", "", {}, "sha512-Bz2a4qD/5GRhiHSwj30c/8kC8QGj12nNDwz3D4ErQ4Xhy35dsSDvF+RA/tWpjyU0pdGtSDiEk6B5fBGE1qNVhw=="],
+
+    "browserslist": ["browserslist@4.28.0", "", { "dependencies": { "baseline-browser-mapping": "^2.8.25", "caniuse-lite": "^1.0.30001754", "electron-to-chromium": "^1.5.249", "node-releases": "^2.0.27", "update-browserslist-db": "^1.1.4" }, "bin": { "browserslist": "cli.js" } }, "sha512-tbydkR/CxfMwelN0vwdP/pLkDwyAASZ+VfWm4EOwlB6SWhx1sYnWLqo8N5j0rAzPfzfRaxt0mM/4wPU/Su84RQ=="],
+
+    "bundle-name": ["bundle-name@4.1.0", "", { "dependencies": { "run-applescript": "^7.0.0" } }, "sha512-tjwM5exMg6BGRI+kNmTntNsvdZS1X8BFYS6tnJ2hdH0kVxM6/eVZ2xy+FqStSWvYmtfFMDLIxurorHwDKfDz5Q=="],
+
+    "caniuse-lite": ["caniuse-lite@1.0.30001756", "", {}, "sha512-4HnCNKbMLkLdhJz3TToeVWHSnfJvPaq6vu/eRP0Ahub/07n484XHhBF5AJoSGHdVrS8tKFauUQz8Bp9P7LVx7A=="],
+
+    "convert-source-map": ["convert-source-map@2.0.0", "", {}, "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg=="],
+
+    "copy-anything": ["copy-anything@4.0.5", "", { "dependencies": { "is-what": "^5.2.0" } }, "sha512-7Vv6asjS4gMOuILabD3l739tsaxFQmC+a7pLZm02zyvs8p977bL3zEgq3yDk5rn9B0PbYgIv++jmHcuUab4RhA=="],
+
+    "csstype": ["csstype@3.2.3", "", {}, "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ=="],
+
+    "dayjs": ["dayjs@1.11.19", "", {}, "sha512-t5EcLVS6QPBNqM2z8fakk/NKel+Xzshgt8FFKAn+qwlD1pzZWxh0nVCrvFK7ZDb6XucZeF9z8C7CBWTRIVApAw=="],
+
+    "debug": ["debug@4.4.3", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA=="],
+
+    "default-browser": ["default-browser@5.4.0", "", { "dependencies": { "bundle-name": "^4.1.0", "default-browser-id": "^5.0.0" } }, "sha512-XDuvSq38Hr1MdN47EDvYtx3U0MTqpCEn+F6ft8z2vYDzMrvQhVp0ui9oQdqW3MvK3vqUETglt1tVGgjLuJ5izg=="],
+
+    "default-browser-id": ["default-browser-id@5.0.1", "", {}, "sha512-x1VCxdX4t+8wVfd1so/9w+vQ4vx7lKd2Qp5tDRutErwmR85OgmfX7RlLRMWafRMY7hbEiXIbudNrjOAPa/hL8Q=="],
+
+    "define-lazy-prop": ["define-lazy-prop@3.0.0", "", {}, "sha512-N+MeXYoqr3pOgn8xfyRPREN7gHakLYjhsHhWGT3fWAiL4IkAt0iDw14QiiEm2bE30c5XX5q0FtAA3CK5f9/BUg=="],
+
+    "electron-to-chromium": ["electron-to-chromium@1.5.259", "", {}, "sha512-I+oLXgpEJzD6Cwuwt1gYjxsDmu/S/Kd41mmLA3O+/uH2pFRO/DvOjUyGozL8j3KeLV6WyZ7ssPwELMsXCcsJAQ=="],
+
+    "element-plus": ["element-plus@2.11.8", "", { "dependencies": { "@ctrl/tinycolor": "^3.4.1", "@element-plus/icons-vue": "^2.3.2", "@floating-ui/dom": "^1.0.1", "@popperjs/core": "npm:@sxzz/popperjs-es@^2.11.7", "@types/lodash": "^4.17.20", "@types/lodash-es": "^4.17.12", "@vueuse/core": "^9.1.0", "async-validator": "^4.2.5", "dayjs": "^1.11.18", "lodash": "^4.17.21", "lodash-es": "^4.17.21", "lodash-unified": "^1.0.3", "memoize-one": "^6.0.0", "normalize-wheel-es": "^1.2.0" }, "peerDependencies": { "vue": "^3.2.0" } }, "sha512-2wzSj2uubFU1f0t/gHkkE1d09mUgV18fSZX5excw3Ar6hyWcxph4E57U8dgYLDt7HwkKYv1BiqPyBdy0WqWlOA=="],
+
+    "entities": ["entities@4.5.0", "", {}, "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw=="],
+
+    "error-stack-parser-es": ["error-stack-parser-es@1.0.5", "", {}, "sha512-5qucVt2XcuGMcEGgWI7i+yZpmpByQ8J1lHhcL7PwqCwu9FPP3VUXzT4ltHe5i2z9dePwEHcDVOAfSnHsOlCXRA=="],
+
+    "esbuild": ["esbuild@0.25.12", "", { "optionalDependencies": { "@esbuild/aix-ppc64": "0.25.12", "@esbuild/android-arm": "0.25.12", "@esbuild/android-arm64": "0.25.12", "@esbuild/android-x64": "0.25.12", "@esbuild/darwin-arm64": "0.25.12", "@esbuild/darwin-x64": "0.25.12", "@esbuild/freebsd-arm64": "0.25.12", "@esbuild/freebsd-x64": "0.25.12", "@esbuild/linux-arm": "0.25.12", "@esbuild/linux-arm64": "0.25.12", "@esbuild/linux-ia32": "0.25.12", "@esbuild/linux-loong64": "0.25.12", "@esbuild/linux-mips64el": "0.25.12", "@esbuild/linux-ppc64": "0.25.12", "@esbuild/linux-riscv64": "0.25.12", "@esbuild/linux-s390x": "0.25.12", "@esbuild/linux-x64": "0.25.12", "@esbuild/netbsd-arm64": "0.25.12", "@esbuild/netbsd-x64": "0.25.12", "@esbuild/openbsd-arm64": "0.25.12", "@esbuild/openbsd-x64": "0.25.12", "@esbuild/openharmony-arm64": "0.25.12", "@esbuild/sunos-x64": "0.25.12", "@esbuild/win32-arm64": "0.25.12", "@esbuild/win32-ia32": "0.25.12", "@esbuild/win32-x64": "0.25.12" }, "bin": { "esbuild": "bin/esbuild" } }, "sha512-bbPBYYrtZbkt6Os6FiTLCTFxvq4tt3JKall1vRwshA3fdVztsLAatFaZobhkBC8/BrPetoa0oksYoKXoG4ryJg=="],
+
+    "escalade": ["escalade@3.2.0", "", {}, "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA=="],
+
+    "estree-walker": ["estree-walker@2.0.2", "", {}, "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w=="],
+
+    "fdir": ["fdir@6.5.0", "", { "peerDependencies": { "picomatch": "^3 || ^4" }, "optionalPeers": ["picomatch"] }, "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg=="],
+
+    "fsevents": ["fsevents@2.3.3", "", { "os": "darwin" }, "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw=="],
+
+    "gensync": ["gensync@1.0.0-beta.2", "", {}, "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg=="],
+
+    "hookable": ["hookable@5.5.3", "", {}, "sha512-Yc+BQe8SvoXH1643Qez1zqLRmbA5rCL+sSmk6TVos0LWVfNIB7PGncdlId77WzLGSIB5KaWgTaNTs2lNVEI6VQ=="],
+
+    "is-docker": ["is-docker@3.0.0", "", { "bin": { "is-docker": "cli.js" } }, "sha512-eljcgEDlEns/7AXFosB5K/2nCM4P7FQPkGc/DWLy5rmFEWvZayGrik1d9/QIY5nJ4f9YsVvBkA6kJpHn9rISdQ=="],
+
+    "is-inside-container": ["is-inside-container@1.0.0", "", { "dependencies": { "is-docker": "^3.0.0" }, "bin": { "is-inside-container": "cli.js" } }, "sha512-KIYLCCJghfHZxqjYBE7rEy0OBuTd5xCHS7tHVgvCLkx7StIoaxwNW3hCALgEUjFfeRk+MG/Qxmp/vtETEF3tRA=="],
+
+    "is-what": ["is-what@5.5.0", "", {}, "sha512-oG7cgbmg5kLYae2N5IVd3jm2s+vldjxJzK1pcu9LfpGuQ93MQSzo0okvRna+7y5ifrD+20FE8FvjusyGaz14fw=="],
+
+    "is-wsl": ["is-wsl@3.1.0", "", { "dependencies": { "is-inside-container": "^1.0.0" } }, "sha512-UcVfVfaK4Sc4m7X3dUSoHoozQGBEFeDC+zVo06t98xe8CzHSZZBekNXH+tu0NalHolcJ/QAGqS46Hef7QXBIMw=="],
+
+    "js-tokens": ["js-tokens@4.0.0", "", {}, "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ=="],
+
+    "jsesc": ["jsesc@3.1.0", "", { "bin": { "jsesc": "bin/jsesc" } }, "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA=="],
+
+    "json5": ["json5@2.2.3", "", { "bin": { "json5": "lib/cli.js" } }, "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg=="],
+
+    "kolorist": ["kolorist@1.8.0", "", {}, "sha512-Y+60/zizpJ3HRH8DCss+q95yr6145JXZo46OTpFvDZWLfRCE4qChOyk1b26nMaNpfHHgxagk9dXT5OP0Tfe+dQ=="],
+
+    "lodash": ["lodash@4.17.21", "", {}, "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg=="],
+
+    "lodash-es": ["lodash-es@4.17.21", "", {}, "sha512-mKnC+QJ9pWVzv+C4/U3rRsHapFfHvQFoFB92e52xeyGMcX6/OlIl78je1u8vePzYZSkkogMPJ2yjxxsb89cxyw=="],
+
+    "lodash-unified": ["lodash-unified@1.0.3", "", { "peerDependencies": { "@types/lodash-es": "*", "lodash": "*", "lodash-es": "*" } }, "sha512-WK9qSozxXOD7ZJQlpSqOT+om2ZfcT4yO+03FuzAHD0wF6S0l0090LRPDx3vhTTLZ8cFKpBn+IOcVXK6qOcIlfQ=="],
+
+    "lru-cache": ["lru-cache@5.1.1", "", { "dependencies": { "yallist": "^3.0.2" } }, "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w=="],
+
+    "magic-string": ["magic-string@0.30.21", "", { "dependencies": { "@jridgewell/sourcemap-codec": "^1.5.5" } }, "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ=="],
+
+    "memoize-one": ["memoize-one@6.0.0", "", {}, "sha512-rkpe71W0N0c0Xz6QD0eJETuWAJGnJ9afsl1srmwPrI+yBCkge5EycXXbYRyvL29zZVUWQCY7InPRCv3GDXuZNw=="],
+
+    "mitt": ["mitt@3.0.1", "", {}, "sha512-vKivATfr97l2/QBCYAkXYDbrIWPM2IIKEl7YPhjCvKlG3kE2gm+uBo6nEXK3M5/Ffh/FLpKExzOQ3JJoJGFKBw=="],
+
+    "mrmime": ["mrmime@2.0.1", "", {}, "sha512-Y3wQdFg2Va6etvQ5I82yUhGdsKrcYox6p7FfL1LbK2J4V01F9TGlepTIhnK24t7koZibmg82KGglhA1XK5IsLQ=="],
+
+    "ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="],
+
+    "nanoid": ["nanoid@3.3.11", "", { "bin": { "nanoid": "bin/nanoid.cjs" } }, "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w=="],
+
+    "node-releases": ["node-releases@2.0.27", "", {}, "sha512-nmh3lCkYZ3grZvqcCH+fjmQ7X+H0OeZgP40OierEaAptX4XofMh5kwNbWh7lBduUzCcV/8kZ+NDLCwm2iorIlA=="],
+
+    "normalize-wheel-es": ["normalize-wheel-es@1.2.0", "", {}, "sha512-Wj7+EJQ8mSuXr2iWfnujrimU35R2W4FAErEyTmJoJ7ucwTn2hOUSsRehMb5RSYkxXGTM7Y9QpvPmp++w5ftoJw=="],
+
+    "ohash": ["ohash@2.0.11", "", {}, "sha512-RdR9FQrFwNBNXAr4GixM8YaRZRJ5PUWbKYbE5eOsrwAjJW0q2REGcf79oYPsLyskQCZG1PLN+S/K1V00joZAoQ=="],
+
+    "open": ["open@10.2.0", "", { "dependencies": { "default-browser": "^5.2.1", "define-lazy-prop": "^3.0.0", "is-inside-container": "^1.0.0", "wsl-utils": "^0.1.0" } }, "sha512-YgBpdJHPyQ2UE5x+hlSXcnejzAvD0b22U2OuAP+8OnlJT+PjWPxtgmGqKKc+RgTM63U9gN0YzrYc71R2WT/hTA=="],
+
+    "pathe": ["pathe@2.0.3", "", {}, "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w=="],
+
+    "perfect-debounce": ["perfect-debounce@2.0.0", "", {}, "sha512-fkEH/OBiKrqqI/yIgjR92lMfs2K8105zt/VT6+7eTjNwisrsh47CeIED9z58zI7DfKdH3uHAn25ziRZn3kgAow=="],
+
+    "picocolors": ["picocolors@1.1.1", "", {}, "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA=="],
+
+    "picomatch": ["picomatch@4.0.3", "", {}, "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q=="],
+
+    "pinia": ["pinia@3.0.4", "", { "dependencies": { "@vue/devtools-api": "^7.7.7" }, "peerDependencies": { "typescript": ">=4.5.0", "vue": "^3.5.11" }, "optionalPeers": ["typescript"] }, "sha512-l7pqLUFTI/+ESXn6k3nu30ZIzW5E2WZF/LaHJEpoq6ElcLD+wduZoB2kBN19du6K/4FDpPMazY2wJr+IndBtQw=="],
+
+    "postcss": ["postcss@8.5.6", "", { "dependencies": { "nanoid": "^3.3.11", "picocolors": "^1.1.1", "source-map-js": "^1.2.1" } }, "sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg=="],
+
+    "rfdc": ["rfdc@1.4.1", "", {}, "sha512-q1b3N5QkRUWUl7iyylaaj3kOpIT0N2i9MqIEQXP73GVsN9cw3fdx8X63cEmWhJGi2PPCF23Ijp7ktmd39rawIA=="],
+
+    "rollup": ["rollup@4.53.3", "", { "dependencies": { "@types/estree": "1.0.8" }, "optionalDependencies": { "@rollup/rollup-android-arm-eabi": "4.53.3", "@rollup/rollup-android-arm64": "4.53.3", "@rollup/rollup-darwin-arm64": "4.53.3", "@rollup/rollup-darwin-x64": "4.53.3", "@rollup/rollup-freebsd-arm64": "4.53.3", "@rollup/rollup-freebsd-x64": "4.53.3", "@rollup/rollup-linux-arm-gnueabihf": "4.53.3", "@rollup/rollup-linux-arm-musleabihf": "4.53.3", "@rollup/rollup-linux-arm64-gnu": "4.53.3", "@rollup/rollup-linux-arm64-musl": "4.53.3", "@rollup/rollup-linux-loong64-gnu": "4.53.3", "@rollup/rollup-linux-ppc64-gnu": "4.53.3", "@rollup/rollup-linux-riscv64-gnu": "4.53.3", "@rollup/rollup-linux-riscv64-musl": "4.53.3", "@rollup/rollup-linux-s390x-gnu": "4.53.3", "@rollup/rollup-linux-x64-gnu": "4.53.3", "@rollup/rollup-linux-x64-musl": "4.53.3", "@rollup/rollup-openharmony-arm64": "4.53.3", "@rollup/rollup-win32-arm64-msvc": "4.53.3", "@rollup/rollup-win32-ia32-msvc": "4.53.3", "@rollup/rollup-win32-x64-gnu": "4.53.3", "@rollup/rollup-win32-x64-msvc": "4.53.3", "fsevents": "~2.3.2" }, "bin": { "rollup": "dist/bin/rollup" } }, "sha512-w8GmOxZfBmKknvdXU1sdM9NHcoQejwF/4mNgj2JuEEdRaHwwF12K7e9eXn1nLZ07ad+du76mkVsyeb2rKGllsA=="],
+
+    "run-applescript": ["run-applescript@7.1.0", "", {}, "sha512-DPe5pVFaAsinSaV6QjQ6gdiedWDcRCbUuiQfQa2wmWV7+xC9bGulGI8+TdRmoFkAPaBXk8CrAbnlY2ISniJ47Q=="],
+
+    "semver": ["semver@6.3.1", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA=="],
+
+    "sirv": ["sirv@3.0.2", "", { "dependencies": { "@polka/url": "^1.0.0-next.24", "mrmime": "^2.0.0", "totalist": "^3.0.0" } }, "sha512-2wcC/oGxHis/BoHkkPwldgiPSYcpZK3JU28WoMVv55yHJgcZ8rlXvuG9iZggz+sU1d4bRgIGASwyWqjxu3FM0g=="],
+
+    "source-map-js": ["source-map-js@1.2.1", "", {}, "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA=="],
+
+    "speakingurl": ["speakingurl@14.0.1", "", {}, "sha512-1POYv7uv2gXoyGFpBCmpDVSNV74IfsWlDW216UPjbWufNf+bSU6GdbDsxdcxtfwb4xlI3yxzOTKClUosxARYrQ=="],
+
+    "superjson": ["superjson@2.2.5", "", { "dependencies": { "copy-anything": "^4" } }, "sha512-zWPTX96LVsA/eVYnqOM2+ofcdPqdS1dAF1LN4TS2/MWuUpfitd9ctTa87wt4xrYnZnkLtS69xpBdSxVBP5Rm6w=="],
+
+    "tinyglobby": ["tinyglobby@0.2.15", "", { "dependencies": { "fdir": "^6.5.0", "picomatch": "^4.0.3" } }, "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ=="],
+
+    "totalist": ["totalist@3.0.1", "", {}, "sha512-sf4i37nQ2LBx4m3wB74y+ubopq6W/dIzXg0FDGjsYnZHVa1Da8FH853wlL2gtUhg+xJXjfk3kUZS3BRoQeoQBQ=="],
+
+    "unplugin-utils": ["unplugin-utils@0.3.1", "", { "dependencies": { "pathe": "^2.0.3", "picomatch": "^4.0.3" } }, "sha512-5lWVjgi6vuHhJ526bI4nlCOmkCIF3nnfXkCMDeMJrtdvxTs6ZFCM8oNufGTsDbKv/tJ/xj8RpvXjRuPBZJuJog=="],
+
+    "update-browserslist-db": ["update-browserslist-db@1.1.4", "", { "dependencies": { "escalade": "^3.2.0", "picocolors": "^1.1.1" }, "peerDependencies": { "browserslist": ">= 4.21.0" }, "bin": { "update-browserslist-db": "cli.js" } }, "sha512-q0SPT4xyU84saUX+tomz1WLkxUbuaJnR1xWt17M7fJtEJigJeWUNGUqrauFXsHnqev9y9JTRGwk13tFBuKby4A=="],
+
+    "vite": ["vite@7.2.4", "", { "dependencies": { "esbuild": "^0.25.0", "fdir": "^6.5.0", "picomatch": "^4.0.3", "postcss": "^8.5.6", "rollup": "^4.43.0", "tinyglobby": "^0.2.15" }, "optionalDependencies": { "fsevents": "~2.3.3" }, "peerDependencies": { "@types/node": "^20.19.0 || >=22.12.0", "jiti": ">=1.21.0", "less": "^4.0.0", "lightningcss": "^1.21.0", "sass": "^1.70.0", "sass-embedded": "^1.70.0", "stylus": ">=0.54.8", "sugarss": "^5.0.0", "terser": "^5.16.0", "tsx": "^4.8.1", "yaml": "^2.4.2" }, "optionalPeers": ["@types/node", "jiti", "less", "lightningcss", "sass", "sass-embedded", "stylus", "sugarss", "terser", "tsx", "yaml"], "bin": { "vite": "bin/vite.js" } }, "sha512-NL8jTlbo0Tn4dUEXEsUg8KeyG/Lkmc4Fnzb8JXN/Ykm9G4HNImjtABMJgkQoVjOBN/j2WAwDTRytdqJbZsah7w=="],
+
+    "vite-dev-rpc": ["vite-dev-rpc@1.1.0", "", { "dependencies": { "birpc": "^2.4.0", "vite-hot-client": "^2.1.0" }, "peerDependencies": { "vite": "^2.9.0 || ^3.0.0-0 || ^4.0.0-0 || ^5.0.0-0 || ^6.0.1 || ^7.0.0-0" } }, "sha512-pKXZlgoXGoE8sEKiKJSng4hI1sQ4wi5YT24FCrwrLt6opmkjlqPPVmiPWWJn8M8byMxRGzp1CrFuqQs4M/Z39A=="],
+
+    "vite-hot-client": ["vite-hot-client@2.1.0", "", { "peerDependencies": { "vite": "^2.6.0 || ^3.0.0 || ^4.0.0 || ^5.0.0-0 || ^6.0.0-0 || ^7.0.0-0" } }, "sha512-7SpgZmU7R+dDnSmvXE1mfDtnHLHQSisdySVR7lO8ceAXvM0otZeuQQ6C8LrS5d/aYyP/QZ0hI0L+dIPrm4YlFQ=="],
+
+    "vite-plugin-inspect": ["vite-plugin-inspect@11.3.3", "", { "dependencies": { "ansis": "^4.1.0", "debug": "^4.4.1", "error-stack-parser-es": "^1.0.5", "ohash": "^2.0.11", "open": "^10.2.0", "perfect-debounce": "^2.0.0", "sirv": "^3.0.1", "unplugin-utils": "^0.3.0", "vite-dev-rpc": "^1.1.0" }, "peerDependencies": { "vite": "^6.0.0 || ^7.0.0-0" } }, "sha512-u2eV5La99oHoYPHE6UvbwgEqKKOQGz86wMg40CCosP6q8BkB6e5xPneZfYagK4ojPJSj5anHCrnvC20DpwVdRA=="],
+
+    "vite-plugin-vue-devtools": ["vite-plugin-vue-devtools@8.0.5", "", { "dependencies": { "@vue/devtools-core": "^8.0.5", "@vue/devtools-kit": "^8.0.5", "@vue/devtools-shared": "^8.0.5", "sirv": "^3.0.2", "vite-plugin-inspect": "^11.3.3", "vite-plugin-vue-inspector": "^5.3.2" }, "peerDependencies": { "vite": "^6.0.0 || ^7.0.0-0" } }, "sha512-p619BlKFOqQXJ6uDWS1vUPQzuJOD6xJTfftj57JXBGoBD/yeQCowR7pnWcr/FEX4/HVkFbreI6w2uuGBmQOh6A=="],
+
+    "vite-plugin-vue-inspector": ["vite-plugin-vue-inspector@5.3.2", "", { "dependencies": { "@babel/core": "^7.23.0", "@babel/plugin-proposal-decorators": "^7.23.0", "@babel/plugin-syntax-import-attributes": "^7.22.5", "@babel/plugin-syntax-import-meta": "^7.10.4", "@babel/plugin-transform-typescript": "^7.22.15", "@vue/babel-plugin-jsx": "^1.1.5", "@vue/compiler-dom": "^3.3.4", "kolorist": "^1.8.0", "magic-string": "^0.30.4" }, "peerDependencies": { "vite": "^3.0.0-0 || ^4.0.0-0 || ^5.0.0-0 || ^6.0.0-0 || ^7.0.0-0" } }, "sha512-YvEKooQcSiBTAs0DoYLfefNja9bLgkFM7NI2b07bE2SruuvX0MEa9cMaxjKVMkeCp5Nz9FRIdcN1rOdFVBeL6Q=="],
+
+    "vue": ["vue@3.5.24", "", { "dependencies": { "@vue/compiler-dom": "3.5.24", "@vue/compiler-sfc": "3.5.24", "@vue/runtime-dom": "3.5.24", "@vue/server-renderer": "3.5.24", "@vue/shared": "3.5.24" }, "peerDependencies": { "typescript": "*" }, "optionalPeers": ["typescript"] }, "sha512-uTHDOpVQTMjcGgrqFPSb8iO2m1DUvo+WbGqoXQz8Y1CeBYQ0FXf2z1gLRaBtHjlRz7zZUBHxjVB5VTLzYkvftg=="],
+
+    "vue-demi": ["vue-demi@0.14.10", "", { "peerDependencies": { "@vue/composition-api": "^1.0.0-rc.1", "vue": "^3.0.0-0 || ^2.6.0" }, "optionalPeers": ["@vue/composition-api"], "bin": { "vue-demi-fix": "bin/vue-demi-fix.js", "vue-demi-switch": "bin/vue-demi-switch.js" } }, "sha512-nMZBOwuzabUO0nLgIcc6rycZEebF6eeUfaiQx9+WSk8e29IbLvPU9feI6tqW4kTo3hvoYAJkMh8n8D0fuISphg=="],
+
+    "wsl-utils": ["wsl-utils@0.1.0", "", { "dependencies": { "is-wsl": "^3.1.0" } }, "sha512-h3Fbisa2nKGPxCpm89Hk33lBLsnaGBvctQopaBSOW/uIs6FTe1ATyAnKFJrzVs9vpGdsTe73WF3V4lIsk4Gacw=="],
+
+    "yallist": ["yallist@3.1.1", "", {}, "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g=="],
+
+    "@vue/devtools-api/@vue/devtools-kit": ["@vue/devtools-kit@7.7.9", "", { "dependencies": { "@vue/devtools-shared": "^7.7.9", "birpc": "^2.3.0", "hookable": "^5.5.3", "mitt": "^3.0.1", "perfect-debounce": "^1.0.0", "speakingurl": "^14.0.1", "superjson": "^2.2.2" } }, "sha512-PyQ6odHSgiDVd4hnTP+aDk2X4gl2HmLDfiyEnn3/oV+ckFDuswRs4IbBT7vacMuGdwY/XemxBoh302ctbsptuA=="],
+
+    "@vue/devtools-core/nanoid": ["nanoid@5.1.6", "", { "bin": { "nanoid": "bin/nanoid.js" } }, "sha512-c7+7RQ+dMB5dPwwCp4ee1/iV/q2P6aK1mTZcfr1BTuVlyW9hJYiMPybJCcnBlQtuSmTIWNeazm/zqNoZSSElBg=="],
+
+    "@vue/devtools-api/@vue/devtools-kit/@vue/devtools-shared": ["@vue/devtools-shared@7.7.9", "", { "dependencies": { "rfdc": "^1.4.1" } }, "sha512-iWAb0v2WYf0QWmxCGy0seZNDPdO3Sp5+u78ORnyeonS6MT4PC7VPrryX2BpMJrwlDeaZ6BD4vP4XKjK0SZqaeA=="],
+
+    "@vue/devtools-api/@vue/devtools-kit/perfect-debounce": ["perfect-debounce@1.0.0", "", {}, "sha512-xCy9V055GLEqoFaHoC1SoLIaLmWctgCUaBaWxDZ7/Zx4CTyX7cJQLJOok/orfjZAh9kEYpjJa4d0KcJmCbctZA=="],
+  }
+}

frontend/index.html

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html lang="">
+  <head>
+    <meta charset="UTF-8">
+    <link rel="icon" href="/favicon.ico">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Vite App</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="/src/main.js"></script>
+  </body>
+</html>

frontend/jsconfig.json

@@ -0,0 +1,8 @@
+{
+  "compilerOptions": {
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "exclude": ["node_modules", "dist"]
+}

frontend/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "sorawm",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  },
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "axios": "^1.13.2",
+    "element-plus": "^2.11.8",
+    "pinia": "^3.0.4",
+    "vue": "^3.5.22"
+  },
+  "devDependencies": {
+    "@vitejs/plugin-vue": "^6.0.1",
+    "vite": "^7.1.11",
+    "vite-plugin-vue-devtools": "^8.0.3"
+  }
+}

frontend/src/App.vue

@@ -0,0 +1,640 @@
+<script setup>
+import { ref, computed, onMounted, onUnmounted } from 'vue'
+import { ElMessage } from 'element-plus'
+import { UploadFilled, VideoPlay, Download, RefreshRight, Plus, Loading, Check, Warning, Setting } from '@element-plus/icons-vue'
+import dayjs from 'dayjs'
+import axios from 'axios'
+
+// --- Configuration ---
+const API_BASE_URL = '/api/v1' 
+const POLL_INTERVAL = 2000 
+
+// --- State ---
+const isUploading = ref(false)
+const showUploader = ref(true)
+const timer = ref(null)
+const uploadRef = ref(null) // 用于引用 upload 组件以清理文件
+const selectedModel = ref('lama') // 新增：当前选择的模型
+
+// Data State aligned with Backend Models
+const queueSummary = ref({
+  is_busy: false,
+  queue_length: 0,
+  total_active: 0
+})
+
+const currentTaskId = ref(null)
+const currentTaskResult = ref(null) 
+const waitingQueue = ref([]) 
+
+// --- API Interactions ---
+
+// 1. 获取队列状态
+const fetchQueueStatus = async () => {
+  try {
+    const { data } = await axios.get(`${API_BASE_URL}/get_queue_status`)
+    queueSummary.value = data.summary
+    waitingQueue.value = data.waiting_queue
+    const newCurrentTaskId = data.current_task_id
+    currentTaskId.value = newCurrentTaskId
+
+    if (newCurrentTaskId) {
+      fetchCurrentTaskResult(newCurrentTaskId)
+    } else {
+      currentTaskResult.value = null
+    }
+  } catch (error) {
+    console.error('Failed to fetch queue status:', error)
+  }
+}
+
+// 2. 获取特定任务结果
+const fetchCurrentTaskResult = async (taskId) => {
+  try {
+    const { data } = await axios.get(`${API_BASE_URL}/get_results`, {
+      params: { remove_task_id: taskId }
+    })
+    currentTaskResult.value = {
+      id: taskId,
+      status: data.status,
+      percentage: data.percentage,
+      video_path: 'Processing...', 
+      created_at: null, 
+      download_url: data.download_url
+    }
+  } catch (error) {
+    console.error('Failed to fetch task result:', error)
+  }
+}
+
+// 3. 提交任务
+const handleUploadChange = async (file) => {
+  isUploading.value = true
+  const formData = new FormData()
+  formData.append('video', file.raw)
+
+  try {
+    // 修改：使用 selectedModel 的值
+    await axios.post(`${API_BASE_URL}/submit_remove_task`, formData, {
+      params: { cleaner_type: selectedModel.value },
+      headers: { 'Content-Type': 'multipart/form-data' }
+    })
+    
+    ElMessage.success({ message: `Task submitted: ${file.name}`, plain: true })
+    
+    // 修改：不再隐藏上传框，而是刷新队列并清理当前文件，允许继续上传
+    // showUploader.value = false 
+    if (uploadRef.value) {
+      uploadRef.value.clearFiles()
+    }
+    fetchQueueStatus() 
+  } catch (error) {
+    ElMessage.error({ message: `Upload failed: ${error.message}`, plain: true })
+  } finally {
+    isUploading.value = false
+  }
+}
+
+// --- Computed Logic ---
+const tableData = computed(() => {
+  const list = []
+  if (currentTaskId.value && currentTaskResult.value) {
+    list.push({
+      id: currentTaskId.value,
+      status: currentTaskResult.value.status, 
+      percentage: currentTaskResult.value.percentage,
+      video_path: currentTaskResult.value.video_path, 
+      created_at: null, 
+      is_current: true
+    })
+  }
+  if (waitingQueue.value && waitingQueue.value.length > 0) {
+    waitingQueue.value.forEach(task => {
+      list.push({
+        id: task.id,
+        status: task.status, 
+        percentage: task.percentage,
+        video_path: task.video_path,
+        created_at: task.created_at,
+        is_current: false
+      })
+    })
+  }
+  return list
+})
+
+const stats = computed(() => {
+  return {
+    totalActive: queueSummary.value.total_active, 
+    queueLength: queueSummary.value.queue_length, 
+    isBusy: queueSummary.value.is_busy ? 1 : 0    
+  }
+})
+
+// --- Helpers ---
+const formatDate = (dateStr) => {
+  if (!dateStr) return '-'
+  return dayjs(dateStr).format('MMM D, HH:mm')
+}
+
+const getDownloadUrl = (taskId) => {
+  return `${API_BASE_URL}/download/${taskId}`
+}
+
+const getStatusConfig = (status) => {
+  const map = {
+    'FINISHED': { type: 'success', label: 'Ready', icon: Check, bg: 'pill-green' },
+    'PROCESSING': { type: 'primary', label: 'Processing', icon: Loading, bg: 'pill-blue' },
+    'QUEUED': { type: 'info', label: 'Queued', icon: null, bg: 'pill-gray' },
+    'UPLOADING': { type: 'warning', label: 'Uploading', icon: Loading, bg: 'pill-gray' },
+    'ERROR': { type: 'danger', label: 'Failed', icon: Warning, bg: 'pill-red' }
+  }
+  return map[status] || { type: 'info', label: status, bg: 'pill-gray' }
+}
+
+// --- Lifecycle ---
+onMounted(() => {
+  fetchQueueStatus()
+  timer.value = setInterval(fetchQueueStatus, POLL_INTERVAL)
+})
+
+onUnmounted(() => {
+  if (timer.value) clearInterval(timer.value)
+})
+</script>
+
+<template>
+  <div class="oa-page">
+    <header class="oa-header">
+      <div class="oa-header-inner">
+        <div class="oa-brand">
+          <div class="oa-dot" :class="{ 'oa-dot-busy': queueSummary.is_busy }" />
+          <span class="oa-title">Video Tasks</span>
+        </div>
+        <div class="oa-actions">
+          <el-button
+            class="oa-primary-btn"
+            :icon="Plus"
+            @click="showUploader = !showUploader"
+          >
+            {{ showUploader ? 'Hide upload' : 'New task' }}
+          </el-button>
+        </div>
+      </div>
+    </header>
+
+    <main class="oa-container">
+      <section class="oa-stats">
+        <div class="oa-stat-card">
+          <div class="oa-stat-label">System Status</div>
+          <div class="oa-stat-value">
+            {{ queueSummary.is_busy ? 'Busy' : 'Idle' }}
+          </div>
+        </div>
+
+        <div class="oa-stat-card">
+          <div class="oa-stat-label">Queue Length</div>
+          <div class="oa-stat-value">{{ stats.queueLength }}</div>
+        </div>
+
+        <div class="oa-stat-card">
+          <div class="oa-stat-label">Total Active</div>
+          <div class="oa-stat-value">{{ stats.totalActive }}</div>
+        </div>
+      </section>
+
+      <transition name="el-fade-in-linear">
+        <section v-if="showUploader" class="oa-upload-section">
+          <div class="oa-controls">
+            <span class="oa-control-label">Model:</span>
+            <el-radio-group v-model="selectedModel" size="small" class="oa-radio-group">
+              <el-radio-button label="lama">Lama (Fast)</el-radio-button>
+              <el-radio-button label="e2fgvi_hq">E2FGVI (High Quality)</el-radio-button>
+            </el-radio-group>
+          </div>
+
+          <el-upload
+            ref="uploadRef"
+            class="oa-uploader"
+            drag
+            action="#"
+            :auto-upload="false"
+            :on-change="handleUploadChange"
+            :show-file-list="false"
+            :disabled="isUploading"
+          >
+            <div class="oa-upload-inner">
+              <el-icon class="oa-upload-icon" v-if="!isUploading"><UploadFilled /></el-icon>
+              <el-icon class="oa-upload-icon is-loading" v-else><Loading /></el-icon>
+              
+              <div class="oa-upload-text">
+                <span v-if="!isUploading">
+                  <span class="oa-upload-strong">Click to upload</span>
+                  or drag video
+                </span>
+                <span v-else>Uploading to server...</span>
+              </div>
+              <div class="oa-upload-hint">MP4, MOV, AVI · Max 500MB</div>
+            </div>
+          </el-upload>
+        </section>
+      </transition>
+
+      <section class="oa-table">
+        <div class="oa-table-head">
+          <h3 class="oa-section-title">Current & Queue</h3>
+          <el-button
+            :icon="RefreshRight"
+            text
+            size="small"
+            class="oa-refresh"
+            @click="fetchQueueStatus"
+          >
+            Refresh
+          </el-button>
+        </div>
+
+        <el-table
+          :data="tableData"
+          class="oa-el-table"
+          :row-style="{ height: '68px' }"
+          empty-text="No active tasks"
+        >
+          <el-table-column label="Video Info" min-width="320">
+            <template #default="{ row }">
+              <div class="oa-file-cell">
+                <div class="oa-file-icon">
+                  <el-icon><VideoPlay /></el-icon>
+                </div>
+                <div class="oa-file-info">
+                  <div class="oa-file-name">{{ row.video_path || `Task: ${row.id.substring(0,8)}...` }}</div>
+                  <div class="oa-file-meta">{{ row.id }}</div>
+                </div>
+              </div>
+            </template>
+          </el-table-column>
+
+          <el-table-column label="Status" width="150">
+            <template #default="{ row }">
+              <div class="oa-status-pill" :class="getStatusConfig(row.status).bg">
+                <span class="oa-status-dot"></span>
+                {{ getStatusConfig(row.status).label }}
+              </div>
+            </template>
+          </el-table-column>
+
+          <el-table-column label="Progress" width="220">
+            <template #default="{ row }">
+              <div class="oa-progress">
+                <el-progress
+                  :percentage="row.percentage"
+                  :show-text="false"
+                  :stroke-width="4"
+                  :color="row.status === 'ERROR' ? '#ef4444' : '#10a37f'"
+                  :indeterminate="row.status === 'PROCESSING' && row.percentage === 0"
+                  class="oa-progress-bar"
+                />
+                <span class="oa-progress-text">
+                  {{ row.percentage }}%
+                </span>
+              </div>
+            </template>
+          </el-table-column>
+
+          <el-table-column label="Created At" width="170" align="right">
+            <template #default="{ row }">
+              <span class="oa-date">{{ formatDate(row.created_at) }}</span>
+            </template>
+          </el-table-column>
+
+          <el-table-column width="64" align="center">
+            <template #default="{ row }">
+              <a 
+                v-if="row.status === 'FINISHED'"
+                :href="getDownloadUrl(row.id)" 
+                target="_blank"
+                class="oa-download-link"
+              >
+                <el-button link class="oa-download">
+                  <el-icon><Download /></el-icon>
+                </el-button>
+              </a>
+            </template>
+          </el-table-column>
+        </el-table>
+      </section>
+    </main>
+  </div>
+</template>
+
+<style scoped>
+/* ---------------------------
+   OpenAI-like Design Tokens
+---------------------------- */
+:root {
+  --oa-bg: #ffffff;
+  --oa-surface: #f7f7f8;
+  --oa-surface-2: #fbfbfc;
+  --oa-border: #e6e6e9;
+  --oa-text: #0b0c0e;
+  --oa-text-2: #5f6368;
+  --oa-text-3: #8a8f98;
+  --oa-green: #10a37f;
+  --oa-black: #0b0c0e;
+  --oa-radius-lg: 14px;
+  --oa-radius-md: 10px;
+  --oa-shadow-sm: 0 1px 2px rgba(0,0,0,0.04);
+}
+
+/* Page + container */
+.oa-page {
+  min-height: 100vh;
+  background: var(--oa-bg);
+  color: var(--oa-text);
+  font-family: system-ui, -apple-system, Segoe UI, Roboto, Inter, sans-serif;
+}
+
+.oa-container {
+  max-width: 1040px;
+  margin: 0 auto;
+  padding: 28px 24px 56px;
+}
+
+/* Header */
+.oa-header {
+  position: sticky;
+  top: 0;
+  z-index: 5;
+  background: rgba(255,255,255,0.9);
+  backdrop-filter: blur(8px);
+  border-bottom: 1px solid var(--oa-border);
+}
+
+.oa-header-inner {
+  max-width: 1040px;
+  margin: 0 auto;
+  padding: 14px 24px;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+}
+
+.oa-brand {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+}
+
+.oa-dot {
+  width: 10px;
+  height: 10px;
+  background: #ccc; 
+  border-radius: 999px;
+  transition: background 0.3s ease;
+}
+.oa-dot-busy {
+  background: var(--oa-green);
+  box-shadow: 0 0 8px rgba(16, 163, 127, 0.4);
+}
+
+.oa-title {
+  font-size: 15px;
+  font-weight: 600;
+  letter-spacing: 0.1px;
+}
+
+/* Primary button */
+.oa-primary-btn {
+  background: var(--oa-black) !important;
+  color: #fff !important;
+  border: none !important;
+  border-radius: 999px !important;
+  padding: 8px 14px !important;
+  font-weight: 600;
+  box-shadow: var(--oa-shadow-sm);
+}
+.oa-primary-btn:hover { background: #000 !important; }
+
+/* Stats */
+.oa-stats {
+  display: grid;
+  grid-template-columns: repeat(3, 1fr); 
+  gap: 14px;
+  margin-top: 20px;
+  margin-bottom: 22px;
+}
+
+.oa-stat-card {
+  background: var(--oa-surface);
+  border: 1px solid var(--oa-border);
+  border-radius: var(--oa-radius-lg);
+  padding: 18px;
+  box-shadow: var(--oa-shadow-sm);
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+
+.oa-stat-label {
+  font-size: 12px;
+  color: var(--oa-text-2);
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.06em;
+}
+
+.oa-stat-value {
+  font-size: 26px;
+  font-weight: 700;
+  letter-spacing: -0.02em;
+}
+
+/* Upload & Controls */
+.oa-upload-section {
+  margin-top: 8px;
+  margin-bottom: 26px;
+}
+
+.oa-controls {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  margin-bottom: 12px;
+}
+
+.oa-control-label {
+  font-size: 13px;
+  font-weight: 600;
+  color: var(--oa-text-2);
+}
+
+/* Customizing Radio Button to look cleaner */
+.oa-radio-group :deep(.el-radio-button__inner) {
+  border-radius: 6px !important;
+  border: 1px solid var(--oa-border);
+  box-shadow: none !important;
+  margin-right: 8px;
+  padding: 8px 16px;
+  font-weight: 500;
+  background: var(--oa-surface);
+  color: var(--oa-text);
+}
+.oa-radio-group :deep(.el-radio-button__original-radio:checked + .el-radio-button__inner) {
+  background-color: var(--oa-black);
+  border-color: var(--oa-black);
+  color: #fff;
+  box-shadow: none;
+}
+.oa-radio-group :deep(.el-radio-button:first-child .el-radio-button__inner) {
+  border-left: 1px solid var(--oa-border);
+}
+
+.oa-uploader :deep(.el-upload-dragger) {
+  height: 128px;
+  border: 1.5px dashed var(--oa-border);
+  background: var(--oa-surface-2);
+  border-radius: var(--oa-radius-lg);
+  transition: all 0.2s ease;
+}
+.oa-uploader :deep(.el-upload-dragger:hover) {
+  border-color: var(--oa-green);
+  background: #f3fbf8;
+}
+
+.oa-upload-inner {
+  height: 100%;
+  display: grid;
+  place-content: center;
+  gap: 6px;
+  text-align: center;
+}
+
+.oa-upload-icon { font-size: 22px; color: var(--oa-text-3); }
+.oa-upload-text { font-size: 14px; color: var(--oa-text-2); }
+.oa-upload-strong { color: var(--oa-green); font-weight: 700; }
+.oa-upload-hint { font-size: 12px; color: var(--oa-text-3); }
+.is-loading { animation: rotating 2s linear infinite; }
+
+/* Table Section */
+.oa-table {
+  background: var(--oa-bg);
+  border: 1px solid var(--oa-border);
+  border-radius: var(--oa-radius-lg);
+  padding: 14px 12px 6px;
+  box-shadow: var(--oa-shadow-sm);
+}
+
+.oa-table-head {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 6px 8px 12px;
+}
+
+.oa-section-title {
+  margin: 0;
+  font-size: 16px;
+  font-weight: 700;
+  letter-spacing: -0.01em;
+}
+
+.oa-refresh { color: var(--oa-text-2) !important; }
+
+/* Element Plus table overrides */
+.oa-el-table {
+  --el-table-border-color: transparent;
+  --el-table-header-bg-color: transparent;
+  --el-table-row-hover-bg-color: #fafafa;
+}
+.oa-el-table :deep(th.el-table__cell) {
+  font-size: 11px;
+  text-transform: uppercase;
+  letter-spacing: 0.08em;
+  color: var(--oa-text-3);
+  font-weight: 700;
+  border-bottom: 1px solid var(--oa-border) !important;
+  padding: 10px 8px 12px;
+}
+.oa-el-table :deep(td.el-table__cell) {
+  border-bottom: 1px solid var(--oa-border);
+  padding: 12px 8px;
+}
+
+/* File cell */
+.oa-file-cell {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+}
+.oa-file-icon {
+  width: 40px;
+  height: 40px;
+  border-radius: 10px;
+  background: var(--oa-surface);
+  border: 1px solid var(--oa-border);
+  display: grid;
+  place-content: center;
+  color: var(--oa-text);
+}
+.oa-file-name { font-size: 14px; font-weight: 600; }
+.oa-file-meta { font-size: 12px; color: var(--oa-text-2); }
+
+/* Status pills */
+.oa-status-pill {
+  display: inline-flex;
+  align-items: center;
+  gap: 8px;
+  padding: 5px 10px;
+  border-radius: 999px;
+  font-size: 12px;
+  font-weight: 700;
+  letter-spacing: 0.02em;
+}
+.oa-status-dot {
+  width: 6px;
+  height: 6px;
+  border-radius: 50%;
+  background: currentColor;
+}
+
+/* Softer OpenAI-like pastels */
+.pill-green { background: #e9f9f3; color: #0f7a5a; }
+.pill-blue  { background: #eef3ff; color: #2a5bd7; }
+.pill-gray  { background: #f1f2f4; color: #5f6368; }
+.pill-red   { background: #fdecec; color: #b42318; }
+
+/* Progress */
+.oa-progress {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+}
+.oa-progress-bar { flex: 1; }
+.oa-progress-text {
+  font-size: 12px;
+  color: var(--oa-text-2);
+  width: 34px;
+  text-align: right;
+  font-variant-numeric: tabular-nums;
+}
+
+/* Date + download */
+.oa-date {
+  font-size: 13px;
+  color: var(--oa-text-2);
+  font-variant-numeric: tabular-nums;
+}
+.oa-download-link { text-decoration: none; }
+.oa-download { color: var(--oa-text-2) !important; }
+.oa-download:hover { color: var(--oa-green) !important; }
+
+@keyframes rotating {
+  from { transform: rotate(0deg); }
+  to { transform: rotate(360deg); }
+}
+
+/* Responsive */
+@media (max-width: 900px) {
+  .oa-stats { grid-template-columns: 1fr; }
+}
+</style>

frontend/src/assets/base.css

@@ -0,0 +1,86 @@
+/* color palette from <https://github.com/vuejs/theme> */
+:root {
+  --vt-c-white: #ffffff;
+  --vt-c-white-soft: #f8f8f8;
+  --vt-c-white-mute: #f2f2f2;
+
+  --vt-c-black: #181818;
+  --vt-c-black-soft: #222222;
+  --vt-c-black-mute: #282828;
+
+  --vt-c-indigo: #2c3e50;
+
+  --vt-c-divider-light-1: rgba(60, 60, 60, 0.29);
+  --vt-c-divider-light-2: rgba(60, 60, 60, 0.12);
+  --vt-c-divider-dark-1: rgba(84, 84, 84, 0.65);
+  --vt-c-divider-dark-2: rgba(84, 84, 84, 0.48);
+
+  --vt-c-text-light-1: var(--vt-c-indigo);
+  --vt-c-text-light-2: rgba(60, 60, 60, 0.66);
+  --vt-c-text-dark-1: var(--vt-c-white);
+  --vt-c-text-dark-2: rgba(235, 235, 235, 0.64);
+}
+
+/* semantic color variables for this project */
+:root {
+  --color-background: var(--vt-c-white);
+  --color-background-soft: var(--vt-c-white-soft);
+  --color-background-mute: var(--vt-c-white-mute);
+
+  --color-border: var(--vt-c-divider-light-2);
+  --color-border-hover: var(--vt-c-divider-light-1);
+
+  --color-heading: var(--vt-c-text-light-1);
+  --color-text: var(--vt-c-text-light-1);
+
+  --section-gap: 160px;
+}
+
+@media (prefers-color-scheme: dark) {
+  :root {
+    --color-background: var(--vt-c-black);
+    --color-background-soft: var(--vt-c-black-soft);
+    --color-background-mute: var(--vt-c-black-mute);
+
+    --color-border: var(--vt-c-divider-dark-2);
+    --color-border-hover: var(--vt-c-divider-dark-1);
+
+    --color-heading: var(--vt-c-text-dark-1);
+    --color-text: var(--vt-c-text-dark-2);
+  }
+}
+
+*,
+*::before,
+*::after {
+  box-sizing: border-box;
+  margin: 0;
+  font-weight: normal;
+}
+
+body {
+  min-height: 100vh;
+  color: var(--color-text);
+  background: var(--color-background);
+  transition:
+    color 0.5s,
+    background-color 0.5s;
+  line-height: 1.6;
+  font-family:
+    Inter,
+    -apple-system,
+    BlinkMacSystemFont,
+    'Segoe UI',
+    Roboto,
+    Oxygen,
+    Ubuntu,
+    Cantarell,
+    'Fira Sans',
+    'Droid Sans',
+    'Helvetica Neue',
+    sans-serif;
+  font-size: 15px;
+  text-rendering: optimizeLegibility;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+}

frontend/src/assets/main.css

@@ -0,0 +1,35 @@
+@import './base.css';
+
+#app {
+  max-width: 1280px;
+  margin: 0 auto;
+  padding: 2rem;
+  font-weight: normal;
+}
+
+a,
+.green {
+  text-decoration: none;
+  color: hsla(160, 100%, 37%, 1);
+  transition: 0.4s;
+  padding: 3px;
+}
+
+@media (hover: hover) {
+  a:hover {
+    background-color: hsla(160, 100%, 37%, 0.2);
+  }
+}
+
+@media (min-width: 1024px) {
+  body {
+    display: flex;
+    place-items: center;
+  }
+
+  #app {
+    display: grid;
+    grid-template-columns: 1fr 1fr;
+    padding: 0 2rem;
+  }
+}

frontend/src/components/HelloWorld.vue

@@ -0,0 +1,44 @@
+<script setup>
+defineProps({
+  msg: {
+    type: String,
+    required: true,
+  },
+})
+</script>
+
+<template>
+  <div class="greetings">
+    <h1 class="green">{{ msg }}</h1>
+    <h3>
+      You’ve successfully created a project with
+      <a href="https://vite.dev/" target="_blank" rel="noopener">Vite</a> +
+      <a href="https://vuejs.org/" target="_blank" rel="noopener">Vue 3</a>.
+    </h3>
+  </div>
+</template>
+
+<style scoped>
+h1 {
+  font-weight: 500;
+  font-size: 2.6rem;
+  position: relative;
+  top: -10px;
+}
+
+h3 {
+  font-size: 1.2rem;
+}
+
+.greetings h1,
+.greetings h3 {
+  text-align: center;
+}
+
+@media (min-width: 1024px) {
+  .greetings h1,
+  .greetings h3 {
+    text-align: left;
+  }
+}
+</style>

frontend/src/components/TheWelcome.vue

@@ -0,0 +1,95 @@
+<script setup>
+import WelcomeItem from './WelcomeItem.vue'
+import DocumentationIcon from './icons/IconDocumentation.vue'
+import ToolingIcon from './icons/IconTooling.vue'
+import EcosystemIcon from './icons/IconEcosystem.vue'
+import CommunityIcon from './icons/IconCommunity.vue'
+import SupportIcon from './icons/IconSupport.vue'
+
+const openReadmeInEditor = () => fetch('/__open-in-editor?file=README.md')
+</script>
+
+<template>
+  <WelcomeItem>
+    <template #icon>
+      <DocumentationIcon />
+    </template>
+    <template #heading>Documentation</template>
+
+    Vue’s
+    <a href="https://vuejs.org/" target="_blank" rel="noopener">official documentation</a>
+    provides you with all information you need to get started.
+  </WelcomeItem>
+
+  <WelcomeItem>
+    <template #icon>
+      <ToolingIcon />
+    </template>
+    <template #heading>Tooling</template>
+
+    This project is served and bundled with
+    <a href="https://vite.dev/guide/features.html" target="_blank" rel="noopener">Vite</a>. The
+    recommended IDE setup is
+    <a href="https://code.visualstudio.com/" target="_blank" rel="noopener">VSCode</a>
+    +
+    <a href="https://github.com/vuejs/language-tools" target="_blank" rel="noopener"
+      >Vue - Official</a
+    >. If you need to test your components and web pages, check out
+    <a href="https://vitest.dev/" target="_blank" rel="noopener">Vitest</a>
+    and
+    <a href="https://www.cypress.io/" target="_blank" rel="noopener">Cypress</a>
+    /
+    <a href="https://playwright.dev/" target="_blank" rel="noopener">Playwright</a>.
+
+    <br />
+
+    More instructions are available in
+    <a href="javascript:void(0)" @click="openReadmeInEditor"><code>README.md</code></a
+    >.
+  </WelcomeItem>
+
+  <WelcomeItem>
+    <template #icon>
+      <EcosystemIcon />
+    </template>
+    <template #heading>Ecosystem</template>
+
+    Get official tools and libraries for your project:
+    <a href="https://pinia.vuejs.org/" target="_blank" rel="noopener">Pinia</a>,
+    <a href="https://router.vuejs.org/" target="_blank" rel="noopener">Vue Router</a>,
+    <a href="https://test-utils.vuejs.org/" target="_blank" rel="noopener">Vue Test Utils</a>, and
+    <a href="https://github.com/vuejs/devtools" target="_blank" rel="noopener">Vue Dev Tools</a>. If
+    you need more resources, we suggest paying
+    <a href="https://github.com/vuejs/awesome-vue" target="_blank" rel="noopener">Awesome Vue</a>
+    a visit.
+  </WelcomeItem>
+
+  <WelcomeItem>
+    <template #icon>
+      <CommunityIcon />
+    </template>
+    <template #heading>Community</template>
+
+    Got stuck? Ask your question on
+    <a href="https://chat.vuejs.org" target="_blank" rel="noopener">Vue Land</a>
+    (our official Discord server), or
+    <a href="https://stackoverflow.com/questions/tagged/vue.js" target="_blank" rel="noopener"
+      >StackOverflow</a
+    >. You should also follow the official
+    <a href="https://bsky.app/profile/vuejs.org" target="_blank" rel="noopener">@vuejs.org</a>
+    Bluesky account or the
+    <a href="https://x.com/vuejs" target="_blank" rel="noopener">@vuejs</a>
+    X account for latest news in the Vue world.
+  </WelcomeItem>
+
+  <WelcomeItem>
+    <template #icon>
+      <SupportIcon />
+    </template>
+    <template #heading>Support Vue</template>
+
+    As an independent project, Vue relies on community backing for its sustainability. You can help
+    us by
+    <a href="https://vuejs.org/sponsor/" target="_blank" rel="noopener">becoming a sponsor</a>.
+  </WelcomeItem>
+</template>

frontend/src/components/WelcomeItem.vue

@@ -0,0 +1,87 @@
+<template>
+  <div class="item">
+    <i>
+      <slot name="icon"></slot>
+    </i>
+    <div class="details">
+      <h3>
+        <slot name="heading"></slot>
+      </h3>
+      <slot></slot>
+    </div>
+  </div>
+</template>
+
+<style scoped>
+.item {
+  margin-top: 2rem;
+  display: flex;
+  position: relative;
+}
+
+.details {
+  flex: 1;
+  margin-left: 1rem;
+}
+
+i {
+  display: flex;
+  place-items: center;
+  place-content: center;
+  width: 32px;
+  height: 32px;
+
+  color: var(--color-text);
+}
+
+h3 {
+  font-size: 1.2rem;
+  font-weight: 500;
+  margin-bottom: 0.4rem;
+  color: var(--color-heading);
+}
+
+@media (min-width: 1024px) {
+  .item {
+    margin-top: 0;
+    padding: 0.4rem 0 1rem calc(var(--section-gap) / 2);
+  }
+
+  i {
+    top: calc(50% - 25px);
+    left: -26px;
+    position: absolute;
+    border: 1px solid var(--color-border);
+    background: var(--color-background);
+    border-radius: 8px;
+    width: 50px;
+    height: 50px;
+  }
+
+  .item:before {
+    content: ' ';
+    border-left: 1px solid var(--color-border);
+    position: absolute;
+    left: 0;
+    bottom: calc(50% + 25px);
+    height: calc(50% - 25px);
+  }
+
+  .item:after {
+    content: ' ';
+    border-left: 1px solid var(--color-border);
+    position: absolute;
+    left: 0;
+    top: calc(50% + 25px);
+    height: calc(50% - 25px);
+  }
+
+  .item:first-of-type:before {
+    display: none;
+  }
+
+  .item:last-of-type:after {
+    display: none;
+  }
+}
+</style>

frontend/src/components/icons/IconCommunity.vue

@@ -0,0 +1,7 @@
+<template>
+  <svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" fill="currentColor">
+    <path
+      d="M15 4a1 1 0 1 0 0 2V4zm0 11v-1a1 1 0 0 0-1 1h1zm0 4l-.707.707A1 1 0 0 0 16 19h-1zm-4-4l.707-.707A1 1 0 0 0 11 14v1zm-4.707-1.293a1 1 0 0 0-1.414 1.414l1.414-1.414zm-.707.707l-.707-.707.707.707zM9 11v-1a1 1 0 0 0-.707.293L9 11zm-4 0h1a1 1 0 0 0-1-1v1zm0 4H4a1 1 0 0 0 1.707.707L5 15zm10-9h2V4h-2v2zm2 0a1 1 0 0 1 1 1h2a3 3 0 0 0-3-3v2zm1 1v6h2V7h-2zm0 6a1 1 0 0 1-1 1v2a3 3 0 0 0 3-3h-2zm-1 1h-2v2h2v-2zm-3 1v4h2v-4h-2zm1.707 3.293l-4-4-1.414 1.414 4 4 1.414-1.414zM11 14H7v2h4v-2zm-4 0c-.276 0-.525-.111-.707-.293l-1.414 1.414C5.42 15.663 6.172 16 7 16v-2zm-.707 1.121l3.414-3.414-1.414-1.414-3.414 3.414 1.414 1.414zM9 12h4v-2H9v2zm4 0a3 3 0 0 0 3-3h-2a1 1 0 0 1-1 1v2zm3-3V3h-2v6h2zm0-6a3 3 0 0 0-3-3v2a1 1 0 0 1 1 1h2zm-3-3H3v2h10V0zM3 0a3 3 0 0 0-3 3h2a1 1 0 0 1 1-1V0zM0 3v6h2V3H0zm0 6a3 3 0 0 0 3 3v-2a1 1 0 0 1-1-1H0zm3 3h2v-2H3v2zm1-1v4h2v-4H4zm1.707 4.707l.586-.586-1.414-1.414-.586.586 1.414 1.414z"
+    />
+  </svg>
+</template>

frontend/src/components/icons/IconDocumentation.vue

@@ -0,0 +1,7 @@
+<template>
+  <svg xmlns="http://www.w3.org/2000/svg" width="20" height="17" fill="currentColor">
+    <path
+      d="M11 2.253a1 1 0 1 0-2 0h2zm-2 13a1 1 0 1 0 2 0H9zm.447-12.167a1 1 0 1 0 1.107-1.666L9.447 3.086zM1 2.253L.447 1.42A1 1 0 0 0 0 2.253h1zm0 13H0a1 1 0 0 0 1.553.833L1 15.253zm8.447.833a1 1 0 1 0 1.107-1.666l-1.107 1.666zm0-14.666a1 1 0 1 0 1.107 1.666L9.447 1.42zM19 2.253h1a1 1 0 0 0-.447-.833L19 2.253zm0 13l-.553.833A1 1 0 0 0 20 15.253h-1zm-9.553-.833a1 1 0 1 0 1.107 1.666L9.447 14.42zM9 2.253v13h2v-13H9zm1.553-.833C9.203.523 7.42 0 5.5 0v2c1.572 0 2.961.431 3.947 1.086l1.107-1.666zM5.5 0C3.58 0 1.797.523.447 1.42l1.107 1.666C2.539 2.431 3.928 2 5.5 2V0zM0 2.253v13h2v-13H0zm1.553 13.833C2.539 15.431 3.928 15 5.5 15v-2c-1.92 0-3.703.523-5.053 1.42l1.107 1.666zM5.5 15c1.572 0 2.961.431 3.947 1.086l1.107-1.666C9.203 13.523 7.42 13 5.5 13v2zm5.053-11.914C11.539 2.431 12.928 2 14.5 2V0c-1.92 0-3.703.523-5.053 1.42l1.107 1.666zM14.5 2c1.573 0 2.961.431 3.947 1.086l1.107-1.666C18.203.523 16.421 0 14.5 0v2zm3.5.253v13h2v-13h-2zm1.553 12.167C18.203 13.523 16.421 13 14.5 13v2c1.573 0 2.961.431 3.947 1.086l1.107-1.666zM14.5 13c-1.92 0-3.703.523-5.053 1.42l1.107 1.666C11.539 15.431 12.928 15 14.5 15v-2z"
+    />
+  </svg>
+</template>

frontend/src/components/icons/IconEcosystem.vue

@@ -0,0 +1,7 @@
+<template>
+  <svg xmlns="http://www.w3.org/2000/svg" width="18" height="20" fill="currentColor">
+    <path
+      d="M11.447 8.894a1 1 0 1 0-.894-1.789l.894 1.789zm-2.894-.789a1 1 0 1 0 .894 1.789l-.894-1.789zm0 1.789a1 1 0 1 0 .894-1.789l-.894 1.789zM7.447 7.106a1 1 0 1 0-.894 1.789l.894-1.789zM10 9a1 1 0 1 0-2 0h2zm-2 2.5a1 1 0 1 0 2 0H8zm9.447-5.606a1 1 0 1 0-.894-1.789l.894 1.789zm-2.894-.789a1 1 0 1 0 .894 1.789l-.894-1.789zm2 .789a1 1 0 1 0 .894-1.789l-.894 1.789zm-1.106-2.789a1 1 0 1 0-.894 1.789l.894-1.789zM18 5a1 1 0 1 0-2 0h2zm-2 2.5a1 1 0 1 0 2 0h-2zm-5.447-4.606a1 1 0 1 0 .894-1.789l-.894 1.789zM9 1l.447-.894a1 1 0 0 0-.894 0L9 1zm-2.447.106a1 1 0 1 0 .894 1.789l-.894-1.789zm-6 3a1 1 0 1 0 .894 1.789L.553 4.106zm2.894.789a1 1 0 1 0-.894-1.789l.894 1.789zm-2-.789a1 1 0 1 0-.894 1.789l.894-1.789zm1.106 2.789a1 1 0 1 0 .894-1.789l-.894 1.789zM2 5a1 1 0 1 0-2 0h2zM0 7.5a1 1 0 1 0 2 0H0zm8.553 12.394a1 1 0 1 0 .894-1.789l-.894 1.789zm-1.106-2.789a1 1 0 1 0-.894 1.789l.894-1.789zm1.106 1a1 1 0 1 0 .894 1.789l-.894-1.789zm2.894.789a1 1 0 1 0-.894-1.789l.894 1.789zM8 19a1 1 0 1 0 2 0H8zm2-2.5a1 1 0 1 0-2 0h2zm-7.447.394a1 1 0 1 0 .894-1.789l-.894 1.789zM1 15H0a1 1 0 0 0 .553.894L1 15zm1-2.5a1 1 0 1 0-2 0h2zm12.553 2.606a1 1 0 1 0 .894 1.789l-.894-1.789zM17 15l.447.894A1 1 0 0 0 18 15h-1zm1-2.5a1 1 0 1 0-2 0h2zm-7.447-5.394l-2 1 .894 1.789 2-1-.894-1.789zm-1.106 1l-2-1-.894 1.789 2 1 .894-1.789zM8 9v2.5h2V9H8zm8.553-4.894l-2 1 .894 1.789 2-1-.894-1.789zm.894 0l-2-1-.894 1.789 2 1 .894-1.789zM16 5v2.5h2V5h-2zm-4.553-3.894l-2-1-.894 1.789 2 1 .894-1.789zm-2.894-1l-2 1 .894 1.789 2-1L8.553.106zM1.447 5.894l2-1-.894-1.789-2 1 .894 1.789zm-.894 0l2 1 .894-1.789-2-1-.894 1.789zM0 5v2.5h2V5H0zm9.447 13.106l-2-1-.894 1.789 2 1 .894-1.789zm0 1.789l2-1-.894-1.789-2 1 .894 1.789zM10 19v-2.5H8V19h2zm-6.553-3.894l-2-1-.894 1.789 2 1 .894-1.789zM2 15v-2.5H0V15h2zm13.447 1.894l2-1-.894-1.789-2 1 .894 1.789zM18 15v-2.5h-2V15h2z"
+    />
+  </svg>
+</template>

frontend/src/components/icons/IconSupport.vue

@@ -0,0 +1,7 @@
+<template>
+  <svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" fill="currentColor">
+    <path
+      d="M10 3.22l-.61-.6a5.5 5.5 0 0 0-7.666.105 5.5 5.5 0 0 0-.114 7.665L10 18.78l8.39-8.4a5.5 5.5 0 0 0-.114-7.665 5.5 5.5 0 0 0-7.666-.105l-.61.61z"
+    />
+  </svg>
+</template>

frontend/src/components/icons/IconTooling.vue

@@ -0,0 +1,19 @@
+<!-- This icon is from <https://github.com/Templarian/MaterialDesign>, distributed under Apache 2.0 (https://www.apache.org/licenses/LICENSE-2.0) license-->
+<template>
+  <svg
+    xmlns="http://www.w3.org/2000/svg"
+    xmlns:xlink="http://www.w3.org/1999/xlink"
+    aria-hidden="true"
+    role="img"
+    class="iconify iconify--mdi"
+    width="24"
+    height="24"
+    preserveAspectRatio="xMidYMid meet"
+    viewBox="0 0 24 24"
+  >
+    <path
+      d="M20 18v-4h-3v1h-2v-1H9v1H7v-1H4v4h16M6.33 8l-1.74 4H7v-1h2v1h6v-1h2v1h2.41l-1.74-4H6.33M9 5v1h6V5H9m12.84 7.61c.1.22.16.48.16.8V18c0 .53-.21 1-.6 1.41c-.4.4-.85.59-1.4.59H4c-.55 0-1-.19-1.4-.59C2.21 19 2 18.53 2 18v-4.59c0-.32.06-.58.16-.8L4.5 7.22C4.84 6.41 5.45 6 6.33 6H7V5c0-.55.18-1 .57-1.41C7.96 3.2 8.44 3 9 3h6c.56 0 1.04.2 1.43.59c.39.41.57.86.57 1.41v1h.67c.88 0 1.49.41 1.83 1.22l2.34 5.39z"
+      fill="currentColor"
+    ></path>
+  </svg>
+</template>

frontend/src/main.js

@@ -0,0 +1,23 @@
+import './assets/main.css'
+
+import { createApp } from 'vue'
+import App from './App.vue'
+import ElementPlus from 'element-plus'
+import 'element-plus/dist/index.css'
+import zhCn from 'element-plus/dist/locale/zh-cn'
+import * as ElementPlusIconsVue from '@element-plus/icons-vue'
+// import router from './router'
+import { createPinia } from 'pinia'
+
+const app = createApp(App)
+const pinia = createPinia()
+
+app.use(pinia)
+app.use(ElementPlus, {
+  locale: zhCn,
+})
+// app.use(router)
+for (const [key, component] of Object.entries(ElementPlusIconsVue)) {
+  app.component(key, component)
+}
+app.mount('#app')

frontend/src/views/Upload.vue

@@ -0,0 +1,13 @@
+<!-- Upload.vue -->
+<script setup>
+
+</script>
+
+<template>
+
+
+</template>
+
+<style scoped>
+
+</style>

frontend/vite.config.js

@@ -0,0 +1,26 @@
+import { fileURLToPath, URL } from 'node:url'
+
+import { defineConfig } from 'vite'
+import vue from '@vitejs/plugin-vue'
+import vueDevTools from 'vite-plugin-vue-devtools'
+
+// https://vite.dev/config/
+export default defineConfig({
+  plugins: [
+    vue(),
+    vueDevTools(),
+  ],
+  resolve: {
+    alias: {
+      '@': fileURLToPath(new URL('./src', import.meta.url))
+    },
+  },
+  server: {
+    proxy: {
+      "/api": {
+        target: "http://localhost:5344",
+        changeOrigin: true,
+      },
+    },
+  },
+})

hf_spaces_README.md

@@ -0,0 +1,27 @@
+---
+title: Sora Watermark Cleaner
+emoji: 🎬
+colorFrom: purple
+colorTo: blue
+sdk: docker
+pinned: false
+app_port: 8501
+---
+
+# Sora Watermark Cleaner
+
+Remove watermarks from Sora-generated videos using AI-powered inpainting.
+
+## Models
+
+- **LAMA** — Fast, good quality
+- **E2FGVI-HQ** — Slower, best quality with temporal consistency
+
+## API Endpoints
+
+The FastAPI server runs on port 5344:
+
+- `POST /api/v1/submit_remove_task` — Upload video, returns `task_id`
+- `GET /api/v1/get_results?remove_task_id={id}` — Poll task status
+- `GET /api/v1/download/{task_id}` — Download processed video
+- `GET /api/v1/get_queue_status` — Queue metrics

mds/reward.md

@@ -0,0 +1 @@
+![](../assests/wechat_reward.jpg)

model_version.json

@@ -0,0 +1 @@
+{"sha256": "79b44170111bd206d4964966b3b35adef1b3b15e7acf6427a95d35a2c715f987"}

one-click-portable.md

@@ -0,0 +1,26 @@
+# One-Click Portable Version | 一键便携版
+
+For **Windows** users - No installation required! 
+
+适用于 **Windows** 用户 - 无需安装！
+
+## Download | 下载
+
+**Google Drive:**
+- https://drive.google.com/file/d/1ujH28aHaCXGgB146g6kyfz3Qxd-wHR1c/view?usp=share_link
+
+**Baidu Pan | 百度网盘:**
+- Link | 链接: https://pan.baidu.com/s/1onMom81mvw2c6PFkCuYzdg?pwd=jusu
+- Extract Code | 提取码: `jusu`
+
+## Usage | 使用方法
+
+1. Download and extract the zip file | 下载并解压 zip 文件
+2. Double-click `run.bat` | 双击 `run.bat` 文件
+3. The web service will start automatically! | 网页服务将自动启动！
+
+## Features | 特点
+
+- ✅ Zero installation | 无需安装
+- ✅ All dependencies included | 包含所有依赖
+- ✅ Ready to use | 开箱即用

profile/profile_clean.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+
+CUDA_VISIBLE_DEVICES=0 nsys profile \
+  --trace=cuda,cublas,nvtx,osrt,cudnn \
+  --force-overwrite=true \
+  -o profile/profile_clean \
+  python profile/run_clean.py
+
+# 仅追踪 cuda 和 nvtx，不追踪 cudnn/cublas，也不追踪系统调用(osrt)
+# nsys profile \
+#   --trace=cuda,nvtx \
+#   --sample=none \
+#   --cpuctxsw=none \
+#   --force-overwrite=true \
+#   -o profile/profile_lite \
+#   python profile/run.py

profile/profile_process_chunk.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+
+CUDA_VISIBLE_DEVICES=0 nsys profile \
+  --trace=cuda,cublas,nvtx,osrt,cudnn \
+  --force-overwrite=true \
+  -o profiling/profile_process_chunk \
+  python profile/run_process_chunk.py
+
+# 仅追踪 cuda 和 nvtx，不追踪 cudnn/cublas，也不追踪系统调用(osrt)
+# nsys profile \
+#   --trace=cuda,nvtx \
+#   --sample=none \
+#   --cpuctxsw=none \
+#   --force-overwrite=true \
+#   -o profile/profile_lite \
+#   python profile/run.py

profile/profile_process_chunk_async.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+
+CUDA_VISIBLE_DEVICES=0 nsys profile \
+  --trace=cuda,cublas,nvtx,osrt,cudnn \
+  --force-overwrite=true \
+  -o profiling/profile_process_chunk_async \
+  python profile/run_process_chunk_async.py
+
+# 仅追踪 cuda 和 nvtx，不追踪 cudnn/cublas，也不追踪系统调用(osrt)
+# nsys profile \
+#   --trace=cuda,nvtx \
+#   --sample=none \
+#   --cpuctxsw=none \
+#   --force-overwrite=true \
+#   -o profile/profile_lite \
+#   python profile/run.py

profile/profile_whole_infer.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+
+CUDA_VISIBLE_DEVICES=0 nsys profile \
+  --trace=cuda,cublas,nvtx,osrt,cudnn \
+  --force-overwrite=true \
+  -o profile/profile_e2fgvi_hq \
+  python profile/run_whole.py
+
+# 仅追踪 cuda 和 nvtx，不追踪 cudnn/cublas，也不追踪系统调用(osrt)
+# nsys profile \
+#   --trace=cuda,nvtx \
+#   --sample=none \
+#   --cpuctxsw=none \
+#   --force-overwrite=true \
+#   -o profile/profile_lite \
+#   python profile/run.py

profile/run_clean.py

@@ -0,0 +1,128 @@
+from contextlib import contextmanager
+from pathlib import Path
+from typing import List
+
+import numpy as np
+import torch
+from loguru import logger
+from torch.cuda.nvtx import range_pop, range_push
+from tqdm import tqdm
+
+from sorawm.cleaner.e2fgvi_hq_cleaner import *
+from sorawm.utils.video_utils import merge_frames_with_overlap
+
+
+@contextmanager
+def nvtx(msg: str):
+    range_push(msg)
+    try:
+        yield
+    finally:
+        range_pop()
+
+
+class ProfileE2FGVIHDCleaner(E2FGVIHDCleaner):
+    def clean(self, frames: np.ndarray, masks: np.ndarray) -> List[np.ndarray]:
+        """
+        Process frames and masks in overlapping temporal chunks, run per-chunk inpainting/propagation, and merge the chunk results into a final list of cleaned frames.
+
+        Parameters:
+            frames (np.ndarray): Input video frames with time as the first dimension, e.g. shape (T, H, W, C) or a sequence where frames[0].shape == (H, W, C).
+            masks (np.ndarray): Corresponding masks with time as the first dimension, e.g. shape (T, H, W) or (T, H, W, 1). Nonzero pixels indicate regions to be processed.
+
+        Returns:
+            List[np.ndarray]: A list of length T containing the cleaned/composted frames as numpy arrays with shape (H, W, C).
+        """
+        with nvtx("ProfileE2FGVIHDCleaner.clean_total"):
+            with nvtx("setup_basic_params"):
+                video_length = len(frames)
+                chunk_size = int(self.config.chunk_size_ratio * video_length)
+                overlap_size = int(self.config.overlap_ratio * video_length)
+                num_chunks = int(np.ceil(video_length / (chunk_size - overlap_size)))
+                h, w = frames[0].shape[:2]
+
+            # Convert to tensors
+            with nvtx("numpy_to_tensor"):
+                imgs_all, masks_all = numpy_to_tensor(frames, masks)
+
+            # Prepare binary masks for compositing
+            with nvtx("prepare_binary_masks"):
+                binary_masks = np.expand_dims(masks > 0, axis=-1).astype(
+                    np.uint8
+                )  # (T, H, W, 1)
+
+            comp_frames = [None] * video_length
+            logger.debug(
+                f"Processing {video_length} frames in {num_chunks} chunks "
+                f"(chunk_size={chunk_size}, overlap={overlap_size})"
+            )
+
+            for chunk_idx in tqdm(
+                range(num_chunks), desc="Chunk", position=0, leave=True
+            ):
+                with nvtx(f"chunk_{chunk_idx:03d}_total"):
+                    with nvtx("chunk_compute_indices"):
+                        start_idx = chunk_idx * (chunk_size - overlap_size)
+                        end_idx = min(start_idx + chunk_size, video_length)
+                        actual_chunk_size = end_idx - start_idx
+
+                    # Extract chunk data
+                    with nvtx("chunk_extract_and_to_device"):
+                        imgs_chunk = imgs_all[:, start_idx:end_idx, :, :, :].to(device)
+                        masks_chunk = masks_all[:, start_idx:end_idx, :, :, :].to(
+                            device
+                        )
+                        frames_np_chunk = frames[start_idx:end_idx]
+                        binary_masks_chunk = binary_masks[start_idx:end_idx]
+
+                    # Core inpainting / propagation
+                    with nvtx("process_frames_chunk"):
+                        comp_frames_chunk = self.process_frames_chunk(
+                            actual_chunk_size,
+                            self.config.neighbor_stride,
+                            imgs_chunk,
+                            masks_chunk,
+                            binary_masks_chunk,
+                            frames_np_chunk,
+                            h,
+                            w,
+                        )
+
+                    # Merge results with blending in overlap region
+                    with nvtx("merge_frames_with_overlap"):
+                        comp_frames = merge_frames_with_overlap(
+                            result_frames=comp_frames,
+                            chunk_frames=comp_frames_chunk,
+                            start_idx=start_idx,
+                            overlap_size=overlap_size,
+                            is_first_chunk=(chunk_idx == 0),
+                        )
+
+                    # Clear GPU memory
+                    with nvtx("chunk_cleanup"):
+                        del imgs_chunk, masks_chunk, comp_frames_chunk
+                        try:
+                            torch.cuda.empty_cache()
+                        except Exception:
+                            pass
+
+        return comp_frames
+
+
+if __name__ == "__main__":
+    CMD = Path.cwd() / "profile"
+
+    masks_npy_path = CMD / "masks.npy"
+    frames_npy_path = CMD / "frames.npy"
+
+    with nvtx("load_numpy_inputs"):
+        masks = np.load(masks_npy_path)
+        frames = np.load(frames_npy_path)
+
+    with nvtx("init_cleaner"):
+        cleaner = ProfileE2FGVIHDCleaner()
+
+    with nvtx("run_cleaner"):
+        cleaned_frames = cleaner.clean(frames, masks)
+
+    # np.save(CMD / "cleaned_frames.npy", cleaned_frames)

profile/run_process_chunk.py

@@ -0,0 +1,368 @@
+from contextlib import contextmanager
+from pathlib import Path
+from typing import List
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+from loguru import logger
+from torch.cuda.nvtx import range_pop, range_push
+from tqdm import tqdm
+
+from sorawm.cleaner.e2fgvi_hq_cleaner import *
+from sorawm.models.model.e2fgvi_hq import InpaintGenerator
+from sorawm.utils.video_utils import merge_frames_with_overlap
+
+
+@contextmanager
+def nvtx(msg: str):
+    range_push(msg)
+    try:
+        yield
+    finally:
+        range_pop()
+
+
+class ProfileInpaintGenerator(InpaintGenerator):
+    def forward_bidirect_flow(self, masked_local_frames):
+        """
+        Estimate bidirectional optical flows between consecutive frames in a local masked sequence.
+
+        Parameters:
+            masked_local_frames (torch.Tensor): Input tensor of masked local frames with shape
+                (batch, time, channels, height, width).
+
+        Returns:
+            tuple: A pair (pred_flows_forward, pred_flows_backward) where each is a torch.Tensor
+            of shape (batch, time - 1, 2, height // 4, width // 4). Each tensor contains 2D
+            optical flow vectors: `pred_flows_forward` maps each frame to the next (i -> i+1),
+            and `pred_flows_backward` maps each frame to the previous (i+1 -> i).
+        """
+        with nvtx("InpaintGenerator.forward_bidirect_flow_total"):
+            b, l_t, c, h, w = masked_local_frames.size()
+
+            with nvtx("flow_downsample_interpolate"):
+                masked_local_frames = F.interpolate(
+                    masked_local_frames.view(-1, c, h, w),
+                    scale_factor=1 / 4,
+                    mode="bilinear",
+                    align_corners=True,
+                    recompute_scale_factor=True,
+                )
+                masked_local_frames = masked_local_frames.view(
+                    b, l_t, c, h // 4, w // 4
+                )
+
+            with nvtx("flow_prepare_pairs"):
+                mlf_1 = masked_local_frames[:, :-1, :, :, :].reshape(
+                    -1, c, h // 4, w // 4
+                )
+                mlf_2 = masked_local_frames[:, 1:, :, :, :].reshape(
+                    -1, c, h // 4, w // 4
+                )
+
+            with nvtx("spynet_forward"):
+                pred_flows_forward = self.update_spynet(mlf_1, mlf_2)
+
+            with nvtx("spynet_backward"):
+                pred_flows_backward = self.update_spynet(mlf_2, mlf_1)
+
+            with nvtx("flow_reshape"):
+                pred_flows_forward = pred_flows_forward.view(
+                    b, l_t - 1, 2, h // 4, w // 4
+                )
+                pred_flows_backward = pred_flows_backward.view(
+                    b, l_t - 1, 2, h // 4, w // 4
+                )
+
+            return pred_flows_forward, pred_flows_backward
+
+    def forward(self, masked_frames, num_local_frames):
+        """
+        Run inpainting generator on a sequence of masked frames, producing reconstructed frames and bidirectional flow estimates.
+
+        Parameters:
+            masked_frames (torch.Tensor): Tensor of shape (batch, time, channels, height, width) containing masked input frames (expected normalized to model range).
+            num_local_frames (int): Number of initial frames in each sequence treated as local (used for flow estimation and local feature propagation).
+
+        Returns:
+            output (torch.Tensor): Reconstructed frames tensor of shape (batch * time, channels_out, height_out, width_out) with values in [-1, 1].
+            pred_flows (tuple): A pair (pred_flows_forward, pred_flows_backward) of tensors holding predicted optical flows for forward and backward directions; each has shape (batch, time-1, 2, h_flow, w_flow).
+        """
+        with nvtx("InpaintGenerator.forward_total"):
+            l_t = num_local_frames
+            b, t, ori_c, ori_h, ori_w = masked_frames.size()
+
+            with nvtx("forward_normalize_local_frames"):
+                masked_local_frames = (masked_frames[:, :l_t, ...] + 1) / 2
+
+            with nvtx("forward_bidirect_flow_call"):
+                pred_flows = self.forward_bidirect_flow(masked_local_frames)
+
+            with nvtx("encoder_all_frames"):
+                enc_feat = self.encoder(masked_frames.view(b * t, ori_c, ori_h, ori_w))
+
+            with nvtx("split_local_ref_feat"):
+                _, c, h, w = enc_feat.size()
+                fold_output_size = (h, w)
+                local_feat = enc_feat.view(b, t, c, h, w)[:, :l_t, ...]
+                ref_feat = enc_feat.view(b, t, c, h, w)[:, l_t:, ...]
+
+            with nvtx("feat_prop_module"):
+                local_feat = self.feat_prop_module(
+                    local_feat, pred_flows[0], pred_flows[1]
+                )
+
+            with nvtx("concat_local_ref"):
+                enc_feat = torch.cat((local_feat, ref_feat), dim=1)
+
+            with nvtx("temporal_focal_transformers_ss"):
+                trans_feat = self.ss(enc_feat.view(-1, c, h, w), b, fold_output_size)
+
+            with nvtx("temporal_transformer_blocks"):
+                trans_feat = self.transformer([trans_feat, fold_output_size])
+
+            with nvtx("sc_fuse"):
+                trans_feat = self.sc(trans_feat[0], t, fold_output_size)
+                trans_feat = trans_feat.view(b, t, -1, h, w)
+
+            with nvtx("residual_add"):
+                enc_feat = enc_feat + trans_feat
+
+            with nvtx("decoder"):
+                output = self.decoder(enc_feat.view(b * t, c, h, w))
+                output = torch.tanh(output)
+
+            return output, pred_flows
+
+
+class ProfileE2FGVIHDCleaner(E2FGVIHDCleaner):
+    def __init__(
+        self,
+        ckpt_path: Path = E2FGVI_HQ_CHECKPOINT_PATH,
+        config: E2FGVIHDConfig = E2FGVIHDConfig(),
+    ):
+        with nvtx("cleaner_init_total"):
+            with nvtx("ensure_model_downloaded"):
+                ensure_model_downloaded(ckpt_path, E2FGVI_HQ_CHECKPOINT_REMOTE_URL)
+
+            with nvtx("init_model"):
+                self.model = ProfileInpaintGenerator().to(device)
+
+            with nvtx("load_ckpt"):
+                state = torch.load(ckpt_path, map_location=device)
+                self.model.load_state_dict(state)
+
+            with nvtx("model_eval_mode"):
+                self.model.eval()
+
+            self.model = torch.compile(self.model)
+
+            self.config = config
+
+    def clean(self, frames: np.ndarray, masks: np.ndarray) -> List[np.ndarray]:
+        """
+        Run the full cleaning pipeline on a video using chunked, overlapping processing and return reconstructed frames.
+
+        Processes the input frames and masks in configurable chunks with overlap: converts inputs to tensors, runs per-chunk inpainting and fusion, merges chunk outputs handling overlaps, and returns the final list of cleaned frames in original order.
+
+        Parameters:
+            frames (np.ndarray): Sequence of input RGB frames as a numpy array of shape (T, H, W, C) with values in [0, 255] or [0,1].
+            masks (np.ndarray): Corresponding mask array of shape (T, H, W) where nonzero values indicate regions to inpaint.
+
+        Returns:
+            List[np.ndarray]: List of T reconstructed RGB frames as numpy arrays (H, W, C), in the same order as the input.
+        """
+        with nvtx("ProfileE2FGVIHDCleaner.clean_total"):
+            with nvtx("setup_basic_params"):
+                video_length = len(frames)
+                chunk_size = int(self.config.chunk_size_ratio * video_length)
+                overlap_size = int(self.config.overlap_ratio * video_length)
+                num_chunks = int(np.ceil(video_length / (chunk_size - overlap_size)))
+                h, w = frames[0].shape[:2]
+
+            with nvtx("numpy_to_tensor"):
+                imgs_all, masks_all = numpy_to_tensor(frames, masks)
+
+            with nvtx("prepare_binary_masks"):
+                binary_masks = np.expand_dims(masks > 0, axis=-1).astype(np.uint8)
+
+            comp_frames = [None] * video_length
+            logger.debug(
+                f"Processing {video_length} frames in {num_chunks} chunks "
+                f"(chunk_size={chunk_size}, overlap={overlap_size})"
+            )
+
+            for chunk_idx in tqdm(
+                range(num_chunks), desc="Chunk", position=0, leave=True
+            ):
+                with nvtx(f"chunk_{chunk_idx:03d}_total"):
+                    with nvtx("chunk_compute_indices"):
+                        start_idx = chunk_idx * (chunk_size - overlap_size)
+                        end_idx = min(start_idx + chunk_size, video_length)
+                        actual_chunk_size = end_idx - start_idx
+
+                    with nvtx("chunk_extract_and_to_device"):
+                        imgs_chunk = imgs_all[:, start_idx:end_idx, :, :, :].to(device)
+                        masks_chunk = masks_all[:, start_idx:end_idx, :, :, :].to(
+                            device
+                        )
+                        frames_np_chunk = frames[start_idx:end_idx]
+                        binary_masks_chunk = binary_masks[start_idx:end_idx]
+
+                    with nvtx("chunk_process_frames_chunk"):
+                        comp_frames_chunk = self.process_frames_chunk(
+                            actual_chunk_size,
+                            self.config.neighbor_stride,
+                            imgs_chunk,
+                            masks_chunk,
+                            binary_masks_chunk,
+                            frames_np_chunk,
+                            h,
+                            w,
+                        )
+
+                    with nvtx("merge_frames_with_overlap"):
+                        comp_frames = merge_frames_with_overlap(
+                            result_frames=comp_frames,
+                            chunk_frames=comp_frames_chunk,
+                            start_idx=start_idx,
+                            overlap_size=overlap_size,
+                            is_first_chunk=(chunk_idx == 0),
+                        )
+
+                    with nvtx("chunk_cleanup"):
+                        del imgs_chunk, masks_chunk, comp_frames_chunk
+                        try:
+                            torch.cuda.empty_cache()
+                        except Exception:
+                            pass
+
+        return comp_frames
+
+    def process_frames_chunk(
+        self,
+        chunk_length: int,
+        neighbor_stride: int,
+        imgs_chunk: torch.Tensor,
+        masks_chunk: torch.Tensor,
+        binary_masks_chunk: np.ndarray,
+        frames_np_chunk: np.ndarray,
+        h: int,
+        w: int,
+    ) -> List[np.ndarray]:
+        """
+        Compose inpainted frames for a chunk by running the model on sliding windows, blending predictions back into original frames.
+
+        Parameters:
+                chunk_length (int): Number of frames in the current chunk.
+                neighbor_stride (int): Half-window radius (in frames) used to select neighboring frames around each reference; determines step between processed reference frames.
+                imgs_chunk (torch.Tensor): Tensor of shape (1, T, C, H, W) containing chunk frames normalized for model input.
+                masks_chunk (torch.Tensor): Tensor of shape (1, T, 1, H, W) containing corresponding masks where masked regions are 1.
+                binary_masks_chunk (np.ndarray): Array of per-frame binary masks (H, W) or (H, W, 1) used for compositing predictions onto original frames (values 0/1).
+                frames_np_chunk (np.ndarray): Original chunk frames as uint8 numpy arrays in shape (T, H, W, C).
+                h (int): Original frame height.
+                w (int): Original frame width.
+
+        Returns:
+                List[np.ndarray]: A list of length `chunk_length` where each entry is the reconstructed uint8 RGB frame with model predictions composited into unmasked regions; overlapping predictions are averaged.
+
+        Raises:
+                RuntimeError: Intentionally raises RuntimeError("Stop here") to terminate profiling at the profiling breakpoint.
+        """
+        comp_frames_chunk = [None] * chunk_length
+
+        for f in tqdm(
+            range(0, chunk_length, neighbor_stride),
+            desc=f"  Frame progress",
+            position=1,
+            leave=False,
+        ):
+            with nvtx(f"window_f_{f:05d}_total"):
+                with nvtx("window_neighbor_ref_ids"):
+                    neighbor_ids = [
+                        i
+                        for i in range(
+                            max(0, f - neighbor_stride),
+                            min(chunk_length, f + neighbor_stride + 1),
+                        )
+                    ]
+                    ref_ids = get_ref_index(
+                        f,
+                        neighbor_ids,
+                        chunk_length,
+                        self.config.ref_length,
+                        self.config.num_ref,
+                    )
+
+                with nvtx("window_select_tensors"):
+                    selected_imgs = imgs_chunk[:1, neighbor_ids + ref_ids, :, :, :]
+                    selected_masks = masks_chunk[:1, neighbor_ids + ref_ids, :, :, :]
+
+                with torch.no_grad():
+                    with nvtx("window_apply_mask"):
+                        masked_imgs = selected_imgs * (1 - selected_masks)
+
+                    with nvtx("window_pad_flip_concat"):
+                        mod_size_h = 60
+                        mod_size_w = 108
+                        h_pad = (mod_size_h - h % mod_size_h) % mod_size_h
+                        w_pad = (mod_size_w - w % mod_size_w) % mod_size_w
+
+                        masked_imgs = torch.cat(
+                            [masked_imgs, torch.flip(masked_imgs, [3])], 3
+                        )[:, :, :, : h + h_pad, :]
+
+                        masked_imgs = torch.cat(
+                            [masked_imgs, torch.flip(masked_imgs, [4])], 4
+                        )[:, :, :, :, : w + w_pad]
+
+                    with nvtx("window_model_infer"):
+                        # GPU ops
+                        pred_imgs, _ = self.model(masked_imgs, len(neighbor_ids))
+                        pred_imgs = pred_imgs[:, :, :h, :w]
+                        pred_imgs = (pred_imgs + 1) / 2
+                    with nvtx("D2H"):
+                        # IO ops
+                        pred_imgs = pred_imgs.cpu().permute(0, 2, 3, 1).numpy() * 255
+
+                    with nvtx("window_composite_back_to_frames"):
+                        for i in range(len(neighbor_ids)):
+                            idx = neighbor_ids[i]
+                            img = np.array(pred_imgs[i]).astype(
+                                np.uint8
+                            ) * binary_masks_chunk[idx] + frames_np_chunk[idx] * (
+                                1 - binary_masks_chunk[idx]
+                            )
+
+                            if comp_frames_chunk[idx] is None:
+                                comp_frames_chunk[idx] = img
+                            else:
+                                comp_frames_chunk[idx] = (
+                                    comp_frames_chunk[idx].astype(np.float32) * 0.5
+                                    + img.astype(np.float32) * 0.5
+                                )
+
+        # 你用来中断 profiling 的断点，保留
+        raise RuntimeError("Stop here")
+
+        return comp_frames_chunk
+
+
+if __name__ == "__main__":
+    CMD = Path.cwd() / "profiling"
+
+    masks_npy_path = CMD / "masks.npy"
+    frames_npy_path = CMD / "frames.npy"
+
+    with nvtx("load_numpy_inputs"):
+        masks = np.load(masks_npy_path)
+        frames = np.load(frames_npy_path)
+
+    with nvtx("init_cleaner"):
+        cleaner = ProfileE2FGVIHDCleaner()
+
+    with nvtx("run_cleaner"):
+        cleaned_frames = cleaner.clean(frames, masks)
+
+    # np.save(CMD / "cleaned_frames.npy", cleaned_frames)

profile/run_process_chunk_async.py

@@ -0,0 +1,513 @@
+from contextlib import contextmanager
+from pathlib import Path
+from typing import List
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+from loguru import logger
+from torch.cuda.nvtx import range_pop, range_push
+from tqdm import tqdm
+
+from sorawm.cleaner.e2fgvi_hq_cleaner import *
+from sorawm.models.model.e2fgvi_hq import InpaintGenerator
+from sorawm.utils.video_utils import merge_frames_with_overlap
+
+
+@contextmanager
+def nvtx(msg: str):
+    range_push(msg)
+    try:
+        yield
+    finally:
+        range_pop()
+
+
+class ProfileInpaintGenerator(InpaintGenerator):
+    def forward_bidirect_flow(self, masked_local_frames):
+        """
+        Estimate bidirectional optical flows between consecutive frames in a local masked sequence.
+
+        Parameters:
+            masked_local_frames (torch.Tensor): Input tensor of masked local frames with shape
+                (batch, time, channels, height, width).
+
+        Returns:
+            tuple: A pair (pred_flows_forward, pred_flows_backward) where each is a torch.Tensor
+            of shape (batch, time - 1, 2, height // 4, width // 4). Each tensor contains 2D
+            optical flow vectors: `pred_flows_forward` maps each frame to the next (i -> i+1),
+            and `pred_flows_backward` maps each frame to the previous (i+1 -> i).
+        """
+        with nvtx("InpaintGenerator.forward_bidirect_flow_total"):
+            b, l_t, c, h, w = masked_local_frames.size()
+
+            with nvtx("flow_downsample_interpolate"):
+                masked_local_frames = F.interpolate(
+                    masked_local_frames.view(-1, c, h, w),
+                    scale_factor=1 / 4,
+                    mode="bilinear",
+                    align_corners=True,
+                    recompute_scale_factor=True,
+                )
+                masked_local_frames = masked_local_frames.view(
+                    b, l_t, c, h // 4, w // 4
+                )
+
+            with nvtx("flow_prepare_pairs"):
+                mlf_1 = masked_local_frames[:, :-1, :, :, :].reshape(
+                    -1, c, h // 4, w // 4
+                )
+                mlf_2 = masked_local_frames[:, 1:, :, :, :].reshape(
+                    -1, c, h // 4, w // 4
+                )
+
+            with nvtx("spynet_forward"):
+                pred_flows_forward = self.update_spynet(mlf_1, mlf_2)
+
+            with nvtx("spynet_backward"):
+                pred_flows_backward = self.update_spynet(mlf_2, mlf_1)
+
+            with nvtx("flow_reshape"):
+                pred_flows_forward = pred_flows_forward.view(
+                    b, l_t - 1, 2, h // 4, w // 4
+                )
+                pred_flows_backward = pred_flows_backward.view(
+                    b, l_t - 1, 2, h // 4, w // 4
+                )
+
+            return pred_flows_forward, pred_flows_backward
+
+    def forward(self, masked_frames, num_local_frames):
+        """
+        Run inpainting generator on a sequence of masked frames, producing reconstructed frames and bidirectional flow estimates.
+
+        Parameters:
+            masked_frames (torch.Tensor): Tensor of shape (batch, time, channels, height, width) containing masked input frames (expected normalized to model range).
+            num_local_frames (int): Number of initial frames in each sequence treated as local (used for flow estimation and local feature propagation).
+
+        Returns:
+            output (torch.Tensor): Reconstructed frames tensor of shape (batch * time, channels_out, height_out, width_out) with values in [-1, 1].
+            pred_flows (tuple): A pair (pred_flows_forward, pred_flows_backward) of tensors holding predicted optical flows for forward and backward directions; each has shape (batch, time-1, 2, h_flow, w_flow).
+        """
+        with nvtx("InpaintGenerator.forward_total"):
+            l_t = num_local_frames
+            b, t, ori_c, ori_h, ori_w = masked_frames.size()
+
+            with nvtx("forward_normalize_local_frames"):
+                masked_local_frames = (masked_frames[:, :l_t, ...] + 1) / 2
+
+            with nvtx("forward_bidirect_flow_call"):
+                pred_flows = self.forward_bidirect_flow(masked_local_frames)
+
+            with nvtx("encoder_all_frames"):
+                enc_feat = self.encoder(masked_frames.view(b * t, ori_c, ori_h, ori_w))
+
+            with nvtx("split_local_ref_feat"):
+                _, c, h, w = enc_feat.size()
+                fold_output_size = (h, w)
+                local_feat = enc_feat.view(b, t, c, h, w)[:, :l_t, ...]
+                ref_feat = enc_feat.view(b, t, c, h, w)[:, l_t:, ...]
+
+            with nvtx("feat_prop_module"):
+                local_feat = self.feat_prop_module(
+                    local_feat, pred_flows[0], pred_flows[1]
+                )
+
+            with nvtx("concat_local_ref"):
+                enc_feat = torch.cat((local_feat, ref_feat), dim=1)
+
+            with nvtx("temporal_focal_transformers_ss"):
+                trans_feat = self.ss(enc_feat.view(-1, c, h, w), b, fold_output_size)
+
+            with nvtx("temporal_transformer_blocks"):
+                trans_feat = self.transformer([trans_feat, fold_output_size])
+
+            with nvtx("sc_fuse"):
+                trans_feat = self.sc(trans_feat[0], t, fold_output_size)
+                trans_feat = trans_feat.view(b, t, -1, h, w)
+
+            with nvtx("residual_add"):
+                enc_feat = enc_feat + trans_feat
+
+            with nvtx("decoder"):
+                output = self.decoder(enc_feat.view(b * t, c, h, w))
+                output = torch.tanh(output)
+
+            return output, pred_flows
+
+
+class ProfileE2FGVIHDCleaner(E2FGVIHDCleaner):
+    def __init__(
+        self,
+        ckpt_path: Path = E2FGVI_HQ_CHECKPOINT_PATH,
+        config: E2FGVIHDConfig = E2FGVIHDConfig(),
+    ):
+        with nvtx("cleaner_init_total"):
+            with nvtx("ensure_model_downloaded"):
+                ensure_model_downloaded(ckpt_path, E2FGVI_HQ_CHECKPOINT_REMOTE_URL)
+
+            with nvtx("init_model"):
+                self.model = ProfileInpaintGenerator().to(device)
+
+            with nvtx("load_ckpt"):
+                state = torch.load(ckpt_path, map_location=device)
+                self.model.load_state_dict(state)
+
+            with nvtx("model_eval_mode"):
+                self.model.eval()
+
+            self.config = config
+
+    def clean(self, frames: np.ndarray, masks: np.ndarray) -> List[np.ndarray]:
+        """
+        Run the full cleaning pipeline on a video using chunked, overlapping processing and return reconstructed frames.
+
+        Processes the input frames and masks in configurable chunks with overlap: converts inputs to tensors, runs per-chunk inpainting and fusion, merges chunk outputs handling overlaps, and returns the final list of cleaned frames in original order.
+
+        Parameters:
+            frames (np.ndarray): Sequence of input RGB frames as a numpy array of shape (T, H, W, C) with values in [0, 255] or [0,1].
+            masks (np.ndarray): Corresponding mask array of shape (T, H, W) where nonzero values indicate regions to inpaint.
+
+        Returns:
+            List[np.ndarray]: List of T reconstructed RGB frames as numpy arrays (H, W, C), in the same order as the input.
+        """
+        with nvtx("ProfileE2FGVIHDCleaner.clean_total"):
+            with nvtx("setup_basic_params"):
+                video_length = len(frames)
+                chunk_size = int(self.config.chunk_size_ratio * video_length)
+                overlap_size = int(self.config.overlap_ratio * video_length)
+                num_chunks = int(np.ceil(video_length / (chunk_size - overlap_size)))
+                h, w = frames[0].shape[:2]
+
+            with nvtx("numpy_to_tensor"):
+                imgs_all, masks_all = numpy_to_tensor(frames, masks)
+
+            with nvtx("prepare_binary_masks"):
+                binary_masks = np.expand_dims(masks > 0, axis=-1).astype(np.uint8)
+
+            comp_frames = [None] * video_length
+            logger.debug(
+                f"Processing {video_length} frames in {num_chunks} chunks "
+                f"(chunk_size={chunk_size}, overlap={overlap_size})"
+            )
+
+            for chunk_idx in tqdm(
+                range(num_chunks), desc="Chunk", position=0, leave=True
+            ):
+                with nvtx(f"chunk_{chunk_idx:03d}_total"):
+                    with nvtx("chunk_compute_indices"):
+                        start_idx = chunk_idx * (chunk_size - overlap_size)
+                        end_idx = min(start_idx + chunk_size, video_length)
+                        actual_chunk_size = end_idx - start_idx
+
+                    with nvtx("chunk_extract_and_to_device"):
+                        imgs_chunk = imgs_all[:, start_idx:end_idx, :, :, :].to(device)
+                        masks_chunk = masks_all[:, start_idx:end_idx, :, :, :].to(
+                            device
+                        )
+                        frames_np_chunk = frames[start_idx:end_idx]
+                        binary_masks_chunk = binary_masks[start_idx:end_idx]
+
+                    with nvtx("chunk_process_frames_chunk"):
+                        comp_frames_chunk = self.process_frames_chunk(
+                            actual_chunk_size,
+                            self.config.neighbor_stride,
+                            imgs_chunk,
+                            masks_chunk,
+                            binary_masks_chunk,
+                            frames_np_chunk,
+                            h,
+                            w,
+                        )
+
+                    with nvtx("merge_frames_with_overlap"):
+                        comp_frames = merge_frames_with_overlap(
+                            result_frames=comp_frames,
+                            chunk_frames=comp_frames_chunk,
+                            start_idx=start_idx,
+                            overlap_size=overlap_size,
+                            is_first_chunk=(chunk_idx == 0),
+                        )
+
+                    with nvtx("chunk_cleanup"):
+                        del imgs_chunk, masks_chunk, comp_frames_chunk
+                        try:
+                            torch.cuda.empty_cache()
+                        except Exception:
+                            pass
+
+        return comp_frames
+
+    # def process_frames_chunk(
+    #     self,
+    #     chunk_length: int,
+    #     neighbor_stride: int,
+    #     imgs_chunk: torch.Tensor,
+    #     masks_chunk: torch.Tensor,
+    #     binary_masks_chunk: np.ndarray,
+    #     frames_np_chunk: np.ndarray,
+    #     h: int,
+    #     w: int,
+    # ) -> List[np.ndarray]:
+    #     """
+    #     Compose inpainted frames for a chunk by running the model on sliding windows, blending predictions back into original frames.
+
+    #     Parameters:
+    #     	chunk_length (int): Number of frames in the current chunk.
+    #     	neighbor_stride (int): Half-window radius (in frames) used to select neighboring frames around each reference; determines step between processed reference frames.
+    #     	imgs_chunk (torch.Tensor): Tensor of shape (1, T, C, H, W) containing chunk frames normalized for model input.
+    #     	masks_chunk (torch.Tensor): Tensor of shape (1, T, 1, H, W) containing corresponding masks where masked regions are 1.
+    #     	binary_masks_chunk (np.ndarray): Array of per-frame binary masks (H, W) or (H, W, 1) used for compositing predictions onto original frames (values 0/1).
+    #     	frames_np_chunk (np.ndarray): Original chunk frames as uint8 numpy arrays in shape (T, H, W, C).
+    #     	h (int): Original frame height.
+    #     	w (int): Original frame width.
+
+    #     Returns:
+    #     	List[np.ndarray]: A list of length `chunk_length` where each entry is the reconstructed uint8 RGB frame with model predictions composited into unmasked regions; overlapping predictions are averaged.
+
+    #     Raises:
+    #     	RuntimeError: Intentionally raises RuntimeError("Stop here") to terminate profiling at the profiling breakpoint.
+    #     """
+    #     comp_frames_chunk = [None] * chunk_length
+
+    #     for f in tqdm(
+    #         range(0, chunk_length, neighbor_stride),
+    #         desc=f"  Frame progress",
+    #         position=1,
+    #         leave=False,
+    #     ):
+    #         with nvtx(f"window_f_{f:05d}_total"):
+    #             with nvtx("window_neighbor_ref_ids"):
+    #                 neighbor_ids = [
+    #                     i
+    #                     for i in range(
+    #                         max(0, f - neighbor_stride),
+    #                         min(chunk_length, f + neighbor_stride + 1),
+    #                     )
+    #                 ]
+    #                 ref_ids = get_ref_index(
+    #                     f,
+    #                     neighbor_ids,
+    #                     chunk_length,
+    #                     self.config.ref_length,
+    #                     self.config.num_ref,
+    #                 )
+
+    #             with nvtx("window_select_tensors"):
+    #                 selected_imgs = imgs_chunk[:1, neighbor_ids + ref_ids, :, :, :]
+    #                 selected_masks = masks_chunk[:1, neighbor_ids + ref_ids, :, :, :]
+
+    #             with torch.no_grad():
+    #                 with nvtx("window_apply_mask"):
+    #                     masked_imgs = selected_imgs * (1 - selected_masks)
+
+    #                 with nvtx("window_pad_flip_concat"):
+    #                     mod_size_h = 60
+    #                     mod_size_w = 108
+    #                     h_pad = (mod_size_h - h % mod_size_h) % mod_size_h
+    #                     w_pad = (mod_size_w - w % mod_size_w) % mod_size_w
+
+    #                     masked_imgs = torch.cat(
+    #                         [masked_imgs, torch.flip(masked_imgs, [3])], 3
+    #                     )[:, :, :, : h + h_pad, :]
+
+    #                     masked_imgs = torch.cat(
+    #                         [masked_imgs, torch.flip(masked_imgs, [4])], 4
+    #                     )[:, :, :, :, : w + w_pad]
+
+    #                 with nvtx("window_model_infer"):
+    #                     pred_imgs, _ = self.model(masked_imgs, len(neighbor_ids))
+
+    #                 with nvtx("window_crop_postprocess"):
+    #                     pred_imgs = pred_imgs[:, :, :h, :w]
+    #                     pred_imgs = (pred_imgs + 1) / 2
+    #                     pred_imgs = pred_imgs.cpu().permute(0, 2, 3, 1).numpy() * 255
+
+    #                 with nvtx("window_composite_back_to_frames"):
+    #                     for i in range(len(neighbor_ids)):
+    #                         idx = neighbor_ids[i]
+    #                         img = np.array(pred_imgs[i]).astype(
+    #                             np.uint8
+    #                         ) * binary_masks_chunk[idx] + frames_np_chunk[idx] * (
+    #                             1 - binary_masks_chunk[idx]
+    #                         )
+
+    #                         if comp_frames_chunk[idx] is None:
+    #                             comp_frames_chunk[idx] = img
+    #                         else:
+    #                             comp_frames_chunk[idx] = (
+    #                                 comp_frames_chunk[idx].astype(np.float32) * 0.5
+    #                                 + img.astype(np.float32) * 0.5
+    #                             )
+
+    #     # 你用来中断 profiling 的断点，保留
+    #     # raise RuntimeError("Stop here")
+    #     return comp_frames_chunk
+
+    def process_frames_chunk(
+        self,
+        chunk_length: int,
+        neighbor_stride: int,
+        imgs_chunk: torch.Tensor,
+        masks_chunk: torch.Tensor,
+        binary_masks_chunk: np.ndarray,
+        frames_np_chunk: np.ndarray,
+        h: int,
+        w: int,
+    ) -> List[np.ndarray]:
+        comp_frames_chunk = [None] * chunk_length
+
+        # 创建用于数据传输的 stream
+        transfer_stream = torch.cuda.Stream()
+
+        # 用于存储上一轮的结果（异步传输中）
+        prev_pred_imgs_cpu = None
+        prev_neighbor_ids = None
+
+        all_windows = list(range(0, chunk_length, neighbor_stride))
+
+        for window_idx, f in enumerate(
+            tqdm(
+                all_windows,
+                desc=f"  Frame progress",
+                position=1,
+                leave=False,
+            )
+        ):
+            with nvtx(f"window_f_{f:05d}_total"):
+                # ============ 准备当前窗口数据 ============
+                with nvtx("window_neighbor_ref_ids"):
+                    neighbor_ids = [
+                        i
+                        for i in range(
+                            max(0, f - neighbor_stride),
+                            min(chunk_length, f + neighbor_stride + 1),
+                        )
+                    ]
+                    ref_ids = get_ref_index(
+                        f,
+                        neighbor_ids,
+                        chunk_length,
+                        self.config.ref_length,
+                        self.config.num_ref,
+                    )
+
+                with nvtx("window_select_tensors"):
+                    selected_imgs = imgs_chunk[:1, neighbor_ids + ref_ids, :, :, :]
+                    selected_masks = masks_chunk[:1, neighbor_ids + ref_ids, :, :, :]
+
+                with torch.no_grad():
+                    with nvtx("window_apply_mask"):
+                        masked_imgs = selected_imgs * (1 - selected_masks)
+
+                    with nvtx("window_pad_flip_concat"):
+                        mod_size_h = 60
+                        mod_size_w = 108
+                        h_pad = (mod_size_h - h % mod_size_h) % mod_size_h
+                        w_pad = (mod_size_w - w % mod_size_w) % mod_size_w
+
+                        masked_imgs = torch.cat(
+                            [masked_imgs, torch.flip(masked_imgs, [3])], 3
+                        )[:, :, :, : h + h_pad, :]
+
+                        masked_imgs = torch.cat(
+                            [masked_imgs, torch.flip(masked_imgs, [4])], 4
+                        )[:, :, :, :, : w + w_pad]
+
+                    # ============ 模型推理 (默认 stream) ============
+                    with nvtx("window_model_infer"):
+                        pred_imgs, _ = self.model(masked_imgs, len(neighbor_ids))
+
+                    # ============ GPU 上的后处理 ============
+                    with nvtx("window_crop_postprocess_gpu"):
+                        pred_imgs = pred_imgs[:, :, :h, :w]
+                        pred_imgs = (pred_imgs + 1) / 2
+                        pred_imgs = pred_imgs.permute(0, 2, 3, 1) * 255
+
+                    # 记录当前计算完成的事件
+                    compute_done = torch.cuda.Event()
+                    compute_done.record()
+
+                    # ============ 处理上一轮的结果 (如果有) ============
+                    if prev_pred_imgs_cpu is not None:
+                        with nvtx("window_composite_prev"):
+                            # 等待上一轮传输完成
+                            transfer_stream.synchronize()
+
+                            # 在 CPU 上合成上一轮的帧
+                            self._composite_frames(
+                                prev_pred_imgs_cpu,
+                                prev_neighbor_ids,
+                                binary_masks_chunk,
+                                frames_np_chunk,
+                                comp_frames_chunk,
+                            )
+
+                    # ============ 异步传输当前结果到 CPU ============
+                    with nvtx("window_async_transfer"):
+                        # 确保计算完成后再传输
+                        transfer_stream.wait_event(compute_done)
+
+                        with torch.cuda.stream(transfer_stream):
+                            # 使用 non_blocking=True 异步传输
+                            # 先转到 pinned memory 的 tensor
+                            pred_imgs_cpu = pred_imgs.cpu().numpy()
+
+                        # 保存给下一轮处理
+                        prev_pred_imgs_cpu = pred_imgs_cpu
+                        prev_neighbor_ids = neighbor_ids.copy()
+
+        # ============ 处理最后一轮的结果 ============
+        if prev_pred_imgs_cpu is not None:
+            transfer_stream.synchronize()
+            self._composite_frames(
+                prev_pred_imgs_cpu,
+                prev_neighbor_ids,
+                binary_masks_chunk,
+                frames_np_chunk,
+                comp_frames_chunk,
+            )
+
+        return comp_frames_chunk
+
+    def _composite_frames(
+        self,
+        pred_imgs_np: np.ndarray,
+        neighbor_ids: List[int],
+        binary_masks_chunk: np.ndarray,
+        frames_np_chunk: np.ndarray,
+        comp_frames_chunk: List[np.ndarray],
+    ):
+        """将预测结果合成到原始帧上"""
+        for i in range(len(neighbor_ids)):
+            idx = neighbor_ids[i]
+            img = np.array(pred_imgs_np[i]).astype(np.uint8) * binary_masks_chunk[
+                idx
+            ] + frames_np_chunk[idx] * (1 - binary_masks_chunk[idx])
+
+            if comp_frames_chunk[idx] is None:
+                comp_frames_chunk[idx] = img
+            else:
+                comp_frames_chunk[idx] = (
+                    comp_frames_chunk[idx].astype(np.float32) * 0.5
+                    + img.astype(np.float32) * 0.5
+                )
+
+
+if __name__ == "__main__":
+    CMD = Path.cwd() / "profiling"
+
+    masks_npy_path = CMD / "masks.npy"
+    frames_npy_path = CMD / "frames.npy"
+
+    with nvtx("load_numpy_inputs"):
+        masks = np.load(masks_npy_path)
+        frames = np.load(frames_npy_path)
+
+    with nvtx("init_cleaner"):
+        cleaner = ProfileE2FGVIHDCleaner()
+
+    with nvtx("run_cleaner"):
+        cleaned_frames = cleaner.clean(frames, masks)
+
+    # np.save(CMD / "cleaned_frames.npy", cleaned_frames)

profile/run_whole.py

@@ -0,0 +1,273 @@
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Callable
+
+import numpy as np
+from loguru import logger
+from torch.cuda.nvtx import range_pop, range_push
+from tqdm import tqdm
+
+import ffmpeg
+from sorawm.core import SoraWM
+from sorawm.schemas import CleanerType
+from sorawm.utils.imputation_utils import (
+    find_2d_data_bkps,
+    find_idxs_interval,
+    get_interval_average_bbox,
+)
+from sorawm.utils.video_utils import VideoLoader, merge_frames_with_overlap
+from sorawm.watermark_cleaner import WaterMarkCleaner
+from sorawm.watermark_detector import SoraWaterMarkDetector
+
+
+@contextmanager
+def nvtx(msg: str):
+    range_push(msg)
+    try:
+        yield
+    finally:
+        range_pop()
+
+
+class ProfileSoraWM(SoraWM):
+    def run(
+        self,
+        input_video_path: Path,
+        output_video_path: Path,
+        progress_callback: Callable[[int], None] | None = None,
+        quiet: bool = False,
+    ):
+        """
+        Run the watermark detection and removal pipeline on an input video and write the processed video (with audio merged) to the given output path.
+
+        Detects watermark bounding boxes per frame, fills missing detections by interval averaging or neighboring frames, processes the video in breakpoint-based segments with overlap using the configured cleaner, encodes the cleaned frames to an intermediate video file, then merges the original audio into the final output.
+
+        Parameters:
+            input_video_path (Path): Path to the source video to process.
+            output_video_path (Path): Path where the final video with merged audio will be written.
+            progress_callback (Callable[[int], None] | None): Optional callback invoked periodically with an integer progress percentage (0–100). Progress values generally advance through detection and cleaning phases and report a final near-completion value before audio merge.
+            quiet (bool): If True, suppresses progress bar and most debug logging.
+        """
+        with nvtx("ProfileSoraWM.run"):
+            with nvtx("init video loader"):
+                input_video_loader = VideoLoader(input_video_path)
+                width = input_video_loader.width
+                height = input_video_loader.height
+                fps = input_video_loader.fps
+                total_frames = input_video_loader.total_frames
+
+                temp_output_path = (
+                    output_video_path.parent / f"temp_{output_video_path.name}"
+                )
+                output_options = {
+                    "pix_fmt": "yuv420p",
+                    "vcodec": "libx264",
+                    "preset": "slow",
+                }
+
+                if input_video_loader.original_bitrate:
+                    output_options["video_bitrate"] = str(
+                        int(int(input_video_loader.original_bitrate) * 1.2)
+                    )
+                else:
+                    output_options["crf"] = "18"
+
+                process_out = (
+                    ffmpeg.input(
+                        "pipe:",
+                        format="rawvideo",
+                        pix_fmt="bgr24",
+                        s=f"{width}x{height}",
+                        r=fps,
+                    )
+                    .output(str(temp_output_path), **output_options)
+                    .overwrite_output()
+                    .global_args("-loglevel", "error")
+                    .run_async(pipe_stdin=True)
+                )
+            range_push("detect watermarks")
+            frame_bboxes = {}
+            detect_missed = []
+            bbox_centers = []
+            bboxes = []
+
+            if not quiet:
+                logger.debug(
+                    f"total frames: {total_frames}, fps: {fps}, width: {width}, height: {height}"
+                )
+
+                for idx, frame in enumerate(
+                    tqdm(
+                        input_video_loader,
+                        total=total_frames,
+                        desc="Detect watermarks",
+                        disable=quiet,
+                    )
+                ):
+                    detection_result = self.detector.detect(frame)
+                    if detection_result["detected"]:
+                        frame_bboxes[idx] = {"bbox": detection_result["bbox"]}
+                        x1, y1, x2, y2 = detection_result["bbox"]
+                        bbox_centers.append((int((x1 + x2) / 2), int((y1 + y2) / 2)))
+                        bboxes.append((x1, y1, x2, y2))
+                    else:
+                        frame_bboxes[idx] = {"bbox": None}
+                        detect_missed.append(idx)
+                        bbox_centers.append(None)
+                        bboxes.append(None)
+
+                    if progress_callback and idx % 10 == 0:
+                        progress = 10 + int((idx / total_frames) * 40)
+                        progress_callback(progress)
+
+            if not quiet:
+                logger.debug(f"detect missed frames: {detect_missed}")
+
+            range_pop()
+            range_push("find bkps")
+            bkps_full = [0, total_frames]
+            if detect_missed:
+                bkps = find_2d_data_bkps(bbox_centers)
+                bkps_full = [0] + bkps + [total_frames]
+
+                interval_bboxes = get_interval_average_bbox(bboxes, bkps_full)
+                missed_intervals = find_idxs_interval(detect_missed, bkps_full)
+
+                for missed_idx, interval_idx in zip(detect_missed, missed_intervals):
+                    if (
+                        interval_idx < len(interval_bboxes)
+                        and interval_bboxes[interval_idx] is not None
+                    ):
+                        frame_bboxes[missed_idx]["bbox"] = interval_bboxes[interval_idx]
+                        if not quiet:
+                            logger.debug(
+                                f"Filled missed frame {missed_idx} with bbox:\n"
+                                f" {interval_bboxes[interval_idx]}"
+                            )
+                    else:
+                        before = max(missed_idx - 1, 0)
+                        after = min(missed_idx + 1, total_frames - 1)
+                        before_box = frame_bboxes[before]["bbox"]
+                        after_box = frame_bboxes[after]["bbox"]
+                        if before_box:
+                            frame_bboxes[missed_idx]["bbox"] = before_box
+                        elif after_box:
+                            frame_bboxes[missed_idx]["bbox"] = after_box
+            else:
+                del bboxes, bbox_centers, detect_missed
+            range_pop()
+            range_push("remove watermarks")
+
+            if self.cleaner_type == CleanerType.LAMA:
+                raise NotImplementedError("Lama cleaner is not implemented yet.")
+
+            elif self.cleaner_type == CleanerType.E2FGVI_HQ:
+                input_video_loader = VideoLoader(input_video_path)
+                frame_counter = 0
+                overlap_ratio = self.cleaner.config.overlap_ratio
+                all_cleaned_frames = None
+                num_segments = len(bkps_full) - 1
+
+                for segment_idx in range(num_segments):
+                    # with nvtx(f"process segment {segment_idx}"):
+                    range_push(f"process segment {segment_idx}")
+                    seg_start = bkps_full[segment_idx]
+                    seg_end = bkps_full[segment_idx + 1]
+                    seg_length = seg_end - seg_start
+                    segment_overlap = max(1, int(overlap_ratio * seg_length))
+                    start = seg_start
+                    end = seg_end
+
+                    if segment_idx > 0:
+                        start = max(
+                            seg_start - segment_overlap,
+                            bkps_full[segment_idx - 1],
+                        )
+                    if segment_idx < num_segments - 1:
+                        end = min(
+                            seg_end + segment_overlap,
+                            bkps_full[segment_idx + 2],
+                        )
+
+                    if not quiet:
+                        logger.debug(
+                            f"Segment {segment_idx}: original=[{seg_start}, {seg_end}), "
+                            f"with_overlap=[{start}, {end}), overlap={segment_overlap}"
+                        )
+
+                    frames = np.array(input_video_loader.get_slice(start, end))
+                    frames = frames[:, :, :, ::-1].copy()
+
+                    masks = np.zeros((len(frames), height, width), dtype=np.uint8)
+                    for idx in range(start, end):
+                        bbox = frame_bboxes[idx]["bbox"]
+                        if bbox is not None:
+                            x1, y1, x2, y2 = bbox
+                            idx_offset = idx - start
+                            masks[idx_offset][y1:y2, x1:x2] = 255
+
+                    # with nvtx(f"clean frames [{start},{end})"):
+                    range_push(f"clean frames [{start},{end})")
+                    # masks_npy_path = Path("masks.npy")
+                    # frames_np_path = Path("frames.npy")
+                    # np.save(masks_npy_path, masks)
+                    # np.save(frames_np_path, frames)
+                    # raise Exception("Stop here")
+                    cleaned_frames = self.cleaner.clean(frames, masks)
+                    range_pop()
+                    # with nvtx("merge frames"):
+                    range_push("merge frames")
+                    all_cleaned_frames = merge_frames_with_overlap(
+                        result_frames=all_cleaned_frames,
+                        chunk_frames=cleaned_frames,
+                        start_idx=start,
+                        overlap_size=segment_overlap,
+                        is_first_chunk=(segment_idx == 0),
+                    )
+                    range_pop()
+
+                    # with nvtx("write frames"):
+                    range_push("write frames")
+                    write_start = seg_start
+                    write_end = seg_end
+                    for write_idx in range(write_start, write_end):
+                        if (
+                            write_idx < len(all_cleaned_frames)
+                            and all_cleaned_frames[write_idx] is not None
+                        ):
+                            cleaned_frame = all_cleaned_frames[write_idx]
+                            cleaned_frame_bgr = cleaned_frame[:, :, ::-1]
+                            process_out.stdin.write(
+                                cleaned_frame_bgr.astype(np.uint8).tobytes()
+                            )
+                            frame_counter += 1
+                            if progress_callback and frame_counter % 10 == 0:
+                                progress = 50 + int((frame_counter / total_frames) * 45)
+                                progress_callback(progress)
+
+                    range_pop()
+                    range_pop()
+            range_pop()
+            range_push("finalize ffmpeg")
+            process_out.stdin.close()
+            process_out.wait()
+
+            if progress_callback:
+                progress_callback(95)
+
+            range_pop()
+            range_push("merge audio track")
+            self.merge_audio_track(
+                input_video_path, temp_output_path, output_video_path
+            )
+            range_pop()
+
+
+if __name__ == "__main__":
+    input_video_path = Path("resources/dog_vs_sam.mp4")
+    output_stem = Path("outputs/sora_watermark_removed")
+
+    sora_wm = ProfileSoraWM(cleaner_type=CleanerType.E2FGVI_HQ)
+    sora_wm.run(
+        input_video_path, output_stem.parent / (output_stem.name + "_e2fgvi_hq.mp4")
+    )

pyproject.toml

@@ -0,0 +1,64 @@
+[project]
+name = "sorawatermarkcleaner"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "aiofiles>=24.1.0",
+    "aiosqlite>=0.21.0",
+    "diffusers>=0.35.1",
+    "einops>=0.8.1",
+    "fastapi==0.108.0",
+    "ffmpeg-python>=0.2.0",
+    "fire>=0.7.1",
+    "greenlet>=3.2.4",
+    "httpx>=0.28.1",
+    "huggingface-hub>=0.35.3",
+    "jupyter>=1.1.1",
+    "loguru>=0.7.3",
+    "matplotlib>=3.10.6",
+    "mmcv-full>=1.7.2",
+    "notebook>=7.4.7",
+    "omegaconf>=2.3.0",
+    "opencv-python>=4.12.0.88",
+    "pandas>=2.3.3",
+    "pydantic>=2.11.10",
+    "python-multipart>=0.0.20",
+    "requests>=2.32.5",
+    "rich>=14.2.0",
+    "ruptures>=1.1.10",
+    "scikit-learn>=1.7.2",
+    "sqlalchemy>=2.0.43",
+    "streamlit>=1.50.0",
+    "torch>=2.5.0",
+    "torchvision>=0.20.0",
+    "tqdm>=4.67.1",
+    "transformers>=4.57.0",
+    "ultralytics>=8.3.204",
+    "uuid>=1.30",
+    "uvicorn>=0.35.0",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = "test_*.py"
+python_classes = "Test*"
+python_functions = "test_*"
+addopts = "-v --tb=short --strict-markers"
+markers = [
+    "unit: Unit tests",
+    "integration: Integration tests",
+    "slow: Slow running tests",
+    "gpu: Tests requiring GPU",
+]
+filterwarnings = [
+    "ignore::DeprecationWarning",
+    "ignore::PendingDeprecationWarning",
+]
+
+[tool.uv.extra-build-dependencies]
+mmcv-full = ["setuptools<81", "wheel", "packaging"]
+
+[tool.setuptools.packages.find]
+include = ["sorawm*"]