@sjcrh/proteinpaint-server 2.208.0 → 2.210.1-0

package/dataset/termdb.test.js

@@ -3,9 +3,10 @@ const mafFields = [
     id: "tumor_DNA",
     name: "Tumor DNA",
     parent_id: null,
-    child_ids: ["tumor_DNA_WGS"],
+    mafFormatKey: "tumor_DNA_WGS",
     isleaf: true,
     type: "float",
+    mafFilterMode: "maf",
     default: true,
     // indicates default maf term (e.g. will be used by default for making maf filters in predefined groupset)
     min: 0,

package/genome/hg38.base.js

@@ -69,6 +69,28 @@ function getHg38() {
         stackspace: 1,
         vpad: 4
       },
+      {
+        /* ENCODE cCRE registry, coloured by class in SCREEN's own colours. Declared here rather
+        than in a dataset so any hg38 block can turn it on from the Tracks menu; like
+        RepeatMasker it is available, not default-on, because __isgene is what
+        first_genetrack_tolist adds automatically. The differential-methylation region view
+        switches it on explicitly, where a cCRE is at a scale it can actually be drawn at.
+        Built by utils/dnaMeth/build_ccre_track.py -- the shipped registry carries the class in
+        column 6, where bedj cannot see it. */
+        type: "bedj",
+        name: "ENCODE cCREs",
+        file: "anno/encodeCCREtrack.hg38.gz",
+        stackheight: 12,
+        stackspace: 1,
+        vpad: 3,
+        categories: {
+          PLS: { color: "#FF0000", label: "Promoter-like" },
+          pELS: { color: "#FFA700", label: "Proximal enhancer-like" },
+          dELS: { color: "#FFCD00", label: "Distal enhancer-like" },
+          "CTCF-only": { color: "#00B0F0", label: "CTCF-only" },
+          "DNase-H3K4me3": { color: "#FFAAAA", label: "DNase-H3K4me3" }
+        }
+      },
       {
         type: "bedj",
         name: "RepeatMasker",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sjcrh/proteinpaint-server",
-  "version": "2.208.0",
+  "version": "2.210.1-0",
   "type": "module",
   "description": "a genomics visualization tool for exploring a cohort's genotype and phenotype data",
   "main": "src/app.js",
@@ -56,12 +56,12 @@
     "typescript": "^5.6.3"
   },
   "dependencies": {
-    "@sjcrh/augen": "2.204.0",
-    "@sjcrh/proteinpaint-python": "2.208.0",
+    "@sjcrh/augen": "2.210.0",
+    "@sjcrh/proteinpaint-python": "2.209.0",
     "@sjcrh/proteinpaint-r": "2.207.1",
-    "@sjcrh/proteinpaint-rust": "2.208.0",
-    "@sjcrh/proteinpaint-shared": "2.208.0",
-    "@sjcrh/proteinpaint-types": "2.208.0",
+    "@sjcrh/proteinpaint-rust": "2.209.0",
+    "@sjcrh/proteinpaint-shared": "2.210.0",
+    "@sjcrh/proteinpaint-types": "2.210.1-0",
     "@types/express": "^5.0.0",
     "@types/express-session": "^1.18.1",
     "better-sqlite3": "^12.4.1",
@@ -121,5 +121,5 @@
       ]
     ]
   },
-  "_buildTime": "2026-09-13T18:11:20Z"
+  "_buildTime": "2026-09-21T19:04:04Z"
 }

package/routes/termdb.diffMeth.js

@@ -1,7 +1,14 @@
+import { DMR_SCAN_ELEMENT_TYPE } from "#types";
+import { runDmrBatch } from "#src/routes/termdb.dmrBatch.ts";
+import { dmrScanToRows, summarizeProfile, coarsenProfile, dmrBedjLines } from "#src/utils/dmrScanRows.ts";
+import { writeBedjFile } from "#src/utils/bedjCache.ts";
+import { resolveGroupNames, matchedSamplelst, eligibleMethylationSamples } from "#src/utils/methylationMatrix.ts";
 import { mayLog } from "#src/helpers.ts";
 import { run_R } from "@sjcrh/proteinpaint-r";
 import { formatElapsedTime } from "#shared";
 import { renderVolcano } from "../src/renderVolcano.ts";
+import { renderManhattanPoints } from "../src/renderManhattan.ts";
+import { HYPER_COLOR, HYPO_COLOR } from "#shared/dmrColors.js";
 import { cacheOrRecompute } from "#src/utils/cacheOrRecompute.ts";
 import {
   buildGroupValues,
@@ -30,12 +37,37 @@ function init({ genomes }) {
       const rendered = await renderVolcano(result.promoterRows, q.volcanoRender);
       rendered.cacheId = cacheId;
       if (rendered.totalRows === 0)
-        throw new Error("No promoters passed filtering. Try relaxing group criteria or selecting more samples.");
+        throw new Error(
+          !result.scan ? "No promoters passed filtering. Try relaxing group criteria or selecting more samples." : result.scan.kept && result.scan.backgroundCorrection ? (
+            /* rows omit unscored DMRs under the correction, so none plotted does not mean
+            none met the floor */
+            `None of the ${result.scan.kept.toLocaleString()} DMRs meeting the CpG floor could be scored against matched background. Turn off the background correction to see them.`
+          ) : "The scan called no DMRs that met the CpG floor."
+        );
       const output = {
         data: rendered,
         sample_size1: result.sample_size1,
         sample_size2: result.sample_size2
       };
+      if (result.scan) {
+        output.scan = result.scan;
+        if (result.scan.binMethylation) {
+          output.scan.profileSummary = summarizeProfile(result.scan.binMethylation);
+          output.scan.profile = await renderMethylationProfile(
+            result.scan,
+            genomes[q.genome],
+            q.volcanoRender?.devicePixelRatio,
+            // display width only; the summary rows above stay on the native 100 kb bin
+            q.scan?.profileBinBp
+          );
+          delete output.scan.binMethylation;
+        }
+        output.scan.manhattan = await renderScanManhattan(
+          result.promoterRows,
+          genomes[q.genome],
+          q.volcanoRender?.devicePixelRatio
+        );
+      }
       res.send(output);
     } catch (e) {
       res.status(e.status || 500).send({ status: "error", error: e.message || e, code: e.code });
@@ -95,6 +127,7 @@ function dmKeyInputs(req, imputeMissing) {
   };
 }
 async function getDmCacheResult(req, genomes) {
+  if (req.element_type === DMR_SCAN_ELEMENT_TYPE) return getDmrScanAsDm(req, genomes);
   const imputeMissing = genomes?.[req.genome]?.datasets?.[req.dslabel]?.queries?.dnaMethylation?.platform != "wgbs";
   const { result, cacheId } = await cacheOrRecompute({
     computeArgument: dmKeyInputs(req, imputeMissing),
@@ -106,6 +139,153 @@ async function getDmCacheResult(req, genomes) {
   });
   return { result, cacheId };
 }
+function scanChromosomes(req, genome) {
+  let chromosomes = req.scan?.chromosome ? [req.scan.chromosome] : genome.majorchrorder.filter((c) => c != "chrM" && c != "chrMT");
+  if (req.exclude_sex_chr) chromosomes = chromosomes.filter((c) => !/^chr[XY]$/i.test(c));
+  if (!chromosomes.length) throw new Error("No chromosomes left to scan.");
+  return chromosomes;
+}
+async function getDmrScanAsDm(req, genomes) {
+  if (req.tw || req.tw2) throw new Error("Confounding factors are not supported by the DMR scan.");
+  const genome = genomes[req.genome];
+  if (!genome) throw new Error("unknown genome");
+  const ds = genome.datasets?.[req.dslabel];
+  if (!ds) throw new Error("unknown dataset");
+  const groups = req.samplelst?.groups;
+  if (groups?.length != 2)
+    throw new Error("Exactly 2 sample groups are required for differential methylation analysis.");
+  const chromosomes = scanChromosomes(req, genome);
+  const { payload, cacheId } = await runDmrBatch(
+    {
+      genome: req.genome,
+      dslabel: req.dslabel,
+      group1: groups[0].values,
+      group2: groups[1].values,
+      scanChromosomes: chromosomes,
+      backgroundCorrection: !!req.scan?.backgroundCorrection,
+      // the genome-wide profile: the metric the methylome literature compares cohorts with
+      binMethylation: true,
+      lambda: positiveOrUndefined(req.scan?.lambda),
+      C: positiveOrUndefined(req.scan?.C),
+      fdr_cutoff: positiveOrUndefined(req.scan?.fdrCutoff)
+    },
+    genomes
+  );
+  const eligible = eligibleMethylationSamples(ds, void 0);
+  const { group1, group2 } = await resolveGroupNames(groups[0].values, groups[1].values, eligible, ds);
+  const { rows, scan } = dmrScanToRows(payload, {
+    chromosomes,
+    minCpgs: req.scan?.minCpgs,
+    backgroundCorrection: !!req.scan?.backgroundCorrection
+  });
+  scan.matchedSamplelst = await matchedSamplelst(req.samplelst, eligible, ds);
+  scan.cacheId = cacheId;
+  try {
+    scan.bedjFile = await writeBedjFile(`dmr-${cacheId}-${scan.minCpgs}.gz`, {
+      text: dmrBedjLines(payload, scan.minCpgs)
+    });
+  } catch (e) {
+    console.error("DMR scan: bedj cache write failed, browser track unavailable:", e?.message || e);
+  }
+  return {
+    result: { promoterRows: rows, sample_size1: group1.length, sample_size2: group2.length, scan },
+    cacheId
+  };
+}
+function positiveOrUndefined(v) {
+  const n = Number(v);
+  return v != null && Number.isFinite(n) && n > 0 ? n : void 0;
+}
+const SCAN_INTERACTIVE_PER_SIDE = 1e3;
+async function renderScanManhattan(rows, genome, devicePixelRatio) {
+  const chrSizes = {};
+  for (const c of genome.majorchrorder) if (c != "chrM" && c != "chrMT") chrSizes[c] = genome.majorchr[c];
+  const points = rows.map((r) => {
+    const p = r.original_p_value;
+    const mag = p > 0 ? -Math.log10(p) : Infinity;
+    return {
+      chrom: r.chr,
+      pos: r.start,
+      y: r.delta_beta < 0 ? -mag : mag,
+      color: r.delta_beta < 0 ? HYPO_COLOR : HYPER_COLOR,
+      start: r.start,
+      stop: r.stop,
+      delta_beta: r.delta_beta,
+      fold_change: r.fold_change,
+      p,
+      no_cpgs: r.no_cpgs,
+      gene_name: r.gene_name,
+      ...r.excess != null ? { excess: r.excess } : {}
+    };
+  });
+  const plotWidth = 1e3;
+  const plotHeight = 300;
+  const { png, plot_data } = await renderManhattanPoints({
+    points,
+    chrSizes,
+    plotWidth,
+    plotHeight,
+    devicePixelRatio: devicePixelRatio || 1,
+    pngDotRadius: 2,
+    // the GRIN2 defaults: raise the cap only when more than 5 dots would sit on it
+    maxCappedPoints: 5,
+    hardCap: 200,
+    binSize: 10,
+    interactive: SCAN_INTERACTIVE_PER_SIDE,
+    signed: true,
+    // open circles, as the volcano above draws the same DMRs
+    hollow: true
+  });
+  return { png, plotData: plot_data, interactive: SCAN_INTERACTIVE_PER_SIDE, plotWidth, plotHeight };
+}
+function renderMethylationProfile(scan, genome, devicePixelRatio, profileBinBp) {
+  if (!scan.binMethylation?.bins.length) return void 0;
+  const bm = coarsenProfile(scan.binMethylation, profileBinBp);
+  const chrSizes = {};
+  for (const c of genome.majorchrorder) if (c != "chrM" && c != "chrMT") chrSizes[c] = genome.majorchr[c];
+  const points = bm.bins.map((b) => {
+    const d = b.case - b.control;
+    return {
+      chrom: b.chr,
+      pos: b.start,
+      y: d,
+      color: d < 0 ? HYPO_COLOR : HYPER_COLOR,
+      control: b.control,
+      case: b.case,
+      n_probes: b.n_probes
+    };
+  });
+  const plotWidth = 1e3;
+  const plotHeight = 160;
+  const dotRadius = 1;
+  return renderManhattanPoints({
+    points,
+    chrSizes,
+    plotWidth,
+    plotHeight,
+    devicePixelRatio: devicePixelRatio || 1,
+    pngDotRadius: dotRadius,
+    maxCappedPoints: 5,
+    hardCap: 200,
+    binSize: 10,
+    /* The bins that moved most, each way. Ranking is |y| = |Δβ| here rather than evidence: on
+    this figure the effect size IS the result, and the bins a reader wants to identify are the
+    excursions away from the zero line. */
+    interactive: SCAN_INTERACTIVE_PER_SIDE,
+    signed: true,
+    capping: false
+  }).then(({ png, plot_data }) => ({
+    png,
+    plotData: plot_data,
+    binBp: bm.binBp,
+    plotWidth,
+    plotHeight,
+    dotRadius,
+    bins: bm.bins.length,
+    // what the top-N-per-side rule actually left live, which at a coarse width is every bin
+    interactive: plot_data.points.length
+  }));
+}
 async function runDmFresh(param, ds, term_results, term_results2, imputeMissing) {
   const groups = await resolveDmSampleGroups(param, ds, term_results, term_results2);
   if (groups.alerts.length) throw new Error(groups.alerts.join(" | "));
@@ -150,10 +330,10 @@ async function resolveDmSampleGroups(param, ds, term_results, term_results2) {
     throw new Error("Group 1 has no samples. Please select at least one sample.");
   if (param.samplelst.groups[1].values?.length < 1)
     throw new Error("Group 2 has no samples. Please select at least one sample.");
-  const { q } = resolveElementQuery(ds, param.element_type);
+  const allSampleSet = eligibleMethylationSamples(ds, param.element_type);
   const g1 = await buildGroupValues(
     param.samplelst.groups[0].values,
-    q.allSampleSet,
+    allSampleSet,
     ds,
     param.tw,
     param.tw2,
@@ -162,7 +342,7 @@ async function resolveDmSampleGroups(param, ds, term_results, term_results2) {
   );
   const g2 = await buildGroupValues(
     param.samplelst.groups[1].values,
-    q.allSampleSet,
+    allSampleSet,
     ds,
     param.tw,
     param.tw2,
@@ -192,5 +372,6 @@ export {
   init,
   listElementTypes,
   resolveDmSampleGroups,
-  resolveElementQuery
+  resolveElementQuery,
+  scanChromosomes
 };