@wafertools/wafermap 0.21.1

package/dist/packages/canvas-adapter/version.d.ts

@@ -0,0 +1,3 @@
+export declare const WMAP_VERSION = "0.21.1";
+export declare const WMAP_BUILD_TIME = "2026-08-01T11:07:58.032Z";
+//# sourceMappingURL=version.d.ts.map

package/dist/packages/canvas-adapter/version.js

@@ -0,0 +1 @@
+export const WMAP_VERSION="0.21.1",WMAP_BUILD_TIME="2026-08-01T11:07:58.032Z";

package/dist/packages/core/aggregates.d.ts

@@ -0,0 +1,54 @@
+import type { Die } from './dies.js';
+export type AggregationMethod = 'mean' | 'median' | 'stddev' | 'min' | 'max' | 'count';
+/** Minimal die shape required by aggregation functions — satisfied by both Die and DieResult. */
+export interface DieLike {
+    x: number;
+    y: number;
+    testValues?: Record<number, number>;
+    /** Recorded per-test pass/fail verdicts (true = pass). Never aggregated — always stripped from outputs. */
+    testPass?: Record<number, boolean>;
+    hbin?: number;
+    sbin?: number;
+}
+/**
+ * Aggregate a per-test-parameter numeric value across a lot of wafers.
+ *
+ * @param diesByWafer  One `Die[]` per wafer — all wafers must share the same grid layout.
+ * @param method       Aggregation function applied per (x,y) position across all wafers.
+ * @param paramIndex   Which `die.testValues` key to aggregate — a test number such as
+ *                     `1050`, not a positional index (default 0).
+ * @returns One Die per unique (x,y) position with the aggregate stored at
+ *          `testValues[0]` regardless of the input key. Dies that had no value on any
+ *          wafer are included with `testValues: undefined` as a "no data" signal —
+ *          they are not filtered out.
+ *
+ * @example Compute mean test value across a lot:
+ * ```ts
+ * const lotMean = aggregateValues(diesByWafer, 'mean');
+ * const scene = buildView(wafer, lotMean, { plotMode: 'value' });
+ * ```
+ */
+export declare function aggregateValues(diesByWafer: DieLike[][], method: AggregationMethod, paramIndex?: number): DieLike[];
+/**
+ * Return all unique bin values present in dies, sorted ascending.
+ * `binSpace` selects whether to inspect `die.hbin` (default) or `die.sbin`.
+ */
+export declare function getUniqueBins(dies: Die[], binSpace?: 'hard' | 'soft'): number[];
+/**
+ * Aggregate multiple wafers by counting, per die position, how many wafers
+ * had a specific bin value.
+ *
+ * Returns one Die per unique (x,y) position (using the first wafer's layout
+ * as the spatial template) where:
+ *   values[0]  = number of wafers that had targetBin at this position
+ *   hbin/sbin  = targetBin (in the appropriate bin space)
+ *
+ * Use with plotMode: 'value' and valueRange: [0, diesByWafer.length] to get
+ * a colour scale that runs from "never" to "always".
+ *
+ * @param diesByWafer  One Die[] per wafer, all sharing the same grid layout.
+ * @param targetBin    The bin value to count.
+ * @param binSpace     Which bin space to test — `'hard'` (default) or `'soft'`.
+ */
+export declare function aggregateBinCounts(diesByWafer: DieLike[][], targetBin: number, binSpace?: 'hard' | 'soft'): DieLike[];
+//# sourceMappingURL=aggregates.d.ts.map

package/dist/packages/core/aggregates.js

@@ -0,0 +1 @@
+import{getDieKey as g}from"./dies.js";export function aggregateValues(u,s,l=0){if(!u.length)return[];const n=new Map,t=new Map;for(const d of u)for(const o of d){const e=g(o),f=o.testValues?.[l];f!==void 0?(n.has(e)||(n.set(e,[]),t.set(e,o)),n.get(e).push(f)):t.has(e)||t.set(e,o)}const r=[];for(const[d,o]of t){const e=n.get(d);if(!e?.length){r.push({...o,testValues:void 0,testPass:void 0});continue}let f;if(s==="mean")f=e.reduce((i,a)=>i+a,0)/e.length;else if(s==="median"){const i=[...e].sort((c,h)=>c-h),a=Math.floor(i.length/2);f=i.length%2?i[a]:(i[a-1]+i[a])/2}else if(s==="stddev"){if(e.length<2){r.push({...o,testValues:{0:0},testPass:void 0});continue}const i=e.reduce((a,c)=>a+c,0)/e.length;f=Math.sqrt(e.reduce((a,c)=>a+(c-i)**2,0)/(e.length-1))}else s==="min"?f=Math.min(...e):s==="max"?f=Math.max(...e):f=e.length;r.push({...o,testValues:{0:f},testPass:void 0})}return r}export function getUniqueBins(u,s="hard"){const l=new Set;for(const n of u){const t=s==="soft"?n.sbin:n.hbin;t!==void 0&&l.add(t)}return[...l].sort((n,t)=>n-t)}export function aggregateBinCounts(u,s,l="hard"){if(!u.length)return[];const n=new Map;for(const t of u)for(const r of t)if((l==="soft"?r.sbin:r.hbin)===s){const o=g(r);n.set(o,(n.get(o)??0)+1)}return(u[0]??[]).map(t=>({...t,testValues:{0:n.get(g(t))??0},testPass:void 0,...l==="soft"?{sbin:s}:{hbin:s}}))}

package/dist/packages/core/classify.d.ts

@@ -0,0 +1,24 @@
+import type { Wafer } from './wafer.js';
+import type { Die } from './dies.js';
+export type Quadrant = 'NE' | 'NW' | 'SW' | 'SE';
+export interface DieClassification {
+    ring: number;
+    quadrant: Quadrant;
+}
+export interface ClassifyOptions {
+    ringCount?: number;
+}
+/**
+ * Classify a die by its radial ring (1 = innermost) and physical wafer quadrant.
+ *
+ * Quadrant and ring are computed from `physX/physY`, which carry `wafer.orientation`
+ * (notch position) but NOT the view's interactive rotation. This is deliberate:
+ * spatial findings ("NE quadrant yield is low") describe the physical wafer relative
+ * to its notch, so they must follow orientation and stay invariant to how the user
+ * has rotated the on-screen view. (Not "screen" coordinates — those are post-
+ * interactive-transform and live only in the renderer.)
+ */
+export declare function classifyDie(die: Die, wafer: Wafer, options?: ClassifyOptions): DieClassification;
+/** Human-readable label for a ring index (1-based) given a total ring count. */
+export declare function getRingLabel(ring: number, ringCount: number): string;
+//# sourceMappingURL=classify.d.ts.map

package/dist/packages/core/classify.js

@@ -0,0 +1 @@
+export function classifyDie(t,e,s={}){const o=Math.max(1,s.ringCount??4),n=t.physX-e.center.x,r=t.physY-e.center.y,a=Math.sqrt(n*n+r*r)/e.radius,c=Math.min(o,Math.max(1,Math.floor(a*o)+1));let i;return n>=0&&r>=0?i="NE":n<0&&r>=0?i="NW":n<0&&r<0?i="SW":i="SE",{ring:c,quadrant:i}}export function getRingLabel(t,e){return e===1?"Full Wafer":t===1?"Ring 1 (core)":t===e?`Ring ${t} (edge)`:`Ring ${t}`}

package/dist/packages/core/dies.d.ts

@@ -0,0 +1,92 @@
+import type { Wafer } from './wafer.js';
+import type { DieMetadata } from './metadata.js';
+export interface DieSpec {
+    width: number;
+    height: number;
+    gridSize?: number;
+    offset?: {
+        x: number;
+        y: number;
+    };
+}
+export interface Die {
+    id: string;
+    x: number;
+    y: number;
+    physX: number;
+    physY: number;
+    width: number;
+    height: number;
+    /**
+     * Test values keyed by test number (a stable per-test identity, e.g. STDF TEST_NUM).
+     * Example: `{ 1050: 1.42e-3, 1060: 0.487, 1070: 8.3e-12 }`
+     */
+    testValues?: Record<number, number>;
+    /**
+     * Recorded per-test pass/fail verdicts keyed by test number (true = pass),
+     * parallel to `testValues`. Parametric tests carry a value in `testValues`
+     * and may optionally carry a verdict here; functional tests (`testType: 'F'`)
+     * carry a verdict here ONLY — they have no measured value.
+     * Example: `{ 2001: true, 2002: false }`
+     */
+    testPass?: Record<number, boolean>;
+    hbin?: number;
+    sbin?: number;
+    metadata?: DieMetadata;
+    insideWafer?: boolean;
+    partial?: boolean;
+    edgeExcluded?: boolean;
+    probeIndex?: number;
+    /** Number of times this die position appeared in the input results. Only set when > 1. */
+    retestCount?: number;
+    /** STDF site_num — which parallel test site tested this die. Only meaningful when > 1 distinct value appears per wafer. */
+    siteNum?: number;
+    /** STDF pir.part_id — tester-assigned identifier for this tested unit. Encodes probe sequence at most fabs. */
+    partId?: number;
+}
+export interface DieEligibilityOptions {
+    /** Include dies that straddle the wafer boundary (`die.partial`). Default: excluded. */
+    includePartial?: boolean;
+    /** Include dies inside the edge-exclusion zone (`die.edgeExcluded`). Default: excluded. */
+    includeEdgeExcluded?: boolean;
+}
+/**
+ * Whether a die counts toward yield/rollup calculations, per wmap's standard
+ * fab-reporting convention: partial (boundary-straddling) and edge-excluded
+ * dies are skipped by default, even though they may carry real measured
+ * values — many fabs exclude them from yield/bin reporting specifically,
+ * not from other per-die analysis (a partial/edge-excluded die's test
+ * values still belong in distributions, correlations, scatter, etc. — this
+ * predicate is for yield-style pass/fail rollups only).
+ *
+ * Single source of truth for this rule — previously duplicated independently
+ * in `renderer/buildWaferMap.ts`'s yield calculation and
+ * `stats/analyzeWaferMap.ts`'s eligible-die filter, which could (and did)
+ * silently drift apart. Both now call this.
+ */
+/**
+ * Return a stable string key for a die — guaranteed format `"x,y"`.
+ *
+ * THE way to build a die key. Use it for Map keys and post-enrichment lookups
+ * rather than an ad-hoc template literal: findings carry `dieKeys` in this exact
+ * format and the renderer resolves highlights by matching them, so a single site
+ * that formats keys differently silently breaks click-to-highlight. Same reason
+ * it lives in `core/` — `renderer/`, `stats/` and `canvas-adapter/` all need to
+ * agree on one format.
+ *
+ * ```ts
+ * const map = new Map(result.dies.map(d => [getDieKey(d), d]));
+ * const die = map.get(getDieKey({ x: 3, y: -2 }));
+ * ```
+ */
+export declare function getDieKey(die: {
+    x: number;
+    y: number;
+}): string;
+export declare function isYieldEligibleDie(die: Die, options?: DieEligibilityOptions): boolean;
+/**
+ * Generate a rectangular grid of dies centered on the wafer.
+ * Each die carries its width/height for use by the renderer.
+ */
+export declare function generateDies(wafer: Wafer, dieConfig: DieSpec): Die[];
+//# sourceMappingURL=dies.d.ts.map

package/dist/packages/core/dies.js

@@ -0,0 +1 @@
+export function getDieKey(e){return`${e.x},${e.y}`}export function isYieldEligibleDie(e,t={}){return!(!t.includePartial&&e.partial||!t.includeEdgeExcluded&&e.edgeExcluded)}export function generateDies(e,t){const{width:c,height:l,offset:u={x:0,y:0}}=t,n=t.gridSize??Math.ceil(e.radius/Math.min(c,l))+1,s=[];for(let r=-n;r<=n;r++)for(let i=-n;i<=n;i++){const o=e.center.x+i*c+u.x,d=e.center.y+r*l+u.y;s.push({id:`${i}_${r}`,x:i,y:r,physX:o,physY:d,width:c,height:l})}return s}

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

@@ -0,0 +1,13 @@
+export * from './aggregates.js';
+export * from './classify.js';
+export * from './dies.js';
+export * from './metadata.js';
+export * from './probe.js';
+export * from './reticle.js';
+export type { DataRow, MapOptions, TransformOptions, Affine, CoordFrame } from './transforms.js';
+export { isInsideWafer, clipDiesToWafer, applyOrientation, transformDies, mapDataToDies } from './transforms.js';
+export { affineIdentity, affineRotation, affineMirror, affineCompose, affineInvert, affinePoint, affineVector, affineSwapsAxes, } from './transforms.js';
+export * from './wafer.js';
+export type { PitchResult } from './inference/pitch.js';
+export { resolveGridPitch } from './inference/pitch.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/packages/core/index.js

@@ -0,0 +1 @@
+export*from"./aggregates.js";export*from"./classify.js";export*from"./dies.js";export*from"./metadata.js";export*from"./probe.js";export*from"./reticle.js";export{isInsideWafer,clipDiesToWafer,applyOrientation,transformDies,mapDataToDies}from"./transforms.js";export{affineIdentity,affineRotation,affineMirror,affineCompose,affineInvert,affinePoint,affineVector,affineSwapsAxes}from"./transforms.js";export*from"./wafer.js";export{resolveGridPitch}from"./inference/pitch.js";

package/dist/packages/core/inference/grid.d.ts

@@ -0,0 +1,35 @@
+export interface GridAssignment {
+    /** Parallel to the input points array — x,y index for each point. */
+    indices: Array<{
+        x: number;
+        y: number;
+    }>;
+    /**
+     * Integer offset of the grid origin from (0,0) in prober-step units.
+     * To map a generated die's (x,y) back to the original prober position:
+     *   origX = die.x + offsetX,  origY = die.y + offsetY
+     */
+    offsetX: number;
+    offsetY: number;
+    /**
+     * 1.0 when all input positions are already integers (typical prober data);
+     * lower when positions have significant fractional parts.
+     */
+    confidence: number;
+}
+/**
+ * Assign grid indices to prober-step grid positions.
+ *
+ * Input x,y are die grid positions (prober step coordinates — integers in
+ * normal use).  The offset is the rounded centroid of all positions so that
+ * the generated die grid is centred at the wafer's physical origin (0,0).
+ *
+ * The offset is always an integer, which ensures that x = inputX − offsetX is
+ * also an integer for integer inputs regardless of whether the centroid is
+ * a whole number or a half-integer (e.g. even-count symmetric grids).
+ */
+export declare function assignGridIndices(gridPoints: Array<{
+    x: number;
+    y: number;
+}>): GridAssignment;
+//# sourceMappingURL=grid.d.ts.map

package/dist/packages/core/inference/grid.js

@@ -0,0 +1 @@
+export function assignGridIndices(e){if(e.length===0)return{indices:[],offsetX:0,offsetY:0,confidence:1};const f=e.reduce((n,t)=>n+t.x,0)/e.length,h=e.reduce((n,t)=>n+t.y,0)/e.length,c=Math.round(f),o=Math.round(h),a=e.map(n=>({x:Math.round(n.x)-c,y:Math.round(n.y)-o})),s=1-e.filter(n=>Math.abs(n.x-Math.round(n.x))>.01||Math.abs(n.y-Math.round(n.y))>.01).length/e.length;return{indices:a,offsetX:c,offsetY:o,confidence:s}}

package/dist/packages/core/inference/index.d.ts

@@ -0,0 +1,7 @@
+export type { WaferInference } from './wafer.js';
+export { inferWaferFromXY } from './wafer.js';
+export type { PitchResult } from './pitch.js';
+export { resolveGridPitch } from './pitch.js';
+export type { GridAssignment } from './grid.js';
+export { assignGridIndices } from './grid.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/packages/core/inference/index.js

@@ -0,0 +1 @@
+export{inferWaferFromXY}from"./wafer.js";export{resolveGridPitch}from"./pitch.js";export{assignGridIndices}from"./grid.js";

package/dist/packages/core/inference/pitch.d.ts

@@ -0,0 +1,26 @@
+export interface PitchResult {
+    pitchX: number;
+    pitchY: number;
+    /** 'mm' when at least one physical dimension is known; 'normalized' when
+     *  dimensions are estimated solely from the circular grid constraint. */
+    units: 'mm' | 'normalized';
+    confidence: number;
+}
+/**
+ * Resolve die pitch from prober-step grid positions and optional geometry.
+ *
+ * Input x,y are integer prober step coordinates (die grid positions), not mm.
+ * Physical mm position = grid_pos × pitch.
+ *
+ * When neither die dimensions nor wafer diameter are known, the function tries
+ * nearest-neighbour step analysis first (works well for regular grids with ≥ 4
+ * points), then falls back to the circular-wafer aspect-ratio constraint.
+ */
+export declare function resolveGridPitch(gridPoints: Array<{
+    x: number;
+    y: number;
+}>, dieOpts?: {
+    width?: number;
+    height?: number;
+}, waferDiameter?: number): PitchResult;
+//# sourceMappingURL=pitch.d.ts.map

package/dist/packages/core/inference/pitch.js

@@ -0,0 +1 @@
+import{modeOf as Y}from"../utils.js";function X(s){if(!s.length)return null;const i=s.map(e=>Math.round(e*10)/10);return Y(i)}function R(s){if(s.length<2)return null;const i=s.map(t=>({x:Math.round(t.x),y:Math.round(t.y)})),e=new Map;for(const t of i){const n=e.get(t.y)??[];n.push(t.x),e.set(t.y,n)}const l=[];for(const t of e.values()){t.sort((n,c)=>n-c);for(let n=1;n<t.length;n++){const c=t[n]-t[n-1];c>0&&l.push(c)}}const h=new Map;for(const t of i){const n=h.get(t.x)??[];n.push(t.y),h.set(t.x,n)}const r=[];for(const t of h.values()){t.sort((n,c)=>n-c);for(let n=1;n<t.length;n++){const c=t[n]-t[n-1];c>0&&r.push(c)}}const f=X(l),u=X(r);return f===null&&u===null?null:{pitchX:f??u,pitchY:u??f}}export function resolveGridPitch(s,i,e){const l=i?.width!==void 0,h=i?.height!==void 0;if(l&&h)return{pitchX:i.width,pitchY:i.height,units:"mm",confidence:1};if(s.length===0){const o=l?i.width:h?i.height:10;return{pitchX:o,pitchY:o,units:l||h||e!==void 0?"mm":"normalized",confidence:0}}let r=1/0,f=-1/0,u=1/0,y=-1/0;for(const o of s)o.x<r&&(r=o.x),o.x>f&&(f=o.x),o.y<u&&(u=o.y),o.y>y&&(y=o.y);const x=f-r+1,t=y-u+1;let n,c,d,a;if(l)n=i.width,c=n*x/t,d="mm",a=.8;else if(h)c=i.height,n=c*t/x,d="mm",a=.8;else if(e!==void 0)n=e/x,c=e/t,d="mm",a=.6;else{const o=R(s),M=o!==null?o.pitchY/o.pitchX:1,p=M===1&&t>0?x/t:M;n=1,c=p,d="normalized",a=o!==null?.5:.4}if(e!==void 0){const o=e/2,M=(r+f)/2,g=(u+y)/2;let p=0;for(const m of s){const b=Math.hypot(n*(Math.abs(m.x-M)+.5),c*(Math.abs(m.y-g)+.5));b>p&&(p=b)}if(p>o){const m=o/p;n*=m,c*=m}}return{pitchX:n,pitchY:c,units:d,confidence:a}}

package/dist/packages/core/inference/wafer.d.ts

@@ -0,0 +1,30 @@
+export interface WaferInference {
+    center: {
+        x: number;
+        y: number;
+    };
+    diameter: number;
+    radius: number;
+    confidence: number;
+    method: string;
+}
+/**
+ * Infer wafer geometry (center + diameter) from a set of XY die positions.
+ * Snaps to standard wafer sizes; prefers 200mm/300mm if within ±10%.
+ *
+ * `minRadius` is a HARD floor: the resulting wafer is never smaller than this.
+ * Callers pass the distance to the furthest corner of the furthest die, because a
+ * die carrying test results is a real tested prober position and is therefore
+ * always fully on the wafer — a prober cannot step to a site that overhangs the
+ * edge. That makes the die extent ground truth and the inferred diameter the
+ * guess, so the guess must yield to it. Without this floor the p98 sizing below
+ * can undersize the wafer and manufacture "partial" dies that cannot physically
+ * exist.
+ */
+export declare function inferWaferFromXY(points: Array<{
+    x: number;
+    y: number;
+}>, options?: {
+    minRadius?: number;
+}): WaferInference;
+//# sourceMappingURL=wafer.d.ts.map

package/dist/packages/core/inference/wafer.js

@@ -0,0 +1 @@
+import{percentile98 as R,clamp01 as D}from"../utils.js";const M=[25,50,75,100,150,200,300,450],x=[100,150,200,300];export function inferWaferFromXY(t,a={}){if(t.length===0)return{center:{x:0,y:0},diameter:300,radius:150,confidence:0,method:"default"};const d=t.reduce((n,o)=>n+o.x,0)/t.length,c=t.reduce((n,o)=>n+o.y,0)/t.length,r=t.map(n=>Math.sqrt((n.x-d)**2+(n.y-c)**2)),f=R(r),e=(a.minRadius??0)*2,i=Math.max(f*2*1.05,e),s=y(i,e),m=r.reduce((n,o)=>n+o,0)/r.length,u=Math.sqrt(r.reduce((n,o)=>n+(o-m)**2,0)/r.length),h=m>0?u/m:1,l=D(1-h*.5);return{center:{x:d,y:c},diameter:s.diameter,radius:s.diameter/2,confidence:l,method:s.method}}function y(t,a=0){const d=e=>e>=a;for(const e of x)if(d(e)&&Math.abs(t-e)/e<=.1)return{diameter:e,method:`snapped-${e}mm`};let c=1/0,r=t;for(const e of M){if(!d(e))continue;const i=Math.abs(t-e);i<c&&(c=i,r=e)}return c!==1/0&&c/t<=.2?{diameter:r,method:`snapped-${r}mm`}:{diameter:Math.max(Math.ceil(t/10)*10,a),method:"rounded"}}

package/dist/packages/core/metadata.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Genuinely per-die annotations for hover tooltips. Wafer/lot-level facts (lot,
+ * wafer id, product, test program, temperature, …) live on {@link WaferMetadata}
+ * and are merged into the tooltip automatically — do NOT duplicate them here.
+ * A die cannot differ from its wafer on those fields, so storing them per-die was
+ * pure redundancy (removed in 0.15.0). Only set keys here that genuinely vary
+ * die-to-die; a key present here overrides the wafer-level value of the same name.
+ */
+export interface DieMetadata {
+    [key: string]: unknown;
+}
+export interface WaferMetadata {
+    lot?: string;
+    waferId?: string | number;
+    product?: string;
+    testDate?: string;
+    operator?: string;
+    testProgram?: string;
+    temperature?: number;
+    /**
+     * User-assigned experiment/process-corner tag (e.g. "TT", "FF", a custom
+     * group name) — distinct from any parser-derived field. A first-class slot
+     * so hosts that support wafer-split assignment (grouping wafers into
+     * ad-hoc experiment buckets after the fact) get it picked up automatically
+     * by anything that facets/groups on `WaferMetadata` — reports, an
+     * eventual Group-by control — without per-host special-casing.
+     */
+    split?: string;
+    [key: string]: unknown;
+}
+//# sourceMappingURL=metadata.d.ts.map

package/dist/packages/core/metadata.js

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

package/dist/packages/core/probe.d.ts

@@ -0,0 +1,16 @@
+import type { Die } from './dies.js';
+export interface ProbeSequenceConfig {
+    type: 'row' | 'column' | 'snake' | 'custom';
+    /** Ordered array of die IDs — required when type='custom'. */
+    customOrder?: string[];
+}
+/**
+ * Assign a probeIndex to each die according to the chosen scan strategy.
+ *
+ * row    — left→right, top→bottom
+ * snake  — alternating direction per row (boustrophedon)
+ * column — top→bottom, left→right
+ * custom — explicit die ID ordering
+ */
+export declare function applyProbeSequence(dies: Die[], config: ProbeSequenceConfig): Die[];
+//# sourceMappingURL=probe.d.ts.map

package/dist/packages/core/probe.js

@@ -0,0 +1 @@
+export function applyProbeSequence(s,i){const{type:p,customOrder:d}=i;if(p==="custom"){if(!d)throw new Error('customOrder is required for type="custom"');const e=new Map(d.map((t,c)=>[t,c])),r=s.map(t=>({...t,probeIndex:e.get(t.id)})),o=r.filter(t=>t.probeIndex===void 0).map(t=>t.id);if(o.length>0)throw new Error(`applyProbeSequence: die IDs not found in customOrder: ${o.join(", ")}`);return r}if(p==="column")return[...s].sort((r,o)=>r.x-o.x||o.y-r.y).map((r,o)=>({...r,probeIndex:o}));const n=new Map;for(const e of s)n.has(e.y)||n.set(e.y,[]),n.get(e.y).push(e);const a=[...n.entries()].sort(([e],[r])=>r-e),u=[];return a.forEach(([,e],r)=>{const o=e.sort((t,c)=>t.x-c.x);u.push(...p==="snake"&&r%2===1?[...o].reverse():o)}),u.map((e,r)=>({...e,probeIndex:r}))}

package/dist/packages/core/reticle.d.ts

@@ -0,0 +1,68 @@
+import type { Wafer } from './wafer.js';
+export interface ReticleSpec {
+    width: number;
+    height: number;
+    diePitchX: number;
+    diePitchY: number;
+    anchorDie?: {
+        x: number;
+        y: number;
+    };
+    /**
+     * Physical position of die index (0,0) — i.e. where `anchorDie` is measured
+     * from. Defaults to the wafer centre `{0,0}`, correct only when the die grid
+     * is itself centred on the wafer. When the die grid's physical placement is
+     * offset from wafer centre by a non-whole-die-pitch amount (e.g. partial/
+     * off-centre wafer data, where `buildWaferMap` centres the *data extent*
+     * rather than the wafer), that fractional remainder must be passed here or
+     * field boundaries silently drift out of alignment with die edges.
+     */
+    gridOrigin?: {
+        x: number;
+        y: number;
+    };
+}
+/** A reticle rectangle in wafer-local (pre-rotation) coordinates. */
+export interface Reticle {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/**
+ * The field-local (column, row) that a die occupies within its reticle field,
+ * per the `anchorDie` convention documented on `generateReticleGrid`:
+ * `anchorDie` is the field's min-x/min-y (bottom-left) corner, so a die's
+ * local position is `die - anchorDie`, wrapped to the field dimensions.
+ *
+ * This is the single source of truth for "which reticle cell is this die
+ * in" — every consumer that needs the answer (e.g. stats findings, region
+ * labeling) must call this rather than re-deriving the phase math, so field
+ * geometry and cell labeling can never drift apart again.
+ */
+export declare function getReticleCell(die: {
+    x: number;
+    y: number;
+}, config: {
+    width: number;
+    height: number;
+    anchorDie?: {
+        x: number;
+        y: number;
+    };
+}): {
+    column: number;
+    row: number;
+};
+/**
+ * Generate the grid of reticle rectangles that cover the wafer area.
+ * Returns positions in wafer-local coordinates (before orientation rotation).
+ * Reticles that don't overlap the wafer circle are excluded.
+ *
+ * Width and height are in die counts; diePitchX/diePitchY convert to display units.
+ * The anchorDie index lands at the reticle's min-x/min-y corner (bottom-left,
+ * since +Y is up) — i.e. anchorDie is the first (leftmost, bottom-most) die
+ * of the field it belongs to.
+ */
+export declare function generateReticleGrid(wafer: Wafer, config: ReticleSpec): Reticle[];
+//# sourceMappingURL=reticle.d.ts.map

package/dist/packages/core/reticle.js

@@ -0,0 +1 @@
+function x(t,n){return(t%n+n)%n}export function getReticleCell(t,n){const{width:o,height:s,anchorDie:i={x:0,y:0}}=n,h=Math.max(1,Math.floor(o)),r=Math.max(1,Math.floor(s));return{column:x(t.x-i.x,h),row:x(t.y-i.y,r)}}export function generateReticleGrid(t,n){const{width:o,height:s,diePitchX:i,diePitchY:h,anchorDie:r={x:0,y:0},gridOrigin:m={x:0,y:0}}=n,c=o*i,e=s*h,f=x(r.x,o),p=x(r.y,s),l=m.x+(f+(o-1)/2)*i,M=m.y+(p+(s-1)/2)*h,a=t.radius+Math.max(c,e),P=Math.ceil((-a-(l-t.center.x))/c),b=Math.floor((a-(l-t.center.x))/c),D=Math.ceil((-a-(M-t.center.y))/e),H=Math.floor((a-(M-t.center.y))/e),X=[];for(let y=D;y<=H;y++){const d=M+y*e;for(let u=P;u<=b;u++){const g=l+u*c,R=Math.max(g-c/2,Math.min(t.center.x,g+c/2)),W=Math.max(d-e/2,Math.min(t.center.y,d+e/2)),Y=R-t.center.x,k=W-t.center.y;Y*Y+k*k<=t.radius*t.radius&&X.push({x:g,y:d,width:c,height:e})}}return X}

package/dist/packages/core/transforms.d.ts

@@ -0,0 +1,142 @@
+import type { Wafer } from './wafer.js';
+import type { Die, DieSpec } from './dies.js';
+export interface DataRow {
+    [key: string]: string | number;
+}
+export interface MapOptions {
+    xField?: string;
+    yField?: string;
+    iField?: string;
+    jField?: string;
+    valueField: string;
+    /** 'xy' matches by wafer coordinates; 'ij' matches by grid indices (default: 'xy') */
+    matchBy?: 'xy' | 'ij';
+}
+export interface TransformOptions {
+    /** Additional rotation in degrees, applied on top of existing die coordinates. */
+    rotation?: number;
+    /** Mirror x around the wafer centre. Applied after rotation. */
+    flipX?: boolean;
+    /** Mirror y around the wafer centre. Applied after rotation. */
+    flipY?: boolean;
+}
+/** Rotate (x, y) clockwise by angleDegrees around (cx, cy). */
+export declare function rotatePoint(x: number, y: number, angleDegrees: number, cx?: number, cy?: number): {
+    x: number;
+    y: number;
+};
+/**
+ * A 2D affine transform, applied as:
+ * ```
+ *   x' = a·x + c·y + e
+ *   y' = b·x + d·y + f
+ * ```
+ * `From`/`To` are phantom coordinate-frame tags — see {@link CoordFrame}.
+ */
+export interface Affine<From extends CoordFrame = CoordFrame, To extends CoordFrame = CoordFrame> {
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+    e: number;
+    f: number;
+    /** Phantom source frame — never present at runtime. */
+    readonly __from?: From;
+    /** Phantom target frame — never present at runtime. */
+    readonly __to?: To;
+}
+/**
+ * The distinct coordinate frames a point can live in. Mixing them up is the
+ * single most common source of misplaced-geometry bugs in this library, so the
+ * frame travels in the type of the matrix that converts between them.
+ *
+ * - `physical` — wafer-local mm describing a *physical wafer feature* (the
+ *   boundary outline, the notch, ring/quadrant region borders). These follow
+ *   `wafer.orientation` but NOT the data-axis flip: that flip exists to make the
+ *   rendered image physically correct for a prober convention (e.g.
+ *   `yAxisDirection: 'down'` puts row 1 at the top), so the physical wafer must
+ *   stay put while the die grid moves relative to it.
+ * - `grid` — wafer-local mm for geometry *aligned to the die grid* (reticle
+ *   fields, the +X/+Y axis indicator). These DO follow the data-axis flip,
+ *   because they must stay locked to the dies they describe.
+ * - `baked` — what `Die.physX`/`physY` holds after `buildWaferMap` has applied
+ *   `applyOrientation` then `transformDies`. Public API; do not redefine.
+ * - `screen` — final display mm after the interactive rotate/flip. This is what
+ *   `View.hoverPoints` holds and what hit-testing compares against.
+ */
+export type CoordFrame = 'physical' | 'grid' | 'baked' | 'screen';
+/** The identity transform. */
+export declare function affineIdentity<F extends CoordFrame>(): Affine<F, F>;
+/**
+ * Clockwise rotation by `angleDegrees` about (cx, cy) — the same convention as
+ * {@link rotatePoint}, which this reproduces exactly.
+ */
+export declare function affineRotation<From extends CoordFrame, To extends CoordFrame>(angleDegrees: number, cx?: number, cy?: number): Affine<From, To>;
+/** Mirror through (cx, cy) on each requested axis. */
+export declare function affineMirror<From extends CoordFrame, To extends CoordFrame>(flipX: boolean, flipY: boolean, cx?: number, cy?: number): Affine<From, To>;
+/**
+ * Compose two transforms: `inner` runs first, then `outer`. The frame brands must
+ * meet (`inner` ends where `outer` begins), so an out-of-order composition — the
+ * exact mistake that mis-drew reticle fields — will not type-check.
+ */
+export declare function affineCompose<A extends CoordFrame, B extends CoordFrame, C extends CoordFrame>(outer: Affine<B, C>, inner: Affine<A, B>): Affine<A, C>;
+/** Invert a transform. Every transform built here is a rotation/mirror, so it is always invertible. */
+export declare function affineInvert<From extends CoordFrame, To extends CoordFrame>(m: Affine<From, To>): Affine<To, From>;
+/** Transform a point (translation applies). */
+export declare function affinePoint<From extends CoordFrame, To extends CoordFrame>(m: Affine<From, To>, x: number, y: number): {
+    x: number;
+    y: number;
+};
+/**
+ * Transform a direction/offset (translation does NOT apply). Use for arrows and
+ * any other quantity that is a vector rather than a position.
+ */
+export declare function affineVector<From extends CoordFrame, To extends CoordFrame>(m: Affine<From, To>, dx: number, dy: number): {
+    x: number;
+    y: number;
+};
+/**
+ * True when the transform maps the x-axis onto the y-axis (the 90°/270° class,
+ * with or without mirroring) — i.e. when an axis-aligned rectangle's width and
+ * height must be exchanged to describe its image.
+ *
+ * Rotations that are not a multiple of 90° do not map an axis-aligned rectangle
+ * to an axis-aligned rectangle at all; those return `false`, matching the
+ * library's existing behaviour of drawing dies as unrotated rectangles.
+ */
+export declare function affineSwapsAxes(m: Affine): boolean;
+/**
+ * Check whether (x, y) — in wafer-local (pre-rotation) coordinates —
+ * lies inside the wafer boundary, including the notch/flat exclusion zone.
+ */
+export declare function isInsideWafer(x: number, y: number, wafer: Wafer): boolean;
+/**
+ * Clip dies to the wafer boundary (circle + optional notch/flat).
+ * When dieConfig is supplied, all four corners are checked to detect partial dies.
+ * Operates on wafer-local coordinates (before applyOrientation).
+ */
+export declare function clipDiesToWafer(dies: Die[], wafer: Wafer, dieConfig?: DieSpec): Die[];
+/**
+ * Rotate all die display coordinates by wafer.orientation around wafer.center.
+ * Call this after clipping and data mapping so that i/j indices remain intact.
+ */
+export declare function applyOrientation(dies: Die[], wafer: Wafer): Die[];
+/**
+ * Apply interactive transforms (rotation + flip) to die display coordinates.
+ * Rotation is around wafer.center; flip mirrors through wafer.center.
+ * Call this at render time — baseDies already have applyOrientation baked in.
+ */
+export declare function transformDies(dies: Die[], options: TransformOptions, center?: {
+    x: number;
+    y: number;
+}): Die[];
+/**
+ * Attach data values to dies.
+ * matchBy='xy'  — matches by wafer coordinates (v0.1 behaviour)
+ * matchBy='ij'  — matches by grid indices
+ *
+ * Note: duplicate rows with the same coordinate produce last-wins behaviour.
+ * Deduplicate `data` upstream if needed.
+ */
+export declare function mapDataToDies(dies: Die[], data: DataRow[], options: MapOptions): Die[];
+//# sourceMappingURL=transforms.d.ts.map

package/dist/packages/core/transforms.js

@@ -0,0 +1 @@
+import{getDieKey as u}from"./dies.js";export function rotatePoint(t,n,e,o=0,s=0){const c=e*Math.PI/180,a=Math.cos(c),i=Math.sin(c),f=t-o,r=n-s;return{x:o+f*a+r*i,y:s-f*i+r*a}}export function affineIdentity(){return{a:1,b:0,c:0,d:1,e:0,f:0}}export function affineRotation(t,n=0,e=0){const o=t*Math.PI/180,s=Math.cos(o),c=Math.sin(o);return{a:s,c,b:-c,d:s,e:n-(s*n+c*e),f:e-(-c*n+s*e)}}export function affineMirror(t,n,e=0,o=0){return{a:t?-1:1,c:0,b:0,d:n?-1:1,e:t?2*e:0,f:n?2*o:0}}export function affineCompose(t,n){return{a:t.a*n.a+t.c*n.b,b:t.b*n.a+t.d*n.b,c:t.a*n.c+t.c*n.d,d:t.b*n.c+t.d*n.d,e:t.a*n.e+t.c*n.f+t.e,f:t.b*n.e+t.d*n.f+t.f}}export function affineInvert(t){const n=t.a*t.d-t.b*t.c,e=t.d/n,o=-t.b/n,s=-t.c/n,c=t.a/n;return{a:e,b:o,c:s,d:c,e:-(e*t.e+s*t.f),f:-(o*t.e+c*t.f)}}export function affinePoint(t,n,e){return{x:t.a*n+t.c*e+t.e,y:t.b*n+t.d*e+t.f}}export function affineVector(t,n,e){return{x:t.a*n+t.c*e,y:t.b*n+t.d*e}}export function affineSwapsAxes(t){return Math.abs(t.a)<1e-9&&Math.abs(t.d)<1e-9&&Math.abs(t.b)>1e-9}function y(t,n){return Math.sqrt(t*t-(n/2)**2)}export function isInsideWafer(t,n,e){const o=t-e.center.x,s=n-e.center.y;if(o*o+s*s>e.radius*e.radius)return!1;if(e.notch){const c=y(e.radius,e.notch.length);if(e.notch.type==="bottom"&&s<-c||e.notch.type==="top"&&s>c||e.notch.type==="left"&&o<-c||e.notch.type==="right"&&o>c)return!1}return!0}export function clipDiesToWafer(t,n,e){const o=[];for(const s of t){const c=isInsideWafer(s.physX,s.physY,n);if(!e){c&&o.push({...s,insideWafer:!0,partial:!1});continue}const a=e.width/2,i=e.height/2,r=[[s.physX-a,s.physY-i],[s.physX+a,s.physY-i],[s.physX+a,s.physY+i],[s.physX-a,s.physY+i]].filter(([h,p])=>isInsideWafer(h,p,n)).length;!c&&r===0||o.push({...s,insideWafer:!0,partial:r<4})}return o}export function applyOrientation(t,n){if(n.orientation===0)return t;const e=affineRotation(n.orientation,n.center.x,n.center.y);return t.map(o=>{const s=affinePoint(e,o.physX,o.physY);return{...o,physX:s.x,physY:s.y}})}export function transformDies(t,n,e={x:0,y:0}){const{rotation:o=0,flipX:s=!1,flipY:c=!1}=n;if(o===0&&!s&&!c)return t;const a=affineCompose(affineMirror(s,c,e.x,e.y),affineRotation(o,e.x,e.y));return t.map(i=>{const f=affinePoint(a,i.physX,i.physY);return{...i,physX:f.x,physY:f.y}})}export function mapDataToDies(t,n,e){const{valueField:o,matchBy:s="xy"}=e,c=new Map,a=r=>{const h=c.get(u(r));if(h===void 0)return{...r};const p=r.testValues??{};return{...r,testValues:{...p,[Object.keys(p).length]:h}}};if(s==="ij"){const r=e.iField??"x",h=e.jField??"y";for(const p of n)c.set(`${+p[r]},${+p[h]}`,+p[o]);return t.map(a)}const i=e.xField??"x",f=e.yField??"y";for(const r of n)c.set(`${+r[i]},${+r[f]}`,+r[o]);return t.map(a)}