evals-lab 0.1.2

package/lab/evals-core.mjs

@@ -0,0 +1,4526 @@
+// The eval runner. One definition of what a pass is, with three callers: the
+// Prompt Lab tab, `run-evals.js`, and CI.
+//
+// WHY THIS FILE EXISTS. The scoring used to live in the page, and a CLI and a
+// CI job would each have grown a copy of it. Three scorers agree on the day
+// they are written and not after: this repository has already produced a ~6x
+// unit error, a note written to prevent a magnitude error that carried the
+// wrong magnitude, and a scorer that reported 100% for a set it had not run.
+// A number stated in more than one place drifts. Issue #281.
+//
+// WHY JAVASCRIPT, AND NOT PYTHON. The scorer was already JavaScript and was
+// already being run outside a browser -- `evals-check.js` loaded it into a
+// Node `vm` from the day it was written. A Python core would mean rewriting it,
+// which is the second implementation this file exists to prevent, or having
+// the tab post every row to the relay to be scored, which puts the deployed
+// container in the path of a number the page can work out for itself.
+//
+// ONE MODULE, TYPED AT THE SOURCE (#45). The page imports this file and
+// Vite bundles it; run-evals.js and the checks import the same file, and
+// Node runs it by stripping its types, so there is no build step between a
+// change here and any of its callers. That rules out the TypeScript that
+// has to be compiled rather than erased -- enums, namespaces, parameter
+// properties -- and `tsc` (web/'s typecheck, `erasableSyntaxOnly`) says so.
+// The pipeline document's types are declared here and nowhere else.
+//
+// WHAT IS NOT HERE. Preparing an image: the tab has a canvas and the
+// script has not, so `prepare()` stays in the page and the script shells out
+// to ImageMagick with the same arithmetic. Rendering: the tab writes HTML and
+// the script writes JSON. Both read the same verdict out of `scoreCase`.
+//
+// `runner-check.js` runs one set through two of the callers and asserts the
+// verdicts and the totals are identical, because sharing a file is a claim
+// and that is a measurement.
+
+import yaml from "./js-yaml.mjs";
+                                                
+import { evaluate, asText, WdlError,                 } from "./flows/wdl.mjs";
+import registerMetrics from "./metrics/builtin.mjs";
+import list, { ECHO, legacyTagsOut, splitItems, tidy, tryExamples, itemRulesProblems, dropBy, rejectBy, matcher } from "./kinds/list.mjs";
+
+// ---- The types -------------------------------------------------------------
+// docs/pipeline-model.md as types, and the shapes of the registries every
+// caller reads. They are declared here rather than beside any one caller so
+// the page, the worker and the checks cannot disagree about a document: web/
+// imports them from this file and declares none of its own.
+
+/** A reference to something the lab holds: the id is looked up, the name is
+    the label and what an import falls back to when the id is unknown. */
+                      
+             
+               
+ 
+
+/**
+ * One of a job's token mappings: a name the prompt writes in braces, and a
+ * TOKEN_TYPES entry that says what the prompt does with it. What else a
+ * mapping holds is its type's: a value's text, a block's on/off.
+ */
+                               
+               
+               
+                                                
+                 
+                                                                      
+                    
+ 
+
+/** A job's mappings, in the order the page lists them. */
+                                           
+
+/** The version-1 shape of a job's mappings, read only to upgrade it. */
+                      
+                                 
+                                  
+ 
+
+/** One change applied to a job's parsed value, in order: a MODIFIERS
+    entry's type and that entry's options. */
+                           
+               
+                            
+ 
+
+                      
+               
+                        
+                                                                  
+                             
+ 
+
+/** Job 1's first step, when it has one: the items a run goes over. */
+                                    
+                        
+                   
+ 
+
+/** A Call that prompts a model: each scenario's cell says with what words
+    and whom to ask; the step says whether the item's image goes too, and the
+    token mappings the words are resolved under. */
+                             
+                 
+                     
+                               
+ 
+
+/** How a job's reply is read: its output kind, and the modifiers applied. */
+                                
+                    
+           
+ 
+
+/** A Call that sends a Power Automate step's request (docs/power-automate.md
+    § The HTTP Request step): the flow's own template -- method, path, query
+    and body, Workflow Definition Language expressions and all -- evaluated
+    against each item's record. The Setup profile gives the address and the
+    key; each scenario's cell the words, model, settings and prefill the
+    HTTP API puts in the body. */
+                                  
+                      
+                                                                      
+               
+                                                    
+              
+                 
+               
+                                
+                
+                                                                            
+                                                                           
+                  
+                        
+                                                                        
+                      
+ 
+
+                                                                                    
+
+/** A job is its steps, in fixed slots (pipeline-model §3): an Attach Content
+    on job 1 only, one Call, then Read Reply. */
+                      
+              
+                                                                      
+                                                                           
+                                              
+             
+               
+                
+ 
+
+                                
+                 
+           
+                       
+                
+                                                                            
+                                                         
+                   
+                                
+ 
+
+                              
+               
+               
+ 
+
+/** No item: a stage is sent its prompt alone (CONTENT_TYPES.prompt). */
+                                
+                 
+ 
+
+                                                                  
+
+/** One cell of a scenario: what to ask in that job, and whom. */
+                       
+                 
+                
+                                                                           
+                                                                          
+                                                               
+                  
+                 
+                                    
+                   
+                                                                        
+                                                                       
+                                                          
+             
+ 
+
+                           
+                                                                         
+                                                
+             
+               
+               
+                 
+ 
+
+/** What every test carries whatever its type: an id minted once and never
+    shown, an optional name ("Test 2" when blank), and whether the tests after
+    it still read what it failed on (docs/pipeline-model.md §3). */
+                             
+             
+               
+                             
+ 
+
+                                                
+                 
+                                                                             
+                                      
+ 
+
+                                                
+                 
+                
+                
+                 
+                       
+                       
+                        
+                   
+                       
+                  
+ 
+
+/** Checks of every reply (TEST_TYPES.metrics): its own for every item, and
+    a case's own for its item; all must pass, or weighted points reach the
+    threshold. A model-graded one asks the grader. */
+                                                 
+                  
+                    
+                           
+                           
+                     
+                                                                                 
+                                                
+                                                                         
+                        
+ 
+
+/** A test, from version 9: Metrics. A Single Test or a Graded set is what an
+    older document held (upgradePipeline reads it converted). */
+                               
+
+/** A pipeline's tests, in the order they read a run. */
+                           
+
+                           
+                                   
+                                                                             
+                                                                             
+                                                                               
+                                          
+             
+               
+              
+                        
+               
+ 
+
+/** A Setup profile as a run carries it: request settings, never the key. */
+                             
+               
+              
+                
+                                                                 
+               
+                                
+                       
+                  
+                            
+                                            
+ 
+
+/** A pipeline resolved at submit (§5): what the queue runs and History
+    reads. The additions, and nothing else. */
+                                               
+                                       
+                                                         
+                   
+                                                                         
+                                                       
+                          
+ 
+
+/** A plugin as a run records it. */
+                              
+             
+                  
+                 
+ 
+
+/** Either document: what a reader that only looks at jobs takes. */
+                                                 
+
+/**
+ * A Setup profile as the Setup tab stores it: a connection type's settings,
+ * the key, and -- until it is converted -- the old `profile` it was made
+ * with (#46). Its fields are whatever its type's settings are.
+ */
+                          
+              
+                
+               
+                 
+                
+               
+                   
+                             
+ 
+
+/** A connection's settings in one flat set, the shape a type reads. */
+                                               
+
+/** A value read before it is checked -- a document off the wire, out of a
+    file or out of a store. The functions that take one are the ones that
+    establish its shape, so they read it field by field, as it came. */
+                     
+
+// ---- the pipeline's file form (#29) ----
+
+/** A pipeline read from YAML, references remapped to this lab. */
+                                   
+                
+                                                                            
+                                                                         
+                    
+ 
+
+/** What an import matches references against: { id, name } each. */
+                            
+                            
+                           
+                            
+                                                                                 
+                                                                
+ 
+
+/** An import's outcome: the remapped pipeline, or one sentence refusing it. */
+                                                                
+
+// ---- running a job ----
+
+/** A stage as runPipeline takes it. */
+                        
+               
+                                                                                  
+                     
+                
+                      
+                         
+                                                                                   
+                                     
+ 
+
+/** An item a modifier dropped, and what dropped it. */
+/** An item a modifier took out of a list, and what took it: a rule's id, or a modifier's own reason. */
+                          
+               
+             
+ 
+
+/** What a transport answered for one stage. */
+                        
+               
+             
+                 
+                                                                    
+                       
+                                                                         
+                                                                          
+                                           
+                       
+                                                                           
+                
+                                                                            
+                                                                     
+                
+ 
+
+/** The transport: a stage's prompt and image in, its reply out. */
+                                                                              
+
+/** One stage of a run as it happened: what was sent and what came back. */
+                                  
+            
+               
+                      
+                     
+               
+              
+             
+                             
+                                                                        
+                                                                        
+                
+ 
+
+/** A job's result for one item: the terms its last stage holds, and how. */
+                            
+                                                                                  
+                  
+                                
+             
+                 
+                  
+                      
+                                                                   
+               
+ 
+
+/** What runPipeline is told besides the stages. */
+                             
+                                                                   
+                                           
+                
+                       
+                                    
+ 
+
+/** A stage of a run as a transport asks it: stagesFor's answer. */
+                          
+               
+                                                                                 
+                    
+               
+                     
+                        
+                                    
+ 
+
+// ---- grading ----
+
+/** A graded case, as cases.json writes one.
+
+    The item a case grades is named by `filename`: a dataset joins on a file
+    name, and nothing about that is an image -- the next dataset addresses
+    a row of a spreadsheet or a line of a log by the same key. The field had
+    an older name while the lab was one app's bench, and it is still *read*:
+    a set re-synced from that app's repository arrives spelled that way, and
+    a case that silently stopped matching would be worse than one that reads
+    both.
+    `caseFile` is the one reader; `evalsJson` is the one writer, and it writes
+    `filename`. */
+                       
+              
+                    
+                                                                    
+                                                                       
+                 
+               
+                    
+                     
+                    
+                   
+                           
+                           
+                                                            
+                   
+                                                                          
+                     
+                                                                           
+                                                                   
+                      
+                    
+                         
+ 
+
+/** A graded set: cases.json. */
+                          
+                 
+                         
+ 
+
+/** One row the Datasets tab's Cases group draws, as gradedSetFrom builds it:
+    a case of a set validateEvals accepts, so it has its id and file. */
+                                         
+             
+                   
+               
+ 
+
+/** A requirement as a score reports it: a term, or the group it was. */
+                                            
+
+/** How a graded case read a reply: the same shape both engines agree on. */
+                            
+                
+                       
+                     
+                       
+                        
+                     
+                    
+                 
+                
+                
+                       
+                     
+                    
+ 
+
+/** A run's totals, summed across cases. */
+                        
+              
+                 
+                
+             
+ 
+
+/** The whole-run verdict of a test type, where it has one of its own. */
+                                  
+                
+                  
+                                                              
+               
+                                                                          
+                                   
+                       
+ 
+
+/** One thing a test asserts, as its type names it: "Exact" "outdoor". */
+                       
+              
+                
+               
+ 
+
+/** A rule read against a scenario's replies, and what broke it if it failed. */
+                                         
+                
+                
+ 
+
+/** A transcript stage as a stored row carries it: an older row may lack
+    anything but its number. */
+                                                                                
+
+/** A job's result as a stored row carries it. */
+                                                                                                   
+
+/** One scenario's cell of a queue row's result item. */
+                             
+                     
+                                                                         
+                                                        
+                                            
+                 
+ 
+
+/** A per-item test's score as a stored row carries it. */
+                                                                                                              
+                                                                             
+                                                                                       
+                                               
+
+// ---- Metrics (docs/pipeline-model.md § Metrics) ----
+
+/** One check of a reply: a METRICS entry's type and its options, and how it
+    counts -- `not` turns it round, `weight` is what it is worth (negative
+    takes points away), `metric` names the group it is reported under. */
+                         
+               
+                                                                        
+                                         
+                  
+                                                                            
+                        
+                
+                  
+                  
+                            
+ 
+
+/** What a metric reads of one reply. */
+                              
+                                                             
+               
+                                                                      
+                      
+                                               
+                  
+                                     
+                       
+             
+                                                                         
+                                              
+                            
+                    
+                                                                       
+                    
+                                                                           
+                                         
+                 
+ 
+
+/** What a metric needs besides the reply: a model to grade with. */
+                            
+                                                                           
+                        
+                                            
+ 
+
+/** A metric's reading: pass or fail, a score -- 0 to 1, or a count -- and why. */
+                                
+                
+                
+                 
+                                                                            
+                                                         
+                        
+                         
+                      
+ 
+
+/** One metric's reading of one reply, as a stored row keeps it. */
+                                                      
+               
+                
+                 
+                                                                            
+                                   
+                 
+ 
+
+/** A kind of check. A registry: a check a flow or a dataset needs is one
+    more entry, and no reader changes. */
+                              
+                
+                                                                       
+                       
+                                                                                
+                   
+                                                                                
+                   
+                                 
+                                             
+                                      
+                                                        
+                                                                       
+                                               
+                                                                                                             
+                                                                             
+                                    
+                    
+                                                                                    
+                       
+ 
+
+/** What an earlier test that failed and does not continue leaves a later one. */
+                                          
+
+                                              
+
+/** One test's reading of one scenario of a run (scenarioTests). */
+                              
+             
+                
+                                                              
+                 
+                                                                                  
+                   
+                                                                             
+                                  
+                                                                            
+                
+                                                                          
+                                                        
+                              
+                                                                     
+              
+                 
+                       
+ 
+
+/** One item of a queue row's results: a file or the pasted text. */
+                             
+                
+                
+              
+                 
+                           
+ 
+
+// ---- the rules file ----
+
+/** A bound on a number: either end may be left open. */
+                         
+                      
+                      
+ 
+
+/** A rule as a version-2 dataset held it, scoped to one item or to the whole reply. Read
+    only to upgrade a pipeline graded against such a dataset: `legacyTagsOut`
+    turns these into a List's Drop items and Reject rules. */
+                          
+             
+               
+                 
+                                  
+                                                    
+ 
+
+/** A version-2 dataset's `rules`: `{ rules: DudRule[] }`. */
+                           
+                   
+                         
+ 
+
+// ---- the registries ----
+
+/** An option a modifier or a test type exposes for editing. */
+                        
+                                                                                               
+                                                
+                                                          
+                                                    
+                                                  
+                                                    
+                                                                             
+                                                                            
+
+/** What an output kind made of a reply. */
+                                
+            
+                 
+                      
+                  
+                                                                               
+                
+ 
+
+/** What a modifier is told besides its value: the stage's own instruction,
+    and the text the value was read from. */
+                              
+                      
+               
+ 
+
+/** A modifier's answer when it did more than change the value: what it
+    removed, or that the whole answer is rejected and why. */
+                                     
+           
+                      
+                  
+ 
+
+/**
+ * How a job's reply is read, and what its value can be tested for. [V] is
+ * the value a reply reads as -- text, or a shape of its own, such as a list
+ * of items. Methods, so a kind with a value of its own is
+ * assignable to the registry that holds every kind.
+ */
+                                               
+                
+                                                                   
+                       
+                                                                             
+                
+                                                                 
+                    
+                                                                                         
+                                                                     
+                                                                             
+                          
+                                            
+                                              
+                                                                     
+                                                                   
+                                    
+                                            
+                                                                              
+                             
+                                                                    
+                                        
+ 
+
+/** A change applied to a job's parsed value. */
+                                             
+                 
+                                                                     
+                       
+                                              
+                              
+                            
+                                                       
+                         
+                        
+                                                          
+                                                                         
+ 
+
+/** What validation looks references up in: `profiles(id)` and `sources(id)`
+    answer with what the id names, or nothing; `datasets` is the datasets the
+    lab holds, as `GET /api/datasets` lists them. Each is optional, and a
+    reference nothing is given to look up is not checked. */
+                          
+                                                                                                                
+                                                                             
+                         
+                      
+                                                                                                   
+                                                      
+ 
+
+/** Lookups, and whether it is a run document being validated. */
+                                         
+                
+ 
+
+/** A kind of Source: what one of its items is, and what the page and the
+    runner do with it. A reader asks the entry; it never branches on an id. */
+                                  
+                
+                                                                 
+                       
+                                                               
+               
+                                                                           
+                                                                            
+                                                          
+                                    
+                                                                         
+                      
+                                                                
+                                  
+ 
+
+                                   
+                
+                                                                       
+                       
+                                                                         
+                                                                            
+                                         
+                 
+                                                                              
+                                          
+                   
+                            
+                               
+                                                                  
+                                                                                       
+                                                         
+                                                                            
+ 
+
+/** A test type: what it checks of a document, and how it scores a run. */
+                                
+                
+                                                                
+                       
+                            
+                                           
+                                                                                   
+                                                                              
+                                                          
+                                                                  
+                                                                
+                                                                                                   
+                                                                               
+                                                                                
+                               
+                                           
+                                                                       
+                                                                        
+                                                                      
+                                                                                                               
+                                                                    
+                                 
+                                                                           
+                                                     
+                                                  
+                                                                         
+                                                                        
+                  
+                                   
+                                                                     
+                                                                      
+                                      
+                                                                        
+                                                            
+                                                                         
+ 
+
+/** What a test's `read` is handed besides the reply: production's reply to
+    the item, and a grader, where the run has them. */
+                           
+                             
+                                                         
+                  
+                                                           
+                                                                           
+ 
+
+/** A job's slots, in the order they run. */
+                                                    
+const SLOTS                      = ["content", "call", "reply"];
+
+                                
+                    
+                                                          
+                
+                                                                           
+                                                                    
+                                                                        
+                                                                      
+                                                                        
+                                                                        
+                  
+                                                 
+                 
+                                                            
+                       
+                                                                         
+                  
+                                                                         
+                                                             
+                     
+                                                                        
+                         
+                                 
+                                                                          
+                                 
+                                                           
+                        
+                                                                         
+                                                                               
+                                  
+                                                                           
+                                                                        
+                                                                 
+                                                                         
+                                                                                   
+                             
+                                                            
+                                           
+                                                                                           
+ 
+
+/**
+ * A dataset: data, never code. The lab keeps each one as a row in SQLite
+ * (server.py's `datasets` table), and a graded run carries the body it was
+ * submitted against, so nothing grades from a file.
+ */
+                              
+                          
+                
+ 
+
+/**
+ * [body] as this version of a dataset (4), from any earlier one. Version 1
+ * held `imageCases`, each with `minTags`/`maxTags`, and the parser's
+ * `replays` and `conformance` (now fixtures/replays.json beside the checks).
+ * Version 2 held `rules`, which clean a job's answer and so belong to the
+ * job (docs/pipeline-model.md §13): they leave, and the terms a case
+ * watches for are its `watch`. Version 3 held the `prompt` a new scenario
+ * started from, which the Prompt library holds now: it leaves. Every reader of a body calls this: the runner, the page, a
+ * run's kept copy. A reader that needs a version-2 body's rules -- to upgrade
+ * a pipeline graded against it -- takes them first (`datasetRules`).
+ * Anything else comes back as it was.
+ */
+function upgradeDatasetBody   (body   )                  {
+  if (!isObj(body)) return body;
+  if (!("imageCases" in body || "rules" in body)) {
+    if (!("prompt" in body)) return body;
+    const { prompt: _library, ...rest } = body             ;
+    return rest               ;
+  }
+  const b = body             ;
+  // vocab: the names older versions gave these fields
+  const RENAMED                         = { minTags: "minCount", maxTags: "maxCount", textInImage: "watch" };  // vocab: as above
+  const renamed = (c           ) => {
+    if (!isObj(c)) return c;
+    const out            = {};
+    for (const [k, v] of Object.entries(c)) out[RENAMED[k] ?? k] = v;
+    return out;
+  };
+  const raw = Array.isArray(b.cases) ? b.cases : Array.isArray(b.imageCases) ? b.imageCases : null;
+  // Not a body of any version -- a copy kept while a dataset was an overlay.
+  if (!raw) return body;
+  return { cases: (canonicalCases({ cases: raw.map(renamed) })                     ).cases };
+}
+
+/** The rules a version-1 or version-2 dataset body held, or null: what a
+    pipeline graded against it was read under, before rules were the job's. */
+function datasetRules(body         )                  {
+  return isObj(body) && isObj(body.rules) && Array.isArray(body.rules.rules) ? body.rules             : null;
+}
+
+/** Registry entries a module adds in one call: see kinds/list.ts. */
+                        
+                                       
+                       
+                                                
+                                            
+                                            
+                                                
+                                        
+ 
+
+/** A connection type's setting, as the form draws it. */
+                                    
+              
+                
+                             
+                  
+               
+                                               
+ 
+
+/** An HTTP request as a connection type builds it, for the relay to send. */
+                              
+                                               
+                  
+              
+                                  
+                
+ 
+
+/** A registered connection type: its label, its settings, how it transports. */
+                                 
+             
+                
+                                                                         
+                       
+                                         
+                                                                                                                  
+                                                                       
+                                                                                         
+                                                                                                  
+                                    
+                          
+                                                                           
+                                 
+                    
+                                                                           
+                                                                 
+               
+                                                                             
+                                                                         
+                                                                          
+                                                                        
+                                                                             
+                                                                             
+                                                              
+                                                                           
+                                                                      
+                                                                     
+                                
+                                                                       
+                                                    
+                                                                                                            
+                                                        
+                                                                                   
+                                
+                                                                            
+                  
+                                                                             
+                  
+                                                                    
+                                                             
+                                                                                         
+                                                                    
+                                              
+ 
+
+/** What a Call hands its connection. */
+                                            
+
+/** What the core hands a registry module (kinds/list.ts) to register with. */
+                            
+                                      
+ 
+
+// The core reads no dataset as it loads. A dataset is data the lab keeps in
+// SQLite -- its cases and its default prompt -- and whoever
+// holds one hands it over: the worker the body a run was submitted with, the
+// page the one it fetched. So the page, the worker and the checks all load
+// the same module with nothing carried beside it.
+
+// A new job's token mappings: none. A mapping is what a prompt of the
+// pipeline's own asks for, so the lab names none of its own; a prompt that
+// asks for a token no mapping fills is refused, naming it (`jobProblem`),
+// and `mappingsFor` maps the ones a given prompt names, blank.
+const TOKEN_DEFAULTS                = [];
+
+/** A blank mapping for every token [prompt] names that only a mapping can
+    fill: a {name}…{/name} pair as a block, off; any other {name} as a value,
+    empty. What a pipeline built around a dataset's prompt starts from, so it
+    names what to fill in rather than refusing to run. */
+function mappingsFor(prompt        )                {
+  const offered = new Set(Object.values(OUTPUT_KINDS).flatMap(k => k.offers || []));
+  const names = [...String(prompt).matchAll(TOKEN)].map(m => m[1] );
+  const closed = new Set(names.filter(n => n.startsWith("/")).map(n => n.slice(1)));
+  const out                 = [];
+  for (const name of names) {
+    if (name.startsWith("/") || name === "text" || name === "reply" || offered.has(name)
+        || /^stage[1-9]\d*(?:\..+)?$/.test(name) || out.some(m => m.name === name)) continue;
+    out.push(closed.has(name) ? { name, type: "block", enabled: false } : { name, type: "value", value: "" });
+  }
+  return out;
+}
+
+/** A token type: what a mapping of it holds, how a prompt writes it, and
+    what it does to a prompt. The page and the core read these; neither
+    names a type. */
+                                 
+                
+                                                                     
+                                           
+                                                                    
+                                    
+                                                                   
+                                 
+                                                                          
+                                             
+                                
+                                                                            
+                                                  
+                
+                                                 
+                                                          
+ 
+
+const TOKEN_TYPES                                 = Object.create(null);
+TOKEN_TYPES.value = {
+  label: "Value",
+  fields: ["value"],
+  defaults: () => ({ value: "" }),
+  notation: name => `{${name}}`,
+  names: name => [name],
+  order: 1,
+  apply: (prompt, m) => prompt.replaceAll(`{${m.name}}`, m.value ?? ""),
+  validate(m, at, bad){ if (!isStr(m.value)) bad.push(`${at}: a value's value has to be text`); },
+};
+TOKEN_TYPES.block = {
+  label: "Conditional block",
+  fields: ["enabled"],
+  defaults: () => ({ enabled: true }),
+  notation: name => `{${name}}…{/${name}}`,
+  names: name => [name, `/${name}`],
+  order: 0,
+  apply(prompt, m){
+    const open = `{${m.name}}`, close = `{/${m.name}}`;
+    let out = prompt;
+    for (;;) {
+      const s = out.indexOf(open);
+      const e = out.indexOf(close, s + open.length);
+      if (s < 0 || e < 0) break;
+      const inner = out.slice(s + open.length, e);
+      out = out.slice(0, s) + (m.enabled ? inner : "") + out.slice(e + close.length);
+    }
+    return out;
+  },
+  validate(m, at, bad){ if (typeof m.enabled !== "boolean") bad.push(`${at}: a block's enabled has to be true or false`); },
+};
+
+/** A mapping of [type] named [name], holding its type's defaults. */
+function tokenMapping(name        , type        )               {
+  return { name, type, ...(TOKEN_TYPES[type]?.defaults() ?? {}) };
+}
+
+/** Every reason [list] is not a job's token mappings; [at] names the job. */
+function tokenMappingsProblems(list         , at        , bad          )       {
+  if (!Array.isArray(list)) return void bad.push(`${at}: tokenMappings has to be a list`);
+  const seen = new Set        ();
+  list.forEach((m           , i        ) => {
+    const where = `${at}'s token mapping ${i + 1}`;
+    if (!isObj(m)) return void bad.push(`${where} has to be an object`);
+    if (!isStr(m.name) || !m.name.trim()) return void bad.push(`${where} has no name`);
+    const type = TOKEN_TYPES[m.type];
+    if (!type) return void bad.push(`${where} ({${m.name}}) is of type "${m.type}", which is not a token type this lab has`);
+    onlyFields(m, where, ["name", "type", ...type.fields], bad);
+    type.validate(m, `${where} ({${m.name}})`, bad);
+    if (seen.has(m.name)) bad.push(`${at} maps {${m.name}} twice`);
+    seen.add(m.name);
+  });
+}
+
+/**
+ * Mirrors PromptStore.resolve, generalised: values substitute, paired blocks
+ * survive or vanish. The app applies exactly this to {language} and {geo}.
+ *
+ * The tokens are a parameter and not a global, because only one of the three
+ * callers has a localStorage to have loaded a set from.
+ */
+function resolvePrompt(tpl        , tokens               )         {
+  const order = (m              ) => TOKEN_TYPES[m.type]?.order ?? Infinity;
+  let out = tpl;
+  for (const m of [...tokens].sort((a, b) => order(a) - order(b))) {
+    const type = TOKEN_TYPES[m.type];
+    if (type) out = type.apply(out, m);
+  }
+  // Dropping a block leaves the spaces that surrounded it.
+  return out.replace(/[ \t]{2,}/g, " ").trim();
+}
+
+/**
+ * The token set a stage reads. A scenario can carry one set for every stage,
+ * or one per stage -- a job owns its set, so a per-job setup hands each
+ * stage the set its job was given. A missing entry falls back to the
+ * defaults either way, so an older scenario without them still runs.
+ */
+function tokenSet(tokens                                                        , k        )                {
+  // One job's list is a list of mappings; one list per stage is a list of
+  // lists. An empty list is one job's, mapping nothing.
+  const perStage = tokens.length > 0 && tokens.every(t => t === undefined || Array.isArray(t));
+  return perStage ? ((tokens                                          )[k] || TOKEN_DEFAULTS) : tokens                 ;
+}
+
+/** The names a list of mappings answers to inside braces. */
+const tokenNames = (tokens               )           =>
+  tokens.flatMap(m => TOKEN_TYPES[m.type]?.names(m.name) ?? []);
+
+/**
+ * Where a common piece of text goes inside an instruction: at `{text}` if the
+ * wording places it, otherwise on a line of its own at the end.
+ *
+ * Shared rather than written twice because both pages do this and they have
+ * to agree: text content and image content are the same question
+ * asked on two screens, and a wording carried between them that meant
+ * different things would be the drift this file exists to stop. The line
+ * break matters -- gluing the text onto the end of the instruction produced
+ * "of this text.one two three" in issue #310.
+ */
+function textPrompt(instruction        , text        )         {
+  return instruction.includes("{text}") ? instruction.replaceAll("{text}", text)
+                                        : `${instruction}\n${text}`;
+}
+
+// Mirrors TagRules' WORD. The unit the echo guard and the eval matcher both
+// work in, so that "New Zealand." and "new zealand" are the same two words.
+const words = (s         )           => String(s||"").toLowerCase().match(/[\p{L}\p{N}]+/gu) || [];
+
+// The request Tagger builds, field for field -- when the target reads those
+// fields. A llama.cpp server does; the hosted OpenAI-shaped providers do
+// not, and reject unknown arguments outright ("Unrecognized request
+// arguments supplied"), which is what a run against one of them died on.
+// For those the request carries only the portable OpenAI shape, with
+// max_completion_tokens standing in for n_predict (max_tokens is rejected
+// by gpt-5 and other reasoning models: "Use 'max_completion_tokens'
+// instead"). The hosts named here are the same two the relay allow-lists
+// as providers, so what is named is what can be reached at all.
+const HOSTED = new Set(["api.openai.com", "openrouter.ai"]);
+
+/**
+ * Whether an endpoint takes the hosted request shape rather than llama.cpp's.
+ *
+ * Shared with the connection editor so the UI and the request agree on what a
+ * connection is: the editor was offering the Speed profile on hosted
+ * endpoints, where building the body then threw.
+ */
+function isHostedUrl(url = "")          {
+  try {
+    return HOSTED.has(new URL(/:\/\//.test(url) ? url : "http://" + url).hostname.toLowerCase());
+  } catch { return false; } // unreadable means unrecognised; llama.cpp is the default
+}
+
+// Kept in step with Tagger.SEED, so the lab and the handset decode alike.
+const SEED = 1234;
+
+// The reply-token cap every OpenAI-compatible, llama.cpp and Anthropic request
+// carried before a profile had to set one (generic-lab step 4). Now a request
+// carries none unless its profile sets it, so a long answer is not cut to one
+// app's length; `pinReplyTokens` writes this into a profile saved before, so
+// what it measures does not move.
+const REPLY_TOKENS_BEFORE = 160;
+// The Messages API will not answer without a max_tokens, so an Anthropic
+// profile that sets none still sends one: a ceiling, not a length.
+const ANTHROPIC_MAX_TOKENS = 4096;
+
+// The decoding fields a llama.cpp profile carries, as ordinary settings. The
+// measured presets of these are data, Setup's presets, so nothing here is one
+// app's candidate list.
+const DECODING_KEYS                    = ["repeatPenalty", "frequencyPenalty", "presencePenalty",
+                       "dryMultiplier", "dryBase", "dryAllowedLength", "grammar"];
+
+/** A field the user may have left blank. Blank means "use the default". */
+function asNumber(v         )                {
+  if (v == null) return null;
+  const t = String(v).trim();
+  if (t === "" || !/^-?\d+(\.\d+)?$/.test(t)) return null;
+  const n = parseFloat(t);
+  return isFinite(n) ? n : null;
+}
+
+// ---- the connection-type registry (#46) -----------------------------------
+// A Setup profile is one registered connection type plus that type's own
+// settings; nothing is one app's shape. The registry is where the transport
+// lives -- how a request is built, how a reply is read, how models are listed
+// -- and what the form offers comes from it too, so a new type is a new entry
+// and nothing that reads a connection changes. The ones that ship are generic;
+// a tuned local engine is a llama.cpp profile with its settings.
+const CONNECTION_TYPES                                 = Object.create(null);
+
+/** The key [key] as the header most endpoints expect, when there is one. */
+const bearer = (key                           )                         => (key ? { Authorization: "Bearer " + key } : {});
+
+/**
+ * An entered address normalised to the /v1 base the chat paths hang off: a
+ * bare host and port, a base URL, a /v1, or the full chat path. The runner,
+ * the relay and the page's Test connection all build URLs from one copy.
+ */
+function apiBase(raw         )         {
+  let s = String(raw || "").trim().replace(/\/+$/, "");
+  if (!s) return "";
+  if (!/^https?:\/\//.test(s)) s = "http://" + s;
+  if (s.endsWith("/chat/completions")) s = s.slice(0, -"/chat/completions".length);
+  return s.endsWith("/v1") ? s : s + "/v1";
+}
+
+/** The model ids a /v1/models reply lists: every type serves that shape. */
+const idsFrom = (j         )           => ((j                                      )?.data || []).map(m => m.id);
+
+// The models list every type reaches at its base + /models, for the page's
+// Test connection through the relay; only the auth differs (Anthropic's).
+const listModels = (base        , key                , auth = bearer(key)) => ({ url: base + "/models", headers: auth });
+
+/** A /v1/chat/completions reply, as the OpenAI-shaped types read it. */
+function chatReply(j         )                                               {
+  const r = j                                                                                     ;
+  return { raw: r?.choices?.[0]?.message?.content ?? "", finishReason: r?.choices?.[0]?.finish_reason ?? null };
+}
+
+function ollamaType(id        , label        , cloud         )                 {
+  return {
+    id, label,
+    description: cloud ? "Ollama's cloud at ollama.com, with a key." : "Ollama on a machine of your own; it takes no key.",
+    settings: [
+      { key: "seed", label: "Seed", control: "text", default: "", hint: "" },
+      { key: "nPredict", label: "Reply tokens", control: "text", default: "", hint: "" },
+      { key: "temperature", label: "Temperature", control: "text", default: "", hint: "" },
+      { key: "repeatPenalty", label: "Repeat penalty", control: "text", default: "", hint: "" },
+    ],
+    // Ollama's native /api/chat, at the server root rather than under /v1.
+    request(conn, prompt, dataUrl, base, key) {
+      // Seeded by default, like every profile: an eval graded against a
+      // resample is grading noise, and the lab exists to tell wordings apart.
+      const options                         = { seed: asNumber(conn.seed) ?? SEED };
+      const num_predict = asNumber(conn.nPredict); if (num_predict != null) options.num_predict = num_predict;
+      const temperature = asNumber(conn.temperature); if (temperature != null) options.temperature = temperature;
+      const repeat_penalty = asNumber(conn.repeatPenalty); if (repeat_penalty != null) options.repeat_penalty = repeat_penalty;
+      const message                                                       = { role: "user", content: prompt };
+      // Ollama's own endpoint takes the bytes as bare base64, where every /v1
+      // type takes a data URL. Handing it the whole URL puts "data:image/..."
+      // through its decoder as payload, and it refuses the image outright --
+      // "illegal base64 data at input byte 4", once per item, for the whole run.
+      if (dataUrl) message.images = [String(dataUrl).replace(/^data:[^,]*,/, "")];
+      return {
+        url: base.replace(/\/v1$/, "") + "/api/chat",
+        headers: cloud ? bearer(key) : {},
+        body: { model: conn.model, messages: [message], options, stream: false },
+      };
+    },
+    parseReply(j) {
+      const r = j                                                                   ;
+      return { raw: r?.message?.content ?? "", finishReason: r?.done_reason ?? null };
+    },
+    listModels: (base, key) => listModels(base, cloud ? key : null),
+    parseModels: idsFrom,
+    ...(cloud ? { url: "https://ollama.com" } : { keyless: true }),
+  };
+}
+// Two types, one API: Ollama on a machine of your own takes no key -- there
+// is nowhere to set one -- and Ollama's cloud (ollama.com) takes one as a
+// bearer token and has an address of its own.
+CONNECTION_TYPES.ollama = ollamaType("ollama", "Ollama (Local)", false);
+CONNECTION_TYPES["ollama-cloud"] = ollamaType("ollama-cloud", "Ollama (Cloud)", true);
+
+// Echo answers each text item with the item's own text, so a pipeline can be
+// graded over replies recorded earlier -- a Source of them, one a file --
+// with no model at all (#97). Over Prompt only it answers with the
+// scenario's prompt, so a reply can be written straight into the prompt and
+// each scenario holds one. Only job 1 can use it: a later job's item is the
+// job before's answer, not a file.
+const sendsNothing = ()        => { throw new Error("Echo answers from the item and sends no request"); };
+CONNECTION_TYPES.echo = {
+  id: "echo", label: "Echo", settings: [], keyless: true,
+  description: "No model: answers with each text item itself, to grade replies recorded earlier.",
+  local: (item, sent) => item.text ?? sent,
+  request: sendsNothing, parseReply: sendsNothing, listModels: sendsNothing, parseModels: () => [],
+};
+
+/** A local type's answer to one stage, as a model's would come back. An item
+    with no text of its own (Prompt only) is answered from the prompt, and
+    that reply is read against nothing -- the prompt is the reply, not an
+    instruction it could repeat. */
+function localAnswer(conn          , text               , sent        )        {
+  const raw = CONNECTION_TYPES[typeOf(conn)] .local ({ text }, sent);
+  return { raw, ms: 0, conn: (conn.name                      ) ?? null, ...(text == null ? { readAgainst: "" } : {}) };
+}
+
+CONNECTION_TYPES["openai-compatible"] = {
+  id: "openai-compatible", label: "OpenAI-compatible",
+  description: "OpenAI, OpenRouter, vLLM, LM Studio: any chat completions endpoint.",
+  settings: [
+    { key: "temperature", label: "Temperature", control: "text", default: "", hint: "" },
+    { key: "nPredict", label: "Reply tokens", control: "text", default: "", hint: "" },
+  ],
+  // /v1/chat/completions, covering OpenAI, OpenRouter, vLLM, LM Studio. The
+  // reasoning-model temperature rule and max_completion_tokens stay with this
+  // type, as the hosted providers reject the fields a llama.cpp server takes.
+  request(conn, prompt, dataUrl, base, key) {
+    const hosted = isHostedUrl(base);
+    const isReasoning = /^(gpt-5|o\d)/i.test(String(conn.model ?? ""));
+    const temp = asNumber(conn.temperature);
+    const predict = asNumber(conn.nPredict);
+    return {
+      url: base + "/chat/completions",
+      headers: bearer(key),
+      body: {
+        model: conn.model,
+        ...(isReasoning || temp == null ? {} : { temperature: temp }),
+        ...(predict == null ? {} : hosted ? { max_completion_tokens: predict } : { max_tokens: predict }),
+        messages: [{ role: "user", content: [
+          { type: "text", text: prompt },
+          ...(dataUrl ? [{ type: "image_url", image_url: { url: dataUrl } }] : []),
+        ] }],
+      },
+    };
+  },
+  parseReply: chatReply,
+  listModels, parseModels: idsFrom,
+};
+
+CONNECTION_TYPES.anthropic = {
+  id: "anthropic", label: "Anthropic",
+  description: "Claude, through Anthropic's Messages API.",
+  settings: [
+    { key: "temperature", label: "Temperature", control: "text", default: "", hint: "" },
+    { key: "maxTokens", label: "Reply tokens", control: "text", default: "", hint: "" },
+  ],
+  // The Messages API: the x-api-key and anthropic-version headers, base64
+  // image content blocks, and /v1/models for the list.
+  request(conn, prompt, dataUrl, base, key) {
+    const temp = asNumber(conn.temperature);
+    const predict = asNumber(conn.maxTokens) ?? ANTHROPIC_MAX_TOKENS;
+    const content           = [];
+    if (dataUrl) {
+      const m = /^data:(image\/[^;]+);base64,(.*)$/s.exec(dataUrl);
+      if (m) content.push({ type: "image", source: { type: "base64", media_type: m[1], data: m[2] } });
+    }
+    content.push({ type: "text", text: prompt });
+    return {
+      url: base + "/messages",
+      headers: { ...(key ? { "x-api-key": key } : {}), "anthropic-version": "2023-06-01" },
+      body: {
+        model: conn.model,
+        max_tokens: predict,
+        ...(temp == null ? {} : { temperature: temp }),
+        messages: [{ role: "user", content }],
+      },
+    };
+  },
+  parseReply(j) {
+    const r = j                                                                                ;
+    const raw = (r?.content || []).filter(b => b.type === "text").map(b => b.text).join("");
+    return { raw, finishReason: r?.stop_reason ?? null };
+  },
+  listModels: (base, key) => listModels(base, key,
+    { ...(key ? { "x-api-key": key } : {}), "anthropic-version": "2023-06-01" }),
+  parseModels: idsFrom,
+};
+
+// The values Speed sent today, kept as a converted Speed profile's settings
+// so a llama.cpp profile reproduces the Speed request byte for byte.
+const SPEED_IMAGE = "before", SPEED_CACHE = "off", SPEED_THINKING = "off";
+
+CONNECTION_TYPES["llama.cpp"] = {
+  id: "llama.cpp", label: "llama.cpp",
+  description: "A llama-server you run, with its sampler settings.",
+  settings: [
+    { key: "temperature", label: "Temperature", control: "text", default: "", hint: "" },
+    { key: "seed", label: "Seed", control: "text", default: "", hint: "" },
+    { key: "nPredict", label: "Reply tokens", control: "text", default: "", hint: "" },
+    { key: "repeatPenalty", label: "Repeat penalty", control: "text", default: "", hint: "" },
+    { key: "frequencyPenalty", label: "Frequency penalty", control: "text", default: "", hint: "" },
+    { key: "presencePenalty", label: "Presence penalty", control: "text", default: "", hint: "" },
+    { key: "dryMultiplier", label: "DRY multiplier", control: "text", default: "", hint: "" },
+    { key: "dryBase", label: "DRY base", control: "text", default: "", hint: "" },
+    { key: "dryAllowedLength", label: "DRY allowed length", control: "text", default: "", hint: "" },
+    { key: "grammar", label: "Grammar", control: "text", default: "", hint: "" },
+    { key: "imagePosition", label: "Image position", control: "select", default: "after",
+      choices: [{ value: "before", label: "before the prompt" }, { value: "after", label: "after the prompt" }], hint: "" },
+    { key: "cachePrompt", label: "Cache prompt", control: "select", default: "off",
+      choices: [{ value: "on", label: "on" }, { value: "off", label: "off" }], hint: "" },
+    { key: "thinking", label: "Thinking", control: "select", default: "off",
+      choices: [{ value: "on", label: "on" }, { value: "off", label: "off" }], hint: "" },
+    { key: "rejectLoops", label: "Reject looping replies", control: "select", default: "off",
+      choices: [{ value: "on", label: "on" }, { value: "off", label: "off" }], hint: "" },
+  ],
+  request(conn, prompt, dataUrl, base, key) {
+    if (isHostedUrl(base)) throw new Error("llama.cpp requires its llama-server, not a hosted model");
+    const temp = asNumber(conn.temperature);
+    const seed = asNumber(conn.seed) ?? SEED;
+    const predict = asNumber(conn.nPredict);
+    const penalty = asNumber(conn.repeatPenalty);
+    const sampler = {
+      frequency_penalty: asNumber(conn.frequencyPenalty),
+      presence_penalty: asNumber(conn.presencePenalty),
+      dry_multiplier: asNumber(conn.dryMultiplier),
+      dry_base: asNumber(conn.dryBase),
+      dry_allowed_length: asNumber(conn.dryAllowedLength),
+      grammar: String(conn.grammar ?? "").trim() || null,
+    };
+    const content           = [
+      { type: "text", text: prompt },
+      ...(dataUrl ? [{ type: "image_url", image_url: { url: dataUrl } }] : []),
+    ];
+    if ((conn.imagePosition || "after") === "before") content.reverse();
+    return {
+      url: base + "/chat/completions",
+      headers: bearer(key),
+      body: {
+        model: conn.model,
+        seed,
+        ...(temp == null ? {} : { temperature: temp }),
+        ...(penalty == null ? {} : { repeat_penalty: penalty }),
+        ...Object.fromEntries(Object.entries(sampler).filter(([, v]) => v != null)),
+        cache_prompt: (conn.cachePrompt || "off") === "on",
+        ...(predict == null ? {} : { n_predict: predict }),
+        chat_template_kwargs: { enable_thinking: (conn.thinking || "off") === "on" },
+        messages: [{ role: "user", content }],
+      },
+    };
+  },
+  parseReply: chatReply,
+  listModels, parseModels: idsFrom,
+  // A reply that arrived is still a failure when this profile asked for the
+  // Speed looping check (today's speedReplyError, now an opt-in setting).
+  replyProblem(conn, raw, finishReason) {
+    return (conn.rejectLoops || "off") === "on" ? loopReplyError(raw, finishReason) : null;
+  },
+};
+
+// ---- HTTP APIs: how a request body is shaped --------------------------------
+// An HTTP Request step sends a flow's own body; its HTTP API says where in
+// that body a scenario's words, system prompt, model, settings and prefill
+// go, and how the reply's text is read. Same API in and out: a request is
+// never translated to another provider's shape. "Any endpoint" holds the
+// whole body as its words, for an API the lab has no entry for.
+
+/** A body shape an HTTP Request step can send. */
+                               
+                
+                                                                           
+                             
+                                                                              
+                                                                   
+                                                 
+                              
+                                                               
+                                                                                            
+                                                               
+                                            
+                                              
+                                                                  
+                                                                             
+                                         
+                                                     
+ 
+
+const HTTP_APIS                               = Object.create(null);
+
+/** A setting's text as the body wants it: a number when it reads as one. */
+const settingValue = (v        )          => {
+  const t = v.trim();
+  if (t === "true" || t === "false") return t === "true";
+  return t !== "" && !Number.isNaN(Number(t)) ? Number(t) : v;
+};
+const pick = (o           , keys                   )                         =>
+  Object.fromEntries(keys.filter(k => isObj(o) && o[k] != null && !isObj(o[k])).map(k => [k, isStr(o[k]) ? o[k] : JSON.stringify(o[k])]));
+/** A message's text: the string, or its first text block's. */
+const messageText = (m           )         => isStr(m?.content) ? m.content
+  : Array.isArray(m?.content) ? String(m.content.find((b           ) => b?.type === "text")?.text ?? "") : "";
+const withMessageText = (m           , text        )            => !Array.isArray(m?.content) ? { ...m, content: text }
+  : { ...m, content: m.content.map((b           ) => (b?.type === "text" ? { ...b, text } : b)) };
+/** [body] with the cell's settings set: a blank one leaves the key out. */
+const withSettings = (body           , cell      , keys                   )            => {
+  const out = { ...body };
+  for (const [k, v] of Object.entries(cell.settings || {})) {
+    if (!keys.includes(k)) continue;
+    if (String(v).trim() === "") delete out[k];
+    else out[k] = settingValue(v);
+  }
+  return out;
+};
+
+HTTP_APIS.anthropic = {
+  label: "Anthropic",
+  matches: u => u.hostname === "api.anthropic.com",
+  fields: ["system", "model", "settings", "prefill"],
+  settings: ["max_tokens", "temperature", "top_p", "top_k"],
+  cellOf(body) {
+    const b = isObj(body) ? body              : {};
+    const msgs              = Array.isArray(b.messages) ? b.messages : [];
+    const user = [...msgs].reverse().find(m => m?.role === "user");
+    const last = msgs.at(-1);
+    return {
+      prompt: messageText(user),
+      ...(isStr(b.system) ? { system: b.system } : {}),
+      ...(isStr(b.model) ? { model: b.model } : {}),
+      settings: pick(b, this.settings),
+      ...(last?.role === "assistant" ? { prefill: messageText(last) } : {}),
+    };
+  },
+  place(body, cell) {
+    const b = withSettings(isObj(body) ? body : {}, cell, this.settings);
+    if (cell.model) b.model = cell.model;
+    if (cell.system != null) { if (cell.system === "") delete b.system; else b.system = cell.system; }
+    let msgs              = Array.isArray(b.messages) ? [...b.messages] : [];
+    if (msgs.at(-1)?.role === "assistant") msgs = msgs.slice(0, -1);
+    const at = msgs.map(m => m?.role).lastIndexOf("user");
+    if (at >= 0) msgs[at] = withMessageText(msgs[at], cell.prompt);
+    else msgs.push({ role: "user", content: cell.prompt });
+    if (cell.prefill) msgs.push({ role: "assistant", content: cell.prefill });
+    return { ...b, messages: msgs };
+  },
+  reply(j) {
+    const r = j                                                                                ;
+    return { raw: (r?.content || []).filter(b => b?.type === "text").map(b => b.text).join(""), finishReason: r?.stop_reason ?? null };
+  },
+  withPrefill(j, prefill) {
+    const r = j             ;
+    if (!isObj(r) || !Array.isArray(r.content)) return j;
+    let done = false;
+    return { ...r, content: r.content.map((b           ) => {
+      if (done || b?.type !== "text") return b;
+      done = true;
+      return { ...b, text: prefill + (b.text ?? "") };
+    }) };
+  },
+};
+
+// OpenAI's chat completions, and Azure OpenAI's, which is the same body at a
+// deployment's address.
+const openAiApi = (label        , matches                     )               => ({
+  label, matches,
+  fields: ["system", "model", "settings"],
+  settings: ["max_tokens", "max_completion_tokens", "temperature", "top_p"],
+  cellOf(body) {
+    const b = isObj(body) ? body              : {};
+    const msgs              = Array.isArray(b.messages) ? b.messages : [];
+    const system = msgs.find(m => m?.role === "system" || m?.role === "developer");
+    return {
+      prompt: messageText([...msgs].reverse().find(m => m?.role === "user")),
+      ...(system ? { system: messageText(system) } : {}),
+      ...(isStr(b.model) ? { model: b.model } : {}),
+      settings: pick(b, this.settings),
+    };
+  },
+  place(body, cell) {
+    const b = withSettings(isObj(body) ? body : {}, cell, this.settings);
+    if (cell.model) b.model = cell.model;
+    let msgs              = Array.isArray(b.messages) ? [...b.messages] : [];
+    if (cell.system != null) {
+      const at = msgs.findIndex(m => m?.role === "system" || m?.role === "developer");
+      if (cell.system === "") msgs = msgs.filter((_, x) => x !== at);
+      else if (at >= 0) msgs[at] = withMessageText(msgs[at], cell.system);
+      else msgs.unshift({ role: "system", content: cell.system });
+    }
+    const at = msgs.map(m => m?.role).lastIndexOf("user");
+    if (at >= 0) msgs[at] = withMessageText(msgs[at], cell.prompt);
+    else msgs.push({ role: "user", content: cell.prompt });
+    return { ...b, messages: msgs };
+  },
+  reply: chatReply,
+});
+HTTP_APIS.openai = openAiApi("OpenAI", u => u.hostname === "api.openai.com");
+HTTP_APIS["azure-openai"] = openAiApi("Azure OpenAI", u => u.hostname.endsWith(".openai.azure.com"));
+
+// Any endpoint: the words are the whole body, as JSON with the flow's
+// expressions in it, and the reply is its body as text.
+HTTP_APIS.raw = {
+  label: "Any endpoint",
+  matches: () => true,
+  fields: [],
+  settings: [],
+  cellOf: body => ({ prompt: isStr(body) ? body : JSON.stringify(body, null, 2) }),
+  place(body, cell) {
+    if (!isObj(body) && !Array.isArray(body)) return cell.prompt;
+    try { return JSON.parse(cell.prompt); } catch { throw new Error("the body is not JSON"); }
+  },
+  reply: j => ({ raw: isStr(j) ? j : JSON.stringify(j), finishReason: null }),
+};
+
+/** The HTTP API a flow's request to [uri] speaks: the first entry that
+    matches, Any endpoint otherwise. */
+function httpApiFor(uri        )         {
+  let u             = null;
+  try { u = new URL(uri); } catch { return "raw"; }
+  return Object.entries(HTTP_APIS).find(([id, e]) => id !== "raw" && e.matches(u ))?.[0] ?? "raw";
+}
+
+// An HTTP endpoint: an address, and how its key travels. It sends whole
+// requests an HTTP Request step builds -- the flow's method, path and body
+// -- so it has no model and no chat path of its own. Its templates fill in
+// the common providers.
+const KEY_HEADERS                                                          = {
+  bearer: key => ({ Authorization: "Bearer " + key }),
+  "x-api-key": key => ({ "x-api-key": key }),
+  "api-key": key => ({ "api-key": key }),
+  none: () => ({}),
+};
+/** A profile's extra headers: `name: value` pairs, separated by `;`. */
+function extraHeaders(raw         )                         {
+  const out                         = {};
+  for (const part of String(raw ?? "").split(";")) {
+    const at = part.indexOf(":");
+    if (at > 0) out[part.slice(0, at).trim()] = part.slice(at + 1).trim();
+  }
+  return out;
+}
+/** An address as a whole-request type hangs paths off it: its origin, no /v1. */
+function originBase(raw         )         {
+  let s = String(raw || "").trim().replace(/\/+$/, "");
+  if (!s) return "";
+  if (!/^https?:\/\//.test(s)) s = "https://" + s;
+  return s;
+}
+const wholeRequestsOnly = ()        => { throw new Error("an HTTP endpoint is sent an HTTP Request step's request, not a prompt"); };
+CONNECTION_TYPES.http = {
+  id: "http", label: "HTTP endpoint",
+  description: "Any API a Power Automate step calls: an address, a key and how the key is sent.",
+  settings: [
+    { key: "auth", label: "Key header", control: "select", default: "bearer", hint: "",
+      choices: [{ value: "bearer", label: "Authorization: Bearer" }, { value: "x-api-key", label: "x-api-key" },
+                { value: "api-key", label: "api-key" }, { value: "none", label: "none" }] },
+    { key: "headers", label: "Headers", control: "text", default: "", hint: "" },
+    // What Test connection asks of it: a GET, keyed as a run is.
+    { key: "testPath", label: "Test path", control: "text", default: "", hint: "" },
+  ],
+  answers: ["request"],
+  lists: false,
+  baseOf: originBase,
+  send(conn, req, base, key) {
+    const query = new URLSearchParams(req.query).toString();
+    return {
+      method: req.method,
+      url: base + req.path + (query ? (req.path.includes("?") ? "&" : "?") + query : ""),
+      headers: { ...extraHeaders(conn.headers), ...(key ? KEY_HEADERS[String(conn.auth || "bearer")]?.(key) ?? {} : {}) },
+      body: req.body,
+    };
+  },
+  request: wholeRequestsOnly,
+  parseReply: j => ({ raw: isStr(j) ? j : JSON.stringify(j), finishReason: null }),
+  listModels: wholeRequestsOnly,
+  parseModels: () => [],
+  templates: [
+    { id: "anthropic", label: "Anthropic",
+      settings: { url: "https://api.anthropic.com", auth: "x-api-key", headers: "anthropic-version: 2023-06-01", testPath: "/v1/models" } },
+    { id: "openai", label: "OpenAI", settings: { url: "https://api.openai.com", auth: "bearer", headers: "", testPath: "/v1/models" } },
+    { id: "azure-openai", label: "Azure OpenAI",
+      settings: { url: "https://RESOURCE.openai.azure.com", auth: "api-key", headers: "", testPath: "/openai/models?api-version=2024-10-21" } },
+  ],
+  // A key goes in the key box, where it is sent by the Key header and never
+  // kept in a pipeline; a header that would carry one is refused.
+  settingsProblems(conn) {
+    const bad           = [];
+    if (!String(conn.url ?? "").trim()) bad.push("needs its address");
+    for (const name of Object.keys(extraHeaders(conn.headers))) {
+      if (/^(authorization|x-api-key|api-key|cookie)$/i.test(name) || /key|token|secret/i.test(name)) {
+        bad.push(`sends a key in its ${name} header -- put the key in the key box`);
+      }
+    }
+    return bad;
+  },
+};
+
+/** The registry entry for [conn]'s type. An unregistered one throws where
+    it is used, as it always has: validation is what refuses one politely. */
+const typeEntry = (conn          )                 => CONNECTION_TYPES[typeOf(conn)] ;
+
+/** The registered type a connection is, converting a legacy profile. */
+function typeOf(conn                             )         {
+  return (conn?.type                      ) || profileType(conn);
+}
+
+/**
+ * The type an old `profile: "quality" | "speed"` connection converts to
+ * (#46): quality is openai-compatible on a hosted or /v1 address, ollama on
+ * a bare host; speed is llama.cpp.
+ */
+function profileType(p                             )         {
+  if (p?.profile === "speed") return "llama.cpp";
+  if (p?.profile === "quality") {
+    const url = String(p.url || "");
+    return (isHostedUrl(url) || /\/v1(\/|$)/.test(url)) ? "openai-compatible" : "ollama";
+  }
+  return "ollama";
+}
+
+/**
+ * A stored profile converted once to the registry shape: keeps every field
+ * and sets `type`, with the settings a converted Speed profile carries so its
+ * request is byte-identical to today's. Runs once per profile on load.
+ */
+function convertProfile(p         )          {
+  const out          = { ...p };
+  if (p.profile === "speed") {
+    out.type = "llama.cpp";
+    out.temperature = "0.1";
+    out.repeatPenalty = "1.15";
+    out.seed = "1234";
+    out.imagePosition = SPEED_IMAGE;
+    out.cachePrompt = SPEED_CACHE;
+    out.thinking = SPEED_THINKING;
+    out.rejectLoops = "on";
+    out.nPredict = String(REPLY_TOKENS_BEFORE);
+  } else {
+    out.type = profileType(p);
+  }
+  delete out.profile;
+  return out;
+}
+
+/**
+ * An Ollama profile from before Ollama was two types: one holding a key was
+ * reaching a server that takes one, so it is the cloud type; one without is
+ * a machine of the owner's own. Anything else comes back as it was.
+ */
+/**
+ * A profile saved before requests stopped carrying a reply-token cap unless
+ * one was set: its type's Reply tokens setting, absent, is the cap it has
+ * been sending, written in, so its runs go on measuring what they did. A
+ * profile made since has the setting, blank or not, and comes back as it
+ * was, as does one of a type that never sent the cap.
+ */
+function pinReplyTokens(p         )          {
+  const key = ({ "openai-compatible": "nPredict", "llama.cpp": "nPredict", anthropic: "maxTokens" }                          )[String(p.type)];
+  return !key || key in p ? p : { ...p, [key]: String(REPLY_TOKENS_BEFORE) };
+}
+
+function splitOllama(p         )          {
+  if (p.type !== "ollama" || !String(p.key || "").trim()) return p;
+  return { ...p, type: "ollama-cloud", url: String(p.url || "").trim() || CONNECTION_TYPES["ollama-cloud"] .url  };
+}
+
+/**
+ * The request [conn] sends for [prompt] (and an image [dataUrl], if any),
+ * as its type builds it: the URL, the headers, and the body. [base] is the
+ * /v1-normalised base, [key] the auth key if there is one. The resolved
+ * connection carries its type's settings under `options`, so they are merged
+ * up before the type reads them.
+ */
+function connectionRequest(conn          , prompt        , dataUrl               , base        , key                )              {
+  const flat           = { ...conn, ...(conn?.options || {}) };
+  return typeEntry(flat).request(flat, prompt, dataUrl, base, key);
+}
+
+/** Where [conn]'s requests hang off: its type's own reading of its address,
+    or the /v1 base a chat API's paths hang off. */
+function connectionBase(conn          )         {
+  const type = CONNECTION_TYPES[typeOf(conn)];
+  return type?.baseOf ? type.baseOf(conn.url) : apiBase(conn.url);
+}
+
+/** The HTTP request [conn] sends for an HTTP Request step's [req]. */
+function connectionSend(conn          , req                                                                                ,
+                        base        , key                )              {
+  const flat           = { ...conn, ...(conn?.options || {}) };
+  const type = typeEntry(flat);
+  if (!type.send) throw new Error(`a ${type.label} profile cannot send a whole request`);
+  return type.send(flat, req, base, key);
+}
+
+/** A reply [conn] received, read as its raw text and finish reason. */
+function connectionReply(conn          , j         )                                               {
+  return typeEntry(conn).parseReply(j);
+}
+
+/** Why a reply [conn] received is a failure though it arrived, or null. */
+function connectionReplyProblem(conn          , raw        , finishReason               )                {
+  return typeEntry(conn).replyProblem?.(conn, raw, finishReason) ?? null;
+}
+
+/**
+ * Whether a reply the Speed looping check guards against looped or truncated:
+ * today's speedReplyError, now the llama.cpp type's rejectLoops setting.
+ */
+function loopReplyError(reply        , finishReason               )                {
+  if (finishReason === "length") return "the model repeated or truncated its answer";
+  const items = String(reply).toLowerCase().split(/[,;\n]/).map(s => s.trim().replace(/^\.+|\.+$/g, "")).filter(Boolean);
+  const frequencies = new Map                ();
+  for (const item of items) frequencies.set(item, (frequencies.get(item) || 0) + 1);
+  if (items.length >= 4 && [...frequencies.values()].some(n => n >= 3)) return "the model repeated or truncated its answer";
+  const ws = words(reply);
+  for (let width = 1; width <= 6; width++) for (let start = 0; start + width * 3 <= ws.length; start++) {
+    if (Array.from({length: width}, (_, n) => n).every(n => ws[start+n] === ws[start+n+width] && ws[start+n] === ws[start+n+width*2]))
+      return "the model repeated or truncated its answer";
+  }
+  return null;
+}
+
+// ---- Scoring -------------------------------------------------------------
+/**
+ * The dimensions an image is sent at, for a budget.
+ *
+ * [target] is an area in pixels, or the string "edge448" for the one mode an
+ * area cannot express -- see below.
+ */
+function preparedSize(width        , height        , target                 )                   {
+  const ratio = width / height;
+  // 448 on the longest side, aspect kept. Not an area budget and not
+  // expressible as one: it is the single-tile case WITHOUT the squash that
+  // `Tagger.prepare` applies, kept here so the two can be graded against each
+  // other. A 4:3 image goes 448x336 rather than 448x448, so the tile
+  // carries a letterboxed image instead of a distorted one -- which of those
+  // the model reads better is a question, not a known.
+  //
+  // Lab-only: the app has no longest-edge mode, so a result measured here is
+  // not something the handset can currently reproduce.
+  if (target === EDGE_448) {
+    const scale = 448 / Math.max(width, height);
+    const snap = (v        ) => Math.min(448, Math.max(56, Math.round(v * scale / 56) * 56));
+    const tw = snap(width), th = snap(height);
+    return width <= tw && height <= th ? [width, height] : [tw, th];
+  }
+  const square = Number(target) <= 448 * 448;
+  const h = Math.sqrt(Number(target) / ratio);
+  const tw = square ? 448 : Math.max(56, Math.round(h * ratio / 56) * 56);
+  const th = square ? 448 : Math.max(56, Math.round(h / 56) * 56);
+  return width <= tw && height <= th ? [width, height] : [tw, th];
+}
+
+/** The one resolution setting that is a mode rather than a number. */
+const EDGE_448 = "edge448";
+
+/** How a budget reads in a sentence, for the run record and the log. */
+function budgetLabel(target         )         {
+  return target === EDGE_448 ? "448 longest edge" : `${(Number(target) / 1e6).toFixed(1)}MP`;
+}
+
+// What `docs/datasets.md` says the graded set means, in code.
+
+// A term is present when its words appear in some item, in order and adjacent:
+// "cat" is in "cat" and in "tabby cat", and is not in "cathedral". Anything
+// looser scores "new zealand" against "zealandia" and flatters every run.
+function termIn(items                   , term        )          {
+  const t = words(term);
+  if (!t.length) return false;
+  return items.some(item => {
+    const w = words(item);
+    for (let i = 0; i + t.length <= w.length; i++) {
+      if (t.every((x, j) => w[i + j] === x)) return true;
+    }
+    return false;
+  });
+}
+
+// A forbidden term counts wherever termIn finds it, except inside a item that
+// holds one of the case's `allow` phrases and that phrase holds the term:
+// "train car" is a fair item for a locomotive whose case forbids "car", and a
+// bare "car" beside it still counts.
+function forbiddenIn(items                   , term        , allow                               )          {
+  return items.some(item => termIn([item], term)
+    && !(allow || []).some(a => termIn([a], term) && termIn([item], a)));
+}
+
+/**
+ * The graded half as one list, each entry carrying where it is graded.
+ *
+ * A named function rather than a bare array, so that something can check it.
+ * Issue #270 was this list being built from one half of the old file alone, and an inline
+ * assembly can quietly go back to that: nothing in CI can reach into an async
+ * boot for the array it produced, so the fault would ship again with every
+ * check green. `evals-check.js` calls this directly.
+ */
+function gradedSetFrom(ev         )              {
+  return (ev.cases || []).map(c => ({ ...c, filename: caseFile(c), half: "cases" })             );
+}
+
+/**
+ * The file a case grades, whichever of the two keys names it.
+ *
+ * One reader, so that accepting the older spelling is a fact about this
+ * function rather than a branch every caller carries. Everything that joins a
+ * case to an item -- the runner, the Datasets tab, a mapping against a Source
+ * -- goes through here.
+ */
+function caseFile(kase                                                            )         {  // vocab: the older spelling
+  const name = kase?.filename ?? kase?.photo;  // vocab: the older spelling
+  return typeof name === "string" ? name : "";
+}
+
+/**
+ * A graded set with every case naming its file as `filename`.
+ *
+ * What `evalsJson` writes, so the committed bytes carry one key and a set
+ * re-synced from an app's own repository is normalised the first time it is
+ * exported. The key takes the place the older one held, so normalising a set
+ * changes the spelling of
+ * one key and not the order of any.
+ */
+function canonicalCases(ev         )          {
+  const OLD = "photo";  // vocab: the older spelling of filename
+  const set = ev                                ;
+  const cases = set && typeof set === "object" && Array.isArray(set.cases) ? set.cases : null;
+  if (!cases || !cases.some(c => c && typeof c === "object" && OLD in (c          ))) return ev;
+  return {
+    ...set,
+    cases: cases.map(c => {
+      if (!c || typeof c !== "object" || !(OLD in (c          ))) return c;
+      const out                          = {};
+      for (const [k, v] of Object.entries(c                           )) {
+        if (k === OLD) { if (!("filename" in (c          ))) out["filename"] = v; }
+        else out[k] = v;
+      }
+      return out;
+    }),
+  };
+}
+
+/**
+ * One graded case, one result.
+ *
+ * Every expectation is a group, and a plain `expect` term is a group of one:
+ * the requirements are the `expect` terms and the `anyOf` groups alike, and
+ * the score is found requirements over all of them plus `forbid`. A count
+ * bound stays pass/fail: an item that produced two perfect terms when five
+ * were wanted has not done what was asked.
+ *
+ * Pure on purpose, and returning `reasons` as plain sentences rather than
+ * markup. The dashboard was the first consumer; `run-evals.js` is the second
+ * and CI the third, and neither can reach into a page for a rendered cell.
+ * Issue #248 wants a failure written out as a task an agent can act on.
+ */
+function scoreCase(kase      , res                                                              )            {
+  // A case that expects its answer discarded passes on a discard and on
+  // nothing else: the answer the job threw away is the finding.
+  if (kase.discarded === true) {
+    const thrown = !!res.error && res.error.startsWith("discarded: ");
+    const n = (res.terms || []).length;
+    return { pass: thrown, score: thrown ? 1 : 0, discarded: !!res.error, found: [], missed: [], invented: [],
+             unmet: [], under: false, over: false, count: res.error ? 0 : n, watchFound: [], watchTotal: 0,
+             reasons: thrown ? [] : [res.error ? `Error - ${res.error}` : `FAIL: kept ${n} items, and the case expects the answer discarded`] };
+  }
+  // A discarded answer is a failed item: whatever the pipeline produced
+  // along the way does not count.
+  const discarded = !!res.error;
+  const terms = discarded ? [] : (res.terms || []);
+  const expect = kase.expect || [], forbid = kase.forbid || [];
+
+  // `missed` stays populated for a discarded reply even though it reads as
+  // vacuous, because the score depends on it: docs/datasets.md has such a reply
+  // scoring zero against everything the entry asked for, groups included, and
+  // `addToTally` gets there through `found + missed + invented`. Clear it and
+  // a run that discarded every item would contribute nothing to the
+  // total instead of contributing a nought, which flatters it.
+  //
+  // One member of a group is enough. Without this rule the set manufactures
+  // failures out of synonyms.
+  //
+  // A requirement reads back as a term when it had one member and as the
+  // group itself where a synonym list was allowed, so `missed` carries just
+  // enough to state the reason: "FAIL: Missed dog" for a plain expect term,
+  // "none of dog / puppy" for a group.
+  //
+  // Nothing satisfies a group when nothing was stored, so a discarded reply
+  // misses every requirement rather than none -- the same cast that makes its
+  // count bounds not breached by one. `unmet` is a finding only now that
+  // `missed` names the unsatisfied groups itself, but the run report has
+  // always carried it, so it stays.
+  const met = (g          ) => g.some(t => termIn(terms, t));
+  const spoken = (g          )              => g.length === 1 ? g[0]  : g;
+  const requirements = [...expect.map(t => [t]), ...(kase.anyOf || [])];
+  const found = requirements.filter(met).map(spoken);
+  const missed = requirements.filter(g => !met(g)).map(spoken);
+  const invented = forbid.filter(t => forbiddenIn(terms, t, kase.allow));
+  const unmet = discarded ? []
+    : (kase.anyOf || []).filter(g => !g.some(t => termIn(terms, t)));
+
+  const n = terms.length;
+  // A null bound is not checked -- and neither is a bound on a reply that was
+  // discarded. Nothing was counted out and found wanting there; the reply was
+  // thrown away before it had a count, and saying "0 items, wanted at least 4"
+  // states a second failure that never happened.
+  const under = !discarded && kase.minCount != null && n < kase.minCount;
+  const over = !discarded && kase.maxCount != null && n > kase.maxCount;
+
+  const denom = requirements.length + invented.length;
+  // A case that passes is one whose whole expectation was met, not one that
+  // scored well: an unsatisfied group is in `missed` alongside any term
+  // missed, so pass needs nothing more than the terms already covered.
+  const pass = !discarded && !missed.length && !invented.length && !under && !over;
+
+  // `found` and `missed` are groups, not terms, so the reasons word them one
+  // by one: a bare term under one heading, a group on its own line.
+  const reasons           = [];
+  if (discarded) {
+    // Everything else would be derived from this one fact -- there are no
+    // terms -- and would bury it. `scoreHtml` above suppresses `missed` for
+    // the same reason: the reason that matters is already on the row.
+    reasons.push(`Error - ${res.error}`);
+  } else {
+    const plain = missed.filter(t => typeof t === "string");
+    if (plain.length) reasons.push(`FAIL: Missed ${plain.join(", ")}`);
+    for (const g of missed) {
+      if (Array.isArray(g)) reasons.push(`none of ${g.join(" / ")}`);
+    }
+    if (invented.length) reasons.push(`invented ${invented.join(", ")}`);
+    if (under) reasons.push(`${n} items, wanted at least ${kase.minCount}`);
+    if (over) reasons.push(`${n} items, wanted at most ${kase.maxCount}`);
+  }
+
+  // Observed rather than scored: a dataset that wants to know whether some
+  // terms turn up, without grading on them, lists them as `watch`.
+  const watch = kase.watch || [];
+  // `null`, not 1, when there are no requirements and nothing forbidden turned
+  // up: there is no score to report. Returning 1 there printed "fail 100%"
+  // beside an entry that asked for nothing -- a shape `evals-check.js` allows
+  // even though every graded case now names an expectation.
+  return { pass, score: denom ? found.length / denom : null, discarded,
+           found, missed, invented, unmet, under, over, count: n,
+           watchFound: watch.filter(t => termIn(terms, t)), watchTotal: watch.length,
+           reasons };
+}
+
+/**
+ * A queue row's stored results as today's: before generic-lab step 3 a
+ * result's terms and a dropped item were spelled as the retired kind spelled
+ * them (`upgradeResults` names them). Rows are
+ * kept as they were written -- a run's replies cost a model's time to make
+ * again -- so every reader of one (the page's API client, the runner's
+ * resume and re-score) reads it through this. Anything else comes back as it
+ * was.
+ */
+function upgradeResults   (items   )    {
+  if (!Array.isArray(items)) return items;
+  const res = (r         )          => {
+    if (!isObj(r) || !("tags" in r) || "terms" in r) return r;  // vocab: a pre-v3 row's spelling
+    const { tags: was, dropped, ...rest } = r             ;  // vocab: as above
+    return {
+      ...rest, terms: Array.isArray(was) ? was : [],
+      ...(Array.isArray(dropped) ? { dropped: dropped.map((d           ) =>
+        isObj(d) && "tag" in d ? { item: d.tag, by: d.rule } : d) } : {}),  // vocab: as above
+    };
+  };
+  // Before version 6 a run had one test, whose score a cell kept as `score`:
+  // the upgrade names that test t1 (testsList).
+  const cell = (sc                           )                            => {
+    const next = sc.res ? { ...sc, res: res(sc.res) } : sc;
+    if (!("score" in next) || "scores" in next) return next;
+    const { score, ...rest } = next;
+    return { ...rest, scores: isObj(score) ? { t1: score } : null };
+  };
+  return items.map(it => !isObj(it) || !Array.isArray(it.scenarios) ? it
+    : { ...it, scenarios: (it.scenarios             ).map(sc => isObj(sc) ? cell(sc) : sc) })     ;
+}
+
+const emptyTally = ()        => ({ ran: 0, passed: 0, found: 0, of: 0 });
+
+// Summed across cases rather than averaged, for the reason in
+// docs/datasets.md: an item naming more terms should weigh more than
+// one naming fewer, and averaging percentages lets the easiest case carry the
+// score.
+function addToTally(t       , s                                                           )       {
+  t.ran++;
+  if (s.pass) t.passed++;
+  t.found += s.found.length;
+  t.of += s.found.length + s.missed.length + s.invented.length;
+}
+
+// The headline percentage, in one place because it is a number and this file
+// is about numbers stated twice. `null` where there is nothing to take a
+// percentage of -- a set whose entries name no terms -- so that a caller
+// prints a dash rather than a confident nought.
+function tallyPercent(t       )                {
+  return t.of ? Math.round(100 * t.found / t.of) : null;
+}
+
+// ---- the Single Test -----------------------------------------------------
+// A whole-run assertion with no graded set: All of / Any of / None of, a
+// parse, a count, an exact reply and a length bound. It lives in the shared
+// core because it is a pass/fail the tab, the worker and History all have to
+// agree on -- the same one-definition rule that keeps `scoreCase` here.
+function parseCount(raw        , parse                           )                                           {
+  // An unparsed reply is one result, not no result. It used to return null,
+  // which made a Count of 1 fail as "null results" against a reply that
+  // plainly was one -- the answer was simply not in a format we had split up.
+  if (!parse) return {valid:true, count: 1};
+  if (parse === "csv") {
+    const parts = raw.split(",").map(s=>s.trim()).filter(Boolean);
+    return {valid:true, count: parts.length};
+  }
+  if (parse === "json") {
+    try { const j = JSON.parse(raw); return {valid:true, count: Array.isArray(j) ? j.length : 1}; }
+    catch { return {valid:false, count:null}; }
+  }
+  if (parse === "xml") {
+    const t = raw.trim();
+    if (!t.startsWith("<") || !t.endsWith(">")) return {valid:false, count:null};
+    const marks = t.match(/<[^>]+>/g) || [];
+    return {valid: marks.length > 0, count: marks.length ? Math.floor(marks.length/2) || 1 : 0};
+  }
+  return {valid:true, count:null};
+}
+
+// How a wanted count is compared with the one that came back.
+// "Exactly" was the only comparison there was, which made the field useless
+// for the thing people actually want to say: that a reply should have *at
+// least* a few items, or *no more than* a handful. The op is stored beside
+// the number so an older setup, which has a number and no op, still means
+// exactly what it always meant.
+const COUNT_OPS                                         = [
+  ["atleast", "At least"],
+  ["exactly", "Exactly"],
+  ["atmost", "No more than"],
+  ["not", "Not"],
+];
+const COUNT_OP_LABEL = new Map(COUNT_OPS);
+
+// How a reply's length is compared. Characters of the reply once trimmed,
+// because trailing whitespace is the model's punctuation rather than content.
+const LENGTH_OPS                                         = [
+  ["longer", "Longer than"],
+  ["exactly", "Exactly"],
+  ["shorter", "No longer than"],
+];
+const LENGTH_OP_LABEL = new Map(LENGTH_OPS);
+
+function lengthHolds(op        , got        , want        )          {
+  switch (op) {
+    case "longer":  return got > want;
+    case "shorter": return got <= want;
+    default:        return got === want;
+  }
+}
+
+function countHolds(op        , got               , want        )          {
+  switch (op) {
+    case "atleast": return Number(got) >= want;
+    case "atmost":  return Number(got) <= want;
+    case "not":     return got !== want;
+    default:        return got === want;
+  }
+}
+
+/**
+ * The rules a Single Test asserts, in the order it checks them: one per field
+ * it was given, none for a field left empty. Read from the test alone, so a
+ * test skipped before it ran still names what it would have checked.
+ *
+ * A parse only has a rule where it can fail: csv and an unformatted reply are
+ * always read, and a Parse row on every test would say nothing.
+ */
+function singleRules(test                     )         {
+  const rules         = [];
+  const list = (key                        , label        ) => {
+    if (test[key]?.length) rules.push({ key, label, want: test[key] .join(", ") });
+  };
+  list("all", "All of");
+  list("any", "Any of");
+  list("none", "None of");
+  if (test.exact != null && String(test.exact).trim() !== "") {
+    rules.push({ key: "exact", label: "Exact", want: String(test.exact).trim() });
+  }
+  if (test.length != null) {
+    rules.push({ key: "length", label: `Length ${(LENGTH_OP_LABEL.get(test.lengthOp || "exactly") || "Exactly").toLowerCase()}`,
+                 want: String(test.length) });
+  }
+  if (test.parse === "json" || test.parse === "xml") rules.push({ key: "parse", label: "Parses as", want: test.parse });
+  if (test.count != null) {
+    rules.push({ key: "count", label: `Count ${(COUNT_OP_LABEL.get(test.countOp || "exactly") || "Exactly").toLowerCase()}`,
+                 want: String(test.count) });
+  }
+  return rules;
+}
+
+/** "3 of 12 replies", or "the reply" where there was only one. */
+const ofReplies = (k        , n        )         => (n === 1 ? "the reply" : `${k} of ${n} replies`);
+const quoted = (s        )         => `"${s.trim().slice(0, 60)}"`;
+
+/**
+ * The Single Test's verdict over a whole run: [terms] and [raws] pool every
+ * item's reply, [plain] is whether the last stage answered as text, which
+ * decides whether the All/Any/None terms are matched in the terms or the raw
+ * replies. Pass is the absence of any reason. [checks] is each of its rules
+ * (singleRules) met or not, with what broke it, so a reader can say which
+ * rule failed without parsing the reasons.
+ */
+function scoreSingle(test                     , terms                   , raws                   , plain = false) 
+                                                                             {
+  const reasons           = [];
+  const broke = new Map                ();
+  const all = test.all || [], any = test.any || [], none = test.none || [];
+  const checkIn = plain
+    ? (raws                   , term        ) => raws.some(r => r.toLowerCase().includes(term.toLowerCase()))
+    : (items                   , term        ) => items.some(item => termIn([item], term));
+  const poolTerms = terms;
+  const poolRaws = raws;
+  const missed = all.filter(s => plain ? !checkIn(poolRaws, s) : !checkIn(poolTerms, s));
+  if (missed.length) {
+    reasons.push(`FAIL: Missed ${missed.join(", ")}`);
+    broke.set("all", `missed ${missed.join(", ")}`);
+  }
+  if (any.length && !any.some(s => plain ? checkIn(poolRaws, s) : checkIn(poolTerms, s))) {
+    reasons.push(`FAIL: Missed any of ${any.join(", ")}`);
+    broke.set("any", "found none");
+  }
+  const invented = none.filter(s => plain ? checkIn(poolRaws, s) : checkIn(poolTerms, s));
+  if (invented.length) {
+    reasons.push(`invented ${invented.join(", ")}`);
+    broke.set("none", `found ${invented.join(", ")}`);
+  }
+  // Exact and Length judge the reply as it came back, not the items read out
+  // of it: "did it answer with precisely this" is a question about the string.
+  if (test.exact != null && String(test.exact).trim() !== "") {
+    const want = String(test.exact).trim();
+    const off = raws.filter(r => String(r).trim() !== want);
+    if (off.length) {
+      reasons.push(`not an exact match: got "${String(off[0]).trim().slice(0, 60)}"`);
+      broke.set("exact", `${ofReplies(off.length, raws.length)} ${raws.length === 1 ? "was" : "differ, first"} ${quoted(String(off[0]))}`);
+    }
+  }
+  if (test.length != null) {
+    const op = test.lengthOp || "exactly", want = test.length;
+    const bad = raws.filter(r => !lengthHolds(op, String(r).trim().length, want));
+    if (bad.length) {
+      const got = String(bad[0]).trim().length;
+      reasons.push(`${got} characters, wanted ` +
+        `${(LENGTH_OP_LABEL.get(op) || "Exactly").toLowerCase()} ${test.length}`);
+      broke.set("length", `${ofReplies(bad.length, raws.length)}, ${raws.length === 1 ? "" : "first "}${got} characters`);
+    }
+  }
+  for (const raw of raws) {
+    const pc = parseCount(raw, test.parse);
+    if (!pc.valid) { reasons.push(`invalid ${test.parse}`); break; }
+    if (test.count != null && !countHolds(test.countOp || "exactly", pc.count, test.count)) {
+      reasons.push(`${pc.count} results, wanted ${(COUNT_OP_LABEL.get(test.countOp || "exactly") || "Exactly").toLowerCase()} ${test.count}`);
+      break;
+    }
+  }
+  // The reasons stop at the first reply that fails a parse or a count; each
+  // rule's check counts every reply, and a reply that did not parse has no
+  // count to hold against.
+  const counted = raws.map(r => parseCount(r, test.parse));
+  const invalid = counted.filter(pc => !pc.valid);
+  if (invalid.length) broke.set("parse", `${ofReplies(invalid.length, raws.length)} invalid`);
+  if (test.count != null) {
+    const off = counted.filter(pc => pc.valid && !countHolds(test.countOp || "exactly", pc.count, test.count ));
+    if (off.length) broke.set("count", `${ofReplies(off.length, raws.length)}, ${raws.length === 1 ? "" : "first "}${off[0] .count} results`);
+  }
+  const pass = !reasons.length;
+  const checks = singleRules(test).map(r => (broke.has(r.key) ? { ...r, pass: false, note: broke.get(r.key)  } : { ...r, pass: true }));
+  return {pass, reasons, score: pass ? 1 : 0, checks};
+}
+
+// A `{name}` in a stage's wording. Narrow on purpose -- a letter first, then
+// word characters, dots and hyphens -- so a JSON example in a prompt is not
+// read as a token and refused.
+const TOKEN = /\{(\/?[A-Za-z][\w.-]*)\}/g;
+
+/**
+ * The first thing in a job that cannot run, as a sentence naming its stage,
+ * or null. Asked before anything is sent, so a misspelt token costs nothing
+ * rather than a vision pass per image -- and so it is an error at all:
+ * left in place, `{stage2.itme}` reaches the model as those characters
+ * and the run looks like a finding about the wording.
+ */
+function jobProblem(stages                  , call                                  ,
+                      tokens                                                        , text               )                {
+  const kinds = stages.map(kindOf);
+  // The names an output kind renders into tokens -- {items} is the List's
+  // -- so a token is checked against the kinds the lab has, not a list here.
+  const offered = new Set(Object.values(OUTPUT_KINDS).flatMap(k => k.offers || []));
+  for (let i = 0; i < stages.length; i++){
+    const at = `stage ${i + 1}`;
+    const base = new Set(tokenNames(tokenSet(tokens, i)));
+    if (!OUTPUT_KINDS[kinds[i] ]) {
+      return `${at} answers as "${kinds[i]}", which is not an output kind this lab has`;
+    }
+    if (typeof (Array.isArray(call) ? call[i] : call) !== "function") {
+      return `${at} has no connection to send it to`;
+    }
+    const why = (name        )                => {
+      if (base.has(name)) return null;
+      if (name === "text") return text != null ? null : "and there is no text content to put there";
+      const m = /^stage([1-9]\d*)(?:\.(.+))?$/.exec(name);
+      let from        , sub               ;
+      if (m) {
+        from = +m[1]  - 1; sub = m[2] ?? null;
+        if (sub != null && !offered.has(sub)) return "which is not a token";
+      } else if (name === "reply") { from = i - 1; sub = null; }
+      else if (offered.has(name)) { from = i - 1; sub = name; }
+      else return "which is not a token";
+      if (from < 0 || from >= i) return i === 0 ? "and nothing comes before stage 1"
+                                                : "which is not an earlier stage";
+      const kind = OUTPUT_KINDS[kinds[from] ] ;
+      if (sub && !(kind.offers || []).includes(sub)) {
+        return `and stage ${from + 1} answers with ${kind.noun || kinds[from]}, which has no ${sub} — `
+             + `{${m ? `stage${from + 1}` : "reply"}} is its reply`;
+      }
+      return null;
+    };
+    if (stages[i] .verbatim) continue;
+    for (const [, name] of String(stages[i] .text).matchAll(TOKEN)) {
+      const reason = why(name );
+      if (reason) return `${at} asks for {${name}}, ${reason}`;
+    }
+  }
+  return null;
+}
+
+// Runs the stages in order, keeping every prompt sent and every reply
+// received. Without the transcript a multi-stage run is undebuggable: you see
+// a different answer and cannot tell which stage changed it, or whether a
+// stage silently received an empty {items}.
+//
+// `call(prompt, dataUrl)` is the transport, injected because that is the only
+// part that differs between the callers: the tab posts to the relay so the
+// browser can reach a firewalled Ollama, the script goes to the endpoint
+// itself, and a check hands it a recorded reply and no network at all. What a
+// reply then means -- discarded, or these items -- is decided here, once. A
+// job whose stages run on different models passes an array, one transport
+// per stage; a reply carrying `conn` names the connection that gave it.
+//
+// A stage's `kind` is what its reply is, and names an OUTPUT_KINDS entry that
+// reads it: "text" is anything at all, forwarded untouched as {reply}, so a
+// stage can describe the image for the next one to list; a kind with a
+// shape -- "list", items -- is held to its own rules and forwarded under
+// the tokens it renders. The caller sets the last stage's kind, and that stage's
+// result is the one graded: a job that ends in text has no terms.
+//
+// A stage's `modifiers` change its value before it is handed on or tested.
+// A caller that gives no stage any gets the last kind's own defaults at
+// `mode`, which is how every caller before modifiers asked for a case.
+//
+// `text` is the text content, when that is what is being run: it joins stage
+// 1 the way `textPrompt` says, and any later stage that places {text}.
+async function runPipeline(stages                  , dataUrl               , call                        ,
+                           opts             = {})                     {
+  const { tokens = TOKEN_DEFAULTS, mode, text = null } = opts;
+  const transcript                    = [];
+  const problem = jobProblem(stages, call, tokens, text);
+  if (problem) return { error: problem, terms: [], transcript, ms: 0 };
+  const kinds = stages.map(kindOf);
+  const explicit = stages.some(st => Array.isArray(st.modifiers));
+  const mods = stages.map((st, i) => explicit ? (st.modifiers || [])
+    : i === stages.length - 1 ? (OUTPUT_KINDS[kinds[i] ] .modifiers?.(mode) || []) : []);
+  const done                                                        = [];
+  // The most recent stage's value, for the result: the terms a job holds
+  // are the ones its latest stage produced, even when a later one failed.
+  let held                                          = null, total = 0, echoed = 0, dropped            = [];
+  // Each stage's modifiers apply to its own value as it is read. A stage with
+  // none hands the model's own spelling on, because "Eiffel Tower"
+  // lowercased on the way through is a different question from the one the
+  // first model answered; a caller that gives no stage any gets the last
+  // kind's defaults on the last stage alone (above).
+  const result = (more                    )            => {
+    const reader = held && OUTPUT_KINDS[held.kind] ;
+    return { terms: reader?.terms ? reader.terms(held .value) : [], transcript, ms: total, ...more };
+  };
+  for (let i = 0; i < stages.length; i++){
+    const st = stages[i] , kind = kinds[i] , reader = OUTPUT_KINDS[kind] ;
+    const named = (m        ) => stages.length > 1 ? `stage ${i + 1}: ${m}` : m;
+    const forwarded = new Map                (text != null ? [["text", text]] : []);
+    done.forEach((d, k) => {
+      forwarded.set(`stage${k + 1}`, d.reply);
+      for (const [name, v] of Object.entries(d.rendered)) forwarded.set(`stage${k + 1}.${name}`, v);
+    });
+    const prev = done[i - 1];
+    if (prev) {
+      forwarded.set("reply", prev.reply);
+      for (const [name, v] of Object.entries(prev.rendered)) forwarded.set(name, v);
+    }
+    // A verbatim stage's words are the call's own template, sent as written.
+    const instruction = st.verbatim ? st.text : resolvePrompt(st.text, tokenSet(tokens, i));
+    const fill = (to                       ) => instruction.replace(TOKEN, (m, name        ) =>
+      forwarded.has(name) ? to(forwarded.get(name) ) : m);
+    const sent = st.verbatim ? instruction : i === 0 && text != null ? textPrompt(instruction, text) : fill(v => v);
+    // What the echo guard measures the reply against: the stage's own
+    // instruction, with nothing that was forwarded into it. Forwarded material
+    // is what the stage is about -- the text content, the items or the reply
+    // an earlier stage produced -- so a reply that repeats it has answered, not
+    // copied. Judged against the whole prompt, a text run lost every term it
+    // correctly took out of the text (#310), and a stage asked to correct a
+    // list lost every item it rightly kept (#408).
+    const echo = st.verbatim ? instruction : fill(() => "");
+    // A stage that does not say sends the item's image on the first stage
+    // only; a job says, and is honoured, the first one included.
+    const withImage = (st.withImage ?? i === 0) && dataUrl != null;
+    const res = await (Array.isArray(call) ? call[i]  : call        )(sent, withImage ? dataUrl : null);
+    total += res.ms;
+    transcript.push({ n: i + 1, kind, conn: res.conn ?? null, withImage, sent: res.sent ?? sent,
+                      got: res.raw ?? "", ms: res.ms, error: res.error, ...(res.said != null ? { said: res.said } : {}) });
+    if (res.error) return result({ error: named(res.error) });
+    // A stage that failed is the end of the job: nothing after it is asked.
+    // Handed nothing, the next stage still answers -- about an empty list --
+    // and that answer is graded as though the job had worked.
+    const handsOn = i < stages.length - 1;
+    const against = res.readAgainst ?? echo;
+    const read = reader.read(res.raw ?? "", { echo: against, parsing: opts.parsing, settings: st.settings });
+    if (read.error) return result({ error: named(read.error) });
+    const mod = applyModifiers(mods[i], kind, read.value, { instruction: against, body: read.body ?? res.raw ?? "" });
+    if (mod.reject) return result({ error: named(`discarded: ${mod.reject}`) });
+    const nothing = handsOn ? reader.handsOn?.(mod.value) : null;
+    if (nothing) return result({ error: named(nothing) });
+    const value = mod.value;
+    held = { kind, value };
+    const gone = [...(read.dropped || []), ...mod.dropped];
+    echoed = (read.echoed || 0) + mod.dropped.filter(d => d.by === ECHO).length;
+    done.push({ reply: res.raw ?? "", rendered: reader.render?.(value) || {} });
+    if (!handsOn) dropped = gone;
+  }
+  return result({ echoed, dropped });
+}
+
+/**
+ * One reply read as a job's [out] reads it, and every modifier applied, as
+ * a one-stage run would: the items it keeps, what the modifiers dropped and
+ * why, how many repeated [instruction], and why it was thrown away, if it
+ * was. The same code as runPipeline, without a transport -- what a check or
+ * the page asks when it wants to know what a configuration makes of a reply.
+ */
+function readList(reply        , out     , instruction = "") 
+                                                                                  {
+  const reader = OUTPUT_KINDS[out.kind];
+  if (!reader) return { items: [], dropped: [], echoed: 0, error: `"${out.kind}" is not an output kind this lab has` };
+  const { kind, modifiers, ...settings } = out;
+  const read = reader.read(reply, { echo: instruction, settings });
+  if (read.error) return { items: [], dropped: [], echoed: 0, error: read.error };
+  const mod = applyModifiers(modifiers, kind, read.value, { instruction, body: read.body ?? reply });
+  const items = reader.terms ? reader.terms(mod.value) : [];
+  return {
+    items: mod.reject ? [] : items, dropped: mod.dropped,
+    echoed: mod.dropped.filter(d => d.by === ECHO).length,
+    error: mod.reject ? `discarded: ${mod.reject}` : null,
+  };
+}
+
+/** A value through a list of modifiers, in order, each one that accepts its
+    kind: the value they leave, what they removed, and the first rejection. A
+    rejection ends the list -- nothing after it is asked about an answer that
+    was thrown away. */
+function applyModifiers   (list                                 , kind        , value   ,
+                           ctx              = { instruction: "", body: "" })                                              {
+  let v = value;
+  const dropped            = [];
+  for (const m of list || []) {
+    const entry = MODIFIERS[m.type];
+    if (!entry || (entry.accepts && !entry.accepts.includes(kind))) continue;
+    const out = entry.apply(v, m, ctx)                          ;
+    const outcome = out && typeof out === "object" && !Array.isArray(out) && "value" in (out          )
+      ? out                       : null;
+    if (!outcome) { v = out     ; continue; }
+    v = outcome.value;
+    dropped.push(...(outcome.dropped || []));
+    if (outcome.reject) return { value: v, dropped, reject: outcome.reject };
+  }
+  return { value: v, dropped };
+}
+
+// ---- The pipeline model ----------------------------------------------------
+// docs/pipeline-model.md. One document describes a run for the page, the
+// queue and run-evals.js alike, and every one of them reads it through the
+// functions below rather than through a translation of its own.
+//
+// The lab is generic, so what a reply is, what a test scores and how a value
+// is changed are registry entries. The ones here are the lab's own, and so
+// are kinds/list.ts's -- the List kind and its modifiers. A dataset
+// registers nothing: it is data a graded test names by id, and a run carries.
+
+// 2: a job's mappings are a list of { name, type, … } (tokenMappings), where
+// version 1 kept them as two maps (tokens: { values, blocks }).
+// 3: the version-2 list kind is gone; a job that answered in it answers
+// as a `list` with the modifiers that read a reply exactly as it did, and
+// its token is {items} (docs/design/generic-lab.md §3.1).
+// 4: every scenario has an id, and a cell may name the Prompt library prompt
+// it was picked from (docs/pipeline-model.md §14).
+// 5: the pipeline and every job have an id, minted for an older document by
+// position (docs/pipeline-model.md §7, #93); version 4's ids are kept.
+// 6: `tests` is an ordered list, each test with an id, a name and
+// continueOnFailure, where version 5 held one test or null (#98).
+// 7: `chains` are `jobs`: the field renames and each job's `type` is "job".
+// 8: a job is its steps -- job 1's Attach Content (the pipeline's content), a
+// Call (Prompt: the image flag and token mappings), Read Reply (the output).
+// 9: a test is Metrics. A Single Test and a Graded set are read as the Metrics
+// they convert to (LEGACY_TESTS' toMetrics, proven equal by
+// metrics-parity-check.js).
+const PIPELINE_VERSION = 9         ;
+
+// Plain objects, so an entry is added by assignment and a reader never needs
+// to know which registered it.
+const STEP_TYPES                                = Object.create(null);
+const CONTENT_TYPES                                   = Object.create(null);
+const OUTPUT_KINDS                                  = Object.create(null);
+const MODIFIERS                                = Object.create(null);
+const TEST_TYPES                                = Object.create(null);
+const METRICS                              = Object.create(null);
+const SOURCE_TYPES                                  = Object.create(null);
+
+// The type a Source that names none is: every Source was one before types.
+const DEFAULT_SOURCE_TYPE = "files";
+const sourceTypeOf = (src                                       )                              =>
+  SOURCE_TYPES[isStr(src?.type) ? src .type : DEFAULT_SOURCE_TYPE];
+
+// The kind a stage that names none answers in.
+let defaultOutputKind = "text";
+const defaultKind = () => defaultOutputKind;
+const kindOf = (st                               )         => st.kind ?? defaultOutputKind;
+
+/** A module's entries into the registries, in one call. */
+function registerKinds(k       )       {
+  Object.assign(OUTPUT_KINDS, k.outputKinds || {});
+  Object.assign(MODIFIERS, k.modifiers || {});
+  Object.assign(TEST_TYPES, k.testTypes || {});
+  Object.assign(SOURCE_TYPES, k.sourceTypes || {});
+  Object.assign(METRICS, k.metrics || {});
+  if (k.defaultKind) defaultOutputKind = k.defaultKind;
+}
+
+/**
+ * What a plugin's `register(lab)` is handed (plugin-api.d.ts): the same
+ * registries the lab's own kinds go into, and nothing else. An id the lab
+ * already has is refused, naming the plugin, rather than quietly replacing
+ * what every run of it is read by.
+ */
+                             
+                                                                                     
+                     
+                                                                          
+                                                                         
+                                                     
+                                                  
+ 
+
+function pluginHost(pluginId        )             {
+  const taken = (table                         , what        , ids          ) => {
+    const dup = ids.find(id => id in table);
+    if (dup) throw new Error(`the plugin ${pluginId} registers the ${what} ${dup}, which the lab has already`);
+  };
+  return {
+    labVersion: PIPELINE_VERSION,
+    registerKinds(k) {
+      taken(OUTPUT_KINDS, "output kind", Object.keys(k.outputKinds || {}));
+      taken(MODIFIERS, "modifier", Object.keys(k.modifiers || {}));
+      taken(TEST_TYPES, "test type", Object.keys(k.testTypes || {}));
+      taken(METRICS, "metric", Object.keys(k.metrics || {}));
+      // The server keeps its own copy of the Source types, to refuse a row of
+      // one it does not know, and a plugin never reaches the server's code.
+      if (Object.keys((k         ).sourceTypes || {}).length) {
+        throw new Error(`the plugin ${pluginId} registers a Source type, which only the lab can`);
+      }
+      // A plugin adds what the lab lacks; the kind a new job answers in is the lab's.
+      const { defaultKind: _lab, ...added } = k;
+      registerKinds(added);
+    },
+    registerConnectionType(t) {
+      taken(CONNECTION_TYPES, "connection type", [t.id]);
+      CONNECTION_TYPES[t.id] = t;
+    },
+  };
+}
+
+const isObj = (v         )                                 => v != null && typeof v === "object" && !Array.isArray(v);
+const isStr = (v         )              => typeof v === "string";
+const clone =    (v   )    => JSON.parse(JSON.stringify(v));
+
+// A reply read as itself: anything at all, handed on untouched.
+OUTPUT_KINDS.text = {
+  label: "Plain text", noun: "text", offers: [],
+  description: "Keeps the reply as it came back, whole.",
+  read: reply => ({ value: String(reply ?? "") }),
+  handsOn: (value        ) => (value.trim() ? null : "empty reply"),
+}                                                     ;
+
+// ---- the connection a profile reference resolves to ------------------------
+// What a run carries of a Setup profile: everything a request needs and never
+// the key. A key follows the profile's id into $EVAL_API_KEY_<ID>, which the
+// server sets from its profiles store and the runner reads, so a name is only
+// a label and two profiles can share one. #46: the profile carries `type`,
+// and the run's resolved copy carries it too (docs/pipeline-model.md §7).
+const CONNECTION_FIELDS                    = ["name", "url", "model", "type", "temperature",
+                           "px", "format", "quality", "options"];
+const SETTING_KEYS = [...new Set(Object.values(CONNECTION_TYPES).flatMap(t => t.settings.map(s => s.key)))];
+const OPTION_FIELDS = ["seed", "nPredict", ...DECODING_KEYS];
+const IMAGE_FORMATS                    = ["image/jpeg", "image/webp", "image/png"];
+// Ids are what a key variable is spelled from, so they stay spellable: a
+// letter or digit run, with at most one hyphen.
+const PROFILE_ID = /^[A-Za-z0-9]+(?:-[A-Za-z0-9]+)?$/;
+const LOOKS_LIKE_A_KEY = /^(?:api[-_]?)?key$|^(?:authorization|bearer|secret|password|token)$/i;
+
+/** The variable a profile's key is read from: pm1x8k2q is EVAL_API_KEY_PM1X8K2Q. */
+const keyVar = (id        )         => "EVAL_API_KEY_"
+  + String(id).toUpperCase().replace(/[^A-Z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+
+/** A stored profile as a run carries it: its request settings, no key. */
+function connectionOf(p         )             {
+  const type = typeOf(p);
+  const settings = CONNECTION_TYPES[type] .settings.map(s => s.key);
+  const options                            = {};
+  // temperature is a common field, carried at the top like px/format/quality;
+  // the options bag holds the type's own settings only.
+  for (const k of settings) if (k !== "temperature" && String(p[k] ?? "").trim()) options[k] = p[k];
+  const out             = { name: p.name || "unnamed", url: p.url || "", model: p.model || "", type };
+  for (const k of ["px", "format", "quality"]         ) if (p[k] != null && p[k] !== "") out[k] = p[k]             ;
+  if (String(p.temperature ?? "").trim()) out.temperature = p.temperature                   ;
+  if (Object.keys(options).length) out.options = options;
+  return out;
+}
+
+/** A run's connection as one flat set of settings, the shape a profile has. */
+function connectionSettings(c                             )           {
+  const { options, ...rest } = c || {};
+  return { ...rest, ...(options                         || {}) };
+}
+
+// The rest of what a connection's fields mean lives in the connection-type
+// registry above (#46): the runner asks a type how to build a request and how
+// to read a reply, and validation asks connectionProblems (below, with the run
+// document's other rules). A change to a connection's shape is a change to the
+// registry and to connectionProblems, not to anything that calls them.
+
+/** How [conn] prepares an image: its budget, encoding and quality, null where unset. */
+function connectionImage(conn                             )                                                                         {
+  const px = conn?.px === EDGE_448 ? EDGE_448 : (Number(conn?.px) > 0 ? Number(conn .px) : null);
+  const format = IMAGE_FORMATS.includes(conn?.format          ) ? conn .format           : "image/jpeg";
+  const quality = conn?.quality != null && Number(conn.quality) > 0 ? Number(conn.quality) : null;
+  return { px, format, quality };
+}
+
+/**
+ * A profile's quality on the encoder's scale. A profile states it the way the
+ * page's canvas took it, 0 to 1 -- 0.9, and 1 for the best -- while the
+ * runner encodes with ImageMagick, whose scale is 1 to 100 and which ignores
+ * anything under 1. Handed across unscaled, every quality a profile set was
+ * silently dropped for the default, and 1, the best, became ImageMagick's
+ * worst. A value already above 1 is taken as that scale already; none is 92,
+ * the quality the container bakes its own copies at.
+ */
+function encoderQuality(quality               )         {
+  if (quality == null || !(quality > 0)) return 92;
+  return Math.round(quality <= 1 ? quality * 100 : Math.min(quality, 100));
+}
+
+// ---- labels -----------------------------------------------------------------
+// A name is optional everywhere; a blank one is the number the canvas has
+// always shown, so a sentence names what the reader sees.
+const jobLabel = (doc                                         , k        )         =>
+  (doc.jobs?.[k]?.name || "").trim() || `Job ${k + 1}`;
+const scenarioLabel = (doc                                              , i        )         =>
+  (doc.scenarios?.[i]?.name || "").trim() || `Scenario ${i + 1}`;
+// The runner calls a job's link a stage; the model calls it a job.
+const jobWords = (s        )         => s && String(s).replace(/\bstage[ ](\d+)/g, "job $1");
+
+// ---- the steps --------------------------------------------------------------
+
+/** Every field of [obj] not in [allowed], as a sentence -- a key by name. */
+function onlyFields(obj        , at        , allowed                   , bad          , keyFrom         )       {
+  for (const k of Object.keys(obj)) {
+    if (allowed.includes(k)) continue;
+    bad.push(LOOKS_LIKE_A_KEY.test(k)
+      ? `${at} carries "${k}", and a key never goes in a pipeline — $${keyFrom || "EVAL_API_KEY_<ID>"} supplies it`
+      : `${at} has "${k}", which is not a pipeline field`);
+  }
+}
+
+// A Source is referenced, with the two numbers that decide how many items a
+// run over it is: the first N files, and how many times over.
+// A folder of files: images sent as images, text files as {text}. The
+// extensions are server.py's FILE_TYPES, which the server holds uploads to.
+const FILE_LIBRARY_TEXT = [".txt", ".md", ".csv"]         ;
+SOURCE_TYPES.files = {
+  label: "File Library",
+  description: "A folder of images and text files you upload.",
+  noun: "file",
+  uploads: [".jpg", ".jpeg", ".png", ".heic", ".heif", ".dng", ".tif", ".tiff", ...FILE_LIBRARY_TEXT],
+  sendsImage: true,
+  itemText: name => FILE_LIBRARY_TEXT.some(ext => name.toLowerCase().endsWith(ext)),
+};
+
+// A Power Automate cloud flow (docs/power-automate.md): its items are
+// records -- one call of a Power Automate step each: what its template read,
+// the request production sent and what came back (flows/record.ts) -- and it
+// keeps the flow's definition beside them. Records are imported from run
+// history, written by hand or uploaded; nothing it holds is an image.
+SOURCE_TYPES["power-automate"] = {
+  label: "Power Automate workflow",
+  description: "A cloud flow read from Microsoft 365, with records of its steps' calls from its run history.",
+  noun: "record",
+  uploads: [".json"],
+  sendsImage: false,
+  itemText: () => false,
+};
+
+CONTENT_TYPES.source = {
+  label: "Source",
+  description: "Every file or record in a Source from the Library.",
+  fields: ["type", "ref", "first", "loops"],
+  runFields: ["files", "revs"],
+  validate(c, ctx, bad){
+    if (!isRef(c.ref)) return void bad.push("a Source content has to name its Source as { id, name }");
+    if (c.first != null && !(Number.isInteger(c.first) && c.first > 0)) {
+      bad.push("Run first wants a positive number, or empty for all");
+    }
+    if (c.loops != null && !(Number.isInteger(c.loops) && c.loops >= 1)) {
+      bad.push("Loop wants a whole number of times, 1 or more");
+    }
+    if (ctx.run && (!Array.isArray(c.files) || !c.files.every(isStr))) {
+      bad.push("a run's content.files has to be a list of file names");
+    }
+    if (ctx.run && c.revs != null && !(isObj(c.revs) && Object.values(c.revs).every(isStr))) {
+      bad.push("a run's content.revs has to map file names to revisions");
+    }
+    if (ctx.sources) {
+      const src = ctx.sources(c.ref.id);
+      if (!src) bad.push(`Source ${c.ref.name || c.ref.id} not found`);
+      else if (!(src.files || []).length) {
+        bad.push(`${src.name || c.ref.name} has no ${sourceTypeOf(src)?.noun ?? "item"}s`);
+      }
+    }
+  },
+  // What a stage's {text} can be: a Source's text files join there, one item
+  // each (run-evals.js's file-type registry), so {text} is asked for fairly
+  // unless the files are known and none is text. Null is "none".
+  text(c, ctx){
+    const src = ctx.sources?.(c.ref?.id);
+    const names            = src ? (src.files || []).map(f => (f                             )?.name ?? f) : (c.files || []);
+    if (!names.length) return "";
+    const type = sourceTypeOf(src);
+    return type && names.some(n => type.itemText(String(n))) ? "" : null;
+  },
+  // The Source's files, limited to the first N and looped, in order and with
+  // their repeats -- the list the runner, the server and the page all count.
+  expand(c, files){
+    const limited = (files || []).slice(0, c.first != null && c.first > 0 ? c.first : undefined);
+    const out           = [];
+    for (let l = 0; l < Math.max(1, c.loops || 1); l++) out.push(...limited);
+    return out;
+  },
+};
+CONTENT_TYPES.text = {
+  label: "Text",
+  description: "One item: the text written here.",
+  inline: true,
+  fields: ["type", "text"],
+  runFields: [],
+  text: c => c.text,
+  validate(c, ctx, bad){
+    if (!isStr(c.text)) bad.push("a text content has to hold its text");
+    else if (!c.text.trim()) bad.push("the text content is empty");
+  },
+};
+
+// No item at all: one bare item, so a stage is sent its prompt alone -- a
+// model asked the prompt itself, or Echo answering with it, the prompt then
+// being the recorded reply.
+CONTENT_TYPES.prompt = {
+  label: "Prompt only",
+  description: "No item: each scenario's prompt is sent on its own.",
+  inline: true,
+  bare: true,
+  fields: ["type"],
+  runFields: [],
+  text: () => null,
+  validate(){},
+};
+
+const isRef = (r         )                                   => isObj(r) && isStr(r.id) && !!r.id && (r.name == null || isStr(r.name));
+
+// The whole-run assertion: every item's reply pooled, one verdict per
+// scenario. Any kind: a kind with no terms is matched as its replies.
+// ---- tests retired in version 9 ------------------------------------------------
+// The Single Test and the Graded set, as version 8 and earlier held them. They
+// are no longer test types -- a pipeline has one kind of check, Metrics -- but
+// every document that holds one is read with it converted (`toMetrics`,
+// through upgradePipeline), and metrics-parity-check.js still reads a run
+// both ways to prove the conversion changes nothing.
+const LEGACY_TESTS                                = Object.create(null);
+
+LEGACY_TESTS.single = {
+  label: "Single Test",
+  fields: ["type", "all", "any", "none", "parse", "exact", "length", "lengthOp", "count", "countOp"],
+  accepts: null,
+  defaults: () => ({ type: "single", all: [], any: [], none: [], parse: "csv", count: null,
+                     countOp: "exactly", exact: null, length: null, lengthOp: "exactly" }),
+  validate(t, ctx, bad){
+    for (const k of ["all", "any", "none"]) {
+      if (t[k] != null && !(Array.isArray(t[k]) && t[k].every(isStr))) bad.push(`the Single Test's ${k} has to be a list of strings`);
+    }
+    for (const k of ["length", "count"]) {
+      if (t[k] != null && !Number.isInteger(t[k])) bad.push(`the Single Test's ${k} has to be a whole number`);
+    }
+    if (t.parse != null && !["csv", "json", "xml"].includes(t.parse)) bad.push("the Single Test parses as csv, json or xml, or not at all");
+    if (t.countOp != null && !COUNT_OP_LABEL.has(t.countOp)) bad.push(`the Single Test's count is compared ${[...COUNT_OP_LABEL.keys()].join(", ")}`);
+    if (t.lengthOp != null && !LENGTH_OP_LABEL.has(t.lengthOp)) bad.push(`the Single Test's length is compared ${[...LENGTH_OP_LABEL.keys()].join(", ")}`);
+  },
+  // [ress] is one scenario's result per item, in order.
+  verdict(t, ress, kind){
+    const raws           = [], terms           = [];
+    for (const r of ress) {
+      if (!r) continue;
+      raws.push(r.transcript?.[r.transcript.length - 1]?.got ?? r.raw ?? "");
+      terms.push(...(r.terms || []));
+    }
+    const s = scoreSingle(t, terms, raws, !(kind != null && OUTPUT_KINDS[kind]?.terms));
+    return { pass: s.pass, detail: s.pass ? "all matched" : s.reasons.join(" · "), ran: raws.length, checks: s.checks };
+  },
+  rules(t){
+    return singleRules(t);
+  },
+};
+
+// A dataset's cases, scored item by item with scoreCase. The test
+// references the dataset the way a pipeline references a Source, and the run
+// carries the body it was submitted against. It scores the terms a value
+// yields, so it accepts every kind that yields any: plain text has none, and
+// would fail every case.
+LEGACY_TESTS.graded = {
+  label: "Graded set",
+  fields: ["type", "dataset"],
+  accepts: () => Object.keys(OUTPUT_KINDS).filter(k => OUTPUT_KINDS[k] .terms),
+  validate(t, ctx, bad){
+    const d = t.dataset;
+    if (!isRef(d) || (d.version != null && !isStr(d.version))) {
+      return void bad.push("a graded test has to name its dataset as { id, name }");
+    }
+    if (ctx.datasets && !ctx.datasets.some(x => x.id === d.id)) bad.push(`Dataset ${d.name || d.id} not found`);
+  },
+  score: (t, kase, res) => scoreCase(kase, res),
+};
+
+// Metrics: checks of each reply, deterministic or model-graded, from the
+// METRICS registry (metrics/builtin.ts registers the lab's own), with the
+// test's own list for every item and a case's `metrics` for its item. Scored
+// all-must-pass -- every metric passes -- or weighted: points, each metric's
+// score times its weight, against a threshold (#150's points, a negative
+// weight taking them away).
+// `of: "said"` reads the API's own text rather than the reply as the job read
+// it -- an HTTP Request's raw reply beside the flow's reading of it.
+const METRIC_FIELDS                    = ["type", "not", "weight", "metric", "of", "every"];
+const SCORING_MODES = ["all", "weighted"];
+
+/** What is wrong with a list of metrics, as sentences naming [at]. */
+function metricsProblems(list         , at        , bad          )       {
+  if (!Array.isArray(list)) return void bad.push(`${at}: metrics has to be a list`);
+  list.forEach((m           , x        ) => {
+    const where = `${at}, metric ${x + 1}`;
+    const entry = isObj(m) && METRICS[m.type];
+    if (!entry) return void bad.push(`${where} is of type "${m?.type}", which is not a metric this lab has`);
+    onlyFields(m, where, [...METRIC_FIELDS, ...entry.options.map(o => o.key)], bad);
+    if (m.not != null && typeof m.not !== "boolean") bad.push(`${where}: not has to be true or false`);
+    if (m.weight != null && typeof m.weight !== "number") bad.push(`${where}: weight has to be a number`);
+    if (m.metric != null && !isStr(m.metric)) bad.push(`${where}: metric names a group, as text`);
+    if (m.of != null && m.of !== "reply" && m.of !== "said") bad.push(`${where}: of is reply or said`);
+    if (m.every != null && typeof m.every !== "boolean") bad.push(`${where}: every has to be true or false`);
+    entry.validate?.(m          , `${where} (${entry.label})`, bad);
+  });
+}
+
+/** Whether any of [list] asks a grader. */
+const gradedIn = (list         )          => Array.isArray(list) && list.some((m           ) => !!METRICS[m?.type]?.graded);
+
+/** What a metric reads of one result. */
+function metricInput(res                    , kase             , more          )              {
+  const last = res.transcript?.at(-1);
+  const text = last?.got ?? res.raw ?? "";
+  return { text, said: last?.said ?? null, terms: res.terms ?? [], replies: [text], plain: !!more.plain,
+           error: res.error ?? null, ms: res.ms ?? 0, production: more.production ?? null, kase };
+}
+
+/** A whole run's replies as one input: every reply's text together, and
+    every item's terms pooled, as the Single Test pooled them. */
+function runInput(ress                                       , plain         )              {
+  const replies           = [], terms           = [];
+  let ms = 0;
+  for (const r of ress) {
+    if (!r) continue;
+    replies.push(r.transcript?.[r.transcript.length - 1]?.got ?? r.raw ?? "");
+    terms.push(...(r.terms || []));
+    ms += r.ms ?? 0;
+  }
+  return { text: replies.join("\n"), said: null, terms, replies, plain, error: null, ms, production: null, kase: null };
+}
+
+/** One metric's reading of [input]: `of`, `not` and a failure all applied,
+    or null where it has nothing to read. Synchronous where it can be -- a
+    whole run's verdict is read on every render -- and a promise otherwise. */
+function readMetric(m        , input             , ctx           )                                                       {
+  const entry = METRICS[m.type];
+  const weight = typeof m.weight === "number" ? m.weight : 1;
+  const label = (isStr(m.metric) && m.metric.trim()) || entry?.label || m.type;
+  if (!entry) return { type: m.type, label, weight, pass: false, score: 0, reason: `"${m.type}" is not a metric this lab has` };
+  const read = m.of === "said" ? { ...input, text: input.said ?? input.text } : input;
+  const done = (o                      )                       => {
+    if (!o) return null;
+    const turned = m.not ? { ...o, pass: !o.pass, score: entry.counts ? -o.score : 1 - o.score, reason: `not: ${o.reason}` } : o;
+    return { type: m.type, label, weight, ...turned };
+  };
+  const failed = (e         )                => ({ type: m.type, label, weight, pass: false, score: 0,
+                                                  reason: e instanceof Error ? e.message : String(e) });
+  // A grader's call is timed: a run counts its calls and their time.
+  const t0 = Date.now();
+  const timed = (r                      )                       =>
+    r && entry.graded && ctx.ask ? { ...r, asked: Date.now() - t0 } : r;
+  try {
+    const o = entry.score(read, m, ctx);
+    return o && typeof (o                    ).then === "function"
+      ? (o                                 ).then(done, failed).then(timed) : timed(done(o                        ));
+  } catch (e) { return timed(failed(e)); }
+}
+
+/** A test's score from its metrics' readings, the way [mode] says: all must
+    pass, or weighted points against [threshold]. What a case metric found,
+    missed and invented is carried up, for a run's totals. Null for none. */
+function scoreOf(metrics                 , mode = "all", threshold                = null)                     {
+  if (!metrics.length) return null;
+  const detail = metrics.some(r => r.found || r.missed || r.invented) ? {
+    found: metrics.flatMap(r => r.found ?? []), missed: metrics.flatMap(r => r.missed ?? []),
+    invented: metrics.flatMap(r => r.invented ?? []) } : {};
+  if (mode === "weighted") {
+    const points = metrics.reduce((sum, r) => sum + r.weight * r.score, 0);
+    return { pass: points >= (threshold ?? 0), score: points, points: true, metrics, ...detail };
+  }
+  const counted = metrics.filter(r => r.weight !== 0);
+  return { pass: counted.every(r => r.pass), score: counted.length ? counted.filter(r => r.pass).length / counted.length : null,
+           metrics, ...detail };
+}
+
+/** [list] read against one reply, scored the way [mode] says; null where no
+    metric had anything to read. */
+async function readMetrics(list                   , input             , ctx           ,
+                           mode = "all", threshold                = null)                              {
+  const metrics                  = [];
+  for (const m of list) {
+    const r = await readMetric(m, input, ctx);
+    if (r) metrics.push(r);
+  }
+  return scoreOf(metrics, mode, threshold);
+}
+
+/** [list] read over a whole run, synchronously: each metric over the run's
+    replies together, or -- `every` -- each reply alone, all of them passing. */
+function readRun(list                   , run             )                  {
+  const sync = (r                                                      , m        )                       =>
+    r && typeof (r                    ).then === "function"
+      ? { type: m.type, label: METRICS[m.type]?.label ?? m.type, weight: 1, pass: false, score: 0,
+          reason: "a model-graded metric cannot read a whole run" }
+      : r                        ;
+  return list.flatMap(m => {
+    if (!m.every) { const r = sync(readMetric(m, run, {}), m); return r ? [r] : []; }
+    const each = run.replies.map(text => sync(readMetric(m, { ...run, text, replies: [text] }, {}), m))
+      .filter((r)                     => !!r);
+    const off = each.filter(r => !r.pass);
+    const first = each[0];
+    if (!first) return [{ type: m.type, label: METRICS[m.type]?.label ?? m.type, weight: typeof m.weight === "number" ? m.weight : 1,
+                          pass: true, score: 1, reason: "no replies" }];
+    return [{ ...first, pass: !off.length, score: each.length ? (each.length - off.length) / each.length : 1,
+              reason: off.length ? `${off.length} of ${each.length} replies: ${off[0] .reason}` : `all ${each.length} replies` }];
+  });
+}
+
+TEST_TYPES.metrics = {
+  label: "Metrics",
+  description: "Checks of each reply, or of the whole run, scored all-must-pass or in weighted points.",
+  fields: ["type", "metrics", "mode", "threshold", "grader", "dataset", "over"],
+  // A metric that reads terms (a case) reads only a kind that yields them.
+  accepts: t => (Array.isArray(t.metrics) && t.metrics.some((m           ) => METRICS[m?.type]?.needsTerms)
+    ? Object.keys(OUTPUT_KINDS).filter(k => OUTPUT_KINDS[k] .terms) : null),
+  defaults: () => ({ type: "metrics", metrics: [], mode: "all", threshold: null, grader: null, dataset: null, over: "item" }),
+  validate(t, ctx, bad){
+    metricsProblems(t.metrics, "the Metrics", bad);
+    if (t.over != null && t.over !== "item" && t.over !== "run") bad.push("the Metrics read each item, or the whole run");
+    if (t.over === "run") {
+      const one = (Array.isArray(t.metrics) ? t.metrics : []).find((m           ) => METRICS[m?.type]?.graded || METRICS[m?.type]?.perItem);
+      if (one) bad.push(`${METRICS[one.type] .label} reads one item at a time, so it cannot read a whole run`);
+    }
+    // The dataset whose cases a case metric reads, and whose own metrics join.
+    if (t.dataset != null) {
+      if (!isRef(t.dataset) || (t.dataset.version != null && !isStr(t.dataset.version))) bad.push("the Metrics name their dataset as { id, name }");
+      else if (ctx.datasets && !ctx.datasets.some(x => x.id === t.dataset.id)) bad.push(`Dataset ${t.dataset.name || t.dataset.id} not found`);
+    }
+    if (!SCORING_MODES.includes(t.mode)) bad.push(`the Metrics are scored ${SCORING_MODES.join(" or ")}`);
+    if (t.mode === "weighted" && typeof t.threshold !== "number") bad.push("weighted Metrics need a threshold: the points an item has to reach");
+    if (t.threshold != null && typeof t.threshold !== "number") bad.push("the Metrics' threshold has to be a number");
+    if (t.grader != null && !isRef(t.grader)) bad.push("the Metrics name their grader as { id, name }");
+    // The test's own grader, or the lab's.
+    const grader = isRef(t.grader) ? t.grader : isRef(ctx.grader) ? ctx.grader : null;
+    if (gradedIn(t.metrics) && !grader) bad.push("a model-graded metric needs a grader: pick one on the test, or make a Setup profile the lab's grader");
+    // A grader is asked words, and needs a model to ask.
+    const p = grader && ctx.profiles ? ctx.profiles(grader.id) : null;
+    if (grader && ctx.profiles && !p) bad.push(`Setup profile ${grader.name || grader.id} not found`);
+    else if (p) {
+      const type = CONNECTION_TYPES[typeOf(p            )];
+      if (type && !(type.answers ?? ["prompt"]).includes("prompt")) bad.push(`the grader has to be asked words, and ${type.label} is not`);
+      else if (!type?.local && !String((p            ).model || "").trim()) bad.push("no model on the grader's Setup profile");
+    }
+  },
+  rules: t => (Array.isArray(t.metrics) ? t.metrics : []).map((m        , x        ) => ({
+    key: `m${x}`, label: (isStr(m.metric) && m.metric) || METRICS[m.type]?.label || m.type,
+    want: [m.not ? "not" : "", metricSummary(m), typeof m.weight === "number" && m.weight !== 1 ? `×${m.weight}` : ""]
+      .filter(Boolean).join(" ") })),
+  profiles: t => (isRef(t.grader) ? [t.grader] : []),
+  // A run carries the lab's grader on a test that names none and may ask one:
+  // a model-graded metric of its own, or a case's, over a dataset.
+  resolve: (t, ctx) => (!isRef(t.grader) && isRef(ctx.grader) && (gradedIn(t.metrics) || isRef(t.dataset))
+    ? { ...t, grader: { id: ctx.grader.id, name: ctx.grader.name } } : t),
+  wholeRun: t => t.over === "run",
+  // Over the whole run: every metric over the replies together, or each alone.
+  verdict(t, ress, kind){
+    const run = runInput(ress, !(kind != null && OUTPUT_KINDS[kind]?.terms));
+    const metrics = readRun(t.metrics || [], run);
+    const s = scoreOf(metrics, t.mode, t.threshold);
+    const off = metrics.filter(r => !r.pass);
+    return { pass: s ? s.pass : true, detail: off.length ? off.map(r => `${r.label}: ${r.reason}`).join(" · ") : "all matched",
+             ran: run.replies.length,
+             checks: metrics.map((r, x) => ({ key: `m${x}`, label: r.label, want: "", pass: r.pass, ...(r.pass ? {} : { note: r.reason }) })) };
+  },
+  // Rule m{x} is the test's own metric x, read in that place on every item.
+  // A score stored before Metrics -- a Graded set's, read as its conversion --
+  // has no readings of its own: its one metric's reading is the score's.
+  ruleOf: (score, key, t) => (score.metrics ? score.metrics[Number(key.slice(1))]?.pass ?? null
+    : Array.isArray(t?.metrics) && t.metrics.length === 1 ? score.pass : null),
+  // Every item, with its case's own metrics where it has a case.
+  read: async (t, kase, res, more) => (await readMetrics([...(t.metrics || []), ...((kase?.metrics                        ) || [])],
+    metricInput(res, kase, more), graderCtx(t, more), t.mode, t.threshold)),
+};
+
+// ---- the lab's own scorers, as metrics ----------------------------------------
+// What the Graded set and the Single Test check, one metric each, so a test of
+// either converts to Metrics that read a run exactly as it did
+// (metrics-parity-check.js). Here rather than in metrics/builtin.ts because
+// each is the core's own matcher.
+
+// An item's case, as the Graded set scores it: its expectations, forbidden
+// terms and count bounds, with what it found, missed and invented kept.
+METRICS.case = {
+  label: "Matches its case",
+  description: "Scores the reply against the item's case in the dataset: the items it expects, forbids and how many.",
+  perItem: true,
+  needsTerms: true,
+  options: [],
+  defaults: () => ({}),
+  score(input) {
+    if (!input.kase) return null;
+    const s = scoreCase(input.kase, { ...(input.error ? { error: input.error } : {}), terms: input.terms });
+    return { pass: s.pass, score: s.score ?? (s.pass ? 1 : 0), reason: s.reasons.join(" · ") || "all matched",
+             found: s.found, missed: s.missed, invented: s.invented };
+  },
+};
+
+// Items the reply holds -- all of them, or any -- matched as the lab matches
+// a term; a kind that yields none is matched in the replies' text instead,
+// ignoring case, as the Single Test did.
+METRICS["has-items"] = {
+  label: "Has items",
+  description: "Passes when the reply holds all, or any, of the items listed.",
+  options: [{ key: "values", label: "Items", type: "textarea" },
+            { key: "need", label: "Needs", type: "select", choices: [{ value: "all", label: "all" }, { value: "any", label: "any" }] }],
+  defaults: () => ({ values: "", need: "all" }),
+  score(input, m) {
+    const values = String(m.values ?? "").split("\n").map(v => v.trim()).filter(Boolean);
+    const has = (v        ) => input.plain ? input.replies.some(r => r.toLowerCase().includes(v.toLowerCase()))
+      : input.terms.some(t => termIn([t], v));
+    const hit = values.filter(has), missing = values.filter(v => !has(v));
+    const pass = m.need === "any" ? hit.length > 0 : !missing.length;
+    return { pass, score: values.length ? hit.length / values.length : 1,
+             reason: m.need === "any" ? (hit.length ? `has ${hit.join(", ")}` : `has none of ${values.join(", ")}`)
+               : missing.length ? `missed ${missing.join(", ")}` : `has ${values.join(", ")}` };
+  },
+};
+
+// A reply's length in characters, once trimmed.
+METRICS.length = {
+  label: "Length",
+  description: "Compares the reply's length in characters.",
+  options: [{ key: "op", label: "Is", type: "select", choices: LENGTH_OPS.map(([value, label]) => ({ value, label })) },
+            { key: "n", label: "Characters", type: "number" }],
+  defaults: () => ({ op: "exactly", n: 0 }),
+  score(input, m) {
+    const got = input.text.trim().length;
+    const pass = lengthHolds(String(m.op || "exactly"), got, Number(m.n));
+    return { pass, score: pass ? 1 : 0, reason: `${got} characters` };
+  },
+};
+
+// A reply read as CSV, JSON or XML: it has to read, and hold as many results
+// as the count says.
+METRICS["parse-count"] = {
+  label: "Parses",
+  description: "Passes when the reply reads as the format chosen, holding the number of results set.",
+  // Unformatted is one result a reply, as the Single Test counted it.
+  options: [{ key: "parse", label: "As", type: "select", choices: [{ value: "", label: "Unformatted" }, { value: "csv", label: "csv" },
+                                                                    { value: "json", label: "json" }, { value: "xml", label: "xml" }] },
+            { key: "countOp", label: "Count is", type: "select", choices: COUNT_OPS.map(([value, label]) => ({ value, label })) },
+            { key: "count", label: "Count", type: "number" }],
+  defaults: () => ({ parse: "json", countOp: "exactly", count: null }),
+  score(input, m) {
+    const pc = parseCount(input.text, (m.parse          ) || null);
+    if (!pc.valid) return { pass: false, score: 0, reason: `invalid ${m.parse}` };
+    const count = m.count == null || m.count === "" ? null : Number(m.count);
+    if (count != null && !countHolds(String(m.countOp || "exactly"), pc.count, count)) {
+      return { pass: false, score: 0, reason: `${pc.count} results` };
+    }
+    return { pass: true, score: 1, reason: pc.count == null ? `reads as ${m.parse}` : `${pc.count} results` };
+  },
+};
+
+/** What every test carries, kept across a conversion. */
+const common = (t           ) => ({ id: t.id, name: t.name ?? "", continueOnFailure: t.continueOnFailure !== false });
+
+// A Graded set is a Metrics test over the same dataset, its one metric the case.
+LEGACY_TESTS.graded .toMetrics = t => ({ ...common(t), type: "metrics", mode: "all", threshold: null, grader: null,
+  dataset: t.dataset, over: "item", metrics: [{ type: "case" }] });
+
+// A Single Test is Metrics over the whole run: its lists over the run's items
+// together, and exact, length and parse over each reply alone.
+LEGACY_TESTS.single .toMetrics = t => {
+  const list = (v         ) => (Array.isArray(v) ? v : []).map(String).filter(x => x.trim()).join("\n");
+  const metrics           = [];
+  if (list(t.all)) metrics.push({ type: "has-items", values: list(t.all), need: "all" });
+  if (list(t.any)) metrics.push({ type: "has-items", values: list(t.any), need: "any" });
+  if (list(t.none)) metrics.push({ type: "has-items", values: list(t.none), need: "any", not: true });
+  if (t.exact != null && String(t.exact).trim() !== "") metrics.push({ type: "equals", value: String(t.exact), json: false, every: true });
+  if (t.length != null) metrics.push({ type: "length", op: t.lengthOp || "exactly", n: t.length, every: true });
+  if (t.parse === "json" || t.parse === "xml" || t.count != null) {
+    metrics.push({ type: "parse-count", parse: t.parse ?? "", countOp: t.countOp || "exactly", count: t.count ?? null, every: true });
+  }
+  return { ...common(t), type: "metrics", mode: "all", threshold: null, grader: null, dataset: null, over: "run", metrics };
+};
+
+/** The grader a Metrics test names, reached through what the runner hands it. */
+function graderCtx(t           , more          )            {
+  const ask = isRef(t.grader) ? more.grader?.(t.grader) : undefined;
+  return ask ? { ask } : {};
+}
+
+/** A metric's options in a few words -- "watering", "^\\{" -- or nothing
+    for one with none set: what History prints beside its name. */
+function metricSummary(m        )         {
+  const entry = METRICS[m.type];
+  // Each option as it reads in the editor: a choice's label, a box that is
+  // ticked by its own label, text by its first line.
+  const said = (entry?.options || []).map(o => {
+    const v = m[o.key];
+    if (o.type === "select") return o.choices.find(c => c.value === v)?.label ?? "";
+    if (o.type === "checkbox") return v ? o.label.toLowerCase() : "";
+    // Text that runs to lines (a schema) reads as its first words, run together.
+    return v == null || isObj(v) ? "" : String(v).replace(/\s+/g, " ").trim().slice(0, 40);
+  }).filter(Boolean);
+  return said.join(", ");
+}
+
+// ---- a job's steps (pipeline-model §3) -------------------------------------
+
+// Attach Content: the items a run goes over, job 1's first step.
+STEP_TYPES.attachContent = {
+  label: "Attach Content", slot: "content",
+  description: "The items the run goes through: each is sent to every scenario.",
+  in: null, out: "items",
+  apply: "itemContent",   // run-evals.js, through its file-type registry
+  fields: ["type", "content"],
+  validate(step, ctx, bad){
+    const c = step?.content;
+    if (!c) return void bad.push("set the content first");
+    const type = isObj(c) && CONTENT_TYPES[c.type];
+    if (!type) return void bad.push(`content of type "${c?.type}" is not one this lab has`);
+    onlyFields(c, "the content", ctx.run ? [...type.fields, ...type.runFields] : type.fields, bad);
+    type.validate(c, ctx, bad);
+  },
+};
+
+// Prompt: a Call that sends each scenario's words to its model.
+STEP_TYPES.prompt = {
+  label: "Prompt", slot: "call", asks: "prompt", modelFrom: "profile",
+  description: "Asks each scenario's model its prompt about the item.",
+  in: "item", out: "text",
+  apply: "runPipeline",
+  fields: ["type", "withImage", "tokenMappings"],
+  validate(step, _ctx, bad, at){
+    if (typeof step.withImage !== "boolean") bad.push(`${at}: withImage has to be true or false`);
+    tokenMappingsProblems(step.tokenMappings, at, bad);
+  },
+};
+
+// HTTP Request: a Call that sends a Power Automate step's own request,
+// rebuilt for each item from its record (docs/power-automate.md).
+const HTTP_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE"];
+/** The first field under [v] named like a key, as a path, or null. */
+function keyField(v         , at = "body")                {
+  if (Array.isArray(v)) {
+    for (let i = 0; i < v.length; i++) { const hit = keyField(v[i], `${at}[${i}]`); if (hit) return hit; }
+  } else if (isObj(v)) {
+    for (const [k, x] of Object.entries(v)) {
+      if (LOOKS_LIKE_A_KEY.test(k) || /^(?:api[-_]?key|access[-_]?token|client[-_]?secret)$/i.test(k)) return `${at}.${k}`;
+      const hit = keyField(x, `${at}.${k}`);
+      if (hit) return hit;
+    }
+  }
+  return null;
+}
+STEP_TYPES.httpRequest = {
+  label: "HTTP Request", slot: "call", asks: "request", verbatim: true, modelFrom: "cell",
+  description: "Sends a Power Automate step's own request, rebuilt from each record, with each scenario's words in it.",
+  cellFields: ["system", "model", "settings", "prefill"],
+  firstJobOnly: "an HTTP Request is sent from its item's record, so it is job 1's call",
+  // Production's reply is the record's result, read as the flow reads it.
+  production(call, record){
+    const result = isObj(record) && isObj(record.result) ? record.result : null;
+    if (!result || typeof result.status !== "number") return null;
+    try {
+      return httpReplyOf(call, { prompt: "" }, result.body, result.status,
+                         { scope: record.scope || {}, now: record.at ?? null }).raw;
+    } catch { return null; }
+  },
+  // A new scenario starts from the flow's own words and fields.
+  newCell: (call) => (HTTP_APIS[call.api] ?? HTTP_APIS.raw ).cellOf(call.body),
+  // A cell's fields, where its HTTP API has a place for them.
+  cellProblems(cell, call, at, bad){
+    const api = HTTP_APIS[call.api];
+    if (!api) return;
+    for (const f of ["system", "model", "prefill"]         ) {
+      if (cell[f] == null) continue;
+      if (!isStr(cell[f])) bad.push(`${at}: ${f} has to be text`);
+      else if (!api.fields.includes(f)) bad.push(`${at}: ${api.label} has no place for a ${f}`);
+    }
+    if (cell.settings != null) {
+      if (!isObj(cell.settings) || !Object.values(cell.settings).every(isStr)) bad.push(`${at}: settings are names to text`);
+      else for (const k of Object.keys(cell.settings)) {
+        if (!api.settings.includes(k)) bad.push(`${at}: ${api.label} has no setting ${k}`);
+      }
+    }
+    if (isStr(cell.prompt)) {
+      try { api.place(call.body, cell        ); }
+      catch (e) { bad.push(`${at}: ${(e         ).message}`); }
+    }
+  },
+  in: "item", out: "text",
+  apply: "runPipeline",
+  fields: ["type", "step", "api", "method", "path", "query", "body", "readAs", "loop"],
+  validate(step, _ctx, bad, at){
+    if (!isStr(step.step) || !step.step.trim()) bad.push(`${at}: an HTTP Request names the flow step it is`);
+    if (!HTTP_APIS[step.api]) bad.push(`${at}: "${step.api}" is not an HTTP API this lab has`);
+    if (!HTTP_METHODS.includes(step.method)) bad.push(`${at}: the method is one of ${HTTP_METHODS.join(", ")}`);
+    if (!isStr(step.path) || !/^[/@]/.test(step.path)) bad.push(`${at}: the path starts with /`);
+    if (!isObj(step.query) || !Object.values(step.query).every(isStr)) bad.push(`${at}: the query is names to text`);
+    if (step.readAs != null && !isStr(step.readAs)) bad.push(`${at}: readAs is an expression or null`);
+    if (step.loop != null && !isStr(step.loop)) bad.push(`${at}: loop names a loop or is null`);
+    // A key is the Setup profile's, sent by its Key header; one in the
+    // template would be kept in the pipeline and every run of it.
+    const hit = keyField(step.body) ?? keyField(step.query, "query");
+    if (hit) bad.push(`${at} carries a key at ${hit}, and a key never goes in a pipeline -- the Setup profile sends it`);
+  },
+};
+
+// Read Reply: how a job's answer is read -- its kind and modifiers.
+STEP_TYPES.readReply = {
+  label: "Read Reply", slot: "reply",
+  description: "How the reply is read before tests and later jobs see it.",
+  in: "text", out: step => step.out?.kind,
+  // Read inside the stage: runPipeline parses each reply as it comes back.
+  apply: "runPipeline",
+  fields: ["type", "out"],
+  validate(step, _ctx, bad, at){
+    const out = step.out;
+    if (!isObj(out) || !OUTPUT_KINDS[out.kind]) {
+      return void bad.push(`${at} answers as "${out?.kind}", which is not an output kind this lab has`);
+    }
+    const kindEntry = OUTPUT_KINDS[out.kind] ;
+    onlyFields(out, `${at}'s output`, ["kind", "modifiers", ...(kindEntry.settings || []).map(o => o.key)], bad);
+    kindEntry.validateSettings?.(out, `${at}'s output`, bad);
+    if (!Array.isArray(out.modifiers)) return void bad.push(`${at}: modifiers has to be a list`);
+    for (const m of out.modifiers) {
+      const entry = isObj(m) && MODIFIERS[m.type];
+      if (!entry) { bad.push(`${at}: "${m?.type}" is not a modifier this lab has`); continue; }
+      if (entry.accepts && !entry.accepts.includes(out.kind)) {
+        bad.push(`${at}: ${entry.label || m.type} does not apply to ${OUTPUT_KINDS[out.kind] .noun || out.kind}`);
+      }
+      entry.validate?.(m            , `${at}: ${entry.label || m.type}`, bad);
+    }
+  },
+};
+
+// ---- reading a job's steps ---------------------------------------------------
+// Every reader asks these, never a step's position: a job's slots are fixed,
+// but which of them a job has (Attach Content is job 1's alone) is its own.
+
+const slotOf = (st         )                       =>
+  (isObj(st) ? STEP_TYPES[st.type          ]?.slot : undefined);
+
+/** The step in [job]'s [slot], whatever type fills it. */
+const stepIn =                 (job                                                , slot          )                =>
+  (job?.steps || []).find(st => slotOf(st) === slot)                 ;
+
+/** The registry entry that fills [slot] by default: what a new step there is. */
+function slotEntry(slot          )                                                     {
+  const hit = Object.entries(STEP_TYPES).find(([, e]) => e.slot === slot);
+  return hit ? { type: hit[0], entry: hit[1] } : undefined;
+}
+
+/** A pipeline's content: job 1's content step, or none. */
+function contentOf(doc                                              )                 {
+  return stepIn                   (doc?.jobs?.[0], "content")?.content ?? null;
+}
+
+/** [doc] with its content set -- job 1's content step added, replaced, or
+    taken away for null. */
+function withContent                           (doc   , content                )    {
+  const [first, ...rest] = doc.jobs;
+  if (!first) return doc;
+  const steps = first.steps.filter(st => slotOf(st) !== "content");
+  const type = slotEntry("content") .type;
+  return { ...doc, jobs: [{ ...first, steps: content ? [{ type, content }        , ...steps] : steps }, ...rest] };
+}
+
+/** A job's call: the step that asks something and is answered. */
+const callOf = (job                                                )             =>
+  stepIn            (job, "call")              ;
+
+/** The registry entry of a job's call: what it asks, and of whom. */
+const callEntryOf = (job                                                )                            =>
+  STEP_TYPES[(stepIn(job, "call")                    )?.type ?? ""];
+
+/** The request an HTTP Request [step] sends for [cell] over an item whose
+    record read [ctx]'s scope: the cell's words and fields placed in the
+    flow's body by its HTTP API, then every expression evaluated. */
+function httpRequestOf(step                 , cell      , ctx                          ) 
+                                                                                   {
+  const api = HTTP_APIS[step.api] ?? HTTP_APIS.raw ;
+  const at = { ...ctx, loop: step.loop };
+  const path = String(evaluate(step.path, at));
+  // A path an expression wrote whole -- an address -- keeps its path and query.
+  const [p, q] = /^https?:\/\//i.test(path) ? (() => { const u = new URL(path); return [u.pathname, u.search]; })() : [path, ""];
+  const query = Object.fromEntries(Object.entries(step.query).map(([k, v]) => [k, asText(evaluate(v, at))]));
+  return { method: step.method, path: p + q, query, body: evaluate(api.place(step.body, cell), at) };
+}
+
+/** What the flow reads of a reply [j] to [step]: its readAs evaluated with the
+    reply as the step's body -- the prefill put back in front, as the flow has
+    to -- or the HTTP API's own text. */
+function httpReplyOf(step                 , cell      , j         , status        ,
+                     ctx                          )                                                             {
+  const api = HTTP_APIS[step.api] ?? HTTP_APIS.raw ;
+  const whole = cell.prefill && api.withPrefill ? api.withPrefill(j, cell.prefill) : j;
+  const { raw: said, finishReason } = api.reply(whole);
+  if (!step.readAs) return { raw: said, said, finishReason };
+  const scope = { ...ctx.scope, actions: { ...(ctx.scope.actions || {}), [step.step]: { body: whole, statusCode: status } } };
+  return { raw: asText(evaluate(step.readAs, { ...ctx, scope, loop: step.loop })), said, finishReason };
+}
+
+/** A job's reply step. */
+const replyOf = (job                                                )                =>
+  stepIn               (job, "reply")                 ;
+
+/** How a job's reply is read: its kind, settings and modifiers. */
+const outOf = (job                                                )      => replyOf(job)?.out;
+
+/** [job] with the step in [slot] changed by [change]. */
+function withSlot(job     , slot          , change                    )      {
+  return { ...job, steps: job.steps.map(st => (slotOf(st) === slot ? change(st) : st)) };
+}
+
+/** [job] reading its reply as [out]. */
+const withOut = (job     , out     )      => withSlot(job, "reply", st => ({ ...st, out }        ));
+
+/** [job] with its call changed by [patch]. */
+const withCall = (job     , patch                     )      => withSlot(job, "call", st => ({ ...st, ...patch }        ));
+/** A new id: random, so one minted in one browser never collides with one
+    minted in another. A pipeline, its jobs and its scenarios each carry one
+    (#93), minted once and never shown. */
+function newId()         {
+  const bytes = new Uint8Array(6);
+  globalThis.crypto.getRandomValues(bytes);
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+/** A new job: the kind a stage answers in, that kind's own modifiers, and
+    a copy of the token set. */
+function jobDefaults(kind         = defaultOutputKind, tokens                = TOKEN_DEFAULTS)      {
+  return {
+    type: "job", id: newId(), name: "",
+    steps: [
+      { type: "prompt", withImage: false, tokenMappings: clone(tokens) },
+      { type: "readReply",
+        out: { kind, ...(OUTPUT_KINDS[kind]?.settingDefaults?.() || {}), modifiers: OUTPUT_KINDS[kind]?.modifiers?.() || [] } },
+    ],
+  };
+}
+STEP_TYPES.job = {
+  in: "item", out: job => outOf(job         )?.kind,
+  apply: "runPipeline",
+  fields: ["type", "id", "name", "steps"],
+  defaults: jobDefaults,
+  // A job's steps sit in fixed slots: Attach Content first, on job 1 only;
+  // one Call; Read Reply last. Each step is its entry's to check.
+  validate(c, ctx, bad, k, doc){
+    const at = jobLabel(doc, k);
+    if (!isObj(c) || c.type !== "job") return void bad.push(`${at} has to be a job step`);
+    onlyFields(c, at, STEP_TYPES.job .fields , bad);
+    // An id is a job's own, like a scenario's: stable across renames, so a
+    // stored run keeps pointing at the job that actually ran (#93).
+    if (!isStr(c.id) || !c.id.trim()) bad.push(`${at} has no id`);
+    else if ((doc.jobs               ).findIndex((o) => isObj(o) && o.id === c.id) !== k) bad.push(`${at} has the id of another job`);
+    if (c.name != null && !isStr(c.name)) bad.push(`${at}: name has to be text`);
+    if (!Array.isArray(c.steps)) return void bad.push(`${at}: steps has to be a list`);
+    const steps              = c.steps;
+    // A job's steps are the entries with a slot; one without (a job, the
+    // tests) or of no type the lab has is not one.
+    const unknown = steps.find(st => !slotOf(st));
+    if (unknown) return void bad.push(`${at}: "${isObj(unknown) ? unknown.type : unknown}" is not a step this lab has`);
+    const slots = steps.map(st => slotOf(st) );
+    const want             = [...(k === 0 && slots[0] === "content" ? ["content"            ] : []), "call", "reply"];
+    if (slots.join() !== want.join()) {
+      // One sentence for the one mistake, the likeliest first.
+      const label = (slot          ) => slotEntry(slot)?.entry.label ?? slot;
+      bad.push(k > 0 && slots.includes("content")
+        ? `${at}: only job 1 attaches content -- a later job is handed the reply before it`
+        : slots.filter(x => x === "call").length !== 1 ? `${at} has to have one call step`
+        : `${at}: steps are ${label("content")} (job 1), one call, then ${label("reply")}`);
+      return;
+    }
+    for (const st of steps) {
+      const entry = STEP_TYPES[st.type] ;
+      if (k > 0 && entry.firstJobOnly) { bad.push(`${at}: ${entry.firstJobOnly}`); continue; }
+      onlyFields(st, `${at}'s ${entry.label ?? st.type}`, entry.fields ?? [], bad);
+      entry.validate(st, ctx, bad, at);
+    }
+  },
+};
+// What a test carries besides its type's own fields.
+const TEST_FIELDS                    = ["id", "name", "continueOnFailure"];
+
+/** Test [j]'s name, or the number it has always shown. */
+const testLabel = (doc                                                 , j        )         =>
+  (doc.tests?.[j]?.name || "").trim() || `Test ${j + 1}`;
+
+/** A test type that settles over the whole run rather than item by item. */
+const isWholeRun = (type                           , t            )          =>
+  type?.wholeRun && t ? type.wholeRun(t) : !!type?.verdict && !type?.score;
+
+/**
+ * A document's tests as a list, whatever version wrote it: a queue row keeps
+ * the run document it was submitted with, so a run from before version 6
+ * holds one test or null, read here as the upgrade reads it (testsList).
+ */
+function testsOf(doc                                        )         {
+  const t = doc?.tests;
+  if (Array.isArray(t)) return t          ;
+  return isObj(t) ? [{ id: "t1", name: "", ...t, continueOnFailure: true }        ] : [];
+}
+
+/** The dataset a document's tests grade against, where one does: a run
+    grades against one (validatePipeline says so), so the first names it. */
+function testsDataset(doc                     )                                      {
+  const t = testsOf(doc).find((x         ) => isObj(x) && isRef(x.dataset));
+  return t && "dataset" in t ? t.dataset : null;
+}
+
+STEP_TYPES.tests = {
+  in: "results", out: "verdict",
+  apply: "score",
+  validate(tests, ctx, bad, lastKind, doc){
+    if (!Array.isArray(tests)) return void bad.push("tests has to be a list, empty for an unscored run");
+    const seen = new Set        ();
+    tests.forEach((t           , j        ) => {
+      const at = testLabel(doc, j);
+      const type = isObj(t) && TEST_TYPES[t.type];
+      if (!type) return void bad.push(`${at} is of type "${t?.type}", which is not one this lab has`);
+      const before = bad.length;
+      if (!isStr(t.id) || !t.id.trim()) bad.push(`${at} has no id`);
+      else if (seen.has(t.id)) bad.push(`${at} has the id of another test`);
+      else seen.add(t.id);
+      if (t.name != null && !isStr(t.name)) bad.push(`${at}: name has to be text`);
+      if (typeof t.continueOnFailure !== "boolean") bad.push(`${at}: continueOnFailure has to be true or false`);
+      onlyFields(t, at, [...type.fields, ...TEST_FIELDS], bad);
+      type.validate(t, ctx, bad);
+      // Which kinds a test scores is only worth saying of a test that is whole.
+      if (bad.length > before) return;
+      const accepts = typeof type.accepts === "function" ? type.accepts(t) : type.accepts;
+      if (accepts && lastKind && OUTPUT_KINDS[lastKind] && !accepts.includes(lastKind)) {
+        bad.push(`${at}: the ${type.label} scores ${accepts.map(k => OUTPUT_KINDS[k]?.noun || k).join(" or ")}, `
+               + `and the last job answers with ${OUTPUT_KINDS[lastKind] .noun || lastKind}`);
+      }
+    });
+    // A run is handed one dataset's body to grade against (server-side-runs §4).
+    const named = new Set(tests.filter((t           ) => isObj(t) && isRef(t.dataset)).map((t           ) => t.dataset.id));
+    if (named.size > 1) bad.push("the tests grade against one dataset at a time");
+  },
+};
+
+// ---- the document -------------------------------------------------------------
+
+const PIPELINE_FIELDS                    = ["version", "id", "name", "jobs", "scenarios", "tests"];
+// What resolving adds, and nothing else: the profiles it resolved to and the
+// run's own comment, which belongs to the run and never to the pipeline.
+const RUN_FIELDS = [...PIPELINE_FIELDS, "profiles", "comment", "plugins"];
+
+/** The one rule for a document that is not this version: refuse it, by name. */
+function versionProblem(doc         )                {
+  if (!isObj(doc)) return "a pipeline is a JSON object";
+  if (doc.version === PIPELINE_VERSION) return null;
+  return doc.version == null
+    ? `this pipeline carries no version, and the lab reads version ${PIPELINE_VERSION}`
+    : `this pipeline is version ${JSON.stringify(doc.version)}, and the lab reads version ${PIPELINE_VERSION}`;
+}
+
+/** What an upgrade from version 2 needs from outside the document: the rules
+    of the dataset a pipeline was graded against, which the retired
+    version-2 list kind read every reply under. Without them a job is upgraded with no
+    rules, as a run with no graded test parsed. */
+                             
+                                                                
+ 
+
+/**
+ * [doc] at this version, when it is an earlier one this lab can read. From
+ * version 1, its chains' `tokens` maps become `tokenMappings` lists (values
+ * first, then blocks, each in the order the map held them). From version 2,
+ * a chain of the retired version-2 list kind becomes a `list` with the modifiers
+ * that read a reply exactly as it did (legacyTagsOut, held to it by
+ * parity-check.js), under the graded dataset's rules [ctx] supplies, keeping
+ * its case; and that kind's token in every prompt is {items}. From versions 3
+ * and 4, every id a current document must carry is minted for the ones it
+ * lacks: a scenario's `s1`, `s2` ... by position and a chain's `j1`, `j2` ...
+ * by position -- the same on every reading, so a pipeline read twice before
+ * it is saved keeps them, and the Prompt library's recorded uses keep
+ * matching -- and a new one for the pipeline itself. Anything else comes back
+ * as it was, for versionProblem to name. A copy: the caller's document is not
+ * touched. From version 5, its test -- or none -- becomes a list of one (or
+ * none), the test's id `t1`. From version 6, `chains` are `jobs`: the field
+ * renames and every job's `type` becomes `"job"`.
+ */
+/** Every id a current document must carry, minted for the ones [doc] lacks.
+    An id it already has is kept. */
+function upgradeIds(doc           )            {
+  doc.version = PIPELINE_VERSION;
+  if (!isStr(doc.id) || !doc.id) doc.id = newId();
+  (Array.isArray(doc.chains) ? doc.chains : []).forEach((ch           , k        ) => {
+    if (isObj(ch) && (!isStr(ch.id) || !ch.id)) ch.id = `j${k + 1}`;
+  });
+  (Array.isArray(doc.scenarios) ? doc.scenarios : []).forEach((sc           , i        ) => {
+    if (isObj(sc) && (!isStr(sc.id) || !sc.id)) sc.id = `s${i + 1}`;
+  });
+  return doc;
+}
+
+/** Every profile reference cut to { id, name }. The Runs tab once kept the
+    whole Setup profile a scenario picked -- key and all -- so a document saved
+    then is cleaned as it is read, and validation refuses one that is not. */
+function profileRefs(doc           )       {
+  const cut = (r         ) => (isObj(r) && isStr(r.id) ? { id: r.id, name: isStr(r.name) ? r.name : "" } : r);
+  for (const sc of Array.isArray(doc.scenarios) ? doc.scenarios : []) {
+    if (!isObj(sc)) continue;
+    if ("profile" in sc) sc.profile = cut(sc.profile);
+    for (const cell of Array.isArray(sc.stages) ? sc.stages : []) {
+      if (isObj(cell) && cell.profile != null) cell.profile = cut(cell.profile);
+    }
+  }
+}
+
+/** Whether any profile reference in a pipeline holds more than { id, name }. */
+function fatProfileRef(doc         )          {
+  const fat = (r         ) => isObj(r) && Object.keys(r).some(k => k !== "id" && k !== "name");
+  return isObj(doc) && Array.isArray(doc.scenarios) && doc.scenarios.some((sc           ) =>
+    isObj(sc) && (fat(sc.profile) || (Array.isArray(sc.stages) && sc.stages.some((c           ) => isObj(c) && fat(c.profile)))));
+}
+
+/** Version 5 to 6: the one test, or none, as a list. Its id is `t1`, so
+    reading the same document twice gives the same id, and a stored result's
+    score is read as that test's (upgradeResults). */
+function testsList(doc           )            {
+  doc.version = PIPELINE_VERSION;
+  // Every upgrade ends here, so this is where a profile reference is cut.
+  profileRefs(doc);
+  if (Array.isArray(doc.tests)) return doc;
+  doc.tests = isObj(doc.tests) ? [{ id: "t1", name: "", ...doc.tests, continueOnFailure: true }] : [];
+  return doc;
+}
+
+/** A new test of [type] at the lab's defaults, named [name], continuing on failure. */
+function newTest(type        , name = "", fields                          = {})       {
+  const own = TEST_TYPES[type]?.defaults?.() ?? { type };
+  return { ...own, ...fields, type, id: newId(), name, continueOnFailure: true }        ;
+}
+
+/** Version 6 to 7: chains are jobs. The field renames in place -- so an
+    upgraded document reads the same, key for key -- and every job's `type`
+    becomes `"job"`, so an older document reads as one of today's everywhere. */
+function jobsOf(next           )            {
+  next.version = PIPELINE_VERSION;
+  if (Array.isArray(next.chains)) {
+    const entries = Object.entries(next).map(([k, v]) => (k === "chains" ? ["jobs", v] : [k, v]));
+    next = Object.fromEntries(entries);
+    for (const job of next.jobs) if (isObj(job)) job.type = "job";
+  }
+  return next;
+}
+
+/** Version 7 to 8: a job is its steps (pipeline-model §3). The pipeline's
+    content becomes job 1's Attach Content; a job's image flag and token
+    mappings its Prompt call; its output its Read Reply. What each held is
+    moved as it was, so the run is the same run. */
+function stepsOf(next           )            {
+  next.version = PIPELINE_VERSION;
+  const content = next.content ?? null;
+  delete next.content;
+  (Array.isArray(next.jobs) ? next.jobs : []).forEach((job           , k        ) => {
+    if (!isObj(job) || Array.isArray(job.steps)) return;
+    const { withImage, tokenMappings, out, ...rest } = job;
+    for (const key of Object.keys(job)) delete job[key];
+    Object.assign(job, rest, {
+      steps: [
+        ...(k === 0 && content ? [{ type: "attachContent", content }] : []),
+        { type: "prompt", withImage: !!withImage, tokenMappings: tokenMappings ?? [] },
+        { type: "readReply", out },
+      ],
+    });
+  });
+  return next;
+}
+
+/** Version 8 to 9: every test is Metrics -- a Single Test or a Graded set
+    converted, keeping its id, name and Continue on failure; one of a type
+    this lab never had is left for validation to name. */
+function metricsOf(next           )            {
+  next.version = PIPELINE_VERSION;
+  if (Array.isArray(next.tests)) {
+    next.tests = next.tests.map((t           ) => (isObj(t) && LEGACY_TESTS[t.type]?.toMetrics ? LEGACY_TESTS[t.type] .toMetrics (t) : t));
+  }
+  return next;
+}
+
+function upgradePipeline   (doc   , ctx             = {})    {
+  // A current document is read as it is, but for a profile reference the Runs
+  // tab saved whole (see profileRefs), which is cut back.
+  if (isObj(doc) && doc.version === PIPELINE_VERSION) {
+    if (!fatProfileRef(doc)) return doc;
+    const cleaned = clone(doc)             ;
+    profileRefs(cleaned);
+    return cleaned     ;
+  }
+  if (!isObj(doc) || ![1, 2, 3, 4, 5, 6, 7, 8].includes(doc.version          )) return doc;
+  let next = clone(doc)             ;
+  if (next.version === 8) return metricsOf(next)     ;
+  if (next.version === 7) return metricsOf(stepsOf(testsList(next)))     ;
+  if (next.version === 6) return metricsOf(stepsOf(jobsOf(next)))     ;
+  if (next.version === 5) return metricsOf(stepsOf(jobsOf(testsList(next))))     ;
+  if (next.version === 3 || next.version === 4) return metricsOf(stepsOf(jobsOf(testsList(upgradeIds(next)))))     ;
+  if (next.version === 1) {
+    next.version = 2;
+    if (Array.isArray(next.chains)) {
+      for (const ch of next.chains) {
+        if (!isObj(ch) || !("tokens" in ch)) continue;
+        ch.tokenMappings = tokenMappingsFromV1(ch.tokens);
+        delete ch.tokens;
+      }
+    }
+  }
+  next.version = PIPELINE_VERSION;
+  const graded = isObj(next.tests) && next.tests.type === "graded" && isObj(next.tests.dataset) ? next.tests.dataset.id : null;
+  const rules = graded && ctx.rulesFor ? ctx.rulesFor(graded) ?? null : null;
+  for (const ch of Array.isArray(next.chains) ? next.chains : []) {
+    if (!isObj(ch) || !isObj(ch.out) || ch.out.kind !== "tags") continue;  // vocab: the v2 kind's id
+    const mode = (Array.isArray(ch.out.modifiers) ? ch.out.modifiers : []).find((m           ) => m?.type === "case")?.mode ?? "NONE";
+    ch.out = clone(legacyTagsOut(rules, mode));
+  }
+  const renamed = (text         ) => typeof text === "string"
+    ? text.replace(/\{((?:stage[1-9]\d*\.)?)tags\}/g, "{$1items}") : text;  // vocab: the v2 kind's token
+  for (const sc of Array.isArray(next.scenarios) ? next.scenarios : []) {
+    for (const cell of isObj(sc) && Array.isArray(sc.stages) ? sc.stages : []) {
+      if (isObj(cell)) cell.prompt = renamed(cell.prompt);
+    }
+  }
+  return metricsOf(stepsOf(jobsOf(testsList(upgradeIds(next)))))     ;
+}
+
+/** Version 1's two maps as a list of mappings. */
+function tokenMappingsFromV1(set         )                {
+  if (!isObj(set)) return [];
+  const v1 = set                       ;
+  return [
+    ...Object.entries(isObj(v1.values) ? v1.values : {}).map(([name, value]) => ({ name, type: "value", value: String(value) })),
+    ...Object.entries(isObj(v1.blocks) ? v1.blocks : {}).map(([name, on]) => ({ name, type: "block", enabled: !!on })),
+  ];
+}
+
+/** A current-version document with one job and no scenario. Its job sends
+    the item's image, as a job over a Source would; one over text content
+    has none to send, and the page turns it off with the content. */
+function blankPipeline(opts                                                           = {})           {
+  const job = withCall(jobDefaults(opts.kind, opts.tokens), { withImage: true });
+  return { version: PIPELINE_VERSION, id: newId(), name: opts.name || "",
+           jobs: [job], scenarios: [], tests: [] };
+}
+
+/**
+ * Every reason [doc] cannot run, as sentences -- none when it can. The
+ * reference lookups are [ctx]'s: `profiles(id)` and `sources(id)` answer with
+ * what the id names, or nothing. A run document answers for its own profiles.
+ */
+function validatePipeline(input         , ctx          = {})           {
+  const v = versionProblem(input);
+  if (v) return [v];
+  const doc = input             ;
+  const bad           = [];
+  const run = doc.profiles !== undefined;
+  const c                = { ...ctx, run };
+  if (run && !ctx.profiles) {
+    c.profiles = (id        ) => isObj(doc.profiles) && Object.hasOwn(doc.profiles, id) ? doc.profiles[id] : null;
+  }
+  onlyFields(doc, "the pipeline", run ? RUN_FIELDS : PIPELINE_FIELDS, bad);
+  if (!isStr(doc.id) || !doc.id.trim()) bad.push("the pipeline has no id");
+  if (doc.name != null && !isStr(doc.name)) bad.push("name has to be text");
+  if (run && doc.comment != null && !isStr(doc.comment)) bad.push("comment has to be text");
+  if (!Array.isArray(doc.jobs) || !doc.jobs.length) {
+    return [...bad, "jobs has to be a list of at least one job"];
+  }
+  if (!Array.isArray(doc.scenarios) || !doc.scenarios.length) bad.push("add a scenario first");
+  // Content is job 1's Attach Content step; a job 1 without one has none yet.
+  if (!stepIn(doc.jobs[0], "content")) bad.push("set the content first");
+  if (run) profilesProblems(doc.profiles, bad);
+  doc.jobs.forEach((ch           , k        ) => STEP_TYPES.job .validate(ch, c, bad, k, doc));
+  if (bad.length) return bad;
+  const content = contentOf(doc)             ;
+
+  const scenarios              = doc.scenarios;
+  const n         = doc.jobs.length;
+  scenarios.forEach((sc, i) => {
+    const at = scenarioLabel(doc, i);
+    if (!isObj(sc)) return void bad.push(`${at} has to be an object`);
+    onlyFields(sc, at, ["id", "name", "profile", "stages"], bad);
+    if (!isStr(sc.id) || !sc.id.trim()) bad.push(`${at} has no id`);
+    else if (scenarios.findIndex((o) => isObj(o) && o.id === sc.id) !== i) bad.push(`${at} has the id of another scenario`);
+    if (sc.name != null && !isStr(sc.name)) bad.push(`${at}: name has to be text`);
+    if (!isRef(sc.profile)) bad.push(`${at} has to name its Setup profile as { id, name }`);
+    else onlyFields(sc.profile, `${at}'s profile`, ["id", "name"], bad);
+    if (!Array.isArray(sc.stages) || sc.stages.length !== n) {
+      bad.push(`${at} has ${Array.isArray(sc.stages) ? sc.stages.length : "no"} prompts for ${n} job${n === 1 ? "" : "s"}`);
+      return;
+    }
+    sc.stages.forEach((cell           , k        ) => {
+      if (!isObj(cell)) return void bad.push(`${at}, ${jobLabel(doc, k)} has to be an object`);
+      const call = callEntryOf(doc.jobs[k]);
+      onlyFields(cell, `${at}, ${jobLabel(doc, k)}`, ["prompt", "profile", "from", ...(call?.cellFields || [])], bad);
+      call?.cellProblems?.(cell, callOf(doc.jobs[k]), `${at}, ${jobLabel(doc, k)}`, bad);
+      if (cell.profile != null && !isRef(cell.profile)) bad.push(`${at}, ${jobLabel(doc, k)} has to name its Setup profile as { id, name }`);
+      else if (cell.profile != null) onlyFields(cell.profile, `${at}, ${jobLabel(doc, k)}'s profile`, ["id", "name"], bad);
+      if (cell.from != null && !isRef(cell.from)) bad.push(`${at}, ${jobLabel(doc, k)} has to name the prompt it was picked from as { id, name }`);
+    });
+  });
+  if (bad.length) return bad;
+
+  // A reference that resolves to nothing, once per reference.
+  const missing = new Set        ();
+  const lookup = (ref     ) => {
+    const p = c.profiles ? c.profiles(ref.id) : {};
+    if (!p && !missing.has(ref.id)) {
+      missing.add(ref.id);
+      bad.push(`Setup profile ${ref.name || ref.id} not found`);
+    }
+    return p;
+  };
+  // A type that answers from the item (Echo) has no model, answers only
+  // job 1, and answers only a text item.
+  const local = (p         ) => !!p && typeof p === "object" && !!CONNECTION_TYPES[typeOf(p            )]?.local;
+  // Every scenario needs a prompt in every job. A blank one is an error
+  // rather than a stage dropped, which would hand the job before it
+  // straight to the job after it, under numbers nobody sees. The one it
+  // may leave blank is job 1 answered from the item's own text (Echo over
+  // a Source or Text): the reply is the item, and a prompt would only be
+  // what it is read against. Over Prompt only the prompt is the reply.
+  const itemsHaveText = !!content && !CONTENT_TYPES[content.type]?.bare;
+  for (let k = 0; k < n; k++) {
+    const i = scenarios.findIndex(sc => (!isStr(sc.stages[k].prompt) || !sc.stages[k].prompt.trim())
+      && !(k === 0 && itemsHaveText && local(c.profiles ? c.profiles((sc.stages[0].profile || sc.profile).id) : null)));
+    if (i >= 0) bad.push(n > 1 ? `${jobLabel(doc, k)}, ${scenarioLabel(doc, i)} has no prompt`
+                               : `${scenarioLabel(doc, i)} has no prompt`);
+  }
+  const contentFiles                   = content?.type === "source"
+    ? (c.sources?.(content.ref?.id)?.files ?? content.files ?? null) : null;
+  const nonText = (contentFiles || []).map(f => String((f                             )?.name ?? f))
+    .find(n => !/\.(?:txt|md|csv)$/i.test(n));
+  scenarios.forEach((sc, i) => {
+    const conns = sc.stages.map((cell      ) => lookup(cell.profile || sc.profile));
+    conns.forEach((p         , k        ) => {
+      if (!local(p)) return;
+      const label = CONNECTION_TYPES[typeOf(p            )] .label;
+      if (k > 0) bad.push(`${jobLabel(doc, k)}, ${scenarioLabel(doc, i)}: ${label} answers only job 1, with the item's own text`);
+      else if (nonText) bad.push(`${scenarioLabel(doc, i)}: ${label} answers each text item with its own text, and ${nonText} is not text`);
+    });
+    // A connection answers what its job's call asks: words, or a whole request.
+    conns.forEach((p         , k        ) => {
+      const call = callEntryOf(doc.jobs[k]);
+      // Only a profile that was looked up says what it answers.
+      if (!c.profiles || !p || !isObj(p) || !call) return;
+      const type = CONNECTION_TYPES[typeOf(p            )];
+      if (type && !(type.answers ?? ["prompt"]).includes(call.asks ?? "prompt")) {
+        bad.push(`${n > 1 ? `${jobLabel(doc, k)}, ` : ""}${scenarioLabel(doc, i)}: ${call.label ?? "this call"} needs a profile that answers it, and ${type.label} does not`);
+      }
+    });
+    // The model is the profile's unless the call's cell carries it.
+    const bare = conns.findIndex((p                           , k        ) => p && c.profiles && !local(p)
+      && callEntryOf(doc.jobs[k])?.modelFrom !== "cell" && !String(p.model || "").trim());
+    if (bare >= 0) {
+      bad.push(n > 1
+        ? `no model on the profile ${jobLabel(doc, bare)} of ${scenarioLabel(doc, i)} uses — manage profiles on the Setup tab`
+        : `no model on ${scenarioLabel(doc, i)}'s Setup profile — manage profiles on the Setup tab`);
+    }
+  });
+  STEP_TYPES.tests .validate(doc.tests, c, bad, outOf(doc.jobs.at(-1)).kind, doc);
+  if (bad.length) return bad;
+
+  // Asked before anything is sent, so a misspelt token costs nothing and
+  // says which job, instead of failing every item the same way.
+  const text = CONTENT_TYPES[content?.type]?.text?.(content, c) ?? null;
+  scenarios.forEach((sc, i) => {
+    const stages          = doc.jobs.map((ch     , k        ) => ({ text: sc.stages[k].prompt, kind: outOf(ch).kind,
+                                                                   verbatim: !!callEntryOf(ch)?.verbatim }));
+    const problem = jobProblem(stages, stages.map(() => () => {}), doc.jobs.map((ch     ) => callOf(ch).tokenMappings), text);
+    if (problem) bad.push(`${scenarioLabel(doc, i)}: ${jobWords(problem)}`);
+  });
+  return bad;
+}
+
+/** A run document's profiles table: id → connection, keyless, spellable. */
+function profilesProblems(profiles         , bad          )       {
+  if (!isObj(profiles)) return void bad.push("profiles has to be an object of id → connection");
+  const spelt = new Map                ();
+  for (const [id, conn] of Object.entries(profiles)) {
+    if (!PROFILE_ID.test(id)) {
+      bad.push(`profile id "${id}" has to be letters and digits, with at most one hyphen: its key comes from EVAL_API_KEY_<ID>`);
+      continue;
+    }
+    const from = keyVar(id);
+    if (spelt.has(from)) bad.push(`profiles ${spelt.get(from)} and ${id} both take their key from $${from}`);
+    spelt.set(from, id);
+    const at = `profile ${id}`;
+    if (!isObj(conn)) { bad.push(`${at} has to be an object`); continue; }
+    connectionProblems(conn, at, from, bad);
+  }
+}
+
+/** What is wrong with one connection of a run, as sentences naming it [at]. */
+function connectionProblems(conn                           , at        , from        , bad          )       {
+  onlyFields(conn, at, CONNECTION_FIELDS, bad, from);
+  const type = conn.type ?? profileType(conn);
+  if (!isStr(conn.type) || !CONNECTION_TYPES[type]) {
+    bad.push(`${at}: type has to be one of ${Object.keys(CONNECTION_TYPES).join(", ")}`);
+  }
+  if (!isStr(conn.name)) bad.push(`${at}: name has to be text`);
+  const url = conn.url ?? "";
+  if (!isStr(url)) bad.push(`${at}: url has to be text, blank for the lab's Ollama`);
+  else if (url.trim()) {
+    let u             = null;
+    try { u = new URL(/:\/\//.test(url) ? url : "http://" + url); }
+    catch { bad.push(`${at}: ${url} cannot be read as an address`); }
+    // A key in an address is written into every log line and error message
+    // that prints it.
+    if (u && (u.username || u.password)) {
+      bad.push(`${at} has a key in its address, and a key never goes in a pipeline — $${from} supplies it`);
+    }
+  }
+  if (!isStr(conn.model)) bad.push(`${at}: model has to be text`);
+  if (conn.temperature != null && !isStr(conn.temperature) && typeof conn.temperature !== "number") {
+    bad.push(`${at}: temperature has to be a number`);
+  }
+  if (conn.px != null && !(conn.px === EDGE_448
+      || (typeof conn.px === "number" ? conn.px > 0 : isStr(conn.px) && conn.px.trim() && Number(conn.px) > 0))) {
+    bad.push(`${at}: px has to be a pixel-area number, or "edge448"`);
+  }
+  if (conn.format != null && !IMAGE_FORMATS.includes(conn.format)) {
+    bad.push(`${at}: format has to be one of ${IMAGE_FORMATS.join(", ")}`);
+  }
+  if (conn.quality != null && !(typeof conn.quality === "number"
+      ? conn.quality > 0 && conn.quality <= 1 : isStr(conn.quality) && Number(conn.quality) > 0)) {
+    bad.push(`${at}: quality has to be between 0 and 1`);
+  }
+  // A setting the type does not carry is not a setting it can send.
+  if (conn.options != null) {
+    if (!isObj(conn.options)) bad.push(`${at}: options has to be an object`);
+    else {
+      const keys = CONNECTION_TYPES[type] ? CONNECTION_TYPES[type].settings.map(s => s.key) : OPTION_FIELDS;
+      onlyFields(conn.options, `${at}'s options`, keys, bad, from);
+      for (const [k, val] of Object.entries(conn.options)) {
+        if (!isStr(val) && typeof val !== "number") bad.push(`${at}: options.${k} has to be text or a number`);
+      }
+    }
+  }
+  // What a request of this type needs before it can be built.
+  if (CONNECTION_TYPES[type]?.url && !String(url || "").trim()) {
+    bad.push(`${at}: ${CONNECTION_TYPES[type].label} needs its address, ${CONNECTION_TYPES[type].url}`);
+  }
+  if (CONNECTION_TYPES[type]?.refusesHosted && isHostedUrl(url)) {
+    bad.push(`${at}: llama.cpp requires its llama-server, not a hosted model`);
+  }
+  for (const why of CONNECTION_TYPES[type]?.settingsProblems?.(connectionSettings(conn)) ?? []) bad.push(`${at} ${why}`);
+}
+
+/** The profile ids a pipeline references, scenarios first, in order. */
+function profileIds(doc                                                       )           {
+  const ids           = [];
+  for (const sc of doc.scenarios || []) {
+    for (const ref of [sc.profile, ...(sc.stages || []).map((c      ) => c.profile)]) {
+      if (ref?.id && !ids.includes(ref.id)) ids.push(ref.id);
+    }
+  }
+  // Then the ones a test asks (a grader), so a run carries them too.
+  for (const t of testsOf(doc)) {
+    for (const ref of TEST_TYPES[t.type]?.profiles?.(t) ?? []) if (ref?.id && !ids.includes(ref.id)) ids.push(ref.id);
+  }
+  return ids;
+}
+
+/**
+ * The run document: [doc] plus what its references resolved to, once, at
+ * submit. `ctx.profiles(id)` answers with a stored profile, `ctx.files` is
+ * the Source's file list as it reads now, `ctx.comment` is the run's own.
+ */
+function resolvePipeline(doc          ,
+                         ctx                                                                            = {})              {
+  const run = clone(doc)             ;
+  // What the lab supplies a test -- its grader -- before the profiles it
+  // asks are carried.
+  run.tests = (Array.isArray(run.tests) ? run.tests : []).map((t           ) => TEST_TYPES[t?.type]?.resolve?.(t, ctx) ?? t);
+  run.profiles = {};
+  for (const id of profileIds(run)) {
+    const p = ctx.profiles?.(id);
+    if (p) run.profiles[id] = connectionOf(p           );
+  }
+  const content = contentOf(run)             ;
+  if (content?.type === "source") content.files = CONTENT_TYPES.source .expand (content, ctx.files);
+  if (ctx.datasetVersion) {
+    for (const t of run.tests || []) if (isRef(t.dataset)) t.dataset.version = ctx.datasetVersion;
+  }
+  if (isStr(ctx.comment)) run.comment = ctx.comment;
+  return run;
+}
+
+/** A run put back on the canvas: the run document with its additions dropped. */
+function pipelineOfRun(run             , ctx             = {})           {
+  const doc = clone(upgradePipeline(run, ctx))             ;
+  delete doc.profiles;
+  delete doc.comment;
+  delete doc.plugins;
+  const content = contentOf(doc)             ;
+  if (content) { delete content.files; delete content.revs; }
+  for (const t of doc.tests || []) if (isObj(t.dataset)) delete t.dataset.version;
+  return doc;
+}
+
+// ---- the pipeline's file form (#29) ------------------------------------------
+//
+// YAML is what a pipeline is written as and read from: a browser has no YAML
+// parser, and the server is stdlib-only Python, so the vendored js-yaml next
+// to this file does it -- its ES module build, which the page's bundle and
+// node import alike. Only these functions touch it.
+
+
+/** [doc] as YAML text, the pipeline's file form -- references only, so an
+    export carries no key, no URL, no file list and no file bytes. */
+function pipelineToYaml(doc          )         {
+  return yaml.dump(doc, { lineWidth: -1, noRefs: true });
+}
+
+/**
+ * [doc] as this lab would hold it: every reference matched by id, then by
+ * name (pipeline-model §5), so a pipeline written in another lab -- ids that
+ * mean nothing here -- finds its Source and Setup profiles by the names they
+ * were exported under. [ctx]'s lists are what the lab holds:
+ * `{ profiles, sources, datasets }`, each `{ id, name }[]`. Returns
+ * `{ doc, missing }`, where `missing` is one sentence per reference neither
+ * id nor name matched, or `{ error }` when the document is refused: not a
+ * version the lab reads, or not something the lab can edit and run as it
+ * stands.
+ */
+function importPipeline(input         , ctx            = {})               {
+  // A file exported before version 2 still imports: it is upgraded, not refused.
+  const doc = upgradePipeline(input, ctx);
+  const v = versionProblem(doc);
+  if (v) return { error: v };
+  const profiles = ctx.profiles ?? [], sources = ctx.sources ?? [], datasets = ctx.datasets ?? [];
+  const next = clone(doc)             ;
+  const missing           = [], seen = new Set        ();
+  const lists = { profile: profiles, source: sources, dataset: datasets };
+  const words = {
+    profile: (ref     ) => `Setup profile ${ref.name || ref.id} not found`,
+    source: (ref     ) => `Source ${ref.name || ref.id} not found`,
+    dataset: (ref     ) => `Dataset ${ref.name || ref.id} not found`,
+  };
+  const remap = (ref     , kind                    )      => {
+    const hit = lists[kind].find(x => x.id === ref.id) || lists[kind].find(x => x.name === ref.name);
+    if (hit) return { id: hit.id, name: hit.name };
+    const sentence = words[kind](ref);
+    if (!seen.has(sentence)) { seen.add(sentence); missing.push(sentence); }
+    return ref;
+  };
+  const content = contentOf(next)             ;
+  if (content?.type === "source") content.ref = remap(content.ref, "source");
+  for (const sc of next.scenarios || []) {
+    sc.profile = remap(sc.profile, "profile");
+    for (const cell of sc.stages || []) {
+      if (cell.profile) cell.profile = remap(cell.profile, "profile");
+    }
+  }
+  for (const t of Array.isArray(next.tests) ? next.tests : []) {
+    if (isRef(t?.dataset)) t.dataset = remap(t.dataset, "dataset");
+  }
+  // A hand-written file needs no id of its own: mint the ones it lacks, and
+  // keep the ones it carries, so export → import → export is the same
+  // document and a re-import can recognise the same pipeline (#93).
+  mintIds(next);
+  // What a document may still lack on import is its references -- matched
+  // above and listed as missing. Anything else the model says is wrong is a
+  // document the lab cannot edit and run as it stands, so it is refused by
+  // the first such sentence. Validated with no lookups, so a reference a
+  // later step will satisfy is never the refusal.
+  const bad = validatePipeline(next).filter(s => !/ not found$/.test(s));
+  if (bad.length) return { error: bad[0]  };
+  return { doc: next, missing };
+}
+
+/** Mint, in place, the ids a current-version document must have that it
+    lacks: a hand-written YAML carries none, and one it carries is kept. */
+function mintIds(doc           )            {
+  if (!isStr(doc.id) || !doc.id) doc.id = newId();
+  for (const ch of Array.isArray(doc.jobs) ? doc.jobs : []) {
+    if (isObj(ch) && (!isStr(ch.id) || !ch.id)) ch.id = newId();
+  }
+  for (const sc of Array.isArray(doc.scenarios) ? doc.scenarios : []) {
+    if (isObj(sc) && (!isStr(sc.id) || !sc.id)) sc.id = newId();
+  }
+  for (const t of Array.isArray(doc.tests) ? doc.tests : []) {
+    if (isObj(t) && (!isStr(t.id) || !t.id)) t.id = newId();
+  }
+  return doc;
+}
+
+/** [text] as a pipeline of this lab: YAML parsed, references remapped by id
+    then by name. importPipeline's `{ doc, missing }`, or `{ error }` when the
+    text is not YAML or the document is refused. */
+function yamlToPipeline(text        , ctx            )               {
+  let doc         ;
+  try { doc = yaml.load(text); }
+  catch { return { error: "this file is not YAML, so nothing was imported" }; }
+  return importPipeline(doc, ctx);
+}
+
+/**
+ * Scenario [i] of a run document as runPipeline and a transport take it:
+ * each stage's wording, kind, image flag and modifiers, the token set of
+ * the job it sits in, and the connection it asks -- its own profile, or
+ * its scenario's.
+ */
+function stagesFor(run             , i        ) 
+                                                                                                        
+                                     {
+  const sc = run.scenarios[i] ;
+  const stages = run.jobs.map((ch, k) => {
+    const { kind, modifiers, ...settings } = outOf(ch);
+    return { text: sc.stages[k] .prompt, kind, withImage: !!callOf(ch).withImage,
+             verbatim: !!callEntryOf(ch)?.verbatim, modifiers: modifiers || [], settings };
+  });
+  const connections = run.jobs.map((ch, k) => {
+    const id = sc.stages[k] .profile?.id ?? sc.profile.id;
+    return { id, ...(run.profiles?.[id] || {}) };
+  });
+  // Each job's call step and this scenario's cell in it, for a transport
+  // that builds its own request from them (an HTTP Request).
+  return { stages, tokens: run.jobs.map(ch => callOf(ch).tokenMappings), connections,
+           calls: run.jobs.map(ch => stepIn(ch, "call") ), cells: sc.stages };
+}
+
+/** The Setup profile scenario [i] of a run ran under, as History shows it: keyless. */
+function scenarioProfile(run             , i        )                                                          {
+  const id = run.scenarios?.[i]?.profile?.id;
+  const conn = id != null ? run.profiles?.[id] : null;
+  return conn ? { id: id , name: conn.name, settings: connectionSettings(conn                       ) } : null;
+}
+
+/** The kind a run's result is read as: its last job's. */
+const lastKind = (doc                           )                => outOf(doc.jobs?.at(-1))?.kind ?? null;
+
+/** A value of a modifier on a run's last job -- the case mode History prints. */
+const lastModifier = (doc                           , type        )                  =>
+  (outOf(doc.jobs?.at(-1))?.modifiers || []).find(m => m.type === type) || null;
+
+/** What a modifier is set to, in a few words, from its entry's own options:
+    a choice's label, a number, "3 rules" -- or "on" for one with none. What
+    History's column for its type and a failing row's task text print, so
+    neither names a modifier of its own. */
+function modifierSummary(m          )         {
+  const entry = MODIFIERS[m.type];
+  const said = (entry?.options || []).map(o => {
+    const v = (m                           )[o.key];
+    if (o.type === "select") return o.choices.find(c => c.value === v)?.label ?? String(v ?? "");
+    if (o.type === "rules") return Array.isArray(v) ? `${v.length} ${v.length === 1 ? "rule" : "rules"}` : "";
+    return v == null ? "" : String(v);
+  }).filter(Boolean);
+  return said.length ? said.join(", ") : "on";
+}
+
+// ---- the tests, in order (docs/pipeline-model.md §3) ---------------------------
+// Tests only read a run: none changes what a later one sees, and none stops
+// the model being sent the next item. What order changes is Continue on
+// failure. A per-item test that fails and does not continue stops the tests
+// after it for that item alone -- they read Skipped there, and a whole-run
+// test after it pools the items it did not stop. A whole-run test settles
+// once every item is in, and one that fails then and does not continue
+// leaves every test after it Skipped.
+
+const SKIPPED          = Object.freeze({ skipped: true          });
+const isSkipped = (s         )               => isObj(s) && s.skipped === true;
+/** A reading that failed: a score that did not pass. Skipped is not one. */
+const failedScore = (s                              )          => !!s && !isSkipped(s) && !s.pass;
+
+/**
+ * One reply's scores under a run's per-item tests, by test id, in order: a
+ * test with no case to score leaves no entry, and one after a failure that
+ * does not continue reads Skipped. Null where nothing was scored.
+ */
+function itemScores(run             , kase                         , res                    )                                             {
+  if (!kase) return null;
+  const out                                      = {};
+  let stopped = false;
+  for (const t of testsOf(run)) {
+    const type = TEST_TYPES[t.type];
+    if (!type?.score) continue;
+    if (stopped) { out[t.id] = SKIPPED; continue; }
+    const s = type.score(t, kase, res);
+    out[t.id] = s;
+    if (!s.pass && !t.continueOnFailure) stopped = true;
+  }
+  return Object.keys(out).length ? out : null;
+}
+
+/** What production replied to an item, for a run's metrics: its last job's
+    call says, from the item's record, or nobody does. */
+function productionOf(run                          , record         )                {
+  const last = run.jobs.at(-1);
+  const call = stepIn(last, "call");
+  return record ? STEP_TYPES[(call                    )?.type ?? ""]?.production?.(call, record) ?? null : null;
+}
+
+/**
+ * itemScores for the runner, which can wait: a test that reads every item
+ * (`read`: the Metrics, which may ask a grader) scores one with no case too.
+ */
+async function itemScoresAsync(run             , kase                         , res                    ,
+                               more           = {})                                                        {
+  const out                                        = {};
+  let stopped = false;
+  for (const t of testsOf(run)) {
+    const type = TEST_TYPES[t.type];
+    if (isWholeRun(type, t) || (!type?.read && !(type?.score && kase))) continue;
+    if (stopped) { out[t.id] = SKIPPED; continue; }
+    // A test with nothing to read on this item leaves no entry, as a graded
+    // test does on an item with no case.
+    const s = type.read ? await type.read(t, kase ?? null, res, { plain: !OUTPUT_KINDS[lastKind(run) ?? ""]?.terms, ...more })
+      : type.score (t, kase , res);
+    if (!s) continue;
+    out[t.id] = s;
+    if (!s.pass && !t.continueOnFailure) stopped = true;
+  }
+  return Object.keys(out).length ? out : null;
+}
+
+/**
+ * Every test's reading of scenario [i] of a run, in the run's order, from
+ * the items so far. [settled] says every item is in: only then has a
+ * whole-run test settled, so only then does its failure skip the tests
+ * after it.
+ */
+function scenarioTests(run             , i        , items                                             ,
+                       settled = true)                {
+  const cells = (items || []).map(it => (it && !it.unrun ? it.scenarios?.[i] : undefined));
+  // Which items a per-item test has stopped so far, for the tests after it.
+  const stopped = cells.map(() => false);
+  let skipRest = false;
+  const tests = testsOf(run);
+  return tests.map((t, j) => {
+    const type = TEST_TYPES[t.type];
+    const whole = isWholeRun(type, t);
+    const base = { id: t.id, label: testLabel({ tests }, j), whole, skipped: skipRest,
+                   verdict: null                          , rules: type?.rules?.(t) ?? [], items: cells.map(() => null)                        ,
+                   ran: 0, passed: 0, skippedItems: 0 };
+    if (skipRest) {
+      if (!whole) base.items = cells.map(c => (c?.res ? SKIPPED : null));
+      return base;
+    }
+    if (whole) {
+      const ress = cells.map((c, x) => (stopped[x] ? undefined : c?.res));
+      base.verdict = type .verdict (t, ress, lastKind(run));
+      if (settled && !base.verdict.pass && !t.continueOnFailure) skipRest = true;
+      return base;
+    }
+    cells.forEach((c, x) => {
+      const s = c?.scores?.[t.id] ?? null;
+      const read                   = stopped[x] && c?.res ? SKIPPED : s;
+      base.items[x] = read;
+      if (!read) return;
+      if (isSkipped(read)) { base.skippedItems++; return; }
+      base.ran++;
+      if (read.pass) base.passed++;
+      else if (!t.continueOnFailure) stopped[x] = true;
+    });
+    return base;
+  });
+}
+
+/** A scenario's pass or fail over every test that read it: null where none
+    has anything to say yet. */
+function scenarioPasses(outcomes                        )                 {
+  let said = false;
+  for (const o of outcomes) {
+    if (o.skipped) continue;
+    if (o.whole) {
+      if (!o.verdict?.ran) continue;
+      said = true;
+      if (!o.verdict.pass) return false;
+    } else if (o.ran) {
+      said = true;
+      if (o.passed < o.ran) return false;
+    }
+  }
+  return said ? true : null;
+}
+
+/**
+ * Every rule the committed graded set has to satisfy, as sentences.
+ *
+ * Shared rather than asserted in CI alone, because the lab now lets somebody
+ * edit the set in the browser: rules that live only in `evals-check.js` are
+ * rules you discover after committing, and the whole point of editing in the
+ * page is not having to commit to find out. So the check calls this, the page
+ * calls this, and an edit the page accepts is an edit CI accepts.
+ *
+ * [files] is what the lab can show and what it cannot -- `{ shown, hidden }`,
+ * either as file names. Omitted, the coverage rules are skipped rather than
+ * failed: `run-evals.js` grades whatever set it is given and has no business
+ * asserting that a repository directory matches it.
+ *
+ * Returns sentences, not a boolean. A refusal that does not say which case is
+ * wrong sends somebody back to a 2,000-line file to guess.
+ */
+function validateEvals(ev           , files                                          )           {
+  const bad           = [];
+  if (!ev || typeof ev !== "object" || Array.isArray(ev)) {
+    return ["the graded set has to be a JSON object with a `cases` list"];
+  }
+  if (ev.cases != null && !Array.isArray(ev.cases)) bad.push("cases has to be a list");
+  if (bad.length) return bad;
+
+  const graded              = ev.cases || [];
+  // Identity first: every rule below reports which case is at fault, so a
+  // case with no usable id makes the rest of the report unreadable.
+  const seen = new Map                ();
+  for (const c of graded) {
+    {
+      if (!c || typeof c !== "object" || Array.isArray(c)) {
+        bad.push("cases holds something that is not a case");
+        continue;
+      }
+      if (typeof c.id !== "string" || !c.id.trim()) bad.push("a case has no id");
+      else if (seen.has(c.id)) bad.push(`${c.id} is graded twice`);
+      else seen.set(c.id, "cases");
+      if (!caseFile(c).trim()) {
+        bad.push(`${c.id || "a case"} names no file`);
+      }
+      for (const key of ["expect", "forbid", "allow", "anyOf", "watch", "traits"]) {
+        if (c[key] != null && !Array.isArray(c[key])) bad.push(`${c.id}: ${key} has to be a list`);
+      }
+      for (const key of ["minCount", "maxCount"]) {
+        if (c[key] != null && !Number.isInteger(c[key])) bad.push(`${c.id}: ${key} has to be a whole number`);
+      }
+      if (c.discarded != null && c.discarded !== true) bad.push(`${c.id}: discarded is true or left out`);
+      // A case's own metrics, which a Metrics test adds to its own for this item.
+      if (c.metrics != null) metricsProblems(c.metrics, String(c.id), bad);
+    }
+  }
+  if (bad.length) return bad;
+
+  // A term the scorer cannot match is a term that can never be produced, so
+  // the case is unpassable however well the model answers.
+  const matchable = (term        ) => termIn([String(term).trim()], term);
+
+  for (const c of graded) {
+    if (c.todo) continue;
+    const say = (m        ) => bad.push(`${c.id}: ${m}`);
+    const expect = c.expect || [], forbid = c.forbid || [], anyOf = c.anyOf || [];
+
+    if (c.discarded === true) {
+      // What is discarded holds nothing, so there is nothing else to expect.
+      if (expect.length || anyOf.length || forbid.length || c.minCount != null || c.maxCount != null) {
+        say("expects its answer discarded, and states something the answer should hold too");
+      }
+      continue;
+    }
+    const metrics = Array.isArray(c.metrics) ? c.metrics : [];
+    if (!expect.length && !anyOf.length && !metrics.length) say("graded but states nothing to expect");
+    for (const t of expect) if (!matchable(t)) say(`expects ${t}, which its own scorer cannot match`);
+    for (const g of anyOf) {
+      if (!Array.isArray(g)) { say("an anyOf group has to be a list of terms"); continue; }
+      if (!g.length) say("an anyOf group is empty, so nothing can satisfy it");
+      for (const t of g) if (!matchable(t)) say(`offers ${t}, which its own scorer cannot match`);
+    }
+    // An exception excuses only the forbidden terms inside it, so one that
+    // holds none of them changes nothing and reads as if it did.
+    for (const a of c.allow || []) {
+      if (!forbid.some((t        ) => termIn([a], t))) say(`allows ${a}, which holds nothing it forbids`);
+    }
+    // A term on both lists cannot be produced and cannot be withheld.
+    for (const t of [...expect, ...anyOf.flat()]) {
+      if (forbid.includes(t)) say(`${t} is both expected and forbidden`);
+    }
+    const { minCount: lo, maxCount: hi } = c;
+    if (lo != null && hi != null && lo > hi) say(`minCount ${lo} is above maxCount ${hi}`);
+    if (lo != null && lo < 1) say(`minCount ${lo} is not a bound`);
+    // The mirror of the floor: a ceiling below one says no answer is
+    // acceptable, which is an entry that can never pass rather than a
+    // strict one.
+    if (hi != null && hi < 1) say(`maxCount ${hi} leaves no answer that could pass`);
+    // A case that names more distinct things than the reply may carry, in
+    // the scorer's own counting of a thing (#486: an expect term is one, an
+    // anyOf group is one), can never pass however well the model answers.
+    const things = expect.length + anyOf.length;
+    if (hi != null && things > hi) {
+      say(`asks for ${things} things and maxCount ${hi} admits ${hi}`);
+    }
+  }
+
+  // One file, one set of expectations. A file here twice is two sets of
+  // them, graded separately, and both would be listed.
+  const where = new Map                 ();
+  for (const c of graded) {
+    const name = caseFile(c);
+    const counted = where.get(name);
+    if (counted) {
+      bad.push(`${name} is graded twice — one file, `
+             + `two sets of expectations. Grade it once.`);
+    } else where.set(name, true);
+  }
+  const gradedAt = (name        ) => where.has(name);
+
+  if (!files) return bad;
+  const shown = files.shown || [], hidden = files.hidden || [];
+  for (const file of where.keys()) {
+    if (!shown.includes(file) && !hidden.includes(file)) {
+      bad.push(`${file} is graded and is not in the Source`);
+    }
+    if (hidden.includes(file)) {
+      bad.push(`${file} is graded, and the lab cannot display it `
+             + `— the row would have no image and nothing to send`);
+    }
+  }
+  // The other direction, which is issue #270: a file dropped into the
+  // set and graded by nobody is one nobody discovers is ungraded.
+  for (const f of shown) {
+    if (!gradedAt(f)) {
+      bad.push(`${f} is in the Source and this dataset does not grade it, `
+             + `so the Evals tab does not list it`);
+    }
+  }
+  return bad;
+}
+
+/**
+ * Warnings, not refusals: things a graded set may still be right about.
+ *
+ * The one it carries is the count [prompt] -- the dataset's -- asks for. A number
+ * parsed out of the wording (`up to 8 …`) is a hint rather than a
+ * rule -- a prompt without a number carries no hint, and silence follows --
+ * so a case that asks for more things than the prompt requests is told,
+ * never stopped.
+ */
+function evalsWarnings(ev           , prompt        )           {
+  if (!ev || typeof ev !== "object" || Array.isArray(ev)) return [];
+  const n = (String(prompt ?? "").match(/up to (\d+) \w/i) || [])[1];
+  if (!n) return [];
+  const want = Number(n), warn           = [];
+  for (const c of ev.cases || []) {
+    if (!c || c.todo) continue;
+    const things = (c.expect || []).length + (c.anyOf || []).length;
+    if (things > want) {
+      warn.push(`${c.id}: asks for ${things} things and the prompt asks for up to ${want}`);
+    }
+  }
+  return warn;
+}
+
+/**
+ * The graded set as the repository holds it, byte for byte.
+ *
+ * Two-space JSON with a trailing newline and its punctuation written as
+ * characters rather than escapes, which is what the committed file is -- one
+ * line of it disagreed and was normalised when this was written. Byte-identity
+ * is the whole point: an export of a set you edited one case of has to produce
+ * a `git diff` of that one case, or nobody will trust it enough to commit it.
+ * `evals-check.js` asserts the round trip against the real file.
+ */
+function evalsJson(ev         )         {
+  return JSON.stringify(canonicalCases(ev), null, 2) + "\n";
+}
+
+
+// ---- Loading -------------------------------------------------------------
+// The list kind registers its entries from its own file, handed what it
+// registers with rather than importing it, so the two modules are no cycle
+// and every caller that imports this has them without a line of its own.
+list({ registerKinds });
+registerMetrics({ registerKinds });
+
+export {
+    TOKEN_DEFAULTS, TOKEN_TYPES, tokenMapping, tokenNames, resolvePrompt, tokenSet, textPrompt, words,
+    loopReplyError, preparedSize,
+    termIn, forbiddenIn, scoreCase, gradedSetFrom, caseFile, canonicalCases, upgradeDatasetBody, datasetRules, upgradeResults, emptyTally, addToTally, isHostedUrl,
+    SEED, REPLY_TOKENS_BEFORE, ANTHROPIC_MAX_TOKENS, asNumber, pinReplyTokens, mappingsFor,
+    CONNECTION_TYPES, HTTP_APIS, httpApiFor, httpRequestOf, httpReplyOf, callEntryOf, WdlError, localAnswer, typeOf, profileType, convertProfile, splitOllama, DECODING_KEYS, apiBase,
+    EDGE_448, budgetLabel, IMAGE_FORMATS, encoderQuality,
+    tallyPercent, runPipeline, validateEvals, evalsWarnings, evalsJson, readList,
+    scoreSingle, singleRules, parseCount, lengthHolds, countHolds, COUNT_OPS, LENGTH_OPS,
+    COUNT_OP_LABEL, LENGTH_OP_LABEL,
+    PIPELINE_VERSION, STEP_TYPES, CONTENT_TYPES, OUTPUT_KINDS, MODIFIERS, TEST_TYPES, LEGACY_TESTS, METRICS, readMetrics, metricSummary, itemScoresAsync, productionOf,
+    SOURCE_TYPES, DEFAULT_SOURCE_TYPE, sourceTypeOf,
+    registerKinds, defaultKind, jobDefaults, applyModifiers, keyVar, connectionOf, connectionSettings,
+    connectionRequest, connectionBase, connectionSend, connectionReply, connectionReplyProblem, connectionImage, connectionProblems,
+CONNECTION_FIELDS, SETTING_KEYS, OPTION_FIELDS, jobLabel, scenarioLabel, jobWords, versionProblem,
+    contentOf, withContent, callOf, replyOf, outOf, withOut, withCall, slotEntry, SLOTS,
+    blankPipeline, upgradePipeline, fatProfileRef, newId, newTest, validatePipeline, resolvePipeline, pipelineOfRun, stagesFor, profileIds,
+    scenarioProfile, lastKind, lastModifier, modifierSummary, itemScores, scenarioTests, scenarioPasses, isSkipped, failedScore,
+    testLabel, testsOf, testsDataset, isWholeRun, TEST_FIELDS,
+    pipelineToYaml, importPipeline, yamlToPipeline,
+    pluginHost, legacyTagsOut, splitItems, tidy, tryExamples, itemRulesProblems, dropBy, rejectBy, matcher,
+};