@sjcrh/proteinpaint-server 2.186.0 → 2.188.0

package/routes/termdb.DE.js

@@ -5,7 +5,7 @@ import serverconfig from "../src/serverconfig.js";
 import { get_header_txt } from "#src/utils.js";
 import { run_rust } from "@sjcrh/proteinpaint-rust";
 import { renderVolcano } from "../src/renderVolcano.ts";
-import { readCacheFileOrRecompute, resolveDeContext, resolveSampleGroups } from "../src/diffAnalysis.ts";
+import { readCacheFileOrRecompute, resolveDaContext, resolveSampleGroups } from "../src/diffAnalysis.ts";
 const api = {
   endpoint: "termdb/DE",
   methods: {
@@ -24,7 +24,7 @@ function init({ genomes }) {
     try {
       const q = req.query;
       if (q.preAnalysis) {
-        const { ds, term_results, term_results2 } = await resolveDeContext(q, genomes);
+        const { ds, term_results, term_results2 } = await resolveDaContext(q, genomes);
         const groups = resolveSampleGroups(q, ds, term_results, term_results2);
         const group1Name = q.samplelst.groups[0].name;
         const group2Name = q.samplelst.groups[1].name;
@@ -37,20 +37,18 @@ function init({ genomes }) {
         });
         return;
       }
-      const { cacheId, geneData, sample_size1, sample_size2, method, images, bcv } = await readCacheFileOrRecompute({
-        daRequest: q,
-        genomes
-      });
-      const rendered = await renderVolcano(geneData, q.volcanoRender);
-      rendered.cacheId = cacheId;
+      const result = await readCacheFileOrRecompute({ daRequest: q, genomes });
+      if (result.kind !== "DE") throw new Error("expected DE result from readCacheFileOrRecompute");
+      const rendered = await renderVolcano(result.geneData, q.volcanoRender);
+      rendered.cacheId = result.cacheId;
       const output = {
         data: rendered,
-        sample_size1,
-        sample_size2,
-        method,
-        images
+        sample_size1: result.sample_size1,
+        sample_size2: result.sample_size2,
+        method: result.method,
+        images: result.images
       };
-      if (bcv != null) output.bcv = bcv;
+      if (result.bcv != null) output.bcv = result.bcv;
       res.send(output);
     } catch (e) {
       res.send({ status: "error", error: e.message || e });

package/routes/termdb.chat3.js

@@ -1,7 +1,7 @@
 import { ChatPayload } from "#types/checkers";
 import { mayLog } from "#src/helpers.ts";
 import { formatElapsedTime } from "#shared";
-import { readJSONFile, parse_geneset_db } from "./chat/utils.ts";
+import { readJSONFile, parse_geneset_db, getChatRelatedPlotTypes } from "./chat/utils.ts";
 import { classifyQuery } from "./chat/classify1.ts";
 import { classifyPlotType } from "./chat/plot.ts";
 import { classifyNotPlot } from "./chat/classify2.ts";
@@ -11,6 +11,7 @@ import { getDsAllowedTermTypes } from "./termdb.config.ts";
 import { phrase2entity } from "./chat/phrase2entity.ts";
 import { inferTermObjFromEntity } from "./chat/entity2termObj.ts";
 import { resolveToTwTvs } from "./chat/entity2twTvs.ts";
+import { answerDataQueries } from "./chat/dataQueries.ts";
 import path from "path";
 import fs from "fs";
 import { resolveToPlotState } from "./chat/scaffold2state.ts";
@@ -31,9 +32,9 @@ 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];
+      const genome = genomes[q.genome];
+      if (!genome) throw "invalid genome";
+      const ds = genome.datasets?.[q.dslabel];
       if (!ds) throw "invalid dslabel";
       const aiFilesDir = serverconfig.binpath + "/../../dataset/ai/" + q.dslabel;
       let agentFiles = [];
@@ -49,14 +50,24 @@ function init({ genomes }) {
       if (llm.provider !== "SJ" && llm.provider !== "ollama" && llm.provider !== "huggingface" && llm.provider !== "azure") {
         throw "llm.provider must be 'SJ', 'ollama', 'huggingface', or 'azure'";
       }
-      const rawFilter = typeof q.filter === "string" ? JSON.parse(q.filter) : q.filter;
+      let rawFilter;
+      if (typeof q.filter === "string") {
+        try {
+          rawFilter = JSON.parse(q.filter);
+        } catch (e) {
+          throw new Error("Failed to parse filter JSON string: " + e);
+        }
+      } else {
+        rawFilter = q.filter;
+      }
       const filter = rawFilter && typeof rawFilter === "object" ? rawFilter : {};
       const lst = Array.isArray(filter.lst) ? filter.lst : [];
       const cohortFilter = lst.find((item) => item.tag === "cohortFilter");
       const cohortKey = cohortFilter ? cohortFilter.tvs.values[0].key : "";
-      const supportedChartTypes = ds.cohort.termdb.q?.getSupportedChartTypes(req)?.[cohortKey];
-      const genedb = serverconfig.tpmasterdir + "/" + g.genedb.dbfile;
-      const _allowedTermTypes = getDsAllowedTermTypes(ds);
+      const supportedPlotTypes = ds.cohort.termdb.q?.getSupportedChartTypes(req)?.[cohortKey];
+      const chatSupportedPlotTypes = getChatRelatedPlotTypes(supportedPlotTypes);
+      const genedb = serverconfig.tpmasterdir + "/" + genome.genedb.dbfile;
+      const allowedTermTypes = getDsAllowedTermTypes(ds);
       const ai_output_json = await run_chat_pipeline(
         q.prompt,
         llm,
@@ -64,8 +75,9 @@ function init({ genomes }) {
         genedb,
         agentFiles,
         aiFilesDir,
-        supportedChartTypes,
-        _allowedTermTypes
+        chatSupportedPlotTypes,
+        allowedTermTypes,
+        genome
         // 	testing
       );
       mayLog("From init: Final AI output JSON:", JSON.stringify(ai_output_json));
@@ -76,19 +88,19 @@ function init({ genomes }) {
     }
   };
 }
-async function run_chat_pipeline(user_prompt, llm, ds, genedb, agentFiles, aiFilesDir, supportedChartTypes, _allowedTermTypes) {
+async function run_chat_pipeline(userPrompt, llm, ds, genedb, agentFiles, aiFilesDir, supportedPlotTypes, allowedTermTypes, genome) {
   if (!fs.existsSync(path.join(aiFilesDir, "main.json")))
     throw "Main data file is not specified for dataset:" + ds.label;
   const dataset_json = await readJSONFile(path.join(aiFilesDir, "main.json"));
   const time1 = (/* @__PURE__ */ new Date()).valueOf();
-  const class_response = await classifyQuery(user_prompt, llm);
+  const class_response = await classifyQuery(userPrompt, llm);
   mayLog("Time taken for classification:", formatElapsedTime(Date.now() - time1));
   let ai_output_json;
-  if (class_response.type == "notplot") {
+  if (class_response.type === "notplot") {
     const time2 = (/* @__PURE__ */ new Date()).valueOf();
-    const notPlotResult = await classifyNotPlot(user_prompt, llm, agentFiles, aiFilesDir);
+    const notPlotResult = await classifyNotPlot(userPrompt, llm, agentFiles, aiFilesDir);
     mayLog("Time taken for classify2:", formatElapsedTime(Date.now() - time2));
-    if (notPlotResult.type == "html") {
+    if (notPlotResult.type === "html") {
       ai_output_json = notPlotResult;
     } else {
       ai_output_json = {
@@ -96,70 +108,72 @@ async function run_chat_pipeline(user_prompt, llm, ds, genedb, agentFiles, aiFil
         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") {
+  } else if (class_response.type === "binaryQuery") {
+    const answer = await answerDataQueries(userPrompt, llm, allowedTermTypes);
+    if (!answer) throw "Couldn't decide if this is data related query!";
+    mayLog("Data Binary Query: ", answer);
+    ai_output_json = answer;
+  } else if (class_response.type === "plot") {
     let time = (/* @__PURE__ */ new Date()).valueOf();
-    const plotType = await classifyPlotType(user_prompt, llm);
+    const plotType = await classifyPlotType(userPrompt, llm);
     mayLog("Time taken to classify plot type:", formatElapsedTime(Date.now() - time));
-    if (!supportedChartTypes) {
-      const errorMsg = "Supported chart types list is undefined. Please check the dataset configuration and ensure 							  that getSupportedChartTypes is implemented correctly. Skipping chart type validation, but this may 							  lead to unsupported chart type errors downstream.";
-      console.warn(errorMsg);
-      const errorResponse = {
+    if (!supportedPlotTypes.includes(plotType)) {
+      const log = 'Plot type: "' + plotType + '" is not supported.';
+      ai_output_json = {
         type: "text",
-        text: errorMsg
+        text: log
       };
-      return errorResponse;
-    }
-    if (plotType === "summary") {
-      if (!supportedChartTypes.includes("dictionary")) {
-        const log = 'Plot type: "' + plotType + '" is not supported.';
-        ai_output_json = {
-          type: "text",
-          text: log
-        };
-        mayLog(log);
-        return ai_output_json;
-      }
-    } else if (plotType === "dge") {
-      if (!supportedChartTypes.includes("DA")) {
-        const log = 'Plot type: "' + plotType + '" is not supported.';
-        ai_output_json = {
-          type: "text",
-          text: log
-        };
-        mayLog(log);
-        return ai_output_json;
-      }
-    } else {
-      mayLog(`Supported chart types for this cohort: ${supportedChartTypes}`);
-      if (!supportedChartTypes.includes(plotType)) {
-        const log = 'Plot type: "' + plotType + '" is not supported.';
-        ai_output_json = {
-          type: "text",
-          text: log
-        };
-        mayLog(log);
-        return ai_output_json;
-      }
+      mayLog(log);
+      return ai_output_json;
     }
+    const genes_list = await parse_geneset_db(genedb);
+    mayLog("#################################################");
     mayLog("####### First phase: Infer Plot Scaffolds #######");
+    mayLog("#################################################");
     time = (/* @__PURE__ */ new Date()).valueOf();
-    const scaffoldResult = await inferScaffold(user_prompt, plotType, llm);
+    const dataset_db = serverconfig.tpmasterdir + "/" + ds.cohort.db.file;
+    const scaffoldResult = await inferScaffold(
+      userPrompt,
+      plotType,
+      llm,
+      genome,
+      genes_list,
+      allowedTermTypes,
+      dataset_json,
+      ds,
+      dataset_db
+    );
     mayLog("ScaffoldResult: ", scaffoldResult);
+    if (plotType === "hiercluster" && "plot" in scaffoldResult && scaffoldResult.type === "plot" || "text" in scaffoldResult && scaffoldResult.type === "text") {
+      return scaffoldResult;
+    }
     mayLog("Time taken to infer scaffold:", formatElapsedTime(Date.now() - time));
     if (!scaffoldResult)
       throw "Scaffold result is empty or undefined, which is unexpected. Please check the inferScaffold agent for potential issues.";
+    if ("type" in scaffoldResult && scaffoldResult.type === "text") {
+      return scaffoldResult;
+    }
     const subplotType = scaffoldResult.plotType === "summary" ? scaffoldResult.chartType : void 0;
+    mayLog("#################################################");
     mayLog("####### Second phase: From Scaffolds's phrases infer Entities #######");
-    const genes_list = await parse_geneset_db(genedb);
+    mayLog("#################################################");
     time = (/* @__PURE__ */ new Date()).valueOf();
-    const phrase2entityResult = await phrase2entity(scaffoldResult, plotType, llm, genes_list, dataset_json, ds);
+    const phrase2entityResult = await phrase2entity(
+      scaffoldResult,
+      plotType,
+      llm,
+      genes_list,
+      dataset_json,
+      ds
+    );
     mayLog("Time taken to phrase 2 entity:", formatElapsedTime(Date.now() - time));
     if ("type" in phrase2entityResult && phrase2entityResult.type === "text") {
       return phrase2entityResult;
     }
     mayLog(phrase2entityResult);
+    mayLog("#################################################");
     mayLog("####### Third phase: From Entities infer Term Objects #######");
-    const dataset_db = serverconfig.tpmasterdir + "/" + ds.cohort.db.file;
+    mayLog("#################################################");
     time = (/* @__PURE__ */ new Date()).valueOf();
     const termObj = await inferTermObjFromEntity(
       phrase2entityResult,
@@ -170,7 +184,9 @@ async function run_chat_pipeline(user_prompt, llm, ds, genedb, agentFiles, aiFil
     );
     mayLog("Time taken to infer term objects:", formatElapsedTime(Date.now() - time));
     mayLog("Inferred termObj from entity:", JSON.stringify(termObj));
+    mayLog("#################################################");
     mayLog("####### Fourth phase: From Term Objects to TwTvs Objects #######");
+    mayLog("#################################################");
     time = (/* @__PURE__ */ new Date()).valueOf();
     const twTvsObj = await resolveToTwTvs(termObj, plotType, llm, dataset_db);
     mayLog("Time taken to resolve to TwTvs object from termObj:", formatElapsedTime(Date.now() - time));
@@ -178,7 +194,9 @@ async function run_chat_pipeline(user_prompt, llm, ds, genedb, agentFiles, aiFil
       return twTvsObj;
     }
     mayLog("twTvsObj:", twTvsObj);
+    mayLog("#################################################");
     mayLog("####### Fifth/Final phase: From TwTvs Objects to Plot States #######");
+    mayLog("#################################################");
     time = (/* @__PURE__ */ new Date()).valueOf();
     ai_output_json = resolveToPlotState(twTvsObj, plotType, subplotType);
     mayLog("Time taken to resolve to plot state:", formatElapsedTime(Date.now() - time));

package/routes/termdb.cluster.js

@@ -83,7 +83,10 @@ async function getResult(q, ds) {
     ({ term2sample2value, byTermId, bySampleId } = await getNumericDictTermAnnotation(q, ds));
   } else if (q.dataType == PROTEOME_ABUNDANCE) {
     ;
-    ({ term2sample2value, byTermId, bySampleId, skippedSexChrGenes } = await ds.queries.proteome.get(_q));
+    ({ term2sample2value, byTermId, bySampleId, skippedSexChrGenes } = await ds.queries.proteome.get({
+      ..._q,
+      dataTypeDetails: _q.proteomeDetails
+    }));
   } else {
     ;
     ({ term2sample2value, byTermId, bySampleId, skippedSexChrGenes } = await ds.queries[q.dataType].get(_q, ds));

package/routes/termdb.config.js

@@ -203,6 +203,9 @@ function addNonDictionaryQueries(c, ds, genome) {
         if (orgSrc.overlayTerm) {
           q2.proteome.organisms[organism].overlayTerm = JSON.parse(JSON.stringify(orgSrc.overlayTerm));
         }
+        if (orgSrc.genomeName) {
+          q2.proteome.organisms[organism].genomeName = orgSrc.genomeName;
+        }
         if (orgSrc.assays) {
           q2.proteome.organisms[organism].assays = {};
           for (const assay in orgSrc.assays) {
@@ -222,6 +225,9 @@ function addNonDictionaryQueries(c, ds, genome) {
                     JSON.stringify(src.caseFilter)
                   );
                 }
+                if (src.DAPfile) {
+                  q2.proteome.organisms[organism].assays[assay].cohorts[cohort].DAPfile = true;
+                }
               }
             }
           }

package/routes/termdb.dapVolcano.js

@@ -0,0 +1,80 @@
+import path from "path";
+import fs from "fs/promises";
+import { dapVolcanoPayload } from "#types/checkers";
+import { get_ds_tdb } from "#src/termdb.js";
+import { renderVolcano } from "../src/renderVolcano.ts";
+import serverconfig from "../src/serverconfig.js";
+import { countDistinctSamples } from "./termdb.proteome.ts";
+const api = {
+  endpoint: "termdb/dapVolcano",
+  methods: {
+    get: {
+      ...dapVolcanoPayload,
+      init
+    },
+    post: {
+      ...dapVolcanoPayload,
+      init
+    }
+  }
+};
+function init({ genomes }) {
+  return async (req, res) => {
+    try {
+      const q = req.query;
+      const genome = genomes[q.genome];
+      if (!genome) throw "invalid genome";
+      const [ds] = get_ds_tdb(genome, q);
+      const proteomeConfig = ds.queries?.proteome;
+      if (!proteomeConfig) throw "proteome not configured for this dataset";
+      const organismConfig = proteomeConfig.organisms?.[q.organism];
+      if (!organismConfig) throw "invalid organism";
+      const assayConfig = organismConfig.assays?.[q.assay];
+      if (!assayConfig) throw "invalid assay";
+      const cohortConfig = assayConfig.cohorts?.[q.cohort];
+      if (!cohortConfig) throw "invalid cohort";
+      if (!cohortConfig.DAPfile) throw "DAP file not configured for this cohort";
+      const organismFilter = [{ columnIdx: organismConfig.columnIdx, columnValue: organismConfig.columnValue }];
+      const assayFilter = [{ columnIdx: assayConfig.columnIdx, columnValue: assayConfig.columnValue }];
+      const db = proteomeConfig.db;
+      const controlCount = countDistinctSamples(db, [...organismFilter, ...assayFilter, ...cohortConfig.controlFilter]);
+      const caseCount = countDistinctSamples(db, [...organismFilter, ...assayFilter, ...cohortConfig.caseFilter]);
+      if (q.countsOnly) {
+        res.send({ sample_size1: controlCount, sample_size2: caseCount });
+        return;
+      }
+      const filePath = path.join(serverconfig.tpmasterdir, cohortConfig.DAPfile);
+      const content = await fs.readFile(filePath, "utf8");
+      const lines = content.trim().split("\n");
+      const rustRows = [];
+      for (let i = 1; i < lines.length; i++) {
+        const parts = lines[i].split("	");
+        if (parts.length < 4) continue;
+        const fc = Number(parts[2]);
+        if (!Number.isFinite(fc)) continue;
+        const pValue = Number(parts[3]);
+        if (!Number.isFinite(pValue)) continue;
+        rustRows.push({
+          gene_name: parts[0],
+          gene: parts[1],
+          fold_change: fc,
+          original_p_value: pValue,
+          adjusted_p_value: pValue
+        });
+      }
+      const rendered = await renderVolcano(rustRows, q.volcanoRender);
+      for (const d of rendered.dots) delete d.adjusted_p_value;
+      res.send({
+        data: rendered,
+        sample_size1: controlCount,
+        sample_size2: caseCount
+      });
+    } catch (e) {
+      res.send({ status: "error", error: e.message || e });
+      if (e instanceof Error && e.stack) console.log(e);
+    }
+  };
+}
+export {
+  api
+};

package/routes/termdb.diffMeth.js

@@ -1,9 +1,6 @@
 import { diffMethPayload } from "#types/checkers";
-import { getData } from "../src/termdb.matrix.js";
-import { run_R } from "@sjcrh/proteinpaint-r";
-import { mayLog } from "#src/helpers.ts";
-import { formatElapsedTime } from "#shared";
 import { renderVolcano } from "../src/renderVolcano.ts";
+import { readCacheFileOrRecompute, resolveDaContext, resolveDmSampleGroups } from "../src/diffAnalysis.ts";
 const api = {
   endpoint: "termdb/diffMeth",
   methods: {
@@ -21,173 +18,38 @@ function init({ genomes }) {
   return async (req, res) => {
     try {
       const q = req.query;
-      const genome = genomes[q.genome];
-      if (!genome) throw "unknown genome";
-      const ds = genome.datasets?.[q.dslabel];
-      if (!ds) throw "unknown ds";
-      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(
-          "Differential methylation analysis returned no data. Please verify sample selections and try again."
-        );
-      if ("totalRows" in results.data && results.data.totalRows === 0)
+      if (q.preAnalysis) {
+        const { ds, term_results, term_results2 } = await resolveDaContext(q, genomes);
+        const groups = resolveDmSampleGroups(q, ds, term_results, term_results2);
+        const group1Name = q.samplelst.groups[0].name;
+        const group2Name = q.samplelst.groups[1].name;
+        res.send({
+          data: {
+            [group1Name]: groups.group1names.length,
+            [group2Name]: groups.group2names.length,
+            ...groups.alerts.length ? { alert: groups.alerts.join(" | ") } : {}
+          }
+        });
+        return;
+      }
+      const result = await readCacheFileOrRecompute({ daRequest: q, genomes });
+      if (result.kind !== "DM") throw new Error("expected DM result from readCacheFileOrRecompute");
+      const rendered = await renderVolcano(result.promoterData, q.volcanoRender);
+      rendered.cacheId = result.cacheId;
+      if (rendered.totalRows === 0)
         throw new Error("No promoters passed filtering. Try relaxing group criteria or selecting more samples.");
-      res.send(results);
+      const output = {
+        data: rendered,
+        sample_size1: result.sample_size1,
+        sample_size2: result.sample_size2
+      };
+      res.send(output);
     } 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("Exactly 2 sample groups are required for differential methylation analysis.");
-  if (param.samplelst.groups[0].values?.length < 1)
-    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 = ds.queries.dnaMethylation?.promoter;
-  if (!q) throw new Error("This dataset does not have promoter-level methylation data configured.");
-  if (!q.file) throw new Error("Promoter methylation data file is not configured for this dataset.");
-  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 rendered = await renderVolcano(result.promoter_data, param.volcanoRender);
-  const output = {
-    data: rendered,
-    sample_size1,
-    sample_size2
-  };
-  return output;
-}
-function validateGroups(sample_size1, sample_size2, group1names, group2names) {
-  const alerts = [];
-  if (sample_size1 < 1) alerts.push("No samples in group 1 have methylation data available.");
-  if (sample_size2 < 1) alerts.push("No samples in group 2 have methylation data available.");
-  const commonnames = group1names.filter((x) => group2names.includes(x));
-  if (commonnames.length)
-    alerts.push(
-      `${commonnames.length} sample(s) appear in both groups: ${commonnames.join(", ")}. Please remove duplicates.`
-    );
-  return alerts;
-}
 export {
   api
 };