@wafertools/wafermap 0.30.2 → 0.30.4

package/dist/packages/renderer/derivedTests/evaluate.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Evaluator for a parsed derived-test expression.
+ *
+ * Two rules govern every operation here, and they are deliberately different
+ * from each other:
+ *
+ * 1. **Scalars propagate "unknown" strictly.** If any operand is `undefined` —
+ *    a test not run on this die, a verdict never recorded, a value outside its
+ *    limits' knowability — the whole expression is `undefined`, which becomes an
+ *    absent entry and renders as no-data grey. Never `?? 0`, never `?? false`.
+ *    A missing measurement is not a zero and a missing verdict is not a fail.
+ *
+ * 2. **Reducers skip unknowns and count only what is known.** This is the one
+ *    intentional break from (1), and it is why `countKnown` exists: a die binned
+ *    out early legitimately has no verdict for the tests that never ran, and
+ *    under strict propagation `all(testPass[1010..1025])` would grey out most of
+ *    a bad wafer instead of saying what it was asked. A reducer over an entirely
+ *    unknown vector still returns `undefined` — there is nothing to reduce.
+ *
+ * A non-finite arithmetic result (`0/0`, `ln(-1)`, overflow) is `undefined` too,
+ * for the same reason: `NaN` must reach the map as no-data, not as a value that
+ * drags a mean toward zero or classifies as in-spec.
+ */
+import type { ExprNode } from './parser.js';
+/** Per-die data the evaluator is allowed to reach. Deliberately a closed set of
+ *  functions rather than the die object, so the AST has no path to anything
+ *  else on the die or in the host. */
+export interface EvalContext {
+    /** Measured value of a parametric test, or `undefined` if not recorded. */
+    value(test: number): number | undefined;
+    /** Tester's recorded verdict, via `getTestPassStatus`. */
+    testPass(test: number): boolean | undefined;
+    /** Spec-limit judgement, via `classifySpec`. */
+    specPass(test: number): boolean | undefined;
+    /** The die's bin-based pass verdict, via `diePassStatus`. */
+    diePass(): boolean | undefined;
+}
+type Scalar = number | boolean | undefined;
+/**
+ * Evaluate `node` for one die. Returns `undefined` when no answer is knowable.
+ *
+ * The AST is a plain data tree built by `parseExpression` and already statically
+ * type-checked, so this walk performs no validation and cannot reach any host
+ * value not exposed through `ctx`.
+ */
+export declare function evaluate(node: ExprNode, ctx: EvalContext): Scalar;
+export {};
+//# sourceMappingURL=evaluate.d.ts.map

package/dist/packages/renderer/derivedTests/evaluate.js

@@ -0,0 +1 @@
+import{minOf as c,maxOf as f}from"../../core/utils.js";function s(e){return Number.isFinite(e)?e:void 0}function l(e,t){const n=r=>e.kind==="t"?t.value(r):e.kind==="testPass"?t.testPass(r):t.specPass(r);return e.tests.map(n)}function o(e,t){const n=t.filter(r=>r!==void 0);if(e==="countKnown")return n.length;if(n.length!==0)switch(e){case"all":return n.every(Boolean);case"any":return n.some(Boolean);case"none":return!n.some(Boolean);case"countTrue":return n.filter(Boolean).length;case"countFalse":return n.filter(r=>!r).length;case"min":return c(n);case"max":return f(n);case"sum":return s(n.reduce((r,a)=>r+a,0));case"mean":return s(n.reduce((r,a)=>r+a,0)/n.length);default:return}}const d={abs:e=>Math.abs(e[0]),sqrt:e=>Math.sqrt(e[0]),ln:e=>Math.log(e[0]),log10:e=>Math.log10(e[0]),exp:e=>Math.exp(e[0]),floor:e=>Math.floor(e[0]),ceil:e=>Math.ceil(e[0]),round:e=>Math.round(e[0]),sign:e=>Math.sign(e[0]),pow:e=>Math.pow(e[0],e[1]),min:e=>c(e),max:e=>f(e)};export function evaluate(e,t){switch(e.k){case"num":return e.value;case"acc":return e.kind==="t"?t.value(e.test):e.kind==="testPass"?t.testPass(e.test):t.specPass(e.test);case"diePass":return t.diePass();case"vec":return;case"unary":{const n=evaluate(e.arg,t);return n===void 0?void 0:e.op==="-"?s(-n):!n}case"binary":{const n=evaluate(e.left,t);if(n===void 0)return;const r=evaluate(e.right,t);if(r===void 0)return;switch(e.op){case"+":return s(n+r);case"-":return s(n-r);case"*":return s(n*r);case"/":return s(n/r);case"%":return s(n%r);case"^":return s(Math.pow(n,r));case"<":return n<r;case"<=":return n<=r;case">":return n>r;case">=":return n>=r;case"==":return n===r;case"!=":return n!==r;case"and":return n&&r;case"or":return n||r}return}case"call":{if(e.name==="if"){const u=evaluate(e.args[0],t);return u===void 0?void 0:evaluate(e.args[u?1:2],t)}const n=e.args[0];if(e.args.length===1&&n!==void 0&&n.k==="vec")return o(e.name,l(n,t));const r=d[e.name];if(r===void 0)return;const a=[];for(const u of e.args){const i=evaluate(u,t);if(i===void 0)return;a.push(i)}return s(r(a))}}}

package/dist/packages/renderer/derivedTests/parser.d.ts

@@ -0,0 +1,148 @@
+/**
+ * Expression parser for derived tests.
+ *
+ * Deliberately hand-written and dependency-free. A general-purpose expression
+ * library (mathjs, expr-eval) would be the only security boundary between a
+ * shared `.json` template and the host application, and would have to be trusted
+ * to contain no path back to `Function`/`eval`. This grammar is closed: the only
+ * identifiers that resolve are the caller's own declared constants, the only data
+ * reachable is the die being evaluated, and there is no member access, no
+ * assignment, no indexing by anything but an integer literal, and no way to name
+ * a host object. Nothing in the AST can express a call to something not in
+ * `FUNCTIONS` below.
+ *
+ * Grammar (recursive descent, standard precedence):
+ *
+ * ```
+ *   expr     := or
+ *   or       := and ('or' and)*
+ *   and      := not ('and' not)*
+ *   not      := 'not' not | compare
+ *   compare  := add (('<' | '<=' | '>' | '>=' | '==' | '!=') add)?
+ *   add      := mul (('+' | '-') mul)*
+ *   mul      := pow (('*' | '/' | '%') pow)*
+ *   pow      := unary ('^' pow)?                      // right-associative
+ *   unary    := '-' unary | primary
+ *   primary  := NUMBER | IDENT | call | accessor | '(' expr ')'
+ *   accessor := ('t' | 'testPass' | 'specPass') '[' INT ('..' INT)? ']'
+ *   call     := IDENT '(' (expr (',' expr)*)? ')'
+ * ```
+ *
+ * The one non-scalar path: a range accessor (`t[1010..1015]`) produces a VECTOR,
+ * and a vector may ONLY be consumed by a reducer. There is no vector arithmetic,
+ * no elementwise operator and no vector-valued constant — which is what stops
+ * this grammar drifting into an array language.
+ */
+import type { TestDef } from '../buildWaferMap.js';
+/** Static type of an expression node. Checked at parse time, so a type error is
+ *  a build warning with a position rather than a runtime surprise on one die. */
+export type ExprType = 'number' | 'boolean' | 'numberVec' | 'boolVec';
+/** Which per-die quantity an accessor reads. Mirrors `passFailDisplay`'s
+ *  vocabulary exactly: `'test'` is the tester's recorded verdict, `'spec'` is the
+ *  spec-limit judgement. `t` is the measured value itself. */
+export type AccessorKind = 't' | 'testPass' | 'specPass';
+export type ExprNode = {
+    k: 'num';
+    value: number;
+} | {
+    k: 'acc';
+    kind: AccessorKind;
+    test: number;
+} | {
+    k: 'vec';
+    kind: AccessorKind;
+    tests: number[];
+} | {
+    k: 'diePass';
+} | {
+    k: 'unary';
+    op: '-' | 'not';
+    arg: ExprNode;
+} | {
+    k: 'binary';
+    op: BinaryOp;
+    left: ExprNode;
+    right: ExprNode;
+} | {
+    k: 'call';
+    name: string;
+    args: ExprNode[];
+};
+export type BinaryOp = '+' | '-' | '*' | '/' | '%' | '^' | '<' | '<=' | '>' | '>=' | '==' | '!=' | 'and' | 'or';
+export interface ParseOk {
+    ok: true;
+    ast: ExprNode;
+    type: ExprType;
+    /** Every test number the expression reads, for dependency and validity checks. */
+    reads: {
+        kind: AccessorKind;
+        test: number;
+    }[];
+    /** True when the expression consults the die's bin-based pass verdict. */
+    usesDiePass: boolean;
+}
+export interface ParseErr {
+    ok: false;
+    /** Human-readable, already naming the position. */
+    message: string;
+    /** 0-based character offset in the source expression. */
+    position: number;
+}
+export type ParseResult = ParseOk | ParseErr;
+export interface ParseContext {
+    /** Tests the expression may reference — the *source* defs only. A derived test
+     *  referencing another derived test is rejected: chaining needs a dependency
+     *  sort and a cycle check, which is a later feature, not a first one. */
+    testDefs: Map<number, TestDef>;
+    /** Caller-declared named constants. These are the ONLY resolvable identifiers
+     *  besides function names, and they are substituted at parse time. */
+    constants: Record<string, number>;
+}
+/** Argument spec for a whitelisted function. `vec` accepts either vector type
+ *  unless narrowed by `vecOf`. */
+interface FnSpec {
+    /** Fixed scalar arity, when the function takes numbers. */
+    arity?: number;
+    /** Variadic scalar form, e.g. `min(a, b, c)`. */
+    variadic?: boolean;
+    /** Reducer form: takes exactly one vector of this type. */
+    vecOf?: 'numberVec' | 'boolVec' | 'any';
+    /** Result type. */
+    returns: ExprType;
+}
+/**
+ * The complete set of callable names. Scalar maths plus the vector reducers.
+ *
+ * `min`/`max` are the only overloaded names: `min(a, b)` over scalars and
+ * `min(t[1010..1015])` over a vector. Both mean the same thing, so one name is
+ * right; the parser picks the form from the argument types.
+ */
+export declare const FUNCTIONS: Record<string, FnSpec[]>;
+/**
+ * Parse and statically type-check one derived-test expression.
+ *
+ * Never throws: a malformed expression comes back as `{ ok: false }` with a
+ * message and a character position, which `buildWaferMap` turns into a
+ * `derived-test-invalid` warning. The derived test is then dropped rather than
+ * evaluated — a half-working expression would silently plot wrong numbers.
+ */
+export declare function parseExpression(source: string, ctx: ParseContext): ParseResult;
+export type TestReferenceResult = {
+    ok: true;
+    tests: number[];
+    range: boolean;
+} | ParseErr;
+/**
+ * Parse a standalone test reference — `"1020"` or `"1010..1030"` — with exactly
+ * the lexer and range rule an expression's `t[…]` uses. This is how a sweep's
+ * `tests` accepts ranges: the syntax is shared, never re-implemented, so the
+ * same text can never mean different tests in the two places.
+ *
+ * Never throws.
+ */
+export declare function parseTestReference(source: string, testDefs: Map<number, TestDef>): TestReferenceResult;
+/** Bound on source length. A shared template is untrusted input; an expression
+ *  longer than this is a mistake or an attack, not a measurement. */
+export declare const MAX_EXPRESSION_LENGTH = 2000;
+export {};
+//# sourceMappingURL=parser.d.ts.map

package/dist/packages/renderer/derivedTests/parser.js

@@ -0,0 +1,2 @@
+import{isParametricTest as c}from"../buildWaferMap.js";import{hasSpecLimits as l}from"../spec.js";export const FUNCTIONS={abs:[{arity:1,returns:"number"}],sqrt:[{arity:1,returns:"number"}],ln:[{arity:1,returns:"number"}],log10:[{arity:1,returns:"number"}],exp:[{arity:1,returns:"number"}],floor:[{arity:1,returns:"number"}],ceil:[{arity:1,returns:"number"}],round:[{arity:1,returns:"number"}],sign:[{arity:1,returns:"number"}],pow:[{arity:2,returns:"number"}],min:[{vecOf:"numberVec",returns:"number"},{variadic:!0,returns:"number"}],max:[{vecOf:"numberVec",returns:"number"},{variadic:!0,returns:"number"}],if:[{arity:3,returns:"number"}],all:[{vecOf:"boolVec",returns:"boolean"}],any:[{vecOf:"boolVec",returns:"boolean"}],none:[{vecOf:"boolVec",returns:"boolean"}],countTrue:[{vecOf:"boolVec",returns:"number"}],countFalse:[{vecOf:"boolVec",returns:"number"}],mean:[{vecOf:"numberVec",returns:"number"}],sum:[{vecOf:"numberVec",returns:"number"}],countKnown:[{vecOf:"any",returns:"number"}]};const d=["t","testPass","specPass"],m=["<=",">=","==","!=","..","+","-","*","/","%","^","<",">"],b=["(",")","[","]",","];class o extends Error{position;constructor(t,e){super(t),this.position=e}}function h(r){const t=[];let e=0;for(;e<r.length;){const n=r[e];if(n===" "||n==="	"||n===`
+`||n==="\r"){e++;continue}if(n>="0"&&n<="9"){const s=e;for(;e<r.length&&r[e]>="0"&&r[e]<="9";)e++;if(r[e]==="."&&r[e+1]!==".")for(e++;e<r.length&&r[e]>="0"&&r[e]<="9";)e++;if(r[e]==="e"||r[e]==="E"){const a=e;if(e++,(r[e]==="+"||r[e]==="-")&&e++,r[e]>="0"&&r[e]<="9")for(;e<r.length&&r[e]>="0"&&r[e]<="9";)e++;else e=a}const u=r.slice(s,e);t.push({kind:"num",text:u,pos:s,value:Number(u)});continue}if(/[A-Za-z_]/.test(n)){const s=e;for(;e<r.length&&/[A-Za-z0-9_]/.test(r[e]);)e++;t.push({kind:"ident",text:r.slice(s,e),pos:s});continue}const i=m.find(s=>r.startsWith(s,e));if(i){t.push({kind:"op",text:i,pos:e}),e+=i.length;continue}if(b.includes(n)){t.push({kind:"punc",text:n,pos:e}),e++;continue}throw new o(`Unexpected character ${JSON.stringify(n)} at position ${e}`,e)}return t.push({kind:"eof",text:"",pos:r.length}),t}class f{toks;ctx;p=0;reads=[];usesDiePass=!1;constructor(t,e){this.toks=t,this.ctx=e}peek(){return this.toks[this.p]}next(){return this.toks[this.p++]}at(t){const e=this.peek();return(e.kind==="op"||e.kind==="punc"||e.kind==="ident")&&e.text===t}eat(t){return this.at(t)?(this.p++,!0):!1}expect(t){if(!this.at(t)){const e=this.peek();throw new o(`Expected ${JSON.stringify(t)} but found ${e.kind==="eof"?"end of expression":JSON.stringify(e.text)} at position ${e.pos}`,e.pos)}return this.next()}parse(){const t=this.parseOr();return this.expectEnd(),t}parseTestRefOnly(){const t=this.parseTestRef(this.peek().pos);return this.expectEnd(),t}expectEnd(){const t=this.peek();if(t.kind!=="eof")throw new o(`Unexpected ${JSON.stringify(t.text)} at position ${t.pos}`,t.pos)}requireScalar(t,e,n){if(t.type==="numberVec"||t.type==="boolVec")throw new o(`${e} cannot be applied to a test range at position ${n} \u2014 a range must be reduced first, e.g. mean(t[1010..1015]) or all(testPass[1010..1015])`,n);return t.type}parseOr(){let t=this.parseAnd();for(;this.at("or");){const e=this.next().pos,n=this.parseAnd();this.requireBool(t,"or",e),this.requireBool(n,"or",e),t={node:{k:"binary",op:"or",left:t.node,right:n.node},type:"boolean"}}return t}parseAnd(){let t=this.parseNot();for(;this.at("and");){const e=this.next().pos,n=this.parseNot();this.requireBool(t,"and",e),this.requireBool(n,"and",e),t={node:{k:"binary",op:"and",left:t.node,right:n.node},type:"boolean"}}return t}requireBool(t,e,n){if(this.requireScalar(t,`Operator ${JSON.stringify(e)}`,n),t.type!=="boolean")throw new o(`Operator ${JSON.stringify(e)} needs a true/false operand at position ${n}, but got a number \u2014 compare it first, e.g. t[1020] > 5`,n)}parseNot(){if(this.at("not")){const t=this.next().pos,e=this.parseNot();return this.requireBool(e,"not",t),{node:{k:"unary",op:"not",arg:e.node},type:"boolean"}}return this.parseCompare()}parseCompare(){const t=this.parseAdd(),e=this.peek();if(e.kind==="op"&&["<","<=",">",">=","==","!="].includes(e.text)){this.next();const n=this.parseAdd(),i=this.requireScalar(t,`Operator ${JSON.stringify(e.text)}`,e.pos),s=this.requireScalar(n,`Operator ${JSON.stringify(e.text)}`,e.pos);if(i!==s)throw new o(`Cannot compare a ${i} with a ${s} at position ${e.pos}`,e.pos);if(i==="boolean"&&e.text!=="=="&&e.text!=="!=")throw new o(`Operator ${JSON.stringify(e.text)} cannot order true/false values at position ${e.pos}`,e.pos);return{node:{k:"binary",op:e.text,left:t.node,right:n.node},type:"boolean"}}return t}parseAdd(){let t=this.parseMul();for(;;){const e=this.peek();if(e.kind!=="op"||e.text!=="+"&&e.text!=="-")return t;this.next();const n=this.parseMul();this.requireNum(t,e.text,e.pos),this.requireNum(n,e.text,e.pos),t={node:{k:"binary",op:e.text,left:t.node,right:n.node},type:"number"}}}parseMul(){let t=this.parsePow();for(;;){const e=this.peek();if(e.kind!=="op"||!["*","/","%"].includes(e.text))return t;this.next();const n=this.parsePow();this.requireNum(t,e.text,e.pos),this.requireNum(n,e.text,e.pos),t={node:{k:"binary",op:e.text,left:t.node,right:n.node},type:"number"}}}parsePow(){const t=this.parseUnary(),e=this.peek();if(e.kind==="op"&&e.text==="^"){this.next();const n=this.parsePow();return this.requireNum(t,"^",e.pos),this.requireNum(n,"^",e.pos),{node:{k:"binary",op:"^",left:t.node,right:n.node},type:"number"}}return t}requireNum(t,e,n){if(this.requireScalar(t,`Operator ${JSON.stringify(e)}`,n),t.type!=="number")throw new o(`Operator ${JSON.stringify(e)} needs a numeric operand at position ${n}, but got a true/false value`,n)}parseUnary(){const t=this.peek();if(t.kind==="op"&&t.text==="-"){this.next();const e=this.parseUnary();return this.requireNum(e,"-",t.pos),{node:{k:"unary",op:"-",arg:e.node},type:"number"}}return this.parsePrimary()}parsePrimary(){const t=this.next();if(t.kind==="num")return{node:{k:"num",value:t.value},type:"number"};if(t.kind==="punc"&&t.text==="("){const e=this.parseOr();return this.expect(")"),e}if(t.kind==="ident"){if(d.includes(t.text))return this.parseAccessor(t.text,t.pos);if(t.text==="diePass")return this.expect("("),this.expect(")"),this.usesDiePass=!0,{node:{k:"diePass"},type:"boolean"};if(this.at("("))return this.parseCall(t.text,t.pos);if(Object.prototype.hasOwnProperty.call(this.ctx.constants,t.text)){const e=this.ctx.constants[t.text];if(typeof e!="number"||!Number.isFinite(e))throw new o(`Constant ${JSON.stringify(t.text)} at position ${t.pos} is not a finite number`,t.pos);return{node:{k:"num",value:e},type:"number"}}throw new o(`Unknown name ${JSON.stringify(t.text)} at position ${t.pos}. Test values are read as t[1020], verdicts as testPass[1020] or specPass[1020]; other names must be declared in \`constants\`.`,t.pos)}throw new o(`Unexpected ${t.kind==="eof"?"end of expression":JSON.stringify(t.text)} at position ${t.pos}`,t.pos)}parseAccessor(t,e){this.expect("[");const{tests:n,range:i}=this.parseTestRef(e);this.expect("]");for(const u of n)this.checkAccessible(t,u,e);for(const u of n)this.reads.push({kind:t,test:u});const s=t==="t"?"number":"boolean";return i?{node:{k:"vec",kind:t,tests:n},type:s==="number"?"numberVec":"boolVec"}:{node:{k:"acc",kind:t,test:n[0]},type:s}}checkAccessible(t,e,n){const i=this.ctx.testDefs.get(e);if(i===void 0)throw new o(`Test ${e} at position ${n} is not declared in \`testDefs\``,n);if(t==="t"&&!c(i))throw new o(`t[${e}] at position ${n} reads a measured value, but test ${e} is functional (testType 'F') and has no measured value \u2014 use testPass[${e}] for its verdict`,n);if(t==="specPass"){if(!c(i))throw new o(`specPass[${e}] at position ${n} needs test limits, but test ${e} is functional (testType 'F') \u2014 use testPass[${e}] for its recorded verdict`,n);if(!l(i))throw new o(`specPass[${e}] at position ${n} needs \`limitLow\` or \`limitHigh\` on test ${e}, which declares neither`,n)}}parseTestRef(t){const e=this.expectInt();if(!this.eat(".."))return{tests:[e],range:!1};const n=this.expectInt();if(n<e)throw new o(`Test range ${e}..${n} at position ${t} runs backwards`,t);const i=[...this.ctx.testDefs.keys()].filter(s=>s>=e&&s<=n).sort((s,u)=>s-u);if(i.length===0)throw new o(`Test range ${e}..${n} at position ${t} matches no declared test`,t);return{tests:i,range:!0}}expectInt(){const t=this.peek();if(t.kind!=="num"||!Number.isInteger(t.value))throw new o(`Expected a test number at position ${t.pos}`,t.pos);return this.next(),t.value}parseCall(t,e){const n=FUNCTIONS[t];if(n===void 0)throw new o(`Unknown function ${JSON.stringify(t)} at position ${e}. Available: ${Object.keys(FUNCTIONS).sort().join(", ")}`,e);this.expect("(");const i=[];if(!this.at(")"))do i.push(this.parseOr());while(this.eat(","));this.expect(")");const s=i.map(a=>a.type),u={k:"call",name:t,args:i.map(a=>a.node)};for(const a of n){if(a.vecOf!==void 0){if(s.length!==1)continue;const p=s[0];if(!(p==="numberVec"||p==="boolVec")||a.vecOf!=="any"&&a.vecOf!==p)continue;return{node:u,type:a.returns}}if(a.variadic){if(s.length<2||!s.every(p=>p==="number"))continue;return{node:u,type:a.returns}}if(a.arity!==void 0){if(s.length!==a.arity)continue;if(t==="if"){if(s[0]!=="boolean"||s[1]!=="number"||s[2]!=="number")continue;return{node:u,type:"number"}}if(!s.every(p=>p==="number"))continue;return{node:u,type:a.returns}}}throw new o(`${t}(${s.join(", ")}) at position ${e} is not a valid call \u2014 ${y(t,n)}`,e)}}function y(r,t){return`expected ${t.map(n=>n.vecOf==="boolVec"?`${r}(<true/false test range>)`:n.vecOf==="numberVec"?`${r}(<value test range>)`:n.vecOf==="any"?`${r}(<test range>)`:n.variadic?`${r}(number, number, \u2026)`:r==="if"?"if(<true/false>, number, number)":`${r}(${Array.from({length:n.arity??0},()=>"number").join(", ")})`).join(" or ")}`}export function parseExpression(r,t){try{if(r.length>MAX_EXPRESSION_LENGTH)return{ok:!1,message:`Expression is ${r.length} characters, over the ${MAX_EXPRESSION_LENGTH} limit`,position:MAX_EXPRESSION_LENGTH};const e=new f(h(r),t),{node:n,type:i}=e.parse();return i==="numberVec"||i==="boolVec"?{ok:!1,message:"Expression results in a test range, not a single value \u2014 reduce it, e.g. mean(t[1010..1015]) or all(testPass[1010..1015])",position:0}:{ok:!0,ast:n,type:i,reads:e.reads,usesDiePass:e.usesDiePass}}catch(e){if(e instanceof o)return{ok:!1,message:e.message,position:e.position};throw e}}export function parseTestReference(r,t){try{if(r.length>MAX_EXPRESSION_LENGTH)return{ok:!1,message:`Test reference is ${r.length} characters, over the ${MAX_EXPRESSION_LENGTH} limit`,position:MAX_EXPRESSION_LENGTH};const{tests:e,range:n}=new f(h(r),{testDefs:t,constants:{}}).parseTestRefOnly();return{ok:!0,tests:e,range:n}}catch(e){if(e instanceof o)return{ok:!1,message:e.message,position:e.position};throw e}}export const MAX_EXPRESSION_LENGTH=2e3;

package/dist/packages/renderer/fmt.d.ts

@@ -1,3 +1,8 @@
+/** Multiplier per SI prefix letter. Exported for the one place that PARSES a
+ *  prefixed number (`stats/sweepXFromName.ts`), so reading and printing values
+ *  agree on every prefix. Internal — not re-exported from the package. */
+export declare const SI_PREFIX_SCALE: Record<string, number>;
+export declare const KNOWN_BASE_UNITS: string[];
 /**
  * Plain-language labels for lot-stack aggregation methods. Maps internal API terms to the words
  * shown to the user (e.g. `countBin` → "occurrence count"). Shared by the canvas map title and the
@@ -23,8 +28,25 @@ export declare function plainBinTerms(text: string): string;
  *   engineering notation (E±N, multiples of 3) outside that range.
  */
 export declare function fmt(v: number, unit?: string, fallbackFormat?: 'si' | 'engineering'): string;
-export declare function fmtColorbarAxis(vRef: number, name: string | null | undefined, unit: string | undefined, fallbackFormat?: 'si' | 'engineering'): {
+export interface AxisFormat {
+    /** A tick label: a bare number in the axis's shared scale. */
     tickFmt: (v: number) => string;
+    /** A data value at an axis end (not on the tick grid) — see `makeEdgeFormatter`. */
+    edgeFmt: (v: number) => string;
+    /** Name plus scaled unit, shown once for the axis — e.g. `"Idsat (mA)"`. */
     axisLabel: string;
-};
+    /** The scaled unit alone (`"mA"`), for an axis that prints it on every tick; `''` when none. */
+    scaledUnit: string;
+}
+/**
+ * The formatting for one numeric axis: a shared SI scale chosen from `vRef`
+ * (typically the largest-magnitude value), applied to every tick so the axis
+ * reads consistently, with the scaled unit returned once.
+ *
+ * Pass `step` — the spacing of the ticks, from `fitTicks` (`axisTicks.ts`) —
+ * for a tick grid. Omit it for lone values, which keep size-based decimals.
+ * Without a unit, values in [0.1, 9999] are unscaled and, with no step, use
+ * `fmt()` as before.
+ */
+export declare function fmtColorbarAxis(vRef: number, name: string | null | undefined, unit: string | undefined, fallbackFormat?: 'si' | 'engineering', step?: number): AxisFormat;
 //# sourceMappingURL=fmt.d.ts.map

package/dist/packages/renderer/fmt.js

@@ -1 +1 @@
-const p=[[1e12,"T"],[1e9,"G"],[1e6,"M"],[1e3,"k"],[1,""],[.001,"m"],[1e-6,"\xB5"],[1e-9,"n"],[1e-12,"p"],[1e-15,"f"]],g={T:1e12,G:1e9,M:1e6,k:1e3,m:.001,\u00B5:1e-6,u:1e-6,n:1e-9,p:1e-12,f:1e-15},E=["Hz","V","A","W","F","\u03A9","Ohm","S","H","J","C","s"];function m(t){for(const e of E)if(t.length===e.length+1&&t.endsWith(e)){const s=t[0];if(s in g)return{preScale:g[s],base:e}}return{preScale:1,base:t}}function F(t,e){const{preScale:s,base:n}=m(e),o=t*s,i=Math.abs(o),[r,u]=p.find(([f])=>i>=f*.9999)??[1e-15,"f"],a=o/r,l=Math.abs(a),c=l>=100?0:l>=10?1:2;return`${a.toFixed(c)} ${u}${n}`}function A(t){const e=Math.abs(t),s=Math.floor(Math.log10(e)/3)*3,n=Math.max(-15,Math.min(12,s)),o=t/Math.pow(10,n),i=Math.abs(o),r=i>=100?0:i>=10?1:2,u=n===0?"":`E${n>0?"+":""}${n}`;return`${o.toFixed(r)}${u}`}export const AGGREGATION_METHOD_LABELS={mean:"mean",median:"median",stddev:"std dev",min:"min",max:"max",count:"count",countBin:"occurrence count",percent:"occurrence %"};export function fmtAggregationMethod(t){return AGGREGATION_METHOD_LABELS[t??""]??t??"aggregated"}export function plainBinTerms(t){return t.replace(/\bHBin\b/g,"hard bin").replace(/\bSBin\b/g,"soft bin")}export function fmt(t,e,s){if(!isFinite(t))return String(t);const n=Math.abs(t);return n===0?e?`0 ${e}`:"0":e!==void 0?F(t,e):s==="si"?F(t,""):n>=.1&&n<1e4?n>=1e3?t.toFixed(0):n>=100?t.toFixed(1):n>=10?t.toFixed(2):t.toFixed(3):A(t)}function h(t){return e=>{if(!isFinite(e))return String(e);if(e===0)return"0";const s=e/t,n=Math.abs(s),o=n>=100?0:n>=10?1:2;return s.toFixed(o)}}export function fmtColorbarAxis(t,e,s,n="engineering"){const o=Math.abs(t);if(s){const{preScale:c,base:f}=m(s),d=o*c,[b,x]=d===0?[1,""]:p.find(([S])=>d>=S*.9999)??[1e-15,"f"],M=`${x}${f}`,$=e?`${e} (${M})`:M;return{tickFmt:h(b/c),axisLabel:$}}if(o===0||o>=.1&&o<1e4)return{tickFmt:c=>fmt(c,void 0,n),axisLabel:e??""};if(n==="si"){const[c]=p.find(([x])=>o>=x*.9999)??[1e-15,"f"],f=Math.round(Math.log10(c)),d=f===0?"":`\xD710E${f}`,b=e?d?`${e} (${d})`:e:d;return{tickFmt:h(c),axisLabel:b}}const i=Math.floor(Math.log10(o)/3)*3,r=Math.max(-15,Math.min(12,i)),u=Math.pow(10,r),a=r===0?"":`\xD710E${r}`,l=e?a?`${e} (${a})`:e:a;return{tickFmt:h(u),axisLabel:l}}
+import{stepDecimals as m}from"./axisTicks.js";const g=[[1e12,"T"],[1e9,"G"],[1e6,"M"],[1e3,"k"],[1,""],[.001,"m"],[1e-6,"\xB5"],[1e-9,"n"],[1e-12,"p"],[1e-15,"f"]];export const SI_PREFIX_SCALE={T:1e12,G:1e9,M:1e6,k:1e3,m:.001,\u00B5:1e-6,u:1e-6,n:1e-9,p:1e-12,f:1e-15},KNOWN_BASE_UNITS=["Hz","V","A","W","F","\u03A9","Ohm","ohm","S","H","J","C","s"];function M(e){for(const t of KNOWN_BASE_UNITS)if(e.length===t.length+1&&e.endsWith(t)){const i=e[0];if(i in SI_PREFIX_SCALE)return{preScale:SI_PREFIX_SCALE[i],base:t}}return{preScale:1,base:e}}function F(e,t){const{preScale:i,base:n}=M(t),r=e*i,o=Math.abs(r),[c,b]=g.find(([s])=>o>=s*.9999)??[1e-15,"f"],f=r/c,h=Math.abs(f),d=h>=100?0:h>=10?1:2;return`${f.toFixed(d)} ${b}${n}`}function S(e){const t=Math.abs(e),i=Math.floor(Math.log10(t)/3)*3,n=Math.max(-15,Math.min(12,i)),r=e/Math.pow(10,n),o=Math.abs(r),c=o>=100?0:o>=10?1:2,b=n===0?"":`E${n>0?"+":""}${n}`;return`${r.toFixed(c)}${b}`}export const AGGREGATION_METHOD_LABELS={mean:"mean",median:"median",stddev:"std dev",min:"min",max:"max",count:"count",countBin:"occurrence count",percent:"occurrence %"};export function fmtAggregationMethod(e){return AGGREGATION_METHOD_LABELS[e??""]??e??"aggregated"}export function plainBinTerms(e){return e.replace(/\bHBin\b/g,"hard bin").replace(/\bSBin\b/g,"soft bin")}export function fmt(e,t,i){if(!isFinite(e))return String(e);const n=Math.abs(e);return n===0?t?`0 ${t}`:"0":t!==void 0?F(e,t):i==="si"?F(e,""):n>=.1&&n<1e4?n>=1e3?e.toFixed(0):n>=100?e.toFixed(1):n>=10?e.toFixed(2):e.toFixed(3):S(e)}function E(e,t){const i=t!==void 0&&t>0?m(t/e):void 0;return n=>{if(!isFinite(n))return String(n);if(n===0)return"0";const r=n/e;if(i!==void 0)return r.toFixed(i);const o=Math.abs(r),c=o>=100?0:o>=10?1:2;return r.toFixed(c)}}function A(e,t,i){if(t===void 0||!(t>0))return i;const n=m(t/e)+1;return r=>{if(!isFinite(r))return String(r);if(r===0)return"0";const o=(r/e).toFixed(n);return o.endsWith("0")?o.slice(0,n===1?-2:-1):o}}export function fmtColorbarAxis(e,t,i,n="engineering",r){const o=Math.abs(e),c=(s,u,a,x)=>{const l=x&&r===void 0?x:E(s,r);return{tickFmt:l,edgeFmt:A(s,r,l),axisLabel:u,scaledUnit:a}};if(i){const{preScale:s,base:u}=M(i),a=o*s,[x,l]=a===0?[1,""]:g.find(([$])=>a>=$*.9999)??[1e-15,"f"],p=`${l}${u}`;return c(x/s,t?`${t} (${p})`:p,p)}if(o===0||o>=.1&&o<1e4)return c(1,t??"","",s=>fmt(s,void 0,n));if(n==="si"){const[s]=g.find(([x])=>o>=x*.9999)??[1e-15,"f"],u=Math.round(Math.log10(s)),a=u===0?"":`\xD710E${u}`;return c(s,t?a?`${t} (${a})`:t:a,a)}const b=Math.floor(Math.log10(o)/3)*3,f=Math.max(-15,Math.min(12,b)),h=Math.pow(10,f),d=f===0?"":`\xD710E${f}`;return c(h,t?d?`${t} (${d})`:t:d,d)}

package/dist/packages/renderer/index.d.ts

@@ -5,5 +5,6 @@ export type { WaferMetadata, DieMetadata } from '../core/metadata.js';
 export * from './colorSchemes.js';
 export type { BinColors, BinColorOptions, BinColorSource, MapBinColorOptions } from './binColors.js';
 export { binColorsForMaps } from './binColors.js';
+export { DERIVED_MARK, DERIVED_KEY } from './testLabel.js';
 export { valueToViridis, valueToGreyscale, getValueColorScheme, buildView, buildHoverText, buildMapTitle, resolveBinColors, getBinColorScheme, contrastTextColor, dieHasTestData, isParametricTest, getDieTestValue, STANDARD_WAFER_DIAMETERS_MM, } from './deprecated.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/packages/renderer/index.js

@@ -1 +1 @@
-export{getDieKey}from"./buildView.js";export*from"./buildWaferMap.js";export*from"./colorSchemes.js";export{binColorsForMaps}from"./binColors.js";export{valueToViridis,valueToGreyscale,getValueColorScheme,buildView,buildHoverText,buildMapTitle,resolveBinColors,getBinColorScheme,contrastTextColor,dieHasTestData,isParametricTest,getDieTestValue,STANDARD_WAFER_DIAMETERS_MM}from"./deprecated.js";
+export{getDieKey}from"./buildView.js";export*from"./buildWaferMap.js";export*from"./colorSchemes.js";export{binColorsForMaps}from"./binColors.js";export{DERIVED_MARK,DERIVED_KEY}from"./testLabel.js";export{valueToViridis,valueToGreyscale,getValueColorScheme,buildView,buildHoverText,buildMapTitle,resolveBinColors,getBinColorScheme,contrastTextColor,dieHasTestData,isParametricTest,getDieTestValue,STANDARD_WAFER_DIAMETERS_MM}from"./deprecated.js";

package/dist/packages/renderer/spec.d.ts

@@ -0,0 +1,66 @@
+/**
+ * The single spec-limit judgement in the library: "is this measured value within
+ * the test's limits?"
+ *
+ * Every surface that shows or counts an out-of-spec die reads this — value-mode
+ * die fills and ▽/△ markers (`buildView`), the legend's spec tally, the spec
+ * pass-rate tables (`stats/testPassRate.ts`), and the `specPass[n]` accessor in
+ * derived-test expressions. It previously existed twice, once here and once in
+ * `testPassRate.ts`, and the two disagreed on both edge cases below.
+ *
+ * Two rules, and both are the *strict* reading:
+ *
+ * 1. **No limits defined ⇒ `null` (no judgement).** A test with no limits has not
+ *    been given a spec, so there is nothing to be inside of. Reporting `'pass'`
+ *    would manufacture an in-spec verdict out of an absence, and it would inflate
+ *    a spec pass-rate to 100% for every unlimited test.
+ * 2. **A non-finite value ⇒ `null`.** `NaN` is not in spec. Comparison operators
+ *    are false for `NaN`, so a naive `v < low` / `v > high` pair falls through to
+ *    "pass" — which is exactly the "never drawn as plain in-spec" failure this
+ *    judgement exists to prevent.
+ *
+ * `null` means no verdict and must be treated as no-data by every caller, never
+ * as a pass and never as a fail.
+ *
+ * A value exactly equal to a limit passes unless the test says otherwise
+ * (`limitLowInclusive`/`limitHighInclusive: false`, which STDF's `PARM_FLG` bits
+ * 6/7 and ATDF's Limit Compare letters state per test).
+ *
+ * Out-of-spec *classification* depends ONLY on whether limits are defined — never on
+ * `colorbarRangeMode`. An out-of-spec die is always flagged when limits exist, regardless
+ * of how the colorbar is scaled. The *form* of the indication, decided in
+ * `pushDieRectangles`, depends only on the effective `passFailDisplay`: under `'spec'` the
+ * die gets a solid green/blue/red categorical fill; in normal value/gradient mode it keeps
+ * the value gradient fill (so the distribution stays readable and out-of-spec colours don't
+ * collide with the scheme) and is flagged with a ▽/△ marker (`ViewRect.specMark`).
+ */
+export type SpecCategory = 'pass' | 'failHigh' | 'failLow';
+/** Just the fields of a `TestDef` this judgement reads — kept structural so
+ *  `core/` and `stats/` can call it without importing the full def. */
+export interface SpecLimits {
+    limitLow?: number;
+    limitHigh?: number;
+    /** A value equal to `limitLow` passes. Default `true`; STDF `PARM_FLG` bit 6. */
+    limitLowInclusive?: boolean;
+    /** A value equal to `limitHigh` passes. Default `true`; STDF `PARM_FLG` bit 7. */
+    limitHighInclusive?: boolean;
+}
+/**
+ * Classify `value` against `limits`. Returns `null` when no verdict is possible:
+ * no value, a non-finite value, or a test with neither limit defined.
+ */
+export declare function classifySpec(value: number | undefined, limits: SpecLimits | undefined): SpecCategory | null;
+/** True for a verdict that is outside the limits. */
+export declare function isOutOfSpec(category: SpecCategory | null): boolean;
+/**
+ * How many values in an ascending, finite array `classifySpec` would judge out of
+ * spec — the same rule, counted by binary search instead of one call per value,
+ * for callers that already hold the values sorted. `tests/specLimits.test.mjs`
+ * holds the two in agreement.
+ */
+export declare function countOutOfSpecSorted(sorted: ArrayLike<number>, limits: SpecLimits): number;
+/** True when `limits` can produce a verdict at all — i.e. at least one limit is
+ *  defined. Used to reject `specPass[n]` at parse time rather than silently
+ *  yielding no-data for every die. */
+export declare function hasSpecLimits(limits: SpecLimits | undefined): boolean;
+//# sourceMappingURL=spec.d.ts.map

package/dist/packages/renderer/spec.js

@@ -0,0 +1 @@
+export function classifySpec(i,n){return i===void 0||!Number.isFinite(i)||n===void 0||n.limitLow===void 0&&n.limitHigh===void 0?null:n.limitLow!==void 0&&(n.limitLowInclusive===!1?i<=n.limitLow:i<n.limitLow)?"failLow":n.limitHigh!==void 0&&(n.limitHighInclusive===!1?i>=n.limitHigh:i>n.limitHigh)?"failHigh":"pass"}export function isOutOfSpec(i){return i==="failLow"||i==="failHigh"}export function countOutOfSpecSorted(i,n){let u=0,h=0;if(n.limitLow!==void 0){const l=n.limitLow,o=n.limitLowInclusive===!1?e=>e<=l:e=>e<l;let f=0,t=i.length;for(;f<t;){const e=f+t>>1;o(i[e])?f=e+1:t=e}u=f}if(n.limitHigh!==void 0){const l=n.limitHigh,o=n.limitHighInclusive===!1?e=>e<l:e=>e<=l;let f=0,t=i.length;for(;f<t;){const e=f+t>>1;o(i[e])?f=e+1:t=e}h=i.length-Math.max(f,u)}return u+h}export function hasSpecLimits(i){return i!==void 0&&(i.limitLow!==void 0||i.limitHigh!==void 0)}

package/dist/packages/renderer/testLabel.d.ts

@@ -0,0 +1,154 @@
+import type { TestDef } from './buildWaferMap.js';
+/**
+ * The derived-test part of anything that describes a test: a `TestDef`, or a
+ * narrower record carried onward from one — a finding's `variable`, a
+ * capability row. Structural, so every such shape is read by the same helpers.
+ */
+export type DerivedSource = {
+    derived?: true;
+    expression?: string;
+} | undefined;
+/**
+ * Marks a test name as derived rather than measured.
+ *
+ * A dagger rather than the obvious `ƒ`: in this domain `f` is femto, and a `ƒ`
+ * beside a column of `fA`/`fF` units is a genuine misread. The dagger collides
+ * with no unit and no operator, and already means "see the note" — which is the
+ * contract: wherever the glyph can appear, {@link DERIVED_KEY} appears with it.
+ */
+export declare const DERIVED_MARK = "\u2020";
+/**
+ * What {@link DERIVED_MARK} means, in words — the key every marked surface shows.
+ *
+ * Short on purpose: it has to fit the lower-right corner of a map beside the
+ * colorbar as well as a legend, and one string everywhere cannot drift. What a
+ * value was computed FROM is the expression, which tooltips show alongside it.
+ */
+export declare const DERIVED_KEY = "Derived, not measured";
+/**
+ * True when this def describes a test computed from other tests rather than
+ * measured by the tester. Reads the flag `buildWaferMap` stamps on the defs it
+ * admits from `derivedTests` — never infers it from the test number, which is
+ * an application-defined identifier carrying no such meaning.
+ */
+export declare function isDerivedTest(def: DerivedSource): boolean;
+/**
+ * The display name for a test: its `name`, or `"Test <number>"` when it has no
+ * def or no name. The single source of that fallback.
+ *
+ * `testNumber` is passed separately so a caller holding only a number and a
+ * possibly-missing def gets the same string as one holding a complete def — the
+ * shape every previous copy of this rule had.
+ *
+ * Typed to the structural minimum rather than `TestDef` so the chart test
+ * picker's own `TestSelectItem` (which carries only a number and an optional
+ * name) uses the same fallback as everything else instead of keeping its copy.
+ */
+export declare function testLabel(def: {
+    name?: string;
+} | undefined, testNumber: number): string;
+/**
+ * {@link testLabel} with the derived-test marker in front when the def is
+ * derived — `"† On/Off Ratio"`. The form every surface uses to name a test: the
+ * map title, tooltips, findings, tables, pickers and menus.
+ *
+ * The marker always PRECEDES the name, everywhere (Paul, 2026-09-23). In a list
+ * the eye runs down the left edge, so leading marks form a column and a derived
+ * test is found at a glance, where trailing ones land at a different x on every
+ * row; and truncating a long name can never cut the marker off. One position on
+ * every surface, so a reader learns it once. A unit follows the name as usual —
+ * `"† Vth Margin (V)"` — so the marker qualifies the whole test.
+ *
+ * A list that should keep measured names aligned with marked ones pads them by
+ * the marker's width when any entry is derived — {@link DERIVED_LANE_PAD} for
+ * plain text, a fixed-width slot where there is DOM or canvas to measure with.
+ */
+export declare function markedTestLabel(def: (TestDef | {
+    name?: string;
+    derived?: true;
+}) | undefined, testNumber: number): string;
+/**
+ * Plain-text stand-in for `"† "` in front of a MEASURED name, for a text-only
+ * list (a native `<select>`) that holds derived tests too, so every name starts
+ * at about the same x. A figure space plus a thin space: close to the width of
+ * a dagger and a space in the UI fonts, and invisible. Approximate by nature —
+ * a surface that can measure uses a real fixed-width slot instead.
+ */
+export declare const DERIVED_LANE_PAD = "\u2007\u2009";
+/**
+ * The one-line explanation of a derived test for a tooltip:
+ * `"† Derived, not measured: t[1010] / t[1020]"`, or without
+ * the expression when none was carried. `undefined` for a measured test.
+ *
+ * Plain text — the caller escapes it, like every other tooltip line.
+ */
+export declare function derivedTestNote(def: DerivedSource): string | undefined;
+/**
+ * What a derived test was computed from, as a phrase fit to show a user, or
+ * `undefined` for a measured test.
+ *
+ * Deliberately returns the expression verbatim rather than prettifying it: it
+ * is the exact text the application author wrote and can be matched against
+ * their own test-program source, which a reformatted version could not be.
+ */
+export declare function derivedTestSource(def: DerivedSource): string | undefined;
+/**
+ * `{ derived: true, expression }` for a derived test, `{}` for a measured one —
+ * spread into any row or record that carries a test onward (a capability row,
+ * a summary table entry, a finding's variable, a stacked card's def).
+ *
+ * The single form of that hand-off. Every place a test is re-described in a
+ * narrower shape is a place the flag can be dropped — it was, in
+ * `mergeTestDefs`, the Summary panel's table and `poolFunctionalYield`, each a
+ * row rebuilt field by field. A shape that spreads this cannot forget the
+ * expression while remembering the flag.
+ */
+export declare function derivedFields(def: DerivedSource): {
+    derived?: true;
+    expression?: string;
+};
+/**
+ * A label with the derived-test marker taken back out — for a surface that
+ * states derivation another way and so must not also carry a bare glyph (a
+ * CSV column, the key line that opens with the marker). The inverse of
+ * {@link markedTestLabel}, which is the only thing that marks a label, so the
+ * two live side by side.
+ */
+export declare function unmarkedLabel(label: string): string;
+/** Header of the column a CSV export adds when any row is a derived test. */
+export declare const DERIVED_CSV_HEADER = "Derived from";
+/**
+ * The {@link DERIVED_CSV_HEADER} cell for one row. A CSV has nowhere to put a
+ * key, so a derived test is stated as data: its expression, or the key's
+ * words if none was carried — never blank, which would read as measured.
+ * Blank for a measured test.
+ */
+export declare function derivedCsvCell(entry: DerivedSource): string;
+/**
+ * The key line for a surface that shows several tests at once with no hover to
+ * explain each one — a stats table, a findings list, a printed report:
+ * `"† Derived, not measured — Leakage Shift: abs(t[1020] - t[1010]); …"`.
+ * `undefined` when none of `entries` is derived, so the line appears exactly
+ * when a marked name is on the surface.
+ *
+ * Entries are de-duplicated by name, and the marker is dropped from each name
+ * ({@link unmarkedLabel}) since the line already opens with it. Plain text; the
+ * caller escapes it.
+ */
+export declare function derivedKeyText(entries: ReadonlyArray<{
+    label: string;
+    derived?: true;
+    expression?: string;
+}>): string | undefined;
+/**
+ * True when any test in this population is derived — the gate for reserving a
+ * marker gutter in a view.
+ *
+ * Reserving it per view rather than per row is what keeps the marker from
+ * shifting content relative to itself: every row of a view indents equally, so
+ * the markers align in a column instead of leaving a ragged edge, and a
+ * population with no derived tests — the common case — is unchanged to the
+ * pixel.
+ */
+export declare function hasDerivedTests(defs: readonly TestDef[] | undefined): boolean;
+//# sourceMappingURL=testLabel.d.ts.map

package/dist/packages/renderer/testLabel.js

@@ -0,0 +1 @@
+export const DERIVED_MARK="\u2020",DERIVED_KEY="Derived, not measured";export function isDerivedTest(e){return e?.derived===!0}export function testLabel(e,r){const t=e?.name;return t!==void 0&&t!==""?t:`Test ${r}`}export function markedTestLabel(e,r){const t=testLabel(e,r);return e?.derived===!0?`\u2020 ${t}`:t}export const DERIVED_LANE_PAD="\u2007\u2009";export function derivedTestNote(e){if(!isDerivedTest(e))return;const r=derivedTestSource(e);return r?`\u2020 ${DERIVED_KEY}: ${r}`:`\u2020 ${DERIVED_KEY}`}export function derivedTestSource(e){if(!(!isDerivedTest(e)||!e?.expression))return e.expression}export function derivedFields(e){return isDerivedTest(e)?e.expression!==void 0?{derived:!0,expression:e.expression}:{derived:!0}:{}}export function unmarkedLabel(e){return e.startsWith("\u2020 ")?e.slice(2):e}export const DERIVED_CSV_HEADER="Derived from";export function derivedCsvCell(e){return isDerivedTest(e)?derivedTestSource(e)??DERIVED_KEY:""}export function derivedKeyText(e){const r=new Map;for(const n of e){if(!isDerivedTest(n))continue;const i=unmarkedLabel(n.label);r.has(i)||r.set(i,n.expression)}if(r.size===0)return;const t=[...r].map(([n,i])=>i?`${n}: ${i}`:n);return`\u2020 ${DERIVED_KEY} \u2014 ${t.join("; ")}`}export function hasDerivedTests(e){return(e??[]).some(isDerivedTest)}