@wafertools/wafermap 0.21.1

package/dist/packages/stats/index.js

@@ -0,0 +1 @@
+export*from"./types.js";export*from"./regions.js";export*from"./analyzeWaferMap.js";export*from"./analyzeWaferLot.js";export*from"./filterFindings.js";export{classifyPattern}from"./patternClassification.js";export{renderFindingsReportHtml,openHtmlReport,setReportOpener}from"./renderFindingsReport.js";export{renderSummaryReportHtml,renderLotSummaryReportHtml}from"./renderSummaryReport.js";export{buildFacetTable,facetValueOf,FACET_NONE_VALUE,DEFAULT_FACET_CURATION}from"./facets.js";export{buildCapabilityData}from"./capability.js";export{buildCorrelationMatrix,filterCorrelationMatrix}from"./correlation.js";export{buildTestBoxplotData}from"./boxplot.js";export{buildTestHistogramData,buildTestHistogramSeries}from"./histogram.js";export{buildScatterData,buildScatterDataGrouped}from"./scatter.js";export{buildYieldData,buildYieldDataCombined}from"./yield.js";export{buildBinParetoData,buildBinClusterData}from"./binPareto.js";

package/dist/packages/stats/math.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Abramowitz & Stegun 7.1.26 rational approximation of the error function.
+ * Max absolute error ~1.5e-7 — ample for p-value gating.
+ */
+export declare function errorFunction(value: number): number;
+/** Standard normal cumulative distribution function Φ(value). */
+export declare function normalCdf(value: number): number;
+/** Linear-interpolation quantile of a pre-sorted array (`q` in [0, 1]). */
+export declare function quantile(sorted: number[], q: number): number;
+//# sourceMappingURL=math.d.ts.map

package/dist/packages/stats/math.js

@@ -0,0 +1 @@
+export function errorFunction(n){const a=n<0?-1:1,t=Math.abs(n),o=.254829592,r=-.284496736,s=1.421413741,i=-1.453152027,e=1.061405429,c=1/(1+.3275911*t),h=1-((((e*c+i)*c+s)*c+r)*c+o)*c*Math.exp(-t*t);return a*h}export function normalCdf(n){return .5*(1+errorFunction(n/Math.sqrt(2)))}export function quantile(n,a){if(n.length===0)return NaN;const t=a*(n.length-1),o=Math.floor(t),r=Math.ceil(t);return n[o]+(n[r]-n[o])*(t-o)}

package/dist/packages/stats/patternClassification.d.ts

@@ -0,0 +1,107 @@
+import type { Die, Wafer } from '../core/index.js';
+export type PatternLabel = 'center' | 'donut' | 'edge-ring' | 'edge-local' | 'scratch' | 'near-full' | 'random' | 'none';
+export interface PatternFeatures {
+    /** Ratio of failing dies to total eligible dies (whole-wafer). */
+    globalRdd: number;
+    /** Ratio of failing dies in the outermost ring to total outermost-ring dies (whole-wafer). */
+    edgeRdd: number;
+    /** Distance from wafer centre to centroid of the salient region, normalised by wafer radius. */
+    centroidDistNorm: number;
+    /** Minimum distance from wafer centre among salient-region dies, normalised by radius. */
+    minDistNorm: number;
+    /** Maximum distance from wafer centre among salient-region dies, normalised by radius. */
+    maxDistNorm: number;
+    /**
+     * 25th-percentile radial distance among ALL failing dies, normalised by radius.
+     * Used for donut detection: a true donut has most fails away from the centre
+     * even when the salient component incidentally touches the centre.
+     */
+    p25DistNorm: number;
+    /**
+     * Ratio of failure density in the inner half (r < 0.5) vs outer half (r >= 0.5).
+     * Center: inner > outer (ratio > 1). Donut: outer > inner (ratio < 1).
+     */
+    innerOuterRatio: number;
+    /**
+     * Eccentricity of the bounding ellipse around the salient region (0 = circle, 1 = line).
+     * Derived from the 2nd-order central moments of the salient-region die positions.
+     */
+    eccentricity: number;
+    /**
+     * Linear score: fraction of salient-region dies in the single best collinear run
+     * (along row or column), normalised to [0, 1].
+     */
+    linearScore: number;
+    /** Number of dies in the most salient (largest) connected component of failing dies. */
+    salienceSize: number;
+    /** Fraction of all failing dies that belong to the salient region. */
+    salienceFraction: number;
+    /**
+     * Fraction of the full circumference (0–1) covered by edge-zone failing dies,
+     * measured in 16 angular sectors. 1.0 = all sectors occupied (full ring),
+     * low value = concentrated arc (edge-local).
+     */
+    edgeAngularSpread: number;
+}
+export interface PatternClassification {
+    pattern: PatternLabel;
+    confidence: 'high' | 'medium' | 'low';
+    features: PatternFeatures;
+    /** Human-readable note about classification uncertainty, when applicable. */
+    note?: string;
+}
+export interface PatternThresholds {
+    nearFullGlobalRdd: number;
+    edgeRingEdgeRdd: number;
+    edgeRingEdgeRddHigh: number;
+    edgeRingRadialSpread: number;
+    /** Minimum angular spread (0–1) for edge-ring vs edge-local classification. */
+    edgeRingAngularSpread: number;
+    edgeLocalEdgeRdd: number;
+    /** p25DistNorm separator: ≥ this → edge-ring; [0.55, this) → edge-local. */
+    edgeLocalCentroidDist: number;
+    /** p25DistNorm separator: &lt; this → center; [this, 0.55) → donut. */
+    donutP25Dist: number;
+    centerCentroidDist: number;
+    centerCentroidDistHigh: number;
+    centerEdgeRdd: number;
+    donutEdgeRdd: number;
+    scratchLinearScore: number;
+    scratchLinearScoreHigh: number;
+    scratchEccentricity: number;
+    minimumFailingDies: number;
+}
+/**
+ * Default thresholds for the spatial pattern classifier.
+ *
+ * Calibrated against WM-811K — 25,519 labelled real-world wafers from TSMC
+ * 300mm fabrication (Wu et al. 2015). Benchmark results on that dataset:
+ *
+ * | Pattern    | Recall | Notes                                      |
+ * |------------|--------|--------------------------------------------|
+ * | Near-full  | 100%   |                                            |
+ * | Edge-ring  |  74%   |                                            |
+ * | Edge-local |  65%   |                                            |
+ * | Center     |  60%   |                                            |
+ * | Random     |  59%   |                                            |
+ * | Scratch    |  26%   | Fragmented patterns harder to detect       |
+ * | Donut      |  15%   | Geometrically similar to center with noise |
+ *
+ * Overall accuracy: 64% exact match, 86% detection rate (any pattern flagged).
+ */
+export declare const DEFAULT_PATTERN_THRESHOLDS: PatternThresholds;
+/**
+ * Classify the spatial failure pattern of a wafer from its die data.
+ *
+ * Uses connected-component analysis to identify the most salient (largest)
+ * failing region, then computes shape and position features on that region.
+ * Global statistics (RDD, edge RDD) are computed over all failing dies.
+ *
+ * Returns `null` when the failing-die count is below the minimum threshold
+ * (`thresholds.minimumFailingDies`, default 5) — too few failures to classify.
+ */
+export declare function classifyPattern(dies: Die[], wafer: Wafer, options: {
+    passBins: number[];
+    ringCount?: number;
+}): PatternClassification | null;
+//# sourceMappingURL=patternClassification.d.ts.map

package/dist/packages/stats/patternClassification.js

@@ -0,0 +1 @@
+import{getDieKey as F}from"../core/dies.js";import{clamp01 as j}from"../core/utils.js";export const DEFAULT_PATTERN_THRESHOLDS={nearFullGlobalRdd:.6,edgeRingEdgeRdd:.18,edgeRingEdgeRddHigh:.3,edgeRingRadialSpread:.45,edgeRingAngularSpread:.6,edgeLocalEdgeRdd:.1,edgeLocalCentroidDist:.76,donutP25Dist:.4,centerCentroidDist:.22,centerCentroidDistHigh:.1,centerEdgeRdd:.35,donutEdgeRdd:.22,scratchLinearScore:.25,scratchLinearScoreHigh:.45,scratchEccentricity:.75,minimumFailingDies:5};function J(t){if(t.length===0)return[];const e=new Map;for(const s of t)e.set(F(s),s);const c=new Set,i=[];for(const s of t){const d=F(s);if(c.has(d))continue;const r=[],n=[s];for(c.add(d);n.length>0;){const a=n.pop();r.push(a);for(let g=-1;g<=1;g++)for(let m=-1;m<=1;m++){if(g===0&&m===0)continue;const u=`${a.x+g},${a.y+m}`;!c.has(u)&&e.has(u)&&(c.add(u),n.push(e.get(u)))}}i.push(r)}return i}function O(t,e,c){const i=t.physX-e.center.x,s=t.physY-e.center.y,d=Math.sqrt(i*i+s*s)/e.radius;return Math.min(c,Math.max(1,Math.floor(d*c)+1))===c}function Q(t,e,c){if(t.length<3)return 0;let i=0,s=0,d=0;for(const p of t){const l=p.physX-e,D=p.physY-c;i+=l*l,s+=D*D,d+=l*D}i/=t.length,s/=t.length,d/=t.length;const r=i+s,n=i*s-d*d,a=Math.max(0,(r/2)**2-n),g=r/2+Math.sqrt(a),m=r/2-Math.sqrt(a);if(g<=0)return 0;const u=j(m/g);return Math.sqrt(1-u)}function V(t,e){if(e===0)return 0;const c=new Map,i=new Map,s=new Map,d=new Map;for(const n of t)c.set(n.y,(c.get(n.y)??0)+1),i.set(n.x,(i.get(n.x)??0)+1),s.set(n.x-n.y,(s.get(n.x-n.y)??0)+1),d.set(n.x+n.y,(d.get(n.x+n.y)??0)+1);let r=0;for(const n of c.values())n>r&&(r=n);for(const n of i.values())n>r&&(r=n);for(const n of s.values())n>r&&(r=n);for(const n of d.values())n>r&&(r=n);return r/e}function W(t,e,c,i){const s=e.length,d=t.length,r=s>0?d/s:0,n=e.filter(o=>O(o,c,i)),a=t.filter(o=>O(o,c,i)),g=n.length>0?a.length/n.length:0,m=J(t),u=m.length>0?[...m].sort((o,h)=>h.length-o.length):[t],p=u[0],l=u.slice(0,5).flat(),D=p.length,H=d>0?D/d:0,f=c.center.x,y=c.center.y,R=c.radius;let E=0,N=0,M=1/0,x=0;for(const o of p){E+=o.physX,N+=o.physY;const h=Math.sqrt((o.physX-f)**2+(o.physY-y)**2);h<M&&(M=h),h>x&&(x=h)}const P=E/p.length,T=N/p.length,w=Math.sqrt((P-f)**2+(T-y)**2)/R,I=M===1/0?0:M/R,v=Math.min(x/R,1),C=t.map(o=>Math.sqrt((o.physX-f)**2+(o.physY-y)**2)/R).sort((o,h)=>o-h),k=C[Math.floor(C.length*.25)]??0,b=e.filter(o=>Math.sqrt((o.physX-f)**2+(o.physY-y)**2)/R<.5).length,X=e.filter(o=>Math.sqrt((o.physX-f)**2+(o.physY-y)**2)/R>=.5).length,z=t.filter(o=>Math.sqrt((o.physX-f)**2+(o.physY-y)**2)/R<.5).length,A=t.filter(o=>Math.sqrt((o.physX-f)**2+(o.physY-y)**2)/R>=.5).length,Y=b>0?z/b:0,q=X>0?A/X:0,_=q>0?Y/q:Y>0?2:1,G=l.reduce((o,h)=>o+h.physX,0)/l.length,K=l.reduce((o,h)=>o+h.physY,0)/l.length,U=Q(l,G,K),$=V(l,l.length),S=16,L=new Set;for(const o of a){const h=(Math.atan2(o.physY-y,o.physX-f)+2*Math.PI)%(2*Math.PI);L.add(Math.floor(h/(2*Math.PI)*S)%S)}const B=a.length>0?L.size/S:0;return{globalRdd:r,edgeRdd:g,centroidDistNorm:w,minDistNorm:I,maxDistNorm:v,p25DistNorm:k,eccentricity:U,linearScore:$,salienceSize:D,salienceFraction:H,edgeAngularSpread:B,innerOuterRatio:_}}function Z(t,e,c){const i=Math.max(5,Math.round(c*.003)),s=t.salienceSize>=i;if(t.globalRdd<e.nearFullGlobalRdd&&t.salienceFraction<.1)return{pattern:"random",confidence:"low"};if(t.globalRdd>=e.nearFullGlobalRdd)return{pattern:"near-full",confidence:t.globalRdd>=.8?"high":"medium"};if(s&&t.linearScore>=e.scratchLinearScore&&t.eccentricity>=e.scratchEccentricity){const a=t.linearScore>=e.scratchLinearScoreHigh?"high":"medium";return{pattern:"scratch",confidence:a,note:a==="medium"?"Scratch detection is less reliable for fragmented or diagonal patterns":void 0}}const d=s&&t.edgeRdd>=e.edgeLocalEdgeRdd&&t.maxDistNorm>=.7;if(d&&t.p25DistNorm>=e.edgeLocalCentroidDist&&t.maxDistNorm-t.minDistNorm<=e.edgeRingRadialSpread)return{pattern:"edge-ring",confidence:t.edgeRdd>=e.edgeRingEdgeRddHigh?"high":"medium"};if(d&&t.p25DistNorm>=.55&&t.p25DistNorm<e.edgeLocalCentroidDist)return{pattern:"edge-local",confidence:t.edgeRdd>=e.edgeRingEdgeRdd?"medium":"low"};const r=s&&t.centroidDistNorm<=e.centerCentroidDist&&t.edgeRdd<=e.centerEdgeRdd,n="Center and donut patterns have similar geometry; classification may be imprecise";if(r&&t.p25DistNorm<e.donutP25Dist){const a=t.centroidDistNorm<=e.centerCentroidDistHigh?"high":"medium";return{pattern:"center",confidence:a,note:a!=="high"?n:void 0}}return r&&t.p25DistNorm>=e.donutP25Dist&&t.p25DistNorm<.55?{pattern:"donut",confidence:"medium",note:n}:{pattern:"random",confidence:"low"}}export function classifyPattern(t,e,c){const i={...DEFAULT_PATTERN_THRESHOLDS},s=c.ringCount??4,d=new Set(c.passBins),r=t.filter(p=>{const l=p.hbin??p.sbin;return l!==void 0&&!d.has(l)}),n=Math.max(i.minimumFailingDies,Math.round(t.length*.003));if(r.length<n)return null;const a=W(r,t,e,s),{pattern:g,confidence:m,note:u}=Z(a,i,t.length);return{pattern:g,confidence:m,features:a,...u?{note:u}:{}}}

package/dist/packages/stats/regions.d.ts

@@ -0,0 +1,57 @@
+import { type Die, type Wafer } from '../core/index.js';
+import type { ReticleConfig } from '../renderer/buildWaferMap.js';
+export interface StatsRegion {
+    family: 'ring' | 'quadrant' | 'reticle-position' | 'test-site' | 'sector';
+    key: string;
+    label: string;
+    dieKeys: string[];
+}
+export interface RegionYieldDatum {
+    /** Region identity, e.g. `ring:2` or `quadrant:NE` — parse with `parseRegionKey`. */
+    key: string;
+    label: string;
+    /** `(pass / n) × 100`, in [0, 100]. Only present for regions with n > 0 (see filter below). */
+    yieldPercent: number;
+    /** Yield-eligible, binned die count in this region. */
+    n: number;
+}
+/**
+ * Pass/fail yield per region (ring, quadrant, or any other `StatsRegion`
+ * family), pooled across one or more wafers. Single source of truth for this
+ * computation — consumed by both the summary panel's progress-bar rows and
+ * the ring/quadrant yield diagrams, which previously each recomputed the
+ * same pass/total tally independently.
+ */
+export declare function buildRegionYieldData(diesByWafer: Die[][], allWafers: Wafer[], ringCount: number, passBins: number[], regionBuilder: (dies: Die[], wafer: Wafer, ringCount: number) => StatsRegion[]): RegionYieldDatum[];
+/** Compass bearing names for a given sector count, ordered CCW from East. */
+export declare function sectorCompassNames(sectorCount: number): string[];
+/** True when two quadrants share an edge (NE–NW, NE–SE, NW–SW, SE–SW); diagonals are not adjacent. */
+export declare function areQuadrantsAdjacent(a: string, b: string): boolean;
+export interface ParsedRegionKey {
+    family: StatsRegion['family'] | 'unknown';
+    ring?: number;
+    quadrant?: string;
+    sector?: string;
+}
+/**
+ * Parse a region key (e.g. `ring:2`, `quadrant:NE`, `sector:NNE`) into its
+ * structured parts. Always parse identity from the key, never from the label.
+ */
+export declare function parseRegionKey(key: string): ParsedRegionKey;
+export declare function buildRingRegions(dies: Die[], wafer: Wafer, ringCount: number): StatsRegion[];
+export declare function buildQuadrantRegions(dies: Die[], wafer: Wafer, ringCount: number): StatsRegion[];
+export declare function buildReticlePositionRegions(dies: Die[], reticleConfig: ReticleConfig | undefined): StatsRegion[];
+/**
+ * Group dies by siteNum for parallel test site analysis.
+ *
+ * Returns an empty array (suppressing analysis) unless at least 2 distinct
+ * siteNum values each appear on MIN_DIES_PER_SITE or more dies — this prevents
+ * spurious regions when siteNum is used as a monotonically-increasing counter
+ * rather than a true parallel-site identifier.
+ *
+ * Pass `forceEnable: true` to bypass the guard (e.g. when the caller has already
+ * validated the data).
+ */
+export declare function buildTestSiteRegions(dies: Die[], forceEnable?: boolean): StatsRegion[];
+export declare function buildSectorRegions(dies: Die[], wafer: Wafer, sectorCount: number): StatsRegion[];
+//# sourceMappingURL=regions.d.ts.map

package/dist/packages/stats/regions.js

@@ -0,0 +1 @@
+import{classifyDie as E,getReticleCell as W,getRingLabel as b,getDieKey as M}from"../core/index.js";function y(t){return M(t)}export function buildRegionYieldData(t,s,o,e,n){const i=new Set(e),r=new Map,a=[];for(let l=0;l<s.length;l++){const c=t[l];if(!c?.length)continue;const d=n(c,s[l],o),S=new Map(c.map(u=>[y(u),u]));for(const u of d){a.includes(u.key)||a.push(u.key);const g=r.get(u.key)??{label:u.label,pass:0,total:0};for(const h of u.dieKeys){const f=S.get(h);if(!f||f.partial||f.edgeExcluded)continue;const p=f.hbin??f.sbin;p!=null&&(g.total++,i.has(p)&&g.pass++)}r.set(u.key,g)}}return a.map(l=>{const c=r.get(l);return c.total===0?null:{key:l,label:c.label,n:c.total,yieldPercent:c.pass/c.total*100}}).filter(l=>l!==null)}const k=["E","ENE","NE","NNE","N","NNW","NW","WNW","W","WSW","SW","SSW","S","SSE","SE","ESE"],x=["E","NE","N","NW","W","SW","S","SE"],R=["E","N","W","S"];export function sectorCompassNames(t){const s=[4,8,16,32].includes(t)?t:16;return s===4?R:s===8?x:k}const K={NE:["NW","SE"],NW:["NE","SW"],SE:["NE","SW"],SW:["NW","SE"]};export function areQuadrantsAdjacent(t,s){return K[t]?.includes(s)??!1}export function parseRegionKey(t){return t.startsWith("ring:")?{family:"ring",ring:Number(t.slice(5))}:t.startsWith("quadrant:")?{family:"quadrant",quadrant:t.slice(9)}:t.startsWith("sector:")?{family:"sector",sector:t.slice(7)}:{family:"unknown"}}export function buildRingRegions(t,s,o){const e=new Map;for(const n of t){const{ring:i}=E(n,s,{ringCount:o}),r=`ring:${i}`,a=e.get(r)??{family:"ring",key:r,label:b(i,o),dieKeys:[]};a.dieKeys.push(y(n)),e.set(r,a)}return[...e.values()].sort((n,i)=>n.key.localeCompare(i.key))}export function buildQuadrantRegions(t,s,o){const e=new Map;for(const i of t){const{quadrant:r}=E(i,s,{ringCount:o}),a=`quadrant:${r}`,l=e.get(a)??{family:"quadrant",key:a,label:r,dieKeys:[]};l.dieKeys.push(y(i)),e.set(a,l)}const n=new Map([["quadrant:NE",0],["quadrant:NW",1],["quadrant:SE",2],["quadrant:SW",3]]);return[...e.values()].sort((i,r)=>(n.get(i.key)??4)-(n.get(r.key)??4))}export function buildReticlePositionRegions(t,s){if(!s)return[];const o=new Map;for(const e of t){const{column:n,row:i}=W(e,s),r=`reticle-position:cell:${n},${i}`,a=o.get(r)??{family:"reticle-position",key:r,label:`Reticle cell (${n}, ${i})`,dieKeys:[]};a.dieKeys.push(y(e)),o.set(r,a)}return[...o.values()].sort((e,n)=>e.key.localeCompare(n.key))}const q=3;export function buildTestSiteRegions(t,s=!1){const o=new Map;for(const e of t){if(e.siteNum===void 0)continue;const n=o.get(e.siteNum)??[];n.push(y(e)),o.set(e.siteNum,n)}if(!s){let e=0;for(const n of o.values())n.length>=q&&e++;if(e<2)return[]}return[...o.entries()].sort(([e],[n])=>e-n).map(([e,n])=>({family:"test-site",key:`test-site:${e}`,label:`Site ${e}`,dieKeys:n}))}export function buildSectorRegions(t,s,o){const e=[4,8,16,32].includes(o)?o:16,n=sectorCompassNames(e),i=new Map,r=s.center.x,a=s.center.y,l=s.radius;for(const c of t){const d=c.physX-r,S=c.physY-a;if(Math.hypot(d,S)/l<.2)continue;const g=Math.PI/e,h=(Math.atan2(S,d)+2*Math.PI+g)%(2*Math.PI),f=Math.floor(h/(2*Math.PI)*e)%e,p=n[f],N=`sector:${p}`,m=i.get(N)??{family:"sector",key:N,label:`Sector ${p}`,dieKeys:[]};m.dieKeys.push(y(c)),i.set(N,m)}return[...i.values()].sort((c,d)=>c.key.localeCompare(d.key))}

package/dist/packages/stats/renderFindingsReport.d.ts

@@ -0,0 +1,7 @@
+import type { StatsSummary, LotStatsSummary } from './types.js';
+export declare function renderFindingsReportHtml(summary: StatsSummary | LotStatsSummary, options?: {
+    title?: string;
+}): string;
+export declare function openHtmlReport(html: string): void;
+export declare function setReportOpener(opener: (html: string) => void): void;
+//# sourceMappingURL=renderFindingsReport.d.ts.map

package/dist/packages/stats/renderFindingsReport.js

@@ -0,0 +1,41 @@
+import{formatFindingDelta as g,formatFindingCoverage as h,formatFindingTooltip as b,escHtml as a,buildMetadataRows as d,renderDefinitionList as c,renderSection as p,renderSeverityBadge as w,reportStyles as v}from"./reportHtml.js";import{buildFindingsNarrative as y}from"./findingsNarrative.js";import{plainBinTerms as f}from"../renderer/fmt.js";function $(t,n){if(t.level==="lot"){const o=t,l=o.perWafer.map(r=>r.summary.wafer?.wafer??r.summary.wafer?.waferId).filter(r=>r!=null).map(String).join(", ");return c([...d(o.perWafer.map(r=>({metadata:r.summary.wafer}))),...l?[{label:"Wafers",value:l}]:[],{label:"Wafer count",value:String(o.stats.waferCount)},{label:"Generated",value:n}])}const e=t,i=e.stats.yieldPercent!==null?`${e.stats.yieldPercent.toFixed(1)}%`:"N/A";return c([...d([{metadata:e.wafer}]),{label:"Total dies",value:String(e.stats.totalDies)},{label:"Analysed dies",value:String(e.stats.analyzedDies)},{label:"Yield",value:i},{label:"Generated",value:n}])}function R(t,n){return t.length?t.map(e=>`<tr title="${a(b(e))}">
+      <td class="tight">${w(e.severity)}</td>
+      <td class="tight">${a(e.comparison.left)}</td>
+      <td>${a(f(e.variable.label))}</td>
+      <td class="numeric">${a(g(e))}</td>
+      <td class="numeric">${a(h(e,n))}</td>
+    </tr>`).join(`
+`):'<tr><td colspan="5" class="no-data">No significant findings</td></tr>'}function F(t,n){return`<table class="report-table findings-table compact">
+  <thead>
+    <tr>
+      <th>Severity</th>
+      <th>Region</th>
+      <th>Metric</th>
+      <th class="numeric">Delta</th>
+      <th class="numeric">${n!==void 0?"Wafers":"N (region/rest)"}</th>
+    </tr>
+  </thead>
+  <tbody>
+    ${R(t,n)}
+  </tbody>
+</table>`}export function renderFindingsReportHtml(t,n={}){const e=t.level==="lot",i=n.title??(e?"Lot Findings Report":"Wafer Findings Report"),o=new Date().toLocaleString(),l=t.findings,r=t.level==="lot"?t.stats.waferCount:void 0,s=f(y(l)??""),u=s?`<p class="findings-narrative">${a(s)}</p>
+`:"",m=[p("Summary",$(t,o)),p("Findings",u+F(l,r))].join(`
+`);return`<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<title>${a(i)}</title>
+<style>
+${v()}
+</style>
+</head>
+<body>
+<main class="report">
+  <header class="report-header">
+    <h1>${a(i)}</h1>
+    <p class="report-subtitle">Generated ${a(o)}</p>
+  </header>
+  ${m}
+</main>
+</body>
+</html>`}export function openHtmlReport(t){if(typeof window.__openHtmlReport=="function"){window.__openHtmlReport(t);return}const n=window.open("","_blank");n&&(n.document.write(t),n.document.close())}export function setReportOpener(t){window.__openHtmlReport=t}

package/dist/packages/stats/renderSummaryReport.d.ts

@@ -0,0 +1,60 @@
+import type { Die } from '../core/dies.js';
+import type { Wafer } from '../core/wafer.js';
+import { type BinDef, type TestDef, type YieldSummary } from '../renderer/buildWaferMap.js';
+import type { StatsSummary, AnalyzeWaferMapOptions } from './types.js';
+import { openHtmlReport } from './renderFindingsReport.js';
+export interface SummaryReportParams {
+    wafer: Wafer;
+    dies: Die[];
+    yieldSummary: YieldSummary;
+    dataCoverage: {
+        filledDies: number;
+        totalDies: number;
+        edgeExcludedDies: number;
+        ratio: number;
+    };
+    hbinDefs?: BinDef[];
+    sbinDefs?: BinDef[];
+    testDefs?: TestDef[];
+    statsSummary?: StatsSummary;
+    passBins?: number[];
+    ringCount?: number;
+}
+/** Generate a full wafer summary as a standalone HTML string suitable for `openHtmlReport()`. */
+export declare function renderSummaryReportHtml(params: SummaryReportParams, options?: {
+    title?: string;
+}): string;
+export interface LotSummaryReportParams {
+    /** One entry per wafer/item — grouping, per-group analysis (`analyzeWaferLot`),
+     *  and rendering all happen internally; callers never pre-compute a lotSummary
+     *  or pre-partition by lot identity themselves. */
+    items: Array<{
+        label: string;
+        wafer?: Wafer;
+        dies?: Die[];
+        /** Reused directly as `analyzeWaferLot`'s `perWaferSummaries` — the expensive
+         *  per-wafer pass (`analyzeWaferMap`) is never re-run here. */
+        statsSummary?: StatsSummary;
+    }>;
+    hbinDefs?: BinDef[];
+    sbinDefs?: BinDef[];
+    testDefs?: TestDef[];
+    passBins?: number[];
+    ringCount?: number;
+    /** Passthrough to the internal per-group `analyzeWaferLot` call, e.g. `{ enableTestValueAnalysis: true }`. */
+    analyzeOptions?: AnalyzeWaferMapOptions;
+}
+/**
+ * Generate a full lot summary as a standalone HTML string suitable for
+ * `openHtmlReport()`. Grouping, per-group analysis, and rendering all
+ * happen internally — see `groupByIdentity` — so a caller never needs to
+ * pre-partition a multi-lot/multi-product/multi-temperature load itself:
+ * a single call always returns one complete document, whether that's one
+ * `<main>` (the common case) or several side by side with a banner
+ * explaining the split.
+ */
+export declare function renderLotSummaryReportHtml(params: LotSummaryReportParams, options?: {
+    title?: string;
+}): string;
+export { openHtmlReport };
+//# sourceMappingURL=renderSummaryReport.d.ts.map

package/dist/packages/stats/renderSummaryReport.js

@@ -0,0 +1,68 @@
+import{isParametricTest as rt}from"../renderer/buildWaferMap.js";import{buildRingRegions as H,buildQuadrantRegions as L}from"./regions.js";import{openHtmlReport as ct}from"./renderFindingsReport.js";import{analyzeWaferLot as dt}from"./analyzeWaferLot.js";import{computeFunctionalYield as ut}from"./analyzeWaferMap.js";import{buildCapabilityData as ft}from"./capability.js";import{fmt as B}from"../renderer/fmt.js";import{getDieKey as W}from"../core/dies.js";import{formatFindingDelta as mt,formatFindingCoverage as pt,formatFindingTooltip as gt,escHtml as h,renderMetadataSection as k,renderMetricGrid as N,renderSection as $,renderSeverityBadge as ht,renderTable as D,reportStyles as E}from"./reportHtml.js";function P(o,r){return r===0?"\u2014":`${(o/r*100).toFixed(1)}%`}function bt(o){if(!o)return"";const r=o.lot??o.lotId,i=o.wafer??o.waferId,e=[r,i].filter(Boolean).map(String);return e.length?` \u2014 ${e.map(h).join(" \xB7 ")}`:""}function Et(o,r){const i=[{label:"Total dies",value:String(r.totalDies)},{label:"Filled dies",value:String(r.filledDies),hint:`${P(r.filledDies,r.totalDies)} fill`},{label:"Pass dies",value:String(o.passDies)},{label:"Fail dies",value:String(o.failDies)},...o.edgeExcludedDies>0?[{label:"Edge excluded",value:String(o.edgeExcludedDies)}]:[],...o.partialDies>0?[{label:"Partial dies",value:String(o.partialDies)}]:[],{label:"Yield",value:o.yieldPercent!==null?`${o.yieldPercent.toFixed(1)}%`:"N/A"}];return $("Yield",N(i))}function I(o,r,i,e){const l=new Map;if(e)for(const[n,s]of Object.entries(e))l.set(Number(n),s);else for(const n of o){if(n.partial||n.edgeExcluded)continue;const s=i==="hard"?n.hbin:n.sbin;s!=null&&l.set(s,(l.get(s)??0)+1)}if(!l.size)return"";const t=[...l.values()].reduce((n,s)=>n+s,0),a=r?new Map(r.map(n=>[n.bin,n])):null,c=[...l.entries()].sort((n,s)=>n[0]-s[0]).map(([n,s])=>{const p=a?.get(n)?.name??"\u2014";return[String(n),p,String(s),P(s,t)]});return $(i==="hard"?"Hard Bin Breakdown":"Soft Bin Breakdown",D(["Bin","Name","Count","%"],c,{className:"compact"}))}function j(o,r,i,e){const l=new Set(e),t=new Map(i.map(d=>[W(d),d]));if(!i.some(d=>d.hbin!=null||d.sbin!=null)||!r.length)return"";const c=[];for(const d of r){let n=0,s=0;for(const m of d.dieKeys){const p=t.get(m);if(!p||p.partial||p.edgeExcluded)continue;const g=p.hbin??p.sbin;g!=null&&(s++,l.has(g)&&n++)}s&&c.push([d.label,String(n),String(s),P(n,s)])}return c.length?$(o,D(["Region","Pass","Total","Yield"],c,{className:"compact"})):""}function z(o,r,i){if(!r.length)return"";const e=o.filter(a=>!a.partial&&!a.edgeExcluded),l=new Map((i??[]).map(a=>[a.testNumber,a])),t=[];for(const a of r.filter(rt)){const c=a.testNumber,d=a.unit||void 0,n=l.get(c);let s,m,p;if(n)({min:s,max:m,mean:p}=n);else{const g=e.map(b=>b.testValues?.[c]).filter(b=>b!==void 0&&isFinite(b));if(!g.length)continue;g.sort((b,u)=>b-u),s=g[0],m=g[g.length-1],p=g.reduce((b,u)=>b+u,0)/g.length}t.push([h(a.name),B(s,d),B(p,d),B(m,d)])}return t.length?$("Test Values",D(["Test","Min","Mean","Max"],t,{className:"compact"})):""}function A(o,r,i){const e=i??ut(o,r);if(!e?.length)return"";const l=e.map(t=>[h(t.label),String(t.totalDies),String(t.passDies),String(t.failDies),t.passRatePercent!==null?`${t.passRatePercent.toFixed(1)}%`:"\u2014"]);return $("Functional Tests",D(["Test","N","Pass","Fail","Pass Rate"],l,{className:"compact"}))}function G(o,r){const i=ft(o,r);if(!i.length)return"";const e=t=>t===null?"\u2014":t.toFixed(2),l=i.map(t=>[h(t.label),t.hasSpec?`${B(t.lsl,t.unit)} \u2013 ${B(t.usl,t.unit)}`:"\u2014",B(t.mean,t.unit),e(t.cp),e(t.cpk),e(t.pp),e(t.ppk)]);return $("Process Capability",D(["Test","Spec (LSL\u2013USL)","Mean","Cp","Cpk","Pp","Ppk"],l,{className:"compact"}))}function O(o,r){if(!o.length)return"";const i=o.map(t=>`<tr title="${h(gt(t))}">
+      <td class="tight">${ht(t.severity)}</td>
+      <td class="tight">${h(t.comparison.left)}</td>
+      <td>${h(t.variable.label)}</td>
+      <td class="numeric">${h(mt(t))}</td>
+      <td class="numeric">${h(pt(t,r))}</td>
+    </tr>`).join(`
+`),l=`<table class="report-table findings-table compact"><thead><tr>
+    <th>Severity</th><th>Region</th><th>Metric</th><th class="numeric">Delta</th><th class="numeric">${r!==void 0?"Wafers":"N (region/rest)"}</th>
+  </tr></thead><tbody>${i}</tbody></table>`;return $("Findings",l)}export function renderSummaryReportHtml(o,r={}){const{wafer:i,dies:e,yieldSummary:l,dataCoverage:t,hbinDefs:a,sbinDefs:c,testDefs:d=[],statsSummary:n,passBins:s=[1],ringCount:m=4}=o,p=i.metadata,g=bt(p),b=r.title??`Wafer Summary${g}`,u=new Date().toLocaleString(),w=e.some(Y=>Y.hbin!=null),x=e.some(Y=>Y.sbin!=null),S=H(e,i,m),y=L(e,i,m),v=[{label:"Total dies",value:String(t.totalDies)},...l.partialDies>0?[{label:"Partial",value:String(l.partialDies)}]:[],...l.yieldPercent!==null?[{label:`Yield (pass: ${s.length===1?`bin ${s[0]}`:`bins ${s.join(", ")}`})`,value:`${l.yieldPercent.toFixed(1)}%`}]:[],...l.edgeExcludedDies>0?[{label:"Edge excluded (outer zone)",value:String(l.edgeExcludedDies)}]:[]],M=[k([{metadata:i.metadata}]),$("Summary",[N(v)].filter(Boolean).join(`
+`)),w?I(e,a,"hard",n?.stats.hardBinCounts):x?I(e,c,"soft",n?.stats.softBinCounts):"",j("Ring Yield",S,e,s),j("Quadrant Yield",y,e,s),z(e,d,n?.stats.perTestStats),A(e,d,n?.stats.functionalYield),G([{dies:e}],d),n?O(n.findings):""].filter(Boolean).join(`
+`);return`<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<title>${h(b)}</title>
+<style>
+${E()}
+</style>
+</head>
+<body>
+<main class="report">
+  <header class="report-header">
+    <h1>${h(b)}</h1>
+    <p class="report-subtitle">Generated ${h(u)}</p>
+  </header>
+  ${M}
+  <p class="footer">Generated ${h(u)}</p>
+</main>
+</body>
+</html>`}function St(o,r){const i=o.perWafer.map(e=>{const l=r[e.waferIndex]?.label??`W${e.waferIndex+1}`,t=e.summary.stats.yieldPercent;return[l,t!==null?`${t.toFixed(1)}%`:"N/A"]});return D(["Wafer","Yield"],i,{className:"compact"})}function yt(o){const r=o.map(i=>[i.label,i.wafer?.metadata?.split]).filter(i=>!!i[1]).map(([i,e])=>[h(i),h(e)]);return r.length?$("Splits",D(["Wafer","Split"],r,{className:"compact"})):""}function K(o,r,i,e){const l=new Map,t=i==="hard"?"hardBinCounts":"softBinCounts";if(e?.length&&e.every(n=>n.stats[t]!==void 0))for(const n of e)for(const[s,m]of Object.entries(n.stats[t])){const p=Number(s);l.set(p,(l.get(p)??0)+m)}else for(const n of o){if(n.partial||n.edgeExcluded)continue;const s=i==="hard"?n.hbin:n.sbin;s!=null&&l.set(s,(l.get(s)??0)+1)}if(!l.size)return"";const a=[...l.values()].reduce((n,s)=>n+s,0),c=r?new Map(r.map(n=>[n.bin,n])):null,d=[...l.entries()].sort((n,s)=>n[0]-s[0]).map(([n,s])=>{const m=c?.get(n);return[m?.name?`Bin ${n} \xB7 ${m.name} (${s})`:`Bin ${n} (${s})`,P(s,a)]});return $(i==="hard"?"Hard Bin Breakdown (All Wafers)":"Soft Bin Breakdown (All Wafers)",D(["Bin","Yield"],d,{className:"compact"}))}function U(o,r,i,e,l,t){const a=new Set(t),c=new Map,d=[];for(let s=0;s<e.length;s++){const m=e[s],p=i[s]??[];if(!p.length)continue;const g=r(p,m,l),b=new Map(p.map(u=>[W(u),u]));for(const u of g){d.includes(u.label)||d.push(u.label);const w=c.get(u.label)??{pass:0,total:0};for(const x of u.dieKeys){const S=b.get(x);if(!S||S.partial||S.edgeExcluded)continue;const y=S.hbin??S.sbin;y!=null&&(w.total++,a.has(y)&&w.pass++)}c.set(u.label,w)}}if(!c.size)return"";const n=d.filter(s=>c.get(s)?.total).map(s=>{const m=c.get(s);return[s,P(m.pass,m.total)]});return n.length?$(o,D(["Region","Yield"],n,{className:"compact"})):""}function wt(o,r,i){let e;if(i?.length&&i.every(l=>l.stats.perTestStats!==void 0)){const l=new Map;for(const t of i)for(const a of t.stats.perTestStats??[]){const c=l.get(a.testNumber);c?(c.n+=a.count,c.sum+=a.mean*a.count,c.min=Math.min(c.min,a.min),c.max=Math.max(c.max,a.max)):l.set(a.testNumber,{n:a.count,sum:a.mean*a.count,min:a.min,max:a.max})}e=[...l.entries()].map(([t,a])=>({testNumber:t,min:a.min,max:a.max,mean:a.sum/a.n}))}return z(o,r,e)}function $t(o,r,i){let e;if(i?.length&&i.every(l=>l.stats.functionalYield!==void 0)){const l=new Map;for(const t of i)for(const a of t.stats.functionalYield??[]){const c=l.get(a.testNumber)??{label:a.label,passDies:0,failDies:0,totalDies:0};c.passDies+=a.passDies,c.failDies+=a.failDies,c.totalDies+=a.totalDies,l.set(a.testNumber,c)}e=[...l.entries()].map(([t,a])=>({testNumber:t,...a,passRatePercent:a.totalDies>0?a.passDies/a.totalDies*100:null}))}return A(o,r,e?.length?e:void 0)}const R=["lot","product","testProgram","temperature"];function xt(o){const r=new Map(R.map(t=>[t,new Set]));for(const t of o)for(const a of R){const c=t.wafer?.metadata?.[a];c!=null&&c!==""&&r.get(a).add(String(c))}const i=R.filter(t=>r.get(t).size>1);if(i.length===0)return[{label:"",items:o,varying:i}];const e=new Map,l=[];for(const t of o){const a=i.map(c=>String(t.wafer?.metadata?.[c]??"(none)")).join(" \xB7 ");e.has(a)||(e.set(a,[]),l.push(a)),e.get(a).push(t)}return l.map(t=>({label:t,items:e.get(t),varying:i}))}function Q(o,r,i,e,l,t,a){const c=dt(o,{perWaferSummaries:o.map(f=>f.statsSummary),...a}),d=[],n=[],s=[];for(const f of o){const T=f.dies??[];f.wafer&&(d.push(f.wafer),s.push(T)),T.length&&n.push(...T)}const m=n.some(f=>f.hbin!=null),p=n.some(f=>f.sbin!=null),g=m||p,b=c.perWafer.map(f=>f.summary.stats.yieldPercent).filter(f=>f!==null),u=b.length?b.reduce((f,T)=>f+T,0)/b.length:null,w=new Set(l);let x=0,S=0,y=0,v=0,M=0;for(const f of n){if(x++,f.edgeExcluded&&v++,f.partial&&M++,f.partial||f.edgeExcluded)continue;const T=f.hbin??f.sbin;T!=null&&(S++,w.has(T)&&y++)}const Y=S-y,C=S>0?y/S*100:null,V=[{label:"Wafers",value:String(c.stats.waferCount)},{label:"Total dies",value:String(x)},...g?[{label:"Good dies",value:String(y)},{label:"Bad dies",value:String(Y)}]:[],...v>0?[{label:"Edge excluded",value:String(v)}]:[],...M>0?[{label:"Partial dies",value:String(M)}]:[],...u!==null?[{label:"Mean wafer yield",value:`${u.toFixed(1)}%`}]:[],...C!==null?[{label:"Total yield",value:`${C.toFixed(1)}%`}]:[]],_=$("Lot Summary",N(V)),J=k(o.map(f=>({metadata:f.wafer?.metadata}))),X=$("Per-Wafer Yield",St(c,o)),Z=yt(o),F=c.perWafer.map(f=>f.summary),tt=g?m?K(n,r,"hard",F):K(n,i,"soft",F):"",et=g&&d.length?U("Ring Yield (All Wafers)",H,s,d,t,l):"",nt=g&&d.length?U("Quadrant Yield (All Wafers)",L,s,d,t,l):"",at=e.length?wt(n,e,F):"",st=e.length?$t(n,e,F):"",ot=e.length?G(o,e):"",it=c.findings.length?O(c.findings,c.stats.waferCount):"",lt=[_,J,X,Z,tt,et,nt,at,st,ot,it].filter(Boolean).join(`
+`);return{lotSummary:c,sections:lt}}function q(o,r,i){return`<main class="report">
+  <header class="report-header">
+    <h1>${h(o)}</h1>
+    <p class="report-subtitle">Generated ${h(i)}</p>
+  </header>
+  ${r}
+  <p class="footer">Generated ${h(i)}</p>
+</main>`}export function renderLotSummaryReportHtml(o,r={}){const{items:i,hbinDefs:e,sbinDefs:l,testDefs:t=[],passBins:a=[1],ringCount:c=4,analyzeOptions:d}=o,n=new Date().toLocaleString(),s=xt(i);if(s.length===1){const{lotSummary:u,sections:w}=Q(s[0].items,e,l,t,a,c,d),x=(()=>{const y=u.lot;if(!y)return"";const v=y.lot??y.lotId;return v?` \u2014 ${h(String(v))}`:""})(),S=r.title??`Lot Summary${x}`;return`<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<title>${h(S)}</title>
+<style>
+${E()}
+</style>
+</head>
+<body>
+${q(S,w,n)}
+</body>
+</html>`}const m=r.title??"Lot Summary",p=s.map(u=>{const{lotSummary:w,sections:x}=Q(u.items,e,l,t,a,c,d),S=u.varying.includes("lot")?void 0:w.lot?.lot??w.lot?.lotId,y=S?`${u.label} \xB7 Lot ${String(S)}`:u.label;return q(`${m} \u2014 ${y}`,x,n)}),g=`<p style="max-width:1080px;margin:0 auto 8px;padding:8px 12px;background:var(--report-surface,#f7f8fa);border:1px solid var(--report-line,#d8dee6);border-radius:4px;font-size:12px;color:var(--report-muted,#5c6570);">This load spans ${s.length} groups by identity \u2014 shown separately below so stats are never pooled across them.</p>`,b=p.map((u,w)=>`${w===0?"":'<hr style="max-width:1080px;margin:32px auto 0;border:none;border-top:3px solid var(--report-line-strong,#c7ced8);">'}
+${u}`).join(`
+`);return`<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<title>${h(m)}</title>
+<style>
+${E()}
+</style>
+</head>
+<body>
+<div class="report" style="padding-top:24px;">
+${g}
+</div>
+${b}
+</body>
+</html>`}export{ct as openHtmlReport};

package/dist/packages/stats/reportHtml.d.ts

@@ -0,0 +1,42 @@
+import type { StatsFinding, StatsSeverity } from './types.js';
+import { type FacetItem } from './facets.js';
+export interface MetricItem {
+    label: string;
+    value: string;
+    hint?: string;
+}
+export declare function escHtml(value: string): string;
+export declare function renderSection(title: string, body: string, className?: string): string;
+export declare function renderDefinitionList(entries: Array<{
+    label: string;
+    value: string;
+}>, className?: string): string;
+/**
+ * The single source of metadata content for every report and panel surface
+ * — built from `buildFacetTable` over the actual item(s), never a
+ * first-wafer-wins shortcut (e.g. `LotStatsSummary.lot`) or a per-file
+ * known-key list, both of which can silently drop a field that varies
+ * across the population and can drift from what the live Summary panel
+ * shows (`buildMetadataInfoSection` in canvas-adapter/summaryPanel.ts,
+ * which calls the same `buildFacetTable`). A population of one wafer is
+ * just a facet table where every field has exactly one value, so the
+ * wafer- and lot-level reports render identical content for the same
+ * underlying metadata — never two independently-derived renderings.
+ */
+export declare function buildMetadataRows(items: FacetItem[]): Array<{
+    label: string;
+    value: string;
+}>;
+/** `buildMetadataRows` wrapped in a titled section. Returns `''` when there's nothing to show. */
+export declare function renderMetadataSection(items: FacetItem[]): string;
+export declare function renderMetricGrid(items: MetricItem[]): string;
+export declare function renderTable(headers: string[], rows: string[][], options?: {
+    className?: string;
+    emptyMessage?: string;
+}): string;
+export declare function renderSeverityBadge(severity: StatsSeverity): string;
+export declare function formatFindingDelta(finding: Pick<StatsFinding, 'effect' | 'variable'>): string;
+export declare function formatFindingTooltip(finding: StatsFinding): string;
+export declare function formatFindingCoverage(finding: Pick<StatsFinding, 'stats'>, total?: number): string;
+export declare function reportStyles(): string;
+//# sourceMappingURL=reportHtml.d.ts.map