@wafertools/wafermap 0.29.0 → 0.30.1

package/AGENTS.md

@@ -20,14 +20,13 @@ loudly over guessing.
 ### Entry points
 
 - `@wafertools/wafermap` — `buildWaferMap()`, geometry, `registerBinColorScheme()` / `registerValueColorScheme()`. Pure, no DOM, server-safe.
-- `@wafertools/wafermap/render` — `renderWaferMap()`, `renderWaferGallery()`, `toCanvas()`. Needs the DOM.
+- `@wafertools/wafermap/render` — `renderWaferMap()`, `renderWaferGallery()`. Needs the DOM.
 - `@wafertools/wafermap/stats` — `analyzeWaferMap()`, `analyzeWaferLot()`. Pure analysis.
 - `@wafertools/wafermap/worker` — `createWafermapWorker()` for off-main-thread builds.
 
 Default path: `buildWaferMap()` once when data loads, then `renderWaferMap()` for a
-single wafer or `renderWaferGallery()` for several. Reach for `toCanvas()`/`buildView()`
-only when you need the low-level pipeline — they give up the toolbar and every UI
-correctness guarantee that comes with it.
+single wafer or `renderWaferGallery()` for several. Do not use `toCanvas()`, `buildView()`
+or the other low-level pipeline functions: they are deprecated and removed in 0.31.0.
 
 ### Traps that produce silently wrong maps
 
@@ -65,7 +64,6 @@ correctness guarantee that comes with it.
   the wrong place. The renderers surface these themselves in a toolbar indicator, so
   do NOT hand-roll a second display — pass
   `warnings: { display: false, onWarning }` if the app has its own notification UI.
-  (`result.inference.warnings` is a deprecated string mirror; do not use it.)
 - **Give the container a resolved height.** `renderWaferMap` fills its container.
   A bare block-flow `<div>` is fine — it grows to the canvas. The real failure is a
   flex/grid child whose ancestors never resolve a height: it stays 0-tall and the
@@ -82,12 +80,13 @@ correctness guarantee that comes with it.
 - `retestPolicy: 'best'`/`'worst'` is pass/fail-aware via `passBins`; bin number only
   breaks ties within a category.
 - Hard bins (`hbin`) and soft bins (`sbin`) are independent number spaces. Never merge them.
-- **Never pick a bin's colour from its number.** Bin colours are assigned by
-  `resolveBinColors` — pass bins (per `passBins`) take green pass colours, fail bins
-  take the rest, most populous first — and a rendered map exposes the result as
-  `View.binColors`. A legend or chart you build yourself must read those, or it
-  will name colours the map is not drawing. Bin maps and value maps have separate
-  schemes: `binColorScheme` and `valueColorScheme`.
+- **Do not colour bins yourself.** The maps give each bin one colour from its number
+  and its pass/fail verdict (pass bins, per `passBins`, take green pass colours), so a
+  bin is the same colour in every lot. To choose colours, set `BinDef.color` or register
+  a palette with `registerBinColorScheme`. Bin maps and value maps have separate
+  schemes: `binColorScheme` and `valueColorScheme`. Need the colours for a surface of
+  your own (a table swatch, an export)? Read `controller.getBinColors()` for a live map,
+  or `binColorsForMaps(results)` — never a palette lookup of your own.
 - Build once, render many: `buildWaferMap()` handles data + geometry; re-render UI
   changes through the controller's `setOptions()`, not by rebuilding.
 - `result.view` is internal. Use the promoted fields: `result.plotMode`,
@@ -99,8 +98,8 @@ correctness guarantee that comes with it.
   `w.message` to display, branch on `w.code`. Code that calls a string method on an
   entry — `warnings[0].includes('…')` — is the old shape and will throw.
 - **`summary.findings` is the complete list and contains restatements of the same
-  fact.** Building a list for a human to read? Exclude what other findings absorb:
-  `const absorbed = new Set(summary.findings.flatMap(f => f.absorbedIds ?? []))`.
+  fact.** Building a list for a human to read? Pass it through `visibleFindings()`,
+  which drops what other findings absorb — do not re-implement that filter.
   Skip that and one edge failure is reported up to three times per region — a hard
   bin row, its soft-bin twin, and the yield row that restates the pass bin. Do NOT
   use `relatedIds` for this; it is a different relationship and some ids it names
@@ -136,6 +135,14 @@ it is handed, because it has no way to know which tests anyone will look at.
 - **A Web Worker buys responsiveness, not speed.** `createWafermapWorker` copies data
   across `postMessage`, so total time goes *up*. Use it when a build would otherwise
   visibly freeze the page, not for small datasets.
+- **Capability, pass rates and region yield come back from the analysis** —
+  `stats.capability` (with `computePerTestStats`), `stats.testSpecYield`,
+  `stats.testFlagYield`, `stats.functionalYield` and `stats.regionYield`, on wafer and
+  lot summaries alike. Do not compute Cp/Cpk or ring yield yourself: the pooled
+  within-wafer stddev and per-wafer pass bins are easy to get subtly wrong.
+- **Reports from code: `renderWaferReportHtml(result, summary)` and
+  `renderLotReportHtml(results)`** — they take the built maps, so pass bins and ring
+  count cannot be wrong. They run in Node.
 - **In a gallery, pass `perWaferSummaries` to `analyzeWaferLot`** so it reuses the
   per-wafer analysis you already ran instead of redoing it.
 
@@ -146,6 +153,8 @@ it is handed, because it has no way to know which tests anyone will look at.
 | `DieResult.values` / `Die.values` | `testValues` (keyed by test number) |
 | `TestDef.index` | `TestDef.testNumber` (required) |
 | `ViewOptions.colorBySpec` | `passFailDisplay: 'spec'` |
+| `View.colorBySpec` | `view.passFailDisplay` |
+| `WaferMapResult.inference.warnings` | `WaferMapResult.warnings` (structured, with a `code`) |
 | `ViewOptions.testIndex` | `activeTest` |
 | `mountWaferCanvas` | `renderWaferMap` |
 | `HARD_BIN_COLORS` / `SOFT_BIN_COLORS` | `BIN_PALETTE` |
@@ -153,15 +162,15 @@ it is handed, because it has no way to know which tests anyone will look at.
 | `MountOptions` | `RenderOptions` |
 | `WaferCanvasController` | `WaferMapController` |
 | `CanvasHitTarget` | `HitTarget` |
-| `buildScene` / `BuildSceneOptions` / `SceneOptions` | `buildView` / `ViewOptions` |
+| `buildScene` / `BuildSceneOptions` / `SceneOptions` | `renderWaferMap` |
 | `WaferFlat`, field `flat` | `WaferNotch`, field `notch` |
-| `isInsideWaferWithFlat` | `isInsideWafer` |
+| `isInsideWaferWithFlat` | nothing — `buildWaferMap` resolves the geometry |
 | `DieSample` / `WaferMapPoint` | `DieResult` |
 | `colorScheme` / `WaferViewOptions.colorScheme` | `binColorScheme` (bin maps) and `valueColorScheme` (value and stacked maps) |
 | `registerColorScheme` / `getColorScheme` / `listColorSchemes` | `registerBinColorScheme` / `registerValueColorScheme` and their `get` / `list` pairs |
-| `hardBinColor` / `softBinColor` / `hardBinGreyscale` | `resolveBinColors`, or `View.binColors` from a rendered map |
+| `hardBinColor` / `softBinColor` / `hardBinGreyscale` | `BinDef.color`, or `registerBinColorScheme` |
 | `plotMode: 'specLimit'` | `passFailDisplay: 'spec'` |
-| standalone `getDieAtPoint` | `hitTarget.getDieAtPoint` from `toCanvas()` |
+| standalone `getDieAtPoint` | `onHover` / `onClick` on `renderWaferMap` |
 | `RenderOptions.tooltipTestLimit` | (was a no-op; nothing replaces it) |
 
 Passing a removed option is a type error, and is ignored at runtime. Do not add

package/CHANGELOG.md

@@ -22,6 +22,416 @@ under `### Breaking`.
 
 ---
 
+## [0.30.1] — 2026-09-16
+
+### Security
+
+- **Names from a data file could run script in a tooltip.** The die tooltip and the Insights
+  chart tooltips (correlation, capability, boxplot, trend, histogram, bar and grouped-bar
+  charts), plus the legend-row and toolbar tooltips, built HTML from test names, units, bin
+  names, wafer labels and metadata values without escaping them. A file with a test named
+  `<img src=x onerror=…>` ran that script when a user hovered, in a Tauri, Electron or
+  WebView2 host inside the app's own webview. Every such value is now escaped. The escape
+  helper, formerly private to the reports, is the one copy for the library (`core/utils.ts`),
+  and `tests/htmlEscaping.test.mjs` fails if a tooltip puts a raw label into HTML again.
+
+### Changed
+
+- **Every saved file is named for the data it came from.** Exports were named for their content
+  alone — `dies.csv`, `test-values.csv`, `wafermap.png`, `wafer-gallery.png`, a chart's title — so
+  the same export from two wafers of a lot saved as `dies.csv` and `dies (1).csv`, with nothing in
+  either name to say which wafer it described. Map, gallery and chart PNGs and every CSV export
+  are now named `[lot]_[wafer]_[content]`, for example `LOT123_W05_hard-bin.png`,
+  `LOT123_W05_die-list.csv` and `LOT123_25-wafers_yield-by-wafer.png` (see API §5.4.5).
+  - A part the data doesn't have is left out, never invented. A wafer with no `label` or
+    `waferId` gets no wafer part, not a position that could be read as an ID.
+  - A gallery writes its lot and wafer counts (`2-lots`, `25-wafers`), and a lot-stacked map
+    writes `stacked-N-wafers`. A card or detached window names files for its own wafer.
+  - The name is worked out at save time, so it follows `setResult`, `setItems` and plot-mode
+    changes.
+  - Names are safe on every common filesystem: path and reserved characters are replaced,
+    length is limited, and Windows device names are avoided.
+  - **`downloadFilename` is unchanged.** When a host sets it, the map or gallery PNG is still
+    named `<downloadFilename>.png`. Only its defaults change: without it, the map PNG was
+    `wafermap.png` and the gallery PNG `wafer-gallery.png`, and both now get the generated name.
+    Gallery cards, which never read it, also get the generated name, as do all CSVs and charts.
+  - `onSaveImage` and `onSaveText` receive the generated name as `suggestedName`. A host that
+    matched one of the old default names needs to change.
+  - The die-list export's content part is `die-list` (was `dies`).
+- **A floating window's minimize button is now Collapse, and is hidden while the window is
+  maximized.** In a desktop host such as Tauri, where a detached gallery card falls back to an
+  in-page window, a maximized window's header sits directly under the app's own title bar. Its
+  `_` minimize looked like the OS button beside it but only shrank the window to a title strip.
+  The button is now drawn as chevrons, with the tooltip **Collapse** (**Show contents** while
+  collapsed), and a maximized window shows only restore and close, like a modal. This applies to
+  the detached-card fallback window and the user guide window. Modals are unchanged, and
+  `ICONS.windowMinimize`/`windowRestore` are still exported.
+- **The data layer is about 3 KB larger (~52 KB gzip).** Analysis now returns capability, pass
+  rates by recorded verdict and region yield (see Added), so it includes the code that computes
+  them.
+
+### Deprecated
+
+- **`downloadFilename` (on `RenderOptions` and `GalleryOptions`) becomes a prefix in 0.31.0.** It
+  will lead the name of every file a map or gallery saves, CSVs included, with the lot, wafer and
+  content appended, for example `LOT123_sort_W05_hard-bin.png`. Parts it already names won't be
+  repeated, so a host passing a source-file stem that contains the lot won't see the lot twice.
+  It is not being removed. Until 0.31.0 it keeps its current meaning, and passing it logs a
+  one-time console notice. If you rely on setting a map's whole file name, say so at
+  https://github.com/wafertools/wafermap/issues.
+- **Five 0.30.0 deprecations are withdrawn on review**, as each is the only supported path to
+  something a host needs: `visibleFindings` (the one rule for collapsing restated findings —
+  `summary.findings` is deliberately uncollapsed), `openReportModal` (shows a report when a host
+  has installed its own `setReportOpener`), `metadataDisplayValue` (the one rule for a metadata
+  value's text in an export), `getReticleCell` (the only source of a die's reticle cell outside
+  the tooltip) and `renderFindingsReportHtml` (it takes a summary alone, so it cannot be given
+  inconsistent inputs). They log no notice and stay.
+- **Every remaining deprecation notice now names what to use instead**, or says plainly that
+  there is no data replacement (the histogram, scatter and correlation builders). The review
+  behind each verdict is recorded in the repository's `API_REMOVALS.md`.
+
+### Fixed
+
+- **A test could not be chosen from the plot-mode menu on a touchscreen.** With more tests than
+  fit inline, "Test Value ▶" opens a submenu, and it opened on hover only. On a phone or tablet a
+  tap opened the submenu and the same tap closed it again, so the list flashed and no test could
+  be picked. From the keyboard, Enter on the row did nothing. The row now also opens the submenu
+  when tapped or activated with Enter or Space. Focus moves into the submenu when it is opened from
+  the keyboard, the arrow keys move through its tests, and Escape closes it. Tapping the submenu's
+  filter box no longer closes the menu underneath. Applies to both `renderWaferMap` and
+  `renderWaferGallery`. Guarded by `tests/modeMenuCascade.test.mjs`.
+- **Map lines and markers got thinner as display scaling rose.** Ring, quadrant and reticle
+  lines, the wafer outline, the probe path, the +X/+Y indicator, out-of-spec triangles and the
+  failing-die hatch were sized in device pixels, so on a 2× display they drew at half their
+  intended size and on a 3× display at a third. The ring and quadrant lines' light centre fell
+  below one CSS pixel and faded to a faint hairline. They are now sized in CSS pixels, like the
+  colorbar's limit markers, so they look the same at every scale and are sharper at higher ones.
+  A 1× display draws exactly as before. The die outline stays at its device-pixel width, so
+  dense maps on high-DPI screens are not greyed out. Guarded by `tests/strokeScale.test.mjs`.
+- **Outlined buttons lost their border in a dark theme.** Summary report, View die list and the
+  Test values / Functional CSV buttons drew a fixed dark edge (`rgba(0,0,0,0.30)`) whatever the
+  theme, so on a dark panel they had no visible outline while the ring/quadrant toggles beside
+  them did. `--wmap-control-border` now falls back to `--wmap-border` — the edge the
+  toggles use — so a theme that sets `--wmap-border` gets the same outline on both. With neither
+  set the default is unchanged, and a host that sets `--wmap-control-border` is unaffected.
+- **Bins and test values given as text built a wrong map without a warning.** A CSV parser gives
+  every field as a string. String `x`/`y` already made `buildWaferMap` throw, but a bin of `"1"`
+  is not pass bin `1`, so those dies counted as fails and yield read 0 %, and a test value of
+  `"0.5"` was not plotted or analysed as a number — with nothing to say so. `buildWaferMap` now
+  raises an `input-values-not-numbers` warning (severity `error`) counting text bins, text test
+  values and non-boolean verdicts, with an example. The values are not converted: convert them
+  and rebuild.
+- **Changing the bin palette inside an expanded gallery card did not recolour the map.** A card
+  keeps the gallery-wide bin colours so every card agrees, and those took precedence over the
+  palette chosen in the card's own menu, so the menu appeared to do nothing — most visibly for soft
+  bins. A palette or "Use colours from bin definitions" change made in the card now resolves the
+  card's colours from that choice; a change made in the gallery still recolours every card
+  together.
+- **A card reattached to the gallery kept the view it had while expanded.** Reattaching stored the
+  expanded window's options — plot mode, palettes, overlays — as that card's per-card overrides,
+  which win every time the card is built. A card switched to soft bins while expanded stayed a
+  soft-bin map under a gallery bar and legend strip describing hard bins, and later gallery palette
+  changes left it in colours matching no other card. A reattached card now takes the gallery's
+  shared options again, like every other card. This also stops reattaching from discarding
+  per-card `viewOptions` the host set on the item.
+- **A lot report built for wafers without a precomputed summary analysed empty wafers.** The
+  report ran its lot analysis on `{ label, wafer, dies, passBins }` pieces, which the analysis
+  does not recognise as built maps, so it treated each as a fresh input with no results. The
+  report then had no findings, `N/A` per-wafer yields, and a title of "Summary — N wafers"
+  instead of "Lot Summary — <lot>". It now analyses the built maps (`renderLotReportHtml`, and
+  the gallery's and lot panel's report buttons, which use it).
+- **A gallery with a fixed column count left most of the row empty.** Picking 2 columns drew two
+  480px cards and left the rest of the row empty, because a fixed column count was still capped
+  by die density (since 0.21.1). A fixed column count now divides the full width; Auto keeps the
+  cap.
+- **`GalleryOptions.columns` was ignored at mount**, so the grid always drew a single column.
+  Invalid counts (`0`, negative, `NaN`) now fall back to automatic layout, and fractions round.
+
+### Added
+
+Supported replacements for exports deprecated in 0.30.0 that had no other path. Each deprecated
+export's notice names its replacement; the old names are still removed in 0.31.0.
+
+- **Capability, pass rates by recorded verdict, and region yield in the analysis output**
+  (API §7.4.1), replacing `buildCapabilityData`, `buildTestPassRateData`/`hasJudgeableTests`
+  and `buildRegionYieldData` with the ring/quadrant builders:
+  - `stats.capability` — Cp/Cpk/Pp/Ppk per parametric test, computed when per-test statistics
+    are (`computePerTestStats`). On a lot summary each wafer is a subgroup, so `stdWithin` is the
+    pooled within-wafer stddev and Cp and Pp differ. The chart's normalised five-number fields
+    are not included; they are not the test's real minimum and quartiles.
+  - `stats.testFlagYield` — per-test pass rate by the tester's recorded verdict — and
+    `stats.specVerdictDisagreementDies`, the dies where that verdict and the spec-limit judgement
+    disagree. They complement the existing `testSpecYield` and `functionalYield`.
+  - `stats.regionYield` — `{ ring, quadrant }` yield with each region's die and pass counts, each
+    die judged by its own wafer's pass bins.
+  - On `LotStatsSummary.stats`: `capability`, `regionYield`, `testSpecYield`, `functionalYield`,
+    `testFlagYield` and `specVerdictDisagreementDies`, all pooled exactly from the wafer summaries
+    — counts summed, and capability from each wafer's moments — so a lot analysis given
+    `perWaferSummaries` stays cheap. A pooled figure is absent unless every wafer reported it. Lot ring yield is also absent when wafers
+    were built with different ring counts.
+  - `analyzeWaferLot` now builds a raw `WaferMapInput` once and passes the built map to each
+    wafer's analysis.
+- **`renderWaferReportHtml(result, summary?)` and `renderLotReportHtml(results)`**, replacing
+  `renderSummaryReportHtml` and `renderLotSummaryReportHtml`. They take built maps, so pass bins
+  and ring count come from the map rather than defaulting to `[1]` and `4`. They need no DOM.
+  The Summary panel's report buttons use them.
+- **`binColorsForMaps(results, options?)` and `getBinColors()` on `WaferMapController` and
+  `GalleryController`** — the colours the maps draw, for a host's own table, export or chart —
+  replacing `resolveBinColors` and `getBinColorScheme`. `binColorsForMaps` judges each map by its
+  own pass bins; the gallery's own colouring now goes through the same function.
+- **`buildWaferMap({ layout: true, waferConfig, dieConfig })`** — a die layout with no test data:
+  every site fully on the wafer (the gross die count), die `(0, 0)` at the centre, counted in the
+  configured axis directions. It replaces `createWafer` + `generateDies` + `clipDiesToWafer`, and
+  renders like any other result.
+- **`stats.spatialPattern` on `analyzeWaferMap`'s result** — the spatial pattern classifier's label,
+  confidence and geometry features (failure density overall and at the edge, the failing
+  cluster's radial position, eccentricity, linearity, …), replacing a direct `classifyPattern`
+  call. It is present for every wafer the classifier can measure, including those labelled
+  `'random'` or `'none'`, which raise no finding, so the features can feed a model of your own with
+  negative examples as well as patterned ones.
+- **`ICONS.collapse` and `ICONS.uncollapse`**, the floating-window header's collapse and
+  show-contents icons.
+- **`WaferMapController.closeSummaryPanel()` and `GalleryController.setColumns()` are restored.**
+  Both were removed in 0.30.0 without a deprecation period. A host needs the first to get the
+  map's full width back, for example when loading a new file, and the second to apply its own
+  column control or a saved preference without rebuilding the gallery. Closing the panel no
+  longer resets the Summary button's notable-findings colour, as the 0.29 version did.
+
+## [0.30.0] — 2026-09-15
+
+### Breaking
+
+- **Bin colour is keyed by bin number again, not by die count.** Since 0.28.0,
+  `resolveBinColors` ranked bins by die count and handed out palette colours in that order, so
+  a colour meant "the biggest fail bin in this view" rather than any particular bin: two lots
+  of one program drew hard bin 7 red in one and brown in the other, and filtering a gallery
+  could recolour bins. Industry wafer-map tools key colour on the bin number so engineers can
+  learn a program's colours and compare screenshots; wmap now does the same. A pass bin takes
+  `pass[(bin − 1) mod n]` and a fail bin `fail[(bin − 2) mod n]`, so bin 1 is the first green and
+  bin 2 is red in the default palette. Still pass/fail-aware (a failing bin 1 is never green),
+  still honours `BinDef.color`. The slot comes from the number alone, so changing `passBins`
+  recolours only bins whose verdict changed.
+  - **Soft bins read the palette shifted by half its length**, so hard bin *n* and soft bin *n*
+    are different colours by default.
+  - **`shared` now reports fixed pairs:** bins whose numbers are a palette-length apart (fail
+    bins 2 and 21 in `'default'`, 2 and 16 in `'accessible'`) when both are present, rather than
+    "more bins than colours".
+  - Same function, same types, different colours for the same input, which is why this is
+    breaking. Any host screenshot or test that pinned a rank-derived colour will change.
+- **The `passBins` options on `analyzeWaferMap`, `analyzeWaferLot`, `renderWaferMap` and
+  `renderWaferGallery` are removed.** Pass bins are set once, on `buildWaferMap`'s input, and
+  carried on the result as `WaferMapResult.passBins` (new), which all four read — per wafer in a
+  gallery or lot. A second place to set them is how every surface came to judge pass/fail by `[1]`
+  (see Fixed), and an analysis override produced a summary whose findings and yield figure used
+  different pass bins. A map not built by `buildWaferMap` states them in that same `passBins`
+  field. Passing a removed option is a type error; at runtime `analyzeWaferMap` and
+  `analyzeWaferLot` ignore it and say so with an `analysis-option-corrected` warning, as they do
+  for a stale `ringCount`. To analyse or render with different pass bins, rebuild.
+- **Options and methods removed as unused, duplicated or dead.** Found by measuring what tsmap,
+  the examples and the library itself actually use; each was either never set by anything, a
+  second way to set something that already had one, or accepted and ignored.
+  - `RenderOptions`: `minZoom`/`maxZoom` (fixed at 0.4× and 20× of the fitted view),
+    `renderTooltip`, `maxSize`, `toolbarControls` (its `'view-only'` value was never used),
+    `showPlotModeSelector`, and the top-level `legendPosition` and `fallbackFormat` — set both
+    through `viewOptions`.
+  - `GalleryOptions`: `cardPadding`, `maxSize` (the density-derived card size cap always
+    applies), `showPlotModeSelector`, `legendPosition` and `fallbackFormat` (through `viewOptions`).
+  - `WaferMapController`: `setDies` (it replaced dies but not the wafer geometry, so switching
+    wafers with it kept the previous wafer's outline — use `setResult`), `setFallbackFormat` (use
+    `setOptions({ fallbackFormat })`), `setHelpButtonVisible`, `setTooltipParent`.
+    `GalleryController`: `setFallbackFormat`, `setColumns`.
+  - `ViewOptions.dieGap` (fixed at 1 mm), `ToCanvasOptions.topClearance` (always passed 0),
+    `DieListDisplayOptions.csvFilename`.
+  - `AnalyzeWaferMapOptions.includePartial` / `includeEdgeExcluded`: analysing dies that yield
+    excludes could only make the findings describe a different population from the yield figure
+    beside them. `isYieldEligibleDie`'s own options are unchanged.
+  - `fallbackFormat` is now a view preference (`WaferPreferences.fallbackFormat`), reported
+    through `onViewOptionsChange` with the others.
+  - **Gallery-to-card plumbing is off the public API.** `WaferDisplayState` loses `binColors`,
+    `metadataValueOrder` and `lotSize`; `RenderOptions` loses `chromeInset` and `onExpand`;
+    `WaferMapController` loses `setSummaryVisible` and `setViewControlsVisible`. The gallery set
+    all of them on its own cards, and on a host's map they read as settings a host must supply to
+    get a valid map — a lone map resolves its bin colours, metadata order and lot size itself.
+    `renderWaferGallery`'s `getOptions()` and `onViewOptionsChange` no longer carry the three
+    fields either (`binColors` held `Map`s, which a host persisting its options could not
+    serialise). `ViewOptions.binColors`, `.metadataValueOrder` and `.lotSize` for `buildView` are
+    unchanged.
+- **Ring count is set once, on `buildWaferMap`.** `WaferMapInput.ringCount` (default 4) is
+  carried as `WaferMapResult.ringCount`, and the ring overlay, ring findings, Summary panel,
+  report and Insights all read it. `AnalyzeWaferMapOptions.ringCount` and the view preference
+  `ringCount` are removed: they were two places that had to match, and when they did not, the
+  ring boundaries on the map described different rings from the ring findings beside them.
+  Validation moved with it — a bad value is corrected and reported in `result.warnings` as
+  `analysis-option-corrected`, still with no upper bound. A gallery whose wafers were built with
+  different ring counts raises the new `ring-count-mixed` warning; each card and each wafer's
+  findings use their own. `ViewOptions.ringCount` (for `buildView`) and `classifyDie`'s option
+  are unchanged.
+- **`BinColors` has a new required field, `pass: { hard: Set<number>; soft: Set<number> }`** —
+  the bins that pass, per type, as `resolveBinColors` judged them. A host that builds a
+  `BinColors` by hand must add it; an object without it passed as `ViewOptions.binColors` is
+  now ignored and resolved afresh rather than trusted. `binPassSets(dies, passBins)` gives the
+  same sets without colours.
+- **`WaferMapResult.inference.warnings` is removed.** It has been a deprecated string mirror since
+  0.13.5, when `WaferMapResult.warnings` replaced it with the same messages plus a stable `code` and
+  a severity. Read `result.warnings`. Internally each geometry advisory now records its code where it
+  is detected, rather than having it recovered by matching phrases in the message.
+- **`View.colorBySpec` is removed.** Its input option went in 0.21.0; the output stayed, only ever
+  equal to `passFailDisplay === 'spec'`. Read `view.passFailDisplay`.
+- **`ToCanvasOptions.activeBin`, `.hoverBin` and `.minRightReserve` are removed.** They carry the
+  interactive map's own legend highlight, pointer and mode-switch layout state, which a direct
+  `toCanvas` caller has none of — the same reason `RenderOptions` already dropped them.
+- **`AnalyzeWaferMapOptions` loses its per-analysis switches:** `enableYieldAnalysis`, `enableHardBinAnalysis`, `enableSoftBinAnalysis`, `enableReticlePositionAnalysis`, `enableTestSiteAnalysis`, `enableClusterAnalysis`, `enableAngularAnalysis` and `enablePatternClassification`.
+  Each was cheap and on by default; every analysis now runs, and a caller wanting fewer findings
+  filters them (`filterFindings`). Passing one from untyped JavaScript is reported as
+  `analysis-option-corrected`. The two that cost real time stay: `enableTestValueAnalysis`, and
+  `computePerTestStats`, which triples analysis time on a 7,843-die, 50-test wafer (94 ms → 298 ms)
+  and so cannot simply always run.
+- **`WaferMapController.setExpandVisible`, `setIdentityVisible`, `closeSummaryPanel` and
+  `getActiveLegend` are removed.** The first two duplicated the `showExpandButton` and `showIdentity`
+  options, and nothing used the other two. The gallery keeps expand-button control internally.
+
+### Fixed
+
+- **A wafer with no die positions covered the Insights view.** In `renderWaferMap`, a
+  coordinate-less wafer's "No die position data" summary stayed on top of the chart suite once
+  Insights was opened, hiding most of it. A mixed wafer's "+N dies without position data" footer
+  did the same. Their z-index beat the Insights layer's. The map view is now hidden outright while
+  Insights is open, so nothing inside it can show through, and its controls leave the tab order.
+
+- **Input names removed in earlier releases vanished without a trace.** A plain-JavaScript caller
+  still passing `data` instead of `results` got an empty map, and `values` instead of `testValues`
+  a map with no test data — no error, no warning, nothing that looked wrong. `buildWaferMap` now
+  reports every removed name it finds (`data`, `die`, `stack`, `values`, `TestDef.index`,
+  `dieConfig.origin`, `waferConfig.flat`, `reticleConfig.anchor`, `lotStack.aggr`) as a new
+  `input-field-removed` warning naming each replacement, in `result.warnings` and on the console.
+  It still does not honour them: rename and rebuild.
+- **Pass bins given to `buildWaferMap` were used for `result.yield` and nothing else.** The result
+  had nowhere to keep them, so every later surface fell back to `[1]` unless the caller repeated
+  them: `analyzeWaferMap`'s findings and yield statistics, bin colours and legend order, the
+  failing-die hatch, the Summary panel and report, region yield, the Insights yield charts, the
+  gallery strip's Yield, and the map's own internal view. A program whose bins 1 and 2 both pass
+  therefore showed bin 2 as a failure everywhere except the one yield figure — and the docs
+  already claimed `analyzeWaferMap` inferred them from the result. tsmap hit this on every file
+  whose pass bins are not just bin 1: it gives each wafer's pass bins to `buildWaferMap` and to
+  nothing else. `[1]` is now a default only at `buildWaferMap`'s input; `WaferMapResult.passBins`
+  carries the value everywhere after.
+  - **A gallery judges each wafer by its own pass bins**, so a lot mixing test programs is
+    correct per wafer in cards, strip yield, lot panel, report, region yield and Insights. Hard
+    bins that pass on one wafer and fail on another get one colour and one legend row, so the
+    gallery raises `pass-bins-mixed` naming them. Yield labels say "per wafer: bin 1 · bins 1, 2"
+    when wafers disagree, rather than naming one wafer's set.
+  - The report's lot region-yield table and the gallery strip's yield were separate copies of
+    the per-die pass rule; both now use the shared ones (`buildRegionYieldData`, `diePassStatus`).
+- **A map's bin legend drew its title over the first row when there were many bins.** Rows
+  were fitted to the full canvas height and the "Soft Bin"/"Hard Bin" title placed above them
+  afterwards, clamped below the toolbar, so a legend tall enough to fill the height had its
+  title printed across row one. The title row (and a floating legend's padding and heading) is
+  now reserved before rows are fitted; overflow moves into "+ N more" one row sooner.
+- **Bin legends list pass bins first, then failing bins by die count**, the order the Summary
+  panel, report and Insights pareto already used (`sortBinsForDisplay`). The per-map canvas
+  legend and the gallery's legend strip both sorted by bin number, so one lot was listed two
+  ways on one screen, and a program with dozens of bins buried its biggest failures.
+- **Soft bins were ordered, and the gallery's soft-bin yield was totalled, as if hard pass bin
+  numbers applied to them.** The Summary panel, both report bin tables and the gallery strip
+  judged a soft bin "pass" by looking it up in `passBins`, which holds hard-bin numbers: soft bin
+  1 sorted as a pass and soft bin 100 as a fail whatever their dies did, and the gallery strip's
+  Yield read about 0% in soft-bin mode for any program whose passing soft bins are numbered
+  differently. They now use the soft bin's own verdict (`BinColors.pass.soft`).
+- **A gallery card had no title unless the host passed `label`, and every other surface named
+  that wafer differently.** Without `label` the card header was blank, so an engineer could not
+  tell which wafer a card showed. The findings list, the lot report, the yield list and the die
+  list's Wafer column called it `W3`, a position that reads like a wafer ID and need not match
+  the real one; a detached window called it "Wafer map"; and the Insights tab used the wafer ID.
+  The wafer ID was on every item. One internal rule, `waferDisplayLabel` (`core/waferLabel.ts`),
+  now names a wafer everywhere: the host's `label`, else `wafer.metadata.waferId`, else
+  "Wafer 3 (no ID)". Hosts that pass `label` see no change.
+- **The gallery's Legend style menu offered per-card legend positions as if they applied to
+  a legend nobody could see.** Per-card legends are off by default in `renderWaferGallery`
+  (the lot legend strip stands in for them), yet the menu listed the six positions first,
+  live, with **Default (right)** ticked, and the **Legend on each map** toggle last. It read
+  as though the positions moved the lot strip. The toggle now comes first, and the positions
+  follow under **Position on each map**, greyed and unticked, with the reason as a tooltip,
+  until per-card legends are on. The single-map menu, which has no toggle, is unchanged.
+  The rule is in `makeLegendStyleBtn` (`toolbar.ts`).
+
+### Changed
+
+- **Segments of the gallery legend's population bar are now separated by a 1px gap.**
+  Segments are ordered by die count, so any two palette colours can sit side by side, and at
+  8px tall the darker ones (black, indigo, dark teal, brown) and the pass greens ran together,
+  so the bar read as fewer, wider bins than it held. The gap is transparent, so
+  it shows the strip's own background in either theme, and it adds to each segment's 2px
+  minimum width rather than eating into it.
+
+### Deprecated
+
+- **`valueToViridis`, `valueToGreyscale` and `getValueColorScheme`**, to be removed in
+  0.31.0. Each still works, logs one console notice on first use, and is struck
+  through in editors. Use `resolveValueColorFn(name, reversed)` instead:
+  `resolveValueColorFn('default')` and `resolveValueColorFn('greyscale')` return exactly the
+  colours the first two did. None of the three applies `reverseValueScheme`, so a legend, chart
+  or export built on them could show a reading in a different colour from the map.
+  `listValueColorSchemes()` gives scheme names and labels.
+- **The chart-data builders**, to be removed in 0.31.0: `buildYieldData`,
+  `buildYieldDataCombined`, `buildBinParetoData`, `buildBinClusterData`, `buildCapabilityData`,
+  `buildTestBoxplotData`, `buildTestTrendData`, `trendCentre`, `buildTestPassRateData`,
+  `hasJudgeableTests`, `buildTestHistogramData`, `buildTestHistogramSeries`,
+  `buildCorrelationMatrix`, `filterCorrelationMatrix`, `buildScatterData` and
+  `buildScatterDataGrouped`. They were made public so a host could draw the Insights charts
+  itself, before the Insights tab (`insights: { enabled: true }`) drew them; neither tsmap nor
+  any example calls them. Each still works and logs one console notice on first use. There is
+  no replacement: if you depend on one, say so at https://github.com/wafertools/wafermap/issues. Their types stay until the
+  functions go. `buildFacetTable`, `facetValueOf` and `mergeTestDefs` are not
+  deprecated.
+- **The low-level drawing pipeline**, to be removed in 0.31.0: `buildView`, `toCanvas`, `createWafer`,
+  `generateDies`, `clipDiesToWafer`, `applyOrientation`, `transformDies`, `applyProbeSequence`,
+  `generateReticleGrid`, `mapDataToDies`, `isInsideWafer`, `getReticleCell`, `resolveGridPitch`,
+  `classifyDie`, `getRingLabel`, `aggregateValues`, `aggregateBinCounts`, `getUniqueBins`,
+  `buildHoverText`, `buildMapTitle` and the eight `affine*` helpers. It let a host draw a map without
+  `renderWaferMap`; nothing known does — tsmap draws every map through the renderers — and only the
+  pipeline example used it, which is removed. The types only the pipeline needs (`ViewOptions`,
+  `ToCanvasOptions` and the rest) go with it.
+- **Helpers exported by accident**, to be removed in 0.31.0: the region builders (`buildRingRegions`,
+  `buildQuadrantRegions`, `buildSectorRegions`, `buildReticlePositionRegions`, `buildTestSiteRegions`,
+  `buildRegionYieldData`, `areQuadrantsAdjacent`, `parseRegionKey`, `sectorCompassNames`),
+  `classifyPattern`, `visibleFindings`, `computeFunctionalYield`, `resolveMetadataColumns`,
+  `discoverDieMetadataKeys`, the report builders (`renderSummaryReportHtml`,
+  `renderLotSummaryReportHtml`, `renderFindingsReportHtml`, `openHtmlReport`, `openReportModal`),
+  `resolveBinColors`, `getBinColorScheme`, `contrastTextColor`, `getDieTestValue`, `dieHasTestData`,
+  `isParametricTest`, `isPositionedDie`, `metadataDisplayValue`, `metadataCategoricalValue`,
+  `buildDieListSection`, `DEFAULT_FACET_CURATION` and `STANDARD_WAFER_DIAMETERS_MM`. The library
+  applies each itself. Staying, because each carries a rule or a hook a host needs: `getDieKey`,
+  `getTestPassStatus`, `diePassStatus`, `isYieldEligibleDie`, `hasPosition`, `filterFindings`,
+  `resolveValueColorFn`, `FACET_NONE_VALUE`, `setReportOpener` and `setDetachWindowOpener`. The two
+  constants cannot log a notice; the functions do.
+- **The 0.31.0 removal is enforced**, not just announced: a test fails once the changelog or
+  `package.json` reaches 0.31.0 while any of these exports is still there.
+
+### Docs
+
+- **New example, "Bin colours across a full program"** (`docs/examples/bin-colours.html`).
+  A four-wafer gallery over a new generated dataset, `showcase-bin-rich`: 15 hard bins with two
+  pass grades and gaps in the numbering, and 32 soft bins numbered under their hard bin. Each
+  failure mode has its own spatial pattern. Every other bundled dataset has 2–6 bins, which is
+  too few to show how bin colour behaves across a real program. The soft bins deliberately
+  outnumber the palette, so the example also shows the `bin-colors-shared` warning. The data
+  comes from `scripts/gen-showcase-csvs.mjs` like the other showcase files.
+
+### Internal
+
+- **CI runs once per push to `main`, not twice.** `ci.yml` had its own `push` trigger while
+  `deploy.yml`, which also runs on every push, calls it as its gating job, so the same suite
+  ran twice in parallel on each commit. `ci.yml` now triggers only on pull requests (and as
+  a reusable workflow). `deploy.yml` is therefore the only thing testing pushes to `main`,
+  and says so. The README badge now points at `deploy.yml`.
+- **The perf suite's ratio tests use the fastest of N runs instead of the median**
+  (`fastest()` in `tests/perf.test.mjs`). The two paths in a ratio are timed one after the
+  other, so background load inflated them unequally. The value-vs-hardBin check failed an
+  `npm publish` at 2.86× on a loaded machine where both paths had slowed about 7×. Absolute
+  budget tests keep the median, where a minimum would weaken the guard. The value-mode limit
+  stays at 2.5×: measured, the steadier statistic does not buy back enough headroom under
+  CPU saturation to tighten it.
+
 ## [0.29.0] — 2026-09-12
 
 ### Breaking

package/README.md

@@ -2,10 +2,10 @@
 
 <img src="docs/images/wafermap-readme-header-256.png" width="64" height="64" alt="wafermap icon">
 
-[![CI](https://github.com/wafertools/wafermap/actions/workflows/ci.yml/badge.svg)](https://github.com/wafertools/wafermap/actions/workflows/ci.yml)
+[![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-~46%20kB-blue)
+![bundle](https://img.shields.io/badge/data%20layer%20min%2Bgz-~53%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 ~46 kB
+Svelte, Vue, plain HTML, or a Web Worker. The DOM-free data-and-stats layer is ~53 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).
 
@@ -72,13 +72,13 @@ 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 **14** of its ~100 exports. Read the
+application built on this library, imports **15** 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.
 
-Note the two import paths. The renderers (`renderWaferMap`, `renderWaferGallery`,
-`toCanvas`) live **only** at `@wafertools/wafermap/render`, so importing them from the
+Note the two import paths. The renderers (`renderWaferMap`,
+`renderWaferGallery`) live **only** at `@wafertools/wafermap/render`, so importing them from the
 root package will fail. That keeps the root entry DOM-free — usable in Node for a
 build-and-analyse pipeline, and tree-shakeable when you only need the geometry, data
 and stats layers.

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

@@ -1 +1 @@
-import{SPACE as et,fontPx as nt,FONT as ot,CLR as lt}from"../toolbar.js";import{cardShell as it,formatValue as rt,observeResize as st,makeTooltip as ct,positionChartTooltip as at,makeBackButton as ft,makeSegmented as ht,growCardToFitContent as dt,resolveChartCanvasColors as ut,PADDING as f,VALUE_WIDTH as j,prepareCanvas as xt}from"./chartShell.js";const h=24,x=5,mt=15,z=110,bt=12;export function renderBarPanel(i,N){const{barColor:_,valueLabel:P}=i;let b=i.title,l=i.data;const{card:r,heading:R,controlsRow:G,body:A}=it(b,N,i.ownerDocument);if(i.selfControl){const e=i.selfControl;G.appendChild(ht(e.options,e.current,n=>U(n),r.ownerDocument))}const{drill:d}=i;let y=!1,B=null;const L=r.ownerDocument.createElement("div");Object.assign(L.style,{color:lt.label,fontSize:ot.body,marginBottom:et.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?mt:0,E=()=>f*2+v()+Math.min(l.length,bt)*(h+x);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=ct(r);let m=-1,M=Math.max(1,...l.map(e=>e.value));const I=e=>P?P(e):`${rt(e.value)} (${e.percent.toFixed(1)}%)`;function Y(e){const n=f+v()+e*(h+x),o=f+z,t=a.clientWidth-o-j-f;return{y:n,barX:o,barMaxWidth:Math.max(10,t)}}function p(){w.style.maxHeight=`${E()}px`,dt(r,A,E());const e=w.clientWidth,n=f*2+v()+l.length*(h+x),o=xt(a,r,e,n);if(!o)return;const{ctx:t}=o;t.font=`${nt(-1)}px system-ui, sans-serif`,t.textBaseline="middle";const s=ut(r);l.forEach((c,C)=>{const{y:u,barX:T,barMaxWidth:W}=Y(C);C===m&&(t.fillStyle=s.bgHover,t.fillRect(0,u-x/2,e,h+x)),t.fillStyle=s.text,t.textAlign="right";const S=c.label.length>16?`${c.label.slice(0,15)}\u2026`:c.label;t.fillText(S,f+z-8,u+h/2),t.fillStyle=s.track,t.fillRect(T,u,W,h);const $=Math.max(1,c.value/M*W);t.fillStyle=_?_(c,C):s.text,t.fillRect(T,u,$,h),t.fillStyle=s.text,t.textAlign="right",t.fillText(I(c),T+W+j,u+h/2)});const g=i.reference?.(l);if(g&&l.length){const{barX:c,barMaxWidth:C}=Y(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+x)-x,S=(Q,Z,tt)=>{t.save(),t.strokeStyle=Q,t.lineWidth=Z,t.setLineDash(tt),t.beginPath(),t.moveTo(u,T),t.lineTo(u,W),t.stroke(),t.restore()};S(s.bg,3.5,[]),S(s.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(g.label).width+$*2,X=13,V=f+v()-X-1;let H=u-O/2;H=Math.max(c,Math.min(H,c+C-O)),t.fillStyle=s.bg,t.strokeStyle=s.border,t.lineWidth=1,t.beginPath(),t.rect(H,V,O,X),t.fill(),t.stroke(),t.fillStyle=s.text,t.fillText(g.label,H+$,V+X/2+.5),t.restore()}}function U(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)),m=-1,n.title&&(b=n.title,R.textContent=b),D(),p()}function q(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)),m=-1,y||(y=!0,B=ft(()=>J(),r.ownerDocument),G.appendChild(B)),D(),p()}function J(){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)),m=-1,y=!1,B?.remove(),B=null,D(),p()}function F(e){const n=Math.floor((e-f+x/2)/(h+x));return n>=0&&n<l.length?n:-1}a.addEventListener("mousemove",e=>{const n=a.getBoundingClientRect(),o=F(e.clientY-n.top),t=o>=0&&d&&!y&&l[o].itemCount>1,s=o>=0&&(t||!!i.onOpen&&o>=0&&!t);if(o!==m&&(m=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>${I(g)}${c}`,k.style.display="block",at(k,r,e.clientX,e.clientY)}else k.style.display="none"}),a.addEventListener("mouseleave",()=>{m!==-1&&(m=-1,p()),k.style.display="none"}),a.addEventListener("click",e=>{const n=a.getBoundingClientRect(),o=F(e.clientY-n.top);if(o===-1)return;const t=l[o];if(d&&!y&&t.itemCount>1){q(t);return}i.onOpen?.(t)});const K=st(r,()=>p());return p(),{card:r,destroy:()=>K.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 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()}}

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

@@ -1 +1 @@
-import{buildBinClusterData as x}from"../../stats/binPareto.js";import{SPACE as T,FONT as w,CLR as E}from"../toolbar.js";import{cardShell as H,makeTooltip as L,makeSegmented as $,renderEmptyState as D}from"./chartShell.js";import{renderGroupedBarPlot as I}from"./groupedBarPlot.js";const M=90,R=8;export function renderBinClusterPanel(s){const{groups:g,onSaveImage:f}=s;let n="hbin",c=s.title??"Hard bin pareto";const{card:o,heading:h,body:r,controlsRow:S}=H(c,f,s.ownerDocument);S.appendChild($([["hbin","Hard bins"],["sbin","Soft bins"]],n,e=>{n=e,c=`${n==="hbin"?"Hard":"Soft"} bin pareto`,h.textContent=c,d()},o.ownerDocument));const u=o.ownerDocument.createElement("div");u.textContent="One cluster per bin \xB7 a sub-bar per group",Object.assign(u.style,{color:E.label,fontSize:w.body,marginBottom:T.sm}),o.insertBefore(u,r);const y=L(o);let a=null;function d(){a?.destroy(),a=null,r.innerHTML="";const e=x(g,n);if(e.bins.length===0||e.groups.length===0){D(r,"No bin data available for the current grouping.");return}const p=e.groups,b=e.bins,B=Math.max(1,...b.flatMap(t=>t.counts));a=I(o,r,y,{rows:b.map(t=>({label:t.label,bars:t.counts.map(l=>({fraction:l/B})),trailing:`${t.total}`})),groups:p,labelWidth:M,maxVisibleRows:R,tooltipHtml:(t,l)=>{const i=b[t],m=i.counts[l],C=i.total>0?m/i.total*100:0;return`<strong>${i.label}</strong> \xB7 ${p[l]}<br>${m} dies (${C.toFixed(1)}% of bin)`}})}return d(),{card:o,destroy:()=>a?.destroy()}}
+import{buildBinClusterData as H}from"../../stats/binPareto.js";import{SPACE as T,FONT as w,CLR as E}from"../toolbar.js";import{cardShell as L,makeTooltip as $,makeSegmented as D,renderEmptyState as I}from"./chartShell.js";import{renderGroupedBarPlot as M}from"./groupedBarPlot.js";import{escHtml as g}from"../../core/utils.js";const R=90,_=8;export function renderBinClusterPanel(s){const{groups:f,onSaveImage:h}=s;let n="hbin",c=s.title??"Hard bin pareto";const{card:o,heading:S,body:r,controlsRow:y}=L(c,h,s.ownerDocument);y.appendChild(D([["hbin","Hard bins"],["sbin","Soft bins"]],n,e=>{n=e,c=`${n==="hbin"?"Hard":"Soft"} bin pareto`,S.textContent=c,m()},o.ownerDocument));const u=o.ownerDocument.createElement("div");u.textContent="One cluster per bin \xB7 a sub-bar per group",Object.assign(u.style,{color:E.label,fontSize:w.body,marginBottom:T.sm}),o.insertBefore(u,r);const B=$(o);let l=null;function m(){l?.destroy(),l=null,r.innerHTML="";const e=H(f,n);if(e.bins.length===0||e.groups.length===0){I(r,"No bin data available for the current grouping.");return}const p=e.groups,b=e.bins,C=Math.max(1,...b.flatMap(t=>t.counts));l=M(o,r,B,{rows:b.map(t=>({label:t.label,bars:t.counts.map(a=>({fraction:a/C})),trailing:`${t.total}`})),groups:p,labelWidth:R,maxVisibleRows:_,tooltipHtml:(t,a)=>{const i=b[t],d=i.counts[a],x=i.total>0?d/i.total*100:0;return`<strong>${g(i.label)}</strong> \xB7 ${g(String(p[a]))}<br>${d} dies (${x.toFixed(1)}% of bin)`}})}return m(),{card:o,destroy:()=>l?.destroy()}}