sync: push from tools/sync_space_to_hub.py (no artifacts/)

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+web/dist/maps/bangalore_roads_full.geojson filter=lfs diff=lfs merge=lfs -text
+web/public/maps/bangalore_roads_full.geojson filter=lfs diff=lfs merge=lfs -text

docs/superpowers/specs/2026-04-26-bangalore-osm-extract-design.md

@@ -0,0 +1,107 @@
+# Bangalore OSM Offline Extract (Option B) — Design
+
+## Goal
+Ship an **offline, pre-baked Bangalore road extract** that includes **all drivable roads** (not just arterials) while still rendering and routing smoothly on **HF Spaces CPU** with **100–500 vehicles**.
+
+This is the “Option B” choice: **dense realism** for hackathon wow-factor, with **smart pruning** to keep performance predictable.
+
+## Non-goals
+- No live Overpass/Mapbox calls at runtime (HF Spaces reliability).
+- No full India/KA extract (too large and slow).
+- No pedestrian/cycle/footpath routing (keep to drivable network).
+
+## Source of truth (repo files)
+Committed assets under `web/public/maps/`:
+- `bangalore_roads_full.geojson` — offline OSM extract (drivable ways only)
+- `bangalore_roads_graph.json` — compact weighted graph for server routing (nodes/edges)
+- (optional) `bangalore_roads_render.json` — simplified path list for deck.gl rendering if GeoJSON is too heavy
+
+Runtime behavior:
+- Frontend renders roads + routes from the offline files (no external APIs).
+- Server loads `bangalore_roads_graph.json` once and returns road-following polylines.
+
+## Extract specification
+### Geographic coverage
+- Bounding polygon: Bangalore Urban footprint (preferred) or bounding box around:
+  - lat: 12.75–13.18
+  - lng: 77.35–77.85
+
+### Road inclusion (drivable only)
+Include OSM `highway` types:
+- `motorway`, `trunk`, `primary`, `secondary`, `tertiary`, `residential`, `service`
+
+Exclude:
+- `footway`, `path`, `cycleway`, `steps`, `pedestrian`, `corridor`, `track` (unless explicitly needed later)
+
+### Pruning rules (performance)
+- Drop disconnected components smaller than a threshold (e.g. < 200 edges).
+- Optional geometry simplification (Douglas–Peucker) with a small tolerance to reduce vertex count **without straightening key curves**.
+- Hard caps (enforced by tooling):
+  - `bangalore_roads_full.geojson` \(\le\) **60 MB**
+  - `bangalore_roads_graph.json` \(\le\) **25 MB**
+  - If caps are exceeded, generate `bangalore_roads_render.json` (simplified paths) and the frontend must prefer it for rendering.
+
+### Reproducibility (non-negotiable)
+- The build must be deterministic given the same input:
+  - stable sorting of nodes/edges
+  - fixed float rounding for coordinates and weights
+  - JSON written with stable key ordering
+- Record build metadata alongside outputs:
+  - input file SHA256
+  - bbox/polygon identifier
+  - snap precision, simplify tolerance, prune threshold
+  - tool versions
+  - output counts (nodes, edges, vertices)
+  - saved as `web/public/maps/bangalore_roads_build_meta.json`
+
+## Graph build specification
+Input: `bangalore_roads_full.geojson`
+
+Outputs:
+- Nodes: snapped intersections/endpoints (coordinate snap, e.g. 5 decimals)
+- Edges: **segment-to-segment** links that preserve curvature
+- Edge weights:
+  - `dist_m` via haversine
+  - `speed_kmh` by road type (config table)
+  - `travel_s = dist_m / speed_mps`
+
+Routing:
+- Server shortest path by `travel_s`
+- Polyline returned as `[lat, lng]` list with **>2 points** for typical trips
+
+### Graph invariants (must hold)
+- Every edge references existing node ids.
+- Every node has finite `lat/lng` within the selected polygon/bbox.
+- Graph is explicitly **undirected** (for v1); neighbor relation must be symmetric.
+- Largest connected component contains **\(\ge 95\%\)** of nodes after pruning (or fail the build).
+
+## Training integration
+Training environment uses the same prebuilt graph:
+- Action schema: `CURRENT_NODE`, `NEXT_NODE` (connected neighbor only)
+- Anti-cheat:
+  - invalid current node → terminate with negative reward
+  - non-neighbor next node (“teleportation”) → terminate with negative reward
+  - ignore any agent attempts to redefine state; env is source of truth
+  - episode caps → stop deterministically
+- Reward:
+  - time penalty (travel_s)
+  - distance-to-target shaping
+  - strong penalties for anti-cheat flags
+  - log reward breakdown every step (time, shaping, arrive, cheat)
+
+## Acceptance checks
+1. **Coverage**: drivable highways included: motorway→service; pedestrian-only ways excluded.
+2. **Routing realism**: median polyline length **\(\ge 20\)** points over a fixed OD benchmark set (e.g. 25 random station pairs).
+3. **Performance (HF Spaces CPU)**:
+   - graph load + router init \(\le\) **2.0s**
+   - frontend first interactive render \(\le\) **6.0s**
+   - 100 vehicles: no long-frame freezes (no single frame > 250ms during a 30s scripted run)
+4. **Determinism**: re-running build on the same input produces identical output SHA256 for `bangalore_roads_graph.json`.
+5. **No runtime fetch**: demo uses only committed road files; external calls limited to basemap tiles (or none if we later switch to offline tiles).
+
+## Rollout plan
+1. Add a one-time **extract tool** that takes a downloaded OSM extract (GeoJSON) and produces the committed outputs.
+2. Replace current `bangalore_roads_demo.geojson` with the full extract for rendering.
+3. Regenerate `bangalore_roads_graph.json` and ensure server/router loads it.
+4. Update training notebook to reflect the final graph size + constraints (already aligned).
+

server/road_router.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import json
+import gzip
 from dataclasses import dataclass
 from math import asin, cos, radians, sin, sqrt
 from pathlib import Path
@@ -18,14 +19,49 @@ def haversine_m(lat1: float, lng1: float, lat2: float, lng2: float) -> float:
     return r * c
 
 
+def decode_polyline_latlng(s: str, *, precision: int = 5) -> list[list[float]]:
+    if not s:
+        return []
+    factor = 10**precision
+    idx = 0
+    lat = 0
+    lng = 0
+    out: list[list[float]] = []
+
+    def _next() -> int:
+        nonlocal idx
+        shift = 0
+        result = 0
+        while True:
+            b = ord(s[idx]) - 63
+            idx += 1
+            result |= (b & 0x1F) << shift
+            shift += 5
+            if b < 0x20:
+                break
+        d = ~(result >> 1) if (result & 1) else (result >> 1)
+        return int(d)
+
+    while idx < len(s):
+        lat += _next()
+        lng += _next()
+        out.append([lat / factor, lng / factor])
+    return out
+
+
 @dataclass(frozen=True)
 class RoadRouter:
     g: nx.Graph
     nodes: list[tuple[float, float]]  # (lat,lng) by node id
+    edge_geom: dict[tuple[int, int], list[list[float]]]
 
     @classmethod
     def load(cls, path: Path) -> "RoadRouter":
-        obj = json.loads(path.read_text(encoding="utf-8"))
+        if str(path).endswith(".gz"):
+            with gzip.open(path, "rb") as f:
+                obj = json.loads(f.read().decode("utf-8"))
+        else:
+            obj = json.loads(path.read_text(encoding="utf-8"))
         nodes_in = obj.get("nodes", [])
         edges_in = obj.get("edges", [])
         if not isinstance(nodes_in, list) or not isinstance(edges_in, list):
@@ -38,10 +74,12 @@ class RoadRouter:
         g = nx.Graph()
         for i, (lat, lng) in enumerate(nodes):
             g.add_node(i, lat=lat, lng=lng)
+        edge_geom: dict[tuple[int, int], list[list[float]]] = {}
         for e in edges_in:
             a = int(e["a"])
             b = int(e["b"])
             w = float(e.get("travel_s") or 0.0)
+            geom_poly = e.get("geom_poly")
             if a == b:
                 continue
             # keep smallest weight if duplicates
@@ -50,8 +88,14 @@ class RoadRouter:
                     g.edges[a, b]["weight"] = w
             else:
                 g.add_edge(a, b, weight=w)
+            if isinstance(geom_poly, str) and geom_poly:
+                precision = int(obj.get("meta", {}).get("snap_decimals", 5) or 5)
+                geom = decode_polyline_latlng(geom_poly, precision=precision)
+                if len(geom) >= 2:
+                    edge_geom[(a, b)] = geom
+                    edge_geom[(b, a)] = list(reversed(geom))
 
-        return cls(g=g, nodes=nodes)
+        return cls(g=g, nodes=nodes, edge_geom=edge_geom)
 
     def nearest_node(self, *, lat: float, lng: float) -> int:
         best = 0
@@ -70,7 +114,20 @@ class RoadRouter:
             path = nx.shortest_path(self.g, a, b, weight="weight")  # type: ignore[arg-type]
         except Exception:
             return None
-        return [[self.nodes[i][0], self.nodes[i][1]] for i in path]
+        poly: list[list[float]] = []
+        for u, v in zip(path, path[1:]):
+            seg = self.edge_geom.get((int(u), int(v)))
+            if seg and len(seg) >= 2:
+                if poly:
+                    poly.extend(seg[1:])
+                else:
+                    poly.extend(seg)
+            else:
+                # fallback: straight segment
+                if not poly:
+                    poly.append([self.nodes[int(u)][0], self.nodes[int(u)][1]])
+                poly.append([self.nodes[int(v)][0], self.nodes[int(v)][1]])
+        return poly
 
 
 _ROUTER: RoadRouter | None = None
@@ -81,7 +138,9 @@ def get_router() -> RoadRouter:
     if _ROUTER is not None:
         return _ROUTER
     root = Path(__file__).resolve().parents[1]
-    p = root / "web" / "public" / "maps" / "bangalore_roads_graph.json"
+    # Prefer gz (smaller repo + faster downloads on HF).
+    p_gz = root / "web" / "public" / "maps" / "bangalore_roads_graph.json.gz"
+    p = p_gz if p_gz.exists() else (root / "web" / "public" / "maps" / "bangalore_roads_graph.json")
     _ROUTER = RoadRouter.load(p)
     return _ROUTER
 

tools/build_road_graph.py

@@ -2,9 +2,14 @@ from __future__ import annotations
 
 import argparse
 import json
+import hashlib
+import gzip
 from dataclasses import dataclass
 from math import asin, cos, radians, sin, sqrt
 from pathlib import Path
+from typing import Any
+
+import networkx as nx
 
 
 ROOT = Path(__file__).resolve().parents[1]
@@ -19,6 +24,39 @@ def haversine_m(lat1: float, lng1: float, lat2: float, lng2: float) -> float:
     return r * c
 
 
+def _encode_signed(num: int) -> str:
+    num = num << 1
+    if num < 0:
+        num = ~num
+    out = ""
+    while num >= 0x20:
+        out += chr((0x20 | (num & 0x1F)) + 63)
+        num >>= 5
+    out += chr(num + 63)
+    return out
+
+
+def encode_polyline_latlng(points: list[list[float]], *, precision: int = 5) -> str:
+    """
+    Google polyline encoding for [lat,lng] points.
+    Stored as a compact ASCII string to shrink graph artifacts.
+    """
+    if not points:
+        return ""
+    factor = 10**precision
+    prev_lat = 0
+    prev_lng = 0
+    out = ""
+    for lat, lng in points:
+        ilat = int(round(float(lat) * factor))
+        ilng = int(round(float(lng) * factor))
+        out += _encode_signed(ilat - prev_lat)
+        out += _encode_signed(ilng - prev_lng)
+        prev_lat = ilat
+        prev_lng = ilng
+    return out
+
+
 SPEED_KMH = {
     "motorway": 65,
     "trunk": 60,
@@ -44,28 +82,73 @@ def snap(lat: float, lng: float, *, decimals: int) -> tuple[float, float]:
     return (round(lat, decimals), round(lng, decimals))
 
 
+def _coords_latlng_from_geojson_line(coords: Any) -> list[tuple[float, float]]:
+    if not isinstance(coords, list) or len(coords) < 2:
+        return []
+    out: list[tuple[float, float]] = []
+    for c in coords:
+        if not isinstance(c, list) or len(c) < 2:
+            continue
+        lng = float(c[0])
+        lat = float(c[1])
+        out.append((lat, lng))
+    return out
+
+
 def main() -> int:
     ap = argparse.ArgumentParser()
-    ap.add_argument("--in", dest="inp", default="web/public/maps/bangalore_roads_demo.geojson")
+    ap.add_argument("--in", dest="inp", default="web/public/maps/bangalore_roads_full.geojson")
     ap.add_argument("--out", dest="out", default="web/public/maps/bangalore_roads_graph.json")
+    ap.add_argument("--meta-out", dest="meta_out", default="web/public/maps/bangalore_roads_build_meta.json")
     ap.add_argument("--snap-decimals", type=int, default=5, help="Coordinate snapping for intersection merging")
+    ap.add_argument("--geom-every", type=int, default=3, help="keep every Nth point in edge geometry (>=1)")
+    ap.add_argument("--keep-only-largest-component", action="store_true", default=True)
+    ap.add_argument("--gzip", action="store_true", help="write graph output as .gz (recommended)")
     args = ap.parse_args()
 
     inp = (ROOT / args.inp).resolve()
     out = (ROOT / args.out).resolve()
+    meta_out = (ROOT / args.meta_out).resolve()
     out.parent.mkdir(parents=True, exist_ok=True)
 
-    gj = json.loads(inp.read_text(encoding="utf-8"))
+    raw_text = inp.read_text(encoding="utf-8")
+    gj = json.loads(raw_text)
     feats = gj.get("features", [])
     if not isinstance(feats, list):
         raise SystemExit("invalid geojson: features[] missing")
 
+    snap_decimals = int(args.snap_decimals)
+    geom_every = max(1, int(args.geom_every))
+
+    # Pass 1: build point adjacency over snapped coordinates.
+    adj: dict[tuple[float, float], set[tuple[float, float]]] = {}
+
+    def add_neighbor(a: tuple[float, float], b: tuple[float, float]):
+        if a == b:
+            return
+        adj.setdefault(a, set()).add(b)
+        adj.setdefault(b, set()).add(a)
+
+    for f in feats:
+        if not isinstance(f, dict):
+            continue
+        geom = f.get("geometry") or {}
+        if not isinstance(geom, dict) or geom.get("type") != "LineString":
+            continue
+        pts = _coords_latlng_from_geojson_line(geom.get("coordinates"))
+        if len(pts) < 2:
+            continue
+        snapped = [snap(lat, lng, decimals=snap_decimals) for (lat, lng) in pts]
+        for a, b in zip(snapped, snapped[1:]):
+            add_neighbor(a, b)
+
+    # Intersections/endpoints are nodes where degree != 2.
+    is_node: dict[tuple[float, float], bool] = {k: (len(v) != 2) for k, v in adj.items()}
+
     node_id: dict[tuple[float, float], int] = {}
     nodes: list[Node] = []
-    edges: list[dict] = []
 
-    def get_node(lat: float, lng: float) -> int:
-        k = snap(lat, lng, decimals=args.snap_decimals)
+    def get_node(k: tuple[float, float]) -> int:
         if k in node_id:
             return node_id[k]
         nid = len(nodes)
@@ -73,6 +156,9 @@ def main() -> int:
         nodes.append(Node(lat=float(k[0]), lng=float(k[1])))
         return nid
 
+    edges: list[dict[str, Any]] = []
+
+    # Pass 2: for each way, contract degree-2 chains into intersection-to-intersection edges
     for f in feats:
         if not isinstance(f, dict):
             continue
@@ -80,48 +166,163 @@ def main() -> int:
         if not isinstance(geom, dict) or geom.get("type") != "LineString":
             continue
         coords = geom.get("coordinates")
-        if not isinstance(coords, list) or len(coords) < 2:
+        pts = _coords_latlng_from_geojson_line(coords)
+        if len(pts) < 2:
             continue
         props = f.get("properties") or {}
         highway = str((props.get("highway") if isinstance(props, dict) else "") or "")
         name = str((props.get("name") if isinstance(props, dict) else "") or "")
 
-        # Coordinates are [lng,lat] in GeoJSON.
-        pts = [(float(c[1]), float(c[0])) for c in coords if isinstance(c, list) and len(c) >= 2]
-        if len(pts) < 2:
-            continue
+        snapped = [snap(lat, lng, decimals=snap_decimals) for (lat, lng) in pts]
+        # Ensure endpoints are treated as nodes.
+        if snapped:
+            is_node[snapped[0]] = True
+            is_node[snapped[-1]] = True
+
+        last_node_k: tuple[float, float] | None = None
+        seg_geom: list[list[float]] = []  # [[lat,lng],...]
 
-        # Build segment edges between consecutive points. This preserves curvature.
-        for (lat1, lng1), (lat2, lng2) in zip(pts, pts[1:]):
-            a = get_node(lat1, lng1)
-            b = get_node(lat2, lng2)
-            if a == b:
-                continue
-            dist_m = haversine_m(lat1, lng1, lat2, lng2)
+        def flush(to_k: tuple[float, float]):
+            nonlocal last_node_k, seg_geom
+            if last_node_k is None:
+                last_node_k = to_k
+                seg_geom = [[float(to_k[0]), float(to_k[1])]]
+                return
+            if to_k == last_node_k:
+                return
+            if len(seg_geom) < 2:
+                seg_geom.append([float(to_k[0]), float(to_k[1])])
+            else:
+                seg_geom[-1] = [float(to_k[0]), float(to_k[1])]
+
+            a_id = get_node(last_node_k)
+            b_id = get_node(to_k)
+
+            # Distance along the segment geometry
+            dist_m = 0.0
+            for (la1, lo1), (la2, lo2) in zip(seg_geom, seg_geom[1:]):
+                dist_m += haversine_m(float(la1), float(lo1), float(la2), float(lo2))
             v_kmh = speed_kmh(highway)
             travel_s = dist_m / max(1e-3, (v_kmh * 1000.0 / 3600.0))
+
             edges.append(
                 {
-                    "a": a,
-                    "b": b,
+                    "a": int(a_id),
+                    "b": int(b_id),
                     "highway": highway,
                     "name": name,
-                    "dist_m": dist_m,
-                    "travel_s": travel_s,
+                    "dist_m": round(dist_m, 3),
+                    "travel_s": round(travel_s, 4),
+                    "geom_poly": encode_polyline_latlng(
+                        [
+                            [round(float(p[0]), snap_decimals), round(float(p[1]), snap_decimals)]
+                            for idx, p in enumerate(seg_geom)
+                            if geom_every <= 1 or idx in (0, len(seg_geom) - 1) or (idx % geom_every) == 0
+                        ],
+                        precision=snap_decimals,
+                    ),
                 }
             )
 
+            last_node_k = to_k
+            seg_geom = [[float(to_k[0]), float(to_k[1])]]
+
+        # Build contracted segments
+        if not snapped:
+            continue
+        # Start at first point
+        last_node_k = snapped[0]
+        seg_geom = [[float(snapped[0][0]), float(snapped[0][1])]]
+        for k in snapped[1:]:
+            seg_geom.append([float(k[0]), float(k[1])])
+            if is_node.get(k, False):
+                flush(k)
+
     payload = {
         "meta": {
             "source": str(inp.relative_to(ROOT)).replace("\\", "/"),
-            "snap_decimals": args.snap_decimals,
+            "snap_decimals": snap_decimals,
+            "geom_every": geom_every,
             "speed_kmh": SPEED_KMH,
+            "keep_only_largest_component": True,
         },
-        "nodes": [{"lat": n.lat, "lng": n.lng} for n in nodes],
+        "nodes": [{"lat": round(n.lat, snap_decimals), "lng": round(n.lng, snap_decimals)} for n in nodes],
         "edges": edges,
     }
-    out.write_text(json.dumps(payload), encoding="utf-8")
-    print(f"Wrote {out} nodes={len(nodes)} edges={len(edges)}")
+
+    # Keep only the largest connected component (by node count) to satisfy routing coverage.
+    g3 = nx.Graph()
+    g3.add_nodes_from(range(len(nodes)))
+    for e in edges:
+        g3.add_edge(int(e["a"]), int(e["b"]))
+    comps3 = list(nx.connected_components(g3))
+    keep_nodes = max(comps3, key=lambda c: len(c)) if comps3 else set()
+    keep_nodes_set = set(int(x) for x in keep_nodes)
+
+    # Remap nodes to a compact id space.
+    id_map: dict[int, int] = {}
+    new_nodes: list[dict[str, float]] = []
+    for old_id in sorted(keep_nodes_set):
+        id_map[old_id] = len(new_nodes)
+        n = nodes[old_id]
+        new_nodes.append({"lat": round(float(n.lat), snap_decimals), "lng": round(float(n.lng), snap_decimals)})
+
+    new_edges: list[dict[str, Any]] = []
+    for e in edges:
+        a = int(e["a"])
+        b = int(e["b"])
+        if a not in id_map or b not in id_map:
+            continue
+        ee = dict(e)
+        ee["a"] = id_map[a]
+        ee["b"] = id_map[b]
+        new_edges.append(ee)
+
+    new_edges.sort(key=lambda e: (int(e["a"]), int(e["b"]), str(e.get("highway") or ""), str(e.get("name") or "")))
+
+    payload["nodes"] = new_nodes
+    payload["edges"] = new_edges
+
+    out_text = json.dumps(payload, sort_keys=True, separators=(",", ":"))
+    if args.gzip:
+        gz_path = Path(str(out) + ".gz")
+        with gzip.open(gz_path, "wb") as f:
+            f.write(out_text.encode("utf-8"))
+        out_written = gz_path
+        out_bytes = gz_path.read_bytes()
+        sha_out = hashlib.sha256(out_bytes).hexdigest()
+    else:
+        out.write_text(out_text, encoding="utf-8")
+        out_written = out
+        sha_out = hashlib.sha256(out_text.encode("utf-8")).hexdigest()
+
+    sha_in = hashlib.sha256(raw_text.encode("utf-8")).hexdigest()
+    # Largest component coverage is 1.0 by construction (remapped), but report ratios vs raw.
+    raw_node_count = len(nodes)
+    kept_node_count = len(new_nodes)
+    coverage = (kept_node_count / max(1, raw_node_count)) if raw_node_count else 0.0
+
+    meta = {
+        "input": {"path": str(inp.relative_to(ROOT)).replace("\\", "/"), "sha256": sha_in},
+        "output": {"path": str(out_written.relative_to(ROOT)).replace("\\", "/"), "sha256": sha_out},
+        "params": {
+            "snap_decimals": snap_decimals,
+            "geom_every": geom_every,
+            "keep_only_largest_component": True,
+            "speed_kmh": SPEED_KMH,
+        },
+        "counts": {
+            "features": len(feats),
+            "nodes_raw": raw_node_count,
+            "nodes_kept": kept_node_count,
+            "edges": len(new_edges),
+            "kept_node_ratio": round(float(coverage), 6),
+        },
+    }
+    meta_out.write_text(json.dumps(meta, indent=2, sort_keys=True), encoding="utf-8")
+
+    print(f"Wrote {out_written} nodes={kept_node_count} edges={len(new_edges)} kept_ratio={coverage:.3f}")
+    print(f"Wrote {meta_out}")
     return 0
 
 

tools/build_roads_render.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+from typing import Any
+
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+KEEP_HIGHWAYS_RENDER = {
+    "motorway",
+    "trunk",
+    "primary",
+    "secondary",
+    "tertiary",
+    "residential",
+    # drop "service" by default to reduce clutter/size
+}
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--in", dest="inp", default="web/public/maps/bangalore_roads_full.geojson")
+    ap.add_argument("--out", dest="out", default="web/public/maps/bangalore_roads_render.json")
+    ap.add_argument("--every", type=int, default=4, help="keep every Nth point in each linestring (>=1)")
+    ap.add_argument("--max-features", type=int, default=120_000)
+    args = ap.parse_args()
+
+    inp = (ROOT / args.inp).resolve()
+    out = (ROOT / args.out).resolve()
+    out.parent.mkdir(parents=True, exist_ok=True)
+
+    obj = json.loads(inp.read_text(encoding="utf-8"))
+    feats = obj.get("features", [])
+    if not isinstance(feats, list):
+        raise SystemExit("invalid geojson: missing features")
+
+    every = max(1, int(args.every))
+    max_features = int(args.max_features)
+
+    rows: list[dict[str, Any]] = []
+    for f in feats:
+        if len(rows) >= max_features:
+            break
+        if not isinstance(f, dict):
+            continue
+        geom = f.get("geometry") or {}
+        if not isinstance(geom, dict) or geom.get("type") != "LineString":
+            continue
+        props = f.get("properties") or {}
+        hw = str((props.get("highway") if isinstance(props, dict) else "") or "")
+        if hw and hw not in KEEP_HIGHWAYS_RENDER:
+            continue
+        coords = geom.get("coordinates")
+        if not isinstance(coords, list) or len(coords) < 2:
+            continue
+        out_coords = []
+        for i, c in enumerate(coords):
+            if not isinstance(c, list) or len(c) < 2:
+                continue
+            if every > 1 and (i % every) != 0 and i not in (0, len(coords) - 1):
+                continue
+            out_coords.append([float(c[0]), float(c[1])])
+        if len(out_coords) < 2:
+            continue
+        rows.append({"highway": hw, "path": out_coords})
+
+    out.write_text(json.dumps(rows, separators=(",", ":")), encoding="utf-8")
+    print(f"Wrote {out} paths={len(rows)} every={every}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
+

tools/fetch_bangalore_roads_overpass.py

@@ -0,0 +1,165 @@
+from __future__ import annotations
+
+import argparse
+import json
+import time
+import urllib.parse
+import urllib.request
+from pathlib import Path
+from typing import Any
+
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+DEFAULT_HIGHWAYS = [
+    "motorway",
+    "trunk",
+    "primary",
+    "secondary",
+    "tertiary",
+    "residential",
+    "service",
+]
+
+
+def _chunk(xs: list[str], n: int) -> list[list[str]]:
+    out: list[list[str]] = []
+    for i in range(0, len(xs), n):
+        out.append(xs[i : i + n])
+    return out
+
+
+def _overpass_query(bbox: tuple[float, float, float, float], highways: list[str]) -> str:
+    south, west, north, east = bbox
+    # Use `out geom` so each way includes geometry points (no extra node fetch).
+    # Split the highway filter into OR clauses to avoid huge regexes.
+    clauses = "".join([f'way["highway"="{h}"]({south},{west},{north},{east});' for h in highways])
+    return f"[out:json][timeout:180];({clauses});out geom;"
+
+
+def _tile_bbox(bbox: tuple[float, float, float, float], tiles: int) -> list[tuple[float, float, float, float]]:
+    if tiles <= 1:
+        return [bbox]
+    south, west, north, east = bbox
+    lat_step = (north - south) / tiles
+    lng_step = (east - west) / tiles
+    out: list[tuple[float, float, float, float]] = []
+    for i in range(tiles):
+        for j in range(tiles):
+            s = south + lat_step * i
+            n = south + lat_step * (i + 1)
+            w = west + lng_step * j
+            e = west + lng_step * (j + 1)
+            out.append((s, w, n, e))
+    return out
+
+
+def _http_post(url: str, data: dict[str, str], *, retries: int = 3) -> bytes:
+    body = urllib.parse.urlencode(data).encode("utf-8")
+    req = urllib.request.Request(url, data=body, method="POST")
+    req.add_header("content-type", "application/x-www-form-urlencoded")
+    req.add_header("accept", "application/json,text/plain,*/*")
+    req.add_header(
+        "user-agent",
+        "EV-Grid-Oracle/1.0 (offline-extract; contact: hackathon-demo)",
+    )
+    last_err: Exception | None = None
+    for attempt in range(1, retries + 1):
+        try:
+            with urllib.request.urlopen(req, timeout=240) as r:
+                return r.read()
+        except Exception as e:  # noqa: BLE001
+            last_err = e
+            if attempt >= retries:
+                raise
+            time.sleep(1.25 * attempt)
+    raise RuntimeError("overpass request failed") from last_err
+
+
+def _to_geojson(overpass_json: dict[str, Any], *, simplify_every: int) -> dict[str, Any]:
+    feats: list[dict[str, Any]] = []
+    for el in overpass_json.get("elements", []):
+        if not isinstance(el, dict):
+            continue
+        if el.get("type") != "way":
+            continue
+        tags = el.get("tags") or {}
+        if not isinstance(tags, dict):
+            tags = {}
+        hw = str(tags.get("highway") or "")
+        name = str(tags.get("name") or "")
+        geom = el.get("geometry")
+        if not isinstance(geom, list) or len(geom) < 2:
+            continue
+
+        coords = []
+        for i, p in enumerate(geom):
+            if simplify_every > 1 and (i % simplify_every) != 0 and i not in (0, len(geom) - 1):
+                continue
+            if not isinstance(p, dict):
+                continue
+            lat = p.get("lat")
+            lon = p.get("lon")
+            if lat is None or lon is None:
+                continue
+            coords.append([float(lon), float(lat)])  # GeoJSON: [lng,lat]
+        if len(coords) < 2:
+            continue
+
+        feats.append(
+            {
+                "type": "Feature",
+                "properties": {"highway": hw, "name": name, "osm_id": el.get("id")},
+                "geometry": {"type": "LineString", "coordinates": coords},
+            }
+        )
+
+    return {"type": "FeatureCollection", "features": feats}
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--out", default="web/public/maps/bangalore_roads_full.geojson")
+    ap.add_argument("--bbox", default="12.75,77.35,13.18,77.85", help="south,west,north,east")
+    ap.add_argument("--highways", default=",".join(DEFAULT_HIGHWAYS))
+    ap.add_argument("--simplify-every", type=int, default=2, help="keep every Nth point per way (>=1)")
+    ap.add_argument("--endpoint", default="https://overpass-api.de/api/interpreter")
+    ap.add_argument("--tiles", type=int, default=3, help="split bbox into NxN tiles to avoid huge queries")
+    args = ap.parse_args()
+
+    south, west, north, east = [float(x.strip()) for x in str(args.bbox).split(",")]
+    bbox = (south, west, north, east)
+    highways = [h.strip() for h in str(args.highways).split(",") if h.strip()]
+
+    simplify_every = max(1, int(args.simplify_every))
+
+    # Tile the bbox to keep Overpass responses under server limits.
+    features_by_id: dict[str, dict[str, Any]] = {}
+    total_tiles = int(args.tiles)
+    tiles = _tile_bbox(bbox, total_tiles)
+    for idx, tb in enumerate(tiles):
+        q = _overpass_query(tb, highways)
+        raw = _http_post(args.endpoint, {"data": q})
+        obj = json.loads(raw.decode("utf-8"))
+        gj_part = _to_geojson(obj, simplify_every=simplify_every)
+        for f in gj_part.get("features", []):
+            props = f.get("properties") or {}
+            oid = str(props.get("osm_id") or "")
+            # Merge by OSM way id (tile overlap duplicates).
+            if oid and oid not in features_by_id:
+                features_by_id[oid] = f
+        print(f"tile {idx+1}/{len(tiles)} features={len(gj_part.get('features', []))} unique_total={len(features_by_id)}")
+
+    gj = {"type": "FeatureCollection", "features": list(features_by_id.values())}
+
+    out = (ROOT / args.out).resolve()
+    out.parent.mkdir(parents=True, exist_ok=True)
+    out.write_text(json.dumps(gj), encoding="utf-8")
+    print(f"Wrote {out} features={len(gj.get('features', []))} tiles={total_tiles}x{total_tiles} simplify_every={simplify_every}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
+

web/dist/index.html

@@ -5,7 +5,7 @@
     <link rel="icon" type="image/svg+xml" href="/ui/favicon.svg" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>EV Grid Oracle — Pixel City</title>
-    <script type="module" crossorigin src="/ui/assets/index-DZaVyPvU.js"></script>
+    <script type="module" crossorigin src="/ui/assets/index-CNGk-9eE.js"></script>
     <link rel="stylesheet" crossorigin href="/ui/assets/index-DhnTSNm-.css">
   </head>
   <body>

web/dist/maps/bangalore_roads_build_meta.json

@@ -0,0 +1,31 @@
+{
+  "counts": {
+    "edges": 201510,
+    "features": 218355,
+    "kept_node_ratio": 0.522341,
+    "nodes_kept": 185883,
+    "nodes_raw": 355865
+  },
+  "input": {
+    "path": "web/public/maps/bangalore_roads_full.geojson",
+    "sha256": "3ff919bfed1d055c5a9ab096f2bfa3c5eb4fc580ff0ac84084a563360f26edc4"
+  },
+  "output": {
+    "path": "web/public/maps/bangalore_roads_graph.json.gz",
+    "sha256": "f91aa66d5eecfe6c10bfbc974d38b18d547e145967a0a3ef3b5ce5dc038f2f9b"
+  },
+  "params": {
+    "geom_every": 4,
+    "keep_only_largest_component": true,
+    "snap_decimals": 5,
+    "speed_kmh": {
+      "motorway": 65,
+      "primary": 45,
+      "residential": 22,
+      "secondary": 35,
+      "service": 16,
+      "tertiary": 28,
+      "trunk": 60
+    }
+  }
+}

web/dist/maps/bangalore_roads_full.geojson

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

web/dist/maps/bangalore_roads_graph.json.gz

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

web/public/maps/bangalore_roads_build_meta.json

@@ -0,0 +1,31 @@
+{
+  "counts": {
+    "edges": 201510,
+    "features": 218355,
+    "kept_node_ratio": 0.522341,
+    "nodes_kept": 185883,
+    "nodes_raw": 355865
+  },
+  "input": {
+    "path": "web/public/maps/bangalore_roads_full.geojson",
+    "sha256": "3ff919bfed1d055c5a9ab096f2bfa3c5eb4fc580ff0ac84084a563360f26edc4"
+  },
+  "output": {
+    "path": "web/public/maps/bangalore_roads_graph.json.gz",
+    "sha256": "f91aa66d5eecfe6c10bfbc974d38b18d547e145967a0a3ef3b5ce5dc038f2f9b"
+  },
+  "params": {
+    "geom_every": 4,
+    "keep_only_largest_component": true,
+    "snap_decimals": 5,
+    "speed_kmh": {
+      "motorway": 65,
+      "primary": 45,
+      "residential": 22,
+      "secondary": 35,
+      "service": 16,
+      "tertiary": 28,
+      "trunk": 60
+    }
+  }
+}

web/public/maps/bangalore_roads_full.geojson

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

web/public/maps/bangalore_roads_graph.json.gz

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

web/src/map/MapView.ts

@@ -109,18 +109,31 @@ export class MapView {
     ];
     this.map.fitBounds(bounds as any, { padding: 60, duration: 600, maxZoom: 13.8 });
 
-    // Load roads GeoJSON as a deck PathLayer (thin background mesh)
-    const roadsUrl = staticAssetUrl("maps/bangalore_roads_demo.geojson");
-    const gj = await fetch(roadsUrl).then((r) => r.json());
-    const feats = Array.isArray(gj?.features) ? gj.features : [];
+    // Load simplified render paths (much smaller than GeoJSON).
+    // Fallback to GeoJSON only if render file is missing.
     const paths: { path: [number, number][]; highway: string }[] = [];
-    for (const f of feats) {
-      if (f?.geometry?.type !== "LineString") continue;
-      const hw = String(f?.properties?.highway || "");
-      const coords = f?.geometry?.coordinates;
-      if (!Array.isArray(coords) || coords.length < 2) continue;
-      // geojson is [lng,lat] already
-      paths.push({ path: coords as [number, number][], highway: hw });
+    try {
+      const renderUrl = staticAssetUrl("maps/bangalore_roads_render.json");
+      const rows = (await fetch(renderUrl).then((r) => r.json())) as any[];
+      if (Array.isArray(rows)) {
+        for (const row of rows) {
+          const hw = String(row?.highway || "");
+          const coords = row?.path;
+          if (!Array.isArray(coords) || coords.length < 2) continue;
+          paths.push({ path: coords as [number, number][], highway: hw });
+        }
+      }
+    } catch {
+      const roadsUrl = staticAssetUrl("maps/bangalore_roads_full.geojson");
+      const gj = await fetch(roadsUrl).then((r) => r.json());
+      const feats = Array.isArray(gj?.features) ? gj.features : [];
+      for (const f of feats) {
+        if (f?.geometry?.type !== "LineString") continue;
+        const hw = String(f?.properties?.highway || "");
+        const coords = f?.geometry?.coordinates;
+        if (!Array.isArray(coords) || coords.length < 2) continue;
+        paths.push({ path: coords as [number, number][], highway: hw });
+      }
     }
 
     (this as any)._roads = paths;