@sjcrh/proteinpaint-server 2.183.2-0 → 2.184.1-0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sjcrh/proteinpaint-server",
-  "version": "2.183.2-0",
+  "version": "2.184.1-0",
   "type": "module",
   "description": "a genomics visualization tool for exploring a cohort's genotype and phenotype data",
   "main": "src/app.js",
@@ -66,7 +66,7 @@
     "@sjcrh/proteinpaint-r": "2.181.0",
     "@sjcrh/proteinpaint-rust": "2.183.0",
     "@sjcrh/proteinpaint-shared": "2.183.0",
-    "@sjcrh/proteinpaint-types": "2.183.1",
+    "@sjcrh/proteinpaint-types": "2.184.1-0",
     "@types/express": "^5.0.0",
     "@types/express-session": "^1.18.1",
     "better-sqlite3": "^12.4.1",

package/routes/profile.barchart2.js

@@ -0,0 +1,114 @@
+import { ProfileScoresPayload } from "#types/checkers";
+import { getData } from "../src/termdb.matrix.js";
+const api = {
+  endpoint: "termdb/profileBarchart2Scores",
+  methods: {
+    get: {
+      ...ProfileScoresPayload,
+      init
+    },
+    post: {
+      ...ProfileScoresPayload,
+      init
+    }
+  }
+};
+function init({ genomes }) {
+  return async (req, res) => {
+    try {
+      const g = genomes[req.query.genome];
+      if (!g) throw "invalid genome name";
+      const ds = g.datasets?.[req.query.dslabel];
+      const result = await getScores(req.query, ds);
+      res.send(result);
+    } catch (e) {
+      console.log(e);
+      res.send({ status: "error", error: e.message || e });
+    }
+  };
+}
+function derivePrefix(query) {
+  const firstScoreId = query.scoreTerms?.[0]?.score?.term?.id;
+  if (firstScoreId?.startsWith("F")) return "F";
+  if (firstScoreId?.startsWith("A")) return "A";
+  for (const entry of query.filter?.lst || []) {
+    const id = entry.tvs?.term?.id;
+    if (id?.startsWith("F")) return "F";
+    if (id?.startsWith("A")) return "A";
+  }
+  throw "cannot determine cohort prefix from scoreTerms or filter term IDs";
+}
+async function getScores(query, ds) {
+  const { activeCohort, clientAuthResult } = query.__protected__;
+  const prefix = derivePrefix(query);
+  const facilityTermId = `${prefix}UNIT`;
+  const facilityTW = { term: { id: facilityTermId }, q: {} };
+  const terms = [facilityTW];
+  for (const t of query.scoreTerms) {
+    terms.push(t.score);
+    if (t.maxScore?.term) terms.push(t.maxScore);
+  }
+  if (!query.filterByUserSites) {
+    query.__protected__.ignoredTermIds.push(facilityTermId);
+  }
+  const cohortAuth = clientAuthResult[activeCohort];
+  const isPublic = !cohortAuth?.role || cohortAuth.role === "public";
+  const userSites = cohortAuth?.sites;
+  const raw = await getData(
+    {
+      terms,
+      filter: query.filter,
+      __protected__: query.__protected__
+    },
+    ds
+  );
+  if (raw.error) throw raw.error;
+  const sampleList = Object.values(raw.samples);
+  let sites = sampleList.map((s) => {
+    const val = s[facilityTW.$id].value;
+    let label = facilityTW.term.values?.[val]?.label || val;
+    if (label.length > 50) label = label.slice(0, 47) + "...";
+    return { value: val, label };
+  });
+  if (userSites && query.filterByUserSites) {
+    sites = sites.filter((s) => userSites.includes(s.value));
+  }
+  sites.sort((a, b) => a.label.localeCompare(b.label));
+  const samples = Object.values(raw.samples);
+  const eligibleSamples = userSites && query.filterByUserSites ? samples.filter((s) => userSites.includes(s[facilityTW.$id].value)) : samples;
+  const term2Score = {};
+  for (const d of query.scoreTerms) {
+    const score = computeMedianPercentage(d, eligibleSamples);
+    if (score !== null) term2Score[d.score.term.id] = score;
+  }
+  return {
+    term2Score,
+    // Public users see only aggregated scores — do not expose site IDs or names
+    sites: isPublic ? [] : sites,
+    n: eligibleSamples.length
+  };
+}
+function computeMedianPercentage(d, samples) {
+  const percentages = [];
+  for (const s of samples) {
+    const scoreValue = s[d.score.$id]?.value;
+    if (scoreValue == null) continue;
+    let maxScoreValue = null;
+    if (typeof d.maxScore === "number") {
+      maxScoreValue = d.maxScore;
+    } else {
+      maxScoreValue = s[d.maxScore.$id]?.value;
+    }
+    if (maxScoreValue == null || maxScoreValue === 0) continue;
+    const percentage = scoreValue / maxScoreValue * 100;
+    percentages.push(percentage);
+  }
+  if (percentages.length === 0) return null;
+  percentages.sort((a, b) => a - b);
+  const mid = Math.floor(percentages.length / 2);
+  const median = percentages.length % 2 !== 0 ? percentages[mid] : (percentages[mid - 1] + percentages[mid]) / 2;
+  return Math.round(median);
+}
+export {
+  api
+};

package/routes/termdb.chat3.js

@@ -0,0 +1,191 @@
+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 { classifyQuery } from "./chat/classify1.ts";
+import { classifyPlotType } from "./chat/plot.ts";
+import { classifyNotPlot } from "./chat/classify2.ts";
+import { inferScaffold } from "./chat/scaffold.ts";
+import serverconfig from "../src/serverconfig.js";
+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 path from "path";
+import fs from "fs";
+import { resolveToPlotState } from "./chat/scaffold2state.ts";
+const api = {
+  endpoint: "termdb/chat3",
+  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 aiFilesDir = serverconfig.binpath + "/../../dataset/ai/" + q.dslabel;
+      let agentFiles = [];
+      try {
+        agentFiles = await fs.readdirSync(aiFilesDir).filter((file) => file.endsWith(".json"));
+      } catch (err) {
+        if (err.code === "ENOENT") throw new Error(`Directory not found: ${aiFilesDir}`);
+        if (err.code === "ENOTDIR") throw new Error(`Path is not a directory: ${aiFilesDir}`);
+        throw err;
+      }
+      const llm = serverconfig.llm;
+      if (!llm) throw "serverconfig.llm is not configured";
+      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;
+      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 ai_output_json = await run_chat_pipeline(
+        q.prompt,
+        llm,
+        ds,
+        genedb,
+        agentFiles,
+        aiFilesDir,
+        supportedChartTypes,
+        _allowedTermTypes
+        // 	testing
+      );
+      mayLog("From init: Final AI output JSON:", JSON.stringify(ai_output_json));
+      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, ds, genedb, agentFiles, aiFilesDir, supportedChartTypes, _allowedTermTypes) {
+  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);
+  mayLog("Time taken for classification:", formatElapsedTime(Date.now() - time1));
+  let ai_output_json;
+  if (class_response.type == "notplot") {
+    const time2 = (/* @__PURE__ */ new Date()).valueOf();
+    const notPlotResult = await classifyNotPlot(user_prompt, llm, agentFiles, aiFilesDir);
+    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") {
+    let time = (/* @__PURE__ */ new Date()).valueOf();
+    const plotType = await classifyPlotType(user_prompt, 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 = {
+        type: "text",
+        text: errorMsg
+      };
+      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("####### First phase: Infer Plot Scaffolds #######");
+    time = (/* @__PURE__ */ new Date()).valueOf();
+    const scaffoldResult = await inferScaffold(user_prompt, plotType, llm);
+    mayLog("ScaffoldResult: ", 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.";
+    const subplotType = scaffoldResult.plotType === "summary" ? scaffoldResult.chartType : void 0;
+    mayLog("####### Second phase: From Scaffolds's phrases infer Entities #######");
+    const genes_list = await parse_geneset_db(genedb);
+    time = (/* @__PURE__ */ new Date()).valueOf();
+    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("####### Third phase: From Entities infer Term Objects #######");
+    const dataset_db = serverconfig.tpmasterdir + "/" + ds.cohort.db.file;
+    time = (/* @__PURE__ */ new Date()).valueOf();
+    const termObj = await inferTermObjFromEntity(
+      phrase2entityResult,
+      plotType,
+      llm,
+      dataset_db,
+      genes_list
+    );
+    mayLog("Time taken to infer term objects:", formatElapsedTime(Date.now() - time));
+    mayLog("Inferred termObj from entity:", JSON.stringify(termObj));
+    mayLog("####### Fourth phase: From Term Objects to TwTvs Objects #######");
+    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));
+    if ("type" in twTvsObj && twTvsObj.type === "text") {
+      return twTvsObj;
+    }
+    mayLog("twTvsObj:", twTvsObj);
+    mayLog("####### Fifth/Final phase: From TwTvs Objects to Plot States #######");
+    time = (/* @__PURE__ */ new Date()).valueOf();
+    ai_output_json = resolveToPlotState(twTvsObj, plotType, subplotType);
+    mayLog("Time taken to resolve to plot state:", formatElapsedTime(Date.now() - time));
+  }
+  return ai_output_json;
+}
+export {
+  api,
+  run_chat_pipeline
+};

package/routes/termdb.config.js

@@ -47,7 +47,7 @@ function make(q, req, res, ds, genome) {
     selectCohort: getSelectCohort(ds, req),
     supportedChartTypes: tdb.q?.getSupportedChartTypes(req),
     renamedChartTypes: ds.cohort.renamedChartTypes,
-    allowedTermTypes: getAllowedTermTypes(ds),
+    allowedTermTypes: getDsAllowedTermTypes(ds),
     massSessionDuration: serverconfig.features.massSessionDuration || 30,
     dataDownloadCatch: tdb.dataDownloadCatch,
     matrix: tdb.matrix,
@@ -194,6 +194,9 @@ function addNonDictionaryQueries(c, ds, genome) {
   }
   if (q.proteome) {
     q2.proteome = {};
+    if (q.proteome.overlayTerm) {
+      q2.proteome.overlayTerm = JSON.parse(JSON.stringify(q.proteome.overlayTerm));
+    }
     if (q.proteome.assays) {
       q2.proteome.assays = {};
       for (const assay in q.proteome.assays) {
@@ -203,11 +206,11 @@ function addNonDictionaryQueries(c, ds, genome) {
           for (const cohort in q.proteome.assays[assay].cohorts) {
             q2.proteome.assays[assay].cohorts[cohort] = {};
             const src = q.proteome.assays[assay].cohorts[cohort];
-            if ("filter" in src) {
-              q2.proteome.assays[assay].cohorts[cohort].filter = JSON.parse(JSON.stringify(src.filter));
+            if ("controlFilter" in src) {
+              q2.proteome.assays[assay].cohorts[cohort].controlFilter = JSON.parse(JSON.stringify(src.controlFilter));
             }
-            if ("overlayTerm" in src) {
-              q2.proteome.assays[assay].cohorts[cohort].overlayTerm = JSON.parse(JSON.stringify(src.overlayTerm));
+            if ("caseFilter" in src) {
+              q2.proteome.assays[assay].cohorts[cohort].caseFilter = JSON.parse(JSON.stringify(src.caseFilter));
             }
           }
         }
@@ -290,7 +293,7 @@ function addNonDictionaryQueries(c, ds, genome) {
     q2.images = {};
   }
 }
-function getAllowedTermTypes(ds) {
+function getDsAllowedTermTypes(ds) {
   const typeSet = /* @__PURE__ */ new Set();
   for (const r of ds.cohort.termdb.termtypeByCohort) {
     if (r.termType) typeSet.add(r.termType);
@@ -326,5 +329,6 @@ function getSelectCohort(ds, req) {
   return copy;
 }
 export {
-  api
+  api,
+  getDsAllowedTermTypes
 };

package/routes/termdb.proteome.js

@@ -28,16 +28,11 @@ function init({ genomes }) {
       const cohorts = [];
       for (const assayName in ds.queries.proteome.assays) {
         const assay = ds.queries.proteome.assays[assayName];
-        for (const cohort of assay.cohorts) {
+        for (const cohortName in assay.cohorts || {}) {
           const details = {
             dbfile: ds.queries.proteome.dbfile,
-            assayName,
-            cohortName: cohort.cohortName,
-            cohortControlFilter: cohort.controlFilter,
-            cohortCaseFilter: cohort.caseFilter,
-            PTMType: assay.PTMType,
-            assayColumnIdx: assay.columnIdx,
-            assayColumnValue: assay.columnValue
+            assay: assayName,
+            cohort: cohortName
           };
           const tw = {
             $id: "_",
@@ -214,16 +209,14 @@ async function validate_query_proteome(ds) {
   }
   for (const assayName in q.assays) {
     const assay = q.assays[assayName];
-    if (!assay.columnIdx) throw `queries.proteome.assays.${assayName}.columnIdx missing`;
-    if (!assay.columnValue) throw `queries.proteome.assays.${assayName}.columnValue missing`;
+    if (assay.columnIdx == null) throw `queries.proteome.assays.${assayName}.columnIdx missing`;
+    if (assay.columnValue == null) throw `queries.proteome.assays.${assayName}.columnValue missing`;
     if (assay.cohorts) {
-      console.log(`Validating assay "${assayName}" with multiple cohorts`);
-      for (const cohort of assay.cohorts) {
-        if (!cohort.cohortName) throw `Missing cohortName in queries.proteome.assays.${assayName}.cohorts`;
+      for (const cohortName in assay.cohorts) {
+        const cohort = assay.cohorts[cohortName];
         if (!cohort.controlFilter)
-          throw `Missing controlFilter in queries.proteome.assays.${assayName}.cohorts.${cohort.cohortName}`;
-        if (!cohort.caseFilter)
-          throw `Missing caseFilter in queries.proteome.assays.${assayName}.cohorts.${cohort.cohortName}`;
+          throw `Missing controlFilter in queries.proteome.assays.${assayName}.cohorts.${cohortName}`;
+        if (!cohort.caseFilter) throw `Missing caseFilter in queries.proteome.assays.${assayName}.cohorts.${cohortName}`;
       }
     } else {
       throw `Invalid assay structure for "${assayName}". Must have .cohorts`;
@@ -232,15 +225,56 @@ async function validate_query_proteome(ds) {
   q.find = async (arg) => {
     const proteins = arg?.proteins;
     if (!Array.isArray(proteins) || proteins.length == 0) throw "queries.proteome.find arg.proteins[] missing";
-    return findProteinsInCohort(q.db, proteins);
+    const matches = /* @__PURE__ */ new Set();
+    const details = arg?.proteomeDetails || {};
+    const assay = details.assay;
+    const cohort = details.cohort;
+    const MAX_FIND_RESULTS = 500;
+    const filters = [];
+    if (Object.keys(details).length) {
+      if (!assay || !cohort) throw "queries.proteome.find arg.proteomeDetails.{assay,cohort} missing";
+      const assayConfig = q.assays?.[assay];
+      if (!assayConfig) throw `queries.proteome.find invalid assay: ${assay}`;
+      const cohortConfig = assayConfig?.cohorts?.[cohort];
+      if (!cohortConfig) throw `queries.proteome.find invalid cohort: ${cohort}`;
+      const assayFilter = [{ columnIdx: assayConfig.columnIdx, columnValue: assayConfig.columnValue }];
+      const cohortFilter = (Array.isArray(cohortConfig.caseFilter) ? cohortConfig.caseFilter : []).filter(
+        (filter) => !!filter
+      );
+      if (!cohortFilter.length) throw `queries.proteome.find invalid cohort caseFilter: ${cohort}`;
+      filters.push(...assayFilter, ...cohortFilter);
+    }
+    for (const p of proteins) {
+      if (!p) continue;
+      const token = String(p).trim();
+      if (token.length < 2) continue;
+      const upperToken = `${token}\uFFFF`;
+      const rawRows = [];
+      if (filters?.length) {
+        const { conditions, params } = buildFilterClause(filters);
+        const sql = `SELECT DISTINCT gene, identifier FROM proteome_abundance WHERE gene >= ? COLLATE NOCASE AND gene < ? COLLATE NOCASE AND ${conditions.join(
+          " AND "
+        )} LIMIT ${MAX_FIND_RESULTS}`;
+        rawRows.push(...q.db.prepare(sql).all(token, upperToken, ...params));
+      } else {
+        rawRows.push(
+          ...q.db.prepare(
+            `SELECT DISTINCT gene, identifier FROM proteome_abundance WHERE gene >= ? COLLATE NOCASE AND gene < ? COLLATE NOCASE LIMIT ${MAX_FIND_RESULTS}`
+          ).all(token, upperToken)
+        );
+      }
+      for (const row of rawRows) {
+        if (!row?.gene || !row?.identifier) continue;
+        matches.add(`${row.gene}: ${row.identifier}`);
+      }
+    }
+    return [...matches];
   };
   q.get = async (param) => {
     if (!param?.terms?.length) throw "queries.proteome.get param.terms[] missing";
-    if (!param.proteomeDetails?.assayName || !param.proteomeDetails?.cohortName)
-      throw "queries.proteome.get param.proteomeDetails.{assayName,cohortName} missing";
-    if (!param.proteomeDetails?.cohortControlFilter || !param.proteomeDetails?.cohortCaseFilter || !param.proteomeDetails?.assayColumnIdx || !param.proteomeDetails?.assayColumnValue)
-      throw "queries.proteome.get param.proteomeDetails.{cohortControlFilter, cohortCaseFilter, assayColumnIdx, assayColumnValue} missing";
-    return await getProteomeValuesFromCohort(ds, param);
+    if (!param.proteomeDetails?.assay || !param.proteomeDetails?.cohort)
+      throw "queries.proteome.get param.proteomeDetails.{assay,cohort} missing";
+    return await getProteomeValuesFromCohort(ds, param, q);
   };
 }
 const columnIdxToName = {
@@ -267,32 +301,26 @@ function buildFilterClause(filters) {
   }
   return { conditions, params };
 }
-function findProteinsInCohort(db, proteins) {
-  const matches = [];
-  for (const p of proteins) {
-    if (!p) continue;
-    const rows = db.prepare("SELECT DISTINCT gene, identifier FROM proteome_abundance WHERE gene LIKE ? COLLATE NOCASE").all(`%${p}%`);
-    for (const row of rows) {
-      if (row.gene.toLowerCase().includes(p.toLowerCase())) {
-        matches.push(`${row.gene}: ${row.identifier}`);
-      }
-    }
-  }
-  return matches;
-}
 function queryDbRows(db, matchColumn, matchValue, filters) {
-  console.log(`Querying DB for ${matchColumn}=${matchValue} with filters:`, filters);
   const { conditions, params } = buildFilterClause(filters);
   const allConditions = [`${matchColumn} = ? COLLATE NOCASE`, ...conditions];
-  const sql = `SELECT identifier, protein_accession, modsite, gene, sample, value
+  const sql = `SELECT identifier, protein_accession, isoform, modsite, gene, sample, value
 		FROM proteome_abundance
 		WHERE ${allConditions.join(" AND ")}`;
-  console.log("Executing SQL:", sql);
   return db.prepare(sql).all(matchValue, ...params);
 }
-async function getProteomeValuesFromCohort(ds, param) {
+async function getProteomeValuesFromCohort(ds, param, q) {
   const db = ds.queries.proteome.db;
-  const { assayName, cohortName, PTMType, cohortControlFilter, cohortCaseFilter, assayColumnIdx, assayColumnValue } = param.proteomeDetails;
+  const { assay, cohort } = param.proteomeDetails;
+  const assayConfig = q.assays?.[assay];
+  if (!assayConfig) throw `queries.proteome.get invalid assay: ${assay}`;
+  const PTMType = q.assays[assay].PTMType;
+  const assayColumnIdx = assayConfig.columnIdx;
+  const assayColumnValue = assayConfig.columnValue;
+  const cohortConfig = assayConfig?.cohorts?.[cohort];
+  if (!cohortConfig) throw `queries.proteome.get invalid cohort: ${cohort}`;
+  const cohortControlFilter = cohortConfig.controlFilter;
+  const cohortCaseFilter = cohortConfig.caseFilter;
   const assayFilter = [{ columnIdx: assayColumnIdx, columnValue: assayColumnValue }];
   const term2sample2value = /* @__PURE__ */ new Map();
   const allEntries = [];
@@ -336,11 +364,13 @@ async function getProteomeValuesFromCohort(ds, param) {
         if (!entryMap.has(row.identifier)) {
           entryMap.set(row.identifier, {
             uniqueIdentifier: row.identifier,
-            assayName,
-            cohortName,
+            assayName: assay,
+            cohortName: cohort,
             PTMType,
             modSites: PTMType ? row.modsite || void 0 : void 0,
             proteinAccession: row.protein_accession,
+            isoform: row.isoform,
+            // refSeq transcript ID mapped from protein_accession
             geneName: row.gene,
             s2v: {}
           });