formlab-mcp 0.6.45 → 0.6.47

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "formlab-mcp",
-  "version": "0.6.45",
+  "version": "0.6.47",
   "mcpName": "io.github.juliu1980/formlab-mcp",
   "description": "Read-only Model Context Protocol server for FormLab \u2014 lets Claude (and other MCP clients) read and analyze your FormLab data, from a local export file OR your live cloud workspace.",
   "type": "module",

package/server.json

@@ -2,7 +2,7 @@
   "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
   "name": "io.github.juliu1980/formlab-mcp",
   "description": "Read-only MCP for FormLab — let Claude query your formulation lab. Free reads a local export; Pro connects to your live cloud workspace with a dedicated read-only token.",
-  "version": "0.6.45",
+  "version": "0.6.47",
   "websiteUrl": "https://formvix.com/mcp",
   "repository": {
     "url": "https://github.com/juliu1980/FormLab",
@@ -13,7 +13,7 @@
     {
       "registryType": "npm",
       "identifier": "formlab-mcp",
-      "version": "0.6.45",
+      "version": "0.6.47",
       "runtimeHint": "npx",
       "transport": {
         "type": "stdio"

package/tools/analytics.js

@@ -359,13 +359,23 @@ const get_doe_matrix = {
 
     // 4) Aggregate measurements per column per row (mean of numeric scalar
     //    values), reading only the column's own run condition when split.
+    const testOfM = new Map();
+    (db.testResults || []).forEach(t => (t.measurements || []).forEach(x => testOfM.set(x, t)));
     const cellParamValue = (r, col) => {
       const ms = r.measurements.filter(m => m.parameter === col.id && (col.cond == null || _mcpCondSig(m) === col.cond));
       if (!ms.length) return null;
       // The app's DOE Matrix numbers (12v): a curve's final value, a
-      // distribution's D50, an ordinal's 1-based rank; text → its first reading.
+      // distribution's D50, a grade's place on its scale. 13r: a ranked scale
+      // is its LOWER-median grade (never an averaged rank); text its most
+      // frequent value, a tie to a failing one (it took the first reading); a
+      // distribution with no D50 its bins (it read "8 bins").
       const nums = ms.map(m => _mcpRepNumber(m, { ordinal: 'rank' })).filter(v => v != null);
-      if (!nums.length) return ms[0].value ?? null;
+      if (!nums.length) {
+        const rows = ms.map(m => { const t = testOfM.get(m); return { m, type: _mcpMeasType(m), value: m.value, numeric: null, rank: null, pf: _evalPassFail(m, t && t.templateId) }; });
+        if (rows.every(x => x.type === 'categorical')) return _mcpGradedPick(rows).value ?? null;
+        return _mcpCellValue(rows[0]);
+      }
+      if (ms.every(m => _mcpMeasType(m) === 'ordinal')) { const so = nums.slice().sort((a, b) => a - b); return so[Math.floor((so.length - 1) / 2)]; }
       const mean = nums.reduce((s, v) => s + v, 0) / nums.length;
       return +mean.toFixed(4);
     };
@@ -462,7 +472,7 @@ function _mcpRepNumber(m, opts) {
 // app's Stability view draws it (FormLab 12w): one point per test date × run
 // condition — an ordinal date is the MEDIAN rank of its readings (rank =
 // 1-based position on the reading's own scale), a text date its value (or
-// "mixed: a / b") — failing when any reading fails; one series per condition.
+// the most frequent value, a tie to a failing one) — failing when any reading fails; one series per condition.
 function _mcpGradedStability(entity, entityType, args, graded) {
   const nOrd = graded.filter(r => r.type === 'ordinal').length;
   const kind = nOrd >= graded.length - nOrd ? 'ordinal' : 'categorical';
@@ -478,8 +488,11 @@ function _mcpGradedStability(entity, entityType, args, graded) {
       rank = rs.length ? rs[Math.floor((rs.length - 1) / 2)] : null;
       label = rank != null && scale ? scale[rank - 1] : g[0].label;
     } else {
-      const vals = [...new Set(g.map(r => r.label))];
-      label = vals.length === 1 ? vals[0] : 'mixed: ' + vals.join(' / ');
+      // The most frequent value, a tie to a failing one (13r) — "mixed: a / b" said
+      // nothing about which reading counts. The chip's tooltip lists them all.
+      const k = r => String(r.label).toLowerCase(); const cnt = new Map(); g.forEach(r => cnt.set(k(r), (cnt.get(k(r)) || 0) + 1));
+      const top = Math.max(...cnt.values()); const tied = g.filter(r => cnt.get(k(r)) === top);
+      label = (tied.find(r => r.pf === 'fail') || tied[0]).label;
     }
     return { date: g[0].day, condition: split ? (g[0].cond || null) : null, label, ...(kind === 'ordinal' ? { rank } : {}),
       readings: g.length, values: g.map(r => r.label), reports: [...new Set(g.map(r => r.report))],
@@ -504,7 +517,7 @@ function _mcpGradedStability(entity, entityType, args, graded) {
     parameter: args.parameter, kind, ...(scale ? { scale } : {}), spec, byCondition: split, pointCount: pts.length, series,
     note: kind === 'ordinal'
       ? 'A ranked scale (ordinal) has no number, so there is no regression, control chart or shelf-life projection: each point is one test date per condition, its value the MEDIAN rank of that date\'s readings (rank = position on `scale`, 1-based; higher = later on the scale). pf "fail" when any reading that date failed. scaleShift.steps is the rank change first → latest (negative = moved down the scale). Narrate firstFail / latest; do not average ranks into a number.'
-      : 'A text (categorical) result has no number: each point is one test date per condition with its value (or "mixed: a / b" when readings differ) and pass/fail against `spec.required`; pf "fail" when any reading failed. Narrate firstFail / latest.',
+      : 'A text (categorical) result has no number: each point is one test date per condition with its value (several readings that differ → the most frequent, a tie to a failing one; `values` lists them) and pass/fail against `spec.required`; pf "fail" when any reading failed. Narrate firstFail / latest.',
   };
 }
 function _mcpCondSig(m) {
@@ -812,7 +825,8 @@ function _evalPassFail(m, templateId, db) {
   if (type === 'ordinal') {
     if (!raw) return 'untested';
     const scale = Array.isArray(m.scale) ? m.scale : [];
-    const idx = scale.indexOf(raw);
+    // Case-insensitive, as flMeasNum places a grade (13r): "hb" was judged untested but plotted at HB.
+    const idx = scale.map(g => String(g).trim().toUpperCase()).indexOf(raw.toUpperCase());
     if (idx < 0) return 'untested';
     const minRank = _ordinalMinRank(crit, scale);
     if (minRank == null) return 'no-criteria';
@@ -1437,7 +1451,7 @@ const get_stability = {
   },
 };
 
-export { _mcpRepNumber, _mcpMeasType, _evalPassFail, _resolveSpec, _shelfLife, _shelfLifeAssess, _mcpCondTags, _mcpArmNames, _mcpCondDefaultScore };
+export { _mcpRepNumber, _mcpMeasType, _evalPassFail, _resolveSpec, _shelfLife, _shelfLifeAssess, _mcpCondTags, _mcpArmNames, _mcpCondDefaultScore, _mcpCondSig, _mcpCondLabel, _mcpParamGroupsOf };
 // ============================================================
 // compare_test_results — the app's Compare Results table (js/views/testing-
 // compare.js), 13g. Items are formulas, batches, samples or test reports; each
@@ -1511,8 +1525,39 @@ function _mcpCompareCell(item, parameter, agg, db) {
     if (!arms.has(sig)) arms.set(sig, { sig, m, t, rows: [] });
     arms.get(sig).rows.push({ m, t, date: _tcDate(t), value: v, pf: _evalPassFail(m, t.templateId, db) });
   });
-  // Nothing numeric (a ranked scale, a text result, a distribution with no D50):
-  // the latest reading, as typed.
+  // A ranked scale or a text result (13r, as the app's Compare): per run
+  // condition, no condition first, the latest test date — several readings on
+  // it → the lower-median grade / the most frequent text (a tie to a failing
+  // one), failing if any reading fails; two or more conditions → arms.
+  if (!arms.size && (type === 'ordinal' || type === 'categorical')) {
+    const g = new Map();
+    hits.forEach(({ m, t }) => {
+      const label = String(m.value == null ? '' : m.value).trim(); if (!label) return;
+      const sig = _mcpCondSig(m), day = String(t.testDate || '').slice(0, 10);
+      if (!g.has(sig)) g.set(sig, { sig, m, days: new Map() });
+      const a = g.get(sig); if (!a.days.has(day)) a.days.set(day, []);
+      a.days.get(day).push({ type: _mcpMeasType(m), value: label, rank: _mcpRepNumber(m, { ordinal: 'rank' }), pf: _evalPassFail(m, t.templateId, db), m });
+    });
+    const gl = [...g.values()].sort((x, y) => ((x.sig ? 1 : 0) - (y.sig ? 1 : 0)) || (y.days.size - x.days.size) || x.sig.localeCompare(y.sig));
+    if (gl.length) {
+      const cellOf = (a) => {
+        const day = [...a.days.keys()].sort().pop(); const rs = a.days.get(day); const p = _mcpGradedPick(rs);
+        const pf = rs.some(r => r.pf === 'fail') ? 'fail' : rs.some(r => r.pf === 'pass') ? 'pass' : rs[0].pf;
+        const c = { type, value: p.value, pf, date: day, n: a.days.size, readings: [...a.days.values()].reduce((x, r) => x + r.length, 0),
+          ...(rs.length > 1 ? { readingsOnDate: rs.map(r => r.value), basis: type === 'ordinal' ? 'middle grade of the date\'s readings' : 'most frequent of the date\'s readings' } : {}) };
+        if (type === 'ordinal' && p.rank != null && Array.isArray(p.m.scale)) { c.rank = p.rank; c.scaleLength = p.m.scale.length; }
+        return c;
+      };
+      const cells = gl.map(cellOf);
+      if (agg !== 'latest' && hits.length > 1) cells.forEach(c => { c.note = 'not a number — the latest test date is shown'; });
+      if (gl.length === 1) return { ...cells[0], ...(gl[0].sig ? { condition: _mcpCondLabel(gl[0].m) } : {}) };
+      const tags = _mcpCondTags(gl.map(a => a.sig ? _mcpCondLabel(a.m) : ''));
+      return { ...cells[0], splitByCondition: true,
+        arms: gl.map((a, i) => ({ condition: a.sig ? _mcpCondLabel(a.m) : null, tag: tags[i], ...cells[i] })),
+        note: 'measured under more than one run condition: one arm per condition, never mixed; the top-level value is the first arm (no run condition when there is one)' };
+    }
+  }
+  // Nothing numeric (a distribution with no D50): the latest reading.
   if (!arms.size) {
     const { m, t } = hits[hits.length - 1];
     const out = { type, value: m.value ?? null, unit: m.unit || '', pf: _evalPassFail(m, t.templateId, db), date: t.testDate || '', readings: hits.length };

package/tools/designspace.js

@@ -27,7 +27,7 @@
 // ============================================================
 
 import { getStore, resolveById, flattenComposition } from '../data.js';
-import { _mcpRepNumber } from './analytics.js';
+import { _mcpRepNumber, _mcpMeasType } from './analytics.js';
 
 // ---- composition helper -----------------------------------------------------
 // Ingredient wt-% map for one formula, mirroring the app's _asmIngredientMap:
@@ -346,20 +346,24 @@ function _roleCandidates(forms, roleMaps) {
   return out.sort((a, b) => b.score - a.score);
 }
 // A formula's value for a measured parameter, as the app's
-// _asmFormulaValueForCol (12v): readings of the primary run condition (the one
-// with the most readings), each as the DOE Matrix reads it (a curve's final
-// value, a distribution's D50, an ordinal's rank), then their mean.
+// _asmFormulaValueForCol: the plain-name readings — no run condition when
+// there are any (13q; it took the condition with the most readings), else the
+// most readings — each read as the DOE Matrix reads it (a curve's final value,
+// a distribution's D50, a grade's place on its scale), then their mean; a
+// ranked scale's middle grade (lower median), never an averaged rank.
 function _paramValue(f, param, db) {
   const sids = new Set((db.samples || []).filter(s => s.formulationId === f.id).map(s => s.id));
   const ms = [];
   (db.testResults || []).forEach(t => { if (!sids.has(t.sampleId)) return; (t.measurements || []).forEach(m => { if (m.parameter === param) ms.push(m); }); });
   const sig = (m) => { const c = m && m.conditions; return c && typeof c === 'object' ? Object.keys(c).filter(k => c[k] != null && c[k] !== '').sort().map(k => k + '=' + c[k]).join('; ') : ''; };
   const byCond = new Map();
-  ms.forEach(m => { if (_mcpRepNumber(m) == null) return; const k = sig(m); byCond.set(k, (byCond.get(k) || 0) + 1); });
-  const primary = [...byCond.entries()].sort((a, b) => b[1] - a[1])[0];
+  ms.forEach(m => { if (_mcpRepNumber(m, { ordinal: 'rank' }) == null) return; const k = sig(m); byCond.set(k, (byCond.get(k) || 0) + 1); });
+  const primary = [...byCond.entries()].sort((a, b) => ((a[0] ? 1 : 0) - (b[0] ? 1 : 0)) || (b[1] - a[1]) || a[0].localeCompare(b[0]))[0];
   const pool = primary ? ms.filter(m => sig(m) === primary[0]) : ms;
   const vals = pool.map(m => _mcpRepNumber(m, { ordinal: 'rank' })).filter(v => v != null);
-  return vals.length ? vals.reduce((a, b) => a + b, 0) / vals.length : null;
+  if (!vals.length) return null;
+  if (pool.some(m => _mcpMeasType(m) === 'ordinal')) { const so = vals.slice().sort((a, b) => a - b); return so[Math.floor((so.length - 1) / 2)]; }
+  return vals.reduce((a, b) => a + b, 0) / vals.length;
 }
 function _spearman(xs, ys) {
   const rank = (a) => { const idx = a.map((v, i) => [v, i]).sort((p, q) => p[0] - q[0]); const r = new Array(a.length); let i = 0; while (i < idx.length) { let j = i; while (j + 1 < idx.length && idx[j + 1][0] === idx[i][0]) j++; const avg = (i + j) / 2 + 1; for (let k = i; k <= j; k++) r[idx[k][1]] = avg; i = j + 1; } return r; };
@@ -503,7 +507,7 @@ const get_design_space = {
       if (vals.length < 2) out.notes.push(`"${args.property}" is measured on ${vals.length} of the formulas on the map — need at least 2 for insights (check the exact parameter name).`);
       else {
         const hi = vals.reduce((a, b) => b.v > a.v ? b : a), lo = vals.reduce((a, b) => b.v < a.v ? b : a);
-        const pi = { property: args.property, basis: 'mean of every reading per formula', formulasMeasured: vals.length,
+        const pi = { property: args.property, basis: 'per formula: the readings with no run condition (else the condition tested most) — the mean, a curve at its final point, a distribution at its D50; a ranked scale as its middle grade\'s place on the scale', formulasMeasured: vals.length,
           highest: { formula: hi.f.name, uid: hi.f.uid || null, value: +hi.v.toFixed(4) },
           lowest: { formula: lo.f.name, uid: lo.f.uid || null, value: +lo.v.toFixed(4) } };
         if (vals.length >= 4) {

package/tools/library.js

@@ -12,7 +12,7 @@
 // ============================================================
 
 import { getStore, resolveById } from '../data.js';
-import { _evalPassFail } from './analytics.js';
+import { _evalPassFail, _mcpRepNumber, _mcpMeasType, _resolveSpec, _mcpCondSig, _mcpCondLabel, _mcpCondTags, _mcpParamGroupsOf } from './analytics.js';
 
 // ── Usage roll-ups (mirror the Usage tabs on the Panel / Method / Equipment
 //    detail pages) ────────────────────────────────────────────────────────
@@ -26,7 +26,23 @@ function _resolveInstrument(m, t, db) {
   if (t && (t.equipmentId || t.instrument)) return { equipmentId: t.equipmentId || '', name: t.instrument || '', source: 'run' };
   return { equipmentId: '', name: '', source: '' };
 }
-function _num(m) { const v = parseFloat(m && m.value); return Number.isFinite(v) ? v : null; }
+// A reading's number, the app's rule (13q): a curve's final point, a
+// distribution at the statistic its spec names (D90) or D50, nothing for a
+// grade or text. It was parseFloat(m.value): a curve's point count, "6B" → 6.
+function _num(m, t) {
+  if (!m) return null;
+  const sp = _mcpMeasType(m) === 'distribution' ? (_resolveSpec(m, t && t.templateId).spec || null) : null;
+  const v = sp && sp.stat ? _mcpRepNumber(m, { dist: String(sp.stat) }) : _mcpRepNumber(m);
+  return v != null && Number.isFinite(v) ? v : null;
+}
+// Condition tags for one parameter's arms ('' first): { key → "40 °C" }, only
+// when there are two or more.
+function _condTagMap(keys) {
+  const ks = [...new Set(keys)].sort((x, y) => ((x ? 1 : 0) - (y ? 1 : 0)) || x.localeCompare(y));
+  if (ks.length < 2) return new Map();
+  const tags = _mcpCondTags(ks.map(k => k ? k.split('|').map(p => p.replace('=', ' ')).join(' · ') : ''));
+  return new Map(ks.map((k, i) => [k, tags[i]]));
+}
 function _mean(a) { return a.length ? a.reduce((x, y) => x + y, 0) / a.length : null; }
 function _sd(a) { if (a.length < 2) return null; const mu = _mean(a); return Math.sqrt(a.reduce((acc, x) => acc + (x - mu) ** 2, 0) / (a.length - 1)); }
 function _r(v, d = 3) { return v == null ? null : +v.toFixed(d); }
@@ -163,18 +179,32 @@ const get_equipment = {
     const nm = _norm(e.name);
     const mine = (m, t) => { const r = _resolveInstrument(m, t, db); return r.equipmentId ? r.equipmentId === e.id : (!!nm && _norm(r.name) === nm); };
     const tests = (db.testResults || []).filter(t => (t.measurements || []).some(m => mine(m, t)));
-    const here = new Map(), fleet = new Map();
+    // Per parameter × RUN CONDITION (13q, as the app): a unit that ran the
+    // 40 °C pulls was compared with everyone's ambient readings.
+    const here = new Map(), fleet = new Map(), pairs = [];
     (db.testResults || []).forEach(t => (t.measurements || []).forEach(m => {
       const pn = (m.parameter || '').trim(); if (!pn) return;
-      const v = _num(m); const isMine = mine(m, t); const bucket = isMine ? here : fleet;
-      if (!bucket.has(pn)) bucket.set(pn, { parameter: pn, readings: 0, vals: [], fails: 0 });
-      const g = bucket.get(pn); g.readings++; if (v != null) g.vals.push(v); if (isMine && _evalPassFail(m, t.templateId) === 'fail') g.fails++;
+      const cond = _mcpCondSig(m);
+      const v = _num(m, t); const isMine = mine(m, t); const bucket = isMine ? here : fleet;
+      if (isMine) pairs.push({ m, t });
+      const k = pn + '\u0000' + cond;
+      if (!bucket.has(k)) bucket.set(k, { k, parameter: pn, cond, m0: m, readings: 0, vals: [], fails: 0 });
+      const g = bucket.get(k); g.readings++; if (v != null) g.vals.push(v); if (isMine && _evalPassFail(m, t.templateId) === 'fail') g.fails++;
     }));
-    const measured = [...here.values()].map(g => {
-      const f = fleet.get(g.parameter); const mh = _mean(g.vals), me = f ? _mean(f.vals) : null;
-      return { parameter: g.parameter, readings: g.readings, mean: _r(mh), fails: g.fails, readingsElsewhere: f ? f.readings : 0, meanElsewhere: _r(me),
-        biasPct: (mh != null && me != null && me !== 0) ? _r((mh - me) / Math.abs(me) * 100, 1) : null };
-    }).sort((a, b) => b.readings - a.readings);
+    // The app's order: type groups, the test panel's order; no condition first.
+    const order = _mcpParamGroupsOf(pairs, 'method', db).flatMap(g => g.parameters);
+    const oi = (pn) => { const i = order.indexOf(pn); return i < 0 ? 1e6 : i; };
+    const tagsBy = new Map();
+    here.forEach(g => { if (!tagsBy.has(g.parameter)) tagsBy.set(g.parameter, []); tagsBy.get(g.parameter).push(g.cond); });
+    const measured = [...here.values()]
+      .sort((a, b) => (oi(a.parameter) - oi(b.parameter)) || ((a.cond ? 1 : 0) - (b.cond ? 1 : 0)) || a.cond.localeCompare(b.cond))
+      .map(g => {
+        const f = fleet.get(g.k); const mh = _mean(g.vals), me = f ? _mean(f.vals) : null;
+        const tag = _condTagMap(tagsBy.get(g.parameter)).get(g.cond);
+        return { parameter: g.parameter, ...(g.cond ? { condition: _mcpCondLabel(g.m0), ...(tag ? { column: `${g.parameter} · ${tag}` } : {}) } : {}),
+          readings: g.readings, mean: _r(mh), fails: g.fails, readingsElsewhere: f ? f.readings : 0, meanElsewhere: _r(me),
+          biasPct: (mh != null && me != null && me !== 0) ? _r((mh - me) / Math.abs(me) * 100, 1) : null };
+      });
     const usedIn = _equipUsage(e, db);
     usedIn.testReports = tests.length;
     return { ...(_trimEquipment(e)), usedIn, usage: _usageRollup(db, tests, mine), measured };
@@ -278,15 +308,28 @@ const get_test_method = {
     // Usage = every measurement linked to this method (by id, else by exact name).
     const match = (m) => (m.parameterId && m.parameterId === p.id) || (!m.parameterId && _norm(m.parameter) === nm);
     const tests = (db.testResults || []).filter(r => (r.measurements || []).some(match));
-    const vals = [], byInst = new Map();
+    // Values by RUN CONDITION (13q, as the app): the summary is the plain-name
+    // condition (no condition when there is any, else the most readings), with
+    // byCondition when there are two or more; byInstrument within a condition.
+    const byCond = new Map(), byInst = new Map(), condM = new Map();
     tests.forEach(r => (r.measurements || []).filter(match).forEach(m => {
-      const v = _num(m); if (v != null) vals.push(v);
-      const inst = _resolveInstrument(m, r, db); const key = inst.name || inst.equipmentId || '(unresolved)';
-      if (!byInst.has(key)) byInst.set(key, { instrument: key, readings: 0, vals: [], fails: 0 });
+      const cond = _mcpCondSig(m); if (!condM.has(cond)) condM.set(cond, m);
+      const v = _num(m, r);
+      if (!byCond.has(cond)) byCond.set(cond, []);
+      if (v != null) byCond.get(cond).push(v);
+      const inst = _resolveInstrument(m, r, db); const ik = inst.name || inst.equipmentId || '(unresolved)';
+      const key = ik + '\u0000' + cond;
+      if (!byInst.has(key)) byInst.set(key, { instrument: ik, cond, readings: 0, vals: [], fails: 0 });
       const g = byInst.get(key); g.readings++; if (v != null) g.vals.push(v); if (_evalPassFail(m, r.templateId) === 'fail') g.fails++;
     }));
-    const byInstrument = [...byInst.values()].map(g => ({ instrument: g.instrument, readings: g.readings, mean: _r(_mean(g.vals)), fails: g.fails })).sort((a, b) => b.readings - a.readings);
-    const valueSummary = { readings: vals.length, mean: _r(_mean(vals)), sd: _r(_sd(vals)), min: vals.length ? Math.min(...vals) : null, max: vals.length ? Math.max(...vals) : null, unit: p.defaultUnit || '' };
+    const conds = [...byCond.keys()].sort((x, y) => ((x ? 1 : 0) - (y ? 1 : 0)) || (byCond.get(y).length - byCond.get(x).length) || x.localeCompare(y));
+    const primary = conds.length ? conds[0] : '';
+    const sum = (vals) => ({ readings: vals.length, mean: _r(_mean(vals)), sd: _r(_sd(vals)), min: vals.length ? Math.min(...vals) : null, max: vals.length ? Math.max(...vals) : null });
+    const condName = (c) => c ? _mcpCondLabel(condM.get(c)) : null;
+    const byInstrument = [...byInst.values()].map(g => ({ instrument: g.instrument, ...(conds.length > 1 ? { condition: condName(g.cond) } : {}), readings: g.readings, mean: _r(_mean(g.vals)), fails: g.fails })).sort((a, b) => b.readings - a.readings);
+    const valueSummary = { ...sum(byCond.get(primary) || []), unit: p.defaultUnit || '',
+      ...(conds.length > 1 ? { condition: condName(primary), note: 'measured under more than one run condition: this summary is the readings with no condition (else the condition with the most readings); byCondition has each, never averaged together',
+        byCondition: conds.map(c => ({ condition: condName(c), ...sum(byCond.get(c)) })) } : {}) };
     return { ...(_trimMethod(p, { full: true })), analyteSiblings: siblings, usingPanels, usage: _usageRollup(db, tests, match), valueSummary, byInstrument };
   },
 };