@wafertools/wafermap 0.21.1

package/dist/packages/stats/reportHtml.js

@@ -0,0 +1,301 @@
+import{fmt as i}from"../renderer/fmt.js";import{buildFacetTable as d,prettyKey as s}from"./facets.js";export function escHtml(t){return t.replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/"/g,"&quot;")}export function renderSection(t,e,r=""){return`<section class="${["report-section",r].filter(Boolean).join(" ")}">
+  <h2>${escHtml(t)}</h2>
+  ${e}
+</section>`}export function renderDefinitionList(t,e="meta-list"){if(!t.length)return"";const r=t.map(a=>`<div class="definition-item"><dt>${escHtml(a.label)}</dt><dd>${escHtml(a.value)}</dd></div>`).join(`
+`);return`<dl class="${e}">
+${r}
+</dl>`}export function buildMetadataRows(t){return d(t,{facetableOnly:t.length>1}).map(r=>({label:s(r.key),value:r.values.map(a=>a.value).join(", ")}))}export function renderMetadataSection(t){const e=buildMetadataRows(t);return e.length?renderSection("Wafer Info",renderDefinitionList(e)):""}export function renderMetricGrid(t){return t.length?`<dl class="metric-grid">
+${t.map(r=>`<div class="metric">
+  <dt>${escHtml(r.label)}</dt>
+  <dd>${escHtml(r.value)}</dd>
+  ${r.hint?`<span class="metric-hint">${escHtml(r.hint)}</span>`:""}
+</div>`).join(`
+`)}
+</dl>`:""}export function renderTable(t,e,r={}){if(!e.length)return`<p class="no-data">${escHtml(r.emptyMessage??"No data")}</p>`;const a=["report-table",r.className].filter(Boolean).join(" "),n=t.map(o=>`<th>${escHtml(o)}</th>`).join(""),p=e.map(o=>`<tr>${o.map(l=>`<td>${l}</td>`).join("")}</tr>`).join(`
+`);return`<table class="${a}">
+  <thead><tr>${n}</tr></thead>
+  <tbody>${p}</tbody>
+</table>`}export function renderSeverityBadge(t){const e=t.charAt(0).toUpperCase()+t.slice(1);return`<span class="badge badge-${t}">${e}</span>`}export function formatFindingDelta(t){const e=t.effect.absoluteDelta??0,r=e>0?"+":e<0?"\u2212":"";if(t.variable.kind==="yield"||t.variable.kind==="hardBin"||t.variable.kind==="softBin")return`${r}${Math.abs(e*100).toFixed(1)} pp`;if(t.variable.kind==="test"){if(t.effect.relativeDelta!==void 0&&Number.isFinite(t.effect.relativeDelta)){const a=Math.abs(t.effect.relativeDelta*100).toFixed(1);return`${r}${a}%`}return`${r}${i(Math.abs(e),t.variable.unit)}`}return`${r}${i(Math.abs(e),t.variable.unit)}`}export function formatFindingTooltip(t){return t.summary}export function formatFindingCoverage(t,e){return e!==void 0?`${t.stats.sampleSizeLeft}/${e}`:`${t.stats.sampleSizeLeft}/${t.stats.sampleSizeRight}`}export function reportStyles(){return`
+  :root {
+    --report-font: Inter, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+    --report-text: #1f2328;
+    --report-muted: #5c6570;
+    --report-subtle: #7a828d;
+    --report-line: #d8dee6;
+    --report-line-strong: #c7ced8;
+    --report-surface: #f7f8fa;
+    --report-surface-alt: #fbfcfd;
+    --report-severity-unusual: #8b3f35;
+    --report-severity-notable: #8b6428;
+    --report-severity-info: #446883;
+  }
+
+  html {
+    background: #fff;
+  }
+
+  body {
+    margin: 0;
+    color: var(--report-text);
+    background: #fff;
+    font-family: var(--report-font);
+    font-size: 13px;
+    line-height: 1.45;
+    font-variant-numeric: tabular-nums;
+    -webkit-font-smoothing: antialiased;
+    text-rendering: optimizeLegibility;
+  }
+
+  .report {
+    max-width: 1080px;
+    margin: 0 auto;
+    padding: 24px 28px 32px;
+  }
+
+  .report-header {
+    margin: 0 0 16px;
+    padding-bottom: 12px;
+    border-bottom: 1px solid var(--report-line);
+  }
+
+  h1 {
+    margin: 0;
+    font-size: 20px;
+    font-weight: 600;
+    line-height: 1.2;
+    letter-spacing: -0.01em;
+  }
+
+  .report-subtitle {
+    margin: 6px 0 0;
+    color: var(--report-muted);
+    font-size: 12px;
+  }
+
+  section.report-section {
+    margin-top: 18px;
+    break-inside: avoid;
+    page-break-inside: avoid;
+  }
+
+  section.report-section + section.report-section {
+    border-top: 1px solid var(--report-line);
+    padding-top: 14px;
+  }
+
+  h2 {
+    margin: 0 0 8px;
+    color: var(--report-muted);
+    font-size: 11px;
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 0.09em;
+  }
+
+  .no-data {
+    margin: 0;
+    color: var(--report-muted);
+    font-style: italic;
+  }
+
+  .findings-narrative {
+    margin: 0 0 14px;
+    color: var(--report-muted);
+    font-size: 13px;
+    font-style: italic;
+    line-height: 1.6;
+  }
+
+  .definition-item {
+    display: contents;
+  }
+
+  .meta-list {
+    display: grid;
+    grid-template-columns: max-content minmax(0, 1fr);
+    column-gap: 14px;
+    row-gap: 6px;
+    align-items: baseline;
+  }
+
+  .meta-list dt {
+    margin: 0;
+    color: var(--report-muted);
+    font-size: 12px;
+    white-space: nowrap;
+  }
+
+  .meta-list dd {
+    margin: 0;
+    min-width: 0;
+  }
+
+  .metric-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
+    gap: 10px 14px;
+  }
+
+  .metric {
+    padding-top: 10px;
+    border-top: 1px solid var(--report-line);
+  }
+
+  .metric dt {
+    margin: 0 0 3px;
+    color: var(--report-muted);
+    font-size: 11px;
+    text-transform: uppercase;
+    letter-spacing: 0.06em;
+  }
+
+  .metric dd {
+    margin: 0;
+    font-size: 18px;
+    font-weight: 600;
+    line-height: 1.15;
+  }
+
+  .metric-hint {
+    display: block;
+    margin-top: 3px;
+    color: var(--report-subtle);
+    font-size: 11px;
+  }
+
+  table.report-table {
+    width: 100%;
+    border-collapse: collapse;
+    table-layout: fixed;
+    font-variant-numeric: tabular-nums;
+  }
+
+  table.report-table thead {
+    display: table-header-group;
+  }
+
+  table.report-table th,
+  table.report-table td {
+    padding: 4px 8px;
+    text-align: left;
+    vertical-align: top;
+    border-bottom: 1px solid var(--report-line);
+  }
+
+  table.report-table thead th {
+    padding-top: 3px;
+    padding-bottom: 5px;
+    color: var(--report-muted);
+    font-size: 10px;
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 0.08em;
+    border-bottom: 1px solid var(--report-line-strong);
+    background: transparent;
+  }
+
+  table.report-table tbody tr:last-child td {
+    border-bottom: none;
+  }
+
+  table.report-table.compact th,
+  table.report-table.compact td {
+    padding-top: 3px;
+    padding-bottom: 3px;
+  }
+
+  table.report-table .numeric {
+    text-align: right;
+    white-space: nowrap;
+  }
+
+  table.report-table .muted {
+    color: var(--report-muted);
+  }
+
+  table.report-table .tight {
+    white-space: nowrap;
+  }
+
+  table.report-table .summary {
+    color: var(--report-muted);
+    font-size: 12px;
+  }
+
+  .badge {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    min-width: 58px;
+    padding: 1px 6px;
+    border: 1px solid transparent;
+    border-radius: 999px;
+    font-size: 10px;
+    font-weight: 600;
+    line-height: 1.35;
+    letter-spacing: 0.04em;
+    text-transform: uppercase;
+    white-space: nowrap;
+  }
+
+  .badge-unusual {
+    color: var(--report-severity-unusual);
+    background: #f4eeec;
+    border-color: #d9c0bb;
+  }
+
+  .badge-notable {
+    color: var(--report-severity-notable);
+    background: #f5f0e6;
+    border-color: #ddcfb5;
+  }
+
+  .badge-info {
+    color: var(--report-severity-info);
+    background: #eef4f8;
+    border-color: #cfdae4;
+  }
+
+  .footer {
+    margin-top: 14px;
+    padding-top: 10px;
+    border-top: 1px solid var(--report-line);
+    color: var(--report-muted);
+    font-size: 11px;
+  }
+
+  @media print {
+    @page {
+      margin: 10mm 8mm 12mm;
+    }
+
+    body {
+      -webkit-print-color-adjust: exact;
+      print-color-adjust: exact;
+    }
+
+    .report {
+      max-width: none;
+      padding: 0;
+    }
+
+    section.report-section,
+    tr {
+      break-inside: avoid;
+      page-break-inside: avoid;
+    }
+
+    thead {
+      display: table-header-group;
+    }
+
+    .report-header {
+      padding-bottom: 8px;
+      margin-bottom: 12px;
+    }
+
+    .footer {
+      margin-top: 10px;
+    }
+  }
+  `}

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

@@ -0,0 +1,24 @@
+import type { Die } from '../core/dies.js';
+export interface ScatterPoint {
+    x: number;
+    y: number;
+    hbin: number | undefined;
+    /** Facet group this point belongs to — set only by the grouped builder. */
+    group?: string;
+}
+export interface ScatterItem {
+    dies?: Die[];
+}
+/** One point per die with valid values for both tests, across `items`. */
+export declare function buildScatterData(items: ScatterItem[], xTest: number, yTest: number): ScatterPoint[];
+/**
+ * Scatter points tagged with their facet group, for colour-by-group scatter
+ * (group replaces hard-bin colour). Unlike capability/boxplot's `groups`
+ * (which restrict to one group at a time), every group's points are
+ * returned together here — scatter never restricts, it colours.
+ */
+export declare function buildScatterDataGrouped(groups: {
+    key: string;
+    items: ScatterItem[];
+}[], xTest: number, yTest: number): ScatterPoint[];
+//# sourceMappingURL=scatter.d.ts.map

package/dist/packages/stats/scatter.js

@@ -0,0 +1 @@
+function u(i,o,s,t,n){for(const e of i??[]){const f=e.testValues?.[o],r=e.testValues?.[s];f!==void 0&&r!==void 0&&Number.isFinite(f)&&Number.isFinite(r)&&n.push(t===void 0?{x:f,y:r,hbin:e.hbin}:{x:f,y:r,hbin:e.hbin,group:t})}}export function buildScatterData(i,o,s){const t=[];for(const n of i)u(n.dies,o,s,void 0,t);return t}export function buildScatterDataGrouped(i,o,s){const t=[];for(const n of i)for(const e of n.items)u(e.dies,o,s,n.key,t);return t}

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

@@ -0,0 +1,269 @@
+import type { WaferMapInput, WaferMapResult } from '../renderer/buildWaferMap.js';
+export type StatsSeverity = 'info' | 'notable' | 'unusual';
+export type StatsLevel = 'wafer' | 'lot' | 'inter-wafer';
+export type StatsVariableKind = 'yield' | 'hardBin' | 'softBin' | 'test' | 'functionalTest' | 'spatialPattern';
+export type StatsComparisonFamily = 'ring' | 'quadrant' | 'reticle-position' | 'test-site' | 'wafer' | 'sector' | 'cluster' | 'edge-arc' | 'spatial-pattern';
+export interface HighlightRegionTarget {
+    kind: 'region';
+    regionFamily: 'ring' | 'quadrant' | 'reticle-position' | 'test-site' | 'sector';
+    /**
+     * Provenance only — the region keys this finding covers, e.g. `["ring:1", "ring:2"]`
+     * (a merged band lists several). Not used for rendering: the built-in highlight draws
+     * per-die rectangles from {@link dieKeys}. Exposed so callers can group or filter findings
+     * by region without re-parsing the label, and read by the adjacent-finding merge pass.
+     * Same field name and meaning as {@link HighlightBinTarget.regionKeys}.
+     */
+    regionKeys: string[];
+    /** The dies to highlight — what the renderer actually draws. */
+    dieKeys?: string[];
+}
+export interface HighlightBinTarget {
+    kind: 'bin';
+    bin: number;
+    /** Provenance only — see {@link HighlightRegionTarget.regionKeys}. The renderer draws from {@link dieKeys}. */
+    regionKeys?: string[];
+    /** The dies to highlight — what the renderer actually draws. */
+    dieKeys?: string[];
+}
+export interface HighlightWaferTarget {
+    kind: 'wafer';
+    waferIndices: number[];
+}
+export interface HighlightDieTarget {
+    kind: 'dies';
+    dieKeys: string[];
+}
+export type HighlightTarget = HighlightRegionTarget | HighlightBinTarget | HighlightWaferTarget | HighlightDieTarget;
+export interface StatsFinding {
+    id: string;
+    level: StatsLevel;
+    severity: StatsSeverity;
+    variable: {
+        kind: StatsVariableKind;
+        index?: number;
+        bin?: number;
+        label: string;
+        unit?: string;
+    };
+    comparison: {
+        family: StatsComparisonFamily;
+        left: string;
+        right: string;
+    };
+    effect: {
+        direction: 'higher' | 'lower' | 'different';
+        absoluteDelta?: number;
+        relativeDelta?: number;
+        effectSize?: number;
+    };
+    stats: {
+        method: string;
+        pValue?: number;
+        adjustedPValue?: number;
+        sampleSizeLeft: number;
+        sampleSizeRight: number;
+    };
+    summary: string;
+    highlight: HighlightTarget;
+    /** IDs of other findings that describe the same signal at a finer level of detail. */
+    relatedIds?: string[];
+}
+export interface StatsSummary {
+    level: 'wafer';
+    hasNotableFindings: boolean;
+    findings: StatsFinding[];
+    /** Free-form identity fields from waferConfig.metadata (lot, wafer ID, test date, etc.). */
+    wafer?: Record<string, unknown>;
+    /** Engine-computed analysis stats for this wafer. */
+    stats: {
+        totalDies: number;
+        analyzedDies: number;
+        excludedDies: number;
+        /** `(passDies / totalDies) × 100` in [0, 100], or `null` when no bin data is present. */
+        yieldPercent: number | null;
+        testsConsidered: number[];
+        hardBinsConsidered: number[];
+        softBinsConsidered: number[];
+        /**
+         * Die counts per hard/soft bin, keyed by bin code, over the same
+         * yield-eligible population `YieldSummary`/`buildBinParetoData` use
+         * (`isYieldEligibleDie` — excludes `partial`/`edgeExcluded` dies).
+         * Unlike `hardBinsConsidered`/`softBinsConsidered` (which list every bin
+         * code that appears anywhere, eligible or not), these are the actual
+         * counts a bin-breakdown display should show. Consumed by
+         * `buildBinParetoData`/`buildBinClusterData` and the summary panel's bin
+         * section when supplied, instead of each independently re-walking dies.
+         */
+        hardBinCounts?: Record<number, number>;
+        softBinCounts?: Record<number, number>;
+        /** Structured warnings emitted during analysis (e.g. test-count cap exceeded). */
+        warnings?: string[];
+        /** True when this summary was produced from lot-aggregated data (lotStack). */
+        isLotStack?: boolean;
+        /** Aggregation method used to produce the lot-stack (e.g. 'mean', 'countBin'). Present only when isLotStack is true. */
+        aggregationMethod?: string;
+        /** Number of wafers in the lot stack. Present only when isLotStack is true. */
+        lotSize?: number;
+        /**
+         * Per-test spec yield for each test that has at least one limit defined.
+         * Only populated when testDefs with limitLow/limitHigh are provided.
+         */
+        testSpecYield?: Array<{
+            testNumber: number;
+            label: string;
+            passDies: number;
+            failLowDies: number;
+            failHighDies: number;
+            totalDies: number;
+            /** `(passDies / totalDies) × 100` in [0, 100], or `null` when no dies had this test. */
+            yieldPercent: number | null;
+        }>;
+        /**
+         * Per-test pass rate for each functional (`testType: 'F'`) test — "functional
+         * yield" in fab terms. Verdicts are read via `getTestPassStatus` (recorded
+         * `testPass` first, then the legacy 0/1 `testValues` fallback). The
+         * denominator is dies with a recorded verdict for the test — partial and
+         * edge-excluded dies are excluded, dies never tested are not counted as fails.
+         * Only populated when functional testDefs are provided.
+         */
+        functionalYield?: Array<{
+            testNumber: number;
+            label: string;
+            passDies: number;
+            failDies: number;
+            /** Dies with a recorded pass/fail verdict for this test. */
+            totalDies: number;
+            /** `(passDies / totalDies) × 100` in [0, 100], or `null` when no dies had a verdict. */
+            passRatePercent: number | null;
+        }>;
+        /**
+         * Descriptive statistics for each test's values across all eligible dies.
+         * Only populated when `computePerTestStats` or `enableTestValueAnalysis` is
+         * true and the test count is within the cap.
+         */
+        perTestStats?: Array<{
+            testNumber: number;
+            label: string;
+            count: number;
+            min: number;
+            max: number;
+            mean: number;
+            stddev: number;
+            median: number;
+            q1: number;
+            q3: number;
+        }>;
+    };
+}
+export interface LotStatsSummary {
+    level: 'lot';
+    hasNotableFindings: boolean;
+    findings: StatsFinding[];
+    /** Free-form lot-level identity fields (lot ID, product, etc. — wafer-specific keys excluded). */
+    lot?: Record<string, unknown>;
+    /** Engine-computed analysis stats for this lot. */
+    stats: {
+        waferCount: number;
+    };
+    /** Per-wafer yield as a flat series, ordered by waferIndex. `yieldPercent` is in [0, 100]; null when a wafer had no bin data. */
+    lotYieldSeries: Array<{
+        waferIndex: number;
+        yieldPercent: number | null;
+    }>;
+    perWafer: Array<{
+        waferIndex: number;
+        summary: StatsSummary;
+    }>;
+    /**
+     * Per-wafer × per-test descriptive statistics, for box-plot rendering.
+     * Only populated when `computePerTestStats` or `enableTestValueAnalysis` is
+     * true and at least one wafer has test data. Prefer `computePerTestStats` for
+     * box plots — it skips the expensive regional Welch pass.
+     * Each entry's `tests` array has the same shape as `StatsSummary.stats.perTestStats`.
+     */
+    perWaferTestStats?: Array<{
+        waferIndex: number;
+        tests: Array<{
+            testNumber: number;
+            label: string;
+            count: number;
+            min: number;
+            max: number;
+            mean: number;
+            stddev: number;
+            median: number;
+            q1: number;
+            q3: number;
+        }>;
+    }>;
+}
+export interface AnalyzeWaferMapOptions {
+    /**
+     * Should mirror the ring count used by the renderer for consistent semantics.
+     * Defaults to 4, which matches the current render default.
+     */
+    ringCount?: number;
+    passBins?: number[];
+    significanceLevel?: number;
+    minimumEffectSize?: number;
+    /**
+     * Minimum relative effect size (|delta / background|) for proportion findings.
+     * Catches meaningful signals on low-failure-rate wafers where the absolute delta
+     * is small but the relative deviation is large. Default 1.0 (100% of background).
+     */
+    minimumRelativeEffect?: number;
+    includePartial?: boolean;
+    includeEdgeExcluded?: boolean;
+    enableYieldAnalysis?: boolean;
+    enableHardBinAnalysis?: boolean;
+    enableSoftBinAnalysis?: boolean;
+    /**
+     * Full parametric **spatial significance** analysis: Welch comparisons of each
+     * test's values between every region (ring/quadrant/reticle/site/sector) and
+     * the rest of the wafer, plus spec-limit region findings. This is the expensive
+     * pass — it scales with (regions × tests × dies) — so it is **off by default**.
+     * Enable it only when you display the resulting regional test-value findings.
+     *
+     * For per-test descriptive statistics (mean/stddev/quartiles for box plots)
+     * **without** the spatial comparisons, use {@link computePerTestStats} instead —
+     * it is an order of magnitude cheaper. Enabling `enableTestValueAnalysis` also
+     * produces `perTestStats`, so you do not need both.
+     */
+    enableTestValueAnalysis?: boolean;
+    /**
+     * Compute per-test descriptive statistics (`count`, `min`, `max`, `mean`,
+     * `stddev`, `median`, `q1`, `q3`) into `StatsSummary.stats.perTestStats` —
+     * the cheap quartile scan only, **without** the expensive regional Welch
+     * comparisons of {@link enableTestValueAnalysis}. Use this for box-plot /
+     * histogram panels that need distribution shape but not spatial findings.
+     * Off by default. Implied by `enableTestValueAnalysis`.
+     */
+    computePerTestStats?: boolean;
+    enableReticlePositionAnalysis?: boolean;
+    /**
+     * Analyse yield and bin distributions by test site (`siteNum`).
+     * Enabled automatically when the wafer contains meaningful site duplication
+     * (at least 2 distinct site numbers each appearing on 3 or more dies).
+     * Set to `false` to suppress, or `true` to force-enable regardless of the guard.
+     */
+    enableTestSiteAnalysis?: boolean;
+    /** Detect contiguous failure clusters and edge arc damage. Default true. */
+    enableClusterAnalysis?: boolean;
+    /** Angular sector analysis (finer-grained than quadrants). Default true. */
+    enableAngularAnalysis?: boolean;
+    /** Number of angular sectors for sector analysis. Must be 4, 8, 16, or 32. Default 8. */
+    sectorCount?: number;
+    /** Classify the spatial failure pattern (center, edge-ring, scratch, etc.). Default true. */
+    enablePatternClassification?: boolean;
+    /**
+     * Restrict test value analysis to a specific subset of test numbers.
+     * When omitted and more than 250 tests are present in the data, test value
+     * analysis is skipped automatically with a console warning — pass this option
+     * to analyse a specific subset in that case.
+     * Example: `testNumbers: [1050, 1060, 1070]`
+     */
+    testNumbers?: number[];
+}
+export type AnalyzeWaferMapInput = WaferMapInput | WaferMapResult;
+export type AnalyzeWaferLotInput = Array<WaferMapInput | WaferMapResult>;
+//# sourceMappingURL=types.d.ts.map

package/dist/packages/stats/types.js

@@ -0,0 +1 @@
+export{};

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

@@ -0,0 +1,56 @@
+import type { Die } from '../core/dies.js';
+/** Shared row shape for every bar-chart panel (yield, bin pareto, ...). */
+export interface ChartDatum {
+    label: string;
+    value: number;
+    percent: number;
+    /** Number of items (wafers) pooled into this row — >1 marks a drillable group row. */
+    itemCount: number;
+    /** Bin code this datum represents — only set for bin-pareto data. */
+    binCode?: number;
+    /**
+     * Stable identity for a leaf row (`itemCount === 1`), independent of
+     * `label` — a caller with an `onOpen` callback should resolve back to its
+     * own item by `key`, not by re-searching for `label`. Labels are only
+     * guaranteed unique when the caller supplies one per item; an item with no
+     * `label` falls back to a shared default elsewhere (e.g. `analysisTab.ts`
+     * falls back to `''` when both `label` and `wafer.metadata.waferId` are
+     * absent), so two rows can carry an identical, ambiguous label — matching
+     * on it would silently resolve to the wrong item. Absent on group rows
+     * (`itemCount > 1`), which are drilled into rather than opened directly.
+     */
+    key?: string | number;
+}
+export interface YieldItem {
+    label?: string;
+    dies?: Die[];
+    /**
+     * Precomputed yield percent for this item (e.g. from `analyzeWaferLot`'s
+     * `lotYieldSeries[waferIndex].yieldPercent`) — used directly when present.
+     * Omit to have it computed from `dies` instead.
+     */
+    yieldPercent?: number | null;
+    /** Carried through to the resulting `ChartDatum.key` unchanged — see its doc comment. */
+    key?: string | number;
+}
+export type YieldSortBy = 'yield' | 'label';
+/** One bar per item. */
+export declare function buildYieldData(items: YieldItem[], passBins?: number[], sortBy?: YieldSortBy): ChartDatum[];
+/**
+ * Combined yield: one bar per group, pooling the group's items. The pooled
+ * yield is the yield-eligible-die-count-weighted mean of per-item yields —
+ * exact for the standard pass/total definition (Σ pass / Σ total =
+ * Σ(yield·dies)/Σ dies), *provided* `dies` is the same population the rate
+ * was computed over. Weighting uses `yieldEligibleDieCount` (excludes
+ * partial/edge-excluded dies), not raw `dies.length` — a per-item
+ * `yieldPercent` (own or precomputed, e.g. from `analyzeWaferLot`) already
+ * excludes those dies from its own numerator/denominator (`resolveYieldPercent`
+ * → `isYieldEligibleDie`), so weighting by the raw count would let a wafer's
+ * excluded dies (which count toward yield nowhere else) still skew this
+ * combined bar.
+ */
+export declare function buildYieldDataCombined(groups: {
+    key: string;
+    items: YieldItem[];
+}[], passBins?: number[], sortBy?: YieldSortBy): ChartDatum[];
+//# sourceMappingURL=yield.d.ts.map

package/dist/packages/stats/yield.js

@@ -0,0 +1 @@
+import{isYieldEligibleDie as d}from"../core/dies.js";import{compareNatural as b}from"../core/utils.js";function p(e,n){let i=0,t=0;for(const l of e){if(!d(l))continue;const o=l.hbin??l.sbin;o!==void 0&&(t++,n.includes(o)&&i++)}return t>0?i/t*100:0}function s(e,n){return e.yieldPercent!==void 0?e.yieldPercent??0:p(e.dies??[],n)}function m(e){let n=0;for(const i of e)d(i)&&n++;return n}function f(e,n){n==="yield"?e.sort((i,t)=>t.value-i.value):e.sort((i,t)=>b(i.label,t.label))}export function buildYieldData(e,n=[1],i="label"){const t=e.map((l,o)=>{const r=s(l,n);return{label:l.label??`#${o}`,value:r,percent:r,itemCount:1,key:l.key}});return f(t,i),t}export function buildYieldDataCombined(e,n=[1],i="label"){const t=e.map(l=>{let o=0,r=0;for(const c of l.items){const a=m(c.dies??[]);o+=s(c,n)*a,r+=a}const u=r>0?o/r:0;return{label:l.key,value:u,percent:u,itemCount:l.items.length}});return f(t,i),t}