Add files using upload-large-folder tool

derived/Source/scripts/build_circuit_dataset.py

@@ -44,7 +44,10 @@ 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
+GRAPH_DECORATIVE_MAX = 12
+PIN_INFER_BOUNDARY_MARGIN = 10.0
+PIN_INFER_EXPAND_MARGIN = 12.0
+MAX_INFERRED_COMPONENT_PINS = 12
 NO_TEXT_PS_OVERRIDE = (
     "\n"
     "/show { pop } bind def\n"
@@ -167,21 +170,274 @@ ELECTRICAL_FAMILIES = {
 MIN_CONNECTED_PINS = {
     "ac_source": 2,
     "capacitor": 2,
+    "current_source": 2,
     "diode": 2,
     "fuse": 2,
     "ground": 1,
     "integrated_circuit": 2,
     "inductor": 2,
+    "instrument": 2,
     "junction": 1,
     "led": 2,
     "logic_gate": 2,
     "op_amp": 3,
     "potentiometer": 3,
+    "relay": 2,
     "resistor": 2,
+    "switch": 2,
     "terminal": 1,
+    "transformer": 2,
     "transistor": 3,
+    "vacuum_tube": 2,
     "voltage_source": 2,
 }
+DECORATIVE_PROCEDURES = {
+    "approx",
+    "car2",
+    "cart",
+    "candle",
+    "d_dx",
+    "elipse",
+    "flywheel",
+    "g2h",
+    "g2v",
+    "greenlight",
+    "infinity",
+    "jet",
+    "kmap_3",
+    "kmap_4",
+    "left_hand",
+    "left_parenthesis",
+    "log_grid",
+    "omega",
+    "pointer",
+    "radicand1",
+    "radicand2",
+    "right_parenthesis",
+    "spring",
+    "washer",
+    "wave",
+    "bird",
+    "degree",
+    "polygon",
+    "sadfsaf",
+    "signal_air",
+    "squarewave",
+    "sinewave",
+    "sinewave1",
+    "sinewave2",
+    "sinewave3",
+    "sinewave4",
+    "tree",
+}
+BLOCK_PROCEDURES = {
+    "actuator_junk",
+    "analog_input",
+    "analog_output",
+    "air_compressor",
+    "aux_behind",
+    "aux_computer_front",
+    "aux_computer_behind",
+    "aux_front",
+    "aux_shared_behind",
+    "bar2",
+    "box",
+    "breadboard_large",
+    "blower",
+    "body_nut",
+    "brick",
+    "burner_1",
+    "control_selector",
+    "controller_pid",
+    "dndevice",
+    "fault_analysis_box",
+    "fcv",
+    "field",
+    "fieldbus_brick",
+    "fieldbus_terminator",
+    "flange",
+    "keyboard",
+    "link_data",
+    "link_dcs",
+    "main_behind",
+    "main_computer_front",
+    "main_front",
+    "measuring",
+    "packing",
+    "pid_controller",
+    "pipe_elbow",
+    "pipe_female",
+    "pipe_male",
+    "pipe_tee",
+    "proportional",
+    "remote_seal",
+    "signal_electric_binary",
+    "spectrum_display",
+    "tube_tee",
+    "transfer",
+    "valve_3",
+    "valve_5",
+    "valve_6",
+    "valve_7",
+    "valve_solenoid_2way",
+    "valve_control1",
+    "valve_control2",
+    "valve_globe_air",
+    "valve_globe_hand",
+    "valve_small",
+    "wedge",
+}
+TERMINAL_PROCEDURES = {
+    "audioplug",
+    "binding_post_black",
+    "binding_post_red",
+    "bnc_end",
+    "cabletip",
+    "connect",
+    "ladder_start",
+    "ladder_start2",
+    "probe",
+    "term_block_1",
+}
+SOURCE_PROCEDURES = {
+    "ac_supply",
+    "acsource",
+    "acsource2",
+    "alternator1",
+    "cell",
+    "dcgen1",
+    "dcgen2",
+    "function_generator",
+    "pulse_voltage_source",
+    "real_batt2",
+    "real_batt3",
+    "squarewave_source",
+    "variable_voltage",
+    "voltage_source_ac_dependent",
+}
+CURRENT_SOURCE_PROCEDURES = {"ac_dependent_i_source"}
+SWITCH_PROCEDURES = {
+    "dpdt_toggle",
+    "nctc",
+    "ncto",
+    "nc_contact",
+    "nc_electronic",
+    "nc_flow",
+    "nc_pressure",
+    "nc_pushbutton",
+    "no_electronic",
+    "no_flow",
+    "no_level",
+    "no_limit",
+    "no_pressure",
+    "no_pushbutton",
+    "notc",
+    "noto",
+    "relay_coil",
+    "selector",
+    "solenoid",
+    "spdt_toggle",
+    "switch1",
+    "switch_closed",
+    "toggle_nc",
+}
+LOGIC_PROCEDURES = {
+    "compare_eq",
+    "compare_ge",
+    "compare_gt",
+    "compare_le",
+    "compare_lt",
+    "compare_ne",
+    "counter_down",
+    "counter_up",
+    "counter_up_down",
+    "d_flipflop",
+    "d_latch",
+    "halfadder",
+    "invert2",
+    "jk_flipflop",
+    "jk_flipflop2",
+    "neg_and",
+    "neg_or",
+    "schmitt",
+    "sr_enabled_latch",
+    "timer_on_en",
+    "tristate_1",
+    "xnor",
+}
+INDICATOR_PROCEDURES = {
+    "dc_voltmeter",
+    "led2",
+    "dp_cell",
+    "fancy_scope",
+    "gauge",
+    "headphones",
+    "lamp_socket",
+    "meter_movement",
+    "multimeter",
+    "multimeter2",
+    "multimeter_tiny",
+    "nullmeter",
+    "scopemeter",
+    "speaker",
+    "speaker2",
+    "synchro",
+}
+PASSIVE_RESISTIVE_PROCEDURES = {
+    "cds_cell",
+    "heater_element",
+    "load_delta",
+    "load_y",
+    "resistor_delta",
+}
+PASSIVE_MAGNETIC_PROCEDURES = {
+    "coil_out",
+    "inductor_large",
+    "inductor_medium",
+    "saturable_reactor",
+    "variac",
+}
+SEMICONDUCTOR_DIODE_PROCEDURES = {
+    "diac",
+    "lascr",
+    "constant_i_diode",
+    "diode1",
+    "opto_triac",
+    "photodiode",
+    "shockley_diode",
+    "zener_diode",
+}
+SEMICONDUCTOR_TRANSISTOR_PROCEDURES = {
+    "gcs",
+    "gto",
+    "igbt_nchannel",
+    "igbt_npn",
+    "scr",
+    "scs",
+    "triac",
+    "ujt",
+    "bjt_bias",
+    "nmos",
+    "npnn",
+    "pnpp",
+    "transistor1",
+    "transistor3",
+    "transistor4",
+    "tr4",
+}
+ACTIVE_TUBE_PROCEDURES = {
+    "beam_tetrode",
+    "glow_tube",
+    "ignitron",
+    "phototube",
+    "reflex_klystron",
+    "tube_halftriode",
+    "tube_pentode_1",
+    "tube_pentode_2",
+    "tube_tetrode",
+    "tube_thyratron",
+    "tube_triode",
+}
 STRIP_INVOCATION_PROCEDURES = {"person", "person_shocked"}
 NON_CIRCUIT_SOURCE_PATTERNS: tuple[tuple[re.Pattern[str], str], ...] = (
     (
@@ -552,7 +808,11 @@ def parse_eps_metadata(eps_path: Path) -> dict[str, Any]:
     creator_match = XCIRCUIT_CREATOR_RE.search(text)
     creator = normalize_space(creator_match.group(1)) if creator_match else None
     procedures = sorted(set(EPS_PROC_RE.findall(text)))
-    circuit_tokens = sorted(set(procedures) & CIRCUIT_PROCEDURE_WHITELIST)
+    circuit_tokens = sorted(
+        procedure
+        for procedure in procedures
+        if component_family_kind(procedure)[0] in ELECTRICAL_FAMILIES
+    )
     is_xcircuit = bool(creator and "circuit" in creator.lower())
     return {
         "creator": creator,
@@ -902,6 +1162,36 @@ 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 DECORATIVE_PROCEDURES or lower.startswith("truth_") or lower.startswith("die_"):
+        return "decorative", lower
+    if lower in BLOCK_PROCEDURES:
+        return "block", lower
+    if lower in TERMINAL_PROCEDURES or lower.startswith("binding_post"):
+        return "io", "terminal"
+    if lower in SOURCE_PROCEDURES or lower.startswith("real_batt") or lower.endswith("_source"):
+        return "source", "ac_source" if "ac" in lower else "voltage_source"
+    if lower in CURRENT_SOURCE_PROCEDURES:
+        return "source", "current_source"
+    if lower in SWITCH_PROCEDURES or lower.startswith("no_") or lower.startswith("nc_"):
+        return "switch", "relay" if "relay" in lower else "switch"
+    if lower in LOGIC_PROCEDURES or "flipflop" in lower or "latch" in lower or "adder" in lower:
+        return "logic", "integrated_circuit"
+    if lower in INDICATOR_PROCEDURES or "scope" in lower:
+        return "indicator", "instrument"
+    if lower in PASSIVE_RESISTIVE_PROCEDURES or lower == "strain_gauge":
+        return "passive", "resistor"
+    if lower in PASSIVE_MAGNETIC_PROCEDURES:
+        return "passive", "inductor" if "inductor" in lower or "coil" in lower else "transformer"
+    if lower in SEMICONDUCTOR_DIODE_PROCEDURES:
+        return "semiconductor", "diode"
+    if lower in SEMICONDUCTOR_TRANSISTOR_PROCEDURES:
+        return "semiconductor", "transistor"
+    if lower in ACTIVE_TUBE_PROCEDURES or (lower.startswith("tube_") and lower != "tube_tee"):
+        return "active", "vacuum_tube"
+    if lower in {"plc_powersupply"} or "powersupply" in lower:
+        return "source", "voltage_source"
+    if lower in {"plc_processor"} or "processor" in lower:
+        return "logic", "integrated_circuit"
     if lower in {"clip", "label", "marks"} or lower.startswith("die_") or lower.startswith("truth_"):
         return "decorative", lower
     if "arrow" in lower:
@@ -910,6 +1200,8 @@ def component_family_kind(name: str) -> tuple[str, str]:
         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 "flipflop" in lower or "latch" in lower or lower in {"xnor", "xor", "xnor", "schmitt"}:
+        return "logic", "integrated_circuit"
     if "resistor" in lower or lower == "strain_gauge":
         return "passive", "resistor"
     if "capacitor" in lower or "polarized" in lower:
@@ -922,11 +1214,30 @@ def component_family_kind(name: str) -> tuple[str, str]:
         return "source", "voltage_source"
     if "isource" in lower or "current" in lower:
         return "source", "current_source"
+    if "source" in lower:
+        return "source", "ac_source" if "ac" in lower else "voltage_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:
+    if (
+        "diode" in lower
+        or "mosfet" in lower
+        or "jfet" in lower
+        or lower in {"scr", "diode", "triac", "diac", "gto", "gcs", "scs", "ujt"}
+        or "fet" in lower
+        or lower.startswith("npn")
+        or lower.startswith("pnp")
+        or lower.startswith("transistor")
+        or lower == "nmos"
+    ):
+        transistor_like = (
+            "fet" in lower
+            or lower in {"scr", "triac", "gto", "gcs", "scs", "ujt", "nmos"}
+            or lower.startswith("npn")
+            or lower.startswith("pnp")
+            or lower.startswith("transistor")
+        )
+        return "semiconductor", "transistor" if transistor_like else "diode"
+    if "lamp" in lower or "meter" in lower or "motor" in lower or "detector" in lower or "speaker" in lower:
         return "indicator", "indicator"
     if "connector" in lower or "terminal" in lower or lower in {"stud", "tap", "powerpole"}:
         return "io", "terminal"
@@ -944,7 +1255,7 @@ def classify_component(component: dict[str, Any]) -> str:
         return "terminal"
     if family in {"active", "passive", "source", "semiconductor", "switch", "indicator", "protection", "logic"}:
         return "electrical"
-    if family == "block":
+    if family in {"block", "decorative"}:
         return "decorative"
     if family == "unknown":
         return "unknown_bad"
@@ -1025,10 +1336,47 @@ def point_inside_bbox(
     return left - margin <= x <= right + margin and bottom - margin <= y <= top + margin
 
 
+def distance_to_bbox_boundary(
+    point: tuple[float, float],
+    bbox: tuple[float, float, float, float],
+) -> float:
+    x, y = point
+    left, bottom, right, top = bbox
+    if left <= x <= right and bottom <= y <= top:
+        return min(x - left, right - x, y - bottom, top - y)
+    dx = 0.0 if left <= x <= right else min(abs(x - left), abs(x - right))
+    dy = 0.0 if bottom <= y <= top else min(abs(y - bottom), abs(y - top))
+    if dx == 0.0:
+        return dy
+    if dy == 0.0:
+        return dx
+    return math.hypot(dx, dy)
+
+
+def bbox_segments(
+    bbox: tuple[float, float, float, float]
+) -> list[tuple[tuple[float, float], tuple[float, float]]]:
+    left, bottom, right, top = bbox
+    return [
+        ((left, bottom), (right, bottom)),
+        ((right, bottom), (right, top)),
+        ((right, top), (left, top)),
+        ((left, top), (left, bottom)),
+    ]
+
+
 def snap_key(point: tuple[float, float]) -> tuple[int, int]:
     return (round(point[0] / COORD_SNAP), round(point[1] / COORD_SNAP))
 
 
+def dedupe_points(points: list[tuple[float, float]]) -> list[tuple[float, float]]:
+    unique: dict[tuple[int, int], tuple[float, float]] = {}
+    for point in points:
+        key = snap_key(point)
+        unique.setdefault(key, (round(point[0], 3), round(point[1], 3)))
+    return list(unique.values())
+
+
 def _projection_fraction(
     point: tuple[float, float],
     start: tuple[float, float],
@@ -1098,6 +1446,109 @@ def sort_points_on_segment(
     return sorted(points, key=lambda point: _projection_fraction(point, start, end))
 
 
+def fallback_bbox_pin_points(component: dict[str, Any]) -> list[tuple[float, float]]:
+    bbox_values = component.get("bbox")
+    if not bbox_values:
+        origin = component.get("point")
+        if origin:
+            return [(float(origin["x"]), float(origin["y"]))]
+        return []
+
+    bbox = tuple(float(value) for value in bbox_values)
+    left, bottom, right, top = bbox
+    center_x = (left + right) / 2.0
+    center_y = (bottom + top) / 2.0
+    family = component.get("family", "unknown")
+    expected = min_connected_pins(component)
+
+    if family in {"ground", "io", "junction"} or expected <= 1:
+        return [(center_x, center_y)]
+    if expected != 2:
+        return []
+    if (right - left) >= (top - bottom):
+        return [(left, center_y), (right, center_y)]
+    return [(center_x, bottom), (center_x, top)]
+
+
+def infer_missing_component_pins(
+    components: list[dict[str, Any]],
+    pins: list[dict[str, Any]],
+    wire_polylines: list[dict[str, Any]],
+    *,
+    start_index: int,
+) -> tuple[list[dict[str, Any]], int, list[str]]:
+    pins_by_component: dict[str, list[dict[str, Any]]] = defaultdict(list)
+    for pin in pins:
+        pins_by_component[pin["component_id"]].append(pin)
+
+    conductive_segments: list[tuple[tuple[float, float], tuple[float, float]]] = []
+    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:]):
+            conductive_segments.append((start, end))
+
+    inferred_pins: list[dict[str, Any]] = []
+    missing_warnings: list[str] = []
+    pin_index = start_index
+
+    for component in components:
+        if pins_by_component.get(component["id"]):
+            continue
+        family = component.get("family", "unknown")
+        if family in {"decorative", "block"}:
+            continue
+
+        bbox_values = component.get("bbox")
+        candidate_points: list[tuple[float, float]] = []
+        if bbox_values:
+            bbox = tuple(float(value) for value in bbox_values)
+            for start, end in conductive_segments:
+                seg_bbox = (
+                    min(start[0], end[0]),
+                    min(start[1], end[1]),
+                    max(start[0], end[0]),
+                    max(start[1], end[1]),
+                )
+                if not bbox_intersects(bbox, seg_bbox, margin=PIN_INFER_EXPAND_MARGIN):
+                    continue
+                for point in (start, end):
+                    if point_inside_bbox(point, bbox, margin=PIN_INFER_EXPAND_MARGIN) and distance_to_bbox_boundary(point, bbox) <= PIN_INFER_BOUNDARY_MARGIN:
+                        candidate_points.append(point)
+                for edge_start, edge_end in bbox_segments(bbox):
+                    intersection = segment_intersection(start, end, edge_start, edge_end, tolerance=PIN_INFER_EXPAND_MARGIN)
+                    if intersection is not None:
+                        candidate_points.append(intersection)
+
+        candidate_points = sorted(
+            dedupe_points(candidate_points),
+            key=lambda point: (round(point[0], 3), round(point[1], 3)),
+        )
+        if not candidate_points:
+            candidate_points = fallback_bbox_pin_points(component)
+        if not candidate_points:
+            missing_warnings.append(f"missing_pins:{component['raw_kind']}:{component['id']}")
+            continue
+
+        for pin_position, point in enumerate(candidate_points[:MAX_INFERRED_COMPONENT_PINS], start=1):
+            pin_id = f"{component['id']}.pin_{pin_index:04d}"
+            pin_index += 1
+            inferred_pins.append(
+                {
+                    "id": pin_id,
+                    "component_id": component["id"],
+                    "name": f"inferred_{pin_position}",
+                    "kind": "terminal",
+                    "point": point_payload(*point),
+                    "point_ref": point_to_ref(*point),
+                    "raw": "inferred_from_bbox_wire",
+                }
+            )
+
+    return inferred_pins, pin_index, missing_warnings
+
+
 def count_words(text: str) -> int:
     return len(re.findall(r"[A-Za-z0-9_]+", text))
 
@@ -1298,7 +1749,7 @@ def build_eps_ir(source_code: str) -> dict[str, Any]:
         )
 
         local_pins = proc_pin_catalog.get(proc_name, [])
-        if not local_pins and family in {"passive", "source", "indicator", "protection"} and local_bbox:
+        if not local_pins and family in {"passive", "source", "indicator", "protection", "switch"} and local_bbox:
             bx, by, bw, bh = local_bbox
             if abs(bh) >= abs(bw):
                 local_pins = [
@@ -1315,9 +1766,6 @@ def build_eps_ir(source_code: str) -> dict[str, Any]:
                 {"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"]),
@@ -1427,6 +1875,14 @@ def build_eps_ir(source_code: str) -> dict[str, Any]:
             }
         )
 
+    inferred_pins, pin_index, missing_pin_warnings = infer_missing_component_pins(
+        components,
+        pins,
+        wire_polylines,
+        start_index=pin_index,
+    )
+    pins.extend(inferred_pins)
+    warnings_list.extend(missing_pin_warnings)
     wire_polylines.extend(synthesize_component_spans(components, pins))
 
     node_points: dict[tuple[int, int], tuple[float, float]] = {}
@@ -1709,25 +2165,47 @@ def graph_metrics_for_row(row: dict[str, Any], overlay: dict[str, Any], original
         or int(original_render.get("phash_distance", 999)) <= GRAPH_RENDER_PHASH_MAX
     )
 
+    unknown_component_count = int(
+        component_class_counts.get("unknown_bad", 0) + component_class_counts.get("other_bad", 0)
+    )
+    decorative_component_count = int(component_class_counts.get("decorative", 0))
+    severe_underconnected = len(underconnected_components) >= max(
+        2,
+        math.ceil(len(active_component_ids) * 0.5),
+    )
+    symbol_plate_like = bool(
+        active_component_ids
+        and one_pin_active_net_count >= max(2, len(active_component_ids))
+        and electrical_connected_components >= max(1, len(active_component_ids) // 2)
+    )
+    heavily_fragmented = electrical_connected_components >= max(
+        3,
+        math.ceil(len(active_component_ids) * 0.5),
+    )
+
     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:
+    if severe_underconnected and not symbol_plate_like:
         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:
+    if heavily_fragmented and severe_underconnected and not symbol_plate_like:
+        graph_core_reasons.append("electrical_graph_fragmented")
+    if unknown_component_count > 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 electrical_connected_components > 1:
+        pretty_reasons.append("electrical_graph_components_gt_1")
+    if underconnected_components and "electrical_component_underconnected" not in pretty_reasons:
+        pretty_reasons.append("electrical_component_underconnected")
+    if one_pin_active_net_count > 0:
+        pretty_reasons.append("one_pin_active_net_present")
+    if decorative_component_count > GRAPH_DECORATIVE_MAX:
+        pretty_reasons.append("decorative_component_count_gt_12")
     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:
@@ -1757,6 +2235,11 @@ def graph_metrics_for_row(row: dict[str, Any], overlay: dict[str, Any], original
         "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,
+        "unknown_component_count": unknown_component_count,
+        "decorative_component_count": decorative_component_count,
+        "severe_underconnected": severe_underconnected,
+        "heavily_fragmented": heavily_fragmented,
+        "symbol_plate_like": symbol_plate_like,
         "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)),
@@ -1971,6 +2454,8 @@ def derive_crop_bbox(
     source_code: str,
     analysis_png_path: Path,
 ) -> tuple[int, int, int, int] | None:
+    if not analysis_png_path.exists():
+        return None
     with Image.open(analysis_png_path) as image:
         gray = np.array(image.convert("L"))
 
@@ -2080,7 +2565,7 @@ def prepare_figure_artifact(
 
     crop_bbox_px = None if removed_procedures else derive_crop_bbox(sanitized_code, analysis_png)
     crop_bbox_eps = None
-    if crop_bbox_px:
+    if crop_bbox_px and analysis_png.exists():
         with Image.open(analysis_png) as analysis_image:
             crop_bbox_eps = crop_pixels_to_eps_points(
                 crop_bbox_px,
@@ -2118,19 +2603,20 @@ def write_no_text_eps(source_code: str, output_path: Path) -> None:
 
 def render_eps_to_png(eps_path: Path, png_path: Path, *, device: str) -> None:
     png_path.parent.mkdir(parents=True, exist_ok=True)
-    run(
-        [
-            "gs",
-            "-dSAFER",
-            "-dBATCH",
-            "-dNOPAUSE",
-            "-dEPSCrop",
-            f"-sDEVICE={device}",
-            f"-r{PNG_DPI}",
-            f"-sOutputFile={png_path}",
-            str(eps_path),
-        ]
-    )
+    cmd = [
+        "gs",
+        "-dSAFER",
+        "-dBATCH",
+        "-dNOPAUSE",
+        "-dEPSCrop",
+        f"-sDEVICE={device}",
+        f"-r{PNG_DPI}",
+        f"-sOutputFile={png_path}",
+        str(eps_path),
+    ]
+    run(cmd)
+    if not png_path.exists():
+        run(cmd)
 
 
 def images_equal_rgba(path_a: Path, path_b: Path) -> bool:
@@ -2200,13 +2686,23 @@ def render_task(task: dict[str, Any]) -> dict[str, Any]:
     temp_no_text_eps.parent.mkdir(parents=True, exist_ok=True)
     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,
-    }
+    if not no_text_png.exists() and output_png.exists():
+        shutil.copy2(output_png, no_text_png)
+        no_text_status = "fallback_original_copy"
+        no_label_render = {
+            "status": "fallback_original_copy",
+            "compiler": "ghostscript",
+            "word_count": word_count,
+            "label_count": label_count,
+        }
+    else:
+        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)
@@ -2799,3 +3295,7 @@ def main() -> None:
 
 if __name__ == "__main__":
     main()
+    "block",
+    "butterfly",
+    "crt_elec",
+    "displacer",