@sjcrh/proteinpaint-server 2.177.1-0 → 2.178.0

package/dataset/termdb.test.js

@@ -210,18 +210,31 @@ function termdb_test_default() {
         defaultTw4correlationPlot: {
           disease: { id: "diaggrp", q: {} }
         },
-        numericTermCollections: [
+        termCollections: [
           {
             name: "Fake Collection 1",
+            type: "numeric",
             termIds: ["agedx", "a_death", "a_ndi", "agelastvisit"],
             branchIds: ["Demographic Variables", "Age (years)"],
             propsByTermId: {}
           },
           {
             name: "Fake Collection 2",
+            type: "numeric",
             termIds: ["a_death", "a_ndi", "agelastvisit"],
             branchIds: ["Demographic Variables", "Age (years)"],
             propsByTermId: {}
+          },
+          {
+            name: "Assay Availability",
+            type: "categorical",
+            categoryKeys: [
+              { key: "1", shown: true },
+              { key: "2", shown: true }
+            ],
+            termIds: ["assayavailability_cnv", "assayavailability_fusion", "assayavailability_germline"],
+            branchIds: [""],
+            propsByTermId: {}
           }
         ]
       },
@@ -375,7 +388,11 @@ function termdb_test_default() {
       },
       dnaMethylation: {
         file: "files/hg38/TermdbTest/dnaMeth.h5",
-        unit: "Average Beta Value"
+        unit: "Average Beta Value",
+        promoter: {
+          file: "files/hg38/TermdbTest/dnaMethPromoterMvalue.h5",
+          unit: "M-value"
+        }
       },
       topVariablyExpressedGenes: {
         src: "native"
@@ -421,7 +438,7 @@ function termdb_test_default() {
         jsonFile: "files/hg38/TermdbTest/trackLst/facet.json",
         activeTracks: ["bw 1", "bed 1"]
       },
-      chat: {}
+      chat: { aifiles: "./proteinpaint/server/dataset/ai/termdb.test.json" }
     }
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sjcrh/proteinpaint-server",
-  "version": "2.177.1-0",
+  "version": "2.178.0",
   "type": "module",
   "description": "a genomics visualization tool for exploring a cohort's genotype and phenotype data",
   "main": "src/app.js",
@@ -62,11 +62,11 @@
   },
   "dependencies": {
     "@sjcrh/augen": "2.143.0",
-    "@sjcrh/proteinpaint-python": "2.177.1-0",
-    "@sjcrh/proteinpaint-r": "2.152.1-0",
-    "@sjcrh/proteinpaint-rust": "2.177.1-0",
-    "@sjcrh/proteinpaint-shared": "2.177.1-0",
-    "@sjcrh/proteinpaint-types": "2.177.1-0",
+    "@sjcrh/proteinpaint-python": "2.178.0",
+    "@sjcrh/proteinpaint-r": "2.178.0",
+    "@sjcrh/proteinpaint-rust": "2.178.0",
+    "@sjcrh/proteinpaint-shared": "2.178.0",
+    "@sjcrh/proteinpaint-types": "2.178.0",
     "@types/express": "^5.0.0",
     "@types/express-session": "^1.18.1",
     "better-sqlite3": "^12.4.1",

package/routes/grin2.js

@@ -8,6 +8,7 @@ import os from "os";
 import { get_samples } from "#src/termdb.sql.js";
 import { read_file, file_is_readable } from "#src/utils.js";
 import { dtsnvindel, dtcnv, dtfusionrna, dtsv, dt2lesion, optionToDt, formatElapsedTime } from "#shared";
+import { mayFilterByMaf } from "#src/mds3.init.js";
 import crypto from "crypto";
 import { promisify } from "node:util";
 import { exec as execCallback } from "node:child_process";
@@ -32,6 +33,7 @@ const api = {
 };
 function init({ genomes }) {
   return async (req, res) => {
+    const signal = req.query.__abortSignal;
     try {
       const request = req.query;
       const g = genomes[request.genome];
@@ -39,9 +41,13 @@ function init({ genomes }) {
       const ds = g.datasets?.[request.dslabel];
       if (!ds) throw new Error("ds missing");
       if (!ds.queries?.singleSampleMutation) throw new Error("singleSampleMutation query missing from dataset");
-      const result = await runGrin2WithLimit(g, ds, request);
+      const result = await runGrin2WithLimit(g, ds, request, signal);
       res.json(result);
     } catch (e) {
+      if (signal?.aborted) {
+        mayLog("[GRIN2] Analysis aborted due to client disconnect");
+        return;
+      }
       console.error("[GRIN2] Error stack:", e.stack);
       const errorResponse = {
         status: "error",
@@ -93,7 +99,7 @@ async function getMaxLesions() {
   return MAX_LESIONS;
 }
 let activeGrin2Jobs = 0;
-async function runGrin2WithLimit(g, ds, request) {
+async function runGrin2WithLimit(g, ds, request, signal) {
   if (activeGrin2Jobs >= GRIN2_CONCURRENCY_LIMIT) {
     const error = new Error(
       `GRIN2 analysis queue is full (${GRIN2_CONCURRENCY_LIMIT} concurrent analyses). Please try again in a few minutes.`
@@ -105,7 +111,7 @@ async function runGrin2WithLimit(g, ds, request) {
   activeGrin2Jobs++;
   mayLog(`[GRIN2] Starting analysis. Active jobs: ${activeGrin2Jobs}/${GRIN2_CONCURRENCY_LIMIT}`);
   try {
-    return await runGrin2(g, ds, request);
+    return await runGrin2(g, ds, request, signal);
   } finally {
     activeGrin2Jobs--;
     mayLog(`[GRIN2] Analysis complete. Active jobs: ${activeGrin2Jobs}/${GRIN2_CONCURRENCY_LIMIT}`);
@@ -136,7 +142,7 @@ function getCnvLesionType(isGain) {
   }
   return lesionType.lesionType;
 }
-async function runGrin2(g, ds, request) {
+async function runGrin2(g, ds, request, signal) {
   const startTime = Date.now();
   const samples = await get_samples(
     request,
@@ -176,7 +182,7 @@ async function runGrin2(g, ds, request) {
     pyInput.chromosomelist[c] = g.majorchr[c];
   }
   const grin2AnalysisStart = Date.now();
-  const pyResult = await run_python("grin2PpWrapper.py", JSON.stringify(pyInput));
+  const pyResult = await run_python("grin2PpWrapper.py", JSON.stringify(pyInput), { signal });
   if (pyResult.stderr?.trim()) {
     mayLog(`[GRIN2] Python stderr: ${pyResult.stderr}`);
     if (pyResult.stderr.includes("ERROR:")) {
@@ -201,7 +207,7 @@ async function runGrin2(g, ds, request) {
     bin_size: request.binSize
   };
   const manhattanPlotStart = Date.now();
-  const rsResult = await run_rust("manhattan_plot", JSON.stringify(rustInput));
+  const rsResult = await run_rust("manhattan_plot", JSON.stringify(rustInput), [], { signal });
   const manhattanPlotTime = Date.now() - manhattanPlotStart;
   mayLog(`[GRIN2] Manhattan plot generation took ${formatElapsedTime(manhattanPlotTime)}`);
   const manhattanPlotData = JSON.parse(rsResult);
@@ -431,6 +437,19 @@ function filterAndConvertSnvIndel(sampleName, entry, options) {
   if (!Number.isInteger(entry.pos)) {
     return null;
   }
+  if (options.mafFilter?.lst?.length) {
+    if (!Array.isArray(entry.vafs)) return null;
+    const copy = { dt: dtsnvindel };
+    for (const v of entry.vafs) {
+      copy[v.id] = v.refCount + "," + v.altCount;
+    }
+    try {
+      if (!mayFilterByMaf(options.mafFilter, copy)) return null;
+    } catch (e) {
+      mayLog("mayFilterByMaf() crashed on a snvindel " + (e instanceof Error ? e.message : String(e)));
+      return null;
+    }
+  }
   const start = entry.pos;
   const end = entry.pos;
   return [sampleName, entry.chr, start, end, dt2lesion[dtsnvindel].lesionTypes[0].lesionType];

package/routes/termdb.chat.js

@@ -2,6 +2,7 @@ import fs from "fs";
 import { ezFetch } from "#shared";
 import { get_samples } from "#src/termdb.sql.js";
 import { ChatPayload } from "#types/checkers";
+import { extractResourceResponse } from "./chat/resource.ts";
 import serverconfig from "../src/serverconfig.js";
 import { mayLog } from "#src/helpers.ts";
 import Database from "better-sqlite3";
@@ -143,8 +144,15 @@ async function run_chat_pipeline(user_prompt, llm, aiRoute, dataset_json, testin
   );
   let ai_output_json;
   mayLog("Time taken for classification:", formatElapsedTime(Date.now() - time1));
-  if (class_response.type == "html") {
-    ai_output_json = class_response;
+  if (class_response.type == "none") {
+    ai_output_json = {
+      type: "text",
+      text: "Your query does not appear to be related to the available data visualizations. Please try rephrasing your question."
+    };
+  } else if (class_response.type == "resource") {
+    const time12 = (/* @__PURE__ */ new Date()).valueOf();
+    ai_output_json = await extractResourceResponse(user_prompt, llm, dataset_json);
+    mayLog("Time taken for resource agent:", formatElapsedTime(Date.now() - time12));
   } else if (class_response.type == "plot") {
     const classResult = class_response.plot;
     mayLog("classResult:", classResult);
@@ -174,7 +182,7 @@ async function run_chat_pipeline(user_prompt, llm, aiRoute, dataset_json, testin
       );
       mayLog("Time taken for DE agent:", formatElapsedTime(Date.now() - time12));
     } else if (classResult == "survival") {
-      ai_output_json = { type: "html", html: "survival agent has not been implemented yet" };
+      ai_output_json = { type: "text", text: "survival agent has not been implemented yet" };
     } else if (classResult == "matrix") {
       const time12 = (/* @__PURE__ */ new Date()).valueOf();
       ai_output_json = await extract_matrix_search_terms_from_query(
@@ -200,13 +208,10 @@ async function run_chat_pipeline(user_prompt, llm, aiRoute, dataset_json, testin
       );
       mayLog("Time taken for sampleScatter agent:", formatElapsedTime(Date.now() - time12));
     } else {
-      ai_output_json = { type: "html", html: "Unknown classification value" };
+      ai_output_json = { type: "text", text: "Unknown classification value" };
     }
   } else {
-    ai_output_json = {
-      type: "html",
-      html: "Unknown classification type"
-    };
+    ai_output_json = { type: "text", text: "Unknown classification type" };
   }
   return ai_output_json;
 }

package/routes/termdb.chat2.js

@@ -0,0 +1,153 @@
+import { ChatPayload } from "#types/checkers";
+import { classifyQuery } from "./chat/classify1.ts";
+import { classifyNotPlot } from "./chat/classify2.ts";
+import { classifyPlotType } from "./chat/plot.ts";
+import { readJSONFile } from "./chat/utils.ts";
+import { extract_DE_search_terms_from_query } from "./chat/DEagent.ts";
+import { extract_summary_terms } from "./chat/summaryagent.ts";
+import { extract_matrix_search_terms_from_query } from "./chat/matrixagent.ts";
+import { extract_samplescatter_terms_from_query } from "./chat/samplescatteragent.ts";
+import { parse_dataset_db, parse_geneset_db, getGenesetNames } from "./chat/utils.ts";
+import serverconfig from "../src/serverconfig.js";
+import { mayLog } from "#src/helpers.ts";
+import { formatElapsedTime } from "#shared";
+const api = {
+  endpoint: "termdb/chat2",
+  methods: {
+    get: {
+      ...ChatPayload,
+      init
+    },
+    post: {
+      ...ChatPayload,
+      init
+    }
+  }
+};
+function init({ genomes }) {
+  return async (req, res) => {
+    const q = req.query;
+    try {
+      const g = genomes[q.genome];
+      if (!g) throw "invalid genome";
+      const ds = g.datasets?.[q.dslabel];
+      if (!ds) throw "invalid dslabel";
+      const serverconfig_ds_entries = serverconfig.genomes.find((genome) => genome.name == q.genome).datasets.find((dslabel) => dslabel.name == ds.label);
+      if (!serverconfig_ds_entries.aifiles) {
+        throw "aifiles are missing for chatbot to work";
+      }
+      const llm = serverconfig.llm;
+      if (!llm) throw "serverconfig.llm is not configured";
+      if (llm.provider !== "SJ" && llm.provider !== "ollama") {
+        throw "llm.provider must be 'SJ' or 'ollama'";
+      }
+      const dataset_db = serverconfig.tpmasterdir + "/" + ds.cohort.db.file;
+      const genedb = serverconfig.tpmasterdir + "/" + g.genedb.dbfile;
+      const aiFilesPath = serverconfig_ds_entries.aifiles;
+      const dataset_json = await readJSONFile(aiFilesPath);
+      const testing = false;
+      const genesetNames = getGenesetNames(g);
+      const ai_output_json = await run_chat_pipeline(
+        q.prompt,
+        llm,
+        serverconfig.aiRoute,
+        dataset_json,
+        testing,
+        dataset_db,
+        genedb,
+        ds,
+        genesetNames
+      );
+      res.send(ai_output_json);
+    } catch (e) {
+      if (e.stack) mayLog(e.stack);
+      res.send({ error: e?.message || e });
+    }
+  };
+}
+async function run_chat_pipeline(user_prompt, llm, aiRoute, dataset_json, testing, dataset_db, genedb, ds, genesetNames = []) {
+  const time1 = (/* @__PURE__ */ new Date()).valueOf();
+  const class_response = await classifyQuery(user_prompt, llm);
+  let ai_output_json;
+  mayLog("Time taken for classification:", formatElapsedTime(Date.now() - time1));
+  if (class_response.type == "notplot") {
+    const time2 = (/* @__PURE__ */ new Date()).valueOf();
+    const notPlotResult = await classifyNotPlot(user_prompt, llm, dataset_json);
+    mayLog("Time taken for classify2:", formatElapsedTime(Date.now() - time2));
+    if (notPlotResult.type == "html") {
+      ai_output_json = notPlotResult;
+    } else {
+      ai_output_json = {
+        type: "text",
+        text: "Your query does not appear to be related to the available data visualizations. Please try rephrasing your question."
+      };
+    }
+  } else if (class_response.type == "plot") {
+    const classResult = await classifyPlotType(user_prompt, llm);
+    mayLog("classResult:", classResult);
+    const dataset_db_output = await parse_dataset_db(dataset_db);
+    const genes_list = dataset_json.hasGeneExpression ? await parse_geneset_db(genedb) : [];
+    if (classResult == "summary") {
+      const time12 = (/* @__PURE__ */ new Date()).valueOf();
+      ai_output_json = await extract_summary_terms(
+        user_prompt,
+        llm,
+        dataset_db_output,
+        dataset_json,
+        genes_list,
+        ds,
+        testing,
+        genesetNames
+      );
+      mayLog("Time taken for summary agent:", formatElapsedTime(Date.now() - time12));
+    } else if (classResult == "dge") {
+      const time12 = (/* @__PURE__ */ new Date()).valueOf();
+      ai_output_json = await extract_DE_search_terms_from_query(
+        user_prompt,
+        llm,
+        dataset_db_output,
+        dataset_json,
+        ds,
+        testing
+      );
+      mayLog("Time taken for DE agent:", formatElapsedTime(Date.now() - time12));
+    } else if (classResult == "survival") {
+      ai_output_json = { type: "text", text: "survival agent has not been implemented yet" };
+    } else if (classResult == "matrix") {
+      const time12 = (/* @__PURE__ */ new Date()).valueOf();
+      ai_output_json = await extract_matrix_search_terms_from_query(
+        user_prompt,
+        llm,
+        dataset_db_output,
+        dataset_json,
+        genes_list,
+        ds,
+        testing,
+        genesetNames
+      );
+      mayLog("Time taken for matrix agent:", formatElapsedTime(Date.now() - time12));
+    } else if (classResult == "samplescatter") {
+      const time12 = (/* @__PURE__ */ new Date()).valueOf();
+      ai_output_json = await extract_samplescatter_terms_from_query(
+        user_prompt,
+        llm,
+        dataset_db_output,
+        dataset_json,
+        genes_list,
+        ds,
+        testing,
+        genesetNames
+      );
+      mayLog("Time taken for sampleScatter agent:", formatElapsedTime(Date.now() - time12));
+    } else {
+      ai_output_json = { type: "text", text: "Unknown classification value" };
+    }
+  } else {
+    ai_output_json = { type: "text", text: "Unknown classification type" };
+  }
+  return ai_output_json;
+}
+export {
+  api,
+  run_chat_pipeline
+};

package/routes/termdb.cluster.js

@@ -44,6 +44,13 @@ function init({ genomes }) {
         if (q.terms.length < 3)
           throw `A minimum of three genes is required for clustering. Please refresh this page to clear this error.`;
         result = await getResult(q, ds);
+      } else if (TermTypes.WHOLE_PROTEOME_ABUNDANCE == q.dataType) {
+        if (!ds.queries?.proteome?.whole) throw `no ${TermTypes.WHOLE_PROTEOME_ABUNDANCE} data on this dataset`;
+        if (!q.terms) throw `missing gene list`;
+        if (!Array.isArray(q.terms)) throw `gene list is not an array`;
+        if (q.terms.length < 3)
+          throw `A minimum of three genes is required for clustering. Please refresh this page to clear this error.`;
+        result = await getResult(q, ds);
       } else {
         throw "unknown q.dataType " + q.dataType;
       }
@@ -68,6 +75,9 @@ async function getResult(q, ds) {
   if (q.dataType == NUMERIC_DICTIONARY_TERM) {
     ;
     ({ term2sample2value, byTermId, bySampleId } = await getNumericDictTermAnnotation(q, ds));
+  } else if (q.dataType == TermTypes.WHOLE_PROTEOME_ABUNDANCE) {
+    ;
+    ({ term2sample2value, byTermId, bySampleId, skippedSexChrGenes } = await ds.queries.proteome.whole.get(_q, ds));
   } else {
     ;
     ({ term2sample2value, byTermId, bySampleId, skippedSexChrGenes } = await ds.queries[q.dataType].get(_q, ds));

package/routes/termdb.config.js

@@ -72,7 +72,7 @@ function make(q, req, res, ds, genome) {
   if (tdb.survival) c.survival = tdb.survival;
   if (tdb.regression) c.regression = tdb.regression;
   if (tdb.uiLabels) c.uiLabels = tdb.uiLabels;
-  if (tdb.numericTermCollections) c.numericTermCollections = tdb.numericTermCollections;
+  if (tdb.termCollections) c.termCollections = tdb.termCollections;
   if (ds.assayAvailability) c.assayAvailability = ds.assayAvailability;
   if (ds.cohort.correlationVolcano) c.correlationVolcano = ds.cohort.correlationVolcano;
   if (ds.cohort.boxplots) c.boxplots = ds.cohort.boxplots;
@@ -124,8 +124,8 @@ function addMatrixplots(c, ds) {
   });
 }
 function addMutationSignatureplots(c, ds) {
-  const mutationSignatureplots = ds.cohort.termdb.numericTermCollections?.find(
-    (ntc) => ntc.name == "Mutation Signature"
+  const mutationSignatureplots = ds.cohort.termdb.termCollections?.find(
+    (tc) => tc.name == "Mutation Signature" && tc.type === "numeric"
   )?.plots;
   if (!mutationSignatureplots) return;
   c.mutationSignatureplots = mutationSignatureplots.map((p) => {
@@ -191,6 +191,9 @@ function addNonDictionaryQueries(c, ds, genome) {
   }
   if (q.dnaMethylation) {
     q2.dnaMethylation = { unit: q.dnaMethylation.unit };
+    if (q.dnaMethylation.promoter) {
+      q2.dnaMethylation.promoter = { unit: q.dnaMethylation.promoter.unit };
+    }
   }
   if (q.ld) {
     q2.ld = structuredClone(q.ld);
@@ -251,6 +254,9 @@ function addNonDictionaryQueries(c, ds, genome) {
     if (q.singleCell.DEgenes) {
       q2.singleCell.DEgenes = { termId: q.singleCell.DEgenes.termId };
     }
+    if (q.singleCell?.terms?.length) {
+      c.scctTerms = q.singleCell.terms;
+    }
   }
   if (q.images) {
     q2.images = {};
@@ -266,9 +272,14 @@ function getAllowedTermTypes(ds) {
   }
   if (ds.queries?.geneExpression) typeSet.add(TermTypes.GENE_EXPRESSION);
   if (ds.queries?.metaboliteIntensity) typeSet.add(TermTypes.METABOLITE_INTENSITY);
+  if (ds.queries?.proteome?.whole) typeSet.add(TermTypes.WHOLE_PROTEOME_ABUNDANCE);
   if (ds.queries?.ssGSEA) typeSet.add(TermTypes.SSGSEA);
   if (ds.queries?.dnaMethylation) typeSet.add(TermTypes.DNA_METHYLATION);
-  if (ds.cohort.termdb.numericTermCollections) typeSet.add("termCollection");
+  if (ds.queries?.singleCell) {
+    typeSet.add(TermTypes.SINGLECELL_CELLTYPE);
+    if (ds.queries.singleCell?.geneExpression) typeSet.add(TermTypes.SINGLECELL_GENE_EXPRESSION);
+  }
+  if (ds.cohort.termdb.termCollections?.length) typeSet.add("termCollection");
   return [...typeSet];
 }
 function getSelectCohort(ds, req) {

package/routes/termdb.diffMeth.js

@@ -0,0 +1,180 @@
+import { diffMethPayload } from "#types/checkers";
+import { getData } from "../src/termdb.matrix.js";
+import { get_ds_tdb } from "../src/termdb.js";
+import { run_R } from "@sjcrh/proteinpaint-r";
+import { mayLog } from "#src/helpers.ts";
+import { formatElapsedTime } from "#shared";
+const api = {
+  endpoint: "termdb/diffMeth",
+  methods: {
+    get: {
+      ...diffMethPayload,
+      init
+    },
+    post: {
+      ...diffMethPayload,
+      init
+    }
+  }
+};
+function init({ genomes }) {
+  return async (req, res) => {
+    try {
+      const q = req.query;
+      const genome = genomes[q.genome];
+      if (!genome) throw new Error("invalid genome");
+      const [ds] = get_ds_tdb(genome, q);
+      let term_results = [];
+      if (q.tw) {
+        term_results = await getData({ filter: q.filter, filter0: q.filter0, terms: [q.tw] }, ds);
+        if (term_results.error) throw new Error(term_results.error);
+      }
+      let term_results2 = [];
+      if (q.tw2) {
+        term_results2 = await getData({ filter: q.filter, filter0: q.filter0, terms: [q.tw2] }, ds);
+        if (term_results2.error) throw new Error(term_results2.error);
+      }
+      const results = await run_diffMeth(req.query, ds, term_results, term_results2);
+      if (!results || !results.data) throw new Error("No data available");
+      res.send(results);
+    } catch (e) {
+      res.send({ status: "error", error: e.message || e });
+      if (e instanceof Error && e.stack) console.log(e);
+    }
+  };
+}
+async function run_diffMeth(param, ds, term_results, term_results2) {
+  if (param.samplelst?.groups?.length != 2) throw new Error(".samplelst.groups.length!=2");
+  if (param.samplelst.groups[0].values?.length < 1) throw new Error("samplelst.groups[0].values.length<1");
+  if (param.samplelst.groups[1].values?.length < 1) throw new Error("samplelst.groups[1].values.length<1");
+  const q = ds.queries.dnaMethylation?.promoter;
+  if (!q) throw new Error("ds.queries.dnaMethylation.promoter is not configured");
+  if (!q.file) throw new Error("ds.queries.dnaMethylation.promoter.file is missing");
+  const group1names = [];
+  const conf1_group1 = [];
+  const conf2_group1 = [];
+  for (const s of param.samplelst.groups[0].values) {
+    if (!Number.isInteger(s.sampleId)) continue;
+    const n = ds.cohort.termdb.q.id2sampleName(s.sampleId);
+    if (!n) continue;
+    if (!q.allSampleSet.has(n)) continue;
+    if (param.tw && param.tw2) {
+      if (term_results.samples[s.sampleId] && term_results2.samples[s.sampleId]) {
+        conf1_group1.push(
+          param.tw.q.mode == "continuous" ? term_results.samples[s.sampleId][param.tw.$id]["value"] : term_results.samples[s.sampleId][param.tw.$id]["key"]
+        );
+        conf2_group1.push(
+          param.tw2.q.mode == "continuous" ? term_results2.samples[s.sampleId][param.tw2.$id]["value"] : term_results2.samples[s.sampleId][param.tw2.$id]["key"]
+        );
+        group1names.push(n);
+      }
+    } else if (param.tw && !param.tw2) {
+      if (term_results.samples[s.sampleId]) {
+        conf1_group1.push(
+          param.tw.q.mode == "continuous" ? term_results.samples[s.sampleId][param.tw.$id]["value"] : term_results.samples[s.sampleId][param.tw.$id]["key"]
+        );
+        group1names.push(n);
+      }
+    } else if (!param.tw && param.tw2) {
+      if (term_results2.samples[s.sampleId]) {
+        conf2_group1.push(
+          param.tw2.q.mode == "continuous" ? term_results2.samples[s.sampleId][param.tw2.$id]["value"] : term_results2.samples[s.sampleId][param.tw2.$id]["key"]
+        );
+        group1names.push(n);
+      }
+    } else {
+      group1names.push(n);
+    }
+  }
+  const group2names = [];
+  const conf1_group2 = [];
+  const conf2_group2 = [];
+  for (const s of param.samplelst.groups[1].values) {
+    if (!Number.isInteger(s.sampleId)) continue;
+    const n = ds.cohort.termdb.q.id2sampleName(s.sampleId);
+    if (!n) continue;
+    if (!q.allSampleSet.has(n)) continue;
+    if (param.tw && param.tw2) {
+      if (term_results.samples[s.sampleId] && term_results2.samples[s.sampleId]) {
+        conf1_group2.push(
+          param.tw.q.mode == "continuous" ? term_results.samples[s.sampleId][param.tw.$id]["value"] : term_results.samples[s.sampleId][param.tw.$id]["key"]
+        );
+        conf2_group2.push(
+          param.tw2.q.mode == "continuous" ? term_results2.samples[s.sampleId][param.tw2.$id]["value"] : term_results2.samples[s.sampleId][param.tw2.$id]["key"]
+        );
+        group2names.push(n);
+      }
+    } else if (param.tw && !param.tw2) {
+      if (term_results.samples[s.sampleId]) {
+        conf1_group2.push(
+          param.tw.q.mode == "continuous" ? term_results.samples[s.sampleId][param.tw.$id]["value"] : term_results.samples[s.sampleId][param.tw.$id]["key"]
+        );
+        group2names.push(n);
+      }
+    } else if (!param.tw && param.tw2) {
+      if (term_results2.samples[s.sampleId]) {
+        conf2_group2.push(
+          param.tw2.q.mode == "continuous" ? term_results2.samples[s.sampleId][param.tw2.$id]["value"] : term_results2.samples[s.sampleId][param.tw2.$id]["key"]
+        );
+        group2names.push(n);
+      }
+    } else {
+      group2names.push(n);
+    }
+  }
+  const sample_size1 = group1names.length;
+  const sample_size2 = group2names.length;
+  const alerts = validateGroups(sample_size1, sample_size2, group1names, group2names);
+  if (param.preAnalysis) {
+    const group1Name = param.samplelst.groups[0].name;
+    const group2Name = param.samplelst.groups[1].name;
+    return {
+      data: {
+        [group1Name]: sample_size1,
+        [group2Name]: sample_size2,
+        ...alerts.length ? { alert: alerts.join(" | ") } : {}
+      }
+    };
+  }
+  if (alerts.length) throw new Error(alerts.join(" | "));
+  const diffMethInput = {
+    case: group2names.join(","),
+    control: group1names.join(","),
+    input_file: q.file,
+    min_samples_per_group: param.min_samples_per_group
+  };
+  if (param.tw) {
+    diffMethInput.conf1 = [...conf1_group2, ...conf1_group1];
+    diffMethInput.conf1_mode = param.tw.q.mode;
+    if (new Set(diffMethInput.conf1).size === 1) {
+      throw new Error("Confounding variable 1 has only one value");
+    }
+  }
+  if (param.tw2) {
+    diffMethInput.conf2 = [...conf2_group2, ...conf2_group1];
+    diffMethInput.conf2_mode = param.tw2.q.mode;
+    if (new Set(diffMethInput.conf2).size === 1) {
+      throw new Error("Confounding variable 2 has only one value");
+    }
+  }
+  const time1 = Date.now();
+  const result = JSON.parse(await run_R("diffMeth.R", JSON.stringify(diffMethInput)));
+  mayLog("Time taken to run diffMeth:", formatElapsedTime(Date.now() - time1));
+  const output = {
+    data: result.promoter_data,
+    sample_size1,
+    sample_size2
+  };
+  return output;
+}
+function validateGroups(sample_size1, sample_size2, group1names, group2names) {
+  const alerts = [];
+  if (sample_size1 < 1) alerts.push("sample size of group1 < 1");
+  if (sample_size2 < 1) alerts.push("sample size of group2 < 1");
+  const commonnames = group1names.filter((x) => group2names.includes(x));
+  if (commonnames.length) alerts.push(`Common elements found between both groups: ${commonnames.join(", ")}`);
+  return alerts;
+}
+export {
+  api
+};