@wafertools/wafermap 0.30.2 → 0.30.4

package/AGENTS.md

@@ -122,10 +122,21 @@ reporting, not a pattern to build on.
 - **The analysis surfaces are already built — do not reimplement them.** Pass
   `statsSummary` to `renderWaferMap` and it mounts the Summary panel; pass
   `insights: { enabled: true }` and it mounts the chart suite (yield, bin pareto,
-  boxplot, histogram, correlation, scatter, capability). `renderWaferGallery` takes the
-  same option across a whole lot. Supply or replace the analysis later with
-  `setStatsSummary()`. Hand-building those charts is what the deprecated chart-data
-  builders were for, and they go in 0.31.0.
+  boxplot, histogram, correlation, scatter, capability, and one card per
+  `insights.sweeps` entry). `renderWaferGallery` takes the same option across a whole
+  lot. Supply or replace the analysis later with `setStatsSummary()`. Hand-building
+  those charts is what the deprecated chart-data builders were for, and they go in
+  0.31.0. Charting a selection or one wafer (right-click → histogram, capability,
+  sweeps) is built in too, with no wiring.
+- **A value computed from other tests is a derived test, not a host-side column.** Pass
+  `derivedTests` (a `TestDef` plus an `expression`, e.g. `'abs(t[1020] - t[1010])'`) to
+  `buildWaferMap`; it then behaves as a measured test everywhere, marked `†` as not
+  measured. Computing it in the host and injecting it into `testValues` loses that
+  mark, the missing-input rule (absent, never 0) and the collision check. A boolean
+  expression must be declared `testType: 'F'`.
+- **A sweep's x values are data, not guesses.** Give `xValues`, or `xFromName` (a
+  `{x}` placeholder pattern, not a regex) when the swept value is only in the test
+  name. Never derive x from test numbers: they are identifiers, not a scale.
 - **Click-to-highlight is wired, not hand-rolled.** `onSelect` reports what the user
   picked; `setSelection(dies)` / `clearSelection()` drive it from your own UI — for
   example from a finding, whose `dieKeys` match `getDieKey(die)` exactly.
@@ -240,7 +251,7 @@ compatibility shims for them.
 - [API reference](https://wafertools.github.io/wafermap/api/) — every type, option and return value
 - [Developer guide](https://wafertools.github.io/wafermap/guide/) — worked walkthroughs
 - [Troubleshooting](https://wafertools.github.io/wafermap/troubleshooting/)
-- [Examples](https://wafertools.github.io/wafermap/examples/) — 20 runnable pages, also
+- [Examples](https://wafertools.github.io/wafermap/examples/) — 22 runnable pages, also
   [downloadable](https://wafertools.github.io/wafermap/wafermap-examples.zip) to run offline
 
 When a rule here and the API reference disagree, the API reference wins — tell the

package/CHANGELOG.md

@@ -22,6 +22,438 @@ under `### Breaking`.
 
 ---
 
+## [Unreleased]
+
+## [0.30.4] — 2026-09-25
+
+### Added
+
+- **`input-values-outside-stdf` warning** from `buildWaferMap`: bins, coordinates, test
+  numbers or site numbers outside the STDF V4 ranges, test values that are not finite, and a
+  `waferConfig.orientation` other than 0, 90, 180 or 270. The values are used as given; a
+  future release treats them as missing.
+- **`DieResult.supersedes`** (`'partId' | 'position'`): the tester marked the record as
+  replacing an earlier one. Such a record always wins, whatever `retestPolicy` says.
+- **Retests of dies with no position are matched by part ID** within a wafer, resolved by
+  `retestPolicy` and reported with an `info` warning, `retests-by-part-id`. Blank part IDs
+  never match, and part IDs are not used on a wafer where one value covers more than 20% of
+  the unpositioned records.
+- **`TestDef.specLow` / `TestDef.specHigh`**: a test's spec limits, separate from its test
+  limits (`limitLow`/`limitHigh`), as STDF records them. Process capability uses the spec
+  limits when both are given and the test limits otherwise, and reports which as
+  `TestCapability.limitBasis`. Wafers that disagree on a test's spec limits raise a
+  `specLimits` test-definition conflict.
+- **Sweeps tab notice for sweeps that name no test in the data**, and
+  **`InsightsOptions.onRemoveSweeps`**, which adds a Remove button to it. The sweep's own card
+  says the same in place of an empty chart.
+- **`TestDef.limitLowInclusive` / `TestDef.limitHighInclusive`**: whether a value exactly
+  equal to a test limit passes (default `true`), as STDF and ATDF state per test. Every
+  pass/fail judgement, yield and out-of-limit marker honours them. Wafers that disagree on
+  them raise a `limits` test-definition conflict.
+
+### Changed
+
+- **`DieResult.partId` and `Die.partId` accept text** (`number | string`), as STDF defines
+  part IDs; a number is still accepted.
+- **Scatter chart legend:** hard bin 0 has its own entry and colour, and dies without a bin
+  are listed last as "No bin data".
+- **A `NaN` bin is no bin**: it is neither a bin number nor a fail, and is counted in the new
+  warning.
+- **One spec-limit judgement** (`classifySpec`) serves every surface, including the per-test
+  spec yield, lot-stack fail filtering, regional spec-fail findings and the Summary panel.
+  A value that is not a finite number has no verdict everywhere, rather than counting as a
+  pass on some surfaces.
+- **Bin colours** for a bin that is not a whole number are taken from the whole bin below it.
+- **Test limits and spec limits are labelled apart.** `limitLow`/`limitHigh` are test limits,
+  labelled "Lo limit"/"Hi limit" on charts; LSL/USL appear only where a test's spec limits
+  are shown. The pass/fail option is "Limit pass/fail", the Summary panel's yield column is
+  "Limit yield", and the capability chart, tooltip and report name the limits each test was
+  judged against.
+
+## [0.30.3] — 2026-09-23
+
+### Added
+
+- **Sweep x values from test names, an x unit, and a log x axis.** For a
+  program that records the swept quantity only in the test text — a
+  resistance CDF named `Normalized_LRS= LRS_STATS_12K / …`, one test per
+  threshold:
+  - `SweepSeriesSpec.xFromName` reads each test's x from its name with a
+    placeholder pattern, `"LRS_STATS_{x}"`: `{x}` reads a number with its SI
+    prefix (`12K` → 12,000; case-sensitive, `K` accepted as kilo; a letter is a
+    prefix only alone or before a unit, so `12Kangaroos` reads 12; in an all-capitals
+    name the unit's case is gone, so `5NS` is 5 ns and `2MV` — milli or mega? — is
+    reported, not guessed), `*` matches
+    anything, literal text matches in any case, anywhere in the name. Not a
+    regular expression: a sweeps file is shared, and JavaScript cannot
+    interrupt a runaway regex, whereas this matcher's cost is bounded whatever
+    the pattern (`stats/sweepXFromName.ts`). Each x stays attached to its own
+    test, so a missing test loses one point instead of shifting the rest.
+  - `SweepSpec.xUnit` prints the x axis, crossing and widths SI-prefixed
+    (`47.3 kΩ`), trailing zeros dropped (`2 kΩ`, not `2.00 kΩ`).
+  - `SweepSpec.xScale: 'log'` places x on a log axis; the crossing is
+    interpolated along log x and a width is reported as a ratio with both ends
+    (`×2.49 (15.9 kΩ → 39.7 kΩ)`), via new `SweepSeparation.ratio`/`from`/`to`.
+    `SweepData.xScale` is the axis actually drawn: a non-positive x keeps it
+    linear, with a warning.
+  - Reported, never guessed, and then not measured: a name the pattern does not
+    fit, a series giving both `xValues` and `xFromName`, and — for every x
+    source — a series that revisits an x value, which the crossing previously
+    mis-paired silently.
+
+- **Drilldown: chart a selection or a wafer.** Right-click a population for a
+  menu of charts drawn from just those dies, opened in the same modal as an
+  expanded Insights card:
+  - **Populations:** the dies selected on a map (a single map or any gallery
+    card); a whole wafer, from empty map space with nothing selected, from a
+    gallery card anywhere outside its map, or from one wafer's bar, box or point
+    in *Yield by wafer*, *Test value distribution* or *Wafer-to-wafer trend* in
+    Insights (their tooltips say "right-click to chart this wafer"). The Menu
+    key, Shift+F10 and a new map toolbar **Chart** button (the selection if
+    there is one, else the wafer) reach the same menu without a mouse.
+  - **Charts:** value histogram (opening on the test the map shows), process
+    capability, and the sweeps defined in `insights.sweeps` — the gallery now
+    passes those to each card, and a single map offers them whether or not
+    `insights.enabled` is set.
+  - **Population stated on every chart**, in the modal title and on the card
+    ("12 dies selected on W03", "10 of 12 … (partial and edge-excluded dies left
+    out)"). Capability below 30 dies adds that each Ppk is a rough estimate.
+    Charts are snapshots: changing the selection afterwards does not change them.
+    The wafer is named by the item's `label`, else its `metadata.waferId` — never a
+    positional "Wafer 3 (no ID)" — on the map, the gallery and Insights alike.
+  - **The library decides what is offered:** a chart that cannot be drawn stays
+    listed, greyed, with the reason (no values for its tests; fewer than two
+    dies for capability; a lot-stack map, whose dies are per-position aggregates
+    rather than measured dies). Right-clicking an unselected die selects it
+    first. A map with no parametric tests and no sweeps leaves right-click to
+    the browser or host, and the map canvas owns right-click on itself: one it
+    declines (the bin legend) never reaches a gallery card or host handler.
+  - Documented in api.md §5.12, the user guide §4.4 (with screenshots from
+    `capture-definitions.mjs`) and the developer guide.
+  - Built on one source/target mechanism (`canvas-adapter/chartPopulation.ts`
+    builds the populations, `drilldown.ts` the menu and charts, loaded on first
+    use and pinned by `tests/bundle-size.test.mjs`), so a further population or
+    chart is one more of either rather than a menu per pairing.
+
+- **Derived tests** — `WaferMapInput.derivedTests`: tests computed from other tests
+  on the same die, rather than measured. Each entry is a `TestDef` plus an
+  `expression`, and from the build onwards it is an ordinary test — it appears in
+  `result.testDefs`, in the value plot modes, the colorbar, tooltips,
+  `analyzeWaferMap`, Insights and the report, with no other change required.
+
+  ```ts
+  derivedTests: [
+    { testNumber: 900001, name: 'Leakage Shift', unit: 'uA',
+      expression: 'abs(t[1020] - t[1010])', limitHigh: 5 },
+    { testNumber: 900002, name: 'Sweep All Pass', testType: 'F',
+      expression: 'all(testPass[1010..1025])' },
+  ]
+  ```
+
+  Expressions read `t[n]` (measured value), `testPass[n]` (the tester's recorded
+  verdict), `specPass[n]` (spec-limit judgement) and `diePass()` (the die's bin
+  verdict) — the same `'test'`/`'spec'` distinction `passFailDisplay` already
+  draws, because they are different questions and a single accessor would have
+  silently meant "recorded verdict" for parametric data that has none. A range
+  (`t[1010..1015]`) yields a set that must be reduced by `mean`, `sum`, `min`,
+  `max`, `all`, `any`, `none`, `countTrue`, `countFalse` or `countKnown`; there is
+  no vector arithmetic, which is what stops the grammar becoming an array
+  language. Operators `+ - * / % ^`, comparisons, `and`/`or`/`not`, and
+  `if(cond, a, b)`.
+
+  Parsed to a typed tree at build time and walked per die — **no `eval`, no
+  `Function`, no third-party expression engine, and no way to name a host
+  object** — so a chart spec can be shared between teams as plain JSON. This is
+  why the root bundle grows ~5 KB gzip.
+
+  Evaluated on raw probe records **before** lot stacking and retest resolution, so
+  every derived value comes from one real touchdown: deriving after a stack would
+  subtract one aggregate from another, and deriving after retest collapse could mix
+  a value from one touchdown with a verdict from another.
+
+  A boolean expression is a verdict — declare `testType: 'F'` and the result lands
+  in `die.testPass`, never as a 1/0 in `testValues` where it would enter the
+  correlation matrix and the Cpk table. An unknown input yields an **absent** value
+  (no-data grey), never `0` and never `false`.
+
+  Everything statically knowable is checked at build and reported as a
+  `derived-test-invalid` warning naming the position — a parse or type error, a
+  `testNumber` colliding with measured data, a `testType` that disagrees with the
+  expression, `t[n]` on a functional test, `specPass[n]` on a test with no limits.
+  A rejected derived test is **dropped**, never half-applied.
+
+- **Parametric sweeps** — `insights.sweeps` on `renderWaferMap`/`renderWaferGallery`:
+  an ordered run of tests read as a response curve rather than as independent
+  tests, with the crossing point of the first two series and the horizontal
+  separation at named levels measured and stated. `xValues` supplies the real
+  swept quantity so the crossing is reported in physical units; without it the
+  axis is the ordinal position, because test numbers are identifiers and are not
+  guaranteed to be evenly spaced. Each line is the population median with a
+  p10–p90 band. A multiple crossing says so; a level neither curve reaches reads
+  "not measurable" naming the series, never `0`.
+- **Test ranges in a sweep's `tests`** — an entry may be `"1010..1030"`, the exact
+  syntax of a derived-test expression's `t[1010..1030]` and parsed by the same code
+  (`parseTestReference`), so the same text always names the same tests. A range
+  expands to the declared tests inside it, ascending — a program numbered in steps
+  of 2 needs no step syntax. `xValues` is checked against the expanded list: when
+  a test is missing from a range, the footer lists what the range matched and the
+  card is drawn in test order with the crossing and widths **not measured**
+  (`SweepData.notMeasured`), rather than sliding every later x value onto the
+  wrong test. The same now applies when only some series carry `xValues`, which
+  before put physical and ordinal x positions on one axis and reported an ordinal
+  crossing under the physical x label. A range resolves by filtering the declared
+  tests rather than counting through every integer, so `0..2000000000` in a shared
+  template is not a two-billion-step loop — in expressions too.
+- **Nested derived tests** — a derived test may read another. Compilation
+  topologically sorts by what each expression reads, so declaration order does
+  not matter; cycles, self-references and dependents of a rejected test are
+  dropped with the cause named.
+- New example: **Derived tests and sweeps** (`docs/examples/derived-tests.html`).
+- **Sweeps have their own Insights sub-tab**, shown only when `insights.sweeps`
+  defines at least one; `InsightsView` gains `'sweeps'` for `defaultView`, which
+  falls back to `'overview'` when there are none. Not an option and not a count
+  threshold: a threshold would move a sweep between tabs the day a colleague
+  added another, and an option would be a layout flag with one right answer.
+  They never belonged in Distributions either — that view is driven by one
+  selected test (capability → boxplot → histogram → trend), while a sweep draws
+  many tests as one curve and ignores the selection.
+- New example: **Parametric sweeps** (`docs/examples/sweeps.html`) — four
+  characterisation sweeps in the Sweeps tab, each a different use of the
+  crossing and the width: the temperature-inversion voltage (Fmax vs VDD at
+  25/125 °C, with the iso-frequency VDD gap at two speeds), DIBL from an NMOS
+  transfer curve at two drain biases, the retention bake at which the read
+  window closes (uneven read times, which is what `xValues` is for), and an
+  output driver's maximum drive current (VOH vs VOL under load). The transfer
+  curve is swept over **derived** `log10(t[n])` tests — a sweep reads any test,
+  which is how a log-scale curve is drawn without a log option.
+- **Derived tests are marked on the sweep card**: `SweepPoint` carries `derived`
+  and `expression`, ordinal tick labels keep the `†` in front of a truncated name, the
+  tooltip marks each series row and adds each expression, and the footer shows
+  the key.
+- **Sweep card text.** The crossing line lower-cased the y label ("Cell Vt"
+  became "cell vt", "Fmax" became "fmax") — the width line had already been
+  fixed for the same reason ("dBm" → "dbm"); widths printed in engineering
+  notation (`32.7E-3`); and an x label carrying its own unit doubled the
+  brackets (`(VDD (V))`). X values — ticks, crossing and widths — now share one
+  plain-decimal rule, and a width reads "0.0327 on the VDD (V) axis".
+- The derived-tests example opened on a Switching Window measured at the step
+  where its two curves cross, so the gap sat around zero against `limitLow: 0`
+  and nearly every die carried a ▽. It is now measured at a fixed read step
+  with a 0.33 V margin, so only an edge band fails.
+- **A derived test is now identifiable from `result.testDefs` alone.** `derived`
+  was declared only on the `DerivedTestDef` *input* type, while `result.testDefs`
+  is a homogeneous `TestDef[]` — so every display surface needed a cast to ask
+  whether a value was measured or derived, and `expression`/`constants` were
+  stripped off the admitted def entirely, leaving nothing to say where a number
+  came from. All three now travel on `TestDef` as `readonly` fields set by
+  `buildWaferMap`. This is the prerequisite for marking derived tests in the UI:
+  a display that cannot ask the question cannot mark it, and an engineer reading a
+  Cpk table should never be left to assume a number came off the tester. The
+  alternative — hosts holding their own `derivedTests` input beside the result and
+  joining by test number — is a second source of truth that can disagree with the
+  def actually admitted, which carries the resolved `testType`.
+- **`testLabel` / `isDerivedTest` / `derivedTestSource` / `hasDerivedTests`**
+  (`renderer/testLabel.ts`, internal) — one definition of how a test is named and
+  how a derived one is distinguished. The "name, or *Test N* when it has none"
+  fallback existed in six places (`stats/sweep.ts`, `capability.ts`, `testPassRate.ts`,
+  `analyzeWaferMap.ts`, `charts/chartShell.ts`), all now routed through it. Around
+  sixteen surfaces display a test name; a marker added per surface would have been
+  that rule twenty-odd times over, which is how two of them end up disagreeing.
+- **Derived tests are marked in the process capability panel.** A `†` precedes
+  the test name, the legend gains the key "† Derived, not measured", and the
+  tooltip says the same in words and shows the expression the value was
+  computed from. A dagger, not `ƒ`: in this domain `f` reads as femto,
+  and a `ƒ` beside `fA`/`fF` units is a real misread.
+  `TestCapability`/`CapabilityDatum` gain `derived` and `expression`.
+- **…and everywhere else a test is named, always in front of the name.** In a
+  list the marks then form a column down the left edge, so a derived test is found
+  at a glance, and truncating a long name can never cut the mark off; a list
+  holding a derived test pads its measured names by the mark's width so names stay
+  aligned, and a list without one is unchanged. The map title and colorbar
+  (`† Leak Shift (nA)`)
+  with the key on its own line beneath, drawn via a new optional
+  `MapTitleParts.note`; the map tooltip, which adds the key and the expression;
+  finding labels and sentences, marked at the source so no reader of a finding
+  can show it unmarked, with `StatsFinding.variable.derived`/`expression` as the
+  structured form; `stats.functionalYield[].label` (plus `derived`/`expression`);
+  the Summary panel's parametric and functional tables and its findings list,
+  each with a key line naming every expression; and both HTML reports, whose key
+  lists the expressions because a printed report has no hover. CSV exports carry
+  plain names plus a trailing **Derived from** column, only when a row is
+  derived — a CSV has nowhere to put a key. The key is a single short string,
+  *Derived, not measured*, so it fits the corner of a map and cannot drift
+  between surfaces. Every surface goes through `renderer/testLabel.ts`, which
+  also replaced two more hand-written *Test N* fallbacks in `buildView.ts` and
+  one in the gallery's stacked cards, whose synthetic def now keeps the flag.
+  The finding tooltip now has one rule, `formatFindingTooltip`, which the
+  Summary panel shares with both reports instead of using `summary` directly.
+  The places a test is *chosen* are marked too: the plot-mode test menu (a slot
+  in front of each name, reserved only when a derived test is listed, and a key
+  line at the foot), the Insights test pickers (`testOptionLabels`), the
+  correlation matrix's axis labels and tooltip (key on its hint line; its CSV
+  gains per-side *derived from* columns) and the die list's column headers (key
+  line above the table; the CSV header states the expression). The last two
+  hand-written *Test N* fallbacks, in the plot-mode menu and the die list, now go
+  through `testLabel`.
+- **`DERIVED_MARK` and `DERIVED_KEY` are exported** (root and `/renderer`), so a
+  host listing tests in its own UI marks derived tests exactly as the library does
+  instead of keeping its own copy of the glyph and the words. tsmap's test selector
+  is the first use.
+- Getting there turned up two places that dropped the flag. **`mergeTestDefs`**,
+  which builds a gallery's single test list, rebuilt each def field by field and
+  never named `derived`, so every cross-wafer panel would have shown a derived
+  test unmarked while the single-wafer view marked it. It now carries `derived`
+  and `expression`, marking a test derived when **any** wafer says so: marking
+  a measured test is an oddity someone queries, while leaving a derived one
+  unmarked goes unnoticed. The Summary panel's per-test table narrowed defs the
+  same way and now keeps both fields. It also held a seventh copy of the
+  *Test N* fallback, now routed through `testLabel`.
+
+### Changed
+
+- **Docs and examples brought up to date with this release.** The developer
+  guide's sweep section no longer says `tests` has no range syntax or that a
+  sweep has no log option; it covers ranges, `xFromName`, `xUnit`, `xScale` and
+  drilldown. The sweeps example adds a fifth sweep (an RRAM resistance
+  distribution read from test names on a log axis) and gives the output-driver
+  sweep an x unit; the derived-tests example's sweep uses ranges and a real swept
+  quantity (pulse amplitude in volts) instead of ordinal steps, and places the †
+  in front of the name as everywhere else. The README, `AGENTS.md` and
+  `llms.txt` now mention derived tests, sweeps and drilldown.
+  Those two examples' code cards, a four-across grid that cut every code
+  block off at about half its width in 12 px type, now show one example per
+  row — the code whole, in monospace at 13.5 px, beside notes at 14.5 px,
+  stacked on narrow screens — from one shared style in `demo.css`. `--mono`,
+  which every example's code referenced and nothing defined, is now set.
+  The derived-tests example is now in two labelled parts — derived tests are
+  *data* (`buildWaferMap`'s `derivedTests`; tsmap's test-definitions file), a
+  sweep is a *chart* (the renderer's `insights.sweeps`; tsmap's separate sweeps
+  file) — because a run of look-alike snippets read as one list. Its snippets
+  show the whole call each belongs to, it says the sweep is in Insights →
+  Sweeps, with a *Show the sweep* button that presses the gallery's own Insights
+  button, and it links to the sweeps example. The sweeps example opens with
+  where its entries go.
+
+- **`scripts/check-bundle-size.mjs` attributes lazy chunks by what imports
+  them, not by file name.** Once drilldown and Insights shared the chart panels,
+  esbuild split the shared code into an anonymous `chunk-*.js`, which a file-name
+  test counted as core. That would have added ~5 KB of lazy code to the "always
+  downloaded" figure. The guide, Insights and drilldown now count as their own
+  static closure minus what the entry already loads. The Insights figure now
+  includes the chart code it shares with drilldown, because opening Insights
+  downloads it.
+- **Axis ticks sit on round values, and are labelled to their spacing.** Tick
+  labels used to take their decimals from each value's own size, never from the
+  gap between ticks, so a 1–10 axis read "2.00 4.00 6.00 8.00" and a bandgap's
+  1.195–1.205 V read "1.20" five times — a sloped curve labelled as a flat line.
+  And only the colorbar placed ticks on round numbers: the box plot, scatter,
+  trend and sweep divided the data range into equal fractions (2.54 / 2.04 /
+  1.53 GHz), the histogram labelled its bucket edges, and its count axis carried
+  an inline copy of the rounding rule with different breakpoints. Every numeric
+  axis now goes through `renderer/axisTicks.ts` — one 1-2-5 rounding rule
+  (`niceStep`), round ticks inside the data range, and labels with exactly the
+  decimals the step needs (`stepDecimals`): "2 4 6 8", "1.196 1.198 1.200".
+  **Density comes from the space, not a tick count:** `fitTicks` takes the
+  finest round step whose labels fit — measured label widths plus an 8 px gap
+  on a horizontal axis, a line spacing on a vertical one. A fixed count, tried
+  first, rounded a 200 px Idsat box plot (0.863–1.56 mA) to 1.0 / 1.2 / 1.4 —
+  fewer ticks than the five it replaced; it now reads 0.9 / 1.0 / … / 1.5. The colorbar's exact min and max are data values rather than grid
+  values, so they get one decimal more, dropped when it is a zero — a 9.87
+  maximum no longer rounds to "10". Log-scale and integer-valued colorbars, die
+  labels and limit labels keep size-based formatting; they are not tick grids.
+  Every chart's tick labels change, so doc screenshots need recapturing.
+- **The wafer and lot reports' findings table now uses plain bin terms**
+  ("hard bin 2", not "HBin 2"). Both HTML reports render one findings table,
+  `findingsTableHtml`; each report module had kept its own, and only the
+  findings-only report translated the bin terms.
+
+### Deprecated
+
+- **`renderFindingsReportHtml`** — removed in 0.31.0. Use
+  `renderWaferReportHtml(result, summary)` or `renderLotReportHtml(results)`:
+  their Findings section is the same table, alongside the population and yield
+  it was found in. It was kept in 0.30.1 on the grounds that the Summary panel
+  used it, which had not been true since 0.20.0; nothing in wmap or tsmap calls
+  it. It ships deprecated in this release, so it goes in 0.31.0 with the 0.30.0
+  deprecations. `deprecated()` now takes a removal version per name, for a name
+  deprecated too late to go with the rest.
+
+### Fixed
+
+- **A menu row's hint is no longer drawn under its own menu.** Menus sit in a
+  dedicated layer (`menuLayerFor`) that outranks everything else in its root,
+  and the shared tooltip was placed beside that layer — so the reason on a
+  greyed-out row (the drilldown menu's, the Overlays menu's) appeared behind the
+  menu it explained. `positionTooltip` now places the tooltip inside the
+  anchor's menu layer at `Z_ABOVE2`, above every menu there, still resolved per
+  root (a host `<dialog>`, a wmap modal).
+
+- **The map's hover tooltip no longer jumps away from the die.** The shared
+  tooltip steps clear of its anchor when the anchor is under 40% of the window
+  tall — right for a toolbar button, which its tip must not cover, and wrong
+  for the map canvas, where the pointer is on the die the tip describes. Every
+  map that small (every gallery card, the smaller maps on a page such as the
+  geometry example, any map in a tall window) had its tip thrown below or above
+  the whole canvas, measured at up to 266 px from the pointer. The map now
+  passes `followPointer` to `positionTooltip` and the tip stays beside the
+  pointer; control tips keep stepping around their buttons.
+
+- **An expanded chart grows into its modal, in the direction that suits it.**
+  Several cards kept their grid-card size inside the expand modal: the trend
+  and sweep plots stayed a few hundred pixels tall, ring and quadrant yield
+  kept a fixed-size circle, the correlation matrix kept small cells, process
+  capability stopped at ~160 px per test, and row charts (yield by wafer,
+  pareto, pass rate, value distribution) left most of a 700 px box empty. Each
+  card now declares how it grows (`setChartGrow`): **plots** fill width and
+  height in a wider box; **row charts** keep bars full-width, show every row the
+  box has room for, and the box opens sized to its rows (within the viewport);
+  **square** charts grow to the shorter side in a square box. Capability's
+  columns spread across the width while each box keeps its grid maximum width.
+  Growth past the grid size happens only while expanded, so the Insights grid
+  is unchanged; maximise/restore and drag-resize shrink back correctly.
+- **Chart cards measure their chrome, not their stretch.**
+  `growCardToFitContent` took the card's overhead as `card height − body
+  height`, which counts any stretch as overhead and grows the card on every
+  redraw — why several panels opted out of stretching (`alignSelf: 'start'`),
+  which is what kept them small in the modal. It now sums the card's other
+  children, so a stretched card is harmless. Trend and sweep no longer ask for
+  the height they were given as their minimum, which would have stopped a
+  shrinking modal.
+- **Chart tooltips wrap inside their background.** They were `nowrap` under a
+  280 px cap, so a longer line — a sweep row with its p10–p90 and n, a derived
+  test's expression — ran out past the dark box. They now wrap within 320 px,
+  breaking an unbroken expression if they must. The sweep tooltip puts each
+  series' spread and n on a line of their own under its median.
+
+- **A functional-test finding merged across adjacent regions reported no
+  difference, and hid the real one.** Since 0.20.3, when a functional pass-rate
+  signal spanned adjacent rings, sectors or quadrants, the merge pass that joins
+  them into one finding (`Rings 1–2`) had no functional branch and fell through
+  to the bin one. It counted dies whose hard bin equalled `variable.bin` — which
+  a functional finding does not have — so both sides counted 0, and the merged
+  finding read *"Rings 1–2 has HBin undefined occurrence 0.0 percentage points
+  lower than the rest of the map"*, with a meaningless p-value. It also
+  **replaced** the correct per-region findings it merged, so a real functional
+  signal spanning adjacent regions was shown as no difference at all. The merge
+  now recomputes the pass rate over the merged region exactly as the per-region
+  builder does (verdicts through `getTestPassStatus`, dies without a verdict
+  excluded), and the sentence names the test. Found while testing the
+  derived-test marker, whose test wafer happened to have exactly this shape.
+- **Merged-region findings used a singular verb:** *"Rings 1–2 has HBin 3
+  occurrence…"*, *"Quadrants NE & SE has…"*. A merged region is plural; bin and
+  functional pass-rate sentences now say "have". The Summary panel, which strips
+  the region from a row shown under its own group header, accepts either verb.
+- **A `NaN` test value was classified as in-spec.** The spec-limit rule existed in
+  two places — `classifySpec` (die colouring, ▽/△ markers, the legend's spec tally)
+  and a private `specJudgement` in `stats/testPassRate.ts` (spec pass-rate tables) —
+  and they disagreed on two cases. `classifySpec` compared with `<` and `>`, which
+  are both false for `NaN`, so a non-finite measurement fell through to `'pass'`:
+  the exact "never drawn as plain in-spec" failure its own doc comment described.
+  It also reported `'pass'` for a test declaring no limits at all, inflating a spec
+  pass rate to 100% for every unlimited test. There is now one implementation
+  (`renderer/spec.ts`), strict on both, used by the renderer, stats and the
+  `specPass[n]` accessor.
+
 ## [0.30.2] — 2026-09-20
 
 ### Added

package/README.md

@@ -5,7 +5,7 @@
 [![CI and deploy](https://github.com/wafertools/wafermap/actions/workflows/deploy.yml/badge.svg)](https://github.com/wafertools/wafermap/actions/workflows/deploy.yml)
 [![npm](https://img.shields.io/npm/v/@wafertools/wafermap.svg)](https://www.npmjs.com/package/@wafertools/wafermap)
 ![runtime deps](https://img.shields.io/badge/runtime%20deps-0-brightgreen)
-![bundle](https://img.shields.io/badge/data%20layer%20min%2Bgz-~53%20kB-blue)
+![bundle](https://img.shields.io/badge/data%20layer%20min%2Bgz-~61%20kB-blue)
 [![license: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE)
 
 <img src="docs/images/hero-test-values.png" alt="wafermap demo" style="max-width:640px; display:block; margin:8px 0;" />
@@ -13,7 +13,7 @@
 Browser-first wafer map visualization for semiconductor test data.
 
 **Zero runtime dependencies.** Pure ES modules with TypeScript types — works in React,
-Svelte, Vue, plain HTML, or a Web Worker. The DOM-free data-and-stats layer is ~53 kB
+Svelte, Vue, plain HTML, or a Web Worker. The DOM-free data-and-stats layer is ~61 kB
 min+gz; the interactive renderer is larger, and its chart suite and in-app guide are
 loaded on demand rather than shipped up front — [measured sizes](docs/performance.md).
 
@@ -32,6 +32,9 @@ wafermap renders interactive wafer maps from semiconductor prober output. Hard b
 - `renderWaferMap` — interactive canvas map with toolbar, zoom/pan, tooltips, die selection, and summary panel
 - `renderWaferGallery` — lot-level card grid with shared controls and click-to-expand
 - Insights tab (`insights: { enabled: true }`) — an in-toolbar chart suite (yield, per-test pass rate, bin pareto, capability, boxplot, histogram, wafer-to-wafer trend, correlation, scatter) computed from the same wafer/lot data, for one wafer or the whole gallery
+- Derived tests (`derivedTests`) — tests computed per die from other tests (`abs(t[1020] - t[1010])`), which then work everywhere a measured test does, marked † as not measured
+- Parametric sweeps (`insights.sweeps`) — an ordered run of tests read as a response curve, with the crossing and widths between two curves measured; x values given directly or read from the test names, on a linear or log axis
+- Drilldown — right-click selected dies, a wafer card or a wafer's bar to chart just that population, with the population stated on the chart
 - `analyzeWaferMap` / `analyzeWaferLot` — spatial analysis across rings, quadrants, sectors, and reticle positions; failure cluster detection; lot trend series
 - Pure ES modules, no server, no runtime dependencies — works in React, Svelte, Vue, plain HTML, or a Web Worker
 
@@ -72,7 +75,7 @@ export. Add `analyzeWaferMap` for the findings and summary panel, swap in
 
 The API reference is long because it documents every option, not because you need
 them: [tsmap](https://github.com/wafertools/tsmap), a complete cross-platform desktop
-application built on this library, imports **15** of its ~100 exports. Read the
+application built on this library, imports **17** of its ~100 exports. Read the
 [Quick Start](https://wafertools.github.io/wafermap/quickstart/) first and treat the
 [API reference](https://wafertools.github.io/wafermap/api/) as something to search,
 not to read.

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

@@ -0,0 +1,48 @@
+import type { Die } from '../core/dies.js';
+import { type TestDef } from '../renderer/buildWaferMap.js';
+import type { SweepSpec } from '../stats/sweep.js';
+/** One wafer's share of a population. */
+export interface DrilldownItem {
+    /** The wafer's display label. */
+    label: string;
+    dies: Die[];
+    waferIndex?: number;
+}
+/** A population a chart can be opened on. */
+export interface DrilldownSource {
+    /** One entry per wafer the population spans. A snapshot: the chart keeps
+     *  these dies whatever happens to the selection afterwards. */
+    items: DrilldownItem[];
+    /** Who the dies are, read after a count — `"selected on W03"`, `"on W03"`. */
+    population: string;
+    testDefs: TestDef[] | undefined;
+    /** The test on screen where the gesture happened — a chart that shows one
+     *  test at a time opens on it. */
+    activeTest?: number;
+    /** Set when the dies are not measured dies (a lot stack's per-position
+     *  aggregates): every chart is then unavailable, with this as the reason. */
+    notMeasuredReason?: string;
+}
+/**
+ * Whether any drilldown chart could exist for this data — decides whether a
+ * right-click is taken over at all, without loading the drilldown chunk. The
+ * distribution charts need a parametric test, a sweep needs to be defined;
+ * with neither (a bins-only map) right-click stays the browser's or host's.
+ * `targetsFor` in drilldown.ts is the list this summarises.
+ */
+export declare function hasDrilldownTargets(testDefs: readonly TestDef[] | undefined, sweeps: readonly SweepSpec[] | undefined): boolean;
+interface WaferFacts {
+    /** The wafer's real identity, if it has one — never a positional stand-in,
+     *  which would read as an ID ("Wafer 3 (no ID)") in a chart title. */
+    waferLabel: string | undefined;
+    testDefs: TestDef[] | undefined;
+    isLotStack?: boolean;
+    activeTest?: number;
+    waferIndex?: number;
+}
+/** Dies the user selected on one wafer's map. */
+export declare function selectionPopulation(selected: Die[], f: WaferFacts): DrilldownSource;
+/** Every die of one wafer. */
+export declare function waferPopulation(dies: Die[], f: WaferFacts): DrilldownSource;
+export {};
+//# sourceMappingURL=chartPopulation.d.ts.map

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

@@ -0,0 +1 @@
+import{isParametricTest as s}from"../renderer/buildWaferMap.js";export function hasDrilldownTargets(t,e){return(e?.length??0)>0||(t??[]).some(s)}const n="This map stacks a lot: its dies are per-position aggregates, not measured dies";function r(t,e,a){return{items:[{label:a.waferLabel??"this wafer",dies:t,waferIndex:a.waferIndex}],population:e,testDefs:a.testDefs,activeTest:a.activeTest,notMeasuredReason:a.isLotStack?n:void 0}}export function selectionPopulation(t,e){return r(t,e.waferLabel?`selected on ${e.waferLabel}`:"selected",e)}export function waferPopulation(t,e){return r(t,e.waferLabel?`on ${e.waferLabel}`:"on this wafer",e)}

package/dist/packages/canvas-adapter/charts/barPanel.d.ts

@@ -1,5 +1,5 @@
 import type { ChartDatum } from '../../stats/yield.js';
-import { type SaveImageHandler } from './chartShell.js';
+import { type SaveImageHandler, type WaferContextMenuHandler } from './chartShell.js';
 export interface ChartPanel {
     title: string;
     data: ChartDatum[];
@@ -59,6 +59,9 @@ export interface ChartPanel {
      * instead, via `drill.onOpenGroup` — this is never called for those.
      */
     onOpen?: (datum: ChartDatum) => void;
+    /** Right-click on a leaf row that carries a wafer (`datum.key`) — see
+     *  `WaferContextMenuHandler`. Not called for a group row. */
+    onWaferContextMenu?: WaferContextMenuHandler;
     /** Document to build this panel's DOM into. Default `document` — pass the
      *  host's own `ownerDocument` when the container might live in a
      *  different document (e.g. a gallery card detached into its own popup

package/dist/packages/canvas-adapter/charts/barPanel.js

@@ -1 +1 @@
-import{SPACE as nt,fontPx as ot,FONT as lt,CLR as it}from"../toolbar.js";import{cardShell as rt,formatValue as st,observeResize as ct,makeTooltip as at,positionChartTooltip as ft,makeBackButton as ht,makeSegmented as dt,growCardToFitContent as ut,resolveChartCanvasColors as mt,PADDING as f,VALUE_WIDTH as z,prepareCanvas as xt}from"./chartShell.js";import{escHtml as _}from"../../core/utils.js";const h=24,m=5,bt=15,N=110,pt=12;export function renderBarPanel(i,U){const{barColor:P,valueLabel:G}=i;let b=i.title,l=i.data;const{card:r,heading:R,controlsRow:I,body:A}=rt(b,U,i.ownerDocument);if(i.selfControl){const e=i.selfControl;I.appendChild(dt(e.options,e.current,n=>q(n),r.ownerDocument))}const{drill:d}=i;let y=!1,B=null;const L=r.ownerDocument.createElement("div");Object.assign(L.style,{color:it.label,fontSize:lt.body,marginBottom:nt.sm}),r.insertBefore(L,A);function D(){const e=[];i.onOpen&&e.push("click to open this wafer"),d&&!y&&e.push(`click a ${d.groupLabelText} to see it by wafer`);const n=e.join(", or ");let o=n?`${n[0].toUpperCase()}${n.slice(1)}.`:"";const t=i.reference?.(l);t&&(o=o?`${o} Dashed line: ${t.label}.`:`Dashed line: ${t.label}.`),L.textContent=o}D();const w=r.ownerDocument.createElement("div"),v=()=>i.reference?bt:0,E=()=>f*2+v()+Math.min(l.length,pt)*(h+m);Object.assign(w.style,{overflowX:"hidden",overflowY:"auto",minHeight:"0",flex:"1",maxHeight:`${E()}px`,scrollbarGutter:"stable"}),A.appendChild(w);const a=r.ownerDocument.createElement("canvas");a.style.display="block",a.style.cursor="default",w.appendChild(a);const k=at(r);let x=-1,M=Math.max(1,...l.map(e=>e.value));const Y=e=>G?G(e):`${st(e.value)} (${e.percent.toFixed(1)}%)`;function F(e){const n=f+v()+e*(h+m),o=f+N,t=a.clientWidth-o-z-f;return{y:n,barX:o,barMaxWidth:Math.max(10,t)}}function p(){w.style.maxHeight=`${E()}px`,ut(r,A,E());const e=w.clientWidth,n=f*2+v()+l.length*(h+m),o=xt(a,r,e,n);if(!o)return;const{ctx:t}=o;t.font=`${ot(-1)}px system-ui, sans-serif`,t.textBaseline="middle";const s=mt(r);l.forEach((c,C)=>{const{y:u,barX:T,barMaxWidth:W}=F(C);C===x&&(t.fillStyle=s.bgHover,t.fillRect(0,u-m/2,e,h+m)),t.fillStyle=s.text,t.textAlign="right";const H=c.label.length>16?`${c.label.slice(0,15)}\u2026`:c.label;t.fillText(H,f+N-8,u+h/2),t.fillStyle=s.track,t.fillRect(T,u,W,h);const S=Math.max(1,c.value/M*W);t.fillStyle=P?P(c,C):s.text,t.fillRect(T,u,S,h),t.fillStyle=s.text,t.textAlign="right",t.fillText(Y(c),T+W+z,u+h/2)});const g=i.reference?.(l);if(g&&l.length){const{barX:c,barMaxWidth:C}=F(0),u=Math.round(c+Math.max(0,Math.min(1,g.value/M))*C)+.5,T=f+v()-3,W=f+v()+l.length*(h+m)-m,H=(Z,tt,et)=>{t.save(),t.strokeStyle=Z,t.lineWidth=tt,t.setLineDash(et),t.beginPath(),t.moveTo(u,T),t.lineTo(u,W),t.stroke(),t.restore()};H(s.bg,3.5,[]),H(s.text,1.5,[4,3]),t.save(),t.font="600 10px system-ui, sans-serif",t.textBaseline="middle",t.textAlign="left";const S=4,O=t.measureText(g.label).width+S*2,X=13,j=f+v()-X-1;let $=u-O/2;$=Math.max(c,Math.min($,c+C-O)),t.fillStyle=s.bg,t.strokeStyle=s.border,t.lineWidth=1,t.beginPath(),t.rect($,j,O,X),t.fill(),t.stroke(),t.fillStyle=s.text,t.fillText(g.label,$+S,j+X/2+.5),t.restore()}}function q(e){if(!i.selfControl)return;i.selfControl.current=e;const n=i.selfControl.onChange(e);l=n.data,M=Math.max(1,...l.map(o=>o.value)),x=-1,n.title&&(b=n.title,R.textContent=b),D(),p()}function J(e){if(!d)return;const n=d.onOpenGroup(e);l=n.data,b=n.title,R.textContent=b,M=Math.max(1,...l.map(o=>o.value)),x=-1,y||(y=!0,B=ht(()=>K(),r.ownerDocument),I.appendChild(B)),D(),p()}function K(){if(!d)return;const e=d.onBack();l=e.data,b=e.title,R.textContent=b,M=Math.max(1,...l.map(n=>n.value)),x=-1,y=!1,B?.remove(),B=null,D(),p()}function V(e){const n=Math.floor((e-f+m/2)/(h+m));return n>=0&&n<l.length?n:-1}a.addEventListener("mousemove",e=>{const n=a.getBoundingClientRect(),o=V(e.clientY-n.top),t=o>=0&&d&&!y&&l[o].itemCount>1,s=o>=0&&(t||!!i.onOpen&&o>=0&&!t);if(o!==x&&(x=o,a.style.cursor=s?"pointer":"default",p()),o>=0){const g=l[o],c=t?`<br><em>click to see this ${_(d.groupLabelText)} by wafer</em>`:i.onOpen?"<br><em>click to open this wafer</em>":"";k.innerHTML=`<strong>${_(g.label)}</strong><br>${_(Y(g))}${c}`,k.style.display="block",ft(k,r,e.clientX,e.clientY)}else k.style.display="none"}),a.addEventListener("mouseleave",()=>{x!==-1&&(x=-1,p()),k.style.display="none"}),a.addEventListener("click",e=>{const n=a.getBoundingClientRect(),o=V(e.clientY-n.top);if(o===-1)return;const t=l[o];if(d&&!y&&t.itemCount>1){J(t);return}i.onOpen?.(t)});const Q=ct(r,()=>p());return p(),{card:r,destroy:()=>Q.disconnect()}}
+import{SPACE as nt,fontPx as ot,FONT as lt,CLR as it}from"../toolbar.js";import{cardShell as rt,formatValue as st,observeResize as ct,makeTooltip as at,positionChartTooltip as ft,makeBackButton as ut,makeSegmented as dt,fitRowsHeight as ht,setChartGrow as mt,resolveChartCanvasColors as xt,PADDING as u,VALUE_WIDTH as j,WAFER_MENU_HINT as bt,prepareCanvas as pt}from"./chartShell.js";import{escHtml as X}from"../../core/utils.js";const d=24,m=5,gt=15,z=110,yt=12;export function renderBarPanel(l,U){const{barColor:G,valueLabel:I}=l;let g=l.title,i=l.data;const{card:r,heading:E,controlsRow:P,body:S}=rt(g,U,l.ownerDocument);if(mt(r,"rows"),l.selfControl){const e=l.selfControl;P.appendChild(dt(e.options,e.current,n=>q(n),r.ownerDocument))}const{drill:f}=l;let y=!1,R=null;const A=r.ownerDocument.createElement("div");Object.assign(A.style,{color:it.label,fontSize:lt.body,marginBottom:nt.sm}),r.insertBefore(A,S);function B(){const e=[];l.onOpen&&e.push("click to open this wafer"),f&&!y&&e.push(`click a ${f.groupLabelText} to see it by wafer`);const n=e.join(", or ");let o=n?`${n[0].toUpperCase()}${n.slice(1)}.`:"";const t=l.reference?.(i);t&&(o=o?`${o} Dashed line: ${t.label}.`:`Dashed line: ${t.label}.`),A.textContent=o}B();const k=r.ownerDocument.createElement("div"),v=()=>l.reference?gt:0,Y=()=>u*2+v()+Math.min(i.length,yt)*(d+m);Object.assign(k.style,{overflowX:"hidden",overflowY:"auto",minHeight:"0",flex:"1",maxHeight:`${Y()}px`,scrollbarGutter:"stable"}),S.appendChild(k);const s=r.ownerDocument.createElement("canvas");s.style.display="block",s.style.cursor="default",k.appendChild(s);const w=at(r);let x=-1,M=Math.max(1,...i.map(e=>e.value));const N=e=>I?I(e):`${st(e.value)} (${e.percent.toFixed(1)}%)`;function F(e){const n=u+v()+e*(d+m),o=u+z,t=s.clientWidth-o-j-u;return{y:n,barX:o,barMaxWidth:Math.max(10,t)}}function C(){const e=u*2+v()+i.length*(d+m);k.style.maxHeight=`${ht(r,S,Y(),e)}px`;const n=k.clientWidth,o=pt(s,r,n,e);if(!o)return;const{ctx:t}=o;t.font=`${ot(-1)}px system-ui, sans-serif`,t.textBaseline="middle";const c=xt(r);i.forEach((a,p)=>{const{y:h,barX:W,barMaxWidth:H}=F(p);p===x&&(t.fillStyle=c.bgHover,t.fillRect(0,h-m/2,n,d+m)),t.fillStyle=c.text,t.textAlign="right";const T=a.label.length>16?`${a.label.slice(0,15)}\u2026`:a.label;t.fillText(T,u+z-8,h+d/2),t.fillStyle=c.track,t.fillRect(W,h,H,d);const $=Math.max(1,a.value/M*H);t.fillStyle=G?G(a,p):c.text,t.fillRect(W,h,$,d),t.fillStyle=c.text,t.textAlign="right",t.fillText(N(a),W+H+j,h+d/2)});const b=l.reference?.(i);if(b&&i.length){const{barX:a,barMaxWidth:p}=F(0),h=Math.round(a+Math.max(0,Math.min(1,b.value/M))*p)+.5,W=u+v()-3,H=u+v()+i.length*(d+m)-m,T=(Z,tt,et)=>{t.save(),t.strokeStyle=Z,t.lineWidth=tt,t.setLineDash(et),t.beginPath(),t.moveTo(h,W),t.lineTo(h,H),t.stroke(),t.restore()};T(c.bg,3.5,[]),T(c.text,1.5,[4,3]),t.save(),t.font="600 10px system-ui, sans-serif",t.textBaseline="middle",t.textAlign="left";const $=4,O=t.measureText(b.label).width+$*2,_=13,V=u+v()-_-1;let D=h-O/2;D=Math.max(a,Math.min(D,a+p-O)),t.fillStyle=c.bg,t.strokeStyle=c.border,t.lineWidth=1,t.beginPath(),t.rect(D,V,O,_),t.fill(),t.stroke(),t.fillStyle=c.text,t.fillText(b.label,D+$,V+_/2+.5),t.restore()}}function q(e){if(!l.selfControl)return;l.selfControl.current=e;const n=l.selfControl.onChange(e);i=n.data,M=Math.max(1,...i.map(o=>o.value)),x=-1,n.title&&(g=n.title,E.textContent=g),B(),C()}function J(e){if(!f)return;const n=f.onOpenGroup(e);i=n.data,g=n.title,E.textContent=g,M=Math.max(1,...i.map(o=>o.value)),x=-1,y||(y=!0,R=ut(()=>K(),r.ownerDocument),P.appendChild(R)),B(),C()}function K(){if(!f)return;const e=f.onBack();i=e.data,g=e.title,E.textContent=g,M=Math.max(1,...i.map(n=>n.value)),x=-1,y=!1,R?.remove(),R=null,B(),C()}function L(e){const n=Math.floor((e-u+m/2)/(d+m));return n>=0&&n<i.length?n:-1}s.addEventListener("mousemove",e=>{const n=s.getBoundingClientRect(),o=L(e.clientY-n.top),t=o>=0&&f&&!y&&i[o].itemCount>1,c=o>=0&&(t||!!l.onOpen&&o>=0&&!t);if(o!==x&&(x=o,s.style.cursor=c?"pointer":"default",C()),o>=0){const b=i[o],a=t?`<br><em>click to see this ${X(f.groupLabelText)} by wafer</em>`:l.onOpen?"<br><em>click to open this wafer</em>":"",p=!t&&l.onWaferContextMenu&&typeof b.key=="number"?bt:"";w.innerHTML=`<strong>${X(b.label)}</strong><br>${X(N(b))}${a}${p}`,w.style.display="block",ft(w,r,e.clientX,e.clientY)}else w.style.display="none"}),s.addEventListener("mouseleave",()=>{x!==-1&&(x=-1,C()),w.style.display="none"}),s.addEventListener("click",e=>{const n=s.getBoundingClientRect(),o=L(e.clientY-n.top);if(o===-1)return;const t=i[o];if(f&&!y&&t.itemCount>1){J(t);return}l.onOpen?.(t)}),s.addEventListener("contextmenu",e=>{const n=s.getBoundingClientRect(),o=L(e.clientY-n.top);if(o===-1||!l.onWaferContextMenu)return;const t=i[o];f&&!y&&t.itemCount>1||typeof t.key!="number"||(w.style.display="none",l.onWaferContextMenu(t.key,void 0,e))});const Q=ct(r,()=>C());return C(),{card:r,destroy:()=>Q.disconnect()}}

package/dist/packages/canvas-adapter/charts/boxplot.d.ts

@@ -1,6 +1,6 @@
 import { type BoxplotItem } from '../../stats/boxplot.js';
 import type { TestDef } from '../../renderer/buildWaferMap.js';
-import { type AxisPrefs, type SaveImageHandler } from './chartShell.js';
+import { type AxisPrefs, type SaveImageHandler, type WaferContextMenuHandler } from './chartShell.js';
 /** A `BoxplotItem` carrying enough identity for the panel to open its wafer
  *  on a leaf-row click — the tab's own item shape already has this. */
 export type BoxplotPanelItem = BoxplotItem & {
@@ -43,6 +43,9 @@ export interface BoxplotPanelOptions {
      *  same test in value mode instead of defaulting to hard-bin mode.
      *  Never called for a pooled group-overview row (that drills instead). */
     onOpen?: (waferIndex: number, testNumber: number) => void;
+    /** Right-click on a wafer's box — see `WaferContextMenuHandler`. Not called
+     *  for a pooled group row. */
+    onWaferContextMenu?: WaferContextMenuHandler;
     /** What `onOpen` will actually do, in the user's words — substituted into
      *  both click affordances ("click a box to …" / "click to …"). Default
      *  wording describes opening that wafer, which is what a gallery host does;