Add DataView tool: dataset visualizer with gallery, table, compare, and drawer views

clean_dataset.py

@@ -0,0 +1,376 @@
+"""
+clean_dataset.py — Extract clean prompts from Telegram AI image dataset.
+Groups consecutive images by prompt, strips ads/model names/hashtags,
+and outputs a VLM-training-ready JSONL file.
+
+Usage:
+  python tools/dataview/clean_dataset.py \
+    --input telegram-channel-dataset/dataset.parquet \
+    --output telegram-channel-dataset/cleaned.jsonl
+"""
+
+import argparse
+import json
+import re
+import sys
+from pathlib import Path
+
+import pandas as pd
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+
+# ── Patterns to strip ──────────────────────────────────────────────────
+STRIP_PATTERNS = [
+    # Hashtags
+    r'#[\w\u4e00-\u9fff]+',
+    # Bot links / Telegram links
+    r'\[.*?\]\(https?://t\.me/[^\)]+\)',
+    r'https?://t\.me/\S+',
+    r'https?://\S+',
+    # Source/author lines
+    r'来源：.*',
+    r'作者：.*',
+    r'Source:.*',
+    r'Author:.*',
+    # Ad / promo lines
+    r'🚀.*',
+    r'📚\s*教程目录.*',
+    r'━━+',
+    r'🤖.*我们的 Bot.*',
+    r'🔥.*邪修频道.*',
+    r'VPN推荐.*',
+    r'NanoGPT.*',
+    r'免费赠送.*',
+    r'快来体验.*',
+    r'Dubis.*',
+    r'Bot 机器人.*',
+    # Model name prefixes in titles
+    r'^(✨|🔥|🧩|🖼️|🎞️|🎬|🏮|🎨|📷|📸|🌟|💡|🎭|🎪|🎬|🌙|🌅|🌸|🎭|🖌️)\s*',
+    r'^GPT-?Image[-\s]*2?[｜|]',
+    r'^GPTImage2?[｜|]',
+    # Title lines (Chinese titles with emoji)
+    r'^.*?[｜|].*?(prompt|模板|技巧|构图|写真|人像|海报|封面).*?$',
+]
+
+# Fields that contain prompt-relevant information
+PROMPT_FIELDS = [
+    '任务', '主体', '服装', '场景', '光线', '镜头', '风格', '构图',
+    '约束', '画幅', '关键特征', '变体', '重点', '角色感', '妆造',
+    '动作', '调色', '反差', '结构', '适用', '示例',
+    'Task', 'Subject', 'Style', 'Lighting', 'Camera', 'Composition',
+    'Prompt skeleton',
+]
+
+# Chinese field labels to English mapping
+FIELD_MAP = {
+    '任务': 'task',
+    '主体': 'subject',
+    '服装': 'clothing',
+    '场景': 'scene',
+    '光线': 'lighting',
+    '镜头': 'camera',
+    '风格': 'style',
+    '构图': 'composition',
+    '约束': 'avoid',
+    '画幅': 'aspect_ratio',
+    '关键特征': 'key_features',
+    '变体': 'variants',
+    '重点': 'focus',
+    '角色感': 'character',
+    '妆造': 'makeup',
+    '动作': 'pose',
+    '调色': 'color_grading',
+    '反差': 'contrast',
+    '结构': 'layout',
+    '适用': 'use_case',
+    '示例': 'examples',
+    'Task': 'task',
+    'Subject': 'subject',
+    'Style': 'style',
+    'Lighting': 'lighting',
+    'Camera': 'camera',
+    'Composition': 'composition',
+    'Prompt skeleton': 'prompt_skeleton',
+}
+
+
+def clean_text(text: str) -> str:
+    """Remove ads, links, hashtags, model names, and other noise."""
+    if not text or pd.isna(text):
+        return ''
+    text = str(text)
+
+    # Apply strip patterns
+    for pattern in STRIP_PATTERNS:
+        text = re.sub(pattern, '', text, flags=re.MULTILINE | re.IGNORECASE)
+
+    # Remove lines that are just emojis or very short
+    lines = text.split('\n')
+    cleaned_lines = []
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
+        # Skip very short lines (likely noise)
+        if len(line) < 3:
+            continue
+        # Skip lines that are mostly emojis
+        emoji_chars = len(re.findall(r'[\U0001F300-\U0001F9FF]', line))
+        if emoji_chars > len(line) * 0.5:
+            continue
+        cleaned_lines.append(line)
+
+    return '\n'.join(cleaned_lines).strip()
+
+
+def extract_structured_fields(text: str) -> dict:
+    """Extract structured prompt fields from Chinese text."""
+    if not text:
+        return {}
+
+    fields = {}
+    # Match patterns like "字段名：值" or "字段名: value"
+    field_names = '|'.join(re.escape(f) for f in PROMPT_FIELDS)
+    field_pattern = re.compile(
+        rf'^(?:[-•]\s*)?({field_names})[:：]\s*(.+?)(?:\n|$)',
+        re.MULTILINE
+    )
+
+    for match in field_pattern.finditer(text):
+        field_name = match.group(1).strip()
+        value = match.group(2).strip()
+        if value and len(value) > 2:
+            eng_name = FIELD_MAP.get(field_name, field_name)
+            fields[eng_name] = value
+
+    return fields
+
+
+def extract_prompt_skeleton(text: str) -> str:
+    """Extract 'Prompt skeleton' section if present."""
+    if not text:
+        return ''
+    match = re.search(r'Prompt skeleton[:\s]*\n(.+?)(?:\n\n|\n备注|\Z)', text, re.DOTALL)
+    if match:
+        return match.group(1).strip()
+    return ''
+
+
+def build_prompt(text: str) -> str:
+    """Build a clean prompt from the structured fields."""
+    if not text:
+        return ''
+
+    # Try to get prompt skeleton first (most direct)
+    skeleton = extract_prompt_skeleton(text)
+    if skeleton and len(skeleton) > 20:
+        return skeleton
+
+    # Extract structured fields
+    fields = extract_structured_fields(text)
+
+    if not fields:
+        # Fallback: try to extract any English prompt-like content
+        lines = text.split('\n')
+        prompt_parts = []
+        for line in lines:
+            line = line.strip()
+            # Skip Chinese-only lines
+            chinese_chars = len(re.findall(r'[\u4e00-\u9fff]', line))
+            if chinese_chars > len(line) * 0.3:
+                continue
+            # Skip very short lines
+            if len(line) < 10:
+                continue
+            # Skip known noise
+            if any(skip in line.lower() for skip in ['bot', 'http', '#', '来源', '作者', 'source', 'author']):
+                continue
+            prompt_parts.append(line)
+        if prompt_parts:
+            return '; '.join(prompt_parts)
+        return ''
+
+    # Build prompt from fields in logical order
+    order = ['task', 'subject', 'character', 'makeup', 'clothing', 'pose',
+             'scene', 'lighting', 'camera', 'composition', 'aspect_ratio',
+             'key_features', 'style', 'color_grading', 'contrast', 'layout',
+             'avoid', 'use_case', 'prompt_skeleton']
+
+    parts = []
+    for key in order:
+        if key in fields:
+            parts.append(fields[key])
+
+    # Add any remaining fields not in order
+    for key, val in fields.items():
+        if key not in order and val:
+            parts.append(val)
+
+    return '; '.join(parts) if parts else ''
+
+
+def group_images(df: pd.DataFrame) -> list:
+    """Group consecutive images by prompt (same dimensions = same generation)."""
+    groups = []
+    current_group = None
+
+    for idx, row in df.iterrows():
+        has_text = row['text'] and str(row['text']).strip()
+        has_image = row['image'] is not None and isinstance(row['image'], bytes) and len(row['image']) > 100
+
+        if has_text and has_image:
+            # Start new group
+            if current_group:
+                groups.append(current_group)
+            current_group = {
+                'message_id': row['message_id'],
+                'datetime': row['datetime'],
+                'raw_text': row['text'],
+                'images': [{
+                    'row_idx': idx,
+                    'message_id': row['message_id'],
+                    'width': row['width'],
+                    'height': row['height'],
+                    'image_bytes': row['image'],
+                }]
+            }
+        elif current_group and has_image:
+            # Check if dimensions match (same generation batch)
+            last_img = current_group['images'][-1]
+            if row['width'] == last_img['width'] and row['height'] == last_img['height']:
+                current_group['images'].append({
+                    'row_idx': idx,
+                    'message_id': row['message_id'],
+                    'width': row['width'],
+                    'height': row['height'],
+                    'image_bytes': row['image'],
+                })
+
+    if current_group:
+        groups.append(current_group)
+
+    return groups
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Clean Telegram AI image dataset')
+    parser.add_argument('--input', '-i', required=True, help='Input parquet file')
+    parser.add_argument('--output', '-o', default=None, help='Output JSONL file')
+    parser.add_argument('--parquet', default=None, help='Output cleaned parquet (with only useful columns)')
+    parser.add_argument('--min-images', type=int, default=1, help='Min images per group')
+    parser.add_argument('--min-prompt-len', type=int, default=10, help='Min prompt length')
+    parser.add_argument('--stats', action='store_true', help='Print stats only')
+    args = parser.parse_args()
+
+    # Read parquet
+    print(f"Reading {args.input}...")
+    df = pq.read_table(args.input).to_pandas()
+    print(f"  Total rows: {len(df)}")
+
+    # Optionally output cleaned parquet (strip noise columns)
+    if args.parquet:
+        KEEP = ['message_id', 'datetime', 'media_type', 'text', 'width', 'height', 'image']
+        available = [c for c in KEEP if c in df.columns]
+        clean = df[available].copy()
+        if 'media_type' in clean.columns:
+            clean = clean[clean['media_type'] == 'photo'].copy()
+        clean.reset_index(drop=True, inplace=True)
+        pq.write_table(pa.Table.from_pandas(clean), args.parquet)
+        print(f"  Cleaned parquet: {len(clean)} rows, {len(clean.columns)} cols -> {args.parquet}")
+
+    # Group images
+    groups = group_images(df)
+    print(f"  Prompt groups: {len(groups)}")
+
+    # Clean and filter
+    cleaned = []
+    for group in groups:
+        prompt = build_prompt(group['raw_text'])
+        if len(prompt) < args.min_prompt_len:
+            continue
+        if len(group['images']) < args.min_images:
+            continue
+
+        cleaned.append({
+            'prompt': prompt,
+            'raw_text': group['raw_text'],
+            'num_images': len(group['images']),
+            'message_id': group['message_id'],
+            'datetime': group['datetime'],
+            'images': group['images'],
+        })
+
+    print(f"  Cleaned groups: {len(cleaned)}")
+    print(f"  Total images: {sum(g['num_images'] for g in cleaned)}")
+
+    if args.stats:
+        # Print distribution
+        from collections import Counter
+        sizes = Counter(g['num_images'] for g in cleaned)
+        print("\n  Group size distribution:")
+        for size, count in sorted(sizes.items()):
+            print(f"    {size} images: {count} groups")
+
+        # Show sample prompts
+        print("\n  Sample prompts:")
+        for g in cleaned[:5]:
+            print(f"    [{g['num_images']} imgs] {g['prompt'][:120]}...")
+        return
+
+    # Output
+    if args.output:
+        output_path = Path(args.output)
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+
+        with open(output_path, 'w', encoding='utf-8') as f:
+            for group in cleaned:
+                record = {
+                    'prompt': group['prompt'],
+                    'num_images': group['num_images'],
+                    'message_id': group['message_id'],
+                    'datetime': group['datetime'],
+                    'image_paths': [
+                        f"images/msg_{img['message_id']}_row_{img['row_idx']}.webp"
+                        for img in group['images']
+                    ],
+                }
+                f.write(json.dumps(record, ensure_ascii=False) + '\n')
+
+        print(f"\n  Written to {output_path}")
+
+        # Also save images
+        img_dir = output_path.parent / 'images'
+        img_dir.mkdir(exist_ok=True)
+
+        from PIL import Image
+        import io
+
+        print("  Extracting images...")
+        saved = 0
+        for group in cleaned:
+            for img_data in group['images']:
+                try:
+                    img = Image.open(io.BytesIO(img_data['image_bytes']))
+                    img_path = img_dir / f"msg_{img_data['message_id']}_row_{img_data['row_idx']}.webp"
+                    img.save(img_path, format='WEBP', quality=90)
+                    saved += 1
+                except Exception as e:
+                    print(f"    Warning: Failed to save image {img_data['message_id']}: {e}")
+
+        print(f"  Saved {saved} images to {img_dir}")
+    else:
+        # Just print stats
+        from collections import Counter
+        sizes = Counter(g['num_images'] for g in cleaned)
+        print("\n  Group size distribution:")
+        for size, count in sorted(sizes.items()):
+            print(f"    {size} images: {count} groups")
+
+        print("\n  Sample prompts:")
+        for g in cleaned[:10]:
+            print(f"    [{g['num_images']} imgs] {g['prompt'][:150]}...")
+
+
+if __name__ == '__main__':
+    main()

server.py

@@ -0,0 +1,412 @@
+"""
+DataView — General-purpose dataset visualizer for HuggingFace-style files.
+Supports: Parquet, Arrow, CSV, JSON/JSONL.
+Run:  python tools/dataview/server.py [--port 8080] [--dir /path/to/datasets]
+"""
+
+import argparse
+import io
+import json
+import os
+import uuid
+from pathlib import Path
+from typing import Any
+
+import pandas as pd
+import pyarrow as pa
+import pyarrow.parquet as pq
+from fastapi import FastAPI, HTTPException, Query
+from fastapi.responses import HTMLResponse, Response
+from fastapi.staticfiles import StaticFiles
+from PIL import Image
+
+app = FastAPI(title="DataView")
+
+STATIC_DIR = Path(__file__).parent / "static"
+app.mount("/static", StaticFiles(directory=str(STATIC_DIR)), name="static")
+
+DEFAULT_DIR = str(Path(__file__).parent.parent.parent)
+
+# ---------------------------------------------------------------------------
+# In-memory store of opened files
+# ---------------------------------------------------------------------------
+_store: dict[str, dict] = {}  # file_id -> metadata
+
+SUPPORTED_EXTS = {".parquet", ".pq", ".arrow", ".feather", ".csv", ".tsv", ".json", ".jsonl"}
+
+
+def _detect_format(path: str) -> str:
+    p = path.lower()
+    if p.endswith(".parquet") or p.endswith(".pq"):
+        return "parquet"
+    if p.endswith(".arrow") or p.endswith(".feather"):
+        return "arrow"
+    if p.endswith(".csv") or p.endswith(".tsv"):
+        return "csv"
+    if p.endswith(".jsonl") or p.endswith(".json"):
+        return "jsonl" if ".jsonl" in p else "json"
+    return "unknown"
+
+
+def _read_parquet_schema(path: str) -> dict:
+    pf = pq.ParquetFile(path)
+    schema = pf.schema_arrow
+    meta = pf.metadata
+    return {
+        "format": "parquet",
+        "num_rows": meta.num_rows,
+        "num_row_groups": meta.num_row_groups,
+        "file_size_bytes": os.path.getsize(path),
+        "columns": [
+            {
+                "name": field.name,
+                "type": str(field.type),
+                "is_image": str(field.type) in ("binary", "large_binary"),
+                "nullable": field.nullable,
+            }
+            for field in schema
+        ],
+    }
+
+
+def _read_arrow_schema(path: str) -> dict:
+    table = pa.ipc.open_file(path).read_all()
+    return {
+        "format": "arrow",
+        "num_rows": table.num_rows,
+        "columns": [
+            {
+                "name": field.name,
+                "type": str(field.type),
+                "is_image": str(field.type) in ("binary", "large_binary"),
+                "nullable": field.nullable,
+            }
+            for field in table.schema
+        ],
+    }
+
+
+def _read_csv_schema(path: str) -> dict:
+    df = pd.read_csv(path, nrows=0)
+    return {
+        "format": "csv",
+        "num_rows": sum(1 for _ in open(path)) - 1,
+        "columns": [
+            {
+                "name": col,
+                "type": str(dtype),
+                "is_image": False,
+                "nullable": True,
+            }
+            for col, dtype in df.dtypes.items()
+        ],
+    }
+
+
+def _read_json_schema(path: str) -> dict:
+    with open(path) as f:
+        first_line = f.readline().strip()
+    if first_line.startswith("["):
+        rows = json.loads(open(path).read())
+        num_rows = len(rows)
+        sample = rows[0] if rows else {}
+    else:
+        num_rows = sum(1 for _ in open(path))
+        sample = json.loads(first_line) if first_line else {}
+    return {
+        "format": "json",
+        "num_rows": num_rows,
+        "columns": [
+            {
+                "name": k,
+                "type": type(v).__name__,
+                "is_image": isinstance(v, bytes),
+                "nullable": v is None,
+            }
+            for k, v in sample.items()
+        ],
+    }
+
+
+# ---------------------------------------------------------------------------
+# Routes
+# ---------------------------------------------------------------------------
+@app.get("/", response_class=HTMLResponse)
+async def index():
+    return (STATIC_DIR / "index.html").read_text()
+
+
+@app.get("/api/browse")
+async def browse(path: str = Query(""), show_hidden: bool = Query(False)):
+    """List directory contents for the folder browser."""
+    if not path:
+        path = DEFAULT_DIR
+    path = os.path.expanduser(path)
+
+    if not os.path.isdir(path):
+        raise HTTPException(400, f"Not a directory: {path}")
+
+    entries = []
+    try:
+        for name in sorted(os.listdir(path)):
+            if not show_hidden and name.startswith("."):
+                continue
+            full = os.path.join(path, name)
+            is_dir = os.path.isdir(full)
+            ext = os.path.splitext(name)[1].lower() if not is_dir else ""
+            size = 0
+            if not is_dir:
+                try:
+                    size = os.path.getsize(full)
+                except OSError:
+                    pass
+            entries.append({
+                "name": name,
+                "path": full,
+                "is_dir": is_dir,
+                "ext": ext,
+                "is_dataset": ext in SUPPORTED_EXTS,
+                "size": size,
+            })
+
+        # Sort: dirs first, then dataset files, then others
+        def sort_key(e):
+            if e["is_dir"]:
+                return (0, e["name"].lower())
+            if e["is_dataset"]:
+                return (1, e["name"].lower())
+            return (2, e["name"].lower())
+
+        entries.sort(key=sort_key)
+    except PermissionError:
+        raise HTTPException(403, f"Permission denied: {path}")
+
+    return {
+        "path": path,
+        "parent": os.path.dirname(path) if path != "/" else None,
+        "entries": entries,
+    }
+
+
+@app.get("/api/default-path")
+async def default_path():
+    return {"path": DEFAULT_DIR}
+
+
+@app.post("/api/open")
+async def open_file(body: dict):
+    path = body.get("path", "").strip()
+    if not path:
+        raise HTTPException(400, "path is required")
+    path = os.path.expanduser(path)
+    if not os.path.isfile(path):
+        raise HTTPException(404, f"File not found: {path}")
+
+    fmt = _detect_format(path)
+    try:
+        if fmt == "parquet":
+            info = _read_parquet_schema(path)
+        elif fmt == "arrow":
+            info = _read_arrow_schema(path)
+        elif fmt == "csv":
+            info = _read_csv_schema(path)
+        elif fmt in ("json", "jsonl"):
+            info = _read_json_schema(path)
+        else:
+            raise HTTPException(400, f"Unsupported format: {fmt}")
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(500, f"Error reading file: {e}")
+
+    fid = str(uuid.uuid4())[:8]
+    _store[fid] = {"path": path, "fmt": fmt, "info": info}
+    return {"id": fid, **info, "path": path}
+
+
+@app.get("/api/data/{fid}")
+async def get_data(
+    fid: str,
+    offset: int = Query(0, ge=0),
+    limit: int = Query(50, ge=1, le=500),
+    columns: str = Query("", description="comma-separated column names, empty=all"),
+):
+    if fid not in _store:
+        raise HTTPException(404, "File not opened")
+    entry = _store[fid]
+    path, fmt = entry["path"], entry["fmt"]
+    col_list = [c.strip() for c in columns.split(",") if c.strip()] or None
+
+    try:
+        if fmt == "parquet":
+            table = pq.read_table(path, columns=col_list)
+            df = table.to_pandas()
+        elif fmt == "arrow":
+            table = pa.ipc.open_file(path).read_all()
+            if col_list:
+                table = table.select(col_list)
+            df = table.to_pandas()
+        elif fmt == "csv":
+            df = pd.read_csv(path, usecols=col_list)
+        elif fmt in ("json", "jsonl"):
+            if fmt == "jsonl":
+                df = pd.read_json(path, lines=True)
+            else:
+                df = pd.read_json(path)
+            if col_list:
+                df = df[col_list]
+        else:
+            raise HTTPException(400, "Unsupported format")
+    except Exception as e:
+        raise HTTPException(500, str(e))
+
+    total = len(df)
+    sliced = df.iloc[offset : offset + limit]
+
+    # Serialize: handle binary columns by converting to base64 placeholders
+    records = []
+    for _, row in sliced.iterrows():
+        rec = {}
+        for col in df.columns:
+            val = row[col]
+            if isinstance(val, bytes):
+                rec[col] = {"_type": "image", "size": len(val)}
+            elif pd.isna(val):
+                rec[col] = None
+            elif hasattr(val, "item"):
+                rec[col] = val.item()
+            else:
+                rec[col] = val
+        records.append(rec)
+
+    return {"total": total, "offset": offset, "limit": limit, "data": records}
+
+
+@app.get("/api/image/{fid}/{row}/{col}")
+async def get_image(fid: str, row: int, col: str):
+    if fid not in _store:
+        raise HTTPException(404, "File not opened")
+    entry = _store[fid]
+    path, fmt = entry["path"], entry["fmt"]
+
+    try:
+        if fmt == "parquet":
+            table = pq.read_table(path, columns=[col])
+        elif fmt == "arrow":
+            table = pa.ipc.open_file(path).read_all().select([col])
+        else:
+            raise HTTPException(400, "Image columns only supported for parquet/arrow")
+
+        if row >= table.num_rows:
+            raise HTTPException(400, "Row index out of range")
+
+        cell = table.column(col)[row].as_py()
+        if not isinstance(cell, (bytes, bytearray)):
+            raise HTTPException(400, "Column is not binary/image")
+
+        img = Image.open(io.BytesIO(cell))
+        buf = io.BytesIO()
+        img.save(buf, format="WEBP", quality=85)
+        return Response(content=buf.getvalue(), media_type="image/webp")
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(500, str(e))
+
+
+@app.get("/api/stats/{fid}")
+async def get_stats(fid: str):
+    if fid not in _store:
+        raise HTTPException(404, "File not opened")
+    entry = _store[fid]
+    path, fmt = entry["path"], entry["fmt"]
+    info = entry["info"]
+
+    try:
+        if fmt == "parquet":
+            table = pq.read_table(path)
+            df = table.to_pandas()
+        elif fmt == "arrow":
+            table = pa.ipc.open_file(path).read_all()
+            df = table.to_pandas()
+        elif fmt == "csv":
+            df = pd.read_csv(path)
+        elif fmt in ("json", "jsonl"):
+            df = pd.read_json(path, lines=(fmt == "jsonl"))
+        else:
+            raise HTTPException(400, "Unsupported format")
+    except Exception as e:
+        raise HTTPException(500, str(e))
+
+    stats = []
+    for col_info in info["columns"]:
+        name = col_info["name"]
+        is_img = col_info["is_image"]
+        col = df[name]
+
+        non_null = int(col.notna().sum())
+        null_count = int(col.isna().sum())
+
+        s: dict[str, Any] = {
+            "name": name,
+            "type": col_info["type"],
+            "non_null": non_null,
+            "null_count": null_count,
+        }
+
+        if is_img:
+            sizes = col.dropna().apply(lambda x: len(x) if isinstance(x, (bytes, bytearray)) else 0)
+            if len(sizes) > 0:
+                s["image_stats"] = {
+                    "min_bytes": int(sizes.min()),
+                    "max_bytes": int(sizes.max()),
+                    "mean_bytes": float(sizes.mean()),
+                }
+        elif col.dtype in ("int64", "float64", "int32", "float32"):
+            s["numeric_stats"] = {
+                "min": float(col.min()) if non_null else None,
+                "max": float(col.max()) if non_null else None,
+                "mean": float(col.mean()) if non_null else None,
+                "median": float(col.median()) if non_null else None,
+                "std": float(col.std()) if non_null else None,
+            }
+        elif col.dtype == "object":
+            nunique = int(col.nunique())
+            s["text_stats"] = {
+                "nunique": nunique,
+                "avg_length": float(col.astype(str).str.len().mean()) if non_null else 0,
+            }
+            if nunique <= 30:
+                vc = col.value_counts().head(20)
+                s["text_stats"]["top_values"] = {str(k): int(v) for k, v in vc.items()}
+        elif col.dtype == "bool":
+            vc = col.value_counts()
+            s["bool_stats"] = {str(k): int(v) for k, v in vc.items()}
+
+        stats.append(s)
+
+    return {"total_rows": len(df), "columns": stats}
+
+
+@app.get("/api/list")
+async def list_files():
+    return [
+        {"id": fid, "path": e["path"], "format": e["fmt"], "rows": e["info"]["num_rows"]}
+        for fid, e in _store.items()
+    ]
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="DataView server")
+    parser.add_argument("--port", type=int, default=8080)
+    parser.add_argument("--host", default="0.0.0.0")
+    parser.add_argument("--dir", default=None, help="Default directory for folder browser")
+    args = parser.parse_args()
+
+    if args.dir:
+        DEFAULT_DIR = os.path.expanduser(args.dir)
+
+    import uvicorn
+    print(f"\n  DataView running at http://localhost:{args.port}")
+    print(f"  Default directory: {DEFAULT_DIR}\n")
+    uvicorn.run(app, host=args.host, port=args.port, log_level="info")

static/app.js

@@ -0,0 +1,527 @@
+(() => {
+  const $ = (sel) => document.querySelector(sel);
+  const $$ = (sel) => document.querySelectorAll(sel);
+
+  let currentFile = null;
+  let galleryOffset = 0;
+  let tableOffset = 0;
+  const PER_PAGE = 60;
+  let compareSet = new Map();
+  let searchText = '';
+  let dataCache = null;
+  let drawerRowIdx = null;
+  let drawerNavList = [];
+
+  function showLoading() { $('#loading').classList.remove('hidden'); }
+  function hideLoading() { $('#loading').classList.add('hidden'); }
+
+  function fmtSize(b) {
+    if (!b) return '—';
+    if (b < 1024) return b + ' B';
+    if (b < 1048576) return (b / 1024).toFixed(1) + ' KB';
+    if (b < 1073741824) return (b / 1048576).toFixed(1) + ' MB';
+    return (b / 1073741824).toFixed(2) + ' GB';
+  }
+
+  function fmtNum(n) {
+    if (n == null) return '—';
+    return Number.isInteger(n) ? n.toLocaleString() : n.toLocaleString(undefined, { maximumFractionDigits: 2 });
+  }
+
+  function esc(s) {
+    const d = document.createElement('div');
+    d.textContent = s;
+    return d.innerHTML;
+  }
+
+  function trunc(s, len) {
+    if (!s) return '';
+    return s.length > len ? s.slice(0, len) + '…' : s;
+  }
+
+  function imgSrc(fid, rowIdx, col) {
+    return `/api/image/${fid}/${rowIdx}/${col}`;
+  }
+
+  // ── Folder browser ───────────────────────────────────────────────
+  function openSidebar(path) {
+    $('#sidebar').classList.add('open');
+    $('#sidebar-backdrop').classList.add('open');
+    loadFolder(path || '');
+  }
+
+  function closeSidebar() {
+    $('#sidebar').classList.remove('open');
+    $('#sidebar-backdrop').classList.remove('open');
+  }
+
+  async function loadFolder(path) {
+    try {
+      const res = await fetch(`/api/browse?path=${encodeURIComponent(path)}`);
+      if (!res.ok) throw new Error();
+      const data = await res.json();
+      renderBreadcrumb(data.path);
+      renderFolderList(data);
+    } catch (e) { console.error(e); }
+  }
+
+  function renderBreadcrumb(path) {
+    const parts = path.split('/').filter(Boolean);
+    let h = '<span class="breadcrumb-item" data-path="/">/</span>';
+    let acc = '';
+    parts.forEach((p) => {
+      acc += '/' + p;
+      h += '<span class="breadcrumb-sep">/</span>';
+      h += '<span class="breadcrumb-item" data-path="' + esc(acc) + '">' + esc(p) + '</span>';
+    });
+    $('#breadcrumb').innerHTML = h;
+    $$('.breadcrumb-item').forEach((el) => el.addEventListener('click', () => loadFolder(el.dataset.path)));
+  }
+
+  function renderFolderList(data) {
+    let h = '';
+    if (data.parent) {
+      h += '<div class="folder-entry is-parent" data-path="' + esc(data.parent) + '"><span class="fe-icon">..</span><span class="fe-name">Up</span></div>';
+    }
+    data.entries.forEach((e) => {
+      let icon = '📄', cls = 'is-file';
+      if (e.is_dir) { icon = '📁'; cls = 'is-dir'; }
+      else if (e.is_dataset) { icon = '◉'; cls = 'is-dataset'; }
+      h += '<div class="folder-entry ' + cls + '" data-path="' + esc(e.path) + '" data-dir="' + e.is_dir + '" data-ds="' + e.is_dataset + '">';
+      h += '<span class="fe-icon">' + icon + '</span>';
+      h += '<span class="fe-name">' + esc(e.name) + '</span>';
+      if (!e.is_dir) h += '<span class="fe-meta">' + fmtSize(e.size) + '</span>';
+      h += '</div>';
+    });
+    if (!data.entries.length) h = '<div style="padding:24px;text-align:center;color:var(--text-tertiary);font-size:12px">Empty directory</div>';
+    $('#folder-list').innerHTML = h;
+    $$('.folder-entry').forEach((el) => el.addEventListener('click', () => {
+      if (el.dataset.dir === 'true') loadFolder(el.dataset.path);
+      else if (el.dataset.ds === 'true') {
+        $('#file-path').value = el.dataset.path;
+        closeSidebar();
+        openFile(el.dataset.path);
+      }
+    }));
+  }
+
+  $('#btn-browse').addEventListener('click', () => openSidebar(''));
+  $('#btn-close-sidebar').addEventListener('click', closeSidebar);
+  $('#sidebar-backdrop').addEventListener('click', closeSidebar);
+
+  // ── Open file ────────────────────────────────────────────────────
+  async function openFile(path) {
+    showLoading();
+    try {
+      const res = await fetch('/api/open', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ path }),
+      });
+      if (!res.ok) { const e = await res.json(); alert(e.detail || 'Failed to open file'); return; }
+      currentFile = await res.json();
+      renderInfoBar();
+      renderColumnSelects();
+      galleryOffset = 0;
+      tableOffset = 0;
+      compareSet.clear();
+      updateCompareBadge();
+      closeDrawer();
+      $('#main').classList.remove('hidden');
+      $('#welcome').classList.add('hidden');
+      switchView('gallery');
+    } finally { hideLoading(); }
+  }
+
+  function renderInfoBar() {
+    $('#pill-file').textContent = currentFile.path.split('/').pop();
+    $('#pill-rows').textContent = fmtNum(currentFile.num_rows) + ' rows';
+    $('#pill-cols').textContent = currentFile.columns.length + ' cols';
+  }
+
+  function renderColumnSelects() {
+    const imgCols = currentFile.columns.filter((c) => c.is_image);
+    const textCols = currentFile.columns.filter((c) => !c.is_image);
+    $('#sel-img-col').innerHTML = imgCols.map((c) => '<option value="' + c.name + '">' + c.name + '</option>').join('');
+    $('#sel-txt-col').innerHTML = '<option value="">None</option>' + textCols.map((c) => '<option value="' + c.name + '">' + c.name + '</option>').join('');
+    const prefer = textCols.find((c) => c.name === 'text') || textCols[0];
+    if (prefer) {
+      const sel = $('#sel-txt-col');
+      for (let i = 0; i < sel.options.length; i++) {
+        if (sel.options[i].value === prefer.name) { sel.selectedIndex = i; break; }
+      }
+    }
+  }
+
+  // ── View switching ───────────────────────────────────────────────
+  function switchView(name) {
+    $$('.vs-btn').forEach((b) => b.classList.toggle('active', b.dataset.view === name));
+    $$('.view').forEach((v) => v.classList.add('hidden'));
+    $('#view-' + name).classList.remove('hidden');
+    if (name === 'gallery') loadGallery();
+    else if (name === 'table') loadTable();
+    else if (name === 'compare') renderCompare();
+  }
+
+  $$('.vs-btn').forEach((b) => b.addEventListener('click', () => switchView(b.dataset.view)));
+
+  // ── Search ───────────────────────────────────────────────────────
+  let searchTimer;
+  $('#search-input').addEventListener('input', (e) => {
+    clearTimeout(searchTimer);
+    searchTimer = setTimeout(() => {
+      searchText = e.target.value.trim().toLowerCase();
+      galleryOffset = 0;
+      tableOffset = 0;
+      const active = $('.vs-btn.active');
+      if (active) {
+        const v = active.dataset.view;
+        if (v === 'gallery') loadGallery();
+        else if (v === 'table') loadTable();
+      }
+    }, 200);
+  });
+
+  // ── Gallery ──────────────────────────────────────────────────────
+  async function loadGallery() {
+    if (!currentFile) return;
+    showLoading();
+    try {
+      const imgCol = $('#sel-img-col').value;
+      const txtCol = $('#sel-txt-col').value;
+      if (!imgCol) { hideLoading(); return; }
+      const cols = [imgCol];
+      if (txtCol) cols.push(txtCol);
+      const res = await fetch('/api/data/' + currentFile.id + '?offset=' + galleryOffset + '&limit=' + PER_PAGE + '&columns=' + cols.join(','));
+      if (!res.ok) throw new Error();
+      const data = await res.json();
+      dataCache = data;
+      drawerNavList = data.data.map((_, ri) => data.offset + ri);
+      renderGallery(data, imgCol, txtCol);
+    } finally { hideLoading(); }
+  }
+
+  function renderGallery(data, imgCol, txtCol) {
+    const totalPages = Math.ceil(data.total / PER_PAGE);
+    const page = Math.floor(data.offset / PER_PAGE) + 1;
+    $('#gallery-page').textContent = page + '/' + totalPages + '  (' + fmtNum(data.total) + ')';
+    $('#gallery-prev').disabled = data.offset === 0;
+    $('#gallery-next').disabled = data.offset + PER_PAGE >= data.total;
+
+    const fid = currentFile.id;
+    let h = '';
+    data.data.forEach((row, ri) => {
+      const rowIdx = data.offset + ri;
+      const caption = txtCol ? (row[txtCol] || '') : '';
+      const w = row.width || '';
+      const hm = row.height || '';
+      const sel = compareSet.has(rowIdx);
+      const isOpen = drawerRowIdx === rowIdx;
+
+      h += '<div class="card' + (sel ? ' selected' : '') + (isOpen ? ' card-open' : '') + '" data-row="' + rowIdx + '">';
+      h += '<span class="card-row">#' + (rowIdx + 1) + '</span>';
+      h += '<span class="card-check">&#10003;</span>';
+      h += '<img class="card-img" src="' + imgSrc(fid, rowIdx, imgCol) + '" loading="lazy" data-row="' + rowIdx + '" data-col="' + imgCol + '">';
+      if (w && hm) h += '<span class="card-dims">' + w + '&times;' + hm + '</span>';
+      if (caption) h += '<div class="card-caption">' + esc(trunc(caption, 140)) + '</div>';
+      h += '</div>';
+    });
+    if (!data.data.length) {
+      h = '<p style="color:var(--text-tertiary);padding:48px;text-align:center;grid-column:1/-1">No matching rows</p>';
+    }
+    $('#gallery-grid').innerHTML = h;
+  }
+
+  // Gallery event delegation
+  $('#gallery-grid').addEventListener('click', (e) => {
+    const img = e.target.closest('.card-img');
+    const card = e.target.closest('.card');
+    if (!card) return;
+    const rowIdx = parseInt(card.dataset.row);
+
+    if (e.shiftKey || e.metaKey || e.ctrlKey) {
+      toggleCompare(rowIdx);
+      return;
+    }
+    if (img) openDrawer(rowIdx);
+  });
+
+  $('#sel-img-col').addEventListener('change', () => { galleryOffset = 0; loadGallery(); });
+  $('#sel-txt-col').addEventListener('change', () => { galleryOffset = 0; loadGallery(); });
+  $('#sel-thumb-size').addEventListener('change', (e) => {
+    $('#gallery-grid').style.gridTemplateColumns = 'repeat(auto-fill, minmax(' + e.target.value + 'px, 1fr))';
+  });
+  $('#gallery-prev').addEventListener('click', () => { galleryOffset = Math.max(0, galleryOffset - PER_PAGE); loadGallery(); });
+  $('#gallery-next').addEventListener('click', () => { galleryOffset += PER_PAGE; loadGallery(); });
+
+  // ── Compare ──────────────────────────────────────────────────────
+  function toggleCompare(rowIdx) {
+    const imgCol = $('#sel-img-col').value;
+    if (compareSet.has(rowIdx)) {
+      compareSet.delete(rowIdx);
+    } else {
+      if (compareSet.size >= 4) {
+        const oldest = compareSet.keys().next().value;
+        compareSet.delete(oldest);
+        const oldCard = document.querySelector('.card[data-row="' + oldest + '"]');
+        if (oldCard) oldCard.classList.remove('selected');
+      }
+      compareSet.set(rowIdx, { src: imgSrc(currentFile.id, rowIdx, imgCol), rowIdx });
+    }
+    updateCompareBadge();
+    const card = document.querySelector('.card[data-row="' + rowIdx + '"]');
+    if (card) card.classList.toggle('selected', compareSet.has(rowIdx));
+  }
+
+  function updateCompareBadge() {
+    const badge = $('#compare-badge');
+    const n = compareSet.size;
+    badge.textContent = n;
+    badge.classList.toggle('hidden', n === 0);
+  }
+
+  function renderCompare() {
+    const content = $('#compare-content');
+    const empty = $('#compare-empty');
+    if (compareSet.size < 2) {
+      content.classList.add('hidden');
+      empty.classList.remove('hidden');
+      return;
+    }
+    content.classList.remove('hidden');
+    empty.classList.add('hidden');
+    const txtCol = $('#sel-txt-col').value;
+    let h = '';
+    let idx = 0;
+    for (const [rowIdx, item] of compareSet) {
+      const label = String.fromCharCode(65 + idx);
+      h += '<div class="compare-card">';
+      h += '<div class="cc-head"><span class="cc-label">' + label + ' &middot; Row ' + (rowIdx + 1) + '</span>';
+      h += '<button class="cc-remove" data-row="' + rowIdx + '">&times;</button></div>';
+      h += '<img src="' + item.src + '" alt="Row ' + (rowIdx + 1) + '">';
+      if (txtCol && dataCache) {
+        const row = dataCache.data.find((_, ri) => dataCache.offset + ri === rowIdx);
+        if (row && row[txtCol]) {
+          h += '<div class="cc-prompt">' + esc(row[txtCol]) + '</div>';
+        }
+      }
+      h += '<div class="cc-meta">';
+      currentFile.columns.forEach((col) => {
+        if (col.is_image) return;
+        const row = dataCache?.data?.find((_, ri) => dataCache.offset + ri === rowIdx);
+        const val = row ? row[col.name] : null;
+        if (val === null || val === undefined) return;
+        const s = String(val);
+        if (s.length > 200) return;
+        h += '<div class="cc-meta-row"><span class="cc-meta-key">' + esc(col.name) + '</span><span class="cc-meta-val">' + esc(s) + '</span></div>';
+      });
+      h += '</div></div>';
+      idx++;
+    }
+    content.innerHTML = h;
+    content.querySelectorAll('.cc-remove').forEach((btn) => {
+      btn.addEventListener('click', () => {
+        const r = parseInt(btn.dataset.row);
+        compareSet.delete(r);
+        updateCompareBadge();
+        renderCompare();
+        const card = document.querySelector('.card[data-row="' + r + '"]');
+        if (card) card.classList.remove('selected');
+      });
+    });
+  }
+
+  // ── Table ────────────────────────────────────────────────────────
+  async function loadTable() {
+    if (!currentFile) return;
+    showLoading();
+    try {
+      const limit = parseInt($('#sel-page-size').value);
+      const res = await fetch('/api/data/' + currentFile.id + '?offset=' + tableOffset + '&limit=' + limit);
+      if (!res.ok) throw new Error();
+      const data = await res.json();
+      renderTable(data);
+    } finally { hideLoading(); }
+  }
+
+  function renderTable(data) {
+    const limit = parseInt($('#sel-page-size').value);
+    const totalPages = Math.ceil(data.total / limit);
+    const page = Math.floor(data.offset / limit) + 1;
+    $('#table-page').textContent = page + '/' + totalPages + '  (' + fmtNum(data.total) + ')';
+    $('#table-prev').disabled = data.offset === 0;
+    $('#table-next').disabled = data.offset + limit >= data.total;
+
+    const imgCols = currentFile.columns.filter((c) => c.is_image).map((c) => c.name);
+    const cols = currentFile.columns.map((c) => c.name);
+    const fid = currentFile.id;
+
+    let h = '<table><thead><tr><th style="width:36px">#</th>';
+    cols.forEach((c) => { h += '<th>' + esc(c) + '</th>'; });
+    h += '</tr></thead><tbody>';
+
+    data.data.forEach((row, ri) => {
+      const rowIdx = data.offset + ri;
+      h += '<tr><td class="row-num">' + (rowIdx + 1) + '</td>';
+      cols.forEach((col) => {
+        const val = row[col];
+        if (val === null || val === undefined) {
+          h += '<td class="cell-null">—</td>';
+        } else if (typeof val === 'object' && val._type === 'image') {
+          if (imgCols.includes(col)) {
+            h += '<td><img class="cell-thumb" src="' + imgSrc(fid, rowIdx, col) + '" loading="lazy" data-row="' + rowIdx + '" data-col="' + col + '"></td>';
+          } else {
+            h += '<td class="cell-null">' + fmtSize(val.size) + '</td>';
+          }
+        } else if (typeof val === 'string' && val.length > 120) {
+          h += '<td title="' + esc(val) + '">' + esc(trunc(val, 120)) + '</td>';
+        } else {
+          h += '<td>' + esc(String(val)) + '</td>';
+        }
+      });
+      h += '</tr>';
+    });
+    h += '</tbody></table>';
+    $('#table-container').innerHTML = h;
+
+    $('#table-container').querySelectorAll('.cell-thumb').forEach((img) => {
+      img.addEventListener('click', () => {
+        const rowIdx = parseInt(img.dataset.row);
+        openDrawer(rowIdx);
+      });
+    });
+  }
+
+  $('#sel-page-size').addEventListener('change', () => { tableOffset = 0; loadTable(); });
+  $('#table-prev').addEventListener('click', () => { tableOffset = Math.max(0, tableOffset - parseInt($('#sel-page-size').value)); loadTable(); });
+  $('#table-next').addEventListener('click', () => { tableOffset += parseInt($('#sel-page-size').value); loadTable(); });
+
+  // ── Drawer ───────────────────────────────────────────────────────
+  function openDrawer(rowIdx) {
+    if (!currentFile || !dataCache) return;
+    const row = dataCache.data.find((_, ri) => dataCache.offset + ri === rowIdx);
+    if (!row) return;
+
+    drawerRowIdx = rowIdx;
+    const imgCol = $('#sel-img-col').value;
+    const txtCol = $('#sel-txt-col').value;
+    const fid = currentFile.id;
+
+    $('#drawer-title').textContent = 'Row ' + (rowIdx + 1);
+    $('#drawer-img').src = imgSrc(fid, rowIdx, imgCol);
+
+    const prompt = txtCol ? (row[txtCol] || '') : '';
+    $('#drawer-prompt').textContent = prompt || 'No prompt text';
+
+    let meta = '';
+    currentFile.columns.forEach((col) => {
+      if (col.is_image) return;
+      const val = row[col.name];
+      if (val === null || val === undefined) return;
+      meta += '<div class="drawer-meta-row"><span class="drawer-meta-key">' + esc(col.name) + '</span><span class="drawer-meta-val">' + esc(String(val)) + '</span></div>';
+    });
+    $('#drawer-meta').innerHTML = meta;
+    $('#drawer-meta-section').classList.toggle('hidden', !meta);
+
+    updateDrawerNav();
+    $('#drawer').classList.add('open');
+    $('#drawer-backdrop').classList.add('open');
+    highlightOpenCard();
+  }
+
+  function closeDrawer() {
+    drawerRowIdx = null;
+    $('#drawer').classList.remove('open');
+    $('#drawer-backdrop').classList.remove('open');
+    $$('.card.card-open').forEach((c) => c.classList.remove('card-open'));
+  }
+
+  function highlightOpenCard() {
+    $$('.card.card-open').forEach((c) => c.classList.remove('card-open'));
+    if (drawerRowIdx != null) {
+      const card = document.querySelector('.card[data-row="' + drawerRowIdx + '"]');
+      if (card) card.classList.add('card-open');
+    }
+  }
+
+  function updateDrawerNav() {
+    if (drawerRowIdx == null) return;
+    const idx = drawerNavList.indexOf(drawerRowIdx);
+    $('#drawer-prev').disabled = idx <= 0;
+    $('#drawer-next').disabled = idx < 0 || idx >= drawerNavList.length - 1;
+  }
+
+  function drawerNavigate(dir) {
+    if (drawerRowIdx == null) return;
+    const idx = drawerNavList.indexOf(drawerRowIdx);
+    const newIdx = idx + dir;
+    if (newIdx < 0 || newIdx >= drawerNavList.length) return;
+    openDrawer(drawerNavList[newIdx]);
+  }
+
+  $('#btn-close-drawer').addEventListener('click', closeDrawer);
+  $('#drawer-backdrop').addEventListener('click', closeDrawer);
+  $('#drawer-prev').addEventListener('click', () => drawerNavigate(-1));
+  $('#drawer-next').addEventListener('click', () => drawerNavigate(1));
+
+  $('#drawer-zoom').addEventListener('click', () => {
+    if (drawerRowIdx == null) return;
+    const imgCol = $('#sel-img-col').value;
+    openLightbox(imgSrc(currentFile.id, drawerRowIdx, imgCol));
+  });
+
+  $('#drawer-img').addEventListener('click', () => {
+    if (drawerRowIdx == null) return;
+    const imgCol = $('#sel-img-col').value;
+    openLightbox(imgSrc(currentFile.id, drawerRowIdx, imgCol));
+  });
+
+  // ── Lightbox ─────────────────────────────────────────────────────
+  const lightbox = $('#lightbox');
+  const lbImg = $('#lb-img');
+
+  function openLightbox(src) {
+    lbImg.src = src;
+    lightbox.classList.add('active');
+  }
+
+  function closeLightbox() {
+    lightbox.classList.remove('active');
+  }
+
+  lightbox.addEventListener('click', (e) => {
+    if (e.target === lightbox || e.target.classList.contains('lb-close')) closeLightbox();
+  });
+
+  // ── Keyboard shortcuts ───────────────────────────────────────────
+  document.addEventListener('keydown', (e) => {
+    if (lightbox.classList.contains('active')) {
+      if (e.key === 'Escape') closeLightbox();
+      return;
+    }
+    if ($('#drawer').classList.contains('open')) {
+      if (e.key === 'Escape') closeDrawer();
+      if (e.key === 'ArrowLeft') drawerNavigate(-1);
+      if (e.key === 'ArrowRight') drawerNavigate(1);
+      return;
+    }
+  });
+
+  // ── Init ─────────────────────────────────────────────────────────
+  $('#btn-open').addEventListener('click', () => {
+    const path = $('#file-path').value.trim();
+    if (path) openFile(path);
+  });
+  $('#file-path').addEventListener('keydown', (e) => {
+    if (e.key === 'Enter') {
+      const path = $('#file-path').value.trim();
+      if (path) openFile(path);
+    }
+  });
+
+  if (window.location.hash) {
+    const path = decodeURIComponent(window.location.hash.slice(1));
+    $('#file-path').value = path;
+    openFile(path);
+  }
+})();

static/index.html

@@ -0,0 +1,192 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>DataView</title>
+  <link rel="preconnect" href="https://fonts.googleapis.com">
+  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+  <link href="https://fonts.googleapis.com/css2?family=DM+Sans:ital,wght@0,400;0,500;0,600;0,700;1,400&family=Newsreader:ital,opsz,wght@0,6..72,400;0,6..72,500;1,6..72,400&family=JetBrains+Mono:wght@400;500&display=swap" rel="stylesheet">
+  <link rel="stylesheet" href="/static/style.css">
+</head>
+<body>
+
+  <!-- Folder browser panel -->
+  <aside id="sidebar" class="sidebar">
+    <div class="sidebar-head">
+      <span class="sidebar-label">Browse files</span>
+      <button id="btn-close-sidebar" class="btn-icon" aria-label="Close">&times;</button>
+    </div>
+    <div id="breadcrumb" class="breadcrumb"></div>
+    <div id="folder-list" class="folder-list"></div>
+  </aside>
+  <div id="sidebar-backdrop" class="backdrop"></div>
+
+  <!-- Header -->
+  <header class="header">
+    <button id="btn-browse" class="header-btn" title="Browse folders">
+      <svg width="15" height="15" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M22 19a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h5l2 3h9a2 2 0 0 1 2 2z"/></svg>
+      Browse
+    </button>
+    <div class="path-wrap">
+      <input id="file-path" type="text" placeholder="Paste a file path to open" spellcheck="false">
+      <button id="btn-open" class="path-open-btn">Open</button>
+    </div>
+    <span class="wordmark">data<span class="wordmark-accent">view</span></span>
+  </header>
+
+  <!-- Main content (hidden until file opened) -->
+  <main id="main" class="main hidden">
+
+    <!-- Toolbar -->
+    <div class="toolbar">
+      <div class="toolbar-left">
+        <span class="pill" id="pill-file"></span>
+        <span class="pill pill-accent" id="pill-rows"></span>
+        <span class="pill" id="pill-cols"></span>
+      </div>
+      <div class="toolbar-right">
+        <div class="search-box">
+          <svg class="search-icon" width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5"><circle cx="11" cy="11" r="7"/><line x1="16.5" y1="16.5" x2="21" y2="21"/></svg>
+          <input id="search-input" type="text" placeholder="Search prompts..." spellcheck="false">
+          <span id="search-count" class="search-count"></span>
+        </div>
+        <div class="view-switch">
+          <button class="vs-btn active" data-view="gallery" title="Gallery view">
+            <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><rect x="3" y="3" width="7" height="7"/><rect x="14" y="3" width="7" height="7"/><rect x="3" y="14" width="7" height="7"/><rect x="14" y="14" width="7" height="7"/></svg>
+          </button>
+          <button class="vs-btn" data-view="table" title="Table view">
+            <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><rect x="3" y="3" width="18" height="18" rx="2"/><line x1="3" y1="9" x2="21" y2="9"/><line x1="9" y1="3" x2="9" y2="21"/></svg>
+          </button>
+          <button class="vs-btn" data-view="compare" title="Compare selected">
+            <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><rect x="2" y="3" width="8" height="18" rx="1"/><rect x="14" y="3" width="8" height="18" rx="1"/></svg>
+            <span id="compare-badge" class="vs-badge hidden">0</span>
+          </button>
+        </div>
+      </div>
+    </div>
+
+    <!-- Gallery view -->
+    <section id="view-gallery" class="view">
+      <div class="gallery-toolbar">
+        <label class="gt-label">Image
+          <select id="sel-img-col" class="gt-select"></select>
+        </label>
+        <label class="gt-label">Caption
+          <select id="sel-txt-col" class="gt-select">
+            <option value="">None</option>
+          </select>
+        </label>
+        <label class="gt-label">Size
+          <select id="sel-thumb-size" class="gt-select">
+            <option value="160">S</option>
+            <option value="220" selected>M</option>
+            <option value="320">L</option>
+          </select>
+        </label>
+        <span class="gt-hint">Shift+click to select for compare</span>
+        <span class="spacer"></span>
+        <span id="gallery-page" class="page-label"></span>
+        <button id="gallery-prev" class="page-btn" disabled>
+          <svg width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5"><polyline points="15 18 9 12 15 6"/></svg>
+        </button>
+        <button id="gallery-next" class="page-btn" disabled>
+          <svg width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5"><polyline points="9 18 15 12 9 6"/></svg>
+        </button>
+      </div>
+      <div id="gallery-grid" class="gallery-grid"></div>
+    </section>
+
+    <!-- Table view -->
+    <section id="view-table" class="view hidden">
+      <div class="gallery-toolbar">
+        <label class="gt-label">Rows
+          <select id="sel-page-size" class="gt-select">
+            <option value="25">25</option>
+            <option value="50" selected>50</option>
+            <option value="100">100</option>
+          </select>
+        </label>
+        <span class="spacer"></span>
+        <span id="table-page" class="page-label"></span>
+        <button id="table-prev" class="page-btn" disabled>
+          <svg width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5"><polyline points="15 18 9 12 15 6"/></svg>
+        </button>
+        <button id="table-next" class="page-btn" disabled>
+          <svg width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5"><polyline points="9 18 15 12 9 6"/></svg>
+        </button>
+      </div>
+      <div id="table-container" class="table-wrap"></div>
+    </section>
+
+    <!-- Compare view -->
+    <section id="view-compare" class="view hidden">
+      <div id="compare-empty" class="empty-state">
+        <svg width="28" height="28" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><rect x="2" y="3" width="8" height="18" rx="1"/><rect x="14" y="3" width="8" height="18" rx="1"/></svg>
+        <p>Select images to compare</p>
+        <p class="empty-hint">Shift+click images in the gallery, then return here</p>
+      </div>
+      <div id="compare-content" class="compare-grid hidden"></div>
+    </section>
+  </main>
+
+  <!-- Welcome -->
+  <div id="welcome" class="welcome">
+    <div class="welcome-inner">
+      <div class="welcome-icon">
+        <svg width="40" height="40" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.2" stroke-linecap="round" stroke-linejoin="round"><rect x="3" y="3" width="7" height="7"/><rect x="14" y="3" width="7" height="7"/><rect x="3" y="14" width="7" height="7"/><rect x="14" y="14" width="7" height="7"/></svg>
+      </div>
+      <h2>Open a dataset</h2>
+      <p>Browse or paste a <code>.parquet</code> file path to begin exploring.</p>
+    </div>
+  </div>
+
+  <!-- Detail drawer -->
+  <aside id="drawer" class="drawer">
+    <div class="drawer-head">
+      <span id="drawer-title" class="drawer-title"></span>
+      <div class="drawer-head-actions">
+        <button id="drawer-prev" class="drawer-nav-btn" title="Previous">
+          <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5"><polyline points="15 18 9 12 15 6"/></svg>
+        </button>
+        <button id="drawer-next" class="drawer-nav-btn" title="Next">
+          <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5"><polyline points="9 18 15 12 9 6"/></svg>
+        </button>
+        <button id="drawer-zoom" class="drawer-nav-btn" title="Fullscreen">
+          <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5"><polyline points="15 3 21 3 21 9"/><polyline points="9 21 3 21 3 15"/><line x1="21" y1="3" x2="14" y2="10"/><line x1="3" y1="21" x2="10" y2="14"/></svg>
+        </button>
+        <button id="btn-close-drawer" class="drawer-close" title="Close">&times;</button>
+      </div>
+    </div>
+    <div class="drawer-body">
+      <div class="drawer-image-wrap">
+        <img id="drawer-img" class="drawer-image" alt="">
+      </div>
+      <div class="drawer-content">
+        <div class="drawer-section">
+          <span class="drawer-section-label">Prompt</span>
+          <p id="drawer-prompt" class="drawer-prompt"></p>
+        </div>
+        <div class="drawer-section" id="drawer-meta-section">
+          <span class="drawer-section-label">Metadata</span>
+          <div id="drawer-meta" class="drawer-meta"></div>
+        </div>
+      </div>
+    </div>
+  </aside>
+  <div id="drawer-backdrop" class="backdrop"></div>
+
+  <!-- Loading -->
+  <div id="loading" class="loading hidden">
+    <div class="spinner"></div>
+  </div>
+
+  <!-- Lightbox (fullscreen image) -->
+  <div id="lightbox" class="lightbox">
+    <img id="lb-img" alt="">
+    <button class="lb-close" aria-label="Close">&times;</button>
+  </div>
+
+  <script src="/static/app.js"></script>
+</body>
+</html>

static/style.css

@@ -0,0 +1,871 @@
+/* ═══════════════════════════════════════════════════════════════════════
+   DataView — "Light Table"
+   A dataset explorer for AI image-prompt pairs.
+   Warm parchment palette, editorial typography, image-forward cards.
+   ═══════════════════════════════════════════════════════════════════════ */
+
+:root {
+  --bg:             #F7F4EE;
+  --surface:        #FFFFFF;
+  --surface-raised: #FDFCFA;
+  --border:         #E6E0D6;
+  --border-light:   #EFE9DF;
+  --text:           #2D2A26;
+  --text-secondary: #8C8478;
+  --text-tertiary:  #B5AEA4;
+  --accent:         #8B5C3C;
+  --accent-hover:   #A06A45;
+  --accent-soft:    #F0E6DA;
+  --accent-softer:  #F8F2EB;
+  --danger:         #B54A4A;
+  --sans:           'DM Sans', -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
+  --serif:          'Newsreader', Georgia, 'Times New Roman', serif;
+  --mono:           'JetBrains Mono', 'SF Mono', 'Fira Code', monospace;
+  --radius:         8px;
+  --radius-sm:      5px;
+  --drawer-w:       480px;
+  --shadow-sm:      0 1px 3px rgba(45,42,38,0.06);
+  --shadow-md:      0 4px 16px rgba(45,42,38,0.08);
+  --shadow-lg:      0 8px 32px rgba(45,42,38,0.12);
+  --transition:     180ms ease;
+}
+
+*, *::before, *::after { margin: 0; padding: 0; box-sizing: border-box; }
+
+body {
+  font-family: var(--sans);
+  background: var(--bg);
+  color: var(--text);
+  min-height: 100vh;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+}
+
+::-webkit-scrollbar { width: 5px; height: 5px; }
+::-webkit-scrollbar-track { background: transparent; }
+::-webkit-scrollbar-thumb { background: var(--border); border-radius: 3px; }
+::-webkit-scrollbar-thumb:hover { background: var(--text-tertiary); }
+
+.hidden { display: none !important; }
+.spacer { flex: 1; }
+
+/* ── Header ───────────────────────────────────────────────────────── */
+.header {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  padding: 10px 20px;
+  background: var(--surface);
+  border-bottom: 1px solid var(--border);
+  position: sticky;
+  top: 0;
+  z-index: 100;
+}
+
+.header-btn {
+  display: flex;
+  align-items: center;
+  gap: 5px;
+  padding: 6px 12px;
+  background: var(--bg);
+  color: var(--text-secondary);
+  border: 1px solid var(--border);
+  border-radius: var(--radius-sm);
+  cursor: pointer;
+  font-size: 12.5px;
+  font-family: var(--sans);
+  font-weight: 500;
+  transition: all var(--transition);
+  white-space: nowrap;
+}
+.header-btn:hover { color: var(--text); border-color: var(--text-tertiary); background: var(--surface); }
+
+.path-wrap {
+  flex: 1;
+  display: flex;
+  max-width: 640px;
+  position: relative;
+}
+
+.path-wrap input {
+  width: 100%;
+  padding: 6px 60px 6px 10px;
+  background: var(--bg);
+  border: 1px solid var(--border);
+  border-radius: var(--radius-sm);
+  color: var(--text);
+  font-family: var(--mono);
+  font-size: 12px;
+  outline: none;
+  transition: border-color var(--transition);
+}
+.path-wrap input:focus { border-color: var(--accent); }
+.path-wrap input::placeholder { color: var(--text-tertiary); }
+
+.path-open-btn {
+  position: absolute;
+  right: 1px; top: 1px; bottom: 1px;
+  padding: 0 14px;
+  background: var(--accent);
+  color: #fff;
+  border: none;
+  border-radius: 0 var(--radius-sm) var(--radius-sm) 0;
+  cursor: pointer;
+  font-size: 12px;
+  font-weight: 600;
+  font-family: var(--sans);
+  transition: background var(--transition);
+}
+.path-open-btn:hover { background: var(--accent-hover); }
+
+.wordmark {
+  font-family: var(--mono);
+  font-size: 13px;
+  font-weight: 500;
+  color: var(--text-tertiary);
+  letter-spacing: -0.3px;
+  flex-shrink: 0;
+}
+.wordmark-accent { color: var(--accent); }
+
+/* ── Toolbar ──────────────────────────────────────────────────────── */
+.toolbar {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  padding: 8px 20px;
+  background: var(--surface);
+  border-bottom: 1px solid var(--border);
+  flex-wrap: wrap;
+}
+
+.toolbar-left, .toolbar-right { display: flex; align-items: center; gap: 6px; }
+
+.pill {
+  display: inline-flex;
+  align-items: center;
+  padding: 2px 10px;
+  background: var(--bg);
+  border: 1px solid var(--border);
+  border-radius: 100px;
+  font-size: 11px;
+  font-family: var(--mono);
+  color: var(--text-secondary);
+  white-space: nowrap;
+  line-height: 1.6;
+}
+.pill-accent { color: var(--accent); border-color: var(--accent-soft); background: var(--accent-softer); font-weight: 500; }
+
+.search-box {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  background: var(--bg);
+  border: 1px solid var(--border);
+  border-radius: var(--radius-sm);
+  padding: 0 8px;
+  transition: border-color var(--transition);
+}
+.search-box:focus-within { border-color: var(--accent); }
+
+.search-icon { color: var(--text-tertiary); flex-shrink: 0; }
+
+#search-input {
+  background: none;
+  border: none;
+  color: var(--text);
+  font-family: var(--mono);
+  font-size: 12px;
+  padding: 5px 0;
+  outline: none;
+  width: 160px;
+}
+#search-input::placeholder { color: var(--text-tertiary); }
+
+.search-count {
+  font-size: 10px;
+  font-family: var(--mono);
+  color: var(--text-tertiary);
+}
+
+.view-switch {
+  display: flex;
+  gap: 2px;
+  background: var(--bg);
+  border: 1px solid var(--border);
+  border-radius: var(--radius-sm);
+  padding: 2px;
+}
+
+.vs-btn {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 4px;
+  padding: 5px 8px;
+  background: none;
+  border: none;
+  border-radius: 3px;
+  color: var(--text-tertiary);
+  cursor: pointer;
+  transition: all var(--transition);
+  position: relative;
+}
+.vs-btn:hover { color: var(--text-secondary); }
+.vs-btn.active { color: var(--accent); background: var(--surface); box-shadow: var(--shadow-sm); }
+
+.vs-badge {
+  background: var(--accent);
+  color: #fff;
+  font-size: 9px;
+  font-weight: 600;
+  font-family: var(--mono);
+  padding: 0 4px;
+  border-radius: 6px;
+  min-width: 14px;
+  text-align: center;
+  line-height: 16px;
+}
+
+/* ── Main ─────────────────────────────────────────────────────────── */
+.main { display: flex; flex-direction: column; height: calc(100vh - 93px); }
+.view { flex: 1; overflow: auto; }
+
+.gallery-toolbar {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  padding: 6px 20px;
+  border-bottom: 1px solid var(--border-light);
+  background: var(--surface-raised);
+  position: sticky;
+  top: 0;
+  z-index: 10;
+}
+
+.gt-label {
+  display: flex;
+  align-items: center;
+  gap: 5px;
+  font-size: 11px;
+  color: var(--text-secondary);
+  font-weight: 500;
+}
+
+.gt-select {
+  background: var(--surface);
+  color: var(--text);
+  border: 1px solid var(--border);
+  padding: 3px 6px;
+  border-radius: var(--radius-sm);
+  font-size: 12px;
+  font-family: var(--mono);
+  cursor: pointer;
+}
+
+.gt-hint {
+  font-size: 10.5px;
+  color: var(--text-tertiary);
+  font-style: italic;
+}
+
+.page-label {
+  font-size: 11px;
+  font-family: var(--mono);
+  color: var(--text-secondary);
+}
+
+.page-btn {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 26px;
+  height: 26px;
+  background: var(--surface);
+  color: var(--text-secondary);
+  border: 1px solid var(--border);
+  border-radius: var(--radius-sm);
+  cursor: pointer;
+  transition: all var(--transition);
+}
+.page-btn:hover:not(:disabled) { color: var(--text); border-color: var(--text-tertiary); }
+.page-btn:disabled { opacity: 0.3; cursor: default; }
+
+/* ── Gallery ──────────────────────────────────────────────────────── */
+.gallery-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(220px, 1fr));
+  gap: 12px;
+  padding: 16px 20px;
+}
+
+.card {
+  position: relative;
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: var(--radius);
+  overflow: hidden;
+  cursor: pointer;
+  transition: border-color var(--transition), box-shadow var(--transition), transform var(--transition);
+}
+.card:hover { border-color: var(--text-tertiary); box-shadow: var(--shadow-md); transform: translateY(-1px); }
+.card.selected { border-color: var(--accent); box-shadow: 0 0 0 1px var(--accent), var(--shadow-md); }
+.card.card-open { border-color: var(--accent); background: var(--accent-softer); }
+
+.card-img {
+  width: 100%;
+  aspect-ratio: 1;
+  object-fit: cover;
+  display: block;
+  background: var(--bg);
+}
+
+.card-row {
+  position: absolute;
+  top: 6px;
+  left: 6px;
+  background: rgba(255,255,255,0.92);
+  backdrop-filter: blur(6px);
+  color: var(--text-secondary);
+  padding: 1px 6px;
+  border-radius: 3px;
+  font-size: 10px;
+  font-family: var(--mono);
+  font-weight: 500;
+  pointer-events: none;
+}
+
+.card-dims {
+  position: absolute;
+  bottom: 6px;
+  right: 6px;
+  background: rgba(255,255,255,0.92);
+  backdrop-filter: blur(6px);
+  color: var(--text-tertiary);
+  padding: 1px 6px;
+  border-radius: 3px;
+  font-size: 9px;
+  font-family: var(--mono);
+  pointer-events: none;
+}
+
+.card-check {
+  position: absolute;
+  top: 6px;
+  right: 6px;
+  width: 20px;
+  height: 20px;
+  border-radius: 50%;
+  background: var(--accent);
+  color: #fff;
+  display: none;
+  align-items: center;
+  justify-content: center;
+  font-size: 11px;
+  font-weight: 700;
+  pointer-events: none;
+  box-shadow: var(--shadow-sm);
+}
+.card.selected .card-check { display: flex; }
+
+.card-caption {
+  padding: 8px 10px;
+  font-size: 12px;
+  font-family: var(--serif);
+  color: var(--text-secondary);
+  line-height: 1.45;
+  max-height: 60px;
+  overflow: hidden;
+  border-top: 1px solid var(--border-light);
+}
+
+/* ── Table ────────────────────────────────────────────────────────── */
+.table-wrap {
+  overflow: auto;
+  flex: 1;
+}
+
+.table-wrap table {
+  width: 100%;
+  border-collapse: collapse;
+  font-size: 12px;
+  font-family: var(--mono);
+}
+
+.table-wrap th {
+  padding: 7px 12px;
+  background: var(--surface);
+  color: var(--text-secondary);
+  font-weight: 500;
+  text-align: left;
+  border-bottom: 1px solid var(--border);
+  position: sticky;
+  top: 0;
+  z-index: 5;
+  white-space: nowrap;
+  text-transform: uppercase;
+  font-size: 10px;
+  letter-spacing: 0.4px;
+}
+
+.table-wrap td {
+  padding: 5px 12px;
+  border-bottom: 1px solid var(--border-light);
+  max-width: 360px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  vertical-align: middle;
+}
+
+.table-wrap tbody tr:hover td { background: var(--accent-softer); }
+.table-wrap .cell-null { color: var(--text-tertiary); }
+.table-wrap .row-num { color: var(--text-tertiary); font-size: 10px; user-select: none; }
+
+.cell-thumb {
+  width: 36px;
+  height: 36px;
+  object-fit: cover;
+  border-radius: 3px;
+  display: block;
+  cursor: pointer;
+  border: 1px solid var(--border);
+  transition: transform var(--transition);
+}
+.cell-thumb:hover { transform: scale(1.12); }
+
+/* ── Compare ──────────────────────────────────────────────────────── */
+.empty-state {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  height: 55vh;
+  color: var(--text-tertiary);
+  gap: 10px;
+  text-align: center;
+}
+.empty-state p { font-size: 13px; color: var(--text-secondary); }
+.empty-hint { font-size: 11.5px !important; color: var(--text-tertiary) !important; }
+
+.compare-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(380px, 1fr));
+  gap: 16px;
+  padding: 20px;
+  align-items: start;
+}
+
+.compare-card {
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: var(--radius);
+  overflow: hidden;
+}
+
+.cc-head {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 8px 12px;
+  border-bottom: 1px solid var(--border-light);
+}
+
+.cc-label {
+  font-size: 11px;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.4px;
+  color: var(--accent);
+  font-family: var(--mono);
+}
+
+.cc-remove {
+  background: none;
+  border: none;
+  color: var(--text-tertiary);
+  cursor: pointer;
+  font-size: 16px;
+  padding: 2px 6px;
+  border-radius: 3px;
+  line-height: 1;
+}
+.cc-remove:hover { color: var(--danger); background: rgba(181,74,74,0.06); }
+
+.compare-card img {
+  width: 100%;
+  max-height: 45vh;
+  object-fit: contain;
+  display: block;
+  background: var(--bg);
+  cursor: zoom-in;
+}
+
+.cc-prompt {
+  padding: 12px 14px;
+  font-family: var(--serif);
+  font-size: 13.5px;
+  line-height: 1.55;
+  color: var(--text);
+  border-top: 1px solid var(--border-light);
+  max-height: 140px;
+  overflow-y: auto;
+}
+
+.cc-meta {
+  padding: 8px 14px 12px;
+  border-top: 1px solid var(--border-light);
+}
+
+.cc-meta-row {
+  display: flex;
+  gap: 8px;
+  font-size: 11px;
+  line-height: 1.6;
+}
+.cc-meta-key { color: var(--text-tertiary); font-family: var(--mono); font-size: 10px; min-width: 80px; flex-shrink: 0; }
+.cc-meta-val { color: var(--text-secondary); font-family: var(--mono); font-size: 10px; word-break: break-all; }
+
+/* ── Drawer ───────────────────────────────────────────────────────── */
+.drawer {
+  position: fixed;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  width: var(--drawer-w);
+  background: var(--surface);
+  border-left: 1px solid var(--border);
+  z-index: 200;
+  display: flex;
+  flex-direction: column;
+  transform: translateX(100%);
+  transition: transform 250ms cubic-bezier(0.4, 0, 0.2, 1);
+  box-shadow: -4px 0 24px rgba(45,42,38,0.06);
+}
+.drawer.open { transform: translateX(0); }
+
+.drawer-head {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 10px 16px;
+  border-bottom: 1px solid var(--border);
+  flex-shrink: 0;
+}
+
+.drawer-title {
+  font-size: 12px;
+  font-family: var(--mono);
+  font-weight: 500;
+  color: var(--text-secondary);
+}
+
+.drawer-head-actions {
+  display: flex;
+  align-items: center;
+  gap: 4px;
+}
+
+.drawer-nav-btn {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 26px;
+  height: 26px;
+  background: none;
+  border: 1px solid transparent;
+  border-radius: var(--radius-sm);
+  color: var(--text-tertiary);
+  cursor: pointer;
+  transition: all var(--transition);
+}
+.drawer-nav-btn:hover { color: var(--text); background: var(--bg); border-color: var(--border); }
+
+.drawer-close {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 26px;
+  height: 26px;
+  background: none;
+  border: none;
+  border-radius: var(--radius-sm);
+  color: var(--text-tertiary);
+  cursor: pointer;
+  font-size: 18px;
+  transition: all var(--transition);
+  margin-left: 2px;
+}
+.drawer-close:hover { color: var(--text); background: var(--bg); }
+
+.drawer-body {
+  display: flex;
+  flex-direction: column;
+  height: calc(100vh - 45px);
+  overflow: hidden;
+}
+
+.drawer-image-wrap {
+  flex-shrink: 0;
+  background: var(--bg);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  max-height: 50vh;
+  overflow: hidden;
+  border-bottom: 1px solid var(--border-light);
+}
+
+.drawer-image {
+  max-width: 100%;
+  max-height: 50vh;
+  object-fit: contain;
+  display: block;
+  cursor: zoom-in;
+}
+
+.drawer-content {
+  flex: 1;
+  overflow-y: auto;
+  padding: 16px;
+  display: flex;
+  flex-direction: column;
+  gap: 20px;
+}
+
+.drawer-section-label {
+  display: block;
+  font-size: 10px;
+  font-family: var(--mono);
+  font-weight: 500;
+  text-transform: uppercase;
+  letter-spacing: 0.5px;
+  color: var(--text-tertiary);
+  margin-bottom: 6px;
+}
+
+.drawer-prompt {
+  font-family: var(--serif);
+  font-size: 14.5px;
+  line-height: 1.6;
+  color: var(--text);
+}
+
+.drawer-meta {
+  display: flex;
+  flex-direction: column;
+  gap: 1px;
+}
+
+.drawer-meta-row {
+  display: flex;
+  gap: 10px;
+  font-size: 12px;
+  line-height: 1.7;
+  padding: 2px 0;
+  border-bottom: 1px solid var(--border-light);
+}
+.drawer-meta-row:last-child { border-bottom: none; }
+.drawer-meta-key { color: var(--text-tertiary); font-family: var(--mono); font-size: 11px; min-width: 90px; flex-shrink: 0; }
+.drawer-meta-val { color: var(--text-secondary); font-family: var(--mono); font-size: 11px; word-break: break-all; }
+
+/* ── Sidebar ──────────────────────────────────────────────────────── */
+.sidebar {
+  position: fixed;
+  left: 0; top: 0; bottom: 0;
+  width: 340px;
+  background: var(--surface);
+  border-right: 1px solid var(--border);
+  z-index: 200;
+  display: flex;
+  flex-direction: column;
+  transform: translateX(-100%);
+  transition: transform 0.22s ease;
+}
+.sidebar.open { transform: translateX(0); }
+
+.backdrop {
+  position: fixed;
+  inset: 0;
+  background: rgba(45,42,38,0.18);
+  z-index: 199;
+  display: none;
+  backdrop-filter: blur(1px);
+}
+.backdrop.open { display: block; }
+
+.sidebar-head {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 10px 14px;
+  border-bottom: 1px solid var(--border);
+}
+
+.sidebar-label {
+  font-size: 11.5px;
+  font-weight: 600;
+  color: var(--text-secondary);
+}
+
+.btn-icon {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 26px;
+  height: 26px;
+  background: none;
+  border: 1px solid transparent;
+  border-radius: var(--radius-sm);
+  color: var(--text-tertiary);
+  cursor: pointer;
+  font-size: 18px;
+}
+.btn-icon:hover { color: var(--text); background: var(--bg); border-color: var(--border); }
+
+.breadcrumb {
+  display: flex;
+  align-items: center;
+  gap: 2px;
+  padding: 6px 14px;
+  font-size: 11px;
+  font-family: var(--mono);
+  color: var(--text-secondary);
+  border-bottom: 1px solid var(--border-light);
+  overflow-x: auto;
+  white-space: nowrap;
+  flex-shrink: 0;
+}
+
+.breadcrumb-item { cursor: pointer; padding: 2px 4px; border-radius: 3px; }
+.breadcrumb-item:hover { background: var(--bg); color: var(--text); }
+.breadcrumb-sep { color: var(--text-tertiary); margin: 0 1px; }
+
+.folder-list { flex: 1; overflow-y: auto; padding: 4px 0; }
+
+.folder-entry {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  padding: 5px 14px;
+  cursor: pointer;
+  transition: background var(--transition);
+}
+.folder-entry:hover { background: var(--bg); }
+
+.folder-entry .fe-icon { width: 16px; text-align: center; flex-shrink: 0; font-size: 13px; }
+.folder-entry .fe-name { flex: 1; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; font-family: var(--mono); font-size: 12px; }
+.folder-entry .fe-meta { font-size: 10px; font-family: var(--mono); color: var(--text-tertiary); flex-shrink: 0; }
+
+.folder-entry.is-dir .fe-name { color: var(--text); }
+.folder-entry.is-dataset .fe-name { color: var(--accent); font-weight: 500; }
+.folder-entry.is-file .fe-name { color: var(--text-secondary); }
+.folder-entry.is-dataset .fe-icon { color: var(--accent); }
+.folder-entry.is-dir .fe-icon { color: var(--text-secondary); }
+.folder-entry.is-file .fe-icon { color: var(--text-tertiary); }
+.folder-entry.is-parent { color: var(--text-secondary); border-bottom: 1px solid var(--border-light); margin-bottom: 4px; }
+.folder-entry.is-parent .fe-icon { color: var(--text-tertiary); }
+
+/* ── Welcome ──────────────────────────────────────────────────────── */
+.welcome {
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  min-height: calc(100vh - 52px);
+  padding: 40px 20px;
+}
+.welcome-inner { text-align: center; }
+.welcome-icon { color: var(--text-tertiary); margin-bottom: 16px; opacity: 0.35; }
+.welcome-inner h2 { font-size: 20px; font-weight: 600; color: var(--text); margin-bottom: 6px; }
+.welcome-inner p { font-size: 14px; color: var(--text-secondary); }
+.welcome-inner code {
+  padding: 1px 5px;
+  background: var(--bg);
+  border: 1px solid var(--border);
+  border-radius: 3px;
+  font-family: var(--mono);
+  font-size: 12px;
+  color: var(--text-secondary);
+}
+
+/* ── Lightbox ─────────────────────────────────────────────────────── */
+.lightbox {
+  display: none;
+  position: fixed;
+  inset: 0;
+  background: rgba(45,42,38,0.92);
+  z-index: 300;
+  justify-content: center;
+  align-items: center;
+  cursor: zoom-out;
+  backdrop-filter: blur(4px);
+}
+.lightbox.active { display: flex; }
+
+.lightbox img {
+  max-width: 92vw;
+  max-height: 92vh;
+  object-fit: contain;
+  border-radius: var(--radius);
+  box-shadow: 0 12px 48px rgba(0,0,0,0.25);
+}
+
+.lb-close {
+  position: absolute;
+  top: 14px;
+  right: 14px;
+  width: 34px;
+  height: 34px;
+  background: rgba(255,255,255,0.1);
+  border: 1px solid rgba(255,255,255,0.15);
+  border-radius: 50%;
+  color: rgba(255,255,255,0.7);
+  font-size: 18px;
+  cursor: pointer;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  transition: all var(--transition);
+  backdrop-filter: blur(8px);
+}
+.lb-close:hover { background: rgba(255,255,255,0.18); color: #fff; }
+
+/* ── Loading ──────────────────────────────────────────────────────── */
+.loading {
+  position: fixed;
+  inset: 0;
+  background: rgba(247,244,238,0.6);
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  z-index: 400;
+  backdrop-filter: blur(2px);
+}
+
+.spinner {
+  width: 24px;
+  height: 24px;
+  border: 2px solid var(--border);
+  border-top-color: var(--accent);
+  border-radius: 50%;
+  animation: spin 0.65s linear infinite;
+}
+
+@keyframes spin { to { transform: rotate(360deg); } }
+
+/* ── Responsive ───────────────────────────────────────────────────── */
+@media (max-width: 768px) {
+  .sidebar { width: 100%; }
+  .gallery-grid { grid-template-columns: repeat(auto-fill, minmax(150px, 1fr)); gap: 8px; padding: 12px; }
+  .compare-grid { grid-template-columns: 1fr; }
+  .drawer { width: 100%; }
+  .toolbar { padding: 6px 12px; }
+  .gallery-toolbar { padding: 6px 12px; }
+  .gt-hint { display: none; }
+  #search-input { width: 120px; }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  *, *::before, *::after { transition-duration: 0ms !important; animation-duration: 0ms !important; }
+}