dsh-molbio-tools 0.22.2 → 0.24.0

package/lib/client.js

@@ -4964,6 +4964,16 @@ window.__ModuleLoader__.load({
 			  return entries.map((entry) => `>${entry.id}${entry.description !== '' ? ' ' + entry.description : ''}\n${entry.sequence}`).join('\n') + '\n';
 			}
 
+			/** Render entries as four-line FASTQ text (quality is preserved verbatim). */
+			function toFastq(entries) {
+			  return entries.map((entry) => {
+			    if (typeof entry.quality !== 'string' || entry.quality.length !== entry.sequence.length) {
+			      throw new MolbioInputError(`entry ${entry.id}: sequence and quality lengths differ`);
+			    }
+			    return `@${entry.id}${entry.description !== undefined && entry.description !== '' ? ' ' + entry.description : ''}\n${entry.sequence}\n+\n${entry.quality}`;
+			  }).join('\n') + '\n';
+			}
+
 			/** Summary statistics over parsed entries. */
 			function entryStats(entries, qualityMode = false) {
 			  const lengths = entries.map((entry) => entry.sequence.length);
@@ -5008,6 +5018,7 @@ window.__ModuleLoader__.load({
 			exports.parseFasta = parseFasta;
 			exports.parseFastq = parseFastq;
 			exports.toFasta = toFasta;
+			exports.toFastq = toFastq;
 			exports.entryStats = entryStats;
 			return exports;
 		};
@@ -5051,17 +5062,17 @@ window.__ModuleLoader__.load({
 			 *     from `anchor` and not from the RC-scan `start`. It is the REVERSE primer,
 			 *     and the amplicon ends at `anchor + length - 1`.
 			 *
-			 * NOTE — `designIntronSpanningPrimers` (tool: `molbio_design_intron_primers`)
-			 * deliberately does NOT follow this convention and is unchanged in 0.16.0: it
-			 * reports both primers as sense substrings of the spliced transcript, which is
-			 * what makes its `exon`/`junction_left`/`junction_right` geometry, its
-			 * spliced-vs-genomic mismatch report and its 3'-tail mispriming check read
-			 * uniformly on one sequence. Both ends are therefore reported 5'->3' on the
-			 * sense strand, `forward` is downstream of `reverse`, and the molecule to order
-			 * as the reverse primer is the reverse complement of the reported `reverse`.
-			 * That is a real usability wart, not a silent one (nothing feeds this pair to
-			 * `molbio_pcr_simulate`), so it is recorded on the roadmap rather than changed
-			 * in the same release that moves `designPrimerPairs`.
+			 * `designIntronSpanningPrimers` (tool: `molbio_design_intron_primers`)
+			 * follows the SAME convention since 0.23.0. The junction is carried by the
+			 * REVERSE primer (the assay sits 5' of the junction), so the reverse candidate
+			 * is scanned on the reverse complement of the spliced transcript: every 3'-end
+			 * constraint is then evaluated on the molecule that is ordered, and the hit is
+			 * mapped back to sense coordinates through `anchor` (its 3' end, the LEFT edge
+			 * of its site). `forward` is upstream of `reverse`, the spliced amplicon runs
+			 * from the forward 5' end to the reverse 5' end, and the reported reverse
+			 * sequence is what goes on the order form. Before 0.23.0 the tool reported both
+			 * primers as sense substrings, so `forward` sat downstream of `reverse` and the
+			 * reported reverse was the reverse complement of the molecule to order.
 			 */
 
 			const { DNA_BASES, MolbioInputError, baseCounts, complement, dimerThermo, endGcCount5, endStability5, findRuns, hairpinThermo, normalizeSequence, primerTm, reverseComplement, selfAnyScore, selfEndScore } = __molbio_require("lib.mjs");
@@ -5737,37 +5748,60 @@ window.__ModuleLoader__.load({
 			// ── cross-intron primer design ──────────────────────────────────────────────
 
 			/**
-			 * Mismatch report for cross-intron candidates. Both primer scans run on the
-			 * spliced transcript in the sense orientation (the reported reverse.sequence
-			 * follows the established sense-substring convention of this tool), so the
-			 * mapping is uniform: `template_base` is what a perfectly matching primer
-			 * carries at the position on the spliced transcript, and coordinates come back
-			 * both spliced and genomic.
+			 * Mismatch report for cross-intron candidates. The forward primer is the
+			 * sense-strand substring at its binding site; the reverse primer is the REVERSE
+			 * COMPLEMENT of the sense-strand substring at its site (the molecule that is
+			 * ordered). `anchorStart` is the 0-based sense-strand position of the primer's
+			 * 3' end — for the reverse primer that is the LEFT edge of its site — and
+			 * `isReverse` flips both the perfect-match base and how a primer offset maps
+			 * onto the transcript.
 			 */
-			function intronMismatchReport(candidate, spliced, splicedToGenomic) {
+			function intronMismatchReport(candidate, spliced, splicedToGenomic, anchorStart, isReverse) {
 			  const len = candidate.length;
-			  return candidate.mismatches.map(({ p, base }) => ({
-			    position: p + 1,
-			    template_base: spliced[candidate.start + p],
-			    primer_base: base,
-			    spliced_position: candidate.start + p + 1,
-			    genomic_position: splicedToGenomic[candidate.start + p] + 1,
-			    distance_from_3prime: len - 1 - p,
-			  }));
+			  return candidate.mismatches.map(({ p, base }) => {
+			    const offset = isReverse ? len - 1 - p : p;
+			    const index = anchorStart + offset;
+			    return {
+			      position: p + 1,
+			      template_base: isReverse ? complement(spliced[index]) : spliced[index],
+			      primer_base: base,
+			      spliced_position: index + 1,
+			      genomic_position: splicedToGenomic[index] + 1,
+			      distance_from_3prime: len - 1 - p,
+			    };
+			  });
 			}
 
 			/**
-			 * Design qPCR primer pairs where the forward primer spans an exon-exon
-			 * junction (>= min_junction_bases on each side) so genomic DNA cannot be
-			 * amplified, and the reverse primer sits in a different exon. Coordinates are
-			 * reported both on the spliced transcript and on the genomic sequence.
+			 * The same weights as `mismatchPenalty`, over the snake_case report fields.
+			 * The old intron path handed snake_case reports to the camelCase helper, so the
+			 * 3'-zone surcharge never applied there; this keeps the two conventions apart on
+			 * purpose instead of loosening the shared helper.
+			 */
+			function intronMismatchPenalty(report, zone) {
+			  return report.reduce((sum, mismatch) => sum + 8 + (mismatch.distance_from_3prime <= zone ? 4 : 0), 0);
+			}
+
+			/**
+			 * Design qPCR primer pairs across an exon-exon junction so genomic DNA cannot
+			 * be amplified: the REVERSE primer straddles the junction (>= minJunctionBases
+			 * on each side), the FORWARD primer sits upstream inside a single exon, and the
+			 * spliced amplicon crosses the junction inside the reverse primer's site.
+			 *
+			 * Coordinates are reported both on the spliced transcript and on the genomic
+			 * sequence. Orientation follows `designPrimerPairs` (see the file header):
+			 * `forward.sequence` is the sense-strand substring at its site and
+			 * `reverse.sequence` is the reverse complement of the sense-strand substring at
+			 * its site. The reverse candidate is scanned on the reverse complement of the
+			 * spliced transcript, so every 3'-end constraint (GC clamp, end stability, end
+			 * GC, self-end, hairpin) applies to the molecule that is ordered.
 			 */
 			function designIntronSpanningPrimers(genomic, exons, opts) {
 			  if (!Array.isArray(exons) || exons.length < 2) throw new MolbioInputError('exons must be an array of at least two {start, end} spans');
 			  const sorted = [...exons].sort((a, b) => a.start - b.start);
 			  for (const exon of sorted) {
 			    if (!Number.isInteger(exon.start) || !Number.isInteger(exon.end) || exon.start < 1 || exon.end > genomic.length || exon.start > exon.end) {
-			      throw new MolbioInputError(`exon ${JSON.stringify(exon)} is outside the genomic sequence (length ${genomic.length})`);
+			      throw new MolbioInputError('exon ' + JSON.stringify(exon) + ' is outside the genomic sequence (length ' + genomic.length + ')');
 			    }
 			  }
 			  for (let i = 1; i < sorted.length; i++) {
@@ -5790,33 +5824,39 @@ window.__ModuleLoader__.load({
 			    }
 			  });
 			  if (spliced.length < 24) throw new MolbioInputError('the spliced transcript is too short for primer design');
+			  const splicedLength = spliced.length;
+			  const rcSpliced = reverseComplement(spliced);
 
 			  // v13 target position preference (coordinates on the spliced transcript).
 			  const targetPosition = opts.targetPosition;
-			  if (targetPosition !== undefined && (!Number.isInteger(targetPosition) || targetPosition < 1 || targetPosition > spliced.length)) {
-			    throw new MolbioInputError(`target_position ${targetPosition} is outside the spliced transcript (length ${spliced.length})`);
+			  if (targetPosition !== undefined && (!Number.isInteger(targetPosition) || targetPosition < 1 || targetPosition > splicedLength)) {
+			    throw new MolbioInputError('target_position ' + targetPosition + ' is outside the spliced transcript (length ' + splicedLength + ')');
 			  }
 			  const targetWeight = opts.targetPenalty ?? DESIGN_DEFAULTS.targetPenalty;
 
-			  // Forward candidates must span a junction with minSide bases on each side.
-			  const fwd = [];
-			  for (const candidate of scanCandidates(spliced, 0, spliced.length - opts.lenMin, opts)) {
+			  // Forward candidates: entirely inside one exon on the sense strand.
+			  const fwd = scanCandidates(spliced, 0, splicedLength - opts.lenMin, opts)
+			    .filter((candidate) => splicedToExon[candidate.start] === splicedToExon[candidate.start + candidate.length - 1])
+			    .map((candidate) => ({ ...candidate, exon: splicedToExon[candidate.start] }))
+			    .sort((a, b) => a.start - b.start);
+
+			  // Reverse candidates: scanned on the reverse complement (the ordered
+			  // molecule), then mapped back to the sense-strand 3' end `anchor`.
+			  const rev = [];
+			  for (const candidate of scanCandidates(rcSpliced, 0, splicedLength - opts.lenMin, opts)) {
+			    const anchor = splicedLength - (candidate.start + candidate.length);
+			    const topEnd = anchor + candidate.length - 1;
 			    for (const junction of junctionPositions) {
-			      const left = junction.splicedPos - candidate.start;
-			      const right = candidate.start + candidate.length - junction.splicedPos;
+			      const left = junction.splicedPos - anchor;
+			      const right = topEnd + 1 - junction.splicedPos;
 			      if (left >= minSide && right >= minSide) {
-			        fwd.push({ ...candidate, junction, junction_left: left, junction_right: right });
+			        rev.push({ ...candidate, anchor, junction, junction_left: left, junction_right: right });
 			        break;
 			      }
 			    }
 			  }
-
-			  // Reverse candidates sit entirely inside one exon.
-			  const rev = scanCandidates(spliced, 0, spliced.length - opts.lenMin, opts)
-			    .filter((candidate) => splicedToExon[candidate.start] === splicedToExon[candidate.start + candidate.length - 1])
-			    .map((candidate) => ({ ...candidate, exon: splicedToExon[candidate.start] }))
-			    .sort((a, b) => a.start - b.start);
-			  const revStarts = rev.map((candidate) => candidate.start);
+			  rev.sort((a, b) => a.anchor - b.anchor);
+			  const revAnchors = rev.map((candidate) => candidate.anchor);
 
 			  const tmCenter = (opts.tmMin + opts.tmMax) / 2;
 			  const misprimingIndex = opts.checkMispriming
@@ -5825,48 +5865,52 @@ window.__ModuleLoader__.load({
 			  const maxSites = opts.misprimingMaxSites ?? DESIGN_DEFAULTS.misprimingMaxSites;
 			  const pairs = [];
 			  for (const f of fwd) {
-			    const fwdEnd = f.start + f.length - 1;
-			    const aMin = fwdEnd - opts.ampliconMax + 1;
-			    const aMax = fwdEnd - opts.ampliconMin + 1;
+			    // The reverse site must start after the forward 3' end, and the amplicon
+			    // (forward 5' -> reverse 5') must fit the window. The bounds are widened by
+			    // the primer-length range and the exact length is checked below, because a
+			    // long reverse primer can start earlier and still close inside the window.
+			    const aMin = Math.max(f.start + f.length, f.start + opts.ampliconMin - opts.lenMax);
+			    const aMax = f.start + opts.ampliconMax - opts.lenMin;
+			    if (aMax < aMin) continue;
 			    let lo = 0;
-			    let hi = revStarts.length;
+			    let hi = revAnchors.length;
 			    while (lo < hi) {
 			      const mid = (lo + hi) >> 1;
-			      if (revStarts[mid] < aMin) lo = mid + 1;
+			      if (revAnchors[mid] < aMin) lo = mid + 1;
 			      else hi = mid;
 			    }
 			    for (let i = lo; i < rev.length; i++) {
 			      const r = rev[i];
-			      if (r.start > aMax) break;
-			      if (r.exon === f.junction.down) continue; // reverse primer must sit in a different exon
-			      const gEnd = splicedToGenomic[fwdEnd];
-			      const gStart = splicedToGenomic[r.start];
+			      if (r.anchor > aMax) break;
+			      const ampliconStart = f.start;
+			      const ampliconEnd = r.anchor + r.length - 1;
+			      const ampliconLength = ampliconEnd - ampliconStart + 1;
+			      if (ampliconLength < opts.ampliconMin || ampliconLength > opts.ampliconMax) continue;
+			      const gStart = splicedToGenomic[ampliconStart];
+			      const gEnd = splicedToGenomic[ampliconEnd];
 			      if (gEnd - gStart + 1 < minGenomicSpan) continue;
 			      if (Math.abs(f.tm - r.tm) > opts.maxTmDelta) continue;
 			      const dimer = dimerThermo(f.sequence, r.sequence, opts.ctMolar ?? DEFAULT_CT_MOLAR);
 			      if (dimer.any_tm > opts.maxDimerTm || dimer.end_tm > opts.maxDimerEndTm) continue;
+			      const misK = opts.mispriming3PrimeBases ?? DESIGN_DEFAULTS.mispriming3PrimeBases;
 			      let fMispriming = { count: 0, sites: [] };
 			      let rMispriming = { count: 0, sites: [] };
 			      if (misprimingIndex !== undefined) {
-			        const misK = opts.mispriming3PrimeBases ?? DESIGN_DEFAULTS.mispriming3PrimeBases;
-			        fMispriming = misprimingForCandidate(f, f.sequence.slice(-misK), misprimingIndex, opts, f.start);
+			        // Exclude each primer's own 3'-tail window (not its 5' end).
+			        fMispriming = misprimingForCandidate(f, f.sequence.slice(-misK), misprimingIndex, opts, f.start + f.length - misK);
 			        if (fMispriming.count > maxSites) continue;
-			        // the reported reverse sequence follows the sense-substring convention:
-			        // the real oligo is its reverse complement, so its 3' tail is the RC
-			        // of the FIRST k bases and the intended site is r.start
-			        const rTail = reverseComplement(r.sequence.slice(0, misK));
-			        rMispriming = misprimingForCandidate(r, rTail, misprimingIndex, opts, r.start);
+			        rMispriming = misprimingForCandidate(r, r.sequence.slice(-misK), misprimingIndex, opts, r.anchor);
 			        if (rMispriming.count > maxSites) continue;
 			      }
-			      const fMismatches = intronMismatchReport(f, spliced, splicedToGenomic);
-			      const rMismatches = intronMismatchReport(r, spliced, splicedToGenomic);
+			      const fMismatches = intronMismatchReport(f, spliced, splicedToGenomic, f.start, false);
+			      const rMismatches = intronMismatchReport(r, spliced, splicedToGenomic, r.anchor, true);
 			      const zone = opts.mismatch3PrimeZone ?? DESIGN_DEFAULTS.mismatch3PrimeZone;
 			      let fTargetDistance;
 			      let rTargetDistance;
 			      let targetDistance;
 			      if (targetPosition !== undefined) {
-			        fTargetDistance = Math.abs(f.start + f.length - targetPosition); // spliced 1-based 3' end
-			        rTargetDistance = Math.abs(r.start + 1 - targetPosition);
+			        fTargetDistance = Math.abs(f.start + f.length - targetPosition); // forward 3' end (1-based)
+			        rTargetDistance = Math.abs(r.anchor + 1 - targetPosition);       // reverse 3' end (1-based)
 			        targetDistance = Math.min(fTargetDistance, rTargetDistance);
 			      }
 			      const penalty = 0.6 * Math.abs(f.tm - r.tm) + Math.abs(f.tm - tmCenter) + Math.abs(r.tm - tmCenter)
@@ -5874,8 +5918,8 @@ window.__ModuleLoader__.load({
 			        + 1.0 * Math.max(0, f.self_end - 1) + 1.0 * Math.max(0, r.self_end - 1)
 			        + 0.2 * Math.max(0, f.hairpin_tm - 40) + 0.2 * Math.max(0, r.hairpin_tm - 40)
 			        + 0.2 * Math.max(0, dimer.any_tm - 40) + 0.2 * Math.max(0, dimer.end_tm - 40)
-			        + mismatchPenalty(fMismatches, zone)
-			        + mismatchPenalty(rMismatches, zone)
+			        + intronMismatchPenalty(fMismatches, zone)
+			        + intronMismatchPenalty(rMismatches, zone)
 			        + 8 * fMispriming.count + 8 * rMispriming.count
 			        + (targetDistance !== undefined ? targetWeight * targetDistance : 0);
 			      pairs.push({
@@ -5893,9 +5937,7 @@ window.__ModuleLoader__.load({
 			          spliced_end: f.start + f.length,
 			          genomic_start: splicedToGenomic[f.start] + 1,
 			          genomic_end: splicedToGenomic[f.start + f.length - 1] + 1,
-			          exons: [String(f.junction.up + 1), String(f.junction.down + 1)],
-			          junction_left: f.junction_left,
-			          junction_right: f.junction_right,
+			          exon: f.exon + 1,
 			          mismatch_count: fMismatches.length,
 			          mismatches: fMismatches,
 			          mispriming_count: fMispriming.count,
@@ -5917,11 +5959,13 @@ window.__ModuleLoader__.load({
 			          hairpin_tm: r.hairpin_tm,
 			          end_stability_kcal: r.end_stability_kcal,
 			          end_gc_count: r.end_gc_count,
-			          spliced_start: r.start + 1,
-			          spliced_end: r.start + r.length,
-			          genomic_start: splicedToGenomic[r.start] + 1,
-			          genomic_end: splicedToGenomic[r.start + r.length - 1] + 1,
-			          exon: r.exon + 1,
+			          spliced_start: r.anchor + 1,
+			          spliced_end: r.anchor + r.length,
+			          genomic_start: splicedToGenomic[r.anchor] + 1,
+			          genomic_end: splicedToGenomic[r.anchor + r.length - 1] + 1,
+			          exons: [String(r.junction.up + 1), String(r.junction.down + 1)],
+			          junction_left: r.junction_left,
+			          junction_right: r.junction_right,
 			          mismatch_count: rMismatches.length,
 			          mismatches: rMismatches,
 			          mispriming_count: rMispriming.count,
@@ -5933,7 +5977,7 @@ window.__ModuleLoader__.load({
 			          })),
 			          ...(rTargetDistance !== undefined ? { target_distance: rTargetDistance } : {}),
 			        },
-			        spliced_amplicon: { start: r.start + 1, end: fwdEnd + 1, length: fwdEnd - r.start + 1 },
+			        spliced_amplicon: { start: ampliconStart + 1, end: ampliconEnd + 1, length: ampliconLength },
 			        genomic_amplicon_length: gEnd - gStart + 1,
 			        ...(targetDistance !== undefined ? { target_distance: targetDistance } : {}),
 			        penalty: Math.round(penalty * 100) / 100,
@@ -5944,7 +5988,7 @@ window.__ModuleLoader__.load({
 			  const seen = new Set();
 			  const unique = [];
 			  for (const pair of pairs) {
-			    const key = `${pair.spliced_amplicon.start}:${pair.spliced_amplicon.end}`;
+			    const key = pair.spliced_amplicon.start + ':' + pair.spliced_amplicon.end;
 			    if (seen.has(key)) continue;
 			    seen.add(key);
 			    unique.push(pair);
@@ -7093,12 +7137,27 @@ window.__ModuleLoader__.load({
 			};
 			const WATER = 18.015;
 
-			// Bjellqvist 1993 pK values (EMBOSS-style)
-			const PK = {
-			  Nterm: 8.6, Cterm: 3.6, C: 9.0, D: 4.05, E: 4.45, H: 6.04,
-			  K: 10.8, R: 12.0, Y: 10.3,
+			/**
+			 * Selectable pK sets for the Henderson-Hasselbalch charge model. `bjellqvist`
+			 * is the set `proteinProperties` has always used for its pI; `emboss` is the
+			 * Epk.dat table EMBOSS ships with `iep`. They are NOT interchangeable — the
+			 * reported set name travels with every charge/pI value.
+			 */
+			const PK_SETS = {
+			  bjellqvist: {
+			    label: 'Bjellqvist 1993',
+			    Nterm: 8.6, Cterm: 3.6, C: 9.0, D: 4.05, E: 4.45, H: 6.04,
+			    K: 10.8, R: 12.0, Y: 10.3,
+			  },
+			  emboss: {
+			    label: 'EMBOSS Epk.dat',
+			    Nterm: 8.6, Cterm: 3.6, C: 8.5, D: 3.9, E: 4.1, H: 6.5,
+			    K: 10.8, R: 12.5, Y: 10.1,
+			  },
 			};
 
+			const PK = PK_SETS.bjellqvist;
+
 			const HYDROPATHY = {
 			  A: 1.8, R: -4.5, N: -3.5, D: -3.5, C: 2.5, Q: -3.5, E: -3.5,
 			  G: -0.4, H: -3.2, I: 4.5, L: 3.8, K: -3.9, M: 1.9, F: 2.8,
@@ -7111,30 +7170,37 @@ window.__ModuleLoader__.load({
 			  return counts;
 			}
 
-			function chargeAt(seq, counts, pH) {
+			/**
+			 * Net charge at a given pH by Henderson-Hasselbalch summation. The terminal
+			 * groups count once each; K/R/H are positive, D/E/C/Y negative. `pkaSet` is a
+			 * key of PK_SETS (or a set object), so callers can name the table they used.
+			 */
+			function netCharge(seq, counts, pH, pkaSet = 'bjellqvist') {
+			  const pk = typeof pkaSet === 'string' ? PK_SETS[pkaSet] : pkaSet;
+			  if (pk === undefined) throw new MolbioInputError('unknown pK set ' + JSON.stringify(pkaSet) + '; expected one of ' + Object.keys(PK_SETS).join(', '));
 			  let charge = 0;
 			  const pos = (pKa) => 1 / (1 + Math.pow(10, pH - pKa));
 			  const neg = (pKa) => 1 / (1 + Math.pow(10, pKa - pH));
-			  charge += pos(PK.Nterm);
-			  for (const [aa, pKa] of [['K', PK.K], ['R', PK.R], ['H', PK.H]]) {
+			  charge += pos(pk.Nterm);
+			  for (const [aa, pKa] of [['K', pk.K], ['R', pk.R], ['H', pk.H]]) {
 			    if (counts[aa] !== undefined) charge += counts[aa] * pos(pKa);
 			  }
-			  charge -= neg(PK.Cterm);
-			  for (const [aa, pKa] of [['D', PK.D], ['E', PK.E], ['C', PK.C], ['Y', PK.Y]]) {
+			  charge -= neg(pk.Cterm);
+			  for (const [aa, pKa] of [['D', pk.D], ['E', pk.E], ['C', pk.C], ['Y', pk.Y]]) {
 			    if (counts[aa] !== undefined) charge -= counts[aa] * neg(pKa);
 			  }
 			  return charge;
 			}
 
 			/** Isoelectric point by bisection over the net-charge function. */
-			function isoelectricPoint(seq, counts) {
+			function isoelectricPoint(seq, counts, pkaSet = 'bjellqvist') {
 			  let lo = 0;
 			  let hi = 14;
-			  let chargeLo = chargeAt(seq, counts, lo);
-			  let chargeHi = chargeAt(seq, counts, hi);
+			  let chargeLo = netCharge(seq, counts, lo, pkaSet);
+			  let chargeHi = netCharge(seq, counts, hi, pkaSet);
 			  for (let i = 0; i < 60; i++) {
 			    const mid = (lo + hi) / 2;
-			    const chargeMid = chargeAt(seq, counts, mid);
+			    const chargeMid = netCharge(seq, counts, mid, pkaSet);
 			    if (Math.abs(chargeMid) < 1e-4) return Math.round(mid * 100) / 100;
 			    if (Math.sign(chargeMid) === Math.sign(chargeLo)) {
 			      lo = mid;
@@ -7439,6 +7505,9 @@ window.__ModuleLoader__.load({
 			}
 
 			exports.normalizeProtein = normalizeProtein;
+			exports.PK_SETS = PK_SETS;
+			exports.countAminoAcids = countAminoAcids;
+			exports.netCharge = netCharge;
 			exports.isoelectricPoint = isoelectricPoint;
 			exports.proteinProperties = proteinProperties;
 			exports.peptideDigest = peptideDigest;
@@ -8394,6 +8463,91 @@ window.__ModuleLoader__.load({
 			  return parts.join(' · ');
 			}
 
+			// ── figure cards (the same `tool.call.toolview` seat) ───────────────────────
+
+			/** The meta kind the sequence-logo and gRNA tools attach to their results. */
+			const FIGURE_CARD_KIND = 'molbio-figure';
+
+			const CARD_SUMMARY_MAX = 300;
+			const CARD_PATH_MAX = 500;
+			const CARD_GUIDES_MAX = 5;
+
+			/** A bounded string, or '' when the value is not a string. */
+			function cardText(value, max) {
+			  return typeof value === 'string' ? value.slice(0, max) : '';
+			}
+
+			/** One guide row, validated field by field; malformed rows are dropped. */
+			function cardGuide(row) {
+			  if (row === null || typeof row !== 'object' || Array.isArray(row)) return undefined;
+			  const sequence = cardText(row.sequence, 60);
+			  if (sequence === '') return undefined;
+			  return {
+			    rank: Number.isInteger(row.rank) ? row.rank : 0,
+			    sequence,
+			    pam: cardText(row.pam, 12),
+			    strand: row.strand === 'reverse' ? 'reverse' : 'forward',
+			    start: Number.isInteger(row.start) ? row.start : 0,
+			    end: Number.isInteger(row.end) ? row.end : 0,
+			    score: typeof row.score === 'number' && Number.isFinite(row.score) ? row.score : 0,
+			    offTargets: Number.isInteger(row.off_target_count) ? row.off_target_count : 0,
+			  };
+			}
+
+			/**
+			 * Read a tool-result block's meta into what the figure card draws.
+			 *
+			 * Like `mapCardView`, the value is a projection this package produced itself,
+			 * but the card renders inside the conversation, so every field is checked and
+			 * bounded rather than trusted: a block from an older version, another tool, a
+			 * running call or a failed run must degrade to a notice, never throw.
+			 *
+			 * @param {unknown} meta the block's meta, as the client received it.
+			 * @returns {{kind: 'notice', message: string, ...} | {kind: 'figure', figure:
+			 *   'logo'|'grna', summary: string, svg: string, svgPath: string,
+			 *   csvPath: string, mapPath: string, guides: Array}}
+			 */
+			function figureCardView(meta) {
+			  if (meta === null || typeof meta !== 'object' || Array.isArray(meta)) {
+			    return { kind: 'notice', message: 'No figure data was attached to this call.' };
+			  }
+			  if (meta.kind !== FIGURE_CARD_KIND) {
+			    return { kind: 'notice', message: 'This call carries no figure.' };
+			  }
+			  const figure = meta.figure === 'grna' ? 'grna' : meta.figure === 'logo' ? 'logo' : '';
+			  if (figure === '') {
+			    return { kind: 'notice', message: 'This call carries an unknown figure type.' };
+			  }
+			  const base = {
+			    figure,
+			    summary: cardText(meta.summary, CARD_SUMMARY_MAX),
+			    svgPath: cardText(meta.svg_path, CARD_PATH_MAX),
+			    csvPath: cardText(meta.csv_path, CARD_PATH_MAX),
+			    mapPath: cardText(meta.map_path, CARD_PATH_MAX),
+			    guides: Array.isArray(meta.guides)
+			      // Bound the work before validating, then keep at most five VALID rows:
+			      // malformed entries must not consume the budget and hide good ones.
+			      ? meta.guides.slice(0, 50).map(cardGuide).filter((guide) => guide !== undefined).slice(0, CARD_GUIDES_MAX)
+			      : [],
+			    svg: '',
+			  };
+			  if (!isSvgMarkup(meta.svg)) {
+			    const message = meta.svg_missing === true
+			      ? 'No picture was requested for this call; the numbers are in the tool result.'
+			      : meta.svg_omitted === true
+			        ? `The figure is too large to draw inline (${Math.round((Number.isInteger(meta.svg_bytes) ? meta.svg_bytes : 0) / 1024)} KB); the written file is named below.`
+			        : 'The figure markup did not travel with this call.';
+			    return { kind: 'notice', message, ...base };
+			  }
+			  return { kind: 'figure', ...base, svg: meta.svg };
+			}
+
+			/** The header line for a figure card, with a stable fallback. */
+			function figureCardSummary(view) {
+			  if (view.summary !== '') return view.summary;
+			  return view.figure === 'logo' ? 'Sequence logo' : 'gRNA design';
+			}
+
 			// ── literature library (papers.json) ────────────────────────────────────────
 
 			/** The library file the molbio_paper_* tools write, relative to the workspace. */
@@ -8571,6 +8725,9 @@ window.__ModuleLoader__.load({
 			exports.MAP_CARD_KIND = MAP_CARD_KIND;
 			exports.mapCardView = mapCardView;
 			exports.mapCardSummary = mapCardSummary;
+			exports.FIGURE_CARD_KIND = FIGURE_CARD_KIND;
+			exports.figureCardView = figureCardView;
+			exports.figureCardSummary = figureCardSummary;
 			exports.LIBRARY_FILE = LIBRARY_FILE;
 			exports.readWorkspaceText = readWorkspaceText;
 			exports.parseLibrary = parseLibrary;
@@ -8619,7 +8776,7 @@ window.__ModuleLoader__.load({
 			 * inside the factory would also have to be torn down by hand on unload.
 			 */
 			const { createElement: h, useEffect, useMemo, useRef, useState } = __ext0;
-			const { LIBRARY_FILE, NCBI_KEY_REF, childPath, classifyEntry, credentialInfo, isMolbioDetailSubject, remoteFailure, decodeWorkspaceBytes, filterPapers, isOpenable, libraryTags, logoSvg, mapCardSummary, mapCardView, paperFields, paperLink, paperSummary, parseAlignmentFile, parseLibrary, parsePlasmidFile, plasmidSvg, readWorkspaceText, sortEntries } = __molbio_require("build/panel-core.mjs");
+			const { LIBRARY_FILE, NCBI_KEY_REF, childPath, classifyEntry, credentialInfo, figureCardSummary, figureCardView, isMolbioDetailSubject, remoteFailure, decodeWorkspaceBytes, filterPapers, isOpenable, libraryTags, logoSvg, mapCardSummary, mapCardView, paperFields, paperLink, paperSummary, parseAlignmentFile, parseLibrary, parsePlasmidFile, plasmidSvg, readWorkspaceText, sortEntries } = __molbio_require("build/panel-core.mjs");
 			/** This implementation's identity, and the key its body/title register under. */
 			const PANEL_ID = 'dsh-molbio-tools';
 			/** Type discriminator the tab is opened by. */
@@ -8858,8 +9015,10 @@ window.__ModuleLoader__.load({
 			  return 'Papers';
 			}
 
-			/** The tool names whose transcript card this package draws. */
+			/** The tool names whose transcript card this package draws (plasmid maps). */
 			const MAP_TOOL_KEYS = ['molbio_plasmid_map', 'molbio_plasmid_map_file'];
+			/** Figure tools: a drawn logo / gRNA map plus (for gRNA) the ranked list. */
+			const FIGURE_TOOL_KEYS = ['molbio_sequence_logo', 'molbio_grna_design'];
 
 			/**
 			 * The transcript card for the map tools (`tool.call.toolview`, keyed by tool
@@ -8928,6 +9087,72 @@ window.__ModuleLoader__.load({
 			  return h('div', { style: styles.card }, ...content);
 			}
 
+			/**
+			 * The transcript card for the sequence-logo and gRNA tools. The logo card draws
+			 * the logo; the gRNA card draws the map when `map_path` was requested AND lists
+			 * the top-ranked guides (a gRNA call without a map still gets the table). Like
+			 * the map card it is a pure function of the block, and everything it reads is
+			 * validated and bounded by `figureCardView`.
+			 */
+			function MolbioFigureCard({ block, inspect }) {
+			  const settled = block !== null && typeof block === 'object' && block.kind === 'tool-result';
+			  const view = figureCardView(settled ? block.meta : undefined);
+			  const host = useRef(null);
+			  const svg = view.kind === 'figure' ? view.svg : '';
+			  const [drawError, setDrawError] = useState(null);
+
+			  useEffect(() => {
+			    const node = host.current;
+			    if (node === null) return;
+			    node.replaceChildren();
+			    if (svg === '') return;
+			    const parsed = new DOMParser().parseFromString(svg, 'image/svg+xml');
+			    if (parsed.querySelector('parsererror') !== null) {
+			      setDrawError('the figure markup could not be parsed as SVG');
+			      return;
+			    }
+			    setDrawError(null);
+			    const element = parsed.documentElement;
+			    element.setAttribute('style', 'width:100%;height:auto;max-width:640px');
+			    node.append(document.importNode(element, true));
+			  }, [svg]);
+
+			  const content = [h('div', { key: 'head', style: styles.cardHead }, settled ? figureCardSummary(view) : 'Drawing the figure…')];
+			  if (view.kind === 'figure') {
+			    if (drawError !== null) content.push(h('div', { key: 'drawerr', style: styles.cardNote }, drawError));
+			    content.push(h('div', { key: 'svg', ref: host, style: styles.cardSvg }));
+			  } else {
+			    content.push(h('div', { key: 'note', style: styles.cardNote }, view.message));
+			  }
+			  if (view.guides.length > 0) {
+			    const head = ['#', 'Guide', 'PAM', 'Position', 'Score', 'Off-targets'];
+			    const rows = view.guides.map((guide) => h('tr', { key: guide.rank },
+			      h('td', { style: styles.td }, String(guide.rank)),
+			      h('td', { style: styles.td }, guide.sequence),
+			      h('td', { style: styles.td }, guide.pam === '' ? '—' : guide.pam),
+			      h('td', { style: styles.td }, `${guide.strand === 'reverse' ? '−' : '+'}${guide.start}-${guide.end}`),
+			      h('td', { style: styles.td }, String(guide.score)),
+			      h('td', { style: styles.td }, String(guide.offTargets)),
+			    ));
+			    content.push(h('table', { key: 'guides', style: styles.table },
+			      h('thead', null, h('tr', null, ...head.map((label) => h('th', { key: label, style: styles.th }, label)))),
+			      h('tbody', null, ...rows)));
+			  }
+			  if (view.svgPath !== '') content.push(h('div', { key: 'path', style: styles.cardPath }, view.svgPath));
+			  if (view.csvPath !== '') content.push(h('div', { key: 'csv', style: styles.cardPath }, view.csvPath));
+			  if (settled && block.isError === true) {
+			    const text = (Array.isArray(block.content) ? block.content : [])
+			      .map((item) => (item !== null && typeof item === 'object' && item.type === 'text' ? String(item.text ?? '') : ''))
+			      .join('\n')
+			      .trim();
+			    content.push(h('div', { key: 'err', style: styles.error }, text === '' ? 'The call failed.' : text));
+			    if (typeof inspect === 'function') {
+			      content.push(h('button', { key: 'inspect', style: styles.cardButton, onClick: () => inspect() }, 'Inspect'));
+			    }
+			  }
+			  return h('div', { style: styles.card }, ...content);
+			}
+
 			/**
 			 * The literature panel: the workspace `papers.json` the molbio_paper_* tools
 			 * maintain, rendered as a searchable reading list with a detail pane.
@@ -9276,6 +9501,15 @@ window.__ModuleLoader__.load({
 			      key: toolName,
 			    }, MolbioMapCard)), `molbio panel: ${toolName} card`);
 			  }
+			  // Figure cards: the sequence-logo and gRNA tools declare a `molbio-figure`
+			  // projection; the same component draws a logo or a gRNA map and, for gRNA,
+			  // lists the top-ranked guides even when no map was requested.
+			  for (const toolName of FIGURE_TOOL_KEYS) {
+			    ctx.effect(() => ctx.slots.inject('tool.call.toolview', () => ctx.slots.register({
+			      name: 'tool.call.toolview',
+			      key: toolName,
+			    }, MolbioFigureCard)), `molbio panel: ${toolName} card`);
+			  }
 			  // Plugins -> the installed plugin's detail page: the one place a user can
 			  // store the NCBI key without editing a YAML file or exporting a variable.
 			  //