diff --git a/.gitignore b/.gitignore
index 4ef22d8..8e7a709 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,6 +3,7 @@ __pycache__/
 *.py[cod]
 *$py.class
 .idea/
+*.DS_Store
 docs/.docusaurus
 docs/node_modules
 
@@ -135,3 +136,6 @@ src/zepben/examples/config*.json
 *.crt
 
 src/zepben/examples/csvs/
+
+config.json
+src/zepben/examples/config.json
diff --git a/pyproject.toml b/pyproject.toml
index 74983fb..5e7690a 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -30,6 +30,9 @@ dependencies = [
     "gql[requests]==3.5.3",
     "geopandas",
     "pandas",
+    "pg8000",
+    "python-dotenv>=1.0,<2",
+    "SQLAlchemy>=2.0,<3",
     "shapely",
     "tqdm"
 ]
diff --git a/src/zepben/examples/studies/README.md b/src/zepben/examples/studies/README.md
new file mode 100644
index 0000000..da92699
--- /dev/null
+++ b/src/zepben/examples/studies/README.md
@@ -0,0 +1,93 @@
+# Studies
+
+This folder contains runnable study scripts that fetch network data, generate GeoJSON overlays, and upload results to EAS.
+Most scripts accept a zone code (e.g. `CPM`) and use the shared config at `src/zepben/examples/config.json`.
+
+## Quick start
+
+1. Ensure `src/zepben/examples/config.json` has valid `host`, `access_token`, and `rpc_port`.
+2. Run a study from this folder, for example:
+
+```bash
+python transformer_utilisation_by_demand.py CPM
+```
+
+## Common patterns
+
+- **Zones vs feeders**: Some scripts support explicit feeder MRIDs. For transformer utilisation, use:
+
+```bash
+python transformer_utilisation_by_demand.py --mode feeders CPM3B3
+```
+
+- **Config override**: Most scripts accept `--config` to point at a different config file.
+- **Styles**: Each study uses a companion `style_*.json` file to control map rendering.
+- **Outputs**: Studies upload results to EAS and will log progress in the terminal.
+
+## Feeder tie switches study
+
+Detects switches acting as feeder ties and uploads a single tie-switch result layer.
+
+- **Default scope**: MV-only switch detection.
+- **Core tie rule**: a switch is treated as a feeder tie when it belongs to **more than one container** (normal/current feeder containers, plus LV parent containers when `--include-lv` is used).
+- **Tie type classification**:
+  - `mv_mv_tie` → MV↔MV ties
+  - `mv_lv_tie` → MV↔LV ties
+  - `lv_lv_tie` → LV↔LV ties
+- **LV support**: opt-in via `--include-lv`.
+- **CSV export**: always writes a detailed tie report to CSV. Override path with `--csv-output`.
+- **Study styling**: tie types are colour-coded in the study layers.
+
+Examples:
+
+```bash
+python feeder_tie_switches.py CPM
+python feeder_tie_switches.py --mode feeders CPM3B3
+python feeder_tie_switches.py --include-lv CPM
+python feeder_tie_switches.py CPM --csv-output ./reports/feeder_tie_switches_cpm.csv
+python feeder_tie_switches.py --mode full-network
+python feeder_tie_switches.py --mode full-network --full-network-list zones
+```
+
+## Data quality studies
+
+Data quality scripts live in `data_quality_studies/`. See the dedicated README for usage:
+
+- `src/zepben/examples/studies/data_quality_studies/README.md`
+
+## Analytics demo studies
+
+Mock zone-substation analytics demo scripts live in `analytics_demo_examples/`:
+
+- `src/zepben/examples/studies/analytics_demo_examples/README.md`
+
+## Hosting Capacity DB-backed studies
+
+Hosting Capacity examples that query PostgreSQL and upload propagated measurement-zone studies live in
+`hosting_capacity_examples/`:
+
+- `src/zepben/examples/studies/hosting_capacity_examples/README.md`
+
+## Troubleshooting
+
+- **Timeouts**: Large zones can take several minutes. Use a longer shell timeout or reduce concurrency if available.
+- **404s from Load API**: Some assets may not have demand profiles; the scripts continue and mark those as missing.
+- **No features uploaded**: If locations are missing, the study skips upload and logs a message.
+
+## Scripts in this folder
+
+Representative studies:
+- `transformer_utilisation_by_demand.py`
+- `pv_percent_by_transformer.py`
+- `suspect_end_of_line.py`
+- `feeder_tie_switches.py`
+- `transformer_downstream_density.py`
+- `customer_distance_to_transformer.py`
+- `loop_impedance_by_energy_consumer.py`
+- `tap_changer_info_by_transformer.py`
+
+See each script’s header and help output for specifics:
+
+```bash
+python <script>.py --help
+```
diff --git a/src/zepben/examples/studies/analytics_demo_examples/README.md b/src/zepben/examples/studies/analytics_demo_examples/README.md
new file mode 100644
index 0000000..333311e
--- /dev/null
+++ b/src/zepben/examples/studies/analytics_demo_examples/README.md
@@ -0,0 +1,48 @@
+# Zone Substation Analytics Demo
+
+This folder contains a correlated analytics demo study uploader for regional network-performance review.
+
+The demo is designed for overview workflows at zone-substation level and intentionally keeps drill-down dashboards out of scope.
+Each feature includes a `dashboard_key` property so external dashboards can be linked later.
+The generated values are synthetic, but correlated to live EWB network signals (topology, customer counts, PV/PEC penetration, phase spread, impedance proxy, inferred loading/headroom).
+
+## Script
+
+- `mock_zone_analytics_study.py`
+
+## Included use-case layers
+
+The script currently publishes one result per selected use case:
+
+1. Neutral Integrity Fault Detection
+2. Voltage Monitoring and Reporting
+3. Dynamic Voltage Control
+4. Phase Identification
+5. CER Compliance
+6. CER Performance
+7. EV Charger Detection
+
+Notes:
+- Dynamic Voltage Control mock logic uses ADMD `4kW` and ADMG `5kW` per customer for tap-zone voltage-drop estimates on MV lines.
+- MV/LV loading and New connection assessment layers were intentionally removed from this demo.
+- CER detection was intentionally removed in this version.
+
+Each result maps to dedicated styles in `style_mock_zone_analytics.json`, so every use case appears as its own selectable layer in the study sidebar/legend.
+
+## Run
+
+From `src/zepben/examples/studies/analytics_demo_examples`:
+
+```bash
+python mock_zone_analytics_study.py
+```
+
+Optional args:
+
+```bash
+python mock_zone_analytics_study.py --zones CPM --seed 42
+python mock_zone_analytics_study.py --dry-run
+python mock_zone_analytics_study.py --period-start 2025-01-01 --period-end 2025-12-31
+```
+
+The script reads credentials from `src/zepben/examples/config.json` by default.
diff --git a/src/zepben/examples/studies/analytics_demo_examples/mock_zone_analytics_study.py b/src/zepben/examples/studies/analytics_demo_examples/mock_zone_analytics_study.py
new file mode 100644
index 0000000..0d9a544
--- /dev/null
+++ b/src/zepben/examples/studies/analytics_demo_examples/mock_zone_analytics_study.py
@@ -0,0 +1,1264 @@
+#  Copyright 2026 Zeppelin Bend Pty Ltd
+#
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+import argparse
+import asyncio
+import json
+import math
+import random
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Dict, Iterable, List, Optional, Sequence, Set, Tuple
+
+from geojson import Feature, FeatureCollection
+from geojson.geometry import LineString, Point
+from zepben.eas.client.eas_client import EasClient
+from zepben.eas.client.study import GeoJsonOverlay, Result, Study
+from zepben.ewb import (
+    AcLineSegment,
+    ConductingEquipment,
+    EnergyConsumer,
+    Feeder,
+    IncludedEnergizedContainers,
+    NetworkConsumerClient,
+    NetworkTraceStep,
+    PhaseCode,
+    PhotoVoltaicUnit,
+    PowerElectronicsConnection,
+    PowerTransformer,
+    Tracing,
+    connect_with_token,
+    downstream,
+    stop_at_open,
+    upstream,
+)
+from zepben.ewb.services.network.tracing.networktrace.operators.network_state_operators import NetworkStateOperators
+
+
+CONFIG_PATH = Path(__file__).resolve().parents[2] / "config.json"
+STYLE_PATH = Path(__file__).resolve().parent / "style_mock_zone_analytics.json"
+
+# ADMD / ADMG assumptions requested by user.
+ADMD_KW_PER_CUSTOMER = 4.0
+ADMG_KW_PER_CUSTOMER = 5.0
+
+
+USE_CASE_NAMES: Dict[int, str] = {
+    6: "Neutral Integrity Fault Detection",
+    7: "Voltage Monitoring and Reporting",
+    8: "Dynamic Voltage Control",
+    9: "Phase Identification",
+    13: "CER Compliance",
+    14: "CER Performance",
+    15: "EV Charger Detection",
+}
+
+
+@dataclass(frozen=True)
+class FeederRef:
+    zone_code: str
+    feeder_mrid: str
+    feeder_name: str
+
+
+@dataclass
+class CustomerAnalytics:
+    mrid: str
+    feeder_mrid: str
+    feeder_name: str
+    zone_code: str
+    lon: float
+    lat: float
+    phase_class: str
+    has_pv: bool
+    transformer_mrid: str
+    tx_impedance_proxy: float
+    tx_load_util_pct: float
+    tx_generation_util_pct: float
+    tx_est_voltage_pct: float
+    tx_pv_penetration_pct: float
+    tx_pec_penetration_pct: float
+
+
+@dataclass
+class TransformerAnalytics:
+    mrid: str
+    name: str
+    feeder_mrid: str
+    feeder_name: str
+    zone_code: str
+    lon: Optional[float]
+    lat: Optional[float]
+    ec_count: int
+    pv_ec_count: int
+    pv_capacity_kva: float
+    pec_count: int
+    pec_capacity_kva: float
+    rating_kva: float
+    line_km: float
+    mean_z_ohm_per_km: float
+    impedance_proxy: float
+    load_util_pct: float
+    generation_util_pct: float
+    headroom_kw: float
+    upstream_mv_line_ids: Set[str] = field(default_factory=set)
+    path_mv_impedance_ohm: float = 0.0
+    estimated_mv_voltage_pct: float = 100.0
+    tap_from: int = 0
+    tap_to: int = 0
+    tap_action: str = "Hold"
+    tap_change_required: bool = False
+    curtailment_kwh: float = 0.0
+
+    @property
+    def pv_ratio(self) -> float:
+        if self.ec_count <= 0:
+            return 0.0
+        return self.pv_ec_count / self.ec_count
+
+    @property
+    def pv_penetration_pct_of_rating(self) -> float:
+        return (self.pv_capacity_kva / max(self.rating_kva, 1.0)) * 100.0
+
+    @property
+    def pec_penetration_pct_of_rating(self) -> float:
+        return (self.pec_capacity_kva / max(self.rating_kva, 1.0)) * 100.0
+
+
+@dataclass
+class MvLineAnalytics:
+    mrid: str
+    name: str
+    feeder_mrid: str
+    feeder_name: str
+    zone_code: str
+    coordinates: List[Tuple[float, float]]
+    length_km: float
+    z_ohm_per_km: float
+    base_kv: float
+    downstream_ec_count: int
+    downstream_pv_count: int
+    net_kw: float
+    signed_voltage_change_pct: float
+    estimated_end_voltage_pct: float
+    tap_zone: str
+
+
+@dataclass
+class FeederAnalytics:
+    ref: FeederRef
+    customers: List[CustomerAnalytics]
+    transformers: List[TransformerAnalytics]
+    mv_lines: List[MvLineAnalytics]
+
+    @property
+    def total_ec(self) -> int:
+        return len(self.customers)
+
+    @property
+    def total_pv_ec(self) -> int:
+        return sum(1 for c in self.customers if c.has_pv)
+
+    @property
+    def pv_ratio(self) -> float:
+        if self.total_ec <= 0:
+            return 0.0
+        return self.total_pv_ec / self.total_ec
+
+
+def parse_args(argv: Sequence[str]) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Upload a correlated mock analytics study using live EWB network data. "
+            "Each use case is published as its own result layer."
+        )
+    )
+    parser.add_argument("--zones", default="CPM", help="Comma-separated zone MRIDs to analyse.")
+    parser.add_argument("--config", default=str(CONFIG_PATH), help="Path to config.json.")
+    parser.add_argument("--seed", type=int, default=20260219, help="Deterministic seed for mock generation.")
+    parser.add_argument("--batch-size", type=int, default=2, help="Feeders analysed in parallel.")
+    parser.add_argument("--period-start", default="2025-01-01", help="Historic start date.")
+    parser.add_argument("--period-end", default="2025-12-31", help="Historic end date.")
+    parser.add_argument("--name", default="Zone Substation Analytics Demo", help="Study name.")
+    parser.add_argument("--dry-run", action="store_true", help="Generate outputs but do not upload.")
+    return parser.parse_args(argv)
+
+
+def _load_config(path: str) -> Dict:
+    with open(path, "r") as f:
+        return json.loads(f.read())
+
+
+def _load_styles() -> List[Dict]:
+    with open(STYLE_PATH, "r") as f:
+        return json.loads(f.read())
+
+
+def _connect_rpc(config: Dict):
+    return connect_with_token(
+        host=config["host"],
+        access_token=config["access_token"],
+        rpc_port=config["rpc_port"],
+        ca_filename=config.get("ca_filename"),
+        timeout_seconds=config.get("timeout_seconds", 5),
+        debug=bool(config.get("debug", False)),
+        skip_connection_test=bool(config.get("skip_connection_test", False)),
+    )
+
+
+def _chunk(items: Sequence, size: int) -> Iterable[Sequence]:
+    safe = max(size, 1)
+    for i in range(0, len(items), safe):
+        yield items[i : i + safe]
+
+
+def _clamp(value: float, low: float, high: float) -> float:
+    return max(low, min(value, high))
+
+
+def _rng(seed: int, *parts: str) -> random.Random:
+    return random.Random(":".join([str(seed), *parts]))
+
+
+@dataclass(frozen=True)
+class Normaliser:
+    min_value: float
+    max_value: float
+
+    def scale(self, value: float, default: float = 0.5) -> float:
+        spread = self.max_value - self.min_value
+        if spread <= 1e-9:
+            return default
+        return _clamp((value - self.min_value) / spread, 0.0, 1.0)
+
+
+def _normaliser(values: Iterable[float]) -> Normaliser:
+    vals = list(values)
+    if not vals:
+        return Normaliser(0.0, 1.0)
+    return Normaliser(min(vals), max(vals))
+
+
+async def _collect_feeders(config: Dict, zone_codes: Sequence[str]) -> List[FeederRef]:
+    rpc_channel = _connect_rpc(config)
+    client = NetworkConsumerClient(rpc_channel)
+    hierarchy = (await client.get_network_hierarchy()).throw_on_error()
+    substations = hierarchy.value.substations
+
+    feeder_refs: List[FeederRef] = []
+    missing: List[str] = []
+    for zone in zone_codes:
+        zone_data = substations.get(zone)
+        if zone_data is None:
+            missing.append(zone)
+            continue
+        for feeder in zone_data.feeders:
+            feeder_refs.append(
+                FeederRef(
+                    zone_code=zone,
+                    feeder_mrid=feeder.mrid,
+                    feeder_name=(getattr(feeder, "name", None) or feeder.mrid),
+                )
+            )
+
+    if missing:
+        available = ", ".join(sorted(substations.keys()))
+        raise ValueError(f"Unknown zone code(s): {', '.join(missing)}. Available zones include: {available}")
+
+    return feeder_refs
+
+
+def _point_from_location(location) -> Optional[Tuple[float, float]]:
+    points = list(location.points) if location is not None else []
+    if not points:
+        return None
+    if len(points) == 1:
+        return points[0].x_position, points[0].y_position
+    x = sum(p.x_position for p in points) / len(points)
+    y = sum(p.y_position for p in points) / len(points)
+    return x, y
+
+
+def _line_coords(location) -> List[Tuple[float, float]]:
+    points = list(location.points) if location is not None else []
+    if len(points) < 2:
+        return []
+    return [(p.x_position, p.y_position) for p in points]
+
+
+def _distance_km(lon1: float, lat1: float, lon2: float, lat2: float) -> float:
+    r = 6371.0
+    d_lat = math.radians(lat2 - lat1)
+    d_lon = math.radians(lon2 - lon1)
+    a = (
+        math.sin(d_lat / 2) ** 2
+        + math.cos(math.radians(lat1))
+        * math.cos(math.radians(lat2))
+        * math.sin(d_lon / 2) ** 2
+    )
+    return 2 * r * math.asin(min(1.0, math.sqrt(a)))
+
+
+def _location_length_km(location) -> float:
+    points = list(location.points) if location is not None else []
+    if len(points) < 2:
+        return 0.0
+    length = 0.0
+    for i in range(1, len(points)):
+        p1 = points[i - 1]
+        p2 = points[i]
+        length += _distance_km(p1.x_position, p1.y_position, p2.x_position, p2.y_position)
+    return length
+
+
+def _line_length_km(line: AcLineSegment) -> float:
+    if line.length is not None and line.length > 0:
+        return line.length / 1000.0
+    return _location_length_km(getattr(line, "location", None))
+
+
+def _line_impedance_ohm_per_km(line: AcLineSegment) -> float:
+    for attr in ("per_length_sequence_impedance", "per_length_phase_impedance", "per_length_impedance"):
+        imp = getattr(line, attr, None)
+        if imp is None:
+            continue
+        r = getattr(imp, "r", None)
+        x = getattr(imp, "x", None)
+        if r is None and x is None:
+            continue
+        return math.hypot(float(r or 0.0), float(x or 0.0)) * 1000.0
+    return 0.0
+
+
+def _line_base_kv(line: AcLineSegment) -> float:
+    base_value = getattr(line, "base_voltage_value", None)
+    if base_value is not None and base_value > 0:
+        return float(base_value) / 1000.0
+    base = getattr(line, "base_voltage", None)
+    nominal = getattr(base, "nominal_voltage", None) if base is not None else None
+    if nominal is not None and nominal > 0:
+        return float(nominal) / 1000.0
+    return 11.0
+
+
+def _is_mv_line(line: AcLineSegment) -> bool:
+    return _line_base_kv(line) > 1.0
+
+
+def _transformer_rating_kva(pt: PowerTransformer) -> float:
+    ratings: List[float] = []
+    for end in pt.ends:
+        if end.rated_s is not None:
+            ratings.append(float(end.rated_s) / 1000.0)
+        else:
+            for rating in end.s_ratings:
+                if rating and rating.rated_s is not None:
+                    ratings.append(float(rating.rated_s) / 1000.0)
+    return max(ratings) if ratings else 315.0
+
+
+def _pec_has_pv_unit(pec: PowerElectronicsConnection) -> bool:
+    return any(isinstance(unit, PhotoVoltaicUnit) for unit in pec.units)
+
+
+def _pec_capacity_kva(pec: PowerElectronicsConnection) -> float:
+    if pec.rated_s is not None and pec.rated_s > 0:
+        return float(pec.rated_s) / 1000.0
+    unit_capacity = sum(float(unit.max_p or 0.0) for unit in pec.units)
+    return (unit_capacity / 1000.0) if unit_capacity > 0 else 0.0
+
+
+def _phase_class(ec: EnergyConsumer) -> str:
+    def classify(phase_obj) -> Optional[str]:
+        if phase_obj is None:
+            return None
+
+        candidates: List[str] = [str(phase_obj).upper()]
+        try:
+            as_code = phase_obj.as_phase_code() if hasattr(phase_obj, "as_phase_code") else None
+            if as_code is not None:
+                candidates.append(str(as_code).upper())
+        except Exception:
+            pass
+
+        for text in candidates:
+            token = text.split(".")[-1]
+            phase_token = "".join(ch for ch in token if ch in {"A", "B", "C", "N"})
+            letters = {ch for ch in phase_token if ch in {"A", "B", "C"}}
+            has_n = "N" in phase_token
+            if letters == {"A"} and has_n:
+                return "A"
+            if letters == {"B"} and has_n:
+                return "B"
+            if letters == {"C"} and has_n:
+                return "C"
+            if letters == {"A"}:
+                return "A"
+            if letters == {"B"}:
+                return "B"
+            if letters == {"C"}:
+                return "C"
+            if len(letters) >= 2:
+                return "OTHER"
+        return None
+
+    for terminal in ec.terminals:
+        # Prefer static terminal phase code over dynamic NormalPhases state.
+        phase = classify(getattr(terminal, "phases", None))
+        if phase is not None:
+            return phase
+        phase = classify(getattr(terminal, "normal_phases", None))
+        if phase is not None:
+            return phase
+    return "OTHER"
+
+
+def _sample_nominal_tap(rng: random.Random) -> int:
+    # Keep most transformers near nominal tap 4 with 90% between 3 and 7.
+    r = rng.random()
+    if r < 0.66:
+        return 4
+    if r < 0.80:
+        return 3
+    if r < 0.92:
+        return 5
+    if r < 0.96:
+        return 6
+    if r < 0.985:
+        return 7
+    if r < 0.995:
+        return 2
+    return 1
+
+
+def _collect_eq_provider(collection: Set[ConductingEquipment]):
+    async def collect(ps: NetworkTraceStep, _):
+        to_eq = ps.path.to_equipment
+        if to_eq is not None:
+            collection.add(to_eq)
+
+    return collect
+
+
+async def _get_downstream_equipment(start: ConductingEquipment) -> Set[ConductingEquipment]:
+    equipment_set: Set[ConductingEquipment] = set()
+    await (
+        Tracing.network_trace()
+        .add_condition(downstream())
+        .add_step_action(_collect_eq_provider(equipment_set))
+    ).run(start=start, phases=PhaseCode.ABCN, can_stop_on_start_item=False)
+    return equipment_set
+
+
+def _collect_line_provider(lines: Set[AcLineSegment]):
+    async def collect(ps: NetworkTraceStep, _):
+        traversed = ps.path.traversed_ac_line_segment
+        if isinstance(traversed, AcLineSegment):
+            lines.add(traversed)
+        if isinstance(ps.path.to_equipment, AcLineSegment):
+            lines.add(ps.path.to_equipment)
+        if isinstance(ps.path.from_equipment, AcLineSegment):
+            lines.add(ps.path.from_equipment)
+
+    return collect
+
+
+async def _get_upstream_lines(start: ConductingEquipment) -> Set[AcLineSegment]:
+    lines: Set[AcLineSegment] = set()
+    await (
+        Tracing.network_trace()
+        .add_condition(upstream())
+        .add_condition(stop_at_open())
+        .add_step_action(_collect_line_provider(lines))
+    ).run(start=start, phases=PhaseCode.ABCN, can_stop_on_start_item=False)
+    return lines
+
+
+def _find_pv_energy_consumers(network) -> Set[str]:
+    pv_usage_points: Set[str] = set()
+    pv_nodes: Set[str] = set()
+
+    for pv in network.objects(PhotoVoltaicUnit):
+        for up in pv.usage_points:
+            pv_usage_points.add(up.mrid)
+        if pv.power_electronics_connection:
+            for up in pv.power_electronics_connection.usage_points:
+                pv_usage_points.add(up.mrid)
+
+    for pec in network.objects(PowerElectronicsConnection):
+        if not _pec_has_pv_unit(pec):
+            continue
+        for up in pec.usage_points:
+            pv_usage_points.add(up.mrid)
+        for terminal in pec.terminals:
+            if terminal.connectivity_node:
+                pv_nodes.add(terminal.connectivity_node.mrid)
+
+    pv_consumers: Set[str] = set()
+    for ec in network.objects(EnergyConsumer):
+        if any(up.mrid in pv_usage_points for up in ec.usage_points):
+            pv_consumers.add(ec.mrid)
+            continue
+        if pv_nodes and any(t.connectivity_node and t.connectivity_node.mrid in pv_nodes for t in ec.terminals):
+            pv_consumers.add(ec.mrid)
+
+    return pv_consumers
+
+
+async def _analyse_feeder(ref: FeederRef, config: Dict, seed: int) -> Optional[FeederAnalytics]:
+    print(f"Fetching feeder {ref.feeder_name} ({ref.feeder_mrid})")
+    rpc_channel = _connect_rpc(config)
+    client = NetworkConsumerClient(rpc_channel)
+    result = await client.get_equipment_container(
+        mrid=ref.feeder_mrid,
+        expected_class=Feeder,
+        include_energized_containers=IncludedEnergizedContainers.LV_FEEDERS,
+    )
+    if result.was_failure:
+        print(f"Failed feeder {ref.feeder_mrid}: {result.thrown}")
+        return None
+
+    network = client.service
+    await Tracing.set_direction().run(network, network_state_operators=NetworkStateOperators.NORMAL)
+
+    pv_consumers = _find_pv_energy_consumers(network)
+
+    ec_objects = list(network.objects(EnergyConsumer))
+    ec_locations: Dict[str, Tuple[EnergyConsumer, Tuple[float, float]]] = {}
+    for ec in ec_objects:
+        point = _point_from_location(ec.location)
+        if point is not None:
+            ec_locations[ec.mrid] = (ec, point)
+
+    transformers: List[TransformerAnalytics] = []
+    tx_by_id: Dict[str, TransformerAnalytics] = {}
+    ec_to_tx: Dict[str, str] = {}
+
+    line_down_ec: Dict[str, int] = {}
+    line_down_pv: Dict[str, int] = {}
+
+    tx_objects = list(network.objects(PowerTransformer))
+    print(f"Tracing {len(tx_objects)} transformers for feeder {ref.feeder_name}")
+
+    for pt in tx_objects:
+        downstream_eq = await _get_downstream_equipment(pt)
+        downstream_ecs = [eq for eq in downstream_eq if isinstance(eq, EnergyConsumer)]
+        downstream_lines = [eq for eq in downstream_eq if isinstance(eq, AcLineSegment)]
+        downstream_pecs = [eq for eq in downstream_eq if isinstance(eq, PowerElectronicsConnection)]
+
+        ec_count = len(downstream_ecs)
+        pv_ec_count = sum(1 for ec in downstream_ecs if ec.mrid in pv_consumers)
+
+        pv_pecs = [pec for pec in downstream_pecs if _pec_has_pv_unit(pec)]
+        pv_capacity_kva = sum(_pec_capacity_kva(pec) for pec in pv_pecs)
+        pec_capacity_kva = sum(_pec_capacity_kva(pec) for pec in downstream_pecs)
+
+        line_km = 0.0
+        weighted_impedance = 0.0
+        for line in downstream_lines:
+            length_km = _line_length_km(line)
+            z = _line_impedance_ohm_per_km(line)
+            line_km += length_km
+            if z > 0 and length_km > 0:
+                weighted_impedance += z * length_km
+
+        mean_z = weighted_impedance / max(line_km, 0.001) if weighted_impedance > 0 else 0.35
+        impedance_proxy = mean_z * (line_km / max(ec_count, 1))
+
+        rating_kva = _transformer_rating_kva(pt)
+        est_peak_kw = ec_count * ADMD_KW_PER_CUSTOMER
+        est_reverse_kw = pv_ec_count * ADMG_KW_PER_CUSTOMER
+        load_util_pct = _clamp((est_peak_kw / max(rating_kva, 1.0)) * 100.0, 0.0, 240.0)
+        generation_util_pct = _clamp((est_reverse_kw / max(rating_kva, 1.0)) * 100.0, 0.0, 240.0)
+
+        point = _point_from_location(pt.location)
+        tx = TransformerAnalytics(
+            mrid=pt.mrid,
+            name=pt.name or pt.mrid,
+            feeder_mrid=ref.feeder_mrid,
+            feeder_name=ref.feeder_name,
+            zone_code=ref.zone_code,
+            lon=(point[0] if point is not None else None),
+            lat=(point[1] if point is not None else None),
+            ec_count=ec_count,
+            pv_ec_count=pv_ec_count,
+            pv_capacity_kva=pv_capacity_kva,
+            pec_count=len(downstream_pecs),
+            pec_capacity_kva=pec_capacity_kva,
+            rating_kva=rating_kva,
+            line_km=line_km,
+            mean_z_ohm_per_km=mean_z,
+            impedance_proxy=impedance_proxy,
+            load_util_pct=load_util_pct,
+            generation_util_pct=generation_util_pct,
+            headroom_kw=rating_kva - est_peak_kw,
+        )
+
+        upstream_lines = await _get_upstream_lines(pt)
+        mv_upstream_lines = [line for line in upstream_lines if _is_mv_line(line)]
+        mv_line_ids = {line.mrid for line in mv_upstream_lines}
+        tx.upstream_mv_line_ids = mv_line_ids
+        tx.path_mv_impedance_ohm = sum(
+            max(_line_impedance_ohm_per_km(line), 0.35) * max(_line_length_km(line), 0.01)
+            for line in mv_upstream_lines
+        )
+
+        for line_id in mv_line_ids:
+            line_down_ec[line_id] = line_down_ec.get(line_id, 0) + ec_count
+            line_down_pv[line_id] = line_down_pv.get(line_id, 0) + pv_ec_count
+
+        for ec in downstream_ecs:
+            if ec.mrid in ec_locations and ec.mrid not in ec_to_tx:
+                ec_to_tx[ec.mrid] = pt.mrid
+
+        transformers.append(tx)
+        tx_by_id[tx.mrid] = tx
+
+    mv_lines: List[MvLineAnalytics] = []
+    line_drop_map: Dict[str, float] = {}
+    for line in network.objects(AcLineSegment):
+        if not _is_mv_line(line):
+            continue
+        coords = _line_coords(line.location)
+        if len(coords) < 2:
+            continue
+
+        length_km = max(_line_length_km(line), 0.01)
+        z_ohm_per_km = _line_impedance_ohm_per_km(line)
+        if z_ohm_per_km <= 0:
+            z_ohm_per_km = 0.35
+
+        down_ec = line_down_ec.get(line.mrid, 0)
+        down_pv = line_down_pv.get(line.mrid, 0)
+
+        net_kw = down_ec * ADMD_KW_PER_CUSTOMER - down_pv * ADMG_KW_PER_CUSTOMER
+        base_kv = max(_line_base_kv(line), 1.0)
+        current_a = abs(net_kw) / (math.sqrt(3.0) * base_kv)
+        total_line_ohm = z_ohm_per_km * length_km
+        voltage_change_v = current_a * total_line_ohm
+        voltage_change_pct = (voltage_change_v / (base_kv * 1000.0)) * 100.0
+        signed_change_pct = voltage_change_pct if net_kw >= 0 else -voltage_change_pct
+        est_end_v_pct = 100.0 - signed_change_pct
+
+        if est_end_v_pct < 99.0:
+            tap_zone = "Raise"
+        elif est_end_v_pct > 101.0:
+            tap_zone = "Lower"
+        else:
+            tap_zone = "Hold"
+
+        line_drop_map[line.mrid] = signed_change_pct
+        mv_lines.append(
+            MvLineAnalytics(
+                mrid=line.mrid,
+                name=line.name or line.mrid,
+                feeder_mrid=ref.feeder_mrid,
+                feeder_name=ref.feeder_name,
+                zone_code=ref.zone_code,
+                coordinates=coords,
+                length_km=length_km,
+                z_ohm_per_km=z_ohm_per_km,
+                base_kv=base_kv,
+                downstream_ec_count=down_ec,
+                downstream_pv_count=down_pv,
+                net_kw=net_kw,
+                signed_voltage_change_pct=signed_change_pct,
+                estimated_end_voltage_pct=est_end_v_pct,
+                tap_zone=tap_zone,
+            )
+        )
+
+    for tx in transformers:
+        path_change = sum(line_drop_map.get(line_id, 0.0) for line_id in tx.upstream_mv_line_ids)
+        tx.estimated_mv_voltage_pct = 100.0 - path_change
+
+    path_norm = _normaliser(tx.path_mv_impedance_ohm for tx in transformers)
+    dev_norm = _normaliser(abs(tx.estimated_mv_voltage_pct - 100.0) for tx in transformers)
+    load_norm = _normaliser(tx.load_util_pct for tx in transformers)
+
+    for tx in transformers:
+        tap_rng = _rng(seed, "tap", tx.mrid)
+        tx.tap_from = _sample_nominal_tap(tap_rng)
+
+        change_score = (
+            0.62 * path_norm.scale(tx.path_mv_impedance_ohm)
+            + 0.23 * dev_norm.scale(abs(tx.estimated_mv_voltage_pct - 100.0))
+            + 0.15 * load_norm.scale(tx.load_util_pct)
+            + tap_rng.uniform(-0.08, 0.08)
+        )
+
+        should_consider_change = (
+            change_score > 0.72
+            and (
+                abs(tx.estimated_mv_voltage_pct - 100.0) > 0.22
+                or path_norm.scale(tx.path_mv_impedance_ohm) > 0.82
+            )
+        )
+
+        if should_consider_change:
+            if tx.estimated_mv_voltage_pct < 99.2:
+                tx.tap_to = int(_clamp(tx.tap_from + 1, 1, 7))
+                tx.tap_action = "Raise"
+            elif tx.estimated_mv_voltage_pct > 100.9:
+                tx.tap_to = int(_clamp(tx.tap_from - 1, 1, 7))
+                tx.tap_action = "Lower"
+            elif tx.generation_util_pct > tx.load_util_pct:
+                tx.tap_to = int(_clamp(tx.tap_from - 1, 1, 7))
+                tx.tap_action = "Lower"
+            else:
+                tx.tap_to = int(_clamp(tx.tap_from + 1, 1, 7))
+                tx.tap_action = "Raise"
+        else:
+            tx.tap_to = tx.tap_from
+            tx.tap_action = "Hold"
+
+        tx.tap_change_required = tx.tap_to != tx.tap_from
+
+        pec_pct = tx.pec_penetration_pct_of_rating
+        tx.curtailment_kwh = max(0.0, (pec_pct - 28.0)) * (16.0 + tx.pv_ec_count * 1.4)
+
+    if not transformers:
+        print(f"Skipping feeder {ref.feeder_mrid}: no transformers found")
+        return None
+
+    mean_tx_impedance = sum(t.impedance_proxy for t in transformers) / len(transformers)
+    mean_load_util = sum(t.load_util_pct for t in transformers) / len(transformers)
+    mean_gen_util = sum(t.generation_util_pct for t in transformers) / len(transformers)
+    mean_tx_voltage = sum(t.estimated_mv_voltage_pct for t in transformers) / len(transformers)
+
+    customers: List[CustomerAnalytics] = []
+    for ec_mrid, (ec, point) in ec_locations.items():
+        tx_id = ec_to_tx.get(ec_mrid)
+        tx = tx_by_id.get(tx_id) if tx_id else None
+        customers.append(
+            CustomerAnalytics(
+                mrid=ec_mrid,
+                feeder_mrid=ref.feeder_mrid,
+                feeder_name=ref.feeder_name,
+                zone_code=ref.zone_code,
+                lon=point[0],
+                lat=point[1],
+                phase_class=_phase_class(ec),
+                has_pv=(ec_mrid in pv_consumers),
+                transformer_mrid=(tx.mrid if tx is not None else "unknown"),
+                tx_impedance_proxy=(tx.impedance_proxy if tx is not None else mean_tx_impedance),
+                tx_load_util_pct=(tx.load_util_pct if tx is not None else mean_load_util),
+                tx_generation_util_pct=(tx.generation_util_pct if tx is not None else mean_gen_util),
+                tx_est_voltage_pct=(tx.estimated_mv_voltage_pct if tx is not None else mean_tx_voltage),
+                tx_pv_penetration_pct=(tx.pv_penetration_pct_of_rating if tx is not None else 0.0),
+                tx_pec_penetration_pct=(tx.pec_penetration_pct_of_rating if tx is not None else 0.0),
+            )
+        )
+
+    if not customers:
+        print(f"Skipping feeder {ref.feeder_mrid}: no mappable customers")
+        return None
+
+    return FeederAnalytics(
+        ref=ref,
+        customers=customers,
+        transformers=transformers,
+        mv_lines=mv_lines,
+    )
+
+
+def _build_uc6_neutral_faults(feeders: Sequence[FeederAnalytics], seed: int, period_start: str, period_end: str) -> FeatureCollection:
+    features: List[Feature] = []
+    for feeder in feeders:
+        customers = feeder.customers
+        if not customers:
+            continue
+
+        imp_norm = _normaliser(c.tx_impedance_proxy for c in customers)
+        volt_norm = _normaliser(abs(c.tx_est_voltage_pct - 100.0) for c in customers)
+        load_norm = _normaliser(c.tx_load_util_pct for c in customers)
+
+        ranked: List[Tuple[float, CustomerAnalytics]] = []
+        for c in customers:
+            rng = _rng(seed, "uc6", feeder.ref.feeder_mrid, c.mrid)
+            risk = (
+                0.50 * imp_norm.scale(c.tx_impedance_proxy)
+                + 0.30 * volt_norm.scale(abs(c.tx_est_voltage_pct - 100.0))
+                + 0.17 * load_norm.scale(c.tx_load_util_pct)
+                + 0.03 * (1.0 if c.has_pv else 0.0)
+                + rng.uniform(-0.05, 0.06)
+            )
+            ranked.append((risk, c))
+
+        ranked.sort(key=lambda x: x[0], reverse=True)
+        if len(customers) <= 2:
+            target_count = len(customers)
+        else:
+            base_count = 2 + int(round(len(customers) / 350.0))
+            target_count = int(_clamp(base_count, 2, 5))
+            target_count = min(target_count, len(customers))
+
+        min_sep_km = 0.25 if len(customers) < 180 else 0.35
+        selected: List[Tuple[float, CustomerAnalytics]] = []
+        selected_ids: Set[str] = set()
+
+        for risk, c in ranked:
+            if all(_distance_km(c.lon, c.lat, s.lon, s.lat) >= min_sep_km for _, s in selected):
+                selected.append((risk, c))
+                selected_ids.add(c.mrid)
+                if len(selected) >= target_count:
+                    break
+
+        if len(selected) < target_count:
+            for risk, c in ranked:
+                if c.mrid in selected_ids:
+                    continue
+                selected.append((risk, c))
+                selected_ids.add(c.mrid)
+                if len(selected) >= target_count:
+                    break
+
+        for risk, c in selected:
+            rng = _rng(seed, "uc6-detected", feeder.ref.feeder_mrid, c.mrid)
+            fault_events = int(round(_clamp(1 + risk * 4 + rng.uniform(0, 1.0), 1, 6)))
+            confidence = round(_clamp(62 + risk * 32 + rng.uniform(-3, 3), 55, 98), 1)
+            loop_calc = round(max(0.05, c.tx_impedance_proxy * (0.78 + 0.48 * risk)), 3)
+            loop_gis = round(loop_calc * (0.92 + rng.uniform(-0.05, 0.16)), 3)
+            non_compliance_days = int(round(_clamp(2 + risk * 34 + rng.uniform(0, 6), 1, 65)))
+
+            features.append(
+                Feature(
+                    id=f"uc6-{c.mrid}",
+                    geometry=Point((c.lon, c.lat)),
+                    properties={
+                        "use_case": 6,
+                        "feature_kind": "neutral_customer",
+                        "zone_code": c.zone_code,
+                        "feeder_mrid": c.feeder_mrid,
+                        "feeder_name": c.feeder_name,
+                        "customer_mrid": c.mrid,
+                        "fault_events": fault_events,
+                        "fault_label": f"{fault_events}",
+                        "confidence_pct": confidence,
+                        "loop_impedance_calc_ohm": loop_calc,
+                        "loop_impedance_gis_ohm": loop_gis,
+                        "non_compliance_days": non_compliance_days,
+                        "period_start": period_start,
+                        "period_end": period_end,
+                        "dashboard_key": f"neutral-integrity::{c.zone_code}::{c.feeder_mrid}::{c.mrid}",
+                    },
+                )
+            )
+
+    return FeatureCollection(features)
+
+
+def _build_uc7_voltage_reporting(feeders: Sequence[FeederAnalytics], seed: int, period_start: str, period_end: str) -> FeatureCollection:
+    all_customers = [c for feeder in feeders for c in feeder.customers]
+    imp_norm = _normaliser(c.tx_impedance_proxy for c in all_customers)
+    volt_norm = _normaliser(abs(c.tx_est_voltage_pct - 100.0) for c in all_customers)
+
+    features: List[Feature] = []
+    for c in all_customers:
+        rng = _rng(seed, "uc7", c.mrid)
+        voltage_dev = abs(c.tx_est_voltage_pct - 100.0)
+        heat = _clamp(
+            0.08
+            + 0.62 * volt_norm.scale(voltage_dev)
+            + 0.23 * imp_norm.scale(c.tx_impedance_proxy)
+            + 0.07 * (1.0 if c.has_pv else 0.0)
+            + rng.uniform(-0.04, 0.06),
+            0.02,
+            1.0,
+        )
+        severe = 1 if heat >= 0.72 else 0
+
+        features.append(
+            Feature(
+                id=f"uc7-{c.mrid}",
+                geometry=Point((c.lon, c.lat)),
+                properties={
+                    "use_case": 7,
+                    "feature_kind": "voltage_customer",
+                    "zone_code": c.zone_code,
+                    "feeder_mrid": c.feeder_mrid,
+                    "feeder_name": c.feeder_name,
+                    "customer_mrid": c.mrid,
+                    "voltage_heat": round(heat, 3),
+                    "voltage_heat_weight": round(heat, 3),
+                    "voltage_dev_pct": round(voltage_dev, 3),
+                    "tx_est_voltage_pct": round(c.tx_est_voltage_pct, 3),
+                    "severe": severe,
+                    "period_start": period_start,
+                    "period_end": period_end,
+                    "dashboard_key": f"voltage-monitoring::{c.zone_code}::{c.feeder_mrid}::{c.mrid}",
+                },
+            )
+        )
+
+    return FeatureCollection(features)
+
+
+def _build_uc8_dynamic_voltage_control(feeders: Sequence[FeederAnalytics], period_start: str, period_end: str) -> FeatureCollection:
+    features: List[Feature] = []
+
+    for feeder in feeders:
+        for line in feeder.mv_lines:
+            features.append(
+                Feature(
+                    id=f"uc8-line-{line.mrid}",
+                    geometry=LineString(line.coordinates),
+                    properties={
+                        "use_case": 8,
+                        "feature_kind": "dvc_mv_line",
+                        "zone_code": line.zone_code,
+                        "feeder_mrid": line.feeder_mrid,
+                        "feeder_name": line.feeder_name,
+                        "line_mrid": line.mrid,
+                        "line_name": line.name,
+                        "base_kv": round(line.base_kv, 3),
+                        "length_km": round(line.length_km, 3),
+                        "z_ohm_per_km": round(line.z_ohm_per_km, 3),
+                        "admd_kw": round(line.downstream_ec_count * ADMD_KW_PER_CUSTOMER, 3),
+                        "admg_kw": round(line.downstream_pv_count * ADMG_KW_PER_CUSTOMER, 3),
+                        "net_kw": round(line.net_kw, 3),
+                        "signed_voltage_change_pct": round(line.signed_voltage_change_pct, 4),
+                        "estimated_end_voltage_pct": round(line.estimated_end_voltage_pct, 4),
+                        "tap_zone": line.tap_zone,
+                        "period_start": period_start,
+                        "period_end": period_end,
+                        "dashboard_key": f"dynamic-voltage-control::{line.zone_code}::{line.feeder_mrid}::{line.mrid}",
+                    },
+                )
+            )
+
+        for tx in feeder.transformers:
+            if tx.lon is None or tx.lat is None or not tx.tap_change_required:
+                continue
+            features.append(
+                Feature(
+                    id=f"uc8-tx-{tx.mrid}",
+                    geometry=Point((tx.lon, tx.lat)),
+                    properties={
+                        "use_case": 8,
+                        "feature_kind": "dvc_tap_transformer",
+                        "zone_code": tx.zone_code,
+                        "feeder_mrid": tx.feeder_mrid,
+                        "feeder_name": tx.feeder_name,
+                        "transformer_mrid": tx.mrid,
+                        "transformer_name": tx.name,
+                        "estimated_mv_voltage_pct": round(tx.estimated_mv_voltage_pct, 4),
+                        "tap_from": tx.tap_from,
+                        "tap_to": tx.tap_to,
+                        "tap_move": f"{tx.tap_from}->{tx.tap_to}",
+                        "tap_action": tx.tap_action,
+                        "period_start": period_start,
+                        "period_end": period_end,
+                        "dashboard_key": f"dynamic-voltage-control::{tx.zone_code}::{tx.feeder_mrid}::{tx.mrid}",
+                    },
+                )
+            )
+
+    return FeatureCollection(features)
+
+
+def _build_uc9_phase_identification(feeders: Sequence[FeederAnalytics], period_start: str, period_end: str) -> FeatureCollection:
+    features: List[Feature] = []
+    for feeder in feeders:
+        for c in feeder.customers:
+            features.append(
+                Feature(
+                    id=f"uc9-{c.mrid}",
+                    geometry=Point((c.lon, c.lat)),
+                    properties={
+                        "use_case": 9,
+                        "feature_kind": "phase_customer",
+                        "zone_code": c.zone_code,
+                        "feeder_mrid": c.feeder_mrid,
+                        "feeder_name": c.feeder_name,
+                        "customer_mrid": c.mrid,
+                        "phase_class": c.phase_class,
+                        "period_start": period_start,
+                        "period_end": period_end,
+                        "dashboard_key": f"phase-identification::{c.zone_code}::{c.feeder_mrid}::{c.mrid}",
+                    },
+                )
+            )
+    return FeatureCollection(features)
+
+
+def _build_uc13_cer_compliance(feeders: Sequence[FeederAnalytics], seed: int, period_start: str, period_end: str) -> FeatureCollection:
+    all_customers = [c for feeder in feeders for c in feeder.customers]
+    imp_norm = _normaliser(c.tx_impedance_proxy for c in all_customers)
+
+    features: List[Feature] = []
+    for c in all_customers:
+        if not c.has_pv:
+            continue
+
+        rng = _rng(seed, "uc13", c.mrid)
+        voltage_risk = _clamp(abs(c.tx_est_voltage_pct - 100.0) / 2.5, 0.0, 1.0)
+        gen_risk = _clamp(c.tx_generation_util_pct / 130.0, 0.0, 1.0)
+        impedance_risk = imp_norm.scale(c.tx_impedance_proxy)
+        risk = _clamp(0.45 * voltage_risk + 0.35 * gen_risk + 0.20 * impedance_risk + rng.uniform(-0.08, 0.08), 0.0, 1.0)
+
+        if risk >= 0.72:
+            tier = "Non-Compliant"
+            issue = "Over-export risk"
+        elif risk >= 0.42:
+            tier = "At Risk"
+            issue = "Potential Volt/Watt concern"
+        else:
+            tier = "Compliant"
+            issue = "No active issue"
+
+        unresolved_days = int(round(_clamp(risk * 90 + rng.uniform(0, 12), 0, 120)))
+
+        features.append(
+            Feature(
+                id=f"uc13-{c.mrid}",
+                geometry=Point((c.lon, c.lat)),
+                properties={
+                    "use_case": 13,
+                    "feature_kind": "cer_compliance_customer",
+                    "zone_code": c.zone_code,
+                    "feeder_mrid": c.feeder_mrid,
+                    "feeder_name": c.feeder_name,
+                    "customer_mrid": c.mrid,
+                    "compliance_tier": tier,
+                    "compliance_issue": issue,
+                    "unresolved_days": unresolved_days,
+                    "risk_score": round(risk * 100.0, 1),
+                    "period_start": period_start,
+                    "period_end": period_end,
+                    "dashboard_key": f"cer-compliance::{c.zone_code}::{c.feeder_mrid}::{c.mrid}",
+                },
+            )
+        )
+
+    return FeatureCollection(features)
+
+
+def _build_uc14_cer_performance(feeders: Sequence[FeederAnalytics], seed: int, period_start: str, period_end: str) -> FeatureCollection:
+    features: List[Feature] = []
+
+    for feeder in feeders:
+        for tx in feeder.transformers:
+            if tx.lon is None or tx.lat is None:
+                continue
+
+            rng = _rng(seed, "uc14", tx.mrid)
+            pec_pct = tx.pec_penetration_pct_of_rating
+            curtailment_kwh = max(0.0, tx.curtailment_kwh * (0.9 + rng.uniform(-0.05, 0.18)))
+            value_aud = curtailment_kwh * (0.08 + rng.uniform(-0.01, 0.04))
+
+            features.append(
+                Feature(
+                    id=f"uc14-{tx.mrid}",
+                    geometry=Point((tx.lon, tx.lat)),
+                    properties={
+                        "use_case": 14,
+                        "feature_kind": "cer_performance_transformer",
+                        "zone_code": tx.zone_code,
+                        "feeder_mrid": tx.feeder_mrid,
+                        "feeder_name": tx.feeder_name,
+                        "transformer_mrid": tx.mrid,
+                        "transformer_name": tx.name,
+                        "pec_percent_rating": round(pec_pct, 2),
+                        "curtailed_kwh": round(curtailment_kwh, 2),
+                        "curtailment_value_aud": round(value_aud, 2),
+                        "curtailment_label": f"{int(round(curtailment_kwh))}kWh",
+                        "period_start": period_start,
+                        "period_end": period_end,
+                        "dashboard_key": f"cer-performance::{tx.zone_code}::{tx.feeder_mrid}::{tx.mrid}",
+                    },
+                )
+            )
+
+    return FeatureCollection(features)
+
+
+def _build_uc15_ev_detection(feeders: Sequence[FeederAnalytics], seed: int, period_start: str, period_end: str) -> FeatureCollection:
+    features: List[Feature] = []
+
+    for feeder in feeders:
+        customers = feeder.customers
+        if not customers:
+            continue
+
+        feeder_rng = _rng(seed, "uc15-feeder", feeder.ref.feeder_mrid)
+        # Keep average EV detection no more than 1-in-8 per feeder.
+        target_ratio = _clamp(0.09 + feeder_rng.uniform(-0.015, 0.02), 0.07, 0.125)
+        target_count = int(round(len(customers) * target_ratio))
+        if target_count <= 0 and len(customers) >= 32:
+            target_count = 1
+
+        pocket_count = min(4, max(1, int(round(math.sqrt(len(customers)) / 40.0)) + 1))
+        pocket_centres = feeder_rng.sample(customers, min(pocket_count, len(customers)))
+
+        ranked: List[Tuple[float, CustomerAnalytics]] = []
+        for c in customers:
+            random_component = feeder_rng.random()
+            pocket_boost = 0.0
+            for centre in pocket_centres:
+                d_km = _distance_km(c.lon, c.lat, centre.lon, centre.lat)
+                pocket_boost = max(pocket_boost, math.exp(-(d_km * d_km) / 0.06))
+
+            score = 0.52 * random_component + 0.48 * pocket_boost + feeder_rng.uniform(-0.06, 0.08)
+            ranked.append((score, c))
+
+        ranked.sort(key=lambda x: x[0], reverse=True)
+        selected = ranked[:target_count]
+
+        for _, c in selected:
+            rng = _rng(seed, "uc15", c.mrid)
+            charger_type = "L1" if rng.random() < 0.3 else "L2"
+            if charger_type == "L1":
+                peak_kw = round(rng.uniform(2.4, 6.9), 1)
+            else:
+                if rng.random() < 0.22:
+                    peak_kw = round(rng.uniform(11.0, 22.0), 1)
+                else:
+                    peak_kw = round(rng.uniform(7.0, 11.5), 1)
+
+            features.append(
+                Feature(
+                    id=f"uc15-{c.mrid}",
+                    geometry=Point((c.lon, c.lat)),
+                    properties={
+                        "use_case": 15,
+                        "feature_kind": "ev_customer",
+                        "zone_code": c.zone_code,
+                        "feeder_mrid": c.feeder_mrid,
+                        "feeder_name": c.feeder_name,
+                        "customer_mrid": c.mrid,
+                        "ev_detected": True,
+                        "charger_type": charger_type,
+                        "peak_kw": peak_kw,
+                        "ev_label": f"{charger_type} {peak_kw}kW",
+                        "period_start": period_start,
+                        "period_end": period_end,
+                        "dashboard_key": f"ev-detection::{c.zone_code}::{c.feeder_mrid}::{c.mrid}",
+                    },
+                )
+            )
+
+    return FeatureCollection(features)
+
+
+def _build_results(feeders: Sequence[FeederAnalytics], seed: int, period_start: str, period_end: str) -> List[Result]:
+    uc6 = _build_uc6_neutral_faults(feeders, seed, period_start, period_end)
+    uc7 = _build_uc7_voltage_reporting(feeders, seed, period_start, period_end)
+    uc8 = _build_uc8_dynamic_voltage_control(feeders, period_start, period_end)
+    uc9 = _build_uc9_phase_identification(feeders, period_start, period_end)
+    uc13 = _build_uc13_cer_compliance(feeders, seed, period_start, period_end)
+    uc14 = _build_uc14_cer_performance(feeders, seed, period_start, period_end)
+    uc15 = _build_uc15_ev_detection(feeders, seed, period_start, period_end)
+
+    return [
+        Result(
+            name=USE_CASE_NAMES[6],
+            geo_json_overlay=GeoJsonOverlay(data=uc6, styles=["uc6-neutral-customer", "uc6-neutral-label"]),
+        ),
+        Result(
+            name=USE_CASE_NAMES[7],
+            geo_json_overlay=GeoJsonOverlay(data=uc7, styles=["uc7-voltage-heatmap", "uc7-voltage-hotspot"]),
+        ),
+        Result(
+            name=USE_CASE_NAMES[8],
+            geo_json_overlay=GeoJsonOverlay(data=uc8, styles=["uc8-dvc-mv-line", "uc8-dvc-tap-transformer", "uc8-dvc-tap-label"]),
+        ),
+        Result(
+            name=USE_CASE_NAMES[9],
+            geo_json_overlay=GeoJsonOverlay(data=uc9, styles=["uc9-phase-customer"]),
+        ),
+        Result(
+            name=USE_CASE_NAMES[13],
+            geo_json_overlay=GeoJsonOverlay(data=uc13, styles=["uc13-compliance-customer"]),
+        ),
+        Result(
+            name=USE_CASE_NAMES[14],
+            geo_json_overlay=GeoJsonOverlay(data=uc14, styles=["uc14-curtailment-transformer", "uc14-curtailment-label"]),
+        ),
+        Result(
+            name=USE_CASE_NAMES[15],
+            geo_json_overlay=GeoJsonOverlay(data=uc15, styles=["uc15-ev-customer", "uc15-ev-label"]),
+        ),
+    ]
+
+
+def _count_features(results: Sequence[Result]) -> Dict[str, int]:
+    counts: Dict[str, int] = {}
+    for result in results:
+        data = result.geo_json_overlay.data
+        counts[result.name] = len(data.features) if hasattr(data, "features") else 0
+    return counts
+
+
+async def main(argv: Sequence[str]) -> None:
+    args = parse_args(argv)
+    zone_codes = [z.strip() for z in args.zones.split(",") if z.strip()]
+    if not zone_codes:
+        raise ValueError("At least one zone must be provided via --zones")
+
+    config = _load_config(args.config)
+    styles = _load_styles()
+
+    feeder_refs = await _collect_feeders(config, zone_codes)
+    if not feeder_refs:
+        raise ValueError(f"No feeders found in zones: {', '.join(zone_codes)}")
+
+    print(f"Analysing {len(feeder_refs)} feeders from zones: {', '.join(zone_codes)}")
+
+    feeder_analytics: List[FeederAnalytics] = []
+    for batch in _chunk(feeder_refs, args.batch_size):
+        tasks = [asyncio.create_task(_analyse_feeder(ref, config, args.seed)) for ref in batch]
+        for result in await asyncio.gather(*tasks):
+            if result is not None:
+                feeder_analytics.append(result)
+
+    if not feeder_analytics:
+        raise RuntimeError("No feeder analytics generated. Check network data/locations.")
+
+    feeder_analytics.sort(key=lambda f: (f.ref.zone_code, f.ref.feeder_name))
+
+    results = _build_results(
+        feeders=feeder_analytics,
+        seed=args.seed,
+        period_start=args.period_start,
+        period_end=args.period_end,
+    )
+
+    print("Generated demo analytics layers:")
+    for layer_name, count in _count_features(results).items():
+        print(f"  - {layer_name}: {count} feature(s)")
+
+    if args.dry_run:
+        print("Dry-run enabled. Study was not uploaded.")
+        return
+
+    eas_client = EasClient(
+        host=config["host"],
+        port=config["rpc_port"],
+        protocol="https",
+        access_token=config["access_token"],
+    )
+
+    study = Study(
+        name=args.name,
+        description=(
+            "Zone-substation analytics demo generated from live feeder topology with correlated synthetic "
+            "network-performance indicators. DVC assumes ADMD=4kW and ADMG=5kW per customer."
+        ),
+        tags=["analytics_demo", "zone_substations", "regional_overview", "correlated_data"],
+        results=results,
+        styles=styles,
+    )
+
+    print(f"Uploading study for zones: {', '.join(zone_codes)}")
+    response = await eas_client.async_upload_study(study)
+    await eas_client.aclose()
+    print(f"Study upload response: {response}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main(sys.argv[1:]))
diff --git a/src/zepben/examples/studies/analytics_demo_examples/style_mock_zone_analytics.json b/src/zepben/examples/studies/analytics_demo_examples/style_mock_zone_analytics.json
new file mode 100644
index 0000000..d10d5dd
--- /dev/null
+++ b/src/zepben/examples/studies/analytics_demo_examples/style_mock_zone_analytics.json
@@ -0,0 +1,411 @@
+[
+  {
+    "id": "uc6-neutral-customer",
+    "name": "Neutral integrity faults",
+    "type": "circle",
+    "minzoom": 10,
+    "paint": {
+      "circle-radius": [
+        "interpolate",
+        ["linear"],
+        ["get", "fault_events"],
+        1,
+        6,
+        6,
+        18
+      ],
+      "circle-color": [
+        "match",
+        ["get", "feature_kind"],
+        "neutral_customer",
+        "#de2d26",
+        "#de2d26"
+      ],
+      "circle-opacity": 0.9,
+      "circle-stroke-color": "#ffffff",
+      "circle-stroke-width": 1.2
+    },
+    "metadata": {
+      "zb:legend": {
+        "label": "Neutral integrity fault detection"
+      }
+    },
+    "filter": ["all", ["==", ["get", "use_case"], 6], ["==", ["get", "feature_kind"], "neutral_customer"]]
+  },
+  {
+    "id": "uc6-neutral-label",
+    "name": "Neutral fault labels",
+    "type": "symbol",
+    "minzoom": 15,
+    "layout": {
+      "text-field": ["get", "fault_label"],
+      "text-font": ["DIN Offc Pro Medium", "Arial Unicode MS Bold"],
+      "text-size": 22,
+      "text-allow-overlap": true,
+      "text-ignore-placement": true
+    },
+    "paint": {
+      "text-color": "#202020",
+      "text-halo-color": "#ffffff",
+      "text-halo-width": 2
+    },
+    "filter": ["all", ["==", ["get", "use_case"], 6], ["==", ["get", "feature_kind"], "neutral_customer"]]
+  },
+  {
+    "id": "uc7-voltage-heatmap",
+    "name": "Voltage heatmap",
+    "type": "heatmap",
+    "maxzoom": 15,
+    "paint": {
+      "heatmap-weight": [
+        "interpolate",
+        ["linear"],
+        ["get", "voltage_heat_weight"],
+        0,
+        0,
+        1,
+        0.8
+      ],
+      "heatmap-intensity": [
+        "interpolate",
+        ["linear"],
+        ["zoom"],
+        6,
+        0.08,
+        9,
+        0.2,
+        12,
+        0.55,
+        14,
+        1.0
+      ],
+      "heatmap-radius": [
+        "interpolate",
+        ["linear"],
+        ["zoom"],
+        6,
+        12,
+        9,
+        16,
+        12,
+        24,
+        14,
+        32
+      ],
+      "heatmap-opacity": [
+        "interpolate",
+        ["linear"],
+        ["zoom"],
+        6,
+        0.36,
+        10,
+        0.55,
+        14,
+        0.85
+      ],
+      "heatmap-color": [
+        "interpolate",
+        ["linear"],
+        ["heatmap-density"],
+        0,
+        "rgba(33,102,172,0)",
+        0.2,
+        "rgb(146,197,222)",
+        0.4,
+        "rgb(209,229,240)",
+        0.6,
+        "rgb(253,219,199)",
+        0.8,
+        "rgb(244,165,130)",
+        1,
+        "rgb(214,96,77)"
+      ]
+    },
+    "metadata": {
+      "zb:legend": {
+        "label": "Voltage monitoring and reporting"
+      }
+    },
+    "filter": ["all", ["==", ["get", "use_case"], 7], ["==", ["get", "feature_kind"], "voltage_customer"]]
+  },
+  {
+    "id": "uc7-voltage-hotspot",
+    "name": "Voltage severe points",
+    "type": "circle",
+    "minzoom": 11,
+    "paint": {
+      "circle-radius": 3,
+      "circle-color": "#b10026",
+      "circle-opacity": 0.45,
+      "circle-stroke-width": 0
+    },
+    "filter": [
+      "all",
+      ["==", ["get", "use_case"], 7],
+      ["==", ["get", "feature_kind"], "voltage_customer"],
+      ["==", ["get", "severe"], 1]
+    ]
+  },
+  {
+    "id": "uc8-dvc-mv-line",
+    "name": "DVC tap zones on MV lines",
+    "type": "line",
+    "minzoom": 9,
+    "paint": {
+      "line-width": [
+        "interpolate",
+        ["linear"],
+        ["zoom"],
+        9,
+        1.5,
+        14,
+        4.2
+      ],
+      "line-color": [
+        "interpolate",
+        ["linear"],
+        ["get", "estimated_end_voltage_pct"],
+        97.5,
+        "#d73027",
+        99,
+        "#fdae61",
+        100,
+        "#ffffbf",
+        101,
+        "#abd9e9",
+        102.5,
+        "#4575b4"
+      ],
+      "line-opacity": 0.93
+    },
+    "metadata": {
+      "zb:legend": {
+        "label": "Dynamic Voltage Control"
+      }
+    },
+    "filter": ["all", ["==", ["get", "use_case"], 8], ["==", ["get", "feature_kind"], "dvc_mv_line"]]
+  },
+  {
+    "id": "uc8-dvc-tap-transformer",
+    "name": "Transformers requiring tap change",
+    "type": "circle",
+    "minzoom": 10,
+    "paint": {
+      "circle-radius": 18,
+      "circle-color": [
+        "match",
+        ["get", "tap_action"],
+        "Raise",
+        "#2ca25f",
+        "Lower",
+        "#de2d26",
+        "#636363"
+      ],
+      "circle-opacity": 0.9,
+      "circle-stroke-color": "#ffffff",
+      "circle-stroke-width": 1.2
+    },
+    "filter": ["all", ["==", ["get", "use_case"], 8], ["==", ["get", "feature_kind"], "dvc_tap_transformer"]]
+  },
+  {
+    "id": "uc8-dvc-tap-label",
+    "name": "DVC tap labels",
+    "type": "symbol",
+    "minzoom": 11,
+    "layout": {
+      "text-field": ["get", "tap_move"],
+      "text-font": ["DIN Offc Pro Medium", "Arial Unicode MS Bold"],
+      "text-size": 24,
+      "text-allow-overlap": true,
+      "text-ignore-placement": true
+    },
+    "paint": {
+      "text-color": "#111111",
+      "text-halo-color": "#ffffff",
+      "text-halo-width": 2
+    },
+    "filter": ["all", ["==", ["get", "use_case"], 8], ["==", ["get", "feature_kind"], "dvc_tap_transformer"]]
+  },
+  {
+    "id": "uc9-phase-customer",
+    "name": "Customer phase circles",
+    "type": "circle",
+    "minzoom": 10,
+    "paint": {
+      "circle-radius": 4.6,
+      "circle-color": [
+        "match",
+        ["get", "phase_class"],
+        "A",
+        "#ff2020",
+        "B",
+        "#ffffff",
+        "C",
+        "#1e5bff",
+        "#000000"
+      ],
+      "circle-stroke-color": "#333333",
+      "circle-stroke-width": 0.8,
+      "circle-opacity": 0.92
+    },
+    "metadata": {
+      "zb:legend": {
+        "label": "Phase identification"
+      }
+    },
+    "filter": ["all", ["==", ["get", "use_case"], 9], ["==", ["get", "feature_kind"], "phase_customer"]]
+  },
+  {
+    "id": "uc13-compliance-customer",
+    "name": "CER compliance at customers",
+    "type": "circle",
+    "minzoom": 10,
+    "paint": {
+      "circle-radius": 4.8,
+      "circle-color": [
+        "match",
+        ["get", "compliance_tier"],
+        "Compliant",
+        "#2ca25f",
+        "At Risk",
+        "#fdae6b",
+        "Non-Compliant",
+        "#de2d26",
+        "#636363"
+      ],
+      "circle-opacity": 0.86,
+      "circle-stroke-color": "#ffffff",
+      "circle-stroke-width": 0.8
+    },
+    "metadata": {
+      "zb:legend": {
+        "label": "CER compliance"
+      }
+    },
+    "filter": ["all", ["==", ["get", "use_case"], 13], ["==", ["get", "feature_kind"], "cer_compliance_customer"]]
+  },
+  {
+    "id": "uc14-curtailment-transformer",
+    "name": "Transformer curtailment",
+    "type": "circle",
+    "minzoom": 10,
+    "paint": {
+      "circle-radius": [
+        "interpolate",
+        ["linear"],
+        ["get", "curtailed_kwh"],
+        0,
+        6,
+        1500,
+        10,
+        6000,
+        16
+      ],
+      "circle-color": [
+        "interpolate",
+        ["linear"],
+        ["get", "curtailed_kwh"],
+        0,
+        "#f7fcfd",
+        600,
+        "#ccece6",
+        2500,
+        "#66c2a4",
+        6000,
+        "#238b45",
+        12000,
+        "#00441b"
+      ],
+      "circle-opacity": 0.9,
+      "circle-stroke-color": "#ffffff",
+      "circle-stroke-width": 1.1
+    },
+    "metadata": {
+      "zb:legend": {
+        "label": "CER performance"
+      }
+    },
+    "filter": ["all", ["==", ["get", "use_case"], 14], ["==", ["get", "feature_kind"], "cer_performance_transformer"]]
+  },
+  {
+    "id": "uc14-curtailment-label",
+    "name": "Curtailment labels",
+    "type": "symbol",
+    "minzoom": 11,
+    "layout": {
+      "text-field": ["get", "curtailment_label"],
+      "text-font": ["DIN Offc Pro Medium", "Arial Unicode MS Bold"],
+      "text-size": 10,
+      "text-allow-overlap": true,
+      "text-ignore-placement": true
+    },
+    "paint": {
+      "text-color": "#111111",
+      "text-halo-color": "#ffffff",
+      "text-halo-width": 2
+    },
+    "filter": ["all", ["==", ["get", "use_case"], 14], ["==", ["get", "feature_kind"], "cer_performance_transformer"]]
+  },
+  {
+    "id": "uc15-ev-customer",
+    "name": "EV detections",
+    "type": "circle",
+    "minzoom": 10,
+    "paint": {
+      "circle-radius": [
+        "interpolate",
+        ["linear"],
+        ["get", "peak_kw"],
+        1,
+        7,
+        4,
+        10,
+        8,
+        14,
+        12,
+        18
+      ],
+      "circle-color": [
+        "interpolate",
+        ["linear"],
+        ["get", "peak_kw"],
+        2.4,
+        "#2ca25f",
+        7,
+        "#fdd49e",
+        11,
+        "#fd8d3c",
+        22,
+        "#de2d26"
+      ],
+      "circle-opacity": 0.86,
+      "circle-stroke-color": "#ffffff",
+      "circle-stroke-width": 1.2
+    },
+    "metadata": {
+      "zb:legend": {
+        "label": "EV charger detection"
+      }
+    },
+    "filter": ["all", ["==", ["get", "use_case"], 15], ["==", ["get", "feature_kind"], "ev_customer"]]
+  },
+  {
+    "id": "uc15-ev-label",
+    "name": "EV charger labels",
+    "type": "symbol",
+    "minzoom": 14,
+    "layout": {
+      "text-field": ["get", "ev_label"],
+      "text-font": ["DIN Offc Pro Medium", "Arial Unicode MS Bold"],
+      "text-size": 14,
+      "text-allow-overlap": true,
+      "text-ignore-placement": true
+    },
+    "paint": {
+      "text-color": "#161616",
+      "text-halo-color": "#ffffff",
+      "text-halo-width": 2
+    },
+    "filter": ["all", ["==", ["get", "use_case"], 15], ["==", ["get", "feature_kind"], "ev_customer"]]
+  }
+]
diff --git a/src/zepben/examples/studies/analytics_demo_examples/use_cases.txt b/src/zepben/examples/studies/analytics_demo_examples/use_cases.txt
new file mode 100644
index 0000000..4089541
--- /dev/null
+++ b/src/zepben/examples/studies/analytics_demo_examples/use_cases.txt
@@ -0,0 +1,105 @@
+6	Neutral integrity fault detection	The platform will utilise available time series voltage data to detect loss-of-neutral faults within the low-voltage (LV) network. Each fault detection event will include a confidence score and an estimated fault location, such as the service cable or feeder. In addition to neutral faults, the platform will identify LV and high-voltage (HV) phase faults that manifest in the LV network. These faults will be monitored and reported through a weekly report, which provides detailed tracking and diagnostic insights to support fault resolution and network reliability.	"The platform must understand Evoenergy's policies around neutral integrity and provide:
+- Calculated loop impedance;
+- Estimated loop impendance based on GIS data;
+- Start and end date of non-compliance; 
+- Detection and tracking must be visually represented for user review and evaluation.
+
+Additional requirements of this feature
+- Provide a confidence rating of detected fault;
+- Indicate the location of the fault including customer installation, LV feeder, transformer etc. The platform must be user-friendly, allowing users to easily navigate the local network, identify other NMIs, and determine whether the issue originates from the LV feeder or the distribution transformer.
+- Have provisions to track workflow status and log comments for each fault detected;
+- Send automated emails for faults with >= 85% confidence rating
+
+"
+7	Voltage monitoring and reporting	"Aggregate time series voltage measurements from LV voltage measurements to generate consolidated data at both the distribution substation and zone substation levels. The reporting will include key power quality metrics such as the 1st and 99th voltage percentiles, voltage unbalance, and voltage spread. Data will be available in daily, weekly, and monthly aggregations, and presented in a downloadable report format for user access. 
+When the platform detects voltage breaches, the platform should automatically generate notifications and/or compile them into a structured report, delivered on a weekly basis. This reporting capability enables timely visibility into voltage compliance issues and supports proactive network management and planning. "	"The platform must understand Evoenergy's obligations around voltage performance management and provide:
+Weekly, monthly and yearly assessments of
+- Network wide customer compliance of all LV voltage measurements - this will be available as total noncompliance customers, undervoltage customers, overvoltage customers, sag customers and swell customers. This data will be presented both as a graph and as a table that the users can easily navigate across various layers of the network starting from the zone substation down to the customer premises.
+- Voltage assessment (V99 and V1) across zone substations, distribution substations and customers. This data must be presented in an easy to access format on the platform and the users must be able to sort the columns from low to high or high to low readings and download the reports.
+- User must be able to select the view of their preference- i.e. Weekly, Monthly or Yearly
+- Automated notifications when voltages exceed Evoenergy's safety limits. The platform must have provisions for Evoenergy to manage workflow- for instance, sites that breached the limits must be made available in a report format daily, with provisions to capture workflow status.
+
+Additional requirements:
+Distribution substation data:
+- A time series of aggregated voltage data (daily, weekly, and monthly) must be available for each distribution substation and provided in a downloadable format.
+- A detailed list of customers on each LV circuit must be displayed, including their V99 and V1 values and estimated phase connections. This data must also be downloadable.
+- The platform must have the capability to simulate changing a distribution trasnformer tap setting and evaluate the affect to downstream customers.
+Customer data:
+-For each customer, a time series plot of voltage data by phase (daily, weekly, and monthly) must be available and downloadable."
+8	 Dynamic Voltage Control	The analytics platform will utilise data from smart meters, distribution transformers, and zone substation SCADA points to support planning and implementation of zone substation power transformer dynamic voltage control strategies.	"Core functionalities will include:
+- Visualising zone substation power transformer power quality data via a network exploration interface
+- Generating medium-voltage performance reports
+- Producing optimal tap settings for distribution substations
+- Simulating dynamic voltage control scenarios across the zone"
+9	Phase identification	"The data analytics platform must identify phase connections for customers with smart meter power quality data, identify the phase connection as Red, White, Blue for single and three phase customers with reference to the distirbution trasnformer and/or other customers on the distribution transformer.
+"	"The platform must indicate
+- The customer's connection type and connected as single phase or three-phase supply, along with the identified phase (R, W, or B) for single-phase customers.
+- A summary of phase connections at the substation level- including the number of customers connected to each phase (R, W, B), the number of three-phase connections, and how many connections are unknown.
+-Identify which phases of the installation have generation connected.
+- Aggregrate power by phase connection at the distribution transformer and LV feeders in aggregated power analysis.
+- Aggregate voltage by phase connection at the distribution transformer in agregated voltage analysis."
+10	 MV and LV network loading	The data analytics platform must analyse network loading for MV feeders, distribution transformers and LV feeders, total loading will be estimated at every timestamp where sufficient data is availiable. Using either direct transformer monitoring data or derived loading estimates, the system will identify peak forward and reverse power flows and calculate both load and generation headroom. 	"The platform must analyse the LV data and provide an aggregated weekly, monthly and yearly overview of
+- MV feeder capacity and its estimated utilisation;
+- Dsitrbution transformers capacity and its utilisation;
+- LV circuits capacity and its utilisation.
+Additional requirements
+-Transformer Capacity and Cyclic Loading: Display current transformer capacity, preferably- its cyclic loading (in accordance with AS/NZS 60076.7) and time spent by the transformer in long-time and short-time emergency loading categories.
+- Utilisation Metric: Show average and maximum utilisation based on estimates, ADMD (After Diversity Maximum Demand), and meter summation, benchmarked against transformer capacity and (preferably) cyclic loading. For meter summation analysis, the platform must indicate the percentage of available smart meters that contributed to the calculation, relative to the total number of customers on the transformer
+- Capacity Exceedance Tracking: Indicate the number of days the transformer capacity and (preferably) cyclic loading limits were exceeded.
+- Headroom Availability: Report available headroom for both load and generation.
+- Estimate Confidence Rating: Include a confidence rating for each estimate to support decision-making.
+- The users must be able to filter data based on transformer size, confidence rating, look up for specific assets etc. and this information must be downloadable
+- Automated email notifications for high confidence asset estimates and/or meter summation exceed 1.5 times the rated load, for 45 consecutive days.
+
+LV circuit analysis must align closely with the substation-level requirements and additionally include automated email notifications if the platform estimates a potential LV circuit outage."
+11	 New load connection assessments	The data analytics platform must leverage both the characteristics of the network model and available smart meter data to assess the potential impacts of a new load connection. 	"The platform must support analysis of new customer connections by providing the following capabilities:
+-Selection Interface: Allow users to select a specific distribution transformer/substation, its associated LV circuit  and a point on the LV circuit to simulate a new connection. The platform should be capable of allowing for single and three phase load simulations.
+-Connection Type Analysis: Support simulation of both load and generation connections. The platform must assess whether the proposed connection would cause the transformer to exceed its ratings.
+-Voltage Impact Simulation: Display the expected voltage rise and/or drop resulting from the new connection. This impact must be visualised as a time series across daily, monthly, and yearly intervals.
+- Risk Identification and Mitigation: The platform will flag high-risk connection proposals to maintain network capacity and power quality.
+- All simulation results must be available in a downloadable format for further analysis or reporting."
+12	 CER detection	The data analytics platform must identify whether a customer has a solar PV system, determine the connected phase, and estimate both arrary and inverter capacity in kilowatts, validating these details against existing CER records. For customers with PV systems, the platform should also detect battery installations and confirm any existing battery records. It must determine the installation date based on when the PV or battery was first detected if this is within the available data period. At the distribution substation level, downstream CERs must be aggregated to support voltage behaviour analysis.	"1. Rooftop Solar PV Detection and Validation
+-System Validation: Detected rooftop solar PV systems must be validated against Evoenergy records, including:
+- PV system size, Inverter rating, Maximum export capacity, Date of installation
+- System Categorisation: Post-validation, each system must be classified into categories such as:
+recorded/unrecorded, Oversized, Undersized, Unable to size, OK, not detected.
+- Detection Source Transparency: Clearly indicate the data source used for detection (e.g., NEM12, BPQD).
+- A symbol on the map must indicate installed PV systems on the network.
+- Reporting and Filtering: All findings must be presented in a report format with various filtering options. 
+- Must have the option to export results as .csv or excel format. Must show a sun or other symbol on map view to indicate where solar is located.
+- Must be able to view timeseries graphs for export at a specific site, or at a group of NMIs at the same connection point. Need to be able to choose between single day or longer time periods. Must have some comparison to weather data to visualise if reduced output is likely from cloud cover or self-consumption.
+
+2. Residential Battery Validation
+-Validate detected residential battery systems against Evoenergy records. Catogorise as recorded/unrecorded and provide an export option of the results in .csv or excel format. A battery symbol must indicate on map view where a battery has been detected. It is preferable that unrecorded batteries will display some sort of confidence rating with the highest confidence category having <5% false positives.
+
+"
+13	CER compliance	The data analytics platform must utilise available smart meter data to improve the accuracy of solar PV identification and sizing, battery detection etc. For each identified PV customer, if sufficient smart meter data is available, the platform should perform performance, inverter compliance characterisation and detect the maximum export date. This includes detecting curtailment modes such as Volt/Watt, Volt/VAr, disconnection curtailment, and hard export limits, which are specified by Evoenergy on a per customer basis. Furthermore, it must determine the version of AS/NZS 4777.2 that the detected PV system complies with and identify the date when a previously non-compliant system becomes compliant. 	"i.The platform must analyse basic power quality data and provide compliance status for each detected system on
+- Volt/Watt (Enabled / Disabled / Undetermined / no data)
+- Volt/Var (Enabled / Disabled / Undetermined / no data)
+- Disconnect settings (Enabled / Disabled / Undetermined / no data)
+-Export limit (compliant / overexport / undetermined)
+ii. Date of non-compliance detection and date of remediation must be recorded. All of the above information must be accessible through the CER detection feature and provided in a downloadable format. The data must include filtering options based on compliance status, enabling users to easily sort and analyse relevant records. New compliance issues must be calculated in a timely fashion, and displayed in reports no more than 1 month after it is first detected, with shorter time periods preferable.
+iii. Preferably a graph showing max import/export on each day with a year history so trends can be seen easily. 
+"
+14	CER performance	The platform must provide functionality to quantify energy losses resulting from inverter curtailment modes, such as Volt/Watt, Volt/VAr, static export limits etc. These calculations must be aggregated over weekly and monthly periods, and expressed as both kilowatt-hours (kWh) and curtailment value ($/kWh), where user-defined pricing inputs are available. 	" The platform must provide information on CER curtailment across distribution substations, zone substations and network wide- in a weekly, monthly and yearly basis and in a downloadable format. 
+- Curtailment due to inverter voltage response (kWh)
+- Curtailment due to static export limits (kWh)
+- Curtailment due to dynamic export limits (kWh)
+- Curtailment directed for system security (kWh)
+The platform must calculate curtailment value ($/kWh) based on user input. "
+15	 Other detection capabilities	The data analytics platform must detect EV chargers using active power data and generate statistical outputs to support engineers in identifying high-risk chargers, enhancing load forecasting. Additionally, the platform must perform large load detection and characterisation across available smart meters to identify significant customer loads that could enable demand management through load shifting and control strategies. Key metrics should include load capacity, median continuous duration, average daily usage duration, and the longest continuous occurrence. 	"1. Electric Vehicle (EV) Charger Detection
+- Customer-Level Detection: Identify EV chargers at the customer level, including:
+Charger type
+Estimated charging sessions per week
+Power time series to show typical usage behavior
+- Substation-Level Aggregation: Count of EV chargers per distribution substation
+- Network-Level Aggregation: Total count of EV chargers across the network
+
+2. Large Load Detection
+- Detect large electrical loads and provide the following metrics:
+Estimated capacity (kW)
+Average daily duration
+Average occurrence duration
+Longest duration
+Power time series to show typical usage behavior
+- All data and insights generated by the platform must be made available to Evoenergy in a downloadable format. Filtering options must be provided across all features to support targeted analysis."
\ No newline at end of file
diff --git a/src/zepben/examples/studies/customer_distance_to_transformer.py b/src/zepben/examples/studies/customer_distance_to_transformer.py
new file mode 100644
index 0000000..1fb16bd
--- /dev/null
+++ b/src/zepben/examples/studies/customer_distance_to_transformer.py
@@ -0,0 +1,284 @@
+#  Copyright 2025 Zeppelin Bend Pty Ltd
+#
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+import asyncio
+import json
+from datetime import datetime
+from itertools import islice
+from typing import List, Dict, Tuple, Callable, Any, Union, Type, Set
+
+from geojson import FeatureCollection, Feature
+from geojson.geometry import Geometry, LineString, Point
+from zepben.eas.client.eas_client import EasClient
+from zepben.eas.client.study import Study, Result, GeoJsonOverlay
+from zepben.ewb import (
+    AcLineSegment,
+    EnergyConsumer,
+    PowerTransformer,
+    NetworkConsumerClient,
+    PhaseCode,
+    Feeder,
+    PowerSystemResource,
+    Location,
+    connect_with_token,
+    NetworkTraceStep,
+    Tracing,
+    upstream,
+    stop_at_open,
+    IncludedEnergizedContainers,
+)
+from zepben.ewb.services.network.tracing.networktrace.operators.network_state_operators import NetworkStateOperators
+
+
+with open("../config.json") as f:
+    c = json.loads(f.read())
+
+
+def chunk(it, size):
+    it = iter(it)
+    return iter(lambda: tuple(islice(it, size)), ())
+
+
+async def main():
+    # Only process feeders in the following zones
+    zone_mrids = ["CPM"]
+    print(f"Start time: {datetime.now()}")
+
+    rpc_channel = connect_with_token(
+        host=c["host"],
+        access_token=c["access_token"],
+        rpc_port=c["rpc_port"],
+        ca_filename=c.get("ca_filename"),
+        timeout_seconds=c.get("timeout_seconds", 5),
+        debug=bool(c.get("debug", False)),
+        skip_connection_test=bool(c.get("skip_connection_test", False)),
+    )
+    client = NetworkConsumerClient(rpc_channel)
+    hierarchy = (await client.get_network_hierarchy()).throw_on_error()
+    substations = hierarchy.value.substations
+
+    print(f"Collecting feeders from zones {', '.join(zone_mrids)}.")
+    feeder_mrids = []
+    for zone_mrid in zone_mrids:
+        if zone_mrid in substations:
+            for feeder in substations[zone_mrid].feeders:
+                feeder_mrids.append(feeder.mrid)
+
+    print(f"Feeders to be processed: {', '.join(feeder_mrids)}")
+
+    all_ecs: List[EnergyConsumer] = []
+    ec_to_distance_m: Dict[str, float] = {}
+
+    # Process feeders in batches of 3, using asyncio, for performance
+    batches = chunk(feeder_mrids, 3)
+    for feeders in batches:
+        futures = []
+        rpc_channel = connect_with_token(
+            host=c["host"],
+            access_token=c["access_token"],
+            rpc_port=c["rpc_port"],
+            ca_filename=c.get("ca_filename"),
+            timeout_seconds=c.get("timeout_seconds", 5),
+            debug=bool(c.get("debug", False)),
+            skip_connection_test=bool(c.get("skip_connection_test", False)),
+        )
+        print(f"Processing feeders {', '.join(feeders)}")
+        for feeder_mrid in feeders:
+            futures.append(asyncio.ensure_future(fetch_feeder_customer_distance(feeder_mrid, rpc_channel)))
+
+        for future in futures:
+            result = await future
+            if result is None:
+                continue
+            ecs, distances = result
+            all_ecs.extend(ecs)
+            ec_to_distance_m.update(distances)
+
+    print(f"Creating study for {len(all_ecs)} energy consumers")
+
+    eas_client = EasClient(host=c["host"], port=c["rpc_port"], protocol="https", access_token=c["access_token"])
+    print(f"Uploading Study for zones {', '.join(zone_mrids)} ...")
+    await upload_distance_study(
+        eas_client,
+        all_ecs,
+        ec_to_distance_m,
+        name=f"Customer distance to transformer ({', '.join(zone_mrids)})",
+        description="Distance along the normal network path from each EnergyConsumer to its upstream transformer.",
+        tags=["customer_distance", "-".join(zone_mrids)],
+        styles=json.load(open("style_customer_distance.json", "r")),
+    )
+    await eas_client.aclose()
+    print("Uploaded Study")
+
+    print(f"Finish time: {datetime.now()}")
+
+
+async def fetch_feeder_customer_distance(
+    feeder_mrid: str,
+    rpc_channel,
+) -> Union[Tuple[List[EnergyConsumer], Dict[str, float]], None]:
+    print(f"Fetching Feeder {feeder_mrid}")
+    client = NetworkConsumerClient(rpc_channel)
+
+    result = (
+        await client.get_equipment_container(
+            mrid=feeder_mrid,
+            expected_class=Feeder,
+            include_energized_containers=IncludedEnergizedContainers.LV_FEEDERS,
+        )
+    )
+    if result.was_failure:
+        print(f"Failed: {result.thrown}")
+        return None
+
+    network = client.service
+    print(f"Finished fetching Feeder {feeder_mrid}")
+
+    # Required for directed traces (upstream/downstream)
+    await Tracing.set_direction().run(network, network_state_operators=NetworkStateOperators.NORMAL)
+
+    ecs = list(network.objects(EnergyConsumer))
+    ec_to_distance_m = {}
+    for ec in ecs:
+        path_lines = await get_upstream_lines_to_transformer(ec)
+        distance = sum(_line_length_m(line) for line in path_lines)
+        ec_to_distance_m[ec.mrid] = distance
+
+    return ecs, ec_to_distance_m
+
+
+def _line_length_m(line: AcLineSegment) -> float:
+    return float(line.length or 0.0)
+
+
+def collect_upstream_lines_provider(lines: Set[AcLineSegment]):
+
+    async def collect_lines(ps: NetworkTraceStep, _):
+        line = ps.path.traversed_ac_line_segment
+        if line is not None:
+            lines.add(line)
+        if isinstance(ps.path.to_equipment, AcLineSegment):
+            lines.add(ps.path.to_equipment)
+        if isinstance(ps.path.from_equipment, AcLineSegment):
+            lines.add(ps.path.from_equipment)
+
+    return collect_lines
+
+
+async def get_upstream_lines_to_transformer(ec: EnergyConsumer) -> Set[AcLineSegment]:
+    lines = set()
+
+    await (
+        Tracing.network_trace()
+        .add_condition(upstream())
+        .add_condition(stop_at_open())
+        .add_step_action(collect_upstream_lines_provider(lines))
+        .add_stop_condition(_is_transformer)
+    ).run(start=ec, phases=PhaseCode.ABCN, can_stop_on_start_item=False)
+
+    return lines
+
+
+def _is_transformer(ps: NetworkTraceStep, _context=None) -> bool:
+    return isinstance(ps.path.to_equipment, PowerTransformer)
+
+
+async def upload_distance_study(
+    eas_client: EasClient,
+    ecs: List[EnergyConsumer],
+    ec_to_distance_m: Dict[str, float],
+    name: str,
+    description: str,
+    tags: List[str],
+    styles: List,
+) -> None:
+
+    class_to_properties = {
+        EnergyConsumer: {
+            "name": lambda ec: ec.name,
+            "distance_m": _distance_from(ec_to_distance_m),
+            "distance_label": _distance_label_from(ec_to_distance_m),
+            "type": lambda x: "ec",
+        },
+    }
+    feature_collection = to_geojson_feature_collection(ecs, class_to_properties)
+    response = await eas_client.async_upload_study(
+        Study(
+            name=name,
+            description=description,
+            tags=tags,
+            results=[
+                Result(
+                    name=name,
+                    geo_json_overlay=GeoJsonOverlay(
+                        data=feature_collection,
+                        styles=[s['id'] for s in styles]
+                    )
+                )
+            ],
+            styles=styles
+        )
+    )
+    print(f"Study response: {response}")
+
+
+def _distance_from(ec_to_distance_m: Dict[str, float]):
+    def fun(ec: EnergyConsumer):
+        return round(ec_to_distance_m.get(ec.mrid, 0.0))
+
+    return fun
+
+
+def _distance_label_from(ec_to_distance_m: Dict[str, float]):
+    def fun(ec: EnergyConsumer):
+        value = ec_to_distance_m.get(ec.mrid, 0.0)
+        return f"{round(value)}m"
+
+    return fun
+
+
+def to_geojson_feature_collection(
+    psrs: List[PowerSystemResource],
+    class_to_properties: Dict[Type, Dict[str, Callable[[Any], Any]]]
+) -> FeatureCollection:
+
+    features = []
+    for psr in psrs:
+        properties_map = class_to_properties.get(type(psr))
+
+        if properties_map is not None:
+            feature = to_geojson_feature(psr, properties_map)
+            if feature is not None:
+                features.append(feature)
+
+    return FeatureCollection(features)
+
+
+def to_geojson_feature(
+    psr: PowerSystemResource,
+    property_map: Dict[str, Callable[[PowerSystemResource], Any]]
+) -> Union[Feature, None]:
+
+    geometry = to_geojson_geometry(psr.location)
+    if geometry is None:
+        return None
+
+    properties = {k: f(psr) for (k, f) in property_map.items()}
+    return Feature(psr.mrid, geometry, properties)
+
+
+def to_geojson_geometry(location: Location) -> Union[Geometry, None]:
+    points = list(location.points) if location is not None else []
+    if len(points) > 1:
+        return LineString([(point.x_position, point.y_position) for point in points])
+    elif len(points) == 1:
+        return Point((points[0].x_position, points[0].y_position))
+    else:
+        return None
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/src/zepben/examples/studies/data_quality_studies/README.md b/src/zepben/examples/studies/data_quality_studies/README.md
new file mode 100644
index 0000000..0d02032
--- /dev/null
+++ b/src/zepben/examples/studies/data_quality_studies/README.md
@@ -0,0 +1,40 @@
+# Data Quality Studies
+
+These scripts generate data-quality analysis layers focused on connectivity and power-flow modeling issues.
+They upload EAS studies using the credentials in `src/zepben/examples/config.json`.
+
+## Usage
+
+From the repository root:
+
+```
+python src/zepben/examples/studies/data_quality_studies/connectivity_gaps.py CPM
+python src/zepben/examples/studies/data_quality_studies/consumer_mapping_issues.py CPM
+python src/zepben/examples/studies/data_quality_studies/phase_conductor_issues.py CPM
+python src/zepben/examples/studies/data_quality_studies/asset_attribute_inconsistencies.py CPM
+python src/zepben/examples/studies/data_quality_studies/protection_directionality_anomalies.py CPM
+python src/zepben/examples/studies/data_quality_studies/spatial_location_anomalies.py CPM
+```
+
+Use a comma-separated list for multiple zones:
+
+```
+python src/zepben/examples/studies/data_quality_studies/connectivity_gaps.py CPM,NSK
+```
+
+## Summary Study
+
+`data_quality_summary.py` runs all checks for a zone and uploads a single study
+containing only layers where anomalies are detected. The study description and
+tags list only the tests that reported anomalies.
+
+```
+python src/zepben/examples/studies/data_quality_studies/data_quality_summary.py NSK
+```
+
+## Notes
+
+- Each script accepts a zone code argument. If omitted, it defaults to `CPM`.
+- Individual scripts always upload all layers; if no anomalies are found, the
+  layer name is prefixed with "No anomalies detected: ...".
+- The summary script skips upload if no anomalies are detected at all.
diff --git a/src/zepben/examples/studies/data_quality_studies/__init__.py b/src/zepben/examples/studies/data_quality_studies/__init__.py
new file mode 100644
index 0000000..e976163
--- /dev/null
+++ b/src/zepben/examples/studies/data_quality_studies/__init__.py
@@ -0,0 +1 @@
+# Data quality study examples.
diff --git a/src/zepben/examples/studies/data_quality_studies/asset_attribute_inconsistencies.py b/src/zepben/examples/studies/data_quality_studies/asset_attribute_inconsistencies.py
new file mode 100644
index 0000000..4562e99
--- /dev/null
+++ b/src/zepben/examples/studies/data_quality_studies/asset_attribute_inconsistencies.py
@@ -0,0 +1,389 @@
+#  Copyright 2025 Zeppelin Bend Pty Ltd
+#
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+import asyncio
+import json
+from pathlib import Path
+from datetime import datetime
+from typing import Dict, List, Set, Tuple
+import sys
+
+from geojson import FeatureCollection
+from zepben.eas.client.eas_client import EasClient
+from zepben.eas.client.study import GeoJsonOverlay, Result, Study
+from zepben.ewb import (
+    AcLineSegment,
+    Feeder,
+    IncludedEnergizedContainers,
+    NetworkConsumerClient,
+    PowerTransformer,
+    Switch,
+    connect_with_token,
+)
+
+from dq_utils import (
+    chunk,
+    get_zone_mrids,
+    line_length_m,
+    load_config,
+    no_anomaly_feature_collection,
+    to_geojson_feature_collection,
+)
+
+
+async def main():
+    zone_mrids = get_zone_mrids(sys.argv, default=["CPM"])
+    print(f"Start time: {datetime.now()}")
+
+    config = load_config()
+    rpc_channel = _connect_rpc(config)
+    client = NetworkConsumerClient(rpc_channel)
+    hierarchy = (await client.get_network_hierarchy()).throw_on_error()
+    feeder_mrids = _collect_feeder_mrids(hierarchy.value.substations, zone_mrids)
+
+    print(f"Collecting feeders from zones {', '.join(zone_mrids)}.")
+    print(f"Feeders to be processed: {', '.join(feeder_mrids)}")
+
+    zero_length_lines: Set[AcLineSegment] = set()
+    missing_impedance_lines: Set[AcLineSegment] = set()
+    missing_rating_transformers: Set[PowerTransformer] = set()
+    missing_impedance_transformers: Set[PowerTransformer] = set()
+    missing_normal_state_switches: Set[Switch] = set()
+
+    for feeders in chunk(feeder_mrids, 3):
+        rpc_channel = _connect_rpc(config)
+        for feeder_mrid in feeders:
+            result = await _fetch_asset_inconsistencies(feeder_mrid, rpc_channel)
+            if result is None:
+                continue
+            z_lines, i_lines, t_missing, t_imp_missing, s_missing = result
+            zero_length_lines.update(z_lines)
+            missing_impedance_lines.update(i_lines)
+            missing_rating_transformers.update(t_missing)
+            missing_impedance_transformers.update(t_imp_missing)
+            missing_normal_state_switches.update(s_missing)
+
+    style_path = Path(__file__).resolve().parent / "style_asset_attribute.json"
+    styles = json.load(open(style_path, "r"))
+    result_specs = [
+        (
+            "Zero-length line segments",
+            _build_line_result(
+                "Zero-length line segments",
+                list(zero_length_lines),
+                style_ids=["dq-zero-length-lines"],
+                issue="zero_length",
+            ),
+        ),
+        (
+            "Line segments missing impedance info",
+            _build_line_result(
+                "Line segments missing impedance info",
+                list(missing_impedance_lines),
+                style_ids=["dq-missing-impedance-lines"],
+                issue="missing_impedance",
+            ),
+        ),
+        (
+            "Transformers missing rating",
+            _build_transformer_result(
+                "Transformers missing rating",
+                list(missing_rating_transformers),
+                style_ids=["dq-missing-rating-transformer"],
+                issue="missing_rating",
+            ),
+        ),
+        (
+            "Transformers missing impedance",
+            _build_transformer_result(
+                "Transformers missing impedance",
+                list(missing_impedance_transformers),
+                style_ids=["dq-missing-impedance-transformer"],
+                issue="missing_transformer_impedance",
+            ),
+        ),
+        (
+            "Switches missing normal state",
+            _build_switch_result(
+                "Switches missing normal state",
+                list(missing_normal_state_switches),
+                style_ids=["dq-missing-normal-state-switch"],
+                issue="missing_normal_state",
+            ),
+        ),
+    ]
+    results = []
+    for name, result in result_specs:
+        if result is not None:
+            results.append(result)
+        else:
+            results.append(
+                Result(
+                    name=f"No anomalies detected: {name}",
+                    geo_json_overlay=GeoJsonOverlay(
+                        data=no_anomaly_feature_collection(),
+                        styles=["dq-no-anomalies"],
+                    ),
+                )
+            )
+
+    eas_client = EasClient(host=config["host"], port=config["rpc_port"], protocol="https", access_token=config["access_token"])
+    print(f"Uploading Study for zones {', '.join(zone_mrids)} ...")
+    await eas_client.async_upload_study(
+        Study(
+            name=f"Asset attribute inconsistencies ({', '.join(zone_mrids)})",
+            description="Lines with missing length/impedance, transformers missing ratings/impedance, and switches missing normal state.",
+            tags=["dq_asset_attributes", "-".join(zone_mrids)],
+            results=results,
+            styles=styles,
+        )
+    )
+    await eas_client.aclose()
+    print("Uploaded Study")
+    print(f"Finish time: {datetime.now()}")
+
+
+def _connect_rpc(config):
+    return connect_with_token(
+        host=config["host"],
+        access_token=config["access_token"],
+        rpc_port=config["rpc_port"],
+        ca_filename=config.get("ca_filename"),
+        timeout_seconds=config.get("timeout_seconds", 5),
+        debug=bool(config.get("debug", False)),
+        skip_connection_test=bool(config.get("skip_connection_test", False)),
+    )
+
+
+def _collect_feeder_mrids(substations: Dict, zone_mrids: List[str]) -> List[str]:
+    feeder_mrids: List[str] = []
+    for zone_mrid in zone_mrids:
+        if zone_mrid in substations:
+            for feeder in substations[zone_mrid].feeders:
+                feeder_mrids.append(feeder.mrid)
+    return feeder_mrids
+
+
+async def _fetch_asset_inconsistencies(
+    feeder_mrid: str,
+    rpc_channel,
+) -> Tuple[Set[AcLineSegment], Set[AcLineSegment], Set[PowerTransformer], Set[PowerTransformer], Set[Switch]] | None:
+    print(f"Fetching Feeder {feeder_mrid}")
+    client = NetworkConsumerClient(rpc_channel)
+    result = await client.get_equipment_container(
+        mrid=feeder_mrid,
+        expected_class=Feeder,
+        include_energized_containers=IncludedEnergizedContainers.LV_FEEDERS,
+    )
+    if result.was_failure:
+        print(f"Failed: {result.thrown}")
+        return None
+
+    network = client.service
+    print(f"Finished fetching Feeder {feeder_mrid}")
+
+    return await analyze_network(network)
+
+
+async def analyze_network(
+    network,
+) -> Tuple[Set[AcLineSegment], Set[AcLineSegment], Set[PowerTransformer], Set[PowerTransformer], Set[Switch]]:
+    zero_length_lines = set()
+    missing_impedance_lines = set()
+    for line in network.objects(AcLineSegment):
+        if line_length_m(line) <= 0.0:
+            zero_length_lines.add(line)
+        if not _has_impedance(line):
+            missing_impedance_lines.add(line)
+
+    missing_rating_transformers = set()
+    missing_impedance_transformers = set()
+    for pt in network.objects(PowerTransformer):
+        if not _has_transformer_rating(pt):
+            missing_rating_transformers.add(pt)
+        if not _has_transformer_impedance(pt):
+            missing_impedance_transformers.add(pt)
+
+    missing_normal_state_switches = set()
+    for sw in network.objects(Switch):
+        if _normal_open_value(sw) is None:
+            missing_normal_state_switches.add(sw)
+
+    return zero_length_lines, missing_impedance_lines, missing_rating_transformers, missing_impedance_transformers, missing_normal_state_switches
+
+
+def _has_impedance(line: AcLineSegment) -> bool:
+    impedance_attrs = [
+        "per_length_sequence_impedance",
+        "per_length_phase_impedance",
+        "per_length_impedance",
+        "wire_info",
+        "ac_line_segment_wire_info",
+    ]
+    for attr in impedance_attrs:
+        value = getattr(line, attr, None)
+        if value is not None:
+            return True
+    for attr in ["r", "x", "r0", "x0"]:
+        value = getattr(line, attr, None)
+        if value not in (None, 0):
+            return True
+    return False
+
+
+def _has_transformer_rating(pt: PowerTransformer) -> bool:
+    ends = list(pt.ends)
+    for end in ends:
+        rated_s = getattr(end, "rated_s", None)
+        if rated_s and rated_s > 0:
+            return True
+        for rating in getattr(end, "s_ratings", []):
+            if rating and getattr(rating, "rated_s", None):
+                return True
+    return False
+
+
+def _has_transformer_impedance(pt: PowerTransformer) -> bool:
+    primary_end = _primary_transformer_end(pt)
+    if primary_end is None:
+        return False
+
+    for attr in ("r", "x", "r0", "x0"):
+        value = getattr(primary_end, attr, None)
+        if value not in (None, 0):
+            return True
+
+    star_impedance = getattr(primary_end, "star_impedance", None)
+    if star_impedance is not None:
+        rr = star_impedance.resistance_reactance()
+        if rr is not None and not rr.is_empty():
+            return True
+
+    power_transformer_info = getattr(pt, "power_transformer_info", None)
+    if power_transformer_info is not None and getattr(primary_end, "end_number", None) is not None:
+        rr = power_transformer_info.resistance_reactance(primary_end.end_number)
+        if rr is not None and not rr.is_empty():
+            return True
+
+    return False
+
+
+def _primary_transformer_end(pt: PowerTransformer):
+    ends = list(pt.ends)
+    if not ends:
+        return None
+    for end in ends:
+        if getattr(end, "end_number", None) == 1:
+            return end
+    return max(ends, key=_end_voltage)
+
+
+def _end_voltage(end) -> float:
+    try:
+        nominal = end.nominal_voltage
+    except Exception:
+        nominal = getattr(end, "rated_u", None)
+    if nominal is None:
+        base = getattr(end, "base_voltage", None)
+        nominal = getattr(base, "nominal_voltage", None) if base is not None else None
+    return float(nominal or 0.0)
+
+
+def _normal_open_value(sw: Switch):
+    if hasattr(sw, "is_normally_open"):
+        try:
+            return sw.is_normally_open()
+        except Exception:
+            return None
+    for attr in ["normally_open", "normal_open"]:
+        if hasattr(sw, attr):
+            return getattr(sw, attr)
+    return None
+
+
+def _build_line_result(
+    name: str,
+    lines: List[AcLineSegment],
+    style_ids: List[str],
+    issue: str,
+) -> Result | None:
+    if not lines:
+        return None
+    class_to_properties = {
+        AcLineSegment: {
+            "issue": lambda _: issue,
+            "name": lambda line: line.name or line.mrid,
+            "type": lambda _: "line",
+        }
+    }
+    feature_collection: FeatureCollection = to_geojson_feature_collection(lines, class_to_properties)
+    if not feature_collection.features:
+        return None
+    return Result(
+        name=name,
+        geo_json_overlay=GeoJsonOverlay(
+            data=feature_collection,
+            styles=style_ids,
+        ),
+    )
+
+
+def _build_transformer_result(
+    name: str,
+    transformers: List[PowerTransformer],
+    style_ids: List[str],
+    issue: str,
+) -> Result | None:
+    if not transformers:
+        return None
+    class_to_properties = {
+        PowerTransformer: {
+            "issue": lambda _: issue,
+            "name": lambda pt: pt.name or pt.mrid,
+            "type": lambda _: "pt",
+        }
+    }
+    feature_collection: FeatureCollection = to_geojson_feature_collection(transformers, class_to_properties)
+    if not feature_collection.features:
+        return None
+    return Result(
+        name=name,
+        geo_json_overlay=GeoJsonOverlay(
+            data=feature_collection,
+            styles=style_ids,
+        ),
+    )
+
+
+def _build_switch_result(
+    name: str,
+    switches: List[Switch],
+    style_ids: List[str],
+    issue: str,
+) -> Result | None:
+    if not switches:
+        return None
+    class_to_properties = {
+        Switch: {
+            "issue": lambda _: issue,
+            "name": lambda sw: sw.name or sw.mrid,
+            "type": lambda _: "switch",
+        }
+    }
+    feature_collection: FeatureCollection = to_geojson_feature_collection(switches, class_to_properties)
+    if not feature_collection.features:
+        return None
+    return Result(
+        name=name,
+        geo_json_overlay=GeoJsonOverlay(
+            data=feature_collection,
+            styles=style_ids,
+        ),
+    )
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/src/zepben/examples/studies/data_quality_studies/connectivity_gaps.py b/src/zepben/examples/studies/data_quality_studies/connectivity_gaps.py
new file mode 100644
index 0000000..e913c5d
--- /dev/null
+++ b/src/zepben/examples/studies/data_quality_studies/connectivity_gaps.py
@@ -0,0 +1,248 @@
+#  Copyright 2025 Zeppelin Bend Pty Ltd
+#
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+import asyncio
+import json
+from pathlib import Path
+from datetime import datetime
+from typing import Dict, List, Set, Tuple
+import sys
+
+from geojson import FeatureCollection
+from zepben.eas.client.eas_client import EasClient
+from zepben.eas.client.study import GeoJsonOverlay, Result, Study
+from zepben.ewb import (
+    AcLineSegment,
+    ConductingEquipment,
+    Feeder,
+    IncludedEnergizedContainers,
+    NetworkConsumerClient,
+    NetworkTraceStep,
+    PhaseCode,
+    Tracing,
+    connect_with_token,
+    stop_at_open,
+)
+
+from dq_utils import (
+    chunk,
+    get_zone_mrids,
+    load_config,
+    no_anomaly_feature_collection,
+    to_geojson_feature_collection,
+)
+
+
+async def main():
+    zone_mrids = get_zone_mrids(sys.argv, default=["CPM"])
+    print(f"Start time: {datetime.now()}")
+
+    config = load_config()
+    rpc_channel = _connect_rpc(config)
+    client = NetworkConsumerClient(rpc_channel)
+    hierarchy = (await client.get_network_hierarchy()).throw_on_error()
+
+    feeder_mrids = _collect_feeder_mrids(hierarchy.value.substations, zone_mrids)
+    print(f"Collecting feeders from zones {', '.join(zone_mrids)}.")
+    print(f"Feeders to be processed: {', '.join(feeder_mrids)}")
+
+    open_ended_lines: Set[AcLineSegment] = set()
+    disconnected_lines: Set[AcLineSegment] = set()
+
+    for feeders in chunk(feeder_mrids, 3):
+        rpc_channel = _connect_rpc(config)
+        for feeder_mrid in feeders:
+            result = await _fetch_connectivity_gaps(feeder_mrid, rpc_channel)
+            if result is None:
+                continue
+            feeder_open_ends, feeder_disconnected = result
+            open_ended_lines.update(feeder_open_ends)
+            disconnected_lines.update(feeder_disconnected)
+
+    style_path = Path(__file__).resolve().parent / "style_connectivity_gaps.json"
+    styles = json.load(open(style_path, "r"))
+    result_specs = [
+        (
+            "Open-ended line segments",
+            _build_line_result(
+                "Open-ended line segments",
+                list(open_ended_lines),
+                style_ids=["dq-open-ended-lines"],
+                issue="open_end",
+            ),
+        ),
+        (
+            "Disconnected island lines",
+            _build_line_result(
+                "Disconnected island lines",
+                list(disconnected_lines),
+                style_ids=["dq-disconnected-lines"],
+                issue="disconnected_island",
+            ),
+        ),
+    ]
+    results = []
+    for name, result in result_specs:
+        if result is not None:
+            results.append(result)
+        else:
+            results.append(
+                Result(
+                    name=f"No anomalies detected: {name}",
+                    geo_json_overlay=GeoJsonOverlay(
+                        data=no_anomaly_feature_collection(),
+                        styles=["dq-no-anomalies"],
+                    ),
+                )
+            )
+
+    eas_client = EasClient(host=config["host"], port=config["rpc_port"], protocol="https", access_token=config["access_token"])
+    print(f"Uploading Study for zones {', '.join(zone_mrids)} ...")
+    await eas_client.async_upload_study(
+        Study(
+            name=f"Connectivity gaps ({', '.join(zone_mrids)})",
+            description="Highlights open-ended lines and disconnected line islands.",
+            tags=["dq_connectivity_gaps", "-".join(zone_mrids)],
+            results=results,
+            styles=styles,
+        )
+    )
+    await eas_client.aclose()
+    print("Uploaded Study")
+    print(f"Finish time: {datetime.now()}")
+
+
+def _connect_rpc(config):
+    return connect_with_token(
+        host=config["host"],
+        access_token=config["access_token"],
+        rpc_port=config["rpc_port"],
+        ca_filename=config.get("ca_filename"),
+        timeout_seconds=config.get("timeout_seconds", 5),
+        debug=bool(config.get("debug", False)),
+        skip_connection_test=bool(config.get("skip_connection_test", False)),
+    )
+
+
+def _collect_feeder_mrids(substations: Dict, zone_mrids: List[str]) -> List[str]:
+    feeder_mrids: List[str] = []
+    for zone_mrid in zone_mrids:
+        if zone_mrid in substations:
+            for feeder in substations[zone_mrid].feeders:
+                feeder_mrids.append(feeder.mrid)
+    return feeder_mrids
+
+
+async def _fetch_connectivity_gaps(
+    feeder_mrid: str,
+    rpc_channel,
+) -> Tuple[Set[AcLineSegment], Set[AcLineSegment]] | None:
+    print(f"Fetching Feeder {feeder_mrid}")
+    client = NetworkConsumerClient(rpc_channel)
+    result = await client.get_equipment_container(
+        mrid=feeder_mrid,
+        expected_class=Feeder,
+        include_energized_containers=IncludedEnergizedContainers.LV_FEEDERS,
+    )
+    if result.was_failure:
+        print(f"Failed: {result.thrown}")
+        return None
+
+    network = client.service
+    print(f"Finished fetching Feeder {feeder_mrid}")
+
+    return await analyze_network(network, feeder_mrid)
+
+
+async def analyze_network(
+    network,
+    feeder_mrid: str,
+) -> Tuple[Set[AcLineSegment], Set[AcLineSegment]]:
+    node_to_equipment: Dict[object, Set[ConductingEquipment]] = {}
+    for ce in network.objects(ConductingEquipment):
+        for terminal in ce.terminals:
+            node = terminal.connectivity_node
+            if node is None:
+                continue
+            node_to_equipment.setdefault(node, set()).add(ce)
+
+    open_ended_lines = set()
+    for line in network.objects(AcLineSegment):
+        for terminal in line.terminals:
+            node = terminal.connectivity_node
+            if node and len(node_to_equipment.get(node, set())) == 1:
+                open_ended_lines.add(line)
+                break
+
+    disconnected_lines = await _disconnected_island_lines(network, feeder_mrid)
+    return open_ended_lines, disconnected_lines
+
+
+async def _disconnected_island_lines(network, feeder_mrid: str) -> Set[AcLineSegment]:
+    feeder_head = None
+    for feeder in network.objects(Feeder):
+        if feeder.mrid == feeder_mrid and feeder.normal_head_terminal:
+            feeder_head = feeder.normal_head_terminal.conducting_equipment
+            break
+    if feeder_head is None:
+        print(f"Feeder {feeder_mrid} has no normal head terminal; skipping disconnected island check.")
+        return set()
+
+    reachable: Set[ConductingEquipment] = set()
+
+    async def collect(ps: NetworkTraceStep, _):
+        if ps.path.from_equipment is not None:
+            reachable.add(ps.path.from_equipment)
+        if ps.path.to_equipment is not None:
+            reachable.add(ps.path.to_equipment)
+
+    await (
+        Tracing.network_trace()
+        .add_condition(stop_at_open())
+        .add_step_action(collect)
+    ).run(start=feeder_head, phases=PhaseCode.ABCN, can_stop_on_start_item=False)
+
+    feeder_lines = [
+        line for line in network.objects(AcLineSegment) if _belongs_to_feeder(line, feeder_mrid)
+    ]
+    reachable_lines = {eq for eq in reachable if isinstance(eq, AcLineSegment)}
+    return set(feeder_lines) - reachable_lines
+
+
+def _belongs_to_feeder(psr, feeder_mrid: str) -> bool:
+    feeders = getattr(psr, "normal_feeders", []) or []
+    return any(feeder.mrid == feeder_mrid for feeder in feeders)
+
+
+def _build_line_result(
+    name: str,
+    lines: List[AcLineSegment],
+    style_ids: List[str],
+    issue: str,
+) -> Result | None:
+    if not lines:
+        return None
+    class_to_properties = {
+        AcLineSegment: {
+            "issue": lambda _: issue,
+            "name": lambda line: line.name or line.mrid,
+            "type": lambda _: "line",
+        }
+    }
+    feature_collection: FeatureCollection = to_geojson_feature_collection(lines, class_to_properties)
+    if not feature_collection.features:
+        return None
+    return Result(
+        name=name,
+        geo_json_overlay=GeoJsonOverlay(
+            data=feature_collection,
+            styles=style_ids,
+        ),
+    )
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/src/zepben/examples/studies/data_quality_studies/consumer_mapping_issues.py b/src/zepben/examples/studies/data_quality_studies/consumer_mapping_issues.py
new file mode 100644
index 0000000..485b366
--- /dev/null
+++ b/src/zepben/examples/studies/data_quality_studies/consumer_mapping_issues.py
@@ -0,0 +1,312 @@
+#  Copyright 2025 Zeppelin Bend Pty Ltd
+#
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+import asyncio
+import json
+from pathlib import Path
+from datetime import datetime
+from typing import Dict, List, Set, Tuple
+import sys
+
+from geojson import FeatureCollection
+from zepben.eas.client.eas_client import EasClient
+from zepben.eas.client.study import GeoJsonOverlay, Result, Study
+from zepben.ewb import (
+    EnergyConsumer,
+    PowerTransformer,
+    Feeder,
+    IncludedEnergizedContainers,
+    NetworkConsumerClient,
+    NetworkTraceStep,
+    PhaseCode,
+    Tracing,
+    connect_with_token,
+    downstream,
+    stop_at_open,
+    upstream,
+)
+from zepben.ewb.services.network.tracing.networktrace.operators.network_state_operators import (
+    NetworkStateOperators,
+)
+
+from dq_utils import (
+    chunk,
+    get_zone_mrids,
+    load_config,
+    no_anomaly_feature_collection,
+    to_geojson_feature_collection,
+)
+
+
+async def main():
+    zone_mrids = get_zone_mrids(sys.argv, default=["CPM"])
+    print(f"Start time: {datetime.now()}")
+
+    config = load_config()
+    rpc_channel = _connect_rpc(config)
+    client = NetworkConsumerClient(rpc_channel)
+    hierarchy = (await client.get_network_hierarchy()).throw_on_error()
+    feeder_mrids = _collect_feeder_mrids(hierarchy.value.substations, zone_mrids)
+
+    print(f"Collecting feeders from zones {', '.join(zone_mrids)}.")
+    print(f"Feeders to be processed: {', '.join(feeder_mrids)}")
+
+    unserved_ecs: Set[EnergyConsumer] = set()
+    missing_lv_feeder_ecs: Set[EnergyConsumer] = set()
+    no_load_transformers: Set[PowerTransformer] = set()
+
+    for feeders in chunk(feeder_mrids, 3):
+        rpc_channel = _connect_rpc(config)
+        for feeder_mrid in feeders:
+            result = await _fetch_consumer_mapping_issues(feeder_mrid, rpc_channel)
+            if result is None:
+                continue
+            feeder_unserved, feeder_missing_lv, feeder_no_load = result
+            unserved_ecs.update(feeder_unserved)
+            missing_lv_feeder_ecs.update(feeder_missing_lv)
+            no_load_transformers.update(feeder_no_load)
+
+    style_path = Path(__file__).resolve().parent / "style_consumer_mapping.json"
+    styles = json.load(open(style_path, "r"))
+    result_specs = [
+        (
+            "Unserved EnergyConsumers",
+            _build_point_result(
+                "Unserved EnergyConsumers",
+                list(unserved_ecs),
+                style_ids=["dq-unserved-ec"],
+                issue="unserved",
+            ),
+        ),
+        (
+            "EnergyConsumers missing LV feeder container",
+            _build_point_result(
+                "EnergyConsumers missing LV feeder container",
+                list(missing_lv_feeder_ecs),
+                style_ids=["dq-missing-lv-feeder-ec"],
+                issue="missing_lv_feeder",
+            ),
+        ),
+        (
+            "Transformers with no downstream consumers",
+            _build_transformer_result(
+                "Transformers with no downstream consumers",
+                list(no_load_transformers),
+                style_ids=["dq-no-load-transformer"],
+                issue="no_downstream_consumers",
+            ),
+        ),
+    ]
+    results = []
+    for name, result in result_specs:
+        if result is not None:
+            results.append(result)
+        else:
+            results.append(
+                Result(
+                    name=f"No anomalies detected: {name}",
+                    geo_json_overlay=GeoJsonOverlay(
+                        data=no_anomaly_feature_collection(),
+                        styles=["dq-no-anomalies"],
+                    ),
+                )
+            )
+
+    eas_client = EasClient(host=config["host"], port=config["rpc_port"], protocol="https", access_token=config["access_token"])
+    print(f"Uploading Study for zones {', '.join(zone_mrids)} ...")
+    await eas_client.async_upload_study(
+        Study(
+            name=f"Consumer mapping issues ({', '.join(zone_mrids)})",
+            description="Unserved consumers, consumers missing LV feeder containers, and transformers with no downstream consumers.",
+            tags=["dq_consumer_mapping", "-".join(zone_mrids)],
+            results=results,
+            styles=styles,
+        )
+    )
+    await eas_client.aclose()
+    print("Uploaded Study")
+    print(f"Finish time: {datetime.now()}")
+
+
+def _connect_rpc(config):
+    return connect_with_token(
+        host=config["host"],
+        access_token=config["access_token"],
+        rpc_port=config["rpc_port"],
+        ca_filename=config.get("ca_filename"),
+        timeout_seconds=config.get("timeout_seconds", 5),
+        debug=bool(config.get("debug", False)),
+        skip_connection_test=bool(config.get("skip_connection_test", False)),
+    )
+
+
+def _collect_feeder_mrids(substations: Dict, zone_mrids: List[str]) -> List[str]:
+    feeder_mrids: List[str] = []
+    for zone_mrid in zone_mrids:
+        if zone_mrid in substations:
+            for feeder in substations[zone_mrid].feeders:
+                feeder_mrids.append(feeder.mrid)
+    return feeder_mrids
+
+
+async def _fetch_consumer_mapping_issues(
+    feeder_mrid: str,
+    rpc_channel,
+) -> Tuple[Set[EnergyConsumer], Set[EnergyConsumer], Set[PowerTransformer]] | None:
+    print(f"Fetching Feeder {feeder_mrid}")
+    client = NetworkConsumerClient(rpc_channel)
+    result = await client.get_equipment_container(
+        mrid=feeder_mrid,
+        expected_class=Feeder,
+        include_energized_containers=IncludedEnergizedContainers.LV_FEEDERS,
+    )
+    if result.was_failure:
+        print(f"Failed: {result.thrown}")
+        return None
+
+    network = client.service
+    print(f"Finished fetching Feeder {feeder_mrid}")
+
+    return await analyze_network(network, feeder_mrid)
+
+
+async def analyze_network(
+    network,
+    feeder_mrid: str,
+) -> Tuple[Set[EnergyConsumer], Set[EnergyConsumer], Set[PowerTransformer]]:
+    await Tracing.set_direction().run(network, network_state_operators=NetworkStateOperators.NORMAL)
+
+    unserved_ecs: Set[EnergyConsumer] = set()
+    missing_lv_feeder_ecs: Set[EnergyConsumer] = set()
+
+    for ec in network.objects(EnergyConsumer):
+        if not _has_lv_feeder_container(ec):
+            missing_lv_feeder_ecs.add(ec)
+        if not await _has_upstream_transformer(ec):
+            unserved_ecs.add(ec)
+
+    no_load_transformers: Set[PowerTransformer] = set()
+    for pt in network.objects(PowerTransformer):
+        if not _belongs_to_feeder(pt, feeder_mrid):
+            continue
+        downstream_eq = await _get_downstream_eq(pt)
+        if not any(isinstance(eq, EnergyConsumer) for eq in downstream_eq):
+            no_load_transformers.add(pt)
+
+    return unserved_ecs, missing_lv_feeder_ecs, no_load_transformers
+
+
+async def _has_upstream_transformer(ec: EnergyConsumer) -> bool:
+    found = False
+
+    async def mark_transformer(ps: NetworkTraceStep, _):
+        nonlocal found
+        if isinstance(ps.path.to_equipment, PowerTransformer):
+            found = True
+
+    await (
+        Tracing.network_trace()
+        .add_condition(upstream())
+        .add_condition(stop_at_open())
+        .add_step_action(mark_transformer)
+        .add_stop_condition(_is_transformer)
+    ).run(start=ec, phases=PhaseCode.ABCN, can_stop_on_start_item=False)
+
+    return found
+
+
+def _is_transformer(ps: NetworkTraceStep, _context=None) -> bool:
+    return isinstance(ps.path.to_equipment, PowerTransformer)
+
+
+async def _get_downstream_eq(pt: PowerTransformer) -> Set[object]:
+    nodes: Set[object] = {pt}
+    adjacency: Dict[object, Set[object]] = {}
+
+    async def collect_edges(ps: NetworkTraceStep, _):
+        nodes.add(ps.path.from_equipment)
+        nodes.add(ps.path.to_equipment)
+        if ps.path.traced_externally:
+            adjacency.setdefault(ps.path.from_equipment, set()).add(ps.path.to_equipment)
+
+    await (
+        Tracing.network_trace()
+        .add_condition(downstream())
+        .add_step_action(collect_edges)
+    ).run(start=pt, phases=PhaseCode.ABCN, can_stop_on_start_item=False)
+
+    return nodes
+
+
+def _has_lv_feeder_container(ec: EnergyConsumer) -> bool:
+    return any(True for _ in ec.normal_lv_feeders)
+
+
+def _belongs_to_feeder(psr, feeder_mrid: str) -> bool:
+    if any(feeder.mrid == feeder_mrid for feeder in psr.normal_feeders):
+        return True
+    for lv_feeder in psr.normal_lv_feeders:
+        if any(feeder.mrid == feeder_mrid for feeder in lv_feeder.normal_energizing_feeders):
+            return True
+    return False
+
+
+def _build_point_result(
+    name: str,
+    ecs: List[EnergyConsumer],
+    style_ids: List[str],
+    issue: str,
+) -> Result | None:
+    if not ecs:
+        return None
+    class_to_properties = {
+        EnergyConsumer: {
+            "issue": lambda _: issue,
+            "name": lambda ec: ec.name or ec.mrid,
+            "type": lambda _: "ec",
+        }
+    }
+    feature_collection: FeatureCollection = to_geojson_feature_collection(ecs, class_to_properties)
+    if not feature_collection.features:
+        return None
+    return Result(
+        name=name,
+        geo_json_overlay=GeoJsonOverlay(
+            data=feature_collection,
+            styles=style_ids,
+        ),
+    )
+
+
+def _build_transformer_result(
+    name: str,
+    transformers: List[PowerTransformer],
+    style_ids: List[str],
+    issue: str,
+) -> Result | None:
+    if not transformers:
+        return None
+    class_to_properties = {
+        PowerTransformer: {
+            "issue": lambda _: issue,
+            "name": lambda pt: pt.name or pt.mrid,
+            "type": lambda _: "pt",
+        }
+    }
+    feature_collection: FeatureCollection = to_geojson_feature_collection(transformers, class_to_properties)
+    if not feature_collection.features:
+        return None
+    return Result(
+        name=name,
+        geo_json_overlay=GeoJsonOverlay(
+            data=feature_collection,
+            styles=style_ids,
+        ),
+    )
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/src/zepben/examples/studies/data_quality_studies/data_quality_summary.py b/src/zepben/examples/studies/data_quality_studies/data_quality_summary.py
new file mode 100644
index 0000000..a3f20f5
--- /dev/null
+++ b/src/zepben/examples/studies/data_quality_studies/data_quality_summary.py
@@ -0,0 +1,446 @@
+#  Copyright 2025 Zeppelin Bend Pty Ltd
+#
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+import asyncio
+import json
+import sys
+import time
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, List, Set, Tuple
+
+from zepben.eas.client.eas_client import EasClient
+from zepben.eas.client.study import Study
+from zepben.ewb import (
+    Feeder,
+    IncludedEnergizedContainers,
+    NetworkConsumerClient,
+    connect_with_token,
+)
+
+import asset_attribute_inconsistencies as aa
+import connectivity_gaps as cg
+import consumer_mapping_issues as cm
+import phase_conductor_issues as pc
+import protection_directionality_anomalies as pd
+import spatial_location_anomalies as sl
+from dq_utils import chunk, get_zone_mrids, load_config
+
+BATCH_SIZE = 4
+
+
+async def main():
+    zone_mrids = get_zone_mrids(sys.argv, default=["CPM"])
+    print(f"Start time: {datetime.now()}")
+
+    config = load_config()
+    rpc_channel = _connect_rpc(config)
+    client = NetworkConsumerClient(rpc_channel)
+    hierarchy = (await client.get_network_hierarchy()).throw_on_error()
+
+    feeder_mrids = _collect_feeder_mrids(hierarchy.value.substations, zone_mrids)
+    print(f"Collecting feeders from zones {', '.join(zone_mrids)}.")
+    print(f"Feeders to be processed: {', '.join(feeder_mrids)}")
+
+    open_ended_lines: Set = set()
+    disconnected_lines: Set = set()
+    unserved_ecs: Set = set()
+    missing_lv_feeder_ecs: Set = set()
+    no_load_transformers: Set = set()
+    phase_mismatch_features: List = []
+    missing_phase_lines: Set = set()
+    zero_length_lines: Set = set()
+    missing_impedance_lines: Set = set()
+    missing_rating_transformers: Set = set()
+    missing_impedance_transformers: Set = set()
+    missing_normal_state_switches: Set = set()
+    loop_lines: Set = set()
+    switch_terminal_issues: Set = set()
+    long_service_ecs: Set = set()
+    ec_to_distance: Dict[str, float] = {}
+    very_long_lines: Set = set()
+
+    for feeders in chunk(feeder_mrids, BATCH_SIZE):
+        rpc_channel = _connect_rpc(config)
+        tasks = [
+            asyncio.create_task(_process_feeder(feeder_mrid, rpc_channel))
+            for feeder_mrid in feeders
+        ]
+        for result in await asyncio.gather(*tasks):
+            if result is None:
+                continue
+            open_ended_lines.update(result["open_ended_lines"])
+            disconnected_lines.update(result["disconnected_lines"])
+            unserved_ecs.update(result["unserved_ecs"])
+            missing_lv_feeder_ecs.update(result["missing_lv_feeder_ecs"])
+            no_load_transformers.update(result["no_load_transformers"])
+            phase_mismatch_features.extend(result["phase_mismatch_features"])
+            missing_phase_lines.update(result["missing_phase_lines"])
+            zero_length_lines.update(result["zero_length_lines"])
+            missing_impedance_lines.update(result["missing_impedance_lines"])
+            missing_rating_transformers.update(result["missing_rating_transformers"])
+            missing_impedance_transformers.update(result["missing_impedance_transformers"])
+            missing_normal_state_switches.update(result["missing_normal_state_switches"])
+            loop_lines.update(result["loop_lines"])
+            switch_terminal_issues.update(result["switch_terminal_issues"])
+            long_service_ecs.update(result["long_service_ecs"])
+            ec_to_distance.update(result["ec_to_distance"])
+            very_long_lines.update(result["very_long_lines"])
+
+    results, detected_tests, used_style_ids = _build_results(
+        open_ended_lines,
+        disconnected_lines,
+        unserved_ecs,
+        missing_lv_feeder_ecs,
+        no_load_transformers,
+        phase_mismatch_features,
+        missing_phase_lines,
+        zero_length_lines,
+        missing_impedance_lines,
+        missing_rating_transformers,
+        missing_impedance_transformers,
+        missing_normal_state_switches,
+        loop_lines,
+        switch_terminal_issues,
+        long_service_ecs,
+        ec_to_distance,
+        very_long_lines,
+    )
+
+    if not results:
+        print("No anomalies detected across all tests. Study upload skipped.")
+        return
+
+    styles = _load_styles(used_style_ids)
+    description = _description_from_tests(detected_tests)
+    tags = [_slugify(test) for test in detected_tests]
+
+    eas_client = EasClient(host=config["host"], port=config["rpc_port"], protocol="https", access_token=config["access_token"])
+    print(f"Uploading Study for zones {', '.join(zone_mrids)} ...")
+    await eas_client.async_upload_study(
+        Study(
+            name=f"Data quality summary ({', '.join(zone_mrids)})",
+            description=description,
+            tags=tags,
+            results=results,
+            styles=styles,
+        )
+    )
+    await eas_client.aclose()
+    print("Uploaded Study")
+    print(f"Finish time: {datetime.now()}")
+
+
+def _connect_rpc(config):
+    return connect_with_token(
+        host=config["host"],
+        access_token=config["access_token"],
+        rpc_port=config["rpc_port"],
+        ca_filename=config.get("ca_filename"),
+        timeout_seconds=config.get("timeout_seconds", 5),
+        debug=bool(config.get("debug", False)),
+        skip_connection_test=bool(config.get("skip_connection_test", False)),
+    )
+
+
+def _collect_feeder_mrids(substations: Dict, zone_mrids: List[str]) -> List[str]:
+    feeder_mrids: List[str] = []
+    for zone_mrid in zone_mrids:
+        if zone_mrid in substations:
+            for feeder in substations[zone_mrid].feeders:
+                feeder_mrids.append(feeder.mrid)
+    return feeder_mrids
+
+
+async def _fetch_feeder_network(feeder_mrid: str, rpc_channel):
+    print(f"Fetching Feeder {feeder_mrid}")
+    start = time.perf_counter()
+    client = NetworkConsumerClient(rpc_channel)
+    result = await client.get_equipment_container(
+        mrid=feeder_mrid,
+        expected_class=Feeder,
+        include_energized_containers=IncludedEnergizedContainers.LV_FEEDERS,
+    )
+    if result.was_failure:
+        print(f"Failed: {result.thrown}")
+        return None
+    elapsed = time.perf_counter() - start
+    print(f"Finished fetching Feeder {feeder_mrid} ({elapsed:.2f}s)")
+    return client.service
+
+
+async def _process_feeder(feeder_mrid: str, rpc_channel):
+    feeder_start = time.perf_counter()
+    network = await _fetch_feeder_network(feeder_mrid, rpc_channel)
+    if network is None:
+        return None
+
+    async def timed(label: str, coro):
+        start = time.perf_counter()
+        result = await coro
+        elapsed = time.perf_counter() - start
+        print(f"[{feeder_mrid}] {label}: {elapsed:.2f}s")
+        return result
+
+    feeder_open, feeder_disconnected = await timed(
+        "connectivity_gaps",
+        cg.analyze_network(network, feeder_mrid),
+    )
+    feeder_unserved, feeder_missing_lv, feeder_no_load = await timed(
+        "consumer_mapping",
+        cm.analyze_network(network, feeder_mrid),
+    )
+    mismatch_features, missing_lines = await timed(
+        "phase_conductor",
+        pc.analyze_network(network),
+    )
+    z_lines, i_lines, t_missing, t_imp_missing, s_missing = await timed(
+        "asset_attributes",
+        aa.analyze_network(network),
+    )
+    loop_segments, switch_issues = await timed(
+        "protection_directionality",
+        pd.analyze_network(network),
+    )
+    feeder_ecs, feeder_distances, feeder_lines = await timed(
+        "spatial_location",
+        sl.analyze_network(network),
+    )
+
+    total = time.perf_counter() - feeder_start
+    print(f"[{feeder_mrid}] total: {total:.2f}s")
+
+    return {
+        "open_ended_lines": feeder_open,
+        "disconnected_lines": feeder_disconnected,
+        "unserved_ecs": feeder_unserved,
+        "missing_lv_feeder_ecs": feeder_missing_lv,
+        "no_load_transformers": feeder_no_load,
+        "phase_mismatch_features": mismatch_features,
+        "missing_phase_lines": missing_lines,
+        "zero_length_lines": z_lines,
+        "missing_impedance_lines": i_lines,
+        "missing_rating_transformers": t_missing,
+        "missing_impedance_transformers": t_imp_missing,
+        "missing_normal_state_switches": s_missing,
+        "loop_lines": loop_segments,
+        "switch_terminal_issues": switch_issues,
+        "long_service_ecs": feeder_ecs,
+        "ec_to_distance": feeder_distances,
+        "very_long_lines": feeder_lines,
+    }
+
+
+def _build_results(
+    open_ended_lines: Set,
+    disconnected_lines: Set,
+    unserved_ecs: Set,
+    missing_lv_feeder_ecs: Set,
+    no_load_transformers: Set,
+    phase_mismatch_features: List,
+    missing_phase_lines: Set,
+    zero_length_lines: Set,
+    missing_impedance_lines: Set,
+    missing_rating_transformers: Set,
+    missing_impedance_transformers: Set,
+    missing_normal_state_switches: Set,
+    loop_lines: Set,
+    switch_terminal_issues: Set,
+    long_service_ecs: Set,
+    ec_to_distance: Dict[str, float],
+    very_long_lines: Set,
+) -> Tuple[List, List[str], Set[str]]:
+    results = []
+    detected_tests: List[str] = []
+    used_style_ids: Set[str] = set()
+
+    def add_result(name: str, result):
+        if result is None:
+            return
+        results.append(result)
+        detected_tests.append(name)
+        used_style_ids.update(result.geo_json_overlay.styles)
+
+    add_result(
+        "Open-ended line segments",
+        cg._build_line_result(
+            "Open-ended line segments",
+            list(open_ended_lines),
+            style_ids=["dq-open-ended-lines"],
+            issue="open_end",
+        ),
+    )
+    add_result(
+        "Disconnected island lines",
+        cg._build_line_result(
+            "Disconnected island lines",
+            list(disconnected_lines),
+            style_ids=["dq-disconnected-lines"],
+            issue="disconnected_island",
+        ),
+    )
+    add_result(
+        "Unserved EnergyConsumers",
+        cm._build_point_result(
+            "Unserved EnergyConsumers",
+            list(unserved_ecs),
+            style_ids=["dq-unserved-ec"],
+            issue="unserved",
+        ),
+    )
+    add_result(
+        "EnergyConsumers missing LV feeder container",
+        cm._build_point_result(
+            "EnergyConsumers missing LV feeder container",
+            list(missing_lv_feeder_ecs),
+            style_ids=["dq-missing-lv-feeder-ec"],
+            issue="missing_lv_feeder",
+        ),
+    )
+    add_result(
+        "Transformers with no downstream consumers",
+        cm._build_transformer_result(
+            "Transformers with no downstream consumers",
+            list(no_load_transformers),
+            style_ids=["dq-no-load-transformer"],
+            issue="no_downstream_consumers",
+        ),
+    )
+    add_result(
+        "Phase mismatch at nodes",
+        pc._build_feature_result(
+            "Phase mismatch at nodes",
+            phase_mismatch_features,
+            style_ids=["dq-phase-mismatch-node"],
+        ),
+    )
+    add_result(
+        "Lines missing phase information",
+        pc._build_line_result(
+            "Lines missing phase information",
+            list(missing_phase_lines),
+            style_ids=["dq-missing-phase-lines"],
+        ),
+    )
+    add_result(
+        "Zero-length line segments",
+        aa._build_line_result(
+            "Zero-length line segments",
+            list(zero_length_lines),
+            style_ids=["dq-zero-length-lines"],
+            issue="zero_length",
+        ),
+    )
+    add_result(
+        "Line segments missing impedance info",
+        aa._build_line_result(
+            "Line segments missing impedance info",
+            list(missing_impedance_lines),
+            style_ids=["dq-missing-impedance-lines"],
+            issue="missing_impedance",
+        ),
+    )
+    add_result(
+        "Transformers missing rating",
+        aa._build_transformer_result(
+            "Transformers missing rating",
+            list(missing_rating_transformers),
+            style_ids=["dq-missing-rating-transformer"],
+            issue="missing_rating",
+        ),
+    )
+    add_result(
+        "Transformers missing impedance",
+        aa._build_transformer_result(
+            "Transformers missing impedance",
+            list(missing_impedance_transformers),
+            style_ids=["dq-missing-impedance-transformer"],
+            issue="missing_transformer_impedance",
+        ),
+    )
+    add_result(
+        "Switches missing normal state",
+        aa._build_switch_result(
+            "Switches missing normal state",
+            list(missing_normal_state_switches),
+            style_ids=["dq-missing-normal-state-switch"],
+            issue="missing_normal_state",
+        ),
+    )
+    add_result(
+        "Loops without switches",
+        pd._build_line_result(
+            "Loops without switches",
+            list(loop_lines),
+            style_ids=["dq-loop-no-switch"],
+            issue="loop_without_switch",
+        ),
+    )
+    add_result(
+        "Switch terminal anomalies",
+        pd._build_switch_result(
+            "Switch terminal anomalies",
+            list(switch_terminal_issues),
+            style_ids=["dq-switch-terminal-issue"],
+            issue="switch_terminal_issue",
+        ),
+    )
+    add_result(
+        "Long service drops",
+        sl._build_ec_distance_result(
+            "Long service drops",
+            list(long_service_ecs),
+            ec_to_distance,
+            style_ids=["dq-long-service-drop"],
+        ),
+    )
+    add_result(
+        "Very long line segments",
+        sl._build_line_result(
+            "Very long line segments",
+            list(very_long_lines),
+            style_ids=["dq-very-long-lines"],
+            issue="very_long_line",
+        ),
+    )
+
+    return results, detected_tests, used_style_ids
+
+
+def _load_styles(used_style_ids: Set[str]) -> List[Dict]:
+    style_dir = Path(__file__).resolve().parent
+    style_files = [
+        style_dir / "style_connectivity_gaps.json",
+        style_dir / "style_consumer_mapping.json",
+        style_dir / "style_phase_conductor.json",
+        style_dir / "style_asset_attribute.json",
+        style_dir / "style_protection_directionality.json",
+        style_dir / "style_spatial_location.json",
+    ]
+    style_map: Dict[str, Dict] = {}
+    for style_file in style_files:
+        styles = json.load(open(style_file, "r"))
+        for style in styles:
+            if style.get("id") in used_style_ids:
+                style_map[style["id"]] = style
+    return list(style_map.values())
+
+
+def _description_from_tests(detected_tests: List[str]) -> str:
+    if not detected_tests:
+        return "No anomalies detected."
+    return "Detected anomalies: " + ", ".join(detected_tests)
+
+
+def _slugify(text: str) -> str:
+    cleaned = "".join(ch.lower() if ch.isalnum() else "_" for ch in text).strip("_")
+    while "__" in cleaned:
+        cleaned = cleaned.replace("__", "_")
+    return cleaned
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/src/zepben/examples/studies/data_quality_studies/dq_utils.py b/src/zepben/examples/studies/data_quality_studies/dq_utils.py
new file mode 100644
index 0000000..fd92ca3
--- /dev/null
+++ b/src/zepben/examples/studies/data_quality_studies/dq_utils.py
@@ -0,0 +1,118 @@
+#  Copyright 2025 Zeppelin Bend Pty Ltd
+#
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+from pathlib import Path
+from typing import Any, Callable, Dict, Iterable, List, Optional, Type, Union
+import json
+
+from geojson import Feature, FeatureCollection
+from geojson.geometry import Geometry, LineString, Point
+from zepben.ewb import Location, PowerSystemResource
+
+
+CONFIG_PATH = Path(__file__).resolve().parents[2] / "config.json"
+
+
+def load_config() -> Dict[str, Any]:
+    with open(CONFIG_PATH, "r") as f:
+        return json.loads(f.read())
+
+
+def get_zone_mrids(argv: List[str], default: Optional[List[str]] = None) -> List[str]:
+    if len(argv) > 1:
+        zones = [z.strip() for z in argv[1].split(",") if z.strip()]
+        if zones:
+            return zones
+    return default or []
+
+
+def chunk(it: Iterable[Any], size: int):
+    it = iter(it)
+    return iter(lambda: tuple(_take(it, size)), ())
+
+
+def _take(it: Iterable[Any], size: int):
+    items = []
+    for _ in range(size):
+        try:
+            items.append(next(it))
+        except StopIteration:
+            break
+    return items
+
+
+def line_length_m(line) -> float:
+    return float(getattr(line, "length", 0.0) or 0.0)
+
+
+def terminal_phase_code(terminal) -> Optional[Any]:
+    phases = getattr(terminal, "normal_phases", None) or getattr(terminal, "phases", None)
+    if phases is None:
+        return None
+    if hasattr(phases, "as_phase_code"):
+        return phases.as_phase_code()
+    return phases
+
+
+def to_geojson_feature_collection(
+    psrs: List[PowerSystemResource],
+    class_to_properties: Dict[Type, Dict[str, Callable[[Any], Any]]],
+) -> FeatureCollection:
+    features = []
+    for psr in psrs:
+        properties_map = class_to_properties.get(type(psr))
+        if properties_map is None:
+            continue
+        feature = to_geojson_feature(psr, properties_map)
+        if feature is not None:
+            features.append(feature)
+    return FeatureCollection(features)
+
+
+def to_geojson_feature(
+    psr: PowerSystemResource,
+    property_map: Dict[str, Callable[[PowerSystemResource], Any]],
+) -> Union[Feature, None]:
+    geometry = to_geojson_geometry(getattr(psr, "location", None))
+    if geometry is None:
+        return None
+    properties = {k: f(psr) for (k, f) in property_map.items()}
+    return Feature(psr.mrid, geometry, properties)
+
+
+def to_geojson_geometry(location: Location) -> Union[Geometry, None]:
+    points = list(location.points) if location is not None else []
+    if len(points) > 1:
+        return LineString([(point.x_position, point.y_position) for point in points])
+    if len(points) == 1:
+        return Point((points[0].x_position, points[0].y_position))
+    return None
+
+
+def feature_from_location(
+    feature_id: str,
+    location: Location,
+    properties: Dict[str, Any],
+) -> Optional[Feature]:
+    geometry = to_geojson_geometry(location)
+    if geometry is None:
+        return None
+    return Feature(feature_id, geometry, properties)
+
+
+def point_feature(
+    feature_id: str,
+    x: float,
+    y: float,
+    properties: Dict[str, Any],
+) -> Feature:
+    return Feature(feature_id, Point((x, y)), properties)
+
+
+def no_anomaly_feature_collection(message: str = "No anomalies detected") -> FeatureCollection:
+    return FeatureCollection(
+        [Feature("no-anomalies", Point((0.0, 0.0)), {"message": message, "type": "no_anomalies"})]
+    )
diff --git a/src/zepben/examples/studies/data_quality_studies/phase_conductor_issues.py b/src/zepben/examples/studies/data_quality_studies/phase_conductor_issues.py
new file mode 100644
index 0000000..a4d3af5
--- /dev/null
+++ b/src/zepben/examples/studies/data_quality_studies/phase_conductor_issues.py
@@ -0,0 +1,256 @@
+#  Copyright 2025 Zeppelin Bend Pty Ltd
+#
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+import asyncio
+import json
+from pathlib import Path
+from datetime import datetime
+from typing import Dict, List, Set, Tuple
+import sys
+
+from geojson import FeatureCollection
+from zepben.eas.client.eas_client import EasClient
+from zepben.eas.client.study import GeoJsonOverlay, Result, Study
+from zepben.ewb import (
+    AcLineSegment,
+    ConductingEquipment,
+    Feeder,
+    IncludedEnergizedContainers,
+    NetworkConsumerClient,
+    connect_with_token,
+)
+
+from dq_utils import (
+    chunk,
+    get_zone_mrids,
+    load_config,
+    no_anomaly_feature_collection,
+    point_feature,
+    terminal_phase_code,
+    to_geojson_feature_collection,
+)
+
+
+async def main():
+    zone_mrids = get_zone_mrids(sys.argv, default=["CPM"])
+    print(f"Start time: {datetime.now()}")
+
+    config = load_config()
+    rpc_channel = _connect_rpc(config)
+    client = NetworkConsumerClient(rpc_channel)
+    hierarchy = (await client.get_network_hierarchy()).throw_on_error()
+    feeder_mrids = _collect_feeder_mrids(hierarchy.value.substations, zone_mrids)
+
+    print(f"Collecting feeders from zones {', '.join(zone_mrids)}.")
+    print(f"Feeders to be processed: {', '.join(feeder_mrids)}")
+
+    phase_mismatch_features = []
+    missing_phase_lines: Set[AcLineSegment] = set()
+
+    for feeders in chunk(feeder_mrids, 3):
+        rpc_channel = _connect_rpc(config)
+        for feeder_mrid in feeders:
+            result = await _fetch_phase_issues(feeder_mrid, rpc_channel)
+            if result is None:
+                continue
+            mismatch_features, missing_lines = result
+            phase_mismatch_features.extend(mismatch_features)
+            missing_phase_lines.update(missing_lines)
+
+    style_path = Path(__file__).resolve().parent / "style_phase_conductor.json"
+    styles = json.load(open(style_path, "r"))
+    result_specs = [
+        (
+            "Phase mismatch at nodes",
+            _build_feature_result(
+                "Phase mismatch at nodes",
+                phase_mismatch_features,
+                style_ids=["dq-phase-mismatch-node"],
+            ),
+        ),
+        (
+            "Lines missing phase information",
+            _build_line_result(
+                "Lines missing phase information",
+                list(missing_phase_lines),
+                style_ids=["dq-missing-phase-lines"],
+            ),
+        ),
+    ]
+    results = []
+    for name, result in result_specs:
+        if result is not None:
+            results.append(result)
+        else:
+            results.append(
+                Result(
+                    name=f"No anomalies detected: {name}",
+                    geo_json_overlay=GeoJsonOverlay(
+                        data=no_anomaly_feature_collection(),
+                        styles=["dq-no-anomalies"],
+                    ),
+                )
+            )
+
+    eas_client = EasClient(host=config["host"], port=config["rpc_port"], protocol="https", access_token=config["access_token"])
+    print(f"Uploading Study for zones {', '.join(zone_mrids)} ...")
+    await eas_client.async_upload_study(
+        Study(
+            name=f"Phase and conductor issues ({', '.join(zone_mrids)})",
+            description="Connectivity nodes with mixed phases and lines missing phase info.",
+            tags=["dq_phase_conductor", "-".join(zone_mrids)],
+            results=results,
+            styles=styles,
+        )
+    )
+    await eas_client.aclose()
+    print("Uploaded Study")
+    print(f"Finish time: {datetime.now()}")
+
+
+def _connect_rpc(config):
+    return connect_with_token(
+        host=config["host"],
+        access_token=config["access_token"],
+        rpc_port=config["rpc_port"],
+        ca_filename=config.get("ca_filename"),
+        timeout_seconds=config.get("timeout_seconds", 5),
+        debug=bool(config.get("debug", False)),
+        skip_connection_test=bool(config.get("skip_connection_test", False)),
+    )
+
+
+def _collect_feeder_mrids(substations: Dict, zone_mrids: List[str]) -> List[str]:
+    feeder_mrids: List[str] = []
+    for zone_mrid in zone_mrids:
+        if zone_mrid in substations:
+            for feeder in substations[zone_mrid].feeders:
+                feeder_mrids.append(feeder.mrid)
+    return feeder_mrids
+
+
+async def _fetch_phase_issues(
+    feeder_mrid: str,
+    rpc_channel,
+) -> Tuple[List, Set[AcLineSegment]] | None:
+    print(f"Fetching Feeder {feeder_mrid}")
+    client = NetworkConsumerClient(rpc_channel)
+    result = await client.get_equipment_container(
+        mrid=feeder_mrid,
+        expected_class=Feeder,
+        include_energized_containers=IncludedEnergizedContainers.LV_FEEDERS,
+    )
+    if result.was_failure:
+        print(f"Failed: {result.thrown}")
+        return None
+
+    network = client.service
+    print(f"Finished fetching Feeder {feeder_mrid}")
+
+    return await analyze_network(network)
+
+
+async def analyze_network(
+    network,
+) -> Tuple[List, Set[AcLineSegment]]:
+    node_to_terminals: Dict[object, List[object]] = {}
+    node_to_equipment: Dict[object, ConductingEquipment] = {}
+    for ce in network.objects(ConductingEquipment):
+        for terminal in ce.terminals:
+            node = terminal.connectivity_node
+            if node is None:
+                continue
+            node_to_terminals.setdefault(node, []).append(terminal)
+            node_to_equipment.setdefault(node, ce)
+
+    phase_mismatch_features = []
+    for node, terminals in node_to_terminals.items():
+        phase_codes = []
+        for terminal in terminals:
+            phase_code = terminal_phase_code(terminal)
+            if phase_code is not None:
+                phase_codes.append(str(phase_code))
+        unique_phases = sorted(set(phase_codes))
+        if len(unique_phases) > 1:
+            equipment = node_to_equipment.get(node)
+            if equipment is None or equipment.location is None:
+                continue
+            points = list(equipment.location.points)
+            if not points:
+                continue
+            pt = points[0]
+            feature = point_feature(
+                f"phase-mismatch-{getattr(node, 'mrid', id(node))}",
+                pt.x_position,
+                pt.y_position,
+                {
+                    "issue": "phase_mismatch",
+                    "phases": ", ".join(unique_phases),
+                    "type": "node",
+                },
+            )
+            phase_mismatch_features.append(feature)
+
+    missing_phase_lines: Set[AcLineSegment] = set()
+    for line in network.objects(AcLineSegment):
+        terminal_phases = []
+        for terminal in line.terminals:
+            phase_code = terminal_phase_code(terminal)
+            if phase_code is not None:
+                terminal_phases.append(phase_code)
+        if not terminal_phases:
+            missing_phase_lines.add(line)
+
+    return phase_mismatch_features, missing_phase_lines
+
+
+def _build_feature_result(
+    name: str,
+    features: List,
+    style_ids: List[str],
+) -> Result | None:
+    if not features:
+        return None
+    feature_collection = FeatureCollection(features)
+    if not feature_collection.features:
+        return None
+    return Result(
+        name=name,
+        geo_json_overlay=GeoJsonOverlay(
+            data=feature_collection,
+            styles=style_ids,
+        ),
+    )
+
+
+def _build_line_result(
+    name: str,
+    lines: List[AcLineSegment],
+    style_ids: List[str],
+) -> Result | None:
+    if not lines:
+        return None
+    class_to_properties = {
+        AcLineSegment: {
+            "issue": lambda _: "missing_phase",
+            "name": lambda line: line.name or line.mrid,
+            "type": lambda _: "line",
+        }
+    }
+    feature_collection: FeatureCollection = to_geojson_feature_collection(lines, class_to_properties)
+    if not feature_collection.features:
+        return None
+    return Result(
+        name=name,
+        geo_json_overlay=GeoJsonOverlay(
+            data=feature_collection,
+            styles=style_ids,
+        ),
+    )
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/src/zepben/examples/studies/data_quality_studies/protection_directionality_anomalies.py b/src/zepben/examples/studies/data_quality_studies/protection_directionality_anomalies.py
new file mode 100644
index 0000000..c5a2746
--- /dev/null
+++ b/src/zepben/examples/studies/data_quality_studies/protection_directionality_anomalies.py
@@ -0,0 +1,286 @@
+#  Copyright 2025 Zeppelin Bend Pty Ltd
+#
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+import asyncio
+import json
+from pathlib import Path
+from datetime import datetime
+from typing import Dict, List, Set, Tuple
+import sys
+
+from geojson import FeatureCollection
+from zepben.eas.client.eas_client import EasClient
+from zepben.eas.client.study import GeoJsonOverlay, Result, Study
+from zepben.ewb import (
+    AcLineSegment,
+    Feeder,
+    IncludedEnergizedContainers,
+    NetworkConsumerClient,
+    Switch,
+    connect_with_token,
+)
+
+from dq_utils import (
+    chunk,
+    get_zone_mrids,
+    load_config,
+    no_anomaly_feature_collection,
+    to_geojson_feature_collection,
+)
+
+
+async def main():
+    zone_mrids = get_zone_mrids(sys.argv, default=["CPM"])
+    print(f"Start time: {datetime.now()}")
+
+    config = load_config()
+    rpc_channel = _connect_rpc(config)
+    client = NetworkConsumerClient(rpc_channel)
+    hierarchy = (await client.get_network_hierarchy()).throw_on_error()
+    feeder_mrids = _collect_feeder_mrids(hierarchy.value.substations, zone_mrids)
+
+    print(f"Collecting feeders from zones {', '.join(zone_mrids)}.")
+    print(f"Feeders to be processed: {', '.join(feeder_mrids)}")
+
+    loop_lines: Set[AcLineSegment] = set()
+    switch_terminal_issues: Set[Switch] = set()
+
+    for feeders in chunk(feeder_mrids, 3):
+        rpc_channel = _connect_rpc(config)
+        for feeder_mrid in feeders:
+            result = await _fetch_protection_directionality_issues(feeder_mrid, rpc_channel)
+            if result is None:
+                continue
+            loop_segments, switch_issues = result
+            loop_lines.update(loop_segments)
+            switch_terminal_issues.update(switch_issues)
+
+    style_path = Path(__file__).resolve().parent / "style_protection_directionality.json"
+    styles = json.load(open(style_path, "r"))
+    result_specs = [
+        (
+            "Loops without switches",
+            _build_line_result(
+                "Loops without switches",
+                list(loop_lines),
+                style_ids=["dq-loop-no-switch"],
+                issue="loop_without_switch",
+            ),
+        ),
+        (
+            "Switch terminal anomalies",
+            _build_switch_result(
+                "Switch terminal anomalies",
+                list(switch_terminal_issues),
+                style_ids=["dq-switch-terminal-issue"],
+                issue="switch_terminal_issue",
+            ),
+        ),
+    ]
+    results = []
+    for name, result in result_specs:
+        if result is not None:
+            results.append(result)
+        else:
+            results.append(
+                Result(
+                    name=f"No anomalies detected: {name}",
+                    geo_json_overlay=GeoJsonOverlay(
+                        data=no_anomaly_feature_collection(),
+                        styles=["dq-no-anomalies"],
+                    ),
+                )
+            )
+
+    eas_client = EasClient(host=config["host"], port=config["rpc_port"], protocol="https", access_token=config["access_token"])
+    print(f"Uploading Study for zones {', '.join(zone_mrids)} ...")
+    await eas_client.async_upload_study(
+        Study(
+            name=f"Protection and directionality anomalies ({', '.join(zone_mrids)})",
+            description="Loops without switches and switch terminal count anomalies.",
+            tags=["dq_protection_directionality", "-".join(zone_mrids)],
+            results=results,
+            styles=styles,
+        )
+    )
+    await eas_client.aclose()
+    print("Uploaded Study")
+    print(f"Finish time: {datetime.now()}")
+
+
+def _connect_rpc(config):
+    return connect_with_token(
+        host=config["host"],
+        access_token=config["access_token"],
+        rpc_port=config["rpc_port"],
+        ca_filename=config.get("ca_filename"),
+        timeout_seconds=config.get("timeout_seconds", 5),
+        debug=bool(config.get("debug", False)),
+        skip_connection_test=bool(config.get("skip_connection_test", False)),
+    )
+
+
+def _collect_feeder_mrids(substations: Dict, zone_mrids: List[str]) -> List[str]:
+    feeder_mrids: List[str] = []
+    for zone_mrid in zone_mrids:
+        if zone_mrid in substations:
+            for feeder in substations[zone_mrid].feeders:
+                feeder_mrids.append(feeder.mrid)
+    return feeder_mrids
+
+
+async def _fetch_protection_directionality_issues(
+    feeder_mrid: str,
+    rpc_channel,
+) -> Tuple[Set[AcLineSegment], Set[Switch]] | None:
+    print(f"Fetching Feeder {feeder_mrid}")
+    client = NetworkConsumerClient(rpc_channel)
+    result = await client.get_equipment_container(
+        mrid=feeder_mrid,
+        expected_class=Feeder,
+        include_energized_containers=IncludedEnergizedContainers.LV_FEEDERS,
+    )
+    if result.was_failure:
+        print(f"Failed: {result.thrown}")
+        return None
+
+    network = client.service
+    print(f"Finished fetching Feeder {feeder_mrid}")
+
+    return await analyze_network(network)
+
+
+async def analyze_network(
+    network,
+) -> Tuple[Set[AcLineSegment], Set[Switch]]:
+    loop_lines = _find_loops_without_switch(network)
+
+    switch_terminal_issues = set()
+    for sw in network.objects(Switch):
+        terminals = [t for t in sw.terminals if t.connectivity_node is not None]
+        if len(terminals) != 2:
+            switch_terminal_issues.add(sw)
+
+    return loop_lines, switch_terminal_issues
+
+
+def _find_loops_without_switch(network) -> Set[AcLineSegment]:
+    lines = list(network.objects(AcLineSegment))
+    if not lines:
+        return set()
+
+    parent = {}
+
+    def find(node):
+        if node not in parent:
+            parent[node] = node
+        while parent[node] != node:
+            parent[node] = parent[parent[node]]
+            node = parent[node]
+        return node
+
+    def union(a, b):
+        ra = find(a)
+        rb = find(b)
+        if ra != rb:
+            parent[rb] = ra
+
+    line_nodes: Dict[AcLineSegment, Tuple[object, object]] = {}
+    for line in lines:
+        nodes = [t.connectivity_node for t in line.terminals if t.connectivity_node is not None]
+        if len(nodes) < 2:
+            continue
+        n1, n2 = nodes[0], nodes[1]
+        line_nodes[line] = (n1, n2)
+        union(n1, n2)
+
+    component_edges: Dict[object, int] = {}
+    component_nodes: Dict[object, Set[object]] = {}
+    component_lines: Dict[object, Set[AcLineSegment]] = {}
+    for line, (n1, n2) in line_nodes.items():
+        root = find(n1)
+        component_edges[root] = component_edges.get(root, 0) + 1
+        component_nodes.setdefault(root, set()).update([n1, n2])
+        component_lines.setdefault(root, set()).add(line)
+
+    component_has_switch: Dict[object, bool] = {root: False for root in component_nodes}
+    for sw in network.objects(Switch):
+        for terminal in sw.terminals:
+            node = terminal.connectivity_node
+            if node is None:
+                continue
+            root = find(node)
+            if root in component_has_switch:
+                component_has_switch[root] = True
+
+    loop_lines: Set[AcLineSegment] = set()
+    for root, edges in component_edges.items():
+        nodes = component_nodes.get(root, set())
+        if not nodes:
+            continue
+        if edges >= len(nodes) and not component_has_switch.get(root, False):
+            loop_lines.update(component_lines.get(root, set()))
+
+    return loop_lines
+
+
+def _build_line_result(
+    name: str,
+    lines: List[AcLineSegment],
+    style_ids: List[str],
+    issue: str,
+) -> Result | None:
+    if not lines:
+        return None
+    class_to_properties = {
+        AcLineSegment: {
+            "issue": lambda _: issue,
+            "name": lambda line: line.name or line.mrid,
+            "type": lambda _: "line",
+        }
+    }
+    feature_collection: FeatureCollection = to_geojson_feature_collection(lines, class_to_properties)
+    if not feature_collection.features:
+        return None
+    return Result(
+        name=name,
+        geo_json_overlay=GeoJsonOverlay(
+            data=feature_collection,
+            styles=style_ids,
+        ),
+    )
+
+
+def _build_switch_result(
+    name: str,
+    switches: List[Switch],
+    style_ids: List[str],
+    issue: str,
+) -> Result | None:
+    if not switches:
+        return None
+    class_to_properties = {
+        Switch: {
+            "issue": lambda _: issue,
+            "name": lambda sw: sw.name or sw.mrid,
+            "type": lambda _: "switch",
+            "terminal_count": lambda sw: len([t for t in sw.terminals if t.connectivity_node is not None]),
+        }
+    }
+    feature_collection: FeatureCollection = to_geojson_feature_collection(switches, class_to_properties)
+    if not feature_collection.features:
+        return None
+    return Result(
+        name=name,
+        geo_json_overlay=GeoJsonOverlay(
+            data=feature_collection,
+            styles=style_ids,
+        ),
+    )
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/src/zepben/examples/studies/data_quality_studies/spatial_location_anomalies.py b/src/zepben/examples/studies/data_quality_studies/spatial_location_anomalies.py
new file mode 100644
index 0000000..697e8bc
--- /dev/null
+++ b/src/zepben/examples/studies/data_quality_studies/spatial_location_anomalies.py
@@ -0,0 +1,281 @@
+#  Copyright 2025 Zeppelin Bend Pty Ltd
+#
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+import asyncio
+import json
+from pathlib import Path
+from datetime import datetime
+from typing import Dict, List, Set, Tuple
+import sys
+
+from geojson import FeatureCollection
+from zepben.eas.client.eas_client import EasClient
+from zepben.eas.client.study import GeoJsonOverlay, Result, Study
+from zepben.ewb import (
+    AcLineSegment,
+    EnergyConsumer,
+    Feeder,
+    IncludedEnergizedContainers,
+    NetworkConsumerClient,
+    NetworkTraceStep,
+    PhaseCode,
+    PowerTransformer,
+    Tracing,
+    connect_with_token,
+    stop_at_open,
+    upstream,
+)
+from zepben.ewb.services.network.tracing.networktrace.operators.network_state_operators import (
+    NetworkStateOperators,
+)
+
+from dq_utils import (
+    chunk,
+    get_zone_mrids,
+    line_length_m,
+    load_config,
+    no_anomaly_feature_collection,
+    to_geojson_feature_collection,
+)
+
+
+LONG_SERVICE_DROP_M = 500.0
+VERY_LONG_LINE_M = 2000.0
+
+
+async def main():
+    zone_mrids = get_zone_mrids(sys.argv, default=["CPM"])
+    print(f"Start time: {datetime.now()}")
+
+    config = load_config()
+    rpc_channel = _connect_rpc(config)
+    client = NetworkConsumerClient(rpc_channel)
+    hierarchy = (await client.get_network_hierarchy()).throw_on_error()
+    feeder_mrids = _collect_feeder_mrids(hierarchy.value.substations, zone_mrids)
+
+    print(f"Collecting feeders from zones {', '.join(zone_mrids)}.")
+    print(f"Feeders to be processed: {', '.join(feeder_mrids)}")
+
+    long_service_ecs: Set[EnergyConsumer] = set()
+    ec_to_distance: Dict[str, float] = {}
+    very_long_lines: Set[AcLineSegment] = set()
+
+    for feeders in chunk(feeder_mrids, 3):
+        rpc_channel = _connect_rpc(config)
+        for feeder_mrid in feeders:
+            result = await _fetch_spatial_anomalies(feeder_mrid, rpc_channel)
+            if result is None:
+                continue
+            feeder_ecs, feeder_distances, feeder_lines = result
+            long_service_ecs.update(feeder_ecs)
+            ec_to_distance.update(feeder_distances)
+            very_long_lines.update(feeder_lines)
+
+    style_path = Path(__file__).resolve().parent / "style_spatial_location.json"
+    styles = json.load(open(style_path, "r"))
+    result_specs = [
+        (
+            "Long service drops",
+            _build_ec_distance_result(
+                "Long service drops",
+                list(long_service_ecs),
+                ec_to_distance,
+                style_ids=["dq-long-service-drop"],
+            ),
+        ),
+        (
+            "Very long line segments",
+            _build_line_result(
+                "Very long line segments",
+                list(very_long_lines),
+                style_ids=["dq-very-long-lines"],
+                issue="very_long_line",
+            ),
+        ),
+    ]
+    results = []
+    for name, result in result_specs:
+        if result is not None:
+            results.append(result)
+        else:
+            results.append(
+                Result(
+                    name=f"No anomalies detected: {name}",
+                    geo_json_overlay=GeoJsonOverlay(
+                        data=no_anomaly_feature_collection(),
+                        styles=["dq-no-anomalies"],
+                    ),
+                )
+            )
+
+    eas_client = EasClient(host=config["host"], port=config["rpc_port"], protocol="https", access_token=config["access_token"])
+    print(f"Uploading Study for zones {', '.join(zone_mrids)} ...")
+    await eas_client.async_upload_study(
+        Study(
+            name=f"Spatial/location anomalies ({', '.join(zone_mrids)})",
+            description="Long service drops and unusually long line segments.",
+            tags=["dq_spatial_location", "-".join(zone_mrids)],
+            results=results,
+            styles=styles,
+        )
+    )
+    await eas_client.aclose()
+    print("Uploaded Study")
+    print(f"Finish time: {datetime.now()}")
+
+
+def _connect_rpc(config):
+    return connect_with_token(
+        host=config["host"],
+        access_token=config["access_token"],
+        rpc_port=config["rpc_port"],
+        ca_filename=config.get("ca_filename"),
+        timeout_seconds=config.get("timeout_seconds", 5),
+        debug=bool(config.get("debug", False)),
+        skip_connection_test=bool(config.get("skip_connection_test", False)),
+    )
+
+
+def _collect_feeder_mrids(substations: Dict, zone_mrids: List[str]) -> List[str]:
+    feeder_mrids: List[str] = []
+    for zone_mrid in zone_mrids:
+        if zone_mrid in substations:
+            for feeder in substations[zone_mrid].feeders:
+                feeder_mrids.append(feeder.mrid)
+    return feeder_mrids
+
+
+async def _fetch_spatial_anomalies(
+    feeder_mrid: str,
+    rpc_channel,
+) -> Tuple[Set[EnergyConsumer], Dict[str, float], Set[AcLineSegment]] | None:
+    print(f"Fetching Feeder {feeder_mrid}")
+    client = NetworkConsumerClient(rpc_channel)
+    result = await client.get_equipment_container(
+        mrid=feeder_mrid,
+        expected_class=Feeder,
+        include_energized_containers=IncludedEnergizedContainers.LV_FEEDERS,
+    )
+    if result.was_failure:
+        print(f"Failed: {result.thrown}")
+        return None
+
+    network = client.service
+    print(f"Finished fetching Feeder {feeder_mrid}")
+
+    return await analyze_network(network)
+
+
+async def analyze_network(
+    network,
+) -> Tuple[Set[EnergyConsumer], Dict[str, float], Set[AcLineSegment]]:
+    await Tracing.set_direction().run(network, network_state_operators=NetworkStateOperators.NORMAL)
+
+    long_service_ecs: Set[EnergyConsumer] = set()
+    ec_to_distance: Dict[str, float] = {}
+    for ec in network.objects(EnergyConsumer):
+        path_lines = await _get_upstream_lines_to_transformer(ec)
+        distance = sum(line_length_m(line) for line in path_lines)
+        ec_to_distance[ec.mrid] = distance
+        if distance >= LONG_SERVICE_DROP_M:
+            long_service_ecs.add(ec)
+
+    very_long_lines = {line for line in network.objects(AcLineSegment) if line_length_m(line) >= VERY_LONG_LINE_M}
+
+    return long_service_ecs, ec_to_distance, very_long_lines
+
+
+async def _get_upstream_lines_to_transformer(ec: EnergyConsumer) -> Set[AcLineSegment]:
+    lines = set()
+
+    async def collect_lines(ps: NetworkTraceStep, _):
+        line = ps.path.traversed_ac_line_segment
+        if line is not None:
+            lines.add(line)
+        if isinstance(ps.path.to_equipment, AcLineSegment):
+            lines.add(ps.path.to_equipment)
+        if isinstance(ps.path.from_equipment, AcLineSegment):
+            lines.add(ps.path.from_equipment)
+
+    await (
+        Tracing.network_trace()
+        .add_condition(upstream())
+        .add_condition(stop_at_open())
+        .add_step_action(collect_lines)
+        .add_stop_condition(_is_transformer)
+    ).run(start=ec, phases=PhaseCode.ABCN, can_stop_on_start_item=False)
+
+    return lines
+
+
+def _is_transformer(ps: NetworkTraceStep, _context=None) -> bool:
+    return isinstance(ps.path.to_equipment, PowerTransformer)
+
+
+def _build_ec_distance_result(
+    name: str,
+    ecs: List[EnergyConsumer],
+    ec_to_distance: Dict[str, float],
+    style_ids: List[str],
+) -> Result | None:
+    if not ecs:
+        return None
+
+    def distance(ec: EnergyConsumer) -> float:
+        return float(ec_to_distance.get(ec.mrid, 0.0))
+
+    def label(ec: EnergyConsumer) -> str:
+        value = distance(ec)
+        return f"{value:.0f} m" if value > 0 else "n/a"
+
+    class_to_properties = {
+        EnergyConsumer: {
+            "distance_m": distance,
+            "distance_label": label,
+            "type": lambda _: "ec",
+        }
+    }
+    feature_collection: FeatureCollection = to_geojson_feature_collection(ecs, class_to_properties)
+    if not feature_collection.features:
+        return None
+    return Result(
+        name=name,
+        geo_json_overlay=GeoJsonOverlay(
+            data=feature_collection,
+            styles=style_ids,
+        ),
+    )
+
+
+def _build_line_result(
+    name: str,
+    lines: List[AcLineSegment],
+    style_ids: List[str],
+    issue: str,
+) -> Result | None:
+    if not lines:
+        return None
+    class_to_properties = {
+        AcLineSegment: {
+            "issue": lambda _: issue,
+            "name": lambda line: line.name or line.mrid,
+            "type": lambda _: "line",
+        }
+    }
+    feature_collection: FeatureCollection = to_geojson_feature_collection(lines, class_to_properties)
+    if not feature_collection.features:
+        return None
+    return Result(
+        name=name,
+        geo_json_overlay=GeoJsonOverlay(
+            data=feature_collection,
+            styles=style_ids,
+        ),
+    )
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/src/zepben/examples/studies/data_quality_studies/style_asset_attribute.json b/src/zepben/examples/studies/data_quality_studies/style_asset_attribute.json
new file mode 100644
index 0000000..e9091b7
--- /dev/null
+++ b/src/zepben/examples/studies/data_quality_studies/style_asset_attribute.json
@@ -0,0 +1,63 @@
+[
+  {
+    "id": "dq-zero-length-lines",
+    "name": "Zero-length line segments",
+    "type": "line",
+    "paint": {
+      "line-color": "rgb(210,2,29)",
+      "line-width": 2
+    }
+  },
+  {
+    "id": "dq-missing-impedance-lines",
+    "name": "Lines missing impedance",
+    "type": "line",
+    "paint": {
+      "line-color": "rgb(244,109,67)",
+      "line-width": 2
+    }
+  },
+  {
+    "id": "dq-missing-rating-transformer",
+    "name": "Transformers missing rating",
+    "type": "circle",
+    "paint": {
+      "circle-radius": 8,
+      "circle-color": "rgb(94,79,162)",
+      "circle-stroke-color": "white",
+      "circle-stroke-width": 1
+    }
+  },
+  {
+    "id": "dq-missing-impedance-transformer",
+    "name": "Transformers missing impedance",
+    "type": "circle",
+    "paint": {
+      "circle-radius": 8,
+      "circle-color": "rgb(253,174,97)",
+      "circle-stroke-color": "white",
+      "circle-stroke-width": 1
+    }
+  },
+  {
+    "id": "dq-missing-normal-state-switch",
+    "name": "Switches missing normal state",
+    "type": "circle",
+    "paint": {
+      "circle-radius": 6,
+      "circle-color": "rgb(44,123,182)",
+      "circle-stroke-color": "white",
+      "circle-stroke-width": 1
+    }
+  },
+  {
+    "id": "dq-no-anomalies",
+    "name": "No anomalies detected",
+    "type": "circle",
+    "paint": {
+      "circle-radius": 1,
+      "circle-opacity": 0,
+      "circle-stroke-opacity": 0
+    }
+  }
+]
diff --git a/src/zepben/examples/studies/data_quality_studies/style_connectivity_gaps.json b/src/zepben/examples/studies/data_quality_studies/style_connectivity_gaps.json
new file mode 100644
index 0000000..6ba6104
--- /dev/null
+++ b/src/zepben/examples/studies/data_quality_studies/style_connectivity_gaps.json
@@ -0,0 +1,30 @@
+[
+  {
+    "id": "dq-open-ended-lines",
+    "name": "Open-ended lines",
+    "type": "line",
+    "paint": {
+      "line-color": "rgb(210,2,29)",
+      "line-width": 2
+    }
+  },
+  {
+    "id": "dq-disconnected-lines",
+    "name": "Disconnected island lines",
+    "type": "line",
+    "paint": {
+      "line-color": "rgb(244,109,67)",
+      "line-width": 2
+    }
+  },
+  {
+    "id": "dq-no-anomalies",
+    "name": "No anomalies detected",
+    "type": "circle",
+    "paint": {
+      "circle-radius": 1,
+      "circle-opacity": 0,
+      "circle-stroke-opacity": 0
+    }
+  }
+]
diff --git a/src/zepben/examples/studies/data_quality_studies/style_consumer_mapping.json b/src/zepben/examples/studies/data_quality_studies/style_consumer_mapping.json
new file mode 100644
index 0000000..73dd6f1
--- /dev/null
+++ b/src/zepben/examples/studies/data_quality_studies/style_consumer_mapping.json
@@ -0,0 +1,45 @@
+[
+  {
+    "id": "dq-unserved-ec",
+    "name": "Unserved EnergyConsumers",
+    "type": "circle",
+    "paint": {
+      "circle-radius": 6,
+      "circle-color": "rgb(210,2,29)",
+      "circle-stroke-color": "white",
+      "circle-stroke-width": 1
+    }
+  },
+  {
+    "id": "dq-missing-lv-feeder-ec",
+    "name": "EnergyConsumers missing LV feeder",
+    "type": "circle",
+    "paint": {
+      "circle-radius": 6,
+      "circle-color": "rgb(244,109,67)",
+      "circle-stroke-color": "white",
+      "circle-stroke-width": 1
+    }
+  },
+  {
+    "id": "dq-no-load-transformer",
+    "name": "Transformers with no downstream consumers",
+    "type": "circle",
+    "paint": {
+      "circle-radius": 9,
+      "circle-color": "rgb(44,123,182)",
+      "circle-stroke-color": "white",
+      "circle-stroke-width": 1
+    }
+  },
+  {
+    "id": "dq-no-anomalies",
+    "name": "No anomalies detected",
+    "type": "circle",
+    "paint": {
+      "circle-radius": 1,
+      "circle-opacity": 0,
+      "circle-stroke-opacity": 0
+    }
+  }
+]
diff --git a/src/zepben/examples/studies/data_quality_studies/style_phase_conductor.json b/src/zepben/examples/studies/data_quality_studies/style_phase_conductor.json
new file mode 100644
index 0000000..062bd33
--- /dev/null
+++ b/src/zepben/examples/studies/data_quality_studies/style_phase_conductor.json
@@ -0,0 +1,32 @@
+[
+  {
+    "id": "dq-phase-mismatch-node",
+    "name": "Phase mismatch nodes",
+    "type": "circle",
+    "paint": {
+      "circle-radius": 7,
+      "circle-color": "rgb(158,1,66)",
+      "circle-stroke-color": "white",
+      "circle-stroke-width": 1
+    }
+  },
+  {
+    "id": "dq-missing-phase-lines",
+    "name": "Lines missing phase info",
+    "type": "line",
+    "paint": {
+      "line-color": "rgb(210,2,29)",
+      "line-width": 2
+    }
+  },
+  {
+    "id": "dq-no-anomalies",
+    "name": "No anomalies detected",
+    "type": "circle",
+    "paint": {
+      "circle-radius": 1,
+      "circle-opacity": 0,
+      "circle-stroke-opacity": 0
+    }
+  }
+]
diff --git a/src/zepben/examples/studies/data_quality_studies/style_protection_directionality.json b/src/zepben/examples/studies/data_quality_studies/style_protection_directionality.json
new file mode 100644
index 0000000..4c76e44
--- /dev/null
+++ b/src/zepben/examples/studies/data_quality_studies/style_protection_directionality.json
@@ -0,0 +1,32 @@
+[
+  {
+    "id": "dq-loop-no-switch",
+    "name": "Loops without switches",
+    "type": "line",
+    "paint": {
+      "line-color": "rgb(210,2,29)",
+      "line-width": 2
+    }
+  },
+  {
+    "id": "dq-switch-terminal-issue",
+    "name": "Switch terminal anomalies",
+    "type": "circle",
+    "paint": {
+      "circle-radius": 7,
+      "circle-color": "rgb(244,109,67)",
+      "circle-stroke-color": "white",
+      "circle-stroke-width": 1
+    }
+  },
+  {
+    "id": "dq-no-anomalies",
+    "name": "No anomalies detected",
+    "type": "circle",
+    "paint": {
+      "circle-radius": 1,
+      "circle-opacity": 0,
+      "circle-stroke-opacity": 0
+    }
+  }
+]
diff --git a/src/zepben/examples/studies/data_quality_studies/style_spatial_location.json b/src/zepben/examples/studies/data_quality_studies/style_spatial_location.json
new file mode 100644
index 0000000..f78faef
--- /dev/null
+++ b/src/zepben/examples/studies/data_quality_studies/style_spatial_location.json
@@ -0,0 +1,38 @@
+[
+  {
+    "id": "dq-long-service-drop",
+    "name": "Long service drops",
+    "type": "circle",
+    "paint": {
+      "circle-radius": 7,
+      "circle-color": [
+        "step",
+        ["get", "distance_m"],
+        "rgb(244,109,67)", 500,
+        "rgb(210,2,29)", 1000,
+        "rgb(165,0,38)"
+      ],
+      "circle-stroke-color": "white",
+      "circle-stroke-width": 1
+    }
+  },
+  {
+    "id": "dq-very-long-lines",
+    "name": "Very long lines",
+    "type": "line",
+    "paint": {
+      "line-color": "rgb(94,79,162)",
+      "line-width": 2
+    }
+  },
+  {
+    "id": "dq-no-anomalies",
+    "name": "No anomalies detected",
+    "type": "circle",
+    "paint": {
+      "circle-radius": 1,
+      "circle-opacity": 0,
+      "circle-stroke-opacity": 0
+    }
+  }
+]
diff --git a/src/zepben/examples/studies/feeder_tie_switches.py b/src/zepben/examples/studies/feeder_tie_switches.py
new file mode 100644
index 0000000..1139d34
--- /dev/null
+++ b/src/zepben/examples/studies/feeder_tie_switches.py
@@ -0,0 +1,887 @@
+#  Copyright 2026 Zeppelin Bend Pty Ltd
+#
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+import argparse
+import asyncio
+import csv
+import json
+import os
+import sys
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from itertools import islice
+from typing import Any, Dict, List, Optional, Sequence, Set, Tuple, Union
+
+from geojson import Feature, FeatureCollection
+from geojson.geometry import Geometry, LineString, Point
+from zepben.eas.client.eas_client import EasClient
+from zepben.eas.client.study import GeoJsonOverlay, Result, Study
+from zepben.ewb import (
+    Feeder,
+    IncludedEnergizedContainers,
+    Location,
+    NetworkConsumerClient,
+    PowerSystemResource,
+    Switch,
+    connect_with_token,
+)
+
+
+DEFAULT_CONFIG_PATH = os.path.normpath(os.path.join(os.path.dirname(__file__), "..", "config.json"))
+DEFAULT_BATCH_SIZE = 3
+CSV_FIELDNAMES = [
+    "switch_mrid",
+    "name",
+    "type",
+    "is_tie",
+    "tie_class",
+    "tie_type",
+    "tie_type_label",
+    "container_count",
+    "container_ids",
+    "normal_container_ids",
+    "current_container_ids",
+    "lv_parent_container_ids",
+    "mv_container_count",
+    "mv_container_ids",
+    "lv_circuit_count",
+    "lv_circuit_ids",
+    "normal_lv_circuit_ids",
+    "current_lv_circuit_ids",
+    "observed_container_ids",
+    "observed_container_count",
+    "terminal_count",
+    "is_open",
+    "is_normally_open",
+    "include_lv_mode",
+    "scope_mode",
+    "scope_label",
+    "generated_at_utc",
+]
+
+
+@dataclass
+class SwitchEvidence:
+    switch: Switch
+    source_feeder_mrids: Set[str] = field(default_factory=set)
+
+
+def chunk(it, size):
+    it = iter(it)
+    return iter(lambda: tuple(islice(it, size)), ())
+
+
+def _connect_rpc(config):
+    return connect_with_token(
+        host=config["host"],
+        access_token=config["access_token"],
+        rpc_port=config["rpc_port"],
+        ca_filename=config.get("ca_filename"),
+        timeout_seconds=config.get("timeout_seconds", 5),
+        debug=bool(config.get("debug", False)),
+        skip_connection_test=bool(config.get("skip_connection_test", False)),
+    )
+
+
+async def main():
+    (
+        zone_mrids,
+        feeder_mrids,
+        mode,
+        config_path,
+        include_lv,
+        full_network_list,
+        csv_output,
+    ) = _parse_args(sys.argv[1:])
+    with open(config_path, "r") as f:
+        config = json.loads(f.read())
+
+    print(f"Start time: {datetime.now()}")
+
+    rpc_channel = _connect_rpc(config)
+
+    if mode in ("zones", "full-network"):
+        client = NetworkConsumerClient(rpc_channel)
+        hierarchy = (await client.get_network_hierarchy()).throw_on_error()
+        substations = hierarchy.value.substations
+
+        if mode == "zones":
+            feeder_mrids = _collect_feeder_mrids(substations, zone_mrids)
+            print(f"Collecting feeders from zones {', '.join(zone_mrids)}.")
+        else:
+            if full_network_list == "zones":
+                zone_mrids = _collect_all_zone_mrids(substations)
+                feeder_mrids = _collect_feeder_mrids(substations, zone_mrids)
+                print(
+                    "Full-network mode (zones): "
+                    f"resolved {len(zone_mrids)} zones and {len(feeder_mrids)} feeders."
+                )
+            else:
+                feeder_mrids = _collect_all_feeder_mrids(substations)
+                print(f"Full-network mode (feeders): resolved {len(feeder_mrids)} feeders.")
+    else:
+        print(f"Running for feeders {', '.join(feeder_mrids)}.")
+
+    if not feeder_mrids:
+        print("No feeders resolved for the requested scope. Nothing to process.")
+        return
+
+    print(f"Feeders to be processed: {', '.join(feeder_mrids)}")
+    print(f"LV inclusion: {'enabled' if include_lv else 'disabled (MV-only)'}")
+
+    switch_evidence_by_mrid: Dict[str, SwitchEvidence] = {}
+    failed_feeder_requests: List[str] = []
+
+    for feeders in chunk(feeder_mrids, DEFAULT_BATCH_SIZE):
+        rpc_channel = _connect_rpc(config)
+        print(f"Processing feeders {', '.join(feeders)}")
+        futures_by_feeder = {
+            feeder_mrid: asyncio.ensure_future(
+                _fetch_feeder_switch_evidence(
+                    feeder_mrid=feeder_mrid,
+                    rpc_channel=rpc_channel,
+                    include_lv=include_lv,
+                )
+            )
+            for feeder_mrid in feeders
+        }
+
+        for feeder_mrid, future in futures_by_feeder.items():
+            try:
+                feeder_switches = await future
+            except Exception as error:
+                print(f"Failed feeder {feeder_mrid}: {error}")
+                failed_feeder_requests.append(feeder_mrid)
+                continue
+
+            if feeder_switches is None:
+                failed_feeder_requests.append(feeder_mrid)
+                continue
+
+            _merge_switch_evidence(switch_evidence_by_mrid, feeder_switches)
+
+    failed_feeder_request_count = len(failed_feeder_requests)
+    succeeded_feeder_request_count = len(feeder_mrids) - failed_feeder_request_count
+    failed_feeder_mrids = sorted(set(failed_feeder_requests))
+
+    print(
+        "Feeder fetch summary: "
+        f"succeeded={succeeded_feeder_request_count}, "
+        f"failed={failed_feeder_request_count}, "
+        f"total={len(feeder_mrids)}"
+    )
+    if failed_feeder_mrids:
+        print(
+            f"Failed feeder MRIDs ({len(failed_feeder_mrids)} unique): "
+            f"{', '.join(failed_feeder_mrids)}"
+        )
+
+    print(f"Unique switches considered: {len(switch_evidence_by_mrid)}")
+
+    switch_to_properties: Dict[str, Dict[str, Any]] = {}
+    tie_switches: List[Switch] = []
+
+    tie_count = 0
+
+    for evidence in switch_evidence_by_mrid.values():
+        props = _build_tie_properties(evidence, include_lv)
+        if props.get("tie_class") != "feeder_tie":
+            continue
+
+        tie_count += 1
+        tie_switches.append(evidence.switch)
+
+        switch_to_properties[evidence.switch.mrid] = props
+
+    print(f"Detected feeder ties: {tie_count}")
+
+    if mode == "zones":
+        scope_label = ", ".join(zone_mrids)
+        scope_tag = "-".join(zone_mrids)
+    elif mode == "feeders":
+        scope_label = ", ".join(feeder_mrids)
+        scope_tag = "-".join(feeder_mrids)
+    else:
+        scope_label = f"full-network ({full_network_list})"
+        scope_tag = f"full-network-{full_network_list}"
+
+    lv_tag = "mv_lv" if include_lv else "mv_only"
+    csv_report_path = _resolve_csv_report_path(csv_output, scope_tag, lv_tag)
+    csv_rows = _build_csv_rows(switch_to_properties, mode, scope_label)
+    _write_tie_csv_report(csv_report_path, csv_rows)
+    print(f"Wrote tie switch CSV report: {csv_report_path} ({len(csv_rows)} rows)")
+
+    mv_mv_tie_switches = [
+        sw
+        for sw in tie_switches
+        if switch_to_properties.get(sw.mrid, {}).get("tie_type") == "mv_mv_tie"
+    ]
+    mv_lv_tie_switches = [
+        sw
+        for sw in tie_switches
+        if switch_to_properties.get(sw.mrid, {}).get("tie_type") == "mv_lv_tie"
+    ]
+    mv_via_lv_tie_switches = [
+        sw
+        for sw in tie_switches
+        if switch_to_properties.get(sw.mrid, {}).get("tie_type") == "mv_via_lv_tie"
+    ]
+    lv_lv_tie_switches = [
+        sw
+        for sw in tie_switches
+        if switch_to_properties.get(sw.mrid, {}).get("tie_type") == "lv_lv_tie"
+    ]
+
+    mv_mv_tie_feature_collection = _build_feature_collection(mv_mv_tie_switches, switch_to_properties)
+    mv_lv_tie_feature_collection = _build_feature_collection(mv_lv_tie_switches, switch_to_properties)
+    mv_via_lv_tie_feature_collection = _build_feature_collection(mv_via_lv_tie_switches, switch_to_properties)
+    lv_lv_tie_feature_collection = _build_feature_collection(lv_lv_tie_switches, switch_to_properties)
+    if (
+        not mv_mv_tie_feature_collection.features
+        and not mv_lv_tie_feature_collection.features
+        and not mv_via_lv_tie_feature_collection.features
+        and not lv_lv_tie_feature_collection.features
+    ):
+        print("No mappable tie switch features were found (e.g. missing location). Study upload skipped.")
+        return
+
+    print(
+        "Mappable tie features: "
+        f"mv_mv={len(mv_mv_tie_feature_collection.features)}, "
+        f"mv_lv={len(mv_lv_tie_feature_collection.features)}, "
+        f"mv_via_lv={len(mv_via_lv_tie_feature_collection.features)}, "
+        f"lv_lv={len(lv_lv_tie_feature_collection.features)}, "
+        f"total={len(mv_mv_tie_feature_collection.features) + len(mv_lv_tie_feature_collection.features) + len(mv_via_lv_tie_feature_collection.features) + len(lv_lv_tie_feature_collection.features)}"
+    )
+
+    style_path = os.path.join(os.path.dirname(__file__), "style_feeder_tie_switches.json")
+    with open(style_path, "r") as f:
+        styles = json.load(f)
+
+    fetch_coverage_summary = (
+        "Feeder fetch coverage: "
+        f"succeeded={succeeded_feeder_request_count}, "
+        f"failed={failed_feeder_request_count}, "
+        f"total={len(feeder_mrids)}, "
+        f"failed_unique={len(failed_feeder_mrids)}."
+    )
+
+    results: List[Result] = []
+    if mv_mv_tie_feature_collection.features:
+        results.append(
+            Result(
+                name=f"Feeder ties (MV↔MV) ({len(mv_mv_tie_feature_collection.features)})",
+                geo_json_overlay=GeoJsonOverlay(
+                    data=mv_mv_tie_feature_collection,
+                    styles=[
+                        "feeder-tie-switch-mv-mv",
+                        "feeder-tie-switch-label-mv-mv",
+                    ],
+                ),
+            )
+        )
+
+    if mv_lv_tie_feature_collection.features:
+        results.append(
+            Result(
+                name=f"Feeder ties (MV↔LV) ({len(mv_lv_tie_feature_collection.features)})",
+                geo_json_overlay=GeoJsonOverlay(
+                    data=mv_lv_tie_feature_collection,
+                    styles=[
+                        "feeder-tie-switch-mv-lv",
+                        "feeder-tie-switch-label-mv-lv",
+                    ],
+                ),
+            )
+        )
+
+    if mv_via_lv_tie_feature_collection.features:
+        results.append(
+            Result(
+                name=f"Feeder ties (MV via LV) ({len(mv_via_lv_tie_feature_collection.features)})",
+                geo_json_overlay=GeoJsonOverlay(
+                    data=mv_via_lv_tie_feature_collection,
+                    styles=[
+                        "feeder-tie-switch-mv-via-lv",
+                        "feeder-tie-switch-label-mv-via-lv",
+                    ],
+                ),
+            )
+        )
+
+    if lv_lv_tie_feature_collection.features:
+        results.append(
+            Result(
+                name=f"Feeder ties (LV↔LV) ({len(lv_lv_tie_feature_collection.features)})",
+                geo_json_overlay=GeoJsonOverlay(
+                    data=lv_lv_tie_feature_collection,
+                    styles=[
+                        "feeder-tie-switch-lv-lv",
+                        "feeder-tie-switch-label-lv-lv",
+                    ],
+                ),
+            )
+        )
+
+    if not results:
+        print("No enabled mappable tie switch layers were produced. Study upload skipped.")
+        return
+
+    eas_client = EasClient(
+        host=config["host"],
+        port=config["rpc_port"],
+        protocol="https",
+        access_token=config["access_token"],
+    )
+    print(f"Uploading Study for {mode} {scope_label} ...")
+    await eas_client.async_upload_study(
+        Study(
+            name=f"Feeder tie switches ({scope_label})",
+            description=(
+                "Detects feeder tie switches using container-membership evidence "
+                "(switch associated with more than one container). "
+                "Detected tie switch attributes are exported to CSV. "
+                f"{fetch_coverage_summary}"
+            ),
+            tags=[
+                "feeder_tie_switches",
+                lv_tag,
+                scope_tag,
+                f"fetch_failed_{failed_feeder_request_count}",
+                f"fetch_total_{len(feeder_mrids)}",
+            ],
+            results=results,
+            styles=styles,
+        )
+    )
+    await eas_client.aclose()
+    print("Uploaded Study")
+    print(f"Finish time: {datetime.now()}")
+
+
+def _collect_feeder_mrids(substations: Dict, zone_mrids: List[str]) -> List[str]:
+    feeder_mrids: List[str] = []
+    for zone_mrid in zone_mrids:
+        if zone_mrid in substations:
+            for feeder in substations[zone_mrid].feeders:
+                feeder_mrids.append(feeder.mrid)
+    return feeder_mrids
+
+
+def _collect_all_zone_mrids(substations: Dict) -> List[str]:
+    return sorted(zone_mrid for zone_mrid in substations.keys())
+
+
+def _collect_all_feeder_mrids(substations: Dict) -> List[str]:
+    feeder_mrids: List[str] = []
+    seen: Set[str] = set()
+    for zone_mrid in _collect_all_zone_mrids(substations):
+        for feeder in substations[zone_mrid].feeders:
+            if feeder.mrid in seen:
+                continue
+            seen.add(feeder.mrid)
+            feeder_mrids.append(feeder.mrid)
+    return feeder_mrids
+
+
+async def _fetch_feeder_switch_evidence(
+    feeder_mrid: str,
+    rpc_channel,
+    include_lv: bool,
+) -> Optional[Dict[str, SwitchEvidence]]:
+    print(f"Fetching Feeder {feeder_mrid}")
+    client = NetworkConsumerClient(rpc_channel)
+
+    if include_lv:
+        result = await client.get_equipment_container(
+            mrid=feeder_mrid,
+            expected_class=Feeder,
+            include_energized_containers=IncludedEnergizedContainers.LV_FEEDERS,
+        )
+    else:
+        result = await client.get_equipment_container(
+            mrid=feeder_mrid,
+            expected_class=Feeder,
+        )
+    if result.was_failure:
+        print(f"Failed feeder {feeder_mrid}: {_failure_reason(result)}")
+        return None
+
+    network = client.service
+    print(f"Finished fetching Feeder {feeder_mrid}")
+
+    feeder_switches: Dict[str, SwitchEvidence] = {}
+    for sw in network.objects(Switch):
+        if not include_lv and _is_lv_switch(sw):
+            continue
+
+        feeder_switches[sw.mrid] = SwitchEvidence(
+            switch=sw,
+            source_feeder_mrids={feeder_mrid},
+        )
+
+    return feeder_switches
+
+
+def _failure_reason(result: Any) -> str:
+    thrown = getattr(result, "thrown", None)
+    if thrown is not None:
+        text = str(thrown).strip()
+        if text and text.lower() != "none":
+            return text
+
+    parts: List[str] = []
+    for attr in ("message", "details", "status", "code", "error"):
+        value = getattr(result, attr, None)
+        if value is None:
+            continue
+        text = str(value).strip()
+        if text and text.lower() != "none":
+            parts.append(f"{attr}={text}")
+
+    if parts:
+        return "; ".join(parts)
+
+    return repr(result)
+
+
+def _merge_switch_evidence(
+    combined: Dict[str, SwitchEvidence],
+    next_batch: Dict[str, SwitchEvidence],
+):
+    for mrid, evidence in next_batch.items():
+        existing = combined.get(mrid)
+        if existing is None:
+            combined[mrid] = evidence
+            continue
+
+        existing.source_feeder_mrids.update(evidence.source_feeder_mrids)
+
+        # Keep whichever object has location data for better map output.
+        if existing.switch.location is None and evidence.switch.location is not None:
+            existing.switch = evidence.switch
+
+
+def _build_tie_properties(evidence: SwitchEvidence, include_lv: bool) -> Dict[str, Any]:
+    switch = evidence.switch
+    (
+        container_ids,
+        normal_container_ids,
+        current_container_ids,
+        lv_parent_container_ids,
+        normal_lv_circuit_ids,
+        current_lv_circuit_ids,
+    ) = _switch_container_ids(switch, include_lv)
+    mv_container_ids = set(normal_container_ids | current_container_ids)
+    lv_circuit_ids = set(normal_lv_circuit_ids | current_lv_circuit_ids)
+    total_terminal_count = len(list(switch.terminals))
+    is_open = _switch_open_value(switch)
+    is_normally_open = _switch_normal_open_value(switch)
+    is_lv_switch = _is_lv_switch(switch)
+
+    tie_type = _classify_tie_type(
+        include_lv=include_lv,
+        is_lv_switch=is_lv_switch,
+        mv_container_ids=mv_container_ids,
+        lv_circuit_ids=lv_circuit_ids,
+        lv_parent_container_ids=lv_parent_container_ids,
+    )
+    tie_class = "feeder_tie" if tie_type != "non_tie" else "non_tie"
+
+    return {
+        "name": switch.name or switch.mrid,
+        "type": "switch",
+        "is_tie": tie_class == "feeder_tie",
+        "tie_class": tie_class,
+        "tie_type": tie_type,
+        "tie_type_label": _tie_type_label(tie_type),
+        "container_count": len(container_ids),
+        "container_ids": sorted(container_ids),
+        "normal_container_ids": sorted(normal_container_ids),
+        "current_container_ids": sorted(current_container_ids),
+        "lv_parent_container_ids": sorted(lv_parent_container_ids),
+        "mv_container_count": len(mv_container_ids),
+        "mv_container_ids": sorted(mv_container_ids),
+        "lv_circuit_count": len(lv_circuit_ids),
+        "lv_circuit_ids": sorted(lv_circuit_ids),
+        "normal_lv_circuit_ids": sorted(normal_lv_circuit_ids),
+        "current_lv_circuit_ids": sorted(current_lv_circuit_ids),
+        "observed_container_ids": sorted(evidence.source_feeder_mrids),
+        "observed_container_count": len(evidence.source_feeder_mrids),
+        "terminal_count": total_terminal_count,
+        "is_open": is_open,
+        "is_normally_open": is_normally_open,
+        "is_lv_switch": is_lv_switch,
+        "include_lv_mode": include_lv,
+    }
+
+
+def _switch_container_ids(
+    switch: Switch,
+    include_lv: bool,
+) -> Tuple[Set[str], Set[str], Set[str], Set[str], Set[str], Set[str]]:
+    normal_container_ids = _normal_container_ids(switch)
+    current_container_ids = _current_container_ids(switch)
+    container_ids = set(normal_container_ids | current_container_ids)
+
+    lv_parent_container_ids: Set[str] = set()
+    normal_lv_circuit_ids: Set[str] = set()
+    current_lv_circuit_ids: Set[str] = set()
+    if include_lv:
+        normal_lv_circuit_ids.update(_normal_lv_circuit_ids(switch))
+        current_lv_circuit_ids.update(_current_lv_circuit_ids(switch))
+        lv_parent_container_ids.update(_normal_lv_parent_container_ids(switch))
+        lv_parent_container_ids.update(_current_lv_parent_container_ids(switch))
+        container_ids.update(lv_parent_container_ids)
+        container_ids.update(normal_lv_circuit_ids)
+        container_ids.update(current_lv_circuit_ids)
+
+    return (
+        container_ids,
+        normal_container_ids,
+        current_container_ids,
+        lv_parent_container_ids,
+        normal_lv_circuit_ids,
+        current_lv_circuit_ids,
+    )
+
+
+def _classify_tie_type(
+    include_lv: bool,
+    is_lv_switch: bool,
+    mv_container_ids: Set[str],
+    lv_circuit_ids: Set[str],
+    lv_parent_container_ids: Set[str],
+) -> str:
+    mv_count = len(mv_container_ids)
+
+    # MV↔MV ties are strictly MV switch + more than one MV feeder container.
+    if not is_lv_switch and mv_count >= 2:
+        return "mv_mv_tie"
+
+    if not include_lv:
+        return "non_tie"
+
+    lv_circuit_count = len(lv_circuit_ids)
+    lv_parent_count = len(lv_parent_container_ids)
+
+    # MV↔LV ties require MV assignment plus one or more LV circuits.
+    if mv_count >= 1 and lv_circuit_count >= 1:
+        return "mv_lv_tie"
+
+    # MV-via-LV only when LV parent evidence indicates >1 distinct parent
+    # containers for the switch.
+    if lv_parent_count >= 2:
+        return "mv_via_lv_tie"
+
+    if lv_circuit_count >= 2:
+        return "lv_lv_tie"
+
+    return "non_tie"
+
+
+def _tie_type_label(tie_type: str) -> str:
+    if tie_type == "mv_mv_tie":
+        return "MV↔MV ties"
+    if tie_type == "mv_lv_tie":
+        return "MV↔LV ties"
+    if tie_type == "mv_via_lv_tie":
+        return "MV via LV ties"
+    if tie_type == "lv_lv_tie":
+        return "LV↔LV ties"
+    return "Non-tie"
+
+
+def _normal_container_ids(equipment: Any) -> Set[str]:
+    return {
+        feeder.mrid
+        for feeder in (getattr(equipment, "normal_feeders", None) or [])
+        if getattr(feeder, "mrid", None)
+    }
+
+
+def _current_container_ids(equipment: Any) -> Set[str]:
+    return {
+        feeder.mrid
+        for feeder in (getattr(equipment, "current_feeders", None) or [])
+        if getattr(feeder, "mrid", None)
+    }
+
+
+def _normal_lv_circuit_ids(equipment: Any) -> Set[str]:
+    return {
+        feeder.mrid
+        for feeder in (getattr(equipment, "normal_lv_feeders", None) or [])
+        if getattr(feeder, "mrid", None)
+    }
+
+
+def _current_lv_circuit_ids(equipment: Any) -> Set[str]:
+    return {
+        feeder.mrid
+        for feeder in (getattr(equipment, "current_lv_feeders", None) or [])
+        if getattr(feeder, "mrid", None)
+    }
+
+
+def _normal_lv_parent_container_ids(equipment: Any) -> Set[str]:
+    parent_ids: Set[str] = set()
+    for lv_feeder in (getattr(equipment, "normal_lv_feeders", None) or []):
+        for feeder in (getattr(lv_feeder, "normal_energizing_feeders", None) or []):
+            if getattr(feeder, "mrid", None):
+                parent_ids.add(feeder.mrid)
+    return parent_ids
+
+
+def _current_lv_parent_container_ids(equipment: Any) -> Set[str]:
+    parent_ids: Set[str] = set()
+    for lv_feeder in (getattr(equipment, "current_lv_feeders", None) or []):
+        for feeder in (getattr(lv_feeder, "current_energizing_feeders", None) or []):
+            if getattr(feeder, "mrid", None):
+                parent_ids.add(feeder.mrid)
+    return parent_ids
+
+
+def _switch_open_value(sw: Switch) -> Optional[bool]:
+    if hasattr(sw, "is_open"):
+        try:
+            return bool(sw.is_open())
+        except Exception:
+            pass
+    if hasattr(sw, "open"):
+        try:
+            value = getattr(sw, "open")
+            return bool(value() if callable(value) else value)
+        except Exception:
+            pass
+    return None
+
+
+def _switch_normal_open_value(sw: Switch) -> Optional[bool]:
+    if hasattr(sw, "is_normally_open"):
+        try:
+            return bool(sw.is_normally_open())
+        except Exception:
+            pass
+    for attr in ("normally_open", "normal_open"):
+        if hasattr(sw, attr):
+            try:
+                value = getattr(sw, attr)
+                return bool(value() if callable(value) else value)
+            except Exception:
+                continue
+    return None
+
+
+def _is_lv_switch(sw: Switch) -> bool:
+    base_voltage = getattr(sw, "base_voltage_value", None)
+    if base_voltage is not None and base_voltage > 0:
+        return base_voltage <= 1000
+
+    # Fallback for models where base voltage is absent:
+    # if the switch appears only in LV containers, treat as LV.
+    has_mv = bool(_normal_container_ids(sw) or _current_container_ids(sw))
+    has_lv = bool(_normal_lv_parent_container_ids(sw) or _current_lv_parent_container_ids(sw))
+    return has_lv and not has_mv
+
+
+def _build_feature_collection(
+    switches: List[Switch],
+    switch_to_properties: Dict[str, Dict[str, Any]],
+) -> FeatureCollection:
+    features: List[Feature] = []
+    for sw in switches:
+        geometry = to_geojson_geometry(sw.location)
+        if geometry is None:
+            continue
+        features.append(Feature(sw.mrid, geometry, switch_to_properties.get(sw.mrid, {})))
+    return FeatureCollection(features)
+
+
+def to_geojson_feature_collection(
+    psrs: List[PowerSystemResource],
+    class_to_properties: Dict[type, Dict[str, Any]],
+) -> FeatureCollection:
+    # Retained for compatibility with existing study patterns if needed for extension.
+    features = []
+    for psr in psrs:
+        properties = class_to_properties.get(type(psr))
+        if properties is None:
+            continue
+        geometry = to_geojson_geometry(psr.location)
+        if geometry is None:
+            continue
+        features.append(Feature(psr.mrid, geometry, {k: f(psr) for (k, f) in properties.items()}))
+    return FeatureCollection(features)
+
+
+def to_geojson_geometry(location: Location) -> Union[Geometry, None]:
+    points = list(location.points) if location is not None else []
+    if len(points) > 1:
+        return LineString([(point.x_position, point.y_position) for point in points])
+    if len(points) == 1:
+        return Point((points[0].x_position, points[0].y_position))
+    return None
+
+
+def _resolve_csv_report_path(csv_output: str, scope_tag: str, lv_tag: str) -> str:
+    if csv_output:
+        return csv_output
+    timestamp = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+    return os.path.join(
+        os.path.dirname(__file__),
+        f"feeder_tie_switches_{scope_tag}_{lv_tag}_{timestamp}.csv",
+    )
+
+
+def _build_csv_rows(
+    switch_to_properties: Dict[str, Dict[str, Any]],
+    mode: str,
+    scope_label: str,
+) -> List[Dict[str, Any]]:
+    generated_at_utc = datetime.now(timezone.utc).replace(microsecond=0).isoformat().replace("+00:00", "Z")
+    rows: List[Dict[str, Any]] = []
+    for switch_mrid in sorted(switch_to_properties.keys()):
+        row: Dict[str, Any] = {
+            "switch_mrid": switch_mrid,
+            "scope_mode": mode,
+            "scope_label": scope_label,
+            "generated_at_utc": generated_at_utc,
+        }
+        row.update(switch_to_properties[switch_mrid])
+        rows.append(row)
+    return rows
+
+
+def _csv_cell(value: Any) -> str:
+    if value is None:
+        return ""
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    if isinstance(value, (list, tuple, set)):
+        return "|".join(str(item) for item in value)
+    return str(value)
+
+
+def _write_tie_csv_report(path: str, rows: List[Dict[str, Any]]) -> None:
+    directory = os.path.dirname(path)
+    if directory:
+        os.makedirs(directory, exist_ok=True)
+
+    with open(path, "w", newline="") as f:
+        writer = csv.DictWriter(f, fieldnames=CSV_FIELDNAMES)
+        writer.writeheader()
+        for row in rows:
+            writer.writerow({column: _csv_cell(row.get(column)) for column in CSV_FIELDNAMES})
+
+
+def _parse_args(argv: List[str]) -> Tuple[List[str], List[str], str, str, bool, str, str]:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Generate a feeder-tie switch study for one or more zones or feeders. "
+            "Default behavior is MV-only; "
+            "use --include-lv to include LV containers."
+        )
+    )
+    parser.add_argument(
+        "--mode",
+        choices=["zones", "feeders", "full-network"],
+        default="zones",
+        help="Run by zones, feeders, or full-network list expansion (default: zones).",
+    )
+    parser.add_argument(
+        "--zones",
+        default="CPM",
+        help="Comma-separated zone codes (default: CPM).",
+    )
+    parser.add_argument(
+        "--feeders",
+        default="",
+        help="Comma-separated feeder MRIDs (used when --mode feeders).",
+    )
+    parser.add_argument(
+        "--config",
+        default=DEFAULT_CONFIG_PATH,
+        help=f"Path to config.json (default: {DEFAULT_CONFIG_PATH}).",
+    )
+    parser.add_argument(
+        "--full-network-list",
+        choices=["feeders", "zones"],
+        default="feeders",
+        help=(
+            "When --mode full-network is used: run all feeders directly (feeders) "
+            "or derive all zones and then expand to feeders (zones)."
+        ),
+    )
+    parser.add_argument(
+        "--include-lv",
+        action="store_true",
+        help="Include LV containers in fetch and tie detection (default is MV-only).",
+    )
+    parser.add_argument(
+        "--csv-output",
+        default="",
+        help=(
+            "Optional path for detected tie CSV report. "
+            "Default writes feeder_tie_switches_<scope>_<mode>_<timestamp>.csv in this folder."
+        ),
+    )
+    parser.add_argument(
+        "ids",
+        nargs="*",
+        help="Zone codes or feeder MRIDs (positional values override --zones/--feeders).",
+    )
+    args = parser.parse_args(argv)
+
+    def _split_values(values: Union[str, Sequence[str]]) -> List[str]:
+        if isinstance(values, str):
+            items = values.split(",")
+        else:
+            items = list(values)
+        return [item.strip() for item in items if item and item.strip()]
+
+    if args.mode == "feeders":
+        feeders = _split_values(args.ids) or _split_values(args.feeders)
+        if not feeders:
+            raise ValueError("At least one feeder MRID is required in feeder mode.")
+        return (
+            [],
+            feeders,
+            args.mode,
+            args.config,
+            bool(args.include_lv),
+            args.full_network_list,
+            args.csv_output,
+        )
+
+    if args.mode == "full-network":
+        return (
+            [],
+            [],
+            args.mode,
+            args.config,
+            bool(args.include_lv),
+            args.full_network_list,
+            args.csv_output,
+        )
+
+    zones = _split_values(args.ids) or _split_values(args.zones)
+    if not zones:
+        raise ValueError("At least one zone code is required in zone mode.")
+
+    return (
+        zones,
+        [],
+        args.mode,
+        args.config,
+        bool(args.include_lv),
+        args.full_network_list,
+        args.csv_output,
+    )
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/src/zepben/examples/studies/hosting_capacity_examples/README.md b/src/zepben/examples/studies/hosting_capacity_examples/README.md
new file mode 100644
index 0000000..14c1551
--- /dev/null
+++ b/src/zepben/examples/studies/hosting_capacity_examples/README.md
@@ -0,0 +1,112 @@
+# Hosting Capacity DB-backed studies
+
+This folder contains two study examples that read Hosting Capacity results from
+`public.network_performance_metrics_enhanced` in PostgreSQL, map each
+`conducting_equipment_mrid` as a measurement-zone head, and propagate metrics
+downstream until the next measurement-zone head.
+
+`mz_type` is used to control propagation mode:
+- `FEEDER_HEAD`, `FUSE`, `SWITCH`, and `LINE` types are treated as downstream
+  zone heads and traced until the next measurement-zone head.
+- `TRANSFORMER` is normally treated as a point source.
+- Fallback: if a slice only contains `TRANSFORMER`/`FEEDER_HEAD` zones and has
+  no explicit LV `FUSE`/`SWITCH`/`LINE` heads, transformers are traced
+  downstream so LV line segments are also colour-coded.
+
+## Scripts
+
+- `hcm_asset_metrics_study.py`
+  - Uploads six colour-coded downstream **line** metric results:
+    - `peak_import`
+    - `peak_export`
+    - `import_utilisation`
+    - `export_utilisation`
+    - `load_exceeding_normal_thermal_voltage_kwh`
+    - `gen_exceeding_normal_thermal_voltage_kwh`
+  - Utilisation is based on measurement-zone head ratings:
+    - Transformer heads use transformer end rating (`kVA`).
+    - Line-style zones (`FUSE`/`SWITCH`/`LINE`) use the first downstream `AcLineSegment`
+      from the zone head and its current rating (`A`).
+- `hcm_voltage_heatmap_study.py`
+  - Uploads two downstream **line voltage map** results:
+    - `v1_avg_section_voltage`
+    - `v99_avg_section_voltage`
+  - Converts both to line-ground voltage magnitude:
+    - `v*_lg = v*_avg_section_voltage * (v_base / sqrt(3))`
+  - Applies colour across downstream line segments between measurement-zone heads.
+
+## Required env keys
+
+Read from `.env` by default:
+
+- `EWB_HOST`
+- `EWB_RPC_PORT`
+- `EWB_ACCESS_TOKEN`
+- `INPUT_DB_HOST`
+- `INPUT_DB_PORT`
+- `INPUT_DB_USER`
+- `INPUT_DB_PASSWORD`
+- `INPUT_DB_NAME`
+
+## Selection workflow
+
+Both scripts now support a discovery-first interface:
+
+1. Pass `--work-package-id` and list options.
+2. Choose values for year/scope/scenario/timestamp.
+3. Re-run with selected values, or use interactive prompts.
+
+## Example commands
+
+List selectable options for a work package:
+
+```bash
+python hcm_asset_metrics_study.py \
+  --work-package-id <wp_id> \
+  --list-options
+```
+
+Prompt for missing year/scenario/timestamp:
+
+```bash
+python hcm_asset_metrics_study.py \
+  --work-package-id <wp_id> \
+  --zones CPM \
+  --interactive
+```
+
+From this folder:
+
+```bash
+python hcm_asset_metrics_study.py \
+  --work-package-id <wp_id> \
+  --year 2025 \
+  --zones CPM
+```
+
+```bash
+python hcm_asset_metrics_study.py \
+  --work-package-id <wp_id> \
+  --year 2025 \
+  --feeder-prefixes 271
+```
+
+```bash
+python hcm_voltage_heatmap_study.py \
+  --work-package-id <wp_id> \
+  --year 2025 \
+  --zones CPM \
+  --scenario base \
+  --time-of-day all \
+  --season all
+```
+
+List options for voltage script:
+
+```bash
+python hcm_voltage_heatmap_study.py \
+  --work-package-id <wp_id> \
+  --list-options
+```
+
+Use `--dry-run` to build layers without upload.
diff --git a/src/zepben/examples/studies/hosting_capacity_examples/__init__.py b/src/zepben/examples/studies/hosting_capacity_examples/__init__.py
new file mode 100644
index 0000000..4a7146f
--- /dev/null
+++ b/src/zepben/examples/studies/hosting_capacity_examples/__init__.py
@@ -0,0 +1,5 @@
+#  Copyright 2026 Zeppelin Bend Pty Ltd
+#
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
diff --git a/src/zepben/examples/studies/hosting_capacity_examples/common.py b/src/zepben/examples/studies/hosting_capacity_examples/common.py
new file mode 100644
index 0000000..4520fd5
--- /dev/null
+++ b/src/zepben/examples/studies/hosting_capacity_examples/common.py
@@ -0,0 +1,1281 @@
+#  Copyright 2026 Zeppelin Bend Pty Ltd
+#
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+from __future__ import annotations
+
+import asyncio
+import math
+from collections import defaultdict
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+import re
+from typing import DefaultDict, Dict, List, Mapping, Optional, Sequence, Set, Tuple
+
+from dotenv import dotenv_values
+from geojson.geometry import LineString, Point
+from sqlalchemy import bindparam, create_engine, text
+from sqlalchemy.engine import Engine, URL
+from zepben.ewb import (
+    AcLineSegment,
+    ConductingEquipment,
+    Feeder,
+    IncludedEnergizedContainers,
+    NetworkConsumerClient,
+    NetworkTraceStep,
+    PhaseCode,
+    Tracing,
+    connect_with_token,
+    downstream,
+)
+from zepben.ewb.services.network.tracing.networktrace.operators.network_state_operators import NetworkStateOperators
+
+
+@dataclass(frozen=True)
+class DbSettings:
+    host: str
+    port: int
+    user: str
+    password: str
+    database: str
+
+
+@dataclass(frozen=True)
+class EwbSettings:
+    host: str
+    rpc_port: int
+    access_token: str
+    ca_filename: Optional[str]
+    timeout_seconds: int
+    debug: bool
+    skip_connection_test: bool
+
+
+@dataclass(frozen=True)
+class SliceSelection:
+    work_package_id: str
+    year: int
+    scenario: str
+    timestamp: datetime
+    season: str
+    time_of_day: str
+    feeders: Tuple[str, ...]
+
+
+@dataclass(frozen=True)
+class DbMetricRow:
+    work_package_id: str
+    scenario: str
+    timestamp: datetime
+    feeder: str
+    measurement_zone_name: str
+    mz_type: str
+    conducting_equipment_mrid: str
+    season: str
+    time_of_day: str
+    v_base: Optional[float]
+    peak_import: Optional[float]
+    peak_export: Optional[float]
+    load_exceeding_normal_thermal_voltage_kwh: Optional[float]
+    gen_exceeding_normal_thermal_voltage_kwh: Optional[float]
+    v1_avg_section_voltage: Optional[float]
+    v99_avg_section_voltage: Optional[float]
+
+
+@dataclass(frozen=True)
+class SliceOptionCatalog:
+    years: Tuple[int, ...]
+    feeders: Tuple[str, ...]
+    scenarios: Tuple[str, ...]
+    timestamps: Tuple[datetime, ...]
+    seasons: Tuple[str, ...]
+    time_of_days: Tuple[str, ...]
+
+
+@dataclass(frozen=True)
+class SliceOptionRecord:
+    year: int
+    feeder: str
+    scenario: str
+    timestamp: datetime
+    season: str
+    time_of_day: str
+
+
+@dataclass(frozen=True)
+class SliceOptionSnapshot:
+    records: Tuple[SliceOptionRecord, ...]
+
+
+@dataclass
+class FeederTraceContext:
+    feeder_mrid: str
+    equipment_by_mrid: Dict[str, ConductingEquipment]
+    downstream_edges_by_from: Dict[str, Set[str]]
+    traversed_lines_by_edge: Dict[Tuple[str, str], Set[str]]
+
+
+POINT_SOURCE_MZ_TYPES: Set[str] = {"TRANSFORMER"}
+TRACE_SOURCE_MZ_TOKENS: Tuple[str, ...] = ("FEEDER_HEAD", "FUSE", "SWITCH", "LINE")
+
+
+def split_csv_values(raw: str) -> List[str]:
+    if not raw:
+        return []
+    return [value.strip() for value in raw.split(",") if value and value.strip()]
+
+
+def canonical_mz_type(mz_type: str) -> str:
+    return re.sub(r"[^A-Z0-9]+", "_", (mz_type or "").strip().upper()).strip("_")
+
+
+def is_point_source_mz_type(mz_type: str) -> bool:
+    return canonical_mz_type(mz_type) in POINT_SOURCE_MZ_TYPES
+
+
+def is_trace_source_mz_type(mz_type: str) -> bool:
+    canonical = canonical_mz_type(mz_type)
+    if canonical in POINT_SOURCE_MZ_TYPES:
+        return False
+    if any(token in canonical for token in TRACE_SOURCE_MZ_TOKENS):
+        return True
+    # Default to trace for unknown types to avoid silently dropping zones.
+    return True
+
+
+def should_apply_transformer_trace_fallback(mz_types: Sequence[str]) -> bool:
+    canonical = [canonical_mz_type(value) for value in mz_types if (value or "").strip()]
+    if not canonical:
+        return False
+
+    has_transformer = any(value == "TRANSFORMER" for value in canonical)
+    if not has_transformer:
+        return False
+
+    # Fallback is only for the "point-only transformer zones" case.
+    allowed_point_only = {"TRANSFORMER", "FEEDER_HEAD"}
+    if any(value not in allowed_point_only for value in canonical):
+        return False
+
+    # If explicit LV group heads exist, use normal trace classification.
+    has_explicit_lv_trace_heads = any(
+        any(token in value for token in ("FUSE", "SWITCH", "LINE"))
+        for value in canonical
+    )
+    if has_explicit_lv_trace_heads:
+        return False
+
+    return True
+
+
+def _load_env_values(env_file: str) -> Mapping[str, Optional[str]]:
+    env_path = Path(env_file)
+    return dotenv_values(str(env_path))
+
+
+def _parse_bool(raw: Optional[str], default: bool = False) -> bool:
+    if raw is None:
+        return default
+    value = raw.strip().lower()
+    if value in {"1", "true", "yes", "y", "on"}:
+        return True
+    if value in {"0", "false", "no", "n", "off"}:
+        return False
+    return default
+
+
+def load_db_settings(env_file: str) -> DbSettings:
+    env_values = _load_env_values(env_file)
+
+    required = [
+        "INPUT_DB_HOST",
+        "INPUT_DB_PORT",
+        "INPUT_DB_USER",
+        "INPUT_DB_PASSWORD",
+        "INPUT_DB_NAME",
+    ]
+    missing = [key for key in required if not (env_values.get(key) or "").strip()]
+    if missing:
+        raise ValueError(
+            "Missing required database settings in .env: " + ", ".join(missing)
+        )
+
+    return DbSettings(
+        host=str(env_values["INPUT_DB_HOST"]),
+        port=int(str(env_values["INPUT_DB_PORT"])),
+        user=str(env_values["INPUT_DB_USER"]),
+        password=str(env_values["INPUT_DB_PASSWORD"]),
+        database=str(env_values["INPUT_DB_NAME"]),
+    )
+
+
+def load_ewb_settings(env_file: str) -> EwbSettings:
+    env_values = _load_env_values(env_file)
+
+    required = [
+        "EWB_HOST",
+        "EWB_RPC_PORT",
+        "EWB_ACCESS_TOKEN",
+    ]
+    missing = [key for key in required if not (env_values.get(key) or "").strip()]
+    if missing:
+        raise ValueError(
+            "Missing required EWB settings in .env: " + ", ".join(missing)
+        )
+
+    ca_filename = (env_values.get("EWB_CA_FILENAME") or "").strip() or None
+    timeout_raw = (env_values.get("EWB_TIMEOUT_SECONDS") or "").strip()
+    timeout_seconds = int(timeout_raw) if timeout_raw else 30
+
+    return EwbSettings(
+        host=str(env_values["EWB_HOST"]),
+        rpc_port=int(str(env_values["EWB_RPC_PORT"])),
+        access_token=str(env_values["EWB_ACCESS_TOKEN"]),
+        ca_filename=ca_filename,
+        timeout_seconds=timeout_seconds,
+        debug=_parse_bool(env_values.get("EWB_DEBUG"), default=False),
+        skip_connection_test=_parse_bool(env_values.get("EWB_SKIP_CONNECTION_TEST"), default=False),
+    )
+
+
+def create_postgres_engine(settings: DbSettings) -> Engine:
+    url = URL.create(
+        drivername="postgresql+pg8000",
+        username=settings.user,
+        password=settings.password,
+        host=settings.host,
+        port=settings.port,
+        database=settings.database,
+    )
+    return create_engine(url, pool_pre_ping=True, future=True)
+
+
+def _connect_rpc(ewb: EwbSettings):
+    return connect_with_token(
+        host=ewb.host,
+        access_token=ewb.access_token,
+        rpc_port=ewb.rpc_port,
+        ca_filename=ewb.ca_filename,
+        timeout_seconds=ewb.timeout_seconds,
+        debug=ewb.debug,
+        skip_connection_test=ewb.skip_connection_test,
+    )
+
+
+def _is_deadline_exceeded_error(error: object) -> bool:
+    text = str(error or "").upper()
+    return "DEADLINE_EXCEEDED" in text or "DEADLINE EXCEEDED" in text
+
+
+def _year_bounds(year: int) -> Tuple[datetime, datetime]:
+    start = datetime(year, 1, 1, tzinfo=timezone.utc)
+    end = datetime(year + 1, 1, 1, tzinfo=timezone.utc)
+    return start, end
+
+
+def _parse_timestamp(value: str) -> datetime:
+    normalised = value.strip().replace("Z", "+00:00")
+    parsed = datetime.fromisoformat(normalised)
+    if parsed.tzinfo is None:
+        parsed = parsed.replace(tzinfo=timezone.utc)
+    return parsed
+
+
+async def resolve_zone_feeders(ewb: EwbSettings, zone_codes: Sequence[str]) -> Set[str]:
+    if not zone_codes:
+        return set()
+
+    rpc_channel = _connect_rpc(ewb)
+    client = NetworkConsumerClient(rpc_channel)
+    hierarchy = (await client.get_network_hierarchy()).throw_on_error()
+    substations = hierarchy.value.substations
+
+    feeders: Set[str] = set()
+    missing: List[str] = []
+
+    for zone in zone_codes:
+        zone_data = substations.get(zone)
+        if zone_data is None:
+            missing.append(zone)
+            continue
+        for feeder in zone_data.feeders:
+            feeders.add(str(feeder.mrid))
+
+    if missing:
+        available = ", ".join(sorted(substations.keys()))
+        raise ValueError(f"Unknown zone code(s): {', '.join(missing)}. Available zones include: {available}")
+
+    return feeders
+
+
+def fetch_prefixed_feeders(
+    engine: Engine,
+    work_package_id: str,
+    year: Optional[int],
+    feeder_prefixes: Sequence[str],
+) -> Set[str]:
+    if not feeder_prefixes:
+        return set()
+
+    prefix_terms = []
+    params: Dict[str, object] = {"work_package_id": work_package_id}
+
+    for i, prefix in enumerate(feeder_prefixes):
+        key = f"prefix_{i}"
+        prefix_terms.append(f"feeder::text LIKE :{key}")
+        params[key] = f"{prefix}%"
+
+    year_clause = ""
+    if year is not None:
+        year_start, year_end = _year_bounds(year)
+        params["year_start"] = year_start
+        params["year_end"] = year_end
+        year_clause = ' AND "timestamp" >= :year_start AND "timestamp" < :year_end'
+
+    sql = f"""
+        SELECT DISTINCT feeder::text AS feeder
+        FROM public.network_performance_metrics_enhanced
+        WHERE work_package_id = :work_package_id
+          {year_clause}
+          AND ({' OR '.join(prefix_terms)})
+        ORDER BY feeder::text
+    """
+
+    with engine.connect() as conn:
+        rows = conn.execute(text(sql), params).mappings().all()
+
+    return {str(row["feeder"]) for row in rows if row.get("feeder") is not None}
+
+
+def combine_feeder_scope(zone_feeders: Set[str], prefix_feeders: Set[str]) -> Set[str]:
+    if zone_feeders and prefix_feeders:
+        selected = zone_feeders.intersection(prefix_feeders)
+    elif zone_feeders:
+        selected = zone_feeders
+    elif prefix_feeders:
+        selected = prefix_feeders
+    else:
+        raise ValueError("At least one feeder scope is required: --zones and/or --feeder-prefixes")
+
+    if not selected:
+        raise ValueError("No feeders matched the requested scope intersection.")
+
+    return selected
+
+
+def _feeder_clause(feeders: Sequence[str]) -> Tuple[str, bool]:
+    if not feeders:
+        return "", False
+    return " AND feeder::text IN :feeders", True
+
+
+def _year_clause(year: Optional[int]) -> Tuple[str, Optional[datetime], Optional[datetime]]:
+    if year is None:
+        return "", None, None
+    year_start, year_end = _year_bounds(year)
+    return ' AND "timestamp" >= :year_start AND "timestamp" < :year_end', year_start, year_end
+
+
+def _normalise_optional_text(value: Optional[str]) -> Optional[str]:
+    if value is None:
+        return None
+    cleaned = value.strip()
+    return cleaned if cleaned else None
+
+
+def _base_option_filters(
+    work_package_id: str,
+    year: Optional[int],
+    scenario: Optional[str],
+    feeders: Sequence[str],
+) -> Tuple[str, Dict[str, object], bool]:
+    feeder_clause, has_feeders = _feeder_clause(feeders)
+    year_clause, year_start, year_end = _year_clause(year)
+    scenario_value = _normalise_optional_text(scenario)
+    scenario_clause = " AND scenario = :scenario" if scenario_value else ""
+
+    where_clause = f"""
+        WHERE work_package_id = :work_package_id
+          {year_clause}
+          {scenario_clause}
+          {feeder_clause}
+    """
+
+    params: Dict[str, object] = {"work_package_id": work_package_id}
+    if year_start is not None and year_end is not None:
+        params["year_start"] = year_start
+        params["year_end"] = year_end
+    if scenario_value:
+        params["scenario"] = scenario_value
+    if has_feeders:
+        params["feeders"] = list(feeders)
+
+    return where_clause, params, has_feeders
+
+
+def _select_distinct_text_values(
+    engine: Engine,
+    select_expression: str,
+    where_clause: str,
+    params: Dict[str, object],
+    has_feeders: bool,
+) -> List[str]:
+    stmt = text(
+        f"""
+        SELECT DISTINCT {select_expression} AS value
+        FROM public.network_performance_metrics_enhanced
+        {where_clause}
+        ORDER BY value
+        """
+    )
+    if has_feeders:
+        stmt = stmt.bindparams(bindparam("feeders", expanding=True))
+    with engine.connect() as conn:
+        rows = conn.execute(stmt, params).mappings().all()
+    return [str(row["value"]) for row in rows if row.get("value") is not None]
+
+
+def _select_distinct_timestamps(
+    engine: Engine,
+    where_clause: str,
+    params: Dict[str, object],
+    has_feeders: bool,
+) -> List[datetime]:
+    stmt = text(
+        f"""
+        SELECT DISTINCT "timestamp" AS value
+        FROM public.network_performance_metrics_enhanced
+        {where_clause}
+        ORDER BY value
+        """
+    )
+    if has_feeders:
+        stmt = stmt.bindparams(bindparam("feeders", expanding=True))
+
+    with engine.connect() as conn:
+        rows = conn.execute(stmt, params).mappings().all()
+
+    values: List[datetime] = []
+    for row in rows:
+        value = row.get("value")
+        if value is None:
+            continue
+        if isinstance(value, datetime):
+            values.append(value if value.tzinfo is not None else value.replace(tzinfo=timezone.utc))
+            continue
+        values.append(_parse_timestamp(str(value)))
+    return values
+
+
+def fetch_slice_option_snapshot(
+    engine: Engine,
+    work_package_id: str,
+    feeders: Sequence[str] = (),
+) -> SliceOptionSnapshot:
+    feeder_clause, has_feeders = _feeder_clause(feeders)
+    stmt = text(
+        f"""
+        SELECT DISTINCT
+            EXTRACT(YEAR FROM "timestamp" AT TIME ZONE 'UTC')::int AS year,
+            feeder::text AS feeder,
+            scenario,
+            "timestamp" AS timestamp,
+            season,
+            time_of_day
+        FROM public.network_performance_metrics_enhanced
+        WHERE work_package_id = :work_package_id
+          {feeder_clause}
+        ORDER BY year, scenario, "timestamp", season, time_of_day, feeder::text
+        """
+    )
+    if has_feeders:
+        stmt = stmt.bindparams(bindparam("feeders", expanding=True))
+
+    params: Dict[str, object] = {"work_package_id": work_package_id}
+    if has_feeders:
+        params["feeders"] = list(feeders)
+
+    with engine.connect() as conn:
+        rows = conn.execute(stmt, params).mappings().all()
+
+    records: List[SliceOptionRecord] = []
+    for row in rows:
+        year = row.get("year")
+        feeder = row.get("feeder")
+        scenario = row.get("scenario")
+        ts = row.get("timestamp")
+        season = row.get("season")
+        time_of_day = row.get("time_of_day")
+        if year is None or feeder is None or scenario is None or ts is None or season is None or time_of_day is None:
+            continue
+
+        if isinstance(ts, datetime):
+            timestamp = ts if ts.tzinfo is not None else ts.replace(tzinfo=timezone.utc)
+        else:
+            timestamp = _parse_timestamp(str(ts))
+
+        records.append(
+            SliceOptionRecord(
+                year=int(year),
+                feeder=str(feeder),
+                scenario=str(scenario),
+                timestamp=timestamp,
+                season=str(season),
+                time_of_day=str(time_of_day),
+            )
+        )
+
+    return SliceOptionSnapshot(records=tuple(records))
+
+
+def _filter_slice_option_records(
+    records: Sequence[SliceOptionRecord],
+    year: Optional[int] = None,
+    scenario: Optional[str] = None,
+    timestamp: Optional[datetime] = None,
+) -> List[SliceOptionRecord]:
+    scenario_filter = _normalise_optional_text(scenario)
+    filtered: List[SliceOptionRecord] = []
+    for record in records:
+        if year is not None and record.year != year:
+            continue
+        if scenario_filter is not None and record.scenario != scenario_filter:
+            continue
+        if timestamp is not None and record.timestamp != timestamp:
+            continue
+        filtered.append(record)
+    return filtered
+
+
+def catalog_from_slice_option_snapshot(
+    snapshot: SliceOptionSnapshot,
+    year: Optional[int] = None,
+    scenario: Optional[str] = None,
+    timestamp: Optional[datetime] = None,
+) -> SliceOptionCatalog:
+    filtered = _filter_slice_option_records(
+        records=snapshot.records,
+        year=year,
+        scenario=scenario,
+        timestamp=timestamp,
+    )
+    years = tuple(sorted({record.year for record in filtered}))
+    feeders = tuple(sorted({record.feeder for record in filtered}))
+    scenarios = tuple(sorted({record.scenario for record in filtered}))
+    timestamps = tuple(sorted({record.timestamp for record in filtered}))
+    seasons = tuple(sorted({record.season for record in filtered}))
+    time_of_days = tuple(sorted({record.time_of_day for record in filtered}))
+    return SliceOptionCatalog(
+        years=years,
+        feeders=feeders,
+        scenarios=scenarios,
+        timestamps=timestamps,
+        seasons=seasons,
+        time_of_days=time_of_days,
+    )
+
+
+def season_time_of_day_pairs_from_snapshot(
+    snapshot: SliceOptionSnapshot,
+    year: int,
+    scenario: str,
+    timestamp: datetime,
+) -> List[Tuple[str, str]]:
+    filtered = _filter_slice_option_records(
+        records=snapshot.records,
+        year=year,
+        scenario=scenario,
+        timestamp=timestamp,
+    )
+    pairs = sorted({(record.season, record.time_of_day) for record in filtered})
+    return list(pairs)
+
+
+def feeders_for_year_from_snapshot(snapshot: SliceOptionSnapshot, year: int) -> Set[str]:
+    return {record.feeder for record in snapshot.records if record.year == year}
+
+
+def fetch_slice_option_catalog(
+    engine: Engine,
+    work_package_id: str,
+    year: Optional[int] = None,
+    scenario: Optional[str] = None,
+    feeders: Sequence[str] = (),
+) -> SliceOptionCatalog:
+    years_stmt = text(
+        """
+        SELECT DISTINCT EXTRACT(YEAR FROM "timestamp" AT TIME ZONE 'UTC')::int AS year
+        FROM public.network_performance_metrics_enhanced
+        WHERE work_package_id = :work_package_id
+        ORDER BY year
+        """
+    )
+    with engine.connect() as conn:
+        year_rows = conn.execute(years_stmt, {"work_package_id": work_package_id}).mappings().all()
+    years = tuple(int(row["year"]) for row in year_rows if row.get("year") is not None)
+
+    where_clause, params, has_feeders = _base_option_filters(
+        work_package_id=work_package_id,
+        year=year,
+        scenario=scenario,
+        feeders=feeders,
+    )
+
+    feeders_values = tuple(
+        _select_distinct_text_values(
+            engine=engine,
+            select_expression="feeder::text",
+            where_clause=where_clause,
+            params=params,
+            has_feeders=has_feeders,
+        )
+    )
+    scenarios = tuple(
+        _select_distinct_text_values(
+            engine=engine,
+            select_expression="scenario",
+            where_clause=where_clause,
+            params=params,
+            has_feeders=has_feeders,
+        )
+    )
+    seasons = tuple(
+        _select_distinct_text_values(
+            engine=engine,
+            select_expression="season",
+            where_clause=where_clause,
+            params=params,
+            has_feeders=has_feeders,
+        )
+    )
+    time_of_days = tuple(
+        _select_distinct_text_values(
+            engine=engine,
+            select_expression="time_of_day",
+            where_clause=where_clause,
+            params=params,
+            has_feeders=has_feeders,
+        )
+    )
+    timestamps = tuple(
+        _select_distinct_timestamps(
+            engine=engine,
+            where_clause=where_clause,
+            params=params,
+            has_feeders=has_feeders,
+        )
+    )
+
+    return SliceOptionCatalog(
+        years=years,
+        feeders=feeders_values,
+        scenarios=scenarios,
+        timestamps=timestamps,
+        seasons=seasons,
+        time_of_days=time_of_days,
+    )
+
+
+def fetch_slice_season_time_of_day_pairs(
+    engine: Engine,
+    work_package_id: str,
+    year: int,
+    scenario: str,
+    timestamp: datetime,
+    feeders: Sequence[str],
+) -> List[Tuple[str, str]]:
+    year_start, year_end = _year_bounds(year)
+    feeder_clause, has_feeders = _feeder_clause(feeders)
+
+    stmt = text(
+        f"""
+        SELECT DISTINCT season, time_of_day
+        FROM public.network_performance_metrics_enhanced
+        WHERE work_package_id = :work_package_id
+          AND scenario = :scenario
+          AND "timestamp" = :timestamp
+          AND "timestamp" >= :year_start
+          AND "timestamp" < :year_end
+          {feeder_clause}
+        ORDER BY season, time_of_day
+        """
+    )
+    if has_feeders:
+        stmt = stmt.bindparams(bindparam("feeders", expanding=True))
+
+    params: Dict[str, object] = {
+        "work_package_id": work_package_id,
+        "scenario": scenario,
+        "timestamp": timestamp,
+        "year_start": year_start,
+        "year_end": year_end,
+    }
+    if has_feeders:
+        params["feeders"] = list(feeders)
+
+    with engine.connect() as conn:
+        rows = conn.execute(stmt, params).mappings().all()
+
+    pairs: List[Tuple[str, str]] = []
+    for row in rows:
+        season = row.get("season")
+        time_of_day = row.get("time_of_day")
+        if season is None or time_of_day is None:
+            continue
+        pairs.append((str(season), str(time_of_day)))
+    return pairs
+
+
+def print_slice_option_catalog(
+    catalog: SliceOptionCatalog,
+    work_package_id: str,
+    selected_year: Optional[int],
+    selected_scenario: Optional[str],
+    selected_feeders: Sequence[str],
+) -> None:
+    print(f"Selectable options for work_package_id={work_package_id}")
+    print(
+        "Active filters: "
+        f"year={selected_year if selected_year is not None else 'ALL'}, "
+        f"scenario={selected_scenario.strip() if selected_scenario else 'ALL'}, "
+        f"feeders={'ALL' if not selected_feeders else len(selected_feeders)}"
+    )
+
+    if catalog.years:
+        print("  years: " + ", ".join(str(value) for value in catalog.years))
+    else:
+        print("  years: <none>")
+
+    if catalog.scenarios:
+        print("  scenarios: " + ", ".join(catalog.scenarios))
+    else:
+        print("  scenarios: <none>")
+
+    if catalog.seasons:
+        print("  seasons: " + ", ".join(catalog.seasons))
+    else:
+        print("  seasons: <none>")
+
+    if catalog.time_of_days:
+        print("  time_of_day: " + ", ".join(catalog.time_of_days))
+    else:
+        print("  time_of_day: <none>")
+
+    if catalog.timestamps:
+        print(f"  timestamps: {len(catalog.timestamps)} option(s)")
+        preview = [value.isoformat() for value in catalog.timestamps[:20]]
+        print("    " + ", ".join(preview))
+        if len(catalog.timestamps) > 20:
+            print("    ...")
+    else:
+        print("  timestamps: <none>")
+
+    if catalog.feeders:
+        print(f"  feeders: {len(catalog.feeders)} option(s)")
+        feeder_preview = list(catalog.feeders[:20])
+        print("    " + ", ".join(feeder_preview))
+        if len(catalog.feeders) > 20:
+            print("    ...")
+    else:
+        print("  feeders: <none>")
+
+
+def prompt_select_from_values(label: str, values: Sequence[str], default: Optional[str] = None) -> str:
+    if not values:
+        raise ValueError(f"No values available to select for {label}.")
+
+    print(f"Select {label}:")
+    for index, value in enumerate(values, start=1):
+        suffix = " (default)" if default is not None and value == default else ""
+        print(f"  {index}. {value}{suffix}")
+
+    default_index = None
+    if default is not None:
+        try:
+            default_index = list(values).index(default) + 1
+        except ValueError:
+            default_index = None
+
+    while True:
+        prompt = f"Enter {label} number"
+        if default_index is not None:
+            prompt += f" [{default_index}]"
+        prompt += ": "
+        entered = input(prompt).strip()
+        if not entered and default_index is not None:
+            return values[default_index - 1]
+        if entered.isdigit():
+            selected = int(entered)
+            if 1 <= selected <= len(values):
+                return values[selected - 1]
+        print(f"Invalid selection for {label}.")
+
+def resolve_scenario(
+    engine: Engine,
+    work_package_id: str,
+    year: int,
+    feeders: Sequence[str],
+    scenario: Optional[str],
+) -> str:
+    if scenario:
+        return scenario
+
+    year_start, year_end = _year_bounds(year)
+    clause, has_feeders = _feeder_clause(feeders)
+    stmt = text(
+        f"""
+        SELECT MIN(scenario) AS scenario
+        FROM public.network_performance_metrics_enhanced
+        WHERE work_package_id = :work_package_id
+          AND "timestamp" >= :year_start
+          AND "timestamp" < :year_end
+          {clause}
+        """
+    )
+    if has_feeders:
+        stmt = stmt.bindparams(bindparam("feeders", expanding=True))
+
+    params = {
+        "work_package_id": work_package_id,
+        "year_start": year_start,
+        "year_end": year_end,
+    }
+    if has_feeders:
+        params["feeders"] = list(feeders)
+
+    with engine.connect() as conn:
+        value = conn.execute(stmt, params).scalar_one_or_none()
+
+    if not value:
+        raise ValueError("Could not resolve a scenario for the requested work package/year/scope.")
+
+    return str(value)
+
+
+def resolve_timestamp(
+    engine: Engine,
+    work_package_id: str,
+    year: int,
+    feeders: Sequence[str],
+    scenario: str,
+    timestamp: Optional[str],
+) -> datetime:
+    if timestamp:
+        return _parse_timestamp(timestamp)
+
+    year_start, year_end = _year_bounds(year)
+    clause, has_feeders = _feeder_clause(feeders)
+    stmt = text(
+        f"""
+        SELECT MIN("timestamp") AS ts
+        FROM public.network_performance_metrics_enhanced
+        WHERE work_package_id = :work_package_id
+          AND scenario = :scenario
+          AND "timestamp" >= :year_start
+          AND "timestamp" < :year_end
+          {clause}
+        """
+    )
+    if has_feeders:
+        stmt = stmt.bindparams(bindparam("feeders", expanding=True))
+
+    params = {
+        "work_package_id": work_package_id,
+        "scenario": scenario,
+        "year_start": year_start,
+        "year_end": year_end,
+    }
+    if has_feeders:
+        params["feeders"] = list(feeders)
+
+    with engine.connect() as conn:
+        value = conn.execute(stmt, params).scalar_one_or_none()
+
+    if value is None:
+        raise ValueError("Could not resolve a timestamp for the requested work package/year/scenario/scope.")
+
+    if isinstance(value, datetime):
+        if value.tzinfo is None:
+            return value.replace(tzinfo=timezone.utc)
+        return value
+
+    return _parse_timestamp(str(value))
+
+
+def resolve_slice_selection(
+    engine: Engine,
+    work_package_id: str,
+    year: int,
+    feeders: Sequence[str],
+    scenario: Optional[str],
+    timestamp: Optional[str],
+    season: str,
+    time_of_day: str,
+) -> SliceSelection:
+    resolved_scenario = resolve_scenario(
+        engine=engine,
+        work_package_id=work_package_id,
+        year=year,
+        feeders=feeders,
+        scenario=scenario,
+    )
+    resolved_timestamp = resolve_timestamp(
+        engine=engine,
+        work_package_id=work_package_id,
+        year=year,
+        feeders=feeders,
+        scenario=resolved_scenario,
+        timestamp=timestamp,
+    )
+
+    return SliceSelection(
+        work_package_id=work_package_id,
+        year=year,
+        scenario=resolved_scenario,
+        timestamp=resolved_timestamp,
+        season=season,
+        time_of_day=time_of_day,
+        feeders=tuple(sorted(set(feeders))),
+    )
+
+
+def _as_float(value) -> Optional[float]:
+    if value is None:
+        return None
+    try:
+        return float(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def fetch_metric_rows(engine: Engine, selection: SliceSelection) -> List[DbMetricRow]:
+    clause, has_feeders = _feeder_clause(selection.feeders)
+
+    stmt = text(
+        f"""
+        SELECT
+            work_package_id::text AS work_package_id,
+            scenario,
+            "timestamp",
+            feeder::text AS feeder,
+            measurement_zone_name,
+            mz_type,
+            conducting_equipment_mrid::text AS conducting_equipment_mrid,
+            season,
+            time_of_day,
+            v_base,
+            peak_import,
+            peak_export,
+            load_exceeding_normal_thermal_voltage_kwh,
+            gen_exceeding_normal_thermal_voltage_kwh,
+            v1_avg_section_voltage,
+            v99_avg_section_voltage
+        FROM public.network_performance_metrics_enhanced
+        WHERE work_package_id = :work_package_id
+          AND scenario = :scenario
+          AND "timestamp" = :timestamp
+          AND season = :season
+          AND time_of_day = :time_of_day
+          {clause}
+        ORDER BY feeder::text, measurement_zone_name, conducting_equipment_mrid::text
+        """
+    )
+
+    if has_feeders:
+        stmt = stmt.bindparams(bindparam("feeders", expanding=True))
+
+    params = {
+        "work_package_id": selection.work_package_id,
+        "scenario": selection.scenario,
+        "timestamp": selection.timestamp,
+        "season": selection.season,
+        "time_of_day": selection.time_of_day,
+    }
+    if has_feeders:
+        params["feeders"] = list(selection.feeders)
+
+    with engine.connect() as conn:
+        rows = conn.execute(stmt, params).mappings().all()
+
+    parsed: List[DbMetricRow] = []
+    for row in rows:
+        ts = row["timestamp"]
+        if isinstance(ts, datetime):
+            ts_value = ts if ts.tzinfo is not None else ts.replace(tzinfo=timezone.utc)
+        else:
+            ts_value = _parse_timestamp(str(ts))
+
+        parsed.append(
+            DbMetricRow(
+                work_package_id=str(row["work_package_id"]),
+                scenario=str(row["scenario"]),
+                timestamp=ts_value,
+                feeder=str(row["feeder"]),
+                measurement_zone_name=str(row["measurement_zone_name"]),
+                mz_type=str(row["mz_type"]),
+                conducting_equipment_mrid=str(row["conducting_equipment_mrid"]),
+                season=str(row["season"]),
+                time_of_day=str(row["time_of_day"]),
+                v_base=_as_float(row["v_base"]),
+                peak_import=_as_float(row["peak_import"]),
+                peak_export=_as_float(row["peak_export"]),
+                load_exceeding_normal_thermal_voltage_kwh=_as_float(row["load_exceeding_normal_thermal_voltage_kwh"]),
+                gen_exceeding_normal_thermal_voltage_kwh=_as_float(row["gen_exceeding_normal_thermal_voltage_kwh"]),
+                v1_avg_section_voltage=_as_float(row["v1_avg_section_voltage"]),
+                v99_avg_section_voltage=_as_float(row["v99_avg_section_voltage"]),
+            )
+        )
+
+    return parsed
+
+
+async def build_feeder_trace_context(ewb: EwbSettings, feeder_mrid: str) -> FeederTraceContext:
+    rpc_channel = _connect_rpc(ewb)
+    client = NetworkConsumerClient(rpc_channel)
+    result = None
+    fetch_error = None
+    max_attempts = 3
+    for attempt in range(1, max_attempts + 1):
+        result = await client.get_equipment_container(
+            mrid=feeder_mrid,
+            expected_class=Feeder,
+            include_energized_containers=IncludedEnergizedContainers.LV_FEEDERS,
+        )
+        if not result.was_failure:
+            fetch_error = None
+            break
+
+        fetch_error = result.thrown
+        if attempt < max_attempts and _is_deadline_exceeded_error(fetch_error):
+            await asyncio.sleep(2 ** (attempt - 1))
+            continue
+        break
+
+    if result is None or result.was_failure:
+        raise RuntimeError(f"Failed to fetch feeder {feeder_mrid}: {fetch_error}")
+
+    network = client.service
+    await Tracing.set_direction().run(network, network_state_operators=NetworkStateOperators.NORMAL)
+
+    equipment_by_mrid: Dict[str, ConductingEquipment] = {}
+    for equipment in network.objects(ConductingEquipment):
+        equipment_by_mrid[str(equipment.mrid)] = equipment
+
+    feeder_head: Optional[ConductingEquipment] = None
+    for feeder in network.objects(Feeder):
+        if str(feeder.mrid) != feeder_mrid:
+            continue
+        if feeder.normal_head_terminal and isinstance(feeder.normal_head_terminal.conducting_equipment, ConductingEquipment):
+            feeder_head = feeder.normal_head_terminal.conducting_equipment
+            break
+
+    downstream_edges_by_from: DefaultDict[str, Set[str]] = defaultdict(set)
+    traversed_lines_by_edge: DefaultDict[Tuple[str, str], Set[str]] = defaultdict(set)
+
+    if feeder_head is not None:
+
+        async def collect_edges(step: NetworkTraceStep, _):
+            from_equipment = step.path.from_equipment
+            to_equipment = step.path.to_equipment
+            traversed = step.path.traversed_ac_line_segment
+            if not isinstance(from_equipment, ConductingEquipment) or not isinstance(to_equipment, ConductingEquipment):
+                return
+
+            from_mrid = str(from_equipment.mrid)
+            to_mrid = str(to_equipment.mrid)
+            if from_mrid == to_mrid:
+                return
+
+            downstream_edges_by_from[from_mrid].add(to_mrid)
+            if isinstance(traversed, AcLineSegment):
+                traversed_lines_by_edge[(from_mrid, to_mrid)].add(str(traversed.mrid))
+
+        await (
+            Tracing.network_trace()
+            .add_condition(downstream())
+            .add_step_action(collect_edges)
+        ).run(start=feeder_head, phases=PhaseCode.ABCN, can_stop_on_start_item=False)
+
+    return FeederTraceContext(
+        feeder_mrid=feeder_mrid,
+        equipment_by_mrid=equipment_by_mrid,
+        downstream_edges_by_from={key: set(values) for key, values in downstream_edges_by_from.items()},
+        traversed_lines_by_edge={key: set(values) for key, values in traversed_lines_by_edge.items()},
+    )
+
+
+def _trace_zone_segment_from_graph(
+    start_mrid: str,
+    downstream_edges_by_from: Mapping[str, Set[str]],
+    traversed_lines_by_edge: Mapping[Tuple[str, str], Set[str]],
+    boundary_head_ids: Set[str],
+) -> Tuple[Set[str], Set[Tuple[str, str]]]:
+    assets: Set[str] = {start_mrid}
+    edges: Set[Tuple[str, str]] = set()
+    visited: Set[str] = set()
+    stack: List[str] = [start_mrid]
+
+    while stack:
+        current = stack.pop()
+        if current in visited:
+            continue
+        visited.add(current)
+
+        for downstream_mrid in downstream_edges_by_from.get(current, set()):
+            edge = (current, downstream_mrid)
+            edges.add(edge)
+
+            for line_mrid in traversed_lines_by_edge.get(edge, set()):
+                assets.add(line_mrid)
+
+            if downstream_mrid in boundary_head_ids and downstream_mrid != start_mrid:
+                continue
+
+            assets.add(downstream_mrid)
+            if downstream_mrid not in visited:
+                stack.append(downstream_mrid)
+
+    return assets, edges
+
+
+async def map_zone_heads_to_assets(
+    context: FeederTraceContext,
+    head_ids: Set[str],
+) -> Tuple[Dict[str, Set[str]], List[str]]:
+    available_heads = {head_id for head_id in head_ids if head_id in context.equipment_by_mrid}
+    missing_heads = sorted(head_ids.difference(available_heads))
+
+    mapped: Dict[str, Set[str]] = {}
+    for head_id in sorted(available_heads):
+        boundaries = available_heads.difference({head_id})
+        mapped[head_id], _ = _trace_zone_segment_from_graph(
+            start_mrid=head_id,
+            downstream_edges_by_from=context.downstream_edges_by_from,
+            traversed_lines_by_edge=context.traversed_lines_by_edge,
+            boundary_head_ids=boundaries,
+        )
+
+    return mapped, missing_heads
+
+
+async def map_zone_heads_to_assets_and_edges(
+    context: FeederTraceContext,
+    head_ids: Set[str],
+) -> Tuple[Dict[str, Set[str]], Dict[str, Set[Tuple[str, str]]], List[str]]:
+    available_heads = {head_id for head_id in head_ids if head_id in context.equipment_by_mrid}
+    missing_heads = sorted(head_ids.difference(available_heads))
+
+    mapped_assets: Dict[str, Set[str]] = {}
+    mapped_edges: Dict[str, Set[Tuple[str, str]]] = {}
+
+    for head_id in sorted(available_heads):
+        boundaries = available_heads.difference({head_id})
+        assets, edges = _trace_zone_segment_from_graph(
+            start_mrid=head_id,
+            downstream_edges_by_from=context.downstream_edges_by_from,
+            traversed_lines_by_edge=context.traversed_lines_by_edge,
+            boundary_head_ids=boundaries,
+        )
+        mapped_assets[head_id] = assets
+        mapped_edges[head_id] = edges
+
+    return mapped_assets, mapped_edges, missing_heads
+
+
+def to_equipment_geometry(equipment: ConductingEquipment):
+    location = getattr(equipment, "location", None)
+    points = list(location.points) if location is not None else []
+
+    if len(points) > 1:
+        coords = [(point.x_position, point.y_position) for point in points]
+        return "line", LineString(coords)
+
+    if len(points) == 1:
+        point = points[0]
+        return "point", Point((point.x_position, point.y_position))
+
+    return None, None
+
+
+def to_equipment_point(equipment: ConductingEquipment) -> Optional[Tuple[float, float]]:
+    location = getattr(equipment, "location", None)
+    points = list(location.points) if location is not None else []
+
+    if not points:
+        return None
+
+    if len(points) == 1:
+        p = points[0]
+        return p.x_position, p.y_position
+
+    mean_x = sum(p.x_position for p in points) / len(points)
+    mean_y = sum(p.y_position for p in points) / len(points)
+    return mean_x, mean_y
+
+
+def to_edge_geometry(
+    equipment_by_mrid: Dict[str, ConductingEquipment],
+    from_mrid: str,
+    to_mrid: str,
+) -> Optional[LineString]:
+    from_equipment = equipment_by_mrid.get(from_mrid)
+    to_equipment = equipment_by_mrid.get(to_mrid)
+    if from_equipment is None or to_equipment is None:
+        return None
+
+    from_point = to_equipment_point(from_equipment)
+    to_point = to_equipment_point(to_equipment)
+    if from_point is None or to_point is None:
+        return None
+    if from_point == to_point:
+        return None
+
+    return LineString([from_point, to_point])
+
+
+def compute_percentiles(values: Sequence[float], probabilities: Sequence[float]) -> List[float]:
+    if not values:
+        return [0.0 for _ in probabilities]
+
+    ordered = sorted(values)
+    last_index = len(ordered) - 1
+    output: List[float] = []
+
+    for prob in probabilities:
+        p = max(0.0, min(1.0, float(prob)))
+        index = p * last_index
+        low = int(math.floor(index))
+        high = int(math.ceil(index))
+        if low == high:
+            output.append(ordered[low])
+            continue
+        fraction = index - low
+        output.append(ordered[low] * (1.0 - fraction) + ordered[high] * fraction)
+
+    return output
+
+
+def bucket_from_thresholds(value: float, thresholds: Sequence[float]) -> int:
+    if len(thresholds) != 4:
+        raise ValueError("Expected exactly 4 thresholds.")
+
+    if value <= thresholds[0]:
+        return 0
+    if value <= thresholds[1]:
+        return 1
+    if value <= thresholds[2]:
+        return 2
+    if value <= thresholds[3]:
+        return 3
+    return 4
+
+
+def normalise(value: float, min_value: float, max_value: float, default: float = 0.5) -> float:
+    spread = max_value - min_value
+    if spread <= 1e-9:
+        return default
+    scaled = (value - min_value) / spread
+    return max(0.0, min(1.0, scaled))
diff --git a/src/zepben/examples/studies/hosting_capacity_examples/hcm_asset_metrics_study.py b/src/zepben/examples/studies/hosting_capacity_examples/hcm_asset_metrics_study.py
new file mode 100644
index 0000000..e66f81a
--- /dev/null
+++ b/src/zepben/examples/studies/hosting_capacity_examples/hcm_asset_metrics_study.py
@@ -0,0 +1,785 @@
+#  Copyright 2026 Zeppelin Bend Pty Ltd
+#
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import math
+import sys
+from collections import defaultdict
+from pathlib import Path
+from typing import Dict, List, Optional, Sequence, Set, Tuple
+
+import aiohttp
+from geojson import Feature, FeatureCollection
+from zepben.eas.client.eas_client import EasClient
+from zepben.eas.client.study import GeoJsonOverlay, Result, Study
+from zepben.ewb import AcLineSegment, ConductingEquipment, PowerTransformer
+
+try:
+    from zepben.examples.studies.hosting_capacity_examples.common import (
+        bucket_from_thresholds,
+        build_feeder_trace_context,
+        canonical_mz_type,
+        catalog_from_slice_option_snapshot,
+        combine_feeder_scope,
+        compute_percentiles,
+        create_postgres_engine,
+        feeders_for_year_from_snapshot,
+        fetch_metric_rows,
+        fetch_prefixed_feeders,
+        fetch_slice_option_snapshot,
+        is_trace_source_mz_type,
+        load_db_settings,
+        load_ewb_settings,
+        map_zone_heads_to_assets,
+        print_slice_option_catalog,
+        prompt_select_from_values,
+        resolve_slice_selection,
+        resolve_zone_feeders,
+        should_apply_transformer_trace_fallback,
+        season_time_of_day_pairs_from_snapshot,
+        split_csv_values,
+        to_equipment_geometry,
+    )
+except ModuleNotFoundError:
+    from common import (  # type: ignore
+        bucket_from_thresholds,
+        build_feeder_trace_context,
+        canonical_mz_type,
+        catalog_from_slice_option_snapshot,
+        combine_feeder_scope,
+        compute_percentiles,
+        create_postgres_engine,
+        feeders_for_year_from_snapshot,
+        fetch_metric_rows,
+        fetch_prefixed_feeders,
+        fetch_slice_option_snapshot,
+        is_trace_source_mz_type,
+        load_db_settings,
+        load_ewb_settings,
+        map_zone_heads_to_assets,
+        print_slice_option_catalog,
+        prompt_select_from_values,
+        resolve_slice_selection,
+        resolve_zone_feeders,
+        should_apply_transformer_trace_fallback,
+        season_time_of_day_pairs_from_snapshot,
+        split_csv_values,
+        to_equipment_geometry,
+    )
+
+
+STYLE_PATH = Path(__file__).resolve().parent / "style_hcm_asset_metrics.json"
+
+METRIC_SPECS: List[Tuple[str, str, str]] = [
+    ("peak_import", "Peak Import", "hc-peak-import"),
+    ("peak_export", "Peak Export", "hc-peak-export"),
+    ("import_utilisation", "Import Utilisation", "hc-import-utilisation"),
+    ("export_utilisation", "Export Utilisation", "hc-export-utilisation"),
+    (
+        "load_exceeding_normal_thermal_voltage_kwh",
+        "Load Exceeding Normal Thermal + Voltage (kWh)",
+        "hc-load-thermal-voltage",
+    ),
+    (
+        "gen_exceeding_normal_thermal_voltage_kwh",
+        "Generation Exceeding Normal Thermal + Voltage (kWh)",
+        "hc-gen-thermal-voltage",
+    ),
+]
+
+BUCKET_LABELS = {
+    0: "Very Low",
+    1: "Low",
+    2: "Medium",
+    3: "High",
+    4: "Very High",
+}
+
+
+def summarise_zone_names(zone_names: Set[str], limit: int = 4) -> str:
+    ordered = sorted(name for name in zone_names if name)
+    if not ordered:
+        return ""
+    if len(ordered) <= limit:
+        return ", ".join(ordered)
+    return ", ".join(ordered[:limit]) + f" (+{len(ordered) - limit} more)"
+
+
+def _as_positive_float(value: object) -> Optional[float]:
+    if value is None:
+        return None
+    try:
+        parsed = float(value)
+    except (TypeError, ValueError):
+        return None
+    if parsed <= 0:
+        return None
+    return parsed
+
+
+def _transformer_rating_kva(eq: ConductingEquipment) -> Optional[float]:
+    if not isinstance(eq, PowerTransformer):
+        return None
+    ratings: List[float] = []
+    for end in getattr(eq, "ends", []) or []:
+        rated_s = getattr(end, "rated_s", None)
+        if rated_s is not None:
+            ratings.append(float(rated_s) / 1000.0)
+            continue
+        for rating in getattr(end, "s_ratings", []) or []:
+            rated_s = getattr(rating, "rated_s", None)
+            if rated_s is not None:
+                ratings.append(float(rated_s) / 1000.0)
+    return max(ratings) if ratings else None
+
+
+def _line_rating_amp(line: AcLineSegment) -> Optional[float]:
+    direct = _as_positive_float(getattr(line, "rated_current", None))
+    if direct is not None:
+        return direct
+
+    asset_info = getattr(line, "asset_info", None)
+    if asset_info is not None:
+        info_rating = _as_positive_float(getattr(asset_info, "rated_current", None))
+        if info_rating is not None:
+            return info_rating
+
+    for limits_attr in ("normal_current_limits", "current_limits", "operational_limits"):
+        limits = getattr(line, limits_attr, None)
+        if not limits:
+            continue
+        values: List[float] = []
+        for limit in limits:
+            for field in ("value", "normal_value", "current_limit", "rated_current", "limit_value"):
+                rating = _as_positive_float(getattr(limit, field, None))
+                if rating is not None:
+                    values.append(rating)
+        if values:
+            return max(values)
+    return None
+
+
+def _phase_letters_from_phase_code(phase_obj) -> Set[str]:
+    if phase_obj is None:
+        return set()
+    candidates = [str(phase_obj).upper()]
+    try:
+        as_code = phase_obj.as_phase_code() if hasattr(phase_obj, "as_phase_code") else None
+        if as_code is not None:
+            candidates.append(str(as_code).upper())
+    except Exception:
+        pass
+
+    letters: Set[str] = set()
+    for text in candidates:
+        token = text.split(".")[-1]
+        for ch in token:
+            if ch in {"A", "B", "C"}:
+                letters.add(ch)
+    return letters
+
+
+def _line_phase_count(line: AcLineSegment) -> int:
+    letters: Set[str] = set()
+    for terminal in getattr(line, "terminals", []) or []:
+        letters.update(_phase_letters_from_phase_code(getattr(terminal, "phases", None)))
+        letters.update(_phase_letters_from_phase_code(getattr(terminal, "normal_phases", None)))
+
+    if letters:
+        return len(letters)
+    return 3
+
+
+def _first_zone_head_line_mrid(context, head_mrid: str) -> Optional[str]:
+    equipment = context.equipment_by_mrid.get(head_mrid)
+    if isinstance(equipment, AcLineSegment):
+        return head_mrid
+
+    visited: Set[str] = set()
+    queue: List[str] = [head_mrid]
+    while queue:
+        current = queue.pop(0)
+        if current in visited:
+            continue
+        visited.add(current)
+        for downstream_mrid in sorted(context.downstream_edges_by_from.get(current, set())):
+            downstream_eq = context.equipment_by_mrid.get(downstream_mrid)
+            if isinstance(downstream_eq, AcLineSegment):
+                return downstream_mrid
+
+            edge = (current, downstream_mrid)
+            lines = sorted(context.traversed_lines_by_edge.get(edge, set()))
+            if lines:
+                return lines[0]
+            if downstream_mrid not in visited:
+                queue.append(downstream_mrid)
+    return None
+
+
+def _zone_rating(context, head_mrid: str) -> Tuple[Optional[float], Optional[str], Optional[str], Optional[int]]:
+    equipment = context.equipment_by_mrid.get(head_mrid)
+    if equipment is None:
+        return None, None, None, None
+
+    tx_rating = _transformer_rating_kva(equipment)
+    if tx_rating is not None:
+        return tx_rating, "kVA", head_mrid, None
+
+    line_mrid = _first_zone_head_line_mrid(context, head_mrid)
+    if line_mrid is None:
+        return None, None, None, None
+    line_eq = context.equipment_by_mrid.get(line_mrid)
+    if not isinstance(line_eq, AcLineSegment):
+        return None, None, None, None
+
+    line_rating = _line_rating_amp(line_eq)
+    phase_count = _line_phase_count(line_eq)
+    if line_rating is None:
+        return None, None, line_mrid, phase_count
+    return line_rating, "A", line_mrid, phase_count
+
+
+def _utilisation_value(
+    metric_key: str,
+    peak_import_kw: Optional[float],
+    peak_export_kw: Optional[float],
+    rating_value: Optional[float],
+    rating_unit: Optional[str],
+    v_base: Optional[float],
+    phase_count: Optional[int],
+) -> Optional[float]:
+    if rating_value is None or rating_unit is None:
+        return None
+
+    if metric_key == "import_utilisation":
+        source = peak_import_kw
+        if source is None:
+            return None
+        magnitude = abs(float(source))
+    elif metric_key == "export_utilisation":
+        source = peak_export_kw
+        if source is None:
+            return None
+        magnitude = abs(float(source))
+    else:
+        return None
+
+    if rating_unit == "kVA":
+        if rating_value <= 0:
+            return None
+        return (magnitude / rating_value) * 100.0
+
+    if rating_unit == "A":
+        phase_n = phase_count or 3
+        if phase_n <= 0:
+            phase_n = 3
+        if rating_value <= 0 or v_base is None or v_base <= 0:
+            return None
+        # Line rating is per phase. DB peaks are total zone flow, so split
+        # across available phases on the zone-head line.
+        current_a = (magnitude * 1000.0 * math.sqrt(3.0)) / (phase_n * float(v_base))
+        return (current_a / rating_value) * 100.0
+
+    return None
+
+
+def parse_args(argv: Sequence[str]) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Upload a Hosting Capacity asset metrics study using DB results propagated "
+            "from measurement-zone heads until the next downstream measurement zone."
+        )
+    )
+    parser.add_argument("--work-package-id", required=True, help="Work package ID.")
+    parser.add_argument("--year", type=int, help="Result year (calendar year).")
+    parser.add_argument("--zones", default="", help="Comma-separated zone codes.")
+    parser.add_argument(
+        "--feeder-prefixes",
+        default="",
+        help="Comma-separated feeder prefixes (matched against DB feeder column).",
+    )
+    parser.add_argument("--scenario", default="", help="Optional scenario override.")
+    parser.add_argument(
+        "--timestamp",
+        default="",
+        help="Optional timestamp override (ISO-8601, e.g. 2025-06-30T14:30:00+00:00).",
+    )
+    parser.add_argument("--season", default="all", help="Season filter (default: all).")
+    parser.add_argument("--time-of-day", default="all", help="Time-of-day filter (default: all).")
+    parser.add_argument("--env-file", default=".env", help="Path to .env with EWB_* and INPUT_DB_* keys.")
+    parser.add_argument("--name", default="Hosting Capacity Asset Metrics", help="Study name.")
+    parser.add_argument(
+        "--list-options",
+        action="store_true",
+        help="List selectable year/scenario/timestamp/season/time-of-day/feeders for the work package and exit.",
+    )
+    parser.add_argument(
+        "--interactive",
+        action="store_true",
+        help="Prompt for missing slice selections (year/scenario/timestamp).",
+    )
+    parser.add_argument("--dry-run", action="store_true", help="Generate results but do not upload.")
+    return parser.parse_args(argv)
+
+
+async def main(argv: Sequence[str]) -> None:
+    args = parse_args(argv)
+
+    zone_codes = split_csv_values(args.zones)
+    feeder_prefixes = split_csv_values(args.feeder_prefixes)
+
+    ewb_settings = load_ewb_settings(args.env_file)
+    db_settings = load_db_settings(args.env_file)
+    styles = json.load(open(STYLE_PATH, "r"))
+
+    engine = create_postgres_engine(db_settings)
+
+    try:
+        zone_feeders = await resolve_zone_feeders(ewb_settings, zone_codes) if zone_codes else set()
+        prefix_feeders = (
+            fetch_prefixed_feeders(
+                engine=engine,
+                work_package_id=args.work_package_id,
+                year=args.year,
+                feeder_prefixes=feeder_prefixes,
+            )
+            if feeder_prefixes
+            else set()
+        )
+        if feeder_prefixes and not prefix_feeders:
+            print(
+                "No feeders matched --feeder-prefixes for the current filter "
+                f"(year={args.year if args.year is not None else 'ALL'})."
+            )
+
+        selected_feeders: Set[str] = set()
+        if zone_feeders or prefix_feeders:
+            selected_feeders = combine_feeder_scope(zone_feeders=zone_feeders, prefix_feeders=prefix_feeders)
+
+        scenario_arg = args.scenario.strip() or None
+        option_snapshot = None
+
+        if args.list_options or args.interactive or args.year is None:
+            option_snapshot = fetch_slice_option_snapshot(
+                engine=engine,
+                work_package_id=args.work_package_id,
+                feeders=sorted(selected_feeders),
+            )
+            catalog = catalog_from_slice_option_snapshot(
+                snapshot=option_snapshot,
+                year=args.year,
+                scenario=scenario_arg,
+            )
+            print_slice_option_catalog(
+                catalog=catalog,
+                work_package_id=args.work_package_id,
+                selected_year=args.year,
+                selected_scenario=scenario_arg,
+                selected_feeders=sorted(selected_feeders),
+            )
+
+            if args.list_options and not args.interactive:
+                return
+
+            if args.year is None and not args.interactive:
+                print("No year selected. Re-run with --year or use --interactive.")
+                return
+
+        resolved_year = args.year
+        if resolved_year is None and args.interactive:
+            if option_snapshot is None:
+                option_snapshot = fetch_slice_option_snapshot(
+                    engine=engine,
+                    work_package_id=args.work_package_id,
+                    feeders=sorted(selected_feeders),
+                )
+            unfiltered_catalog = catalog_from_slice_option_snapshot(snapshot=option_snapshot)
+            selected_year_value = prompt_select_from_values(
+                label="year",
+                values=[str(value) for value in unfiltered_catalog.years],
+            )
+            resolved_year = int(selected_year_value)
+
+        if resolved_year is None:
+            raise ValueError("A year is required. Use --year or --interactive.")
+
+        if not zone_codes and not feeder_prefixes:
+            raise ValueError("At least one scope is required: --zones and/or --feeder-prefixes")
+
+        if not selected_feeders:
+            selected_feeders = combine_feeder_scope(zone_feeders=zone_feeders, prefix_feeders=prefix_feeders)
+
+        if option_snapshot is None:
+            option_snapshot = fetch_slice_option_snapshot(
+                engine=engine,
+                work_package_id=args.work_package_id,
+                feeders=sorted(selected_feeders),
+            )
+        year_feeders = feeders_for_year_from_snapshot(option_snapshot, resolved_year)
+        if not year_feeders:
+            raise ValueError(
+                f"No feeders in scope have rows for year {resolved_year}. "
+                "Use --list-options to inspect available years."
+            )
+        selected_feeders = selected_feeders.intersection(year_feeders)
+        if not selected_feeders:
+            raise ValueError(
+                f"No feeders matched the requested scope for year {resolved_year}."
+            )
+
+        resolved_scenario = scenario_arg
+        resolved_timestamp = args.timestamp.strip() or None
+        filtered_catalog = catalog_from_slice_option_snapshot(
+            snapshot=option_snapshot,
+            year=resolved_year,
+            scenario=resolved_scenario,
+        )
+        if resolved_scenario is None:
+            if not filtered_catalog.scenarios:
+                raise ValueError("No scenarios available for selected year/scope.")
+            if args.interactive:
+                resolved_scenario = prompt_select_from_values(
+                    label="scenario",
+                    values=list(filtered_catalog.scenarios),
+                )
+            else:
+                resolved_scenario = filtered_catalog.scenarios[0]
+
+        filtered_catalog = catalog_from_slice_option_snapshot(
+            snapshot=option_snapshot,
+            year=resolved_year,
+            scenario=resolved_scenario,
+        )
+        if resolved_timestamp is None:
+            if not filtered_catalog.timestamps:
+                raise ValueError("No timestamps available for selected year/scenario/scope.")
+            if resolved_scenario is None:
+                raise ValueError("Could not resolve scenario.")
+            if args.interactive:
+                resolved_timestamp = prompt_select_from_values(
+                    label="timestamp",
+                    values=[value.isoformat() for value in filtered_catalog.timestamps],
+                )
+            else:
+                resolved_timestamp = filtered_catalog.timestamps[0].isoformat()
+
+        resolved_season = args.season.strip() or "all"
+        resolved_time_of_day = args.time_of_day.strip() or "all"
+
+        selection = resolve_slice_selection(
+            engine=engine,
+            work_package_id=args.work_package_id,
+            year=resolved_year,
+            feeders=sorted(selected_feeders),
+            scenario=resolved_scenario,
+            timestamp=resolved_timestamp,
+            season=resolved_season,
+            time_of_day=resolved_time_of_day,
+        )
+
+        season_time_pairs = season_time_of_day_pairs_from_snapshot(
+            snapshot=option_snapshot,
+            year=selection.year,
+            scenario=selection.scenario,
+            timestamp=selection.timestamp,
+        )
+        if not season_time_pairs:
+            raise RuntimeError(
+                "No season/time_of_day rows available for the resolved work package/scenario/timestamp/feeders."
+            )
+
+        available_seasons = sorted({season for season, _ in season_time_pairs})
+        if selection.season not in available_seasons:
+            if args.interactive:
+                season_default = "yearly" if "yearly" in available_seasons else available_seasons[0]
+                selected_season = prompt_select_from_values(
+                    label="season",
+                    values=available_seasons,
+                    default=season_default,
+                )
+                selection = resolve_slice_selection(
+                    engine=engine,
+                    work_package_id=args.work_package_id,
+                    year=resolved_year,
+                    feeders=sorted(selected_feeders),
+                    scenario=selection.scenario,
+                    timestamp=selection.timestamp.isoformat(),
+                    season=selected_season,
+                    time_of_day=selection.time_of_day,
+                )
+            else:
+                raise ValueError(
+                    f"Season '{selection.season}' is not valid for the resolved slice. "
+                    f"Available seasons: {', '.join(available_seasons)}"
+                )
+
+        available_tods = sorted({tod for season, tod in season_time_pairs if season == selection.season})
+        if selection.time_of_day not in available_tods:
+            if args.interactive:
+                tod_default = "all" if "all" in available_tods else available_tods[0]
+                selected_tod = prompt_select_from_values(
+                    label="time_of_day",
+                    values=available_tods,
+                    default=tod_default,
+                )
+                selection = resolve_slice_selection(
+                    engine=engine,
+                    work_package_id=args.work_package_id,
+                    year=resolved_year,
+                    feeders=sorted(selected_feeders),
+                    scenario=selection.scenario,
+                    timestamp=selection.timestamp.isoformat(),
+                    season=selection.season,
+                    time_of_day=selected_tod,
+                )
+            else:
+                raise ValueError(
+                    f"time_of_day '{selection.time_of_day}' is not valid for season '{selection.season}'. "
+                    f"Available time_of_day values: {', '.join(available_tods)}"
+                )
+
+        print(
+            "Resolved slice: "
+            f"scenario={selection.scenario}, "
+            f"timestamp={selection.timestamp.isoformat()}, "
+            f"season={selection.season}, time_of_day={selection.time_of_day}, "
+            f"feeders={len(selection.feeders)}"
+        )
+
+        rows = fetch_metric_rows(engine, selection)
+        if not rows:
+            raise RuntimeError("No rows returned for the resolved slice.")
+
+        print(f"Fetched {len(rows)} DB rows.")
+
+        rows_by_feeder: Dict[str, List] = defaultdict(list)
+        for row in rows:
+            rows_by_feeder[row.feeder].append(row)
+
+        segment_geometries: Dict[str, object] = {}
+        metric_segment_values: Dict[str, Dict[str, List[float]]] = {
+            metric_key: defaultdict(list) for metric_key, _, _ in METRIC_SPECS
+        }
+        metric_segment_zones: Dict[str, Dict[str, Set[str]]] = {
+            metric_key: defaultdict(set) for metric_key, _, _ in METRIC_SPECS
+        }
+        metric_segment_rating: Dict[str, Dict[str, Tuple[Optional[float], Optional[str], Optional[int]]]] = {
+            metric_key: {} for metric_key, _, _ in METRIC_SPECS
+        }
+
+        missing_head_total = 0
+        for feeder_mrid in sorted(rows_by_feeder.keys()):
+            feeder_rows = rows_by_feeder[feeder_mrid]
+            print(f"Tracing feeder {feeder_mrid} ({len(feeder_rows)} zone rows)")
+            transformer_trace_fallback = should_apply_transformer_trace_fallback(
+                [row.mz_type for row in feeder_rows]
+            )
+            if transformer_trace_fallback:
+                print(
+                    "  - transformer trace fallback enabled "
+                    "(transformer/feeder-head-only measurement zones)."
+                )
+
+            context = await build_feeder_trace_context(ewb_settings, feeder_mrid)
+            head_ids = {row.conducting_equipment_mrid for row in feeder_rows}
+            head_to_assets, missing_heads = await map_zone_heads_to_assets(context, head_ids)
+
+            if missing_heads:
+                missing_head_total += len(missing_heads)
+                print(f"  - missing zone heads in network model: {len(missing_heads)}")
+
+            zone_rating_cache: Dict[str, Tuple[Optional[float], Optional[str], Optional[str], Optional[int]]] = {}
+            trace_source_rows = 0
+            point_source_rows = 0
+            for row in feeder_rows:
+                canonical_mz = canonical_mz_type(row.mz_type)
+                use_trace_source = is_trace_source_mz_type(row.mz_type) or (
+                    transformer_trace_fallback and canonical_mz == "TRANSFORMER"
+                )
+
+                if use_trace_source:
+                    trace_source_rows += 1
+                    mapped_assets = head_to_assets.get(row.conducting_equipment_mrid)
+                else:
+                    point_source_rows += 1
+                    mapped_assets = {row.conducting_equipment_mrid}
+                if not mapped_assets:
+                    continue
+
+                if row.conducting_equipment_mrid not in zone_rating_cache:
+                    zone_rating_cache[row.conducting_equipment_mrid] = _zone_rating(context, row.conducting_equipment_mrid)
+                zone_rating_value, zone_rating_unit, _, zone_phase_count = zone_rating_cache[row.conducting_equipment_mrid]
+
+                row_metric_values: Dict[str, Optional[float]] = {
+                    "peak_import": row.peak_import,
+                    "peak_export": row.peak_export,
+                    "load_exceeding_normal_thermal_voltage_kwh": row.load_exceeding_normal_thermal_voltage_kwh,
+                    "gen_exceeding_normal_thermal_voltage_kwh": row.gen_exceeding_normal_thermal_voltage_kwh,
+                    "import_utilisation": _utilisation_value(
+                        "import_utilisation",
+                        row.peak_import,
+                        row.peak_export,
+                        zone_rating_value,
+                        zone_rating_unit,
+                        row.v_base,
+                        zone_phase_count,
+                    ),
+                    "export_utilisation": _utilisation_value(
+                        "export_utilisation",
+                        row.peak_import,
+                        row.peak_export,
+                        zone_rating_value,
+                        zone_rating_unit,
+                        row.v_base,
+                        zone_phase_count,
+                    ),
+                }
+
+                for asset_mrid in (mapped_assets or set()):
+                    equipment = context.equipment_by_mrid.get(asset_mrid)
+                    if equipment is None:
+                        continue
+                    geom_kind, geometry = to_equipment_geometry(equipment)
+                    if geometry is None or geom_kind != "line":
+                        continue
+
+                    segment_key = f"asset:{asset_mrid}"
+                    segment_geometries.setdefault(segment_key, geometry)
+                    for metric_key, _, _ in METRIC_SPECS:
+                        value = row_metric_values.get(metric_key)
+                        if value is None:
+                            continue
+                        metric_segment_values[metric_key][segment_key].append(float(value))
+                        metric_segment_zones[metric_key][segment_key].add(row.measurement_zone_name)
+                        if metric_key in {"import_utilisation", "export_utilisation"}:
+                            metric_segment_rating[metric_key][segment_key] = (zone_rating_value, zone_rating_unit, zone_phase_count)
+
+            print(
+                "  - zone source rows: "
+                f"trace={trace_source_rows}, point={point_source_rows}"
+            )
+
+        print(f"Total mapped line segments: {len(segment_geometries)}")
+        if missing_head_total:
+            print(f"Total missing zone heads: {missing_head_total}")
+
+        results: List[Result] = []
+        for metric_key, metric_name, style_prefix in METRIC_SPECS:
+            by_segment = metric_segment_values[metric_key]
+            aggregated = {
+                segment_key: max(values)
+                for segment_key, values in by_segment.items()
+                if values
+            }
+
+            thresholds = compute_percentiles(list(aggregated.values()), [0.50, 0.75, 0.90, 0.99])
+            features: List[Feature] = []
+
+            for segment_key, value in aggregated.items():
+                geometry = segment_geometries.get(segment_key)
+                if geometry is None:
+                    continue
+
+                bucket = bucket_from_thresholds(value, thresholds)
+                zone_names = metric_segment_zones[metric_key].get(segment_key, set())
+                rating_value, rating_unit, zone_phase_count = metric_segment_rating.get(metric_key, {}).get(segment_key, (None, None, None))
+                rating_label = ""
+                if rating_value is not None and rating_unit is not None:
+                    if rating_unit == "A":
+                        phase_n = zone_phase_count or 3
+                        rating_label = f"{rating_value:.2f} A/ph x{phase_n}"
+                    else:
+                        rating_label = f"{rating_value:.2f} {rating_unit}"
+
+                value_label = f"{value:.2f}"
+                if metric_key in {"import_utilisation", "export_utilisation"}:
+                    value_label = f"{value:.1f}%"
+                    if rating_label:
+                        value_label = f"{value_label} | {rating_label}"
+                features.append(
+                    Feature(
+                        id=f"{metric_key}:{segment_key}",
+                        geometry=geometry,
+                        properties={
+                            "metric_key": metric_key,
+                            "metric_value": round(value, 6),
+                            "bucket": bucket,
+                            "bucket_label": BUCKET_LABELS[bucket],
+                            "geom_kind": "line",
+                            "segment_key": segment_key,
+                            "value_label": value_label,
+                            "zone_rating_value": (round(rating_value, 6) if rating_value is not None else None),
+                            "zone_rating_unit": rating_unit,
+                            "zone_phase_count": zone_phase_count,
+                            "zone_rating_label": rating_label,
+                            "measurement_zone_count": len(zone_names),
+                            "measurement_zone_names": summarise_zone_names(zone_names),
+                            "q50": round(thresholds[0], 6),
+                            "q75": round(thresholds[1], 6),
+                            "q90": round(thresholds[2], 6),
+                            "q99": round(thresholds[3], 6),
+                        },
+                    )
+                )
+
+            print(f"  - {metric_name}: {len(features)} line feature(s)")
+
+            results.append(
+                Result(
+                    name=metric_name,
+                    geo_json_overlay=GeoJsonOverlay(
+                        data=FeatureCollection(features),
+                        styles=[f"{style_prefix}-line", f"{style_prefix}-label"],
+                    ),
+                )
+            )
+
+        study = Study(
+            name=args.name,
+            description=(
+                "Hosting Capacity metric layers sourced from public.network_performance_metrics_enhanced, "
+                "propagated from each measurement-zone head until the next downstream measurement-zone head."
+            ),
+            tags=[
+                "hosting_capacity",
+                "network_performance_metrics",
+                f"work_package_{args.work_package_id}",
+                f"scenario_{selection.scenario}",
+                f"season_{selection.season}",
+                f"time_of_day_{selection.time_of_day}",
+            ],
+            results=results,
+            styles=styles,
+        )
+
+        if args.dry_run:
+            print("Dry-run enabled. Study was not uploaded.")
+            return
+
+        session = aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=300))
+        eas_client = EasClient(
+            host=ewb_settings.host,
+            port=ewb_settings.rpc_port,
+            protocol="https",
+            access_token=ewb_settings.access_token,
+            session=session,
+        )
+        try:
+            print("Uploading study...")
+            response = await eas_client.async_upload_study(study)
+            print(f"Study upload response: {response}")
+        finally:
+            await eas_client.aclose()
+    finally:
+        engine.dispose()
+
+
+if __name__ == "__main__":
+    asyncio.run(main(sys.argv[1:]))
diff --git a/src/zepben/examples/studies/hosting_capacity_examples/hcm_voltage_heatmap_study.py b/src/zepben/examples/studies/hosting_capacity_examples/hcm_voltage_heatmap_study.py
new file mode 100644
index 0000000..afd1ff8
--- /dev/null
+++ b/src/zepben/examples/studies/hosting_capacity_examples/hcm_voltage_heatmap_study.py
@@ -0,0 +1,609 @@
+#  Copyright 2026 Zeppelin Bend Pty Ltd
+#
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import math
+import sys
+from collections import defaultdict
+from pathlib import Path
+from typing import Dict, List, Sequence
+
+import aiohttp
+from geojson import Feature, FeatureCollection
+from zepben.eas.client.eas_client import EasClient
+from zepben.eas.client.study import GeoJsonOverlay, Result, Study
+
+try:
+    from zepben.examples.studies.hosting_capacity_examples.common import (
+        build_feeder_trace_context,
+        canonical_mz_type,
+        catalog_from_slice_option_snapshot,
+        combine_feeder_scope,
+        create_postgres_engine,
+        feeders_for_year_from_snapshot,
+        fetch_metric_rows,
+        fetch_prefixed_feeders,
+        fetch_slice_option_snapshot,
+        is_trace_source_mz_type,
+        load_db_settings,
+        load_ewb_settings,
+        map_zone_heads_to_assets,
+        print_slice_option_catalog,
+        prompt_select_from_values,
+        resolve_slice_selection,
+        resolve_zone_feeders,
+        should_apply_transformer_trace_fallback,
+        season_time_of_day_pairs_from_snapshot,
+        split_csv_values,
+        to_equipment_geometry,
+    )
+except ModuleNotFoundError:
+    from common import (  # type: ignore
+        build_feeder_trace_context,
+        canonical_mz_type,
+        catalog_from_slice_option_snapshot,
+        combine_feeder_scope,
+        create_postgres_engine,
+        feeders_for_year_from_snapshot,
+        fetch_metric_rows,
+        fetch_prefixed_feeders,
+        fetch_slice_option_snapshot,
+        is_trace_source_mz_type,
+        load_db_settings,
+        load_ewb_settings,
+        map_zone_heads_to_assets,
+        print_slice_option_catalog,
+        prompt_select_from_values,
+        resolve_slice_selection,
+        resolve_zone_feeders,
+        should_apply_transformer_trace_fallback,
+        season_time_of_day_pairs_from_snapshot,
+        split_csv_values,
+        to_equipment_geometry,
+    )
+
+
+STYLE_PATH = Path(__file__).resolve().parent / "style_hcm_voltage_heatmap.json"
+V1_RED_LOW_LIMIT = 216.0
+V1_GREEN_LOW = 225.0
+V1_GREEN_HIGH = 240.0
+V99_RED_HIGH_LIMIT = 235.0
+V99_GREEN_LOW = 225.0
+
+
+def voltage_label(voltage_lg: float, pu: float | None) -> str:
+    if pu is None:
+        return f"{voltage_lg:.1f} V"
+    return f"{voltage_lg:.1f} V ({pu:.3f} pu)"
+
+
+def v1_bucket(voltage_lg: float) -> int:
+    if voltage_lg < V1_RED_LOW_LIMIT or voltage_lg > V1_GREEN_HIGH:
+        return 0  # red: outside technical range
+    if voltage_lg < V1_GREEN_LOW:
+        return 1  # orange: approaching lower limit
+    return 2  # green: normal range
+
+
+def v99_bucket(voltage_lg: float) -> int:
+    if voltage_lg > V99_RED_HIGH_LIMIT or voltage_lg < V1_RED_LOW_LIMIT:
+        return 0  # red: outside technical range
+    if voltage_lg < V99_GREEN_LOW:
+        return 1  # orange: approaching lower side
+    return 2  # green: normal range for this metric
+
+
+def parse_args(argv: Sequence[str]) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Upload a Hosting Capacity voltage heatmap study using V1 and V99 magnitudes "
+            "converted to line-ground voltage from v_base."
+        )
+    )
+    parser.add_argument("--work-package-id", required=True, help="Work package ID.")
+    parser.add_argument("--year", type=int, help="Result year (calendar year).")
+    parser.add_argument("--zones", default="", help="Comma-separated zone codes.")
+    parser.add_argument(
+        "--feeder-prefixes",
+        default="",
+        help="Comma-separated feeder prefixes (matched against DB feeder column).",
+    )
+    parser.add_argument("--scenario", default="", help="Optional scenario override.")
+    parser.add_argument(
+        "--timestamp",
+        default="",
+        help="Optional timestamp override (ISO-8601, e.g. 2025-06-30T14:30:00+00:00).",
+    )
+    parser.add_argument("--season", default="all", help="Season filter (default: all).")
+    parser.add_argument("--time-of-day", default="all", help="Time-of-day filter (default: all).")
+    parser.add_argument("--env-file", default=".env", help="Path to .env with EWB_* and INPUT_DB_* keys.")
+    parser.add_argument("--name", default="Hosting Capacity Voltage Heatmaps", help="Study name.")
+    parser.add_argument(
+        "--list-options",
+        action="store_true",
+        help="List selectable year/scenario/timestamp/season/time-of-day/feeders for the work package and exit.",
+    )
+    parser.add_argument(
+        "--interactive",
+        action="store_true",
+        help="Prompt for missing slice selections (year/scenario/timestamp).",
+    )
+    parser.add_argument("--dry-run", action="store_true", help="Generate results but do not upload.")
+    return parser.parse_args(argv)
+
+
+async def main(argv: Sequence[str]) -> None:
+    args = parse_args(argv)
+
+    zone_codes = split_csv_values(args.zones)
+    feeder_prefixes = split_csv_values(args.feeder_prefixes)
+
+    ewb_settings = load_ewb_settings(args.env_file)
+    db_settings = load_db_settings(args.env_file)
+    styles = json.load(open(STYLE_PATH, "r"))
+
+    engine = create_postgres_engine(db_settings)
+
+    try:
+        zone_feeders = await resolve_zone_feeders(ewb_settings, zone_codes) if zone_codes else set()
+        prefix_feeders = (
+            fetch_prefixed_feeders(
+                engine=engine,
+                work_package_id=args.work_package_id,
+                year=args.year,
+                feeder_prefixes=feeder_prefixes,
+            )
+            if feeder_prefixes
+            else set()
+        )
+        if feeder_prefixes and not prefix_feeders:
+            print(
+                "No feeders matched --feeder-prefixes for the current filter "
+                f"(year={args.year if args.year is not None else 'ALL'})."
+            )
+
+        selected_feeders = set()
+        if zone_feeders or prefix_feeders:
+            selected_feeders = combine_feeder_scope(zone_feeders=zone_feeders, prefix_feeders=prefix_feeders)
+
+        scenario_arg = args.scenario.strip() or None
+        option_snapshot = None
+
+        if args.list_options or args.interactive or args.year is None:
+            option_snapshot = fetch_slice_option_snapshot(
+                engine=engine,
+                work_package_id=args.work_package_id,
+                feeders=sorted(selected_feeders),
+            )
+            catalog = catalog_from_slice_option_snapshot(
+                snapshot=option_snapshot,
+                year=args.year,
+                scenario=scenario_arg,
+            )
+            print_slice_option_catalog(
+                catalog=catalog,
+                work_package_id=args.work_package_id,
+                selected_year=args.year,
+                selected_scenario=scenario_arg,
+                selected_feeders=sorted(selected_feeders),
+            )
+
+            if args.list_options and not args.interactive:
+                return
+
+            if args.year is None and not args.interactive:
+                print("No year selected. Re-run with --year or use --interactive.")
+                return
+
+        resolved_year = args.year
+        if resolved_year is None and args.interactive:
+            if option_snapshot is None:
+                option_snapshot = fetch_slice_option_snapshot(
+                    engine=engine,
+                    work_package_id=args.work_package_id,
+                    feeders=sorted(selected_feeders),
+                )
+            unfiltered_catalog = catalog_from_slice_option_snapshot(snapshot=option_snapshot)
+            selected_year_value = prompt_select_from_values(
+                label="year",
+                values=[str(value) for value in unfiltered_catalog.years],
+            )
+            resolved_year = int(selected_year_value)
+
+        if resolved_year is None:
+            raise ValueError("A year is required. Use --year or --interactive.")
+
+        if not zone_codes and not feeder_prefixes:
+            raise ValueError("At least one scope is required: --zones and/or --feeder-prefixes")
+
+        if not selected_feeders:
+            selected_feeders = combine_feeder_scope(zone_feeders=zone_feeders, prefix_feeders=prefix_feeders)
+
+        if option_snapshot is None:
+            option_snapshot = fetch_slice_option_snapshot(
+                engine=engine,
+                work_package_id=args.work_package_id,
+                feeders=sorted(selected_feeders),
+            )
+        year_feeders = feeders_for_year_from_snapshot(option_snapshot, resolved_year)
+        if not year_feeders:
+            raise ValueError(
+                f"No feeders in scope have rows for year {resolved_year}. "
+                "Use --list-options to inspect available years."
+            )
+        selected_feeders = selected_feeders.intersection(year_feeders)
+        if not selected_feeders:
+            raise ValueError(
+                f"No feeders matched the requested scope for year {resolved_year}."
+            )
+
+        resolved_scenario = scenario_arg
+        resolved_timestamp = args.timestamp.strip() or None
+        filtered_catalog = catalog_from_slice_option_snapshot(
+            snapshot=option_snapshot,
+            year=resolved_year,
+            scenario=resolved_scenario,
+        )
+        if resolved_scenario is None:
+            if not filtered_catalog.scenarios:
+                raise ValueError("No scenarios available for selected year/scope.")
+            if args.interactive:
+                resolved_scenario = prompt_select_from_values(
+                    label="scenario",
+                    values=list(filtered_catalog.scenarios),
+                )
+            else:
+                resolved_scenario = filtered_catalog.scenarios[0]
+
+        filtered_catalog = catalog_from_slice_option_snapshot(
+            snapshot=option_snapshot,
+            year=resolved_year,
+            scenario=resolved_scenario,
+        )
+        if resolved_timestamp is None:
+            if not filtered_catalog.timestamps:
+                raise ValueError("No timestamps available for selected year/scenario/scope.")
+            if resolved_scenario is None:
+                raise ValueError("Could not resolve scenario.")
+            if args.interactive:
+                resolved_timestamp = prompt_select_from_values(
+                    label="timestamp",
+                    values=[value.isoformat() for value in filtered_catalog.timestamps],
+                )
+            else:
+                resolved_timestamp = filtered_catalog.timestamps[0].isoformat()
+
+        resolved_season = args.season.strip() or "all"
+        resolved_time_of_day = args.time_of_day.strip() or "all"
+
+        selection = resolve_slice_selection(
+            engine=engine,
+            work_package_id=args.work_package_id,
+            year=resolved_year,
+            feeders=sorted(selected_feeders),
+            scenario=resolved_scenario,
+            timestamp=resolved_timestamp,
+            season=resolved_season,
+            time_of_day=resolved_time_of_day,
+        )
+
+        season_time_pairs = season_time_of_day_pairs_from_snapshot(
+            snapshot=option_snapshot,
+            year=selection.year,
+            scenario=selection.scenario,
+            timestamp=selection.timestamp,
+        )
+        if not season_time_pairs:
+            raise RuntimeError(
+                "No season/time_of_day rows available for the resolved work package/scenario/timestamp/feeders."
+            )
+
+        available_seasons = sorted({season for season, _ in season_time_pairs})
+        if selection.season not in available_seasons:
+            if args.interactive:
+                season_default = "yearly" if "yearly" in available_seasons else available_seasons[0]
+                selected_season = prompt_select_from_values(
+                    label="season",
+                    values=available_seasons,
+                    default=season_default,
+                )
+                selection = resolve_slice_selection(
+                    engine=engine,
+                    work_package_id=args.work_package_id,
+                    year=resolved_year,
+                    feeders=sorted(selected_feeders),
+                    scenario=selection.scenario,
+                    timestamp=selection.timestamp.isoformat(),
+                    season=selected_season,
+                    time_of_day=selection.time_of_day,
+                )
+            else:
+                raise ValueError(
+                    f"Season '{selection.season}' is not valid for the resolved slice. "
+                    f"Available seasons: {', '.join(available_seasons)}"
+                )
+
+        available_tods = sorted({tod for season, tod in season_time_pairs if season == selection.season})
+        if selection.time_of_day not in available_tods:
+            if args.interactive:
+                tod_default = "all" if "all" in available_tods else available_tods[0]
+                selected_tod = prompt_select_from_values(
+                    label="time_of_day",
+                    values=available_tods,
+                    default=tod_default,
+                )
+                selection = resolve_slice_selection(
+                    engine=engine,
+                    work_package_id=args.work_package_id,
+                    year=resolved_year,
+                    feeders=sorted(selected_feeders),
+                    scenario=selection.scenario,
+                    timestamp=selection.timestamp.isoformat(),
+                    season=selection.season,
+                    time_of_day=selected_tod,
+                )
+            else:
+                raise ValueError(
+                    f"time_of_day '{selection.time_of_day}' is not valid for season '{selection.season}'. "
+                    f"Available time_of_day values: {', '.join(available_tods)}"
+                )
+
+        print(
+            "Resolved slice: "
+            f"scenario={selection.scenario}, "
+            f"timestamp={selection.timestamp.isoformat()}, "
+            f"season={selection.season}, time_of_day={selection.time_of_day}, "
+            f"feeders={len(selection.feeders)}"
+        )
+
+        rows = fetch_metric_rows(engine, selection)
+        if not rows:
+            raise RuntimeError("No rows returned for the resolved slice.")
+
+        print(f"Fetched {len(rows)} DB rows.")
+
+        rows_by_feeder: Dict[str, List] = defaultdict(list)
+        for row in rows:
+            rows_by_feeder[row.feeder].append(row)
+
+        segment_geometries: Dict[str, object] = {}
+        v1_by_asset: Dict[str, float] = {}
+        v1_base_by_asset: Dict[str, float] = {}
+        v1_zone_name_by_asset: Dict[str, str] = {}
+        v1_mz_type_by_asset: Dict[str, str] = {}
+        v99_by_asset: Dict[str, float] = {}
+        v99_base_by_asset: Dict[str, float] = {}
+        v99_zone_name_by_asset: Dict[str, str] = {}
+        v99_mz_type_by_asset: Dict[str, str] = {}
+
+        missing_head_total = 0
+        skipped_no_vbase = 0
+
+        for feeder_mrid in sorted(rows_by_feeder.keys()):
+            feeder_rows = rows_by_feeder[feeder_mrid]
+            print(f"Tracing feeder {feeder_mrid} ({len(feeder_rows)} zone rows)")
+            transformer_trace_fallback = should_apply_transformer_trace_fallback(
+                [row.mz_type for row in feeder_rows]
+            )
+            if transformer_trace_fallback:
+                print(
+                    "  - transformer trace fallback enabled "
+                    "(transformer/feeder-head-only measurement zones)."
+                )
+
+            context = await build_feeder_trace_context(ewb_settings, feeder_mrid)
+            head_ids = {row.conducting_equipment_mrid for row in feeder_rows}
+            head_to_assets, missing_heads = await map_zone_heads_to_assets(context, head_ids)
+
+            if missing_heads:
+                missing_head_total += len(missing_heads)
+                print(f"  - missing zone heads in network model: {len(missing_heads)}")
+
+            trace_source_rows = 0
+            point_source_rows = 0
+            for row in feeder_rows:
+                if row.v_base is None or row.v_base <= 0:
+                    skipped_no_vbase += 1
+                    continue
+
+                canonical_mz = canonical_mz_type(row.mz_type)
+                use_trace_source = is_trace_source_mz_type(row.mz_type) or (
+                    transformer_trace_fallback and canonical_mz == "TRANSFORMER"
+                )
+
+                if use_trace_source:
+                    trace_source_rows += 1
+                    mapped_assets = head_to_assets.get(row.conducting_equipment_mrid)
+                else:
+                    point_source_rows += 1
+                    mapped_assets = {row.conducting_equipment_mrid}
+                if not mapped_assets:
+                    continue
+
+                v_base_lg = float(row.v_base) / math.sqrt(3.0)
+
+                v1_lg = None
+                if row.v1_avg_section_voltage is not None:
+                    v1_lg = float(row.v1_avg_section_voltage) * v_base_lg
+
+                v99_lg = None
+                if row.v99_avg_section_voltage is not None:
+                    v99_lg = float(row.v99_avg_section_voltage) * v_base_lg
+
+                for asset_mrid in (mapped_assets or set()):
+                    equipment = context.equipment_by_mrid.get(asset_mrid)
+                    if equipment is None:
+                        continue
+
+                    geom_kind, geometry = to_equipment_geometry(equipment)
+                    if geometry is None or geom_kind != "line":
+                        continue
+                    segment_key = f"asset:{asset_mrid}"
+                    segment_geometries[segment_key] = geometry
+
+                    if v1_lg is not None:
+                        existing_v1 = v1_by_asset.get(segment_key)
+                        if existing_v1 is None or v1_lg < existing_v1:
+                            v1_by_asset[segment_key] = v1_lg
+                            v1_base_by_asset[segment_key] = v_base_lg
+                            v1_zone_name_by_asset[segment_key] = row.measurement_zone_name
+                            v1_mz_type_by_asset[segment_key] = row.mz_type
+
+                    if v99_lg is not None:
+                        existing_v99 = v99_by_asset.get(segment_key)
+                        if existing_v99 is None or v99_lg > existing_v99:
+                            v99_by_asset[segment_key] = v99_lg
+                            v99_base_by_asset[segment_key] = v_base_lg
+                            v99_zone_name_by_asset[segment_key] = row.measurement_zone_name
+                            v99_mz_type_by_asset[segment_key] = row.mz_type
+
+            print(
+                "  - zone source rows: "
+                f"trace={trace_source_rows}, point={point_source_rows}"
+            )
+
+        print(f"Mapped line segments: {len(segment_geometries)}")
+        if missing_head_total:
+            print(f"Total missing zone heads: {missing_head_total}")
+        if skipped_no_vbase:
+            print(f"Rows skipped due to missing/invalid v_base: {skipped_no_vbase}")
+
+        v1_features: List[Feature] = []
+        for asset_mrid, voltage_lg in v1_by_asset.items():
+            geometry = segment_geometries.get(asset_mrid)
+            if geometry is None:
+                continue
+
+            v_base_lg = v1_base_by_asset.get(asset_mrid, 0.0)
+            pu = (voltage_lg / v_base_lg) if v_base_lg > 0 else None
+            bucket = v1_bucket(voltage_lg)
+            zone_name = v1_zone_name_by_asset.get(asset_mrid, "")
+
+            v1_features.append(
+                Feature(
+                    id=f"v1:{asset_mrid}",
+                    geometry=geometry,
+                    properties={
+                        "metric_key": "v1_avg_section_voltage",
+                        "asset_mrid": asset_mrid,
+                        "v_base_lg": round(v_base_lg, 6),
+                        "voltage_lg_v": round(voltage_lg, 6),
+                        "voltage_pu": (round(pu, 8) if pu is not None else None),
+                        "value_label": voltage_label(voltage_lg, pu),
+                        "bucket": bucket,
+                        "bucket_label": ("Outside limit" if bucket == 0 else "Approaching limit" if bucket == 1 else "Normal range"),
+                        "measurement_zone_name": zone_name,
+                        "measurement_zone_type": v1_mz_type_by_asset.get(asset_mrid, ""),
+                        "technical_limit_low_v": V1_RED_LOW_LIMIT,
+                        "green_range_low_v": V1_GREEN_LOW,
+                        "green_range_high_v": V1_GREEN_HIGH,
+                        "conversion": "v1_avg_section_voltage * (v_base/sqrt(3))",
+                    },
+                )
+            )
+
+        v99_features: List[Feature] = []
+        for asset_mrid, voltage_lg in v99_by_asset.items():
+            geometry = segment_geometries.get(asset_mrid)
+            if geometry is None:
+                continue
+
+            v_base_lg = v99_base_by_asset.get(asset_mrid, 0.0)
+            pu = (voltage_lg / v_base_lg) if v_base_lg > 0 else None
+            bucket = v99_bucket(voltage_lg)
+            zone_name = v99_zone_name_by_asset.get(asset_mrid, "")
+
+            v99_features.append(
+                Feature(
+                    id=f"v99:{asset_mrid}",
+                    geometry=geometry,
+                    properties={
+                        "metric_key": "v99_avg_section_voltage",
+                        "asset_mrid": asset_mrid,
+                        "v_base_lg": round(v_base_lg, 6),
+                        "voltage_lg_v": round(voltage_lg, 6),
+                        "voltage_pu": (round(pu, 8) if pu is not None else None),
+                        "value_label": voltage_label(voltage_lg, pu),
+                        "bucket": bucket,
+                        "bucket_label": ("Outside limit" if bucket == 0 else "Approaching limit" if bucket == 1 else "Normal range"),
+                        "measurement_zone_name": zone_name,
+                        "measurement_zone_type": v99_mz_type_by_asset.get(asset_mrid, ""),
+                        "technical_limit_high_v": V99_RED_HIGH_LIMIT,
+                        "green_range_low_v": V99_GREEN_LOW,
+                        "green_range_high_v": V99_RED_HIGH_LIMIT,
+                        "conversion": "v99_avg_section_voltage * (v_base/sqrt(3))",
+                    },
+                )
+            )
+
+        print(f"  - V1 heatmap features: {len(v1_features)}")
+        print(f"  - V99 heatmap features: {len(v99_features)}")
+
+        results = [
+            Result(
+                name="V1 Avg Section Voltage (Line-Ground)",
+                geo_json_overlay=GeoJsonOverlay(
+                    data=FeatureCollection(v1_features),
+                    styles=["hc-v1-line", "hc-v1-label"],
+                ),
+            ),
+            Result(
+                name="V99 Avg Section Voltage (Line-Ground)",
+                geo_json_overlay=GeoJsonOverlay(
+                    data=FeatureCollection(v99_features),
+                    styles=["hc-v99-line", "hc-v99-label"],
+                ),
+            ),
+        ]
+
+        study = Study(
+            name=args.name,
+            description=(
+                "Hosting Capacity voltage heatmaps derived from measurement-zone results and propagated "
+                "to downstream assets until the next measurement-zone head. V1 and V99 are converted to "
+                "line-ground voltage magnitudes: v*_avg_section_voltage * (v_base/sqrt(3))."
+            ),
+            tags=[
+                "hosting_capacity",
+                "network_performance_metrics",
+                "voltage_heatmap",
+                f"work_package_{args.work_package_id}",
+                f"scenario_{selection.scenario}",
+                f"season_{selection.season}",
+                f"time_of_day_{selection.time_of_day}",
+            ],
+            results=results,
+            styles=styles,
+        )
+
+        if args.dry_run:
+            print("Dry-run enabled. Study was not uploaded.")
+            return
+
+        session = aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=300))
+        eas_client = EasClient(
+            host=ewb_settings.host,
+            port=ewb_settings.rpc_port,
+            protocol="https",
+            access_token=ewb_settings.access_token,
+            session=session,
+        )
+        try:
+            print("Uploading study...")
+            response = await eas_client.async_upload_study(study)
+            print(f"Study upload response: {response}")
+        finally:
+            await eas_client.aclose()
+    finally:
+        engine.dispose()
+
+
+if __name__ == "__main__":
+    asyncio.run(main(sys.argv[1:]))
diff --git a/src/zepben/examples/studies/hosting_capacity_examples/style_hcm_asset_metrics.json b/src/zepben/examples/studies/hosting_capacity_examples/style_hcm_asset_metrics.json
new file mode 100644
index 0000000..84b1841
--- /dev/null
+++ b/src/zepben/examples/studies/hosting_capacity_examples/style_hcm_asset_metrics.json
@@ -0,0 +1,412 @@
+[
+  {
+    "id": "hc-peak-import-line",
+    "name": "Peak Import Lines",
+    "type": "line",
+    "paint": {
+      "line-width": 4.6,
+      "line-opacity": 0.92,
+      "line-color": [
+        "match",
+        ["get", "bucket"],
+        0, "#2c7bb6",
+        1, "#00a6ca",
+        2, "#fdae61",
+        3, "#f46d43",
+        4, "#d73027",
+        "#8f8f8f"
+      ]
+    },
+    "metadata": {
+      "zb:legend": {
+        "label": "Peak Import",
+        "states": [
+          { "label": "Very Low (#2c7bb6)", "properties": { "bucket": 0 } },
+          { "label": "Low (#00a6ca)", "properties": { "bucket": 1 } },
+          { "label": "Medium (#fdae61)", "properties": { "bucket": 2 } },
+          { "label": "High (#f46d43)", "properties": { "bucket": 3 } },
+          { "label": "Very High (#d73027)", "properties": { "bucket": 4 } }
+        ]
+      }
+    },
+    "filter": ["all", ["==", ["get", "metric_key"], "peak_import"], ["==", ["get", "geom_kind"], "line"]]
+  },
+  {
+    "id": "hc-peak-import-label",
+    "name": "Peak Import Labels",
+    "type": "symbol",
+    "minzoom": 13,
+    "layout": {
+      "symbol-placement": "line-center",
+      "text-field": ["get", "value_label"],
+      "text-size": 10
+    },
+    "paint": {
+      "text-color": "#1f2a44",
+      "text-halo-color": "#ffffff",
+      "text-halo-width": 1.2
+    },
+    "filter": ["all", ["==", ["get", "metric_key"], "peak_import"], ["==", ["get", "geom_kind"], "line"]]
+  },
+  {
+    "id": "hc-peak-import-point",
+    "name": "Peak Import Points",
+    "type": "circle",
+    "minzoom": 10,
+    "paint": {
+      "circle-radius": 6,
+      "circle-opacity": 0.94,
+      "circle-stroke-color": "#ffffff",
+      "circle-stroke-width": 0.8,
+      "circle-color": [
+        "match",
+        ["get", "bucket"],
+        0, "#2c7bb6",
+        1, "#00a6ca",
+        2, "#fdae61",
+        3, "#f46d43",
+        4, "#d73027",
+        "#8f8f8f"
+      ]
+    },
+    "filter": ["all", ["==", ["get", "metric_key"], "peak_import"], ["==", ["get", "geom_kind"], "point"]]
+  },
+  {
+    "id": "hc-peak-export-line",
+    "name": "Peak Export Lines",
+    "type": "line",
+    "paint": {
+      "line-width": 4.6,
+      "line-opacity": 0.92,
+      "line-color": [
+        "match",
+        ["get", "bucket"],
+        0, "#d73027",
+        1, "#f46d43",
+        2, "#fdae61",
+        3, "#abd9e9",
+        4, "#4575b4",
+        "#8f8f8f"
+      ]
+    },
+    "metadata": {
+      "zb:legend": {
+        "label": "Peak Export",
+        "states": [
+          { "label": "Most Negative (High) #d73027", "properties": { "bucket": 0 } },
+          { "label": "Negative (Elevated) #f46d43", "properties": { "bucket": 1 } },
+          { "label": "Moderate #fdae61", "properties": { "bucket": 2 } },
+          { "label": "Near Zero (Low) #abd9e9", "properties": { "bucket": 3 } },
+          { "label": "Closest to Zero (Lowest) #4575b4", "properties": { "bucket": 4 } }
+        ]
+      }
+    },
+    "filter": ["all", ["==", ["get", "metric_key"], "peak_export"], ["==", ["get", "geom_kind"], "line"]]
+  },
+  {
+    "id": "hc-peak-export-label",
+    "name": "Peak Export Labels",
+    "type": "symbol",
+    "minzoom": 13,
+    "layout": {
+      "symbol-placement": "line-center",
+      "text-field": ["get", "value_label"],
+      "text-size": 10
+    },
+    "paint": {
+      "text-color": "#1f2a44",
+      "text-halo-color": "#ffffff",
+      "text-halo-width": 1.2
+    },
+    "filter": ["all", ["==", ["get", "metric_key"], "peak_export"], ["==", ["get", "geom_kind"], "line"]]
+  },
+  {
+    "id": "hc-peak-export-point",
+    "name": "Peak Export Points",
+    "type": "circle",
+    "minzoom": 10,
+    "paint": {
+      "circle-radius": 6,
+      "circle-opacity": 0.94,
+      "circle-stroke-color": "#ffffff",
+      "circle-stroke-width": 0.8,
+      "circle-color": [
+        "match",
+        ["get", "bucket"],
+        0, "#d73027",
+        1, "#f46d43",
+        2, "#fdae61",
+        3, "#abd9e9",
+        4, "#4575b4",
+        "#8f8f8f"
+      ]
+    },
+    "filter": ["all", ["==", ["get", "metric_key"], "peak_export"], ["==", ["get", "geom_kind"], "point"]]
+  },
+  {
+    "id": "hc-import-utilisation-line",
+    "name": "Import Utilisation Lines",
+    "type": "line",
+    "paint": {
+      "line-width": 4.6,
+      "line-opacity": 0.92,
+      "line-color": [
+        "match",
+        ["get", "bucket"],
+        0, "#2c7bb6",
+        1, "#00a6ca",
+        2, "#fdae61",
+        3, "#f46d43",
+        4, "#d73027",
+        "#8f8f8f"
+      ]
+    },
+    "metadata": {
+      "zb:legend": {
+        "label": "Import Utilisation (%)",
+        "states": [
+          { "label": "Very Low (#2c7bb6)", "properties": { "bucket": 0 } },
+          { "label": "Low (#00a6ca)", "properties": { "bucket": 1 } },
+          { "label": "Medium (#fdae61)", "properties": { "bucket": 2 } },
+          { "label": "High (#f46d43)", "properties": { "bucket": 3 } },
+          { "label": "Very High (#d73027)", "properties": { "bucket": 4 } }
+        ]
+      }
+    },
+    "filter": ["all", ["==", ["get", "metric_key"], "import_utilisation"], ["==", ["get", "geom_kind"], "line"]]
+  },
+  {
+    "id": "hc-import-utilisation-label",
+    "name": "Import Utilisation Labels",
+    "type": "symbol",
+    "minzoom": 13,
+    "layout": {
+      "symbol-placement": "line-center",
+      "text-field": ["get", "value_label"],
+      "text-size": 10
+    },
+    "paint": {
+      "text-color": "#1f2a44",
+      "text-halo-color": "#ffffff",
+      "text-halo-width": 1.2
+    },
+    "filter": ["all", ["==", ["get", "metric_key"], "import_utilisation"], ["==", ["get", "geom_kind"], "line"]]
+  },
+  {
+    "id": "hc-export-utilisation-line",
+    "name": "Export Utilisation Lines",
+    "type": "line",
+    "paint": {
+      "line-width": 4.6,
+      "line-opacity": 0.92,
+      "line-color": [
+        "match",
+        ["get", "bucket"],
+        0, "#2c7bb6",
+        1, "#00a6ca",
+        2, "#fdae61",
+        3, "#f46d43",
+        4, "#d73027",
+        "#8f8f8f"
+      ]
+    },
+    "metadata": {
+      "zb:legend": {
+        "label": "Export Utilisation (%)",
+        "states": [
+          { "label": "Very Low (#2c7bb6)", "properties": { "bucket": 0 } },
+          { "label": "Low (#00a6ca)", "properties": { "bucket": 1 } },
+          { "label": "Medium (#fdae61)", "properties": { "bucket": 2 } },
+          { "label": "High (#f46d43)", "properties": { "bucket": 3 } },
+          { "label": "Very High (#d73027)", "properties": { "bucket": 4 } }
+        ]
+      }
+    },
+    "filter": ["all", ["==", ["get", "metric_key"], "export_utilisation"], ["==", ["get", "geom_kind"], "line"]]
+  },
+  {
+    "id": "hc-export-utilisation-label",
+    "name": "Export Utilisation Labels",
+    "type": "symbol",
+    "minzoom": 13,
+    "layout": {
+      "symbol-placement": "line-center",
+      "text-field": ["get", "value_label"],
+      "text-size": 10
+    },
+    "paint": {
+      "text-color": "#1f2a44",
+      "text-halo-color": "#ffffff",
+      "text-halo-width": 1.2
+    },
+    "filter": ["all", ["==", ["get", "metric_key"], "export_utilisation"], ["==", ["get", "geom_kind"], "line"]]
+  },
+  {
+    "id": "hc-load-thermal-voltage-line",
+    "name": "Load Thermal/Voltage Lines",
+    "type": "line",
+    "paint": {
+      "line-width": 4.6,
+      "line-opacity": 0.92,
+      "line-color": [
+        "match",
+        ["get", "bucket"],
+        0, "#2166ac",
+        1, "#67a9cf",
+        2, "#fddbc7",
+        3, "#ef8a62",
+        4, "#b2182b",
+        "#8f8f8f"
+      ]
+    },
+    "metadata": {
+      "zb:legend": {
+        "label": "Load Exceeding Normal Thermal + Voltage (kWh)",
+        "states": [
+          { "label": "Very Low (#2166ac)", "properties": { "bucket": 0 } },
+          { "label": "Low (#67a9cf)", "properties": { "bucket": 1 } },
+          { "label": "Medium (#fddbc7)", "properties": { "bucket": 2 } },
+          { "label": "High (#ef8a62)", "properties": { "bucket": 3 } },
+          { "label": "Very High (#b2182b)", "properties": { "bucket": 4 } }
+        ]
+      }
+    },
+    "filter": [
+      "all",
+      ["==", ["get", "metric_key"], "load_exceeding_normal_thermal_voltage_kwh"],
+      ["==", ["get", "geom_kind"], "line"]
+    ]
+  },
+  {
+    "id": "hc-load-thermal-voltage-label",
+    "name": "Load Thermal/Voltage Labels",
+    "type": "symbol",
+    "minzoom": 13,
+    "layout": {
+      "symbol-placement": "line-center",
+      "text-field": ["get", "value_label"],
+      "text-size": 10
+    },
+    "paint": {
+      "text-color": "#1f2a44",
+      "text-halo-color": "#ffffff",
+      "text-halo-width": 1.2
+    },
+    "filter": [
+      "all",
+      ["==", ["get", "metric_key"], "load_exceeding_normal_thermal_voltage_kwh"],
+      ["==", ["get", "geom_kind"], "line"]
+    ]
+  },
+  {
+    "id": "hc-load-thermal-voltage-point",
+    "name": "Load Thermal/Voltage Points",
+    "type": "circle",
+    "minzoom": 10,
+    "paint": {
+      "circle-radius": 6,
+      "circle-opacity": 0.94,
+      "circle-stroke-color": "#ffffff",
+      "circle-stroke-width": 0.8,
+      "circle-color": [
+        "match",
+        ["get", "bucket"],
+        0, "#2166ac",
+        1, "#67a9cf",
+        2, "#fddbc7",
+        3, "#ef8a62",
+        4, "#b2182b",
+        "#8f8f8f"
+      ]
+    },
+    "filter": [
+      "all",
+      ["==", ["get", "metric_key"], "load_exceeding_normal_thermal_voltage_kwh"],
+      ["==", ["get", "geom_kind"], "point"]
+    ]
+  },
+  {
+    "id": "hc-gen-thermal-voltage-line",
+    "name": "Generation Thermal/Voltage Lines",
+    "type": "line",
+    "paint": {
+      "line-width": 4.6,
+      "line-opacity": 0.92,
+      "line-color": [
+        "match",
+        ["get", "bucket"],
+        0, "#238443",
+        1, "#78c679",
+        2, "#fdd49e",
+        3, "#f16913",
+        4, "#b30000",
+        "#8f8f8f"
+      ]
+    },
+    "metadata": {
+      "zb:legend": {
+        "label": "Generation Exceeding Normal Thermal + Voltage (kWh)",
+        "states": [
+          { "label": "Very Low (#238443)", "properties": { "bucket": 0 } },
+          { "label": "Low (#78c679)", "properties": { "bucket": 1 } },
+          { "label": "Medium (#fdd49e)", "properties": { "bucket": 2 } },
+          { "label": "High (#f16913)", "properties": { "bucket": 3 } },
+          { "label": "Very High (#b30000)", "properties": { "bucket": 4 } }
+        ]
+      }
+    },
+    "filter": [
+      "all",
+      ["==", ["get", "metric_key"], "gen_exceeding_normal_thermal_voltage_kwh"],
+      ["==", ["get", "geom_kind"], "line"]
+    ]
+  },
+  {
+    "id": "hc-gen-thermal-voltage-label",
+    "name": "Generation Thermal/Voltage Labels",
+    "type": "symbol",
+    "minzoom": 13,
+    "layout": {
+      "symbol-placement": "line-center",
+      "text-field": ["get", "value_label"],
+      "text-size": 10
+    },
+    "paint": {
+      "text-color": "#1f2a44",
+      "text-halo-color": "#ffffff",
+      "text-halo-width": 1.2
+    },
+    "filter": [
+      "all",
+      ["==", ["get", "metric_key"], "gen_exceeding_normal_thermal_voltage_kwh"],
+      ["==", ["get", "geom_kind"], "line"]
+    ]
+  },
+  {
+    "id": "hc-gen-thermal-voltage-point",
+    "name": "Generation Thermal/Voltage Points",
+    "type": "circle",
+    "minzoom": 10,
+    "paint": {
+      "circle-radius": 6,
+      "circle-opacity": 0.94,
+      "circle-stroke-color": "#ffffff",
+      "circle-stroke-width": 0.8,
+      "circle-color": [
+        "match",
+        ["get", "bucket"],
+        0, "#238443",
+        1, "#78c679",
+        2, "#fdd49e",
+        3, "#f16913",
+        4, "#b30000",
+        "#8f8f8f"
+      ]
+    },
+    "filter": [
+      "all",
+      ["==", ["get", "metric_key"], "gen_exceeding_normal_thermal_voltage_kwh"],
+      ["==", ["get", "geom_kind"], "point"]
+    ]
+  }
+]
diff --git a/src/zepben/examples/studies/hosting_capacity_examples/style_hcm_voltage_heatmap.json b/src/zepben/examples/studies/hosting_capacity_examples/style_hcm_voltage_heatmap.json
new file mode 100644
index 0000000..e15e261
--- /dev/null
+++ b/src/zepben/examples/studies/hosting_capacity_examples/style_hcm_voltage_heatmap.json
@@ -0,0 +1,106 @@
+[
+  {
+    "id": "hc-v1-line",
+    "name": "V1 Line-Ground Zone Lines",
+    "type": "line",
+    "paint": {
+      "line-width": [
+        "interpolate",
+        ["linear"],
+        ["zoom"],
+        8, 3.0,
+        12, 4.8,
+        15, 6.2
+      ],
+      "line-opacity": 0.9,
+      "line-color": [
+        "match",
+        ["get", "bucket"],
+        0, "#d73027",
+        1, "#fdae61",
+        2, "#1a9850",
+        "#8f8f8f"
+      ]
+    },
+    "metadata": {
+      "zb:legend": {
+        "label": "V1 Avg Section Voltage (Line-Ground)",
+        "states": [
+          { "label": "Outside Limit (<216V or >240V) - Red", "properties": { "bucket": 0 } },
+          { "label": "Approaching Limit (216-225V) - Orange", "properties": { "bucket": 1 } },
+          { "label": "Normal (225-240V) - Green", "properties": { "bucket": 2 } }
+        ]
+      }
+    },
+    "filter": ["==", ["get", "metric_key"], "v1_avg_section_voltage"]
+  },
+  {
+    "id": "hc-v1-label",
+    "name": "V1 Labels",
+    "type": "symbol",
+    "minzoom": 13,
+    "layout": {
+      "symbol-placement": "line-center",
+      "text-field": ["get", "value_label"],
+      "text-size": 10
+    },
+    "paint": {
+      "text-color": "#1f2a44",
+      "text-halo-color": "#ffffff",
+      "text-halo-width": 1.2
+    },
+    "filter": ["==", ["get", "metric_key"], "v1_avg_section_voltage"]
+  },
+  {
+    "id": "hc-v99-line",
+    "name": "V99 Line-Ground Zone Lines",
+    "type": "line",
+    "paint": {
+      "line-width": [
+        "interpolate",
+        ["linear"],
+        ["zoom"],
+        8, 3.0,
+        12, 4.8,
+        15, 6.2
+      ],
+      "line-opacity": 0.9,
+      "line-color": [
+        "match",
+        ["get", "bucket"],
+        0, "#d73027",
+        1, "#fdae61",
+        2, "#1a9850",
+        "#8f8f8f"
+      ]
+    },
+    "metadata": {
+      "zb:legend": {
+        "label": "V99 Avg Section Voltage (Line-Ground)",
+        "states": [
+          { "label": "Outside Limit (>235V or <216V) - Red", "properties": { "bucket": 0 } },
+          { "label": "Approaching Limit (216-225V) - Orange", "properties": { "bucket": 1 } },
+          { "label": "Normal (225-235V) - Green", "properties": { "bucket": 2 } }
+        ]
+      }
+    },
+    "filter": ["==", ["get", "metric_key"], "v99_avg_section_voltage"]
+  },
+  {
+    "id": "hc-v99-label",
+    "name": "V99 Labels",
+    "type": "symbol",
+    "minzoom": 13,
+    "layout": {
+      "symbol-placement": "line-center",
+      "text-field": ["get", "value_label"],
+      "text-size": 10
+    },
+    "paint": {
+      "text-color": "#1f2a44",
+      "text-halo-color": "#ffffff",
+      "text-halo-width": 1.2
+    },
+    "filter": ["==", ["get", "metric_key"], "v99_avg_section_voltage"]
+  }
+]
diff --git a/src/zepben/examples/studies/loop_impedance_by_energy_consumer.py b/src/zepben/examples/studies/loop_impedance_by_energy_consumer.py
new file mode 100644
index 0000000..c449c18
--- /dev/null
+++ b/src/zepben/examples/studies/loop_impedance_by_energy_consumer.py
@@ -0,0 +1,393 @@
+#  Copyright 2025 Zeppelin Bend Pty Ltd
+#
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+import asyncio
+import json
+from datetime import datetime
+from itertools import islice
+from typing import List, Dict, Tuple, Callable, Any, Union, Type, Set
+
+from geojson import FeatureCollection, Feature
+from geojson.geometry import Geometry, LineString, Point
+from zepben.eas.client.eas_client import EasClient
+from zepben.eas.client.study import Study, Result, GeoJsonOverlay
+from zepben.ewb import (
+    AcLineSegment,
+    EnergyConsumer,
+    PowerTransformer,
+    NetworkConsumerClient,
+    PhaseCode,
+    Feeder,
+    PowerSystemResource,
+    Location,
+    connect_with_token,
+    NetworkTraceStep,
+    Tracing,
+    upstream,
+    stop_at_open,
+    IncludedEnergizedContainers,
+)
+from zepben.ewb.services.network.tracing.networktrace.operators.network_state_operators import NetworkStateOperators
+
+
+with open("../config.json") as f:
+    c = json.loads(f.read())
+
+
+def chunk(it, size):
+    it = iter(it)
+    return iter(lambda: tuple(islice(it, size)), ())
+
+
+async def main():
+    # Only process feeders in the following zones
+    zone_mrids = ["CPM"]
+    print(f"Start time: {datetime.now()}")
+
+    rpc_channel = connect_with_token(
+        host=c["host"],
+        access_token=c["access_token"],
+        rpc_port=c["rpc_port"],
+        ca_filename=c.get("ca_filename"),
+        timeout_seconds=c.get("timeout_seconds", 5),
+        debug=bool(c.get("debug", False)),
+        skip_connection_test=bool(c.get("skip_connection_test", False)),
+    )
+    client = NetworkConsumerClient(rpc_channel)
+    hierarchy = (await client.get_network_hierarchy()).throw_on_error()
+    substations = hierarchy.value.substations
+
+    print(f"Collecting feeders from zones {', '.join(zone_mrids)}.")
+    feeder_mrids = []
+    for zone_mrid in zone_mrids:
+        if zone_mrid in substations:
+            for feeder in substations[zone_mrid].feeders:
+                feeder_mrids.append(feeder.mrid)
+
+    print(f"Feeders to be processed: {', '.join(feeder_mrids)}")
+
+    all_ecs: List[EnergyConsumer] = []
+    all_lines: List[AcLineSegment] = []
+    ec_to_loop_z_phase_phase: Dict[str, float] = {}
+    ec_to_loop_z_phase_earth: Dict[str, float] = {}
+    line_to_z_per_km: Dict[str, float] = {}
+
+    # Process feeders in batches of 3, using asyncio, for performance
+    batches = chunk(feeder_mrids, 3)
+    for feeders in batches:
+        futures = []
+        rpc_channel = connect_with_token(
+            host=c["host"],
+            access_token=c["access_token"],
+            rpc_port=c["rpc_port"],
+            ca_filename=c.get("ca_filename"),
+            timeout_seconds=c.get("timeout_seconds", 5),
+            debug=bool(c.get("debug", False)),
+            skip_connection_test=bool(c.get("skip_connection_test", False)),
+        )
+        print(f"Processing feeders {', '.join(feeders)}")
+        for feeder_mrid in feeders:
+            futures.append(asyncio.ensure_future(fetch_feeder_loop_impedance(feeder_mrid, rpc_channel)))
+
+        for future in futures:
+            result = await future
+            if result is None:
+                continue
+            ecs, lines, ec_impedance_phase_phase, ec_impedance_phase_earth, line_impedance = result
+            all_ecs.extend(ecs)
+            all_lines.extend(lines)
+            ec_to_loop_z_phase_phase.update(ec_impedance_phase_phase)
+            ec_to_loop_z_phase_earth.update(ec_impedance_phase_earth)
+            line_to_z_per_km.update(line_impedance)
+
+    print(f"Creating study for {len(all_ecs)} energy consumers")
+
+    eas_client = EasClient(host=c["host"], port=c["rpc_port"], protocol="https", access_token=c["access_token"])
+    print(f"Uploading Study for zones {', '.join(zone_mrids)} ...")
+    await upload_loop_impedance_study(
+        eas_client,
+        all_ecs,
+        all_lines,
+        ec_to_loop_z_phase_phase,
+        ec_to_loop_z_phase_earth,
+        line_to_z_per_km,
+        name=f"Loop impedance (normal) ({', '.join(zone_mrids)})",
+        description=(
+            "Loop impedance approximations at EnergyConsumers on the normal upstream network path to transformer; "
+            "AC line segments are colored by positive-sequence impedance."
+        ),
+        tags=["loop_impedance", "-".join(zone_mrids)],
+        styles=json.load(open("style_loop_impedance.json", "r")),
+    )
+    await eas_client.aclose()
+    print("Uploaded Study")
+
+    print(f"Finish time: {datetime.now()}")
+
+
+async def fetch_feeder_loop_impedance(
+    feeder_mrid: str,
+    rpc_channel,
+) -> Union[Tuple[List[EnergyConsumer], List[AcLineSegment], Dict[str, float], Dict[str, float], Dict[str, float]], None]:
+    print(f"Fetching Feeder {feeder_mrid}")
+    client = NetworkConsumerClient(rpc_channel)
+
+    result = (
+        await client.get_equipment_container(
+            mrid=feeder_mrid,
+            expected_class=Feeder,
+            include_energized_containers=IncludedEnergizedContainers.LV_FEEDERS,
+        )
+    )
+    if result.was_failure:
+        print(f"Failed: {result.thrown}")
+        return None
+
+    network = client.service
+    print(f"Finished fetching Feeder {feeder_mrid}")
+
+    # Required for directed traces (upstream/downstream)
+    await Tracing.set_direction().run(network, network_state_operators=NetworkStateOperators.NORMAL)
+
+    ecs = list(network.objects(EnergyConsumer))
+    lines = list(network.objects(AcLineSegment))
+
+    line_to_z_per_km = {
+        line.mrid: _line_impedance_per_km(line)
+        for line in lines
+    }
+
+    ec_to_loop_z_phase_phase: Dict[str, float] = {}
+    ec_to_loop_z_phase_earth: Dict[str, float] = {}
+    for ec in ecs:
+        path_lines = await get_upstream_lines_to_transformer(ec)
+        z1_path, z2_path, z0_path = _path_sequence_impedance(path_lines)
+        ec_to_loop_z_phase_phase[ec.mrid] = abs(2.0 * z1_path)
+        ec_to_loop_z_phase_earth[ec.mrid] = abs(z1_path + z2_path + z0_path)
+
+    return ecs, lines, ec_to_loop_z_phase_phase, ec_to_loop_z_phase_earth, line_to_z_per_km
+
+
+def _line_impedance_per_m(line: AcLineSegment) -> float:
+    z1 = _line_z1_per_m(line)
+    return abs(z1)
+
+
+def _line_z1_per_m(line: AcLineSegment) -> complex:
+    plsi = line.per_length_sequence_impedance
+    if plsi is None:
+        return 0j
+    r = plsi.r or 0.0
+    x = plsi.x or 0.0
+    return complex(r, x)
+
+
+def _line_z2_per_m(line: AcLineSegment) -> complex:
+    plsi = line.per_length_sequence_impedance
+    if plsi is None:
+        return 0j
+    r2 = getattr(plsi, "r2", None)
+    x2 = getattr(plsi, "x2", None)
+    if r2 is None:
+        r2 = plsi.r
+    if x2 is None:
+        x2 = plsi.x
+    return complex(r2 or 0.0, x2 or 0.0)
+
+
+def _line_z0_per_m(line: AcLineSegment) -> complex:
+    plsi = line.per_length_sequence_impedance
+    if plsi is None:
+        return 0j
+    r0 = getattr(plsi, "r0", 0.0)
+    x0 = getattr(plsi, "x0", 0.0)
+    return complex(r0 or 0.0, x0 or 0.0)
+
+
+def _path_sequence_impedance(path_lines: Set[AcLineSegment]) -> Tuple[complex, complex, complex]:
+    z1_total = 0j
+    z2_total = 0j
+    z0_total = 0j
+    for line in path_lines:
+        # EWB AcLineSegment.length is in metres.
+        length_m = line.length or 0.0
+        z1_total += _line_z1_per_m(line) * length_m
+        z2_total += _line_z2_per_m(line) * length_m
+        z0_total += _line_z0_per_m(line) * length_m
+    return z1_total, z2_total, z0_total
+
+
+def _line_impedance_per_km(line: AcLineSegment) -> float:
+    # Convert per-metre magnitude to per-km for line styling/legend display.
+    return _line_impedance_per_m(line) * 1000.0
+
+
+def collect_upstream_lines_provider(lines: Set[AcLineSegment]):
+
+    async def collect_lines(ps: NetworkTraceStep, _):
+        line = ps.path.traversed_ac_line_segment
+        if line is not None:
+            lines.add(line)
+        if isinstance(ps.path.to_equipment, AcLineSegment):
+            lines.add(ps.path.to_equipment)
+        if isinstance(ps.path.from_equipment, AcLineSegment):
+            lines.add(ps.path.from_equipment)
+
+    return collect_lines
+
+
+async def get_upstream_lines_to_transformer(ec: EnergyConsumer) -> Set[AcLineSegment]:
+    lines = set()
+
+    await (
+        Tracing.network_trace()
+        .add_condition(upstream())
+        .add_condition(stop_at_open())
+        .add_step_action(collect_upstream_lines_provider(lines))
+        .add_stop_condition(_is_transformer)
+    ).run(start=ec, phases=PhaseCode.ABCN, can_stop_on_start_item=False)
+
+    return lines
+
+
+def _is_transformer(ps: NetworkTraceStep, _context=None) -> bool:
+    return isinstance(ps.path.to_equipment, PowerTransformer)
+
+
+async def upload_loop_impedance_study(
+    eas_client: EasClient,
+    ecs: List[EnergyConsumer],
+    lines: List[AcLineSegment],
+    ec_to_loop_z_phase_phase: Dict[str, float],
+    ec_to_loop_z_phase_earth: Dict[str, float],
+    line_to_z_per_km: Dict[str, float],
+    name: str,
+    description: str,
+    tags: List[str],
+    styles: List,
+) -> None:
+
+    class_to_properties = {
+        EnergyConsumer: {
+            "name": lambda ec: ec.name,
+            "type": lambda x: "ec",
+        },
+        AcLineSegment: {
+            "name": lambda line: line.name,
+            "z_ohm_per_km": _line_z_per_km_from(line_to_z_per_km),
+            "type": lambda x: "line",
+        },
+    }
+    phase_phase_feature_collection = _to_loop_feature_collection(ecs, lines, class_to_properties, ec_to_loop_z_phase_phase)
+    phase_earth_feature_collection = _to_loop_feature_collection(ecs, lines, class_to_properties, ec_to_loop_z_phase_earth)
+    response = await eas_client.async_upload_study(
+        Study(
+            name=name,
+            description=description,
+            tags=tags,
+            results=[
+                Result(
+                    name="Phase-to-Phase Loop Approximation",
+                    geo_json_overlay=GeoJsonOverlay(
+                        data=phase_phase_feature_collection,
+                        styles=[s['id'] for s in styles]
+                    )
+                ),
+                Result(
+                    name="Phase-to-Earth Loop Approximation",
+                    geo_json_overlay=GeoJsonOverlay(
+                        data=phase_earth_feature_collection,
+                        styles=[s['id'] for s in styles]
+                    )
+                )
+            ],
+            styles=styles
+        )
+    )
+    print(f"Study response: {response}")
+
+
+def _loop_z_from(ec_to_loop_z: Dict[str, float]):
+    def fun(ec: EnergyConsumer):
+        return round(ec_to_loop_z.get(ec.mrid, 0.0), 4)
+
+    return fun
+
+
+def _loop_z_label_from(ec_to_loop_z: Dict[str, float]):
+    def fun(ec: EnergyConsumer):
+        value = ec_to_loop_z.get(ec.mrid, 0.0)
+        return f"{value:.2f}Ω"
+
+    return fun
+
+
+def _line_z_per_km_from(line_to_z_per_km: Dict[str, float]):
+    def fun(line: AcLineSegment):
+        return round(line_to_z_per_km.get(line.mrid, 0.0), 4)
+
+    return fun
+
+
+def to_geojson_feature_collection(
+    psrs: List[PowerSystemResource],
+    class_to_properties: Dict[Type, Dict[str, Callable[[Any], Any]]]
+) -> FeatureCollection:
+
+    features = []
+    for psr in psrs:
+        properties_map = class_to_properties.get(type(psr))
+
+        if properties_map is not None:
+            feature = to_geojson_feature(psr, properties_map)
+            if feature is not None:
+                features.append(feature)
+
+    return FeatureCollection(features)
+
+
+def _to_loop_feature_collection(
+    ecs: List[EnergyConsumer],
+    lines: List[AcLineSegment],
+    class_to_properties: Dict[Type, Dict[str, Callable[[Any], Any]]],
+    ec_to_loop_z: Dict[str, float],
+) -> FeatureCollection:
+    properties = {
+        **class_to_properties,
+        EnergyConsumer: {
+            **class_to_properties[EnergyConsumer],
+            "loop_z_ohm": _loop_z_from(ec_to_loop_z),
+            "loop_z_label": _loop_z_label_from(ec_to_loop_z),
+        },
+    }
+    return to_geojson_feature_collection(ecs + lines, properties)
+
+
+def to_geojson_feature(
+    psr: PowerSystemResource,
+    property_map: Dict[str, Callable[[PowerSystemResource], Any]]
+) -> Union[Feature, None]:
+
+    geometry = to_geojson_geometry(psr.location)
+    if geometry is None:
+        return None
+
+    properties = {k: f(psr) for (k, f) in property_map.items()}
+    return Feature(psr.mrid, geometry, properties)
+
+
+def to_geojson_geometry(location: Location) -> Union[Geometry, None]:
+    points = list(location.points) if location is not None else []
+    if len(points) > 1:
+        return LineString([(point.x_position, point.y_position) for point in points])
+    elif len(points) == 1:
+        return Point((points[0].x_position, points[0].y_position))
+    else:
+        return None
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/src/zepben/examples/studies/pec_capacity_vs_transformer_rating.py b/src/zepben/examples/studies/pec_capacity_vs_transformer_rating.py
new file mode 100644
index 0000000..831b0e0
--- /dev/null
+++ b/src/zepben/examples/studies/pec_capacity_vs_transformer_rating.py
@@ -0,0 +1,337 @@
+#  Copyright 2025 Zeppelin Bend Pty Ltd
+#
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+import asyncio
+import json
+from datetime import datetime
+from itertools import islice
+from typing import List, Dict, Tuple, Callable, Any, Union, Type, Set
+
+from geojson import FeatureCollection, Feature
+from geojson.geometry import Geometry, LineString, Point
+from zepben.eas.client.eas_client import EasClient
+from zepben.eas.client.study import Study, Result, GeoJsonOverlay
+from zepben.ewb import (
+    PowerTransformer,
+    ConductingEquipment,
+    PhotoVoltaicUnit,
+    PowerElectronicsConnection,
+    NetworkConsumerClient,
+    PhaseCode,
+    Feeder,
+    PowerSystemResource,
+    Location,
+    connect_with_token,
+    NetworkTraceStep,
+    Tracing,
+    downstream,
+    IncludedEnergizedContainers,
+)
+
+
+with open("../config.json") as f:
+    c = json.loads(f.read())
+
+
+def chunk(it, size):
+    it = iter(it)
+    return iter(lambda: tuple(islice(it, size)), ())
+
+
+async def main():
+    # Only process feeders in the following zones
+    zone_mrids = ["CPM"]
+    pv_only = True  # Set False to include all PowerElectronicsConnections, not just those with PV units.
+    print(f"Start time: {datetime.now()}")
+
+    rpc_channel = connect_with_token(
+        host=c["host"],
+        access_token=c["access_token"],
+        rpc_port=c["rpc_port"],
+        ca_filename=c.get("ca_filename"),
+        timeout_seconds=c.get("timeout_seconds", 5),
+        debug=bool(c.get("debug", False)),
+        skip_connection_test=bool(c.get("skip_connection_test", False)),
+    )
+    client = NetworkConsumerClient(rpc_channel)
+    hierarchy = (await client.get_network_hierarchy()).throw_on_error()
+    substations = hierarchy.value.substations
+
+    print(f"Collecting feeders from zones {', '.join(zone_mrids)}.")
+    feeder_mrids = []
+    for zone_mrid in zone_mrids:
+        if zone_mrid in substations:
+            for feeder in substations[zone_mrid].feeders:
+                feeder_mrids.append(feeder.mrid)
+
+    print(f"Feeders to be processed: {', '.join(feeder_mrids)}")
+
+    all_transformers: List[PowerTransformer] = []
+    transformer_to_stats: Dict[str, Tuple[int, int, int, int]] = {}
+
+    # Process the feeders in batches of 3, using asyncio, for performance
+    batches = chunk(feeder_mrids, 3)
+    for feeders in batches:
+        futures = []
+        rpc_channel = connect_with_token(
+            host=c["host"],
+            access_token=c["access_token"],
+            rpc_port=c["rpc_port"],
+            ca_filename=c.get("ca_filename"),
+            timeout_seconds=c.get("timeout_seconds", 5),
+            debug=bool(c.get("debug", False)),
+            skip_connection_test=bool(c.get("skip_connection_test", False)),
+        )
+        print(f"Processing feeders {', '.join(feeders)}")
+        for feeder_mrid in feeders:
+            futures.append(
+                asyncio.ensure_future(
+                    fetch_feeder_and_capacity_stats(
+                        feeder_mrid,
+                        rpc_channel,
+                        pv_only=pv_only,
+                    )
+                )
+            )
+
+        for future in futures:
+            transformers, stats = await future
+            if transformers:  # Empty if the feeder failed
+                all_transformers.extend(transformers)
+                transformer_to_stats.update(stats)
+
+    print(f"Created Study for {len(all_transformers)} transformers")
+
+    eas_client = EasClient(host=c["host"], port=c["rpc_port"], protocol="https", access_token=c["access_token"])
+    print(f"Uploading Study for zones {', '.join(zone_mrids)} ...")
+    await upload_capacity_percent_study(
+        eas_client,
+        all_transformers,
+        transformer_to_stats,
+        name=f"PEC Capacity % vs Transformer Rating ({', '.join(zone_mrids)})",
+        description="Compares sum of PowerElectronicsConnection capacity (PV only by default) to transformer rating.",
+        tags=["pec_capacity_percent", "-".join(zone_mrids)],
+        styles=json.load(open("style_pec_capacity_percent.json", "r")),
+    )
+    await eas_client.aclose()
+    print("Uploaded Study")
+
+    print(f"Finish time: {datetime.now()}")
+
+
+def collect_eq_provider(collection: Set[ConductingEquipment]):
+
+    async def collect_equipment(ps: NetworkTraceStep, _):
+        collection.add(ps.path.to_equipment)
+
+    return collect_equipment
+
+
+async def get_downstream_eq(ce: ConductingEquipment) -> Set[ConductingEquipment]:
+    equipment_set = set()
+
+    await (
+        Tracing.network_trace()
+        .add_condition(downstream())
+        .add_step_action(collect_eq_provider(equipment_set))
+    ).run(start=ce, phases=PhaseCode.ABCN, can_stop_on_start_item=False)
+
+    return equipment_set
+
+
+async def fetch_feeder_and_capacity_stats(
+    feeder_mrid: str,
+    rpc_channel,
+    pv_only: bool,
+) -> Tuple[List[PowerTransformer], Dict[str, Tuple[int, int, int, int]]]:
+    print(f"Fetching Feeder {feeder_mrid}")
+    client = NetworkConsumerClient(rpc_channel)
+
+    result = (
+        await client.get_equipment_container(
+            mrid=feeder_mrid,
+            expected_class=Feeder,
+            include_energized_containers=IncludedEnergizedContainers.LV_FEEDERS,
+        )
+    )
+    if result.was_failure:
+        print(f"Failed: {result.thrown}")
+        return [], {}
+
+    network = client.service
+    print(f"Finished fetching Feeder {feeder_mrid}")
+
+    transformers: List[PowerTransformer] = []
+    transformer_to_stats: Dict[str, Tuple[int, int, int, int]] = {}
+
+    print(f"Tracing downstream transformers for feeder {feeder_mrid}")
+    for io in (pt for pt in network.objects(PowerTransformer)):
+        pt: PowerTransformer = io
+        transformers.append(pt)
+        downstream_equipment = await get_downstream_eq(pt)
+
+        pecs = [
+            eq for eq in downstream_equipment
+            if isinstance(eq, PowerElectronicsConnection)
+        ]
+        if pv_only:
+            pecs = [pec for pec in pecs if _pec_has_pv_unit(pec)]
+
+        capacity_va = sum(_pec_capacity_va(pec) for pec in pecs)
+        rating_va = _transformer_rating_va(pt)
+        percent = round((capacity_va / rating_va) * 100) if rating_va else 0
+
+        transformer_to_stats[pt.mrid] = (capacity_va, rating_va, percent, len(pecs))
+
+    return transformers, transformer_to_stats
+
+
+def _pec_has_pv_unit(pec: PowerElectronicsConnection) -> bool:
+    return any(isinstance(unit, PhotoVoltaicUnit) for unit in pec.units)
+
+
+def _pec_capacity_va(pec: PowerElectronicsConnection) -> int:
+    if pec.rated_s is not None:
+        return int(pec.rated_s)
+    unit_capacity = sum(unit.max_p for unit in pec.units if unit.max_p is not None)
+    return int(unit_capacity) if unit_capacity else 0
+
+
+def _transformer_rating_va(pt: PowerTransformer) -> int:
+    ratings: List[int] = []
+    for end in pt.ends:
+        if end.rated_s is not None:
+            ratings.append(end.rated_s)
+        else:
+            for rating in end.s_ratings:
+                if rating and rating.rated_s is not None:
+                    ratings.append(rating.rated_s)
+    return max(ratings) if ratings else 0
+
+
+async def upload_capacity_percent_study(
+    eas_client: EasClient,
+    transformers: List[PowerTransformer],
+    transformer_to_stats: Dict[str, Tuple[int, int, int, int]],
+    name: str,
+    description: str,
+    tags: List[str],
+    styles: List,
+) -> None:
+
+    class_to_properties = {
+        PowerTransformer: {
+            "capacity_percent": _capacity_percent_from(transformer_to_stats),
+            "capacity_percent_label": _capacity_percent_label_from(transformer_to_stats),
+            "pec_capacity_va": _pec_capacity_from(transformer_to_stats),
+            "transformer_rating_va": _transformer_rating_from(transformer_to_stats),
+            "pec_count": _pec_count_from(transformer_to_stats),
+            "type": lambda x: "pt",
+        }
+    }
+    feature_collection = to_geojson_feature_collection(transformers, class_to_properties)
+    response = await eas_client.async_upload_study(
+        Study(
+            name=name,
+            description=description,
+            tags=tags,
+            results=[
+                Result(
+                    name=name,
+                    geo_json_overlay=GeoJsonOverlay(
+                        data=feature_collection,
+                        styles=[s["id"] for s in styles],
+                    ),
+                )
+            ],
+            styles=styles,
+        )
+    )
+    print(f"Study response: {response}")
+
+
+def _capacity_percent_from(pt_to_stats: Dict[str, Tuple[int, int, int, int]]):
+    def fun(pt: PowerTransformer):
+        capacity, rating, percent, pec_count = pt_to_stats.get(pt.mrid, (0, 0, 0, 0))
+        return percent
+
+    return fun
+
+
+def _capacity_percent_label_from(pt_to_stats: Dict[str, Tuple[int, int, int, int]]):
+    def fun(pt: PowerTransformer):
+        capacity, rating, percent, pec_count = pt_to_stats.get(pt.mrid, (0, 0, 0, 0))
+        return "n/a" if rating == 0 else f"{percent}%"
+
+    return fun
+
+
+def _pec_capacity_from(pt_to_stats: Dict[str, Tuple[int, int, int, int]]):
+    def fun(pt: PowerTransformer):
+        capacity, rating, percent, pec_count = pt_to_stats.get(pt.mrid, (0, 0, 0, 0))
+        return capacity
+
+    return fun
+
+
+def _transformer_rating_from(pt_to_stats: Dict[str, Tuple[int, int, int, int]]):
+    def fun(pt: PowerTransformer):
+        capacity, rating, percent, pec_count = pt_to_stats.get(pt.mrid, (0, 0, 0, 0))
+        return rating
+
+    return fun
+
+
+def _pec_count_from(pt_to_stats: Dict[str, Tuple[int, int, int, int]]):
+    def fun(pt: PowerTransformer):
+        capacity, rating, percent, pec_count = pt_to_stats.get(pt.mrid, (0, 0, 0, 0))
+        return pec_count
+
+    return fun
+
+
+def to_geojson_feature_collection(
+    psrs: List[PowerSystemResource],
+    class_to_properties: Dict[Type, Dict[str, Callable[[Any], Any]]],
+) -> FeatureCollection:
+
+    features = []
+    for psr in psrs:
+        properties_map = class_to_properties.get(type(psr))
+        if properties_map is None:
+            continue
+        feature = to_geojson_feature(psr, properties_map)
+        if feature is not None:
+            features.append(feature)
+
+    return FeatureCollection(features)
+
+
+def to_geojson_feature(
+    psr: PowerSystemResource,
+    property_map: Dict[str, Callable[[PowerSystemResource], Any]],
+) -> Union[Feature, None]:
+
+    geometry = to_geojson_geometry(psr.location)
+    if geometry is None:
+        return None
+
+    properties = {k: f(psr) for (k, f) in property_map.items()}
+    return Feature(psr.mrid, geometry, properties)
+
+
+def to_geojson_geometry(location: Location) -> Union[Geometry, None]:
+    points = list(location.points) if location is not None else []
+    if len(points) > 1:
+        return LineString([(point.x_position, point.y_position) for point in points])
+    elif len(points) == 1:
+        return Point((points[0].x_position, points[0].y_position))
+    else:
+        return None
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/src/zepben/examples/studies/pv_percent_by_transformer.py b/src/zepben/examples/studies/pv_percent_by_transformer.py
new file mode 100644
index 0000000..66e91ef
--- /dev/null
+++ b/src/zepben/examples/studies/pv_percent_by_transformer.py
@@ -0,0 +1,322 @@
+#  Copyright 2025 Zeppelin Bend Pty Ltd
+#
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+import asyncio
+import json
+from datetime import datetime
+from itertools import islice
+from typing import List, Dict, Tuple, Callable, Any, Union, Type, Set
+
+from geojson import FeatureCollection, Feature
+from geojson.geometry import Geometry, LineString, Point
+from zepben.eas.client.eas_client import EasClient
+from zepben.eas.client.study import Study, Result, GeoJsonOverlay
+from zepben.ewb import (
+    PowerTransformer,
+    ConductingEquipment,
+    EnergyConsumer,
+    PhotoVoltaicUnit,
+    PowerElectronicsConnection,
+    NetworkConsumerClient,
+    PhaseCode,
+    Feeder,
+    PowerSystemResource,
+    Location,
+    connect_with_token,
+    NetworkTraceStep,
+    Tracing,
+    downstream,
+    IncludedEnergizedContainers,
+)
+
+
+with open("../config.json") as f:
+    c = json.loads(f.read())
+
+
+def chunk(it, size):
+    it = iter(it)
+    return iter(lambda: tuple(islice(it, size)), ())
+
+
+async def main():
+    # Only process feeders in the following zones
+    zone_mrids = ["CPM"]
+    print(f"Start time: {datetime.now()}")
+
+    rpc_channel = connect_with_token(
+        host=c["host"],
+        access_token=c["access_token"],
+        rpc_port=c["rpc_port"],
+        ca_filename=c.get("ca_filename"),
+        timeout_seconds=c.get("timeout_seconds", 5),
+        debug=bool(c.get("debug", False)),
+        skip_connection_test=bool(c.get("skip_connection_test", False)),
+    )
+    client = NetworkConsumerClient(rpc_channel)
+    hierarchy = (await client.get_network_hierarchy()).throw_on_error()
+    substations = hierarchy.value.substations
+
+    print(f"Collecting feeders from zones {', '.join(zone_mrids)}.")
+    feeder_mrids = []
+    for zone_mrid in zone_mrids:
+        if zone_mrid in substations:
+            for feeder in substations[zone_mrid].feeders:
+                feeder_mrids.append(feeder.mrid)
+
+    print(f"Feeders to be processed: {', '.join(feeder_mrids)}")
+
+    all_transformers: List[PowerTransformer] = []
+    transformer_to_stats: Dict[str, Tuple[int, int, int]] = {}
+
+    # Process the feeders in batches of 3, using asyncio, for performance
+    batches = chunk(feeder_mrids, 3)
+    for feeders in batches:
+        futures = []
+        rpc_channel = connect_with_token(
+            host=c["host"],
+            access_token=c["access_token"],
+            rpc_port=c["rpc_port"],
+            ca_filename=c.get("ca_filename"),
+            timeout_seconds=c.get("timeout_seconds", 5),
+            debug=bool(c.get("debug", False)),
+            skip_connection_test=bool(c.get("skip_connection_test", False)),
+        )
+        print(f"Processing feeders {', '.join(feeders)}")
+        for feeder_mrid in feeders:
+            futures.append(asyncio.ensure_future(fetch_feeder_and_pv_stats(feeder_mrid, rpc_channel)))
+
+        for future in futures:
+            transformers, stats = await future
+            if transformers:  # Empty if the feeder failed
+                all_transformers.extend(transformers)
+                transformer_to_stats.update(stats)
+
+    print(f"Created Study for {len(all_transformers)} transformers")
+
+    eas_client = EasClient(host=c["host"], port=c["rpc_port"], protocol="https", access_token=c["access_token"])
+    print(f"Uploading Study for zones {', '.join(zone_mrids)} ...")
+    await upload_pv_percent_study(
+        eas_client,
+        all_transformers,
+        transformer_to_stats,
+        name=f"PV % by Transformer ({', '.join(zone_mrids)})",
+        description="Percentage of EnergyConsumers with PV (PhotoVoltaicUnit) downstream of each transformer.",
+        tags=["pv_percent_by_transformer", "-".join(zone_mrids)],
+        styles=json.load(open("style_pv_percent.json", "r")),
+    )
+    await eas_client.aclose()
+    print("Uploaded Study")
+
+    print(f"Finish time: {datetime.now()}")
+
+
+def collect_eq_provider(collection: Set[ConductingEquipment]):
+
+    async def collect_equipment(ps: NetworkTraceStep, _):
+        collection.add(ps.path.to_equipment)
+
+    return collect_equipment
+
+
+async def get_downstream_eq(ce: ConductingEquipment) -> Set[ConductingEquipment]:
+    equipment_set = set()
+
+    await (
+        Tracing.network_trace()
+        .add_condition(downstream())
+        .add_step_action(collect_eq_provider(equipment_set))
+    ).run(start=ce, phases=PhaseCode.ABCN, can_stop_on_start_item=False)
+
+    return equipment_set
+
+
+async def fetch_feeder_and_pv_stats(
+    feeder_mrid: str,
+    rpc_channel,
+) -> Tuple[List[PowerTransformer], Dict[str, Tuple[int, int, int]]]:
+    print(f"Fetching Feeder {feeder_mrid}")
+    client = NetworkConsumerClient(rpc_channel)
+
+    result = (
+        await client.get_equipment_container(
+            mrid=feeder_mrid,
+            expected_class=Feeder,
+            include_energized_containers=IncludedEnergizedContainers.LV_FEEDERS,
+        )
+    )
+    if result.was_failure:
+        print(f"Failed: {result.thrown}")
+        return [], {}
+
+    network = client.service
+    print(f"Finished fetching Feeder {feeder_mrid}")
+
+    pv_consumers = _find_pv_energy_consumers(network)
+
+    transformers: List[PowerTransformer] = []
+    transformer_to_stats: Dict[str, Tuple[int, int, int]] = {}
+
+    print(f"Tracing downstream transformers for feeder {feeder_mrid}")
+    for io in (pt for pt in network.objects(PowerTransformer)):
+        pt: PowerTransformer = io
+        transformers.append(pt)
+        downstream_equipment = await get_downstream_eq(pt)
+        downstream_ecs = [eq for eq in downstream_equipment if isinstance(eq, EnergyConsumer)]
+        total_ec = len(downstream_ecs)
+        pv_ec = sum(1 for ec in downstream_ecs if ec.mrid in pv_consumers)
+        pv_percent = round((pv_ec / total_ec) * 100) if total_ec else 0
+        transformer_to_stats[pt.mrid] = (pv_ec, total_ec, pv_percent)
+
+    return transformers, transformer_to_stats
+
+
+def _find_pv_energy_consumers(network) -> Set[str]:
+    pv_usage_points: Set[str] = set()
+    pv_nodes: Set[str] = set()
+
+    # PV units can be directly linked to usage points or via their power electronics connection
+    for pv in network.objects(PhotoVoltaicUnit):
+        for up in pv.usage_points:
+            pv_usage_points.add(up.mrid)
+        if pv.power_electronics_connection:
+            for up in pv.power_electronics_connection.usage_points:
+                pv_usage_points.add(up.mrid)
+
+    # PV units also appear on power electronics connections
+    for pec in network.objects(PowerElectronicsConnection):
+        if any(isinstance(unit, PhotoVoltaicUnit) for unit in pec.units):
+            for up in pec.usage_points:
+                pv_usage_points.add(up.mrid)
+            for terminal in pec.terminals:
+                if terminal.connectivity_node:
+                    pv_nodes.add(terminal.connectivity_node.mrid)
+
+    pv_consumers: Set[str] = set()
+    for ec in network.objects(EnergyConsumer):
+        if any(up.mrid in pv_usage_points for up in ec.usage_points):
+            pv_consumers.add(ec.mrid)
+            continue
+        if pv_nodes and any(t.connectivity_node and t.connectivity_node.mrid in pv_nodes for t in ec.terminals):
+            pv_consumers.add(ec.mrid)
+
+    return pv_consumers
+
+
+async def upload_pv_percent_study(
+    eas_client: EasClient,
+    transformers: List[PowerTransformer],
+    transformer_to_stats: Dict[str, Tuple[int, int, int]],
+    name: str,
+    description: str,
+    tags: List[str],
+    styles: List,
+) -> None:
+
+    class_to_properties = {
+        PowerTransformer: {
+            "pv_percent": _pv_percent_from(transformer_to_stats),
+            "pv_percent_label": _pv_percent_label_from(transformer_to_stats),
+            "pv_ec_count": _pv_count_from(transformer_to_stats),
+            "ec_count": _ec_count_from(transformer_to_stats),
+            "type": lambda x: "pt",
+        }
+    }
+    feature_collection = to_geojson_feature_collection(transformers, class_to_properties)
+    response = await eas_client.async_upload_study(
+        Study(
+            name=name,
+            description=description,
+            tags=tags,
+            results=[
+                Result(
+                    name=name,
+                    geo_json_overlay=GeoJsonOverlay(
+                        data=feature_collection,
+                        styles=[s["id"] for s in styles],
+                    ),
+                )
+            ],
+            styles=styles,
+        )
+    )
+    print(f"Study response: {response}")
+
+
+def _pv_percent_from(pt_to_stats: Dict[str, Tuple[int, int, int]]):
+    def fun(pt: PowerTransformer):
+        pv_count, total, percent = pt_to_stats.get(pt.mrid, (0, 0, 0))
+        return percent
+
+    return fun
+
+
+def _pv_percent_label_from(pt_to_stats: Dict[str, Tuple[int, int, int]]):
+    def fun(pt: PowerTransformer):
+        pv_count, total, percent = pt_to_stats.get(pt.mrid, (0, 0, 0))
+        return f"{percent}%"
+
+    return fun
+
+
+def _pv_count_from(pt_to_stats: Dict[str, Tuple[int, int, int]]):
+    def fun(pt: PowerTransformer):
+        pv_count, total, percent = pt_to_stats.get(pt.mrid, (0, 0, 0))
+        return pv_count
+
+    return fun
+
+
+def _ec_count_from(pt_to_stats: Dict[str, Tuple[int, int, int]]):
+    def fun(pt: PowerTransformer):
+        pv_count, total, percent = pt_to_stats.get(pt.mrid, (0, 0, 0))
+        return total
+
+    return fun
+
+
+def to_geojson_feature_collection(
+    psrs: List[PowerSystemResource],
+    class_to_properties: Dict[Type, Dict[str, Callable[[Any], Any]]],
+) -> FeatureCollection:
+
+    features = []
+    for psr in psrs:
+        properties_map = class_to_properties.get(type(psr))
+        if properties_map is None:
+            continue
+        feature = to_geojson_feature(psr, properties_map)
+        if feature is not None:
+            features.append(feature)
+
+    return FeatureCollection(features)
+
+
+def to_geojson_feature(
+    psr: PowerSystemResource,
+    property_map: Dict[str, Callable[[PowerSystemResource], Any]],
+) -> Union[Feature, None]:
+
+    geometry = to_geojson_geometry(psr.location)
+    if geometry is None:
+        return None
+
+    properties = {k: f(psr) for (k, f) in property_map.items()}
+    return Feature(psr.mrid, geometry, properties)
+
+
+def to_geojson_geometry(location: Location) -> Union[Geometry, None]:
+    points = list(location.points) if location is not None else []
+    if len(points) > 1:
+        return LineString([(point.x_position, point.y_position) for point in points])
+    elif len(points) == 1:
+        return Point((points[0].x_position, points[0].y_position))
+    else:
+        return None
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/src/zepben/examples/studies/style_customer_distance.json b/src/zepben/examples/studies/style_customer_distance.json
new file mode 100644
index 0000000..7b87cbb
--- /dev/null
+++ b/src/zepben/examples/studies/style_customer_distance.json
@@ -0,0 +1,44 @@
+[
+  {
+    "id": "ec-distance",
+    "name": "Customer Distance to Transformer (m)",
+    "type": "circle",
+    "minzoom": 12,
+    "paint": {
+      "circle-radius": 12,
+      "circle-color": [
+        "case",
+        ["==", ["get", "distance_m"], 0],
+        "rgb(160,160,160)",
+        ["step", ["get", "distance_m"],
+          "rgb(0,180,40)", 200,
+          "rgb(171,221,164)", 300,
+          "rgb(253,174,97)", 400,
+          "rgb(244,109,67)", 500,
+          "rgb(210,2,29)"
+        ]
+      ],
+      "circle-stroke-color": "white",
+      "circle-stroke-width": 1
+    },
+    "filter" : ["==", ["get", "type"], "ec"]
+  },
+  {
+    "id": "ec-distance-label",
+    "name": "Distance Label",
+    "type": "symbol",
+    "minzoom": 13,
+    "layout": {
+      "text-field": ["get", "distance_label"],
+      "text-font": ["DIN Offc Pro Medium", "Arial Unicode MS Bold"],
+      "text-size": 11
+    },
+    "paint": {
+      "text-color": "black",
+      "text-halo-blur": 6,
+      "text-halo-width": 6,
+      "text-halo-color": "white"
+    },
+    "filter" : ["==", ["get", "type"], "ec"]
+  }
+]
diff --git a/src/zepben/examples/studies/style_eol.json b/src/zepben/examples/studies/style_eol.json
index 546c44c..6001d8b 100644
--- a/src/zepben/examples/studies/style_eol.json
+++ b/src/zepben/examples/studies/style_eol.json
@@ -50,19 +50,25 @@
     "minzoom": 12,
     "paint": {
       "circle-radius": 15,
-      "circle-color": "rgb(0,200,2)",
+      "circle-color": [
+        "step",
+        ["get", "suspect_length_m"],
+        "rgb(0,200,2)", 100,
+        "rgb(244,109,67)", 200,
+        "rgb(210,2,29)"
+      ],
       "circle-stroke-color": "white",
       "circle-stroke-width": 1
     },
     "filter" : ["==", ["get", "type"], "pt"]
   },
   {
-    "id": "consumer-count-label",
-    "name": "Consumer Count",
+    "id": "suspect-length-label",
+    "name": "Suspect Length",
     "type": "symbol",
     "minzoom": 12,
     "layout": {
-      "text-field": ["get", "consumer_count"],
+      "text-field": ["get", "suspect_length_label"],
       "text-font": ["DIN Offc Pro Medium", "Arial Unicode MS Bold"],
       "text-size": 12
     },
diff --git a/src/zepben/examples/studies/style_feeder_tie_switches.json b/src/zepben/examples/studies/style_feeder_tie_switches.json
new file mode 100644
index 0000000..cea689f
--- /dev/null
+++ b/src/zepben/examples/studies/style_feeder_tie_switches.json
@@ -0,0 +1,142 @@
+[
+  {
+    "id": "feeder-tie-switch-mv-mv",
+    "name": "Feeder Tie Switches (MV↔MV)",
+    "type": "circle",
+    "minzoom": 11,
+    "paint": {
+      "circle-radius": 9,
+      "circle-color": "rgb(49,130,189)",
+      "circle-stroke-color": "white",
+      "circle-stroke-width": 1.5
+    },
+    "filter": ["all", ["==", ["get", "type"], "switch"], ["==", ["get", "tie_type"], "mv_mv_tie"]]
+  },
+  {
+    "id": "feeder-tie-switch-label-mv-mv",
+    "name": "Feeder Tie Switch Labels (MV↔MV)",
+    "type": "symbol",
+    "minzoom": 13,
+    "layout": {
+      "text-field": [
+        "concat",
+        ["get", "name"],
+        " (MV↔MV)"
+      ],
+      "text-font": ["DIN Offc Pro Medium", "Arial Unicode MS Bold"],
+      "text-size": 11
+    },
+    "paint": {
+      "text-color": "black",
+      "text-halo-blur": 6,
+      "text-halo-width": 4,
+      "text-halo-color": "white"
+    },
+    "filter": ["all", ["==", ["get", "type"], "switch"], ["==", ["get", "tie_type"], "mv_mv_tie"]]
+  },
+  {
+    "id": "feeder-tie-switch-mv-lv",
+    "name": "Feeder Tie Switches (MV↔LV)",
+    "type": "circle",
+    "minzoom": 11,
+    "paint": {
+      "circle-radius": 9,
+      "circle-color": "rgb(244,109,67)",
+      "circle-stroke-color": "white",
+      "circle-stroke-width": 1.5
+    },
+    "filter": ["all", ["==", ["get", "type"], "switch"], ["==", ["get", "tie_type"], "mv_lv_tie"]]
+  },
+  {
+    "id": "feeder-tie-switch-label-mv-lv",
+    "name": "Feeder Tie Switch Labels (MV↔LV)",
+    "type": "symbol",
+    "minzoom": 13,
+    "layout": {
+      "text-field": [
+        "concat",
+        ["get", "name"],
+        " (MV↔LV)"
+      ],
+      "text-font": ["DIN Offc Pro Medium", "Arial Unicode MS Bold"],
+      "text-size": 11
+    },
+    "paint": {
+      "text-color": "black",
+      "text-halo-blur": 6,
+      "text-halo-width": 4,
+      "text-halo-color": "white"
+    },
+    "filter": ["all", ["==", ["get", "type"], "switch"], ["==", ["get", "tie_type"], "mv_lv_tie"]]
+  },
+  {
+    "id": "feeder-tie-switch-mv-via-lv",
+    "name": "Feeder Tie Switches (MV via LV)",
+    "type": "circle",
+    "minzoom": 11,
+    "paint": {
+      "circle-radius": 9,
+      "circle-color": "rgb(171,221,164)",
+      "circle-stroke-color": "white",
+      "circle-stroke-width": 1.5
+    },
+    "filter": ["all", ["==", ["get", "type"], "switch"], ["==", ["get", "tie_type"], "mv_via_lv_tie"]]
+  },
+  {
+    "id": "feeder-tie-switch-label-mv-via-lv",
+    "name": "Feeder Tie Switch Labels (MV via LV)",
+    "type": "symbol",
+    "minzoom": 13,
+    "layout": {
+      "text-field": [
+        "concat",
+        ["get", "name"],
+        " (MV via LV)"
+      ],
+      "text-font": ["DIN Offc Pro Medium", "Arial Unicode MS Bold"],
+      "text-size": 11
+    },
+    "paint": {
+      "text-color": "black",
+      "text-halo-blur": 6,
+      "text-halo-width": 4,
+      "text-halo-color": "white"
+    },
+    "filter": ["all", ["==", ["get", "type"], "switch"], ["==", ["get", "tie_type"], "mv_via_lv_tie"]]
+  },
+  {
+    "id": "feeder-tie-switch-lv-lv",
+    "name": "Feeder Tie Switches (LV↔LV)",
+    "type": "circle",
+    "minzoom": 11,
+    "paint": {
+      "circle-radius": 9,
+      "circle-color": "rgb(49,163,84)",
+      "circle-stroke-color": "white",
+      "circle-stroke-width": 1.5
+    },
+    "filter": ["all", ["==", ["get", "type"], "switch"], ["==", ["get", "tie_type"], "lv_lv_tie"]]
+  },
+  {
+    "id": "feeder-tie-switch-label-lv-lv",
+    "name": "Feeder Tie Switch Labels (LV↔LV)",
+    "type": "symbol",
+    "minzoom": 13,
+    "layout": {
+      "text-field": [
+        "concat",
+        ["get", "name"],
+        " (LV↔LV)"
+      ],
+      "text-font": ["DIN Offc Pro Medium", "Arial Unicode MS Bold"],
+      "text-size": 11
+    },
+    "paint": {
+      "text-color": "black",
+      "text-halo-blur": 6,
+      "text-halo-width": 4,
+      "text-halo-color": "white"
+    },
+    "filter": ["all", ["==", ["get", "type"], "switch"], ["==", ["get", "tie_type"], "lv_lv_tie"]]
+  }
+]
diff --git a/src/zepben/examples/studies/style_loop_impedance.json b/src/zepben/examples/studies/style_loop_impedance.json
new file mode 100644
index 0000000..d94e383
--- /dev/null
+++ b/src/zepben/examples/studies/style_loop_impedance.json
@@ -0,0 +1,65 @@
+[
+  {
+    "id": "line-impedance",
+    "name": "Line Impedance (ohm/km)",
+    "type": "line",
+    "paint": {
+      "line-color": [
+        "case",
+        ["==", ["get", "z_ohm_per_km"], 0],
+        "rgb(160,160,160)",
+        ["step", ["get", "z_ohm_per_km"],
+          "rgb(0,180,40)", 0.2,
+          "rgb(171,221,164)", 0.5,
+          "rgb(253,174,97)", 1.5,
+          "rgb(244,109,67)", 6.0,
+          "rgb(210,2,29)"
+        ]
+      ],
+      "line-width": 2
+    },
+    "filter" : ["==", ["get", "type"], "line"]
+  },
+  {
+    "id": "ec-loop-impedance",
+    "name": "Loop Impedance (ohm)",
+    "type": "circle",
+    "minzoom": 12,
+    "paint": {
+      "circle-radius": 12,
+      "circle-color": [
+        "case",
+        ["==", ["get", "loop_z_ohm"], 0],
+        "rgb(160,160,160)",
+        ["step", ["get", "loop_z_ohm"],
+          "rgb(0,180,40)", 0.1,
+          "rgb(171,221,164)", 0.2,
+          "rgb(253,174,97)", 0.5,
+          "rgb(244,109,67)", 1.0,
+          "rgb(210,2,29)"
+        ]
+      ],
+      "circle-stroke-color": "white",
+      "circle-stroke-width": 1
+    },
+    "filter" : ["==", ["get", "type"], "ec"]
+  },
+  {
+    "id": "ec-loop-impedance-label",
+    "name": "Loop Impedance Label",
+    "type": "symbol",
+    "minzoom": 13,
+    "layout": {
+      "text-field": ["get", "loop_z_label"],
+      "text-font": ["DIN Offc Pro Medium", "Arial Unicode MS Bold"],
+      "text-size": 11
+    },
+    "paint": {
+      "text-color": "black",
+      "text-halo-blur": 6,
+      "text-halo-width": 6,
+      "text-halo-color": "white"
+    },
+    "filter" : ["==", ["get", "type"], "ec"]
+  }
+]
diff --git a/src/zepben/examples/studies/style_pec_capacity_percent.json b/src/zepben/examples/studies/style_pec_capacity_percent.json
new file mode 100644
index 0000000..70f8669
--- /dev/null
+++ b/src/zepben/examples/studies/style_pec_capacity_percent.json
@@ -0,0 +1,41 @@
+[
+  {
+    "id": "pec-capacity-transformers",
+    "name": "PEC Capacity % by Transformer",
+    "type": "circle",
+    "minzoom": 12,
+    "paint": {
+      "circle-radius": 15,
+      "circle-color": [
+        "case",
+        ["==", ["get", "transformer_rating_va"], 0],
+        "rgb(160,160,160)",
+        ["step", ["get", "capacity_percent"],
+          "rgb(0,180,40)",   30,
+          "rgb(171,221,164)", 60,
+          "rgb(253,174,97)", 80,
+          "rgb(244,109,67)", 90,
+          "rgb(210,2,29)"
+        ]
+      ],
+      "circle-stroke-color": "white",
+      "circle-stroke-width": 1
+    },
+    "filter" : ["==", ["get", "type"], "pt"]
+  },
+  {
+    "id": "pec-capacity-label",
+    "name": "PEC Capacity %",
+    "type": "symbol",
+    "minzoom": 12,
+    "layout": {
+      "text-field": ["get", "capacity_percent_label"],
+      "text-font": ["DIN Offc Pro Medium", "Arial Unicode MS Bold"],
+      "text-size": 12
+    },
+    "paint": {
+      "text-color": "white"
+    },
+    "filter" : ["==", ["get", "type"], "pt"]
+  }
+]
diff --git a/src/zepben/examples/studies/style_pv_percent.json b/src/zepben/examples/studies/style_pv_percent.json
new file mode 100644
index 0000000..ed0d72a
--- /dev/null
+++ b/src/zepben/examples/studies/style_pv_percent.json
@@ -0,0 +1,41 @@
+[
+  {
+    "id": "pv-transformers",
+    "name": "PV % by Transformer",
+    "type": "circle",
+    "minzoom": 12,
+    "paint": {
+      "circle-radius": 15,
+      "circle-color": [
+        "case",
+        ["<", ["get", "ec_count"], 3],
+        "rgb(160,160,160)",
+        ["step", ["get", "pv_percent"],
+          "rgb(0,180,40)",   10,
+          "rgb(171,221,164)", 25,
+          "rgb(253,174,97)", 40,
+          "rgb(244,109,67)", 60,
+          "rgb(210,2,29)"
+        ]
+      ],
+      "circle-stroke-color": "white",
+      "circle-stroke-width": 1
+    },
+    "filter" : ["==", ["get", "type"], "pt"]
+  },
+  {
+    "id": "pv-percent-label",
+    "name": "PV Percentage",
+    "type": "symbol",
+    "minzoom": 12,
+    "layout": {
+      "text-field": ["get", "pv_percent_label"],
+      "text-font": ["DIN Offc Pro Medium", "Arial Unicode MS Bold"],
+      "text-size": 12
+    },
+    "paint": {
+      "text-color": "white"
+    },
+    "filter" : ["==", ["get", "type"], "pt"]
+  }
+]
diff --git a/src/zepben/examples/studies/style_tap_changer.json b/src/zepben/examples/studies/style_tap_changer.json
new file mode 100644
index 0000000..980bc89
--- /dev/null
+++ b/src/zepben/examples/studies/style_tap_changer.json
@@ -0,0 +1,48 @@
+[
+  {
+    "id": "tap-transformers",
+    "name": "Tap Changer Transformers",
+    "type": "circle",
+    "minzoom": 12,
+    "paint": {
+      "circle-radius": 12,
+      "circle-color": "rgb(0,120,255)",
+      "circle-stroke-color": "white",
+      "circle-stroke-width": 1
+    },
+    "filter" : ["==", ["get", "type"], "pt"]
+  },
+  {
+    "id": "tap-step-label",
+    "name": "Tap Step",
+    "type": "symbol",
+    "minzoom": 12,
+    "layout": {
+      "text-field": ["get", "tap_label"],
+      "text-font": ["DIN Offc Pro Medium", "Arial Unicode MS Bold"],
+      "text-size": 11
+    },
+    "paint": {
+      "text-color": "white"
+    },
+    "filter" : ["==", ["get", "type"], "pt"]
+  },
+  {
+    "id": "tap-json-label",
+    "name": "Tap JSON",
+    "type": "symbol",
+    "minzoom": 16,
+    "layout": {
+      "text-field": ["get", "tap_json"],
+      "text-font": ["DIN Offc Pro Medium", "Arial Unicode MS Bold"],
+      "text-size": 10
+    },
+    "paint": {
+      "text-color": "black",
+      "text-halo-blur": 6,
+      "text-halo-width": 6,
+      "text-halo-color": "white"
+    },
+    "filter" : ["==", ["get", "type"], "pt"]
+  }
+]
diff --git a/src/zepben/examples/studies/style_transformer_density.json b/src/zepben/examples/studies/style_transformer_density.json
new file mode 100644
index 0000000..4f28db2
--- /dev/null
+++ b/src/zepben/examples/studies/style_transformer_density.json
@@ -0,0 +1,128 @@
+[
+  {
+    "id": "ec-density-circle",
+    "name": "EC Density (/100m)",
+    "type": "circle",
+    "minzoom": 12,
+    "paint": {
+      "circle-radius": 15,
+      "circle-color": [
+        "case",
+        ["==", ["get", "ec_density"], 0],
+        "rgb(160,160,160)",
+        ["step", ["get", "ec_density"],
+          "rgb(0,180,40)", 0.5,
+          "rgb(171,221,164)", 2,
+          "rgb(253,174,97)", 5,
+          "rgb(244,109,67)", 10,
+          "rgb(210,2,29)"
+        ]
+      ],
+      "circle-stroke-color": "white",
+      "circle-stroke-width": 1
+    },
+    "filter" : ["==", ["get", "type"], "pt"]
+  },
+  {
+    "id": "ec-density-label",
+    "name": "EC Density Label",
+    "type": "symbol",
+    "minzoom": 12,
+    "layout": {
+      "text-field": ["get", "ec_density_label"],
+      "text-font": ["DIN Offc Pro Medium", "Arial Unicode MS Bold"],
+      "text-size": 12
+    },
+    "paint": {
+      "text-color": "black",
+      "text-halo-color": "white",
+      "text-halo-width": 2,
+      "text-halo-blur": 1
+    },
+    "filter" : ["==", ["get", "type"], "pt"]
+  },
+  {
+    "id": "up-density-circle",
+    "name": "Usage Point Density (/100m)",
+    "type": "circle",
+    "minzoom": 12,
+    "paint": {
+      "circle-radius": 15,
+      "circle-color": [
+        "case",
+        ["==", ["get", "up_density"], 0],
+        "rgb(160,160,160)",
+        ["step", ["get", "up_density"],
+          "rgb(0,180,40)", 0.5,
+          "rgb(171,221,164)", 2,
+          "rgb(253,174,97)", 5,
+          "rgb(244,109,67)", 10,
+          "rgb(210,2,29)"
+        ]
+      ],
+      "circle-stroke-color": "white",
+      "circle-stroke-width": 1
+    },
+    "filter" : ["==", ["get", "type"], "pt"]
+  },
+  {
+    "id": "up-density-label",
+    "name": "Usage Point Density Label",
+    "type": "symbol",
+    "minzoom": 12,
+    "layout": {
+      "text-field": ["get", "up_density_label"],
+      "text-font": ["DIN Offc Pro Medium", "Arial Unicode MS Bold"],
+      "text-size": 12
+    },
+    "paint": {
+      "text-color": "black",
+      "text-halo-color": "white",
+      "text-halo-width": 2,
+      "text-halo-blur": 1
+    },
+    "filter" : ["==", ["get", "type"], "pt"]
+  },
+  {
+    "id": "pv-density-circle",
+    "name": "PV Density (/100m)",
+    "type": "circle",
+    "minzoom": 12,
+    "paint": {
+      "circle-radius": 15,
+      "circle-color": [
+        "case",
+        ["==", ["get", "pv_density"], 0],
+        "rgb(160,160,160)",
+        ["step", ["get", "pv_density"],
+          "rgb(0,180,40)", 0.1,
+          "rgb(171,221,164)", 0.5,
+          "rgb(253,174,97)", 1,
+          "rgb(244,109,67)", 2,
+          "rgb(210,2,29)"
+        ]
+      ],
+      "circle-stroke-color": "white",
+      "circle-stroke-width": 1
+    },
+    "filter" : ["==", ["get", "type"], "pt"]
+  },
+  {
+    "id": "pv-density-label",
+    "name": "PV Density Label",
+    "type": "symbol",
+    "minzoom": 12,
+    "layout": {
+      "text-field": ["get", "pv_density_label"],
+      "text-font": ["DIN Offc Pro Medium", "Arial Unicode MS Bold"],
+      "text-size": 12
+    },
+    "paint": {
+      "text-color": "black",
+      "text-halo-color": "white",
+      "text-halo-width": 2,
+      "text-halo-blur": 1
+    },
+    "filter" : ["==", ["get", "type"], "pt"]
+  }
+]
diff --git a/src/zepben/examples/studies/style_transformer_utilisation.json b/src/zepben/examples/studies/style_transformer_utilisation.json
new file mode 100644
index 0000000..88e5fd0
--- /dev/null
+++ b/src/zepben/examples/studies/style_transformer_utilisation.json
@@ -0,0 +1,292 @@
+[
+  {
+    "id": "max-demand-utilisation",
+    "name": "Max Demand Utilisation (Import)",
+    "type": "circle",
+    "minzoom": 12,
+    "paint": {
+      "circle-radius": 18,
+      "circle-color": [
+        "case",
+        ["any",
+          ["==", ["get", "transformer_rating_va"], 0],
+          ["==", ["get", "has_max_profile"], false]
+        ],
+        "rgb(160,160,160)",
+        ["step", ["get", "max_import_util_percent"],
+          "rgb(0,180,40)",   30,
+          "rgb(171,221,164)", 60,
+          "rgb(253,174,97)", 80,
+          "rgb(244,109,67)", 90,
+          "rgb(210,2,29)"
+        ]
+      ],
+      "circle-stroke-color": "white",
+      "circle-stroke-width": 1
+    },
+    "metadata": {
+      "zb:legend": {
+        "label": "Max Demand Utilisation (Import)"
+      }
+    },
+    "filter" : ["==", ["get", "type"], "pt"]
+  },
+  {
+    "id": "max-demand-season-shape",
+    "name": "Max Demand Season Shape",
+    "type": "symbol",
+    "minzoom": 12,
+    "layout": {
+      "text-field": [
+        "case",
+        ["any",
+          ["==", ["get", "transformer_rating_va"], 0],
+          ["==", ["get", "has_max_profile"], false]
+        ],
+        "",
+        ["match", ["get", "max_demand_season"],
+          "Summer", "▲",
+          "Autumn", "◆",
+          "Winter", "■",
+          "Spring", "●",
+          ""
+        ]
+      ],
+      "text-font": ["Arial Unicode MS Regular"],
+      "text-size": [
+        "match", ["get", "max_demand_season"],
+        "Winter", 76.5,
+        102
+      ],
+      "text-offset": [0, 0],
+      "text-allow-overlap": true,
+      "text-ignore-placement": true
+    },
+    "paint": {
+      "text-color": [
+        "case",
+        ["any",
+          ["==", ["get", "transformer_rating_va"], 0],
+          ["==", ["get", "has_max_profile"], false]
+        ],
+        "rgb(160,160,160)",
+        ["step", ["get", "max_import_util_percent"],
+          "rgb(0,180,40)",   30,
+          "rgb(171,221,164)", 60,
+          "rgb(253,174,97)", 80,
+          "rgb(244,109,67)", 90,
+          "rgb(210,2,29)"
+        ]
+      ],
+      "text-halo-color": "white",
+      "text-halo-width": 1.5,
+      "text-halo-blur": 1
+    },
+    "metadata": {
+      "zb:legend": {
+        "label": "Max Demand Season",
+        "states": [
+          {
+            "label": "▲ Summer",
+            "properties": {
+              "max_demand_season": "Summer"
+            }
+          },
+          {
+            "label": "◆ Autumn",
+            "properties": {
+              "max_demand_season": "Autumn"
+            }
+          },
+          {
+            "label": "■ Winter",
+            "properties": {
+              "max_demand_season": "Winter"
+            }
+          },
+          {
+            "label": "● Spring",
+            "properties": {
+              "max_demand_season": "Spring"
+            }
+          }
+        ]
+      }
+    },
+    "filter" : ["==", ["get", "type"], "pt"]
+  },
+  {
+    "id": "max-demand-label",
+    "name": "Max Demand Utilisation Label",
+    "type": "symbol",
+    "minzoom": 12,
+    "layout": {
+      "text-field": [
+        "case",
+        ["any",
+          ["==", ["get", "transformer_rating_va"], 0],
+          ["==", ["get", "has_max_profile"], false]
+        ],
+        "",
+        ["concat", ["round", ["get", "max_import_util_percent"]], "%"]
+      ],
+      "text-font": ["Arial Unicode MS Regular"],
+      "text-size": 12,
+      "text-offset": [0, 0],
+      "text-allow-overlap": true,
+      "text-ignore-placement": true
+    },
+    "paint": {
+      "text-color": "black",
+      "text-halo-blur": 2,
+      "text-halo-width": 2,
+      "text-halo-color": "white"
+    },
+    "filter" : ["==", ["get", "type"], "pt"]
+  },
+  {
+    "id": "min-demand-utilisation",
+    "name": "Min Demand Utilisation (Export)",
+    "type": "circle",
+    "minzoom": 12,
+    "paint": {
+      "circle-radius": 18,
+      "circle-color": [
+        "case",
+        ["any",
+          ["==", ["get", "transformer_rating_va"], 0],
+          ["==", ["get", "has_min_profile"], false]
+        ],
+        "rgb(160,160,160)",
+        ["step", ["get", "min_export_util_percent"],
+          "rgb(0,180,40)",   30,
+          "rgb(171,221,164)", 60,
+          "rgb(253,174,97)", 80,
+          "rgb(244,109,67)", 90,
+          "rgb(210,2,29)"
+        ]
+      ],
+      "circle-stroke-color": "white",
+      "circle-stroke-width": 1
+    },
+    "metadata": {
+      "zb:legend": {
+        "label": "Min Demand Utilisation (Export)"
+      }
+    },
+    "filter" : ["==", ["get", "type"], "pt"]
+  },
+  {
+    "id": "min-demand-season-shape",
+    "name": "Min Demand Season Shape",
+    "type": "symbol",
+    "minzoom": 12,
+    "layout": {
+      "text-field": [
+        "case",
+        ["any",
+          ["==", ["get", "transformer_rating_va"], 0],
+          ["==", ["get", "has_min_profile"], false]
+        ],
+        "",
+        ["match", ["get", "min_demand_season"],
+          "Summer", "▲",
+          "Autumn", "◆",
+          "Winter", "■",
+          "Spring", "●",
+          ""
+        ]
+      ],
+      "text-font": ["Arial Unicode MS Regular"],
+      "text-size": [
+        "match", ["get", "min_demand_season"],
+        "Winter", 76.5,
+        102
+      ],
+      "text-offset": [0, 0],
+      "text-allow-overlap": true,
+      "text-ignore-placement": true
+    },
+    "paint": {
+      "text-color": [
+        "case",
+        ["any",
+          ["==", ["get", "transformer_rating_va"], 0],
+          ["==", ["get", "has_min_profile"], false]
+        ],
+        "rgb(160,160,160)",
+        ["step", ["get", "min_export_util_percent"],
+          "rgb(0,180,40)",   30,
+          "rgb(171,221,164)", 60,
+          "rgb(253,174,97)", 80,
+          "rgb(244,109,67)", 90,
+          "rgb(210,2,29)"
+        ]
+      ],
+      "text-halo-color": "white",
+      "text-halo-width": 1.5,
+      "text-halo-blur": 1
+    },
+    "metadata": {
+      "zb:legend": {
+        "label": "Min Demand Season",
+        "states": [
+          {
+            "label": "▲ Summer",
+            "properties": {
+              "min_demand_season": "Summer"
+            }
+          },
+          {
+            "label": "◆ Autumn",
+            "properties": {
+              "min_demand_season": "Autumn"
+            }
+          },
+          {
+            "label": "■ Winter",
+            "properties": {
+              "min_demand_season": "Winter"
+            }
+          },
+          {
+            "label": "● Spring",
+            "properties": {
+              "min_demand_season": "Spring"
+            }
+          }
+        ]
+      }
+    },
+    "filter" : ["==", ["get", "type"], "pt"]
+  },
+  {
+    "id": "min-demand-label",
+    "name": "Min Demand Utilisation Label",
+    "type": "symbol",
+    "minzoom": 12,
+    "layout": {
+      "text-field": [
+        "case",
+        ["any",
+          ["==", ["get", "transformer_rating_va"], 0],
+          ["==", ["get", "has_min_profile"], false]
+        ],
+        "",
+        ["concat", ["round", ["get", "min_export_util_percent"]], "%"]
+      ],
+      "text-font": ["Arial Unicode MS Regular"],
+      "text-size": 12,
+      "text-offset": [0, 0],
+      "text-allow-overlap": true,
+      "text-ignore-placement": true
+    },
+    "paint": {
+      "text-color": "black",
+      "text-halo-blur": 2,
+      "text-halo-width": 2,
+      "text-halo-color": "white"
+    },
+    "filter" : ["==", ["get", "type"], "pt"]
+  }
+]
diff --git a/src/zepben/examples/studies/suspect_end_of_line.py b/src/zepben/examples/studies/suspect_end_of_line.py
index 5bf2671..3e147bd 100644
--- a/src/zepben/examples/studies/suspect_end_of_line.py
+++ b/src/zepben/examples/studies/suspect_end_of_line.py
@@ -13,7 +13,7 @@
 from geojson import FeatureCollection, Feature
 from geojson.geometry import Geometry, LineString, Point
 from zepben.eas import EasClient, Study, Result, GeoJsonOverlay
-from zepben.ewb import PowerTransformer, ConductingEquipment, EnergyConsumer, AcLineSegment, \
+from zepben.ewb import PowerTransformer, ConductingEquipment, EnergyConsumer, AcLineSegment, Switch, \
     NetworkConsumerClient, PhaseCode, PowerElectronicsConnection, Feeder, PowerSystemResource, Location, \
     connect_with_token, NetworkTraceStep, Tracing, downstream, upstream, IncludedEnergizedContainers
 
@@ -29,10 +29,18 @@ def chunk(it, size):
 
 async def main():
     # Only process feeders in the following zones
-    zone_mrids = ["MTN"]
+    zone_mrids = ["CPM"]
     print(f"Start time: {datetime.now()}")
 
-    rpc_channel = connect_with_token(host=c["host"], access_token=c["access_token"], rpc_port=c["rpc_port"])
+    rpc_channel = connect_with_token(
+        host=c["host"],
+        access_token=c["access_token"],
+        rpc_port=c["rpc_port"],
+        ca_filename=c.get("ca_filename"),
+        timeout_seconds=c.get("timeout_seconds", 5),
+        debug=bool(c.get("debug", False)),
+        skip_connection_test=bool(c.get("skip_connection_test", False)),
+    )
     client = NetworkConsumerClient(rpc_channel)
     hierarchy = (await client.get_network_hierarchy()).throw_on_error()
     substations = hierarchy.value.substations
@@ -46,38 +54,60 @@ async def main():
                 feeder_mrids.append(feeder.mrid)
 
     print(f"Feeders to be processed: {', '.join(feeder_mrids)}")
-    futures = []
 
     # Process the feeders in batches of 3, using asyncio, for performance
     batches = chunk(feeder_mrids, 3)
     for feeders in batches:
-        all_traced_equipment = []
-        transformer_to_suspect_end = dict()
-
-        rpc_channel = connect_with_token(host=c["host"], access_token=c["access_token"], rpc_port=c["rpc_port"])
+        feeder_results = []
+        futures = []
+
+        rpc_channel = connect_with_token(
+            host=c["host"],
+            access_token=c["access_token"],
+            rpc_port=c["rpc_port"],
+            ca_filename=c.get("ca_filename"),
+            timeout_seconds=c.get("timeout_seconds", 5),
+            debug=bool(c.get("debug", False)),
+            skip_connection_test=bool(c.get("skip_connection_test", False)),
+        )
         print(f"Processing feeders {', '.join(feeders)}")
         for feeder_mrid in feeders:
             futures.append(asyncio.ensure_future(fetch_feeder_and_trace(feeder_mrid, rpc_channel)))
 
         for future in futures:
-            tx_to_sus_end = await future
-            if tx_to_sus_end:   # Empty if the feeder failed
-                all_traced_equipment.extend(eq for (k, (count, sus_eq_list)) in tx_to_sus_end.items() for eq in sus_eq_list)
-                transformer_to_suspect_end.update(tx_to_sus_end)
+            result = await future
+            if not result:   # Empty if the feeder failed
+                continue
+            feeder_mrid, transformers, tx_to_sus_lines, feeder_suspect_lines = result
+            total_length_m = sum(_line_length_m(line) for line in feeder_suspect_lines)
+            highlight_equipment = set(transformers) | set(feeder_suspect_lines)
+            feeder_results.append(
+                (feeder_mrid, total_length_m, list(highlight_equipment), tx_to_sus_lines)
+            )
 
         print(f"Created Study for {len(feeder_mrids)} feeders")
 
         eas_client = EasClient(host=c["host"], port=c["rpc_port"], protocol="https", access_token=c["access_token"])
 
         print(f"Uploading Study for {', '.join(feeders)} ...")
+        styles = json.load(open("style_eol.json", "r"))
+        results = [
+            _build_suspect_end_result(
+                feeder_mrid,
+                total_length_m,
+                equipment,
+                transformer_to_suspect_lines,
+                styles=styles,
+            )
+            for feeder_mrid, total_length_m, equipment, transformer_to_suspect_lines in feeder_results
+        ]
         await upload_suspect_end_of_line_study(
             eas_client,
-            all_traced_equipment,
-            transformer_to_suspect_end,
-            name=f"Suspect end of line {', '.join(feeders)}",
-            description="Highlights every line that is downstream of transformer and ends without a consumer.",
+            results,
+            name=f"Suspect end of line ({', '.join(feeders)})",
+            description="Highlights only line segments that have no downstream EnergyConsumers (excludes shared upstream segments).",
             tags=["suspect_end_of_line", "-".join(zone_mrids)],
-            styles=json.load(open("style_eol.json", "r"))
+            styles=styles
         )
         await eas_client.aclose()
         print(f"Uploaded Study")
@@ -85,24 +115,62 @@ async def main():
     print(f"Finish time: {datetime.now()}")
 
 
-def collect_eq_provider(collection: Set[ConductingEquipment]):
+def collect_downstream_edges_provider(
+    adjacency: Dict[ConductingEquipment, Set[ConductingEquipment]],
+    nodes: Set[ConductingEquipment],
+):
 
-    async def collect_equipment(ps: NetworkTraceStep, _):
-        collection.add(ps.path.to_equipment)
+    async def collect_edges(ps: NetworkTraceStep, _):
+        nodes.add(ps.path.from_equipment)
+        nodes.add(ps.path.to_equipment)
+        if ps.path.traced_externally:
+            adjacency.setdefault(ps.path.from_equipment, set()).add(ps.path.to_equipment)
 
-    return collect_equipment
+    return collect_edges
 
 
-async def get_downstream_eq(ce: ConductingEquipment) -> Set[ConductingEquipment]:
-    equipment_set = set()
+async def build_downstream_graph(
+    start: ConductingEquipment,
+) -> Tuple[Dict[ConductingEquipment, Set[ConductingEquipment]], Set[ConductingEquipment]]:
+    adjacency: Dict[ConductingEquipment, Set[ConductingEquipment]] = {}
+    nodes: Set[ConductingEquipment] = {start}
 
     await (
         Tracing.network_trace()
         .add_condition(downstream())
-        .add_step_action(collect_eq_provider(equipment_set))
-    ).run(start=ce, phases=PhaseCode.ABCN, can_stop_on_start_item=False)
+        .add_step_action(collect_downstream_edges_provider(adjacency, nodes))
+    ).run(start=start, phases=PhaseCode.ABCN, can_stop_on_start_item=False)
+
+    for node in nodes:
+        adjacency.setdefault(node, set())
+
+    return adjacency, nodes
 
-    return equipment_set
+
+def build_has_consumer_downstream(
+    adjacency: Dict[ConductingEquipment, Set[ConductingEquipment]],
+    backfeed_switches: Set[ConductingEquipment],
+):
+    memo: Dict[ConductingEquipment, bool] = {}
+    visiting: Set[ConductingEquipment] = set()
+
+    def has_consumer(node: ConductingEquipment) -> bool:
+        if node in memo:
+            return memo[node]
+        if node in visiting:
+            return False
+        visiting.add(node)
+        result = isinstance(node, EnergyConsumer) or node in backfeed_switches
+        if not result:
+            for child in adjacency.get(node, ()):
+                if has_consumer(child):
+                    result = True
+                    break
+        visiting.remove(node)
+        memo[node] = result
+        return result
+
+    return has_consumer
 
 
 async def fetch_feeder_and_trace(feeder_mrid: str, rpc_channel):
@@ -118,111 +186,141 @@ async def fetch_feeder_and_trace(feeder_mrid: str, rpc_channel):
     )
     if result.was_failure:
         print(f"Failed: {result.thrown}")
-        return {}
+        return None
 
     network = client.service
 
     print(f"Finished fetching Feeder {feeder_mrid}")
-    print(f"Tracing downstream transformers for feeder {feeder_mrid}")
-    transformer_to_eq: Dict[str, Set[ConductingEquipment]] = {}
+    print(f"Tracing suspect lines for feeder {feeder_mrid}")
+    transformers: List[PowerTransformer] = []
+    transformer_to_suspect_lines: Dict[str, Tuple[float, List[ConductingEquipment]]] = {}
+    feeder_suspect_lines: Set[AcLineSegment] = set()
     for io in (pt for pt in network.objects(PowerTransformer)):
         pt: PowerTransformer = io
-        downstream_equipment = await get_downstream_eq(pt)
-        transformer_to_eq[pt.mrid] = downstream_equipment
-
-    print(f"Tracing suspect ends for feeder {feeder_mrid}")
-    transformer_to_suspect_end = await get_transformer_to_suspect_end(transformer_to_eq)
-
-    return transformer_to_suspect_end
-
-
-async def get_transformer_to_suspect_end(
-    transformer_to_eq: Dict[str, Set[ConductingEquipment]]
-) -> Dict[str, Tuple[int, Set[ConductingEquipment]]]:
-
-    transformer_to_suspect_end: Dict[str, (int, List[ConductingEquipment])] = {}
-    for pt_mrid, eq_list in transformer_to_eq.items():
-        single_terminal_junctions = [
-            eq for eq in eq_list
-            if not isinstance(eq, (EnergyConsumer, PowerElectronicsConnection))
-               and len(list(eq.terminals)) == 1
-        ]
-        upstream_eq = set(
-            await _get_upstream_eq_up_to_transformer(stj) for stj in single_terminal_junctions
-        )
-
-        transformer_to_suspect_end[pt_mrid] = (len(single_terminal_junctions), list(upstream_eq))
-
-    return transformer_to_suspect_end
+        transformers.append(pt)
+        suspect_lines = await get_suspect_lines_for_transformer(pt)
+        feeder_suspect_lines.update(suspect_lines)
+        total_length_m = sum(_line_length_m(line) for line in suspect_lines)
+        transformer_to_suspect_lines[pt.mrid] = (total_length_m, list(suspect_lines))
+
+    return feeder_mrid, transformers, transformer_to_suspect_lines, feeder_suspect_lines
+
+
+def _switch_has_external_network(
+    switch: Switch,
+    nodes: Set[ConductingEquipment],
+) -> bool:
+    for terminal in switch.terminals:
+        cn = terminal.connectivity_node
+        if cn is None:
+            continue
+        for term in cn.terminals:
+            ce = term.conducting_equipment
+            if ce is None or ce is switch:
+                continue
+            if ce not in nodes:
+                return True
+    return False
+
+
+def _find_backfeed_switches(
+    nodes: Set[ConductingEquipment],
+) -> Set[ConductingEquipment]:
+    backfeed = set()
+    for node in nodes:
+        if isinstance(node, Switch) and _switch_has_external_network(node, nodes):
+            backfeed.add(node)
+    return backfeed
+
+
+async def get_suspect_lines_for_transformer(
+    transformer: PowerTransformer,
+) -> Set[AcLineSegment]:
+    adjacency, nodes = await build_downstream_graph(transformer)
+    backfeed_switches = _find_backfeed_switches(nodes)
+    has_consumer = build_has_consumer_downstream(adjacency, backfeed_switches)
+
+    suspect_lines = {
+        node for node in nodes
+        if isinstance(node, AcLineSegment) and not has_consumer(node)
+    }
+    return suspect_lines
 
 
-async def upload_suspect_end_of_line_study(
-    eas_client: EasClient,
-    pts: List[PowerTransformer],
-    transformer_to_suspect_end: Dict[str, Tuple[int, List[ConductingEquipment]]],
-    name: str,
-    description: str,
-    tags: List[str],
+def _build_suspect_end_result(
+    feeder_mrid: str,
+    total_length_m: float,
+    pts: List[ConductingEquipment],
+    transformer_to_suspect_lines: Dict[str, Tuple[float, List[ConductingEquipment]]],
     styles: List
-) -> None:
-
+) -> Result:
     class_to_properties = {
         EnergyConsumer: {
             "name": lambda ec: ec.name,
             "type": lambda x: "ec"
         },
         PowerTransformer: {
-            "consumer_count": _suspect_end_count_from(transformer_to_suspect_end),
+            "suspect_length_m": _suspect_length_m_from(transformer_to_suspect_lines),
+            "suspect_length_label": _suspect_length_label_from(transformer_to_suspect_lines),
             "type": lambda x: "pt"
         },
-        AcLineSegment: {"name": lambda ec: ec.name},
+        AcLineSegment: {
+            "name": lambda ec: ec.name,
+            "length_m": lambda line: _line_length_m(line),
+        },
     }
     feature_collection = to_geojson_feature_collection(pts, class_to_properties)
+    result_name = f"{feeder_mrid} - {round(total_length_m)}m"
+    return Result(
+        name=result_name,
+        geo_json_overlay=GeoJsonOverlay(
+            data=feature_collection,
+            styles=[s['id'] for s in styles]
+        )
+    )
+
+
+async def upload_suspect_end_of_line_study(
+    eas_client: EasClient,
+    results: List[Result],
+    name: str,
+    description: str,
+    tags: List[str],
+    styles: List
+) -> None:
     response = await eas_client.async_upload_study(
         Study(
             name=name,
             description=description,
             tags=tags,
-            results=[
-                Result(
-                    name=name,
-                    geo_json_overlay=GeoJsonOverlay(
-                        data=feature_collection,
-                        styles=[s['id'] for s in styles]
-                    )
-                )
-            ],
+            results=results,
             styles=styles
         )
     )
     print(f"Study response: {response}")
 
 
-async def _get_upstream_eq_up_to_transformer(ce: ConductingEquipment) -> Set[ConductingEquipment]:
-    eqs = set()
-
-    await (
-        Tracing.network_trace()
-        .add_condition(upstream())
-        .add_step_action(collect_eq_provider(eqs))
-        .add_stop_condition(_is_transformer)
-    ).run(start=ce, phases=PhaseCode.ABCN, can_stop_on_start_item=False)
-
-    return eqs
-
+def _suspect_length_m_from(pt_to_sus_end: Dict[str, Tuple[float, List[ConductingEquipment]]]):
+    def fun(pt: PowerTransformer):
+        value = pt_to_sus_end.get(pt.mrid)
+        return round(value[0]) if value else 0
 
-async def _is_transformer(ps: NetworkTraceStep):
-    return isinstance(ps.path.to_equipment, PowerTransformer)
+    return fun
 
 
-def _suspect_end_count_from(pt_to_sus_end: Dict[str, Tuple[int, List[ConductingEquipment]]]):
+def _suspect_length_label_from(pt_to_sus_end: Dict[str, Tuple[float, List[ConductingEquipment]]]):
     def fun(pt: PowerTransformer):
-        count, suspect_eq = pt_to_sus_end.get(pt.mrid)
-        return count if count else 0
+        value = pt_to_sus_end.get(pt.mrid)
+        meters = round(value[0]) if value else 0
+        return f"{meters}m"
 
     return fun
 
 
+def _line_length_m(line: AcLineSegment) -> float:
+    return float(line.length or 0.0)
+
+
 def to_geojson_feature_collection(
     psrs: List[PowerSystemResource],
     class_to_properties: Dict[Type, Dict[str, Callable[[Any], Any]]]
@@ -262,5 +360,4 @@ def to_geojson_geometry(location: Location) -> Union[Geometry, None]:
 
 
 if __name__ == "__main__":
-    loop = asyncio.get_event_loop()
-    loop.run_until_complete(main())
+    asyncio.run(main())
diff --git a/src/zepben/examples/studies/suspect_end_of_line_all_feeders.py b/src/zepben/examples/studies/suspect_end_of_line_all_feeders.py
new file mode 100644
index 0000000..7716ca4
--- /dev/null
+++ b/src/zepben/examples/studies/suspect_end_of_line_all_feeders.py
@@ -0,0 +1,121 @@
+#  Copyright 2025 Zeppelin Bend Pty Ltd
+#
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+import asyncio
+import json
+from datetime import datetime
+from itertools import islice
+from typing import List
+
+from zepben.eas.client.eas_client import EasClient
+from zepben.ewb import NetworkConsumerClient, connect_with_token
+
+from suspect_end_of_line import (
+    fetch_feeder_and_trace,
+    upload_suspect_end_of_line_study,
+    _build_suspect_end_result,
+    _line_length_m,
+)
+
+
+with open("../config.json") as f:
+    c = json.loads(f.read())
+
+
+def chunk(it, size):
+    it = iter(it)
+    return iter(lambda: tuple(islice(it, size)), ())
+
+
+async def main():
+    # Only process feeders in the following zones
+    zone_mrids = ["CPM"]
+    print(f"Start time: {datetime.now()}")
+
+    rpc_channel = connect_with_token(
+        host=c["host"],
+        access_token=c["access_token"],
+        rpc_port=c["rpc_port"],
+        ca_filename=c.get("ca_filename"),
+        timeout_seconds=c.get("timeout_seconds", 5),
+        debug=bool(c.get("debug", False)),
+        skip_connection_test=bool(c.get("skip_connection_test", False)),
+    )
+    client = NetworkConsumerClient(rpc_channel)
+    hierarchy = (await client.get_network_hierarchy()).throw_on_error()
+    substations = hierarchy.value.substations
+
+    print(f"Collecting feeders from zones {', '.join(zone_mrids)}.")
+    feeder_mrids = []
+    for zone_mrid in zone_mrids:
+        if zone_mrid in substations:
+            for feeder in substations[zone_mrid].feeders:
+                feeder_mrids.append(feeder.mrid)
+
+    print(f"Feeders to be processed: {', '.join(feeder_mrids)}")
+
+    feeder_results = []
+
+    # Process the feeders in batches of 3, using asyncio, for performance
+    batches = chunk(feeder_mrids, 3)
+    for feeders in batches:
+        futures = []
+        rpc_channel = connect_with_token(
+            host=c["host"],
+            access_token=c["access_token"],
+            rpc_port=c["rpc_port"],
+            ca_filename=c.get("ca_filename"),
+            timeout_seconds=c.get("timeout_seconds", 5),
+            debug=bool(c.get("debug", False)),
+            skip_connection_test=bool(c.get("skip_connection_test", False)),
+        )
+        print(f"Processing feeders {', '.join(feeders)}")
+        for feeder_mrid in feeders:
+            futures.append(asyncio.ensure_future(fetch_feeder_and_trace(feeder_mrid, rpc_channel)))
+
+        for future in futures:
+            result = await future
+            if not result:   # Empty if the feeder failed
+                continue
+            feeder_mrid, transformers, tx_to_sus_lines, feeder_suspect_lines = result
+            total_length_m = sum(_line_length_m(line) for line in feeder_suspect_lines)
+            highlight_equipment = set(transformers) | set(feeder_suspect_lines)
+            feeder_results.append(
+                (feeder_mrid, total_length_m, list(highlight_equipment), tx_to_sus_lines)
+            )
+
+    print(f"Created Study for {len(feeder_mrids)} feeders")
+
+    eas_client = EasClient(host=c["host"], port=c["rpc_port"], protocol="https", access_token=c["access_token"])
+
+    print(f"Uploading Study for zones {', '.join(zone_mrids)} ...")
+    styles = json.load(open("style_eol.json", "r"))
+    results = [
+        _build_suspect_end_result(
+            feeder_mrid,
+            total_length_m,
+            equipment,
+            transformer_to_suspect_lines,
+            styles=styles,
+        )
+        for feeder_mrid, total_length_m, equipment, transformer_to_suspect_lines in feeder_results
+    ]
+    await upload_suspect_end_of_line_study(
+        eas_client,
+        results,
+        name=f"Suspect end of line ({', '.join(zone_mrids)})",
+        description="Highlights only line segments that have no downstream EnergyConsumers (excludes shared upstream segments).",
+        tags=["suspect_end_of_line", "-".join(zone_mrids)],
+        styles=styles,
+    )
+    await eas_client.aclose()
+    print("Uploaded Study")
+
+    print(f"Finish time: {datetime.now()}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/src/zepben/examples/studies/tap_changer_info_by_transformer.py b/src/zepben/examples/studies/tap_changer_info_by_transformer.py
new file mode 100644
index 0000000..e8d8cd9
--- /dev/null
+++ b/src/zepben/examples/studies/tap_changer_info_by_transformer.py
@@ -0,0 +1,325 @@
+#  Copyright 2025 Zeppelin Bend Pty Ltd
+#
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+import asyncio
+import json
+from datetime import datetime
+from itertools import islice
+from typing import List, Dict, Tuple, Callable, Any, Union, Type
+
+from geojson import FeatureCollection, Feature
+from geojson.geometry import Geometry, LineString, Point
+from zepben.eas.client.eas_client import EasClient
+from zepben.eas.client.study import Study, Result, GeoJsonOverlay
+from zepben.ewb import (
+    PowerTransformer,
+    RatioTapChanger,
+    NetworkConsumerClient,
+    Feeder,
+    PowerSystemResource,
+    Location,
+    connect_with_token,
+)
+
+
+with open("../config.json") as f:
+    c = json.loads(f.read())
+
+
+def chunk(it, size):
+    it = iter(it)
+    return iter(lambda: tuple(islice(it, size)), ())
+
+
+async def main():
+    # Only process feeders in the following zones
+    zone_mrids = ["CPM"]
+    print(f"Start time: {datetime.now()}")
+
+    rpc_channel = connect_with_token(
+        host=c["host"],
+        access_token=c["access_token"],
+        rpc_port=c["rpc_port"],
+        ca_filename=c.get("ca_filename"),
+        timeout_seconds=c.get("timeout_seconds", 5),
+        debug=bool(c.get("debug", False)),
+        skip_connection_test=bool(c.get("skip_connection_test", False)),
+    )
+    client = NetworkConsumerClient(rpc_channel)
+    hierarchy = (await client.get_network_hierarchy()).throw_on_error()
+    substations = hierarchy.value.substations
+
+    print(f"Collecting feeders from zones {', '.join(zone_mrids)}.")
+    feeder_mrids = []
+    for zone_mrid in zone_mrids:
+        if zone_mrid in substations:
+            for feeder in substations[zone_mrid].feeders:
+                feeder_mrids.append(feeder.mrid)
+
+    print(f"Feeders to be processed: {', '.join(feeder_mrids)}")
+
+    all_transformers: List[PowerTransformer] = []
+    transformer_to_tap: Dict[str, Dict[str, Any]] = {}
+
+    batches = chunk(feeder_mrids, 3)
+    for feeders in batches:
+        futures = []
+        rpc_channel = connect_with_token(
+            host=c["host"],
+            access_token=c["access_token"],
+            rpc_port=c["rpc_port"],
+            ca_filename=c.get("ca_filename"),
+            timeout_seconds=c.get("timeout_seconds", 5),
+            debug=bool(c.get("debug", False)),
+            skip_connection_test=bool(c.get("skip_connection_test", False)),
+        )
+        print(f"Processing feeders {', '.join(feeders)}")
+        for feeder_mrid in feeders:
+            futures.append(asyncio.ensure_future(fetch_tap_info_for_feeder(feeder_mrid, rpc_channel)))
+
+        for future in futures:
+            transformers, tap_info = await future
+            if transformers:
+                all_transformers.extend(transformers)
+                transformer_to_tap.update(tap_info)
+
+    print(f"Creating study for {len(all_transformers)} transformers")
+
+    eas_client = EasClient(host=c["host"], port=c["rpc_port"], protocol="https", access_token=c["access_token"])
+    print(f"Uploading Study for zones {', '.join(zone_mrids)} ...")
+    await upload_tap_changer_study(
+        eas_client,
+        all_transformers,
+        transformer_to_tap,
+        name=f"Tap changer info ({', '.join(zone_mrids)})",
+        description="Tap changer info shown as JSON at transformers; step or normal_step shown as label.",
+        tags=["tap_changer", "-".join(zone_mrids)],
+        styles=json.load(open("style_tap_changer.json", "r")),
+    )
+    await eas_client.aclose()
+    print("Uploaded Study")
+
+    print(f"Finish time: {datetime.now()}")
+
+
+async def fetch_tap_info_for_feeder(
+    feeder_mrid: str,
+    rpc_channel,
+) -> Tuple[List[PowerTransformer], Dict[str, Dict[str, Any]]]:
+    print(f"Fetching Feeder {feeder_mrid}")
+    client = NetworkConsumerClient(rpc_channel)
+
+    result = (
+        await client.get_equipment_container(
+            mrid=feeder_mrid,
+            expected_class=Feeder,
+            include_energized_containers=None,
+        )
+    )
+    if result.was_failure:
+        print(f"Failed: {result.thrown}")
+        return [], {}
+
+    network = client.service
+    print(f"Finished fetching Feeder {feeder_mrid}")
+
+    transformers: List[PowerTransformer] = []
+    transformer_to_tap: Dict[str, Dict[str, Any]] = {}
+    tap_changers_by_transformer = _collect_tap_changers_by_transformer(network)
+
+    for io in (pt for pt in network.objects(PowerTransformer)):
+        pt: PowerTransformer = io
+        tap_info = _tap_info_from_transformer(pt, tap_changers_by_transformer.get(pt.mrid, []))
+        if tap_info is None:
+            continue
+        transformers.append(pt)
+        transformer_to_tap[pt.mrid] = tap_info
+
+    return transformers, transformer_to_tap
+
+
+def _collect_tap_changers_by_transformer(network) -> Dict[str, List[RatioTapChanger]]:
+    mapping: Dict[str, List[RatioTapChanger]] = {}
+    for tc in network.objects(RatioTapChanger):
+        end = tc.transformer_end
+        if end is None or end.power_transformer is None:
+            continue
+        pt_mrid = end.power_transformer.mrid
+        mapping.setdefault(pt_mrid, []).append(tc)
+    return mapping
+
+
+def _tap_info_from_transformer(
+    pt: PowerTransformer,
+    extra_tap_changers: List[RatioTapChanger],
+) -> Union[Dict[str, Any], None]:
+    tap_changers: List[RatioTapChanger] = []
+    for end in pt.ends:
+        if end.ratio_tap_changer is not None:
+            tap_changers.append(end.ratio_tap_changer)
+
+    tap_changers.extend(extra_tap_changers)
+    if tap_changers:
+        # De-duplicate by mRID
+        unique = {}
+        for tc in tap_changers:
+            unique[tc.mrid] = tc
+        tap_changers = list(unique.values())
+
+    if not tap_changers:
+        return None
+
+    # Prefer a tap changer with an explicit step; fallback to any with normal_step
+    preferred = None
+    for tc in tap_changers:
+        if tc.step is not None:
+            preferred = tc
+            break
+    if preferred is None:
+        for tc in tap_changers:
+            if tc.normal_step is not None:
+                preferred = tc
+                break
+    if preferred is None:
+        preferred = tap_changers[0]
+
+    step_value = preferred.step if preferred.step is not None else preferred.normal_step
+    tap_label = f"{step_value}" if step_value is not None else "n/a"
+
+    tap_json = {
+        "step": preferred.step,
+        "normal_step": preferred.normal_step,
+        "neutral_step": preferred.neutral_step,
+        "low_step": preferred.low_step,
+        "high_step": preferred.high_step,
+        "control_enabled": preferred.control_enabled,
+    }
+
+    return {
+        "tap_label": tap_label,
+        "tap_json": json.dumps(tap_json, separators=(",", ":")),
+        "tap_step": step_value if step_value is not None else 0,
+        "tap_count": len(tap_changers),
+    }
+
+
+async def upload_tap_changer_study(
+    eas_client: EasClient,
+    pts: List[PowerTransformer],
+    transformer_to_tap: Dict[str, Dict[str, Any]],
+    name: str,
+    description: str,
+    tags: List[str],
+    styles: List,
+) -> None:
+
+    class_to_properties = {
+        PowerTransformer: {
+            "tap_label": _tap_label_from(transformer_to_tap),
+            "tap_json": _tap_json_from(transformer_to_tap),
+            "tap_step": _tap_step_from(transformer_to_tap),
+            "tap_count": _tap_count_from(transformer_to_tap),
+            "type": lambda x: "pt",
+        },
+    }
+    feature_collection = to_geojson_feature_collection(pts, class_to_properties)
+    if not feature_collection.features:
+        print("No transformer features to display (missing locations or tap changers). Study upload skipped.")
+        return
+    response = await eas_client.async_upload_study(
+        Study(
+            name=name,
+            description=description,
+            tags=tags,
+            results=[
+                Result(
+                    name=name,
+                    geo_json_overlay=GeoJsonOverlay(
+                        data=feature_collection,
+                        styles=[s['id'] for s in styles]
+                    )
+                )
+            ],
+            styles=styles
+        )
+    )
+    print(f"Study response: {response}")
+
+
+def _tap_label_from(pt_to_tap: Dict[str, Dict[str, Any]]):
+    def fun(pt: PowerTransformer):
+        info = pt_to_tap.get(pt.mrid, {})
+        return info.get("tap_label", "n/a")
+
+    return fun
+
+
+def _tap_json_from(pt_to_tap: Dict[str, Dict[str, Any]]):
+    def fun(pt: PowerTransformer):
+        info = pt_to_tap.get(pt.mrid, {})
+        return info.get("tap_json", "{}")
+
+    return fun
+
+
+def _tap_step_from(pt_to_tap: Dict[str, Dict[str, Any]]):
+    def fun(pt: PowerTransformer):
+        info = pt_to_tap.get(pt.mrid, {})
+        return info.get("tap_step", 0)
+
+    return fun
+
+
+def _tap_count_from(pt_to_tap: Dict[str, Dict[str, Any]]):
+    def fun(pt: PowerTransformer):
+        info = pt_to_tap.get(pt.mrid, {})
+        return info.get("tap_count", 0)
+
+    return fun
+
+
+def to_geojson_feature_collection(
+    psrs: List[PowerSystemResource],
+    class_to_properties: Dict[Type, Dict[str, Callable[[Any], Any]]]
+) -> FeatureCollection:
+
+    features = []
+    for psr in psrs:
+        properties_map = class_to_properties.get(type(psr))
+
+        if properties_map is not None:
+            feature = to_geojson_feature(psr, properties_map)
+            if feature is not None:
+                features.append(feature)
+
+    return FeatureCollection(features)
+
+
+def to_geojson_feature(
+    psr: PowerSystemResource,
+    property_map: Dict[str, Callable[[PowerSystemResource], Any]]
+) -> Union[Feature, None]:
+
+    geometry = to_geojson_geometry(psr.location)
+    if geometry is None:
+        return None
+
+    properties = {k: f(psr) for (k, f) in property_map.items()}
+    return Feature(psr.mrid, geometry, properties)
+
+
+def to_geojson_geometry(location: Location) -> Union[Geometry, None]:
+    points = list(location.points) if location is not None else []
+    if len(points) > 1:
+        return LineString([(point.x_position, point.y_position) for point in points])
+    elif len(points) == 1:
+        return Point((points[0].x_position, points[0].y_position))
+    else:
+        return None
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/src/zepben/examples/studies/transformer_downstream_density.py b/src/zepben/examples/studies/transformer_downstream_density.py
new file mode 100644
index 0000000..6a89bc7
--- /dev/null
+++ b/src/zepben/examples/studies/transformer_downstream_density.py
@@ -0,0 +1,356 @@
+#  Copyright 2025 Zeppelin Bend Pty Ltd
+#
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+import asyncio
+import json
+from datetime import datetime
+from itertools import islice
+from typing import List, Dict, Tuple, Callable, Any, Union, Type, Set
+
+from geojson import FeatureCollection, Feature
+from geojson.geometry import Geometry, LineString, Point
+from zepben.eas.client.eas_client import EasClient
+from zepben.eas.client.study import Study, Result, GeoJsonOverlay
+from zepben.ewb import (
+    AcLineSegment,
+    EnergyConsumer,
+    PhotoVoltaicUnit,
+    PowerElectronicsConnection,
+    PowerTransformer,
+    NetworkConsumerClient,
+    PhaseCode,
+    Feeder,
+    PowerSystemResource,
+    Location,
+    connect_with_token,
+    NetworkTraceStep,
+    Tracing,
+    downstream,
+    IncludedEnergizedContainers,
+)
+
+
+with open("../config.json") as f:
+    c = json.loads(f.read())
+
+
+def chunk(it, size):
+    it = iter(it)
+    return iter(lambda: tuple(islice(it, size)), ())
+
+
+async def main():
+    zone_mrids = ["CPM"]
+    print(f"Start time: {datetime.now()}")
+
+    rpc_channel = connect_with_token(
+        host=c["host"],
+        access_token=c["access_token"],
+        rpc_port=c["rpc_port"],
+        ca_filename=c.get("ca_filename"),
+        timeout_seconds=c.get("timeout_seconds", 5),
+        debug=bool(c.get("debug", False)),
+        skip_connection_test=bool(c.get("skip_connection_test", False)),
+    )
+    client = NetworkConsumerClient(rpc_channel)
+    hierarchy = (await client.get_network_hierarchy()).throw_on_error()
+    substations = hierarchy.value.substations
+
+    print(f"Collecting feeders from zones {', '.join(zone_mrids)}.")
+    feeder_mrids = []
+    for zone_mrid in zone_mrids:
+        if zone_mrid in substations:
+            for feeder in substations[zone_mrid].feeders:
+                feeder_mrids.append(feeder.mrid)
+
+    print(f"Feeders to be processed: {', '.join(feeder_mrids)}")
+
+    all_transformers: List[PowerTransformer] = []
+    transformer_to_metrics: Dict[str, Dict[str, float]] = {}
+
+    batches = chunk(feeder_mrids, 3)
+    for feeders in batches:
+        futures = []
+        rpc_channel = connect_with_token(
+            host=c["host"],
+            access_token=c["access_token"],
+            rpc_port=c["rpc_port"],
+            ca_filename=c.get("ca_filename"),
+            timeout_seconds=c.get("timeout_seconds", 5),
+            debug=bool(c.get("debug", False)),
+            skip_connection_test=bool(c.get("skip_connection_test", False)),
+        )
+        print(f"Processing feeders {', '.join(feeders)}")
+        for feeder_mrid in feeders:
+            futures.append(asyncio.ensure_future(fetch_transformer_densities(feeder_mrid, rpc_channel)))
+
+        for future in futures:
+            transformers, metrics = await future
+            if transformers:
+                all_transformers.extend(transformers)
+                transformer_to_metrics.update(metrics)
+
+    print(f"Creating study for {len(all_transformers)} transformers")
+
+    styles = json.load(open("style_transformer_density.json", "r"))
+    results = [
+        _build_density_result(
+            "EnergyConsumer density (/100m)",
+            all_transformers,
+            transformer_to_metrics,
+            metric_key="ec_density",
+            label_key="ec_density_label",
+            style_ids=["ec-density-circle", "ec-density-label"],
+        ),
+        _build_density_result(
+            "UsagePoint density (/100m)",
+            all_transformers,
+            transformer_to_metrics,
+            metric_key="up_density",
+            label_key="up_density_label",
+            style_ids=["up-density-circle", "up-density-label"],
+        ),
+        _build_density_result(
+            "PV density (/100m)",
+            all_transformers,
+            transformer_to_metrics,
+            metric_key="pv_density",
+            label_key="pv_density_label",
+            style_ids=["pv-density-circle", "pv-density-label"],
+        ),
+    ]
+
+    results = [r for r in results if r is not None]
+    if not results:
+        print("No transformer features to display (missing locations). Study upload skipped.")
+        return
+
+    eas_client = EasClient(host=c["host"], port=c["rpc_port"], protocol="https", access_token=c["access_token"])
+    print(f"Uploading Study for zones {', '.join(zone_mrids)} ...")
+    await eas_client.async_upload_study(
+        Study(
+            name=f"Transformer densities ({', '.join(zone_mrids)})",
+            description="Downstream EC, UsagePoint and PV density per 100m of AC line segment.",
+            tags=["transformer_density", "-".join(zone_mrids)],
+            results=results,
+            styles=styles,
+        )
+    )
+    await eas_client.aclose()
+    print("Uploaded Study")
+    print(f"Finish time: {datetime.now()}")
+
+
+async def fetch_transformer_densities(
+    feeder_mrid: str,
+    rpc_channel,
+) -> Tuple[List[PowerTransformer], Dict[str, Dict[str, float]]]:
+    print(f"Fetching Feeder {feeder_mrid}")
+    client = NetworkConsumerClient(rpc_channel)
+
+    result = (
+        await client.get_equipment_container(
+            mrid=feeder_mrid,
+            expected_class=Feeder,
+            include_energized_containers=IncludedEnergizedContainers.LV_FEEDERS,
+        )
+    )
+    if result.was_failure:
+        print(f"Failed: {result.thrown}")
+        return [], {}
+
+    network = client.service
+    print(f"Finished fetching Feeder {feeder_mrid}")
+
+    pv_consumers = _find_pv_energy_consumers(network)
+
+    transformers: List[PowerTransformer] = []
+    transformer_to_metrics: Dict[str, Dict[str, float]] = {}
+    for io in (pt for pt in network.objects(PowerTransformer)):
+        pt: PowerTransformer = io
+        transformers.append(pt)
+
+        downstream_eq = await get_downstream_eq(pt)
+        downstream_lines = {eq for eq in downstream_eq if isinstance(eq, AcLineSegment)}
+        downstream_ecs = {eq for eq in downstream_eq if isinstance(eq, EnergyConsumer)}
+
+        total_length_m = sum(_line_length_m(line) for line in downstream_lines)
+        ec_count = len(downstream_ecs)
+        up_count = _usage_point_count(downstream_ecs)
+        pv_count = sum(1 for ec in downstream_ecs if ec.mrid in pv_consumers)
+
+        ec_density = _safe_density_per_100m(ec_count, total_length_m)
+        up_density = _safe_density_per_100m(up_count, total_length_m)
+        pv_density = _safe_density_per_100m(pv_count, total_length_m)
+
+        transformer_to_metrics[pt.mrid] = {
+            "ec_density": ec_density,
+            "ec_density_label": _density_label(ec_density),
+            "up_density": up_density,
+            "up_density_label": _density_label(up_density),
+            "pv_density": pv_density,
+            "pv_density_label": _density_label(pv_density),
+        }
+
+    return transformers, transformer_to_metrics
+
+
+def _usage_point_count(ecs: Set[EnergyConsumer]) -> int:
+    usage_points = set()
+    for ec in ecs:
+        for up in ec.usage_points:
+            usage_points.add(up.mrid)
+    return len(usage_points)
+
+
+def _safe_density_per_100m(count: int, length_m: float) -> float:
+    if length_m <= 0:
+        return 0.0
+    return (count / length_m) * 100.0
+
+
+def _density_label(value: float) -> str:
+    return f"{value:.2f}/100m" if value > 0 else "n/a"
+
+
+def _line_length_m(line: AcLineSegment) -> float:
+    return float(line.length or 0.0)
+
+
+def collect_downstream_edges_provider(
+    adjacency: Dict[PowerSystemResource, Set[PowerSystemResource]],
+    nodes: Set[PowerSystemResource],
+):
+
+    async def collect_edges(ps: NetworkTraceStep, _):
+        nodes.add(ps.path.from_equipment)
+        nodes.add(ps.path.to_equipment)
+        if ps.path.traced_externally:
+            adjacency.setdefault(ps.path.from_equipment, set()).add(ps.path.to_equipment)
+
+    return collect_edges
+
+
+async def get_downstream_eq(ce: PowerTransformer) -> Set[PowerSystemResource]:
+    nodes: Set[PowerSystemResource] = {ce}
+    adjacency: Dict[PowerSystemResource, Set[PowerSystemResource]] = {}
+
+    await (
+        Tracing.network_trace()
+        .add_condition(downstream())
+        .add_step_action(collect_downstream_edges_provider(adjacency, nodes))
+    ).run(start=ce, phases=PhaseCode.ABCN, can_stop_on_start_item=False)
+
+    return nodes
+
+
+def _find_pv_energy_consumers(network) -> Set[str]:
+    pv_usage_points: Set[str] = set()
+    pv_nodes: Set[str] = set()
+
+    for pv in network.objects(PhotoVoltaicUnit):
+        for up in pv.usage_points:
+            pv_usage_points.add(up.mrid)
+        if pv.power_electronics_connection:
+            for up in pv.power_electronics_connection.usage_points:
+                pv_usage_points.add(up.mrid)
+
+    for pec in network.objects(PowerElectronicsConnection):
+        if any(isinstance(unit, PhotoVoltaicUnit) for unit in pec.units):
+            for up in pec.usage_points:
+                pv_usage_points.add(up.mrid)
+            for terminal in pec.terminals:
+                if terminal.connectivity_node:
+                    pv_nodes.add(terminal.connectivity_node.mrid)
+
+    pv_consumers: Set[str] = set()
+    for ec in network.objects(EnergyConsumer):
+        if any(up.mrid in pv_usage_points for up in ec.usage_points):
+            pv_consumers.add(ec.mrid)
+            continue
+        if pv_nodes and any(t.connectivity_node and t.connectivity_node.mrid in pv_nodes for t in ec.terminals):
+            pv_consumers.add(ec.mrid)
+
+    return pv_consumers
+
+
+def _build_density_result(
+    result_name: str,
+    transformers: List[PowerTransformer],
+    transformer_to_metrics: Dict[str, Dict[str, float]],
+    metric_key: str,
+    label_key: str,
+    style_ids: List[str],
+) -> Union[Result, None]:
+    class_to_properties = {
+        PowerTransformer: {
+            metric_key: _metric_from(transformer_to_metrics, metric_key),
+            label_key: _metric_from(transformer_to_metrics, label_key),
+            "type": lambda x: "pt",
+        },
+    }
+    feature_collection = to_geojson_feature_collection(transformers, class_to_properties)
+    if not feature_collection.features:
+        return None
+    return Result(
+        name=result_name,
+        geo_json_overlay=GeoJsonOverlay(
+            data=feature_collection,
+            styles=style_ids,
+        )
+    )
+
+
+def _metric_from(pt_to_metrics: Dict[str, Dict[str, float]], key: str):
+    def fun(pt: PowerTransformer):
+        info = pt_to_metrics.get(pt.mrid, {})
+        return info.get(key, 0.0)
+
+    return fun
+
+
+def to_geojson_feature_collection(
+    psrs: List[PowerSystemResource],
+    class_to_properties: Dict[Type, Dict[str, Callable[[Any], Any]]]
+) -> FeatureCollection:
+
+    features = []
+    for psr in psrs:
+        properties_map = class_to_properties.get(type(psr))
+
+        if properties_map is not None:
+            feature = to_geojson_feature(psr, properties_map)
+            if feature is not None:
+                features.append(feature)
+
+    return FeatureCollection(features)
+
+
+def to_geojson_feature(
+    psr: PowerSystemResource,
+    property_map: Dict[str, Callable[[PowerSystemResource], Any]]
+) -> Union[Feature, None]:
+
+    geometry = to_geojson_geometry(psr.location)
+    if geometry is None:
+        return None
+
+    properties = {k: f(psr) for (k, f) in property_map.items()}
+    return Feature(psr.mrid, geometry, properties)
+
+
+def to_geojson_geometry(location: Location) -> Union[Geometry, None]:
+    points = list(location.points) if location is not None else []
+    if len(points) > 1:
+        return LineString([(point.x_position, point.y_position) for point in points])
+    elif len(points) == 1:
+        return Point((points[0].x_position, points[0].y_position))
+    else:
+        return None
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/src/zepben/examples/studies/transformer_utilisation_by_demand.py b/src/zepben/examples/studies/transformer_utilisation_by_demand.py
new file mode 100644
index 0000000..f57738e
--- /dev/null
+++ b/src/zepben/examples/studies/transformer_utilisation_by_demand.py
@@ -0,0 +1,842 @@
+#  Copyright 2025 Zeppelin Bend Pty Ltd
+#
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+import argparse
+from dataclasses import dataclass
+import asyncio
+import calendar
+import json
+import os
+import sys
+import threading
+from datetime import date, datetime
+from itertools import islice
+from typing import List, Dict, Tuple, Callable, Any, Union, Type, Optional
+
+import requests
+from geojson import FeatureCollection, Feature
+from geojson.geometry import Geometry, LineString, Point
+from zepben.eas.client.eas_client import EasClient
+from zepben.eas.client.study import Study, Result, GeoJsonOverlay
+from zepben.ewb import (
+    PowerTransformer,
+    NetworkConsumerClient,
+    Feeder,
+    PowerSystemResource,
+    Location,
+    connect_with_token,
+    IncludedEnergizedContainers,
+)
+
+
+DEFAULT_CONFIG_PATH = os.path.normpath(os.path.join(os.path.dirname(__file__), "..", "config.json"))
+
+
+def chunk(it, size):
+    it = iter(it)
+    return iter(lambda: tuple(islice(it, size)), ())
+
+
+def _build_base_url(host: str, port: Optional[int]) -> str:
+    host = host.rstrip("/")
+    if host.startswith("http://") or host.startswith("https://"):
+        base = host
+    else:
+        base = f"https://{host}"
+
+    if port and port not in (80, 443):
+        # Only append if a port is not already present
+        if ":" not in base.split("//", 1)[-1]:
+            base = f"{base}:{port}"
+    return base
+
+
+def _subtract_months(d: date, months: int) -> date:
+    year = d.year - (months // 12)
+    month = d.month - (months % 12)
+    if month <= 0:
+        year -= 1
+        month += 12
+    day = min(d.day, calendar.monthrange(year, month)[1])
+    return date(year, month, day)
+
+
+class LoadApiClient:
+    def __init__(
+        self,
+        base_url: str,
+        access_token: str,
+        system_tag: str = "EWB",
+        timeout_seconds: int = 10,
+        verify: Union[bool, str] = True,
+    ):
+        self.base_url = base_url.rstrip("/")
+        self.system_tag = system_tag
+        self.timeout_seconds = timeout_seconds
+        self.verify = verify
+        self.session = requests.Session()
+        self.session.headers.update(
+            {
+                "Authorization": f"Bearer {access_token}",
+                "Accept": "application/json",
+            }
+        )
+
+    def close(self):
+        self.session.close()
+
+    def get_max_demand(self, asset_id: str, from_date: str, to_date: str) -> Dict[str, Any]:
+        return self._get_profile(f"/ewb/energy/profiles/api/v1/max-demand/{asset_id}", from_date, to_date)
+
+    def get_min_demand(self, asset_id: str, from_date: str, to_date: str) -> Dict[str, Any]:
+        return self._get_profile(f"/ewb/energy/profiles/api/v1/min-demand/{asset_id}", from_date, to_date)
+
+    def _get_profile(self, path: str, from_date: str, to_date: str) -> Dict[str, Any]:
+        url = f"{self.base_url}{path}"
+        params = {
+            "fromDate": from_date,
+            "toDate": to_date,
+            "systemTag": self.system_tag,
+        }
+        response = self.session.get(url, params=params, timeout=self.timeout_seconds, verify=self.verify)
+        response.raise_for_status()
+        return response.json()
+
+
+class LoadApiConfig:
+    def __init__(
+        self,
+        base_url: str,
+        access_token: str,
+        system_tag: str,
+        timeout_seconds: int,
+        verify: Union[bool, str],
+    ):
+        self.base_url = base_url
+        self.access_token = access_token
+        self.system_tag = system_tag
+        self.timeout_seconds = timeout_seconds
+        self.verify = verify
+
+
+_thread_local = threading.local()
+
+
+def _get_thread_client(config: LoadApiConfig) -> LoadApiClient:
+    client = getattr(_thread_local, "client", None)
+    if client is None:
+        client = LoadApiClient(
+            base_url=config.base_url,
+            access_token=config.access_token,
+            system_tag=config.system_tag,
+            timeout_seconds=config.timeout_seconds,
+            verify=config.verify,
+        )
+        _thread_local.client = client
+    return client
+
+
+def _iter_series_entries(series: Any):
+    if isinstance(series, dict):
+        yield series
+        return
+    if not isinstance(series, list):
+        return
+    for entry in series:
+        if isinstance(entry, dict):
+            yield entry
+            continue
+        if isinstance(entry, list):
+            for nested in entry:
+                if isinstance(nested, dict):
+                    yield nested
+
+
+def _first_dict(value: Any) -> Optional[Dict[str, Any]]:
+    if isinstance(value, dict):
+        return value
+    if isinstance(value, list) and value:
+        for item in value:
+            if isinstance(item, dict):
+                return item
+    return None
+
+
+def _preview_payload(payload: Any, max_chars: int = 1200) -> str:
+    try:
+        text = json.dumps(payload, default=str)
+    except (TypeError, ValueError):
+        text = str(payload)
+    if len(text) > max_chars:
+        return f"{text[:max_chars]}... (truncated {len(text) - max_chars} chars)"
+    return text
+
+
+@dataclass
+class DebugConfig:
+    log_summary: bool = False
+    log_samples: int = 0
+    log_api_samples: int = 0
+
+
+class DebugState:
+    def __init__(self, config: DebugConfig):
+        self.config = config
+        self._samples_left = max(config.log_samples, 0)
+        self._api_left = max(config.log_api_samples, 0)
+        self._lock = threading.Lock()
+
+    def log_api(self, pt: PowerTransformer, max_profile: Any, min_profile: Any):
+        with self._lock:
+            if self._api_left <= 0:
+                return
+            self._api_left -= 1
+        print(f"[debug] API payloads for {pt.mrid}:")
+        print(f"[debug] max_profile={_preview_payload(max_profile)}")
+        print(f"[debug] min_profile={_preview_payload(min_profile)}")
+
+    def log_stats(self, pt: PowerTransformer, rating_va: float, max_data: Any, min_data: Any, stats: Dict[str, Any]):
+        with self._lock:
+            if self._samples_left <= 0:
+                return
+            self._samples_left -= 1
+        sample = {
+            "rating_va": rating_va,
+            "rating_kva": stats.get("transformer_rating_kva"),
+            "has_max_profile": stats.get("has_max_profile"),
+            "has_min_profile": stats.get("has_min_profile"),
+            "max_import_util_percent": stats.get("max_import_util_percent"),
+            "max_export_util_percent": stats.get("max_export_util_percent"),
+            "min_export_util_percent": stats.get("min_export_util_percent"),
+            "min_import_util_percent": stats.get("min_import_util_percent"),
+            "max_demand_date": stats.get("max_demand_date"),
+            "min_demand_date": stats.get("min_demand_date"),
+            "max_demand_season": stats.get("max_demand_season"),
+            "min_demand_season": stats.get("min_demand_season"),
+        }
+        print(f"[debug] Stats for {pt.mrid}: {sample}")
+        print(f"[debug] max_data={max_data}")
+        print(f"[debug] min_data={min_data}")
+
+
+def _extract_maximums(payload: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    if payload is None:
+        return None
+    if isinstance(payload, list):
+        payload = _first_dict(payload)
+        if payload is None:
+            return None
+    if not isinstance(payload, dict):
+        return None
+    if payload.get("error"):
+        return None
+
+    results = payload.get("results") or []
+    if not results:
+        return None
+
+    for result in results:
+        series = result.get("series") if isinstance(result, dict) else None
+        if not series:
+            continue
+
+        for entry in _iter_series_entries(series):
+            energy = _first_dict(entry.get("energy")) if isinstance(entry, dict) else None
+            if energy is None and isinstance(entry, dict) and ("maximums" in entry or "date" in entry):
+                energy = entry
+            if not isinstance(energy, dict):
+                continue
+
+            maximums = energy.get("maximums") or {}
+
+            return {
+                "date": energy.get("date"),
+                "kwIn": maximums.get("kwIn"),
+                "kwOut": maximums.get("kwOut"),
+                "kwNet": maximums.get("kwNet"),
+                "kvaNet": maximums.get("kvaNet"),
+                "pf": maximums.get("pf"),
+            }
+
+    return None
+
+
+def _safe_float(value: Any) -> Optional[float]:
+    if value is None:
+        return None
+    try:
+        return float(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def _util_percent(value_kw: Optional[float], rating_va: float) -> Optional[float]:
+    if value_kw is None or rating_va <= 0:
+        return None
+    return round((value_kw / rating_va) * 100, 1)
+
+
+async def main():
+    zone_mrids, feeder_mrids, mode, config_path, max_workers, debug_cfg, seasonal_shapes_flag = _parse_args(
+        sys.argv[1:]
+    )
+    with open(config_path) as f:
+        c = json.loads(f.read())
+    print(f"Start time: {datetime.now()}")
+
+    rpc_channel = connect_with_token(
+        host=c["host"],
+        access_token=c["access_token"],
+        rpc_port=c["rpc_port"],
+        ca_filename=c.get("ca_filename"),
+        timeout_seconds=c.get("timeout_seconds", 5),
+        debug=bool(c.get("debug", False)),
+        skip_connection_test=bool(c.get("skip_connection_test", False)),
+    )
+    if mode == "zones":
+        client = NetworkConsumerClient(rpc_channel)
+        hierarchy = (await client.get_network_hierarchy()).throw_on_error()
+        substations = hierarchy.value.substations
+
+        print(f"Collecting feeders from zones {', '.join(zone_mrids)}.")
+        feeder_mrids = []
+        for zone_mrid in zone_mrids:
+            if zone_mrid in substations:
+                for feeder in substations[zone_mrid].feeders:
+                    feeder_mrids.append(feeder.mrid)
+    else:
+        print(f"Running for feeders {', '.join(feeder_mrids)}.")
+
+    print(f"Feeders to be processed: {', '.join(feeder_mrids)}")
+
+    transformers_by_id: Dict[str, PowerTransformer] = {}
+
+    # Process the feeders in batches of 3, using asyncio, for performance
+    batches = chunk(feeder_mrids, 3)
+    for feeders in batches:
+        futures = []
+        rpc_channel = connect_with_token(
+            host=c["host"],
+            access_token=c["access_token"],
+            rpc_port=c["rpc_port"],
+            ca_filename=c.get("ca_filename"),
+            timeout_seconds=c.get("timeout_seconds", 5),
+            debug=bool(c.get("debug", False)),
+            skip_connection_test=bool(c.get("skip_connection_test", False)),
+        )
+        print(f"Processing feeders {', '.join(feeders)}")
+        for feeder_mrid in feeders:
+            futures.append(asyncio.ensure_future(fetch_feeder_transformers(feeder_mrid, rpc_channel)))
+
+        for future in futures:
+            transformers = await future
+            for pt in transformers:
+                transformers_by_id[pt.mrid] = pt
+
+    all_transformers = list(transformers_by_id.values())
+    print(f"Collected {len(all_transformers)} transformers")
+
+    today = date.today()
+    start_date = _subtract_months(today, 18)
+    from_date = start_date.isoformat()
+    to_date = today.isoformat()
+    print(f"Load API date range: {from_date} to {to_date}")
+
+    base_url = _build_base_url(c["host"], c.get("rpc_port"))
+    system_tag = c.get("load_api_system_tag", "EWB")
+    timeout_seconds = c.get("timeout_seconds", 10)
+    verify = c.get("ca_filename") or True
+    season_hemisphere = c.get("season_hemisphere", "southern")
+    seasonal_shapes = bool(c.get("seasonal_shapes", False)) or seasonal_shapes_flag
+
+    load_config = LoadApiConfig(
+        base_url=base_url,
+        access_token=c["access_token"],
+        system_tag=system_tag,
+        timeout_seconds=timeout_seconds,
+        verify=verify,
+    )
+
+    debug_state = (
+        DebugState(debug_cfg)
+        if debug_cfg.log_summary or debug_cfg.log_samples or debug_cfg.log_api_samples
+        else None
+    )
+
+    transformer_to_stats: Dict[str, Dict[str, Any]] = {}
+    semaphore = asyncio.Semaphore(max_workers)
+    tasks = [
+        asyncio.create_task(
+            _fetch_transformer_utilisation_async(
+                pt, load_config, from_date, to_date, season_hemisphere, semaphore, debug_state
+            )
+        )
+        for pt in all_transformers
+    ]
+    completed = 0
+    for future in asyncio.as_completed(tasks):
+        mrid, stats = await future
+        transformer_to_stats[mrid] = stats
+        completed += 1
+        if completed % 25 == 0 or completed == len(tasks):
+            print(f"Load API progress: {completed}/{len(tasks)}")
+
+    print(f"Created Study for {len(all_transformers)} transformers")
+
+    styles = json.load(open("style_transformer_utilisation.json", "r"))
+    max_feature_collection = to_geojson_feature_collection(
+        all_transformers,
+        {
+            PowerTransformer: {
+                "max_import_util_percent": _stat_getter(transformer_to_stats, "max_import_util_percent"),
+                "max_import_label": _stat_getter(transformer_to_stats, "max_import_label"),
+                "max_import_util_kw_percent": _stat_getter(transformer_to_stats, "max_import_util_kw_percent"),
+                "max_import_kw": _stat_getter(transformer_to_stats, "max_import_kw"),
+                "max_import_kva": _stat_getter(transformer_to_stats, "max_import_kva"),
+                "max_demand_date": _stat_getter(transformer_to_stats, "max_demand_date"),
+                "max_demand_season": _stat_getter(transformer_to_stats, "max_demand_season"),
+                "transformer_rating_va": _stat_getter(transformer_to_stats, "transformer_rating_va"),
+                "transformer_rating_kva": _stat_getter(transformer_to_stats, "transformer_rating_kva"),
+                "has_max_profile": _stat_getter(transformer_to_stats, "has_max_profile"),
+                "type": lambda x: "pt",
+            }
+        },
+    )
+    min_feature_collection = to_geojson_feature_collection(
+        all_transformers,
+        {
+            PowerTransformer: {
+                "min_export_util_percent": _stat_getter(transformer_to_stats, "min_export_util_percent"),
+                "min_export_label": _stat_getter(transformer_to_stats, "min_export_label"),
+                "min_export_util_kw_percent": _stat_getter(transformer_to_stats, "min_export_util_kw_percent"),
+                "min_export_kw": _stat_getter(transformer_to_stats, "min_export_kw"),
+                "min_export_kva": _stat_getter(transformer_to_stats, "min_export_kva"),
+                "min_demand_date": _stat_getter(transformer_to_stats, "min_demand_date"),
+                "min_demand_season": _stat_getter(transformer_to_stats, "min_demand_season"),
+                "transformer_rating_va": _stat_getter(transformer_to_stats, "transformer_rating_va"),
+                "transformer_rating_kva": _stat_getter(transformer_to_stats, "transformer_rating_kva"),
+                "has_min_profile": _stat_getter(transformer_to_stats, "has_min_profile"),
+                "type": lambda x: "pt",
+            }
+        },
+    )
+
+    if debug_state and debug_state.config.log_summary:
+        missing_location = 0
+        for pt in all_transformers:
+            points = list(pt.location.points) if pt.location is not None else []
+            if not points:
+                missing_location += 1
+
+        stats_values = list(transformer_to_stats.values())
+        has_max_profile = sum(1 for stats in stats_values if stats.get("has_max_profile"))
+        has_min_profile = sum(1 for stats in stats_values if stats.get("has_min_profile"))
+        rating_zero = sum(1 for stats in stats_values if stats.get("transformer_rating_va") in (0, 0.0))
+
+        max_import_values = [
+            stats.get("max_import_util_percent")
+            for stats in stats_values
+            if stats.get("has_max_profile") and stats.get("max_import_util_percent") is not None
+        ]
+        min_export_values = [
+            stats.get("min_export_util_percent")
+            for stats in stats_values
+            if stats.get("has_min_profile") and stats.get("min_export_util_percent") is not None
+        ]
+
+        print(
+            "[debug] Summary:"
+            f" total_transformers={len(all_transformers)}"
+            f" max_features={len(max_feature_collection.features)}"
+            f" min_features={len(min_feature_collection.features)}"
+            f" missing_location={missing_location}"
+            f" rating_zero={rating_zero}"
+            f" has_max_profile={has_max_profile}"
+            f" has_min_profile={has_min_profile}"
+        )
+        if max_import_values:
+            print(
+                "[debug] Max import utilisation (percent):"
+                f" min={min(max_import_values)}"
+                f" max={max(max_import_values)}"
+            )
+        if min_export_values:
+            print(
+                "[debug] Min export utilisation (percent):"
+                f" min={min(min_export_values)}"
+                f" max={max(min_export_values)}"
+            )
+        sample_feature = None
+        if max_feature_collection.features:
+            sample_feature = max_feature_collection.features[0]
+        elif min_feature_collection.features:
+            sample_feature = min_feature_collection.features[0]
+        if sample_feature is not None:
+            sample_props = getattr(sample_feature, "properties", None)
+            if sample_props is None and isinstance(sample_feature, dict):
+                sample_props = sample_feature.get("properties")
+            if sample_props is not None:
+                print(f"[debug] Sample feature properties: {sample_props}")
+
+    results = []
+    max_styles = ["max-demand-utilisation", "max-demand-label"]
+    min_styles = ["min-demand-utilisation", "min-demand-label"]
+    if seasonal_shapes:
+        max_styles = ["max-demand-season-shape", "max-demand-label"]
+        min_styles = ["min-demand-season-shape", "min-demand-label"]
+
+    if max_feature_collection.features:
+        results.append(
+            Result(
+                name="Max Demand Utilisation (Import)",
+                geo_json_overlay=GeoJsonOverlay(
+                    data=max_feature_collection,
+                    styles=max_styles,
+                ),
+            )
+        )
+    if min_feature_collection.features:
+        results.append(
+            Result(
+                name="Min Demand Utilisation (Export)",
+                geo_json_overlay=GeoJsonOverlay(
+                    data=min_feature_collection,
+                    styles=min_styles,
+                ),
+            )
+        )
+
+    if not results:
+        print("No transformer features to display (missing locations). Study upload skipped.")
+        return
+
+    scope_mrids = zone_mrids if mode == "zones" else feeder_mrids
+    scope_label = ", ".join(scope_mrids)
+    scope_tag = "-".join(scope_mrids)
+
+    eas_client = EasClient(host=c["host"], port=c["rpc_port"], protocol="https", access_token=c["access_token"])
+    print(f"Uploading Study for {mode} {scope_label} ...")
+    await eas_client.async_upload_study(
+        Study(
+            name=f"Transformer utilisation (import/export) ({scope_label})",
+            description=(
+                "Max-demand import utilisation (kwIn) and min-demand export utilisation (kwOut) "
+                "for the last 18 months via the Energy Profiles API."
+            ),
+            tags=["transformer_utilisation", "load_api", scope_tag],
+            results=results,
+            styles=styles,
+        )
+    )
+    await eas_client.aclose()
+    print("Uploaded Study")
+
+    print(f"Finish time: {datetime.now()}")
+
+
+async def fetch_feeder_transformers(
+    feeder_mrid: str,
+    rpc_channel,
+) -> List[PowerTransformer]:
+    print(f"Fetching Feeder {feeder_mrid}")
+    client = NetworkConsumerClient(rpc_channel)
+
+    result = (
+        await client.get_equipment_container(
+            mrid=feeder_mrid,
+            expected_class=Feeder,
+            include_energized_containers=IncludedEnergizedContainers.LV_FEEDERS,
+        )
+    )
+    if result.was_failure:
+        print(f"Failed: {result.thrown}")
+        return []
+
+    network = client.service
+    print(f"Finished fetching Feeder {feeder_mrid}")
+
+    return [pt for pt in network.objects(PowerTransformer)]
+
+
+def fetch_transformer_utilisation(
+    pt: PowerTransformer,
+    load_config: LoadApiConfig,
+    from_date: str,
+    to_date: str,
+    season_hemisphere: str,
+    debug_state: Optional[DebugState] = None,
+) -> Dict[str, Any]:
+    load_client = _get_thread_client(load_config)
+    rating_va = _transformer_rating_va(pt)
+    rating_kva = rating_va / 1000.0 if rating_va else 0.0
+
+    max_profile = None
+    min_profile = None
+
+    try:
+        max_profile = load_client.get_max_demand(pt.mrid, from_date, to_date)
+    except requests.RequestException as ex:
+        print(f"Max-demand request failed for {pt.mrid}: {ex}")
+
+    try:
+        min_profile = load_client.get_min_demand(pt.mrid, from_date, to_date)
+    except requests.RequestException as ex:
+        print(f"Min-demand request failed for {pt.mrid}: {ex}")
+
+    max_data = _extract_maximums(max_profile) if max_profile else None
+    min_data = _extract_maximums(min_profile) if min_profile else None
+
+    max_kw_in = _safe_float(max_data.get("kwIn")) if max_data else None
+    max_kw_out = _safe_float(max_data.get("kwOut")) if max_data else None
+    max_kva_net = _safe_float(max_data.get("kvaNet")) if max_data else None
+    min_kw_in = _safe_float(min_data.get("kwIn")) if min_data else None
+    min_kw_out = _safe_float(min_data.get("kwOut")) if min_data else None
+    min_kva_net = _safe_float(min_data.get("kvaNet")) if min_data else None
+
+    max_import_util_kw = _util_percent(max_kw_in, rating_kva)
+    min_export_util_kw = _util_percent(abs(min_kw_out) if min_kw_out is not None else None, rating_kva)
+    max_import_util = _util_percent(max_kva_net, rating_kva)
+    min_export_util = _util_percent(abs(min_kva_net) if min_kva_net is not None else None, rating_kva)
+    max_season = _season_from_date(max_data.get("date") if max_data else None, season_hemisphere)
+    min_season = _season_from_date(min_data.get("date") if min_data else None, season_hemisphere)
+
+    stats = {
+        "max_import_util_percent": max_import_util or 0,
+        "min_export_util_percent": min_export_util or 0,
+        "max_import_label": _percent_label(max_import_util),
+        "min_export_label": _percent_label(min_export_util),
+        "max_import_util_kw_percent": max_import_util_kw or 0,
+        "min_export_util_kw_percent": min_export_util_kw or 0,
+        "max_import_kw": max_kw_in or 0,
+        "min_export_kw": abs(min_kw_out) if min_kw_out is not None else 0,
+        "max_import_kva": max_kva_net or 0,
+        "min_export_kva": abs(min_kva_net) if min_kva_net is not None else 0,
+        "max_demand_date": max_data.get("date") if max_data else None,
+        "min_demand_date": min_data.get("date") if min_data else None,
+        "max_demand_season": max_season,
+        "min_demand_season": min_season,
+        "transformer_rating_va": rating_va,
+        "transformer_rating_kva": rating_kva,
+        "has_max_profile": max_data is not None,
+        "has_min_profile": min_data is not None,
+        "max_export_util_percent": _util_percent(abs(max_kw_out) if max_kw_out is not None else None, rating_kva) or 0,
+        "min_import_util_percent": _util_percent(min_kw_in, rating_kva) or 0,
+    }
+
+    if debug_state:
+        debug_state.log_api(pt, max_profile, min_profile)
+        debug_state.log_stats(pt, rating_va, max_data, min_data, stats)
+
+    return stats
+
+
+async def _fetch_transformer_utilisation_async(
+    pt: PowerTransformer,
+    load_config: LoadApiConfig,
+    from_date: str,
+    to_date: str,
+    season_hemisphere: str,
+    semaphore: asyncio.Semaphore,
+    debug_state: Optional[DebugState] = None,
+) -> Tuple[str, Dict[str, Any]]:
+    async with semaphore:
+        stats = await asyncio.to_thread(
+            fetch_transformer_utilisation,
+            pt,
+            load_config,
+            from_date,
+            to_date,
+            season_hemisphere,
+            debug_state,
+        )
+        return pt.mrid, stats
+
+
+def _percent_label(value: Optional[float]) -> str:
+    return "n/a" if value is None else f"{value}%"
+
+
+def _season_from_date(value: Optional[str], hemisphere: str = "southern") -> Optional[str]:
+    if not value:
+        return None
+    try:
+        parsed = date.fromisoformat(value)
+    except ValueError:
+        return None
+
+    month = parsed.month
+    hemi = hemisphere.strip().lower() if hemisphere else "southern"
+    is_northern = hemi.startswith("n")
+
+    if is_northern:
+        if month in (12, 1, 2):
+            return "Winter"
+        if month in (3, 4, 5):
+            return "Spring"
+        if month in (6, 7, 8):
+            return "Summer"
+        return "Autumn"
+
+    if month in (12, 1, 2):
+        return "Summer"
+    if month in (3, 4, 5):
+        return "Autumn"
+    if month in (6, 7, 8):
+        return "Winter"
+    return "Spring"
+
+
+def _transformer_rating_va(pt: PowerTransformer) -> float:
+    ratings: List[float] = []
+    for end in pt.ends:
+        if end.rated_s is not None:
+            ratings.append(end.rated_s)
+        else:
+            for rating in end.s_ratings:
+                if rating and rating.rated_s is not None:
+                    ratings.append(rating.rated_s)
+    return max(ratings) if ratings else 0
+
+
+def _stat_getter(stats: Dict[str, Dict[str, Any]], key: str, default: Any = None):
+    def fun(pt: PowerTransformer):
+        return stats.get(pt.mrid, {}).get(key, default)
+
+    return fun
+
+
+def to_geojson_feature_collection(
+    psrs: List[PowerSystemResource],
+    class_to_properties: Dict[Type, Dict[str, Callable[[Any], Any]]],
+) -> FeatureCollection:
+
+    features = []
+    for psr in psrs:
+        properties_map = class_to_properties.get(type(psr))
+        if properties_map is None:
+            continue
+        feature = to_geojson_feature(psr, properties_map)
+        if feature is not None:
+            features.append(feature)
+
+    return FeatureCollection(features)
+
+
+def to_geojson_feature(
+    psr: PowerSystemResource,
+    property_map: Dict[str, Callable[[PowerSystemResource], Any]],
+) -> Union[Feature, None]:
+
+    geometry = to_geojson_geometry(psr.location)
+    if geometry is None:
+        return None
+
+    properties = {k: f(psr) for (k, f) in property_map.items()}
+    return Feature(psr.mrid, geometry, properties)
+
+
+def to_geojson_geometry(location: Location) -> Union[Geometry, None]:
+    points = list(location.points) if location is not None else []
+    if len(points) > 1:
+        return LineString([(point.x_position, point.y_position) for point in points])
+    elif len(points) == 1:
+        return Point((points[0].x_position, points[0].y_position))
+    else:
+        return None
+
+
+def _parse_args(argv: List[str]) -> Tuple[List[str], List[str], str, str, int, DebugConfig, bool]:
+    parser = argparse.ArgumentParser(
+        description="Generate a transformer utilisation study for one or more zones or feeders.",
+    )
+    parser.add_argument(
+        "--mode",
+        choices=["zones", "feeders"],
+        default="zones",
+        help="Interpret positional values as zones or feeders (default: zones).",
+    )
+    parser.add_argument(
+        "--zones",
+        default="CPM",
+        help="Comma-separated zone codes (default: CPM).",
+    )
+    parser.add_argument(
+        "--feeders",
+        default="",
+        help="Comma-separated feeder MRIDs (used when --mode feeders).",
+    )
+    parser.add_argument(
+        "--config",
+        default=DEFAULT_CONFIG_PATH,
+        help=f"Path to config.json (default: {DEFAULT_CONFIG_PATH}).",
+    )
+    parser.add_argument(
+        "--max-workers",
+        type=int,
+        default=None,
+        help="Maximum concurrent load API requests (default: 8).",
+    )
+    parser.add_argument(
+        "--log-summary",
+        action="store_true",
+        help="Log summary counts (profiles, ratings, locations).",
+    )
+    parser.add_argument(
+        "--log-samples",
+        type=int,
+        default=0,
+        help="Log computed stats for the first N transformers.",
+    )
+    parser.add_argument(
+        "--log-api-samples",
+        type=int,
+        default=0,
+        help="Log raw max/min API payloads for the first N transformers.",
+    )
+    parser.add_argument(
+        "--seasonal-shapes",
+        action="store_true",
+        help="Use season shapes (Summer/Autumn/Winter/Spring) for icons.",
+    )
+    parser.add_argument(
+        "ids",
+        nargs="*",
+        help="Zone codes or feeder MRIDs (positional values override --zones/--feeders).",
+    )
+    args = parser.parse_args(argv)
+
+    def _split_values(values: Any) -> List[str]:
+        if isinstance(values, list):
+            items = values
+        elif isinstance(values, str):
+            items = values.split(",")
+        else:
+            items = []
+        return [item.strip() for item in items if item and item.strip()]
+
+    max_workers = args.max_workers or 8
+    debug_cfg = DebugConfig(
+        log_summary=bool(args.log_summary),
+        log_samples=int(args.log_samples or 0),
+        log_api_samples=int(args.log_api_samples or 0),
+    )
+
+    if args.mode == "feeders":
+        feeder_mrids = _split_values(args.ids) or _split_values(args.feeders)
+        if not feeder_mrids:
+            raise ValueError("At least one feeder MRID is required.")
+        return [], feeder_mrids, args.mode, args.config, max_workers, debug_cfg, bool(args.seasonal_shapes)
+
+    zone_mrids = _split_values(args.ids) or _split_values(args.zones)
+
+    if not zone_mrids:
+        raise ValueError("At least one zone code is required.")
+
+    return zone_mrids, [], args.mode, args.config, max_workers, debug_cfg, bool(args.seasonal_shapes)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())