Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20260930T065633Z-summary-deck-scsemi-final/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/README.md

@@ -0,0 +1,56 @@
+# PBISC-Diffusion paper summary deck (2026-09-30, r00)
+
+29-slide English summary of the PBISC-Diffusion (Model 8) paper experiments: title,
+outline, 10 sections (24 content slides), then a Backup divider and 3 backup slides.
+Short keyword lines only; the figures carry the results. Section 10 is planned work.
+
+- `PBISC-Diffusion_paper_summary_20260930.pptx`: the deck
+- `PBISC-Diffusion_paper_summary_20260930.pdf`: LibreOffice PDF of the deck
+- `data/slides_spec.json`: slide order, titles, keywords, footnotes, speaker-note text
+- `generate_deck.py`: builds the pptx from `data/slides_spec.json` only (python-pptx)
+- `figures/`: all slide figures (PNG + PDF), made by `tools/sec*.py`
+- `data/sec*.csv`, `data/sec09_slide_text.json`: every plotted or quoted number with its source path
+- `render/`: PDF and 70-dpi slide JPGs for checking
+
+## Rebuild
+
+Everything is CPU only; no GPU or checkpoint is touched.
+
+```bash
+cd /home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/presentations/2026-09-30--paper-summary--r00
+# figures + data tables (sec03_common.py and style.py are shared helpers, not run directly)
+for f in sec01_overview sec02_backbone sec03_width_loss sec03_width_bench sec03_panel \
+         sec04_sle_benchmark sec04_immicro sec05_condition_space sec05_cells_offmanifold \
+         sec05_behcet_direction sec05_shift_cohorts sec06_finetune_method sec07_ft_modes \
+         sec07_k_aug sec08_pairs_needed sec09_paired_validation sec10_paired_subset_cohorts; do
+  python3 "tools/$f.py" || break
+done
+python3 tools/sync_sec09_text.py      # copy regenerated section 9 text into data/slides_spec.json
+python3 generate_deck.py              # -> PBISC-Diffusion_paper_summary_20260930.pptx
+soffice --headless --convert-to pdf --outdir render PBISC-Diffusion_paper_summary_20260930.pptx
+pdftoppm -jpeg -r 70 render/PBISC-Diffusion_paper_summary_20260930.pdf render/slide
+cp render/PBISC-Diffusion_paper_summary_20260930.pdf .
+```
+
+`generate_deck.py` stops with an error if a figure is missing, a title does not fit on one
+line, a footnote needs more than 2 lines, or any text contains Korean or placeholder words.
+
+## Notes
+
+- Section 9 (few-pair scSemiProfiler comparison) uses all 25 scSemiProfiler draws
+  (5 cohorts x 5 draws). If scores change, rerun `tools/sec09_paired_validation.py`, then
+  `tools/sync_sec09_text.py`, then check the short footnotes it lists and rebuild.
+- On-slide footnotes are one short line; the full source and method text is in the speaker
+  notes (`footnote_full` in the spec).
+- `DRAFT_1150_*`: frozen copy shown at the 2026-09-30 12:00 meeting (23/25 scSemiProfiler
+  draws, long footnotes). Superseded by the files above.
+- The ImMicro external-reference slide (made by `tools/sec04_immicro.py`) sits at the end of
+  section 5, after refcal is introduced.
+
+## Sources
+
+Final model: `runs/f01_6k_1x_seed20260627` (epoch 16, EMA). Scores and receipts come from
+`plans/utility_studies_final6k_20260925/`, `plans/paired_finetune_intradataset_20260927/`,
+`plans/immicro_scsemi_comparison_20260927/`, `plans/floor01_campaign_20260923/`,
+`analysis/scsemi_benchmark_diffusion_20260913/` and the run folders named in each
+`data/sec*.csv`. Manuscript: `/home/sj_server_1/PBISC/paper-release-20260928/manuscript/`.

paper-releases/pbisc-diffusion/updates/20260930T065633Z-summary-deck-scsemi-final/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/generate_deck.py

@@ -0,0 +1,340 @@
+#!/usr/bin/env python3
+"""Build the PBISC-Diffusion paper-summary deck.
+
+Reads data/slides_spec.json only and writes
+PBISC-Diffusion_paper_summary_20260930.pptx next to this script.
+Rerunnable; CPU only.
+
+Design rules (user request: plain, clean, no decoration):
+  16:9 13.333 x 7.5 in, white background, Arial only.
+  Text #1A1A1A, footnotes / labels #6E6E6E. Colour only inside figures.
+  Title 26 pt bold at (0.45, 0.30); section label 11 pt grey, top right.
+  Figures fill x 0.45-12.9, y 1.05-6.75, aspect kept, never cropped.
+  Keywords 16 pt, max 3 lines of content, beside or below the figure.
+  Footnote 9 pt grey from y 7.0, at most 2 lines; slide number bottom right.
+
+The script measures text with the Arial TrueType metrics and fails loudly
+if a title, keyword block or footnote would not fit.
+"""
+from __future__ import annotations
+
+import json
+import re
+import sys
+from pathlib import Path
+
+from PIL import Image, ImageFont
+from pptx import Presentation
+from pptx.dml.color import RGBColor
+from pptx.enum.text import MSO_ANCHOR, PP_ALIGN
+from pptx.util import Emu, Inches, Pt
+
+DECK = Path(__file__).resolve().parent
+SPEC = DECK / "data" / "slides_spec.json"
+
+# ---------------------------------------------------------------- geometry
+SLIDE_W, SLIDE_H = 13.333, 7.5
+X0, X1 = 0.45, 12.9            # content left / right
+Y0, YFIG1 = 1.05, 6.75         # figure top / bottom limit
+KW_BOTTOM = 6.85               # keywords below a figure must end here
+FOOT_Y = 7.0                   # footnote top
+FOOT_W = 11.6                  # leaves room for the slide number
+GAP_BELOW = 0.20               # figure -> keywords (below)
+GAP_RIGHT = 0.35               # figure -> keyword column (right)
+MIN_COL = 2.9                  # narrowest keyword column
+FIG_GAP = 0.25                 # between two figures
+
+INK = RGBColor(0x1A, 0x1A, 0x1A)
+GREY = RGBColor(0x6E, 0x6E, 0x6E)
+WHITE = RGBColor(0xFF, 0xFF, 0xFF)
+FONT = "Arial"
+
+TITLE_PT, LABEL_PT, KW_PT, FOOT_PT, NUM_PT = 26, 11, 16, 9, 9
+AGENDA_PT, COVER_PT, COVER_SUB_PT = 18, 36, 18
+LINE = 1.2                     # line height / font size used for layout
+KW_PARA_GAP_PT = 6
+
+_FONT_FILES = {
+    False: "/usr/share/fonts/truetype/msttcorefonts/Arial.ttf",
+    True: "/usr/share/fonts/truetype/msttcorefonts/arialbd.ttf",
+}
+_font_cache: dict = {}
+
+HANGUL = re.compile("[ᄀ-ᇿ㄰-㆏가-힣]")
+
+
+def text_w_in(text: str, pt: float, bold: bool = False) -> float:
+    """Rendered width of one line in inches (Arial metrics)."""
+    key = bold
+    if key not in _font_cache:
+        _font_cache[key] = ImageFont.truetype(_FONT_FILES[bold], 1000)
+    return _font_cache[key].getlength(text) * pt / 1000.0 / 72.0
+
+
+def wrap(text: str, pt: float, width_in: float, bold: bool = False) -> list[str]:
+    words, lines, cur = text.split(" "), [], ""
+    for w in words:
+        trial = w if not cur else cur + " " + w
+        if text_w_in(trial, pt, bold) <= width_in:
+            cur = trial
+        else:
+            if cur:
+                lines.append(cur)
+            cur = w
+    if cur:
+        lines.append(cur)
+    return lines
+
+
+def line_h(pt: float) -> float:
+    return pt * LINE / 72.0
+
+
+def kw_block_h(keywords: list[str], width_in: float) -> float:
+    n_lines = sum(len(wrap(k, KW_PT, width_in)) for k in keywords)
+    return n_lines * line_h(KW_PT) + (len(keywords) - 1) * KW_PARA_GAP_PT / 72.0
+
+
+# ---------------------------------------------------------------- helpers
+def check_text(s: str, where: str) -> None:
+    if HANGUL.search(s):
+        sys.exit(f"Korean text in {where}: {s!r}")
+    for bad in ("TODO", "TBD", "lorem", "xxxx", "PLACEHOLDER"):
+        if bad.lower() in s.lower():
+            sys.exit(f"placeholder text {bad!r} in {where}: {s!r}")
+
+
+def white_bg(slide) -> None:
+    fill = slide.background.fill
+    fill.solid()
+    fill.fore_color.rgb = WHITE
+
+
+def add_text(slide, x, y, w, h, paras, pt, color=INK, bold=False,
+             align=PP_ALIGN.LEFT, anchor=MSO_ANCHOR.TOP, wrap_text=True,
+             space_before_pt=0):
+    """paras: list of strings, one paragraph each."""
+    tb = slide.shapes.add_textbox(Inches(x), Inches(y), Inches(w), Inches(h))
+    tf = tb.text_frame
+    tf.word_wrap = wrap_text
+    tf.auto_size = None
+    tf.margin_left = tf.margin_right = tf.margin_top = tf.margin_bottom = Emu(0)
+    tf.vertical_anchor = anchor
+    for i, text in enumerate(paras):
+        p = tf.paragraphs[0] if i == 0 else tf.add_paragraph()
+        p.alignment = align
+        p.line_spacing = 1.0
+        if i > 0 and space_before_pt:
+            p.space_before = Pt(space_before_pt)
+        r = p.add_run()
+        r.text = text
+        f = r.font
+        f.name = FONT
+        f.size = Pt(pt)
+        f.bold = bold
+        f.color.rgb = color
+    return tb
+
+
+def add_title(slide, title: str, label: str | None) -> None:
+    label_w = text_w_in(label, LABEL_PT) if label else 0.0
+    room = (X1 - X0) - (label_w + 0.3 if label else 0.0)
+    tw = text_w_in(title, TITLE_PT, bold=True)
+    if tw > room:
+        sys.exit(f"title too long ({tw:.2f} > {room:.2f} in): {title!r}")
+    # title box stops short of the section label so the two never overlap
+    add_text(slide, X0, 0.30, min(12.4, room), 0.5, [title], TITLE_PT,
+             bold=True, wrap_text=False)
+    if label:
+        # baseline of the label aligned with the title baseline
+        asc = 0.905
+        y = 0.30 + asc * TITLE_PT / 72.0 - asc * LABEL_PT / 72.0
+        add_text(slide, X1 - label_w - 0.05, y, label_w + 0.05, 0.25, [label],
+                 LABEL_PT,
+                 color=GREY, align=PP_ALIGN.RIGHT, wrap_text=False)
+
+
+def add_footer(slide, footnote: str | None, number: int) -> None:
+    if footnote:
+        lines = wrap(footnote, FOOT_PT, FOOT_W)
+        if len(lines) > 2:
+            sys.exit(f"footnote needs {len(lines)} lines (max 2): {footnote!r}")
+        add_text(slide, X0, FOOT_Y, FOOT_W, 2 * line_h(FOOT_PT) + 0.02,
+                 [footnote], FOOT_PT, color=GREY)
+    add_text(slide, X1 - 0.6, FOOT_Y, 0.6, line_h(NUM_PT), [str(number)],
+             NUM_PT, color=GREY, align=PP_ALIGN.RIGHT, wrap_text=False)
+
+
+def add_notes(slide, s: dict) -> None:
+    parts = []
+    if s.get("say"):
+        parts.append(s["say"])
+    full = s.get("footnote_full")
+    if full and full != s.get("footnote"):
+        parts.append("Full footnote: " + full)
+    if s.get("sources"):
+        parts.append("Sources: " + s["sources"])
+    if parts:
+        slide.notes_slide.notes_text_frame.text = "\n\n".join(parts)
+
+
+# ---------------------------------------------------------------- layout
+def aspect(path: Path) -> float:
+    with Image.open(path) as im:
+        w, h = im.size
+    return w / h
+
+
+def fit(total_aspect: float, extra_w: float, wmax: float, hmax: float):
+    """Largest (w, h) with w = h * total_aspect + extra_w inside the box."""
+    h = min(hmax, (wmax - extra_w) / total_aspect)
+    return h * total_aspect + extra_w, h
+
+
+def plan(aspects: list[float], keywords: list[str], layout: str):
+    """Return dict with figure height/width and keyword placement."""
+    n = len(aspects)
+    tot = sum(aspects)
+    extra = FIG_GAP * (n - 1)
+    full_w, full_h = X1 - X0, YFIG1 - Y0
+    options = []
+    if not keywords:
+        w, h = fit(tot, extra, full_w, full_h)
+        return {"mode": "none", "w": w, "h": h}
+    # keywords below
+    kh = kw_block_h(keywords, full_w)
+    hmax = min(full_h, KW_BOTTOM - GAP_BELOW - kh - Y0)
+    w, h = fit(tot, extra, full_w, hmax)
+    kh = kw_block_h(keywords, full_w)   # keywords sit at the text margin X0
+    if Y0 + h + GAP_BELOW + kh <= KW_BOTTOM + 1e-6:
+        options.append({"mode": "below", "w": w, "h": h, "area": w * h,
+                        "kw_w": full_w, "kw_h": kh})
+    # keywords right
+    w, h = fit(tot, extra, full_w - GAP_RIGHT - MIN_COL, full_h)
+    col = X1 - (X0 + w) - GAP_RIGHT
+    kh = kw_block_h(keywords, col)
+    if kh <= full_h:
+        options.append({"mode": "right", "w": w, "h": h, "area": w * h,
+                        "kw_w": col, "kw_h": kh})
+    if not options:
+        sys.exit(f"no layout fits keywords {keywords!r}")
+    best = max(options, key=lambda o: o["area"])
+    if layout == "figure_keywords":
+        right = [o for o in options if o["mode"] == "right"]
+        if right and right[0]["area"] * 1.15 >= best["area"]:
+            best = right[0]
+    return best
+
+
+def build_content(prs, s: dict, number: int) -> None:
+    slide = prs.slides.add_slide(prs.slide_layouts[6])
+    white_bg(slide)
+    for fld in ("title", "footnote", "section_label"):
+        if s.get(fld):
+            check_text(s[fld], f"slide {number} {fld}")
+    kws = s.get("keywords", [])
+    if len(kws) > 3:
+        sys.exit(f"slide {number}: more than 3 keywords")
+    for k in kws:
+        check_text(k, f"slide {number} keyword")
+    add_title(slide, s["title"], s.get("section_label"))
+
+    paths = [DECK / f for f in s["figures"]]
+    for p in paths:
+        if not p.is_file():
+            sys.exit(f"slide {number}: missing figure {p}")
+    asp = [aspect(p) for p in paths]
+    L = plan(asp, kws, s.get("layout", "full"))
+    w, h = L["w"], L["h"]
+    if L["mode"] == "below":
+        fx = X0 + ((X1 - X0) - w) / 2.0      # centred; keywords at the text margin
+    else:
+        fx = X0
+    fy = Y0
+    x = fx
+    for p, a in zip(paths, asp):
+        pw = h * a
+        slide.shapes.add_picture(str(p), Inches(x), Inches(fy),
+                                 Inches(pw), Inches(h))
+        x += pw + FIG_GAP
+    assert fy + h <= YFIG1 + 1e-6 and fx + w <= X1 + 1e-6, s["title"]
+
+    if L["mode"] == "below":
+        add_text(slide, X0, fy + h + GAP_BELOW, L["kw_w"], L["kw_h"] + 0.05,
+                 kws, KW_PT, space_before_pt=KW_PARA_GAP_PT)
+    elif L["mode"] == "right":
+        kx = fx + w + GAP_RIGHT
+        add_text(slide, kx, fy + 0.15, L["kw_w"], L["kw_h"] + 0.05, kws,
+                 KW_PT, space_before_pt=KW_PARA_GAP_PT)
+    add_footer(slide, s.get("footnote"), number)
+    add_notes(slide, s)
+    print(f"{number:>2}  {L['mode']:<5} fig {w:5.2f}x{h:4.2f} in  {s['title']}")
+
+
+def build_title(prs, s: dict) -> None:
+    slide = prs.slides.add_slide(prs.slide_layouts[6])
+    white_bg(slide)
+    check_text(s["title"] + s.get("subtitle", ""), "title slide")
+    if text_w_in(s["title"], COVER_PT, bold=True) > X1 - X0:
+        sys.exit("cover title too long")
+    add_text(slide, X0, 2.95, X1 - X0, 0.7, [s["title"]], COVER_PT, bold=True,
+             wrap_text=False)
+    if s.get("subtitle"):
+        add_text(slide, X0, 3.8, X1 - X0, 0.4, [s["subtitle"]], COVER_SUB_PT,
+                 color=GREY, wrap_text=False)
+
+
+def build_agenda(prs, s: dict, number: int) -> None:
+    slide = prs.slides.add_slide(prs.slide_layouts[6])
+    white_bg(slide)
+    add_title(slide, s["title"], None)
+    items = s["items"]
+    if len(items) != 10:
+        sys.exit("agenda must list 10 sections")
+    step = 0.52
+    for i, item in enumerate(items):
+        check_text(item, "agenda")
+        y = 1.3 + i * step
+        add_text(slide, X0, y, 0.45, 0.35, [str(i + 1)], AGENDA_PT, color=GREY,
+                 align=PP_ALIGN.RIGHT, wrap_text=False)
+        add_text(slide, X0 + 0.65, y, 10.5, 0.35, [item], AGENDA_PT,
+                 wrap_text=False)
+    add_footer(slide, None, number)
+
+
+def build_divider(prs, s: dict, number: int) -> None:
+    slide = prs.slides.add_slide(prs.slide_layouts[6])
+    white_bg(slide)
+    check_text(s["title"], "divider")
+    add_text(slide, X0, 2.95, X1 - X0, 0.7, [s["title"]], COVER_PT, bold=True,
+             wrap_text=False)
+    add_footer(slide, None, number)
+
+
+def main() -> None:
+    spec = json.loads(SPEC.read_text())
+    out = DECK / spec["deck"]["output_pptx"]
+    prs = Presentation()
+    prs.slide_width = Inches(SLIDE_W)
+    prs.slide_height = Inches(SLIDE_H)
+    for i, s in enumerate(spec["slides"], start=1):
+        kind = s["kind"]
+        if kind == "title":
+            build_title(prs, s)
+            print(f"{i:>2}  title  {s['title']}")
+        elif kind == "agenda":
+            build_agenda(prs, s, i)
+            print(f"{i:>2}  agenda {s['title']}")
+        elif kind == "divider":
+            build_divider(prs, s, i)
+            print(f"{i:>2}  divider {s['title']}")
+        elif kind == "content":
+            build_content(prs, s, i)
+        else:
+            sys.exit(f"unknown slide kind {kind!r}")
+    prs.save(out)
+    print(f"wrote {out} ({len(spec['slides'])} slides)")
+
+
+if __name__ == "__main__":
+    main()

paper-releases/pbisc-diffusion/updates/20260930T065633Z-summary-deck-scsemi-final/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/build_archive_request.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python3
+"""Archive-maintenance request for the paper summary deck (PBISC-Diffusion paper, pbisc-diffusion).
+
+Follows paper-release-20260928/maintenance/POLICY.md. Payloads: the deck (pptx + PDF, final and the frozen
+12:00 draft), its builder, section figure scripts, figures, the number tables every figure and quoted value
+reads, the slide spec and the copied server_2 run-status snapshots used for the loss curves.
+Not uploaded: data/refs (third-party paper text and upstream SDD code kept only for checking the backbone
+table) and render/ (contact-sheet JPGs; the PDF is the rendered record).
+
+Optionally merges another request (for example the paired fine-tuning request) so both go out as one delta.
+usage: build_archive_request.py OUT.json [OTHER_REQUEST.json]
+"""
+from __future__ import annotations
+
+import glob
+import json
+import sys
+from pathlib import Path
+
+D = Path(__file__).resolve().parents[1]
+
+
+def files(patterns):
+    out = set()
+    for p in patterns:
+        for f in glob.glob(str(D / p), recursive=True):
+            q = Path(f)
+            if q.is_file() and not q.is_symlink() and "__pycache__" not in q.parts:
+                out.add(str(q))
+    return sorted(out)
+
+
+def main(out: str, other: str | None = None) -> int:
+    assets = []
+
+    def add(paths, kind):
+        for p in paths:
+            assets.append({"host": "server_1", "source": p, "kind": kind, "state": "completed"})
+
+    add(files(["*.pptx", "*.pdf"]), "report")
+    add(files(["README.md"]), "document")
+    add(files(["generate_deck.py", "tools/*.py"]), "code")
+    add(files(["figures/*.png", "figures/*.pdf", "figures/*.svg"]), "figure")
+    add(files(["data/*.csv"]), "table")
+    add(files(["data/*.json"]), "config")
+    add(files(["data/sec03_server2_snapshots/**/*.json"]), "log")
+    req = {
+        "project_id": "pbisc-diffusion",
+        "summary": (
+            "Paper summary deck 2026-09-30 (presentations/2026-09-30--paper-summary--r00): 29 English slides over the "
+            "ten paper sections (model, backbone, width/context/panel ablation, SLE vs scSemiProfiler, real bulk vs "
+            "pseudobulk, paired fine-tuning, LoRA and K ablations, pairs needed, five-cohort validation with all 25 "
+            "scSemiProfiler draws, planned paired-subset cohorts). Deck, PDF, frozen 12:00 draft, builder, figure "
+            "scripts, figures and every plotted/quoted number table. CPU only; no new checkpoint or inference."),
+        "assets": assets,
+        "inference_locations": [],
+    }
+    if other:
+        o = json.loads(Path(other).read_text())
+        assert o["project_id"] == "pbisc-diffusion"
+        req["summary"] = req["summary"] + " || " + o["summary"]
+        req["assets"] += o["assets"]
+        req["inference_locations"] += o.get("inference_locations", [])
+    Path(out).write_text(json.dumps(req, indent=1))
+    kinds = {}
+    for a in req["assets"]:
+        kinds[a["kind"]] = kinds.get(a["kind"], 0) + 1
+    print(json.dumps({"assets": len(req["assets"]), "by_kind": kinds,
+                      "locations": len(req["inference_locations"])}, indent=1))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(*sys.argv[1:3]))

paper-releases/pbisc-diffusion/updates/20260930T065633Z-summary-deck-scsemi-final/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/sec01_overview.py

@@ -0,0 +1,628 @@
+"""Section 1 (model overview) figures for the 2026-09-30 paper-summary deck.
+
+Outputs (deck folder only):
+  figures/sec01_fig1a_denoiser.{svg,png,pdf}   deck redraw of manuscript Fig. 1a with slide-size labels
+  figures/sec01_fig1b_inference.{svg,png,pdf}  deck redraw of manuscript Fig. 1b with slide-size labels
+  figures/sec01_corpus.{png,pdf}               pretraining corpus: cells per dataset + recipes per K
+  figures/sec01_slide_a.{png,pdf}              slide (a) composite, exactly 12.3 in wide
+  data/sec01_corpus_datasets.csv, data/sec01_recipe_k.csv, data/sec01_model_numbers.csv,
+  data/sec01_fig1_label_pt.csv (on-slide point size of every text line in the two redraws)
+
+The manuscript SVG is only read. The deck copies change label sizes, drop the panel letters and the
+legend row, widen a few boxes so the larger labels fit, and (panel b) say that cells differ by x_T and by
+the Bernoulli support draw (drawn read-out, manuscript Methods). CPU only; every number is read from the
+source files named below.
+"""
+import html
+import json
+import re
+import sys
+from collections import defaultdict
+from pathlib import Path
+
+DECK = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/presentations/2026-09-30--paper-summary--r00")
+sys.path.insert(0, str(DECK / "tools"))
+import style  # noqa: E402
+
+import cairosvg  # 2.9.1, the renderer recorded in fig01_architecture.provenance.json  # noqa: E402
+import fitz  # PyMuPDF, only to check page sizes  # noqa: E402
+import matplotlib.pyplot as plt  # noqa: E402
+import numpy as np  # noqa: E402
+import pandas as pd  # noqa: E402
+from PIL import ImageFont  # noqa: E402
+
+FIG = DECK / "figures"
+DATA = DECK / "data"
+
+MS = Path("/home/sj_server_1/PBISC/paper-release-20260928/manuscript")
+FIG1_SVG = MS / "figures/fig01_architecture.svg"
+METHODS = MS / "sections/methods.tex"
+SRC_MANIFEST = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_7_no_annotation_sh_hwang/data/e2_full_source/dataset_manifest.json")
+IDX_MANIFEST = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_7_no_annotation_sh_hwang/data/e2_full_index/dataset_manifest.json")
+M8 = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion")
+RUN = M8 / "runs/f01_6k_1x_seed20260627"
+CFG = RUN / "effective_config.json"
+STATUS = RUN / "RUN_STATUS.json"
+CONTRACT = RUN / "ALLCELL_DATA_CONTRACT.json"
+PLAN = M8 / "plans/full_recipe_allcells_6k_broad_20260909"
+TOPUP_CSV = PLAN / "topup_v1/topup_recipes.csv"
+SHARD_OFFSETS = PLAN / "topup_v1/shard_offsets.csv"
+COVERAGE = PLAN / "coverage_v1/summary.json"
+MODEL_PY = M8 / "src/pbisc_sdd/model.py"
+
+# Short readable labels for the 22 corpus datasets (text only; counts come from the manifest).
+LABELS = {
+    "001": "Perez SLE", "005": "OneK1K", "006": "AIDA", "007": "Miao RA", "009": "AIFI Health Atlas",
+    "010": "ScaleBio PBMC", "053": "Hao CITE-seq", "058": "COVID immunodeficiency",
+    "061": "RA at-risk (Savage)", "065": "Sound Life", "071": "JDM CITE-seq", "074": "COMBAT",
+    "081": "COVID atlas (Seq-Well)", "093": "SARS-CoV-2 local/systemic", "200": "Immunobiology of Aging",
+    "202": "Fatal COVID time course", "203": "Indonesia diversity", "204": "cHSPC aging / MDS",
+    "300b": "DRESS / DiHS", "301": "SLE B-cell study", "302": "SLE IL-36 stim", "304": "Parse 10M cytokine",
+}
+
+# On-slide sizes (inches). Slide (b): one keyword line under the diagram leaves about 5.25 in.
+A_HEIGHT_IN = 5.25
+SLIDE_A_H = 5.30          # composite height: leaves room for one keyword line in the 5.7-in content area
+W_FULL = style.FULL[0]    # 12.3 in
+
+# ============================================================== SVG copy with slide-size labels
+FONT_R = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", 100)
+FONT_B = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", 100)
+LS = 0.5  # letter-spacing set on the outer <g> of the figure
+SKEW = 0.2126
+
+
+def text_w(s, fs, bold=False):
+    s = html.unescape(s)
+    return (FONT_B if bold else FONT_R).getlength(s) * fs / 100.0 + LS * len(s)
+
+
+def attr(a, name):
+    m = re.search(rf'(?<![\w-]){name}="([^"]*)"', a)
+    return m.group(1) if m else None
+
+
+def set_attr(a, name, val):
+    new, n = re.subn(rf'(?<![\w-]){name}="[^"]*"', f'{name}="{val}"', a, count=1)
+    assert n == 1, (name, a)
+    return new
+
+
+def fmt(v):
+    return f"{v:.2f}".rstrip("0").rstrip(".")
+
+
+def map_d(d, fx, fy):
+    """Map absolute M/L/H/V/Z path data (one coordinate group per command, as in the manuscript SVG)."""
+    segs = []
+    for cmd, args in re.findall(r"([MLHVZ])([^MLHVZ]*)", d):
+        nums = [float(v) for v in re.findall(r"-?\d+(?:\.\d+)?", args)]
+        if cmd in "ML":
+            assert len(nums) == 2, d
+            segs.append(f"{cmd}{fmt(fx(nums[0]))},{fmt(fy(nums[1]))}")
+        elif cmd == "H":
+            assert len(nums) == 1, d
+            segs.append(f"H{fmt(fx(nums[0]))}")
+        elif cmd == "V":
+            assert len(nums) == 1, d
+            segs.append(f"V{fmt(fy(nums[0]))}")
+        else:
+            segs.append("Z")
+    return " ".join(segs)
+
+
+def d_xs(d):
+    toks = re.findall(r"[MLHVZ]|-?\d+(?:\.\d+)?", d)
+    xs, cmd, i = [], None, 0
+    while i < len(toks):
+        t = toks[i]
+        if t in "MLHVZ":
+            cmd = t
+            i += 1
+        elif cmd in "ML":
+            xs.append(float(t))
+            i += 2
+        elif cmd == "H":
+            xs.append(float(t))
+            i += 1
+        else:
+            i += 1
+    return xs
+
+
+def piecewise(knots):
+    xs = np.array([k[0] for k in knots], float)
+    ys = np.array([k[1] for k in knots], float)
+
+    def X(x):
+        if x <= xs[0]:
+            return x + (ys[0] - xs[0])
+        if x >= xs[-1]:
+            return x + (ys[-1] - xs[-1])
+        return float(np.interp(x, xs, ys))
+    return X
+
+
+# Panel a: widen the Expression column (+36) and the Conditioning column (+20); the main column only shifts.
+X_A = piecewise([(24, 24), (232, 268), (1184, 1220), (1416, 1472)])
+X_ID = piecewise([(0, 0), (1, 1)])
+
+TOKEN = re.compile(
+    r'<g transform="matrix\(1,0,-0\.2126,1,(?P<gtx>[-\d.]+),0\)">(?P<ginner>.*?)</g>'
+    r'|<text (?P<tattrs>[^>]*)>(?P<tbody>.*?)</text>'
+    r'|<path (?P<pattrs>[^>]*)/>')
+INNER_TEXT = re.compile(r'<text (?P<attrs>[^>]*)>(?P<body>.*?)</text>')
+INNER_PATH = re.compile(r'<path (?P<attrs>[^>]*)/>')
+
+
+def process_text_line(line, X, target=None, mode="c", dy=0.0, ax_fixed=None):
+    """Rescale one visual text line (several runs, skew groups, hat paths) about its anchor.
+    target: new main font size (None keeps it); mode 'c' centres on the old centre, 'l' keeps the left edge;
+    ax_fixed: old-coordinate centre to use instead of the measured one (re-centres a line in its box)."""
+    runs = []
+    for m in TOKEN.finditer(line):
+        if m.group("gtx") is not None:
+            t = INNER_TEXT.search(m.group("ginner"))
+            runs.append(dict(attrs=t.group("attrs"), body=t.group("body")))
+        elif m.group("tattrs") is not None:
+            runs.append(dict(attrs=m.group("tattrs"), body=m.group("tbody")))
+    for r in runs:
+        a = r["attrs"]
+        r.update(x=float(attr(a, "x")), y=float(attr(a, "y")), fs=float(attr(a, "font-size")),
+                 bold=attr(a, "font-weight") == "700", anchor=attr(a, "text-anchor") or "start")
+        r["w"] = text_w(r["body"], r["fs"], r["bold"])
+    fs0 = max(r["fs"] for r in runs)
+    yb = next(r["y"] for r in runs if r["fs"] == fs0)
+    if any(r["anchor"] in ("middle", "end") for r in runs):
+        assert len(runs) == 1, line
+        ax_old = runs[0]["x"]
+        extent = (runs[0]["x"] - runs[0]["w"] / 2, runs[0]["x"] + runs[0]["w"] / 2) if runs[0]["anchor"] == "middle" \
+            else (runs[0]["x"] - runs[0]["w"], runs[0]["x"])
+    else:
+        x0 = min(r["x"] for r in runs)
+        x1 = max(r["x"] + r["w"] for r in runs)
+        extent = (x0, x1)
+        ax_old = x0 if mode == "l" else (x0 + x1) / 2
+    f = (target / fs0) if target else 1.0
+    # the measured centre goes to the mapped box centre when one is given
+    ax_new = X(ax_fixed) if ax_fixed is not None else X(ax_old)
+    yb_new = yb + dy
+    fx = lambda x: ax_new + (x - ax_old) * f  # noqa: E731
+    fy = lambda y: yb_new + (y - yb) * f  # noqa: E731
+
+    def fix_text(a):
+        x, y, fs = float(attr(a, "x")), float(attr(a, "y")), float(attr(a, "font-size"))
+        a = set_attr(a, "x", fmt(fx(x)))
+        a = set_attr(a, "y", fmt(fy(y)))
+        return set_attr(a, "font-size", fmt(fs * f)), fy(y)
+
+    def fix_path(a):
+        return set_attr(a, "d", map_d(attr(a, "d"), fx, fy))
+
+    def repl(m):
+        if m.group("gtx") is not None:
+            inner = m.group("ginner")
+            t = INNER_TEXT.search(inner)
+            ta, ynew = fix_text(t.group("attrs"))
+            inner = inner.replace(t.group(0), f'<text {ta}>{t.group("body")}</text>')
+            inner = INNER_PATH.sub(lambda p: f'<path {fix_path(p.group("attrs"))}/>', inner)
+            return f'<g transform="matrix(1,0,-0.2126,1,{fmt(SKEW * ynew)},0)">{inner}</g>'
+        if m.group("tattrs") is not None:
+            ta, _ = fix_text(m.group("tattrs"))
+            return f'<text {ta}>{m.group("tbody")}</text>'
+        return f'<path {fix_path(m.group("pattrs"))}/>'
+
+    new = TOKEN.sub(repl, line)
+    w_new = (extent[1] - extent[0]) * f
+    info = dict(fs_old=fs0, fs_new=fs0 * f, width_new=w_new, center_new=fx((extent[0] + extent[1]) / 2),
+                text=" ".join(html.unescape(r["body"]) for r in runs))
+    return new, info
+
+
+def process_geometry_line(line, X):
+    def rect(m):
+        a = m.group(1)
+        x, w = float(attr(a, "x")), float(attr(a, "width"))
+        a = set_attr(a, "x", fmt(X(x)))
+        a = set_attr(a, "width", fmt(X(x + w) - X(x)))
+        return f"<rect {a}/>"
+
+    def circ(m):
+        a = m.group(1)
+        return f'<circle {set_attr(a, "cx", fmt(X(float(attr(a, "cx")))))}/>'
+
+    def path(m):
+        a = m.group(1)
+        d = attr(a, "d")
+        rigid = attr(a, "stroke") == "#FFFFFF" or d.count("M") > 1   # bar rulings and plus signs keep their size
+        if rigid:
+            xs = d_xs(d)
+            c = (min(xs) + max(xs)) / 2
+            dx = X(c) - c
+            return f'<path {set_attr(a, "d", map_d(d, lambda x: x + dx, lambda y: y))}/>'
+        return f'<path {set_attr(a, "d", map_d(d, X, lambda y: y))}/>'
+
+    line = re.sub(r"<rect ([^>]*)/>", rect, line)
+    line = re.sub(r"<circle ([^>]*)/>", circ, line)
+    line = re.sub(r"<path ([^>]*)/>", path, line)
+    return line
+
+
+def run_line(y, parts, fill, cx, fs=19.0):
+    """Build a centred text line from (text, style, space_before) parts at font fs.
+    style: 'n' upright, 'i' italic (skew group, as in the manuscript), 'sub' upright subscript at 0.7 fs."""
+    fsub = round(fs * 0.7, 2)
+    sp = text_w(" ", fs)
+    widths = [text_w(t, fsub if s == "sub" else fs) for t, s, _ in parts]
+    total = sum(widths) + sp * sum(1 for *_, g in parts if g)
+    x = cx - total / 2
+    out = []
+    for (t, s, gap), w in zip(parts, widths):
+        x += sp if gap else 0.0
+        size, yy = (fsub, y + round(fs * 0.17, 1)) if s == "sub" else (fs, y)
+        el = (f'<text x="{fmt(x)}" y="{fmt(yy)}" font-size="{fmt(size)}" font-weight="400" fill="{fill}" '
+              f'letter-spacing="0.5" text-anchor="start">{t}</text>')
+        if s == "i":
+            el = f'<g transform="matrix(1,0,-0.2126,1,{fmt(SKEW * yy)},0)">{el}</g>'
+        out.append(el)
+        x += w
+    return "".join(out), total
+
+
+# Line-specific geometry edits (1-based line numbers of the manuscript SVG); each old string must occur once.
+EDITS = {
+    126: [("M677.5,548 H657", "M677.5,548 H663")],
+    132: [('<rect x="577" y="511" width="80" height="73"', '<rect x="571" y="511" width="92" height="73"')],
+    135: [('<rect x="404" y="480" width="130" height="48"', '<rect x="398" y="480" width="142" height="48"')],
+    137: [('<rect x="404" y="551" width="130" height="48"', '<rect x="398" y="548" width="142" height="60"')],
+    140: [("M577,548 H560 V504 H542", "M571,548 H560 V504 H549")],
+    141: [("M560,548 V575 H542", "M560,548 V578 H549")],
+    142: [("M404,504 H366", "M398,504 H366")],
+    143: [("M404,575 H366 V539", "M398,578 H366 V539")],
+    190: [('<rect x="658" y="694" width="266" height="58"', '<rect x="658" y="694" width="266" height="64"')],
+    # panel b: wider reverse-sampling box for the longer last line
+    262: [("H782", "H772")], 264: [("H782", "H772")], 266: [("H782", "H772")],
+    270: [('<rect x="790" y="1000" width="276" height="164"', '<rect x="780" y="1000" width="296" height="164"')],
+    275: [("M1066,1082 H1098", "M1076,1082 H1098")],
+}
+# Text lines: (new main font size, anchor mode, baseline shift in SVG units)
+TEXT_A = {
+    31: (21, "c", 0), 32: (21, "c", 0), 33: (21, "c", 0), 37: (21, "c", 0), 38: (21, "c", 1),
+    42: (21, "c", -3), 44: (21, "c", -2),
+    43: (21, "c", -5, 128.0),   # manuscript line sits ~5 units right of its box centre (128); re-centred
+    59: (20, "c", 0), 60: (20, "c", 0),
+    61: (21, "l", 0), 75: (21, "c", 0), 76: (21, "c", 0), 77: (21, "l", 0), 83: (21, "c", 0),
+    89: (21, "c", 0), 130: (21, "c", 3), 133: (21, "c", -1), 134: (21, "c", 1), 138: (21, "c", -2),
+    139: (21, "c", 4), 158: (21, "c", 0), 159: (21, "c", 0), 160: (21, "l", 0), 162: (21, "l", 0),
+    176: (21, "c", 0), 177: (21, "c", 0), 178: (21, "l", 0), 182: (21, "l", 0), 191: (21, "c", -1),
+    192: (21, "c", 4), 195: (21, "c", -3), 198: (21, "c", 0), 199: (21, "c", 0), 208: (21, "c", 0),
+    214: (21, "c", 0), 217: (21, "c", 0), 221: (21, "c", 0), 222: (21, "c", 0),
+}
+TEXT_B = {
+    234: (19, "c", 0), 251: (19, "c", 0), 256: (19, "c", 0), 257: (19, "c", 0), 259: (19, "c", -2),
+    260: (19, "c", 2), 278: (19, "c", 0), 287: (19, "c", 0), 295: (19, "c", 0), 303: (19, "c", 0),
+    311: (19, "c", 0), 312: (19, "c", 0), 314: (19, "c", 0),
+}
+# panel a: lines 17-223 (drop the letter "a" 14-16 and the legend 224-229); panel b: 232-315 (drop letter "b")
+A_LINES = list(range(17, 224))
+B_LINES = [230] + list(range(232, 316))   # 230 opens the panel-b group, 315 closes it
+CROP_A = (18, 110, 1478, 777)     # after widening; boxes span y 116-771
+CROP_B = (18, 918, 1422, 1216)    # connector lines at y 926 and 1208
+
+
+def build_svg(lines, rng, X, text_cfg, crop, width_in, drop_bg=True):
+    head = lines[:12]  # xml decl .. defs .. outer <g>
+    x0, y0, x1, y1 = crop
+    vw, vh = x1 - x0, y1 - y0
+    h_in = width_in * vh / vw
+    head[1] = re.sub(r'width="[^"]*" height="[^"]*" viewBox="[^"]*"',
+                     f'width="{width_in:.4f}in" height="{h_in:.4f}in" viewBox="{x0} {y0} {vw} {vh}"', head[1])
+    body = [f'<rect x="{x0}" y="{y0}" width="{vw}" height="{vh}" fill="#FFFFFF" stroke="none"/>']
+    infos = []
+    for ln in rng:
+        s = lines[ln - 1]
+        for old, new in EDITS.get(ln, []):
+            assert s.count(old) == 1, (ln, old)
+            s = s.replace(old, new)
+        if ln == 274:   # panel b: cells differ by x_T and by the Bernoulli support draw (drawn read-out)
+            assert "the draw of" in s and 'font-size="18"' in s
+            s, w = run_line(1138.0, [("x", "i", False), ("T", "sub", False), ("and support draw differ", "n", True)],
+                            "#5C6C74", 928.0)
+            infos.append(dict(line=ln, fs_old=18.0, fs_new=19.0, width_new=w, center_new=928.0,
+                              text="x T and support draw differ (deck wording; manuscript: the draw of x T differs)"))
+        elif "<text" in s:
+            tgt, mode, dy, *fixed = text_cfg.get(ln, (None, "c", 0))
+            s, info = process_text_line(s, X, tgt, mode, dy, fixed[0] if fixed else None)
+            info["line"] = ln
+            infos.append(info)
+        elif X is not X_ID:
+            s = process_geometry_line(s, X)
+        body.append(s)
+    svg = "\n".join(head + body + ["</g></svg>"])
+    return svg, infos, h_in
+
+
+def render(svg, stem, width_in):
+    p_svg = FIG / f"{stem}.svg"
+    p_svg.write_text(svg)
+    cairosvg.svg2png(bytestring=svg.encode(), write_to=str(FIG / f"{stem}.png"), dpi=300)
+    cairosvg.svg2pdf(bytestring=svg.encode(), write_to=str(FIG / f"{stem}.pdf"), dpi=72)
+    doc = fitz.open(FIG / f"{stem}.pdf")
+    wpt = doc[0].rect.width
+    doc.close()
+    assert abs(wpt - width_in * 72) < 1.0, (stem, wpt, width_in * 72)
+    return FIG / f"{stem}.png"
+
+
+# ============================================================== corpus tables
+def fmt_cells(v):
+    if v >= 1e7:
+        return f"{v / 1e6:.1f}M"
+    if v >= 1e6:
+        return f"{v / 1e6:.2f}M"
+    return f"{v / 1e3:.0f}K"
+
+
+def corpus_tables():
+    src = json.loads(SRC_MANIFEST.read_text())
+    idx = json.loads(IDX_MANIFEST.read_text())
+    cov = json.loads(COVERAGE.read_text())
+    con = json.loads(CONTRACT.read_text())
+    base, over, raw, nsrc = (defaultdict(int) for _ in range(4))
+    for s in src["source_audit"]:
+        d = s["dataset_id"]
+        base[d] += int(s["base_rows"])
+        over[d] += int(s["overlay_rows"])
+        raw[d] += int(s["raw_rows"])
+        nsrc[d] += 1
+    ds = pd.DataFrame({"dataset_id": list(base)})
+    ds["base_rows"] = ds["dataset_id"].map(base)
+    ds["overlay_rows"] = ds["dataset_id"].map(over)
+    ds["cells"] = ds["base_rows"] + ds["overlay_rows"]
+    assert (ds["cells"] == ds["dataset_id"].map(raw)).all()
+    # cross-check against the index shards used by the run (base + overlay shards)
+    sh = pd.read_csv(SHARD_OFFSETS).groupby("dataset_id")["n_cells"].sum()
+    assert (ds.set_index("dataset_id")["cells"] == sh.reindex(ds["dataset_id"]).values).all()
+    ds["n_source_files"] = ds["dataset_id"].map(nsrc)
+    ds["label"] = ds["dataset_id"].str.split("_").str[0].map(LABELS)
+    assert ds["label"].notna().all()
+    ds = ds.sort_values("cells", ascending=False).reset_index(drop=True)
+    ds["rank"] = np.arange(1, len(ds) + 1)
+    ds["source"] = (f"{SRC_MANIFEST} :: source_audit[].base_rows + overlay_rows (= raw_rows) summed by dataset_id; "
+                    f"equals {SHARD_OFFSETS} n_cells by dataset_id")
+    total = int(ds["cells"].sum())
+    assert len(ds) == src["n_datasets"] == idx["n_datasets"] == 22
+    assert total == src["logical_cells"] == idx["n_cells"] == cov["source_cells_all_splits"]
+    assert int(ds["base_rows"].sum()) == src["base_cells"] and int(ds["overlay_rows"].sum()) == src["overlay_cells"]
+    ds[["rank", "label", "cells", "base_rows", "overlay_rows", "n_source_files", "dataset_id", "source"]].to_csv(
+        DATA / "sec01_corpus_datasets.csv", index=False)
+
+    kq = idx["k_quotas_per_epoch"]
+    kk = pd.DataFrame({"K": [f"{k:,}" for k in idx["k_values"]], "k_weight": idx["k_weights"],
+                       "recipes_per_epoch": [float(kq[str(k)]) for k in idx["k_values"]],
+                       "recipes_per_epoch_min": [int(kq[str(k)]) for k in idx["k_values"]],
+                       "recipes_per_epoch_max": [int(kq[str(k)]) for k in idx["k_values"]],
+                       "kind": "registered K grid"})
+    kk["source"] = f"{IDX_MANIFEST} :: k_values, k_weights, k_quotas_per_epoch"
+    assert int(kk["recipes_per_epoch"].sum()) == idx["train_recipes_per_epoch"]
+
+    pairing = con["pairing"]
+    cat = con["coverage_after_topup"]
+    reg = pairing["registered_recipes_per_epoch"]
+    per_ep = np.array(pairing["total_recipe_counts_by_epoch"]) - reg
+    slot = pd.DataFrame(cat["slot_coverage"])
+    assert (np.sort(per_ep) == np.sort(slot["topup_recipes"].values)).all()
+    assert int(per_ep.sum()) == cat["topup_recipes"]
+    tu = pd.read_csv(TOPUP_CSV)
+    assert len(tu) == cat["topup_recipes"] and tu["is_topup"].all() and (tu["split"] == "train").all()
+    topup = dict(n=int(len(tu)), k_min=int(tu["k"].min()), k_max=int(tu["k"].max()),
+                 k_median=float(tu["k"].median()), n_k_below_250=int((tu["k"] < 250).sum()),
+                 per_epoch_mean=float(per_ep.mean()), per_epoch_min=int(per_ep.min()), per_epoch_max=int(per_ep.max()),
+                 target_cells=int(cat["topup_target_cells"]), train_cells=int(cat["train_universe_cells"]),
+                 coverage=float(cat["train_cell_coverage_after_topup"]),
+                 recipes_by_epoch_min=int(min(pairing["total_recipe_counts_by_epoch"])),
+                 recipes_by_epoch_max=int(max(pairing["total_recipe_counts_by_epoch"])))
+    kk = pd.concat([kk, pd.DataFrame([{
+        "K": "top-up", "k_weight": np.nan, "recipes_per_epoch": topup["per_epoch_mean"],
+        "recipes_per_epoch_min": topup["per_epoch_min"], "recipes_per_epoch_max": topup["per_epoch_max"],
+        "kind": f"top-up, K {topup['k_min']}-{topup['k_max']:,} (mean over 16 epochs)",
+        "source": f"{CONTRACT} :: pairing.total_recipe_counts_by_epoch - registered_recipes_per_epoch; {TOPUP_CSV} :: k"}])],
+        ignore_index=True)
+    kk.to_csv(DATA / "sec01_recipe_k.csv", index=False)
+    meta = {"n_datasets": src["n_datasets"], "cells": total, "base_cells": src["base_cells"],
+            "overlay_cells": src["overlay_cells"], "train_recipes_per_epoch": idx["train_recipes_per_epoch"],
+            "train_recipe_pool_size": idx["train_recipe_pool_size"], "max_disjoint_epochs": idx["max_disjoint_epochs"],
+            "split_unit": idx["split_unit"], "split_fractions": idx["split_fractions"],
+            "corpus_fingerprint": idx["corpus_fingerprint"], "topup": topup,
+            "all_members_targets": cov["all_k_member_occurrences_become_targets"],
+            "original_target_exposures": con["coverage_after_topup"]["original_target_exposures"],
+            "observed_target_cells_by_epoch": con["observed_target_cells_by_epoch"]}
+    return ds, kk, meta
+
+
+def overlaps(fig, texts):
+    fig.canvas.draw()
+    r = fig.canvas.get_renderer()
+    bbs = [(t.get_text(), t.get_window_extent(r)) for t in texts if t.get_text()]
+    bad = []
+    for i in range(len(bbs)):
+        for j in range(i + 1, len(bbs)):
+            if bbs[i][1].overlaps(bbs[j][1]):
+                bad.append((bbs[i][0], bbs[j][0]))
+    return bad
+
+
+def draw_corpus(fig, W, H, y0, h, ds, kk, meta, fs=12):
+    """Corpus panels placed in inches: two sorted dataset columns on one shared log scale (values printed,
+    no axis), then recipes per epoch by K. y0 = bottom of the bar area, h = its height (inches)."""
+    half = int(np.ceil(len(ds) / 2))
+    parts = [ds.iloc[:half], ds.iloc[half:]]
+    lo, hi = 1e4, 3e7
+    cols = [(2.2, 2.35), (7.2, 2.35)]           # (left, width) in inches
+    texts = []
+    for (left, width), part in zip(cols, parts):
+        ax = fig.add_axes([left / W, y0 / H, width / W, h / H])
+        y = np.arange(len(part))
+        ax.barh(y, part["cells"], color=style.GREY, height=0.66)
+        for yi, v in zip(y, part["cells"]):
+            texts.append(ax.text(v * 1.2, yi, fmt_cells(v), va="center", ha="left", fontsize=fs, color=style.INK))
+        ax.set_xscale("log")
+        ax.set_xlim(lo, hi)
+        ax.set_ylim(half - 0.5, -0.5)
+        ax.set_yticks(y)
+        ax.set_yticklabels(part["label"], fontsize=fs)
+        texts += ax.get_yticklabels()
+        ax.tick_params(axis="y", length=0, pad=4)
+        ax.set_xticks([])
+        ax.minorticks_off()
+        for sp in ("left", "bottom"):
+            ax.spines[sp].set_visible(False)
+    t = meta["topup"]
+    texts.append(fig.text((cols[0][0] + cols[1][0] + cols[1][1]) / 2 / W, (y0 - 0.1) / H,
+                          f"cells per dataset (log scale) · {meta['n_datasets']} datasets · "
+                          f"{fmt_cells(meta['cells'])} cells · {fmt_cells(t['train_cells'])} in train split",
+                          ha="center", va="top", fontsize=fs + 1))
+
+    ax = fig.add_axes([10.75 / W, y0 / H, 0.95 / W, h / H])
+    y = np.arange(len(kk))
+    is_top = (kk["K"] == "top-up").values
+    ax.barh(y[~is_top], kk.loc[~is_top, "recipes_per_epoch"], color=style.INK, height=0.62)
+    ax.barh(y[is_top], kk.loc[is_top, "recipes_per_epoch"], color=style.GREY, height=0.62)
+    vmax = kk["recipes_per_epoch"].max()
+    for yi, v, top in zip(y, kk["recipes_per_epoch"], is_top):
+        lab = f"~{v:.0f}" if top else f"{v:,.0f}"
+        texts.append(ax.text(v + vmax * 0.05, yi, lab, va="center", ha="left", fontsize=fs))
+    ax.set_ylim(len(kk) - 0.5, -0.5)
+    ax.set_yticks(y)
+    ax.set_yticklabels(kk["K"], fontsize=fs)
+    texts += ax.get_yticklabels()
+    ax.tick_params(axis="y", length=0, pad=4)
+    ax.set_xlim(0, vmax * 1.02)
+    ax.set_xticks([])
+    for sp in ("left", "bottom"):
+        ax.spines[sp].set_visible(False)
+    ax.set_ylabel("K cells / recipe", fontsize=fs + 1, labelpad=6)
+    texts.append(ax.yaxis.label)
+    texts.append(fig.text((10.75 + 0.5) / W, (y0 - 0.1) / H, "recipes / epoch", ha="center", va="top", fontsize=fs + 1))
+    return texts
+
+
+def main():
+    FIG.mkdir(exist_ok=True)
+    DATA.mkdir(exist_ok=True)
+    lines = FIG1_SVG.read_text().split("\n")
+    assert len(lines) >= 316 and lines[230].startswith('<text x="24" y="914"') and 'y="813"' in lines[225]
+
+    # ---------- panel a (slide b) and panel b (slide a) deck copies
+    a_w = A_HEIGHT_IN * (CROP_A[2] - CROP_A[0]) / (CROP_A[3] - CROP_A[1])
+    svg_a, info_a, _ = build_svg(lines, A_LINES, X_A, TEXT_A, CROP_A, a_w)
+    render(svg_a, "sec01_fig1a_denoiser", a_w)
+    svg_b, info_b, b_h = build_svg(lines, B_LINES, X_ID, TEXT_B, CROP_B, W_FULL)
+    b_png = render(svg_b, "sec01_fig1b_inference", W_FULL)
+
+    # on-slide point size of every text line
+    pt_a = A_HEIGHT_IN * 72 / (CROP_A[3] - CROP_A[1])
+    pt_b = W_FULL * 72 / (CROP_B[2] - CROP_B[0])
+    rows = [dict(panel="a (slide b)", placed_in=f"{a_w:.2f} x {A_HEIGHT_IN:.2f}", pt_per_unit=pt_a, **i) for i in info_a]
+    rows += [dict(panel="b (slide a)", placed_in=f"{W_FULL:.2f} x {b_h:.3f}", pt_per_unit=pt_b, **i) for i in info_b]
+    lab = pd.DataFrame(rows)
+    lab["pt_on_slide"] = lab["fs_new"] * lab["pt_per_unit"]
+    lab = lab[["panel", "line", "text", "fs_old", "fs_new", "pt_on_slide", "width_new", "center_new", "placed_in", "pt_per_unit"]]
+    lab.to_csv(DATA / "sec01_fig1_label_pt.csv", index=False)
+
+    # ---------- corpus
+    ds, kk, meta = corpus_tables()
+    W = W_FULL
+    fig = plt.figure(figsize=(W, 2.75))
+    texts = draw_corpus(fig, W, 2.75, 0.45, 2.2, ds, kk, meta)
+    bad = overlaps(fig, texts)
+    assert not bad, bad
+    style.save(fig, "sec01_corpus", FIG)
+
+    # ---------- slide (a) composite: exactly 12.3 x 5.3 in, panel b redraw on top
+    H = SLIDE_A_H
+    img = plt.imread(b_png)
+    fig = plt.figure(figsize=(W, H))
+    ax_img = fig.add_axes([0, 1 - b_h / H, 1, b_h / H])
+    ax_img.imshow(img, interpolation="lanczos")
+    ax_img.set_axis_off()
+    y0 = 0.45
+    texts = draw_corpus(fig, W, H, y0, H - b_h - 0.16 - y0, ds, kk, meta)
+    bad = overlaps(fig, texts)
+    assert not bad, bad
+    r = fig.canvas.get_renderer()
+    for t in texts:   # every corpus label stays on the canvas
+        bb = t.get_window_extent(r)
+        assert bb.x0 >= 0 and bb.x1 <= W * fig.dpi and bb.y0 >= 0, t.get_text()
+    with plt.rc_context({"savefig.bbox": "standard"}):   # keep the canvas at exactly 12.3 x 5.3 in
+        for ext in ("png", "pdf"):
+            fig.savefig(FIG / f"sec01_slide_a.{ext}", dpi=300)
+    plt.close(fig)
+
+    # ---------- numbers used on the slides, with sources
+    cfg = json.loads(CFG.read_text())
+    st = json.loads(STATUS.read_text())
+    idx = json.loads(IDX_MANIFEST.read_text())
+    con = json.loads(CONTRACT.read_text())
+    hd = cfg["model"]["hidden_dims"]
+    blocks = hd + hd[-2::-1]
+    assert "descending half of the symmetric MLP" in MODEL_PY.read_text()
+    meth = METHODS.read_text().split("\n")
+    assert "Generation used EMA weights and 50 deterministic DDIM steps ($\\eta=0$)" in meth[57]
+    assert "The drawn read-out is implemented in the standalone sampler that generated every set scored in this paper" in meth[98]
+    t = meta["topup"]
+    nums = [
+        ("n_datasets", meta["n_datasets"], f"{SRC_MANIFEST} :: n_datasets (= {IDX_MANIFEST} :: n_datasets)"),
+        ("corpus_cells", meta["cells"], f"{SRC_MANIFEST} :: logical_cells = base_cells + overlay_cells (= {IDX_MANIFEST} :: n_cells; = {COVERAGE} :: source_cells_all_splits)"),
+        ("corpus_base_cells", meta["base_cells"], f"{SRC_MANIFEST} :: base_cells"),
+        ("corpus_overlay_cells", meta["overlay_cells"], f"{SRC_MANIFEST} :: overlay_cells"),
+        ("train_split_cells", t["train_cells"], f"{CONTRACT} :: coverage_after_topup.train_universe_cells"),
+        ("split", f"{idx['split_unit']} {idx['split_fractions']}", f"{IDX_MANIFEST} :: split_unit, split_fractions"),
+        ("k_values", " ".join(str(k) for k in idx["k_values"]), f"{IDX_MANIFEST} :: k_values"),
+        ("registered_recipes_per_epoch", idx["train_recipes_per_epoch"], f"{IDX_MANIFEST} :: train_recipes_per_epoch"),
+        ("train_recipe_pool_size", idx["train_recipe_pool_size"], f"{IDX_MANIFEST} :: train_recipe_pool_size"),
+        ("max_disjoint_epochs", idx["max_disjoint_epochs"], f"{IDX_MANIFEST} :: max_disjoint_epochs (schedule_slots)"),
+        ("topup_recipes_total", t["n"], f"{CONTRACT} :: coverage_after_topup.topup_recipes (= rows of {TOPUP_CSV})"),
+        ("topup_recipes_per_epoch_mean_min_max", f"{t['per_epoch_mean']:.1f} {t['per_epoch_min']} {t['per_epoch_max']}", f"{CONTRACT} :: pairing.total_recipe_counts_by_epoch - pairing.registered_recipes_per_epoch"),
+        ("recipes_per_epoch_actual_min_max", f"{t['recipes_by_epoch_min']} {t['recipes_by_epoch_max']}", f"{CONTRACT} :: pairing.total_recipe_counts_by_epoch"),
+        ("topup_k_min_median_max", f"{t['k_min']} {t['k_median']:.0f} {t['k_max']}", f"{TOPUP_CSV} :: k"),
+        ("topup_recipes_k_below_250", t["n_k_below_250"], f"{TOPUP_CSV} :: k < 250"),
+        ("train_cell_coverage_after_topup", t["coverage"], f"{CONTRACT} :: coverage_after_topup.train_cell_coverage_after_topup"),
+        ("all_member_cells_are_targets", meta["all_members_targets"], f"{COVERAGE} :: all_k_member_occurrences_become_targets"),
+        ("target_cells_per_epoch_min_max", f"{min(meta['observed_target_cells_by_epoch'])} {max(meta['observed_target_cells_by_epoch'])}", f"{CONTRACT} :: observed_target_cells_by_epoch"),
+        ("corpus_fingerprint_matches_run", idx["corpus_fingerprint"] == st["corpus_fingerprint"] == con["pairing"]["source_corpus_fingerprint"],
+         f"{IDX_MANIFEST} :: corpus_fingerprint vs {STATUS} :: corpus_fingerprint and {CONTRACT} :: pairing.source_corpus_fingerprint"),
+        ("n_genes", cfg["data"]["n_genes"], f"{CFG} :: data.n_genes (= {STATUS} :: n_genes)"),
+        ("condition_dim", st["condition_dim"], f"{STATUS} :: condition_dim (= 3G+6)"),
+        ("parameters", st["parameters"], f"{STATUS} :: parameters"),
+        ("hidden_dims_descending_half", "-".join(map(str, hd)), f"{CFG} :: model.hidden_dims ({MODEL_PY} SparseDenoiserConfig: descending half of a symmetric skip MLP)"),
+        ("denoiser_blocks", f"{len(blocks)} blocks: {'-'.join(map(str, blocks))}", f"derived: hidden_dims + reversed(hidden_dims[:-1]); matches Fig. 1a '7 blocks + skip sums'"),
+        ("context_dim", cfg["model"]["context_dim"], f"{CFG} :: model.context_dim"),
+        ("time_embedding_dim", cfg["model"]["time_embedding_dim"], f"{CFG} :: model.time_embedding_dim"),
+        ("sampler", "EMA weights, 50 DDIM steps, eta 0", f"{METHODS} l.58"),
+        ("support_readout", "drawn (Bernoulli): keep gene g if u < sigmoid(logit); used for every scored set", f"{METHODS} l.99 (Support read-out)"),
+        ("ema_decay", cfg["training"]["ema_decay"], f"{CFG} :: training.ema_decay"),
+        ("epochs_completed", st["epochs_completed"], f"{STATUS} :: epochs_completed (= 16 disjoint schedule slots; {IDX_MANIFEST} :: schedule_slots)"),
+        ("status", st["status"], f"{STATUS} :: status"),
+    ]
+    assert cfg["data"]["n_genes"] == st["n_genes"]
+    assert st["condition_dim"] == 3 * st["n_genes"] + 6
+    assert st["epochs_completed"] == idx["schedule_slots"] == idx["max_disjoint_epochs"] == 16
+    assert idx["train_recipes_per_epoch"] * idx["schedule_slots"] == idx["train_recipe_pool_size"]
+    assert meta["original_target_exposures"] == sum(int(k) * int(v) for k, v in zip(
+        idx["k_values"], [idx["k_quotas_per_epoch"][str(k)] for k in idx["k_values"]])) * idx["schedule_slots"]
+    pd.DataFrame(nums, columns=["key", "value", "source"]).to_csv(DATA / "sec01_model_numbers.csv", index=False)
+
+    print(f"panel a placed {a_w:.2f} x {A_HEIGHT_IN} in, {pt_a:.4f} pt/unit; panel b {W_FULL} x {b_h:.3f} in, {pt_b:.4f} pt/unit")
+    for p, g in lab.groupby("panel"):
+        g = g.sort_values("pt_on_slide")
+        print(p, "min label pt", round(g["pt_on_slide"].min(), 2), "|", g.iloc[0]["text"][:40])
+    print("datasets", meta["n_datasets"], "cells", meta["cells"], fmt_cells(meta["cells"]))
+    print(ds[["label", "cells"]].to_string(index=False))
+    print(kk[["K", "recipes_per_epoch", "recipes_per_epoch_min", "recipes_per_epoch_max"]].to_string(index=False))
+    for k, v, _ in nums:
+        print(k, v)
+
+
+if __name__ == "__main__":
+    main()