Adds source files.

.gitattributes

@@ -58,3 +58,10 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+
+# Dataset specific files
+*.jsonl filter=lfs diff=lfs merge=lfs -text
+*.json filter=lfs diff=lfs merge=lfs -text
+*.ork filter=lfs diff=lfs merge=lfs -text
+*.rkt filter=lfs diff=lfs merge=lfs -text
+*.csv filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,72 @@
+# macOS
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+*.egg
+*.egg-info/
+dist/
+build/
+eggs/
+parts/
+var/
+sdist/
+wheels/
+*.egg-link
+.installed.cfg
+
+# Virtual environments
+.venv/
+venv/
+env/
+ENV/
+
+# uv
+.uv/
+
+# Distribution / packaging
+MANIFEST
+
+# Unit test / coverage
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Jupyter Notebooks
+.ipynb_checkpoints/
+*.ipynb
+
+# Environment variables
+.env
+.env.*
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# Logs
+*.log
+logs/
+
+# Data / output files
+*.csv
+*.parquet
+*.jsonl
+data/
+output/

README.md

@@ -0,0 +1,86 @@
+# RocketReviews Dataset
+
+A structured dataset scraped from [RocketReviews.com](https://www.rocketreviews.com) for use in AI/ML pipelines and vector databases.
+
+---
+
+## Collection Status
+
+Legend: `[ ]` not started · `[~]` in progress · `[x]` complete
+
+### Primary Tables
+
+| Table | Description | Script | Output | Status |
+|-------|-------------|--------|--------|--------|
+| `reviews` | Kit and product reviews with ratings and text sections | `scripts/reviews/01_scrape.py` | `source/reviews/` | `[~]` |
+| `flights` | Member flight logs with conditions and notes | `scripts/flights/01_scrape.py` | `source/flights/` | `[~]` |
+| `products` | Full product catalog (kits, motors, components, software, etc.) | `scripts/products/01_scrape.py` | `source/products/` | `[ ]` |
+| `motors` | Motor specifications with thrust and performance data | `scripts/motors/01_scrape.py` | `source/motors/` | `[~]` |
+| `designs` | OpenRocket (.ork) and RockSim (.rkt) design files | `scripts/designs/01_scrape.py` | `source/designs/` | `[~]` |
+| `plans` | Rocket plans and build instructions | `scripts/plans/01_scrape.py` | `source/plans/` | `[~]` |
+| `clubs` | Rocketry clubs directory | `scripts/clubs/01_scrape.py` | `source/clubs/` | `[~]` |
+| `glossary` | Rocketry terms and definitions | `scripts/glossary/01_scrape.py` | `source/glossary/` | `[~]` |
+
+### Relational Tables
+
+| Table | Description | Script | Output | Status | Used By |
+|-------|-------------|--------|--------|--------|---------|
+| `manufacturers` | Rocket kit and product manufacturers | `scripts/manufacturers/01_scrape.py` | `source/manufacturers/` | `[~]` | `products`, `reviews` |
+| `designers` | Rocket designers linked to products | `scripts/designers/01_scrape.py` | `source/designers/` | `[ ]` | `products` |
+| `contributors` | Site members who write reviews | `scripts/contributors/01_scrape.py` | `source/contributors/` | `[ ]` | `reviews` |
+
+### Lookup Tables
+
+| Table | Description | Script | Output | Status | Used By |
+|-------|-------------|--------|--------|--------|---------|
+| `styles` | Rocket style classifications (Sport, Scale, Upscale, etc.) | `scripts/styles/01_scrape.py` | `source/styles/` | `[ ]` | `products` |
+| `recovery_types` | Recovery method types (Parachute, Streamer, Glide, etc.) | `scripts/recovery_types/01_scrape.py` | `source/recovery_types/` | `[ ]` | `products` |
+| `power_classes` | Motor power classifications (Low, Mid, High Power, etc.) | `scripts/power_classes/01_scrape.py` | `source/power_classes/` | `[ ]` | `products` |
+| `cp_library` | Center of pressure data per product | `scripts/cp_library/01_scrape.py` | `source/cp_library/` | `[ ]` | `products` |
+
+---
+
+## Source Layout
+
+```
+source/
+  reviews/
+    index.jsonl
+    detail/{id}.json
+  products/
+    index.jsonl
+    detail/{id}.json
+  motors/
+    index.jsonl
+    detail/{id}.json
+  designs/
+    index.jsonl
+    detail/{id}.json
+    files/
+      ork/
+      rkt/
+  flights/
+    index.jsonl
+    detail/{id}.json
+  plans/
+    index.jsonl
+  clubs/
+    index.jsonl
+  glossary/
+    index.jsonl
+    detail/{slug}.json
+  manufacturers/
+    index.jsonl
+  designers/
+    index.jsonl
+  contributors/
+    index.jsonl
+  styles/
+    index.jsonl
+  recovery_types/
+    index.jsonl
+  power_classes/
+    index.jsonl
+  cp_library/
+    index.jsonl
+```

pyproject.toml

@@ -4,4 +4,9 @@ version = "0.1.0"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.10"
-dependencies = []
+dependencies = [
+    "requests>=2.31.0",
+    "beautifulsoup4>=4.12.0",
+    "urllib3>=2.0.0",
+    "lxml>=4.9.0",
+]

scripts/clubs/01_scrape.py

@@ -0,0 +1,359 @@
+#!/usr/bin/env python3
+"""
+scrape_clubs.py — Fetch the RocketReviews.com rocketry clubs index and scrape each
+detail page, saving structured JSON to source/clubs/.
+
+Output
+------
+    source/clubs/index.jsonl        one record per club (raw index fields)
+    source/clubs/detail/{id}.json   full parsed detail per club
+
+Usage
+-----
+    python scripts/clubs/01_scrape.py
+    python scripts/clubs/01_scrape.py --delay 1.0 --limit 10
+    python scripts/clubs/01_scrape.py --force   # re-scrape existing files
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import re
+import sys
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional
+from urllib.parse import quote
+
+import requests
+from bs4 import BeautifulSoup
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+
+# ---------------------------------------------------------------------------
+# Config
+# ---------------------------------------------------------------------------
+
+BASE_URL = "https://www.rocketreviews.com"
+INDEX_URL = f"{BASE_URL}/index.php?action=clubs&lat=x&lon=x"
+USER_AGENT = "RocketReviews-Dataset/1.0"
+DEFAULT_DELAY = 1.0
+
+ROOT = Path(__file__).parent.parent.parent
+SOURCE_DIR = ROOT / "source" / "clubs"
+DETAIL_DIR = SOURCE_DIR / "detail"
+
+# ---------------------------------------------------------------------------
+# Logging
+# ---------------------------------------------------------------------------
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s %(levelname)s %(message)s",
+    handlers=[logging.StreamHandler(sys.stdout)],
+)
+log = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# HTTP session
+# ---------------------------------------------------------------------------
+
+
+def _build_session() -> requests.Session:
+    s = requests.Session()
+    s.headers["User-Agent"] = USER_AGENT
+    retry = Retry(
+        total=3,
+        backoff_factor=2.0,
+        status_forcelist=[429, 500, 502, 503, 504],
+        allowed_methods=["GET"],
+    )
+    s.mount("https://", HTTPAdapter(max_retries=retry))
+    s.mount("http://", HTTPAdapter(max_retries=retry))
+    return s
+
+
+class RateLimiter:
+    def __init__(self, delay: float) -> None:
+        self.delay = delay
+        self._last: float = 0.0
+
+    def wait(self) -> None:
+        elapsed = time.monotonic() - self._last
+        if elapsed < self.delay:
+            time.sleep(self.delay - elapsed)
+        self._last = time.monotonic()
+
+
+# ---------------------------------------------------------------------------
+# Parsing helpers
+# ---------------------------------------------------------------------------
+
+def _normalize_string(val: Optional[str]) -> Optional[str]:
+    if not val:
+        return None
+    val = val.strip()
+    if val in ("-Unknown-", "-", "", "Unknown"):
+        return None
+    return val
+
+def _parse_index(html: str) -> list[dict]:
+    """
+    Parse the index.php?action=clubs page to extract the inline JSON array
+    containing the club index records.
+    """
+    m = re.search(r"data\s*=\s*(\[.*?\]);", html, re.DOTALL)
+    if not m:
+        log.warning("Could not find the clubs data array in the index HTML.")
+        return []
+
+    data_str = m.group(1)
+    
+    # The JSON array embedded in the page uses single quotes, making it invalid strict JSON.
+    # We must manually parse or convert it to double quotes carefully.
+    # To be safe from inner single quotes, we can parse using an eval-like approach or regex substitution.
+    # Since we know the structure is a list of flat dicts, let's clean it up:
+    
+    # Replace single quotes enclosing keys/values with double quotes, being careful of internal ones
+    def _repair_json(s: str) -> str:
+        # replace {' with {"
+        s = re.sub(r"\{\s*'", '{"', s)
+        # replace ': with ":
+        s = re.sub(r"'\s*:", '":', s)
+        # replace , ' with , "
+        s = re.sub(r",\s*'", ', "', s)
+        # replace ': ' with ": "
+        s = re.sub(r":\s*'", ': "', s)
+        # replace '} with "}
+        s = re.sub(r"'\s*\}", '"}', s)
+        # replace ', with ",
+        s = re.sub(r"'\s*,", '",', s)
+        return s
+        
+    try:
+        # We might still have issues if there are apostrophes inside the strings.
+        # Python's ast.literal_eval is safer for single-quoted Python dict representations.
+        import ast
+        records = ast.literal_eval(data_str)
+    except Exception as exc:
+        log.warning("Failed to parse embedded JSON with ast.literal_eval, falling back to manual: %s", exc)
+        try:
+            records = json.loads(_repair_json(data_str))
+        except json.JSONDecodeError as exc2:
+            log.error("Failed to parse clubs JSON entirely: %s", exc2)
+            return []
+
+    cleaned_records = []
+    for rec in records:
+        club_id = int(rec["id"])
+        raw_title = rec.get("title", "")
+        
+        # Determine affiliations based on logo tags embedded in the title string
+        has_nar = "NAR-Logo" in raw_title
+        has_tripoli = "Tripoli-Logo" in raw_title
+        
+        # Clean title
+        title = raw_title.replace("NAR-Logo", "").replace("Tripoli-Logo", "").strip()
+        
+        # The site dynamically constructs the redirect URL:
+        # index.php?autoredir={encoded_title}&action=displayclub&clubid={id}
+        url = f"{BASE_URL}/index.php?autoredir={quote(title)}&action=displayclub&clubid={club_id}"
+        
+        cleaned_records.append({
+            "id": club_id,
+            "name": title,
+            "city": _normalize_string(rec.get("city")),
+            "state": _normalize_string(rec.get("state")),
+            "country": _normalize_string(rec.get("country")),
+            "has_nar": has_nar,
+            "has_tripoli": has_tripoli,
+            "url": url  # Note: this is a redirect URL. Detail parsing will resolve the canonical URL.
+        })
+
+    return cleaned_records
+
+
+def _parse_detail(html: str, index_rec: dict, resolved_url: str) -> dict:
+    """Merge index-level fields with full detail page information."""
+    soup = BeautifulSoup(html, "lxml")
+    
+    data = {
+        **index_rec,
+        "url": resolved_url,
+        "scraped_at": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+        "nar_section": None,
+        "tripoli_prefecture": None,
+        "website": None,
+        "location": None,
+        "description": None
+    }
+    
+    # Try to grab the exact clean title from the h2 (removes external link image)
+    h2 = soup.find('h2')
+    if h2:
+        data["name"] = _normalize_string(h2.get_text(strip=True))
+
+    ul = soup.find('ul', class_='mt-1')
+    if ul:
+        for li in ul.find_all('li'):
+            text = li.get_text(separator=' ', strip=True)
+            if ':' in text:
+                key, val = [part.strip() for part in text.split(':', 1)]
+                key_lower = key.lower()
+                if "nar" in key_lower:
+                    try:
+                        data["nar_section"] = int(re.sub(r"[^\d]", "", val))
+                    except ValueError:
+                        pass
+                elif "tripoli" in key_lower:
+                    try:
+                        data["tripoli_prefecture"] = int(re.sub(r"[^\d]", "", val))
+                    except ValueError:
+                        pass
+                elif "web site" in key_lower or "website" in key_lower:
+                    data["website"] = val if val.startswith("http") else f"http://{val}"
+                elif "location" in key_lower:
+                    data["location"] = val
+
+    # Try to get the descriptive text
+    # Usually it's in a <p> tag without a class containing the club name.
+    for p in soup.find_all('p'):
+        text = p.get_text(separator=' ', strip=True)
+        if data.get('name') and data['name'] in text and 'What You Can Do' not in text:
+            data['description'] = text
+            break
+            
+    return data
+
+
+# ---------------------------------------------------------------------------
+# Fetch helpers
+# ---------------------------------------------------------------------------
+
+
+def fetch_index(session: requests.Session) -> list[dict]:
+    log.info("Fetching clubs index from %s", INDEX_URL)
+    resp = session.get(INDEX_URL, timeout=30)
+    resp.raise_for_status()
+    records = _parse_index(resp.text)
+    log.info("Index returned %d records.", len(records))
+    return records
+
+
+def scrape_detail(
+    session: requests.Session,
+    rate: RateLimiter,
+    index_rec: dict,
+    force: bool = False,
+) -> Optional[dict]:
+    club_id = index_rec["id"]
+    dest = DETAIL_DIR / f"{club_id:06d}.json"
+
+    if dest.exists() and not force:
+        log.debug("Already scraped %s, skipping.", club_id)
+        return None
+
+    url = index_rec["url"]
+    rate.wait()
+
+    try:
+        # This request will automatically follow the index.php?autoredir= redirect
+        # to the clean SEO URL (e.g. /4-corners-rocketry-association.html)
+        resp = session.get(url, timeout=30)
+        resp.raise_for_status()
+    except requests.RequestException as exc:
+        log.warning("Failed to fetch club %s: %s", club_id, exc)
+        return None
+
+    return _parse_detail(resp.text, index_rec, resp.url)
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Scrape RocketReviews.com rocketry clubs.")
+    parser.add_argument(
+        "--delay",
+        type=float,
+        default=DEFAULT_DELAY,
+        help=f"Seconds between requests (default: {DEFAULT_DELAY})",
+    )
+    parser.add_argument(
+        "--limit",
+        type=int,
+        default=None,
+        help="Stop after scraping this many detail pages (useful for testing)",
+    )
+    parser.add_argument(
+        "--force",
+        action="store_true",
+        help="Re-scrape clubs that already have a saved detail file",
+    )
+    args = parser.parse_args()
+
+    SOURCE_DIR.mkdir(parents=True, exist_ok=True)
+    DETAIL_DIR.mkdir(parents=True, exist_ok=True)
+
+    session = _build_session()
+    rate = RateLimiter(args.delay)
+
+    # ------------------------------------------------------------------
+    # Step 1: fetch index and write index.jsonl
+    # ------------------------------------------------------------------
+    records = fetch_index(session)
+
+    scraped_at = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+    index_path = SOURCE_DIR / "index.jsonl"
+    with index_path.open("w", encoding="utf-8") as f:
+        for rec in records:
+            f.write(json.dumps({**rec, "scraped_at": scraped_at}) + "\n")
+    log.info("Wrote %d index records to %s", len(records), index_path)
+
+    # ------------------------------------------------------------------
+    # Step 2: scrape each detail page
+    # ------------------------------------------------------------------
+    if args.limit:
+        records = records[: args.limit]
+
+    ok = skipped = failed = 0
+    total = len(records)
+
+    for i, rec in enumerate(records, 1):
+        result = scrape_detail(session, rate, rec, force=args.force)
+
+        if result is None:
+            skipped += 1
+            continue
+
+        dest = DETAIL_DIR / f"{rec['id']:06d}.json"
+        try:
+            dest.write_text(
+                json.dumps(result, indent=2, ensure_ascii=False), encoding="utf-8"
+            )
+            ok += 1
+            log.debug("Saved %s", dest.name)
+        except OSError as exc:
+            log.warning("Could not write %s: %s", dest, exc)
+            failed += 1
+
+        if i % 25 == 0 or i == total:
+            log.info(
+                "Progress: %d/%d — ok=%d  skipped=%d  failed=%d",
+                i,
+                total,
+                ok,
+                skipped,
+                failed,
+            )
+
+    log.info("Done — ok=%d  skipped=%d  failed=%d", ok, skipped, failed)
+
+
+if __name__ == "__main__":
+    main()

scripts/designs/01_scrape.py

@@ -0,0 +1,422 @@
+#!/usr/bin/env python3
+"""
+scrape_designs.py — Fetch the RocketReviews.com OpenRocket and RockSim indexes
+and scrape each detail page, downloading the binary design file and saving
+structured JSON metadata to source/designs/.
+
+Output
+------
+    source/designs/index.jsonl           one record per design (raw index fields)
+    source/designs/detail/{id}.json      full parsed metadata per design
+    source/designs/files/ork/{id}.ork    downloaded OpenRocket files
+    source/designs/files/rkt/{id}.rkt    downloaded RockSim files
+
+Usage
+-----
+    python scripts/designs/01_scrape.py
+    python scripts/designs/01_scrape.py --delay 1.0 --limit 10
+    python scripts/designs/01_scrape.py --force   # re-scrape existing files
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import re
+import sys
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional, Tuple
+
+import requests
+from bs4 import BeautifulSoup
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+
+# ---------------------------------------------------------------------------
+# Config
+# ---------------------------------------------------------------------------
+
+BASE_URL = "https://www.rocketreviews.com"
+ENDPOINTS = [
+    {
+        "format": "openrocket",
+        "url": f"{BASE_URL}/data/openrocket/openrocket.php?search=&optimized=&type=",
+        "ext": "ork"
+    },
+    {
+        "format": "rocksim",
+        "url": f"{BASE_URL}/data/rocksim/rocksim.php?search=&optimized=&type=",
+        "ext": "rkt"
+    }
+]
+
+USER_AGENT = "RocketReviews-Dataset/1.0"
+DEFAULT_DELAY = 1.0
+
+ROOT = Path(__file__).parent.parent.parent
+SOURCE_DIR = ROOT / "source" / "designs"
+DETAIL_DIR = SOURCE_DIR / "detail"
+FILES_DIR = SOURCE_DIR / "files"
+
+# ---------------------------------------------------------------------------
+# Logging
+# ---------------------------------------------------------------------------
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s %(levelname)s %(message)s",
+    handlers=[logging.StreamHandler(sys.stdout)],
+)
+log = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# HTTP session
+# ---------------------------------------------------------------------------
+
+
+def _build_session() -> requests.Session:
+    s = requests.Session()
+    s.headers["User-Agent"] = USER_AGENT
+    retry = Retry(
+        total=3,
+        backoff_factor=2.0,
+        status_forcelist=[429, 500, 502, 503, 504],
+        allowed_methods=["GET"],
+    )
+    s.mount("https://", HTTPAdapter(max_retries=retry))
+    s.mount("http://", HTTPAdapter(max_retries=retry))
+    return s
+
+
+class RateLimiter:
+    def __init__(self, delay: float) -> None:
+        self.delay = delay
+        self._last: float = 0.0
+
+    def wait(self) -> None:
+        elapsed = time.monotonic() - self._last
+        if elapsed < self.delay:
+            time.sleep(self.delay - elapsed)
+        self._last = time.monotonic()
+
+
+# ---------------------------------------------------------------------------
+# Parsing helpers
+# ---------------------------------------------------------------------------
+
+def _normalize_string(val: Optional[str]) -> Optional[str]:
+    if not val:
+        return None
+    val = val.strip()
+    if val in ("-Unknown-", "-", "", "Unknown"):
+        return None
+    return val
+
+def _parse_measure(text: Optional[str]) -> Tuple[Optional[float], Optional[str]]:
+    """Parse '28.6470 inches from front' -> (28.647, 'Front')"""
+    if not text:
+        return None, None
+    m = re.search(r"([\d\.]+)\s+inches\s+from\s+(front|rear)", text, re.I)
+    if m:
+        return float(m.group(1)), m.group(2).title()
+    return None, None
+
+def _parse_margin(text: Optional[str]) -> Tuple[Optional[float], Optional[str]]:
+    """Parse '4.03 Overstable' -> (4.03, 'Overstable')"""
+    if not text:
+        return None, None
+    m = re.search(r"([\d\.]+)\s+(\w+)", text)
+    if m:
+        return float(m.group(1)), m.group(2).title()
+    return None, None
+
+def _extract_person(soup: BeautifulSoup, label: str) -> Optional[dict]:
+    """
+    Extract a person (Contributor or Designer) and their URL.
+    Checks for <strong>Designer:</strong> Name or Contributed by <a href="...">Name</a>
+    """
+    # Look for <strong>Label:</strong>
+    strong = soup.find("strong", string=re.compile(rf"{label}:?", re.I))
+    if strong:
+        # The name might be in the next sibling or a link
+        a_tag = strong.find_next_sibling("a")
+        if a_tag and a_tag.get("href"):
+            name = a_tag.get_text(strip=True)
+            url = a_tag["href"] if a_tag["href"].startswith("http") else f"{BASE_URL}{a_tag['href']}"
+            return {"name": _normalize_string(name), "url": url}
+        elif strong.next_sibling:
+            name = strong.next_sibling.get_text(strip=True) if hasattr(strong.next_sibling, "get_text") else str(strong.next_sibling).strip()
+            return {"name": _normalize_string(name), "url": None}
+            
+    # Look for inline text like "Contributed by Name" or "Designer: Name"
+    text_node = soup.find(string=re.compile(rf"{label}", re.I))
+    if text_node and text_node.parent.name in ("p", "div"):
+        parent = text_node.parent
+        a_tag = parent.find("a")
+        if a_tag and a_tag.get("href"):
+            name = a_tag.get_text(strip=True)
+            url = a_tag["href"] if a_tag["href"].startswith("http") else f"{BASE_URL}{a_tag['href']}"
+            return {"name": _normalize_string(name), "url": url}
+        
+        raw_text = parent.get_text(strip=True)
+        name = re.sub(rf"{label}(?: by)?:?\s*", "", raw_text, flags=re.I).strip()
+        return {"name": _normalize_string(name), "url": None}
+
+    return None
+
+def _parse_detail(html: str, index_rec: dict, format_ext: str) -> dict:
+    soup = BeautifulSoup(html, "lxml")
+    
+    # Find download URL
+    dl_link = soup.find('a', href=lambda h: h and ('/file-' in h))
+    file_url = None
+    if dl_link:
+        href = dl_link['href']
+        file_url = href if href.startswith("http") else f"{BASE_URL}{href}"
+        
+    # Find external URL (e.g. Rocketry Forum, Ye Olde Rocket Forum)
+    external_url = None
+    for img in soup.find_all('img', src=lambda s: s and 'download.gif' in s):
+        a = img.find_parent('a')
+        if a and a.get('href') and '/file-' not in a['href']:
+            external_url = a['href']
+            break
+            
+    if not external_url:
+        ext_link = soup.find('a', href=lambda h: h and 'rocketryforum.com' in h.lower())
+        external_url = ext_link['href'] if ext_link else None
+        
+    # People
+    contributor = _extract_person(soup, "Contributed")
+    designer = _extract_person(soup, "Designer")
+    
+    # Metrics
+    cg_raw, cp_raw, margin_raw, comments = None, None, None, None
+    for b in soup.find_all(['b', 'strong']):
+        text = b.get_text(strip=True)
+        if "CG:" in text:
+            cg_raw = b.next_sibling.strip() if b.next_sibling and isinstance(b.next_sibling, str) else b.parent.get_text(strip=True).replace("CG:", "").strip()
+        elif "CP:" in text:
+            cp_raw = b.next_sibling.strip() if b.next_sibling and isinstance(b.next_sibling, str) else b.parent.get_text(strip=True).replace("CP:", "").strip()
+        elif "Margin:" in text:
+            margin_raw = b.next_sibling.strip() if b.next_sibling and isinstance(b.next_sibling, str) else b.parent.get_text(strip=True).replace("Margin:", "").strip()
+        elif "Comments:" in text:
+            comments = b.next_sibling.strip() if b.next_sibling and isinstance(b.next_sibling, str) else b.parent.get_text(strip=True).replace("Comments:", "").strip()
+
+    cg_loc, cg_from = _parse_measure(cg_raw)
+    cp_loc, cp_from = _parse_measure(cp_raw)
+    margin_val, margin_status = _parse_margin(margin_raw)
+
+    design_id = int(index_rec["id"])
+    local_path = f"files/{format_ext}/{design_id:06d}.{format_ext}"
+
+    return {
+        "id": design_id,
+        "format": index_rec["format"],
+        "name": _normalize_string(index_rec.get("name")),
+        "title": _normalize_string(index_rec.get("title")),
+        "type": _normalize_string(index_rec.get("type")),
+        "optimized": _normalize_string(index_rec.get("optimized")),
+        "manufacturer": _normalize_string(index_rec.get("manufacturer")),
+        "added_date": index_rec.get("added"),
+        "url": index_rec.get("url"),
+        "scraped_at": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+        "contributor": contributor,
+        "designer": designer,
+        "comments": _normalize_string(comments),
+        "cg": {"location_in": cg_loc, "location_from": cg_from} if cg_loc is not None else None,
+        "cp": {"location_in": cp_loc, "location_from": cp_from} if cp_loc is not None else None,
+        "margin": margin_val,
+        "margin_status": margin_status,
+        "file_url": file_url,
+        "external_url": external_url,
+        "local_path": local_path if file_url else None
+    }
+
+
+# ---------------------------------------------------------------------------
+# Fetch helpers
+# ---------------------------------------------------------------------------
+
+def fetch_index(session: requests.Session, endpoint: dict) -> list[dict]:
+    log.info("Fetching %s index from %s", endpoint["format"], endpoint["url"])
+    resp = session.get(endpoint["url"], timeout=30)
+    resp.raise_for_status()
+    records = resp.json().get("records", [])
+    
+    # Normalize index record to add format and construct full URL
+    normalized = []
+    for rec in records:
+        path = rec.get("url", "")
+        url = f"{BASE_URL}{path}" if path.startswith("/") else path
+        normalized.append({
+            **rec,
+            "format": endpoint["format"],
+            "url": url,
+            "_ext": endpoint["ext"] # internal use
+        })
+        
+    log.info("Index returned %d records for %s.", len(normalized), endpoint["format"])
+    return normalized
+
+def download_file(session: requests.Session, url: str, dest: Path) -> bool:
+    """Download a file streaming to disk. Returns True if successful."""
+    try:
+        with session.get(url, stream=True, timeout=30) as r:
+            r.raise_for_status()
+            with dest.open("wb") as f:
+                for chunk in r.iter_content(chunk_size=8192):
+                    f.write(chunk)
+        return True
+    except requests.RequestException as exc:
+        log.warning("Failed to download file %s: %s", url, exc)
+        # Clean up partial file
+        if dest.exists():
+            dest.unlink()
+        return False
+
+def scrape_detail(
+    session: requests.Session,
+    rate: RateLimiter,
+    index_rec: dict,
+    force: bool = False,
+) -> Optional[dict]:
+    design_id = int(index_rec["id"])
+    dest_json = DETAIL_DIR / f"{design_id:06d}.json"
+    format_ext = index_rec["_ext"]
+    dest_file = FILES_DIR / format_ext / f"{design_id:06d}.{format_ext}"
+
+    if dest_json.exists() and not force:
+        try:
+            with dest_json.open("r", encoding="utf-8") as f:
+                cached = json.load(f)
+            if cached.get("local_path") is None or dest_file.exists():
+                log.debug("Already scraped %s, skipping.", design_id)
+                return None
+        except (OSError, json.JSONDecodeError):
+            pass
+
+    url = index_rec["url"]
+    rate.wait()
+
+    try:
+        resp = session.get(url, timeout=30)
+        resp.raise_for_status()
+    except requests.RequestException as exc:
+        log.warning("Failed to fetch design %s: %s", design_id, exc)
+        return None
+
+    # Parse metadata
+    metadata = _parse_detail(resp.text, index_rec, format_ext)
+    
+    # Download file if URL found
+    file_url = metadata.get("file_url")
+    if file_url:
+        rate.wait()
+        success = download_file(session, file_url, dest_file)
+        if not success:
+            log.warning("Could not download binary file for %s, skipping metadata.", design_id)
+            return None
+    elif metadata.get("external_url"):
+        log.info("No direct file for %s, but external link found. Saving metadata.", design_id)
+    else:
+        log.warning("No file download link or external link found for %s on page %s", design_id, url)
+
+    return metadata
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Scrape RocketReviews.com designs (OpenRocket & RockSim).")
+    parser.add_argument(
+        "--delay",
+        type=float,
+        default=DEFAULT_DELAY,
+        help=f"Seconds between requests (default: {DEFAULT_DELAY})",
+    )
+    parser.add_argument(
+        "--limit",
+        type=int,
+        default=None,
+        help="Stop after scraping this many detail pages (useful for testing)",
+    )
+    parser.add_argument(
+        "--force",
+        action="store_true",
+        help="Re-scrape designs that already have saved files",
+    )
+    args = parser.parse_args()
+
+    SOURCE_DIR.mkdir(parents=True, exist_ok=True)
+    DETAIL_DIR.mkdir(parents=True, exist_ok=True)
+    (FILES_DIR / "ork").mkdir(parents=True, exist_ok=True)
+    (FILES_DIR / "rkt").mkdir(parents=True, exist_ok=True)
+
+    session = _build_session()
+    rate = RateLimiter(args.delay)
+
+    # ------------------------------------------------------------------
+    # Step 1: fetch indexes and write index.jsonl
+    # ------------------------------------------------------------------
+    all_records = []
+    for endpoint in ENDPOINTS:
+        records = fetch_index(session, endpoint)
+        all_records.extend(records)
+
+    scraped_at = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+    index_path = SOURCE_DIR / "index.jsonl"
+    with index_path.open("w", encoding="utf-8") as f:
+        for rec in all_records:
+            # Strip out internal use `_ext` before writing to index.jsonl
+            out_rec = {k: v for k, v in rec.items() if k != "_ext"}
+            f.write(json.dumps({**out_rec, "scraped_at": scraped_at}) + "\n")
+    log.info("Wrote %d total index records to %s", len(all_records), index_path)
+
+    # ------------------------------------------------------------------
+    # Step 2: scrape each detail page & download file
+    # ------------------------------------------------------------------
+    if args.limit:
+        all_records = all_records[: args.limit]
+
+    ok = skipped = failed = 0
+    total = len(all_records)
+
+    for i, rec in enumerate(all_records, 1):
+        result = scrape_detail(session, rate, rec, force=args.force)
+
+        if result is None:
+            skipped += 1
+            continue
+
+        dest = DETAIL_DIR / f"{int(rec['id']):06d}.json"
+        try:
+            dest.write_text(
+                json.dumps(result, indent=2, ensure_ascii=False), encoding="utf-8"
+            )
+            ok += 1
+            log.debug("Saved metadata %s", dest.name)
+        except OSError as exc:
+            log.warning("Could not write %s: %s", dest, exc)
+            failed += 1
+
+        if i % 25 == 0 or i == total:
+            log.info(
+                "Progress: %d/%d — ok=%d  skipped=%d  failed=%d",
+                i,
+                total,
+                ok,
+                skipped,
+                failed,
+            )
+
+    log.info("Done — ok=%d  skipped=%d  failed=%d", ok, skipped, failed)
+
+
+if __name__ == "__main__":
+    main()

scripts/flights/01_scrape.py

@@ -0,0 +1,397 @@
+#!/usr/bin/env python3
+"""
+scrape_flights.py — Fetch all flight logs from RocketReviews.com and scrape
+each detail page, saving structured JSON to source/flights/.
+
+The index is fetched from a single date-range endpoint that returns all
+flights at once. Detail pages are scraped only for flights that have an
+image/detail URL. Flights without a detail page are saved with index fields
+only and detail fields set to null.
+
+Output
+------
+    source/flights/index.jsonl        one record per flight (raw index fields)
+    source/flights/detail/{id}.json   full parsed detail per flight
+
+Usage
+-----
+    python scripts/flights/01_scrape.py
+    python scripts/flights/01_scrape.py --delay 1.0 --limit 10
+    python scripts/flights/01_scrape.py --force   # re-scrape existing files
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import re
+import sys
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional
+
+import requests
+from bs4 import BeautifulSoup, Tag
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+
+# ---------------------------------------------------------------------------
+# Config
+# ---------------------------------------------------------------------------
+
+BASE_URL = "https://www.rocketreviews.com"
+USER_AGENT = "RocketReviews-Dataset/1.0"
+DEFAULT_DELAY = 1.0
+
+# Fetch all flights from the earliest recorded date to today
+_TODAY = datetime.now().strftime("%Y-%m-%d")
+INDEX_URL = f"{BASE_URL}/data/flightlog/flightdates.php?search=2000-01-01:{_TODAY}"
+
+ROOT = Path(__file__).parent.parent.parent
+SOURCE_DIR = ROOT / "source" / "flights"
+DETAIL_DIR = SOURCE_DIR / "detail"
+
+# ---------------------------------------------------------------------------
+# Logging
+# ---------------------------------------------------------------------------
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s %(levelname)s %(message)s",
+    handlers=[logging.StreamHandler(sys.stdout)],
+)
+log = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# HTTP session
+# ---------------------------------------------------------------------------
+
+
+def _build_session() -> requests.Session:
+    s = requests.Session()
+    s.headers["User-Agent"] = USER_AGENT
+    retry = Retry(
+        total=3,
+        backoff_factor=2.0,
+        status_forcelist=[429, 500, 502, 503, 504],
+        allowed_methods=["GET"],
+    )
+    s.mount("https://", HTTPAdapter(max_retries=retry))
+    s.mount("http://", HTTPAdapter(max_retries=retry))
+    return s
+
+
+class RateLimiter:
+    def __init__(self, delay: float) -> None:
+        self.delay = delay
+        self._last: float = 0.0
+
+    def wait(self) -> None:
+        elapsed = time.monotonic() - self._last
+        if elapsed < self.delay:
+            time.sleep(self.delay - elapsed)
+        self._last = time.monotonic()
+
+
+# ---------------------------------------------------------------------------
+# Parsing helpers
+# ---------------------------------------------------------------------------
+
+
+def _re_first(pattern: str, text: str, group: int = 1) -> Optional[str]:
+    m = re.search(pattern, text)
+    return m.group(group) if m else None
+
+
+def _after_strong(soup: BeautifulSoup, label: str) -> Optional[str]:
+    """
+    Find '<strong>{label}:</strong>' and return the text immediately after it,
+    stopping at the next <strong> tag.
+    """
+    strong = soup.find("strong", string=re.compile(rf"^{label}:?$", re.I))
+    if not strong:
+        return None
+    text = ""
+    for sib in strong.next_siblings:
+        if isinstance(sib, Tag) and sib.name == "strong":
+            break
+        text += sib.get_text() if isinstance(sib, Tag) else str(sib)
+    return text.strip() or None
+
+
+def _parse_altitude(raw: Optional[str]) -> Optional[float]:
+    """
+    Parse altitude from the raw index string. Returns feet as a float or None.
+
+    Handles:
+        "16,504 Feet"   -> 16504.0
+        "600-700 Feet"  -> 650.0  (midpoint of range)
+        "-"             -> None
+    """
+    if not raw or raw.strip() == "-":
+        return None
+    cleaned = raw.replace(",", "").lower()
+    # Range: "600-700 feet" -> midpoint
+    m = re.search(r"(\d+(?:\.\d+)?)\s*-\s*(\d+(?:\.\d+)?)", cleaned)
+    if m:
+        return (float(m.group(1)) + float(m.group(2))) / 2
+    # Single value
+    m = re.search(r"(\d+(?:\.\d+)?)", cleaned)
+    return float(m.group(1)) if m else None
+
+
+def _parse_conditions(soup: BeautifulSoup) -> dict:
+    """Extract weather conditions from labeled strong fields."""
+    wind_speed_raw = _after_strong(soup, "Wind Speed")
+    wind_speed = None
+    if wind_speed_raw:
+        m = re.search(r"(\d+(?:\.\d+)?)", wind_speed_raw)
+        wind_speed = float(m.group(1)) if m else None
+
+    wind_dir_raw = _after_strong(soup, "Wind Direction")
+    wind_dir = None
+    if wind_dir_raw:
+        # "From the WSW" -> "WSW"
+        m = re.search(r"from\s+the\s+(\w+)", wind_dir_raw, re.I)
+        wind_dir = m.group(1).upper() if m else wind_dir_raw.strip()
+
+    temp_raw = _after_strong(soup, "Temperature")
+    temp = None
+    if temp_raw:
+        m = re.search(r"(\d+(?:\.\d+)?)", temp_raw)
+        temp = float(m.group(1)) if m else None
+
+    return {
+        "wind_speed_mph": wind_speed,
+        "wind_direction": wind_dir,
+        "temperature_f": temp,
+    }
+
+
+def _parse_notes(soup: BeautifulSoup) -> Optional[str]:
+    """
+    Extract the narrative flight description. Notes appear as plain <p> tags
+    in the main content area with no section heading.
+    """
+    paragraphs = [
+        p.get_text(strip=True)
+        for p in soup.find_all("p")
+        if len(p.get_text(strip=True)) > 20
+    ]
+    return " ".join(paragraphs) if paragraphs else None
+
+
+def _parse_rocket_url(html: str) -> Optional[str]:
+    """
+    Extract the URL for the flyer's specific rocket instance.
+    These use a 12-digit timestamp-based suffix, e.g.:
+        /aerospace-specialty-products-sky-ferry-250708140332.html
+    """
+    m = re.search(r'href="(/[a-z][a-z0-9-]+-\d{10,}\.html)"', html)
+    return f"{BASE_URL}{m.group(1)}" if m else None
+
+
+def _parse_motor_url(html: str, motors: str) -> Optional[str]:
+    """
+    Extract the motor product page URL using the first motor designation
+    as a search anchor. Motor URLs embed the designation slug, e.g.:
+        /estes-d12-5112.html  for motor "D12-5"
+    """
+    if not motors:
+        return None
+    # Use the first motor designation (split on + for multi-motor configs)
+    first_motor = motors.split("+")[0].strip()
+    slug = re.sub(r"[^a-z0-9]+", "-", first_motor.lower()).strip("-")
+    # Match a link href containing the motor slug prefix
+    m = re.search(
+        rf'href="(/[a-z0-9-]*{re.escape(slug[:6])}[a-z0-9-]*\.html)"',
+        html,
+    )
+    return f"{BASE_URL}{m.group(1)}" if m else None
+
+
+def _parse_detail(html: str, index_rec: dict) -> dict:
+    """Parse a flight detail page into a structured record."""
+    soup = BeautifulSoup(html, "lxml")
+    image_path = index_rec.get("image", "")
+
+    return {
+        "id": int(index_rec["id"]),
+        "url": f"{BASE_URL}{image_path}" if image_path else None,
+        "date": index_rec.get("date"),
+        "scraped_at": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+        "flyer": index_rec.get("flyer"),
+        "rocket": index_rec.get("rocket"),
+        "rocket_url": _parse_rocket_url(html),
+        "kit": index_rec.get("kit") or None,
+        "motors": index_rec.get("motors") or None,
+        "motor_url": _parse_motor_url(html, index_rec.get("motors", "")),
+        "altitude_raw": index_rec.get("altitude") or None,
+        "altitude_ft": _parse_altitude(index_rec.get("altitude")),
+        "launch_site": _after_strong(soup, "Launch Site"),
+        "conditions": _parse_conditions(soup),
+        "notes": _parse_notes(soup),
+    }
+
+
+def _index_only_record(index_rec: dict) -> dict:
+    """
+    Build a detail record from index fields only for flights that have no
+    detail page. Detail-only fields are set to null.
+    """
+    return {
+        "id": int(index_rec["id"]),
+        "url": None,
+        "date": index_rec.get("date"),
+        "scraped_at": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+        "flyer": index_rec.get("flyer"),
+        "rocket": index_rec.get("rocket"),
+        "rocket_url": None,
+        "kit": index_rec.get("kit") or None,
+        "motors": index_rec.get("motors") or None,
+        "motor_url": None,
+        "altitude_raw": index_rec.get("altitude") or None,
+        "altitude_ft": _parse_altitude(index_rec.get("altitude")),
+        "launch_site": None,
+        "conditions": {
+            "wind_speed_mph": None,
+            "wind_direction": None,
+            "temperature_f": None,
+        },
+        "notes": None,
+    }
+
+
+# ---------------------------------------------------------------------------
+# Fetch helpers
+# ---------------------------------------------------------------------------
+
+
+def fetch_index(session: requests.Session) -> list[dict]:
+    log.info("Fetching flight index from %s", INDEX_URL)
+    resp = session.get(INDEX_URL, timeout=30)
+    resp.raise_for_status()
+    records = resp.json().get("records", [])
+    log.info("Index returned %d records.", len(records))
+    return records
+
+
+def scrape_detail(
+    session: requests.Session,
+    rate: RateLimiter,
+    index_rec: dict,
+    force: bool = False,
+) -> dict:
+    flight_id = index_rec["id"]
+    dest = DETAIL_DIR / f"{int(flight_id):06d}.json"
+
+    if dest.exists() and not force:
+        log.debug("Already scraped %s, skipping.", flight_id)
+        return None
+
+    image_path = index_rec.get("image", "")
+    if not image_path:
+        # No detail page — save index-only record without making a request
+        return _index_only_record(index_rec)
+
+    url = f"{BASE_URL}{image_path}"
+    rate.wait()
+
+    try:
+        resp = session.get(url, timeout=30)
+        resp.raise_for_status()
+    except requests.RequestException as exc:
+        log.warning("Failed to fetch flight %s: %s", flight_id, exc)
+        return _index_only_record(index_rec)
+
+    return _parse_detail(resp.text, index_rec)
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Scrape RocketReviews.com flight logs.")
+    parser.add_argument(
+        "--delay",
+        type=float,
+        default=DEFAULT_DELAY,
+        help=f"Seconds between requests (default: {DEFAULT_DELAY})",
+    )
+    parser.add_argument(
+        "--limit",
+        type=int,
+        default=None,
+        help="Stop after scraping this many records (useful for testing)",
+    )
+    parser.add_argument(
+        "--force",
+        action="store_true",
+        help="Re-scrape flights that already have a saved detail file",
+    )
+    args = parser.parse_args()
+
+    SOURCE_DIR.mkdir(parents=True, exist_ok=True)
+    DETAIL_DIR.mkdir(parents=True, exist_ok=True)
+
+    session = _build_session()
+    rate = RateLimiter(args.delay)
+
+    # ------------------------------------------------------------------
+    # Step 1: fetch and write the full index
+    # ------------------------------------------------------------------
+    records = fetch_index(session)
+
+    scraped_at = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+    index_path = SOURCE_DIR / "index.jsonl"
+    with index_path.open("w", encoding="utf-8") as f:
+        for rec in records:
+            f.write(json.dumps({**rec, "scraped_at": scraped_at}) + "\n")
+    log.info("Wrote %d index records to %s", len(records), index_path)
+
+    # ------------------------------------------------------------------
+    # Step 2: scrape each detail page
+    # ------------------------------------------------------------------
+    if args.limit:
+        records = records[: args.limit]
+
+    ok = skipped = failed = 0
+    total = len(records)
+
+    for i, rec in enumerate(records, 1):
+        result = scrape_detail(session, rate, rec, force=args.force)
+
+        if result is None:
+            skipped += 1
+            continue
+
+        dest = DETAIL_DIR / f"{int(rec['id']):06d}.json"
+        try:
+            dest.write_text(
+                json.dumps(result, indent=2, ensure_ascii=False), encoding="utf-8"
+            )
+            ok += 1
+            log.debug("Saved %s", dest.name)
+        except OSError as exc:
+            log.warning("Could not write %s: %s", dest, exc)
+            failed += 1
+
+        if i % 25 == 0 or i == total:
+            log.info(
+                "Progress: %d/%d — ok=%d  skipped=%d  failed=%d",
+                i,
+                total,
+                ok,
+                skipped,
+                failed,
+            )
+
+    log.info("Done — ok=%d  skipped=%d  failed=%d", ok, skipped, failed)
+
+
+if __name__ == "__main__":
+    main()

scripts/glossary/01_scrape.py

@@ -0,0 +1,301 @@
+#!/usr/bin/env python3
+"""
+scrape_glossary.py — Fetch the RocketReviews.com glossary index and scrape each
+detail page, saving structured JSON to source/glossary/.
+
+Output
+------
+    source/glossary/index.jsonl        one record per term (raw index fields)
+    source/glossary/detail/{slug}.json full parsed detail per term
+
+Usage
+-----
+    python scripts/glossary/01_scrape.py
+    python scripts/glossary/01_scrape.py --delay 1.0 --limit 10
+    python scripts/glossary/01_scrape.py --force   # re-scrape existing files
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import re
+import sys
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional
+
+import requests
+from bs4 import BeautifulSoup, Tag
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+
+# ---------------------------------------------------------------------------
+# Config
+# ---------------------------------------------------------------------------
+
+BASE_URL = "https://www.rocketreviews.com"
+INDEX_URL = f"{BASE_URL}/glossary.html"
+USER_AGENT = "RocketReviews-Dataset/1.0"
+DEFAULT_DELAY = 1.0
+
+ROOT = Path(__file__).parent.parent.parent
+SOURCE_DIR = ROOT / "source" / "glossary"
+DETAIL_DIR = SOURCE_DIR / "detail"
+
+# ---------------------------------------------------------------------------
+# Logging
+# ---------------------------------------------------------------------------
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s %(levelname)s %(message)s",
+    handlers=[logging.StreamHandler(sys.stdout)],
+)
+log = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# HTTP session
+# ---------------------------------------------------------------------------
+
+
+def _build_session() -> requests.Session:
+    s = requests.Session()
+    s.headers["User-Agent"] = USER_AGENT
+    retry = Retry(
+        total=3,
+        backoff_factor=2.0,
+        status_forcelist=[429, 500, 502, 503, 504],
+        allowed_methods=["GET"],
+    )
+    s.mount("https://", HTTPAdapter(max_retries=retry))
+    s.mount("http://", HTTPAdapter(max_retries=retry))
+    return s
+
+
+class RateLimiter:
+    def __init__(self, delay: float) -> None:
+        self.delay = delay
+        self._last: float = 0.0
+
+    def wait(self) -> None:
+        elapsed = time.monotonic() - self._last
+        if elapsed < self.delay:
+            time.sleep(self.delay - elapsed)
+        self._last = time.monotonic()
+
+
+# ---------------------------------------------------------------------------
+# Index parsing
+# ---------------------------------------------------------------------------
+
+
+def _slug_from_path(path: str) -> str:
+    """
+    Extract the slug from a url path.
+    e.g. '/1010-extrusion-230702231652.html' -> '1010-extrusion'
+    """
+    name = path.lstrip("/").removesuffix(".html")
+    name = re.sub(r"-\d{10,}$", "", name)
+    return name
+
+
+def _parse_index(html: str) -> list[dict]:
+    """
+    Parse the glossary.html static page and return one record
+    per term with name and url.
+    """
+    soup = BeautifulSoup(html, "lxml")
+    records = []
+
+    # Glossary terms are usually in <a class="entry">
+    for link in soup.find_all("a", class_="entry"):
+        path = link.get("href")
+        if not path or not path.endswith(".html"):
+            continue
+
+        name = link.get_text(strip=True)
+        if not name:
+            continue
+
+        slug = _slug_from_path(path)
+        url = f"{BASE_URL}{path}" if path.startswith("/") else path
+
+        # Find the short description in the following blockquote
+        description = None
+        parent_p = link.find_parent("p")
+        if parent_p:
+            blockquote = parent_p.find_next_sibling("blockquote")
+            if blockquote:
+                # Remove the [Read More] link text
+                read_more = blockquote.find("a", string=re.compile(r"Read More", re.I))
+                if read_more:
+                    # Also try to remove the surrounding brackets if they exist as text nodes
+                    for sib in read_more.previous_siblings:
+                        if isinstance(sib, str) and "[" in sib:
+                            sib.replace_with(sib.replace("[", ""))
+                    for sib in read_more.next_siblings:
+                        if isinstance(sib, str) and "]" in sib:
+                            sib.replace_with(sib.replace("]", ""))
+                    read_more.extract()
+                description = blockquote.get_text(separator=" ", strip=True) or None
+
+        records.append({
+            "slug": slug,
+            "url": url,
+            "term": name,
+            "short_description": description,
+        })
+
+    return records
+
+
+# ---------------------------------------------------------------------------
+# Detail page parsing
+# ---------------------------------------------------------------------------
+
+
+def _parse_detail(html: str, index_rec: dict) -> dict:
+    """Extract description from the detail page."""
+    soup = BeautifulSoup(html, "lxml")
+    
+    article = soup.find("div", class_="article")
+    description = None
+    if article:
+        description = article.get_text(separator="\n", strip=True)
+        
+    return {
+        **index_rec,
+        "scraped_at": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+        "description": description,
+    }
+
+
+# ---------------------------------------------------------------------------
+# Fetch helpers
+# ---------------------------------------------------------------------------
+
+
+def fetch_index(session: requests.Session) -> list[dict]:
+    log.info("Fetching glossary index from %s", INDEX_URL)
+    resp = session.get(INDEX_URL, timeout=30)
+    resp.raise_for_status()
+    records = _parse_index(resp.text)
+    log.info("Index returned %d records.", len(records))
+    return records
+
+
+def scrape_detail(
+    session: requests.Session,
+    rate: RateLimiter,
+    index_rec: dict,
+    force: bool = False,
+) -> Optional[dict]:
+    slug = index_rec["slug"]
+    dest = DETAIL_DIR / f"{slug}.json"
+
+    if dest.exists() and not force:
+        log.debug("Already scraped %s, skipping.", slug)
+        return None
+
+    url = index_rec["url"]
+    rate.wait()
+
+    try:
+        resp = session.get(url, timeout=30)
+        resp.raise_for_status()
+    except requests.RequestException as exc:
+        log.warning("Failed to fetch glossary term %s: %s", slug, exc)
+        return None
+
+    return _parse_detail(resp.text, index_rec)
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Scrape RocketReviews.com glossary.")
+    parser.add_argument(
+        "--delay",
+        type=float,
+        default=DEFAULT_DELAY,
+        help=f"Seconds between requests (default: {DEFAULT_DELAY})",
+    )
+    parser.add_argument(
+        "--limit",
+        type=int,
+        default=None,
+        help="Stop after scraping this many detail pages (useful for testing)",
+    )
+    parser.add_argument(
+        "--force",
+        action="store_true",
+        help="Re-scrape terms that already have a saved detail file",
+    )
+    args = parser.parse_args()
+
+    SOURCE_DIR.mkdir(parents=True, exist_ok=True)
+    DETAIL_DIR.mkdir(parents=True, exist_ok=True)
+
+    session = _build_session()
+    rate = RateLimiter(args.delay)
+
+    # ------------------------------------------------------------------
+    # Step 1: fetch index and write index.jsonl
+    # ------------------------------------------------------------------
+    records = fetch_index(session)
+
+    scraped_at = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+    index_path = SOURCE_DIR / "index.jsonl"
+    with index_path.open("w", encoding="utf-8") as f:
+        for rec in records:
+            f.write(json.dumps({**rec, "scraped_at": scraped_at}) + "\n")
+    log.info("Wrote %d index records to %s", len(records), index_path)
+
+    # ------------------------------------------------------------------
+    # Step 2: scrape each detail page
+    # ------------------------------------------------------------------
+    if args.limit:
+        records = records[: args.limit]
+
+    ok = skipped = failed = 0
+    total = len(records)
+
+    for i, rec in enumerate(records, 1):
+        result = scrape_detail(session, rate, rec, force=args.force)
+
+        if result is None:
+            skipped += 1
+            continue
+
+        dest = DETAIL_DIR / f"{rec['slug']}.json"
+        try:
+            dest.write_text(
+                json.dumps(result, indent=2, ensure_ascii=False), encoding="utf-8"
+            )
+            ok += 1
+            log.debug("Saved %s", dest.name)
+        except OSError as exc:
+            log.warning("Could not write %s: %s", dest, exc)
+            failed += 1
+
+        if i % 25 == 0 or i == total:
+            log.info(
+                "Progress: %d/%d — ok=%d  skipped=%d  failed=%d",
+                i,
+                total,
+                ok,
+                skipped,
+                failed,
+            )
+
+    log.info("Done — ok=%d  skipped=%d  failed=%d", ok, skipped, failed)
+
+
+if __name__ == "__main__":
+    main()

scripts/manufacturers/01_scrape.py

@@ -0,0 +1,387 @@
+#!/usr/bin/env python3
+"""
+scrape_manufacturers.py — Scrape the RocketReviews.com manufacturers list and
+each detail page, saving structured JSON to source/manufacturers/.
+
+The index is a single static HTML page (/manufacturers-by-name.html) with
+alphabetical sections. Detail pages add AKA names, operational dates, and
+product listings.
+
+Output
+------
+    source/manufacturers/index.jsonl        one record per manufacturer
+    source/manufacturers/detail/{slug}.json full parsed detail per manufacturer
+
+Usage
+-----
+    python scripts/manufacturers/01_scrape.py
+    python scripts/manufacturers/01_scrape.py --delay 1.0 --limit 10
+    python scripts/manufacturers/01_scrape.py --force   # re-scrape existing files
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import re
+import sys
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional
+
+import requests
+from bs4 import BeautifulSoup, NavigableString, Tag
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+
+# ---------------------------------------------------------------------------
+# Config
+# ---------------------------------------------------------------------------
+
+BASE_URL = "https://www.rocketreviews.com"
+INDEX_PATH = "/manufacturers-by-name.html"
+USER_AGENT = "RocketReviews-Dataset/1.0"
+DEFAULT_DELAY = 1.0
+
+ROOT = Path(__file__).parent.parent.parent
+SOURCE_DIR = ROOT / "source" / "manufacturers"
+DETAIL_DIR = SOURCE_DIR / "detail"
+
+# ---------------------------------------------------------------------------
+# Logging
+# ---------------------------------------------------------------------------
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s %(levelname)s %(message)s",
+    handlers=[logging.StreamHandler(sys.stdout)],
+)
+log = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# HTTP session
+# ---------------------------------------------------------------------------
+
+
+def _build_session() -> requests.Session:
+    s = requests.Session()
+    s.headers["User-Agent"] = USER_AGENT
+    retry = Retry(
+        total=3,
+        backoff_factor=2.0,
+        status_forcelist=[429, 500, 502, 503, 504],
+        allowed_methods=["GET"],
+    )
+    s.mount("https://", HTTPAdapter(max_retries=retry))
+    s.mount("http://", HTTPAdapter(max_retries=retry))
+    return s
+
+
+class RateLimiter:
+    def __init__(self, delay: float) -> None:
+        self.delay = delay
+        self._last: float = 0.0
+
+    def wait(self) -> None:
+        elapsed = time.monotonic() - self._last
+        if elapsed < self.delay:
+            time.sleep(self.delay - elapsed)
+        self._last = time.monotonic()
+
+
+# ---------------------------------------------------------------------------
+# Index parsing
+# ---------------------------------------------------------------------------
+
+
+def _slug_from_path(path: str) -> str:
+    """
+    Extract the slug from a manufacturer URL path.
+    e.g. '/estes-230703173737.html' -> 'estes'
+         '/aardvark-rockets-230703173737.html' -> 'aardvark-rockets'
+    """
+    # Strip leading slash and .html
+    name = path.lstrip("/").removesuffix(".html")
+    # Remove trailing -NNNNNNNNNNNN timestamp (12-digit numeric suffix)
+    name = re.sub(r"-\d{10,}$", "", name)
+    return name
+
+
+def _parse_index(html: str) -> list[dict]:
+    """
+    Parse the manufacturers-by-name.html static page and return one record
+    per manufacturer with name, url, description, and external website.
+    """
+    soup = BeautifulSoup(html, "lxml")
+    records = []
+
+    for link in soup.find_all("a", href=re.compile(r"^/[a-z][a-z0-9-]+-\d{10,}\.html$")):
+        path = link["href"]
+        name = link.get_text(strip=True)
+        if not name:
+            continue
+
+        slug = _slug_from_path(path)
+        url = f"{BASE_URL}{path}"
+
+        # Description: text node(s) immediately after the link, before <br> or next <a>
+        description_parts = []
+        for sib in link.next_siblings:
+            if isinstance(sib, Tag):
+                if sib.name in ("a", "br"):
+                    break
+                text = sib.get_text(strip=True)
+                if text:
+                    description_parts.append(text)
+            elif isinstance(sib, NavigableString):
+                text = str(sib).strip(" \t\r\n—–-").strip()
+                if text:
+                    description_parts.append(text)
+
+        description = " ".join(description_parts).strip() or None
+
+        # External website link following the manufacturer link
+        website = None
+        for sib in link.next_siblings:
+            if isinstance(sib, Tag) and sib.name == "a":
+                href = sib.get("href", "")
+                if href.startswith("http") and "rocketreviews.com" not in href:
+                    website = href
+                break
+
+        records.append({
+            "slug": slug,
+            "url": url,
+            "name": name,
+            "description": description,
+            "website": website,
+        })
+
+    return records
+
+
+# ---------------------------------------------------------------------------
+# Detail page parsing
+# ---------------------------------------------------------------------------
+
+
+def _after_strong(soup: BeautifulSoup, label: str) -> Optional[str]:
+    """
+    Find '<strong>{label}:</strong>' and return the text immediately after it,
+    stopping at the next tag boundary.
+    """
+    strong = soup.find("strong", string=re.compile(rf"^{re.escape(label)}:?$", re.I))
+    if not strong:
+        return None
+    text = ""
+    for sib in strong.next_siblings:
+        if isinstance(sib, Tag) and sib.name in ("strong", "h4", "p", "br"):
+            break
+        text += sib.get_text() if isinstance(sib, Tag) else str(sib)
+    return text.strip() or None
+
+
+def _parse_h4_list(soup: BeautifulSoup, heading: str) -> list[str]:
+    """
+    Find '<h4>{heading}:</h4>' and return text items from the following <ul>.
+    """
+    h4 = soup.find("h4", string=re.compile(rf"^{re.escape(heading)}:?$", re.I))
+    if not h4:
+        return []
+    ul = h4.find_next_sibling("ul")
+    if not ul:
+        return []
+    return [li.get_text(strip=True) for li in ul.find_all("li") if li.get_text(strip=True)]
+
+
+def _parse_h4_link_list(soup: BeautifulSoup, heading: str) -> list[dict]:
+    """
+    Find '<h4>{heading}:</h4>' and return {name, url} dicts from links in the following <ul>.
+    """
+    h4 = soup.find("h4", string=re.compile(rf"^{re.escape(heading)}:?$", re.I))
+    if not h4:
+        return []
+    ul = h4.find_next_sibling("ul")
+    if not ul:
+        return []
+    results = []
+    for li in ul.find_all("li"):
+        a = li.find("a")
+        if a and a.get("href"):
+            href = a["href"]
+            full_url = href if href.startswith("http") else f"{BASE_URL}{href}"
+            results.append({
+                "name": a.get_text(strip=True) or None,
+                "url": full_url,
+            })
+    return results
+
+
+def _parse_description(soup: BeautifulSoup) -> Optional[str]:
+    """
+    Extract the narrative description paragraphs from the detail page,
+    excluding boilerplate navigation/header content.
+    """
+    paragraphs = [
+        p.get_text(separator=" ", strip=True)
+        for p in soup.find_all("p")
+        if len(p.get_text(strip=True)) > 30
+    ]
+    return " ".join(paragraphs) if paragraphs else None
+
+
+def _parse_detail(html: str, index_rec: dict) -> dict:
+    """Merge index-level fields with detail page data."""
+    soup = BeautifulSoup(html, "lxml")
+
+    began = _after_strong(soup, "Began Operations")
+    ceased = _after_strong(soup, "Ceased Operations")
+
+    # Normalize "?" to None
+    if began and began.strip() in ("?", "-", ""):
+        began = None
+    if ceased and ceased.strip() in ("?", "-", ""):
+        ceased = None
+
+    aka = _parse_h4_list(soup, "AKA")
+    products = _parse_h4_link_list(soup, "Products")
+
+    return {
+        **index_rec,
+        "scraped_at": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+        "aka": aka,
+        "began_operations": began,
+        "ceased_operations": ceased,
+        "products": products,
+    }
+
+
+# ---------------------------------------------------------------------------
+# Fetch helpers
+# ---------------------------------------------------------------------------
+
+
+def fetch_index(session: requests.Session) -> list[dict]:
+    url = f"{BASE_URL}{INDEX_PATH}"
+    log.info("Fetching manufacturer index from %s", url)
+    resp = session.get(url, timeout=30)
+    resp.raise_for_status()
+    records = _parse_index(resp.text)
+    log.info("Index returned %d records.", len(records))
+    return records
+
+
+def scrape_detail(
+    session: requests.Session,
+    rate: RateLimiter,
+    index_rec: dict,
+    force: bool = False,
+) -> Optional[dict]:
+    slug = index_rec["slug"]
+    dest = DETAIL_DIR / f"{slug}.json"
+
+    if dest.exists() and not force:
+        log.debug("Already scraped %s, skipping.", slug)
+        return None
+
+    url = index_rec["url"]
+    rate.wait()
+
+    try:
+        resp = session.get(url, timeout=30)
+        resp.raise_for_status()
+    except requests.RequestException as exc:
+        log.warning("Failed to fetch manufacturer %s: %s", slug, exc)
+        return None
+
+    return _parse_detail(resp.text, index_rec)
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Scrape RocketReviews.com manufacturers.")
+    parser.add_argument(
+        "--delay",
+        type=float,
+        default=DEFAULT_DELAY,
+        help=f"Seconds between requests (default: {DEFAULT_DELAY})",
+    )
+    parser.add_argument(
+        "--limit",
+        type=int,
+        default=None,
+        help="Stop after scraping this many detail pages (useful for testing)",
+    )
+    parser.add_argument(
+        "--force",
+        action="store_true",
+        help="Re-scrape manufacturers that already have a saved detail file",
+    )
+    args = parser.parse_args()
+
+    SOURCE_DIR.mkdir(parents=True, exist_ok=True)
+    DETAIL_DIR.mkdir(parents=True, exist_ok=True)
+
+    session = _build_session()
+    rate = RateLimiter(args.delay)
+
+    # ------------------------------------------------------------------
+    # Step 1: fetch index and write index.jsonl
+    # ------------------------------------------------------------------
+    records = fetch_index(session)
+
+    scraped_at = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+    index_path = SOURCE_DIR / "index.jsonl"
+    with index_path.open("w", encoding="utf-8") as f:
+        for rec in records:
+            f.write(json.dumps({**rec, "scraped_at": scraped_at}) + "\n")
+    log.info("Wrote %d index records to %s", len(records), index_path)
+
+    # ------------------------------------------------------------------
+    # Step 2: scrape each detail page
+    # ------------------------------------------------------------------
+    if args.limit:
+        records = records[: args.limit]
+
+    ok = skipped = failed = 0
+    total = len(records)
+
+    for i, rec in enumerate(records, 1):
+        result = scrape_detail(session, rate, rec, force=args.force)
+
+        if result is None:
+            skipped += 1
+            continue
+
+        dest = DETAIL_DIR / f"{rec['slug']}.json"
+        try:
+            dest.write_text(
+                json.dumps(result, indent=2, ensure_ascii=False), encoding="utf-8"
+            )
+            ok += 1
+            log.debug("Saved %s", dest.name)
+        except OSError as exc:
+            log.warning("Could not write %s: %s", dest, exc)
+            failed += 1
+
+        if i % 25 == 0 or i == total:
+            log.info(
+                "Progress: %d/%d — ok=%d  skipped=%d  failed=%d",
+                i,
+                total,
+                ok,
+                skipped,
+                failed,
+            )
+
+    log.info("Done — ok=%d  skipped=%d  failed=%d", ok, skipped, failed)
+
+
+if __name__ == "__main__":
+    main()

scripts/motors/01_scrape.py

@@ -0,0 +1,399 @@
+#!/usr/bin/env python3
+"""
+scrape_motors.py — Fetch the RocketReviews.com motor index and scrape each
+detail page, saving structured JSON to source/motors/.
+
+The index API already contains ~30 fields per motor. Detail pages add thrust
+curve coordinates and propellant/formula/casing data.
+
+Output
+------
+    source/motors/index.jsonl        one record per motor (raw index fields)
+    source/motors/detail/{id}.json   full parsed detail per motor
+
+Usage
+-----
+    python scripts/motors/01_scrape.py
+    python scripts/motors/01_scrape.py --delay 1.0 --limit 10
+    python scripts/motors/01_scrape.py --force   # re-scrape existing files
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import re
+import sys
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional
+from urllib.parse import quote
+
+import requests
+from bs4 import BeautifulSoup, Tag
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+
+# ---------------------------------------------------------------------------
+# Config
+# ---------------------------------------------------------------------------
+
+BASE_URL = "https://www.rocketreviews.com"
+INDEX_URL = f"{BASE_URL}/data/motors/motors.php?search=&status="
+USER_AGENT = "RocketReviews-Dataset/1.0"
+DEFAULT_DELAY = 1.0
+
+ROOT = Path(__file__).parent.parent.parent
+SOURCE_DIR = ROOT / "source" / "motors"
+DETAIL_DIR = SOURCE_DIR / "detail"
+
+# Fields where "0.0000" means no data and should be stored as null
+_ZERO_AS_NULL = {"MassFraction", "SpecificImpulse", "ThroatDiameter", "ExitDiameter"}
+
+# ---------------------------------------------------------------------------
+# Logging
+# ---------------------------------------------------------------------------
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s %(levelname)s %(message)s",
+    handlers=[logging.StreamHandler(sys.stdout)],
+)
+log = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# HTTP session
+# ---------------------------------------------------------------------------
+
+
+def _build_session() -> requests.Session:
+    s = requests.Session()
+    s.headers["User-Agent"] = USER_AGENT
+    retry = Retry(
+        total=3,
+        backoff_factor=2.0,
+        status_forcelist=[429, 500, 502, 503, 504],
+        allowed_methods=["GET"],
+    )
+    s.mount("https://", HTTPAdapter(max_retries=retry))
+    s.mount("http://", HTTPAdapter(max_retries=retry))
+    return s
+
+
+class RateLimiter:
+    def __init__(self, delay: float) -> None:
+        self.delay = delay
+        self._last: float = 0.0
+
+    def wait(self) -> None:
+        elapsed = time.monotonic() - self._last
+        if elapsed < self.delay:
+            time.sleep(self.delay - elapsed)
+        self._last = time.monotonic()
+
+
+# ---------------------------------------------------------------------------
+# Index field parsers
+# ---------------------------------------------------------------------------
+
+
+def _strip_units(val: str) -> Optional[float]:
+    """Extract the leading float from a string like '18.0 mm' or '10.75 N'."""
+    if not val or not val.strip():
+        return None
+    m = re.match(r"\s*([0-9]+(?:\.[0-9]+)?)", val.strip())
+    return float(m.group(1)) if m else None
+
+
+def _zero_as_null(val: str) -> Optional[float]:
+    """Parse float, returning None if the value is zero (missing data sentinel)."""
+    f = _strip_units(val)
+    return f if f else None
+
+
+def _yn_bool(val: str) -> Optional[bool]:
+    """Convert 'Y'/'N'/'' to True/False/None."""
+    if val == "Y":
+        return True
+    if val == "N":
+        return False
+    return None
+
+
+def _parse_delays(val: str) -> list[str]:
+    """Split delay string into a list, handling plugged/variable formats."""
+    if not val or not val.strip():
+        return []
+    return [d.strip() for d in val.split(",") if d.strip()]
+
+
+def _motor_url(designation: str, motor_id: str) -> str:
+    return (
+        f"{BASE_URL}/index.php"
+        f"?autoredir={quote(designation)}&action=displaymotor&motorid={motor_id}"
+    )
+
+
+def _parse_index_record(rec: dict) -> dict:
+    """Transform a raw API record into a cleaned index-level document."""
+    motor_id = int(rec["Motor_ID"])
+    designation = rec.get("Designation", "").strip()
+    kit_id_raw = rec.get("Kit_ID", "0").strip()
+    kit_url = (
+        f"{BASE_URL}/product-{kit_id_raw}.html"
+        if kit_id_raw and kit_id_raw != "0"
+        else None
+    )
+
+    return {
+        "id": motor_id,
+        "url": _motor_url(designation, rec["Motor_ID"]),
+        "kit_url": kit_url,
+        "title": rec.get("Title", "").strip() or None,
+        "designation": designation or None,
+        "short_name": rec.get("ShortName", "").strip() or None,
+        "letter": rec.get("Letter", "").strip() or None,
+        "equiv": rec.get("Equiv", "").strip() or None,
+        "manufacturer": rec.get("Manufacturer", "").strip() or None,
+        "motor_type": rec.get("MotorType", "").strip() or None,
+        "in_production": _yn_bool(rec.get("InProduction", "")),
+        "custom": _yn_bool(rec.get("Custom", "")),
+        "last_updated": rec.get("LastUpdated", "").strip() or None,
+        "thrustcurve_id": int(rec.get("Thrustcurve_ID", 0)) or None,
+        "delays": _parse_delays(rec.get("Delays", "")),
+        "variable_delay": _yn_bool(rec.get("VariableDelay", "")),
+        "description": rec.get("Description", "").strip() or None,
+        "physical": {
+            "diameter_mm": _strip_units(rec.get("Diameter", "")),
+            "length_mm": _zero_as_null(rec.get("Length", "")),
+            "propellant_weight_g": _zero_as_null(rec.get("PropellantWeight", "")),
+            "total_weight_g": _zero_as_null(rec.get("TotalWeight", "")),
+            "throat_diameter_mm": _zero_as_null(rec.get("ThroatDiameter", "")),
+            "exit_diameter_mm": _zero_as_null(rec.get("ExitDiameter", "")),
+        },
+        "performance": {
+            "average_thrust_n": _strip_units(rec.get("AverageThrust", "")),
+            "peak_thrust_n": _strip_units(rec.get("PeakThrust", "")),
+            "total_impulse_ns": _strip_units(rec.get("TotalImpulse", "")),
+            "thrust_duration_s": _strip_units(rec.get("ThrustDuration", "")),
+            "mass_fraction": _zero_as_null(rec.get("MassFraction", "")),
+            "specific_impulse": _zero_as_null(rec.get("SpecificImpulse", "")),
+        },
+    }
+
+
+# ---------------------------------------------------------------------------
+# Detail page parsers
+# ---------------------------------------------------------------------------
+
+
+def _parse_thrust_curve(html: str) -> list[dict]:
+    """
+    Extract thrust curve coordinate pairs from the Google Charts
+    arrayToDataTable call embedded in the page scripts.
+
+    Format in source:
+        var data = google.visualization.arrayToDataTable([
+          ['Time (seconds)', 'Thrust (N)'],
+          [0.0, 0.0],
+          [0.13, 20.61],
+          ...
+        ]);
+    """
+    # Extract the full arrayToDataTable block
+    m = re.search(
+        r"arrayToDataTable\(\s*\[(.*?)\]\s*\)",
+        html,
+        re.DOTALL,
+    )
+    if not m:
+        return []
+
+    content = m.group(1)
+    # Find all [number, number] pairs, skipping the string header row
+    pairs = re.findall(
+        r"\[\s*(-?\d+(?:\.\d+)?)\s*,\s*(-?\d+(?:\.\d+)?)\s*\]",
+        content,
+    )
+    return [{"time_s": float(t), "thrust_n": float(n)} for t, n in pairs]
+
+
+def _parse_linked_field(html: str, pattern: str) -> Optional[dict]:
+    """
+    Extract a name+url pair from a href matching the given pattern.
+    e.g. pattern r'/propellant([^.]+)\.html' → {name, url}
+    """
+    m = re.search(pattern, html)
+    if not m:
+        return None
+    path = m.group(0) if m.lastindex == 0 else None
+    # Re-search for the full href
+    href_m = re.search(rf'href="({re.escape(m.group(0)) if m.lastindex == 0 else m.group(1)})"', html)
+    return None  # fallback — use _parse_linked_href instead
+
+
+def _parse_linked_href(
+    soup: BeautifulSoup, href_pattern: str
+) -> Optional[dict]:
+    """
+    Find an <a> tag whose href matches href_pattern.
+    Returns {"name": link_text, "url": full_url}.
+    """
+    link = soup.find("a", href=re.compile(href_pattern))
+    if not link:
+        return None
+    return {
+        "name": link.get_text(strip=True) or None,
+        "url": f"{BASE_URL}{link['href']}",
+    }
+
+
+def _parse_propellant(soup: BeautifulSoup) -> dict:
+    """Extract propellant type, formula, and casing as name+url objects."""
+    return {
+        "type": _parse_linked_href(soup, r"^/propellant"),
+        "formula": _parse_linked_href(soup, r"^/formula"),
+        "casing": _parse_linked_href(soup, r"^/casing"),
+    }
+
+
+def _parse_detail(html: str, index_doc: dict) -> dict:
+    """Merge index-level fields with detail page data."""
+    soup = BeautifulSoup(html, "lxml")
+    return {
+        **index_doc,
+        "scraped_at": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+        "propellant": _parse_propellant(soup),
+        "thrust_curve": _parse_thrust_curve(html),
+    }
+
+
+# ---------------------------------------------------------------------------
+# Fetch helpers
+# ---------------------------------------------------------------------------
+
+
+def fetch_index(session: requests.Session) -> list[dict]:
+    log.info("Fetching motor index from %s", INDEX_URL)
+    resp = session.get(INDEX_URL, timeout=30)
+    resp.raise_for_status()
+    records = resp.json().get("records", [])
+    log.info("Index returned %d records.", len(records))
+    return records
+
+
+def scrape_detail(
+    session: requests.Session,
+    rate: RateLimiter,
+    index_doc: dict,
+    force: bool = False,
+) -> Optional[dict]:
+    motor_id = index_doc["id"]
+    dest = DETAIL_DIR / f"{motor_id:06d}.json"
+
+    if dest.exists() and not force:
+        log.debug("Already scraped %s, skipping.", motor_id)
+        return None
+
+    url = index_doc["url"]
+    rate.wait()
+
+    try:
+        resp = session.get(url, timeout=30)
+        resp.raise_for_status()
+    except requests.RequestException as exc:
+        log.warning("Failed to fetch motor %s: %s", motor_id, exc)
+        return None
+
+    return _parse_detail(resp.text, index_doc)
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Scrape RocketReviews.com motors.")
+    parser.add_argument(
+        "--delay",
+        type=float,
+        default=DEFAULT_DELAY,
+        help=f"Seconds between requests (default: {DEFAULT_DELAY})",
+    )
+    parser.add_argument(
+        "--limit",
+        type=int,
+        default=None,
+        help="Stop after scraping this many detail pages (useful for testing)",
+    )
+    parser.add_argument(
+        "--force",
+        action="store_true",
+        help="Re-scrape motors that already have a saved detail file",
+    )
+    args = parser.parse_args()
+
+    SOURCE_DIR.mkdir(parents=True, exist_ok=True)
+    DETAIL_DIR.mkdir(parents=True, exist_ok=True)
+
+    session = _build_session()
+    rate = RateLimiter(args.delay)
+
+    # ------------------------------------------------------------------
+    # Step 1: fetch index, clean records, and write index.jsonl
+    # ------------------------------------------------------------------
+    raw_records = fetch_index(session)
+    index_docs = [_parse_index_record(r) for r in raw_records]
+
+    scraped_at = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+    index_path = SOURCE_DIR / "index.jsonl"
+    with index_path.open("w", encoding="utf-8") as f:
+        for doc in index_docs:
+            f.write(json.dumps({**doc, "scraped_at": scraped_at}) + "\n")
+    log.info("Wrote %d index records to %s", len(index_docs), index_path)
+
+    # ------------------------------------------------------------------
+    # Step 2: scrape each detail page
+    # ------------------------------------------------------------------
+    if args.limit:
+        index_docs = index_docs[: args.limit]
+
+    ok = skipped = failed = 0
+    total = len(index_docs)
+
+    for i, doc in enumerate(index_docs, 1):
+        result = scrape_detail(session, rate, doc, force=args.force)
+
+        if result is None:
+            skipped += 1
+            continue
+
+        dest = DETAIL_DIR / f"{doc['id']:06d}.json"
+        try:
+            dest.write_text(
+                json.dumps(result, indent=2, ensure_ascii=False), encoding="utf-8"
+            )
+            ok += 1
+            log.debug("Saved %s", dest.name)
+        except OSError as exc:
+            log.warning("Could not write %s: %s", dest, exc)
+            failed += 1
+
+        if i % 25 == 0 or i == total:
+            log.info(
+                "Progress: %d/%d — ok=%d  skipped=%d  failed=%d",
+                i,
+                total,
+                ok,
+                skipped,
+                failed,
+            )
+
+    log.info("Done — ok=%d  skipped=%d  failed=%d", ok, skipped, failed)
+
+
+if __name__ == "__main__":
+    main()

scripts/plans/01_scrape.py

@@ -0,0 +1,324 @@
+#!/usr/bin/env python3
+"""
+scrape_plans.py — Fetch the RocketReviews.com plans index and scrape each
+detail page, saving structured JSON to source/plans/.
+
+Output
+------
+    source/plans/index.jsonl        one record per plan (raw index fields)
+    source/plans/detail/{slug}.json full parsed detail per plan
+
+Usage
+-----
+    python scripts/plans/01_scrape.py
+    python scripts/plans/01_scrape.py --delay 1.0 --limit 10
+    python scripts/plans/01_scrape.py --force   # re-scrape existing files
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import re
+import sys
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional
+
+import requests
+from bs4 import BeautifulSoup
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+
+# ---------------------------------------------------------------------------
+# Config
+# ---------------------------------------------------------------------------
+
+BASE_URL = "https://www.rocketreviews.com"
+INDEX_URL = f"{BASE_URL}/rocketry-plans.html"
+USER_AGENT = "RocketReviews-Dataset/1.0"
+DEFAULT_DELAY = 1.0
+
+ROOT = Path(__file__).parent.parent.parent
+SOURCE_DIR = ROOT / "source" / "plans"
+DETAIL_DIR = SOURCE_DIR / "detail"
+
+# ---------------------------------------------------------------------------
+# Logging
+# ---------------------------------------------------------------------------
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s %(levelname)s %(message)s",
+    handlers=[logging.StreamHandler(sys.stdout)],
+)
+log = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# HTTP session
+# ---------------------------------------------------------------------------
+
+
+def _build_session() -> requests.Session:
+    s = requests.Session()
+    s.headers["User-Agent"] = USER_AGENT
+    retry = Retry(
+        total=3,
+        backoff_factor=2.0,
+        status_forcelist=[429, 500, 502, 503, 504],
+        allowed_methods=["GET"],
+    )
+    s.mount("https://", HTTPAdapter(max_retries=retry))
+    s.mount("http://", HTTPAdapter(max_retries=retry))
+    return s
+
+
+class RateLimiter:
+    def __init__(self, delay: float) -> None:
+        self.delay = delay
+        self._last: float = 0.0
+
+    def wait(self) -> None:
+        elapsed = time.monotonic() - self._last
+        if elapsed < self.delay:
+            time.sleep(self.delay - elapsed)
+        self._last = time.monotonic()
+
+
+# ---------------------------------------------------------------------------
+# Parsing helpers
+# ---------------------------------------------------------------------------
+
+
+def _slug_from_path(path: str) -> str:
+    """
+    Extract the slug from a url path.
+    e.g. '/1940-exploratory-planetary-cargo-ferry-180703114912.html' ->
+         '1940-exploratory-planetary-cargo-ferry'
+    """
+    name = path.lstrip("/").removesuffix(".html")
+    # Remove trailing -NNNNNNNNNNNN timestamp (12-digit numeric suffix)
+    name = re.sub(r"-\d{10,}$", "", name)
+    return name
+
+
+def _parse_index(html: str) -> list[dict]:
+    """
+    Parse the rocketry-plans.html static page and return one record
+    per plan from the main data table.
+    """
+    soup = BeautifulSoup(html, "lxml")
+    records = []
+
+    # The plans table is typically the last large table on the page
+    tables = soup.find_all("table")
+    table = tables[-1] if tables else None
+    
+    if not table:
+        log.warning("Could not find the plans table on the index page.")
+        return records
+
+    # Skip the header row
+    for row in table.find_all("tr")[1:]:
+        cells = row.find_all(["td", "th"])
+        if len(cells) < 5:
+            continue
+            
+        # 1: Source, 2: Title (link to detail), 3: Style, 4: Site (external link)
+        source = cells[1].get_text(strip=True) or None
+        
+        title_a = cells[2].find("a")
+        title_trunc = title_a.get_text(strip=True) if title_a else cells[2].get_text(strip=True)
+        
+        detail_path = title_a["href"] if title_a and title_a.has_attr("href") else None
+        
+        # Skip if there's no detail page link to use as an identifier
+        if not detail_path:
+            continue
+            
+        detail_url = detail_path if detail_path.startswith("http") else f"{BASE_URL}{detail_path}"
+        slug = _slug_from_path(detail_path)
+        
+        style = cells[3].get_text(strip=True) or None
+        
+        site_a = cells[4].find("a")
+        site_name = site_a.get_text(strip=True) if site_a else cells[4].get_text(strip=True)
+        external_url = site_a["href"] if site_a and site_a.has_attr("href") else None
+        
+        # In case it's just plain text without a link, normalize empty string to None
+        if not site_name:
+            site_name = None
+
+        records.append({
+            "slug": slug,
+            "title_truncated": title_trunc,
+            "source": source,
+            "style": style,
+            "site": {
+                "name": site_name,
+                "url": external_url
+            },
+            "url": detail_url
+        })
+
+    return records
+
+
+def _parse_detail(html: str, index_rec: dict) -> dict:
+    """Merge index-level fields with full title from the detail page."""
+    soup = BeautifulSoup(html, "lxml")
+    
+    # Try to extract the full title from the h1 on the detail page
+    h1 = soup.find("h1")
+    full_title = None
+    if h1:
+        # Example: "Rocketry Plans/Instructions - Model Rocket News 1940 Exploratory Planetary Cargo Ferry"
+        raw_h1 = h1.get_text(strip=True)
+        full_title = re.sub(r"^Rocketry Plans/Instructions\s*-\s*", "", raw_h1, flags=re.I).strip()
+        
+    # If the h1 wasn't found or was weird, fall back to what we had
+    if not full_title:
+        full_title = index_rec.get("title_truncated")
+        
+    # Exclude title_truncated from the final output and replace with full title
+    out_rec = {k: v for k, v in index_rec.items() if k != "title_truncated"}
+        
+    return {
+        **out_rec,
+        "title": full_title,
+        "scraped_at": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+    }
+
+
+# ---------------------------------------------------------------------------
+# Fetch helpers
+# ---------------------------------------------------------------------------
+
+
+def fetch_index(session: requests.Session) -> list[dict]:
+    log.info("Fetching plans index from %s", INDEX_URL)
+    resp = session.get(INDEX_URL, timeout=30)
+    resp.raise_for_status()
+    records = _parse_index(resp.text)
+    log.info("Index returned %d records.", len(records))
+    return records
+
+
+def scrape_detail(
+    session: requests.Session,
+    rate: RateLimiter,
+    index_rec: dict,
+    force: bool = False,
+) -> Optional[dict]:
+    slug = index_rec["slug"]
+    dest = DETAIL_DIR / f"{slug}.json"
+
+    if dest.exists() and not force:
+        log.debug("Already scraped %s, skipping.", slug)
+        return None
+
+    url = index_rec["url"]
+    rate.wait()
+
+    try:
+        resp = session.get(url, timeout=30)
+        resp.raise_for_status()
+    except requests.RequestException as exc:
+        log.warning("Failed to fetch plan %s: %s", slug, exc)
+        return None
+
+    return _parse_detail(resp.text, index_rec)
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Scrape RocketReviews.com plans.")
+    parser.add_argument(
+        "--delay",
+        type=float,
+        default=DEFAULT_DELAY,
+        help=f"Seconds between requests (default: {DEFAULT_DELAY})",
+    )
+    parser.add_argument(
+        "--limit",
+        type=int,
+        default=None,
+        help="Stop after scraping this many detail pages (useful for testing)",
+    )
+    parser.add_argument(
+        "--force",
+        action="store_true",
+        help="Re-scrape plans that already have a saved detail file",
+    )
+    args = parser.parse_args()
+
+    SOURCE_DIR.mkdir(parents=True, exist_ok=True)
+    DETAIL_DIR.mkdir(parents=True, exist_ok=True)
+
+    session = _build_session()
+    rate = RateLimiter(args.delay)
+
+    # ------------------------------------------------------------------
+    # Step 1: fetch index and write index.jsonl
+    # ------------------------------------------------------------------
+    records = fetch_index(session)
+
+    scraped_at = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+    index_path = SOURCE_DIR / "index.jsonl"
+    with index_path.open("w", encoding="utf-8") as f:
+        for rec in records:
+            # We want to output full 'title' to index.jsonl if possible, 
+            # but since we only have truncated title right now, we'll write that as 'title'
+            out_rec = {k: v for k, v in rec.items() if k != "title_truncated"}
+            out_rec["title"] = rec["title_truncated"]
+            f.write(json.dumps({**out_rec, "scraped_at": scraped_at}) + "\n")
+    log.info("Wrote %d index records to %s", len(records), index_path)
+
+    # ------------------------------------------------------------------
+    # Step 2: scrape each detail page
+    # ------------------------------------------------------------------
+    if args.limit:
+        records = records[: args.limit]
+
+    ok = skipped = failed = 0
+    total = len(records)
+
+    for i, rec in enumerate(records, 1):
+        result = scrape_detail(session, rate, rec, force=args.force)
+
+        if result is None:
+            skipped += 1
+            continue
+
+        dest = DETAIL_DIR / f"{rec['slug']}.json"
+        try:
+            dest.write_text(
+                json.dumps(result, indent=2, ensure_ascii=False), encoding="utf-8"
+            )
+            ok += 1
+            log.debug("Saved %s", dest.name)
+        except OSError as exc:
+            log.warning("Could not write %s: %s", dest, exc)
+            failed += 1
+
+        if i % 25 == 0 or i == total:
+            log.info(
+                "Progress: %d/%d — ok=%d  skipped=%d  failed=%d",
+                i,
+                total,
+                ok,
+                skipped,
+                failed,
+            )
+
+    log.info("Done — ok=%d  skipped=%d  failed=%d", ok, skipped, failed)
+
+
+if __name__ == "__main__":
+    main()

scripts/products/01_scrape.py

@@ -0,0 +1,409 @@
+#!/usr/bin/env python3
+"""
+scrape_products.py — Fetch the RocketReviews.com product index and scrape each
+detail page, saving structured JSON to source/products/.
+
+Output
+------
+    source/products/index.jsonl        one record per product (raw index fields)
+    source/products/detail/{id}.json   full parsed detail per product
+
+Usage
+-----
+    python scripts/products/01_scrape.py
+    python scripts/products/01_scrape.py --delay 2.0 --limit 10
+    python scripts/products/01_scrape.py --force   # re-scrape existing files
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import re
+import sys
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional
+
+import requests
+from bs4 import BeautifulSoup, NavigableString, Tag
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+
+# ---------------------------------------------------------------------------
+# Config
+# ---------------------------------------------------------------------------
+
+BASE_URL = "https://www.rocketreviews.com"
+INDEX_URL = f"{BASE_URL}/data/products/products.php?search=&type="
+USER_AGENT = "RocketReviews-Dataset/1.0"
+DEFAULT_DELAY = 1.0  # seconds between requests
+
+ROOT = Path(__file__).parent.parent.parent
+SOURCE_DIR = ROOT / "source" / "products"
+DETAIL_DIR = SOURCE_DIR / "detail"
+
+# ---------------------------------------------------------------------------
+# Logging
+# ---------------------------------------------------------------------------
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s %(levelname)s %(message)s",
+    handlers=[logging.StreamHandler(sys.stdout)],
+)
+log = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# HTTP session
+# ---------------------------------------------------------------------------
+
+
+def _build_session() -> requests.Session:
+    s = requests.Session()
+    s.headers["User-Agent"] = USER_AGENT
+    retry = Retry(
+        total=3,
+        backoff_factor=2.0,
+        status_forcelist=[429, 500, 502, 503, 504],
+        allowed_methods=["GET"],
+    )
+    s.mount("https://", HTTPAdapter(max_retries=retry))
+    s.mount("http://", HTTPAdapter(max_retries=retry))
+    return s
+
+
+class RateLimiter:
+    def __init__(self, delay: float) -> None:
+        self.delay = delay
+        self._last: float = 0.0
+
+    def wait(self) -> None:
+        elapsed = time.monotonic() - self._last
+        if elapsed < self.delay:
+            time.sleep(self.delay - elapsed)
+        self._last = time.monotonic()
+
+
+# ---------------------------------------------------------------------------
+# Parsing helpers
+# ---------------------------------------------------------------------------
+
+
+def _re_first(pattern: str, text: str, group: int = 1) -> Optional[str]:
+    m = re.search(pattern, text)
+    return m.group(group) if m else None
+
+
+def _slug_to_label(slug: str) -> str:
+    """Convert a hyphenated slug to a title-cased label."""
+    return slug.replace("-", " ").title()
+
+
+def _kit_index_int(field: str, html: str) -> Optional[int]:
+    """
+    Extract an integer value from a /kit-index-{field}-{value}.html href.
+    Used for fields stored as integers (e.g. skill-level).
+    """
+    val = _re_first(rf"/kit-index-{field}-(\d+)\.html", html)
+    return int(val) if val else None
+
+
+def _kit_index_scaled(field: str, html: str, scale: int = 10000) -> Optional[float]:
+    """
+    Extract a scaled integer from a /kit-index-{field}-{value}.html href
+    and divide by scale. Used for diameter, length, weight (4 decimal places).
+    """
+    val = _re_first(rf"/kit-index-{field}-(\d+)\.html", html)
+    return int(val) / scale if val else None
+
+
+def _kit_index_slug(field: str, html: str) -> Optional[str]:
+    """
+    Extract and humanize a slug value from a /kit-index-{field}-{slug}.html href.
+    Used for power class, recovery type, status.
+    """
+    val = _re_first(rf"/kit-index-{field}-([a-z][a-z-]*)\.html", html)
+    return _slug_to_label(val) if val else None
+
+
+def _parse_manufacturer(html: str, soup: BeautifulSoup) -> dict:
+    """Extract manufacturer name and URLs from the page."""
+    # Canonical manufacturer page: e.g. /estes-1093.html
+    mfr_canonical = _re_first(r'href="(/[a-z][a-z0-9-]+-\d+\.html)"', html)
+    url = f"{BASE_URL}{mfr_canonical}" if mfr_canonical else None
+
+    # Alias: kit-index filter page e.g. /kit-index-manufacturer-estes.html
+    mfr_alias = _re_first(r"(/kit-index-manufacturer-[^\"']+\.html)", html)
+    url_alias = f"{BASE_URL}{mfr_alias}" if mfr_alias else None
+
+    mfr_link = soup.find("a", href=re.compile(r"/kit-index-manufacturer-"))
+    name = mfr_link.get_text(strip=True) if mfr_link else None
+    return {
+        "name": name,
+        "url": url,
+        "url_alias": url_alias,
+    }
+
+
+def _parse_designer(html: str) -> Optional[dict]:
+    """
+    Extract designer name and URL from /kit-index-designer-{name}-{id}.html.
+    Returns None if no designer is present.
+    """
+    m = re.search(r"(/kit-index-designer-([a-z][a-z-]*)-\d+\.html)", html)
+    if not m:
+        return None
+    return {
+        "name": _slug_to_label(m.group(2)),
+        "url": f"{BASE_URL}{m.group(1)}",
+    }
+
+
+def _parse_styles(html: str) -> list[str]:
+    """Extract all style labels from /kit-index-style-{name}-{id}.html hrefs."""
+    return [
+        _slug_to_label(m)
+        for m in re.findall(r"/kit-index-style-([a-z][a-z-]*)-\d+\.html", html)
+    ]
+
+
+def _parse_recommended_motors(soup: BeautifulSoup) -> list[str]:
+    """
+    Find the 'Recommended Motors' label and extract the motor designations
+    that follow it as comma-separated text.
+    """
+    strong = soup.find("strong", string=re.compile(r"Recommended Motors?", re.I))
+    if not strong:
+        return []
+    # Collect text from following siblings until next <strong>
+    text = ""
+    for sib in strong.next_siblings:
+        if isinstance(sib, Tag) and sib.name == "strong":
+            break
+        text += sib.get_text() if isinstance(sib, Tag) else str(sib)
+    motors = [m.strip() for m in re.split(r"[,\s]+", text.strip()) if m.strip()]
+    return motors
+
+
+def _parse_cp(html: str) -> Optional[dict]:
+    """
+    Extract CP location and method if present on the product page.
+    CP location href: /kit-index-cp-{value}.html (value = inches * 10000)
+    CP method href: /kit-index-cpmethod-{slug}.html
+    Direction (Front/Rear) extracted from surrounding text.
+    """
+    location_raw = _re_first(r"/kit-index-cp-(\d+)\.html", html)
+    if not location_raw:
+        return None
+
+    location_in = int(location_raw) / 10000
+
+    # Determine direction from surrounding text
+    direction = "Front"
+    m = re.search(r"(\d+\.\d+)\s+inches\s+from\s+(Front|Rear)", html, re.I)
+    if m:
+        direction = m.group(2).title()
+
+    method_slug = _re_first(r"/kit-index-cpmethod-([a-z][a-z/]*[a-z-]*)\.html", html)
+    method = _slug_to_label(method_slug) if method_slug else None
+
+    return {
+        "location_in": location_in,
+        "location_from": direction,
+        "method": method,
+    }
+
+
+def _parse_specs(html: str, soup: BeautifulSoup) -> Optional[dict]:
+    """
+    Parse kit-specific structured specs from /kit-index-{field}-{value}.html
+    link patterns. Returns None for non-kit product types that lack specs.
+    """
+    diameter = _kit_index_scaled("diameter", html)
+    length = _kit_index_scaled("length", html)
+    weight = _kit_index_scaled("weight", html)
+    motor_size = _kit_index_int("motor-size", html)
+    skill_level = _kit_index_int("skill-level", html)
+    power_class = _kit_index_slug("power", html)
+    recovery = _kit_index_slug("recovery", html)
+    status_slug = _re_first(r"/kit-index-status-([a-z][a-z-]*)\.html", html)
+    status = _slug_to_label(status_slug) if status_slug else None
+    styles = _parse_styles(html)
+    recommended_motors = _parse_recommended_motors(soup)
+
+    # If none of the kit-specific fields are present, this isn't a kit-type page
+    if not any([diameter, length, weight, motor_size, skill_level, power_class]):
+        return None
+
+    return {
+        "diameter_in": diameter,
+        "length_in": length,
+        "weight_oz": weight,
+        "motor_size_mm": motor_size,
+        "power_class": power_class,
+        "skill_level": skill_level,
+        "style": styles,
+        "recovery": recovery,
+        "status": status,
+        "recommended_motors": recommended_motors,
+    }
+
+
+def _parse_detail(html: str, index_rec: dict) -> dict:
+    soup = BeautifulSoup(html, "lxml")
+    product_id = int(index_rec["id"])
+
+    # Canonical URL is directly constructable from the product ID
+    url = f"{BASE_URL}/product-{product_id}.html"
+
+    # Alias URL from the index
+    alias_path = index_rec.get("url", "")
+    url_alias = f"{BASE_URL}{alias_path}" if alias_path else None
+
+    return {
+        "id": product_id,
+        "url": url,
+        "url_alias": url_alias,
+        "name": index_rec.get("name"),
+        "title": index_rec.get("title"),
+        "type": index_rec.get("type"),
+        "model": index_rec.get("model") or None,
+        "years": index_rec.get("years") or None,
+        "manufacturer": _parse_manufacturer(html, soup),
+        "designer": _parse_designer(html),
+        "scraped_at": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+        "specs": _parse_specs(html, soup),
+        "cp": _parse_cp(html),
+    }
+
+
+# ---------------------------------------------------------------------------
+# Fetch helpers
+# ---------------------------------------------------------------------------
+
+
+def fetch_index(session: requests.Session) -> list[dict]:
+    log.info("Fetching product index from %s", INDEX_URL)
+    resp = session.get(INDEX_URL, timeout=30)
+    resp.raise_for_status()
+    records = resp.json().get("records", [])
+    log.info("Index returned %d records.", len(records))
+    return records
+
+
+def scrape_detail(
+    session: requests.Session,
+    rate: RateLimiter,
+    index_rec: dict,
+    force: bool = False,
+) -> Optional[dict]:
+    product_id = index_rec["id"]
+    dest = DETAIL_DIR / f"{int(product_id):06d}.json"
+
+    if dest.exists() and not force:
+        log.debug("Already scraped %s, skipping.", product_id)
+        return None
+
+    # Use canonical URL directly — constructable from the ID
+    url = f"{BASE_URL}/product-{product_id}.html"
+    rate.wait()
+
+    try:
+        resp = session.get(url, timeout=30)
+        resp.raise_for_status()
+    except requests.RequestException as exc:
+        log.warning("Failed to fetch product %s: %s", product_id, exc)
+        return None
+
+    return _parse_detail(resp.text, index_rec)
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Scrape RocketReviews.com products.")
+    parser.add_argument(
+        "--delay",
+        type=float,
+        default=DEFAULT_DELAY,
+        help=f"Seconds between requests (default: {DEFAULT_DELAY})",
+    )
+    parser.add_argument(
+        "--limit",
+        type=int,
+        default=None,
+        help="Stop after scraping this many detail pages (useful for testing)",
+    )
+    parser.add_argument(
+        "--force",
+        action="store_true",
+        help="Re-scrape products that already have a saved detail file",
+    )
+    args = parser.parse_args()
+
+    SOURCE_DIR.mkdir(parents=True, exist_ok=True)
+    DETAIL_DIR.mkdir(parents=True, exist_ok=True)
+
+    session = _build_session()
+    rate = RateLimiter(args.delay)
+
+    # ------------------------------------------------------------------
+    # Step 1: fetch and write the full index
+    # ------------------------------------------------------------------
+    records = fetch_index(session)
+
+    scraped_at = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+    index_path = SOURCE_DIR / "index.jsonl"
+    with index_path.open("w", encoding="utf-8") as f:
+        for rec in records:
+            f.write(json.dumps({**rec, "scraped_at": scraped_at}) + "\n")
+    log.info("Wrote %d index records to %s", len(records), index_path)
+
+    # ------------------------------------------------------------------
+    # Step 2: scrape each detail page
+    # ------------------------------------------------------------------
+    if args.limit:
+        records = records[: args.limit]
+
+    ok = skipped = failed = 0
+    total = len(records)
+
+    for i, rec in enumerate(records, 1):
+        result = scrape_detail(session, rate, rec, force=args.force)
+
+        if result is None:
+            skipped += 1
+            continue
+
+        dest = DETAIL_DIR / f"{int(rec['id']):06d}.json"
+        try:
+            dest.write_text(
+                json.dumps(result, indent=2, ensure_ascii=False), encoding="utf-8"
+            )
+            ok += 1
+            log.debug("Saved %s", dest.name)
+        except OSError as exc:
+            log.warning("Could not write %s: %s", dest, exc)
+            failed += 1
+
+        if i % 25 == 0 or i == total:
+            log.info(
+                "Progress: %d/%d — ok=%d  skipped=%d  failed=%d",
+                i,
+                total,
+                ok,
+                skipped,
+                failed,
+            )
+
+    log.info("Done — ok=%d  skipped=%d  failed=%d", ok, skipped, failed)
+
+
+if __name__ == "__main__":
+    main()

scripts/reviews/01_scrape.py

@@ -0,0 +1,391 @@
+#!/usr/bin/env python3
+"""
+scrape_reviews.py — Fetch the RocketReviews.com review index and scrape each
+detail page, saving structured JSON to source/reviews/.
+
+Output
+------
+    source/reviews/index.jsonl        one record per review (raw index fields)
+    source/reviews/detail/{id}.json   full parsed detail per review
+
+Usage
+-----
+    python scripts/scrape_reviews.py
+    python scripts/scrape_reviews.py --delay 2.0 --limit 10
+    python scripts/scrape_reviews.py --force   # re-scrape existing files
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import re
+import sys
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional
+
+import requests
+from bs4 import BeautifulSoup, NavigableString, Tag
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+
+# ---------------------------------------------------------------------------
+# Config
+# ---------------------------------------------------------------------------
+
+BASE_URL = "https://www.rocketreviews.com"
+INDEX_URL = f"{BASE_URL}/data/reviews/reviews.php"
+USER_AGENT = "RocketReviews-Dataset/1.0"
+DEFAULT_DELAY = 1.0  # seconds between requests
+
+ROOT = Path(__file__).parent.parent.parent
+SOURCE_DIR = ROOT / "source" / "reviews"
+DETAIL_DIR = SOURCE_DIR / "detail"
+
+# ---------------------------------------------------------------------------
+# Logging
+# ---------------------------------------------------------------------------
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s %(levelname)s %(message)s",
+    handlers=[logging.StreamHandler(sys.stdout)],
+)
+log = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# HTTP session
+# ---------------------------------------------------------------------------
+
+
+def _build_session() -> requests.Session:
+    s = requests.Session()
+    s.headers["User-Agent"] = USER_AGENT
+    retry = Retry(
+        total=3,
+        backoff_factor=2.0,
+        status_forcelist=[429, 500, 502, 503, 504],
+        allowed_methods=["GET"],
+    )
+    s.mount("https://", HTTPAdapter(max_retries=retry))
+    s.mount("http://", HTTPAdapter(max_retries=retry))
+    return s
+
+
+class RateLimiter:
+    def __init__(self, delay: float) -> None:
+        self.delay = delay
+        self._last: float = 0.0
+
+    def wait(self) -> None:
+        elapsed = time.monotonic() - self._last
+        if elapsed < self.delay:
+            time.sleep(self.delay - elapsed)
+        self._last = time.monotonic()
+
+
+# ---------------------------------------------------------------------------
+# Parsing helpers
+# ---------------------------------------------------------------------------
+
+
+def _re_first(pattern: str, text: str, group: int = 1) -> Optional[str]:
+    m = re.search(pattern, text)
+    return m.group(group) if m else None
+
+
+def _parse_rating_block(soup: BeautifulSoup, label: str) -> Optional[int]:
+    """
+    Find '<strong>{label} Rating:</strong>' and count filled Material Icons
+    stars ('star') that follow it, excluding 'star_border' (empty stars).
+    """
+    strong = soup.find("strong", string=re.compile(rf"^{label} Rating:?$", re.I))
+    if not strong:
+        return None
+
+    # Collect raw text from siblings until the next <strong> tag
+    text = ""
+    for sib in strong.next_siblings:
+        if isinstance(sib, Tag) and sib.name == "strong":
+            break
+        text += sib.get_text() if isinstance(sib, Tag) else str(sib)
+
+    # Count 'star' occurrences that are NOT 'star_border'
+    filled = len(re.findall(r"\bstar\b(?!_border)", text))
+    return filled if filled else None
+
+
+def _parse_ratings(soup: BeautifulSoup) -> dict:
+    return {
+        "construction": _parse_rating_block(soup, "Construction"),
+        "flight": _parse_rating_block(soup, "Flight"),
+        "overall": _parse_rating_block(soup, "Overall"),
+    }
+
+
+def _parse_product(soup: BeautifulSoup) -> dict:
+    html = str(soup)
+
+    # Diameter: /kit-index-diameter-13260.html → 13260 / 10000 = 1.3260 inches
+    diameter_raw = _re_first(r"/kit-index-diameter-(\d+)\.html", html)
+    diameter = int(diameter_raw) / 10000 if diameter_raw else None
+
+    # Length: /kit-index-length-290000.html → 290000 / 10000 = 29.0000 inches
+    length_raw = _re_first(r"/kit-index-length-(\d+)\.html", html)
+    length = int(length_raw) / 10000 if length_raw else None
+
+    # Skill level: /kit-index-skilllevel-1.html → 1
+    skill_raw = _re_first(r"/kit-index-skilllevel-(\d+)\.html", html)
+    skill = int(skill_raw) if skill_raw else None
+
+    # Style: /kit-index-style-{name}-{id}.html — one or more values
+    styles = [
+        m.replace("-", " ").title()
+        for m in re.findall(r"/kit-index-style-([a-z][a-z-]*)-\d+\.html", html)
+    ]
+
+    # Price: first dollar amount mentioned in the page text
+    price_raw = _re_first(r"\$\s*(\d+(?:\.\d{1,2})?)", soup.get_text())
+    price = float(price_raw) if price_raw else None
+
+    return {
+        "diameter_in": diameter,
+        "length_in": length,
+        "skill_level": skill,
+        "style": styles,
+        "price_usd": price,
+    }
+
+
+# Section headings that contain grids/tables rather than review text
+_SKIP_SECTION_RE = re.compile(
+    r"^\s*(flights?|.*reviews?|what you can do|sign in|create account)\s*$",
+    re.I,
+)
+
+
+def _parse_sections(soup: BeautifulSoup) -> dict[str, str]:
+    """
+    Walk all h2/h4 headings and collect the plain text that follows each one
+    until the next heading of the same or higher level. Skips headings that
+    correspond to data grids (flight logs, related reviews).
+    """
+    sections: dict[str, str] = {}
+
+    for heading in soup.find_all(["h2", "h4"]):
+        title = heading.get_text(strip=True)
+        if not title or _SKIP_SECTION_RE.match(title):
+            continue
+
+        parts: list[str] = []
+        for sib in heading.next_siblings:
+            if isinstance(sib, Tag) and sib.name in ("h2", "h4"):
+                break
+            if isinstance(sib, Tag):
+                text = sib.get_text(separator=" ", strip=True)
+            elif isinstance(sib, NavigableString):
+                text = str(sib).strip()
+            else:
+                continue
+            if text:
+                parts.append(text)
+
+        content = " ".join(parts).strip()
+        if content:
+            sections[title] = content
+
+    return sections
+
+
+def _parse_detail(html: str, index_rec: dict) -> dict:
+    soup = BeautifulSoup(html, "lxml")
+
+    # Canonical URL from any /review-{N}.html href in the page
+    canonical_path = _re_first(r'href=["\']?(/review-\d+\.html)', html)
+    canonical_url = f"{BASE_URL}{canonical_path}" if canonical_path else None
+
+    # Alias URL — slug URL from the index
+    alias_path = index_rec.get("url", "")
+    url_alias = f"{BASE_URL}{alias_path}" if alias_path else None
+
+    # Kit URL constructed from the Kit_ID in the JS data source
+    # e.g. data/flightlog/flights.php?column=Kit_ID&value=7163
+    kit_id_raw = _re_first(r"Kit_ID&value=(-?\d+)", html)
+    kit_id_int = int(kit_id_raw) if kit_id_raw else None
+    kit_url = f"{BASE_URL}/product-{kit_id_int}.html" if kit_id_int and kit_id_int > 0 else None
+
+    # Manufacturer canonical URL: e.g. /estes-1093.html
+    mfr_canonical = _re_first(r'href="(/[a-z][a-z0-9-]+-\d+\.html)"', html)
+    manufacturer_url = f"{BASE_URL}{mfr_canonical}" if mfr_canonical else None
+
+    # Manufacturer alias URL from the kit-index filter link
+    # e.g. /kit-index-manufacturer-estes.html
+    mfr_alias = _re_first(r"(/kit-index-manufacturer-[^\"']+\.html)", html)
+    manufacturer_url_alias = f"{BASE_URL}{mfr_alias}" if mfr_alias else None
+
+    # Manufacturer name from the kit-index link (more reliable than the index field)
+    manufacturer = index_rec.get("manufacturer") or None
+    mfr_link = soup.find("a", href=re.compile(r"/kit-index-manufacturer-"))
+    if mfr_link:
+        manufacturer = mfr_link.get_text(strip=True) or manufacturer
+
+    # Contributor URL from profile link with 4+ digit numeric suffix
+    # e.g. /darrell-ritchies-darrell-8979.html
+    contributor_path = _re_first(r"(/[a-z][a-z0-9-]+-\d{4,}\.html)", html)
+    contributor_url = f"{BASE_URL}{contributor_path}" if contributor_path else None
+
+    return {
+        "id": int(index_rec["id"]),
+        "url": canonical_url,
+        "url_alias": url_alias,
+        "date": index_rec.get("date"),
+        "contributor": index_rec.get("contributor"),
+        "contributor_url": contributor_url,
+        "kit": index_rec.get("kit"),
+        "kit_url": kit_url,
+        "manufacturer": manufacturer,
+        "manufacturer_url": manufacturer_url,
+        "manufacturer_url_alias": manufacturer_url_alias,
+        "type": index_rec.get("type"),
+        "scraped_at": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+        "ratings": _parse_ratings(soup),
+        "product": _parse_product(soup),
+        "sections": _parse_sections(soup),
+    }
+
+
+# ---------------------------------------------------------------------------
+# Fetch helpers
+# ---------------------------------------------------------------------------
+
+
+def fetch_index(session: requests.Session) -> list[dict]:
+    log.info("Fetching review index from %s", INDEX_URL)
+    resp = session.get(INDEX_URL, timeout=30)
+    resp.raise_for_status()
+    records = resp.json().get("records", [])
+    log.info("Index returned %d records.", len(records))
+    return records
+
+
+def scrape_detail(
+    session: requests.Session,
+    rate: RateLimiter,
+    index_rec: dict,
+    force: bool = False,
+) -> Optional[dict]:
+    review_id = index_rec["id"]
+    dest = DETAIL_DIR / f"{int(review_id):06d}.json"
+
+    if dest.exists() and not force:
+        log.debug("Already scraped %s, skipping.", review_id)
+        return None
+
+    alias_path = index_rec.get("url", "")
+    if not alias_path:
+        log.warning("No URL for review %s, skipping.", review_id)
+        return None
+
+    url = f"{BASE_URL}{alias_path}"
+    rate.wait()
+
+    try:
+        resp = session.get(url, timeout=30)
+        resp.raise_for_status()
+    except requests.RequestException as exc:
+        log.warning("Failed to fetch review %s: %s", review_id, exc)
+        return None
+
+    return _parse_detail(resp.text, index_rec)
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Scrape RocketReviews.com reviews.")
+    parser.add_argument(
+        "--delay",
+        type=float,
+        default=DEFAULT_DELAY,
+        help=f"Seconds between requests (default: {DEFAULT_DELAY})",
+    )
+    parser.add_argument(
+        "--limit",
+        type=int,
+        default=None,
+        help="Stop after scraping this many detail pages (useful for testing)",
+    )
+    parser.add_argument(
+        "--force",
+        action="store_true",
+        help="Re-scrape reviews that already have a saved detail file",
+    )
+    args = parser.parse_args()
+
+    SOURCE_DIR.mkdir(parents=True, exist_ok=True)
+    DETAIL_DIR.mkdir(parents=True, exist_ok=True)
+
+    session = _build_session()
+    rate = RateLimiter(args.delay)
+
+    # ------------------------------------------------------------------
+    # Step 1: fetch and write the full index
+    # ------------------------------------------------------------------
+    records = fetch_index(session)
+
+    scraped_at = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+    index_path = SOURCE_DIR / "index.jsonl"
+    with index_path.open("w", encoding="utf-8") as f:
+        for rec in records:
+            f.write(json.dumps({**rec, "scraped_at": scraped_at}) + "\n")
+    log.info("Wrote %d index records to %s", len(records), index_path)
+
+    # ------------------------------------------------------------------
+    # Step 2: scrape each detail page
+    # ------------------------------------------------------------------
+    if args.limit:
+        records = records[: args.limit]
+
+    ok = skipped = failed = 0
+    total = len(records)
+
+    for i, rec in enumerate(records, 1):
+        result = scrape_detail(session, rate, rec, force=args.force)
+
+        if result is None:
+            # Already exists and --force not set, or missing URL
+            skipped += 1
+            continue
+
+        dest = DETAIL_DIR / f"{int(rec['id']):06d}.json"
+        try:
+            dest.write_text(
+                json.dumps(result, indent=2, ensure_ascii=False), encoding="utf-8"
+            )
+            ok += 1
+            log.debug("Saved %s", dest.name)
+        except OSError as exc:
+            log.warning("Could not write %s: %s", dest, exc)
+            failed += 1
+
+        if i % 25 == 0 or i == total:
+            log.info(
+                "Progress: %d/%d — ok=%d  skipped=%d  failed=%d",
+                i,
+                total,
+                ok,
+                skipped,
+                failed,
+            )
+
+    log.info("Done — ok=%d  skipped=%d  failed=%d", ok, skipped, failed)
+
+
+if __name__ == "__main__":
+    main()

source/clubs/detail/000001.json

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

source/clubs/detail/000002.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6bc2d949d5aa311358d57e02717062d28d98a7bc30d8e4a6a5bfb6feb55d9458
+size 728

source/clubs/detail/000003.json

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

source/clubs/detail/000021.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2bb5c9e9221781a3d0552853137e015233387f260f503c1e06e7a6b7f3895c22
+size 631

source/clubs/detail/000022.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:89f6a99a963bfe59caf5de40d89ba0ecedb2915e991f7add14e0ddeaaacb5168
+size 662

source/clubs/detail/000023.json

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

source/clubs/detail/000026.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:35b3b49c42cee70dd75e5e96d2f341ac92999cf638e756b27f291b858bde74b5
+size 548

source/clubs/detail/000027.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:33b1ecd6978b594020b690a05cfebf24eefdf33e902b6291baa3a8d980659aeb
+size 621

source/clubs/detail/000028.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:012a858e5149e8207b45039d92b73c741ba44909449ad7d59fe5fd1395408c0e
+size 551

source/clubs/detail/000029.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2dc1ebc91c28c5b0b798207637729ae3ffba2157c0000fa22cc8243a70609e62
+size 526

source/clubs/detail/000030.json

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

source/clubs/detail/000031.json

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

source/clubs/detail/000032.json

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

source/clubs/detail/000033.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:94be22603c093330f5909122e4f2ead6183a2f2453c049b9fb50be86d88cdf32
+size 719

source/clubs/detail/000034.json

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

source/clubs/detail/000035.json

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

source/clubs/detail/000036.json

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

source/clubs/detail/000037.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:64e29a13e57a02eefd8ce2df504c101c98fb033c93bcb49a3caeffb8da2800b9
+size 533

source/clubs/detail/000038.json

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

source/clubs/detail/000039.json

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

source/clubs/detail/000040.json

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

source/clubs/detail/000041.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0074407481c9e36145b07ee763613254aabcf193c4a6df5f5f15dca9ba329d7b
+size 569

source/clubs/detail/000042.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7d6d264e2c3c30b967d8bd0247c50a12c5cc8be6ed7a5612a231e28325a26cc5
+size 504

source/clubs/detail/000043.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0783822b4163e611adc29ad1b3fc9a20dae5c66ae00ee51e38e05c8a672cac71
+size 642

source/clubs/detail/000044.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4e4e501bc9d4674cd7714da687c7baafcbef00bab182fa215449d344db630ab6
+size 676

source/clubs/detail/000045.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7ab5df77f1bb8e51908650d87c70ef7a60156fcf1214a9be24f6506d08da4d15
+size 655

source/clubs/detail/000046.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:71087d4d5b5ba527209adaa1ef2ccb6fc7a4092c6f6b991afcbe30343041fb1c
+size 605

source/clubs/detail/000047.json

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

source/clubs/detail/000048.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4f957796491dd81dbac9077006056f310c0789483275c30c2f7bea37d6a1ae84
+size 564

source/clubs/detail/000049.json

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

source/clubs/detail/000050.json

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

source/clubs/detail/000051.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:244b17bd29bdf36014f4e44bd7b00b636ec0dbdc43f43b22660c8c4f5f9fd99c
+size 590

source/clubs/detail/000052.json

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

source/clubs/detail/000053.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6fb4869ff527f96c6d5cf0202c70bb0e21bddd00246309b8e7597786fa940ca4
+size 693

source/clubs/detail/000054.json

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

source/clubs/detail/000055.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8507d367335f2734c48a91923420358cb9e7e960b3b6c14417ae975c92652a5c
+size 505

source/clubs/detail/000056.json

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