jean — Molecular Biology & Genomics

Withdraw a research run's pending hypotheses (all of them, or the ones named) so no resume runs them, and return the sealed run file. Nothing is deleted: a canceled hypothesis stays registered and still counts in e-BH with e 1, because it was registered before any result and dropping it would raise the others' chance of support after the fact. Answered and settled hypotheses cannot be canceled. To stop a run that is advancing in budgeted slices, stop calling resume_research_run; cancel when the pending hypotheses should never run.

Merge one or two Sanger reads into a consensus with the ported SeqTrace caller. With two reads (typically a forward and a reverse of the same amplicon) an IUPAC ambiguity code marks a position the two DISAGREE about; with one read there is nothing to disagree with and a code marks a position where no single base cleared the confidence bar. Returns the consensus, how many positions are ambiguous, and how many the consensus's own trimming stage cut from the ends.

SALI activity cliffs (Guha & Van Drie 2008) in a list of small molecules with one activity each: every pair scored as the activity difference over one minus the Tanimoto similarity of RDKit path fingerprints, steepest first; identical fingerprints with different activities score Infinity. Indices are 0-based.

Replace a Sanger read's own base calls with TraceTuner's, on the trace that is open, so the rest of the editor works from the re-called read: its sequence, its consensus, its verification against a reference, and every export. The signal is untouched — this is the same electropherogram with a second opinion about where the bases are — and every coordinate already on the read is carried across the peaks it sits on, so a trim window, a hand-corrected call and an annotation all follow. Reports what moved and what could not be placed. Use `call_bases_from_trace` instead to ASK what the re-call says without changing the read.

Multiple-sequence alignment over several sequences, under either of TWO engines that answer different questions and neither of which is a fallback for the other. `poa` (partial-order, poapy) aligns into a graph, keeps every path a read took and produces its own consensus row — what a pile of reads over one locus wants. `progressive` (biotite) computes Feng-Doolittle distances, clusters them into a guide tree and merges along it under "once a gap, always a gap" — the classic MSA algorithm, what a FAMILY of homologous genes wants, and what a reader coming from Clustal or MUSCLE expects. Wire many upstream `record`/`sequence` outputs into `sequences`, or name library documents.

Say what a genomic region holds in the reference tracks: the genes and RefSeq transcripts it overlaps, which complete coding sequences it CONTAINS (the only case where a residue-level design is honest), the DGV structural variants seen there in control populations with their frequencies, and how much of it lies in segmental duplications and how similar the best paralogue is. Every track answers with its authority, table and retrieval date. Coordinates are 1-based and inclusive, as a person writes chr17:41196312-41277500.

Type the ANTIBODY-ANTIGEN INTERFACE of a deposited complex: which residue of each antibody chain touches which residue of the antigen, how close, and what kind of interaction each pair makes - ionic, polar, weak polar, hydrophobic, aromatic, carbonyl, or a disulfide. The antigen is found rather than named: a protein chain with no immunoglobulin variable domain is the thing being bound. Geometric definitions are CREDO's as Arpeggio implements them, graded contact-for-contact against pdbe-arpeggio. `polar` is the hydrogen-bond criterion WITHOUT the donor angle, because a crystal structure carries no hydrogens; it is the superset an angle test would filter, and no angle-checked hydrogen bond is claimed.

Assign each CDR of an antibody heavy, kappa or lambda variable domain to its canonical structure class: SCALOP's length-independent clusters of known loop conformations (CDR-H1, H2, L1, L2, L3; H3 has no canonical classes). Each loop is scored against every cluster of its length by the cluster's position-specific log-odds; the best score above SCALOP's threshold names the class and its median structure (a PDB chain). Graded against the real SCALOP on every heavy, kappa and lambda chain of ANARCI's PDB benchmark.

Name the CONSTANT region of an antibody chain: which immunoglobulin gene and allele it carries (IGHG1, IGHA2, IGKC, IGLC2 …), and where each IMGT domain sits on it — CH1, the hinge, CH2, CH3, the secretory tail and the membrane exons, or the single C region of a light chain. A domain search says 'a C1-set immunoglobulin domain'; this says which isotype it is. Reads IMGT/GENE-DB's own per-label translations for every species, and is graded against UniProtKB's curated human constant chains and their CH1/hinge/CH2/CH3 regions.

Scan antibody and TCR variable domains for sequence liabilities (Asn deamidation, Asp isomerization, N-glycosylation sequons, Asp-Pro cleavage, Met and Trp oxidation, unpaired or missing conserved cysteines), each placed in its IMGT region so CDR hits can be told from framework ones. Every motif is cited to its source.

Properties of an assembled antibody from its heavy and light chains: molecular weight, isoelectric point, net charge at a pH, and the extinction coefficient and A280 with cysteines reduced and with every pair formed into a cystine, for a Fab (1 heavy + 1 light) or an IgG (2 + 2). Each chain keeps its own termini, so this is not the same as pasting the chains end to end. Graded against Biopython ProtParam over every heavy/light pair of ANARCI's PDB benchmark.

How common each residue of an antibody variable domain is at its IMGT position, and which residues are rarer there than a cut (abYsis's 1% "unusual residue" by default). Two distributions: IMGT's own germline V and J alleles of a species (one count per reference allele), or a bundled Observed Antibody Space repertoire subset (one count per unique expressed sequence; human naive B cells, Jaffe et al. 2022). Graded against independent pandas counts of ANARCI's germline alignments and of every OAS data unit of the subset.

Put the features from a GTF in this project onto the open record. A GTF lists features and their positions and carries no sequence, so this is how one reaches a molecule. It REFUSES unless something says the two are in the same coordinate space: if the file names a genome build and the record names the same one it proceeds; if they name different ones it refuses outright; if either is silent it refuses until you pass coordinates_only, which states that you are applying the intervals as positions in this record's own numbering with no genome correspondence checked. Reports what would not fit rather than trimming it.

Substitute one called ALT allele into a sequence and return the edited bases, the range the edit occupies and the length change. The REF allele is checked against the sequence first and a mismatch REFUSES naming both: applying a call from a different assembly would produce a construct that looks fine and is wrong. Symbolic and breakend alleles are refused for what they are: they name a rearrangement rather than replacement bases.

Turn index sequences into the oligos a synthesiser makes: each index spliced between 5'/3' adapter arms, or onto a PCR primer in either orientation with an optional spacer. Audited for the problems that only exist once tag and oligo are concatenated and that no check of the index alone can see — a homopolymer run across the junction, a 5' tetramer recurring as its reverse complement, and an oligo over the synthesis length guideline.

Stack several CDSs into one contiguous operon, designing a fresh ribosome-binding site in front of each one AGAINST ITS REAL UPSTREAM CONTEXT — which is why the RBS for gene 2 is not the RBS design_rbs would give it in isolation. Returns the assembled sequence, its layout, and each gene's achieved strength.

Run a MULTI-LEVEL assembly plan (DnaCauldron `AssemblyPlan`): several assemblies arranged into dependency levels, where each level's products become parts for the next. Emits the FINAL construct as a record. The plan is DnaCauldron's own spreadsheet shape — one row per construct, `construct_name, part, part, …`.

Assess a small molecule given as SMILES or a molfile: RDKit's descriptors, medchem's drug-likeness rules (Lipinski, Veber, Ghose, Egan, REOS, rule of three, CNS and more) and the papers' own readings where medchem departs from them, with every bound and this molecule's value, a structural-alert screen (PAINS, Brenk, NIH, ZINC and ChEMBL's seven curated sets) with the matched atoms, the molecular formula with its masses and natural-abundance isotope pattern, QED drug-likeness under all three weightings, ESOL aqueous solubility, synthetic accessibility and natural-product likeness, the Bemis–Murcko scaffold and generic framework, the BOILED-Egg's gut-absorption and brain-penetration verdicts, and per-atom logP, polar-surface and charge contributions. Readings are taken with hydrogens implicit, the form the descriptors and the rules' papers assume. An alert flags a nuisance or reactive substructure; it is not a verdict on activity or toxicity.

Check an index set you ALREADY have, rather than designing a new one: the minimum distance between any two, how many errors that guarantees correcting, the full distance matrices, and — optionally — the subset that survives pruning to a stricter error budget. This is the question asked of a set inherited from a kit or a previous experiment.

Check every annotated CDS of one or more GenBank maps against its own bases and genetic code: a frame that does not close (frameshift), a stop inside the reading frame, a first codon the code cannot start with, a last codon that is not a stop, and a /translation the bases do not give. A partial end (< or >) is not judged, and a /pseudo CDS carries no flag. Where an annotation ends without a stop it reads on in frame (round the origin of a circular map) to the first stop and says how many codons that adds, whether it runs into another annotated CDS (a fusion annotated in pieces) and the read-through a random backbone of the same composition would give. Extraction and translation match Biopython on all 1,871 CDS of 695 NCBI vector records.

Find and name known features on the subject — vector parts, origins, resistance markers and tags — by exact match, by local alignment (which finds a diverged copy and reports the identity and coverage that earned it), or by both, on either strand and across the origin, plus Cre/loxP and Gateway att recognition sites. Emits an annotated record, so a downstream map or export carries the annotations.

Protein → DNA: the coding sequence that would encode a protein, weighted by a real codon-usage table. Four rules — the host's most-frequent codon (EMBOSS backtranseq), a draw from the family's real frequency distribution, the IUPAC-degenerate consensus for primers/probes (EMBOSS backtranambig), or DnaChisel's table-free first codon. It does NOT optimize: for restriction-site avoidance, a GC target or repeat removal, follow it with optimize_sequence.

Bayesian protein inference, Epifany (validated against OpenMS BayesianProteinInferenceAlgorithm on PXD000001): the posterior probability that each protein, each indistinguishable group and each peptide-spectrum match is present, from the matches' posterior error probabilities under a network in which present proteins emit their peptides. Shared peptides are weighed between their proteins instead of being counted for each.

Resampling error bars on ONE reaction's Cq. A Cq is read off a fitted model, so its uncertainty is how tightly the observations pin that model down - which propagating a measured spread cannot answer. This refits the curve a few hundred times, either by resampling its residuals or by leaving observations out, and reports the spread of everything the fit produces: every model coefficient, the Cq under each definition, the efficiency and the initial fluorescence, each with the quantiles of the iterations rather than a normal approximation, so an asymmetric interval means the estimate genuinely is asymmetric. Reproduces qpcR 1.4.2's `pcrboot`.

Fill Addgene's own deposit spreadsheet from a record: one row per plasmid with its name and sequence, plus your answers for every plasmid (purpose, plasmid type, cloning method, resistance, growth strain and the other drop-downs). The sheet is fetched from Addgene each run, so its columns and choices are current; a value it would refuse is left out and named, and `columns` lists every column with its choices. It WRITES A FILE and sends nothing.

Build DnaCauldron's assembly report from an assembly result: the per-construct summary table, the constructs and errors spreadsheets as pandas-compatible CSV, and the Outcome / Number of assemblies stats. Wire `golden_gate_assemble` or `gibson_assemble`'s `products`, `errors` and `warnings` outputs into it.

Turn a record into what ENA's Webin-CLI takes for an annotated sequence (`-context sequence`): an ENA flat file (`.embl`) and its manifest. Features are checked against the tables ENA's own validator reads, so what Webin-CLI would refuse (an unknown key, a missing mandatory qualifier, a double quote in a value, a duplicate feature) is refused or rewritten here, by name. A description under 10 characters, an entry under 100 bp and a missing study are reported first. It WRITES FILES and sends nothing.

Turn a record into the SUBMISSION SET NCBI's `table2asn` consumes: a `.fsa` whose defline carries the source modifiers, and a 5-column feature table (`.tbl`) beside it. This is not a GenBank export — GenBank's submission pipeline takes neither a `.gb` nor a plain fasta. Its real work is REFUSING and MIGRATING what GenBank will not accept: twelve feature keys were retired in 2014 in favour of `regulatory` (promoter, terminator and RBS among them, so every plasmid map is affected), a qualifier not on a key's approved list is dropped by name, and an unapproved key is kept as a `misc_feature` carrying its original name. Since December 2024 GenBank has required `collection_date` and `geo_loc_name` on every submission, and both are validated here against the INSDC vocabularies BEFORE a file is written. It WRITES FILES and sends nothing: no account, no key, no upload — `table2asn` stays yours to run, and the submission template it also wants is yours to make.

Power and sample size for a planned experiment: how many replicates a test needs to detect an effect, or what power, detectable effect or significance level a design that is already fixed gives. Leave ONE quantity out with `solve_for` and it is solved; everything else is given. Thirteen tests in two families: Cohen's standardized effect sizes (pwr 1.3-0: t one/two-sample/paired and unequal n, one and two proportions by arcsine h, normal mean, correlation, chi-square w, one-way ANOVA f, linear-model f²) and raw units (R's power.t.test from a difference and SD, power.prop.test from two proportions, power.anova.test from variances). Every number is R's, reproduced: the solved value is uniroot's root at R's tolerance, and an unreachable target is refused with R's own message. Returns the power curve around the answer and the R call that reproduces it.

Sample size and power for an RNA-seq comparison of two groups, one gene at a time: the biological replicates per group needed to detect a fold change at a given sequencing depth and within-group coefficient of variation, or the power, detectable fold change, CV or α a fixed design gives. Leave one of n, cv, effect, alpha and power out (or name it in `solve_for`). Every quantity takes a list, and the answer is the whole grid, so depth against replicates is one call. RNASeqPower 1.52.0 (Hart et al. 2013), reproduced: a negative binomial count with Poisson sequencing noise 1/depth plus biological variance CV².

Call the bases of a Sanger trace from the signal, discarding the instrument's calls and deriving the bases, their positions and their quality from the peaks. The read can come back a DIFFERENT LENGTH than the file's. This ANSWERS the question; `adopt_trace_calls` is what puts the answer onto the read.

Amplification curves to Cq, one row per reaction. Fits each raw fluorescence curve to a sigmoid (l4-l7, b4-b7), reads the Cq off it under any of the seven definitions (cpD1, cpD2, maxE, expR, Cy0, CQ, maxRatio) or at a fluorescence threshold you set (the classic Ct), and returns the per-reaction efficiency and the fit-quality block beside it, so a bad fit is visible next to the Cq it produced rather than hidden behind it. Also reports the two exponential-phase locators (Tichopad take-off, model midpoint), which come back null rather than 0 when a curve has no exponential phase at all.

Call the bases of a Sanger trace AND ask at every position whether a second allele is present, writing a two-base IUB code (R, Y, S, W, K, M) where it is. `mode: het` assumes the two alleles are present in equal amounts, which is the diploid heterozygote case; `mode: mix` assumes nothing about their ratio, for a mixed template, a contaminated read or a pooled sample. The two disagree: on this repo's own corpus they differ on 348 of 5,605 calls. Also returns the ALTERNATIVE calls the search considered and rejected.

A small molecule's tautomers and the canonical one, as RDKit's TautomerEnumerator finds and scores them: 37 hydrogen-shift transforms (after MolVS and Sitzmann 2010), scored by aromatic rings, twelve weighted groups and hydrogens on P, S, Se and Te, ties to the smaller SMILES. Returns every tautomer, the canonical SMILES, the score and the 0-based atoms (implicit hydrogens, molfile order) a hydrogen moved between.

Check a published PCR or sequencing assay against the sequences that are circulating now: for each oligo, where its best binding site is in each genome, how many positions mismatch, and whether a mismatch sits in the 3′ end a polymerase has to extend through. It answers the question an assay's age raises — the design was made against the genomes available on the day, and the target has drifted under it since — as a RATE per oligo with an exact binomial interval, plus the mismatch count at each position of the oligo, which is the shape a manufacturer's own in-silico inclusivity table takes. IUPAC codes in an oligo are read as the breadth its designers meant, so a position a code covers is never a mismatch; a site overlapping ambiguous bases in a submitted assembly is missing data and leaves that genome out of that oligo's denominator rather than counting as a match or a mismatch. A probe gets no 3′-end rate, because it is not extended. Graded against EMBOSS fuzznuc on every oligo of twelve published SARS-CoV-2 assays over 400 genomes.

Will the sequencer SEE these indexes? Per-cycle channel occupancy for a set of index sequences under an instrument's own SBS chemistry, checked against Illumina's rules (no dark cycle, both channels preferred, no GG in the first two cycles), each violation citing the vendor article it comes from — and the same set scored across EVERY chemistry generation at once, because XLEAP moved the dual-color base from A to C and a set balanced on a NovaSeq 6000 is not balanced on a NovaSeq X. This is the color question alone; check_index_pool asks it alongside distance, duplicates and hopping for a whole pool.

Check parts BEFORE a Type-IIS assembly: how many recognition sites each carries, which of them are the two deliberate flanking sites and which are internal sites that will mis-cut the part. This is what answers “why will this assembly not work” — an internal site has to be domesticated (silently recoded) before the reaction can be trusted.

Will this pool of sample indexes actually sequence? One verdict over the indexes a lab is about to load: duplicates, uniform length, the distance the set really guarantees against the distance it claims, per-cycle color balance on the chosen instrument's own chemistry, the index-2 orientation that instrument reads, and index-hopping exposure — how many i7 x i5 combinations exist against how many are in use, and which swaps would turn one sample's read into another's undetectably. Takes a pasted list or a vendor kit by id. It CHECKS a pool; design_barcodes builds one.

Decide whether a sequence is scientifically admissible: protein unchanged, forbidden restriction sites absent, reading frame intact, length/GC/CAI inside stated bounds. Every verdict names what broke, where, and the remedy. Run this after any design or optimisation step, and stop the chain when `admissible` is false — never report a designed sequence without it.

Measure a sequence against what a NAMED synthesis vendor publishes it can make: length, average and windowed GC, homopolymer runs, tandem repeats, long repeats and hairpin-forming inverted repeats. Every threshold is the vendor's own, read from the vendor's own page with the date it was read, and every finding carries the span it is about so it can be drawn. It reports the limits that are MET as well as the ones exceeded, because a list of failures cannot tell a clean sequence from an unchecked one. It never predicts a synthesis outcome and never rules a sequence out: a vendor publishes what it supports, so being outside a published window is a conversation with the supplier, not a rejection.

Whether the host's own methylation blocks the given enzymes ON THIS PLASMID, from REBASE's methylation-sensitivity tables localised onto your sites. The other term of the same reaction question `find_star_sites` answers. It is deliberately per-SITE and not per-enzyme: REBASE says Dam blocks ClaI, and pBR322's single ClaI site carries no overlapping GATC, so the enzyme-level warning does not apply there. An enzyme REBASE has never examined comes back `examined: false`, which is UNTESTED and never a clearance.

Check primer pairs for products off their template, the way NCBI Primer-BLAST does, and rank them by it: each distinct primer is searched against a sequence database at EMBL-EBI with short-query BLAST, hits are paired into products by Primer-BLAST's own mismatch rule, and the template is searched too so the record identical to it is recognized as the intended target. Pairs with no product elsewhere rank first, in the order given, then pairs not checked, then pairs with a named unintended product. Primer sequences and the template LEAVE THE MACHINE; the database is a collection, not an assembled genome, and cannot be filtered by organism.

A QC gate over a TABLE: assert something about every row at once (every band inside a size window, no guide above an off-target score, at least three assays under a penalty). Fails the pipeline (so everything downstream skips) and names the rows that broke the rule.

A Scorpion probe's two melting temperatures, side by side: the stem-loop's own hairpin and the duplex the loop makes with its target on the amplicon. A Scorpion is a primer carrying a stem-loop probe on a non-amplifiable blocker (Whitcombe 1999), and it reports by the loop finding its target and pulling the stem apart - so the design question is a RELATION between those two structures, not a property of either. Returns both temperatures, their difference, the stem's GC, and a verdict against WHATEVER margin you pass. It does not apply a margin of its own authority: the widely-quoted 5-10 °C figure comes from one design tool's tech note and has no primary citation, so the default is labelled as that rule of thumb and every result says which margin produced its verdict.

A QC gate. Compares a wired value against a threshold and PASSES or FAILS the pipeline there — every node downstream of a failed gate is skipped, so a run stops at the first check that does not hold. This is how a pipeline expresses 'only continue if the clone is right'.

ddPCR droplet amplitudes to populations. For TWO targets, a four-way classification — NN, NP, PN, PP — under any of THREE published methods that answer different questions and none of which is a fallback for another. `grid` applies eight fixed thresholds: reproducible and auditable, the only one that does not move when the data does, and the only one that needs someone to have chosen the numbers. `kmeans` clusters both channels at once and names the clusters by where they sit, so it adapts to the well, and it CANNOT abstain because k-means partitions everything. `knn` classifies against a well you have already labelled and abstains into `Rain` when the neighbour vote is weaker than a floor you set, so it is the only one that can decline per droplet. They disagree on the droplets between the populations, and that disagreement is the honest measure of how much an answer rests on the method rather than on the data. Distinct from `gate_droplets`, which asks whether a droplet is EMPTY per channel and ends in a concentration; this asks which of four populations it belongs to. For ONE to FOUR targets multiplexed by amplitude, ddPCRclust names up to sixteen populations from the primary clusters and reports each target's copies per droplet, by any of three first clusterings or their consensus: `density` places the primaries from density gates, `samspectral` from spectral clustering of a faithful sample, `flowpeaks` from the density peaks k-means clusters climb to, and `ensemble` (ddPCRclust's own default) runs all three and keeps the partition that agrees most with the others, with their mean corrected Rand index as the confidence. A plate of exports with ddPCRclust's run template is classified well by well and can be normalised to a constant control.

Which Golden Braid / MoClo / Yeast ToolKit grammar, position and level the open plasmid represents (or null). Reads the record's own annotations, which is what lets an assembled transcription unit be recognised by its backbone half, and what lets a Level-0 module whose own backbone carries an extra site for the release enzyme be told from that backbone. Configured entry vectors are a Parts Bin concept and are NOT available here, so a TU sitting in a named acceptor is reported by its overhangs rather than by that acceptor's name.

Cluster or diversity-pick a list of small molecules on 1 − Tanimoto of Morgan radius-2 fingerprints: Butina sphere exclusion (RDKit ClusterData, optional reordering), MaxMin diversity picking (RDKit MaxMinPicker, seeded), or average linkage (UPGMA) cut into k clusters. Indices are 0-based.

Frequency of optimal codons (Fop, Ikemura 1981) for an in-frame CDS against a real codon-usage table: what share of its codons are the ones a highly-expressed gene in that host would use. Where CAI scores how CLOSE each codon is to its family's best, Fop scores only whether it IS one of the best, which makes it comparable across genes of different amino-acid composition. Name a table this project holds in `table`, or one of the bundled hosts in `host`.

Codon-usage analysis of an in-frame CDS: CAI / expression stats, GC, and every rare-codon occurrence for the chosen organism (pydna port), plus the two bias measures that need NO reference table — ENC (Wright 1990) and RCBS (Roymondal 2009), which are therefore computable for any organism.

How this region's codon usage compares with the record's OTHER genes (CUFS, Diament, Pinter & Tuller 2014). Every other codon score grades one sequence against a reference TABLE; this one grades two sequences against each other, so it stays available for an organism no authority covers. Answers 'does the gene I inserted use codons like the rest of this construct'.

Read an Affymetrix array result's own allele-specific copy number: for each segment the major and minor allele counts (1+1, 2+0, 0+0), what they mean (balanced, allelic imbalance, loss of heterozygosity placed against the sample's own ploidy, homozygous deletion), and ASCAT's whole-genome summary over them (LOH fraction, homozygous deletions, modal allele state, whole-genome doubling, genomic instability). OncoScan results state a split when the aberrant-cell fraction was determined; the tool says why when a file states none.

Join two Affymetrix copy-number samples' own calls and report which events they share and which only one of them carries: for every pair, the chromosome both files resolved to, the kind, the bases they overlap and their reciprocal overlap; and separately each sample's unshared calls. Kind is part of the match, so a gain in one sample and a loss in the other at one locus are reported as two unshared calls rather than as agreement. Chromosomes only one file indexes are listed apart and are NOT reported as differences: nothing about them was compared. NO OVERLAP THRESHOLD IS APPLIED — every pair comes back with its numbers, and which agreement counts as agreement is a laboratory's judgement.

Scan every indexed chromosome of an Affymetrix copy-number container and report what the file itself called: gains, losses and stretches of homozygosity, with their positions, marker counts and spans, plus a per-chromosome summary. Reads the file's own CNState and LOH columns and infers nothing — for a second opinion computed from the log2 ratios, use copy_number_segment. A chromosome that was read and carries nothing is reported as clean, which is a different answer from one that could not be read. NO GENOME BUILD IS ASSUMED: positions are the file's own.

Recompute loss of heterozygosity from an Affymetrix array's own per-marker genotype calls, rather than reading the runs the producer wrote: APT's window method, with the false-positive rate and the assumed genotyping error rate as parameters. Answers where a sample has lost one parental haplotype, including where copy number is normal. Needs a container that states genotype calls — an OncoScan OSCHP does; a CytoScan CYCHP states the set with no rows, and this says so rather than answering empty.

Estimate which mosaic fraction class each region of one chromosome is closest to, as Affymetrix Power Tools computes it. A mosaic event is present in only some of the sample's cells, so its log2 ratio sits between the levels a clonal change would produce. Every segment comes back with the class it was assigned (±0.3, ±0.5, ±0.7, ±1.0), the fraction that class is NAMED for, its confidence, and whether the method CALLED it as mosaic — a whole-copy change of exactly ±1.0 is clonal and is reported with call 0, which is the vendor's own test. The mixture values are class labels, not measured cell fractions: there is no published method for this estimate and no independent implementation to grade it against, so it is reported as APT computes it and the provenance output carries that sentence. A chromosome with fewer than 4,330 markers is refused by name rather than answered empty, because the method's own boundary adjustments would delete every call.

Read an Affymetrix copy-number container (CNCHP/CYCHP/OSCHP/CHP) in this project and say what is in it: the algorithm and array that produced it, its data sets and their graphs, the per-chromosome marker index the file carries, and — for one chromosome — each graph decimated to a summary with its real range. Values the analysis left undefined are counted and reported, never plotted as zero. NO GENOME BUILD IS ASSUMED: positions are the file's own, because these files name an annotation release and not an assembly.

Place an Affymetrix copy-number sample's own calls in ClinGen's curated regions: for each region, which gains, losses or stretches of homozygosity fall in it, at what reciprocal overlap, and how much of the region they cover between them. Regions come from ClinGen's dosage-sensitivity curation, cached with its retrieval date — a loss is reported against the region's haploinsufficiency score and a gain against its triplosensitivity score, and no score is claimed for LOH or mosaic events, which change no copy number. NO THRESHOLD IS APPLIED: every overlap is reported with its numbers and which calls are worth reporting is a laboratory's judgement. Regions ClinGen has not placed on this build are listed separately and are NOT reported as clean.

Segment one chromosome of an Affymetrix copy-number container by up to four independent methods and report where they agree. The HMM lays a copy-number model over the log2 ratios and calls a state per segment; circular binary segmentation finds where the mean changes with no model of what a gain looks like, by permutation test; piecewise constant fitting picks the piecewise-constant curve minimizing squared error plus a penalty per jump, with no test and no seed; PELT minimizes the same shape of objective exactly and prices a boundary with an information criterion rather than a tuned constant, so its segment count follows from a model-selection rule. Every parameter and every default is the canvas's own. NO GENOME BUILD IS ASSUMED and no method is on unless asked for.

Read an Affymetrix array result's own somatic-mutation calls: one row per mutation probe set with the producer's call, the score behind it and the two thresholds that call was graded against. OncoScan CNV Plus states this table; CytoScan and SNP 6.0 results do not, and the tool says so rather than answering empty.

Call HITS from a pooled CRISPR screen: per-guide read counts in, a gene-level Bayes factor and a precision/recall curve out. This is the other end of a screen from the pool designer — it reads what came back rather than deciding what to order. The estimator is BAGEL2 (Kim & Hart 2021), reproduced byte-for-byte against upstream, so a gene's Bayes factor here is the number BAGEL2 prints for the same counts. It is a COMPARISON against two reference gene sets, not an absolute fitness measure, and it reports how many of those reference genes the library actually carries, because a screen whose gene symbols do not match the reference sets trains on almost nothing and still returns a ranking. MAGeCK's alpha-RRA and drugZ are different statistics that disagree with this one on the same counts; neither is computed here, and a hit list must say which statistic produced it.

Design and score CRISPR guides on the subject — on/off-target scores, QC flags, and cloning-enzyme conflicts. Nuclease list comes from the real nuclease registry.

Turn the open record's annotated targets into an ORDERABLE sgRNA oligo pool: the best N guides per target, filtered at order time (Pol-III terminator, Graf inactive motif, cloning-enzyme site, minimum on-target score), each composed into the oligo a synthesiser makes — the vector's cloning overhangs around the spacer plus, optionally, one of CRISPOR's eleven subpool barcodes. A spacer that serves two overlapping targets takes ONE well, and every candidate a filter held back is counted by reason, so a short pool says which rule shortened it. It designs a library; it does not analyse one. No recommended representation, MOI or read depth is embedded — the screen-scale arithmetic is in the editor panel, where the numbers are the user's.

Quantify a CRISPR edit from a pair of Sanger traces — how much of the population was edited, what the indel spectrum looks like, and how well the model fits. Synthego ICE: the CONTROL trace gives the unedited sequence, the EDITED trace is decomposed into a mixture of proposed indels around each guide's cut, and the abundances are fitted. Answers the question a screen cannot: not whether a guide is good, but what it actually did to these cells.

Score CRISPR guides with DeepHF: a predicted knockout EFFICIENCY between 0 and 1 for wild-type SpCas9 (U6 or T7 promoter), eSpCas9(1.1) or SpCas9-HF1. It is not a z-score and not comparable with Rule Set 3 — the two answer different questions and must never be averaged or ranked together. Takes 23-nt protospacers (20-nt spacer + NGG PAM), which is what `crispr_design_guides` produces; a guide whose PAM is not canonical NGG comes back null rather than extrapolated, because the model was trained on NGG only. THE WEIGHTS DOWNLOAD ON FIRST USE, 3-5 MB per model, and scoring is slow by construction: each guide is folded twice, once with the 79-nt tracrRNA scaffold, before the network sees it.

Score CRISPR guides with DeepSpCas9 (Kim et al. 2019, Sci Adv 5:eaax9249): a predicted INDEL FREQUENCY IN PERCENT for wild-type SpCas9. It is a third quantity, not a second opinion: Rule Set 3 is a z-score across a screen and DeepHF is an efficiency in [0, 1], so none of the three may be averaged or ranked together. Takes the 30-nt CONTEXT the model reads whole (4 nt + 20-nt spacer + 3-nt PAM + 3 nt), which is what `crispr_design_guides` reports as `context30`; a 23-nt protospacer is not enough and comes back null rather than padded. Unlike DeepHF it does NOT require a canonical NGG PAM, because its training library was not NGG-only. The output is the network's own linear value and is left unclipped, so a context it scores below zero reads below zero. THE WEIGHTS DOWNLOAD ON FIRST USE, about 0.93 MB, once.

RDKit's R-group decomposition of a list of small molecules on a core given as SMARTS (default RGroupDecomposition parameters): per matched structure its core and substituents R1, R2 …, and the structures the core does not match. Indices are 0-based.

DELTA-BLAST, run on this machine: build a position-specific profile for a protein from the SMART conserved domains it contains, then search other proteins with it (one PSI-BLAST iteration) — more sensitive than BLASTP for distant homologs. Searches the open record's coding sequences unless `subjects` gives FASTA. NCBI BLAST+ 2.17.0's algorithms, checked against the deltablast program on every bundled protein. Nothing is sent anywhere.

Assign reads to the index each one came from, and say how many could NOT be assigned reliably — a hit further from a barcode than the set's guaranteed correction radius is not that barcode, and counting it as one is how a demultiplexing report hides a failed run.

Design a set of NGS sample-index barcodes with a guaranteed minimum distance, and report what that set actually corrects — substitutions, or indels too (DNABarcodes).

Design BSP or MSP primers for a methylation assay, on the CONVERTED strands: after bisulfite treatment every unmethylated C reads as T, which is a different template from the one every other designer sees. BSP primers avoid CpGs so they amplify regardless of methylation state; MSP primers sit ON CpGs so they discriminate. Also reports the CpG islands (EMBOSS cpgplot) the assay should target.

Design CODEHOP hybrid oligos from a block of aligned PROTEIN - for homologues too diverged for nucleotide-level design to see at all. Each primer is a 3' DEGENERATE core over a few conserved residues fused to a 5' non-degenerate consensus clamp, back-translated through a codon-usage table. A different algorithm from the degenerate designer, not a variant of it.

Design degenerate primers from a multiple-sequence ALIGNMENT - the 'amplify every homologue in this family' question, which a single-template designer cannot answer because it only ever sees one sequence. A faithful port of DegePrime (Hugerth et al. 2014). Wire an upstream align_sequences `rows` output straight in, or paste an aligned FASTA.

The expression-design deliverable: several coding sequences for one protein, each variant following a different published strategy (maximise codon adaptation, match the host's codon usage, harmonise with the native host, or preserve the initiation region), each scored by an engine — CAI, GC, the folding energy of the Kudla -4..+37 initiation window, and rare codons. It returns the comparison rather than one answer, because the strategies disagree about what limits expression and the researcher picks. Refuses a frame-shifted CDS, an internal stop or a missing host table rather than optimising nonsense.

Generate INDEL-correcting barcodes — FREE divergence codes (Hawkins et al., PNAS 2018) — by reserving each codeword's error sphere over the whole 4^k space, so the guarantee survives an insertion or deletion rather than only a substitution. Or prune a set you already own down to a valid FREE code, and see which members' decode spheres collided. This is a different construction from design_barcodes' distance-based search, and answers a different question: a Levenshtein-distance set corrects indels between two barcodes, a FREE code corrects them in the read.

Design the PCR primers that ADD Type-IIS fusion sites to a part: enzyme site, spacer and the four-base overhang you chose, on a Tm-matched annealing footprint. This is how a sequence that is not yet a Golden Gate part becomes one, and it is the other half of check_golden_gate_parts — that says which parts are unusable, this makes one usable.

Design a genetic circuit that computes: give it a logic function and it synthesizes a NOR/NOT netlist, assigns real characterized repressor gates from a Cello UCF library, predicts the dynamic range between ON and OFF, and emits the construct's DNA. The gate parameters are MEASURED, from the published libraries, with the host and growth conditions they were measured under reported alongside — never estimated here.

Design the PCR primers that CREATE the terminal homology a Gibson/NEBuilder/In-Fusion assembly needs: a Tm-matched pair per fragment, each carrying the 5' overhang that fuses it to its neighbour in the order given (pydna assembly_fragments). This is the step that turns a planned assembly into oligos you can order.

Design HCR v3.0 split-initiator probe pairs against the subject: tile its reverse complement into 52 nt windows, drop windows with C or G runs, a stable hairpin, G+C or RNA:DNA free energy outside their windows, or (given a bowtie2 alignment of the tiles) more than one genome hit, then pick non-overlapping tiles closest to the target free energy and split each around a 2 nt gap into an odd and an even probe carrying half of the chosen amplifier's initiator. Each stage reports how many tiles it kept.

Design an in-situ hybridization probe against the subject: tile it into candidate oligos that meet a melting-temperature, G+C and composition specification, screen them for off-target binding against an alignment and for k-mers abundant in a reference, and gather the survivors into the set that images best. Merges OligoMiner's tiling, its trained specificity model and its k-mer filter with iFISH's probe-set selection; each stage reports what it removed and why.

The complete build package for a knockout or knock-in, as one object: guides inside the target, an off-target census for the chosen one within this molecule, a repair template with real homology arms, a screening PCR whose primers sit OUTSIDE the arms, the protocol in order, the fragments and oligos to buy, and every coordinate ready for the map. Two donor modes: by default the arms sit on the cut (a point insertion — the target's own sequence is kept on both sides), and with `replace_target` the arms flank the whole target and it is deleted, which is the mode for replacing one CDS with another (an empty insert then deletes the target cleanly). It refuses rather than guessing: no PAM in the target, arms that run off a linear molecule, a screening amplicon that cannot clear the arms, or a non-DNA insert; and in the default mode it WARNS when an insert lands inside the target, because that is a fusion rather than a replacement. Arm length, screening flank and guide count are yours to state, because each follows the delivery method and the organism.

Design LAMP (loop-mediated isothermal amplification) primer SETS - four core oligos (F3 · B3 · FIP · BIP) plus optional loop primers, judged against Eiken's own PrimerExplorer V5 criteria. Not a pair: LAMP needs six binding regions in the published order and the distances BETWEEN them are as much of the design as the oligos. Each set comes back with the arithmetic behind its rank.

Design MERFISH encoding probes for the subject transcript: tile it into target regions, keep those whose G+C and melting temperature fall in their windows, that share no k-mer with an rRNA or tRNA, and whose k-mers occur in this gene's transcripts and nowhere else in the transcriptome; attach readout sequences that spell the gene's codeword, add the amplification primers, screen the whole oligo again, select probes that cover every on-bit evenly with least overlap, and drop probes complementary to one another. Each stage reports how many it kept.

Design QCLM (quick-change lightning multi-site) oligos: one primer per mutated site, all annealing in one reaction, with the codons drawn from an organism's usage table. A design/write.

Design site-directed mutagenesis (SOE-PCR/QuikChange) primers for a point change on a CDS: the ranked inner mutagenic pairs, the constant outer pair, and the single spanning primer that replaces an outer when the site sits too near a CDS end. A design/write.

Lay a set of oligos out as a supplier's PLATE order sheet: one worksheet per plate, in the well order the supplier's own order form fills, with the column shape its loading direction requires. A plate order is addressed BY WELL, which a flat tube list cannot express — so this is the shape an oligo set actually gets ordered in once it outgrows a handful of tubes. With `mixed`, a forward and a reverse share one well, which is what the supplier's doubled mix-plate layouts encode. It WRITES A FILE and sends nothing: no account, no key, no network call.

Design a high-fidelity Golden Gate overhang set of a given size against measured ligation data, optionally pinning junctions you cannot change (a fixed vector's own overhangs). The counterpart to score_overhang_fidelity: that grades a set you already have, this proposes one. The search is greedy-plus-steepest-ascent over the same golden-validated objective: real measured data, a heuristic path, no claim of finding the optimum.

Design padlock probes for in-situ sequencing against the subject: find the two-arm targets whose melting temperature falls in a window, check each against a BLAST search for any other transcript that could be ligated across the junction, pack non-overlapping targets from the 3' end, and assemble each into its padlock with the backbone given. Without BLAST results it returns the targets to search, and says the junction check has not been run.

The Primer Designer's own ranked search: scan the open record for primer pairs inside a product-size, Tm, length and GC window, score every candidate on Tm, dimers, hairpins, 3' stability, repeats, clamp and specificity under weights you set, and return the best N. With `task: existing`, supply one primer and it designs the mate. Emits the top pair so a downstream pcr_amplify runs on it. For a sequencing walk use design_sequencing_primers; for pydna's single-pair designer use design_primers.

Design a forward + reverse primer pair to amplify the subject (pydna `primer_design`), with Tm, Ta and suggested Taq/Phusion cycling programs. Emits both primers so a downstream pcr_amplify runs on them — the design→PCR→gel loop.

Design qPCR assays over the subject — primer pair plus hydrolysis probe, ranked by penalty, with amplicon size/GC, per-oligo Tm and whether both primers bind a single site.

Design a 5'UTR (Shine-Dalgarno + spacer) in front of a CDS to hit a target translation-initiation strength (SC-08 engine, Turner-2004 folding).

Design site-saturation mutagenesis (SSM) primers: one overlapping forward/reverse pair per site, each carrying a degenerate codon, sharing ONE reaction-level overlap and 3' temperature so every site amplifies in the same tube (both of Mutation Maker's solvers: fast approximation by default, exhaustive search on request). Every Tm is Biopython's `Tm_NN` over the Allawi & SantaLucia 1997 nearest-neighbour table (`DNA_NN3`, upstream's own), under the salt correction and buffer below. A design/write.

Design a WALK of sequencing primers that reads a whole region, not one pair: tiled reads with confirmed overlap, on both strands by default, plus the coverage the walk actually achieves and any stretch it cannot reach. This is the 'how do I read all 6 kb of this construct' question, which a single pair does not answer. Read length and dead zone default to a named facility's published figures (MSU RTSF, ABI 3730XL) rather than to round numbers.

Decide where to CUT one sequence into Golden Gate fragments, optimising the split positions and the overhangs they create together. Where design_overhang_set proposes junctions for parts you already have, this fragments a sequence you are about to order: it searches every legal arrangement of fragments in your length window and ranks them by the measured ligation efficiency and fidelity of the overhangs each arrangement produces. Ported from OOGGA (Mukundan & Madhusudhan 2025) and scored against the same Potapov 2018 T4 ligase data the fidelity tools use.

Design Xenium custom-panel padlock targets on the subject transcript to 10x Genomics' published rules (CG000683): two 20 nt arms whose primer3 melting temperatures fall in their windows, a ligation-junction dinucleotide the Xenium ligase accepts, no run of five G in the probe, at least four mismatches across both arms to every other transcript in a BLAST search, and probes at least 10 bp apart. Without BLAST results it returns the targets to search and says the off-target check has not been run.

Ask whether a Sanger trace splits into TWO READS OF DIFFERENT LENGTH, which is what a heterozygous insertion or deletion does: clean up to the indel, then a superposition of two sequences offset by its length. This is not mixed-base calling — that asks whether two BASES sit at one position and is blind to a length difference. Emits where the split starts, how long it is, and the two allele sequences the trace deconvolves into, so a pipeline can gate on the answer or carry either allele onward.

Differential expression from raw RNA-seq read counts, by one of the three standard count models. DESeq2 (Love, Huber & Anders 2014): median-of-ratios size factors, negative-binomial GLM with empirical-Bayes shrunken dispersions, Wald or likelihood-ratio test, Cook's-distance outlier handling, independent filtering, optional LFC shrinkage. edgeR quasi-likelihood (Chen et al. 2025): filterByExpr, TMM normalization, a negative-binomial GLM with bias-adjusted QL dispersions squeezed toward an abundance trend, QL F-test. limma-voom (Law et al. 2014): filterByExpr, TMM, log-CPM with mean-variance precision weights, weighted linear models, moderated t. Takes a gene-by-sample count table and a sample table with the design's variables. Every gene of every validated fit is bit-identical to DESeq2 1.52.0, edgeR 4.10.6 and limma 3.68.5 running in R. Hands its significant genes, tested genes and ranked list on for gene-set enrichment.

Digest the subject with the given enzymes into real fragments (sequence + both overhangs). Emits the selected fragment as a NEW record, so a downstream gel/map/ORF runs on that fragment — the digest→assembly hand-off.

The reaction a digest needs, from NEB's own data: the NEBuffer that serves every enzyme together (scored on the WORST enzyme's percent activity, a star-activity buffer disqualified at any percent), the incubation temperature(s), any cofactor that must be added (SAM or ATP), and each product's heat-inactivation step, or the products NEB cannot heat-inactivate. One call is one tube: enzymes that need different temperatures or have no common buffer come back with `singleTube: false`. Needs no open record.

Score every coding sequence of a genome against the genome's own codon usage and report the genes whose synonymous codon choice that average does not explain, with the false discovery rate controlled across the genes. Records from different files are different genomes: each is scored against its own file's usage, and the false discovery rate is controlled once across every gene of every genome. Each gene gets Karlin's B and Supek & Vlahoviček's MILC against the pooled usage of the genes, and a G-test of its codon choice within each amino acid against that usage (χ², degrees of freedom from the amino acids it uses). Outliers are typically highly expressed genes (ribosomal proteins are the most deviant class), genes of unusual composition, and some of foreign origin; an outlier is NOT evidence of horizontal transfer, since codon bias is a poor indicator of transfer.

Measure how often a corpus of maps carries a cryptic σ70 promoter, a cryptic splice site or a synthesis-breaking repeat MORE EXTREME THAN CHANCE, rather than how many it carries. Every map of a few kilobases spells promoters, splice donors and repeats, so a raw hit count measures length and composition; here each map's own extreme (its most negative promoter ΔG, its highest MaxEntScan donor and acceptor score, its longest homopolymer, tandem repeat, repeated stretch and hairpin arm) is scored against k-let-preserving shuffles of that same map, and the false discovery rate is controlled across the corpus within each statistic. No statistic uses a threshold: none of the three models publishes one, and a vendor's repeat limit is a product's capability, which `check_manufacturability` answers instead. The result is a per-statistic rate with an exact binomial interval, plus every map's own test. Cost is dominated by the σ70 scan at roughly a third of a second per map per shuffle, so a corpus of maps at the default 99 shuffles is minutes of work; drop `flags` to the statistics you need to make it cheaper.

Ask whether a reference-gene stability ranking holds across conditions, and which candidate genes rank well everywhere rather than in one tissue or treatment. Each condition (the Group column of a long-format Cq table) is ranked by geNorm on its own samples; the conditions are then the blocks of a Friedman test and Kendall's W says how far they agree (0 independent orders, 1 the same order everywhere), with an asymptotic χ² p and a Monte Carlo p from shuffling each condition's ranks. Returns every gene's rank in every condition, its mean rank (the meta-ranking) and its best and worst. geNorm cannot order its two most stable genes, so they share rank 1.5 in every condition. Use `rank_reference_genes` for one condition's ranking by all four algorithms.

Ask whether the genes used to normalize expression (reference or housekeeping genes, such as GAPDH, ACTB or B2M) are more or less variable across human tissues than genes of the same abundance, on GTEx v8 median expression. Each candidate's standard deviation of log2(TPM + pseudocount) across the chosen tissues is ranked among the genes nearest it in mean expression (1,000 by default, from the 19,107 protein-coding genes GTEx measures), giving one p for 'more variable than its peers' and one for 'steadier', each corrected across the candidates. The four rankers the field runs (geNorm M, NormFinder, BestKeeper, comparative ΔCt, and RefFinder's consensus) also order the candidates against each other, reading the tissues as samples. A ranker always finds a most stable gene; the null says whether any candidate is stable at all. Tissue medians hide the variation between people within a tissue, so this answers 'across tissues', not 'across samples of one tissue'.

Sweep a set of sequences against every exact recognition site in the NEB catalog and report the sites each one carries far less (avoided) or far more (enriched) often than a stated null predicts, with the false discovery rate controlled across every (sequence, site) test. Avoidance is evidence of the restriction–modification systems a lineage has lived with, and a site a design can rely on being rare. Three nulls: base composition (order-0, Poisson); k-let-preserving shuffles (uShuffle), which holds dinucleotide skews such as CpG depletion in the null rather than reporting them as findings; and R'MES's maximal-order Markov model, the standard in published avoidance analyses, which judges a site of length k against the record's own (k−1)-mers so only what those cannot explain is reported.

Test a hypothesis that a gene drives a phenotype ("gene G regulates IL-2 production") the way POPPER does: each evidence table is one falsification test, an implication of the hypothesis that a gene-level score could contradict (expression in the relevant tissue, association with related disease, interaction with genes annotated to the process). Under the null that G is exchangeable with any gene the tables score, G's p in each table is the share of genes scoring at or beyond it; each p is calibrated to the e-value κ·p^(κ−1), the e-values are multiplied in the order given, and the hypothesis passes when the product exceeds 1/α. The product is a valid e-value only when the tests are independent under the null, so the run also reports the joint p: the product's own share among every gene's product, valid whatever the tables' dependence. Returns every test's score, rank, p, e and running product, the test after which the product first crossed 1/α, and the joint p. Each table is `gene<TAB>score` with one header line; the gene must be in every table.

Silently recode the internal Type-IIS sites inside a part's coding sequence so the part can be used in a Golden Gate assembly — same protein, no recognition site. Only occurrences the given CDS covers can be fixed this way; any outside it are reported untouched rather than skipped quietly, because a site in a promoter needs a different answer.

Self-similarity or pairwise comparison of the subject as a dot plot — repeats, inversions and shared regions. Three real engines: exact k-mer (FlexiDot/dottup), windowed identity (seqinr) and windowed substitution-matrix scoring (EMBOSS dotmatcher), which answer different questions.

All-against-all dot plot over a sequence SET — EMBOSS `polydot`. Every ordered pair is plotted with the exact k-mer engine and laid out as an N×N grid, so shared regions, repeats and inversions across a whole family are visible in one picture. Answers a different question from `dot_plot`, which compares exactly two: this one ranks which members share material and how much. Wire many upstream record/sequence outputs into `sequences`, or name library documents.

Draw a block of an alignment as an SVG figure: the rows named, the residues shaded by how much of their column agrees with them, the column numbers over the block and Easel's Clustal conservation line under it. Wire `alignedSequences` from align_sequences. Name the window around whatever you are asking about — a variable site, a motif, a gap — because a 2,000-column alignment drawn at once shows nothing.

Run an agarose gel and photograph it: every lane's fragments migrated by the validated pydna model, drawn as a gel-doc image with the marker ladder's bp marks and each lane's name. The same plate the gel panels draw, so the figure and the rail put every fragment in the same place. Wire `fragments` from a digest or `lengths` from an assembly into `lanes`. A fragment the calibrating curve cannot place is COUNTED in `offScale`, never drawn at the well.

Draw a window of a Sanger read as an SVG figure: the four dye traces over their called bases, the per-base Phred bars and a base ruler. The same geometry the Chromatogram tab draws with, so the figure and the tab put every peak in the same place. Name the window around whatever you are asking about — a mutation site, a trim bound, an ambiguous call — because a whole 1,000-base read drawn at once shows nothing.

Run a sequence through EMBL-EBI's Job Dispatcher: Clustal Omega, MUSCLE, MAFFT, Kalign, T-Coffee, EMBOSS needle/water/matcher/stretcher, LALIGN, phmmer, hmmscan, PSI-BLAST or Phobius. These are the reference implementations a methods section names, so a local alignment can be checked against the tool the field actually cites. The sequences LEAVE THE MACHINE.

Enumerate a small molecule's protonation states across a pH window with Dimorphite-DL (Ropp et al. 2019): each ionisable group it recognizes (substructures with pKa means and spreads taken from measured pKa values) is kept protonated, deprotonated or both, and every combination is returned as SMILES. Reproduces Dimorphite-DL 2.1.0, including that it neutralizes charged groups first and keeps only the part it neutralized.

Run a reaction SMARTS over lists of reactants, every combination, with RDKit's reaction engine: one list per reactant template, in template order. Pick one of 94 library reactions (the 58 robust organic reactions of Hartenfeller et al. 2011 and 36 click-chemistry reactions, as AutoGrow4 encodes them) or pass your own SMARTS. Each product is sanitised; a product set is kept only when every product in it sanitises. Indices are 0-based.

The effect a power calculation needs, measured from a pilot instead of guessed: two groups of one measurement in a table, standardized as Hedges' g (default), Cohen's d or Glass's Δ with its noncentral-t confidence interval (effectsize 1.0.3, reproduced), and the two-sample t design sized at the estimate and at the interval limit nearest zero. A column can be subtracted row by row first (a reference gene's Ct, giving delta-Ct). Returns the `design` calculate_power takes: Cohen's d for the `t` test, the raw difference and SD for `t_raw`.

Write an index set out in the form the next step needs: a CSV or TSV order sheet, FASTA, an IDT bulk-input sheet of the bare tags, an Illumina BCLConvert SampleSheet, or the actual oligos — adapters built on a template, or primers carrying the tag — with the junction warnings that emission produces.

Write a construct's recorded build out as a document: a methods section, a step spreadsheet, the full decoded record, the molecule carrying its own history as GenBank qualifiers, the whole strategy as an OpenCloning document, the runnable QUEEN script that rebuilds it, or the build as an SBOL 2 document. This is the Export tab of the History & Provenance panel (the same seven writers), refusing the same formats that source cannot produce.

Render the open plasmid's circular map to a publication SVG string — the same figure the Export panel draws, with the same knobs and the same defaults. Give it enzymes to draw the outer restriction-site ring.

Write a Sanger read out in any of the eight formats the trace editor's Export section offers, and hand the file back as TEXT in the pipeline rather than as a download. Reports what the chosen target DROPPED — a read written as FASTA loses its annotations, and every target but FASTQ loses the per-base quality — because those losses are invisible in the file itself. Trims the ends first when asked, by the same three methods the Trim section offers, so a graph does not need a separate step to write a trimmed read.

Convert a tree between the four formats this workbench reads and writes — Newick, NEXUS, PhyloXML and NeXML — sniffing the input format rather than making the caller declare it. Newick loses annotations the richer formats carry, which is why the conversion is a step you choose rather than something done silently on export.

FastQC's report on FASTQ reads, every module a default FastQC run reports: per-base quality boxes, per-tile quality (when the headers carry a tile), per-sequence quality, per-base sequence content, per-sequence GC against FastQC's theoretical normal, per-base N content, sequence length distribution, duplication levels, overrepresented sequences with their possible source, and adapter content, each with FastQC's own pass/warn/fail grade and the limit it was graded on. The numbers are FastQC 0.13.0's, checked against the real program, including its quirks: a read's mean quality is the integer mean of its characters, GC is counted on the read cut to a whole 100 (or 1,000) bases, duplication is counted on the first 50 bases, and an adapter found at a position counts at every position after it, so the curve is cumulative. FastQC does not detect the encoding: Phred+33 unless you say 64. It does not trim or filter anything.

Keep only the rows of a table-shaped output that meet a condition — the bands above a size, the guides over a score, the assays under a penalty. Emits the kept rows plus how many were dropped, so a downstream gate can act on the count.

Fold a guide RNA — the spacer alone, and the whole sgRNA on a real published scaffold — and report which bases of the spacer pair with the scaffold. A spacer that base-pairs into the scaffold disrupts the structure Cas9 binds, which is a physical cause of a dead guide rather than a score. Every free energy is a minimum-free-energy fold under the Turner 2004 nearest-neighbour parameters, in kcal/mol, cross-checked against ViennaRNA 2.7.2.

Minimum-free-energy secondary structure (dot-bracket + ΔG) of an RNA/DNA sequence (Turner-2004).

Theoretical MS/MS fragment ion ladder of a peptide: a, b, c from the N-terminus and x, y, z from the C-terminus, with neutral-loss and radical variants, at each charge up to a maximum (validated against pyteomics, cross-checked against OpenMS). Takes ProForma modification tags (a signed mass, a Unimod name, or UNIMOD:accession) on residues and termini.

Overlap-extension (fusion) PCR — join fragments that share terminal homology into one product, carrying their features across (pydna). Emits the fused product as a NEW record.

Two-channel ddPCR droplet-amplitude exports to a template concentration, by CLASSIFYING the raw droplets rather than trusting a count the instrument already made. Four steps in a fixed order, each of which needs the previous one's output: a k-means quality check marks wells whose two droplet clusters are not separable, a plate-wide 1%-slice IQR cutoff marks outlier droplets, a two-component Gaussian mixture per well per channel sets the empty-droplet cutoff on the droplets that survive, and the empty fraction inverts through the Poisson zero term to copies/uL. Reports the cluster the droplets landed in and the reason any well was rejected, so a failed well reads as rejected rather than as a concentration. This is the counterpart of `quantify_dpcr`, not a duplicate: that one starts from per-well positive COUNTS an instrument already classified, this one starts from the amplitudes and does the classifying.

GC fraction of the subject — whole-sequence, or a sliding window profile (DnaChisel).

Preranked gene set enrichment analysis (GSEA; Subramanian et al. 2005) with fgsea's multilevel p-values (Korotkevich et al.), as clusterProfiler's GSEA() runs it (enrichit 0.2.6): weighted running-sum enrichment score, normalized ES against size-matched permutations, multilevel Monte Carlo p-values down to eps, adjusted p and q-value, rank at maximum, leading-edge genes. Seeded: a seed reproduces upstream's p-values exactly, and every set is bit-identical to enrichit in R on pasilla's DESeq2 Wald statistics against every fly GO term.

Over-representation analysis (ORA): which gene sets hold more of a gene list than chance, by the one-sided hypergeometric test against a background, as clusterProfiler's enricher() runs it (enrichit 0.2.6). Reports gene and background ratios, fold enrichment, odds ratio, z-score, p, adjusted p and Storey q-value per set, and which sets pass both cutoffs. Every tested set is bit-identical to enrichit in R on pasilla's DE genes against every fly GO term.

3D conformers of a small molecule by OpenChemLib's torsion-library generator, each scored and optionally minimized under MMFF94, MMFF94s or MMFF94s+ (whose MMFF94 equals Halgren's OPTIMOL on all 761 validation-suite structures), lowest energy first, as molfiles with every hydrogen; for a 3D molfile also the energy of its own geometry. Energies in kcal/mol.

Principal components of a call set's genotypes, the population-structure picture: biallelic sites above a minor-allele count, LD-pruned by sliding windows, scaled per site (Patterson, standard or centring) and decomposed; every sample's coordinates with its population, and the variance each component explains (scikit-allel pca). Validated on 1000 Genomes phase 3 APOL1, all 2,504 samples.

Assemble fragments by terminal homology (Gibson / NEBuilder / In-Fusion, DnaCauldron). Emits the first product as a NEW record for downstream nodes.

Assemble parts with a Type-IIS enzyme (Golden Gate / MoClo, DnaCauldron). Emits the first construct as a NEW record for downstream nodes.

Humanize an antibody variable domain by CDR grafting: find the closest human germline V and J, merge them into an acceptor framework, and put the parental CDRs onto it. The classical humanization route, and the counterpart to humanize_antibody's language model. Reproduces abnumber 0.4.4 over every antibody chain of ANARCI's PDB benchmark.

Render a construct's build history into a numbered bench-recipe protocol.

Humanize an antibody variable domain with Sapiens, the antibody language model behind BioPhi: score every position against human repertoires, take the highest-scoring residue in the frameworks, and keep the parental CDRs (and optionally the Kabat Vernier zone). Reports every mutation, and what the model would change next. Validated against the published PyTorch model on every chain of ANARCI's PDB benchmark.

Protein inference from peptide-spectrum matches (validated against OpenMS BasicProteinInferenceAlgorithm on PXD000001): maps each peptide to the protein database, keeps the best match per spectrum, scores each protein by aggregating its peptides' best scores, reports the proteins its evidence cannot tell apart as indistinguishable groups, and the percent of each sequence the matches cover.

Coarse isotope pattern of a peptide or of an elemental formula (C29H31N7O, as a compound's formula reads): the relative heights and masses of its M, M+1, M+2 … peaks as an instrument that does not resolve isotopic fine structure sees them, computed by per-element convolution from natural abundances (validated against OpenMS).

The most probable isotopic composition of a peptide (e.g. how many 13C atoms it most likely carries) and that composition's relative abundance, from natural isotope abundances (validated against pyteomics).

Ligate fragments by their overhangs (pydna ligation_assembly) — sticky, optionally blunt. Each input may be digested by its own enzymes first, which is the digest → ligate hand-off. Emits the first product as a NEW record.

Linkage disequilibrium between every pair of biallelic sites of a call set: the dosage correlation r of Rogers and Huff (scikit-allel), or haplotype r² and D′ from the maximum-likelihood two-locus haplotype frequencies (PLINK 1.9 --r2 dprime-signed), plus LD pruning by sliding windows (scikit-allel locate_unlinked). Validated on every pair of 1000 Genomes phase 3 APOL1 sites.

Principal components of a list of small molecules, computed as R's prcomp computes them, on the scaled property table or on Morgan radius-2 bits: each structure's scores on PC1 and PC2, every component's standard deviation and variance share, the property loadings, and constant properties left out. Indices are 0-based.

Predict which reactant atom each product atom came from (atom-to-atom mapping) with RXNMapper (Schwaller et al., Sci. Adv. 2021), the most accurate mapper in Lin et al.'s 2022 benchmark of 1,851 curated reactions. Agents join the reactants, each compound is canonicalised and each side sorted before mapping, as RXNMapper does. Returns the reaction SMILES with atom maps and a confidence (the product of each product atom's attention score). A prediction, not a measurement.

Mask the parts of a sequence a similarity search should not seed on, using BLAST's own three maskers: DUST for compositionally biased DNA (poly-A, simple repeats), SEG for the protein equivalent, and WindowMasker for repeats that are ordinary in composition but occur far more often than chance allows in the sequences given. Emits the soft- and hard-masked sequences and the masked intervals, so a pipeline can mask before it searches rather than explaining an empty hit table afterwards.

Identify a stretch of DNA by asking the iGEM Registry which published part carries exactly those bases, and hand back that part's own description, Sequence-Ontology role, literature citation and license. The match is decided by comparing bases, never by a name — so a pipeline can label a fragment it has assembled, or check that a feature really is the part it is called.

Matched molecular pairs (Hussain & Rea 2010) in a list of small molecules, as mmpdb finds them: pairs that differ by one change no larger than a heavy-atom limit, grouped by the change as a reaction SMIRKS, most pairs first. Indices are 0-based.

DNA melting behaviour of the subject by the Poland–Scheraga model (DECIPHER): the melt curve (mean helicity vs temperature), its Tm50, and the cooperatively-melting domains behind each HRM peak.

The melting temperature of an oligo IN A BUFFER, UNDER A MODEL — and the working, not just the number. Nearest-neighbor (SantaLucia & Hicks 2004 · Allawi & SantaLucia 1997 · Sugimoto 1996 · Breslauer 1986), pydna's dsDNA-binding-domain model, the GC formula, the Wallace rule or NEB, over the salt correction you name, then DMSO and formamide depression under the published model you name. LOCKED NUCLEIC ACID is understood: write the probe as it is ordered, with an L after each locked base (GTCGLAACAGC), and McTigue, Peterson & Kahn's (2004) per-neighbor increments are added to the nearest-neighbor sum. Returns the per-step breakdown the panel shows, so a pipeline can read WHICH coefficient produced a ΔTm rather than a bare temperature.

The MIQE 2.0 checklist for a qPCR paper (Bustin et al. 2025, Clin Chem 71:634, Table 1): every item in its five sections, with your answers. Each answer is Provided (yes or no) and Description/Justification: where in the article when yes, why it is omitted when no; an answer missing that is named. Returns every row, the counts and a TSV under the paper's headers. Run with no answers to read the item ids. Digital PCR has its own checklist, dMIQE 2020.

Screen a primer POOL against one or more templates: every predicted product, per-primer off-target binding, the pairs that tell templates apart on a gel, and the all-against-all primer-dimer matrix a pool actually lives or dies by (pydna primer_screen + primer3 thal).

Extract @plasmid / !action / &gel cross-references from a lab-notebook markdown body.

Run the DnaChisel optimizer over the subject with real constraints/objectives (GC window, pattern avoidance, translation enforcement, …). Emits the optimized sequence as a NEW record for downstream nodes.

Amplify the subject template with a forward + reverse primer (pydna Anneal). Emits the first product as a NEW sequence record so downstream tools (digest, gel, map) operate on the amplicon, not the template — the tool→tool hand-off.

Monoisotopic and average mass of a peptide, and its m/z at each charge state (validated against pyteomics). Plain one-letter sequences also take an ion type (b, y, c, z, a, x and their neutral-loss forms); a ProForma peptidoform with modification tags, as masses or Unimod names and accessions (e.g. [TMT6plex]-PEPTM[Oxidation]IDE, M[UNIMOD:35], M[+15.994915]), is weighed monoisotopically with its modifications.

Rejoin two branches: takes the outputs of several conditional steps and emits the first one that actually ran. This is how a two-way branch comes back together: wire both arms in, and whichever arm ran is what continues.

What can run next, and what each next step would add. Give it a tool whose run just finished (or the output types in hand) and it returns the tools whose own declared inputs those outputs fill, each with the parameter the wire lands on, the question that tool answers, its limits, what grades it, whether it is seeded, asynchronous, writing or leaving the machine, and which of the data files it reads the run in hand already read — so a step that would re-read the same table can be told from one that brings independent evidence. Ask for a `target_type` and it returns the shortest chains of tools that reach it. The hand-offs are the workflow builder's own port graph, so a step it names is a wire the builder would draw.

How many biological replicates an RNA-seq experiment needs when the question is about the WHOLE experiment rather than one gene: the exact negative-binomial test with the per-gene α derived from a target false discovery rate across m genes of which m1 are expected to move (RnaSeqSampleSize 2.23.0, Zhao et al. 2018; the test is Robinson & Smyth 2008's, edgeR's exactTest), or the AVERAGE power across genes whose effects differ, with the FDR controlled (ssizeRNA 1.3.3, Bi & Liu 2016). Give `solve_for` n to size the experiment or power to score a design. With `counts` and `dispersions` from a pilot, the power is computed per gene over that real distribution rather than for one idealised gene. Unlike calculate_rnaseq_power this makes no normal approximation, so it is the one to use at small n or low counts.

Plan the cycling programme for an amplicon on a NAMED enzyme, and check the reaction against that manufacturer's own published limits. The extension rate and the denaturation step come from the product's datasheet and protocol manual; the annealing temperature is yours (from design_primers or pcr_amplify), and anything the manufacturer does not publish comes from the pydna-faithful Taq or Phusion/Q5 preset — the result says which numbers came from where. The check reports the product as a percentage of the vendor's stated maximum, the extension time its rate implies, the substitutions expected per molecule and the fraction of molecules that should be error-free, each finding quoting the specification line it rests on.

Individual ancestry coefficients, the ADMIXTURE-style picture: each sample as a mixture of K ancestral populations, fitted by sparse non-negative matrix factorisation for every K in a range, with K scored by the cross-entropy of predicting genotypes held out at random (LEA snmf, Frichot et al. 2014). Single-base records only, as LEA's vcf2geno keeps them. Validated against LEA 3.19.8 on every record and sample of 1000 Genomes phase 3 APOL1.

Differentiation between populations of a call set: Weir and Cockerham's θ over two or more populations, or Hudson's or Patterson's Fst between pairs, per site and averaged with a block-jackknife standard error (scikit-allel). Every pair when more than two populations are compared. Validated on every site of 1000 Genomes phase 3 APOL1 for the 5 super-populations and 26 populations.

Per-site and per-sample genotype statistics of a call set, for all samples or one population: allele counts and frequencies, called and missing calls, heterozygous and homozygous counts, observed and expected heterozygosity and the inbreeding coefficient F (scikit-allel), and the exact Hardy–Weinberg test with its excess-heterozygosity tail (bcftools +fill-tags). Validated on every site and sample of 1000 Genomes phase 3 APOL1 in 32 groups.

Where a primer anneals on the open plasmid: 3'-anchored sites with identity % and the ✓/⚠/~/✗ verdict, graded at a bar you can move and that the answer states. The scan is 3'-anchored, so every site it reports matches the oligo's 3' seed exactly and 'no sites' means no seed match rather than a low score.

Uncertainty through any qPCR quantity, three independent ways at once. Give it the expression you actually report - a ratio, a normalised expression, an efficiency-corrected quantity - and a mean and standard deviation for each variable in it (or the replicate observations themselves), and it returns the analytic Taylor propagation, a Monte-Carlo simulation and a permutation resampling side by side, because they disagree in informative ways: the Taylor arm is exact only for a linear expression, and a ratio is not linear. Also reports the derivative per variable and how much of the total variance each one contributes, which is the answer to "which measurement should I make more precisely?". Reproduces qpcR 1.4.2's `propagate`.

In-silico proteolytic digest of a protein (ExPASy PeptideCutter / PeptideMass): peptides with coordinates, average and monoisotopic masses, m/z per charge state, and the MS mass-window filter. 49 proteases and chemicals — or an enzyme of your own written in RPG rule grammar — one or several at a time; a multi-enzyme digest runs concurrently (all at once, products re-digested until nothing changes) or sequentially (one result per enzyme).

Intrinsic disorder along a protein by FoldIndex (Prilusky 2005): I_F = 2.785·⟨H⟩ − |⟨R⟩| − 1.151 over a sliding window, where ⟨H⟩ is mean normalized Kyte-Doolittle hydropathy and ⟨R⟩ the mean net charge per residue. Negative means predicted unfolded. Reports the whole-protein score, the per-window series, the runs below zero, and the Uversky charge-hydropathy point with the boundary it was judged against.

Per-residue intrinsic disorder by metapredict (Emenecker, Griffith & Holehouse, Biophys J 2021; V2/V3 the lab's successors), a bidirectional LSTM trained to reproduce a consensus of disorder predictors, run locally. Reports a 0–1 score per residue, the IDRs and folded domains its domain caller draws from the smoothed profile, and the percentage of residues at or above the network's threshold. A different question from protein_disorder's FoldIndex, which reads composition alone.

Eisenberg hydrophobic-moment plot along a protein: per-window mean hydrophobicity and moment, each classified Globular / Transmembrane / Surface-seeking, plus those windows collapsed into residue spans. A hydrophobicity-based prediction, NOT a trained topology model.

Windowed physicochemical profile along a protein (ExPASy ProtScale). Pass `scaleId` for any of the 57 scales ProtScale publishes plus the 14 Biopython tables it does not, with optional 0-1 normalisation; or pass `kind` for the five ProtParam profiles (hydropathy over the 28 GRAVY scales, Vihinen flexibility, Hopp & Woods hydrophilicity, Emini surface accessibility, Janin interior-to-surface transfer). Returns one value per window with the residue it centres on.

Molecular weight (average + monoisotopic), molecular formula, isoelectric point, instability index and amphipathicity (Boman index, Eisenberg hydrophobic moment) of a protein sequence (Biopython ProtParam + `peptides` + `pyteomics`).

Signal-peptidase cleavage sites in a protein, by von Heijne's (1986) weight matrix as implemented by EMBOSS sigcleave. Scores a 15-residue window at every position (the 13 residues before the cut plus the first two after) against either the eukaryotic or the prokaryotic training set. Predicts WHERE the cut would fall, not WHETHER the protein is secreted — a high score away from the N-terminus is a look-alike, not a secretion call.

Transmembrane topology of a protein by the HMM-TM 114-state hidden Markov model (JUCHMME, Bagos et al.), decoded residue by residue into inside / transmembrane-helix / outside runs. Reports the labelled path, the runs as residue spans, and the per-residue posterior. Needs the trained model, which the host loads once per session — this refuses by name when it has not been.

Quantify BASE EDITING from a single Sanger trace, with no control read — the EditR method (Kluesner et al. 2018), ported and graded against the authors' own R. A base editor makes no double-strand break and no indel, so it is invisible to ICE and TIDE: the edit is a C→T or A→G inside the protospacer that shows up only as a second peak under the called base. This models the trace's OWN background from the positions outside the guide, then p-values every base of the guide against it. Emits the significant calls, so a pipeline can gate on whether editing happened and at which position.

Digital PCR (dPCR) partition counts to absolute concentration, with no standard curve. Positives and accepted partitions become lambda = -ln(1 - k/n), lambda becomes copies per uL through the partition volume and the dilution chain, and the confidence interval is carried on the lambda scale under any of eleven published binomial interval methods. Returns the dMIQE-2020 occupancy QC beside every reading, so a well with no positives, or one saturated past 95% occupancy, is reported as such rather than as a number.

Rank candidate experiments by what running them would TEACH — Lindley's expected information gain, the drop in uncertainty about a hypothesis expected before anything is run. Three grains: `tests` ranks candidate falsification tests against the beliefs a discovery ledger holds, each with the posterior its two outcomes would leave, by gain and separately by gain per unit cost; `measurements` says what n readings of a normal quantity would teach, and how many it takes to reach a target; `trials` says the same for a rate held as a Beta. A gain is what a result would settle whichever way it lands — never evidence that a hypothesis is true, which stays with the ledger's e-values.

Which candidate reference gene is actually stable, ranked by all four published algorithms at once plus the RefFinder consensus: geNorm (pairwise variation M), NormFinder (intra/inter-group variance), BestKeeper (SD of raw Cq and correlation to the index) and the comparative delta-Ct method. They disagree on real plates, which is the point of running them side by side; the consensus is the geometric mean of the four ranks. Also returns geNorm's pairwise variation V(n/n+1), whose 0.15 cutoff is what says HOW MANY genes to normalise to.

Which candidates in a table are not beaten on every objective at once: Pareto (non-dominated) sorting of rows scored on several columns, each to maximize or minimize. Returns each candidate's front (1 = non-dominated), the candidate one front up that beats it, and its crowding distance within its front (how isolated it is, so a short list can be spread along the front). Rows can be filtered first (`em_max>=580, agg=m`), and rows with an empty objective are left out and counted, never ranked last. moocore 0.3.2's pareto_rank and is_nondominated, emoa 0.5-3's and pymoo 0.6.2's crowding distances, reproduced.

Recombination between molecules — Gateway BP/LR (att sites), Cre/loxP, a serine integrase whose two half-sites you supply, plain homologous recombination through shared arms, or a CRISPR knock-in that keeps only products whose repair region contains every guide's cut. Emits the first product as a NEW record for downstream nodes.

Re-score a Sanger trace's own base calls from the signal, replacing the instrument's Phred values with ones measured from the peaks. Keeps the bases; only their quality changes. Reports the read's mean quality, its lowest-scoring base and the four trace parameters that base was scored from, which are the whole input to the quality table.

What the subject record is MADE OF: molecular weight under its own topology and strand count, GC and AT over the resolved bases, and the per-symbol census with the ambiguity codes broken out. The nucleic-acid counterpart of `protein_properties`, and the same derivation the editor's Properties panel, its inspector and the alignment inspector all draw (Biopython's mass model; ProtParam for a protein subject).

Write what just happened into your lab notebook: a new entry, or more text appended to one you name. The body is markdown and its @plasmid / !action / &gel references are extracted as you write, so an entry made by a run is cross-linked exactly like one you typed — and carries the `automated` tag, so you can always tell which is which. Use it to end a pipeline with a record of itself instead of a reminder to write one.

Relative gene expression from a Ct table, by all THREE models the Analyze panel offers: delta-delta-Ct (normalised to a reference gene AND calibrated to a reference group), delta-Ct (calibrated to a reference group only), and the two-step standard-curve model, which fits each gene's own dilution series and converts Ct to amount before taking the ratio. Reproduces the `pcr` package's `pcr_ddct`/`pcr_dct`/`pcr_curve`, including its separate-tube and same-tube estimators, which differ in WHEN the subtraction happens and are not a display option. A significance test runs beside the model on request - Welch t-test, the equivalent linear model, the Wilcoxon rank-sum test with R's own exactness rule, or a design-matrix lm for designs the two-group form cannot express - and delta-delta-Ct's equal-efficiency assumption can be checked in the same run.

Remember what this lab uses, so the PCR program, primer design and codon optimization start on it: the polymerase, the primer length and GC windows, and the expression host. Use it when the user says what they use ("we use Q5", "our primers are 20 to 24 nt"). Saved where the user reads and edits it, Settings · Lab; each panel still says when it is showing the lab's choice, and a project can still choose otherwise. Enzyme supplier order is saved in Enzyme Collections, not here.

Read a research run file without running anything: whether its seal holds (an edited or truncated file is refused), every hypothesis's verdict and the rule its evidence was merged by, which hypotheses a resume would run (no evidence, and the last attempt failed or was deferred by a call's budget) and which are settled or canceled, and what resuming would do. Given the corpus, also reports every pinned input whose content changed under the same name, which a resume refuses.

Put an open Sanger read back on the base calls its FILE carries, undoing an adopted re-call. The same carry runs in the other direction, so the trim window, the hand-corrected calls and the annotations come back with it rather than being left on indices the file does not have. Not the same as clearing the read's edits, which also discards the trim and the manual calls.

Cut and ligate in ONE POT (pydna restriction_ligation_assembly): every input is digested by the same enzymes inside the reaction and the pieces are joined as they appear, so a junction that re-forms a recognition site can be cut again. This is the reaction Golden Gate is a special case of, and it is a different chemistry from ligate_fragments, which digests first and then ligates whatever the digest left. Reports how many sites of the FIRST enzyme each product still carries — a finished construct has none.

Continue a research run from its file after an interruption or a failed test: the seal is checked, every pinned input the corpus still holds must have the content it had (a changed file is refused by name), and only the hypotheses with no evidence whose last attempt failed or was deferred are run, each with the settings it was registered with. Answered, settled and canceled hypotheses are never run again, so a resumed run reaches the verdicts an uninterrupted one would. With budget_seconds, a long run continues in slices: call again with the returned file until nothing is pending. Returns the updated run file with the same outputs as run_discovery_programme.

Reverse-complement the subject sequence. Emits a NEW record, so downstream nodes (map, digest, gel, ORF) run on the revcomp rather than the original.

RPS-BLAST a protein against NCBI's Conserved Domain Database (CDD) or one of its member collections (Pfam, SMART, COG, KOG, PRK, TIGR, NCBI-curated), through NCBI Batch CD-Search. Returns every domain hit with its hit type (specific, non-specific, superfamily, multi-domain), residue span, E-value, bit score, CDD accession, superfamily cluster and whether the alignment stops short of either end of the model. This is the rpsblast program. Give `protein`, or give `dna` to send its six reading frames as six proteins (per-frame CD-Search: each E-value is for its own frame, which is not rpstblastn; rpstblastn_smart runs rpstblastn itself on this machine). The query leaves the machine for NCBI.

rpsblast, run on this machine: find conserved domains in a protein against NCBI's SMART domain models (1,011 PSSMs from CDD). NCBI BLAST+ 2.17.0's algorithms, checked against the rpsblast program on every bundled protein. Nothing is sent anywhere; for all of CDD use rps_blast_cdd, which goes to NCBI.

rpstblastn, run on this machine: find conserved domains in DNA by searching all six reading frames against NCBI's SMART domain models (1,011 PSSMs from CDD). Leave `sequence` empty to search the open record. NCBI BLAST+ 2.17.0's algorithms, checked against the rpstblastn program on every bundled GenBank record. Nothing is sent anywhere; for all of CDD use rps_blast_cdd on a translated protein.

Run a discovery program end to end under pre-registration: every hypothesis names its test (discover_site_avoidance: a site, optionally a record, and its null; discover_codon_outliers: a gene and its genetic code; validate_gene_trait: a human gene, the trait's own gene or tissues, and GWAS Catalog categories; discover_flag_rates: a cryptic-element flag, optionally a record, against k-let shuffles; discover_tree_incongruence: a locus of a multi-locus alignment, by the ILD test; discover_gene_tree_discordance: a gene alignment against a species tree, by the SH test; discover_reference_stability: a candidate reference gene against its GTEx abundance peers; discover_annotation_contradictions: a UniProt signal peptide or transmembrane segment against the experimentally confirmed ones; discover_reference_concordance: a Cq table whose conditions should rank its reference genes alike) and direction, and all are registered in a hypothesis ledger before any test runs. Each registered test then runs once over the corpus, every answering result is attached as a κ-calibrated e-value (evidence from another test, a changed parameter or the same data twice is refused and reported), and e-BH decides over all hypotheses, those without evidence included. Returns the verdicts, the whole ledger as a file that imports into Discovery Expert, every run's input, the refusals, and the literature query each supported hypothesis needs before it may be called new. Pass a previous ledger with posterior beliefs to get the follow-up order by Bayesian surprise, which ranks what to test next and never changes a verdict. Also returns the whole program as a sealed run file (every corpus input pinned by SHA-256, the last attempt at each hypothesis); pass it back as `run` to add hypotheses and retry the ones whose test failed, or to research_run_status and resume_research_run. Evidence that read one source (one table, or one sequence under two names) is averaged, not multiplied, and each verdict names the rule.

Resolve a gel lane (ladder / plasmid / digest / pcr) into [bp, form] bands for the open plasmid.

Run a multi-lane virtual agarose gel and return its READING, not just its bands: how many lanes carrying how many bands over what range, positioned by which ladder, plus only the cautions this plate earned — a lane running off the top or bottom of the reference ladder entirely (no mark to interpolate against, so the position is the calibration curve extrapolated), a band inside the ladder but outside the resolving window of the agarose percentage cast, two fragments co-migrating as one drawn band, a DNA form the chosen law cannot move, an empty lane, and a refused calibration. Wire one `run_gel_lane` per lane into `lanes`. The migration model is `@ports/gel`, the same one the Virtual Gel Bench panel draws.

Run a workflow graph: nodes naming tools, wires carrying one node’s output into another’s input, `$whenExpression` to make a step conditional, and `scatter` to run a step once per element of a list. Returns the run record — per-node status, outputs and errors, in topological order.

Save a set of enzymes as a named collection in your Enzyme Collections panel, so a scan that found the enzymes worth keeping ends by keeping them instead of asking you to retype the list. Every name is checked against the cut catalog first and an unknown one refuses the whole save by name, because a collection that silently lost two enzymes is worse than one that was never made. An existing collection is never overwritten unless you say so.

The scaffold network (Kruger et al. 2020) of a list of small molecules, as RDKit's CreateScaffoldNetwork builds it, under RDKit's default ring-side cuts or the 46 BRICS bond types (Degen 2008). Every node with the structures that contain it and how many times the network made it, and every edge with RDKit's type. Structures over the cut limit are named and left out. Indices are 0-based.

De-novo protein domain and family annotation: submits a protein to EMBL-EBI InterProScan and returns every member-database signature that matches it — Pfam, CATH-Gene3D, SUPERFAMILY, PANTHER, PROSITE, SMART, CDD and the rest — with its InterPro entry, its GO terms, its coordinates and its E-value. This is the DOMAIN half of the Protein domains panel; for the short linear motifs a profile scan cannot see, use find_linear_motifs, which takes the `domains` this tool emits. The scan runs at EBI, takes minutes, and needs a contact address because EBI requires one.

Score a Golden Gate junction (fusion-site) set against MEASURED T4 DNA ligase end-joining data. It is the number NEB's Ligase Fidelity Viewer reports: the expected fraction of assemblies in which EVERY junction ligated correctly. This is the quantitative counterpart to check_golden_gate_parts: that says whether the parts will be cut, this says whether the pieces will go back together in the right order. Wire golden_gate_assemble's `overhangs` output straight into it.

Score the ribosome-binding site already in front of a start codon: the Shine-Dalgarno hybridisation energy, the mRNA folding that competes with it, the spacing it implies, and the resulting relative initiation strength. This reads an existing 5'UTR — design_rbs writes a new one.

Score how well an MS/MS spectrum matches a peptide with the X!Tandem HyperScore (validated against OpenMS): b and y ions are generated for the peptide, matched to the observed peaks within a tolerance, and scored as ln(1 + dot product) + ln(matched b!) + ln(matched y!).

Score protein substitutions with ESM-2, the zero-shot way `facebookresearch/esm`'s own `predict.py` does: how much less (or more) likely the mutant residue is than the wild type at that site, under a protein language model. It ranks a saturation library without an assay — and it is a RANKING IN NATS, not a stability measurement: it carries no kcal/mol and is calibrated against nothing. THE MODEL IS DOWNLOADED ON FIRST RUN, 30 MB for the 8M export and 2.6 GB for the 650M one, then cached; a run in a browser with no network to Hugging Face will refuse rather than hang.

Screen a nucleotide sequence for vector, adapter, linker and primer contamination against NCBI's UniVec, using VecScreen's own BLASTn parameters and category rules. Reports every match graded Strong/Moderate/Weak plus the short 'suspect origin' stretches NCBI asks to be removed with the vector, and emits both the N-masked sequence and the longest clean region so a pipeline can gate on the result or carry the clean part onward.

Screen guide spacers the way CHOPCHOP does before it accepts them: GC gate, self-complementary hairpins inside the spacer, and hairpins against the sgRNA backbone. A guide that folds onto its own scaffold is loaded into Cas9 poorly however good its on-target score is, so this is the check that explains a guide with a good score and no activity.

Screen every structure of a library at once against drug-likeness rules and structural-alert catalogs, as the library grid does, and bin one rule property across it, split at the bound of a chosen rule. Returns, per 0-based structure, the rules it breaks and the alerts it trips, and the binned distribution with how many structures fall within the bound.

Fold a set of oligos and check them against each other: every oligo's hairpin, its self-dimer anywhere and its self-dimer at the 3' end, plus the cross-dimer with every other oligo in the set, at any position and at a 3' end. This is primer3's `thal` — the same engine the Tm columns elsewhere use — so a pool can be screened before it is ordered rather than explained after a gel. The 3'-end measures are the ones that matter for a primer-dimer BAND, because only a paired 3' end extends. Works on any oligo: primers, probes, ssODN donors, guides, adapters.

Propose the minimal SILENT synonymous edits that remove forbidden restriction sites from a CDS (a design/write).

Choose the substitution model for a maximum-likelihood phylogeny by fitting every candidate — model x rate-heterogeneity x invariant-sites — on ONE shared topology and ranking them by AIC, AICc or BIC with Akaike weights. Fitting on a shared topology is the point: a model test that also searched topologies would vary two things at once, and a log-likelihood measured on a different tree answers a different question. Wire the winning model into build_tree's `ml_model`.

Power and FDR for a two-group RNA-seq experiment by SIMULATION (PROPER 1.44.0): whole experiments drawn from a real pilot (Cheung, Gilad, Bottomly, MAQC, or a sequencing depth), each run through edgeR's exact test at every sample size. Reports power stratified by expression, the FDR actually achieved, true and false calls, and power at other depths; reproducible from its seed, value for value against R.

Predict the amplification curve a hydrolysis-probe (TaqMan) qPCR assay will draw, and the Cq read off it, from the assay's own sequences and its thermocycling programme - a forward simulation, not a fit to data. Ports DYNAMIC (Kreitmann et al., Anal. Chem. 2026, 98(12):9089-9101): thirteen species, four phases per cycle, mass-action annealing integrated as a stiff ODE, with primer-dimer formation and amplicon re-annealing competing for the primers. It is SINGLEPLEX, which is the paper's own stated limit and not an omission here - one target per run, no interassay competition. Two things it needs said about their provenance every time they are quoted: the primer-dimer free energy is upstream's NUPACK quantity and primer3's `thal` is explicitly NOT a substitute for it, and the association rate constants are one assay's FITTED values reused, not physical constants.

Size the peaks of a fragment-analysis run (.fsa / .hid) against its own size standard, and hand them on as lengths in bases. A fragment run carries no sequence at all — dye channels and a ladder — so this is the node that turns one into numbers a pipeline can act on: allele sizes, a peak table, and the ladder's own measured accuracy beside them.

False discovery rate and q-values for peptide-spectrum matches by target-decoy competition (validated against pyteomics): give each match's score and whether it hit a decoy; returns every match's q-value, the whole set's FDR, and how many targets pass a q-value threshold. Supports the +1 and finite-sample corrections of Levitsky et al. 2017.

Quantify a CRISPR edit from a pair of Sanger traces by TIDE (Brinkman et al.) — the abundance of each indel SIZE in the sequenced population, with a p-value per size class, the total editing efficiency, the goodness of fit, and the base composition of the +1 insertion. This is a different question from crispr_quantify_edits, not a cheaper version of it: ICE fits a mixture of whole proposed alleles and names them, TIDE fits the control trace shifted by n bases and so reports how much of the population shifted by n, whatever allele carried it. Run both on the same pair when the two disagree about how much was edited — that disagreement is information about the read.

The UNPROCESSED signal of a Sanger trace: how many scans the instrument recorded, where each channel's baseline sits, the peak raw value, and how many scans analysis discarded off the front as dye front. This separates an instrument problem from an analysis problem — a read whose analyzed trace looks wrong while its raw channels are clean was mis-analyzed, not mis-run, and a baseline spread far above the others names the channel responsible. ABIF only: SCF and ZTR store no raw channels, and this refuses rather than substituting the processed ones.

Edit a tree that is already built — re-root it (at its midpoint, on an outgroup, or remove the root), prune taxa away or down to a set, ladderize it, or collapse branches that are too weakly supported or too short to believe. Pruning the TREE keeps the branch lengths estimated from the full alignment, which is a different answer from rebuilding without those taxa.

Translate the subject DNA to protein (Biopython `Bio.Seq.translate` semantics). The SUBJECT is the selection when there is one, the named feature when `feature` is given, and the whole record otherwise — the `region` output says which, so never paste bases in to scope it.

Trim a Sanger read's low-quality ends, by either of the two methods that answer different questions: the instrument's own Mott record as written into the file, or a sliding mean-Phred window computed here. Returns the kept interval as 1-based inclusive bounds, and the mean quality of what it KEPT beside the mean of what it DISCARDED — the pair that says whether the trim was worth making, because a trim whose discarded ends score no worse than the bases it left has shortened the read for nothing.

Put a hypothesis of the form "gene G is involved in trait T" through POPPER-style sequential falsification on two public tables, each test fixed in advance and run in a fixed order. (1) GTEx v8 expression: either G's co-expression across the 54 tissues with the trait's own gene(s), such as IL2 for IL-2 production, or G's expression in named tissues against its own elsewhere. (2) The GWAS Catalog: how many studies place an association inside G for traits in the named GWAS Catalog categories. Each p is G's rank among the 19,107 protein-coding genes GTEx measures, so it is exact under the null that G is just another gene, with no model of how expression or GWAS hits are distributed. Each p becomes an e-value (κ calibrator), the running product is the evidence, and testing stops at the first product above 1/α, which is POPPER's own sequential stop. Benchmarked on POPPER's TargetVal (Schmidt et al. 2022 CRISPR screens): it holds Type-I below α and has far less power than an agent writing its own tests, because two tables answer fewer questions; the result says which tests were run and what each could and could not show.

Summarize a variant call set the way bcftools stats does: records by class, transitions and transversions with their ratio, the twelve directed substitutions, indel lengths, per-contig counts, the FILTER tally, the QUAL range, and per-sample genotype counts. Reports what could NOT be counted rather than leaving a zero standing in for it, meaning a file whose genotypes were not parsed, and any genotype naming an allele its record never declares.

Write a list of small molecules as one file: SDF (V2000 or V3000), each record named and, optionally, carrying its canonical SMILES and RDKit descriptors as data fields; or SMILES or CXSMILES, one record a line followed by its name. Written as RDKit's SDWriter, MolToSmiles and MolToCXSmiles write it; a structure RDKit cannot read is left out and its index returned.

Pairwise-align ONE sequencing read against a reference and hand on the two gapped rows, so the read can be graded. Needleman-Wunsch with free end gaps and the IUPAC substitution matrix — SeqTrace's aligner, the same call the trace editor makes, so a pipeline and the panel align a read identically. Leave `reference` unset to align against the record this step runs on.

Read an alignment window and say how well its reads agree with the reference underneath them, the way the pileup's own bar does: the compared and differing base counts, plus the RefSeq gene models and known dbSNP variants over the same window. The reference is a FASTA in this project or a public UCSC assembly, exactly as the panel offers it. There is no threshold and no verdict: a rate in the tens of percent almost always means the reads were aligned to a different assembly than the one asked for, and when the file declares its own reference length the answer says so as a fact rather than as a judgement.

Read one window of a BAM or SAM in this project: its reads, the depth across it, and what the pairs say about the library — the same window, filters and record cap the pileup draws. Wire `reads` into an alignment or a screen the way the pane's own hand-offs do.

Melt curves to melting temperature, under any of THREE engines that answer different questions and none of which is a fallback for another. `plate` (RDML-Python) normalises, derives twice, calls the peaks of -dF/dT and CLASSIFIES them against the target's expected Tm into per-reaction verdicts — one peak in the window is the product, an extra peak is an artifact or a primer dimer, no peak at all is a reaction that did not amplify; it is the only engine that produces a verdict. `vertex` (MBmca diffQ) fits a quadratic near the extremum and reports its vertex, so the Tm is NOT one of the sampled temperatures — the only sub-grid answer. `curve` (qpcR) does no plate normalisation and gives no verdicts, but reports every melting peak with the AREA under it. Replicate spread travels with all three, because it describes the readings rather than the method.

Search a sequence against THIS PROJECT'S OWN records with blastn or blastp, on this machine: the local database is built from every project record of the program's alphabet, and every E-value is computed from that database's own size. Use it to ask which of my constructs, reads or proteins carry this span. Nothing leaves the machine; for public databases use blast_search.

Search a sequence against NCBI BLAST+ at EMBL-EBI (blastn, blastp, blastx, tblastn or tblastx) over ENA, UniProtKB, PDB and the vector-screening sets. This is the similarity search a methods section cites: it turns an unnamed span into named homologues with E-values, and hands the hits, the tabular report and the job id downstream. The sequence LEAVES THE MACHINE.

Read one window of a genome the way a genome browser shows it: the cytogenetic bands it spans, the transcripts in the chosen RefSeq set, which residues of each protein the window encodes (translated from the assembly’s own bases), how many dbSNP 155 variants fall in it and how many ClinVar calls pathogenic, and every CRISPR site for the chosen nuclease (SpCas9 unless told otherwise) with its strand, cut position and on-target scores. Give a gene symbol (resolved through MANE Select, then HGNC) or a locus, 1-based and inclusive. Each lane refuses a window wider than it will read, and says so.

Build a phylogeny from aligned sequences — distance methods (NJ, BIONJ, FastME, UPGMA/WPGMA), parsimony, maximum likelihood, or Bayesian MCMC under a strict clock and coalescent prior — with branch support from a bootstrap, aLRT or aBayes, or, for the Bayesian method, clade posterior probabilities. Wire it downstream of align_sequences.

Fetch a real codon-usage table for an organism and save it into this project, so later steps can score against it by name. NCBI builds the table by counting codons in the annotated CDS of a RefSeq assembly (the same counting the Codon Usage panel does, with the assembly and CDS count in the provenance); the Kazusa mirror serves a published table for an organism the mirror covers. The table LEAVES NOTHING but takes a network round-trip. Hand the saved name to `codon_usage_analysis` or `codon_optimality` in `table`.

Several antibodies side by side: each record numbered by ANARCI, its heavy or its light variable domains aligned column by column by their numbering (a column is one scheme position, so nothing is re-aligned and an insertion is its own column), the CDR of every column under the chosen definition, how many columns agree, and the same properties read off each V domain: length, mass, isoelectric point, net charge, GRAVY, ε280 and the net charge of its CDRs. The alignment is abnumber's `Chain.align`, graded against it over every chain of ANARCI's PDB benchmark; the properties against Biopython ProtParam.

Align two constructs' build procedures step by step, in order — was this built the same way as that? Works across formats: a build received as a SnapGene binary and the same build received as an OpenCloning strategy align, because each step's identity is derived from the reaction and its parameters rather than assigned.

How similar two small molecules are: Tanimoto under six RDKit fingerprints (Morgan/ECFP4, atom pair, topological torsion, RDKit path, pattern, MACCS), every DataStructs metric (Tanimoto, Dice, cosine, Sokal, Russell, Rogot-Goldberg, all-bit, Kulczynski, McConnaughey, asymmetric, Braun-Blanquet, on-bit, Tversky) on the chosen one, and count-based Tanimoto, Dice and Tversky on Morgan counts. The first molecule is the query.

Compare a SET of sequencing reads against one reference in ONE shared frame: align every read to the reference, vote a consensus column by column, and report the positions where the reads differ from it, each with the change it makes to the protein. This is the whole-plate answer that grading reads one at a time cannot give — a variant is accepted only when every covering read agrees, so a single bad call does not become a mutation. Reads arrive as records or bases; the reference is the record this step runs on.

Compare trees over the same taxa: the Robinson-Foulds distance between two of them, and the consensus of any number. Two methods disagreeing is a result about the data, so the distance and the shared topology are reported together.

The design step's view of a discovery corpus: each record's name, file, length and GC fraction, and how many records each file holds. Runs no test and returns no statistic, so hypotheses proposed from it are proposed before any result is seen (POPPER's metadata-only design step). Use it before run_discovery_programme.

Find the signal peptides or transmembrane segments in reviewed human UniProt that a sequence predictor contradicts. Each feature backed by experiment (evidence code ECO:0000269) is scored to say what a confirmed feature looks like to the predictor; every other feature, annotated from similarity, sequence analysis or a rule, is ranked among those scores, and its conformal p-value (1 + experimental features scoring at or below it) / (experimental + 1) is corrected across all of them. Signal, by either predictor: von Heijne's weight-matrix score (EMBOSS sigcleave) of the cleavage site UniProt annotates, or DeepSig's probability that the protein carries a signal peptide at all (its eukaryotic network ensemble, from the first 96 residues). Transmembrane: the share of the segment the HMM-TM topology model labels membrane helix. A contradiction is a disagreement between two models, to be read, not a correction of UniProt: von Heijne's matrix and the HMM-TM model are weaker than the SignalP and TMHMM runs behind most such annotations; DeepSig is of their generation. The result carries a self-check, half the experimental features tested against the other half, whose calls are all false by construction.

Find the genes whose own alignment rejects the species tree. Each named alignment file is one gene, its records the taxa, named as the species tree's tips. For every gene the species tree and each of its nearest-neighbour rearrangements (two per internal branch) is fitted by maximum likelihood under GTR + Γ (rates, base frequencies and shape fitted on the species tree, branch lengths refitted on each rearrangement), and the Shimodaira–Hasegawa test asks whether the species tree is significantly worse than the best of them; the false discovery rate is controlled across genes. A rejection says the gene fits another tree better: incomplete lineage sorting does that to a share of genes among closely spaced species, and so do hidden paralogy, alignment error and transfer, so it is a gene to read, never a call of any one of them. Also reports which genes' best tree is not the species tree, rejected or not, and which alternative trees they choose. Graded against phangorn's pml, optim.pml and SH.test on 122 great-ape genes. About a second of fitting per gene in a browser.

Ask whether some loci of a multi-locus alignment have a different history from the rest, by the incongruence length difference test (Farris et al. 1994). Each locus is one aligned FASTA file (or a set of wired alignment rows) over the same taxa, named alike in every file. D is the extra parsimony steps one shared tree costs over each locus's own tree; the null deals the same columns into parts of the same sizes at random. One global test over every locus, and one per locus against all the others combined, with the false discovery rate controlled across loci. A locus that recombined or was transferred costs steps when forced onto the others' tree, but so does a locus evolving at a different rate (Darlu & Lecointre 2002), so a call is a candidate for a tree comparison, never a recombination call. Lengths are NNI parsimony searches from each alignment's own neighbour-joining tree. Cost: a run is 1 + k + k·n + k·(1 + 2n) searches for k loci and n permutations, and a search grows fast with taxa: the default 99 permutations over seven Neisseria MLST loci took 23 s on 12 strains, 48 s on 16 and 122 s on 20, and one search of the 62-strain concatenation takes about 8 s, so 62 strains is hours. Each file is one locus; records wired with no file are grouped by the part of their name before ` · `.

Draw a tree as an SVG figure — rectangular, slanted, circular or unrooted, as a phylogram or a cladogram, with tip names, branch support and a scale bar. The same layout the phylogeny panel draws with, so the figure and the panel place every node identically. Wire `newick` from build_tree or edit_tree.

Resolve one of your saved enzyme collections to the enzyme names in it, so a later step can scan, digest or design with 'my Golden Gate set' by name instead of whatever happens to be selected. Names the collection, says which of its enzymes the cut catalog can resolve and which it cannot, and — when a record is open — how many times each one cuts it. Left unnamed it answers for the collection that is currently active, and says that is what it did.

Per-enzyme cut counts on the open plasmid (the EcoRI² superscript-badge numbers).

Fetch a sequence by accession from an authoritative archive (NCBI Nucleotide or Protein, ENA, UniProtKB, the iGEM Registry, Addgene, or the EBI Dbfetch gateway) and hand it downstream as a real record with its annotations. This is how a pipeline starts from a published sequence rather than from whatever happens to be open.

Resolve an organism to its published genome assemblies and the chromosomes, plasmids and organelles each one is made of, with every accession and length NCBI reports. This is how a pipeline starts from a SPECIES rather than from an accession somebody looked up by hand: hand the replicon accession it returns to fetch_record, with a region, to pull a window of that chromosome. Assemblies come back reference-first, so the default pick is the canonical genome.

Short linear motifs in a protein: degrons, docking sites, targeting signals, cleavage and modification sites — the three-to-eleven-residue functional sites a profile-HMM domain scan cannot see. Runs ELM's own class patterns ON THIS MACHINE; only the class table is fetched. Applies ELM's context filters: the chance-probability cutoff, family selection, and the globular-domain filter when you pass domains. It does NOT scan for DOMAINS — for those call scan_protein_domains, which submits to EMBL-EBI InterProScan and returns `domains` in exactly the form this tool's `domains` parameter takes.

Find open reading frames on BOTH strands of the subject (origin-spanning when circular).

Find known SNPs under primers, the check NCBI Primer-BLAST makes with "Primer binding site may not contain known SNP". The template is placed on the UCSC assembly it was cut from, and the placement is proved by comparing the assembly's own sequence with the template; dbSNP 155 is then read over that span from the UCSC Genome Browser, and every primer is reported with the SNPs under it and each one's distance from the 3' end. `excluded` is the SNP spans in the form design_primer_pairs takes, to design around them. The template's sequence does not leave the machine; the assembly, chromosome and span are sent to UCSC.

Cut positions of the given enzymes on the open plasmid (top/bottom cut, overhang, kind).

Where the given enzymes could ALSO cut the open plasmid under non-standard conditions, from REBASE's own star-activity list and its one-base rule. Not cut sites: these need low ionic strength, high pH, Mn²⁺ for Mg²⁺, glycerol, DMSO or some detergents, and are what turns an over-digested reaction into a band pattern that reads as the wrong clone.

What a construct was BUILT from: the recorded operations, the molecules they consumed, how many rounds deep the build goes, and which of the 5 sources the record came from. This is the build history, not the edit history — for what CHANGED in a document and when, call get_document_history instead.

Return the plasmid/sequence currently open in the editor. Emits it as a `record`, so it is the SOURCE node of a pipeline — wire its record into any downstream node's $subject.

The region selected on the canvas, as its own record. This is what makes a highlighted stretch a pipeline INPUT: wire its record into any node's subject and that step runs on the selection rather than on the whole molecule.

The authoritative databases available, with what each one covers, whether it is reachable from the browser, and any license or coverage caveat. Call this before searching if unsure which source answers a question.

Your lab-notebook entries, newest first — id, title, tags, collection, when they changed, and the @plasmid / !action / &gel cross-references each one names. Filter by a tag, by collection, or by text in the title and body, so a run can find the entry it is continuing instead of starting a second one about the same experiment.

List the project's sequence documents (id, name, length, topology, kind).

List research runs without running anything: the runs this project holds (in the app), or the run files given (`runs`, which is how an HTTP or MCP caller lists the files it kept). For each run: whether its seal holds, its id, how many hypotheses it registered and how many are supported, not supported or without evidence, how many a resume would run, how many inputs it pins, and what resuming would do. A file whose seal fails is listed as refused with the reason, never dropped. Hand one to research_run_status for its decisions, or to resume_research_run.

Browse the bundled sample library: the real bio files a new project can start from (GenBank and SnapGene plasmids, FASTA sets, alignments, Sanger traces, structures, variant calls and more), each with its id, format and size, and its archive provenance where the corpus records one. This is the headless form of starting a project from a sample: pass an id as a `_subject` or `_files` entry's `sample` and the file is read exactly as the lobby opens it.

Every sgRNA scaffold this workbench has sourced, with the nucleases each covers and the publication it comes from. A scaffold not listed here is one we do not have — the list is what we ship, not what exists.