@wafertools/wafermap 0.21.1

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

@@ -0,0 +1,60 @@
+/**
+ * Compare two label strings in natural (alphanumeric) order, so embedded numbers
+ * sort by value rather than character-by-character: `D0, D1, D2, D10, D11` rather
+ * than the plain-`.sort()` result `D0, D1, D10, D11, D2`.
+ *
+ * THE comparator for any user-visible list of mixed alpha-numeric labels (metadata
+ * values, legend entries, facet values, yield rows) — semiconductor identifiers are
+ * overwhelmingly of this `<prefix><number>` shape, so lexicographic ordering reads
+ * as scrambled to an engineer scanning a legend.
+ *
+ * Locale is pinned to `'en'` rather than left to the host: this ordering also drives
+ * categorical colour assignment, and a library must not hand the same wafer different
+ * colours on machines with different locales.
+ */
+export declare function compareNatural(a: string, b: string): number;
+/**
+ * camelCase/snake_case key → "Title Case" label (`dieSize` → "Die Size",
+ * `test_program` → "Test Program").
+ *
+ * Lives in `core/` because both `renderer/` (on-canvas map title) and `stats/`
+ * (facet tables, HTML report, summary panel, metadata badge) need it, and
+ * `renderer/` must not depend on `stats/`. Previously duplicated in both with a
+ * "keep in sync" comment — the same field would otherwise be labelled two
+ * different ways depending on which surface rendered it.
+ */
+export declare function prettyKey(key: string): string;
+/** Clamp `v` into [0, 1] — the normalization range every colour scale expects. */
+export declare function clamp01(v: number): number;
+/**
+ * Arithmetic mean. Returns **NaN** for an empty array — deliberately, not 0.
+ *
+ * This feeds statistical comparisons (Welch tests, effect sizes), where "no data"
+ * must never masquerade as a real measurement of zero: a 0 would silently become
+ * a genuine-looking delta in a finding. NaN propagates and is caught by the
+ * existing non-finite guards. Same reasoning as never defaulting a missing bin
+ * to `0` elsewhere in the library.
+ */
+export declare function mean(values: number[]): number;
+/**
+ * Median of an ALREADY-SORTED ascending array. Returns 0 when empty — these two
+ * median helpers back display/summary surfaces whose call sites already guard for
+ * emptiness, and 0 keeps them from rendering "NaN" in a panel. Do not use them
+ * where the result feeds a statistical test; see {@link mean} on why that case
+ * wants NaN instead.
+ */
+export declare function medianOfSorted(sorted: number[]): number;
+/** Median of an unsorted array (sorts a copy, leaving the input untouched). */
+export declare function median(values: number[]): number;
+/**
+ * The 98th-percentile value (nearest-rank, on a sorted copy). Used by wafer-size
+ * inference to take a robust maximum — the true extreme is too easily thrown off
+ * by a single stray coordinate. Returns 0 for an empty array.
+ */
+export declare function percentile98(values: number[]): number;
+/**
+ * Return the most-frequent (mode) value from an array of numbers.
+ * For pitch estimation, values should be pre-rounded to absorb noise.
+ */
+export declare function modeOf(values: number[]): number | null;
+//# sourceMappingURL=utils.d.ts.map

package/dist/packages/core/utils.js

@@ -0,0 +1 @@
+export function compareNatural(t,n){return t.localeCompare(n,"en",{numeric:!0})}export function prettyKey(t){return t.replace(/([A-Z])/g," $1").replace(/_/g," ").trim().replace(/^./,n=>n.toUpperCase())}export function clamp01(t){return Math.max(0,Math.min(1,t))}export function mean(t){if(t.length===0)return NaN;let n=0;for(const e of t)n+=e;return n/t.length}export function medianOfSorted(t){const n=t.length;if(n===0)return 0;const e=Math.floor(n/2);return n%2===1?t[e]:(t[e-1]+t[e])/2}export function median(t){return medianOfSorted([...t].sort((n,e)=>n-e))}export function percentile98(t){if(t.length===0)return 0;const n=[...t].sort((o,r)=>o-r),e=Math.floor(n.length*.98);return n[Math.min(e,n.length-1)]}export function modeOf(t){if(!t.length)return null;const n=new Map;for(const r of t)n.set(r,(n.get(r)??0)+1);let e=0,o=t[0];for(const[r,c]of n)c>e&&(e=c,o=r);return o}

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

@@ -0,0 +1,45 @@
+import type { WaferMetadata } from './metadata.js';
+/**
+ * Wafer orientation mark.  Pass only `type`; the library derives the standard
+ * dimensions from the wafer diameter automatically.
+ *
+ * - ≤ 150 mm wafers: orientation **flat** (straight chord, 32.5–57.5 mm).
+ * - > 150 mm wafers: orientation **notch** (small V-indentation, ~3.5 mm wide).
+ *
+ * Both are modelled with the same type; the appropriate geometry is chosen
+ * internally based on the wafer diameter.
+ */
+export interface WaferNotch {
+    type: 'top' | 'bottom' | 'left' | 'right';
+}
+export interface WaferSpec {
+    diameter: number;
+    center?: {
+        x: number;
+        y: number;
+    };
+    notch?: WaferNotch;
+    orientation?: number;
+    metadata?: WaferMetadata;
+}
+export interface Wafer {
+    diameter: number;
+    radius: number;
+    center: {
+        x: number;
+        y: number;
+    };
+    /**
+     * Resolved orientation mark.  `length` is the standard chord length (flat) or
+     * half-width (V-notch), derived from the wafer diameter by `createWafer`.
+     */
+    notch?: {
+        type: 'top' | 'bottom' | 'left' | 'right';
+        length: number;
+    };
+    orientation: number;
+    metadata?: WaferMetadata;
+}
+/** Create a wafer model from spec. Defaults: center={0,0}, orientation=0. */
+export declare function createWafer(config: WaferSpec): Wafer;
+//# sourceMappingURL=wafer.d.ts.map

package/dist/packages/core/wafer.js

@@ -0,0 +1 @@
+function t(e){return e<=100?32.5:e<=150?57.5:1.75}export function createWafer(e){if(e.diameter<=0)throw new RangeError(`createWafer: diameter must be > 0 (got ${e.diameter})`);return{diameter:e.diameter,radius:e.diameter/2,center:e.center??{x:0,y:0},notch:e.notch?{type:e.notch.type,length:t(e.diameter)}:void 0,orientation:e.orientation??0,metadata:e.metadata}}

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

@@ -0,0 +1,420 @@
+import type { Wafer } from '../core/wafer.js';
+import type { Die } from '../core/dies.js';
+import type { Reticle } from '../core/reticle.js';
+import type { DieMetadata, WaferMetadata } from '../core/metadata.js';
+import { type Affine } from '../core/transforms.js';
+import type { TestDef, BinDef, MetadataFieldDef, ReticleConfig } from './buildWaferMap.js';
+/** Resolve a toolbar activeTest cursor to the canonical test number for getDieTestValue. */
+export declare function resolveTestNumber(activeTest: number, testDefs?: TestDef[]): {
+    testNumber: number;
+};
+/** Find a TestDef by its testNumber. Returns undefined when testDefs is absent or no match. */
+export declare function findTestDef(testDefs: TestDef[] | undefined, testNumber: number): TestDef | undefined;
+/** Return sorted unique test numbers present across a set of dies (from testValues keys). */
+export declare function getUniqueTestNumbers(dies: Die[]): number[];
+export type PlotMode = 'value' | 'hardBin' | 'softBin' | 'stackedValues' | 'stackedBins' | 'stackedSoftBins' | 'metadata';
+interface Point {
+    x: number;
+    y: number;
+}
+export interface ViewRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    fill: string | number;
+    type: 'hardBin' | 'softBin' | 'value' | 'stacked' | 'metadata';
+    stack?: number[];
+    metadata?: DieMetadata;
+    /**
+     * Out-of-spec indicator for value-mode dies drawn with the value gradient.
+     * The die keeps its gradient fill (so the distribution stays readable) and the
+     * renderer draws a ▽ (`failLow`) / △ (`failHigh`) marker on top so the die is
+     * never shown as plain in-spec. Set in both `'spec'` and `'data'` colorbar
+     * ranges. Absent only under a pass/fail display (`passFailDisplay: 'spec'`),
+     * where the solid categorical fill is itself the indication and no marker is needed.
+     */
+    specMark?: 'failLow' | 'failHigh';
+}
+export interface ViewText {
+    x: number;
+    y: number;
+    text: string;
+    fontSize: number;
+    color: string;
+    align: 'center';
+    /** Marks fixed-size overlay labels (currently only the +X/+Y orientation
+     *  indicators) so canvas-adapter excludes them from die-label uniform sizing.
+     *  Absent = an ordinary die label; its `fontSize` here is a build-time
+     *  (mm-space, zoom-unaware) default for non-canvas consumers of ViewText —
+     *  canvas-adapter recomputes the actual on-screen size at draw time. */
+    role?: 'indicator';
+}
+export interface ViewHoverPoint {
+    x: number;
+    y: number;
+}
+export interface ViewOverlay {
+    kind: 'wafer-boundary' | 'reticle' | 'probe-path' | 'ring-boundary' | 'quadrant-boundary' | 'xy-indicator';
+    points: Point[][];
+    closed: boolean;
+    lineColor: string;
+    lineWidth: number;
+    fill?: string;
+}
+export interface View {
+    rectangles: ViewRect[];
+    hoverPoints: ViewHoverPoint[];
+    texts: ViewText[];
+    overlays: ViewOverlay[];
+    plotMode: PlotMode;
+    colorScheme: string;
+    metadata: WaferMetadata | null;
+    dies: Die[];
+    /** Actual [min, max] of the value data used for color normalization. */
+    valueRange: [number, number];
+    /** True when every observed value for the active test is a whole number. Drives integer-only colorbar ticks. */
+    allIntegerValues?: boolean;
+    /** Named test definitions — populated when `testDefs` is passed to `buildWaferMap`. */
+    testDefs?: TestDef[];
+    /** Which `values[]` index is being displayed (for `value` plot mode). Default 0. */
+    activeTest: number;
+    /** True when log₁₀ scale is both requested and valid (vMin > 0). */
+    logScale: boolean;
+    /**
+     * True when log₁₀ scale was *requested* (option or per-test default), regardless of whether it
+     * was applied. When `logScaleRequested && !logScale` the data range included ≤ 0 and the view
+     * fell back to linear — the colorbar reports this as "linear — log n/a".
+     */
+    logScaleRequested: boolean;
+    /** Aggregation method label for `stackedValues` hover tooltips (e.g. `'mean'`). */
+    aggrMethod?: string;
+    /** Total wafers in lot — for `stackedBins` hover percentage calculation. */
+    lotSize?: number;
+    /**
+     * Total effective axis flip (data-pipeline flip XOR interactive flip).
+     *
+     * @deprecated for coordinate maths — this and {@link rotation} are a *lossy*
+     * summary: a summed angle plus XOR'd flip flags cannot represent
+     * rotate→mirror→rotate, because rotation and mirroring don't commute. They are
+     * correct only while `wafer.orientation` is 0. Use {@link gridToScreen} (or its
+     * inverse) for anything positional. Retained for display code that only needs a
+     * rough orientation hint, and because it is read back as a data-flip hint below.
+     */
+    axisFlip: {
+        x: boolean;
+        y: boolean;
+    };
+    /**
+     * The data-pipeline axis flip ALONE (from `xAxisDirection`/`yAxisDirection`/
+     * `coordinateOrigin`), with no interactive flip mixed in. `renderWaferMap` feeds
+     * this back into `buildView` as `dataAxisFlip` on every rebuild; reading
+     * {@link axisFlip} for that purpose double-counts an active interactive flip.
+     */
+    dataAxisFlip: {
+        x: boolean;
+        y: boolean;
+    };
+    /** Total effective rotation in degrees (wafer orientation + interactive rotation). See {@link axisFlip} on why this is lossy. */
+    rotation: number;
+    /**
+     * Die-grid geometry → screen. THE authoritative display transform: composed from
+     * the real pipeline in order, so it stays correct for any combination of wafer
+     * orientation, data-axis flip and interactive rotate/flip. Invert it
+     * (`affineInvert`) to map a screen position back to a die-grid position — this is
+     * what axis tick labels do.
+     */
+    gridToScreen: Affine<'grid', 'screen'>;
+    /** True when reticle geometry is present — used to conditionally show the reticle toolbar button. */
+    hasReticle: boolean;
+    /** True when the scene was built from lot-aggregated data (lotStack). Controls toolbar stacked-mode visibility. */
+    isLotStack: boolean;
+    /**
+     * The *effective* pass/fail display for value mode, resolved by the library
+     * from the request and the data (never trust the caller's flag alone):
+     * - `'spec'` — dies coloured by spec pass/fail against the active test's limits.
+     * - `'test'` — dies coloured by the tester's recorded verdict
+     *   (`getTestPassStatus`). Forced automatically when the active test is
+     *   functional (`testType: 'F'`) — a functional test has no value to plot.
+     * - `'off'`  — continuous value gradient (or a non-value plot mode).
+     */
+    passFailDisplay: 'off' | 'spec' | 'test';
+    /** True when `passFailDisplay === 'spec'` — kept for back-compat with existing consumers. */
+    colorBySpec: boolean;
+    /** Whether the colorbar range is anchored to spec limits ('spec') or data extents ('data'). */
+    colorbarRangeMode: 'spec' | 'data';
+    /** Wafer centre in scene/display mm coordinates (the rotation pivot). */
+    waferCenter: {
+        x: number;
+        y: number;
+    };
+    /** Wafer radius in mm. */
+    waferRadius: number;
+    /** Unit vector pointing toward the notch/flat in display space (post-transform). Null when no notch. */
+    notchDir: {
+        x: number;
+        y: number;
+    } | null;
+    /** Bin → die count for the active bin mode (hardBin or softBin). Undefined in value modes. */
+    binCounts?: Map<number, number>;
+    /** Value → die count for the active metadata field, `'metadata'` mode only. */
+    metadataCounts?: Map<string, number>;
+    /**
+     * Value → resolved fill colour for the active metadata field, `'metadata'` mode only. The
+     * single source of truth for metadata colours — built from the same filtered die population
+     * as `metadataCounts`, so legend swatches (built from this map) always match die fills (also
+     * built from this map). Consumers must read this rather than recomputing colours from
+     * `metadataCounts`'s keys, or the two can diverge in ranking whenever iteration order differs.
+     */
+    metadataColorMap?: Map<string, string> | null;
+    /** Which `die.metadata` key is active in `'metadata'` mode. */
+    activeMetadataKey?: string;
+    /** Named metadata-field definitions — populated when `metadataFields` is passed to `buildWaferMap`. */
+    metadataFields?: MetadataFieldDef[];
+    /**
+     * Per-category die counts for `value` + `passFailDisplay: 'spec'` — drives the spec legend. Counts only
+     * dies with a value (no-data dies excluded). Undefined outside spec mode.
+     */
+    specCounts?: {
+        pass: number;
+        failHigh: number;
+        failLow: number;
+    };
+    /**
+     * Per-category die counts for `value` mode with `passFailDisplay: 'test'` — drives the
+     * Pass/Fail legend. Counts only dies with a recorded verdict (no-data dies excluded).
+     * Undefined outside test pass/fail display.
+     */
+    passFailCounts?: {
+        pass: number;
+        fail: number;
+    };
+    /** Bounding box of all die centres in scene coordinates (mm). */
+    dieBounds: {
+        minX: number;
+        maxX: number;
+        minY: number;
+        maxY: number;
+    } | null;
+}
+export interface ViewOptions {
+    plotMode?: PlotMode;
+    showDieLabels?: boolean;
+    showReticle?: boolean;
+    showProbePath?: boolean;
+    ringCount?: number;
+    showRingBoundaries?: boolean;
+    showQuadrantBoundaries?: boolean;
+    showXYIndicator?: boolean;
+    dieGap?: number;
+    /** Named colour scheme — any scheme registered via registerColorScheme(). Default: 'default'. */
+    colorScheme?: string;
+    highlightBin?: number;
+    /** Dim every die except this metadata value, `'metadata'` mode's analogue of `highlightBin`. */
+    highlightMetadataValue?: string;
+    interactiveTransform?: {
+        rotation?: number;
+        flipX?: boolean;
+        flipY?: boolean;
+    };
+    /**
+     * Explicit value colour normalization range.
+     *
+     * - Tuple `[min, max]`: applied to whichever test is active. The caller is
+     *   responsible for keeping it consistent with `activeTest`.
+     * - Object `{ test, range }`: applied **only** when `test` matches the active
+     *   test. On mismatch the range is ignored and the scene auto-scales — this
+     *   makes it impossible to colour one test's data against another test's
+     *   range. Prefer this form when the range was computed for a specific test.
+     *
+     * When omitted entirely, the range is auto-computed from the die values present.
+     */
+    valueRange?: [number, number] | {
+        test: number;
+        range: [number, number];
+    };
+    /**
+     * Controls the default colorbar range when the active testDef has spec limits.
+     * `'spec'` (default when limits present): colorbar spans [limitLow, limitHigh].
+     * `'data'`: colorbar spans the actual data min/max regardless of limits.
+     */
+    colorbarRangeMode?: 'spec' | 'data';
+    /**
+     * Reticle rectangles to overlay on the map.
+     * Generated by `generateReticleGrid` or the `reticle` option on `buildWaferMap`.
+     */
+    reticles?: Reticle[];
+    /** Named test definitions — one per `values[]` entry. */
+    testDefs?: TestDef[];
+    /**
+     * Which `values[]` index to display in `value` plot mode. Default `0`.
+     * When `testDefs` is provided, the toolbar mode dropdown offers one item per test.
+     */
+    activeTest?: number;
+    /**
+     * Which `die.metadata` key to display in `'metadata'` plot mode. Must match
+     * a `key` in `metadataFields` (passed to `buildWaferMap`, not here — see
+     * the `binDefs` parameter of `buildView`) for the field to be colored/
+     * legended; dies without that key set render as no-data.
+     */
+    activeMetadataKey?: string;
+    /**
+     * When true, apply log₁₀ scale to value normalization and the colorbar.
+     * Overrides the per-test `TestDef.logScale` default.
+     * Falls back to linear when vMin ≤ 0.
+     */
+    logScale?: boolean;
+    /**
+     * Format to use for unitless values outside the normal display range [0.1, 9999].
+     * `'engineering'` (default): multiples-of-3 exponent notation (e.g. `12E-6`).
+     * `'si'`: SI prefix with no unit suffix (e.g. `12 µ`).
+     * Values with a unit always use SI prefix regardless of this setting.
+     */
+    fallbackFormat?: 'si' | 'engineering';
+    /**
+     * Aggregation method label shown in hover tooltips for `stackedValues` mode.
+     * E.g. `'mean'`, `'median'`, `'stddev'`, `'min'`, `'max'`.
+     */
+    aggregationMethod?: string;
+    /**
+     * Total number of wafers in the lot — used to compute bin occurrence percentage
+     * in `stackedBins` hover tooltips.
+     */
+    lotSize?: number;
+    /**
+     * Axis flip baked in by the data pipeline (for LL/LR/UL/UR origins or explicit
+     * `xAxisDirection`/`yAxisDirection`). Combined with `interactiveTransform` flip
+     * to produce the total effective axis flip for tick labels.
+     */
+    dataAxisFlip?: {
+        x: boolean;
+        y: boolean;
+    };
+    /** Set to true when the scene is built from lot-aggregated data (lotStack). */
+    isLotStack?: boolean;
+    /**
+     * Requested pass/fail display for `value` mode. The library resolves the
+     * *effective* display from this request and the data (see `View.passFailDisplay`):
+     * - `'spec'` — colour dies by spec pass/fail against the active test's limits
+     *   (solid green / blue fail-low / red fail-high). Degrades to `'off'` when the
+     *   active test has no limits.
+     * - `'test'` — colour dies by the tester's recorded pass/fail verdict
+     *   (`die.testPass`, via `getTestPassStatus`; solid green pass / red fail).
+     *   Degrades to `'off'` when no die has a recorded verdict for the active test.
+     * - `'off'` (default) — continuous value gradient.
+     * A functional active test (`testType: 'F'`) always renders as `'test'`
+     * regardless of this option — it has no value to plot.
+     */
+    passFailDisplay?: 'off' | 'spec' | 'test';
+    /**
+     * When true (default), partial (edge) dies — positions that only partially
+     * overlap the wafer circle — are rendered in a muted grey.
+     * Set to false to hide them entirely, matching real prober behaviour where
+     * edge positions are never tested.
+     */
+    showPartialDies?: boolean;
+}
+interface ColorFns {
+    forValue: (t: number) => string;
+    forBin: (bin: number) => string;
+}
+/** A die's spec classification for `value` mode against the active test's limits. */
+export type SpecCategory = 'pass' | 'failHigh' | 'failLow';
+/**
+ * Classify a value against the active test's spec limits, using the SAME rules as the value-mode
+ * die colouring in `pushDieRectangles`. Returns null when there is no value. Shared by the colour
+ * branch and the spec-count tally so the two never diverge.
+ *
+ * Out-of-spec *classification* depends ONLY on whether limits are defined — never on
+ * `colorbarRangeMode`. An out-of-spec die is always flagged when limits exist, regardless of
+ * how the colorbar is scaled. The *form* of the indication, decided in `pushDieRectangles`,
+ * depends only on the effective `passFailDisplay`: under `'spec'` (pass/fail mode) the die gets a solid
+ * green/blue/red categorical fill; in normal value/gradient mode it keeps the value gradient
+ * fill (like every other die, so the distribution stays readable and out-of-spec colours don't
+ * collide with the scheme) and is flagged with a ▽/△ marker (`ViewRect.specMark`). Either way
+ * the die is never drawn as plain in-spec — the silent correctness bug this guards against.
+ */
+export declare function classifySpec(value: number | undefined, activeTestDef: {
+    limitLow?: number;
+    limitHigh?: number;
+} | undefined): SpecCategory | null;
+/** Options for {@link buildHoverText}. All fields are optional. */
+export interface HoverTextOptions {
+    testDefs?: TestDef[];
+    hbinDefs?: BinDef[];
+    sbinDefs?: BinDef[];
+    fallbackFormat?: 'si' | 'engineering';
+    /** Lot-stack aggregation method name — shown so the reader knows what the scalar means. */
+    aggrMethod?: string;
+    /** Number of wafers in the stack, used to annotate a count with its share of the lot. */
+    lotSize?: number;
+    waferMeta?: WaferMetadata | null;
+    /** Active test number (value mode only) — leads the tooltip and gets an out-of-spec note. */
+    activeTest?: number;
+    /** Reticle geometry, when configured — appended as a "Reticle (col, row)" line below Die (x, y). */
+    reticleConfig?: ReticleConfig;
+}
+export declare function buildHoverText(die: Die, plotMode: PlotMode, opts?: HoverTextOptions): string;
+/**
+ * The on-canvas map title split into two parts for placement around the colorbar/legend:
+ * - `primary`   — the most important identifier, drawn ABOVE the colorbar/legend.
+ * - `secondary` — supporting context (stack/wafer-count), drawn BELOW it. Empty when not needed.
+ */
+export interface MapTitleParts {
+    primary: string;
+    secondary: string;
+}
+/**
+ * Build the on-canvas map title for any plot mode, derived from the View (+ optional bin defs so a
+ * single-bin stacked card can name its bin). Returns a primary/secondary split so the renderer can
+ * place the key identifier above the scale and the supporting context below it — keeping each line
+ * short and never obscured.
+ *
+ * Primary / secondary per mode:
+ * - value            → "{name} ({unit})"            / —
+ * - stackedValues    → "{name} ({unit}) · {method}" / "stacked ({n} wafers)"
+ * - hardBin/softBin  → "Hard Bin" / "Soft Bin"      / —
+ * - stackedBins      → "Hard Bin {bin}" (or "Hard Bin") / "stacked ({n} wafers)"
+ * - stackedSoftBins  → "Soft Bin {bin}" (or "Soft Bin") / "stacked ({n} wafers)"
+ *
+ * @param fallbackFormat unitless value formatting — matches the colorbar tick formatting.
+ * @param binDefs the active bin defs (hbinDefs for hard modes, sbinDefs for soft) — used to name
+ *   the bin on single-bin stacked cards.
+ */
+export declare function buildMapTitle(view: View, fallbackFormat?: 'si' | 'engineering', binDefs?: BinDef[]): MapTitleParts;
+export declare function generateTextOverlay(dies: Die[], txCoords: Float64Array | null, options: {
+    plotMode: PlotMode;
+    colorFns: ColorFns;
+    normalize: (v: number) => number;
+    activeTest: number;
+    valueRange: [number, number];
+    testDefs?: TestDef[];
+    fallbackFormat?: 'si' | 'engineering';
+    /** Effective pass/fail display (see View.passFailDisplay). 'test' renders P/F verdict labels. */
+    passFailDisplay?: 'off' | 'spec' | 'test';
+    /** Active `die.metadata` key + its resolved value→color map, `'metadata'` mode only. */
+    activeMetadataKey?: string;
+    metadataColorMap?: Map<string, string> | null;
+}): ViewText[];
+/**
+ * Build a renderer-agnostic scene from a wafer, dies, and display options.
+ *
+ * ```ts
+ * buildView(wafer, dies, { plotMode: 'hardBin', reticles })
+ * ```
+ */
+export declare function buildView(wafer: Wafer, dies: Die[], options?: ViewOptions, binDefs?: {
+    hbinDefs?: BinDef[];
+    sbinDefs?: BinDef[];
+    metadataFields?: MetadataFieldDef[];
+}): View;
+/**
+ * Return a stable string key for a die — guaranteed format `"x,y"`.
+ *
+ * Re-exported from `core/dies.ts`, where the canonical implementation lives so
+ * that `stats/` and `canvas-adapter/` can share it without depending on
+ * `renderer/`. Kept exported here to preserve the public `@wafertools/wafermap/renderer`
+ * entry point.
+ */
+export { getDieKey } from '../core/dies.js';
+//# sourceMappingURL=buildView.d.ts.map

package/dist/packages/renderer/buildView.js

@@ -0,0 +1 @@
+import{getReticleCell as Qt}from"../core/reticle.js";import{affineRotation as ft,affineMirror as Vt,affineCompose as at,affinePoint as X,affineVector as dt,affineSwapsAxes as Ut}from"../core/transforms.js";import{contrastTextColor as Y,SPEC_PASS_FILL as ht,SPEC_FAIL_LOW as Jt,SPEC_FAIL_HIGH as pt}from"./colorMap.js";import{getColorScheme as Zt}from"./colorSchemes.js";import{getDieTestValue as R,getTestPassStatus as G,isParametricTest as mt}from"./buildWaferMap.js";import{fmt as yt,fmtColorbarAxis as gt,fmtAggregationMethod as Rt}from"./fmt.js";import{metadataValueColor as te}from"./colorMap.js";import{compareNatural as ee,clamp01 as Ct}from"../core/utils.js";import{prettyKey as ne}from"../core/utils.js";export function resolveTestNumber(t,e){return e?.length?{testNumber:(findTestDef(e,t)??e[0]).testNumber}:{testNumber:t}}export function findTestDef(t,e){return t?.find(n=>n.testNumber===e)}export function getUniqueTestNumbers(t){return[...new Set(t.flatMap(e=>e.testValues?Object.keys(e.testValues).map(Number):[]))].sort((e,n)=>e-n)}const ae="#d3d6db",Nt="#e8e9ea",ie="#eceef0",w="#d6d9dd";function it(t,e){const n=e?t.metadata?.[e]:void 0;return n!=null&&(typeof n=="string"||typeof n=="number"||typeof n=="boolean")?String(n):void 0}export function classifySpec(t,e){return t===void 0?null:e?.limitLow!==void 0&&t<e.limitLow?"failLow":e?.limitHigh!==void 0&&t>e.limitHigh?"failHigh":"pass"}function se(t,e,n){const{x:i,y:s}=t.center,a=ft(t.orientation,i,s),o=at(Vt(e?.x??!1,e?.y??!1,i,s),ft(t.orientation,i,s)),l=at(Vt(n?.flipX??!1,n?.flipY??!1,i,s),ft(n?.rotation??0,i,s));return{bakedToScreen:l,physicalToScreen:at(l,a),gridToScreen:at(l,o)}}function _(t,e=!1){return{points:[t],closed:e}}function oe(t,e){const{center:n,radius:i,notch:s}=t;let a=n.x+i*Math.cos(e),o=n.y+i*Math.sin(e);if(!s)return{x:a,y:o};const l=Math.sqrt(i**2-(s.length/2)**2),f=s.length/2,y=a-n.x,m=o-n.y;return s.type==="bottom"&&m<-l?(o=n.y-l,a=n.x+Math.max(-f,Math.min(f,y))):s.type==="top"&&m>l?(o=n.y+l,a=n.x+Math.max(-f,Math.min(f,y))):s.type==="left"&&y<-l?(a=n.x-l,o=n.y+Math.max(-f,Math.min(f,m))):s.type==="right"&&y>l&&(a=n.x+l,o=n.y+Math.max(-f,Math.min(f,m))),{x:a,y:o}}function Ht(t,e){return t.map(e).join(" / ")}function re(t,e=256){const n=Array.from({length:e},(i,s)=>t(s/(e-1)));return i=>n[Math.min(e-1,Math.max(0,Math.round(i*(e-1))))]}function le(t,e){const n=Math.max(1,Math.min(t.width,t.height)),i=t.width/Math.max(e.length,1);return Math.max(8,Math.min(16,Math.round(Math.min(n*.55,i*1.8))))}function ce(t,e,n){if(e?.length){const i=e.flatMap(s=>{const a=s.testNumber;if(!mt(s)){const f=G(t,a,s);return f===void 0?[]:[{key:a,label:s.name,value:f?"Pass":"Fail"}]}const o=R(t,a);if(o===void 0)return[];const l=t.testPass?.[a]===!1?" <i>(recorded fail)</i>":"";return[{key:a,label:s.name,value:`${yt(o,s.unit,n)}${l}`}]});if(i.length)return i}return t.testValues&&Object.keys(t.testValues).length>0?Object.entries(t.testValues).map(([i,s])=>({key:Number(i),label:`Test ${i}`,value:yt(s,void 0,n)})):t.testPass&&Object.keys(t.testPass).length>0?Object.entries(t.testPass).map(([i,s])=>({key:Number(i),label:`Test ${i}`,value:s?"Pass":"Fail"})):[]}export function buildHoverText(t,e,n={}){const{testDefs:i,hbinDefs:s,sbinDefs:a,fallbackFormat:o,aggrMethod:l,lotSize:f,waferMeta:y,activeTest:m,reticleConfig:$}=n,D=s?new Map(s.map(r=>[r.bin,r])):null,v=a?new Map(a.map(r=>[r.bin,r])):null,x=[`Die (${t.x}, ${t.y})`];if($){const r=Qt(t,$);x.push(`Reticle (${r.column}, ${r.row})`)}if(e==="stackedValues"){const r=R(t,0);if(r!==void 0){const c=i?.[0],p=c?.testNumber,h=c?.name??(p!=null?`Test ${p}`:"Value"),M=l?` (${l})`:"";x.push(`${h}${M}: ${yt(r,c?.unit,o)}`)}}else if(e==="stackedBins"||e==="stackedSoftBins"){const r=R(t,0),c=e==="stackedSoftBins"?t.sbin:t.hbin;if(r!==void 0){const p=e==="stackedSoftBins"?v:D,h=c!==void 0?p?.get(c)?.name?`${c} \xB7 ${p.get(c).name}`:`Bin ${c}`:"Bin";let M;if(l==="percent")M=`${r.toFixed(0)}%`;else{const b=f?` (${(r/f*100).toFixed(0)}% of lot)`:"";M=`${r}${b}`}const T=l?` [${Rt(l)}]`:"";x.push(`${h}: ${M}${T}`)}}else{const r=ce(t,i,o);if(e==="value"&&r.length){const{testNumber:c}=resolveTestNumber(m??0,i),p=findTestDef(i,c),h=R(t,c);let M=r.findIndex(A=>A.key===c);M<0&&(M=0);const T=r[M];let b=`<b>${T.label}: ${T.value}</b>`;if(T.key===c&&p){const A=classifySpec(h,p);(A==="failLow"||A==="failHigh")&&(b+=" <i>(out of spec)</i>")}x.push(b);const O=r.length-1;O>0&&x.push(`<i>+${O} more test${O===1?"":"s"}</i>`)}else if(r.length){const c=r.length;x.push(`<i>${c} test result${c===1?"":"s"} recorded</i>`)}if(t.hbin!==void 0||t.sbin!==void 0){const c=[];if(t.hbin!==void 0){const p=D?.get(t.hbin)?.name,h=p?`${t.hbin} \xB7 ${p}`:String(t.hbin);c.push(`HBin: ${h}`)}if(t.sbin!==void 0){const p=v?.get(t.sbin)?.name,h=p?`${t.sbin} \xB7 ${p}`:String(t.sbin);c.push(`SBin: ${h}`)}x.push(c.join(" &nbsp;\xB7&nbsp; "))}}t.retestCount!==void 0&&x.push(`Retests: ${t.retestCount}`),t.siteNum!==void 0&&x.push(`Site: ${t.siteNum}`),t.partId!==void 0&&x.push(`Part ID: ${t.partId}`),t.partial&&x.push("<i>partial die</i>"),t.probeIndex!==void 0&&x.push(`Probe: #${t.probeIndex}`);const k={...y??{},...t.metadata??{}};for(const[r,c]of Object.entries(k))c!=null&&x.push(`${r}: ${String(c)}`);return x.join("<br>")}export function buildMapTitle(t,e="engineering",n){const i=t.isLotStack&&t.lotSize!==void 0?`stacked (${t.lotSize} ${t.lotSize===1?"wafer":"wafers"})`:"stacked",s=a=>{const o=n?.length===1?n[0]:void 0;return o===void 0?`${a} Bin`:o.name?`${a} Bin ${o.bin} \xB7 ${o.name}`:`${a} Bin ${o.bin}`};switch(t.plotMode){case"hardBin":return{primary:"Hard Bin",secondary:""};case"softBin":return{primary:"Soft Bin",secondary:""};case"stackedBins":return{primary:s("Hard"),secondary:i};case"stackedSoftBins":return{primary:s("Soft"),secondary:i};case"metadata":{const a=t.metadataFields?.find(l=>l.key===t.activeMetadataKey),o=t.activeMetadataKey?ne(t.activeMetadataKey):"Metadata";return{primary:a?.label??o,secondary:""}}case"stackedValues":{const a=t.testDefs?.[0],o=t.valueRange[1]||t.valueRange[0]||0,{axisLabel:l}=gt(o,a?.name,a?.unit,e),f=l||"Value",y=t.aggrMethod?` \xB7 ${Rt(t.aggrMethod)}`:"";return{primary:`${f}${y}`,secondary:i}}default:{const a=findTestDef(t.testDefs,t.activeTest),o=t.valueRange[1]||t.valueRange[0]||0,{axisLabel:l}=gt(o,a?.name,a?.unit,e),f=l||a?.name;if(t.passFailDisplay!=="off"){const y=a?.testNumber??t.activeTest,m=f?`${f} \xB7 #${y}`:`Test ${y}`,$=t.passFailDisplay==="spec"?"Spec pass/fail":a!==void 0&&!mt(a)?"Functional pass/fail":"Tester pass/fail";return{primary:m,secondary:$}}return{primary:f??`Test ${t.activeTest}`,secondary:""}}}}export function generateTextOverlay(t,e,n){const{plotMode:i,colorFns:s,normalize:a,activeTest:o,valueRange:l,testDefs:f,fallbackFormat:y,passFailDisplay:m="off",activeMetadataKey:$,metadataColorMap:D}=n,v=findTestDef(f,o),{tickFmt:x}=gt(l[1],v?.name,v?.unit,y),{testNumber:k}=resolveTestNumber(o,f);return t.flatMap((r,c)=>{let p="",h="#111111";if(i==="value"&&m==="test"){const b=G(r,k,v);if(b===void 0)return[];p=b?"P":"F",h=Y(b?ht:pt)}else if(i==="value"){const b=R(r,k);if(b===void 0)return[];p=Ht([b],x),h=Y(s.forValue(a(b)))}else if(i==="hardBin"||i==="softBin"){const b=i==="softBin"?r.sbin:r.hbin;if(b===void 0)return[];p=String(b),h=Y(s.forBin(b))}else if(i==="metadata"){const b=it(r,$);if(b===void 0)return[];p=b,h=Y(D?.get(p)??w)}else{const b=R(r,0);if(b===void 0)return[];p=Ht([b],x),h=Y(s.forValue(a(b)))}const M=e?e[c*2]:r.physX,T=e?e[c*2+1]:r.physY;return[{x:M,y:T,text:p,fontSize:le(r,p),color:h,align:"center"}]})}function Ot(t){return t==="top"?Math.PI/2:t==="bottom"?-Math.PI/2:t==="left"?Math.PI:0}function ue(t,e,n=720){const{center:i,radius:s,notch:a}=t,o=k=>X(e,k.x,k.y);if(!(a!==void 0&&t.diameter>150)){const k=[];for(let r=0;r<=n;r++){const c=2*Math.PI*r/n;k.push(o(oe(t,c)))}return[{kind:"wafer-boundary",..._(k,!0),lineColor:"#888888",lineWidth:1}]}const f=1.25,y=a.length,m=Ot(a.type),$=Math.atan2(y,s),D=s-f,v=[];let x=!1;for(let k=0;k<=n;k++){const r=2*Math.PI*k/n;let c=r-m;for(;c>Math.PI;)c-=2*Math.PI;for(;c<-Math.PI;)c+=2*Math.PI;if(Math.abs(c)<=$){if(!x){x=!0;const p={x:i.x+s*Math.cos(m-$),y:i.y+s*Math.sin(m-$)},h={x:i.x+D*Math.cos(m),y:i.y+D*Math.sin(m)},M={x:i.x+s*Math.cos(m+$),y:i.y+s*Math.sin(m+$)};v.push(o(p),o(h),o(M))}continue}v.push(o({x:i.x+s*Math.cos(r),y:i.y+s*Math.sin(r)}))}return[{kind:"wafer-boundary",..._(v,!0),lineColor:"#888888",lineWidth:1}]}function fe(t,e,n,i=360){const s=[],a=Math.max(1,Math.floor(n));for(let o=1;o<a;o++){const l=t.radius*o/a,f=[];for(let y=0;y<=i;y++){const m=2*Math.PI*y/i,$={x:t.center.x+l*Math.cos(m),y:t.center.y+l*Math.sin(m)};f.push(X(e,$.x,$.y))}s.push({kind:"ring-boundary",..._(f,!0),lineColor:"rgba(255,255,255,0.7)",lineWidth:1.5})}return s}function de(t,e,n,i){const{x:s,y:a}=t.center,o=t.radius,l=(r,c)=>X(e,r,c),f=n-s,y=Math.sqrt(Math.max(0,o*o-f*f)),m=l(n,a-y),$=l(n,a+y),D=i-a,v=Math.sqrt(Math.max(0,o*o-D*D)),x=l(s-v,i),k=l(s+v,i);return[{kind:"quadrant-boundary",..._([m,$]),lineColor:"rgba(255,255,255,0.7)",lineWidth:1.5},{kind:"quadrant-boundary",..._([x,k]),lineColor:"rgba(255,255,255,0.7)",lineWidth:1.5}]}function he(t,e){return t.map(n=>{const i=n.width/2,s=n.height/2;return{kind:"reticle",points:[[[n.x-i,n.y-s],[n.x+i,n.y-s],[n.x+i,n.y+s],[n.x-i,n.y+s]].map(([o,l])=>X(e,o,l))],closed:!0,lineColor:"rgba(255,255,255,0.7)",lineWidth:1.5,fill:"rgba(0,0,0,0)"}})}function pe(t){const e=t.filter(n=>n.probeIndex!==void 0).sort((n,i)=>(n.probeIndex??0)-(i.probeIndex??0));return e.length?[{kind:"probe-path",..._(e.map(n=>({x:n.physX,y:n.physY}))),lineColor:"rgba(220,80,0,0.55)",lineWidth:1}]:[]}function me(t,e,n,i,s,a,o,l,f,y,m,$,D,v="off",x,k,r){const c=e.width-o,p=e.height-o,h=a?p:c,M=a?c:p,T=B=>s==="softBin"?B.sbin:B.hbin,b=B=>it(B,x);if(e.partial){t.push({x:n,y:i,width:h,height:M,fill:ae,type:"stacked",metadata:e.metadata});return}if(e.edgeExcluded){t.push({x:n,y:i,width:h,height:M,fill:ie,type:"stacked",metadata:e.metadata});return}if(f!==void 0&&(s==="hardBin"||s==="softBin")&&T(e)!==f){t.push({x:n,y:i,width:h,height:M,fill:Nt,type:"hardBin",metadata:e.metadata});return}if(r!==void 0&&s==="metadata"&&b(e)!==r){t.push({x:n,y:i,width:h,height:M,fill:Nt,type:"metadata",metadata:e.metadata});return}if(s==="value"){if(v==="test"){const U=G(e,m,D),st=U===void 0?w:U?ht:pt;t.push({x:n,y:i,width:h,height:M,fill:st,type:"value",metadata:e.metadata});return}const B=R(e,m),P=classifySpec(B,D);let W,Q;B===void 0?W=w:v==="spec"?W=P==="failLow"?Jt:P==="failHigh"?pt:ht:(W=l.forValue(y(B)),(P==="failLow"||P==="failHigh")&&(Q=P)),t.push({x:n,y:i,width:h,height:M,fill:W,type:"value",specMark:Q,metadata:e.metadata});return}if(s==="hardBin"||s==="softBin"){const B=T(e),P=B!=null?l.forBin(B):w;t.push({x:n,y:i,width:h,height:M,fill:P,type:s,metadata:e.metadata});return}if(s==="metadata"){const B=b(e),P=B!==void 0?k?.get(B)??w:w;t.push({x:n,y:i,width:h,height:M,fill:P,type:"metadata",metadata:e.metadata});return}const O=R(e,0),A=O!==void 0?l.forValue(y(O)):w;t.push({x:n,y:i,width:h,height:M,fill:A,type:"value",metadata:e.metadata})}function ye(t,e,n){const i=t.radius*.15,s=dt(e,i,0),a=dt(e,0,i),o=s.x+a.x>=0?-1:1,l=s.y+a.y>=0?-1:1,f={x:t.center.x+o*t.radius*.9,y:t.center.y+l*t.radius*.9},y={x:f.x+s.x,y:f.y+s.y},m={x:f.x+a.x,y:f.y+a.y};return n.push({x:y.x+s.x*.35,y:y.y+s.y*.35,text:"+X",fontSize:10,color:"#cc3300",align:"center",role:"indicator"},{x:m.x+a.x*.35,y:m.y+a.y*.35,text:"+Y",fontSize:10,color:"#0044cc",align:"center",role:"indicator"}),[{kind:"xy-indicator",..._([f,y]),lineColor:"#cc3300",lineWidth:2},{kind:"xy-indicator",..._([f,m]),lineColor:"#0044cc",lineWidth:2}]}export function buildView(t,e,n={},i){const s=n.reticles??[],{plotMode:a="value",showDieLabels:o=!1,showReticle:l=!1,showProbePath:f=!1,ringCount:y=4,showRingBoundaries:m=!1,showQuadrantBoundaries:$=!1,showXYIndicator:D=!1,dieGap:v=1,colorScheme:x="default",highlightBin:k,highlightMetadataValue:r,interactiveTransform:c,valueRange:p,testDefs:h,activeTest:M=0,activeMetadataKey:T,fallbackFormat:b="engineering",aggregationMethod:O,lotSize:A,dataAxisFlip:B,isLotStack:P=!1,logScale:W,colorbarRangeMode:Q="spec",passFailDisplay:U,showPartialDies:st=!0}=n,xt=U??"off",bt=i?.hbinDefs,Mt=i?.sbinDefs,St=i?.metadataFields,At=St?.find(u=>u.key===T),Et={x:(B?.x??!1)!==(c?.flipX??!1),y:(B?.y??!1)!==(c?.flipY??!1)},_t=bt?new Map(bt.map(u=>[u.bin,u])):null,wt=Mt?new Map(Mt.map(u=>[u.bin,u])):null,ot=a==="softBin"?wt:_t,rt=Zt(x),$t={forValue:re(rt.forValue),forBin:x==="custom"&&ot?u=>ot.get(u)?.color??rt.forBin(u):rt.forBin};let{testNumber:H}=resolveTestNumber(M,h);if(!h?.length&&a==="value"&&!e.some(d=>d.testValues&&H in d.testValues)){const d=e.reduce((g,L)=>{if(!L.testValues)return g;const S=Object.keys(L.testValues).map(Number),K=S.length?Math.min(...S):void 0;return K!==void 0&&(g===void 0||K<g)?K:g},void 0);d!==void 0&&(H=d)}let J;if(Array.isArray(p))J=p;else if(p){const{testNumber:u}=resolveTestNumber(p.test,h);J=u===H?p.range:void 0}const I=findTestDef(h,H),kt=a==="value"&&I!==void 0&&!mt(I),Wt=I!==void 0&&(I.limitLow!==void 0||I.limitHigh!==void 0);let C="off";a==="value"&&(kt?C="test":xt==="spec"&&Wt?C="spec":xt==="test"&&e.some(u=>G(u,H,I)!==void 0)&&(C="test"));const Bt=C==="spec"?"spec":Q;let V,N,vt=!1;if(J)[V,N]=J;else{const u=a==="stackedValues"||a==="stackedBins"||a==="stackedSoftBins",d=!u&&a==="value"&&Bt==="spec"&&I&&(I.limitLow!==void 0||I.limitHigh!==void 0);let g=1/0,L=-1/0,S=!0;for(const K of e){const q=u?R(K,0):R(K,H);q!==void 0&&(q<g&&(g=q),q>L&&(L=q),Number.isInteger(q)||(S=!1))}isFinite(g)||(S=!1),vt=S,d?(V=I.limitLow!==void 0?I.limitLow:isFinite(g)?g:0,N=I.limitHigh!==void 0?I.limitHigh:isFinite(L)?L:1):(V=isFinite(g)?g:0,N=isFinite(L)?L:1)}V===N&&(N=V+1);const Tt=kt?!1:W??I?.logScale??!1,It=Tt&&V>0&&N>0,jt=It;let Z;if(It){const u=Math.log10(V),d=Math.log10(N)-u;Z=g=>g<=0?0:Ct((Math.log10(g)-u)/d)}else Z=u=>Ct((u-V)/(N-V));const F=se(t,B,c);let Lt=null;if(t.notch){const u=Ot(t.notch.type),d=dt(F.physicalToScreen,Math.cos(u)*t.radius,Math.sin(u)*t.radius),g=Math.hypot(d.x,d.y);g>0&&(Lt={x:d.x/g,y:d.y/g})}let j=1/0;for(let u=0;u<e.length;u++){const d=e[u];d.width<j&&(j=d.width),d.height<j&&(j=d.height)}const zt=j!==1/0?Math.min(v,j*.12):v,Dt=[],lt=[],Kt=F.bakedToScreen.a===1&&F.bakedToScreen.b===0&&F.bakedToScreen.c===0&&F.bakedToScreen.d===1&&F.bakedToScreen.e===0&&F.bakedToScreen.f===0;let E=null;if(!Kt){E=new Float64Array(e.length*2);for(let u=0;u<e.length;u++){const d=X(F.bakedToScreen,e[u].physX,e[u].physY);E[u*2]=d.x,E[u*2+1]=d.y}}const qt=Ut(F.gridToScreen),Xt=a==="hardBin"||a==="softBin"||a==="stackedBins"||a==="stackedSoftBins",Yt=a==="softBin"||a==="stackedSoftBins";let tt=Xt?new Map:void 0;const ct=a==="value"&&C==="spec"?{pass:0,failHigh:0,failLow:0}:void 0,ut=a==="value"&&C==="test"?{pass:0,fail:0}:void 0,Ft=a==="metadata";let et=Ft?new Map:void 0,nt=null;if(Ft&&T){const u=new Set;for(const g of e){if(g.partial||g.edgeExcluded)continue;const L=it(g,T);L!==void 0&&u.add(L)}const d=[...u].sort(ee);nt=new Map(d.map((g,L)=>[g,At?.values?.find(S=>S.value===g)?.color??te(L)]))}for(let u=0;u<e.length;u++){const d=e[u],g=E?E[u*2]:d.physX,L=E?E[u*2+1]:d.physY;if(lt.push({x:g,y:L}),tt&&!d.partial&&!d.edgeExcluded){const S=Yt?d.sbin:d.hbin;S!=null&&tt.set(S,(tt.get(S)??0)+1)}if(ct&&!d.partial&&!d.edgeExcluded){const S=classifySpec(R(d,H),I);S&&ct[S]++}if(ut&&!d.partial&&!d.edgeExcluded){const S=G(d,H,I);S!==void 0&&ut[S?"pass":"fail"]++}if(et&&!d.partial&&!d.edgeExcluded){const S=it(d,T);S!==void 0&&et.set(S,(et.get(S)??0)+1)}d.partial&&!st||me(Dt,d,g,L,a,qt,zt,$t,k,Z,H,ot,I,C,T,nt,r)}const Pt=o?generateTextOverlay(e,E,{plotMode:a,colorFns:$t,normalize:Z,activeTest:M,valueRange:[V,N],testDefs:h,fallbackFormat:b,passFailDisplay:C,activeMetadataKey:T,metadataColorMap:nt}):[],z=ue(t,F.physicalToScreen);m&&z.push(...fe(t,F.physicalToScreen,y)),$&&z.push(...de(t,F.physicalToScreen,t.center.x,t.center.y)),l&&z.push(...he(s,F.gridToScreen)),f&&z.push(...pe(e)),D&&z.push(...ye(t,F.gridToScreen,Pt));const Gt=lt.length>0?{minX:t.center.x-t.radius,maxX:t.center.x+t.radius,minY:t.center.y-t.radius,maxY:t.center.y+t.radius}:null;return{rectangles:Dt,hoverPoints:lt,texts:Pt,overlays:z,plotMode:a,colorScheme:x,metadata:t.metadata??null,dies:e,valueRange:[V,N],allIntegerValues:vt,testDefs:h,activeTest:M,logScale:jt,logScaleRequested:Tt,aggrMethod:O,lotSize:A,axisFlip:Et,dataAxisFlip:{x:B?.x??!1,y:B?.y??!1},gridToScreen:F.gridToScreen,rotation:((t.orientation+(c?.rotation??0))%360+360)%360,hasReticle:s.length>0,isLotStack:P,passFailDisplay:C,colorBySpec:C==="spec",colorbarRangeMode:Bt,waferCenter:t.center,waferRadius:t.radius,notchDir:Lt,binCounts:tt,metadataCounts:et,metadataColorMap:nt,activeMetadataKey:T,metadataFields:St,specCounts:ct,passFailCounts:ut,dieBounds:Gt}}export{getDieKey}from"../core/dies.js";