Add files using upload-large-folder tool

derived/Source/hf_dataset/dataset_info.json

@@ -2,6 +2,212 @@
   "citation": "",
   "description": "",
   "features": {
+    "record_id": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "source_dataset": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "source_repo": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "source_split": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "source_parquet": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "source_row_index": {
+      "dtype": "int64",
+      "_type": "Value"
+    },
+    "source_id": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "source_uri": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "source_origin": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "caption": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "description": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "code": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "image": {
+      "_type": "Image"
+    },
+    "width": {
+      "dtype": "int32",
+      "_type": "Value"
+    },
+    "height": {
+      "dtype": "int32",
+      "_type": "Value"
+    },
+    "full_code_hash": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "tikz_body_hash": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "caption_hash": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "image_pixels_sha256": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "image_phash": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "dedup_cluster_id": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "structural_version": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "extraction_branch": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "parse_status": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "circuit_ir_json": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "parse_warnings_json": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "unsupported_constructs_json": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "component_count": {
+      "dtype": "int64",
+      "_type": "Value"
+    },
+    "pin_count": {
+      "dtype": "int64",
+      "_type": "Value"
+    },
+    "net_count": {
+      "dtype": "int64",
+      "_type": "Value"
+    },
+    "wire_count": {
+      "dtype": "int64",
+      "_type": "Value"
+    },
+    "label_count": {
+      "dtype": "int64",
+      "_type": "Value"
+    },
+    "render_check_json": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "render_check_status": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "no_label": {
+      "_type": "Image"
+    },
+    "no_label_render_json": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "overlay_check_json": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "original_render_check_json": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "quality_bucket": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "keep_for_modeling": {
+      "dtype": "bool",
+      "_type": "Value"
+    },
+    "quality_reasons_json": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "source_group": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "graph_metrics_json": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "graph_underconnected_components_json": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "graph_overlapping_active_components_json": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "graph_reasons_core_json": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "graph_reasons_pretty_json": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "graph_reasons_pretty_render_json": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "graph_keep_graph_sane": {
+      "dtype": "bool",
+      "_type": "Value"
+    },
+    "graph_keep_graph_sane_pretty": {
+      "dtype": "bool",
+      "_type": "Value"
+    },
+    "graph_keep_graph_sane_pretty_render": {
+      "dtype": "bool",
+      "_type": "Value"
+    },
+    "graph_quality_bucket": {
+      "dtype": "string",
+      "_type": "Value"
+    },
     "Circuit Generation Code": {
       "dtype": "string",
       "_type": "Value"

derived/Source/hf_dataset/state.json

@@ -4,7 +4,7 @@
       "filename": "data-00000-of-00001.arrow"
     }
   ],
-  "_fingerprint": "545a5d8fc5886e81",
+  "_fingerprint": "12dbf5a6aed9fa0d",
   "_format_columns": null,
   "_format_kwargs": {},
   "_format_type": null,

derived/Source/metadata/graph_summary.json

@@ -0,0 +1,82 @@
+{
+  "active_component_count_histogram": {
+    "0": 29,
+    "1": 171,
+    "10": 34,
+    "11": 27,
+    "12": 24,
+    "13": 14,
+    "14": 13,
+    "15": 9,
+    "16": 28,
+    "17": 2,
+    "18": 3,
+    "19": 7,
+    "2": 309,
+    "20": 3,
+    "21": 6,
+    "22": 3,
+    "23": 3,
+    "25": 3,
+    "26": 3,
+    "28": 5,
+    "3": 236,
+    "30": 1,
+    "31": 1,
+    "32": 5,
+    "36": 1,
+    "39": 1,
+    "4": 282,
+    "42": 1,
+    "44": 2,
+    "47": 1,
+    "5": 216,
+    "51": 1,
+    "6": 133,
+    "65": 1,
+    "67": 1,
+    "7": 81,
+    "8": 76,
+    "84": 1,
+    "86": 1,
+    "9": 38
+  },
+  "graph_quality_bucket_counts": {
+    "graph_reject": 1545,
+    "graph_sane_keep": 4,
+    "graph_sane_pretty_keep": 21,
+    "graph_sane_pretty_render_keep": 206
+  },
+  "quality_bucket_counts": {
+    "jank": 1530,
+    "well_generated": 246
+  },
+  "rows": 1776,
+  "top_graph_core_reasons": {
+    "active_component_span_overlap": 4,
+    "electrical_component_count_zero": 29,
+    "electrical_component_underconnected": 492,
+    "electrical_graph_components_gt_1": 975,
+    "one_pin_active_net_present": 1244,
+    "unrecognized_component_present": 985
+  },
+  "top_graph_pretty_reasons": {
+    "active_component_span_overlap": 4,
+    "electrical_component_count_zero": 29,
+    "electrical_component_underconnected": 492,
+    "electrical_graph_components_gt_1": 975,
+    "one_pin_active_net_present": 1244,
+    "unrecognized_component_present": 985,
+    "word_count_gt_50": 83
+  },
+  "top_graph_pretty_render_reasons": {
+    "active_component_span_overlap": 4,
+    "electrical_component_count_zero": 29,
+    "electrical_component_underconnected": 492,
+    "electrical_graph_components_gt_1": 975,
+    "one_pin_active_net_present": 1244,
+    "render_alignment_weak": 218,
+    "unrecognized_component_present": 985,
+    "word_count_gt_50": 83
+  }
+}

derived/Source/scripts/build_circuit_dataset.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import argparse
+import hashlib
 import json
 import math
 import os
@@ -13,6 +14,7 @@ import tarfile
 import urllib.parse
 import urllib.request
 import warnings
+from collections import Counter, defaultdict
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from dataclasses import dataclass
 from pathlib import Path
@@ -27,6 +29,22 @@ from PIL import Image, ImageChops
 
 PNG_DPI = 120
 DEFAULT_LIII_PDF_URL = "https://www.ibiblio.org/kuphaldt/socratic/sinst/book/liii_2v16.pdf"
+STRUCTURAL_VERSION = "schemid_source_structural_v1"
+EXTRACTION_BRANCH = "xcircuit_eps_ir_v1"
+SOURCE_DATASET_NAME = "schemid_source_available"
+SOURCE_REPO_ID = "lsnu/SchemID"
+SOURCE_SPLIT = "train"
+SOURCE_ORIGIN = "xcircuit_eps"
+SOURCE_GROUP = "non_cosyn"
+PAGE_SCOPE_ID = "page_001"
+COORD_SNAP = 0.75
+PHASH_SIZE = 8
+PHASH_HIGHFREQ = 32
+GRAPH_WORD_COUNT_MAX = 50
+GRAPH_TEXT_FRACTION_MAX = 0.18
+GRAPH_RENDER_MAE_MAX = 3.0
+GRAPH_RENDER_PHASH_MAX = 8
+GRAPH_DECORATIVE_MAX = 1
 NO_TEXT_PS_OVERRIDE = (
     "\n"
     "/show { pop } bind def\n"
@@ -98,6 +116,72 @@ PROC_BBOX_CATALOG: dict[str, tuple[int, int, int, int]] = {
     "resistor": (-14, -64, 28, 128),
     "source": (-32, -64, 64, 128),
 }
+PROCEDURE_KIND_MAP: dict[str, tuple[str, str]] = {
+    "LED": ("indicator", "led"),
+    "acsource": ("source", "ac_source"),
+    "and_gate": ("logic", "logic_gate"),
+    "arrow": ("decorative", "arrow"),
+    "arrowhead": ("decorative", "arrowhead"),
+    "battery": ("source", "voltage_source"),
+    "breadboard": ("block", "breadboard"),
+    "capacitor": ("passive", "capacitor"),
+    "capacitor1": ("passive", "capacitor"),
+    "circle": ("io", "terminal"),
+    "diode": ("semiconductor", "diode"),
+    "dip_8": ("logic", "integrated_circuit"),
+    "dot": ("junction", "junction"),
+    "fuse_blown": ("protection", "fuse"),
+    "gnd": ("ground", "ground"),
+    "indicator": ("indicator", "indicator"),
+    "inductor": ("passive", "inductor"),
+    "invert": ("logic", "logic_gate"),
+    "jumper": ("switch", "jumper"),
+    "nand": ("logic", "logic_gate"),
+    "njf": ("semiconductor", "transistor"),
+    "no_contact": ("io", "terminal"),
+    "npn": ("semiconductor", "transistor"),
+    "opamp": ("active", "op_amp"),
+    "or_gate": ("logic", "logic_gate"),
+    "pnp": ("semiconductor", "transistor"),
+    "potentiometer": ("passive", "potentiometer"),
+    "potentiometer1": ("passive", "potentiometer"),
+    "real_batt": ("source", "voltage_source"),
+    "resistor": ("passive", "resistor"),
+    "resistor4": ("passive", "resistor"),
+    "source": ("source", "voltage_source"),
+    "transistor2": ("semiconductor", "transistor"),
+}
+ELECTRICAL_FAMILIES = {
+    "active",
+    "passive",
+    "source",
+    "semiconductor",
+    "switch",
+    "indicator",
+    "protection",
+    "ground",
+    "io",
+    "junction",
+    "logic",
+}
+MIN_CONNECTED_PINS = {
+    "ac_source": 2,
+    "capacitor": 2,
+    "diode": 2,
+    "fuse": 2,
+    "ground": 1,
+    "integrated_circuit": 2,
+    "inductor": 2,
+    "junction": 1,
+    "led": 2,
+    "logic_gate": 2,
+    "op_amp": 3,
+    "potentiometer": 3,
+    "resistor": 2,
+    "terminal": 1,
+    "transistor": 3,
+    "voltage_source": 2,
+}
 STRIP_INVOCATION_PROCEDURES = {"person", "person_shocked"}
 NON_CIRCUIT_SOURCE_PATTERNS: tuple[tuple[re.Pattern[str], str], ...] = (
     (
@@ -147,7 +231,7 @@ FULL_INVOCATION_LINE_RE = re.compile(
     r"^\s*(?P<scale>-?\d+(?:\.\d+)?)\s+(?P<rot>-?\d+(?:\.\d+)?)\s+"
     r"(?P<x>-?\d+(?:\.\d+)?)\s+(?P<y>-?\d+(?:\.\d+)?)\s+"
     r"(?P<name>[A-Za-z][A-Za-z0-9_]*)\s*$"
-)
+, re.M)
 SML_TOKEN_RE = re.compile(
     r"(?P<chapter><chaptertitle>(?P<chapter_text>.*?)</chaptertitle>)"
     r"|(?P<section><sectiontitle>(?P<section_text>.*?)</sectiontitle>)"
@@ -160,6 +244,15 @@ LATEX_SECTION_RE = re.compile(
 LATEX_INCLUDE_RE = re.compile(
     r"\\includegraphics(?:\[[^]]*\])?\{(?P<name>[^}]+\.eps)\}"
 )
+LABEL_COMMAND_RE = re.compile(
+    r"(?P<raw>(?P<content>(?:\((?:\\.|[^\\)])*\)|\{[^{}]*\}|\s+)+?)\s+"
+    r"(?P<count>\d+)\s+(?P<just>-?\d+)\s+(?P<rot>-?\d+(?:\.\d+)?)\s+"
+    r"(?:(?P<scale>-?\d+(?:\.\d+)?)\s+)?"
+    r"(?P<x>-?\d+(?:\.\d+)?)\s+(?P<y>-?\d+(?:\.\d+)?)\s+"
+    r"(?P<kind>label|pinlabel|pinglobal|infolabel)\b)",
+    re.S,
+)
+PS_STRING_RE = re.compile(r"\((?:\\.|[^\\)])*\)")
 
 warnings.filterwarnings(
     "ignore",
@@ -591,6 +684,1099 @@ def parse_page_transform(source_code: str) -> tuple[tuple[float, float, float, f
     return bbox, scale, tx, ty
 
 
+def dumps_json(value: Any) -> str:
+    return json.dumps(value, ensure_ascii=True, sort_keys=True)
+
+
+def sha256_text(text: str) -> str:
+    return hashlib.sha256(text.encode("utf-8")).hexdigest()
+
+
+def sha256_bytes(data: bytes) -> str:
+    return hashlib.sha256(data).hexdigest()
+
+
+def normalize_code_for_hash(source_code: str) -> str:
+    return "\n".join(line.rstrip() for line in source_code.strip().splitlines())
+
+
+def normalize_body_for_hash(source_code: str) -> str:
+    page_parts = split_page_body(source_code)
+    if not page_parts:
+        return normalize_code_for_hash(source_code)
+    return normalize_code_for_hash(page_parts[1])
+
+
+def image_pixel_sha256(path: Path) -> str:
+    with Image.open(path) as image:
+        rgba = image.convert("RGBA")
+        return sha256_bytes(rgba.tobytes())
+
+
+def image_dimensions(path: Path) -> tuple[int, int]:
+    with Image.open(path) as image:
+        return image.size
+
+
+def _dct_matrix(size: int) -> np.ndarray:
+    matrix = np.zeros((size, size), dtype=np.float64)
+    factor = math.pi / (2.0 * size)
+    scale0 = math.sqrt(1.0 / size)
+    scale = math.sqrt(2.0 / size)
+    for k in range(size):
+        alpha = scale0 if k == 0 else scale
+        for n in range(size):
+            matrix[k, n] = alpha * math.cos((2 * n + 1) * k * factor)
+    return matrix
+
+
+_PHASH_DCT = _dct_matrix(PHASH_HIGHFREQ)
+
+
+def compute_image_phash(path: Path) -> str:
+    with Image.open(path) as image:
+        gray = image.convert("L").resize((PHASH_HIGHFREQ, PHASH_HIGHFREQ))
+        pixels = np.asarray(gray, dtype=np.float64)
+    transformed = _PHASH_DCT @ pixels @ _PHASH_DCT.T
+    low_freq = transformed[:PHASH_SIZE, :PHASH_SIZE]
+    flat = low_freq.flatten()
+    median = float(np.median(flat[1:])) if flat.size > 1 else float(flat[0])
+    bits = "".join("1" if value > median else "0" for value in flat)
+    return f"{int(bits, 2):0{len(bits) // 4}x}"
+
+
+def phash_distance(left: str | None, right: str | None) -> int | None:
+    if not left or not right:
+        return None
+    return (int(left, 16) ^ int(right, 16)).bit_count()
+
+
+def compare_image_paths(rendered_path: Path, reference_path: Path | None) -> dict[str, Any]:
+    if not reference_path or not reference_path.exists():
+        return {"status": "not_run"}
+
+    with Image.open(rendered_path) as rendered_img, Image.open(reference_path) as reference_img:
+        rendered = rendered_img.convert("RGBA")
+        reference = reference_img.convert("RGBA")
+        stored_size = list(reference.size)
+        rendered_size = list(rendered.size)
+        if rendered.size != reference.size:
+            reference = reference.resize(rendered.size)
+        diff = ImageChops.difference(rendered, reference).convert("L")
+        histogram = diff.histogram()
+        total_pixels = max(1, rendered.width * rendered.height)
+        diff_sum = int(sum(index * value for index, value in enumerate(histogram)))
+        mae = round(diff_sum / float(total_pixels), 6)
+        match = diff.getbbox() is None
+    rendered_hash = compute_image_phash(rendered_path)
+    reference_hash = compute_image_phash(reference_path)
+    return {
+        "status": "ok",
+        "match": match,
+        "mae": mae,
+        "phash_distance": phash_distance(rendered_hash, reference_hash),
+        "rendered_size": rendered_size,
+        "stored_size": stored_size,
+    }
+
+
+def decode_ps_string(raw: str) -> str:
+    if raw.startswith("(") and raw.endswith(")"):
+        raw = raw[1:-1]
+    out: list[str] = []
+    index = 0
+    while index < len(raw):
+        char = raw[index]
+        if char != "\\":
+            out.append(char)
+            index += 1
+            continue
+        index += 1
+        if index >= len(raw):
+            break
+        escaped = raw[index]
+        if escaped in "()\\":
+            out.append(escaped)
+            index += 1
+            continue
+        if escaped == "n":
+            out.append("\n")
+            index += 1
+            continue
+        if escaped == "r":
+            out.append("\r")
+            index += 1
+            continue
+        if escaped == "t":
+            out.append("\t")
+            index += 1
+            continue
+        if escaped.isdigit():
+            octal = escaped
+            for _ in range(2):
+                if index + 1 < len(raw) and raw[index + 1].isdigit():
+                    index += 1
+                    octal += raw[index]
+                else:
+                    break
+            out.append(chr(int(octal, 8)))
+            index += 1
+            continue
+        out.append(escaped)
+        index += 1
+    return normalize_space("".join(out).replace("\n", " "))
+
+
+def extract_label_strings(content: str) -> list[str]:
+    return [decode_ps_string(match.group(0)) for match in PS_STRING_RE.finditer(content)]
+
+
+def parse_visible_labels(body: str) -> list[dict[str, Any]]:
+    labels: list[dict[str, Any]] = []
+    for match in LABEL_COMMAND_RE.finditer(body):
+        if match.group("kind") not in {"label", "pinlabel", "pinglobal"}:
+            continue
+        parts = [value for value in extract_label_strings(match.group("content")) if value]
+        labels.append(
+            {
+                "raw": normalize_space(match.group("raw")),
+                "kind": match.group("kind"),
+                "text": normalize_space(" ".join(parts)),
+                "x": float(match.group("x")),
+                "y": float(match.group("y")),
+                "scale": float(match.group("scale")) if match.group("scale") else 1.0,
+                "rotation": float(match.group("rot")),
+            }
+        )
+    return labels
+
+
+def parse_symbol_procedures(source_code: str) -> dict[str, str]:
+    lines = source_code.splitlines()
+    procedures: dict[str, str] = {}
+    index = 0
+    while index < len(lines):
+        line = lines[index]
+        if line.startswith("/") and line.rstrip().endswith("{"):
+            name = line[1:].split("{", 1)[0].strip()
+            depth = line.count("{") - line.count("}")
+            body_lines: list[str] = []
+            index += 1
+            while index < len(lines):
+                current = lines[index]
+                depth += current.count("{") - current.count("}")
+                if depth <= 0 and current.strip().endswith("def"):
+                    break
+                body_lines.append(current)
+                index += 1
+            procedures[name] = "\n".join(body_lines)
+        index += 1
+    return procedures
+
+
+def parse_symbol_pin_catalog(source_code: str) -> dict[str, list[dict[str, Any]]]:
+    pin_catalog: dict[str, list[dict[str, Any]]] = {}
+    for proc_name, body in parse_symbol_procedures(source_code).items():
+        entries: list[dict[str, Any]] = []
+        for match in LABEL_COMMAND_RE.finditer(body):
+            kind = match.group("kind")
+            if kind not in {"pinlabel", "pinglobal"}:
+                continue
+            strings = extract_label_strings(match.group("content"))
+            label_text = normalize_space(" ".join(strings))
+            entries.append(
+                {
+                    "label": label_text,
+                    "kind": "terminal" if kind == "pinlabel" else "global",
+                    "x": float(match.group("x")),
+                    "y": float(match.group("y")),
+                    "raw": normalize_space(match.group("raw")),
+                }
+            )
+        if entries:
+            pin_catalog[proc_name] = entries
+    return pin_catalog
+
+
+def component_family_kind(name: str) -> tuple[str, str]:
+    if name in PROCEDURE_KIND_MAP:
+        return PROCEDURE_KIND_MAP[name]
+    lower = name.lower()
+    if lower in {"clip", "label", "marks"} or lower.startswith("die_") or lower.startswith("truth_"):
+        return "decorative", lower
+    if "arrow" in lower:
+        return "decorative", lower
+    if "opamp" in lower or (lower.endswith("amp") and "lamp" not in lower):
+        return "active", "op_amp"
+    if name.endswith("_gate") or "gate" in lower or lower in {"nor", "buffer"} or "flipflop" in lower or lower.startswith("dip_"):
+        return "logic", "logic_gate"
+    if "resistor" in lower or lower == "strain_gauge":
+        return "passive", "resistor"
+    if "capacitor" in lower or "polarized" in lower:
+        return "passive", "capacitor"
+    if "inductor" in lower or "coil" in lower:
+        return "passive", "inductor"
+    if "transformer" in lower or lower == "core":
+        return "passive", "transformer"
+    if "battery" in lower or lower in {"vsource", "cell", "vdd", "vss", "vcc", "vee"}:
+        return "source", "voltage_source"
+    if "isource" in lower or "current" in lower:
+        return "source", "current_source"
+    if "switch" in lower or "toggle" in lower or "pushbutton" in lower or "contact" in lower:
+        return "switch", "switch"
+    if "diode" in lower or "mosfet" in lower or "jfet" in lower or lower in {"scr", "diode"} or "fet" in lower:
+        return "semiconductor", "transistor" if "fet" in lower or lower in {"scr"} else "diode"
+    if "lamp" in lower or "meter" in lower or "motor" in lower or "detector" in lower:
+        return "indicator", "indicator"
+    if "connector" in lower or "terminal" in lower or lower in {"stud", "tap", "powerpole"}:
+        return "io", "terminal"
+    if lower in {"fuse", "thermal_overload"}:
+        return "protection", "fuse"
+    if "relay" in lower:
+        return "switch", "relay"
+    return "unknown", name.lower()
+
+
+def classify_component(component: dict[str, Any]) -> str:
+    family = component.get("family", "unknown")
+    kind = component.get("kind", "unknown")
+    if family in {"ground", "io", "junction"}:
+        return "terminal"
+    if family in {"active", "passive", "source", "semiconductor", "switch", "indicator", "protection", "logic"}:
+        return "electrical"
+    if family == "block":
+        return "decorative"
+    if family == "unknown":
+        return "unknown_bad"
+    return "other_bad"
+
+
+def min_connected_pins(component: dict[str, Any]) -> int:
+    family = component.get("family", "unknown")
+    kind = component.get("kind", "unknown")
+    if kind in MIN_CONNECTED_PINS:
+        return MIN_CONNECTED_PINS[kind]
+    if family in {"active", "passive", "source", "semiconductor", "switch", "indicator", "protection", "logic"}:
+        return 2
+    return 1
+
+
+def transform_component_point(
+    x: float,
+    y: float,
+    *,
+    scale: float,
+    rotation_deg: float,
+    origin_x: float,
+    origin_y: float,
+    page_scale: float,
+    page_tx: float,
+    page_ty: float,
+) -> tuple[float, float]:
+    effective_scale = abs(scale)
+    radians = math.radians(rotation_deg)
+    scaled_x = x * effective_scale
+    scaled_y = y * effective_scale
+    rotated_x = scaled_x * math.cos(radians) - scaled_y * math.sin(radians)
+    rotated_y = scaled_x * math.sin(radians) + scaled_y * math.cos(radians)
+    global_x = page_scale * (page_tx + origin_x + rotated_x)
+    global_y = page_scale * (page_ty + origin_y + rotated_y)
+    return global_x, global_y
+
+
+def point_to_ref(x: float, y: float) -> str:
+    return f"coord:{PAGE_SCOPE_ID}:{x:.3f}:{y:.3f}"
+
+
+def point_payload(x: float, y: float) -> dict[str, float]:
+    return {"x": round(x, 3), "y": round(y, 3)}
+
+
+def bbox_from_points(points: list[tuple[float, float]]) -> tuple[float, float, float, float]:
+    xs = [point[0] for point in points]
+    ys = [point[1] for point in points]
+    return min(xs), min(ys), max(xs), max(ys)
+
+
+def bbox_intersects(
+    outer: tuple[float, float, float, float],
+    inner: tuple[float, float, float, float],
+    *,
+    margin: float = 0.0,
+) -> bool:
+    left, bottom, right, top = outer
+    in_left, in_bottom, in_right, in_top = inner
+    return not (
+        in_right < left - margin
+        or in_left > right + margin
+        or in_top < bottom - margin
+        or in_bottom > top + margin
+    )
+
+
+def point_inside_bbox(
+    point: tuple[float, float],
+    bbox: tuple[float, float, float, float],
+    *,
+    margin: float = 0.0,
+) -> bool:
+    x, y = point
+    left, bottom, right, top = bbox
+    return left - margin <= x <= right + margin and bottom - margin <= y <= top + margin
+
+
+def snap_key(point: tuple[float, float]) -> tuple[int, int]:
+    return (round(point[0] / COORD_SNAP), round(point[1] / COORD_SNAP))
+
+
+def _projection_fraction(
+    point: tuple[float, float],
+    start: tuple[float, float],
+    end: tuple[float, float],
+) -> float:
+    dx = end[0] - start[0]
+    dy = end[1] - start[1]
+    denom = dx * dx + dy * dy
+    if denom <= 1e-9:
+        return 0.0
+    return ((point[0] - start[0]) * dx + (point[1] - start[1]) * dy) / denom
+
+
+def point_on_segment(
+    point: tuple[float, float],
+    start: tuple[float, float],
+    end: tuple[float, float],
+    *,
+    tolerance: float = COORD_SNAP,
+) -> bool:
+    if start == end:
+        return math.dist(point, start) <= tolerance
+    t = _projection_fraction(point, start, end)
+    if t < -1e-6 or t > 1.0 + 1e-6:
+        return False
+    projected = (start[0] + t * (end[0] - start[0]), start[1] + t * (end[1] - start[1]))
+    return math.dist(projected, point) <= tolerance
+
+
+def segment_intersection(
+    start_a: tuple[float, float],
+    end_a: tuple[float, float],
+    start_b: tuple[float, float],
+    end_b: tuple[float, float],
+    *,
+    tolerance: float = COORD_SNAP,
+) -> tuple[float, float] | None:
+    ax1, ay1 = start_a
+    ax2, ay2 = end_a
+    bx1, by1 = start_b
+    bx2, by2 = end_b
+    denom = (ax1 - ax2) * (by1 - by2) - (ay1 - ay2) * (bx1 - bx2)
+    if abs(denom) <= 1e-9:
+        shared = [point for point in (start_a, end_a, start_b, end_b) if point_on_segment(point, start_a, end_a, tolerance=tolerance) and point_on_segment(point, start_b, end_b, tolerance=tolerance)]
+        if shared:
+            return min(shared)
+        return None
+    px = (
+        (ax1 * ay2 - ay1 * ax2) * (bx1 - bx2)
+        - (ax1 - ax2) * (bx1 * by2 - by1 * bx2)
+    ) / denom
+    py = (
+        (ax1 * ay2 - ay1 * ax2) * (by1 - by2)
+        - (ay1 - ay2) * (bx1 * by2 - by1 * bx2)
+    ) / denom
+    point = (px, py)
+    if point_on_segment(point, start_a, end_a, tolerance=tolerance) and point_on_segment(point, start_b, end_b, tolerance=tolerance):
+        return point
+    return None
+
+
+def sort_points_on_segment(
+    points: set[tuple[float, float]],
+    start: tuple[float, float],
+    end: tuple[float, float],
+) -> list[tuple[float, float]]:
+    return sorted(points, key=lambda point: _projection_fraction(point, start, end))
+
+
+def count_words(text: str) -> int:
+    return len(re.findall(r"[A-Za-z0-9_]+", text))
+
+
+def first_caption(refs: list[dict[str, Any]]) -> str | None:
+    for ref in refs:
+        caption = normalize_space(ref.get("caption") or "")
+        if caption:
+            return caption
+    return None
+
+
+def build_description(book: BookConfig, figure_stem: str, refs: list[dict[str, Any]]) -> str:
+    parts = [book.display_name, f"Figure {figure_stem}"]
+    if refs:
+        ref = refs[0]
+        for key in ("chapter", "section", "subsection"):
+            value = normalize_space(ref.get(key) or "")
+            if value:
+                parts.append(value)
+        caption = first_caption(refs)
+        if caption:
+            parts.append(caption)
+    return " | ".join(parts)
+
+
+def synthesize_component_spans(components: list[dict[str, Any]], pins: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    pins_by_component: dict[str, list[dict[str, Any]]] = defaultdict(list)
+    for pin in pins:
+        pins_by_component[pin["component_id"]].append(pin)
+
+    spans: list[dict[str, Any]] = []
+    span_index = 1
+    for component in components:
+        component_pins = pins_by_component.get(component["id"], [])
+        if len(component_pins) != 2:
+            continue
+        ordered = sorted(component_pins, key=lambda item: item["id"])
+        spans.append(
+            {
+                "id": f"wire_cmp_{span_index:04d}",
+                "kind": "component_span",
+                "conductive": False,
+                "draw_options": [component["kind"]],
+                "points": [
+                    {
+                        "kind": "coord",
+                        "raw": ordered[0]["point_ref"],
+                        "ref": ordered[0]["point_ref"],
+                        **ordered[0]["point"],
+                    },
+                    {
+                        "kind": "coord",
+                        "raw": ordered[1]["point_ref"],
+                        "ref": ordered[1]["point_ref"],
+                        **ordered[1]["point"],
+                    },
+                ],
+                "point_refs": [ordered[0]["point_ref"], ordered[1]["point_ref"]],
+                "raw": component["raw"],
+                "scope_id": PAGE_SCOPE_ID,
+                "component_id": component["id"],
+            }
+        )
+        span_index += 1
+    return spans
+
+
+def build_eps_ir(source_code: str) -> dict[str, Any]:
+    page_parts = split_page_body(source_code)
+    if not page_parts:
+        return {
+            "parse_status": "failed",
+            "circuit_ir_json": dumps_json({}),
+            "parse_warnings_json": dumps_json(["missing_page_body"]),
+            "unsupported_constructs_json": dumps_json([]),
+            "component_count": 0,
+            "pin_count": 0,
+            "net_count": 0,
+            "wire_count": 0,
+            "label_count": 0,
+        }
+
+    bbox, page_scale, page_tx, page_ty = parse_page_transform(source_code)
+    _, body, _ = page_parts
+    proc_pin_catalog = parse_symbol_pin_catalog(source_code)
+    proc_bbox_catalog = {
+        match.group("name"): (
+            int(match.group("x")),
+            int(match.group("y")),
+            int(match.group("w")),
+            int(match.group("h")),
+        )
+        for match in PROC_BBOX_RE.finditer(source_code)
+    }
+
+    components: list[dict[str, Any]] = []
+    pins: list[dict[str, Any]] = []
+    transforms: list[dict[str, Any]] = [
+        {
+            "scope_id": PAGE_SCOPE_ID,
+            "parent_scope_id": None,
+            "raw": f"bbox={bbox}",
+            "options": {
+                "page_scale": round(page_scale, 6),
+                "translate_x": round(page_tx, 3),
+                "translate_y": round(page_ty, 3),
+                "bounding_box": [round(value, 3) for value in bbox],
+            },
+        }
+    ]
+    warnings_list: list[str] = []
+    unsupported_constructs: list[str] = []
+
+    pin_index = 1
+    component_index = 1
+    for match in FULL_INVOCATION_LINE_RE.finditer(body):
+        proc_name = match.group("name")
+        family, kind = component_family_kind(proc_name)
+        origin_x = float(match.group("x"))
+        origin_y = float(match.group("y"))
+        rotation = float(match.group("rot"))
+        scale = float(match.group("scale"))
+
+        local_bbox = proc_bbox_catalog.get(proc_name) or PROC_BBOX_CATALOG.get(proc_name)
+        placed_bbox = None
+        if local_bbox:
+            bx, by, bw, bh = local_bbox
+            corners = [
+                transform_component_point(
+                    corner_x,
+                    corner_y,
+                    scale=scale,
+                    rotation_deg=rotation,
+                    origin_x=origin_x,
+                    origin_y=origin_y,
+                    page_scale=page_scale,
+                    page_tx=page_tx,
+                    page_ty=page_ty,
+                )
+                for corner_x, corner_y in (
+                    (bx, by),
+                    (bx + bw, by),
+                    (bx, by + bh),
+                    (bx + bw, by + bh),
+                )
+            ]
+            placed_bbox = bbox_from_points(corners)
+            if not bbox_intersects(bbox, placed_bbox, margin=COORD_SNAP):
+                continue
+
+        global_origin = transform_component_point(
+            0.0,
+            0.0,
+            scale=scale,
+            rotation_deg=rotation,
+            origin_x=origin_x,
+            origin_y=origin_y,
+            page_scale=page_scale,
+            page_tx=page_tx,
+            page_ty=page_ty,
+        )
+        if not point_inside_bbox(global_origin, bbox, margin=COORD_SNAP) and not placed_bbox:
+            continue
+
+        component_id = f"cmp_{component_index:04d}"
+        component_index += 1
+        component_payload = {
+            "id": component_id,
+            "family": family,
+            "kind": kind,
+            "raw_kind": proc_name,
+            "raw": normalize_space(match.group(0)),
+            "scope_id": PAGE_SCOPE_ID,
+            "point": point_payload(*global_origin),
+            "point_ref": point_to_ref(*global_origin),
+            "option_tokens": [proc_name],
+            "options_raw": proc_name,
+            "transform_id": f"xfm_{component_id}",
+        }
+        if placed_bbox:
+            component_payload["bbox"] = [round(value, 3) for value in placed_bbox]
+        components.append(component_payload)
+        transforms.append(
+            {
+                "scope_id": component_payload["transform_id"],
+                "parent_scope_id": PAGE_SCOPE_ID,
+                "raw": normalize_space(match.group(0)),
+                "options": {
+                    "procedure": proc_name,
+                    "scale": scale,
+                    "rotation": rotation,
+                    "origin_x": origin_x,
+                    "origin_y": origin_y,
+                    "bbox": component_payload.get("bbox"),
+                },
+            }
+        )
+
+        local_pins = proc_pin_catalog.get(proc_name, [])
+        if not local_pins and family in {"passive", "source", "indicator", "protection"} and local_bbox:
+            bx, by, bw, bh = local_bbox
+            if abs(bh) >= abs(bw):
+                local_pins = [
+                    {"label": "start", "kind": "terminal", "x": 0.0, "y": by + bh, "raw": "inferred"},
+                    {"label": "end", "kind": "terminal", "x": 0.0, "y": by, "raw": "inferred"},
+                ]
+            else:
+                local_pins = [
+                    {"label": "start", "kind": "terminal", "x": bx, "y": 0.0, "raw": "inferred"},
+                    {"label": "end", "kind": "terminal", "x": bx + bw, "y": 0.0, "raw": "inferred"},
+                ]
+        if not local_pins and family in {"junction", "io", "ground"}:
+            local_pins = [
+                {"label": kind, "kind": "terminal", "x": 0.0, "y": 0.0, "raw": "inferred"}
+            ]
+
+        if not local_pins and family != "decorative":
+            warnings_list.append(f"missing_pins:{proc_name}:{component_id}")
+
+        for pin_position, pin_info in enumerate(local_pins, start=1):
+            global_point = transform_component_point(
+                float(pin_info["x"]),
+                float(pin_info["y"]),
+                scale=scale,
+                rotation_deg=rotation,
+                origin_x=origin_x,
+                origin_y=origin_y,
+                page_scale=page_scale,
+                page_tx=page_tx,
+                page_ty=page_ty,
+            )
+            if not point_inside_bbox(global_point, bbox, margin=COORD_SNAP):
+                continue
+            name = pin_info["label"] or f"pin_{pin_position}"
+            pin_id = f"{component_id}.pin_{pin_index:04d}"
+            pin_index += 1
+            pins.append(
+                {
+                    "id": pin_id,
+                    "component_id": component_id,
+                    "name": name,
+                    "kind": pin_info.get("kind", "terminal"),
+                    "point": point_payload(*global_point),
+                    "point_ref": point_to_ref(*global_point),
+                    "raw": pin_info.get("raw"),
+                }
+            )
+
+    labels: list[dict[str, Any]] = []
+    label_index = 1
+    for label_info in parse_visible_labels(body):
+        point = (
+            page_scale * (page_tx + label_info["x"]),
+            page_scale * (page_ty + label_info["y"]),
+        )
+        if not point_inside_bbox(point, bbox, margin=COORD_SNAP):
+            continue
+        labels.append(
+            {
+                "id": f"lbl_{label_index:04d}",
+                "scope_id": PAGE_SCOPE_ID,
+                "raw": label_info["raw"],
+                "text": label_info["text"],
+                "point": point_payload(*point),
+                "point_ref": point_to_ref(*point),
+                "kind": label_info["kind"],
+            }
+        )
+        label_index += 1
+
+    wire_polylines: list[dict[str, Any]] = []
+    wire_index = 1
+    conductive_wire_ids: set[str] = set()
+    for line in body.splitlines():
+        stripped = line.strip()
+        if not stripped.endswith("polygon"):
+            continue
+        tokens = stripped.split()
+        if len(tokens) < 8:
+            unsupported_constructs.append(f"polygon:{stripped}")
+            continue
+        try:
+            style = int(float(tokens[0]))
+            line_width = float(tokens[1])
+            point_count = int(tokens[-2])
+            coords = [float(value) for value in tokens[2:-2]]
+        except ValueError:
+            unsupported_constructs.append(f"polygon:{stripped}")
+            continue
+        if len(coords) != point_count * 2:
+            unsupported_constructs.append(f"polygon_coord_mismatch:{stripped}")
+            continue
+        points = [
+            (
+                page_scale * (page_tx + coords[index]),
+                page_scale * (page_ty + coords[index + 1]),
+            )
+            for index in range(0, len(coords), 2)
+        ]
+        poly_bbox = bbox_from_points(points)
+        if not bbox_intersects(bbox, poly_bbox, margin=COORD_SNAP):
+            continue
+        conductive = bool(style & 1)
+        wire_id = f"wire_{wire_index:04d}"
+        wire_index += 1
+        if conductive:
+            conductive_wire_ids.add(wire_id)
+        wire_polylines.append(
+            {
+                "id": wire_id,
+                "kind": "wire" if conductive else "graphic_polyline",
+                "conductive": conductive,
+                "draw_options": [f"style:{style}", f"width:{line_width:g}"],
+                "points": [
+                    {
+                        "kind": "coord",
+                        "raw": f"({coords[index]:g},{coords[index + 1]:g})",
+                        "ref": point_to_ref(*point),
+                        **point_payload(*point),
+                    }
+                    for index, point in zip(range(0, len(coords), 2), points)
+                ],
+                "point_refs": [point_to_ref(*point) for point in points],
+                "raw": stripped,
+                "scope_id": PAGE_SCOPE_ID,
+            }
+        )
+
+    wire_polylines.extend(synthesize_component_spans(components, pins))
+
+    node_points: dict[tuple[int, int], tuple[float, float]] = {}
+    node_labels: dict[tuple[int, int], str] = {}
+    node_sources: dict[str, set[str]] = defaultdict(set)
+    graph_adjacency: dict[str, set[str]] = defaultdict(set)
+
+    def register_point(point: tuple[float, float]) -> str:
+        key = snap_key(point)
+        if key not in node_points:
+            node_points[key] = (round(point[0], 3), round(point[1], 3))
+            node_labels[key] = point_to_ref(*node_points[key])
+        return node_labels[key]
+
+    segments: list[dict[str, Any]] = []
+    for wire in wire_polylines:
+        if not wire.get("conductive"):
+            continue
+        points = [(float(point["x"]), float(point["y"])) for point in wire["points"]]
+        for start, end in zip(points, points[1:]):
+            segments.append({"wire_id": wire["id"], "start": start, "end": end, "split_points": {start, end}})
+
+    for segment in segments:
+        for pin in pins:
+            point = (float(pin["point"]["x"]), float(pin["point"]["y"]))
+            if point_on_segment(point, segment["start"], segment["end"]):
+                segment["split_points"].add(point)
+
+    for index, left in enumerate(segments):
+        for right in segments[index + 1 :]:
+            intersection = segment_intersection(left["start"], left["end"], right["start"], right["end"])
+            if intersection is None:
+                continue
+            left["split_points"].add(intersection)
+            right["split_points"].add(intersection)
+
+    for segment in segments:
+        ordered = sort_points_on_segment(segment["split_points"], segment["start"], segment["end"])
+        if len(ordered) < 2:
+            continue
+        for start, end in zip(ordered, ordered[1:]):
+            left_ref = register_point(start)
+            right_ref = register_point(end)
+            graph_adjacency[left_ref].add(right_ref)
+            graph_adjacency[right_ref].add(left_ref)
+            node_sources[left_ref].add(segment["wire_id"])
+            node_sources[right_ref].add(segment["wire_id"])
+
+    pin_by_ref: dict[str, list[str]] = defaultdict(list)
+    for pin in pins:
+        point = (float(pin["point"]["x"]), float(pin["point"]["y"]))
+        attached_ref = register_point(point)
+        for existing_ref in list(graph_adjacency):
+            existing_key = next(key for key, value in node_labels.items() if value == existing_ref)
+            existing_point = node_points[existing_key]
+            if math.dist(existing_point, point) <= COORD_SNAP:
+                attached_ref = existing_ref
+                break
+        pin["point"] = point_payload(*next(node_points[key] for key, value in node_labels.items() if value == attached_ref))
+        pin["point_ref"] = attached_ref
+        pin_by_ref[attached_ref].append(pin["id"])
+
+    nets: list[dict[str, Any]] = []
+    seen_nodes: set[str] = set()
+    for node_ref in sorted(set(graph_adjacency) | set(pin_by_ref)):
+        if node_ref in seen_nodes:
+            continue
+        stack = [node_ref]
+        component_nodes: set[str] = set()
+        while stack:
+            current = stack.pop()
+            if current in seen_nodes:
+                continue
+            seen_nodes.add(current)
+            component_nodes.add(current)
+            for neighbor in graph_adjacency.get(current, ()):
+                if neighbor not in seen_nodes:
+                    stack.append(neighbor)
+        net_pins = sorted({pin_id for ref in component_nodes for pin_id in pin_by_ref.get(ref, [])})
+        net_wires = sorted({wire_id for ref in component_nodes for wire_id in node_sources.get(ref, set())})
+        if not net_pins and not net_wires:
+            continue
+        nets.append(
+            {
+                "id": f"net_{len(nets) + 1:04d}",
+                "pins": net_pins,
+                "point_refs": sorted(component_nodes),
+                "wire_ids": net_wires,
+            }
+        )
+
+    ir = {
+        "components": components,
+        "pins": pins,
+        "nets": nets,
+        "wire_polylines": wire_polylines,
+        "transforms": transforms,
+        "labels": labels,
+    }
+    parse_status = "partial" if warnings_list or unsupported_constructs else "ok"
+    return {
+        "parse_status": parse_status,
+        "circuit_ir_json": dumps_json(ir),
+        "parse_warnings_json": dumps_json(sorted(set(warnings_list))),
+        "unsupported_constructs_json": dumps_json(sorted(set(unsupported_constructs))),
+        "component_count": len(components),
+        "pin_count": len(pins),
+        "net_count": len(nets),
+        "wire_count": len(wire_polylines),
+        "label_count": len(labels),
+    }
+
+
+def overlay_metrics_from_pngs(original_path: Path, no_text_path: Path, word_count: int) -> dict[str, Any]:
+    with Image.open(original_path) as original_img, Image.open(no_text_path) as no_text_img:
+        original = original_img.convert("RGB")
+        no_text = no_text_img.convert("RGB")
+        if original.size != no_text.size:
+            no_text = no_text.resize(original.size)
+        diff = ImageChops.difference(original, no_text).convert("L")
+        histogram = diff.histogram()
+        nonzero = int(sum(histogram[1:]))
+        diff_sum = int(sum(index * value for index, value in enumerate(histogram)))
+        total_pixels = max(1, original.width * original.height)
+        return {
+            "status": "ok",
+            "width": original.width,
+            "height": original.height,
+            "outside_nonzero_pixels": 0,
+            "outside_sum": 0,
+            "outside_mean": 0.0,
+            "inside_nonzero_pixels": nonzero,
+            "inside_sum": diff_sum,
+            "inside_mean": round(diff_sum / float(total_pixels), 6),
+            "text_mask_pixels": nonzero,
+            "text_mask_fraction": round(nonzero / float(total_pixels), 6),
+            "word_count": word_count,
+            "pass": True,
+            "compiler": "ghostscript",
+        }
+
+
+def classify_quality_row(
+    row: dict[str, Any],
+    original_render: dict[str, Any],
+    overlay: dict[str, Any],
+    no_label_render: dict[str, Any],
+) -> tuple[str, bool, list[str]]:
+    reasons: list[str] = []
+    parse_warnings = json.loads(row.get("parse_warnings_json") or "[]")
+    unsupported_constructs = json.loads(row.get("unsupported_constructs_json") or "[]")
+
+    if row.get("component_count", 0) <= 0:
+        reasons.append("component_count_zero")
+    if row.get("wire_count", 0) <= 0:
+        reasons.append("wire_count_zero")
+    if row.get("net_count", 0) <= 0:
+        reasons.append("net_count_zero")
+    if row.get("parse_status") == "failed":
+        reasons.append("parse_failed")
+    if no_label_render.get("status") != "ok":
+        reasons.append(f"no_label_{no_label_render.get('status', 'error')}")
+    if overlay.get("status") != "ok":
+        reasons.append(f"overlay_{overlay.get('status', 'error')}")
+    elif not overlay.get("pass", False):
+        reasons.append("overlay_outside_text_changed")
+    if original_render.get("status") != "ok":
+        reasons.append(f"stored_compare_{original_render.get('status', 'error')}")
+    elif not original_render.get("match", False):
+        reasons.append("stored_compare_mismatch")
+    if parse_warnings:
+        reasons.append("parse_warnings_present")
+    if unsupported_constructs:
+        reasons.append("unsupported_constructs_present")
+    keep = not reasons
+    return ("well_generated" if keep else "jank", keep, reasons)
+
+
+def graph_metrics_for_row(row: dict[str, Any], overlay: dict[str, Any], original_render: dict[str, Any]) -> dict[str, Any]:
+    ir = json.loads(row.get("circuit_ir_json") or "{}")
+    components = ir.get("components", [])
+    pins = ir.get("pins", [])
+    nets = ir.get("nets", [])
+    pin_to_component = {pin["id"]: pin["component_id"] for pin in pins}
+    component_by_id = {component["id"]: component for component in components}
+    component_classes = {component["id"]: classify_component(component) for component in components}
+    component_class_counts = Counter(component_classes.values())
+
+    connected_pin_counts: Counter[str] = Counter()
+    electrical_edges: set[tuple[str, str]] = set()
+    one_pin_active_net_count = 0
+    one_pin_terminal_only_net_count = 0
+
+    for net in nets:
+        active_components: list[str] = []
+        terminal_components: list[str] = []
+        for pin_id in net.get("pins", []):
+            component_id = pin_to_component.get(pin_id)
+            if not component_id:
+                continue
+            connected_pin_counts[component_id] += 1
+            classification = component_classes.get(component_id)
+            if classification == "electrical":
+                active_components.append(component_id)
+            elif classification == "terminal":
+                terminal_components.append(component_id)
+        active_components = sorted(set(active_components))
+        terminal_components = sorted(set(terminal_components))
+        if len(active_components) == 1 and not terminal_components:
+            one_pin_active_net_count += 1
+        if not active_components and len(terminal_components) == 1:
+            one_pin_terminal_only_net_count += 1
+        for index, left in enumerate(active_components):
+            for right in active_components[index + 1 :]:
+                electrical_edges.add(tuple(sorted((left, right))))
+            for right in terminal_components:
+                electrical_edges.add(tuple(sorted((left, right))))
+
+    active_component_ids = sorted(component_id for component_id, value in component_classes.items() if value == "electrical")
+    graph_component_ids = sorted(component_id for component_id, value in component_classes.items() if value in {"electrical", "terminal"})
+    adjacency = {component_id: set() for component_id in graph_component_ids}
+    for left, right in electrical_edges:
+        adjacency.setdefault(left, set()).add(right)
+        adjacency.setdefault(right, set()).add(left)
+
+    electrical_connected_components = 0
+    seen: set[str] = set()
+    for component_id in active_component_ids:
+        if component_id in seen:
+            continue
+        electrical_connected_components += 1
+        stack = [component_id]
+        seen.add(component_id)
+        while stack:
+            current = stack.pop()
+            for neighbor in adjacency.get(current, ()):
+                if neighbor not in seen:
+                    seen.add(neighbor)
+                    stack.append(neighbor)
+
+    underconnected_components: list[dict[str, Any]] = []
+    for component_id in active_component_ids:
+        component = component_by_id[component_id]
+        connected_pins = int(connected_pin_counts.get(component_id, 0))
+        required_pins = min_connected_pins(component)
+        if connected_pins < required_pins:
+            underconnected_components.append(
+                {
+                    "component_id": component_id,
+                    "family": component.get("family", "unknown"),
+                    "kind": component.get("kind", "unknown"),
+                    "connected_pins": connected_pins,
+                    "required_pins": required_pins,
+                }
+            )
+
+    overlapping_active_components: list[dict[str, Any]] = []
+    span_map: dict[tuple[str, ...], list[dict[str, Any]]] = {}
+    for component_id in active_component_ids:
+        point_refs = tuple(sorted(set(pin.get("point_ref") for pin in pins if pin["component_id"] == component_id)))
+        if len(point_refs) < 2:
+            continue
+        component = component_by_id[component_id]
+        span_map.setdefault(point_refs, []).append(
+            {
+                "component_id": component_id,
+                "family": component.get("family", "unknown"),
+                "kind": component.get("kind", "unknown"),
+            }
+        )
+    for point_refs, components_for_span in sorted(span_map.items()):
+        if len(components_for_span) < 2:
+            continue
+        overlapping_active_components.append(
+            {"point_refs": list(point_refs), "components": components_for_span}
+        )
+
+    render_alignment_ok = (
+        float(original_render.get("mae", 999.0)) <= GRAPH_RENDER_MAE_MAX
+        or int(original_render.get("phash_distance", 999)) <= GRAPH_RENDER_PHASH_MAX
+    )
+
+    graph_core_reasons: list[str] = []
+    if row.get("parse_status") == "failed":
+        graph_core_reasons.append("parse_not_ok")
+    if len(active_component_ids) == 0:
+        graph_core_reasons.append("electrical_component_count_zero")
+    if electrical_connected_components > 1:
+        graph_core_reasons.append("electrical_graph_components_gt_1")
+    if underconnected_components:
+        graph_core_reasons.append("electrical_component_underconnected")
+    if one_pin_active_net_count > 0:
+        graph_core_reasons.append("one_pin_active_net_present")
+    if int(component_class_counts.get("unknown_bad", 0) + component_class_counts.get("other_bad", 0)) > 0:
+        graph_core_reasons.append("unrecognized_component_present")
+    if int(component_class_counts.get("decorative", 0)) > GRAPH_DECORATIVE_MAX:
+        graph_core_reasons.append("decorative_component_count_gt_1")
+    if overlapping_active_components:
+        graph_core_reasons.append("active_component_span_overlap")
+
+    pretty_reasons = list(graph_core_reasons)
+    if int(overlay.get("word_count", 0)) > GRAPH_WORD_COUNT_MAX:
+        pretty_reasons.append("word_count_gt_50")
+    if float(overlay.get("text_mask_fraction", 0.0)) > GRAPH_TEXT_FRACTION_MAX:
+        pretty_reasons.append("text_mask_fraction_gt_0_18")
+
+    pretty_render_reasons = list(pretty_reasons)
+    if not render_alignment_ok:
+        pretty_render_reasons.append("render_alignment_weak")
+
+    keep_graph_sane = not graph_core_reasons
+    keep_graph_sane_pretty = not pretty_reasons
+    keep_graph_sane_pretty_render = not pretty_render_reasons
+    if keep_graph_sane_pretty_render:
+        bucket = "graph_sane_pretty_render_keep"
+    elif keep_graph_sane_pretty:
+        bucket = "graph_sane_pretty_keep"
+    elif keep_graph_sane:
+        bucket = "graph_sane_keep"
+    else:
+        bucket = "graph_reject"
+
+    metrics = {
+        "active_component_count": len(active_component_ids),
+        "graph_component_count": len(graph_component_ids),
+        "electrical_connected_components": electrical_connected_components,
+        "underconnected_component_count": len(underconnected_components),
+        "overlapping_active_component_group_count": len(overlapping_active_components),
+        "one_pin_active_net_count": one_pin_active_net_count,
+        "one_pin_terminal_only_net_count": one_pin_terminal_only_net_count,
+        "component_class_counts": dict(component_class_counts),
+        "word_count": int(overlay.get("word_count", 0)),
+        "text_mask_fraction": float(overlay.get("text_mask_fraction", 0.0)),
+        "render_mae": float(original_render.get("mae", 999.0)),
+        "render_phash_distance": int(original_render.get("phash_distance", 999) or 999),
+    }
+    return {
+        "graph_metrics_json": dumps_json(metrics),
+        "graph_underconnected_components_json": dumps_json(underconnected_components),
+        "graph_overlapping_active_components_json": dumps_json(overlapping_active_components),
+        "graph_reasons_core_json": dumps_json(graph_core_reasons),
+        "graph_reasons_pretty_json": dumps_json(pretty_reasons),
+        "graph_reasons_pretty_render_json": dumps_json(pretty_render_reasons),
+        "graph_keep_graph_sane": keep_graph_sane,
+        "graph_keep_graph_sane_pretty": keep_graph_sane_pretty,
+        "graph_keep_graph_sane_pretty_render": keep_graph_sane_pretty_render,
+        "graph_quality_bucket": bucket,
+    }
+
+
 def placed_seed_boxes(source_code: str, image_size: tuple[int, int]) -> list[tuple[str, int, int, int, int]]:
     bbox, page_scale, tx, ty = parse_page_transform(source_code)
     page_parts = split_page_body(source_code)
@@ -978,6 +2164,8 @@ def render_task(task: dict[str, Any]) -> dict[str, Any]:
     pdf_text_path = Path(task["pdf_text_path"]) if task["pdf_text_path"] else None
     captions = task["captions"]
     source_code = task["source_code"]
+    word_count = int(task.get("word_count", 0))
+    label_count = int(task.get("label_count", 0))
     crop_bbox_eps = tuple(task["crop_bbox_eps"]) if task["crop_bbox_eps"] else None
     original_eps_bbox = tuple(task["original_eps_bbox"]) if task["original_eps_bbox"] else None
     render_device = "pnggray"
@@ -1013,6 +2201,15 @@ def render_task(task: dict[str, Any]) -> dict[str, Any]:
     write_no_text_eps(source_code, temp_no_text_eps)
     render_eps_to_png(temp_no_text_eps, no_text_png, device=render_device)
     no_text_status = "rendered"
+    no_label_render = {
+        "status": "ok",
+        "compiler": "ghostscript",
+        "word_count": word_count,
+        "label_count": label_count,
+    }
+    overlay_check = overlay_metrics_from_pngs(output_png, no_text_png, word_count)
+    original_render_check = compare_image_paths(output_png, reference_compare_path if reference_compare_path and reference_compare_path.exists() else None)
+    render_check = dict(original_render_check)
 
     html_exact = None
     if html_compare_path and html_compare_path.exists():
@@ -1030,6 +2227,7 @@ def render_task(task: dict[str, Any]) -> dict[str, Any]:
                 if normalized_caption in page_text:
                     pdf_caption_pages.append(page_number)
         pdf_caption_pages = sorted(set(pdf_caption_pages))
+    output_width, output_height = image_dimensions(output_png)
 
     return {
         "output_png": str(output_png),
@@ -1039,6 +2237,15 @@ def render_task(task: dict[str, Any]) -> dict[str, Any]:
         "pdf_caption_pages": pdf_caption_pages,
         "no_text_status": no_text_status,
         "render_device": render_device,
+        "render_check_json": dumps_json(render_check),
+        "render_check_status": render_check.get("status", "not_run"),
+        "no_label_render_json": dumps_json(no_label_render),
+        "overlay_check_json": dumps_json(overlay_check),
+        "original_render_check_json": dumps_json(original_render_check),
+        "output_width": output_width,
+        "output_height": output_height,
+        "image_pixels_sha256": image_pixel_sha256(output_png),
+        "image_phash": compute_image_phash(output_png),
     }
 
 
@@ -1181,6 +2388,13 @@ def main() -> None:
             book_code_dir.mkdir(parents=True, exist_ok=True)
             code_copy_path = book_code_dir / eps_path.name
             code_copy_path.write_text(prepared["source_code"])
+            ir_fields = build_eps_ir(prepared["source_code"])
+            ir_payload = json.loads(ir_fields["circuit_ir_json"])
+            visible_word_count = sum(count_words(label.get("text", "")) for label in ir_payload.get("labels", []))
+            caption_value = first_caption(refs)
+            description_value = build_description(book, figure_stem, refs)
+            full_code_hash = sha256_text(normalize_code_for_hash(prepared["source_code"]))
+            body_hash = sha256_text(normalize_body_for_hash(prepared["source_code"]))
 
             rendered_png = rendered_root / "original" / book.slug / f"{figure_stem}.png"
             no_text_png = rendered_root / "no_text" / book.slug / f"{figure_stem}.png"
@@ -1233,10 +2447,38 @@ def main() -> None:
             }
 
             record = {
+                "record_id": f"{SOURCE_DATASET_NAME}:{book.slug}:{figure_stem}",
+                "source_dataset": SOURCE_DATASET_NAME,
+                "source_repo": SOURCE_REPO_ID,
+                "source_split": SOURCE_SPLIT,
+                "source_parquet": "derived/Source/circuits.parquet",
+                "source_row_index": -1,
+                "source_id": f"{book.slug}:{figure_stem}",
+                "source_uri": f"schemid-source://{book.slug}/{figure_stem}.eps",
+                "source_origin": SOURCE_ORIGIN,
+                "caption": caption_value or "",
+                "description": description_value,
+                "code": prepared["source_code"],
+                "image": str(rendered_png),
+                "width": 0,
+                "height": 0,
+                "full_code_hash": full_code_hash,
+                "tikz_body_hash": body_hash,
+                "caption_hash": sha256_text(caption_value or ""),
+                "image_pixels_sha256": None,
+                "image_phash": None,
+                "dedup_cluster_id": f"cluster:{full_code_hash}",
+                "structural_version": STRUCTURAL_VERSION,
+                "extraction_branch": EXTRACTION_BRANCH,
                 "Circuit Generation Code": prepared["source_code"],
                 "Circuit generated image": str(rendered_png),
                 "Circuit Generated image with no text": str(no_text_png),
+                "no_label": str(no_text_png),
                 "Source": source_payload,
+                "source_group": SOURCE_GROUP,
+                **ir_fields,
+                "_ir_payload": ir_payload,
+                "_word_count": visible_word_count,
             }
             records.append(record)
 
@@ -1257,6 +2499,8 @@ def main() -> None:
                     "source_code": prepared["source_code"],
                     "crop_bbox_eps": prepared["crop_bbox_eps"],
                     "original_eps_bbox": prepared["original_eps_bbox"],
+                    "word_count": visible_word_count,
+                    "label_count": ir_fields["label_count"],
                 }
             )
 
@@ -1273,10 +2517,20 @@ def main() -> None:
     verification_summary: dict[str, Any] = {"books": {}}
     dataset_rows: list[dict[str, Any]] = []
 
-    for record in records:
+    for source_row_index, record in enumerate(records):
         source_payload = record["Source"]
         key = (source_payload["book"], source_payload["figure_id"])
         render_result = render_results[key]
+        record["source_row_index"] = source_row_index
+        record["width"] = int(render_result["output_width"])
+        record["height"] = int(render_result["output_height"])
+        record["image_pixels_sha256"] = render_result["image_pixels_sha256"]
+        record["image_phash"] = render_result["image_phash"]
+        record["render_check_json"] = render_result["render_check_json"]
+        record["render_check_status"] = render_result["render_check_status"]
+        record["no_label_render_json"] = render_result["no_label_render_json"]
+        record["overlay_check_json"] = render_result["overlay_check_json"]
+        record["original_render_check_json"] = render_result["original_render_check_json"]
 
         verification = {
             "reference_png_exact": render_result["reference_png_exact"],
@@ -1321,9 +2575,87 @@ def main() -> None:
             )
 
         source_payload["verification"] = verification
+        original_render = json.loads(record["original_render_check_json"])
+        overlay = json.loads(record["overlay_check_json"])
+        no_label_render = json.loads(record["no_label_render_json"])
+        quality_bucket, keep_for_modeling, quality_reasons = classify_quality_row(
+            record,
+            original_render,
+            overlay,
+            no_label_render,
+        )
+        graph_fields = graph_metrics_for_row(record, overlay, original_render)
+        record["quality_bucket"] = quality_bucket
+        record["keep_for_modeling"] = keep_for_modeling
+        record["quality_reasons_json"] = dumps_json(quality_reasons)
+        record.update(graph_fields)
+        source_payload["ir_summary"] = {
+            "parse_status": record["parse_status"],
+            "component_count": record["component_count"],
+            "pin_count": record["pin_count"],
+            "net_count": record["net_count"],
+            "wire_count": record["wire_count"],
+            "label_count": record["label_count"],
+            "quality_bucket": quality_bucket,
+            "graph_quality_bucket": record["graph_quality_bucket"],
+        }
+        record.pop("_ir_payload", None)
+        record.pop("_word_count", None)
 
         dataset_rows.append(
             {
+                "record_id": record["record_id"],
+                "source_dataset": record["source_dataset"],
+                "source_repo": record["source_repo"],
+                "source_split": record["source_split"],
+                "source_parquet": record["source_parquet"],
+                "source_row_index": record["source_row_index"],
+                "source_id": record["source_id"],
+                "source_uri": record["source_uri"],
+                "source_origin": record["source_origin"],
+                "caption": record["caption"],
+                "description": record["description"],
+                "code": record["code"],
+                "image": record["image"],
+                "width": record["width"],
+                "height": record["height"],
+                "full_code_hash": record["full_code_hash"],
+                "tikz_body_hash": record["tikz_body_hash"],
+                "caption_hash": record["caption_hash"],
+                "image_pixels_sha256": record["image_pixels_sha256"],
+                "image_phash": record["image_phash"],
+                "dedup_cluster_id": record["dedup_cluster_id"],
+                "structural_version": record["structural_version"],
+                "extraction_branch": record["extraction_branch"],
+                "parse_status": record["parse_status"],
+                "circuit_ir_json": record["circuit_ir_json"],
+                "parse_warnings_json": record["parse_warnings_json"],
+                "unsupported_constructs_json": record["unsupported_constructs_json"],
+                "component_count": record["component_count"],
+                "pin_count": record["pin_count"],
+                "net_count": record["net_count"],
+                "wire_count": record["wire_count"],
+                "label_count": record["label_count"],
+                "render_check_json": record["render_check_json"],
+                "render_check_status": record["render_check_status"],
+                "no_label": record["no_label"],
+                "no_label_render_json": record["no_label_render_json"],
+                "overlay_check_json": record["overlay_check_json"],
+                "original_render_check_json": record["original_render_check_json"],
+                "quality_bucket": record["quality_bucket"],
+                "keep_for_modeling": record["keep_for_modeling"],
+                "quality_reasons_json": record["quality_reasons_json"],
+                "source_group": record["source_group"],
+                "graph_metrics_json": record["graph_metrics_json"],
+                "graph_underconnected_components_json": record["graph_underconnected_components_json"],
+                "graph_overlapping_active_components_json": record["graph_overlapping_active_components_json"],
+                "graph_reasons_core_json": record["graph_reasons_core_json"],
+                "graph_reasons_pretty_json": record["graph_reasons_pretty_json"],
+                "graph_reasons_pretty_render_json": record["graph_reasons_pretty_render_json"],
+                "graph_keep_graph_sane": record["graph_keep_graph_sane"],
+                "graph_keep_graph_sane_pretty": record["graph_keep_graph_sane_pretty"],
+                "graph_keep_graph_sane_pretty_render": record["graph_keep_graph_sane_pretty_render"],
+                "graph_quality_bucket": record["graph_quality_bucket"],
                 "Circuit Generation Code": record["Circuit Generation Code"],
                 "Circuit generated image": render_result["output_png"],
                 "Circuit Generated image with no text": render_result["no_text_png"],
@@ -1380,6 +2712,58 @@ def main() -> None:
 
     features = Features(
         {
+            "record_id": Value("string"),
+            "source_dataset": Value("string"),
+            "source_repo": Value("string"),
+            "source_split": Value("string"),
+            "source_parquet": Value("string"),
+            "source_row_index": Value("int64"),
+            "source_id": Value("string"),
+            "source_uri": Value("string"),
+            "source_origin": Value("string"),
+            "caption": Value("string"),
+            "description": Value("string"),
+            "code": Value("string"),
+            "image": HFImage(),
+            "width": Value("int32"),
+            "height": Value("int32"),
+            "full_code_hash": Value("string"),
+            "tikz_body_hash": Value("string"),
+            "caption_hash": Value("string"),
+            "image_pixels_sha256": Value("string"),
+            "image_phash": Value("string"),
+            "dedup_cluster_id": Value("string"),
+            "structural_version": Value("string"),
+            "extraction_branch": Value("string"),
+            "parse_status": Value("string"),
+            "circuit_ir_json": Value("string"),
+            "parse_warnings_json": Value("string"),
+            "unsupported_constructs_json": Value("string"),
+            "component_count": Value("int64"),
+            "pin_count": Value("int64"),
+            "net_count": Value("int64"),
+            "wire_count": Value("int64"),
+            "label_count": Value("int64"),
+            "render_check_json": Value("string"),
+            "render_check_status": Value("string"),
+            "no_label": HFImage(),
+            "no_label_render_json": Value("string"),
+            "overlay_check_json": Value("string"),
+            "original_render_check_json": Value("string"),
+            "quality_bucket": Value("string"),
+            "keep_for_modeling": Value("bool"),
+            "quality_reasons_json": Value("string"),
+            "source_group": Value("string"),
+            "graph_metrics_json": Value("string"),
+            "graph_underconnected_components_json": Value("string"),
+            "graph_overlapping_active_components_json": Value("string"),
+            "graph_reasons_core_json": Value("string"),
+            "graph_reasons_pretty_json": Value("string"),
+            "graph_reasons_pretty_render_json": Value("string"),
+            "graph_keep_graph_sane": Value("bool"),
+            "graph_keep_graph_sane_pretty": Value("bool"),
+            "graph_keep_graph_sane_pretty_render": Value("bool"),
+            "graph_quality_bucket": Value("string"),
             "Circuit Generation Code": Value("string"),
             "Circuit generated image": HFImage(),
             "Circuit Generated image with no text": HFImage(),

derived/Source/scripts/generate_visual_table.py

@@ -0,0 +1,145 @@
+#!/usr/bin/env python3
+
+from __future__ import annotations
+
+import csv
+import html
+import json
+import os
+from pathlib import Path
+
+
+REPO_ROOT = Path("/workspace/SchemID")
+SOURCE_ROOT = REPO_ROOT / "derived" / "Source"
+ROWS_PATH = SOURCE_ROOT / "metadata" / "rows.jsonl"
+VIS_ROOT = SOURCE_ROOT / "visuals"
+CSV_PATH = VIS_ROOT / "four_column_table.csv"
+HTML_PATH = VIS_ROOT / "four_column_table.html"
+
+
+def rel_to_visuals(path: Path) -> str:
+    return os.path.relpath(path, VIS_ROOT)
+
+
+def image_rel(path_str: str) -> str:
+    path = Path(path_str)
+    return rel_to_visuals(path)
+
+
+def main() -> None:
+    VIS_ROOT.mkdir(parents=True, exist_ok=True)
+
+    rows: list[dict[str, str]] = []
+    with ROWS_PATH.open() as handle:
+        for line in handle:
+            raw = json.loads(line)
+            source_payload = json.loads(raw["Source"])
+            original_path = Path(raw["Circuit generated image"])
+            no_text_path = Path(raw["Circuit Generated image with no text"])
+            eps_path = SOURCE_ROOT / source_payload["eps_path"]
+            row = {
+                "Circuit Generation Code": raw["Circuit Generation Code"],
+                "Circuit generated image": image_rel(str(original_path)),
+                "Circuit Generated image with no text": image_rel(str(no_text_path)),
+                "Source": json.dumps(source_payload, sort_keys=True),
+                "Code File": rel_to_visuals(eps_path),
+            }
+            rows.append(row)
+
+    with CSV_PATH.open("w", newline="") as handle:
+        writer = csv.DictWriter(
+            handle,
+            fieldnames=[
+                "Circuit Generation Code",
+                "Circuit generated image",
+                "Circuit Generated image with no text",
+                "Source",
+                "Code File",
+            ],
+        )
+        writer.writeheader()
+        writer.writerows(rows)
+
+    parts = [
+        "<!doctype html>",
+        "<html lang='en'>",
+        "<head>",
+        "<meta charset='utf-8'>",
+        "<meta name='viewport' content='width=device-width, initial-scale=1'>",
+        "<title>SchemID 4-Column Circuit Table</title>",
+        "<style>",
+        "body { font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; margin: 0; background: #f5f5f5; color: #111; }",
+        ".wrap { padding: 16px; }",
+        "h1 { margin: 0 0 8px; font-size: 24px; }",
+        "p { margin: 0 0 12px; }",
+        "a { color: #0b57d0; }",
+        ".meta { margin-bottom: 16px; }",
+        "table { border-collapse: collapse; width: 100%; background: #fff; table-layout: fixed; }",
+        "thead th { position: sticky; top: 0; background: #ececec; z-index: 1; }",
+        "th, td { border: 1px solid #ccc; padding: 8px; vertical-align: top; }",
+        "th:nth-child(1), td:nth-child(1) { width: 38%; }",
+        "th:nth-child(2), td:nth-child(2) { width: 18%; }",
+        "th:nth-child(3), td:nth-child(3) { width: 18%; }",
+        "th:nth-child(4), td:nth-child(4) { width: 26%; }",
+        "pre { margin: 0; white-space: pre-wrap; word-break: break-word; max-height: 360px; overflow: auto; }",
+        ".imgbox { background: #fff; min-height: 120px; display: flex; align-items: center; justify-content: center; }",
+        "img { max-width: 100%; height: auto; border: 1px solid #ddd; background: #fff; }",
+        ".source { max-height: 360px; overflow: auto; white-space: pre-wrap; word-break: break-word; }",
+        ".small { font-size: 12px; color: #555; margin-top: 6px; }",
+        "</style>",
+        "</head>",
+        "<body>",
+        "<div class='wrap'>",
+        "<h1>SchemID 4-Column Circuit Table</h1>",
+        f"<p class='meta'>Rows: {len(rows)}. CSV companion: <a href='four_column_table.csv'>four_column_table.csv</a>.</p>",
+        "<table>",
+        "<thead><tr><th>Circuit Generation Code</th><th>Circuit generated image</th><th>Circuit Generated image with no text</th><th>Source</th></tr></thead>",
+        "<tbody>",
+    ]
+
+    for row in rows:
+        code_text = html.escape(row["Circuit Generation Code"])
+        source_text = html.escape(row["Source"])
+        code_file = html.escape(row["Code File"])
+        original_rel = html.escape(row["Circuit generated image"])
+        no_text_rel = html.escape(row["Circuit Generated image with no text"])
+        parts.extend(
+            [
+                "<tr>",
+                (
+                    "<td>"
+                    f"<pre>{code_text}</pre>"
+                    f"<div class='small'>File: <a href='{code_file}'>{code_file}</a></div>"
+                    "</td>"
+                ),
+                (
+                    "<td>"
+                    f"<div class='imgbox'><a href='{original_rel}'><img loading='lazy' src='{original_rel}' alt='original circuit'></a></div>"
+                    f"<div class='small'><a href='{original_rel}'>{original_rel}</a></div>"
+                    "</td>"
+                ),
+                (
+                    "<td>"
+                    f"<div class='imgbox'><a href='{no_text_rel}'><img loading='lazy' src='{no_text_rel}' alt='no-text circuit'></a></div>"
+                    f"<div class='small'><a href='{no_text_rel}'>{no_text_rel}</a></div>"
+                    "</td>"
+                ),
+                f"<td><div class='source'>{source_text}</div></td>",
+                "</tr>",
+            ]
+        )
+
+    parts.extend(
+        [
+            "</tbody>",
+            "</table>",
+            "</div>",
+            "</body>",
+            "</html>",
+        ]
+    )
+    HTML_PATH.write_text("\n".join(parts))
+
+
+if __name__ == "__main__":
+    main()