Bulk register + compare modes

Two more user-facing modes on top of the address endpoint:

/compare — side-by-side briefings for two queries, useful
when picking between candidate parcels or
comparing two neighborhoods.

/register/{class} — pre-computed exposure for an entire asset
register: NYC DOE schools, NYCHA developments,
MTA subway entrances. The JSON ships baked
(built offline by register_builder), so the
UI is just paginated rendering — every row
shows the same paragraph + tier the address
mode would produce.

Asset loaders normalise each register's source GeoJSON into the
common (name, lat, lon, props) shape register_builder expects.

.gitattributes

@@ -3,6 +3,9 @@
 *.tif filter=lfs diff=lfs merge=lfs -text
 *.pdf filter=lfs diff=lfs merge=lfs -text
 
+# Pre-computed register paragraphs
+data/registers/*.json filter=lfs diff=lfs merge=lfs -text
+
 # Esri FileGDB internal binary files (DEP Stormwater scenario data)
 *.gdbtable filter=lfs diff=lfs merge=lfs -text
 *.gdbtablx filter=lfs diff=lfs merge=lfs -text

app/assets/mta_entrances.py

@@ -0,0 +1,74 @@
+"""MTA Subway Entrances and Exits (NY OpenData i9wp-a4ja).
+
+~1,900 subway entrances city-wide. The MTA Climate Resilience Roadmap
+(Oct 2025) names ~1,500 of these as priorities for sealing — this is
+exactly the asset class our RAG corpus has the most to say about, and
+exactly the audience (MTA capital planners, transit advocacy) the
+register is built for.
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import geopandas as gpd
+import httpx
+
+from app.spatial import DATA, NYC_CRS
+
+URL = "https://data.ny.gov/api/geospatial/i9wp-a4ja?method=export&format=GeoJSON"
+LOCAL = DATA / "mta_entrances.geojson"
+
+
+def _ensure_fixture() -> Path:
+    if LOCAL.exists():
+        return LOCAL
+    print("downloading MTA Subway Entrances (one-time)...", flush=True)
+    r = httpx.get(URL, timeout=60)
+    r.raise_for_status()
+    LOCAL.write_text(r.text)
+    return LOCAL
+
+
+def load() -> gpd.GeoDataFrame:
+    _ensure_fixture()
+    g = gpd.read_file(LOCAL)
+    if g.crs is None:
+        g.set_crs("EPSG:4326", inplace=True)
+    g = g.to_crs(NYC_CRS)
+    rename_map = {
+        "stop_name": "name",
+        "constrained_floor_to_floor_height": None,
+        "borough": "borough",
+        "entrance_type": "entrance_type",
+        "ada": "ada",
+        "north_south_street": "ns_street",
+        "east_west_street": "ew_street",
+        "corner": "corner",
+    }
+    for k, v in rename_map.items():
+        if v and k in g.columns and k != v:
+            g = g.rename(columns={k: v})
+
+    # build a usable address-style label
+    def label(row):
+        nm = (row.get("name") or "").strip()
+        ns = (row.get("ns_street") or "").strip()
+        ew = (row.get("ew_street") or "").strip()
+        cn = (row.get("corner") or "").strip()
+        bits = [nm]
+        cross = " & ".join(b for b in [ns, ew] if b)
+        if cross: bits.append(cross)
+        if cn: bits.append(f"({cn})")
+        return ", ".join([b for b in bits if b])
+
+    g["address"] = g.apply(label, axis=1)
+    if "borough" in g.columns:
+        boro_map = {"M": "Manhattan", "Bk": "Brooklyn", "B": "Brooklyn",
+                    "Q": "Queens", "Bx": "Bronx", "SI": "Staten Island"}
+        g["borough"] = g["borough"].astype(str).map(lambda v: boro_map.get(v, v.title()))
+
+    keep = [c for c in ["name", "address", "borough", "entrance_type",
+                        "ada", "ns_street", "ew_street", "corner", "geometry"]
+            if c in g.columns]
+    return g[keep].copy()

app/assets/nycha.py

@@ -0,0 +1,28 @@
+"""NYCHA Developments (NYC OpenData phvi-damg).
+
+326 public-housing developments across NYC. Used as an asset class for
+the bulk-mode register; the parent rationale for surfacing this layer
+is that NYCHA was hit hard by Sandy and remains a published Tier-1
+flood-resilience priority in the city's Hazard Mitigation Plan.
+"""
+from __future__ import annotations
+
+import geopandas as gpd
+
+from app.spatial import DATA, load_layer
+
+
+def load() -> gpd.GeoDataFrame:
+    g = load_layer(DATA / "nycha.geojson")
+    # NYCHA developments come back as polygons; the FSM expects point
+    # geometry for spatial joins. Use centroid.
+    g = g.copy()
+    g["geometry"] = g.geometry.centroid
+
+    # NYCHA Developments has only `developmen` (truncated label), tds_num, borough.
+    g = g.rename(columns={"developmen": "name"})
+    g["address"] = g["name"]  # the field doubles as both
+    g["borough"] = g["borough"].str.title()  # "BRONX" -> "Bronx" to match Riprap convention
+
+    keep = [c for c in ["name", "address", "borough", "tds_num", "geometry"] if c in g.columns]
+    return g[keep].copy()

app/assets/schools.py

@@ -0,0 +1,27 @@
+"""NYC DOE School Point Locations (Socrata a3nt-yts4)."""
+from __future__ import annotations
+
+import geopandas as gpd
+
+from app.spatial import DATA, load_layer
+
+BORO = {"1": "Manhattan", "2": "Bronx", "3": "Brooklyn", "4": "Queens", "5": "Staten Island"}
+
+
+def load() -> gpd.GeoDataFrame:
+    g = load_layer(DATA / "schools.geojson")
+    g = g.rename(columns={
+        "loc_code": "loc_code",
+        "loc_name": "name",
+        "address": "address",
+        "bbl": "bbl",
+        "bin": "bin",
+        "boronum": "boro_num",
+        "geodistric": "geo_district",
+        "adimindist": "admin_district",
+    })
+    g["borough"] = g["boro_num"].astype(str).map(BORO)
+    g["bbl"] = g["bbl"].astype(str).str.replace(r"\.0$", "", regex=True)
+    keep = ["loc_code", "name", "address", "borough", "bbl", "bin",
+            "geo_district", "admin_district", "geometry"]
+    return g[keep].copy()

app/register_builder.py

@@ -0,0 +1,169 @@
+"""Generic per-asset register builder.
+
+Runs the same FSM specialists over every asset in a class. Tier 1+2
+get full Granite paragraphs; Tier 3 gets signals only (paragraph
+generated on click in the UI).
+"""
+from __future__ import annotations
+
+import json
+import sys
+import time
+from pathlib import Path
+from typing import Any, Callable
+
+import geopandas as gpd
+from shapely.geometry import Point
+
+from app.context import floodnet, microtopo, nyc311
+from app.flood_layers import dep_stormwater, ida_hwm, sandy_inundation
+from app.rag import retrieve as rag_retrieve, warm as rag_warm
+from app.reconcile import reconcile as run_reconcile
+from app.score import score_frame
+
+ROOT = Path(__file__).resolve().parent.parent
+REGISTERS_DIR = ROOT / "data" / "registers"
+
+
+def _build_one(row_meta: dict, geom_2263, lat: float, lon: float,
+               with_paragraph: bool) -> dict:
+    pt = gpd.GeoDataFrame(geometry=[geom_2263], crs="EPSG:2263")
+    sandy = bool(sandy_inundation.join(pt).iloc[0])
+    dep = {}
+    for scen in ["dep_extreme_2080", "dep_moderate_2050", "dep_moderate_current"]:
+        j = dep_stormwater.join(pt, scen).iloc[0]
+        dep[scen] = {
+            "depth_class": int(j["depth_class"]),
+            "depth_label": j["depth_label"],
+            "citation": f"NYC DEP Stormwater Flood Map — {dep_stormwater.label(scen)}",
+        }
+    fn = floodnet.summary_for_point(lat, lon, 600); fn["radius_m"] = 600
+    n311 = nyc311.summary_for_point(lat, lon, 200, 5)
+    mt_obj = microtopo.microtopo_at(lat, lon)
+    mt = vars(mt_obj) if mt_obj else None
+    ida_obj = ida_hwm.summary_for_point(lat, lon, 800)
+    ida = vars(ida_obj) if ida_obj else None
+
+    snap = {
+        "geocode": {**row_meta, "lat": lat, "lon": lon},
+        "sandy": sandy, "dep": dep, "floodnet": fn, "nyc311": n311,
+        "microtopo": mt, "ida_hwm": ida,
+    }
+    if with_paragraph:
+        rag_query = (f"flood risk for {row_meta.get('name','')} in "
+                     f"{row_meta.get('borough','')}, NYC; resilience plan, "
+                     f"vulnerability, mitigation")
+        snap["rag"] = rag_retrieve(rag_query, k=2, min_score=0.55)
+        para, audit = run_reconcile(snap, return_audit=True)
+        snap["paragraph"] = para
+        snap["audit"] = audit
+    return snap
+
+
+def build_register(asset_class: str, loader: Callable, *,
+                   tier_with_paragraph: tuple[int, ...] = (1, 2),
+                   meta_keys: tuple[str, ...] = ("name", "address", "borough"),
+                   regenerate: bool = False) -> Path:
+    """Build a register JSON for an asset class.
+
+    Args:
+      asset_class: short id (also the output filename)
+      loader: zero-arg callable returning a GeoDataFrame in EPSG:2263 with
+              point geometry and at least the columns in meta_keys
+      tier_with_paragraph: which tiers get full Granite reconciliation
+      meta_keys: which row columns to surface as the geocode-style metadata
+    """
+    out = REGISTERS_DIR / f"{asset_class}.json"
+    if out.exists() and not regenerate:
+        print(f"already exists: {out}; pass regenerate=True to rebuild",
+              file=sys.stderr)
+        return out
+    REGISTERS_DIR.mkdir(exist_ok=True, parents=True)
+
+    print(f"loading asset class {asset_class!r}...", file=sys.stderr)
+    g = loader()
+    if g.crs is None or g.crs.to_string() != "EPSG:2263":
+        g = g.to_crs("EPSG:2263")
+
+    # tier each asset off the same rubric (sandy + 3 DEP scenarios)
+    g["sandy"] = sandy_inundation.join(g).astype(int)
+    for scen in ["dep_extreme_2080", "dep_moderate_2050", "dep_moderate_current"]:
+        j = dep_stormwater.join(g, scen)
+        g[scen] = (j["depth_class"] > 0).astype(int)
+    g = score_frame(g)
+    g["lat"] = g.geometry.to_crs("EPSG:4326").y
+    g["lon"] = g.geometry.to_crs("EPSG:4326").x
+
+    targets = g[g["tier"].isin([1, 2, 3])].copy()
+    print(f"  {len(targets)} of {len(g)} assets at Tier 1-3", file=sys.stderr)
+    print("warming RAG index...", file=sys.stderr)
+    rag_warm()
+
+    # Resume support: a partial JSON sits next to the final output. We
+    # write it after every row, so any blip can be retried without losing
+    # work.
+    partial = REGISTERS_DIR / f"{asset_class}.partial.json"
+    rows: list[dict] = []
+    done_keys: set = set()
+    if partial.exists():
+        try:
+            data = json.loads(partial.read_text())
+            rows = data.get("rows", [])
+            # use lat/lon as the unique key (works for any asset class)
+            done_keys = {(round(r["lat"], 5), round(r["lon"], 5)) for r in rows}
+            print(f"  resuming with {len(rows)} rows already processed",
+                  file=sys.stderr)
+        except Exception as e:
+            print(f"  failed to read partial, starting fresh: {e}",
+                  file=sys.stderr)
+
+    t0 = time.time()
+    for i, (_, row) in enumerate(
+            targets.sort_values(["score", "name"], ascending=[False, True]).iterrows()):
+        key = (round(float(row["lat"]), 5), round(float(row["lon"]), 5))
+        if key in done_keys:
+            continue
+        tier = int(row["tier"])
+        with_paragraph = tier in tier_with_paragraph
+        meta = {k: row.get(k) for k in meta_keys}
+        try:
+            snap = _build_one(meta, row["geometry"],
+                              float(row["lat"]), float(row["lon"]),
+                              with_paragraph=with_paragraph)
+        except Exception as e:
+            print(f"  [{i+1}/{len(targets)}] FAILED tier-{tier}  "
+                  f"{str(meta.get('name',''))[:50]} -- {type(e).__name__}: {e}",
+                  file=sys.stderr)
+            time.sleep(2)  # back off on transient errors
+            continue
+
+        rec: dict[str, Any] = {
+            **{k: row.get(k) for k in g.columns if k != "geometry"},
+            "lat": float(row["lat"]),
+            "lon": float(row["lon"]),
+            "score": int(row["score"]),
+            "tier": tier,
+            "snap": snap,
+        }
+        rows.append(rec)
+        done_keys.add(key)
+        # incremental persist
+        partial.write_text(json.dumps({
+            "asset_class": asset_class,
+            "rows": rows,
+        }, default=str))
+        elapsed = time.time() - t0
+        print(f"  [{i+1}/{len(targets)}] tier-{tier}  "
+              f"{str(meta.get('name',''))[:50]:<50}  "
+              f"({elapsed:.0f}s elapsed)", file=sys.stderr)
+
+    out.write_text(json.dumps({
+        "asset_class": asset_class,
+        "generated_at": time.strftime("%Y-%m-%dT%H:%M:%SZ"),
+        "rows": rows,
+    }, default=str))
+    if partial.exists():
+        partial.unlink()
+    print(f"\nwrote {len(rows)} rows -> {out} ({out.stat().st_size // 1024} KB)",
+          file=sys.stderr)
+    return out

data/mta_entrances.geojson

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

data/nycha.geojson

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

data/registers/nycha.json

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

data/registers/schools.json

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

data/schools.geojson

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

web/static/compare.html

@@ -0,0 +1,131 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width,initial-scale=1">
+  <title>Riprap — compare two NYC addresses</title>
+  <link rel="stylesheet" href="/static/style.css">
+  <link rel="stylesheet" href="https://unpkg.com/maplibre-gl@4.7.1/dist/maplibre-gl.css">
+  <script src="https://unpkg.com/maplibre-gl@4.7.1/dist/maplibre-gl.js"></script>
+</head>
+<body class="compare-mode">
+
+  <header class="topbar">
+    <div class="topbar-inner">
+      <div class="brand">
+        <span class="brand-name">Riprap</span>
+        <span class="brand-sep">·</span>
+        <span class="brand-tag">compare two NYC addresses, side by side</span>
+      </div>
+      <div class="topbar-right">
+        <a href="/" class="modelink">address</a>
+        <a href="/register/schools" class="modelink">register</a>
+        <span class="local-pill" title="Granite 4.1 inference runs on this machine. Two FSMs run in parallel.">
+          <span class="dot"></span>local · 2× Granite 4.1
+        </span>
+      </div>
+    </div>
+  </header>
+
+  <div class="form-bar form-bar-compare">
+    <form id="cform">
+      <div class="cform-row">
+        <label>A</label>
+        <input type="text" id="qa" name="a" autocomplete="off"
+               placeholder='Address A — e.g. "153-09 90 Avenue, Jamaica, Queens"'
+               value="153-09 90 Avenue, Jamaica, Queens" required />
+      </div>
+      <div class="cform-row">
+        <label>B</label>
+        <input type="text" id="qb" name="b" autocomplete="off"
+               placeholder='Address B — e.g. "350 5 Avenue, Manhattan"  (Empire State)'
+               value="350 5 Avenue, Manhattan" required />
+      </div>
+      <button type="submit" id="cgo">Compare</button>
+    </form>
+    <div class="suggest">
+      <span class="suggest-label">try:</span>
+      <button class="chip" data-a="153-09 90 Avenue, Jamaica, Queens" data-b="350 5 Avenue, Manhattan">Ida basements vs. Empire State</button>
+      <button class="chip" data-a="180 Beach 35 St, Queens" data-b="2950 W 25 St, Brooklyn">Far Rockaway vs. Coney Island NYCHA</button>
+      <button class="chip" data-a="Smith and 9 Street, Brooklyn" data-b="220 W 109 St, Manhattan">Gowanus vs. Upper West Side</button>
+    </div>
+  </div>
+
+  <div class="workbench compare-workbench">
+
+    <!-- LEFT pane: address A -->
+    <aside class="cpane" id="paneA">
+      <div class="cpane-head"><span class="ctag a">A</span><span id="aTitle">Address A</span></div>
+      <section class="panel">
+        <h2>Trace<span class="hint">Burr FSM · A</span></h2>
+        <ul id="stepsA"></ul>
+      </section>
+      <section class="panel hidden" id="reportA">
+        <h2>Cited report<span class="hint">Granite 4.1 · A</span></h2>
+        <div class="report-section"><h3>At a glance</h3><ul id="glanceA" class="glance-list"></ul></div>
+        <div class="report-section"><h3>Summary</h3><p id="paragraphA"></p></div>
+        <div class="report-section"><h3>Sources fired</h3><ol id="sourcesA" class="sources-list"></ol></div>
+      </section>
+    </aside>
+
+    <!-- MIDDLE pane: shared map -->
+    <section class="col-mid compare-mid">
+      <div class="panel panel-map" id="map-card">
+        <h2>Map<span class="hint">Both addresses · shared layers</span></h2>
+        <div id="map"></div>
+        <div class="legend">
+          <span><i class="sw sandy"></i>Sandy 2012</span>
+          <span><i class="sw dep"></i>DEP Extreme 2080</span>
+          <span><i class="sw fnDot"></i>FloodNet (no events)</span>
+          <span><i class="sw fnDotHot"></i>FloodNet w/ events</span>
+          <span><i class="sw addr"></i>A &amp; B markers</span>
+        </div>
+      </div>
+    </section>
+
+    <!-- RIGHT pane: address B -->
+    <aside class="cpane" id="paneB">
+      <div class="cpane-head"><span class="ctag b">B</span><span id="bTitle">Address B</span></div>
+      <section class="panel">
+        <h2>Trace<span class="hint">Burr FSM · B</span></h2>
+        <ul id="stepsB"></ul>
+      </section>
+      <section class="panel hidden" id="reportB">
+        <h2>Cited report<span class="hint">Granite 4.1 · B</span></h2>
+        <div class="report-section"><h3>At a glance</h3><ul id="glanceB" class="glance-list"></ul></div>
+        <div class="report-section"><h3>Summary</h3><p id="paragraphB"></p></div>
+        <div class="report-section"><h3>Sources fired</h3><ol id="sourcesB" class="sources-list"></ol></div>
+      </section>
+    </aside>
+
+  </div>
+
+  <footer>
+    <div class="foot-inner">
+      <div class="foot-col">
+        <h3>Compare mode</h3>
+        <p>
+          Two addresses, two parallel runs of the same 8-specialist FSM.
+          Each side renders its own trace, at-a-glance signals, cited
+          summary, and source list. The map shows both markers and shared
+          layer overlays. Both Granite 4.1 reconciliations run concurrently
+          via Ollama (<code>OLLAMA_NUM_PARALLEL=2</code>); wallclock is
+          comparable to a single query.
+        </p>
+      </div>
+      <div class="foot-col">
+        <h3>Sources</h3>
+        <p>
+          <a href="https://data.cityofnewyork.us/" target="_blank">NYC Open Data</a> ·
+          <a href="https://api.floodnet.nyc/" target="_blank">FloodNet NYC</a> ·
+          <a href="https://geosearch.planninglabs.nyc/" target="_blank">NYC DCP Geosearch</a> ·
+          <a href="https://stn.wim.usgs.gov/" target="_blank">USGS STN</a> ·
+          <a href="https://www.usgs.gov/3d-elevation-program" target="_blank">USGS 3DEP</a>
+        </p>
+      </div>
+    </div>
+  </footer>
+
+  <script src="/static/compare.js"></script>
+</body>
+</html>

web/static/compare.js

@@ -0,0 +1,323 @@
+// Riprap — Compare mode. Two addresses, parallel FSM runs, shared map.
+
+const STEP_LABELS = {
+  geocode:                ["Geocode (DCP Geosearch)",          "address → lat/lon, BBL"],
+  sandy_inundation:       ["Sandy Inundation (NYC OD)",        "empirical 2012 extent"],
+  dep_stormwater:         ["DEP Stormwater Maps",              "pluvial scenarios + 2080 SLR"],
+  floodnet:               ["FloodNet sensor network",          "live ultrasonic depth sensors"],
+  nyc311:                 ["NYC 311 archive",                  "flood complaints in buffer"],
+  microtopo_lidar:        ["LiDAR terrain (DEM + TWI + HAND)", "USGS 3DEP DEM + whitebox hydrology"],
+  ida_hwm_2021:           ["Ida 2021 high-water marks",        "USGS empirical post-event extent"],
+  prithvi_eo_v2:          ["Prithvi-EO 2.0 (300M, NASA/IBM)",  "Sen1Floods11 satellite water segmentation"],
+  rag_granite_embedding:  ["Granite Embedding 278M (RAG)",     "policy corpus retrieval"],
+  reconcile_granite41:    ["Granite 4.1 reconcile (local)",    "document-grounded synthesis"],
+};
+
+const STEPS_ORDER = [
+  "geocode", "sandy_inundation", "dep_stormwater", "floodnet", "nyc311",
+  "microtopo_lidar", "ida_hwm_2021", "prithvi_eo_v2",
+  "rag_granite_embedding", "reconcile_granite41",
+];
+
+const SOURCE_LABELS = {
+  geocode:                "NYC DCP Geosearch",
+  sandy:                  "NYC OpenData 5xsi-dfpx — Sandy 2012 inundation",
+  dep_extreme_2080:       "NYC DEP Stormwater — Extreme 3.66 in/hr + 2080 SLR",
+  dep_moderate_2050:      "NYC DEP Stormwater — Moderate 2.13 in/hr + 2050 SLR",
+  dep_moderate_current:   "NYC DEP Stormwater — Moderate 2.13 in/hr current",
+  floodnet:               "FloodNet NYC — live ultrasonic sensor network",
+  nyc311:                 "NYC 311 (Socrata erm2-nwe9) — flood descriptors",
+  microtopo:              "USGS 3DEP 30 m DEM via py3dep",
+  ida_hwm:                "USGS STN — Hurricane Ida 2021 HWMs (Event 312, NY)",
+  prithvi_water:          "Prithvi-EO 2.0 (300M, NASA/IBM) Sen1Floods11 — satellite water segmentation",
+  rag_dep_2013:           "NYC DEP Wastewater Resiliency Plan (2013)",
+  rag_nycha:              "NYCHA — Flood Resilience: Lessons Learned",
+  rag_coned:              "Con Edison Climate Change Resilience Plan (Case 22-E-0222)",
+  rag_mta:                "MTA Climate Resilience Roadmap (Oct 2025)",
+  rag_comptroller:        "NYC Comptroller — \"Is NYC Ready for Rain?\" (2024)",
+};
+
+const $ = (s) => document.querySelector(s);
+
+let evtSrc = null;
+let map = null;
+let mapInit = false;
+
+const MAP_STYLE = {
+  version: 8,
+  sources: {
+    carto: {
+      type: "raster",
+      tiles: ["https://a.basemaps.cartocdn.com/light_all/{z}/{x}/{y}.png"],
+      tileSize: 256,
+      attribution: "© OpenStreetMap contributors © CARTO",
+    },
+  },
+  layers: [
+    { id: "bg", type: "background", paint: { "background-color": "#fafbfd" } },
+    { id: "carto", type: "raster", source: "carto" },
+  ],
+};
+
+function ensureMap() {
+  if (mapInit) return;
+  mapInit = true;
+  map = new maplibregl.Map({
+    container: "map",
+    style: MAP_STYLE,
+    center: [-74.0, 40.72],
+    zoom: 10,
+    attributionControl: { compact: true },
+  });
+  map.addControl(new maplibregl.NavigationControl({ visualizePitch: false }), "top-right");
+  map.on("load", () => {
+    for (const sideKey of ["a", "b"]) {
+      map.addSource("sandy_" + sideKey, { type: "geojson", data: { type: "FeatureCollection", features: [] } });
+      map.addLayer({ id: "sandy_" + sideKey + "-fill", type: "fill", source: "sandy_" + sideKey,
+        paint: { "fill-color": "#fc5d52", "fill-opacity": 0.22 } });
+      map.addSource("dep_" + sideKey, { type: "geojson", data: { type: "FeatureCollection", features: [] } });
+      map.addLayer({ id: "dep_" + sideKey + "-fill", type: "fill", source: "dep_" + sideKey,
+        paint: {
+          "fill-color": ["match", ["get", "Flooding_Category"],
+            1, "#568adf", 2, "#1642DF", 3, "#031553", "#568adf"],
+          "fill-opacity": 0.28 } });
+      map.addSource("fn_" + sideKey, { type: "geojson", data: { type: "FeatureCollection", features: [] } });
+      map.addLayer({ id: "fn_" + sideKey + "-circles", type: "circle", source: "fn_" + sideKey,
+        paint: {
+          "circle-radius": 5,
+          "circle-color": ["case", [">", ["get", "n_events_3y"], 0], "#fc5d52", "#1a8754"],
+          "circle-stroke-color": "#ffffff",
+          "circle-stroke-width": 1.5,
+        } });
+    }
+    map.addSource("addr_a", { type: "geojson", data: { type: "FeatureCollection", features: [] } });
+    map.addLayer({ id: "addr_a-marker", type: "circle", source: "addr_a",
+      paint: { "circle-radius": 9, "circle-color": "#1642DF", "circle-stroke-color": "#fff", "circle-stroke-width": 2.5 } });
+    map.addSource("addr_b", { type: "geojson", data: { type: "FeatureCollection", features: [] } });
+    map.addLayer({ id: "addr_b-marker", type: "circle", source: "addr_b",
+      paint: { "circle-radius": 9, "circle-color": "#9333ea", "circle-stroke-color": "#fff", "circle-stroke-width": 2.5 } });
+  });
+}
+
+function resetSide(side) {
+  const ul = document.getElementById("steps" + side.toUpperCase());
+  ul.innerHTML = "";
+  for (const sid of STEPS_ORDER) {
+    const [lbl, hint] = STEP_LABELS[sid] || [sid, ""];
+    const li = document.createElement("li");
+    li.id = `step-${side}-${sid}`;
+    li.className = "pending";
+    li.innerHTML = `
+      <span class="icon">○</span>
+      <div>
+        <div class="label">${lbl}</div>
+        <div class="meta">${hint}</div>
+      </div>
+      <span class="meta time"></span>`;
+    ul.appendChild(li);
+  }
+  document.getElementById("step-" + side + "-" + STEPS_ORDER[0]).classList.replace("pending", "running");
+
+  document.getElementById("report" + side.toUpperCase()).classList.add("hidden");
+  document.getElementById("paragraph" + side.toUpperCase()).innerHTML = "";
+  document.getElementById("glance" + side.toUpperCase()).innerHTML = "";
+  document.getElementById("sources" + side.toUpperCase()).innerHTML = "";
+}
+
+function markStep(side, stepId, ev) {
+  const li = document.getElementById(`step-${side}-${stepId}`);
+  if (!li) return;
+  li.className = ev.ok ? "ok" : "err";
+  li.querySelector(".icon").textContent = ev.ok ? "✓" : "✗";
+  if (ev.elapsed_s != null) {
+    li.querySelector(".time").textContent = ev.elapsed_s.toFixed(2) + "s";
+  }
+  if (ev.result) {
+    let div = li.querySelector(".result");
+    if (!div) {
+      div = document.createElement("div"); div.className = "result";
+      li.appendChild(div);
+    }
+    div.textContent = formatResult(ev.result);
+  } else if (ev.err) {
+    let div = li.querySelector(".result");
+    if (!div) {
+      div = document.createElement("div"); div.className = "result";
+      li.appendChild(div);
+    }
+    div.textContent = "error: " + ev.err;
+  }
+  const idx = STEPS_ORDER.indexOf(stepId);
+  if (idx >= 0 && idx + 1 < STEPS_ORDER.length) {
+    const next = document.getElementById(`step-${side}-${STEPS_ORDER[idx + 1]}`);
+    if (next && next.classList.contains("pending")) next.classList.replace("pending", "running");
+  }
+}
+
+function formatResult(r) {
+  if (typeof r !== "object") return String(r);
+  return Object.entries(r)
+    .map(([k, v]) => `${k}: ${typeof v === "object" ? JSON.stringify(v) : v}`)
+    .join(" · ");
+}
+
+function renderParagraph(side, text) {
+  const html = (text || "").replace(/\[([a-z0-9_]+)\]/gi, (_, d) =>
+    `<span class="cite" title="document id: ${d}">[${d}]</span>`);
+  document.getElementById("paragraph" + side.toUpperCase()).innerHTML = html;
+}
+
+function renderGlance(side, ev) {
+  const ul = document.getElementById("glance" + side.toUpperCase());
+  if (!ul) return;
+  const rows = [];
+  if (ev.sandy) {
+    rows.push({c: "hit", mark: "■", html: "Inside <strong>Sandy 2012</strong> inundation extent"});
+  } else {
+    rows.push({c: "miss", mark: "□", html: "Outside Sandy 2012 inundation extent"});
+  }
+  const dep = ev.dep || {};
+  const depHits = Object.entries(dep).filter(([_, v]) => (v.depth_class || 0) > 0);
+  if (depHits.length) {
+    for (const [scen, v] of depHits) {
+      const lbl = scen.replace("dep_", "").replace(/_/g, " ");
+      rows.push({c: "hit", mark: "■", html: `Inside DEP ${lbl} — <strong>${v.depth_label}</strong>`});
+    }
+  } else {
+    rows.push({c: "miss", mark: "□", html: "Outside all DEP stormwater scenarios"});
+  }
+  const fn = ev.floodnet;
+  if (fn && fn.n_sensors) {
+    if (fn.n_flood_events_3y > 0) {
+      const peak = fn.peak_event;
+      const peakStr = peak && peak.max_depth_mm
+        ? `, peak <span class="gnum">${peak.max_depth_mm} mm</span>` : '';
+      rows.push({c: "hit", mark: "■",
+        html: `<span class="gnum">${fn.n_flood_events_3y}</span> FloodNet events (3 yr)${peakStr}`});
+    } else {
+      rows.push({c: "miss", mark: "□",
+        html: `<span class="gnum">${fn.n_sensors}</span> FloodNet sensor(s), no events`});
+    }
+  }
+  const ida = ev.ida_hwm;
+  if (ida && ida.n_within_radius > 0) {
+    const ht = ida.max_height_above_gnd_ft != null
+      ? `up to <span class="gnum">${ida.max_height_above_gnd_ft} ft</span> above ground` : '';
+    rows.push({c: "hit", mark: "■",
+      html: `<span class="gnum">${ida.n_within_radius}</span> Ida 2021 HWMs ≤${ida.radius_m} m${ht ? ', ' + ht : ''}`});
+  }
+  const mt = ev.microtopo;
+  if (mt) {
+    rows.push({c: "note", mark: "◆",
+      html: `Elevation <span class="gnum">${mt.point_elev_m} m</span>, lower than <span class="gnum">${mt.rel_elev_pct_200m}%</span> of nearby (200 m)`});
+  }
+  const c311 = ev.nyc311;
+  if (c311 && c311.n > 0) {
+    rows.push({c: "note", mark: "◆",
+      html: `<span class="gnum">${c311.n}</span> 311 flood complaints ≤${c311.radius_m} m, ${c311.years} yr`});
+  }
+  ul.innerHTML = rows
+    .map(r => `<li class="${r.c}"><span class="gmark">${r.mark}</span><span class="gtext">${r.html}</span></li>`).join("");
+}
+
+function renderSources(side, ev, paraText) {
+  const fired = new Set([...(paraText || "").matchAll(/\[([a-z0-9_]+)\]/g)].map(m => m[1]));
+  const order = [
+    "sandy", "dep_extreme_2080", "dep_moderate_2050", "dep_moderate_current",
+    "floodnet", "ida_hwm", "microtopo", "nyc311",
+    "rag_dep_2013", "rag_nycha", "rag_coned", "rag_mta", "rag_comptroller",
+  ];
+  const present = new Set();
+  if (ev.sandy) present.add("sandy");
+  for (const [k, v] of Object.entries(ev.dep || {})) {
+    if ((v.depth_class || 0) > 0) present.add(k);
+  }
+  if (ev.floodnet && ev.floodnet.n_sensors > 0) present.add("floodnet");
+  if (ev.ida_hwm && ev.ida_hwm.n_within_radius > 0) present.add("ida_hwm");
+  if (ev.microtopo) present.add("microtopo");
+  if (ev.nyc311 && ev.nyc311.n > 0) present.add("nyc311");
+  if (ev.rag) for (const h of ev.rag) present.add(h.doc_id);
+
+  const ol = document.getElementById("sources" + side.toUpperCase());
+  ol.innerHTML = order.filter(d => present.has(d)).map(d => {
+    const label = SOURCE_LABELS[d] || d;
+    const dim = fired.has(d) ? "" : ' style="opacity:0.5"';
+    return `<li${dim}><span class="src-tag">${d}</span><span class="src-cite">${label}</span></li>`;
+  }).join("");
+}
+
+async function updateMapForSide(side, geo) {
+  ensureMap();
+  if (!map.loaded()) await new Promise(res => map.once("load", res));
+  const sideKey = side.toLowerCase();
+  map.getSource("addr_" + sideKey).setData({
+    type: "FeatureCollection",
+    features: [{ type: "Feature", geometry: { type: "Point", coordinates: [geo.lon, geo.lat] }, properties: {} }],
+  });
+  const url = (p) => `${p}?lat=${geo.lat}&lon=${geo.lon}&r=1500`;
+  const [sandy, dep, fn] = await Promise.all([
+    fetch(url("/api/layers/sandy")).then(r => r.json()).catch(() => null),
+    fetch(url("/api/layers/dep_extreme_2080")).then(r => r.json()).catch(() => null),
+    fetch(`/api/floodnet_near?lat=${geo.lat}&lon=${geo.lon}&r=1000`).then(r => r.json()).catch(() => null),
+  ]);
+  if (sandy) map.getSource("sandy_" + sideKey).setData(sandy);
+  if (dep)   map.getSource("dep_" + sideKey).setData(dep);
+  if (fn)    map.getSource("fn_" + sideKey).setData(fn);
+}
+
+function fitBoth(ga, gb) {
+  if (!ga || !gb || !map.loaded()) return;
+  const bounds = new maplibregl.LngLatBounds()
+    .extend([ga.lon, ga.lat]).extend([gb.lon, gb.lat]);
+  map.fitBounds(bounds, { padding: 80, duration: 800, maxZoom: 13 });
+}
+
+let geoA = null, geoB = null;
+
+document.querySelectorAll(".chip[data-a]").forEach((btn) => {
+  btn.addEventListener("click", (e) => {
+    e.preventDefault();
+    document.getElementById("qa").value = btn.getAttribute("data-a");
+    document.getElementById("qb").value = btn.getAttribute("data-b");
+    document.getElementById("cform").requestSubmit();
+  });
+});
+
+document.getElementById("cform").addEventListener("submit", (e) => {
+  e.preventDefault();
+  const a = document.getElementById("qa").value.trim();
+  const b = document.getElementById("qb").value.trim();
+  if (!a || !b) return;
+  document.getElementById("aTitle").textContent = a;
+  document.getElementById("bTitle").textContent = b;
+  resetSide("a"); resetSide("b");
+  ensureMap();
+  geoA = geoB = null;
+  document.getElementById("cgo").disabled = true;
+  if (evtSrc) evtSrc.close();
+  evtSrc = new EventSource(`/api/compare?a=${encodeURIComponent(a)}&b=${encodeURIComponent(b)}`);
+
+  evtSrc.addEventListener("step", (msg) => {
+    const ev = JSON.parse(msg.data);
+    markStep(ev.side, ev.step, ev);
+  });
+  evtSrc.addEventListener("final", (msg) => {
+    const ev = JSON.parse(msg.data);
+    const side = ev.side;
+    document.getElementById("report" + side.toUpperCase()).classList.remove("hidden");
+    if (ev.geocode) {
+      if (side === "a") geoA = ev.geocode; else geoB = ev.geocode;
+      updateMapForSide(side, ev.geocode).then(() => fitBoth(geoA, geoB));
+    }
+    if (ev.paragraph) renderParagraph(side, ev.paragraph);
+    renderGlance(side, ev);
+    renderSources(side, ev, ev.paragraph || "");
+  });
+  evtSrc.addEventListener("done", () => {
+    document.getElementById("cgo").disabled = false;
+    evtSrc.close();
+  });
+  evtSrc.addEventListener("error", () => {
+    document.getElementById("cgo").disabled = false;
+  });
+});

web/static/register.html

@@ -0,0 +1,121 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width,initial-scale=1">
+  <title>Riprap — NYC public schools flood exposure register</title>
+  <link rel="stylesheet" href="/static/style.css">
+  <link rel="stylesheet" href="https://unpkg.com/maplibre-gl@4.7.1/dist/maplibre-gl.css">
+  <script src="https://unpkg.com/maplibre-gl@4.7.1/dist/maplibre-gl.js"></script>
+</head>
+<body class="register-mode">
+
+  <header class="topbar">
+    <div class="topbar-inner">
+      <div class="brand">
+        <span class="brand-name">Riprap</span>
+        <span class="brand-sep">·</span>
+        <span class="brand-tag">NYC public schools — flood exposure register</span>
+      </div>
+      <div class="topbar-right">
+        <a href="/" class="modelink">address</a>
+        <a href="/compare" class="modelink">compare</a>
+        <select id="classPicker" class="topbar-select">
+          <option value="schools">DOE schools</option>
+          <option value="nycha">NYCHA developments</option>
+          <option value="mta_entrances">MTA subway entrances</option>
+        </select>
+        <span class="local-pill" title="Pre-computed by the same FSM, bulk mode."><span class="dot"></span>bulk · pre-computed</span>
+      </div>
+    </div>
+  </header>
+
+  <div class="register-summary">
+    <div class="reg-stat"><span class="reg-stat-num" id="totalCount">—</span><span class="reg-stat-lbl">schools assessed</span></div>
+    <div class="reg-stat tier-1"><span class="reg-stat-num" id="tier1Count">—</span><span class="reg-stat-lbl">Tier 1</span></div>
+    <div class="reg-stat tier-2"><span class="reg-stat-num" id="tier2Count">—</span><span class="reg-stat-lbl">Tier 2</span></div>
+    <div class="reg-stat tier-3"><span class="reg-stat-num" id="tier3Count">—</span><span class="reg-stat-lbl">Tier 3</span></div>
+    <div class="reg-stat-spacer"></div>
+    <div class="reg-controls">
+      <input type="text" id="filter" placeholder="filter by name, address, or borough…" />
+      <select id="boroughFilter">
+        <option value="">All boroughs</option>
+        <option>Manhattan</option><option>Bronx</option>
+        <option>Brooklyn</option><option>Queens</option><option>Staten Island</option>
+      </select>
+      <button id="exportCsv" class="btn-secondary" type="button">CSV</button>
+      <button id="exportGeojson" class="btn-secondary" type="button">GeoJSON</button>
+    </div>
+  </div>
+
+  <div class="register-workbench">
+    <section class="reg-table-wrap panel">
+      <h2>Ranked by exposure score<span class="hint">click any row for details</span></h2>
+      <div class="reg-tablescroll">
+        <table id="regTable">
+          <thead>
+            <tr>
+              <th>Tier</th>
+              <th>Score</th>
+              <th>School</th>
+              <th>Borough</th>
+              <th class="num">Sandy</th>
+              <th class="num">DEP&nbsp;2080</th>
+              <th class="num">311</th>
+              <th class="num">FloodNet</th>
+              <th class="num">Ida</th>
+            </tr>
+          </thead>
+          <tbody id="regBody"></tbody>
+        </table>
+      </div>
+    </section>
+
+    <aside class="reg-detail panel" id="regDetail">
+      <h2>Detail<span class="hint">select a school</span></h2>
+      <div class="reg-detail-empty" id="detailEmpty">
+        Select a row to load the cited per-asset report.
+      </div>
+      <div class="reg-detail-body hidden" id="detailBody">
+        <div id="detailHeader" class="reg-detail-header"></div>
+        <div id="detailMap"></div>
+        <div class="report-section"><h3>At a glance</h3><ul id="detailGlance" class="glance-list"></ul></div>
+        <div class="report-section"><h3>Summary</h3><p id="detailParagraph"></p>
+          <div id="detailNoPara" class="hint" style="margin-top: 8px;">
+            Tier-3 paragraphs are computed on demand. <button id="livePara" type="button" class="btn-secondary">Generate cited paragraph (~10 s)</button>
+          </div>
+        </div>
+        <div class="report-section"><h3>Sources fired</h3><ol id="detailSources" class="sources-list"></ol></div>
+      </div>
+    </aside>
+  </div>
+
+  <footer>
+    <div class="foot-inner">
+      <div class="foot-col">
+        <h3>Bulk mode</h3>
+        <p>
+          The same 8-specialist FSM that answers a single address is run
+          in batch over every NYC public school (1,992 from the DOE
+          location dataset). Each row is scored on a transparent rubric —
+          Sandy 2012 inundation, DEP stormwater scenarios, FloodNet sensor
+          history, USGS Ida 2021 high-water marks, LiDAR micro-topography,
+          NYC 311 flood complaints. Tier-1 and Tier-2 schools have their
+          full Granite-reconciled cited paragraph pre-computed; Tier-3
+          paragraphs are generated on click.
+        </p>
+      </div>
+      <div class="foot-col">
+        <h3>Source</h3>
+        <p>
+          NYC DOE 2019-2020 School Point Locations
+          (<a href="https://data.cityofnewyork.us/Education/2019-2020-School-Point-Locations/a3nt-yts4" target="_blank">a3nt-yts4</a>).
+          Same data substrate as the address mode.
+        </p>
+      </div>
+    </div>
+  </footer>
+
+  <script src="/static/register.js"></script>
+</body>
+</html>

web/static/register.js

@@ -0,0 +1,315 @@
+// Riprap — Bulk mode (schools register).
+
+const SOURCE_LABELS = {
+  geocode:                "NYC DCP Geosearch",
+  sandy:                  "NYC OpenData 5xsi-dfpx — Sandy 2012 inundation",
+  dep_extreme_2080:       "NYC DEP Stormwater — Extreme 3.66 in/hr + 2080 SLR",
+  dep_moderate_2050:      "NYC DEP Stormwater — Moderate 2.13 in/hr + 2050 SLR",
+  dep_moderate_current:   "NYC DEP Stormwater — Moderate 2.13 in/hr current",
+  floodnet:               "FloodNet NYC — live ultrasonic sensor network",
+  nyc311:                 "NYC 311 (Socrata erm2-nwe9) — flood descriptors",
+  microtopo:              "USGS 3DEP 30 m DEM via py3dep",
+  ida_hwm:                "USGS STN — Hurricane Ida 2021 HWMs (Event 312, NY)",
+  prithvi_water:          "Prithvi-EO 2.0 (300M, NASA/IBM) Sen1Floods11 — satellite water segmentation",
+  rag_dep_2013:           "NYC DEP Wastewater Resiliency Plan (2013)",
+  rag_nycha:              "NYCHA — Flood Resilience: Lessons Learned",
+  rag_coned:              "Con Edison Climate Change Resilience Plan (Case 22-E-0222)",
+  rag_mta:                "MTA Climate Resilience Roadmap (Oct 2025)",
+  rag_comptroller:        "NYC Comptroller — \"Is NYC Ready for Rain?\" (2024)",
+};
+
+const $ = (s) => document.querySelector(s);
+
+let allRows = [];
+let filteredRows = [];
+let selected = null;
+let detailMap = null;
+
+function tierBadge(t) {
+  const cls = "tier-badge tier-" + t;
+  return `<span class="${cls}">${t}</span>`;
+}
+
+function yn(b) { return b ? '<span class="yn yes">●</span>' : '<span class="yn no">○</span>'; }
+
+function renderTable() {
+  const tbody = $("#regBody");
+  tbody.innerHTML = filteredRows.map((r, i) => {
+    const snap = r.snap || {};
+    const sandy  = snap.sandy ? yn(true) : yn(false);
+    const dep80  = snap.dep && snap.dep.dep_extreme_2080 && snap.dep.dep_extreme_2080.depth_class > 0 ? yn(true) : yn(false);
+    const c311   = (snap.nyc311 && snap.nyc311.n) || 0;
+    const fnEv   = (snap.floodnet && snap.floodnet.n_flood_events_3y) || 0;
+    const idaN   = (snap.ida_hwm && snap.ida_hwm.n_within_radius) || 0;
+    return `<tr data-idx="${i}">
+      <td>${tierBadge(r.tier)}</td>
+      <td class="num">${r.score}</td>
+      <td>
+        <div class="rname">${r.name}</div>
+        <div class="raddr">${r.address || ""}</div>
+      </td>
+      <td>${r.borough || ""}</td>
+      <td class="num">${sandy}</td>
+      <td class="num">${dep80}</td>
+      <td class="num">${c311 || ""}</td>
+      <td class="num">${fnEv || ""}</td>
+      <td class="num">${idaN || ""}</td>
+    </tr>`;
+  }).join("");
+
+  tbody.querySelectorAll("tr").forEach((tr) => {
+    tr.addEventListener("click", () => selectRow(parseInt(tr.dataset.idx, 10)));
+  });
+}
+
+function applyFilters() {
+  const q = ($("#filter").value || "").toLowerCase();
+  const boro = $("#boroughFilter").value || "";
+  filteredRows = allRows.filter((r) => {
+    if (boro && r.borough !== boro) return false;
+    if (!q) return true;
+    return (
+      (r.name || "").toLowerCase().includes(q) ||
+      (r.address || "").toLowerCase().includes(q) ||
+      (r.borough || "").toLowerCase().includes(q) ||
+      (r.bbl || "").toString().includes(q)
+    );
+  });
+  renderTable();
+}
+
+function selectRow(idx) {
+  selected = filteredRows[idx];
+  if (!selected) return;
+  $("#detailEmpty").classList.add("hidden");
+  $("#detailBody").classList.remove("hidden");
+  $("#detailHeader").innerHTML = `
+    <div class="rname">${selected.name}</div>
+    <div class="raddr">${selected.address}, ${selected.borough}</div>
+    <div class="rmeta">BBL: ${selected.bbl || "—"} · Tier ${selected.tier} · Score ${selected.score}</div>`;
+  renderDetail(selected);
+}
+
+function renderDetail(row) {
+  const snap = row.snap || {};
+  // glance
+  const rows = [];
+  if (snap.sandy) rows.push({c:"hit", mark:"■", html:"Inside <strong>Sandy 2012</strong> inundation extent"});
+  else            rows.push({c:"miss",mark:"□", html:"Outside Sandy 2012 inundation extent"});
+  const dep = snap.dep || {};
+  const depHits = Object.entries(dep).filter(([_,v]) => (v.depth_class || 0) > 0);
+  if (depHits.length) {
+    for (const [scen, v] of depHits) {
+      const lbl = scen.replace("dep_","").replace(/_/g, " ");
+      rows.push({c:"hit", mark:"■", html:`Inside DEP ${lbl} — <strong>${v.depth_label}</strong>`});
+    }
+  } else {
+    rows.push({c:"miss", mark:"□", html:"Outside all DEP stormwater scenarios"});
+  }
+  const fn = snap.floodnet;
+  if (fn && fn.n_sensors) {
+    if (fn.n_flood_events_3y > 0) {
+      const peak = fn.peak_event;
+      const peakStr = peak && peak.max_depth_mm ? `, peak <span class="gnum">${peak.max_depth_mm} mm</span>` : "";
+      rows.push({c:"hit", mark:"■", html:`<span class="gnum">${fn.n_flood_events_3y}</span> FloodNet events (3 yr)${peakStr}`});
+    }
+  }
+  const ida = snap.ida_hwm;
+  if (ida && ida.n_within_radius > 0) {
+    const ht = ida.max_height_above_gnd_ft != null ? `up to <span class="gnum">${ida.max_height_above_gnd_ft} ft</span> above ground` : "";
+    rows.push({c:"hit", mark:"■", html:`<span class="gnum">${ida.n_within_radius}</span> Ida HWMs ≤${ida.radius_m} m${ht ? ", " + ht : ""}`});
+  }
+  const mt = snap.microtopo;
+  if (mt) {
+    rows.push({c:"note", mark:"◆", html:`Elevation <span class="gnum">${mt.point_elev_m} m</span>; lower than <span class="gnum">${mt.rel_elev_pct_200m}%</span> of nearby (200 m)`});
+  }
+  const c311 = snap.nyc311;
+  if (c311 && c311.n > 0) {
+    rows.push({c:"note", mark:"◆", html:`<span class="gnum">${c311.n}</span> 311 flood complaints ≤${c311.radius_m} m, ${c311.years} yr`});
+  }
+  $("#detailGlance").innerHTML = rows.map(r =>
+    `<li class="${r.c}"><span class="gmark">${r.mark}</span><span class="gtext">${r.html}</span></li>`).join("");
+
+  // paragraph
+  const para = snap.paragraph;
+  const noPara = $("#detailNoPara");
+  if (para) {
+    $("#detailParagraph").innerHTML = (para || "").replace(/\[([a-z0-9_]+)\]/gi,
+      (_, d) => `<span class="cite" title="document id: ${d}">[${d}]</span>`);
+    noPara.classList.add("hidden");
+  } else {
+    $("#detailParagraph").innerHTML = "";
+    noPara.classList.remove("hidden");
+  }
+
+  // sources
+  const fired = new Set([...(para || "").matchAll(/\[([a-z0-9_]+)\]/g)].map(m => m[1]));
+  const order = [
+    "sandy", "dep_extreme_2080", "dep_moderate_2050", "dep_moderate_current",
+    "floodnet", "ida_hwm", "microtopo", "nyc311",
+    "rag_dep_2013", "rag_nycha", "rag_coned", "rag_mta", "rag_comptroller",
+  ];
+  const present = new Set();
+  if (snap.sandy) present.add("sandy");
+  for (const [k, v] of Object.entries(snap.dep || {})) {
+    if ((v.depth_class || 0) > 0) present.add(k);
+  }
+  if (snap.floodnet && snap.floodnet.n_sensors > 0) present.add("floodnet");
+  if (snap.ida_hwm && snap.ida_hwm.n_within_radius > 0) present.add("ida_hwm");
+  if (snap.microtopo) present.add("microtopo");
+  if (snap.nyc311 && snap.nyc311.n > 0) present.add("nyc311");
+  if (snap.rag) for (const h of snap.rag) present.add(h.doc_id);
+
+  $("#detailSources").innerHTML = order.filter(d => present.has(d)).map(d => {
+    const dim = fired.has(d) ? "" : ' style="opacity:0.5"';
+    return `<li${dim}><span class="src-tag">${d}</span><span class="src-cite">${SOURCE_LABELS[d] || d}</span></li>`;
+  }).join("");
+
+  showDetailMap(row);
+}
+
+function showDetailMap(row) {
+  const div = $("#detailMap");
+  if (!detailMap) {
+    detailMap = new maplibregl.Map({
+      container: "detailMap",
+      style: {
+        version: 8,
+        sources: {
+          carto: { type: "raster",
+            tiles: ["https://a.basemaps.cartocdn.com/light_all/{z}/{x}/{y}.png"],
+            tileSize: 256, attribution: "© OSM · CARTO" },
+        },
+        layers: [{ id: "bg", type: "raster", source: "carto" }],
+      },
+      center: [row.lon, row.lat], zoom: 14, attributionControl: { compact: true },
+    });
+    detailMap.on("load", () => {
+      detailMap.addSource("addr", { type: "geojson", data: { type:"FeatureCollection", features:[] }});
+      detailMap.addLayer({ id:"addr-marker", type:"circle", source:"addr",
+        paint: { "circle-radius": 9, "circle-color": "#1642DF", "circle-stroke-color":"#fff", "circle-stroke-width": 2.5 }});
+    });
+  }
+  const setMarker = () => {
+    detailMap.getSource("addr").setData({ type:"FeatureCollection", features:[
+      { type:"Feature", geometry:{ type:"Point", coordinates:[row.lon, row.lat] }, properties:{} }
+    ]});
+    detailMap.flyTo({ center: [row.lon, row.lat], zoom: 14 });
+  };
+  if (detailMap.loaded()) setMarker(); else detailMap.once("load", setMarker);
+}
+
+async function generateLiveParagraph() {
+  if (!selected) return;
+  const btn = $("#livePara"); btn.disabled = true; btn.textContent = "Generating…";
+  try {
+    const u = `/api/stream?q=${encodeURIComponent(selected.address + ", " + selected.borough)}`;
+    // collect SSE final event
+    const text = await new Promise((resolve, reject) => {
+      const es = new EventSource(u);
+      es.addEventListener("final", (m) => { resolve(JSON.parse(m.data)); es.close(); });
+      es.addEventListener("error", () => { reject(new Error("stream error")); es.close(); });
+      setTimeout(() => { reject(new Error("timeout")); es.close(); }, 90000);
+    });
+    if (text.paragraph) {
+      selected.snap.paragraph = text.paragraph;
+      selected.snap.rag = text.rag || selected.snap.rag;
+      renderDetail(selected);
+    }
+  } catch (e) {
+    btn.textContent = "Failed: " + e.message;
+    btn.disabled = false;
+  }
+}
+
+function exportCsv() {
+  const cols = ["tier","score","name","address","borough","bbl","bin",
+                "lat","lon","sandy","dep_extreme_2080","floodnet_events_3y",
+                "ida_hwms_800m","nyc311_5y"];
+  const lines = [cols.join(",")];
+  for (const r of filteredRows) {
+    const s = r.snap || {};
+    const row = [
+      r.tier, r.score, JSON.stringify(r.name), JSON.stringify(r.address || ""),
+      r.borough || "", r.bbl || "", r.bin || "", r.lat, r.lon,
+      s.sandy ? 1 : 0,
+      (s.dep && s.dep.dep_extreme_2080 && s.dep.dep_extreme_2080.depth_class) || 0,
+      (s.floodnet && s.floodnet.n_flood_events_3y) || 0,
+      (s.ida_hwm && s.ida_hwm.n_within_radius) || 0,
+      (s.nyc311 && s.nyc311.n) || 0,
+    ];
+    lines.push(row.join(","));
+  }
+  const blob = new Blob([lines.join("\n")], { type: "text/csv" });
+  download(blob, "riprap_schools_register.csv");
+}
+
+function exportGeojson() {
+  const features = filteredRows.map((r) => ({
+    type: "Feature",
+    geometry: { type: "Point", coordinates: [r.lon, r.lat] },
+    properties: {
+      tier: r.tier, score: r.score, name: r.name, address: r.address,
+      borough: r.borough, bbl: r.bbl, bin: r.bin,
+      sandy: !!(r.snap && r.snap.sandy),
+      dep_extreme_2080: (r.snap && r.snap.dep && r.snap.dep.dep_extreme_2080 && r.snap.dep.dep_extreme_2080.depth_class) || 0,
+    },
+  }));
+  const blob = new Blob([JSON.stringify({ type: "FeatureCollection", features })],
+                        { type: "application/geo+json" });
+  download(blob, "riprap_schools_register.geojson");
+}
+
+function download(blob, filename) {
+  const u = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = u; a.download = filename;
+  document.body.appendChild(a); a.click();
+  setTimeout(() => { document.body.removeChild(a); URL.revokeObjectURL(u); }, 200);
+}
+
+// Asset class is parsed from URL path: /register/<asset_class>
+const ASSET_CLASS = (location.pathname.match(/\/register\/([^\/?]+)/) || [])[1] || "schools";
+
+const ASSET_TITLES = {
+  schools:        "NYC public schools — flood exposure register",
+  nycha:          "NYCHA developments — flood exposure register",
+  mta_entrances:  "MTA subway entrances — flood exposure register",
+};
+document.title = `Riprap — ${ASSET_TITLES[ASSET_CLASS] || ASSET_CLASS}`;
+const tagSpan = document.querySelector(".brand-tag");
+if (tagSpan) tagSpan.textContent = ASSET_TITLES[ASSET_CLASS] || ASSET_CLASS;
+
+const classPicker = document.getElementById("classPicker");
+if (classPicker) {
+  classPicker.value = ASSET_CLASS;
+  classPicker.addEventListener("change", () => {
+    location.href = `/register/${classPicker.value}`;
+  });
+}
+
+(async function init() {
+  const r = await fetch(`/api/register/${ASSET_CLASS}`);
+  if (!r.ok) {
+    const script = `python scripts/build_${ASSET_CLASS}_register.py`;
+    $("#regBody").innerHTML = `<tr><td colspan="9" style="padding: 20px; color: var(--text-muted);">Register not built. Run <code>${script}</code>.</td></tr>`;
+    return;
+  }
+  const data = await r.json();
+  allRows = data.rows || [];
+  filteredRows = allRows.slice();
+
+  // tier counts
+  $("#totalCount").textContent = allRows.length;
+  $("#tier1Count").textContent = allRows.filter(r => r.tier === 1).length;
+  $("#tier2Count").textContent = allRows.filter(r => r.tier === 2).length;
+  $("#tier3Count").textContent = allRows.filter(r => r.tier === 3).length;
+
+  renderTable();
+
+  $("#filter").addEventListener("input", applyFilters);
+  $("#boroughFilter").addEventListener("change", applyFilters);
+  $("#exportCsv").addEventListener("click", exportCsv);
+  $("#exportGeojson").addEventListener("click", exportGeojson);
+  $("#livePara").addEventListener("click", generateLiveParagraph);
+})();