Add BraTS2020 segmentation pipeline - UNet3D, FastAPI backend, React frontend, 110 epochs Mean Dice 0.557

.env.example

@@ -0,0 +1,2 @@
+DATA_ROOT=path/to/MICCAI_BraTS2020_TrainingData
+CHECKPOINT_PATH=checkpoints/best_model.pth

.gitattributes

@@ -0,0 +1 @@
+*.pth filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,27 @@
+# Dataset
+BraTS2020_TrainingData/
+BraTS2020_ValidationData/
+
+# Environment
+.env
+
+# Python
+__pycache__/
+*.pyc
+.venv/
+
+# Checkpoints — keep best only
+checkpoints/epoch_*.pth
+src/checkpoints/
+checkpoints/logs/
+
+# Node
+frontend/node_modules/
+frontend/dist/
+
+# Jupyter
+.ipynb_checkpoints/
+
+# OS
+.DS_Store
+Thumbs.db

ExploringData.ipynb

@@ -0,0 +1,677 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "3d7f60a0",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "## Stage 1 — Data Exploration\n",
+    "\n",
+    "### What & Why\n",
+    "\n",
+    "Before writing any model code, we need to understand the raw data deeply.  \n",
+    "BraTS2020 gives us 369 training cases, each with 4 MRI modalities and a segmentation mask.\n",
+    "\n",
+    "**Key questions this stage answers:**\n",
+    "- What shape and dtype are the volumes?\n",
+    "- Are intensity ranges consistent across modalities and patients?\n",
+    "- What is the class distribution in the segmentation masks?\n",
+    "- What label remapping is required before training?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "9cb7973b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import nibabel as nib\n",
+    "import numpy as np\n",
+    "from pathlib import Path\n",
+    "\n",
+    "# ── Point this at your BraTS2020 training data root ──────────────────────────\n",
+    "DATA_ROOT = Path(r\"D:\\personal projects\\Brain-Tumor-Segmentation-with-BraTS\\BraTS2020_TrainingData\\MICCAI_BraTS2020_TrainingData\")\n",
+    "CASE_001  = DATA_ROOT / \"BraTS20_Training_001\"\n",
+    "MODALITIES = [\"flair\", \"t1\", \"t1ce\", \"t2\"]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4de818c4",
+   "metadata": {},
+   "source": [
+    "### 1.1 Modality Exploration\n",
+    "\n",
+    "We load each modality and inspect:\n",
+    "- **Shape** — should be `(240, 240, 155)` for all BraTS2020 volumes\n",
+    "- **Intensity range** — will differ across modalities (MRI values are not standardized)\n",
+    "- **Non-zero fraction** — tells us how much of the volume is actual brain vs background air"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "5328263a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "============================================================\n",
+      "MODALITY EXPLORATION — Case 001\n",
+      "============================================================\n",
+      "\n",
+      "── FLAIR ──────────────────────────\n",
+      "  Shape:           (240, 240, 155)\n",
+      "  Dtype:           float64\n",
+      "  Global min/max:  0.0  /  625.0\n",
+      "  Brain mean:      173.0\n",
+      "  Brain std:       64.9\n",
+      "  Non-zero voxels: 1,342,885  /  8,928,000  (15.0%)\n",
+      "\n",
+      "── T1 ──────────────────────────\n",
+      "  Shape:           (240, 240, 155)\n",
+      "  Dtype:           float64\n",
+      "  Global min/max:  0.0  /  678.0\n",
+      "  Brain mean:      354.3\n",
+      "  Brain std:       84.2\n",
+      "  Non-zero voxels: 1,342,885  /  8,928,000  (15.0%)\n",
+      "\n",
+      "── T1CE ──────────────────────────\n",
+      "  Shape:           (240, 240, 155)\n",
+      "  Dtype:           float64\n",
+      "  Global min/max:  0.0  /  1845.0\n",
+      "  Brain mean:      417.3\n",
+      "  Brain std:       109.2\n",
+      "  Non-zero voxels: 1,342,885  /  8,928,000  (15.0%)\n",
+      "\n",
+      "── T2 ──────────────────────────\n",
+      "  Shape:           (240, 240, 155)\n",
+      "  Dtype:           float64\n",
+      "  Global min/max:  0.0  /  376.0\n",
+      "  Brain mean:      114.7\n",
+      "  Brain std:       47.7\n",
+      "  Non-zero voxels: 1,342,885  /  8,928,000  (15.0%)\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"=\" * 60)\n",
+    "print(\"MODALITY EXPLORATION — Case 001\")\n",
+    "print(\"=\" * 60)\n",
+    "\n",
+    "for mod in MODALITIES:\n",
+    "    path = CASE_001 / f\"BraTS20_Training_001_{mod}.nii\"\n",
+    "    img  = nib.load(str(path))\n",
+    "    vol  = img.get_fdata()\n",
+    "\n",
+    "    brain_mask    = vol > 0\n",
+    "    brain_voxels  = vol[brain_mask]\n",
+    "\n",
+    "    print(f\"\\n── {mod.upper()} ──────────────────────────\")\n",
+    "    print(f\"  Shape:           {vol.shape}\")\n",
+    "    print(f\"  Dtype:           {vol.dtype}\")\n",
+    "    print(f\"  Global min/max:  {vol.min():.1f}  /  {vol.max():.1f}\")\n",
+    "    print(f\"  Brain mean:      {brain_voxels.mean():.1f}\")\n",
+    "    print(f\"  Brain std:       {brain_voxels.std():.1f}\")\n",
+    "    print(f\"  Non-zero voxels: {brain_mask.sum():,}  /  {vol.size:,}  ({100*brain_mask.mean():.1f}%)\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6f39f11f",
+   "metadata": {},
+   "source": [
+    "**What this tells us:**\n",
+    "\n",
+    "| Observation | Implication |\n",
+    "|---|---|\n",
+    "| All modalities: shape `(240, 240, 155)` | Pre-registered — voxel [x,y,z] is the same tissue in all 4 |\n",
+    "| All modalities: same non-zero fraction | Shared brain mask — background zeroed identically |\n",
+    "| Intensity ranges differ wildly (T2 max=376 vs T1ce max=1845) | Cannot normalize globally — must normalize **per modality** |\n",
+    "| Only 15% of voxels are non-zero | 85% is background air — wasteful for model input, crop it |"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0ba37626",
+   "metadata": {},
+   "source": [
+    "### 1.2 Segmentation Mask Exploration\n",
+    "\n",
+    "The segmentation mask is the ground truth we train against.  \n",
+    "BraTS2020 uses label set `{0, 1, 2, 4}` — note the jump from 2 to 4.  \n",
+    "This is a historical artifact. Our model uses output indices `{0,1,2,3}`, so we must remap `4 → 3`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "ab2d226c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "============================================================\n",
+      "SEGMENTATION MASK — Case 001\n",
+      "============================================================\n",
+      "\n",
+      "  Shape:         (240, 240, 155)\n",
+      "  Unique labels: [0 1 2 4]\n",
+      "\n",
+      "  Label 0:  8,716,021 voxels  (97.63%)  ← Background\n",
+      "  Label 1:     15,443 voxels  (0.17%)  ← Necrotic Core (NCR)\n",
+      "  Label 2:    168,794 voxels  (1.89%)  ← Peritumoral Edema (ED)\n",
+      "  Label 4:     27,742 voxels  (0.31%)  ← Enhancing Tumor (ET)\n",
+      "\n",
+      "⚠  Label 4 will be remapped to 3 before training\n",
+      "   Tumor burden: 2.37% of all voxels\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"=\" * 60)\n",
+    "print(\"SEGMENTATION MASK — Case 001\")\n",
+    "print(\"=\" * 60)\n",
+    "\n",
+    "seg_path = CASE_001 / \"BraTS20_Training_001_seg.nii\"\n",
+    "seg = nib.load(str(seg_path)).get_fdata().astype(np.uint8)\n",
+    "\n",
+    "CLASS_NAMES = {0: \"Background\", 1: \"Necrotic Core (NCR)\", 2: \"Peritumoral Edema (ED)\", 4: \"Enhancing Tumor (ET)\"}\n",
+    "\n",
+    "print(f\"\\n  Shape:         {seg.shape}\")\n",
+    "print(f\"  Unique labels: {np.unique(seg)}\")\n",
+    "print()\n",
+    "\n",
+    "for label in np.unique(seg):\n",
+    "    count = int((seg == label).sum())\n",
+    "    pct   = 100 * count / seg.size\n",
+    "    name  = CLASS_NAMES.get(label, \"Unknown\")\n",
+    "    print(f\"  Label {label}: {count:>10,} voxels  ({pct:.2f}%)  ← {name}\")\n",
+    "\n",
+    "print()\n",
+    "print(\"⚠  Label 4 will be remapped to 3 before training\")\n",
+    "print(f\"   Tumor burden: {100*(seg>0).mean():.2f}% of all voxels\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "982c8657",
+   "metadata": {},
+   "source": [
+    "**Why class imbalance matters:**\n",
+    "\n",
+    "Background = **97.63%** of all voxels. If a model predicts background everywhere,  \n",
+    "it achieves 97.63% voxel accuracy — and is clinically worthless.\n",
+    "\n",
+    "This is why we use **Dice loss** instead of cross-entropy alone.  \n",
+    "Dice is computed per class independently, so a 0.17% class gets the same gradient weight as a 50% class.\n",
+    "\n",
+    "**BraTS Evaluation Regions** (derived from the 4 labels):\n",
+    "\n",
+    "| Region | Labels | Clinical meaning |\n",
+    "|---|---|---|\n",
+    "| Whole Tumor (WT) | {1, 2, 3} | Total tumor extent |\n",
+    "| Tumor Core (TC) | {1, 3} | Surgically targetable core |\n",
+    "| Enhancing Tumor (ET) | {3} | Active, contrast-enhancing tumor |"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "240e9ec0",
+   "metadata": {},
+   "source": [
+    "### 1.3 Affine and Voxel Size"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "4cf35669",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Affine matrix (voxel → world space in mm):\n",
+      "[[ -1.  -0.  -0.   0.]\n",
+      " [ -0.  -1.  -0. 239.]\n",
+      " [  0.   0.   1.   0.]\n",
+      " [  0.   0.   0.   1.]]\n",
+      "\n",
+      "Voxel size: [1. 1. 1.] mm\n",
+      "→ Isotropic 1mm³ — each voxel represents 1mm × 1mm × 1mm of brain tissue\n"
+     ]
+    }
+   ],
+   "source": [
+    "img = nib.load(str(CASE_001 / \"BraTS20_Training_001_t1.nii\"))\n",
+    "print(\"Affine matrix (voxel → world space in mm):\")\n",
+    "print(img.affine)\n",
+    "print()\n",
+    "voxel_size = np.sqrt((img.affine[:3, :3] ** 2).sum(axis=0))\n",
+    "print(f\"Voxel size: {voxel_size} mm\")\n",
+    "print(\"→ Isotropic 1mm³ — each voxel represents 1mm × 1mm × 1mm of brain tissue\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "043bd59d",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "## Stage 2 — Z-Score Normalization\n",
+    "\n",
+    "### What & Why\n",
+    "\n",
+    "MRI intensity values are **scanner-dependent** — they have no universal physical meaning.  \n",
+    "A voxel value of 400 in one patient's T1 is not comparable to 400 in another patient's T1,  \n",
+    "even on the same scanner.\n",
+    "\n",
+    "**Why not min-max normalization?**  \n",
+    "MRI volumes often contain bright artifact voxels (motion, metal implants) that would  \n",
+    "compress the entire meaningful intensity range into a tiny interval.\n",
+    "\n",
+    "**The solution: Z-score normalization restricted to brain voxels**\n",
+    "\n",
+    "$$z = \\frac{x - \\mu_{brain}}{\\sigma_{brain}}$$\n",
+    "\n",
+    "Where $\\mu_{brain}$ and $\\sigma_{brain}$ are computed only over non-zero (brain) voxels.  \n",
+    "Background voxels are left at exactly 0.\n",
+    "\n",
+    "**Applied independently per modality** — never across modalities, never globally."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "db65548c",
+   "metadata": {},
+   "source": [
+    "### 2.1 Implementation\n",
+    "\n",
+    "```\n",
+    "CODE                                    │  EXPLANATION\n",
+    "────────────────────────────────────────│─────────────────────────────────────────\n",
+    "def normalize_modality(vol):            │  Takes one 3D modality volume.\n",
+    "                                        │\n",
+    "    brain_mask = vol > 0                │  Boolean mask: True = brain tissue.\n",
+    "                                        │  Background air is exactly 0 in BraTS.\n",
+    "                                        │\n",
+    "    if brain_mask.sum() == 0:           │  Edge case: completely empty volume\n",
+    "        return vol                      │  (e.g. a corrupted scan). Return as-is,\n",
+    "                                        │  do not divide by zero.\n",
+    "                                        │\n",
+    "    mu  = vol[brain_mask].mean()        │  Mean of brain voxels ONLY.\n",
+    "    std = vol[brain_mask].std() + 1e-8  │  Std of brain voxels + epsilon.\n",
+    "                                        │  Epsilon (1e-8) prevents div-by-zero\n",
+    "                                        │  if a region has constant intensity.\n",
+    "                                        │\n",
+    "    normalized = np.zeros_like(vol)     │  Start with all zeros — background\n",
+    "                                        │  stays 0 without any extra masking step.\n",
+    "                                        │\n",
+    "    normalized[brain_mask] = (          │  Apply z-score to brain voxels only.\n",
+    "        vol[brain_mask] - mu) / std     │  Background is untouched (stays 0).\n",
+    "                                        │\n",
+    "    return normalized                   │  Returns float32 array, same shape.\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "99c728a6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def normalize_modality(vol: np.ndarray) -> np.ndarray:\n",
+    "    \"\"\"\n",
+    "    Z-score normalization restricted to brain (non-zero) voxels.\n",
+    "    Background voxels remain exactly 0.\n",
+    "    Returns float32 array of same shape as input.\n",
+    "    \"\"\"\n",
+    "    brain_mask = vol > 0\n",
+    "\n",
+    "    if brain_mask.sum() == 0:\n",
+    "        return vol\n",
+    "\n",
+    "    mu  = vol[brain_mask].mean()\n",
+    "    std = vol[brain_mask].std() + 1e-8\n",
+    "\n",
+    "    normalized = np.zeros_like(vol)\n",
+    "    normalized[brain_mask] = (vol[brain_mask] - mu) / std\n",
+    "    return normalized.astype(np.float32)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7c0de8b9",
+   "metadata": {},
+   "source": [
+    "### 2.2 Verification"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "0b472c6c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "=== BEFORE ===\n",
+      "  mean (brain): 417.33\n",
+      "  std  (brain): 109.19\n",
+      "  background:   0.0000\n",
+      "\n",
+      "=== AFTER ===\n",
+      "  mean (brain): 0.0000   ← should be ≈ 0.0\n",
+      "  std  (brain): 1.0000    ← should be ≈ 1.0\n",
+      "  background:   0.0000               ← should be exactly 0.0\n",
+      "  dtype:        float32                    ← should be float32\n",
+      "\n",
+      "=== EDGE CASES ===\n",
+      "  Empty volume — all zeros: True\n",
+      "  Empty volume — no NaN:    True\n",
+      "  Background unchanged:     True\n",
+      "\n",
+      "=== ALL MODALITIES ===\n",
+      "  flair  → mean: +0.0000  std: 1.0000\n",
+      "  t1     → mean: -0.0000  std: 1.0000\n",
+      "  t1ce   → mean: +0.0000  std: 1.0000\n",
+      "  t2     → mean: +0.0000  std: 1.0000\n"
+     ]
+    }
+   ],
+   "source": [
+    "vol  = nib.load(str(CASE_001 / \"BraTS20_Training_001_t1ce.nii\")).get_fdata().astype(np.float32)\n",
+    "norm = normalize_modality(vol)\n",
+    "brain_mask = vol > 0\n",
+    "\n",
+    "print(\"=== BEFORE ===\")\n",
+    "print(f\"  mean (brain): {vol[brain_mask].mean():.2f}\")\n",
+    "print(f\"  std  (brain): {vol[brain_mask].std():.2f}\")\n",
+    "print(f\"  background:   {vol[0,0,0]:.4f}\")\n",
+    "\n",
+    "print(\"\\n=== AFTER ===\")\n",
+    "print(f\"  mean (brain): {norm[brain_mask].mean():.4f}   ← should be ≈ 0.0\")\n",
+    "print(f\"  std  (brain): {norm[brain_mask].std():.4f}    ← should be ≈ 1.0\")\n",
+    "print(f\"  background:   {norm[0,0,0]:.4f}               ← should be exactly 0.0\")\n",
+    "print(f\"  dtype:        {norm.dtype}                    ← should be float32\")\n",
+    "\n",
+    "print(\"\\n=== EDGE CASES ===\")\n",
+    "empty  = np.zeros((240,240,155), dtype=np.float32)\n",
+    "result = normalize_modality(empty)\n",
+    "print(f\"  Empty volume — all zeros: {(result == 0).all()}\")\n",
+    "print(f\"  Empty volume — no NaN:    {np.isfinite(result).all()}\")\n",
+    "print(f\"  Background unchanged:     {((vol==0) == (norm==0)).all()}\")\n",
+    "\n",
+    "print(\"\\n=== ALL MODALITIES ===\")\n",
+    "for mod in MODALITIES:\n",
+    "    v = nib.load(str(CASE_001 / f\"BraTS20_Training_001_{mod}.nii\")).get_fdata().astype(np.float32)\n",
+    "    n = normalize_modality(v)\n",
+    "    b = v > 0\n",
+    "    print(f\"  {mod:6s} → mean: {n[b].mean():+.4f}  std: {n[b].std():.4f}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "aa3d4a27",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "## Stage 3 — Bounding Box Crop + Resize\n",
+    "\n",
+    "### What & Why\n",
+    "\n",
+    "After normalization the volume is still `(240, 240, 155)` — but 85% is background zeros.  \n",
+    "Feeding this to a 3D U-Net wastes GPU memory on empty space.\n",
+    "\n",
+    "**Two-step spatial reduction:**\n",
+    "1. **Crop** — find the smallest box enclosing all non-zero voxels, discard the rest\n",
+    "2. **Resize** — interpolate the cropped volume to a fixed `(128, 128, 128)` shape\n",
+    "\n",
+    "Why `128³`? It is the largest cube that fits in ~10GB VRAM with batch size 1  \n",
+    "using a standard 3D U-Net with 32 base filters. It is the de facto BraTS standard."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "43ed8cf3",
+   "metadata": {},
+   "source": [
+    "### 3.1 Crop to Brain Bounding Box\n",
+    "\n",
+    "```\n",
+    "CODE                                    │  EXPLANATION\n",
+    "────────────────────────────────────────│─────────────────────────────────────────\n",
+    "def crop_to_brain(vol):                 │  Takes a 3D numpy array.\n",
+    "                                        │\n",
+    "    coords = np.array(                  │  np.where(vol > 0) returns a tuple of\n",
+    "        np.where(vol > 0))              │  3 arrays: (x_idxs, y_idxs, z_idxs)\n",
+    "                                        │  for every non-zero voxel.\n",
+    "                                        │  np.array(...) stacks them → shape (3, N)\n",
+    "                                        │\n",
+    "    if coords.shape[1] == 0:            │  Edge case: empty volume.\n",
+    "        return vol                      │\n",
+    "                                        │\n",
+    "    mins = coords.min(axis=1)           │  Minimum index along each axis.\n",
+    "                                        │  shape (3,) → [x_min, y_min, z_min]\n",
+    "                                        │\n",
+    "    maxs = coords.max(axis=1) + 1       │  Maximum index + 1.\n",
+    "                                        │  +1 because Python slicing is exclusive\n",
+    "                                        │  at the end: vol[0:228] gives indices\n",
+    "                                        │  0..227, so last brain voxel at 227\n",
+    "                                        │  requires stop index 228.\n",
+    "                                        │\n",
+    "    return vol[mins[0]:maxs[0],         │  Slice all three axes simultaneously.\n",
+    "               mins[1]:maxs[1],         │  Returns a VIEW — no data is copied\n",
+    "               mins[2]:maxs[2]]         │  until you modify it.\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "e678433b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def crop_to_brain(vol: np.ndarray) -> np.ndarray:\n",
+    "    \"\"\"\n",
+    "    Crop vol to the tight bounding box of non-zero voxels.\n",
+    "    If the volume is entirely zero, return it unchanged.\n",
+    "    \"\"\"\n",
+    "    coords = np.array(np.where(vol > 0))\n",
+    "\n",
+    "    if coords.shape[1] == 0:\n",
+    "        return vol\n",
+    "\n",
+    "    mins = coords.min(axis=1)\n",
+    "    maxs = coords.max(axis=1) + 1\n",
+    "\n",
+    "    return vol[mins[0]:maxs[0],\n",
+    "               mins[1]:maxs[1],\n",
+    "               mins[2]:maxs[2]]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "effdef0f",
+   "metadata": {},
+   "source": [
+    "### 3.2 Resize to Target Shape\n",
+    "\n",
+    "```\n",
+    "CODE                                    │  EXPLANATION\n",
+    "────────────────────────────────────────│─────────────────────────────────────────\n",
+    "def resize_volume(vol, target=          │  Default target is 128³.\n",
+    "        (128,128,128)):                 │\n",
+    "                                        │\n",
+    "    tensor = torch.from_numpy(vol)      │  numpy → torch tensor\n",
+    "        .float()                        │  Ensure float32\n",
+    "        .unsqueeze(0)                   │  Add batch dim:   (H,W,D) → (1,H,W,D)\n",
+    "        .unsqueeze(0)                   │  Add channel dim: (1,H,W,D) → (1,1,H,W,D)\n",
+    "                                        │  F.interpolate requires (B,C,H,W,D)\n",
+    "                                        │\n",
+    "    resized = F.interpolate(            │\n",
+    "        tensor,                         │\n",
+    "        size=target,                    │  Target spatial shape (128,128,128)\n",
+    "        mode=\"trilinear\",               │  3D equivalent of bilinear for images.\n",
+    "                                        │  Smoothly interpolates between voxels.\n",
+    "                                        │  (nearest-neighbor creates blocky edges)\n",
+    "        align_corners=True              │  Corner voxels of input map exactly to\n",
+    "    )                                   │  corner voxels of output.\n",
+    "                                        │  Use True for medical data — ensures\n",
+    "                                        │  image and mask stay aligned when resized\n",
+    "                                        │  separately.\n",
+    "                                        │\n",
+    "    return resized.squeeze().numpy()    │  Remove batch+channel dims, back to numpy\n",
+    "                                        │  (1,1,128,128,128) → (128,128,128)\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "9eecc011",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import torch.nn.functional as F\n",
+    "\n",
+    "def resize_volume(vol: np.ndarray, target=(128, 128, 128)) -> np.ndarray:\n",
+    "    \"\"\"\n",
+    "    Resize a 3D volume to target shape using trilinear interpolation.\n",
+    "    align_corners=True ensures image and mask stay aligned when resized separately.\n",
+    "    \"\"\"\n",
+    "    tensor = torch.from_numpy(vol).float().unsqueeze(0).unsqueeze(0)\n",
+    "\n",
+    "    resized = F.interpolate(\n",
+    "        tensor,\n",
+    "        size=target,\n",
+    "        mode=\"trilinear\",\n",
+    "        align_corners=True\n",
+    "    )\n",
+    "\n",
+    "    return resized.squeeze().numpy()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "46e24f22",
+   "metadata": {},
+   "source": [
+    "### 3.3 Verification"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "c1c0211d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "=== CROP ===\n",
+      "  Before: (240, 240, 155)\n",
+      "  After:  (136, 171, 132)   ← smaller than (240,240,155)\n",
+      "  Brain signal preserved: True\n",
+      "\n",
+      "=== RESIZE ===\n",
+      "  Shape: (128, 128, 128)   ← should be (128, 128, 128)\n",
+      "  dtype: float32   ← should be float32\n",
+      "\n",
+      "=== FULL PIPELINE — ALL 4 MODALITIES ===\n",
+      "  (normalize → crop → resize)\n",
+      "  flair  → (128, 128, 128)  mean=+0.932\n",
+      "  t1     → (128, 128, 128)  mean=+0.747\n",
+      "  t1ce   → (128, 128, 128)  mean=+0.659\n",
+      "  t2     → (128, 128, 128)  mean=+0.993\n",
+      "\n",
+      "  ✅ All modalities: (128, 128, 128) — ready for model input\n"
+     ]
+    }
+   ],
+   "source": [
+    "vol  = nib.load(str(CASE_001 / \"BraTS20_Training_001_t1ce.nii\")).get_fdata().astype(np.float32)\n",
+    "norm = normalize_modality(vol)\n",
+    "\n",
+    "print(\"=== CROP ===\")\n",
+    "cropped = crop_to_brain(norm)\n",
+    "print(f\"  Before: {norm.shape}\")\n",
+    "print(f\"  After:  {cropped.shape}   ← smaller than (240,240,155)\")\n",
+    "print(f\"  Brain signal preserved: {(cropped > 0).any()}\")\n",
+    "\n",
+    "print(\"\\n=== RESIZE ===\")\n",
+    "resized = resize_volume(cropped, target=(128, 128, 128))\n",
+    "print(f\"  Shape: {resized.shape}   ← should be (128, 128, 128)\")\n",
+    "print(f\"  dtype: {resized.dtype}   ← should be float32\")\n",
+    "\n",
+    "print(\"\\n=== FULL PIPELINE — ALL 4 MODALITIES ===\")\n",
+    "print(\"  (normalize → crop → resize)\")\n",
+    "for mod in MODALITIES:\n",
+    "    v = nib.load(str(CASE_001 / f\"BraTS20_Training_001_{mod}.nii\")).get_fdata().astype(np.float32)\n",
+    "    processed = resize_volume(crop_to_brain(normalize_modality(v)))\n",
+    "    print(f\"  {mod:6s} → {processed.shape}  mean={processed[processed>0].mean():+.3f}\")\n",
+    "print(\"\\n  ✅ All modalities: (128, 128, 128) — ready for model input\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0787a97b",
+   "metadata": {},
+   "source": [
+    "### 3.4 What the Pipeline Does to One Voxel\n",
+    "\n",
+    "```\n",
+    "Raw T1ce voxel at brain center:   417.3  (scanner units, meaningless across patients)\n",
+    "After normalize_modality:           0.0  (mean of brain = 0, std = 1)\n",
+    "After crop_to_brain:                0.0  (same value, just in smaller array)\n",
+    "After resize_volume:               ~0.0  (trilinear blend of neighbors, close to 0)\n",
+    "```\n",
+    "\n",
+    "```\n",
+    "Raw T1ce bright tumor voxel:     1845.0\n",
+    "After normalize_modality:          12.9  (13 standard deviations above brain mean)\n",
+    "After crop_to_brain:               12.9\n",
+    "After resize_volume:              ~12.0  (slightly smoothed by interpolation)\n",
+    "```\n",
+    "\n",
+    "The tumor voxel remains a strong outlier even after normalization.  \n",
+    "That outlier signal is exactly what the model learns to detect."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

README.md

@@ -1 +1,173 @@
-# Brain-Tumor-Segmentation-with-BraTS
+# Brain Tumor Segmentation with BraTS2020
+
+A full-stack 3D U-Net implementation for brain tumor segmentation, built step-by-step as a learning project.
+
+**Stack:** Python · NumPy · PyTorch · nibabel · FastAPI · React  
+**Dataset:** [BraTS2020](https://www.med.upenn.edu/cbica/brats2020/) — 369 training cases, 125 validation cases
+
+---
+
+## Progress
+
+| Stage | Topic | Status |
+|-------|-------|--------|
+| 1 | Data exploration | ✅ Complete |
+| 2 | Z-score normalization | ✅ Complete |
+| 3 | Bounding box crop + resize | ✅ Complete |
+| 4 | PyTorch Dataset class | 🔜 Next |
+| 5 | 3D U-Net architecture | 🔜 Coming |
+| 6 | Training loop | 🔜 Coming |
+| 7 | FastAPI backend | 🔜 Coming |
+| 8 | React frontend | 🔜 Coming |
+
+---
+
+## Dataset Structure
+
+```
+MICCAI_BraTS2020_TrainingData/
+  BraTS20_Training_001/
+    BraTS20_Training_001_flair.nii   ← FLAIR modality
+    BraTS20_Training_001_t1.nii      ← T1-weighted
+    BraTS20_Training_001_t1ce.nii    ← T1 contrast-enhanced
+    BraTS20_Training_001_t2.nii      ← T2-weighted
+    BraTS20_Training_001_seg.nii     ← Ground truth mask
+  BraTS20_Training_002/ ...
+  BraTS20_Training_369/
+  name_mapping.csv
+  survival_info.csv
+```
+
+Each volume: shape `(240, 240, 155)`, voxel size `1mm³`, dtype `float64`.
+
+---
+
+## Key Data Facts
+
+| Property | Value | Implication |
+|---|---|---|
+| Volume shape | `(240, 240, 155)` | 3D — needs 3D-aware model |
+| Voxel size | `1mm × 1mm × 1mm` | Physical scale known |
+| Non-zero fraction | ~15% | Crop before feeding to model |
+| Intensity ranges | T2: 0–376, T1ce: 0–1845 | Normalize per modality |
+| Seg labels | `{0, 1, 2, 4}` | Remap `4 → 3` before training |
+| Background fraction | 97.63% | Cross-entropy alone won't work |
+
+### MRI Modalities
+
+| Modality | Measures | Key use |
+|---|---|---|
+| T1 | Longitudinal relaxation | Anatomy, grey/white matter |
+| T1ce | T1 + gadolinium contrast | Active tumor (enhancing) |
+| T2 | Transverse relaxation | Fluid, edema |
+| FLAIR | T2 with free water suppressed | Peritumoral edema |
+
+### BraTS Evaluation Regions
+
+| Region | Labels | Clinical meaning |
+|---|---|---|
+| Whole Tumor (WT) | {1, 2, 3} | Total tumor extent |
+| Tumor Core (TC) | {1, 3} | Surgically targetable core |
+| Enhancing Tumor (ET) | {3} | Active, contrast-enhancing |
+
+---
+
+## Preprocessing Pipeline
+
+```
+Raw NIfTI (240×240×155)
+        ↓
+normalize_modality()     Z-score within brain mask, per modality
+        ↓
+crop_to_brain()          Tight bounding box of non-zero voxels
+        ↓
+resize_volume()          Trilinear interpolation → (128, 128, 128)
+        ↓
+Model input tensor       (4, 128, 128, 128) — 4 modalities stacked
+```
+
+### normalize_modality
+
+```python
+def normalize_modality(vol: np.ndarray) -> np.ndarray:
+    brain_mask = vol > 0
+    if brain_mask.sum() == 0:
+        return vol
+    mu  = vol[brain_mask].mean()
+    std = vol[brain_mask].std() + 1e-8
+    normalized = np.zeros_like(vol)
+    normalized[brain_mask] = (vol[brain_mask] - mu) / std
+    return normalized.astype(np.float32)
+```
+
+**Why:** MRI intensities are scanner-dependent — not comparable across patients or modalities.
+Z-score within brain voxels gives each modality mean≈0, std≈1, regardless of scanner.
+
+### crop_to_brain
+
+```python
+def crop_to_brain(vol: np.ndarray) -> np.ndarray:
+    coords = np.array(np.where(vol > 0))
+    if coords.shape[1] == 0:
+        return vol
+    mins = coords.min(axis=1)
+    maxs = coords.max(axis=1) + 1
+    return vol[mins[0]:maxs[0], mins[1]:maxs[1], mins[2]:maxs[2]]
+```
+
+**Why:** 85% of the `(240,240,155)` volume is background air.
+Cropping to the brain bounding box removes wasted computation and GPU memory.
+
+### resize_volume
+
+```python
+def resize_volume(vol: np.ndarray, target=(128, 128, 128)) -> np.ndarray:
+    tensor  = torch.from_numpy(vol).float().unsqueeze(0).unsqueeze(0)
+    resized = F.interpolate(tensor, size=target, mode="trilinear", align_corners=True)
+    return resized.squeeze().numpy()
+```
+
+**Why:** The model requires fixed-size input. `128³` fits in ~10GB VRAM at batch size 1.
+`align_corners=True` ensures image and mask stay spatially aligned when resized separately.
+
+---
+
+## Segmentation Label Remapping
+
+BraTS2020 raw labels: `{0, 1, 2, 4}` — no label 3 (historical artifact).  
+Before training, remap `4 → 3` so model output indices match:
+
+```python
+seg[seg == 4] = 3
+# 0 = background
+# 1 = necrotic core (NCR)
+# 2 = peritumoral edema (ED)
+# 3 = enhancing tumor (ET)  ← was label 4 in raw file
+```
+
+---
+
+## Repository Structure
+
+```
+Brain-Tumor-Segmentation-with-BraTS/
+├── README.md
+├── BraTS2020_Tutorial.ipynb     ← learning notebook (grows each stage)
+├── src/
+│   ├── preprocessing.py         ← normalize, crop, resize  ✅
+│   ├── dataset.py               ← BraTSDataset             🔜
+│   ├── model.py                 ← 3D U-Net                 🔜
+│   ├── train.py                 ← training loop            🔜
+│   └── inference.py             ← inference + export       🔜
+├── backend/                     ← FastAPI server           🔜
+└── frontend/                    ← React UI                 🔜
+```
+
+---
+
+## References
+
+- [BraTS 2020 Challenge](https://www.med.upenn.edu/cbica/brats2020/)
+- [3D U-Net (Çiçek et al., 2016)](https://arxiv.org/abs/1606.06650)
+- [nnU-Net (Isensee et al., 2021)](https://www.nature.com/articles/s41592-020-01008-z)
+- [Dice Loss for medical segmentation](https://arxiv.org/abs/1707.03237)

checkpoints/best_model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9b82ab27f5111b3a88c9c9071c5412dd670ccd7bc9ba31a0afcaafd2a5c0145d
+size 315966437

frontend/.gitignore

@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?

frontend/README.md

@@ -0,0 +1,16 @@
+# React + Vite
+
+This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.
+
+Currently, two official plugins are available:
+
+- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react) uses [Oxc](https://oxc.rs)
+- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react-swc) uses [SWC](https://swc.rs/)
+
+## React Compiler
+
+The React Compiler is not enabled on this template because of its impact on dev & build performances. To add it, see [this documentation](https://react.dev/learn/react-compiler/installation).
+
+## Expanding the ESLint configuration
+
+If you are developing a production application, we recommend using TypeScript with type-aware lint rules enabled. Check out the [TS template](https://github.com/vitejs/vite/tree/main/packages/create-vite/template-react-ts) for information on how to integrate TypeScript and [`typescript-eslint`](https://typescript-eslint.io) in your project.

frontend/eslint.config.js

@@ -0,0 +1,29 @@
+import js from '@eslint/js'
+import globals from 'globals'
+import reactHooks from 'eslint-plugin-react-hooks'
+import reactRefresh from 'eslint-plugin-react-refresh'
+import { defineConfig, globalIgnores } from 'eslint/config'
+
+export default defineConfig([
+  globalIgnores(['dist']),
+  {
+    files: ['**/*.{js,jsx}'],
+    extends: [
+      js.configs.recommended,
+      reactHooks.configs.flat.recommended,
+      reactRefresh.configs.vite,
+    ],
+    languageOptions: {
+      ecmaVersion: 2020,
+      globals: globals.browser,
+      parserOptions: {
+        ecmaVersion: 'latest',
+        ecmaFeatures: { jsx: true },
+        sourceType: 'module',
+      },
+    },
+    rules: {
+      'no-unused-vars': ['error', { varsIgnorePattern: '^[A-Z_]' }],
+    },
+  },
+])

frontend/index.html

@@ -0,0 +1,15 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link href="https://fonts.googleapis.com/css2?family=IBM+Plex+Mono:wght@300;400;500&display=swap" rel="stylesheet">
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>frontend</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.jsx"></script>
+  </body>
+</html>

frontend/package-lock.json

@@ -0,0 +1,2610 @@
+{
+  "name": "frontend",
+  "version": "0.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "frontend",
+      "version": "0.0.0",
+      "dependencies": {
+        "react": "^19.2.4",
+        "react-dom": "^19.2.4"
+      },
+      "devDependencies": {
+        "@eslint/js": "^9.39.4",
+        "@types/react": "^19.2.14",
+        "@types/react-dom": "^19.2.3",
+        "@vitejs/plugin-react": "^6.0.0",
+        "eslint": "^9.39.4",
+        "eslint-plugin-react-hooks": "^7.0.1",
+        "eslint-plugin-react-refresh": "^0.5.2",
+        "globals": "^17.4.0",
+        "vite": "^8.0.0"
+      }
+    },
+    "node_modules/@babel/code-frame": {
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.0.tgz",
+      "integrity": "sha512-9NhCeYjq9+3uxgdtp20LSiJXJvN0FeCtNGpJxuMFZ1Kv3cWUNb6DOhJwUvcVCzKGR66cw4njwM6hrJLqgOwbcw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-validator-identifier": "^7.28.5",
+        "js-tokens": "^4.0.0",
+        "picocolors": "^1.1.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/compat-data": {
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.29.0.tgz",
+      "integrity": "sha512-T1NCJqT/j9+cn8fvkt7jtwbLBfLC/1y1c7NtCeXFRgzGTsafi68MRv8yzkYSapBnFA6L3U2VSc02ciDzoAJhJg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/core": {
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.29.0.tgz",
+      "integrity": "sha512-CGOfOJqWjg2qW/Mb6zNsDm+u5vFQ8DxXfbM09z69p5Z6+mE1ikP2jUXw+j42Pf1XTYED2Rni5f95npYeuwMDQA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.29.0",
+        "@babel/generator": "^7.29.0",
+        "@babel/helper-compilation-targets": "^7.28.6",
+        "@babel/helper-module-transforms": "^7.28.6",
+        "@babel/helpers": "^7.28.6",
+        "@babel/parser": "^7.29.0",
+        "@babel/template": "^7.28.6",
+        "@babel/traverse": "^7.29.0",
+        "@babel/types": "^7.29.0",
+        "@jridgewell/remapping": "^2.3.5",
+        "convert-source-map": "^2.0.0",
+        "debug": "^4.1.0",
+        "gensync": "^1.0.0-beta.2",
+        "json5": "^2.2.3",
+        "semver": "^6.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/babel"
+      }
+    },
+    "node_modules/@babel/generator": {
+      "version": "7.29.1",
+      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.29.1.tgz",
+      "integrity": "sha512-qsaF+9Qcm2Qv8SRIMMscAvG4O3lJ0F1GuMo5HR/Bp02LopNgnZBC/EkbevHFeGs4ls/oPz9v+Bsmzbkbe+0dUw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.29.0",
+        "@babel/types": "^7.29.0",
+        "@jridgewell/gen-mapping": "^0.3.12",
+        "@jridgewell/trace-mapping": "^0.3.28",
+        "jsesc": "^3.0.2"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-compilation-targets": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.28.6.tgz",
+      "integrity": "sha512-JYtls3hqi15fcx5GaSNL7SCTJ2MNmjrkHXg4FSpOA/grxK8KwyZ5bubHsCq8FXCkua6xhuaaBit+3b7+VZRfcA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/compat-data": "^7.28.6",
+        "@babel/helper-validator-option": "^7.27.1",
+        "browserslist": "^4.24.0",
+        "lru-cache": "^5.1.1",
+        "semver": "^6.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-globals": {
+      "version": "7.28.0",
+      "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.28.0.tgz",
+      "integrity": "sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-module-imports": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.28.6.tgz",
+      "integrity": "sha512-l5XkZK7r7wa9LucGw9LwZyyCUscb4x37JWTPz7swwFE/0FMQAGpiWUZn8u9DzkSBWEcK25jmvubfpw2dnAMdbw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/traverse": "^7.28.6",
+        "@babel/types": "^7.28.6"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-module-transforms": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.28.6.tgz",
+      "integrity": "sha512-67oXFAYr2cDLDVGLXTEABjdBJZ6drElUSI7WKp70NrpyISso3plG9SAGEF6y7zbha/wOzUByWWTJvEDVNIUGcA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-module-imports": "^7.28.6",
+        "@babel/helper-validator-identifier": "^7.28.5",
+        "@babel/traverse": "^7.28.6"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
+      }
+    },
+    "node_modules/@babel/helper-string-parser": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz",
+      "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-validator-identifier": {
+      "version": "7.28.5",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.28.5.tgz",
+      "integrity": "sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-validator-option": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.27.1.tgz",
+      "integrity": "sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helpers": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.28.6.tgz",
+      "integrity": "sha512-xOBvwq86HHdB7WUDTfKfT/Vuxh7gElQ+Sfti2Cy6yIWNW05P8iUslOVcZ4/sKbE+/jQaukQAdz/gf3724kYdqw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/template": "^7.28.6",
+        "@babel/types": "^7.28.6"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/parser": {
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.0.tgz",
+      "integrity": "sha512-IyDgFV5GeDUVX4YdF/3CPULtVGSXXMLh1xVIgdCgxApktqnQV0r7/8Nqthg+8YLGaAtdyIlo2qIdZrbCv4+7ww==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.29.0"
+      },
+      "bin": {
+        "parser": "bin/babel-parser.js"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@babel/template": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.28.6.tgz",
+      "integrity": "sha512-YA6Ma2KsCdGb+WC6UpBVFJGXL58MDA6oyONbjyF/+5sBgxY/dwkhLogbMT2GXXyU84/IhRw/2D1Os1B/giz+BQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.28.6",
+        "@babel/parser": "^7.28.6",
+        "@babel/types": "^7.28.6"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/traverse": {
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.0.tgz",
+      "integrity": "sha512-4HPiQr0X7+waHfyXPZpWPfWL/J7dcN1mx9gL6WdQVMbPnF3+ZhSMs8tCxN7oHddJE9fhNE7+lxdnlyemKfJRuA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.29.0",
+        "@babel/generator": "^7.29.0",
+        "@babel/helper-globals": "^7.28.0",
+        "@babel/parser": "^7.29.0",
+        "@babel/template": "^7.28.6",
+        "@babel/types": "^7.29.0",
+        "debug": "^4.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/types": {
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.0.tgz",
+      "integrity": "sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-string-parser": "^7.27.1",
+        "@babel/helper-validator-identifier": "^7.28.5"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@emnapi/core": {
+      "version": "1.9.0",
+      "resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.9.0.tgz",
+      "integrity": "sha512-0DQ98G9ZQZOxfUcQn1waV2yS8aWdZ6kJMbYCJB3oUBecjWYO1fqJ+a1DRfPF3O5JEkwqwP1A9QEN/9mYm2Yd0w==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@emnapi/wasi-threads": "1.2.0",
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@emnapi/runtime": {
+      "version": "1.9.0",
+      "resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.9.0.tgz",
+      "integrity": "sha512-QN75eB0IH2ywSpRpNddCRfQIhmJYBCJ1x5Lb3IscKAL8bMnVAKnRg8dCoXbHzVLLH7P38N2Z3mtulB7W0J0FKw==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@emnapi/wasi-threads": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/@emnapi/wasi-threads/-/wasi-threads-1.2.0.tgz",
+      "integrity": "sha512-N10dEJNSsUx41Z6pZsXU8FjPjpBEplgH24sfkmITrBED1/U2Esum9F3lfLrMjKHHjmi557zQn7kR9R+XWXu5Rg==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@eslint-community/eslint-utils": {
+      "version": "4.9.1",
+      "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.9.1.tgz",
+      "integrity": "sha512-phrYmNiYppR7znFEdqgfWHXR6NCkZEK7hwWDHZUjit/2/U0r6XvkDl0SYnoM51Hq7FhCGdLDT6zxCCOY1hexsQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "eslint-visitor-keys": "^3.4.3"
+      },
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      },
+      "peerDependencies": {
+        "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0"
+      }
+    },
+    "node_modules/@eslint-community/eslint-utils/node_modules/eslint-visitor-keys": {
+      "version": "3.4.3",
+      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz",
+      "integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/@eslint-community/regexpp": {
+      "version": "4.12.2",
+      "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.12.2.tgz",
+      "integrity": "sha512-EriSTlt5OC9/7SXkRSCAhfSxxoSUgBm33OH+IkwbdpgoqsSsUg7y3uh+IICI/Qg4BBWr3U2i39RpmycbxMq4ew==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^12.0.0 || ^14.0.0 || >=16.0.0"
+      }
+    },
+    "node_modules/@eslint/config-array": {
+      "version": "0.21.2",
+      "resolved": "https://registry.npmjs.org/@eslint/config-array/-/config-array-0.21.2.tgz",
+      "integrity": "sha512-nJl2KGTlrf9GjLimgIru+V/mzgSK0ABCDQRvxw5BjURL7WfH5uoWmizbH7QB6MmnMBd8cIC9uceWnezL1VZWWw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@eslint/object-schema": "^2.1.7",
+        "debug": "^4.3.1",
+        "minimatch": "^3.1.5"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "node_modules/@eslint/config-helpers": {
+      "version": "0.4.2",
+      "resolved": "https://registry.npmjs.org/@eslint/config-helpers/-/config-helpers-0.4.2.tgz",
+      "integrity": "sha512-gBrxN88gOIf3R7ja5K9slwNayVcZgK6SOUORm2uBzTeIEfeVaIhOpCtTox3P6R7o2jLFwLFTLnC7kU/RGcYEgw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@eslint/core": "^0.17.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "node_modules/@eslint/core": {
+      "version": "0.17.0",
+      "resolved": "https://registry.npmjs.org/@eslint/core/-/core-0.17.0.tgz",
+      "integrity": "sha512-yL/sLrpmtDaFEiUj1osRP4TI2MDz1AddJL+jZ7KSqvBuliN4xqYY54IfdN8qD8Toa6g1iloph1fxQNkjOxrrpQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@types/json-schema": "^7.0.15"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "node_modules/@eslint/eslintrc": {
+      "version": "3.3.5",
+      "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-3.3.5.tgz",
+      "integrity": "sha512-4IlJx0X0qftVsN5E+/vGujTRIFtwuLbNsVUe7TO6zYPDR1O6nFwvwhIKEKSrl6dZchmYBITazxKoUYOjdtjlRg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ajv": "^6.14.0",
+        "debug": "^4.3.2",
+        "espree": "^10.0.1",
+        "globals": "^14.0.0",
+        "ignore": "^5.2.0",
+        "import-fresh": "^3.2.1",
+        "js-yaml": "^4.1.1",
+        "minimatch": "^3.1.5",
+        "strip-json-comments": "^3.1.1"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/@eslint/eslintrc/node_modules/globals": {
+      "version": "14.0.0",
+      "resolved": "https://registry.npmjs.org/globals/-/globals-14.0.0.tgz",
+      "integrity": "sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/@eslint/js": {
+      "version": "9.39.4",
+      "resolved": "https://registry.npmjs.org/@eslint/js/-/js-9.39.4.tgz",
+      "integrity": "sha512-nE7DEIchvtiFTwBw4Lfbu59PG+kCofhjsKaCWzxTpt4lfRjRMqG6uMBzKXuEcyXhOHoUp9riAm7/aWYGhXZ9cw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://eslint.org/donate"
+      }
+    },
+    "node_modules/@eslint/object-schema": {
+      "version": "2.1.7",
+      "resolved": "https://registry.npmjs.org/@eslint/object-schema/-/object-schema-2.1.7.tgz",
+      "integrity": "sha512-VtAOaymWVfZcmZbp6E2mympDIHvyjXs/12LqWYjVw6qjrfF+VK+fyG33kChz3nnK+SU5/NeHOqrTEHS8sXO3OA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "node_modules/@eslint/plugin-kit": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/@eslint/plugin-kit/-/plugin-kit-0.4.1.tgz",
+      "integrity": "sha512-43/qtrDUokr7LJqoF2c3+RInu/t4zfrpYdoSDfYyhg52rwLV6TnOvdG4fXm7IkSB3wErkcmJS9iEhjVtOSEjjA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@eslint/core": "^0.17.0",
+        "levn": "^0.4.1"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "node_modules/@humanfs/core": {
+      "version": "0.19.1",
+      "resolved": "https://registry.npmjs.org/@humanfs/core/-/core-0.19.1.tgz",
+      "integrity": "sha512-5DyQ4+1JEUzejeK1JGICcideyfUbGixgS9jNgex5nqkW+cY7WZhxBigmieN5Qnw9ZosSNVC9KQKyb+GUaGyKUA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=18.18.0"
+      }
+    },
+    "node_modules/@humanfs/node": {
+      "version": "0.16.7",
+      "resolved": "https://registry.npmjs.org/@humanfs/node/-/node-0.16.7.tgz",
+      "integrity": "sha512-/zUx+yOsIrG4Y43Eh2peDeKCxlRt/gET6aHfaKpuq267qXdYDFViVHfMaLyygZOnl0kGWxFIgsBy8QFuTLUXEQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@humanfs/core": "^0.19.1",
+        "@humanwhocodes/retry": "^0.4.0"
+      },
+      "engines": {
+        "node": ">=18.18.0"
+      }
+    },
+    "node_modules/@humanwhocodes/module-importer": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz",
+      "integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=12.22"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/nzakas"
+      }
+    },
+    "node_modules/@humanwhocodes/retry": {
+      "version": "0.4.3",
+      "resolved": "https://registry.npmjs.org/@humanwhocodes/retry/-/retry-0.4.3.tgz",
+      "integrity": "sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=18.18"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/nzakas"
+      }
+    },
+    "node_modules/@jridgewell/gen-mapping": {
+      "version": "0.3.13",
+      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
+      "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.0",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "node_modules/@jridgewell/remapping": {
+      "version": "2.3.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz",
+      "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/gen-mapping": "^0.3.5",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "node_modules/@jridgewell/resolve-uri": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
+      "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/sourcemap-codec": {
+      "version": "1.5.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
+      "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@jridgewell/trace-mapping": {
+      "version": "0.3.31",
+      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz",
+      "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/resolve-uri": "^3.1.0",
+        "@jridgewell/sourcemap-codec": "^1.4.14"
+      }
+    },
+    "node_modules/@napi-rs/wasm-runtime": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/@napi-rs/wasm-runtime/-/wasm-runtime-1.1.1.tgz",
+      "integrity": "sha512-p64ah1M1ld8xjWv3qbvFwHiFVWrq1yFvV4f7w+mzaqiR4IlSgkqhcRdHwsGgomwzBH51sRY4NEowLxnaBjcW/A==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@emnapi/core": "^1.7.1",
+        "@emnapi/runtime": "^1.7.1",
+        "@tybys/wasm-util": "^0.10.1"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@oxc-project/runtime": {
+      "version": "0.115.0",
+      "resolved": "https://registry.npmjs.org/@oxc-project/runtime/-/runtime-0.115.0.tgz",
+      "integrity": "sha512-Rg8Wlt5dCbXhQnsXPrkOjL1DTSvXLgb2R/KYfnf1/K+R0k6UMLEmbQXPM+kwrWqSmWA2t0B1EtHy2/3zikQpvQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@oxc-project/types": {
+      "version": "0.115.0",
+      "resolved": "https://registry.npmjs.org/@oxc-project/types/-/types-0.115.0.tgz",
+      "integrity": "sha512-4n91DKnebUS4yjUHl2g3/b2T+IUdCfmoZGhmwsovZCDaJSs+QkVAM+0AqqTxHSsHfeiMuueT75cZaZcT/m0pSw==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/Boshen"
+      }
+    },
+    "node_modules/@rolldown/binding-android-arm64": {
+      "version": "1.0.0-rc.9",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-android-arm64/-/binding-android-arm64-1.0.0-rc.9.tgz",
+      "integrity": "sha512-lcJL0bN5hpgJfSIz/8PIf02irmyL43P+j1pTCfbD1DbLkmGRuFIA4DD3B3ZOvGqG0XiVvRznbKtN0COQVaKUTg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-darwin-arm64": {
+      "version": "1.0.0-rc.9",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-arm64/-/binding-darwin-arm64-1.0.0-rc.9.tgz",
+      "integrity": "sha512-J7Zk3kLYFsLtuH6U+F4pS2sYVzac0qkjcO5QxHS7OS7yZu2LRs+IXo+uvJ/mvpyUljDJ3LROZPoQfgBIpCMhdQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-darwin-x64": {
+      "version": "1.0.0-rc.9",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-x64/-/binding-darwin-x64-1.0.0-rc.9.tgz",
+      "integrity": "sha512-iwtmmghy8nhfRGeNAIltcNXzD0QMNaaA5U/NyZc1Ia4bxrzFByNMDoppoC+hl7cDiUq5/1CnFthpT9n+UtfFyg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-freebsd-x64": {
+      "version": "1.0.0-rc.9",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-freebsd-x64/-/binding-freebsd-x64-1.0.0-rc.9.tgz",
+      "integrity": "sha512-DLFYI78SCiZr5VvdEplsVC2Vx53lnA4/Ga5C65iyldMVaErr86aiqCoNBLl92PXPfDtUYjUh+xFFor40ueNs4Q==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-linux-arm-gnueabihf": {
+      "version": "1.0.0-rc.9",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm-gnueabihf/-/binding-linux-arm-gnueabihf-1.0.0-rc.9.tgz",
+      "integrity": "sha512-CsjTmTwd0Hri6iTw/DRMK7kOZ7FwAkrO4h8YWKoX/kcj833e4coqo2wzIFywtch/8Eb5enQ/lwLM7w6JX1W5RQ==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-linux-arm64-gnu": {
+      "version": "1.0.0-rc.9",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-gnu/-/binding-linux-arm64-gnu-1.0.0-rc.9.tgz",
+      "integrity": "sha512-2x9O2JbSPxpxMDhP9Z74mahAStibTlrBMW0520+epJH5sac7/LwZW5Bmg/E6CXuEF53JJFW509uP+lSedaUNxg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-linux-arm64-musl": {
+      "version": "1.0.0-rc.9",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-musl/-/binding-linux-arm64-musl-1.0.0-rc.9.tgz",
+      "integrity": "sha512-JA1QRW31ogheAIRhIg9tjMfsYbglXXYGNPLdPEYrwFxdbkQCAzvpSCSHCDWNl4hTtrol8WeboCSEpjdZK8qrCg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-linux-ppc64-gnu": {
+      "version": "1.0.0-rc.9",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-ppc64-gnu/-/binding-linux-ppc64-gnu-1.0.0-rc.9.tgz",
+      "integrity": "sha512-aOKU9dJheda8Kj8Y3w9gnt9QFOO+qKPAl8SWd7JPHP+Cu0EuDAE5wokQubLzIDQWg2myXq2XhTpOVS07qqvT+w==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-linux-s390x-gnu": {
+      "version": "1.0.0-rc.9",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-s390x-gnu/-/binding-linux-s390x-gnu-1.0.0-rc.9.tgz",
+      "integrity": "sha512-OalO94fqj7IWRn3VdXWty75jC5dk4C197AWEuMhIpvVv2lw9fiPhud0+bW2ctCxb3YoBZor71QHbY+9/WToadA==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-linux-x64-gnu": {
+      "version": "1.0.0-rc.9",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-gnu/-/binding-linux-x64-gnu-1.0.0-rc.9.tgz",
+      "integrity": "sha512-cVEl1vZtBsBZna3YMjGXNvnYYrOJ7RzuWvZU0ffvJUexWkukMaDuGhUXn0rjnV0ptzGVkvc+vW9Yqy6h8YX4pg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-linux-x64-musl": {
+      "version": "1.0.0-rc.9",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-musl/-/binding-linux-x64-musl-1.0.0-rc.9.tgz",
+      "integrity": "sha512-UzYnKCIIc4heAKgI4PZ3dfBGUZefGCJ1TPDuLHoCzgrMYPb5Rv6TLFuYtyM4rWyHM7hymNdsg5ik2C+UD9VDbA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-openharmony-arm64": {
+      "version": "1.0.0-rc.9",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-openharmony-arm64/-/binding-openharmony-arm64-1.0.0-rc.9.tgz",
+      "integrity": "sha512-+6zoiF+RRyf5cdlFQP7nm58mq7+/2PFaY2DNQeD4B87N36JzfF/l9mdBkkmTvSYcYPE8tMh/o3cRlsx1ldLfog==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-wasm32-wasi": {
+      "version": "1.0.0-rc.9",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-wasm32-wasi/-/binding-wasm32-wasi-1.0.0-rc.9.tgz",
+      "integrity": "sha512-rgFN6sA/dyebil3YTlL2evvi/M+ivhfnyxec7AccTpRPccno/rPoNlqybEZQBkcbZu8Hy+eqNJCqfBR8P7Pg8g==",
+      "cpu": [
+        "wasm32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@napi-rs/wasm-runtime": "^1.1.1"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
+    "node_modules/@rolldown/binding-win32-arm64-msvc": {
+      "version": "1.0.0-rc.9",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-arm64-msvc/-/binding-win32-arm64-msvc-1.0.0-rc.9.tgz",
+      "integrity": "sha512-lHVNUG/8nlF1IQk1C0Ci574qKYyty2goMiPlRqkC5R+3LkXDkL5Dhx8ytbxq35m+pkHVIvIxviD+TWLdfeuadA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-win32-x64-msvc": {
+      "version": "1.0.0-rc.9",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-x64-msvc/-/binding-win32-x64-msvc-1.0.0-rc.9.tgz",
+      "integrity": "sha512-G0oA4+w1iY5AGi5HcDTxWsoxF509hrFIPB2rduV5aDqS9FtDg1CAfa7V34qImbjfhIcA8C+RekocJZA96EarwQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/pluginutils": {
+      "version": "1.0.0-rc.7",
+      "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-rc.7.tgz",
+      "integrity": "sha512-qujRfC8sFVInYSPPMLQByRh7zhwkGFS4+tyMQ83srV1qrxL4g8E2tyxVVyxd0+8QeBM1mIk9KbWxkegRr76XzA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@tybys/wasm-util": {
+      "version": "0.10.1",
+      "resolved": "https://registry.npmjs.org/@tybys/wasm-util/-/wasm-util-0.10.1.tgz",
+      "integrity": "sha512-9tTaPJLSiejZKx+Bmog4uSubteqTvFrVrURwkmHixBo0G4seD0zUxp98E1DzUBJxLQ3NPwXrGKDiVjwx/DpPsg==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@types/estree": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
+      "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/json-schema": {
+      "version": "7.0.15",
+      "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz",
+      "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/react": {
+      "version": "19.2.14",
+      "resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.14.tgz",
+      "integrity": "sha512-ilcTH/UniCkMdtexkoCN0bI7pMcJDvmQFPvuPvmEaYA/NSfFTAgdUSLAoVjaRJm7+6PvcM+q1zYOwS4wTYMF9w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "csstype": "^3.2.2"
+      }
+    },
+    "node_modules/@types/react-dom": {
+      "version": "19.2.3",
+      "resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-19.2.3.tgz",
+      "integrity": "sha512-jp2L/eY6fn+KgVVQAOqYItbF0VY/YApe5Mz2F0aykSO8gx31bYCZyvSeYxCHKvzHG5eZjc+zyaS5BrBWya2+kQ==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "@types/react": "^19.2.0"
+      }
+    },
+    "node_modules/@vitejs/plugin-react": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-6.0.0.tgz",
+      "integrity": "sha512-Bu5/eP6td3WI654+tRq+ryW1PbgA90y5pqMKpb3U7UpNk6VjI53P/ncPUd192U9dSrepLy7DHnq1XEMDz5H++w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@rolldown/pluginutils": "1.0.0-rc.7"
+      },
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      },
+      "peerDependencies": {
+        "@rolldown/plugin-babel": "^0.1.7",
+        "babel-plugin-react-compiler": "^1.0.0",
+        "vite": "^8.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@rolldown/plugin-babel": {
+          "optional": true
+        },
+        "babel-plugin-react-compiler": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/acorn": {
+      "version": "8.16.0",
+      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.16.0.tgz",
+      "integrity": "sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "acorn": "bin/acorn"
+      },
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/acorn-jsx": {
+      "version": "5.3.2",
+      "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz",
+      "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0"
+      }
+    },
+    "node_modules/ajv": {
+      "version": "6.14.0",
+      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.14.0.tgz",
+      "integrity": "sha512-IWrosm/yrn43eiKqkfkHis7QioDleaXQHdDVPKg0FSwwd/DuvyX79TZnFOnYpB7dcsFAMmtFztZuXPDvSePkFw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fast-deep-equal": "^3.1.1",
+        "fast-json-stable-stringify": "^2.0.0",
+        "json-schema-traverse": "^0.4.1",
+        "uri-js": "^4.2.2"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/epoberezkin"
+      }
+    },
+    "node_modules/ansi-styles": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "color-convert": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/argparse": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
+      "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
+      "dev": true,
+      "license": "Python-2.0"
+    },
+    "node_modules/balanced-match": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/baseline-browser-mapping": {
+      "version": "2.10.7",
+      "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.10.7.tgz",
+      "integrity": "sha512-1ghYO3HnxGec0TCGBXiDLVns4eCSx4zJpxnHrlqFQajmhfKMQBzUGDdkMK7fUW7PTHTeLf+j87aTuKuuwWzMGw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "baseline-browser-mapping": "dist/cli.cjs"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/brace-expansion": {
+      "version": "1.1.12",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
+      "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "node_modules/browserslist": {
+      "version": "4.28.1",
+      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.28.1.tgz",
+      "integrity": "sha512-ZC5Bd0LgJXgwGqUknZY/vkUQ04r8NXnJZ3yYi4vDmSiZmC/pdSN0NbNRPxZpbtO4uAfDUAFffO8IZoM3Gj8IkA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "baseline-browser-mapping": "^2.9.0",
+        "caniuse-lite": "^1.0.30001759",
+        "electron-to-chromium": "^1.5.263",
+        "node-releases": "^2.0.27",
+        "update-browserslist-db": "^1.2.0"
+      },
+      "bin": {
+        "browserslist": "cli.js"
+      },
+      "engines": {
+        "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
+      }
+    },
+    "node_modules/callsites": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
+      "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/caniuse-lite": {
+      "version": "1.0.30001778",
+      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001778.tgz",
+      "integrity": "sha512-PN7uxFL+ExFJO61aVmP1aIEG4i9whQd4eoSCebav62UwDyp5OHh06zN4jqKSMePVgxHifCw1QJxdRkA1Pisekg==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/caniuse-lite"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "CC-BY-4.0"
+    },
+    "node_modules/chalk": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
+      "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.1.0",
+        "supports-color": "^7.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/chalk?sponsor=1"
+      }
+    },
+    "node_modules/color-convert": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
+      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "color-name": "~1.1.4"
+      },
+      "engines": {
+        "node": ">=7.0.0"
+      }
+    },
+    "node_modules/color-name": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
+      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/concat-map": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
+      "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/convert-source-map": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz",
+      "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/cross-spawn": {
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
+      "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "path-key": "^3.1.0",
+        "shebang-command": "^2.0.0",
+        "which": "^2.0.1"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/csstype": {
+      "version": "3.2.3",
+      "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz",
+      "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/debug": {
+      "version": "4.4.3",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
+      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/deep-is": {
+      "version": "0.1.4",
+      "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz",
+      "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/detect-libc": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz",
+      "integrity": "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/electron-to-chromium": {
+      "version": "1.5.313",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.313.tgz",
+      "integrity": "sha512-QBMrTWEf00GXZmJyx2lbYD45jpI3TUFnNIzJ5BBc8piGUDwMPa1GV6HJWTZVvY/eiN3fSopl7NRbgGp9sZ9LTA==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/escalade": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/escape-string-regexp": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
+      "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/eslint": {
+      "version": "9.39.4",
+      "resolved": "https://registry.npmjs.org/eslint/-/eslint-9.39.4.tgz",
+      "integrity": "sha512-XoMjdBOwe/esVgEvLmNsD3IRHkm7fbKIUGvrleloJXUZgDHig2IPWNniv+GwjyJXzuNqVjlr5+4yVUZjycJwfQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@eslint-community/eslint-utils": "^4.8.0",
+        "@eslint-community/regexpp": "^4.12.1",
+        "@eslint/config-array": "^0.21.2",
+        "@eslint/config-helpers": "^0.4.2",
+        "@eslint/core": "^0.17.0",
+        "@eslint/eslintrc": "^3.3.5",
+        "@eslint/js": "9.39.4",
+        "@eslint/plugin-kit": "^0.4.1",
+        "@humanfs/node": "^0.16.6",
+        "@humanwhocodes/module-importer": "^1.0.1",
+        "@humanwhocodes/retry": "^0.4.2",
+        "@types/estree": "^1.0.6",
+        "ajv": "^6.14.0",
+        "chalk": "^4.0.0",
+        "cross-spawn": "^7.0.6",
+        "debug": "^4.3.2",
+        "escape-string-regexp": "^4.0.0",
+        "eslint-scope": "^8.4.0",
+        "eslint-visitor-keys": "^4.2.1",
+        "espree": "^10.4.0",
+        "esquery": "^1.5.0",
+        "esutils": "^2.0.2",
+        "fast-deep-equal": "^3.1.3",
+        "file-entry-cache": "^8.0.0",
+        "find-up": "^5.0.0",
+        "glob-parent": "^6.0.2",
+        "ignore": "^5.2.0",
+        "imurmurhash": "^0.1.4",
+        "is-glob": "^4.0.0",
+        "json-stable-stringify-without-jsonify": "^1.0.1",
+        "lodash.merge": "^4.6.2",
+        "minimatch": "^3.1.5",
+        "natural-compare": "^1.4.0",
+        "optionator": "^0.9.3"
+      },
+      "bin": {
+        "eslint": "bin/eslint.js"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://eslint.org/donate"
+      },
+      "peerDependencies": {
+        "jiti": "*"
+      },
+      "peerDependenciesMeta": {
+        "jiti": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/eslint-plugin-react-hooks": {
+      "version": "7.0.1",
+      "resolved": "https://registry.npmjs.org/eslint-plugin-react-hooks/-/eslint-plugin-react-hooks-7.0.1.tgz",
+      "integrity": "sha512-O0d0m04evaNzEPoSW+59Mezf8Qt0InfgGIBJnpC0h3NH/WjUAR7BIKUfysC6todmtiZ/A0oUVS8Gce0WhBrHsA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/core": "^7.24.4",
+        "@babel/parser": "^7.24.4",
+        "hermes-parser": "^0.25.1",
+        "zod": "^3.25.0 || ^4.0.0",
+        "zod-validation-error": "^3.5.0 || ^4.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "eslint": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-0 || ^9.0.0"
+      }
+    },
+    "node_modules/eslint-plugin-react-refresh": {
+      "version": "0.5.2",
+      "resolved": "https://registry.npmjs.org/eslint-plugin-react-refresh/-/eslint-plugin-react-refresh-0.5.2.tgz",
+      "integrity": "sha512-hmgTH57GfzoTFjVN0yBwTggnsVUF2tcqi7RJZHqi9lIezSs4eFyAMktA68YD4r5kNw1mxyY4dmkyoFDb3FIqrA==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "eslint": "^9 || ^10"
+      }
+    },
+    "node_modules/eslint-scope": {
+      "version": "8.4.0",
+      "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-8.4.0.tgz",
+      "integrity": "sha512-sNXOfKCn74rt8RICKMvJS7XKV/Xk9kA7DyJr8mJik3S7Cwgy3qlkkmyS2uQB3jiJg6VNdZd/pDBJu0nvG2NlTg==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "esrecurse": "^4.3.0",
+        "estraverse": "^5.2.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/eslint-visitor-keys": {
+      "version": "4.2.1",
+      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-4.2.1.tgz",
+      "integrity": "sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/espree": {
+      "version": "10.4.0",
+      "resolved": "https://registry.npmjs.org/espree/-/espree-10.4.0.tgz",
+      "integrity": "sha512-j6PAQ2uUr79PZhBjP5C5fhl8e39FmRnOjsD5lGnWrFU8i2G776tBK7+nP8KuQUTTyAZUwfQqXAgrVH5MbH9CYQ==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "acorn": "^8.15.0",
+        "acorn-jsx": "^5.3.2",
+        "eslint-visitor-keys": "^4.2.1"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/esquery": {
+      "version": "1.7.0",
+      "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.7.0.tgz",
+      "integrity": "sha512-Ap6G0WQwcU/LHsvLwON1fAQX9Zp0A2Y6Y/cJBl9r/JbW90Zyg4/zbG6zzKa2OTALELarYHmKu0GhpM5EO+7T0g==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "estraverse": "^5.1.0"
+      },
+      "engines": {
+        "node": ">=0.10"
+      }
+    },
+    "node_modules/esrecurse": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz",
+      "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "estraverse": "^5.2.0"
+      },
+      "engines": {
+        "node": ">=4.0"
+      }
+    },
+    "node_modules/estraverse": {
+      "version": "5.3.0",
+      "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz",
+      "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=4.0"
+      }
+    },
+    "node_modules/esutils": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
+      "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/fast-deep-equal": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
+      "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/fast-json-stable-stringify": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz",
+      "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/fast-levenshtein": {
+      "version": "2.0.6",
+      "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz",
+      "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/fdir": {
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+      "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "peerDependencies": {
+        "picomatch": "^3 || ^4"
+      },
+      "peerDependenciesMeta": {
+        "picomatch": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/file-entry-cache": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-8.0.0.tgz",
+      "integrity": "sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "flat-cache": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=16.0.0"
+      }
+    },
+    "node_modules/find-up": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz",
+      "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "locate-path": "^6.0.0",
+        "path-exists": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/flat-cache": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-4.0.1.tgz",
+      "integrity": "sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "flatted": "^3.2.9",
+        "keyv": "^4.5.4"
+      },
+      "engines": {
+        "node": ">=16"
+      }
+    },
+    "node_modules/flatted": {
+      "version": "3.4.1",
+      "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.4.1.tgz",
+      "integrity": "sha512-IxfVbRFVlV8V/yRaGzk0UVIcsKKHMSfYw66T/u4nTwlWteQePsxe//LjudR1AMX4tZW3WFCh3Zqa/sjlqpbURQ==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/gensync": {
+      "version": "1.0.0-beta.2",
+      "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz",
+      "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/glob-parent": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz",
+      "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "is-glob": "^4.0.3"
+      },
+      "engines": {
+        "node": ">=10.13.0"
+      }
+    },
+    "node_modules/globals": {
+      "version": "17.4.0",
+      "resolved": "https://registry.npmjs.org/globals/-/globals-17.4.0.tgz",
+      "integrity": "sha512-hjrNztw/VajQwOLsMNT1cbJiH2muO3OROCHnbehc8eY5JyD2gqz4AcMHPqgaOR59DjgUjYAYLeH699g/eWi2jw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/has-flag": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
+      "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/hermes-estree": {
+      "version": "0.25.1",
+      "resolved": "https://registry.npmjs.org/hermes-estree/-/hermes-estree-0.25.1.tgz",
+      "integrity": "sha512-0wUoCcLp+5Ev5pDW2OriHC2MJCbwLwuRx+gAqMTOkGKJJiBCLjtrvy4PWUGn6MIVefecRpzoOZ/UV6iGdOr+Cw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/hermes-parser": {
+      "version": "0.25.1",
+      "resolved": "https://registry.npmjs.org/hermes-parser/-/hermes-parser-0.25.1.tgz",
+      "integrity": "sha512-6pEjquH3rqaI6cYAXYPcz9MS4rY6R4ngRgrgfDshRptUZIc3lw0MCIJIGDj9++mfySOuPTHB4nrSW99BCvOPIA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "hermes-estree": "0.25.1"
+      }
+    },
+    "node_modules/ignore": {
+      "version": "5.3.2",
+      "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
+      "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 4"
+      }
+    },
+    "node_modules/import-fresh": {
+      "version": "3.3.1",
+      "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz",
+      "integrity": "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "parent-module": "^1.0.0",
+        "resolve-from": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/imurmurhash": {
+      "version": "0.1.4",
+      "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz",
+      "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.8.19"
+      }
+    },
+    "node_modules/is-extglob": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
+      "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-glob": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
+      "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "is-extglob": "^2.1.1"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/isexe": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
+      "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/js-tokens": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
+      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/js-yaml": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz",
+      "integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "argparse": "^2.0.1"
+      },
+      "bin": {
+        "js-yaml": "bin/js-yaml.js"
+      }
+    },
+    "node_modules/jsesc": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz",
+      "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "jsesc": "bin/jsesc"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/json-buffer": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz",
+      "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/json-schema-traverse": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
+      "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/json-stable-stringify-without-jsonify": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz",
+      "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/json5": {
+      "version": "2.2.3",
+      "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz",
+      "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "json5": "lib/cli.js"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/keyv": {
+      "version": "4.5.4",
+      "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz",
+      "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "json-buffer": "3.0.1"
+      }
+    },
+    "node_modules/levn": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz",
+      "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "prelude-ls": "^1.2.1",
+        "type-check": "~0.4.0"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/lightningcss": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss/-/lightningcss-1.32.0.tgz",
+      "integrity": "sha512-NXYBzinNrblfraPGyrbPoD19C1h9lfI/1mzgWYvXUTe414Gz/X1FD2XBZSZM7rRTrMA8JL3OtAaGifrIKhQ5yQ==",
+      "dev": true,
+      "license": "MPL-2.0",
+      "dependencies": {
+        "detect-libc": "^2.0.3"
+      },
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      },
+      "optionalDependencies": {
+        "lightningcss-android-arm64": "1.32.0",
+        "lightningcss-darwin-arm64": "1.32.0",
+        "lightningcss-darwin-x64": "1.32.0",
+        "lightningcss-freebsd-x64": "1.32.0",
+        "lightningcss-linux-arm-gnueabihf": "1.32.0",
+        "lightningcss-linux-arm64-gnu": "1.32.0",
+        "lightningcss-linux-arm64-musl": "1.32.0",
+        "lightningcss-linux-x64-gnu": "1.32.0",
+        "lightningcss-linux-x64-musl": "1.32.0",
+        "lightningcss-win32-arm64-msvc": "1.32.0",
+        "lightningcss-win32-x64-msvc": "1.32.0"
+      }
+    },
+    "node_modules/lightningcss-android-arm64": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-android-arm64/-/lightningcss-android-arm64-1.32.0.tgz",
+      "integrity": "sha512-YK7/ClTt4kAK0vo6w3X+Pnm0D2cf2vPHbhOXdoNti1Ga0al1P4TBZhwjATvjNwLEBCnKvjJc2jQgHXH0NEwlAg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-darwin-arm64": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-darwin-arm64/-/lightningcss-darwin-arm64-1.32.0.tgz",
+      "integrity": "sha512-RzeG9Ju5bag2Bv1/lwlVJvBE3q6TtXskdZLLCyfg5pt+HLz9BqlICO7LZM7VHNTTn/5PRhHFBSjk5lc4cmscPQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-darwin-x64": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-darwin-x64/-/lightningcss-darwin-x64-1.32.0.tgz",
+      "integrity": "sha512-U+QsBp2m/s2wqpUYT/6wnlagdZbtZdndSmut/NJqlCcMLTWp5muCrID+K5UJ6jqD2BFshejCYXniPDbNh73V8w==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-freebsd-x64": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-freebsd-x64/-/lightningcss-freebsd-x64-1.32.0.tgz",
+      "integrity": "sha512-JCTigedEksZk3tHTTthnMdVfGf61Fky8Ji2E4YjUTEQX14xiy/lTzXnu1vwiZe3bYe0q+SpsSH/CTeDXK6WHig==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-linux-arm-gnueabihf": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-arm-gnueabihf/-/lightningcss-linux-arm-gnueabihf-1.32.0.tgz",
+      "integrity": "sha512-x6rnnpRa2GL0zQOkt6rts3YDPzduLpWvwAF6EMhXFVZXD4tPrBkEFqzGowzCsIWsPjqSK+tyNEODUBXeeVHSkw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-linux-arm64-gnu": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-gnu/-/lightningcss-linux-arm64-gnu-1.32.0.tgz",
+      "integrity": "sha512-0nnMyoyOLRJXfbMOilaSRcLH3Jw5z9HDNGfT/gwCPgaDjnx0i8w7vBzFLFR1f6CMLKF8gVbebmkUN3fa/kQJpQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-linux-arm64-musl": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-musl/-/lightningcss-linux-arm64-musl-1.32.0.tgz",
+      "integrity": "sha512-UpQkoenr4UJEzgVIYpI80lDFvRmPVg6oqboNHfoH4CQIfNA+HOrZ7Mo7KZP02dC6LjghPQJeBsvXhJod/wnIBg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-linux-x64-gnu": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-gnu/-/lightningcss-linux-x64-gnu-1.32.0.tgz",
+      "integrity": "sha512-V7Qr52IhZmdKPVr+Vtw8o+WLsQJYCTd8loIfpDaMRWGUZfBOYEJeyJIkqGIDMZPwPx24pUMfwSxxI8phr/MbOA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-linux-x64-musl": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-musl/-/lightningcss-linux-x64-musl-1.32.0.tgz",
+      "integrity": "sha512-bYcLp+Vb0awsiXg/80uCRezCYHNg1/l3mt0gzHnWV9XP1W5sKa5/TCdGWaR/zBM2PeF/HbsQv/j2URNOiVuxWg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-win32-arm64-msvc": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-win32-arm64-msvc/-/lightningcss-win32-arm64-msvc-1.32.0.tgz",
+      "integrity": "sha512-8SbC8BR40pS6baCM8sbtYDSwEVQd4JlFTOlaD3gWGHfThTcABnNDBda6eTZeqbofalIJhFx0qKzgHJmcPTnGdw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-win32-x64-msvc": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-win32-x64-msvc/-/lightningcss-win32-x64-msvc-1.32.0.tgz",
+      "integrity": "sha512-Amq9B/SoZYdDi1kFrojnoqPLxYhQ4Wo5XiL8EVJrVsB8ARoC1PWW6VGtT0WKCemjy8aC+louJnjS7U18x3b06Q==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/locate-path": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz",
+      "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "p-locate": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/lodash.merge": {
+      "version": "4.6.2",
+      "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz",
+      "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/lru-cache": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz",
+      "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "yallist": "^3.0.2"
+      }
+    },
+    "node_modules/minimatch": {
+      "version": "3.1.5",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz",
+      "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/nanoid": {
+      "version": "3.3.11",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz",
+      "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "bin": {
+        "nanoid": "bin/nanoid.cjs"
+      },
+      "engines": {
+        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+      }
+    },
+    "node_modules/natural-compare": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz",
+      "integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/node-releases": {
+      "version": "2.0.36",
+      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.36.tgz",
+      "integrity": "sha512-TdC8FSgHz8Mwtw9g5L4gR/Sh9XhSP/0DEkQxfEFXOpiul5IiHgHan2VhYYb6agDSfp4KuvltmGApc8HMgUrIkA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/optionator": {
+      "version": "0.9.4",
+      "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz",
+      "integrity": "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "deep-is": "^0.1.3",
+        "fast-levenshtein": "^2.0.6",
+        "levn": "^0.4.1",
+        "prelude-ls": "^1.2.1",
+        "type-check": "^0.4.0",
+        "word-wrap": "^1.2.5"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/p-limit": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz",
+      "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "yocto-queue": "^0.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/p-locate": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz",
+      "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "p-limit": "^3.0.2"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/parent-module": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz",
+      "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "callsites": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/path-exists": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
+      "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/path-key": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
+      "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/picocolors": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/picomatch": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
+      "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/postcss": {
+      "version": "8.5.8",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.8.tgz",
+      "integrity": "sha512-OW/rX8O/jXnm82Ey1k44pObPtdblfiuWnrd8X7GJ7emImCOstunGbXUpp7HdBrFQX6rJzn3sPT397Wp5aCwCHg==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/postcss"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "nanoid": "^3.3.11",
+        "picocolors": "^1.1.1",
+        "source-map-js": "^1.2.1"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      }
+    },
+    "node_modules/prelude-ls": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz",
+      "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/punycode": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
+      "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/react": {
+      "version": "19.2.4",
+      "resolved": "https://registry.npmjs.org/react/-/react-19.2.4.tgz",
+      "integrity": "sha512-9nfp2hYpCwOjAN+8TZFGhtWEwgvWHXqESH8qT89AT/lWklpLON22Lc8pEtnpsZz7VmawabSU0gCjnj8aC0euHQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/react-dom": {
+      "version": "19.2.4",
+      "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.2.4.tgz",
+      "integrity": "sha512-AXJdLo8kgMbimY95O2aKQqsz2iWi9jMgKJhRBAxECE4IFxfcazB2LmzloIoibJI3C12IlY20+KFaLv+71bUJeQ==",
+      "license": "MIT",
+      "dependencies": {
+        "scheduler": "^0.27.0"
+      },
+      "peerDependencies": {
+        "react": "^19.2.4"
+      }
+    },
+    "node_modules/resolve-from": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz",
+      "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/rolldown": {
+      "version": "1.0.0-rc.9",
+      "resolved": "https://registry.npmjs.org/rolldown/-/rolldown-1.0.0-rc.9.tgz",
+      "integrity": "sha512-9EbgWge7ZH+yqb4d2EnELAntgPTWbfL8ajiTW+SyhJEC4qhBbkCKbqFV4Ge4zmu5ziQuVbWxb/XwLZ+RIO7E8Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@oxc-project/types": "=0.115.0",
+        "@rolldown/pluginutils": "1.0.0-rc.9"
+      },
+      "bin": {
+        "rolldown": "bin/cli.mjs"
+      },
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      },
+      "optionalDependencies": {
+        "@rolldown/binding-android-arm64": "1.0.0-rc.9",
+        "@rolldown/binding-darwin-arm64": "1.0.0-rc.9",
+        "@rolldown/binding-darwin-x64": "1.0.0-rc.9",
+        "@rolldown/binding-freebsd-x64": "1.0.0-rc.9",
+        "@rolldown/binding-linux-arm-gnueabihf": "1.0.0-rc.9",
+        "@rolldown/binding-linux-arm64-gnu": "1.0.0-rc.9",
+        "@rolldown/binding-linux-arm64-musl": "1.0.0-rc.9",
+        "@rolldown/binding-linux-ppc64-gnu": "1.0.0-rc.9",
+        "@rolldown/binding-linux-s390x-gnu": "1.0.0-rc.9",
+        "@rolldown/binding-linux-x64-gnu": "1.0.0-rc.9",
+        "@rolldown/binding-linux-x64-musl": "1.0.0-rc.9",
+        "@rolldown/binding-openharmony-arm64": "1.0.0-rc.9",
+        "@rolldown/binding-wasm32-wasi": "1.0.0-rc.9",
+        "@rolldown/binding-win32-arm64-msvc": "1.0.0-rc.9",
+        "@rolldown/binding-win32-x64-msvc": "1.0.0-rc.9"
+      }
+    },
+    "node_modules/rolldown/node_modules/@rolldown/pluginutils": {
+      "version": "1.0.0-rc.9",
+      "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-rc.9.tgz",
+      "integrity": "sha512-w6oiRWgEBl04QkFZgmW+jnU1EC9b57Oihi2ot3HNWIQRqgHp5PnYDia5iZ5FF7rpa4EQdiqMDXjlqKGXBhsoXw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/scheduler": {
+      "version": "0.27.0",
+      "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.27.0.tgz",
+      "integrity": "sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q==",
+      "license": "MIT"
+    },
+    "node_modules/semver": {
+      "version": "6.3.1",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
+      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
+      "dev": true,
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      }
+    },
+    "node_modules/shebang-command": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
+      "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "shebang-regex": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/shebang-regex": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
+      "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/source-map-js": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/strip-json-comments": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz",
+      "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/supports-color": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
+      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "has-flag": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/tinyglobby": {
+      "version": "0.2.15",
+      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz",
+      "integrity": "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fdir": "^6.5.0",
+        "picomatch": "^4.0.3"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/SuperchupuDev"
+      }
+    },
+    "node_modules/tslib": {
+      "version": "2.8.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+      "dev": true,
+      "license": "0BSD",
+      "optional": true
+    },
+    "node_modules/type-check": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz",
+      "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "prelude-ls": "^1.2.1"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/update-browserslist-db": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.2.3.tgz",
+      "integrity": "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "escalade": "^3.2.0",
+        "picocolors": "^1.1.1"
+      },
+      "bin": {
+        "update-browserslist-db": "cli.js"
+      },
+      "peerDependencies": {
+        "browserslist": ">= 4.21.0"
+      }
+    },
+    "node_modules/uri-js": {
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz",
+      "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "punycode": "^2.1.0"
+      }
+    },
+    "node_modules/vite": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-8.0.0.tgz",
+      "integrity": "sha512-fPGaRNj9Zytaf8LEiBhY7Z6ijnFKdzU/+mL8EFBaKr7Vw1/FWcTBAMW0wLPJAGMPX38ZPVCVgLceWiEqeoqL2Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@oxc-project/runtime": "0.115.0",
+        "lightningcss": "^1.32.0",
+        "picomatch": "^4.0.3",
+        "postcss": "^8.5.8",
+        "rolldown": "1.0.0-rc.9",
+        "tinyglobby": "^0.2.15"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
+      },
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "peerDependencies": {
+        "@types/node": "^20.19.0 || >=22.12.0",
+        "@vitejs/devtools": "^0.0.0-alpha.31",
+        "esbuild": "^0.27.0",
+        "jiti": ">=1.21.0",
+        "less": "^4.0.0",
+        "sass": "^1.70.0",
+        "sass-embedded": "^1.70.0",
+        "stylus": ">=0.54.8",
+        "sugarss": "^5.0.0",
+        "terser": "^5.16.0",
+        "tsx": "^4.8.1",
+        "yaml": "^2.4.2"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "@vitejs/devtools": {
+          "optional": true
+        },
+        "esbuild": {
+          "optional": true
+        },
+        "jiti": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "sass-embedded": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        },
+        "tsx": {
+          "optional": true
+        },
+        "yaml": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/which": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
+      "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "isexe": "^2.0.0"
+      },
+      "bin": {
+        "node-which": "bin/node-which"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/word-wrap": {
+      "version": "1.2.5",
+      "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz",
+      "integrity": "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/yallist": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz",
+      "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/yocto-queue": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz",
+      "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/zod": {
+      "version": "4.3.6",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-4.3.6.tgz",
+      "integrity": "sha512-rftlrkhHZOcjDwkGlnUtZZkvaPHCsDATp4pGpuOOMDaTdDDXF91wuVDJoWoPsKX/3YPQ5fHuF3STjcYyKr+Qhg==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    },
+    "node_modules/zod-validation-error": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/zod-validation-error/-/zod-validation-error-4.0.2.tgz",
+      "integrity": "sha512-Q6/nZLe6jxuU80qb/4uJ4t5v2VEZ44lzQjPDhYJNztRQ4wyWc6VF3D3Kb/fAuPetZQnhS3hnajCf9CsWesghLQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18.0.0"
+      },
+      "peerDependencies": {
+        "zod": "^3.25.0 || ^4.0.0"
+      }
+    }
+  }
+}

frontend/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "frontend",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "lint": "eslint .",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.4",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "@vitejs/plugin-react": "^6.0.0",
+    "eslint": "^9.39.4",
+    "eslint-plugin-react-hooks": "^7.0.1",
+    "eslint-plugin-react-refresh": "^0.5.2",
+    "globals": "^17.4.0",
+    "vite": "^8.0.0"
+  }
+}

frontend/src/App.css

@@ -0,0 +1,184 @@
+.counter {
+  font-size: 16px;
+  padding: 5px 10px;
+  border-radius: 5px;
+  color: var(--accent);
+  background: var(--accent-bg);
+  border: 2px solid transparent;
+  transition: border-color 0.3s;
+  margin-bottom: 24px;
+
+  &:hover {
+    border-color: var(--accent-border);
+  }
+  &:focus-visible {
+    outline: 2px solid var(--accent);
+    outline-offset: 2px;
+  }
+}
+
+.hero {
+  position: relative;
+
+  .base,
+  .framework,
+  .vite {
+    inset-inline: 0;
+    margin: 0 auto;
+  }
+
+  .base {
+    width: 170px;
+    position: relative;
+    z-index: 0;
+  }
+
+  .framework,
+  .vite {
+    position: absolute;
+  }
+
+  .framework {
+    z-index: 1;
+    top: 34px;
+    height: 28px;
+    transform: perspective(2000px) rotateZ(300deg) rotateX(44deg) rotateY(39deg)
+      scale(1.4);
+  }
+
+  .vite {
+    z-index: 0;
+    top: 107px;
+    height: 26px;
+    width: auto;
+    transform: perspective(2000px) rotateZ(300deg) rotateX(40deg) rotateY(39deg)
+      scale(0.8);
+  }
+}
+
+#center {
+  display: flex;
+  flex-direction: column;
+  gap: 25px;
+  place-content: center;
+  place-items: center;
+  flex-grow: 1;
+
+  @media (max-width: 1024px) {
+    padding: 32px 20px 24px;
+    gap: 18px;
+  }
+}
+
+#next-steps {
+  display: flex;
+  border-top: 1px solid var(--border);
+  text-align: left;
+
+  & > div {
+    flex: 1 1 0;
+    padding: 32px;
+    @media (max-width: 1024px) {
+      padding: 24px 20px;
+    }
+  }
+
+  .icon {
+    margin-bottom: 16px;
+    width: 22px;
+    height: 22px;
+  }
+
+  @media (max-width: 1024px) {
+    flex-direction: column;
+    text-align: center;
+  }
+}
+
+#docs {
+  border-right: 1px solid var(--border);
+
+  @media (max-width: 1024px) {
+    border-right: none;
+    border-bottom: 1px solid var(--border);
+  }
+}
+
+#next-steps ul {
+  list-style: none;
+  padding: 0;
+  display: flex;
+  gap: 8px;
+  margin: 32px 0 0;
+
+  .logo {
+    height: 18px;
+  }
+
+  a {
+    color: var(--text-h);
+    font-size: 16px;
+    border-radius: 6px;
+    background: var(--social-bg);
+    display: flex;
+    padding: 6px 12px;
+    align-items: center;
+    gap: 8px;
+    text-decoration: none;
+    transition: box-shadow 0.3s;
+
+    &:hover {
+      box-shadow: var(--shadow);
+    }
+    .button-icon {
+      height: 18px;
+      width: 18px;
+    }
+  }
+
+  @media (max-width: 1024px) {
+    margin-top: 20px;
+    flex-wrap: wrap;
+    justify-content: center;
+
+    li {
+      flex: 1 1 calc(50% - 8px);
+    }
+
+    a {
+      width: 100%;
+      justify-content: center;
+      box-sizing: border-box;
+    }
+  }
+}
+
+#spacer {
+  height: 88px;
+  border-top: 1px solid var(--border);
+  @media (max-width: 1024px) {
+    height: 48px;
+  }
+}
+
+.ticks {
+  position: relative;
+  width: 100%;
+
+  &::before,
+  &::after {
+    content: '';
+    position: absolute;
+    top: -4.5px;
+    border: 5px solid transparent;
+  }
+
+  &::before {
+    left: 0;
+    border-left-color: var(--border);
+  }
+  &::after {
+    right: 0;
+    border-right-color: var(--border);
+  }
+}

frontend/src/App.jsx

@@ -0,0 +1,406 @@
+import { useState, useCallback } from "react";
+
+const API = "http://localhost:8000";
+
+const CLASS_META = {
+  0: { name: "Background",        color: "#0a0a14", border: "#3a4a5a" },
+  1: { name: "Necrotic Core",     color: "#cc2200", border: "#ff5533" },
+  2: { name: "Peritumoral Edema", color: "#00aa44", border: "#00ee66" },
+  3: { name: "Enhancing Tumor",   color: "#ccaa00", border: "#ffdd00" },
+};
+
+const COLOR_MAP = {
+  0: [10,  10,  20],
+  1: [255, 50,  20],
+  2: [0,   220, 80],
+  3: [255, 220, 0],
+};
+
+const REGIONS = [
+  { key: "WT", label: "Whole Tumor",   desc: "Labels 1+2+3", color: "#4fa3e0" },
+  { key: "TC", label: "Tumor Core",    desc: "Labels 1+3",   color: "#ff5533" },
+  { key: "ET", label: "Enhancing",     desc: "Label 3",      color: "#ffdd00" },
+];
+
+// ── MRI grayscale canvas ──────────────────────────────────────────────────────
+function MRICanvas({ data, label }) {
+  const ref = useCallback((canvas) => {
+    if (!canvas || !data || data.length === 0) return;
+    const h = data.length, w = data[0].length;
+    canvas.width = w; canvas.height = h;
+    const ctx = canvas.getContext("2d");
+    const img = ctx.createImageData(w, h);
+    for (let y = 0; y < h; y++) {
+      for (let x = 0; x < w; x++) {
+        const v = data[y][x];
+        const i = (y * w + x) * 4;
+        img.data[i] = v; img.data[i+1] = v; img.data[i+2] = v; img.data[i+3] = 255;
+      }
+    }
+    ctx.putImageData(img, 0, 0);
+  }, [data]);
+
+  return (
+    <div style={{ display:"flex", flexDirection:"column", alignItems:"center", gap:6 }}>
+      <span style={{ fontSize:11, letterSpacing:"0.15em", color:"#7ab8d8", textTransform:"uppercase" }}>{label}</span>
+      <canvas ref={ref} style={{ width:160, height:160, imageRendering:"pixelated", border:"1px solid #1e3a50", borderRadius:4, background:"#000" }} />
+    </div>
+  );
+}
+
+// ── Segmentation color canvas ─────────────────────────────────────────────────
+function SegCanvas({ data, label }) {
+  const ref = useCallback((canvas) => {
+    if (!canvas || !data || data.length === 0) return;
+    const h = data.length, w = data[0].length;
+    canvas.width = w; canvas.height = h;
+    const ctx = canvas.getContext("2d");
+    const img = ctx.createImageData(w, h);
+    for (let y = 0; y < h; y++) {
+      for (let x = 0; x < w; x++) {
+        const val = data[y][x];
+        const [r, g, b] = COLOR_MAP[val] || [0,0,0];
+        const i = (y * w + x) * 4;
+        img.data[i] = r; img.data[i+1] = g; img.data[i+2] = b;
+        img.data[i+3] = val === 0 ? 40 : 230;
+      }
+    }
+    ctx.putImageData(img, 0, 0);
+  }, [data]);
+
+  return (
+    <div style={{ display:"flex", flexDirection:"column", alignItems:"center", gap:6 }}>
+      <span style={{ fontSize:11, letterSpacing:"0.15em", color:"#7ab8d8", textTransform:"uppercase" }}>{label}</span>
+      <canvas ref={ref} style={{ width:160, height:160, imageRendering:"pixelated", border:"1px solid #1e3a50", borderRadius:4, background:"#050810" }} />
+    </div>
+  );
+}
+
+// ── MRI + segmentation overlay canvas ────────────────────────────────────────
+function OverlayCanvas({ mriData, segData, label }) {
+  const ref = useCallback((canvas) => {
+    if (!canvas || !mriData || !segData || mriData.length === 0) return;
+    const h = mriData.length, w = mriData[0].length;
+    canvas.width = w; canvas.height = h;
+    const ctx = canvas.getContext("2d");
+    const img = ctx.createImageData(w, h);
+    for (let y = 0; y < h; y++) {
+      for (let x = 0; x < w; x++) {
+        const gray = mriData[y][x];
+        const seg  = segData[y][x];
+        const i    = (y * w + x) * 4;
+        if (seg === 0) {
+          img.data[i] = gray; img.data[i+1] = gray; img.data[i+2] = gray; img.data[i+3] = 255;
+        } else {
+          const [r, g, b] = COLOR_MAP[seg];
+          img.data[i]   = Math.round(gray * 0.45 + r * 0.55);
+          img.data[i+1] = Math.round(gray * 0.45 + g * 0.55);
+          img.data[i+2] = Math.round(gray * 0.45 + b * 0.55);
+          img.data[i+3] = 255;
+        }
+      }
+    }
+    ctx.putImageData(img, 0, 0);
+  }, [mriData, segData]);
+
+  return (
+    <div style={{ display:"flex", flexDirection:"column", alignItems:"center", gap:6 }}>
+      <span style={{ fontSize:11, letterSpacing:"0.15em", color:"#00ee66", textTransform:"uppercase" }}>{label}</span>
+      <canvas ref={ref} style={{ width:160, height:160, imageRendering:"pixelated", border:"1px solid #2a4a30", borderRadius:4, background:"#000" }} />
+    </div>
+  );
+}
+
+// ── File drop zone ────────────────────────────────────────────────────────────
+function DropZone({ label, file, onChange }) {
+  const [drag, setDrag] = useState(false);
+  return (
+    <label
+      onDragOver={e => { e.preventDefault(); setDrag(true); }}
+      onDragLeave={() => setDrag(false)}
+      onDrop={e => { e.preventDefault(); setDrag(false); onChange(e.dataTransfer.files[0]); }}
+      style={{
+        display:"flex", flexDirection:"column", alignItems:"center", justifyContent:"center",
+        border:`1px dashed ${drag ? "#4fa3e0" : file ? "#00ee66" : "#2a3a50"}`,
+        borderRadius:6, padding:"14px 10px", cursor:"pointer",
+        background: drag ? "rgba(79,163,224,0.07)" : file ? "rgba(0,238,102,0.05)" : "rgba(255,255,255,0.02)",
+        transition:"all 0.2s ease", minHeight:72,
+      }}
+    >
+      <input type="file" accept=".nii,.nii.gz" onChange={e => onChange(e.target.files[0])} style={{ display:"none" }} />
+      <div style={{ fontSize:12, letterSpacing:"0.12em", color:"#7ab8d8", marginBottom:4, fontWeight:500 }}>{label}</div>
+      {file
+        ? <div style={{ fontSize:11, color:"#00ee66", textAlign:"center", wordBreak:"break-all" }}>✓ {file.name}</div>
+        : <div style={{ fontSize:11, color:"#4a6070" }}>drop .nii file</div>
+      }
+    </label>
+  );
+}
+
+// ── Main App ──────────────────────────────────────────────────────────────────
+export default function App() {
+  const [files, setFiles]     = useState({ flair:null, t1:null, t1ce:null, t2:null });
+  const [result, setResult]   = useState(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError]     = useState(null);
+  const [plane, setPlane]     = useState("axial");
+
+  const allLoaded = Object.values(files).every(Boolean);
+
+  const runDemo = async () => {
+    setLoading(true); setError(null); setResult(null);
+    try {
+      const res = await fetch(`${API}/segment/demo`, { method:"POST" });
+      if (!res.ok) throw new Error(await res.text());
+      setResult(await res.json());
+    } catch(e) { setError(e.message); }
+    setLoading(false);
+  };
+
+  const runSegment = async () => {
+    setLoading(true); setError(null); setResult(null);
+    try {
+      const fd = new FormData();
+      fd.append("flair", files.flair);
+      fd.append("t1",    files.t1);
+      fd.append("t1ce",  files.t1ce);
+      fd.append("t2",    files.t2);
+      const res = await fetch(`${API}/segment`, { method:"POST", body:fd });
+      if (!res.ok) throw new Error(await res.text());
+      setResult(await res.json());
+    } catch(e) { setError(e.message); }
+    setLoading(false);
+  };
+
+  const classes   = result?.classes    || {};
+  const regions   = result?.regions    || {};
+  const slices    = result?.slices     || {};
+  const mriSlices = result?.mri_slices || {};
+
+  return (
+    <div style={{ minHeight:"100vh", background:"#030609", color:"#d0e4f0", fontFamily:"'IBM Plex Mono', monospace", display:"flex", flexDirection:"column" }}>
+      <style>{`@keyframes spin { to { transform: rotate(360deg); } }`}</style>
+
+      {/* ── Header ── */}
+      <header style={{ borderBottom:"1px solid #0f1e2e", padding:"16px 28px", display:"flex", alignItems:"center", justifyContent:"space-between", background:"rgba(5,8,16,0.8)" }}>
+        <div>
+          <div style={{ display:"flex", alignItems:"center", gap:10 }}>
+            <div style={{ width:8, height:8, borderRadius:"50%", background:"#4fa3e0", boxShadow:"0 0 12px #4fa3e0" }} />
+            <span style={{ fontSize:15, letterSpacing:"0.2em", color:"#6bbfe8", fontWeight:500 }}>BraTS</span>
+            <span style={{ color:"#2a3a50", fontSize:16 }}>·</span>
+            <span style={{ fontSize:14, letterSpacing:"0.15em", color:"#9abcd4" }}>3D U-NET SEGMENTATION</span>
+          </div>
+          <div style={{ fontSize:11, color:"#4a6070", marginTop:4, letterSpacing:"0.12em" }}>
+            BraTS2020 · PyTorch · FastAPI · React
+          </div>
+        </div>
+        <div style={{ fontSize:12, color:"#6a8a9a", fontFamily:"monospace" }}>
+          {result && !result.demo && `tumor burden: ${result["tumor_burden_%"]}%`}
+          {result?.demo && <span style={{ color:"#cc8833" }}>⚠ synthetic data</span>}
+        </div>
+      </header>
+
+      <main style={{ display:"flex", flex:1 }}>
+
+        {/* ── Left Panel ── */}
+        <div style={{ width:264, flexShrink:0, borderRight:"1px solid #0f1e2e", padding:"20px 16px", display:"flex", flexDirection:"column", gap:12, background:"rgba(4,7,14,0.6)" }}>
+          <div style={{ fontSize:11, letterSpacing:"0.2em", color:"#5a7a8a", marginBottom:2 }}>── INPUT MODALITIES</div>
+
+          {["flair","t1","t1ce","t2"].map(mod => (
+            <DropZone key={mod} label={mod.toUpperCase()} file={files[mod]}
+              onChange={f => setFiles(p => ({ ...p, [mod]:f }))} />
+          ))}
+
+          <button onClick={runSegment} disabled={!allLoaded || loading} style={{
+            padding:"12px", marginTop:4,
+            background: allLoaded && !loading ? "#0d2844" : "#090f1a",
+            border:`1px solid ${allLoaded && !loading ? "#4fa3e0" : "#1a2a3a"}`,
+            borderRadius:6, color: allLoaded && !loading ? "#7ac8f0" : "#2a3a50",
+            letterSpacing:"0.15em", fontSize:12, fontFamily:"'IBM Plex Mono', monospace",
+            cursor: allLoaded && !loading ? "pointer" : "not-allowed", transition:"all 0.2s", fontWeight:500,
+          }}>
+            {loading ? "PROCESSING..." : "RUN SEGMENTATION"}
+          </button>
+
+          <div style={{ display:"flex", alignItems:"center", gap:8 }}>
+            <div style={{ flex:1, height:1, background:"#0f1e2e" }} />
+            <span style={{ fontSize:11, color:"#2a3a50" }}>or</span>
+            <div style={{ flex:1, height:1, background:"#0f1e2e" }} />
+          </div>
+
+          <button onClick={runDemo} disabled={loading} style={{
+            padding:10, background:"transparent", border:"1px solid #1a2e40", borderRadius:6,
+            color:"#4a7090", letterSpacing:"0.12em", fontSize:11,
+            fontFamily:"'IBM Plex Mono', monospace",
+            cursor: loading ? "not-allowed" : "pointer", transition:"all 0.2s",
+          }}
+            onMouseOver={e => { e.currentTarget.style.color="#7ac8f0"; e.currentTarget.style.borderColor="#2a4a60"; }}
+            onMouseOut={e  => { e.currentTarget.style.color="#4a7090"; e.currentTarget.style.borderColor="#1a2e40"; }}
+          >
+            DEMO (SYNTHETIC)
+          </button>
+
+          {error && (
+            <div style={{ padding:10, background:"rgba(200,40,20,0.1)", border:"1px solid #4a1a10", borderRadius:6, fontSize:11, color:"#e06650", lineHeight:1.7 }}>
+              ⚠ {error}
+            </div>
+          )}
+
+          {/* Legend */}
+          <div style={{ marginTop:10 }}>
+            <div style={{ fontSize:11, letterSpacing:"0.2em", color:"#5a7a8a", marginBottom:10 }}>── LEGEND</div>
+            {Object.entries(CLASS_META).map(([id, c]) => (
+              <div key={id} style={{ display:"flex", alignItems:"center", gap:9, marginBottom:8 }}>
+                <div style={{ width:10, height:10, borderRadius:2, background:c.color, border:`1px solid ${c.border}`, flexShrink:0 }} />
+                <span style={{ fontSize:12, color:"#8aaabb" }}>{c.name}</span>
+              </div>
+            ))}
+          </div>
+        </div>
+
+        {/* ── Center Panel ── */}
+        <div style={{ flex:1, padding:"20px 24px", display:"flex", flexDirection:"column", gap:16, minWidth:0 }}>
+
+          {/* Empty state */}
+          {!result && !loading && (
+            <div style={{ flex:1, display:"flex", flexDirection:"column", alignItems:"center", justifyContent:"center", gap:16 }}>
+              <div style={{ width:80, height:80, borderRadius:"50%", border:"1px solid #1a3050", display:"flex", alignItems:"center", justifyContent:"center", background:"radial-gradient(circle, #0a1828 0%, #030609 100%)", boxShadow:"0 0 30px rgba(79,163,224,0.05)" }}>
+                <svg width="32" height="32" viewBox="0 0 24 24" fill="none" stroke="#2a5070" strokeWidth="1.2">
+                  <path d="M12 2a9 9 0 0 1 9 9c0 3.5-2 6.5-5 8.1V20H8v-.9C5 17.5 3 14.5 3 11a9 9 0 0 1 9-9z"/>
+                  <circle cx="12" cy="11" r="3"/>
+                </svg>
+              </div>
+              <div style={{ textAlign:"center" }}>
+                <div style={{ fontSize:14, color:"#5a8090", letterSpacing:"0.1em" }}>Upload 4 MRI modalities or run demo</div>
+                <div style={{ fontSize:12, color:"#3a5060", marginTop:6, letterSpacing:"0.08em" }}>FLAIR · T1 · T1ce · T2</div>
+              </div>
+            </div>
+          )}
+
+          {/* Loading */}
+          {loading && (
+            <div style={{ flex:1, display:"flex", flexDirection:"column", alignItems:"center", justifyContent:"center", gap:20 }}>
+              <div style={{ width:48, height:48, border:"2px solid #0f2030", borderTop:"2px solid #4fa3e0", borderRadius:"50%", animation:"spin 1s linear infinite" }} />
+              <div style={{ fontSize:13, color:"#4a7a90", letterSpacing:"0.2em" }}>RUNNING INFERENCE...</div>
+            </div>
+          )}
+
+          {/* Results */}
+          {result && !loading && (
+            <>
+              <div style={{ fontSize:11, letterSpacing:"0.2em", color:"#5a7a8a" }}>── SEGMENTATION OUTPUT</div>
+
+              {/* Plane selector */}
+              <div style={{ display:"flex", gap:1, background:"#0a1520", borderRadius:6, padding:3, width:"fit-content" }}>
+                {["axial","coronal","sagittal"].map(p => (
+                  <button key={p} onClick={() => setPlane(p)} style={{
+                    padding:"6px 16px",
+                    background: plane===p ? "#0d2844" : "transparent",
+                    border: plane===p ? "1px solid #2a5070" : "1px solid transparent",
+                    borderRadius:4, color: plane===p ? "#7ac8f0" : "#4a6a7a",
+                    fontSize:11, letterSpacing:"0.12em",
+                    fontFamily:"'IBM Plex Mono', monospace", cursor:"pointer", transition:"all 0.15s",
+                  }}>
+                    {p.toUpperCase()}
+                  </button>
+                ))}
+              </div>
+
+              {/* Three-column comparison */}
+              <div style={{ background:"#050810", border:"1px solid #0f1e2e", borderRadius:8, padding:20 }}>
+                {/* Column headers */}
+                <div style={{ display:"grid", gridTemplateColumns:"1fr 1fr 1fr", gap:16, marginBottom:12 }}>
+                  {["FLAIR MRI", "SEGMENTATION", "OVERLAY"].map(h => (
+                    <div key={h} style={{ fontSize:10, letterSpacing:"0.2em", color:"#5a7a8a", textAlign:"center" }}>{h}</div>
+                  ))}
+                </div>
+
+                {/* Three canvases */}
+                <div style={{ display:"grid", gridTemplateColumns:"1fr 1fr 1fr", gap:16, justifyItems:"center" }}>
+
+                  {/* MRI */}
+                  {mriSlices[plane]
+                    ? <MRICanvas data={mriSlices[plane]} label={plane} />
+                    : <div style={{ width:160, height:160, background:"#0a1020", borderRadius:4, border:"1px solid #1e2d40", display:"flex", alignItems:"center", justifyContent:"center" }}>
+                        <span style={{ fontSize:11, color:"#2a3a50" }}>no MRI data</span>
+                      </div>
+                  }
+
+                  {/* Segmentation */}
+                  {slices[plane] && <SegCanvas data={slices[plane]} label={plane} />}
+
+                  {/* Overlay */}
+                  {slices[plane] && mriSlices[plane]
+                    ? <OverlayCanvas mriData={mriSlices[plane]} segData={slices[plane]} label={plane} />
+                    : slices[plane] && <SegCanvas data={slices[plane]} label={plane} />
+                  }
+
+                </div>
+              </div>
+
+              {/* Volume info + region cards */}
+              <div style={{ display:"flex", gap:10, alignItems:"stretch" }}>
+                <div style={{ padding:"14px 18px", background:"#050810", border:"1px solid #0f1e2e", borderRadius:6, minWidth:160 }}>
+                  <div style={{ fontSize:11, color:"#5a7a8a", marginBottom:6 }}>Volume</div>
+                  <div style={{ fontSize:13, color:"#6a8a9a", fontFamily:"monospace", marginBottom:12 }}>{result.shape?.join(" × ")}</div>
+                  <div style={{ fontSize:11, color:"#5a7a8a", marginBottom:4 }}>Tumor burden</div>
+                  <div style={{ fontSize:26, color:"#4fa3e0", fontFamily:"monospace", fontWeight:300 }}>
+                    {result["tumor_burden_%"]}<span style={{ fontSize:13, marginLeft:3 }}>%</span>
+                  </div>
+                  {result.demo && <div style={{ marginTop:10, fontSize:10, color:"#aa7722", border:"1px solid #2a1a08", borderRadius:4, padding:"5px 8px" }}>⚠ SYNTHETIC</div>}
+                </div>
+
+                {REGIONS.map(r => (
+                  <div key={r.key} style={{ flex:1, padding:"14px 16px", background:"#050810", border:`1px solid ${r.color}33`, borderRadius:6 }}>
+                    <div style={{ fontSize:10, letterSpacing:"0.18em", color:r.color, marginBottom:6 }}>{r.key}</div>
+                    <div style={{ fontSize:14, color:"#c0d8e8", marginBottom:2, fontWeight:500 }}>{r.label}</div>
+                    <div style={{ fontSize:11, color:"#5a7a8a", marginBottom:10 }}>{r.desc}</div>
+                    <div style={{ fontSize:22, color:r.color, fontFamily:"monospace", fontWeight:300 }}>
+                      {(regions[r.key] ?? 0).toLocaleString()}
+                      <span style={{ fontSize:11, color:"#5a7a8a", marginLeft:5 }}>vox</span>
+                    </div>
+                  </div>
+                ))}
+              </div>
+            </>
+          )}
+        </div>
+
+        {/* ── Right Panel ── */}
+        <div style={{ width:224, flexShrink:0, borderLeft:"1px solid #0f1e2e", padding:"20px 16px", background:"rgba(4,7,14,0.6)" }}>
+          <div style={{ fontSize:11, letterSpacing:"0.2em", color:"#5a7a8a", marginBottom:16 }}>── CLASS BREAKDOWN</div>
+
+          {result
+            ? Object.entries(classes).map(([id, info]) => {
+                const meta = CLASS_META[parseInt(id)];
+                return (
+                  <div key={id} style={{ marginBottom:18 }}>
+                    <div style={{ fontSize:12, color:meta?.border, marginBottom:5, fontWeight:500 }}>{info.name}</div>
+                    <div style={{ display:"flex", justifyContent:"space-between", marginBottom:4 }}>
+                      <span style={{ fontSize:11, color:"#7a9aaa" }}>{info.voxels.toLocaleString()}</span>
+                      <span style={{ fontSize:11, color:"#9abccc", fontFamily:"monospace" }}>{info.percentage}%</span>
+                    </div>
+                    <div style={{ height:3, background:"#0a1520", borderRadius:2, overflow:"hidden" }}>
+                      <div style={{ height:"100%", width:`${Math.min(info.percentage * 10, 100)}%`, background:meta?.border, borderRadius:2, transition:"width 1.2s ease" }} />
+                    </div>
+                  </div>
+                );
+              })
+            : <div style={{ fontSize:12, color:"#3a5060", lineHeight:1.8 }}>Run segmentation<br/>to see results</div>
+          }
+
+          <div style={{ marginTop:20, paddingTop:16, borderTop:"1px solid #0f1e2e" }}>
+            <div style={{ fontSize:11, letterSpacing:"0.2em", color:"#5a7a8a", marginBottom:12 }}>── MODEL</div>
+            {[["Type","3D U-Net"],["Input","4 × 128³"],["Classes","4"],["Params","26.3M"],["Device","CUDA"]].map(([k,v]) => (
+              <div key={k} style={{ display:"flex", justifyContent:"space-between", marginBottom:7 }}>
+                <span style={{ fontSize:11, color:"#4a6a7a" }}>{k}</span>
+                <span style={{ fontSize:11, color:"#7a9aaa", fontFamily:"monospace" }}>{v}</span>
+              </div>
+            ))}
+          </div>
+        </div>
+
+      </main>
+    </div>
+  );
+}

frontend/src/index.css

@@ -0,0 +1,2 @@
+*, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+body { background: #030609; }

frontend/src/main.jsx

@@ -0,0 +1,10 @@
+import { StrictMode } from 'react'
+import { createRoot } from 'react-dom/client'
+import './index.css'
+import App from './App.jsx'
+
+createRoot(document.getElementById('root')).render(
+  <StrictMode>
+    <App />
+  </StrictMode>,
+)

frontend/vite.config.js

@@ -0,0 +1,7 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+
+// https://vite.dev/config/
+export default defineConfig({
+  plugins: [react()],
+})

src/dataset.py

@@ -0,0 +1,106 @@
+import numpy as np
+import torch
+import torch.nn.functional as F
+from torch.utils.data import Dataset
+import nibabel as nib
+from pathlib import Path
+
+MODALITIES   = ["flair", "t1", "t1ce", "t2"]
+TARGET_SHAPE = (128, 128, 128)
+
+
+# ─── Preprocessing Functions ──────────────────────────────────────────────────
+
+def normalize_modality(vol: np.ndarray) -> np.ndarray:
+    brain_mask = vol > 0
+    if brain_mask.sum() == 0:
+        return vol
+    mu  = vol[brain_mask].mean()
+    std = vol[brain_mask].std() + 1e-8
+    normalized = np.zeros_like(vol)
+    normalized[brain_mask] = (vol[brain_mask] - mu) / std
+    return normalized.astype(np.float32)
+
+
+def crop_to_brain(vol: np.ndarray) -> np.ndarray:
+    coords = np.array(np.where(vol > 0))
+    if coords.shape[1] == 0:
+        return vol
+    mins = coords.min(axis=1)
+    maxs = coords.max(axis=1) + 1
+    return vol[mins[0]:maxs[0],
+               mins[1]:maxs[1],
+               mins[2]:maxs[2]]
+
+
+def resize_volume(vol: np.ndarray, target=TARGET_SHAPE,
+                  mode="trilinear") -> np.ndarray:
+    tensor = torch.from_numpy(vol).float().unsqueeze(0).unsqueeze(0)
+    kwargs = {"align_corners": True} if mode == "trilinear" else {}
+    resized = F.interpolate(tensor, size=target, mode=mode, **kwargs)
+    return resized.squeeze().numpy()
+
+
+# ─── Dataset ──────────────────────────────────────────────────────────────────
+
+class BraTSDataset(Dataset):
+    """
+    PyTorch Dataset for BraTS2020 training data.
+
+    Returns per sample:
+        images : float32 tensor  (4, 128, 128, 128)  — 4 modalities
+        mask   : long tensor     (128, 128, 128)      — labels {0,1,2,3}
+    """
+
+    def __init__(self, root_dir: str, split: str = "train",
+                 train_ratio: float = 0.8, seed: int = 42):
+      
+        root = Path(root_dir)
+        cases = sorted([d for d in root.iterdir() if d.is_dir()])
+        rng = np.random.default_rng(seed)
+        rng.shuffle(cases)
+
+        # Split into train / val
+        n_train = int(len(cases) * train_ratio)
+        if split == "train":
+            self.cases = cases[:n_train]
+        else:
+            self.cases = cases[n_train:]
+
+        self.split = split
+
+    def __len__(self):
+        # DataLoader calls this to know how many batches to produce per epoch
+        return len(self.cases)
+
+    def __getitem__(self, idx: int):
+    
+        case_dir = self.cases[idx]
+        case_id  = case_dir.name
+
+        # ── Load and preprocess all 4 modalities ─────────────────────────────
+        volumes = []
+        for mod in MODALITIES:
+            path = case_dir / f"{case_id}_{mod}.nii"
+            vol  = nib.load(str(path)).get_fdata().astype(np.float32)
+            vol  = normalize_modality(vol)
+            vol  = crop_to_brain(vol)
+            vol  = resize_volume(vol, mode="trilinear")
+            volumes.append(vol)
+
+        # Stack: list of 4 × (128,128,128) → (4, 128, 128, 128)
+        stacked = np.stack(volumes, axis=0)
+
+        # ── Load and preprocess segmentation mask ─────────────────────────────
+        seg_path = case_dir / f"{case_id}_seg.nii"
+        seg = nib.load(str(seg_path)).get_fdata().astype(np.uint8)
+
+        seg[seg == 4] = 3                              # remap label 4 → 3
+        seg = resize_volume(seg, mode="nearest")       # nearest for labels
+        seg = seg.astype(np.int64)
+
+        # ── Convert to tensors ────────────────────────────────────────────────
+        images = torch.from_numpy(stacked).float()    # (4, 128, 128, 128)
+        mask   = torch.from_numpy(seg).long()         # (128, 128, 128)
+
+        return images, mask

src/inference.py

@@ -0,0 +1,229 @@
+"""
+inference.py — FastAPI Backend for BraTS Segmentation
+=======================================================
+Loads the trained UNet3D checkpoint and serves predictions via HTTP.
+
+Endpoints:
+    GET  /health              — model status
+    POST /segment             — run segmentation on uploaded NIfTI files
+    POST /segment/demo        — run on a synthetic volume (no upload needed)
+
+Run:
+    cd src
+    uvicorn inference:app --host 0.0.0.0 --port 8000 --reload
+"""
+
+import io
+import sys
+import numpy as np
+import torch
+from pathlib import Path
+from fastapi import FastAPI, File, UploadFile, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+from dotenv import load_dotenv
+import os
+load_dotenv()
+# Make sure src/ is on the path when running from project root
+sys.path.append(str(Path(__file__).parent))
+
+from model   import UNet3D
+from dataset import normalize_modality, crop_to_brain, resize_volume, MODALITIES
+
+
+# ─── App Setup ────────────────────────────────────────────────────────────────
+# CORSMiddleware allows the React frontend (running on localhost:5173)
+# to call this API without being blocked by the browser's same-origin policy.
+
+app = FastAPI(
+    title="BraTS Segmentation API",
+    description="3D U-Net brain tumor segmentation — BraTS2020",
+    version="1.0.0",
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://localhost:5173", "http://localhost:3000"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+# ─── Model Loading ────────────────────────────────────────────────────────────
+# Model is loaded once at startup and reused for every request.
+# Loading per-request would be ~5 seconds of overhead each time.
+
+DEVICE     = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+CHECKPOINT = Path(__file__).parent.parent / os.getenv("CHECKPOINT_PATH", "checkpoints/best_model.pth")
+TARGET     = (128, 128, 128)
+
+model: UNet3D | None = None
+
+
+@app.on_event("startup")
+def load_model():
+    global model
+    model = UNet3D(in_channels=4, out_channels=4,
+                   base_filters=32, depth=4).to(DEVICE)
+
+    if CHECKPOINT.exists():
+        ckpt = torch.load(str(CHECKPOINT), map_location=DEVICE)
+        model.load_state_dict(ckpt["model_state_dict"])
+        print(f"✅ Loaded checkpoint from epoch {ckpt['epoch']}  "
+              f"best Dice: {ckpt['best_dice']:.4f}")
+    else:
+        print("⚠️  No checkpoint found — using random weights")
+
+    model.eval()
+
+
+# ─── Helpers ──────────────────────────────────────────────────────────────────
+# Converts a raw NIfTI bytes object into a preprocessed numpy array.
+# Supports .nii and .nii.gz — nibabel detects format from the header.
+
+def load_nifti_bytes(content: bytes, filename: str) -> np.ndarray:
+    try:
+        import nibabel as nib
+        import tempfile, os
+        suffix = ".nii.gz" if filename.endswith(".gz") else ".nii"
+        with tempfile.NamedTemporaryFile(suffix=suffix, delete=False) as tmp:
+            tmp.write(content)
+            tmp_path = tmp.name
+        vol = nib.load(tmp_path).get_fdata().astype(np.float32)
+        os.unlink(tmp_path)
+        return vol
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Failed to load {filename}: {e}")
+
+
+def preprocess_volume(volumes: list[np.ndarray]) -> torch.Tensor:
+    # Apply full pipeline to each modality: normalize → crop → resize
+    # Then stack → (1, 4, 128, 128, 128) with batch dim
+    processed = []
+    for vol in volumes:
+        vol = normalize_modality(vol)
+        vol = crop_to_brain(vol)
+        vol = resize_volume(vol, target=TARGET, mode="trilinear")
+        processed.append(vol)
+    stacked = np.stack(processed, axis=0)                      # (4, 128, 128, 128)
+    return torch.from_numpy(stacked).float().unsqueeze(0)      # (1, 4, 128, 128, 128)
+
+
+def run_inference(input_tensor: torch.Tensor) -> np.ndarray:
+    # Returns (128, 128, 128) integer label map {0,1,2,3}
+    input_tensor = input_tensor.to(DEVICE)
+    with torch.no_grad():
+        logits = model(input_tensor)                           # (1, 4, 128, 128, 128)
+        pred   = torch.argmax(logits, dim=1).squeeze(0)       # (128, 128, 128)
+    return pred.cpu().numpy().astype(np.uint8)
+
+
+def build_response(pred: np.ndarray, volumes: list[np.ndarray] | None = None, demo: bool = False) -> dict:
+    total = pred.size
+    classes = {}
+    class_names  = {0: "Background", 1: "Necrotic Core", 2: "Edema", 3: "Enhancing Tumor"}
+    class_colors = {0: [0,0,0,0], 1: [255,50,20,200], 2: [0,220,80,200], 3: [255,220,0,200]}
+
+    for label in range(4):
+        count = int((pred == label).sum())
+        classes[str(label)] = {
+            "name":       class_names[label],
+            "voxels":     count,
+            "percentage": round(100 * count / total, 2),
+            "color":      class_colors[label],
+        }
+
+    regions = {
+        "WT": int((pred > 0).sum()),
+        "TC": int(np.isin(pred, [1, 3]).sum()),
+        "ET": int((pred == 3).sum()),
+    }
+
+    h, w, d = pred.shape
+
+    # Segmentation slices
+    slices = {
+        "axial":    pred[:, :, d // 2].tolist(),
+        "coronal":  pred[:, w // 2, :].tolist(),
+        "sagittal": pred[h // 2, :, :].tolist(),
+    }
+
+    # MRI slices — normalize each modality to 0-255 for display
+    # FLAIR (index 0) is best for showing tumor context
+    mri_slices = {}
+    if volumes is not None:
+        flair = volumes[0]   # FLAIR is most informative for tumor visualization
+        # Normalize to 0–255 for frontend rendering
+        flair_min, flair_max = flair.min(), flair.max()
+        flair_norm = ((flair - flair_min) / (flair_max - flair_min + 1e-8) * 255).astype(np.uint8)
+        mri_slices = {
+            "axial":    flair_norm[:, :, d // 2].tolist(),
+            "coronal":  flair_norm[:, w // 2, :].tolist(),
+            "sagittal": flair_norm[h // 2, :, :].tolist(),
+        }
+
+    return {
+        "success":        True,
+        "demo":           demo,
+        "shape":          list(pred.shape),
+        "tumor_burden_%": round(100 * (pred > 0).sum() / total, 3),
+        "classes":        classes,
+        "regions":        regions,
+        "slices":         slices,
+        "mri_slices":     mri_slices,
+    }
+
+# ─── Endpoints ────────────────────────────────────────────────────────────────
+
+@app.get("/health")
+def health():
+    # Called by frontend on load to check if the model is ready
+    return {
+        "status":           "ok",
+        "device":           str(DEVICE),
+        "model_loaded":     model is not None,
+        "checkpoint_found": CHECKPOINT.exists(),
+    }
+
+
+@app.post("/segment")
+async def segment(
+    flair: UploadFile = File(...),
+    t1:    UploadFile = File(...),
+    t1ce:  UploadFile = File(...),
+    t2:    UploadFile = File(...),
+):
+    if model is None:
+        raise HTTPException(status_code=503, detail="Model not loaded")
+
+    uploads = [flair, t1, t1ce, t2]
+    volumes = []
+    for upload in uploads:
+        content = await upload.read()
+        vol     = load_nifti_bytes(content, upload.filename)
+        volumes.append(vol)
+
+    tensor = preprocess_volume(volumes)
+
+    # Also get the preprocessed volumes for visualization
+    preprocessed_vols = []
+    for vol in volumes:
+        v = normalize_modality(vol)
+        v = crop_to_brain(v)
+        v = resize_volume(v, target=TARGET, mode="trilinear")
+        preprocessed_vols.append(v)
+
+    pred = run_inference(tensor)
+    return JSONResponse(build_response(pred, volumes=preprocessed_vols, demo=False))
+
+
+@app.post("/segment/demo")
+def segment_demo():
+    # Runs inference on a synthetic random volume — no file upload needed.
+    # Useful for testing the frontend without real patient data.
+    if model is None:
+        raise HTTPException(status_code=503, detail="Model not loaded")
+
+    synthetic = torch.randn(1, 4, 128, 128, 128)
+    pred      = run_inference(synthetic)
+    return JSONResponse(build_response(pred, volumes=None, demo=True))

src/model.py

@@ -0,0 +1,163 @@
+"""
+model.py — 3D U-Net for BraTS2020 Brain Tumor Segmentation
+============================================================
+Architecture: Encoder → Bottleneck → Decoder with skip connections.
+Each level doubles/halves the feature maps and halves/doubles spatial dims.
+
+Input:  (B, 4,  128, 128, 128)  — batch of 4-modality MRI volumes
+Output: (B, 4,  128, 128, 128)  — per-voxel class logits
+"""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+# ─── Residual Block ───────────────────────────────────────────────────────────
+# Two conv3d layers with a skip connection.
+# InstanceNorm3d is used instead of BatchNorm because BraTS batch size is 1
+# (one 128³ volume barely fits in VRAM), and BatchNorm is unstable at batch=1.
+# LeakyReLU(0.01) avoids dead neurons better than standard ReLU.
+
+class ResidualBlock(nn.Module):
+    def __init__(self, in_ch: int, out_ch: int):
+        super().__init__()
+        self.conv1 = nn.Conv3d(in_ch,  out_ch, kernel_size=3, padding=1, bias=False)
+        self.norm1 = nn.InstanceNorm3d(out_ch, affine=True)
+        self.conv2 = nn.Conv3d(out_ch, out_ch, kernel_size=3, padding=1, bias=False)
+        self.norm2 = nn.InstanceNorm3d(out_ch, affine=True)
+        self.act   = nn.LeakyReLU(0.01, inplace=True)
+
+        # 1×1×1 projection so skip connection can match channel count
+        # If in_ch == out_ch this is just an identity (no parameters added)
+        self.skip = nn.Conv3d(in_ch, out_ch, kernel_size=1, bias=False) \
+                    if in_ch != out_ch else nn.Identity()
+
+    def forward(self, x):
+        residual = self.skip(x)
+        out = self.act(self.norm1(self.conv1(x)))
+        out = self.norm2(self.conv2(out))
+        return self.act(out + residual)   # add skip then activate
+
+
+# ─── Encoder Block ────────────────────────────────────────────────────────────
+# Each encoder level:
+#   1. ResidualBlock to extract features at current resolution
+#   2. Strided Conv3d (stride=2) to halve spatial dimensions
+# Returns both the downsampled output AND the pre-downsample features (skip).
+# The skip connection is later concatenated in the corresponding decoder level.
+
+class DownBlock(nn.Module):
+    def __init__(self, in_ch: int, out_ch: int):
+        super().__init__()
+        self.res  = ResidualBlock(in_ch, out_ch)
+        self.down = nn.Conv3d(out_ch, out_ch, kernel_size=3,
+                              stride=2, padding=1, bias=False)
+
+    def forward(self, x):
+        skip = self.res(x)      # full-resolution features → stored for skip
+        out  = self.down(skip)  # halved spatial dims → passed to next level
+        return out, skip
+
+
+# ─── Decoder Block ────────────────────────────────────────────────────────────
+# Each decoder level:
+#   1. Trilinear upsample to double spatial dimensions
+#   2. Concatenate with the skip connection from the matching encoder level
+#   3. ResidualBlock to fuse upsampled + skip features
+# The concat doubles the channel count, so ResidualBlock takes in_ch + skip_ch.
+
+class UpBlock(nn.Module):
+    def __init__(self, in_ch: int, skip_ch: int, out_ch: int):
+        super().__init__()
+        self.up  = nn.Upsample(scale_factor=2, mode="trilinear",
+                               align_corners=True)
+        self.res = ResidualBlock(in_ch + skip_ch, out_ch)
+
+    def forward(self, x, skip):
+        x = self.up(x)
+
+        # Pad if spatial dims don't match exactly (can happen with odd input sizes)
+        if x.shape != skip.shape:
+            x = F.pad(x, _pad_to_match(x, skip))
+
+        return self.res(torch.cat([x, skip], dim=1))
+
+
+# ─── Full 3D U-Net ────────────────────────────────────────────────────────────
+# depth=4 means 4 encoder levels, 1 bottleneck, 4 decoder levels.
+# base_filters=32 means the first level has 32 feature maps.
+# Each subsequent level doubles: [32, 64, 128, 256] with bottleneck at 512.
+# Total parameters with default settings: ~19M
+
+class UNet3D(nn.Module):
+    def __init__(self, in_channels=4, out_channels=4,
+                 base_filters=32, depth=4):
+        super().__init__()
+        self.depth = depth
+
+        # Build filter counts per level: [32, 64, 128, 256, 512]
+        filters = [base_filters * (2 ** i) for i in range(depth + 1)]
+
+        # Encoder: depth DownBlocks
+        self.encoders = nn.ModuleList()
+        self.encoders.append(DownBlock(in_channels, filters[0]))
+        for i in range(1, depth):
+            self.encoders.append(DownBlock(filters[i - 1], filters[i]))
+
+        # Bottleneck: single ResidualBlock at lowest resolution
+        self.bottleneck = ResidualBlock(filters[depth - 1], filters[depth])
+
+        # Decoder: depth UpBlocks (mirror of encoder)
+        self.decoders = nn.ModuleList()
+        for i in range(depth - 1, -1, -1):
+            self.decoders.append(UpBlock(filters[i + 1], filters[i], filters[i]))
+
+        # Final 1×1×1 conv: map feature maps → class logits
+        self.head = nn.Conv3d(filters[0], out_channels, kernel_size=1)
+
+        self._init_weights()
+
+    def forward(self, x):
+        # Encode — collect skip connections
+        skips = []
+        for enc in self.encoders:
+            x, skip = enc(x)
+            skips.append(skip)
+
+        # Bottleneck
+        x = self.bottleneck(x)
+
+        # Decode — consume skip connections in reverse order
+        for i, dec in enumerate(self.decoders):
+            x = dec(x, skips[-(i + 1)])
+
+        return self.head(x)   # (B, 4, 128, 128, 128) logits
+
+    def count_parameters(self):
+        return sum(p.numel() for p in self.parameters() if p.requires_grad)
+
+    def _init_weights(self):
+        # Kaiming init for conv layers — designed for LeakyReLU
+        # Ones/zeros for InstanceNorm affine parameters (standard)
+        for m in self.modules():
+            if isinstance(m, nn.Conv3d):
+                nn.init.kaiming_normal_(m.weight, mode="fan_out",
+                                        nonlinearity="leaky_relu")
+                if m.bias is not None:
+                    nn.init.zeros_(m.bias)
+            elif isinstance(m, nn.InstanceNorm3d) and m.affine:
+                nn.init.ones_(m.weight)
+                nn.init.zeros_(m.bias)
+
+
+# ─── Utility ──────────────────────────────────────────────────────────────────
+# Computes the padding needed to make tensor x match the spatial dims of target.
+# Only needed when input dimensions are odd, causing off-by-one after downsample.
+
+def _pad_to_match(x: torch.Tensor, target: torch.Tensor):
+    diffs = [t - s for s, t in zip(x.shape[2:], target.shape[2:])]
+    pad = []
+    for d in reversed(diffs):
+        pad += [d // 2, d - d // 2]
+    return pad

src/train.py

@@ -0,0 +1,286 @@
+"""
+train.py — Training Loop for BraTS2020 3D U-Net
+=================================================
+Connects dataset → model → loss → optimizer into a full training pipeline.
+
+Run:
+    python train.py
+
+Checkpoints saved to: checkpoints/best_model.pth
+TensorBoard logs:     checkpoints/logs/
+"""
+from dotenv import load_dotenv
+import os
+load_dotenv()
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.utils.data import DataLoader
+from torch.optim import AdamW
+from torch.optim.lr_scheduler import CosineAnnealingLR
+from torch.utils.tensorboard import SummaryWriter
+from pathlib import Path
+import numpy as np
+
+from dataset import BraTSDataset
+from model import UNet3D
+
+
+
+# ─── Config ───────────────────────────────────────────────────────────────────
+# All training hyperparameters in one place — easy to change without
+# hunting through the code.
+
+CONFIG = {
+    "data_root":    os.getenv("DATA_ROOT"),
+    "output_dir":   os.getenv("CHECKPOINT_PATH"),
+    "epochs":       110,
+    "batch_size":   1,       # 1 is the max for 128³ on ~10GB VRAM
+    "lr":           1e-4,    # AdamW learning rate
+    "num_workers":  2,       # parallel data loading — set to 0 on Windows if errors
+    "base_filters": 32,
+    "depth":        4,
+    "seed":         42,
+}
+
+
+# ─── Loss Functions ───────────────────────────────────────────────────────────
+# DiceLoss: computed per tumor class independently — handles class imbalance.
+# CombinedLoss: Dice + CrossEntropy equally weighted.
+#   Dice handles imbalance, CE provides stable per-voxel gradients.
+
+class DiceLoss(nn.Module):
+    def __init__(self, smooth=1e-5):
+        super().__init__()
+        self.smooth = smooth
+
+    def forward(self, logits, targets):
+        # logits:  (B, C, H, W, D) — raw model output
+        # targets: (B, H, W, D)    — integer labels {0,1,2,3}
+        num_classes = logits.shape[1]
+        probs = F.softmax(logits, dim=1)
+
+        # One-hot encode targets: (B, H, W, D) → (B, C, H, W, D)
+        targets_oh = F.one_hot(targets.long(), num_classes)
+        targets_oh = targets_oh.permute(0, 4, 1, 2, 3).float()
+
+        # Skip class 0 (background) — we only care about tumor Dice
+        dice_scores = []
+        for c in range(1, num_classes):
+            p = probs[:, c]
+            t = targets_oh[:, c]
+            intersection = (p * t).sum()
+            dsc = (2 * intersection + self.smooth) / (p.sum() + t.sum() + self.smooth)
+            dice_scores.append(dsc)
+
+        # Return loss = 1 - mean Dice (minimizing loss = maximizing Dice)
+        return 1 - torch.stack(dice_scores).mean()
+
+
+class CombinedLoss(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.dice = DiceLoss()
+        self.ce   = nn.CrossEntropyLoss()
+
+    def forward(self, logits, targets):
+        return 0.5 * self.dice(logits, targets) + \
+               0.5 * self.ce(logits, targets.long())
+
+
+# ─── BraTS Dice Metrics ───────────────────────────────────────────────────────
+# Computes the three official BraTS evaluation region Dice scores.
+# Called during validation — not used in the loss, only for monitoring.
+#
+# WT (Whole Tumor)   = labels {1,2,3}
+# TC (Tumor Core)    = labels {1,3}
+# ET (Enhancing)     = label  {3}
+
+def compute_brats_dice(pred, target, smooth=1e-5):
+    # pred, target: (H, W, D) numpy arrays with values {0,1,2,3}
+    regions = {
+        "WT": (pred > 0,              target > 0),
+        "TC": (np.isin(pred, [1, 3]), np.isin(target, [1, 3])),
+        "ET": (pred == 3,             target == 3),
+    }
+    scores = {}
+    for name, (p, t) in regions.items():
+        intersection = (p & t).sum()
+        scores[name] = float(2 * intersection + smooth) / \
+                       float(p.sum() + t.sum() + smooth)
+    return scores
+
+
+# ─── Training Loop (one epoch) ────────────────────────────────────────────────
+# AMP (Automatic Mixed Precision): runs forward pass in float16 where safe,
+# keeps weights in float32. Roughly 2× faster and halves VRAM usage.
+# GradScaler prevents float16 underflow during backprop.
+
+def train_one_epoch(model, loader, optimizer, criterion, scaler, device):
+    model.train()
+    total_loss = 0.0
+
+    for step, (images, masks) in enumerate(loader):
+        images = images.to(device, non_blocking=True)
+        masks  = masks.to(device, non_blocking=True)
+
+        optimizer.zero_grad(set_to_none=True)  # slightly faster than zero_grad()
+
+        with torch.amp.autocast("cuda"):                       # float16 forward pass
+            logits = model(images)
+            loss   = criterion(logits, masks)
+
+        scaler.scale(loss).backward()           # scaled backprop
+        scaler.unscale_(optimizer)
+        # Gradient clipping: prevents exploding gradients in deep 3D networks
+        torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
+        scaler.step(optimizer)
+        scaler.update()
+
+        total_loss += loss.item()
+
+        if step % 10 == 0:
+            print(f"    step {step:3d}/{len(loader)}  loss: {loss.item():.4f}")
+
+    return total_loss / len(loader)
+
+
+# ─── Validation Loop ──────────────────────────────────────────────────────────
+# Runs inference on the val set with no gradients (torch.no_grad saves memory).
+# Computes mean Dice across WT/TC/ET — this is what we save the best model on.
+
+@torch.no_grad()
+def validate(model, loader, criterion, device):
+    model.eval()
+    total_loss = 0.0
+    all_dice   = {"WT": [], "TC": [], "ET": []}
+
+    for images, masks in loader:
+        images = images.to(device, non_blocking=True)
+        masks  = masks.to(device, non_blocking=True)
+
+        with torch.amp.autocast("cuda"):
+            logits = model(images)
+            loss   = criterion(logits, masks)
+
+        total_loss += loss.item()
+
+        # Argmax over class dim → predicted label map
+        pred = torch.argmax(logits, dim=1).cpu().numpy()   # (B, H, W, D)
+        gt   = masks.cpu().numpy()                          # (B, H, W, D)
+
+        # Compute BraTS Dice per sample in batch
+        for b in range(pred.shape[0]):
+            scores = compute_brats_dice(pred[b], gt[b])
+            for region, score in scores.items():
+                all_dice[region].append(score)
+
+    mean_dice = {r: float(np.mean(v)) for r, v in all_dice.items()}
+    mean_dice["mean"] = float(np.mean(list(mean_dice.values())))
+    return total_loss / len(loader), mean_dice
+
+
+# ─── Main ─────────────────────────────────────────────────────────────────────
+
+def main():
+    device     = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    output_dir = Path(CONFIG["output_dir"])
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    print(f"Device:     {device}")
+    print(f"Output dir: {output_dir}")
+
+    # ── Data ─────────────────────────────────────────────────────────────────
+    train_ds = BraTSDataset(CONFIG["data_root"], split="train", seed=CONFIG["seed"])
+    val_ds   = BraTSDataset(CONFIG["data_root"], split="val",   seed=CONFIG["seed"])
+
+    train_loader = DataLoader(train_ds, batch_size=CONFIG["batch_size"],
+                              shuffle=True,  num_workers=CONFIG["num_workers"],
+                              pin_memory=True)
+    val_loader   = DataLoader(val_ds,   batch_size=CONFIG["batch_size"],
+                              shuffle=False, num_workers=CONFIG["num_workers"],
+                              pin_memory=True)
+
+    print(f"Train: {len(train_ds)} cases  |  Val: {len(val_ds)} cases")
+
+    # ── Model ────────────────────────────────────────────────────────────────
+    model = UNet3D(in_channels=4, out_channels=4,
+                   base_filters=CONFIG["base_filters"],
+                   depth=CONFIG["depth"]).to(device)
+    print(f"Parameters: {model.count_parameters():,}")
+
+    # ── Training components ──────────────────────────────────────────────────
+    criterion = CombinedLoss()
+    # AdamW: Adam + weight decay. Weight decay regularizes weights,
+    # preventing overfitting on a 295-case dataset.
+    optimizer = AdamW(model.parameters(), lr=CONFIG["lr"], weight_decay=1e-5)
+    # CosineAnnealingLR: smoothly decays LR from lr → eta_min over all epochs.
+    # Avoids the sharp drops of step schedulers that can destabilize training.
+    scheduler = CosineAnnealingLR(optimizer, T_max=CONFIG["epochs"], eta_min=1e-6)
+    scaler = torch.amp.GradScaler("cuda")                # for AMP
+    writer    = SummaryWriter(output_dir / "logs")  # TensorBoard
+
+    best_dice  = 0.0
+
+    # ── Resume from checkpoint ────────────────────────────────────────────────
+    RESUME = "checkpoints/best_model.pth"   # set to None to start fresh
+    start_epoch = 0
+
+    if RESUME and Path(RESUME).exists():
+        ckpt = torch.load(RESUME, map_location=device)
+        model.load_state_dict(ckpt["model_state_dict"])
+        optimizer.load_state_dict(ckpt["optimizer_state_dict"])
+        start_epoch = ckpt["epoch"] + 1
+        best_dice   = ckpt["best_dice"]
+        print(f"Resumed from epoch {ckpt['epoch']}  best Dice: {best_dice:.4f}")
+
+    # ── Epoch loop ───────────────────────────────────────────────────────────
+    for epoch in range(start_epoch, CONFIG["epochs"]):
+        print(f"\nEpoch {epoch:03d}/{CONFIG['epochs']}")
+
+        train_loss = train_one_epoch(
+            model, train_loader, optimizer, criterion, scaler, device
+        )
+        val_loss, val_dice = validate(model, val_loader, criterion, device)
+        scheduler.step()
+
+        print(f"  Train loss: {train_loss:.4f}")
+        print(f"  Val loss:   {val_loss:.4f}")
+        print(f"  Val Dice — WT: {val_dice['WT']:.3f}  "
+              f"TC: {val_dice['TC']:.3f}  "
+              f"ET: {val_dice['ET']:.3f}  "
+              f"Mean: {val_dice['mean']:.3f}")
+
+        # TensorBoard logging — run: tensorboard --logdir checkpoints/logs
+        writer.add_scalar("Loss/train", train_loss, epoch)
+        writer.add_scalar("Loss/val",   val_loss,   epoch)
+        for region, score in val_dice.items():
+            writer.add_scalar(f"Dice/{region}", score, epoch)
+        writer.add_scalar("LR", scheduler.get_last_lr()[0], epoch)
+
+        # Save best model based on mean val Dice across WT/TC/ET
+        if val_dice["mean"] > best_dice:
+            best_dice = val_dice["mean"]
+            torch.save({
+                "epoch":                epoch,
+                "model_state_dict":     model.state_dict(),
+                "optimizer_state_dict": optimizer.state_dict(),
+                "val_dice":             val_dice,
+                "best_dice":            best_dice,
+                "config":               CONFIG,
+            }, output_dir / "best_model.pth")
+            print(f"  ✅ Best model saved  (mean Dice: {best_dice:.4f})")
+
+        # Periodic checkpoint every 50 epochs — lets you resume if training crashes
+        if epoch % 50 == 0:
+            torch.save({
+                "epoch":            epoch,
+                "model_state_dict": model.state_dict(),
+            }, output_dir / f"epoch_{epoch:03d}.pth")
+
+    writer.close()
+    print(f"\nTraining complete. Best mean Dice: {best_dice:.4f}")
+
+
+if __name__ == "__main__":
+    main()