@wafertools/wafermap 0.21.1

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

@@ -0,0 +1,543 @@
+import type { Die } from '../core/dies.js';
+import type { DieMetadata, WaferMetadata } from '../core/metadata.js';
+import type { Wafer } from '../core/wafer.js';
+import type { Reticle } from '../core/reticle.js';
+import { type View, type ViewOptions, type PlotMode } from './buildView.js';
+/**
+ * Test result for a single die position, as output by the prober.
+ * `x` and `y` are **die grid positions** (prober step coordinates) — integers
+ * such as −7, 0, 5.  They are NOT millimetre values.
+ */
+export interface DieResult {
+    /** Die grid X position (prober step coordinate). */
+    x: number;
+    /** Die grid Y position (prober step coordinate). */
+    y: number;
+    /**
+     * Test values keyed by test number — a stable per-test identity such as
+     * STDF TEST_NUM or an equivalent application-defined integer. Keying by test
+     * number is unaffected by test ordering changes in the test program.
+     * 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 the tester's recorded verdict here (e.g. STDF
+     * PTR TEST_FLG); functional tests (`testType: 'F'` in `testDefs`) carry a
+     * verdict here ONLY — they have no measured value.
+     * Example: `{ 2001: true, 2002: false }`
+     */
+    testPass?: Record<number, boolean>;
+    /** Hard bin assignment (physical sort result). */
+    hbin?: number;
+    /** Soft bin assignment (test-program failure category). */
+    sbin?: number;
+    /**
+     * Number of times this die position appeared in the input results array.
+     * Populated automatically by `buildWaferMap` — do not set manually.
+     * Only present when the die was tested more than once.
+     */
+    retestCount?: number;
+    /**
+     * STDF `site_num` — which parallel test site tested this die.
+     * Only meaningful when more than one distinct value appears across the wafer
+     * (i.e. the wafer was tested with a multi-site probe card).
+     */
+    siteNum?: number;
+    /**
+     * STDF `pir.part_id` — tester-assigned identifier for this tested unit.
+     * At most fabs this encodes the probe sequence (the order in which the prober
+     * stepped across the wafer), but the field is semantically neutral — its
+     * meaning is fab-specific.
+     */
+    partId?: number;
+    /** Per-die metadata — all fields appear automatically in hover tooltips. See `DieMetadata → §12.4`. */
+    metadata?: DieMetadata;
+}
+/** Wafer geometry parameters — all optional; any omitted fields are inferred. */
+export interface WaferConfig {
+    /** Wafer diameter in mm.  Inferred from grid extent × pitch when omitted. */
+    diameter?: number;
+    /**
+     * The prober coordinate `(x, y)` that lies at the physical centre of the
+     * wafer.  Supply this for **partial or sparse** data (a half wafer, a single
+     * quadrant, an edge ring, a small cluster) or whenever the prober origin is
+     * not the wafer centre.
+     *
+     * When omitted, the centre is inferred as the midpoint of the observed die
+     * positions — correct only when the data spans a full, roughly symmetric
+     * wafer.  For partial data that assumption is wrong: the data midpoint is not
+     * the wafer centre, so dies would be mis-positioned relative to the true
+     * boundary and notch.  Setting this anchors placement to the real centre.
+     *
+     * Note: this does not change the public `die.x` / `die.y` labels — those are
+     * always the original prober coordinates.  It only fixes physical placement.
+     */
+    center?: {
+        x: number;
+        y: number;
+    };
+    /**
+     * Orientation mark direction.  Standard dimensions are derived automatically
+     * from the wafer diameter:
+     * - ≤ 100 mm → 32.5 mm orientation flat (SEMI M1)
+     * - ≤ 150 mm → 57.5 mm orientation flat (SEMI M1)
+     * - > 150 mm → V-notch (~3.5 mm wide, 1.25 mm deep — SEMI M1)
+     */
+    notch?: {
+        type: 'top' | 'bottom' | 'left' | 'right';
+    };
+    /**
+     * Wafer orientation in degrees.  Positive values rotate the map
+     * clockwise.  The notch/flat position is set by `notch.type` and is not
+     * affected by this value — `orientation` rotates the *die grid* on the display.
+     *
+     * Common values: 0 (default), 90, 180, 270.
+     */
+    orientation?: number;
+    metadata?: WaferMetadata;
+    /**
+     * Physical edge exclusion zone in mm measured from the wafer edge inward.
+     * Dies whose centres fall inside this band are rendered dimmed and marked
+     * `edgeExcluded: true` on the returned Die objects.
+     */
+    edgeExclusion?: number;
+}
+/**
+ * Die geometry and coordinate-system parameters — all optional.
+ * When omitted, dimensions are estimated from the grid layout.
+ */
+export interface DieConfig {
+    /** Die width in mm (= X pitch). */
+    width?: number;
+    /** Die height in mm (= Y pitch). */
+    height?: number;
+    /**
+     * Where the prober places coordinate (0,0) on the wafer grid.
+     *
+     * - `'center'`  (default) — grid already near (0,0); centroid offset applied.
+     * - `'LL'`      — (0,0) at lower-left; positive x right, positive y up.
+     * - `'UL'`      — (0,0) at upper-left; positive x right, positive y **down**.
+     * - `'LR'`      — (0,0) at lower-right; positive x **left**, positive y up.
+     * - `'UR'`      — (0,0) at upper-right; positive x left, positive y down.
+     * - `'custom'`  — apply explicit `offset` (in grid steps) to centre the grid.
+     *
+     */
+    coordinateOrigin?: {
+        type: 'center' | 'LL' | 'UL' | 'LR' | 'UR' | 'custom';
+        /** Grid-step offset to the true centre.  Used only when type is `'custom'`. */
+        offset?: {
+            x: number;
+            y: number;
+        };
+    };
+    /**
+     * Direction in which the prober Y axis increases.
+     * `'up'` (default) is standard Cartesian; `'down'` is row/matrix convention
+     * (row 1 at top).  The library flips the display Y axis so the map renders
+     * with +Y pointing up regardless of the prober convention.
+     */
+    yAxisDirection?: 'up' | 'down';
+    /**
+     * Direction in which the prober X axis increases.
+     * `'right'` (default) is standard; `'left'` is used for backside probing or
+     * mirrored coordinate systems.
+     */
+    xAxisDirection?: 'right' | 'left';
+}
+/**
+ * Reticle (stepper field) overlay configuration.
+ * Dimensions are in die counts; `anchorDie` pins a specific die index to the
+ * reticle's min-x/min-y corner (bottom-left, since +Y is up).
+ */
+export interface ReticleConfig {
+    /** Field width in number of dies. */
+    width: number;
+    /** Field height in number of dies. */
+    height: number;
+    /**
+     * Die grid index (x, y) — in original die coordinates (`die.x`/`die.y`) — that
+     * sits at the reticle field's min-x/min-y corner (bottom-left, since +Y is up).
+     * That die becomes the leftmost, bottom-most die of the field it belongs to;
+     * every field boundary is placed relative to it. Controls the phase
+     * (alignment) of the reticle grid. Defaults to `{x: 0, y: 0}`.
+     */
+    anchorDie?: {
+        x: number;
+        y: number;
+    };
+}
+/**
+ * Lot-level stacking — collapse results from several wafers into a single map.
+ * The aggregated result is used as the `results` for this map; any top-level
+ * `results` field is ignored when `lotStack` is present.
+ */
+export interface LotStackConfig {
+    /** One `DieResult[]` per wafer in the lot. */
+    results: DieResult[][];
+    /** Aggregation method applied per die position across all wafers. */
+    method: 'mean' | 'median' | 'stddev' | 'min' | 'max' | 'count' | 'countBin' | 'mode' | 'percent';
+    /** Required when `method` is `'countBin'` or `'percent'`. */
+    targetBin?: number;
+}
+/**
+ * Metadata for one test measurement.
+ * Provides a human-readable name and optional unit for display in tooltips,
+ * the colorbar, and the mode selector.
+ */
+export interface TestDef {
+    /**
+     * Stable per-test identity — an application-defined integer that uniquely
+     * identifies this test within a test program (for example, STDF TEST_NUM).
+     * Must match the key used in `DieResult.testValues` / `DieResult.testPass`.
+     */
+    testNumber: number;
+    /** Human-readable test name, e.g. `"Idsat"` or `"Vth"`. */
+    name: string;
+    /** Physical unit string, e.g. `"A"`, `"V"`, `"Ω"`. Shown in tooltip and colorbar. */
+    unit?: string;
+    /**
+     * When true, value normalization and the colorbar use log₁₀ scale for this test.
+     * Silently falls back to linear when any die value is ≤ 0. Default: false.
+     */
+    logScale?: boolean;
+    /**
+     * Lower specification limit in the same units as the test value.
+     * When set, values below this limit are considered out-of-spec.
+     * Both limits are optional independently — some tests have one-sided limits.
+     */
+    limitLow?: number;
+    /**
+     * Upper specification limit in the same units as the test value.
+     * When set, values above this limit are considered out-of-spec.
+     */
+    limitHigh?: number;
+    /**
+     * Test kind: `'P'` (parametric — a continuous measured value) or `'F'`
+     * (functional — a pass/fail outcome, conventionally recorded as 1 = pass,
+     * 0 = fail, e.g. an STDF FTR). Functional tests render on the wafer map
+     * like any other test value, but are excluded from parametric statistics —
+     * per-test descriptive stats, capability, correlation, distribution charts,
+     * and regional value findings — where a mean or Cpk of a binary outcome
+     * would be meaningless. Default: `'P'`.
+     */
+    testType?: 'P' | 'F';
+}
+/**
+ * True when `def` describes a parametric (continuous-value) test — i.e. its
+ * values are valid input for parametric statistics (mean, quartiles, Cpk,
+ * correlation). Functional tests (`testType: 'F'`) record pass/fail outcomes,
+ * not measurements. An undefined def or undefined `testType` defaults to
+ * parametric, so untyped callers keep today's behaviour.
+ */
+export declare function isParametricTest(def: TestDef | undefined): boolean;
+/**
+ * Metadata for one bin number (hard bin or soft bin).
+ * Hard bins and soft bins have independent number spaces (both 0–32767 per STDF V4)
+ * so separate `hbinDefs` and `sbinDefs` arrays are used — never mixed.
+ */
+export interface BinDef {
+    /** Numeric bin value this definition describes. */
+    bin: number;
+    /** Human-readable bin name, e.g. `"Pass"` or `"Contact Open"`. */
+    name: string;
+    /**
+     * Optional CSS color override for this bin.
+     * When set, overrides the active colour scheme for this bin value.
+     */
+    color?: string;
+}
+/**
+ * Named definition for one `die.metadata` key, opting it into the `'metadata'`
+ * plot mode's toolbar entry, color fill, and legend. Presence in
+ * `metadataFields` is what makes a key selectable — wmap never guesses which
+ * metadata keys are "categorical enough" to plot.
+ */
+export interface MetadataFieldDef {
+    /** The `die.metadata` key this definition applies to. */
+    key: string;
+    /** Display name for the toolbar entry and map title. Defaults to a Title-Cased version of `key`. */
+    label?: string;
+    /**
+     * Optional per-value name/color overrides. Distinct values not listed here
+     * are still shown — auto-labeled with the raw (stringified) value and
+     * auto-colored from an ordered palette.
+     */
+    values?: Array<{
+        value: string;
+        label?: string;
+        color?: string;
+    }>;
+}
+/** Input accepted by {@link buildWaferMap}.  All fields are optional. */
+/** Fields common to both single-wafer and lot-stack inputs. */
+export interface WaferMapInputBase {
+    /** Wafer geometry — diameter, notch direction, orientation, edge exclusion. */
+    waferConfig?: WaferConfig;
+    /** Die size and coordinate-system conventions. */
+    dieConfig?: DieConfig;
+    /** Pre-built die array. When supplied, geometry generation is skipped. */
+    dies?: Die[];
+    /**
+     * Reticle (stepper field) overlay.
+     * When provided, `showReticle` defaults to `true` in the scene options.
+     */
+    reticleConfig?: ReticleConfig;
+    /**
+     * Bin values that count as pass for yield calculation.
+     * Defaults to `[1]` (industry convention: bin 1 = pass).
+     * Set to an empty array to suppress yield calculation.
+     */
+    passBins?: number[];
+    /**
+     * How to handle multiple `DieResult` entries for the same die position (retests).
+     *
+     * - `'last'`  (default) — keep the most recent result. Matches pre-existing behaviour
+     *              and is appropriate when records are in probe order and the final touch
+     *              is the authoritative result.
+     * - `'first'` — keep the earliest result. Useful when the first touch is canonical
+     *              or when the array is already sorted best-first.
+     * - `'best'`  — keep the result with the best hard bin outcome. Pass beats fail
+     *              (determined by `passBins`); within the same category, the lower hbin
+     *              number wins. Requires `hbin` on each result — if either record in a
+     *              comparison has no `hbin`, the existing record is kept. `sbin` and
+     *              `testValues` are not used as ordering criteria.
+     * - `'worst'` — inverse of `'best'`: fail beats pass; higher hbin number wins within
+     *              each category. Same `hbin` requirement applies.
+     *
+     * Regardless of policy, `die.retestCount` is set on any die that was tested more than
+     * once, so retest hotspots are always visible.
+     */
+    retestPolicy?: 'last' | 'first' | 'best' | 'worst';
+    /**
+     * Named test definitions — one per entry in `die.values[]`.
+     * When provided, tooltips show `"Idsat: 1.23 A"` instead of `"Values: 1.23"`,
+     * and the mode selector offers a per-test dropdown entry.
+     */
+    testDefs?: TestDef[];
+    /**
+     * Named hard bin definitions — one per distinct `hbin` value.
+     * Hard bins and soft bins have independent number spaces (STDF V4: both 0–32767),
+     * so they are defined separately.
+     * When provided, the bin legend and tooltips show names like `"Pass"` instead of `"Bin 1"`.
+     * A `color` on a `BinDef` overrides the active colour scheme for that bin.
+     */
+    hbinDefs?: BinDef[];
+    /**
+     * Named soft bin definitions — one per distinct `sbin` value.
+     * Soft bins are the logical/test-program classification; hard bins are the physical sort result.
+     * Both spaces range 0–32767 and may overlap — define them separately.
+     */
+    sbinDefs?: BinDef[];
+    /**
+     * Named definitions for `die.metadata` keys that should be selectable as the
+     * `'metadata'` plot mode — a generic categorical view driven by whatever
+     * per-die classification a host already has in `metadata` (project, vendor,
+     * test site, wafer zone, …), distinct from test/bin results. A key only
+     * appears in the toolbar when it's listed here (opt-in, never auto-detected)
+     * and at least one die actually has that key set.
+     */
+    metadataFields?: MetadataFieldDef[];
+    /**
+     * Controls how edge-excluded dies (dies within the edge exclusion zone) are counted in yield.
+     *
+     * - `'exclude'` (default) — edge dies are excluded from both numerator and denominator.
+     *   `yieldPercent` = `passDies / (passDies + failDies)` counting only non-edge dies.
+     * - `'denominator-only'` — edge dies are counted in `totalDies` denominator but never
+     *   as pass.  This gives gross die yield: pass count vs. total populated area.
+     *   `yieldPercentGross` is also set on `YieldSummary` for unambiguous reference.
+     */
+    edgeDieYieldMode?: 'exclude' | 'denominator-only';
+}
+/** Single-wafer input — pass one wafer's die results directly. */
+export interface WaferMapInputSingle extends WaferMapInputBase {
+    /** Per-die test results from the prober. */
+    results?: DieResult[];
+    lotStack?: never;
+}
+/** Lot-stack input — collapse results from multiple wafers into a single aggregated map. */
+export interface WaferMapInputLotStack extends WaferMapInputBase {
+    /** Lot-level stacking — collapse results from several wafers into a single map. */
+    lotStack: LotStackConfig;
+    results?: never;
+}
+/**
+ * Input accepted by {@link buildWaferMap}.
+ * Use {@link WaferMapInputSingle} for a single wafer or {@link WaferMapInputLotStack}
+ * for an aggregated lot-stack map. Passing both `results` and `lotStack` is a type error.
+ */
+export type WaferMapInput = WaferMapInputSingle | WaferMapInputLotStack;
+/** Options forwarded to {@link buildView}. */
+export interface WaferMapOptions extends ViewOptions {
+    debug?: boolean;
+}
+export interface YieldSummary {
+    /** Dies with a bin in `passBins`. */
+    passDies: number;
+    /** Full dies inside wafer boundary with a bin not in `passBins`. */
+    failDies: number;
+    /** Full dies whose centres fall within the edge exclusion zone. */
+    edgeExcludedDies: number;
+    /** Dies that straddle the wafer boundary. */
+    partialDies: number;
+    /** Total full dies inside wafer boundary used for yield (excludes edge and partial). */
+    totalDies: number;
+    /** `(passDies / totalDies) × 100` in [0, 100], or `null` when no bin data is present. */
+    yieldPercent: number | null;
+    /**
+     * Gross die yield: `passDies / (passDies + failDies + edgeExcludedDies) × 100` in [0, 100].
+     * Set when `edgeDieYieldMode: 'denominator-only'` was passed; `null` otherwise.
+     */
+    yieldPercentGross?: number | null;
+}
+/**
+ * A non-fatal advisory raised while `buildWaferMap` inferred geometry from data.
+ * Surface these to the user (a panel, a log, a status line) instead of letting
+ * silent inference mask questionable input — an engineer reading a wafer map
+ * built on guessed geometry must be told the geometry was guessed.
+ */
+export interface WaferWarning {
+    /**
+     * Stable machine-readable key for the advisory. Branch on this, not on
+     * `message` (which is prose and may be reworded). Known codes:
+     * - `'partial-coverage'` — data does not span a full symmetric wafer; the
+     *   inferred diameter and centre may be wrong and dies may be mis-positioned.
+     * - `'geometry-conflict'` — `waferConfig.diameter` and `dieConfig.width`/`height`
+     *   were BOTH supplied, and the wafer is too small to contain the probed dies.
+     *   Since a die with test results is a real prober position and is always fully
+     *   on the wafer, the two supplied values contradict each other and the die
+     *   positions are the trustworthy side. wmap does not silently resize a diameter
+     *   you asserted — it reports this so you can correct one of them. Only raised
+     *   when the pitch was supplied: pitch is a free scaling parameter, so with an
+     *   inferred pitch "the dies don't fit" is not a statement about your data.
+     * - `'inferred-pitch'` — `waferConfig.diameter` was supplied without a die pitch,
+     *   so the pitch was derived as `diameter ÷ grid span`, assuming the grid spans
+     *   the full wafer. That assumption fails whenever edge dies are absent, which
+     *   silently scales every die position. Supply `dieConfig.width`/`height`.
+     *
+     * The union is intentionally open to string so future advisory codes can be
+     * added without a breaking change; switch with a `default` branch.
+     */
+    code: 'partial-coverage' | 'geometry-conflict' | 'inferred-pitch' | (string & {});
+    /** Human-readable explanation, suitable for direct display. */
+    message: string;
+    /** Inference confidence in [0, 1] for the related quantity, when one exists. */
+    confidence?: number;
+}
+export interface WaferMapResult {
+    wafer: Wafer;
+    dies: Die[];
+    /**
+     * The initial plot mode selected by `buildWaferMap` — `'value'` when test values are
+     * present, `'hardBin'` otherwise. Used to initialise the toolbar to the most useful mode.
+     */
+    plotMode: PlotMode;
+    /** Wafer metadata copied from `waferConfig.metadata`, or `null` if none was provided. */
+    metadata: import('../core/metadata.js').WaferMetadata | null;
+    /** `true` when the result was built from a `lotStack` aggregation. */
+    isLotStack: boolean;
+    /**
+     * @internal Renderer-agnostic draw list consumed by `renderWaferMap` and `toCanvas`.
+     * Not part of the public API — access the named fields on `WaferMapResult` instead.
+     */
+    view: View;
+    /** Reticle configuration used to generate the overlay and reticle-local groupings. */
+    reticleConfig?: ReticleConfig;
+    /**
+     * Coordinate space of `die.physX` / `die.physY` and wafer dimensions:
+     * - **'mm'**         — at least one physical dimension was provided or could
+     *                      be inferred; all spatial values are in real millimetres.
+     * - **'normalized'** — only grid positions were supplied; coordinates are
+     *                      proportionally correct but not in physical mm.
+     */
+    units: 'mm' | 'normalized';
+    inference: {
+        wafer: {
+            confidence: number;
+            method: string;
+        };
+        diePitch: {
+            confidence: number;
+            units: 'mm' | 'normalized';
+        };
+        grid: {
+            confidence: number;
+        };
+        /**
+         * @deprecated Use the promoted top-level `WaferMapResult.warnings` instead —
+         * it is always present (empty when none) and carries structured
+         * `{ code, message, confidence? }` entries you can branch on. This raw
+         * string array is retained for backward compatibility and mirrors the
+         * `message` of each structured warning.
+         */
+        warnings?: string[];
+    };
+    /**
+     * Structured non-fatal advisories raised while inferring geometry from data.
+     * Always present; empty when geometry was supplied or confidently inferred.
+     * Branch on `warning.code` and display `warning.message`. The most important
+     * case is `'partial-coverage'`: data that does not span a full symmetric
+     * wafer, where the inferred diameter and centre may be wrong. Read this
+     * programmatically rather than relying on console output.
+     */
+    warnings: WaferWarning[];
+    /** Die population statistics. */
+    dataCoverage: {
+        /** Dies inside the wafer boundary that have at least one value or bin. */
+        filledDies: number;
+        /** Total dies inside the wafer boundary (including partial). */
+        totalDies: number;
+        /** Dies falling within the edge exclusion zone. */
+        edgeExcludedDies: number;
+        /** `filledDies / totalDies` in [0, 1]. */
+        ratio: number;
+    };
+    /** Yield statistics computed against `passBins`. */
+    yield: YieldSummary;
+    /** Generated reticle geometry — pass as `viewOptions.reticles` to `renderWaferMap` to show the reticle overlay. */
+    reticles: Reticle[];
+    /** Named hard bin definitions passed to `buildWaferMap`. Consumed automatically by the renderer — no need to pass again to `renderWaferMap`. */
+    hbinDefs?: BinDef[];
+    /** Named soft bin definitions passed to `buildWaferMap`. Consumed automatically by the renderer — no need to pass again to `renderWaferMap`. */
+    sbinDefs?: BinDef[];
+    /** Named test definitions passed to `buildWaferMap`. Consumed automatically by the renderer — no need to pass again to `renderWaferMap`. */
+    testDefs?: TestDef[];
+    /** Named metadata-field definitions passed to `buildWaferMap`. Consumed automatically by the renderer — no need to pass again to `renderWaferMap`. */
+    metadataFields?: MetadataFieldDef[];
+    /**
+     * Lot-stack aggregation method used when `lotStack` was passed to `buildWaferMap`.
+     * `undefined` for single-wafer results.
+     */
+    aggrMethod?: string;
+    /**
+     * Number of wafers aggregated when `lotStack` was passed to `buildWaferMap`.
+     * `undefined` for single-wafer results.
+     */
+    lotSize?: number;
+}
+/** Read a test value from a die by test number. */
+export declare function getDieTestValue(die: Die, testNumber: number): number | undefined;
+/**
+ * Single read-path for "did this die pass test `testNumber`".
+ *
+ * Primary source: `die.testPass[testNumber]` (the tester's recorded verdict).
+ * Migration fallback — the ONLY place this rule exists: a functional test
+ * (`testType: 'F'`) with no `testPass` entry but a `testValues` entry of
+ * exactly 0 or 1 is legacy encoding (1 = pass, 0 = fail) from callers that
+ * predate `testPass`. The fallback is never applied to parametric tests,
+ * whose values are measurements.
+ *
+ * Returns `undefined` when no verdict is recorded — callers must treat that
+ * as no-data, never as a fail.
+ */
+export declare function getTestPassStatus(die: Pick<Die, 'testValues' | 'testPass'>, testNumber: number, testDef?: TestDef): boolean | undefined;
+/**
+ * True when the die carries any per-test data — a measured test value or a
+ * recorded pass/fail verdict. The single source for "does this die have test
+ * data", used by coverage, plot-mode inference, and the toolbar's value-mode
+ * availability checks.
+ */
+export declare function dieHasTestData(die: Pick<Die, 'testValues' | 'testPass'>): boolean;
+export declare function buildWaferMap(input: DieResult[] | WaferMapInput, options?: WaferMapOptions): WaferMapResult;
+//# sourceMappingURL=buildWaferMap.d.ts.map

package/dist/packages/renderer/buildWaferMap.js

@@ -0,0 +1 @@
+import{createWafer as $}from"../core/wafer.js";import{isYieldEligibleDie as Q,getDieKey as I}from"../core/dies.js";import{applyOrientation as A,transformDies as Z}from"../core/transforms.js";import{affineRotation as ee,affineMirror as te,affineCompose as ne,affinePoint as ie}from"../core/transforms.js";import{inferWaferFromXY as se}from"../core/inference/wafer.js";import{resolveGridPitch as oe}from"../core/inference/pitch.js";import{assignGridIndices as re}from"../core/inference/grid.js";import{generateReticleGrid as ae}from"../core/reticle.js";import{buildView as T}from"./buildView.js";import{modeOf as fe}from"../core/utils.js";import{aggregateValues as L,aggregateBinCounts as de}from"../core/aggregates.js";export function isParametricTest(t){return t?.testType!=="F"}function ce(t){if(!Array.isArray(t)&&"results"in t&&t.results!==void 0&&"lotStack"in t&&t.lotStack!==void 0)throw new Error("buildWaferMap: pass either `results` or `lotStack`, not both.");return Array.isArray(t)?{results:t,waferOpts:void 0,dieOpts:void 0,explicitDies:void 0,reticleOpts:void 0,lotStackOpts:void 0,passBins:[1],testDefs:void 0,hbinDefs:void 0,sbinDefs:void 0,metadataFields:void 0,retestPolicy:"last",edgeDieYieldMode:"exclude"}:{results:t.results??[],waferOpts:t.waferConfig,dieOpts:t.dieConfig,explicitDies:t.dies,reticleOpts:t.reticleConfig,lotStackOpts:t.lotStack,passBins:t.passBins??[1],testDefs:t.testDefs,hbinDefs:t.hbinDefs,sbinDefs:t.sbinDefs,metadataFields:t.metadataFields,retestPolicy:t.retestPolicy??"last",edgeDieYieldMode:t.edgeDieYieldMode??"exclude"}}function le(t,n){return n?.coordinateOrigin?n.coordinateOrigin:{type:"center"}}function ue(t,n,e){if(n.type==="custom"&&n.offset)return{offsetX:n.offset.x,offsetY:n.offset.y};if(n.type!=="center"){let o=1/0,r=-1/0,h=1/0,f=-1/0;for(const i of t)i.x<o&&(o=i.x),i.x>r&&(r=i.x),i.y<h&&(h=i.y),i.y>f&&(f=i.y);return{offsetX:Math.round((r+o)/2),offsetY:Math.round((f+h)/2)}}return{offsetX:e.offsetX,offsetY:e.offsetY}}function he(t,n,e,o,r,h){if(h)return{colMidX:(Math.round(h.x)-n)*o,colMidY:(Math.round(h.y)-e)*r,anchored:!0};if(t.length===0)return{colMidX:0,colMidY:0,anchored:!1};let f=1/0,i=-1/0,d=1/0,a=-1/0;for(const s of t){const c=Math.round(s.x)-n,p=Math.round(s.y)-e;c<f&&(f=c),c>i&&(i=c),p<d&&(d=p),p>a&&(a=p)}return{colMidX:(f+i)/2*o,colMidY:(d+a)/2*r,anchored:!1}}function pe(t,n,e){let o=1/0,r=-1/0,h=1/0,f=-1/0,i=0,d=0;for(const c of t){const p=Math.round(c.x)-n,u=Math.round(c.y)-e;i+=p,d+=u,p<o&&(o=p),p>r&&(r=p),u<h&&(h=u),u>f&&(f=u)}const a=t.length,s=(c,p,u)=>{const g=(u-p)/2;return g<=0?0:Math.abs(c/a-(p+u)/2)/g};return s(i,o,r)>.11||s(d,h,f)>.11}function me(t,n){let e=t?.xAxisDirection==="left",o=t?.yAxisDirection==="down";return(n.type==="UL"||n.type==="UR")&&(o=!0),(n.type==="LR"||n.type==="UR")&&(e=!0),{flipX:e,flipY:o}}function ye(t,n){const{results:e,method:o,targetBin:r}=t;if(o==="mean"||o==="median"||o==="stddev"||o==="min"||o==="max"||o==="count"){const h=new Set((n??[]).filter(s=>!isParametricTest(s)).map(s=>s.testNumber)),f=new Set;for(const s of e)for(const c of s)if(c.testValues)for(const p of Object.keys(c.testValues)){const u=Number(p);h.has(u)||f.add(u)}if(f.size===0)return L(e,o);const i=[...f],d=i.map(s=>L(e,o,s)),a=new Map;for(let s=0;s<i.length;s++){const c=i[s];for(const p of d[s]){const u=I(p);a.has(u)||a.set(u,{template:p,testValues:{}});const g=a.get(u),m=p.testValues?.[0];m!==void 0&&(g.testValues[c]=m)}}return[...a.values()].map(({template:s,testValues:c})=>({...s,testValues:Object.keys(c).length>0?c:void 0}))}if(o==="countBin"||o==="percent"){if(r===void 0)return[];const h=de(e,r,"hard");if(o==="countBin")return h;const f=e.length;return h.map(i=>({...i,testValues:{0:f>0?(i.testValues?.[0]??0)/f*100:0}}))}if(o==="mode"){const h=new Map;for(const i of e)for(const d of i){const a=I(d);h.has(a)||h.set(a,[]),h.get(a).push(d)}const f=[];for(const[i,d]of h){const a=i.split(","),s=Number(a[0]),c=Number(a[1]),p=d.map(g=>g.hbin).filter(g=>g!==void 0),u=fe(p);u!==null&&f.push({x:s,y:c,hbin:u})}return f}return[]}function W(t){const n=t.length,e=t.filter(r=>r.edgeExcluded).length,o=t.filter(r=>dieHasTestData(r)||r.hbin!==void 0||r.sbin!==void 0).length;return{filledDies:o,totalDies:n,edgeExcludedDies:e,ratio:n>0?o/n:0}}function N(t,n,e="exclude"){const o=new Set(n),h=t.filter(u=>!u.partial).filter(u=>u.edgeExcluded).length,f=t.filter(u=>u.partial).length;let i=0,d=0,a=!1;for(const u of t){if(!Q(u))continue;const g=u.hbin??u.sbin;g!==void 0&&(a=!0,o.has(g)?i++:d++)}const s=i+d,c=a&&s>0?i/s*100:null;let p=null;if(e==="denominator-only"){const u=s+h;p=a&&u>0?i/u*100:null}return{passDies:i,failDies:d,edgeExcludedDies:h,partialDies:f,totalDies:s,yieldPercent:c,yieldPercentGross:p}}function _(t,n,e,o,r,h=0,f=0,i=0,d=0,a=0,s=!1,c=!1){if(!t)return[];const p=t.anchorDie??{x:0,y:0},u=ae(n,{width:t.width,height:t.height,diePitchX:o,diePitchY:r,anchorDie:{x:p.x-h,y:p.y-f},gridOrigin:{x:-i,y:-d}}),g=ne(te(s,c,n.center.x,n.center.y),ee(a,n.center.x,n.center.y));return u.filter(m=>{const x=m.width/2,O=m.height/2,S=[[m.x-x,m.y-O],[m.x+x,m.y-O],[m.x+x,m.y+O],[m.x-x,m.y+O]].map(([y,C])=>ie(g,y,C)),R=Math.min(...S.map(y=>y.x)),Y=Math.max(...S.map(y=>y.x)),E=Math.min(...S.map(y=>y.y)),D=Math.max(...S.map(y=>y.y));return e.some(y=>y.physX>=R&&y.physX<Y&&y.physY>=E&&y.physY<D)})}function ge(t,n,e){const o=(n.radius-e)**2;return t.map(r=>{const h=r.physX-n.center.x,f=r.physY-n.center.y;return h*h+f*f>o?{...r,edgeExcluded:!0}:r})}function xe(t,n,e){const o=new Map;for(const i of t){let d=o.get(i.x);d||(d=new Map,o.set(i.x,d)),d.set(i.y,(d.get(i.y)??0)+1)}const r=new Set(e);function h(i,d){const a=i.hbin,s=d.hbin;if(a===void 0||s===void 0)return!1;const c=r.has(a),p=r.has(s);return n==="best"?p!==c?p:s<a:p!==c?c:s>a}const f=new Map;for(const i of t){const d=I(i),a=f.get(d);n==="first"&&a||(n==="best"||n==="worst")&&a&&!h(a,i)||f.set(d,i)}return Array.from(f.values()).map(i=>{const a=o.get(i.x)?.get(i.y)??1;return a>1?{...i,retestCount:a}:i})}export function getDieTestValue(t,n){return t.testValues?.[n]}export function getTestPassStatus(t,n,e){const o=t.testPass?.[n];if(o!==void 0)return o;if(e!==void 0&&!isParametricTest(e)){const r=t.testValues?.[n];if(r===0||r===1)return r===1}}export function dieHasTestData(t){return t.testValues!==void 0&&Object.keys(t.testValues).length>0||t.testPass!==void 0&&Object.keys(t.testPass).length>0}function G(t,n){const e={};return n.hbin!==void 0&&(e.hbin=n.hbin),n.sbin!==void 0&&(e.sbin=n.sbin),n.retestCount!==void 0&&(e.retestCount=n.retestCount),n.siteNum!==void 0&&(e.siteNum=n.siteNum),n.partId!==void 0&&(e.partId=n.partId),n.metadata!==void 0&&(e.metadata=n.metadata),n.testPass!==void 0&&(e.testPass=n.testPass),n.testValues!==void 0&&(e.testValues=n.testValues),{...t,...e}}function K(t,n){return n.plotMode?n.plotMode:t.some(dieHasTestData)?"value":"hardBin"}function z(t){return(t.warnings??[]).map(n=>({code:we(n),message:n,confidence:t.wafer.confidence}))}function we(t){return t.includes(j)?"geometry-conflict":t.includes(H)?"inferred-pitch":"partial-coverage"}const j="do not fit inside the supplied",H="The die pitch was inferred as";export function buildWaferMap(t,n){const e=ce(t),{debug:o,...r}=n??{},h=e.lotStackOpts?ye(e.lotStackOpts,e.testDefs):e.results;for(let l=0;l<Math.min(5,h.length);l++){const M=h[l];if(typeof M.x=="string"||typeof M.y=="string")throw new TypeError("buildWaferMap: x and y must be numbers, received strings. Did you forget to cast CSV values? e.g. { x: +row.x, y: +row.y }")}const f=xe(h,e.retestPolicy,e.passBins),i={wafer:{confidence:1,method:"provided"},diePitch:{confidence:1,units:"mm"},grid:{confidence:1}};if(e.explicitDies){let l=e.explicitDies;if(f.length>0){const J=new Map(f.map(P=>[I(P),P]));l=l.map(P=>{const X=J.get(I(P));return X?G(P,X):P})}const M=e.waferOpts?.diameter??300,b=$({diameter:M,notch:e.waferOpts?.notch,orientation:e.waferOpts?.orientation??0,metadata:e.waferOpts?.metadata});b.orientation!==0&&(l=A(l,b));const v=_(e.reticleOpts,b,l,1,1,0,0,0,0,b.orientation),q=r.showReticle??e.reticleOpts!==void 0,V=T(b,l,{...r,reticles:v,showReticle:q,plotMode:K(f,r),testDefs:e.testDefs,isLotStack:!1},{hbinDefs:e.hbinDefs,sbinDefs:e.sbinDefs,metadataFields:e.metadataFields});return{wafer:b,dies:l,view:V,reticleConfig:e.reticleOpts,units:"mm",inference:i,warnings:z(i),plotMode:V.plotMode,metadata:V.metadata,isLotStack:!1,dataCoverage:W(l),yield:N(l,e.passBins,e.edgeDieYieldMode),reticles:v,hbinDefs:e.hbinDefs,sbinDefs:e.sbinDefs,testDefs:e.testDefs,metadataFields:e.metadataFields}}const d=f.map(l=>({x:l.x,y:l.y})),a=oe(d,e.dieOpts,e.waferOpts?.diameter);i.diePitch={confidence:a.confidence,units:a.units};const{pitchX:s,pitchY:c}=a,p=a.units,u=le(f,e.dieOpts),g=re(d);i.grid={confidence:g.confidence};const{offsetX:m,offsetY:x}=ue(d,u,g),{flipX:O,flipY:S}=me(e.dieOpts,u),{colMidX:R,colMidY:Y,anchored:E}=he(d,m,x,s,c,e.waferOpts?.center);let D=e.waferOpts?.diameter;const y=d.map(l=>({x:(Math.round(l.x)-m)*s-R,y:(Math.round(l.y)-x)*c-Y})),C=y.length>0?Math.max(...y.map(({x:l,y:M})=>Math.hypot(Math.abs(l)+s/2,Math.abs(M)+c/2))):0;if(D===void 0)if(d.length>0)if(p==="mm"){const l=se(y,{minRadius:C});D=l.diameter,i.wafer={confidence:l.confidence,method:l.method}}else D=C*2,i.wafer={confidence:a.confidence*.8,method:"extent"};else D=p==="mm"?300:30,i.wafer={confidence:0,method:"default"};if(!E&&d.length>0&&pe(d,m,x)&&(i.wafer.method="inferred-partial",(i.warnings??=[]).push("Wafer geometry was inferred from die positions alone. The data does not span a full symmetric wafer, so the inferred diameter and centre may be wrong and dies may be mis-positioned relative to the true wafer boundary. Supply waferConfig.diameter and waferConfig.center (the prober coordinate of the wafer centre) to position partial data correctly.")),e.waferOpts?.diameter!==void 0){const l=e.dieOpts?.width!==void 0&&e.dieOpts?.height!==void 0;if(l&&C>D/2+1e-9){const M=y.filter(({x:b,y:v})=>Math.hypot(Math.abs(b)+s/2,Math.abs(v)+c/2)>D/2+1e-9).length;(i.warnings??=[]).push(`${M} of ${y.length} probed die positions ${j} ${D} mm wafer at the supplied die pitch of ${s} \xD7 ${c} mm. A die with test results is a real prober position and is always fully on the wafer, so one of the two supplied values must be wrong: containing these dies at this pitch would need a diameter of at least ${(C*2).toFixed(1)} mm. Check waferConfig.diameter and dieConfig.width/height against the real device.`)}else l||(i.warnings??=[]).push(`${H} ${s.toFixed(3)} \xD7 ${c.toFixed(3)} mm by assuming the die grid fits within the ${D} mm wafer. The assumed aspect ratio may not match the true die shape whenever edge dies are absent from the data (a reticle-complete map, or partial dies filtered out upstream). Supply dieConfig.width and dieConfig.height \u2014 the die pitch, not the diameter, is what fixes placement.`)}const k=$({diameter:D,notch:e.waferOpts?.notch,orientation:e.waferOpts?.orientation??0,metadata:e.waferOpts?.metadata}),Me={width:s,height:c};let w=f.map(l=>{const M=Math.round(l.x)-m,b=Math.round(l.y)-x,v={id:`${M}_${b}`,x:M,y:b,physX:M*s-R,physY:b*c-Y,width:s,height:c,insideWafer:!0,partial:!1};return G(v,l)});(m!==0||x!==0)&&(w=w.map(l=>({...l,x:l.x+m,y:l.y+x,id:`${l.x+m}_${l.y+x}`}))),w=A(w,k),(O||S)&&(w=Z(w,{flipX:O,flipY:S},k.center)),e.waferOpts?.edgeExclusion&&e.waferOpts.edgeExclusion>0&&(w=ge(w,k,e.waferOpts.edgeExclusion));const B=_(e.reticleOpts,k,w,s,c,m,x,R,Y,k.orientation,O,S),U=r.showReticle??e.reticleOpts!==void 0,F=T(k,w,{...r,reticles:B,showReticle:U,plotMode:K(f,r),testDefs:e.testDefs,dataAxisFlip:{x:O,y:S},isLotStack:e.lotStackOpts!==void 0,aggregationMethod:e.lotStackOpts?.method,lotSize:e.lotStackOpts?.results.length},{hbinDefs:e.hbinDefs,sbinDefs:e.sbinDefs,metadataFields:e.metadataFields});return{wafer:k,dies:w,view:F,reticleConfig:e.reticleOpts,units:p,inference:i,warnings:z(i),plotMode:F.plotMode,metadata:F.metadata,isLotStack:e.lotStackOpts!==void 0,dataCoverage:W(w),yield:N(w,e.passBins,e.edgeDieYieldMode),reticles:B,hbinDefs:e.hbinDefs,sbinDefs:e.sbinDefs,testDefs:e.testDefs,metadataFields:e.metadataFields,aggrMethod:F.aggrMethod,lotSize:F.lotSize}}

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

@@ -0,0 +1,46 @@
+/**
+ * Spec pass/fail die colours, shared by the value-map renderer and the spec legend so both use one
+ * definition. Pass = green, fail-low (below limitLow) = blue, fail-high (above limitHigh) = red.
+ */
+export declare const SPEC_PASS_FILL = "#2ecc71";
+export declare const SPEC_FAIL_LOW = "#3498db";
+export declare const SPEC_FAIL_HIGH = "#e74c3c";
+/**
+ * Shared categorical palette for hard and soft bin colouring.
+ * Index 0 is the no-data grey sentinel. Indices 1–63 are perceptually
+ * spread colours generated via golden-angle HSL stepping.
+ * Hard and soft bins use different hash salts so the same bin number
+ * maps to different colours in each scheme.
+ */
+export declare const BIN_PALETTE: readonly string[];
+/** Wang hash — maps any integer to a well-distributed unsigned 32-bit value. Shared with colorSchemes. */
+export declare function wangHash(n: number): number;
+/** Categorical colour for a hard bin. No-data handling is the caller's responsibility. */
+export declare function hardBinColor(bin: number): string;
+/** Linear interpolation across RGB keypoints for t ∈ [0, 1]. */
+export declare function lerpKp(kp: readonly [number, number, number][], t: number): string;
+export declare const VIRIDIS: readonly [number, number, number][];
+/** Map t ∈ [0, 1] to a Viridis RGB colour string. */
+export declare function valueToViridis(t: number): string;
+/** Categorical colour for a soft bin. No-data handling is the caller's responsibility. */
+export declare function softBinColor(bin: number): string;
+/**
+ * Categorical colour for the `index`-th distinct value of an active
+ * `'metadata'` field, where `index` comes from sorting the field's distinct
+ * values alphabetically (deterministic — never dependent on die array
+ * iteration order). Ordered assignment, not hashing, for the first
+ * `METADATA_PALETTE.length` slots — this maximizes distinctness for the
+ * common case of a handful of categories, unlike a hash which doesn't
+ * optimize for a *known* small set. Falls back to the same
+ * hash+`BIN_PALETTE` mechanism `hardBinColor`/`softBinColor` use (a new
+ * salt) for wafers with an unusually large category count.
+ */
+export declare function metadataValueColor(index: number): string;
+/** Categorical greyscale shades for hard bins. Index 0 = no data. */
+export declare const HARD_BIN_GREY: readonly string[];
+export declare function hardBinGreyscale(bin: number): string;
+/** Map t ∈ [0, 1] to a greyscale rgb string (range 30–230 to avoid pure black/white). */
+export declare function valueToGreyscale(t: number): string;
+/** Return '#000000' or '#ffffff' for maximum contrast against the given colour. */
+export declare function contrastTextColor(cssColor: string): '#000000' | '#ffffff';
+//# sourceMappingURL=colorMap.d.ts.map

package/dist/packages/renderer/colorMap.js

@@ -0,0 +1 @@
+import{clamp01 as f}from"../core/utils.js";export const SPEC_PASS_FILL="#2ecc71",SPEC_FAIL_LOW="#3498db",SPEC_FAIL_HIGH="#e74c3c",BIN_PALETTE=["#95a5a6","#1eb84b","#932cdd","#b8a51e","#2cbfdd","#b81e71","#58dd2c","#251eb8","#dd672c","#1eb87f","#ce2cdd","#98b81e","#2c84dd","#b81e3e","#2cdd3b","#581eb8","#dda22c","#1eb8b2","#dd2cb0","#64b81e","#2c49dd","#b8321e","#2cdd76","#8c1eb8","#dcdd2c","#1e8bb8","#dd2c75","#31b81e","#4b2cdd","#b8651e","#2cddb1","#b81eb1","#a1dd2c","#1e57b8","#dd2c3a","#1eb83f","#852cdd","#b8991e","#2ccddd","#b81e7e","#66dd2c","#1e24b8","#dd5a2c","#1eb872","#c02cdd","#a4b81e","#2c92dd","#b81e4a","#2cdd2e","#4c1eb8","#dd942c","#1eb8a6","#dd2cbe","#70b81e","#2c57dd","#b8261e","#2cdd69","#801eb8","#ddcf2c","#1e97b8","#dd2c83","#3db81e","#3d2cdd","#b8591e"];export function wangHash(e){let c=e|0;return c=Math.imul(c^c>>>16,73244475),c=Math.imul(c^c>>>16,73244475),(c^c>>>16)>>>0}const s=BIN_PALETTE.length-1,i=2654435769,h=1818371886,x={1:"#2ecc71",2:"#e74c3c",3:"#f39c12",4:"#9b59b6",5:"#3498db",6:"#1abc9c",7:"#e67e22",8:"#2c3e50",9:"#c0392b",10:"#8e44ad",11:"#2980b9",12:"#27ae60",13:"#d35400",14:"#16a085"};export function hardBinColor(e){return x[e]??BIN_PALETTE[wangHash(e^i)%s+1]}export function lerpKp(e,c){const b=f(c)*(e.length-1),t=Math.floor(b),d=Math.min(t+1,e.length-1),a=b-t,n=Math.round(e[t][0]+a*(e[d][0]-e[t][0])),o=Math.round(e[t][1]+a*(e[d][1]-e[t][1])),l=Math.round(e[t][2]+a*(e[d][2]-e[t][2]));return`rgb(${n},${o},${l})`}export const VIRIDIS=[[68,1,84],[59,82,139],[33,145,140],[94,201,98],[253,231,37]];export function valueToViridis(e){return lerpKp(VIRIDIS,e)}export function softBinColor(e){return BIN_PALETTE[wangHash(e^h)%s+1]}const u=["#4e79a7","#f28e2b","#e15759","#76b7b2","#59a14f","#edc948","#b07aa1","#ff9da7","#9c755f","#bab0ac"],A=668265263;export function metadataValueColor(e){return e<u.length?u[e]:BIN_PALETTE[wangHash(e^A)%s+1]}export const HARD_BIN_GREY=["#aaaaaa","#f7f7f7","#303030","#888888","#bbbbbb","#666666","#999999","#555555","#444444","#222222","#cccccc","#777777","#eeeeee","#333333","#888888"];export function hardBinGreyscale(e){return HARD_BIN_GREY[Math.max(0,Math.min(e,HARD_BIN_GREY.length-1))]}export function valueToGreyscale(e){const c=Math.round(f(e)*200+30);return`rgb(${c},${c},${c})`}export function contrastTextColor(e){let c=0,r=0,b=0;const t=e.match(/rgb\((\d+),\s*(\d+),\s*(\d+)\)/);if(t)c=+t[1],r=+t[2],b=+t[3];else{const n=e.replace("#","");c=parseInt(n.slice(0,2),16),r=parseInt(n.slice(2,4),16),b=parseInt(n.slice(4,6),16)}const d=n=>{const o=n/255;return o<=.03928?o/12.92:((o+.055)/1.055)**2.4};return .2126*d(c)+.7152*d(r)+.0722*d(b)>.179?"#000000":"#ffffff"}

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

@@ -0,0 +1,40 @@
+export interface ColorScheme {
+    /** Human-readable display name */
+    label: string;
+    /**
+     * Return a CSS colour string for a categorical bin number.
+     * Index 0 conventionally means "no data / unknown".
+     */
+    forBin: (bin: number) => string;
+    /**
+     * Return a CSS colour string for a continuous value t ∈ [0, 1].
+     * Values are pre-normalized by buildView before this is called.
+     */
+    forValue: (t: number) => string;
+}
+/**
+ * Register a named colour scheme, making it available to buildView via the
+ * colorScheme option.  Call this once at app startup before rendering.
+ *
+ * `forBin` and `forValue` must return valid CSS color strings — invalid values
+ * produce silent rendering artifacts (blank or black rectangles).
+ *
+ * @example
+ * registerColorScheme('my-brand', {
+ *   label: 'My Brand',
+ *   forBin: (bin) => MY_BRAND_BINS[bin] ?? '#ccc',
+ *   forValue: (t) => `hsl(${200 + t * 60}, 70%, ${30 + t * 40}%)`,
+ * });
+ */
+export declare function registerColorScheme(name: string, scheme: ColorScheme): void;
+/**
+ * Retrieve a registered scheme by name.  Falls back to 'default' if the name
+ * is not found, so callers never receive undefined.
+ */
+export declare function getColorScheme(name?: string): ColorScheme;
+/** Return all registered schemes as { name, label } pairs, in insertion order. */
+export declare function listColorSchemes(): Array<{
+    name: string;
+    label: string;
+}>;
+//# sourceMappingURL=colorSchemes.d.ts.map