Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261013T094815Z-all-celltypes-final-palette-142/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/apply_final_palette_20261013.py

@@ -0,0 +1,464 @@
+"""Apply the final method palette to explicitly audited deck assets.
+
+Sources are never changed. Vector rewrites preserve text, paths and images;
+native exceptions replay saved-table renderers. One legacy PNG receives only a
+source-defined, region-bounded method-arrow colour translation with pixel proof.
+"""
+from __future__ import annotations
+
+import argparse
+import ast
+import base64
+import hashlib
+import importlib.util
+import json
+import os
+import shutil
+import sys
+import tempfile
+from pathlib import Path
+
+os.environ["CUDA_VISIBLE_DEVICES"] = ""
+import fitz
+import numpy as np
+import pandas as pd
+from PIL import Image
+
+D = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(D / "tools"))
+import review_palette_pdf as V
+
+DATA = D / "data/final_palette_20261013"
+FIG = D / "figures/final_palette_20261013"
+DECISION = D / "PBISC-Diffusion_color_palette_20261013.md"
+DEFAULT_SPEC = D / "data/figure_enrichment_20261013/spec.json"
+LO, CAL, RAW, SC, BP, CX = "#168FE5", "#59A8DF", "#C3E2F4", "#83C6A8", "#D9B23F", "#F0D77D"
+FULL = "#0D6EA8"
+RULES: dict[str, dict] = {}
+
+
+def rule(names, mapping=None, *, reason, mode="vector"):
+    for name in names.split():
+        if name in RULES:
+            raise ValueError("Duplicate semantic rule: " + name)
+        RULES[name] = {"mode": mode, "mapping": mapping or {}, "reason": reason}
+
+
+STANDARD = {"#C5AA4B": LO, "#2166AC": SC, "#E8DDAE": RAW, "#B59A50": CAL}
+SC_ONLY = {**STANDARD, "#8E823C": "#3F91C5"}
+ARCH = {"#C5AA4B": LO, "#8F772B": FULL, "#B59A50": CAL, "#66531E": "#164C70",
+        "#D8C57E": "#A6D4EF", "#9D8240": "#388DBD", "#806A25": FULL}
+OLD_ARCH = {**STANDARD, "#D4BE75": "#93C6E8", "#806A25": FULL, "#6F5B1B": "#164C70",
+            "#DED09B": "#A6D4EF", "#978034": "#377FAD", "#E69F00": SC}
+MODES = {**SC_ONLY, "#806A25": FULL, "#D4BE75": "#92C4E5"}
+INPUTS = {"#E8DDAE": RAW, "#D2BC70": "#A6D4EF", "#B59A50": CAL, "#9C8138": "#388FCA",
+          "#806A25": "#79B8E0", "#C5AA4B": "#73B8E5", "#65521B": "#267FB9", "#A68B3C": "#9BCDEC"}
+
+rule("fig1d_corpus sec01_slide_a trajectory_four_pca_frames sec05_cells_umap sec01_fig1a_denoiser",
+     reason="Cell types, corpus categories or value/support computational components; not method-series colours.", mode="preserve")
+rule("sec02_backbone_compare", reason="PBISC column and changed-feature highlights use PBISC blue; the colour-word caption becomes neutral while every table cell stays fixed.", mode="native-backbone")
+rule("sec02_bulk_conditioning", reason="Colours distinguish input/conditioning components, not competing models.", mode="preserve")
+rule("sec06_eval_design sec09_cohorts", reason="Neutral sample/design metadata.", mode="preserve")
+rule("labels_real_cell_repeat labels_metrics_overview", reason="Real-cell sampling schematic or metric-family categories, not method colours.", mode="preserve")
+rule("mismatch_expression_values", reason="Blue density represents numbers of donor-gene observations, not a method series.", mode="preserve")
+rule("sec05_shift_cohorts", reason="Input-space measured versus offset-removed diagnostic; preserve its non-model intervention encoding.", mode="preserve")
+rule("stored_real_reference_umap saved_density_difference input_control_composition label_transitions immicro_replicate_controls annotation_agreement",
+     reason="Cell-type/cohort palettes, density or confusion-matrix values, or observed-reference controls.", mode="preserve")
+rule("strict_ye2026_sepsis_deg strict_imperial_eskd_deg covid_endpoints external_rare_screen rare_misses_1 rare_misses_2 sepsis_rare_support sepsis_rare_direction review_style_20261013_rare_observed",
+     reason="Heatmap colours encode numerical magnitudes; row/column labels carry method identities.", mode="preserve")
+rule("review_style_20261013_rare_corrected_comparison", reason="Point colours identify cohorts, while axes identify the methods.", mode="preserve")
+rule("covid_monocyte_direction_detail covid_cd14_direction_detail", reason="Filled versus open gold/white markers identify depth1000 versus native readout, not models.", mode="preserve")
+rule("c1q_cross_disease", reason="Colours identify one-gene versus two-gene C1Q rules, not methods.", mode="preserve")
+rule("bulkonly_imperial_wave_shift bulkonly_verification_history sec10_paired_subset_cohorts",
+     reason="Wave, audit disposition or planning status; preserve these non-method colours.", mode="preserve")
+rule("fig5_rare_fivefold", reason="All point colours identify cohorts; pale acceptable-error band is a numeric guide.", mode="preserve")
+rule("fig1_umap_seven_panels_by_label_depth1000", reason="Cell types and grey reference cells only, including embedded raster points.", mode="preserve")
+rule("fraction_correlation fraction_mae", reason="New all-celltype plots already use the approved final method palette.", mode="approved-native")
+
+rule("fig1b_overview_nature", {"#8F772B": FULL, "#F6F0DC": "#EDF6FC", "#DED09B": "#A2D1ED", "#A48A34": LO},
+     reason="Model blocks and adaptation arrows only; biological channels retain their original colours.")
+rule("arch_context_vs_trunk arch_hint_injection", {**ARCH, "#F7F2DF": "#EDF6FC", "#DDD5BC": "#BBD9EA", "#FCFAF1": "#F8FBFE"},
+     reason="PBISC computational blocks, model variants and their pale backgrounds; no measured biology.")
+rule("arch_width_arm_register arch_panel_arm_register", {"#F7F2DF": "#EDF6FC", "#806A25": FULL, "#E4DFD2": "#D4E4EF", "#FCFBF6": "#F8FBFE"},
+     reason="Model-register header and stripe colours; all parameter/time text stays fixed.")
+rule("arch_width_loss_progression arch_panel_loss_progression arch_all_arm_compute", ARCH,
+     reason="PBISC architecture/gene-panel variants; line styles, markers and failed-run status retained.")
+rule("sec03_width_bench", OLD_ARCH, reason="PBISC architecture variants blue; scSemi reference mint.")
+rule("sec03_panel", {**STANDARD, "#978034": "#377FAD"}, reason="PBISC gene panels blue; scSemi reference mint.")
+rule("labels_ablation", {"#C5AA4B": LO, "#B79A3F": CAL, "#967B2B": FULL, "#DEC975": "#A6D4EF"},
+     reason="PBISC ablation families use blue shades; black real-cell repeat reference remains unchanged.")
+rule("mismatch_same_donor_errors", {"#C5AA4B": CAL}, reason="Ten-pair calibration medium blue; measured bulk and paired lines remain neutral.")
+rule("sec06_ft_method", {"#C5AA4B": LO}, reason="Trainable PBISC LoRA blocks and merges.")
+rule("review_style_20261013_rank fig2_healthy_modes fig4_disease_variants sec07_ft_modes", MODES,
+     reason="LoRA bright blue; full FT darker blue; other PBISC adaptation variants retain distinct blue shades.")
+rule("fig3_healthy_pairs fig3_healthy_fewpair fig3_healthy_copy fig2_healthy_pairs fig4_disease_fewpair sec09_fewpair_cells sec09_extra_ksens sec09_same_pairs sec04_sle_benchmark sec04_sle_per_celltype fig3_time_days sec09_extra_fewpair sec09_scsemi_representative",
+     STANDARD, reason="LoRA, same-pair calibration, raw conditions and scSemi method identities.")
+rule("fig4_disease_fivefold sec09_cat_curves sec09_extra_fivefold fig2_healthy_cells fig2_healthy_realism", SC_ONLY,
+     reason="PBISC raw/calibrated/sc-only/LoRA blue family and scSemi mint.")
+rule("review_style_20261013_healthy_composition", {"#C5AA4B": LO, "#2166AC": SC}, reason="Paired PBISC-versus-scSemi absolute-error and donor-win comparison.")
+rule("sec09_time_to_apply", {"#C5AA4B": LO, "#E5D59C": CAL, "#2166AC": SC, "#67A9CF": "#B6DEC8"}, reason="Adaptation/generation stages retain light/dark variants within each method family.")
+rule("secS_deconv_disease secS_deconv_composition", {"#C5AA4B": LO, "#2166AC": SC, "#009E73": BP, "#6A51A3": CX}, reason="PBISC blue, scSemi mint, BayesPrism gold and CIBERSORTx pale gold.")
+rule("sec04_sle_broadcast", {"#C5AA4B": LO, "#2166AC": SC}, reason="PBISC and scSemi methods; bulk broadcast remains its labelled neutral reference.")
+rule("sec05_cells_metrics", {"#E8DDAE": RAW, "#B59A50": CAL, "#C5AA4B": "#79B8E0"}, reason="PBISC raw versus pseudobulk-conditioned controls; actual observed cells remain grey.")
+rule("fig2_healthy_rank sec07_rank_sweep", {"#C5AA4B": LO, "#E8DDAE": "#9DCFEF", "#806A25": FULL}, reason="PBISC rank variants, not a method-versus-cell-type colour encoding.")
+rule("sec07_k_aug", {"#C5AA4B": LO, "#5E5E5E": CAL, "#BDBDBD": RAW}, reason="All three arms are PBISC LoRA conditions: plain blue, multi-K medium blue, half-batch recipes pale blue. Neutral text and axes stay unchanged.", mode="vector-gray-variants")
+rule("sec08_pairs_realism sec08_pairs_signal", {**STANDARD, "#DAC990": "#A6D4EF"}, reason="LoRA/raw/calibrated/TPM inputs blue family; scSemi mint; observed and null references neutral.")
+rule("sec08_cross_cohort sec08_cross_cohort_steps", {**STANDARD, "#D4BE75": "#86BDE2", "#978034": "#3E92C7", "#665522": FULL}, reason="Distinct PBISC cross-cohort adaptation variants.")
+rule("sec07_no_pretraining sec08_cross_scratch secS_scratch_rare_states", {**STANDARD, "#806A25": "#BC9632", "#D4BE75": "#86BDE2", "#978034": "#3E92C7", "#665522": FULL},
+     reason="Pretrained PBISC/adaptation blue; from-scratch comparator dark yellow; neutral references unchanged.")
+rule("sec10_other_tissues", {"#C5AA4B": LO, "#806A25": "#BC9632"}, reason="Pretrained-versus-scratch evidence; prospective tissue labels unchanged.")
+rule("secA_scsemi_readout", {"#C5AA4B": LO, "#2166AC": SC, "#67A9CF": "#B6DEC8"}, reason="Official and modified scSemi mint shades; original hatching retained.")
+rule("fig5_rare_fraction fig5_rare_donors", {"#C5AA4B": LO, "#E8DDAE": RAW, "#2166AC": SC},
+     reason="Already separated method-colour tuples; Ji/Imperial and all cohort colours remain unchanged.")
+rule("review_style_20261013_behcet", {"#C5AA4B": LO, "#B59A50": CAL}, reason="PBISC conditions and LoRA, with observed references black.")
+rule("sec05_behcet_direction", {"#E8DDAE": RAW, "#B59A50": CAL}, reason="Raw-bulk PBISC diagnostic; neutral observed and pseudobulk oracle controls retained.")
+rule("matched_similarity nearest_real_by_type labels_within_type_centroids stored_matched_trajectories raw_tpm_top_genes donor_axes reference_choice depth_matched_quality labels_detection_and_library",
+     INPUTS, reason="PBISC input-condition variants only. Distinct six-cell-type palette and reference grey are untouched; no LoRA in these panels.")
+rule("sle_conditioning_interventions", {"#C5AA4B": LO, "#806A25": FULL, "#B59A50": CAL, "#E8DDAE": RAW}, reason="PBISC conditioning intervention variants; not disease/cohort-category colours.")
+rule("strict_sepsis_quality strict_sepsis_realism strict_imperial_draw0_quality", {"#C5AA4B": LO, "#2166AC": SC, "#E9DFB9": RAW, "#D7C788": "#88BFE4", "#97802C": CAL}, reason="Five explicit strict comparison methods; real/real remains grey.")
+rule("behcet_k4000", {"#DDD0A0": RAW, "#C5AA4B": LO, "#826B22": FULL}, reason="Raw versus LoRA K1000/K4000 method settings.")
+rule("k4000_quality k4000_disease k4000_calibration", {"#C5AA4B": LO, "#826B22": FULL}, reason="Existing PBISC K1000/K4000 recipe variants.")
+rule("deconv_expression_coverage", {"#6A51A3": CX}, reason="CIBERSORTx method, with open-marker missingness retained.")
+rule("fig_randolph_celltype_response", {"#E8DDAE": RAW, "#B59A50": "#82BDE3", "#978034": CAL, "#806A25": "#79B8E0", "#2166AC": SC}, reason="PBISC raw/refcal/cal/pseudobulk conditions; neutral measured/oracle broadcasts retained.")
+rule("gene_length_input gene_length_stable refcal_top_genes healthy_ft_comparison sle_disjoint_truth_control", reason="Source-native role-specific replay, required by embedded method rasters/shared colour roles.", mode="native")
+rule("fig2_covid_hc_monocyte_arrows_depth1000", reason="PNG-only recorded map: recolour only source-defined method arrows/legend in their known panels; protect every other pixel.", mode="scoped-raster")
+
+
+def sha(path):
+    with Path(path).open("rb") as handle:
+        return hashlib.file_digest(handle, "sha256").hexdigest()
+
+
+def binding(path, role="source"):
+    p = Path(path).resolve()
+    return {"path": str(p), "sha256": sha(p), "bytes": p.stat().st_size, "role": role}
+
+
+def dump(path, obj):
+    Path(path).write_text(json.dumps(obj, indent=2, allow_nan=False) + "\n")
+
+
+def module(name):
+    p = D / "tools" / f"{name}.py"
+    spec = importlib.util.spec_from_file_location("_final_palette_" + name, p)
+    obj = importlib.util.module_from_spec(spec); spec.loader.exec_module(obj)
+    return obj
+
+
+def collect(spec_path):
+    spec = json.loads(Path(spec_path).read_text())
+    assets = {}
+    for number, slide in enumerate(spec["slides"], 1):
+        for value in slide.get("figures", []):
+            p = Path(value); p = p if p.is_absolute() else D / p
+            assets.setdefault(p.resolve(), []).append(number)
+    extra = D / "data/pair_budget_celltypes_20261013/result.json"
+    if extra.exists():
+        for slide in json.loads(extra.read_text())["slides"]:
+            for value in slide["figures"]:
+                p = Path(value); p = p if p.is_absolute() else D / p
+                assets.setdefault(p.resolve(), [])
+    missing = [str(p) for p in assets if p.stem not in RULES]
+    if missing:
+        raise ValueError("Unclassified semantic assets: " + "; ".join(missing))
+    return assets
+
+
+def pdf_geometry(source, target, *, caption_change=False, backbone_caption_change=False):
+    left, right = V._geometry(Path(source)), V._geometry(Path(target))
+    if caption_change or backbone_caption_change:
+        for document in (left, right):
+            for page in document:
+                for block in page["text_geometry"].get("blocks", []):
+                    for line in block.get("lines", []):
+                        # Character lists are used by rawdict; remove only the
+                        # explicitly permitted colour-word caption line.
+                        for span in line.get("spans", []):
+                            text = "".join(c["c"] for c in span.get("chars", []))
+                            permitted = (caption_change and "bars: generated log1p cp10k shift" in text.lower()) or (backbone_caption_change and text in {"orange = changed from SDD", "Highlighted = changed from SDD"})
+                            if permitted:
+                                span.clear(); line.pop("bbox", None); block.pop("bbox", None)
+    if left != right:
+        raise ValueError("Native rerender changed text/page geometry: " + str(source))
+    return True
+
+
+def native_backbone(source):
+    """Replay only the original table drawing block, using its frozen 18-cell CSV."""
+    import matplotlib.pyplot as plt
+    source = Path(source)
+    renderer = D / "tools/sec02_backbone.py"
+    original_csv = D / "data/sec02_backbone_compare.csv"
+    frame = pd.read_csv(original_csv, keep_default_na=False)
+    if len(frame) != 18 or frame.duplicated(["row", "model"]).any():
+        raise ValueError("Backbone table must contain the original 18 distinct cells")
+    text = renderer.read_text()
+    parsed = ast.parse(text)
+    literals = {node.targets[0].id: ast.literal_eval(node.value) for node in parsed.body
+                if isinstance(node, ast.Assign) and len(node.targets) == 1
+                and isinstance(node.targets[0], ast.Name) and node.targets[0].id in {"ROWS", "COLS"}}
+    cells = {}; states = {}
+    for row in frame.itertuples(index=False):
+        value = tuple(row.cell_text.split(" | ")) if row.vs_sdd == "partial" else row.cell_text
+        cells[(row.row, row.model)] = (value, [])
+        if row.model == "PBISC-Diffusion": states[row.row] = (row.vs_sdd, row.vs_sdd_basis)
+    if set(cells) != {(row, name) for row in literals["ROWS"] for name, _ in literals["COLS"]}:
+        raise ValueError("Backbone table axes do not match source renderer")
+    start = 'W, H = style.FULL[0], 4.5'
+    stop = 'style.save(fig, "sec02_backbone_compare", FIG)'
+    if text.count(start) != 1 or text.count(stop) != 1:
+        raise ValueError("Backbone drawing section is ambiguous")
+    block = text[text.index(start):text.index(stop) + len(stop)]
+    if block.count('PB = style.ARM["pbisc"]') != 1 or block.count('"orange = changed from SDD"') != 1:
+        raise ValueError("Expected backbone palette/caption not found")
+    block = block.replace('PB = style.ARM["pbisc"]', 'PB = "#168FE5"').replace('"orange = changed from SDD"', '"Highlighted = changed from SDD"')
+    outdir = FIG / "native"; outdir.mkdir(parents=True, exist_ok=True)
+    datadir = DATA / "native"; datadir.mkdir(parents=True, exist_ok=True)
+    with plt.rc_context():
+        style = module("style")
+        scope = {**literals, "cells": cells, "VS_SDD": states, "style": style, "plt": plt, "FIG": outdir}
+        exec(compile(block, str(renderer) + "::comparison-only", "exec"), scope)
+    copied_csv = datadir / original_csv.name
+    shutil.copyfile(original_csv, copied_csv)
+    target_pdf = outdir / source.with_suffix(".pdf").name
+    pdf_geometry(source.with_suffix(".pdf"), target_pdf, backbone_caption_change=True)
+    return {"png": str(outdir/source.name), "pdf": str(target_pdf), "original": binding(source),
+            "original_pdf": binding(source.with_suffix(".pdf")), "sources": [binding(renderer), binding(D/"tools/style.py"), binding(original_csv)],
+            "original_csv": binding(original_csv), "new_csv": binding(copied_csv),
+            "numeric_csv_equal": sha(original_csv) == sha(copied_csv), "table_cells_preserved": 18,
+            "text_geometry_preserved_except_declared_caption": True,
+            "text_changes": [{"old": "orange = changed from SDD", "new": "Highlighted = changed from SDD", "reason": "Remove obsolete colour word"}],
+            "mapping": {"#D55E00": LO}, "preservation_pass": True}
+
+
+def vector_k_variants(source):
+    """Translate only source-proven PBISC bar colours, including PDF DeviceGray."""
+    source = Path(source)
+    target_pdf = FIG / source.with_suffix(".pdf").name
+    target_png = FIG / source.name
+    gray_rules = {"#5E5E5E": CAL, "#BDBDBD": RAW}
+    counts = {old: 0 for old in gray_rules}; stream_proofs = []
+    with tempfile.TemporaryDirectory(prefix=".k-variants-", dir=FIG) as tmp:
+        intermediate = Path(tmp)/"plain.pdf"; updated = Path(tmp)/target_pdf.name
+        plain_proof = V.recolor_pdf(source.with_suffix(".pdf"), intermediate, {"#C5AA4B": LO})
+        with V.pikepdf.Pdf.open(intermediate) as pdf:
+            images_before = V._image_payloads(pdf)
+            expected = {}
+            for label, stream in V._content_streams(pdf):
+                before = list(V.pikepdf.parse_content_stream(stream)); after = list(before); slots = []
+                for index, instruction in enumerate(before):
+                    if str(instruction.operator) != "g": continue
+                    for old, new in gray_rules.items():
+                        gray = int(old[1:3], 16)/255
+                        if len(instruction.operands) == 1 and abs(float(instruction.operands[0])-gray) < 1e-8:
+                            after[index] = V.pikepdf.ContentStreamInstruction(list(V._rgb(new)), V.pikepdf.Operator("rg"))
+                            slots.append(index); counts[old] += 1
+                kept_before = [item for i,item in enumerate(before) if i not in slots]
+                kept_after = [item for i,item in enumerate(after) if i not in slots]
+                before_hash = V._fingerprint(kept_before, ignore_rgb=False)
+                if before_hash != V._fingerprint(kept_after, ignore_rgb=False):
+                    raise ValueError("Non-target PDF operator changed")
+                expected[label] = V._fingerprint(after, ignore_rgb=False)
+                if slots:
+                    stream.write(V.pikepdf.unparse_content_stream(after))
+                    stream_proofs.append({"stream":label,"changed_color_slots":slots,"all_other_operator_sha256":before_hash})
+            if counts != {"#5E5E5E":10,"#BDBDBD":10}:
+                raise ValueError("K-variant grey operand counts differ from the source-defined five bars per arm: " + repr(counts))
+            pdf.save(updated)
+        with V.pikepdf.Pdf.open(updated) as pdf:
+            actual = {label: V._fingerprint(list(V.pikepdf.parse_content_stream(stream)), ignore_rgb=False)
+                      for label, stream in V._content_streams(pdf)}
+            if actual != expected or V._image_payloads(pdf) != images_before:
+                raise ValueError("Serialized K-variant content/image preservation failed")
+        pdf_geometry(source.with_suffix(".pdf"), updated)
+        png = Path(tmp)/target_png.name
+        render = V.render_pdf_to_png(updated, png, dpi=200)
+        updated.replace(target_pdf); png.replace(target_png)
+    render.update(pdf=str(target_pdf), png=str(target_png))
+    return {"png":str(target_png),"pdf":str(target_pdf),"original":binding(source),
+            "original_pdf":binding(source.with_suffix(".pdf")),"renderer":binding(D/"tools/sec07_k_aug.py"),
+            "plain_lora_rgb_proof":plain_proof,"devicegray_to_rgb":gray_rules,"matched_color_operators":counts,
+            "method_bar_count":{"multi_k":5,"half_batch_recipes":5},"stream_proofs":stream_proofs,
+            "all_non_target_operators_preserved":True,"text_geometry_preserved":True,
+            "image_payloads_preserved":True,"render":render,"preservation_pass":True}
+
+
+def native_replays(needed):
+    import matplotlib.pyplot as plt
+    from matplotlib.colors import to_hex
+    from matplotlib.text import Text
+    h = module("expanded_healthy_materials")
+    h.FIG = FIG / "native"; h.DATA = DATA / "native"
+    h.FIG.mkdir(parents=True, exist_ok=True); h.DATA.mkdir(parents=True, exist_ok=True)
+    for arm, old in list(h.COL.items()):
+        h.COL[arm] = INPUTS.get(old, old)
+
+    class Replay(h.MaterialBuilder):
+        def finish(self, fig, key, *args, **kwargs):
+            if key == "sle_disjoint_truth_control":
+                colors = {"#aaaaaa": BP, "#cccccc": CX, "#c5aa4b": LO, "#2166ac": SC}
+                for ax in fig.axes:
+                    for patch in ax.patches:
+                        old = to_hex(patch.get_facecolor())
+                        if old in colors: patch.set_facecolor(colors[old])
+            if key == "refcal_top_genes":
+                for text in fig.findobj(match=Text):
+                    if "Gold bars:" in text.get_text():
+                        text.set_text(text.get_text().replace("Gold bars:", "Bars:"))
+            super().finish(fig, key, *args, **kwargs)
+
+    b = Replay()
+    settings = {"font.family":"sans-serif", "font.sans-serif":["Arial","Liberation Sans","DejaVu Sans"],
+                "font.size":14,"axes.labelsize":14,"axes.titlesize":14,"xtick.labelsize":12,"ytick.labelsize":12,
+                "legend.fontsize":12,"axes.spines.top":False,"axes.spines.right":False,"axes.linewidth":1.,
+                "pdf.fonttype":42,"ps.fonttype":42,"svg.fonttype":"none","figure.facecolor":"white","axes.facecolor":"white"}
+    with plt.rc_context(settings):
+        if "gene_length_input" in needed: h.gene_length(b, False)
+        if "gene_length_stable" in needed: h.gene_length(b, True)
+        if "refcal_top_genes" in needed: h.top_genes(b, True)
+        if "sle_disjoint_truth_control" in needed: h.split_half(b)
+    proofs = {}
+    for key in needed - {"healthy_ft_comparison"}:
+        original_csv = D / "data/expanded_master_20261013/healthy" / f"{key}.csv"
+        generated_csv = h.DATA / f"{key}.csv"
+        pd.testing.assert_frame_equal(pd.read_csv(original_csv), pd.read_csv(generated_csv), check_exact=True, check_dtype=False)
+        proofs[key] = {"png": str(h.FIG / f"{key}.png"), "pdf": str(h.FIG / f"{key}.pdf"),
+                       "sources": list(b.sources.values()), "numeric_csv_equal": True,
+                       "original_csv": binding(original_csv), "new_csv": binding(generated_csv),
+                       "text_changes": [{"old":"Gold bars:","new":"Bars:","reason":"Remove obsolete colour word"}] if key == "refcal_top_genes" else []}
+    if "healthy_ft_comparison" in needed:
+        f = module("figure_order_healthy_ft_20261013")
+        f.FIG = FIG / "native"; f.DATA = DATA / "native"
+        f.COLORS = [RAW, CAL, FULL, LO]
+        result = f.build()
+        pd.testing.assert_frame_equal(pd.read_csv(D / "data/figure_order_fixed_20261013/healthy_ft_comparison.csv"),
+                                      pd.read_csv(f.DATA / "healthy_ft_comparison.csv"), check_exact=True, check_dtype=False)
+        proofs["healthy_ft_comparison"] = {"png": str(f.FIG / "healthy_ft_comparison.png"),
+                                            "pdf": str(f.FIG / "healthy_ft_comparison.pdf"),
+                                            "numeric_csv_equal": True, "source_renderer_proof": result, "text_changes": [],
+                                            "method_colors": dict(zip(f.ORDER, f.COLORS)),
+                                            "numerical_estimates_count": 12,
+                                            "role_separation": "Full FT uses #0D6EA8; paired calibration #59A8DF; LoRA #168FE5"}
+    return proofs
+
+
+def scoped_arrow_png(source):
+    """Translate unambiguous method-colour cores and white antialias edges only."""
+    from scipy.ndimage import binary_dilation
+    colors = {"#D62728": RAW, "#7B3294":"#A6D4EF", "#1A9850":"#78B8E1", "#91CF60":"#91C7E8", "#E08214":CAL, "#1F5FBF":"#439ACF"}
+    panel = {"#D62728":(1,0), "#7B3294":(2,0), "#1A9850":(3,0), "#91CF60":(0,1), "#E08214":(1,1), "#1F5FBF":(2,1)}
+    with Image.open(source) as im:
+        array = np.asarray(im.convert("RGBA")).copy(); dpi = im.info.get("dpi", (150,150))
+    result = array.copy(); rgb = array[:,:,:3]; height,width = rgb.shape[:2]
+    biological = ["#C2A5CF","#A6DBA0","#1B7837","#762A83"]
+    changed = np.zeros((height,width), dtype=bool); masks = {}; records=[]
+    for old,new in colors.items():
+        c = np.asarray([int(old[i:i+2],16) for i in (1,3,5)],dtype=float)
+        target = np.asarray([int(new[i:i+2],16) for i in (1,3,5)],dtype=float)
+        column,row = panel[old]
+        allowed = np.zeros((height,width),dtype=bool)
+        # Wide subplot regions derive from the original 2x4 source layout.
+        x0,x1=int(column*width/4),int((column+1)*width/4)
+        y0,y1=(int(.12*height),int(.52*height)) if row==0 else (int(.50*height),int(.87*height))
+        allowed[y0:y1,x0:x1]=True
+        allowed[int(.48*height):,int(.77*width):]=True  # PCA vector comparison + method legend
+        core=np.all(rgb==c.astype(np.uint8),axis=2)&allowed
+        if int(core.sum())<20: raise ValueError("Method colour core missing: "+old)
+        candidate=binary_dilation(core,iterations=1)&allowed&~core
+        ys,xs=np.where(candidate);pixels=rgb[ys,xs].astype(float);direction=255-c
+        alpha=((255-pixels)@direction)/(direction@direction)
+        expected=255-alpha[:,None]*direction
+        good=(alpha>=.08)&(alpha<=1)&(np.max(np.abs(expected-pixels),axis=1)<=.65)
+        for bio in biological:
+            bc=np.asarray([int(bio[i:i+2],16) for i in (1,3,5)],dtype=float);bd=255-bc
+            ba=((255-pixels)@bd)/(bd@bd)
+            ambiguous=(ba>=.04)&(ba<=1)&(np.max(np.abs((255-ba[:,None]*bd)-pixels),axis=1)<=1.0)
+            good &= ~ambiguous
+        mask=core.copy();mask[ys[good],xs[good]]=True
+        if np.any(mask&changed):raise ValueError("Method pixel masks overlap")
+        result[core,:3]=target.astype(np.uint8)
+        result[ys[good],xs[good],:3]=np.rint(255-alpha[good,None]*(255-target)).clip(0,255).astype(np.uint8)
+        changed |= mask;masks[old]=mask
+        records.append({"old":old,"new":new,"opaque_core_pixels":int(core.sum()),"unambiguous_antialias_pixels":int(good.sum()),
+                        "panel":list(panel[old]),"panel_rectangle_pixels":[x0,y0,x1,y1],
+                        "summary_rectangle_pixels":[int(.77*width),int(.48*height),width,height]})
+    if not np.array_equal(result[~changed],array[~changed]) or not np.array_equal(result[:,:,3],array[:,:,3]):
+        raise ValueError("Protected pixel/alpha preservation failed")
+    for bio in biological:
+        c=np.asarray([int(bio[i:i+2],16) for i in (1,3,5)],dtype=np.uint8);mask=np.all(rgb==c,axis=2)
+        if not np.array_equal(result[mask],array[mask]):raise ValueError("Biological core colours changed")
+    target=FIG/(source.stem+'.png');Image.fromarray(result,'RGBA').save(target,dpi=dpi)
+    pdf=target.with_suffix('.pdf')
+    with fitz.open() as doc:
+        page=doc.new_page(width=width*72/dpi[0],height=height*72/dpi[1]);page.insert_image(page.rect,filename=str(target));doc.save(pdf)
+    svg=target.with_suffix('.svg');svg.write_text(f'<svg xmlns="http://www.w3.org/2000/svg" width="{width}" height="{height}" viewBox="0 0 {width} {height}"><image width="{width}" height="{height}" href="data:image/png;base64,{base64.b64encode(target.read_bytes()).decode()}"/></svg>\n')
+    maskpath=DATA/(source.stem+'_method_masks.npz');np.savez_compressed(maskpath,**{key.removeprefix('#'):value for key,value in masks.items()})
+    proof={"mode":"source-defined scientific raster chart colour translation", "source":binding(source),
+           "mapping":colors,"method_masks":records,"mask_file":binding(maskpath),"image_dimensions":[width,height],
+           "changed_pixels":int(changed.sum()),"protected_pixels":int((~changed).sum()),"protected_pixels_bit_exact":True,
+           "alpha_channel_bit_exact":True,"biological_core_colours_bit_exact":True,"pixel_positions_unchanged":True,
+           "geometry_or_statistic_recomputation":False,"ambiguous_antialias_pixels":"left unchanged",
+           "source_definition":str(D.parents[1]/'plans/utility_studies_final6k_20260925/refcal_scoring/arunachalam/tools/analyze_placement_refcal.py'),
+           "preservation_pass":True,"png":str(target),"pdf":str(pdf),"svg":str(svg)}
+    return proof
+
+
+def run(spec_path=DEFAULT_SPEC, *, prepare_only=False):
+    DATA.mkdir(parents=True,exist_ok=True);FIG.mkdir(parents=True,exist_ok=True)
+    assets=collect(spec_path)
+    catalog={str(path):{**RULES[path.stem],"slides":pages} for path,pages in assets.items()}
+    dump(DATA/'SEMANTIC_MAP.json',{"decision":binding(DECISION),"input_spec":binding(spec_path),"assets":catalog})
+    if prepare_only:return {"assets_classified":len(catalog),"semantic_map":str(DATA/'SEMANTIC_MAP.json')}
+    originals={str(path):sha(path) for path in assets}
+    for path in assets:
+        if path.with_suffix('.pdf').exists():originals[str(path.with_suffix('.pdf'))]=sha(path.with_suffix('.pdf'))
+    dump(DATA/'ORIGINALS_BEFORE.json',originals)
+    needed={p.stem for p in assets if RULES[p.stem]['mode']=='native'}
+    native=native_replays(needed)
+    mapping={};records=[];sources=[binding(DECISION),binding(spec_path),binding(Path(__file__)),binding(D/'tools/review_palette_pdf.py')]
+    for path,pages in assets.items():
+        r=RULES[path.stem];mode=r['mode'];record={"original":str(path),"source_png_sha256":originals[str(path)],"slides":pages,"reason":r['reason'],"action":mode}
+        sources.append(binding(path,'original figure'))
+        if mode in {'preserve','approved-native'}:
+            mapping[str(path)]=str(path);record['output']=str(path);record['preservation_pass']=True
+        elif mode=='native':
+            proof=native[path.stem];out=Path(proof['png']);pdf_geometry(path.with_suffix('.pdf'),Path(proof['pdf']),caption_change=path.stem=='refcal_top_genes')
+            proof.update({'original':binding(path),'original_pdf':binding(path.with_suffix('.pdf')),'text_geometry_preserved_except_declared_caption':True,'preservation_pass':True})
+            receipt=DATA/(path.stem+'.proof.json');dump(receipt,proof);mapping[str(path)]=str(out);record.update(output=str(out),proof=str(receipt),preservation_pass=True)
+        elif mode=='scoped-raster':
+            proof=scoped_arrow_png(path);receipt=DATA/(path.stem+'.proof.json');dump(receipt,proof);mapping[str(path)]=proof['png'];record.update(output=proof['png'],proof=str(receipt),preservation_pass=True)
+        elif mode=='native-backbone':
+            proof=native_backbone(path);receipt=DATA/(path.stem+'.proof.json');dump(receipt,proof);mapping[str(path)]=proof['png'];record.update(output=proof['png'],proof=str(receipt),preservation_pass=True)
+        elif mode=='vector-gray-variants':
+            proof=vector_k_variants(path);receipt=DATA/(path.stem+'.proof.json');dump(receipt,proof);mapping[str(path)]=proof['png'];record.update(output=proof['png'],proof=str(receipt),preservation_pass=True)
+        else:
+            original_pdf=path.with_suffix('.pdf')
+            if not original_pdf.is_file():raise FileNotFoundError('No vector companion for '+str(path))
+            sources.append(binding(original_pdf,'source vector figure'))
+            target_pdf=FIG/(path.stem+'.pdf');target_png=FIG/(path.stem+'.png')
+            with tempfile.TemporaryDirectory(prefix='.build-',dir=FIG) as tmp:
+                pdf=Path(tmp)/target_pdf.name;png=Path(tmp)/target_png.name
+                proof=V.recolor_pdf(original_pdf,pdf,r['mapping'],rgb_tolerance=5.1e-7 if path.stem=='fig1b_overview_nature' else 1e-8)
+                render=V.render_pdf_to_png(pdf,png,dpi=300 if path.stem=='fig1b_overview_nature' else 200)
+                pdf.replace(target_pdf);png.replace(target_png)
+            proof['destination']=str(target_pdf);render.update(pdf=str(target_pdf),png=str(target_png));proof.update(render=render,semantic_reason=r['reason'],source_png=binding(path))
+            receipt=DATA/(path.stem+'.proof.json');dump(receipt,proof);mapping[str(path)]=str(target_png);record.update(output=str(target_png),proof=str(receipt),preservation_pass=True)
+        record['output_sha256']=sha(mapping[str(path)]);records.append(record)
+    changed=[path for path,expected in originals.items() if sha(path)!=expected]
+    if changed:raise ValueError('Original assets changed: '+repr(changed))
+    outputs=[str(path) for root in (FIG,DATA/'native') for path in root.rglob('*') if path.is_file()]
+    outputs += [str(p) for p in DATA.glob('*.proof.json')]+[str(p) for p in DATA.glob('*_method_masks.npz')]
+    result={"schema":"pbisc.final-deck-palette.v1","decision":binding(DECISION),"mapping":mapping,"records":records,
+            "sources":sources,"assets":sorted(set(outputs)),"coverage":{"total":len(assets),"mapped":len(mapping),"preservation_pass":all(r['preservation_pass'] for r in records)},
+            "originals_unchanged":True,"no_new_inference":True,"no_new_statistics":True,
+            "native_text_exception":"'Gold bars:' becomes 'Bars:' in refcal_top_genes; 'orange = changed from SDD' becomes 'Highlighted = changed from SDD' in sec02_backbone_compare. All table values and other text stay fixed.",
+            "raster_exception":"One PNG-only COVID arrow plot uses saved source colours and protected per-method pixel masks; no coordinate fit or resampling.",
+            "unresolved":[]}
+    dump(DATA/'ASSET_MAP.json',result);dump(DATA/'result.json',result)
+    return result
+
+
+if __name__=='__main__':
+    parser=argparse.ArgumentParser(description=__doc__);parser.add_argument('--spec',type=Path,default=DEFAULT_SPEC);parser.add_argument('--prepare-only',action='store_true');args=parser.parse_args()
+    result=run(args.spec,prepare_only=args.prepare_only)
+    print(json.dumps(result.get('coverage',result),indent=2))