Archive 4 checkpoints (1-4)

paper-releases/20260928/diffusion/data/source_prep/giroux2022/code/giroux2022_pipeline.py

@@ -0,0 +1,545 @@
+#!/usr/bin/env python3
+"""Giroux et al., Sci Rep 2022 (Duke outpatient COVID-19) PBMC bulk (GSE206263) + scRNA (GSE206283) processing.
+
+CPU only; never imports torch or initializes CUDA.
+
+Reuses the frozen ImMicro strict-QC code bundle v5 VERBATIM (copied to code/strict_qc_v1_code_bundle_v5,
+sha256 verified against its MANIFEST), exactly as the Ye 2026 build did:
+  * qc_core.extract_archive / scan_mtx  (safe extraction, streaming MTX audit, cell flags:
+    min_genes 200, min_counts 500, max mito 20 %, 5-MAD outliers)
+  * qc_genes.GeneMapper                  (frozen 20,097-gene GENCODE v49 axis; symbol / ID mapping with
+    ambiguity and conflict quarantine)
+  * qc_singlecell.read_axes / canonical_export (canonical sparse H5AD, measured-gene masks,
+    per-sample SUM pseudobulk of all / review-pass cells)
+  * qc_bulk.from_assembled-style BulkInput + harmonize (bulk canonical matrix, NaN + masks)
+Only study-specific glue (GEO title parsing, the author count-table column names, per-library obs) is new.
+
+Subcommands: sources | extract | pairing | bulk | sc
+"""
+from __future__ import annotations
+
+import argparse
+import csv
+import gzip
+import json
+import re
+import sys
+import time
+from collections import defaultdict
+from concurrent.futures import ProcessPoolExecutor, as_completed
+from datetime import datetime, timezone
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+DATALAKE = Path("/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc")
+RAW = {"GSE206263": DATALAKE / "datasets/GSE206263", "GSE206283": DATALAKE / "datasets/GSE206283"}
+RUN = DATALAKE / "processing/giroux2022_v1_20260928"
+BUNDLE = RUN / "code/strict_qc_v1_code_bundle_v5"  # verbatim copy of strict_qc_v1_20260913/code_bundle_v5
+REFERENCE = DATALAKE / "processing/strict_qc_v1_20260913/reference"  # frozen; read only, sha-verified by GeneMapper
+RECEIPTS = DATALAKE / "acquisition/20260927/manifests/download_receipts.jsonl"
+BULK_TABLE = RUN / "extracted/GSE206263/bulk_RNA-seq_all_counts.csv"
+BULK_META = RUN / "extracted/GSE206263/bulk_RNA-seq_sample_metadata.tsv"
+sys.path.insert(0, str(BUNDLE))
+
+import qc_core  # noqa: E402
+import qc_genes  # noqa: E402
+
+GROUP_CODES = {"Mild": "mild", "Severe": "severe", "Exposed": "exposed", "Healthy": "healthy"}
+SEX_GENES = {"XIST": "ENSG00000229807", "RPS4Y1": "ENSG00000129824", "DDX3Y": "ENSG00000067048",
+             "UTY": "ENSG00000183878", "KDM5D": "ENSG00000012817"}
+META_FIELDS = ["ch_age", "ch_Sex", "ch_exposure", "ch_serostatus"]
+COUNT_EVIDENCE = ("Published per-GSM 10x Cell Ranger 3.1.0 filtered_feature_bc_matrix (matrix/features/barcodes, "
+                  "refdata hg19 32,738 genes); GEO: 10x Genomics Single Cell 5' v1, Cell Ranger count")
+
+
+def now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def log(event: dict) -> None:
+    event = {"t": now(), **event}
+    line = json.dumps(event, default=str)
+    print(line, flush=True)
+    with open(RUN / "events.jsonl", "a") as handle:
+        handle.write(line + "\n")
+
+
+def sha256(path: Path) -> str:
+    return qc_core.sha256_file(path)
+
+
+def verify_bundle() -> dict:
+    manifest = json.loads((BUNDLE / "MANIFEST.json").read_text())
+    for name, digest in manifest["files"].items():
+        if sha256(BUNDLE / name) != digest:
+            raise RuntimeError(f"Code bundle file changed: {name}")
+    return manifest
+
+
+# ----------------------------------------------------------------- sources
+def receipts() -> dict:
+    out = {}
+    for line in open(RECEIPTS):
+        rec = json.loads(line)
+        out[rec["local_path"]] = rec
+    return out
+
+
+def cmd_sources(_args) -> None:
+    """sha256 every acquired Giroux file used here and compare with the acquisition receipt."""
+    verify_bundle()
+    known = receipts()
+    records = []
+    for acc, base in RAW.items():
+        for path in sorted(list((base / "raw").glob("*")) + list((base / "metadata").glob("*"))):
+            if not path.is_file() or path.name.endswith((".partial", ".tmp")):
+                continue
+            rec = {"accession": acc, "path": str(path), "bytes": path.stat().st_size, "sha256": sha256(path)}
+            receipt = known.get(str(path))
+            rec["acquisition_receipt"] = bool(receipt)
+            if receipt:
+                rec.update(url=receipt["url"], receipt_sha256=receipt["sha256"], receipt_bytes=receipt["bytes"],
+                           receipt_completed_at=receipt["completed_at"],
+                           matches_receipt=(receipt["sha256"] == rec["sha256"] and receipt["bytes"] == rec["bytes"]))
+                if not rec["matches_receipt"]:
+                    raise RuntimeError(f"Acquired file differs from its receipt: {path}")
+            records.append(rec)
+    urls = json.loads((RUN / "external_metadata/URLS.json").read_text())["files"]
+    external = [{"path": str(RUN / "external_metadata" / name), "url": url,
+                 "bytes": (RUN / "external_metadata" / name).stat().st_size,
+                 "sha256": sha256(RUN / "external_metadata" / name)} for name, url in sorted(urls.items())]
+    qc_core._write_json(RUN / "SOURCES.json", {"created_at_utc": now(), "files": records,
+                                               "external_metadata_fetched_20260928": external,
+                                               "acquisition": "paired-datasets-20260927 acquisition (read only; not modified)",
+                                               "receipts": str(RECEIPTS)})
+    log({"stage": "sources", "n_files": len(records), "n_external": len(external),
+         "unreceipted": [r["path"] for r in records if not r["acquisition_receipt"]]})
+
+
+# ----------------------------------------------------------------- extract
+def cmd_extract(_args) -> None:
+    known = receipts()
+    # bulk: small tar.gz with one CSV count table and one TSV sample sheet
+    tgz = RAW["GSE206263"] / "raw/GSE206263_bulkRNA_processed.tar.gz"
+    rec = known[str(tgz)]
+    if tgz.stat().st_size != rec["bytes"] or sha256(tgz) != rec["sha256"]:
+        raise RuntimeError(f"Archive differs from acquisition receipt: {tgz}")
+    r = qc_core.extract_archive(tgz, RUN / "extracted/GSE206263", RUN / "extracted/GSE206263.extraction_receipt.json",
+                                disk_floor_bytes=50 * 1024**3)
+    log({"stage": "extract", "accession": "GSE206263", "members": r["member_count"], "complete": r["complete"]})
+    # scRNA: outer tar of 41 per-GSM tar.gz, each holding one filtered_feature_bc_matrix directory
+    tar = RAW["GSE206283"] / "raw/GSE206283_RAW.tar"
+    rec = known[str(tar)]
+    if tar.stat().st_size != rec["bytes"] or sha256(tar) != rec["sha256"]:
+        raise RuntimeError(f"Tar differs from acquisition receipt: {tar}")
+    outer_dir = RUN / "extracted/GSE206283_outer"
+    outer = qc_core.extract_archive(tar, outer_dir, RUN / "extracted/GSE206283_outer.extraction_receipt.json",
+                                    disk_floor_bytes=50 * 1024**3)
+    inner_receipts = {}
+    for name in sorted(outer["files"]):
+        m = re.fullmatch(r"(GSM\d+)_scRNA_(.+)_filtered_feature_bc_matrix\.tar\.gz", name)
+        if not m:
+            raise RuntimeError(f"Unexpected outer member: {name}")
+        dest = RUN / "extracted/GSE206283" / m.group(1)
+        inner = qc_core.extract_archive(outer_dir / name, dest, dest / ".extraction_receipt.json",
+                                        disk_floor_bytes=50 * 1024**3)
+        inner_receipts[name] = {"gsm": m.group(1), "author_library": m.group(2), "dest": str(dest),
+                                "members": sorted(inner["files"]), "complete": inner["complete"],
+                                "inner_archive_sha256": outer["files"][name]["sha256"]}
+    # The per-GSM tar.gz copies are redundant with the read-only original tar (sha256 kept in both receipts).
+    for name in outer["files"]:
+        (outer_dir / name).unlink()
+    qc_core._write_json(RUN / "extracted/GSE206283.inner_extraction.json",
+                        {"created_at_utc": now(), "outer_receipt": str(RUN / "extracted/GSE206283_outer.extraction_receipt.json"),
+                         "inner": inner_receipts,
+                         "note": "outer members (per-GSM tar.gz) were deleted after their verified inner extraction; "
+                                 "their sha256 remain in the outer receipt and the original tar is unchanged"})
+    log({"stage": "extract", "accession": "GSE206283", "libraries": len(inner_receipts),
+         "complete": all(v["complete"] for v in inner_receipts.values())})
+
+
+# ----------------------------------------------------------------- pairing
+def parse_soft(path: Path) -> pd.DataFrame:
+    samples, cur, section = [], None, None
+    with gzip.open(path, "rt", encoding="utf-8") as fh:
+        for line in fh:
+            line = line.rstrip("\n")
+            if line.startswith("^"):
+                section = line[1:].split(" = ")[0]
+                if section == "SAMPLE":
+                    cur = defaultdict(list)
+                    cur["gsm"] = [line.split(" = ")[1]]
+                    samples.append(cur)
+                continue
+            if section != "SAMPLE" or not line.startswith("!") or " = " not in line:
+                continue
+            key, val = line[1:].split(" = ", 1)
+            if key == "Sample_characteristics_ch1" and ": " in val:
+                k, v = val.split(": ", 1)
+                cur["ch_" + k.strip()].append(v.strip())
+            else:
+                cur[key].append(val)
+    return pd.DataFrame([{k: "|".join(v) for k, v in s.items()} for s in samples]).fillna("")
+
+
+TITLE = re.compile(r"^([0-9A-F]{6}), (\d+|NA), (Mild|Severe|Exposed|Healthy), (Negative|Positive|Exposed|Healthy)$")
+
+
+def parse_title(frame: pd.DataFrame, suffix: str = "") -> pd.DataFrame:
+    t = frame.Sample_title.str.removesuffix(suffix)
+    parts = t.str.extract(TITLE)
+    if parts.isna().any().any():
+        raise RuntimeError(f"Unexpected GEO title format: {t[parts.isna().any(axis=1)].tolist()}")
+    frame = frame.copy()
+    frame["subject"], frame["day"], frame["title_group"], frame["title_serostatus"] = parts[0], parts[1], parts[2], parts[3]
+    # every title field must equal its characteristics field
+    bad = frame[(frame.day != frame.ch_time) | (frame.title_group != frame.ch_exposure) |
+                (frame.title_serostatus != frame.ch_serostatus)]
+    if len(bad):
+        raise RuntimeError(f"Title differs from characteristics: {bad.gsm.tolist()}")
+    return frame
+
+
+def sample_key(subject: str, day: str) -> str:
+    return f"{subject}_d{day}"
+
+
+def read_bulk_header() -> list[str]:
+    with open(BULK_TABLE, newline="") as handle:
+        header = next(csv.reader(handle))
+    if len(set(header)) != len(header) or any(not h.strip() for h in header):
+        raise RuntimeError("Bulk count-table header has duplicate or empty sample names")
+    return header
+
+
+def cmd_pairing(_args) -> None:
+    out = RUN / "pairing"
+    out.mkdir(parents=True, exist_ok=True)
+    bulk = parse_title(parse_soft(RAW["GSE206263"] / "metadata/GSE206263_family.soft.gz"))
+    sc = parse_title(parse_soft(RAW["GSE206283"] / "metadata/GSE206283_family.soft.gz"), " [scRNA-Seq]")
+    bulk.to_csv(out / "GSE206263_samples.csv", index=False)
+    sc.to_csv(out / "GSE206283_samples.csv", index=False)
+    if not (sc.ch_library == sc.subject).all():
+        raise RuntimeError("sc 'library' characteristic differs from the title subject")
+    sc["matrix_archive"] = sc.Sample_supplementary_file_1.str.extract(r"/(GSM\d+_scRNA_[^/]+_filtered_feature_bc_matrix\.tar\.gz)$")[0]
+    sc["author_library"] = sc.matrix_archive.str.extract(r"^GSM\d+_scRNA_(.+)_filtered_feature_bc_matrix\.tar\.gz$")[0]
+    if sc.author_library.isna().any():
+        raise RuntimeError("sc GSM without a filtered_feature_bc_matrix archive")
+    # author library names are '<internal no>-<day>' for infected/exposed subjects and '<no>' for healthy
+    lib_day = sc.author_library.str.extract(r"^\d+-(\d+)$")[0].fillna("NA")
+    if not (lib_day == sc.day).all():
+        raise RuntimeError("sc author library day suffix differs from GEO time")
+    for name, frame in (("bulk", bulk), ("sc", sc)):
+        frame["sample_id"] = [sample_key(s, d) for s, d in zip(frame.subject, frame.day)]
+        if not frame.sample_id.is_unique:
+            raise RuntimeError(f"Duplicate {name} subject-day keys")
+    # author count-table columns: '<subject>-<day>' (infected) or '<subject>' (healthy)
+    header = read_bulk_header()
+    cols = pd.DataFrame({"bulk_column": header})
+    parsed = cols.bulk_column.str.extract(r"^([0-9A-F]{6})(?:-(\d+))?$")
+    if parsed[0].isna().any():
+        raise RuntimeError(f"Unparsed bulk column names: {cols.bulk_column[parsed[0].isna()].tolist()}")
+    cols["subject"], cols["day"] = parsed[0], parsed[1].fillna("NA")
+    cols["sample_id"] = [sample_key(s, d) for s, d in zip(cols.subject, cols.day)]
+    author_meta = pd.read_csv(BULK_META, sep="\t", dtype=str, keep_default_na=False)
+    cols = cols.merge(author_meta.rename(columns={"SampleID": "subject", "Cohort": "author_cohort"})[
+        ["subject", "author_cohort", "IgG_Negative_Day", "IgG_Positive_Day"]], on="subject", how="left")
+    by_key = dict(zip(bulk.sample_id, bulk.gsm))
+    cols["bulk_gsm"] = cols.sample_id.map(by_key)
+    cols["column_to_gsm"] = np.where(cols.bulk_gsm.notna(), "exact_subject_day", "no_GEO_bulk_GSM_with_this_subject_day")
+    cols.to_csv(out / "bulk_count_columns.csv", index=False)
+    col_by_gsm = dict(zip(cols.bulk_gsm.dropna(), cols.bulk_column[cols.bulk_gsm.notna()]))
+    bulk["bulk_count_column"] = bulk.gsm.map(col_by_gsm).fillna("")
+    bulk["group"] = bulk.ch_exposure.map(GROUP_CODES)
+
+    brow = bulk.set_index("sample_id")
+    rows = []
+    for _, g in sc.iterrows():
+        rec = {"sc_gsm": g.gsm, "sc_title": g.Sample_title, "sample_id": g.sample_id, "subject": g.subject,
+               "day": g.day, "group": GROUP_CODES[g.ch_exposure], "author_library": g.author_library,
+               "sc_age": g.ch_age, "sc_sex": g.ch_Sex, "sc_serostatus": g.ch_serostatus}
+        if g.sample_id in brow.index:
+            b = brow.loc[g.sample_id]
+            mismatch = [f for f in META_FIELDS if b[f] != g[f]]
+            rec.update({"bulk_gsm": b.gsm, "bulk_title": b.Sample_title, "bulk_count_column": b.bulk_count_column,
+                        "metadata_mismatch_fields": ";".join(mismatch)})
+            if mismatch:
+                status = "geo_metadata_mismatch"
+            elif b.bulk_count_column:
+                status = "paired"
+            else:
+                status = "bulk_GSM_has_no_column_in_author_count_table"
+        else:
+            status = "no_bulk_GSM_for_this_subject_day"
+            other = bulk[bulk.subject == g.subject]
+            rec["bulk_days_for_subject"] = ",".join(other.day) if len(other) else ""
+        rec["pair_status"] = status
+        rows.append(rec)
+    table = pd.DataFrame(rows)
+    table["paired"] = table.pair_status == "paired"
+    table["pair_sample_id"] = np.where(table.paired, table.sample_id, "")
+    for c in ("bulk_gsm", "bulk_title", "bulk_count_column", "metadata_mismatch_fields", "bulk_days_for_subject"):
+        if c not in table:
+            table[c] = ""
+        table[c] = table[c].fillna("")
+    table.to_csv(out / "sc_libraries_with_bulk_match.csv", index=False)
+    used_cols = set(table.bulk_count_column[table.paired])
+    cols["paired"] = cols.bulk_column.isin(used_cols)
+    sc_keys = set(sc.sample_id)
+    cols["unpaired_reason"] = np.where(cols.paired, "",
+                                       np.where(cols.bulk_gsm.isna(), "column_name_not_a_GEO_subject_day",
+                                                np.where(cols.sample_id.isin(sc_keys), "sc_exists_but_not_accepted",
+                                                         "no_sc_library_for_this_subject_day")))
+    cols.to_csv(out / "bulk_count_columns.csv", index=False)
+    bulk_no_col = bulk[bulk.bulk_count_column == ""][["gsm", "Sample_title", "sample_id", "subject", "day", "group"]]
+    bulk_no_col.to_csv(out / "bulk_GSM_without_count_column.csv", index=False)
+    cohort = cols.drop_duplicates("subject").set_index("subject").author_cohort
+    geo_group = bulk.drop_duplicates("subject").set_index("subject").ch_exposure
+    both = sorted(set(cohort.index) & set(geo_group.index))
+    summary = {
+        "bulk_gsms": len(bulk), "bulk_subjects_geo": int(bulk.subject.nunique()),
+        "bulk_count_table_columns": len(cols), "bulk_count_table_subjects": int(cols.subject.nunique()),
+        "bulk_columns_matched_to_GSM": int(cols.bulk_gsm.notna().sum()),
+        "bulk_columns_without_GSM": cols[cols.bulk_gsm.isna()].bulk_column.tolist(),
+        "bulk_GSMs_without_count_column": len(bulk_no_col),
+        "bulk_GSMs_without_count_column_by_group": bulk_no_col.group.value_counts().to_dict(),
+        "sc_gsms": len(sc), "sc_subjects": int(sc.subject.nunique()),
+        "geo_level_subject_day_matches": int(table.bulk_gsm.astype(bool).sum()),
+        "geo_level_subject_day_matches_by_group": table[table.bulk_gsm.astype(bool)].group.value_counts().to_dict(),
+        "geo_level_subjects": int(table[table.bulk_gsm.astype(bool)].subject.nunique()),
+        "pairs_total": int(table.paired.sum()), "pairs_subjects": int(table[table.paired].subject.nunique()),
+        "pairs_by_group": table[table.paired].group.value_counts().to_dict(),
+        "pairs_by_day": table[table.paired].day.value_counts().to_dict(),
+        "sc_by_pair_status": table.pair_status.value_counts().to_dict(),
+        "sc_unpaired": table[~table.paired][["sc_gsm", "sample_id", "group", "pair_status"]].to_dict("records"),
+        "author_cohort_vs_geo_exposure": {s: {"author_cohort": cohort[s], "geo_exposure": geo_group[s]} for s in both
+                                          if cohort[s] != geo_group[s]},
+        "rule": ("A pair is one sc GEX GSM and one bulk GSM with the same GEO subject ID and the same GEO sampling day "
+                 "(title '<subject>, <day>, <group>, <serostatus>' = characteristics subject/time); both GSMs must "
+                 "agree on GEO age, sex, exposure group and serostatus; and the bulk GSM must have a column in the "
+                 "author featureCounts table (column '<subject>-<day>' for infected/exposed subjects, '<subject>' "
+                 "for healthy). No expression, age-sex or row-order matching is used to create a pair."),
+    }
+    qc_core._write_json(out / "PAIRING_SUMMARY.json", summary)
+    log({"stage": "pairing", **{k: summary[k] for k in ("pairs_total", "pairs_subjects", "pairs_by_group",
+                                                        "geo_level_subject_day_matches", "bulk_columns_without_GSM")}})
+
+
+# ----------------------------------------------------------------- bulk
+def read_bulk_table():
+    header = read_bulk_header()
+    ids, rows = [], []
+    with open(BULK_TABLE, newline="") as handle:
+        reader = csv.reader(handle)
+        next(reader)
+        for line_number, fields in enumerate(reader, start=2):
+            if len(fields) != len(header) + 1:
+                raise ValueError(f"Line {line_number}: expected gene symbol + {len(header)} values, got {len(fields)}")
+            ids.append(fields[0])
+            rows.append([float(x) for x in fields[1:]])  # float() raises on any non-numeric token
+    values = np.asarray(rows, dtype=np.float64)
+    if len(set(ids)) != len(ids):
+        raise ValueError("Duplicate gene symbols in the author count table")
+    return header, ids, values
+
+
+def cmd_bulk(_args) -> None:
+    import qc_bulk
+    verify_bundle()
+    mapper = qc_genes.GeneMapper(REFERENCE)
+    samples, ids, values = read_bulk_table()
+    (RUN / "bulk").mkdir(exist_ok=True)
+    cols = pd.read_csv(RUN / "pairing/bulk_count_columns.csv", dtype=str, keep_default_na=False).set_index("bulk_column")
+    np.savez_compressed(RUN / "bulk/bulk_source_counts.npz", gene_ids=np.asarray(ids), sample_ids=np.asarray(samples),
+                        gsm=np.asarray([cols.loc[s, "bulk_gsm"] for s in samples]), counts=values.T.copy())
+    meta = [{"bulk_column": s, "GSM": cols.loc[s, "bulk_gsm"], "subject": cols.loc[s, "subject"],
+             "day": cols.loc[s, "day"], "author_cohort": cols.loc[s, "author_cohort"],
+             "assigned_gene_total": float(values[:, j].sum())} for j, s in enumerate(samples)]
+    assay = qc_bulk.BulkInput(
+        "GSE206263", "GSE206263_featureCounts", "featureCounts_raw_gene_counts", ids, samples, values.T.copy(),
+        symbols=None, present=None, declared_raw_counts=True, sources=[BULK_TABLE, BULK_META], sample_metadata=meta,
+        caveats=["GEO: PBMC total RNA (Zymo Direct-zol), NuGEN Ovation SoLo RNA-Seq library kit, NovaSeq 6000, "
+                 "SortMeRNA rRNA removal, STAR to hg19, featureCounts; strandedness option not stated.",
+                 "Author table (bulk_RNA-seq_all_counts.csv) holds 49 of the 71 GEO bulk GSMs; genes are hg19 "
+                 "annotation symbols (no Ensembl IDs), mapped to the canonical axis by symbol only.",
+                 "Five healthy column names (77DA77, 22CBD6, 4F2EAD, F8FF1A, 56E219) are not GEO subject IDs and "
+                 "column 3F05F3-14 has no GEO GSM (GEO lists 3F05F3 days 0, 7, 28); see pairing/.",
+                 "The table header has no gene-ID column label; each data row is symbol + 49 values (checked)."],
+        extra={"source_format": "CSV, header = 49 sample names, rows = gene symbol + 49 integer values",
+               "source_gene_rows": len(ids)})
+    report = qc_bulk.harmonize(assay, mapper, RUN / "bulk" / assay.assay_id)
+    log({"stage": "bulk", "status": report["status"], "n_samples": report["n_samples"],
+         "raw_count_eligible": report["raw_count_eligible"], "canonical_coverage": report["canonical_coverage"],
+         "duplicate_target_groups_summed": report["duplicate_target_groups_summed_counts"]})
+
+
+# ----------------------------------------------------------------- single cell
+def library_files(gsm: str) -> dict:
+    base = RUN / "extracted/GSE206283" / gsm
+    found = {}
+    for kind in ("barcodes.tsv.gz", "features.tsv.gz", "matrix.mtx.gz"):
+        hits = sorted(base.rglob(kind))
+        if len(hits) != 1:
+            raise RuntimeError(f"{gsm}: expected one {kind}, found {len(hits)}")
+        found[kind.split(".")[0]] = hits[0]
+    return found
+
+
+def process_library(row: dict) -> dict:
+    import qc_singlecell as qs
+    import scipy.io._fast_matrix_market as fmm
+    from scipy.io import mmread
+
+    fmm.PARALLELISM = 1  # single-threaded MTX reader (host CPU budget)
+
+    qs.COUNT_SOURCE_EVIDENCE["GSE206283"] = COUNT_EVIDENCE  # provenance string only
+    gsm, sid = row["sc_gsm"], row["sample_id"]
+    out = RUN / "singlecell" / gsm
+    out.mkdir(parents=True, exist_ok=True)
+    summary_path = out / "summary.json"
+    if summary_path.exists() and json.loads(summary_path.read_text()).get("status") == "PASS":
+        return json.loads(summary_path.read_text())
+    files = library_files(gsm)
+    item = {"accession": "GSE206283", "library_id": gsm, "path": str(files["matrix"]), "format": "mtx",
+            "duplicate_representation": False, "features_path": str(files["features"]),
+            "barcodes_path": str(files["barcodes"])}
+    summary = {**item, "sample_id": sid, "author_library": row["author_library"], "status": "RUNNING",
+               "output_dir": str(out), "started": now()}
+    qc_core._write_json(summary_path, summary)
+    t0 = time.time()
+    try:
+        mapper = qc_genes.GeneMapper(REFERENCE)
+        ids, symbols, cells, rna, axes = qs.read_axes(item)
+        item["matrix_path"] = axes["matrix_path"]
+        mapping = mapper.map_features(ids, symbols)
+        mapping_summary = mapper.write_rows(mapping, out / "gene_mapping")
+        mito = np.asarray([r["mitochondrial"] for r in mapping])
+        n = len(cells)
+        if len(set(cells)) != n:
+            raise qs.QCError("Duplicate barcodes within library")
+        obs = pd.DataFrame({"barcode": cells, "source_barcode": cells, "raw_10x_barcode": cells,
+                            "author_cell_id": "", "library_id": gsm, "donor_id": row["subject"], "sample_id": sid,
+                            "visit_id": "day_" + row["day"], "author_retained": "unknown",
+                            "mapping_basis": "one 10x library per GEO GSM; subject and day from GEO title/characteristics",
+                            "protocol": "10x_5prime_v1"})
+        obs.to_csv(out / "cell_metadata.csv.gz", index=False, compression="gzip")
+        metrics = out / "metrics"
+        if (metrics / "qc_summary.json").exists():
+            qc = json.loads((metrics / "qc_summary.json").read_text())
+        else:
+            qc = qc_core.scan_mtx(item["path"], metrics, mito_mask=mito, feature_mask=rna,
+                                  sample_ids=obs.sample_id.to_numpy(), feature_ids=ids,
+                                  feature_symbols=symbols, cell_ids=cells)
+        total = np.load(metrics / "cell_total.npy")
+        detected = np.load(metrics / "cell_detected.npy")
+        mito_pct = np.load(metrics / "cell_mito_percent.npy")
+        pd.DataFrame([{"min_genes": g, "min_abundance": 500, "max_mito_percent": m,
+                       "n_review_pass": int(((detected >= g) & (total >= 500) & (mito_pct <= m)).sum())}
+                      for g in (100, 200, 500) for m in (10, 20, 30)]).to_csv(out / "threshold_sensitivity.csv", index=False)
+        integral = qc["numeric"]["integer_fraction_selected_stored"] == 1
+        item["source_sha256"] = qc["input"].get("sha256", "")
+        item["canonical_identity_sha256"] = mapper.manifest.get("canonical_identity_sha256", "")
+        verified = bool(integral)
+        units = "UMI_counts" if verified else "nonnegative_abundance_source_units_unproven"
+        export = qs.canonical_export(item, out, mapping, mapper.canonical, obs, rna,
+                                     verified_counts=verified, units=units, full_mapping=True)
+        # Source-axis sums (all RNA features, incl. non-protein-coding XIST) for identity checks.
+        qcpass = np.load(metrics / "flag_conservative_review_pass.npy")
+        matrix = mmread(item["path"]).tocsc()
+        if matrix.shape != (len(ids), n):
+            raise qs.QCError("MTX shape changed")
+        all_sum = np.asarray(matrix.sum(axis=1)).ravel()
+        pass_sum = np.asarray(matrix[:, np.flatnonzero(qcpass)].sum(axis=1)).ravel()
+        if not np.isclose(all_sum[rna].sum(), total.sum(), rtol=1e-12):
+            raise qs.QCError("Source-axis sum differs from QC scan")
+        np.savez_compressed(out / "source_axis_pseudobulk.npz", feature_ids=np.asarray(ids),
+                            feature_symbols=np.asarray(symbols), rna=rna, all_cells_sum=all_sum,
+                            qc_pass_sum=pass_sum, n_cells=n, n_qc_pass=int(qcpass.sum()))
+        where = {g: i for i, g in enumerate(ids)}
+        sex_rows = [where.get(g, -1) for g in SEX_GENES.values()]
+        per_cell = np.zeros((len(SEX_GENES), n), dtype=np.float64)
+        csr = matrix.tocsr()
+        for k, r in enumerate(sex_rows):
+            if r >= 0:
+                per_cell[k] = csr[r].toarray().ravel()
+        np.savez_compressed(out / "cell_sex_gene_counts.npz", genes=np.asarray(list(SEX_GENES)),
+                            gene_ids=np.asarray(list(SEX_GENES.values())), found=np.asarray(sex_rows) >= 0,
+                            counts=per_cell)
+        del matrix, csr
+        # Author filtering evidence (GEO: Seurat removed cells with > 5 % mito reads or > 2,500 genes).
+        author = {"cells": n, "mito_gt_5pct": int((mito_pct > 5).sum()), "genes_gt_2500": int((detected > 2500).sum()),
+                  "author_rule_would_keep": int(((mito_pct <= 5) & (detected <= 2500)).sum()),
+                  "counts_lt_500": int((total < 500).sum()), "genes_lt_200": int((detected < 200).sum()),
+                  "min_genes": int(detected.min()), "min_total": float(total.min()),
+                  "max_mito_pct": float(mito_pct.max()), "median_genes": float(np.median(detected)),
+                  "median_total": float(np.median(total))}
+        barcodes = sorted(cells)
+        chemistry = {"first_sorted_barcode": barcodes[0], "barcode_suffixes": sorted({c.rsplit("-", 1)[-1] for c in cells}),
+                     "barcode_length": sorted({len(c.split("-")[0]) for c in cells}),
+                     "mtx_header": open_mtx_header(item["path"])}
+        summary.update({"status": "PASS", "n_cells": n, "n_features": len(ids),
+                        "n_rna_features": int(rna.sum()), "n_qc_review_pass": int(qcpass.sum()),
+                        "flag_counts": qc["flag_counts"], "numeric": qc["numeric"], "units": units,
+                        "count_space_verified": verified, "count_provenance": COUNT_EVIDENCE,
+                        "canonicalcoverage": mapping_summary, "canonical_export": export,
+                        "author_prefilter_evidence": author, "chemistry_evidence": chemistry,
+                        "features_sha256": sha256(files["features"]),
+                        "seconds": round(time.time() - t0, 1), "finished": now()})
+    except Exception as error:  # noqa: BLE001 - recorded, not hidden
+        summary.update({"status": "QUARANTINED", "error_type": type(error).__name__, "error": str(error)})
+    qc_core._write_json(summary_path, summary)
+    return summary
+
+
+def open_mtx_header(path: str) -> str:
+    with gzip.open(path, "rt") as handle:
+        lines = [handle.readline().strip() for _ in range(2)]
+    return " | ".join(lines)
+
+
+def cmd_sc(args) -> None:
+    verify_bundle()
+    table = pd.read_csv(RUN / "pairing/sc_libraries_with_bulk_match.csv", dtype=str, keep_default_na=False)
+    rows = table.to_dict("records")
+    if args.only_paired:
+        rows = [r for r in rows if r["paired"] == "True"]
+    if args.gsm:
+        rows = [r for r in rows if r["sc_gsm"] in set(args.gsm.split(","))]
+    if args.limit:
+        rows = rows[:args.limit]
+    log({"stage": "sc", "event": "start", "n_libraries": len(rows), "workers": args.workers})
+    done = []
+    with ProcessPoolExecutor(max_workers=args.workers, max_tasks_per_child=1) as pool:
+        futures = {pool.submit(process_library, r): r["sc_gsm"] for r in rows}
+        for future in as_completed(futures):
+            s = future.result()
+            done.append(s)
+            log({"stage": "sc", "library": futures[future], "status": s["status"], "n_cells": s.get("n_cells"),
+                 "n_qc_review_pass": s.get("n_qc_review_pass"), "seconds": s.get("seconds"), "error": s.get("error")})
+    if not args.gsm and not args.limit:
+        qc_core._write_json(RUN / "singlecell/SINGLECELL_SUMMARY.json",
+                            {"created_at_utc": now(), "libraries": sorted(done, key=lambda s: s["library_id"])})
+    log({"stage": "sc", "event": "finish", "pass": sum(s["status"] == "PASS" for s in done), "n": len(done)})
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    sub = parser.add_subparsers(dest="cmd", required=True)
+    sub.add_parser("sources")
+    sub.add_parser("extract")
+    sub.add_parser("pairing")
+    sub.add_parser("bulk")
+    p = sub.add_parser("sc")
+    p.add_argument("--workers", type=int, default=3)
+    p.add_argument("--limit", type=int, default=0)
+    p.add_argument("--only-paired", action="store_true")
+    p.add_argument("--gsm", default="", help="comma-separated GSM subset")
+    args = parser.parse_args()
+    RUN.mkdir(parents=True, exist_ok=True)
+    {"sources": cmd_sources, "extract": cmd_extract, "pairing": cmd_pairing, "bulk": cmd_bulk, "sc": cmd_sc}[args.cmd](args)
+
+
+if __name__ == "__main__":
+    main()

paper-releases/20260928/diffusion/data/source_prep/giroux2022/code/run_step.sh

@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+# Run one CPU-only pipeline step as a transient systemd user unit.
+# Limits: 12 GiB memory (no swap), <= 4 CPUs, positive OOM score, no restart,
+# CUDA hidden, single-threaded BLAS/OpenMP. Usage: run_step.sh <subcommand> [args]
+set -euo pipefail
+RUN=/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc/processing/giroux2022_v1_20260928
+PY=/home/sj_server_1/miniforge3/envs/scanvi/bin/python
+step="$1"
+shift || true
+unit="giroux2022-${step}-$(date +%H%M%S)"
+systemctl --user is-active --quiet ml-memory-guard.service
+case "$step" in
+  assemble) script=giroux2022_assemble.py ;;
+  findings) script=giroux2022_findings.py ;;
+  fullcells) script=giroux2022_full_cells.py ;;
+  *) script=giroux2022_pipeline.py; set -- "$step" "$@" ;;
+esac
+exec systemd-run --user --wait --collect --quiet --unit="$unit" --slice=app.slice \
+  -p MemoryHigh=10G -p MemoryMax=12G -p MemorySwapMax=0 -p CPUQuota=400% \
+  -p OOMPolicy=kill -p OOMScoreAdjust=500 -p Nice=10 -p IOSchedulingClass=idle \
+  --working-directory="$RUN" \
+  -E CUDA_VISIBLE_DEVICES= -E OMP_NUM_THREADS=1 -E OPENBLAS_NUM_THREADS=1 -E MKL_NUM_THREADS=1 \
+  -E NUMEXPR_NUM_THREADS=1 -E PYTHONDONTWRITEBYTECODE=1 -E PYTHONUNBUFFERED=1 \
+  -p StandardOutput="append:$RUN/logs/${step}.log" -p StandardError="append:$RUN/logs/${step}.log" \
+  "$PY" "$RUN/code/$script" "$@"

paper-releases/20260928/diffusion/data/source_prep/giroux2022/code/strict_qc_v1_code_bundle_v5/qc_bulk.py

@@ -0,0 +1,667 @@
+#!/usr/bin/env python3
+"""Bulk expression file validation and lossless unit-preserving organization.
+
+No biological inference, donor guessing, normalization, integer coercion,
+inverse log transformation, or imputation is performed. Run through the root
+orchestrator; this module does not start a process or initialize CUDA.
+"""
+from __future__ import annotations
+
+from collections import Counter, defaultdict
+from dataclasses import dataclass, field
+import csv
+import gzip
+import io
+import json
+from pathlib import Path
+import re
+from typing import Iterable
+
+import numpy as np
+import pandas as pd
+
+from qc_genes import GeneMapper, clean_token, sha256
+
+
+@dataclass
+class BulkInput:
+    accession: str
+    assay_id: str
+    units: str
+    ids: list[str]
+    samples: list[str]
+    values: np.ndarray  # samples x source features, float64, unchanged units
+    symbols: list[str] | None = None
+    present: np.ndarray | None = None
+    declared_raw_counts: bool = False
+    allow_negative: bool = False
+    sources: list[Path] = field(default_factory=list)
+    sample_metadata: list[dict] = field(default_factory=list)
+    feature_metadata: list[dict] = field(default_factory=list)
+    caveats: list[str] = field(default_factory=list)
+    extra: dict = field(default_factory=dict)
+
+
+def opener(path: Path):
+    return gzip.open(path, "rt", encoding="utf-8-sig", newline="") if path.suffix == ".gz" else path.open("r", encoding="utf-8-sig", newline="")
+
+
+def validate_original_header(fields: list[str], source: str, *, allow_first_empty: bool = True) -> list[str]:
+    """Refuse identity loss before pandas can rename repeated/empty headers."""
+    if not fields:
+        raise ValueError(f"Missing table header: {source}")
+    duplicates = [name for name, count in Counter(fields).items() if count > 1]
+    if duplicates:
+        raise ValueError(f"Duplicate original table headers in {source}: {duplicates}")
+    for index, name in enumerate(fields):
+        if not name.strip() and not (allow_first_empty and index == 0):
+            raise ValueError(f"Empty original sample/column header at position {index} in {source}")
+    return fields
+
+
+def read_original_header(path: Path, sep: str = "\t", *, comment: str | None = None) -> list[str]:
+    with opener(path) as handle:
+        for row in csv.reader(handle, delimiter=sep):
+            if not row or (comment and row[0].startswith(comment)):
+                continue
+            return validate_original_header(row, str(path))
+    raise ValueError(f"No table header in {path}")
+
+
+def load_table(path: Path, sep: str = "\t", **kwargs) -> pd.DataFrame:
+    if kwargs.get("header", "infer") is not None:
+        read_original_header(path, sep, comment=kwargs.get("comment"))
+    with opener(path) as handle:
+        return pd.read_csv(handle, sep=sep, keep_default_na=False, **kwargs)
+
+
+def load_space_header_matrix(path: Path) -> tuple[list[str], pd.DataFrame]:
+    """Randolph's first line contains samples only, with no gene-ID placeholder.
+
+    Use positional dataframe columns: supplying synthetic pandas column names
+    could promote an extra source field to an implicit index or collide with a
+    real sample named 'gene_id'. Width is checked before assigning identities.
+    """
+    with opener(path) as handle:
+        samples = validate_original_header(handle.readline().split(), str(path), allow_first_empty=False)
+        frame = pd.read_csv(handle, sep=r"\s+", header=None, keep_default_na=False)
+    if frame.shape[1] != len(samples) + 1:
+        raise ValueError(f"Space-header matrix requires one gene ID plus {len(samples)} values, got {frame.shape[1]} columns: {path}")
+    return samples, frame
+
+
+def validate_featurecounts_header(path: Path) -> list[str]:
+    header = read_original_header(path, comment="#")
+    metadata = ["Geneid", "Chr", "Start", "End", "Strand", "Length", "gene_name"]
+    if len(header) != 8 or header[:7] != metadata:
+        raise ValueError(f"featureCounts requires seven expected metadata columns and exactly one expression column; got {len(header)} columns in {path}")
+    return header
+
+
+def numeric_values(frame: pd.DataFrame) -> np.ndarray:
+    # Reject arbitrary strings rather than silently coercing them to missing.
+    return frame.apply(pd.to_numeric, errors="raise").to_numpy(dtype=np.float64).T
+
+
+def raw_file(root: Path, accession: str, glob: str) -> Path:
+    found = sorted((root / "datasets" / accession / "raw").glob(glob))
+    found = [p for p in found if not p.name.endswith(".sha256")]
+    if len(found) != 1:
+        raise ValueError(f"Expected one {accession}/{glob}, found {len(found)}")
+    return found[0]
+
+
+def extracted_files(runroot: Path, accession: str, predicate) -> list[Path]:
+    files = [p for p in (runroot / "extracted" / accession).rglob("*") if p.is_file() and predicate(p.name)]
+    # Prefer an expanded sibling if both gzip and expanded copies are present.
+    by_name: dict[str, Path] = {}
+    for path in sorted(files):
+        key = path.name[:-3] if path.name.endswith(".gz") else path.name
+        if key in by_name and by_name[key].parent != path.parent:
+            raise ValueError(f"Ambiguous extracted source filename across directories: {key}")
+        if key not in by_name or path.suffix != ".gz":
+            by_name[key] = path
+    if not by_name:
+        raise FileNotFoundError(f"No extracted expression files for {accession}")
+    return sorted(by_name.values())
+
+
+def sample_file_label(path: Path, suffix: str) -> tuple[str, str]:
+    name = path.name.removesuffix(".gz").removesuffix(suffix)
+    match = re.match(r"^(GSM\d+)_(.*)$", name)
+    return (match[2], match[1]) if match else (name, "")
+
+
+def assemble_samples(records: Iterable[tuple[str, list[str], list[str] | None, np.ndarray, dict]]) -> tuple:
+    """Exact union with per-sample feature-table masks; no positional joins.
+
+    Repeated source identities get an occurrence key and remain separate rows.
+    The harmonizer alone decides whether count-only aggregation is allowed.
+    """
+    keys: dict[tuple[str, str, int], int] = {}
+    sample_names, stored, metadata = [], [], []
+    for sample, ids, symbols, vector, meta in records:
+        if sample in sample_names:
+            raise ValueError(f"Duplicate bulk sample label: {sample}")
+        vector = np.asarray(vector, dtype=np.float64)
+        if vector.ndim != 1 or len(ids) != len(vector):
+            raise ValueError(f"Feature/value dimensions differ for {sample}")
+        if symbols is not None and len(symbols) != len(ids):
+            raise ValueError(f"ID/symbol dimensions differ for {sample}")
+        occurrence: Counter = Counter()
+        indices = []
+        for i, gid in enumerate(ids):
+            symbol = symbols[i] if symbols is not None else ""
+            identity = (clean_token(gid), clean_token(symbol))
+            nth = occurrence[identity]
+            occurrence[identity] += 1
+            key = identity + (nth,)
+            if key not in keys:
+                keys[key] = len(keys)
+            indices.append(keys[key])
+        stored.append((np.asarray(indices, dtype=np.int64), vector))
+        sample_names.append(sample)
+        metadata.append(meta)
+    if not stored:
+        raise ValueError("No bulk samples parsed")
+    matrix = np.full((len(stored), len(keys)), np.nan, dtype=np.float64)
+    present = np.zeros(matrix.shape, dtype=bool)
+    for i, (indices, vector) in enumerate(stored):
+        matrix[i, indices] = vector
+        present[i, indices] = True
+    identities = list(keys)
+    return ([k[0] for k in identities], [k[1] for k in identities], sample_names, matrix, present, metadata)
+
+
+def from_assembled(accession: str, assay_id: str, units: str, records, **kwargs) -> BulkInput:
+    ids, symbols, samples, values, present, metadata = assemble_samples(records)
+    return BulkInput(accession, assay_id, units, ids, samples, values,
+                     symbols=symbols if any(symbols) else None, present=present,
+                     sample_metadata=metadata, **kwargs)
+
+
+def json_safe(value):
+    if isinstance(value, dict):
+        return {str(k): json_safe(v) for k, v in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [json_safe(v) for v in value]
+    if isinstance(value, np.ndarray):
+        return json_safe(value.tolist())
+    if isinstance(value, (np.integer, np.bool_)):
+        return value.item()
+    if isinstance(value, (float, np.floating)):
+        return float(value) if np.isfinite(value) else None
+    if isinstance(value, Path):
+        return str(value)
+    return value
+
+
+def write_json(path: Path, value) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(json_safe(value), ensure_ascii=False, indent=2, allow_nan=False) + "\n")
+
+
+def _fraction(numerator: float, denominator: float) -> float:
+    return float(numerator / denominator) if denominator else np.nan
+
+
+def harmonize(assay: BulkInput, mapper: GeneMapper, output: Path) -> dict:
+    """Validate source numbers and organize them without changing their units."""
+    import anndata as ad
+
+    output.mkdir(parents=True, exist_ok=True)
+    values = np.asarray(assay.values, dtype=np.float64)
+    if values.shape != (len(assay.samples), len(assay.ids)):
+        raise ValueError(f"Bulk matrix dimensions do not match declared axes: {assay.assay_id}")
+    if len(set(assay.samples)) != len(assay.samples):
+        raise ValueError("Nonunique sample IDs are not automatically renamed")
+    present = np.ones(values.shape, dtype=bool) if assay.present is None else np.asarray(assay.present, dtype=bool)
+    if present.shape != values.shape:
+        raise ValueError("Presence-mask dimensions differ from expression matrix")
+    finite = np.isfinite(values) & present
+    selected = values[present]
+    finite_values = selected[np.isfinite(selected)]
+    negative = int(np.sum(finite_values < 0))
+    fractional = int(np.sum(finite_values != np.trunc(finite_values)))
+    invalid = int(selected.size - finite_values.size)
+    raw_eligible = bool(assay.declared_raw_counts and not negative and not fractional and not invalid)
+    rows = mapper.map_features(assay.ids, assay.symbols)
+    if assay.feature_metadata and len(assay.feature_metadata) != len(rows):
+        raise ValueError("Feature annotation length differs from source feature axis")
+    for i, row in enumerate(rows):
+        if assay.feature_metadata:
+            annotation = assay.feature_metadata[i]
+            row["source_annotation"] = json.dumps(annotation, ensure_ascii=False, sort_keys=True)
+            if annotation.get("mapping_blocker"):
+                row["target_index"] = -1
+                row["target_gene_id"] = ""
+                row["target_gene_symbol"] = ""
+                row["status"] = str(annotation["mapping_blocker"])
+                row["evidence"] += ";explicit_source_annotation_refusal"
+    mapper.write_rows(rows, output / "source_feature_mapping")
+    groups: dict[int, list[int]] = defaultdict(list)
+    for i, row in enumerate(rows):
+        if row["target_index"] >= 0:
+            groups[row["target_index"]].append(i)
+    n, g = len(assay.samples), mapper.canonical_size
+    aligned = np.full((n, g), np.nan, dtype=np.float64)
+    target_present = np.zeros((n, g), dtype=bool)
+    valid = np.zeros((n, g), dtype=bool)
+    duplicate_quarantine = np.zeros(values.shape[1], dtype=bool)
+    duplicate_count_groups = 0
+    for target, indices in groups.items():
+        member_present = present[:, indices]
+        target_present[:, target] = np.any(member_present, axis=1)
+        count_per_sample = np.sum(member_present, axis=1)
+        if len(indices) > 1 and not raw_eligible:
+            # Even if only one occurrence is exported in one sample, a shared
+            # axis with unresolved many-to-one normalized features is refused.
+            duplicate_quarantine[indices] = True
+            continue
+        ok = target_present[:, target] & np.all(finite[:, indices] | ~member_present, axis=1)
+        if not assay.allow_negative:
+            ok &= np.all((values[:, indices] >= 0) | ~member_present, axis=1)
+        if len(indices) == 1:
+            aligned[ok, target] = values[ok, indices[0]]
+        else:
+            duplicate_count_groups += int(np.any(count_per_sample > 1))
+            summed = np.sum(np.where(member_present, values[:, indices], 0.0), axis=1)
+            aligned[ok, target] = summed[ok]
+        valid[ok, target] = True
+    mapped = np.asarray([r["target_index"] >= 0 for r in rows])
+    ambiguous = np.asarray([r["status"] == "ambiguous_symbol" or "ambiguous" in r["status"] for r in rows])
+    blank = np.asarray([not r["source_id"] for r in rows])
+    mito = np.asarray([bool(r["mitochondrial"]) for r in rows])
+    ribo = np.asarray([bool(r["ribosomal"]) for r in rows])
+    metrics = []
+    for s, name in enumerate(assay.samples):
+        current = values[s, finite[s]]
+        absolute = np.where(finite[s], np.abs(values[s]), 0.0)
+        total_abs = float(np.sum(absolute))
+        rec = {"sample_id": name, "accession": assay.accession, "assay_id": assay.assay_id,
+               "units": assay.units, "source_features_present": int(np.sum(present[s])),
+               "source_values_finite": len(current), "source_values_nonfinite": int(np.sum(present[s] & ~finite[s])),
+               "source_values_negative": int(np.sum(current < 0)),
+               "source_values_fractional": int(np.sum(current != np.trunc(current))),
+               "source_values_zero": int(np.sum(current == 0)),
+               "source_values_positive": int(np.sum(current > 0)),
+               "source_min": float(np.min(current)) if len(current) else np.nan,
+               "source_max": float(np.max(current)) if len(current) else np.nan,
+               "source_median": float(np.median(current)) if len(current) else np.nan,
+               "source_sum_in_original_units": float(np.sum(current)),
+               "source_absolute_mass": total_abs,
+               "unmapped_absolute_mass": float(np.sum(absolute[~mapped])),
+               "unmapped_absolute_mass_fraction": _fraction(np.sum(absolute[~mapped]), total_abs),
+               "ambiguous_absolute_mass_fraction": _fraction(np.sum(absolute[ambiguous]), total_abs),
+               "blank_id_absolute_mass_fraction": _fraction(np.sum(absolute[blank]), total_abs),
+               "duplicate_quarantined_absolute_mass_fraction": _fraction(np.sum(absolute[duplicate_quarantine]), total_abs),
+               "canonical_features_present": int(np.sum(target_present[s])),
+               "canonical_values_valid": int(np.sum(valid[s])),
+               "canonical_features_absent": int(np.sum(~target_present[s])),
+               "canonical_present_but_quarantined": int(np.sum(target_present[s] & ~valid[s])),
+               "source_mitochondrial_features_present": int(np.sum(present[s] & mito)),
+               "source_ribosomal_features_present": int(np.sum(present[s] & ribo)),
+               "raw_count_eligible": raw_eligible,
+               "numeric_validation_pass": bool(not np.any(present[s] & ~finite[s]) and (assay.allow_negative or not np.any(current < 0)))}
+        if assay.sample_metadata:
+            for key, value in assay.sample_metadata[s].items():
+                rec["source_" + key] = json.dumps(value, ensure_ascii=False) if isinstance(value, (list, dict)) else value
+        metrics.append(rec)
+    pd.DataFrame(metrics).to_csv(output / "sample_metrics.csv", index=False)
+    feature_metrics = []
+    for j, row in enumerate(rows):
+        feature = values[finite[:, j], j]
+        feature_metrics.append({"source_index": j, "source_id": row["source_id"],
+                                "source_symbol": row["source_symbol"], "status": row["status"],
+                                "target_index": row["target_index"], "samples_feature_present": int(present[:, j].sum()),
+                                "finite_values": len(feature), "nonfinite_values": int(np.sum(present[:, j] & ~finite[:, j])),
+                                "positive_values": int(np.sum(feature > 0)), "zero_values": int(np.sum(feature == 0)),
+                                "negative_values": int(np.sum(feature < 0)),
+                                "fractional_values": int(np.sum(feature != np.trunc(feature))),
+                                "absolute_mass_across_samples": float(np.sum(np.abs(feature))),
+                                "duplicate_target_quarantined": bool(duplicate_quarantine[j])})
+    pd.DataFrame(feature_metrics).to_csv(output / "source_gene_metrics.csv", index=False)
+    canon = pd.DataFrame(mapper.canonical).copy()
+    canon.index = pd.Index(canon["gene_id"].astype(str), name="canonical_gene_id")
+    for column in canon.columns:
+        if canon[column].dtype == object:
+            canon[column] = canon[column].astype(str)
+    canon["samples_source_feature_present"] = target_present.sum(axis=0)
+    canon["samples_harmonization_valid"] = valid.sum(axis=0)
+    canon["source_rows_targeted"] = [len(groups.get(j, [])) for j in range(g)]
+    canon.to_csv(output / "canonical_gene_metrics.csv", index=False)
+    obs = pd.DataFrame(metrics).set_index("sample_id")
+    for column in obs.columns:
+        if obs[column].dtype == object:
+            obs[column] = obs[column].fillna("").astype(str)
+    organized = ad.AnnData(X=aligned, obs=obs, var=canon)
+    organized.layers["source_feature_present"] = target_present
+    organized.layers["harmonization_valid"] = valid
+    organized.uns["units"] = assay.units
+    organized.uns["expression_transform"] = "none;float64_representation;NaN_for_missing_or_quarantined"
+    organized.uns["presence_mask_semantics"] = "source_feature_table_membership_not_assay_coverage_or_nonzero_detection"
+    organized.uns["raw_count_eligible"] = raw_eligible
+    organized.uns["canonical_identity_sha256"] = mapper.manifest.get("canonical_identity_sha256", "fixture")
+    organized.uns["duplicate_policy"] = "sum_only_if_entire_assay_verified_finite_nonnegative_integer_declared_counts;otherwise_quarantine"
+    organized.uns["donor_pair_validation"] = "external_manifest_required;not_inferred_by_bulk_file_organization"
+    organized.uns["caveats_json"] = json.dumps(assay.caveats, ensure_ascii=False)
+    organized.write_h5ad(output / "harmonized.h5ad", compression="gzip")
+    sources = [{"path": str(p), "bytes": p.stat().st_size, "sha256": sha256(p)} for p in assay.sources]
+    status = "organized_with_explicit_masks"
+    if invalid or (negative and not assay.allow_negative):
+        status = "organized_with_numeric_quarantine"
+    if assay.declared_raw_counts and not raw_eligible:
+        status = "organized_declared_count_semantics_failed"
+    report = {"schema": "bulk_file_organization_v1", "assay_id": assay.assay_id,
+              "accession": assay.accession, "units": assay.units, "raw_count_eligible": raw_eligible,
+              "n_genes": len(assay.ids), "n_samples": len(assay.samples),
+              "canonical_genes": g, "canonical_coverage": len(groups) / g if g else 0,
+              "canonical_coverage_valid_min": float(np.min(valid.sum(axis=1)) / g) if g else 0,
+              "canonical_coverage_valid_max": float(np.max(valid.sum(axis=1)) / g) if g else 0,
+              "harmonized_path": str(output / "harmonized.h5ad"), "status": status,
+              "caveats": assay.caveats, "n_values_present": int(selected.size),
+              "nonfinite_values": invalid, "negative_values": negative, "fractional_values": fractional,
+              "integer_fraction_of_finite_values": 1 - fractional / len(finite_values) if len(finite_values) else None,
+              "duplicate_target_groups_summed_counts": duplicate_count_groups,
+              "duplicate_source_rows_quarantined": int(duplicate_quarantine.sum()),
+              "source_gene_mapping_summary": mapper.summarize(rows), "sources": sources,
+              "missing_value_policy": "NaN plus source_feature_present and harmonization_valid boolean layers",
+              "analysis_scope": "file_format_numeric_integrity_gene_identity_organization_only",
+              "pairing_status": "not_determined_by_this_module", "extra": assay.extra}
+    write_json(output / "REPORT.json", report)
+    return report
+
+
+def parse_simple(root: Path, accession: str) -> list[BulkInput]:
+    if accession == "GSE152418":
+        path = raw_file(root, accession, "*RawCounts.txt.gz")
+        frame = load_table(path)
+        return [BulkInput(accession, accession + "_counts", "raw_gene_counts", frame.iloc[:, 0].astype(str).tolist(),
+                          frame.columns[1:].tolist(), numeric_values(frame.iloc[:, 1:]), declared_raw_counts=True, sources=[path])]
+    if accession == "GSE198533":
+        path = raw_file(root, accession, "*Raw_gene_counts_matrix.csv.gz")
+        frame = load_table(path, sep=",")
+        result = []
+        for suffix, unit, raw in [("_count", "raw_gene_counts", True), ("_fpkm", "FPKM", False)]:
+            columns = [c for c in frame.columns if c.endswith(suffix)]
+            result.append(BulkInput(accession, accession + suffix, unit, frame.iloc[:, 0].astype(str).tolist(),
+                                    [c.removesuffix(suffix) for c in columns], numeric_values(frame[columns]),
+                                    declared_raw_counts=raw, sources=[path], caveats=["Condition/age/sex similarities do not establish donor pairing."]))
+        return result
+    if accession == "GSE162632":
+        result = []
+        for kind in ["bulk", "time_course"]:
+            path = raw_file(root, accession, f"{accession}_{kind}_PBMCs.*ScaledTPM.txt.gz")
+            samples, frame = load_space_header_matrix(path)
+            result.append(BulkInput(accession, accession + "_" + kind + "_ScaledTPM", "kallisto_gene_level_ScaledTPM",
+                                    frame.iloc[:, 0].astype(str).tolist(), samples, numeric_values(frame.iloc[:, 1:]), sources=[path],
+                                    caveats=["ScaledTPM is retained in its deposited units; not converted to counts.",
+                                             "Main and time-course arms remain separate."]))
+        return result
+    if accession == "GSE132044":
+        path = raw_file(root, accession, "*TPM_bulk.tsv.gz")
+        frame = load_table(path)
+        ids, symbols = [], []
+        for token in frame.iloc[:, 0].astype(str):
+            match = re.fullmatch(r"(ENSG\d{11}(?:\.\d+)?)_(.+)", token)
+            if not match:
+                raise ValueError(f"Unexpected Ding composite feature identity: {token}")
+            ids.append(match[1]); symbols.append(match[2])
+        samples = ["PBMC1", "PBMC2"]
+        return [BulkInput(accession, accession + "_PBMC_TPM", "TPM", ids, samples, numeric_values(frame[samples]), symbols=symbols,
+                          sources=[path], caveats=["HEK293 mixtures omitted from the PBMC assay; PBMC1/PBMC2 are source labels, not independently verified donor identities."])]
+    if accession == "GSE246525":
+        path = raw_file(root, accession, "*raw_counts.csv.gz")
+        frame = load_table(path, sep=",")
+        return [BulkInput(accession, accession + "_kallisto_values", "kallisto_estimated_counts",
+                          frame.iloc[:, 0].astype(str).tolist(), frame.columns[1:].tolist(), numeric_values(frame.iloc[:, 1:]), sources=[path],
+                          caveats=["kallisto 0.46.1 estimated counts preserve fractional assignments; strict integer-read-count eligibility is false.",
+                                   "Blank gene-ID rows are retained in source metrics and excluded from canonical expression.",
+                                   "Generic sample labels require an external metadata crosswalk; bulk material is whole blood."])]
+    if accession == "GSE252990":
+        result = []
+        for kind, unit in [("count", "kallisto_estimated_counts"), ("tpm", "TPM")]:
+            path = raw_file(root, accession, f"*_{kind}_matrix.csv.gz")
+            frame = load_table(path, sep=",")
+            result.append(BulkInput(accession, accession + "_" + kind, unit, frame.iloc[:, 0].astype(str).tolist(),
+                                    frame.columns[1:].tolist(), numeric_values(frame.iloc[:, 1:]), sources=[path],
+                                    caveats=["Whole-blood versus PBMC material descriptions conflict; pairing/material review is separate.",
+                                             "kallisto 0.43.0 count output via sleuth_to_matrix is retained as fractional estimated counts; TPM remains separate."]))
+        return result
+    if accession == "GSE161711":
+        path = raw_file(root, accession, "*log2CPM_counts.txt.gz")
+        frame = load_table(path)
+        samples = [c for c in frame.columns[9:] if c.endswith("_PB_CD19")]
+        if not samples:
+            raise ValueError("No explicitly PB_CD19-labeled CLL columns")
+        return [BulkInput(accession, accession + "_PB_CD19_log2CPM", "log2CPM", frame.gene_id.astype(str).tolist(), samples,
+                          numeric_values(frame[samples]), symbols=frame.gene_name.astype(str).tolist(), allow_negative=True, sources=[path],
+                          caveats=["Sorted CD19-positive peripheral-blood cells, not whole PBMC bulk.",
+                                   "Lymph-node and mixed-cell columns omitted; negative log2CPM values are valid and remain unchanged."],
+                          extra={"omitted_non_PB_CD19_columns": [c for c in frame.columns[9:] if c not in samples]})]
+    raise ValueError(f"No simple parser for {accession}")
+
+
+def parse_star_file(path: Path) -> tuple[str, list[str], None, np.ndarray, dict]:
+    frame = load_table(path, header=None)
+    if frame.shape[1] != 4:
+        raise ValueError(f"STAR ReadsPerGene must have exactly four columns: {path}")
+    ids = frame.iloc[:, 0].astype(str)
+    counts = frame.iloc[:, 1:].apply(pd.to_numeric, errors="raise").to_numpy(dtype=np.float64)
+    meta_rows = ids.str.startswith("N_").to_numpy()
+    if not {"N_unmapped", "N_multimapping", "N_noFeature", "N_ambiguous"}.issubset(set(ids[meta_rows])):
+        raise ValueError(f"Missing STAR summary rows: {path}")
+    gene_counts = counts[~meta_rows]
+    totals = np.sum(gene_counts, axis=0)
+    sample, gsm = sample_file_label(path, "_ReadsPerGene.out.tab")
+    names = ["unstranded", "forward", "reverse"]
+    meta = {"GSM": gsm, "file": str(path), "selected_STAR_column_one_based": 3,
+            "strand_selection": "forward;retained_alternatives_in_original_ReadsPerGene_file",
+            "gene_counts_total_unstranded": float(totals[0]),
+            "gene_counts_total_forward": float(totals[1]),
+            "gene_counts_total_reverse": float(totals[2]),
+            "forward_fraction_of_stranded_assigned_counts": _fraction(totals[1], totals[1] + totals[2]),
+            "strand_selection_requires_review": bool(totals[1] + totals[2] == 0 or totals[1] / (totals[1] + totals[2]) < 0.8)}
+    for gid, row in zip(ids[meta_rows], counts[meta_rows]):
+        for name, count in zip(names, row):
+            meta[f"STAR_{gid}_{name}"] = float(count)
+    return sample, ids[~meta_rows].tolist(), None, gene_counts[:, 1], meta
+
+
+def parse_star(runroot: Path) -> BulkInput:
+    accession = "GSE314922"
+    paths = extracted_files(runroot, accession, lambda n: n.removesuffix(".gz").endswith("_ReadsPerGene.out.tab"))
+    return from_assembled(accession, accession + "_STAR_forward_counts", "STAR_forward_raw_gene_counts",
+                          (parse_star_file(path) for path in paths), declared_raw_counts=True, sources=paths,
+                          caveats=["STAR column 3 (one based; first-read strand aligned with RNA) selected; unstranded and reverse columns are never summed.",
+                                   "Tecan Universal Plus mRNA-Seq with NuQuant protocol is recorded in GEO. Per-sample forward fractions below 0.8 trigger review flags, not data correction.",
+                                   "Original genotype VCF files remain outside expression matrices."],
+                          extra={"source_format": "STAR_ReadsPerGene_4_columns", "strand_review_threshold": 0.8})
+
+
+def parse_two_column(path: Path) -> tuple[str, list[str], None, np.ndarray, dict]:
+    frame = load_table(path, header=None)
+    if frame.shape[1] != 2:
+        raise ValueError(f"Expected exactly two columns in Asan bulk file: {path}")
+    sample, gsm = sample_file_label(path, ".txt")
+    return sample, frame.iloc[:, 0].astype(str).tolist(), None, pd.to_numeric(frame.iloc[:, 1], errors="raise").to_numpy(dtype=np.float64), {"GSM": gsm, "file": str(path)}
+
+
+def parse_asan(runroot: Path) -> BulkInput:
+    accession = "GSE201533"
+    paths = extracted_files(runroot, accession, lambda n: n.removesuffix(".gz").endswith(".txt"))
+    return from_assembled(accession, accession + "_counts", "raw_gene_counts", (parse_two_column(path) for path in paths),
+                          declared_raw_counts=True, sources=paths,
+                          caveats=["Exact source symbol union/reordering; absent features have per-sample masks.",
+                                   "Bulk-to-single-cell donor identities are not inferred from cohort, condition, or timepoint labels."])
+
+
+def parse_featurecounts_group(gsm: str, paths: list[Path]) -> tuple:
+    lanes = []
+    first_ids = first_symbols = total = None
+    for path in paths:
+        lane_match = re.search(r"_L(\d{3})_", path.name)
+        if lane_match is None:
+            raise ValueError(f"Cannot verify technical lane identity: {path}")
+        lane = lane_match[1]
+        if lane in lanes:
+            raise ValueError(f"Multiple files for the same GSM/lane, refusing duplicate sum: {gsm}/L{lane}")
+        lanes.append(lane)
+        validate_featurecounts_header(path)
+        frame = load_table(path, comment="#")
+        if frame.shape[1] != 8:
+            raise ValueError(f"Not the expected gene-level featureCounts table: {path}")
+        if not frame.Geneid.astype(str).is_unique:
+            raise ValueError(f"Duplicate gene IDs within a featureCounts lane: {path}")
+        ids = frame.Geneid.astype(str).tolist()
+        symbols = frame.gene_name.astype(str).tolist()
+        counts = pd.to_numeric(frame.iloc[:, -1], errors="raise").to_numpy(dtype=np.float64)
+        if np.any(~np.isfinite(counts)) or np.any(counts < 0) or np.any(counts != np.trunc(counts)):
+            raise ValueError(f"Lane sum requires verified nonnegative integer counts: {path}")
+        if first_ids is None:
+            first_ids, first_symbols, total = ids, symbols, counts.copy()
+        else:
+            if set(ids) != set(first_ids):
+                raise ValueError(f"Lane feature sets differ for {gsm}; partial-lane sums are refused")
+            index = {gid: i for i, gid in enumerate(ids)}
+            order = [index[gid] for gid in first_ids]
+            if [symbols[i] for i in order] != first_symbols:
+                raise ValueError(f"Lane gene symbols conflict for {gsm}")
+            total += counts[order]
+    return gsm, first_ids, first_symbols, total, {"GSM": gsm, "lane_ids": lanes,
+                                                  "lane_files": [str(p) for p in paths], "technical_lane_count": len(paths),
+                                                  "lane_sum_basis": "same_GSM_distinct_explicit_lane_IDs_exact_gene_set_and_symbol_match"}
+
+
+def parse_featurecounts(runroot: Path) -> BulkInput:
+    accession = "GSE161777"
+    paths = extracted_files(runroot, accession, lambda n: n.removesuffix(".gz").endswith("_gene.featureCounts.txt"))
+    grouped: dict[str, list[Path]] = defaultdict(list)
+    for path in paths:
+        gsm = re.match(r"^(GSM\d+)_", path.name)
+        if not gsm:
+            raise ValueError(f"No explicit GSM prefix in featureCounts source: {path}")
+        grouped[gsm[1]].append(path)
+    return from_assembled(accession, accession + "_lane_summed_featureCounts", "featureCounts_raw_gene_counts",
+                          (parse_featurecounts_group(gsm, group) for gsm, group in sorted(grouped.items())),
+                          declared_raw_counts=True, sources=paths,
+                          caveats=["Whole-blood bulk, not PBMC bulk. BCR clonotype files are excluded.",
+                                   "Only distinct explicitly labeled technical lanes within one GSM are added after exact gene identity alignment."])
+
+
+def read_platform_assignments(path: Path) -> dict[str, dict]:
+    """Use only the deposited GPL table; never infer symbols from probe IDs."""
+    with opener(path) as handle:
+        for line in handle:
+            if line.startswith("!platform_table_begin"):
+                break
+        else:
+            return {}
+        header = handle.readline().rstrip("\r\n").split("\t")
+        if "ID" not in header or "gene_assignment" not in header:
+            return {}
+        assignments = {}
+        for line in handle:
+            if line.startswith("!platform_table_end"):
+                break
+            row = dict(zip(header, line.rstrip("\r\n").split("\t")))
+            original = row.get("gene_assignment", "")
+            symbols = set()
+            for assignment in original.split(" /// "):
+                fields = assignment.split(" // ")
+                if len(fields) >= 2 and fields[1].strip() not in {"", "---"}:
+                    symbols.add(fields[1].strip())
+            assignments[row["ID"]] = {"platform": "GPL6244", "gene_assignment": original,
+                                       "candidate_symbols": sorted(symbols),
+                                       "symbol": next(iter(symbols)) if len(symbols) == 1 else "",
+                                       "mapping_blocker": "platform_ambiguous_symbols" if len(symbols) > 1 else ("platform_unassigned_probe" if not symbols else "")}
+        return assignments
+
+
+def parse_series_matrix(path: Path) -> pd.DataFrame:
+    # Read only the table, retaining its exact numeric values and source IDs.
+    with opener(path) as handle:
+        for line in handle:
+            if line.startswith("!series_matrix_table_begin"):
+                break
+        else:
+            raise ValueError(f"No GEO series matrix table: {path}")
+        header_line = handle.readline()
+        validate_original_header(next(csv.reader([header_line], delimiter="\t")), str(path))
+        lines = [header_line]
+        for line in handle:
+            if line.startswith("!series_matrix_table_end"):
+                break
+            lines.append(line)
+        else:
+            raise ValueError(f"Unclosed GEO series matrix table: {path}")
+    return pd.read_csv(io.StringIO("".join(lines)), sep="\t", keep_default_na=False)
+
+
+def parse_microarray(root: Path) -> BulkInput:
+    accession = "GSE47353"
+    directory = root / "datasets" / accession / "metadata"
+    paths = sorted(directory.glob("*series_matrix*.txt.gz"))
+    if len(paths) != 1:
+        raise ValueError("Expected one GSE47353 series matrix")
+    platform_path = directory / f"{accession}_family.soft.gz"
+    assignments = read_platform_assignments(platform_path)
+    frame = parse_series_matrix(paths[0])
+    ids = frame.iloc[:, 0].astype(str).tolist()
+    annotation = [assignments.get(gid, {"platform": "GPL6244", "mapping_blocker": "platform_missing_probe_annotation", "symbol": ""}) for gid in ids]
+    return BulkInput(accession, accession + "_GPL6244_RMA_microarray", "RMA_normalized_microarray_log_intensity",
+                     ids, frame.columns[1:].tolist(), numeric_values(frame.iloc[:, 1:]),
+                     symbols=[a["symbol"] for a in annotation], feature_metadata=annotation,
+                     allow_negative=True, sources=paths + [platform_path],
+                     caveats=["Microarray RMA/log intensity, not RNA-seq counts; units unchanged.",
+                              "Only source probes with one unique GPL gene-assignment symbol may map.",
+                              "Multiple normalized probes targeting one model gene are quarantined, not averaged or summed."])
+
+
+def run_bulk(root: Path, runroot: Path) -> list[dict]:
+    """Run serially inside the root CPU service; return one record per assay."""
+    root, runroot = Path(root), Path(runroot)
+    mapper = GeneMapper(runroot / "reference")
+    results = []
+    accessions = ["GSE152418", "GSE198533", "GSE314922", "GSE162632", "GSE132044", "GSE201533",
+                  "GSE246525", "GSE252990", "GSE161711", "GSE161777", "GSE47353", "GSE247706"]
+    for accession in accessions:
+        if accession == "GSE247706":
+            result = {"accession": accession, "assay_id": accession + "_bulk_expression_unavailable",
+                      "status": "missing_bulk_expression_VCF_only", "units": "not_applicable", "raw_count_eligible": False,
+                      "n_genes": 0, "n_samples": 0, "canonical_coverage": 0, "harmonized_path": "",
+                      "caveats": ["Downloaded bulk supplementary archive contains genotype VCFs, not an expression matrix."]}
+            write_json(runroot / "bulk" / result["assay_id"] / "REPORT.json", result)
+            results.append(result)
+            continue
+        try:
+            if accession == "GSE314922":
+                assays = [parse_star(runroot)]
+            elif accession == "GSE201533":
+                assays = [parse_asan(runroot)]
+            elif accession == "GSE161777":
+                assays = [parse_featurecounts(runroot)]
+            elif accession == "GSE47353":
+                assays = [parse_microarray(root)]
+            else:
+                assays = parse_simple(root, accession)
+            for assay in assays:
+                try:
+                    results.append(harmonize(assay, mapper, runroot / "bulk" / assay.assay_id))
+                except Exception as error:
+                    result = {"accession": accession, "assay_id": assay.assay_id, "units": assay.units,
+                              "status": "failed_harmonization", "raw_count_eligible": False,
+                              "error_type": type(error).__name__, "error": str(error), "harmonized_path": "",
+                              "caveats": ["Partial output directory may exist; REPORT failure status is authoritative."]}
+                    write_json(runroot / "bulk" / assay.assay_id / "REPORT.json", result)
+                    results.append(result)
+            del assays
+        except Exception as error:
+            result = {"accession": accession, "assay_id": accession + "_parse_failure", "status": "failed_source_parse",
+                      "units": "unresolved", "raw_count_eligible": False, "error_type": type(error).__name__,
+                      "error": str(error), "harmonized_path": "", "caveats": ["Source files remain unchanged."]}
+            write_json(runroot / "bulk" / result["assay_id"] / "REPORT.json", result)
+            results.append(result)
+        write_json(runroot / "bulk" / "BULK_ORGANIZATION_STATUS.json", {"results_so_far": results, "last_accession": accession})
+    write_json(runroot / "bulk" / "BULK_ORGANIZATION_SUMMARY.json", results)
+    return results

paper-releases/20260928/diffusion/data/source_prep/giroux2022/code/strict_qc_v1_code_bundle_v5/qc_core.py

@@ -0,0 +1,650 @@
+"""Strict, disk-backed expression auditing. No input is modified or filtered.
+
+Public scanners return JSON dictionaries and persist NPY metrics/flags. MTX input
+is features x cells. H5AD is cells x features and 10x H5 is features x cells.
+Duplicate coordinates are rejected, including unsorted input: a disk-backed
+uint64 coordinate key vector is sorted in place (quicksort, O(log n) scratch).
+Integral numeric values are evidence about representation, NEVER proof of raw
+counts. Callers must establish count provenance before any aggregation.
+"""
+
+from __future__ import annotations
+
+import csv
+import gzip
+import hashlib
+import json
+import os
+from pathlib import Path, PurePosixPath
+import shutil
+import stat
+import tarfile
+import tempfile
+from typing import Iterable, Sequence
+import zipfile
+
+import numpy as np
+
+
+class QCError(ValueError):
+    """Input failed a structural or safety requirement."""
+
+
+def sha256_file(path: str | Path, chunk_bytes: int = 4 * 1024**2) -> str:
+    digest = hashlib.sha256()
+    with open(path, "rb") as handle:
+        for chunk in iter(lambda: handle.read(chunk_bytes), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _write_json(path: Path, value: dict) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    fd, temporary = tempfile.mkstemp(prefix=path.name + ".", suffix=".partial", dir=path.parent)
+    try:
+        with os.fdopen(fd, "w") as handle:
+            json.dump(value, handle, indent=2, allow_nan=False)
+            handle.write("\n")
+            handle.flush()
+            os.fsync(handle.fileno())
+        os.replace(temporary, path)
+    finally:
+        if os.path.exists(temporary):
+            os.unlink(temporary)
+
+
+def _safe_member(name: str) -> str:
+    if not name or "\\" in name or "\x00" in name:
+        raise QCError(f"Unsafe archive member: {name!r}")
+    path = PurePosixPath(name)
+    if path.is_absolute() or ".." in path.parts or any(":" in p for p in path.parts):
+        raise QCError(f"Unsafe archive member: {name!r}")
+    normalized = str(path)
+    if normalized in ("", "."):
+        raise QCError(f"Empty archive member: {name!r}")
+    return normalized
+
+
+def inventory_archive(path: str | Path) -> list[dict]:
+    """Inspect zip/tar without extracting; reject links, special files and collisions."""
+    path = Path(path)
+    members: list[dict] = []
+    if zipfile.is_zipfile(path):
+        with zipfile.ZipFile(path) as archive:
+            for item in archive.infolist():
+                name = _safe_member(item.filename)
+                mode = item.external_attr >> 16
+                kind = stat.S_IFMT(mode)
+                if kind not in (0, stat.S_IFREG, stat.S_IFDIR) or item.flag_bits & 1:
+                    raise QCError(f"Unsupported zip member: {item.filename}")
+                members.append({"name": name, "size": item.file_size, "directory": item.is_dir()})
+    elif tarfile.is_tarfile(path):
+        with tarfile.open(path, "r:*") as archive:
+            for item in archive:
+                if item.name in (".", "./") and item.isdir():
+                    continue
+                name = _safe_member(item.name)
+                if not (item.isfile() or item.isdir()) or getattr(item, "sparse", None):
+                    raise QCError(f"Unsupported tar member: {item.name}")
+                members.append({"name": name, "size": item.size, "directory": item.isdir()})
+    else:
+        raise QCError(f"Unsupported archive format: {path}")
+    seen: dict[str, bool] = {}
+    for member in members:
+        name = member["name"]
+        if name in seen:
+            raise QCError(f"Duplicate archive path: {name}")
+        if member["size"] < 0:
+            raise QCError(f"Negative member size: {name}")
+        seen[name] = member["directory"]
+    for name in seen:
+        for parent in PurePosixPath(name).parents:
+            if str(parent) in seen and not seen[str(parent)]:
+                raise QCError(f"Archive file/directory collision: {name}")
+    return members
+
+
+def _safe_destination(root: Path, relative: str) -> Path:
+    destination = root / relative
+    for component in (destination, *destination.parents):
+        if component == root.parent:
+            break
+        if component.is_symlink():
+            raise QCError(f"Extraction destination contains symlink: {component}")
+    if not destination.resolve().is_relative_to(root.resolve()):
+        raise QCError(f"Extraction escaped destination: {destination}")
+    return destination
+
+
+def extract_archive(
+    path: str | Path,
+    dest: str | Path,
+    receipt_path: str | Path | None = None,
+    disk_floor_bytes: int = 5 * 1024**3,
+) -> dict:
+    """Safely extract regular files; atomic members and SHA256-verified resume.
+
+    The receipt is rewritten atomically after every completed member. Existing
+    files without a matching receipt are compared to freshly streamed archive
+    bytes, then adopted only if identical. Source archives are preserved.
+    """
+    path, dest = Path(path), Path(dest)
+    if dest.is_symlink():
+        raise QCError("Extraction root must not be a symlink")
+    inventory = inventory_archive(path)
+    dest.mkdir(parents=True, exist_ok=True)
+    source_hash = sha256_file(path)
+    receipt_file = Path(receipt_path) if receipt_path else dest / ".extraction_receipt.json"
+    receipt = {"source": str(path.resolve()), "source_sha256": source_hash, "files": {}, "complete": False}
+    if receipt_file.exists():
+        previous = json.loads(receipt_file.read_text())
+        if previous.get("source_sha256") != source_hash:
+            raise QCError("Existing extraction receipt belongs to a different archive")
+        receipt = previous
+        receipt["complete"] = False
+    required = sum(item["size"] for item in inventory if not item["directory"] and not (dest / item["name"]).exists())
+    if shutil.disk_usage(dest).free < required + disk_floor_bytes:
+        raise QCError(f"Insufficient disk headroom: need {required + disk_floor_bytes} bytes")
+    zipped = zipfile.is_zipfile(path)
+    archive = zipfile.ZipFile(path) if zipped else tarfile.open(path, "r:*")
+    try:
+        lookup = {(_safe_member(m.filename) if zipped else _safe_member(m.name)): m
+                  for m in (archive.infolist() if zipped else archive.getmembers())
+                  if (m.filename if zipped else m.name) not in (".", "./")}
+        for item in inventory:
+            destination = _safe_destination(dest, item["name"])
+            if item["directory"]:
+                destination.mkdir(parents=True, exist_ok=True)
+                continue
+            destination.parent.mkdir(parents=True, exist_ok=True)
+            old = receipt["files"].get(item["name"])
+            if old and destination.is_file() and destination.stat().st_size == item["size"]:
+                if old.get("size") == item["size"] and sha256_file(destination) == old.get("sha256"):
+                    continue
+                raise QCError(f"Previously extracted member has changed: {destination}")
+            if destination.exists() and not destination.is_file():
+                raise QCError(f"Non-file extraction target: {destination}")
+            if shutil.disk_usage(dest).free < item["size"] + disk_floor_bytes:
+                raise QCError("Disk floor reached before extraction")
+            fd, temporary = tempfile.mkstemp(prefix=destination.name + ".", suffix=".partial", dir=destination.parent)
+            digest, written = hashlib.sha256(), 0
+            try:
+                entry = lookup[item["name"]]
+                stream = archive.open(entry) if zipped else archive.extractfile(entry)
+                if stream is None:
+                    raise QCError(f"Unreadable archive member: {item['name']}")
+                with stream, os.fdopen(fd, "wb") as output:
+                    for chunk in iter(lambda: stream.read(4 * 1024**2), b""):
+                        written += len(chunk)
+                        if written > item["size"]:
+                            raise QCError(f"Member exceeds declared size: {item['name']}")
+                        if shutil.disk_usage(dest).free < len(chunk) + disk_floor_bytes:
+                            raise QCError("Disk floor reached during extraction")
+                        output.write(chunk)
+                        digest.update(chunk)
+                    output.flush()
+                    os.fsync(output.fileno())
+                if written != item["size"]:
+                    raise QCError(f"Truncated member: {item['name']}")
+                checksum = digest.hexdigest()
+                if destination.exists():
+                    if destination.stat().st_size != written or sha256_file(destination) != checksum:
+                        raise QCError(f"Existing extraction target differs: {destination}")
+                else:
+                    os.replace(temporary, destination)
+                receipt["files"][item["name"]] = {"size": written, "sha256": checksum}
+                _write_json(receipt_file, receipt)
+            finally:
+                if os.path.exists(temporary):
+                    os.unlink(temporary)
+    finally:
+        archive.close()
+    receipt["complete"] = True
+    receipt["member_count"] = len(inventory)
+    _write_json(receipt_file, receipt)
+    return receipt
+
+
+def _vector(value: Sequence | None, size: int, name: str, default: bool = False) -> np.ndarray:
+    if value is None:
+        return np.full(size, default, dtype=bool)
+    vector = np.asarray(value, dtype=bool)
+    if vector.shape != (size,):
+        raise QCError(f"{name} length mismatch: {vector.shape} vs {(size,)}")
+    return vector
+
+
+def _quantiles(values: np.ndarray) -> dict:
+    if not len(values):
+        return {"n": 0}
+    quantiles = np.quantile(values, [0, .01, .05, .25, .5, .75, .95, .99, 1])
+    return {"n": len(values), **{key: float(number) for key, number in zip(
+        ["min", "p01", "p05", "p25", "median", "p75", "p95", "p99", "max"], quantiles)}}
+
+
+class _Accumulator:
+    def __init__(self, out_dir: Path, n_features: int, n_cells: int, nnz: int,
+                 mito_mask: Sequence | None, feature_mask: Sequence | None,
+                 duplicate_policy: str = "reject", disk_floor_bytes: int = 1024**3):
+        if min(n_features, n_cells, nnz) < 0 or n_features == 0 or n_cells == 0:
+            raise QCError("Matrix dimensions must be positive; nnz must be nonnegative")
+        if n_features * n_cells > np.iinfo(np.uint64).max:
+            raise QCError("Matrix dimensions exceed supported coordinate-key range")
+        if duplicate_policy != "reject":
+            raise QCError("Only duplicate_policy='reject' is supported; duplicates require provenance-aware repair")
+        out_dir.mkdir(parents=True, exist_ok=True)
+        if (out_dir / "qc_summary.json").exists():
+            raise QCError(f"Refusing to overwrite an existing QC result: {out_dir}")
+        required = nnz * 8 + (n_features * 16) + (n_cells * 60)
+        if shutil.disk_usage(out_dir).free < required + disk_floor_bytes:
+            raise QCError(f"Insufficient disk for audit vectors: {required} bytes plus floor")
+        self.out, self.n_features, self.n_cells, self.nnz = out_dir, n_features, n_cells, nnz
+        self.selected = _vector(feature_mask, n_features, "feature_mask", default=True)
+        self.mito = _vector(mito_mask, n_features, "mito_mask") & self.selected
+        if not np.any(self.selected):
+            raise QCError("No expression features selected")
+        self.arrays: dict[str, np.ndarray] = {}
+        for name, size, dtype in [("cell_total", n_cells, "f8"), ("cell_detected", n_cells, "i8"),
+                                  ("cell_mito_total", n_cells, "f8"), ("gene_total", n_features, "f8"),
+                                  ("gene_detected", n_features, "i8")]:
+            array = np.lib.format.open_memmap(out_dir / (name + ".npy"), mode="w+", dtype=dtype, shape=(size,))
+            array[:] = 0
+            self.arrays[name] = array
+        self.keys_path = out_dir / ".coordinate_keys.uint64"
+        self.keys = np.memmap(self.keys_path, mode="w+", dtype="u8", shape=(nnz,)) if nnz else None
+        self.offset = self.nonzero = self.selected_nonzero = self.integer_values = self.selected_integer_values = 0
+        self.stored_zero = self.selected_stored = 0
+        self.minimum, self.maximum = float("inf"), float("-inf")
+
+    def add(self, features: np.ndarray, cells: np.ndarray, values: np.ndarray) -> None:
+        if not (len(features) == len(cells) == len(values)):
+            raise QCError("Sparse vector length mismatch")
+        if self.offset + len(values) > self.nnz:
+            raise QCError("More coordinates than declared nnz")
+        if np.any(features < 0) or np.any(features >= self.n_features) or np.any(cells < 0) or np.any(cells >= self.n_cells):
+            raise QCError("Sparse coordinate out of bounds")
+        if not np.all(np.isfinite(values)):
+            raise QCError("Nonfinite expression value")
+        if np.any(values < 0):
+            raise QCError("Negative expression value; assay/layer is not nonnegative abundance")
+        if self.keys is not None:
+            self.keys[self.offset:self.offset + len(values)] = cells.astype("u8") * self.n_features + features.astype("u8")
+        self.offset += len(values)
+        self.stored_zero += int(np.count_nonzero(values == 0))
+        self.nonzero += int(np.count_nonzero(values))
+        integral = np.equal(values, np.floor(values))
+        self.integer_values += int(np.count_nonzero(integral))
+        if len(values):
+            self.minimum = min(self.minimum, float(values.min()))
+            self.maximum = max(self.maximum, float(values.max()))
+        keep = self.selected[features]
+        self.selected_stored += int(keep.sum())
+        self.selected_integer_values += int(np.count_nonzero(integral & keep))
+        genes, columns, expression = features[keep], cells[keep], values[keep]
+        positive = expression > 0
+        self.selected_nonzero += int(positive.sum())
+        np.add.at(self.arrays["cell_total"], columns, expression)
+        np.add.at(self.arrays["gene_total"], genes, expression)
+        np.add.at(self.arrays["cell_detected"], columns[positive], 1)
+        np.add.at(self.arrays["gene_detected"], genes[positive], 1)
+        mitochondrial = self.mito[genes]
+        np.add.at(self.arrays["cell_mito_total"], columns[mitochondrial], expression[mitochondrial])
+
+    def finish(self, metadata: dict, sample_ids: Sequence | None = None,
+               feature_ids: Sequence | None = None, feature_symbols: Sequence | None = None,
+               cell_ids: Sequence | None = None) -> dict:
+        for ids, expected, kind in ((feature_ids, self.n_features, "feature_ids"),
+                                    (feature_symbols, self.n_features, "feature_symbols"),
+                                    (cell_ids, self.n_cells, "cell_ids")):
+            if ids is not None and len(ids) != expected:
+                raise QCError(f"{kind} length mismatch")
+        if cell_ids is not None:
+            labels = np.asarray(cell_ids, dtype=str)
+            if np.any(np.char.strip(labels) == "") or len(np.unique(labels)) != len(labels):
+                raise QCError("Empty or duplicate cell_ids within matrix/library")
+        if self.offset != self.nnz:
+            raise QCError(f"Truncated matrix: observed {self.offset}, declared {self.nnz} coordinates")
+        if self.keys is not None:
+            self.keys.flush()
+            self.keys.sort(kind="quicksort")
+            previous = None
+            for start in range(0, self.nnz, 250_000):
+                part = self.keys[start:start + 250_000]
+                if (previous is not None and part[0] == previous) or np.any(part[1:] == part[:-1]):
+                    raise QCError("Duplicate sparse coordinates; matrix quarantined (no automatic summation)")
+                previous = part[-1]
+            del self.keys
+            self.keys = None
+            self.keys_path.unlink()
+        for array in self.arrays.values():
+            if not np.all(np.isfinite(array)):
+                raise QCError("Nonfinite accumulated metrics (numeric overflow)")
+            array.flush()
+        total, detected = self.arrays["cell_total"], self.arrays["cell_detected"]
+        mito_percent = np.divide(self.arrays["cell_mito_total"] * 100, total,
+                                 out=np.zeros(self.n_cells), where=total > 0)
+        np.save(self.out / "cell_mito_percent.npy", mito_percent)
+        flags = {"zero_total": total == 0, "low_genes_200": detected < 200,
+                 "low_abundance_500": total < 500, "mito_above_20pct": mito_percent > 20}
+        if sample_ids is None:
+            sample_ids = np.full(self.n_cells, "__matrix__", dtype=object)
+            sample_scope = "whole matrix; donor/sample IDs unavailable"
+        else:
+            sample_ids = np.asarray(sample_ids, dtype=str)
+            if sample_ids.shape != (self.n_cells,):
+                raise QCError("sample_ids length mismatch")
+            sample_scope = "caller-provided sample IDs"
+        sample_summaries = []
+        for name in ["low_total_mad", "low_genes_mad", "high_mito_mad", "high_total_review_only"]:
+            flags[name] = np.zeros(self.n_cells, dtype=bool)
+        for sample in np.unique(sample_ids):
+            indices = np.flatnonzero(sample_ids == sample)
+            sample_info = {"sample_id": str(sample), "n_cells": len(indices), "mad_applied": len(indices) >= 20}
+            if len(indices) >= 20:
+                for name, vector, transform, direction in [
+                    ("low_total_mad", total, True, -1), ("low_genes_mad", detected, True, -1),
+                    ("high_mito_mad", mito_percent, False, 1), ("high_total_review_only", total, True, 1)]:
+                    values = np.log1p(vector[indices]) if transform else vector[indices]
+                    median = float(np.median(values))
+                    mad = float(np.median(np.abs(values - median)))
+                    # A zero MAD has no useful scale and must not flag every departure.
+                    cutoff = median + direction * 5 * 1.4826 * mad
+                    if mad > 0:
+                        flags[name][indices] = values < cutoff if direction < 0 else values > cutoff
+                    sample_info[name] = {"median": median, "mad": mad, "cutoff": cutoff, "enabled": mad > 0}
+            sample_summaries.append(sample_info)
+        flags["structural_nonempty"] = (total > 0) & (detected > 0)
+        flags["conservative_review_pass"] = ~(flags["low_genes_200"] | flags["low_abundance_500"] | flags["mito_above_20pct"])
+        for name, vector in flags.items():
+            np.save(self.out / ("flag_" + name + ".npy"), vector)
+        np.save(self.out / "feature_selected.npy", self.selected)
+        np.save(self.out / "feature_mito.npy", self.mito)
+        for values, size, name in [(feature_ids, self.n_features, "feature_ids"),
+                                    (feature_symbols, self.n_features, "feature_symbols"),
+                                    (cell_ids, self.n_cells, "cell_ids")]:
+            if values is not None:
+                if len(values) != size:
+                    raise QCError(f"{name} length mismatch")
+                with open(self.out / (name + ".tsv"), "w", newline="") as handle:
+                    writer = csv.writer(handle, delimiter="\t")
+                    writer.writerow(["index", name.rstrip("s")])
+                    writer.writerows(enumerate(str(value) for value in values))
+        summary = {"schema_version": "1.0", "structural_status": "PASS", "input": metadata,
+                   "orientation": "features_by_cells", "n_features": self.n_features, "n_cells": self.n_cells,
+                   "n_selected_features": int(self.selected.sum()), "n_mito_features": int(self.mito.sum()),
+                   "declared_stored_entries": self.nnz, "observed_stored_entries": self.offset,
+                   "explicit_zero_entries": self.stored_zero, "positive_entries": self.nonzero,
+                   "selected_positive_entries": self.selected_nonzero, "duplicate_coordinates": 0,
+                   "duplicates_policy": "reject; exact disk-backed coordinate sort",
+                   "numeric": {"minimum_stored": self.minimum if self.nnz else None,
+                               "maximum_stored": self.maximum if self.nnz else None,
+                               "integer_fraction_stored": self.integer_values / self.nnz if self.nnz else None,
+                               "integer_fraction_selected_stored": self.selected_integer_values / self.selected_stored if self.selected_stored else None,
+                               "raw_counts_proven": False,
+                               "interpretation": "Integer-valued entries do not establish raw-count provenance; normalized integer tables can exist."},
+                   "cell_total": _quantiles(total), "cell_detected": _quantiles(detected),
+                   "cell_mito_percent": _quantiles(mito_percent),
+                   "gene_total": _quantiles(self.arrays["gene_total"][self.selected]),
+                   "gene_detected": _quantiles(self.arrays["gene_detected"][self.selected]),
+                   "flag_counts": {name: int(vector.sum()) for name, vector in flags.items()},
+                   "sample_scope": sample_scope, "sample_summaries": sample_summaries,
+                   "outlier_mad_multiplier": 5, "mad_normal_consistency_factor": 1.4826,
+                   "warnings": ["Flags are review annotations, not irreversible filtering.",
+                                "High-count cells are review-only; immune activation can increase RNA content.",
+                                "Abundance 500 threshold is count-like and requires raw-count provenance.",
+                                "Mitochondrial percentage requires a validated feature mask; zero mask is not a biological zero."],
+                   "metrics_directory": str(self.out.resolve())}
+        _write_json(self.out / "qc_summary.json", summary)
+        return summary
+
+
+def _text_open(path: str | Path):
+    return gzip.open(path, "rt") if str(path).lower().endswith(".gz") else open(path, "rt")
+
+
+def scan_mtx(path: str | Path, out_dir: str | Path, *, mito_mask: Sequence | None = None,
+             feature_mask: Sequence | None = None, sample_ids: Sequence | None = None,
+             feature_ids: Sequence | None = None, feature_symbols: Sequence | None = None,
+             cell_ids: Sequence | None = None, duplicate_policy: str = "reject",
+             chunk_nnz: int = 250_000, disk_floor_bytes: int = 1024**3) -> dict:
+    """Stream general coordinate MTX (integer/real), validating every entry."""
+    if not 1 <= chunk_nnz <= 2_000_000:
+        raise QCError("chunk_nnz must be between 1 and 2000000")
+    with _text_open(path) as handle:
+        header = handle.readline().strip().split()
+        if len(header) != 5 or [part.lower() for part in header[:3]] != ["%%matrixmarket", "matrix", "coordinate"]:
+            raise QCError("Expected MatrixMarket coordinate matrix header")
+        field, symmetry = header[3].lower(), header[4].lower()
+        if field not in ("integer", "real") or symmetry != "general":
+            raise QCError(f"Unsupported MatrixMarket field/symmetry: {field}/{symmetry}")
+        dimensions = None
+        for line in handle:
+            if line.strip() and not line.lstrip().startswith("%"):
+                try:
+                    dimensions = tuple(int(value) for value in line.split())
+                except ValueError as error:
+                    raise QCError("Invalid MatrixMarket dimensions") from error
+                break
+        if dimensions is None or len(dimensions) != 3:
+            raise QCError("Missing or malformed MatrixMarket dimensions")
+        features, cells, nnz = dimensions
+        accumulator = _Accumulator(Path(out_dir), features, cells, nnz, mito_mask, feature_mask, duplicate_policy, disk_floor_bytes)
+        rows, columns, values = [], [], []
+        for line_number, line in enumerate(handle, start=1):
+            if not line.strip() or line.lstrip().startswith("%"):
+                continue
+            fields = line.split()
+            if len(fields) != 3:
+                raise QCError(f"Malformed coordinate line {line_number}: expected three fields")
+            try:
+                row, column = int(fields[0]), int(fields[1])
+                value = float(fields[2])
+                if field == "integer":
+                    integer = int(fields[2])
+                    if abs(integer) > 2**53:
+                        raise QCError("Integer exceeds exact float64 accumulation range")
+            except (ValueError, OverflowError) as error:
+                raise QCError(f"Invalid numeric field at coordinate line {line_number}") from error
+            rows.append(row - 1)
+            columns.append(column - 1)
+            values.append(value)
+            if len(values) >= chunk_nnz:
+                accumulator.add(np.asarray(rows, dtype="i8"), np.asarray(columns, dtype="i8"), np.asarray(values, dtype="f8"))
+                rows, columns, values = [], [], []
+        if values:
+            accumulator.add(np.asarray(rows, dtype="i8"), np.asarray(columns, dtype="i8"), np.asarray(values, dtype="f8"))
+        return accumulator.finish({"path": str(Path(path).resolve()), "format": "mtx", "field": field,
+                                   "sha256": sha256_file(path)}, sample_ids, feature_ids, feature_symbols, cell_ids)
+
+
+def _strings(dataset) -> np.ndarray:
+    array = np.asarray(dataset[...])
+    if array.ndim != 1:
+        raise QCError("Expected one-dimensional string metadata")
+    return np.asarray([value.decode("utf-8") if isinstance(value, bytes) else str(value) for value in array])
+
+
+def _h5_column(group, name: str) -> np.ndarray | None:
+    import h5py
+    if name not in group:
+        return None
+    column = group[name]
+    if isinstance(column, h5py.Dataset):
+        return _strings(column)
+    if "codes" in column and "categories" in column:
+        categories = _strings(column["categories"])
+        codes = np.asarray(column["codes"][...])
+        if not np.issubdtype(codes.dtype, np.integer) or np.any(codes < -1) or np.any(codes >= len(categories)):
+            raise QCError(f"Invalid H5AD categorical codes: {name}")
+        return np.asarray([categories[code] if code >= 0 else "" for code in codes])
+    raise QCError(f"Unsupported H5 metadata column encoding: {name}")
+
+
+def _h5_index(group) -> np.ndarray:
+    key = group.attrs.get("_index", "_index")
+    if isinstance(key, bytes):
+        key = key.decode()
+    if key not in group and "index" in group:
+        key = "index"
+    result = _h5_column(group, key)
+    if result is None:
+        raise QCError("H5AD dataframe index missing")
+    return result
+
+
+def scan_h5(path: str | Path, out_dir: str | Path, *, matrix_path: str | None = None,
+            mito_mask: Sequence | None = None, feature_mask: Sequence | None = None,
+            sample_ids: Sequence | None = None, chunk_nnz: int = 250_000,
+            disk_floor_bytes: int = 1024**3) -> dict:
+    """Audit backed sparse/dense H5AD or 10x H5; only RNA features contribute.
+
+    H5AD defaults to X; raw/X or layers/counts must be selected explicitly.
+    All source coordinates, including non-RNA features, are structurally checked.
+    """
+    import h5py
+    if not 1 <= chunk_nnz <= 2_000_000:
+        raise QCError("chunk_nnz must be between 1 and 2000000")
+    with h5py.File(path, "r", rdcc_nbytes=256 * 1024**2) as handle:
+        tenx = "matrix" in handle and all(name in handle["matrix"] for name in ("data", "indices", "indptr", "shape", "features"))
+        if tenx:
+            matrix_path = matrix_path or "matrix"
+            matrix = handle[matrix_path]
+            shape = tuple(int(value) for value in matrix["shape"][...])
+            if len(shape) != 2:
+                raise QCError("10x shape must have two dimensions")
+            n_features, n_cells = shape
+            features = matrix["features"]
+            feature_ids = _strings(features["id"])
+            symbols = _strings(features["name"]) if "name" in features else feature_ids
+            feature_types = _strings(features["feature_type"]) if "feature_type" in features else None
+            cell_ids = _strings(matrix["barcodes"])
+            orientation, encoding = "features_by_cells", "csc_matrix"
+        else:
+            matrix_path = matrix_path or "X"
+            if matrix_path not in handle or "obs" not in handle or "var" not in handle:
+                raise QCError("Unsupported HDF5 layout: expected 10x matrix or H5AD X/obs/var")
+            matrix = handle[matrix_path]
+            feature_group = handle["raw/var"] if matrix_path.startswith("raw/") and "raw/var" in handle else handle["var"]
+            feature_ids = _h5_index(feature_group)
+            symbols = None
+            for name in ("gene_symbols", "gene_symbol", "feature_name", "gene_names", "symbol"):
+                symbols = _h5_column(feature_group, name)
+                if symbols is not None:
+                    break
+            if symbols is None:
+                symbols = feature_ids
+            feature_types = None
+            for name in ("feature_types", "feature_type"):
+                feature_types = _h5_column(feature_group, name)
+                if feature_types is not None:
+                    break
+            cell_ids = _h5_index(handle["obs"])
+            n_features, n_cells = len(feature_ids), len(cell_ids)
+            shape = (n_cells, n_features)
+            orientation = "cells_by_features"
+            encoding = matrix.attrs.get("encoding-type", "")
+            if isinstance(encoding, bytes):
+                encoding = encoding.decode()
+            if isinstance(matrix, h5py.Dataset):
+                encoding = "dense"
+                actual_shape = matrix.shape
+            else:
+                actual_shape = tuple(matrix.attrs.get("shape", ()))
+            if tuple(actual_shape) != shape:
+                raise QCError(f"H5AD shape/metadata mismatch: {actual_shape} vs {shape}")
+        if len(feature_ids) != n_features or len(symbols) != n_features or len(cell_ids) != n_cells:
+            raise QCError("H5 matrix dimensions and metadata lengths differ")
+        rna = np.ones(n_features, dtype=bool) if feature_types is None else feature_types == "Gene Expression"
+        if rna.shape != (n_features,):
+            raise QCError("H5 feature_type length mismatch")
+        rna &= _vector(feature_mask, n_features, "feature_mask", default=True)
+        inferred_mito = np.char.startswith(np.char.upper(symbols.astype(str)), "MT-") if mito_mask is None else mito_mask
+        metadata = {"path": str(Path(path).resolve()), "format": "10x_h5" if tenx else "h5ad",
+                    "matrix_path": matrix_path, "source_orientation": orientation, "encoding": encoding,
+                    "rna_selection": "feature_type == Gene Expression" if feature_types is not None else "No feature types supplied; all features assumed expression",
+                    "mito_selection": "symbols beginning MT- (case insensitive)" if mito_mask is None else "caller-provided mask"}
+        if encoding == "dense":
+            if matrix.ndim != 2 or not np.issubdtype(matrix.dtype, np.number) or np.issubdtype(matrix.dtype, np.complexfloating):
+                raise QCError("Unsupported dense H5 dtype or dimensions")
+            # Dense input is visited in bounded blocks; zeros are omitted from the
+            # coordinate stream. Count positive entries in a bounded first pass.
+            block_rows = max(1, chunk_nnz // n_features)
+            nnz = 0
+            for start in range(0, n_cells, block_rows):
+                block = np.asarray(matrix[start:start + block_rows, :])
+                if not np.all(np.isfinite(block)) or np.any(block < 0):
+                    raise QCError("Dense matrix contains nonfinite or negative values")
+                nnz += int(np.count_nonzero(block))
+            accumulator = _Accumulator(Path(out_dir), n_features, n_cells, nnz, inferred_mito, rna, disk_floor_bytes=disk_floor_bytes)
+            for start in range(0, n_cells, block_rows):
+                block = np.asarray(matrix[start:start + block_rows, :])
+                rows, cols = np.nonzero(block)
+                accumulator.add(cols, rows + start, block[rows, cols].astype("f8"))
+        elif encoding in ("csr_matrix", "csc_matrix"):
+            if not all(key in matrix for key in ("data", "indices", "indptr")):
+                raise QCError("Sparse H5 lacks required arrays")
+            data, indices, indptr = matrix["data"], matrix["indices"], matrix["indptr"]
+            if any(array.ndim != 1 for array in (data, indices, indptr)):
+                raise QCError("Sparse H5 arrays must be one-dimensional")
+            if not np.issubdtype(data.dtype, np.number) or np.issubdtype(data.dtype, np.complexfloating):
+                raise QCError("Unsupported sparse expression dtype")
+            if not np.issubdtype(indices.dtype, np.integer) or not np.issubdtype(indptr.dtype, np.integer):
+                raise QCError("Sparse indices/indptr must have integer dtypes")
+            nnz = len(data)
+            major_size = shape[0] if encoding == "csr_matrix" else shape[1]
+            minor_size = shape[1] if encoding == "csr_matrix" else shape[0]
+            if len(indices) != nnz or len(indptr) != major_size + 1:
+                raise QCError("Sparse H5 array lengths disagree with shape/nnz")
+            if int(indptr[0]) != 0 or int(indptr[-1]) != nnz:
+                raise QCError("Sparse indptr endpoints disagree with nnz")
+            accumulator = _Accumulator(Path(out_dir), n_features, n_cells, nnz, inferred_mito, rna, disk_floor_bytes=disk_floor_bytes)
+            pointer_path = Path(out_dir) / ".indptr.int64"
+            pointer = np.memmap(pointer_path, mode="w+", dtype="i8", shape=(major_size + 1,))
+            previous = 0
+            for start in range(0, major_size + 1, chunk_nnz):
+                part = np.asarray(indptr[start:start + chunk_nnz])
+                if np.any(part < 0) or np.any(part > nnz) or part[0] < previous or np.any(part[1:] < part[:-1]):
+                    raise QCError("Sparse indptr is nonmonotonic or out of bounds")
+                pointer[start:start + len(part)] = part
+                previous = int(part[-1])
+            for start in range(0, nnz, chunk_nnz):
+                stop = min(start + chunk_nnz, nnz)
+                minor = np.asarray(indices[start:stop])
+                if np.any(minor < 0) or np.any(minor >= minor_size):
+                    raise QCError("Sparse H5 index out of bounds")
+                major = np.searchsorted(pointer, np.arange(start, stop), side="right") - 1
+                rows, cols = (major, minor) if encoding == "csr_matrix" else (minor, major)
+                genes, cells = (rows, cols) if tenx else (cols, rows)
+                accumulator.add(genes.astype("i8"), cells.astype("i8"), np.asarray(data[start:stop], dtype="f8"))
+            del pointer
+            pointer_path.unlink()
+        else:
+            raise QCError(f"Unsupported H5 sparse encoding: {encoding!r}")
+        metadata["sha256"] = sha256_file(path)
+        return accumulator.finish(metadata, sample_ids, feature_ids, symbols, cell_ids)
+
+
+def harmonize_coordinate_chunks(chunks: Iterable[tuple[np.ndarray, np.ndarray, np.ndarray]],
+                                feature_mapping: Sequence[int], *, verified_raw_counts: bool,
+                                has_duplicate_targets: bool) -> Iterable[tuple[np.ndarray, np.ndarray, np.ndarray]]:
+    """Map sparse chunks without densifying; -1 mappings are quarantined/omitted.
+
+    This helper does NOT combine coordinates. A downstream sparse reducer may
+    sum collisions only when verified_raw_counts is true. Normalized duplicate
+    targets raise before consuming input. Callers must retain the original map
+    and explicitly account for excluded -1 features in their audit manifest.
+    """
+    mapping = np.asarray(feature_mapping, dtype="i8")
+    if mapping.ndim != 1 or np.any(mapping < -1):
+        raise QCError("Invalid canonical feature mapping")
+    actual_duplicates = len(np.unique(mapping[mapping >= 0])) < int(np.sum(mapping >= 0))
+    if actual_duplicates != has_duplicate_targets:
+        raise QCError("Declared target duplication disagrees with feature mapping")
+    if actual_duplicates and not verified_raw_counts:
+        raise QCError("Normalized/unknown duplicate gene mappings quarantined; summation is prohibited")
+    for features, cells, values in chunks:
+        if np.any(features < 0) or np.any(features >= len(mapping)):
+            raise QCError("Feature index outside canonical mapping")
+        target = mapping[features]
+        keep = target >= 0
+        yield target[keep], cells[keep], values[keep]