@rubytech/create-maxy-code 0.1.62 → 0.1.64

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

@@ -1,630 +0,0 @@
-"""property-preval renderer.
-
-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 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, 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>'
-    return "".join(
-        f"<tr><td>{html.escape(r['date'])}</td>"
-        f"<td>{html.escape(r['address'])}</td>"
-        f"<td>{html.escape(r['type'])}</td>"
-        f"<td class=\"num\">{_money(r['price'])}</td></tr>"
-        for r in rows[:6]
-    )
-
-
-def _asking_comps_tiles(rows: list[dict]) -> str:
-    if not rows:
-        return '<div class="muted">No live asking comps in the sample.</div>'
-    out = []
-    for r in rows[:4]:
-        meta_bits = []
-        if r.get("beds"):
-            meta_bits.append(f"{r['beds']} bed")
-        if r.get("type"):
-            meta_bits.append(html.escape(r["type"]))
-        meta = " · ".join(meta_bits) or "&nbsp;"
-        out.append(
-            f'<div class="ask-tile">'
-            f'<div class="addr">{html.escape(r["address"])}</div>'
-            f'<div class="price">{_money(r["price"])}</div>'
-            f'<div class="meta">{meta}</div>'
-            f"</div>"
-        )
-    return "".join(out)
-
-
-def _type_dist_rows(rows: list[dict]) -> str:
-    if not rows:
-        return '<div class="muted">No property-type mix data.</div>'
-    ordered = sorted(rows, key=lambda r: float(r["pct"]), reverse=True)
-    return "".join(
-        f'<div class="dist-row">'
-        f'<div class="name">{html.escape(r["name"])}</div>'
-        f'<div class="bar"><span{" class=gold" if i == 0 else ""} style="width:{float(r["pct"]):.0f}%"></span></div>'
-        f'<div class="pct">{float(r["pct"]):.1f}%</div>'
-        f"</div>"
-        for i, r in enumerate(ordered)
-    )
-
-
-def _spark_svg(price_series: list[dict], psf_series: list[dict]) -> str:
-    """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
-
-    def _line(series, key, css_pl, css_pt):
-        if not series:
-            return ""
-        ys = [float(p[key]) for p in series]
-        ymin, ymax = min(ys), max(ys)
-        if ymax == ymin:
-            ymax = ymin + 1
-        n = len(series)
-        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
-            pts.append(f"{x:.1f},{y:.1f}")
-            circles.append(f'<circle class="{css_pt}" cx="{x:.1f}" cy="{y:.1f}" r="3"/>')
-            labels.append(
-                f'<text x="{x:.1f}" y="{H - 18}" text-anchor="middle">{html.escape(p["label"])}</text>'
-            )
-        return (
-            f'<polyline class="{css_pl}" points="{" ".join(pts)}"/>'
-            + "".join(circles) + "".join(labels)
-        )
-
-    axis = (
-        f'<line class="axis" x1="{pad_l}" y1="{pad_t + ih}" x2="{W - pad_r}" y2="{pad_t + ih}"/>'
-    )
-    body = axis + _line(price_series, "price", "pl", "pt") + _line(psf_series, "psf", "pl-psf", "pt-psf")
-    return (
-        f'<svg class="spark" viewBox="0 0 {W} {H}" preserveAspectRatio="none" xmlns="http://www.w3.org/2000/svg">{body}</svg>'
-    )
-
-
-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()
-
-    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"],
-
-        # 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 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(str(slots[k]))
-
-    out = tmpl
-    for k, val in slots.items():
-        out = out.replace(f"<!-- REPLACE: {k} -->", val)
-
-    leftovers = re.findall(r"<!-- REPLACE: (\w+) -->", out)
-    if leftovers:
-        raise RuntimeError(
-            "template has unfilled placeholders: " + ", ".join(sorted(set(leftovers)))
-        )
-
-    out_path = out_dir / "index.html"
-    out_path.write_text(out)
-    return out_path
-
-
-def render_pdf(out_dir: Path, pdf_name: str) -> Path:
-    chrome = "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"
-    if not Path(chrome).exists():
-        raise FileNotFoundError(
-            "Chrome not found at " + chrome + " — install Chrome or override the path."
-        )
-    pdf_path = out_dir / pdf_name
-    subprocess.run([
-        chrome, "--headless", "--disable-gpu", "--no-pdf-header-footer",
-        f"--print-to-pdf={pdf_path.resolve()}", "--virtual-time-budget=30000",
-        f"file://{(out_dir / 'index.html').resolve()}",
-    ], check=True, capture_output=True)
-    return pdf_path
-
-
-_PAGE_OBJ_RE = re.compile(rb"/Type\s*/Page(?![sA-Za-z])")
-
-
-def _count_pages(pdf_path: Path) -> int:
-    """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:
-        result = subprocess.run(
-            [pdfinfo, str(pdf_path)], check=True, capture_output=True, text=True,
-        )
-        for line in result.stdout.splitlines():
-            if line.startswith("Pages:"):
-                return int(line.split(":", 1)[1].strip())
-        raise RuntimeError(f"pdfinfo emitted no Pages line for {pdf_path}")
-    return len(_PAGE_OBJ_RE.findall(pdf_path.read_bytes()))
-
-
-def assert_page_count(pdf_path: Path, expected: int) -> int:
-    n = _count_pages(pdf_path)
-    if n != expected:
-        raise RuntimeError(
-            f"page-count mismatch: expected {expected}, got {n} ({pdf_path}) — "
-            "tighten panel padding for the overflowing page"
-        )
-    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"]
-    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)")
-
-
-if __name__ == "__main__":
-    main()