@rubytech/create-maxy-code 0.1.60 → 0.1.62

package/payload/platform/plugins/preval/skills/property-preval/references/render.py

@@ -2,20 +2,38 @@
 
 Substitutes <!-- REPLACE: <slot> --> placeholders in template.html with values
 derived from one inputs.json (shape: template-inputs.schema.json), drives
-Chrome headless to produce a 4-page A4 PDF, and asserts page count == 4.
+Chrome headless to produce a 5-page A4 PDF, and asserts page count == 5.
+
+Fails loud on any missing / unverifiable load-bearing input. No silent
+fallback modes — see _assert_inputs.
 
 Usage:
     python3 render.py inputs.json
 """
 from __future__ import annotations
-import html, json, re, shutil, subprocess, sys
+import html, json, re, shutil, subprocess, sys, time
 from pathlib import Path
 
 
+M2_TO_SQFT = 10.7639
+
+
 def _money(n: int) -> str:
     return f"£{int(n):,}"
 
 
+def _range_money(low: int, high: int) -> str:
+    return f"£{int(low):,} – £{int(high):,}"
+
+
+# ---------------- helpers ----------------
+
+def _short_address(address: str) -> str:
+    """First two address tokens for the cover meta strip."""
+    parts = [p.strip() for p in address.split(",")]
+    return ", ".join(parts[:2]) if len(parts) >= 2 else address
+
+
 def _sold_comps_rows(rows: list[dict]) -> str:
     if not rows:
         return '<tr><td colspan="4" class="muted">No sold transactions in the sample.</td></tr>'
@@ -49,31 +67,6 @@ def _asking_comps_tiles(rows: list[dict]) -> str:
     return "".join(out)
 
 
-def _crime_rows(rows: list[dict]) -> str:
-    if not rows:
-        return '<div class="muted">No crime data.</div>'
-    top = sorted(rows, key=lambda r: r["count"], reverse=True)[:6]
-    cap = max((r["count"] for r in top), default=1) or 1
-    return "".join(
-        f'<div class="dist-row">'
-        f'<div class="name">{html.escape(r["category"])}</div>'
-        f'<div class="bar"><span{" class=gold" if i == 0 else ""} style="width:{int(100 * r["count"] / cap)}%"></span></div>'
-        f'<div class="pct">{r["count"]}</div>'
-        f"</div>"
-        for i, r in enumerate(top)
-    )
-
-
-def _band_rows(rows: list[dict]) -> str:
-    if not rows:
-        return '<tr><td colspan="2" class="muted">No banding data.</td></tr>'
-    return "".join(
-        f"<tr><td>Band {html.escape(r['band'])}</td>"
-        f"<td class=\"num\">{_money(r['amount'])}</td></tr>"
-        for r in rows
-    )
-
-
 def _type_dist_rows(rows: list[dict]) -> str:
     if not rows:
         return '<div class="muted">No property-type mix data.</div>'
@@ -89,7 +82,7 @@ def _type_dist_rows(rows: list[dict]) -> str:
 
 
 def _spark_svg(price_series: list[dict], psf_series: list[dict]) -> str:
-    """Two-line sparkline in a 1000x380 viewBox SVG, no external dependencies."""
+    """Two-line sparkline in a 1000x380 viewBox SVG, no external deps."""
     W, H = 1000, 380
     pad_l, pad_r, pad_t, pad_b = 70, 30, 30, 50
     iw, ih = W - pad_l - pad_r, H - pad_t - pad_b
@@ -102,9 +95,7 @@ def _spark_svg(price_series: list[dict], psf_series: list[dict]) -> str:
         if ymax == ymin:
             ymax = ymin + 1
         n = len(series)
-        pts = []
-        circles = []
-        labels = []
+        pts, circles, labels = [], [], []
         for i, p in enumerate(series):
             x = pad_l + (i * iw / max(1, n - 1))
             y = pad_t + ih - ((float(p[key]) - ymin) / (ymax - ymin)) * ih
@@ -115,8 +106,7 @@ def _spark_svg(price_series: list[dict], psf_series: list[dict]) -> str:
             )
         return (
             f'<polyline class="{css_pl}" points="{" ".join(pts)}"/>'
-            + "".join(circles)
-            + "".join(labels)
+            + "".join(circles) + "".join(labels)
         )
 
     axis = (
@@ -128,54 +118,406 @@ def _spark_svg(price_series: list[dict], psf_series: list[dict]) -> str:
     )
 
 
+def _summary_paragraphs(paras: list[str]) -> str:
+    if not paras:
+        return ""
+    out = [f'<p class="dropcap">{html.escape(paras[0])}</p>']
+    for p in paras[1:]:
+        out.append(f"<p>{html.escape(p)}</p>")
+    return "".join(out)
+
+
+def _wordmark(brand: dict, variant: str, out_dir: Path) -> str:
+    """variant ∈ {'light', 'dark'}. Mirrors property-market-report's wordmark."""
+    key = "logo_light" if variant == "light" else "logo_dark"
+    logo_path = brand.get(key)
+    if logo_path:
+        src = Path(logo_path).expanduser()
+        dest_dir = out_dir / "img"
+        dest_dir.mkdir(parents=True, exist_ok=True)
+        dest = dest_dir / src.name
+        if src.resolve() != dest.resolve():
+            shutil.copy2(src, dest)
+        rel = f"img/{src.name}"
+        height = "14mm" if variant == "light" else "9mm"
+        return f'<img src="{html.escape(rel)}" alt="{html.escape(brand["name"])}" style="height:{height};width:auto;display:block">'
+    cls = "wm light" if variant == "light" else "wm small"
+    return (
+        f'<div class="{cls}">'
+        f'<span class="wm-name">{html.escape(brand["name"])}</span>'
+        f'<span class="wm-sub">{html.escape(brand["tagline"])}</span>'
+        f"</div>"
+    )
+
+
+def _hero_asset(subject: dict, out_dir: Path) -> str:
+    """Copy subject.cover_hero into img/ and return the relative path. URLs pass through."""
+    hero = subject["cover_hero"]
+    if hero.startswith(("http://", "https://", "data:")):
+        return hero
+    src = Path(hero).expanduser()
+    if not src.exists():
+        raise FileNotFoundError(f"subject.cover_hero not found: {src}")
+    dest_dir = out_dir / "img"
+    dest_dir.mkdir(parents=True, exist_ok=True)
+    dest = dest_dir / f"hero{src.suffix.lower()}"
+    if src.resolve() != dest.resolve():
+        shutil.copy2(src, dest)
+    return f"img/{dest.name}"
+
+
+def _listing_card(p: dict, index: int, out_dir: Path) -> str:
+    addr_parts = [x.strip() for x in p["address"].split(",")]
+    addr = html.escape(addr_parts[0])
+    chips = []
+    if p.get("beds"):  chips.append(f"{p['beds']} bed")
+    if p.get("type"):  chips.append(html.escape(p["type"]))
+    chips_html = "".join(f"<span>{c}</span>" for c in chips)
+    img_src = ""
+    if p.get("image"):
+        src = Path(p["image"]).expanduser() if not str(p["image"]).startswith(("http://", "https://", "data:")) else None
+        if src and src.exists():
+            dest_dir = out_dir / "img"
+            dest_dir.mkdir(parents=True, exist_ok=True)
+            dest = dest_dir / f"agent-{index:02d}-{p['slug']}{src.suffix.lower()}"
+            if src.resolve() != dest.resolve():
+                shutil.copy2(src, dest)
+            img_src = f"img/{dest.name}"
+        elif src is None:
+            img_src = str(p["image"])
+    status = p.get("status", "")
+    badge_cls = {"Sold": "sold", "Under offer": "under"}.get(status, "")
+    photo = (
+        f'<div class="photo">'
+        f'{f"<img src=\"{html.escape(img_src)}\" alt=\"{addr}\">" if img_src else ""}'
+        f'<div class="badge {badge_cls}">{html.escape(status)}</div>'
+        f"</div>"
+    )
+    meta = (
+        f'<div class="meta">'
+        f'<div class="addr">{addr}</div>'
+        f'<div class="price">{_money(p["price"])}</div>'
+        f'<div class="kfs">{chips_html}</div>'
+        f"</div>"
+    )
+    inner = photo + meta
+    if p.get("url"):
+        return f'<a class="listing" href="{html.escape(p["url"])}" target="_blank" rel="noopener">{inner}</a>'
+    return f'<div class="listing">{inner}</div>'
+
+
+def _agent_listings_cards(rows: list[dict], out_dir: Path) -> str:
+    if not rows:
+        return '<div class="muted" style="margin-top:5mm">No recent listings supplied.</div>'
+    return "".join(_listing_card(p, i, out_dir) for i, p in enumerate(rows[:6]))
+
+
+# ---------------- valuation maths ----------------
+
+def _valuation_block(subject: dict, valuation: dict) -> str:
+    """Build the page-2 valuation panel: headline range, adjustments, final range.
+
+    sqft is asserted non-null upstream by _assert_inputs — no fallback panel here.
+    """
+    sqft = subject["sqft"]
+    low_psf  = valuation["sold_psf_low"]
+    mid_psf  = valuation["sold_psf"]
+    high_psf = valuation["sold_psf_high"]
+    ask_psf  = valuation["asking_psf"]
+
+    low_raw  = int(sqft * low_psf)
+    mid_raw  = int(sqft * mid_psf)
+    high_raw = int(sqft * high_psf)
+    ask_raw  = int(sqft * ask_psf)
+
+    rows = [
+        ('<div class="val-row headline">'
+         f'<div class="lbl">Headline range<small>{sqft:,} sqft × £{low_psf}–£{high_psf} sold £/sqft (Land Registry 70pc band)</small></div>'
+         f'<div class="num">{_range_money(low_raw, high_raw)}</div></div>'),
+        ('<div class="val-row">'
+         f'<div class="lbl">Cross-check · asking £/sqft<small>{sqft:,} sqft × £{ask_psf} mean asking £/sqft</small></div>'
+         f'<div class="num">{_money(ask_raw)}</div></div>'),
+    ]
+
+    adjustments = subject.get("adjustments") or []
+    if adjustments:
+        rows.append('<div class="val-row"><div class="lbl" style="font-family:var(--sans);font-weight:600;font-size:8pt;letter-spacing:2pt;text-transform:uppercase;color:var(--text-accent)">Adjustments</div><div class="num">&nbsp;</div></div>')
+        for adj in adjustments:
+            delta = float(adj["delta_pct"])
+            cls = "pos" if delta > 0 else ("neg" if delta < 0 else "")
+            sign = "+" if delta >= 0 else ""
+            rows.append(
+                '<div class="val-row adj">'
+                f'<div class="lbl">{html.escape(adj["label"])}</div>'
+                f'<div class="num {cls}">{sign}{delta:.1f}%</div>'
+                "</div>"
+            )
+
+    delta_sum = sum(float(a["delta_pct"]) for a in adjustments)
+    factor = 1.0 + delta_sum / 100.0
+    low_final  = int(low_raw  * factor)
+    high_final = int(high_raw * factor)
+
+    final = (
+        '<div class="val-final">'
+        f'<div class="lbl">Final indicative range</div>'
+        f'<div class="num">{_range_money(low_final, high_final)}</div>'
+        "</div>"
+    )
+
+    return '<div class="val-panel">' + "".join(rows) + "</div>" + final
+
+
+def _kpi_subject_sqft(subject: dict) -> tuple[str, str]:
+    sqft = subject["sqft"]
+    m2 = subject.get("sqft_m2")
+    sub = f"≈ {m2:.0f} m² · from EPC register" if m2 else "Square feet (operator)"
+    return f"{int(sqft):,}", sub
+
+
+def _kpi_subject_epc(subject: dict) -> tuple[str, str]:
+    current  = subject.get("epc_current")
+    potential = subject.get("epc_potential")
+    lodgement = subject.get("epc_lodgement")
+    if not current:
+        return "—", "No EPC on file"
+    sub_bits = []
+    if potential:
+        sub_bits.append(f"potential {potential}")
+    if lodgement:
+        sub_bits.append(f"lodged {lodgement}")
+    return current, " · ".join(sub_bits) or "EPC register"
+
+
+# ---------------- input assertions ----------------
+
+class PrevalAbort(RuntimeError):
+    """Raised when a load-bearing input is missing or unverifiable.
+
+    .cause is the short slug logged as `reason=<cause>` and shown in the
+    operator's remediation hint.
+    """
+    def __init__(self, cause: str, hint: str):
+        super().__init__(f"{cause}: {hint}")
+        self.cause = cause
+        self.hint = hint
+
+
+def _assert_path_image(path_str: str, min_w: int = 1200, min_h: int = 800) -> None:
+    """Existence + dimension check. Symlinks pointing into another property's
+    folder are rejected (cover-hero cross-contamination guard)."""
+    p = Path(path_str).expanduser()
+    if not p.exists():
+        raise PrevalAbort(
+            "subject-cover-hero-missing",
+            f"cover_hero path does not exist: {p}",
+        )
+    if p.is_symlink():
+        target = p.resolve()
+        parts = target.parts
+        if "properties" in parts:
+            # symlink → properties/<other-slug>/… is a cross-contamination
+            raise PrevalAbort(
+                "subject-cover-hero-symlinked-foreign",
+                f"cover_hero is a symlink into another property's folder: {target}",
+            )
+    # Dimensions. Avoid a Pillow dep; read PNG/JPEG headers directly.
+    w, h = _image_dimensions(p)
+    if w is None or h is None:
+        raise PrevalAbort(
+            "subject-cover-hero-unreadable",
+            f"cover_hero is not a readable PNG or JPEG: {p}",
+        )
+    if w < min_w or h < min_h:
+        raise PrevalAbort(
+            "subject-cover-hero-too-small",
+            f"cover_hero is {w}×{h}, below the {min_w}×{min_h} minimum: {p}",
+        )
+
+
+def _image_dimensions(p: Path) -> tuple[int | None, int | None]:
+    """Return (width, height) for PNG or JPEG. None on any failure."""
+    try:
+        with p.open("rb") as f:
+            head = f.read(24)
+            if len(head) < 24:
+                return None, None
+            if head[:8] == b"\x89PNG\r\n\x1a\n":
+                # IHDR width/height at bytes 16..24, big-endian uint32.
+                w = int.from_bytes(head[16:20], "big")
+                h = int.from_bytes(head[20:24], "big")
+                return w, h
+            if head[:2] == b"\xff\xd8":
+                f.seek(2)
+                while True:
+                    b = f.read(1)
+                    while b and b != b"\xff":
+                        b = f.read(1)
+                    marker = f.read(1)
+                    if not marker:
+                        return None, None
+                    if 0xC0 <= marker[0] <= 0xCF and marker[0] not in (0xC4, 0xC8, 0xCC):
+                        f.read(3)  # length(2) + precision(1)
+                        h = int.from_bytes(f.read(2), "big")
+                        w = int.from_bytes(f.read(2), "big")
+                        return w, h
+                    seg_len = int.from_bytes(f.read(2), "big")
+                    f.seek(seg_len - 2, 1)
+            return None, None
+    except OSError:
+        return None, None
+
+
+def _assert_inputs(inputs: dict) -> None:
+    """Fail loud on any missing or unverifiable load-bearing input.
+
+    Raises PrevalAbort with a named cause. No silent fallback paths.
+    """
+    subject = inputs.get("subject") or {}
+
+    # subject.sqft / sqft_m2 — required, non-null integers.
+    if not subject.get("sqft"):
+        raise PrevalAbort(
+            "subject-sqft-missing",
+            "subject.sqft is null — run epc-key-register and re-derive, or paste subject.sqft as an operator override before invocation.",
+        )
+    if not subject.get("sqft_m2"):
+        raise PrevalAbort(
+            "subject-sqft-m2-missing",
+            "subject.sqft_m2 is null — the EPC m² figure must be supplied alongside sqft.",
+        )
+
+    # subject.cover_hero — required, exists, ≥ 1200×800, not symlinked into another property's folder.
+    hero = subject.get("cover_hero")
+    if not hero:
+        raise PrevalAbort(
+            "subject-cover-hero-missing",
+            "subject.cover_hero is required for the cover page.",
+        )
+    if not hero.startswith(("http://", "https://", "data:")):
+        _assert_path_image(hero)
+
+    # brand — must be the resolved DESIGN.md object, not a stub.
+    brand = inputs.get("brand") or {}
+    required_brand = ("name", "tagline", "primary", "primary_dark", "accent", "paper", "paper_banded", "rule")
+    missing_brand = [k for k in required_brand if not brand.get(k)]
+    if missing_brand:
+        raise PrevalAbort(
+            "brand-unresolved",
+            f"brand is missing required token(s) {missing_brand} — resolve from the agent's on-disk DESIGN.md before invocation.",
+        )
+
+    # agent_listings — non-empty.
+    if not inputs.get("agent_listings"):
+        raise PrevalAbort(
+            "agent-listings-empty",
+            "agent_listings is empty — paste at least one recent listing for the closing page.",
+        )
+
+    # market_summary.paragraphs — at least 2.
+    paras = (inputs.get("market_summary") or {}).get("paragraphs") or []
+    if len(paras) < 2:
+        raise PrevalAbort(
+            "market-summary-too-thin",
+            f"market_summary.paragraphs has {len(paras)} entries — minimum 2.",
+        )
+
+
+# ---------------- render ----------------
+
 def render(inputs: dict, out_dir: Path, template_path: Path | None = None) -> Path:
+    _assert_inputs(inputs)
+
     template_path = template_path or (Path(__file__).parent / "template.html")
     tmpl = template_path.read_text()
 
-    v = inputs["valuation"]
-    a = inputs["area"]
-    d = inputs["demand_trend"]
-    r = d["rental"]
+    brand   = inputs["brand"]
+    subject = inputs["subject"]
+    v       = inputs["valuation"]
+    a       = inputs["area"]
+    d       = inputs["demand_trend"]
+    ms      = inputs["market_summary"]
+    r       = d["rental"]
+
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    subject_sqft, subject_sqft_sub = _kpi_subject_sqft(subject)
+    subject_epc,  subject_epc_sub  = _kpi_subject_epc(subject)
+
+    yoy = d.get("yoy_growth_pct")
+    if yoy is None and len(d.get("growth_series", [])) >= 2:
+        last, prev = d["growth_series"][-1]["price"], d["growth_series"][-2]["price"]
+        yoy = (last - prev) / prev * 100.0
+    yoy_str = f"{yoy:+.1f}%" if yoy is not None else "—"
+
+    psf = d.get("sales_per_month")
+    if psf is None:
+        psf = max(1, round(d["for_sale"] / 7))  # crude fallback only when not provided
 
     slots = {
+        # branding
+        "brand_name":         brand["name"],
+        "brand_tagline":      brand["tagline"],
+        "brand_primary":      brand["primary"],
+        "brand_primary_dark": brand["primary_dark"],
+        "brand_accent":       brand["accent"],
+        "brand_paper":        brand["paper"],
+        "brand_paper_banded": brand["paper_banded"],
+        "brand_rule":         brand["rule"],
+        "wordmark_light":     _wordmark(brand, "light", out_dir),
+        "wordmark_dark":      _wordmark(brand, "dark",  out_dir),
+
+        # cover + header
+        "subject_hero_path":  _hero_asset(subject, out_dir),
         "address":            inputs["address"],
+        "address_short":      _short_address(inputs["address"]),
         "postcode":           inputs["postcode"],
         "generated":          inputs["generated"],
 
-        "kpi_avg_asking":     _money(v["avg_asking"]),
-        "kpi_asking_psf":     _money(v["asking_psf"]),
-        "kpi_avg_sold":       _money(v["avg_sold"]),
-        "kpi_sold_psf":       _money(v["sold_psf"]),
-        "sold_comps_rows":    _sold_comps_rows(v.get("sold_comps", [])),
-        "asking_comps_tiles": _asking_comps_tiles(v.get("asking_comps", [])),
-
-        "area_headline":      a["headline"],
-        "kpi_crime":          a["crime_rating"],
-        "kpi_flood":          a["flood_risk"],
-        "kpi_band_d":         _money(a["council_tax_band_d"]),
-        "kpi_population":     f"{int(a['population']):,}",
-        "crime_rows":         _crime_rows(a.get("crime_breakdown", [])),
-        "band_rows":          _band_rows(a.get("council_tax_bands", [])),
-
-        "kpi_demand_rating":  d["demand_rating"],
-        "kpi_dom":            str(d["dom"]),
-        "kpi_turnover":       f"{int(d['turnover_pct'])}%",
-        "kpi_for_sale":       str(d["for_sale"]),
-        "spark_svg":          _spark_svg(d.get("growth_series", []), d.get("growth_psf_series", [])),
-
-        "rental_rating":      r["demand_rating"],
-        "rental_dom":         str(r["dom"]),
-        "rental_turnover":    f"{int(r['turnover_pct'])}%",
-        "rental_for_rent":    str(r["for_rent"]),
-
-        "type_dist_rows":     _type_dist_rows(d.get("type_dist", [])),
+        # page 2 — subject valuation
+        "kpi_subject_sqft":     subject_sqft,
+        "kpi_subject_sqft_sub": subject_sqft_sub,
+        "kpi_subject_beds":     str(subject.get("beds") or "—"),
+        "kpi_subject_epc":      subject_epc,
+        "kpi_subject_epc_sub":  subject_epc_sub,
+        "kpi_subject_type":     subject.get("type") or "—",
+        "kpi_subject_tenure":   subject.get("tenure") or "Tenure unknown",
+        "valuation_block":      _valuation_block(subject, v),
+        "subject_narrative":    subject.get("narrative") or "",
+
+        # page 3 — market context
+        "summary_headline":     ms["headline"],
+        "summary_paragraphs":   _summary_paragraphs(ms["paragraphs"]),
+        "kpi_avg_asking":       _money(v["avg_asking"]),
+        "kpi_avg_sold":         _money(v["avg_sold"]),
+        "kpi_psf":              _money(v["asking_psf"]),
+        "kpi_yoy":              yoy_str,
+        "demand_rating":        d["demand_rating"],
+        "gauge_position":       ms["demand_gauge_position"],
+        "price_growth_note":    ms["price_growth_note"],
+        "demand_note":          ms["demand_note"],
+        "spark_svg":            _spark_svg(d.get("growth_series", []), d.get("growth_psf_series", [])),
+
+        # page 4 — comparables
+        "sold_comps_rows":      _sold_comps_rows(v.get("sold_comps", [])),
+        "asking_comps_tiles":   _asking_comps_tiles(v.get("asking_comps", [])),
+
+        # page 5 — agent listings + sources
+        "agent_listings_cards": _agent_listings_cards(inputs["agent_listings"], out_dir),
     }
 
-    # Escape free-form text slots that aren't already HTML fragments.
-    text_slots = {"address", "postcode", "generated", "area_headline", "kpi_crime", "kpi_flood",
-                  "kpi_demand_rating", "rental_rating"}
+    # Escape only the plain-text slots; HTML fragments pass through untouched.
+    text_slots = {
+        "address", "address_short", "postcode", "generated",
+        "brand_name", "brand_tagline",
+        "kpi_subject_beds", "kpi_subject_epc", "kpi_subject_epc_sub",
+        "kpi_subject_sqft", "kpi_subject_sqft_sub",
+        "kpi_subject_type", "kpi_subject_tenure",
+        "summary_headline", "demand_rating",
+        "price_growth_note", "demand_note", "subject_narrative",
+    }
     for k in text_slots:
-        slots[k] = html.escape(slots[k])
+        slots[k] = html.escape(str(slots[k]))
 
     out = tmpl
     for k, val in slots.items():
@@ -187,7 +529,6 @@ def render(inputs: dict, out_dir: Path, template_path: Path | None = None) -> Pa
             "template has unfilled placeholders: " + ", ".join(sorted(set(leftovers)))
         )
 
-    out_dir.mkdir(parents=True, exist_ok=True)
     out_path = out_dir / "index.html"
     out_path.write_text(out)
     return out_path
@@ -212,11 +553,10 @@ _PAGE_OBJ_RE = re.compile(rb"/Type\s*/Page(?![sA-Za-z])")
 
 
 def _count_pages(pdf_path: Path) -> int:
-    """Prefer pdfinfo (handles compressed object streams); fall back to a
-    raw `/Type /Page` byte scan when pdfinfo is not installed. The fallback
-    is correct for current Chrome `--print-to-pdf` output (no `/ObjStm`)
-    but would silently undercount if a future Chrome switches to compressed
-    page-object streams — hence pdfinfo first when available.
+    """pdfinfo first (handles /ObjStm-compressed page-object streams), with a
+    raw /Type /Page byte scan as fallback. The fallback is correct for current
+    Chrome --print-to-pdf output but would undercount if Chrome ever switches
+    to compressed page-object streams — hence pdfinfo first when present.
     """
     pdfinfo = shutil.which("pdfinfo")
     if pdfinfo:
@@ -231,13 +571,6 @@ def _count_pages(pdf_path: Path) -> int:
 
 
 def assert_page_count(pdf_path: Path, expected: int) -> int:
-    """Assert PDF page count == expected; raise RuntimeError otherwise.
-
-    Synchronous and reliable — does not depend on Spotlight (`mdls` returns
-    `(null)` until indexing finishes, which is async). Operators can still
-    verify externally with `mdls -name kMDItemNumberOfPages <pdf>` once
-    Spotlight catches up.
-    """
     n = _count_pages(pdf_path)
     if n != expected:
         raise RuntimeError(
@@ -247,16 +580,48 @@ def assert_page_count(pdf_path: Path, expected: int) -> int:
     return n
 
 
+def _abort(cause: str, hint: str, *, address: str, postcode: str, t0: float, out_dir: Path | None) -> None:
+    """Emit the abort log line, scrub any partial output, exit non-zero."""
+    ms = int((time.monotonic() - t0) * 1000)
+    print(
+        f'[preval] aborted reason={cause} address="{address}" postcode={postcode} ms={ms}',
+        file=sys.stderr,
+    )
+    print(hint, file=sys.stderr)
+    if out_dir is not None:
+        for name in ("index.html",):
+            p = out_dir / name
+            if p.exists():
+                p.unlink()
+        # Any PDF whose stem matches filename_stem would be a partial — caller passes the stem.
+    sys.exit(2)
+
+
 def main():
+    t0 = time.monotonic()
     if len(sys.argv) < 2:
         print("Usage: render.py <inputs.json>", file=sys.stderr)
         sys.exit(2)
     inputs = json.loads(Path(sys.argv[1]).read_text())
     out_dir = Path(inputs["out_dir"]).expanduser()
     base = inputs["filename_stem"]
-    render(inputs, out_dir)
-    pdf = render_pdf(out_dir, f"{base}.pdf")
-    pages = assert_page_count(pdf, 4)
+    address = inputs.get("address", "")
+    postcode = inputs.get("postcode", "")
+    try:
+        render(inputs, out_dir)
+        pdf = render_pdf(out_dir, f"{base}.pdf")
+        pages = assert_page_count(pdf, 5)
+    except PrevalAbort as e:
+        # Scrub partial PDF too, if rendered before page-count failure.
+        pdf_path = out_dir / f"{base}.pdf"
+        if pdf_path.exists():
+            pdf_path.unlink()
+        _abort(e.cause, e.hint, address=address, postcode=postcode, t0=t0, out_dir=out_dir)
+    except RuntimeError as e:
+        pdf_path = out_dir / f"{base}.pdf"
+        if pdf_path.exists():
+            pdf_path.unlink()
+        _abort("render-error", str(e), address=address, postcode=postcode, t0=t0, out_dir=out_dir)
     print(f"HTML  → {out_dir/'index.html'}")
     print(f"PDF   → {pdf} ({pages} pages)")