@sjcrh/proteinpaint-server 2.216.1 → 2.217.1-0

package/src/serverconfig.js

@@ -7,6 +7,7 @@ import fs from 'fs'
 import os from 'os'
 import path from 'path'
 import { fileURLToPath } from 'url'
+import crypto from 'crypto'
 
 // import.meta.dirname is undefined when using docker dev environment
 // use __dirname and __filename global variable convention from commonjs
@@ -364,6 +365,128 @@ if (process.env.PP_MODE?.startsWith('container')) {
 	})
 }
 
+/*
+	The key for deriving the cache file names and the cachedir subdir name, kept module-local, not in serverconfig,
+	so that it is never part of a config dump or a response.
+
+	Set PP_CACHEID_CREDS to the same value on every instance that shares a cachedir, so that they derive the same names
+	and keep finding the existing cache files across restarts. When the server is started with container/envHelpers.mjs,
+	as in the container images, PP_CACHEID_CREDS_FILE may name a file with the value instead: envHelpers.mjs reads that
+	file and passes its content like the other <NAME>_CREDS values, so that it is not in the initial env of the server
+	process. This module does not read PP_CACHEID_CREDS_FILE, so without envHelpers.mjs it is ignored. When not set, a
+	random key is generated per process: the cache still works, but every restart or other instance misses on the
+	files that were written before.
+
+	Read here, after the handoff values are set in process.env above, and removed from process.env in every mode, so
+	that it is not inherited by a child process. Only native modules are imported by this file, since it is also
+	loaded unbundled from the published package, such as by genome/copyDataFilesFromRepo2Tp.js, besides its bundled
+	copy in app.js. Only the first loaded copy, which is the bundled one in a server process, reads the key and sets
+	up the cache subdir, see firstLoad below.
+*/
+const cacheIdKeyValue = process.env.PP_CACHEID_CREDS
+const hasPersistentCacheKey = !!cacheIdKeyValue
+const cacheIdKey = cacheIdKeyValue ? Buffer.from(cacheIdKeyValue, 'utf8') : crypto.randomBytes(32)
+delete process.env.PP_CACHEID_CREDS
+
+/** Derive a 32-hex-char cacheId from the given object via
+ * HMAC-sha256(key, JSON.stringify([scope, args])). Truncation at 32 chars is safe
+ * for cache keys — collision probability is negligible at realistic cache sizes.
+ * Callers shape `args` to include only the fields whose identity
+ * determines the cache key, and must construct it with a stable key order
+ * (object literals do this naturally).
+ *
+ * `scope` is optional, and separates cacheIds for the same args, e.g. per user or session
+ * when the result depends on what the requester may access. Without a scope, identical
+ * args share one cacheId, which is the intended behavior for results that are the same for
+ * every requester. */
+export function generateHash(args, scope = '') {
+	return crypto
+		.createHmac('sha256', cacheIdKey)
+		.update(JSON.stringify([scope, args]))
+		.digest('hex')
+		.slice(0, 32)
+}
+
+/*
+	true for the first loaded copy of this module in a process. A later copy, such as the unbundled file that a genome
+	file imports, finds no PP_CACHEID_CREDS since the first copy removed it, so it would derive a different cache
+	subdir. The flag only marks that the cache subdir is set up, and does not hold its name.
+*/
+const firstLoadFlag = Symbol.for('proteinpaint.serverconfig.firstLoad')
+const firstLoad = !globalThis[firstLoadFlag]
+// configurable, so that a test can evaluate another first copy
+if (firstLoad) Object.defineProperty(globalThis, firstLoadFlag, { value: true, configurable: true })
+
+/*
+	Use an unlisted subdir of the configured cachedir, whose name is derived from the PP_CACHEID_CREDS key, so that the
+	cache files cannot be found by listing directories. On by default in a container, and may be set with
+	serverconfig.hideCachedir in any mode. The configured cachedir must then be owned by another user than the server
+	process, such as root, with mode 1733: the server user may create and use a subdir with a known name, but may not
+	list the entries or change the mode. A dir that is owned by the server user can always be listed by that user,
+	since the owner may change its mode.
+
+	All code that uses the path must copy serverconfig.cachedir to a module-local variable when it is loaded:
+	app.ts deletes serverconfig.cachedir before the server starts listening.
+*/
+if (serverconfig.hideCachedir ?? process.env.PP_MODE?.startsWith('container')) {
+	// a later copy does not use the cache, and must not use the configured cachedir, which is the parent of the subdir
+	if (!firstLoad) delete serverconfig.cachedir
+	else {
+		const parent = serverconfig.cachedir
+		if (!parent) throw 'serverconfig.cachedir missing'
+		// a parent dir that is created here is owned by the server user, which the warning below reports
+		if (!fs.existsSync(parent)) fs.mkdirSync(parent, { recursive: true })
+		let parentEntries
+		try {
+			parentEntries = fs.readdirSync(parent)
+			console.warn(
+				`WARNING: serverconfig.cachedir='${parent}' can be listed by the server process, so the cache subdir name ` +
+					`is not hidden; the dir should be owned by another user, such as root, with mode 1733`
+			)
+		} catch (e) {
+			// EACCES is the expected result; another error is reported by the mkdirSync() below
+		}
+		if (!hasPersistentCacheKey) {
+			console.warn(
+				`WARNING: PP_CACHEID_CREDS is not set, so the cache subdir name is generated for this process only, ` +
+					`and the files cached by an earlier process are not found or removed`
+			)
+		}
+		// not a generateHash() value, since the HMAC input is not a JSON array
+		const dirName = crypto.createHmac('sha256', cacheIdKey).update('cachedir').digest('hex').slice(0, 32)
+		serverconfig.cachedir = path.join(parent, dirName)
+		// the name is not logged, so that it is not in any log output
+		fs.mkdirSync(serverconfig.cachedir, { recursive: true, mode: 0o700 })
+		if (parentEntries) moveEarlierCacheEntries(parent, parentEntries, dirName)
+	}
+}
+delete serverconfig.hideCachedir
+
+/*
+	Moves the entries of the earlier cache layout, such as the saved sessions in massSession/, from the configured
+	cachedir into the derived subdir, where they are still found by the server and evicted by the cache monitor.
+	This is only possible while the configured cachedir can be listed, such as on the first start with the derived
+	subdir, before the dir owner and mode are changed. An entry with the name shape of a derived subdir, such as from
+	another instance with a different key, is not moved, and neither is an entry whose name already exists in the
+	derived subdir.
+*/
+function moveEarlierCacheEntries(parent, entries, dirName) {
+	let moved = 0
+	for (const name of entries) {
+		if (name == dirName || /^[0-9a-f]{32}$/.test(name)) continue
+		const dest = path.join(parent, dirName, name)
+		if (fs.existsSync(dest)) continue
+		try {
+			fs.renameSync(path.join(parent, name), dest)
+			moved++
+		} catch (e) {
+			// such as EXDEV for a separately mounted entry, which then stays where it is
+			console.warn(`WARNING: unable to move the earlier cache entry '${name}' into the cache subdir: ${e.code || e}`)
+		}
+	}
+	if (moved) console.log(`moved ${moved} earlier cache entries into the cache subdir`)
+}
+
 // when a mandatory setting is not defined in any ds, declare its default here
 
 if (process.argv.find(a => a == 'validate')) {
@@ -417,7 +540,8 @@ if (fs.existsSync('./package.json')) {
 	serverconfig.version = JSON.parse(pkg).version
 }
 
-if (!serverconfig.cache_snpgt) {
+// a later copy may have no cachedir, see firstLoad above
+if (!serverconfig.cache_snpgt && serverconfig.cachedir) {
 	serverconfig.cache_snpgt = {
 		dir: path.join(serverconfig.cachedir, 'snpgt'),
 		fileNameRegexp: /[^\w]/, // client-provided cache file name matching with this are denied

package/routes/termdb.geneRanking.js

@@ -1,178 +0,0 @@
-import path from "path";
-import fs from "fs";
-import { run_R } from "@sjcrh/proteinpaint-r";
-import serverconfig from "#src/serverconfig.js";
-import { clusterMethodLst, distanceMethodLst } from "#shared/clustering.js";
-function init({ genomes }) {
-  return async (req, res) => {
-    try {
-      const q = (req.method === "POST" ? req.body : req.query) || {};
-      if (q.for === "cluster") {
-        await handleCluster(q, res);
-      } else {
-        await handleData(q, res, genomes);
-      }
-    } catch (e) {
-      if (e instanceof Error && e.stack) console.log(e);
-      res.send({ error: e?.message || String(e) });
-    }
-  };
-}
-const fileCache = /* @__PURE__ */ new Map();
-function stripQuotes(s) {
-  if (s.length >= 2 && s[0] === '"' && s[s.length - 1] === '"') return s.slice(1, -1);
-  return s;
-}
-async function parseTsv(absPath) {
-  const text = await fs.promises.readFile(absPath, "utf8");
-  const lines = text.split(/\r?\n/).filter((l) => l.length > 0);
-  if (lines.length === 0) return { columns: [], rows: [], counts: [], geneIndex: /* @__PURE__ */ new Map() };
-  const columns = lines[0].split("	").map(stripQuotes);
-  const rows = [];
-  for (let i = 1; i < lines.length; i++) {
-    const fields = lines[i].split("	").map(stripQuotes);
-    const normalizedFields = fields.length < columns.length ? fields.concat(Array(columns.length - fields.length).fill("")) : fields.slice(0, columns.length);
-    const row = normalizedFields.map((v) => {
-      if (v === "" || v === "NA" || v === "NaN") return null;
-      const n = Number(v);
-      return Number.isFinite(n) && v.trim() !== "" ? n : v;
-    });
-    rows.push(row);
-  }
-  const counts = columns.map(
-    (_, c) => c === 0 ? rows.length : rows.filter((r) => r[c] !== null && r[c] !== void 0).length
-  );
-  const geneIndex = /* @__PURE__ */ new Map();
-  for (const [i, r] of rows.entries()) {
-    if (typeof r[0] === "string") {
-      const g = r[0].toLowerCase();
-      if (!geneIndex.has(g)) geneIndex.set(g, i);
-    }
-  }
-  return { columns, rows, counts, geneIndex };
-}
-function zscorePerColumnIgnoringNull(matrix, ncol) {
-  const out = matrix.map((r) => [...r]);
-  for (let c = 0; c < ncol; c++) {
-    const vals = [];
-    for (const r of matrix) {
-      const v = r[c];
-      if (v !== null && v !== void 0 && Number.isFinite(v)) vals.push(v);
-    }
-    if (vals.length === 0) continue;
-    const mean = vals.reduce((s, v) => s + v, 0) / vals.length;
-    const sd = Math.sqrt(vals.reduce((s, v) => s + (v - mean) ** 2, 0) / vals.length);
-    for (let r = 0; r < matrix.length; r++) {
-      const v = matrix[r][c];
-      if (v === null || v === void 0 || !Number.isFinite(v)) out[r][c] = null;
-      else out[r][c] = sd === 0 ? 0 : (v - mean) / sd;
-    }
-  }
-  return out;
-}
-async function handleData(q, res, genomes) {
-  const genome = genomes[q.genome];
-  if (!genome) throw "invalid genome";
-  const ds = genome.datasets[q.dslabel];
-  if (!ds) throw "invalid dslabel";
-  const cfg = ds.queries?.geneRanking;
-  if (!cfg || !cfg.rankings) throw "geneRanking not configured for this dataset";
-  if (q.gene) {
-    const wanted = String(q.gene).trim().toLowerCase();
-    const geneRanks = {};
-    const keys = Object.keys(cfg.rankings);
-    const loaded = await Promise.all(
-      keys.map(
-        (key) => loadRanking(q, cfg.rankings[key], key).catch((e) => {
-          console.log(`geneRanking: cannot load ranking "${key}": ${e?.message || e}`);
-          return null;
-        })
-      )
-    );
-    for (const [i, parsed2] of loaded.entries()) {
-      if (!parsed2) continue;
-      const ri = parsed2.geneIndex.get(wanted);
-      geneRanks[keys[i]] = {
-        columns: parsed2.columns,
-        row: ri === void 0 ? null : parsed2.rows[ri],
-        counts: parsed2.counts,
-        total: parsed2.rows.length
-      };
-    }
-    res.send({ geneRanks });
-    return;
-  }
-  if (!q.key) {
-    res.send({ keys: Object.keys(cfg.rankings) });
-    return;
-  }
-  const relPath = cfg.rankings[q.key];
-  if (!relPath) throw "invalid key";
-  const parsed = await loadRanking(q, relPath, q.key);
-  res.send({ columns: parsed.columns, rows: parsed.rows });
-}
-async function loadRanking(q, relPath, key) {
-  if (path.isAbsolute(relPath) || relPath.split(/[\\/]/).includes("..")) throw "invalid file path";
-  const absPath = path.resolve(serverconfig.tpmasterdir, relPath);
-  const tpRoot = path.resolve(serverconfig.tpmasterdir) + path.sep;
-  if (!absPath.startsWith(tpRoot)) throw "invalid file path";
-  const stat = await fs.promises.stat(absPath);
-  const cacheKey = `${q.genome}|${q.dslabel}|${key}`;
-  let entry = fileCache.get(cacheKey);
-  if (!entry || entry.mtimeMs !== stat.mtimeMs) {
-    entry = { parsed: await parseTsv(absPath), mtimeMs: stat.mtimeMs };
-    fileCache.set(cacheKey, entry);
-  }
-  return entry.parsed;
-}
-async function handleCluster(q, res) {
-  const { row_names, col_names } = q;
-  if (!Array.isArray(q.matrix) || !Array.isArray(row_names) || !Array.isArray(col_names)) {
-    throw "matrix, row_names, and col_names are required";
-  }
-  if (q.matrix.length !== row_names.length) throw "matrix.length must equal row_names.length";
-  if (col_names.length < 2) throw "need at least 2 modalities to cluster";
-  const minAssays = Math.max(2, q.minAssays ?? 3);
-  const keptRows = [];
-  const keptNames = [];
-  for (let i = 0; i < q.matrix.length; i++) {
-    const row = q.matrix[i];
-    if (!Array.isArray(row) || row.length !== col_names.length) continue;
-    const nonNull = row.filter((v) => v !== null && v !== void 0 && Number.isFinite(v)).length;
-    if (nonNull < minAssays) continue;
-    keptRows.push(row.map((v) => v === null || v === void 0 || !Number.isFinite(v) ? null : v));
-    keptNames.push(row_names[i]);
-  }
-  if (keptRows.length < 3) throw `need at least 3 rows with \u2265${minAssays} non-null values for clustering`;
-  const zMatrix = zscorePerColumnIgnoringNull(keptRows, col_names.length);
-  const matrixForR = zMatrix.map((row) => row.map((v) => v === null ? 0 : v));
-  const clusterMethod = q.clusterMethod || "average";
-  const distanceMethod = q.distanceMethod || "euclidean";
-  if (!clusterMethodLst.find((i) => i.value == clusterMethod)) throw "Invalid cluster method";
-  if (!distanceMethodLst.find((i) => i.value == distanceMethod)) throw "Invalid distance method";
-  const inputData = {
-    matrix: matrixForR,
-    row_names: keptNames,
-    col_names,
-    cluster_method: clusterMethod,
-    distance_method: distanceMethod,
-    plot_image: false
-  };
-  const Routput = JSON.parse(await run_R("hclust.R", JSON.stringify(inputData)));
-  const rowOrderIdx = Routput.RowOrder.map((row) => keptNames.indexOf(row.name));
-  const orderedMatrix = rowOrderIdx.map((i) => zMatrix[i]);
-  res.send({
-    row: {
-      merge: Routput.RowMerge,
-      height: Routput.RowHeight,
-      order: Routput.RowOrder,
-      inputOrder: keptNames
-    },
-    usedRowNames: keptNames,
-    usedColNames: col_names,
-    matrix: orderedMatrix
-  });
-}
-export {
-  init
-};

package/routes/termdb.proteome.js

@@ -1,359 +0,0 @@
-import path from "path";
-import { get_ds_tdb } from "#src/termdb.js";
-import * as utils from "#src/utils.js";
-import { mayLimitSamples } from "#src/mds3.filter.js";
-import serverconfig from "#src/serverconfig.js";
-import { sql } from "#src/sql.ts";
-import { readGeneRows, baseUniProtAcc } from "../src/routes/termdb.bubbleHeatmap.ts";
-const missingDapWarned = /* @__PURE__ */ new Set();
-function init({ genomes }) {
-  return async (req, res) => {
-    const q = req.query;
-    try {
-      const genome = genomes[q.genome];
-      if (!genome) throw "invalid genome";
-      const [ds] = get_ds_tdb(genome, q);
-      if (!ds.queries?.proteome?.organisms) throw "queries.proteome not configured";
-      const term = q.term?.term || q.term;
-      if (!term?.name) throw "term.name missing";
-      const cohorts = [];
-      const brConfig = ds.queries.proteome.brainRegions;
-      const regionRemap = brConfig?.regionValueRemap || {};
-      const sampleRegions = {};
-      const identifierAnno = /* @__PURE__ */ new Map();
-      for (const organismName in ds.queries.proteome.organisms) {
-        const organism = ds.queries.proteome.organisms[organismName];
-        for (const assayName in organism.assays) {
-          const assay = organism.assays[assayName];
-          for (const cohortName in assay.cohorts || {}) {
-            const cohortCfg = assay.cohorts[cohortName];
-            const dapPath = path.join(serverconfig.tpmasterdir, cohortCfg.DAPfile);
-            const rows = await readGeneRows(dapPath, String(term.name).toLowerCase());
-            if (!rows) {
-              if (!missingDapWarned.has(dapPath)) {
-                missingDapWarned.add(dapPath);
-                console.warn(
-                  `proteome: DAPfile missing or unreadable for ${organismName}/${assayName}/${cohortName}: ${dapPath}`
-                );
-              }
-              continue;
-            }
-            if (!rows.length) continue;
-            const organismFilter = [{ columnIdx: organism.columnIdx, columnValue: organism.columnValue }];
-            const assayFilter = [{ columnIdx: assay.columnIdx, columnValue: assay.columnValue }];
-            let caseSamples = [];
-            let controlSamples = [];
-            try {
-              caseSamples = listCohortSamples(ds.queries.proteome.db, [
-                ...organismFilter,
-                ...assayFilter,
-                ...cohortCfg.caseFilter
-              ]);
-              controlSamples = listCohortSamples(ds.queries.proteome.db, [
-                ...organismFilter,
-                ...assayFilter,
-                ...cohortCfg.controlFilter
-              ]);
-            } catch {
-            }
-            const annoKey = `${organismName}|${assayName}`;
-            if (!identifierAnno.has(annoKey)) {
-              let m = /* @__PURE__ */ new Map();
-              try {
-                m = listIdentifierAnnotations(ds.queries.proteome.db, term.name, [...organismFilter, ...assayFilter]);
-              } catch {
-              }
-              identifierAnno.set(annoKey, m);
-            }
-            const anno = identifierAnno.get(annoKey);
-            const sampleIds = brConfig ? [...caseSamples, ...controlSamples] : [];
-            if (brConfig) {
-              const regionOf = (filters) => {
-                const f = filters.find((f2) => f2.columnIdx === brConfig.regionColumnIdx);
-                if (!f) return void 0;
-                const code = regionRemap[String(f.columnValue)] ?? String(f.columnValue);
-                return brConfig.regions[code] !== void 0 ? code : void 0;
-              };
-              const caseRegion = regionOf(cohortCfg.caseFilter);
-              const controlRegion = regionOf(cohortCfg.controlFilter);
-              if (caseRegion) for (const sid of caseSamples) sampleRegions[sid] = caseRegion;
-              if (controlRegion) for (const sid of controlSamples) sampleRegions[sid] = controlRegion;
-            }
-            for (const row of rows) {
-              const entry = {
-                organism: organismName,
-                // the study catalog (dataset config) is the authority on disease
-                disease: cohortCfg.catalog?.disease,
-                assayName,
-                cohortName,
-                uniqueIdentifier: row.identifier,
-                proteinAccession: row.acc,
-                geneName: term.name,
-                // client computes log2(foldChange); DAP stores log2FC directly
-                foldChange: Math.pow(2, row.fc),
-                // significance is the DAP file's FDR (BH-adjusted p), consistent with
-                // the other DAP-driven tools; a nominal p is only present when the
-                // DAP file carries one (6th column)
-                fdr: row.fdr,
-                pValue: row.fdr,
-                testedN: caseSamples.length,
-                controlN: controlSamples.length
-              };
-              const a = anno.get(row.identifier);
-              if (a?.isoform) entry.isoform = a.isoform;
-              if (assay.PTMType) {
-                entry.PTMType = assay.PTMType;
-                if (a?.modsite) entry.modSites = a.modsite;
-              }
-              if (assay.mclassOverride) entry.mclassOverride = assay.mclassOverride;
-              if (organism.genomeName) entry.genomeName = organism.genomeName;
-              if (brConfig) entry.sampleIds = sampleIds.slice();
-              cohorts.push(entry);
-            }
-          }
-        }
-      }
-      const refAssay = ds.queries.proteome.proteinReferenceAssay;
-      if (refAssay) {
-        const refFcByKey = /* @__PURE__ */ new Map();
-        for (const e of cohorts) {
-          if (e.assayName !== refAssay || !Number.isFinite(e.foldChange)) continue;
-          const baseAcc = baseUniProtAcc(e.proteinAccession);
-          if (!baseAcc) continue;
-          const key = `${e.organism}|${e.cohortName}|${baseAcc}`;
-          const p = Number.isFinite(e.fdr) ? e.fdr : Infinity;
-          const cur = refFcByKey.get(key);
-          if (!cur || p < cur.p) refFcByKey.set(key, { fc: e.foldChange, p });
-        }
-        for (const e of cohorts) {
-          if (!e.PTMType) continue;
-          const baseAcc = baseUniProtAcc(e.proteinAccession);
-          if (!baseAcc) continue;
-          const ref = refFcByKey.get(`${e.organism}|${e.cohortName}|${baseAcc}`);
-          if (ref) e.proteinFoldChange = ref.fc;
-        }
-      }
-      res.send({ protein: term.name, cohorts, sampleRegions: brConfig ? sampleRegions : void 0 });
-    } catch (e) {
-      if (e?.stack) console.log(e.stack);
-      res.send({ error: e.message || e });
-    }
-  };
-}
-async function validate_query_proteome(ds) {
-  const q = ds.queries.proteome;
-  if (!q) return;
-  if (!q.organisms) {
-    throw "queries.proteome.organisms is missing";
-  }
-  if (!q.dbfile) {
-    throw "queries.proteome.dbfile is missing";
-  }
-  try {
-    q.db = utils.connect_db(q.dbfile);
-  } catch (e) {
-    throw `Cannot connect to proteome db ${q.dbfile}: ${e.message || e}`;
-  }
-  for (const organismName in q.organisms) {
-    const organism = q.organisms[organismName];
-    if (organism.columnIdx == null) throw `queries.proteome.organisms.${organismName}.columnIdx missing`;
-    if (organism.columnValue == null) throw `queries.proteome.organisms.${organismName}.columnValue missing`;
-    if (!organism.assays || typeof organism.assays != "object")
-      throw `queries.proteome.organisms.${organismName}.assays missing or invalid`;
-    for (const assayName in organism.assays) {
-      const assay = organism.assays[assayName];
-      if (assay.columnIdx == null)
-        throw `queries.proteome.organisms.${organismName}.assays.${assayName}.columnIdx missing`;
-      if (assay.columnValue == null)
-        throw `queries.proteome.organisms.${organismName}.assays.${assayName}.columnValue missing`;
-      if (assay.cohorts) {
-        for (const cohortName in assay.cohorts) {
-          const cohort = assay.cohorts[cohortName];
-          if (!cohort.controlFilter)
-            throw `Missing controlFilter in queries.proteome.organisms.${organismName}.assays.${assayName}.cohorts.${cohortName}`;
-          if (!cohort.caseFilter)
-            throw `Missing caseFilter in queries.proteome.organisms.${organismName}.assays.${assayName}.cohorts.${cohortName}`;
-          if (!cohort.DAPfile)
-            throw `Missing DAPfile in queries.proteome.organisms.${organismName}.assays.${assayName}.cohorts.${cohortName}`;
-        }
-      } else {
-        throw `Invalid assay structure for "${assayName}". Must have .cohorts`;
-      }
-    }
-  }
-  const geneIndexHint = q.db.prepare("SELECT 1 FROM sqlite_master WHERE type = ? AND name = ?").get("index", "proteome_abundance_gene") ? sql` INDEXED BY proteome_abundance_gene` : sql``;
-  q.find = async (arg) => {
-    const proteins = arg?.proteins;
-    if (!Array.isArray(proteins) || proteins.length == 0) throw "queries.proteome.find arg.proteins[] missing";
-    const matches = /* @__PURE__ */ new Set();
-    const details = arg?.dataTypeDetails || {};
-    const organism = details.organism;
-    const assay = details.assay;
-    const cohort = details.cohort;
-    const MAX_FIND_RESULTS = 500;
-    const filters = [];
-    if (Object.keys(details).length) {
-      if (!organism || !assay || !cohort)
-        throw "queries.proteome.find arg.dataTypeDetails.{organism,assay,cohort} missing";
-      const organismConfig = q.organisms?.[organism];
-      if (!organismConfig) throw `queries.proteome.find invalid organism: ${organism}`;
-      const assayConfig = organismConfig.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 organismFilter = [{ columnIdx: organismConfig.columnIdx, columnValue: organismConfig.columnValue }];
-      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(...organismFilter, ...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 query = sql`SELECT DISTINCT gene, identifier FROM proteome_abundance${geneIndexHint} WHERE gene >= ${token} COLLATE NOCASE AND gene < ${upperToken} COLLATE NOCASE AND ${buildFilterClause(
-          filters
-        )} LIMIT ${MAX_FIND_RESULTS}`;
-        rawRows.push(...q.db.prepare(query).all());
-      } else {
-        rawRows.push(
-          ...q.db.prepare(
-            sql`SELECT DISTINCT gene, identifier FROM proteome_abundance WHERE gene >= ${token} COLLATE NOCASE AND gene < ${upperToken} COLLATE NOCASE LIMIT ${MAX_FIND_RESULTS}`
-          ).all()
-        );
-      }
-      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.dataTypeDetails?.assay || !param.dataTypeDetails?.cohort || !param.dataTypeDetails?.organism)
-      throw "queries.proteome.get param.dataTypeDetails.{assay,cohort,organism} missing";
-    return await getProteomeValuesFromCohort(ds, param, q);
-  };
-}
-const columnIdxToName = {
-  0: "organism",
-  1: "disease",
-  2: "tissue",
-  3: "brain_region",
-  4: "tech1",
-  5: "tech2",
-  6: "cohort"
-};
-function resolveColumnName(idx) {
-  const name = columnIdxToName[idx];
-  if (!name) throw `Invalid columnIdx: ${idx}, must be one of ${Object.keys(columnIdxToName).join(",")}`;
-  return name;
-}
-function buildFilterClause(filters) {
-  return sql.join(
-    filters.map((f) => sql`${sql.id(resolveColumnName(f.columnIdx))} = ${f.columnValue}`),
-    sql` AND `
-  );
-}
-function listCohortSamples(db, filters) {
-  if (!filters?.length) throw "listCohortSamples: filters must not be empty";
-  let perDb = cohortSampleCache.get(db);
-  if (!perDb) cohortSampleCache.set(db, perDb = /* @__PURE__ */ new Map());
-  const key = JSON.stringify(filters);
-  const hit = perDb.get(key);
-  if (hit) return hit;
-  const samples = db.prepare(sql`SELECT DISTINCT sample FROM proteome_abundance WHERE ${buildFilterClause(filters)}`).all().map((r) => String(r.sample));
-  perDb.set(key, samples);
-  return samples;
-}
-const cohortSampleCache = /* @__PURE__ */ new WeakMap();
-function listIdentifierAnnotations(db, gene, filters) {
-  const rows = db.prepare(
-    sql`SELECT identifier, modsite, isoform FROM proteome_abundance WHERE gene = ${gene} COLLATE NOCASE${filters.length ? sql` AND ${buildFilterClause(filters)}` : sql``} GROUP BY identifier`
-  ).all();
-  return new Map(rows.map((r) => [r.identifier, { modsite: r.modsite, isoform: r.isoform }]));
-}
-function queryDbRows(db, identifier, filters) {
-  const query = sql`SELECT organism, disease, identifier, protein_accession, isoform, modsite, gene, sample, value, brain_region
-		FROM proteome_abundance
-		WHERE identifier = ${identifier} COLLATE NOCASE${filters.length ? sql` AND ${buildFilterClause(filters)}` : sql``}`;
-  return db.prepare(query).all();
-}
-async function getProteomeValuesFromCohort(ds, param, q) {
-  const db = ds.queries.proteome.db;
-  const { assay, cohort, organism } = param.dataTypeDetails;
-  const organismConfig = q.organisms?.[organism];
-  if (!organismConfig) throw `queries.proteome invalid organism: ${organism}`;
-  const organismColumnIdx = organismConfig.columnIdx;
-  const organismColumnValue = organismConfig.columnValue;
-  const assayConfig = organismConfig.assays?.[assay];
-  if (!assayConfig) throw `queries.proteome.get invalid assay: ${assay}`;
-  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 organismFilter = [{ columnIdx: organismColumnIdx, columnValue: organismColumnValue }];
-  const assayFilter = [{ columnIdx: assayColumnIdx, columnValue: assayColumnValue }];
-  const term2sample2value = /* @__PURE__ */ new Map();
-  const controlSampleIds = /* @__PURE__ */ new Set();
-  for (const tw of param.terms) {
-    if (!tw) continue;
-    const fullGeneName = tw.term.name;
-    const identifier = fullGeneName.split(":")[1]?.trim();
-    const geneName = fullGeneName.split(":")[0]?.trim();
-    if (!identifier || !geneName)
-      throw "invalid term name for proteome query, must be in format geneName: uniqueIdentifier";
-    const caseRows = queryDbRows(db, identifier, [...organismFilter, ...assayFilter, ...cohortCaseFilter]);
-    const controlRows = queryDbRows(db, identifier, [...organismFilter, ...assayFilter, ...cohortControlFilter]);
-    for (const row of controlRows) {
-      const sid = ds.cohort.termdb.q.sampleName2id(row.sample);
-      if (sid !== void 0) controlSampleIds.add(String(sid));
-    }
-    const allRows = [...caseRows, ...controlRows];
-    const allSampleIds = [];
-    for (const row of allRows) {
-      const sid = ds.cohort.termdb.q.sampleName2id(row.sample);
-      if (sid !== void 0) allSampleIds.push(sid);
-    }
-    const uniqueSampleIds = [...new Set(allSampleIds)];
-    const allowedSampleIds = await mayLimitSamples(param, uniqueSampleIds, ds);
-    if (allowedSampleIds?.size == 0) {
-      return { term2sample2value: /* @__PURE__ */ new Map(), byTermId: {}, bySampleId: {} };
-    }
-    const s2v = {};
-    for (const row of allRows) {
-      const sid = ds.cohort.termdb.q.sampleName2id(row.sample);
-      if (sid === void 0) continue;
-      if (allowedSampleIds && !allowedSampleIds.has(sid)) continue;
-      s2v[sid] = row.value;
-    }
-    if (Object.keys(s2v).length) {
-      term2sample2value.set(tw.$id, s2v);
-    }
-  }
-  const bySampleId = {};
-  if (term2sample2value.size == 0) {
-    throw `No data available for: ${param.terms?.map((t) => t.term.name).join(", ")}`;
-  }
-  for (const s2v of term2sample2value.values()) {
-    for (const sid of Object.keys(s2v)) {
-      bySampleId[sid] = { label: ds.cohort.termdb.q.id2sampleName(Number(sid)) };
-    }
-  }
-  return { term2sample2value, controlSampleIds, bySampleId };
-}
-export {
-  init,
-  listCohortSamples,
-  listIdentifierAnnotations,
-  queryDbRows,
-  validate_query_proteome
-};