@sjcrh/proteinpaint-server 2.177.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: {}
           }
         ]
       },
@@ -373,6 +386,14 @@ function termdb_test_default() {
       ssGSEA: {
         file: "files/hg38/TermdbTest/rnaseq/TermdbTest.ssgsea.h5"
       },
+      dnaMethylation: {
+        file: "files/hg38/TermdbTest/dnaMeth.h5",
+        unit: "Average Beta Value",
+        promoter: {
+          file: "files/hg38/TermdbTest/dnaMethPromoterMvalue.h5",
+          unit: "M-value"
+        }
+      },
       topVariablyExpressedGenes: {
         src: "native"
       },
@@ -417,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.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.174.0",
-    "@sjcrh/proteinpaint-r": "2.152.1-0",
-    "@sjcrh/proteinpaint-rust": "2.177.0",
-    "@sjcrh/proteinpaint-shared": "2.177.0",
-    "@sjcrh/proteinpaint-types": "2.177.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;
 }
@@ -870,28 +875,72 @@ function removeLastOccurrence(str, word) {
     return str.slice(0, index) + str.slice(index + word.length);
   }
 }
+function sortSameCategoricalFilterKeys(filters, ds) {
+  let html = "";
+  const keys = filters.map((f) => f.term);
+  if (new Set(keys).size == keys.length) return { filters, html };
+  const seen = /* @__PURE__ */ new Set();
+  const categorical_filter_terms_with_multiple_fields = /* @__PURE__ */ new Set();
+  for (const item of filters) {
+    if (seen.has(item.term)) categorical_filter_terms_with_multiple_fields.add(item.term);
+    else seen.add(item.term);
+  }
+  const multiple_fields_keys = [];
+  for (const key of categorical_filter_terms_with_multiple_fields) {
+    const term = ds.cohort.termdb.q.termjsonByOneid(key);
+    if (!term) {
+      html += "invalid filter id:" + key;
+    } else {
+      if (term.type == "categorical") {
+        const multiple_fields = filters.filter((x) => x.term == key);
+        multiple_fields_keys.push({ key, categories: multiple_fields.map((f) => f.category) });
+      }
+    }
+  }
+  const sorted_filter = [];
+  const seen2 = /* @__PURE__ */ new Set();
+  for (const f of filters) {
+    const repeated_term = multiple_fields_keys.find((x) => x.key == f.term);
+    if (!repeated_term) {
+      sorted_filter.push(f);
+    } else {
+      if (!seen2.has(f.term)) {
+        const new_filter_term = {
+          term: f.term,
+          category: repeated_term.categories
+        };
+        seen2.add(f.term);
+        sorted_filter.push(new_filter_term);
+      }
+    }
+  }
+  return { filters: sorted_filter, html };
+}
 function validate_filter(filters, ds, group_name) {
   if (!Array.isArray(filters)) throw "filter is not array";
-  let filter_result = { html: "" };
-  if (filters.length <= 2) {
-    filter_result = generate_filter_term(filters, ds);
+  const sorted_filters = sortSameCategoricalFilterKeys(filters, ds);
+  let filter_result = { html: sorted_filters.html };
+  if (sorted_filters.filters.length <= 2) {
+    const generated = generate_filter_term(sorted_filters.filters, ds);
+    filter_result.simplefilter = generated.simplefilter;
+    filter_result.html += generated.html;
   } else {
-    if (filters.length > num_filter_cutoff) {
-      filter_result.html = "For now, the maximum number of filter terms supported through the chatbot is " + num_filter_cutoff;
+    if (sorted_filters.filters.length > num_filter_cutoff) {
+      filter_result.html += "For now, the maximum number of filter terms supported through the chatbot is " + num_filter_cutoff;
       if (group_name.length > 0) {
-        filter_result.html += " . The number of filter terms for group " + group_name + " is " + filters.length + "\n";
+        filter_result.html += " . The number of filter terms for group " + group_name + " is " + sorted_filters.filters.length + "\n";
       } else {
-        filter_result.html += "The number of filter terms for this query is " + filters.length;
+        filter_result.html += "The number of filter terms for this query is " + sorted_filters.filters.length;
       }
     } else {
-      for (let i = 0; i < filters.length - 1; i++) {
+      for (let i = 0; i < sorted_filters.filters.length - 1; i++) {
         const filter_lst = [];
         if (i == 0) {
-          filter_lst.push(filters[i]);
+          filter_lst.push(sorted_filters.filters[i]);
         } else {
           filter_lst.push(filter_result.simplefilter);
         }
-        filter_lst.push(filters[i + 1]);
+        filter_lst.push(sorted_filters.filters[i + 1]);
         filter_result = generate_filter_term(filter_lst, ds);
       }
     }
@@ -913,19 +962,35 @@ function generate_filter_term(filters, ds) {
           localfilter.join = f.join;
         }
         if (term.type == "categorical") {
-          let cat;
-          for (const ck in term.values) {
-            if (ck == f.category) cat = ck;
-            else if (term.values[ck].label == f.category) cat = ck;
-          }
-          if (!cat) invalid_html += "invalid category from " + JSON.stringify(f);
-          localfilter.lst.push({
-            type: "tvs",
-            tvs: {
-              term,
-              values: [{ key: cat }]
+          if (Array.isArray(f.category)) {
+            const categories = [];
+            for (const category of f.category) {
+              const cat = findCategoryKey(term.values, category);
+              if (!cat) invalid_html += "invalid category from " + JSON.stringify(f);
+              else {
+                categories.push({ key: cat });
+              }
+            }
+            localfilter.lst.push({
+              type: "tvs",
+              tvs: {
+                term,
+                values: categories
+              }
+            });
+          } else {
+            const cat = findCategoryKey(term.values, f.category);
+            if (!cat) invalid_html += "invalid category from " + JSON.stringify(f);
+            else {
+              localfilter.lst.push({
+                type: "tvs",
+                tvs: {
+                  term,
+                  values: [{ key: cat }]
+                }
+              });
             }
-          });
+          }
         } else if (term.type == "float" || term.type == "integer") {
           const numeric = {
             type: "tvs",
@@ -958,6 +1023,12 @@ function generate_filter_term(filters, ds) {
   }
   return { simplefilter: localfilter, html: invalid_html };
 }
+function findCategoryKey(termValues, category) {
+  for (const ck in termValues) {
+    if (ck === category || termValues[ck].label === category) return ck;
+  }
+  return void 0;
+}
 async function parse_geneset_db(genedb) {
   let genes_list = [];
   const db = new Database(genedb);

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) => {
@@ -189,6 +189,12 @@ function addNonDictionaryQueries(c, ds, genome) {
   if (q.geneExpression) {
     q2.geneExpression = { unit: q.geneExpression.unit };
   }
+  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);
   }
@@ -248,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 = {};
@@ -263,8 +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.cohort.termdb.numericTermCollections) typeSet.add("termCollection");
+  if (ds.queries?.dnaMethylation) typeSet.add(TermTypes.DNA_METHYLATION);
+  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) {