Archive 4 checkpoints (1-4)

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

@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+# Run one CPU-only pipeline step as a transient systemd user unit.
+# Limits: 12 GiB memory (no swap), <= 6 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/ye2026_sepsis_v1_20260927
+PY=/home/sj_server_1/miniforge3/envs/scanvi/bin/python
+step="$1"
+unit="ye2026-${step}-$(date +%H%M%S)"
+systemctl --user is-active --quiet ml-memory-guard.service
+exec systemd-run --user --wait --collect --quiet --unit="$unit" --slice=app.slice \
+  -p MemoryHigh=10G -p MemoryMax=12G -p MemorySwapMax=0 -p CPUQuota=600% \
+  -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/$(case "$step" in assemble) echo ye2026_assemble.py;; findings) echo ye2026_findings.py;; *) echo ye2026_pipeline.py;; esac)" \
+  $(case "$step" in assemble|findings) ;; *) printf '%q ' "$@";; esac)

paper-releases/20260928/diffusion/data/source_prep/ye2026_sepsis/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/ye2026_sepsis/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]

paper-releases/20260928/diffusion/data/source_prep/ye2026_sepsis/code/strict_qc_v1_code_bundle_v5/qc_finalize.py

@@ -0,0 +1,336 @@
+"""Consolidate technical file QC and identity audits without inferring identities."""
+from __future__ import annotations
+
+import csv
+from collections import Counter
+from datetime import datetime, timezone
+import hashlib
+import json
+from pathlib import Path
+
+import h5py
+import numpy as np
+import pandas as pd
+
+
+SC_TERMINAL = {'PASS', 'PASS_QC_EXPORT_QUARANTINED', 'QUARANTINED', 'DUPLICATE_REPRESENTATION_VALIDATED'}
+BULK_ORGANIZED = {'organized_with_explicit_masks', 'organized_with_numeric_quarantine', 'organized_declared_count_semantics_failed'}
+
+
+def bulk_failed(record: dict) -> bool:
+    status = str(record.get('status', '')).lower()
+    return status.startswith('failed_') or status in {'failed', 'error', 'quarantined'}
+
+
+def stage_coverage(root: Path, runroot: Path, bulk: list[dict], sc: list[dict]) -> dict:
+    """Compare terminal stage records against acquired sources and exact exports."""
+    from qc_singlecell import discover_libraries
+    issues, expected_paths = [], []
+    manifest = read(root / 'SOURCE_MANIFEST.json', {})
+    datasets = manifest.get('datasets', [])
+    expected_bulk = {row['bulk_accession'] for row in datasets if row.get('bulk_accession')}
+    expected_sc_accessions = {row['sc_accession'] for row in datasets if row.get('sc_accession')}
+    discovered = discover_libraries(root, runroot)
+    key = lambda row: (row.get('accession', ''), row.get('library_id', ''), bool(row.get('duplicate_representation')))
+    expected_sc = Counter(key(row) for row in discovered)
+    actual_sc = Counter(key(row) for row in sc)
+    discovered_accessions = {row['accession'] for row in discovered}
+    for accession in sorted(expected_sc_accessions - discovered_accessions):
+        issues.append({'code': 'missing_expected_sc_source_accession', 'accession': accession})
+    if not datasets or not expected_bulk or not bulk:
+        issues.append({'code': 'empty_required_bulk_inventory_or_results', 'problem': 'Expected bulk inventory and terminal results must be nonempty'})
+    if not discovered or not sc:
+        issues.append({'code': 'empty_required_sc_inventory_or_results', 'problem': 'Discovered single-cell sources and terminal results must be nonempty'})
+    for identity, count in expected_sc.items():
+        if count != 1:
+            issues.append({'code': 'duplicate_discovered_sc_identity', 'identity': identity, 'count': count})
+        if actual_sc[identity] != count:
+            issues.append({'code': 'sc_result_coverage_mismatch', 'identity': identity, 'expected': count, 'observed': actual_sc[identity]})
+    for identity, count in actual_sc.items():
+        if identity not in expected_sc:
+            issues.append({'code': 'unexpected_sc_result', 'identity': identity, 'count': count})
+        if count != 1:
+            issues.append({'code': 'duplicate_sc_result', 'identity': identity, 'count': count})
+    bulk_present = {row.get('accession') for row in bulk}
+    for accession in sorted(expected_bulk - bulk_present):
+        issues.append({'code': 'missing_bulk_accession_result', 'accession': accession})
+    for accession in sorted(bulk_present - expected_bulk, key=str):
+        issues.append({'code': 'unexpected_bulk_accession_result', 'accession': accession})
+    bulk_ids = Counter(row.get('assay_id', '') for row in bulk)
+    for assay, count in bulk_ids.items():
+        if not assay or count != 1:
+            issues.append({'code': 'invalid_bulk_assay_identity', 'assay': assay, 'count': count})
+    terminal = True
+    required_exports_complete = True
+    for record in bulk:
+        status, path = record.get('status', ''), record.get('harmonized_path', '')
+        accepted_missing = status == 'missing_bulk_expression_VCF_only' and record.get('accession') == 'GSE247706'
+        if status not in BULK_ORGANIZED and not bulk_failed(record) and not accepted_missing:
+            terminal = False
+            issues.append({'code': 'nonterminal_or_unknown_bulk_status', 'assay': record.get('assay_id'), 'status': status})
+        if status in BULK_ORGANIZED:
+            if not path:
+                issues.append({'code': 'missing_success_export_path', 'assay': record.get('assay_id')})
+                required_exports_complete = False
+            else:
+                expected_paths.append({'modality': 'bulk', 'assay_id': record.get('assay_id'), 'path': str(Path(path).resolve())})
+        if bulk_failed(record):
+            required_exports_complete = False
+    for record in sc:
+        status = record.get('status', '')
+        if status not in SC_TERMINAL:
+            terminal = False
+            issues.append({'code': 'nonterminal_or_unknown_sc_status', 'identity': key(record), 'status': status})
+        if record.get('duplicate_representation'):
+            if status != 'DUPLICATE_REPRESENTATION_VALIDATED':
+                required_exports_complete = False
+            continue
+        if status == 'PASS':
+            path = record.get('canonical_export', {}).get('path', '')
+            if not path:
+                issues.append({'code': 'missing_success_export_path', 'identity': key(record)})
+                required_exports_complete = False
+            else:
+                expected_paths.append({'modality': 'singlecell', 'assay_id': record.get('library_id'), 'path': str(Path(path).resolve())})
+        else:
+            required_exports_complete = False
+    path_counts = Counter(row['path'] for row in expected_paths)
+    for path, count in path_counts.items():
+        if count != 1:
+            issues.append({'code': 'duplicate_export_path', 'path': path, 'count': count})
+        if not Path(path).is_file():
+            issues.append({'code': 'missing_expected_export', 'path': path})
+            required_exports_complete = False
+    actual_paths = {str(path.resolve()) for directory in ['bulk', 'singlecell']
+                    for path in (runroot / directory).rglob('*.h5ad')}
+    for path in sorted(actual_paths - set(path_counts)):
+        issues.append({'code': 'untracked_export_file', 'path': path})
+    if not expected_paths:
+        issues.append({'code': 'zero_expected_exports', 'problem': 'No successful required expression exports'})
+        required_exports_complete = False
+    # Inventory coverage and terminal processing are distinct from export quality.
+    coverage_codes = {'empty_required_bulk_inventory_or_results', 'empty_required_sc_inventory_or_results',
+                      'duplicate_discovered_sc_identity', 'sc_result_coverage_mismatch', 'unexpected_sc_result',
+                      'duplicate_sc_result', 'missing_bulk_accession_result', 'unexpected_bulk_accession_result',
+                      'missing_expected_sc_source_accession',
+                      'invalid_bulk_assay_identity', 'nonterminal_or_unknown_bulk_status', 'nonterminal_or_unknown_sc_status'}
+    result_coverage = not any(row['code'] in coverage_codes for row in issues)
+    return {'issues': issues, 'expected_exports': expected_paths,
+            'expected_bulk_accessions': sorted(expected_bulk), 'expected_sc_records': sum(expected_sc.values()),
+            'expected_sc_accessions': sorted(expected_sc_accessions),
+            'observed_sc_records': len(sc), 'result_coverage_complete': result_coverage,
+            'file_processing_finished': bool(result_coverage and terminal),
+            'required_exports_complete': bool(required_exports_complete and result_coverage and not issues),
+            'bulk_failures': sum(bulk_failed(row) for row in bulk),
+            'bulk_numeric_quarantine': sum(row.get('status') in {'organized_with_numeric_quarantine', 'organized_declared_count_semantics_failed'} for row in bulk),
+            'bulk_expression_unavailable': sum(row.get('status') == 'missing_bulk_expression_VCF_only' for row in bulk),
+            'sc_quarantined': sum(row.get('status') == 'QUARANTINED' for row in sc),
+            'sc_export_resource_or_semantic_quarantine': sum(row.get('status') == 'PASS_QC_EXPORT_QUARANTINED' for row in sc)}
+
+
+def digest(path: Path) -> str:
+    value = hashlib.sha256()
+    with path.open('rb') as source:
+        for chunk in iter(lambda: source.read(4 * 1024**2), b''):
+            value.update(chunk)
+    return value.hexdigest()
+
+
+def write_json(path: Path, value: object) -> None:
+    path.write_text(json.dumps(value, indent=2, ensure_ascii=False, default=str) + '\n')
+
+
+def read(path: Path, default: object = None) -> object:
+    return json.loads(path.read_text()) if path.exists() else default
+
+
+def scalar_column(row: dict, key: str, default: object = '') -> object:
+    value = row.get(key, default)
+    return json.dumps(value, ensure_ascii=False, default=str) if isinstance(value, (dict, list)) else value
+
+
+def csv_rows(path: Path, rows: list[dict]) -> None:
+    if not rows:
+        path.write_text('status\nno_records\n')
+        return
+    fields = list(dict.fromkeys(key for row in rows for key in row))
+    with path.open('w', newline='') as target:
+        writer = csv.DictWriter(target, fieldnames=fields)
+        writer.writeheader()
+        writer.writerows({key: scalar_column(row, key) for key in fields} for row in rows)
+
+
+def validate_h5ad(path: Path, canonical: list[str], require_units: bool) -> dict:
+    with h5py.File(path, 'r') as handle:
+        var = handle['var']
+        index = var.attrs.get('_index', '_index')
+        if isinstance(index, bytes):
+            index = index.decode()
+        ids = var[index].asstr()[...].tolist()
+        if ids != canonical:
+            raise ValueError('Canonical feature order mismatch')
+        matrix = handle['X']
+        shape = tuple(matrix.attrs['shape']) if isinstance(matrix, h5py.Group) else matrix.shape
+        if shape[1] != len(canonical):
+            raise ValueError('Export matrix gene dimension differs from reference')
+        if require_units and ('uns' not in handle or 'units' not in handle['uns']):
+            raise ValueError('Export units absent from standard AnnData uns')
+        return {'path': str(path), 'n_samples_or_cells': int(shape[0]), 'n_genes': len(ids),
+                'gene_order_verified': True, 'bytes': path.stat().st_size, 'sha256': digest(path)}
+
+
+def finalize(root: Path, runroot: Path) -> dict:
+    root, runroot = Path(root), Path(runroot)
+    bulk = read(runroot / 'BULK_RESULTS.json')
+    sc = read(runroot / 'SINGLECELL_RESULTS.json')
+    if not isinstance(bulk, list) or not isinstance(sc, list):
+        raise ValueError('Both bulk and singlecell stage result lists are required')
+    source = read(runroot / 'SOURCE_VERIFICATION.json', {})
+    extraction = read(runroot / 'EXTRACTION.json', {})
+    pairing = read(runroot / 'pairing_audit/PAIRING_AUDIT.json', {})
+    canonical = pd.read_csv(runroot / 'reference/canonical_genes.tsv', sep='\t', dtype=str)['gene_id'].tolist()
+    if len(canonical) != 20097 or len(set(canonical)) != len(canonical):
+        raise ValueError('Frozen canonical axis is not 20097 unique IDs')
+    reportdir = runroot / 'reports'
+    reportdir.mkdir(exist_ok=True)
+    coverage = stage_coverage(root, runroot, bulk, sc)
+    assay_rows, export_checks, problems = [], [], list(coverage['issues'])
+    for record in bulk:
+        row = {'modality': 'bulk', 'accession': record.get('accession'), 'assay_id': record.get('assay_id'),
+               'status': record.get('status'), 'units': record.get('units'), 'samples': record.get('n_samples'),
+               'source_genes': record.get('n_genes'), 'canonical_coverage': record.get('canonical_coverage'),
+               'raw_integer_count_eligible': record.get('raw_count_eligible'),
+               'nonfinite_values': record.get('nonfinite_values'), 'fractional_values': record.get('fractional_values'),
+               'duplicate_source_rows_quarantined': record.get('duplicate_source_rows_quarantined'),
+               'export_path': record.get('harmonized_path', ''), 'caveats': record.get('caveats', [])}
+        assay_rows.append(row)
+        if record.get('harmonized_path'):
+            try:
+                export_checks.append(validate_h5ad(Path(record['harmonized_path']), canonical, require_units=True))
+            except Exception as error:
+                problems.append({'assay': row['assay_id'], 'problem': str(error)})
+    primary_sc = [row for row in sc if not row.get('duplicate_representation')]
+    for record in sc:
+        export = record.get('canonical_export', {})
+        mapping = record.get('canonicalcoverage', {})
+        assay_rows.append({'modality': 'singlecell', 'accession': record.get('accession'),
+                           'assay_id': record.get('library_id'), 'status': record.get('status'),
+                           'units': record.get('units'), 'cells': record.get('n_cells'),
+                           'qc_review_pass_cells': record.get('n_qc_review_pass'),
+                           'source_genes': record.get('n_features'),
+                           'canonical_coverage': mapping.get('canonical_coverage_fraction'),
+                           'raw_integer_count_eligible': record.get('count_space_verified'),
+                           'duplicate_representation': record.get('duplicate_representation'),
+                           'export_path': export.get('path', ''),
+                           'cell_metadata_linkage': record.get('author_map_match', {}),
+                           'error': record.get('error', record.get('export_error', ''))})
+        if export.get('path'):
+            try:
+                if not export.get('mass_conservation_pass'):
+                    raise ValueError('Selected-source = canonical + excluded mass identity failed')
+                export_checks.append(validate_h5ad(Path(export['path']), canonical, require_units=True))
+            except Exception as error:
+                problems.append({'assay': record['library_id'], 'problem': str(error)})
+    csv_rows(reportdir / 'ASSAY_QC_SUMMARY.csv', assay_rows)
+    samples = []
+    for record in primary_sc:
+        export = record.get('canonical_export', {})
+        if record.get('status') != 'PASS' or not export.get('pseudobulk_enabled') or not export.get('path'):
+            continue
+        path = Path(export['path']).parent / 'pseudobulk_sample_summary.csv'
+        if not path.is_file():
+            problems.append({'assay': record.get('library_id'), 'problem': 'Declared pseudobulk sample summary is missing'})
+            continue
+        frame = pd.read_csv(path, keep_default_na=False)
+        if frame.empty or 'sample_id' not in frame or frame.sample_id.duplicated().any():
+            problems.append({'assay': record.get('library_id'), 'problem': 'Pseudobulk sample summary is empty or has invalid/duplicate sample IDs'})
+            continue
+        frame['source_library_directory'] = str(path.parent)
+        frame['accession'] = path.parent.parent.name
+        samples.extend(frame.to_dict('records'))
+    csv_rows(reportdir / 'PUBLISHED_SAMPLE_AGGREGATES.csv', samples)
+    # Namespace sample IDs by accession; repeated libraries stay traceable.
+    pooled = []
+    if samples:
+        frame = pd.DataFrame(samples)
+        for (accession, sample_id), group in frame.groupby(['accession', 'sample_id'], sort=True):
+            contexts = {}
+            for key in ['donor_id', 'visit_id', 'protocol', 'units']:
+                values = group[key] if key in group else []
+                contexts[key] = sorted(set(str(v) for v in values if str(v) not in {'', 'unknown', 'not_published'}))
+            conflict = any(len(v) > 1 for v in contexts.values())
+            pooled.append({'accession': accession, 'sample_id': sample_id,
+                           'donor_id': contexts['donor_id'][0] if len(contexts['donor_id']) == 1 else '',
+                           'visit_id': contexts['visit_id'][0] if len(contexts['visit_id']) == 1 else '',
+                           'units': contexts['units'][0] if len(contexts['units']) == 1 else '',
+                           'protocol': contexts['protocol'][0] if len(contexts['protocol']) == 1 else '',
+                           'library_count': len(group), 'mapped_cells': int(group.n_cells.sum()),
+                           'review_pass_cells': int(group.n_qc_review_pass.sum()),
+                           'minimum_200_review_cells': bool(group.n_qc_review_pass.sum() >= 200),
+                           'minimum_1000_review_cells': bool(group.n_qc_review_pass.sum() >= 1000),
+                           'context_conflict': conflict, 'library_dirs': group.source_library_directory.tolist()})
+            if conflict:
+                problems.append({'sample_id': sample_id, 'accession': accession, 'problem': 'Cross-library donor/visit/protocol/unit conflict'})
+    csv_rows(reportdir / 'SAMPLE_QC_SUMMARY.csv', pooled)
+    studies = json.loads((root / 'SOURCE_MANIFEST.json').read_text())['datasets']
+    readiness = []
+    for study in studies:
+        sid = study['inventory_id']
+        b = [row for row in bulk if row.get('accession') == study.get('bulk_accession') and row.get('harmonized_path')]
+        c = [row for row in primary_sc if row.get('accession') == study.get('sc_accession')]
+        metadata = pairing.get('studies', {}).get(sid, {})
+        exports = [row for row in c if row.get('canonical_export', {}).get('path')]
+        readiness.append({'study_id': sid, 'study': study['study'], 'bulk_accession': study.get('bulk_accession'),
+                          'sc_accession': study.get('sc_accession'), 'bulk_export_assays': len(b),
+                          'sc_primary_libraries': len(c), 'sc_exported_libraries': len(exports),
+                          'sc_quarantined_libraries': sum(row.get('status') == 'QUARANTINED' for row in c),
+                          'sc_export_quarantined_libraries': sum(row.get('status') == 'PASS_QC_EXPORT_QUARANTINED' for row in c),
+                          'bulk_units': sorted(set(row.get('units', '') for row in b)),
+                          'metadata_audit': metadata, 'bulk_material': study.get('bulk_material'),
+                          'sc_material': study.get('sc_material'), 'caveats': study.get('caveats', []),
+                          'file_organization_status': 'both_sides_exported' if b and exports and len(exports) == len(c) else 'partial_or_missing_counterpart',
+                          'pair_use_status': 'requires_explicit_identity_material_and_unit_gates;not_inferred_from_export_success'})
+    csv_rows(reportdir / 'STUDY_READINESS.csv', readiness)
+    failures = [row for row in sc if row.get('status') == 'QUARANTINED']
+    bulk_failures = [row for row in bulk if bulk_failed(row)]
+    numeric_quality_pass = not (coverage['bulk_numeric_quarantine'] or coverage['bulk_failures'] or coverage['sc_quarantined'] or coverage['sc_export_resource_or_semantic_quarantine'])
+    result = {'generated_at': datetime.now(timezone.utc).isoformat(),
+              'file_processing_finished': coverage['file_processing_finished'], 'source_verified': bool(source.get('complete')),
+              'archive_expansion_complete': bool(extraction.get('complete')),
+              'canonical_genes': len(canonical), 'bulk_records': len(bulk),
+              'bulk_expression_exports': sum(bool(row.get('harmonized_path')) for row in bulk),
+              'singlecell_primary_libraries': len(primary_sc),
+              'singlecell_primary_cells': sum(row.get('n_cells', 0) for row in primary_sc),
+              'singlecell_exported_libraries': sum(bool(row.get('canonical_export', {}).get('path')) for row in primary_sc),
+              'alternate_format_validations': sum(row.get('status') == 'DUPLICATE_REPRESENTATION_VALIDATED' for row in sc),
+              'quarantined_libraries': len(failures), 'bulk_failures': len(bulk_failures),
+              'sc_export_quarantined_libraries': coverage['sc_export_resource_or_semantic_quarantine'],
+              'bulk_numeric_quarantine': coverage['bulk_numeric_quarantine'],
+              'bulk_expression_unavailable': coverage['bulk_expression_unavailable'],
+              'stage_coverage': coverage,
+              'required_exports_complete': coverage['required_exports_complete'],
+              'file_organization_complete': bool(source.get('complete') and extraction.get('complete') and coverage['required_exports_complete'] and not problems),
+              'numerical_file_quality_pass': bool(numeric_quality_pass and coverage['required_exports_complete'] and not problems),
+              'export_validation_problems': problems, 'exports': export_checks,
+              'technical_export_validation_pass': bool(not problems and export_checks and coverage['required_exports_complete']),
+              'scope': 'File integrity, numerical representation, feature identifiers and published sample metadata only; no biological inference',
+              'limits': ['Data access and unresolved sample IDs remain explicit constraints.',
+                         'Soft QC flags are preserved; they are not proof of biological quality.',
+                         'Fractional and normalized values retain original units.',
+                         'Missing or quarantined features are masked and are not observed zeros.']}
+    write_json(reportdir / 'VALIDATION.json', result)
+    lines = ['# PBMC 파일 QC·ID 표준화 결과', '',
+             f"원본 검증: {result['source_verified']}; 압축 해제: {result['archive_expansion_complete']}.",
+             f"Bulk 발현 결과 {result['bulk_expression_exports']}개, single-cell 기본 library {len(primary_sc)}개 중 표준 파일 {result['singlecell_exported_libraries']}개를 만들었다.",
+             f"모든 표준 파일은 검증된 20,097개 유전자 ID와 동일한 순서를 사용한다. Export 구조·해시 검사 문제: {len(problems)}건.", '',
+             '| 연구 | Bulk 결과 | sc 결과/기본 library | 시료·연결 제한 |', '|---|---:|---:|---|']
+    for row in readiness:
+        caveats = '; '.join(str(v) for v in row['caveats']).replace('|', '/')
+        lines.append(f"| {row['study_id']} | {row['bulk_export_assays']} | {row['sc_exported_libraries']}/{row['sc_primary_libraries']} | {caveats} |")
+    lines += ['', '파일 구조 검증과 분석용 pair의 적합성은 별개다. 동일 환자·시점·시료가 입증되지 않은 행은 임의로 연결하지 않았다.',
+              'Count, estimated count, TPM, FPKM, log2CPM, microarray 값을 분리했으며 반올림·역변환·생물학적 의미 추론은 수행하지 않았다.',
+              'Bulk는 NaN 및 source_feature_present/harmonization_valid mask로 결측과 격리를 구분한다. Sparse single-cell은 저장상 0과 별도로 var mask 및 uns의 단위·정책을 보존한다.', '',
+              '상세 결과: ASSAY_QC_SUMMARY.csv, STUDY_READINESS.csv, SAMPLE_QC_SUMMARY.csv, VALIDATION.json.',
+              '유전자 ID 근거는 ../reference/README.md, 샘플 ID 대응과 미해결 사항은 ../pairing_audit/README.md에 있다.', '']
+    (reportdir / 'REPORT_KO.md').write_text('\n'.join(lines))
+    return result