fix(arch): Config SSOT, reproducible builds, and data pipeline documentation (#41)

* fix(arch): consolidate config and enforce reproducible builds

Consolidates API config into core/config.py (BUG-009) and enforces reproducible builds in Dockerfile using uv and pinned base image (BUG-012).

* chore(deps): migrate from CloseChoice/datasets to neuroimaging-go-brrrr

Replaces the hard-forked dependency with the maintained extension package from . This aligns with the new domain-specific extension architecture while preserving BIDS/NIfTI lazy loading capabilities.

* chore: add results/ to .gitignore

* docs: update NEXT-CONCERNS.md with validated dependency fixes

* docs: add comprehensive documentation for data pipeline and refactor plans

Introduces detailed specifications for the neuroimaging-go-brrrr data pipeline, addressing the integration of NIfTI/BIDS formats with HuggingFace datasets. The documentation outlines the current architecture, proposed refactor for data loading, and the async job queue for long-running ML inference to mitigate timeout issues. Additionally, it includes a postmortem on the NiiVue and Gradio integration attempts, highlighting the challenges faced and lessons learned. This commit aims to enhance clarity and guide future development efforts.

* docs: correct specs per senior review feedback

CORRECTIONS:
- Nifti() returns nibabel.Nifti1Image, NOT numpy array
- Nifti1ImageWrapper calls get_fdata() in constructor (eager load)
- CaseFiles contract requires Paths, wrapper must materialize to temp files
- staging.py already handles nibabel via hasattr(source, "to_filename")

ADDED TO SPEC:
- Tests to delete/rewrite: test_hf_adapter.py, test_loader.py
- Risk matrix: full dataset download, all modalities decoded, eager RAM
- Performance considerations and mitigations
- Open questions to validate during implementation

* style: fix markdown linting in refactor spec

Add language identifiers to fenced code blocks (text for ASCII diagrams)

.gitignore

@@ -217,3 +217,4 @@ data/scratch/
 .DS_Store
 # Auto-generated at runtime (path is environment-specific)
 src/stroke_deepisles_demo/ui/assets/niivue-loader.html
+results/

DATA-PIPELINE.md

@@ -0,0 +1,177 @@
+# Data Pipeline
+
+> **The Problem:** HuggingFace `datasets` doesn't natively support NIfTI/BIDS neuroimaging formats.
+> **The Solution:** `neuroimaging-go-brrrr` extends `datasets` with `Nifti()` feature type.
+
+---
+
+## What is neuroimaging-go-brrrr?
+
+```text
+┌─────────────────────────────────────────────────────────────────────────────────┐
+│              neuroimaging-go-brrrr EXTENDS HUGGINGFACE DATASETS                 │
+├─────────────────────────────────────────────────────────────────────────────────┤
+│                                                                                 │
+│   pip install datasets              pip install neuroimaging-go-brrrr           │
+│   ───────────────────────           ─────────────────────────────────           │
+│   Standard HuggingFace              EXTENDS datasets with:                      │
+│   • Images, text, audio             • Nifti() feature type for .nii.gz          │
+│   • Parquet/Arrow storage           • BIDS directory parsing                    │
+│   • Hub integration                 • Upload utilities (BIDS→Hub)               │
+│                                     • Validation utilities                      │
+│                                     • Bug workarounds for upstream issues       │
+│                                                                                 │
+│   When you install neuroimaging-go-brrrr, you get:                              │
+│   • A patched datasets library with Nifti() support (pinned git commit)         │
+│   • bids_hub module for upload/validation                                       │
+│   • All upstream bug workarounds in one place                                   │
+│                                                                                 │
+└─────────────────────────────────────────────────────────────────────────────────┘
+```
+
+**Key insight:** `neuroimaging-go-brrrr` pins to a specific commit of `datasets` that includes `Nifti()` support:
+
+```toml
+# From neuroimaging-go-brrrr/pyproject.toml
+[tool.uv.sources]
+datasets = { git = "https://github.com/huggingface/datasets.git", rev = "004a5bf4..." }
+```
+
+---
+
+## The Two Pipelines
+
+### Pipeline 1: UPLOAD (How Data Gets to HuggingFace)
+
+```text
+┌─────────────────┐     ┌──────────────────────┐     ┌─────────────────────┐
+│  Local BIDS     │     │  neuroimaging-go-    │     │   HuggingFace Hub   │
+│  Directory      │ ──► │  brrrr (bids_hub)    │ ──► │   hugging-science/  │
+│  (Zenodo)       │     │                      │     │   isles24-stroke    │
+└─────────────────┘     │  • build_isles24_    │     └─────────────────────┘
+                        │    file_table()      │
+                        │  • Nifti() features  │
+                        │  • push_to_hub()     │
+                        └──────────────────────┘
+```
+
+### Pipeline 2: CONSUMPTION (How This Demo Loads Data)
+
+**THE CORRECT PATTERN:**
+
+```python
+from datasets import load_dataset
+
+# neuroimaging-go-brrrr provides the patched datasets with Nifti() support
+ds = load_dataset("hugging-science/isles24-stroke", split="train")
+
+# Access data - Nifti() returns nibabel.Nifti1Image objects
+example = ds[0]
+dwi = example["dwi"]           # nibabel.Nifti1Image (NOT numpy array)
+adc = example["adc"]           # nibabel.Nifti1Image
+lesion_mask = example["lesion_mask"]  # nibabel.Nifti1Image
+
+# To get numpy array: dwi.get_fdata()
+# To save to file: dwi.to_filename("dwi.nii.gz")
+```
+
+This is the **intended consumption pattern**. It should just work because:
+1. `neuroimaging-go-brrrr` provides the patched `datasets` with `Nifti()` support
+2. The dataset was uploaded with `Nifti()` features
+3. `Nifti(decode=True)` returns nibabel images with affine/header preserved
+
+---
+
+## Current State: REFACTOR NEEDED
+
+**Problem:** stroke-deepisles-demo currently has a hand-rolled workaround in `data/adapter.py` that bypasses `datasets.load_dataset()`. This workaround uses `HfFileSystem` + `pyarrow` directly to download individual parquet files.
+
+**Why this is wrong:**
+1. Duplicates bug workarounds that should live in `neuroimaging-go-brrrr`
+2. Doesn't use the `Nifti()` feature type properly
+3. Harder to maintain - fixes need to happen in multiple places
+
+**The fix:**
+1. Delete the custom `HuggingFaceDataset` adapter in `data/adapter.py`
+2. Use standard `datasets.load_dataset()` consumption pattern
+3. If there are bugs, fix them in `neuroimaging-go-brrrr`, not locally
+
+---
+
+## Dependency Relationship
+
+```text
+stroke-deepisles-demo (this repo)
+        │
+        └── neuroimaging-go-brrrr @ v0.2.1
+                │
+                └── datasets @ git commit 004a5bf4... (patched with Nifti())
+                └── huggingface-hub
+                └── bids_hub module (upload + validation utilities)
+```
+
+**The consumption should flow through the standard pattern:**
+
+```text
+stroke-deepisles-demo
+        │
+        │ from datasets import load_dataset
+        │ ds = load_dataset("hugging-science/isles24-stroke")
+        ▼
+neuroimaging-go-brrrr (provides patched datasets)
+        │
+        │ Nifti() feature type handles lazy loading
+        ▼
+HuggingFace Hub (isles24-stroke dataset)
+```
+
+---
+
+## Dataset Info
+
+| Property | Value |
+|----------|-------|
+| Dataset ID | `hugging-science/isles24-stroke` |
+| Subjects | 149 |
+| Modalities | DWI, ADC, Lesion Mask, NCCT, CTA, CTP, Perfusion Maps |
+| Source | [Zenodo 17652035](https://zenodo.org/records/17652035) |
+
+---
+
+## What bids_hub Provides
+
+```text
+┌─────────────────────────────────────────────────────────────────────────────────┐
+│                    neuroimaging-go-brrrr (bids_hub)                             │
+├─────────────────────────────────────────────────────────────────────────────────┤
+│                                                                                 │
+│   FOR UPLOADING:                       FOR CONSUMING:                           │
+│   ──────────────                       ──────────────                           │
+│   build_isles24_file_table()           Patched datasets with Nifti()            │
+│   get_isles24_features()               └── Use standard load_dataset()          │
+│   push_dataset_to_hub()                                                         │
+│                                        validate_isles24_download()              │
+│   We DON'T use these in this demo.     └── ISLES24_EXPECTED_COUNTS              │
+│   Dataset already uploaded.            └── Can use for sanity checking          │
+│                                                                                 │
+└─────────────────────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## Related Documentation
+
+- [neuroimaging-go-brrrr](https://github.com/The-Obstacle-Is-The-Way/neuroimaging-go-brrrr)
+- [isles24-stroke dataset card](https://huggingface.co/datasets/hugging-science/isles24-stroke)
+
+---
+
+## TODO: Refactor Data Loading
+
+The current hand-rolled adapter in `data/adapter.py` should be replaced with standard `datasets.load_dataset()` consumption. This refactor should:
+
+1. Remove `HuggingFaceDataset` class from `data/adapter.py`
+2. Update `data/loader.py` to use `datasets.load_dataset()`
+3. Remove pre-computed constants in `data/constants.py` (no longer needed)
+4. Test that `Nifti()` lazy loading works correctly
+5. If bugs are found, report/fix them in `neuroimaging-go-brrrr`

Dockerfile

@@ -13,7 +13,7 @@
 #   FROM isleschallenge/deepisles@sha256:<digest>
 # Check https://hub.docker.com/r/isleschallenge/deepisles/tags for updates.
 # Current base: DeepISLES v1.1 (as of Dec 2025)
-FROM isleschallenge/deepisles:latest
+FROM isleschallenge/deepisles@sha256:848c9eceb67dbc585bcb37f093389d142caeaa98878bd31039af04ef297a5af4
 
 # Set environment variables for non-interactive installation
 ENV DEBIAN_FRONTEND=noninteractive
@@ -28,16 +28,21 @@ RUN useradd -m -u 1000 user 2>/dev/null || true
 # /app contains DeepISLES code (main.py, src/, weights/) that we must NOT overwrite
 WORKDIR /home/user/demo
 
-# Copy requirements first for better layer caching
-COPY --chown=1000:1000 requirements.txt /home/user/demo/requirements.txt
+# Copy dependency files for reproducible installs
+COPY --chown=1000:1000 pyproject.toml uv.lock /home/user/demo/
 
-# Install Python dependencies into SYSTEM Python (NOT conda env)
-# DeepISLES conda env is Python 3.8, but FastAPI needs Python 3.10+
-# We'll shell out to conda env for inference only
-RUN pip install --no-cache-dir -r requirements.txt
+# Install uv for reproducible dependency management
+RUN pip install --no-cache-dir uv
+
+# Create virtual environment and add to PATH
+ENV VIRTUAL_ENV=/home/user/demo/.venv
+ENV PATH="$VIRTUAL_ENV/bin:$PATH"
+
+# Install Python dependencies from lock file (frozen = fail if lock stale)
+# This ensures CI, local dev, and production use IDENTICAL versions
+RUN uv sync --frozen --no-dev --no-install-project
 
 # Copy application source code and package files
-COPY --chown=1000:1000 pyproject.toml /home/user/demo/pyproject.toml
 COPY --chown=1000:1000 README.md /home/user/demo/README.md
 COPY --chown=1000:1000 src/ /home/user/demo/src/
 
@@ -45,9 +50,8 @@ COPY --chown=1000:1000 src/ /home/user/demo/src/
 # This script runs in the conda env (Py3.8) and is called via subprocess
 COPY --chown=1000:1000 scripts/deepisles_adapter.py /app/deepisles_adapter.py
 
-# Install the package itself into SYSTEM Python
-# Using --no-deps since requirements.txt already installed dependencies
-RUN pip install --no-cache-dir --no-deps -e .
+# Install the package itself (dependencies already installed from lock)
+RUN uv pip install --no-deps -e .
 
 # Set environment variable to indicate we're running in HF Spaces
 # This allows the app to detect runtime environment and use direct invocation
@@ -76,11 +80,14 @@ EXPOSE 7860
 ENTRYPOINT []
 
 # Explicit frontend origin for CORS
-ENV FRONTEND_ORIGIN=https://vibecodermcswaggins-stroke-viewer-frontend.hf.space
+ENV STROKE_DEMO_FRONTEND_ORIGINS='["https://vibecodermcswaggins-stroke-viewer-frontend.hf.space"]'
 
 # Explicit backend public URL for constructing file URLs
 # This ensures correct https:// URLs even if proxy headers aren't forwarded correctly
-ENV BACKEND_PUBLIC_URL=https://vibecodermcswaggins-stroke-deepisles-demo.hf.space
+ENV STROKE_DEMO_BACKEND_PUBLIC_URL=https://vibecodermcswaggins-stroke-deepisles-demo.hf.space
+
+# Results directory (matches default in code, but explicit is better)
+ENV STROKE_DEMO_RESULTS_DIR=/tmp/stroke-results
 
 # Run FastAPI with uvicorn (module path: stroke_deepisles_demo.api.main:app)
 # --proxy-headers: Trust X-Forwarded-Proto from HF Spaces proxy (ensures https:// in request.base_url)

NEXT-CONCERNS.md

@@ -5,212 +5,34 @@
 
 ---
 
-## PART 1: CONFIG DRIFT (BUG-009) - CRITICAL
+## PART 1: CONFIG DRIFT (BUG-009) - RESOLVED
 
-### Current State: Two Parallel Config Systems
-
-**System A: Pydantic Settings** (`core/config.py`)
-
-```python
-# Line 93
-results_dir: Path = Path("./results")
-```
-
-- Uses `STROKE_DEMO_*` env prefix
-- Supports `.env` file loading
-- Used by: `inference/deepisles.py`, `ui/components.py`, `ui/app.py`
-
-**System B: Module Constants** (`api/config.py`)
-
-```python
-# Line 10
-RESULTS_DIR = Path("/tmp/stroke-results")
-```
-
-- Raw constants, no env var support
-- Used by: `routes.py`, `files.py`, `main.py`, `job_store.py`
-
-### The Problem
-
-These define **DIFFERENT VALUES** for the same concept:
-
-- `./results` vs `/tmp/stroke-results`
-
-Production uses System B (API), but System A exists and could cause confusion.
-
-### Env Var Fragmentation
-
-| Where | Var Name | System |
-|-------|----------|--------|
-| Dockerfile:79 | `FRONTEND_ORIGIN` | Raw env var |
-| Dockerfile:83 | `BACKEND_PUBLIC_URL` | Raw env var |
-| core/config.py:68 | `STROKE_DEMO_*` | Pydantic Settings |
-
-**These don't talk to each other.** The Dockerfile sets raw vars that Settings doesn't read.
-
-### Recommended Fix
-
-**Option B from audit: Pydantic Settings as SSOT**
-
-1. Add API-relevant settings to `core/config.py`:
-   - `results_dir` (already exists, fix default to `/tmp/stroke-results`)
-   - `max_concurrent_jobs`
-   - `frontend_origin`
-   - `backend_public_url`
-
-2. Delete or convert `api/config.py` to thin shim that imports from Settings
-
-3. Update Dockerfile env vars to use `STROKE_DEMO_*` prefix
-
-4. Update all API modules to import from `core/config.py`
+### Status
+- **Consolidated:** `api/config.py` deleted.
+- **SSOT:** `core/config.py` now holds all API settings.
+- **Env Vars:** `Dockerfile` updated to use `STROKE_DEMO_*` prefix.
+- **Validation:** Tests pass, env var overrides work.
 
 ---
 
-## PART 2: DEPENDENCY PINNING (BUG-012) - CRITICAL
-
-### Current State: Production Build is NOT Reproducible
-
-**What we have:**
-
-- `uv.lock` ✅ Committed and used by CI
-- `requirements.txt` ⚠️ Has loose `>=` ranges
-- Dockerfile uses `pip install -r requirements.txt` ❌ **IGNORES uv.lock**
-
-**Evidence:**
-
-```dockerfile
-# Dockerfile:37 - IGNORES uv.lock!
-RUN pip install --no-cache-dir -r requirements.txt
-```
-
-```txt
-# requirements.txt - LOOSE PINS
-fastapi>=0.115.0
-pydantic>=2.5.0
-uvicorn[standard]>=0.32.0
-```
-
-### Base Image Unpinned
-
-```dockerfile
-# Dockerfile:16 - NO SHA DIGEST
-FROM isleschallenge/deepisles:latest
-```
-
-`:latest` can change anytime. A rebuild tomorrow could get different dependencies.
-
-### The Problem
-
-| Environment | Install Method | Reproducible? |
-|-------------|----------------|---------------|
-| CI | `uv sync` | ✅ Yes |
-| Local dev | `uv sync` | ✅ Yes |
-| **Production Docker** | `pip install -r requirements.txt` | ❌ **NO** |
-
-### Recommended Fix
-
-**Option A: Make Docker use uv.lock**
-
-```dockerfile
-# Install uv
-RUN pip install uv
-
-# Copy lock file
-COPY uv.lock pyproject.toml ./
-
-# Install from lock (frozen = fail if lock is stale)
-RUN uv sync --frozen --no-dev
-```
-
-**Option B: Pin requirements.txt exactly**
-
-```txt
-# requirements.txt - EXACT PINS
-fastapi==0.115.6
-pydantic==2.10.3
-uvicorn[standard]==0.32.1
-```
-
-**Either way: Pin the base image**
-
-```dockerfile
-# Get digest from: docker pull isleschallenge/deepisles:latest && docker images --digests
-FROM isleschallenge/deepisles@sha256:<actual-digest>
-```
-
----
-
-## PART 3: FRONTEND CONFIG
-
-### Current State
-
-- `frontend/.env.production` hardcodes API URL at build time
-- Works but not flexible for different deployments
-
-### HF Static Spaces Alternative
-
-HF exposes runtime variables via `window.huggingface.variables`. Currently unused.
-
-### Recommendation
-
-Keep current approach (build-time `.env.production`) unless multi-deployment flexibility needed.
-
----
-
-## MIGRATION PLAN
-
-### Phase 1: Config Consolidation (BUG-009)
-
-1. Add to `core/config.py` Settings class:
-
-   ```python
-   # API settings
-   results_dir: Path = Path("/tmp/stroke-results")  # Fix default
-   max_concurrent_jobs: int = 10
-   frontend_origins: list[str] = ["http://localhost:5173"]
-   backend_public_url: str | None = None
-   ```
-
-2. Update Dockerfile env vars:
-
-   ```dockerfile
-   ENV STROKE_DEMO_FRONTEND_ORIGINS='["https://...hf.space"]'
-   ENV STROKE_DEMO_BACKEND_PUBLIC_URL=https://...hf.space
-   ```
-
-3. Update imports in API modules:
-   - `routes.py`, `files.py`, `main.py`, `job_store.py`
-   - Change from `api.config` to `core.config.get_settings()`
-
-4. Delete `api/config.py` or convert to compatibility shim
-
-### Phase 2: Dependency Reproducibility (BUG-012)
-
-1. Pin base image with SHA digest in Dockerfile
-
-2. Choose ONE lock strategy:
-   - **Recommended:** Make Dockerfile use `uv sync --frozen`
-   - Alternative: Generate pinned requirements.txt from uv.lock
-
-3. Update CI to use `--frozen` flag (fail if lock stale)
-
-### Phase 3: Validation
+## PART 2: DEPENDENCY PINNING (BUG-012) - RESOLVED
 
-1. Build Docker image locally
-2. Verify all settings load correctly
-3. Verify reproducible builds (rebuild should get same versions)
+### Status
+- **Base Image:** Pinned to `sha256:848c9eceb67dbc585bcb37f093389d142caeaa98878bd31039af04ef297a5af4`.
+- **Lock File:** Dockerfile now uses `uv sync --frozen` to respect `uv.lock`.
+- **Path:** Dockerfile adds `.venv/bin` to `PATH` for correct execution.
+- **Dependency Migration:** Migrated from hard-forked `datasets` to maintained `neuroimaging-go-brrrr` extension (v0.2.1) + standard `datasets` library. Validated end-to-end in Docker.
+- **Validation:** Docker build succeeds, runtime verifies settings load and modules importable.
 
 ---
 
-## SOURCES
+## PART 3: FRONTEND CONFIG - NO ACTION NEEDED
 
-- FastAPI Settings: https://fastapi.tiangolo.com/advanced/settings/
-- Pydantic Settings: https://docs.pydantic.dev/latest/concepts/pydantic_settings/
-- uv sync docs: https://docs.astral.sh/uv/concepts/projects/sync/
-- Docker pinning: https://docs.docker.com/build/building/best-practices/
-- 12-Factor Config: https://12factor.net/config
+### Status
+- Keeping current build-time `.env.production` approach.
+- No immediate need for runtime variables via `window.huggingface.variables`.
 
 ---
 
-**Validated:** 2024-12-12
-**Status:** Ready for implementation
+**Validated:** 2025-12-12
+**Status:** COMPLETED

docs/bugs/BUGS-HF-SPACES-INTEGRATION.md

@@ -357,24 +357,20 @@ Document in README:
 
 ---
 
-### BUG-009: FRONTEND_ORIGIN Env Var Not Explicitly Set
+### BUG-009: FRONTEND_ORIGIN Env Var Not Explicitly Set (RESOLVED)
 
-**Severity**: P3 - LOW
-**Impact**: Relies on regex fallback, less explicit
-**File**: `Dockerfile`
-
-#### Problem
+**Resolved:** 2024-12-12 via Config Consolidation.
+Backend now uses `STROKE_DEMO_FRONTEND_ORIGINS` (JSON list) via Pydantic Settings.
 
+Previous state:
 Code supports `FRONTEND_ORIGIN` but Dockerfile doesn't set it:
 ```python
 FRONTEND_ORIGIN = os.environ.get("FRONTEND_ORIGIN", "")
 ```
 
-#### Optional Fix
-
-Add to Dockerfile:
+Fixed state:
 ```dockerfile
-ENV FRONTEND_ORIGIN=https://vibecodermcswaggins-stroke-viewer-frontend.hf.space
+ENV STROKE_DEMO_FRONTEND_ORIGINS='["https://vibecodermcswaggins-stroke-viewer-frontend.hf.space"]'
 ```
 
 ---

docs/specs/00-data-loading-refactor.md

@@ -0,0 +1,340 @@
+# SPEC-00: Data Loading Refactor
+
+> **Status:** Draft (Updated per Senior Review)
+> **Priority:** Critical
+> **Estimated Scope:** Delete ~350 lines, add ~100 lines, rewrite 2 test files
+
+---
+
+## Problem Statement
+
+`stroke-deepisles-demo` has a hand-rolled data loading workaround that:
+
+1. **Bypasses `datasets.load_dataset()`** - Uses `HfFileSystem + pyarrow` directly
+2. **Duplicates bug workarounds** - Should live in `neuroimaging-go-brrrr`
+3. **Doesn't use `Nifti()` feature type** - Manually extracts bytes from parquet
+4. **Pre-computes 149 case IDs** - Static list that could drift from source
+
+This defeats the purpose of depending on `neuroimaging-go-brrrr`.
+
+---
+
+## Root Cause
+
+The workaround was created due to:
+- PyArrow streaming bug (apache/arrow#45214) - hangs on parquet iteration
+- Memory concerns about downloading 99GB
+
+**But:** These should be solved in `neuroimaging-go-brrrr`, not locally.
+
+---
+
+## Current Architecture (WRONG)
+
+```text
+stroke-deepisles-demo
+        │
+        ├── data/adapter.py (379 lines)
+        │   ├── HuggingFaceDataset class
+        │   │   ├── _download_case_from_parquet() - manual parquet reading
+        │   │   └── Uses HfFileSystem + pyarrow directly
+        │   └── build_huggingface_dataset() - bypasses load_dataset()
+        │
+        ├── data/constants.py (182 lines)
+        │   └── ISLES24_CASE_IDS - pre-computed 149 case IDs
+        │
+        ├── data/loader.py
+        │   └── load_isles_dataset() - dispatches to adapter
+        │
+        └── tests/data/
+            ├── test_hf_adapter.py - tests HuggingFaceDataset (DELETE/REWRITE)
+            └── test_loader.py - imports HuggingFaceDataset (UPDATE)
+```
+
+---
+
+## What Nifti() Actually Returns
+
+**CRITICAL CORRECTION:** The original spec incorrectly stated `Nifti()` returns numpy arrays.
+
+Per the `datasets` source code:
+- **`Nifti(decode=True)`** (default): Returns a `Nifti1ImageWrapper` (subclass of `nibabel.nifti1.Nifti1Image`)
+  - The wrapper calls `get_fdata()` in its constructor (eager load to RAM)
+  - Preserves affine and header
+- **`Nifti(decode=False)`**: Returns a dict `{"path": ..., "bytes": ...}`
+
+This means:
+```python
+ds = load_dataset("hugging-science/isles24-stroke", split="train")
+example = ds[0]
+dwi = example["dwi"]  # nibabel.Nifti1Image, NOT numpy array
+```
+
+---
+
+## CaseFiles Contract
+
+The existing `CaseFiles` TypedDict expects **Paths**, not nibabel images:
+
+```python
+# core/types.py:12
+class CaseFiles(TypedDict):
+    dwi: Path
+    adc: Path
+    flair: NotRequired[Path]
+    ground_truth: NotRequired[Path]
+```
+
+Downstream code (`pipeline.py:124`) uses:
+```python
+shutil.copy2(case_files["dwi"], dwi_dest)  # Expects Path!
+```
+
+**The new wrapper MUST continue materializing to temp files to preserve this contract.**
+
+---
+
+## Target Architecture (CORRECT)
+
+```text
+stroke-deepisles-demo
+        │
+        └── data/loader.py
+            └── load_isles_dataset()
+                │
+                │  from datasets import load_dataset
+                │  ds = load_dataset("hugging-science/isles24-stroke")
+                ▼
+        HuggingFaceDatasetWrapper (thin wrapper)
+                │
+                │  get_case() materializes nibabel → temp file → Path
+                ▼
+        CaseFiles (Paths to temp files, same contract as before)
+```
+
+---
+
+## Files to Modify
+
+### DELETE
+
+| File | Lines | Reason |
+|------|-------|--------|
+| `data/constants.py` | 182 | Pre-computed IDs no longer needed |
+| `data/adapter.py` (partial) | ~250 | `HuggingFaceDataset` class + `build_huggingface_dataset()` |
+
+**Keep in `adapter.py`:**
+- `LocalDataset` class (for local BIDS directories)
+- `build_local_dataset()` function
+- `parse_subject_id()` helper
+
+### DELETE/REWRITE (Tests)
+
+| File | Reason |
+|------|--------|
+| `tests/data/test_hf_adapter.py` | Tests deleted `HuggingFaceDataset` class |
+| `tests/data/test_loader.py` | Imports `HuggingFaceDataset` |
+
+### MODIFY
+
+| File | Change |
+|------|--------|
+| `data/loader.py` | Add `HuggingFaceDatasetWrapper`, use `load_dataset()` |
+| `data/__init__.py` | Update exports |
+
+### NO CHANGE NEEDED
+
+| File | Reason |
+|------|--------|
+| `data/staging.py` | Already handles nibabel via `hasattr(source, "to_filename")` |
+| `pipeline.py` | Will work unchanged if wrapper returns Paths |
+
+---
+
+## Implementation Plan
+
+### Phase 1: Add HuggingFaceDatasetWrapper
+
+```python
+# data/loader.py
+
+from pathlib import Path
+import tempfile
+import shutil
+
+class HuggingFaceDatasetWrapper:
+    """Thin wrapper matching Dataset protocol.
+
+    Uses datasets.load_dataset() for consumption.
+    Materializes nibabel images to temp files to preserve CaseFiles contract.
+    """
+
+    def __init__(self, hf_dataset, dataset_id: str):
+        self._ds = hf_dataset
+        self._dataset_id = dataset_id
+        self._temp_dir: Path | None = None
+        self._cached_cases: dict[str, CaseFiles] = {}
+        # Build subject_id index once (avoid repeated iteration)
+        self._subject_index: dict[str, int] = {
+            row["subject_id"]: i for i, row in enumerate(self._ds)
+        }
+
+    def __len__(self) -> int:
+        return len(self._ds)
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(self, *args: object) -> None:
+        self.cleanup()
+
+    def list_case_ids(self) -> list[str]:
+        """Return sorted list of subject IDs (uses cached index)."""
+        return sorted(self._subject_index.keys())
+
+    def get_case(self, case_id: str | int) -> CaseFiles:
+        """Get case - materializes nibabel images to temp files."""
+        # Resolve case_id
+        if isinstance(case_id, int):
+            subject_id = list(self._subject_index.keys())[case_id]
+            idx = case_id
+        else:
+            subject_id = case_id
+            idx = self._subject_index[subject_id]
+
+        # Return cached if available
+        if subject_id in self._cached_cases:
+            return self._cached_cases[subject_id]
+
+        # Create temp dir on first use
+        if self._temp_dir is None:
+            self._temp_dir = Path(tempfile.mkdtemp(prefix="isles24_hf_"))
+
+        # Get row from dataset (this triggers Nifti() decode)
+        row = self._ds[idx]
+
+        # Materialize nibabel images to temp files
+        case_dir = self._temp_dir / subject_id
+        case_dir.mkdir(exist_ok=True)
+
+        dwi_path = case_dir / f"{subject_id}_dwi.nii.gz"
+        adc_path = case_dir / f"{subject_id}_adc.nii.gz"
+
+        # row["dwi"] is a nibabel.Nifti1Image
+        row["dwi"].to_filename(str(dwi_path))
+        row["adc"].to_filename(str(adc_path))
+
+        case_files: CaseFiles = {
+            "dwi": dwi_path,
+            "adc": adc_path,
+        }
+
+        # Handle lesion_mask if present
+        if row.get("lesion_mask") is not None:
+            mask_path = case_dir / f"{subject_id}_lesion-msk.nii.gz"
+            row["lesion_mask"].to_filename(str(mask_path))
+            case_files["ground_truth"] = mask_path
+
+        self._cached_cases[subject_id] = case_files
+        return case_files
+
+    def cleanup(self) -> None:
+        """Remove temp directory."""
+        if self._temp_dir and self._temp_dir.exists():
+            shutil.rmtree(self._temp_dir)
+        self._temp_dir = None
+        self._cached_cases.clear()
+```
+
+### Phase 2: Update load_isles_dataset()
+
+```python
+def load_isles_dataset(
+    source: str | Path | None = None,
+    *,
+    local_mode: bool | None = None,
+) -> Dataset:
+    """Load ISLES24 dataset."""
+
+    if local_mode:
+        from stroke_deepisles_demo.data.adapter import build_local_dataset
+        return build_local_dataset(Path(source or "data/isles24"))
+
+    # HuggingFace mode - USE STANDARD CONSUMPTION
+    from datasets import load_dataset
+
+    dataset_id = str(source) if source else "hugging-science/isles24-stroke"
+    ds = load_dataset(dataset_id, split="train")
+
+    return HuggingFaceDatasetWrapper(ds, dataset_id)
+```
+
+### Phase 3: Delete Dead Code
+
+1. Delete `data/constants.py` entirely
+2. Remove from `adapter.py`:
+   - `HuggingFaceDataset` class (lines 143-337)
+   - `build_huggingface_dataset()` function (lines 339-378)
+3. Delete `tests/data/test_hf_adapter.py`
+4. Rewrite `tests/data/test_loader.py` to not import deleted classes
+
+### Phase 4: Test
+
+1. Verify `load_isles_dataset()` works with HuggingFace
+2. Verify nibabel → temp file materialization works
+3. Verify `pipeline.py` still works (shutil.copy2 on Paths)
+4. Run inference end-to-end
+
+---
+
+## Risks and Mitigations
+
+| Risk | Severity | Mitigation |
+|------|----------|------------|
+| **Full dataset download** | HIGH | `load_dataset()` may download all 27GB. Test if streaming or column selection works. May need to file issue in neuroimaging-go-brrrr. |
+| **All modalities decoded** | MEDIUM | Accessing `ds[i]` may decode ALL Nifti columns (ncct, cta, ctp, tmax...). Consider `ds.select_columns(["subject_id", "dwi", "adc", "lesion_mask"])` |
+| **Eager RAM load** | MEDIUM | `Nifti1ImageWrapper` calls `get_fdata()` in constructor. For large 4D volumes this could be GB per modality. |
+| **Byte-for-byte fidelity** | LOW | `to_filename()` may re-encode differently than original bytes. Verify inference results are equivalent. |
+| **O(n) index build** | LOW | Building `_subject_index` iterates full dataset once. Acceptable for 149 rows. |
+
+---
+
+## Performance Considerations
+
+The current adapter downloads ~50MB per case on-demand. The new approach may:
+1. Download more data upfront (all parquet shards)
+2. Decode more modalities than needed
+
+**If this regresses performance significantly:**
+1. File issue in `neuroimaging-go-brrrr` for selective loading
+2. Consider `streaming=True` mode (if supported with Nifti)
+3. Consider column selection before access
+
+---
+
+## Success Criteria
+
+1. `data/constants.py` deleted
+2. `HuggingFaceDataset` class deleted
+3. `load_isles_dataset()` uses `datasets.load_dataset()`
+4. All tests pass (with rewritten HF tests)
+5. Inference works end-to-end
+6. No regression in single-case load time (verify <30s)
+
+---
+
+## Dependencies
+
+- `neuroimaging-go-brrrr @ v0.2.1` (already installed)
+- Patched `datasets` with `Nifti()` support (provided by neuroimaging-go-brrrr)
+
+---
+
+## Open Questions (To Validate During Implementation)
+
+1. Does `load_dataset()` download all shards or lazy-load?
+2. Does `ds.select_columns()` prevent unwanted Nifti decodes?
+3. Is `streaming=True` compatible with `Nifti()` features?
+4. Any byte-for-byte differences when re-encoding via nibabel?
+
+These should be answered by testing, not by adding local workarounds.

docs/specs/{frontend → archive/frontend}/36-frontend-without-gradio-hf-spaces.md

@@ -4,6 +4,8 @@
 **Date**: 2025-12-11
 **Goal**: Replace Gradio with React frontend for NiiVue, FastAPI backend for DeepISLES
 
+**UPDATE (2025-12-12):** See `NEXT-CONCERNS.md` for latest architecture fixes regarding config consolidation (BUG-009) and dependency reproducibility (BUG-012). The env var `FRONTEND_ORIGIN` is now `STROKE_DEMO_FRONTEND_ORIGINS`.
+
 ---
 
 ## Security Note: CVE-2025-55182 Does NOT Affect This App

frontend/README.md

@@ -98,8 +98,11 @@ If you fork this repository, update these files before deploying:
    VITE_API_URL=https://{YOUR_HF_USERNAME}-stroke-deepisles-demo.hf.space
    ```
 
-2. **Backend CORS** (`src/stroke_deepisles_demo/api/main.py`):
-   Add your frontend URL to the `CORS_ORIGINS` list, or set `FRONTEND_ORIGIN` env var.
+2. **Backend CORS** (`src/stroke_deepisles_demo/core/config.py`):
+   Set `STROKE_DEMO_FRONTEND_ORIGINS` env var (JSON list) on the backend Space:
+   ```bash
+   STROKE_DEMO_FRONTEND_ORIGINS='["https://{YOUR_HF_USERNAME}-stroke-viewer-frontend.hf.space"]'
+   ```
 
 3. **Rebuild frontend**:
    ```bash

pyproject.toml

@@ -19,8 +19,8 @@ classifiers = [
 keywords = ["stroke", "neuroimaging", "segmentation", "BIDS", "NIfTI", "deep-learning"]
 
 dependencies = [
-    # Core - pinned to Tobias's fork for BIDS + NIfTI lazy loading (commit c1c15aa)
-    "datasets @ git+https://github.com/CloseChoice/datasets.git@c1c15aaa4f00f28f1916f3a896283494162eac49",
+    # Core - BIDS + NIfTI lazy loading (maintained fork)
+    "neuroimaging-go-brrrr @ git+https://github.com/The-Obstacle-Is-The-Way/neuroimaging-go-brrrr.git@v0.2.1",
     "huggingface-hub>=0.25.0",
 
     # NIfTI handling

requirements.txt

@@ -2,9 +2,8 @@
 # Generated: December 2025
 # See: docs/specs/07-hf-spaces-deployment.md
 
-# Core - Tobias's fork with BIDS + NIfTI lazy loading
-# Pinned to specific commit for reproducibility (Dec 2025)
-git+https://github.com/CloseChoice/datasets.git@c1c15aaa4f00f28f1916f3a896283494162eac49
+# Core - BIDS + NIfTI lazy loading (maintained fork)
+neuroimaging-go-brrrr @ git+https://github.com/The-Obstacle-Is-The-Way/neuroimaging-go-brrrr.git@v0.2.1
 
 # HuggingFace
 huggingface-hub>=0.25.0

src/stroke_deepisles_demo/api/config.py

@@ -1,16 +0,0 @@
-"""API configuration constants.
-
-Single source of truth for API configuration values.
-"""
-
-from pathlib import Path
-
-# Results directory for job outputs (must be in /tmp for HF Spaces)
-# CRITICAL: This is the single source of truth. Import this instead of hardcoding.
-RESULTS_DIR = Path("/tmp/stroke-results")
-
-# Maximum active jobs (pending + running) accepted by the API
-# This limits how many jobs can be queued/running at once, NOT serialized GPU execution
-# T4 GPU (16GB) can handle ~1-2 concurrent DeepISLES inferences safely
-# Value of 10 allows reasonable queue depth while preventing unbounded accumulation
-MAX_CONCURRENT_JOBS = 10

src/stroke_deepisles_demo/api/files.py

@@ -18,7 +18,7 @@ Reference: https://github.com/fastapi/fastapi/discussions/7319
 from fastapi import APIRouter, HTTPException
 from fastapi.responses import FileResponse
 
-from stroke_deepisles_demo.api.config import RESULTS_DIR
+from stroke_deepisles_demo.core.config import get_settings
 from stroke_deepisles_demo.core.logging import get_logger
 
 logger = get_logger(__name__)
@@ -45,13 +45,14 @@ async def get_result_file(job_id: str, case_id: str, filename: str) -> FileRespo
         404: File not found (job expired, invalid path, or doesn't exist)
     """
     # Construct file path
-    file_path = RESULTS_DIR / job_id / case_id / filename
+    results_dir = get_settings().results_dir
+    file_path = results_dir / job_id / case_id / filename
 
     # Security: Ensure path doesn't escape RESULTS_DIR (path traversal protection)
     # Using is_relative_to() instead of startswith() to prevent prefix-collision bypass
     # e.g., /tmp/stroke-results-evil/file.txt would pass startswith but fail is_relative_to
     try:
-        base_dir = RESULTS_DIR.resolve()
+        base_dir = results_dir.resolve()
         resolved = file_path.resolve()
         if not resolved.is_relative_to(base_dir):
             logger.warning("Path traversal attempt blocked: %s", filename)

src/stroke_deepisles_demo/api/job_store.py

@@ -25,7 +25,7 @@ from datetime import datetime, timedelta
 from enum import Enum
 from typing import TYPE_CHECKING, Any
 
-from stroke_deepisles_demo.api.config import RESULTS_DIR
+from stroke_deepisles_demo.core.config import get_settings
 from stroke_deepisles_demo.core.logging import get_logger
 
 if TYPE_CHECKING:
@@ -138,7 +138,7 @@ class JobStore:
         self._jobs: dict[str, Job] = {}
         self._lock = threading.RLock()
         self._ttl = ttl
-        self._results_dir = results_dir or RESULTS_DIR
+        self._results_dir = results_dir or get_settings().results_dir
         self._cleanup_thread: threading.Thread | None = None
         self._shutdown = threading.Event()
 

src/stroke_deepisles_demo/api/main.py

@@ -13,7 +13,6 @@ Architecture designed to work within HuggingFace Spaces constraints:
 - /tmp writable only (results stored there)
 """
 
-import os
 from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
 from typing import Any
@@ -22,10 +21,10 @@ from fastapi import FastAPI, Request, Response
 from fastapi.middleware.cors import CORSMiddleware
 from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
 
-from stroke_deepisles_demo.api.config import RESULTS_DIR
 from stroke_deepisles_demo.api.files import files_router
 from stroke_deepisles_demo.api.job_store import init_job_store
 from stroke_deepisles_demo.api.routes import router
+from stroke_deepisles_demo.core.config import get_settings
 from stroke_deepisles_demo.core.logging import get_logger
 
 logger = get_logger(__name__)
@@ -44,6 +43,7 @@ async def lifespan(_app: FastAPI) -> AsyncIterator[None]:
     """
     # Startup
     logger.info("Starting stroke segmentation API...")
+    settings = get_settings()
 
     # Check for GPU availability (DeepISLES requires GPU)
     try:
@@ -58,10 +58,10 @@ async def lifespan(_app: FastAPI) -> AsyncIterator[None]:
         pass  # torch may not be available in all environments
 
     # Create results directory
-    RESULTS_DIR.mkdir(parents=True, exist_ok=True)
+    settings.results_dir.mkdir(parents=True, exist_ok=True)
 
     # Initialize job store with cleanup scheduler
-    job_store = init_job_store(results_dir=RESULTS_DIR)
+    job_store = init_job_store(results_dir=settings.results_dir)
     logger.info("Job store initialized with %d jobs", len(job_store))
 
     yield
@@ -94,21 +94,7 @@ class CORPMiddleware(BaseHTTPMiddleware):
         return response
 
 
-# CORS configuration - Single source of truth (no regex needed for exact origins)
-# Production HF Space frontend origin
-HF_SPACE_FRONTEND = "https://vibecodermcswaggins-stroke-viewer-frontend.hf.space"
-
-CORS_ORIGINS: list[str] = [
-    "http://localhost:5173",  # Vite dev server
-    "http://localhost:3000",  # Alternative local port
-    HF_SPACE_FRONTEND,  # Production HF Space frontend
-]
-
-# Allow override via environment variable (for custom deployments)
-FRONTEND_ORIGIN = os.environ.get("FRONTEND_ORIGIN", "")
-if FRONTEND_ORIGIN and FRONTEND_ORIGIN not in CORS_ORIGINS:
-    CORS_ORIGINS.append(FRONTEND_ORIGIN)
-
+# CORS configuration - Single source of truth from Settings
 # Add CORP middleware first (for COEP compatibility)
 app.add_middleware(CORPMiddleware)
 
@@ -117,7 +103,7 @@ app.add_middleware(CORPMiddleware)
 # This eliminates regex security concerns while maintaining single source of truth
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=CORS_ORIGINS,
+    allow_origins=get_settings().frontend_origins,
     allow_credentials=False,  # Not needed - no cookies/auth
     allow_methods=["GET", "POST", "HEAD"],  # HEAD for preflight checks
     allow_headers=["Content-Type", "Range"],  # Range needed for partial content requests
@@ -150,9 +136,10 @@ async def health() -> dict[str, Any]:
     from stroke_deepisles_demo.api.job_store import get_job_store
 
     store = get_job_store()
+    settings = get_settings()
     return {
         "status": "healthy",
         "jobs_in_memory": len(store),
-        "results_dir": str(RESULTS_DIR),
-        "results_dir_exists": RESULTS_DIR.exists(),
+        "results_dir": str(settings.results_dir),
+        "results_dir_exists": settings.results_dir.exists(),
     }

src/stroke_deepisles_demo/api/routes.py

@@ -10,12 +10,10 @@ This pattern avoids HuggingFace Spaces' ~60s gateway timeout.
 
 from __future__ import annotations
 
-import os
 import uuid
 
 from fastapi import APIRouter, BackgroundTasks, HTTPException, Request
 
-from stroke_deepisles_demo.api.config import MAX_CONCURRENT_JOBS, RESULTS_DIR
 from stroke_deepisles_demo.api.job_store import JobStatus, get_job_store
 from stroke_deepisles_demo.api.schemas import (
     CasesResponse,
@@ -24,6 +22,7 @@ from stroke_deepisles_demo.api.schemas import (
     SegmentRequest,
     SegmentResponse,
 )
+from stroke_deepisles_demo.core.config import get_settings
 from stroke_deepisles_demo.core.logging import get_logger
 from stroke_deepisles_demo.data import list_case_ids
 from stroke_deepisles_demo.metrics import compute_volume_ml
@@ -38,12 +37,12 @@ def get_backend_base_url(request: Request) -> str:
     """Get the backend's public URL for building absolute file URLs.
 
     Priority:
-    1. BACKEND_PUBLIC_URL env var (for production HF Spaces)
+    1. BACKEND_PUBLIC_URL setting (from env var or config)
     2. Request's base URL (for local development)
     """
-    env_url = os.environ.get("BACKEND_PUBLIC_URL", "").rstrip("/")
-    if env_url:
-        return env_url
+    settings_url = get_settings().backend_public_url
+    if settings_url:
+        return settings_url.rstrip("/")
     return str(request.base_url).rstrip("/")
 
 
@@ -92,7 +91,7 @@ def create_segment_job(
     try:
         # Concurrency limit to prevent GPU memory exhaustion (BUG-006 fix)
         store = get_job_store()
-        if store.get_active_job_count() >= MAX_CONCURRENT_JOBS:
+        if store.get_active_job_count() >= get_settings().max_concurrent_jobs:
             raise HTTPException(
                 status_code=503,
                 detail="Server busy: too many active jobs. Please try again later.",
@@ -223,7 +222,7 @@ def run_segmentation_job(
         store.update_progress(job_id, 10, "Loading case data...")
 
         # Set up output directory
-        output_dir = RESULTS_DIR / job_id
+        output_dir = get_settings().results_dir / job_id
 
         store.update_progress(job_id, 20, "Staging files for DeepISLES...")
 

src/stroke_deepisles_demo/core/config.py

@@ -90,7 +90,19 @@ class Settings(BaseSettings):
 
     # Paths
     temp_dir: Path | None = None
-    results_dir: Path = Path("./results")
+    # Results directory - MUST be /tmp for HF Spaces (only /tmp is writable)
+    results_dir: Path = Path("/tmp/stroke-results")
+
+    # API Settings
+    # Concurrency control
+    max_concurrent_jobs: int = 10
+
+    # CORS - frontend origins allowed to call this API
+    frontend_origins: list[str] = Field(default=["http://localhost:5173", "http://localhost:3000"])
+
+    # Public URL for constructing absolute file URLs in responses
+    # If not set, uses request.base_url (works for local dev)
+    backend_public_url: str | None = None
 
     # UI
     gradio_server_name: str = "0.0.0.0"

uv.lock

@@ -582,7 +582,7 @@ wheels = [
 [[package]]
 name = "datasets"
 version = "4.4.2.dev0"
-source = { git = "https://github.com/CloseChoice/datasets.git?rev=c1c15aaa4f00f28f1916f3a896283494162eac49#c1c15aaa4f00f28f1916f3a896283494162eac49" }
+source = { git = "https://github.com/huggingface/datasets.git?rev=004a5bf4addd9293d6d40f43360c03c8f7e42b28#004a5bf4addd9293d6d40f43360c03c8f7e42b28" }
 dependencies = [
     { name = "dill" },
     { name = "filelock" },
@@ -618,6 +618,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/33/6b/e0547afaf41bf2c42e52430072fa5658766e3d65bd4b03a563d1b6336f57/distlib-0.4.0-py2.py3-none-any.whl", hash = "sha256:9659f7d87e46584a30b5780e43ac7a2143098441670ff0a49d5f9034c54a6c16", size = 469047 },
 ]
 
+[[package]]
+name = "et-xmlfile"
+version = "2.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d3/38/af70d7ab1ae9d4da450eeec1fa3918940a5fafb9055e934af8d6eb0c2313/et_xmlfile-2.0.0.tar.gz", hash = "sha256:dab3f4764309081ce75662649be815c4c9081e88f0837825f90fd28317d4da54", size = 17234 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c1/8b/5fe2cc11fee489817272089c4203e679c63b570a5aaeb18d852ae3cbba6a/et_xmlfile-2.0.0-py3-none-any.whl", hash = "sha256:7a91720bc756843502c3b7504c77b8fe44217c85c537d85037f0f536151b2caa", size = 18059 },
+]
+
 [[package]]
 name = "fastapi"
 version = "0.123.8"
@@ -1567,6 +1576,20 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/79/7b/2c79738432f5c924bef5071f933bcc9efd0473bac3b4aa584a6f7c1c8df8/mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505", size = 4963 },
 ]
 
+[[package]]
+name = "neuroimaging-go-brrrr"
+version = "0.2.0"
+source = { git = "https://github.com/The-Obstacle-Is-The-Way/neuroimaging-go-brrrr.git?rev=v0.2.1#97445127210269f1d59fd0bf96fa8127585a7fc1" }
+dependencies = [
+    { name = "datasets" },
+    { name = "hf-xet" },
+    { name = "huggingface-hub" },
+    { name = "nibabel" },
+    { name = "openpyxl" },
+    { name = "pandas" },
+    { name = "typer" },
+]
+
 [[package]]
 name = "nibabel"
 version = "5.3.2"
@@ -1615,6 +1638,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/16/2e/86f24451c2d530c88daf997cb8d6ac622c1d40d19f5a031ed68a4b73a374/numpy-1.26.4-cp312-cp312-win_amd64.whl", hash = "sha256:08beddf13648eb95f8d867350f6a018a4be2e5ad54c8d8caed89ebca558b2818", size = 15517754 },
 ]
 
+[[package]]
+name = "openpyxl"
+version = "3.1.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "et-xmlfile" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3d/f9/88d94a75de065ea32619465d2f77b29a0469500e99012523b91cc4141cd1/openpyxl-3.1.5.tar.gz", hash = "sha256:cf0e3cf56142039133628b5acffe8ef0c12bc902d2aadd3e0fe5878dc08d1050", size = 186464 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c0/da/977ded879c29cbd04de313843e76868e6e13408a94ed6b987245dc7c8506/openpyxl-3.1.5-py2.py3-none-any.whl", hash = "sha256:5282c12b107bffeef825f4617dc029afaf41d0ea60823bbb665ef3079dc79de2", size = 250910 },
+]
+
 [[package]]
 name = "orjson"
 version = "3.11.4"
@@ -2437,8 +2472,8 @@ name = "stroke-deepisles-demo"
 version = "0.1.0"
 source = { editable = "." }
 dependencies = [
-    { name = "datasets" },
     { name = "huggingface-hub" },
+    { name = "neuroimaging-go-brrrr" },
     { name = "nibabel" },
     { name = "numpy" },
     { name = "pydantic" },
@@ -2471,12 +2506,12 @@ dev = [
 
 [package.metadata]
 requires-dist = [
-    { name = "datasets", git = "https://github.com/CloseChoice/datasets.git?rev=c1c15aaa4f00f28f1916f3a896283494162eac49" },
     { name = "fastapi", marker = "extra == 'api'", specifier = ">=0.115.0" },
     { name = "gradio", marker = "extra == 'gradio'", specifier = ">=6.0.0,<7.0.0" },
     { name = "gradio-niivueviewer", marker = "extra == 'gradio'", editable = "packages/niivueviewer" },
     { name = "huggingface-hub", specifier = ">=0.25.0" },
     { name = "matplotlib", marker = "extra == 'gradio'", specifier = ">=3.8.0" },
+    { name = "neuroimaging-go-brrrr", git = "https://github.com/The-Obstacle-Is-The-Way/neuroimaging-go-brrrr.git?rev=v0.2.1" },
     { name = "nibabel", specifier = ">=5.2.0" },
     { name = "numpy", specifier = ">=1.26.0,<2.0.0" },
     { name = "pydantic", specifier = ">=2.5.0" },